tcdist.h

Go to the documentation of this file.

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

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.63.2.1 $

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

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

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

// *********************************************************************
// class declarations
namespace OSB_LIB {
    class Cdr;
    class ConnectionPt;
    class CpMapper;
    class Date;
    class OsbException;
}

namespace OSB_DB {
    class Session;
    class TariffSystemGw;
    class MappingDistTcsGw;
    struct DistTcsGw;
    struct TariffZoneGw;
    struct TzConfigGw;
}

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

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

    // *****************************************************************
    // class TariffZone
    class TariffZone : public TariffObject {
        friend struct OSB_DB::TariffZoneGw;
        friend class TariffCatalogue;
    public:
        typedef Id<TariffZone> Oid;
    public:
        explicit TariffZone(const Oid& oid = Oid()) : oid_(oid) {}
    public:
        const Oid& oid() const { return oid_; }



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

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

        bool remove(const OSB_DB::Session& session);
    private:
        Oid oid_;
    };

    typedef std::list<TariffZone> TariffZones;

    // *****************************************************************
    // class TzConfig
    class TzConfig : public ToCfgPeriodBase {
        friend struct OSB_DB::TzConfigGw;
        friend class TariffCatalogue;
    public:
        typedef Id<TzConfig> Oid;
    public:
        TzConfig(const Oid& oid = Oid());
        TzConfig(
            const Id<TariffZone>& tzId,
            const Id<ConnectionPt>& origin,
            const Id<ConnectionPt>& dest
        );
    public:


        const Oid& oid() const;
        const Id<TariffZone>& tzOid() const;
        inline const Id<ConnectionPt>& origin() const
        {
            return origin_;
        }
        inline const Id<ConnectionPt>& dest() const
        {
            return dest_;
        }



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

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

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

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



        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
        );
    private:
        Oid oid_;
        long objVs_;
        Id<TariffZone> tzId_;
        Id<ConnectionPt> origin_;
        Id<ConnectionPt> dest_;
    };                                  // class TzConfig

    typedef std::list<TzConfig> TzConfigs;

    // *****************************************************************
    // DistTcs
    class DistTcs : public TcsVersion {
        friend struct OSB_DB::DistTcsGw;

        typedef std::multimap< Id<ConnectionPt>, TzConfig> Config;

        static const TcSystem::TcsType type_ = TcSystem::tcsDist;

    public:
        typedef std::map<TariffZone::Oid, TariffClass::Oid> ZoneClassMap;

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

        explicit DistTcs(const TcSystem::Oid& tcsId);

        virtual TcSystem::TcsType type() const;

        // doc from base class
        void copyCfg(const OSB_LIB::TcsVersion* src);

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

        const ZoneClassMap& zcMap() const { return zcMap_; }

        void supportedTc(
            std::set<TariffClass::Oid>& tcOids
        ) const;

        virtual TariffClass::Oid getTc(
            Cdr&         cdr,
            UsedService& service
        ) const;

        void addZone(
            const TariffZone::Oid&  tzOid,
            const TariffClass::Oid& tcOid
        );

        void removeZone( const TariffZone::Oid& tzOid);

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



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

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

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

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



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

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

        virtual bool delSpecific(
            const OSB_DB::Session& session
        );

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

        const TariffClass::Oid& getTariffClass(
            const TariffZone::Oid& tzOid
        ) const;



        void populate() const;

        bool findDest(
                  Id<ConnectionPt>& dest,
            const DateTime&         ts
        ) const;

        TariffZone::Oid findTzOid(
                  Id<ConnectionPt>& origin,
            const DateTime&         ts,
            const Id<ConnectionPt>& dest
        ) const;

    private:
        mutable Config config_;

        ZoneClassMap zcMap_;
    };

    class UsageMapping {
    public:
        typedef OSB_LIB::TypeId<OSB_LIB::Cdr, 1> UsageType;
    public:
        explicit UsageMapping(
            UsageType        ut = UsageType(),
            TypeId<CpMapper> ot = TypeId<CpMapper>(),
            TypeId<CpMapper> dt = TypeId<CpMapper>()
        );
        ~UsageMapping();
        UsageMapping(const UsageMapping& rhs);
        UsageMapping& operator=(const UsageMapping& rhs);
    public:
        UsageType usageType() const;
        TypeId<CpMapper> originType() const;
        TypeId<CpMapper>  destType() const;
        const CpMapper* originMapper() const;
        const CpMapper* destMapper() const;

        void createMappers();
    private:
        UsageType    usageType_;
        TypeId<CpMapper>  originType_;
        TypeId<CpMapper>  destType_;
        CpMapper*         originMapper_;
        CpMapper*         destMapper_;
    };

    // *****************************************************************
    // class MappingDistTcs
    class MappingDistTcs : public TcsVersion {
    private:
        static const TcSystem::TcsType type_ = TcSystem::tcsMapping;

        friend class OSB_DB::MappingDistTcsGw;
    public:
        typedef TypeId<Cdr, 1> UsageType;
        // Documentation from base class.
        typedef std::auto_ptr<MappingDistTcs> AutoPtr;
        typedef std::vector<UsageMapping> MappingList;
    public:
        explicit MappingDistTcs(const TcSystem::Oid& tcsId);
        // Documentation from base class.
        AutoPtr clone() const;

        void supportedTc(
            std::set<TariffClass::Oid>& tcOids
        ) const;

        TcSystem::TcsType type() const;

        // doc from base class
        void copyCfg(const OSB_LIB::TcsVersion* src);

        TariffClass::Oid getTc(
            Cdr&         cdr,
            UsedService& service
        ) const;

        const UsageMapping* findMapping(const UsageType& ut) const;



        const TcSystem::Oid& distTcs() const
        {
            return distTcs_;
        }
        bool setDistTcs(const TcSystem::Oid& distTcs);

        const MappingList& usageTypeMapping() const;
        bool addMapping(const UsageMapping& mapping);
        bool rmMapping(const UsageType& ut);

        void clearMappings();



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

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

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

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



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

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

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

        virtual bool delSpecific(
            const OSB_DB::Session& session
        );

    private:
        TcSystem::Oid distTcs_;
        MappingList mappings_;

        // Documentation from base class.
        virtual TcsVersion* clone_() const;

        MappingList::iterator mappingDef(const UsageType& ut);
    };

// *********************************************************************
// inline definitions

}                                       // namespace OSB_LIB
#endif                                  // #ifndef _TCDIST_H_

---