STLdoc: regex_token_iterator< _BidIt, _Elem, _RxTraits > Class Template Reference

STLdoc

STLdocumentation

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros

Public Types
typedef regex_iterator< _BidIt, _Elem, _RxTraits >	_Position

typedef regex_token_iterator< _BidIt, _Elem, _RxTraits >	_Myt

typedef basic_regex< _Elem, _RxTraits >	regex_type

typedef sub_match< _BidIt >	value_type

typedef ptrdiff_t	difference_type

typedef const value_type *	pointer

typedef const value_type &	reference

typedef forward_iterator_tag	iterator_category

Public Member Functions
	regex_token_iterator ()

	regex_token_iterator (_BidIt _First, _BidIt _Last, const regex_type &_Re, int _Sub=0, regex_constants::match_flag_type _Fl=regex_constants::match_default)

	regex_token_iterator (_BidIt _First, _BidIt _Last, const regex_type &_Re, const vector< int > &_Subx, regex_constants::match_flag_type _Fl=regex_constants::match_default)

template<size_t _Nx>
	regex_token_iterator (_BidIt _First, _BidIt _Last, const regex_type &_Re, const int(&_Subx)[_Nx], regex_constants::match_flag_type _Fl=regex_constants::match_default)

	regex_token_iterator (_BidIt _First, _BidIt _Last, const regex_type &_Re, _XSTD initializer_list< int > _Ilist, regex_constants::match_flag_type _Fl=regex_constants::match_default)

	regex_token_iterator (const regex_token_iterator &_Right)

regex_token_iterator &	operator= (const regex_token_iterator &_Right)

bool	operator== (const _Myt &_Right) const

bool	operator!= (const _Myt &_Right) const

const value_type &	operator* () const

pointer	operator-> () const

_Myt &	operator++ ()

_Myt	operator++ (int)

Private Member Functions
bool	_Has_suffix () const

void	_Init (_BidIt _First, _BidIt _Last)

const value_type *	_Current () const

Private Attributes
_Position	_Pos

const value_type *	_Res

value_type	_Suffix

size_t	_Cur

vector< int >	_Subs

Member Typedef Documentation

template<class _BidIt , class _Elem = _REGEX_VALT(_BidIt), class _RxTraits = regex_traits<_Elem>>

typedef regex_token_iterator<_BidIt, _Elem, _RxTraits> regex_token_iterator< _BidIt, _Elem, _RxTraits >::_Myt

template<class _BidIt , class _Elem = _REGEX_VALT(_BidIt), class _RxTraits = regex_traits<_Elem>>

typedef regex_iterator<_BidIt, _Elem, _RxTraits> regex_token_iterator< _BidIt, _Elem, _RxTraits >::_Position

template<class _BidIt , class _Elem = _REGEX_VALT(_BidIt), class _RxTraits = regex_traits<_Elem>>

typedef ptrdiff_t regex_token_iterator< _BidIt, _Elem, _RxTraits >::difference_type

template<class _BidIt , class _Elem = _REGEX_VALT(_BidIt), class _RxTraits = regex_traits<_Elem>>

typedef forward_iterator_tag regex_token_iterator< _BidIt, _Elem, _RxTraits >::iterator_category

template<class _BidIt , class _Elem = _REGEX_VALT(_BidIt), class _RxTraits = regex_traits<_Elem>>

typedef const value_type* regex_token_iterator< _BidIt, _Elem, _RxTraits >::pointer

template<class _BidIt , class _Elem = _REGEX_VALT(_BidIt), class _RxTraits = regex_traits<_Elem>>

typedef const value_type& regex_token_iterator< _BidIt, _Elem, _RxTraits >::reference

template<class _BidIt , class _Elem = _REGEX_VALT(_BidIt), class _RxTraits = regex_traits<_Elem>>

typedef basic_regex<_Elem, _RxTraits> regex_token_iterator< _BidIt, _Elem, _RxTraits >::regex_type

template<class _BidIt , class _Elem = _REGEX_VALT(_BidIt), class _RxTraits = regex_traits<_Elem>>

typedef sub_match<_BidIt> regex_token_iterator< _BidIt, _Elem, _RxTraits >::value_type

Constructor & Destructor Documentation

template<class _BidIt , class _Elem = _REGEX_VALT(_BidIt), class _RxTraits = regex_traits<_Elem>>

regex_token_iterator< _BidIt, _Elem, _RxTraits >::regex_token_iterator ( )

inline

         : _Res(0)
         {   // construct end of sequence iterator
         }

template<class _BidIt , class _Elem = _REGEX_VALT(_BidIt), class _RxTraits = regex_traits<_Elem>>

regex_token_iterator< _BidIt, _Elem, _RxTraits >::regex_token_iterator	(	_BidIt	_First,
		_BidIt	_Last,
		const regex_type &	_Re,
		int	_Sub = `0`,
		regex_constants::match_flag_type	_Fl = `regex_constants::match_default`
	)

