blob: 339bb252fceea2e76e5709913e226e97765ac6e7 [file] [log] [blame]
// -*- C++ -*-
//===--------------------------- filesystem -------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP_FILESYSTEM
#define _LIBCPP_FILESYSTEM
/*
filesystem synopsis
namespace std { namespace filesystem {
class path;
void swap(path& lhs, path& rhs) noexcept;
size_t hash_value(const path& p) noexcept;
bool operator==(const path& lhs, const path& rhs) noexcept;
bool operator!=(const path& lhs, const path& rhs) noexcept;
bool operator< (const path& lhs, const path& rhs) noexcept;
bool operator<=(const path& lhs, const path& rhs) noexcept;
bool operator> (const path& lhs, const path& rhs) noexcept;
bool operator>=(const path& lhs, const path& rhs) noexcept;
path operator/ (const path& lhs, const path& rhs);
// fs.path.io operators are friends of path.
template <class charT, class traits>
friend basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os, const path& p);
template <class charT, class traits>
friend basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is, path& p);
template <class Source>
path u8path(const Source& source);
template <class InputIterator>
path u8path(InputIterator first, InputIterator last);
class filesystem_error;
class directory_entry;
class directory_iterator;
// enable directory_iterator range-based for statements
directory_iterator begin(directory_iterator iter) noexcept;
directory_iterator end(const directory_iterator&) noexcept;
class recursive_directory_iterator;
// enable recursive_directory_iterator range-based for statements
recursive_directory_iterator begin(recursive_directory_iterator iter) noexcept;
recursive_directory_iterator end(const recursive_directory_iterator&) noexcept;
class file_status;
struct space_info
{
uintmax_t capacity;
uintmax_t free;
uintmax_t available;
};
enum class file_type;
enum class perms;
enum class perm_options;
enum class copy_options;
enum class directory_options;
typedef chrono::time_point<trivial-clock> file_time_type;
// operational functions
path absolute(const path& p);
path absolute(const path& p, error_code &ec);
path canonical(const path& p);
path canonical(const path& p, error_code& ec);
void copy(const path& from, const path& to);
void copy(const path& from, const path& to, error_code& ec);
void copy(const path& from, const path& to, copy_options options);
void copy(const path& from, const path& to, copy_options options,
error_code& ec);
bool copy_file(const path& from, const path& to);
bool copy_file(const path& from, const path& to, error_code& ec);
bool copy_file(const path& from, const path& to, copy_options option);
bool copy_file(const path& from, const path& to, copy_options option,
error_code& ec);
void copy_symlink(const path& existing_symlink, const path& new_symlink);
void copy_symlink(const path& existing_symlink, const path& new_symlink,
error_code& ec) noexcept;
bool create_directories(const path& p);
bool create_directories(const path& p, error_code& ec);
bool create_directory(const path& p);
bool create_directory(const path& p, error_code& ec) noexcept;
bool create_directory(const path& p, const path& attributes);
bool create_directory(const path& p, const path& attributes,
error_code& ec) noexcept;
void create_directory_symlink(const path& to, const path& new_symlink);
void create_directory_symlink(const path& to, const path& new_symlink,
error_code& ec) noexcept;
void create_hard_link(const path& to, const path& new_hard_link);
void create_hard_link(const path& to, const path& new_hard_link,
error_code& ec) noexcept;
void create_symlink(const path& to, const path& new_symlink);
void create_symlink(const path& to, const path& new_symlink,
error_code& ec) noexcept;
path current_path();
path current_path(error_code& ec);
void current_path(const path& p);
void current_path(const path& p, error_code& ec) noexcept;
bool exists(file_status s) noexcept;
bool exists(const path& p);
bool exists(const path& p, error_code& ec) noexcept;
bool equivalent(const path& p1, const path& p2);
bool equivalent(const path& p1, const path& p2, error_code& ec) noexcept;
uintmax_t file_size(const path& p);
uintmax_t file_size(const path& p, error_code& ec) noexcept;
uintmax_t hard_link_count(const path& p);
uintmax_t hard_link_count(const path& p, error_code& ec) noexcept;
bool is_block_file(file_status s) noexcept;
bool is_block_file(const path& p);
bool is_block_file(const path& p, error_code& ec) noexcept;
bool is_character_file(file_status s) noexcept;
bool is_character_file(const path& p);
bool is_character_file(const path& p, error_code& ec) noexcept;
bool is_directory(file_status s) noexcept;
bool is_directory(const path& p);
bool is_directory(const path& p, error_code& ec) noexcept;
bool is_empty(const path& p);
bool is_empty(const path& p, error_code& ec) noexcept;
bool is_fifo(file_status s) noexcept;
bool is_fifo(const path& p);
bool is_fifo(const path& p, error_code& ec) noexcept;
bool is_other(file_status s) noexcept;
bool is_other(const path& p);
bool is_other(const path& p, error_code& ec) noexcept;
bool is_regular_file(file_status s) noexcept;
bool is_regular_file(const path& p);
bool is_regular_file(const path& p, error_code& ec) noexcept;
bool is_socket(file_status s) noexcept;
bool is_socket(const path& p);
bool is_socket(const path& p, error_code& ec) noexcept;
bool is_symlink(file_status s) noexcept;
bool is_symlink(const path& p);
bool is_symlink(const path& p, error_code& ec) noexcept;
file_time_type last_write_time(const path& p);
file_time_type last_write_time(const path& p, error_code& ec) noexcept;
void last_write_time(const path& p, file_time_type new_time);
void last_write_time(const path& p, file_time_type new_time,
error_code& ec) noexcept;
void permissions(const path& p, perms prms,
perm_options opts=perm_options::replace);
void permissions(const path& p, perms prms, error_code& ec) noexcept;
void permissions(const path& p, perms prms, perm_options opts,
error_code& ec);
path proximate(const path& p, error_code& ec);
path proximate(const path& p, const path& base = current_path());
path proximate(const path& p, const path& base, error_code &ec);
path read_symlink(const path& p);
path read_symlink(const path& p, error_code& ec);
path relative(const path& p, error_code& ec);
path relative(const path& p, const path& base=current_path());
path relative(const path& p, const path& base, error_code& ec);
bool remove(const path& p);
bool remove(const path& p, error_code& ec) noexcept;
uintmax_t remove_all(const path& p);
uintmax_t remove_all(const path& p, error_code& ec);
void rename(const path& from, const path& to);
void rename(const path& from, const path& to, error_code& ec) noexcept;
void resize_file(const path& p, uintmax_t size);
void resize_file(const path& p, uintmax_t size, error_code& ec) noexcept;
space_info space(const path& p);
space_info space(const path& p, error_code& ec) noexcept;
file_status status(const path& p);
file_status status(const path& p, error_code& ec) noexcept;
bool status_known(file_status s) noexcept;
file_status symlink_status(const path& p);
file_status symlink_status(const path& p, error_code& ec) noexcept;
path temp_directory_path();
path temp_directory_path(error_code& ec);
path weakly_canonical(path const& p);
path weakly_canonical(path const& p, error_code& ec);
} } // namespaces std::filesystem
*/
#include <__config>
#include <cstddef>
#include <cstdlib>
#include <chrono>
#include <iterator>
#include <iosfwd>
#include <locale>
#include <memory>
#include <stack>
#include <string>
#include <system_error>
#include <utility>
#include <iomanip> // for quoted
#include <string_view>
#include <version>
#include <__debug>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_PUSH_MACROS
#include <__undef_macros>
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
struct _FilesystemClock {
#if !defined(_LIBCPP_HAS_NO_INT128)
typedef __int128_t rep;
typedef nano period;
#else
typedef long long rep;
typedef nano period;
#endif
typedef chrono::duration<rep, period> duration;
typedef chrono::time_point<_FilesystemClock> time_point;
static _LIBCPP_CONSTEXPR_AFTER_CXX11 const bool is_steady = false;
_LIBCPP_FUNC_VIS static time_point now() noexcept;
_LIBCPP_INLINE_VISIBILITY
static time_t to_time_t(const time_point& __t) noexcept {
typedef chrono::duration<rep> __secs;
return time_t(
chrono::duration_cast<__secs>(__t.time_since_epoch()).count());
}
_LIBCPP_INLINE_VISIBILITY
static time_point from_time_t(time_t __t) noexcept {
typedef chrono::duration<rep> __secs;
return time_point(__secs(__t));
}
};
typedef chrono::time_point<_FilesystemClock> file_time_type;
struct _LIBCPP_TYPE_VIS space_info {
uintmax_t capacity;
uintmax_t free;
uintmax_t available;
};
enum class _LIBCPP_ENUM_VIS file_type : signed char {
none = 0,
not_found = -1,
regular = 1,
directory = 2,
symlink = 3,
block = 4,
character = 5,
fifo = 6,
socket = 7,
unknown = 8
};
enum class _LIBCPP_ENUM_VIS perms : unsigned {
none = 0,
owner_read = 0400,
owner_write = 0200,
owner_exec = 0100,
owner_all = 0700,
group_read = 040,
group_write = 020,
group_exec = 010,
group_all = 070,
others_read = 04,
others_write = 02,
others_exec = 01,
others_all = 07,
all = 0777,
set_uid = 04000,
set_gid = 02000,
sticky_bit = 01000,
mask = 07777,
unknown = 0xFFFF,
};
_LIBCPP_INLINE_VISIBILITY
inline constexpr perms operator&(perms _LHS, perms _RHS) {
return static_cast<perms>(static_cast<unsigned>(_LHS) &
static_cast<unsigned>(_RHS));
}
_LIBCPP_INLINE_VISIBILITY
inline constexpr perms operator|(perms _LHS, perms _RHS) {
return static_cast<perms>(static_cast<unsigned>(_LHS) |
static_cast<unsigned>(_RHS));
}
_LIBCPP_INLINE_VISIBILITY
inline constexpr perms operator^(perms _LHS, perms _RHS) {
return static_cast<perms>(static_cast<unsigned>(_LHS) ^
static_cast<unsigned>(_RHS));
}
_LIBCPP_INLINE_VISIBILITY
inline constexpr perms operator~(perms _LHS) {
return static_cast<perms>(~static_cast<unsigned>(_LHS));
}
_LIBCPP_INLINE_VISIBILITY
inline perms& operator&=(perms& _LHS, perms _RHS) { return _LHS = _LHS & _RHS; }
_LIBCPP_INLINE_VISIBILITY
inline perms& operator|=(perms& _LHS, perms _RHS) { return _LHS = _LHS | _RHS; }
_LIBCPP_INLINE_VISIBILITY
inline perms& operator^=(perms& _LHS, perms _RHS) { return _LHS = _LHS ^ _RHS; }
enum class _LIBCPP_ENUM_VIS perm_options : unsigned char {
replace = 1,
add = 2,
remove = 4,
nofollow = 8
};
_LIBCPP_INLINE_VISIBILITY
inline constexpr perm_options operator&(perm_options _LHS, perm_options _RHS) {
return static_cast<perm_options>(static_cast<unsigned>(_LHS) &
static_cast<unsigned>(_RHS));
}
_LIBCPP_INLINE_VISIBILITY
inline constexpr perm_options operator|(perm_options _LHS, perm_options _RHS) {
return static_cast<perm_options>(static_cast<unsigned>(_LHS) |
static_cast<unsigned>(_RHS));
}
_LIBCPP_INLINE_VISIBILITY
inline constexpr perm_options operator^(perm_options _LHS, perm_options _RHS) {
return static_cast<perm_options>(static_cast<unsigned>(_LHS) ^
static_cast<unsigned>(_RHS));
}
_LIBCPP_INLINE_VISIBILITY
inline constexpr perm_options operator~(perm_options _LHS) {
return static_cast<perm_options>(~static_cast<unsigned>(_LHS));
}
_LIBCPP_INLINE_VISIBILITY
inline perm_options& operator&=(perm_options& _LHS, perm_options _RHS) {
return _LHS = _LHS & _RHS;
}
_LIBCPP_INLINE_VISIBILITY
inline perm_options& operator|=(perm_options& _LHS, perm_options _RHS) {
return _LHS = _LHS | _RHS;
}
_LIBCPP_INLINE_VISIBILITY
inline perm_options& operator^=(perm_options& _LHS, perm_options _RHS) {
return _LHS = _LHS ^ _RHS;
}
enum class _LIBCPP_ENUM_VIS copy_options : unsigned short {
none = 0,
skip_existing = 1,
overwrite_existing = 2,
update_existing = 4,
recursive = 8,
copy_symlinks = 16,
skip_symlinks = 32,
directories_only = 64,
create_symlinks = 128,
create_hard_links = 256,
__in_recursive_copy = 512,
};
_LIBCPP_INLINE_VISIBILITY
inline constexpr copy_options operator&(copy_options _LHS, copy_options _RHS) {
return static_cast<copy_options>(static_cast<unsigned short>(_LHS) &
static_cast<unsigned short>(_RHS));
}
_LIBCPP_INLINE_VISIBILITY
inline constexpr copy_options operator|(copy_options _LHS, copy_options _RHS) {
return static_cast<copy_options>(static_cast<unsigned short>(_LHS) |
static_cast<unsigned short>(_RHS));
}
_LIBCPP_INLINE_VISIBILITY
inline constexpr copy_options operator^(copy_options _LHS, copy_options _RHS) {
return static_cast<copy_options>(static_cast<unsigned short>(_LHS) ^
static_cast<unsigned short>(_RHS));
}
_LIBCPP_INLINE_VISIBILITY
inline constexpr copy_options operator~(copy_options _LHS) {
return static_cast<copy_options>(~static_cast<unsigned short>(_LHS));
}
_LIBCPP_INLINE_VISIBILITY
inline copy_options& operator&=(copy_options& _LHS, copy_options _RHS) {
return _LHS = _LHS & _RHS;
}
_LIBCPP_INLINE_VISIBILITY
inline copy_options& operator|=(copy_options& _LHS, copy_options _RHS) {
return _LHS = _LHS | _RHS;
}
_LIBCPP_INLINE_VISIBILITY
inline copy_options& operator^=(copy_options& _LHS, copy_options _RHS) {
return _LHS = _LHS ^ _RHS;
}
enum class _LIBCPP_ENUM_VIS directory_options : unsigned char {
none = 0,
follow_directory_symlink = 1,
skip_permission_denied = 2
};
_LIBCPP_INLINE_VISIBILITY
inline constexpr directory_options operator&(directory_options _LHS,
directory_options _RHS) {
return static_cast<directory_options>(static_cast<unsigned char>(_LHS) &
static_cast<unsigned char>(_RHS));
}
_LIBCPP_INLINE_VISIBILITY
inline constexpr directory_options operator|(directory_options _LHS,
directory_options _RHS) {
return static_cast<directory_options>(static_cast<unsigned char>(_LHS) |
static_cast<unsigned char>(_RHS));
}
_LIBCPP_INLINE_VISIBILITY
inline constexpr directory_options operator^(directory_options _LHS,
directory_options _RHS) {
return static_cast<directory_options>(static_cast<unsigned char>(_LHS) ^
static_cast<unsigned char>(_RHS));
}
_LIBCPP_INLINE_VISIBILITY
inline constexpr directory_options operator~(directory_options _LHS) {
return static_cast<directory_options>(~static_cast<unsigned char>(_LHS));
}
_LIBCPP_INLINE_VISIBILITY
inline directory_options& operator&=(directory_options& _LHS,
directory_options _RHS) {
return _LHS = _LHS & _RHS;
}
_LIBCPP_INLINE_VISIBILITY
inline directory_options& operator|=(directory_options& _LHS,
directory_options _RHS) {
return _LHS = _LHS | _RHS;
}
_LIBCPP_INLINE_VISIBILITY
inline directory_options& operator^=(directory_options& _LHS,
directory_options _RHS) {
return _LHS = _LHS ^ _RHS;
}
class _LIBCPP_TYPE_VIS file_status {
public:
// constructors
_LIBCPP_INLINE_VISIBILITY
file_status() noexcept : file_status(file_type::none) {}
_LIBCPP_INLINE_VISIBILITY
explicit file_status(file_type __ft, perms __prms = perms::unknown) noexcept
: __ft_(__ft),
__prms_(__prms) {}
file_status(const file_status&) noexcept = default;
file_status(file_status&&) noexcept = default;
_LIBCPP_INLINE_VISIBILITY
~file_status() {}
file_status& operator=(const file_status&) noexcept = default;
file_status& operator=(file_status&&) noexcept = default;
// observers
_LIBCPP_INLINE_VISIBILITY
file_type type() const noexcept { return __ft_; }
_LIBCPP_INLINE_VISIBILITY
perms permissions() const noexcept { return __prms_; }
// modifiers
_LIBCPP_INLINE_VISIBILITY
void type(file_type __ft) noexcept { __ft_ = __ft; }
_LIBCPP_INLINE_VISIBILITY
void permissions(perms __p) noexcept { __prms_ = __p; }
private:
file_type __ft_;
perms __prms_;
};
class _LIBCPP_TYPE_VIS directory_entry;
template <class _Tp>
struct __can_convert_char {
static const bool value = false;
};
template <class _Tp>
struct __can_convert_char<const _Tp> : public __can_convert_char<_Tp> {};
template <>
struct __can_convert_char<char> {
static const bool value = true;
using __char_type = char;
};
template <>
struct __can_convert_char<wchar_t> {
static const bool value = true;
using __char_type = wchar_t;
};
template <>
struct __can_convert_char<char16_t> {
static const bool value = true;
using __char_type = char16_t;
};
template <>
struct __can_convert_char<char32_t> {
static const bool value = true;
using __char_type = char32_t;
};
template <class _ECharT>
typename enable_if<__can_convert_char<_ECharT>::value, bool>::type
__is_separator(_ECharT __e) {
return __e == _ECharT('/');
}
struct _NullSentinal {};
template <class _Tp>
using _Void = void;
template <class _Tp, class = void>
struct __is_pathable_string : public false_type {};
template <class _ECharT, class _Traits, class _Alloc>
struct __is_pathable_string<
basic_string<_ECharT, _Traits, _Alloc>,
_Void<typename __can_convert_char<_ECharT>::__char_type> >
: public __can_convert_char<_ECharT> {
using _Str = basic_string<_ECharT, _Traits, _Alloc>;
using _Base = __can_convert_char<_ECharT>;
static _ECharT const* __range_begin(_Str const& __s) { return __s.data(); }
static _ECharT const* __range_end(_Str const& __s) {
return __s.data() + __s.length();
}
static _ECharT __first_or_null(_Str const& __s) {
return __s.empty() ? _ECharT{} : __s[0];
}
};
template <class _ECharT, class _Traits>
struct __is_pathable_string<
basic_string_view<_ECharT, _Traits>,
_Void<typename __can_convert_char<_ECharT>::__char_type> >
: public __can_convert_char<_ECharT> {
using _Str = basic_string_view<_ECharT, _Traits>;
using _Base = __can_convert_char<_ECharT>;
static _ECharT const* __range_begin(_Str const& __s) { return __s.data(); }
static _ECharT const* __range_end(_Str const& __s) {
return __s.data() + __s.length();
}
static _ECharT __first_or_null(_Str const& __s) {
return __s.empty() ? _ECharT{} : __s[0];
}
};
template <class _Source, class _DS = typename decay<_Source>::type,
class _UnqualPtrType =
typename remove_const<typename remove_pointer<_DS>::type>::type,
bool _IsCharPtr = is_pointer<_DS>::value&&
__can_convert_char<_UnqualPtrType>::value>
struct __is_pathable_char_array : false_type {};
template <class _Source, class _ECharT, class _UPtr>
struct __is_pathable_char_array<_Source, _ECharT*, _UPtr, true>
: __can_convert_char<typename remove_const<_ECharT>::type> {
using _Base = __can_convert_char<typename remove_const<_ECharT>::type>;
static _ECharT const* __range_begin(const _ECharT* __b) { return __b; }
static _ECharT const* __range_end(const _ECharT* __b) {
using _Iter = const _ECharT*;
const _ECharT __sentinal = _ECharT{};
_Iter __e = __b;
for (; *__e != __sentinal; ++__e)
;
return __e;
}
static _ECharT __first_or_null(const _ECharT* __b) { return *__b; }
};
template <class _Iter, bool _IsIt = __is_input_iterator<_Iter>::value,
class = void>
struct __is_pathable_iter : false_type {};
template <class _Iter>
struct __is_pathable_iter<
_Iter, true,
_Void<typename __can_convert_char<
typename iterator_traits<_Iter>::value_type>::__char_type> >
: __can_convert_char<typename iterator_traits<_Iter>::value_type> {
using _ECharT = typename iterator_traits<_Iter>::value_type;
using _Base = __can_convert_char<_ECharT>;
static _Iter __range_begin(_Iter __b) { return __b; }
static _NullSentinal __range_end(_Iter) { return _NullSentinal{}; }
static _ECharT __first_or_null(_Iter __b) { return *__b; }
};
template <class _Tp, bool _IsStringT = __is_pathable_string<_Tp>::value,
bool _IsCharIterT = __is_pathable_char_array<_Tp>::value,
bool _IsIterT = !_IsCharIterT && __is_pathable_iter<_Tp>::value>
struct __is_pathable : false_type {
static_assert(!_IsStringT && !_IsCharIterT && !_IsIterT, "Must all be false");
};
template <class _Tp>
struct __is_pathable<_Tp, true, false, false> : __is_pathable_string<_Tp> {};
template <class _Tp>
struct __is_pathable<_Tp, false, true, false> : __is_pathable_char_array<_Tp> {
};
template <class _Tp>
struct __is_pathable<_Tp, false, false, true> : __is_pathable_iter<_Tp> {};
template <class _ECharT>
struct _PathCVT {
static_assert(__can_convert_char<_ECharT>::value,
"Char type not convertible");
typedef __narrow_to_utf8<sizeof(_ECharT) * __CHAR_BIT__> _Narrower;
static void __append_range(string& __dest, _ECharT const* __b,
_ECharT const* __e) {
_Narrower()(back_inserter(__dest), __b, __e);
}
template <class _Iter>
static void __append_range(string& __dest, _Iter __b, _Iter __e) {
static_assert(!is_same<_Iter, _ECharT*>::value, "Call const overload");
if (__b == __e)
return;
basic_string<_ECharT> __tmp(__b, __e);
_Narrower()(back_inserter(__dest), __tmp.data(),
__tmp.data() + __tmp.length());
}
template <class _Iter>
static void __append_range(string& __dest, _Iter __b, _NullSentinal) {
static_assert(!is_same<_Iter, _ECharT*>::value, "Call const overload");
const _ECharT __sentinal = _ECharT{};
if (*__b == __sentinal)
return;
basic_string<_ECharT> __tmp;
for (; *__b != __sentinal; ++__b)
__tmp.push_back(*__b);
_Narrower()(back_inserter(__dest), __tmp.data(),
__tmp.data() + __tmp.length());
}
template <class _Source>
static void __append_source(string& __dest, _Source const& __s) {
using _Traits = __is_pathable<_Source>;
__append_range(__dest, _Traits::__range_begin(__s),
_Traits::__range_end(__s));
}
};
template <>
struct _PathCVT<char> {
template <class _Iter>
static typename enable_if<__is_exactly_input_iterator<_Iter>::value>::type
__append_range(string& __dest, _Iter __b, _Iter __e) {
for (; __b != __e; ++__b)
__dest.push_back(*__b);
}
template <class _Iter>
static typename enable_if<__is_forward_iterator<_Iter>::value>::type
__append_range(string& __dest, _Iter __b, _Iter __e) {
__dest.__append_forward_unsafe(__b, __e);
}
template <class _Iter>
static void __append_range(string& __dest, _Iter __b, _NullSentinal) {
const char __sentinal = char{};
for (; *__b != __sentinal; ++__b)
__dest.push_back(*__b);
}
template <class _Source>
static void __append_source(string& __dest, _Source const& __s) {
using _Traits = __is_pathable<_Source>;
__append_range(__dest, _Traits::__range_begin(__s),
_Traits::__range_end(__s));
}
};
class _LIBCPP_TYPE_VIS path {
template <class _SourceOrIter, class _Tp = path&>
using _EnableIfPathable =
typename enable_if<__is_pathable<_SourceOrIter>::value, _Tp>::type;
template <class _Tp>
using _SourceChar = typename __is_pathable<_Tp>::__char_type;
template <class _Tp>
using _SourceCVT = _PathCVT<_SourceChar<_Tp> >;
public:
typedef char value_type;
typedef basic_string<value_type> string_type;
typedef _VSTD::string_view __string_view;
static constexpr value_type preferred_separator = '/';
enum class _LIBCPP_ENUM_VIS format : unsigned char {
auto_format,
native_format,
generic_format
};
// constructors and destructor
_LIBCPP_INLINE_VISIBILITY path() noexcept {}
_LIBCPP_INLINE_VISIBILITY path(const path& __p) : __pn_(__p.__pn_) {}
_LIBCPP_INLINE_VISIBILITY path(path&& __p) noexcept
: __pn_(_VSTD::move(__p.__pn_)) {}
_LIBCPP_INLINE_VISIBILITY
path(string_type&& __s, format = format::auto_format) noexcept
: __pn_(_VSTD::move(__s)) {}
template <class _Source, class = _EnableIfPathable<_Source, void> >
path(const _Source& __src, format = format::auto_format) {
_SourceCVT<_Source>::__append_source(__pn_, __src);
}
template <class _InputIt>
path(_InputIt __first, _InputIt __last, format = format::auto_format) {
typedef typename iterator_traits<_InputIt>::value_type _ItVal;
_PathCVT<_ItVal>::__append_range(__pn_, __first, __last);
}
// TODO Implement locale conversions.
template <class _Source, class = _EnableIfPathable<_Source, void> >
path(const _Source& __src, const locale& __loc, format = format::auto_format);
template <class _InputIt>
path(_InputIt __first, _InputIt _last, const locale& __loc,
format = format::auto_format);
_LIBCPP_INLINE_VISIBILITY
~path() = default;
// assignments
_LIBCPP_INLINE_VISIBILITY
path& operator=(const path& __p) {
__pn_ = __p.__pn_;
return *this;
}
_LIBCPP_INLINE_VISIBILITY
path& operator=(path&& __p) noexcept {
__pn_ = _VSTD::move(__p.__pn_);
return *this;
}
template <class = void>
_LIBCPP_INLINE_VISIBILITY path& operator=(string_type&& __s) noexcept {
__pn_ = _VSTD::move(__s);
return *this;
}
_LIBCPP_INLINE_VISIBILITY
path& assign(string_type&& __s) noexcept {
__pn_ = _VSTD::move(__s);
return *this;
}
template <class _Source>
_LIBCPP_INLINE_VISIBILITY _EnableIfPathable<_Source>
operator=(const _Source& __src) {
return this->assign(__src);
}
template <class _Source>
_EnableIfPathable<_Source> assign(const _Source& __src) {
__pn_.clear();
_SourceCVT<_Source>::__append_source(__pn_, __src);
return *this;
}
template <class _InputIt>
path& assign(_InputIt __first, _InputIt __last) {
typedef typename iterator_traits<_InputIt>::value_type _ItVal;
__pn_.clear();
_PathCVT<_ItVal>::__append_range(__pn_, __first, __last);
return *this;
}
private:
template <class _ECharT>
static bool __source_is_absolute(_ECharT __first_or_null) {
return __is_separator(__first_or_null);
}
public:
// appends
path& operator/=(const path& __p) {
if (__p.is_absolute()) {
__pn_ = __p.__pn_;
return *this;
}
if (has_filename())
__pn_ += preferred_separator;
__pn_ += __p.native();
return *this;
}
// FIXME: Use _LIBCPP_DIAGNOSE_WARNING to produce a diagnostic when __src
// is known at compile time to be "/' since the user almost certainly intended
// to append a separator instead of overwriting the path with "/"
template <class _Source>
_LIBCPP_INLINE_VISIBILITY _EnableIfPathable<_Source>
operator/=(const _Source& __src) {
return this->append(__src);
}
template <class _Source>
_EnableIfPathable<_Source> append(const _Source& __src) {
using _Traits = __is_pathable<_Source>;
using _CVT = _PathCVT<_SourceChar<_Source> >;
if (__source_is_absolute(_Traits::__first_or_null(__src)))
__pn_.clear();
else if (has_filename())
__pn_ += preferred_separator;
_CVT::__append_source(__pn_, __src);
return *this;
}
template <class _InputIt>
path& append(_InputIt __first, _InputIt __last) {
typedef typename iterator_traits<_InputIt>::value_type _ItVal;
static_assert(__can_convert_char<_ItVal>::value, "Must convertible");
using _CVT = _PathCVT<_ItVal>;
if (__first != __last && __source_is_absolute(*__first))
__pn_.clear();
else if (has_filename())
__pn_ += preferred_separator;
_CVT::__append_range(__pn_, __first, __last);
return *this;
}
// concatenation
_LIBCPP_INLINE_VISIBILITY
path& operator+=(const path& __x) {
__pn_ += __x.__pn_;
return *this;
}
_LIBCPP_INLINE_VISIBILITY
path& operator+=(const string_type& __x) {
__pn_ += __x;
return *this;
}
_LIBCPP_INLINE_VISIBILITY
path& operator+=(__string_view __x) {
__pn_ += __x;
return *this;
}
_LIBCPP_INLINE_VISIBILITY
path& operator+=(const value_type* __x) {
__pn_ += __x;
return *this;
}
_LIBCPP_INLINE_VISIBILITY
path& operator+=(value_type __x) {
__pn_ += __x;
return *this;
}
template <class _ECharT>
typename enable_if<__can_convert_char<_ECharT>::value, path&>::type
operator+=(_ECharT __x) {
basic_string<_ECharT> __tmp;
__tmp += __x;
_PathCVT<_ECharT>::__append_source(__pn_, __tmp);
return *this;
}
template <class _Source>
_EnableIfPathable<_Source> operator+=(const _Source& __x) {
return this->concat(__x);
}
template <class _Source>
_EnableIfPathable<_Source> concat(const _Source& __x) {
_SourceCVT<_Source>::__append_source(__pn_, __x);
return *this;
}
template <class _InputIt>
path& concat(_InputIt __first, _InputIt __last) {
typedef typename iterator_traits<_InputIt>::value_type _ItVal;
_PathCVT<_ItVal>::__append_range(__pn_, __first, __last);
return *this;
}
// modifiers
_LIBCPP_INLINE_VISIBILITY
void clear() noexcept { __pn_.clear(); }
path& make_preferred() { return *this; }
_LIBCPP_INLINE_VISIBILITY
path& remove_filename() {
auto __fname = __filename();
if (!__fname.empty())
__pn_.erase(__fname.data() - __pn_.data());
return *this;
}
path& replace_filename(const path& __replacement) {
remove_filename();
return (*this /= __replacement);
}
path& replace_extension(const path& __replacement = path());
_LIBCPP_INLINE_VISIBILITY
void swap(path& __rhs) noexcept { __pn_.swap(__rhs.__pn_); }
// private helper to allow reserving memory in the path
_LIBCPP_INLINE_VISIBILITY
void __reserve(size_t __s) { __pn_.reserve(__s); }
// native format observers
_LIBCPP_INLINE_VISIBILITY
const string_type& native() const noexcept { return __pn_; }
_LIBCPP_INLINE_VISIBILITY
const value_type* c_str() const noexcept { return __pn_.c_str(); }
_LIBCPP_INLINE_VISIBILITY operator string_type() const { return __pn_; }
template <class _ECharT, class _Traits = char_traits<_ECharT>,
class _Allocator = allocator<_ECharT> >
basic_string<_ECharT, _Traits, _Allocator>
string(const _Allocator& __a = _Allocator()) const {
using _CVT = __widen_from_utf8<sizeof(_ECharT) * __CHAR_BIT__>;
using _Str = basic_string<_ECharT, _Traits, _Allocator>;
_Str __s(__a);
__s.reserve(__pn_.size());
_CVT()(back_inserter(__s), __pn_.data(), __pn_.data() + __pn_.size());
return __s;
}
_LIBCPP_INLINE_VISIBILITY std::string string() const { return __pn_; }
_LIBCPP_INLINE_VISIBILITY std::wstring wstring() const {
return string<wchar_t>();
}
_LIBCPP_INLINE_VISIBILITY std::string u8string() const { return __pn_; }
_LIBCPP_INLINE_VISIBILITY std::u16string u16string() const {
return string<char16_t>();
}
_LIBCPP_INLINE_VISIBILITY std::u32string u32string() const {
return string<char32_t>();
}
// generic format observers
template <class _ECharT, class _Traits = char_traits<_ECharT>,
class _Allocator = allocator<_ECharT> >
basic_string<_ECharT, _Traits, _Allocator>
generic_string(const _Allocator& __a = _Allocator()) const {
return string<_ECharT, _Traits, _Allocator>(__a);
}
std::string generic_string() const { return __pn_; }
std::wstring generic_wstring() const { return string<wchar_t>(); }
std::string generic_u8string() const { return __pn_; }
std::u16string generic_u16string() const { return string<char16_t>(); }
std::u32string generic_u32string() const { return string<char32_t>(); }
private:
int __compare(__string_view) const;
__string_view __root_name() const;
__string_view __root_directory() const;
__string_view __root_path_raw() const;
__string_view __relative_path() const;
__string_view __parent_path() const;
__string_view __filename() const;
__string_view __stem() const;
__string_view __extension() const;
public:
// compare
_LIBCPP_INLINE_VISIBILITY int compare(const path& __p) const noexcept {
return __compare(__p.__pn_);
}
_LIBCPP_INLINE_VISIBILITY int compare(const string_type& __s) const {
return __compare(__s);
}
_LIBCPP_INLINE_VISIBILITY int compare(__string_view __s) const {
return __compare(__s);
}
_LIBCPP_INLINE_VISIBILITY int compare(const value_type* __s) const {
return __compare(__s);
}
// decomposition
_LIBCPP_INLINE_VISIBILITY path root_name() const {
return string_type(__root_name());
}
_LIBCPP_INLINE_VISIBILITY path root_directory() const {
return string_type(__root_directory());
}
_LIBCPP_INLINE_VISIBILITY path root_path() const {
return root_name().append(string_type(__root_directory()));
}
_LIBCPP_INLINE_VISIBILITY path relative_path() const {
return string_type(__relative_path());
}
_LIBCPP_INLINE_VISIBILITY path parent_path() const {
return string_type(__parent_path());
}
_LIBCPP_INLINE_VISIBILITY path filename() const {
return string_type(__filename());
}
_LIBCPP_INLINE_VISIBILITY path stem() const { return string_type(__stem()); }
_LIBCPP_INLINE_VISIBILITY path extension() const {
return string_type(__extension());
}
// query
_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY bool
empty() const noexcept {
return __pn_.empty();
}
_LIBCPP_INLINE_VISIBILITY bool has_root_name() const {
return !__root_name().empty();
}
_LIBCPP_INLINE_VISIBILITY bool has_root_directory() const {
return !__root_directory().empty();
}
_LIBCPP_INLINE_VISIBILITY bool has_root_path() const {
return !__root_path_raw().empty();
}
_LIBCPP_INLINE_VISIBILITY bool has_relative_path() const {
return !__relative_path().empty();
}
_LIBCPP_INLINE_VISIBILITY bool has_parent_path() const {
return !__parent_path().empty();
}
_LIBCPP_INLINE_VISIBILITY bool has_filename() const {
return !__filename().empty();
}
_LIBCPP_INLINE_VISIBILITY bool has_stem() const { return !__stem().empty(); }
_LIBCPP_INLINE_VISIBILITY bool has_extension() const {
return !__extension().empty();
}
_LIBCPP_INLINE_VISIBILITY bool is_absolute() const {
return has_root_directory();
}
_LIBCPP_INLINE_VISIBILITY bool is_relative() const { return !is_absolute(); }
// relative paths
path lexically_normal() const;
path lexically_relative(const path& __base) const;
_LIBCPP_INLINE_VISIBILITY path lexically_proximate(const path& __base) const {
path __result = this->lexically_relative(__base);
if (__result.native().empty())
return *this;
return __result;
}
// iterators
class _LIBCPP_TYPE_VIS iterator;
typedef iterator const_iterator;
iterator begin() const;
iterator end() const;
template <class _CharT, class _Traits>
_LIBCPP_INLINE_VISIBILITY friend
typename enable_if<is_same<_CharT, char>::value &&
is_same<_Traits, char_traits<char> >::value,
basic_ostream<_CharT, _Traits>&>::type
operator<<(basic_ostream<_CharT, _Traits>& __os, const path& __p) {
__os << std::__quoted(__p.native());
return __os;
}
template <class _CharT, class _Traits>
_LIBCPP_INLINE_VISIBILITY friend
typename enable_if<!is_same<_CharT, char>::value ||
!is_same<_Traits, char_traits<char> >::value,
basic_ostream<_CharT, _Traits>&>::type
operator<<(basic_ostream<_CharT, _Traits>& __os, const path& __p) {
__os << std::__quoted(__p.string<_CharT, _Traits>());
return __os;
}
template <class _CharT, class _Traits>
_LIBCPP_INLINE_VISIBILITY friend basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, path& __p) {
basic_string<_CharT, _Traits> __tmp;
__is >> __quoted(__tmp);
__p = __tmp;
return __is;
}
private:
inline _LIBCPP_INLINE_VISIBILITY path&
__assign_view(__string_view const& __s) noexcept {
__pn_ = string_type(__s);
return *this;
}
string_type __pn_;
};
inline _LIBCPP_INLINE_VISIBILITY void swap(path& __lhs, path& __rhs) noexcept {
__lhs.swap(__rhs);
}
_LIBCPP_FUNC_VIS
size_t hash_value(const path& __p) noexcept;
inline _LIBCPP_INLINE_VISIBILITY bool operator==(const path& __lhs,
const path& __rhs) noexcept {
return __lhs.compare(__rhs) == 0;
}
inline _LIBCPP_INLINE_VISIBILITY bool operator!=(const path& __lhs,
const path& __rhs) noexcept {
return __lhs.compare(__rhs) != 0;
}
inline _LIBCPP_INLINE_VISIBILITY bool operator<(const path& __lhs,
const path& __rhs) noexcept {
return __lhs.compare(__rhs) < 0;
}
inline _LIBCPP_INLINE_VISIBILITY bool operator<=(const path& __lhs,
const path& __rhs) noexcept {
return __lhs.compare(__rhs) <= 0;
}
inline _LIBCPP_INLINE_VISIBILITY bool operator>(const path& __lhs,
const path& __rhs) noexcept {
return __lhs.compare(__rhs) > 0;
}
inline _LIBCPP_INLINE_VISIBILITY bool operator>=(const path& __lhs,
const path& __rhs) noexcept {
return __lhs.compare(__rhs) >= 0;
}
inline _LIBCPP_INLINE_VISIBILITY path operator/(const path& __lhs,
const path& __rhs) {
path __result(__lhs);
__result /= __rhs;
return __result;
}
template <class _Source>
_LIBCPP_INLINE_VISIBILITY
typename enable_if<__is_pathable<_Source>::value, path>::type
u8path(const _Source& __s) {
static_assert(
is_same<typename __is_pathable<_Source>::__char_type, char>::value,
"u8path(Source const&) requires Source have a character type of type "
"'char'");
return path(__s);
}
template <class _InputIt>
_LIBCPP_INLINE_VISIBILITY
typename enable_if<__is_pathable<_InputIt>::value, path>::type
u8path(_InputIt __f, _InputIt __l) {
static_assert(
is_same<typename __is_pathable<_InputIt>::__char_type, char>::value,
"u8path(Iter, Iter) requires Iter have a value_type of type 'char'");
return path(__f, __l);
}
class _LIBCPP_TYPE_VIS path::iterator {
public:
enum _ParserState : unsigned char {
_Singular,
_BeforeBegin,
_InRootName,
_InRootDir,
_InFilenames,
_InTrailingSep,
_AtEnd
};
public:
typedef bidirectional_iterator_tag iterator_category;
typedef path value_type;
typedef std::ptrdiff_t difference_type;
typedef const path* pointer;
typedef const path& reference;
typedef void
__stashing_iterator_tag; // See reverse_iterator and __is_stashing_iterator
public:
_LIBCPP_INLINE_VISIBILITY
iterator()
: __stashed_elem_(), __path_ptr_(nullptr), __entry_(),
__state_(_Singular) {}
iterator(const iterator&) = default;
~iterator() = default;
iterator& operator=(const iterator&) = default;
_LIBCPP_INLINE_VISIBILITY
reference operator*() const { return __stashed_elem_; }
_LIBCPP_INLINE_VISIBILITY
pointer operator->() const { return &__stashed_elem_; }
_LIBCPP_INLINE_VISIBILITY
iterator& operator++() {
_LIBCPP_ASSERT(__state_ != _Singular,
"attempting to increment a singular iterator");
_LIBCPP_ASSERT(__state_ != _AtEnd,
"attempting to increment the end iterator");
return __increment();
}
_LIBCPP_INLINE_VISIBILITY
iterator operator++(int) {
iterator __it(*this);
this->operator++();
return __it;
}
_LIBCPP_INLINE_VISIBILITY
iterator& operator--() {
_LIBCPP_ASSERT(__state_ != _Singular,
"attempting to decrement a singular iterator");
_LIBCPP_ASSERT(__entry_.data() != __path_ptr_->native().data(),
"attempting to decrement the begin iterator");
return __decrement();
}
_LIBCPP_INLINE_VISIBILITY
iterator operator--(int) {
iterator __it(*this);
this->operator--();
return __it;
}
private:
friend class path;
inline _LIBCPP_INLINE_VISIBILITY friend bool operator==(const iterator&,
const iterator&);
iterator& __increment();
iterator& __decrement();
path __stashed_elem_;
const path* __path_ptr_;
path::__string_view __entry_;
_ParserState __state_;
};
inline _LIBCPP_INLINE_VISIBILITY bool operator==(const path::iterator& __lhs,
const path::iterator& __rhs) {
return __lhs.__path_ptr_ == __rhs.__path_ptr_ &&
__lhs.__entry_.data() == __rhs.__entry_.data();
}
inline _LIBCPP_INLINE_VISIBILITY bool operator!=(const path::iterator& __lhs,
const path::iterator& __rhs) {
return !(__lhs == __rhs);
}
class _LIBCPP_EXCEPTION_ABI filesystem_error : public system_error {
public:
_LIBCPP_INLINE_VISIBILITY
filesystem_error(const string& __what, error_code __ec)
: system_error(__ec, __what),
__storage_(make_shared<_Storage>(path(), path())) {
__create_what(0);
}
_LIBCPP_INLINE_VISIBILITY
filesystem_error(const string& __what, const path& __p1, error_code __ec)
: system_error(__ec, __what),
__storage_(make_shared<_Storage>(__p1, path())) {
__create_what(1);
}
_LIBCPP_INLINE_VISIBILITY
filesystem_error(const string& __what, const path& __p1, const path& __p2,
error_code __ec)
: system_error(__ec, __what),
__storage_(make_shared<_Storage>(__p1, __p2)) {
__create_what(2);
}
_LIBCPP_INLINE_VISIBILITY
const path& path1() const noexcept { return __storage_->__p1_; }
_LIBCPP_INLINE_VISIBILITY
const path& path2() const noexcept { return __storage_->__p2_; }
~filesystem_error() override; // key function
_LIBCPP_INLINE_VISIBILITY
const char* what() const noexcept override {
return __storage_->__what_.c_str();
}
_LIBCPP_FUNC_VIS
void __create_what(int __num_paths);
private:
struct _Storage {
_LIBCPP_INLINE_VISIBILITY
_Storage(const path& __p1, const path& __p2) : __p1_(__p1), __p2_(__p2) {}
path __p1_;
path __p2_;
string __what_;
};
shared_ptr<_Storage> __storage_;
};
template <class... _Args>
_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
#ifndef _LIBCPP_NO_EXCEPTIONS
void
__throw_filesystem_error(_Args&&... __args) {
throw filesystem_error(std::forward<_Args>(__args)...);
}
#else
void
__throw_filesystem_error(_Args&&...) {
_VSTD::abort();
}
#endif
// operational functions
_LIBCPP_FUNC_VIS
path __absolute(const path&, error_code* __ec = nullptr);
_LIBCPP_FUNC_VIS
path __canonical(const path&, error_code* __ec = nullptr);
_LIBCPP_FUNC_VIS
void __copy(const path& __from, const path& __to, copy_options __opt,
error_code* __ec = nullptr);
_LIBCPP_FUNC_VIS
bool __copy_file(const path& __from, const path& __to, copy_options __opt,
error_code* __ec = nullptr);
_LIBCPP_FUNC_VIS
void __copy_symlink(const path& __existing_symlink, const path& __new_symlink,
error_code* __ec = nullptr);
_LIBCPP_FUNC_VIS
bool __create_directories(const path& p, error_code* ec = nullptr);
_LIBCPP_FUNC_VIS
bool __create_directory(const path& p, error_code* ec = nullptr);
_LIBCPP_FUNC_VIS
bool __create_directory(const path& p, const path& attributes,
error_code* ec = nullptr);
_LIBCPP_FUNC_VIS
void __create_directory_symlink(const path& __to, const path& __new_symlink,
error_code* __ec = nullptr);
_LIBCPP_FUNC_VIS
void __create_hard_link(const path& __to, const path& __new_hard_link,
error_code* __ec = nullptr);
_LIBCPP_FUNC_VIS
void __create_symlink(const path& __to, const path& __new_symlink,
error_code* __ec = nullptr);
_LIBCPP_FUNC_VIS
path __current_path(error_code* __ec = nullptr);
_LIBCPP_FUNC_VIS
void __current_path(const path&, error_code* __ec = nullptr);
_LIBCPP_FUNC_VIS
bool __equivalent(const path&, const path&, error_code* __ec = nullptr);
_LIBCPP_FUNC_VIS
uintmax_t __file_size(const path&, error_code* __ec = nullptr);
_LIBCPP_FUNC_VIS
uintmax_t __hard_link_count(const path&, error_code* __ec = nullptr);
_LIBCPP_FUNC_VIS
bool __fs_is_empty(const path& p, error_code* ec = nullptr);
_LIBCPP_FUNC_VIS
file_time_type __last_write_time(const path& p, error_code* ec = nullptr);
_LIBCPP_FUNC_VIS
void __last_write_time(const path& p, file_time_type new_time,
error_code* ec = nullptr);
_LIBCPP_FUNC_VIS
void __permissions(const path&, perms, perm_options, error_code* = nullptr);
_LIBCPP_FUNC_VIS
path __read_symlink(const path& p, error_code* ec = nullptr);
_LIBCPP_FUNC_VIS
bool __remove(const path& p, error_code* ec = nullptr);
_LIBCPP_FUNC_VIS
uintmax_t __remove_all(const path& p, error_code* ec = nullptr);
_LIBCPP_FUNC_VIS
void __rename(const path& from, const path& to, error_code* ec = nullptr);
_LIBCPP_FUNC_VIS
void __resize_file(const path& p, uintmax_t size, error_code* ec = nullptr);
_LIBCPP_FUNC_VIS
space_info __space(const path&, error_code* __ec = nullptr);
_LIBCPP_FUNC_VIS
file_status __status(const path&, error_code* __ec = nullptr);
_LIBCPP_FUNC_VIS
file_status __symlink_status(const path&, error_code* __ec = nullptr);
_LIBCPP_FUNC_VIS
path __system_complete(const path&, error_code* __ec = nullptr);
_LIBCPP_FUNC_VIS
path __temp_directory_path(error_code* __ec = nullptr);
_LIBCPP_FUNC_VIS
path __weakly_canonical(path const& __p, error_code* __ec = nullptr);
inline _LIBCPP_INLINE_VISIBILITY path current_path() {
return __current_path();
}
inline _LIBCPP_INLINE_VISIBILITY path current_path(error_code& __ec) {
return __current_path(&__ec);
}
inline _LIBCPP_INLINE_VISIBILITY void current_path(const path& __p) {
__current_path(__p);
}
inline _LIBCPP_INLINE_VISIBILITY void current_path(const path& __p,
error_code& __ec) noexcept {
__current_path(__p, &__ec);
}
inline _LIBCPP_INLINE_VISIBILITY path absolute(const path& __p) {
return __absolute(__p);
}
inline _LIBCPP_INLINE_VISIBILITY path absolute(const path& __p,
error_code& __ec) {
return __absolute(__p, &__ec);
}
inline _LIBCPP_INLINE_VISIBILITY path canonical(const path& __p) {
return __canonical(__p);
}
inline _LIBCPP_INLINE_VISIBILITY path canonical(const path& __p,
error_code& __ec) {
return __canonical(__p, &__ec);
}
inline _LIBCPP_INLINE_VISIBILITY void copy(const path& __from,
const path& __to) {
__copy(__from, __to, copy_options::none);
}
inline _LIBCPP_INLINE_VISIBILITY void copy(const path& __from, const path& __to,
error_code& __ec) {
__copy(__from, __to, copy_options::none, &__ec);
}
inline _LIBCPP_INLINE_VISIBILITY void copy(const path& __from, const path& __to,
copy_options __opt) {
__copy(__from, __to, __opt);
}
inline _LIBCPP_INLINE_VISIBILITY void copy(const path& __from, const path& __to,
copy_options __opt,
error_code& __ec) {
__copy(__from, __to, __opt, &__ec);
}
inline _LIBCPP_INLINE_VISIBILITY bool copy_file(const path& __from,
const path& __to) {
return __copy_file(__from, __to, copy_options::none);
}
inline _LIBCPP_INLINE_VISIBILITY bool
copy_file(const path& __from, const path& __to, error_code& __ec) {
return __copy_file(__from, __to, copy_options::none, &__ec);
}
inline _LIBCPP_INLINE_VISIBILITY bool
copy_file(const path& __from, const path& __to, copy_options __opt) {
return __copy_file(__from, __to, __opt);
}
inline _LIBCPP_INLINE_VISIBILITY bool copy_file(const path& __from,
const path& __to,
copy_options __opt,
error_code& __ec) {
return __copy_file(__from, __to, __opt, &__ec);
}
inline _LIBCPP_INLINE_VISIBILITY void copy_symlink(const path& __existing,
const path& __new) {
__copy_symlink(__existing, __new);
}
inline _LIBCPP_INLINE_VISIBILITY void
copy_symlink(const path& __ext, const path& __new, error_code& __ec) noexcept {
__copy_symlink(__ext, __new, &__ec);
}
inline _LIBCPP_INLINE_VISIBILITY bool create_directories(const path& __p) {
return __create_directories(__p);
}
inline _LIBCPP_INLINE_VISIBILITY bool create_directories(const path& __p,
error_code& __ec) {
return __create_directories(__p, &__ec);
}
inline _LIBCPP_INLINE_VISIBILITY bool create_directory(const path& __p) {
return __create_directory(__p);
}
inline _LIBCPP_INLINE_VISIBILITY bool
create_directory(const path& __p, error_code& __ec) noexcept {
return __create_directory(__p, &__ec);
}
inline _LIBCPP_INLINE_VISIBILITY bool create_directory(const path& __p,
const path& __attrs) {
return __create_directory(__p, __attrs);
}
inline _LIBCPP_INLINE_VISIBILITY bool
create_directory(const path& __p, const path& __attrs,
error_code& __ec) noexcept {
return __create_directory(__p, __attrs, &__ec);
}
inline _LIBCPP_INLINE_VISIBILITY void
create_directory_symlink(const path& __to, const path& __new) {
__create_directory_symlink(__to, __new);
}
inline _LIBCPP_INLINE_VISIBILITY void
create_directory_symlink(const path& __to, const path& __new,
error_code& __ec) noexcept {
__create_directory_symlink(__to, __new, &__ec);
}
inline _LIBCPP_INLINE_VISIBILITY void create_hard_link(const path& __to,
const path& __new) {
__create_hard_link(__to, __new);
}
inline _LIBCPP_INLINE_VISIBILITY void
create_hard_link(const path& __to, const path& __new,
error_code& __ec) noexcept {
__create_hard_link(__to, __new, &__ec);
}
inline _LIBCPP_INLINE_VISIBILITY void create_symlink(const path& __to,
const path& __new) {
__create_symlink(__to, __new);
}
inline _LIBCPP_INLINE_VISIBILITY void
create_symlink(const path& __to, const path& __new, error_code& __ec) noexcept {
return __create_symlink(__to, __new, &__ec);
}
inline _LIBCPP_INLINE_VISIBILITY bool status_known(file_status __s) noexcept {
return __s.type() != file_type::none;
}
inline _LIBCPP_INLINE_VISIBILITY bool exists(file_status __s) noexcept {
return status_known(__s) && __s.type() != file_type::not_found;
}
inline _LIBCPP_INLINE_VISIBILITY bool exists(const path& __p) {
return exists(__status(__p));
}
inline _LIBCPP_INLINE_VISIBILITY bool exists(const path& __p,
error_code& __ec) noexcept {
auto __s = __status(__p, &__ec);
if (status_known(__s))
__ec.clear();
return exists(__s);
}
inline _LIBCPP_INLINE_VISIBILITY bool equivalent(const path& __p1,
const path& __p2) {
return __equivalent(__p1, __p2);
}
inline _LIBCPP_INLINE_VISIBILITY bool
equivalent(const path& __p1, const path& __p2, error_code& __ec) noexcept {
return __equivalent(__p1, __p2, &__ec);
}
inline _LIBCPP_INLINE_VISIBILITY uintmax_t file_size(const path& __p) {
return __file_size(__p);
}
inline _LIBCPP_INLINE_VISIBILITY uintmax_t
file_size(const path& __p, error_code& __ec) noexcept {
return __file_size(__p, &__ec);
}
inline _LIBCPP_INLINE_VISIBILITY uintmax_t hard_link_count(const path& __p) {
return __hard_link_count(__p);
}
inline _LIBCPP_INLINE_VISIBILITY uintmax_t
hard_link_count(const path& __p, error_code& __ec) noexcept {
return __hard_link_count(__p, &__ec);
}
inline _LIBCPP_INLINE_VISIBILITY bool is_block_file(file_status __s) noexcept {
return __s.type() == file_type::block;
}
inline _LIBCPP_INLINE_VISIBILITY bool is_block_file(const path& __p) {
return is_block_file(__status(__p));
}
inline _LIBCPP_INLINE_VISIBILITY bool is_block_file(const path& __p,
error_code& __ec) noexcept {
return is_block_file(__status(__p, &__ec));
}
inline _LIBCPP_INLINE_VISIBILITY bool
is_character_file(file_status __s) noexcept {
return __s.type() == file_type::character;
}
inline _LIBCPP_INLINE_VISIBILITY bool is_character_file(const path& __p) {
return is_character_file(__status(__p));
}
inline _LIBCPP_INLINE_VISIBILITY bool
is_character_file(const path& __p, error_code& __ec) noexcept {
return is_character_file(__status(__p, &__ec));
}
inline _LIBCPP_INLINE_VISIBILITY bool is_directory(file_status __s) noexcept {
return __s.type() == file_type::directory;
}
inline _LIBCPP_INLINE_VISIBILITY bool is_directory(const path& __p) {
return is_directory(__status(__p));
}
inline _LIBCPP_INLINE_VISIBILITY bool is_directory(const path& __p,
error_code& __ec) noexcept {
return is_directory(__status(__p, &__ec));
}
inline _LIBCPP_INLINE_VISIBILITY bool is_empty(const path& __p) {
return __fs_is_empty(__p);
}
inline _LIBCPP_INLINE_VISIBILITY bool is_empty(const path& __p,
error_code& __ec) {
return __fs_is_empty(__p, &__ec);
}
inline _LIBCPP_INLINE_VISIBILITY bool is_fifo(file_status __s) noexcept {
return __s.type() == file_type::fifo;
}
inline _LIBCPP_INLINE_VISIBILITY bool is_fifo(const path& __p) {
return is_fifo(__status(__p));
}
inline _LIBCPP_INLINE_VISIBILITY bool is_fifo(const path& __p,
error_code& __ec) noexcept {
return is_fifo(__status(__p, &__ec));
}
inline _LIBCPP_INLINE_VISIBILITY bool
is_regular_file(file_status __s) noexcept {
return __s.type() == file_type::regular;
}
inline _LIBCPP_INLINE_VISIBILITY bool is_regular_file(const path& __p) {
return is_regular_file(__status(__p));
}
inline _LIBCPP_INLINE_VISIBILITY bool
is_regular_file(const path& __p, error_code& __ec) noexcept {
return is_regular_file(__status(__p, &__ec));
}
inline _LIBCPP_INLINE_VISIBILITY bool is_socket(file_status __s) noexcept {
return __s.type() == file_type::socket;
}
inline _LIBCPP_INLINE_VISIBILITY bool is_socket(const path& __p) {
return is_socket(__status(__p));
}
inline _LIBCPP_INLINE_VISIBILITY bool is_socket(const path& __p,
error_code& __ec) noexcept {
return is_socket(__status(__p, &__ec));
}
inline _LIBCPP_INLINE_VISIBILITY bool is_symlink(file_status __s) noexcept {
return __s.type() == file_type::symlink;
}
inline _LIBCPP_INLINE_VISIBILITY bool is_symlink(const path& __p) {
return is_symlink(__symlink_status(__p));
}
inline _LIBCPP_INLINE_VISIBILITY bool is_symlink(const path& __p,
error_code& __ec) noexcept {
return is_symlink(__symlink_status(__p, &__ec));
}
inline _LIBCPP_INLINE_VISIBILITY bool is_other(file_status __s) noexcept {
return exists(__s) && !is_regular_file(__s) && !is_directory(__s) &&
!is_symlink(__s);
}
inline _LIBCPP_INLINE_VISIBILITY bool is_other(const path& __p) {
return is_other(__status(__p));
}
inline _LIBCPP_INLINE_VISIBILITY bool is_other(const path& __p,
error_code& __ec) noexcept {
return is_other(__status(__p, &__ec));
}
inline _LIBCPP_INLINE_VISIBILITY file_time_type
last_write_time(const path& __p) {
return __last_write_time(__p);
}
inline _LIBCPP_INLINE_VISIBILITY file_time_type
last_write_time(const path& __p, error_code& __ec) noexcept {
return __last_write_time(__p, &__ec);
}
inline _LIBCPP_INLINE_VISIBILITY void last_write_time(const path& __p,
file_time_type __t) {
__last_write_time(__p, __t);
}
inline _LIBCPP_INLINE_VISIBILITY void
last_write_time(const path& __p, file_time_type __t,
error_code& __ec) noexcept {
__last_write_time(__p, __t, &__ec);
}
inline _LIBCPP_INLINE_VISIBILITY void
permissions(const path& __p, perms __prms,
perm_options __opts = perm_options::replace) {
__permissions(__p, __prms, __opts);
}
inline _LIBCPP_INLINE_VISIBILITY void permissions(const path& __p, perms __prms,
error_code& __ec) noexcept {
__permissions(__p, __prms, perm_options::replace, &__ec);
}
inline _LIBCPP_INLINE_VISIBILITY void permissions(const path& __p, perms __prms,
perm_options __opts,
error_code& __ec) {
__permissions(__p, __prms, __opts, &__ec);
}
inline _LIBCPP_INLINE_VISIBILITY path proximate(const path& __p,
const path& __base,
error_code& __ec) {
path __tmp = __weakly_canonical(__p, &__ec);
if (__ec)
return {};
path __tmp_base = __weakly_canonical(__base, &__ec);
if (__ec)
return {};
return __tmp.lexically_proximate(__tmp_base);
}
inline _LIBCPP_INLINE_VISIBILITY path proximate(const path& __p,
error_code& __ec) {
return proximate(__p, current_path(), __ec);
}
inline _LIBCPP_INLINE_VISIBILITY path
proximate(const path& __p, const path& __base = current_path()) {
return __weakly_canonical(__p).lexically_proximate(
__weakly_canonical(__base));
}
inline _LIBCPP_INLINE_VISIBILITY path read_symlink(const path& __p) {
return __read_symlink(__p);
}
inline _LIBCPP_INLINE_VISIBILITY path read_symlink(const path& __p,
error_code& __ec) {
return __read_symlink(__p, &__ec);
}
inline _LIBCPP_INLINE_VISIBILITY path relative(const path& __p,
const path& __base,
error_code& __ec) {
path __tmp = __weakly_canonical(__p, &__ec);
if (__ec)
return path();
path __tmpbase = __weakly_canonical(__base, &__ec);
if (__ec)
return path();
return __tmp.lexically_relative(__tmpbase);
}
inline _LIBCPP_INLINE_VISIBILITY path relative(const path& __p,
error_code& __ec) {
return relative(__p, current_path(), __ec);
}
inline _LIBCPP_INLINE_VISIBILITY path
relative(const path& __p, const path& __base = current_path()) {
return __weakly_canonical(__p).lexically_relative(__weakly_canonical(__base));
}
inline _LIBCPP_INLINE_VISIBILITY bool remove(const path& __p) {
return __remove(__p);
}
inline _LIBCPP_INLINE_VISIBILITY bool remove(const path& __p,
error_code& __ec) noexcept {
return __remove(__p, &__ec);
}
inline _LIBCPP_INLINE_VISIBILITY uintmax_t remove_all(const path& __p) {
return __remove_all(__p);
}
inline _LIBCPP_INLINE_VISIBILITY uintmax_t remove_all(const path& __p,
error_code& __ec) {
return __remove_all(__p, &__ec);
}
inline _LIBCPP_INLINE_VISIBILITY void rename(const path& __from,
const path& __to) {
return __rename(__from, __to);
}
inline _LIBCPP_INLINE_VISIBILITY void
rename(const path& __from, const path& __to, error_code& __ec) noexcept {
return __rename(__from, __to, &__ec);
}
inline _LIBCPP_INLINE_VISIBILITY void resize_file(const path& __p,
uintmax_t __ns) {
return __resize_file(__p, __ns);
}
inline _LIBCPP_INLINE_VISIBILITY void
resize_file(const path& __p, uintmax_t __ns, error_code& __ec) noexcept {
return __resize_file(__p, __ns, &__ec);
}
inline _LIBCPP_INLINE_VISIBILITY space_info space(const path& __p) {
return __space(__p);
}
inline _LIBCPP_INLINE_VISIBILITY space_info space(const path& __p,
error_code& __ec) noexcept {
return __space(__p, &__ec);
}
inline _LIBCPP_INLINE_VISIBILITY file_status status(const path& __p) {
return __status(__p);
}
inline _LIBCPP_INLINE_VISIBILITY file_status status(const path& __p,
error_code& __ec) noexcept {
return __status(__p, &__ec);
}
inline _LIBCPP_INLINE_VISIBILITY file_status symlink_status(const path& __p) {
return __symlink_status(__p);
}
inline _LIBCPP_INLINE_VISIBILITY file_status
symlink_status(const path& __p, error_code& __ec) noexcept {
return __symlink_status(__p, &__ec);
}
inline _LIBCPP_INLINE_VISIBILITY path temp_directory_path() {
return __temp_directory_path();
}
inline _LIBCPP_INLINE_VISIBILITY path temp_directory_path(error_code& __ec) {
return __temp_directory_path(&__ec);
}
inline _LIBCPP_INLINE_VISIBILITY path weakly_canonical(path const& __p) {
return __weakly_canonical(__p);
}
inline _LIBCPP_INLINE_VISIBILITY path weakly_canonical(path const& __p,
error_code& __ec) {
return __weakly_canonical(__p, &__ec);
}
class directory_iterator;
class recursive_directory_iterator;
class __dir_stream;
class directory_entry {
typedef _VSTD_FS::path _Path;
public:
// constructors and destructors
directory_entry() noexcept = default;
directory_entry(directory_entry const&) = default;
directory_entry(directory_entry&&) noexcept = default;
_LIBCPP_INLINE_VISIBILITY
explicit directory_entry(_Path const& __p) : __p_(__p) {
error_code __ec;
__refresh(&__ec);
}
_LIBCPP_INLINE_VISIBILITY
directory_entry(_Path const& __p, error_code& __ec) : __p_(__p) {
__refresh(&__ec);
}
~directory_entry() {}
directory_entry& operator=(directory_entry const&) = default;
directory_entry& operator=(directory_entry&&) noexcept = default;
_LIBCPP_INLINE_VISIBILITY
void assign(_Path const& __p) {
__p_ = __p;
error_code __ec;
__refresh(&__ec);
}
_LIBCPP_INLINE_VISIBILITY
void assign(_Path const& __p, error_code& __ec) {
__p_ = __p;
__refresh(&__ec);
}
_LIBCPP_INLINE_VISIBILITY
void replace_filename(_Path const& __p) {
__p_.replace_filename(__p);
error_code __ec;
__refresh(&__ec);
}
_LIBCPP_INLINE_VISIBILITY
void replace_filename(_Path const& __p, error_code& __ec) {
__p_ = __p_.parent_path() / __p;
__refresh(&__ec);
}
_LIBCPP_INLINE_VISIBILITY
void refresh() { __refresh(); }
_LIBCPP_INLINE_VISIBILITY
void refresh(error_code& __ec) noexcept { __refresh(&__ec); }
_LIBCPP_INLINE_VISIBILITY
_Path const& path() const noexcept { return __p_; }
_LIBCPP_INLINE_VISIBILITY
operator const _Path&() const noexcept { return __p_; }
_LIBCPP_INLINE_VISIBILITY
bool exists() const { return _VSTD_FS::exists(file_status{__get_ft()}); }
_LIBCPP_INLINE_VISIBILITY
bool exists(error_code& __ec) const noexcept {
return _VSTD_FS::exists(file_status{__get_ft(&__ec)});
}
_LIBCPP_INLINE_VISIBILITY
bool is_block_file() const { return __get_ft() == file_type::block; }
_LIBCPP_INLINE_VISIBILITY
bool is_block_file(error_code& __ec) const noexcept {
return __get_ft(&__ec) == file_type::block;
}
_LIBCPP_INLINE_VISIBILITY
bool is_character_file() const { return __get_ft() == file_type::character; }
_LIBCPP_INLINE_VISIBILITY
bool is_character_file(error_code& __ec) const noexcept {
return __get_ft(&__ec) == file_type::character;
}
_LIBCPP_INLINE_VISIBILITY
bool is_directory() const { return __get_ft() == file_type::directory; }
_LIBCPP_INLINE_VISIBILITY
bool is_directory(error_code& __ec) const noexcept {
return __get_ft(&__ec) == file_type::directory;
}
_LIBCPP_INLINE_VISIBILITY
bool is_fifo() const { return __get_ft() == file_type::fifo; }
_LIBCPP_INLINE_VISIBILITY
bool is_fifo(error_code& __ec) const noexcept {
return __get_ft(&__ec) == file_type::fifo;
}
_LIBCPP_INLINE_VISIBILITY
bool is_other() const { return _VSTD_FS::is_other(file_status{__get_ft()}); }
_LIBCPP_INLINE_VISIBILITY
bool is_other(error_code& __ec) const noexcept {
return _VSTD_FS::is_other(file_status{__get_ft(&__ec)});
}
_LIBCPP_INLINE_VISIBILITY
bool is_regular_file() const { return __get_ft() == file_type::regular; }
_LIBCPP_INLINE_VISIBILITY
bool is_regular_file(error_code& __ec) const noexcept {
return __get_ft(&__ec) == file_type::regular;
}
_LIBCPP_INLINE_VISIBILITY
bool is_socket() const { return __get_ft() == file_type::socket; }
_LIBCPP_INLINE_VISIBILITY
bool is_socket(error_code& __ec) const noexcept {
return __get_ft(&__ec) == file_type::socket;
}
_LIBCPP_INLINE_VISIBILITY
bool is_symlink() const { return __get_sym_ft() == file_type::symlink; }
_LIBCPP_INLINE_VISIBILITY
bool is_symlink(error_code& __ec) const noexcept {
return __get_sym_ft(&__ec) == file_type::symlink;
}
_LIBCPP_INLINE_VISIBILITY
uintmax_t file_size() const { return __get_size(); }
_LIBCPP_INLINE_VISIBILITY
uintmax_t file_size(error_code& __ec) const noexcept {
return __get_size(&__ec);
}
_LIBCPP_INLINE_VISIBILITY
uintmax_t hard_link_count() const { return __get_nlink(); }
_LIBCPP_INLINE_VISIBILITY
uintmax_t hard_link_count(error_code& __ec) const noexcept {
return __get_nlink(&__ec);
}
_LIBCPP_INLINE_VISIBILITY
file_time_type last_write_time() const { return __get_write_time(); }
_LIBCPP_INLINE_VISIBILITY
file_time_type last_write_time(error_code& __ec) const noexcept {
return __get_write_time(&__ec);
}
_LIBCPP_INLINE_VISIBILITY
file_status status() const { return __get_status(); }
_LIBCPP_INLINE_VISIBILITY
file_status status(error_code& __ec) const noexcept {
return __get_status(&__ec);
}
_LIBCPP_INLINE_VISIBILITY
file_status symlink_status() const { return __get_symlink_status(); }
_LIBCPP_INLINE_VISIBILITY
file_status symlink_status(error_code& __ec) const noexcept {
return __get_symlink_status(&__ec);
}
_LIBCPP_INLINE_VISIBILITY
bool operator<(directory_entry const& __rhs) const noexcept {
return __p_ < __rhs.__p_;
}
_LIBCPP_INLINE_VISIBILITY
bool operator==(directory_entry const& __rhs) const noexcept {
return __p_ == __rhs.__p_;
}
_LIBCPP_INLINE_VISIBILITY
bool operator!=(directory_entry const& __rhs) const noexcept {
return __p_ != __rhs.__p_;
}
_LIBCPP_INLINE_VISIBILITY
bool operator<=(directory_entry const& __rhs) const noexcept {
return __p_ <= __rhs.__p_;
}
_LIBCPP_INLINE_VISIBILITY
bool operator>(directory_entry const& __rhs) const noexcept {
return __p_ > __rhs.__p_;
}
_LIBCPP_INLINE_VISIBILITY
bool operator>=(directory_entry const& __rhs) const noexcept {
return __p_ >= __rhs.__p_;
}
private:
friend class directory_iterator;
friend class recursive_directory_iterator;
friend class __dir_stream;
enum _CacheType : unsigned char {
_Empty,
_IterSymlink,
_IterNonSymlink,
_RefreshSymlink,
_RefreshSymlinkUnresolved,
_RefreshNonSymlink
};
struct __cached_data {
uintmax_t __size_;
uintmax_t __nlink_;
file_time_type __write_time_;
perms __sym_perms_;
perms __non_sym_perms_;
file_type __type_;
_CacheType __cache_type_;
_LIBCPP_INLINE_VISIBILITY
__cached_data() noexcept { __reset(); }
_LIBCPP_INLINE_VISIBILITY
void __reset() {
__cache_type_ = _Empty;
__type_ = file_type::none;
__sym_perms_ = __non_sym_perms_ = perms::unknown;
__size_ = __nlink_ = uintmax_t(-1);
__write_time_ = file_time_type::min();
}
};
_LIBCPP_INLINE_VISIBILITY
static __cached_data __create_iter_result(file_type __ft) {
__cached_data __data;
__data.__type_ = __ft;
__data.__cache_type_ = [&]() {
switch (__ft) {
case file_type::none:
return _Empty;
case file_type::symlink:
return _IterSymlink;
default:
return _IterNonSymlink;
}
}();
return __data;
}
_LIBCPP_INLINE_VISIBILITY
void __assign_iter_entry(_Path&& __p, __cached_data __dt) {
__p_ = std::move(__p);
__data_ = __dt;
}
_LIBCPP_FUNC_VIS
error_code __do_refresh() noexcept;
_LIBCPP_INLINE_VISIBILITY
static bool __is_dne_error(error_code const& __ec) {
if (!__ec)
return true;
switch (static_cast<errc>(__ec.value())) {
case errc::no_such_file_or_directory:
case errc::not_a_directory:
return true;
default:
return false;
}
}
_LIBCPP_INLINE_VISIBILITY
void __handle_error(const char* __msg, error_code* __dest_ec,
error_code const& __ec, bool __allow_dne = false) const {
if (__dest_ec) {
*__dest_ec = __ec;
return;
}
if (__ec && (!__allow_dne || !__is_dne_error(__ec)))
__throw_filesystem_error(__msg, __p_, __ec);
}
_LIBCPP_INLINE_VISIBILITY
void __refresh(error_code* __ec = nullptr) {
__handle_error("in directory_entry::refresh", __ec, __do_refresh(),
/*allow_dne*/ true);
}
_LIBCPP_INLINE_VISIBILITY
file_type __get_sym_ft(error_code* __ec = nullptr) const {
switch (__data_.__cache_type_) {
case _Empty:
return __symlink_status(__p_, __ec).type();
case _IterSymlink:
case _RefreshSymlink:
case _RefreshSymlinkUnresolved:
if (__ec)
__ec->clear();
return file_type::symlink;
case _IterNonSymlink:
case _RefreshNonSymlink:
file_status __st(__data_.__type_);
if (__ec && !_VSTD_FS::exists(__st))
*__ec = make_error_code(errc::no_such_file_or_directory);
else if (__ec)
__ec->clear();
return __data_.__type_;
}
_LIBCPP_UNREACHABLE();
}
_LIBCPP_INLINE_VISIBILITY
file_type __get_ft(error_code* __ec = nullptr) const {
switch (__data_.__cache_type_) {
case _Empty:
case _IterSymlink:
case _RefreshSymlinkUnresolved:
return __status(__p_, __ec).type();
case _IterNonSymlink:
case _RefreshNonSymlink:
case _RefreshSymlink: {
file_status __st(__data_.__type_);
if (__ec && !_VSTD_FS::exists(__st))
*__ec = make_error_code(errc::no_such_file_or_directory);
else if (__ec)
__ec->clear();
return __data_.__type_;
}
}
_LIBCPP_UNREACHABLE();
}
_LIBCPP_INLINE_VISIBILITY
file_status __get_status(error_code* __ec = nullptr) const {
switch (__data_.__cache_type_) {
case _Empty:
case _IterNonSymlink:
case _IterSymlink:
case _RefreshSymlinkUnresolved:
return __status(__p_, __ec);
case _RefreshNonSymlink:
case _RefreshSymlink:
return file_status(__get_ft(__ec), __data_.__non_sym_perms_);
}
_LIBCPP_UNREACHABLE();
}
_LIBCPP_INLINE_VISIBILITY
file_status __get_symlink_status(error_code* __ec = nullptr) const {
switch (__data_.__cache_type_) {
case _Empty:
case _IterNonSymlink:
case _IterSymlink:
return __symlink_status(__p_, __ec);
case _RefreshNonSymlink:
return file_status(__get_sym_ft(__ec), __data_.__non_sym_perms_);
case _RefreshSymlink:
case _RefreshSymlinkUnresolved:
return file_status(__get_sym_ft(__ec), __data_.__sym_perms_);
}
_LIBCPP_UNREACHABLE();
}
_LIBCPP_INLINE_VISIBILITY
uintmax_t __get_size(error_code* __ec = nullptr) const {
switch (__data_.__cache_type_) {
case _Empty:
case _IterNonSymlink:
case _IterSymlink:
case _RefreshSymlinkUnresolved:
return _VSTD_FS::__file_size(__p_, __ec);
case _RefreshSymlink:
case _RefreshNonSymlink: {
error_code __m_ec;
file_status __st(__get_ft(&__m_ec));
__handle_error("in directory_entry::file_size", __ec, __m_ec);
if (_VSTD_FS::exists(__st) && !_VSTD_FS::is_regular_file(__st)) {
errc __err_kind = _VSTD_FS::is_directory(__st) ? errc::is_a_directory
: errc::not_supported;
__handle_error("in directory_entry::file_size", __ec,
make_error_code(__err_kind));
}
return __data_.__size_;
}
}
_LIBCPP_UNREACHABLE();
}
_LIBCPP_INLINE_VISIBILITY
uintmax_t __get_nlink(error_code* __ec = nullptr) const {
switch (__data_.__cache_type_) {
case _Empty:
case _IterNonSymlink:
case _IterSymlink:
case _RefreshSymlinkUnresolved:
return _VSTD_FS::__hard_link_count(__p_, __ec);
case _RefreshSymlink:
case _RefreshNonSymlink: {
error_code __m_ec;
(void)__get_ft(&__m_ec);
__handle_error("in directory_entry::hard_link_count", __ec, __m_ec);
return __data_.__nlink_;
}
}
_LIBCPP_UNREACHABLE();
}
_LIBCPP_INLINE_VISIBILITY
file_time_type __get_write_time(error_code* __ec = nullptr) const {
switch (__data_.__cache_type_) {
case _Empty:
case _IterNonSymlink:
case _IterSymlink:
case _RefreshSymlinkUnresolved:
return _VSTD_FS::__last_write_time(__p_, __ec);
case _RefreshSymlink:
case _RefreshNonSymlink: {
error_code __m_ec;
file_status __st(__get_ft(&__m_ec));
__handle_error("in directory_entry::last_write_time", __ec, __m_ec);
if (_VSTD_FS::exists(__st) &&
__data_.__write_time_ == file_time_type::min())
__handle_error("in directory_entry::last_write_time", __ec,
make_error_code(errc::value_too_large));
return __data_.__write_time_;
}
}
_LIBCPP_UNREACHABLE();
}
private:
_Path __p_;
__cached_data __data_;
};
class __dir_element_proxy {
public:
inline _LIBCPP_INLINE_VISIBILITY directory_entry operator*() {
return _VSTD::move(__elem_);
}
private:
friend class directory_iterator;
friend class recursive_directory_iterator;
explicit __dir_element_proxy(directory_entry const& __e) : __elem_(__e) {}
__dir_element_proxy(__dir_element_proxy&& __o)
: __elem_(_VSTD::move(__o.__elem_)) {}
directory_entry __elem_;
};
class directory_iterator {
public:
typedef directory_entry value_type;
typedef ptrdiff_t difference_type;
typedef value_type const* pointer;
typedef value_type const& reference;
typedef input_iterator_tag iterator_category;
public:
//ctor & dtor
directory_iterator() noexcept {}
explicit directory_iterator(const path& __p)
: directory_iterator(__p, nullptr) {}
directory_iterator(const path& __p, directory_options __opts)
: directory_iterator(__p, nullptr, __opts) {}
directory_iterator(const path& __p, error_code& __ec)
: directory_iterator(__p, &__ec) {}
directory_iterator(const path& __p, directory_options __opts,
error_code& __ec)
: directory_iterator(__p, &__ec, __opts) {}
directory_iterator(const directory_iterator&) = default;
directory_iterator(directory_iterator&&) = default;
directory_iterator& operator=(const directory_iterator&) = default;
directory_iterator& operator=(directory_iterator&& __o) noexcept {
// non-default implementation provided to support self-move assign.
if (this != &__o) {
__imp_ = _VSTD::move(__o.__imp_);
}
return *this;
}
~directory_iterator() = default;
const directory_entry& operator*() const {
_LIBCPP_ASSERT(__imp_, "The end iterator cannot be dereferenced");
return __dereference();
}
const directory_entry* operator->() const { return &**this; }
directory_iterator& operator++() { return __increment(); }
__dir_element_proxy operator++(int) {
__dir_element_proxy __p(**this);
__increment();
return __p;
}
directory_iterator& increment(error_code& __ec) { return __increment(&__ec); }
private:
inline _LIBCPP_INLINE_VISIBILITY friend bool
operator==(const directory_iterator& __lhs,
const directory_iterator& __rhs) noexcept;
// construct the dir_stream
_LIBCPP_FUNC_VIS
directory_iterator(const path&, error_code*,
directory_options = directory_options::none);
_LIBCPP_FUNC_VIS
directory_iterator& __increment(error_code* __ec = nullptr);
_LIBCPP_FUNC_VIS
const directory_entry& __dereference() const;
private:
shared_ptr<__dir_stream> __imp_;
};
inline _LIBCPP_INLINE_VISIBILITY bool
operator==(const directory_iterator& __lhs,
const directory_iterator& __rhs) noexcept {
return __lhs.__imp_ == __rhs.__imp_;
}
inline _LIBCPP_INLINE_VISIBILITY bool
operator!=(const directory_iterator& __lhs,
const directory_iterator& __rhs) noexcept {
return !(__lhs == __rhs);
}
// enable directory_iterator range-based for statements
inline _LIBCPP_INLINE_VISIBILITY directory_iterator
begin(directory_iterator __iter) noexcept {
return __iter;
}
inline _LIBCPP_INLINE_VISIBILITY directory_iterator
end(const directory_iterator&) noexcept {
return directory_iterator();
}
class recursive_directory_iterator {
public:
using value_type = directory_entry;
using difference_type = std::ptrdiff_t;
using pointer = directory_entry const*;
using reference = directory_entry const&;
using iterator_category = std::input_iterator_tag;
public:
// constructors and destructor
_LIBCPP_INLINE_VISIBILITY
recursive_directory_iterator() noexcept : __rec_(false) {}
_LIBCPP_INLINE_VISIBILITY
explicit recursive_directory_iterator(
const path& __p, directory_options __xoptions = directory_options::none)
: recursive_directory_iterator(__p, __xoptions, nullptr) {}
_LIBCPP_INLINE_VISIBILITY
recursive_directory_iterator(const path& __p, directory_options __xoptions,
error_code& __ec)
: recursive_directory_iterator(__p, __xoptions, &__ec) {}
_LIBCPP_INLINE_VISIBILITY
recursive_directory_iterator(const path& __p, error_code& __ec)
: recursive_directory_iterator(__p, directory_options::none, &__ec) {}
recursive_directory_iterator(const recursive_directory_iterator&) = default;
recursive_directory_iterator(recursive_directory_iterator&&) = default;
recursive_directory_iterator&
operator=(const recursive_directory_iterator&) = default;
_LIBCPP_INLINE_VISIBILITY
recursive_directory_iterator&
operator=(recursive_directory_iterator&& __o) noexcept {
// non-default implementation provided to support self-move assign.
if (this != &__o) {
__imp_ = _VSTD::move(__o.__imp_);
__rec_ = __o.__rec_;
}
return *this;
}
~recursive_directory_iterator() = default;
_LIBCPP_INLINE_VISIBILITY
const directory_entry& operator*() const { return __dereference(); }
_LIBCPP_INLINE_VISIBILITY
const directory_entry* operator->() const { return &__dereference(); }
recursive_directory_iterator& operator++() { return __increment(); }
_LIBCPP_INLINE_VISIBILITY
__dir_element_proxy operator++(int) {
__dir_element_proxy __p(**this);
__increment();
return __p;
}
_LIBCPP_INLINE_VISIBILITY
recursive_directory_iterator& increment(error_code& __ec) {
return __increment(&__ec);
}
_LIBCPP_FUNC_VIS directory_options options() const;
_LIBCPP_FUNC_VIS int depth() const;
_LIBCPP_INLINE_VISIBILITY
void pop() { __pop(); }
_LIBCPP_INLINE_VISIBILITY
void pop(error_code& __ec) { __pop(&__ec); }
_LIBCPP_INLINE_VISIBILITY
bool recursion_pending() const { return __rec_; }
_LIBCPP_INLINE_VISIBILITY
void disable_recursion_pending() { __rec_ = false; }
private:
recursive_directory_iterator(const path& __p, directory_options __opt,
error_code* __ec);
_LIBCPP_FUNC_VIS
const directory_entry& __dereference() const;
_LIBCPP_FUNC_VIS
bool __try_recursion(error_code* __ec);
_LIBCPP_FUNC_VIS
void __advance(error_code* __ec = nullptr);
_LIBCPP_FUNC_VIS
recursive_directory_iterator& __increment(error_code* __ec = nullptr);
_LIBCPP_FUNC_VIS
void __pop(error_code* __ec = nullptr);
inline _LIBCPP_INLINE_VISIBILITY friend bool
operator==(const recursive_directory_iterator&,
const recursive_directory_iterator&) noexcept;
struct __shared_imp;
shared_ptr<__shared_imp> __imp_;
bool __rec_;
}; // class recursive_directory_iterator
inline _LIBCPP_INLINE_VISIBILITY bool
operator==(const recursive_directory_iterator& __lhs,
const recursive_directory_iterator& __rhs) noexcept {
return __lhs.__imp_ == __rhs.__imp_;
}
_LIBCPP_INLINE_VISIBILITY
inline bool operator!=(const recursive_directory_iterator& __lhs,
const recursive_directory_iterator& __rhs) noexcept {
return !(__lhs == __rhs);
}
// enable recursive_directory_iterator range-based for statements
inline _LIBCPP_INLINE_VISIBILITY recursive_directory_iterator
begin(recursive_directory_iterator __iter) noexcept {
return __iter;
}
inline _LIBCPP_INLINE_VISIBILITY recursive_directory_iterator
end(const recursive_directory_iterator&) noexcept {
return recursive_directory_iterator();
}
_LIBCPP_END_NAMESPACE_FILESYSTEM
#endif // !_LIBCPP_CXX03_LANG
_LIBCPP_POP_MACROS
#endif // _LIBCPP_FILESYSTEM