cgi.h

Go to the documentation of this file.

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

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.37 $

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

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

// + local headers
#include "osbid.h"
#include "osbconst.h"
#include "cpmapper.h"

// + class declarations
namespace OSB_DB {
    struct CgiGw;
}

namespace OSB_LIB {
    class ConnectionPt;
    class OsbErrors;
}

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

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

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

    // *****************************************************************
    // Cgi
    class Cgi {
        friend struct OSB_DB::CgiGw;

        friend class TariffCatalogue;
    public:
        typedef Id<Cgi> Oid;

        typedef Id<ConnectionPt> CpId;

        Cgi() : objVs_() {};

        Cgi(const Oid&         oid,
            const long         objVs,
            const std::string& name,
            const std::string& val,
            const CpId&        cpId
        );



        const Oid& oid() const { return oid_; }

        const CpId& cpId() const { return cpId_; }

        long objVs() const { return objVs_; }

        const std::string& name() const { return name_; }

        const std::string& value() const { return value_; }

        const CfgStatus& status() const { return status_; }

        const Date& startDate() const { return startDate_; }

        const Date& endDate() const { return endDate_; }

        static bool validate(
            const std::string& value
        );

        bool validate() const;



        static std::string mcc(const std::string& value);
        static std::string mnc(const std::string& value);
        static std::string lac(const std::string& value);
        static std::string ci(const std::string& valule);



        std::string mcc() const;
        std::string mnc() const;
        std::string lac() const;
        std::string ci() const;

        bool setName(const std::string& newName);

        bool setValue(const std::string& newValue);

        bool setCpId(const CpId& id);

        void setStartDate(const Date& sDate);

        void setEndDate(const Date& eDate);

        static const std::string catchall;



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

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

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

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



        bool check(
            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_;       
        std::string name_;        
        std::string value_;       
        CpId        cpId_;        
        CfgStatus   status_;      
        Date        startDate_;   
        Date        endDate_;     
    };

    typedef std::list<Cgi> Cgis;

    // *****************************************************************
    // CgiToCp
    class CgiToCp : public CpMapper {
        static const CpmType cpmType_ = cpmCgi;
        // Documentation from base class.
        typedef std::auto_ptr<CgiToCp> AutoPtr;
    public:
        // Documentation from base class.
        AutoPtr clone() const;

        Type type() const { return Type(cpmType_); }

        virtual Id<ConnectionPt> map2Cp(Cdr& cdr) const;
    private:
        // Documentation from base class.
        virtual CpMapper* clone_() const;
    };

    // *****************************************************************
    // CgiMap
    class CgiMap {
        friend class TariffCatalogue;


        struct Ci;
        struct Lac;
        struct Mnc;
        struct Mcc;
        friend struct Ci;
        friend struct Lac;
        friend struct Mnc;
        friend struct Mcc;
    public:
        CgiMap();

        void build(const TariffCatalogue& tcat);

        Id<ConnectionPt> map2Cp(
            const std::string& cgi,
            const DateTime&    ts
        ) const;

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

    private:
        typedef Id<ConnectionPt> CpId;

        struct Ci {
            std::string        ci_;
            MappedPartInfoList mappedPartInfoList_;
            void map2Cp(
                      CpId&     id,
                const DateTime& ts
            ) const;
            void print(std::ostream& os, std::string spacer) const;
        };
        typedef std::map<std::string, Ci> Cis;

        struct Lac {
            std::string        lac_;
            MappedPartInfoList mappedPartInfoList_;
            Cis         cis_;
            void add(
                const Cgi&          cgi,
                const std::string&  ci,
                const ConnectionPt& cp
            );
            void map2Cp(
                      CpId&        id,
                const std::string& cgi,
                const DateTime&    ts
            ) const;
            void print(std::ostream& os, std::string spacer) const;
        };
        typedef std::map<std::string, Lac> Lacs;

        struct Mnc {
            std::string mnc_;
            MappedPartInfoList mappedPartInfoList_;
            Lacs        lacs_;
            void add(
                const Cgi&          cgi,
                const std::string&  lac,
                const ConnectionPt& cp
            );
            void map2Cp(
                      CpId&        id,
                const std::string& cgi,
                const DateTime&    ts
            ) const;
            void print(std::ostream& os, std::string spacer) const;
        };
        typedef std::map<std::string, Mnc> Mncs;

        struct Mcc {
            std::string mcc_;
            MappedPartInfoList mappedPartInfoList_;
            Mncs        mncs_;
            void add(
                const Cgi&          cgi,
                const std::string&  mnc,
                const ConnectionPt& cp
            );
            void map2Cp(
                      CpId&        id,
                const std::string& cgi,
                const DateTime&    ts
            ) const;
            void print(std::ostream& os, std::string spacer) const;
        };
        typedef std::map<std::string, Mcc> Mccs;

    private:
        Mccs        mccs_;              
        MappedCp    catchall_;          

        bool        needBuild_;

        void add(const Cgi& cgi, const ConnectionPt& cp);
    };
}                                       // namespace OSB_LIB
#endif                                  // #ifndef _OSB_CGI_H_

---