cpmapper.h

Go to the documentation of this file.

// OSB library ********************************************* -*- C++ -*-
/*
  AUTHOR(S): 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 _CPMAPPER_H_
#define _CPMAPPER_H_

// *********************************************************************
// included header files
// + standard includes
#include <memory>
#include <string>
#include <vector>
#include <list>

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

// + class declarations
namespace OSB_LIB {
    template<typename T> class Id;
    class Cdr;
    class UsedService;
    class TariffCatalogue;
    class ConnectionPt;
}

namespace OSB_DB {
    class Session;
}

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

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

    // *****************************************************************
    // class CpMapper
    class CpMapper {
    public:
        typedef TypeId<CpMapper> Type;
        enum CpmType {
            cpmCgi           = 1,       
            cpmCalledParty   = 2,       
            cpmCallingParty  = 3,       
            cpmNetwork       = 4,       
            cpmNwElement     = 5,       
            cpmMsrn          = 6,       
            cpmServedParty   = 7        
            // if you add here: change cpmMax below!
        };
        static const CpmType cpmMax_ = cpmServedParty;

        typedef std::auto_ptr<CpMapper> AutoPtr;

    public:
        virtual ~CpMapper() {}

        AutoPtr clone() const;

        virtual Id<ConnectionPt> map2Cp(Cdr& cdr) const = 0;

        virtual Type type() const = 0;
        CpmType cpmType() const;
    public:
        static CpmType cpmType(const Type& type);
    private:
        virtual CpMapper* clone_() const = 0;
    };

    // *****************************************************************
    // class CpMapperList
    class CpMapperList {
    public:
        struct Info {
            CpMapper::Type type_;       
            std::string    name_;       
            std::string    des_;        
        };

        typedef std::vector<Info> InfoList;
        typedef InfoList::const_iterator ConstIterator;

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

        ConstIterator begin() const { return infoList_.begin(); }
        ConstIterator end() const { return infoList_.end(); }
        const InfoList& infoList() const { return infoList_; }

        const Info* findInfo(CpMapper::Type type) const;

        const Info* findInfo(const std::string& name) const;

        const Info& getInfo(CpMapper::Type type) const;

        const Info& getInfo(const std::string& name) const;

    private:
        InfoList infoList_;             

        Info* find(CpMapper::Type type);
        Info* find(const std::string& name);
    };

    // *****************************************************************
    // class CpMapperFactory
    class CpMapperFactory {
    private:
        CpMapperFactory();
        ~CpMapperFactory();
        CpMapperFactory(const CpMapperFactory&);
        CpMapperFactory& operator=(CpMapperFactory&);
    public:
        static CpMapper::AutoPtr mkCpMapper(
            CpMapper::Type type
        );
    };

    // *****************************************************************
    // struct MappedCp
    struct MappedCp {
        Id<ConnectionPt> cpId_;          
        DateTime         cpStart_;       
        DateTime         cpEnd_;         

        MappedCp();
        MappedCp(const ConnectionPt& cp);
//        MappedCp& operator=(const ConnectionPt& cp);

        bool withinPeriod(const DateTime& ts) const;
    };

    // *****************************************************************
    // MappedPartInfo
    class MappedPartInfo {
        friend class MappedPartInfoList;

    public:
        MappedPartInfo(
            const ConnectionPt& cp,
            const DateTime&     startTs,
            const DateTime&     endTs
        );

        bool withinPeriod(const DateTime& ts) const;

        void print(std::ostream& os, std::string spacer) const;

    private:
        MappedCp mappedCp_;
        DateTime startTs_;
        DateTime endTs_;
    };

    // *****************************************************************
    // MappedPartInfoList
    class MappedPartInfoList {
    public:
        typedef std::list<MappedPartInfo> MappedPartInfos;

        std::list<MappedPartInfo> mappedInfo_;

        void add(const MappedPartInfo& info);

        void map2Cp(Id<ConnectionPt>& cpId, const DateTime& ts) const;

        void print(std::ostream& os, std::string spacer) const;
    };
}                                       // namespace OSB_LIB
#endif                                  // #ifndef _CPMAPPER_H_

---