tr2::sys Namespace Reference

Classes
struct	_Altslash
struct	_Altslash< path >
struct	_Altslash< wpath >
class	_Path_iterator
class	_Wrap_init_dir
class	basic_directory_entry
class	basic_directory_iterator
class	basic_filesystem_error
class	basic_path
class	basic_recursive_directory_iterator
struct	colon
struct	colon< path >
struct	colon< wpath >
struct	dot
struct	dot< path >
struct	dot< wpath >
class	file_status
struct	is_basic_path
struct	is_basic_path< path >
struct	is_basic_path< wpath >
struct	path_traits
struct	slash
struct	slash< path >
struct	slash< wpath >
struct	space_info
struct	wpath_traits

Typedefs
typedef basic_path< string, path_traits >	path
typedef basic_path< wstring, wpath_traits >	wpath
typedef basic_filesystem_error< path >	filesystem_error
typedef basic_filesystem_error< wpath >	wfilesystem_error
typedef basic_directory_entry< path >	directory_entry
typedef basic_directory_entry< wpath >	wdirectory_entry
typedef basic_directory_iterator< path >	directory_iterator
typedef basic_directory_iterator< wpath >	wdirectory_iterator
typedef basic_recursive_directory_iterator< path >	recursive_directory_iterator
typedef basic_recursive_directory_iterator< wpath >	wrecursive_directory_iterator
typedef copy_option	_Copy_option

Enumerations
enum	file_type {   status_unknown, file_not_found, regular_file, directory_file,   symlink_file, block_file, character_file, fifo_file,   socket_file, type_unknown }
enum	copy_option { copy_option::fail_if_exists, copy_option::overwrite_if_exists }

