]> git.proxmox.com Git - ceph.git/blame - ceph/src/boost/boost/filesystem/directory.hpp
projects / ceph.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
import quincy beta 17.1.0
[ceph.git] / ceph / src / boost / boost / filesystem / directory.hpp
CommitLineData
92f5a8d4
TL		 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
46namespace boost {
47namespace 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
59class directory_entry
60{
61public:
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
144private:
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
148private:
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//
20effc67
TL		 165// These functions avoid a costly recomputation of the status if one calls 'is_directory(e)' instead of 'is_directory(e.status())'
166
167inline file_status status (const directory_entry& e) { return e.status(); }
168inline file_status status (const directory_entry& e, system::error_code& ec) BOOST_NOEXCEPT { return e.status(ec); }
169inline bool type_present (const directory_entry& e) { return filesystem::type_present(e.status()); }
170inline bool type_present (const directory_entry& e, system::error_code& ec) BOOST_NOEXCEPT { return filesystem::type_present(e.status(ec)); }
171inline bool status_known (const directory_entry& e) { return filesystem::status_known(e.status()); }
172inline bool status_known (const directory_entry& e, system::error_code& ec) BOOST_NOEXCEPT { return filesystem::status_known(e.status(ec)); }
173inline bool exists (const directory_entry& e) { return filesystem::exists(e.status()); }
174inline bool exists (const directory_entry& e, system::error_code& ec) BOOST_NOEXCEPT { return filesystem::exists(e.status(ec)); }
175inline bool is_regular_file(const directory_entry& e) { return filesystem::is_regular_file(e.status()); }
176inline bool is_regular_file(const directory_entry& e, system::error_code& ec) BOOST_NOEXCEPT { return filesystem::is_regular_file(e.status(ec)); }
177inline bool is_directory (const directory_entry& e) { return filesystem::is_directory(e.status()); }
178inline bool is_directory (const directory_entry& e, system::error_code& ec) BOOST_NOEXCEPT { return filesystem::is_directory(e.status(ec)); }
179inline bool is_symlink (const directory_entry& e) { return filesystem::is_symlink(e.symlink_status()); }
180inline bool is_symlink (const directory_entry& e, system::error_code& ec) BOOST_NOEXCEPT { return filesystem::is_symlink(e.symlink_status(ec)); }
181inline bool is_other (const directory_entry& e) { return filesystem::is_other(e.status()); }
182inline bool is_other (const directory_entry& e, system::error_code& ec) BOOST_NOEXCEPT { return filesystem::is_other(e.status(ec)); }
92f5a8d4 183#ifndef BOOST_FILESYSTEM_NO_DEPRECATED
20effc67 184inline bool is_regular (const directory_entry& e) { return filesystem::is_regular(e.status()); }
92f5a8d4
TL		 185#endif
186
187//--------------------------------------------------------------------------------------//
188// //
189// directory_iterator helpers //
190// //
191//--------------------------------------------------------------------------------------//
192
193BOOST_SCOPED_ENUM_UT_DECLARE_BEGIN(directory_options, unsigned int)
194{
195 none = 0u,
196 skip_permission_denied = 1u, // if a directory cannot be opened because of insufficient permissions, pretend that the directory is empty
197 follow_directory_symlink = 1u << 1, // recursive_directory_iterator: follow directory symlinks
198 skip_dangling_symlinks = 1u << 2, // non-standard extension for recursive_directory_iterator: don't follow dangling directory symlinks,
199 pop_on_error = 1u << 3, // non-standard extension for recursive_directory_iterator: instead of producing an end iterator on errors,
200 // repeatedly invoke pop() until it succeeds or the iterator becomes equal to end iterator
201 _detail_no_push = 1u << 4 // internal use only
202}
203BOOST_SCOPED_ENUM_DECLARE_END(directory_options)
204
205BOOST_BITMASK(BOOST_SCOPED_ENUM_NATIVE(directory_options))
206
207class directory_iterator;
208
209namespace detail {
210
211BOOST_FILESYSTEM_DECL
212system::error_code dir_itr_close(// never throws()
213 void*& handle
214#if defined(BOOST_POSIX_API)
215 , void*& buffer
216#endif
217) BOOST_NOEXCEPT;
218
219struct dir_itr_imp :
220 public boost::intrusive_ref_counter< dir_itr_imp >
221{
222 directory_entry dir_entry;
223 void* handle;
224
225#if defined(BOOST_POSIX_API)
226 void* buffer; // see dir_itr_increment implementation
227#endif
228
229 dir_itr_imp() BOOST_NOEXCEPT :
230 handle(0)
231#if defined(BOOST_POSIX_API)
232 , buffer(0)
233#endif
234 {
235 }
236
237 ~dir_itr_imp() BOOST_NOEXCEPT
238 {
239 dir_itr_close(handle
240#if defined(BOOST_POSIX_API)
241 , buffer
242#endif
243 );
244 }
245};
246
247// see path::iterator: comment below
248BOOST_FILESYSTEM_DECL void directory_iterator_construct(directory_iterator& it, const path& p, unsigned int opts, system::error_code* ec);
249BOOST_FILESYSTEM_DECL void directory_iterator_increment(directory_iterator& it, system::error_code* ec);
250
251} // namespace detail
252
253//--------------------------------------------------------------------------------------//
254// //
255// directory_iterator //
256// //
257//--------------------------------------------------------------------------------------//
258
259class directory_iterator :
260 public boost::iterator_facade<
261 directory_iterator,
262 directory_entry,
263 boost::single_pass_traversal_tag
264 >
265{
266 friend class boost::iterator_core_access;
267
268 friend BOOST_FILESYSTEM_DECL void detail::directory_iterator_construct(directory_iterator& it, const path& p, unsigned int opts, system::error_code* ec);
269 friend BOOST_FILESYSTEM_DECL void detail::directory_iterator_increment(directory_iterator& it, system::error_code* ec);
270
271public:
272 directory_iterator() BOOST_NOEXCEPT {} // creates the "end" iterator
273
274 // iterator_facade derived classes don't seem to like implementations in
275 // separate translation unit dll's, so forward to detail functions
276 explicit directory_iterator(const path& p, BOOST_SCOPED_ENUM_NATIVE(directory_options) opts = directory_options::none)
277 {
278 detail::directory_iterator_construct(*this, p, static_cast< unsigned int >(opts), 0);
279 }
280
281 directory_iterator(const path& p, system::error_code& ec) BOOST_NOEXCEPT
282 {
283 detail::directory_iterator_construct(*this, p, static_cast< unsigned int >(directory_options::none), &ec);
284 }
285
286 directory_iterator(const path& p, BOOST_SCOPED_ENUM_NATIVE(directory_options) opts, system::error_code& ec) BOOST_NOEXCEPT
287 {
288 detail::directory_iterator_construct(*this, p, static_cast< unsigned int >(opts), &ec);
289 }
290
291 BOOST_DEFAULTED_FUNCTION(directory_iterator(directory_iterator const& that), : m_imp(that.m_imp) {})
292 BOOST_DEFAULTED_FUNCTION(directory_iterator& operator= (directory_iterator const& that), { m_imp = that.m_imp; return *this; })
293
294#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
295 directory_iterator(directory_iterator&& that) BOOST_NOEXCEPT :
296 m_imp(std::move(that.m_imp))
297 {
298 }
299
300 directory_iterator& operator= (directory_iterator&& that) BOOST_NOEXCEPT
301 {
302 m_imp = std::move(that.m_imp);
303 return *this;
304 }
305#endif // !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
306
307 directory_iterator& increment(system::error_code& ec) BOOST_NOEXCEPT
308 {
309 detail::directory_iterator_increment(*this, &ec);
310 return *this;
311 }
312
313private:
314 boost::iterator_facade<
315 directory_iterator,
316 directory_entry,
317 boost::single_pass_traversal_tag
318 >::reference dereference() const
319 {
320 BOOST_ASSERT_MSG(!is_end(), "attempt to dereference end directory iterator");
321 return m_imp->dir_entry;
322 }
323
324 void increment() { detail::directory_iterator_increment(*this, 0); }
325
326 bool equal(const directory_iterator& rhs) const BOOST_NOEXCEPT
327 {
328 return m_imp == rhs.m_imp || (is_end() && rhs.is_end());
329 }
330
331 bool is_end() const BOOST_NOEXCEPT
332 {
333 // Note: The check for handle is needed because the iterator can be copied and the copy
334 // can be incremented to end while the original iterator still refers to the same dir_itr_imp.
335 return !m_imp || !m_imp->handle;
336 }
337
338private:
339 // intrusive_ptr provides the shallow-copy semantics required for single pass iterators
340 // (i.e. InputIterators). The end iterator is indicated by is_end().
341 boost::intrusive_ptr< detail::dir_itr_imp > m_imp;
342};
343
344// enable directory_iterator C++11 range-based for statement use --------------------//
345
346// begin() and end() are only used by a range-based for statement in the context of
347// auto - thus the top-level const is stripped - so returning const is harmless and
348// emphasizes begin() is just a pass through.
349inline const directory_iterator& begin(const directory_iterator& iter) BOOST_NOEXCEPT { return iter; }
350inline directory_iterator end(const directory_iterator&) BOOST_NOEXCEPT { return directory_iterator(); }
351
352// enable C++14 generic accessors for range const iterators
353inline const directory_iterator& cbegin(const directory_iterator& iter) BOOST_NOEXCEPT { return iter; }
354inline directory_iterator cend(const directory_iterator&) BOOST_NOEXCEPT { return directory_iterator(); }
355
356// enable directory_iterator BOOST_FOREACH -----------------------------------------//
357
358inline directory_iterator& range_begin(directory_iterator& iter) BOOST_NOEXCEPT { return iter; }
359inline directory_iterator range_begin(const directory_iterator& iter) BOOST_NOEXCEPT { return iter; }
360inline directory_iterator range_end(directory_iterator&) BOOST_NOEXCEPT { return directory_iterator(); }
361inline directory_iterator range_end(const directory_iterator&) BOOST_NOEXCEPT { return directory_iterator(); }
362
363} // namespace filesystem
364
365// namespace boost template specializations
366template<typename C, typename Enabler>
367struct range_mutable_iterator;
368
369template<>
370struct range_mutable_iterator<boost::filesystem::directory_iterator, void>
371{
372 typedef boost::filesystem::directory_iterator type;
373};
374
375template<typename C, typename Enabler>
376struct range_const_iterator;
377
378template<>
379struct range_const_iterator<boost::filesystem::directory_iterator, void>
380{
381 typedef boost::filesystem::directory_iterator type;
382};
383
384namespace filesystem {
385
386//--------------------------------------------------------------------------------------//
387// //
388// recursive_directory_iterator helpers //
389// //
390//--------------------------------------------------------------------------------------//
391
392#if !defined(BOOST_FILESYSTEM_NO_DEPRECATED)
393// Deprecated enum, use directory_options instead
394BOOST_SCOPED_ENUM_UT_DECLARE_BEGIN(symlink_option, unsigned int)
395{
396 none = static_cast< unsigned int >(directory_options::none),
397 no_recurse = none, // don't follow directory symlinks (default behavior)
398 recurse = static_cast< unsigned int >(directory_options::follow_directory_symlink), // follow directory symlinks
399 _detail_no_push = static_cast< unsigned int >(directory_options::_detail_no_push) // internal use only
400}
401BOOST_SCOPED_ENUM_DECLARE_END(symlink_option)
402
403BOOST_BITMASK(BOOST_SCOPED_ENUM_NATIVE(symlink_option))
404#endif // BOOST_FILESYSTEM_NO_DEPRECATED
405
406class recursive_directory_iterator;
407
408namespace detail {
409
410struct recur_dir_itr_imp :
411 public boost::intrusive_ref_counter< recur_dir_itr_imp >
412{
413 typedef directory_iterator element_type;
414 std::vector< element_type > m_stack;
415 // directory_options values, declared as unsigned int for ABI compatibility
416 unsigned int m_options;
417
418 explicit recur_dir_itr_imp(unsigned int opts) BOOST_NOEXCEPT : m_options(opts) {}
419};
420
421BOOST_FILESYSTEM_DECL void recursive_directory_iterator_construct(recursive_directory_iterator& it, const path& dir_path, unsigned int opts, system::error_code* ec);
422BOOST_FILESYSTEM_DECL void recursive_directory_iterator_increment(recursive_directory_iterator& it, system::error_code* ec);
423BOOST_FILESYSTEM_DECL void recursive_directory_iterator_pop(recursive_directory_iterator& it, system::error_code* ec);
424
425} // namespace detail
426
427//--------------------------------------------------------------------------------------//
428// //
429// recursive_directory_iterator //
430// //
431//--------------------------------------------------------------------------------------//
432
433class recursive_directory_iterator :
434 public boost::iterator_facade<
435 recursive_directory_iterator,
436 directory_entry,
437 boost::single_pass_traversal_tag
438 >
439{
440 friend class boost::iterator_core_access;
441
442 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);
443 friend BOOST_FILESYSTEM_DECL void detail::recursive_directory_iterator_increment(recursive_directory_iterator& it, system::error_code* ec);
444 friend BOOST_FILESYSTEM_DECL void detail::recursive_directory_iterator_pop(recursive_directory_iterator& it, system::error_code* ec);
445
446public:
447 recursive_directory_iterator() BOOST_NOEXCEPT {} // creates the "end" iterator
448
449 explicit recursive_directory_iterator(const path& dir_path)
450 {
451 detail::recursive_directory_iterator_construct(*this, dir_path, static_cast< unsigned int >(directory_options::none), 0);
452 }
453
454 recursive_directory_iterator(const path& dir_path, system::error_code& ec)
455 {
456 detail::recursive_directory_iterator_construct(*this, dir_path, static_cast< unsigned int >(directory_options::none), &ec);
457 }
458
459 recursive_directory_iterator(const path& dir_path, BOOST_SCOPED_ENUM_NATIVE(directory_options) opts)
460 {
461 detail::recursive_directory_iterator_construct(*this, dir_path, static_cast< unsigned int >(opts), 0);
462 }
463
464 recursive_directory_iterator(const path& dir_path, BOOST_SCOPED_ENUM_NATIVE(directory_options) opts, system::error_code& ec)
465 {
466 detail::recursive_directory_iterator_construct(*this, dir_path, static_cast< unsigned int >(opts), &ec);
467 }
468
469#if !defined(BOOST_FILESYSTEM_NO_DEPRECATED)
470 // Deprecated constructors
471 recursive_directory_iterator(const path& dir_path, BOOST_SCOPED_ENUM_NATIVE(symlink_option) opts)
472 {
473 detail::recursive_directory_iterator_construct(*this, dir_path, static_cast< unsigned int >(opts), 0);
474 }
475
476 recursive_directory_iterator(const path& dir_path, BOOST_SCOPED_ENUM_NATIVE(symlink_option) opts, system::error_code& ec) BOOST_NOEXCEPT
477 {
478 detail::recursive_directory_iterator_construct(*this, dir_path, static_cast< unsigned int >(opts), &ec);
479 }
480#endif // BOOST_FILESYSTEM_NO_DEPRECATED
481
482 BOOST_DEFAULTED_FUNCTION(recursive_directory_iterator(recursive_directory_iterator const& that), : m_imp(that.m_imp) {})
483 BOOST_DEFAULTED_FUNCTION(recursive_directory_iterator& operator= (recursive_directory_iterator const& that), { m_imp = that.m_imp; return *this; })
484
485#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
486 recursive_directory_iterator(recursive_directory_iterator&& that) BOOST_NOEXCEPT :
487 m_imp(std::move(that.m_imp))
488 {
489 }
490
491 recursive_directory_iterator& operator= (recursive_directory_iterator&& that) BOOST_NOEXCEPT
492 {
493 m_imp = std::move(that.m_imp);
494 return *this;
495 }
496#endif // !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
497
498 recursive_directory_iterator& increment(system::error_code& ec) BOOST_NOEXCEPT
499 {
500 detail::recursive_directory_iterator_increment(*this, &ec);
501 return *this;
502 }
503
504 int depth() const BOOST_NOEXCEPT
505 {
506 BOOST_ASSERT_MSG(!is_end(), "depth() on end recursive_directory_iterator");
507 return static_cast< int >(m_imp->m_stack.size() - 1u);
508 }
509
510 bool recursion_pending() const BOOST_NOEXCEPT
511 {
512 BOOST_ASSERT_MSG(!is_end(), "recursion_pending() on end recursive_directory_iterator");
513 return (m_imp->m_options & static_cast< unsigned int >(directory_options::_detail_no_push)) == 0u;
514 }
515
516#ifndef BOOST_FILESYSTEM_NO_DEPRECATED
517 int level() const BOOST_NOEXCEPT { return depth(); }
518 bool no_push_pending() const BOOST_NOEXCEPT { return !recursion_pending(); }
519 bool no_push_request() const BOOST_NOEXCEPT { return !recursion_pending(); }
520#endif
521
522 void pop()
523 {
524 detail::recursive_directory_iterator_pop(*this, 0);
525 }
526
527 void pop(system::error_code& ec) BOOST_NOEXCEPT
528 {
529 detail::recursive_directory_iterator_pop(*this, &ec);
530 }
531
532 void disable_recursion_pending(bool value = true) BOOST_NOEXCEPT
533 {
534 BOOST_ASSERT_MSG(!is_end(), "disable_recursion_pending() on end recursive_directory_iterator");
535 if (value)
536 m_imp->m_options |= static_cast< unsigned int >(directory_options::_detail_no_push);
537 else
538 m_imp->m_options &= ~static_cast< unsigned int >(directory_options::_detail_no_push);
539 }
540
541#ifndef BOOST_FILESYSTEM_NO_DEPRECATED
542 void no_push(bool value = true) BOOST_NOEXCEPT { disable_recursion_pending(value); }
543#endif
544
545 file_status status() const
546 {
547 BOOST_ASSERT_MSG(!is_end(), "status() on end recursive_directory_iterator");
548 return m_imp->m_stack.back()->status();
549 }
550
551 file_status symlink_status() const
552 {
553 BOOST_ASSERT_MSG(!is_end(), "symlink_status() on end recursive_directory_iterator");
554 return m_imp->m_stack.back()->symlink_status();
555 }
556
557private:
558 boost::iterator_facade<
559 recursive_directory_iterator,
560 directory_entry,
561 boost::single_pass_traversal_tag
562 >::reference dereference() const
563 {
564 BOOST_ASSERT_MSG(!is_end(), "dereference of end recursive_directory_iterator");
565 return *m_imp->m_stack.back();
566 }
567
568 void increment() { detail::recursive_directory_iterator_increment(*this, 0); }
569
570 bool equal(const recursive_directory_iterator& rhs) const BOOST_NOEXCEPT
571 {
572 return m_imp == rhs.m_imp || (is_end() && rhs.is_end());
573 }
574
575 bool is_end() const BOOST_NOEXCEPT
576 {
577 // Note: The check for m_stack.empty() is needed because the iterator can be copied and the copy
578 // can be incremented to end while the original iterator still refers to the same recur_dir_itr_imp.
579 return !m_imp || m_imp->m_stack.empty();
580 }
581
582private:
583 // intrusive_ptr provides the shallow-copy semantics required for single pass iterators
584 // (i.e. InputIterators). The end iterator is indicated by is_end().
585 boost::intrusive_ptr< detail::recur_dir_itr_imp > m_imp;
586};
587
588#if !defined(BOOST_FILESYSTEM_NO_DEPRECATED)
589typedef recursive_directory_iterator wrecursive_directory_iterator;
590#endif
591
592// enable recursive directory iterator C++11 range-base for statement use ----------//
593
594// begin() and end() are only used by a range-based for statement in the context of
595// auto - thus the top-level const is stripped - so returning const is harmless and
596// emphasizes begin() is just a pass through.
597inline const recursive_directory_iterator& begin(const recursive_directory_iterator& iter) BOOST_NOEXCEPT { return iter; }
598inline recursive_directory_iterator end(const recursive_directory_iterator&) BOOST_NOEXCEPT { return recursive_directory_iterator(); }
599
600// enable C++14 generic accessors for range const iterators
601inline const recursive_directory_iterator& cbegin(const recursive_directory_iterator& iter) BOOST_NOEXCEPT { return iter; }
602inline recursive_directory_iterator cend(const recursive_directory_iterator&) BOOST_NOEXCEPT { return recursive_directory_iterator(); }
603
604// enable recursive directory iterator BOOST_FOREACH -------------------------------//
605
606inline recursive_directory_iterator& range_begin(recursive_directory_iterator& iter) BOOST_NOEXCEPT { return iter; }
607inline recursive_directory_iterator range_begin(const recursive_directory_iterator& iter) BOOST_NOEXCEPT { return iter; }
608inline recursive_directory_iterator range_end(recursive_directory_iterator&) BOOST_NOEXCEPT { return recursive_directory_iterator(); }
609inline recursive_directory_iterator range_end(const recursive_directory_iterator&) BOOST_NOEXCEPT { return recursive_directory_iterator(); }
610
611} // namespace filesystem
612
613// namespace boost template specializations
614template<>
615struct range_mutable_iterator<boost::filesystem::recursive_directory_iterator, void>
616{
617 typedef boost::filesystem::recursive_directory_iterator type;
618};
619template<>
620struct range_const_iterator<boost::filesystem::recursive_directory_iterator, void>
621{
622 typedef boost::filesystem::recursive_directory_iterator type;
623};
624
625} // namespace boost
626
627#include <boost/config/abi_suffix.hpp> // pops abi_prefix.hpp pragmas
628#endif // BOOST_FILESYSTEM3_DIRECTORY_HPP
Ceph