/* Copyright (C) 2022 Povilas Kanapickas <povilas@radix.lt>

This file is part of cppreference-doc

This work is licensed under the Creative Commons Attribution-ShareAlike 3.0

Unported License. To view a copy of this license, visit

http://creativecommons.org/licenses/by-sa/3.0/ or send a letter to Creative

Commons, 444 Castro Street, Suite 900, Mountain View, California, 94041, USA.

Permission is granted to copy, distribute and/or modify this document

under the terms of the GNU Free Documentation License, Version 1.3 or

any later version published by the Free Software Foundation; with no

Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.

*/

#ifndef CPPREFERENCE_FILESYSTEM_H

#define CPPREFERENCE_FILESYSTEM_H

#if CPPREFERENCE_STDVER >= 2017

#include <chrono>

#include <compare>

#include <string>

#include <locale>

#include <cstdint>

namespace std::filesystem {

enum class file_type {

none,

not_found,

regular,

directory,

symlink,

block,

character,

fifo,

socket,

unknown

};

enum class perms {

none,

owner_read,

owner_write,

owner_exec,

owner_all,

group_read,

group_write,

group_exec,

group_all,

others_read,

others_write,

others_exec,

others_all,

all,

set_uid,

set_gid,

sticky_bit,

mask,

unknown,

};

enum class perm_options {

replace,

add,

remove,

nofollow

};

enum class copy_options {

none,

skip_existing,

overwrite_existing,

update_existing,

recursive,

copy_symlinks,

skip_symlinks,

directories_only,

create_symlinks,

create_hard_links,

};

enum class directory_options {

none,

follow_directory_symlink,

skip_permission_denied,

};

class path {

public:

using value_type = char; // SIMPLIFIED, actually implementation-dependent

using string_type = basic_string<value_type>;

static constexpr value_type preferred_separator = '/';

enum format {

native_format,

generic_format,

auto_format

};

path() noexcept;

path(const path& other);

path(path&& other) noexcept;

path(string_type&& source, format fmt = auto_format);

template<class Source>

path(const Source& source, format fmt = auto_format);

template<class InputIt>

path(InputIt first, InputIt last, format fmt = auto_format);

template<class Source>

path(const Source& source, const locale& loc, format fmt = auto_format);

template<class InputIt>

path(InputIt first, InputIt last, const locale& loc, format fmt = auto_format);

~path();

path& operator=(const path& other);

path& operator=(path&& other) noexcept;

path& operator=(string_type&& source);

path& assign(string_type&& source);

template<class Source>

path& operator=(const Source& source);

template<class Source>

path& assign(const Source& source);

template<class InputIt>

path& assign(InputIt first, InputIt last);

path& operator/=(const path& p);

template<class Source>

path& operator/=(const Source& source);

template<class Source>

path& append(const Source& source);

template<class InputIt>

path& append(InputIt first, InputIt last);

path& operator+=(const path& x);

path& operator+=(const string_type& x);

path& operator+=(basic_string_view<value_type> x);

path& operator+=(const value_type* x);

path& operator+=(value_type x);

template<class Source>

path& operator+=(const Source& x);

template<class ECharT>

path& operator+=(ECharT x);

template<class Source>

path& concat(const Source& x);

template<class InputIt>

path& concat(InputIt first, InputIt last);

void clear() noexcept;

path& make_preferred();

path& remove_filename();

path& replace_filename(const path& replacement);

path& replace_extension(const path& replacement = path());

void swap(path& rhs) noexcept;

const string_type& native() const noexcept;

const value_type* c_str() const noexcept;

operator string_type() const;

template<class CharT, class Traits = char_traits<CharT>,

class Allocator = allocator<CharT>>

basic_string<CharT, Traits, Allocator>

string(const Allocator& a = Allocator()) const;

std::string string() const;

std::wstring wstring() const;

#if CPPREFERENCE_STDVER >= 2020

std::u8string u8string() const;

#endif

std::u16string u16string() const;

std::u32string u32string() const;

// generic format observers

template<class ECharT, class Traits = char_traits<ECharT>,

class Allocator = allocator<ECharT>>

basic_string<ECharT, Traits, Allocator>

generic_string(const Allocator& a = Allocator()) const;

std::string generic_string() const;

std::wstring generic_wstring() const;

#if CPPREFERENCE_STDVER >= 2020

std::u8string generic_u8string() const;

#endif

std::u16string generic_u16string() const;

std::u32string generic_u32string() const;

int compare(const path& p) const noexcept;

int compare(const string_type& s) const;

int compare(basic_string_view<value_type> s) const;

int compare(const value_type* s) const;

path root_name() const;

path root_directory() const;

path root_path() const;

path relative_path() const;

path parent_path() const;

path filename() const;

path stem() const;

path extension() const;

[[nodiscard]] bool empty() const noexcept;

bool has_root_name() const;

bool has_root_directory() const;

bool has_root_path() const;

bool has_relative_path() const;

bool has_parent_path() const;

bool has_filename() const;

bool has_stem() const;

bool has_extension() const;

bool is_absolute() const;

bool is_relative() const;

path lexically_normal() const;

path lexically_relative(const path& base) const;

path lexically_proximate(const path& base) const;

class iterator;

using const_iterator = iterator;

iterator begin() const;

iterator end() const;

#if CPPREFERENCE_STDVER >= 2020

friend strong_ordering operator<=>(const path& lhs, const path& rhs) noexcept;

#else

friend bool operator==(const path& lhs, const path& rhs) noexcept;

friend bool operator!=(const path& lhs, const path& rhs) noexcept;

friend bool operator>(const path& lhs, const path& rhs) noexcept;

friend bool operator>=(const path& lhs, const path& rhs) noexcept;

friend bool operator<(const path& lhs, const path& rhs) noexcept;

friend bool operator<=(const path& lhs, const path& rhs) noexcept;

#endif

friend path operator/(const path& lhs, const path& rhs);

};

void swap(path& lhs, path& rhs) noexcept;

size_t hash_value(const path& p) noexcept;

// deprecated

template<class Source>

path u8path(const Source& source);

template<class InputIt>

path u8path(InputIt first, InputIt last);

template<class CharT, class Traits>

basic_ostream<CharT, Traits>&

operator<<(basic_ostream<CharT, Traits>& os, const path& p);

template<class CharT, class Traits>

basic_istream<CharT, Traits>&

operator>>(basic_istream<CharT, Traits>& is, path& p);

class filesystem_error : public system_error {

public:

filesystem_error(const string& what, error_code ec);

filesystem_error(const string& what, const path& path1, error_code ec);

filesystem_error(const string& what_arg, const path& path1, const path& path2, error_code ec);

const path& path1() const noexcept;

const path& path2() const noexcept;

const char* what() const noexcept override;

};

class file_status {

public:

file_status() noexcept;

explicit file_status(file_type ft,

perms prms = perms::unknown) noexcept;

file_status(const file_status& other) noexcept = default;

file_status(file_status&& other) noexcept = default;

~file_status();

file_status& operator=(const file_status& other) noexcept = default;

file_status& operator=(file_status&& other) noexcept = default;

void type(file_type ft) noexcept;

void permissions(perms prms) noexcept;

file_type type() const noexcept;

perms permissions() const noexcept;

};

bool operator==(const file_status& lhs, const file_status& rhs) noexcept;

using file_time_type = chrono::time_point<chrono::file_clock>;

class directory_entry {

public:

// constructors and destructor

directory_entry() noexcept = default;

directory_entry(const directory_entry& other) = default;

directory_entry(directory_entry&& other) noexcept = default;

explicit directory_entry(const filesystem::path& p);

directory_entry(const filesystem::path& p, error_code& ec);

~directory_entry();

directory_entry& operator=(const directory_entry&) = default;

directory_entry& operator=(directory_entry&&) noexcept = default;

void assign(const filesystem::path& p);

void assign(const filesystem::path& p, error_code& ec);

void replace_filename(const filesystem::path& p);

void replace_filename(const filesystem::path& p, error_code& ec);

void refresh();

void refresh(error_code& ec) noexcept;

const filesystem::path& path() const noexcept;

operator const filesystem::path&() const noexcept;

bool exists() const;

bool exists(error_code& ec) const noexcept;

bool is_block_file() const;

bool is_block_file(error_code& ec) const noexcept;

bool is_character_file() const;

bool is_character_file(error_code& ec) const noexcept;

bool is_directory() const;

bool is_directory(error_code& ec) const noexcept;

bool is_fifo() const;

bool is_fifo(error_code& ec) const noexcept;

bool is_other() const;

bool is_other(error_code& ec) const noexcept;

bool is_regular_file() const;

bool is_regular_file(error_code& ec) const noexcept;

bool is_socket() const;

bool is_socket(error_code& ec) const noexcept;

bool is_symlink() const;

bool is_symlink(error_code& ec) const noexcept;

uintmax_t file_size() const;

uintmax_t file_size(error_code& ec) const noexcept;

uintmax_t hard_link_count() const;

uintmax_t hard_link_count(error_code& ec) const noexcept;

file_time_type last_write_time() const;

file_time_type last_write_time(error_code& ec) const noexcept;

file_status status() const;

file_status status(error_code& ec) const noexcept;

file_status symlink_status() const;

file_status symlink_status(error_code& ec) const noexcept;

bool operator==(const directory_entry& rhs) const noexcept;

auto operator<=>const directory_entry& rhs) const noexcept = default;

};

