tr2::sys::_Path_iterator< _Path > Class Template Reference

Inheritance diagram for tr2::sys::_Path_iterator< _Path >:

Public Types
typedef _Path_iterator< _Path >	_Myt
typedef _Path	path_type
typedef _Path::string_type	string_type
typedef const _Path::string_type *	pointer
typedef const _Path::string_type &	reference
Public Types inherited from iterator< bidirectional_iterator_tag, _Path::string_type, ptrdiff_t, _Path::string_type *, _Path::string_type & >
typedef bidirectional_iterator_tag	iterator_category
typedef _Path::string_type	value_type
typedef ptrdiff_t	difference_type
typedef ptrdiff_t	distance_type
typedef _Path::string_type *	pointer
typedef _Path::string_type &	reference

Public Member Functions
	_Path_iterator ()
	_Path_iterator (const path_type &_Pval, size_t _Off)
	_Path_iterator (const _Path_iterator &_Right)
_Path_iterator &	operator= (const _Path_iterator &_Right)
	_Path_iterator (_Path_iterator &&_Right)
_Path_iterator &	operator= (_Path_iterator &&_Right)
reference	operator* () const
pointer	operator-> () const
_Myt &	operator++ ()
_Myt	operator++ (int)
_Myt &	operator-- ()
_Myt	operator-- (int)
bool	operator== (const _Myt &_Right) const
bool	operator!= (const _Myt &_Right) const

Private Member Functions
void	_Getval ()

Private Attributes
const path_type *	_Myptr
string_type	_Myelem
size_t	_Myoff

Member Typedef Documentation

template<class _Path >

typedef _Path_iterator<_Path> tr2::sys::_Path_iterator< _Path >::_Myt

template<class _Path >

typedef _Path tr2::sys::_Path_iterator< _Path >::path_type

template<class _Path >

typedef const _Path::string_type* tr2::sys::_Path_iterator< _Path >::pointer

template<class _Path >

typedef const _Path::string_type& tr2::sys::_Path_iterator< _Path >::reference

template<class _Path >

typedef _Path::string_type tr2::sys::_Path_iterator< _Path >::string_type

Constructor & Destructor Documentation

template<class _Path >

tr2::sys::_Path_iterator< _Path >::_Path_iterator ( )

inline

        : _Myptr(0), _Myoff(0)
        {   // construct singular iterator
        }

template<class _Path >

tr2::sys::_Path_iterator< _Path >::_Path_iterator ( const path_type &  _Pval, size_t  _Off  )

inline

        : _Myptr(&_Pval), _Myoff(_Off)
        {   // construct iterator
        _Getval();
        }

template<class _Path >

tr2::sys::_Path_iterator< _Path >::_Path_iterator ( const _Path_iterator< _Path > &  _Right )

inline

        : _Myptr(_Right._Myptr),
            _Myelem(_Right._Myelem),
            _Myoff(_Right._Myoff)
        {   // copy construct
        }

template<class _Path >

tr2::sys::_Path_iterator< _Path >::_Path_iterator ( _Path_iterator< _Path > &&  _Right )

inline

        : _Myptr(_Right._Myptr),
            _Myelem(_STD move(_Right._Myelem)),
            _Myoff(_Right._Myoff)
        {   // move construct
        }

Member Function Documentation

template<class _Path >

void tr2::sys::_Path_iterator< _Path >::_Getval ( )

inlineprivate

        {   // determine _Myelem
        size_t _Pend = _Myptr->_Prefix_end();
        size_t _Size = _Myptr->_Mystr.size();

        _Myelem.clear();
        if (_Size <= _Myoff)
            ;   // off end, no field
        else if (_Myoff < _Pend)
            _Myelem = _Myptr->_Mystr.substr(0, _Pend);  // get "x:"
        else if (_Myoff == _Pend && _Pend < _Size
            && _Myptr->_Mystr[_Pend] == slash<path_type>::value)
            _Myelem = slash<path_type>::value;  // get "/"
        else
            {   // determine next field as slashes followed by stuff
            size_t _Nslash = 0;
            size_t _Nstuff = 0;

            for (; _Myoff + _Nslash < _Size; ++_Nslash)
                if (_Myptr->_Mystr[_Myoff + _Nslash]
                    != slash<path_type>::value)
                    break;
            for (; _Myoff + _Nslash + _Nstuff < _Size; ++_Nstuff)
                if (_Myptr->_Mystr[_Myoff + _Nslash + _Nstuff]
                    == slash<path_type>::value)
                    break;
            if (0 < _Nstuff)
                _Myelem = _Myptr->_Mystr.substr(_Myoff + _Nslash,
                    _Nstuff);   // get "stuff"
            else if (0 < _Nslash)
                _Myelem = dot<path_type>::value;    // get "."
            }
        }

template<class _Path >

bool tr2::sys::_Path_iterator< _Path >::operator!= ( const _Myt &  _Right ) const

