sumcdr.h

Go to the documentation of this file.

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

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

// *********************************************************************
// included header files
// + standard includes

// + local headers
#include "cdr.h"

// *********************************************************************
// class declarations
namespace OSB_DB {
    class SumCdr01Gw;
}

namespace OSB_LIB {
    class SumCdrList;
    class BsPage;
    template<typename T> class Id;
}

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

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

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

    // *****************************************************************
    // class SumCdr
    class SumCdr : public Udr {
    public:
        typedef Id<SumCdr> Oid;

        SumCdr() {}

        SumCdr(
            const Id<BsPage>&  page,
            const Cdr&         cdr,
            const UsedService& us
        );

        virtual void add(Cdr& cdr) = 0;

        virtual bool match(
            const Cdr&         cdr,
            const UsedService& us
        ) const;

        virtual
        void insert(const OSB_DB::Session& session) = 0;

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

    protected:
        void addMoneyInfoList(
            const MoneyInfoList& usMoney,
                  MoneyInfoList& sumMoney
        );

        void addUsedServiceToSumCdr(
            const UsedService& us
        );

    public:
        Oid oid_;

        Id<BsPage> pageId_;

        Id2<TfVersion> flatTfId_;

        Id2<TfVersion> massTfId_;

        ChargeDetails chargeDetails_;
    };

    // *****************************************************************
    // class SumCdr01
    class SumCdr01 : public SumCdr {

        static const Udr::UdrType type_ = Udr::sumcdr01;

        friend class SumCdr01Gw;

    public:
        SumCdr01() : numCdrs_(0) {}

        SumCdr01(
            const Id<BsPage>&  page,
            const Cdr&         cdr,
            const UsedService& us
        );

        UdrType udrType() const;

        struct GroupingInfo {
            GroupingInfo() {};
            GroupingInfo(const Cdr& cdr, const UsedService& us);
            bool operator==(const GroupingInfo& rhs) const;
            bool match(const Cdr& cdr, const UsedService& us) const;

            Id<PersProduct>  persProduct_;  

            DateTime         from_;
            DateTime         to_;

            Id<TariffZone>   tariffZone_;   
            Id<TariffPeriod> tariffPeriod_; 
            Id<TariffClass>  tariffClass_;  

            Id<ConnectionPt> ratedOrigin_;  
            Id<ConnectionPt> ratedDest_;    

            std::string         inTrunkGroup_;
            std::string         outTrunkGroup_;
            Id2<NetworkElement> networkElement_;
        };

        // Documentation from base class.
        void add(Cdr& cdr);

        // Documentation from base class.
        bool match(
            const Cdr&         cdr,
            const UsedService& us
        ) const;

    private:

        // Documentation from base class.
        virtual
        void insert(const OSB_DB::Session& session);

        // Documentation from base class.
        virtual
        bool update(const OSB_DB::Session& session);

    public:
        long numCdrs_;

        GroupingInfo groupingInfo_;
    };

    // *****************************************************************
    // class SumCdr01Key
    class SumCdr01Key {
    public:
        SumCdr01Key(
            Id<ConnectionPt> a,
            Id<TariffPeriod> b,
            Id2<TfVersion>   c,
            Id2<TfVersion>   d
        ) : destinationId_(a),  tariffPeriodId_(b),
            flatTfId_(c), massTfId_(d) {}

        bool operator==(const SumCdr01Key&) const;
        bool operator!=(const SumCdr01Key&) const;
        bool operator< (const SumCdr01Key&) const;
        bool operator> (const SumCdr01Key&) const;
        bool operator<=(const SumCdr01Key&) const;
        bool operator>=(const SumCdr01Key&) const;

        Id<ConnectionPt> destinationId_;
        Id<TariffPeriod> tariffPeriodId_;
        Id2<TfVersion> flatTfId_;
        Id2<TfVersion> massTfId_;
    };

    typedef std::map<SumCdr01Key, SumCdr01> GroupedSumCdr01;

    void groupSumCdr01(
        const SumCdrList&      source,
              GroupedSumCdr01& target
    );

    // *****************************************************************
    // class SumCdrList
    class SumCdrList {
    public:
        typedef std::list<SumCdr*> List;

        virtual ~SumCdrList() { this->clear(); }



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


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

        virtual List& usageList() { return list_; }

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

        virtual void add(
            const Cdr&        cdr,
            const Id<BsPage>& pageId
        ) = 0;

        virtual long read(
            const OSB_DB::Session& session,
            const Id<BsPage>&      pageId
        ) = 0;

        virtual void remove(
            const OSB_DB::Session& session,
            const Id<BsPage>&      pageId
        ) = 0;

        virtual void save(
            const OSB_DB::Session& session
        );

        void clear();

    protected:
        List list_;
    };

    // *****************************************************************
    // class SumCdr01List
    class SumCdr01List : public SumCdrList {
    public:
        SumCdr01List() {}

        SumCdr01List(const SumCdr01List& rhs);

        SumCdr01List& operator=(const SumCdr01List& rhs);

        virtual void add(
            const Cdr&        cdr,
            const Id<BsPage>& pageId
        );

        // Documentation from base class.
        virtual long read(
            const OSB_DB::Session& session,
            const Id<BsPage>&      pageId
        );

        // Documentation from base class.
        virtual void remove(
            const OSB_DB::Session& session,
            const Id<BsPage>&      pageId
        );

    };
}                                       // namespace OSB_LIB
#endif                                  // #ifndef _SUMCDR_H_

---