_M_extract() [1/2]

template<typename _CharT, typename _InIter>

template<bool _Intl>

_GLIBCXX_BEGIN_NAMESPACE_LDBL_OR_CXX11 _InIter std::money_get< _CharT, _InIter >::_M_extract	(	iter_type	__beg,
		iter_type	__end,
		ios_base &	__io,
		ios_base::iostate &	__err,
		string &	__units ) const

Definition at line 138 of file locale_facets_nonio.tcc.

      {
      typedef char_traits<_CharT>                 __traits_type;
      typedef typename string_type::size_type             size_type;    
      typedef money_base::part                    part;
      typedef __moneypunct_cache<_CharT, _Intl>         __cache_type;
      
      const locale& __loc = __io._M_getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
 
      __use_cache<__cache_type> __uc;
      const __cache_type* __lc = __uc(__loc);
      const char_type* __lit = __lc->_M_atoms;
 
      // Deduced sign.
      bool __negative = false;
      // Sign size.
      size_type __sign_size = 0;
      // True if sign is mandatory.
      const bool __mandatory_sign = (__lc->_M_positive_sign_size
                               && __lc->_M_negative_sign_size);
      // String of grouping info from thousands_sep plucked from __units.
      string __grouping_tmp;
      if (__lc->_M_use_grouping)
        __grouping_tmp.reserve(32);
      // Last position before the decimal point.
      int __last_pos = 0;
      // Separator positions, then, possibly, fractional digits.
      int __n = 0;
      // If input iterator is in a valid state.
      bool __testvalid = true;
      // Flag marking when a decimal point is found.
      bool __testdecfound = false;
 
      // The tentative returned string is stored here.
      string __res;
      __res.reserve(32);
 
      const char_type* __lit_zero = __lit + money_base::_S_zero;
      const money_base::pattern __p = __lc->_M_neg_format;
      for (int __i = 0; __i < 4 && __testvalid; ++__i)
        {
          const part __which = static_cast<part>(__p.field[__i]);
          switch (__which)
            {
            case money_base::symbol:
            // According to 22.2.6.1.2, p2, symbol is required
            // if (__io.flags() & ios_base::showbase), otherwise
            // is optional and consumed only if other characters
            // are needed to complete the format.
            if (__io.flags() & ios_base::showbase || __sign_size > 1
                || __i == 0
                || (__i == 1 && (__mandatory_sign
                             || (static_cast<part>(__p.field[0])
                               == money_base::sign)
                             || (static_cast<part>(__p.field[2])
                               == money_base::space)))
                || (__i == 2 && ((static_cast<part>(__p.field[3])
                              == money_base::value)
                             || (__mandatory_sign
                               && (static_cast<part>(__p.field[3])
                                   == money_base::sign)))))
              {
                const size_type __len = __lc->_M_curr_symbol_size;
                size_type __j = 0;
                for (; __beg != __end && __j < __len
                     && *__beg == __lc->_M_curr_symbol[__j];
                   ++__beg, (void)++__j);
                if (__j != __len
                  && (__j || __io.flags() & ios_base::showbase))
                  __testvalid = false;
              }
            break;
            case money_base::sign:
            // Sign might not exist, or be more than one character long.
            if (__lc->_M_positive_sign_size && __beg != __end
                && *__beg == __lc->_M_positive_sign[0])
              {
                __sign_size = __lc->_M_positive_sign_size;
                ++__beg;
              }
            else if (__lc->_M_negative_sign_size && __beg != __end
                   && *__beg == __lc->_M_negative_sign[0])
              {
                __negative = true;
                __sign_size = __lc->_M_negative_sign_size;
                ++__beg;
              }
            else if (__lc->_M_positive_sign_size
                   && !__lc->_M_negative_sign_size)
              // "... if no sign is detected, the result is given the sign
              // that corresponds to the source of the empty string"
              __negative = true;
            else if (__mandatory_sign)
              __testvalid = false;
            break;
            case money_base::value:
            // Extract digits, remove and stash away the
            // grouping of found thousands separators.
            for (; __beg != __end; ++__beg)
              {
                const char_type __c = *__beg;
                const char_type* __q = __traits_type::find(__lit_zero, 
                                                 10, __c);
                if (__q != 0)
                  {
                  __res += money_base::_S_atoms[__q - __lit];
                  ++__n;
                  }
                else if (__c == __lc->_M_decimal_point 
                       && !__testdecfound)
                  {
                  if (__lc->_M_frac_digits <= 0)
                    break;
 
                  __last_pos = __n;
                  __n = 0;
                  __testdecfound = true;
                  }
                else if (__lc->_M_use_grouping
                       && __c == __lc->_M_thousands_sep
                       && !__testdecfound)
                  {
                  if (__n)
                    {
                      // Mark position for later analysis.
                      __grouping_tmp += static_cast<char>(__n);
                      __n = 0;
                    }
                  else
                    {
                      __testvalid = false;
                      break;
                    }
                  }
                else
                  break;
              }
            if (__res.empty())
              __testvalid = false;
            break;
            case money_base::space:
            // At least one space is required.
            if (__beg != __end && __ctype.is(ctype_base::space, *__beg))
              ++__beg;
            else
              __testvalid = false;
            // fallthrough
            case money_base::none:
            // Only if not at the end of the pattern.
            if (__i != 3)
              for (; __beg != __end
                   && __ctype.is(ctype_base::space, *__beg); ++__beg);
            break;
            }
        }
 
      // Need to get the rest of the sign characters, if they exist.
      if (__sign_size > 1 && __testvalid)
        {
          const char_type* __sign = __negative ? __lc->_M_negative_sign
                                               : __lc->_M_positive_sign;
          size_type __i = 1;
          for (; __beg != __end && __i < __sign_size
               && *__beg == __sign[__i]; ++__beg, (void)++__i);
          
          if (__i != __sign_size)
            __testvalid = false;
        }
 
      if (__testvalid)
        {
          // Strip leading zeros.
          if (__res.size() > 1)
            {
            const size_type __first = __res.find_first_not_of('0');
            const bool __only_zeros = __first == string::npos;
            if (__first)
              __res.erase(0, __only_zeros ? __res.size() - 1 : __first);
            }
 
          // 22.2.6.1.2, p4
          if (__negative && __res[0] != '0')
            __res.insert(__res.begin(), '-');
          
          // Test for grouping fidelity.
          if (__grouping_tmp.size())
            {
            // Add the ending grouping.
            __grouping_tmp += static_cast<char>(__testdecfound ? __last_pos
                                                       : __n);
            if (!std::__verify_grouping(__lc->_M_grouping,
                                  __lc->_M_grouping_size,
                                  __grouping_tmp))
              __err |= ios_base::failbit;
            }
          
          // Iff not enough digits were supplied after the decimal-point.
          if (__testdecfound && __n != __lc->_M_frac_digits)
            __testvalid = false;
        }
 
      // Iff valid sequence is not recognized.
      if (!__testvalid)
        __err |= ios_base::failbit;
      else
        __units.swap(__res);
      
      // Iff no more characters are available.
      if (__beg == __end)
        __err |= ios_base::eofbit;
      return __beg;
      }

References money_get(), std::__verify_grouping(), std::ios_base::_M_getloc(), std::money_base::_S_atoms, std::money_base::_S_zero, std::basic_string< _CharT, _Traits, _Alloc >::begin(), std::basic_string< _CharT, _Traits, _Alloc >::empty(), std::ios_base::eofbit, std::basic_string< _CharT, _Traits, _Alloc >::erase(), std::ios_base::failbit, std::money_base::pattern::field, std::basic_string< _CharT, _Traits, _Alloc >::find_first_not_of(), std::ios_base::flags(), std::basic_string< _CharT, _Traits, _Alloc >::insert(), std::__ctype_abstract_base< _CharT >::is(), std::locale::facet::locale, std::money_base::none, std::basic_string< char >::npos, std::basic_string< _CharT, _Traits, _Alloc >::reserve(), std::ios_base::showbase, std::money_base::sign, std::basic_string< _CharT, _Traits, _Alloc >::size(), std::ctype_base::space, std::money_base::space, std::basic_string< _CharT, _Traits, _Alloc >::swap(), std::money_base::symbol, std::use_facet(), and std::money_base::value.

Here is the call graph for this function: