productpart_i.h

Go to the documentation of this file.

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

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.39 $

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

// *********************************************************************
// included header files
// + standard inlcudes

// + local headers
#include "productpartS.h"
#include "productcat.h"    // for ProductNodeRg
#include "trunkresource.h"
#include "accessnumber.h"
#include "ipaddress.h"

// + class declarations
namespace OSB_CORBA {
    class Product_i;
    class ProductWriter_i;
}

// ************************************************************************
// namespace extensions
namespace OSB_CORBA {

    using namespace corba::common;
    using namespace corba::pcat;
    using namespace corba::pcat::pp;

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

    // *****************************************************************
    // class ProductPartBase_i
    class ProductPartBase_i :
        public virtual POA_corba::pcat::pp::ProductPart
    {
    public:                             // CORBA interface
        virtual ProductPartId id()
            throw (OsbCorbaException);

        virtual Utf8String* name()
            throw (OsbCorbaException);

        virtual Utf8String* desc()
            throw (OsbCorbaException);

        virtual PpTypeId tid()
            throw (OsbCorbaException);

        virtual PpCfgType cfgType()
            throw (OsbCorbaException);

        virtual PpDefPersType defPersType()
            throw (OsbCorbaException);

        virtual Utf8String* configDes()
            throw (OsbCorbaException);

        virtual Utf8String* defPersDes()
            throw (OsbCorbaException);

        virtual CORBA::Long mandatory()
            throw (OsbCorbaException);

        virtual PpCfgPersType canPersonalize()
            throw (OsbCorbaException);

        virtual ProductPartId parentId()
            throw (OsbCorbaException);

        virtual ProductPartSeq* getParts()
            throw (OsbCorbaException);

    // Typedefs for OSB library object ids.
    protected:
        typedef OSB_LIB::Product::Oid ProductOid;
        typedef OSB_LIB::ProductNode::Oid NodeOid;
        typedef OSB_LIB::ProductItem::Oid ItemOid;

    // Provide OSB library object ids: in order to avoid multiuser
    // problem we return objects and not references.
    public:
        ProductOid prodId() const;
        virtual NodeOid nodeId() const = 0;
        virtual ItemOid itemId() const = 0;

    protected:
        typedef OSB_LIB::PcatLockMgr::ProductNodeRg NodeRg;

        const OSB_LIB::ProductNode* getNode(
            const NodeRg&      guard,
            const std::string& ifc,
            const std::string& module
        ) const throw (OsbCorbaException);

        const OSB_LIB::ProductItem* getItem(
            const NodeRg&      guard,
            const std::string& ifc,
            const std::string& module
        ) const throw (OsbCorbaException);

        virtual NodeRg lockNode() const = 0;

        virtual Product_i& productServant() = 0;
        virtual const Product_i& productServant() const = 0;

        virtual const std::string& ifc() const = 0;
    };                                  // class ProductPartBase_i

    // *****************************************************************
    // class ProductPart_i
    class ProductPart_i : public virtual ProductPartBase_i
    {
    // Construction & destruction.
    public:
        ProductPart_i(
                  Product_i& pd,
            const NodeOid&   pnId,
            const ItemOid&   piId
        );

        virtual ~ProductPart_i() = 0;

    protected:                          // required by ProductPartBase_i
        virtual NodeRg lockNode() const;

    public:                             // required by ProductPartBase_i
        // Documentation from base class.
        virtual NodeOid nodeId() const;
        // Documentation from base class.
        virtual ItemOid itemId() const;

    private:                            // required by ProductPartBase_i
        // Documentation from base class.
        virtual Product_i& productServant();
        // Documentation from base class.
        virtual const Product_i& productServant() const;

    private:                            // data members
        Product_i&       prodi_;
        const NodeOid    pnId_;
    protected:
        const ItemOid    piId_;
    };                                  // class ProductPart_i

    // *****************************************************************
    // class ProductPartWriter_i
    class ProductPartWriter_i :
        public virtual POA_corba::pcat::pp::ProductPartWriter,
        public virtual ProductPartBase_i
    {
    // Construction & destruction.
    public:
        ProductPartWriter_i(
            ProductWriter_i&      prod,
            OSB_LIB::ProductNode& node
        );

    // Implementation of ProductPartWriter's abstract methods.
    public:
        virtual void setName(const Utf8String& name)
          throw (OsbCorbaException);

        virtual void setDesc(const Utf8String& desc)
          throw (OsbCorbaException);

        virtual void setConfigDes(const Utf8String& desc)
          throw (OsbCorbaException);

        virtual void setDefPersDes(const Utf8String& desc)
          throw (OsbCorbaException);

        virtual void setMandatory(int value)
          throw (OsbCorbaException);

        virtual ProductPartWriter_ptr addPart(const PpTypeId& tid)
          throw (OsbCorbaException);

        virtual void removePart(const ProductPartId& pid)
          throw (OsbCorbaException);

    protected:                          // required by ProductPartBase_i
        virtual NodeRg lockNode() const;

    public:                             // required by ProductPartBase_i
        // Documentation from base class.
        virtual NodeOid nodeId() const;
        // Documentation from base class.
        virtual ItemOid itemId() const;

    private:                            // required by ProductPartBase_i
        // Documentation from base class.
        virtual Product_i& productServant();
        // Documentation from base class.
        virtual const Product_i& productServant() const;

    private:


        virtual OSB_LIB::ProductItem* pItem() = 0;
        virtual const OSB_LIB::ProductItem* pItem() const = 0;

    private:                            // data members
        ProductWriter_i& product_;
        OSB_LIB::ProductNode& node_;
    };                                  // class ProductPartWriter_i

    // *****************************************************************
    // class DescPartBase_i
    class DescPartBase_i :
        public virtual POA_corba::pcat::pp::DescriptionPart,
        public virtual ProductPartBase_i
    {
    private:
        virtual const OSB_LIB::DescriptionItem* getDescItem(
            const ProductPartBase_i::NodeRg& guard,
            const std::string&               ifc,
            const std::string&               module
        ) const throw (OsbCorbaException) = 0;
   };

    // *****************************************************************
    // class DescPart_i
    class DescPart_i :
        public virtual DescPartBase_i,
        public virtual ProductPart_i
    {
    public:
        static const std::string IFC;

    public:
        DescPart_i(
                  Product_i& pd,
            const NodeOid&   pnId,
            const ItemOid&   piId
        );

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

        virtual const OSB_LIB::DescriptionItem* getDescItem(
            const ProductPartBase_i::NodeRg& guard,
            const std::string&               ifc,
            const std::string&               module
        ) const throw (OsbCorbaException);
        const std::string& ifc() const;
    };                                  // class DescPart_i

    // *****************************************************************
    // class DescPartWriter_i
    class DescPartWriter_i :
        public virtual POA_corba::pcat::pp::DescriptionPartWriter,
        public virtual ProductPartWriter_i,
        public virtual DescPartBase_i
    {
    public:
        static const std::string IFC;

    public:
        DescPartWriter_i(
            ProductWriter_i&          prod,
            OSB_LIB::ProductNode&     node,
            OSB_LIB::DescriptionItem& item
        );

    private:


        DescPartWriter_i(const DescPartWriter_i& rhs);
        DescPartWriter_i& operator=(const DescPartWriter_i& rhs);

    private:
        OSB_LIB::DescriptionItem& item_;

    private:                        // required by ProductPartWriter_i
        // Documentation from base class.
        virtual OSB_LIB::ProductItem* pItem();
        // Documentation from base class.
        virtual const OSB_LIB::ProductItem* pItem() const;

        virtual const OSB_LIB::DescriptionItem* getDescItem(
            const ProductPartBase_i::NodeRg& guard,
            const std::string&               ifc,
            const std::string&               module
        ) const throw (OsbCorbaException);
        const std::string& ifc() const;
    };                                  // class DescPartWriter_i

    // *****************************************************************
    // class AnPartBase_i
    class AnPartBase_i :
        public virtual POA_corba::pcat::pp::AnPart,
        public virtual ProductPartBase_i
    {

    private:
        virtual const OSB_LIB::AnItem* getAnItem(
            const ProductPartBase_i::NodeRg& guard,
            const std::string&               ifc,
            const std::string&               module
        ) const throw (OsbCorbaException) = 0;
    };

    // *****************************************************************
    // class AnPart_i
    class AnPart_i :
        public virtual AnPartBase_i,
        public virtual ProductPart_i
    {
    public:
        static const std::string IFC;

        AnPart_i(
                  Product_i& pd,
            const NodeOid&   pnId,
            const ItemOid&   piId
        );

    private:
        virtual const OSB_LIB::AnItem* getAnItem(
            const ProductPartBase_i::NodeRg& guard,
            const std::string&               ifc,
            const std::string&               module
        ) const throw (OsbCorbaException);

        const std::string& ifc() const;
    };                                  // class AnPart_i

    // *****************************************************************
    // class AnPartWriter_i
    class AnPartWriter_i :
        public virtual POA_corba::pcat::pp::AnPartWriter,
        public virtual ProductPartWriter_i,
        public virtual AnPartBase_i
    {
    public:
        static const std::string IFC;

        AnPartWriter_i(
            ProductWriter_i&      prod,
            OSB_LIB::ProductNode& node,
            OSB_LIB::AnItem&      item
        );

    private:
        OSB_LIB::AnItem& item_;

    private:                        // required by AnPartBase_i
        const std::string& ifc() const;

    private:                        // required by ProductPartWriter_i
        virtual OSB_LIB::ProductItem* pItem();
        virtual const OSB_LIB::ProductItem* pItem() const;

        virtual const OSB_LIB::AnItem* getAnItem(
            const ProductPartBase_i::NodeRg& guard,
            const std::string&               ifc,
            const std::string&               module
        ) const throw (OsbCorbaException);
    };

    // *****************************************************************
    // class IpGroupPartBase_i
    class IpGroupPartBase_i :
        public virtual POA_corba::pcat::pp::IpGroupPart,
        public virtual ProductPartBase_i
    {

    private:
        virtual const OSB_LIB::IpGroupItem* getIpGroupItem(
            const ProductPartBase_i::NodeRg& guard,
            const std::string&               ifc,
            const std::string&               module
        ) const throw (OsbCorbaException) = 0;
    };

    // *****************************************************************
    // class IpGroupPart_i
    class IpGroupPart_i :
        public virtual IpGroupPartBase_i,
        public virtual ProductPart_i
    {
    public:
        static const std::string IFC;

        IpGroupPart_i(
                  Product_i& pd,
            const NodeOid&   pnId,
            const ItemOid&   piId
        );

    private:
        virtual const OSB_LIB::IpGroupItem* getIpGroupItem(
            const ProductPartBase_i::NodeRg& guard,
            const std::string&               ifc,
            const std::string&               module
        ) const throw (OsbCorbaException);

        const std::string& ifc() const;
    };                                  // class IpGroupPart_i

    // *****************************************************************
    // class IpGroupPartWriter_i
    class IpGroupPartWriter_i :
        public virtual POA_corba::pcat::pp::IpGroupPartWriter,
        public virtual ProductPartWriter_i,
        public virtual IpGroupPartBase_i
    {
    public:
        static const std::string IFC;

        IpGroupPartWriter_i(
            ProductWriter_i&      prod,
            OSB_LIB::ProductNode& node,
            OSB_LIB::IpGroupItem& item
        );

    private:
        OSB_LIB::IpGroupItem& item_;

    private:                        // required by IpGroupPartBase_i
        const std::string& ifc() const;

    private:                        // required by ProductPartWriter_i
        virtual OSB_LIB::ProductItem* pItem();
        virtual const OSB_LIB::ProductItem* pItem() const;

        virtual const OSB_LIB::IpGroupItem* getIpGroupItem(
            const ProductPartBase_i::NodeRg& guard,
            const std::string&               ifc,
            const std::string&               module
        ) const throw (OsbCorbaException);
    };                                  // class IpGroupPartWriter_i

    // *****************************************************************
    // class TrunkPartBase_i
    class TrunkPartBase_i :
        public virtual POA_corba::pcat::pp::TrunkPart,
        public virtual ProductPartBase_i
    {
    private:
        virtual const OSB_LIB::TrunkItem* getTrunkItem(
            const ProductPartBase_i::NodeRg& guard,
            const std::string&               ifc,
            const std::string&               module
        ) const throw (OsbCorbaException) = 0;
    };                                  // class TrunkPartBase_i

    // *****************************************************************
    // class TrunkPart_i
    class TrunkPart_i :
        public virtual TrunkPartBase_i,
        public virtual ProductPart_i
    {
    public:
        static const std::string IFC;

        TrunkPart_i(
                  Product_i& pd,
            const NodeOid&   pnId,
            const ItemOid&   piId
        );

    private:
        virtual const OSB_LIB::TrunkItem* getTrunkItem(
            const ProductPartBase_i::NodeRg& guard,
            const std::string&               ifc,
            const std::string&               module
        ) const throw (OsbCorbaException);

        const std::string& ifc() const;
    };                                  // class TrunkPart_i

    // *****************************************************************
    // class TrunkPartWriter_i
    class TrunkPartWriter_i :
        public virtual POA_corba::pcat::pp::TrunkPartWriter,
        public virtual ProductPartWriter_i,
        public virtual TrunkPartBase_i
    {
    public:
        static const std::string IFC;

        TrunkPartWriter_i(
            ProductWriter_i&      prod,
            OSB_LIB::ProductNode& node,
            OSB_LIB::TrunkItem&   item
        );

    private:
        OSB_LIB::TrunkItem& item_;

    private:                        // required by TrunkPartBase_i
        const std::string& ifc() const;

    private:                        // required by ProductPartWriter_i
        virtual OSB_LIB::ProductItem* pItem();
        virtual const OSB_LIB::ProductItem* pItem() const;

        virtual const OSB_LIB::TrunkItem* getTrunkItem(
            const ProductPartBase_i::NodeRg& guard,
            const std::string&               ifc,
            const std::string&               module
        ) const throw (OsbCorbaException);
    };                                  // class TrunkPartWriter_i :

    // *****************************************************************
    // class PpType_i

    class PpType_i : public virtual POA_corba::pcat::pp::PpType
    {
    public:
        PpType_i(
            const OSB_LIB::ProductItemTypes::Info& info
        );

        PpTypeId id() throw ();
        Utf8String* name() throw ();
        Utf8String* desc() throw ();
        CORBA::Boolean isProductPart() throw();
    private:
        OSB_LIB::ProductItemTypes::Info info_;
    };
}                                       // namespace OSB_CORBA
#endif

---