experimental::filesystem::v1 Namespace Reference

Classes
class	_Directory_iterator
struct	_Path_cvt
struct	_Path_cvt< _Outchar, _Outchar, _Outtraits, _Outalloc >
struct	_Path_cvt< char, char16_t, _Outtraits, _Outalloc >
struct	_Path_cvt< char, char32_t, _Outtraits, _Outalloc >
struct	_Path_cvt< char, char8_t, char_traits< char >, allocator< char > >
struct	_Path_cvt< char, wchar_t, _Outtraits, _Outalloc >
struct	_Path_cvt< char16_t, char, _Outtraits, _Outalloc >
struct	_Path_cvt< char32_t, char, _Outtraits, _Outalloc >
struct	_Path_cvt< char32_t, wchar_t, _Outtraits, _Outalloc >
struct	_Path_cvt< char8_t, char, _Outtraits, _Outalloc >
struct	_Path_cvt< char8_t, wchar_t, _Outtraits, _Outalloc >
struct	_Path_cvt< wchar_t, char, _Outtraits, _Outalloc >
struct	_Path_cvt< wchar_t, char32_t, _Outtraits, _Outalloc >
struct	_Path_cvt< wchar_t, char8_t, char_traits< char >, allocator< char > >
class	_Path_iterator
class	directory_entry
class	file_status
class	filesystem_error
class	path
class	recursive_directory_iterator
struct	space_info

Typedefs
typedef wchar_t	_Pchar
typedef file_type	_File_type
typedef copy_options	_Copy_options
typedef directory_options	_Directory_options
typedef perms	_Perms
typedef chrono::system_clock::time_point	file_time_type
typedef _Directory_iterator< true_type >	directory_iterator

Enumerations
enum	file_type {   file_type::not_found = -1, file_type::none, file_type::regular, file_type::directory,   file_type::symlink, file_type::block, file_type::character, file_type::fifo,   file_type::socket, file_type::unknown }
enum	copy_options {   copy_options::none = 0, copy_options::skip_existing = 1, copy_options::overwrite_existing = 2, copy_options::update_existing = 4,   copy_options::recursive = 8, copy_options::copy_symlinks = 16, copy_options::skip_symlinks = 32, copy_options::directories_only = 64,   copy_options::create_symlinks = 128, copy_options::create_hard_links = 256, copy_options::_Unspecified_recursion_prevention_tag = 512 }
enum	directory_options { directory_options::none = 0, directory_options::follow_directory_symlink }
enum	perms {   perms::none = 0, perms::owner_read = 0400, perms::owner_write = 0200, perms::owner_exec = 0100,   perms::owner_all = 0700, perms::group_read = 040, perms::group_write = 020, perms::group_exec = 010,   perms::group_all = 070, perms::others_read = 04, perms::others_write = 02, perms::others_exec = 01,   perms::others_all = 07, perms::all = 0777, perms::set_uid = 04000, perms::set_gid = 02000,   perms::sticky_bit = 01000, perms::mask = 07777, perms::unknown = 0xFFFF, perms::add_perms = 0x10000,   perms::remove_perms = 0x20000, perms::resolve_symlinks = 0x40000 }

