OutPortSHMConsumer.h

Go to the documentation of this file.

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

#include <rtm/SharedMemoryPort.h>
#include <rtm/CorbaConsumer.h>
#include <rtm/OutPortConsumer.h>
#include <rtm/ConnectorListener.h>
#include <rtm/ConnectorBase.h>

namespace RTC
{
  class OutPortSHMConsumer
    : public OutPortConsumer,
      public CorbaConsumer< ::OpenRTM::PortSharedMemory >
  {
    typedef coil::Guard<coil::Mutex> Guard;
  public:
    DATAPORTSTATUS_ENUM

    OutPortSHMConsumer();

    virtual ~OutPortSHMConsumer();

    virtual void init(coil::Properties& prop);

    virtual void setBuffer(CdrBufferBase* buffer);

    virtual void setListener(ConnectorInfo& info,
                             ConnectorListeners* listeners);

    virtual ReturnCode get(cdrMemoryStream& data);

    virtual bool subscribeInterface(const SDOPackage::NVList& properties);

    virtual void unsubscribeInterface(const SDOPackage::NVList& properties);
    virtual bool setObject(CORBA::Object_ptr obj);

  private:
    OutPortConsumer::ReturnCode convertReturn(::OpenRTM::PortStatus status,
                                              cdrMemoryStream& data);

    inline void onBufferWrite(cdrMemoryStream& data)
    {
      m_listeners->
        connectorData_[ON_BUFFER_WRITE].notify(m_profile, data);
    }

    inline void onBufferFull(cdrMemoryStream& data)
    {
      m_listeners->
        connectorData_[ON_BUFFER_FULL].notify(m_profile, data);
    }

    inline void onReceived(cdrMemoryStream& data)
    {
      m_listeners->
        connectorData_[ON_RECEIVED].notify(m_profile, data);
    }

    inline void onReceiverFull(cdrMemoryStream& data)
    {
      m_listeners->
        connectorData_[ON_RECEIVER_FULL].notify(m_profile, data);
    }

    inline void onSenderEmpty()
    {
      m_listeners->
        connector_[ON_SENDER_EMPTY].notify(m_profile);
    }

    inline void onSenderTimeout()
    {
      m_listeners->
        connector_[ON_SENDER_TIMEOUT].notify(m_profile);
    }

    inline void onSenderError()
    {
      m_listeners->
        connector_[ON_SENDER_ERROR].notify(m_profile);
    }
protected:
    //    RTC::OutPortCdr_var m_outport;
    coil::Mutex m_mutex;
    mutable Logger rtclog;

    SharedMemoryPort m_shmem;

    CdrBufferBase* m_buffer;
    ConnectorListeners* m_listeners;
    ConnectorInfo m_profile;
  };
};     // namespace RTC

extern "C"
{
  void OutPortSHMConsumerInit(void);
};

#endif // RTC_OUTPORTSHMCONSUMER_H