Functions
template<class _String , class _Traits >
void	swap (basic_path< _String, _Traits > &_Left, basic_path< _String, _Traits > &_Right)
template<class _String , class _Traits >
basic_path< _String, _Traits >	operator/ (const basic_path< _String, _Traits > &_Left, const basic_path< _String, _Traits > &_Right)
template<class _String , class _Traits >
bool	operator== (const basic_path< _String, _Traits > &_Left, const basic_path< _String, _Traits > &_Right)
template<class _String , class _Traits >
bool	operator!= (const basic_path< _String, _Traits > &_Left, const basic_path< _String, _Traits > &_Right)
template<class _String , class _Traits >
bool	operator< (const basic_path< _String, _Traits > &_Left, const basic_path< _String, _Traits > &_Right)
template<class _String , class _Traits >
bool	operator> (const basic_path< _String, _Traits > &_Left, const basic_path< _String, _Traits > &_Right)
template<class _String , class _Traits >
bool	operator<= (const basic_path< _String, _Traits > &_Left, const basic_path< _String, _Traits > &_Right)
template<class _String , class _Traits >
bool	operator>= (const basic_path< _String, _Traits > &_Left, const basic_path< _String, _Traits > &_Right)
template<class _String , class _Traits >
basic_ostream< typename _String::value_type, typename _String::traits_type > &	operator<< (basic_ostream< typename _String::value_type, typename _String::traits_type > &_Ostr, const basic_path< _String, _Traits > &_Pval)
template<class _String , class _Traits >
basic_istream< typename _String::value_type, typename _String::traits_type > &	operator>> (basic_istream< typename _String::value_type, typename _String::traits_type > &_Istr, basic_path< _String, _Traits > &_Pval)
_FS_DLL void *__CLRCALL_PURE_OR_CDECL	_Open_dir (char(&)[_MAX_FILESYS_NAME], const char *, int &, file_type &)
_FS_DLL char *__CLRCALL_PURE_OR_CDECL	_Read_dir (char(&)[_MAX_FILESYS_NAME], void *, file_type &)
_FS_DLL void __CLRCALL_PURE_OR_CDECL	_Close_dir (void *)
_FS_DLL char *__CLRCALL_PURE_OR_CDECL	_Current_get (char(&)[_MAX_FILESYS_NAME])
_FS_DLL bool __CLRCALL_PURE_OR_CDECL	_Current_set (const char *)
_FS_DLL int __CLRCALL_PURE_OR_CDECL	_Make_dir (const char *)
_FS_DLL bool __CLRCALL_PURE_OR_CDECL	_Remove_dir (const char *)
_FS_DLL file_type __CLRCALL_PURE_OR_CDECL	_Stat (const char *, int &)
_FS_DLL file_type __CLRCALL_PURE_OR_CDECL	_Lstat (const char *, int &)
_FS_DLL _ULonglong __CLRCALL_PURE_OR_CDECL	_File_size (const char *)
_FS_DLL time_t __CLRCALL_PURE_OR_CDECL	_Last_write_time (const char *)
_FS_DLL void __CLRCALL_PURE_OR_CDECL	_Last_write_time (const char *, time_t)
_FS_DLL space_info __CLRCALL_PURE_OR_CDECL	_Statvfs (const char *)
_FS_DLL int __CLRCALL_PURE_OR_CDECL	_Equivalent (const char *, const char *)
_FS_DLL int __CLRCALL_PURE_OR_CDECL	_Link (const char *, const char *)
_FS_DLL int __CLRCALL_PURE_OR_CDECL	_Symlink (const char *, const char *)
_FS_DLL int __CLRCALL_PURE_OR_CDECL	_Rename (const char *, const char *)
_FS_DLL int __CLRCALL_PURE_OR_CDECL	_Unlink (const char *)
_FS_DLL int __CLRCALL_PURE_OR_CDECL	_Copy_file (const char *, const char *, bool)
_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 wchar_t *__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 int __CLRCALL_PURE_OR_CDECL	_Make_dir (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 *, int &)
_FS_DLL file_type __CLRCALL_PURE_OR_CDECL	_Lstat (const wchar_t *, int &)
_FS_DLL _ULonglong __CLRCALL_PURE_OR_CDECL	_File_size (const wchar_t *)
_FS_DLL time_t __CLRCALL_PURE_OR_CDECL	_Last_write_time (const wchar_t *)
_FS_DLL void __CLRCALL_PURE_OR_CDECL	_Last_write_time (const wchar_t *, time_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	_Unlink (const wchar_t *)
_FS_DLL int __CLRCALL_PURE_OR_CDECL	_Copy_file (const wchar_t *, const wchar_t *, bool)
template<class _Path , class _Prefix_directory >
bool	operator== (const basic_directory_iterator< _Path, _Prefix_directory > &_Left, const basic_directory_iterator< _Path, _Prefix_directory > &_Right)
template<class _Path , class _Prefix_directory >
bool	operator!= (const basic_directory_iterator< _Path, _Prefix_directory > &_Left, const basic_directory_iterator< _Path, _Prefix_directory > &_Right)
template<class _Path >
bool	operator== (const basic_recursive_directory_iterator< _Path > &_Left, const basic_recursive_directory_iterator< _Path > &_Right)
template<class _Path >
bool	operator!= (const basic_recursive_directory_iterator< _Path > &_Left, const basic_recursive_directory_iterator< _Path > &_Right)
template<class _Path >
file_status	status (const _Path &_Pval)
template<class _Path >
file_status	status (const _Path &_Pval, error_code &_Code)
template<class _Path >
file_status	symlink_status (const _Path &_Pval)
template<class _Path >
file_status	symlink_status (const _Path &_Pval, error_code &_Code)
bool	status_known (file_status _Stat)
bool	exists (file_status _Stat)
bool	is_regular (file_status _Stat)
bool	is_regular_file (file_status _Stat)
bool	is_directory (file_status _Stat)
bool	is_symlink (file_status _Stat)
bool	is_other (file_status _Stat)
template<class _Path >
bool	exists (const _Path &_Pval)
template<class _Path >
bool	is_regular (const _Path &_Pval)
template<class _Path >
bool	is_regular_file (const _Path &_Pval)
template<class _Path >
bool	is_directory (const _Path &_Pval)
template<class _Path >
bool	is_symlink (const _Path &_Pval)
template<class _Path >
bool	is_other (const _Path &_Pval)
template<class _Path >
bool	is_empty (const _Path &_Pval)
template<class _Path1 , class _Path2 >
bool	equivalent (const _Path1 &_Pval1, const _Path2 &_Pval2)
template<class _Path >
_Path	current_path ()
template<class _Path >
void	current_path (const _Path &_Pval)
template<class _Path >
_Path	initial_path ()
template<class _Path >
_ULonglong	file_size (const _Path &_Pval)
template<class _Path >
space_info	space (const _Path &_Pval)
template<class _Path >
time_t	last_write_time (const _Path &_Pval)
template<class _Path >
void	last_write_time (const _Path &_Pval, time_t _Newtime)
template<class _Path >
bool	create_directory (const _Path &_Pval)
template<class _Path >
bool	remove_directory (const _Path &_Pval)
template<class _Path1 , class _Path2 >
void	create_hard_link (const _Path1 &_Oldpval, const _Path2 &_Newpval)
template<class _Path1 , class _Path2 >
error_code	create_hard_link (const _Path1 &_Oldpval, const _Path2 &_Newpval, error_code &_Code)
template<class _Path1 , class _Path2 >
void	create_symlink (const _Path1 &_Oldpval, const _Path2 &_Newpval)
template<class _Path1 , class _Path2 >
error_code	create_symlink (const _Path1 &_Oldpval, const _Path2 &_Newpval, error_code &_Code)
template<class _Path >
bool	remove (const _Path &_Pval)
template<class _Path >
bool	remove_filename (const _Path &_Pval)
template<class _Path >
bool	_Remove_all (const _Path &_Pval, unsigned long &_Ans)
template<class _Path >
unsigned long	remove_all (const _Path &_Pval)
template<class _Path1 , class _Path2 >
bool	rename (const _Path1 &_Oldpval, const _Path2 &_Newpval)
template<class _Path1 , class _Path2 >
void	copy_file (const _Path1 &_Oldpval, const _Path2 &_Newpval, _Copy_option _Opt=copy_option::fail_if_exists)
template<class _Path >
_Path	complete (const _Path &_Pval, const _Path &_Pbase=initial_path< _Path >())
template<class _Path >
_Path	system_complete (const _Path &_Pval)
template<class _Path >
bool	create_directories (const _Path &_Pval)
template<class _Path >
_Path::string_type	extension (const _Path &_Pval)
template<class _Path >
_Path::string_type	basename (const _Path &_Pval)
template<class _Path >
_Path::string_type	stem (const _Path &_Pval)
template<class _Path >
_Path	replace_extension (const _Path &_Pval, const typename _Path::string_type &_Newext)

Typedef Documentation

typedef copy_option tr2::sys::_Copy_option

typedef basic_directory_entry<path> tr2::sys::directory_entry

typedef basic_directory_iterator<path> tr2::sys::directory_iterator

typedef basic_filesystem_error<path> tr2::sys::filesystem_error

typedef basic_path<string, path_traits> tr2::sys::path

typedef basic_recursive_directory_iterator<path> tr2::sys::recursive_directory_iterator

typedef basic_directory_entry<wpath> tr2::sys::wdirectory_entry

typedef basic_directory_iterator<wpath> tr2::sys::wdirectory_iterator

typedef basic_filesystem_error<wpath> tr2::sys::wfilesystem_error

typedef basic_path<wstring, wpath_traits> tr2::sys::wpath

typedef basic_recursive_directory_iterator<wpath> tr2::sys::wrecursive_directory_iterator

Enumeration Type Documentation

enum tr2::sys::copy_option

strong

Enumerator
fail_if_exists
overwrite_if_exists

                       {    // names for copy options
    fail_if_exists,
    overwrite_if_exists
    };

enum tr2::sys::file_type

Enumerator
status_unknown
file_not_found
regular_file
directory_file
symlink_file
block_file
character_file
fifo_file
socket_file
type_unknown

               {    // types of files
    status_unknown, file_not_found, regular_file, directory_file,
    symlink_file, block_file, character_file, fifo_file,
    socket_file, type_unknown
    };

Function Documentation

_FS_DLL void __CLRCALL_PURE_OR_CDECL tr2::sys::_Close_dir

(

void *

)

_FS_DLL int __CLRCALL_PURE_OR_CDECL tr2::sys::_Copy_file	(	const char *	,
		const char *	,
		bool
	)

_FS_DLL int __CLRCALL_PURE_OR_CDECL tr2::sys::_Copy_file	(	const wchar_t *	,
		const wchar_t *	,
		bool
	)

_FS_DLL char* __CLRCALL_PURE_OR_CDECL tr2::sys::_Current_get

(

char(&)

[_MAX_FILESYS_NAME]

)

_FS_DLL wchar_t* __CLRCALL_PURE_OR_CDECL tr2::sys::_Current_get

(

wchar_t(&)

[_MAX_FILESYS_NAME]

)

_FS_DLL bool __CLRCALL_PURE_OR_CDECL tr2::sys::_Current_set

(

const char *

)

_FS_DLL bool __CLRCALL_PURE_OR_CDECL tr2::sys::_Current_set

(

const wchar_t *

)

_FS_DLL int __CLRCALL_PURE_OR_CDECL tr2::sys::_Equivalent	(	const char *	,
		const char *
	)

_FS_DLL int __CLRCALL_PURE_OR_CDECL tr2::sys::_Equivalent	(	const wchar_t *	,
		const wchar_t *
	)

_FS_DLL _ULonglong __CLRCALL_PURE_OR_CDECL tr2::sys::_File_size

(

const char *

)

_FS_DLL _ULonglong __CLRCALL_PURE_OR_CDECL tr2::sys::_File_size

(

const wchar_t *

)

_FS_DLL time_t __CLRCALL_PURE_OR_CDECL tr2::sys::_Last_write_time

(

const char *

)

_FS_DLL void __CLRCALL_PURE_OR_CDECL tr2::sys::_Last_write_time	(	const char *	,
		time_t
	)

_FS_DLL time_t __CLRCALL_PURE_OR_CDECL tr2::sys::_Last_write_time

(

const wchar_t *

)

_FS_DLL void __CLRCALL_PURE_OR_CDECL tr2::sys::_Last_write_time	(	const wchar_t *	,
		time_t
	)

_FS_DLL int __CLRCALL_PURE_OR_CDECL tr2::sys::_Link	(	const char *	,
		const char *
	)

_FS_DLL int __CLRCALL_PURE_OR_CDECL tr2::sys::_Link	(	const wchar_t *	,
		const wchar_t *
	)

_FS_DLL file_type __CLRCALL_PURE_OR_CDECL tr2::sys::_Lstat	(	const char *	,
		int &
	)

_FS_DLL file_type __CLRCALL_PURE_OR_CDECL tr2::sys::_Lstat	(	const wchar_t *	,
		int &
	)

_FS_DLL int __CLRCALL_PURE_OR_CDECL tr2::sys::_Make_dir

(

const char *

)

_FS_DLL int __CLRCALL_PURE_OR_CDECL tr2::sys::_Make_dir

(

const wchar_t *

)

_FS_DLL void* __CLRCALL_PURE_OR_CDECL tr2::sys::_Open_dir	(	char(&)	[_MAX_FILESYS_NAME],
		const char *	,
		int &	,
		file_type &
	)

_FS_DLL void* __CLRCALL_PURE_OR_CDECL tr2::sys::_Open_dir	(	wchar_t(&)	[_MAX_FILESYS_NAME],
		const wchar_t *	,
		int &	,
		file_type &
	)

_FS_DLL char* __CLRCALL_PURE_OR_CDECL tr2::sys::_Read_dir	(	char(&)	[_MAX_FILESYS_NAME],
		void *	,
		file_type &
	)

_FS_DLL wchar_t* __CLRCALL_PURE_OR_CDECL tr2::sys::_Read_dir	(	wchar_t(&)	[_MAX_FILESYS_NAME],
		void *	,
		file_type &
	)

template<class _Path >

bool tr2::sys::_Remove_all ( const _Path &  _Pval, unsigned long &  _Ans  )

inline

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

        for (; ; )
            {   // remove a directory entry
            _Myit _First(_Pval);
            if (_First == _Last)
                break;
            if (!_Remove_all(_Pval / _First->path(), _Ans))
                return (false);
            }
        return (remove_directory(_Pval));
        }
    else if (!remove(_Pval))
        return (false);
    else
        {   // file remove succeeded, count it
        ++_Ans;
        return (true);
        }
    }