Functions
_FS_DLL void *__CLRCALL_PURE_OR_CDECL	_Open_dir (wchar_t(&)[_MAX_FILESYS_NAME], const wchar_t *, int &, _File_type &)
_FS_DLL wchar_t *__CLRCALL_PURE_OR_CDECL	_Read_dir (wchar_t(&)[_MAX_FILESYS_NAME], void *, _File_type &)
_FS_DLL void __CLRCALL_PURE_OR_CDECL	_Close_dir (void *)
_FS_DLL bool __CLRCALL_PURE_OR_CDECL	_Current_get (wchar_t(&)[_MAX_FILESYS_NAME])
_FS_DLL bool __CLRCALL_PURE_OR_CDECL	_Current_set (const wchar_t *)
_FS_DLL wchar_t *__CLRCALL_PURE_OR_CDECL	_Symlink_get (wchar_t(&)[_MAX_FILESYS_NAME], const wchar_t *)
_FS_DLL wchar_t *__CLRCALL_PURE_OR_CDECL	_Temp_get (wchar_t(&)[_MAX_FILESYS_NAME])
_FS_DLL int __CLRCALL_PURE_OR_CDECL	_Make_dir (const wchar_t *, const wchar_t *)
_FS_DLL bool __CLRCALL_PURE_OR_CDECL	_Remove_dir (const wchar_t *)
_FS_DLL _File_type __CLRCALL_PURE_OR_CDECL	_Stat (const wchar_t *, _Perms *)
_FS_DLL _File_type __CLRCALL_PURE_OR_CDECL	_Lstat (const wchar_t *, _Perms *)
_FS_DLL uintmax_t __CLRCALL_PURE_OR_CDECL	_File_size (const wchar_t *)
_FS_DLL uintmax_t __CLRCALL_PURE_OR_CDECL	_Hard_links (const wchar_t *)
_FS_DLL int64_t __CLRCALL_PURE_OR_CDECL	_Last_write_time (const wchar_t *)
_FS_DLL int __CLRCALL_PURE_OR_CDECL	_Set_last_write_time (const wchar_t *, int64_t)
_FS_DLL space_info __CLRCALL_PURE_OR_CDECL	_Statvfs (const wchar_t *)
_FS_DLL int __CLRCALL_PURE_OR_CDECL	_Equivalent (const wchar_t *, const wchar_t *)
_FS_DLL int __CLRCALL_PURE_OR_CDECL	_Link (const wchar_t *, const wchar_t *)
_FS_DLL int __CLRCALL_PURE_OR_CDECL	_Symlink (const wchar_t *, const wchar_t *)
_FS_DLL int __CLRCALL_PURE_OR_CDECL	_Rename (const wchar_t *, const wchar_t *)
_FS_DLL int __CLRCALL_PURE_OR_CDECL	_Resize (const wchar_t *, uintmax_t)
_FS_DLL int __CLRCALL_PURE_OR_CDECL	_Unlink (const wchar_t *)
_FS_DLL int __CLRCALL_PURE_OR_CDECL	_Copy_file (const wchar_t *, const wchar_t *)
_FS_DLL int __CLRCALL_PURE_OR_CDECL	_Chmod (const wchar_t *, _Perms)
_FS_DLL int __CLRCALL_PURE_OR_CDECL	_To_byte (const wchar_t *, char *)
_FS_DLL int __CLRCALL_PURE_OR_CDECL	_To_wide (const char *, wchar_t *)
path	operator/ (const path &, const path &)
path	_Absolute (const path &, const path &, error_code &)
void	_Canonicalize_string_only (path &, const path &)
path	canonical (const path &, error_code &)
path	canonical (const path &, const path &, error_code &)
void	copy (const path &, const path &)
void	copy (const path &, const path &, error_code &) _NOEXCEPT
void	copy (const path &, const path &, _Copy_options)
void	copy (const path &, const path &, _Copy_options, error_code &) _NOEXCEPT
bool	copy_file (const path &, const path &, _Copy_options=copy_options::none)
bool	copy_file (const path &, const path &, error_code &) _NOEXCEPT
bool	copy_file (const path &, const path &, _Copy_options, error_code &) _NOEXCEPT
void	copy_symlink (const path &, const path &)
void	copy_symlink (const path &, const path &, error_code &) _NOEXCEPT
bool	create_directories (const path &)
bool	create_directories (const path &, error_code &) _NOEXCEPT
bool	create_directory (const path &)
bool	create_directory (const path &, error_code &) _NOEXCEPT
bool	create_directory (const path &, const path &)
bool	create_directory (const path &, const path &, error_code &) _NOEXCEPT
void	create_directory_symlink (const path &, const path &)
void	create_directory_symlink (const path &, const path &, error_code &) _NOEXCEPT
void	create_hard_link (const path &, const path &)
void	create_hard_link (const path &, const path &, error_code &) _NOEXCEPT
void	create_symlink (const path &, const path &)
void	create_symlink (const path &, const path &, error_code &) _NOEXCEPT
path	current_path ()
path	current_path (error_code &)
void	current_path (const path &)
void	current_path (const path &, error_code &) _NOEXCEPT
bool	equivalent (const path &, const path &)
bool	equivalent (const path &, const path &, error_code &) _NOEXCEPT
bool	exists (file_status) _NOEXCEPT
bool	exists (const path &)
bool	exists (const path &, error_code &) _NOEXCEPT
uintmax_t	file_size (const path &)
uintmax_t	file_size (const path &, error_code &) _NOEXCEPT
uintmax_t	hard_link_count (const path &)
uintmax_t	hard_link_count (const path &, error_code &) _NOEXCEPT
bool	is_block_file (file_status) _NOEXCEPT
bool	is_block_file (const path &)
bool	is_block_file (const path &, error_code &) _NOEXCEPT
bool	is_character_file (file_status) _NOEXCEPT
bool	is_character_file (const path &)
bool	is_character_file (const path &, error_code &) _NOEXCEPT
bool	is_directory (file_status) _NOEXCEPT
bool	is_directory (const path &)
bool	is_directory (const path &, error_code &) _NOEXCEPT
bool	is_empty (const path &)
bool	is_empty (const path &, error_code &) _NOEXCEPT
bool	is_fifo (file_status) _NOEXCEPT
bool	is_fifo (const path &)
bool	is_fifo (const path &, error_code &) _NOEXCEPT
bool	is_other (file_status) _NOEXCEPT
bool	is_other (const path &)
bool	is_other (const path &, error_code &) _NOEXCEPT
bool	is_regular_file (file_status) _NOEXCEPT
bool	is_regular_file (const path &)
bool	is_regular_file (const path &, error_code &) _NOEXCEPT
bool	is_socket (file_status) _NOEXCEPT
bool	is_socket (const path &)
bool	is_socket (const path &, error_code &) _NOEXCEPT
bool	is_symlink (file_status) _NOEXCEPT
bool	is_symlink (const path &)
bool	is_symlink (const path &, error_code &) _NOEXCEPT
file_time_type	last_write_time (const path &, error_code &) _NOEXCEPT
file_time_type	last_write_time (const path &)
void	last_write_time (const path &, file_time_type, error_code &) _NOEXCEPT
void	last_write_time (const path &, file_time_type)
void	permissions (const path &, _Perms)
void	permissions (const path &, _Perms, error_code &) _NOEXCEPT
path	read_symlink (const path &)
path	read_symlink (const path &, error_code &)
bool	remove (const path &)
bool	remove (const path &, error_code &) _NOEXCEPT
uintmax_t	remove_all (const path &)
uintmax_t	remove_all (const path &, error_code &) _NOEXCEPT
void	rename (const path &, const path &)
void	rename (const path &, const path &, error_code &) _NOEXCEPT
void	resize_file (const path &, uintmax_t)
void	resize_file (const path &, uintmax_t, error_code &) _NOEXCEPT
space_info	space (const path &)
space_info	space (const path &, error_code &) _NOEXCEPT
file_status	status (const path &)
file_status	status (const path &, error_code &) _NOEXCEPT
bool	status_known (file_status) _NOEXCEPT
file_status	symlink_status (const path &)
file_status	symlink_status (const path &, error_code &) _NOEXCEPT
path	system_complete (const path &)
path	system_complete (const path &, error_code &)
path	temp_directory_path ()
path	temp_directory_path (error_code &)
void	swap (path &_Left, path &_Right) _NOEXCEPT
size_t	hash_value (const path &_Path) _NOEXCEPT
bool	operator== (const path &_Left, const path &_Right) _NOEXCEPT
bool	operator!= (const path &_Left, const path &_Right) _NOEXCEPT
bool	operator< (const path &_Left, const path &_Right) _NOEXCEPT
bool	operator<= (const path &_Left, const path &_Right) _NOEXCEPT
bool	operator> (const path &_Left, const path &_Right) _NOEXCEPT
bool	operator>= (const path &_Left, const path &_Right) _NOEXCEPT
template<class _Elem , class _Traits >
basic_ostream< _Elem, _Traits > &	operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const path &_Path)
template<class _Elem , class _Traits >
basic_istream< _Elem, _Traits > &	operator>> (basic_istream< _Elem, _Traits > &_Istr, path &_Path)
template<class _InIt , class = typename enable_if<_Is_iterator<_InIt>::value, void>::type>
path	u8path (_InIt _First, _InIt _Last)
template<class _InIt , class = typename enable_if<_Is_iterator<_InIt>::value, void>::type>
path	u8path (_InIt _First)
template<class _Traits , class _Alloc >
path	u8path (const basic_string< char, _Traits, _Alloc > &_Str)
template<class _Prefix_directory >
bool	operator== (const _Directory_iterator< _Prefix_directory > &_Left, const _Directory_iterator< _Prefix_directory > &_Right)
template<class _Prefix_directory >
bool	operator!= (const _Directory_iterator< _Prefix_directory > &_Left, const _Directory_iterator< _Prefix_directory > &_Right)
const directory_iterator &	begin (const directory_iterator &_Iter) _NOEXCEPT
directory_iterator	end (const directory_iterator &) _NOEXCEPT
bool	operator== (const recursive_directory_iterator &_Left, const recursive_directory_iterator &_Right)
bool	operator!= (const recursive_directory_iterator &_Left, const recursive_directory_iterator &_Right)
const recursive_directory_iterator &	begin (const recursive_directory_iterator &_Iter) _NOEXCEPT
recursive_directory_iterator	end (const recursive_directory_iterator &) _NOEXCEPT
path	absolute (const path &_Path, const path &_Base=current_path())
path	canonical (const path &_Path, const path &_Base=current_path())
bool	_Copy_options_indicate_recursive_copy (_Copy_options _Opts)
bool	_Remove_all (const path &_Path, uintmax_t &_Ans, error_code &_Code) _NOEXCEPT

Typedef Documentation

typedef copy_options experimental::filesystem::v1::_Copy_options

typedef directory_options experimental::filesystem::v1::_Directory_options

typedef file_type experimental::filesystem::v1::_File_type

typedef wchar_t experimental::filesystem::v1::_Pchar

typedef perms experimental::filesystem::v1::_Perms

typedef _Directory_iterator<true_type> experimental::filesystem::v1::directory_iterator

typedef chrono::system_clock::time_point experimental::filesystem::v1::file_time_type

Enumeration Type Documentation

enum experimental::filesystem::v1::copy_options

strong

Enumerator
none
skip_existing
overwrite_existing
update_existing
recursive
copy_symlinks
skip_symlinks
directories_only
create_symlinks
create_hard_links
_Unspecified_recursion_prevention_tag

                        {   // names for copy options
    none = 0,
    skip_existing = 1, overwrite_existing = 2, update_existing = 4,
    recursive = 8,
    copy_symlinks = 16, skip_symlinks = 32,
    directories_only = 64, create_symlinks = 128, create_hard_links = 256,
    _Unspecified_recursion_prevention_tag = 512
    };

enum experimental::filesystem::v1::directory_options

strong

Enumerator
none
follow_directory_symlink

                             {  // names for directory options
    none = 0, follow_directory_symlink
    };

enum experimental::filesystem::v1::file_type

strong

Enumerator
not_found
none
regular
directory
symlink
block
character
fifo
socket
unknown

                     {  // names for file types
    not_found = -1, none, regular, directory, symlink,
    block, character, fifo, socket, unknown
    };

enum experimental::filesystem::v1::perms

strong

