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>
#include <string>
#include <vector>
 
namespace RTC
{
  class CorbaPort
    : public PortBase
  {
  public:
    explicit CorbaPort(const char* name);
 
    ~CorbaPort() override;
 
    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:
    ReturnCode_t
    publishInterfaces(ConnectorProfile& connector_profile) override;
 
    ReturnCode_t
    subscribeInterfaces(const ConnectorProfile& connector_profile) override;
 
    void
    unsubscribeInterfaces(const ConnectorProfile& connector_profile) override;
 
    //============================================================
    // Local operations
    //============================================================
    void activateInterfaces() override;
 
    void deactivateInterfaces() override;
 
  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 &)
          {
          }
        catch(...)
          {
          }
      }
      void deactivate()
      {
        try
          {
            m_poa->deactivate_object(m_oid);
          }
        catch(...)
          {
          }
      }
    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;
    };
 
    using CorbaProviderList = std::vector<CorbaProviderHolder>;
    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("")
      {
      }
      ~CorbaConsumerHolder();
      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;
    };
    using CorbaConsumerList = std::vector<CorbaConsumerHolder>;
    CorbaConsumerList m_consumers;
 
    // functors
    struct unsubscribe
    {
      explicit unsubscribe(CorbaConsumerList& consumers)
        : m_consumers(consumers)
      {
      }
 
      void operator()(const SDOPackage::NameValue& nv)
      {
        for (auto & consumer : m_consumers)
          {
            if (consumer.descriptor() == static_cast<const char*>(nv.name))
              {
                consumer.releaseObject();
              }
          }
      }
      CorbaConsumerList& m_consumers;
    };
  };
} // namespace RTC
#endif  // RTC_CORBAPORT_H