Public Types
typedef _Pchar	value_type

typedef basic_string< value_type >	string_type

typedef _Path_iterator< path >	iterator

typedef iterator	const_iterator

Public Member Functions
	path ()

	path (const path &_Right)

template<class _InIt , class = typename enable_if<_Is_iterator<_InIt>::value, void>::type>
	path (_InIt _First, _InIt _Last)

template<class _InIt , class = typename enable_if<_Is_iterator<_InIt>::value, void>::type>
	path (_InIt _First)

template<class _Elem , class _Traits , class _Alloc >
	path (const basic_string< _Elem, _Traits, _Alloc > &_Str)

template<class _InIt , class = typename enable_if<_Is_iterator<_InIt>::value, void>::type>
	path (_InIt _First, _InIt _Last, const locale &_Loc)

template<class _InIt , class = typename enable_if<_Is_iterator<_InIt>::value, void>::type>
	path (_InIt _First, const locale &_Loc)

template<class _Elem , class _Traits , class _Alloc >
	path (const basic_string< _Elem, _Traits, _Alloc > &_Str, const locale &_Loc)

	path (path &&_Right) _NOEXCEPT

path &	operator= (path &&_Right) _NOEXCEPT

	~path () _NOEXCEPT

path &	operator= (const path &_Right)

template<class _InIt >
path &	operator= (_InIt _First)

template<class _Elem , class _Traits , class _Alloc >
path &	operator= (const basic_string< _Elem, _Traits, _Alloc > &_Str)

template<class _InIt >
path &	assign (_InIt _First, _InIt _Last)

template<class _InIt >
path &	assign (_InIt _First)

template<class _Elem , class _Traits , class _Alloc >
path &	assign (const basic_string< _Elem, _Traits, _Alloc > &_Str)

path &	operator/= (const path &_Path)

template<class _InIt >
path &	operator/= (_InIt _First)

template<class _Elem , class _Traits , class _Alloc >
path &	operator/= (const basic_string< _Elem, _Traits, _Alloc > &_Str)

template<class _InIt >
path &	append (_InIt _First, _InIt _Last)

template<class _InIt >
path &	append (_InIt _First)

template<class _Elem , class _Traits , class _Alloc >
path &	append (const basic_string< _Elem, _Traits, _Alloc > &_Str0)

path &	operator+= (const path &_Path)

template<class _Ty >
path &	operator+= (_Ty _Val)

template<class _Elem , class _Traits , class _Alloc >
path &	operator+= (const basic_string< _Elem, _Traits, _Alloc > &_Str)

template<class _Elem >
path &	operator+= (const _Elem *_Ptr)

template<class _InIt >
path &	concat (_InIt _First, _InIt _Last)

template<class _InIt , class = typename enable_if<_Is_iterator<_InIt>::value, void>::type>
path &	concat (_InIt _First)

template<class _Elem >
path &	concat (const _Elem *_Ptr)

template<class _Elem >
path &	concat (_Elem _Val)

template<class _Elem , class _Traits , class _Alloc >
path &	concat (const basic_string< _Elem, _Traits, _Alloc > &_Str)

void	clear () _NOEXCEPT

path &	make_preferred ()

path &	remove_filename ()

path &	replace_filename (const path &_Path)

path &	replace_extension (const path &_Newext=path())

void	swap (path &_Right) _NOEXCEPT

const string_type &	native () const _NOEXCEPT

const value_type *	c_str () const _NOEXCEPT

	operator string_type () const

template<class _Elem , class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>
basic_string< _Elem, _Traits, _Alloc >	string (const _Alloc &_Al=_Alloc()) const

_STD string	string () const

_STD wstring	wstring () const

_STD string	u8string () const

_STD u16string	u16string () const

_STD u32string	u32string () const =delete

string_type	_Make_generic () const

template<class _Elem , class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>
basic_string< _Elem, _Traits, _Alloc >	generic_string (const _Alloc &_Al=_Alloc()) const

_STD string	generic_string () const

_STD wstring	generic_wstring () const

_STD string	generic_u8string () const

_STD u16string	generic_u16string () const

_STD u32string	generic_u32string () const =delete

int	compare (const path &_Path) const _NOEXCEPT

int	compare (const string_type &_Str) const

int	compare (const value_type *_Ptr) 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

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