Enumerator
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
add_perms
remove_perms
resolve_symlinks

                 {  // names for permissions
    none = 0,
    owner_read = 0400,  // S_IRUSR
    owner_write = 0200, // S_IWUSR
    owner_exec = 0100,  // S_IXUSR
    owner_all = 0700,   // S_IRWXU
    group_read = 040,   // S_IRGRP
    group_write = 020,  // S_IWGRP
    group_exec = 010,   // S_IXGRP
    group_all = 070,    // S_IRWXG
    others_read = 04,   // S_IROTH
    others_write = 02,  // S_IWOTH
    others_exec = 01,   // S_IXOTH
    others_all = 07,    // S_IRWXO
    all = 0777,
    set_uid = 04000,    // S_ISUID
    set_gid = 02000,    // S_ISGID
    sticky_bit = 01000, // S_ISVTX
    mask = 07777,
    unknown = 0xFFFF,
    add_perms = 0x10000,
    remove_perms = 0x20000,
    resolve_symlinks = 0x40000
    };

Function Documentation

path experimental::filesystem::v1::_Absolute ( const path &  _Path, const path &  _Base, error_code &  _Code  )

inline

    {   // make absolute path from _Path and directory _Base; errors in _Code
    _Code = error_code();
    bool _Path_has_root_name = _Path.has_root_name();
    bool _Path_has_root_directory = _Path.has_root_directory();
    if (_Path_has_root_name && _Path_has_root_directory)
        return (_Path); // fine as is

    path _Current = current_path(_Code);
    if (_Code != error_code())
        return (path());
    path _Abs_base = _Absolute(_Base, _Current, _Code);
    if (_Code != error_code())
        return (path());

    if (_Path_has_root_name)
        {   // insert _Base
        return (_Path.root_name()
            / _Abs_base.root_directory()
            / _Abs_base.relative_path()
            / _Path.relative_path());
        }
    else
        if (_Path_has_root_directory)
            return (_Abs_base.root_name()
                / _Path);   // prepend root name of base
        else
            return (_Abs_base
                / _Path);   // prepend absolute name of base
    }

void experimental::filesystem::v1::_Canonicalize_string_only ( path &  _Canon_path, const path &  _Abs_path  )

inline

    {   // transform absolute path _Abs_path, removing .s, and ..s, using string
        // manipulations (rather than platform support)
    vector<path> _Components;
    path::const_iterator _Abs_path_next = _Abs_path.begin();
    const path::const_iterator _Abs_path_end = _Abs_path.end();
    // This is safe because we have already made the path absolute
    _Canon_path /= *_Abs_path_next; // root_name
    ++_Abs_path_next;
    _Canon_path /= *_Abs_path_next; // root_directory
    ++_Abs_path_next;
    for (; _Abs_path_next != _Abs_path_end; ++_Abs_path_next)
        {
        const auto _Cstr = _Abs_path_next->c_str();
        if (_Cstr[0] == _FS_PERIOD)
            {
            if (_Cstr[1] == static_cast<path::value_type>(0))
                continue; // consume "."
            else if (_Cstr[1] == _FS_PERIOD
                && _Cstr[2] == static_cast<path::value_type>(0))
                {
                // If no parent is found to remove with .., ignore ..
                // (that is, C:\..\..\..\Meow canonicalizes to C:\Meow)
                if (!_Components.empty())
                    _Components.pop_back();

                continue; // consume ".."
                }
            }

        _Components.push_back(*_Abs_path_next);
        }

    for (const auto& _Component : _Components)
        _Canon_path /= _Component;
    }

_FS_DLL int __CLRCALL_PURE_OR_CDECL experimental::filesystem::v1::_Chmod	(	const wchar_t *	,
		_Perms
	)

_FS_DLL void __CLRCALL_PURE_OR_CDECL experimental::filesystem::v1::_Close_dir

(

void *

)

_FS_DLL int __CLRCALL_PURE_OR_CDECL experimental::filesystem::v1::_Copy_file	(	const wchar_t *	,
		const wchar_t *
	)

bool experimental::filesystem::v1::_Copy_options_indicate_recursive_copy ( _Copy_options  _Opts )

inline

    {   // Checks a _Copy_options for whether copy should call itself recursively
    if (_Opts == _Copy_options::none)
        // This supports "copying a directory" as copying the directory and
        // files therein but not subdirectories.
        return (true);
    if ((_Opts & _Copy_options::recursive) != _Copy_options::none)
        return (true);
    return (false);
    }

_FS_DLL bool __CLRCALL_PURE_OR_CDECL experimental::filesystem::v1::_Current_get

(

wchar_t(&)

[_MAX_FILESYS_NAME]

)

_FS_DLL bool __CLRCALL_PURE_OR_CDECL experimental::filesystem::v1::_Current_set

(

const wchar_t *

)

_FS_DLL int __CLRCALL_PURE_OR_CDECL experimental::filesystem::v1::_Equivalent	(	const wchar_t *	,
		const wchar_t *
	)

_FS_DLL uintmax_t __CLRCALL_PURE_OR_CDECL experimental::filesystem::v1::_File_size

(

const wchar_t *

)

_FS_DLL uintmax_t __CLRCALL_PURE_OR_CDECL experimental::filesystem::v1::_Hard_links

(

const wchar_t *

)

_FS_DLL int64_t __CLRCALL_PURE_OR_CDECL experimental::filesystem::v1::_Last_write_time

(

const wchar_t *

)

_FS_DLL int __CLRCALL_PURE_OR_CDECL experimental::filesystem::v1::_Link	(	const wchar_t *	,
		const wchar_t *
	)

_FS_DLL _File_type __CLRCALL_PURE_OR_CDECL experimental::filesystem::v1::_Lstat	(	const wchar_t *	,
		_Perms *
	)

_FS_DLL int __CLRCALL_PURE_OR_CDECL experimental::filesystem::v1::_Make_dir	(	const wchar_t *	,
		const wchar_t *
	)

_FS_DLL void* __CLRCALL_PURE_OR_CDECL experimental::filesystem::v1::_Open_dir	(	wchar_t(&)	[_MAX_FILESYS_NAME],
		const wchar_t *	,
		int &	,
		_File_type &
	)

_FS_DLL wchar_t* __CLRCALL_PURE_OR_CDECL experimental::filesystem::v1::_Read_dir	(	wchar_t(&)	[_MAX_FILESYS_NAME],
		void *	,
		_File_type &
	)

bool experimental::filesystem::v1::_Remove_all ( const path &  _Path, uintmax_t &  _Ans, error_code &  _Code  )

inline

    {   // recursively remove a file or directory, count removed files
    _Code = error_code();
    if (is_directory(_Path))
        {   // empty and remove a directory
        typedef _Directory_iterator<false_type> _Myit;
        _Myit _Last;

        for (; ; )
            {   // remove a directory entry
            _Myit _First(_Path);
            if (_First == _Last)
                break;
            if (!_Remove_all(_Path / _First->path(), _Ans, _Code))
                return (false);
            }
        if (_Remove_dir(_Path.c_str()))
            return (true);
        else
            {   // couldn't remove emptied directory, report it
            _Code = make_error_code(errc::operation_not_permitted);
            return (false);
            }
        }
    else if (!remove(_Path, _Code))
        return (false);
    else
        {   // file remove succeeded, count it
        ++_Ans;
        return (true);
        }
    }

_FS_DLL bool __CLRCALL_PURE_OR_CDECL experimental::filesystem::v1::_Remove_dir

(

const wchar_t *

)

_FS_DLL int __CLRCALL_PURE_OR_CDECL experimental::filesystem::v1::_Rename	(	const wchar_t *	,
		const wchar_t *
	)

_FS_DLL int __CLRCALL_PURE_OR_CDECL experimental::filesystem::v1::_Resize	(	const wchar_t *	,
		uintmax_t
	)

_FS_DLL int __CLRCALL_PURE_OR_CDECL experimental::filesystem::v1::_Set_last_write_time	(	const wchar_t *	,
		int64_t
	)

