Inheritance diagram for ctype< _Elem >:

Public Types
typedef _Elem	char_type

Public Types inherited from ctype_base
enum	{ alnum = _DI \| _LO \| _UP \| _XA, alpha = _LO \| _UP \| _XA, cntrl = _BB, digit = _DI, graph = _DI \| _LO \| _PU \| _UP \| _XA, lower = _LO, print = _DI \| _LO \| _PU \| _SP \| _UP \| _XA \| _XD, punct = _PU, space = _CN \| _SP \| _XS, upper = _UP, xdigit = _XD, blank = _CN \| _SP \| _XS \| _XB }

typedef short	mask

Public Member Functions
bool __CLR_OR_THIS_CALL	is (mask _Maskval, _Elem _Ch) const

const _Elem *__CLR_OR_THIS_CALL	is (const _Elem _First, const _Elem _Last, mask *_Dest) const

const _Elem *__CLR_OR_THIS_CALL	scan_is (mask _Maskval, const _Elem _First, const _Elem _Last) const

const _Elem *__CLR_OR_THIS_CALL	scan_not (mask _Maskval, const _Elem _First, const _Elem _Last) const

_Elem __CLR_OR_THIS_CALL	tolower (_Elem _Ch) const

const _Elem *__CLR_OR_THIS_CALL	tolower (_Elem _First, const _Elem _Last) const

_Elem __CLR_OR_THIS_CALL	toupper (_Elem _Ch) const

const _Elem *__CLR_OR_THIS_CALL	toupper (_Elem _First, const _Elem _Last) const

_Elem __CLR_OR_THIS_CALL	widen (char _Byte) const

const char *__CLR_OR_THIS_CALL	widen (const char _First, const char _Last, _Elem *_Dest) const

char __CLR_OR_THIS_CALL	narrow (_Elem _Ch, char _Dflt= '\0') const

const _Elem *__CLR_OR_THIS_CALL	narrow (const _Elem _First, const _Elem _Last, char _Dflt, char *_Dest) const

__CLR_OR_THIS_CALL	ctype (size_t _Refs=0)

__CLR_OR_THIS_CALL	ctype (const _Locinfo &_Lobj, size_t _Refs=0)

Public Member Functions inherited from ctype_base
__CLR_OR_THIS_CALL	ctype_base (size_t _Refs=0)

__CLR_OR_THIS_CALL	~ctype_base () _NOEXCEPT

Public Member Functions inherited from locale::facet
virtual void __CLR_OR_THIS_CALL	_Incref ()

virtual _Facet_base *__CLR_OR_THIS_CALL	_Decref ()

__CLR_OR_THIS_CALL	facet (const facet &)=delete

facet &__CLR_OR_THIS_CALL	operator= (const facet &)=delete

Public Member Functions inherited from _Facet_base
virtual __CLR_OR_THIS_CALL	~_Facet_base () _NOEXCEPT

Static Public Member Functions
static size_t __CLRCALL_OR_CDECL	_Getcat (const locale::facet *_Ppf=0, const locale _Ploc=0)

Static Public Member Functions inherited from locale::facet
static size_t __CLRCALL_OR_CDECL	_Getcat (const facet *=0, const locale =0)

Static Public Attributes
static __PURE_APPDOMAIN_GLOBAL locale::id	id

Protected Member Functions
virtual __CLR_OR_THIS_CALL	~ctype () _NOEXCEPT

void __CLR_OR_THIS_CALL	_Init (const _Locinfo &_Lobj)

virtual bool __CLR_OR_THIS_CALL	do_is (mask _Maskval, _Elem _Ch) const

virtual const _Elem *__CLR_OR_THIS_CALL	do_is (const _Elem _First, const _Elem _Last, mask *_Dest) const

virtual const _Elem *__CLR_OR_THIS_CALL	do_scan_is (mask _Maskval, const _Elem _First, const _Elem _Last) const

virtual const _Elem *__CLR_OR_THIS_CALL	do_scan_not (mask _Maskval, const _Elem _First, const _Elem _Last) const

virtual _Elem __CLR_OR_THIS_CALL	do_tolower (_Elem _Ch) const

virtual const _Elem *__CLR_OR_THIS_CALL	do_tolower (_Elem _First, const _Elem _Last) const

virtual _Elem __CLR_OR_THIS_CALL	do_toupper (_Elem _Ch) const