_FS_DLL bool __CLRCALL_PURE_OR_CDECL tr2::sys::_Remove_dir

(

const char *

)

_FS_DLL bool __CLRCALL_PURE_OR_CDECL tr2::sys::_Remove_dir

(

const wchar_t *

)

_FS_DLL int __CLRCALL_PURE_OR_CDECL tr2::sys::_Rename	(	const char *	,
		const char *
	)

_FS_DLL int __CLRCALL_PURE_OR_CDECL tr2::sys::_Rename	(	const wchar_t *	,
		const wchar_t *
	)

_FS_DLL file_type __CLRCALL_PURE_OR_CDECL tr2::sys::_Stat	(	const char *	,
		int &
	)

_FS_DLL file_type __CLRCALL_PURE_OR_CDECL tr2::sys::_Stat	(	const wchar_t *	,
		int &
	)

_FS_DLL space_info __CLRCALL_PURE_OR_CDECL tr2::sys::_Statvfs

(

const char *

)

_FS_DLL space_info __CLRCALL_PURE_OR_CDECL tr2::sys::_Statvfs

(

const wchar_t *

)

_FS_DLL int __CLRCALL_PURE_OR_CDECL tr2::sys::_Symlink	(	const char *	,
		const char *
	)

_FS_DLL int __CLRCALL_PURE_OR_CDECL tr2::sys::_Symlink	(	const wchar_t *	,
		const wchar_t *
	)