iterator	begin () const

iterator	end () const

size_t	_Prefix_end () const

size_t	_Root_end () const

Public Attributes
string_type	_Mystr

Static Public Attributes
static constexpr value_type	preferred_separator = _FS_PREF

Member Typedef Documentation

typedef iterator experimental::filesystem::v1::path::const_iterator

typedef _Path_iterator<path> experimental::filesystem::v1::path::iterator

typedef basic_string<value_type> experimental::filesystem::v1::path::string_type

typedef _Pchar experimental::filesystem::v1::path::value_type

Constructor & Destructor Documentation

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

inline

853 { // default construct

854 }

experimental::filesystem::v1::path::path ( const path & _Right )

inline

         : _Mystr(_Right._Mystr)
         {   // copy construct
         }

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

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

inline

         {   // construct from [_First, _Last), given iterators
         typedef _Iter_value_t<_InIt> _Valty;
         basic_string<_Valty> _Str(_First, _Last);
         string_type _Str_out;
         *this /= _Path_cvt<_Valty, value_type>::
 			_Cvt(_Str_out, _Str.c_str(), _Str.size());
         }

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

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

inline

         {   // construct from NTCTS, given iterator
         typedef _Iter_value_t<_InIt> _Valty;
         basic_string<_Valty> _Str;
         for (; *_First != _Valty(0); ++_First)
             _Str += *_First;
         string_type _Str_out;
         *this /= _Path_cvt<_Valty, value_type>::
 			_Cvt(_Str_out, _Str.c_str(), _Str.size());
         }

template<class _Elem , class _Traits , class _Alloc >

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

inline

         {   // construct from arbitrary source string
         string_type _Str_out;
         *this /= _Path_cvt<_Elem, value_type>::
 			_Cvt(_Str_out, _Str.c_str(), _Str.size());
         }

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

experimental::filesystem::v1::path::path	(	_InIt	_First,
		_InIt	_Last,
		const locale &	_Loc
	)

inline

         {   // construct from [_First, _Last), given iterators
         typedef _Iter_value_t<_InIt> _Valty;
         basic_string<_Valty> _Str(_First, _Last);
         string_type _Str_out;
         *this /= _Path_cvt<_Valty, value_type>::
 			_Cvt(_Str_out, _Str.c_str(), _Str.size(), _Loc);
         }

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

experimental::filesystem::v1::path::path	(	_InIt	_First,
		const locale &	_Loc
	)

inline

         {   // construct from NTCTS, given iterator
         typedef _Iter_value_t<_InIt> _Valty;
         basic_string<_Valty> _Str;
         for (; *_First != _Valty(0); ++_First)
             _Str += *_First;
         string_type _Str_out;
         *this /= _Path_cvt<_Valty, value_type>::
 			_Cvt(_Str_out, _Str.c_str(), _Str.size(), _Loc);
         }

template<class _Elem , class _Traits , class _Alloc >

experimental::filesystem::v1::path::path	(	const basic_string< _Elem, _Traits, _Alloc > &	_Str,
		const locale &	_Loc
	)

inline

         {   // construct from arbitrary source string
         string_type _Str_out;
         *this /= _Path_cvt<_Elem, value_type>::
 			_Cvt(_Str_out, _Str.c_str(), _Str.size(), _Loc);
         }

experimental::filesystem::v1::path::path ( path && _Right )

inline

         : _Mystr(_STD move(_Right._Mystr))
         {   // move construct
         }

experimental::filesystem::v1::path::~path ( )

inline

956 { // destroy the object

957 }

Member Function Documentation

string_type experimental::filesystem::v1::path::_Make_generic ( ) const

inline

         {   // copy and convert any '\' to '/'
         string_type _Str = _Mystr;
         _STD replace(_Str.begin(), _Str.end(), _FS_BSLASH, _FS_SLASH);
         return (_Str);
         }

size_t experimental::filesystem::v1::path::_Prefix_end ( ) const