template<class charT, class traits>

basic_ostream<charT, traits>&

operator<<(basic_ostream<charT, traits>& os, const directory_entry& d);

class directory_iterator {

public:

using iterator_category = input_iterator_tag;

using value_type = directory_entry;

using difference_type = ptrdiff_t;

using pointer = const directory_entry*;

using reference = const directory_entry&;

directory_iterator() noexcept;

explicit directory_iterator(const path& p);

directory_iterator(const path& p, directory_options options);

directory_iterator(const path& p, error_code& ec);

directory_iterator(const path& p, directory_options options, error_code& ec);

directory_iterator(const directory_iterator& other);

directory_iterator(directory_iterator&& other) noexcept;

~directory_iterator();

directory_iterator& operator=(const directory_iterator& other);

directory_iterator& operator=(directory_iterator&& other) noexcept;

const directory_entry& operator*() const;

const directory_entry* operator->() const;

directory_iterator& operator++();

directory_iterator& increment(error_code& ec);

};

directory_iterator begin(directory_iterator iter) noexcept;

directory_iterator end(directory_iterator) noexcept;

class recursive_directory_iterator {

public:

using iterator_category = input_iterator_tag;

using value_type = directory_entry;

using difference_type = ptrdiff_t;

using pointer = const directory_entry*;

using reference = const directory_entry&;

recursive_directory_iterator() noexcept;

explicit recursive_directory_iterator(const path& p);

recursive_directory_iterator(const path& p, directory_options options);

recursive_directory_iterator(const path& p, directory_options options, error_code& ec);

recursive_directory_iterator(const path& p, error_code& ec);

recursive_directory_iterator(const recursive_directory_iterator& other);

recursive_directory_iterator(recursive_directory_iterator&& other) noexcept;

~recursive_directory_iterator();

recursive_directory_iterator& operator=(const recursive_directory_iterator& other);

recursive_directory_iterator& operator=(recursive_directory_iterator&& other) noexcept;

directory_options options() const;

int depth() const;

bool recursion_pending() const;

const directory_entry& operator*() const;

const directory_entry* operator->() const;

recursive_directory_iterator& operator++();

recursive_directory_iterator& increment(error_code& ec);

void pop();

void pop(error_code& ec);

void disable_recursion_pending();

};

