num_get< _Elem, _InIt > Class Template Reference

Inheritance diagram for num_get< _Elem, _InIt >:

Public Types
typedef numpunct< _Elem >	_Mypunct
typedef basic_string< _Elem, char_traits< _Elem >, allocator< _Elem > >	_Mystr
typedef _Elem	char_type
typedef _InIt	iter_type

Public Member Functions
__CLR_OR_THIS_CALL	num_get (size_t _Refs=0)
__CLR_OR_THIS_CALL	num_get (const _Locinfo &_Lobj, size_t _Refs=0)
_InIt __CLR_OR_THIS_CALL	get (_InIt _First, _InIt _Last, ios_base &_Iosbase, ios_base::iostate &_State, bool &_Val) const
_InIt __CLR_OR_THIS_CALL	get (_InIt _First, _InIt _Last, ios_base &_Iosbase, ios_base::iostate &_State, unsigned short &_Val) const
_InIt __CLR_OR_THIS_CALL	get (_InIt _First, _InIt _Last, ios_base &_Iosbase, ios_base::iostate &_State, unsigned int &_Val) const
_InIt __CLR_OR_THIS_CALL	get (_InIt _First, _InIt _Last, ios_base &_Iosbase, ios_base::iostate &_State, long &_Val) const
_InIt __CLR_OR_THIS_CALL	get (_InIt _First, _InIt _Last, ios_base &_Iosbase, ios_base::iostate &_State, unsigned long &_Val) const
_InIt __CLR_OR_THIS_CALL	get (_InIt _First, _InIt _Last, ios_base &_Iosbase, ios_base::iostate &_State, long long &_Val) const
_InIt __CLR_OR_THIS_CALL	get (_InIt _First, _InIt _Last, ios_base &_Iosbase, ios_base::iostate &_State, unsigned long long &_Val) const
_InIt __CLR_OR_THIS_CALL	get (_InIt _First, _InIt _Last, ios_base &_Iosbase, ios_base::iostate &_State, float &_Val) const
_InIt __CLR_OR_THIS_CALL	get (_InIt _First, _InIt _Last, ios_base &_Iosbase, ios_base::iostate &_State, double &_Val) const
_InIt __CLR_OR_THIS_CALL	get (_InIt _First, _InIt _Last, ios_base &_Iosbase, ios_base::iostate &_State, long double &_Val) const
_InIt __CLR_OR_THIS_CALL	get (_InIt _First, _InIt _Last, ios_base &_Iosbase, ios_base::iostate &_State, void *&_Val) const
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	~num_get () _NOEXCEPT
void	_Init (const _Locinfo &)
virtual _InIt __CLR_OR_THIS_CALL	do_get (_InIt _First, _InIt _Last, ios_base &_Iosbase, ios_base::iostate &_State, bool &_Val) const
virtual _InIt __CLR_OR_THIS_CALL	do_get (_InIt _First, _InIt _Last, ios_base &_Iosbase, ios_base::iostate &_State, unsigned short &_Val) const
virtual _InIt __CLR_OR_THIS_CALL	do_get (_InIt _First, _InIt _Last, ios_base &_Iosbase, ios_base::iostate &_State, unsigned int &_Val) const
virtual _InIt __CLR_OR_THIS_CALL	do_get (_InIt _First, _InIt _Last, ios_base &_Iosbase, ios_base::iostate &_State, long &_Val) const
virtual _InIt __CLR_OR_THIS_CALL	do_get (_InIt _First, _InIt _Last, ios_base &_Iosbase, ios_base::iostate &_State, unsigned long &_Val) const
virtual _InIt __CLR_OR_THIS_CALL	do_get (_InIt _First, _InIt _Last, ios_base &_Iosbase, ios_base::iostate &_State, long long &_Val) const
virtual _InIt __CLR_OR_THIS_CALL	do_get (_InIt _First, _InIt _Last, ios_base &_Iosbase, ios_base::iostate &_State, unsigned long long &_Val) const
virtual _InIt __CLR_OR_THIS_CALL	do_get (_InIt _First, _InIt _Last, ios_base &_Iosbase, ios_base::iostate &_State, float &_Val) const
virtual _InIt __CLR_OR_THIS_CALL	do_get (_InIt _First, _InIt _Last, ios_base &_Iosbase, ios_base::iostate &_State, double &_Val) const
virtual _InIt __CLR_OR_THIS_CALL	do_get (_InIt _First, _InIt _Last, ios_base &_Iosbase, ios_base::iostate &_State, long double &_Val) const
virtual _InIt __CLR_OR_THIS_CALL	do_get (_InIt _First, _InIt _Last, ios_base &_Iosbase, ios_base::iostate &_State, void *&_Val) 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
int __CLRCALL_OR_CDECL	_Getifld (char *_Ac, _InIt &_First, _InIt &_Last, ios_base::fmtflags _Basefield, const locale &_Loc) const
int __CLRCALL_OR_CDECL	_Getffld (char *_Ac, _InIt &_First, _InIt &_Last, ios_base &_Iosbase, int *_Phexexp) const
int __CLRCALL_OR_CDECL	_Getffldx (char *_Ac, _InIt &_First, _InIt &_Last, ios_base &_Iosbase, int *_Phexexp) const

Member Typedef Documentation

template<class _Elem , class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem> >>

typedef numpunct<_Elem> num_get< _Elem, _InIt >::_Mypunct

template<class _Elem , class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem> >>

typedef basic_string<_Elem, char_traits<_Elem>, allocator<_Elem> > num_get< _Elem, _InIt >::_Mystr

