product_i.h

Go to the documentation of this file.

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

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.63 $

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

// *********************************************************************
// included header files
// + standard includes

// + local headers
#include "utf8string.h"

#include "productS.h"
#include "servantlocators.h"
#include "productcatalogue_i.h"
#include "productpart_i.h"

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

namespace OSB_LIB {
    class ProductCatalogue;
    class Product;
    class ProductNode;
    class ProductItem;

    class DescriptionItem;
    class CallingCardItem;
    class ServiceItem;
    class CreditItem;
    class TariffSystemItem;
    class ResourceItem;
}

namespace OSB_CORBA {

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

    class Product_i : public virtual POA_corba::pcat::pd::Product
    {
    public:

        static const std::string IFC;

        Product_i (
            ProductCatalogue_i&              pcati,
            const OSB_LIB::Product::Oid& pdId,
            PortableServer::POA_ptr          ppPoa
        );

        virtual ~Product_i();

        // Hint: needed by ProductPart
        const OSB_LIB::Product::Oid& pdId() const;


        virtual ProductId id()
            throw (CORBA::SystemException, OsbCorbaException);

        virtual Utf8String* name()
            throw (CORBA::SystemException, OsbCorbaException);

        virtual Utf8String* desc()
            throw (CORBA::SystemException, OsbCorbaException);

        virtual CfgStatus status()
           throw (CORBA::SystemException, OsbCorbaException);

        virtual Date startDate()
           throw (CORBA::SystemException, OsbCorbaException);

        virtual Date endDate()
           throw (CORBA::SystemException, OsbCorbaException);




        virtual ProductPart_ptr getPart(
            const ProductPartId& id
        ) throw (CORBA::SystemException, OsbCorbaException);

        virtual ProductPartSeq* getParts()
            throw (CORBA::SystemException);

        virtual ProductWriter_ptr getWriter()
            throw (CORBA::SystemException);

    protected:
        struct ServantListElement;
        friend struct ServantListElement;
        typedef OSB_LIB::Guard           Guard;
        typedef Locators::Key ServantKey;

        struct ServantListElement {
            ServantKey         key;
            ProductPartBase_i* servant;
            ServantListElement(
                ServantKey         k,
                ProductPartBase_i* s
            );
        };
        typedef std::list<ServantListElement> ServantList;

        virtual Guard lock();

        virtual ServantList::iterator retrieveServant (
            const OSB_LIB::ProductNode::Oid& nodeId
        );

    private:
        virtual OSB_LIB::PcatLockMgr::ProductRg lockProduct()
            throw (OsbCorbaException);
    public:
        void deleteServants();

        virtual ProductPart_ptr getPartServant(
            const OSB_LIB::Product::Oid& pId,
            const OSB_LIB::ProductNode&  node
        ) throw (OsbCorbaException);

    protected:
        ProductCatalogue_i&     pcati_;
        ServantList             servantList_;
        PortableServer::POA_ptr ppPoa_;

    private:
        const OSB_LIB::Product::Oid pdId_;
        OSB_LIB::Mutex              mutex_;
        OSB_LIB::MutexUnlock        unlock_;
    };

    // *****************************************************************
    // class ProductWriter_i
    class ProductWriter_i :
        public virtual POA_corba::pcat::pd::ProductWriter,
        public virtual Product_i
    {
    public:

        static const std::string IFC;

        ProductWriter_i (
                  Product_i*              prodi,
            const OSB_LIB::Product*       prod,
                  ProductCatalogue_i&     pcati,
                  PortableServer::POA_ptr ppPoa
        );

        virtual ~ProductWriter_i ();



        virtual void setName (const Utf8String& name)
            throw (CORBA::SystemException);

        virtual void setDesc (const Utf8String& desc)
            throw (CORBA::SystemException);

        virtual void setStartDate(const Date& start)
            throw (CORBA::SystemException, OsbCorbaException);

        virtual void setEndDate(const Date& end)
            throw (CORBA::SystemException, OsbCorbaException);




        virtual ProductPartWriter_ptr getWritablePart(
            const ProductPartId& id
        ) throw (CORBA::SystemException, OsbCorbaException);

        virtual ProductPartWriter_ptr addPart(
            const PpTypeId&                  pptypeid,
            const OSB_LIB::ProductNode::Oid& parentId
        ) throw (CORBA::SystemException, OsbCorbaException);

        virtual ProductPartWriter_ptr addPart(
            const PpTypeId& pptypeid
        ) throw (CORBA::SystemException, OsbCorbaException);

        virtual void removePart(const ProductPartId& id)
            throw (CORBA::SystemException, OsbCorbaException);

        virtual void commitChanges()
            throw (CORBA::SystemException, OsbCorbaException);


    private:
        ProductPartWriter_ptr getPartWriter(
            const ProductPartId& id
        ) throw (OsbCorbaException);

        ProductPartWriter_ptr createPartWriter(
            OSB_LIB::ProductNode& node
        ) throw (OsbCorbaException);

        virtual void checkDowncast(
                  OSB_LIB::ProductItem* item,
            const std::string&          module
        ) throw (OsbCorbaException);

        virtual OSB_LIB::PcatLockMgr::ProductRg lockProduct()
            throw(OSB_CORBA::OsbCorbaException);

    private:
        Product_i*              prodi_;
        OSB_LIB::Product*       prod_;
        PortableServer::POA_ptr writerPoa_;
};

} //namespace OSB_CORBA

#endif

---