InPort.h

Go to the documentation of this file.

// -*- C++ -*-
#ifndef RTC_INPORT_H
#define RTC_INPORT_H

#include <string>
#include <vector>
#include <iostream>

#include <coil/TimeValue.h>
#include <coil/Time.h>
#include <coil/OS.h>

#include <rtm/RTC.h>
#include <rtm/Typename.h>
#include <rtm/InPortBase.h>
#include <rtm/CdrBufferBase.h>
#include <rtm/PortCallback.h>
#include <rtm/InPortConnector.h>

namespace RTC
{
  template <class DataType>
  class InPort
    : public InPortBase
  {
  public:
    DATAPORTSTATUS_ENUM
    InPort(const char* name, DataType& value,
           int bufsize=64, 
           bool read_block = false, bool write_block = false,
           int read_timeout = 0, int write_timeout = 0)
#if defined(__GNUC__) && (__GNUC__ <= 3 && __GNUC_MINOR__ <= 3) 
      : InPortBase(name, ::CORBA_Util::toRepositoryIdOfStruct<DataType>()),
#else
      : InPortBase(name, ::CORBA_Util::toRepositoryId<DataType>()),
#endif
        m_name(name), m_value(value),
        m_OnRead(NULL),  m_OnReadConvert(NULL)
    {
    }
    
    virtual ~InPort(void){};

    virtual const char* name()
    {
      return m_name.c_str();
    }

    
    virtual bool isNew()
    {
      RTC_TRACE(("isNew()"));

      // In single-buffer mode, all connectors share the same buffer. This
      // means that we only need to read from the first connector to get data
      // received by any connector.
      int r(0);
      {
        Guard guard(m_connectorsMutex);
        if (m_connectors.size() == 0)
          {
            RTC_DEBUG(("no connectors"));
            return false;
          }
        r = m_connectors[0]->getBuffer()->readable();
      }
      
      if (r > 0)
        {
          RTC_DEBUG(("isNew() = true, readable data: %d", r));
          return true;
        }
      
      RTC_DEBUG(("isNew() = false, no readable data"));
      return false;
    }

    virtual bool isEmpty()
    {
      RTC_TRACE(("isEmpty()"));
      int r(0);

      {
        Guard guard(m_connectorsMutex);
        if (m_connectors.size() == 0)
          {
            RTC_DEBUG(("no connectors"));
            return true;
          }
        // In single-buffer mode, all connectors share the same buffer. This
        // means that we only need to read from the first connector to get data
        // received by any connector.
        r = m_connectors[0]->getBuffer()->readable();
      }

      if (r == 0)
        {
          RTC_DEBUG(("isEmpty() = true, buffer is empty"));
          return true;
        }
      
      RTC_DEBUG(("isEmpty() = false, data exists in the buffer"));
      return false;
    }

    bool read()
    {
      RTC_TRACE(("DataType read()"));

      if (m_OnRead != NULL) 
        {
          (*m_OnRead)();
          RTC_TRACE(("OnRead called"));
        }

      cdrMemoryStream cdr;
      ReturnCode ret;
      {
        Guard guard(m_connectorsMutex);
        if (m_connectors.size() == 0)
          {
            RTC_DEBUG(("no connectors"));
            return false;
          }
        
        // In single-buffer mode, all connectors share the same buffer. This
        // means that we only need to read from the first connector to get data
        // received by any connector.
        ret = m_connectors[0]->read(cdr);
      }
      if (ret == PORT_OK)
        {
          RTC_DEBUG(("data read succeeded"));
          m_value <<= cdr;
          if (m_OnReadConvert != 0) 
            {
              m_value = (*m_OnReadConvert)(m_value);
              RTC_DEBUG(("OnReadConvert called"));
              return true;
            }
          return true;
        }
      else if (ret == BUFFER_EMPTY)
        {
          RTC_WARN(("buffer empty"));
          return false;
        }
      else if (ret == BUFFER_TIMEOUT)
        {
          RTC_WARN(("buffer read timeout"));
          return false;
        }
      RTC_ERROR(("unknown retern value from buffer.read()"));
      return false;
    }
    

    virtual void update()
    {
      this->read();
    };
    
    void operator>>(DataType& rhs)
    {
      this->read();
      rhs = m_value;
      return;
    }
    
    inline void setOnRead(OnRead<DataType>* on_read)
    {
      m_OnRead = on_read;
    }
    
    inline void setOnReadConvert(OnReadConvert<DataType>* on_rconvert)
    {
      m_OnReadConvert = on_rconvert;
    }
    
  private:
    std::string m_typename;
    std::string m_name;
    
    DataType& m_value;
    
    OnRead<DataType>* m_OnRead;
    
    OnReadConvert<DataType>* m_OnReadConvert;
   
  };
}; // End of namesepace RTM

#endif // RTC_INPORT_H