template<class _Elem , class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem> >>

typedef _Elem num_get< _Elem, _InIt >::char_type

template<class _Elem , class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem> >>

typedef _InIt num_get< _Elem, _InIt >::iter_type

Constructor & Destructor Documentation

template<class _Elem , class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem> >>

virtual __CLR_OR_THIS_CALL num_get< _Elem, _InIt >::~num_get ( )

inlineprotectedvirtual

        {   // destroy the object
        }

template<class _Elem , class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem> >>

__CLR_OR_THIS_CALL num_get< _Elem, _InIt >::num_get ( size_t  _Refs = 0 )

inlineexplicit

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

template<class _Elem , class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem> >>

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

inline

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

Member Function Documentation

template<class _Elem , class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem> >>

static size_t __CLRCALL_OR_CDECL num_get< _Elem, _InIt >::_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 num_get<_Elem, _InIt>(
                _Locinfo(_Ploc->c_str()));
        return (_X_NUMERIC);
        }

template<class _Elem , class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem> >>

int __CLRCALL_OR_CDECL num_get< _Elem, _InIt >::_Getffld ( char *  _Ac, _InIt &  _First, _InIt &  _Last, ios_base &  _Iosbase, int *  _Phexexp  ) const

inlineprivate

        {   // get floating-point field from [_First, _Last) into _Ac
        if ((_Iosbase.flags() & ios_base::floatfield) == ios_base::hexfloat)
            return (_Getffldx(_Ac, _First, _Last,
                _Iosbase, _Phexexp));   // hex format

        const _Mypunct& _Punct_fac = _USE(_Iosbase.getloc(), _Mypunct);
        const string _Grouping = _Punct_fac.grouping();
        char *_Ptr = _Ac;
        bool _Bad = false;
        bool _Sticky = false;

        enum {
            _NUMGET_SIGNOFF = 10,
            _NUMGET_EOFF = 12};
        static constexpr char _Src[] = {"0123456789-+Ee"};
        _Elem _Atoms[sizeof (_Src)];
        const ctype<_Elem>& _Ctype_fac =
            _USE(_Iosbase.getloc(), ctype<_Elem>);
        _Ctype_fac.widen(&_Src[0], &_Src[sizeof (_Src)], _Atoms);

        if (_First == _Last)
            ;   // empty field
        else if (*_First == _Atoms[_NUMGET_SIGNOFF + 1])
            {   // gather plus sign
            *_Ptr++ = '+';
            ++_First;
            }
        else if (*_First == _Atoms[_NUMGET_SIGNOFF])
            {   // gather minus sign
            *_Ptr++ = '-';
            ++_First;
            }

        char *_Leading = _Ptr;  // remember backstop
        *_Ptr++ = '0';  // backstop carries from sticky bit

        bool _Seendigit = false;    // seen a digit in input
        int _Significant = 0;   // number of significant digits
        int _Pten = 0;  // power of 10 multiplier
        size_t _Idx;

        const int _Max_sig_dig = (*_Phexexp == _ENABLE_V2_BEHAVIOR ? _MAX_SIG_DIG_V2 : _MAX_SIG_DIG_V1);

        const char *_Pg = &_Grouping[0];
        if (*_Pg == CHAR_MAX || *_Pg <= '\0')
            for (; _First != _Last
                && (_Idx = _Find_elem(_Atoms, *_First)) < 10;
                    _Seendigit = true, (void)++_First)
                if (_Max_sig_dig <= _Significant)
                    {   // enough digits, scale by 10 and update _Sticky
                    ++_Pten;
                    if (0 < _Idx)
                        _Sticky = true;
                    }
                else if (_Idx == 0 && _Significant == 0)
                    ;   // drop leading zeros
                else
                    {   // save a significant digit
                    *_Ptr++ = _Src[_Idx];
                    ++_Significant;
                    }
        else
            {   // grouping specified, gather digits and group sizes
            const _Elem _Kseparator = _Grouping.size() == 0
                ? (_Elem)0 : _Punct_fac.thousands_sep();
            string _Groups((size_t)1, '\0');
            size_t _Group = 0;

            for (; _First != _Last; ++_First)
                if ((_Idx = _Find_elem(_Atoms, *_First)) < 10)
                    {   // got a digit, add to group size
                    _Seendigit = true;
                    if (_Max_sig_dig <= _Significant)
                        {   // enough digits, scale by 10 and update _Sticky
                        ++_Pten;
                        if (0 < _Idx)
                            _Sticky = true;
                        }
                    else if (_Idx == 0 && _Significant == 0)
                        ;   // drop leading zeros
                    else
                        {   // save a significant digit
                        *_Ptr++ = _Src[_Idx];
                        ++_Significant;
                        }
                    if (_Groups[_Group] != CHAR_MAX)
                        ++_Groups[_Group];
                    }
                else if (_Groups[_Group] == '\0'
                    || _Kseparator == (_Elem)0
                    || *_First != _Kseparator)
                    break;  // not a group separator, done
                else
                    {   // add a new group to _Groups string
                    _Groups.append((size_t)1, '\0');
                    ++_Group;
                    }
            if (_Group == 0)
                ;   // no thousands separators seen
            else if ('\0' < _Groups[_Group])
                ++_Group;   // add trailing group to group count
            else
                _Bad = true;    // trailing separator, fail

            while (!_Bad && 0 < _Group)
                if (*_Pg == CHAR_MAX)
                    break;  // end of grouping constraints to check
                else if ((0 < --_Group && *_Pg != _Groups[_Group])
                    || (0 == _Group && *_Pg < _Groups[_Group]))
                    _Bad = true;    // bad group size, fail
                else if ('\0' < _Pg[1])
                    ++_Pg;  // group size okay, advance to next test
            }

        if (_First != _Last && *_First == _Punct_fac.decimal_point())
            {   // add .
            *_Ptr++ = localeconv()->decimal_point[0];
            ++_First;
            }

        if (*_Phexexp != _ENABLE_V2_BEHAVIOR && _Significant == 0)
            {   // 0000. so far
            for (; _First != _Last && *_First == _Atoms[0];
                _Seendigit = true, (void)++_First)
                --_Pten;    // just count leading fraction zeros
            if (_Pten < 0)
                {   // put one back
                *_Ptr++ = '0';
                ++_Pten;
                }
            }

        for (; _First != _Last
                && (_Idx = _Find_elem(_Atoms, *_First)) < 10;
                _Seendigit = true, (void)++_First)
            if (_Significant < _Max_sig_dig)
                {   // save a significant fraction digit
                *_Ptr++ = _Src[_Idx];
                ++_Significant;
                }
            else if (0 < _Idx)
                _Sticky = true; // just update _Sticky

        if (_Sticky)
            {   // increment ls digit in memory of those lost
            char *_Px = _Ptr;
            for (; --_Px != _Leading; )
                {   // add in carry
                if (*_Px == localeconv()->decimal_point[0])
                    ;   // skip over decimal point
                else if (*_Px != '9')
                    {   // carry stops here
                    ++*_Px;
                    break;
                    }
                else
                    *_Px = '0'; // propagate carry
                }

            if (_Px == _Leading)
                {   // change "999..." to "1000..." and scale _Pten
                *_Px = '1';
                ++_Pten;
                }
            }

        if (_Seendigit && _First != _Last
            && (*_First == _Atoms[_NUMGET_EOFF + 1]
                || *_First == _Atoms[_NUMGET_EOFF]))
            {   // 'e' or 'E', collect exponent
            *_Ptr++ = 'e';
            ++_First;
            _Seendigit = false;
            _Significant = 0;

            if (_First == _Last)
                ;   // 'e' or 'E' is last element
            else if (*_First == _Atoms[_NUMGET_SIGNOFF + 1])
                {   // gather plus sign
                *_Ptr++ = '+';
                ++_First;
                }
            else if (*_First == _Atoms[_NUMGET_SIGNOFF])
                {   // gather minus sign
                *_Ptr++ = '-';
                ++_First;
                }

            for (; _First != _Last && *_First == _Atoms[0]; ++_First)
                {   // strip leading zeros
                _Seendigit = true;
                }

            if (_Seendigit)
                *_Ptr++ = '0';  // put one back
            for (; _First != _Last
                && (_Idx = _Find_elem(_Atoms, *_First)) < 10;
                _Seendigit = true, (void)++_First)
                if (_Significant < _MAX_EXP_DIG)
                    {   // save a significant exponent digit
                    *_Ptr++ = _Src[_Idx];
                    ++_Significant;
                    }
            }

        if (_Bad || !_Seendigit)
            _Ptr = _Ac; // roll back pointer to indicate failure
        *_Ptr = '\0';
        return (_Pten);
        }

