boost/filesystem/directory.hpp

   1 //  boost/filesystem/directory.hpp  ---------------------------------------------------//
   2
   3 //  Copyright Beman Dawes 2002-2009
   4 //  Copyright Jan Langer 2002
   5 //  Copyright Dietmar Kuehl 2001
   6 //  Copyright Vladimir Prus 2002
   7 //  Copyright Andrey Semashev 2019
   8
   9 //  Distributed under the Boost Software License, Version 1.0.
  10 //  See http://www.boost.org/LICENSE_1_0.txt
  11
  12 //  Library home page: http://www.boost.org/libs/filesystem
  13
  14 //--------------------------------------------------------------------------------------//
  15
  16 #ifndef BOOST_FILESYSTEM3_DIRECTORY_HPP
  17 #define BOOST_FILESYSTEM3_DIRECTORY_HPP
  18
  19 #include <boost/config.hpp>
  20
  21 # if defined( BOOST_NO_STD_WSTRING )
  22 #   error Configuration not supported: Boost.Filesystem V3 and later requires std::wstring support
  23 # endif
  24
  25 #include <boost/filesystem/config.hpp>
  26 #include <boost/filesystem/path.hpp>
  27 #include <boost/filesystem/file_status.hpp>
  28
  29 #include <string>
  30 #include <vector>
  31 #include <utility> // std::move
  32
  33 #include <boost/assert.hpp>
  34 #include <boost/core/scoped_enum.hpp>
  35 #include <boost/detail/bitmask.hpp>
  36 #include <boost/system/error_code.hpp>
  37 #include <boost/smart_ptr/intrusive_ptr.hpp>
  38 #include <boost/smart_ptr/intrusive_ref_counter.hpp>
  39 #include <boost/iterator/iterator_facade.hpp>
  40 #include <boost/iterator/iterator_categories.hpp>
  41
  42 #include <boost/config/abi_prefix.hpp> // must be the last #include
  43
  44 //--------------------------------------------------------------------------------------//
  45
  46 namespace boost {
  47 namespace filesystem {
  48
  49 //--------------------------------------------------------------------------------------//
  50 //                                                                                      //
  51 //                                 directory_entry                                      //
  52 //                                                                                      //
  53 //--------------------------------------------------------------------------------------//
  54
  55 //  GCC has a problem with a member function named path within a namespace or
  56 //  sub-namespace that also has a class named path. The workaround is to always
  57 //  fully qualify the name path when it refers to the class name.
  58
  59 class directory_entry
  60 {
  61 public:
  62   typedef boost::filesystem::path::value_type value_type;   // enables class path ctor taking directory_entry
  63
  64   directory_entry() BOOST_NOEXCEPT {}
  65   explicit directory_entry(const boost::filesystem::path& p) :
  66     m_path(p), m_status(file_status()), m_symlink_status(file_status())
  67   {
  68   }
  69   directory_entry(const boost::filesystem::path& p,
  70     file_status st, file_status symlink_st = file_status()) :
  71     m_path(p), m_status(st), m_symlink_status(symlink_st)
  72   {
  73   }
  74
  75   directory_entry(const directory_entry& rhs) :
  76     m_path(rhs.m_path), m_status(rhs.m_status), m_symlink_status(rhs.m_symlink_status)
  77   {
  78   }
  79
  80   directory_entry& operator=(const directory_entry& rhs)
  81   {
  82     m_path = rhs.m_path;
  83     m_status = rhs.m_status;
  84     m_symlink_status = rhs.m_symlink_status;
  85     return *this;
  86   }
  87
  88   //  As of October 2015 the interaction between noexcept and =default is so troublesome
  89   //  for VC++, GCC, and probably other compilers, that =default is not used with noexcept
  90   //  functions. GCC is not even consistent for the same release on different platforms.
  91
  92 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
  93   directory_entry(directory_entry&& rhs) BOOST_NOEXCEPT :
  94     m_path(std::move(rhs.m_path)), m_status(std::move(rhs.m_status)), m_symlink_status(std::move(rhs.m_symlink_status))
  95   {
  96   }
  97   directory_entry& operator=(directory_entry&& rhs) BOOST_NOEXCEPT
  98   {
  99     m_path = std::move(rhs.m_path);
 100     m_status = std::move(rhs.m_status);
 101     m_symlink_status = std::move(rhs.m_symlink_status);
 102     return *this;
 103   }
 104 #endif
 105
 106   void assign(const boost::filesystem::path& p,
 107     file_status st = file_status(), file_status symlink_st = file_status())
 108   {
 109     m_path = p;
 110     m_status = st;
 111     m_symlink_status = symlink_st;
 112   }
 113
 114   void replace_filename(const boost::filesystem::path& p,
 115     file_status st = file_status(), file_status symlink_st = file_status())
 116   {
 117     m_path.remove_filename();
 118     m_path /= p;
 119     m_status = st;
 120     m_symlink_status = symlink_st;
 121   }
 122
 123 # ifndef BOOST_FILESYSTEM_NO_DEPRECATED
 124   void replace_leaf(const boost::filesystem::path& p, file_status st, file_status symlink_st)
 125   {
 126     replace_filename(p, st, symlink_st);
 127   }
 128 # endif
 129
 130   const boost::filesystem::path& path() const BOOST_NOEXCEPT { return m_path; }
 131   operator const boost::filesystem::path&() const BOOST_NOEXCEPT { return m_path; }
 132   file_status status() const { return get_status(); }
 133   file_status status(system::error_code& ec) const BOOST_NOEXCEPT { return get_status(&ec); }
 134   file_status symlink_status() const { return get_symlink_status(); }
 135   file_status symlink_status(system::error_code& ec) const BOOST_NOEXCEPT { return get_symlink_status(&ec); }
 136
 137   bool operator==(const directory_entry& rhs) const BOOST_NOEXCEPT { return m_path == rhs.m_path; }
 138   bool operator!=(const directory_entry& rhs) const BOOST_NOEXCEPT { return m_path != rhs.m_path; }
 139   bool operator< (const directory_entry& rhs) const BOOST_NOEXCEPT { return m_path < rhs.m_path; }
 140   bool operator<=(const directory_entry& rhs) const BOOST_NOEXCEPT { return m_path <= rhs.m_path; }
 141   bool operator> (const directory_entry& rhs) const BOOST_NOEXCEPT { return m_path > rhs.m_path; }
 142   bool operator>=(const directory_entry& rhs) const BOOST_NOEXCEPT { return m_path >= rhs.m_path; }
 143
 144 private:
 145   BOOST_FILESYSTEM_DECL file_status get_status(system::error_code* ec=0) const;
 146   BOOST_FILESYSTEM_DECL file_status get_symlink_status(system::error_code* ec=0) const;
 147
 148 private:
 149   boost::filesystem::path   m_path;
 150   mutable file_status       m_status;           // stat()-like
 151   mutable file_status       m_symlink_status;   // lstat()-like
 152 }; // directory_entry
 153
 154
 155 //--------------------------------------------------------------------------------------//
 156 //                                                                                      //
 157 //                            directory_entry overloads                                 //
 158 //                                                                                      //
 159 //--------------------------------------------------------------------------------------//
 160
 161 //  Without these functions, calling (for example) 'is_directory' with a 'directory_entry' results in:
 162 //  - a conversion to 'path' using 'operator const boost::filesystem::path&()',
 163 //  - then a call to 'is_directory(const path& p)' which recomputes the status with 'detail::status(p)'.
 164 //
 165 //  These functions avoid a costly recomputation of the status if one calls 'is_directory(e)' instead of 'is_directory(e.status)'
 166
 167 inline file_status status         (const directory_entry& e) BOOST_NOEXCEPT { return e.status(); }
 168 inline bool        type_present   (const directory_entry& e) BOOST_NOEXCEPT { return filesystem::type_present(e.status()); }
 169 inline bool        status_known   (const directory_entry& e) BOOST_NOEXCEPT { return filesystem::status_known(e.status()); }
 170 inline bool        exists         (const directory_entry& e) BOOST_NOEXCEPT { return filesystem::exists(e.status()); }
 171 inline bool        is_regular_file(const directory_entry& e) BOOST_NOEXCEPT { return filesystem::is_regular_file(e.status()); }
 172 inline bool        is_directory   (const directory_entry& e) BOOST_NOEXCEPT { return filesystem::is_directory(e.status()); }
 173 inline bool        is_symlink     (const directory_entry& e) BOOST_NOEXCEPT { return filesystem::is_symlink(e.status()); }
 174 inline bool        is_other       (const directory_entry& e) BOOST_NOEXCEPT { return filesystem::is_other(e.status()); }
 175 #ifndef BOOST_FILESYSTEM_NO_DEPRECATED
 176 inline bool        is_regular     (const directory_entry& e) BOOST_NOEXCEPT { return filesystem::is_regular(e.status()); }
 177 #endif
 178
 179 //--------------------------------------------------------------------------------------//
 180 //                                                                                      //
 181 //                            directory_iterator helpers                                //
 182 //                                                                                      //
 183 //--------------------------------------------------------------------------------------//
 184
 185 BOOST_SCOPED_ENUM_UT_DECLARE_BEGIN(directory_options, unsigned int)
 186 {
 187   none = 0u,
 188   skip_permission_denied = 1u,        // if a directory cannot be opened because of insufficient permissions, pretend that the directory is empty
 189   follow_directory_symlink = 1u << 1, // recursive_directory_iterator: follow directory symlinks
 190   skip_dangling_symlinks = 1u << 2,   // non-standard extension for recursive_directory_iterator: don't follow dangling directory symlinks,
 191   pop_on_error = 1u << 3,             // non-standard extension for recursive_directory_iterator: instead of producing an end iterator on errors,
 192                                       // repeatedly invoke pop() until it succeeds or the iterator becomes equal to end iterator
 193   _detail_no_push = 1u << 4           // internal use only
 194 }
 195 BOOST_SCOPED_ENUM_DECLARE_END(directory_options)
 196
 197 BOOST_BITMASK(BOOST_SCOPED_ENUM_NATIVE(directory_options))
 198
 199 class directory_iterator;
 200
 201 namespace detail {
 202
 203 BOOST_FILESYSTEM_DECL
 204 system::error_code dir_itr_close(// never throws()
 205   void*& handle
 206 #if defined(BOOST_POSIX_API)
 207   , void*& buffer
 208 #endif
 209 ) BOOST_NOEXCEPT;
 210
 211 struct dir_itr_imp :
 212   public boost::intrusive_ref_counter< dir_itr_imp >
 213 {
 214   directory_entry  dir_entry;
 215   void*            handle;
 216
 217 #if defined(BOOST_POSIX_API)
 218   void*            buffer;  // see dir_itr_increment implementation
 219 #endif
 220
 221   dir_itr_imp() BOOST_NOEXCEPT :
 222     handle(0)
 223 #if defined(BOOST_POSIX_API)
 224     , buffer(0)
 225 #endif
 226   {
 227   }
 228
 229   ~dir_itr_imp() BOOST_NOEXCEPT
 230   {
 231     dir_itr_close(handle
 232 #if defined(BOOST_POSIX_API)
 233        , buffer
 234 #endif
 235     );
 236   }
 237 };
 238
 239 // see path::iterator: comment below
 240 BOOST_FILESYSTEM_DECL void directory_iterator_construct(directory_iterator& it, const path& p, unsigned int opts, system::error_code* ec);
 241 BOOST_FILESYSTEM_DECL void directory_iterator_increment(directory_iterator& it, system::error_code* ec);
 242
 243 }  // namespace detail
 244
 245 //--------------------------------------------------------------------------------------//
 246 //                                                                                      //
 247 //                                directory_iterator                                    //
 248 //                                                                                      //
 249 //--------------------------------------------------------------------------------------//
 250
 251 class directory_iterator :
 252   public boost::iterator_facade<
 253     directory_iterator,
 254     directory_entry,
 255     boost::single_pass_traversal_tag
 256   >
 257 {
 258   friend class boost::iterator_core_access;
 259
 260   friend BOOST_FILESYSTEM_DECL void detail::directory_iterator_construct(directory_iterator& it, const path& p, unsigned int opts, system::error_code* ec);
 261   friend BOOST_FILESYSTEM_DECL void detail::directory_iterator_increment(directory_iterator& it, system::error_code* ec);
 262
 263 public:
 264   directory_iterator() BOOST_NOEXCEPT {}  // creates the "end" iterator
 265
 266   // iterator_facade derived classes don't seem to like implementations in
 267   // separate translation unit dll's, so forward to detail functions
 268   explicit directory_iterator(const path& p, BOOST_SCOPED_ENUM_NATIVE(directory_options) opts = directory_options::none)
 269   {
 270     detail::directory_iterator_construct(*this, p, static_cast< unsigned int >(opts), 0);
 271   }
 272
 273   directory_iterator(const path& p, system::error_code& ec) BOOST_NOEXCEPT
 274   {
 275     detail::directory_iterator_construct(*this, p, static_cast< unsigned int >(directory_options::none), &ec);
 276   }
 277
 278   directory_iterator(const path& p, BOOST_SCOPED_ENUM_NATIVE(directory_options) opts, system::error_code& ec) BOOST_NOEXCEPT
 279   {
 280     detail::directory_iterator_construct(*this, p, static_cast< unsigned int >(opts), &ec);
 281   }
 282
 283   BOOST_DEFAULTED_FUNCTION(directory_iterator(directory_iterator const& that), : m_imp(that.m_imp) {})
 284   BOOST_DEFAULTED_FUNCTION(directory_iterator& operator= (directory_iterator const& that), { m_imp = that.m_imp; return *this; })
 285
 286 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 287   directory_iterator(directory_iterator&& that) BOOST_NOEXCEPT :
 288     m_imp(std::move(that.m_imp))
 289   {
 290   }
 291
 292   directory_iterator& operator= (directory_iterator&& that) BOOST_NOEXCEPT
 293   {
 294     m_imp = std::move(that.m_imp);
 295     return *this;
 296   }
 297 #endif // !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 298
 299   directory_iterator& increment(system::error_code& ec) BOOST_NOEXCEPT
 300   {
 301     detail::directory_iterator_increment(*this, &ec);
 302     return *this;
 303   }
 304
 305 private:
 306   boost::iterator_facade<
 307     directory_iterator,
 308     directory_entry,
 309     boost::single_pass_traversal_tag
 310   >::reference dereference() const
 311   {
 312     BOOST_ASSERT_MSG(!is_end(), "attempt to dereference end directory iterator");
 313     return m_imp->dir_entry;
 314   }
 315
 316   void increment() { detail::directory_iterator_increment(*this, 0); }
 317
 318   bool equal(const directory_iterator& rhs) const BOOST_NOEXCEPT
 319   {
 320     return m_imp == rhs.m_imp || (is_end() && rhs.is_end());
 321   }
 322
 323   bool is_end() const BOOST_NOEXCEPT
 324   {
 325     // Note: The check for handle is needed because the iterator can be copied and the copy
 326     // can be incremented to end while the original iterator still refers to the same dir_itr_imp.
 327     return !m_imp || !m_imp->handle;
 328   }
 329
 330 private:
 331   // intrusive_ptr provides the shallow-copy semantics required for single pass iterators
 332   // (i.e. InputIterators). The end iterator is indicated by is_end().
 333   boost::intrusive_ptr< detail::dir_itr_imp > m_imp;
 334 };
 335
 336 //  enable directory_iterator C++11 range-based for statement use  --------------------//
 337
 338 //  begin() and end() are only used by a range-based for statement in the context of
 339 //  auto - thus the top-level const is stripped - so returning const is harmless and
 340 //  emphasizes begin() is just a pass through.
 341 inline const directory_iterator& begin(const directory_iterator& iter) BOOST_NOEXCEPT { return iter; }
 342 inline directory_iterator end(const directory_iterator&) BOOST_NOEXCEPT { return directory_iterator(); }
 343
 344 // enable C++14 generic accessors for range const iterators
 345 inline const directory_iterator& cbegin(const directory_iterator& iter) BOOST_NOEXCEPT { return iter; }
 346 inline directory_iterator cend(const directory_iterator&) BOOST_NOEXCEPT { return directory_iterator(); }
 347
 348 //  enable directory_iterator BOOST_FOREACH  -----------------------------------------//
 349
 350 inline directory_iterator& range_begin(directory_iterator& iter) BOOST_NOEXCEPT { return iter; }
 351 inline directory_iterator range_begin(const directory_iterator& iter) BOOST_NOEXCEPT { return iter; }
 352 inline directory_iterator range_end(directory_iterator&) BOOST_NOEXCEPT { return directory_iterator(); }
 353 inline directory_iterator range_end(const directory_iterator&) BOOST_NOEXCEPT { return directory_iterator(); }
 354
 355 } // namespace filesystem
 356
 357 //  namespace boost template specializations
 358 template<typename C, typename Enabler>
 359 struct range_mutable_iterator;
 360
 361 template<>
 362 struct range_mutable_iterator<boost::filesystem::directory_iterator, void>
 363 {
 364   typedef boost::filesystem::directory_iterator type;
 365 };
 366
 367 template<typename C, typename Enabler>
 368 struct range_const_iterator;
 369
 370 template<>
 371 struct range_const_iterator<boost::filesystem::directory_iterator, void>
 372 {
 373   typedef boost::filesystem::directory_iterator type;
 374 };
 375
 376 namespace filesystem {
 377
 378 //--------------------------------------------------------------------------------------//
 379 //                                                                                      //
 380 //                      recursive_directory_iterator helpers                            //
 381 //                                                                                      //
 382 //--------------------------------------------------------------------------------------//
 383
 384 #if !defined(BOOST_FILESYSTEM_NO_DEPRECATED)
 385 // Deprecated enum, use directory_options instead
 386 BOOST_SCOPED_ENUM_UT_DECLARE_BEGIN(symlink_option, unsigned int)
 387 {
 388   none = static_cast< unsigned int >(directory_options::none),
 389   no_recurse = none,                                                                      // don't follow directory symlinks (default behavior)
 390   recurse = static_cast< unsigned int >(directory_options::follow_directory_symlink),     // follow directory symlinks
 391   _detail_no_push = static_cast< unsigned int >(directory_options::_detail_no_push)       // internal use only
 392 }
 393 BOOST_SCOPED_ENUM_DECLARE_END(symlink_option)
 394
 395 BOOST_BITMASK(BOOST_SCOPED_ENUM_NATIVE(symlink_option))
 396 #endif // BOOST_FILESYSTEM_NO_DEPRECATED
 397
 398 class recursive_directory_iterator;
 399
 400 namespace detail {
 401
 402 struct recur_dir_itr_imp :
 403   public boost::intrusive_ref_counter< recur_dir_itr_imp >
 404 {
 405   typedef directory_iterator element_type;
 406   std::vector< element_type > m_stack;
 407   // directory_options values, declared as unsigned int for ABI compatibility
 408   unsigned int m_options;
 409
 410   explicit recur_dir_itr_imp(unsigned int opts) BOOST_NOEXCEPT : m_options(opts) {}
 411 };
 412
 413 BOOST_FILESYSTEM_DECL void recursive_directory_iterator_construct(recursive_directory_iterator& it, const path& dir_path, unsigned int opts, system::error_code* ec);
 414 BOOST_FILESYSTEM_DECL void recursive_directory_iterator_increment(recursive_directory_iterator& it, system::error_code* ec);
 415 BOOST_FILESYSTEM_DECL void recursive_directory_iterator_pop(recursive_directory_iterator& it, system::error_code* ec);
 416
 417 } // namespace detail
 418
 419 //--------------------------------------------------------------------------------------//
 420 //                                                                                      //
 421 //                           recursive_directory_iterator                               //
 422 //                                                                                      //
 423 //--------------------------------------------------------------------------------------//
 424
 425 class recursive_directory_iterator :
 426   public boost::iterator_facade<
 427     recursive_directory_iterator,
 428     directory_entry,
 429     boost::single_pass_traversal_tag
 430   >
 431 {
 432   friend class boost::iterator_core_access;
 433
 434   friend BOOST_FILESYSTEM_DECL void detail::recursive_directory_iterator_construct(recursive_directory_iterator& it, const path& dir_path, unsigned int opts, system::error_code* ec);
 435   friend BOOST_FILESYSTEM_DECL void detail::recursive_directory_iterator_increment(recursive_directory_iterator& it, system::error_code* ec);
 436   friend BOOST_FILESYSTEM_DECL void detail::recursive_directory_iterator_pop(recursive_directory_iterator& it, system::error_code* ec);
 437
 438 public:
 439   recursive_directory_iterator() BOOST_NOEXCEPT {}  // creates the "end" iterator
 440
 441   explicit recursive_directory_iterator(const path& dir_path)
 442   {
 443     detail::recursive_directory_iterator_construct(*this, dir_path, static_cast< unsigned int >(directory_options::none), 0);
 444   }
 445
 446   recursive_directory_iterator(const path& dir_path, system::error_code& ec)
 447   {
 448     detail::recursive_directory_iterator_construct(*this, dir_path, static_cast< unsigned int >(directory_options::none), &ec);
 449   }
 450
 451   recursive_directory_iterator(const path& dir_path, BOOST_SCOPED_ENUM_NATIVE(directory_options) opts)
 452   {
 453     detail::recursive_directory_iterator_construct(*this, dir_path, static_cast< unsigned int >(opts), 0);
 454   }
 455
 456   recursive_directory_iterator(const path& dir_path, BOOST_SCOPED_ENUM_NATIVE(directory_options) opts, system::error_code& ec)
 457   {
 458     detail::recursive_directory_iterator_construct(*this, dir_path, static_cast< unsigned int >(opts), &ec);
 459   }
 460
 461 #if !defined(BOOST_FILESYSTEM_NO_DEPRECATED)
 462   // Deprecated constructors
 463   recursive_directory_iterator(const path& dir_path, BOOST_SCOPED_ENUM_NATIVE(symlink_option) opts)
 464   {
 465     detail::recursive_directory_iterator_construct(*this, dir_path, static_cast< unsigned int >(opts), 0);
 466   }
 467
 468   recursive_directory_iterator(const path& dir_path, BOOST_SCOPED_ENUM_NATIVE(symlink_option) opts, system::error_code& ec) BOOST_NOEXCEPT
 469   {
 470     detail::recursive_directory_iterator_construct(*this, dir_path, static_cast< unsigned int >(opts), &ec);
 471   }
 472 #endif // BOOST_FILESYSTEM_NO_DEPRECATED
 473
 474   BOOST_DEFAULTED_FUNCTION(recursive_directory_iterator(recursive_directory_iterator const& that), : m_imp(that.m_imp) {})
 475   BOOST_DEFAULTED_FUNCTION(recursive_directory_iterator& operator= (recursive_directory_iterator const& that), { m_imp = that.m_imp; return *this; })
 476
 477 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 478   recursive_directory_iterator(recursive_directory_iterator&& that) BOOST_NOEXCEPT :
 479     m_imp(std::move(that.m_imp))
 480   {
 481   }
 482
 483   recursive_directory_iterator& operator= (recursive_directory_iterator&& that) BOOST_NOEXCEPT
 484   {
 485     m_imp = std::move(that.m_imp);
 486     return *this;
 487   }
 488 #endif // !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 489
 490   recursive_directory_iterator& increment(system::error_code& ec) BOOST_NOEXCEPT
 491   {
 492     detail::recursive_directory_iterator_increment(*this, &ec);
 493     return *this;
 494   }
 495
 496   int depth() const BOOST_NOEXCEPT
 497   {
 498     BOOST_ASSERT_MSG(!is_end(), "depth() on end recursive_directory_iterator");
 499     return static_cast< int >(m_imp->m_stack.size() - 1u);
 500   }
 501
 502   bool recursion_pending() const BOOST_NOEXCEPT
 503   {
 504     BOOST_ASSERT_MSG(!is_end(), "recursion_pending() on end recursive_directory_iterator");
 505     return (m_imp->m_options & static_cast< unsigned int >(directory_options::_detail_no_push)) == 0u;
 506   }
 507
 508 #ifndef BOOST_FILESYSTEM_NO_DEPRECATED
 509   int level() const BOOST_NOEXCEPT { return depth(); }
 510   bool no_push_pending() const BOOST_NOEXCEPT { return !recursion_pending(); }
 511   bool no_push_request() const BOOST_NOEXCEPT { return !recursion_pending(); }
 512 #endif
 513
 514   void pop()
 515   {
 516     detail::recursive_directory_iterator_pop(*this, 0);
 517   }
 518
 519   void pop(system::error_code& ec) BOOST_NOEXCEPT
 520   {
 521     detail::recursive_directory_iterator_pop(*this, &ec);
 522   }
 523
 524   void disable_recursion_pending(bool value = true) BOOST_NOEXCEPT
 525   {
 526     BOOST_ASSERT_MSG(!is_end(), "disable_recursion_pending() on end recursive_directory_iterator");
 527     if (value)
 528       m_imp->m_options |= static_cast< unsigned int >(directory_options::_detail_no_push);
 529     else
 530       m_imp->m_options &= ~static_cast< unsigned int >(directory_options::_detail_no_push);
 531   }
 532
 533 #ifndef BOOST_FILESYSTEM_NO_DEPRECATED
 534   void no_push(bool value = true) BOOST_NOEXCEPT { disable_recursion_pending(value); }
 535 #endif
 536
 537   file_status status() const
 538   {
 539     BOOST_ASSERT_MSG(!is_end(), "status() on end recursive_directory_iterator");
 540     return m_imp->m_stack.back()->status();
 541   }
 542
 543   file_status symlink_status() const
 544   {
 545     BOOST_ASSERT_MSG(!is_end(), "symlink_status() on end recursive_directory_iterator");
 546     return m_imp->m_stack.back()->symlink_status();
 547   }
 548
 549 private:
 550   boost::iterator_facade<
 551     recursive_directory_iterator,
 552     directory_entry,
 553     boost::single_pass_traversal_tag
 554   >::reference dereference() const
 555   {
 556     BOOST_ASSERT_MSG(!is_end(), "dereference of end recursive_directory_iterator");
 557     return *m_imp->m_stack.back();
 558   }
 559
 560   void increment() { detail::recursive_directory_iterator_increment(*this, 0); }
 561
 562   bool equal(const recursive_directory_iterator& rhs) const BOOST_NOEXCEPT
 563   {
 564     return m_imp == rhs.m_imp || (is_end() && rhs.is_end());
 565   }
 566
 567   bool is_end() const BOOST_NOEXCEPT
 568   {
 569     // Note: The check for m_stack.empty() is needed because the iterator can be copied and the copy
 570     // can be incremented to end while the original iterator still refers to the same recur_dir_itr_imp.
 571     return !m_imp || m_imp->m_stack.empty();
 572   }
 573
 574 private:
 575   // intrusive_ptr provides the shallow-copy semantics required for single pass iterators
 576   // (i.e. InputIterators). The end iterator is indicated by is_end().
 577   boost::intrusive_ptr< detail::recur_dir_itr_imp > m_imp;
 578 };
 579
 580 #if !defined(BOOST_FILESYSTEM_NO_DEPRECATED)
 581 typedef recursive_directory_iterator wrecursive_directory_iterator;
 582 #endif
 583
 584 //  enable recursive directory iterator C++11 range-base for statement use  ----------//
 585
 586 //  begin() and end() are only used by a range-based for statement in the context of
 587 //  auto - thus the top-level const is stripped - so returning const is harmless and
 588 //  emphasizes begin() is just a pass through.
 589 inline const recursive_directory_iterator& begin(const recursive_directory_iterator& iter) BOOST_NOEXCEPT { return iter; }
 590 inline recursive_directory_iterator end(const recursive_directory_iterator&) BOOST_NOEXCEPT { return recursive_directory_iterator(); }
 591
 592 // enable C++14 generic accessors for range const iterators
 593 inline const recursive_directory_iterator& cbegin(const recursive_directory_iterator& iter) BOOST_NOEXCEPT { return iter; }
 594 inline recursive_directory_iterator cend(const recursive_directory_iterator&) BOOST_NOEXCEPT { return recursive_directory_iterator(); }
 595
 596 //  enable recursive directory iterator BOOST_FOREACH  -------------------------------//
 597
 598 inline recursive_directory_iterator& range_begin(recursive_directory_iterator& iter) BOOST_NOEXCEPT { return iter; }
 599 inline recursive_directory_iterator range_begin(const recursive_directory_iterator& iter) BOOST_NOEXCEPT { return iter; }
 600 inline recursive_directory_iterator range_end(recursive_directory_iterator&) BOOST_NOEXCEPT { return recursive_directory_iterator(); }
 601 inline recursive_directory_iterator range_end(const recursive_directory_iterator&) BOOST_NOEXCEPT { return recursive_directory_iterator(); }
 602
 603 } // namespace filesystem
 604
 605 //  namespace boost template specializations
 606 template<>
 607 struct range_mutable_iterator<boost::filesystem::recursive_directory_iterator, void>
 608 {
 609   typedef boost::filesystem::recursive_directory_iterator type;
 610 };
 611 template<>
 612 struct range_const_iterator<boost::filesystem::recursive_directory_iterator, void>
 613 {
 614   typedef boost::filesystem::recursive_directory_iterator type;
 615 };
 616
 617 } // namespace boost
 618
 619 #include <boost/config/abi_suffix.hpp> // pops abi_prefix.hpp pragmas
 620 #endif // BOOST_FILESYSTEM3_DIRECTORY_HPP