_FS_DLL _File_type __CLRCALL_PURE_OR_CDECL experimental::filesystem::v1::_Stat	(	const wchar_t *	,
		_Perms *
	)

_FS_DLL space_info __CLRCALL_PURE_OR_CDECL experimental::filesystem::v1::_Statvfs

(

const wchar_t *

)

_FS_DLL int __CLRCALL_PURE_OR_CDECL experimental::filesystem::v1::_Symlink	(	const wchar_t *	,
		const wchar_t *
	)

_FS_DLL wchar_t* __CLRCALL_PURE_OR_CDECL experimental::filesystem::v1::_Symlink_get	(	wchar_t(&)	[_MAX_FILESYS_NAME],
		const wchar_t *
	)

_FS_DLL wchar_t* __CLRCALL_PURE_OR_CDECL experimental::filesystem::v1::_Temp_get

(

wchar_t(&)

[_MAX_FILESYS_NAME]

)

_FS_DLL int __CLRCALL_PURE_OR_CDECL experimental::filesystem::v1::_To_byte	(	const wchar_t *	,
		char *
	)

_FS_DLL int __CLRCALL_PURE_OR_CDECL experimental::filesystem::v1::_To_wide	(	const char *	,
		wchar_t *
	)

_FS_DLL int __CLRCALL_PURE_OR_CDECL experimental::filesystem::v1::_Unlink

(

const wchar_t *

)

path experimental::filesystem::v1::absolute ( const path &  _Path, const path &  _Base = current_path()  )

inline

    {   // make absolute path from _Path and directory _Base
    error_code _Code;
    path _Result = _Absolute(_Path, _Base, _Code);
    if (_Code != error_code())
        _THROW_NCEE(filesystem_error,
            "absolute(p1, p2): current_path() couldn't get current working directory");
    return (_Result);
    }

const directory_iterator& experimental::filesystem::v1::begin ( const directory_iterator &  _Iter )

inline

    {   // return begin directory_iterator for range-based for
    return (_Iter);
    }

const recursive_directory_iterator& experimental::filesystem::v1::begin ( const recursive_directory_iterator &  _Iter )

inline

    {   // return begin recursive_directory_iterator for range-based for
    return (_Iter);
    }

path experimental::filesystem::v1::canonical ( const path &  _Path, error_code &  _Code  )

inline

    {   // make absolute path from _Path with no ., .., or symlink
    path _Current = current_path(_Code);
    if (_Code != error_code())
        return (path());
    return (canonical(_Path, _Current, _Code));
    }

path experimental::filesystem::v1::canonical ( const path &  _Path, const path &  _Base, error_code &  _Code  )

inline

    {   // make absolute path from _Path, _Base with no ".", "..", symlink
    _Code = error_code();
    path _Canon_path; // NRVO this variable
    path _Abs_path = _Absolute(_Path, _Base, _Code);
    if (_Code != error_code())
        return (_Canon_path);

    if (_Abs_path.native().size() >= _MAX_FILESYS_NAME)
        {
        _Code = make_error_code(errc::filename_too_long);
        return (_Canon_path);
        }

    _Canonicalize_string_only(_Canon_path, _Abs_path);
    return (_Canon_path);
    }

path experimental::filesystem::v1::canonical ( const path &  _Path, const path &  _Base = current_path()  )

inline

    {   // make absolute path from _Path, _Base with no ., .., or symlink
    error_code _Code;
    path _Ans = canonical(_Path, _Base, _Code);

    if (_Code != error_code())
        _THROW_NCEE(filesystem_error,
            "canonical(p1, p2): invalid arguments");
    return (_Ans);
    }

void experimental::filesystem::v1::copy ( const path &  _Oldpval, const path &  _Newpval  )

inline

    {   // copy _Oldpval to _Newpval, general
    error_code _Code;

    copy(_Oldpval, _Newpval, _Copy_options::none, _Code);
    if (_Code != error_code())
        _THROW_NCEE(filesystem_error,
            "copy(p1, p2): invalid arguments");
    }

void experimental::filesystem::v1::copy ( const path &  _Oldpval, const path &  _Newpval, error_code &  _Code  )

inline

    {   // copy _Oldpval to _Newpval, general
    copy(_Oldpval, _Newpval, _Copy_options::none, _Code);
    }

void experimental::filesystem::v1::copy ( const path &  _Oldpval, const path &  _Newpval, _Copy_options  _Opts  )

inline

    {   // copy _Oldpval to _Newpval, general
    error_code _Code;

    copy(_Oldpval, _Newpval, _Opts, _Code);
    if (_Code != error_code())
        _THROW_NCEE(filesystem_error,
            "copy(p1, p2, options): invalid arguments");
    }

void experimental::filesystem::v1::copy ( const path &  _Oldpval, const path &  _Newpval, _Copy_options  _Opts, error_code &  _Code  )

inline

    {   // copy _Oldpval to _Newpval, general
    file_status _Oldstat;
    file_status _Newstat;
    error_code _Code2;

    _Code = error_code();
    if ((_Opts & _Copy_options::create_symlinks) != _Copy_options::none
        || (_Opts & _Copy_options::skip_symlinks) != _Copy_options::none)
        {   // get symlink status
        _Oldstat = symlink_status(_Oldpval);
        _Newstat = symlink_status(_Newpval);
        }
    else
        {   // get file status
        _Oldstat = status(_Oldpval);
        _Newstat = status(_Newpval);
        }
    if (!exists(_Oldstat)
        || equivalent(_Oldpval, _Newpval, _Code2)
        || is_other(_Oldstat)
        || is_other(_Newstat)
        || (is_directory(_Oldstat) && is_regular_file(_Newstat)))
        _Code = make_error_code(errc::operation_not_permitted);
    else if (is_symlink(_Oldstat))
        if ((_Opts & _Copy_options::skip_symlinks) != _Copy_options::none)
            ;
        else if (!exists(_Newstat)
            && (_Opts & _Copy_options::copy_symlinks) != _Copy_options::none)
            copy_symlink(_Oldpval, _Newpval, _Code);
        else
            _Code = make_error_code(errc::operation_not_permitted);
    else if (is_regular_file(_Oldstat))
        if ((_Opts & _Copy_options::directories_only) != _Copy_options::none)
            ;
        else if ((_Opts & _Copy_options::create_symlinks)
            != _Copy_options::none)
            create_symlink(_Oldpval, _Newpval, _Code);
        else if ((_Opts & _Copy_options::create_hard_links)
            != _Copy_options::none)
            create_hard_link(_Oldpval, _Newpval, _Code);
        else if (is_directory(_Newstat))
            copy_file(_Oldpval, _Newpval / _Oldpval.filename(), _Opts, _Code);
        else
            copy_file(_Oldpval, _Newpval, _Opts, _Code);
    else if (is_directory(_Oldstat)
        && _Copy_options_indicate_recursive_copy(_Opts))
        {   // copy directory recursively
        if (!exists(_Newpval) && !create_directory(_Newpval, _Code) && !_Code)
            _Code = make_error_code(errc::operation_not_permitted);
        for (directory_iterator _Next(_Oldpval), _End;
            _Code == error_code() && _Next != _End; ++_Next)
            copy(_Next->path(),
                _Newpval / _Next->path().filename(),
                _Opts | _Copy_options::_Unspecified_recursion_prevention_tag,
                _Code);
        }
    }

bool experimental::filesystem::v1::copy_file ( const path &  _Oldpval, const path &  _Newpval, _Copy_options  _Opt = copy_options::none  )

inline

    {   // copy _Oldpval to _Newpval
    error_code _Code;
    bool _Ans = copy_file(_Oldpval, _Newpval, _Opt, _Code);
    if (_Code != error_code())
        _THROW_NCEE(filesystem_error,
            "copy_file(p1, p2, options): invalid arguments");
    return (_Ans);
    }

