anulax
/
glm
1
0
Fork 0
Code Issues Pull Requests Packages project_board Releases Wiki Activity
OpenGL Mathematics (GLM)
You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and dots ('.'), can be up to 35 characters long. Letters must be lowercase.
1096 Commits
1 Branch
0 Tags
73 MiB
 
 
 
Tag: Branch: Tree: c3b722a733
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from "c3b722a733"
${ noResults }
glm/test/external/boost/filesystem/v2/path.hpp

1571 lines
55 KiB
Raw Blame History

// boost/filesystem/path.hpp -----------------------------------------------//
// Copyright Beman Dawes 2002-2005
// Copyright Vladimir Prus 2002
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
// See library home page at http://www.boost.org/libs/filesystem
// basic_path's stem(), extension(), and replace_extension() are based on
// basename(), extension(), and change_extension() from the original
// filesystem/convenience.hpp header by Vladimir Prus.
//----------------------------------------------------------------------------//
#ifndef BOOST_FILESYSTEM2_PATH_HPP
#define BOOST_FILESYSTEM2_PATH_HPP
#include <boost/filesystem/v2/config.hpp>
#include <boost/system/system_error.hpp>
#include <boost/iterator/iterator_facade.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/static_assert.hpp>
#include <boost/assert.hpp>
#include <string>
#include <algorithm> // for lexicographical_compare
#include <iosfwd> // needed by basic_path inserter and extractor
#include <stdexcept>
# ifndef BOOST_FILESYSTEM2_NARROW_ONLY
# include <locale>
# endif
#include <boost/config/abi_prefix.hpp> // must be the last #include
namespace boost
{
namespace BOOST_FILESYSTEM2_NAMESPACE
{
template<class String, class Traits> class basic_path;
struct path_traits;
typedef basic_path< std::string, path_traits > path;
struct path_traits
{
typedef std::string internal_string_type;
typedef std::string external_string_type;
static external_string_type to_external( const path &,
const internal_string_type & src ) { return src; }
static internal_string_type to_internal(
const external_string_type & src ) { return src; }
};
# ifndef BOOST_FILESYSTEM2_NARROW_ONLY
struct BOOST_FILESYSTEM_DECL wpath_traits;
typedef basic_path< std::wstring, wpath_traits > wpath;
struct BOOST_FILESYSTEM_DECL wpath_traits
{
typedef std::wstring internal_string_type;
# ifdef BOOST_WINDOWS_API
typedef std::wstring external_string_type;
static external_string_type to_external( const wpath &,
const internal_string_type & src ) { return src; }
static internal_string_type to_internal(
const external_string_type & src ) { return src; }
# else
typedef std::string external_string_type;
static external_string_type to_external( const wpath & ph,
const internal_string_type & src );
static internal_string_type to_internal(
const external_string_type & src );
# endif
static void imbue( const std::locale & loc );
static bool imbue( const std::locale & loc, const std::nothrow_t & );
};
# endif // ifndef BOOST_FILESYSTEM2_NARROW_ONLY
// path traits ---------------------------------------------------------//
template<class Path> struct is_basic_path
{ BOOST_STATIC_CONSTANT( bool, value = false ); };
template<> struct is_basic_path<path>
{ BOOST_STATIC_CONSTANT( bool, value = true ); };
# ifndef BOOST_FILESYSTEM2_NARROW_ONLY
template<> struct is_basic_path<wpath>
{ BOOST_STATIC_CONSTANT( bool, value = true ); };
# endif
// These only have to be specialized if Path::string_type::value_type
// is not convertible from char, although specializations may eliminate
// compiler warnings. See ticket 2543.
template<class Path> struct slash
{ BOOST_STATIC_CONSTANT( char, value = '/' ); };
template<class Path> struct dot
{ BOOST_STATIC_CONSTANT( char, value = '.' ); };
template<class Path> struct colon
{ BOOST_STATIC_CONSTANT( char, value = ':' ); };
# ifndef BOOST_FILESYSTEM2_NARROW_ONLY
template<> struct slash<wpath>
{ BOOST_STATIC_CONSTANT( wchar_t, value = L'/' ); };
template<> struct dot<wpath>
{ BOOST_STATIC_CONSTANT( wchar_t, value = L'.' ); };
template<> struct colon<wpath>
{ BOOST_STATIC_CONSTANT( wchar_t, value = L':' ); };
# endif
# ifdef BOOST_WINDOWS_PATH
template<class Path> struct path_alt_separator
{ BOOST_STATIC_CONSTANT( char, value = '\\' ); };
# ifndef BOOST_FILESYSTEM2_NARROW_ONLY
template<> struct path_alt_separator<wpath>
{ BOOST_STATIC_CONSTANT( wchar_t, value = L'\\' ); };
# endif
# endif
// workaround for VC++ 7.0 and earlier issues with nested classes
namespace detail
{
template<class Path>
class iterator_helper
{
public:
typedef typename Path::iterator iterator;
static void do_increment( iterator & ph );
static void do_decrement( iterator & ph );
};
}
// basic_path ----------------------------------------------------------//
template<class String, class Traits>
class basic_path
{
// invariant: m_path valid according to the portable generic path grammar
// validate template arguments
// TODO: get these working
// BOOST_STATIC_ASSERT( ::boost::is_same<String,typename Traits::internal_string_type>::value );
// BOOST_STATIC_ASSERT( ::boost::is_same<typename Traits::external_string_type,std::string>::value || ::boost::is_same<typename Traits::external_string_type,std::wstring>::value );
public:
// compiler generates copy constructor and copy assignment
typedef basic_path<String, Traits> path_type;
typedef String string_type;
typedef typename String::value_type value_type;
typedef Traits traits_type;
typedef typename Traits::external_string_type external_string_type;
// constructors/destructor
basic_path() {}
basic_path( const string_type & s ) { operator/=( s ); }
basic_path( const value_type * s ) { operator/=( s ); }
# ifndef BOOST_NO_MEMBER_TEMPLATES
template <class InputIterator>
basic_path( InputIterator first, InputIterator last )
{ append( first, last ); }
# endif
~basic_path() {}
// assignments
basic_path & operator=( const string_type & s )
{
# if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, >= 310)
m_path.clear();
# else
m_path.erase( m_path.begin(), m_path.end() );
# endif
operator/=( s );
return *this;
}
basic_path & operator=( const value_type * s )
{
# if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, >= 310)
m_path.clear();
# else
m_path.erase( m_path.begin(), m_path.end() );
# endif
operator/=( s );
return *this;
}
# ifndef BOOST_NO_MEMBER_TEMPLATES
template <class InputIterator>
basic_path & assign( InputIterator first, InputIterator last )
{ m_path.clear(); append( first, last ); return *this; }
# endif
// modifiers
basic_path & operator/=( const basic_path & rhs ) { return operator /=( rhs.string().c_str() ); }
basic_path & operator/=( const string_type & rhs ) { return operator /=( rhs.c_str() ); }
basic_path & operator/=( const value_type * s );
# ifndef BOOST_NO_MEMBER_TEMPLATES
template <class InputIterator>
basic_path & append( InputIterator first, InputIterator last );
# endif
void clear()
{
# if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, >= 310)
m_path.clear();
# else
m_path.erase( m_path.begin(), m_path.end() );
# endif
}
void swap( basic_path & rhs )
{
m_path.swap( rhs.m_path );
# ifdef BOOST_CYGWIN_PATH
std::swap( m_cygwin_root, rhs.m_cygwin_root );
# endif
}
basic_path & remove_filename();
basic_path & replace_extension( const string_type & new_extension = string_type() );
# ifndef BOOST_FILESYSTEM_NO_DEPRECATED
basic_path & remove_leaf() { return remove_filename(); }
# endif
// observers
const string_type & string() const { return m_path; }
const string_type file_string() const;
const string_type directory_string() const { return file_string(); }
const external_string_type external_file_string() const { return Traits::to_external( *this, file_string() ); }
const external_string_type external_directory_string() const { return Traits::to_external( *this, directory_string() ); }
basic_path root_path() const;
string_type root_name() const;
string_type root_directory() const;
basic_path relative_path() const;
basic_path parent_path() const;
string_type filename() const;
string_type stem() const;
string_type extension() const;
# ifndef BOOST_FILESYSTEM_NO_DEPRECATED
string_type leaf() const { return filename(); }
basic_path branch_path() const { return parent_path(); }
bool has_leaf() const { return !m_path.empty(); }
bool has_branch_path() const { return !parent_path().empty(); }
# endif
bool empty() const { return m_path.empty(); } // name consistent with std containers
bool is_complete() const;
bool has_root_path() const;
bool has_root_name() const;
bool has_root_directory() const;
bool has_relative_path() const { return !relative_path().empty(); }
bool has_filename() const { return !m_path.empty(); }
bool has_parent_path() const { return !parent_path().empty(); }
// iterators
class iterator : public boost::iterator_facade<
iterator,
string_type const,
boost::bidirectional_traversal_tag >
{
private:
friend class boost::iterator_core_access;
friend class boost::BOOST_FILESYSTEM2_NAMESPACE::basic_path<String, Traits>;
const string_type & dereference() const
{ return m_name; }
bool equal( const iterator & rhs ) const
{ return m_path_ptr == rhs.m_path_ptr && m_pos == rhs.m_pos; }
friend class boost::BOOST_FILESYSTEM2_NAMESPACE::detail::iterator_helper<path_type>;
void increment()
{
boost::BOOST_FILESYSTEM2_NAMESPACE::detail::iterator_helper<path_type>::do_increment(
*this );
}
void decrement()
{
boost::BOOST_FILESYSTEM2_NAMESPACE::detail::iterator_helper<path_type>::do_decrement(
*this );
}
string_type m_name; // current element
const basic_path * m_path_ptr; // path being iterated over
typename string_type::size_type m_pos; // position of name in
// path_ptr->string(). The
// end() iterator is indicated by
// pos == path_ptr->m_path.size()
}; // iterator
typedef iterator const_iterator;
iterator begin() const;
iterator end() const;
private:
// Note: This is an implementation for POSIX and Windows, where there
// are only minor differences between generic and native path grammars.
// Private members might be quite different in other implementations,
// particularly where there were wide differences between portable and
// native path formats, or between file_string() and
// directory_string() formats, or simply that the implementation
// was willing expend additional memory to achieve greater speed for
// some operations at the expense of other operations.
string_type m_path; // invariant: portable path grammar
// on Windows, backslashes converted to slashes
# ifdef BOOST_CYGWIN_PATH
bool m_cygwin_root; // if present, m_path[0] was slash. note: initialization
// done by append
# endif
void m_append_separator_if_needed();
void m_append( value_type value ); // converts Windows alt_separator
// Was qualified; como433beta8 reports:
// warning #427-D: qualified name is not allowed in member declaration
friend class iterator;
friend class boost::BOOST_FILESYSTEM2_NAMESPACE::detail::iterator_helper<path_type>;
// Deprecated features ease transition for existing code. Don't use these
// in new code.
# ifndef BOOST_FILESYSTEM_NO_DEPRECATED
public:
typedef bool (*name_check)( const std::string & name );
basic_path( const string_type & str, name_check ) { operator/=( str ); }
basic_path( const typename string_type::value_type * s, name_check )
{ operator/=( s );}
string_type native_file_string() const { return file_string(); }
string_type native_directory_string() const { return directory_string(); }
static bool default_name_check_writable() { return false; }
static void default_name_check( name_check ) {}
static name_check default_name_check() { return 0; }
basic_path & canonize();
basic_path & normalize();
# endif
};
// basic_path non-member functions ---------------------------------------//
template< class String, class Traits >
inline void swap( basic_path<String, Traits> & lhs,
basic_path<String, Traits> & rhs ) { lhs.swap( rhs ); }
template< class String, class Traits >
bool operator<( const basic_path<String, Traits> & lhs, const basic_path<String, Traits> & rhs )
{
return std::lexicographical_compare(
lhs.begin(), lhs.end(), rhs.begin(), rhs.end() );
}
template< class String, class Traits >
bool operator<( const typename basic_path<String, Traits>::string_type::value_type * lhs,
const basic_path<String, Traits> & rhs )
{
basic_path<String, Traits> tmp( lhs );
return std::lexicographical_compare(
tmp.begin(), tmp.end(), rhs.begin(), rhs.end() );
}
template< class String, class Traits >
bool operator<( const typename basic_path<String, Traits>::string_type & lhs,
const basic_path<String, Traits> & rhs )
{
basic_path<String, Traits> tmp( lhs );
return std::lexicographical_compare(
tmp.begin(), tmp.end(), rhs.begin(), rhs.end() );
}
template< class String, class Traits >
bool operator<( const basic_path<String, Traits> & lhs,
const typename basic_path<String, Traits>::string_type::value_type * rhs )
{
basic_path<String, Traits> tmp( rhs );
return std::lexicographical_compare(
lhs.begin(), lhs.end(), tmp.begin(), tmp.end() );
}
template< class String, class Traits >
bool operator<( const basic_path<String, Traits> & lhs,
const typename basic_path<String, Traits>::string_type & rhs )
{
basic_path<String, Traits> tmp( rhs );
return std::lexicographical_compare(
lhs.begin(), lhs.end(), tmp.begin(), tmp.end() );
}
// operator == uses hand-written compare rather than !(lhs < rhs) && !(rhs < lhs)
// because the result is the same yet the direct compare is much more efficient
// than lexicographical_compare, which would also be called twice.
template< class String, class Traits >
inline bool operator==( const basic_path<String, Traits> & lhs,
const typename basic_path<String, Traits>::string_type::value_type * rhs )
{
typedef typename
boost::BOOST_FILESYSTEM2_NAMESPACE::basic_path<String, Traits> path_type;
const typename path_type::string_type::value_type * l (lhs.string().c_str());
while ( (*l == *rhs
# ifdef BOOST_WINDOWS_PATH
|| (*l == path_alt_separator<path_type>::value && *rhs == slash<path_type>::value)
|| (*l == slash<path_type>::value && *rhs == path_alt_separator<path_type>::value)
# endif
) && *l ) { ++l; ++rhs; }
return *l == *rhs
# ifdef BOOST_WINDOWS_PATH
|| (*l == path_alt_separator<path_type>::value && *rhs == slash<path_type>::value)
|| (*l == slash<path_type>::value && *rhs == path_alt_separator<path_type>::value)
# endif
;
}
template< class String, class Traits >
inline bool operator==( const basic_path<String, Traits> & lhs,
const basic_path<String, Traits> & rhs )
{
return lhs == rhs.string().c_str();
}
template< class String, class Traits >
inline bool operator==( const typename basic_path<String, Traits>::string_type::value_type * lhs,
const basic_path<String, Traits> & rhs )
{
return rhs == lhs;
}
template< class String, class Traits >
inline bool operator==( const typename basic_path<String, Traits>::string_type & lhs,
const basic_path<String, Traits> & rhs )
{
return rhs == lhs.c_str();
}
template< class String, class Traits >
inline bool operator==( const basic_path<String, Traits> & lhs,
const typename basic_path<String, Traits>::string_type & rhs )
{
return lhs == rhs.c_str();
}
template< class String, class Traits >
inline bool operator!=( const basic_path<String, Traits> & lhs,
const basic_path<String, Traits> & rhs )
{ return !(lhs == rhs); }
template< class String, class Traits >
inline bool operator!=( const typename basic_path<String,
Traits>::string_type::value_type * lhs,
const basic_path<String, Traits> & rhs )
{ return !(lhs == rhs); }
template< class String, class Traits >
inline bool operator!=( const typename basic_path<String, Traits>::string_type & lhs,
const basic_path<String, Traits> & rhs )
{ return !(lhs == rhs); }
template< class String, class Traits >
inline bool operator!=( const basic_path<String, Traits> & lhs,
const typename basic_path<String, Traits>::string_type::value_type * rhs )
{ return !(lhs == rhs); }
template< class String, class Traits >
inline bool operator!=( const basic_path<String, Traits> & lhs,
const typename basic_path<String, Traits>::string_type & rhs )
{ return !(lhs == rhs); }
template< class String, class Traits >
inline bool operator>( const basic_path<String, Traits> & lhs, const basic_path<String, Traits> & rhs ) { return rhs < lhs; }
template< class String, class Traits >
inline bool operator>( const typename basic_path<String, Traits>::string_type::value_type * lhs,
const basic_path<String, Traits> & rhs ) { return rhs < basic_path<String, Traits>(lhs); }
template< class String, class Traits >
inline bool operator>( const typename basic_path<String, Traits>::string_type & lhs,
const basic_path<String, Traits> & rhs ) { return rhs < basic_path<String, Traits>(lhs); }
template< class String, class Traits >
inline bool operator>( const basic_path<String, Traits> & lhs,
const typename basic_path<String, Traits>::string_type::value_type * rhs )
{ return basic_path<String, Traits>(rhs) < lhs; }
template< class String, class Traits >
inline bool operator>( const basic_path<String, Traits> & lhs,
const typename basic_path<String, Traits>::string_type & rhs )
{ return basic_path<String, Traits>(rhs) < lhs; }
template< class String, class Traits >
inline bool operator<=( const basic_path<String, Traits> & lhs, const basic_path<String, Traits> & rhs ) { return !(rhs < lhs); }
template< class String, class Traits >
inline bool operator<=( const typename basic_path<String, Traits>::string_type::value_type * lhs,
const basic_path<String, Traits> & rhs ) { return !(rhs < basic_path<String, Traits>(lhs)); }
template< class String, class Traits >
inline bool operator<=( const typename basic_path<String, Traits>::string_type & lhs,
const basic_path<String, Traits> & rhs ) { return !(rhs < basic_path<String, Traits>(lhs)); }
template< class String, class Traits >
inline bool operator<=( const basic_path<String, Traits> & lhs,
const typename basic_path<String, Traits>::string_type::value_type * rhs )
{ return !(basic_path<String, Traits>(rhs) < lhs); }
template< class String, class Traits >
inline bool operator<=( const basic_path<String, Traits> & lhs,
const typename basic_path<String, Traits>::string_type & rhs )
{ return !(basic_path<String, Traits>(rhs) < lhs); }
template< class String, class Traits >
inline bool operator>=( const basic_path<String, Traits> & lhs, const basic_path<String, Traits> & rhs ) { return !(lhs < rhs); }
template< class String, class Traits >
inline bool operator>=( const typename basic_path<String, Traits>::string_type::value_type * lhs,
const basic_path<String, Traits> & rhs ) { return !(lhs < basic_path<String, Traits>(rhs)); }
template< class String, class Traits >
inline bool operator>=( const typename basic_path<String, Traits>::string_type & lhs,
const basic_path<String, Traits> & rhs ) { return !(lhs < basic_path<String, Traits>(rhs)); }
template< class String, class Traits >
inline bool operator>=( const basic_path<String, Traits> & lhs,
const typename basic_path<String, Traits>::string_type::value_type * rhs )
{ return !(basic_path<String, Traits>(lhs) < rhs); }
template< class String, class Traits >
inline bool operator>=( const basic_path<String, Traits> & lhs,
const typename basic_path<String, Traits>::string_type & rhs )
{ return !(basic_path<String, Traits>(lhs) < rhs); }
// operator /
template< class String, class Traits >
inline basic_path<String, Traits> operator/(
const basic_path<String, Traits> & lhs,
const basic_path<String, Traits> & rhs )
{ return basic_path<String, Traits>( lhs ) /= rhs; }
template< class String, class Traits >
inline basic_path<String, Traits> operator/(
const basic_path<String, Traits> & lhs,
const typename String::value_type * rhs )
{ return basic_path<String, Traits>( lhs ) /=
basic_path<String, Traits>( rhs ); }
template< class String, class Traits >
inline basic_path<String, Traits> operator/(
const basic_path<String, Traits> & lhs, const String & rhs )
{ return basic_path<String, Traits>( lhs ) /=
basic_path<String, Traits>( rhs ); }
template< class String, class Traits >
inline basic_path<String, Traits> operator/(
const typename String::value_type * lhs,
const basic_path<String, Traits> & rhs )
{ return basic_path<String, Traits>( lhs ) /= rhs; }
template< class String, class Traits >
inline basic_path<String, Traits> operator/(
const String & lhs, const basic_path<String, Traits> & rhs )
{ return basic_path<String, Traits>( lhs ) /= rhs; }
// inserters and extractors --------------------------------------------//
// bypass VC++ 7.0 and earlier, and broken Borland compilers
# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) && !BOOST_WORKAROUND(__BORLANDC__, < 0x610)
template< class Path >
std::basic_ostream< typename Path::string_type::value_type,
typename Path::string_type::traits_type > &
operator<<
( std::basic_ostream< typename Path::string_type::value_type,
typename Path::string_type::traits_type >& os, const Path & ph )
{
os << ph.string();
return os;
}
template< class Path >
std::basic_istream< typename Path::string_type::value_type,
typename Path::string_type::traits_type > &
operator>>
( std::basic_istream< typename Path::string_type::value_type,
typename Path::string_type::traits_type >& is, Path & ph )
{
typename Path::string_type str;
std::getline(is, str); // See ticket 3863
ph = str;
return is;
}
# elif BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
template< class String, class Traits >
std::basic_ostream< BOOST_DEDUCED_TYPENAME String::value_type,
BOOST_DEDUCED_TYPENAME String::traits_type > &
operator<<
( std::basic_ostream< BOOST_DEDUCED_TYPENAME String::value_type,
BOOST_DEDUCED_TYPENAME String::traits_type >& os,
const basic_path< String, Traits > & ph )
{
os << ph.string();
return os;
}
template< class String, class Traits >
std::basic_istream< BOOST_DEDUCED_TYPENAME String::value_type,
BOOST_DEDUCED_TYPENAME String::traits_type > &
operator>>
( std::basic_istream< BOOST_DEDUCED_TYPENAME String::value_type,
BOOST_DEDUCED_TYPENAME String::traits_type> & is,
basic_path< String, Traits > & ph )
{
String str;
std::getline(is, str); // See ticket 3863
ph = str;
return is;
}
# endif
// basic_filesystem_error helpers --------------------------------------//
// Originally choice of implementation was done via specialization of
// basic_filesystem_error::what(). Several compilers (GCC, aCC, etc.)
// couldn't handle that, so the choice is now accomplished by overloading.
namespace detail
{
// BOOST_FILESYSTEM_DECL version works for VC++ but not GCC. Go figure!
inline
const char * what( const char * sys_err_what,
const path & path1_arg, const path & path2_arg, std::string & target )
{
try
{
if ( target.empty() )
{
target = sys_err_what;
if ( !path1_arg.empty() )
{
target += ": \"";
target += path1_arg.file_string();
target += "\"";
}
if ( !path2_arg.empty() )
{
target += ", \"";
target += path2_arg.file_string();
target += "\"";
}
}
return target.c_str();
}
catch (...)
{
return sys_err_what;
}
}
template<class Path>
const char * what( const char * sys_err_what,
const Path & /*path1_arg*/, const Path & /*path2_arg*/, std::string & /*target*/ )
{
return sys_err_what;
}
}
// basic_filesystem_error ----------------------------------------------//
template<class Path>
class basic_filesystem_error : public system::system_error
{
// see http://www.boost.org/more/error_handling.html for design rationale
public:
// compiler generates copy constructor and copy assignment
typedef Path path_type;
basic_filesystem_error( const std::string & what_arg,
system::error_code ec );
basic_filesystem_error( const std::string & what_arg,
const path_type & path1_arg, system::error_code ec );
basic_filesystem_error( const std::string & what_arg, const path_type & path1_arg,
const path_type & path2_arg, system::error_code ec );
~basic_filesystem_error() throw() {}
const path_type & path1() const
{
static const path_type empty_path;
return m_imp_ptr.get() ? m_imp_ptr->m_path1 : empty_path ;
}
const path_type & path2() const
{
static const path_type empty_path;
return m_imp_ptr.get() ? m_imp_ptr->m_path2 : empty_path ;
}
const char * what() const throw()
{
if ( !m_imp_ptr.get() )
return system::system_error::what();
return detail::what( system::system_error::what(), m_imp_ptr->m_path1,
m_imp_ptr->m_path2, m_imp_ptr->m_what );
}
private:
struct m_imp
{
path_type m_path1; // may be empty()
path_type m_path2; // may be empty()
std::string m_what; // not built until needed
};
boost::shared_ptr<m_imp> m_imp_ptr;
};
typedef basic_filesystem_error<path> filesystem_error;
# ifndef BOOST_FILESYSTEM2_NARROW_ONLY
typedef basic_filesystem_error<wpath> wfilesystem_error;
# endif
// path::name_checks -----------------------------------------------------//
BOOST_FILESYSTEM_DECL bool portable_posix_name( const std::string & name );
BOOST_FILESYSTEM_DECL bool windows_name( const std::string & name );
BOOST_FILESYSTEM_DECL bool portable_name( const std::string & name );
BOOST_FILESYSTEM_DECL bool portable_directory_name( const std::string & name );
BOOST_FILESYSTEM_DECL bool portable_file_name( const std::string & name );
BOOST_FILESYSTEM_DECL bool native( const std::string & name );
inline bool no_check( const std::string & )
{ return true; }
// implementation -----------------------------------------------------------//
namespace detail
{
// is_separator helper ------------------------------------------------//
template<class Path>
inline bool is_separator( typename Path::string_type::value_type c )
{
return c == slash<Path>::value
# ifdef BOOST_WINDOWS_PATH
|| c == path_alt_separator<Path>::value
# endif
;
}
// filename_pos helper ----------------------------------------------------//
template<class String, class Traits>
typename String::size_type filename_pos(
const String & str, // precondition: portable generic path grammar
typename String::size_type end_pos ) // end_pos is past-the-end position
// return 0 if str itself is filename (or empty)
{
typedef typename
boost::BOOST_FILESYSTEM2_NAMESPACE::basic_path<String, Traits> path_type;
// case: "//"
if ( end_pos == 2
&& str[0] == slash<path_type>::value
&& str[1] == slash<path_type>::value ) return 0;
// case: ends in "/"
if ( end_pos && str[end_pos-1] == slash<path_type>::value )
return end_pos-1;
// set pos to start of last element
typename String::size_type pos(
str.find_last_of( slash<path_type>::value, end_pos-1 ) );
# ifdef BOOST_WINDOWS_PATH
if ( pos == String::npos )
pos = str.find_last_of( path_alt_separator<path_type>::value, end_pos-1 );
if ( pos == String::npos )
pos = str.find_last_of( colon<path_type>::value, end_pos-2 );
# endif
return ( pos == String::npos // path itself must be a filename (or empty)
|| (pos == 1 && str[0] == slash<path_type>::value) ) // or net
? 0 // so filename is entire string
: pos + 1; // or starts after delimiter
}
// first_element helper -----------------------------------------------//
// sets pos and len of first element, excluding extra separators
// if src.empty(), sets pos,len, to 0,0.
template<class String, class Traits>
void first_element(
const String & src, // precondition: portable generic path grammar
typename String::size_type & element_pos,
typename String::size_type & element_size,
# if !BOOST_WORKAROUND( BOOST_MSVC, <= 1310 ) // VC++ 7.1
typename String::size_type size = String::npos
# else
typename String::size_type size = -1
# endif
)
{
if ( size == String::npos ) size = src.size();
element_pos = 0;
element_size = 0;
if ( src.empty() ) return;
typedef typename boost::BOOST_FILESYSTEM2_NAMESPACE::basic_path<String, Traits> path_type;
typename String::size_type cur(0);
// deal with // [network]
if ( size >= 2 && src[0] == slash<path_type>::value
&& src[1] == slash<path_type>::value
&& (size == 2
|| src[2] != slash<path_type>::value) )
{
cur += 2;
element_size += 2;
}
// leading (not non-network) separator
else if ( src[0] == slash<path_type>::value )
{
++element_size;
// bypass extra leading separators
while ( cur+1 < size
&& src[cur+1] == slash<path_type>::value )
{
++cur;
++element_pos;
}
return;
}
// at this point, we have either a plain name, a network name,
// or (on Windows only) a device name
// find the end
while ( cur < size
# ifdef BOOST_WINDOWS_PATH
&& src[cur] != colon<path_type>::value
# endif
&& src[cur] != slash<path_type>::value )
{
++cur;
++element_size;
}
# ifdef BOOST_WINDOWS_PATH
if ( cur == size ) return;
// include device delimiter
if ( src[cur] == colon<path_type>::value )
{ ++element_size; }
# endif
return;
}
// root_directory_start helper ----------------------------------------//
template<class String, class Traits>
typename String::size_type root_directory_start(
const String & s, // precondition: portable generic path grammar
typename String::size_type size )
// return npos if no root_directory found
{
typedef typename boost::BOOST_FILESYSTEM2_NAMESPACE::basic_path<String, Traits> path_type;
# ifdef BOOST_WINDOWS_PATH
// case "c:/"
if ( size > 2
&& s[1] == colon<path_type>::value
&& s[2] == slash<path_type>::value ) return 2;
# endif
// case "//"
if ( size == 2
&& s[0] == slash<path_type>::value
&& s[1] == slash<path_type>::value ) return String::npos;
// case "//net {/}"
if ( size > 3
&& s[0] == slash<path_type>::value
&& s[1] == slash<path_type>::value
&& s[2] != slash<path_type>::value )
{
typename String::size_type pos(
s.find( slash<path_type>::value, 2 ) );
return pos < size ? pos : String::npos;
}
// case "/"
if ( size > 0 && s[0] == slash<path_type>::value ) return 0;
return String::npos;
}
// is_non_root_slash helper -------------------------------------------//
template<class String, class Traits>
bool is_non_root_slash( const String & str,
typename String::size_type pos ) // pos is position of the slash
{
typedef typename
boost::BOOST_FILESYSTEM2_NAMESPACE::basic_path<String, Traits>
path_type;
BOOST_ASSERT( !str.empty() && str[pos] == slash<path_type>::value
&& "precondition violation" );
// subsequent logic expects pos to be for leftmost slash of a set
while ( pos > 0 && str[pos-1] == slash<path_type>::value )
--pos;
return pos != 0
&& (pos <= 2 || str[1] != slash<path_type>::value
|| str.find( slash<path_type>::value, 2 ) != pos)
# ifdef BOOST_WINDOWS_PATH
&& (pos !=2 || str[1] != colon<path_type>::value)
# endif
;
}
} // namespace detail
// decomposition functions ----------------------------------------------//
template<class String, class Traits>
String basic_path<String, Traits>::filename() const
{
typename String::size_type end_pos(
detail::filename_pos<String, Traits>( m_path, m_path.size() ) );
return (m_path.size()
&& end_pos
&& m_path[end_pos] == slash<path_type>::value
&& detail::is_non_root_slash< String, Traits >(m_path, end_pos))
? String( 1, dot<path_type>::value )
: m_path.substr( end_pos );
}
template<class String, class Traits>
String basic_path<String, Traits>::stem() const
{
string_type name = filename();
typename string_type::size_type n = name.rfind(dot<path_type>::value);
return name.substr(0, n);
}
template<class String, class Traits>
String basic_path<String, Traits>::extension() const
{
string_type name = filename();
typename string_type::size_type n = name.rfind(dot<path_type>::value);
if (n != string_type::npos)
return name.substr(n);
else
return string_type();
}
template<class String, class Traits>
basic_path<String, Traits> basic_path<String, Traits>::parent_path() const
{
typename String::size_type end_pos(
detail::filename_pos<String, Traits>( m_path, m_path.size() ) );
bool filename_was_separator( m_path.size()
&& m_path[end_pos] == slash<path_type>::value );
// skip separators unless root directory
typename string_type::size_type root_dir_pos( detail::root_directory_start
<string_type, traits_type>( m_path, end_pos ) );
for ( ;
end_pos > 0
&& (end_pos-1) != root_dir_pos
&& m_path[end_pos-1] == slash<path_type>::value
;
--end_pos ) {}
return (end_pos == 1 && root_dir_pos == 0 && filename_was_separator)
? path_type()
: path_type( m_path.substr( 0, end_pos ) );
}
template<class String, class Traits>
basic_path<String, Traits> basic_path<String, Traits>::relative_path() const
{
iterator itr( begin() );
for ( ; itr.m_pos != m_path.size()
&& (itr.m_name[0] == slash<path_type>::value
# ifdef BOOST_WINDOWS_PATH
|| itr.m_name[itr.m_name.size()-1]
== colon<path_type>::value
# endif
); ++itr ) {}
return basic_path<String, Traits>( m_path.substr( itr.m_pos ) );
}
template<class String, class Traits>
String basic_path<String, Traits>::root_name() const
{
iterator itr( begin() );
return ( itr.m_pos != m_path.size()
&& (
( itr.m_name.size() > 1
&& itr.m_name[0] == slash<path_type>::value
&& itr.m_name[1] == slash<path_type>::value
)
# ifdef BOOST_WINDOWS_PATH
|| itr.m_name[itr.m_name.size()-1]
== colon<path_type>::value
# endif
) )
? *itr
: String();
}
template<class String, class Traits>
String basic_path<String, Traits>::root_directory() const
{
typename string_type::size_type start(
detail::root_directory_start<String, Traits>( m_path, m_path.size() ) );
return start == string_type::npos
? string_type()
: m_path.substr( start, 1 );
}
template<class String, class Traits>
basic_path<String, Traits> basic_path<String, Traits>::root_path() const
{
// even on POSIX, root_name() is non-empty() on network paths
return basic_path<String, Traits>( root_name() ) /= root_directory();
}
// path query functions -------------------------------------------------//
template<class String, class Traits>
inline bool basic_path<String, Traits>::is_complete() const
{
# ifdef BOOST_WINDOWS_PATH
return has_root_name() && has_root_directory();
# else
return has_root_directory();
# endif
}
template<class String, class Traits>
inline bool basic_path<String, Traits>::has_root_path() const
{
return !root_path().empty();
}
template<class String, class Traits>
inline bool basic_path<String, Traits>::has_root_name() const
{
return !root_name().empty();
}
template<class String, class Traits>
inline bool basic_path<String, Traits>::has_root_directory() const
{
return !root_directory().empty();
}
// append ---------------------------------------------------------------//
template<class String, class Traits>
void basic_path<String, Traits>::m_append_separator_if_needed()
// requires: !empty()
{
if (
# ifdef BOOST_WINDOWS_PATH
*(m_path.end()-1) != colon<path_type>::value &&
# endif
*(m_path.end()-1) != slash<path_type>::value )
{
m_path += slash<path_type>::value;
}
}
template<class String, class Traits>
void basic_path<String, Traits>::m_append( value_type value )
{
# ifdef BOOST_CYGWIN_PATH
if ( m_path.empty() ) m_cygwin_root = (value == slash<path_type>::value);
# endif
# ifdef BOOST_WINDOWS_PATH
// for BOOST_WINDOWS_PATH, convert alt_separator ('\') to separator ('/')
m_path += ( value == path_alt_separator<path_type>::value
? slash<path_type>::value
: value );
# else
m_path += value;
# endif
}
// except that it wouldn't work for BOOST_NO_MEMBER_TEMPLATES compilers,
// the append() member template could replace this code.
template<class String, class Traits>
basic_path<String, Traits> & basic_path<String, Traits>::operator /=
( const value_type * next_p )
{
// ignore escape sequence on POSIX or Windows
if ( *next_p == slash<path_type>::value
&& *(next_p+1) == slash<path_type>::value
&& *(next_p+2) == colon<path_type>::value ) next_p += 3;
// append slash<path_type>::value if needed
if ( !empty() && *next_p != 0
&& !detail::is_separator<path_type>( *next_p ) )
{ m_append_separator_if_needed(); }
for ( ; *next_p != 0; ++next_p ) m_append( *next_p );
return *this;
}
# ifndef BOOST_NO_MEMBER_TEMPLATES
template<class String, class Traits> template <class InputIterator>
basic_path<String, Traits> & basic_path<String, Traits>::append(
InputIterator first, InputIterator last )
{
// append slash<path_type>::value if needed
if ( !empty() && first != last
&& !detail::is_separator<path_type>( *first ) )
{ m_append_separator_if_needed(); }
// song-and-dance to avoid violating InputIterator requirements
// (which prohibit lookahead) in detecting a possible escape sequence
// (escape sequences are simply ignored on POSIX and Windows)
bool was_escape_sequence(true);
std::size_t append_count(0);
typename String::size_type initial_pos( m_path.size() );
for ( ; first != last && *first; ++first )
{
if ( append_count == 0 && *first != slash<path_type>::value )
was_escape_sequence = false;
if ( append_count == 1 && *first != slash<path_type>::value )
was_escape_sequence = false;
if ( append_count == 2 && *first != colon<path_type>::value )
was_escape_sequence = false;
m_append( *first );
++append_count;
}
// erase escape sequence if any
if ( was_escape_sequence && append_count >= 3 )
m_path.erase( initial_pos, 3 );
return *this;
}
# endif
# ifndef BOOST_FILESYSTEM_NO_DEPRECATED
// canonize ------------------------------------------------------------//
template<class String, class Traits>
basic_path<String, Traits> & basic_path<String, Traits>::canonize()
{
static const typename string_type::value_type dot_str[]
= { dot<path_type>::value, 0 };
if ( m_path.empty() ) return *this;
path_type temp;
for ( iterator itr( begin() ); itr != end(); ++itr )
{
temp /= *itr;
};
if ( temp.empty() ) temp /= dot_str;
m_path = temp.m_path;
return *this;
}
// normalize ------------------------------------------------------------//
template<class String, class Traits>
basic_path<String, Traits> & basic_path<String, Traits>::normalize()
{
static const typename string_type::value_type dot_str[]
= { dot<path_type>::value, 0 };
if ( m_path.empty() ) return *this;
path_type temp;
iterator start( begin() );
iterator last( end() );
iterator stop( last-- );
for ( iterator itr( start ); itr != stop; ++itr )
{
// ignore "." except at start and last
if ( itr->size() == 1
&& (*itr)[0] == dot<path_type>::value
&& itr != start
&& itr != last ) continue;
// ignore a name and following ".."
if ( !temp.empty()
&& itr->size() == 2
&& (*itr)[0] == dot<path_type>::value
&& (*itr)[1] == dot<path_type>::value ) // dot dot
{
string_type lf( temp.filename() );
if ( lf.size() > 0
&& (lf.size() != 1
|| (lf[0] != dot<path_type>::value
&& lf[0] != slash<path_type>::value))
&& (lf.size() != 2
|| (lf[0] != dot<path_type>::value
&& lf[1] != dot<path_type>::value
# ifdef BOOST_WINDOWS_PATH
&& lf[1] != colon<path_type>::value
# endif
)
)
)
{
temp.remove_filename();
// if not root directory, must also remove "/" if any
if ( temp.m_path.size() > 0
&& temp.m_path[temp.m_path.size()-1]
== slash<path_type>::value )
{
typename string_type::size_type rds(
detail::root_directory_start<String,Traits>( temp.m_path,
temp.m_path.size() ) );
if ( rds == string_type::npos
|| rds != temp.m_path.size()-1 )
{ temp.m_path.erase( temp.m_path.size()-1 ); }
}
iterator next( itr );
if ( temp.empty() && ++next != stop
&& next == last && *last == dot_str ) temp /= dot_str;
continue;
}
}
temp /= *itr;
};
if ( temp.empty() ) temp /= dot_str;
m_path = temp.m_path;
return *this;
}
# endif
// modifiers ------------------------------------------------------------//
template<class String, class Traits>
basic_path<String, Traits> & basic_path<String, Traits>::remove_filename()
{
m_path.erase(
detail::filename_pos<String, Traits>( m_path, m_path.size() ) );
return *this;
}
template<class String, class Traits>
basic_path<String, Traits> &
basic_path<String, Traits>::replace_extension( const string_type & new_ext )
{
// erase existing extension if any
string_type old_ext = extension();
if ( !old_ext.empty() )
m_path.erase( m_path.size() - old_ext.size() );
if ( !new_ext.empty() && new_ext[0] != dot<path_type>::value )
m_path += dot<path_type>::value;
m_path += new_ext;
return *this;
}
// path conversion functions --------------------------------------------//
template<class String, class Traits>
const String
basic_path<String, Traits>::file_string() const
{
# ifdef BOOST_WINDOWS_PATH
// for Windows, use the alternate separator, and bypass extra
// root separators
typename string_type::size_type root_dir_start(
detail::root_directory_start<String, Traits>( m_path, m_path.size() ) );
bool in_root( root_dir_start != string_type::npos );
String s;
for ( typename string_type::size_type pos( 0 );
pos != m_path.size(); ++pos )
{
// special case // [net]
if ( pos == 0 && m_path.size() > 1
&& m_path[0] == slash<path_type>::value
&& m_path[1] == slash<path_type>::value
&& ( m_path.size() == 2
|| !detail::is_separator<path_type>( m_path[2] )
) )
{
++pos;
s += path_alt_separator<path_type>::value;
s += path_alt_separator<path_type>::value;
continue;
}
// bypass extra root separators
if ( in_root )
{
if ( s.size() > 0
&& s[s.size()-1] == path_alt_separator<path_type>::value
&& m_path[pos] == slash<path_type>::value
) continue;
}
if ( m_path[pos] == slash<path_type>::value )
s += path_alt_separator<path_type>::value;
else
s += m_path[pos];
if ( pos > root_dir_start
&& m_path[pos] == slash<path_type>::value )
{ in_root = false; }
}
# ifdef BOOST_CYGWIN_PATH
if ( m_cygwin_root ) s[0] = slash<path_type>::value;
# endif
return s;
# else
return m_path;
# endif
}
// iterator functions ---------------------------------------------------//
template<class String, class Traits>
typename basic_path<String, Traits>::iterator basic_path<String, Traits>::begin() const
{
iterator itr;
itr.m_path_ptr = this;
typename string_type::size_type element_size;
detail::first_element<String, Traits>( m_path, itr.m_pos, element_size );
itr.m_name = m_path.substr( itr.m_pos, element_size );
return itr;
}
template<class String, class Traits>
typename basic_path<String, Traits>::iterator basic_path<String, Traits>::end() const
{
iterator itr;
itr.m_path_ptr = this;
itr.m_pos = m_path.size();
return itr;
}
namespace detail
{
// do_increment ------------------------------------------------------//
template<class Path>
void iterator_helper<Path>::do_increment( iterator & itr )
{
typedef typename Path::string_type string_type;
typedef typename Path::traits_type traits_type;
BOOST_ASSERT( itr.m_pos < itr.m_path_ptr->m_path.size() && "basic_path::iterator increment past end()" );
bool was_net( itr.m_name.size() > 2
&& itr.m_name[0] == slash<Path>::value
&& itr.m_name[1] == slash<Path>::value
&& itr.m_name[2] != slash<Path>::value );
// increment to position past current element
itr.m_pos += itr.m_name.size();
// if end reached, create end iterator
if ( itr.m_pos == itr.m_path_ptr->m_path.size() )
{
itr.m_name.erase( itr.m_name.begin(), itr.m_name.end() ); // VC++ 6.0 lib didn't supply clear()
return;
}
// process separator (Windows drive spec is only case not a separator)
if ( itr.m_path_ptr->m_path[itr.m_pos] == slash<Path>::value )
{
// detect root directory
if ( was_net
# ifdef BOOST_WINDOWS_PATH
// case "c:/"
|| itr.m_name[itr.m_name.size()-1] == colon<Path>::value
# endif
)
{
itr.m_name = slash<Path>::value;
return;
}
// bypass separators
while ( itr.m_pos != itr.m_path_ptr->m_path.size()
&& itr.m_path_ptr->m_path[itr.m_pos] == slash<Path>::value )
{ ++itr.m_pos; }
// detect trailing separator, and treat it as ".", per POSIX spec
if ( itr.m_pos == itr.m_path_ptr->m_path.size()
&& detail::is_non_root_slash< string_type, traits_type >(
itr.m_path_ptr->m_path, itr.m_pos-1 ) )
{
--itr.m_pos;
itr.m_name = dot<Path>::value;
return;
}
}
// get next element
typename string_type::size_type end_pos(
itr.m_path_ptr->m_path.find( slash<Path>::value, itr.m_pos ) );
itr.m_name = itr.m_path_ptr->m_path.substr( itr.m_pos, end_pos - itr.m_pos );
}
// do_decrement ------------------------------------------------------//
template<class Path>
void iterator_helper<Path>::do_decrement( iterator & itr )
{
BOOST_ASSERT( itr.m_pos && "basic_path::iterator decrement past begin()" );
typedef typename Path::string_type string_type;
typedef typename Path::traits_type traits_type;
typename string_type::size_type end_pos( itr.m_pos );
typename string_type::size_type root_dir_pos(
detail::root_directory_start<string_type, traits_type>(
itr.m_path_ptr->m_path, end_pos ) );
// if at end and there was a trailing non-root '/', return "."
if ( itr.m_pos == itr.m_path_ptr->m_path.size()
&& itr.m_path_ptr->m_path.size() > 1
&& itr.m_path_ptr->m_path[itr.m_pos-1] == slash<Path>::value
&& detail::is_non_root_slash< string_type, traits_type >(
itr.m_path_ptr->m_path, itr.m_pos-1 )
)
{
--itr.m_pos;
itr.m_name = dot<Path>::value;
return;
}
// skip separators unless root directory
for (
;
end_pos > 0
&& (end_pos-1) != root_dir_pos
&& itr.m_path_ptr->m_path[end_pos-1] == slash<Path>::value
;
--end_pos ) {}
itr.m_pos = detail::filename_pos<string_type, traits_type>
( itr.m_path_ptr->m_path, end_pos );
itr.m_name = itr.m_path_ptr->m_path.substr( itr.m_pos, end_pos - itr.m_pos );
}
} // namespace detail
// basic_filesystem_error implementation --------------------------------//
template<class Path>
basic_filesystem_error<Path>::basic_filesystem_error(
const std::string & what_arg, system::error_code ec )
: system::system_error(ec, what_arg)
{
try
{
m_imp_ptr.reset( new m_imp );
}
catch (...) { m_imp_ptr.reset(); }
}
template<class Path>
basic_filesystem_error<Path>::basic_filesystem_error(
const std::string & what_arg, const path_type & path1_arg,
system::error_code ec )
: system::system_error(ec, what_arg)
{
try
{
m_imp_ptr.reset( new m_imp );
m_imp_ptr->m_path1 = path1_arg;
}
catch (...) { m_imp_ptr.reset(); }
}
template<class Path>
basic_filesystem_error<Path>::basic_filesystem_error(
const std::string & what_arg, const path_type & path1_arg,
const path_type & path2_arg, system::error_code ec )
: system::system_error(ec, what_arg)
{
try
{
m_imp_ptr.reset( new m_imp );
m_imp_ptr->m_path1 = path1_arg;
m_imp_ptr->m_path2 = path2_arg;
}
catch (...) { m_imp_ptr.reset(); }
}
} // namespace BOOST_FILESYSTEM2_NAMESPACE
} // namespace boost
//----------------------------------------------------------------------------//
namespace boost
{
namespace filesystem
{
using filesystem2::basic_path;
using filesystem2::path_traits;
using filesystem2::slash;
using filesystem2::dot;
using filesystem2::colon;
using filesystem2::path;
# ifndef BOOST_FILESYSTEM2_NARROW_ONLY
using filesystem2::wpath_traits;
using filesystem2::wpath;
using filesystem2::wfilesystem_error;
# endif
using filesystem2::basic_filesystem_error;
using filesystem2::filesystem_error;
using filesystem2::portable_posix_name;
using filesystem2::windows_name;
using filesystem2::portable_name;
using filesystem2::portable_directory_name;
using filesystem2::portable_file_name;
using filesystem2::native;
using filesystem2::no_check;
using filesystem2::swap;
using filesystem2::operator<;
using filesystem2::operator==;
using filesystem2::operator!=;
using filesystem2::operator>;
using filesystem2::operator<=;
using filesystem2::operator>=;
using filesystem2::operator/;
using filesystem2::operator<<;
using filesystem2::operator>>;
}
}
//----------------------------------------------------------------------------//
#include <boost/config/abi_suffix.hpp> // pops abi_prefix.hpp pragmas
#endif // BOOST_FILESYSTEM2_PATH_HPP