зеркало из https://github.com/microsoft/STL.git
2698 строки
91 KiB
C++
2698 строки
91 KiB
C++
// filesystem experimental header
|
|
|
|
// Copyright (c) Microsoft Corporation.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
|
|
#ifndef _EXPERIMENTAL_FILESYSTEM_
|
|
#define _EXPERIMENTAL_FILESYSTEM_
|
|
#include <yvals_core.h>
|
|
#if _STL_COMPILER_PREPROCESSOR
|
|
|
|
#include <__msvc_chrono.hpp> // for chrono::time_point
|
|
#include <algorithm> // for replace
|
|
#include <codecvt> // for codecvt_utf8_*
|
|
#include <list> // for recursive_directory_iterator stack
|
|
#include <locale> // for wstring_convert
|
|
#include <memory> // for shared_ptr
|
|
#include <vector> // for canonical's .. handling
|
|
|
|
#pragma pack(push, _CRT_PACKING)
|
|
#pragma warning(push, _STL_WARNING_LEVEL)
|
|
#pragma warning(disable : _STL_DISABLED_WARNINGS)
|
|
_STL_DISABLE_CLANG_WARNINGS
|
|
#pragma push_macro("new")
|
|
#undef new
|
|
|
|
#ifndef _SILENCE_EXPERIMENTAL_FILESYSTEM_DEPRECATION_WARNING
|
|
#error The <experimental/filesystem> header providing std::experimental::filesystem is deprecated by Microsoft \
|
|
and will be REMOVED. It is superseded by the C++17 <filesystem> header providing std::filesystem. \
|
|
You can define _SILENCE_EXPERIMENTAL_FILESYSTEM_DEPRECATION_WARNING to suppress this error.
|
|
#endif // !defined(_SILENCE_EXPERIMENTAL_FILESYSTEM_DEPRECATION_WARNING)
|
|
|
|
#pragma warning(disable : 4365) // conversion from 'type_1' to 'type_2', signed/unsigned mismatch (/Wall)
|
|
|
|
#ifndef _FS_DLL
|
|
#define _FS_DLL extern "C" _CRTIMP2_PURE
|
|
#endif // !defined(_FS_DLL)
|
|
|
|
#define _MAX_FILESYS_NAME 260 // longest Windows or Posix filename + 1
|
|
|
|
#define _FS_BEGIN \
|
|
_STD_BEGIN \
|
|
namespace experimental { \
|
|
namespace filesystem { \
|
|
inline namespace v1 {
|
|
#define _FS_END \
|
|
} \
|
|
} \
|
|
} \
|
|
_STD_END
|
|
#define _FSPFX _STD experimental::filesystem::v1::
|
|
|
|
_FS_BEGIN
|
|
using _Pchar = wchar_t; // UTF16
|
|
#define _FS_ISSEP(x) ((x) == L'/' || (x) == L'\\')
|
|
#define _FS_PREF L'\\'
|
|
|
|
#define _FS_COLON L':'
|
|
#define _FS_PERIOD L'.'
|
|
#define _FS_SLASH L'/'
|
|
#define _FS_BSLASH L'\\'
|
|
|
|
struct _Char8_t; // flag for UTF8
|
|
|
|
enum class file_type { // names for file types
|
|
not_found = -1,
|
|
none,
|
|
regular,
|
|
directory,
|
|
symlink,
|
|
block,
|
|
character,
|
|
fifo,
|
|
socket,
|
|
unknown
|
|
};
|
|
|
|
enum class copy_options { // names for copy options
|
|
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,
|
|
_Unspecified_recursion_prevention_tag = 512
|
|
};
|
|
|
|
_BITMASK_OPS(_EMPTY_ARGUMENT, copy_options)
|
|
|
|
enum class directory_options { // names for directory options
|
|
none = 0,
|
|
follow_directory_symlink
|
|
};
|
|
|
|
enum class perms { // names for permissions
|
|
none = 0,
|
|
owner_read = 0400, // S_IRUSR
|
|
owner_write = 0200, // S_IWUSR
|
|
owner_exec = 0100, // S_IXUSR
|
|
owner_all = 0700, // S_IRWXU
|
|
group_read = 040, // S_IRGRP
|
|
group_write = 020, // S_IWGRP
|
|
group_exec = 010, // S_IXGRP
|
|
group_all = 070, // S_IRWXG
|
|
others_read = 04, // S_IROTH
|
|
others_write = 02, // S_IWOTH
|
|
others_exec = 01, // S_IXOTH
|
|
others_all = 07, // S_IRWXO
|
|
all = 0777,
|
|
set_uid = 04000, // S_ISUID
|
|
set_gid = 02000, // S_ISGID
|
|
sticky_bit = 01000, // S_ISVTX
|
|
mask = 07777,
|
|
unknown = 0xFFFF,
|
|
add_perms = 0x10000,
|
|
remove_perms = 0x20000,
|
|
resolve_symlinks = 0x40000
|
|
};
|
|
|
|
_BITMASK_OPS(_EMPTY_ARGUMENT, perms)
|
|
|
|
class file_status { // stores file status
|
|
public:
|
|
explicit file_status(file_type _Ftype = file_type::none, perms _Prms = perms::unknown) noexcept
|
|
: _Myftype(_Ftype), _Myperms(_Prms) {}
|
|
|
|
file_status(const file_status&) noexcept = default;
|
|
file_status& operator=(const file_status&) noexcept = default;
|
|
|
|
file_status(file_status&&) = default;
|
|
file_status& operator=(file_status&&) = default;
|
|
|
|
_NODISCARD file_type type() const noexcept {
|
|
return _Myftype;
|
|
}
|
|
|
|
_NODISCARD perms permissions() const noexcept {
|
|
return _Myperms;
|
|
}
|
|
|
|
void type(file_type _Ftype) noexcept {
|
|
_Myftype = _Ftype;
|
|
}
|
|
|
|
void permissions(perms _Prms) noexcept {
|
|
_Myperms = _Prms;
|
|
}
|
|
|
|
private:
|
|
file_type _Myftype;
|
|
perms _Myperms;
|
|
};
|
|
|
|
struct space_info { // space information for a file
|
|
uintmax_t capacity;
|
|
uintmax_t free;
|
|
uintmax_t available;
|
|
};
|
|
|
|
// wide filenames
|
|
_FS_DLL void* __CLRCALL_PURE_OR_CDECL _Open_dir(
|
|
wchar_t (&)[_MAX_FILESYS_NAME], const wchar_t*, int&, file_type&) noexcept;
|
|
_FS_DLL wchar_t* __CLRCALL_PURE_OR_CDECL _Read_dir(wchar_t (&)[_MAX_FILESYS_NAME], void*, file_type&) noexcept;
|
|
_FS_DLL void __CLRCALL_PURE_OR_CDECL _Close_dir(void*) noexcept;
|
|
_FS_DLL bool __CLRCALL_PURE_OR_CDECL _Current_get(wchar_t (&)[_MAX_FILESYS_NAME]) noexcept;
|
|
_FS_DLL bool __CLRCALL_PURE_OR_CDECL _Current_set(const wchar_t*) noexcept;
|
|
_FS_DLL wchar_t* __CLRCALL_PURE_OR_CDECL _Symlink_get(wchar_t (&)[_MAX_FILESYS_NAME], const wchar_t*) noexcept;
|
|
_FS_DLL wchar_t* __CLRCALL_PURE_OR_CDECL _Temp_get(wchar_t (&)[_MAX_FILESYS_NAME]) noexcept;
|
|
|
|
_FS_DLL int __CLRCALL_PURE_OR_CDECL _Make_dir(const wchar_t*, const wchar_t*) noexcept;
|
|
_FS_DLL bool __CLRCALL_PURE_OR_CDECL _Remove_dir(const wchar_t*) noexcept;
|
|
|
|
_FS_DLL file_type __CLRCALL_PURE_OR_CDECL _Stat(const wchar_t*, perms*) noexcept;
|
|
_FS_DLL file_type __CLRCALL_PURE_OR_CDECL _Lstat(const wchar_t*, perms*) noexcept;
|
|
_FS_DLL uintmax_t __CLRCALL_PURE_OR_CDECL _File_size(const wchar_t*) noexcept;
|
|
_FS_DLL uintmax_t __CLRCALL_PURE_OR_CDECL _Hard_links(const wchar_t*) noexcept;
|
|
_FS_DLL int64_t __CLRCALL_PURE_OR_CDECL _Last_write_time(const wchar_t*) noexcept;
|
|
_FS_DLL int __CLRCALL_PURE_OR_CDECL _Set_last_write_time(const wchar_t*, int64_t) noexcept;
|
|
_FS_DLL space_info __CLRCALL_PURE_OR_CDECL _Statvfs(const wchar_t*) noexcept;
|
|
_FS_DLL int __CLRCALL_PURE_OR_CDECL _Equivalent(const wchar_t*, const wchar_t*) noexcept;
|
|
|
|
_FS_DLL int __CLRCALL_PURE_OR_CDECL _Link(const wchar_t*, const wchar_t*) noexcept;
|
|
_FS_DLL int __CLRCALL_PURE_OR_CDECL _Symlink(const wchar_t*, const wchar_t*) noexcept;
|
|
_FS_DLL int __CLRCALL_PURE_OR_CDECL _Rename(const wchar_t*, const wchar_t*) noexcept;
|
|
_FS_DLL int __CLRCALL_PURE_OR_CDECL _Resize(const wchar_t*, uintmax_t) noexcept;
|
|
_FS_DLL int __CLRCALL_PURE_OR_CDECL _Unlink(const wchar_t*) noexcept;
|
|
_FS_DLL int __CLRCALL_PURE_OR_CDECL _Copy_file(const wchar_t*, const wchar_t*) noexcept;
|
|
_FS_DLL int __CLRCALL_PURE_OR_CDECL _Chmod(const wchar_t*, perms) noexcept;
|
|
|
|
template <class _Inchar, class _Outchar, class _Outtraits = char_traits<_Outchar>,
|
|
class _Outalloc = allocator<_Outchar>>
|
|
struct _Path_cvt { // converts among {char, wchar_t, UTF8, char16_t, char32_t} paths
|
|
using _Outstr = basic_string<_Outchar, _Outtraits, _Outalloc>;
|
|
static _Outstr&& _Cvt(_Outstr& _Str, const _Inchar* _First, size_t _Size,
|
|
_Unused_parameter = {}) { // convert _Inchar sequence to _Outchar one-to-one
|
|
for (; 0 < _Size; --_Size, ++_First) {
|
|
_Str.push_back(static_cast<_Outchar>(*_First));
|
|
}
|
|
|
|
return _STD move(_Str);
|
|
}
|
|
};
|
|
|
|
template <class _Outchar, class _Outtraits, class _Outalloc>
|
|
struct _Path_cvt<_Outchar, _Outchar, _Outtraits,
|
|
_Outalloc> { // converts among {char, wchar_t, UTF8, char16_t, char32_t} paths
|
|
using _Outstr = basic_string<_Outchar, _Outtraits, _Outalloc>;
|
|
static _Outstr&& _Cvt(_Outstr& _Str, const _Outchar* _First, size_t _Size,
|
|
_Unused_parameter = {}) { // copy _Outchar sequence to _Outchar one-to-one
|
|
return _STD move(_Str.append(_First, _First + _Size));
|
|
}
|
|
};
|
|
|
|
_STL_DISABLE_DEPRECATED_WARNING
|
|
template <class _Outtraits, class _Outalloc>
|
|
struct _Path_cvt<char, char16_t, _Outtraits,
|
|
_Outalloc> { // converts among {char, wchar_t, UTF8, char16_t, char32_t} paths
|
|
using _Inchar = char;
|
|
using _Outchar = char16_t;
|
|
using _Outstr = basic_string<_Outchar, _Outtraits, _Outalloc>;
|
|
static _Outstr&& _Cvt(_Outstr& _Str, const _Inchar* _First, size_t _Size,
|
|
_Unused_parameter = {}) { // convert char sequence to char16_t string
|
|
wstring_convert<codecvt_utf8_utf16<_Outchar>, _Outchar> _Wcvt;
|
|
return _STD move(_Str.append(_Wcvt.from_bytes(_First, _First + _Size)));
|
|
}
|
|
};
|
|
|
|
template <class _Outtraits, class _Outalloc>
|
|
struct _Path_cvt<char16_t, char, _Outtraits,
|
|
_Outalloc> { // converts among {char, wchar_t, UTF8, char16_t, char32_t} paths
|
|
using _Inchar = char16_t;
|
|
using _Outchar = char;
|
|
using _Outstr = basic_string<_Outchar, _Outtraits, _Outalloc>;
|
|
static _Outstr&& _Cvt(_Outstr& _Str, const _Inchar* _First, size_t _Size,
|
|
_Unused_parameter = {}) { // convert char16_t sequence to char string
|
|
wstring_convert<codecvt_utf8_utf16<_Inchar>, _Inchar> _Wcvt;
|
|
return _STD move(_Str.append(_Wcvt.to_bytes(_First, _First + _Size)));
|
|
}
|
|
};
|
|
|
|
template <class _Outtraits, class _Outalloc>
|
|
struct _Path_cvt<char, char32_t, _Outtraits,
|
|
_Outalloc> { // converts among {char, wchar_t, UTF8, char16_t, char32_t} paths
|
|
using _Inchar = char;
|
|
using _Outchar = char32_t;
|
|
using _Outstr = basic_string<_Outchar, _Outtraits, _Outalloc>;
|
|
static _Outstr&& _Cvt(_Outstr& _Str, const _Inchar* _First, size_t _Size,
|
|
_Unused_parameter = {}) { // convert char sequence to char32_t string
|
|
wstring_convert<codecvt_utf8<_Outchar>, _Outchar> _Wcvt;
|
|
return _STD move(_Str.append(_Wcvt.from_bytes(_First, _First + _Size)));
|
|
}
|
|
};
|
|
|
|
template <class _Outtraits, class _Outalloc>
|
|
struct _Path_cvt<char32_t, char, _Outtraits,
|
|
_Outalloc> { // converts among {char, wchar_t, UTF8, char16_t, char32_t} paths
|
|
using _Inchar = char32_t;
|
|
using _Outchar = char;
|
|
using _Outstr = basic_string<_Outchar, _Outtraits, _Outalloc>;
|
|
static _Outstr&& _Cvt(_Outstr& _Str, const _Inchar* _First, size_t _Size,
|
|
_Unused_parameter = {}) { // convert char32_t sequence to char string
|
|
wstring_convert<codecvt_utf8<_Inchar>, _Inchar> _Wcvt;
|
|
return _STD move(_Str.append(_Wcvt.to_bytes(_First, _First + _Size)));
|
|
}
|
|
};
|
|
|
|
_FS_DLL int __CLRCALL_PURE_OR_CDECL _To_byte(const wchar_t*, char*) noexcept;
|
|
_FS_DLL int __CLRCALL_PURE_OR_CDECL _To_wide(const char*, wchar_t*) noexcept;
|
|
|
|
template <class _Outtraits, class _Outalloc>
|
|
struct _Path_cvt<char, wchar_t, _Outtraits,
|
|
_Outalloc> { // converts among {char, wchar_t, UTF8, char16_t, char32_t} paths
|
|
using _Inchar = char;
|
|
using _Outchar = wchar_t;
|
|
using _Outstr = basic_string<_Outchar, _Outtraits, _Outalloc>;
|
|
static _Outstr&& _Cvt(_Outstr& _Str, const _Inchar* _First,
|
|
size_t) { // convert char sequence to wchar_t string -- Windows
|
|
_Outchar _Fname_wide[_MAX_FILESYS_NAME];
|
|
if (_To_wide(_First, _Fname_wide) == 0) {
|
|
_Xinvalid_argument("invalid char filename argument");
|
|
}
|
|
|
|
return _STD move(_Str.append(_Fname_wide));
|
|
}
|
|
|
|
static _Outstr&& _Cvt(_Outstr& _Str, const _Inchar* _First, size_t _Size,
|
|
const locale& _Loc) { // convert char sequence to wchar_t string, locale -- Windows
|
|
using _Mycvt = codecvt<_Outchar, _Inchar, _Mbstatet>;
|
|
wstring_convert<_Mycvt> _Wcvt(&_STD use_facet<_Mycvt>(_Loc));
|
|
return _STD move(_Str.append(_Wcvt.from_bytes(_First, _First + _Size)));
|
|
}
|
|
};
|
|
|
|
template <class _Outtraits, class _Outalloc>
|
|
struct _Path_cvt<wchar_t, char, _Outtraits,
|
|
_Outalloc> { // converts among {char, wchar_t, UTF8, char16_t, char32_t} paths
|
|
using _Inchar = wchar_t;
|
|
using _Outchar = char;
|
|
using _Outstr = basic_string<_Outchar, _Outtraits, _Outalloc>;
|
|
static _Outstr&& _Cvt(_Outstr& _Str, const _Inchar* _First,
|
|
size_t) { // convert wchar_t sequence to char string -- Windows
|
|
_Outchar _Fname_byte[_MAX_FILESYS_NAME];
|
|
if (_To_byte(_First, _Fname_byte) == 0) {
|
|
_Xinvalid_argument("invalid wchar_t filename argument");
|
|
}
|
|
|
|
return _STD move(_Str.append(_Fname_byte));
|
|
}
|
|
|
|
static _Outstr&& _Cvt(_Outstr& _Str, const _Inchar* _First, size_t _Size,
|
|
const locale& _Loc) { // convert wchar_t sequence to char string, locale -- Windows
|
|
using _Mycvt = codecvt<_Inchar, _Outchar, _Mbstatet>;
|
|
wstring_convert<_Mycvt> _Wcvt(&_STD use_facet<_Mycvt>(_Loc));
|
|
return _STD move(_Str.append(_Wcvt.to_bytes(_First, _First + _Size)));
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct _Path_cvt<char, _Char8_t, char_traits<char>,
|
|
allocator<char>> { // converts among {char, wchar_t, UTF8, char16_t, char32_t} paths
|
|
using _Inchar = char;
|
|
using _Outchar = char;
|
|
using _Outtraits = char_traits<_Outchar>;
|
|
using _Outalloc = allocator<_Outchar>;
|
|
using _Outstr = basic_string<_Outchar, _Outtraits, _Outalloc>;
|
|
static _Outstr&& _Cvt(_Outstr& _Str, const _Inchar* _First, size_t,
|
|
_Unused_parameter = {}) { // convert char sequence to UTF8 string -- Windows
|
|
wchar_t _Fname_wide[_MAX_FILESYS_NAME];
|
|
if (_To_wide(_First, _Fname_wide) == 0) {
|
|
_Xinvalid_argument("invalid char filename argument");
|
|
}
|
|
|
|
wstring_convert<codecvt_utf8<wchar_t>, wchar_t> _Wcvt;
|
|
wchar_t* _Last1 = _Fname_wide;
|
|
while (*_Last1 != L'\0') {
|
|
++_Last1;
|
|
}
|
|
|
|
return _STD move(_Str.append(_Wcvt.to_bytes(_Fname_wide, _Last1)));
|
|
}
|
|
};
|
|
|
|
template <class _Outtraits, class _Outalloc>
|
|
struct _Path_cvt<_Char8_t, char, _Outtraits,
|
|
_Outalloc> { // converts among {char, wchar_t, UTF8, char16_t, char32_t} paths
|
|
using _Inchar = char;
|
|
using _Outchar = char;
|
|
using _Outstr = basic_string<_Outchar, _Outtraits, _Outalloc>;
|
|
static _Outstr&& _Cvt(_Outstr& _Str, const _Inchar* _First, size_t _Size,
|
|
_Unused_parameter = {}) { // convert UTF8 sequence to char string -- Windows
|
|
wstring_convert<codecvt_utf8_utf16<wchar_t>, wchar_t> _Wcvt;
|
|
wstring _Str0(_Wcvt.from_bytes(_First, _First + _Size));
|
|
|
|
_Outchar _Fname_byte[_MAX_FILESYS_NAME];
|
|
if (_To_byte(_Str0.c_str(), _Fname_byte) == 0) {
|
|
_Xinvalid_argument("invalid UTF8 filename argument");
|
|
}
|
|
|
|
return _STD move(_Str.append(_Fname_byte));
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct _Path_cvt<wchar_t, _Char8_t, char_traits<char>,
|
|
allocator<char>> { // converts among {char, wchar_t, UTF8, char16_t, char32_t} paths
|
|
using _Inchar = wchar_t;
|
|
using _Outchar = char;
|
|
using _Outtraits = char_traits<_Outchar>;
|
|
using _Outalloc = allocator<_Outchar>;
|
|
using _Outstr = basic_string<_Outchar, _Outtraits, _Outalloc>;
|
|
static _Outstr&& _Cvt(_Outstr& _Str, const _Inchar* _First, size_t _Size,
|
|
_Unused_parameter = {}) { // convert wchar_t sequence to UTF8 string -- Windows
|
|
wstring_convert<codecvt_utf8<_Inchar>, _Inchar> _Wcvt;
|
|
return _STD move(_Str.append(_Wcvt.to_bytes(_First, _First + _Size)));
|
|
}
|
|
};
|
|
|
|
template <class _Outtraits, class _Outalloc>
|
|
struct _Path_cvt<_Char8_t, wchar_t, _Outtraits,
|
|
_Outalloc> { // converts among {char, wchar_t, UTF8, char16_t, char32_t} paths
|
|
using _Inchar = char;
|
|
using _Outchar = wchar_t;
|
|
using _Outstr = basic_string<_Outchar, _Outtraits, _Outalloc>;
|
|
static _Outstr&& _Cvt(_Outstr& _Str, const _Inchar* _First, size_t _Size,
|
|
_Unused_parameter = {}) { // convert UTF8 sequence to wchar_t string -- Windows
|
|
wstring_convert<codecvt_utf8<_Outchar>, _Outchar> _Wcvt;
|
|
return _STD move(_Str.append(_Wcvt.from_bytes(_First, _First + _Size)));
|
|
}
|
|
};
|
|
|
|
// struct _Path_cvt<wchar_t, char16_t, _Outtraits, _Outalloc> Windows (copy)
|
|
// struct _Path_cvt<char16_t, wchar_t, _Outtraits, _Outalloc> Windows (copy)
|
|
|
|
template <class _Outtraits, class _Outalloc>
|
|
struct _Path_cvt<wchar_t, char32_t, _Outtraits,
|
|
_Outalloc> { // converts among {char, wchar_t, UTF8, char16_t, char32_t} paths
|
|
using _Inchar = wchar_t;
|
|
using _Outchar = char32_t;
|
|
using _Outstr = basic_string<_Outchar, _Outtraits, _Outalloc>;
|
|
static _Outstr&& _Cvt(_Outstr& _Str, const _Inchar* _First, size_t _Size,
|
|
_Unused_parameter = {}) { // convert wchar_t sequence to char32_t string -- Windows
|
|
wstring_convert<codecvt_utf8_utf16<_Inchar>, _Inchar> _Wcvt0;
|
|
_STD string _Str0(_Wcvt0.to_bytes(_First, _First + _Size));
|
|
|
|
wstring_convert<codecvt_utf8<_Outchar>, _Outchar> _Wcvt;
|
|
return _STD move(_Str.append(_Wcvt.from_bytes(_Str0)));
|
|
}
|
|
};
|
|
|
|
template <class _Outtraits, class _Outalloc>
|
|
struct _Path_cvt<char32_t, wchar_t, _Outtraits,
|
|
_Outalloc> { // converts among {char, wchar_t, UTF8, char16_t, char32_t} paths
|
|
using _Inchar = char32_t;
|
|
using _Outchar = wchar_t;
|
|
using _Outstr = basic_string<_Outchar, _Outtraits, _Outalloc>;
|
|
static _Outstr&& _Cvt(_Outstr& _Str, const _Inchar* _First, size_t _Size,
|
|
_Unused_parameter = {}) { // convert char32_t sequence to wchar_t string -- Windows
|
|
wstring_convert<codecvt_utf8<_Inchar>, _Inchar> _Wcvt0;
|
|
_STD string _Str0(_Wcvt0.to_bytes(_First, _First + _Size));
|
|
|
|
wstring_convert<codecvt_utf8_utf16<_Outchar>, _Outchar> _Wcvt;
|
|
return _STD move(_Str.append(_Wcvt.from_bytes(_Str0)));
|
|
}
|
|
};
|
|
_STL_RESTORE_DEPRECATED_WARNING
|
|
|
|
class path;
|
|
path operator/(const path&, const path&);
|
|
|
|
path _Absolute(const path&, const path&, error_code&);
|
|
// path absolute(const path&, const path& = current_path());
|
|
|
|
void _Canonicalize_string_only(path&, const path&);
|
|
// path canonical(const path&, const path& _Base = current_path());
|
|
path canonical(const path&, error_code&);
|
|
path canonical(const path&, const path&, error_code&);
|
|
|
|
void copy(const path&, const path&);
|
|
void copy(const path&, const path&, error_code&) noexcept;
|
|
void copy(const path&, const path&, copy_options);
|
|
void copy(const path&, const path&, copy_options, error_code&) noexcept;
|
|
|
|
bool copy_file(const path&, const path&, copy_options = copy_options::none);
|
|
bool copy_file(const path&, const path&, error_code&) noexcept;
|
|
bool copy_file(const path&, const path&, copy_options, error_code&) noexcept;
|
|
|
|
void copy_symlink(const path&, const path&);
|
|
void copy_symlink(const path&, const path&, error_code&) noexcept;
|
|
|
|
bool create_directories(const path&);
|
|
bool create_directories(const path&, error_code&) noexcept;
|
|
|
|
bool create_directory(const path&);
|
|
bool create_directory(const path&, error_code&) noexcept;
|
|
bool create_directory(const path&, const path&);
|
|
bool create_directory(const path&, const path&, error_code&) noexcept;
|
|
|
|
void create_directory_symlink(const path&, const path&);
|
|
void create_directory_symlink(const path&, const path&, error_code&) noexcept;
|
|
|
|
void create_hard_link(const path&, const path&);
|
|
void create_hard_link(const path&, const path&, error_code&) noexcept;
|
|
|
|
void create_symlink(const path&, const path&);
|
|
void create_symlink(const path&, const path&, error_code&) noexcept;
|
|
|
|
path current_path();
|
|
path current_path(error_code&);
|
|
void current_path(const path&);
|
|
void current_path(const path&, error_code&) noexcept;
|
|
|
|
bool equivalent(const path&, const path&);
|
|
bool equivalent(const path&, const path&, error_code&) noexcept;
|
|
|
|
bool exists(file_status) noexcept;
|
|
bool exists(const path&);
|
|
bool exists(const path&, error_code&) noexcept;
|
|
|
|
uintmax_t file_size(const path&);
|
|
uintmax_t file_size(const path&, error_code&) noexcept;
|
|
|
|
uintmax_t hard_link_count(const path&);
|
|
uintmax_t hard_link_count(const path&, error_code&) noexcept;
|
|
|
|
bool is_block_file(file_status) noexcept;
|
|
bool is_block_file(const path&);
|
|
bool is_block_file(const path&, error_code&) noexcept;
|
|
|
|
bool is_character_file(file_status) noexcept;
|
|
bool is_character_file(const path&);
|
|
bool is_character_file(const path&, error_code&) noexcept;
|
|
|
|
bool is_directory(file_status) noexcept;
|
|
bool is_directory(const path&);
|
|
bool is_directory(const path&, error_code&) noexcept;
|
|
|
|
bool is_empty(const path&);
|
|
bool is_empty(const path&, error_code&) noexcept;
|
|
|
|
bool is_fifo(file_status) noexcept;
|
|
bool is_fifo(const path&);
|
|
bool is_fifo(const path&, error_code&) noexcept;
|
|
|
|
bool is_other(file_status) noexcept;
|
|
bool is_other(const path&);
|
|
bool is_other(const path&, error_code&) noexcept;
|
|
|
|
bool is_regular_file(file_status) noexcept;
|
|
bool is_regular_file(const path&);
|
|
bool is_regular_file(const path&, error_code&) noexcept;
|
|
|
|
bool is_socket(file_status) noexcept;
|
|
bool is_socket(const path&);
|
|
bool is_socket(const path&, error_code&) noexcept;
|
|
|
|
bool is_symlink(file_status) noexcept;
|
|
bool is_symlink(const path&);
|
|
bool is_symlink(const path&, error_code&) noexcept;
|
|
|
|
using file_time_type = chrono::system_clock::time_point;
|
|
|
|
file_time_type last_write_time(const path&, error_code&) noexcept;
|
|
file_time_type last_write_time(const path&);
|
|
void last_write_time(const path&, file_time_type, error_code&) noexcept;
|
|
void last_write_time(const path&, file_time_type);
|
|
|
|
void permissions(const path&, perms);
|
|
void permissions(const path&, perms, error_code&);
|
|
|
|
path read_symlink(const path&);
|
|
path read_symlink(const path&, error_code&);
|
|
|
|
bool remove(const path&);
|
|
bool remove(const path&, error_code&) noexcept;
|
|
|
|
uintmax_t remove_all(const path&);
|
|
uintmax_t remove_all(const path&, error_code&) noexcept;
|
|
|
|
void rename(const path&, const path&);
|
|
void rename(const path&, const path&, error_code&) noexcept;
|
|
|
|
void resize_file(const path&, uintmax_t);
|
|
void resize_file(const path&, uintmax_t, error_code&) noexcept;
|
|
|
|
space_info space(const path&);
|
|
space_info space(const path&, error_code&) noexcept;
|
|
|
|
file_status status(const path&);
|
|
file_status status(const path&, error_code&) noexcept;
|
|
|
|
bool status_known(file_status) noexcept;
|
|
|
|
file_status symlink_status(const path&);
|
|
file_status symlink_status(const path&, error_code&) noexcept;
|
|
|
|
path system_complete(const path&);
|
|
path system_complete(const path&, error_code&);
|
|
|
|
path temp_directory_path();
|
|
path temp_directory_path(error_code&);
|
|
|
|
template <class _Path_type>
|
|
class _Path_iterator {
|
|
public:
|
|
using path_type = _Path_type;
|
|
using string_type = typename _Path_type::string_type;
|
|
|
|
using iterator_category = bidirectional_iterator_tag;
|
|
using value_type = path_type;
|
|
using difference_type = ptrdiff_t;
|
|
using pointer = const value_type*;
|
|
using reference = const value_type&;
|
|
|
|
_Path_iterator() : _Myptr(nullptr), _Myoff(0) {}
|
|
|
|
_Path_iterator(const path_type& _Path, size_t _Off) : _Myptr(&_Path), _Myoff(_Off) {
|
|
_Getval();
|
|
}
|
|
|
|
_Path_iterator(const _Path_iterator& _Right)
|
|
: _Myptr(_Right._Myptr), _Myelem(_Right._Myelem), _Myoff(_Right._Myoff) {}
|
|
|
|
_Path_iterator& operator=(const _Path_iterator& _Right) {
|
|
_Myptr = _Right._Myptr;
|
|
_Myelem = _Right._Myelem;
|
|
_Myoff = _Right._Myoff;
|
|
return *this;
|
|
}
|
|
|
|
_Path_iterator(_Path_iterator&& _Right) noexcept
|
|
: _Myptr(_Right._Myptr), _Myelem(_STD move(_Right._Myelem)), _Myoff(_Right._Myoff) {}
|
|
|
|
_Path_iterator& operator=(_Path_iterator&& _Right) noexcept {
|
|
_Myptr = _Right._Myptr;
|
|
_Myelem = _STD move(_Right._Myelem);
|
|
_Myoff = _Right._Myoff;
|
|
return *this;
|
|
}
|
|
|
|
_NODISCARD reference operator*() const {
|
|
return _Myelem;
|
|
}
|
|
|
|
_NODISCARD pointer operator->() const {
|
|
return pointer_traits<pointer>::pointer_to(**this);
|
|
}
|
|
|
|
_Path_iterator& operator++() {
|
|
#if _ITERATOR_DEBUG_LEVEL != 0
|
|
_STL_VERIFY(_Myptr && _Myoff < _Myptr->_Mystr.size(), "path::iterator is not incrementable");
|
|
#endif // _ITERATOR_DEBUG_LEVEL != 0
|
|
|
|
const size_t _Pend = _Myptr->_Prefix_end();
|
|
const size_t _Size = _Myptr->_Mystr.size();
|
|
|
|
if (_Myoff < _Pend) {
|
|
_Myoff = _Pend; // point past "x:"
|
|
} else if (_Myoff == _Pend && _Pend < _Size
|
|
&& _FS_ISSEP(_Myptr->_Mystr[_Pend])) { // point past root "/" and following slashes
|
|
for (++_Myoff; _Myoff < _Size; ++_Myoff) {
|
|
if (!_FS_ISSEP(_Myptr->_Mystr[_Myoff])) {
|
|
break;
|
|
}
|
|
}
|
|
} else { // point past slashes followed by stuff
|
|
for (; _Myoff < _Size; ++_Myoff) {
|
|
if (!_FS_ISSEP(_Myptr->_Mystr[_Myoff])) {
|
|
break;
|
|
}
|
|
}
|
|
for (; _Myoff < _Size; ++_Myoff) {
|
|
if (_FS_ISSEP(_Myptr->_Mystr[_Myoff])) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
_Getval();
|
|
return *this;
|
|
}
|
|
|
|
_Path_iterator operator++(int) {
|
|
_Path_iterator _Tmp = *this;
|
|
++*this;
|
|
return _Tmp;
|
|
}
|
|
|
|
_Path_iterator& operator--() {
|
|
#if _ITERATOR_DEBUG_LEVEL != 0
|
|
_STL_VERIFY(_Myptr && _Myoff != 0, "path::iterator is not decrementable");
|
|
#endif // _ITERATOR_DEBUG_LEVEL != 0
|
|
|
|
const size_t _Myoff_sav = _Myoff;
|
|
size_t _Off_back = 0;
|
|
_Myoff = 0;
|
|
do { // scan down to previous
|
|
_Off_back = _Myoff;
|
|
++*this;
|
|
} while (_Myoff < _Myoff_sav);
|
|
_Myoff = _Off_back;
|
|
_Getval();
|
|
return *this;
|
|
}
|
|
|
|
_Path_iterator operator--(int) {
|
|
_Path_iterator _Tmp = *this;
|
|
--*this;
|
|
return _Tmp;
|
|
}
|
|
|
|
_NODISCARD bool operator==(const _Path_iterator& _Right) const {
|
|
return _Myptr == _Right._Myptr && _Myoff == _Right._Myoff;
|
|
}
|
|
|
|
_NODISCARD bool operator!=(const _Path_iterator& _Right) const {
|
|
return !(*this == _Right);
|
|
}
|
|
|
|
private:
|
|
void _Getval() { // determine _Myelem
|
|
string_type _Str;
|
|
const size_t _Pend = _Myptr->_Prefix_end();
|
|
const size_t _Size = _Myptr->_Mystr.size();
|
|
|
|
if (_Size > _Myoff) {
|
|
if (_Myoff < _Pend) {
|
|
_Str = _Myptr->_Mystr.substr(0, _Pend); // get "x:"
|
|
} else if (_Myoff == _Pend && _Pend < _Size && _FS_ISSEP(_Myptr->_Mystr[_Pend])) {
|
|
_Str = _FS_PREF; // get "/"
|
|
} else { // determine next field as slashes followed by stuff
|
|
size_t _Nslash = 0;
|
|
size_t _Nstuff = 0;
|
|
|
|
for (; _Myoff + _Nslash < _Size; ++_Nslash) {
|
|
if (!_FS_ISSEP(_Myptr->_Mystr[_Myoff + _Nslash])) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
for (; _Myoff + _Nslash + _Nstuff < _Size; ++_Nstuff) {
|
|
if (_FS_ISSEP(_Myptr->_Mystr[_Myoff + _Nslash + _Nstuff])) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (0 < _Nstuff) {
|
|
_Str = _Myptr->_Mystr.substr(_Myoff + _Nslash, _Nstuff); // get "stuff"
|
|
} else if (0 < _Nslash) {
|
|
_Str = _FS_PERIOD; // get "."
|
|
}
|
|
}
|
|
}
|
|
|
|
_Myelem = _Str;
|
|
}
|
|
|
|
const path_type* _Myptr; // pointer to full path
|
|
path_type _Myelem; // current element subpath
|
|
size_t _Myoff; // current offset in full path
|
|
};
|
|
|
|
class path { // stores a pathname
|
|
public:
|
|
using value_type = _Pchar;
|
|
using string_type = basic_string<value_type>;
|
|
|
|
static constexpr value_type preferred_separator = _FS_PREF;
|
|
|
|
path() {}
|
|
|
|
path(const path& _Right) : _Mystr(_Right._Mystr) {}
|
|
|
|
template <class _InIt, enable_if_t<_Is_iterator_v<_InIt>, int> = 0>
|
|
path(_InIt _First, _InIt _Last) {
|
|
using _Valty = _Iter_value_t<_InIt>;
|
|
basic_string<_Valty> _Str(_First, _Last);
|
|
string_type _Str_out;
|
|
*this /= _Path_cvt<_Valty, value_type>::_Cvt(_Str_out, _Str.c_str(), _Str.size());
|
|
}
|
|
|
|
template <class _InIt, enable_if_t<conjunction_v<negation<is_same<_InIt, path>>, _Is_iterator<_InIt>>, int> = 0>
|
|
path(_InIt _First) {
|
|
using _Valty = _Iter_value_t<_InIt>;
|
|
basic_string<_Valty> _Str;
|
|
for (; *_First != _Valty(0); ++_First) {
|
|
_Str += *_First;
|
|
}
|
|
|
|
string_type _Str_out;
|
|
*this /= _Path_cvt<_Valty, value_type>::_Cvt(_Str_out, _Str.c_str(), _Str.size());
|
|
}
|
|
|
|
template <class _Elem, class _Traits, class _Alloc>
|
|
path(const basic_string<_Elem, _Traits, _Alloc>& _Str) {
|
|
string_type _Str_out;
|
|
*this /= _Path_cvt<_Elem, value_type>::_Cvt(_Str_out, _Str.c_str(), _Str.size());
|
|
}
|
|
|
|
template <class _InIt, enable_if_t<_Is_iterator_v<_InIt>, int> = 0>
|
|
path(_InIt _First, _InIt _Last, const locale& _Loc) {
|
|
using _Valty = _Iter_value_t<_InIt>;
|
|
basic_string<_Valty> _Str(_First, _Last);
|
|
string_type _Str_out;
|
|
*this /= _Path_cvt<_Valty, value_type>::_Cvt(_Str_out, _Str.c_str(), _Str.size(), _Loc);
|
|
}
|
|
|
|
template <class _InIt, enable_if_t<_Is_iterator_v<_InIt>, int> = 0>
|
|
path(_InIt _First, const locale& _Loc) {
|
|
using _Valty = _Iter_value_t<_InIt>;
|
|
basic_string<_Valty> _Str;
|
|
for (; *_First != _Valty(0); ++_First) {
|
|
_Str += *_First;
|
|
}
|
|
|
|
string_type _Str_out;
|
|
*this /= _Path_cvt<_Valty, value_type>::_Cvt(_Str_out, _Str.c_str(), _Str.size(), _Loc);
|
|
}
|
|
|
|
template <class _Elem, class _Traits, class _Alloc>
|
|
path(const basic_string<_Elem, _Traits, _Alloc>& _Str, const locale& _Loc) {
|
|
string_type _Str_out;
|
|
*this /= _Path_cvt<_Elem, value_type>::_Cvt(_Str_out, _Str.c_str(), _Str.size(), _Loc);
|
|
}
|
|
|
|
path(path&& _Right) noexcept : _Mystr(_STD move(_Right._Mystr)) {}
|
|
|
|
path& operator=(path&& _Right) noexcept {
|
|
_Mystr = _STD move(_Right._Mystr);
|
|
return *this;
|
|
}
|
|
|
|
~path() noexcept {}
|
|
|
|
path& operator=(const path& _Right) {
|
|
_Mystr = _Right._Mystr;
|
|
return *this;
|
|
}
|
|
|
|
template <class _InIt>
|
|
path& operator=(_InIt _First) {
|
|
return *this = path{_First};
|
|
}
|
|
|
|
template <class _Elem, class _Traits, class _Alloc>
|
|
path& operator=(const basic_string<_Elem, _Traits, _Alloc>& _Str) {
|
|
return *this = path{_Str};
|
|
}
|
|
|
|
template <class _InIt>
|
|
path& assign(_InIt _First, _InIt _Last) {
|
|
return *this = path{_First, _Last};
|
|
}
|
|
|
|
template <class _InIt>
|
|
path& assign(_InIt _First) {
|
|
return *this = path{_First};
|
|
}
|
|
|
|
template <class _Elem, class _Traits, class _Alloc>
|
|
path& assign(const basic_string<_Elem, _Traits, _Alloc>& _Str) {
|
|
return *this = path{_Str};
|
|
}
|
|
|
|
path& operator/=(const path& _Path) { // append copy
|
|
return append(_Path._Mystr);
|
|
}
|
|
|
|
template <class _InIt>
|
|
path& operator/=(_InIt _First) { // append NTCTS, given iterator
|
|
return append(path{_First}._Mystr);
|
|
}
|
|
|
|
template <class _Elem, class _Traits, class _Alloc>
|
|
path& operator/=(const basic_string<_Elem, _Traits, _Alloc>& _Str) { // append arbitrary source string
|
|
return append(_Str);
|
|
}
|
|
|
|
template <class _InIt>
|
|
path& append(_InIt _First, _InIt _Last) { // append NTCTS
|
|
return append(path{_First, _Last}._Mystr);
|
|
}
|
|
|
|
template <class _InIt>
|
|
path& append(_InIt _First) { // append NTCTS
|
|
return append(path{_First}._Mystr);
|
|
}
|
|
|
|
template <class _Elem, class _Traits, class _Alloc>
|
|
path& append(const basic_string<_Elem, _Traits, _Alloc>& _Str0) { // append arbitrary source string
|
|
string_type _Str(_Str0.size(), L'\0');
|
|
// convert _Elem and '/' to '\'
|
|
_STD transform(_Str0.begin(), _Str0.end(), _Str.begin(), [](const _Elem _Ch) _STATIC_CALL_OPERATOR {
|
|
auto _Wch = static_cast<wchar_t>(_Ch);
|
|
if (_Wch == _FS_SLASH) {
|
|
_Wch = _FS_PREF;
|
|
}
|
|
|
|
return _Wch;
|
|
});
|
|
|
|
if (0 < _Mystr.size() && 0 < _Str.size() && _Mystr.back() != _FS_COLON && !_FS_ISSEP(_Mystr.back())
|
|
&& !_FS_ISSEP(_Str[0])) {
|
|
_Mystr.push_back(_FS_PREF); // add needed separator
|
|
}
|
|
|
|
_Mystr.append(_Str);
|
|
return *this;
|
|
}
|
|
|
|
path& operator+=(const path& _Path) { // concatenate copy
|
|
return concat(_Path._Mystr);
|
|
}
|
|
|
|
template <class _Ty>
|
|
path& operator+=(_Ty _Val) { // concatenate NTCTS, given iterator/element
|
|
return concat(_Val);
|
|
}
|
|
|
|
template <class _Elem, class _Traits, class _Alloc>
|
|
path& operator+=(const basic_string<_Elem, _Traits, _Alloc>& _Str) { // concatenate arbitrary source string
|
|
return concat(_Str);
|
|
}
|
|
|
|
template <class _Elem>
|
|
path& operator+=(const _Elem* _Ptr) { // concatenate arbitrary NTCTS
|
|
return concat(basic_string<_Elem>(_Ptr));
|
|
}
|
|
|
|
template <class _InIt>
|
|
path& concat(_InIt _First, _InIt _Last) { // concatenate NTCTS
|
|
return concat(path{_First, _Last}._Mystr);
|
|
}
|
|
|
|
template <class _Elem>
|
|
path& concat(const _Elem* _Ptr) { // concatenate arbitrary NTCTS
|
|
return concat(basic_string<_Elem>(_Ptr));
|
|
}
|
|
|
|
template <class _InIt, enable_if_t<_Is_iterator_v<_InIt>, int> = 0>
|
|
path& concat(_InIt _First) { // concatenate NTCTS
|
|
return concat(path{_First}._Mystr);
|
|
}
|
|
|
|
template <class _Elem, enable_if_t<!_Is_iterator_v<_Elem>, int> = 0>
|
|
path& concat(_Elem _Val) { // concatenate element
|
|
return concat(path{basic_string<_Elem>(1, _Val)}._Mystr);
|
|
}
|
|
|
|
template <class _Elem, class _Traits, class _Alloc>
|
|
path& concat(const basic_string<_Elem, _Traits, _Alloc>& _Str) { // concatenate arbitrary source string
|
|
for (const auto& _Ch : _Str) {
|
|
_Mystr.push_back(static_cast<wchar_t>(_Ch));
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
void clear() noexcept { // clear the stored string
|
|
_Mystr.clear();
|
|
}
|
|
|
|
path& make_preferred() { // convert any '/' to '\'
|
|
_STD replace(_Mystr.begin(), _Mystr.end(), _FS_SLASH, _FS_BSLASH);
|
|
return *this;
|
|
}
|
|
|
|
path& remove_filename() { // remove filename (leaf)
|
|
if (!empty() && begin() != --end()) { // leaf to remove, back up over it
|
|
const size_t _Rend = _Root_end();
|
|
size_t _Idx = _Mystr.size();
|
|
|
|
for (; _Rend < _Idx; --_Idx) {
|
|
if (_FS_ISSEP(_Mystr[_Idx - 1])) {
|
|
break; // back up over stuff at end
|
|
}
|
|
}
|
|
|
|
for (; _Rend < _Idx; --_Idx) {
|
|
if (!_FS_ISSEP(_Mystr[_Idx - 1])) {
|
|
break; // back up over trailing non-root slashes
|
|
}
|
|
}
|
|
|
|
_Mystr.erase(_Idx);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
path& replace_filename(const path& _Path) { // replace filename
|
|
remove_filename();
|
|
*this /= _Path;
|
|
return *this;
|
|
}
|
|
|
|
path& replace_extension(const path& _Newext = {}) { // replace extension with _Newext
|
|
if (_Newext.empty() || _Newext.c_str()[0] == _FS_PERIOD) {
|
|
*this = parent_path() / path{stem().native() + _Newext.native()};
|
|
} else {
|
|
*this = parent_path() / path{stem().native() + _FS_PERIOD + _Newext.native()};
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
void swap(path& _Right) noexcept {
|
|
_Mystr.swap(_Right._Mystr);
|
|
}
|
|
|
|
_NODISCARD const string_type& native() const noexcept {
|
|
return _Mystr;
|
|
}
|
|
|
|
_NODISCARD _Ret_z_ const value_type* c_str() const noexcept {
|
|
return _Mystr.c_str();
|
|
}
|
|
|
|
operator string_type() const {
|
|
return _Mystr;
|
|
}
|
|
|
|
template <class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>
|
|
_NODISCARD basic_string<_Elem, _Traits, _Alloc> string(
|
|
const _Alloc& _Al = _Alloc()) const { // return path as basic_string<_Elem, _Traits, _Alloc>
|
|
basic_string<_Elem, _Traits, _Alloc> _Str(_Al);
|
|
return _Path_cvt<value_type, _Elem>::_Cvt(_Str, _Mystr.c_str(), _Mystr.size());
|
|
}
|
|
|
|
_NODISCARD _STD string string() const { // return path as basic_string<char> native
|
|
_STD string _Str;
|
|
return _Path_cvt<value_type, char>::_Cvt(_Str, _Mystr.c_str(), _Mystr.size());
|
|
}
|
|
|
|
_NODISCARD _STD wstring wstring() const { // return path as basic_string<wchar_t> native
|
|
_STD wstring _Str;
|
|
return _Path_cvt<value_type, wchar_t>::_Cvt(_Str, _Mystr.c_str(), _Mystr.size());
|
|
}
|
|
|
|
_NODISCARD _STD string u8string() const { // return path as basic_string<char> UTF8
|
|
_STD string _Str;
|
|
return _Path_cvt<value_type, _Char8_t, char_traits<char>, allocator<char>>::_Cvt(
|
|
_Str, _Mystr.c_str(), _Mystr.size());
|
|
}
|
|
|
|
_NODISCARD _STD u16string u16string() const { // return path as basic_string<char16_t> UTF16
|
|
_STD u16string _Str;
|
|
return _Path_cvt<value_type, char16_t>::_Cvt(_Str, _Mystr.c_str(), _Mystr.size());
|
|
}
|
|
|
|
_STD u32string u32string() const = delete;
|
|
|
|
string_type _Make_generic() const { // copy and convert any '\' to '/'
|
|
string_type _Str = _Mystr;
|
|
_STD replace(_Str.begin(), _Str.end(), _FS_BSLASH, _FS_SLASH);
|
|
return _Str;
|
|
}
|
|
|
|
template <class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>
|
|
_NODISCARD basic_string<_Elem, _Traits, _Alloc> generic_string(
|
|
const _Alloc& _Al = _Alloc()) const { // return path as basic_string<_Elem, _Traits, _Alloc>
|
|
basic_string<_Elem, _Traits, _Alloc> _Str(_Al);
|
|
const string_type _Genstr = _Make_generic();
|
|
return _Path_cvt<value_type, _Elem>::_Cvt(_Str, _Genstr.c_str(), _Genstr.size());
|
|
}
|
|
|
|
_NODISCARD _STD string generic_string() const { // return path as basic_string<char> native
|
|
_STD string _Str;
|
|
const string_type _Genstr = _Make_generic();
|
|
return _Path_cvt<value_type, char>::_Cvt(_Str, _Genstr.c_str(), _Genstr.size());
|
|
}
|
|
|
|
_NODISCARD _STD wstring generic_wstring() const { // return path as basic_string<wchar_t> native
|
|
_STD wstring _Str;
|
|
const string_type _Genstr = _Make_generic();
|
|
return _Path_cvt<value_type, wchar_t>::_Cvt(_Str, _Genstr.c_str(), _Genstr.size());
|
|
}
|
|
|
|
_NODISCARD _STD string generic_u8string() const { // return path as basic_string<char> UTF8
|
|
_STD string _Str;
|
|
const string_type _Genstr = _Make_generic();
|
|
return _Path_cvt<value_type, _Char8_t, char_traits<char>, allocator<char>>::_Cvt(
|
|
_Str, _Genstr.c_str(), _Genstr.size());
|
|
}
|
|
|
|
_NODISCARD _STD u16string generic_u16string() const { // return path as basic_string<char16_t> UTF16
|
|
_STD u16string _Str;
|
|
const string_type _Genstr = _Make_generic();
|
|
return _Path_cvt<value_type, char16_t>::_Cvt(_Str, _Genstr.c_str(), _Genstr.size());
|
|
}
|
|
|
|
_STD u32string generic_u32string() const = delete;
|
|
|
|
_NODISCARD int compare(const path& _Path) const noexcept { // compare native() to _Path.native()
|
|
return _Mystr.compare(_Path._Mystr);
|
|
}
|
|
|
|
_NODISCARD int compare(const string_type& _Str) const { // compare native() to string
|
|
return _Mystr.compare(_Str);
|
|
}
|
|
|
|
_NODISCARD int compare(const value_type* _Ptr) const { // compare native() to NTCS
|
|
return _Mystr.compare(_Ptr);
|
|
}
|
|
|
|
_NODISCARD path root_name() const {
|
|
return path{_Mystr.substr(0, _Prefix_end())};
|
|
}
|
|
|
|
_NODISCARD path root_directory() const {
|
|
const size_t _Idx = _Prefix_end();
|
|
if (_Idx < _Mystr.size() && _FS_ISSEP(_Mystr[_Idx])) {
|
|
return path{string_type(1, _FS_PREF)};
|
|
} else {
|
|
return {};
|
|
}
|
|
}
|
|
|
|
_NODISCARD path root_path() const {
|
|
return path{_Mystr.c_str(), _Mystr.c_str() + _Root_end()};
|
|
}
|
|
|
|
_NODISCARD path relative_path() const {
|
|
size_t _Idx = _Root_end();
|
|
while (_Idx < _Mystr.size() && _FS_ISSEP(_Mystr[_Idx])) {
|
|
++_Idx; // skip extra '/' after root
|
|
}
|
|
|
|
return path{_Mystr.substr(_Idx)};
|
|
}
|
|
|
|
_NODISCARD path parent_path() const {
|
|
path _Ans;
|
|
if (!empty()) { // append all but last element
|
|
iterator _End = --end();
|
|
for (iterator _Next = begin(); _Next != _End; ++_Next) {
|
|
_Ans /= *_Next;
|
|
}
|
|
}
|
|
return _Ans;
|
|
}
|
|
|
|
_NODISCARD path filename() const {
|
|
return empty() ? path{} : path{*--end()};
|
|
}
|
|
|
|
_NODISCARD path stem() const { // pick off stem (basename) in filename (leaf) before dot
|
|
string_type _Str0 = filename().native();
|
|
string_type _Str1 = extension().native();
|
|
_Str0.resize(_Str0.size() - _Str1.size());
|
|
return path{_Str0};
|
|
}
|
|
|
|
_NODISCARD path extension() const { // pick off .extension in filename (leaf), including dot
|
|
string_type _Str = filename().native();
|
|
const size_t _Idx = _Str.rfind(_FS_PERIOD);
|
|
return _Idx == string_type::npos // no .
|
|
|| _Str.size() == 1 // only .
|
|
|| (_Str.size() == 2 && _Str[0] == _FS_PERIOD && _Str[1] == _FS_PERIOD) // only ..
|
|
? path{}
|
|
: path{_Str.substr(_Idx)};
|
|
}
|
|
|
|
_NODISCARD bool empty() const noexcept {
|
|
return _Mystr.empty();
|
|
}
|
|
|
|
_NODISCARD bool has_root_name() const {
|
|
return !root_name().empty();
|
|
}
|
|
|
|
_NODISCARD bool has_root_directory() const {
|
|
return !root_directory().empty();
|
|
}
|
|
|
|
_NODISCARD bool has_root_path() const {
|
|
return !root_path().empty();
|
|
}
|
|
|
|
_NODISCARD bool has_relative_path() const {
|
|
return !relative_path().empty();
|
|
}
|
|
|
|
_NODISCARD bool has_parent_path() const {
|
|
return !parent_path().empty();
|
|
}
|
|
|
|
_NODISCARD bool has_filename() const {
|
|
return !filename().empty();
|
|
}
|
|
|
|
_NODISCARD bool has_stem() const {
|
|
return !stem().empty();
|
|
}
|
|
|
|
_NODISCARD bool has_extension() const {
|
|
return !extension().empty();
|
|
}
|
|
|
|
_NODISCARD bool is_absolute() const {
|
|
return has_root_name() && has_root_directory();
|
|
}
|
|
|
|
_NODISCARD bool is_relative() const {
|
|
return !is_absolute();
|
|
}
|
|
|
|
using iterator = _Path_iterator<path>;
|
|
using const_iterator = iterator;
|
|
|
|
_NODISCARD iterator begin() const {
|
|
return iterator(*this, 0);
|
|
}
|
|
|
|
_NODISCARD iterator end() const {
|
|
return iterator(*this, _Mystr.size());
|
|
}
|
|
|
|
size_t _Prefix_end() const {
|
|
if (2 < _Mystr.size() && _FS_ISSEP(_Mystr[0]) && _FS_ISSEP(_Mystr[1])
|
|
&& !_FS_ISSEP(_Mystr[2])) { // network name, pick off \\name
|
|
size_t _Idx = 3;
|
|
while (_Idx < _Mystr.size() && !_FS_ISSEP(_Mystr[_Idx])) {
|
|
++_Idx;
|
|
}
|
|
|
|
return _Idx;
|
|
} else { // no network name, pick off drive:
|
|
size_t _Idx = _Mystr.find(_FS_COLON, 0);
|
|
if (_Idx == _Mystr.npos) {
|
|
_Idx = 0;
|
|
} else {
|
|
++_Idx;
|
|
}
|
|
|
|
return _Idx;
|
|
}
|
|
}
|
|
|
|
size_t _Root_end() const {
|
|
size_t _Idx = _Prefix_end();
|
|
if (_Idx < _Mystr.size() && _FS_ISSEP(_Mystr[_Idx])) {
|
|
++_Idx;
|
|
}
|
|
|
|
return _Idx;
|
|
}
|
|
|
|
string_type _Mystr;
|
|
};
|
|
|
|
inline void swap(path& _Left, path& _Right) noexcept {
|
|
_Left.swap(_Right);
|
|
}
|
|
|
|
_NODISCARD inline size_t hash_value(const path& _Path) noexcept {
|
|
return hash<path::string_type>()(_Path.native());
|
|
}
|
|
|
|
_NODISCARD inline bool operator==(const path& _Left, const path& _Right) noexcept {
|
|
return _Left.native() == _Right.native();
|
|
}
|
|
|
|
_NODISCARD inline bool operator!=(const path& _Left, const path& _Right) noexcept {
|
|
return !(_Left == _Right);
|
|
}
|
|
|
|
_NODISCARD inline bool operator<(const path& _Left, const path& _Right) noexcept {
|
|
return _Left.native() < _Right.native();
|
|
}
|
|
|
|
_NODISCARD inline bool operator<=(const path& _Left, const path& _Right) noexcept {
|
|
return !(_Right < _Left);
|
|
}
|
|
|
|
_NODISCARD inline bool operator>(const path& _Left, const path& _Right) noexcept {
|
|
return _Right < _Left;
|
|
}
|
|
|
|
_NODISCARD inline bool operator>=(const path& _Left, const path& _Right) noexcept {
|
|
return !(_Left < _Right);
|
|
}
|
|
|
|
_NODISCARD inline path operator/(const path& _Left, const path& _Right) { // concatenate paths
|
|
path _Ans = _Left;
|
|
_Ans /= _Right;
|
|
return _Ans;
|
|
}
|
|
|
|
template <class _Elem, class _Traits>
|
|
basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, const path& _Path) { // insert a path
|
|
return _Ostr << _Path.string<_Elem, _Traits, allocator<_Elem>>();
|
|
}
|
|
|
|
template <class _Elem, class _Traits>
|
|
basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, path& _Path) { // extract a path
|
|
basic_string<_Elem, _Traits> _Str;
|
|
_Istr >> _Str;
|
|
_Path = _Str;
|
|
return _Istr;
|
|
}
|
|
|
|
template <class _InIt, enable_if_t<_Is_iterator_v<_InIt>, int> = 0>
|
|
_NODISCARD path u8path(_InIt _First, _InIt _Last) { // make path from [_First, _Last) UTF8, given iterators
|
|
string _Str(_First, _Last);
|
|
path::string_type _Str_out;
|
|
return path{_Path_cvt<_Char8_t, _Pchar>::_Cvt(_Str_out, _Str.c_str(), _Str.size())};
|
|
}
|
|
|
|
template <class _InIt, enable_if_t<_Is_iterator_v<_InIt>, int> = 0>
|
|
_NODISCARD path u8path(_InIt _First) { // make path from NTBS UTF8, given iterator
|
|
string _Str;
|
|
for (; *_First != '\0'; ++_First) {
|
|
_Str += *_First;
|
|
}
|
|
|
|
path::string_type _Str_out;
|
|
return path{_Path_cvt<_Char8_t, _Pchar>::_Cvt(_Str_out, _Str.c_str(), _Str.size())};
|
|
}
|
|
|
|
template <class _Traits, class _Alloc>
|
|
_NODISCARD path u8path(const basic_string<char, _Traits, _Alloc>& _Str) { // make path from arbitrary char string UTF8
|
|
path::string_type _Str_out;
|
|
return path{_Path_cvt<_Char8_t, _Pchar>::_Cvt(_Str_out, _Str.c_str(), _Str.size())};
|
|
}
|
|
|
|
class filesystem_error : public system_error { // base of all filesystem-error exceptions
|
|
public:
|
|
explicit filesystem_error(
|
|
const string& _Message, error_code _Errcode = make_error_code(errc::operation_not_permitted))
|
|
: system_error(_Errcode, _Message) {}
|
|
|
|
filesystem_error(const string& _Message, const path& _Path1, error_code _Errcode)
|
|
: system_error(_Errcode, _Message), _Mypval1(_Path1) {}
|
|
|
|
filesystem_error(const string& _Message, const path& _Path1, const path& _Path2, error_code _Errcode)
|
|
: system_error(_Errcode, _Message), _Mypval1(_Path1), _Mypval2(_Path2) {}
|
|
|
|
__CLR_OR_THIS_CALL ~filesystem_error() noexcept override {}
|
|
|
|
filesystem_error(filesystem_error&& _Right) noexcept
|
|
: system_error(_Right.code(), _Right.what()), _Mypval1(_STD move(_Right._Mypval1)),
|
|
_Mypval2(_STD move(_Right._Mypval2)) {}
|
|
|
|
filesystem_error& operator=(filesystem_error&& _Right) noexcept {
|
|
static_cast<system_error&>(*this) = _Right;
|
|
_Mypval1 = _STD move(_Right._Mypval1);
|
|
_Mypval2 = _STD move(_Right._Mypval2);
|
|
return *this;
|
|
}
|
|
|
|
_NODISCARD const path& path1() const noexcept {
|
|
return _Mypval1;
|
|
}
|
|
|
|
_NODISCARD const path& path2() const noexcept {
|
|
return _Mypval2;
|
|
}
|
|
|
|
filesystem_error(const filesystem_error&) = default;
|
|
filesystem_error& operator=(const filesystem_error&) = default;
|
|
|
|
private:
|
|
path _Mypval1;
|
|
path _Mypval2;
|
|
|
|
#if !_HAS_EXCEPTIONS
|
|
protected:
|
|
__CLR_OR_THIS_CALL void _Doraise() const override { // perform class-specific exception handling
|
|
_RAISE(*this);
|
|
}
|
|
#endif // !_HAS_EXCEPTIONS
|
|
};
|
|
|
|
[[noreturn]] inline void _Throw_filesystem_error(const char* const _Message) {
|
|
_THROW(filesystem_error{_Message}); // centralize construction of temporary string
|
|
}
|
|
|
|
class directory_entry { // represents a directory entry
|
|
public:
|
|
using string_type = _FSPFX path::string_type;
|
|
|
|
directory_entry() : _Mystat(), _Mysymstat() {}
|
|
|
|
directory_entry(const directory_entry&) = default;
|
|
directory_entry& operator=(const directory_entry&) = default;
|
|
|
|
directory_entry(directory_entry&&) = default;
|
|
directory_entry& operator=(directory_entry&&) = default;
|
|
|
|
explicit directory_entry(
|
|
const _FSPFX path& _Path, file_status _Statarg = file_status{}, file_status _Symstatarg = file_status{})
|
|
: _Mypval(_Path), _Mystat(_Statarg), _Mysymstat(_Symstatarg) {}
|
|
|
|
void assign(
|
|
const _FSPFX path& _Path, file_status _Statarg = file_status{}, file_status _Symstatarg = file_status{}) {
|
|
_Mypval = _Path;
|
|
_Mystat = _Statarg;
|
|
_Mysymstat = _Symstatarg;
|
|
}
|
|
|
|
void replace_filename(const _FSPFX path& _Path, file_status _Statarg = file_status{},
|
|
file_status _Symstatarg = file_status{}) { // replace filename and assign status
|
|
_Mypval = _Mypval.parent_path() / _Path;
|
|
_Mystat = _Statarg;
|
|
_Mysymstat = _Symstatarg;
|
|
}
|
|
|
|
operator const _FSPFX path&() const noexcept {
|
|
return _Mypval;
|
|
}
|
|
|
|
_NODISCARD const _FSPFX path& path() const noexcept {
|
|
return _Mypval;
|
|
}
|
|
|
|
_NODISCARD file_status status() const {
|
|
error_code _Code;
|
|
return status(_Code);
|
|
}
|
|
|
|
_NODISCARD file_status status(error_code& _Code) const noexcept {
|
|
_Code.clear();
|
|
if (!status_known(_Mystat)) {
|
|
if (status_known(_Mysymstat) && !is_symlink(_Mysymstat)) {
|
|
_Mystat = _Mysymstat;
|
|
} else {
|
|
_Mystat = _FSPFX status(_Mypval, _Code);
|
|
}
|
|
}
|
|
|
|
return _Mystat;
|
|
}
|
|
|
|
_NODISCARD file_status symlink_status() const {
|
|
error_code _Code;
|
|
return symlink_status(_Code);
|
|
}
|
|
|
|
_NODISCARD file_status symlink_status(error_code& _Code) const noexcept {
|
|
_Code.clear();
|
|
if (!status_known(_Mysymstat)) {
|
|
_Mysymstat = _FSPFX symlink_status(_Mypval, _Code);
|
|
}
|
|
|
|
return _Mysymstat;
|
|
}
|
|
|
|
_NODISCARD bool operator==(const directory_entry& _Right) const noexcept {
|
|
return _Mypval == _Right._Mypval;
|
|
}
|
|
|
|
_NODISCARD bool operator!=(const directory_entry& _Right) const noexcept {
|
|
return !(*this == _Right);
|
|
}
|
|
|
|
_NODISCARD bool operator<(const directory_entry& _Right) const noexcept {
|
|
return _Mypval < _Right._Mypval;
|
|
}
|
|
|
|
_NODISCARD bool operator>(const directory_entry& _Right) const noexcept {
|
|
return _Right < *this;
|
|
}
|
|
_NODISCARD bool operator<=(const directory_entry& _Right) const noexcept {
|
|
return !(_Right < *this);
|
|
}
|
|
|
|
_NODISCARD bool operator>=(const directory_entry& _Right) const noexcept {
|
|
return !(*this < _Right);
|
|
}
|
|
|
|
private:
|
|
_FSPFX path _Mypval;
|
|
mutable file_status _Mystat;
|
|
mutable file_status _Mysymstat;
|
|
};
|
|
|
|
template <class _Prefix_directory>
|
|
class _Directory_iterator {
|
|
public:
|
|
using string_type = path::string_type;
|
|
|
|
using iterator_category = input_iterator_tag;
|
|
using value_type = directory_entry;
|
|
using difference_type = ptrdiff_t;
|
|
using pointer = const value_type*;
|
|
using reference = const value_type&;
|
|
|
|
_Directory_iterator() noexcept : _Mypdir(new void*(nullptr), &_Delptr) {}
|
|
|
|
explicit _Directory_iterator(const path& _Path) : _Mypdir(new void*(nullptr), &_Delptr), _Mydirpath(_Path) {
|
|
typename string_type::value_type _Dest[_MAX_FILESYS_NAME];
|
|
int _Errno = 0;
|
|
file_type _Ftype;
|
|
|
|
*_Mypdir = _Open_dir(_Dest, _Path.c_str(), _Errno, _Ftype);
|
|
if (*_Mypdir) {
|
|
_Form_name(_Dest, _Ftype);
|
|
}
|
|
}
|
|
|
|
_Directory_iterator(const path& _Path, error_code& _Code) noexcept
|
|
: _Mypdir(new void*(nullptr), &_Delptr), _Mydirpath(_Path) {
|
|
typename string_type::value_type _Dest[_MAX_FILESYS_NAME];
|
|
int _Errno = 0;
|
|
file_type _Ftype;
|
|
|
|
*_Mypdir = _Open_dir(_Dest, _Path.c_str(), _Errno, _Ftype);
|
|
if (*_Mypdir) {
|
|
_Form_name(_Dest, _Ftype);
|
|
}
|
|
|
|
_Code = error_code(_Errno, _STD system_category());
|
|
}
|
|
|
|
_Directory_iterator(const _Directory_iterator&) = default;
|
|
_Directory_iterator& operator=(const _Directory_iterator&) = default;
|
|
|
|
_Directory_iterator(_Directory_iterator&&) = default;
|
|
_Directory_iterator& operator=(_Directory_iterator&&) = default;
|
|
|
|
_NODISCARD const value_type& operator*() const {
|
|
#if _ITERATOR_DEBUG_LEVEL != 0
|
|
_STL_VERIFY(*_Mypdir, "directory_iterator is not dereferenceable");
|
|
#endif // _ITERATOR_DEBUG_LEVEL != 0
|
|
|
|
return _Myentry;
|
|
}
|
|
|
|
_NODISCARD pointer operator->() const {
|
|
return pointer_traits<pointer>::pointer_to(**this);
|
|
}
|
|
|
|
_Directory_iterator& operator++() {
|
|
#if _ITERATOR_DEBUG_LEVEL != 0
|
|
_STL_VERIFY(*_Mypdir, "directory_iterator is not incrementable");
|
|
#endif // _ITERATOR_DEBUG_LEVEL != 0
|
|
|
|
_Get();
|
|
return *this;
|
|
}
|
|
|
|
_Directory_iterator& increment(error_code& _Code) noexcept {
|
|
_Code.clear();
|
|
if (_Mypdir && *_Mypdir) {
|
|
_Get();
|
|
} else {
|
|
_Code = make_error_code(errc::operation_not_permitted);
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
_Directory_iterator operator++(int) {
|
|
_Directory_iterator _Tmp = *this;
|
|
++*this;
|
|
return _Tmp;
|
|
}
|
|
|
|
bool _Equal(const _Directory_iterator& _Right) const {
|
|
if (_Mypdir.get() && _Right._Mypdir.get()) {
|
|
return *_Mypdir == *_Right._Mypdir;
|
|
}
|
|
|
|
return !_Mypdir.get() && !_Right._Mypdir.get();
|
|
}
|
|
|
|
private:
|
|
static void _Delptr(void** _Ptr) { // close directory and delete pointer
|
|
if (_Ptr && *_Ptr) {
|
|
_Close_dir(*_Ptr);
|
|
}
|
|
|
|
delete _Ptr;
|
|
}
|
|
|
|
void _Get() { // peek at next input element
|
|
if (*_Mypdir) { // read a directory entry
|
|
typename string_type::value_type _Dest[_MAX_FILESYS_NAME];
|
|
file_type _Ftype;
|
|
if (_Read_dir(_Dest, *_Mypdir, _Ftype)[0] == 0) { // end of directory, close it
|
|
_Close_dir(*_Mypdir);
|
|
*_Mypdir = nullptr; // end of directory
|
|
} else {
|
|
_Form_name(_Dest, _Ftype);
|
|
}
|
|
}
|
|
}
|
|
|
|
void _Form_name(typename string_type::value_type* _Filename, file_type _Ftype) {
|
|
if constexpr (_Prefix_directory::value) {
|
|
// set entry to _Mydirpath/_Filename
|
|
_Myentry.assign(_Mydirpath / path{_Filename}, file_status{_Ftype});
|
|
} else {
|
|
// set entry to _Filename
|
|
_Myentry.assign(path{_Filename}, file_status{_Ftype});
|
|
}
|
|
}
|
|
|
|
shared_ptr<void*> _Mypdir;
|
|
path _Mydirpath;
|
|
value_type _Myentry;
|
|
};
|
|
|
|
template <class _Prefix_directory>
|
|
_NODISCARD bool operator==(
|
|
const _Directory_iterator<_Prefix_directory>& _Left, const _Directory_iterator<_Prefix_directory>& _Right) {
|
|
return _Left._Equal(_Right);
|
|
}
|
|
|
|
template <class _Prefix_directory>
|
|
_NODISCARD bool operator!=(
|
|
const _Directory_iterator<_Prefix_directory>& _Left, const _Directory_iterator<_Prefix_directory>& _Right) {
|
|
return !(_Left == _Right);
|
|
}
|
|
|
|
using directory_iterator = _Directory_iterator<true_type>;
|
|
|
|
_NODISCARD inline const directory_iterator& begin(const directory_iterator& _Iter) noexcept {
|
|
return _Iter;
|
|
}
|
|
|
|
_NODISCARD inline directory_iterator end(const directory_iterator&) noexcept {
|
|
return {};
|
|
}
|
|
|
|
class recursive_directory_iterator {
|
|
public:
|
|
using _Myiter = _Directory_iterator<false_type>;
|
|
using _Mypair = pair<_Myiter, path>;
|
|
using string_type = path::string_type;
|
|
using char_type = string_type::value_type;
|
|
|
|
using iterator_category = input_iterator_tag;
|
|
using value_type = directory_entry;
|
|
using difference_type = ptrdiff_t;
|
|
using pointer = const value_type*;
|
|
using reference = const value_type&;
|
|
|
|
recursive_directory_iterator() noexcept
|
|
: _Mylist(1, _Mypair()), _Myentry(), _No_push(false), _Options(directory_options::none) {}
|
|
|
|
explicit recursive_directory_iterator(const path& _Path, directory_options _Opts = directory_options::none)
|
|
: _Mylist(1, _Mypair(_Myiter(_Path), _Path)), _Myentry(), _No_push(false), _Options(_Opts) {
|
|
_Get();
|
|
}
|
|
|
|
recursive_directory_iterator(const path& _Path, directory_options _Opts, error_code& _Code) noexcept
|
|
: _Mylist(1, _Mypair(_Myiter(_Path), _Path)), _Myentry(), _No_push(false), _Options(_Opts) {
|
|
_Code.clear();
|
|
_Get();
|
|
}
|
|
|
|
recursive_directory_iterator(const path& _Path, error_code& _Code) noexcept
|
|
: _Mylist(1, _Mypair(_Myiter(_Path), _Path)), _Myentry(), _No_push(false), _Options(directory_options::none) {
|
|
_Code.clear();
|
|
_Get();
|
|
}
|
|
|
|
recursive_directory_iterator(const recursive_directory_iterator&) = default;
|
|
recursive_directory_iterator& operator=(const recursive_directory_iterator&) = default;
|
|
|
|
recursive_directory_iterator(recursive_directory_iterator&&) = default;
|
|
recursive_directory_iterator& operator=(recursive_directory_iterator&&) = default;
|
|
|
|
_NODISCARD directory_options options() const {
|
|
return _Options;
|
|
}
|
|
|
|
_NODISCARD int depth() const {
|
|
return static_cast<int>(_Mylist.size()) - 1;
|
|
}
|
|
|
|
_NODISCARD bool recursion_pending() const {
|
|
return !_No_push;
|
|
}
|
|
|
|
void pop() { // pop a level
|
|
if (_Mylist.size() > 1) {
|
|
_Mylist.pop_front(); // something to pop, do it
|
|
}
|
|
}
|
|
|
|
void disable_recursion_pending() { // disable directory recursion
|
|
_No_push = true;
|
|
}
|
|
|
|
_NODISCARD const value_type& operator*() const {
|
|
#if _ITERATOR_DEBUG_LEVEL != 0
|
|
_STL_VERIFY(_Mylist.front().first != _Myiter(), "recursive_directory_iterator is not dereferenceable");
|
|
#endif // _ITERATOR_DEBUG_LEVEL != 0
|
|
|
|
return _Myentry;
|
|
}
|
|
|
|
_NODISCARD pointer operator->() const {
|
|
return pointer_traits<pointer>::pointer_to(**this);
|
|
}
|
|
|
|
recursive_directory_iterator& operator++() {
|
|
#if _ITERATOR_DEBUG_LEVEL != 0
|
|
_STL_VERIFY(_Mylist.front().first != _Myiter(), "recursive_directory_iterator is not incrementable");
|
|
#endif // _ITERATOR_DEBUG_LEVEL != 0
|
|
|
|
if (_No_push || !is_directory(_Mylist.front().first->status())
|
|
|| (_Options != directory_options::follow_directory_symlink
|
|
&& is_symlink(_Mylist.front().first->status()))) {
|
|
_No_push = false;
|
|
++_Mylist.front().first;
|
|
} else { // push down a subdirectory
|
|
path _Newpath = _Mylist.front().second / _Mylist.front().first->path();
|
|
++_Mylist.front().first;
|
|
_Mylist.emplace_front(_Myiter(_Newpath), _Newpath);
|
|
}
|
|
while (1 < _Mylist.size() && _Mylist.front().first == _Myiter()) {
|
|
pop();
|
|
}
|
|
|
|
_Get();
|
|
return *this;
|
|
}
|
|
|
|
recursive_directory_iterator& increment(error_code& _Code) noexcept {
|
|
_Code.clear();
|
|
if (_Mylist.front().first == _Myiter()) {
|
|
_Code = make_error_code(errc::operation_not_permitted);
|
|
} else {
|
|
++*this;
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
recursive_directory_iterator operator++(int) {
|
|
recursive_directory_iterator _Tmp = *this;
|
|
++*this;
|
|
return _Tmp;
|
|
}
|
|
|
|
bool _Equal(const recursive_directory_iterator& _Right) const {
|
|
return _Mylist.front().first == _Right._Mylist.front().first;
|
|
}
|
|
|
|
void _Get() { // prime _Myentry for future gets
|
|
if (_Mylist.front().first != _Myiter()) { // item present, get it
|
|
value_type _Dentry = *_Mylist.front().first;
|
|
_Myentry.assign(_Mylist.front().second / _Dentry.path(), _Dentry.status(), _Dentry.symlink_status());
|
|
}
|
|
}
|
|
|
|
private:
|
|
list<_Mypair> _Mylist;
|
|
value_type _Myentry;
|
|
bool _No_push;
|
|
directory_options _Options;
|
|
};
|
|
|
|
_NODISCARD inline bool operator==(
|
|
const recursive_directory_iterator& _Left, const recursive_directory_iterator& _Right) {
|
|
return _Left._Equal(_Right);
|
|
}
|
|
|
|
_NODISCARD inline bool operator!=(
|
|
const recursive_directory_iterator& _Left, const recursive_directory_iterator& _Right) {
|
|
return !(_Left == _Right);
|
|
}
|
|
|
|
_NODISCARD inline const recursive_directory_iterator& begin(const recursive_directory_iterator& _Iter) noexcept {
|
|
return _Iter;
|
|
}
|
|
|
|
_NODISCARD inline recursive_directory_iterator end(const recursive_directory_iterator&) noexcept {
|
|
return {};
|
|
}
|
|
|
|
inline path _Absolute(const path& _Path, const path& _Base,
|
|
error_code& _Code) { // make absolute path from _Path and directory _Base; errors in _Code
|
|
_Code.clear();
|
|
const bool _Path_has_root_name = _Path.has_root_name();
|
|
const bool _Path_has_root_directory = _Path.has_root_directory();
|
|
if (_Path_has_root_name && _Path_has_root_directory) {
|
|
return _Path; // fine as is
|
|
}
|
|
|
|
path _Current = current_path(_Code);
|
|
if (_Code) {
|
|
return {};
|
|
}
|
|
|
|
path _Abs_base = _Absolute(_Base, _Current, _Code);
|
|
if (_Code) {
|
|
return {};
|
|
}
|
|
|
|
if (_Path_has_root_name) { // insert _Base
|
|
return _Path.root_name() / _Abs_base.root_directory() / _Abs_base.relative_path() / _Path.relative_path();
|
|
} else if (_Path_has_root_directory) {
|
|
return _Abs_base.root_name() / _Path; // prepend root name of base
|
|
} else {
|
|
return _Abs_base / _Path; // prepend absolute name of base
|
|
}
|
|
}
|
|
|
|
_NODISCARD inline path absolute(const path& _Path,
|
|
const path& _Base = current_path()) { // make absolute path from _Path and directory _Base
|
|
error_code _Code;
|
|
path _Result = _Absolute(_Path, _Base, _Code);
|
|
if (_Code) {
|
|
_Throw_filesystem_error("absolute(p1, p2): current_path() couldn't get current working directory");
|
|
}
|
|
|
|
return _Result;
|
|
}
|
|
|
|
inline void _Canonicalize_string_only(
|
|
path& _Canon_path, const path& _Abs_path) { // transform absolute path _Abs_path, removing .s, and ..s,
|
|
// using string manipulations (rather than platform support)
|
|
vector<path> _Components;
|
|
path::const_iterator _Abs_path_next = _Abs_path.begin();
|
|
const path::const_iterator _Abs_path_end = _Abs_path.end();
|
|
// This is safe because we have already made the path absolute
|
|
_Canon_path /= *_Abs_path_next; // root_name
|
|
++_Abs_path_next;
|
|
_Canon_path /= *_Abs_path_next; // root_directory
|
|
++_Abs_path_next;
|
|
for (; _Abs_path_next != _Abs_path_end; ++_Abs_path_next) {
|
|
const auto _Cstr = _Abs_path_next->c_str();
|
|
if (_Cstr[0] == _FS_PERIOD) {
|
|
if (_Cstr[1] == static_cast<path::value_type>(0)) {
|
|
continue; // consume "."
|
|
} else if (_Cstr[1] == _FS_PERIOD && _Cstr[2] == static_cast<path::value_type>(0)) {
|
|
// If no parent is found to remove with .., ignore ..
|
|
// (that is, C:\..\..\..\Meow canonicalizes to C:\Meow)
|
|
if (!_Components.empty()) {
|
|
_Components.pop_back();
|
|
}
|
|
|
|
continue; // consume ".."
|
|
}
|
|
}
|
|
|
|
_Components.push_back(*_Abs_path_next);
|
|
}
|
|
|
|
for (const auto& _Component : _Components) {
|
|
_Canon_path /= _Component;
|
|
}
|
|
}
|
|
|
|
_NODISCARD inline path canonical(const path& _Path,
|
|
const path& _Base = current_path()) { // make absolute path from _Path, _Base with no ., .., or symlink
|
|
error_code _Code;
|
|
path _Ans = canonical(_Path, _Base, _Code);
|
|
|
|
if (_Code) {
|
|
_Throw_filesystem_error("canonical(p1, p2): invalid arguments");
|
|
}
|
|
|
|
return _Ans;
|
|
}
|
|
|
|
_NODISCARD inline path canonical(const path& _Path,
|
|
error_code& _Code) { // make absolute path from _Path with no ., .., or symlink
|
|
path _Current = current_path(_Code);
|
|
if (_Code) {
|
|
return {};
|
|
}
|
|
|
|
return canonical(_Path, _Current, _Code);
|
|
}
|
|
|
|
_NODISCARD inline path canonical(const path& _Path, const path& _Base,
|
|
error_code& _Code) { // make absolute path from _Path, _Base with no ".", "..", symlink
|
|
_Code.clear();
|
|
path _Canon_path; // NRVO this variable
|
|
path _Abs_path = _Absolute(_Path, _Base, _Code);
|
|
if (_Code) {
|
|
return _Canon_path;
|
|
}
|
|
|
|
if (_Abs_path.native().size() >= _MAX_FILESYS_NAME) {
|
|
_Code = make_error_code(errc::filename_too_long);
|
|
return _Canon_path;
|
|
}
|
|
|
|
_Canonicalize_string_only(_Canon_path, _Abs_path);
|
|
return _Canon_path;
|
|
}
|
|
|
|
inline bool _Copy_options_indicate_recursive_copy(
|
|
copy_options _Opts) { // Checks a copy_options for whether copy should call itself recursively
|
|
if (_Opts == copy_options::none) {
|
|
// This supports "copying a directory" as copying the directory and
|
|
// files therein but not subdirectories.
|
|
return true;
|
|
}
|
|
|
|
if ((_Opts & copy_options::recursive) != copy_options::none) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
inline void copy(const path& _Oldpval, const path& _Newpval) { // copy _Oldpval to _Newpval, general
|
|
error_code _Code;
|
|
|
|
copy(_Oldpval, _Newpval, copy_options::none, _Code);
|
|
if (_Code) {
|
|
_Throw_filesystem_error("copy(p1, p2): invalid arguments");
|
|
}
|
|
}
|
|
|
|
inline void copy(const path& _Oldpval, const path& _Newpval,
|
|
error_code& _Code) noexcept { // copy _Oldpval to _Newpval, general
|
|
copy(_Oldpval, _Newpval, copy_options::none, _Code);
|
|
}
|
|
|
|
inline void copy(const path& _Oldpval, const path& _Newpval,
|
|
copy_options _Opts) { // copy _Oldpval to _Newpval, general
|
|
error_code _Code;
|
|
|
|
copy(_Oldpval, _Newpval, _Opts, _Code);
|
|
if (_Code) {
|
|
_Throw_filesystem_error("copy(p1, p2, options): invalid arguments");
|
|
}
|
|
}
|
|
|
|
inline void copy(const path& _Oldpval, const path& _Newpval, copy_options _Opts,
|
|
error_code& _Code) noexcept { // copy _Oldpval to _Newpval, general
|
|
file_status _Oldstat;
|
|
file_status _Newstat;
|
|
error_code _Code2;
|
|
|
|
_Code.clear();
|
|
if ((_Opts & copy_options::create_symlinks) != copy_options::none
|
|
|| (_Opts & copy_options::skip_symlinks) != copy_options::none) { // get symlink status
|
|
_Oldstat = symlink_status(_Oldpval);
|
|
_Newstat = symlink_status(_Newpval);
|
|
} else { // get file status
|
|
_Oldstat = status(_Oldpval);
|
|
_Newstat = status(_Newpval);
|
|
}
|
|
|
|
if (!exists(_Oldstat) || equivalent(_Oldpval, _Newpval, _Code2) || is_other(_Oldstat) || is_other(_Newstat)
|
|
|| (is_directory(_Oldstat) && is_regular_file(_Newstat))) {
|
|
_Code = make_error_code(errc::operation_not_permitted);
|
|
} else if (is_symlink(_Oldstat)) {
|
|
if ((_Opts & copy_options::skip_symlinks) == copy_options::none) {
|
|
if (exists(_Newstat) || (_Opts & copy_options::copy_symlinks) == copy_options::none) {
|
|
_Code = make_error_code(errc::operation_not_permitted);
|
|
} else {
|
|
copy_symlink(_Oldpval, _Newpval, _Code);
|
|
}
|
|
}
|
|
} else if (is_regular_file(_Oldstat)) {
|
|
if ((_Opts & copy_options::directories_only) == copy_options::none) {
|
|
if ((_Opts & copy_options::create_symlinks) != copy_options::none) {
|
|
create_symlink(_Oldpval, _Newpval, _Code);
|
|
} else if ((_Opts & copy_options::create_hard_links) != copy_options::none) {
|
|
create_hard_link(_Oldpval, _Newpval, _Code);
|
|
} else if (is_directory(_Newstat)) {
|
|
copy_file(_Oldpval, _Newpval / _Oldpval.filename(), _Opts, _Code);
|
|
} else {
|
|
copy_file(_Oldpval, _Newpval, _Opts, _Code);
|
|
}
|
|
}
|
|
} else if (is_directory(_Oldstat) && _Copy_options_indicate_recursive_copy(_Opts)) { // copy directory recursively
|
|
if (!exists(_Newpval) && !create_directory(_Newpval, _Code) && !_Code) {
|
|
_Code = make_error_code(errc::operation_not_permitted);
|
|
}
|
|
|
|
for (directory_iterator _Next(_Oldpval), _End; !_Code && _Next != _End; ++_Next) {
|
|
copy(_Next->path(), _Newpval / _Next->path().filename(),
|
|
_Opts | copy_options::_Unspecified_recursion_prevention_tag, _Code);
|
|
}
|
|
}
|
|
}
|
|
|
|
inline bool copy_file(const path& _Oldpval, const path& _Newpval,
|
|
copy_options _Opt /* = copy_options::none */) { // copy _Oldpval to _Newpval
|
|
error_code _Code;
|
|
const bool _Ans = copy_file(_Oldpval, _Newpval, _Opt, _Code);
|
|
if (_Code) {
|
|
_Throw_filesystem_error("copy_file(p1, p2, options): invalid arguments");
|
|
}
|
|
|
|
return _Ans;
|
|
}
|
|
|
|
inline bool copy_file(const path& _Oldpval, const path& _Newpval,
|
|
error_code& _Code) noexcept { // copy _Oldpval to _Newpval
|
|
return copy_file(_Oldpval, _Newpval, copy_options::none, _Code);
|
|
}
|
|
|
|
inline bool copy_file(const path& _Oldpval, const path& _Newpval, copy_options _Opt,
|
|
error_code& _Code) noexcept { // copy _Oldpval to _Newpval
|
|
_Opt &= (copy_options::skip_existing | copy_options::overwrite_existing | copy_options::update_existing);
|
|
const bool _Exists = exists(_Newpval);
|
|
file_time_type _Oldtime;
|
|
file_time_type _Newtime;
|
|
|
|
_Code.clear();
|
|
if (_Exists && (_Opt == copy_options::none || equivalent(_Oldpval, _Newpval, _Code))) {
|
|
_Code = make_error_code(errc::file_exists);
|
|
return false;
|
|
}
|
|
|
|
if (_Code) { // equivalent() failed, report error
|
|
return false;
|
|
}
|
|
|
|
if (!_Exists || (_Opt & copy_options::overwrite_existing) != copy_options::none
|
|
|| ((_Opt & copy_options::update_existing) != copy_options::none
|
|
&& ((void) (_Oldtime = last_write_time(_Oldpval, _Code)), !_Code)
|
|
&& ((void) (_Newtime = last_write_time(_Newpval, _Code)), !_Code)
|
|
&& _Newtime < _Oldtime)) { // ok to overwrite, if necessary
|
|
if (_Copy_file(_Oldpval.c_str(), _Newpval.c_str()) == 0) {
|
|
return true;
|
|
}
|
|
|
|
_Code = make_error_code(errc::operation_not_permitted);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
inline void copy_symlink(const path& _Oldpval, const path& _Newpval) { // copy symlink, file or directory
|
|
error_code _Code;
|
|
copy_symlink(_Oldpval, _Newpval, _Code);
|
|
if (_Code) {
|
|
_Throw_filesystem_error("copy_symlink(p1, p2): invalid arguments");
|
|
}
|
|
}
|
|
|
|
inline void copy_symlink(const path& _Oldpval, const path& _Newpval,
|
|
error_code& _Code) noexcept { // copy symlink, file or directory
|
|
if (is_directory(_Oldpval)) {
|
|
create_directory_symlink(_Oldpval, _Newpval, _Code);
|
|
} else {
|
|
create_symlink(_Oldpval, _Newpval, _Code);
|
|
}
|
|
}
|
|
|
|
inline bool create_directories(const path& _Path) { // create directories chain
|
|
error_code _Code;
|
|
const bool _Ans = create_directories(_Path, _Code);
|
|
if (_Code) {
|
|
_Throw_filesystem_error("create_directories(p): invalid argument");
|
|
}
|
|
|
|
return _Ans;
|
|
}
|
|
|
|
inline bool create_directories(const path& _Path,
|
|
error_code& _Code) noexcept { // create directory chain
|
|
_Code.clear();
|
|
if (_Path.empty()) {
|
|
return false;
|
|
} else if (!exists(_Path)) { // recursively create parent directories, then current
|
|
create_directories(_Path.parent_path(), _Code);
|
|
if (_Code) {
|
|
return false; // report error
|
|
}
|
|
|
|
create_directory(_Path, _Code);
|
|
if (_Code) {
|
|
return false; // report error
|
|
}
|
|
|
|
return true;
|
|
} else if (is_directory(_Path)) {
|
|
return false; // directory already there
|
|
} else { // report bad argument
|
|
_Code = make_error_code(errc::operation_not_permitted);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
inline bool create_directory(const path& _Path) { // create a directory
|
|
error_code _Code;
|
|
const bool _Ans = create_directory(_Path, _Code);
|
|
|
|
if (_Code) {
|
|
_Throw_filesystem_error("create_directory(p): invalid argument");
|
|
}
|
|
|
|
return _Ans;
|
|
}
|
|
|
|
inline bool create_directory(const path& _Path,
|
|
error_code& _Code) noexcept { // create a directory
|
|
const int _Ans = _Make_dir(_Path.c_str(), nullptr);
|
|
|
|
_Code.clear();
|
|
if (_Ans < 0) {
|
|
_Code = make_error_code(errc::operation_not_permitted);
|
|
}
|
|
|
|
return 0 < _Ans;
|
|
}
|
|
|
|
inline bool create_directory(const path& _Path, const path& _Attrs) { // create a directory, copying attributes
|
|
error_code _Code;
|
|
const bool _Ans = create_directory(_Path, _Attrs, _Code);
|
|
|
|
if (_Code) {
|
|
_Throw_filesystem_error("create_directory(p1, p2): invalid arguments");
|
|
}
|
|
|
|
return _Ans;
|
|
}
|
|
|
|
inline bool create_directory(const path& _Path, const path& _Attrs,
|
|
error_code& _Code) noexcept { // create a directory, copying attributes
|
|
const int _Ans = _Make_dir(_Path.c_str(), _Attrs.c_str());
|
|
|
|
_Code.clear();
|
|
if (_Ans < 0) {
|
|
_Code = make_error_code(errc::operation_not_permitted);
|
|
}
|
|
|
|
return 0 < _Ans;
|
|
}
|
|
|
|
inline void create_directory_symlink(const path& _Oldpval,
|
|
const path& _Newpval) { // symlink directory _Newpval to _Oldpval
|
|
error_code _Code;
|
|
create_directory_symlink(_Oldpval, _Newpval, _Code);
|
|
if (_Code) {
|
|
_Throw_filesystem_error("create_directory_symlink(p1, p2): invalid arguments");
|
|
}
|
|
}
|
|
|
|
inline void create_directory_symlink(const path& _Oldpval, const path& _Newpval,
|
|
error_code& _Code) noexcept { // symlink directory_Newpval to _Oldpval (NB: SAME AS FILE)
|
|
const int _Ans = _Symlink(_Oldpval.c_str(), _Newpval.c_str());
|
|
|
|
_Code.clear();
|
|
if (_Ans != 0) {
|
|
_Code = error_code(_Ans, _STD system_category());
|
|
}
|
|
}
|
|
|
|
inline void create_hard_link(const path& _Oldpval, const path& _Newpval) { // hard link _Newpval to _Oldpval
|
|
error_code _Code;
|
|
create_hard_link(_Oldpval, _Newpval, _Code);
|
|
if (_Code) {
|
|
_Throw_filesystem_error("create_hard_link(p1, p2): invalid arguments");
|
|
}
|
|
}
|
|
|
|
inline void create_hard_link(const path& _Oldpval, const path& _Newpval,
|
|
error_code& _Code) noexcept { // hard link _Newpval to _Oldpval
|
|
const int _Ans = _Link(_Oldpval.c_str(), _Newpval.c_str());
|
|
|
|
_Code.clear();
|
|
if (_Ans != 0) {
|
|
_Code = error_code(_Ans, _STD system_category());
|
|
}
|
|
}
|
|
|
|
inline void create_symlink(const path& _Oldpval, const path& _Newpval) { // symlink _Newpval to _Oldpval
|
|
error_code _Code;
|
|
create_symlink(_Oldpval, _Newpval, _Code);
|
|
if (_Code) {
|
|
_Throw_filesystem_error("create_symlink(p1, p2): invalid arguments");
|
|
}
|
|
}
|
|
|
|
inline void create_symlink(const path& _Oldpval, const path& _Newpval,
|
|
error_code& _Code) noexcept { // symlink _Newpval to _Oldpval
|
|
const int _Ans = _Symlink(_Oldpval.c_str(), _Newpval.c_str());
|
|
|
|
_Code.clear();
|
|
if (_Ans != 0) {
|
|
_Code = error_code(_Ans, _STD system_category());
|
|
}
|
|
}
|
|
|
|
_NODISCARD inline path current_path() {
|
|
error_code _Code;
|
|
path _Ans = current_path(_Code);
|
|
if (_Code) {
|
|
_Throw_filesystem_error("current_path(): can't get current working directory");
|
|
}
|
|
|
|
return _Ans;
|
|
}
|
|
|
|
_NODISCARD inline path current_path(error_code& _Code) {
|
|
_Code.clear();
|
|
_Pchar _Dest[_MAX_FILESYS_NAME];
|
|
if (!_Current_get(_Dest)) { // report error
|
|
_Code = make_error_code(errc::operation_not_permitted);
|
|
return {};
|
|
}
|
|
return path{_Dest};
|
|
}
|
|
|
|
inline void current_path(const path& _Path) { // set current working directory
|
|
if (!_Current_set(_Path.c_str())) {
|
|
_Throw_filesystem_error("current_path(p): invalid argument");
|
|
}
|
|
}
|
|
|
|
inline void current_path(const path& _Path,
|
|
error_code& _Code) noexcept { // set current working directory
|
|
_Code.clear();
|
|
if (!_Current_set(_Path.c_str())) {
|
|
_Code = make_error_code(errc::no_such_file_or_directory);
|
|
}
|
|
}
|
|
|
|
_NODISCARD inline bool equivalent(const path& _Path1, const path& _Path2) {
|
|
error_code _Code;
|
|
const int _Ans = equivalent(_Path1, _Path2, _Code);
|
|
|
|
if (_Code) {
|
|
_Throw_filesystem_error("equivalent(p1, p2): invalid arguments");
|
|
}
|
|
|
|
return 0 < _Ans;
|
|
}
|
|
|
|
_NODISCARD inline bool equivalent(const path& _Path1, const path& _Path2, error_code& _Code) noexcept {
|
|
const int _Ans = _Equivalent(_Path1.c_str(), _Path2.c_str());
|
|
|
|
_Code.clear();
|
|
if (_Ans < 0) {
|
|
_Code = make_error_code(errc::operation_not_permitted);
|
|
}
|
|
|
|
return 0 < _Ans;
|
|
}
|
|
|
|
_NODISCARD inline bool exists(file_status _Stat) noexcept {
|
|
return status_known(_Stat) && _Stat.type() != file_type::not_found;
|
|
}
|
|
|
|
_NODISCARD inline bool exists(const path& _Path) {
|
|
return exists(status(_Path));
|
|
}
|
|
|
|
_NODISCARD inline bool exists(const path& _Path, error_code& _Code) noexcept {
|
|
_Code.clear();
|
|
return exists(status(_Path));
|
|
}
|
|
|
|
_NODISCARD inline uintmax_t file_size(const path& _Path) {
|
|
error_code _Code;
|
|
const uintmax_t _Ans = file_size(_Path, _Code);
|
|
if (_Code) {
|
|
_Throw_filesystem_error("file_size(p): invalid argument");
|
|
}
|
|
|
|
return _Ans;
|
|
}
|
|
|
|
_NODISCARD inline uintmax_t file_size(const path& _Path, error_code& _Code) noexcept {
|
|
uintmax_t _Ans = static_cast<uintmax_t>(-1);
|
|
const file_status _Stat = status(_Path);
|
|
|
|
_Code.clear();
|
|
if (exists(_Stat) && is_regular_file(_Stat)) {
|
|
_Ans = _File_size(_Path.c_str());
|
|
}
|
|
|
|
if (_Ans == static_cast<uintmax_t>(-1)) {
|
|
_Code = make_error_code(errc::operation_not_permitted);
|
|
}
|
|
|
|
return _Ans;
|
|
}
|
|
|
|
_NODISCARD inline uintmax_t hard_link_count(const path& _Path) {
|
|
error_code _Code;
|
|
const uintmax_t _Ans = hard_link_count(_Path, _Code);
|
|
if (_Code) {
|
|
_Throw_filesystem_error("hard_link_count(p): invalid argument");
|
|
}
|
|
|
|
return _Ans;
|
|
}
|
|
|
|
_NODISCARD inline uintmax_t hard_link_count(const path& _Path, error_code& _Code) noexcept {
|
|
_Code.clear();
|
|
const uintmax_t _Ans = _Hard_links(_Path.c_str());
|
|
if (_Ans == static_cast<uintmax_t>(-1)) {
|
|
_Code = make_error_code(errc::operation_not_permitted);
|
|
}
|
|
|
|
return _Ans;
|
|
}
|
|
|
|
_NODISCARD inline bool is_block_file(file_status _Stat) noexcept {
|
|
return _Stat.type() == file_type::block;
|
|
}
|
|
|
|
_NODISCARD inline bool is_block_file(const path& _Path) {
|
|
return is_block_file(status(_Path));
|
|
}
|
|
|
|
_NODISCARD inline bool is_block_file(const path& _Path, error_code& _Code) noexcept {
|
|
return is_block_file(status(_Path, _Code));
|
|
}
|
|
|
|
_NODISCARD inline bool is_character_file(file_status _Stat) noexcept {
|
|
return _Stat.type() == file_type::character;
|
|
}
|
|
|
|
_NODISCARD inline bool is_character_file(const path& _Path) {
|
|
return is_character_file(status(_Path));
|
|
}
|
|
|
|
_NODISCARD inline bool is_character_file(const path& _Path, error_code& _Code) noexcept {
|
|
return is_character_file(status(_Path, _Code));
|
|
}
|
|
|
|
_NODISCARD inline bool is_directory(file_status _Stat) noexcept {
|
|
return _Stat.type() == file_type::directory;
|
|
}
|
|
|
|
_NODISCARD inline bool is_directory(const path& _Path) {
|
|
return is_directory(status(_Path));
|
|
}
|
|
|
|
_NODISCARD inline bool is_directory(const path& _Path, error_code& _Code) noexcept {
|
|
return is_directory(status(_Path, _Code));
|
|
}
|
|
|
|
_NODISCARD inline bool is_empty(const path& _Path) {
|
|
error_code _Code;
|
|
const bool _Ans = _FSPFX is_empty(_Path, _Code);
|
|
if (_Code) {
|
|
_Throw_filesystem_error("is_empty(p): invalid argument");
|
|
}
|
|
|
|
return _Ans;
|
|
}
|
|
|
|
_NODISCARD inline bool is_empty(const path& _Path, error_code& _Code) noexcept {
|
|
const file_status _Stat = status(_Path);
|
|
|
|
_Code.clear();
|
|
if (is_directory(_Stat)) {
|
|
return directory_iterator(_Path) == directory_iterator();
|
|
} else {
|
|
return file_size(_Path, _Code) == 0;
|
|
}
|
|
}
|
|
|
|
_NODISCARD inline bool is_fifo(file_status _Stat) noexcept {
|
|
return _Stat.type() == file_type::fifo;
|
|
}
|
|
|
|
_NODISCARD inline bool is_fifo(const path& _Path) {
|
|
return is_fifo(status(_Path));
|
|
}
|
|
|
|
_NODISCARD inline bool is_fifo(const path& _Path, error_code& _Code) noexcept {
|
|
return is_fifo(status(_Path, _Code));
|
|
}
|
|
|
|
_NODISCARD inline bool is_other(file_status _Stat) noexcept {
|
|
return exists(_Stat) && !is_regular_file(_Stat) && !is_directory(_Stat) && !is_symlink(_Stat);
|
|
}
|
|
|
|
_NODISCARD inline bool is_other(const path& _Path) {
|
|
return is_other(status(_Path));
|
|
}
|
|
|
|
_NODISCARD inline bool is_other(const path& _Path, error_code& _Code) noexcept {
|
|
return is_other(status(_Path, _Code));
|
|
}
|
|
|
|
_NODISCARD inline bool is_regular_file(file_status _Stat) noexcept {
|
|
return _Stat.type() == file_type::regular;
|
|
}
|
|
|
|
_NODISCARD inline bool is_regular_file(const path& _Path) {
|
|
return is_regular_file(status(_Path));
|
|
}
|
|
|
|
_NODISCARD inline bool is_regular_file(const path& _Path, error_code& _Code) noexcept {
|
|
return is_regular_file(status(_Path, _Code));
|
|
}
|
|
|
|
_NODISCARD inline bool is_socket(file_status _Stat) noexcept {
|
|
return _Stat.type() == file_type::socket;
|
|
}
|
|
|
|
_NODISCARD inline bool is_socket(const path& _Path) {
|
|
return is_socket(status(_Path));
|
|
}
|
|
|
|
_NODISCARD inline bool is_socket(const path& _Path, error_code& _Code) noexcept {
|
|
return is_socket(status(_Path, _Code));
|
|
}
|
|
|
|
_NODISCARD inline bool is_symlink(file_status _Stat) noexcept {
|
|
return _Stat.type() == file_type::symlink;
|
|
}
|
|
|
|
_NODISCARD inline bool is_symlink(const path& _Path) {
|
|
return is_symlink(status(_Path));
|
|
}
|
|
|
|
_NODISCARD inline bool is_symlink(const path& _Path, error_code& _Code) noexcept {
|
|
return is_symlink(status(_Path, _Code));
|
|
}
|
|
|
|
_NODISCARD inline file_time_type last_write_time(const path& _Path) {
|
|
error_code _Code;
|
|
file_time_type _Ans = last_write_time(_Path, _Code);
|
|
if (_Code) {
|
|
_Throw_filesystem_error("last_write_time(p): invalid argument");
|
|
}
|
|
|
|
return _Ans;
|
|
}
|
|
|
|
_NODISCARD inline file_time_type last_write_time(const path& _Path, error_code& _Code) noexcept {
|
|
const int64_t _Ticks = _Last_write_time(_Path.c_str());
|
|
|
|
_Code.clear();
|
|
if (_Ticks == -1) { // report error
|
|
_Code = make_error_code(errc::operation_not_permitted);
|
|
return (file_time_type::min)();
|
|
}
|
|
return file_time_type(chrono::system_clock::duration(_Ticks));
|
|
}
|
|
|
|
inline void last_write_time(const path& _Path, file_time_type _Newtime) { // set last write time
|
|
error_code _Code;
|
|
last_write_time(_Path, _Newtime, _Code);
|
|
if (_Code) {
|
|
_Throw_filesystem_error("last_write_time(p, new_time): invalid arguments");
|
|
}
|
|
}
|
|
|
|
inline void last_write_time(const path& _Path, file_time_type _Newtime,
|
|
error_code& _Code) noexcept { // set last write time
|
|
_Code.clear();
|
|
if (_Set_last_write_time(_Path.c_str(), _Newtime.time_since_epoch().count()) == 0) {
|
|
_Code = make_error_code(errc::operation_not_permitted);
|
|
}
|
|
}
|
|
|
|
inline void permissions(const path& _Path, perms _Mask) { // set access permissions
|
|
error_code _Code;
|
|
permissions(_Path, _Mask, _Code);
|
|
if (_Code) {
|
|
_Throw_filesystem_error("permissions(p, prms): can't set permissions");
|
|
}
|
|
}
|
|
|
|
inline void permissions(const path& _Path, perms _Mask,
|
|
error_code& _Code) { // set access permissions
|
|
const perms _Todo = _Mask;
|
|
_Mask = _Mask & perms::mask;
|
|
bool _Ok = true;
|
|
|
|
_Code.clear();
|
|
if ((_Todo & perms::add_perms) == perms::none) {
|
|
if ((_Todo & perms::remove_perms) != perms::none) {
|
|
_Mask = status(_Path).permissions() & ~_Mask;
|
|
}
|
|
} else {
|
|
if ((_Todo & perms::remove_perms) == perms::none) {
|
|
_Mask = _Mask | status(_Path).permissions();
|
|
} else {
|
|
_Ok = false;
|
|
}
|
|
}
|
|
|
|
if (!_Ok || _Chmod(_Path.c_str(), _Mask) != 0) {
|
|
_Code = make_error_code(errc::operation_not_permitted);
|
|
}
|
|
}
|
|
|
|
_NODISCARD inline path read_symlink(const path& _Path) { // read symbolic link
|
|
error_code _Code;
|
|
path _Sympath = read_symlink(_Path, _Code);
|
|
if (_Code) {
|
|
_Throw_filesystem_error("read_symlink(p): can't read symbolic link");
|
|
}
|
|
|
|
return _Sympath;
|
|
}
|
|
|
|
_NODISCARD inline path read_symlink(const path& _Path,
|
|
error_code& _Code) { // read symbolic link
|
|
_Code.clear();
|
|
if (!is_symlink(_Path)) { // report error
|
|
_Code = make_error_code(errc::no_such_file_or_directory);
|
|
return {};
|
|
}
|
|
_Pchar _Dest[_MAX_FILESYS_NAME];
|
|
return path{_Symlink_get(_Dest, _Path.c_str())};
|
|
}
|
|
|
|
inline bool remove(const path& _Path) { // remove a file
|
|
error_code _Code;
|
|
const bool _Ans = remove(_Path, _Code);
|
|
|
|
if (_Code) {
|
|
_Throw_filesystem_error("remove(p): invalid argument");
|
|
}
|
|
|
|
return _Ans;
|
|
}
|
|
|
|
inline bool remove(const path& _Path,
|
|
error_code& _Code) noexcept { // remove a file
|
|
_Code.clear();
|
|
if (!exists(symlink_status(_Path))) {
|
|
return false;
|
|
} else if (is_directory(_Path, _Code)) {
|
|
if (_Remove_dir(_Path.c_str())) {
|
|
return true;
|
|
} else { // couldn't remove emptied directory, report it
|
|
_Code = make_error_code(errc::operation_not_permitted);
|
|
return false;
|
|
}
|
|
} else { // file exists, try to remove it
|
|
const bool _Ans = _Unlink(_Path.c_str()) == 0;
|
|
if (!_Ans) {
|
|
_Code = make_error_code(errc::operation_not_permitted);
|
|
}
|
|
|
|
return _Ans;
|
|
}
|
|
}
|
|
|
|
inline bool _Remove_all(const path& _Path, uintmax_t& _Ans,
|
|
error_code& _Code) noexcept { // recursively remove a file or directory, count removed files
|
|
_Code.clear();
|
|
if (is_directory(_Path)) { // empty and remove a directory
|
|
using _Myit = _Directory_iterator<false_type>;
|
|
_Myit _Last;
|
|
|
|
for (;;) { // remove a directory entry
|
|
_Myit _First(_Path);
|
|
if (_First == _Last) {
|
|
break;
|
|
}
|
|
|
|
if (!_Remove_all(_Path / _First->path(), _Ans, _Code)) {
|
|
return false;
|
|
}
|
|
}
|
|
if (_Remove_dir(_Path.c_str())) {
|
|
return true;
|
|
} else { // couldn't remove emptied directory, report it
|
|
_Code = make_error_code(errc::operation_not_permitted);
|
|
return false;
|
|
}
|
|
} else if (!remove(_Path, _Code)) {
|
|
return false;
|
|
} else { // file remove succeeded, count it
|
|
++_Ans;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
inline uintmax_t remove_all(const path& _Path) { // recursively remove a directory
|
|
error_code _Code;
|
|
const uintmax_t _Ans = remove_all(_Path, _Code);
|
|
if (_Code) {
|
|
_Throw_filesystem_error("remove_all(p): invalid argument");
|
|
}
|
|
|
|
return _Ans;
|
|
}
|
|
|
|
inline uintmax_t remove_all(const path& _Path,
|
|
error_code& _Code) noexcept { // recursively remove a directory
|
|
uintmax_t _Ans = 0;
|
|
_Remove_all(_Path, _Ans, _Code);
|
|
if (_Code) {
|
|
return static_cast<uintmax_t>(-1);
|
|
}
|
|
|
|
return _Ans;
|
|
}
|
|
|
|
inline void rename(const path& _Oldpval, const path& _Newpval) { // rename _Oldpval as _Newpval
|
|
error_code _Code;
|
|
rename(_Oldpval, _Newpval, _Code);
|
|
if (_Code) {
|
|
_Throw_filesystem_error("rename(p1, p2): invalid arguments");
|
|
}
|
|
}
|
|
|
|
inline void rename(const path& _Oldpval, const path& _Newpval,
|
|
error_code& _Code) noexcept { // rename _Oldpval as _Newpval
|
|
_Code.clear();
|
|
|
|
if (!exists(_Oldpval)) { // fail immediately without modifying the filesystem
|
|
_Code = make_error_code(errc::operation_not_permitted);
|
|
return;
|
|
}
|
|
|
|
if (exists(_Newpval)) { // both exist; there can be only one
|
|
if (equivalent(_Oldpval, _Newpval, _Code) || _Code) {
|
|
return; // successful no-op, or report equivalent() failure
|
|
}
|
|
|
|
if (!remove(_Newpval, _Code)) {
|
|
return; // report remove() failure
|
|
}
|
|
}
|
|
|
|
if (_Rename(_Oldpval.c_str(), _Newpval.c_str()) != 0) {
|
|
_Code = make_error_code(errc::operation_not_permitted);
|
|
}
|
|
}
|
|
|
|
inline void resize_file(const path& _Path, uintmax_t _Newsize) { // change file size
|
|
error_code _Code;
|
|
resize_file(_Path, _Newsize, _Code);
|
|
if (_Code) {
|
|
_Throw_filesystem_error("resize_file(p, n): invalid arguments");
|
|
}
|
|
}
|
|
|
|
inline void resize_file(const path& _Path, uintmax_t _Newsize,
|
|
error_code& _Code) noexcept { // change file size
|
|
const int _Errno = _Resize(_Path.c_str(), _Newsize);
|
|
|
|
_Code.clear();
|
|
if (_Errno != 0) {
|
|
_Code = error_code(_Errno, _STD system_category());
|
|
}
|
|
}
|
|
|
|
_NODISCARD inline space_info space(const path& _Path) {
|
|
return _Statvfs(_Path.c_str());
|
|
}
|
|
|
|
_NODISCARD inline space_info space(const path& _Path, error_code& _Code) noexcept {
|
|
_Code.clear();
|
|
return _Statvfs(_Path.c_str());
|
|
}
|
|
|
|
_NODISCARD inline file_status status(const path& _Path) {
|
|
error_code _Code;
|
|
return status(_Path, _Code);
|
|
}
|
|
|
|
_NODISCARD inline file_status status(const path& _Path, error_code& _Code) noexcept {
|
|
_Code.clear();
|
|
perms _Mode;
|
|
const file_type _Ftype = _Stat(_Path.c_str(), &_Mode);
|
|
return file_status{_Ftype, _Mode};
|
|
}
|
|
|
|
_NODISCARD inline bool status_known(file_status _Stat) noexcept {
|
|
return _Stat.type() != file_type::unknown;
|
|
}
|
|
|
|
_NODISCARD inline file_status symlink_status(const path& _Path) {
|
|
error_code _Code;
|
|
return symlink_status(_Path, _Code);
|
|
}
|
|
|
|
_NODISCARD inline file_status symlink_status(const path& _Path, error_code& _Code) noexcept {
|
|
perms _Mode;
|
|
const file_type _Ftype = _Lstat(_Path.c_str(), &_Mode);
|
|
|
|
_Code.clear();
|
|
return file_status{_Ftype, _Mode};
|
|
}
|
|
|
|
_NODISCARD inline path system_complete(const path& _Path) {
|
|
if (_Path.is_absolute()) {
|
|
return _Path;
|
|
}
|
|
|
|
path _Curpath = current_path();
|
|
if (!_Path.has_root_name() || _Path.root_name() == _Curpath.root_name()) {
|
|
return absolute(_Path);
|
|
}
|
|
|
|
current_path(_Path.root_name()); // switch to new device
|
|
path _Altpath = current_path(); // get its full current path
|
|
current_path(_Curpath); // revert to original current path
|
|
return _Altpath / _Path.relative_path();
|
|
}
|
|
|
|
_NODISCARD inline path system_complete(const path& _Path, error_code& _Code) {
|
|
_Code.clear();
|
|
|
|
path _Ans;
|
|
|
|
_TRY_BEGIN
|
|
_Ans = system_complete(_Path);
|
|
_CATCH_ALL
|
|
_Code = make_error_code(errc::operation_not_permitted);
|
|
return {};
|
|
_CATCH_END
|
|
|
|
return _Ans;
|
|
}
|
|
|
|
_NODISCARD inline path temp_directory_path() {
|
|
error_code _Code;
|
|
path _Ans = temp_directory_path(_Code);
|
|
if (_Code) {
|
|
_Throw_filesystem_error("temp_directory_path(): can't find temp directory");
|
|
}
|
|
|
|
return _Ans;
|
|
}
|
|
|
|
_NODISCARD inline path temp_directory_path(error_code& _Code) {
|
|
_Pchar _Dest[_MAX_FILESYS_NAME];
|
|
_Temp_get(_Dest);
|
|
path _Ans(_Dest);
|
|
|
|
_Code.clear();
|
|
if (!exists(_Ans) || !is_directory(_Ans)) { // report error
|
|
_Code = make_error_code(errc::no_such_file_or_directory);
|
|
return {};
|
|
}
|
|
return _Ans;
|
|
}
|
|
_FS_END
|
|
|
|
#pragma pop_macro("new")
|
|
_STL_RESTORE_CLANG_WARNINGS
|
|
#pragma warning(pop)
|
|
#pragma pack(pop)
|
|
|
|
#endif // _STL_COMPILER_PREPROCESSOR
|
|
#endif // _EXPERIMENTAL_FILESYSTEM_
|