money.h

Go to the documentation of this file.

// OSB library ********************************************* -*- C++ -*-
/*
  AUTHOR(S): Vipul Gupta (vg)
             Stephan Broennimann (vb)

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.46 $

  License
   OSB rating and billing library for communication networks
   Copyright (C) 2004, 2005, 2006  OSB systems

   This file may be distributed and/or modify under the terms of the
   GNU General Public License (GPL) as published by the Free Software
   Foundation which is provided in the file LICENSE.GPL included in the
   packaging of this file.

   The file is distributed in the hope that it will be useful, but WITHOUT
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   for more details.

   Holders of a OSB Commercial License may use this file under the terms
   and conditions of this commercial license.
 */
#ifndef _MONEY_H_
#define _MONEY_H_

// *********************************************************************
// included header files
// + standard includes
#include <string>
#include <utility>
#include <map>
#include <iosfwd>

// + local headers
#include "decimal.h"
#include "osbid.h"

// *********************************************************************
// class declarations
namespace OSB_DB {
    class CurrencyBookGw;
    class Session;
}

// *********************************************************************
// namespace extensions
namespace OSB_LIB {

// *********************************************************************
// type definitions

    class Currency
    {
        friend class OSB_DB::CurrencyBookGw;
    public:
        typedef std::string Oid;
    public:
        explicit Currency(const Oid& oid = Oid());



        Oid oid() const { return oid_; }
        std::string baseName() const { return baseName_; }
        std::string fractionName() const { return fractionName_; }
        std::string baseSymbol() const { return baseSymbol_; }
        std::string fractionSymbol() const { return fractionSymbol_; }

        bool match(const Oid& oid) const { return oid_ == oid; }

    private:
        Oid oid_;
        std::string baseName_;
        std::string baseSymbol_;
        std::string fractionName_;
        std::string fractionSymbol_;
    };                                  // class Currency

    std::ostream& operator<<(std::ostream& os, const Currency& c);

    class CurrencyBook {
    public:
        typedef std::map<Currency::Oid, Currency> CurrencyList;
    public:
        CurrencyBook() {}



        typedef CurrencyList::iterator Iterator;
        typedef CurrencyList::const_iterator ConstIterator;
        typedef CurrencyList::size_type SizeType;


        Iterator begin() { return currencyList_.begin(); }
        Iterator end() { return currencyList_.end(); }
        ConstIterator begin() const { return currencyList_.begin(); }
        ConstIterator end() const { return currencyList_.end(); }
        SizeType size() const { return currencyList_.size(); }

        long read(const OSB_DB::Session& session);
        void add(const Currency& currency, bool isBase = false);
        void print(std::ostream& os);
        const Currency* findCurrency(const Currency::Oid& oid) const;
        const Currency& getCurrency(const Currency::Oid& oid) const;
        void clear();
        void swap(CurrencyBook&);
        const Currency::Oid& baseCurrency() const;
        void setBaseCurrency(const Currency::Oid& newBase);

    private:
        CurrencyList currencyList_;
        Currency::Oid baseCurrency_;
    };

    // *****************************************************************
    // Money
    class Money
    {
        friend std::ostream& operator<<(std::ostream&, const Money&);

    public:
        enum ConversionMethod { noConversion, baseCurrency, automatic };

        Money() {}
        Money(const Currency::Oid& cc, const Decimal& d)
            : currency_(cc), amount_(d) {}

        // Copy, destructor and assignment by compiler.



        const Currency::Oid& currency() const
            { return currency_; }
        Decimal amount() const
            { return amount_; }
        static ConversionMethod conversionMethod()
            { return conversionMethod_; }

        static ConversionMethod conversionMethod(ConversionMethod);



        Money& operator+=(const Money&);
        Money& operator-=(const Money&);
        Money& operator*=(double);
        Money& operator*=(const Decimal&);
        Money& operator/=(double);
        Money& operator/=(const Decimal&);
        Money& operator-();

    private:
        Currency::Oid currency_;
        Decimal amount_;
        static ConversionMethod conversionMethod_;
    };

    typedef std::map<Currency::Oid, Money> MoneyList;



    void add(MoneyList& ml, const Money& m);
    void add(MoneyList& ml, const MoneyList& m);
    void subtract(MoneyList& ml, const Money& m);
    void subtract(MoneyList& ml, const MoneyList& m);

    // ToDo: Implement conversion / exchange rate managers, etc.
    // See the OMG Currency Specification (formal/00-06-29) and
    // Vipul's IA report for details

    void convert(Money&, Money&);



    inline Money operator*(const Money&, double);
    inline Money operator*(const Money&, const Decimal&);
    inline Money operator/(const Money&, double);
    inline Money operator/(const Money&, const Decimal&);
    inline Money operator+(const Money&, const Money&);
    inline Money operator-(const Money&, const Money&);
    bool operator==(const Money&, const Money&);
    bool operator!=(const Money&, const Money&);
    bool operator<(const Money&, const Money&);
    bool operator>(const Money&, const Money&);
    bool operator<=(const Money&, const Money&);
    bool operator>=(const Money&, const Money&);

    std::ostream& operator<<(std::ostream& out, const Money& m);

// *********************************************************************
// inline definitions

    inline Money operator+(const Money& m1, const Money& m2)
    {
        Money m3(m1);
        m3 += m2;
        return m3;
    }

    inline Money operator-(const Money& m1, const Money& m2)
    {
        Money m3(m1);
        m3 -= m2;
        return m3;
    }

    inline Money& Money::operator*=(double d)
    {
        amount_ *= d;
        return *this;
    }

    inline Money operator*(const Money& m, double d)
    {
        Money r(m);
        return r *= d;
    }

    inline Money& Money::operator*=(const Decimal& d)
    {
        amount_ *= d;
        return *this;
    }

    inline Money operator*(const Money& m, const Decimal& d)
    {
        Money r(m);
        return r *= d;
    }

    inline Money& Money::operator/=(double d)
    {
        amount_ /= d;
        return *this;
    }

    inline Money operator/(const Money& m, double d)
    {
        Money r(m);
        return r /= d;
    }

    inline Money& Money::operator/=(const Decimal& d)
    {
        amount_ /= d;
        return *this;
    }

    inline Money operator/(const Money& m, const Decimal& d)
    {
        Money r(m);
        return r /= d;
    }
}                                       // namespace OSB_LIB
#endif                                  // #ifndef _MONEY_H_

---