CORBAManager.h

Go to the documentation of this file.

// -*- C++ -*-
#ifndef DOIL_CORBA_CORBAMANAGER_H
#define DOIL_CORBA_CORBAMANAGER_H

#include <coil/Properties.h>
#include <coil/Mutex.h>
#include <coil/Guard.h>
#include <doil/IORB.h>
#include <doil/ServantFactory.h>
#include <doil/ProxyFactory.h>
#include <doil/corba/CORBA.h>
#include <doil/corba/CORBAServantBase.h>
#include <doil/corba/CORBAProxyBase.h>
#include <doil/ObjectManager.h>

namespace doil
{
namespace CORBA
{
  class CORBAManager
    : public doil::IORB
  {
  public:
    //
    //for unit tests
    //
//    doil::LocalBase* toLocal(::CORBA::Object_ptr& obj);
    doil::LocalBase* toLocal(::CORBA::Object_ptr& obj)
    {
        return NULL;
    }
    static CORBAManager* init(coil::Properties prop)
      throw();

    static CORBAManager& instance()
      throw();

    //------------------------------------------------------------
    // IORB interfaces
    //------------------------------------------------------------
    virtual const char* name()
      throw();

    virtual void run()
      throw();
    virtual void shutdown()
      throw();

    virtual ReturnCode_t
    registerFactory(const char* id,
                    doil::ServantNewFunc new_func,
                    doil::ServantDeleteFunc delete_func)
      throw();
#if 1
    //
    //for unit tests
    //
    virtual ReturnCode_t
    registerProxyFactory(const char* id,
                    doil::ProxyNewFunc new_func,
                    doil::ProxyDeleteFunc delete_func)
      throw();
#endif

    virtual ReturnCode_t activateObject(doil::ImplBase* impl)
      throw();

    virtual ReturnCode_t activateObject(doil::ImplBase* impl,
                                        doil::ServantBase* servant)
      throw();

    virtual ReturnCode_t deactivateObject(doil::ImplBase* impl)
      throw();

    virtual ReturnCode_t deactivateObject(const char* name)
      throw();

    virtual ImplBase* getImpl(const char* name)
      throw();

    virtual ImplBase* toImpl(doil::ServantBase* servant)
      throw();

    virtual ServantBase* getServant(const char* name)
      throw();

    virtual ServantBase* toServant(doil::ImplBase* lobj)
      throw();

    //------------------------------------------------------------
    // CORBAManager interfaces
    //------------------------------------------------------------
    doil::ImplBase* toImpl(::CORBA::Object_ptr obj)
      throw();

    ::CORBA::Object_ptr getReference(const char* name)
      throw();

    ::CORBA::Object_ptr toReference(doil::ImplBase* impl)
      throw();

    ::CORBA::Object_ptr toReference(doil::ServantBase* servant)
      throw();

    doil::ServantBase* toServant(::CORBA::Object_ptr obj)
      throw();

    //------------------------------------------------------------
    // CORBA functions
    //------------------------------------------------------------
    ::CORBA::ORB_ptr getORB()
      throw();

    ::PortableServer::POA_ptr getPOA()
      throw();

    ::PortableServer::POAManager_ptr getPOAManager()
      throw();

    //------------------------------------------------------------
    // protected functions:
    //------------------------------------------------------------
  protected:
    void initOrb(coil::Properties prop);

    std::string createORBOptions();
    
    //------------------------------------------------------------
    // private functions:
    //------------------------------------------------------------
  private:
    // private constructor
    CORBAManager(){}
    // private big three
    CORBAManager(const CORBAManager& cmgr);
    CORBAManager& operator=(const CORBAManager& rhs);
    ~CORBAManager() throw() {}

    //------------------------------------------------------------
    // private data:
    //------------------------------------------------------------
  private:
    // static data member for singleton
    static CORBAManager* manager;
    static coil::Mutex mutex;

    // CORBA ORB pointer
    ::CORBA::ORB_ptr m_orb;

    // default POA pointer
    ::PortableServer::POA_ptr m_poa;

    // POAManager pointer
    ::PortableServer::POAManager_ptr m_poaManager;

    // configuration properties
    coil::Properties m_config;


    // Entry class for active object map
    class Entry
    {
    public:
      Entry(ImplBase* impl, CORBAServantBase* servant,
            ::CORBA::Object_ptr objref)
        : impl_(impl), servant_(servant), objref_(objref)
      {
      }
      virtual ~Entry()
      {
      }
      ImplBase* impl_;
      CORBAServantBase* servant_;
      ::CORBA::Object_ptr objref_;
    };

    // Predicate class for active object map
    class EntryPred
    {
    public:
      EntryPred(const char* name)
        : m_name(name)
      {
      }
      EntryPred(Entry* entry)
        : m_name(entry->impl_->name())
      {
      }
      bool operator()(Entry* entry)
      {
        return m_name == entry->impl_->name();
      }
      std::string m_name;
    };
    
    // Active object map
    ObjectManager<const char*, Entry, EntryPred> m_map;



#if 0
    //
    // for unit test
    //
    // Entry class for active object map
    class EntryProxy
    {
    public:
      EntryProxy(ImplBase* impl, CORBAProxyBase* proxy,
            ::CORBA::Object_ptr objref)
        : impl_(impl), proxy_(proxy), objref_(objref)
      {
      }
      virtual ~EntryProxy()
      {
      }
      ImplBase* impl_;
      CORBAProxyBase* proxy_;
      ::CORBA::Object_ptr objref_;
    };

    //
    // for unit test
    //
    // Predicate class for active object map
    class EntryPredProxy
    {
    public:
      EntryPredProxy(const char* name)
        : m_name(name)
      {
      }
      EntryPredProxy(Entry* entry)
        : m_name(entry->impl_->name())
      {
      }
      bool operator()(Entry* entry)
      {
        return m_name == entry->impl_->name();
      }
      std::string m_name;
    };
    
    //
    // for unit test
    //
    // Active object map
    ObjectManager<const char*, EntryProxy, EntryPredProxy> m_map_proxy;
#endif

    // Predicate functor for Factory map
    class FactoryPred
    {
    public:
      FactoryPred(const char* id) : m_id(id) {}
      FactoryPred(ServantFactory* factory) : m_id(factory->id()) {}
      bool operator()(ServantFactory* factory)
      {
        return m_id == factory->id();
      }
      std::string m_id;
    };
    // Servant factory map
    ObjectManager<const char*, ServantFactory, FactoryPred> m_factory;

#if 1
    //
    // for unit test
    //
    // Predicate functor for Factory map
    class ProxyFactoryPred
    {
    public:
      ProxyFactoryPred(const char* id) : m_id(id) {}
      ProxyFactoryPred(ProxyFactory* factory) : m_id(factory->id()) {}
      bool operator()(ProxyFactory* factory)
      {
        return m_id == factory->id();
      }
      std::string m_id;
    };
    //
    // for unit test
    //
    // Servant factory map
    ObjectManager<const char*, ProxyFactory, ProxyFactoryPred> m_factory_proxy;
#endif
  };
};
};

extern "C"
{
  void DoilCORBAInit(coil::Properties& prop);
}
#endif // RTM_CORBA_CORBAMANAGER_H