virtual const _Elem *__CLR_OR_THIS_CALL	do_toupper (_Elem _First, const _Elem _Last) const

virtual _Elem __CLR_OR_THIS_CALL	do_widen (char _Byte) const

virtual const char *__CLR_OR_THIS_CALL	do_widen (const char _First, const char _Last, _Elem *_Dest) const

char __CLR_OR_THIS_CALL	_Donarrow (_Elem _Ch, char _Dflt) const

virtual char __CLR_OR_THIS_CALL	do_narrow (_Elem _Ch, char _Dflt) const

virtual const _Elem *__CLR_OR_THIS_CALL	do_narrow (const _Elem _First, const _Elem _Last, char _Dflt, char *_Dest) const

Protected Member Functions inherited from locale::facet
__CLR_OR_THIS_CALL	facet (size_t _Initrefs=0)

virtual __CLR_OR_THIS_CALL	~facet () _NOEXCEPT

Private Attributes
_Locinfo::_Ctypevec	_Ctype

_Locinfo::_Cvtvec	_Cvt

Member Typedef Documentation

template<class _Elem>

typedef _Elem ctype< _Elem >::char_type

Constructor & Destructor Documentation

template<class _Elem>

__CLR_OR_THIS_CALL ctype< _Elem >::ctype ( size_t _Refs = 0 )

inlineexplicit

         : ctype_base(_Refs)
         {   // construct from current locale
         _BEGIN_LOCINFO(_Lobj)
             _Init(_Lobj);
         _END_LOCINFO()
         }

template<class _Elem>

__CLR_OR_THIS_CALL ctype< _Elem >::ctype	(	const _Locinfo &	_Lobj,
		size_t	_Refs = `0`
	)

inline

         : ctype_base(_Refs)
         {   // construct from specified locale
         _Init(_Lobj);
         }

template<class _Elem>

virtual __CLR_OR_THIS_CALL ctype< _Elem >::~ctype ( )

inlineprotectedvirtual

         {   // destroy the object
         if (_Ctype._Delfl)
             _CSTD free((void *)_Ctype._Table);
 
         _CSTD free(_Ctype._LocaleName);
         }

Member Function Documentation

template<class _Elem>

char __CLR_OR_THIS_CALL ctype< _Elem >::_Donarrow	(	_Elem	_Ch,
		char	_Dflt
	)		const

inlineprotected

         {   // narrow element to char
         char _Byte;
         if (_Ch == (_Elem)0)
             return ('\0');
         else if ((_Byte = _MAKLOCBYTE(_Elem, _Ch, _Cvt)) == '\0')
             return (_Dflt);
         else
             return (_Byte);
         }

template<class _Elem>

static size_t __CLRCALL_OR_CDECL ctype< _Elem >::_Getcat	(	const locale::facet **	_Ppf = `0`,
		const locale *	_Ploc = `0`
	)

inlinestatic

         {   // return locale category mask and construct standard facet
         if (_Ppf != 0 && *_Ppf == 0)
             *_Ppf = new ctype<_Elem>(
                 _Locinfo(_Ploc->c_str()));
         return (_X_CTYPE);
         }

template<class _Elem>

void __CLR_OR_THIS_CALL ctype< _Elem >::_Init ( const _Locinfo & _Lobj )

inlineprotected

         {   // initialize from _Lobj
         _Ctype = _Lobj._Getctype();
         _Cvt = _Lobj._Getcvt();
         }

template<class _Elem>

virtual bool __CLR_OR_THIS_CALL ctype< _Elem >::do_is	(	mask	_Maskval,
		_Elem	_Ch
	)		const

inlineprotectedvirtual

         {   // test if element fits any mask classifications
         return ((_Ctype._Table[(unsigned char)narrow(_Ch)]
             & _Maskval) != 0);
         }

template<class _Elem>

virtual const _Elem* __CLR_OR_THIS_CALL ctype< _Elem >::do_is	(	const _Elem *	_First,
		const _Elem *	_Last,
		mask *	_Dest
	)		const

inlineprotectedvirtual

         {   // get mask sequence for elements in [_First, _Last)
         _DEBUG_RANGE(_First, _Last);
         for (; _First != _Last; ++_First, ++_Dest)
             *_Dest = _Ctype._Table[(unsigned char)narrow(*_First)];
         return (_First);
         }