template<class _Elem , class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem> >>

int __CLRCALL_OR_CDECL num_get< _Elem, _InIt >::_Getffldx ( char *  _Ac, _InIt &  _First, _InIt &  _Last, ios_base &  _Iosbase, int *  _Phexexp  ) const

inlineprivate

        {   // get hex floating-point field from [_First, _Last) into _Ac
        const _Mypunct& _Punct_fac = _USE(_Iosbase.getloc(), _Mypunct);
        const string _Grouping = _Punct_fac.grouping();

        enum {
            _NUMGET_SIGNOFF = 22,
            _NUMGET_XOFF = 24,
            _NUMGET_POFF = 26};
        static constexpr char _Src[] = {"0123456789ABCDEFabcdef-+XxPp"};
        _Elem _Atoms[sizeof (_Src)];
        const ctype<_Elem>& _Ctype_fac =
            _USE(_Iosbase.getloc(), ctype<_Elem>);
        _Ctype_fac.widen(&_Src[0], &_Src[sizeof (_Src)], _Atoms);

        char *_Ptr = _Ac;
        bool _Bad = false;
        size_t _Idx;

        if (_First == _Last)
            ;   // empty field
        else if (*_First == _Atoms[_NUMGET_SIGNOFF + 1])
            {   // gather plus sign
            *_Ptr++ = '+';
            ++_First;
            }
        else if (*_First == _Atoms[_NUMGET_SIGNOFF])
            {   // gather minus sign
            *_Ptr++ = '-';
            ++_First;
            }

        *_Ptr++ = '0';
        *_Ptr++ = 'x';

        bool _Seendigit = false;    // seen a digit in input
        int _Significant = 0;   // number of significant digits
        int _Phex = 0;  // power of 10 multiplier

        if (_First == _Last || *_First != _Atoms[0])
            ;
        else if (++_First != _Last
            && (*_First == _Atoms[_NUMGET_XOFF + 1]
                || *_First == _Atoms[_NUMGET_XOFF]))
            ++_First;   // discard any 0x or 0X
        else
            _Seendigit = true;  // '0' not followed by 'x' or 'X'

        const int _Max_sig_dig = (*_Phexexp == _ENABLE_V2_BEHAVIOR ? _MAX_SIG_DIG_V2 : _MAX_SIG_DIG_V1);

        const char *_Pg = &_Grouping[0];
        if (*_Pg == CHAR_MAX || *_Pg <= '\0')
            for (; _First != _Last
                && (_Idx = _Find_elem(_Atoms, *_First)) < _NUMGET_SIGNOFF;
                    _Seendigit = true, (void)++_First)
                if (_Max_sig_dig <= _Significant)
                    ++_Phex;    // just scale by 10
                else if (_Idx == 0 && _Significant == 0)
                    ;   // drop leading zeros
                else
                    {   // save a significant digit
                    *_Ptr++ = _Src[_Idx];
                    ++_Significant;
                    }
        else
            {   // grouping specified, gather digits and group sizes
            const _Elem _Kseparator = _Grouping.size() == 0
                ? (_Elem)0 : _Punct_fac.thousands_sep();
            string _Groups((size_t)1, '\0');
            size_t _Group = 0;

            for (; _First != _Last; ++_First)
                if ((_Idx = _Find_elem(_Atoms, *_First)) < _NUMGET_SIGNOFF)
                    {   // got a digit, add to group size
                    _Seendigit = true;
                    if (_Max_sig_dig <= _Significant)
                        ++_Phex;    // just scale by 10
                    else if (_Idx == 0 && _Significant == 0)
                        ;   // drop leading zeros
                    else
                        {   // save a significant digit
                        *_Ptr++ = _Src[_Idx];
                        ++_Significant;
                        }
                    if (_Groups[_Group] != CHAR_MAX)
                        ++_Groups[_Group];
                    }
                else if (_Groups[_Group] == '\0'
                    || _Kseparator == (_Elem)0
                    || *_First != _Kseparator)
                    break;  // not a group separator, done
                else
                    {   // add a new group to _Groups string
                    _Groups.append((size_t)1, '\0');
                    ++_Group;
                    }
            if (_Group == 0)
                ;   // no thousands separators seen
            else if ('\0' < _Groups[_Group])
                ++_Group;   // add trailing group to group count
            else
                _Bad = true;    // trailing separator, fail

            while (!_Bad && 0 < _Group)
                if (*_Pg == CHAR_MAX)
                    break;  // end of grouping constraints to check
                else if ((0 < --_Group && *_Pg != _Groups[_Group])
                    || (0 == _Group && *_Pg < _Groups[_Group]))
                    _Bad = true;    // bad group size, fail
                else if ('\0' < _Pg[1])
                    ++_Pg;  // group size okay, advance to next test
            }

        if (_Seendigit && _Significant == 0)
            *_Ptr++ = '0';  // save at least one leading digit

        if (_First != _Last && *_First == _Punct_fac.decimal_point())
            {   // add .
            *_Ptr++ = localeconv()->decimal_point[0];
            ++_First;
            }

        if (_Significant == 0)
            {   // 0000. so far
            for (; _First != _Last && *_First == _Atoms[0];
                _Seendigit = true, (void)++_First)
                --_Phex;    // just count leading fraction zeros
            if (_Phex < 0)
                {   // put one back
                *_Ptr++ = '0';
                ++_Phex;
                }
            }

        for (; _First != _Last
                && (_Idx = _Find_elem(_Atoms, *_First)) < _NUMGET_SIGNOFF;
                _Seendigit = true, (void)++_First)
            if (_Significant < _Max_sig_dig)
                {   // save a significant fraction digit
                *_Ptr++ = _Src[_Idx];
                ++_Significant;
                }

        if (_Seendigit && _First != _Last
            && (*_First == _Atoms[_NUMGET_POFF + 1]
                || *_First == _Atoms[_NUMGET_POFF]))
            {   // 'p' or 'P', collect exponent
            *_Ptr++ = 'p';
            ++_First;
            _Seendigit = false;
            _Significant = 0;

            if (_First == _Last)
                ;   // 'p' or 'P' is last element
            else if (*_First == _Atoms[_NUMGET_SIGNOFF + 1])
                {   // gather plus sign
                *_Ptr++ = '+';
                ++_First;
                }
            else if (*_First == _Atoms[_NUMGET_SIGNOFF])
                {   // gather minus sign
                *_Ptr++ = '-';
                ++_First;
                }

            for (; _First != _Last && *_First == _Atoms[0]; ++_First)
                {   // strip leading zeros
                _Seendigit = true;
                }

            if (_Seendigit)
                *_Ptr++ = '0';  // put one back
            for (; _First != _Last
                && (_Idx = _Find_elem(_Atoms, *_First)) < _NUMGET_SIGNOFF;
                _Seendigit = true, (void)++_First)
                if (_Significant < _MAX_EXP_DIG)
                    {   // save a significant exponent digit
                    *_Ptr++ = _Src[_Idx];
                    ++_Significant;
                    }
            }

        if (_Bad || !_Seendigit)
            _Ptr = _Ac; // roll back pointer to indicate failure
        *_Ptr = '\0';
        *_Phexexp = _Phex;  // power of 16 multiplier
        return (0); // power of 10 multiplier
        }

