Inheritance diagram for sub_match< _BidIt >:

Public Types
typedef pair< _BidIt, _BidIt >	_Mybase

typedef iterator_traits< _BidIt >::value_type	value_type

typedef iterator_traits< _BidIt >::difference_type	difference_type

typedef _BidIt	iterator

typedef basic_string< value_type >	string_type

typedef string_type::traits_type	_Traits

typedef string_type::size_type	_Size_type

Public Types inherited from pair< _BidIt, _BidIt >
typedef pair< _BidIt, _BidIt >	_Myt

typedef _BidIt	first_type

typedef _BidIt	second_type

Public Member Functions
constexpr	sub_match ()

difference_type	length () const

	operator string_type () const

string_type	str () const

int	compare (const sub_match &_Right) const

int	compare (const string_type &_Right) const

int	compare (_In_z_ const value_type *_Ptr) const

int	_Compare (const value_type *const _Ptr, const _Size_type _Count) const

bool	_Match_equal (const sub_match &_Right) const

bool	_Match_equal (const value_type *const _Ptr, const _Size_type _Count) const

bool	_Match_equal (const value_type *const _Ptr) const

bool	_Less (const sub_match &_Right) const

bool	_Less (const value_type *const _Ptr, const _Size_type _Count) const

bool	_Less (const value_type *const _Ptr) const

bool	_Greater (const value_type *const _Ptr, const _Size_type _Count) const

bool	_Greater (const value_type *const _Ptr) const

_Mybase	_Effective_range () const

Public Member Functions inherited from pair< _BidIt, _BidIt >
constexpr _Other1::value	second (_STD forward< _Other2 >(_Val2))

constexpr _Other1::value	second (_STD forward< _Other2 >(_Val2))

constexpr _Other1::value	second (_STD forward< _Other2 >(_Right.second))

constexpr _Other1::value	second (_STD forward< _Other2 >(_Right.second))

constexpr	pair ()

constexpr	pair (const _BidIt &_Val1, const _BidIt &_Val2)

constexpr	pair (const _BidIt &_Val1, const _BidIt &_Val2)

	pair (const pair &)=default

	pair (pair &&)=default

constexpr	pair (const pair< _Other1, _Other2 > &_Right)

constexpr	pair (const pair< _Other1, _Other2 > &_Right)

	pair (_Tuple1 &_Val1, _Tuple2 &_Val2, index_sequence< _Indexes1...>, index_sequence< _Indexes2...>)

	pair (piecewise_construct_t, tuple< _Types1...> _Val1, tuple< _Types2...> _Val2)