recursive_directory_iterator begin(recursive_directory_iterator iter) noexcept;

recursive_directory_iterator end(recursive_directory_iterator) noexcept;

struct space_info {

uintmax_t capacity;

uintmax_t free;

uintmax_t available;

friend bool operator==(const space_info&, const space_info&);

};

path absolute(const path& p);

path absolute(const path& p, error_code& ec);

path canonical(const path& p);

path canonical(const path& p, error_code& ec);

void copy(const path& from, const path& to);

void copy(const path& from, const path& to, error_code& ec);

void copy(const path& from, const path& to, copy_options options);

void copy(const path& from, const path& to, copy_options options,

error_code& ec);

bool copy_file(const path& from, const path& to);

bool copy_file(const path& from, const path& to, error_code& ec);

bool copy_file(const path& from, const path& to, copy_options option);

bool copy_file(const path& from, const path& to, copy_options option,

error_code& ec);

void copy_symlink(const path& existing_symlink, const path& new_symlink);

void copy_symlink(const path& existing_symlink, const path& new_symlink,

error_code& ec) noexcept;

bool create_directories(const path& p);

bool create_directories(const path& p, error_code& ec);

bool create_directory(const path& p);

bool create_directory(const path& p, error_code& ec) noexcept;

bool create_directory(const path& p, const path& attributes);