inline

        {   // test for iterator inequality
        return (!(*this == _Right));
        }

template<class _Path >

reference tr2::sys::_Path_iterator< _Path >::operator* ( ) const

inline

        {   // return designated value
        return (_Myelem);
        }

template<class _Path >

_Myt& tr2::sys::_Path_iterator< _Path >::operator++ ( )

inline

        {   // preincrement
 #pragma warning(push)
 #pragma warning(disable: 6011) /* quiet analyze noise */

 #if _ITERATOR_DEBUG_LEVEL == 2
        if (_Myptr == 0 || _Myptr->_Mystr.size() <= _Myoff)
            _DEBUG_ERROR(
                "basic_path<T>::iterator is not incrementable");

 #elif _ITERATOR_DEBUG_LEVEL == 1
        _SCL_SECURE_VALIDATE(_Myptr != 0 && _Myoff < _Myptr->_Mystr.size());
 #endif /* _ITERATOR_DEBUG_LEVEL */

        size_t _Pend = _Myptr->_Prefix_end();
        size_t _Size = _Myptr->_Mystr.size();

        if (_Myoff < _Pend)
            _Myoff = _Pend; // point past "x:"
        else if (_Myoff == _Pend && _Pend < _Size
            && _Myptr->_Mystr[_Pend] == slash<path_type>::value)
            {   // point past root "/" and following slashes
            for (++_Myoff; _Myoff < _Size; ++_Myoff)
                if (_Myptr->_Mystr[_Myoff]
                    != slash<path_type>::value)
                    break;
            }
        else
            {   // point past slashes followed by stuff
            for (; _Myoff < _Size; ++_Myoff)
                if (_Myptr->_Mystr[_Myoff]
                    != slash<path_type>::value)
                    break;
            for (; _Myoff < _Size; ++_Myoff)
                if (_Myptr->_Mystr[_Myoff]
                    == slash<path_type>::value)
                    break;
            }
        _Getval();
        return (*this);

 #pragma warning(pop)
        }

template<class _Path >

_Myt tr2::sys::_Path_iterator< _Path >::operator++ ( int  )

inline

        {   // postincrement
        _Myt _Tmp = *this;
        ++*this;
        return (_Tmp);
        }

template<class _Path >

_Myt& tr2::sys::_Path_iterator< _Path >::operator-- ( )

inline

        {   // predecrement
 #if _ITERATOR_DEBUG_LEVEL == 2
        if (_Myptr == 0 || _Myoff == 0)
            _DEBUG_ERROR(
                "basic_path<T>::iterator is not decrementable");

 #elif _ITERATOR_DEBUG_LEVEL == 1
        _SCL_SECURE_VALIDATE(_Myptr != 0 && _Myoff != 0);
 #endif /* _ITERATOR_DEBUG_LEVEL */

        size_t _Myoff_sav = _Myoff;
        size_t _Off_back = 0;
        _Myoff = 0;
        do
            {   // scan down to previous
            _Off_back = _Myoff;
            ++*this;
            } while (_Myoff < _Myoff_sav);
        _Myoff = _Off_back;
        _Getval();
        return (*this);
        }

template<class _Path >

_Myt tr2::sys::_Path_iterator< _Path >::operator-- ( int  )

inline

        {   // postdecrement
        _Myt _Tmp = *this;
        --*this;
        return (_Tmp);
        }

template<class _Path >

pointer tr2::sys::_Path_iterator< _Path >::operator-> ( ) const

inline

        {   // return pointer to class object
        return (_STD pointer_traits<pointer>::pointer_to(**this));
        }

template<class _Path >

_Path_iterator& tr2::sys::_Path_iterator< _Path >::operator= ( const _Path_iterator< _Path > &  _Right )

inline

        {   // copy assign
        _Myptr = _Right._Myptr;
        _Myelem = _Right._Myelem;
        _Myoff = _Right._Myoff;
        return (*this);
        }

template<class _Path >

_Path_iterator& tr2::sys::_Path_iterator< _Path >::operator= ( _Path_iterator< _Path > &&  _Right )

inline

        {   // move assign
        _Myptr = _Right._Myptr;
        _Myelem = _STD move(_Right._Myelem);
        _Myoff = _Right._Myoff;
        return (*this);
        }

template<class _Path >

bool tr2::sys::_Path_iterator< _Path >::operator== ( const _Myt &  _Right ) const

inline

        {   // test for iterator equality
        return (_Myptr == _Right._Myptr && _Myoff == _Right._Myoff);
        }

Member Data Documentation

template<class _Path >

string_type tr2::sys::_Path_iterator< _Path >::_Myelem

private

template<class _Path >

size_t tr2::sys::_Path_iterator< _Path >::_Myoff

private

template<class _Path >

const path_type* tr2::sys::_Path_iterator< _Path >::_Myptr

private

---

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

• VS2013/inc/filesystem