_Regex_traits< _Elem > Class Template Reference

Inheritance diagram for _Regex_traits< _Elem >:

Public Types
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 Attributes
const collate< _Elem > *	_Pcoll
const ctype< _Elem > *	_Pctype
locale_type	_Loc

Static Private Attributes
static const _Cl_names< _Elem >	_Names []

Member Typedef Documentation

template<class _Elem>

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

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

        : _Pcoll(0), _Pctype(0)
        {   // default construct
        }

template<class _Elem>

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

inline

        : _Pcoll(0), _Pctype(0), _Loc(_Right._Loc)
        {   // copy construct
        }

Member Function Documentation

template<class _Elem>

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

inline

        {   // get collate facet pointer
        if (_Pcoll == 0)
            *((const collate<_Elem> **)&_Pcoll) =
                &_USE(getloc(), collate<_Elem>);
        return (_Pcoll);
        }

template<class _Elem>

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

inline

        {   // get ctype facet pointer
        if (_Pctype == 0)
            *((const ctype<_Elem> **)&_Pctype) =
                &_USE(getloc(), ctype<_Elem>);
        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
        _Pcoll = 0;
        _Pctype = 0;
        locale_type _Tmp = _Loc;
        _Loc = _Lx;
        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
        if (_Str == 0)
            _Xregex_error(
                regex_constants::error_parse);  // to quiet diagnostics
        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
        _DEBUG_RANGE(_First, _Last);
        int _Ix = 0;
        for (; _Names[_Ix]._Ptr; ++_Ix)
            if (_Same(_First, _Last,
                _Names[_Ix]._Ptr, _Names[_Ix]._Ptr + _Names[_Ix]._Len,
                _Cmp_icase<_Regex_traits<_Elem> >(*this)))
                break;

        char_class_type _Mask = (char_class_type)0;
        if (_Names[_Ix]._Ptr != 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
        _Pcoll = 0;
        _Pctype = 0;
        _Loc = _Right._Loc;
        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 _Cl_names<_Elem> _Regex_traits< _Elem >::_Names[]

staticprivate

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:

• VS2013/inc/regex