PublisherFlush.py

Go to the documentation of this file.

#!/usr/bin/env python
# -*- coding: euc-jp -*-
 
 
 
 
import OpenRTM_aist
 
 
 
class PublisherFlush(OpenRTM_aist.PublisherBase):
  """
  """
 
 
 
  
  def __init__(self):
    self._rtcout = OpenRTM_aist.Manager.instance().getLogbuf("PublisherFlush")
    self._consumer  = None
    self._active    = False
    self._profile   = None # ConnectorInfo
    self._listeners = None # ConnectorListeners
    self._retcode   = self.PORT_OK
 
  
  def __del__(self):
    # "consumer" should be deleted in the Connector
    self._rtcout.RTC_TRACE("~PublisherFlush()")
    self._consumer = None
    return
 
  
  def init(self, prop):
    self._rtcout.RTC_TRACE("init()")
    return self.PORT_OK;
 
  
  def setConsumer(self, consumer):
    self._rtcout.RTC_TRACE("setConsumer()")
    if not consumer:
      return self.INVALID_ARGS
 
    self._consumer = consumer
 
    return self.PORT_OK
 
  
  def setBuffer(self, buffer):
    self._rtcout.RTC_TRACE("setBuffer()")
    return self.PORT_OK
 
  
  def setListener(self, info, listeners):
    self._rtcout.RTC_TRACE("setListeners()")
    
    if not listeners:
      self._rtcout.RTC_ERROR("setListeners(listeners == 0): invalid argument")
      return self.INVALID_ARGS
 
    self._profile = info
    self._listeners = listeners
 
    return self.PORT_OK
 
  
  def write(self, data, sec, usec):
    self._rtcout.RTC_PARANOID("write()")
    if not self._consumer or not self._listeners:
      return self.PRECONDITION_NOT_MET
 
    if self._retcode == self.CONNECTION_LOST:
      self._rtcout.RTC_DEBUG("write(): connection lost.")
      return self._retcode
 
    self.onSend(data)
 
    self._retcode = self._consumer.put(data)
 
    if self._retcode == self.PORT_OK:
      self.onReceived(data)
      return self._retcode
    elif self._retcode == self.PORT_ERROR:
      self.onReceiverError(data)
      return self._retcode
    elif self._retcode == self.SEND_FULL:
      self.onReceiverFull(data)
      return self._retcode
    elif self._retcode == self.SEND_TIMEOUT:
      self.onReceiverTimeout(data)
      return self._retcode
    elif self._retcode == self.CONNECTION_LOST:
      self.onReceiverTimeout(data)
      return self._retcode
    elif self._retcode == self.UNKNOWN_ERROR:
      self.onReceiverError(data)
      return self._retcode
    else:
      self.onReceiverError(data)
      return self._retcode
 
    return self._retcode
 
 
  
  def isActive(self):
    return self._active
 
 
  
  def activate(self):
    if self._active:
      return self.PRECONDITION_NOT_MET
 
    self._active = True
 
    return self.PORT_OK
 
  
  def deactivate(self):
    if not self._active:
      return self.PRECONDITION_NOT_MET
 
    self._active = False
 
    return self.PORT_OK
 
  
  def onSend(self, data):
    if self._listeners is not None and self._profile is not None:
      self._listeners.connectorData_[OpenRTM_aist.ConnectorDataListenerType.ON_SEND].notify(self._profile, data)
    return
 
  
  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
 
  
  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 onReceiverTimeout(self, data):
    if self._listeners is not None and self._profile is not None:
      self._listeners.connectorData_[OpenRTM_aist.ConnectorDataListenerType.ON_RECEIVER_TIMEOUT].notify(self._profile, data)
    return
 
  
  def onReceiverError(self, data):
    if self._listeners is not None and self._profile is not None:
      self._listeners.connectorData_[OpenRTM_aist.ConnectorDataListenerType.ON_RECEIVER_ERROR].notify(self._profile, data)
    return
  
 
def PublisherFlushInit():
  OpenRTM_aist.PublisherFactory.instance().addFactory("flush",
                                                      OpenRTM_aist.PublisherFlush,
                                                      OpenRTM_aist.Delete)