Inheritance diagram for _Regex_traits< _Elem >:

Public Types
typedef make_unsigned< _Elem >::type	_Uelem

typedef _Regex_traits< _Elem >	_Myt

typedef _Elem	char_type

typedef size_t	size_type

typedef basic_string< _Elem >	string_type

typedef locale	locale_type

Public Types inherited from _Regex_traits_base
enum	_Char_class_type { _Ch_none = 0, _Ch_alnum = ctype_base::alnum, _Ch_alpha = ctype_base::alpha, _Ch_cntrl = ctype_base::cntrl, _Ch_digit = ctype_base::digit, _Ch_graph = ctype_base::graph, _Ch_lower = ctype_base::lower, _Ch_print = ctype_base::print, _Ch_punct = ctype_base::punct, _Ch_space = ctype_base::space, _Ch_upper = ctype_base::upper, _Ch_xdigit = ctype_base::xdigit, _Ch_blank = ctype_base::blank }

typedef ctype_base::mask	char_class_type

Public Member Functions
	_Regex_traits ()

	_Regex_traits (const _Myt &_Right)

_Myt &	operator= (const _Myt &_Right)

_Elem	translate (_Elem _Ch) const

_Elem	translate_nocase (_Elem _Ch) const

template<class _FwdIt >
string_type	transform (_FwdIt _First, _FwdIt _Last) const

template<class _FwdIt >
string_type	transform_primary (_FwdIt _First, _FwdIt _Last) const

bool	isctype (_Elem _Ch, char_class_type _Fx) const

template<class _Iter >
char_class_type	lookup_classname (_Iter _First, _Iter _Last, bool _Icase=false) const

template<class _FwdIt >
string_type	lookup_collatename (_FwdIt _First, _FwdIt _Last) const

locale_type	imbue (locale_type _Lx)

locale_type	getloc () const

const collate< _Elem > *	_Getcoll () const

const ctype< _Elem > *	_Getctype () const

Static Public Member Functions
static size_type	length (const _Elem *_Str)

Private Member Functions
void	_Cache_locale ()

Private Attributes
const collate< _Elem > *	_Pcoll

const ctype< _Elem > *	_Pctype

locale_type	_Loc

Member Typedef Documentation

template<class _Elem>

typedef _Regex_traits<_Elem> _Regex_traits< _Elem >::_Myt

template<class _Elem>

typedef make_unsigned<_Elem>::type _Regex_traits< _Elem >::_Uelem

template<class _Elem>

typedef _Elem _Regex_traits< _Elem >::char_type

template<class _Elem>

typedef locale _Regex_traits< _Elem >::locale_type

template<class _Elem>

typedef size_t _Regex_traits< _Elem >::size_type

template<class _Elem>

typedef basic_string<_Elem> _Regex_traits< _Elem >::string_type

Constructor & Destructor Documentation

template<class _Elem>

_Regex_traits< _Elem >::_Regex_traits ( )

inline

         {   // default construct
         _Cache_locale();
         }

template<class _Elem>

_Regex_traits< _Elem >::_Regex_traits ( const _Myt & _Right )

inline

         : _Loc(_Right._Loc)
         {   // copy construct
         _Cache_locale();
         }

Member Function Documentation

template<class _Elem>

void _Regex_traits< _Elem >::_Cache_locale ( )

inlineprivate

         {   // populate _Pcoll and _Pctype with _Loc locale
         _Pcoll = &_USE(_Loc, collate<_Elem>);
         _Pctype = &_USE(_Loc, ctype<_Elem>);
         }

template<class _Elem>

const collate<_Elem>* _Regex_traits< _Elem >::_Getcoll ( ) const

inline

         {   // get collate facet pointer
         return (_Pcoll);
         }

template<class _Elem>

const ctype<_Elem>* _Regex_traits< _Elem >::_Getctype ( ) const

inline

         {   // get ctype facet pointer
         return (_Pctype);
         }

template<class _Elem>

locale_type _Regex_traits< _Elem >::getloc ( ) const

inline

         {   // return locale object
         return (_Loc);
         }

template<class _Elem>

locale_type _Regex_traits< _Elem >::imbue ( locale_type _Lx )

inline

         {   // store locale object
         locale_type _Tmp = _Loc;
         _Loc = _Lx;
         _Cache_locale();
         return (_Tmp);
         }

template<class _Elem>

bool _Regex_traits< _Elem >::isctype	(	_Elem	_Ch,
		char_class_type	_Fx
	)		const

inline

         {   // return true if _Ch is in character class _Fx
         if (_Fx != (char_class_type)(-1))
             return (_Getctype()->is(_Fx, _Ch));
         else
             return (_Ch == '_'  // assumes L'_' == '_'
                 || _Getctype()->is(_Ch_alnum, _Ch));
         }

template<class _Elem>

static size_type _Regex_traits< _Elem >::length ( const _Elem * _Str )

inlinestatic

         {   // return length of _Str
         return (char_traits<_Elem>::length(_Str));
         }

template<class _Elem>

