currency.hpp

Go to the documentation of this file.

#ifndef CURRENCY_HPP_
#define CURRENCY_HPP_

#include <iomanip>
#include <istream>
#include <locale>
#include <ostream>
#include <sstream>
#include <string>
#include <stdexcept>

#include "ioflags.hpp"
#include "fixed.hpp"
#include "rational.hpp"

template<class T=long, int N=2>
class currency
{
public:
  typedef T int_type;                    
  typedef fixed<T,N> value_type;         

  constexpr currency() : value_() {}
  constexpr currency(T integer) : value_(integer) {}
  currency(T integer, T fraction) : value_(integer, fraction) {}
  currency(double value) : value_(value) {}

  template<class U, int M>
  currency(currency<U, M> const& rhs): value_(rhs.value()) {}

  template<class U, int M>
  currency& operator=(currency<U, M> rhs)
  {
    value_ = rhs.value();
    return *this;
  }

  std::string as_string() const;
  template<class Char, class Traits>
  bool read(std::basic_istream<Char, Traits>& strm);

  template<class U>
  U convert() const { return value().template convert<U>(); }

  int_type round() const { return value().round(); }

  int_type integer()  const { return value().integer(); }
  template<int M>
  int_type fraction() const { return value().template fraction<M>(); }
  int_type fraction() const { return value().fraction(); }

  currency& operator+=(currency c);
  currency& operator-=(currency c);
  currency& operator*=(value_type m);
  currency& operator*=(int_type m);
  currency& operator/=(value_type m);
  currency& operator/=(int_type m);

  void negate();

  currency& operator++();
  currency operator++(int);
  currency& operator--();
  currency operator--(int);

  value_type value()    const { return value_; }

private:
  value_type value_;
};

template<class T, int N>
std::string currency<T,N>::as_string()
const
{
  std::ostringstream digits;
  digits.imbue(std::locale::classic());
  digits << integer() << std::setw(value_type::places) << std::setfill('0') << fraction();

  std::ostringstream out;
  std::money_put<char> const& put(std::use_facet<std::money_put<char> >(std::locale()));
  put.put(std::ostreambuf_iterator<char>(out), false, out, '0', digits.str());
  return out.str();
}

template<class T, int N>
currency<T,N>& currency<T,N>::operator+=(currency f)
{
  value_ += f.value();
  return *this;
}

template<class T, int N>
currency<T,N>& currency<T,N>::operator-=(currency f)
{
  value_ -= f.value();
  return *this;
}

template<class T, int N>
currency<T,N>& currency<T,N>::operator*=(value_type i)
{
  value_ *= i;
  return *this;
}
template<class T, int N>
currency<T,N>& currency<T,N>::operator*=(int_type i)
{
  value_ *= i;
  return *this;
}

template<class T, int N>
currency<T,N>& currency<T,N>::operator/=(value_type i)
{
  value_ /= i;
  return *this;
}
template<class T, int N>
currency<T,N>& currency<T,N>::operator/=(int_type i)
{
  value_ /= i;
  return *this;
}

template<class T, int N>
void currency<T,N>::negate()
{
  value_ = -value_;
}

template<class T, int N>
currency<T,N>& currency<T,N>::operator++()
{
  ++value_;
  return *this;
}

template<class T, int N>
currency<T,N> currency<T,N>::operator++(int)
{
  currency result(*this);
  ++value_;
  return result;
}

template<class T, int N>
currency<T,N>& currency<T,N>::operator--()
{
  --value_;
  return *this;
}

template<class T, int N>
currency<T,N> currency<T,N>::operator--(int)
{
  currency result(*this);
  --value_;
  return result;
}

