1 //  boost/filesystem/path.hpp  -----------------------------------------------//

     2 

     3 //  Copyright Beman Dawes 2002-2005

     4 //  Use, modification, and distribution is subject to the Boost Software

     5 //  License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at

     6 //  http://www.boost.org/LICENSE_1_0.txt)

     7 

     8 //  See library home page at http://www.boost.org/libs/filesystem

     9 

    10 //----------------------------------------------------------------------------// 

    11 

    12 #ifndef BOOST_FILESYSTEM_PATH_HPP

    13 #define BOOST_FILESYSTEM_PATH_HPP

    14 

    15 #include <boost/filesystem/config.hpp>

    16 #include <boost/iterator/iterator_facade.hpp>

    17 #include <boost/throw_exception.hpp>

    18 #include <boost/shared_ptr.hpp>

    19 #include <boost/type_traits/is_same.hpp>

    20 #include <boost/static_assert.hpp>

    21 

    22 #include <string>

    23 #include <algorithm> // for lexicographical_compare

    24 #include <iosfwd>    // needed by basic_path inserter and extractor

    25 #include <stdexcept>

    26 #include <cassert>

    27 

    28 # ifndef BOOST_FILESYSTEM_NARROW_ONLY

    29 #   include <locale>

    30 # endif

    31 

    32 #include <boost/config/abi_prefix.hpp> // must be the last #include

    33 

    34 //----------------------------------------------------------------------------//

    35 

    36 namespace boost

    37 {

    38   namespace BOOST_FILESYSTEM_NAMESPACE

    39   {

    40     template<class String, class Traits> class basic_path;

    41 

    42     struct path_traits;

    43     typedef basic_path< std::string, path_traits > path;

    44 

    45     struct path_traits

    46     {

    47       typedef std::string internal_string_type;

    48       typedef std::string external_string_type;

    49       static external_string_type to_external( const path &,

    50         const internal_string_type & src ) { return src; }

    51       static internal_string_type to_internal(

    52         const external_string_type & src ) { return src; }

    53     };

    54 

    55 # ifndef BOOST_FILESYSTEM_NARROW_ONLY

    56 

    57     struct wpath_traits;

    58     

    59     typedef basic_path< std::wstring, wpath_traits > wpath;

    60 

    61     struct wpath_traits

    62     {

    63       typedef std::wstring internal_string_type;

    64 # ifdef BOOST_WINDOWS_API

    65       typedef std::wstring external_string_type;

    66       static external_string_type to_external( const wpath &,

    67         const internal_string_type & src ) { return src; }

    68       static internal_string_type to_internal(

    69         const external_string_type & src ) { return src; }

    70 # else

    71       typedef std::string external_string_type;

    72       static external_string_type to_external( const wpath & ph,

    73         const internal_string_type & src );

    74       static internal_string_type to_internal(

    75         const external_string_type & src );

    76 # endif

    77       static void imbue( const std::locale & loc );

    78       static bool imbue( const std::locale & loc, const std::nothrow_t & );

    79     };

    80 

    81 # endif // ifndef BOOST_FILESYSTEM_NARROW_ONLY

    82 

    83 //  error reporting support  -------------------------------------------------//

    84 

    85     typedef int errno_type;  // determined by C standard

    86     

    87 # ifdef BOOST_WINDOWS_API

    88     typedef unsigned system_error_type;

    89 

    90     BOOST_FILESYSTEM_DECL

    91     errno_type lookup_errno( system_error_type sys_err_code );

    92 # else

    93     typedef int system_error_type;

    94 

    95     inline errno_type lookup_errno( system_error_type sys_err_code )

    96       { return sys_err_code; }

    97 # endif

    98 

    99     // deprecated support for legacy function name

   100     inline errno_type lookup_error_code( system_error_type sys_err_code )

   101       { return lookup_errno( sys_err_code ); }

   102 

   103     BOOST_FILESYSTEM_DECL

   104     void system_message( system_error_type sys_err_code, std::string & target );

   105     // Effects: appends error message to target

   106 

   107 # if defined(BOOST_WINDOWS_API) && !defined(BOOST_FILESYSTEM_NARROW_ONLY)

   108     BOOST_FILESYSTEM_DECL void

   109     system_message( system_error_type sys_err_code, std::wstring & target );

   110 # endif

   111 

   112     //  filesystem_error  ----------------------------------------------------//

   113 

   114     class filesystem_error : public std::runtime_error

   115     // see http://www.boost.org/more/error_handling.html for design rationale

   116     {

   117     public:

   118       filesystem_error()

   119         : std::runtime_error("filesystem error"), m_sys_err(0) {}

   120       explicit filesystem_error(

   121         const std::string & what_arg, system_error_type sys_ec = 0 )

   122         : std::runtime_error(what_arg), m_sys_err(sys_ec) {}

   123 

   124       system_error_type  system_error() const { return m_sys_err; }

   125       // Note: system_error() == 0 implies a library (rather than system) error

   126 

   127     private:

   128       system_error_type m_sys_err;

   129     };

   130 

   131     //  basic_filesystem_error  ----------------------------------------------//

   132 

   133     template<class Path>

   134     class basic_filesystem_error : public filesystem_error

   135     {

   136     // see http://www.boost.org/more/error_handling.html for design rationale

   137     public:

   138       // compiler generates copy constructor and copy assignment

   139 

   140       typedef Path path_type;

   141 

   142       basic_filesystem_error( const std::string & what,

   143         system_error_type sys_err_code );

   144 

   145       basic_filesystem_error( const std::string & what,

   146         const path_type & path1, system_error_type sys_err_code );

   147 

   148       basic_filesystem_error( const std::string & what, const path_type & path1,

   149         const path_type & path2, system_error_type sys_err_code );

   150 

   151       ~basic_filesystem_error() throw() {}

   152 

   153       const path_type & path1() const

   154       {

   155         static const path_type empty_path;

   156         return m_imp_ptr.get() ? m_imp_ptr->m_path1 : empty_path ;

   157       }

   158       const path_type & path2() const

   159       {

   160         static const path_type empty_path;

   161         return m_imp_ptr.get() ? m_imp_ptr->m_path2 : empty_path ;

   162       }

   163 

   164     private:

   165       struct m_imp

   166       {

   167         path_type       m_path1; // may be empty()

   168         path_type       m_path2; // may be empty()

   169       };

   170       boost::shared_ptr<m_imp> m_imp_ptr;

   171     };

   172 

   173     typedef basic_filesystem_error<path> filesystem_path_error;

   174 

   175 # ifndef BOOST_FILESYSTEM_NARROW_ONLY

   176     typedef basic_filesystem_error<wpath> filesystem_wpath_error;

   177 # endif

   178 

   179     //  path traits  ---------------------------------------------------------//

   180 

   181     template<class Path> struct is_basic_path

   182       { BOOST_STATIC_CONSTANT( bool, value = false ); };

   183     template<> struct is_basic_path<path>

   184       { BOOST_STATIC_CONSTANT( bool, value = true ); };

   185 # ifndef BOOST_FILESYSTEM_NARROW_ONLY

   186     template<> struct is_basic_path<wpath>

   187       { BOOST_STATIC_CONSTANT( bool, value = true ); };

   188 # endif

   189 

   190     // these only have to be specialized if Path::string_type::value_type

   191     // is not convertible from char

   192     template<class Path> struct slash

   193       { BOOST_STATIC_CONSTANT( char, value = '/' ); };

   194 

   195     template<class Path> struct dot

   196       { BOOST_STATIC_CONSTANT( char, value = '.' ); };

   197 

   198     template<class Path> struct colon

   199       { BOOST_STATIC_CONSTANT( char, value = ':' ); };

   200 

   201 # ifdef BOOST_WINDOWS_PATH

   202     template<class Path> struct path_alt_separator

   203       { BOOST_STATIC_CONSTANT( char, value = '\\' ); };

   204 # endif

   205 

   206     //  workaround for VC++ 7.0 and earlier issues with nested classes

   207     namespace detail

   208     {

   209       template<class Path>

   210       class iterator_helper

   211       {

   212       public:

   213         typedef typename Path::iterator iterator;

   214         static void do_increment( iterator & ph );

   215         static void do_decrement( iterator & ph );

   216       };

   217     }

   218 

   219     //  basic_path  ----------------------------------------------------------//

   220   

   221     template<class String, class Traits>

   222     class basic_path

   223     {

   224     // invariant: m_path valid according to the portable generic path grammar

   225 

   226       // validate template arguments

   227 // TODO: get these working

   228 //      BOOST_STATIC_ASSERT( ::boost::is_same<String,typename Traits::internal_string_type>::value );

   229 //      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 );

   230 

   231     public:

   232       // compiler generates copy constructor and copy assignment

   233 

   234       typedef basic_path<String, Traits> path_type;

   235       typedef String string_type;

   236       typedef typename String::value_type value_type;

   237       typedef Traits traits_type;

   238       typedef typename Traits::external_string_type external_string_type; 

   239 

   240       // constructors/destructor

   241       basic_path() {}

   242       basic_path( const string_type & s ) { operator/=( s ); }

   243       basic_path( const value_type * s )  { operator/=( s ); }

   244 #     ifndef BOOST_NO_MEMBER_TEMPLATES

   245         template <class InputIterator>

   246           basic_path( InputIterator first, InputIterator last )

   247             { append( first, last ); }

   248 #     endif

   249      ~basic_path() {}

   250 

   251       // assignments

   252       basic_path & operator=( const string_type & s )

   253       {

   254 #     if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, >= 310)

   255         m_path.clear();

   256 #     else

   257         m_path.erase( m_path.begin(), m_path.end() );

   258 #     endif

   259         operator/=( s ); 

   260         return *this;

   261       }

   262       basic_path & operator=( const value_type * s )

   263       { 

   264 #     if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, >= 310)

   265         m_path.clear();

   266 #     else

   267         m_path.erase( m_path.begin(), m_path.end() );

   268 #     endif

   269         operator/=( s ); 

   270         return *this;

   271       }

   272 #     ifndef BOOST_NO_MEMBER_TEMPLATES

   273         template <class InputIterator>

   274           basic_path & assign( InputIterator first, InputIterator last )

   275             { m_path.clear(); append( first, last ); return *this; }

   276 #     endif

   277 

   278       // modifiers

   279       basic_path & operator/=( const basic_path & rhs )  { return operator /=( rhs.string().c_str() ); }

   280       basic_path & operator/=( const string_type & rhs ) { return operator /=( rhs.c_str() ); }

   281       basic_path & operator/=( const value_type * s );

   282 #     ifndef BOOST_NO_MEMBER_TEMPLATES

   283         template <class InputIterator>

   284           basic_path & append( InputIterator first, InputIterator last );

   285 #     endif

   286       

   287       void swap( basic_path & rhs )

   288       {

   289         m_path.swap( rhs.m_path );

   290 #       ifdef BOOST_CYGWIN_PATH

   291           std::swap( m_cygwin_root, rhs.m_cygwin_root );

   292 #       endif

   293       }

   294 

   295       basic_path & remove_leaf();

   296 

   297       // observers

   298       const string_type & string() const         { return m_path; }

   299       const string_type file_string() const;

   300       const string_type directory_string() const { return file_string(); }

   301 

   302       const external_string_type external_file_string() const { return Traits::to_external( *this, file_string() ); }

   303       const external_string_type external_directory_string() const { return Traits::to_external( *this, directory_string() ); }

   304 

   305       basic_path   root_path() const;

   306       string_type  root_name() const;

   307       string_type  root_directory() const;

   308       basic_path   relative_path() const;

   309       string_type  leaf() const;

   310       basic_path   branch_path() const;

   311 

   312       bool empty() const               { return m_path.empty(); } // name consistent with std containers

   313       bool is_complete() const;

   314       bool has_root_path() const;

   315       bool has_root_name() const;

   316       bool has_root_directory() const;

   317       bool has_relative_path() const   { return !relative_path().empty(); }

   318       bool has_leaf() const            { return !m_path.empty(); }

   319       bool has_branch_path() const     { return !branch_path().empty(); }

   320 

   321       // iterators

   322       class iterator : public boost::iterator_facade<

   323         iterator,

   324         string_type const,

   325         boost::bidirectional_traversal_tag >

   326       {

   327       private:

   328         friend class boost::iterator_core_access;

   329         friend class boost::BOOST_FILESYSTEM_NAMESPACE::basic_path<String, Traits>;

   330 

   331         const string_type & dereference() const

   332           { return m_name; }

   333         bool equal( const iterator & rhs ) const

   334           { return m_path_ptr == rhs.m_path_ptr && m_pos == rhs.m_pos; }

   335 

   336         friend class boost::BOOST_FILESYSTEM_NAMESPACE::detail::iterator_helper<path_type>;

   337 

   338         void increment()

   339         { 

   340           boost::BOOST_FILESYSTEM_NAMESPACE::detail::iterator_helper<path_type>::do_increment(

   341             *this );

   342         }

   343         void decrement()

   344         { 

   345           boost::BOOST_FILESYSTEM_NAMESPACE::detail::iterator_helper<path_type>::do_decrement(

   346             *this );

   347         }

   348 

   349         string_type             m_name;     // current element

   350         const basic_path *      m_path_ptr; // path being iterated over

   351         typename string_type::size_type  m_pos;  // position of name in

   352                                             // path_ptr->string(). The

   353                                             // end() iterator is indicated by 

   354                                             // pos == path_ptr->m_path.size()

   355       }; // iterator

   356 

   357       typedef iterator const_iterator;

   358 

   359       iterator begin() const;

   360       iterator end() const;

   361 

   362     private:

   363       // Note: This is an implementation for POSIX and Windows, where there

   364       // are only minor differences between generic and native path grammars.

   365       // Private members might be quite different in other implementations,

   366       // particularly where there were wide differences between portable and

   367       // native path formats, or between file_string() and

   368       // directory_string() formats, or simply that the implementation

   369       // was willing expend additional memory to achieve greater speed for

   370       // some operations at the expense of other operations.

   371 

   372       string_type  m_path; // invariant: portable path grammar

   373                            // on Windows, backslashes converted to slashes

   374 

   375 #   ifdef BOOST_CYGWIN_PATH

   376       bool m_cygwin_root; // if present, m_path[0] was slash. note: initialization

   377                           // done by append

   378 #   endif  

   379 

   380       void m_append_separator_if_needed();

   381       void m_append( value_type value ); // converts Windows alt_separator

   382 

   383       // Was qualified; como433beta8 reports:

   384       //    warning #427-D: qualified name is not allowed in member declaration 

   385       friend class iterator;

   386       friend class boost::BOOST_FILESYSTEM_NAMESPACE::detail::iterator_helper<path_type>;

   387 

   388       // Deprecated features ease transition for existing code. Don't use these

   389       // in new code.

   390 # ifndef BOOST_FILESYSTEM_NO_DEPRECATED

   391     public:

   392       typedef bool (*name_check)( const std::string & name );

   393       basic_path( const string_type & str, name_check ) { operator/=( str ); }

   394       basic_path( const typename string_type::value_type * s, name_check )

   395         { operator/=( s );}

   396       string_type native_file_string() const { return file_string(); }

   397       string_type native_directory_string() const { return directory_string(); }

   398       static bool default_name_check_writable() { return false; } 

   399       static void default_name_check( name_check ) {}

   400       static name_check default_name_check() { return 0; }

   401       basic_path & canonize();

   402       basic_path & normalize();

   403 # endif

   404     };

   405 

   406   //  basic_path non-member functions  ---------------------------------------//

   407 

   408     template< class String, class Traits >

   409     inline void swap( basic_path<String, Traits> & lhs,

   410                basic_path<String, Traits> & rhs ) { lhs.swap( rhs ); }

   411 

   412     template< class String, class Traits >

   413     bool operator<( const basic_path<String, Traits> & lhs, const basic_path<String, Traits> & rhs )

   414     {

   415       return std::lexicographical_compare(

   416         lhs.begin(), lhs.end(), rhs.begin(), rhs.end() );

   417     }

   418 

   419     template< class String, class Traits >

   420     bool operator<( const typename basic_path<String, Traits>::string_type::value_type * lhs,

   421                     const basic_path<String, Traits> & rhs )

   422     {

   423       basic_path<String, Traits> tmp( lhs );

   424       return std::lexicographical_compare(

   425         tmp.begin(), tmp.end(), rhs.begin(), rhs.end() );

   426     }

   427 

   428     template< class String, class Traits >

   429     bool operator<( const typename basic_path<String, Traits>::string_type & lhs,

   430                     const basic_path<String, Traits> & rhs )

   431     {

   432       basic_path<String, Traits> tmp( lhs );

   433       return std::lexicographical_compare(

   434         tmp.begin(), tmp.end(), rhs.begin(), rhs.end() );

   435     }

   436 

   437     template< class String, class Traits >

   438     bool operator<( const basic_path<String, Traits> & lhs,

   439                     const typename basic_path<String, Traits>::string_type::value_type * rhs )

   440     {

   441       basic_path<String, Traits> tmp( rhs );

   442       return std::lexicographical_compare(

   443         lhs.begin(), lhs.end(), tmp.begin(), tmp.end() );

   444     }

   445 

   446     template< class String, class Traits >

   447     bool operator<( const basic_path<String, Traits> & lhs,

   448                     const typename basic_path<String, Traits>::string_type & rhs )

   449     {

   450       basic_path<String, Traits> tmp( rhs );

   451       return std::lexicographical_compare(

   452         lhs.begin(), lhs.end(), tmp.begin(), tmp.end() );

   453     }

   454 

   455     template< class String, class Traits >

   456     inline bool operator==( const basic_path<String, Traits> & lhs, const basic_path<String, Traits> & rhs )

   457     { 

   458       return !(lhs < rhs) && !(rhs < lhs);

   459     }

   460 

   461     template< class String, class Traits >

   462     inline bool operator==( const typename basic_path<String, Traits>::string_type::value_type * lhs,

   463                     const basic_path<String, Traits> & rhs )

   464     {

   465       basic_path<String, Traits> tmp( lhs );

   466       return !(tmp < rhs) && !(rhs < tmp);

   467     }

   468 

   469     template< class String, class Traits >

   470     inline bool operator==( const typename basic_path<String, Traits>::string_type & lhs,

   471                     const basic_path<String, Traits> & rhs )

   472     {

   473       basic_path<String, Traits> tmp( lhs );

   474       return !(tmp < rhs) && !(rhs < tmp);

   475     }

   476 

   477     template< class String, class Traits >

   478     inline bool operator==( const basic_path<String, Traits> & lhs,

   479                     const typename basic_path<String, Traits>::string_type::value_type * rhs )

   480     {

   481       basic_path<String, Traits> tmp( rhs );

   482       return !(lhs < tmp) && !(tmp < lhs);

   483     }

   484 

   485     template< class String, class Traits >

   486     inline bool operator==( const basic_path<String, Traits> & lhs,

   487                     const typename basic_path<String, Traits>::string_type & rhs )

   488     {

   489       basic_path<String, Traits> tmp( rhs );

   490       return !(lhs < tmp) && !(tmp < lhs);

   491     }

   492 

   493     template< class String, class Traits >

   494     inline bool operator!=( const basic_path<String, Traits> & lhs, const basic_path<String, Traits> & rhs ) { return !(lhs == rhs); }

   495     

   496     template< class String, class Traits >

   497     inline bool operator!=( const typename basic_path<String, Traits>::string_type::value_type * lhs,

   498                     const basic_path<String, Traits> & rhs ) { return !(basic_path<String, Traits>(lhs) == rhs); }

   499 

   500     template< class String, class Traits >

   501     inline bool operator!=( const typename basic_path<String, Traits>::string_type & lhs,

   502                     const basic_path<String, Traits> & rhs ) { return !(basic_path<String, Traits>(lhs) == rhs); }

   503 

   504     template< class String, class Traits >

   505     inline bool operator!=( const basic_path<String, Traits> & lhs,

   506                     const typename basic_path<String, Traits>::string_type::value_type * rhs )

   507                     { return !(lhs == basic_path<String, Traits>(rhs)); }

   508 

   509     template< class String, class Traits >

   510     inline bool operator!=( const basic_path<String, Traits> & lhs,

   511                     const typename basic_path<String, Traits>::string_type & rhs )

   512                     { return !(lhs == basic_path<String, Traits>(rhs)); }

   513 

   514     template< class String, class Traits >

   515     inline bool operator>( const basic_path<String, Traits> & lhs, const basic_path<String, Traits> & rhs ) { return rhs < lhs; }

   516     

   517     template< class String, class Traits >

   518     inline bool operator>( const typename basic_path<String, Traits>::string_type::value_type * lhs,

   519                     const basic_path<String, Traits> & rhs ) { return rhs < basic_path<String, Traits>(lhs); }

   520 

   521     template< class String, class Traits >

   522     inline bool operator>( const typename basic_path<String, Traits>::string_type & lhs,

   523                     const basic_path<String, Traits> & rhs ) { return rhs < basic_path<String, Traits>(lhs); }

   524 

   525     template< class String, class Traits >

   526     inline bool operator>( const basic_path<String, Traits> & lhs,

   527                     const typename basic_path<String, Traits>::string_type::value_type * rhs )

   528                     { return basic_path<String, Traits>(rhs) < lhs; }

   529 

   530     template< class String, class Traits >

   531     inline bool operator>( const basic_path<String, Traits> & lhs,

   532                     const typename basic_path<String, Traits>::string_type & rhs )

   533                     { return basic_path<String, Traits>(rhs) < lhs; }

   534 

   535     template< class String, class Traits >

   536     inline bool operator<=( const basic_path<String, Traits> & lhs, const basic_path<String, Traits> & rhs ) { return !(rhs < lhs); }

   537     

   538     template< class String, class Traits >

   539     inline bool operator<=( const typename basic_path<String, Traits>::string_type::value_type * lhs,

   540                     const basic_path<String, Traits> & rhs ) { return !(rhs < basic_path<String, Traits>(lhs)); }

   541 

   542     template< class String, class Traits >

   543     inline bool operator<=( const typename basic_path<String, Traits>::string_type & lhs,

   544                     const basic_path<String, Traits> & rhs ) { return !(rhs < basic_path<String, Traits>(lhs)); }

   545 

   546     template< class String, class Traits >

   547     inline bool operator<=( const basic_path<String, Traits> & lhs,

   548                     const typename basic_path<String, Traits>::string_type::value_type * rhs )

   549                     { return !(basic_path<String, Traits>(rhs) < lhs); }

   550 

   551     template< class String, class Traits >

   552     inline bool operator<=( const basic_path<String, Traits> & lhs,

   553                     const typename basic_path<String, Traits>::string_type & rhs )

   554                     { return !(basic_path<String, Traits>(rhs) < lhs); }

   555 

   556     template< class String, class Traits >

   557     inline bool operator>=( const basic_path<String, Traits> & lhs, const basic_path<String, Traits> & rhs ) { return !(lhs < rhs); }

   558     

   559     template< class String, class Traits >

   560     inline bool operator>=( const typename basic_path<String, Traits>::string_type::value_type * lhs,

   561                     const basic_path<String, Traits> & rhs ) { return !(lhs < basic_path<String, Traits>(rhs)); }

   562 

   563     template< class String, class Traits >

   564     inline bool operator>=( const typename basic_path<String, Traits>::string_type & lhs,

   565                     const basic_path<String, Traits> & rhs ) { return !(lhs < basic_path<String, Traits>(rhs)); }

   566 

   567     template< class String, class Traits >

   568     inline bool operator>=( const basic_path<String, Traits> & lhs,

   569                     const typename basic_path<String, Traits>::string_type::value_type * rhs )

   570                     { return !(basic_path<String, Traits>(lhs) < rhs); }

   571 

   572     template< class String, class Traits >

   573     inline bool operator>=( const basic_path<String, Traits> & lhs,

   574                     const typename basic_path<String, Traits>::string_type & rhs )

   575                     { return !(basic_path<String, Traits>(lhs) < rhs); }

   576 

   577     // operator /

   578 

   579     template< class String, class Traits >

   580     inline basic_path<String, Traits> operator/( 

   581       const basic_path<String, Traits> & lhs,

   582       const basic_path<String, Traits> & rhs )

   583       { return basic_path<String, Traits>( lhs ) /= rhs; }

   584 

   585     template< class String, class Traits >

   586     inline basic_path<String, Traits> operator/( 

   587       const basic_path<String, Traits> & lhs,

   588       const typename String::value_type * rhs )

   589       { return basic_path<String, Traits>( lhs ) /=

   590           basic_path<String, Traits>( rhs ); }

   591 

   592     template< class String, class Traits >

   593     inline basic_path<String, Traits> operator/( 

   594       const basic_path<String, Traits> & lhs, const String & rhs )

   595       { return basic_path<String, Traits>( lhs ) /=

   596           basic_path<String, Traits>( rhs ); }

   597 

   598     template< class String, class Traits >

   599     inline basic_path<String, Traits> operator/( 

   600       const typename String::value_type * lhs,

   601       const basic_path<String, Traits> & rhs )

   602       { return basic_path<String, Traits>( lhs ) /= rhs; }

   603 

   604     template< class String, class Traits >

   605     inline basic_path<String, Traits> operator/(

   606       const String & lhs, const basic_path<String, Traits> & rhs )

   607       { return basic_path<String, Traits>( lhs ) /= rhs; }

   608    

   609     //  inserters and extractors  --------------------------------------------//

   610 

   611 // bypass VC++ 7.0 and earlier, and broken Borland compilers

   612 # if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) && !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))

   613     template< class Path >

   614     std::basic_ostream< typename Path::string_type::value_type,

   615       typename Path::string_type::traits_type > &

   616       operator<<

   617       ( std::basic_ostream< typename Path::string_type::value_type,

   618       typename Path::string_type::traits_type >& os, const Path & ph )

   619     {

   620       os << ph.string();

   621       return os;

   622     }

   623 

   624     template< class Path >

   625     std::basic_istream< typename Path::string_type::value_type,

   626       typename Path::string_type::traits_type > &

   627       operator>>

   628       ( std::basic_istream< typename Path::string_type::value_type,

   629       typename Path::string_type::traits_type >& is, Path & ph )

   630     {

   631       typename Path::string_type str;

   632       is >> str;

   633       ph = str;

   634       return is;

   635     }

   636 # elif BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))

   637     template< class String, class Traits >

   638     std::basic_ostream< BOOST_DEDUCED_TYPENAME String::value_type,

   639       BOOST_DEDUCED_TYPENAME String::traits_type > &

   640       operator<<

   641       ( std::basic_ostream< BOOST_DEDUCED_TYPENAME String::value_type,

   642           BOOST_DEDUCED_TYPENAME String::traits_type >& os, 

   643         const basic_path< String, Traits > & ph )

   644     {

   645       os << ph.string();

   646       return os;

   647     }

   648 

   649     template< class String, class Traits >

   650     std::basic_istream< BOOST_DEDUCED_TYPENAME String::value_type, 

   651       BOOST_DEDUCED_TYPENAME String::traits_type > &

   652       operator>>

   653       ( std::basic_istream< BOOST_DEDUCED_TYPENAME String::value_type,

   654           BOOST_DEDUCED_TYPENAME String::traits_type> & is,

   655         basic_path< String, Traits > & ph )

   656     {

   657       String str;

   658       is >> str;

   659       ph = str;

   660       return is;

   661     }

   662 # endif

   663 

   664   //  path::name_checks  -----------------------------------------------------//

   665 

   666     BOOST_FILESYSTEM_DECL bool portable_posix_name( const std::string & name );

   667     BOOST_FILESYSTEM_DECL bool windows_name( const std::string & name );

   668     BOOST_FILESYSTEM_DECL bool portable_name( const std::string & name );

   669     BOOST_FILESYSTEM_DECL bool portable_directory_name( const std::string & name );

   670     BOOST_FILESYSTEM_DECL bool portable_file_name( const std::string & name );

   671     BOOST_FILESYSTEM_DECL bool native( const std::string & name );

   672     inline bool no_check( const std::string & )

   673       { return true; }

   674 

   675 // implementation  -----------------------------------------------------------//

   676 

   677     namespace detail

   678     {

   679 

   680       //  is_separator helper ------------------------------------------------//

   681 

   682       template<class Path>

   683       inline  bool is_separator( typename Path::string_type::value_type c )

   684       {

   685         return c == slash<Path>::value

   686 #     ifdef BOOST_WINDOWS_PATH

   687           || c == path_alt_separator<Path>::value

   688 #     endif

   689           ;

   690       }

   691 

   692       // leaf_pos helper  ----------------------------------------------------//

   693 

   694       template<class String, class Traits>

   695       typename String::size_type leaf_pos(

   696         const String & str, // precondition: portable generic path grammar

   697         typename String::size_type end_pos ) // end_pos is past-the-end position

   698       // return 0 if str itself is leaf (or empty)

   699       {

   700         typedef typename

   701           boost::BOOST_FILESYSTEM_NAMESPACE::basic_path<String, Traits> path_type;

   702 

   703         // case: "//"

   704         if ( end_pos == 2 

   705           && str[0] == slash<path_type>::value

   706           && str[1] == slash<path_type>::value ) return 0;

   707 

   708         // case: ends in "/"

   709         if ( end_pos && str[end_pos-1] == slash<path_type>::value )

   710           return end_pos-1;

   711         

   712         // set pos to start of last element

   713         typename String::size_type pos(

   714           str.find_last_of( slash<path_type>::value, end_pos-1 ) );

   715 #       ifdef BOOST_WINDOWS_PATH

   716         if ( pos == String::npos )

   717           pos = str.find_last_of( path_alt_separator<path_type>::value, end_pos-1 );

   718         if ( pos == String::npos )

   719           pos = str.find_last_of( colon<path_type>::value, end_pos-2 );

   720 #       endif

   721 

   722         return ( pos == String::npos // path itself must be a leaf (or empty)

   723           || (pos == 1 && str[0] == slash<path_type>::value) ) // or net

   724             ? 0 // so leaf is entire string

   725             : pos + 1; // or starts after delimiter

   726       }

   727 

   728       // first_element helper  -----------------------------------------------//

   729       //   sets pos and len of first element, excluding extra separators

   730       //   if src.empty(), sets pos,len, to 0,0.

   731 

   732       template<class String, class Traits>

   733         void first_element(

   734           const String & src, // precondition: portable generic path grammar

   735           typename String::size_type & element_pos,

   736           typename String::size_type & element_size,

   737 #       if !BOOST_WORKAROUND( BOOST_MSVC, <= 1310 ) // VC++ 7.1

   738           typename String::size_type size = String::npos

   739 #       else

   740           typename String::size_type size = -1

   741 #       endif

   742           )

   743       {

   744         if ( size == String::npos ) size = src.size();

   745         element_pos = 0;

   746         element_size = 0;

   747         if ( src.empty() ) return;

   748 

   749         typedef typename boost::BOOST_FILESYSTEM_NAMESPACE::basic_path<String, Traits> path_type;

   750 

   751         typename String::size_type cur(0);

   752         

   753         // deal with // [network]

   754         if ( size >= 2 && src[0] == slash<path_type>::value

   755           && src[1] == slash<path_type>::value

   756           && (size == 2

   757             || src[2] != slash<path_type>::value) )

   758         { 

   759           cur += 2;

   760           element_size += 2;

   761         }

   762 

   763         // leading (not non-network) separator

   764         else if ( src[0] == slash<path_type>::value )

   765         {

   766           ++element_size;

   767           // bypass extra leading separators

   768           while ( cur+1 < size

   769             && src[cur+1] == slash<path_type>::value )

   770           {

   771             ++cur;

   772             ++element_pos;

   773           }

   774           return;

   775         }

   776 

   777         // at this point, we have either a plain name, a network name,

   778         // or (on Windows only) a device name

   779 

   780         // find the end

   781         while ( cur < size

   782 #         ifdef BOOST_WINDOWS_PATH

   783           && src[cur] != colon<path_type>::value

   784 #         endif

   785           && src[cur] != slash<path_type>::value )

   786         {

   787           ++cur;

   788           ++element_size;

   789         }

   790 

   791 #       ifdef BOOST_WINDOWS_PATH

   792         if ( cur == size ) return;

   793         // include device delimiter

   794         if ( src[cur] == colon<path_type>::value )

   795           { ++element_size; }

   796 #       endif

   797 

   798         return;

   799       }

   800 

   801       // root_directory_start helper  ----------------------------------------//

   802 

   803       template<class String, class Traits>

   804       typename String::size_type root_directory_start(

   805         const String & s, // precondition: portable generic path grammar

   806         typename String::size_type size )

   807       // return npos if no root_directory found

   808       {

   809         typedef typename boost::BOOST_FILESYSTEM_NAMESPACE::basic_path<String, Traits> path_type;

   810 

   811 #     ifdef BOOST_WINDOWS_PATH

   812         // case "c:/"

   813         if ( size > 2

   814           && s[1] == colon<path_type>::value

   815           && s[2] == slash<path_type>::value ) return 2;

   816 #     endif

   817 

   818         // case "//"

   819         if ( size == 2

   820           && s[0] == slash<path_type>::value

   821           && s[1] == slash<path_type>::value ) return String::npos;

   822 

   823         // case "//net {/}"

   824         if ( size > 3

   825           && s[0] == slash<path_type>::value

   826           && s[1] == slash<path_type>::value

   827           && s[2] != slash<path_type>::value )

   828         {

   829           typename String::size_type pos(

   830             s.find( slash<path_type>::value, 2 ) );

   831           return pos < size ? pos : String::npos;

   832         }

   833         

   834         // case "/"

   835         if ( size > 0 && s[0] == slash<path_type>::value ) return 0;

   836 

   837         return String::npos;

   838       }

   839 

   840       // is_non_root_slash helper  -------------------------------------------//

   841 

   842       template<class String, class Traits>

   843       bool is_non_root_slash( const String & str,

   844         typename String::size_type pos ) // pos is position of the slash

   845       {

   846         typedef typename

   847           boost::BOOST_FILESYSTEM_NAMESPACE::basic_path<String, Traits>

   848             path_type;

   849 

   850         assert( !str.empty() && str[pos] == slash<path_type>::value

   851           && "precondition violation" );

   852 

   853         // subsequent logic expects pos to be for leftmost slash of a set

   854         while ( pos > 0 && str[pos-1] == slash<path_type>::value )

   855           --pos;

   856 

   857         return  pos != 0

   858           && (pos <= 2 || str[1] != slash<path_type>::value

   859             || str.find( slash<path_type>::value, 2 ) != pos)

   860 #       ifdef BOOST_WINDOWS_PATH

   861           && (pos !=2 || str[1] != colon<path_type>::value)

   862 #       endif

   863             ;

   864       }

   865     } // namespace detail

   866 

   867     // decomposition functions  ----------------------------------------------//

   868 

   869     template<class String, class Traits>

   870     String basic_path<String, Traits>::leaf() const

   871     {

   872       typename String::size_type end_pos(

   873         detail::leaf_pos<String, Traits>( m_path, m_path.size() ) );

   874       return (m_path.size()

   875                 && end_pos

   876                 && m_path[end_pos] == slash<path_type>::value

   877                 && detail::is_non_root_slash< String, Traits >(m_path, end_pos))

   878         ? String( 1, dot<path_type>::value )

   879         : m_path.substr( end_pos );

   880     }

   881 

   882     template<class String, class Traits>

   883     basic_path<String, Traits> basic_path<String, Traits>::branch_path() const

   884     {

   885       typename String::size_type end_pos(

   886         detail::leaf_pos<String, Traits>( m_path, m_path.size() ) );

   887 

   888       bool leaf_was_separator( m_path.size()

   889         && m_path[end_pos] == slash<path_type>::value );

   890 

   891       // skip separators unless root directory

   892       typename string_type::size_type root_dir_pos( detail::root_directory_start

   893         <string_type, traits_type>( m_path, end_pos ) );

   894       for ( ; 

   895         end_pos > 0

   896         && (end_pos-1) != root_dir_pos

   897         && m_path[end_pos-1] == slash<path_type>::value

   898         ;

   899         --end_pos ) {}

   900 

   901      return (end_pos == 1 && root_dir_pos == 0 && leaf_was_separator)

   902        ? path_type()

   903        : path_type( m_path.substr( 0, end_pos ) );

   904     }

   905 

   906     template<class String, class Traits>

   907     basic_path<String, Traits> basic_path<String, Traits>::relative_path() const

   908     {

   909       iterator itr( begin() );

   910       for ( ; itr.m_pos != m_path.size()

   911           && (itr.m_name[0] == slash<path_type>::value

   912 #     ifdef BOOST_WINDOWS_PATH

   913           || itr.m_name[itr.m_name.size()-1]

   914             == colon<path_type>::value

   915 #     endif

   916              ); ++itr ) {}

   917 

   918       return basic_path<String, Traits>( m_path.substr( itr.m_pos ) );

   919     }

   920 

   921     template<class String, class Traits>

   922     String basic_path<String, Traits>::root_name() const

   923     {

   924       iterator itr( begin() );

   925 

   926       return ( itr.m_pos != m_path.size()

   927         && (

   928             ( itr.m_name.size() > 1

   929               && itr.m_name[0] == slash<path_type>::value

   930               && itr.m_name[1] == slash<path_type>::value

   931             )

   932 #     ifdef BOOST_WINDOWS_PATH

   933           || itr.m_name[itr.m_name.size()-1]

   934             == colon<path_type>::value

   935 #     endif

   936            ) )

   937         ? *itr

   938         : String();

   939     }

   940 

   941     template<class String, class Traits>

   942     String basic_path<String, Traits>::root_directory() const

   943     {

   944       typename string_type::size_type start(

   945         detail::root_directory_start<String, Traits>( m_path, m_path.size() ) );

   946 

   947       return start == string_type::npos

   948         ? string_type()

   949         : m_path.substr( start, 1 );

   950     }

   951 

   952     template<class String, class Traits>

   953     basic_path<String, Traits> basic_path<String, Traits>::root_path() const

   954     {

   955       // even on POSIX, root_name() is non-empty() on network paths

   956       return basic_path<String, Traits>( root_name() ) /= root_directory();

   957     }

   958 

   959     // path query functions  -------------------------------------------------//

   960 

   961     template<class String, class Traits>

   962     inline bool basic_path<String, Traits>::is_complete() const

   963     {

   964 #   ifdef BOOST_WINDOWS_PATH

   965       return has_root_name() && has_root_directory();

   966 #   else

   967       return has_root_directory();

   968 #   endif

   969     }

   970 

   971     template<class String, class Traits>

   972     inline bool basic_path<String, Traits>::has_root_path() const

   973     {

   974       return !root_path().empty();

   975     }

   976 

   977     template<class String, class Traits>

   978     inline bool basic_path<String, Traits>::has_root_name() const

   979     {

   980       return !root_name().empty();

   981     }

   982 

   983     template<class String, class Traits>

   984     inline bool basic_path<String, Traits>::has_root_directory() const

   985     {

   986       return !root_directory().empty();

   987     }

   988 

   989     // append  ---------------------------------------------------------------//

   990 

   991     template<class String, class Traits>

   992     void basic_path<String, Traits>::m_append_separator_if_needed()

   993     // requires: !empty()

   994     {

   995       if (

   996 #       ifdef BOOST_WINDOWS_PATH

   997         *(m_path.end()-1) != colon<path_type>::value && 

   998 #       endif

   999         *(m_path.end()-1) != slash<path_type>::value )

  1000       {

  1001         m_path += slash<path_type>::value;

  1002       }

  1003     }

  1004       

  1005     template<class String, class Traits>

  1006     void basic_path<String, Traits>::m_append( value_type value )

  1007     {

  1008 #   ifdef BOOST_CYGWIN_PATH

  1009       if ( m_path.empty() ) m_cygwin_root = (value == slash<path_type>::value);

  1010 #   endif

  1011 

  1012 #   ifdef BOOST_WINDOWS_PATH

  1013       // for BOOST_WINDOWS_PATH, convert alt_separator ('\') to separator ('/')

  1014       m_path += ( value == path_alt_separator<path_type>::value

  1015         ? slash<path_type>::value

  1016         : value );

  1017 #   else

  1018       m_path += value;

  1019 #   endif

  1020     }

  1021     

  1022     // except that it wouldn't work for BOOST_NO_MEMBER_TEMPLATES compilers,

  1023     // the append() member template could replace this code.

  1024     template<class String, class Traits>

  1025     basic_path<String, Traits> & basic_path<String, Traits>::operator /=

  1026       ( const value_type * next_p )

  1027     {

  1028       // ignore escape sequence on POSIX or Windows

  1029       if ( *next_p == slash<path_type>::value

  1030         && *(next_p+1) == slash<path_type>::value

  1031         && *(next_p+2) == colon<path_type>::value ) next_p += 3;

  1032       

  1033       // append slash<path_type>::value if needed

  1034       if ( !empty() && *next_p != 0

  1035         && !detail::is_separator<path_type>( *next_p ) )

  1036       { m_append_separator_if_needed(); }

  1037 

  1038       for ( ; *next_p != 0; ++next_p ) m_append( *next_p );

  1039       return *this;

  1040     }

  1041 

  1042 # ifndef BOOST_NO_MEMBER_TEMPLATES

  1043     template<class String, class Traits> template <class InputIterator>

  1044       basic_path<String, Traits> & basic_path<String, Traits>::append(

  1045         InputIterator first, InputIterator last )

  1046     {

  1047       // append slash<path_type>::value if needed

  1048       if ( !empty() && first != last

  1049         && !detail::is_separator<path_type>( *first ) )

  1050       { m_append_separator_if_needed(); }

  1051 

  1052       // song-and-dance to avoid violating InputIterator requirements

  1053       // (which prohibit lookahead) in detecting a possible escape sequence

  1054       // (escape sequences are simply ignored on POSIX and Windows)

  1055       bool was_escape_sequence(true);

  1056       std::size_t append_count(0);

  1057       typename String::size_type initial_pos( m_path.size() );

  1058 

  1059       for ( ; first != last && *first; ++first )

  1060       {

  1061         if ( append_count == 0 && *first != slash<path_type>::value )

  1062           was_escape_sequence = false;

  1063         if ( append_count == 1 && *first != slash<path_type>::value )

  1064           was_escape_sequence = false;

  1065         if ( append_count == 2 && *first != colon<path_type>::value )

  1066           was_escape_sequence = false;

  1067         m_append( *first );

  1068         ++append_count;

  1069       }

  1070 

  1071       // erase escape sequence if any

  1072       if ( was_escape_sequence && append_count >= 3 )

  1073         m_path.erase( initial_pos, 3 );

  1074 

  1075       return *this;

  1076     }

  1077 # endif

  1078 

  1079 # ifndef BOOST_FILESYSTEM_NO_DEPRECATED

  1080 

  1081     // canonize  ------------------------------------------------------------//

  1082 

  1083     template<class String, class Traits>

  1084     basic_path<String, Traits> & basic_path<String, Traits>::canonize()

  1085     {

  1086       static const typename string_type::value_type dot_str[]

  1087         = { dot<path_type>::value, 0 };

  1088 

  1089       if ( m_path.empty() ) return *this;

  1090         

  1091       path_type temp;

  1092 

  1093       for ( iterator itr( begin() ); itr != end(); ++itr )

  1094       {

  1095         temp /= *itr;

  1096       };

  1097 

  1098       if ( temp.empty() ) temp /= dot_str;

  1099       m_path = temp.m_path;

  1100       return *this;

  1101     }

  1102 

  1103     // normalize  ------------------------------------------------------------//

  1104 

  1105     template<class String, class Traits>

  1106     basic_path<String, Traits> & basic_path<String, Traits>::normalize()

  1107     {

  1108       static const typename string_type::value_type dot_str[]

  1109         = { dot<path_type>::value, 0 };

  1110 

  1111       if ( m_path.empty() ) return *this;

  1112         

  1113       path_type temp;

  1114       iterator start( begin() );

  1115       iterator last( end() );

  1116       iterator stop( last-- );

  1117       for ( iterator itr( start ); itr != stop; ++itr )

  1118       {

  1119         // ignore "." except at start and last

  1120         if ( itr->size() == 1

  1121           && (*itr)[0] == dot<path_type>::value

  1122           && itr != start

  1123           && itr != last ) continue;

  1124 

  1125         // ignore a name and following ".."

  1126         if ( !temp.empty()

  1127           && itr->size() == 2

  1128           && (*itr)[0] == dot<path_type>::value

  1129           && (*itr)[1] == dot<path_type>::value ) // dot dot

  1130         {

  1131           string_type lf( temp.leaf() );  

  1132           if ( lf.size() > 0  

  1133             && (lf.size() != 1

  1134               || (lf[0] != dot<path_type>::value

  1135                 && lf[0] != slash<path_type>::value))