ratingfn.h

Go to the documentation of this file.

// OSB library ********************************************* -*- C++ -*-
/*
  AUTHOR(S): Tang Boon Leong (tbl)

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.70 $

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

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

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

// *********************************************************************
// class declarations
namespace OSB_DB {
    struct RatingFnGw;
    struct RfStairCaseGw;
    struct RfSlotGw;
}

namespace OSB_LIB {
    class CtBase;
    class ChargeTraits;
    class Unit;
    class Money;
    class Currency;
}

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

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

    // *****************************************************************
    // RatingFn
    class RatingFn : public TariffObject, public ToCfgBase {
        friend struct OSB_DB::RatingFnGw;
        friend class TariffCatalogue;
        friend class RatingFns;
    public:
        typedef Id<RatingFn> Oid;

        typedef TypeId<RatingFn> Type;
        typedef std::auto_ptr<RatingFn> AutoPtr;
        enum RfType {
            rfStairCase  = 1,  
            rfSlot       = 2   
        };
        static RfType rfType(const Type& t);
    public:
        explicit RatingFn(
            const Oid&  oid = Oid()
        );
        virtual ~RatingFn() {}

        AutoPtr clone() const;

        template<typename F> F* isa(F*& ptr);
        template<typename F> const F* isa(const F*& ptr) const;
    public:
        virtual const Money rateVolumeToMoney(
            const TypeId<Unit>& unitId,
            const Decimal&    volume,
                  Decimal&    roundedVolume
        ) const = 0;

        virtual const Decimal rateMoneyToVolume(
            const Money& money
        ) const = 0;



        virtual Type type() const = 0;
        RfType rfType() const;
        const Oid& oid() const;
        const Id<CtBase>& ctId() const;
        const std::string& currency() const;
        const TypeId<Unit>& unitId() const;



        void setCtId(const ChargeTraits& ct);

        void setUnitId(const TypeId<Unit>& id);



        bool freeze(
            const OSB_DB::Session& session,
                  OsbErrors&       errors
        );

        bool release(
            const OSB_DB::Session& session,
                  OsbErrors&       errors
        );

        bool revoke(
            const OSB_DB::Session& session,
                  OsbErrors&       errors
        );

        bool unfreeze(
            const OSB_DB::Session& session,
                  OsbErrors&       errors
        );

    protected:
        virtual RatingFn& operator=(const RatingFn& rhs);

    protected:
        bool checkObjVs(
            const OSB_DB::Session& session,
                  OsbErrors&       errors
        );
    private:
        virtual RatingFn* clone_() const = 0;

        virtual bool freezeSpecific(
            const OSB_DB::Session& session,
                  OsbErrors&       errors
        ) = 0;

        virtual bool releaseSpecific(
            const OSB_DB::Session& session,
                  OsbErrors&       errors
        ) = 0;

        virtual bool revokeSpecific(
            const OSB_DB::Session& session,
                  OsbErrors&       errors
        ) = 0;

        virtual bool unfreezeSpecific(
            const OSB_DB::Session& session,
                  OsbErrors&       errors
        ) = 0;

        virtual bool
        readSpecific(const OSB_DB::Session& session) = 0;

        virtual bool
        insSpecific(const OSB_DB::Session& session) = 0;

        virtual bool
        removeSpecific(const OSB_DB::Session& session) = 0;

        virtual bool
        updSpecific(const OSB_DB::Session& session) = 0;


    public:
        bool read(const OSB_DB::Session& session);

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

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

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

    private:
        Oid oid_;
        Id<CtBase> ctId_;
        std::string currency_;
        TypeId<Unit> unitId_;
    };

    // *****************************************************************
    // class RatingFns
    class RatingFns {
        friend struct OSB_DB::RatingFnGw;

    public:
        RatingFns() {};

        RatingFns(const RatingFns& rhs);

        RatingFns& operator=(const RatingFns& rhs);

        ~RatingFns();



        typedef std::list<RatingFn*> List;
        typedef List::iterator Iterator;
        typedef List::const_iterator ConstIterator;
        typedef List::size_type SizeType;


        Iterator       begin();
        Iterator       end();
        ConstIterator begin() const;
        ConstIterator end() const;
        SizeType      size() const;
        void swap(RatingFns& rhs);

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

        List& getList() { return items_; }

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

        RatingFn* ratingFn(
            const RatingFn::Oid& id
        ) const;

        const RatingFn* findRatingFn(
            const RatingFn::Oid& id
        ) const;

        const RatingFn& getRatingFn(
            const RatingFn::Oid& id
        ) const;

        void erase(const RatingFn& rf);

        void clear();

        void pushBack(const RatingFn& rf);

        void pushBack(RatingFn::AutoPtr rf);

   private:
        List items_;
   };


    // *****************************************************************
    // RfStairCase
    class RfStairCase : public RatingFn
    {
        friend struct OSB_DB::RfStairCaseGw;

    public:
        // Documentation from base class.
        typedef std::auto_ptr<RfStairCase> AutoPtr;

        struct Charge {
            Charge(
                      long     seq,
                const Decimal& len,
                      long     multi,
                const Decimal& rate
            ) : sequence_(seq), length_(len),
                multiplier_(multi), rate_(rate)
            {
                // empty
            }

            Charge () {};

            long     sequence_;
            Decimal  length_;
            long     multiplier_;
            Decimal  rate_;
        };

        typedef std::list<Charge> Charges;

        explicit RfStairCase(const RatingFn::Oid& oid = Oid());

        // Documentation from base class.
        AutoPtr clone() const;

        virtual const Money rateVolumeToMoney(
            const TypeId<Unit>& unitId,
            const Decimal&      volume,
                  Decimal&      roundedVolume
        ) const;

        virtual const Decimal rateMoneyToVolume(
            const Money& money
        ) const;


        // documentation from base class
        Type type() const;
        const Charges& charges() const;



        bool setCharges(const Charges& charges);

    private:
        // Documentation from base class.
        virtual RatingFn* clone_() const;

        void volumeToMoney(
            Decimal& volume,
            Decimal& roundedVolume,
            long     seq,
            Decimal& rate
        ) const;

        void moneyToVolume(
            Money&   money,
            long&    seq,
            Decimal& volume
        ) const;



        virtual bool freezeSpecific(
            const OSB_DB::Session& session,
                  OsbErrors&       errors
        );

        virtual bool releaseSpecific(
            const OSB_DB::Session& session,
                  OsbErrors&       errors
        );

        virtual bool revokeSpecific(
            const OSB_DB::Session& session,
                  OsbErrors&       errors
        );

        virtual bool unfreezeSpecific(
            const OSB_DB::Session& session,
                  OsbErrors&       errors
        );



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

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

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

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

    private:
        Charges charges_;
    };


    // *****************************************************************
    // RfSlot
    class RfSlot : public RatingFn
    {
        friend struct OSB_DB::RfSlotGw;

    public:
        // Documentation from base class.
        typedef std::auto_ptr<RfSlot> AutoPtr;

        typedef std::map<Decimal, Decimal> Charges;

        explicit RfSlot(const RatingFn::Oid& oid = Oid());

        // Documentation from base class.
        AutoPtr clone() const;

        virtual const Money rateVolumeToMoney(
            const TypeId<Unit>& unitId,
            const Decimal&      volume,
                  Decimal&      roundedVolume
        ) const;

    protected:
        virtual const Decimal rateMoneyToVolume(const Money&) const;

    public:

        // documentation from base class
        Type type() const;
        const Charges& charges() const;



        bool setCharges(const Charges& charges);

    private:
        // Documentation from base class.
        virtual RatingFn* clone_() const;



        virtual bool freezeSpecific(
            const OSB_DB::Session& session,
                  OsbErrors&       errors
        );

        virtual bool releaseSpecific(
            const OSB_DB::Session& session,
                  OsbErrors&       errors
        );

        virtual bool revokeSpecific(
            const OSB_DB::Session& session,
                  OsbErrors&       errors
        );

        virtual bool unfreezeSpecific(
            const OSB_DB::Session& session,
                  OsbErrors&       errors
        );



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

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

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

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

    private:
        Charges charges_;
    };


    // *****************************************************************
    // RatingFnFactory
    class RatingFnFactory {
    public:
        static RatingFn::AutoPtr create(
            const RatingFn::Type& rfType,
            const RatingFn::Oid&  oid = RatingFn::Oid()
        );

    private:
        RatingFnFactory();
        RatingFnFactory(const RatingFnFactory& rhs);
    };

// *********************************************************************
// template definitions

    // *****************************************************************
    // RatingFn
    template<typename F> F* RatingFn::isa(F*& ptr)
    {
        ptr = dynamic_cast<F*>(this);
        return ptr;
    }

    template<typename F> const F* RatingFn::isa(const F*& ptr) const
    {
        ptr = dynamic_cast<const F*>(this);
        return ptr;
    }
}                                       // namespace OSB_LIB
#endif                                  // #ifndef _RATINGFN_H_

---