template<class _Elem , class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem> >>

int __CLRCALL_OR_CDECL num_get< _Elem, _InIt >::_Getifld ( char *  _Ac, _InIt &  _First, _InIt &  _Last, ios_base::fmtflags  _Basefield, const locale &  _Loc  ) const

inlineprivate

        {   // get integer field from [_First, _Last) into _Ac
        const _Mypunct& _Punct_fac = _USE(_Loc, _Mypunct);
        const string _Grouping = _Punct_fac.grouping();
        const _Elem _Kseparator = _Grouping.size() == 0
            ? (_Elem)0 : _Punct_fac.thousands_sep();

        enum {
            _NUMGET_SIGNOFF = 22,
            _NUMGET_XOFF = 24};
        static constexpr char _Src[] = {"0123456789ABCDEFabcdef-+Xx"};
        _Elem _Atoms[sizeof (_Src)];
        const ctype<_Elem>& _Ctype_fac =
            _USE(_Loc, ctype<_Elem>);
        _Ctype_fac.widen(&_Src[0], &_Src[sizeof (_Src)], _Atoms);

        char *_Ptr = _Ac;

        if (_First == _Last)
            ;   // empty field
        else if (*_First == _Atoms[_NUMGET_SIGNOFF + 1])
            {   // gather plus sign
            *_Ptr++ = '+';
            ++_First;
            }
        else if (*_First == _Atoms[_NUMGET_SIGNOFF])
            {   // gather minus sign
            *_Ptr++ = '-';
            ++_First;
            }

        _Basefield &= ios_base::basefield;
        int _Base = _Basefield == ios_base::oct ? 8
            : _Basefield == ios_base::hex ? 16
            : _Basefield == ios_base::_Fmtzero ? 0 : 10;

        bool _Seendigit = false;    // seen a digit in input
        bool _Nonzero = false;  // seen a nonzero digit in input

        if (_First != _Last && *_First == _Atoms[0])
            {   // leading zero, look for 0x, 0X
            _Seendigit = true;
            ++_First;
            if (_First != _Last && (*_First == _Atoms[_NUMGET_XOFF + 1]
                    || *_First == _Atoms[_NUMGET_XOFF])
                && (_Base == 0 || _Base == 16))
                {
                _Base = 16;
                _Seendigit = false;
                ++_First;
                }
            else if (_Base == 0)
                {
                _Base = 8;
                }
            }

        size_t _Dlen = _Base == 0 || _Base == 10 ? 10
            : _Base == 8 ? 8 : 16 + 6;
        string _Groups((size_t)1, (char)_Seendigit);
        size_t _Group = 0;

        for (char *const _Pe = &_Ac[_MAX_INT_DIG - 1];
            _First != _Last; ++_First)
            {   // look for digits and separators
            size_t _Idx = _Find_elem(_Atoms, *_First);
            if (_Idx < _Dlen)
                {   // got a digit, characterize it and add to group size
                *_Ptr = _Src[_Idx];
                if ((_Nonzero || *_Ptr != '0') && _Ptr < _Pe)
                    {
                    ++_Ptr;
                    _Nonzero = true;
                    }

                _Seendigit = true;
                if (_Groups[_Group] != CHAR_MAX)
                    ++_Groups[_Group];
                }
            else if (_Groups[_Group] == '\0'
                || _Kseparator == (_Elem)0
                || *_First != _Kseparator)
                break;  // not a group separator, done
            else
                {   // add a new group to _Groups string
                _Groups.append((string::size_type)1, '\0');
                ++_Group;
                }
            }

        if (_Group == 0)
            ;   // no thousands separators seen
        else if ('\0' < _Groups[_Group])
            ++_Group;   // add trailing group to group count
        else
            _Seendigit = false; // trailing separator, fail

        for (const char *_Pg = &_Grouping[0]; _Seendigit && 0 < _Group; )
            if (*_Pg == CHAR_MAX)
                break;  // end of grouping constraints to check
            else if ((0 < --_Group && *_Pg != _Groups[_Group])
                || (0 == _Group && *_Pg < _Groups[_Group]))
                _Seendigit = false; // bad group size, fail
            else if ('\0' < _Pg[1])
                ++_Pg;  // group size okay, advance to next test

        if (_Seendigit && !_Nonzero)
            *_Ptr++ = '0';  // zero field, replace stripped zero(s)
        else if (!_Seendigit)
            _Ptr = _Ac; // roll back pointer to indicate failure
        *_Ptr = '\0';
        return (_Base);
        }

