InPortPushConnector.py

Go to the documentation of this file.

#!/usr/bin/env python
# -*- coding: euc-jp -*-




from omniORB import *
from omniORB import any

import OpenRTM_aist



class InPortPushConnector(OpenRTM_aist.InPortConnector):
  """
  """

  
  def __init__(self, info, provider, listeners, buffer = 0):
    OpenRTM_aist.InPortConnector.__init__(self, info, buffer)
    self._provider = provider
    self._listeners = listeners

    if buffer:
      self._deleteBuffer = True
    else:
      self._deleteBuffer = False

    if self._buffer == 0:
      self._buffer = self.createBuffer(info)

    if self._buffer == 0 or not self._provider:
      raise

    self._buffer.init(info.properties.getNode("buffer"))
    self._provider.init(info.properties)
    self._provider.setBuffer(self._buffer)
    self._provider.setListener(info, self._listeners)
    
    self.onConnect()
    return

    
  
  def __del__(self):
    return


  
  def read(self, data):
    self._rtcout.RTC_TRACE("read()")

    
    if not self._buffer:
      return self.PRECONDITION_NOT_MET

    if type(data) == list:
      ret = self._buffer.read(data)
    else:
      tmp = [data]
      ret = self._buffer.read(tmp)
            
            
    if ret == OpenRTM_aist.BufferStatus.BUFFER_OK:
      return self.PORT_OK

    elif ret == OpenRTM_aist.BufferStatus.BUFFER_EMPTY:
      return self.BUFFER_EMPTY

    elif ret == OpenRTM_aist.BufferStatus.TIMEOUT:
      return self.BUFFER_TIMEOUT

    elif ret == OpenRTM_aist.BufferStatus.PRECONDITION_NOT_MET:
      return self.PRECONDITION_NOT_MET
    
    return self.PORT_ERROR
        

  
  def disconnect(self):
    self._rtcout.RTC_TRACE("disconnect()")
    self.onDisconnect()
    # delete consumer
    if self._provider:
      cfactory = OpenRTM_aist.InPortProviderFactory.instance()
      cfactory.deleteObject(self._provider)

    self._provider = 0

    # delete buffer
    if self._buffer and self._deleteBuffer == True:
      bfactory = OpenRTM_aist.CdrBufferFactory.instance()
      bfactory.deleteObject(self._buffer)
    
    self._buffer = 0
    
    return self.PORT_OK

  
  def activate(self): # do nothing
    pass

  
  def deactivate(self):  # do nothing
    pass


  
  def createBuffer(self, profile):
    buf_type = profile.properties.getProperty("buffer_type","ring_buffer")
    return OpenRTM_aist.CdrBufferFactory.instance().createObject(buf_type)


  
  def write(self, data):
    if not self._dataType:
      return OpenRTM_aist.BufferStatus.PRECONDITION_NOT_MET

    _data = None
    # CDR -> (conversion) -> data
    if self._endian is not None:
      _data = cdrUnmarshal(any.to_any(self._dataType).typecode(),data,self._endian)

    else:
      self._rtcout.RTC_ERROR("unknown endian from connector")
      return OpenRTM_aist.BufferStatus.PRECONDITION_NOT_MET

    return self._buffer.write(_data)
        
    
  
  def onConnect(self):
    if self._listeners and self._profile:
      self._listeners.connector_[OpenRTM_aist.ConnectorListenerType.ON_CONNECT].notify(self._profile)
    return

  
  def onDisconnect(self):
    if self._listeners and self._profile:
      self._listeners.connector_[OpenRTM_aist.ConnectorListenerType.ON_DISCONNECT].notify(self._profile)
    return