money_manip.cpp

Go to the documentation of this file.

 
#include <iomanip>    // for __rw_smanip
#include <iostream>   // for cout
#include <locale>     // for money_get, money_put
 
#include <examples.h>
 
 
// implementation class of the extraction manipulator for monetary values
template <class moneyT>
struct money_get_manip
{
    moneyT *pval_;
 
    explicit money_get_manip (moneyT *pval)
        : pval_ (pval) { }
 
    template <class charT, class Traits>
    void
    operator() (std::basic_ios<charT, Traits> &strm, bool intl) const {
        typedef std::istreambuf_iterator<charT> Iter;
        typedef std::money_get<charT, Iter>     MoneyGet;
 
        std::ios_base::iostate err = std::ios_base::goodbit;
        const MoneyGet &mg = std::use_facet<MoneyGet>(strm.getloc ());
 
        // extract the monetary value from the stream
        mg.get (Iter (strm.rdbuf ()), Iter (), intl, strm, err, *pval_);
 
        if (std::ios_base::goodbit != err)
            strm.setstate (err);
    }
};
 
 
// implementation class of the insertion manipulator for monetary values
template <class moneyT>
struct money_put_manip
{
    const moneyT &val_;
 
    explicit money_put_manip (const moneyT &val)
        : val_ (val) { }
 
    template <class charT, class Traits>
    void
    operator() (std::basic_ios<charT, Traits> &strm, bool intl) const {
        typedef std::ostreambuf_iterator<charT> Iter;
        typedef std::money_put<charT, Iter>     MoneyPut;
 
        const MoneyPut &tp = std::use_facet<MoneyPut>(strm.getloc ());
 
        // insert the monetary value into the stream
        const Iter end =
            tp.put (Iter (strm.rdbuf ()), intl, strm, strm.fill (), val_);
 
        if (end.failed ())
            strm.setstate (std::ios_base::badbit);
    }
};
 
 
// manipulator for the extraction of monetary long double values
inline std::__rw_smanip<money_get_manip<long double>, bool>
get_money (long double *pval, bool intl = false)
{
    // return an object of the manipulator implementation type
    // that will store the function arguments until its function
    // call operator is invoked by the extraction operator for
    // std::__rw_smanip
    typedef money_get_manip<long double>     GetMoney;
    typedef std::__rw_smanip<GetMoney, bool> Manip;
 
    return Manip (GetMoney (pval), intl);
}
 
 
// manipulator for the extraction of monetary strings
template <class charT>
inline std::__rw_smanip<money_get_manip<std::basic_string<charT> >, bool>
get_money (std::basic_string<charT> *pval, bool intl = false)
{
    // return an object of the manipulator implementation type
    // that will store the function arguments until its function
    // call operator is invoked by the extraction operator for
    // std::__rw_smanip
    typedef std::basic_string<charT>         String;
    typedef money_get_manip<String>          GetMoney;
    typedef std::__rw_smanip<GetMoney, bool> Manip;
 
    return Manip (GetMoney (pval), intl);
}
 
 
// manipulator for the insertion of monetary long double values
inline std::__rw_smanip<money_put_manip<long double>, bool>
put_money (const long double &val, bool intl = false)
{
    // return an object of the manipulator implementation type
    // that will store the function arguments until its function
    // call operator is invoked by the insertion operator for
    // std::__rw_smanip
    typedef money_put_manip<long double>     PutMoney;
    typedef std::__rw_smanip<PutMoney, bool> Manip;
 
    return Manip (PutMoney (val), intl);
}
 
 
// manipulator for the insertion of monetary strings
template <class charT>
inline std::__rw_smanip<money_put_manip<std::basic_string<charT> >, bool>
put_money (const std::basic_string<charT> &val, bool intl = false)
{
    // return an object of the manipulator implementation type
    // that will store the function arguments until its function
    // call operator is invoked by the insertion operator for
    // std::__rw_smanip
    typedef std::basic_string<charT>         String;
    typedef money_put_manip<String>          PutMoney;
    typedef std::__rw_smanip<PutMoney, bool> Manip;
 
    return Manip (PutMoney (val), intl);
}
 
 
int main (int argc, char *argv[])
{
    const std::string valstr = argc < 2 ? "0" : argv [1];
 
    // set cin and cout's locale to the one specified in the environment
    std::cin.imbue (std::locale (""));
    std::cout.imbue (std::cin.getloc ());
 
    // output the monetary value specified by the command line argument,
    // including the currency symbol, in both the local and international
    // formats
    std::cout.setf (std::cout.showbase);
    std::cout << put_money (valstr) << '\n';
    std::cout << put_money (valstr, true) << '\n';
 
    long double val = 0.0L;
 
    // input a long double monetary value
    std::cin >> get_money (&val);
 
    // if the input was successful, output the extracted monetary value
    // otherwise, output an error message
    if (std::cin.good ()) {
        std::cout << put_money (val) << '\n';
        std::cout << put_money (val, true) << '\n';
    }
    else {
        std::cerr << "get_money (long double*) failed\n";
        return 1;
    }
 
    return 0;
}