_FS_DLL int __CLRCALL_PURE_OR_CDECL tr2::sys::_Unlink

(

const char *

)

_FS_DLL int __CLRCALL_PURE_OR_CDECL tr2::sys::_Unlink

(

const wchar_t *

)

template<class _Path >

_Path::string_type tr2::sys::basename ( const _Path &  _Pval )

inline

    {   // pick off base name in leaf before dot
    return (_Pval.stem());
    }

template<class _Path >

_Path tr2::sys::complete ( const _Path &  _Pval, const _Path &  _Pbase = initial_path<_Path>()  )

inline

    {   // complete _Pval with _Pbase
    if (!(_Pbase.is_complete()
        && (_Pval.is_complete() || !_Pval.has_root_name())))
        _THROW_NCEE(basic_filesystem_error<_Path>,
            "complete(p1, p2): invalid arguments");
    if (_Pval.has_root_name())
        return (_Pval);
    else if (_Pval.has_root_directory())
        return (_Path(_Pbase.root_name()) / _Pval);
    else
        return (_Pbase / _Pval);
    }

template<class _Path1 , class _Path2 >

void tr2::sys::copy_file ( const _Path1 &  _Oldpval, const _Path2 &  _Newpval, _Copy_option  _Opt = copy_option::fail_if_exists  )