template<class _Elem , class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem> >>

void num_get< _Elem, _InIt >::_Init ( const _Locinfo &  )

inlineprotected

        {   // initialize from _Locinfo object
        }

template<class _Elem , class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem> >>

virtual _InIt __CLR_OR_THIS_CALL num_get< _Elem, _InIt >::do_get ( _InIt  _First, _InIt  _Last, ios_base &  _Iosbase, ios_base::iostate &  _State, bool &  _Val  ) const

inlineprotectedvirtual

        {   // get bool from [_First, _Last) into _Val
        _DEBUG_RANGE(_First, _Last);
        int _Ans = -1;  // negative answer indicates failure

        if (_Iosbase.flags() & ios_base::boolalpha)
            {   // get false name or true name
            typedef typename _Mystr::size_type _Mystrsize;
            const _Mypunct& _Punct_fac = _USE(_Iosbase.getloc(), _Mypunct);
            _Mystr _Str((_Mystrsize)1, (char_type)0);
            _Str += _Punct_fac.falsename();
            _Str += (char_type)0;
            _Str += _Punct_fac.truename();  // construct "\0false\0true"
            _Ans = _Getloctxt(_First, _Last, (size_t)2, _Str.c_str());
            }
        else
            {   // get zero or nonzero integer
            char _Ac[_MAX_INT_DIG], *_Ep;
            int _Errno = 0;
            const unsigned long _Ulo = _CSTD _Stoulx(_Ac, &_Ep,
                _Getifld(_Ac, _First, _Last, _Iosbase.flags(),
                    _Iosbase.getloc()), &_Errno);
            if (_Ep != _Ac && _Errno == 0 && _Ulo <= 1)
                _Ans = _Ulo;
            }

        if (_First == _Last)
            _State |= ios_base::eofbit;
        if (_Ans < 0)
            _State |= ios_base::failbit;
        else
            _Val = _Ans != 0;   // deliver value
        return (_First);
        }

