PublisherFlush.h

[詳解]

// -*- C++ -*-
 
#ifndef RTC_PUBLISHERFLUSH_H
#define RTC_PUBLISHERFLUSH_H
 
#include <condition_variable>
#include <rtm/PublisherBase.h>
#include <rtm/SystemLogger.h>
#include <rtm/ConnectorBase.h>
#include <rtm/ConnectorListener.h>
 
namespace coil
{
  class Properties;
} // namespace coil
 
namespace RTC
{
  class InPortConsumer;

  class PublisherFlush
    : public PublisherBase
  {
  public:

    PublisherFlush();

    ~PublisherFlush() override;

    DataPortStatus init(coil::Properties& prop) override;

    DataPortStatus setConsumer(InPortConsumer* consumer) override;

    DataPortStatus setBuffer(CdrBufferBase* buffer) override;

    ::RTC::DataPortStatus
    setListener(ConnectorInfo& info,
                RTC::ConnectorListenersBase* listeners) override;

    DataPortStatus write(ByteDataStreamBase* data,
                     std::chrono::nanoseconds timeout
                     = std::chrono::nanoseconds(-1)) override;
    bool isActive() override;

    DataPortStatus activate() override;

    DataPortStatus deactivate() override;
 
  protected:
    inline void onSend(ByteData& data)
    {
      m_listeners->notifyOut(ConnectorDataListenerType::ON_SEND, m_profile, data);
    }

    inline void onReceived(ByteData& data)
    {
      m_listeners->notifyOut(ConnectorDataListenerType::ON_RECEIVED, m_profile, data);
    }

    inline void onReceiverFull(ByteData& data)
    {
      m_listeners->notifyOut(ConnectorDataListenerType::ON_RECEIVER_FULL, m_profile, data);
    }

    inline void onReceiverTimeout(ByteData& data)
    {
      m_listeners->notifyOut(ConnectorDataListenerType::ON_RECEIVER_TIMEOUT, m_profile, data);
    }

    inline void onReceiverError(ByteData& data)
    {
      m_listeners->notifyOut(ConnectorDataListenerType::ON_RECEIVER_ERROR, m_profile, data);
    }
 
  private:
    Logger rtclog{"PublisherFlush"};
    InPortConsumer* m_consumer{nullptr};
    ConnectorInfo m_profile;
    ConnectorListenersBase* m_listeners{nullptr};
    DataPortStatus m_retcode{DataPortStatus::PORT_OK};
    std::mutex m_retmutex;
    bool m_active{false};
    ByteData m_data;
  };
 
} // namespace RTC
 
extern "C"
{
  void PublisherFlushInit();
}
 
#endif  // RTC_PUBLISHERFLUSH_H