Public Types
typedef basic_path< _String, _Traits >	path_type

typedef _String	string_type

typedef _Traits	traits_type

typedef _String::value_type	value_type

typedef _Traits::external_string_type	external_string_type

typedef _Path_iterator< path_type >	iterator

typedef iterator	const_iterator

Public Member Functions
	basic_path ()

	basic_path (const string_type &_Str)

	basic_path (const value_type *_Ptr)

template<class _InIt >
	basic_path (_InIt _First, _InIt _Last)

	basic_path (const basic_path &_Right)

basic_path &	operator= (const basic_path &_Right)

	~basic_path () _NOEXCEPT

	basic_path (basic_path &&_Right)

basic_path &	operator= (basic_path &&_Right)

basic_path &	operator= (const string_type &_Str)

basic_path &	operator= (const value_type *_Ptr)

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

basic_path &	operator/= (const basic_path &_Pval)

basic_path &	operator/= (const string_type &_Str)

basic_path &	operator/= (const value_type *_Ptr)

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

void	clear ()

void	swap (basic_path &_Right)

basic_path &	remove_leaf ()

basic_path &	remove_filename ()

basic_path &	replace_extension (const string_type &_Newext=string_type())

string_type	string () const

string_type	file_string () const

	operator string_type () const

string_type	directory_string () const

external_string_type	external_file_string () const

external_string_type	external_directory_string () const

string_type	root_name () const

string_type	root_directory () const

string_type	leaf () const

string_type	filename () const

basic_path	root_path () const

basic_path	relative_path () const

basic_path	branch_path () const

basic_path	parent_path () const

string_type	basename () const

string_type	stem () const

string_type	extension () const

bool	empty () const

bool	is_complete () const

bool	has_root_name () const

bool	has_root_directory () const

bool	has_leaf () const

bool	has_filename () const

bool	has_root_path () const

bool	has_relative_path () const

bool	has_branch_path () const

bool	has_parent_path () const

iterator	begin () const

iterator	end () const

size_t	_Prefix_end () const

size_t	_Root_end () const

const value_type *	_Ptr () const

Public Attributes
string_type	_Mystr

Member Typedef Documentation

template<class _String , class _Traits >

typedef iterator tr2::sys::basic_path< _String, _Traits >::const_iterator

template<class _String , class _Traits >

typedef _Traits::external_string_type tr2::sys::basic_path< _String, _Traits >::external_string_type

template<class _String , class _Traits >

typedef _Path_iterator<path_type> tr2::sys::basic_path< _String, _Traits >::iterator

template<class _String , class _Traits >

typedef basic_path<_String, _Traits> tr2::sys::basic_path< _String, _Traits >::path_type

template<class _String , class _Traits >

typedef _String tr2::sys::basic_path< _String, _Traits >::string_type

template<class _String , class _Traits >

typedef _Traits tr2::sys::basic_path< _String, _Traits >::traits_type

template<class _String , class _Traits >

typedef _String::value_type tr2::sys::basic_path< _String, _Traits >::value_type

Constructor & Destructor Documentation

template<class _String , class _Traits >

tr2::sys::basic_path< _String, _Traits >::basic_path ( )

inline

283 { // default construct

284 }

template<class _String , class _Traits >

tr2::sys::basic_path< _String, _Traits >::basic_path ( const string_type & _Str )

inline

         {   // construct from string
         *this /= _Str;
         }

template<class _String , class _Traits >

tr2::sys::basic_path< _String, _Traits >::basic_path ( const value_type * _Ptr )

inline

         {   // construct from NTBS
         *this /= _Ptr;
         }

template<class _String , class _Traits >

template<class _InIt >

tr2::sys::basic_path< _String, _Traits >::basic_path	(	_InIt	_First,
		_InIt	_Last
	)

inline

         {   // construct from [_First, _Last)
         append(_First, _Last);
         }

template<class _String , class _Traits >

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

inline

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

template<class _String , class _Traits >

