callaccounting.h

Go to the documentation of this file.

// OSB library ************************************************ -*- C++ -*-
/*
  AUTHOR(S): Darryl Kang (dk)

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.24 $

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

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

// + local headers
#include "fraction.h"
#include "osbid.h"
#include "modules.h"

// + class declarations
namespace OSB_DB {
    class Session;
    class CallAccountingGw;
}

namespace OSB_LIB {
    class Cdr;
    class CdrList;
    class RecordStreamInfo;
}

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

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

    class CallAccounting {
    public:
        enum Result {
            caOk       = 'o',      
            caError    = 'e',      
            caFiltered = 'f'       
        };

        static char toChar(Result result);

        static Result mkResult(char r);


        typedef std::pair< Id<RecordStreamInfo>, Result > Key;
        typedef std::map<Key, Fraction> Counts;

    public:
        CallAccounting(ModuleId module);

        ModuleId module() const { return module_; }

        void reset();

        void add(
                  Result   result,
            const CdrList& cdrs
        );

        void subtract(
                  Result   result,
            const CdrList& cdrs
        );

        void add(
                  Result result,
            const Cdr&   cdr
        );

        void subtract(
                  Result result,
            const Cdr&   cdr
        );

        void add(
                  Result                result,
            const Id<RecordStreamInfo>& rsId
        );

        void subtract(
                  Result                result,
            const Id<RecordStreamInfo>& rsId
        );

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

    private:
        inline Key key(
                  Result                result,
            const Id<RecordStreamInfo>& rsId
        )
        {
            return std::make_pair(rsId, result);
        }

    private:
        ModuleId module_;
        Counts counts_;
    };                                  // class CallAccounting

    struct CaResultDef {
        typedef Id<RecordStreamInfo> RsId;
        typedef std::map<CallAccounting::Result, double> CaCounts;
    };                                  // struct CaResultDef

    struct CaCounts : public CaResultDef::CaCounts {
        explicit CaCounts(
            const CaResultDef::CaCounts& caCounts
        ) : CaResultDef::CaCounts(caCounts)
        {
            // empty
        }
    };                                  // struct CaCounts

    class CaStreamResult : public CaResultDef {
        friend class OSB_DB::CallAccountingGw;

    public:
        typedef std::map<ModuleId, CaCounts> ModuleCounts;

    public:
        explicit CaStreamResult(const RsId& rsId = RsId());

    public:
        const RsId rsId() const
        {
            return rsId_;
        }

        long numRecords() const
        {
            return numRecords_;
        }

        const ModuleCounts& result() const
        {
            return result_;
        }

        const ModuleCounts resNotZero() const;

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

    private:
        RsId rsId_;
        long numRecords_;
        ModuleCounts result_;
    };                                  // class CaStreamResult

    struct CaModuleResult : public CaResultDef {
        struct StreamInfo {
            RsId rsId_;
            long numRecords_;
            StreamInfo(
                const RsId& rsId,
                      long  numRecords
            ) : rsId_(rsId), numRecords_(numRecords)
            {
                // empty
            }

            bool operator<(const StreamInfo& rhs) const
            {
                return rsId_ < rhs.rsId_;
            }
        };                              // struct StreamInfo

        typedef std::map<StreamInfo, CaCounts> StreamCounts;

    public:
        ModuleId module_;
        StreamCounts result_;
    public:
        explicit CaModuleResult(
            ModuleId module = mdUnknown
        ) : module_(module)
        {
            // empty
        }
    };                              // struct CaModuleResult

    class CaResults : public CaResultDef {
    public:
        typedef std::set<ModuleId> Modules;

        typedef std::map<RsId, CaStreamResult> Results;

    public:
        const Results& results() const;
        const Modules& modules() const;
        const CaStreamResult& result(const RsId& rsId);
        bool result(CaModuleResult& modRes) const;

        void clear();
        const CaStreamResult& add(const CaStreamResult& caRes);
        const CaStreamResult& read(
            const OSB_DB::Session& session,
            const RsId&            rsId
        );
    private:
        Results results_;
        Modules modules_;
    };                                  // class CaResults
} // namespace OSB_LIB
#endif                                  // #ifndef _CALLACCOUNTING_H_

---