inline

         {   // get end of prefix
         if (2 < _Mystr.size()
             && _FS_ISSEP(_Mystr[0])
             && _FS_ISSEP(_Mystr[1])
             && !_FS_ISSEP(_Mystr[2]))
             {   // network name, pick off \\name
             size_t _Idx = 3;
             for (; _Idx < _Mystr.size() && !_FS_ISSEP(_Mystr[_Idx]); ++_Idx)
                 ;
             return (_Idx);
             }
         else
             {   // no network name, pick off drive:
             size_t _Idx = _Mystr.find(_FS_COLON, 0);
             if (_Idx == _Mystr.npos)
                 _Idx = 0;
             else
                 ++_Idx;
             return (_Idx);
             }
         }

size_t experimental::filesystem::v1::path::_Root_end ( ) const

inline

         {   // get end of root
         size_t _Idx = _Prefix_end();
         if (_Idx < _Mystr.size()
             && _FS_ISSEP(_Mystr[_Idx]))
             ++_Idx;
         return (_Idx);
         }

template<class _InIt >

path& experimental::filesystem::v1::path::append	(	_InIt	_First,
		_InIt	_Last
	)

inline

         {   // append NTCTS
         return (append(path(_First, _Last)._Mystr));
         }

template<class _InIt >

path& experimental::filesystem::v1::path::append ( _InIt _First )

inline

         {   // append NTCTS
         return (append(path(_First)._Mystr));
         }

template<class _Elem , class _Traits , class _Alloc >

path& experimental::filesystem::v1::path::append ( const basic_string< _Elem, _Traits, _Alloc > & _Str0 )

inline

         {   // append arbitrary source string
         string_type _Str(_Str0.begin(), _Str0.end());   // avoid overlap
 
         for (size_t _Idx = 0; _Idx < _Str.size(); ++_Idx)
             if (_Str[_Idx] == _FS_SLASH)
                 _Str[_Idx] = _FS_PREF;  // convert '/' to '\'
 
         if (0 < _Mystr.size() && 0 < _Str.size()
             && _Mystr.back() != _FS_COLON
             && !_FS_ISSEP(_Mystr.back())
             && !_FS_ISSEP(_Str[0]))
             _Mystr.append(1, _FS_PREF); // add needed separator
 
         _Mystr.append(_Str);
         return (*this);
         }

template<class _InIt >

path& experimental::filesystem::v1::path::assign	(	_InIt	_First,
		_InIt	_Last
	)

inline

         {   // assign from [_First, _Last), given iterators
         return (*this = path(_First, _Last));
         }

template<class _InIt >

path& experimental::filesystem::v1::path::assign ( _InIt _First )

inline

         {   // assign from NTCTS
         return (*this = path(_First));
         }

template<class _Elem , class _Traits , class _Alloc >

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

inline

         {   // assign from arbitrary source string
         return (*this = path(_Str));
         }

iterator experimental::filesystem::v1::path::begin ( ) const

inline

         {   // get beginning of path
         return (iterator(*this, (size_t)0));
         }

const value_type* experimental::filesystem::v1::path::c_str ( ) const

inline

         {   // get the stored string
         return (_Mystr.c_str());
         }

void experimental::filesystem::v1::path::clear ( )

inline

         {   // clear the stored string
         _Mystr.clear();
         }

int experimental::filesystem::v1::path::compare ( const path & _Path ) const

inline

         {   // compare native() to _Path.native()
         return (_Mystr.compare(_Path._Mystr));
         }

int experimental::filesystem::v1::path::compare ( const string_type & _Str ) const

inline

         {   // compare native() to string
         return (_Mystr.compare(_Str));
         }

int experimental::filesystem::v1::path::compare ( const value_type * _Ptr ) const

inline

         {   // compare native() to NTCS
         return (_Mystr.compare(_Ptr));
         }

template<class _InIt >

path& experimental::filesystem::v1::path::concat	(	_InIt	_First,
		_InIt	_Last
	)

inline

         {   // concatenate NTCTS
         return (concat(path(_First, _Last)._Mystr));
         }

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

path& experimental::filesystem::v1::path::concat ( _InIt _First )

inline

         {   // concatenate NTCTS
         return (concat(path(_First)._Mystr));
         }

template<class _Elem >

path& experimental::filesystem::v1::path::concat ( const _Elem * _Ptr )

inline

         {   // concatenate arbitrary NTCTS
         return (concat(basic_string<_Elem>(_Ptr)));
         }

template<class _Elem >

path& experimental::filesystem::v1::path::concat ( _Elem _Val )

