appltaxes.h

Go to the documentation of this file.

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

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.34 $

  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 _APPLTAXES_H_
#define _APPLTAXES_H_

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

// + libraries

// + local headers
#include "osbid.h"
#include "chargetraits.h"
#include "chrono.h"

// ************************************************************************
// class declarations
namespace OSB_LIB {
    class Tax;
    class BaseAmount;
}

namespace OSB_DB {
    class Session;
}

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

// ************************************************************************
// forward declarations

// ************************************************************************
// type definitions
    const long TK_WILDCARD = 0;

    enum TK_Types {
        tk_associateKey  = 0,
        tk_contractKey   = 1,
        tk_productKey    = 2,
        tk_numberOfTypes = 3
    };

    const char tk_type[] = { 'a', 'c', 'p' };

// ************************************************************************
// class definitions

    struct TaxkeyTriplet {
        TaxkeyTriplet() {}
        TaxkeyTriplet(TaxKey::Oid& a, TaxKey::Oid& c, TaxKey::Oid& p)
            { key[tk_associateKey] = a; key[tk_contractKey] = c;
              key[tk_productKey] = p; }
        bool operator==(const TaxkeyTriplet&) const;
        bool operator<(const TaxkeyTriplet&) const;
        friend  std::ostream& operator<<(std::ostream&,
                                         const TaxkeyTriplet&);

        TaxKey::Oid key[tk_numberOfTypes];
    };

    typedef long                                TaxId;
    typedef std::map<TaxIdVs, Tax*>             TaxList;
    typedef long                                TaxListId;
    typedef std::vector<TaxId>                  TaxIdList;
    typedef std::map<TaxListId, TaxIdList>      TaxIdLists;
    typedef std::vector<TaxKey::Oid>            TaxKeyIdList;
    typedef std::map<TaxkeyTriplet, TaxIdList*> TaxkeyTriplets;

    class ApplicableTaxes {
        ApplicableTaxes(const ApplicableTaxes&);
        ApplicableTaxes& operator=(const ApplicableTaxes&);
    public:
        ApplicableTaxes() {}

        const TaxIdList* findTaxIdList(const TaxkeyTriplet& tkt) const;

        const TaxIdList& getTaxIdList(const TaxkeyTriplet& tkt) const;

        const Tax* findTax(const TaxIdVs& vsId) const;

        const Tax& getTax(const TaxIdVs& vsId) const;

        const Tax* findTax(TaxId id, const Date& dt) const
            { return findTax(TaxIdVs(TaxId(id), dt)); }

        const Tax& getTax(TaxId id, const Date& dt) const
            { return getTax(TaxIdVs(TaxId(id), dt)); }

        void initialise(const OSB_DB::Session& session);

        void taxableAmount(
                  MoneyList&,
            const BaseAmount&,
            const TaxIdList&
        ) const;


        long taxIdListsSize()     { return taxIdLists_.size(); }
        long taxkeyTripletsSize() { return taxkeyTriplets_.size(); }
        long taxListSize()        { return taxList_.size(); }


        void writeTaxIdLists(std::ostream&) const;
        void writeTaxkeyTriplets(std::ostream&) const;
        void writeTaxList(std::ostream&) const;

    private:
        TaxIdLists taxIdLists_;

        TaxkeyTriplets taxkeyTriplets_;

        TaxList taxList_;
    };                                  // class ApplicableTaxes

    // *****************************************************************
    // TheApplicableTaxes
    class TheApplicableTaxes {
    public:
        static ApplicableTaxes& instance();

    private:
        TheApplicableTaxes();
        TheApplicableTaxes(const TheApplicableTaxes& rhs);

        static ApplicableTaxes* instance_;
    };
}                                       // namespace OSB_LIB
#endif                                  // #ifndef _APPLTAXES_H_

---