rpevalmgr.h

Go to the documentation of this file.

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

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.11 $

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

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

// + libraries

// + local headers
#include "osberror.h"
#include "osbtype.h"
#include "rpeval.h"

// + class declarations
namespace OSB_DB {
    class RpEvalGw;
}

namespace OSB_LIB {
    class NetworkElement;
    class RatedParty;
    class UsageType;
}

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

// ************************************************************************
// forward declarations

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

// ************************************************************************
// class definitions
    class RpEvalMgr {
        friend class OSB_DB::RpEvalGw;
    public:
        // defined below
        class EvalExists;
    public:
        typedef TypeId<RatedParty> RpType;
        typedef std::map<RpType, RatedPartyEval*> RpEvals;
        typedef TypeId<Cdr, 1> UsgType;
        typedef std::map<UsgType, RpEvals> UsgEvalMap;
        typedef Id2<NetworkElement> NeId;
        typedef std::map<NeId, UsgEvalMap> EvalMap;

    public:
        RpEvalMgr();
        ~RpEvalMgr();

    private:
        RpEvalMgr(const RpEvalMgr&);
        RpEvalMgr& operator=(const RpEvalMgr&);

    public:                             // get RP evaluators


        bool resourceCacheNeeded() const;
        const RpEvals* getEvals(
            const NeId&    neId,
            const UsgType& usgType
        ) const;

        const RatedPartyEval* getEval(
            const NeId&    neId,
            const UsgType& usgType,
            const RpType&  rpType
        ) const;



        const UsgEvalMap* find(
            const NeId& neId
        ) const;

        const RpEvals* find(
            const NeId&    neId,
            const UsgType& usgType
        ) const;

        const RatedPartyEval* find(
            const NeId&    neId,
            const UsgType& usgType,
            const RpType&  rpType
        ) const;

    public:                             // maintenance
        void clear();

        void replace(
            const NeId&                         neId,
            const UsageType&                    usgType,
                  std::auto_ptr<RatedPartyEval> rpEval
        );

        void remove(
            const NeId&      neId,
            const UsageType& usgType,
            const RpType&    rpType
        );

    public:                             // database operations
        void read(const OSB_DB::Session& session);

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

    private:
        void add(
            const NeId&                         neId,
                  long                          objVs,
            const UsageType&                    usgType,
                  std::auto_ptr<RatedPartyEval> rpEval
        );

        struct ModInfo {
            ModInfo();

            long objVs_;
            bool dirty_;
        };                              // struct ModInfo

    private:
        typedef std::map<NeId, ModInfo> ModInfos;
        EvalMap evalMap_;
        ModInfos modInfo_;
    };                                  // class RpEvalMgr

    struct RpEvalUsgMap {
        typedef RpEvalMgr::NeId NeId;
        typedef RpEvalMgr::UsgEvalMap       UsgMap;
    public:
        RpEvalUsgMap(
            const NeId&   neId,
                  UsgMap& usgMap,
                  long    objVs
        ) : neId_(neId), objVs_(objVs), usgMap_(usgMap)
        {
        }
    public:
        NeId neId_;
        long             objVs_;
        UsgMap&          usgMap_;
    private:
        RpEvalUsgMap(const RpEvalUsgMap& rhs);
        RpEvalUsgMap operator=(const RpEvalUsgMap& rhs);
    };                                  // struct RpEvalUsgMap

    class RpEvalMgr::EvalExists : public OsbException {
    public:
        EvalExists();
    };                                  // class RpEvalMgr::EvalExists
}                                       // namespace OSB_LIB

// ************************************************************************
// inline definitions
namespace OSB_LIB {
}                                       // namespace OSB_LIB
#endif                                  // #ifndef _RPEVALMGR_H_

---