template<class T, int N>
template<class CharT, class Traits>
bool currency<T,N>::read(std::basic_istream<CharT,Traits>& strm)
{
  ioflags flags(strm);
  typename std::basic_istream<CharT, Traits>::sentry sentry(strm, false);
  if (not sentry)
    return false;

  std::ios_base::iostate error(std::ios_base::goodbit);
  std::string digits;
  std::money_get<CharT> const& get(
      std::use_facet<std::money_get<CharT> >(strm.getloc()));
  get.get(std::istreambuf_iterator<CharT>(strm), std::istreambuf_iterator<CharT>(),
          false, strm, error, digits);

  if ((error & std::ios_base::failbit) != 0)
    return false;

  std::moneypunct<CharT> const& punct(
      std::use_facet<std::moneypunct<CharT> >(strm.getloc()));

  // Set fraction to the rightmost frac_digits() characters of digits.
  std::string fraction(digits.substr(digits.size() - punct.frac_digits(), punct.frac_digits()));
  // Set integer to the remainder of digits.
  std::string integer(digits.substr(0, digits.size() - punct.frac_digits()));

  std::istringstream fixed_stream(integer + "." + fraction);
  return value_.read(fixed_stream);
}

template<class T, int N, class Char, class Traits>
std::basic_istream<Char, Traits>& operator>>(std::basic_istream<Char, Traits>& strm, currency<T,N>& c)
{
  if (not c.read(strm))
    strm.setstate(strm.failbit);
  return strm;
}

template<class T, int N, class Char, class Traits>
std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& strm, currency<T,N> c)
{
  typename std::basic_ostream<Char, Traits>::sentry sentry(strm);
  strm << c.as_string();
  return strm;
}

template<class T, int N>
currency<T,N> operator-(currency<T,N> a)
{
  a.negate();
  return a;
}

template<class T, int N>
currency<T,N> operator+(currency<T,N> a, currency<T,N> b)
{
  a += b;
  return a;
}

template<class T, int N>
currency<T,N> operator-(currency<T,N> a, currency<T,N> b)
{
  a -= b;
  return a;
}

template<class T, int N>
currency<T,N> operator*(currency<T,N> a, T b)
{
  a *= b;
  return a;
}

template<class T, int N>
currency<T,N> operator*(T a, currency<T,N> b)
{
  b *= a;
  return b;
}

template<class T, int N>
currency<T,N> operator/(currency<T,N> a, T b)
{
  a /= b;
  return a;
}

template<class T, int N>
rational<T> operator/(currency<T,N> n, currency<T,N> d)
{
  // Extract the underlying value of the fixed values. No adjustment
  // to scaling is needed because the numerator and denominator are
  // both scaled to the same amount.
  return rational<T>(n.value().value(), d.value().value());
}

template<class T, int N>
bool operator==(currency<T,N> a, currency<T,N> b)
{
  return a.value() == b.value();
}
template<class T, int N>
bool operator==(currency<T,N> a, T b)
{
  return a.value() == b;
}
template<class T, int N>
bool operator==(T a, currency<T,N> b)
{
  return a == b.value();
}

template<class T, int N>
inline bool operator!=(currency<T,N> a, currency<T,N> b)
{
  return not (a == b);
}
template<class T, int N>
inline bool operator!=(currency<T,N> a, T b)
{
  return not (a == b);
}
template<class T, int N>
inline bool operator!=(T a, currency<T,N> b)
{
  return not (a == b);
}

template<class T, int N>
bool operator<(currency<T,N> a, currency<T,N> b)
{
  return a.value() < b.value();
}
template<class T, int N>
bool operator<(currency<T,N> a, T b)
{
  return a.value() < b;
}
template<class T, int N>
bool operator<(T a, currency<T,N> b)
{
  return a < b.value();
}

template<class T, int N>
inline bool operator>(currency<T,N> a, currency<T,N> b)
{
  return b < a;
}
template<class T, int N>
inline bool operator>(currency<T,N> a, T b)
{
  return b < a;
}
template<class T, int N>
inline bool operator>(T a, currency<T,N> b)
{
  return b < a;
}

template<class T, int N>
inline bool operator<=(currency<T,N> a, currency<T,N> b)
{
  return not (b < a);
}
template<class T, int N>
inline bool operator<=(currency<T,N> a, T b)
{
  return not (b < a);
}
template<class T, int N>
inline bool operator<=(T a, currency<T,N> b)
{
  return not (b < a);
}

template<class T, int N>
inline bool operator>=(currency<T,N> a, currency<T,N> b)
{
  return not (a < b);
}
template<class T, int N>
inline bool operator>=(currency<T,N> a, T b)
{
  return not (a < b);
}
template<class T, int N>
inline bool operator>=(T a, currency<T,N> b)
{
  return not (a < b);
}

#endif