bool experimental::filesystem::v1::copy_file ( const path &  _Oldpval, const path &  _Newpval, error_code &  _Code  )

inline

    {   // copy _Oldpval to _Newpval
    return (copy_file(_Oldpval, _Newpval, copy_options::none, _Code));
    }

bool experimental::filesystem::v1::copy_file ( const path &  _Oldpval, const path &  _Newpval, _Copy_options  _Opt, error_code &  _Code  )

inline

    {   // copy _Oldpval to _Newpval
    _Opt &= (copy_options::skip_existing
        | copy_options::overwrite_existing
        | copy_options::update_existing);
    bool _Exists = exists(_Newpval);
    bool _Ans = false;
    file_time_type _Oldtime;
    file_time_type _Newtime;

    _Code = error_code();
    if (_Exists && (_Opt == copy_options::none
        || equivalent(_Oldpval, _Newpval, _Code)))
        _Code = make_error_code(errc::file_exists);
    else if (_Code)
        ;   // equivalent() failed, report error
    else if (!_Exists
        || (_Opt & copy_options::overwrite_existing) != copy_options::none
        || ((_Opt & copy_options::update_existing) != copy_options::none
            && ((void)(_Oldtime = last_write_time(_Oldpval, _Code)), !_Code)
            && ((void)(_Newtime = last_write_time(_Newpval, _Code)), !_Code)
            && _Newtime < _Oldtime))
        {   // ok to overwrite, if necessary
        if (_Copy_file(_Oldpval.c_str(), _Newpval.c_str()) == 0)
            _Ans = true;
        else
            _Code = make_error_code(errc::operation_not_permitted);
        }
    return (_Ans);
    }

void experimental::filesystem::v1::copy_symlink ( const path &  _Oldpval, const path &  _Newpval  )

inline

    {   // copy symlink, file or directory
    error_code _Code;
    copy_symlink(_Oldpval, _Newpval, _Code);
    if (_Code != error_code())
        _THROW_NCEE(filesystem_error,
            "copy_symlink(p1, p2): invalid arguments");
    }

void experimental::filesystem::v1::copy_symlink ( const path &  _Oldpval, const path &  _Newpval, error_code &  _Code  )

inline

    {   // copy symlink, file or directory
    if (is_directory(_Oldpval))
        create_directory_symlink(_Oldpval, _Newpval, _Code);
    else
        create_symlink(_Oldpval, _Newpval, _Code);
    }

bool experimental::filesystem::v1::create_directories ( const path &  _Path )

inline

    {   // create directories chain
    error_code _Code;
    bool _Ans = create_directories(_Path, _Code);
    if (_Code != error_code())
        _THROW_NCEE(filesystem_error,
            "create_directories(p): invalid argument");
    return (_Ans);
    }

bool experimental::filesystem::v1::create_directories ( const path &  _Path, error_code &  _Code  )

inline

    {   // create directory chain
    _Code = error_code();
    if (_Path.empty())
        return (false);
    else if (!exists(_Path))
        {   // recursively create parent directories, then current
        create_directories(_Path.parent_path(), _Code);
        if (_Code)
            return (false); // report error

        create_directory(_Path, _Code);
        if (_Code)
            return (false); // report error

        return (true);
        }
    else if (is_directory(_Path))
        return (false); // directory already there
    else
        {   // report bad argument
        _Code = make_error_code(errc::operation_not_permitted);
        return (false);
        }
    }

bool experimental::filesystem::v1::create_directory ( const path &  _Path )

inline

    {   // create a directory
    error_code _Code;
    bool _Ans = create_directory(_Path, _Code);

    if (_Code != error_code())
        _THROW_NCEE(filesystem_error,
            "create_directory(p): invalid argument");
    return (_Ans);
    }

bool experimental::filesystem::v1::create_directory ( const path &  _Path, error_code &  _Code  )

inline

    {   // create a directory
    int _Ans = _Make_dir(_Path.c_str(), 0);

    _Code = error_code();
    if (_Ans < 0)
        _Code = make_error_code(errc::operation_not_permitted);
    return (0 < _Ans);
    }

bool experimental::filesystem::v1::create_directory ( const path &  _Path, const path &  _Attrs  )

inline

    {   // create a directory, copying attributes
    error_code _Code;
    bool _Ans = create_directory(_Path, _Attrs, _Code);

    if (_Code != error_code())
        _THROW_NCEE(filesystem_error,
            "create_directory(p1, p2): invalid arguments");
    return (_Ans);
    }

bool experimental::filesystem::v1::create_directory ( const path &  _Path, const path &  _Attrs, error_code &  _Code  )

inline

    {   // create a directory, copying attributes
    int _Ans = _Make_dir(_Path.c_str(), _Attrs.c_str());

    _Code = error_code();
    if (_Ans < 0)
        _Code = make_error_code(errc::operation_not_permitted);
    return (0 < _Ans);
    }

void experimental::filesystem::v1::create_directory_symlink ( const path &  _Oldpval, const path &  _Newpval  )

inline

    {   // symlink directory _Newpval to _Oldpval
    error_code _Code;
    create_directory_symlink(_Oldpval, _Newpval, _Code);
    if (_Code != error_code())
        _THROW_NCEE(filesystem_error,
            "create_directory_symlink(p1, p2): invalid arguments");
    }

void experimental::filesystem::v1::create_directory_symlink ( const path &  _Oldpval, const path &  _Newpval, error_code &  _Code  )

inline

    {   // symlink directory_Newpval to _Oldpval (NB: SAME AS FILE)
    int _Ans = _Symlink(_Oldpval.c_str(), _Newpval.c_str());

    _Code = error_code();
    if (_Ans != 0)
        _Code = error_code(_Ans, _STD system_category());
    }

void experimental::filesystem::v1::create_hard_link ( const path &  _Oldpval, const path &  _Newpval  )

inline

    {   // hard link _Newpval to _Oldpval
    error_code _Code;
    create_hard_link(_Oldpval, _Newpval, _Code);
    if (_Code != error_code())
        _THROW_NCEE(filesystem_error,
            "create_hard_link(p1, p2): invalid arguments");
    }

void experimental::filesystem::v1::create_hard_link ( const path &  _Oldpval, const path &  _Newpval, error_code &  _Code  )

inline

    {   // hard link _Newpval to _Oldpval
    int _Ans = _Link(_Oldpval.c_str(), _Newpval.c_str());

    _Code = error_code();
    if (_Ans != 0)
        _Code = error_code(_Ans, _STD system_category());
    }

void experimental::filesystem::v1::create_symlink ( const path &  _Oldpval, const path &  _Newpval  )

inline

    {   // symlink _Newpval to _Oldpval
    error_code _Code;
    create_symlink(_Oldpval, _Newpval, _Code);
    if (_Code != error_code())
        _THROW_NCEE(filesystem_error,
            "create_symlink(p1, p2): invalid arguments");
    }

void experimental::filesystem::v1::create_symlink ( const path &  _Oldpval, const path &  _Newpval, error_code &  _Code  )

inline

    {   // symlink _Newpval to _Oldpval
    int _Ans = _Symlink(_Oldpval.c_str(), _Newpval.c_str());

    _Code = error_code();
    if (_Ans != 0)
        _Code = error_code(_Ans, _STD system_category());
    }

path experimental::filesystem::v1::current_path ( )

inline

    {   // get current working directory
    error_code _Code;
    path _Ans = current_path(_Code);
    if (_Code != error_code())
        _THROW_NCEE(filesystem_error,
            "current_path(): can't get current working directory");
    return (_Ans);
    }

path experimental::filesystem::v1::current_path ( error_code &  _Code )

inline

    {   // get current working directory
    _Code = error_code();
    _Pchar _Dest[_MAX_FILESYS_NAME];
    if (!_Current_get(_Dest))
        {   // report error
        _Code = make_error_code(errc::operation_not_permitted);
        return (path());
        }
    return (path(_Dest));
    }

