026d38e8fb
path uses string::append to construct, append, and concatenate paths. Unfortunatly string::append has a strong exception safety guaranteed and if it can't prove that the iterator operations don't throw then it will allocate a temporary string copy to append to. However this extra allocation and copy is very undesirable for path which doesn't have the same exception guarantees. To work around this this patch adds string::__append_forward_unsafe which exposes the std::string::append interface for forward iterators without enforcing that the iterator is noexcept. git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@285532 91177308-0d34-0410-b5e6-96231b3b80d8
2128 lines
65 KiB
C++
2128 lines
65 KiB
C++
// -*- 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_EXPERIMENTAL_FILESYSTEM
|
|
#define _LIBCPP_EXPERIMENTAL_FILESYSTEM
|
|
/*
|
|
filesystem synopsis
|
|
|
|
namespace std { namespace experimental { namespace filesystem { inline namespace v1 {
|
|
|
|
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);
|
|
|
|
template <class charT, class traits>
|
|
basic_ostream<charT, traits>&
|
|
operator<<(basic_ostream<charT, traits>& os, const path& p);
|
|
|
|
template <class charT, class traits>
|
|
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 copy_options;
|
|
enum class directory_options;
|
|
|
|
typedef chrono::time_point<trivial-clock> file_time_type;
|
|
|
|
// operational functions
|
|
|
|
path absolute(const path& p, const path& base=current_path());
|
|
|
|
path canonical(const path& p, const path& base = current_path());
|
|
path canonical(const path& p, error_code& ec);
|
|
path canonical(const path& p, const path& base, error_code& ec);
|
|
|
|
void copy(const path& from, const path& to);
|
|
void copy(const path& from, const path& to, error_code& ec) _NOEXCEPT;
|
|
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) _NOEXCEPT;
|
|
|
|
bool copy_file(const path& from, const path& to);
|
|
bool copy_file(const path& from, const path& to, error_code& ec) _NOEXCEPT;
|
|
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) _NOEXCEPT;
|
|
|
|
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) _NOEXCEPT;
|
|
|
|
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);
|
|
void permissions(const path& p, perms prms, error_code& ec) _NOEXCEPT;
|
|
|
|
path read_symlink(const path& p);
|
|
path read_symlink(const path& p, 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) _NOEXCEPT;
|
|
|
|
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 system_complete(const path& p);
|
|
path system_complete(const path& p, error_code& ec);
|
|
|
|
path temp_directory_path();
|
|
path temp_directory_path(error_code& ec);
|
|
|
|
} } } } // namespaces std::experimental::filesystem::v1
|
|
|
|
*/
|
|
|
|
#include <experimental/__config>
|
|
#include <cstddef>
|
|
#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 <__debug>
|
|
|
|
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
|
#pragma GCC system_header
|
|
#endif
|
|
|
|
#define __cpp_lib_experimental_filesystem 201406
|
|
|
|
_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_FILESYSTEM
|
|
|
|
typedef chrono::time_point<std::chrono::system_clock> 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,
|
|
|
|
add_perms = 0x10000,
|
|
remove_perms = 0x20000,
|
|
symlink_nofollow = 0x40000
|
|
};
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
inline _LIBCPP_CONSTEXPR perms operator&(perms _LHS, perms _RHS)
|
|
{ return static_cast<perms>(static_cast<unsigned>(_LHS) & static_cast<unsigned>(_RHS)); }
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
inline _LIBCPP_CONSTEXPR perms operator|(perms _LHS, perms _RHS)
|
|
{ return static_cast<perms>(static_cast<unsigned>(_LHS) | static_cast<unsigned>(_RHS)); }
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
inline _LIBCPP_CONSTEXPR perms operator^(perms _LHS, perms _RHS)
|
|
{ return static_cast<perms>(static_cast<unsigned>(_LHS) ^ static_cast<unsigned>(_RHS)); }
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
inline _LIBCPP_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 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 _LIBCPP_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 _LIBCPP_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 _LIBCPP_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 _LIBCPP_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 _LIBCPP_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 _LIBCPP_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 _LIBCPP_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 _LIBCPP_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
|
|
explicit file_status(file_type __ft = file_type::none,
|
|
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_ALWAYS_INLINE
|
|
file_type type() const _NOEXCEPT {
|
|
return __ft_;
|
|
}
|
|
|
|
_LIBCPP_ALWAYS_INLINE
|
|
perms permissions() const _NOEXCEPT {
|
|
return __prms_;
|
|
}
|
|
|
|
// modifiers
|
|
_LIBCPP_ALWAYS_INLINE
|
|
void type(file_type __ft) _NOEXCEPT {
|
|
__ft_ = __ft;
|
|
}
|
|
|
|
_LIBCPP_ALWAYS_INLINE
|
|
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 _LIBCPP_CONSTEXPR value_type preferred_separator = '/';
|
|
|
|
// 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) _NOEXCEPT : __pn_(_VSTD::move(__s)) {}
|
|
|
|
template <
|
|
class _Source,
|
|
class = _EnableIfPathable<_Source, void>
|
|
>
|
|
path(const _Source& __src) {
|
|
_SourceCVT<_Source>::__append_source(__pn_, __src);
|
|
}
|
|
|
|
template <class _InputIt>
|
|
path(_InputIt __first, _InputIt __last) {
|
|
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);
|
|
template <class _InputIt>
|
|
path(_InputIt __first, _InputIt _last, const locale& __loc);
|
|
|
|
_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;
|
|
}
|
|
|
|
_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>
|
|
void __append_sep_if_needed(_ECharT __first_or_null) {
|
|
const _ECharT __null_val = {};
|
|
bool __append_sep = !empty() &&
|
|
!__is_separator(__pn_.back()) &&
|
|
__first_or_null != __null_val && // non-empty
|
|
!__is_separator(__first_or_null);
|
|
if (__append_sep)
|
|
__pn_ += preferred_separator;
|
|
}
|
|
|
|
public:
|
|
// appends
|
|
path& operator/=(const path& __p) {
|
|
_LIBCPP_ASSERT(!__p.has_root_name(),
|
|
"cannot append to a path with a root name");
|
|
__append_sep_if_needed(__p.empty() ? char{} : __p.__pn_[0]);
|
|
__pn_ += __p.native();
|
|
return *this;
|
|
}
|
|
|
|
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>>;
|
|
__append_sep_if_needed(_Traits::__first_or_null(__src));
|
|
_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) {
|
|
__append_sep_if_needed(*__first);
|
|
_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() {
|
|
if (__pn_.size() == __root_path_raw().size())
|
|
clear();
|
|
else
|
|
__pn_ = __parent_path();
|
|
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_);
|
|
}
|
|
|
|
// 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:
|
|
_LIBCPP_FUNC_VIS int __compare(__string_view) const;
|
|
_LIBCPP_FUNC_VIS __string_view __root_name() const;
|
|
_LIBCPP_FUNC_VIS __string_view __root_directory() const;
|
|
_LIBCPP_FUNC_VIS __string_view __root_path_raw() const;
|
|
_LIBCPP_FUNC_VIS __string_view __relative_path() const;
|
|
_LIBCPP_FUNC_VIS __string_view __parent_path() const;
|
|
_LIBCPP_FUNC_VIS __string_view __filename() const;
|
|
_LIBCPP_FUNC_VIS __string_view __stem() const;
|
|
_LIBCPP_FUNC_VIS __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_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(); }
|
|
|
|
// iterators
|
|
class _LIBCPP_TYPE_VIS iterator;
|
|
typedef iterator const_iterator;
|
|
|
|
_LIBCPP_FUNC_VIS iterator begin() const;
|
|
_LIBCPP_FUNC_VIS iterator end() const;
|
|
|
|
private:
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
path& __assign_view(__string_view const& __s) noexcept { __pn_ = string_type(__s); return *this; }
|
|
string_type __pn_;
|
|
};
|
|
|
|
inline _LIBCPP_ALWAYS_INLINE
|
|
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) {
|
|
return path(__lhs) /= __rhs;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
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
|
|
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
|
|
basic_istream<_CharT, _Traits>&
|
|
operator>>(basic_istream<_CharT, _Traits>& __is, path& __p)
|
|
{
|
|
basic_string<_CharT, _Traits> __tmp;
|
|
__is >> __quoted(__tmp);
|
|
__p = __tmp;
|
|
return __is;
|
|
}
|
|
|
|
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:
|
|
typedef bidirectional_iterator_tag iterator_category;
|
|
typedef path value_type;
|
|
typedef std::ptrdiff_t difference_type;
|
|
typedef const path* pointer;
|
|
typedef const path& reference;
|
|
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_ != __at_end,
|
|
"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;
|
|
|
|
static constexpr unsigned char __singular = 0;
|
|
static constexpr unsigned char __at_end = 6;
|
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
friend bool operator==(const iterator&, const iterator&);
|
|
|
|
_LIBCPP_FUNC_VIS iterator& __increment();
|
|
_LIBCPP_FUNC_VIS iterator& __decrement();
|
|
|
|
path __stashed_elem_;
|
|
const path* __path_ptr_;
|
|
path::__string_view __entry_;
|
|
unsigned char __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),
|
|
__paths_(make_shared<_Storage>(path(), path()))
|
|
{}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
filesystem_error(const string& __what, const path& __p1, error_code __ec)
|
|
: system_error(__ec, __what),
|
|
__paths_(make_shared<_Storage>(__p1, path()))
|
|
{}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
filesystem_error(const string& __what, const path& __p1, const path& __p2,
|
|
error_code __ec)
|
|
: system_error(__ec, __what),
|
|
__paths_(make_shared<_Storage>(__p1, __p2))
|
|
{}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
const path& path1() const _NOEXCEPT {
|
|
return __paths_->first;
|
|
}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
const path& path2() const _NOEXCEPT {
|
|
return __paths_->second;
|
|
}
|
|
|
|
_LIBCPP_FUNC_VIS
|
|
~filesystem_error() override; // key function
|
|
|
|
// TODO(ericwf): Create a custom error message.
|
|
//const char* what() const _NOEXCEPT;
|
|
|
|
private:
|
|
typedef pair<path, path> _Storage;
|
|
shared_ptr<_Storage> __paths_;
|
|
};
|
|
|
|
template <class... _Args>
|
|
_LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE
|
|
void __throw_filesystem_error(_Args && ...__args)
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
throw filesystem_error(std::forward<_Args>(__args)...);
|
|
#else
|
|
_VSTD::abort();
|
|
#endif
|
|
}
|
|
|
|
// operational functions
|
|
|
|
_LIBCPP_FUNC_VIS
|
|
path __canonical(const path&, 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& p, perms prms, error_code *ec=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);
|
|
|
|
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);
|
|
}
|
|
|
|
_LIBCPP_FUNC_VIS
|
|
path absolute(const path&, const path& __p2 = current_path());
|
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
path canonical(const path& __p, const path& __base = current_path()) {
|
|
return __canonical(__p, __base);
|
|
}
|
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
path canonical(const path& __p, error_code& __ec) {
|
|
path __base = __current_path(&__ec);
|
|
if (__ec) return {};
|
|
return __canonical(__p, __base, &__ec);
|
|
}
|
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
path canonical(const path& __p, const path& __base, error_code& __ec) {
|
|
return __canonical(__p, __base, &__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) _NOEXCEPT {
|
|
__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) _NOEXCEPT {
|
|
__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) _NOEXCEPT {
|
|
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) _NOEXCEPT {
|
|
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) _NOEXCEPT {
|
|
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) _NOEXCEPT {
|
|
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) {
|
|
__permissions(__p, __prms);
|
|
}
|
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
void permissions(const path& __p, perms __prms, error_code& __ec) {
|
|
__permissions(__p, __prms, &__ec);
|
|
}
|
|
|
|
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
|
|
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) _NOEXCEPT {
|
|
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 system_complete(const path& __p) {
|
|
return __system_complete(__p);
|
|
}
|
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
path system_complete(const path& __p, error_code& __ec) {
|
|
return __system_complete(__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);
|
|
}
|
|
|
|
|
|
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) {}
|
|
|
|
~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;
|
|
}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void replace_filename(_Path const& __p) {
|
|
__p_ = __p_.parent_path() / __p;
|
|
}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_Path const& path() const _NOEXCEPT {
|
|
return __p_;
|
|
}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator const _Path&() const _NOEXCEPT {
|
|
return __p_;
|
|
}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
file_status status() const {
|
|
return _VSTD_FS::status(__p_);
|
|
}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
file_status status(error_code& __ec) const _NOEXCEPT {
|
|
return _VSTD_FS::status(__p_, __ec);
|
|
}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
file_status symlink_status() const {
|
|
return _VSTD_FS::symlink_status(__p_);
|
|
}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
file_status symlink_status(error_code& __ec) const _NOEXCEPT {
|
|
return _VSTD_FS::symlink_status(__p_, __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:
|
|
_Path __p_;
|
|
};
|
|
|
|
|
|
class directory_iterator;
|
|
class recursive_directory_iterator;
|
|
class __dir_stream;
|
|
|
|
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) _NOEXCEPT
|
|
: directory_iterator(__p, &__ec)
|
|
{ }
|
|
|
|
directory_iterator(const path& __p, directory_options __opts,
|
|
error_code& __ec) _NOEXCEPT
|
|
: 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 __deref();
|
|
}
|
|
|
|
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) _NOEXCEPT
|
|
{ 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& __deref() 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) _NOEXCEPT
|
|
: recursive_directory_iterator(__p, __xoptions, &__ec)
|
|
{ }
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
recursive_directory_iterator(const path& __p, error_code& __ec) _NOEXCEPT
|
|
: 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 __deref(); }
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
const directory_entry* operator->() const
|
|
{ return &__deref(); }
|
|
|
|
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) _NOEXCEPT
|
|
{ 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& __deref() 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_EXPERIMENTAL_FILESYSTEM
|
|
|
|
#endif // _LIBCPP_EXPERIMENTAL_FILESYSTEM
|