inline

    {   // copy _Oldpval to _Newpval, with attributes
    if (_Copy_file(_Oldpval._Ptr(), _Newpval._Ptr(),
        (int)_Opt == (int)copy_option::fail_if_exists))
        _THROW_NCEE(basic_filesystem_error<_Path1>,
            "copy(p1, p2): invalid arguments");
    }

template<class _Path >

bool tr2::sys::create_directories ( const _Path &  _Pval )

inline

    {   // create directory chain
    if (_Pval.empty())
        return (false);
    else if (!exists(_Pval))
        {   // recursively create parent directories, then current
        create_directories(_Pval.branch_path());
        create_directory(_Pval);
        return (true);
        }
    else if (is_directory(_Pval))
        return (false); // directory already there
    else
        _THROW_NCEE(basic_filesystem_error<_Path>,
            "create_directories(p): bad argument");
    }

template<class _Path >

bool tr2::sys::create_directory ( const _Path &  _Pval )

inline

    {   // create a directory
    int _Ans = _Make_dir(_Pval._Ptr());

    if (_Ans < 0)
        _THROW_NCEE(basic_filesystem_error<_Path>,
            "create_directory(p): invalid argument");
    else
        return (0 < _Ans);
    }

template<class _Path1 , class _Path2 >

void tr2::sys::create_hard_link ( const _Path1 &  _Oldpval, const _Path2 &  _Newpval  )