tr2::sys::basic_path< _String, _Traits >::~basic_path ( )

inline

314 { // destroy the object

315 }

template<class _String , class _Traits >

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

inline

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

Member Function Documentation

template<class _String , class _Traits >

size_t tr2::sys::basic_path< _String, _Traits >::_Prefix_end ( ) const

inline

         {   // get end of prefix
         size_t _Idx = _Mystr.find(colon<path_type>::value, 0);
         if (_Idx == _Mystr.npos)
             _Idx = 0;
         else
             ++_Idx;
         return (_Idx);
         }

template<class _String , class _Traits >

const value_type* tr2::sys::basic_path< _String, _Traits >::_Ptr ( ) const

inline

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

template<class _String , class _Traits >

size_t tr2::sys::basic_path< _String, _Traits >::_Root_end ( ) const

inline

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

template<class _String , class _Traits >

template<class _InIt >

basic_path& tr2::sys::basic_path< _String, _Traits >::append	(	_InIt	_First,
		_InIt	_Last
	)

inline

         {   // append [_First, _Last)
         string_type _Str = _Mystr;  // avoid overlap
         size_t _Oldsize = _Str.size();
         for (; _First != _Last && *_First != value_type(0); ++_First)
             _Str.push_back(*_First);
 
         if (_Oldsize + 3 <= _Str.size()
             && _Str[_Oldsize] == slash<path_type>::value
             && _Str[_Oldsize + 1] == slash<path_type>::value
             && _Str[_Oldsize + 2] == colon<path_type>::value)
             _Str.erase(_Oldsize, 3);    // drop leading escape sequence
 
         for (size_t _Idx = _Oldsize; _Idx < _Str.size(); ++_Idx)
             if (_Str[_Idx] == _Altslash<path_type>::value)
                 _Str[_Idx] = slash<path_type>::value;   // convert '\' to '/'
 
         if (0 < _Oldsize && _Oldsize < _Str.size()
             && _Str[_Oldsize - 1] != colon<path_type>::value
             && _Str[_Oldsize - 1] != slash<path_type>::value
             && _Str[_Oldsize] != slash<path_type>::value)
             _Str.insert(_Oldsize, 1, slash<path_type>::value);  // add '/'
 
         _Mystr = _Str;  // copy back new filename
         return (*this);
         }

template<class _String , class _Traits >

template<class _InIt >

basic_path& tr2::sys::basic_path< _String, _Traits >::assign	(	_InIt	_First,
		_InIt	_Last
	)

inline

         {   // assign from [_First, _Last)
         clear();
         return (append(_First, _Last));
         }

template<class _String , class _Traits >

string_type tr2::sys::basic_path< _String, _Traits >::basename ( ) const

inline

         {   // pick off base name in leaf before dot
         string_type _Str = leaf();
         size_t _Idx = _Str.rfind(dot<path_type>::value);
         return (_Str.substr(0, _Idx));
         }

template<class _String , class _Traits >

iterator tr2::sys::basic_path< _String, _Traits >::begin ( ) const

inline

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

template<class _String , class _Traits >

basic_path tr2::sys::basic_path< _String, _Traits >::branch_path ( ) const

inline

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

template<class _String , class _Traits >

void tr2::sys::basic_path< _String, _Traits >::clear ( )

inline

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

template<class _String , class _Traits >

string_type tr2::sys::basic_path< _String, _Traits >::directory_string ( ) const

inline

         {   // get the stored string, directory form
         return (file_string());
         }

template<class _String , class _Traits >

bool tr2::sys::basic_path< _String, _Traits >::empty ( ) const

inline

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

template<class _String , class _Traits >

iterator tr2::sys::basic_path< _String, _Traits >::end ( ) const

inline

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

template<class _String , class _Traits >

string_type tr2::sys::basic_path< _String, _Traits >::extension ( ) const