inline

         {   // concatenate element
         return (concat(path(basic_string<_Elem>((size_t)1, _Val))._Mystr));
         }

template<class _Elem , class _Traits , class _Alloc >

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

inline

         {   // concatenate arbitrary source string
         _Mystr.append(_Str.begin(), _Str.end());
         return (*this);
         }

bool experimental::filesystem::v1::path::empty ( ) const

inline

         {   // test if stored string is empty
         return (_Mystr.empty());
         }

iterator experimental::filesystem::v1::path::end ( ) const

inline

         {   // get end of path
         return (iterator(*this, _Mystr.size()));
         }

path experimental::filesystem::v1::path::extension ( ) const

inline

         {   // pick off .extension in filename (leaf), including dot
         string_type _Str = filename().native();
         size_t _Idx = _Str.rfind(_FS_PERIOD);
         return (_Idx == string_type::npos   // no .
             || _Str.size() == 1 // only .
             || (_Str.size() == 2 && _Str[0] == _FS_PERIOD
                 && _Str[1] == _FS_PERIOD)   // only ..
             ? path() : path(_Str.substr(_Idx)));
         }

path experimental::filesystem::v1::path::filename ( ) const

inline

         {   // get filename (leaf)
         return (empty() ? path() : path(*--end()));
         }

template<class _Elem , class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

basic_string<_Elem, _Traits, _Alloc> experimental::filesystem::v1::path::generic_string ( const _Alloc & _Al = _Alloc() ) const

inline

         {   // return path as basic_string<_Elem, _Traits, _Alloc>
         basic_string<_Elem, _Traits, _Alloc> _Str(_Al);
         const string_type _Genstr = _Make_generic();
         return (_Path_cvt<value_type, _Elem>::
             _Cvt(_Str, _Genstr.c_str(), _Genstr.size()));
         }

_STD string experimental::filesystem::v1::path::generic_string ( ) const

inline

         {   // return path as basic_string<char> native
         _STD string _Str;
         const string_type _Genstr = _Make_generic();
         return (_Path_cvt<value_type, char>::
             _Cvt(_Str, _Genstr.c_str(), _Genstr.size()));
         }

_STD u16string experimental::filesystem::v1::path::generic_u16string ( ) const

inline

         {   // return path as basic_string<char16_t> UTF16
         _STD u16string _Str;
         const string_type _Genstr = _Make_generic();
         return (_Path_cvt<value_type, char16_t>::
             _Cvt(_Str, _Genstr.c_str(), _Genstr.size()));
         }

_STD u32string experimental::filesystem::v1::path::generic_u32string ( ) const

delete

_STD string experimental::filesystem::v1::path::generic_u8string ( ) const

inline

         {   // return path as basic_string<char> UTF8
         _STD string _Str;
         const string_type _Genstr = _Make_generic();
         return (_Path_cvt<value_type, char8_t,
             char_traits<char>, allocator<char> >::
             _Cvt(_Str, _Genstr.c_str(), _Genstr.size()));
         }

_STD wstring experimental::filesystem::v1::path::generic_wstring ( ) const

inline

         {   // return path as basic_string<wchar_t> native
         _STD wstring _Str;
         const string_type _Genstr = _Make_generic();
         return (_Path_cvt<value_type, wchar_t>::
             _Cvt(_Str, _Genstr.c_str(), _Genstr.size()));
         }

bool experimental::filesystem::v1::path::has_extension ( ) const

inline

         {   // test if extension is nonempty
         return (!extension().empty());
         }

bool experimental::filesystem::v1::path::has_filename ( ) const

inline

         {   // test if filename (leaf) is nonempty
         return (!filename().empty());
         }

bool experimental::filesystem::v1::path::has_parent_path ( ) const

inline

         {   // test if parent (branch) path is nonempty
         return (!parent_path().empty());
         }

bool experimental::filesystem::v1::path::has_relative_path ( ) const

inline

         {   // test if relative path is nonempty
         return (!relative_path().empty());
         }

bool experimental::filesystem::v1::path::has_root_directory ( ) const

inline

         {   // test if root directory is nonempty
         return (!root_directory().empty());
         }

bool experimental::filesystem::v1::path::has_root_name ( ) const

inline

         {   // test if root name is nonempty
         return (!root_name().empty());
         }