template<class _Elem , class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem> >>

virtual _InIt __CLR_OR_THIS_CALL num_get< _Elem, _InIt >::do_get ( _InIt  _First, _InIt  _Last, ios_base &  _Iosbase, ios_base::iostate &  _State, unsigned short &  _Val  ) const

inlineprotectedvirtual

        {   // get unsigned short from [_First, _Last) into _Val
        _DEBUG_RANGE(_First, _Last);
        char _Ac[_MAX_INT_DIG], *_Ep;
        int _Errno = 0;
        int _Base = _Getifld(_Ac, _First, _Last, _Iosbase.flags(),
            _Iosbase.getloc()); // gather field into _Ac
        char *_Ptr = _Ac[0] == '-' ? _Ac + 1 : _Ac; // point past any sign
        const unsigned long _Ans =
            _CSTD _Stoulx(_Ptr, &_Ep, _Base, &_Errno);  // convert

        if (_First == _Last)
            _State |= ios_base::eofbit;
        if (_Ep == _Ptr || _Errno != 0 || USHRT_MAX < _Ans)
            _State |= ios_base::failbit;
        else
            _Val = (unsigned short)(_Ac[0] == '-'
                ? 0 -_Ans : _Ans);  // deliver value
        return (_First);
        }

template<class _Elem , class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem> >>

virtual _InIt __CLR_OR_THIS_CALL num_get< _Elem, _InIt >::do_get ( _InIt  _First, _InIt  _Last, ios_base &  _Iosbase, ios_base::iostate &  _State, unsigned int &  _Val  ) const

inlineprotectedvirtual

        {   // get unsigned int from [_First, _Last) into _Val
        _DEBUG_RANGE(_First, _Last);
        char _Ac[_MAX_INT_DIG], *_Ep;
        int _Errno = 0;
        int _Base = _Getifld(_Ac, _First, _Last, _Iosbase.flags(),
            _Iosbase.getloc()); // gather field into _Ac
        char *_Ptr = _Ac[0] == '-' ? _Ac + 1 : _Ac; // point past any sign
        const unsigned long _Ans =
            _CSTD _Stoulx(_Ptr, &_Ep, _Base, &_Errno);  // convert

        if (_First == _Last)
            _State |= ios_base::eofbit;
        if (_Ep == _Ptr || _Errno != 0 || UINT_MAX < _Ans)
            _State |= ios_base::failbit;
        else
            _Val = _Ac[0] == '-' ? 0 -_Ans : _Ans;  // deliver value
        return (_First);
        }

template<class _Elem , class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem> >>

virtual _InIt __CLR_OR_THIS_CALL num_get< _Elem, _InIt >::do_get ( _InIt  _First, _InIt  _Last, ios_base &  _Iosbase, ios_base::iostate &  _State, long &  _Val  ) const

inlineprotectedvirtual

        {   // get long from [_First, _Last) into _Val
        _DEBUG_RANGE(_First, _Last);
        char _Ac[_MAX_INT_DIG], *_Ep;
        int _Errno = 0;
        const long _Ans = _CSTD _Stolx(_Ac, &_Ep,
            _Getifld(_Ac, _First, _Last, _Iosbase.flags(),
                _Iosbase.getloc()), &_Errno);   // gather field, convert

        if (_First == _Last)
            _State |= ios_base::eofbit;
        if (_Ep == _Ac || _Errno != 0)
            _State |= ios_base::failbit;
        else
            _Val = _Ans;    // deliver value
        return (_First);
        }

template<class _Elem , class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem> >>

virtual _InIt __CLR_OR_THIS_CALL num_get< _Elem, _InIt >::do_get ( _InIt  _First, _InIt  _Last, ios_base &  _Iosbase, ios_base::iostate &  _State, unsigned long &  _Val  ) const

inlineprotectedvirtual

        {   // get unsigned long from [_First, _Last) into _Val
        _DEBUG_RANGE(_First, _Last);
        char _Ac[_MAX_INT_DIG], *_Ep;
        int _Errno = 0;
        const unsigned long _Ans = _CSTD _Stoulx(_Ac, &_Ep,
            _Getifld(_Ac, _First, _Last, _Iosbase.flags(),
                _Iosbase.getloc()), &_Errno);   // gather field, convert

        if (_First == _Last)
            _State |= ios_base::eofbit;
        if (_Ep == _Ac || _Errno != 0)
            _State |= ios_base::failbit;
        else
            _Val = _Ans;    // deliver value
        return (_First);
        }

template<class _Elem , class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem> >>

virtual _InIt __CLR_OR_THIS_CALL num_get< _Elem, _InIt >::do_get ( _InIt  _First, _InIt  _Last, ios_base &  _Iosbase, ios_base::iostate &  _State, long long &  _Val  ) const

