1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/ossrv/ossrv_pub/boost_apis/boost/filesystem/path.hpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1423 @@
1.4 +// boost/filesystem/path.hpp -----------------------------------------------//
1.5 +
1.6 +// Copyright Beman Dawes 2002-2005
1.7 +// Use, modification, and distribution is subject to the Boost Software
1.8 +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
1.9 +// http://www.boost.org/LICENSE_1_0.txt)
1.10 +
1.11 +// See library home page at http://www.boost.org/libs/filesystem
1.12 +
1.13 +//----------------------------------------------------------------------------//
1.14 +
1.15 +#ifndef BOOST_FILESYSTEM_PATH_HPP
1.16 +#define BOOST_FILESYSTEM_PATH_HPP
1.17 +
1.18 +#include <boost/filesystem/config.hpp>
1.19 +#include <boost/iterator/iterator_facade.hpp>
1.20 +#include <boost/throw_exception.hpp>
1.21 +#include <boost/shared_ptr.hpp>
1.22 +#include <boost/type_traits/is_same.hpp>
1.23 +#include <boost/static_assert.hpp>
1.24 +
1.25 +#include <string>
1.26 +#include <algorithm> // for lexicographical_compare
1.27 +#include <iosfwd> // needed by basic_path inserter and extractor
1.28 +#include <stdexcept>
1.29 +#include <cassert>
1.30 +
1.31 +# ifndef BOOST_FILESYSTEM_NARROW_ONLY
1.32 +# include <locale>
1.33 +# endif
1.34 +
1.35 +#include <boost/config/abi_prefix.hpp> // must be the last #include
1.36 +
1.37 +//----------------------------------------------------------------------------//
1.38 +
1.39 +namespace boost
1.40 +{
1.41 + namespace BOOST_FILESYSTEM_NAMESPACE
1.42 + {
1.43 + template<class String, class Traits> class basic_path;
1.44 +
1.45 + struct path_traits;
1.46 + typedef basic_path< std::string, path_traits > path;
1.47 +
1.48 + struct path_traits
1.49 + {
1.50 + typedef std::string internal_string_type;
1.51 + typedef std::string external_string_type;
1.52 + static external_string_type to_external( const path &,
1.53 + const internal_string_type & src ) { return src; }
1.54 + static internal_string_type to_internal(
1.55 + const external_string_type & src ) { return src; }
1.56 + };
1.57 +
1.58 +# ifndef BOOST_FILESYSTEM_NARROW_ONLY
1.59 +
1.60 + struct wpath_traits;
1.61 +
1.62 + typedef basic_path< std::wstring, wpath_traits > wpath;
1.63 +
1.64 + struct wpath_traits
1.65 + {
1.66 + typedef std::wstring internal_string_type;
1.67 +# ifdef BOOST_WINDOWS_API
1.68 + typedef std::wstring external_string_type;
1.69 + static external_string_type to_external( const wpath &,
1.70 + const internal_string_type & src ) { return src; }
1.71 + static internal_string_type to_internal(
1.72 + const external_string_type & src ) { return src; }
1.73 +# else
1.74 + typedef std::string external_string_type;
1.75 + static external_string_type to_external( const wpath & ph,
1.76 + const internal_string_type & src );
1.77 + static internal_string_type to_internal(
1.78 + const external_string_type & src );
1.79 +# endif
1.80 + static void imbue( const std::locale & loc );
1.81 + static bool imbue( const std::locale & loc, const std::nothrow_t & );
1.82 + };
1.83 +
1.84 +# endif // ifndef BOOST_FILESYSTEM_NARROW_ONLY
1.85 +
1.86 +// error reporting support -------------------------------------------------//
1.87 +
1.88 + typedef int errno_type; // determined by C standard
1.89 +
1.90 +# ifdef BOOST_WINDOWS_API
1.91 + typedef unsigned system_error_type;
1.92 +
1.93 + BOOST_FILESYSTEM_DECL
1.94 + errno_type lookup_errno( system_error_type sys_err_code );
1.95 +# else
1.96 + typedef int system_error_type;
1.97 +
1.98 + inline errno_type lookup_errno( system_error_type sys_err_code )
1.99 + { return sys_err_code; }
1.100 +# endif
1.101 +
1.102 + // deprecated support for legacy function name
1.103 + inline errno_type lookup_error_code( system_error_type sys_err_code )
1.104 + { return lookup_errno( sys_err_code ); }
1.105 +
1.106 + BOOST_FILESYSTEM_DECL
1.107 + void system_message( system_error_type sys_err_code, std::string & target );
1.108 + // Effects: appends error message to target
1.109 +
1.110 +# if defined(BOOST_WINDOWS_API) && !defined(BOOST_FILESYSTEM_NARROW_ONLY)
1.111 + BOOST_FILESYSTEM_DECL void
1.112 + system_message( system_error_type sys_err_code, std::wstring & target );
1.113 +# endif
1.114 +
1.115 + // filesystem_error ----------------------------------------------------//
1.116 +
1.117 + class filesystem_error : public std::runtime_error
1.118 + // see http://www.boost.org/more/error_handling.html for design rationale
1.119 + {
1.120 + public:
1.121 + filesystem_error()
1.122 + : std::runtime_error("filesystem error"), m_sys_err(0) {}
1.123 + explicit filesystem_error(
1.124 + const std::string & what_arg, system_error_type sys_ec = 0 )
1.125 + : std::runtime_error(what_arg), m_sys_err(sys_ec) {}
1.126 +
1.127 + system_error_type system_error() const { return m_sys_err; }
1.128 + // Note: system_error() == 0 implies a library (rather than system) error
1.129 +
1.130 + private:
1.131 + system_error_type m_sys_err;
1.132 + };
1.133 +
1.134 + // basic_filesystem_error ----------------------------------------------//
1.135 +
1.136 + template<class Path>
1.137 + class basic_filesystem_error : public filesystem_error
1.138 + {
1.139 + // see http://www.boost.org/more/error_handling.html for design rationale
1.140 + public:
1.141 + // compiler generates copy constructor and copy assignment
1.142 +
1.143 + typedef Path path_type;
1.144 +
1.145 + basic_filesystem_error( const std::string & what,
1.146 + system_error_type sys_err_code );
1.147 +
1.148 + basic_filesystem_error( const std::string & what,
1.149 + const path_type & path1, system_error_type sys_err_code );
1.150 +
1.151 + basic_filesystem_error( const std::string & what, const path_type & path1,
1.152 + const path_type & path2, system_error_type sys_err_code );
1.153 +
1.154 + ~basic_filesystem_error() throw() {}
1.155 +
1.156 + const path_type & path1() const
1.157 + {
1.158 + static const path_type empty_path;
1.159 + return m_imp_ptr.get() ? m_imp_ptr->m_path1 : empty_path ;
1.160 + }
1.161 + const path_type & path2() const
1.162 + {
1.163 + static const path_type empty_path;
1.164 + return m_imp_ptr.get() ? m_imp_ptr->m_path2 : empty_path ;
1.165 + }
1.166 +
1.167 + private:
1.168 + struct m_imp
1.169 + {
1.170 + path_type m_path1; // may be empty()
1.171 + path_type m_path2; // may be empty()
1.172 + };
1.173 + boost::shared_ptr<m_imp> m_imp_ptr;
1.174 + };
1.175 +
1.176 + typedef basic_filesystem_error<path> filesystem_path_error;
1.177 +
1.178 +# ifndef BOOST_FILESYSTEM_NARROW_ONLY
1.179 + typedef basic_filesystem_error<wpath> filesystem_wpath_error;
1.180 +# endif
1.181 +
1.182 + // path traits ---------------------------------------------------------//
1.183 +
1.184 + template<class Path> struct is_basic_path
1.185 + { BOOST_STATIC_CONSTANT( bool, value = false ); };
1.186 + template<> struct is_basic_path<path>
1.187 + { BOOST_STATIC_CONSTANT( bool, value = true ); };
1.188 +# ifndef BOOST_FILESYSTEM_NARROW_ONLY
1.189 + template<> struct is_basic_path<wpath>
1.190 + { BOOST_STATIC_CONSTANT( bool, value = true ); };
1.191 +# endif
1.192 +
1.193 + // these only have to be specialized if Path::string_type::value_type
1.194 + // is not convertible from char
1.195 + template<class Path> struct slash
1.196 + { BOOST_STATIC_CONSTANT( char, value = '/' ); };
1.197 +
1.198 + template<class Path> struct dot
1.199 + { BOOST_STATIC_CONSTANT( char, value = '.' ); };
1.200 +
1.201 + template<class Path> struct colon
1.202 + { BOOST_STATIC_CONSTANT( char, value = ':' ); };
1.203 +
1.204 +# ifdef BOOST_WINDOWS_PATH
1.205 + template<class Path> struct path_alt_separator
1.206 + { BOOST_STATIC_CONSTANT( char, value = '\\' ); };
1.207 +# endif
1.208 +
1.209 + // workaround for VC++ 7.0 and earlier issues with nested classes
1.210 + namespace detail
1.211 + {
1.212 + template<class Path>
1.213 + class iterator_helper
1.214 + {
1.215 + public:
1.216 + typedef typename Path::iterator iterator;
1.217 + static void do_increment( iterator & ph );
1.218 + static void do_decrement( iterator & ph );
1.219 + };
1.220 + }
1.221 +
1.222 + // basic_path ----------------------------------------------------------//
1.223 +
1.224 + template<class String, class Traits>
1.225 + class basic_path
1.226 + {
1.227 + // invariant: m_path valid according to the portable generic path grammar
1.228 +
1.229 + // validate template arguments
1.230 +// TODO: get these working
1.231 +// BOOST_STATIC_ASSERT( ::boost::is_same<String,typename Traits::internal_string_type>::value );
1.232 +// 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 );
1.233 +
1.234 + public:
1.235 + // compiler generates copy constructor and copy assignment
1.236 +
1.237 + typedef basic_path<String, Traits> path_type;
1.238 + typedef String string_type;
1.239 + typedef typename String::value_type value_type;
1.240 + typedef Traits traits_type;
1.241 + typedef typename Traits::external_string_type external_string_type;
1.242 +
1.243 + // constructors/destructor
1.244 + basic_path() {}
1.245 + basic_path( const string_type & s ) { operator/=( s ); }
1.246 + basic_path( const value_type * s ) { operator/=( s ); }
1.247 +# ifndef BOOST_NO_MEMBER_TEMPLATES
1.248 + template <class InputIterator>
1.249 + basic_path( InputIterator first, InputIterator last )
1.250 + { append( first, last ); }
1.251 +# endif
1.252 + ~basic_path() {}
1.253 +
1.254 + // assignments
1.255 + basic_path & operator=( const string_type & s )
1.256 + {
1.257 +# if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, >= 310)
1.258 + m_path.clear();
1.259 +# else
1.260 + m_path.erase( m_path.begin(), m_path.end() );
1.261 +# endif
1.262 + operator/=( s );
1.263 + return *this;
1.264 + }
1.265 + basic_path & operator=( const value_type * s )
1.266 + {
1.267 +# if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, >= 310)
1.268 + m_path.clear();
1.269 +# else
1.270 + m_path.erase( m_path.begin(), m_path.end() );
1.271 +# endif
1.272 + operator/=( s );
1.273 + return *this;
1.274 + }
1.275 +# ifndef BOOST_NO_MEMBER_TEMPLATES
1.276 + template <class InputIterator>
1.277 + basic_path & assign( InputIterator first, InputIterator last )
1.278 + { m_path.clear(); append( first, last ); return *this; }
1.279 +# endif
1.280 +
1.281 + // modifiers
1.282 + basic_path & operator/=( const basic_path & rhs ) { return operator /=( rhs.string().c_str() ); }
1.283 + basic_path & operator/=( const string_type & rhs ) { return operator /=( rhs.c_str() ); }
1.284 + basic_path & operator/=( const value_type * s );
1.285 +# ifndef BOOST_NO_MEMBER_TEMPLATES
1.286 + template <class InputIterator>
1.287 + basic_path & append( InputIterator first, InputIterator last );
1.288 +# endif
1.289 +
1.290 + void swap( basic_path & rhs )
1.291 + {
1.292 + m_path.swap( rhs.m_path );
1.293 +# ifdef BOOST_CYGWIN_PATH
1.294 + std::swap( m_cygwin_root, rhs.m_cygwin_root );
1.295 +# endif
1.296 + }
1.297 +
1.298 + basic_path & remove_leaf();
1.299 +
1.300 + // observers
1.301 + const string_type & string() const { return m_path; }
1.302 + const string_type file_string() const;
1.303 + const string_type directory_string() const { return file_string(); }
1.304 +
1.305 + const external_string_type external_file_string() const { return Traits::to_external( *this, file_string() ); }
1.306 + const external_string_type external_directory_string() const { return Traits::to_external( *this, directory_string() ); }
1.307 +
1.308 + basic_path root_path() const;
1.309 + string_type root_name() const;
1.310 + string_type root_directory() const;
1.311 + basic_path relative_path() const;
1.312 + string_type leaf() const;
1.313 + basic_path branch_path() const;
1.314 +
1.315 + bool empty() const { return m_path.empty(); } // name consistent with std containers
1.316 + bool is_complete() const;
1.317 + bool has_root_path() const;
1.318 + bool has_root_name() const;
1.319 + bool has_root_directory() const;
1.320 + bool has_relative_path() const { return !relative_path().empty(); }
1.321 + bool has_leaf() const { return !m_path.empty(); }
1.322 + bool has_branch_path() const { return !branch_path().empty(); }
1.323 +
1.324 + // iterators
1.325 + class iterator : public boost::iterator_facade<
1.326 + iterator,
1.327 + string_type const,
1.328 + boost::bidirectional_traversal_tag >
1.329 + {
1.330 + private:
1.331 + friend class boost::iterator_core_access;
1.332 + friend class boost::BOOST_FILESYSTEM_NAMESPACE::basic_path<String, Traits>;
1.333 +
1.334 + const string_type & dereference() const
1.335 + { return m_name; }
1.336 + bool equal( const iterator & rhs ) const
1.337 + { return m_path_ptr == rhs.m_path_ptr && m_pos == rhs.m_pos; }
1.338 +
1.339 + friend class boost::BOOST_FILESYSTEM_NAMESPACE::detail::iterator_helper<path_type>;
1.340 +
1.341 + void increment()
1.342 + {
1.343 + boost::BOOST_FILESYSTEM_NAMESPACE::detail::iterator_helper<path_type>::do_increment(
1.344 + *this );
1.345 + }
1.346 + void decrement()
1.347 + {
1.348 + boost::BOOST_FILESYSTEM_NAMESPACE::detail::iterator_helper<path_type>::do_decrement(
1.349 + *this );
1.350 + }
1.351 +
1.352 + string_type m_name; // current element
1.353 + const basic_path * m_path_ptr; // path being iterated over
1.354 + typename string_type::size_type m_pos; // position of name in
1.355 + // path_ptr->string(). The
1.356 + // end() iterator is indicated by
1.357 + // pos == path_ptr->m_path.size()
1.358 + }; // iterator
1.359 +
1.360 + typedef iterator const_iterator;
1.361 +
1.362 + iterator begin() const;
1.363 + iterator end() const;
1.364 +
1.365 + private:
1.366 + // Note: This is an implementation for POSIX and Windows, where there
1.367 + // are only minor differences between generic and native path grammars.
1.368 + // Private members might be quite different in other implementations,
1.369 + // particularly where there were wide differences between portable and
1.370 + // native path formats, or between file_string() and
1.371 + // directory_string() formats, or simply that the implementation
1.372 + // was willing expend additional memory to achieve greater speed for
1.373 + // some operations at the expense of other operations.
1.374 +
1.375 + string_type m_path; // invariant: portable path grammar
1.376 + // on Windows, backslashes converted to slashes
1.377 +
1.378 +# ifdef BOOST_CYGWIN_PATH
1.379 + bool m_cygwin_root; // if present, m_path[0] was slash. note: initialization
1.380 + // done by append
1.381 +# endif
1.382 +
1.383 + void m_append_separator_if_needed();
1.384 + void m_append( value_type value ); // converts Windows alt_separator
1.385 +
1.386 + // Was qualified; como433beta8 reports:
1.387 + // warning #427-D: qualified name is not allowed in member declaration
1.388 + friend class iterator;
1.389 + friend class boost::BOOST_FILESYSTEM_NAMESPACE::detail::iterator_helper<path_type>;
1.390 +
1.391 + // Deprecated features ease transition for existing code. Don't use these
1.392 + // in new code.
1.393 +# ifndef BOOST_FILESYSTEM_NO_DEPRECATED
1.394 + public:
1.395 + typedef bool (*name_check)( const std::string & name );
1.396 + basic_path( const string_type & str, name_check ) { operator/=( str ); }
1.397 + basic_path( const typename string_type::value_type * s, name_check )
1.398 + { operator/=( s );}
1.399 + string_type native_file_string() const { return file_string(); }
1.400 + string_type native_directory_string() const { return directory_string(); }
1.401 + static bool default_name_check_writable() { return false; }
1.402 + static void default_name_check( name_check ) {}
1.403 + static name_check default_name_check() { return 0; }
1.404 + basic_path & canonize();
1.405 + basic_path & normalize();
1.406 +# endif
1.407 + };
1.408 +
1.409 + // basic_path non-member functions ---------------------------------------//
1.410 +
1.411 + template< class String, class Traits >
1.412 + inline void swap( basic_path<String, Traits> & lhs,
1.413 + basic_path<String, Traits> & rhs ) { lhs.swap( rhs ); }
1.414 +
1.415 + template< class String, class Traits >
1.416 + bool operator<( const basic_path<String, Traits> & lhs, const basic_path<String, Traits> & rhs )
1.417 + {
1.418 + return std::lexicographical_compare(
1.419 + lhs.begin(), lhs.end(), rhs.begin(), rhs.end() );
1.420 + }
1.421 +
1.422 + template< class String, class Traits >
1.423 + bool operator<( const typename basic_path<String, Traits>::string_type::value_type * lhs,
1.424 + const basic_path<String, Traits> & rhs )
1.425 + {
1.426 + basic_path<String, Traits> tmp( lhs );
1.427 + return std::lexicographical_compare(
1.428 + tmp.begin(), tmp.end(), rhs.begin(), rhs.end() );
1.429 + }
1.430 +
1.431 + template< class String, class Traits >
1.432 + bool operator<( const typename basic_path<String, Traits>::string_type & lhs,
1.433 + const basic_path<String, Traits> & rhs )
1.434 + {
1.435 + basic_path<String, Traits> tmp( lhs );
1.436 + return std::lexicographical_compare(
1.437 + tmp.begin(), tmp.end(), rhs.begin(), rhs.end() );
1.438 + }
1.439 +
1.440 + template< class String, class Traits >
1.441 + bool operator<( const basic_path<String, Traits> & lhs,
1.442 + const typename basic_path<String, Traits>::string_type::value_type * rhs )
1.443 + {
1.444 + basic_path<String, Traits> tmp( rhs );
1.445 + return std::lexicographical_compare(
1.446 + lhs.begin(), lhs.end(), tmp.begin(), tmp.end() );
1.447 + }
1.448 +
1.449 + template< class String, class Traits >
1.450 + bool operator<( const basic_path<String, Traits> & lhs,
1.451 + const typename basic_path<String, Traits>::string_type & rhs )
1.452 + {
1.453 + basic_path<String, Traits> tmp( rhs );
1.454 + return std::lexicographical_compare(
1.455 + lhs.begin(), lhs.end(), tmp.begin(), tmp.end() );
1.456 + }
1.457 +
1.458 + template< class String, class Traits >
1.459 + inline bool operator==( const basic_path<String, Traits> & lhs, const basic_path<String, Traits> & rhs )
1.460 + {
1.461 + return !(lhs < rhs) && !(rhs < lhs);
1.462 + }
1.463 +
1.464 + template< class String, class Traits >
1.465 + inline bool operator==( const typename basic_path<String, Traits>::string_type::value_type * lhs,
1.466 + const basic_path<String, Traits> & rhs )
1.467 + {
1.468 + basic_path<String, Traits> tmp( lhs );
1.469 + return !(tmp < rhs) && !(rhs < tmp);
1.470 + }
1.471 +
1.472 + template< class String, class Traits >
1.473 + inline bool operator==( const typename basic_path<String, Traits>::string_type & lhs,
1.474 + const basic_path<String, Traits> & rhs )
1.475 + {
1.476 + basic_path<String, Traits> tmp( lhs );
1.477 + return !(tmp < rhs) && !(rhs < tmp);
1.478 + }
1.479 +
1.480 + template< class String, class Traits >
1.481 + inline bool operator==( const basic_path<String, Traits> & lhs,
1.482 + const typename basic_path<String, Traits>::string_type::value_type * rhs )
1.483 + {
1.484 + basic_path<String, Traits> tmp( rhs );
1.485 + return !(lhs < tmp) && !(tmp < lhs);
1.486 + }
1.487 +
1.488 + template< class String, class Traits >
1.489 + inline bool operator==( const basic_path<String, Traits> & lhs,
1.490 + const typename basic_path<String, Traits>::string_type & rhs )
1.491 + {
1.492 + basic_path<String, Traits> tmp( rhs );
1.493 + return !(lhs < tmp) && !(tmp < lhs);
1.494 + }
1.495 +
1.496 + template< class String, class Traits >
1.497 + inline bool operator!=( const basic_path<String, Traits> & lhs, const basic_path<String, Traits> & rhs ) { return !(lhs == rhs); }
1.498 +
1.499 + template< class String, class Traits >
1.500 + inline bool operator!=( const typename basic_path<String, Traits>::string_type::value_type * lhs,
1.501 + const basic_path<String, Traits> & rhs ) { return !(basic_path<String, Traits>(lhs) == rhs); }
1.502 +
1.503 + template< class String, class Traits >
1.504 + inline bool operator!=( const typename basic_path<String, Traits>::string_type & lhs,
1.505 + const basic_path<String, Traits> & rhs ) { return !(basic_path<String, Traits>(lhs) == rhs); }
1.506 +
1.507 + template< class String, class Traits >
1.508 + inline bool operator!=( const basic_path<String, Traits> & lhs,
1.509 + const typename basic_path<String, Traits>::string_type::value_type * rhs )
1.510 + { return !(lhs == basic_path<String, Traits>(rhs)); }
1.511 +
1.512 + template< class String, class Traits >
1.513 + inline bool operator!=( const basic_path<String, Traits> & lhs,
1.514 + const typename basic_path<String, Traits>::string_type & rhs )
1.515 + { return !(lhs == basic_path<String, Traits>(rhs)); }
1.516 +
1.517 + template< class String, class Traits >
1.518 + inline bool operator>( const basic_path<String, Traits> & lhs, const basic_path<String, Traits> & rhs ) { return rhs < lhs; }
1.519 +
1.520 + template< class String, class Traits >
1.521 + inline bool operator>( const typename basic_path<String, Traits>::string_type::value_type * lhs,
1.522 + const basic_path<String, Traits> & rhs ) { return rhs < basic_path<String, Traits>(lhs); }
1.523 +
1.524 + template< class String, class Traits >
1.525 + inline bool operator>( const typename basic_path<String, Traits>::string_type & lhs,
1.526 + const basic_path<String, Traits> & rhs ) { return rhs < basic_path<String, Traits>(lhs); }
1.527 +
1.528 + template< class String, class Traits >
1.529 + inline bool operator>( const basic_path<String, Traits> & lhs,
1.530 + const typename basic_path<String, Traits>::string_type::value_type * rhs )
1.531 + { return basic_path<String, Traits>(rhs) < lhs; }
1.532 +
1.533 + template< class String, class Traits >
1.534 + inline bool operator>( const basic_path<String, Traits> & lhs,
1.535 + const typename basic_path<String, Traits>::string_type & rhs )
1.536 + { return basic_path<String, Traits>(rhs) < lhs; }
1.537 +
1.538 + template< class String, class Traits >
1.539 + inline bool operator<=( const basic_path<String, Traits> & lhs, const basic_path<String, Traits> & rhs ) { return !(rhs < lhs); }
1.540 +
1.541 + template< class String, class Traits >
1.542 + inline bool operator<=( const typename basic_path<String, Traits>::string_type::value_type * lhs,
1.543 + const basic_path<String, Traits> & rhs ) { return !(rhs < basic_path<String, Traits>(lhs)); }
1.544 +
1.545 + template< class String, class Traits >
1.546 + inline bool operator<=( const typename basic_path<String, Traits>::string_type & lhs,
1.547 + const basic_path<String, Traits> & rhs ) { return !(rhs < basic_path<String, Traits>(lhs)); }
1.548 +
1.549 + template< class String, class Traits >
1.550 + inline bool operator<=( const basic_path<String, Traits> & lhs,
1.551 + const typename basic_path<String, Traits>::string_type::value_type * rhs )
1.552 + { return !(basic_path<String, Traits>(rhs) < lhs); }
1.553 +
1.554 + template< class String, class Traits >
1.555 + inline bool operator<=( const basic_path<String, Traits> & lhs,
1.556 + const typename basic_path<String, Traits>::string_type & rhs )
1.557 + { return !(basic_path<String, Traits>(rhs) < lhs); }
1.558 +
1.559 + template< class String, class Traits >
1.560 + inline bool operator>=( const basic_path<String, Traits> & lhs, const basic_path<String, Traits> & rhs ) { return !(lhs < rhs); }
1.561 +
1.562 + template< class String, class Traits >
1.563 + inline bool operator>=( const typename basic_path<String, Traits>::string_type::value_type * lhs,
1.564 + const basic_path<String, Traits> & rhs ) { return !(lhs < basic_path<String, Traits>(rhs)); }
1.565 +
1.566 + template< class String, class Traits >
1.567 + inline bool operator>=( const typename basic_path<String, Traits>::string_type & lhs,
1.568 + const basic_path<String, Traits> & rhs ) { return !(lhs < basic_path<String, Traits>(rhs)); }
1.569 +
1.570 + template< class String, class Traits >
1.571 + inline bool operator>=( const basic_path<String, Traits> & lhs,
1.572 + const typename basic_path<String, Traits>::string_type::value_type * rhs )
1.573 + { return !(basic_path<String, Traits>(lhs) < rhs); }
1.574 +
1.575 + template< class String, class Traits >
1.576 + inline bool operator>=( const basic_path<String, Traits> & lhs,
1.577 + const typename basic_path<String, Traits>::string_type & rhs )
1.578 + { return !(basic_path<String, Traits>(lhs) < rhs); }
1.579 +
1.580 + // operator /
1.581 +
1.582 + template< class String, class Traits >
1.583 + inline basic_path<String, Traits> operator/(
1.584 + const basic_path<String, Traits> & lhs,
1.585 + const basic_path<String, Traits> & rhs )
1.586 + { return basic_path<String, Traits>( lhs ) /= rhs; }
1.587 +
1.588 + template< class String, class Traits >
1.589 + inline basic_path<String, Traits> operator/(
1.590 + const basic_path<String, Traits> & lhs,
1.591 + const typename String::value_type * rhs )
1.592 + { return basic_path<String, Traits>( lhs ) /=
1.593 + basic_path<String, Traits>( rhs ); }
1.594 +
1.595 + template< class String, class Traits >
1.596 + inline basic_path<String, Traits> operator/(
1.597 + const basic_path<String, Traits> & lhs, const String & rhs )
1.598 + { return basic_path<String, Traits>( lhs ) /=
1.599 + basic_path<String, Traits>( rhs ); }
1.600 +
1.601 + template< class String, class Traits >
1.602 + inline basic_path<String, Traits> operator/(
1.603 + const typename String::value_type * lhs,
1.604 + const basic_path<String, Traits> & rhs )
1.605 + { return basic_path<String, Traits>( lhs ) /= rhs; }
1.606 +
1.607 + template< class String, class Traits >
1.608 + inline basic_path<String, Traits> operator/(
1.609 + const String & lhs, const basic_path<String, Traits> & rhs )
1.610 + { return basic_path<String, Traits>( lhs ) /= rhs; }
1.611 +
1.612 + // inserters and extractors --------------------------------------------//
1.613 +
1.614 +// bypass VC++ 7.0 and earlier, and broken Borland compilers
1.615 +# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) && !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
1.616 + template< class Path >
1.617 + std::basic_ostream< typename Path::string_type::value_type,
1.618 + typename Path::string_type::traits_type > &
1.619 + operator<<
1.620 + ( std::basic_ostream< typename Path::string_type::value_type,
1.621 + typename Path::string_type::traits_type >& os, const Path & ph )
1.622 + {
1.623 + os << ph.string();
1.624 + return os;
1.625 + }
1.626 +
1.627 + template< class Path >
1.628 + std::basic_istream< typename Path::string_type::value_type,
1.629 + typename Path::string_type::traits_type > &
1.630 + operator>>
1.631 + ( std::basic_istream< typename Path::string_type::value_type,
1.632 + typename Path::string_type::traits_type >& is, Path & ph )
1.633 + {
1.634 + typename Path::string_type str;
1.635 + is >> str;
1.636 + ph = str;
1.637 + return is;
1.638 + }
1.639 +# elif BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
1.640 + template< class String, class Traits >
1.641 + std::basic_ostream< BOOST_DEDUCED_TYPENAME String::value_type,
1.642 + BOOST_DEDUCED_TYPENAME String::traits_type > &
1.643 + operator<<
1.644 + ( std::basic_ostream< BOOST_DEDUCED_TYPENAME String::value_type,
1.645 + BOOST_DEDUCED_TYPENAME String::traits_type >& os,
1.646 + const basic_path< String, Traits > & ph )
1.647 + {
1.648 + os << ph.string();
1.649 + return os;
1.650 + }
1.651 +
1.652 + template< class String, class Traits >
1.653 + std::basic_istream< BOOST_DEDUCED_TYPENAME String::value_type,
1.654 + BOOST_DEDUCED_TYPENAME String::traits_type > &
1.655 + operator>>
1.656 + ( std::basic_istream< BOOST_DEDUCED_TYPENAME String::value_type,
1.657 + BOOST_DEDUCED_TYPENAME String::traits_type> & is,
1.658 + basic_path< String, Traits > & ph )
1.659 + {
1.660 + String str;
1.661 + is >> str;
1.662 + ph = str;
1.663 + return is;
1.664 + }
1.665 +# endif
1.666 +
1.667 + // path::name_checks -----------------------------------------------------//
1.668 +
1.669 + BOOST_FILESYSTEM_DECL bool portable_posix_name( const std::string & name );
1.670 + BOOST_FILESYSTEM_DECL bool windows_name( const std::string & name );
1.671 + BOOST_FILESYSTEM_DECL bool portable_name( const std::string & name );
1.672 + BOOST_FILESYSTEM_DECL bool portable_directory_name( const std::string & name );
1.673 + BOOST_FILESYSTEM_DECL bool portable_file_name( const std::string & name );
1.674 + BOOST_FILESYSTEM_DECL bool native( const std::string & name );
1.675 + inline bool no_check( const std::string & )
1.676 + { return true; }
1.677 +
1.678 +// implementation -----------------------------------------------------------//
1.679 +
1.680 + namespace detail
1.681 + {
1.682 +
1.683 + // is_separator helper ------------------------------------------------//
1.684 +
1.685 + template<class Path>
1.686 + inline bool is_separator( typename Path::string_type::value_type c )
1.687 + {
1.688 + return c == slash<Path>::value
1.689 +# ifdef BOOST_WINDOWS_PATH
1.690 + || c == path_alt_separator<Path>::value
1.691 +# endif
1.692 + ;
1.693 + }
1.694 +
1.695 + // leaf_pos helper ----------------------------------------------------//
1.696 +
1.697 + template<class String, class Traits>
1.698 + typename String::size_type leaf_pos(
1.699 + const String & str, // precondition: portable generic path grammar
1.700 + typename String::size_type end_pos ) // end_pos is past-the-end position
1.701 + // return 0 if str itself is leaf (or empty)
1.702 + {
1.703 + typedef typename
1.704 + boost::BOOST_FILESYSTEM_NAMESPACE::basic_path<String, Traits> path_type;
1.705 +
1.706 + // case: "//"
1.707 + if ( end_pos == 2
1.708 + && str[0] == slash<path_type>::value
1.709 + && str[1] == slash<path_type>::value ) return 0;
1.710 +
1.711 + // case: ends in "/"
1.712 + if ( end_pos && str[end_pos-1] == slash<path_type>::value )
1.713 + return end_pos-1;
1.714 +
1.715 + // set pos to start of last element
1.716 + typename String::size_type pos(
1.717 + str.find_last_of( slash<path_type>::value, end_pos-1 ) );
1.718 +# ifdef BOOST_WINDOWS_PATH
1.719 + if ( pos == String::npos )
1.720 + pos = str.find_last_of( path_alt_separator<path_type>::value, end_pos-1 );
1.721 + if ( pos == String::npos )
1.722 + pos = str.find_last_of( colon<path_type>::value, end_pos-2 );
1.723 +# endif
1.724 +
1.725 + return ( pos == String::npos // path itself must be a leaf (or empty)
1.726 + || (pos == 1 && str[0] == slash<path_type>::value) ) // or net
1.727 + ? 0 // so leaf is entire string
1.728 + : pos + 1; // or starts after delimiter
1.729 + }
1.730 +
1.731 + // first_element helper -----------------------------------------------//
1.732 + // sets pos and len of first element, excluding extra separators
1.733 + // if src.empty(), sets pos,len, to 0,0.
1.734 +
1.735 + template<class String, class Traits>
1.736 + void first_element(
1.737 + const String & src, // precondition: portable generic path grammar
1.738 + typename String::size_type & element_pos,
1.739 + typename String::size_type & element_size,
1.740 +# if !BOOST_WORKAROUND( BOOST_MSVC, <= 1310 ) // VC++ 7.1
1.741 + typename String::size_type size = String::npos
1.742 +# else
1.743 + typename String::size_type size = -1
1.744 +# endif
1.745 + )
1.746 + {
1.747 + if ( size == String::npos ) size = src.size();
1.748 + element_pos = 0;
1.749 + element_size = 0;
1.750 + if ( src.empty() ) return;
1.751 +
1.752 + typedef typename boost::BOOST_FILESYSTEM_NAMESPACE::basic_path<String, Traits> path_type;
1.753 +
1.754 + typename String::size_type cur(0);
1.755 +
1.756 + // deal with // [network]
1.757 + if ( size >= 2 && src[0] == slash<path_type>::value
1.758 + && src[1] == slash<path_type>::value
1.759 + && (size == 2
1.760 + || src[2] != slash<path_type>::value) )
1.761 + {
1.762 + cur += 2;
1.763 + element_size += 2;
1.764 + }
1.765 +
1.766 + // leading (not non-network) separator
1.767 + else if ( src[0] == slash<path_type>::value )
1.768 + {
1.769 + ++element_size;
1.770 + // bypass extra leading separators
1.771 + while ( cur+1 < size
1.772 + && src[cur+1] == slash<path_type>::value )
1.773 + {
1.774 + ++cur;
1.775 + ++element_pos;
1.776 + }
1.777 + return;
1.778 + }
1.779 +
1.780 + // at this point, we have either a plain name, a network name,
1.781 + // or (on Windows only) a device name
1.782 +
1.783 + // find the end
1.784 + while ( cur < size
1.785 +# ifdef BOOST_WINDOWS_PATH
1.786 + && src[cur] != colon<path_type>::value
1.787 +# endif
1.788 + && src[cur] != slash<path_type>::value )
1.789 + {
1.790 + ++cur;
1.791 + ++element_size;
1.792 + }
1.793 +
1.794 +# ifdef BOOST_WINDOWS_PATH
1.795 + if ( cur == size ) return;
1.796 + // include device delimiter
1.797 + if ( src[cur] == colon<path_type>::value )
1.798 + { ++element_size; }
1.799 +# endif
1.800 +
1.801 + return;
1.802 + }
1.803 +
1.804 + // root_directory_start helper ----------------------------------------//
1.805 +
1.806 + template<class String, class Traits>
1.807 + typename String::size_type root_directory_start(
1.808 + const String & s, // precondition: portable generic path grammar
1.809 + typename String::size_type size )
1.810 + // return npos if no root_directory found
1.811 + {
1.812 + typedef typename boost::BOOST_FILESYSTEM_NAMESPACE::basic_path<String, Traits> path_type;
1.813 +
1.814 +# ifdef BOOST_WINDOWS_PATH
1.815 + // case "c:/"
1.816 + if ( size > 2
1.817 + && s[1] == colon<path_type>::value
1.818 + && s[2] == slash<path_type>::value ) return 2;
1.819 +# endif
1.820 +
1.821 + // case "//"
1.822 + if ( size == 2
1.823 + && s[0] == slash<path_type>::value
1.824 + && s[1] == slash<path_type>::value ) return String::npos;
1.825 +
1.826 + // case "//net {/}"
1.827 + if ( size > 3
1.828 + && s[0] == slash<path_type>::value
1.829 + && s[1] == slash<path_type>::value
1.830 + && s[2] != slash<path_type>::value )
1.831 + {
1.832 + typename String::size_type pos(
1.833 + s.find( slash<path_type>::value, 2 ) );
1.834 + return pos < size ? pos : String::npos;
1.835 + }
1.836 +
1.837 + // case "/"
1.838 + if ( size > 0 && s[0] == slash<path_type>::value ) return 0;
1.839 +
1.840 + return String::npos;
1.841 + }
1.842 +
1.843 + // is_non_root_slash helper -------------------------------------------//
1.844 +
1.845 + template<class String, class Traits>
1.846 + bool is_non_root_slash( const String & str,
1.847 + typename String::size_type pos ) // pos is position of the slash
1.848 + {
1.849 + typedef typename
1.850 + boost::BOOST_FILESYSTEM_NAMESPACE::basic_path<String, Traits>
1.851 + path_type;
1.852 +
1.853 + assert( !str.empty() && str[pos] == slash<path_type>::value
1.854 + && "precondition violation" );
1.855 +
1.856 + // subsequent logic expects pos to be for leftmost slash of a set
1.857 + while ( pos > 0 && str[pos-1] == slash<path_type>::value )
1.858 + --pos;
1.859 +
1.860 + return pos != 0
1.861 + && (pos <= 2 || str[1] != slash<path_type>::value
1.862 + || str.find( slash<path_type>::value, 2 ) != pos)
1.863 +# ifdef BOOST_WINDOWS_PATH
1.864 + && (pos !=2 || str[1] != colon<path_type>::value)
1.865 +# endif
1.866 + ;
1.867 + }
1.868 + } // namespace detail
1.869 +
1.870 + // decomposition functions ----------------------------------------------//
1.871 +
1.872 + template<class String, class Traits>
1.873 + String basic_path<String, Traits>::leaf() const
1.874 + {
1.875 + typename String::size_type end_pos(
1.876 + detail::leaf_pos<String, Traits>( m_path, m_path.size() ) );
1.877 + return (m_path.size()
1.878 + && end_pos
1.879 + && m_path[end_pos] == slash<path_type>::value
1.880 + && detail::is_non_root_slash< String, Traits >(m_path, end_pos))
1.881 + ? String( 1, dot<path_type>::value )
1.882 + : m_path.substr( end_pos );
1.883 + }
1.884 +
1.885 + template<class String, class Traits>
1.886 + basic_path<String, Traits> basic_path<String, Traits>::branch_path() const
1.887 + {
1.888 + typename String::size_type end_pos(
1.889 + detail::leaf_pos<String, Traits>( m_path, m_path.size() ) );
1.890 +
1.891 + bool leaf_was_separator( m_path.size()
1.892 + && m_path[end_pos] == slash<path_type>::value );
1.893 +
1.894 + // skip separators unless root directory
1.895 + typename string_type::size_type root_dir_pos( detail::root_directory_start
1.896 + <string_type, traits_type>( m_path, end_pos ) );
1.897 + for ( ;
1.898 + end_pos > 0
1.899 + && (end_pos-1) != root_dir_pos
1.900 + && m_path[end_pos-1] == slash<path_type>::value
1.901 + ;
1.902 + --end_pos ) {}
1.903 +
1.904 + return (end_pos == 1 && root_dir_pos == 0 && leaf_was_separator)
1.905 + ? path_type()
1.906 + : path_type( m_path.substr( 0, end_pos ) );
1.907 + }
1.908 +
1.909 + template<class String, class Traits>
1.910 + basic_path<String, Traits> basic_path<String, Traits>::relative_path() const
1.911 + {
1.912 + iterator itr( begin() );
1.913 + for ( ; itr.m_pos != m_path.size()
1.914 + && (itr.m_name[0] == slash<path_type>::value
1.915 +# ifdef BOOST_WINDOWS_PATH
1.916 + || itr.m_name[itr.m_name.size()-1]
1.917 + == colon<path_type>::value
1.918 +# endif
1.919 + ); ++itr ) {}
1.920 +
1.921 + return basic_path<String, Traits>( m_path.substr( itr.m_pos ) );
1.922 + }
1.923 +
1.924 + template<class String, class Traits>
1.925 + String basic_path<String, Traits>::root_name() const
1.926 + {
1.927 + iterator itr( begin() );
1.928 +
1.929 + return ( itr.m_pos != m_path.size()
1.930 + && (
1.931 + ( itr.m_name.size() > 1
1.932 + && itr.m_name[0] == slash<path_type>::value
1.933 + && itr.m_name[1] == slash<path_type>::value
1.934 + )
1.935 +# ifdef BOOST_WINDOWS_PATH
1.936 + || itr.m_name[itr.m_name.size()-1]
1.937 + == colon<path_type>::value
1.938 +# endif
1.939 + ) )
1.940 + ? *itr
1.941 + : String();
1.942 + }
1.943 +
1.944 + template<class String, class Traits>
1.945 + String basic_path<String, Traits>::root_directory() const
1.946 + {
1.947 + typename string_type::size_type start(
1.948 + detail::root_directory_start<String, Traits>( m_path, m_path.size() ) );
1.949 +
1.950 + return start == string_type::npos
1.951 + ? string_type()
1.952 + : m_path.substr( start, 1 );
1.953 + }
1.954 +
1.955 + template<class String, class Traits>
1.956 + basic_path<String, Traits> basic_path<String, Traits>::root_path() const
1.957 + {
1.958 + // even on POSIX, root_name() is non-empty() on network paths
1.959 + return basic_path<String, Traits>( root_name() ) /= root_directory();
1.960 + }
1.961 +
1.962 + // path query functions -------------------------------------------------//
1.963 +
1.964 + template<class String, class Traits>
1.965 + inline bool basic_path<String, Traits>::is_complete() const
1.966 + {
1.967 +# ifdef BOOST_WINDOWS_PATH
1.968 + return has_root_name() && has_root_directory();
1.969 +# else
1.970 + return has_root_directory();
1.971 +# endif
1.972 + }
1.973 +
1.974 + template<class String, class Traits>
1.975 + inline bool basic_path<String, Traits>::has_root_path() const
1.976 + {
1.977 + return !root_path().empty();
1.978 + }
1.979 +
1.980 + template<class String, class Traits>
1.981 + inline bool basic_path<String, Traits>::has_root_name() const
1.982 + {
1.983 + return !root_name().empty();
1.984 + }
1.985 +
1.986 + template<class String, class Traits>
1.987 + inline bool basic_path<String, Traits>::has_root_directory() const
1.988 + {
1.989 + return !root_directory().empty();
1.990 + }
1.991 +
1.992 + // append ---------------------------------------------------------------//
1.993 +
1.994 + template<class String, class Traits>
1.995 + void basic_path<String, Traits>::m_append_separator_if_needed()
1.996 + // requires: !empty()
1.997 + {
1.998 + if (
1.999 +# ifdef BOOST_WINDOWS_PATH
1.1000 + *(m_path.end()-1) != colon<path_type>::value &&
1.1001 +# endif
1.1002 + *(m_path.end()-1) != slash<path_type>::value )
1.1003 + {
1.1004 + m_path += slash<path_type>::value;
1.1005 + }
1.1006 + }
1.1007 +
1.1008 + template<class String, class Traits>
1.1009 + void basic_path<String, Traits>::m_append( value_type value )
1.1010 + {
1.1011 +# ifdef BOOST_CYGWIN_PATH
1.1012 + if ( m_path.empty() ) m_cygwin_root = (value == slash<path_type>::value);
1.1013 +# endif
1.1014 +
1.1015 +# ifdef BOOST_WINDOWS_PATH
1.1016 + // for BOOST_WINDOWS_PATH, convert alt_separator ('\') to separator ('/')
1.1017 + m_path += ( value == path_alt_separator<path_type>::value
1.1018 + ? slash<path_type>::value
1.1019 + : value );
1.1020 +# else
1.1021 + m_path += value;
1.1022 +# endif
1.1023 + }
1.1024 +
1.1025 + // except that it wouldn't work for BOOST_NO_MEMBER_TEMPLATES compilers,
1.1026 + // the append() member template could replace this code.
1.1027 + template<class String, class Traits>
1.1028 + basic_path<String, Traits> & basic_path<String, Traits>::operator /=
1.1029 + ( const value_type * next_p )
1.1030 + {
1.1031 + // ignore escape sequence on POSIX or Windows
1.1032 + if ( *next_p == slash<path_type>::value
1.1033 + && *(next_p+1) == slash<path_type>::value
1.1034 + && *(next_p+2) == colon<path_type>::value ) next_p += 3;
1.1035 +
1.1036 + // append slash<path_type>::value if needed
1.1037 + if ( !empty() && *next_p != 0
1.1038 + && !detail::is_separator<path_type>( *next_p ) )
1.1039 + { m_append_separator_if_needed(); }
1.1040 +
1.1041 + for ( ; *next_p != 0; ++next_p ) m_append( *next_p );
1.1042 + return *this;
1.1043 + }
1.1044 +
1.1045 +# ifndef BOOST_NO_MEMBER_TEMPLATES
1.1046 + template<class String, class Traits> template <class InputIterator>
1.1047 + basic_path<String, Traits> & basic_path<String, Traits>::append(
1.1048 + InputIterator first, InputIterator last )
1.1049 + {
1.1050 + // append slash<path_type>::value if needed
1.1051 + if ( !empty() && first != last
1.1052 + && !detail::is_separator<path_type>( *first ) )
1.1053 + { m_append_separator_if_needed(); }
1.1054 +
1.1055 + // song-and-dance to avoid violating InputIterator requirements
1.1056 + // (which prohibit lookahead) in detecting a possible escape sequence
1.1057 + // (escape sequences are simply ignored on POSIX and Windows)
1.1058 + bool was_escape_sequence(true);
1.1059 + std::size_t append_count(0);
1.1060 + typename String::size_type initial_pos( m_path.size() );
1.1061 +
1.1062 + for ( ; first != last && *first; ++first )
1.1063 + {
1.1064 + if ( append_count == 0 && *first != slash<path_type>::value )
1.1065 + was_escape_sequence = false;
1.1066 + if ( append_count == 1 && *first != slash<path_type>::value )
1.1067 + was_escape_sequence = false;
1.1068 + if ( append_count == 2 && *first != colon<path_type>::value )
1.1069 + was_escape_sequence = false;
1.1070 + m_append( *first );
1.1071 + ++append_count;
1.1072 + }
1.1073 +
1.1074 + // erase escape sequence if any
1.1075 + if ( was_escape_sequence && append_count >= 3 )
1.1076 + m_path.erase( initial_pos, 3 );
1.1077 +
1.1078 + return *this;
1.1079 + }
1.1080 +# endif
1.1081 +
1.1082 +# ifndef BOOST_FILESYSTEM_NO_DEPRECATED
1.1083 +
1.1084 + // canonize ------------------------------------------------------------//
1.1085 +
1.1086 + template<class String, class Traits>
1.1087 + basic_path<String, Traits> & basic_path<String, Traits>::canonize()
1.1088 + {
1.1089 + static const typename string_type::value_type dot_str[]
1.1090 + = { dot<path_type>::value, 0 };
1.1091 +
1.1092 + if ( m_path.empty() ) return *this;
1.1093 +
1.1094 + path_type temp;
1.1095 +
1.1096 + for ( iterator itr( begin() ); itr != end(); ++itr )
1.1097 + {
1.1098 + temp /= *itr;
1.1099 + };
1.1100 +
1.1101 + if ( temp.empty() ) temp /= dot_str;
1.1102 + m_path = temp.m_path;
1.1103 + return *this;
1.1104 + }
1.1105 +
1.1106 + // normalize ------------------------------------------------------------//
1.1107 +
1.1108 + template<class String, class Traits>
1.1109 + basic_path<String, Traits> & basic_path<String, Traits>::normalize()
1.1110 + {
1.1111 + static const typename string_type::value_type dot_str[]
1.1112 + = { dot<path_type>::value, 0 };
1.1113 +
1.1114 + if ( m_path.empty() ) return *this;
1.1115 +
1.1116 + path_type temp;
1.1117 + iterator start( begin() );
1.1118 + iterator last( end() );
1.1119 + iterator stop( last-- );
1.1120 + for ( iterator itr( start ); itr != stop; ++itr )
1.1121 + {
1.1122 + // ignore "." except at start and last
1.1123 + if ( itr->size() == 1
1.1124 + && (*itr)[0] == dot<path_type>::value
1.1125 + && itr != start
1.1126 + && itr != last ) continue;
1.1127 +
1.1128 + // ignore a name and following ".."
1.1129 + if ( !temp.empty()
1.1130 + && itr->size() == 2
1.1131 + && (*itr)[0] == dot<path_type>::value
1.1132 + && (*itr)[1] == dot<path_type>::value ) // dot dot
1.1133 + {
1.1134 + string_type lf( temp.leaf() );
1.1135 + if ( lf.size() > 0
1.1136 + && (lf.size() != 1
1.1137 + || (lf[0] != dot<path_type>::value
1.1138 + && lf[0] != slash<path_type>::value))
1.1139 + && (lf.size() != 2
1.1140 + || (lf[0] != dot<path_type>::value
1.1141 + && lf[1] != dot<path_type>::value
1.1142 +# ifdef BOOST_WINDOWS_PATH
1.1143 + && lf[1] != colon<path_type>::value
1.1144 +# endif
1.1145 + )
1.1146 + )
1.1147 + )
1.1148 + {
1.1149 + temp.remove_leaf();
1.1150 + // if not root directory, must also remove "/" if any
1.1151 + if ( temp.m_path.size() > 0
1.1152 + && temp.m_path[temp.m_path.size()-1]
1.1153 + == slash<path_type>::value )
1.1154 + {
1.1155 + typename string_type::size_type rds(
1.1156 + detail::root_directory_start<String,Traits>( temp.m_path,
1.1157 + temp.m_path.size() ) );
1.1158 + if ( rds == string_type::npos
1.1159 + || rds != temp.m_path.size()-1 )
1.1160 + { temp.m_path.erase( temp.m_path.size()-1 ); }
1.1161 + }
1.1162 +
1.1163 + iterator next( itr );
1.1164 + if ( temp.empty() && ++next != stop
1.1165 + && next == last && *last == dot_str ) temp /= dot_str;
1.1166 + continue;
1.1167 + }
1.1168 + }
1.1169 +
1.1170 + temp /= *itr;
1.1171 + };
1.1172 +
1.1173 + if ( temp.empty() ) temp /= dot_str;
1.1174 + m_path = temp.m_path;
1.1175 + return *this;
1.1176 + }
1.1177 +
1.1178 +# endif
1.1179 +
1.1180 + // remove_leaf ----------------------------------------------------------//
1.1181 +
1.1182 + template<class String, class Traits>
1.1183 + basic_path<String, Traits> & basic_path<String, Traits>::remove_leaf()
1.1184 + {
1.1185 + m_path.erase(
1.1186 + detail::leaf_pos<String, Traits>( m_path, m_path.size() ) );
1.1187 + return *this;
1.1188 + }
1.1189 +
1.1190 + // path conversion functions --------------------------------------------//
1.1191 +
1.1192 + template<class String, class Traits>
1.1193 + const String
1.1194 + basic_path<String, Traits>::file_string() const
1.1195 + {
1.1196 +# ifdef BOOST_WINDOWS_PATH
1.1197 + // for Windows, use the alternate separator, and bypass extra
1.1198 + // root separators
1.1199 +
1.1200 + typename string_type::size_type root_dir_start(
1.1201 + detail::root_directory_start<String, Traits>( m_path, m_path.size() ) );
1.1202 + bool in_root( root_dir_start != string_type::npos );
1.1203 + String s;
1.1204 + for ( typename string_type::size_type pos( 0 );
1.1205 + pos != m_path.size(); ++pos )
1.1206 + {
1.1207 + // special case // [net]
1.1208 + if ( pos == 0 && m_path.size() > 1
1.1209 + && m_path[0] == slash<path_type>::value
1.1210 + && m_path[1] == slash<path_type>::value
1.1211 + && ( m_path.size() == 2
1.1212 + || !detail::is_separator<path_type>( m_path[2] )
1.1213 + ) )
1.1214 + {
1.1215 + ++pos;
1.1216 + s += path_alt_separator<path_type>::value;
1.1217 + s += path_alt_separator<path_type>::value;
1.1218 + continue;
1.1219 + }
1.1220 +
1.1221 + // bypass extra root separators
1.1222 + if ( in_root )
1.1223 + {
1.1224 + if ( s.size() > 0
1.1225 + && s[s.size()-1] == path_alt_separator<path_type>::value
1.1226 + && m_path[pos] == slash<path_type>::value
1.1227 + ) continue;
1.1228 + }
1.1229 +
1.1230 + if ( m_path[pos] == slash<path_type>::value )
1.1231 + s += path_alt_separator<path_type>::value;
1.1232 + else
1.1233 + s += m_path[pos];
1.1234 +
1.1235 + if ( pos > root_dir_start
1.1236 + && m_path[pos] == slash<path_type>::value )
1.1237 + { in_root = false; }
1.1238 + }
1.1239 +# ifdef BOOST_CYGWIN_PATH
1.1240 + if ( m_cygwin_root ) s[0] = slash<path_type>::value;
1.1241 +# endif
1.1242 + return s;
1.1243 +# else
1.1244 + return m_path;
1.1245 +# endif
1.1246 + }
1.1247 +
1.1248 + // iterator functions ---------------------------------------------------//
1.1249 +
1.1250 + template<class String, class Traits>
1.1251 + typename basic_path<String, Traits>::iterator basic_path<String, Traits>::begin() const
1.1252 + {
1.1253 + iterator itr;
1.1254 + itr.m_path_ptr = this;
1.1255 + typename string_type::size_type element_size;
1.1256 + detail::first_element<String, Traits>( m_path, itr.m_pos, element_size );
1.1257 + itr.m_name = m_path.substr( itr.m_pos, element_size );
1.1258 + return itr;
1.1259 + }
1.1260 +
1.1261 + template<class String, class Traits>
1.1262 + typename basic_path<String, Traits>::iterator basic_path<String, Traits>::end() const
1.1263 + {
1.1264 + iterator itr;
1.1265 + itr.m_path_ptr = this;
1.1266 + itr.m_pos = m_path.size();
1.1267 + return itr;
1.1268 + }
1.1269 +
1.1270 + namespace detail
1.1271 + {
1.1272 + // do_increment ------------------------------------------------------//
1.1273 +
1.1274 + template<class Path>
1.1275 + void iterator_helper<Path>::do_increment( iterator & itr )
1.1276 + {
1.1277 + typedef typename Path::string_type string_type;
1.1278 + typedef typename Path::traits_type traits_type;
1.1279 +
1.1280 + assert( itr.m_pos < itr.m_path_ptr->m_path.size() && "basic_path::iterator increment past end()" );
1.1281 +
1.1282 + bool was_net( itr.m_name.size() > 2
1.1283 + && itr.m_name[0] == slash<Path>::value
1.1284 + && itr.m_name[1] == slash<Path>::value
1.1285 + && itr.m_name[2] != slash<Path>::value );
1.1286 +
1.1287 + // increment to position past current element
1.1288 + itr.m_pos += itr.m_name.size();
1.1289 +
1.1290 + // if end reached, create end iterator
1.1291 + if ( itr.m_pos == itr.m_path_ptr->m_path.size() )
1.1292 + {
1.1293 + itr.m_name.erase( itr.m_name.begin(), itr.m_name.end() ); // VC++ 6.0 lib didn't supply clear()
1.1294 + return;
1.1295 + }
1.1296 +
1.1297 + // process separator (Windows drive spec is only case not a separator)
1.1298 + if ( itr.m_path_ptr->m_path[itr.m_pos] == slash<Path>::value )
1.1299 + {
1.1300 + // detect root directory
1.1301 + if ( was_net
1.1302 + # ifdef BOOST_WINDOWS_PATH
1.1303 + // case "c:/"
1.1304 + || itr.m_name[itr.m_name.size()-1] == colon<Path>::value
1.1305 + # endif
1.1306 + )
1.1307 + {
1.1308 + itr.m_name = slash<Path>::value;
1.1309 + return;
1.1310 + }
1.1311 +
1.1312 + // bypass separators
1.1313 + while ( itr.m_pos != itr.m_path_ptr->m_path.size()
1.1314 + && itr.m_path_ptr->m_path[itr.m_pos] == slash<Path>::value )
1.1315 + { ++itr.m_pos; }
1.1316 +
1.1317 + // detect trailing separator, and treat it as ".", per POSIX spec
1.1318 + if ( itr.m_pos == itr.m_path_ptr->m_path.size()
1.1319 + && detail::is_non_root_slash< string_type, traits_type >(
1.1320 + itr.m_path_ptr->m_path, itr.m_pos-1 ) )
1.1321 + {
1.1322 + --itr.m_pos;
1.1323 + itr.m_name = dot<Path>::value;
1.1324 + return;
1.1325 + }
1.1326 + }
1.1327 +
1.1328 + // get next element
1.1329 + typename string_type::size_type end_pos(
1.1330 + itr.m_path_ptr->m_path.find( slash<Path>::value, itr.m_pos ) );
1.1331 + itr.m_name = itr.m_path_ptr->m_path.substr( itr.m_pos, end_pos - itr.m_pos );
1.1332 + }
1.1333 +
1.1334 + // do_decrement ------------------------------------------------------//
1.1335 +
1.1336 + template<class Path>
1.1337 + void iterator_helper<Path>::do_decrement( iterator & itr )
1.1338 + {
1.1339 + assert( itr.m_pos && "basic_path::iterator decrement past begin()" );
1.1340 +
1.1341 + typedef typename Path::string_type string_type;
1.1342 + typedef typename Path::traits_type traits_type;
1.1343 +
1.1344 + typename string_type::size_type end_pos( itr.m_pos );
1.1345 +
1.1346 + typename string_type::size_type root_dir_pos(
1.1347 + detail::root_directory_start<string_type, traits_type>(
1.1348 + itr.m_path_ptr->m_path, end_pos ) );
1.1349 +
1.1350 + // if at end and there was a trailing non-root '/', return "."
1.1351 + if ( itr.m_pos == itr.m_path_ptr->m_path.size()
1.1352 + && itr.m_path_ptr->m_path.size() > 1
1.1353 + && itr.m_path_ptr->m_path[itr.m_pos-1] == slash<Path>::value
1.1354 + && detail::is_non_root_slash< string_type, traits_type >(
1.1355 + itr.m_path_ptr->m_path, itr.m_pos-1 )
1.1356 + )
1.1357 + {
1.1358 + --itr.m_pos;
1.1359 + itr.m_name = dot<Path>::value;
1.1360 + return;
1.1361 + }
1.1362 +
1.1363 + // skip separators unless root directory
1.1364 + for (
1.1365 + ;
1.1366 + end_pos > 0
1.1367 + && (end_pos-1) != root_dir_pos
1.1368 + && itr.m_path_ptr->m_path[end_pos-1] == slash<Path>::value
1.1369 + ;
1.1370 + --end_pos ) {}
1.1371 +
1.1372 + itr.m_pos = detail::leaf_pos<string_type, traits_type>
1.1373 + ( itr.m_path_ptr->m_path, end_pos );
1.1374 + itr.m_name = itr.m_path_ptr->m_path.substr( itr.m_pos, end_pos - itr.m_pos );
1.1375 + }
1.1376 + } // namespace detail
1.1377 +
1.1378 + // basic_filesystem_error implementation --------------------------------//
1.1379 +
1.1380 + template<class Path>
1.1381 + basic_filesystem_error<Path>::basic_filesystem_error(
1.1382 + const std::string & what, system_error_type sys_err_code )
1.1383 + : filesystem_error(what, sys_err_code)
1.1384 + {
1.1385 + try
1.1386 + {
1.1387 + m_imp_ptr.reset( new m_imp );
1.1388 + }
1.1389 + catch (...) { m_imp_ptr.reset(); }
1.1390 + }
1.1391 +
1.1392 + template<class Path>
1.1393 + basic_filesystem_error<Path>::basic_filesystem_error(
1.1394 + const std::string & what, const path_type & path1,
1.1395 + system_error_type sys_err_code )
1.1396 + : filesystem_error(what, sys_err_code)
1.1397 + {
1.1398 + try
1.1399 + {
1.1400 + m_imp_ptr.reset( new m_imp );
1.1401 + m_imp_ptr->m_path1 = path1;
1.1402 + }
1.1403 + catch (...) { m_imp_ptr.reset(); }
1.1404 + }
1.1405 +
1.1406 + template<class Path>
1.1407 + basic_filesystem_error<Path>::basic_filesystem_error(
1.1408 + const std::string & what, const path_type & path1,
1.1409 + const path_type & path2, system_error_type sys_err_code )
1.1410 + : filesystem_error(what, sys_err_code)
1.1411 + {
1.1412 + try
1.1413 + {
1.1414 + m_imp_ptr.reset( new m_imp );
1.1415 + m_imp_ptr->m_path1 = path1;
1.1416 + m_imp_ptr->m_path2 = path2;
1.1417 + }
1.1418 + catch (...) { m_imp_ptr.reset(); }
1.1419 + }
1.1420 +
1.1421 + } // namespace BOOST_FILESYSTEM_NAMESPACE
1.1422 +} // namespace boost
1.1423 +
1.1424 +#include <boost/config/abi_suffix.hpp> // pops abi_prefix.hpp pragmas
1.1425 +
1.1426 +#endif // BOOST_FILESYSTEM_PATH_HPP