inline

         : _Pos(_First, _Last, _Re, _Fl), _Cur(0), _Subs(&_Sub, &_Sub + 1)
         {   // construct from RE, target text, and single submatch specifier
         _Init(_First, _Last);
         }

template<class _BidIt , class _Elem = _REGEX_VALT(_BidIt), class _RxTraits = regex_traits<_Elem>>

regex_token_iterator< _BidIt, _Elem, _RxTraits >::regex_token_iterator	(	_BidIt	_First,
		_BidIt	_Last,
		const regex_type &	_Re,
		const vector< int > &	_Subx,
		regex_constants::match_flag_type	_Fl = `regex_constants::match_default`
	)

inline

         : _Pos(_First, _Last, _Re, _Fl), _Cur(0),
             _Subs(_Subx.begin(), _Subx.end())
         {   // construct from RE, target text, and vector submatch specifier
         if (_Subs.empty())
             _Res = 0;   // treat empty vector as end of sequence
         else
             _Init(_First, _Last);
         }

template<class _BidIt , class _Elem = _REGEX_VALT(_BidIt), class _RxTraits = regex_traits<_Elem>>

template<size_t _Nx>

regex_token_iterator< _BidIt, _Elem, _RxTraits >::regex_token_iterator	(	_BidIt	_First,
		_BidIt	_Last,
		const regex_type &	_Re,
		const int(&)	_Subx[_Nx],
		regex_constants::match_flag_type	_Fl = `regex_constants::match_default`
	)

inline

         : _Pos(_First, _Last, _Re, _Fl), _Cur(0),
             _Subs(_Subx, _Subx + _Nx)
         {   // construct from RE, target text, and array submatch specifier
         _Init(_First, _Last);
         }

template<class _BidIt , class _Elem = _REGEX_VALT(_BidIt), class _RxTraits = regex_traits<_Elem>>

regex_token_iterator< _BidIt, _Elem, _RxTraits >::regex_token_iterator	(	_BidIt	_First,
		_BidIt	_Last,
		const regex_type &	_Re,
		_XSTD initializer_list< int >	_Ilist,
		regex_constants::match_flag_type	_Fl = `regex_constants::match_default`
	)

inline

         : _Pos(_First, _Last, _Re, _Fl), _Cur(0),
             _Subs(_Ilist.begin(), _Ilist.end())
         {   // construct from RE, target text, and ilist submatch specifier
         _Init(_First, _Last);
         }

template<class _BidIt , class _Elem = _REGEX_VALT(_BidIt), class _RxTraits = regex_traits<_Elem>>

regex_token_iterator< _BidIt, _Elem, _RxTraits >::regex_token_iterator ( const regex_token_iterator< _BidIt, _Elem, _RxTraits > & _Right )

inline

         : _Pos(_Right._Pos), _Cur(_Right._Cur),
             _Suffix(_Right._Suffix), _Subs(_Right._Subs)
         {   // construct copy of _Right
         if (_Right._Res == 0)
             _Res = 0;
         else if (_Right._Res == &_Right._Suffix)
             _Res = &_Suffix;
         else
             _Res = _Current();
         }

Member Function Documentation

template<class _BidIt , class _Elem = _REGEX_VALT(_BidIt), class _RxTraits = regex_traits<_Elem>>

const value_type* regex_token_iterator< _BidIt, _Elem, _RxTraits >::_Current ( ) const

inlineprivate

         {   // return pointer to current submatch
         return (&(_Subs[_Cur] == -1
             ? _Pos->prefix() : (*_Pos)[_Subs[_Cur]]));
         }

template<class _BidIt , class _Elem = _REGEX_VALT(_BidIt), class _RxTraits = regex_traits<_Elem>>

bool regex_token_iterator< _BidIt, _Elem, _RxTraits >::_Has_suffix ( ) const

inlineprivate

         {   // check for suffix specifier
         return (_STD find(_Subs.begin(), _Subs.end(), -1) != _Subs.end());
         }

template<class _BidIt , class _Elem = _REGEX_VALT(_BidIt), class _RxTraits = regex_traits<_Elem>>

void regex_token_iterator< _BidIt, _Elem, _RxTraits >::_Init	(	_BidIt	_First,
		_BidIt	_Last
	)

inlineprivate

         {   // initialize
         _DEBUG_RANGE(_First, _Last);
         if (!_Pos._Atend())
             _Res = _Current();
         else if (_Has_suffix())
             {   // mark suffix (no match)
             _Suffix.matched = true;
             _Suffix.first = _First;
             _Suffix.second = _Last;
             _Res = &_Suffix;
             }
         else
             _Res = 0;
         }

template<class _BidIt , class _Elem = _REGEX_VALT(_BidIt), class _RxTraits = regex_traits<_Elem>>

bool regex_token_iterator< _BidIt, _Elem, _RxTraits >::operator!= ( const _Myt & _Right ) const

inline

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

template<class _BidIt , class _Elem = _REGEX_VALT(_BidIt), class _RxTraits = regex_traits<_Elem>>

const value_type& regex_token_iterator< _BidIt, _Elem, _RxTraits >::operator* ( ) const