template<class _Elem>

virtual char __CLR_OR_THIS_CALL ctype< _Elem >::do_narrow	(	_Elem	_Ch,
		char	_Dflt
	)		const

inlineprotectedvirtual

         {   // narrow element to char
         return (_Donarrow(_Ch, _Dflt));
         }

template<class _Elem>

virtual const _Elem* __CLR_OR_THIS_CALL ctype< _Elem >::do_narrow	(	const _Elem *	_First,
		const _Elem *	_Last,
		char	_Dflt,
		char *	_Dest
	)		const

inlineprotectedvirtual

         {   // narrow elements in [_First, _Last) to chars
         _DEBUG_RANGE(_First, _Last);
         for (; _First != _Last; ++_First, ++_Dest)
             *_Dest = _Donarrow(*_First, _Dflt);
         return (_First);
         }

template<class _Elem>

virtual const _Elem* __CLR_OR_THIS_CALL ctype< _Elem >::do_scan_is	(	mask	_Maskval,
		const _Elem *	_First,
		const _Elem *	_Last
	)		const

inlineprotectedvirtual

         {   // find first in [_First, _Last) that fits mask classification
         _DEBUG_RANGE(_First, _Last);
         for (; _First != _Last && !is(_Maskval, *_First); ++_First)
             ;
         return (_First);
         }

template<class _Elem>

virtual const _Elem* __CLR_OR_THIS_CALL ctype< _Elem >::do_scan_not	(	mask	_Maskval,
		const _Elem *	_First,
		const _Elem *	_Last
	)		const

inlineprotectedvirtual

         {   // find first in [_First, _Last) not fitting mask classification
         _DEBUG_RANGE(_First, _Last);
         for (; _First != _Last && is(_Maskval, *_First); ++_First)
             ;
         return (_First);
         }

template<class _Elem>

virtual _Elem __CLR_OR_THIS_CALL ctype< _Elem >::do_tolower ( _Elem _Ch ) const

inlineprotectedvirtual

         {   // convert element to lower case
         unsigned char _Byte = (unsigned char)narrow(_Ch, '\0');
         if (_Byte == '\0')
             return (_Ch);
         else
             return (widen((char)_Tolower(_Byte, &_Ctype)));
         }

template<class _Elem>

virtual const _Elem* __CLR_OR_THIS_CALL ctype< _Elem >::do_tolower	(	_Elem *	_First,
		const _Elem *	_Last
	)		const

inlineprotectedvirtual

         {   // convert [_First, _Last) in place to lower case
         _DEBUG_RANGE((const _Elem *)_First, _Last);
         for (; _First != _Last; ++_First)
             {   // convert *_First to lower case
             unsigned char _Byte = (unsigned char)narrow(*_First, '\0');
             if (_Byte != '\0')
                 *_First = (widen((char)_Tolower(_Byte, &_Ctype)));
             }
         return ((const _Elem *)_First);
         }

template<class _Elem>

virtual _Elem __CLR_OR_THIS_CALL ctype< _Elem >::do_toupper ( _Elem _Ch ) const

inlineprotectedvirtual

         {   // convert element to upper case
         unsigned char _Byte = (unsigned char)narrow(_Ch, '\0');
         if (_Byte == '\0')
             return (_Ch);
         else
             return (widen((char)_Toupper(_Byte, &_Ctype)));
         }

template<class _Elem>

virtual const _Elem* __CLR_OR_THIS_CALL ctype< _Elem >::do_toupper	(	_Elem *	_First,
		const _Elem *	_Last
	)		const

inlineprotectedvirtual

         {   // convert [_First, _Last) in place to upper case
         _DEBUG_RANGE((const _Elem *)_First, _Last);
         for (; _First != _Last; ++_First)
             {   // convert *_First to upper case
             unsigned char _Byte = (unsigned char)narrow(*_First, '\0');
             if (_Byte != '\0')
                 *_First = (widen((char)_Toupper(_Byte, &_Ctype)));
             }
         return ((const _Elem *)_First);
         }

template<class _Elem>

virtual _Elem __CLR_OR_THIS_CALL ctype< _Elem >::do_widen ( char _Byte ) const

inlineprotectedvirtual

         {   // widen char
         return (_MAKLOCCHR(_Elem, _Byte, _Cvt));
         }

template<class _Elem>