inline

    {   // link _Newpval to _Oldpval
    if (_Link(_Oldpval._Ptr(), _Newpval._Ptr()) != 0)
        _THROW_NCEE(basic_filesystem_error<_Path1>,
            "create_hard_link(p1, p2): invalid arguments");
    }

template<class _Path1 , class _Path2 >

error_code tr2::sys::create_hard_link ( const _Path1 &  _Oldpval, const _Path2 &  _Newpval, error_code &  _Code  )

inline

    {   // link _Newpval to _Oldpval
    int _Ans = _Link(_Oldpval._Ptr(), _Newpval._Ptr());
    _Code = error_code(_Ans, _STD system_category());
    return (_Code);
    }

template<class _Path1 , class _Path2 >

void tr2::sys::create_symlink ( const _Path1 &  _Oldpval, const _Path2 &  _Newpval  )

inline

    {   // symlink _Newpval to _Oldpval
    if (_Symlink(_Oldpval._Ptr(), _Newpval._Ptr()) != 0)
        _THROW_NCEE(basic_filesystem_error<_Path1>,
            "create_symlink(p1, p2): invalid arguments");
    }

template<class _Path1 , class _Path2 >

error_code tr2::sys::create_symlink ( const _Path1 &  _Oldpval, const _Path2 &  _Newpval, error_code &  _Code  )

inline

    {   // symlink _Newpval to _Oldpval
    int _Ans = _Symlink(_Oldpval._Ptr(), _Newpval._Ptr());
    _Code = error_code(_Ans, _STD system_category());
    return (_Code);
    }

template<class _Path >

_Path tr2::sys::current_path ( )

inline

    {   // get current working directory
    typename _Path::value_type _Dest[_MAX_FILESYS_NAME];
    return (_Current_get(_Dest));
    }

template<class _Path >

void tr2::sys::current_path ( const _Path &  _Pval )

inline

    {   // set current working directory
    _Current_set(_Pval._Ptr());
    }

template<class _Path1 , class _Path2 >

bool tr2::sys::equivalent ( const _Path1 &  _Pval1, const _Path2 &  _Pval2  )

inline

    {   // test if paths designate same file
    int _Ans = _Equivalent(_Pval1._Ptr(), _Pval2._Ptr());

    if (_Ans < 0)
        _THROW_NCEE(basic_filesystem_error<_Path1>,
            "equivalent(p1, p2): invalid arguments");
    return (0 < _Ans);
    }

bool tr2::sys::exists ( file_status  _Stat )

inline

    {   // test if file exists
    return (status_known(_Stat) && _Stat.type() != file_not_found);
    }

template<class _Path >

bool tr2::sys::exists ( const _Path &  _Pval )

inline

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

template<class _Path >

_Path::string_type tr2::sys::extension ( const _Path &  _Pval )

inline

    {   // pick off .extension in leaf, including dot
    return (_Pval.extension());
    }

template<class _Path >

_ULonglong tr2::sys::file_size ( const _Path &  _Pval )

inline

    {   // get file size
    return (_File_size(_Pval._Ptr()));
    }

template<class _Path >

_Path tr2::sys::initial_path ( )

inline

    {   // get initial working directory
    return (_Wrap_init_dir<_Path>::_Mypath);
    }

bool tr2::sys::is_directory ( file_status  _Stat )

inline

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

template<class _Path >

bool tr2::sys::is_directory ( const _Path &  _Pval )

inline

    {   // test if path is directory
    return (is_directory(status(_Pval)));
    }

template<class _Path >

bool tr2::sys::is_empty ( const _Path &  _Pval )

inline

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

    if (!exists(_Stat))
        _THROW_NCEE(basic_filesystem_error<_Path>,
            "is_empty(p): invalid argument");
    else if (is_directory(_Stat))
        return (basic_directory_iterator<_Path>(_Pval)
            == basic_directory_iterator<_Path>());
    else
        return (file_size(_Pval) == 0);
    }

bool tr2::sys::is_other ( file_status  _Stat )