bool experimental::filesystem::v1::path::has_root_path ( ) const

inline

         {   // test if root path is nonempty
         return (!root_path().empty());
         }

bool experimental::filesystem::v1::path::has_stem ( ) const

inline

         {   // test if stem (basename) is nonempty
         return (!stem().empty());
         }

bool experimental::filesystem::v1::path::is_absolute ( ) const

inline

         {   // test if path is absolute
         return (has_root_name() && has_root_directory());
         }

bool experimental::filesystem::v1::path::is_relative ( ) const

inline

         {   // test if path is relative
         return (!is_absolute());
         }

path& experimental::filesystem::v1::path::make_preferred ( )

inline

         {   // convert any '/' to '\'
         for (size_t _Idx = 0; _Idx < _Mystr.size(); ++_Idx)
 
             if (_Mystr[_Idx] == _FS_SLASH)
                 _Mystr[_Idx] = _FS_BSLASH;
 
         return (*this);
         }

const string_type& experimental::filesystem::v1::path::native ( ) const

inline

         {   // get the stored string
         return (_Mystr);
         }

experimental::filesystem::v1::path::operator string_type ( ) const

inline

         {   // convert to file string
         return (_Mystr);
         }

path& experimental::filesystem::v1::path::operator+= ( const path & _Path )

inline

         {   // concatenate copy
         return (concat(_Path._Mystr));
         }

template<class _Ty >

path& experimental::filesystem::v1::path::operator+= ( _Ty _Val )

inline

         {   // concatenate NTCTS, given iterator/element
         return (concat(_Val));
         }

template<class _Elem , class _Traits , class _Alloc >

path& experimental::filesystem::v1::path::operator+= ( const basic_string< _Elem, _Traits, _Alloc > & _Str )

inline

         {   // concatenate arbitrary source string
         return (concat(_Str));
         }

template<class _Elem >

path& experimental::filesystem::v1::path::operator+= ( const _Elem * _Ptr )

inline

         {   // concatenate arbitrary NTCTS
         return (concat(basic_string<_Elem>(_Ptr)));
         }

path& experimental::filesystem::v1::path::operator/= ( const path & _Path )

inline

         {   // append copy
         return (append(_Path._Mystr));
         }

template<class _InIt >

path& experimental::filesystem::v1::path::operator/= ( _InIt _First )

inline

         {   // append NTCTS, given iterator
         return (append(path(_First)._Mystr));
         }

template<class _Elem , class _Traits , class _Alloc >

path& experimental::filesystem::v1::path::operator/= ( const basic_string< _Elem, _Traits, _Alloc > & _Str )

inline

         {   // append arbitrary source string
         return (append(_Str));
         }

path& experimental::filesystem::v1::path::operator= ( path && _Right )

inline

         {   // move assign
         _Mystr = _STD move(_Right._Mystr);
         return (*this);
         }

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

inline

         {   // assign copy
         _Mystr = _Right._Mystr;
         return (*this);
         }

template<class _InIt >

path& experimental::filesystem::v1::path::operator= ( _InIt _First )

inline

         {   // assign from NTCTS, given iterator
         return (*this = path(_First));
         }

template<class _Elem , class _Traits , class _Alloc >

path& experimental::filesystem::v1::path::operator= ( const basic_string< _Elem, _Traits, _Alloc > & _Str )

inline

         {   // assign from arbitrary source string
         return (*this = path(_Str));
         }

path experimental::filesystem::v1::path::parent_path ( ) const

inline

         {   // get parent (branch) path
         path _Ans;
         if (!empty())
             {   // append all but last element
             iterator _End = --end();
             for (iterator _Next = begin(); _Next != _End; ++_Next)
                 _Ans /= *_Next;
             }
         return (_Ans);
         }

path experimental::filesystem::v1::path::relative_path ( ) const

inline

         {   // get relative path
         size_t _Idx = _Root_end();
         while (_Idx < _Mystr.size()
             && _FS_ISSEP(_Mystr[_Idx]))
             ++_Idx; // skip extra '/' after root
 
         return (path(_Mystr.substr(_Idx)));
         }

path& experimental::filesystem::v1::path::remove_filename ( )

inline

         {   // remove filename (leaf)
         if (!empty() && begin() != --end())
             {   // leaf to remove, back up over it
             size_t _Rend = _Root_end();
             size_t _Idx = _Mystr.size();
 
             for (; _Rend < _Idx; --_Idx)
                 if (_FS_ISSEP(_Mystr[_Idx - 1]))
                     break;  // back up over stuff at end
             for (; _Rend < _Idx; --_Idx)
                 if (!_FS_ISSEP(_Mystr[_Idx - 1]))
                     break;  // back up over trailing non-root slashes
             _Mystr.erase(_Idx);
             }
         return (*this);
         }

path& experimental::filesystem::v1::path::replace_extension ( const path & _Newext = path() )

inline

         {   // replace extension with _Newext
         if (_Newext.empty() || _Newext.c_str()[0] == _FS_PERIOD)
             *this = parent_path()
                 / path((stem().native() + _Newext.native()));
         else
             *this = parent_path()
                 / path((stem().native() + _FS_PERIOD + _Newext.native()));
         return (*this);
         }

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

inline

         {   // replace filename
         remove_filename();
         *this /= _Path;
         return (*this);
         }

path experimental::filesystem::v1::path::root_directory ( ) const

inline

         {   // get root directory
         size_t _Idx = _Prefix_end();
         if (_Idx < _Mystr.size()
             && _FS_ISSEP(_Mystr[_Idx]))
             return (path(string_type(1, _FS_PREF)));
         else
             return (path());
         }

path experimental::filesystem::v1::path::root_name ( ) const

inline

         {   // get root name
         return (path(_Mystr.substr(0, _Prefix_end())));
         }

path experimental::filesystem::v1::path::root_path ( ) const

inline

         {   // get root path
         return (path(_Mystr.c_str(),
             _Mystr.c_str() + _Root_end()));
         }

path experimental::filesystem::v1::path::stem ( ) const

inline

         {   // pick off stem (basename) in filename (leaf) before dot
         string_type _Str0 = filename().native();
         string_type _Str1 = extension().native();
         _Str0.resize(_Str0.size() - _Str1.size());
         return (path(_Str0));
         }

template<class _Elem , class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

basic_string<_Elem, _Traits, _Alloc> experimental::filesystem::v1::path::string ( const _Alloc & _Al = _Alloc() ) const

inline

         {   // return path as basic_string<_Elem, _Traits, _Alloc>
         basic_string<_Elem, _Traits, _Alloc> _Str(_Al);
         return (_Path_cvt<value_type, _Elem>::
             _Cvt(_Str, _Mystr.c_str(), _Mystr.size()));
         }

_STD string experimental::filesystem::v1::path::string ( ) const

inline

         {   // return path as basic_string<char> native
         _STD string _Str;
         return (_Path_cvt<value_type, char>::
             _Cvt(_Str, _Mystr.c_str(), _Mystr.size()));
         }

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

inline

         {   // swap the stored strings
         _Mystr.swap(_Right._Mystr);
         }

_STD u16string experimental::filesystem::v1::path::u16string ( ) const

inline

         {   // return path as basic_string<char16_t> UTF16
         _STD u16string _Str;
         return (_Path_cvt<value_type, char16_t>::
             _Cvt(_Str, _Mystr.c_str(), _Mystr.size()));
         }

_STD u32string experimental::filesystem::v1::path::u32string ( ) const

delete

_STD string experimental::filesystem::v1::path::u8string ( ) const

inline

         {   // return path as basic_string<char> UTF8
         _STD string _Str;
         return (_Path_cvt<value_type, char8_t,
             char_traits<char>, allocator<char> >::
             _Cvt(_Str, _Mystr.c_str(), _Mystr.size()));
         }

_STD wstring experimental::filesystem::v1::path::wstring ( ) const

inline

         {   // return path as basic_string<wchar_t> native
         _STD wstring _Str;
         return (_Path_cvt<value_type, wchar_t>::
             _Cvt(_Str, _Mystr.c_str(), _Mystr.size()));
         }

Member Data Documentation

string_type experimental::filesystem::v1::path::_Mystr

constexpr value_type experimental::filesystem::v1::path::preferred_separator = _FS_PREF

static

The documentation for this class was generated from the following file:

VS2015/inc/filesystem

Public Types

Public Member Functions

Public Attributes

Static Public Attributes

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation