OutPortSHMConsumer.h

[詳解]

// -*- 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 >
  {
  public:
 
    OutPortSHMConsumer();
 
    ~OutPortSHMConsumer() override; 
 
    void init(coil::Properties& prop) override;
 
    void setBuffer(CdrBufferBase* buffer) override;
 
    void setListener(ConnectorInfo& info,
                             ConnectorListenersBase* listeners) override;
 
    DataPortStatus get(ByteData& data) override;
 
    bool subscribeInterface(const SDOPackage::NVList& properties) override;
    
    void unsubscribeInterface(const SDOPackage::NVList& properties) override;
    bool setObject(CORBA::Object_ptr obj) override;
    
  private:
    DataPortStatus convertReturn(::OpenRTM::PortStatus status,
                                              ByteData& data);
 
    inline void onBufferWrite(ByteData& data)
    {
      m_listeners->notifyIn(ConnectorDataListenerType::ON_BUFFER_WRITE, m_profile, data);
    }
 
    inline void onBufferFull(ByteData& data)
    {
      m_listeners->notifyIn(ConnectorDataListenerType::ON_BUFFER_FULL, m_profile, data);
    }
 
    inline void onReceived(ByteData& data)
    {
      m_listeners->notifyIn(ConnectorDataListenerType::ON_RECEIVED, m_profile, data);
    }
 
    inline void onReceiverFull(ByteData& data)
    {
      m_listeners->notifyIn(ConnectorDataListenerType::ON_RECEIVER_FULL, m_profile, data);
    }
 
    inline void onSenderEmpty()
    {
      m_listeners->notify(ConnectorListenerType::ON_SENDER_EMPTY, m_profile);
    }
 
    inline void onSenderTimeout()
    {
      m_listeners->notify(ConnectorListenerType::ON_SENDER_TIMEOUT, m_profile);
    }
 
    inline void onSenderError()
    {
      m_listeners->notify(ConnectorListenerType::ON_SENDER_ERROR, m_profile);
    }
protected:
    mutable Logger rtclog;
    coil::Properties m_properties;
    std::mutex m_mutex;
    std::string m_shm_address;
    SharedMemoryPort m_shmem;
    int m_memory_size;
    bool m_endian;
 
    CdrBufferBase* m_buffer;
    ConnectorListenersBase* m_listeners{nullptr};
    ConnectorInfo m_profile;
  };
} // namespace RTC
 
extern "C"
{
  void OutPortSHMConsumerInit(void);
}
 
#endif // RTC_OUTPORTSHMCONSUMER_H