constexpr	pair (_Other1 &&_Val1, _Other2 &&_Val2) _NOEXCEPT_OP((is_nothrow_constructible< _BidIt

constexpr	pair (_Other1 &&_Val1, _Other2 &&_Val2) _NOEXCEPT_OP((is_nothrow_constructible< _BidIt

constexpr	pair (pair< _Other1, _Other2 > &&_Right) _NOEXCEPT_OP((is_nothrow_constructible< _BidIt

constexpr	pair (pair< _Other1, _Other2 > &&_Right) _NOEXCEPT_OP((is_nothrow_constructible< _BidIt

_Myt &	operator= (const pair< _Other1, _Other2 > &_Right)

_Myt &	operator= (pair< _Other1, _Other2 > &&_Right)

_Myt &	operator= (_Myt &&_Right) _NOEXCEPT_OP((is_nothrow_move_assignable< _BidIt >

_Myt &	operator= (const _Myt &_Right)

void	swap (_Myt &_Right) _NOEXCEPT_OP(_Is_nothrow_swappable< _BidIt >

Public Attributes
bool	matched

Public Attributes inherited from pair< _BidIt, _BidIt >
_BidIt	first

_BidIt	second

Member Typedef Documentation

template<class _BidIt>

typedef pair<_BidIt, _BidIt> sub_match< _BidIt >::_Mybase

template<class _BidIt>

typedef string_type::size_type sub_match< _BidIt >::_Size_type

template<class _BidIt>

typedef string_type::traits_type sub_match< _BidIt >::_Traits

template<class _BidIt>

typedef iterator_traits<_BidIt>::difference_type sub_match< _BidIt >::difference_type

template<class _BidIt>

typedef _BidIt sub_match< _BidIt >::iterator

template<class _BidIt>

typedef basic_string<value_type> sub_match< _BidIt >::string_type

template<class _BidIt>

typedef iterator_traits<_BidIt>::value_type sub_match< _BidIt >::value_type

Constructor & Destructor Documentation

template<class _BidIt>

constexpr sub_match< _BidIt >::sub_match ( )

inline

         : _Mybase(), matched(false)
         {   // construct
         }

Member Function Documentation

template<class _BidIt>

int sub_match< _BidIt >::_Compare	(	const value_type *const	_Ptr,
		const _Size_type	_Count
	)		const

inline

         {   // compare *this to array [_Ptr, _Ptr + _Count)
         const _Mybase _Range(_Effective_range());
         return (_Iter_compare<_Traits>(_Range.first, _Range.second, _Ptr, _Ptr + _Count));
         }

template<class _BidIt>

_Mybase sub_match< _BidIt >::_Effective_range ( ) const

inline

         {   // if matched, returns *this; otherwise returns an empty range
         if (matched)
             return (*this);
         else
             return (_Mybase{});
         }

template<class _BidIt>

bool sub_match< _BidIt >::_Greater	(	const value_type *const	_Ptr,
		const _Size_type	_Count
	)		const

inline

         {   // check whether *this is greater than [_Ptr, _Ptr + _Count)
         const _Mybase _Range(_Effective_range());
         return (_STD lexicographical_compare(_Ptr, _Ptr + _Count,
             _Range.first, _Range.second, _Char_traits_lt<_Traits>{}));
         }

template<class _BidIt>

bool sub_match< _BidIt >::_Greater ( const value_type *const _Ptr ) const

inline

         {   // check whether *this is greater than C-string _Ptr
         return (_Greater(_Ptr, _Traits::length(_Ptr)));
         }

template<class _BidIt>

bool sub_match< _BidIt >::_Less ( const sub_match< _BidIt > & _Right ) const

inline

         {   // check whether *this is less than _Right
         const _Mybase _LRange(_Effective_range());
         const _Mybase _RRange(_Right._Effective_range());
         return (_STD lexicographical_compare(_LRange.first, _LRange.second,
             _RRange.first, _RRange.second, _Char_traits_lt<_Traits>{}));
         }

template<class _BidIt>

bool sub_match< _BidIt >::_Less	(	const value_type *const	_Ptr,
		const _Size_type	_Count
	)		const

inline

         {   // check whether *this is less than [_Ptr, _Ptr + _Count)
         const _Mybase _Range(_Effective_range());
         return (_STD lexicographical_compare(_Range.first, _Range.second,
             _Ptr, _Ptr + _Count, _Char_traits_lt<_Traits>{}));
         }

template<class _BidIt>

bool sub_match< _BidIt >::_Less ( const value_type *const _Ptr ) const

inline

         {   // check whether *this is less than C-string _Ptr
         return (_Less(_Ptr, _Traits::length(_Ptr)));
         }

template<class _BidIt>

bool sub_match< _BidIt >::_Match_equal ( const sub_match< _BidIt > & _Right ) const

inline

         {   // check *this to _Right for equality
         const _Mybase _LRange(_Effective_range());
         const _Mybase _RRange(_Right._Effective_range());
         return (_STD equal(_LRange.first, _LRange.second, _RRange.first,
             _RRange.second, _Char_traits_eq<_Traits>{}));
         }

template<class _BidIt>

bool sub_match< _BidIt >::_Match_equal	(	const value_type *const	_Ptr,
		const _Size_type	_Count
	)		const

inline

         {   // check *this to array [_Ptr, _Ptr + _Count) for equality
         const _Mybase _Range(_Effective_range());
         return (_STD equal(_Range.first, _Range.second,
             _Ptr, _Ptr + _Count, _Char_traits_eq<_Traits>{}));
         }

template<class _BidIt>

bool sub_match< _BidIt >::_Match_equal ( const value_type *const _Ptr ) const

inline

         {   // check *this to C-string _Ptr for equality
         return (_Match_equal(_Ptr, _Traits::length(_Ptr)));
         }

template<class _BidIt>

int sub_match< _BidIt >::compare ( const sub_match< _BidIt > & _Right ) const

inline

         {   // compare *this to _Right
         const _Mybase _LRange(_Effective_range());
         const _Mybase _RRange(_Right._Effective_range());
         return (_Iter_compare<_Traits>(_LRange.first, _LRange.second,
             _RRange.first, _RRange.second));
         }

template<class _BidIt>

int sub_match< _BidIt >::compare ( const string_type & _Right ) const

inline

         {   // compare *this to _Right
         return (_Compare(_Right.data(), _Right.size()));
         }

template<class _BidIt>

int sub_match< _BidIt >::compare ( _In_z_ const value_type * _Ptr ) const

inline

         {   // compare *this to array pointed to by _Ptr
         return (_Compare(_Ptr, _Traits::length(_Ptr)));
         }

template<class _BidIt>

difference_type sub_match< _BidIt >::length ( ) const

inline

         {   // return length of matched text
         const _Mybase _Range(_Effective_range());
         return (_STD distance(_Range.first, _Range.second));
         }

template<class _BidIt>

sub_match< _BidIt >::operator string_type ( ) const

inline

         {   // convert matched text to string
         return (str());
         }

template<class _BidIt>

string_type sub_match< _BidIt >::str ( ) const

inline

         {   // convert matched text to string
         const _Mybase _Range(_Effective_range());
         return (string_type(_Range.first, _Range.second));
         }

Member Data Documentation

template<class _BidIt>

bool sub_match< _BidIt >::matched

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

VS2017/inc/regex

Public Types

Public Member Functions

Public Attributes

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation