boost/filesystem/path.hpp
// 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_FILESYSTEM_PATH_HPP #define BOOST_FILESYSTEM_PATH_HPP #include <boost/filesystem/config.hpp> #include <boost/system/system_error.hpp> #include <boost/iterator/iterator_facade.hpp> #include <boost/throw_exception.hpp> #include <boost/shared_ptr.hpp> #include <boost/type_traits/is_same.hpp> #include <boost/static_assert.hpp> #include <string> #include <algorithm> // for lexicographical_compare #include <iosfwd> // needed by basic_path inserter and extractor #include <stdexcept> #include <cassert> # ifndef BOOST_FILESYSTEM_NARROW_ONLY # include <locale> # endif #include <boost/config/abi_prefix.hpp> // must be the last #include //----------------------------------------------------------------------------// namespace boost { namespace BOOST_FILESYSTEM_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_FILESYSTEM_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_FILESYSTEM_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_FILESYSTEM_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_FILESYSTEM_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_FILESYSTEM_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_FILESYSTEM_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_FILESYSTEM_NAMESPACE::detail::iterator_helper<path_type>; void increment() { boost::BOOST_FILESYSTEM_NAMESPACE::detail::iterator_helper<path_type>::do_increment( *this ); } void decrement() { boost::BOOST_FILESYSTEM_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_FILESYSTEM_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 string compare rather than !(lhs < rhs) && !(rhs < lhs) because // the result is the same yet the direct string compare is much more efficient that // lexicographical_compare, and lexicographical_compare used twice at that. template< class String, class Traits > inline bool operator==( const basic_path<String, Traits> & lhs, const basic_path<String, Traits> & rhs ) { return lhs.string() == rhs.string(); } 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.string(); } 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.string(); } 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.string() == 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.string() == rhs; } 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; is >> str; 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; is >> str; 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_FILESYSTEM_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_FILESYSTEM_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_FILESYSTEM_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_FILESYSTEM_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_FILESYSTEM_NAMESPACE::basic_path<String, Traits> path_type; 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; 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 ) { 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_FILESYSTEM_NAMESPACE } // namespace boost #include <boost/config/abi_suffix.hpp> // pops abi_prefix.hpp pragmas #endif // BOOST_FILESYSTEM_PATH_HPP