inline

    {   // test for other file types
    return (exists(_Stat)
        && !is_regular(_Stat) && !is_directory(_Stat) && !is_symlink(_Stat));
    }

template<class _Path >

bool tr2::sys::is_other ( const _Path &  _Pval )

inline

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

bool tr2::sys::is_regular ( file_status  _Stat )

inline

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

template<class _Path >

bool tr2::sys::is_regular ( const _Path &  _Pval )

inline

    {   // test if path is regular
    return (is_regular(status(_Pval)));
    }

bool tr2::sys::is_regular_file ( file_status  _Stat )

inline

    {   // test for regular file
    return (is_regular(_Stat));
    }

template<class _Path >

bool tr2::sys::is_regular_file ( const _Path &  _Pval )

inline

    {   // test if path is regular
    return (is_regular(_Pval));
    }

bool tr2::sys::is_symlink ( file_status  _Stat )

inline

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

template<class _Path >

bool tr2::sys::is_symlink ( const _Path &  _Pval )

inline

    {   // test if path is symlink
    return (is_symlink(status(_Pval)));
    }

template<class _Path >

time_t tr2::sys::last_write_time ( const _Path &  _Pval )

inline

    {   // get last write time
    return (_Last_write_time(_Pval._Ptr()));
    }

template<class _Path >

void tr2::sys::last_write_time ( const _Path &  _Pval, time_t  _Newtime  )

inline

    {   // set last write time
    _Last_write_time(_Pval._Ptr(), _Newtime);
    }

template<class _String , class _Traits >

bool tr2::sys::operator!= ( const basic_path< _String, _Traits > &  _Left, const basic_path< _String, _Traits > &  _Right  )

inline

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

template<class _Path , class _Prefix_directory >

bool tr2::sys::operator!= ( const basic_directory_iterator< _Path, _Prefix_directory > &  _Left, const basic_directory_iterator< _Path, _Prefix_directory > &  _Right  )

inline

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

template<class _Path >

bool tr2::sys::operator!= ( const basic_recursive_directory_iterator< _Path > &  _Left, const basic_recursive_directory_iterator< _Path > &  _Right  )

inline

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

template<class _String , class _Traits >

basic_path<_String, _Traits> tr2::sys::operator/ ( const basic_path< _String, _Traits > &  _Left, const basic_path< _String, _Traits > &  _Right  )

inline

    {   // concatenate paths
    basic_path<_String, _Traits> _Ans = _Left;
    return (_Ans /= _Right);
    }

template<class _String , class _Traits >

bool tr2::sys::operator< ( const basic_path< _String, _Traits > &  _Left, const basic_path< _String, _Traits > &  _Right  )

inline

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

template<class _String , class _Traits >

basic_ostream<typename _String::value_type, typename _String::traits_type>& tr2::sys::operator<< ( basic_ostream< typename _String::value_type, typename _String::traits_type > &  _Ostr, const basic_path< _String, _Traits > &  _Pval  )

inline

    {   // insert a basic_path
    return (_Ostr << _Pval.string());
    }

template<class _String , class _Traits >

bool tr2::sys::operator<= ( const basic_path< _String, _Traits > &  _Left, const basic_path< _String, _Traits > &  _Right  )

inline

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

template<class _String , class _Traits >

bool tr2::sys::operator== ( const basic_path< _String, _Traits > &  _Left, const basic_path< _String, _Traits > &  _Right  )

inline

    {   // test for basic_path equality
    return (_Left.string() == _Right.string());
    }

template<class _Path , class _Prefix_directory >

bool tr2::sys::operator== ( const basic_directory_iterator< _Path, _Prefix_directory > &  _Left, const basic_directory_iterator< _Path, _Prefix_directory > &  _Right  )

inline

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

template<class _Path >

bool tr2::sys::operator== ( const basic_recursive_directory_iterator< _Path > &  _Left, const basic_recursive_directory_iterator< _Path > &  _Right  )

inline

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

template<class _String , class _Traits >

bool tr2::sys::operator> ( const basic_path< _String, _Traits > &  _Left, const basic_path< _String, _Traits > &  _Right  )

inline

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

template<class _String , class _Traits >