void experimental::filesystem::v1::current_path ( const path &  _Path )

inline

    {   // set current working directory
    if (!_Current_set(_Path.c_str()))
        _THROW_NCEE(filesystem_error,
            "current_path(p): invalid argument");
    }

void experimental::filesystem::v1::current_path ( const path &  _Path, error_code &  _Code  )

inline

    {   // set current working directory
    _Code = error_code();
    if (!_Current_set(_Path.c_str()))
        _Code = make_error_code(errc::no_such_file_or_directory);
    }

directory_iterator experimental::filesystem::v1::end ( const directory_iterator &  )

inline

    {   // return end directory_iterator for range-based for
    return (directory_iterator());
    }

recursive_directory_iterator experimental::filesystem::v1::end ( const recursive_directory_iterator &  )

inline

    {   // return end recursive_directory_iterator for range-based for
    return (recursive_directory_iterator());
    }

bool experimental::filesystem::v1::equivalent ( const path &  _Path1, const path &  _Path2  )

inline

    {   // test if paths designate same file
    error_code _Code;
    int _Ans = equivalent(_Path1, _Path2, _Code);

    if (_Code != error_code())
        _THROW_NCEE(filesystem_error,
            "equivalent(p1, p2): invalid arguments");
    return (0 < _Ans);
    }

bool experimental::filesystem::v1::equivalent ( const path &  _Path1, const path &  _Path2, error_code &  _Code  )

inline

    {   // test if paths designate same file
    int _Ans = _Equivalent(_Path1.c_str(), _Path2.c_str());

    _Code = error_code();
    if (_Ans < 0)
        _Code = make_error_code(errc::operation_not_permitted);
    return (0 < _Ans);
    }

bool experimental::filesystem::v1::exists ( file_status  _Stat )

inline

    {   // test if path exists
    return (status_known(_Stat)
        && _Stat.type() != _File_type::not_found);
    }

bool experimental::filesystem::v1::exists ( const path &  _Path )

inline

    {   // test if path exists
    return (exists(status(_Path)));
    }

bool experimental::filesystem::v1::exists ( const path &  _Path, error_code &  _Code  )

inline

    {   // test if path exists
    _Code = error_code();
    return (exists(status(_Path)));
    }

uintmax_t experimental::filesystem::v1::file_size ( const path &  _Path )

inline

    {   // get file size
    error_code _Code;
    uintmax_t _Ans = file_size(_Path, _Code);
    if (_Code != error_code())
        _THROW_NCEE(filesystem_error,
            "file_size(p): invalid argument");
    return (_Ans);
    }

uintmax_t experimental::filesystem::v1::file_size ( const path &  _Path, error_code &  _Code  )

inline

    {   // get file size
    uintmax_t _Ans = (uintmax_t)-1;
    file_status _Stat = status(_Path);

    _Code = error_code();
    if (exists(_Stat) && is_regular_file(_Stat))
        _Ans = _File_size(_Path.c_str());
    if (_Ans == (uintmax_t)-1)
        _Code = make_error_code(errc::operation_not_permitted);
    return (_Ans);
    }

uintmax_t experimental::filesystem::v1::hard_link_count ( const path &  _Path )

inline

    {   // get hard link count
    error_code _Code;
    uintmax_t _Ans = hard_link_count(_Path, _Code);
    if (_Code != error_code())
        _THROW_NCEE(filesystem_error,
            "hard_link_count(p): invalid argument");
    return (_Ans);
    }

uintmax_t experimental::filesystem::v1::hard_link_count ( const path &  _Path, error_code &  _Code  )

inline

    {   // get hard link count
    _Code = error_code();
    uintmax_t _Ans = _Hard_links(_Path.c_str());
    if (_Ans == (uintmax_t)-1)
        _Code = make_error_code(errc::operation_not_permitted);
    return (_Ans);
    }

size_t experimental::filesystem::v1::hash_value ( const path &  _Path )

inline

    {   // get hash value for path
    return (hash<path::string_type>()(_Path.native()));
    }

bool experimental::filesystem::v1::is_block_file ( file_status  _Stat )

inline

    {   // test for block file
    return (_Stat.type() == _File_type::block);
    }

bool experimental::filesystem::v1::is_block_file ( const path &  _Path )

inline

    {   // test for block file
    return (is_block_file(status(_Path)));
    }

bool experimental::filesystem::v1::is_block_file ( const path &  _Path, error_code &  _Code  )

inline

    {   // test for block file
    return (is_block_file(status(_Path, _Code)));
    }

bool experimental::filesystem::v1::is_character_file ( file_status  _Stat )

inline

    {   // test for character file
    return (_Stat.type() == _File_type::character);
    }

bool experimental::filesystem::v1::is_character_file ( const path &  _Path )

inline

    {   // test for character file
    return (is_character_file(status(_Path)));
    }

bool experimental::filesystem::v1::is_character_file ( const path &  _Path, error_code &  _Code  )

inline

    {   // test for character file
    return (is_character_file(status(_Path, _Code)));
    }

bool experimental::filesystem::v1::is_directory ( file_status  _Stat )

inline

    {   // test for directory
    return (_Stat.type() == _File_type::directory);
    }

bool experimental::filesystem::v1::is_directory ( const path &  _Path )

inline

    {   // test for directory
    return (is_directory(status(_Path)));
    }

bool experimental::filesystem::v1::is_directory ( const path &  _Path, error_code &  _Code  )

inline

    {   // test for directory
    return (is_directory(status(_Path, _Code)));
    }

bool experimental::filesystem::v1::is_empty ( const path &  _Path )

inline

    {   // test if path is empty
    error_code _Code;
    bool _Ans = _FSPFX is_empty(_Path, _Code);
    if (_Code != error_code())
        _THROW_NCEE(filesystem_error,
            "is_empty(p): invalid argument");
    return (_Ans);
    }

bool experimental::filesystem::v1::is_empty ( const path &  _Path, error_code &  _Code  )

inline

    {   // test if path is empty
    file_status _Stat = status(_Path);

    _Code = error_code();
    if (is_directory(_Stat))
        return (directory_iterator(_Path)
            == directory_iterator());
    else
        return (file_size(_Path, _Code) == 0);
    }

bool experimental::filesystem::v1::is_fifo ( file_status  _Stat )

inline

    {   // test for fifo file
    return (_Stat.type() == _File_type::fifo);
    }

bool experimental::filesystem::v1::is_fifo ( const path &  _Path )

inline

    {   // test for fifo file
    return (is_fifo(status(_Path)));
    }

bool experimental::filesystem::v1::is_fifo ( const path &  _Path, error_code &  _Code  )

inline

    {   // test for fifo file
    return (is_fifo(status(_Path, _Code)));
    }

bool experimental::filesystem::v1::is_other ( file_status  _Stat )

inline

    {   // test if path is other file type
    return (exists(_Stat)
        && !is_regular_file(_Stat)
        && !is_directory(_Stat)
        && !is_symlink(_Stat));
    }

bool experimental::filesystem::v1::is_other ( const path &  _Path )

inline

    {   // test if path is other file type
    return (is_other(status(_Path)));
    }

bool experimental::filesystem::v1::is_other ( const path &  _Path, error_code &  _Code  )

inline

    {   // test for other file types
    return (is_other(status(_Path, _Code)));
    }

bool experimental::filesystem::v1::is_regular_file ( file_status  _Stat )

inline

    {   // test for regular file
    return (_Stat.type() == _File_type::regular);
    }

bool experimental::filesystem::v1::is_regular_file ( const path &  _Path )

inline

    {   // test for regular file
    return (is_regular_file(status(_Path)));
    }

bool experimental::filesystem::v1::is_regular_file ( const path &  _Path, error_code &  _Code  )

inline

    {   // test for regular file
    return (is_regular_file(status(_Path, _Code)));
    }