inlineprotectedvirtual

        {   // get long long from [_First, _Last) into _Val
        _DEBUG_RANGE(_First, _Last);
        char _Ac[_MAX_INT_DIG], *_Ep;
        int _Errno = 0;
        const long long _Ans = _CSTD _Stollx(_Ac, &_Ep,
            _Getifld(_Ac, _First, _Last, _Iosbase.flags(),
                _Iosbase.getloc()), &_Errno);   // gather field, convert

        if (_First == _Last)
            _State |= ios_base::eofbit;
        if (_Ep == _Ac || _Errno != 0)
            _State |= ios_base::failbit;
        else
            _Val = _Ans;    // deliver value
        return (_First);
        }

template<class _Elem , class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem> >>

virtual _InIt __CLR_OR_THIS_CALL num_get< _Elem, _InIt >::do_get ( _InIt  _First, _InIt  _Last, ios_base &  _Iosbase, ios_base::iostate &  _State, unsigned long long &  _Val  ) const

inlineprotectedvirtual

        {   // get unsigned long long from [_First, _Last) into _Val
        _DEBUG_RANGE(_First, _Last);
        char _Ac[_MAX_INT_DIG], *_Ep;
        int _Errno = 0;
        const unsigned long long _Ans = _CSTD _Stoullx(_Ac, &_Ep,
            _Getifld(_Ac, _First, _Last, _Iosbase.flags(),
                _Iosbase.getloc()), &_Errno);   // gather field, convert

        if (_First == _Last)
            _State |= ios_base::eofbit;
        if (_Ep == _Ac || _Errno != 0)
            _State |= ios_base::failbit;
        else
            _Val = _Ans;    // deliver value
        return (_First);
        }

template<class _Elem , class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem> >>

virtual _InIt __CLR_OR_THIS_CALL num_get< _Elem, _InIt >::do_get ( _InIt  _First, _InIt  _Last, ios_base &  _Iosbase, ios_base::iostate &  _State, float &  _Val  ) const

inlineprotectedvirtual

        {   // get float from [_First, _Last) into _Val
        _DEBUG_RANGE(_First, _Last);
        char _Ac[_FLOATING_BUFFER_SIZE], *_Ep;
        int _Errno = 0;
        int _Hexexp = _ENABLE_V2_BEHAVIOR;
        float _Ans = _Stofx_v2(_Ac, &_Ep,
            _Getffld(_Ac, _First, _Last,
                _Iosbase, &_Hexexp), &_Errno);  // gather field, convert

        if (_Hexexp != _ENABLE_V2_BEHAVIOR && _Hexexp != 0)
            _Ans = _CSTD ldexpf(_Ans, 4 * _Hexexp);

        if (_First == _Last)
            _State |= ios_base::eofbit;
        if (_Ep == _Ac || _Errno != 0)
            _State |= ios_base::failbit;
        else
            _Val = _Ans;    // deliver value
        return (_First);
        }

template<class _Elem , class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem> >>

virtual _InIt __CLR_OR_THIS_CALL num_get< _Elem, _InIt >::do_get ( _InIt  _First, _InIt  _Last, ios_base &  _Iosbase, ios_base::iostate &  _State, double &  _Val  ) const

inlineprotectedvirtual

        {   // get double from [_First, _Last) into _Val
        _DEBUG_RANGE(_First, _Last);
        char _Ac[_FLOATING_BUFFER_SIZE], *_Ep;
        int _Errno = 0;
        int _Hexexp = _ENABLE_V2_BEHAVIOR;
        double _Ans = _Stodx_v2(_Ac, &_Ep,
            _Getffld(_Ac, _First, _Last,
                _Iosbase, &_Hexexp), &_Errno);  // gather field, convert

        if (_Hexexp != _ENABLE_V2_BEHAVIOR && _Hexexp != 0)
            _Ans = _CSTD ldexp(_Ans, 4 * _Hexexp);

        if (_First == _Last)
            _State |= ios_base::eofbit;
        if (_Ep == _Ac || _Errno != 0)
            _State |= ios_base::failbit;
        else
            _Val = _Ans;    // deliver value
        return (_First);
        }

template<class _Elem , class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem> >>

virtual _InIt __CLR_OR_THIS_CALL num_get< _Elem, _InIt >::do_get ( _InIt  _First, _InIt  _Last, ios_base &  _Iosbase, ios_base::iostate &  _State, long double &  _Val  ) const

inlineprotectedvirtual

        {   // get long double from [_First, _Last) into _Val
        _DEBUG_RANGE(_First, _Last);
        char _Ac[_FLOATING_BUFFER_SIZE], *_Ep;
        int _Errno = 0;
        int _Hexexp = _ENABLE_V2_BEHAVIOR;
        long double _Ans = _Stodx_v2(_Ac, &_Ep,
            _Getffld(_Ac, _First, _Last,
                _Iosbase, &_Hexexp), &_Errno);  // gather field, convert, "widen" double to long double

        if (_Hexexp != _ENABLE_V2_BEHAVIOR && _Hexexp != 0)
            _Ans = _CSTD ldexpl(_Ans, 4 * _Hexexp);

        if (_First == _Last)
            _State |= ios_base::eofbit;
        if (_Ep == _Ac || _Errno != 0)
            _State |= ios_base::failbit;
        else
            _Val = _Ans;    // deliver value
        return (_First);
        }

template<class _Elem , class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem> >>

virtual _InIt __CLR_OR_THIS_CALL num_get< _Elem, _InIt >::do_get ( _InIt  _First, _InIt  _Last, ios_base &  _Iosbase, ios_base::iostate &  _State, void *&  _Val  ) const

