1 // filesystem path.hpp ---------------------------------------------------------------// 2 3 // Copyright Beman Dawes 2002-2005, 2009 4 // Copyright Vladimir Prus 2002 5 6 // Distributed under the Boost Software License, Version 1.0. 7 // See http://www.boost.org/LICENSE_1_0.txt 8 9 // Library home page: http://www.boost.org/libs/filesystem 10 11 // path::stem(), extension(), and replace_extension() are based on 12 // basename(), extension(), and change_extension() from the original 13 // filesystem/convenience.hpp header by Vladimir Prus. 14 15 #ifndef BOOST_FILESYSTEM_PATH_HPP 16 #define BOOST_FILESYSTEM_PATH_HPP 17 18 #include <boost/config.hpp> 19 20 # if defined( BOOST_NO_STD_WSTRING ) 21 # error Configuration not supported: Boost.Filesystem V3 and later requires std::wstring support 22 # endif 23 24 #include <boost/assert.hpp> 25 #include <boost/filesystem/config.hpp> 26 #include <boost/filesystem/path_traits.hpp> // includes <cwchar> 27 #include <boost/system/error_code.hpp> 28 #include <boost/system/system_error.hpp> 29 #include <boost/iterator/iterator_facade.hpp> 30 #include <boost/iterator/iterator_categories.hpp> 31 #include <boost/core/enable_if.hpp> 32 #include <boost/io/quoted.hpp> 33 #include <boost/functional/hash_fwd.hpp> 34 #include <boost/type_traits/is_integral.hpp> 35 #include <string> 36 #include <iterator> 37 #include <cstring> 38 #include <iosfwd> 39 #include <stdexcept> 40 #include <cassert> 41 #include <locale> 42 #include <algorithm> 43 44 #include <boost/config/abi_prefix.hpp> // must be the last #include 45 46 namespace boost 47 { 48 namespace filesystem 49 { 50 namespace path_detail // intentionally don't use filesystem::detail to not bring internal Boost.Filesystem functions into ADL via path_constants 51 { 52 53 template< typename Char, Char Separator, Char PreferredSeparator, Char Dot > 54 struct path_constants 55 { 56 typedef path_constants< Char, Separator, PreferredSeparator, Dot > path_constants_base; 57 typedef Char value_type; 58 static BOOST_CONSTEXPR_OR_CONST value_type separator = Separator; 59 static BOOST_CONSTEXPR_OR_CONST value_type preferred_separator = PreferredSeparator; 60 static BOOST_CONSTEXPR_OR_CONST value_type dot = Dot; 61 }; 62 63 #if defined(BOOST_NO_CXX17_INLINE_VARIABLES) 64 template< typename Char, Char Separator, Char PreferredSeparator, Char Dot > 65 BOOST_CONSTEXPR_OR_CONST typename path_constants< Char, Separator, PreferredSeparator, Dot >::value_type 66 path_constants< Char, Separator, PreferredSeparator, Dot >::separator; 67 template< typename Char, Char Separator, Char PreferredSeparator, Char Dot > 68 BOOST_CONSTEXPR_OR_CONST typename path_constants< Char, Separator, PreferredSeparator, Dot >::value_type 69 path_constants< Char, Separator, PreferredSeparator, Dot >::preferred_separator; 70 template< typename Char, Char Separator, Char PreferredSeparator, Char Dot > 71 BOOST_CONSTEXPR_OR_CONST typename path_constants< Char, Separator, PreferredSeparator, Dot >::value_type 72 path_constants< Char, Separator, PreferredSeparator, Dot >::dot; 73 #endif 74 75 } // namespace path_detail 76 77 //------------------------------------------------------------------------------------// 78 // // 79 // class path // 80 // // 81 //------------------------------------------------------------------------------------// 82 83 class path : 84 public filesystem::path_detail::path_constants< 85 #ifdef BOOST_WINDOWS_API 86 wchar_t, L'/', L'\\', L'.' 87 #else 88 char, '/', '/', '.' 89 #endif 90 > 91 { 92 public: 93 94 // value_type is the character type used by the operating system API to 95 // represent paths. 96 97 typedef path_constants_base::value_type value_type; 98 typedef std::basic_string<value_type> string_type; 99 typedef std::codecvt<wchar_t, char, 100 std::mbstate_t> codecvt_type; 101 102 103 // ----- character encoding conversions ----- 104 105 // Following the principle of least astonishment, path input arguments 106 // passed to or obtained from the operating system via objects of 107 // class path behave as if they were directly passed to or 108 // obtained from the O/S API, unless conversion is explicitly requested. 109 // 110 // POSIX specfies that path strings are passed unchanged to and from the 111 // API. Note that this is different from the POSIX command line utilities, 112 // which convert according to a locale. 113 // 114 // Thus for POSIX, char strings do not undergo conversion. wchar_t strings 115 // are converted to/from char using the path locale or, if a conversion 116 // argument is given, using a conversion object modeled on 117 // std::wstring_convert. 118 // 119 // The path locale, which is global to the thread, can be changed by the 120 // imbue() function. It is initialized to an implementation defined locale. 121 // 122 // For Windows, wchar_t strings do not undergo conversion. char strings 123 // are converted using the "ANSI" or "OEM" code pages, as determined by 124 // the AreFileApisANSI() function, or, if a conversion argument is given, 125 // using a conversion object modeled on std::wstring_convert. 126 // 127 // See m_pathname comments for further important rationale. 128 129 // TODO: rules needed for operating systems that use / or . 130 // differently, or format directory paths differently from file paths. 131 // 132 // ********************************************************************************** 133 // 134 // More work needed: How to handle an operating system that may have 135 // slash characters or dot characters in valid filenames, either because 136 // it doesn't follow the POSIX standard, or because it allows MBCS 137 // filename encodings that may contain slash or dot characters. For 138 // example, ISO/IEC 2022 (JIS) encoding which allows switching to 139 // JIS x0208-1983 encoding. A valid filename in this set of encodings is 140 // 0x1B 0x24 0x42 [switch to X0208-1983] 0x24 0x2F [U+304F Kiragana letter KU] 141 // ^^^^ 142 // Note that 0x2F is the ASCII slash character 143 // 144 // ********************************************************************************** 145 146 // Supported source arguments: half-open iterator range, container, c-array, 147 // and single pointer to null terminated string. 148 149 // All source arguments except pointers to null terminated byte strings support 150 // multi-byte character strings which may have embedded nulls. Embedded null 151 // support is required for some Asian languages on Windows. 152 153 // "const codecvt_type& cvt=codecvt()" default arguments are not used because this 154 // limits the impact of locale("") initialization failures on POSIX systems to programs 155 // that actually depend on locale(""). It further ensures that exceptions thrown 156 // as a result of such failues occur after main() has started, so can be caught. 157 158 // ----- constructors ----- 159 path()160 path() BOOST_NOEXCEPT {} path(const path & p)161 path(const path& p) : m_pathname(p.m_pathname) {} 162 163 template <class Source> path(Source const & source,typename boost::enable_if<path_traits::is_pathable<typename boost::decay<Source>::type>>::type * =0)164 path(Source const& source, 165 typename boost::enable_if<path_traits::is_pathable< 166 typename boost::decay<Source>::type> >::type* =0) 167 { 168 path_traits::dispatch(source, m_pathname); 169 } 170 path(const value_type * s)171 path(const value_type* s) : m_pathname(s) {} path(value_type * s)172 path(value_type* s) : m_pathname(s) {} path(const string_type & s)173 path(const string_type& s) : m_pathname(s) {} path(string_type & s)174 path(string_type& s) : m_pathname(s) {} 175 176 // As of October 2015 the interaction between noexcept and =default is so troublesome 177 // for VC++, GCC, and probably other compilers, that =default is not used with noexcept 178 // functions. GCC is not even consistent for the same release on different platforms. 179 180 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) path(path && p)181 path(path&& p) BOOST_NOEXCEPT : m_pathname(std::move(p.m_pathname)) {} operator =(path && p)182 path& operator=(path&& p) BOOST_NOEXCEPT 183 { m_pathname = std::move(p.m_pathname); return *this; } 184 # endif 185 186 template <class Source> path(Source const & source,const codecvt_type & cvt)187 path(Source const& source, const codecvt_type& cvt) 188 { 189 path_traits::dispatch(source, m_pathname, cvt); 190 } 191 192 template <class InputIterator> path(InputIterator begin,InputIterator end)193 path(InputIterator begin, InputIterator end) 194 { 195 if (begin != end) 196 { 197 // convert requires contiguous string, so copy 198 std::basic_string<typename std::iterator_traits<InputIterator>::value_type> 199 seq(begin, end); 200 path_traits::convert(seq.c_str(), seq.c_str()+seq.size(), m_pathname); 201 } 202 } 203 204 template <class InputIterator> path(InputIterator begin,InputIterator end,const codecvt_type & cvt)205 path(InputIterator begin, InputIterator end, const codecvt_type& cvt) 206 { 207 if (begin != end) 208 { 209 // convert requires contiguous string, so copy 210 std::basic_string<typename std::iterator_traits<InputIterator>::value_type> 211 seq(begin, end); 212 path_traits::convert(seq.c_str(), seq.c_str()+seq.size(), m_pathname, cvt); 213 } 214 } 215 216 // ----- assignments ----- 217 operator =(const path & p)218 path& operator=(const path& p) 219 { 220 m_pathname = p.m_pathname; 221 return *this; 222 } 223 224 template <class Source> 225 typename boost::enable_if<path_traits::is_pathable< 226 typename boost::decay<Source>::type>, path&>::type operator =(Source const & source)227 operator=(Source const& source) 228 { 229 m_pathname.clear(); 230 path_traits::dispatch(source, m_pathname); 231 return *this; 232 } 233 234 // value_type overloads 235 operator =(const value_type * ptr)236 path& operator=(const value_type* ptr) // required in case ptr overlaps *this 237 {m_pathname = ptr; return *this;} operator =(value_type * ptr)238 path& operator=(value_type* ptr) // required in case ptr overlaps *this 239 {m_pathname = ptr; return *this;} operator =(const string_type & s)240 path& operator=(const string_type& s) {m_pathname = s; return *this;} operator =(string_type & s)241 path& operator=(string_type& s) {m_pathname = s; return *this;} 242 assign(const value_type * ptr,const codecvt_type &)243 path& assign(const value_type* ptr, const codecvt_type&) // required in case ptr overlaps *this 244 {m_pathname = ptr; return *this;} 245 template <class Source> assign(Source const & source,const codecvt_type & cvt)246 path& assign(Source const& source, const codecvt_type& cvt) 247 { 248 m_pathname.clear(); 249 path_traits::dispatch(source, m_pathname, cvt); 250 return *this; 251 } 252 253 template <class InputIterator> assign(InputIterator begin,InputIterator end)254 path& assign(InputIterator begin, InputIterator end) 255 { 256 m_pathname.clear(); 257 if (begin != end) 258 { 259 std::basic_string<typename std::iterator_traits<InputIterator>::value_type> 260 seq(begin, end); 261 path_traits::convert(seq.c_str(), seq.c_str()+seq.size(), m_pathname); 262 } 263 return *this; 264 } 265 266 template <class InputIterator> assign(InputIterator begin,InputIterator end,const codecvt_type & cvt)267 path& assign(InputIterator begin, InputIterator end, const codecvt_type& cvt) 268 { 269 m_pathname.clear(); 270 if (begin != end) 271 { 272 std::basic_string<typename std::iterator_traits<InputIterator>::value_type> 273 seq(begin, end); 274 path_traits::convert(seq.c_str(), seq.c_str()+seq.size(), m_pathname, cvt); 275 } 276 return *this; 277 } 278 279 // ----- concatenation ----- 280 281 template <class Source> 282 typename boost::enable_if<path_traits::is_pathable< 283 typename boost::decay<Source>::type>, path&>::type operator +=(Source const & source)284 operator+=(Source const& source) 285 { 286 return concat(source); 287 } 288 289 // value_type overloads. Same rationale as for constructors above operator +=(const path & p)290 path& operator+=(const path& p) { m_pathname += p.m_pathname; return *this; } operator +=(const value_type * ptr)291 path& operator+=(const value_type* ptr) { m_pathname += ptr; return *this; } operator +=(value_type * ptr)292 path& operator+=(value_type* ptr) { m_pathname += ptr; return *this; } operator +=(const string_type & s)293 path& operator+=(const string_type& s) { m_pathname += s; return *this; } operator +=(string_type & s)294 path& operator+=(string_type& s) { m_pathname += s; return *this; } operator +=(value_type c)295 path& operator+=(value_type c) { m_pathname += c; return *this; } 296 297 template <class CharT> 298 typename boost::enable_if<boost::is_integral<CharT>, path&>::type operator +=(CharT c)299 operator+=(CharT c) 300 { 301 CharT tmp[2]; 302 tmp[0] = c; 303 tmp[1] = 0; 304 return concat(tmp); 305 } 306 307 template <class Source> concat(Source const & source)308 path& concat(Source const& source) 309 { 310 path_traits::dispatch(source, m_pathname); 311 return *this; 312 } 313 314 template <class Source> concat(Source const & source,const codecvt_type & cvt)315 path& concat(Source const& source, const codecvt_type& cvt) 316 { 317 path_traits::dispatch(source, m_pathname, cvt); 318 return *this; 319 } 320 321 template <class InputIterator> concat(InputIterator begin,InputIterator end)322 path& concat(InputIterator begin, InputIterator end) 323 { 324 if (begin == end) 325 return *this; 326 std::basic_string<typename std::iterator_traits<InputIterator>::value_type> 327 seq(begin, end); 328 path_traits::convert(seq.c_str(), seq.c_str()+seq.size(), m_pathname); 329 return *this; 330 } 331 332 template <class InputIterator> concat(InputIterator begin,InputIterator end,const codecvt_type & cvt)333 path& concat(InputIterator begin, InputIterator end, const codecvt_type& cvt) 334 { 335 if (begin == end) 336 return *this; 337 std::basic_string<typename std::iterator_traits<InputIterator>::value_type> 338 seq(begin, end); 339 path_traits::convert(seq.c_str(), seq.c_str()+seq.size(), m_pathname, cvt); 340 return *this; 341 } 342 343 // ----- appends ----- 344 345 // if a separator is added, it is the preferred separator for the platform; 346 // slash for POSIX, backslash for Windows 347 348 BOOST_FILESYSTEM_DECL path& operator/=(const path& p); 349 350 template <class Source> 351 typename boost::enable_if<path_traits::is_pathable< 352 typename boost::decay<Source>::type>, path&>::type operator /=(Source const & source)353 operator/=(Source const& source) 354 { 355 return append(source); 356 } 357 358 BOOST_FILESYSTEM_DECL path& operator/=(const value_type* ptr); operator /=(value_type * ptr)359 path& operator/=(value_type* ptr) 360 { 361 return this->operator/=(const_cast<const value_type*>(ptr)); 362 } operator /=(const string_type & s)363 path& operator/=(const string_type& s) { return this->operator/=(path(s)); } operator /=(string_type & s)364 path& operator/=(string_type& s) { return this->operator/=(path(s)); } 365 append(const value_type * ptr)366 path& append(const value_type* ptr) // required in case ptr overlaps *this 367 { 368 this->operator/=(ptr); 369 return *this; 370 } 371 append(const value_type * ptr,const codecvt_type &)372 path& append(const value_type* ptr, const codecvt_type&) // required in case ptr overlaps *this 373 { 374 this->operator/=(ptr); 375 return *this; 376 } 377 378 template <class Source> 379 path& append(Source const& source); 380 381 template <class Source> 382 path& append(Source const& source, const codecvt_type& cvt); 383 384 template <class InputIterator> 385 path& append(InputIterator begin, InputIterator end); 386 387 template <class InputIterator> 388 path& append(InputIterator begin, InputIterator end, const codecvt_type& cvt); 389 390 // ----- modifiers ----- 391 clear()392 void clear() BOOST_NOEXCEPT { m_pathname.clear(); } 393 # ifdef BOOST_POSIX_API make_preferred()394 path& make_preferred() { return *this; } // POSIX no effect 395 # else // BOOST_WINDOWS_API 396 BOOST_FILESYSTEM_DECL path& make_preferred(); // change slashes to backslashes 397 # endif 398 BOOST_FILESYSTEM_DECL path& remove_filename(); 399 BOOST_FILESYSTEM_DECL path& remove_trailing_separator(); 400 BOOST_FILESYSTEM_DECL path& replace_extension(const path& new_extension = path()); swap(path & rhs)401 void swap(path& rhs) BOOST_NOEXCEPT { m_pathname.swap(rhs.m_pathname); } 402 403 // ----- observers ----- 404 405 // For operating systems that format file paths differently than directory 406 // paths, return values from observers are formatted as file names unless there 407 // is a trailing separator, in which case returns are formatted as directory 408 // paths. POSIX and Windows make no such distinction. 409 410 // Implementations are permitted to return const values or const references. 411 412 // The string or path returned by an observer are specified as being formatted 413 // as "native" or "generic". 414 // 415 // For POSIX, these are all the same format; slashes and backslashes are as input and 416 // are not modified. 417 // 418 // For Windows, native: as input; slashes and backslashes are not modified; 419 // this is the format of the internally stored string. 420 // generic: backslashes are converted to slashes 421 422 // ----- native format observers ----- 423 native() const424 const string_type& native() const BOOST_NOEXCEPT { return m_pathname; } c_str() const425 const value_type* c_str() const BOOST_NOEXCEPT { return m_pathname.c_str(); } size() const426 string_type::size_type size() const BOOST_NOEXCEPT { return m_pathname.size(); } 427 428 template <class String> 429 String string() const; 430 431 template <class String> 432 String string(const codecvt_type& cvt) const; 433 434 # ifdef BOOST_WINDOWS_API string() const435 const std::string string() const 436 { 437 std::string tmp; 438 if (!m_pathname.empty()) 439 path_traits::convert(m_pathname.c_str(), m_pathname.c_str()+m_pathname.size(), 440 tmp); 441 return tmp; 442 } string(const codecvt_type & cvt) const443 const std::string string(const codecvt_type& cvt) const 444 { 445 std::string tmp; 446 if (!m_pathname.empty()) 447 path_traits::convert(m_pathname.c_str(), m_pathname.c_str()+m_pathname.size(), 448 tmp, cvt); 449 return tmp; 450 } 451 452 // string_type is std::wstring, so there is no conversion wstring() const453 const std::wstring& wstring() const { return m_pathname; } wstring(const codecvt_type &) const454 const std::wstring& wstring(const codecvt_type&) const { return m_pathname; } 455 # else // BOOST_POSIX_API 456 // string_type is std::string, so there is no conversion string() const457 const std::string& string() const { return m_pathname; } string(const codecvt_type &) const458 const std::string& string(const codecvt_type&) const { return m_pathname; } 459 wstring() const460 const std::wstring wstring() const 461 { 462 std::wstring tmp; 463 if (!m_pathname.empty()) 464 path_traits::convert(m_pathname.c_str(), m_pathname.c_str()+m_pathname.size(), 465 tmp); 466 return tmp; 467 } wstring(const codecvt_type & cvt) const468 const std::wstring wstring(const codecvt_type& cvt) const 469 { 470 std::wstring tmp; 471 if (!m_pathname.empty()) 472 path_traits::convert(m_pathname.c_str(), m_pathname.c_str()+m_pathname.size(), 473 tmp, cvt); 474 return tmp; 475 } 476 # endif 477 478 // ----- generic format observers ----- 479 480 // Experimental generic function returning generic formatted path (i.e. separators 481 // are forward slashes). Motivation: simpler than a family of generic_*string 482 // functions. 483 # ifdef BOOST_WINDOWS_API 484 BOOST_FILESYSTEM_DECL path generic_path() const; 485 # else generic_path() const486 path generic_path() const { return path(*this); } 487 # endif 488 489 template <class String> 490 String generic_string() const; 491 492 template <class String> 493 String generic_string(const codecvt_type& cvt) const; 494 495 # ifdef BOOST_WINDOWS_API generic_string() const496 const std::string generic_string() const { return generic_path().string(); } generic_string(const codecvt_type & cvt) const497 const std::string generic_string(const codecvt_type& cvt) const { return generic_path().string(cvt); } generic_wstring() const498 const std::wstring generic_wstring() const { return generic_path().wstring(); } generic_wstring(const codecvt_type &) const499 const std::wstring generic_wstring(const codecvt_type&) const { return generic_wstring(); } 500 # else // BOOST_POSIX_API 501 // On POSIX-like systems, the generic format is the same as the native format generic_string() const502 const std::string& generic_string() const { return m_pathname; } generic_string(const codecvt_type &) const503 const std::string& generic_string(const codecvt_type&) const { return m_pathname; } generic_wstring() const504 const std::wstring generic_wstring() const { return this->wstring(); } generic_wstring(const codecvt_type & cvt) const505 const std::wstring generic_wstring(const codecvt_type& cvt) const { return this->wstring(cvt); } 506 # endif 507 508 // ----- compare ----- 509 510 BOOST_FILESYSTEM_DECL int compare(const path& p) const BOOST_NOEXCEPT; // generic, lexicographical compare(const std::string & s) const511 int compare(const std::string& s) const { return compare(path(s)); } compare(const value_type * s) const512 int compare(const value_type* s) const { return compare(path(s)); } 513 514 // ----- decomposition ----- 515 516 BOOST_FILESYSTEM_DECL path root_path() const; 517 BOOST_FILESYSTEM_DECL path root_name() const; // returns 0 or 1 element path 518 // even on POSIX, root_name() is non-empty() for network paths 519 BOOST_FILESYSTEM_DECL path root_directory() const; // returns 0 or 1 element path 520 BOOST_FILESYSTEM_DECL path relative_path() const; 521 BOOST_FILESYSTEM_DECL path parent_path() const; 522 BOOST_FILESYSTEM_DECL path filename() const; // returns 0 or 1 element path 523 BOOST_FILESYSTEM_DECL path stem() const; // returns 0 or 1 element path 524 BOOST_FILESYSTEM_DECL path extension() const; // returns 0 or 1 element path 525 526 // ----- query ----- 527 empty() const528 bool empty() const BOOST_NOEXCEPT { return m_pathname.empty(); } 529 bool filename_is_dot() const; 530 bool filename_is_dot_dot() const; has_root_path() const531 bool has_root_path() const { return has_root_directory() || has_root_name(); } has_root_name() const532 bool has_root_name() const { return !root_name().empty(); } has_root_directory() const533 bool has_root_directory() const { return !root_directory().empty(); } has_relative_path() const534 bool has_relative_path() const { return !relative_path().empty(); } has_parent_path() const535 bool has_parent_path() const { return !parent_path().empty(); } has_filename() const536 bool has_filename() const { return !m_pathname.empty(); } has_stem() const537 bool has_stem() const { return !stem().empty(); } has_extension() const538 bool has_extension() const { return !extension().empty(); } is_relative() const539 bool is_relative() const { return !is_absolute(); } is_absolute() const540 bool is_absolute() const 541 { 542 // Windows CE has no root name (aka drive letters) 543 # if defined(BOOST_WINDOWS_API) && !defined(UNDER_CE) 544 return has_root_name() && has_root_directory(); 545 # else 546 return has_root_directory(); 547 # endif 548 } 549 550 // ----- lexical operations ----- 551 552 BOOST_FILESYSTEM_DECL path lexically_normal() const; 553 BOOST_FILESYSTEM_DECL path lexically_relative(const path& base) const; lexically_proximate(const path & base) const554 path lexically_proximate(const path& base) const 555 { 556 path tmp(lexically_relative(base)); 557 return tmp.empty() ? *this : tmp; 558 } 559 560 // ----- iterators ----- 561 562 class iterator; 563 typedef iterator const_iterator; 564 class reverse_iterator; 565 typedef reverse_iterator const_reverse_iterator; 566 567 BOOST_FILESYSTEM_DECL iterator begin() const; 568 BOOST_FILESYSTEM_DECL iterator end() const; 569 reverse_iterator rbegin() const; 570 reverse_iterator rend() const; 571 572 // ----- static member functions ----- 573 574 static BOOST_FILESYSTEM_DECL std::locale imbue(const std::locale& loc); 575 static BOOST_FILESYSTEM_DECL const codecvt_type& codecvt(); 576 577 // ----- deprecated functions ----- 578 579 # if defined(BOOST_FILESYSTEM_DEPRECATED) && defined(BOOST_FILESYSTEM_NO_DEPRECATED) 580 # error both BOOST_FILESYSTEM_DEPRECATED and BOOST_FILESYSTEM_NO_DEPRECATED are defined 581 # endif 582 583 # if !defined(BOOST_FILESYSTEM_NO_DEPRECATED) 584 // recently deprecated functions supplied by default normalize()585 path& normalize() { 586 path tmp(lexically_normal()); 587 m_pathname.swap(tmp.m_pathname); 588 return *this; 589 } remove_leaf()590 path& remove_leaf() { return remove_filename(); } leaf() const591 path leaf() const { return filename(); } branch_path() const592 path branch_path() const { return parent_path(); } generic() const593 path generic() const { return generic_path(); } has_leaf() const594 bool has_leaf() const { return !m_pathname.empty(); } has_branch_path() const595 bool has_branch_path() const { return !parent_path().empty(); } is_complete() const596 bool is_complete() const { return is_absolute(); } 597 # endif 598 599 # if defined(BOOST_FILESYSTEM_DEPRECATED) 600 // deprecated functions with enough signature or semantic changes that they are 601 // not supplied by default file_string() const602 const std::string file_string() const { return string(); } directory_string() const603 const std::string directory_string() const { return string(); } native_file_string() const604 const std::string native_file_string() const { return string(); } native_directory_string() const605 const std::string native_directory_string() const { return string(); } external_file_string() const606 const string_type external_file_string() const { return native(); } external_directory_string() const607 const string_type external_directory_string() const { return native(); } 608 609 // older functions no longer supported 610 //typedef bool (*name_check)(const std::string & name); 611 //basic_path(const string_type& str, name_check) { operator/=(str); } 612 //basic_path(const typename string_type::value_type* s, name_check) 613 // { operator/=(s);} 614 //static bool default_name_check_writable() { return false; } 615 //static void default_name_check(name_check) {} 616 //static name_check default_name_check() { return 0; } 617 //basic_path& canonize(); 618 # endif 619 620 //--------------------------------------------------------------------------------------// 621 // class path private members // 622 //--------------------------------------------------------------------------------------// 623 624 private: 625 626 # if defined(_MSC_VER) 627 # pragma warning(push) // Save warning settings 628 # pragma warning(disable : 4251) // disable warning: class 'std::basic_string<_Elem,_Traits,_Ax>' 629 # endif // needs to have dll-interface... 630 /* 631 m_pathname has the type, encoding, and format required by the native 632 operating system. Thus for POSIX and Windows there is no conversion for 633 passing m_pathname.c_str() to the O/S API or when obtaining a path from the 634 O/S API. POSIX encoding is unspecified other than for dot and slash 635 characters; POSIX just treats paths as a sequence of bytes. Windows 636 encoding is UCS-2 or UTF-16 depending on the version. 637 */ 638 string_type m_pathname; // Windows: as input; backslashes NOT converted to slashes, 639 // slashes NOT converted to backslashes 640 # if defined(_MSC_VER) 641 # pragma warning(pop) // restore warning settings. 642 # endif 643 644 // Returns: If separator is to be appended, m_pathname.size() before append. Otherwise 0. 645 // Note: An append is never performed if size()==0, so a returned 0 is unambiguous. 646 BOOST_FILESYSTEM_DECL string_type::size_type m_append_separator_if_needed(); 647 648 BOOST_FILESYSTEM_DECL void m_erase_redundant_separator(string_type::size_type sep_pos); 649 BOOST_FILESYSTEM_DECL string_type::size_type m_parent_path_end() const; 650 651 // Was qualified; como433beta8 reports: 652 // warning #427-D: qualified name is not allowed in member declaration 653 friend class iterator; 654 friend bool operator<(const path& lhs, const path& rhs); 655 656 // see path::iterator::increment/decrement comment below 657 static BOOST_FILESYSTEM_DECL void m_path_iterator_increment(path::iterator& it); 658 static BOOST_FILESYSTEM_DECL void m_path_iterator_decrement(path::iterator& it); 659 660 }; // class path 661 662 namespace detail 663 { 664 BOOST_FILESYSTEM_DECL 665 int lex_compare(path::iterator first1, path::iterator last1, 666 path::iterator first2, path::iterator last2); 667 BOOST_FILESYSTEM_DECL 668 const path& dot_path(); 669 BOOST_FILESYSTEM_DECL 670 const path& dot_dot_path(); 671 } 672 673 # ifndef BOOST_FILESYSTEM_NO_DEPRECATED 674 typedef path wpath; 675 # endif 676 677 //------------------------------------------------------------------------------------// 678 // class path::iterator // 679 //------------------------------------------------------------------------------------// 680 681 class path::iterator 682 : public boost::iterator_facade< 683 path::iterator, 684 path const, 685 boost::bidirectional_traversal_tag > 686 { 687 private: 688 friend class boost::iterator_core_access; 689 friend class boost::filesystem::path; 690 friend class boost::filesystem::path::reverse_iterator; 691 friend void m_path_iterator_increment(path::iterator & it); 692 friend void m_path_iterator_decrement(path::iterator & it); 693 dereference() const694 const path& dereference() const { return m_element; } 695 equal(const iterator & rhs) const696 bool equal(const iterator & rhs) const 697 { 698 return m_path_ptr == rhs.m_path_ptr && m_pos == rhs.m_pos; 699 } 700 701 // iterator_facade derived classes don't seem to like implementations in 702 // separate translation unit dll's, so forward to class path static members increment()703 void increment() { m_path_iterator_increment(*this); } decrement()704 void decrement() { m_path_iterator_decrement(*this); } 705 706 path m_element; // current element 707 const path* m_path_ptr; // path being iterated over 708 string_type::size_type m_pos; // position of m_element in 709 // m_path_ptr->m_pathname. 710 // if m_element is implicit dot, m_pos is the 711 // position of the last separator in the path. 712 // end() iterator is indicated by 713 // m_pos == m_path_ptr->m_pathname.size() 714 }; // path::iterator 715 716 //------------------------------------------------------------------------------------// 717 // class path::reverse_iterator // 718 //------------------------------------------------------------------------------------// 719 720 class path::reverse_iterator 721 : public boost::iterator_facade< 722 path::reverse_iterator, 723 path const, 724 boost::bidirectional_traversal_tag > 725 { 726 public: reverse_iterator(iterator itr)727 explicit reverse_iterator(iterator itr) : m_itr(itr) 728 { 729 if (itr != itr.m_path_ptr->begin()) 730 m_element = *--itr; 731 } 732 733 private: 734 friend class boost::iterator_core_access; 735 friend class boost::filesystem::path; 736 dereference() const737 const path& dereference() const { return m_element; } equal(const reverse_iterator & rhs) const738 bool equal(const reverse_iterator& rhs) const { return m_itr == rhs.m_itr; } increment()739 void increment() 740 { 741 --m_itr; 742 if (m_itr != m_itr.m_path_ptr->begin()) 743 { 744 iterator tmp = m_itr; 745 m_element = *--tmp; 746 } 747 } decrement()748 void decrement() 749 { 750 m_element = *m_itr; 751 ++m_itr; 752 } 753 754 iterator m_itr; 755 path m_element; 756 757 }; // path::reverse_iterator 758 759 //------------------------------------------------------------------------------------// 760 // // 761 // non-member functions // 762 // // 763 //------------------------------------------------------------------------------------// 764 765 // std::lexicographical_compare would infinitely recurse because path iterators 766 // yield paths, so provide a path aware version lexicographical_compare(path::iterator first1,path::iterator last1,path::iterator first2,path::iterator last2)767 inline bool lexicographical_compare(path::iterator first1, path::iterator last1, 768 path::iterator first2, path::iterator last2) 769 { return detail::lex_compare(first1, last1, first2, last2) < 0; } 770 operator ==(const path & lhs,const path & rhs)771 inline bool operator==(const path& lhs, const path& rhs) {return lhs.compare(rhs) == 0;} operator ==(const path & lhs,const path::string_type & rhs)772 inline bool operator==(const path& lhs, const path::string_type& rhs) {return lhs.compare(rhs) == 0;} operator ==(const path::string_type & lhs,const path & rhs)773 inline bool operator==(const path::string_type& lhs, const path& rhs) {return rhs.compare(lhs) == 0;} operator ==(const path & lhs,const path::value_type * rhs)774 inline bool operator==(const path& lhs, const path::value_type* rhs) {return lhs.compare(rhs) == 0;} operator ==(const path::value_type * lhs,const path & rhs)775 inline bool operator==(const path::value_type* lhs, const path& rhs) {return rhs.compare(lhs) == 0;} 776 operator !=(const path & lhs,const path & rhs)777 inline bool operator!=(const path& lhs, const path& rhs) {return lhs.compare(rhs) != 0;} operator !=(const path & lhs,const path::string_type & rhs)778 inline bool operator!=(const path& lhs, const path::string_type& rhs) {return lhs.compare(rhs) != 0;} operator !=(const path::string_type & lhs,const path & rhs)779 inline bool operator!=(const path::string_type& lhs, const path& rhs) {return rhs.compare(lhs) != 0;} operator !=(const path & lhs,const path::value_type * rhs)780 inline bool operator!=(const path& lhs, const path::value_type* rhs) {return lhs.compare(rhs) != 0;} operator !=(const path::value_type * lhs,const path & rhs)781 inline bool operator!=(const path::value_type* lhs, const path& rhs) {return rhs.compare(lhs) != 0;} 782 783 // TODO: why do == and != have additional overloads, but the others don't? 784 operator <(const path & lhs,const path & rhs)785 inline bool operator<(const path& lhs, const path& rhs) {return lhs.compare(rhs) < 0;} operator <=(const path & lhs,const path & rhs)786 inline bool operator<=(const path& lhs, const path& rhs) {return !(rhs < lhs);} operator >(const path & lhs,const path & rhs)787 inline bool operator> (const path& lhs, const path& rhs) {return rhs < lhs;} operator >=(const path & lhs,const path & rhs)788 inline bool operator>=(const path& lhs, const path& rhs) {return !(lhs < rhs);} 789 hash_value(const path & x)790 inline std::size_t hash_value(const path& x) BOOST_NOEXCEPT 791 { 792 # ifdef BOOST_WINDOWS_API 793 std::size_t seed = 0; 794 for(const path::value_type* it = x.c_str(); *it; ++it) 795 hash_combine(seed, *it == L'/' ? L'\\' : *it); 796 return seed; 797 # else // BOOST_POSIX_API 798 return hash_range(x.native().begin(), x.native().end()); 799 # endif 800 } 801 swap(path & lhs,path & rhs)802 inline void swap(path& lhs, path& rhs) BOOST_NOEXCEPT { lhs.swap(rhs); } 803 operator /(const path & lhs,const path & rhs)804 inline path operator/(const path& lhs, const path& rhs) 805 { 806 path p = lhs; 807 p /= rhs; 808 return p; 809 } 810 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) operator /(path && lhs,const path & rhs)811 inline path operator/(path&& lhs, const path& rhs) 812 { 813 lhs /= rhs; 814 return std::move(lhs); 815 } 816 # endif 817 818 // inserters and extractors 819 // use boost::io::quoted() to handle spaces in paths 820 // use '&' as escape character to ease use for Windows paths 821 822 template <class Char, class Traits> 823 inline std::basic_ostream<Char, Traits>& operator <<(std::basic_ostream<Char,Traits> & os,const path & p)824 operator<<(std::basic_ostream<Char, Traits>& os, const path& p) 825 { 826 return os 827 << boost::io::quoted(p.template string<std::basic_string<Char> >(), static_cast<Char>('&')); 828 } 829 830 template <class Char, class Traits> 831 inline std::basic_istream<Char, Traits>& operator >>(std::basic_istream<Char,Traits> & is,path & p)832 operator>>(std::basic_istream<Char, Traits>& is, path& p) 833 { 834 std::basic_string<Char> str; 835 is >> boost::io::quoted(str, static_cast<Char>('&')); 836 p = str; 837 return is; 838 } 839 840 // name_checks 841 842 // These functions are holdovers from version 1. It isn't clear they have much 843 // usefulness, or how to generalize them for later versions. 844 845 BOOST_FILESYSTEM_DECL bool portable_posix_name(const std::string & name); 846 BOOST_FILESYSTEM_DECL bool windows_name(const std::string & name); 847 BOOST_FILESYSTEM_DECL bool portable_name(const std::string & name); 848 BOOST_FILESYSTEM_DECL bool portable_directory_name(const std::string & name); 849 BOOST_FILESYSTEM_DECL bool portable_file_name(const std::string & name); 850 BOOST_FILESYSTEM_DECL bool native(const std::string & name); 851 852 namespace detail 853 { 854 // For POSIX, is_directory_separator() and is_element_separator() are identical since 855 // a forward slash is the only valid directory separator and also the only valid 856 // element separator. For Windows, forward slash and back slash are the possible 857 // directory separators, but colon (example: "c:foo") is also an element separator. 858 is_directory_separator(path::value_type c)859 inline bool is_directory_separator(path::value_type c) BOOST_NOEXCEPT 860 { 861 return c == path::separator 862 # ifdef BOOST_WINDOWS_API 863 || c == path::preferred_separator 864 # endif 865 ; 866 } is_element_separator(path::value_type c)867 inline bool is_element_separator(path::value_type c) BOOST_NOEXCEPT 868 { 869 return c == path::separator 870 # ifdef BOOST_WINDOWS_API 871 || c == path::preferred_separator || c == L':' 872 # endif 873 ; 874 } 875 } // namespace detail 876 877 //------------------------------------------------------------------------------------// 878 // class path miscellaneous function implementations // 879 //------------------------------------------------------------------------------------// 880 rbegin() const881 inline path::reverse_iterator path::rbegin() const { return reverse_iterator(end()); } rend() const882 inline path::reverse_iterator path::rend() const { return reverse_iterator(begin()); } 883 filename_is_dot() const884 inline bool path::filename_is_dot() const 885 { 886 // implicit dot is tricky, so actually call filename(); see path::filename() example 887 // in reference.html 888 path p(filename()); 889 return p.size() == 1 && *p.c_str() == dot; 890 } 891 filename_is_dot_dot() const892 inline bool path::filename_is_dot_dot() const 893 { 894 return size() >= 2 && m_pathname[size()-1] == dot && m_pathname[size()-2] == dot 895 && (m_pathname.size() == 2 || detail::is_element_separator(m_pathname[size()-3])); 896 // use detail::is_element_separator() rather than detail::is_directory_separator 897 // to deal with "c:.." edge case on Windows when ':' acts as a separator 898 } 899 900 //--------------------------------------------------------------------------------------// 901 // class path member template implementation // 902 //--------------------------------------------------------------------------------------// 903 904 template <class InputIterator> append(InputIterator begin,InputIterator end)905 path& path::append(InputIterator begin, InputIterator end) 906 { 907 if (begin == end) 908 return *this; 909 string_type::size_type sep_pos(m_append_separator_if_needed()); 910 std::basic_string<typename std::iterator_traits<InputIterator>::value_type> 911 seq(begin, end); 912 path_traits::convert(seq.c_str(), seq.c_str()+seq.size(), m_pathname); 913 if (sep_pos) 914 m_erase_redundant_separator(sep_pos); 915 return *this; 916 } 917 918 template <class InputIterator> append(InputIterator begin,InputIterator end,const codecvt_type & cvt)919 path& path::append(InputIterator begin, InputIterator end, const codecvt_type& cvt) 920 { 921 if (begin == end) 922 return *this; 923 string_type::size_type sep_pos(m_append_separator_if_needed()); 924 std::basic_string<typename std::iterator_traits<InputIterator>::value_type> 925 seq(begin, end); 926 path_traits::convert(seq.c_str(), seq.c_str()+seq.size(), m_pathname, cvt); 927 if (sep_pos) 928 m_erase_redundant_separator(sep_pos); 929 return *this; 930 } 931 932 template <class Source> append(Source const & source)933 path& path::append(Source const& source) 934 { 935 if (path_traits::empty(source)) 936 return *this; 937 string_type::size_type sep_pos(m_append_separator_if_needed()); 938 path_traits::dispatch(source, m_pathname); 939 if (sep_pos) 940 m_erase_redundant_separator(sep_pos); 941 return *this; 942 } 943 944 template <class Source> append(Source const & source,const codecvt_type & cvt)945 path& path::append(Source const& source, const codecvt_type& cvt) 946 { 947 if (path_traits::empty(source)) 948 return *this; 949 string_type::size_type sep_pos(m_append_separator_if_needed()); 950 path_traits::dispatch(source, m_pathname, cvt); 951 if (sep_pos) 952 m_erase_redundant_separator(sep_pos); 953 return *this; 954 } 955 956 //--------------------------------------------------------------------------------------// 957 // class path member template specializations // 958 //--------------------------------------------------------------------------------------// 959 960 template <> inline string() const961 std::string path::string<std::string>() const 962 { return string(); } 963 964 template <> inline string() const965 std::wstring path::string<std::wstring>() const 966 { return wstring(); } 967 968 template <> inline string(const codecvt_type & cvt) const969 std::string path::string<std::string>(const codecvt_type& cvt) const 970 { return string(cvt); } 971 972 template <> inline string(const codecvt_type & cvt) const973 std::wstring path::string<std::wstring>(const codecvt_type& cvt) const 974 { return wstring(cvt); } 975 976 template <> inline generic_string() const977 std::string path::generic_string<std::string>() const 978 { return generic_string(); } 979 980 template <> inline generic_string() const981 std::wstring path::generic_string<std::wstring>() const 982 { return generic_wstring(); } 983 984 template <> inline generic_string(const codecvt_type & cvt) const985 std::string path::generic_string<std::string>(const codecvt_type& cvt) const 986 { return generic_string(cvt); } 987 988 template <> inline generic_string(const codecvt_type & cvt) const989 std::wstring path::generic_string<std::wstring>(const codecvt_type& cvt) const 990 { return generic_wstring(cvt); } 991 992 //--------------------------------------------------------------------------------------// 993 // path_traits convert function implementations // 994 // requiring path::codecvt() be visable // 995 //--------------------------------------------------------------------------------------// 996 997 namespace path_traits 998 { // without codecvt 999 1000 inline convert(const char * from,const char * from_end,std::wstring & to)1001 void convert(const char* from, 1002 const char* from_end, // 0 for null terminated MBCS 1003 std::wstring & to) 1004 { 1005 convert(from, from_end, to, path::codecvt()); 1006 } 1007 1008 inline convert(const wchar_t * from,const wchar_t * from_end,std::string & to)1009 void convert(const wchar_t* from, 1010 const wchar_t* from_end, // 0 for null terminated MBCS 1011 std::string & to) 1012 { 1013 convert(from, from_end, to, path::codecvt()); 1014 } 1015 1016 inline convert(const char * from,std::wstring & to)1017 void convert(const char* from, 1018 std::wstring & to) 1019 { 1020 BOOST_ASSERT(!!from); 1021 convert(from, 0, to, path::codecvt()); 1022 } 1023 1024 inline convert(const wchar_t * from,std::string & to)1025 void convert(const wchar_t* from, 1026 std::string & to) 1027 { 1028 BOOST_ASSERT(!!from); 1029 convert(from, 0, to, path::codecvt()); 1030 } 1031 } // namespace path_traits 1032 } // namespace filesystem 1033 } // namespace boost 1034 1035 //----------------------------------------------------------------------------// 1036 1037 #include <boost/config/abi_suffix.hpp> // pops abi_prefix.hpp pragmas 1038 1039 #endif // BOOST_FILESYSTEM_PATH_HPP 1040