bool experimental::filesystem::v1::is_socket ( file_status  _Stat )

inline

    {   // test for socket file
    return (_Stat.type() == _File_type::socket);
    }

bool experimental::filesystem::v1::is_socket ( const path &  _Path )

inline

    {   // test for socket file
    return (is_socket(status(_Path)));
    }

bool experimental::filesystem::v1::is_socket ( const path &  _Path, error_code &  _Code  )

inline

    {   // test for socket file
    return (is_socket(status(_Path, _Code)));
    }

bool experimental::filesystem::v1::is_symlink ( file_status  _Stat )

inline

    {   // test for symlink
    return (_Stat.type() == _File_type::symlink);
    }

bool experimental::filesystem::v1::is_symlink ( const path &  _Path )

inline

    {   // test for symlink
    return (is_symlink(status(_Path)));
    }

bool experimental::filesystem::v1::is_symlink ( const path &  _Path, error_code &  _Code  )

inline

    {   // test for symlink
    return (is_symlink(status(_Path, _Code)));
    }

file_time_type experimental::filesystem::v1::last_write_time ( const path &  _Path, error_code &  _Code  )

inline

    {   // get last write time
    int64_t _Ticks = _Last_write_time(_Path.c_str());

    _Code = error_code();
    if (_Ticks == -1)
        {   // report error
        _Code = make_error_code(errc::operation_not_permitted);
        return ((file_time_type::min)());
        }
    return (file_time_type(chrono::system_clock::duration(_Ticks)));
    }

file_time_type experimental::filesystem::v1::last_write_time ( const path &  _Path )

inline

    {   // get last write time
    error_code _Code;
    file_time_type _Ans = last_write_time(_Path, _Code);
    if (_Code != error_code())
        _THROW_NCEE(filesystem_error,
            "last_write_time(p): invalid argument");
    return (_Ans);
    }

void experimental::filesystem::v1::last_write_time ( const path &  _Path, file_time_type  _Newtime, error_code &  _Code  )

inline

    {   // set last write time
    _Code = error_code();
    if (_Set_last_write_time(_Path.c_str(),
        _Newtime.time_since_epoch().count()) == 0)
        _Code = make_error_code(errc::operation_not_permitted);
    }

void experimental::filesystem::v1::last_write_time ( const path &  _Path, file_time_type  _Newtime  )

inline

    {   // set last write time
    error_code _Code;
    last_write_time(_Path, _Newtime, _Code);
    if (_Code != error_code())
        _THROW_NCEE(filesystem_error,
            "last_write_time(p, new_time): invalid arguments");
    }

bool experimental::filesystem::v1::operator!= ( const path &  _Left, const path &  _Right  )

inline

    {   // test for path inequality
    return (!(_Left == _Right));
    }

template<class _Prefix_directory >

bool experimental::filesystem::v1::operator!= ( const _Directory_iterator< _Prefix_directory > &  _Left, const _Directory_iterator< _Prefix_directory > &  _Right  )

inline

    {   // test for _Directory_iterator inequality
    return (!(_Left == _Right));
    }

bool experimental::filesystem::v1::operator!= ( const recursive_directory_iterator &  _Left, const recursive_directory_iterator &  _Right  )

inline

    {   // test for recursive_directory_iterator inequality
    return (!(_Left == _Right));
    }

path experimental::filesystem::v1::operator/ ( const path &  _Left, const path &  _Right  )

inline

    {   // concatenate paths
    path _Ans = _Left;
    return (_Ans /= _Right);
    }

bool experimental::filesystem::v1::operator< ( const path &  _Left, const path &  _Right  )

inline

    {   // test if _Left < _Right
    return (_Left.native() < _Right.native());
    }

template<class _Elem , class _Traits >

basic_ostream<_Elem, _Traits>& experimental::filesystem::v1::operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr, const path &  _Path  )

inline

    {   // insert a path
    return (_Ostr << _Path.string<_Elem, _Traits, allocator<_Elem> >());
    }

bool experimental::filesystem::v1::operator<= ( const path &  _Left, const path &  _Right  )

inline

    {   // test if _Left <= _Right
    return (!(_Right < _Left));
    }

bool experimental::filesystem::v1::operator== ( const path &  _Left, const path &  _Right  )

inline

    {   // test for path equality
    return (_Left.native() == _Right.native());
    }

template<class _Prefix_directory >

bool experimental::filesystem::v1::operator== ( const _Directory_iterator< _Prefix_directory > &  _Left, const _Directory_iterator< _Prefix_directory > &  _Right  )

inline

    {   // test for _Directory_iterator equality
    return (_Left._Equal(_Right));
    }

bool experimental::filesystem::v1::operator== ( const recursive_directory_iterator &  _Left, const recursive_directory_iterator &  _Right  )

inline

    {   // test for recursive_directory_iterator equality
    return (_Left._Equal(_Right));
    }

bool experimental::filesystem::v1::operator> ( const path &  _Left, const path &  _Right  )

inline

    {   // test if _Left > _Right
    return (_Right < _Left);
    }

bool experimental::filesystem::v1::operator>= ( const path &  _Left, const path &  _Right  )

inline

    {   // test if _Left >= _Right
    return (!(_Left < _Right));
    }

template<class _Elem , class _Traits >

basic_istream<_Elem, _Traits>& experimental::filesystem::v1::operator>> ( basic_istream< _Elem, _Traits > &  _Istr, path &  _Path  )

inline

    {   // extract a path
    basic_string<_Elem, _Traits> _Str;
    _Istr >> _Str;
    _Path = _Str;
    return (_Istr);
    }

void experimental::filesystem::v1::permissions ( const path &  _Path, _Perms  _Mask  )

inline

    {   // set access permissions
    error_code _Code;
    permissions(_Path, _Mask, _Code);
    if (_Code != error_code())
        _THROW_NCEE(filesystem_error,
            "permissions(p, prms): can't set permissions");
    }

void experimental::filesystem::v1::permissions ( const path &  _Path, _Perms  _Mask, error_code &  _Code  )

inline

    {   // set access permissions
    _Perms _Todo = _Mask;
    _Mask = (_Perms)(_Mask & perms::mask);
    bool _Ok = true;

    _Code = error_code();
    if ((_Todo & perms::add_perms) == perms::none)
        if ((_Todo & perms::remove_perms) == perms::none)
            ;
        else
            _Mask = (_Perms)(status(_Path).permissions() & ~_Mask);
    else
        if ((_Todo & perms::remove_perms) == perms::none)
            _Mask = (_Perms)(_Mask | status(_Path).permissions());
        else
            _Ok = false;
    if (!_Ok || _Chmod(_Path.c_str(), _Mask) != 0)
        _Code = make_error_code(errc::operation_not_permitted);
    }

path experimental::filesystem::v1::read_symlink ( const path &  _Path )

inline

    {   // read symbolic link
    error_code _Code;
    path _Sympath = read_symlink(_Path, _Code);
    if (_Code != error_code())
        _THROW_NCEE(filesystem_error,
            "read_symlink(p): can't read symbolic link");
    return (_Sympath);
    }

path experimental::filesystem::v1::read_symlink ( const path &  _Path, error_code &  _Code  )

inline

    {   // read symbolic link
    _Code = error_code();
    if (!is_symlink(_Path))
        {   // report error
        _Code = make_error_code(errc::no_such_file_or_directory);
        return (path());
        }
    _Pchar _Dest[_MAX_FILESYS_NAME];
    return (path(_Symlink_get(_Dest, _Path.c_str())));
    }

bool experimental::filesystem::v1::remove ( const path &  _Path )

inline

    {   // remove a file
    error_code _Code;
    bool _Ans = remove(_Path, _Code);

    if (_Code != error_code())
        _THROW_NCEE(filesystem_error,
            "remove(p): invalid argument");
    return (_Ans);
    }

bool experimental::filesystem::v1::remove ( const path &  _Path, error_code &  _Code  )