template<class _Iter >

char_class_type _Regex_traits< _Elem >::lookup_classname	(	_Iter	_First,
		_Iter	_Last,
		bool	_Icase = `false`
	)		const

inline

         {   // map [_First, _Last) to character class mask value
   #define _REGEX_CHAR_CLASS_NAME(n, c) \
     {n, L ## n, sizeof (n) / sizeof (n[0]) - 1, c}
         static constexpr _Cl_names _Names[] =
             {   // map class names to numeric constants
             _REGEX_CHAR_CLASS_NAME("alnum", _Ch_alnum),
             _REGEX_CHAR_CLASS_NAME("alpha", _Ch_alpha),
             _REGEX_CHAR_CLASS_NAME("blank", _Ch_blank),
             _REGEX_CHAR_CLASS_NAME("cntrl", _Ch_cntrl),
             _REGEX_CHAR_CLASS_NAME("d", _Ch_digit),
             _REGEX_CHAR_CLASS_NAME("digit", _Ch_digit),
             _REGEX_CHAR_CLASS_NAME("graph", _Ch_graph),
             _REGEX_CHAR_CLASS_NAME("lower", _Ch_lower),
             _REGEX_CHAR_CLASS_NAME("print", _Ch_print),
             _REGEX_CHAR_CLASS_NAME("punct", _Ch_punct),
             _REGEX_CHAR_CLASS_NAME("space", _Ch_space),
             _REGEX_CHAR_CLASS_NAME("s", _Ch_space),
             _REGEX_CHAR_CLASS_NAME("upper", _Ch_upper),
             _REGEX_CHAR_CLASS_NAME("w", (ctype_base::mask)(-1)),
             _REGEX_CHAR_CLASS_NAME("xdigit", _Ch_xdigit),
             {0, 0, 0},
             };
   #undef _REGEX_CHAR_CLASS_NAME
 
         _DEBUG_RANGE(_First, _Last);
         unsigned int _Ix = 0;
         for (; _Names[_Ix]._Get<_Elem>(); ++_Ix)
             if (_STD equal(_First, _Last,
                 _Names[_Ix]._Get<_Elem>(),
                 _Names[_Ix]._Get<_Elem>() + _Names[_Ix]._Len,
                 _Cmp_icase<_Regex_traits<_Elem> >(*this)))
                 break;
 
         char_class_type _Mask = (char_class_type)0;
         if (_Names[_Ix]._Get<_Elem>() != 0)
             _Mask = _Names[_Ix]._Ctype;
         if (_Icase && _Mask & (_Ch_lower | _Ch_upper))
             _Mask |= _Ch_lower | _Ch_upper;
         return (_Mask);
         }

template<class _Elem>

template<class _FwdIt >

string_type _Regex_traits< _Elem >::lookup_collatename	(	_FwdIt	_First,
		_FwdIt	_Last
	)		const

inline

         {   // map [_First, _Last) to collation element
         return (string_type(_First, _Last));
         }

template<class _Elem>

_Myt& _Regex_traits< _Elem >::operator= ( const _Myt & _Right )

inline

         {   // assign
         _Loc = _Right._Loc;
         _Cache_locale();
         return (*this);
         }

template<class _Elem>

template<class _FwdIt >

string_type _Regex_traits< _Elem >::transform	(	_FwdIt	_First,
		_FwdIt	_Last
	)		const

inline

         {   // apply locale-specific transformation
         return (_Getcoll()->transform(_First, _Last));
         }

template<class _Elem>

template<class _FwdIt >

string_type _Regex_traits< _Elem >::transform_primary	(	_FwdIt	_First,
		_FwdIt	_Last
	)		const

inline

         {   // apply locale-specific case-insensitive transformation
         string_type _Res;
 
         if (_First != _Last)
             {   // non-empty string, transform it
             vector<_Elem> _Temp(_First, _Last);
 
             _Getctype()->tolower(&*_Temp.begin(),
                 &*_Temp.begin() + _Temp.size());
             _Res = _Getcoll()->transform(&*_Temp.begin(),
                 &*_Temp.begin() + _Temp.size());
             }
         return (_Res);
         }

template<class _Elem>

_Elem _Regex_traits< _Elem >::translate ( _Elem _Ch ) const

inline

         {   // provide locale-sensitive mapping
         string_type _Res = _Getcoll()->transform(&_Ch, &_Ch + 1);
         return (_Res.length() == 1 ? _Res[0] : _Ch);
         }

template<class _Elem>

_Elem _Regex_traits< _Elem >::translate_nocase ( _Elem _Ch ) const

inline

         {   // provide case-insensitive mapping
         return (_Getctype()->tolower(_Ch));
         }

Member Data Documentation

template<class _Elem>

locale_type _Regex_traits< _Elem >::_Loc

private

template<class _Elem>

const collate<_Elem>* _Regex_traits< _Elem >::_Pcoll

private

template<class _Elem>

const ctype<_Elem>* _Regex_traits< _Elem >::_Pctype

private

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

VS2017/inc/regex

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation