718 lines
21 KiB
C++
718 lines
21 KiB
C++
#ifndef __MONEY_CC
|
||
#define __MONEY_CC
|
||
#pragma option push -b -a8 -pc -Vx- -Ve- -w-inl -w-aus -w-sig
|
||
/***************************************************************************
|
||
*
|
||
* money.cc - Definitions for the Standard Library money facets
|
||
*
|
||
***************************************************************************
|
||
*
|
||
* Copyright (c) 1994-1999 Rogue Wave Software, Inc. All Rights Reserved.
|
||
*
|
||
* This computer software is owned by Rogue Wave Software, Inc. and is
|
||
* protected by U.S. copyright laws and other laws and by international
|
||
* treaties. This computer software is furnished by Rogue Wave Software,
|
||
* Inc. pursuant to a written license agreement and may be used, copied,
|
||
* transmitted, and stored only in accordance with the terms of such
|
||
* license and with the inclusion of the above copyright notice. This
|
||
* computer software or any other copies thereof may not be provided or
|
||
* otherwise made available to any other person.
|
||
*
|
||
* U.S. Government Restricted Rights. This computer software is provided
|
||
* with Restricted Rights. Use, duplication, or disclosure by the
|
||
* Government is subject to restrictions as set forth in subparagraph (c)
|
||
* (1) (ii) of The Rights in Technical Data and Computer Software clause
|
||
* at DFARS 252.227-7013 or subparagraphs (c) (1) and (2) of the
|
||
* Commercial Computer Software – Restricted Rights at 48 CFR 52.227-19,
|
||
* as applicable. Manufacturer is Rogue Wave Software, Inc., 5500
|
||
* Flatiron Parkway, Boulder, Colorado 80301 USA.
|
||
*
|
||
**************************************************************************/
|
||
|
||
#ifndef _RWSTD_NO_NAMESPACE
|
||
namespace __rwstd {
|
||
#endif
|
||
|
||
// -------------------------------------------------
|
||
// Template moneypunct_data<charT> member templates.
|
||
// -------------------------------------------------
|
||
|
||
template <class charT>
|
||
moneypunct_data<charT>::moneypunct_data
|
||
(moneypunct_init<charT> *init)
|
||
{
|
||
if (!init) {
|
||
this->dp_=charT('.');
|
||
this->ts_=charT(',');
|
||
fd_=0;
|
||
} else {
|
||
this->dp_=init->dp_;
|
||
this->ts_=init->ts_;
|
||
this->gr_=init->gr_;
|
||
cs_=init->cs_;
|
||
ps_=init->ps_;
|
||
ns_=init->ns_;
|
||
fd_=init->fd_;
|
||
pf_=init->pf_;
|
||
nf_=init->nf_;
|
||
|
||
if (init->del_)
|
||
delete[] (char*) init;
|
||
}
|
||
}
|
||
|
||
template <class charT>
|
||
void moneypunct_data<charT>::__initfacetbase (const locale*) { }
|
||
|
||
template <class charT>
|
||
moneypunct_init<charT>*
|
||
_RWSTDExportTemplate fixup_moneypunct_init
|
||
(moneypunct_init<char> *init,charT*)
|
||
{
|
||
moneypunct_init<charT> *result = NULL;
|
||
#if !defined (_RWSTD_NO_NAMESPACE) && !defined (_RWSTD_NO_NEW_HEADER)
|
||
using std::mbstate_t;
|
||
#endif
|
||
|
||
if (init) {
|
||
const _RW_STD::codecvt<charT,char,mbstate_t> &cvt =
|
||
#ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
|
||
_RW_STD::use_facet<_RW_STD::codecvt<charT,char,mbstate_t> >(_RW_STD::locale::classic());
|
||
#else
|
||
_RW_STD::use_facet(_RW_STD::locale::classic(),(_RW_STD::codecvt<charT,char,mbstate_t>*)0);
|
||
#endif
|
||
|
||
typedef _RW_STD::basic_string<charT,_RW_STD::char_traits<charT>,_RW_STD::allocator<charT> > s_type;
|
||
s_type cs_=cvt.in(init->cs_);
|
||
s_type ps_=cvt.in(init->ps_);
|
||
s_type ns_=cvt.in(init->ns_);
|
||
|
||
size_t extra_chars = _RW_STD::char_traits<char>::length(init->gr_);
|
||
|
||
size_t extra_charTs = cs_.length()+ps_.length()+ns_.length()+3;
|
||
|
||
result=(moneypunct_init<charT>*)
|
||
new char[sizeof(*result)+extra_chars+extra_charTs*sizeof(charT)];
|
||
|
||
result->del_=true;
|
||
result->dp_=charT(init->dp_);
|
||
result->ts_=charT(init->ts_);
|
||
result->fd_=init->fd_;
|
||
result->pf_=init->pf_;
|
||
result->nf_=init->nf_;
|
||
|
||
size_t n;
|
||
charT *p=(charT*) (result+1);
|
||
result->cs_=_RW_STD::char_traits<charT>::copy(p,cs_.c_str(),n=cs_.length());
|
||
*(p+=n)++=0;
|
||
result->ps_=_RW_STD::char_traits<charT>::copy(p,ps_.c_str(),n=ps_.length());
|
||
*(p+=n)++=0;
|
||
result->ns_=_RW_STD::char_traits<charT>::copy(p,ns_.c_str(),n=ns_.length());
|
||
*(p+=n)++=0;
|
||
|
||
result->gr_= _RW_STD::char_traits<char>::copy((char*)(p+n),init->gr_,
|
||
_RW_STD::char_traits<char>::length(init->gr_));
|
||
}
|
||
|
||
if (init->del_)
|
||
delete[] (char*) init;
|
||
|
||
return result;
|
||
}
|
||
|
||
template <class charT>
|
||
moneypunct_init<charT>*
|
||
moneypunct_data<charT>::get_init_by_name_
|
||
(const char *name,bool intl)
|
||
{
|
||
return fixup_moneypunct_init (__get_named_init(name,intl),(charT*)0);
|
||
}
|
||
|
||
// ------------------------------------------------------------
|
||
// Template class money_handler_base_1<charT> member templates.
|
||
// ------------------------------------------------------------
|
||
|
||
template <class charT>
|
||
const moneypunct_data<charT>&
|
||
money_handler_base_1<charT>::get_punct_data
|
||
(const _RW_STD::locale &loc,bool intl)
|
||
{
|
||
#ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
|
||
if (intl)
|
||
return _RW_STD::use_facet<_RW_STD::moneypunct<charT,true> >(loc);
|
||
else
|
||
return _RW_STD::use_facet<_RW_STD::moneypunct<charT,false> >(loc);
|
||
#else
|
||
if (intl) // casts required for some compilers
|
||
#if defined(__TURBOC__) && (__TURBOC__ > 0x540)
|
||
return moneypunct_data<charT>( _RW_STD::use_facet(loc,(_RW_STD::moneypunct<charT,true>*)0));
|
||
#else
|
||
return _RW_STD::use_facet(loc,(_RW_STD::moneypunct<charT,true>*)0);
|
||
#endif
|
||
else
|
||
#if defined(__TURBOC__) && (__TURBOC__ > 0x540)
|
||
return moneypunct_data<charT>(_RW_STD::use_facet(loc,(_RW_STD::moneypunct<charT,false>*)0));
|
||
#else
|
||
return _RW_STD::use_facet(loc,(_RW_STD::moneypunct<charT,false>*)0);
|
||
#endif
|
||
#endif
|
||
}
|
||
|
||
// -----------------------------------------------------------
|
||
// Template class money_reader_base_1<charT> member templates.
|
||
// -----------------------------------------------------------
|
||
|
||
template <class charT>
|
||
money_reader_base_1<charT>::
|
||
money_reader_base_1 (digit_reader_base_1<charT> &r,
|
||
const moneypunct_data<charT> &mp)
|
||
: money_handler_base_1<charT>(mp), reader(r)
|
||
{ }
|
||
|
||
template <class charT>
|
||
void money_reader_base_1<charT>::get_money_string
|
||
(string_type &result,const char *eod)
|
||
{
|
||
int len=eod-reader.digits;
|
||
if (reader.negative)
|
||
len++;
|
||
|
||
result.resize(0);
|
||
result.reserve(len);
|
||
|
||
if (reader.negative)
|
||
result+=reader.dmap.punct_chars[digit_map_base::minus];
|
||
|
||
const char *d=reader.digits;
|
||
const char *end=eod-1;
|
||
while (d<end && *d==0) d++;
|
||
for ( ; d<=end; d++)
|
||
result+=reader.dmap.digit_chars[*d];
|
||
}
|
||
|
||
// -------------------------------------------------------------------------
|
||
// Template class money_reader_base_2<charT,InputIterator> member templates.
|
||
// -------------------------------------------------------------------------
|
||
|
||
template <class charT,class InputIterator>
|
||
money_reader_base_2<charT,InputIterator>::
|
||
money_reader_base_2 (InputIterator &i,InputIterator &e,
|
||
_RW_STD::ios_base &b,const moneypunct_data<charT> &mp)
|
||
: digit_reader<charT,InputIterator>(i,e,b,mp),
|
||
money_reader_base_1<charT>(this_as_digit_reader(),mp)
|
||
{
|
||
this->radix=10;
|
||
this->is_signed=false;
|
||
}
|
||
|
||
template <class charT,class InputIterator>
|
||
char* money_reader_base_2<charT,InputIterator>::
|
||
get_money_digits (void)
|
||
{
|
||
charT c;
|
||
// Always parse input according to negative format.
|
||
const _RW_STD::money_base::pattern &patt=this->get_neg_format();
|
||
|
||
// If this ends up non-NULL, it points to trailing sign char(s) that are
|
||
// required at the end of the pattern.
|
||
const charT *sign=NULL;
|
||
|
||
bool need_curr=(this->io.flags()&_RW_STD::ios_base::showbase)? true : false;
|
||
bool got_curr=false;
|
||
int fracs=this->get_frac_digits();
|
||
|
||
char *eod=this->digits;
|
||
const char *p=patt.field,*pend=p+sizeof patt.field-1;
|
||
|
||
for ( ; !this->error && p<=pend; p++) {
|
||
switch (*p) {
|
||
case _RW_STD::money_base::space:
|
||
case _RW_STD::money_base::none:
|
||
while (!this->at_end() && this->ctyp.is(_RW_STD::ctype_base::space,*this->in))
|
||
this->in++;
|
||
break;
|
||
|
||
case _RW_STD::money_base::symbol:
|
||
if (!this->at_end()) {
|
||
const charT *curr=this->get_curr_symbol().c_str();
|
||
if ((c=*this->in)==*curr) {
|
||
// We ate a character, so rest of symbol must be present.
|
||
need_curr=true;
|
||
do {
|
||
this->in++;
|
||
if (*++curr==charT('\0')) {
|
||
got_curr=true;
|
||
break;
|
||
}
|
||
} while (!this->at_end() && (c=*this->in)==*curr);
|
||
}
|
||
}
|
||
if (need_curr && !got_curr)
|
||
this->error|=this->bad_curr_symbol;
|
||
break;
|
||
|
||
case _RW_STD::money_base::sign:
|
||
if (!this->at_end()) {
|
||
sign=this->get_negative_sign().c_str();
|
||
if ((c=*this->in)==*sign) {
|
||
this->negative=true;
|
||
sign++;
|
||
this->in++;
|
||
} else {
|
||
sign=this->get_positive_sign().c_str();
|
||
if (c==*sign) {
|
||
sign++;
|
||
this->in++;
|
||
} else
|
||
sign=NULL;
|
||
}
|
||
}
|
||
break;
|
||
|
||
case _RW_STD::money_base::value:
|
||
eod=this->get_int_digits();
|
||
if (!this->error && fracs && !this->at_end() &&
|
||
*this->in==this->get_decimal_point())
|
||
{
|
||
this->in++;
|
||
char *frac_start=eod;
|
||
eod=this->get_digit_string(eod);
|
||
if (!this->error) {
|
||
fracs-=(eod-frac_start);
|
||
if (fracs<0) {
|
||
// Too many fractional digits in input. We truncate. The
|
||
// alternative would be to return an error.
|
||
eod+=fracs;
|
||
fracs=0;
|
||
}
|
||
}
|
||
}
|
||
if (eod==this->digits)
|
||
this->error|=this->no_digits;
|
||
else if (!this->error && fracs>0) {
|
||
// Add trailing zeros until the correct number of fractional digits
|
||
// is reached.
|
||
if (this->digits+sizeof this->digits-eod < fracs)
|
||
this->error|=this->too_many_digits;
|
||
else {
|
||
do *eod++=0;
|
||
while (--fracs);
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (sign && !this->error)
|
||
// We ate one charT of a sign earlier, rest of sign must be present at end.
|
||
while (*sign)
|
||
if (!this->at_end() && *this->in==*sign++)
|
||
this->in++;
|
||
else {
|
||
this->error|=this->bad_sign;
|
||
break;
|
||
}
|
||
|
||
this->frac_beg=this->exp_beg=eod;
|
||
return eod;
|
||
}
|
||
|
||
// ------------------------------------------------------------
|
||
// Template money_reader<charT,InputIterator> member templates.
|
||
// ------------------------------------------------------------
|
||
|
||
template <class charT,class InputIterator>
|
||
money_reader<charT,InputIterator>::
|
||
money_reader (InputIterator &i,InputIterator &e,
|
||
_RW_STD::ios_base &b,bool intl):
|
||
money_reader_base_2<charT,InputIterator>
|
||
(i,e,b,money_handler_base_1<charT>::
|
||
get_punct_data(b.getloc(),intl))
|
||
{ }
|
||
|
||
// -----------------------------------------------------
|
||
// Template money_writer_base_1<charT> member templates.
|
||
// -----------------------------------------------------
|
||
|
||
template <class charT>
|
||
money_writer_base_1<charT>::money_writer_base_1
|
||
(digit_writer_base_1<charT> &w,
|
||
const moneypunct_data<charT> &mp)
|
||
: money_handler_base_1<charT>(mp), writer(w)
|
||
{ }
|
||
|
||
template <class charT>
|
||
void money_writer_base_1<charT>::put_money (charT fill)
|
||
{
|
||
bool negative;
|
||
if (*writer.start=='-') {
|
||
negative=true;
|
||
writer.start++;
|
||
} else {
|
||
negative=false;
|
||
if (*writer.start=='+' || *writer.start==' ')
|
||
writer.start++;
|
||
}
|
||
|
||
charT wide_digits[sizeof writer.buffer];
|
||
writer.ctyp.widen(writer.start,writer.end,wide_digits);
|
||
put_money_sub(wide_digits,wide_digits+(writer.end-writer.start),
|
||
negative,fill);
|
||
}
|
||
|
||
template <class charT>
|
||
void money_writer_base_1<charT>::put_money
|
||
(const string_type& digits,charT fill)
|
||
{
|
||
const charT *punct =
|
||
digit_map<charT>::get_digit_map(writer.ctyp)
|
||
.get_punct();
|
||
|
||
const charT *start=digits.c_str();
|
||
bool negative;
|
||
if (*start==punct[digit_map_base::minus]) {
|
||
negative=true;
|
||
start++;
|
||
} else
|
||
negative=false;
|
||
|
||
const charT *end=writer.ctyp.scan_not(_RW_STD::ctype_base::digit,start,
|
||
digits.c_str()+digits.length());
|
||
|
||
put_money_sub(start,end,negative,fill);
|
||
}
|
||
|
||
// --------------------------------------------------------------------
|
||
// Template money_writer_base_2<charT,OutputIterator> member templates.
|
||
// --------------------------------------------------------------------
|
||
|
||
template <class charT,class OutputIterator>
|
||
money_writer_base_2<charT,OutputIterator>::money_writer_base_2
|
||
(OutputIterator &os,_RW_STD::ios_base &io,
|
||
const moneypunct_data<charT> &mp)
|
||
: digit_writer<charT,OutputIterator> (os,io,mp),
|
||
money_writer_base_1<charT> (this_as_digit_writer(),mp)
|
||
{ }
|
||
|
||
template <class charT, class OutputIterator>
|
||
void money_writer_base_2<charT,OutputIterator>::put_money_sub
|
||
(const charT *start,const charT *end,bool negative,charT fill)
|
||
{
|
||
const _RW_STD::money_base::pattern *patt;
|
||
const string_type *sign;
|
||
if (negative) {
|
||
patt=&this->get_neg_format();
|
||
sign=&this->get_negative_sign();
|
||
} else {
|
||
patt=&this->get_pos_format();
|
||
sign=&this->get_positive_sign();
|
||
}
|
||
|
||
int frac_digits=this->get_frac_digits();
|
||
int int_digits=end-start-frac_digits;
|
||
int unGrouped,zero_pad;
|
||
|
||
if (int_digits<0) {
|
||
zero_pad=-int_digits;
|
||
int_digits=0;
|
||
} else
|
||
zero_pad=0;
|
||
|
||
charT sep;
|
||
if (int_digits>0) {
|
||
unGrouped=calc_groups(int_digits,this->get_grouping());
|
||
if (this->num_groups)
|
||
sep=this->get_thousands_sep();
|
||
} else
|
||
unGrouped=0;
|
||
|
||
const char *p,*pend=patt->field+sizeof patt->field;
|
||
int leftFill=0,internalFill=0,rightFill=0;
|
||
|
||
if (this->width) {
|
||
int n=0;
|
||
for (p=patt->field; p<pend; p++) {
|
||
switch (*p) {
|
||
case _RW_STD::money_base::space:
|
||
n++;
|
||
break;
|
||
case _RW_STD::money_base::symbol:
|
||
if (this->flags& _RW_STD::ios_base::showbase)
|
||
n+=this->get_curr_symbol().length();
|
||
break;
|
||
case _RW_STD::money_base::sign:
|
||
n+=sign->length();
|
||
break;
|
||
case _RW_STD::money_base::value:
|
||
n+=int_digits+this->num_groups;
|
||
if (frac_digits)
|
||
n+=frac_digits+1;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if ((n-=this->width)>0) {
|
||
switch (this->adjust) {
|
||
case digit_writer_base::left:
|
||
rightFill=n;
|
||
break;
|
||
case digit_writer_base::internal:
|
||
internalFill=n;
|
||
break;
|
||
default:
|
||
leftFill=n;
|
||
}
|
||
}
|
||
|
||
this->width=0;
|
||
}
|
||
|
||
if (leftFill)
|
||
do *this->out++=fill;
|
||
while (--leftFill);
|
||
|
||
const charT *schar=sign->c_str();
|
||
for (p=patt->field; p<pend; p++)
|
||
switch (*p) {
|
||
case _RW_STD::money_base::symbol:
|
||
if (this->flags& _RW_STD::ios_base::showbase)
|
||
put_keyword(this->get_curr_symbol(),fill);
|
||
break;
|
||
case _RW_STD::money_base::sign:
|
||
if (*schar)
|
||
*this->out++=*schar++;
|
||
break;
|
||
case _RW_STD::money_base::value:
|
||
while (unGrouped--)
|
||
*this->out++=*start++;
|
||
while (this->num_groups--) {
|
||
*this->out++=sep;
|
||
while ((*this->group)--)
|
||
*this->out++=*start++;
|
||
this->group++;
|
||
}
|
||
if (frac_digits) {
|
||
*this->out++=this->get_decimal_point();
|
||
while (zero_pad--) {
|
||
frac_digits--;
|
||
*this->out++=this->ctyp.widen('0');
|
||
}
|
||
while (frac_digits-->0)
|
||
*this->out++=*start++;
|
||
}
|
||
break;
|
||
case _RW_STD::money_base::space:
|
||
if (!internalFill) {
|
||
*this->out++=this->ctyp.widen(' ');
|
||
break;
|
||
}
|
||
// Fall through ...
|
||
case _RW_STD::money_base::none:
|
||
if (internalFill)
|
||
do *this->out++=fill;
|
||
while (--internalFill);
|
||
break;
|
||
}
|
||
|
||
while (*schar)
|
||
*this->out++=*schar++;
|
||
|
||
if (rightFill+=internalFill) {
|
||
do *this->out++=fill;
|
||
while (--rightFill);
|
||
}
|
||
}
|
||
|
||
// -------------------------------------------------------------
|
||
// Template money_writer<charT,OutputIterator> member templates.
|
||
// -------------------------------------------------------------
|
||
|
||
template <class charT,class OutputIterator>
|
||
money_writer<charT,OutputIterator>::money_writer
|
||
(OutputIterator &os,_RW_STD::ios_base &io,bool intl)
|
||
: money_writer_base_2<charT,OutputIterator>
|
||
(os,io,money_handler_base_1<charT>::
|
||
get_punct_data(io.getloc(),intl))
|
||
{ }
|
||
#ifndef _RWSTD_NO_NAMESPACE
|
||
} namespace std {
|
||
#endif
|
||
|
||
// ------------------------------------------------------
|
||
// Facet money_get<charT,InputIterator> member templates.
|
||
// ------------------------------------------------------
|
||
|
||
template <class charT, class InputIterator>
|
||
locale::id money_get<charT,InputIterator>::id;
|
||
|
||
template <class charT, class InputIterator>
|
||
money_get<charT,InputIterator>::~money_get() { }
|
||
|
||
// Warning -- these functions do not input actual monetary value; they just
|
||
// input numbers that represent monetary value.
|
||
|
||
template <class charT, class InputIterator>
|
||
InputIterator money_get<charT,InputIterator>::do_get
|
||
(InputIterator in, InputIterator end, bool intl, ios_base& io,
|
||
ios_base::iostate& err, long double& units) const
|
||
{
|
||
__RWSTD::money_reader<charT,InputIterator> reader(in,end,io,intl);
|
||
long double v=reader.to_long_double(reader.get_money_digits());
|
||
err=ios_base::goodbit;
|
||
|
||
if (reader.error)
|
||
err=ios_base::failbit;
|
||
else
|
||
units=v;
|
||
|
||
if (reader.reached_end)
|
||
err|=ios_base::eofbit;
|
||
|
||
return in;
|
||
}
|
||
|
||
template <class charT, class InputIterator>
|
||
InputIterator money_get<charT,InputIterator>::do_get
|
||
(InputIterator in, InputIterator end, bool intl, ios_base &io,
|
||
ios_base::iostate &err, string_type &digit_string) const
|
||
{
|
||
__RWSTD::money_reader<charT,InputIterator> reader(in,end,io,intl);
|
||
const char *eod=reader.get_money_digits();
|
||
err=ios_base::goodbit;
|
||
|
||
if (reader.error)
|
||
err=ios_base::failbit;
|
||
else
|
||
reader.get_money_string(digit_string,eod);
|
||
|
||
if (reader.reached_end)
|
||
err|=ios_base::eofbit;
|
||
|
||
return in;
|
||
}
|
||
|
||
// -------------------------------------------------------
|
||
// Facet money_put<charT,OutputIterator> member templates.
|
||
// -------------------------------------------------------
|
||
|
||
template <class charT, class OutputIterator>
|
||
locale::id money_put<charT,OutputIterator>::id;
|
||
|
||
template <class charT, class OutputIterator>
|
||
money_put<charT,OutputIterator>::~money_put() { }
|
||
|
||
template <class charT, class OutputIterator>
|
||
OutputIterator money_put<charT,OutputIterator>::do_put
|
||
(OutputIterator out, bool intl, ios_base& io, charT fill,
|
||
#ifndef _RWSTD_NO_LONG_DOUBLE
|
||
long double quant) const
|
||
#else
|
||
double quant) const
|
||
#endif
|
||
|
||
{
|
||
__RWSTD::money_writer<charT,OutputIterator> writer(out,io,intl);
|
||
writer.digitize(quant);
|
||
writer.put_money(fill);
|
||
return out;
|
||
}
|
||
|
||
template <class charT, class OutputIterator>
|
||
OutputIterator money_put<charT,OutputIterator>::do_put
|
||
(OutputIterator out, bool intl, ios_base& io, charT fill,
|
||
const string_type& digits) const
|
||
{
|
||
__RWSTD::money_writer<charT,OutputIterator> writer(out,io,intl);
|
||
writer.put_money(digits,fill);
|
||
return out;
|
||
}
|
||
|
||
// ----------------------------------------------
|
||
// Facet moneypunct<charT,Intl> member templates.
|
||
// ----------------------------------------------
|
||
|
||
template <class charT, bool Intl>
|
||
locale::id moneypunct<charT,Intl>::id;
|
||
|
||
#ifndef _RWSTD_NO_STI_SIMPLE
|
||
template <class charT, bool Intl>
|
||
const bool moneypunct<charT,Intl>::intl;
|
||
#endif
|
||
|
||
template <class charT, bool Intl>
|
||
moneypunct<charT,Intl>::~moneypunct () { }
|
||
|
||
template <class charT, bool Intl>
|
||
charT moneypunct<charT,Intl>::do_decimal_point () const
|
||
{ return this->dp_; }
|
||
|
||
template <class charT, bool Intl>
|
||
charT moneypunct<charT,Intl>::do_thousands_sep () const
|
||
{ return this->ts_; }
|
||
|
||
template <class charT, bool Intl>
|
||
string moneypunct<charT,Intl>::do_grouping () const
|
||
{ return this->gr_; }
|
||
|
||
template <class charT, bool Intl>
|
||
_TYPENAME moneypunct<charT,Intl>::string_type
|
||
moneypunct<charT,Intl>::do_curr_symbol () const
|
||
{ return this->cs_; }
|
||
|
||
template <class charT, bool Intl>
|
||
_TYPENAME moneypunct<charT,Intl>::string_type
|
||
moneypunct<charT,Intl>::do_positive_sign () const
|
||
{ return this->ps_; }
|
||
|
||
template <class charT, bool Intl>
|
||
_TYPENAME moneypunct<charT,Intl>::string_type
|
||
moneypunct<charT,Intl>::do_negative_sign () const
|
||
{ return this->ns_; }
|
||
|
||
template <class charT, bool Intl>
|
||
int moneypunct<charT,Intl>::do_frac_digits () const
|
||
{ return this->fd_; }
|
||
|
||
template <class charT, bool Intl>
|
||
money_base::pattern
|
||
moneypunct<charT,Intl>::do_pos_format () const
|
||
{ return this->pf_; }
|
||
|
||
template <class charT, bool Intl>
|
||
money_base::pattern
|
||
moneypunct<charT,Intl>::do_neg_format () const
|
||
{ return this->nf_; }
|
||
|
||
template <class charT, bool Intl>
|
||
void moneypunct<charT,Intl>::__initfacet (const locale* loc) {
|
||
this->dp_=do_decimal_point();
|
||
this->ts_=do_thousands_sep();
|
||
this->gr_=do_grouping();
|
||
this->cs_=do_curr_symbol();
|
||
this->ps_=do_positive_sign();
|
||
this->ns_=do_negative_sign();
|
||
this->fd_=do_frac_digits();
|
||
this->pf_=do_pos_format();
|
||
this->nf_=do_neg_format();
|
||
this->__initfacetbase(loc);
|
||
}
|
||
|
||
// --------------------------------------------------------------------------
|
||
// Money punctuation by-name member templates: moneypunct_byname<charT,Intl>
|
||
// --------------------------------------------------------------------------
|
||
|
||
template <class charT, bool Intl>
|
||
moneypunct_byname<charT,Intl>::moneypunct_byname (const char *n,size_t refs):
|
||
moneypunct<charT,Intl>(refs,get_init_by_name_(n,moneypunct<charT,Intl>::intl))
|
||
{ }
|
||
|
||
template <class charT, bool Intl>
|
||
moneypunct_byname<charT,Intl>::~moneypunct_byname()
|
||
{ }
|
||
#ifndef _RWSTD_NO_NAMESPACE
|
||
}
|
||
#endif
|
||
|
||
#pragma option pop
|
||
#endif /* __MONEY_CC */
|