inline

    {   // remove a file
    _Code = error_code();
    if (!exists(symlink_status(_Path)))
        return (false);
    else if (is_directory(_Path, _Code))
        if (_Remove_dir(_Path.c_str()))
            return (true);
        else
            {   // couldn't remove emptied directory, report it
            _Code = make_error_code(errc::operation_not_permitted);
            return (false);
            }
    else
        {   // file exists, try to remove it
        bool _Ans = _Unlink(_Path.c_str()) == 0;
        if (!_Ans)
            _Code = make_error_code(errc::operation_not_permitted);
        return (_Ans);
        }
    }

uintmax_t experimental::filesystem::v1::remove_all ( const path &  _Path )

inline

    {   // recursively remove a directory
    error_code _Code;
    uintmax_t _Ans = remove_all(_Path, _Code);
    if (_Code != error_code())
        _THROW_NCEE(filesystem_error,
            "remove_all(p): invalid argument");
    return (_Ans);
    }

uintmax_t experimental::filesystem::v1::remove_all ( const path &  _Path, error_code &  _Code  )

inline

    {   // recursively remove a directory
    uintmax_t _Ans = 0;
    _Remove_all(_Path, _Ans, _Code);
    if (_Code)
        return (static_cast<uintmax_t>(-1));
    return (_Ans);
    }

void experimental::filesystem::v1::rename ( const path &  _Oldpval, const path &  _Newpval  )

inline

    {   // rename _Oldpval as _Newpval
    error_code _Code;
    rename(_Oldpval, _Newpval, _Code);
    if (_Code != error_code())
        _THROW_NCEE(filesystem_error,
            "rename(p1, p2): invalid arguments");
    }

void experimental::filesystem::v1::rename ( const path &  _Oldpval, const path &  _Newpval, error_code &  _Code  )

inline

    {   // rename _Oldpval as _Newpval
    _Code = error_code();

    if (!exists(_Oldpval))
        {   // fail immediately without modifying the filesystem
        _Code = make_error_code(errc::operation_not_permitted);
        return;
        }

    if (exists(_Newpval))
        {   // both exist; there can be only one
        if (equivalent(_Oldpval, _Newpval, _Code) || _Code != error_code())
            return; // successful no-op, or report equivalent() failure

        if (!remove(_Newpval, _Code))
            return; // report remove() failure
        }

    if (_Rename(_Oldpval.c_str(), _Newpval.c_str()) != 0)
        _Code = make_error_code(errc::operation_not_permitted);
    }

void experimental::filesystem::v1::resize_file ( const path &  _Path, uintmax_t  _Newsize  )

inline

    {   // change file size
    error_code _Code;
    resize_file(_Path, _Newsize, _Code);
    if (_Code != error_code())
        _THROW_NCEE(filesystem_error,
            "resize_file(p, n): invalid arguments");
    };

void experimental::filesystem::v1::resize_file ( const path &  _Path, uintmax_t  _Newsize, error_code &  _Code  )

inline

    {   // change file size
    int _Errno = _Resize(_Path.c_str(), _Newsize);

    _Code = error_code();
    if (_Errno != 0)
        _Code = error_code(_Errno, _STD system_category());
    }

space_info experimental::filesystem::v1::space ( const path &  _Path )

inline

    {   // get space information for volume
    return (_Statvfs(_Path.c_str()));
    }

space_info experimental::filesystem::v1::space ( const path &  _Path, error_code &  _Code  )

inline

    {   // get space information for volume
    _Code = error_code();
    return (_Statvfs(_Path.c_str()));
    }

file_status experimental::filesystem::v1::status ( const path &  _Path )

inline

    {   // get file status
    error_code _Code;
    return (status(_Path, _Code));
    }

file_status experimental::filesystem::v1::status ( const path &  _Path, error_code &  _Code  )

inline

    {   // get file status
    _Code = error_code();
    _Perms _Mode;
    _File_type _Ftype = _Stat(_Path.c_str(), &_Mode);
    return (file_status(_Ftype, _Mode));
    }

bool experimental::filesystem::v1::status_known ( file_status  _Stat )

inline

    {   // test if status known
    return (_Stat.type() != _File_type::unknown);
    }

void experimental::filesystem::v1::swap ( path &  _Left, path &  _Right  )

inline

    {   // swap two paths
    _Left.swap(_Right);
    }

file_status experimental::filesystem::v1::symlink_status ( const path &  _Path )

inline

    {   // get symlink file status
    error_code _Code;
    return (symlink_status(_Path, _Code));
    }

file_status experimental::filesystem::v1::symlink_status ( const path &  _Path, error_code &  _Code  )

inline

    {   // get symlink file status
    _Perms _Mode;
    _File_type _Ftype = _Lstat(_Path.c_str(), &_Mode);

    _Code = error_code();
    return (file_status(_Ftype, _Mode));
    }

path experimental::filesystem::v1::system_complete ( const path &  _Path )

inline

    {   // get completely specified path
    if (_Path.is_absolute())
        return (_Path);
    path _Curpath = current_path();
    if (!_Path.has_root_name() || _Path.root_name() == _Curpath.root_name())
        return (absolute(_Path));
    current_path(_Path.root_name());    // switch to new device
    path _Altpath = current_path(); // get its full current path
    current_path(_Curpath); // revert to original current path
    return (_Altpath / _Path.relative_path());
    }

path experimental::filesystem::v1::system_complete ( const path &  _Path, error_code &  _Code  )

inline

    {   // get completely specified path
    _Code = error_code();

    path _Ans;

    _TRY_BEGIN
    _Ans = system_complete(_Path);
    _CATCH_ALL
    _Code = make_error_code(errc::operation_not_permitted);
    return (path());
    _CATCH_END

    return (_Ans);
    }

path experimental::filesystem::v1::temp_directory_path ( )

inline

    {   // get temporary directory
    error_code _Code;
    path _Ans = temp_directory_path(_Code);
    if (_Code != error_code())
        _THROW_NCEE(filesystem_error,
            "temp_directory_path(): can't find temp directory");
    return (_Ans);
    }

path experimental::filesystem::v1::temp_directory_path ( error_code &  _Code )

inline

    {   // get temporary directory
    _Pchar _Dest[_MAX_FILESYS_NAME];
    _Temp_get(_Dest);
    path _Ans(_Dest);

    _Code = error_code();
    if (!exists(_Ans) || !is_directory(_Ans))
        {   // report error
        _Code = make_error_code(errc::no_such_file_or_directory);
        return (path());
        }
    return (_Ans);
    }

template<class _InIt , class = typename enable_if<_Is_iterator<_InIt>::value, void>::type>

path experimental::filesystem::v1::u8path ( _InIt  _First, _InIt  _Last  )

inline

    {   // make path from [_First, _Last) UTF8, given iterators
    string _Str(_First, _Last);
    path::string_type _Str_out;
    return (path(_Path_cvt<char8_t, _Pchar>::
        _Cvt(_Str_out, _Str.c_str(), _Str.size())));
    }

template<class _InIt , class = typename enable_if<_Is_iterator<_InIt>::value, void>::type>

path experimental::filesystem::v1::u8path ( _InIt  _First )

inline

    {   // make path from NTBS UTF8, given iterator
    string _Str;
    for (; *_First != '\0'; ++_First)
        _Str += *_First;
    path::string_type _Str_out;
    return (path(_Path_cvt<char8_t, _Pchar>::
        _Cvt(_Str_out, _Str.c_str(), _Str.size())));
    }

template<class _Traits , class _Alloc >

path experimental::filesystem::v1::u8path ( const basic_string< char, _Traits, _Alloc > &  _Str )

inline

    {   // make path from arbitrary char string UTF8
    path::string_type _Str_out;
    return (path(_Path_cvt<char8_t, _Pchar>::
        _Cvt(_Str_out, _Str.c_str(), _Str.size())));
    }