virtual const char* __CLR_OR_THIS_CALL ctype< _Elem >::do_widen	(	const char *	_First,
		const char *	_Last,
		_Elem *	_Dest
	)		const

inlineprotectedvirtual

         {   // widen chars in [_First, _Last)
         _DEBUG_RANGE(_First, _Last);
         for (; _First != _Last; ++_First, ++_Dest)
             *_Dest = _MAKLOCCHR(_Elem, *_First, _Cvt);
         return (_First);
         }

template<class _Elem>

bool __CLR_OR_THIS_CALL ctype< _Elem >::is	(	mask	_Maskval,
		_Elem	_Ch
	)		const

inline

         {   // test if element fits any mask classifications
         return (do_is(_Maskval, _Ch));
         }

template<class _Elem>

const _Elem* __CLR_OR_THIS_CALL ctype< _Elem >::is	(	const _Elem *	_First,
		const _Elem *	_Last,
		mask *	_Dest
	)		const

inline

         {   // get mask sequence for elements in [_First, _Last)
         return (do_is(_First, _Last, _Dest));
         }

template<class _Elem>

char __CLR_OR_THIS_CALL ctype< _Elem >::narrow	(	_Elem	_Ch,
		char	_Dflt = `'\0'`
	)		const

inline

         {   // narrow element to char
         return (do_narrow(_Ch, _Dflt));
         }

template<class _Elem>

const _Elem* __CLR_OR_THIS_CALL ctype< _Elem >::narrow	(	const _Elem *	_First,
		const _Elem *	_Last,
		char	_Dflt,
		char *	_Dest
	)		const

inline

         {   // narrow elements in [_First, _Last) to chars
         return (do_narrow(_First, _Last, _Dflt, _Dest));
         }

template<class _Elem>

const _Elem* __CLR_OR_THIS_CALL ctype< _Elem >::scan_is	(	mask	_Maskval,
		const _Elem *	_First,
		const _Elem *	_Last
	)		const

inline

         {   // find first in [_First, _Last) that fits mask classification
         return (do_scan_is(_Maskval, _First, _Last));
         }

template<class _Elem>

const _Elem* __CLR_OR_THIS_CALL ctype< _Elem >::scan_not	(	mask	_Maskval,
		const _Elem *	_First,
		const _Elem *	_Last
	)		const

inline

         {   // find first in [_First, _Last) not fitting mask classification
         return (do_scan_not(_Maskval, _First, _Last));
         }

template<class _Elem>

_Elem __CLR_OR_THIS_CALL ctype< _Elem >::tolower ( _Elem _Ch ) const

inline

         {   // convert element to lower case
         return (do_tolower(_Ch));
         }

template<class _Elem>

const _Elem* __CLR_OR_THIS_CALL ctype< _Elem >::tolower	(	_Elem *	_First,
		const _Elem *	_Last
	)		const

inline

         {   // convert [_First, _Last) in place to lower case
         return (do_tolower(_First, _Last));
         }

template<class _Elem>

_Elem __CLR_OR_THIS_CALL ctype< _Elem >::toupper ( _Elem _Ch ) const

inline

         {   // convert element to upper case
         return (do_toupper(_Ch));
         }

template<class _Elem>

const _Elem* __CLR_OR_THIS_CALL ctype< _Elem >::toupper	(	_Elem *	_First,
		const _Elem *	_Last
	)		const

inline

         {   // convert [_First, _Last) in place to upper case
         return (do_toupper(_First, _Last));
         }

template<class _Elem>

_Elem __CLR_OR_THIS_CALL ctype< _Elem >::widen ( char _Byte ) const

inline

         {   // widen char
         return (do_widen(_Byte));
         }

template<class _Elem>

const char* __CLR_OR_THIS_CALL ctype< _Elem >::widen	(	const char *	_First,
		const char *	_Last,
		_Elem *	_Dest
	)		const

inline

         {   // widen chars in [_First, _Last)
         return (do_widen(_First, _Last, _Dest));
         }

Member Data Documentation

template<class _Elem>

_Locinfo::_Ctypevec ctype< _Elem >::_Ctype

private

template<class _Elem>

_Locinfo::_Cvtvec ctype< _Elem >::_Cvt

private

template<class _Elem>

locale::id ctype< _Elem >::id

static

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

VS2017/inc/xlocale

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Private Attributes

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation