network.h

Go to the documentation of this file.

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

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.48 $

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

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

// + local headers
#include "osberror.h"
#include "osbid.h"
#include "mutex.h"
#include "timezone.h"

// *********************************************************************
// class declarations
namespace OSB_LIB {
    class ConnectionPt;                 // connectionpt.h
    class Resource;                     // resource.h
}

namespace OSB_DB {
    class Session;
    class NetworkGw;
    class NetworkElementGw;
    class TrunkGroupGw;
}

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

// *********************************************************************
// class forward declarations
    class Network;
    class NetworkElement;
    class NetworkManager;
    class NumberAnalyzer;

// *********************************************************************
// type definitions
    typedef std::list<NetworkElement> NetworkElements;

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

    // *****************************************************************
    // struct NetworkAddressInfo
    struct NetworkAddressInfo {
        struct Code {
            std::string code_;
            bool isDefault_;
            Code() : isDefault_(false) {}
            explicit Code(
                const std::string& c,
                      bool         d = false
            ) : code_(c), isDefault_(d) {}
        };

        typedef std::vector<Code> List;

        Id2<NetworkElement> neId_;
        List ccs_;
        List ndcs_;
        List iacs_;
        List nacs_;

        bool empty() const;

        NetworkAddressInfo();

        explicit NetworkAddressInfo(
            const Id<Network>& nw
        );

        explicit NetworkAddressInfo(
            const Id2<NetworkElement>& ne
        );
    };                                  // struct NetworkAddressInfo

    // *****************************************************************
    // class TrunkGroup
    class TrunkGroup {
        friend class OSB_DB::TrunkGroupGw;
        friend class NetworkElement;
    public:
        typedef Id<TrunkGroup> Oid;



        enum Direction {
           dirUnknown = '\0',           
           dirIn      = 'i',            
           dirOut     = 'o'             
        };
        static char toChar(Direction dir);
        static Direction direction(char c);



        enum LinkType {
            lkUnknown  = '\0',
            lkExternal = 'e',
            lkInternal = 'i',
            lkTerminal = 't'
        };
        static char toChar(LinkType lt);
        static LinkType linkType(char c);

    public:
        TrunkGroup();
        TrunkGroup(
            const Oid&                 oid,
            const Id2<NetworkElement>& elementId
        );
        TrunkGroup(const TrunkGroup& rhs);
        TrunkGroup& operator=(const TrunkGroup& rhs);

        ~TrunkGroup();



        const Oid& oid() const;
        const Id2<NetworkElement>& networkElementId() const;
        Id<Network> networkId() const;
        const std::string& name() const;
        Direction direction() const;
        LinkType linkType() const;
        const Id2<NetworkElement>& extNetworkElementId() const;
        long objVs() const;
        const NumberAnalyzer* numberAnalyzer() const;



        void setName(const std::string& name);
        void setDirection(Direction dir);
        void setLinkType(LinkType lType);
        void setExtNetworkElementId(
            const Id2<NetworkElement>& eNetElementId
        );
        void setNumAnalyzer(NumberAnalyzer* numAnalyzer);

        void delNumAnalyzer();

        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);

        void checkExternal();

    private:
        Oid oid_;
        Id2<NetworkElement> networkElementId_;
        long objVs_;
        std::string name_;
        Direction direction_;
        LinkType linkType_;
        Id2<NetworkElement> extNetworkElementId_;
        NumberAnalyzer* numAnalyzer_;
    };                                  // class TrunkGroup

    typedef std::list<TrunkGroup> TrunkGroups;

    // ****************************************************************`
    // class NetworkElement
    class NetworkElement {
        friend class OSB_DB::NetworkElementGw;
        friend class Network;
    public:

        typedef Id2<NetworkElement> Oid;

        enum DialledNumType {
            incomingDialledNum = 'i',  
            outgoingDialledNum = 'o'   
        };

        static char dialledNumType(const DialledNumType& type);

        static DialledNumType dialledNumType(const char type);

    public:
        NetworkElement();
        NetworkElement(const NetworkElement& rhs);
        NetworkElement(const Oid& oid);
        NetworkElement(
            const Oid&         oid,
                  long         objVs,
            const std::string& name,
            const std::string& des = ""
        );

        ~NetworkElement();

        NetworkElement& operator=(const NetworkElement& rhs);



        const Oid& oid() const;
        Id<Network> networkId() const;
        const std::string& name() const;
        const std::string& des() const;
        long objVs() const;
        const Id<ConnectionPt>& connectionPt() const;
        bool hasNdc() const;
        const std::string& ndc() const;
        const TrunkGroups& trunkGroups() const;
        const TimeZone::Oid tzId() const;
        const DialledNumType& dialledNumType() const;
        const NumberAnalyzer* numberAnalyzer() const;



        void setName(const std::string& name) { name_ = name; }
        void setDes(const std::string& des) { des_ = des; }
        void setConnectionPt(const Id<ConnectionPt>& cpId);
        void setNdc(const std::string ndc);
        void unsetNdc();
        void setTimeZone(const TimeZone::Oid& tzId);
        void setDialledNumType(const DialledNumType& type);
        void setNumAnalyzer(NumberAnalyzer* numAnalyzer);
        void delNumAnalyzer();

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



        bool addTrkGroup(
            OSB_DB::Session& session,
            TrunkGroup&      trkGroup
        );

        bool updTrkGroup(
            OSB_DB::Session& session,
            TrunkGroup&      trunkGroup
        );

        bool delTrkGroup(
                  OSB_DB::Session& session,
            const TrunkGroup::Oid& oid
        );

        const TrunkGroup* findTrkGroup(
            const TrunkGroup::Oid& oid
        ) const;

        TrunkGroup* trkGroup(const TrunkGroup::Oid& oid);

        const TrunkGroup& getTrkGroup(
            const TrunkGroup::Oid& oid
        ) const;

        const TrunkGroup* findTrkGroup(
            const std::string&          name,
                  TrunkGroup::Direction direction
        ) const;

        TrunkGroup* trkGroup(
            const std::string&          name,
                  TrunkGroup::Direction direction
        );

        const TrunkGroup& getTrkGroup(
            const std::string&          name,
                  TrunkGroup::Direction direction
        ) const;

        void sortTrkGroupByName(bool desc = false);

    private:


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

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

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


        void putAddressInfo(
            NetworkAddressInfo& dest
        ) const;
        void getAddressInfo(
            const NetworkAddressInfo& src
        );

    private:
        Oid oid_;
        long objVs_;
        std::string name_;
        std::string des_;
        Id<ConnectionPt> connectionPt_;
        bool hasNdc_;
        std::string ndc_;
        TrunkGroups trunkGroups_;
        TimeZone::Oid tzId_;
        DialledNumType dialledNumType_;
        NumberAnalyzer* numAnalyzer_;
    };                                  // class NetworkElement

    // *****************************************************************
    // class Network
    class Network {
        friend class OSB_DB::NetworkGw;
        friend class NetworkManager;

    public:
        typedef Id<Network> Oid;

        struct NwAddrInfo {
            typedef std::vector<std::string> List;

            std::string cc_;
            std::string ndc_;
            List ndcs_;
            List iacs_;
            std::string nac_;
        };                              // struct NwAddrInfo

    public:
        Network(const Oid& oid = Oid());
        Network(
            const Oid&         oid,
                  long         objVs,
            const std::string& name,
            const std::string& des = ""
        );



        const Oid& oid() const;
        const std::string& name() const;
        const std::string& des() const;
        long objVs() const;
        const Id<ConnectionPt>& connectionPt() const;
        const NwAddrInfo& nwAddrInfo() const;
        const NetworkElements& elements() const;
        const TimeZone::Oid tzId() const;



        void setName(const std::string& name) { name_ = name; }
        void setDes(const std::string& des) { des_ = des; }
        void setConnectionPt(const Id<ConnectionPt>& cpId);
        void setNwAddrInfo(const NwAddrInfo& info);
        void setTimeZone(const TimeZone::Oid& tzId);

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



        bool addElement(
            OSB_DB::Session& session,
            NetworkElement&  element
        );

        bool updElement(
            OSB_DB::Session& session,
            NetworkElement&  netElement
        );

        bool delElement(
                  OSB_DB::Session&     session,
            const Id2<NetworkElement>& neId
        );

        const NetworkElement* findElement(
            const Id2<NetworkElement>& neId
        ) const;
        NetworkElement* element(const Id2<NetworkElement>& neId);
        const NetworkElement& getElement(
            const Id2<NetworkElement>& neId
        ) const;

        void sortElementByName(bool desc = false);

        const TrunkGroup& getTrkGroup(
            const Id<TrunkGroup>& tgId
        ) const;

    private:


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

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

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


        void putAddressInfo(
            NetworkAddressInfo& dest
        ) const;
        void getAddressInfo(
            const NetworkAddressInfo& src
        );

    private:
        Oid oid_;
        long objVs_;
        std::string name_;
        std::string des_;
        Id<ConnectionPt> connectionPt_;
        NwAddrInfo nwAddrInfo_;
        NetworkElements elements_;
        TimeZone::Oid tzId_;
    };                                  // class Network

    typedef std::list<Network> Networks;

    // *****************************************************************
    // class NetworkManager
    class NetworkManager {
    public:


        typedef ReadGuard<Network*> NetworkRg;
        typedef ReadGuard<Networks*> NetworksRg;
        typedef WriteGuard<Network*> NetworkWg;

        typedef RwGuard NetworksWg;

        NetworkManager();


        const Networks& networks() const { return networks_; }



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

        bool addNetwork(
            OSB_DB::Session& session,
            Network&         net
        );

        bool updNetwork(
            OSB_DB::Session& session,
            Network&         net
        );

        bool delNetwork(
                  OSB_DB::Session& session,
            const Network::Oid&    oid
        );

        const Network* findNetwork(const Network::Oid& oid) const;

        Network* network(const Network::Oid& oid);

        const Network& getNetwork(
            const Network::Oid& oid
        ) const;

        void sortNetworkByName(bool desc = false);



        NetworkRg readLock(const Network::Oid& oid);

        NetworksRg readLockList();

        NetworkWg writeLock(const Network::Oid& oid);

        const TrunkGroup& getTrkGroup(
            const Id<TrunkGroup>& tgId
        ) const;



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

        const TimeZone& getTimeZone(
            const TimeZone::Oid& oid
        )const;

        const TimeZones& getTimeZones() const;

    private:
        NetworksWg writeLockList();

    private:
        Networks  networks_;
        RwMutex   mutex_;
        TimeZones timezones_;
    };                                  // class NetworkManager

    // *****************************************************************
    // TheNetworkManager
    class TheNetworkManager {
    public:
        static NetworkManager& instance();

    private:
        TheNetworkManager();
        TheNetworkManager(const TheNetworkManager& rhs);

        static NetworkManager* instance_;
    };

}                                       // namespace OSB_LIB
#endif                                  // #ifndef _NETWORK_H_

---