OutPort.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



def setTimestamp(data):
  # set timestamp
  tm = OpenRTM_aist.Time()
  data.tm.sec  = tm.sec
  data.tm.nsec = tm.usec * 1000



class OutPort(OpenRTM_aist.OutPortBase):
  """
  """



  
  def __init__(self, name, value, buffer=None):
    OpenRTM_aist.OutPortBase.__init__(self, name, OpenRTM_aist.toTypename(value))
    self._value          = value
    #self._timeoutTick    = 1000 # timeout tick: 1ms
    #self._writeBlock     = False
    #self._writeTimeout   = 0
    self._OnWrite        = None
    self._OnWriteConvert = None
    #self._OnOverflow     = None
    #self._OnUnderflow    = None
    #self._OnConnect      = None
    #self._OnDisconnect   = None
    

  def __del__(self, OutPortBase=OpenRTM_aist.OutPortBase):
    OutPortBase.__del__(self)
    return

  
  def write(self, value=None):
    if not value:
      value=self._value

    
    if self._OnWrite:
      self._OnWrite(value)

    # check number of connectors
    conn_size = len(self._connectors)
    if not conn_size > 0:
      return True
  
    # set timestamp
    #tm = Time()
    #value.tm.sec  = tm.sec
    #value.tm.nsec = tm.usec * 1000

    #tm_pre = Time()

    if self._OnWriteConvert:
      value = self._OnWriteConvert(value)
      
    result = True

    guard = OpenRTM_aist.ScopedLock(self._connector_mutex)
    for con in self._connectors:
      ret = con.write(value)
      if ret != self.PORT_OK:
        result = False
        if ret == self.CONNECTION_LOST:
          self.disconnect(con.id())

    return result


  


  


  
  def setOnWrite(self, on_write):
    self._OnWrite = on_write


  
  def setOnWriteConvert(self, on_wconvert):
    self._OnWriteConvert = on_wconvert


  
  def getPortDataType(self):
    val = any.to_any(self._value)
    return str(val.typecode().name())



  class subscribe:
    def __init__(self, prof, subs = None):
      if subs:
        self._prof = subs._prof
        self._consumer = subs._consumer
        return

      self._prof = prof
      self._consumer = None
      

    def __call__(self, cons):
      if cons.subscribeInterface(self._prof.properties):
        self._consumer = cons