amount.h

Go to the documentation of this file.

// OSB library ********************************************* -*- C++ -*-
/*
  AUTHOR(S): Andreas Huggel (ahu)

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.41 $

  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.
 */
// ********************************************************* -*- C++ -*-
#ifndef _AMOUNT_H_
#define _AMOUNT_H_

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

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

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

    class TaxAmount {
    public:
        TaxAmount(
            const TaxTraits& tt,
            const MoneyList& pt,
            const Money& td
        );



        TaxIdVs taxIdVs() const { return traits_.taxIdVs(); }
        TaxTraits traits() const { return traits_; }
        void preciseTax(MoneyList& ml) const { ml = preciseTax_; }
        void tax(MoneyList& ml) const { ml = tax_; }
        void taxed(MoneyList& ml) const { ml = taxed_; }
        TaxAmount& operator+=(const TaxAmount&);

    private:
        TaxTraits traits_;
        MoneyList preciseTax_;
        MoneyList tax_;
        MoneyList taxed_;
    };

    typedef std::vector<TaxAmount> TaxAmountList;

    std::ostream& operator<<(std::ostream&, const TaxAmount&);

    class BaseAmount {
    public:
        BaseAmount() : taxesReady_(false) {}
        BaseAmount(
            const ChargeTraits& ct,
            const Date& dt = Date()
        ) : traits_(ct), refDate_(dt), taxesReady_(false) {}
        virtual ~BaseAmount() =0;
        BaseAmount(const BaseAmount& rhs);
        BaseAmount& operator=(const BaseAmount& rhs);

        virtual void precise(MoneyList& ml) const =0;
        virtual void rounded(MoneyList& ml) const =0;
        void gross(MoneyList& ml) const;
        void net(MoneyList& ml) const;
        virtual bool accumulateTaxes() =0;
        /*
         @brief Write amount to a given standard output.

         @param o Write to this output.
         @returns Writen output.
         */
        virtual std::ostream& write(std::ostream& o) const =0;
        virtual bool taxesReady() const { return taxesReady_; }
        virtual ChargeTraits traits() const { return traits_; }
        virtual Date refDate() const { return refDate_; }
        virtual void setTraits(const ChargeTraits& ct,
                               const Date& dt = Date());
        void addTax(const TaxAmount& bta);
        void deleteTaxes();
        void totalTax(MoneyList& ml) const;
        void taxed(MoneyList& ml, TaxIdVs) const;
        void setTaxesReady(bool flag =true) { taxesReady_ = flag; }
        typedef std::map<TaxIdVs, TaxAmount*> Taxes;
        typedef Taxes::const_iterator TaxesCI;
        typedef Taxes::iterator TaxesI;

        TaxesCI taxesBegin()          const { return taxes_.begin(); }
        TaxesI  taxesBegin()                { return taxes_.begin(); }
        TaxesCI taxesEnd()            const { return taxes_.end(); }
        TaxesI  taxesEnd()                  { return taxes_.end(); }
        TaxesCI taxesFind(TaxIdVs ti) const { return taxes_.find(ti); }

    private:
        ChargeTraits traits_;

        Date refDate_;

        bool taxesReady_;
        Taxes taxes_;
    };

    std::ostream& operator<<(std::ostream&, const BaseAmount&);

    class Amount : public BaseAmount {
    public:
        Amount() : BaseAmount(), precise_(0) {}
        Amount(
            const ChargeTraits& ct,
            const Money&        p,
            const Date&         dt  = Date()
        ) : BaseAmount(ct, dt), precise_(p.amount()) {}
        Amount(const Amount& rhs)
            : BaseAmount(rhs), precise_(rhs.precise_) {}
        Amount& operator=(const Amount& rhs);
        ~Amount() {}
        void precise(MoneyList& ml) const;
        void rounded(MoneyList& ml) const;
        bool accumulateTaxes() { return taxesReady(); }
        Amount& operator+=(const Money&);

        /*
         @brief Write amount to a given standard output.

         @param o Write to this output.
         @returns Writen output.
         */
        virtual std::ostream& write(std::ostream&) const;

    private:
        Decimal precise_;
    };

    class Subtotal : public BaseAmount {
    public:
        Subtotal() : BaseAmount(), primaryAttribute_(computed) {}
        Subtotal(const ChargeTraits& ct, const Date& dt = Date())
            : BaseAmount(ct, dt), primaryAttribute_(assigned) {}
        Subtotal(const Subtotal&);
        Subtotal& operator=(const Subtotal&);
        ~Subtotal() {}

        void precise(MoneyList& ml) const {
            sum(ml, su_precise);
        }
        void rounded(MoneyList& ml) const {
            sum(ml, su_rounded);
        }
        bool taxesReady() const;
        bool accumulateTaxes();

        void addItem(BaseAmount&);

        enum AttributeType { assigned, computed };
        ChargeTraits traits() const
            { return traitsByType(primaryAttribute_); }
        ChargeTraits traitsByType(AttributeType tt) const
            { return tt == assigned ?
                  BaseAmount::traits() : computedTraits_; }

        Date refDate() const
            { return dateByType(primaryAttribute_); }
        Date dateByType(AttributeType dt) const
            { return dt == assigned ?
                  BaseAmount::refDate() : computedRefDate_; }

        void setTraits(const ChargeTraits& ct,
                       const Date& dt = Date())
        {
            BaseAmount::setTraits(ct, dt);
            primaryAttribute_ = assigned;
        }

        // shorthands and functions to deal with the amounts
        typedef std::vector<BaseAmount*> AmountList;
        typedef AmountList::const_iterator AmountListCI;
        typedef AmountList::iterator AmountListI;

        AmountListCI amountListBegin() const { return items_.begin(); }
        AmountListI  amountListBegin()       { return items_.begin(); }
        AmountListCI amountListEnd()   const { return items_.end(); }
        AmountListI  amountListEnd()         { return items_.end(); }

        /*
         @brief Write amount to a given standard output.

         @param o Write to this output.
         @returns Writen output.
         */
        virtual std::ostream& write(std::ostream&) const;

    private:
        enum SumType { su_precise, su_rounded };
        void sum(MoneyList& ml, SumType) const;

        AttributeType primaryAttribute_;

        mutable ChargeTraits computedTraits_;
        mutable Date computedRefDate_;
        AmountList items_;
    };

}                                   // namespace OSB_LIB
#endif                              // #ifndef _AMOUNT_H_

---