OutPortCorbaCdrConsumer.py

Go to the documentation of this file.

#!/usr/bin/env python
# -*- coding: euc-jp -*-
 
 
 
 
import sys
from omniORB import any
import OpenRTM_aist
import OpenRTM
 
 
class OutPortCorbaCdrConsumer(OpenRTM_aist.OutPortConsumer,OpenRTM_aist.CorbaConsumer):
  """
  """
 
  
  def __init__(self):
    OpenRTM_aist.CorbaConsumer.__init__(self)
    self._rtcout = OpenRTM_aist.Manager.instance().getLogbuf("OutPortCorbaCdrConsumer")
    self._buffer = None
    self._profile = None
    self._listeners = None
    return
 
  
  def __del__(self, CorbaConsumer=OpenRTM_aist.CorbaConsumer):
    self._rtcout.RTC_PARANOID("~OutPortCorbaCdrConsumer()")
    CorbaConsumer.__del__(self)
    pass
 
 
  
  def init(self, prop):
    self._rtcout.RTC_TRACE("init()")
    return
 
 
  
  def setBuffer(self, buffer):
    self._rtcout.RTC_TRACE("setBuffer()")
    self._buffer = buffer
    return
 
 
  # void OutPortCorbaCdrConsumer::setListener(ConnectorInfo& info,
  #                                           ConnectorListeners* listeners)
  def setListener(self, info, listeners):
    self._rtcout.RTC_TRACE("setListener()")
    self._listeners = listeners
    self._profile = info
    return
 
 
  
  def get(self, data):
    self._rtcout.RTC_PARANOID("get()")
 
    try:
      outportcdr = self.getObject()._narrow(OpenRTM.OutPortCdr)
      ret,cdr_data = outportcdr.get()
      
      if ret == OpenRTM.PORT_OK:
        self._rtcout.RTC_DEBUG("get() successful")
        data[0] = cdr_data
        self.onReceived(data[0])
        self.onBufferWrite(data[0])
        
        if self._buffer.full():
          self._rtcout.RTC_INFO("InPort buffer is full.")
          self.onBufferFull(data[0])
          self.onReceiverFull(data[0])
          
        self._buffer.put(data[0])
        self._buffer.advanceWptr()
        self._buffer.advanceRptr()
 
        return self.PORT_OK
      return self.convertReturn(ret,data[0])
 
    except:
      self._rtcout.RTC_WARN("Exception caught from OutPort.get().")
      self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception())
      return self.CONNECTION_LOST
 
    self._rtcout.RTC_ERROR("get(): Never comes here.")
    return self.UNKNOWN_ERROR
 
 
  
  def subscribeInterface(self, properties):
    self._rtcout.RTC_TRACE("subscribeInterface()")
    index = OpenRTM_aist.NVUtil.find_index(properties,"dataport.corba_cdr.outport_ior")
        
    if index < 0:
      self._rtcout.RTC_DEBUG("dataport.corba_cdr.outport_ior not found.")
      return False
 
    if OpenRTM_aist.NVUtil.isString(properties,"dataport.corba_cdr.outport_ior"):
      self._rtcout.RTC_DEBUG("dataport.corba_cdr.outport_ior found.")
      ior = ""
      try:
        ior = any.from_any(properties[index].value, keep_structs=True)
      except:
        self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception())
            
      orb = OpenRTM_aist.Manager.instance().getORB()
      obj = orb.string_to_object(ior)
      ret = self.setObject(obj)
      if ret:
        self._rtcout.RTC_DEBUG("CorbaConsumer was set successfully.")
      else:
        self._rtcout.RTC_ERROR("Invalid object reference.")
        
      return ret
 
    return False
 
 
  
  def unsubscribeInterface(self, properties):
    self._rtcout.RTC_TRACE("unsubscribeInterface()")
    index = OpenRTM_aist.NVUtil.find_index(properties,
                                           "dataport.corba_cdr.outport_ref")
    if index < 0:
      self._rtcout.RTC_DEBUG("dataport.corba_cdr.outport_ior not found.")
      return
    
    ior = ""
    try:
      ior = any.from_any(properties[index].value, keep_structs=True)
                
      if ior:
        self._rtcout.RTC_DEBUG("dataport.corba_cdr.outport_ior found.")
        orb = OpenRTM_aist.Manager.instance().getORB()
        obj = orb.string_to_object(ior)
        if self._ptr()._is_equivalent(obj):
          self.releaseObject()
          self._rtcout.RTC_DEBUG("CorbaConsumer's reference was released.")
          return
 
        self._rtcout.RTC_ERROR("hmm. Inconsistent object reference.")
 
    except:
      self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception())
 
    return
 
 
  
  def convertReturn(self, status, data):
    if status == OpenRTM.PORT_OK:
      # never comes here
      return self.PORT_OK
 
    elif status == OpenRTM.PORT_ERROR:
      self.onSenderError()
      return self.PORT_ERROR
 
    elif status == OpenRTM.BUFFER_FULL:
      # never comes here
      return self.BUFFER_FULL
 
    elif status == OpenRTM.BUFFER_EMPTY:
      self.onSenderEmpty()
      return self.BUFFER_EMPTY
 
    elif status == OpenRTM.BUFFER_TIMEOUT:
      self.onSenderTimeout()
      return self.BUFFER_TIMEOUT
 
    elif status == OpenRTM.UNKNOWN_ERROR:
      self.onSenderError()
      return self.UNKNOWN_ERROR
 
    else:
      self.onSenderError()
      return self.UNKNOWN_ERROR
 
    self.onSenderError()
    return self.UNKNOWN_ERROR
 
    
  
  def onBufferWrite(self, data):
    if self._listeners is not None and self._profile is not None:
      self._listeners.connectorData_[OpenRTM_aist.ConnectorDataListenerType.ON_BUFFER_WRITE].notify(self._profile, data)
 
    return
 
 
  # inline void onBufferFull(const cdrMemoryStream& data)
  def onBufferFull(self, data):
    if self._listeners is not None and self._profile is not None:
      self._listeners.connectorData_[OpenRTM_aist.ConnectorDataListenerType.ON_BUFFER_FULL].notify(self._profile, data)
 
    return
 
 
  # inline void onReceived(const cdrMemoryStream& data)
  def onReceived(self, data):
    if self._listeners is not None and self._profile is not None:
      self._listeners.connectorData_[OpenRTM_aist.ConnectorDataListenerType.ON_RECEIVED].notify(self._profile, data)
 
    return
 
 
  # inline void onReceiverFull(const cdrMemoryStream& data)
  def onReceiverFull(self, data):
    if self._listeners is not None and self._profile is not None:
      self._listeners.connectorData_[OpenRTM_aist.ConnectorDataListenerType.ON_RECEIVER_FULL].notify(self._profile, data)
 
    return
 
 
  
  def onSenderEmpty(self):
    if self._listeners is not None and self._profile is not None:
      self._listeners.connector_[OpenRTM_aist.ConnectorListenerType.ON_SENDER_EMPTY].notify(self._profile)
 
    return
 
 
  # inline void onSenderTimeout()
  def onSenderTimeout(self):
    if self._listeners is not None and self._profile is not None:
      self._listeners.connector_[OpenRTM_aist.ConnectorListenerType.ON_SENDER_TIMEOUT].notify(self._profile)
 
    return
 
      
  # inline void onSenderError()
  def onSenderError(self):
    if self._listeners is not None and self._profile is not None:
      self._listeners.connector_[OpenRTM_aist.ConnectorListenerType.ON_SENDER_ERROR].notify(self._profile)
 
    return
 
 
def OutPortCorbaCdrConsumerInit():
  factory = OpenRTM_aist.OutPortConsumerFactory.instance()
  factory.addFactory("corba_cdr",
                     OpenRTM_aist.OutPortCorbaCdrConsumer,
                     OpenRTM_aist.Delete)
  return