inline

         {   // pick off .extension in leaf, including dot
         string_type _Str = leaf();
         size_t _Idx = _Str.rfind(dot<path_type>::value);
         return (_Idx == string_type::npos
             ? string_type() : _Str.substr(_Idx));
         }

template<class _String , class _Traits >

external_string_type tr2::sys::basic_path< _String, _Traits >::external_directory_string ( ) const

inline

         {   // get external form of directory string
         return (_Traits::to_external(*this, directory_string()));
         }

template<class _String , class _Traits >

external_string_type tr2::sys::basic_path< _String, _Traits >::external_file_string ( ) const

inline

         {   // get external form of file string
         return (_Traits::to_external(*this, file_string()));
         }

template<class _String , class _Traits >

string_type tr2::sys::basic_path< _String, _Traits >::file_string ( ) const

inline

         {   // get the stored string, native form
         string_type _Ans;
         size_t _Idx = 0;
         size_t _Size = _Mystr.size();
 
         if (2 <= _Size && _Mystr[0] == slash<path_type>::value)
             while (_Idx < _Size - 1
                 && _Mystr[_Idx + 1] == slash<path_type>::value)
                 ++_Idx; // compress leading slashes
         for (; _Idx < _Size; ++_Idx)
             if (_Mystr[_Idx] == slash<path_type>::value)
                 _Ans.append(1, _Altslash<path_type>::value);    // convert '/' to '\'
             else
                 _Ans.append(1, _Mystr[_Idx]);
         return (_Ans);
         }

template<class _String , class _Traits >

string_type tr2::sys::basic_path< _String, _Traits >::filename ( ) const

inline

         {   // get leaf
         return (leaf());
         }

template<class _String , class _Traits >

bool tr2::sys::basic_path< _String, _Traits >::has_branch_path ( ) const

inline

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

template<class _String , class _Traits >

bool tr2::sys::basic_path< _String, _Traits >::has_filename ( ) const

inline

         {   // test if leaf is nonempty
         return (has_leaf());
         }

template<class _String , class _Traits >

bool tr2::sys::basic_path< _String, _Traits >::has_leaf ( ) const

inline

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

template<class _String , class _Traits >

bool tr2::sys::basic_path< _String, _Traits >::has_parent_path ( ) const

inline

         {   // test if branch path is nonempty
         return (has_branch_path());
         }

template<class _String , class _Traits >

bool tr2::sys::basic_path< _String, _Traits >::has_relative_path ( ) const

inline

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

template<class _String , class _Traits >

bool tr2::sys::basic_path< _String, _Traits >::has_root_directory ( ) const

inline

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

template<class _String , class _Traits >

bool tr2::sys::basic_path< _String, _Traits >::has_root_name ( ) const

inline

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

template<class _String , class _Traits >

bool tr2::sys::basic_path< _String, _Traits >::has_root_path ( ) const

inline

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

template<class _String , class _Traits >

bool tr2::sys::basic_path< _String, _Traits >::is_complete ( ) const

inline

         {   // test if root name is complete
         return (has_root_name() && has_root_directory());
         }

template<class _String , class _Traits >

string_type tr2::sys::basic_path< _String, _Traits >::leaf ( ) const

inline

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

template<class _String , class _Traits >

tr2::sys::basic_path< _String, _Traits >::operator string_type ( ) const

inline

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

template<class _String , class _Traits >

basic_path& tr2::sys::basic_path< _String, _Traits >::operator/= ( const basic_path< _String, _Traits > & _Pval )

inline

         {   // append copy
         return (append(_Pval._Mystr.c_str(),
             _Pval._Mystr.c_str() + _Pval._Mystr.size()));
         }

template<class _String , class _Traits >

basic_path& tr2::sys::basic_path< _String, _Traits >::operator/= ( const string_type & _Str )

inline

         {   // append string
         return (append(_Str.c_str(),
             _Str.c_str() + _Str.size()));
         }

template<class _String , class _Traits >

basic_path& tr2::sys::basic_path< _String, _Traits >::operator/= ( const value_type * _Ptr )

