EventPort.h

Go to the documentation of this file.

// -*- C++ -*-
#ifndef RTC_EVENTINPORT_H
#define RTC_EVENTINPORT_H
 
#include <string>
#include <vector>
#include <iostream>
 
#include <coil/OS.h>
#include <mutex>
 
#include <rtm/RTC.h>
#include <rtm/Typename.h>
#include <rtm/InPortBase.h>
#include <rtm/CdrBufferBase.h>
#include <rtm/PortCallback.h>
#include <rtm/InPortConnector.h>
#include <rtm/Timestamp.h>
#include <rtm/StaticFSM.h>
#include <rtm/RingBuffer.h>
#include <rtm/EventBase.h>
 
namespace RTC
{
 
 
  template <class FSM, class TOP, class R>
  class EventBinder0
    : public ConnectorDataListener, EventBinderBase0
  {
    USE_CONNLISTENER_STATUS;
  public:
    EventBinder0(FSM& fsm,
                 const char* event_name,
                 R (TOP::*handler)(),
                 RingBuffer<EventBase*> &buffer)
      : m_fsm(fsm), m_eventName(event_name), m_handler(handler), m_buffer(buffer) {}
 
    ~EventBinder0() override = default;
 
    ReturnCode operator()(ConnectorInfo& info,
                                  ByteData&  /*data*/, const std::string& /*marshalingtype*/) override
    {
      if (info.properties["fsm_event_name"] == m_eventName ||
          info.name == m_eventName)
        {
            m_buffer.write(new Event0(this));
          return NO_CHANGE;
        }
      return NO_CHANGE;
    }
 
    void run() override
    {
        
        m_fsm.dispatch(Macho::Event(m_handler));
    }
 
    FSM& m_fsm;
    std::string m_eventName;
    R (TOP::*m_handler)();
    RingBuffer<EventBase*> &m_buffer;
 
  };
 
  template <class FSM, class TOP, class R, class P0>
  class EventBinder1
    : public ConnectorDataListenerT<P0>, EventBinderBase1<P0>
  {
    USE_CONNLISTENER_STATUS;
  public:
    EventBinder1(FSM& fsm,
                 const char* event_name,
                 R (TOP::*handler)(P0),
                 RingBuffer<EventBase*> &buffer)
      : m_fsm(fsm), m_eventName(event_name), m_handler(handler), m_buffer(buffer) {}
 
    ~EventBinder1() override = default;
 
    ReturnCode operator()(ConnectorInfo& info, P0& data) override
    {
      if (info.properties["fsm_event_name"] == m_eventName ||
          info.name == m_eventName)
        {
            m_buffer.write(new Event1<P0>(this, data));
          return NO_CHANGE;
        }
      return NO_CHANGE;
    }
 
    void run(P0& data) override
    {
        m_fsm.dispatch(Macho::Event(m_handler, data));
    }
 
    FSM& m_fsm;
    std::string m_eventName;
    R (TOP::*m_handler)(P0);
    RingBuffer<EventBase*> &m_buffer;
  };
 
  class EventConnListener
      : public ConnectorListener
  {
      USE_CONNLISTENER_STATUS;
  public:
      EventConnListener(RingBuffer<EventBase*>&buffer, CdrBufferBase* m_thebuffer) :
          m_buffer(buffer), m_thebuffer(m_thebuffer) {}
      ~EventConnListener() override = default;
 
      ReturnCode operator()(ConnectorInfo& info) override
      {
          coil::Properties prop;
          prop["write.full_policy"] = "do_nothing";
          prop["read.empty_policy"] = "do_nothing";
          m_thebuffer->init(prop);
 
          coil::Properties prop_(info.properties.getNode("dataport.buffer"));
          prop_ << info.properties.getNode("inport.buffer");
 
          m_buffer.init(prop_);
 
 
          return NO_CHANGE;
      }
      RingBuffer<EventBase*>&m_buffer;
      CdrBufferBase *m_thebuffer;
  };
 
 
  template <class FsmType>
  class EventInPort
    : public InPortBase
  {
  public:
    EventInPort(const char* name, FsmType& fsm)
      : InPortBase(name, "any"),
      m_name(name), m_fsm(fsm), m_buffer(fsm.getBuffer())
    {
    }
 
    ~EventInPort() override;
 
    virtual const char* name()
    {
      return m_name.c_str();
    }
 
    void init(coil::Properties& prop) override
    {
        InPortBase::init(prop);
        this->addConnectorListener
            (ConnectorListenerType::ON_CONNECT,
            new EventConnListener(m_buffer, m_thebuffer));
    }
 
    template <class TOP, class R, class P0>
    void bindEvent(const char* name,
                   R (TOP::*handler)(P0))
    {
      this->addConnectorDataListener
        (ConnectorDataListenerType::ON_RECEIVED,
         new EventBinder1<FsmType, TOP, R, P0>(m_fsm, name, handler, m_buffer));
    }
    template <typename TOP, class R>
    void bindEvent(const char* name,
                   R (TOP::*handler)())
    {
      this->addConnectorDataListener
        (ConnectorDataListenerType::ON_RECEIVED,
         new EventBinder0<FsmType, TOP, R>(m_fsm, name, handler, m_buffer));
    }
    bool read(std::string  /*name*/="") override { return true; }
  private:
    std::string m_name;
    FsmType& m_fsm;
    RingBuffer<EventBase*> &m_buffer;
  };
 
  template <class FsmType>
  EventInPort<FsmType>::~EventInPort() = default;
} // namespace RTC
 
#endif // RTC_EVENTINPORT_H