chargetraits.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.53 $

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

// *********************************************************************
// included header files
#include <string>

// + local headers
#include "osbid.h"
#include "osbconst.h"
#include "osbutils.h"
#include "money.h"
#include "taxkey.h"

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

namespace OSB_LIB {
    class RoundRule;
    class TaxKey;
    class Account;
}

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

// ************************************************************************
// forward declarations
    class ChargeTraitsList;

// ************************************************************************
// type definitions
    typedef IdPeriod<long> TaxIdVs;

    // *****************************************************************
    // CtBase
    class CtBase {
        friend class OSB_DB::ChargeTraitsGw;
        friend class ChargeTraitsList;
    public:
        enum CmStatus    { cm_clear, cm_set, cm_grey };
        enum CmAttribute { cm_currency, cm_roundRule, cm_accountCode,
                            cm_numberFormat, cm_chargeType, cm_taxkey,
                            cm_taxIdVs, cm_lastAttribute };
        typedef CmStatus CheckMask[cm_lastAttribute];
    public:
        typedef Id<CtBase> Oid;
    public:
        explicit CtBase(const Oid& oid = Oid());

        virtual ~CtBase() = 0;


        const Oid& oid() const;
        const Currency::Oid& currency() const;
        const Id<RoundRule>& roundRule() const;
        const Id<Account>& accountCode() const;
        std::string numberFormat() const;
        CmStatus checkMask(CmAttribute a) const;

        void setCurrency(const Currency::Oid&);
        void setRoundRule(const Id<RoundRule>&);
        void setAccountCode(const Id<Account>&);
        void setNumberFormat(const std::string&);

    protected:
        bool match(const CtBase& rhs) const;

    protected:
        CtBase& operator&=(const CtBase& rhs);

        Oid oid_;
        Currency::Oid currency_;
        Id<RoundRule> roundRule_;
        Id<Account> accountCode_;
        std::string numberFormat_;
        CheckMask        checkMask_;
    };

    // *****************************************************************
    // TaxTraits
    class TaxTraits : public CtBase {
    public:
        explicit TaxTraits(Oid oid =Oid())
            : CtBase(oid) {}
        ~TaxTraits() {}

        void setTaxIdVs(const TaxIdVs&);
        TaxIdVs taxIdVs() const { return taxIdVs_; }

        TaxTraits& operator&=(const TaxTraits&);

    private:
        TaxIdVs taxIdVs_;
    };

    typedef std::map<TaxTraits::Oid, TaxTraits> TaxTraitsList;
    typedef TaxTraitsList::iterator TaxTraitsListI;
    typedef TaxTraitsList::const_iterator TaxTraitsListCI;

    // *****************************************************************
    // TheTaxTraitsList
    class TheTaxTraitsList {
    public:
        static TaxTraitsList& instance();

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

        static TaxTraitsList* instance_;
    };                                  // TheTaxTraitsList

    const TaxTraits& getTaxTraits(const TaxTraits::Oid& id);

    // *****************************************************************
    // ChargeTraits
    class ChargeTraits : public CtBase {
    public:
        explicit ChargeTraits(Oid oid = Oid())
            : CtBase(oid) {}
        ~ChargeTraits() {}

    public:

        ChargeType chargeType() const { return chargeType_; }
        TaxKey::Oid taxkey() const { return taxkey_; }

        bool match(const ChargeTraits& rhs) const;


        void setChargeType(const ChargeType&);
        void setTaxkey(const TaxKey::Oid&);

        ChargeTraits& operator&=(const ChargeTraits&);

        bool insert(const OSB_DB::Session& session);

         bool remove(const OSB_DB::Session& session);
    private:
        ChargeType chargeType_;
        TaxKey::Oid taxkey_;
    };

    // *****************************************************************
    // ChargeTraitsList
    class ChargeTraitsList {
    public:


        typedef std::map<ChargeTraits::Oid, ChargeTraits> List;
        typedef List::iterator Iterator;
        typedef List::const_iterator ConstIterator;
        typedef List::size_type SizeType;
        typedef List::key_type KeyType;

        const List& list() const { return list_; }


        Iterator begin() { return list_.begin(); }
        Iterator end() { return list_.end(); }
        Iterator find(const KeyType& k) { return list_.find(k); }
        ConstIterator begin() const { return list_.begin(); }
        ConstIterator end() const { return list_.end(); }
        ConstIterator find(const KeyType& k) const
        { return list_.find(k); }
        SizeType size() const { return list_.size(); }

        long read(const OSB_DB::Session& session);

        bool remove(
            OSB_DB::Session& session,
            ChargeTraits&    ct
        );

        bool find(ChargeTraits& ct) const;

        void getChargeTraits(
            OSB_DB::Session& session,
            ChargeTraits&    ct
        );

        const ChargeTraits* findChargeTraits(
            const ChargeTraits::Oid& id
        ) const;

        const ChargeTraits& getChargeTraits(
            const ChargeTraits::Oid& id
        ) const;

    private:
        ChargeTraits::Oid findMatch(
            const ChargeTraits& ct
        ) const;

        void add(const ChargeTraits& ct);

        List list_;
    };
}                                       // namespace OSB_LIB
#endif                                  // #ifndef _CHARGETRAITS_H_

---