inline

         {   // return designated submatch
  #if _ITERATOR_DEBUG_LEVEL == 2
         if (_Res == 0)
             {   // report error
             _DEBUG_ERROR("regex_token_iterator not dereferencable");
             _SCL_SECURE_OUT_OF_RANGE;
             }
 
  #elif _ITERATOR_DEBUG_LEVEL == 1
         _SCL_SECURE_VALIDATE_RANGE(_Res != 0);
  #endif /* _ITERATOR_DEBUG_LEVEL */
 
         _Analysis_assume_(_Res != 0);
 
         return (*_Res);
         }

template<class _BidIt , class _Elem = _REGEX_VALT(_BidIt), class _RxTraits = regex_traits<_Elem>>

_Myt& regex_token_iterator< _BidIt, _Elem, _RxTraits >::operator++ ( )

inline

         {   // preincrement
  #if _ITERATOR_DEBUG_LEVEL == 2
         if (_Res == 0)
             {   // report error
             _DEBUG_ERROR("regex_token_iterator not incrementable");
             _SCL_SECURE_OUT_OF_RANGE;
             }
 
  #elif _ITERATOR_DEBUG_LEVEL == 1
         _SCL_SECURE_VALIDATE_RANGE(_Res != 0);
  #endif /* _ITERATOR_DEBUG_LEVEL */
 
         _Position _Prev(_Pos);
         if (_Res == 0)
             ;
         else if (_Res == &_Suffix)
             _Res = 0;
         else if (++_Cur < _Subs.size())
             _Res = _Current();
         else
             {   // advance to next full match
             _Cur = 0;
             ++_Pos;
             if (!_Pos._Atend())
                 _Res = _Current();
             else if (_Has_suffix() && _Prev->suffix().length() != 0)
                 {   // mark suffix
                 _Suffix.matched = true;
                 _Suffix.first = _Prev->suffix().first;
                 _Suffix.second = _Prev->suffix().second;
                 _Res = &_Suffix;
                 }
             else
                 _Res = 0;
             }
         return (*this);
         }

template<class _BidIt , class _Elem = _REGEX_VALT(_BidIt), class _RxTraits = regex_traits<_Elem>>

_Myt regex_token_iterator< _BidIt, _Elem, _RxTraits >::operator++ ( int )

inline

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

template<class _BidIt , class _Elem = _REGEX_VALT(_BidIt), class _RxTraits = regex_traits<_Elem>>

pointer regex_token_iterator< _BidIt, _Elem, _RxTraits >::operator-> ( ) const

inline

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

template<class _BidIt , class _Elem = _REGEX_VALT(_BidIt), class _RxTraits = regex_traits<_Elem>>

regex_token_iterator& regex_token_iterator< _BidIt, _Elem, _RxTraits >::operator= ( const regex_token_iterator< _BidIt, _Elem, _RxTraits > & _Right )

inline

         {   // assign from _Right
         if (&_Right != this)
             {   // copy from _Right
             _Pos = _Right._Pos;
             _Cur = _Right._Cur;
             _Suffix = _Right._Suffix;
             _Subs = _Right._Subs;
             if (_Right._Res == 0)
                 _Res = 0;
             else if (_Right._Res == &_Right._Suffix)
                 _Res = &_Suffix;
             else
                 _Res = _Current();
             }
         return (*this);
         }

template<class _BidIt , class _Elem = _REGEX_VALT(_BidIt), class _RxTraits = regex_traits<_Elem>>

bool regex_token_iterator< _BidIt, _Elem, _RxTraits >::operator== ( const _Myt & _Right ) const

inline

         {   // test for equality
         if (_Res == 0 || _Right._Res == 0)
             return (_Res == _Right._Res);
         else if (*_Res == *_Right._Res
             && _Pos == _Right._Pos
             && _Subs == _Right._Subs)
             return (true);
         else
             return (false);
         }

Member Data Documentation

template<class _BidIt , class _Elem = _REGEX_VALT(_BidIt), class _RxTraits = regex_traits<_Elem>>

size_t regex_token_iterator< _BidIt, _Elem, _RxTraits >::_Cur

private

template<class _BidIt , class _Elem = _REGEX_VALT(_BidIt), class _RxTraits = regex_traits<_Elem>>

_Position regex_token_iterator< _BidIt, _Elem, _RxTraits >::_Pos

private

template<class _BidIt , class _Elem = _REGEX_VALT(_BidIt), class _RxTraits = regex_traits<_Elem>>

const value_type* regex_token_iterator< _BidIt, _Elem, _RxTraits >::_Res

private

template<class _BidIt , class _Elem = _REGEX_VALT(_BidIt), class _RxTraits = regex_traits<_Elem>>

vector<int> regex_token_iterator< _BidIt, _Elem, _RxTraits >::_Subs

private

template<class _BidIt , class _Elem = _REGEX_VALT(_BidIt), class _RxTraits = regex_traits<_Elem>>

value_type regex_token_iterator< _BidIt, _Elem, _RxTraits >::_Suffix

private

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

VS2013/inc/regex