Inheritance diagram for _Mpunct< _Elem >:

Public Types
typedef _Elem	char_type

typedef basic_string< _Elem, char_traits< _Elem >, allocator< _Elem > >	string_type

Public Types inherited from money_base
enum	{ symbol = '$', sign = '+', space = ' ', value = 'v', none = 'x' }

typedef int	part

Public Member Functions
_Elem	decimal_point () const

_Elem	thousands_sep () const

string	grouping () const

string_type	curr_symbol () const

string_type	positive_sign () const

string_type	negative_sign () const

int	frac_digits () const

pattern	pos_format () const

pattern	neg_format () const

	_Mpunct (size_t _Refs, bool _Intl)

	_Mpunct (const _Locinfo &_Lobj, size_t _Refs, bool _Intl, bool _Isdef=false)

Public Member Functions inherited from money_base
	money_base (size_t _Refs=0)

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

Protected Member Functions
	_Mpunct (const char *_Locname, size_t _Refs, bool _Intl, bool _Isdef=false)

virtual __CLR_OR_THIS_CALL	~_Mpunct () _NOEXCEPT

template<class _Elem2 >
void	_Getvals (_Elem2, const lconv *_Ptr)

template<>
void	_Getvals (wchar_t, const lconv *_Ptr)

void	_Init (const _Locinfo &_Lobj, bool _Isdef=false)

virtual _Elem __CLR_OR_THIS_CALL	do_decimal_point () const

virtual _Elem __CLR_OR_THIS_CALL	do_thousands_sep () const

virtual string __CLR_OR_THIS_CALL	do_grouping () const

virtual string_type __CLR_OR_THIS_CALL	do_curr_symbol () const

virtual string_type __CLR_OR_THIS_CALL	do_positive_sign () const

virtual string_type __CLR_OR_THIS_CALL	do_negative_sign () const

virtual int __CLR_OR_THIS_CALL	do_frac_digits () const

virtual pattern __CLR_OR_THIS_CALL	do_pos_format () const

virtual pattern __CLR_OR_THIS_CALL	do_neg_format () 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 Member Functions
void	_Makpat (pattern &_Pattern, unsigned int _Sepbyspace, unsigned int _Symbolprecedes, unsigned int _Signposition)

void	_Tidy ()

Private Attributes
const char *	_Grouping

_Elem	_Decimalpoint

_Elem	_Kseparator

const _Elem *	_Currencysign

const _Elem *	_Plussign

const _Elem *	_Minussign

int	_Fracdigits

pattern	_Plusformat

pattern	_Minusformat

bool	_International

_Locinfo::_Cvtvec	_Cvt

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

Member Typedef Documentation

template<class _Elem >

typedef _Elem _Mpunct< _Elem >::char_type

template<class _Elem >

typedef basic_string<_Elem, char_traits<_Elem>, allocator<_Elem> > _Mpunct< _Elem >::string_type

Constructor & Destructor Documentation

template<class _Elem >

_Mpunct< _Elem >::_Mpunct	(	size_t	_Refs,
		bool	_Intl
	)

inlineexplicit

         : money_base(_Refs), _International(_Intl)
         {   // construct from current locale
         _BEGIN_LOCINFO(_Lobj)
             _Init(_Lobj);
         _END_LOCINFO()
         }

template<class _Elem >

_Mpunct< _Elem >::_Mpunct	(	const _Locinfo &	_Lobj,
		size_t	_Refs,
		bool	_Intl,
		bool	_Isdef = `false`
	)

inline

         : money_base(_Refs), _International(_Intl)
         {   // construct from specified locale
         _Init(_Lobj, _Isdef);
         }

template<class _Elem >

_Mpunct< _Elem >::_Mpunct	(	const char *	_Locname,
		size_t	_Refs,
		bool	_Intl,
		bool	_Isdef = `false`
	)

inlineprotected

         : money_base(_Refs), _International(_Intl)
         {   // construct from specified locale
         _BEGIN_LOCINFO(_Lobj(_Locname))
             _Init(_Lobj, _Isdef);
         _END_LOCINFO()
         }

template<class _Elem >

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

inlineprotectedvirtual

         {   // destroy the object
         _Tidy();
         }

Member Function Documentation

template<class _Elem >

template<class _Elem2 >

void _Mpunct< _Elem >::_Getvals	(	_Elem2	,
		const lconv *	_Ptr
	)