inline

         {   // append NTBS
         const value_type *_Ptr2 = _Ptr;
         for (; *_Ptr2 != 0; ++_Ptr2)
             ;
         return (append(_Ptr, _Ptr2));
         }

template<class _String , class _Traits >

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

inline

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

template<class _String , class _Traits >

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

inline

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

template<class _String , class _Traits >

basic_path& tr2::sys::basic_path< _String, _Traits >::operator= ( const string_type & _Str )

inline

         {   // assign from string
         if (&_Mystr == &_Str)
             return (*this); // self assignment
         else
             {   // strings differ, clear and append
             clear();
             return (*this /= _Str);
             }
         }

template<class _String , class _Traits >

basic_path& tr2::sys::basic_path< _String, _Traits >::operator= ( const value_type * _Ptr )

inline

         {   // assign from NTBS
         clear();
         return (*this /= _Ptr);
         }

template<class _String , class _Traits >

basic_path tr2::sys::basic_path< _String, _Traits >::parent_path ( ) const

inline

         {   // get branch path
         return (branch_path());
         }

template<class _String , class _Traits >

basic_path tr2::sys::basic_path< _String, _Traits >::relative_path ( ) const

inline

         {   // get relative path
         size_t _Idx = _Root_end();
         while (_Idx < _Mystr.size()
             && _Mystr[_Idx] == slash<path_type>::value)
             ++_Idx; // skip extra '/' after root
 
         return (basic_path(_Mystr.c_str() + _Idx,
             _Mystr.c_str() + _Mystr.size()));
         }

template<class _String , class _Traits >

basic_path& tr2::sys::basic_path< _String, _Traits >::remove_filename ( )

inline

         {   // remove leaf
         return (remove_leaf());
         }

template<class _String , class _Traits >

basic_path& tr2::sys::basic_path< _String, _Traits >::remove_leaf ( )

inline

         {   // remove 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 (_Mystr[_Idx - 1] == slash<path_type>::value)
                     break;  // back up over stuff at end
             for (; _Rend < _Idx; --_Idx)
                 if (_Mystr[_Idx - 1] != slash<path_type>::value)
                     break;  // back up over trailing non-root slashes
             _Mystr.erase(_Idx);
             }
         return (*this);
         }

template<class _String , class _Traits >

basic_path& tr2::sys::basic_path< _String, _Traits >::replace_extension ( const string_type & _Newext = string_type() )

inline

         {   // replace extension with _Newext
         if (_Newext.empty() || _Newext[0] == dot<path_type>::value)
             *this = branch_path()
                 / basic_path((stem() + _Newext));
         else
             *this = branch_path()
                 / basic_path((stem() + dot<path_type>::value + _Newext));
         return (*this);
         }

template<class _String , class _Traits >

string_type tr2::sys::basic_path< _String, _Traits >::root_directory ( ) const

inline

         {   // get root directory
         size_t _Idx = _Prefix_end();
         if (_Idx < _Mystr.size()
             && _Mystr[_Idx] == slash<path_type>::value)
             return (string_type(1, slash<path_type>::value));
         else
             return (string_type());
         }

template<class _String , class _Traits >

string_type tr2::sys::basic_path< _String, _Traits >::root_name ( ) const

inline

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

template<class _String , class _Traits >

basic_path tr2::sys::basic_path< _String, _Traits >::root_path ( ) const

inline

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

template<class _String , class _Traits >

string_type tr2::sys::basic_path< _String, _Traits >::stem ( ) const

inline

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

template<class _String , class _Traits >

string_type tr2::sys::basic_path< _String, _Traits >::string ( ) const

inline

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

template<class _String , class _Traits >

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

inline

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

Member Data Documentation

template<class _String , class _Traits >

string_type tr2::sys::basic_path< _String, _Traits >::_Mystr

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

VS2013/inc/filesystem

Public Types

Public Member Functions

Public Attributes

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation