mirror of
https://github.com/capstone-engine/llvm-capstone.git
synced 2024-11-23 22:00:10 +00:00
[libc++][NFC] Granularize <filesystem>
Granularize the `<filesystem>` header Reviewed By: Quuxplusone, ldionne, #libc Spies: libcxx-commits, mgorny Differential Revision: https://reviews.llvm.org/D115578
This commit is contained in:
Nikolas Klauser
parent
1fe897dffd
commit
7056250f51
@ -141,6 +141,22 @@ set(files
|
||||
__coroutine/trivial_awaitables.h
|
||||
__debug
|
||||
__errc
|
||||
__filesystem/copy_options.h
|
||||
__filesystem/directory_entry.h
|
||||
__filesystem/directory_iterator.h
|
||||
__filesystem/directory_options.h
|
||||
__filesystem/file_status.h
|
||||
__filesystem/file_time_type.h
|
||||
__filesystem/file_type.h
|
||||
__filesystem/filesystem_error.h
|
||||
__filesystem/operations.h
|
||||
__filesystem/path_iterator.h
|
||||
__filesystem/path.h
|
||||
__filesystem/perm_options.h
|
||||
__filesystem/perms.h
|
||||
__filesystem/recursive_directory_iterator.h
|
||||
__filesystem/space_info.h
|
||||
__filesystem/u8path.h
|
||||
__format/format_arg.h
|
||||
__format/format_args.h
|
||||
__format/format_context.h
|
||||
|
||||
80
libcxx/include/__filesystem/copy_options.h
Normal file
80
libcxx/include/__filesystem/copy_options.h
Normal file
@ -0,0 +1,80 @@
|
||||
// -*- C++ -*-
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef _LIBCPP___FILESYSTEM_COPY_OPTIONS_H
|
||||
#define _LIBCPP___FILESYSTEM_COPY_OPTIONS_H
|
||||
|
||||
#include <__availability>
|
||||
#include <__config>
|
||||
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
|
||||
|
||||
_LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
|
||||
|
||||
enum class _LIBCPP_ENUM_VIS copy_options : unsigned short {
|
||||
none = 0,
|
||||
skip_existing = 1,
|
||||
overwrite_existing = 2,
|
||||
update_existing = 4,
|
||||
recursive = 8,
|
||||
copy_symlinks = 16,
|
||||
skip_symlinks = 32,
|
||||
directories_only = 64,
|
||||
create_symlinks = 128,
|
||||
create_hard_links = 256,
|
||||
__in_recursive_copy = 512,
|
||||
};
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
inline constexpr copy_options operator&(copy_options _LHS, copy_options _RHS) {
|
||||
return static_cast<copy_options>(static_cast<unsigned short>(_LHS) &
|
||||
static_cast<unsigned short>(_RHS));
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
inline constexpr copy_options operator|(copy_options _LHS, copy_options _RHS) {
|
||||
return static_cast<copy_options>(static_cast<unsigned short>(_LHS) |
|
||||
static_cast<unsigned short>(_RHS));
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
inline constexpr copy_options operator^(copy_options _LHS, copy_options _RHS) {
|
||||
return static_cast<copy_options>(static_cast<unsigned short>(_LHS) ^
|
||||
static_cast<unsigned short>(_RHS));
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
inline constexpr copy_options operator~(copy_options _LHS) {
|
||||
return static_cast<copy_options>(~static_cast<unsigned short>(_LHS));
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
inline copy_options& operator&=(copy_options& _LHS, copy_options _RHS) {
|
||||
return _LHS = _LHS & _RHS;
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
inline copy_options& operator|=(copy_options& _LHS, copy_options _RHS) {
|
||||
return _LHS = _LHS | _RHS;
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
inline copy_options& operator^=(copy_options& _LHS, copy_options _RHS) {
|
||||
return _LHS = _LHS ^ _RHS;
|
||||
}
|
||||
|
||||
_LIBCPP_AVAILABILITY_FILESYSTEM_POP
|
||||
|
||||
_LIBCPP_END_NAMESPACE_FILESYSTEM
|
||||
|
||||
#endif // _LIBCPP_CXX03_LANG
|
||||
|
||||
#endif // _LIBCPP___FILESYSTEM_COPY_OPTIONS_H
|
||||
504
libcxx/include/__filesystem/directory_entry.h
Normal file
504
libcxx/include/__filesystem/directory_entry.h
Normal file
@ -0,0 +1,504 @@
|
||||
// -*- C++ -*-
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef _LIBCPP___FILESYSTEM_DIRECTORY_ENTRY_H
|
||||
#define _LIBCPP___FILESYSTEM_DIRECTORY_ENTRY_H
|
||||
|
||||
#include <__availability>
|
||||
#include <__config>
|
||||
#include <__filesystem/path.h>
|
||||
#include <__filesystem/file_time_type.h>
|
||||
#include <__filesystem/filesystem_error.h>
|
||||
#include <__filesystem/file_status.h>
|
||||
#include <__filesystem/file_type.h>
|
||||
#include <__filesystem/operations.h>
|
||||
#include <__filesystem/perms.h>
|
||||
#include <__errc>
|
||||
#include <chrono>
|
||||
#include <cstdint>
|
||||
#include <cstdlib>
|
||||
#include <system_error>
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
|
||||
|
||||
_LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
|
||||
|
||||
|
||||
class directory_entry {
|
||||
typedef _VSTD_FS::path _Path;
|
||||
|
||||
public:
|
||||
// constructors and destructors
|
||||
directory_entry() noexcept = default;
|
||||
directory_entry(directory_entry const&) = default;
|
||||
directory_entry(directory_entry&&) noexcept = default;
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
explicit directory_entry(_Path const& __p) : __p_(__p) {
|
||||
error_code __ec;
|
||||
__refresh(&__ec);
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
directory_entry(_Path const& __p, error_code& __ec) : __p_(__p) {
|
||||
__refresh(&__ec);
|
||||
}
|
||||
|
||||
~directory_entry() {}
|
||||
|
||||
directory_entry& operator=(directory_entry const&) = default;
|
||||
directory_entry& operator=(directory_entry&&) noexcept = default;
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void assign(_Path const& __p) {
|
||||
__p_ = __p;
|
||||
error_code __ec;
|
||||
__refresh(&__ec);
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void assign(_Path const& __p, error_code& __ec) {
|
||||
__p_ = __p;
|
||||
__refresh(&__ec);
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void replace_filename(_Path const& __p) {
|
||||
__p_.replace_filename(__p);
|
||||
error_code __ec;
|
||||
__refresh(&__ec);
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void replace_filename(_Path const& __p, error_code& __ec) {
|
||||
__p_ = __p_.parent_path() / __p;
|
||||
__refresh(&__ec);
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void refresh() { __refresh(); }
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void refresh(error_code& __ec) noexcept { __refresh(&__ec); }
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
_Path const& path() const noexcept { return __p_; }
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
operator const _Path&() const noexcept { return __p_; }
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool exists() const { return _VSTD_FS::exists(file_status{__get_ft()}); }
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool exists(error_code& __ec) const noexcept {
|
||||
return _VSTD_FS::exists(file_status{__get_ft(&__ec)});
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool is_block_file() const { return __get_ft() == file_type::block; }
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool is_block_file(error_code& __ec) const noexcept {
|
||||
return __get_ft(&__ec) == file_type::block;
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool is_character_file() const { return __get_ft() == file_type::character; }
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool is_character_file(error_code& __ec) const noexcept {
|
||||
return __get_ft(&__ec) == file_type::character;
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool is_directory() const { return __get_ft() == file_type::directory; }
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool is_directory(error_code& __ec) const noexcept {
|
||||
return __get_ft(&__ec) == file_type::directory;
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool is_fifo() const { return __get_ft() == file_type::fifo; }
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool is_fifo(error_code& __ec) const noexcept {
|
||||
return __get_ft(&__ec) == file_type::fifo;
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool is_other() const { return _VSTD_FS::is_other(file_status{__get_ft()}); }
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool is_other(error_code& __ec) const noexcept {
|
||||
return _VSTD_FS::is_other(file_status{__get_ft(&__ec)});
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool is_regular_file() const { return __get_ft() == file_type::regular; }
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool is_regular_file(error_code& __ec) const noexcept {
|
||||
return __get_ft(&__ec) == file_type::regular;
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool is_socket() const { return __get_ft() == file_type::socket; }
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool is_socket(error_code& __ec) const noexcept {
|
||||
return __get_ft(&__ec) == file_type::socket;
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool is_symlink() const { return __get_sym_ft() == file_type::symlink; }
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool is_symlink(error_code& __ec) const noexcept {
|
||||
return __get_sym_ft(&__ec) == file_type::symlink;
|
||||
}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
uintmax_t file_size() const { return __get_size(); }
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
uintmax_t file_size(error_code& __ec) const noexcept {
|
||||
return __get_size(&__ec);
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
uintmax_t hard_link_count() const { return __get_nlink(); }
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
uintmax_t hard_link_count(error_code& __ec) const noexcept {
|
||||
return __get_nlink(&__ec);
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
file_time_type last_write_time() const { return __get_write_time(); }
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
file_time_type last_write_time(error_code& __ec) const noexcept {
|
||||
return __get_write_time(&__ec);
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
file_status status() const { return __get_status(); }
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
file_status status(error_code& __ec) const noexcept {
|
||||
return __get_status(&__ec);
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
file_status symlink_status() const { return __get_symlink_status(); }
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
file_status symlink_status(error_code& __ec) const noexcept {
|
||||
return __get_symlink_status(&__ec);
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool operator<(directory_entry const& __rhs) const noexcept {
|
||||
return __p_ < __rhs.__p_;
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool operator==(directory_entry const& __rhs) const noexcept {
|
||||
return __p_ == __rhs.__p_;
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool operator!=(directory_entry const& __rhs) const noexcept {
|
||||
return __p_ != __rhs.__p_;
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool operator<=(directory_entry const& __rhs) const noexcept {
|
||||
return __p_ <= __rhs.__p_;
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool operator>(directory_entry const& __rhs) const noexcept {
|
||||
return __p_ > __rhs.__p_;
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool operator>=(directory_entry const& __rhs) const noexcept {
|
||||
return __p_ >= __rhs.__p_;
|
||||
}
|
||||
|
||||
private:
|
||||
friend class directory_iterator;
|
||||
friend class recursive_directory_iterator;
|
||||
friend class __dir_stream;
|
||||
|
||||
enum _CacheType : unsigned char {
|
||||
_Empty,
|
||||
_IterSymlink,
|
||||
_IterNonSymlink,
|
||||
_RefreshSymlink,
|
||||
_RefreshSymlinkUnresolved,
|
||||
_RefreshNonSymlink
|
||||
};
|
||||
|
||||
struct __cached_data {
|
||||
uintmax_t __size_;
|
||||
uintmax_t __nlink_;
|
||||
file_time_type __write_time_;
|
||||
perms __sym_perms_;
|
||||
perms __non_sym_perms_;
|
||||
file_type __type_;
|
||||
_CacheType __cache_type_;
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
__cached_data() noexcept { __reset(); }
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void __reset() {
|
||||
__cache_type_ = _Empty;
|
||||
__type_ = file_type::none;
|
||||
__sym_perms_ = __non_sym_perms_ = perms::unknown;
|
||||
__size_ = __nlink_ = uintmax_t(-1);
|
||||
__write_time_ = file_time_type::min();
|
||||
}
|
||||
};
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static __cached_data __create_iter_result(file_type __ft) {
|
||||
__cached_data __data;
|
||||
__data.__type_ = __ft;
|
||||
__data.__cache_type_ = [&]() {
|
||||
switch (__ft) {
|
||||
case file_type::none:
|
||||
return _Empty;
|
||||
case file_type::symlink:
|
||||
return _IterSymlink;
|
||||
default:
|
||||
return _IterNonSymlink;
|
||||
}
|
||||
}();
|
||||
return __data;
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void __assign_iter_entry(_Path&& __p, __cached_data __dt) {
|
||||
__p_ = _VSTD::move(__p);
|
||||
__data_ = __dt;
|
||||
}
|
||||
|
||||
_LIBCPP_FUNC_VIS
|
||||
error_code __do_refresh() noexcept;
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static bool __is_dne_error(error_code const& __ec) {
|
||||
if (!__ec)
|
||||
return true;
|
||||
switch (static_cast<errc>(__ec.value())) {
|
||||
case errc::no_such_file_or_directory:
|
||||
case errc::not_a_directory:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void __handle_error(const char* __msg, error_code* __dest_ec,
|
||||
error_code const& __ec, bool __allow_dne = false) const {
|
||||
if (__dest_ec) {
|
||||
*__dest_ec = __ec;
|
||||
return;
|
||||
}
|
||||
if (__ec && (!__allow_dne || !__is_dne_error(__ec)))
|
||||
__throw_filesystem_error(__msg, __p_, __ec);
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void __refresh(error_code* __ec = nullptr) {
|
||||
__handle_error("in directory_entry::refresh", __ec, __do_refresh(),
|
||||
/*allow_dne*/ true);
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
file_type __get_sym_ft(error_code* __ec = nullptr) const {
|
||||
switch (__data_.__cache_type_) {
|
||||
case _Empty:
|
||||
return __symlink_status(__p_, __ec).type();
|
||||
case _IterSymlink:
|
||||
case _RefreshSymlink:
|
||||
case _RefreshSymlinkUnresolved:
|
||||
if (__ec)
|
||||
__ec->clear();
|
||||
return file_type::symlink;
|
||||
case _IterNonSymlink:
|
||||
case _RefreshNonSymlink:
|
||||
file_status __st(__data_.__type_);
|
||||
if (__ec && !_VSTD_FS::exists(__st))
|
||||
*__ec = make_error_code(errc::no_such_file_or_directory);
|
||||
else if (__ec)
|
||||
__ec->clear();
|
||||
return __data_.__type_;
|
||||
}
|
||||
_LIBCPP_UNREACHABLE();
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
file_type __get_ft(error_code* __ec = nullptr) const {
|
||||
switch (__data_.__cache_type_) {
|
||||
case _Empty:
|
||||
case _IterSymlink:
|
||||
case _RefreshSymlinkUnresolved:
|
||||
return __status(__p_, __ec).type();
|
||||
case _IterNonSymlink:
|
||||
case _RefreshNonSymlink:
|
||||
case _RefreshSymlink: {
|
||||
file_status __st(__data_.__type_);
|
||||
if (__ec && !_VSTD_FS::exists(__st))
|
||||
*__ec = make_error_code(errc::no_such_file_or_directory);
|
||||
else if (__ec)
|
||||
__ec->clear();
|
||||
return __data_.__type_;
|
||||
}
|
||||
}
|
||||
_LIBCPP_UNREACHABLE();
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
file_status __get_status(error_code* __ec = nullptr) const {
|
||||
switch (__data_.__cache_type_) {
|
||||
case _Empty:
|
||||
case _IterNonSymlink:
|
||||
case _IterSymlink:
|
||||
case _RefreshSymlinkUnresolved:
|
||||
return __status(__p_, __ec);
|
||||
case _RefreshNonSymlink:
|
||||
case _RefreshSymlink:
|
||||
return file_status(__get_ft(__ec), __data_.__non_sym_perms_);
|
||||
}
|
||||
_LIBCPP_UNREACHABLE();
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
file_status __get_symlink_status(error_code* __ec = nullptr) const {
|
||||
switch (__data_.__cache_type_) {
|
||||
case _Empty:
|
||||
case _IterNonSymlink:
|
||||
case _IterSymlink:
|
||||
return __symlink_status(__p_, __ec);
|
||||
case _RefreshNonSymlink:
|
||||
return file_status(__get_sym_ft(__ec), __data_.__non_sym_perms_);
|
||||
case _RefreshSymlink:
|
||||
case _RefreshSymlinkUnresolved:
|
||||
return file_status(__get_sym_ft(__ec), __data_.__sym_perms_);
|
||||
}
|
||||
_LIBCPP_UNREACHABLE();
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
uintmax_t __get_size(error_code* __ec = nullptr) const {
|
||||
switch (__data_.__cache_type_) {
|
||||
case _Empty:
|
||||
case _IterNonSymlink:
|
||||
case _IterSymlink:
|
||||
case _RefreshSymlinkUnresolved:
|
||||
return _VSTD_FS::__file_size(__p_, __ec);
|
||||
case _RefreshSymlink:
|
||||
case _RefreshNonSymlink: {
|
||||
error_code __m_ec;
|
||||
file_status __st(__get_ft(&__m_ec));
|
||||
__handle_error("in directory_entry::file_size", __ec, __m_ec);
|
||||
if (_VSTD_FS::exists(__st) && !_VSTD_FS::is_regular_file(__st)) {
|
||||
errc __err_kind = _VSTD_FS::is_directory(__st) ? errc::is_a_directory
|
||||
: errc::not_supported;
|
||||
__handle_error("in directory_entry::file_size", __ec,
|
||||
make_error_code(__err_kind));
|
||||
}
|
||||
return __data_.__size_;
|
||||
}
|
||||
}
|
||||
_LIBCPP_UNREACHABLE();
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
uintmax_t __get_nlink(error_code* __ec = nullptr) const {
|
||||
switch (__data_.__cache_type_) {
|
||||
case _Empty:
|
||||
case _IterNonSymlink:
|
||||
case _IterSymlink:
|
||||
case _RefreshSymlinkUnresolved:
|
||||
return _VSTD_FS::__hard_link_count(__p_, __ec);
|
||||
case _RefreshSymlink:
|
||||
case _RefreshNonSymlink: {
|
||||
error_code __m_ec;
|
||||
(void)__get_ft(&__m_ec);
|
||||
__handle_error("in directory_entry::hard_link_count", __ec, __m_ec);
|
||||
return __data_.__nlink_;
|
||||
}
|
||||
}
|
||||
_LIBCPP_UNREACHABLE();
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
file_time_type __get_write_time(error_code* __ec = nullptr) const {
|
||||
switch (__data_.__cache_type_) {
|
||||
case _Empty:
|
||||
case _IterNonSymlink:
|
||||
case _IterSymlink:
|
||||
case _RefreshSymlinkUnresolved:
|
||||
return _VSTD_FS::__last_write_time(__p_, __ec);
|
||||
case _RefreshSymlink:
|
||||
case _RefreshNonSymlink: {
|
||||
error_code __m_ec;
|
||||
file_status __st(__get_ft(&__m_ec));
|
||||
__handle_error("in directory_entry::last_write_time", __ec, __m_ec);
|
||||
if (_VSTD_FS::exists(__st) &&
|
||||
__data_.__write_time_ == file_time_type::min())
|
||||
__handle_error("in directory_entry::last_write_time", __ec,
|
||||
make_error_code(errc::value_too_large));
|
||||
return __data_.__write_time_;
|
||||
}
|
||||
}
|
||||
_LIBCPP_UNREACHABLE();
|
||||
}
|
||||
|
||||
private:
|
||||
_Path __p_;
|
||||
__cached_data __data_;
|
||||
};
|
||||
|
||||
class __dir_element_proxy {
|
||||
public:
|
||||
inline _LIBCPP_INLINE_VISIBILITY directory_entry operator*() {
|
||||
return _VSTD::move(__elem_);
|
||||
}
|
||||
|
||||
private:
|
||||
friend class directory_iterator;
|
||||
friend class recursive_directory_iterator;
|
||||
explicit __dir_element_proxy(directory_entry const& __e) : __elem_(__e) {}
|
||||
__dir_element_proxy(__dir_element_proxy&& __o)
|
||||
: __elem_(_VSTD::move(__o.__elem_)) {}
|
||||
directory_entry __elem_;
|
||||
};
|
||||
|
||||
_LIBCPP_AVAILABILITY_FILESYSTEM_POP
|
||||
|
||||
_LIBCPP_END_NAMESPACE_FILESYSTEM
|
||||
|
||||
#endif // _LIBCPP_CXX03_LANG
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif // _LIBCPP___FILESYSTEM_DIRECTORY_ENTRY_H
|
||||
150
libcxx/include/__filesystem/directory_iterator.h
Normal file
150
libcxx/include/__filesystem/directory_iterator.h
Normal file
@ -0,0 +1,150 @@
|
||||
// -*- C++ -*-
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef _LIBCPP___FILESYSTEM_DIRECTORY_ITERATOR_H
|
||||
#define _LIBCPP___FILESYSTEM_DIRECTORY_ITERATOR_H
|
||||
|
||||
#include <__availability>
|
||||
#include <__config>
|
||||
#include <__filesystem/directory_entry.h>
|
||||
#include <__filesystem/directory_options.h>
|
||||
#include <__filesystem/path.h>
|
||||
#include <__iterator/iterator_traits.h>
|
||||
#include <__memory/shared_ptr.h>
|
||||
#include <__debug>
|
||||
#include <__ranges/enable_borrowed_range.h>
|
||||
#include <__ranges/enable_view.h>
|
||||
#include <cstddef>
|
||||
#include <system_error>
|
||||
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
|
||||
|
||||
_LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
|
||||
|
||||
class _LIBCPP_HIDDEN __dir_stream;
|
||||
class directory_iterator {
|
||||
public:
|
||||
typedef directory_entry value_type;
|
||||
typedef ptrdiff_t difference_type;
|
||||
typedef value_type const* pointer;
|
||||
typedef value_type const& reference;
|
||||
typedef input_iterator_tag iterator_category;
|
||||
|
||||
public:
|
||||
//ctor & dtor
|
||||
directory_iterator() noexcept {}
|
||||
|
||||
explicit directory_iterator(const path& __p)
|
||||
: directory_iterator(__p, nullptr) {}
|
||||
|
||||
directory_iterator(const path& __p, directory_options __opts)
|
||||
: directory_iterator(__p, nullptr, __opts) {}
|
||||
|
||||
directory_iterator(const path& __p, error_code& __ec)
|
||||
: directory_iterator(__p, &__ec) {}
|
||||
|
||||
directory_iterator(const path& __p, directory_options __opts,
|
||||
error_code& __ec)
|
||||
: directory_iterator(__p, &__ec, __opts) {}
|
||||
|
||||
directory_iterator(const directory_iterator&) = default;
|
||||
directory_iterator(directory_iterator&&) = default;
|
||||
directory_iterator& operator=(const directory_iterator&) = default;
|
||||
|
||||
directory_iterator& operator=(directory_iterator&& __o) noexcept {
|
||||
// non-default implementation provided to support self-move assign.
|
||||
if (this != &__o) {
|
||||
__imp_ = _VSTD::move(__o.__imp_);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
~directory_iterator() = default;
|
||||
|
||||
const directory_entry& operator*() const {
|
||||
_LIBCPP_ASSERT(__imp_, "The end iterator cannot be dereferenced");
|
||||
return __dereference();
|
||||
}
|
||||
|
||||
const directory_entry* operator->() const { return &**this; }
|
||||
|
||||
directory_iterator& operator++() { return __increment(); }
|
||||
|
||||
__dir_element_proxy operator++(int) {
|
||||
__dir_element_proxy __p(**this);
|
||||
__increment();
|
||||
return __p;
|
||||
}
|
||||
|
||||
directory_iterator& increment(error_code& __ec) { return __increment(&__ec); }
|
||||
|
||||
private:
|
||||
inline _LIBCPP_INLINE_VISIBILITY friend bool
|
||||
operator==(const directory_iterator& __lhs,
|
||||
const directory_iterator& __rhs) noexcept;
|
||||
|
||||
// construct the dir_stream
|
||||
_LIBCPP_FUNC_VIS
|
||||
directory_iterator(const path&, error_code*,
|
||||
directory_options = directory_options::none);
|
||||
|
||||
_LIBCPP_FUNC_VIS
|
||||
directory_iterator& __increment(error_code* __ec = nullptr);
|
||||
|
||||
_LIBCPP_FUNC_VIS
|
||||
const directory_entry& __dereference() const;
|
||||
|
||||
private:
|
||||
shared_ptr<__dir_stream> __imp_;
|
||||
};
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY bool
|
||||
operator==(const directory_iterator& __lhs,
|
||||
const directory_iterator& __rhs) noexcept {
|
||||
return __lhs.__imp_ == __rhs.__imp_;
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY bool
|
||||
operator!=(const directory_iterator& __lhs,
|
||||
const directory_iterator& __rhs) noexcept {
|
||||
return !(__lhs == __rhs);
|
||||
}
|
||||
|
||||
// enable directory_iterator range-based for statements
|
||||
inline _LIBCPP_INLINE_VISIBILITY directory_iterator
|
||||
begin(directory_iterator __iter) noexcept {
|
||||
return __iter;
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY directory_iterator
|
||||
end(directory_iterator) noexcept {
|
||||
return directory_iterator();
|
||||
}
|
||||
|
||||
_LIBCPP_AVAILABILITY_FILESYSTEM_POP
|
||||
|
||||
_LIBCPP_END_NAMESPACE_FILESYSTEM
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_RANGES)
|
||||
|
||||
template <>
|
||||
_LIBCPP_AVAILABILITY_FILESYSTEM
|
||||
inline constexpr bool _VSTD::ranges::enable_borrowed_range<_VSTD_FS::directory_iterator> = true;
|
||||
|
||||
template <>
|
||||
_LIBCPP_AVAILABILITY_FILESYSTEM
|
||||
inline constexpr bool _VSTD::ranges::enable_view<_VSTD_FS::directory_iterator> = true;
|
||||
|
||||
#endif
|
||||
|
||||
#endif // _LIBCPP_CXX03_LANG
|
||||
|
||||
#endif // _LIBCPP___FILESYSTEM_DIRECTORY_ITERATOR_H
|
||||
78
libcxx/include/__filesystem/directory_options.h
Normal file
78
libcxx/include/__filesystem/directory_options.h
Normal file
@ -0,0 +1,78 @@
|
||||
// -*- C++ -*-
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef _LIBCPP___FILESYSTEM_DIRECTORY_OPTIONS_H
|
||||
#define _LIBCPP___FILESYSTEM_DIRECTORY_OPTIONS_H
|
||||
|
||||
#include <__availability>
|
||||
#include <__config>
|
||||
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
|
||||
|
||||
_LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
|
||||
|
||||
enum class _LIBCPP_ENUM_VIS directory_options : unsigned char {
|
||||
none = 0,
|
||||
follow_directory_symlink = 1,
|
||||
skip_permission_denied = 2
|
||||
};
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
inline constexpr directory_options operator&(directory_options _LHS,
|
||||
directory_options _RHS) {
|
||||
return static_cast<directory_options>(static_cast<unsigned char>(_LHS) &
|
||||
static_cast<unsigned char>(_RHS));
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
inline constexpr directory_options operator|(directory_options _LHS,
|
||||
directory_options _RHS) {
|
||||
return static_cast<directory_options>(static_cast<unsigned char>(_LHS) |
|
||||
static_cast<unsigned char>(_RHS));
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
inline constexpr directory_options operator^(directory_options _LHS,
|
||||
directory_options _RHS) {
|
||||
return static_cast<directory_options>(static_cast<unsigned char>(_LHS) ^
|
||||
static_cast<unsigned char>(_RHS));
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
inline constexpr directory_options operator~(directory_options _LHS) {
|
||||
return static_cast<directory_options>(~static_cast<unsigned char>(_LHS));
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
inline directory_options& operator&=(directory_options& _LHS,
|
||||
directory_options _RHS) {
|
||||
return _LHS = _LHS & _RHS;
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
inline directory_options& operator|=(directory_options& _LHS,
|
||||
directory_options _RHS) {
|
||||
return _LHS = _LHS | _RHS;
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
inline directory_options& operator^=(directory_options& _LHS,
|
||||
directory_options _RHS) {
|
||||
return _LHS = _LHS ^ _RHS;
|
||||
}
|
||||
|
||||
_LIBCPP_AVAILABILITY_FILESYSTEM_POP
|
||||
|
||||
_LIBCPP_END_NAMESPACE_FILESYSTEM
|
||||
|
||||
#endif // _LIBCPP_CXX03_LANG
|
||||
|
||||
#endif // _LIBCPP___FILESYSTEM_DIRECTORY_OPTIONS_H
|
||||
68
libcxx/include/__filesystem/file_status.h
Normal file
68
libcxx/include/__filesystem/file_status.h
Normal file
@ -0,0 +1,68 @@
|
||||
// -*- C++ -*-
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef _LIBCPP___FILESYSTEM_FILE_STATUS_H
|
||||
#define _LIBCPP___FILESYSTEM_FILE_STATUS_H
|
||||
|
||||
#include <__availability>
|
||||
#include <__config>
|
||||
#include <__filesystem/file_type.h>
|
||||
#include <__filesystem/perms.h>
|
||||
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
|
||||
|
||||
_LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
|
||||
|
||||
class _LIBCPP_TYPE_VIS file_status {
|
||||
public:
|
||||
// constructors
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
file_status() noexcept : file_status(file_type::none) {}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
explicit file_status(file_type __ft, perms __prms = perms::unknown) noexcept
|
||||
: __ft_(__ft),
|
||||
__prms_(__prms) {}
|
||||
|
||||
file_status(const file_status&) noexcept = default;
|
||||
file_status(file_status&&) noexcept = default;
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
~file_status() {}
|
||||
|
||||
file_status& operator=(const file_status&) noexcept = default;
|
||||
file_status& operator=(file_status&&) noexcept = default;
|
||||
|
||||
// observers
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
file_type type() const noexcept { return __ft_; }
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
perms permissions() const noexcept { return __prms_; }
|
||||
|
||||
// modifiers
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void type(file_type __ft) noexcept { __ft_ = __ft; }
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void permissions(perms __p) noexcept { __prms_ = __p; }
|
||||
|
||||
private:
|
||||
file_type __ft_;
|
||||
perms __prms_;
|
||||
};
|
||||
|
||||
_LIBCPP_AVAILABILITY_FILESYSTEM_POP
|
||||
|
||||
_LIBCPP_END_NAMESPACE_FILESYSTEM
|
||||
|
||||
#endif // _LIBCPP_CXX03_LANG
|
||||
|
||||
#endif // _LIBCPP___FILESYSTEM_FILE_STATUS_H
|
||||
27
libcxx/include/__filesystem/file_time_type.h
Normal file
27
libcxx/include/__filesystem/file_time_type.h
Normal file
@ -0,0 +1,27 @@
|
||||
// -*- C++ -*-
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef _LIBCPP___FILESYSTEM_FILE_TIME_TYPE_H
|
||||
#define _LIBCPP___FILESYSTEM_FILE_TIME_TYPE_H
|
||||
|
||||
#include <__availability>
|
||||
#include <__config>
|
||||
#include <chrono>
|
||||
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
|
||||
|
||||
typedef chrono::time_point<_FilesystemClock> file_time_type;
|
||||
|
||||
_LIBCPP_END_NAMESPACE_FILESYSTEM
|
||||
|
||||
#endif // _LIBCPP_CXX03_LANG
|
||||
|
||||
#endif // _LIBCPP___FILESYSTEM_FILE_TIME_TYPE_H
|
||||
39
libcxx/include/__filesystem/file_type.h
Normal file
39
libcxx/include/__filesystem/file_type.h
Normal file
@ -0,0 +1,39 @@
|
||||
// -*- C++ -*-
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef _LIBCPP___FILESYSTEM_FILE_TYPE_H
|
||||
#define _LIBCPP___FILESYSTEM_FILE_TYPE_H
|
||||
|
||||
#include <__availability>
|
||||
#include <__config>
|
||||
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
|
||||
|
||||
// On Windows, the library never identifies files as block, character, fifo
|
||||
// or socket.
|
||||
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
|
||||
};
|
||||
|
||||
_LIBCPP_END_NAMESPACE_FILESYSTEM
|
||||
|
||||
#endif // _LIBCPP_CXX03_LANG
|
||||
|
||||
#endif // _LIBCPP___FILESYSTEM_FILE_TYPE_H
|
||||
99
libcxx/include/__filesystem/filesystem_error.h
Normal file
99
libcxx/include/__filesystem/filesystem_error.h
Normal file
@ -0,0 +1,99 @@
|
||||
// -*- C++ -*-
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef _LIBCPP___FILESYSTEM_FILESYSTEM_ERROR_H
|
||||
#define _LIBCPP___FILESYSTEM_FILESYSTEM_ERROR_H
|
||||
|
||||
#include <__availability>
|
||||
#include <__config>
|
||||
#include <__filesystem/path.h>
|
||||
#include <__memory/shared_ptr.h>
|
||||
#include <system_error>
|
||||
#include <iosfwd>
|
||||
#include <new>
|
||||
#include <type_traits>
|
||||
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
|
||||
|
||||
class _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_EXCEPTION_ABI filesystem_error : public system_error {
|
||||
public:
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
filesystem_error(const string& __what, error_code __ec)
|
||||
: system_error(__ec, __what),
|
||||
__storage_(make_shared<_Storage>(path(), path())) {
|
||||
__create_what(0);
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
filesystem_error(const string& __what, const path& __p1, error_code __ec)
|
||||
: system_error(__ec, __what),
|
||||
__storage_(make_shared<_Storage>(__p1, path())) {
|
||||
__create_what(1);
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
filesystem_error(const string& __what, const path& __p1, const path& __p2,
|
||||
error_code __ec)
|
||||
: system_error(__ec, __what),
|
||||
__storage_(make_shared<_Storage>(__p1, __p2)) {
|
||||
__create_what(2);
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
const path& path1() const noexcept { return __storage_->__p1_; }
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
const path& path2() const noexcept { return __storage_->__p2_; }
|
||||
|
||||
filesystem_error(const filesystem_error&) = default;
|
||||
~filesystem_error() override; // key function
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
const char* what() const noexcept override {
|
||||
return __storage_->__what_.c_str();
|
||||
}
|
||||
|
||||
void __create_what(int __num_paths);
|
||||
|
||||
private:
|
||||
struct _LIBCPP_HIDDEN _Storage {
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
_Storage(const path& __p1, const path& __p2) : __p1_(__p1), __p2_(__p2) {}
|
||||
|
||||
path __p1_;
|
||||
path __p2_;
|
||||
string __what_;
|
||||
};
|
||||
shared_ptr<_Storage> __storage_;
|
||||
};
|
||||
|
||||
// TODO(ldionne): We need to pop the pragma and push it again after
|
||||
// filesystem_error to work around PR41078.
|
||||
_LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
|
||||
|
||||
template <class... _Args>
|
||||
_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
|
||||
#ifndef _LIBCPP_NO_EXCEPTIONS
|
||||
void __throw_filesystem_error(_Args&&... __args) {
|
||||
throw filesystem_error(_VSTD::forward<_Args>(__args)...);
|
||||
}
|
||||
#else
|
||||
void __throw_filesystem_error(_Args&&...) {
|
||||
_VSTD::abort();
|
||||
}
|
||||
#endif
|
||||
_LIBCPP_AVAILABILITY_FILESYSTEM_POP
|
||||
|
||||
_LIBCPP_END_NAMESPACE_FILESYSTEM
|
||||
|
||||
#endif // _LIBCPP_CXX03_LANG
|
||||
|
||||
#endif // _LIBCPP___FILESYSTEM_FILESYSTEM_ERROR_H
|
||||
599
libcxx/include/__filesystem/operations.h
Normal file
599
libcxx/include/__filesystem/operations.h
Normal file
@ -0,0 +1,599 @@
|
||||
// -*- C++ -*-
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef _LIBCPP___FILESYSTEM_OPERATIONS_H
|
||||
#define _LIBCPP___FILESYSTEM_OPERATIONS_H
|
||||
|
||||
#include <__availability>
|
||||
#include <__config>
|
||||
#include <__filesystem/copy_options.h>
|
||||
#include <__filesystem/file_status.h>
|
||||
#include <__filesystem/file_time_type.h>
|
||||
#include <__filesystem/file_type.h>
|
||||
#include <__filesystem/path.h>
|
||||
#include <__filesystem/perm_options.h>
|
||||
#include <__filesystem/perms.h>
|
||||
#include <__filesystem/space_info.h>
|
||||
#include <chrono>
|
||||
#include <cstdint>
|
||||
#include <system_error>
|
||||
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
|
||||
|
||||
_LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
|
||||
|
||||
_LIBCPP_FUNC_VIS
|
||||
path __absolute(const path&, error_code* __ec = nullptr);
|
||||
_LIBCPP_FUNC_VIS
|
||||
path __canonical(const path&, error_code* __ec = nullptr);
|
||||
_LIBCPP_FUNC_VIS
|
||||
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
|
||||
void __copy(const path& __from, const path& __to, copy_options __opt,
|
||||
error_code* __ec = nullptr);
|
||||
_LIBCPP_FUNC_VIS
|
||||
bool __create_directories(const path& p, 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
|
||||
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_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
|
||||
file_status __status(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
|
||||
file_status __symlink_status(const path&, 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
|
||||
path __weakly_canonical(path const& __p, error_code* __ec = nullptr);
|
||||
_LIBCPP_FUNC_VIS
|
||||
path __read_symlink(const path& p, error_code* ec = nullptr);
|
||||
_LIBCPP_FUNC_VIS
|
||||
uintmax_t __remove_all(const path& p, error_code* ec = nullptr);
|
||||
_LIBCPP_FUNC_VIS
|
||||
bool __remove(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
|
||||
path __temp_directory_path(error_code* __ec = nullptr);
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY path absolute(const path& __p) {
|
||||
return __absolute(__p);
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY path absolute(const path& __p,
|
||||
error_code& __ec) {
|
||||
return __absolute(__p, &__ec);
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY path canonical(const path& __p) {
|
||||
return __canonical(__p);
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY path canonical(const path& __p,
|
||||
error_code& __ec) {
|
||||
return __canonical(__p, &__ec);
|
||||
}
|
||||
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY bool copy_file(const path& __from,
|
||||
const path& __to) {
|
||||
return __copy_file(__from, __to, copy_options::none);
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY bool
|
||||
copy_file(const path& __from, const path& __to, error_code& __ec) {
|
||||
return __copy_file(__from, __to, copy_options::none, &__ec);
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY bool
|
||||
copy_file(const path& __from, const path& __to, copy_options __opt) {
|
||||
return __copy_file(__from, __to, __opt);
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY bool copy_file(const path& __from,
|
||||
const path& __to,
|
||||
copy_options __opt,
|
||||
error_code& __ec) {
|
||||
return __copy_file(__from, __to, __opt, &__ec);
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY void copy_symlink(const path& __existing,
|
||||
const path& __new) {
|
||||
__copy_symlink(__existing, __new);
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY void
|
||||
copy_symlink(const path& __ext, const path& __new, error_code& __ec) noexcept {
|
||||
__copy_symlink(__ext, __new, &__ec);
|
||||
}
|
||||
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY void copy(const path& __from,
|
||||
const path& __to) {
|
||||
__copy(__from, __to, copy_options::none);
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY void copy(const path& __from, const path& __to,
|
||||
error_code& __ec) {
|
||||
__copy(__from, __to, copy_options::none, &__ec);
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY void copy(const path& __from, const path& __to,
|
||||
copy_options __opt) {
|
||||
__copy(__from, __to, __opt);
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY void copy(const path& __from, const path& __to,
|
||||
copy_options __opt,
|
||||
error_code& __ec) {
|
||||
__copy(__from, __to, __opt, &__ec);
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY bool create_directories(const path& __p) {
|
||||
return __create_directories(__p);
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY bool create_directories(const path& __p,
|
||||
error_code& __ec) {
|
||||
return __create_directories(__p, &__ec);
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY 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 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_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 path current_path() {
|
||||
return __current_path();
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY path current_path(error_code& __ec) {
|
||||
return __current_path(&__ec);
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY void current_path(const path& __p) {
|
||||
__current_path(__p);
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY void current_path(const path& __p,
|
||||
error_code& __ec) noexcept {
|
||||
__current_path(__p, &__ec);
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY 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 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 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));
|
||||
}
|
||||
|
||||
_LIBCPP_FUNC_VIS
|
||||
bool __fs_is_empty(const path& p, error_code* ec = nullptr);
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY bool is_empty(const path& __p) {
|
||||
return __fs_is_empty(__p);
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY bool is_empty(const path& __p,
|
||||
error_code& __ec) {
|
||||
return __fs_is_empty(__p, &__ec);
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY bool is_fifo(file_status __s) noexcept {
|
||||
return __s.type() == file_type::fifo;
|
||||
}
|
||||
inline _LIBCPP_INLINE_VISIBILITY bool is_fifo(const path& __p) {
|
||||
return is_fifo(__status(__p));
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY bool is_fifo(const path& __p,
|
||||
error_code& __ec) noexcept {
|
||||
return is_fifo(__status(__p, &__ec));
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY bool
|
||||
is_regular_file(file_status __s) noexcept {
|
||||
return __s.type() == file_type::regular;
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY bool is_regular_file(const path& __p) {
|
||||
return is_regular_file(__status(__p));
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY bool
|
||||
is_regular_file(const path& __p, error_code& __ec) noexcept {
|
||||
return is_regular_file(__status(__p, &__ec));
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY bool is_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 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 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);
|
||||
}
|
||||
|
||||
_LIBCPP_FUNC_VIS
|
||||
void __permissions(const path&, perms, perm_options, error_code* = nullptr);
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY void
|
||||
permissions(const path& __p, perms __prms,
|
||||
perm_options __opts = perm_options::replace) {
|
||||
__permissions(__p, __prms, __opts);
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY void permissions(const path& __p, perms __prms,
|
||||
error_code& __ec) noexcept {
|
||||
__permissions(__p, __prms, perm_options::replace, &__ec);
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY void permissions(const path& __p, perms __prms,
|
||||
perm_options __opts,
|
||||
error_code& __ec) {
|
||||
__permissions(__p, __prms, __opts, &__ec);
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY path proximate(const path& __p,
|
||||
const path& __base,
|
||||
error_code& __ec) {
|
||||
path __tmp = __weakly_canonical(__p, &__ec);
|
||||
if (__ec)
|
||||
return {};
|
||||
path __tmp_base = __weakly_canonical(__base, &__ec);
|
||||
if (__ec)
|
||||
return {};
|
||||
return __tmp.lexically_proximate(__tmp_base);
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY path proximate(const path& __p,
|
||||
error_code& __ec) {
|
||||
return proximate(__p, current_path(), __ec);
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY path
|
||||
proximate(const path& __p, const path& __base = current_path()) {
|
||||
return __weakly_canonical(__p).lexically_proximate(
|
||||
__weakly_canonical(__base));
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY path read_symlink(const path& __p) {
|
||||
return __read_symlink(__p);
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY path read_symlink(const path& __p,
|
||||
error_code& __ec) {
|
||||
return __read_symlink(__p, &__ec);
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY path relative(const path& __p,
|
||||
const path& __base,
|
||||
error_code& __ec) {
|
||||
path __tmp = __weakly_canonical(__p, &__ec);
|
||||
if (__ec)
|
||||
return path();
|
||||
path __tmpbase = __weakly_canonical(__base, &__ec);
|
||||
if (__ec)
|
||||
return path();
|
||||
return __tmp.lexically_relative(__tmpbase);
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY path relative(const path& __p,
|
||||
error_code& __ec) {
|
||||
return relative(__p, current_path(), __ec);
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY path
|
||||
relative(const path& __p, const path& __base = current_path()) {
|
||||
return __weakly_canonical(__p).lexically_relative(__weakly_canonical(__base));
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY uintmax_t remove_all(const path& __p) {
|
||||
return __remove_all(__p);
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY uintmax_t remove_all(const path& __p,
|
||||
error_code& __ec) {
|
||||
return __remove_all(__p, &__ec);
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY 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 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);
|
||||
}
|
||||
|
||||
_LIBCPP_FUNC_VIS
|
||||
space_info __space(const path&, error_code* __ec = nullptr);
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY space_info space(const path& __p) {
|
||||
return __space(__p);
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY space_info space(const path& __p,
|
||||
error_code& __ec) noexcept {
|
||||
return __space(__p, &__ec);
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY file_status status(const path& __p) {
|
||||
return __status(__p);
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY file_status status(const path& __p,
|
||||
error_code& __ec) noexcept {
|
||||
return __status(__p, &__ec);
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY file_status symlink_status(const path& __p) {
|
||||
return __symlink_status(__p);
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY file_status
|
||||
symlink_status(const path& __p, error_code& __ec) noexcept {
|
||||
return __symlink_status(__p, &__ec);
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY path temp_directory_path() {
|
||||
return __temp_directory_path();
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY path temp_directory_path(error_code& __ec) {
|
||||
return __temp_directory_path(&__ec);
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY path weakly_canonical(path const& __p) {
|
||||
return __weakly_canonical(__p);
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY path weakly_canonical(path const& __p,
|
||||
error_code& __ec) {
|
||||
return __weakly_canonical(__p, &__ec);
|
||||
}
|
||||
|
||||
_LIBCPP_AVAILABILITY_FILESYSTEM_POP
|
||||
|
||||
_LIBCPP_END_NAMESPACE_FILESYSTEM
|
||||
|
||||
#endif // _LIBCPP_CXX03_LANG
|
||||
|
||||
#endif // _LIBCPP___FILESYSTEM_OPERATIONS_H
|
||||
1018
libcxx/include/__filesystem/path.h
Normal file
1018
libcxx/include/__filesystem/path.h
Normal file
File diff suppressed because it is too large
Load Diff
132
libcxx/include/__filesystem/path_iterator.h
Normal file
132
libcxx/include/__filesystem/path_iterator.h
Normal file
@ -0,0 +1,132 @@
|
||||
// -*- C++ -*-
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef _LIBCPP___FILESYSTEM_PATH_ITERATOR_H
|
||||
#define _LIBCPP___FILESYSTEM_PATH_ITERATOR_H
|
||||
|
||||
#include <__availability>
|
||||
#include <__config>
|
||||
#include <__filesystem/path.h>
|
||||
#include <__iterator/iterator_traits.h>
|
||||
#include <__debug>
|
||||
#include <cstddef>
|
||||
#include <string>
|
||||
#include <string_view>
|
||||
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
|
||||
|
||||
_LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
|
||||
|
||||
class _LIBCPP_TYPE_VIS path::iterator {
|
||||
public:
|
||||
enum _ParserState : unsigned char {
|
||||
_Singular,
|
||||
_BeforeBegin,
|
||||
_InRootName,
|
||||
_InRootDir,
|
||||
_InFilenames,
|
||||
_InTrailingSep,
|
||||
_AtEnd
|
||||
};
|
||||
|
||||
public:
|
||||
typedef bidirectional_iterator_tag iterator_category;
|
||||
|
||||
typedef path value_type;
|
||||
typedef ptrdiff_t difference_type;
|
||||
typedef const path* pointer;
|
||||
typedef const path& reference;
|
||||
|
||||
typedef void
|
||||
__stashing_iterator_tag; // See reverse_iterator and __is_stashing_iterator
|
||||
|
||||
public:
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
iterator()
|
||||
: __stashed_elem_(), __path_ptr_(nullptr), __entry_(),
|
||||
__state_(_Singular) {}
|
||||
|
||||
iterator(const iterator&) = default;
|
||||
~iterator() = default;
|
||||
|
||||
iterator& operator=(const iterator&) = default;
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
reference operator*() const { return __stashed_elem_; }
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
pointer operator->() const { return &__stashed_elem_; }
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
iterator& operator++() {
|
||||
_LIBCPP_ASSERT(__state_ != _Singular,
|
||||
"attempting to increment a singular iterator");
|
||||
_LIBCPP_ASSERT(__state_ != _AtEnd,
|
||||
"attempting to increment the end iterator");
|
||||
return __increment();
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
iterator operator++(int) {
|
||||
iterator __it(*this);
|
||||
this->operator++();
|
||||
return __it;
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
iterator& operator--() {
|
||||
_LIBCPP_ASSERT(__state_ != _Singular,
|
||||
"attempting to decrement a singular iterator");
|
||||
_LIBCPP_ASSERT(__entry_.data() != __path_ptr_->native().data(),
|
||||
"attempting to decrement the begin iterator");
|
||||
return __decrement();
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
iterator operator--(int) {
|
||||
iterator __it(*this);
|
||||
this->operator--();
|
||||
return __it;
|
||||
}
|
||||
|
||||
private:
|
||||
friend class path;
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY friend bool operator==(const iterator&,
|
||||
const iterator&);
|
||||
|
||||
iterator& __increment();
|
||||
iterator& __decrement();
|
||||
|
||||
path __stashed_elem_;
|
||||
const path* __path_ptr_;
|
||||
path::__string_view __entry_;
|
||||
_ParserState __state_;
|
||||
};
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY bool operator==(const path::iterator& __lhs,
|
||||
const path::iterator& __rhs) {
|
||||
return __lhs.__path_ptr_ == __rhs.__path_ptr_ &&
|
||||
__lhs.__entry_.data() == __rhs.__entry_.data();
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY bool operator!=(const path::iterator& __lhs,
|
||||
const path::iterator& __rhs) {
|
||||
return !(__lhs == __rhs);
|
||||
}
|
||||
|
||||
_LIBCPP_AVAILABILITY_FILESYSTEM_POP
|
||||
|
||||
_LIBCPP_END_NAMESPACE_FILESYSTEM
|
||||
|
||||
#endif // _LIBCPP_CXX03_LANG
|
||||
|
||||
#endif // _LIBCPP___FILESYSTEM_PATH_ITERATOR_H
|
||||
73
libcxx/include/__filesystem/perm_options.h
Normal file
73
libcxx/include/__filesystem/perm_options.h
Normal file
@ -0,0 +1,73 @@
|
||||
// -*- C++ -*-
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef _LIBCPP___FILESYSTEM_PERM_OPTIONS_H
|
||||
#define _LIBCPP___FILESYSTEM_PERM_OPTIONS_H
|
||||
|
||||
#include <__availability>
|
||||
#include <__config>
|
||||
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
|
||||
|
||||
_LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
|
||||
|
||||
enum class _LIBCPP_ENUM_VIS perm_options : unsigned char {
|
||||
replace = 1,
|
||||
add = 2,
|
||||
remove = 4,
|
||||
nofollow = 8
|
||||
};
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
inline constexpr perm_options operator&(perm_options _LHS, perm_options _RHS) {
|
||||
return static_cast<perm_options>(static_cast<unsigned>(_LHS) &
|
||||
static_cast<unsigned>(_RHS));
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
inline constexpr perm_options operator|(perm_options _LHS, perm_options _RHS) {
|
||||
return static_cast<perm_options>(static_cast<unsigned>(_LHS) |
|
||||
static_cast<unsigned>(_RHS));
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
inline constexpr perm_options operator^(perm_options _LHS, perm_options _RHS) {
|
||||
return static_cast<perm_options>(static_cast<unsigned>(_LHS) ^
|
||||
static_cast<unsigned>(_RHS));
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
inline constexpr perm_options operator~(perm_options _LHS) {
|
||||
return static_cast<perm_options>(~static_cast<unsigned>(_LHS));
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
inline perm_options& operator&=(perm_options& _LHS, perm_options _RHS) {
|
||||
return _LHS = _LHS & _RHS;
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
inline perm_options& operator|=(perm_options& _LHS, perm_options _RHS) {
|
||||
return _LHS = _LHS | _RHS;
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
inline perm_options& operator^=(perm_options& _LHS, perm_options _RHS) {
|
||||
return _LHS = _LHS ^ _RHS;
|
||||
}
|
||||
|
||||
_LIBCPP_AVAILABILITY_FILESYSTEM_POP
|
||||
|
||||
_LIBCPP_END_NAMESPACE_FILESYSTEM
|
||||
|
||||
#endif // _LIBCPP_CXX03_LANG
|
||||
|
||||
#endif // _LIBCPP___FILESYSTEM_PERM_OPTIONS_H
|
||||
91
libcxx/include/__filesystem/perms.h
Normal file
91
libcxx/include/__filesystem/perms.h
Normal file
@ -0,0 +1,91 @@
|
||||
// -*- C++ -*-
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef _LIBCPP___FILESYSTEM_PERMS_H
|
||||
#define _LIBCPP___FILESYSTEM_PERMS_H
|
||||
|
||||
#include <__availability>
|
||||
#include <__config>
|
||||
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
|
||||
|
||||
_LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
|
||||
|
||||
// On Windows, these permission bits map to one single readonly flag per
|
||||
// file, and the executable bit is always returned as set. When setting
|
||||
// permissions, as long as the write bit is set for either owner, group or
|
||||
// others, the readonly flag is cleared.
|
||||
enum class _LIBCPP_ENUM_VIS perms : unsigned {
|
||||
none = 0,
|
||||
|
||||
owner_read = 0400,
|
||||
owner_write = 0200,
|
||||
owner_exec = 0100,
|
||||
owner_all = 0700,
|
||||
|
||||
group_read = 040,
|
||||
group_write = 020,
|
||||
group_exec = 010,
|
||||
group_all = 070,
|
||||
|
||||
others_read = 04,
|
||||
others_write = 02,
|
||||
others_exec = 01,
|
||||
others_all = 07,
|
||||
|
||||
all = 0777,
|
||||
|
||||
set_uid = 04000,
|
||||
set_gid = 02000,
|
||||
sticky_bit = 01000,
|
||||
mask = 07777,
|
||||
unknown = 0xFFFF,
|
||||
};
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
inline constexpr perms operator&(perms _LHS, perms _RHS) {
|
||||
return static_cast<perms>(static_cast<unsigned>(_LHS) &
|
||||
static_cast<unsigned>(_RHS));
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
inline constexpr perms operator|(perms _LHS, perms _RHS) {
|
||||
return static_cast<perms>(static_cast<unsigned>(_LHS) |
|
||||
static_cast<unsigned>(_RHS));
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
inline constexpr perms operator^(perms _LHS, perms _RHS) {
|
||||
return static_cast<perms>(static_cast<unsigned>(_LHS) ^
|
||||
static_cast<unsigned>(_RHS));
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
inline constexpr perms operator~(perms _LHS) {
|
||||
return static_cast<perms>(~static_cast<unsigned>(_LHS));
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
inline perms& operator&=(perms& _LHS, perms _RHS) { return _LHS = _LHS & _RHS; }
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
inline perms& operator|=(perms& _LHS, perms _RHS) { return _LHS = _LHS | _RHS; }
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
inline perms& operator^=(perms& _LHS, perms _RHS) { return _LHS = _LHS ^ _RHS; }
|
||||
|
||||
_LIBCPP_AVAILABILITY_FILESYSTEM_POP
|
||||
|
||||
_LIBCPP_END_NAMESPACE_FILESYSTEM
|
||||
|
||||
#endif // _LIBCPP_CXX03_LANG
|
||||
|
||||
#endif // _LIBCPP___FILESYSTEM_PERMS_H
|
||||
181
libcxx/include/__filesystem/recursive_directory_iterator.h
Normal file
181
libcxx/include/__filesystem/recursive_directory_iterator.h
Normal file
@ -0,0 +1,181 @@
|
||||
// -*- C++ -*-
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef _LIBCPP___FILESYSTEM_RECURSIVE_DIRECTORY_ITERATOR_H
|
||||
#define _LIBCPP___FILESYSTEM_RECURSIVE_DIRECTORY_ITERATOR_H
|
||||
|
||||
#include <__availability>
|
||||
#include <__config>
|
||||
#include <__filesystem/directory_entry.h>
|
||||
#include <__filesystem/directory_options.h>
|
||||
#include <__filesystem/path.h>
|
||||
#include <__iterator/iterator_traits.h>
|
||||
#include <__memory/shared_ptr.h>
|
||||
#include <__ranges/enable_borrowed_range.h>
|
||||
#include <__ranges/enable_view.h>
|
||||
#include <cstddef>
|
||||
#include <system_error>
|
||||
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
|
||||
|
||||
_LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
|
||||
|
||||
class recursive_directory_iterator {
|
||||
public:
|
||||
using value_type = directory_entry;
|
||||
using difference_type = ptrdiff_t;
|
||||
using pointer = directory_entry const*;
|
||||
using reference = directory_entry const&;
|
||||
using iterator_category = input_iterator_tag;
|
||||
|
||||
public:
|
||||
// constructors and destructor
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
recursive_directory_iterator() noexcept : __rec_(false) {}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
explicit recursive_directory_iterator(
|
||||
const path& __p, directory_options __xoptions = directory_options::none)
|
||||
: recursive_directory_iterator(__p, __xoptions, nullptr) {}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
recursive_directory_iterator(const path& __p, directory_options __xoptions,
|
||||
error_code& __ec)
|
||||
: recursive_directory_iterator(__p, __xoptions, &__ec) {}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
recursive_directory_iterator(const path& __p, error_code& __ec)
|
||||
: recursive_directory_iterator(__p, directory_options::none, &__ec) {}
|
||||
|
||||
recursive_directory_iterator(const recursive_directory_iterator&) = default;
|
||||
recursive_directory_iterator(recursive_directory_iterator&&) = default;
|
||||
|
||||
recursive_directory_iterator&
|
||||
operator=(const recursive_directory_iterator&) = default;
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
recursive_directory_iterator&
|
||||
operator=(recursive_directory_iterator&& __o) noexcept {
|
||||
// non-default implementation provided to support self-move assign.
|
||||
if (this != &__o) {
|
||||
__imp_ = _VSTD::move(__o.__imp_);
|
||||
__rec_ = __o.__rec_;
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
~recursive_directory_iterator() = default;
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
const directory_entry& operator*() const { return __dereference(); }
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
const directory_entry* operator->() const { return &__dereference(); }
|
||||
|
||||
recursive_directory_iterator& operator++() { return __increment(); }
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
__dir_element_proxy operator++(int) {
|
||||
__dir_element_proxy __p(**this);
|
||||
__increment();
|
||||
return __p;
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
recursive_directory_iterator& increment(error_code& __ec) {
|
||||
return __increment(&__ec);
|
||||
}
|
||||
|
||||
_LIBCPP_FUNC_VIS directory_options options() const;
|
||||
_LIBCPP_FUNC_VIS int depth() const;
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void pop() { __pop(); }
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void pop(error_code& __ec) { __pop(&__ec); }
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool recursion_pending() const { return __rec_; }
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void disable_recursion_pending() { __rec_ = false; }
|
||||
|
||||
private:
|
||||
_LIBCPP_FUNC_VIS
|
||||
recursive_directory_iterator(const path& __p, directory_options __opt,
|
||||
error_code* __ec);
|
||||
|
||||
_LIBCPP_FUNC_VIS
|
||||
const directory_entry& __dereference() const;
|
||||
|
||||
_LIBCPP_FUNC_VIS
|
||||
bool __try_recursion(error_code* __ec);
|
||||
|
||||
_LIBCPP_FUNC_VIS
|
||||
void __advance(error_code* __ec = nullptr);
|
||||
|
||||
_LIBCPP_FUNC_VIS
|
||||
recursive_directory_iterator& __increment(error_code* __ec = nullptr);
|
||||
|
||||
_LIBCPP_FUNC_VIS
|
||||
void __pop(error_code* __ec = nullptr);
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY friend bool
|
||||
operator==(const recursive_directory_iterator&,
|
||||
const recursive_directory_iterator&) noexcept;
|
||||
|
||||
struct _LIBCPP_HIDDEN __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(recursive_directory_iterator) noexcept {
|
||||
return recursive_directory_iterator();
|
||||
}
|
||||
|
||||
_LIBCPP_AVAILABILITY_FILESYSTEM_POP
|
||||
|
||||
_LIBCPP_END_NAMESPACE_FILESYSTEM
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_RANGES)
|
||||
|
||||
template <>
|
||||
_LIBCPP_AVAILABILITY_FILESYSTEM
|
||||
inline constexpr bool _VSTD::ranges::enable_borrowed_range<_VSTD_FS::recursive_directory_iterator> = true;
|
||||
|
||||
template <>
|
||||
_LIBCPP_AVAILABILITY_FILESYSTEM
|
||||
inline constexpr bool _VSTD::ranges::enable_view<_VSTD_FS::recursive_directory_iterator> = true;
|
||||
|
||||
#endif
|
||||
|
||||
#endif // _LIBCPP_CXX03_LANG
|
||||
|
||||
#endif // _LIBCPP___FILESYSTEM_RECURSIVE_DIRECTORY_ITERATOR_H
|
||||
35
libcxx/include/__filesystem/space_info.h
Normal file
35
libcxx/include/__filesystem/space_info.h
Normal file
@ -0,0 +1,35 @@
|
||||
// -*- C++ -*-
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef _LIBCPP___FILESYSTEM_SPACE_INFO_H
|
||||
#define _LIBCPP___FILESYSTEM_SPACE_INFO_H
|
||||
|
||||
#include <__availability>
|
||||
#include <__config>
|
||||
#include <cstdint>
|
||||
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
|
||||
|
||||
_LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
|
||||
|
||||
struct _LIBCPP_TYPE_VIS space_info {
|
||||
uintmax_t capacity;
|
||||
uintmax_t free;
|
||||
uintmax_t available;
|
||||
};
|
||||
|
||||
_LIBCPP_AVAILABILITY_FILESYSTEM_POP
|
||||
|
||||
_LIBCPP_END_NAMESPACE_FILESYSTEM
|
||||
|
||||
#endif // _LIBCPP_CXX03_LANG
|
||||
|
||||
#endif // _LIBCPP___FILESYSTEM_SPACE_INFO_H
|
||||
96
libcxx/include/__filesystem/u8path.h
Normal file
96
libcxx/include/__filesystem/u8path.h
Normal file
@ -0,0 +1,96 @@
|
||||
// -*- C++ -*-
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef _LIBCPP___FILESYSTEM_U8PATH_H
|
||||
#define _LIBCPP___FILESYSTEM_U8PATH_H
|
||||
|
||||
#include <__availability>
|
||||
#include <__config>
|
||||
#include <__filesystem/path.h>
|
||||
#include <type_traits>
|
||||
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
|
||||
|
||||
_LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
|
||||
|
||||
template <class _InputIt>
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_WITH_CHAR8_T
|
||||
typename enable_if<__is_pathable<_InputIt>::value, path>::type
|
||||
u8path(_InputIt __f, _InputIt __l) {
|
||||
static_assert(
|
||||
#ifndef _LIBCPP_HAS_NO_CHAR8_T
|
||||
is_same<typename __is_pathable<_InputIt>::__char_type, char8_t>::value ||
|
||||
#endif
|
||||
is_same<typename __is_pathable<_InputIt>::__char_type, char>::value,
|
||||
"u8path(Iter, Iter) requires Iter have a value_type of type 'char'"
|
||||
" or 'char8_t'");
|
||||
#if defined(_LIBCPP_WIN32API)
|
||||
string __tmp(__f, __l);
|
||||
using _CVT = __widen_from_utf8<sizeof(wchar_t) * __CHAR_BIT__>;
|
||||
_VSTD::wstring __w;
|
||||
__w.reserve(__tmp.size());
|
||||
_CVT()(back_inserter(__w), __tmp.data(), __tmp.data() + __tmp.size());
|
||||
return path(__w);
|
||||
#else
|
||||
return path(__f, __l);
|
||||
#endif /* !_LIBCPP_WIN32API */
|
||||
}
|
||||
|
||||
#if defined(_LIBCPP_WIN32API)
|
||||
template <class _InputIt>
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_WITH_CHAR8_T
|
||||
typename enable_if<__is_pathable<_InputIt>::value, path>::type
|
||||
u8path(_InputIt __f, _NullSentinel) {
|
||||
static_assert(
|
||||
#ifndef _LIBCPP_HAS_NO_CHAR8_T
|
||||
is_same<typename __is_pathable<_InputIt>::__char_type, char8_t>::value ||
|
||||
#endif
|
||||
is_same<typename __is_pathable<_InputIt>::__char_type, char>::value,
|
||||
"u8path(Iter, Iter) requires Iter have a value_type of type 'char'"
|
||||
" or 'char8_t'");
|
||||
string __tmp;
|
||||
const char __sentinel = char{};
|
||||
for (; *__f != __sentinel; ++__f)
|
||||
__tmp.push_back(*__f);
|
||||
using _CVT = __widen_from_utf8<sizeof(wchar_t) * __CHAR_BIT__>;
|
||||
_VSTD::wstring __w;
|
||||
__w.reserve(__tmp.size());
|
||||
_CVT()(back_inserter(__w), __tmp.data(), __tmp.data() + __tmp.size());
|
||||
return path(__w);
|
||||
}
|
||||
#endif /* _LIBCPP_WIN32API */
|
||||
|
||||
template <class _Source>
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_WITH_CHAR8_T
|
||||
typename enable_if<__is_pathable<_Source>::value, path>::type
|
||||
u8path(const _Source& __s) {
|
||||
static_assert(
|
||||
#ifndef _LIBCPP_HAS_NO_CHAR8_T
|
||||
is_same<typename __is_pathable<_Source>::__char_type, char8_t>::value ||
|
||||
#endif
|
||||
is_same<typename __is_pathable<_Source>::__char_type, char>::value,
|
||||
"u8path(Source const&) requires Source have a character type of type "
|
||||
"'char' or 'char8_t'");
|
||||
#if defined(_LIBCPP_WIN32API)
|
||||
using _Traits = __is_pathable<_Source>;
|
||||
return u8path(_VSTD::__unwrap_iter(_Traits::__range_begin(__s)), _VSTD::__unwrap_iter(_Traits::__range_end(__s)));
|
||||
#else
|
||||
return path(__s);
|
||||
#endif
|
||||
}
|
||||
|
||||
_LIBCPP_AVAILABILITY_FILESYSTEM_POP
|
||||
|
||||
_LIBCPP_END_NAMESPACE_FILESYSTEM
|
||||
|
||||
#endif // _LIBCPP_CXX03_LANG
|
||||
|
||||
#endif // _LIBCPP___FILESYSTEM_U8PATH_H
|
||||
File diff suppressed because it is too large
Load Diff
@ -450,6 +450,25 @@ module std [system] {
|
||||
module filesystem {
|
||||
header "filesystem"
|
||||
export *
|
||||
|
||||
module __filesystem {
|
||||
module copy_options { private header "__filesystem/copy_options.h" }
|
||||
module directory_entry { private header "__filesystem/directory_entry.h" }
|
||||
module directory_iterator { private header "__filesystem/directory_iterator.h" }
|
||||
module directory_options { private header "__filesystem/directory_options.h" }
|
||||
module file_status { private header "__filesystem/file_status.h" }
|
||||
module file_time_type { private header "__filesystem/file_time_type.h" }
|
||||
module file_type { private header "__filesystem/file_type.h" }
|
||||
module filesystem_error { private header "__filesystem/filesystem_error.h" }
|
||||
module operations { private header "__filesystem/operations.h" }
|
||||
module path_iterator { private header "__filesystem/path_iterator.h" }
|
||||
module path { private header "__filesystem/path.h" }
|
||||
module perm_options { private header "__filesystem/perm_options.h" }
|
||||
module perms { private header "__filesystem/perms.h" }
|
||||
module recursive_directory_iterator { private header "__filesystem/recursive_directory_iterator.h" }
|
||||
module space_info { private header "__filesystem/space_info.h" }
|
||||
module u8path { private header "__filesystem/u8path.h" }
|
||||
}
|
||||
}
|
||||
module format {
|
||||
header "format"
|
||||
|
||||
@ -0,0 +1,15 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// REQUIRES: modules-build
|
||||
|
||||
// WARNING: This test was generated by 'generate_private_header_tests.py'
|
||||
// and should not be edited manually.
|
||||
|
||||
// expected-error@*:* {{use of private header from outside its module: '__filesystem/copy_options.h'}}
|
||||
#include <__filesystem/copy_options.h>
|
||||
@ -0,0 +1,15 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// REQUIRES: modules-build
|
||||
|
||||
// WARNING: This test was generated by 'generate_private_header_tests.py'
|
||||
// and should not be edited manually.
|
||||
|
||||
// expected-error@*:* {{use of private header from outside its module: '__filesystem/directory_entry.h'}}
|
||||
#include <__filesystem/directory_entry.h>
|
||||
@ -0,0 +1,15 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// REQUIRES: modules-build
|
||||
|
||||
// WARNING: This test was generated by 'generate_private_header_tests.py'
|
||||
// and should not be edited manually.
|
||||
|
||||
// expected-error@*:* {{use of private header from outside its module: '__filesystem/directory_iterator.h'}}
|
||||
#include <__filesystem/directory_iterator.h>
|
||||
@ -0,0 +1,15 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// REQUIRES: modules-build
|
||||
|
||||
// WARNING: This test was generated by 'generate_private_header_tests.py'
|
||||
// and should not be edited manually.
|
||||
|
||||
// expected-error@*:* {{use of private header from outside its module: '__filesystem/directory_options.h'}}
|
||||
#include <__filesystem/directory_options.h>
|
||||
@ -0,0 +1,15 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// REQUIRES: modules-build
|
||||
|
||||
// WARNING: This test was generated by 'generate_private_header_tests.py'
|
||||
// and should not be edited manually.
|
||||
|
||||
// expected-error@*:* {{use of private header from outside its module: '__filesystem/file_status.h'}}
|
||||
#include <__filesystem/file_status.h>
|
||||
@ -0,0 +1,15 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// REQUIRES: modules-build
|
||||
|
||||
// WARNING: This test was generated by 'generate_private_header_tests.py'
|
||||
// and should not be edited manually.
|
||||
|
||||
// expected-error@*:* {{use of private header from outside its module: '__filesystem/file_time_type.h'}}
|
||||
#include <__filesystem/file_time_type.h>
|
||||
@ -0,0 +1,15 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// REQUIRES: modules-build
|
||||
|
||||
// WARNING: This test was generated by 'generate_private_header_tests.py'
|
||||
// and should not be edited manually.
|
||||
|
||||
// expected-error@*:* {{use of private header from outside its module: '__filesystem/file_type.h'}}
|
||||
#include <__filesystem/file_type.h>
|
||||
@ -0,0 +1,15 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// REQUIRES: modules-build
|
||||
|
||||
// WARNING: This test was generated by 'generate_private_header_tests.py'
|
||||
// and should not be edited manually.
|
||||
|
||||
// expected-error@*:* {{use of private header from outside its module: '__filesystem/filesystem_error.h'}}
|
||||
#include <__filesystem/filesystem_error.h>
|
||||
@ -0,0 +1,15 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// REQUIRES: modules-build
|
||||
|
||||
// WARNING: This test was generated by 'generate_private_header_tests.py'
|
||||
// and should not be edited manually.
|
||||
|
||||
// expected-error@*:* {{use of private header from outside its module: '__filesystem/operations.h'}}
|
||||
#include <__filesystem/operations.h>
|
||||
@ -0,0 +1,15 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// REQUIRES: modules-build
|
||||
|
||||
// WARNING: This test was generated by 'generate_private_header_tests.py'
|
||||
// and should not be edited manually.
|
||||
|
||||
// expected-error@*:* {{use of private header from outside its module: '__filesystem/path.h'}}
|
||||
#include <__filesystem/path.h>
|
||||
@ -0,0 +1,15 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// REQUIRES: modules-build
|
||||
|
||||
// WARNING: This test was generated by 'generate_private_header_tests.py'
|
||||
// and should not be edited manually.
|
||||
|
||||
// expected-error@*:* {{use of private header from outside its module: '__filesystem/path_iterator.h'}}
|
||||
#include <__filesystem/path_iterator.h>
|
||||
@ -0,0 +1,15 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// REQUIRES: modules-build
|
||||
|
||||
// WARNING: This test was generated by 'generate_private_header_tests.py'
|
||||
// and should not be edited manually.
|
||||
|
||||
// expected-error@*:* {{use of private header from outside its module: '__filesystem/perm_options.h'}}
|
||||
#include <__filesystem/perm_options.h>
|
||||
@ -0,0 +1,15 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// REQUIRES: modules-build
|
||||
|
||||
// WARNING: This test was generated by 'generate_private_header_tests.py'
|
||||
// and should not be edited manually.
|
||||
|
||||
// expected-error@*:* {{use of private header from outside its module: '__filesystem/perms.h'}}
|
||||
#include <__filesystem/perms.h>
|
||||
@ -0,0 +1,15 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// REQUIRES: modules-build
|
||||
|
||||
// WARNING: This test was generated by 'generate_private_header_tests.py'
|
||||
// and should not be edited manually.
|
||||
|
||||
// expected-error@*:* {{use of private header from outside its module: '__filesystem/recursive_directory_iterator.h'}}
|
||||
#include <__filesystem/recursive_directory_iterator.h>
|
||||
@ -0,0 +1,15 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// REQUIRES: modules-build
|
||||
|
||||
// WARNING: This test was generated by 'generate_private_header_tests.py'
|
||||
// and should not be edited manually.
|
||||
|
||||
// expected-error@*:* {{use of private header from outside its module: '__filesystem/space_info.h'}}
|
||||
#include <__filesystem/space_info.h>
|
||||
@ -0,0 +1,15 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// REQUIRES: modules-build
|
||||
|
||||
// WARNING: This test was generated by 'generate_private_header_tests.py'
|
||||
// and should not be edited manually.
|
||||
|
||||
// expected-error@*:* {{use of private header from outside its module: '__filesystem/u8path.h'}}
|
||||
#include <__filesystem/u8path.h>
|
||||
Loading…
Reference in New Issue
Block a user