inlineprotected

         {   // get values
         _Currencysign = _MAKLOCSTR(_Elem2, _International
             ? _Ptr->int_curr_symbol : _Ptr->currency_symbol, _Cvt);
         _Plussign = _MAKLOCSTR(_Elem2, 4 < (unsigned int)_Ptr->p_sign_posn
             ? "" : _Ptr->positive_sign, _Cvt);
         _Minussign = _MAKLOCSTR(_Elem2, 4 < (unsigned int)_Ptr->n_sign_posn
             ? "-" : _Ptr->negative_sign, _Cvt);
         _Decimalpoint = _MAKLOCCHR(_Elem2, _Ptr->mon_decimal_point[0], _Cvt);
         _Kseparator = _MAKLOCCHR(_Elem2, _Ptr->mon_thousands_sep[0], _Cvt);
         }

template<class _Elem >

template<>

void _Mpunct< _Elem >::_Getvals	(	wchar_t	,
		const lconv *	_Ptr
	)

inlineprotected

         {   // get values
         _Currencysign = (const _Elem *)_Maklocwcs(_International
             ? _Ptr->_W_int_curr_symbol : _Ptr->_W_currency_symbol);
         _Plussign = (const _Elem *)_Maklocwcs(
             4 < (unsigned int)_Ptr->p_sign_posn
                 ? L"" : _Ptr->_W_positive_sign);
         _Minussign = (const _Elem *)_Maklocwcs(
             4 < (unsigned int)_Ptr->n_sign_posn
                 ? L"-" : _Ptr->_W_negative_sign);
         _Decimalpoint = (_Elem)_Ptr->_W_mon_decimal_point[0];
         _Kseparator = (_Elem)_Ptr->_W_mon_thousands_sep[0];
         }

template<class _Elem >

void _Mpunct< _Elem >::_Init	(	const _Locinfo &	_Lobj,
		bool	_Isdef = `false`
	)

inlineprotected

         {   // initialize from _Lobj
         _Cvt = _Lobj._Getcvt();
         const lconv *_Ptr = _Lobj._Getlconv();
 
         _Grouping = 0;
         _Currencysign = 0;
         _Plussign = 0;
         _Minussign = 0;
 
         _TRY_BEGIN
         _Grouping = _MAKLOCSTR(char, _Ptr->mon_grouping, _Cvt);
         _Getvals((_Elem)0, _Ptr);
         _CATCH_ALL
         _Tidy();
         _RERAISE;
         _CATCH_END
 
         _Fracdigits = _International ? _Ptr->int_frac_digits
             : _Ptr->frac_digits;
         if (_Fracdigits < 0 || CHAR_MAX <= _Fracdigits)
             _Fracdigits = 0;
 
         _Makpat(_Plusformat, _Ptr->p_sep_by_space,
             _Ptr->p_cs_precedes, _Ptr->p_sign_posn);
         _Makpat(_Minusformat, _Ptr->n_sep_by_space,
             _Ptr->n_cs_precedes, _Ptr->n_sign_posn);
 
         if (_Isdef)
             {   // apply defaults for required facets
             memcpy(&_Plusformat, "$+xv", 4);
             memcpy(&_Minusformat, "$+xv", 4);
             }
         }

template<class _Elem >

void _Mpunct< _Elem >::_Makpat	(	pattern &	_Pattern,
		unsigned int	_Sepbyspace,
		unsigned int	_Symbolprecedes,
		unsigned int	_Signposition
	)

inlineprivate

         {   // make format pattern from locale information
         const char *_Ptr = _International || 2 < _Sepbyspace
             || 1 < _Symbolprecedes || 4 < _Signposition
                 ? "$+xv"    // international or bad parameters
                 : &(
                 "+v$x" "+v$x" "v$+x" "v+$x" "v$+x"
                 "+$vx" "+$vx" "$v+x" "+$vx" "$+vx"
                 "+v $" "+v $" "v $+" "v +$" "v $+"
                 "+$ v" "+$ v" "$ v+" "+$ v" "$+ v"
                 "+xv$" "+ v$" "v$ +" "v+ $" "v$ +"
                 "+x$v" "+ $v" "$v +" "+ $v" "$ +v")
                     [_Signposition * 4  // pick even/odd column
                     + _Symbolprecedes * 20  // pick even/odd row
                     + _Sepbyspace * 40];    // pick first/second/third group
 
         _CRT_SECURE_MEMCPY(_Pattern.field, sizeof (_Pattern.field), _Ptr, 4);
         }

template<class _Elem >

void _Mpunct< _Elem >::_Tidy ( )

inlineprivate

         {   // free all storage
         _DELETE_CRT_VEC((void *)_Grouping);
         _DELETE_CRT_VEC((void *)_Currencysign);
         _DELETE_CRT_VEC((void *)_Plussign);
         _DELETE_CRT_VEC((void *)_Minussign);
         }

template<class _Elem >

string_type _Mpunct< _Elem >::curr_symbol ( ) const

inline

         {   // return currency symbol string
         return (do_curr_symbol());
         }

template<class _Elem >

_Elem _Mpunct< _Elem >::decimal_point ( ) const

inline

         {   // return decimal point
         return (do_decimal_point());
         }

template<class _Elem >

virtual string_type __CLR_OR_THIS_CALL _Mpunct< _Elem >::do_curr_symbol ( ) const

inlineprotectedvirtual

         {   // return currency symbol string
         return (string_type(_Currencysign));
         }

template<class _Elem >

virtual _Elem __CLR_OR_THIS_CALL _Mpunct< _Elem >::do_decimal_point ( ) const

inlineprotectedvirtual

         {   // return decimal point
         return (_Decimalpoint);
         }

template<class _Elem >

virtual int __CLR_OR_THIS_CALL _Mpunct< _Elem >::do_frac_digits ( ) const

inlineprotectedvirtual

         {   // return number of fraction digits
         return (_Fracdigits);
         }

template<class _Elem >

virtual string __CLR_OR_THIS_CALL _Mpunct< _Elem >::do_grouping ( ) const

inlineprotectedvirtual

         {   // return grouping string
         return (string(_Grouping));
         }

template<class _Elem >

virtual pattern __CLR_OR_THIS_CALL _Mpunct< _Elem >::do_neg_format ( ) const

inlineprotectedvirtual

         {   // return format for negative values
         return (_Minusformat);
         }

template<class _Elem >

virtual string_type __CLR_OR_THIS_CALL _Mpunct< _Elem >::do_negative_sign ( ) const

inlineprotectedvirtual

         {   // return minus sign
         return (string_type(_Minussign));
         }

template<class _Elem >

virtual pattern __CLR_OR_THIS_CALL _Mpunct< _Elem >::do_pos_format ( ) const

inlineprotectedvirtual

         {   // return format for positive values
         return (_Plusformat);
         }

template<class _Elem >

virtual string_type __CLR_OR_THIS_CALL _Mpunct< _Elem >::do_positive_sign ( ) const

inlineprotectedvirtual

         {   // return plus sign
         return (string_type(_Plussign));
         }

template<class _Elem >

virtual _Elem __CLR_OR_THIS_CALL _Mpunct< _Elem >::do_thousands_sep ( ) const

inlineprotectedvirtual

         {   // return thousands separator
         return (_Kseparator);
         }

template<class _Elem >

int _Mpunct< _Elem >::frac_digits ( ) const

inline

         {   // return number of fraction digits
         return (do_frac_digits());
         }

template<class _Elem >

string _Mpunct< _Elem >::grouping ( ) const

inline

         {   // return grouping string
         return (do_grouping());
         }

template<class _Elem >

pattern _Mpunct< _Elem >::neg_format ( ) const

inline

         {   // return format for negative values
         return (do_neg_format());
         }

template<class _Elem >

string_type _Mpunct< _Elem >::negative_sign ( ) const

inline

         {   // return minus sign
         return (do_negative_sign());
         }

template<class _Elem >

pattern _Mpunct< _Elem >::pos_format ( ) const

inline

         {   // return format for positive values
         return (do_pos_format());
         }

template<class _Elem >

string_type _Mpunct< _Elem >::positive_sign ( ) const

inline

         {   // return plus sign
         return (do_positive_sign());
         }

template<class _Elem >

_Elem _Mpunct< _Elem >::thousands_sep ( ) const

inline

         {   // return thousands separator
         return (do_thousands_sep());
         }

Member Data Documentation

template<class _Elem >

const _Elem* _Mpunct< _Elem >::_Currencysign

private

template<class _Elem >

_Locinfo::_Cvtvec _Mpunct< _Elem >::_Cvt

private

template<class _Elem >

_Elem _Mpunct< _Elem >::_Decimalpoint

private

template<class _Elem >

int _Mpunct< _Elem >::_Fracdigits

private

template<class _Elem >

const char* _Mpunct< _Elem >::_Grouping

private

template<class _Elem >

bool _Mpunct< _Elem >::_International

private

template<class _Elem >

_Elem _Mpunct< _Elem >::_Kseparator

private

template<class _Elem >

pattern _Mpunct< _Elem >::_Minusformat

private

template<class _Elem >

const _Elem* _Mpunct< _Elem >::_Minussign

private

template<class _Elem >

pattern _Mpunct< _Elem >::_Plusformat

private

template<class _Elem >

const _Elem* _Mpunct< _Elem >::_Plussign

private

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

VS2013/inc/xlocmon

Public Types

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation