IceManager.h

Go to the documentation of this file.

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

#include <coil/Properties.h>
#include <coil/Mutex.h>
#include <coil/Guard.h>
#include <doil/IORB.h>
#include <doil/ServantFactory.h>
#include <doil/ice/Ice.h>
#include <doil/ice/IceServantBase.h>
#include <doil/ObjectManager.h>

namespace doil
{
namespace Ice
{
  class IceManager
    : public doil::IORB
  {
  public:
    static IceManager* init(coil::Properties prop)
      throw();

    static IceManager& 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();

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

    //------------------------------------------------------------
    // IceManager interfaces
    //------------------------------------------------------------
    doil::ImplBase* toImpl(::Ice::ObjectPrx obj)
      throw();

    ::Ice::ObjectPrx getReference(const char* name)
      throw();

    ::Ice::ObjectPrx toReference(doil::ImplBase* impl)
      throw();

    ::Ice::ObjectPrx toReference(doil::ServantBase* servant)
      throw();

    doil::ServantBase* toServant(::Ice::ObjectPrx obj)
      throw();

    //------------------------------------------------------------
    // Ice functions
    //------------------------------------------------------------
    ::Ice::CommunicatorPtr getORB()
      throw();

    ::Ice::ObjectAdapterPtr getAdapter()
      throw();

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

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

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

    // Ice communicator pointer
    ::Ice::CommunicatorPtr m_ice;

    // Ice object adapter pointer
    ::Ice::ObjectAdapterPtr m_adapter;

    // configuration properties
    coil::Properties m_config;


    // Entry class for active object map
    class Entry
    {
    public:
      Entry(ImplBase* impl, IceServantBase* servant,
            ::Ice::ObjectPrx objref)
        : impl_(impl), servant_(servant), objref_(objref)
      {
      }
      virtual ~Entry()
      {
      }
      ImplBase* impl_;
      IceServantBase* servant_;
      ::Ice::ObjectPrx 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
    typedef ObjectManager<const char*, Entry, EntryPred> ObjectMap;
    ObjectMap m_map;

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


    class find_by_obj
    {
    public:
      find_by_obj(::Ice::ObjectPrx obj) : result_(NULL), m_obj(obj) {};
      void operator()(IceManager::Entry* entry)
      {
        if (m_obj == (entry->objref_))
          {
            result_ = entry;
          }
      }
    public:
      Entry* result_;
    private:
      ::Ice::ObjectPrx m_obj;
    };


  };
};
};

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