CorbaPort.h

Go to the documentation of this file.

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

#include <rtm/PortBase.h>
#include <rtm/CorbaConsumer.h>
#include <rtm/NVUtil.h>
#include <list>

namespace RTC
{
  class CorbaPort
    : public PortBase
  {
  public:
    CorbaPort(const char* name);
    
    virtual ~CorbaPort(void);
    
    void init(coil::Properties& prop);

    bool registerProvider(const char* instance_name, const char* type_name,
                          PortableServer::RefCountServantBase& provider);
    
    bool registerConsumer(const char* instance_name, const char* type_name,
                          CorbaConsumerBase& consumer);
    
  protected:
    virtual ReturnCode_t
    publishInterfaces(ConnectorProfile& connector_profile);
    
    virtual ReturnCode_t
    subscribeInterfaces(const ConnectorProfile& connector_profile);
    
    virtual void
    unsubscribeInterfaces(const ConnectorProfile& connector_profile);

    //============================================================
    // Local operations
    //============================================================
    virtual void activateInterfaces();

    virtual void deactivateInterfaces();

  protected:
    coil::Properties m_properties;
    
  private:
    class CorbaConsumerHolder;
    virtual bool findProvider(const NVList& nv, CorbaConsumerHolder& cons,
                              std::string& iorstr);

    virtual bool findProviderOld(const NVList&nv, CorbaConsumerHolder& cons,
                                 std::string& iorstr);

    bool setObject(const std::string& ior, CorbaConsumerHolder& cons);

    bool releaseObject(const std::string& ior, CorbaConsumerHolder& cons);

  private:
    class CorbaProviderHolder
    {
    public:
      CorbaProviderHolder(const char* type_name,
                          const char* instance_name,
                          PortableServer::RefCountServantBase* servant)
        : m_typeName(type_name),
          m_instanceName(instance_name),
          m_servant(servant),
          m_ior()
      {  
#ifndef ORB_IS_RTORB
#ifdef ORB_IS_OMNIORB
        m_poa = ::RTC::Manager::instance().getShortCutPOA();
        m_poa->activate_object(m_servant);
#else
        m_poa = ::RTC::Manager::instance().getPOA();
#endif
        m_oid = m_poa->servant_to_id(m_servant);
        try
          {
            m_poa->activate_object_with_id(m_oid, m_servant);
          }
        catch(...)
          {
            ;
          }
        CORBA::Object_var obj;
        obj = m_poa->id_to_reference(m_oid);
        CORBA::ORB_var orb = Manager::instance().getORB();
        CORBA::String_var ior_var = orb->object_to_string(obj);
        m_ior = ior_var;
        deactivate();
#else // ORB_IS_RTORB
        // why RtORB does not activate object by __this()
        // and does not deactivate at the end of ctor?
        PortableServer::POA_var poa = ::RTC::Manager::instance().getPOA();
        m_oid = poa->servant_to_id(m_servant);
        CORBA::Object_var obj;
        obj = CORBA::Object_var(m_servant->__this());
        CORBA::ORB_var orb = Manager::instance().getORB();
        CORBA::String_var ior_var = orb->object_to_string(obj);
        m_ior = ior_var;
#endif // ORB_IS_RTORB
      }
      virtual ~CorbaProviderHolder()
      {
        deactivate();
      }
      std::string instanceName() { return m_instanceName; }
      std::string typeName() { return m_typeName; }
      std::string ior() { return m_ior; }
      std::string descriptor() { return m_typeName + "." + m_instanceName; }

      void activate()
      {
        try
          {
            m_poa->activate_object_with_id(m_oid, m_servant);
          }
        catch(const ::PortableServer::POA::ServantAlreadyActive &)
          {
            ; // do nothing
          }
        catch(...)
          {
            ; // do nothing
          }
      }
      void deactivate()
      {
        try
          {
            m_poa->deactivate_object(m_oid);
          }
        catch(...)
          {
            ; // do nothing
          }
      }
    private:
      std::string m_typeName;
      std::string m_instanceName;
      PortableServer::RefCountServantBase* m_servant;
      PortableServer::ObjectId_var m_oid;
      std::string m_ior;
      PortableServer::POA_var m_poa;
    };

    typedef std::vector<CorbaProviderHolder> CorbaProviderList;
    CorbaProviderList m_providers;

    class CorbaConsumerHolder
    {
    public:
      CorbaConsumerHolder(const char* type_name,
                          const char* instance_name,
                          CorbaConsumerBase* consumer)
        : m_typeName(type_name),
          m_instanceName(instance_name),
          m_consumer(consumer),
          m_ior("")
      {
      }
      std::string instanceName() { return m_instanceName; }
      std::string typeName() { return m_typeName; }
      std::string descriptor() { return m_typeName + "." + m_instanceName; }

      bool setObject(const char* ior)
      {
        m_ior = ior;
        CORBA::ORB_var orb = ::RTC::Manager::instance().getORB();
        CORBA::Object_var obj = orb->string_to_object(ior);
        if (CORBA::is_nil(obj))
          {
            return false;
          }

        return m_consumer->setObject(obj.in());
      }
      void releaseObject()
      {
        m_consumer->releaseObject();
      }
      const std::string& getIor()
      {
        return m_ior;
      }
    private:
      std::string m_typeName;
      std::string m_instanceName;
      CorbaConsumerBase* m_consumer;
      std::string m_ior;
    };
    typedef std::vector<CorbaConsumerHolder> CorbaConsumerList;
    CorbaConsumerList m_consumers;
    
    // functors
    struct unsubscribe
    {
      unsubscribe(CorbaConsumerList& consumers)
        : m_consumers(consumers)
      {
      }
      
      void operator()(const SDOPackage::NameValue& nv)
      {
        for (CorbaConsumerList::iterator it(m_consumers.begin());
             it != m_consumers.end(); ++it)
          {
            std::string name(nv.name);
            if (it->descriptor() == (const char*)nv.name)
              {
                it->releaseObject();
              }
          }
      }
      CorbaConsumerList& m_consumers;
    };
  };
};
#endif // RTC_CORBAPORT_H