inlineprotectedvirtual

        {   // get void pointer from [_First, _Last) into _Val
        _DEBUG_RANGE(_First, _Last);
        char _Ac[_MAX_INT_DIG], *_Ep;
        int _Errno = 0;

        int _Base = _Getifld(_Ac, _First, _Last, ios_base::hex,
            _Iosbase.getloc()); // gather field
        const unsigned long long _Ans =
            (sizeof (void *) == sizeof (unsigned long))
                ? (unsigned long long)_CSTD _Stoulx(_Ac, &_Ep, _Base, &_Errno)
                : _CSTD _Stoullx(_Ac, &_Ep, _Base, &_Errno);

        if (_First == _Last)
            _State |= ios_base::eofbit;
        if (_Ep == _Ac || _Errno != 0)
            _State |= ios_base::failbit;
        else
            _Val = (void *)((char *)0 + _Ans);  // deliver value
        return (_First);
        }

template<class _Elem , class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem> >>

_InIt __CLR_OR_THIS_CALL num_get< _Elem, _InIt >::get ( _InIt  _First, _InIt  _Last, ios_base &  _Iosbase, ios_base::iostate &  _State, bool &  _Val  ) const

inline

        {   // get bool from [_First, _Last) into _Val
        return (do_get(_First, _Last, _Iosbase, _State, _Val));
        }

template<class _Elem , class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem> >>

_InIt __CLR_OR_THIS_CALL num_get< _Elem, _InIt >::get ( _InIt  _First, _InIt  _Last, ios_base &  _Iosbase, ios_base::iostate &  _State, unsigned short &  _Val  ) const

inline

        {   // get unsigned short from [_First, _Last) into _Val
        return (do_get(_First, _Last, _Iosbase, _State, _Val));
        }

template<class _Elem , class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem> >>

_InIt __CLR_OR_THIS_CALL num_get< _Elem, _InIt >::get ( _InIt  _First, _InIt  _Last, ios_base &  _Iosbase, ios_base::iostate &  _State, unsigned int &  _Val  ) const

inline

        {   // get unsigned int from [_First, _Last) into _Val
        return (do_get(_First, _Last, _Iosbase, _State, _Val));
        }

template<class _Elem , class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem> >>

_InIt __CLR_OR_THIS_CALL num_get< _Elem, _InIt >::get ( _InIt  _First, _InIt  _Last, ios_base &  _Iosbase, ios_base::iostate &  _State, long &  _Val  ) const

inline

        {   // get long from [_First, _Last) into _Val
        return (do_get(_First, _Last, _Iosbase, _State, _Val));
        }

template<class _Elem , class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem> >>

_InIt __CLR_OR_THIS_CALL num_get< _Elem, _InIt >::get ( _InIt  _First, _InIt  _Last, ios_base &  _Iosbase, ios_base::iostate &  _State, unsigned long &  _Val  ) const

inline

        {   // get unsigned long from [_First, _Last) into _Val
        return (do_get(_First, _Last, _Iosbase, _State, _Val));
        }

template<class _Elem , class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem> >>

_InIt __CLR_OR_THIS_CALL num_get< _Elem, _InIt >::get ( _InIt  _First, _InIt  _Last, ios_base &  _Iosbase, ios_base::iostate &  _State, long long &  _Val  ) const

inline

        {   // get long long from [_First, _Last) into _Val
        return (do_get(_First, _Last, _Iosbase, _State, _Val));
        }

template<class _Elem , class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem> >>

_InIt __CLR_OR_THIS_CALL num_get< _Elem, _InIt >::get ( _InIt  _First, _InIt  _Last, ios_base &  _Iosbase, ios_base::iostate &  _State, unsigned long long &  _Val  ) const

inline

        {   // get unsigned long long from [_First, _Last) into _Val
        return (do_get(_First, _Last, _Iosbase, _State, _Val));
        }

template<class _Elem , class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem> >>

_InIt __CLR_OR_THIS_CALL num_get< _Elem, _InIt >::get ( _InIt  _First, _InIt  _Last, ios_base &  _Iosbase, ios_base::iostate &  _State, float &  _Val  ) const

inline

        {   // get float from [_First, _Last) into _Val
        return (do_get(_First, _Last, _Iosbase, _State, _Val));
        }

template<class _Elem , class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem> >>

_InIt __CLR_OR_THIS_CALL num_get< _Elem, _InIt >::get ( _InIt  _First, _InIt  _Last, ios_base &  _Iosbase, ios_base::iostate &  _State, double &  _Val  ) const

inline

        {   // get double from [_First, _Last) into _Val
        return (do_get(_First, _Last, _Iosbase, _State, _Val));
        }

template<class _Elem , class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem> >>

_InIt __CLR_OR_THIS_CALL num_get< _Elem, _InIt >::get ( _InIt  _First, _InIt  _Last, ios_base &  _Iosbase, ios_base::iostate &  _State, long double &  _Val  ) const

inline

        {   // get long double from [_First, _Last) into _Val
        return (do_get(_First, _Last, _Iosbase, _State, _Val));
        }

template<class _Elem , class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem> >>

_InIt __CLR_OR_THIS_CALL num_get< _Elem, _InIt >::get ( _InIt  _First, _InIt  _Last, ios_base &  _Iosbase, ios_base::iostate &  _State, void *&  _Val  ) const

inline

        {   // get void pointer from [_First, _Last) into _Val
        return (do_get(_First, _Last, _Iosbase, _State, _Val));
        }

Member Data Documentation

template<class _Elem , class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem> >>

__PURE_APPDOMAIN_GLOBAL locale::id num_get< _Elem, _InIt >::id

static

---

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

• VS2017/inc/xlocnum