InPortCorbaCdrConsumer.cpp

Go to the documentation of this file.

// -*- C++ -*-
#include <rtm/NVUtil.h>
#include <rtm/InPortCorbaCdrConsumer.h>

namespace RTC
{
  InPortCorbaCdrConsumer::InPortCorbaCdrConsumer(void)
    : rtclog("InPortCorbaCdrConsumer")
  {
  }
  
  InPortCorbaCdrConsumer::~InPortCorbaCdrConsumer(void)
  {
    RTC_PARANOID(("~InPortCorbaCdrConsumer()"));
  }

  void InPortCorbaCdrConsumer::init(coil::Properties& prop)
  {
    m_properties = prop;
  }

  InPortConsumer::ReturnCode InPortCorbaCdrConsumer::
  put(const cdrMemoryStream& data)
  {
    RTC_PARANOID(("put()"));

#ifndef ORB_IS_RTORB
    ::OpenRTM::CdrData tmp(data.bufSize(), data.bufSize(),
                           static_cast<CORBA::Octet*>(data.bufPtr()), 0);
#else // ORB_IS_RTORB
    OpenRTM_CdrData *cdrdata_tmp = new OpenRTM_CdrData();
    cdrdata_tmp->_buffer = 
      (CORBA_octet *)RtORB_alloc(data.bufSize(), "InPortCorbaCdrComsumer::put");
    memcpy(cdrdata_tmp->_buffer, data.bufPtr(), data.bufSize());
    cdrdata_tmp->_length = cdrdata_tmp->_maximum= data.bufSize();
    ::OpenRTM::CdrData tmp(cdrdata_tmp);
#endif // ORB_IS_RTORB
    try
      {
        // return code conversion
        // (IDL)OpenRTM::DataPort::ReturnCode_t -> DataPortStatus
        return convertReturnCode(_ptr()->put(tmp));
      }
    catch (...)
      {
        return CONNECTION_LOST;
      }
    return UNKNOWN_ERROR;
  }
  
  void InPortCorbaCdrConsumer::
  publishInterfaceProfile(SDOPackage::NVList& properties)
  {
    return;
  }

  bool InPortCorbaCdrConsumer::
  subscribeInterface(const SDOPackage::NVList& properties)
  {
    RTC_TRACE(("subscribeInterface()"));
    RTC_DEBUG_STR((NVUtil::toString(properties)));
    
    // getting InPort's ref from IOR string
    if (subscribeFromIor(properties)) { return true; }
    
    // getting InPort's ref from Object reference
    if (subscribeFromRef(properties)) { return true; }
    
    return false;;
  }
  
  void InPortCorbaCdrConsumer::
  unsubscribeInterface(const SDOPackage::NVList& properties)
  {
    RTC_TRACE(("unsubscribeInterface()"));
    RTC_DEBUG_STR((NVUtil::toString(properties)));
    
    if (unsubscribeFromIor(properties)) { return; }
    unsubscribeFromRef(properties);
  }
  
  //----------------------------------------------------------------------
  // private functions

  bool InPortCorbaCdrConsumer::
  subscribeFromIor(const SDOPackage::NVList& properties)
  {
    RTC_TRACE(("subscribeFromIor()"));
    
    CORBA::Long index;
    index = NVUtil::find_index(properties,
                               "dataport.corba_cdr.inport_ior");
    if (index < 0)
      {
        RTC_ERROR(("inport_ior not found"));
        return false;
      }
    
    const char* ior(0);
    if (!(properties[index].value >>= ior))
      {
        RTC_ERROR(("inport_ior has no string"));
        return false;
      }
    
    CORBA::ORB_ptr orb = RTC::Manager::instance().getORB();
    CORBA::Object_var obj = orb->string_to_object(ior);
    
    if (CORBA::is_nil(obj))
      {
        RTC_ERROR(("invalid IOR string has been passed"));
        return false;
      }
    
    if (!setObject(obj.in()))
      {
        RTC_WARN(("Setting object to consumer failed."));
        return false;
      }
    return true;
  }
  
  bool InPortCorbaCdrConsumer::
  subscribeFromRef(const SDOPackage::NVList& properties)
  {
    RTC_TRACE(("subscribeFromRef()"));
    CORBA::Long index;
    index = NVUtil::find_index(properties,
                               "dataport.corba_cdr.inport_ref");
    if (index < 0)
      {
        RTC_ERROR(("inport_ref not found"));
        return false;
      }
    
    CORBA::Object_var obj;
    if (!(properties[index].value >>= CORBA::Any::to_object(obj.out())))
      {
        RTC_ERROR(("prop[inport_ref] is not objref"));
        return true;
      }
    
    if (CORBA::is_nil(obj))
      {
        RTC_ERROR(("prop[inport_ref] is not objref"));
        return false;
      }
    
    if (!setObject(obj.in()))
      {
        RTC_ERROR(("Setting object to consumer failed."));
        return false;
      }
    return true;
  }
  
  bool InPortCorbaCdrConsumer::
  unsubscribeFromIor(const SDOPackage::NVList& properties)
  {
    RTC_TRACE(("unsubscribeFromIor()"));
    CORBA::Long index;
    index = NVUtil::find_index(properties,
                               "dataport.corba_cdr.inport_ior");
    if (index < 0)
      {
        RTC_ERROR(("inport_ior not found"));
        return false;
      }
    
    const char* ior;
    if (!(properties[index].value >>= ior))
      {
        RTC_ERROR(("prop[inport_ior] is not string"));
        return false;
      }
    
    CORBA::ORB_ptr orb = RTC::Manager::instance().getORB();
    CORBA::Object_var var = orb->string_to_object(ior);
    if (!(_ptr()->_is_equivalent(var)))
      {
        RTC_ERROR(("connector property inconsistency"));
        return false;
      }
    
    releaseObject();
    return true;
  }
  
  bool InPortCorbaCdrConsumer::
  unsubscribeFromRef(const SDOPackage::NVList& properties)
  {
    RTC_TRACE(("unsubscribeFromRef()"));
    CORBA::Long index;
    index = NVUtil::find_index(properties,
                               "dataport.corba_cdr.inport_ref");
    if (index < 0) { return false; }
    
    CORBA::Object_var obj;
    if (!(properties[index].value >>= CORBA::Any::to_object(obj.out()))) 
      {
        return false;
      }
    
    if (!(_ptr()->_is_equivalent(obj.in()))) { return false; }
    
    releaseObject();
    return true;
  }

  InPortConsumer::ReturnCode
  InPortCorbaCdrConsumer::convertReturnCode(OpenRTM::PortStatus ret)
  {
    switch (ret)
      {
      case OpenRTM::PORT_OK:
        return InPortConsumer::PORT_OK;
        break;
      case OpenRTM::PORT_ERROR:
        return InPortConsumer::PORT_ERROR;
        break;
      case OpenRTM::BUFFER_FULL:
        return InPortConsumer::SEND_FULL;
        break;
      case OpenRTM::BUFFER_TIMEOUT:
        return InPortConsumer::SEND_TIMEOUT;
        break;
      case OpenRTM::UNKNOWN_ERROR:
        return InPortConsumer::UNKNOWN_ERROR;
        break;
      default:
        return InPortConsumer::UNKNOWN_ERROR;
        break;
      }
    return InPortConsumer::UNKNOWN_ERROR;
  }
  
};     // namespace RTC

extern "C"
{ 
  void InPortCorbaCdrConsumerInit(void)
  {
    RTC::InPortConsumerFactory& factory(RTC::InPortConsumerFactory::instance());
    factory.addFactory("corba_cdr",
                       ::coil::Creator< ::RTC::InPortConsumer,
                                        ::RTC::InPortCorbaCdrConsumer>,
                       ::coil::Destructor< ::RTC::InPortConsumer,
                                           ::RTC::InPortCorbaCdrConsumer>);
  }
};