bool create_directory(const path& p, const path& attributes,

error_code& ec) noexcept;

void create_directory_symlink(const path& to, const path& new_symlink);

void create_directory_symlink(const path& to, const path& new_symlink,

error_code& ec) noexcept;

void create_hard_link(const path& to, const path& new_hard_link);

void create_hard_link(const path& to, const path& new_hard_link,

error_code& ec) noexcept;

void create_symlink(const path& to, const path& new_symlink);

void create_symlink(const path& to, const path& new_symlink,

error_code& ec) noexcept;

path current_path();

path current_path(error_code& ec);

void current_path(const path& p);

void current_path(const path& p, error_code& ec) noexcept;

bool equivalent(const path& p1, const path& p2);

bool equivalent(const path& p1, const path& p2, error_code& ec) noexcept;

bool exists(file_status s) noexcept;

bool exists(const path& p);

bool exists(const path& p, error_code& ec) noexcept;

uintmax_t file_size(const path& p);

uintmax_t file_size(const path& p, error_code& ec) noexcept;

uintmax_t hard_link_count(const path& p);

uintmax_t hard_link_count(const path& p, error_code& ec) noexcept;

bool is_block_file(file_status s) noexcept;

bool is_block_file(const path& p);

bool is_block_file(const path& p, error_code& ec) noexcept;

bool is_character_file(file_status s) noexcept;

bool is_character_file(const path& p);

bool is_character_file(const path& p, error_code& ec) noexcept;

bool is_directory(file_status s) noexcept;

bool is_directory(const path& p);

bool is_directory(const path& p, error_code& ec) noexcept;

bool is_empty(const path& p);

bool is_empty(const path& p, error_code& ec);

bool is_fifo(file_status s) noexcept;

bool is_fifo(const path& p);

bool is_fifo(const path& p, error_code& ec) noexcept;

bool is_other(file_status s) noexcept;

bool is_other(const path& p);

bool is_other(const path& p, error_code& ec) noexcept;

bool is_regular_file(file_status s) noexcept;

bool is_regular_file(const path& p);

bool is_regular_file(const path& p, error_code& ec) noexcept;

bool is_socket(file_status s) noexcept;

bool is_socket(const path& p);

bool is_socket(const path& p, error_code& ec) noexcept;

bool is_symlink(file_status s) noexcept;

bool is_symlink(const path& p);

bool is_symlink(const path& p, error_code& ec) noexcept;

file_time_type last_write_time(const path& p);

file_time_type last_write_time(const path& p, error_code& ec) noexcept;

void last_write_time(const path& p, file_time_type new_time);

void last_write_time(const path& p, file_time_type new_time,

error_code& ec) noexcept;

void permissions(const path& p, perms prms, perm_options opts=perm_options::replace);

void permissions(const path& p, perms prms, error_code& ec) noexcept;

void permissions(const path& p, perms prms, perm_options opts, error_code& ec);

path proximate(const path& p, error_code& ec);

path proximate(const path& p, const path& base = current_path());

path proximate(const path& p, const path& base, error_code& ec);

path read_symlink(const path& p);

path read_symlink(const path& p, error_code& ec);

path relative(const path& p, error_code& ec);

path relative(const path& p, const path& base = current_path());

path relative(const path& p, const path& base, error_code& ec);

bool remove(const path& p);

bool remove(const path& p, error_code& ec) noexcept;

uintmax_t remove_all(const path& p);

uintmax_t remove_all(const path& p, error_code& ec);

void rename(const path& from, const path& to);

void rename(const path& from, const path& to, error_code& ec) noexcept;

void resize_file(const path& p, uintmax_t size);

void resize_file(const path& p, uintmax_t size, error_code& ec) noexcept;

space_info space(const path& p);

space_info space(const path& p, error_code& ec) noexcept;

file_status status(const path& p);

file_status status(const path& p, error_code& ec) noexcept;

bool status_known(file_status s) noexcept;

file_status symlink_status(const path& p);

file_status symlink_status(const path& p, error_code& ec) noexcept;

path temp_directory_path();

path temp_directory_path(error_code& ec);

path weakly_canonical(const path& p);

path weakly_canonical(const path& p, error_code& ec);

} // namespace std::filesystem

#endif // if CPPREFERENCE_STDVER >= 2017

#endif // CPPREFERENCE_FILESYSTEM_H