bool tr2::sys::operator>= ( const basic_path< _String, _Traits > &  _Left, const basic_path< _String, _Traits > &  _Right  )

inline

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

template<class _String , class _Traits >

basic_istream<typename _String::value_type, typename _String::traits_type>& tr2::sys::operator>> ( basic_istream< typename _String::value_type, typename _String::traits_type > &  _Istr, basic_path< _String, _Traits > &  _Pval  )

inline

    {   // extract a basic_path
    _String _Str;
    _Istr >> _Str;
    _Pval = _Str;
    return (_Istr);
    }

template<class _Path >

bool tr2::sys::remove ( const _Path &  _Pval )

inline

    {   // remove _Pval
    return (_Unlink(_Pval._Ptr()) == 0);
    }

template<class _Path >

unsigned long tr2::sys::remove_all ( const _Path &  _Pval )

inline

    {   // recursively remove a directory
    unsigned long _Ans = 0;

    _Remove_all(_Pval, _Ans);
    return (_Ans);
    }

template<class _Path >

bool tr2::sys::remove_directory ( const _Path &  _Pval )

inline

    {   // remove a directory
    return (_Remove_dir(_Pval._Ptr()));
    }

template<class _Path >

bool tr2::sys::remove_filename ( const _Path &  _Pval )

inline

    {   // remove _Pval
    return (remove(_Pval));
    }

template<class _Path1 , class _Path2 >

bool tr2::sys::rename ( const _Path1 &  _Oldpval, const _Path2 &  _Newpval  )

inline

    {   // rename _Oldpval as _Newpval
    if (exists(_Newpval) && !remove(_Newpval))
        return (false);
    else
        return (_Rename(_Oldpval._Ptr(), _Newpval._Ptr()) == 0);
    }

template<class _Path >

_Path tr2::sys::replace_extension ( const _Path &  _Pval, const typename _Path::string_type &  _Newext  )

inline

    {   // replace extension with _Newext
    _Path _Ans = _Pval;
    return (_Ans.replace_extension(_Newext));
    }

template<class _Path >

space_info tr2::sys::space ( const _Path &  _Pval )

inline

    {   // get space information for volume
    return (_Statvfs(_Pval._Ptr()));
    }

template<class _Path >

file_status tr2::sys::status ( const _Path &  _Pval )

inline

    {   // get file status
    int _Errno = 0;
    file_type _Ftype = _Stat(_Pval._Ptr(), _Errno);

    return (file_status(_Ftype));
    }

template<class _Path >

file_status tr2::sys::status ( const _Path &  _Pval, error_code &  _Code  )

inline

    {   // get file status
    int _Errno = 0;
    file_type _Ftype = _Stat(_Pval._Ptr(), _Errno);

    _Code = error_code(_Errno, _STD system_category());
    return (file_status(_Ftype));
    }

bool tr2::sys::status_known ( file_status  _Stat )

inline

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

template<class _Path >

_Path::string_type tr2::sys::stem ( const _Path &  _Pval )

inline

    {   // pick off base name in leaf before dot
    return (basename(_Pval));
    }

template<class _String , class _Traits >

void tr2::sys::swap ( basic_path< _String, _Traits > &  _Left, basic_path< _String, _Traits > &  _Right  )

inline

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

template<class _Path >

file_status tr2::sys::symlink_status ( const _Path &  _Pval )

inline

    {   // get symlink file status
    int _Errno = 0;
    file_type _Ftype = _Lstat(_Pval._Ptr(), _Errno);

    return (file_status(_Ftype));
    }

template<class _Path >

file_status tr2::sys::symlink_status ( const _Path &  _Pval, error_code &  _Code  )

inline

    {   // get symlink file status
    int _Errno = 0;
    file_type _Ftype = _Lstat(_Pval._Ptr(), _Errno);

    _Code = error_code(_Errno, _STD system_category());
    return (file_status(_Ftype));
    }

template<class _Path >

_Path tr2::sys::system_complete ( const _Path &  _Pval )

inline

    {   // complete _Pval
    return (_Pval.is_complete() ? _Pval : complete(_Pval,
        current_path<_Path>()));
    }