InPortConnector.h

[詳解]

// -*- C++ -*-
#ifndef RTC_INPORTCONNECTOR_H
#define RTC_INPORTCONNECTOR_H
 
#include <rtm/ConnectorListener.h>
#include <rtm/ConnectorBase.h>
#include <rtm/DirectOutPortBase.h>
#include <rtm/PortBase.h>
#include <rtm/ByteData.h>
 
 
namespace RTC
{
  class OutPortBase;
  class InPortConnector
    : public ConnectorBase
  {
  public:
    InPortConnector(ConnectorInfo& info,
                    ConnectorListenersBase* listeners,
                    CdrBufferBase* buffer);
 
    ~InPortConnector() override;
 
    const ConnectorInfo& profile() override;
 
    const char* id() override;
 
    const char* name() override;
 
    DataPortStatus disconnect() override = 0;
 
    CdrBufferBase* getBuffer() override;
 
    virtual DataPortStatus read(ByteDataStreamBase* data) = 0;
 
 
    template<class DataType>
    DataPortStatus read(DataType& data)
    {
      if(m_cdr == nullptr)
      {
        m_cdr = createSerializer<DataType>(m_marshaling_type);
      }
      ::RTC::ByteDataStream<DataType> *cdr = dynamic_cast<::RTC::ByteDataStream<DataType>*>(m_cdr);
        
        if (!cdr)
        {
            RTC_ERROR(("Can not find Marshalizer: %s", m_marshaling_type.c_str()));
            return DataPortStatus::PORT_ERROR;
        }
        cdr->isLittleEndian(isLittleEndian());
        DataPortStatus ret = read((ByteDataStreamBase*)cdr);
        if (ret == DataPortStatus::PORT_OK)
        {
            cdr->deserialize(data);
        }
        return ret;
    }
 
    virtual void setEndian(bool endian_type);
 
    virtual bool isLittleEndian();
 
    virtual BufferStatus write(ByteData &cdr);
 
 
    bool setOutPort(OutPortBase* directOutPort);
 
    template <typename DataType>
    bool getDirectData(DataType &data)
    {
        if (m_directOutPort == nullptr)
        {
            return false;
        }
        DirectOutPortBase<DataType>* outport;
        outport = dynamic_cast<DirectOutPortBase<DataType>*>(m_directOutPort->getDirectPort());
 
        if(outport)
        {
            if (outport->isEmpty())
            {
                m_listeners->notify(ConnectorListenerType::ON_BUFFER_EMPTY,
                                     m_profile);
                m_outPortListeners->notify(
                                  ConnectorListenerType::ON_SENDER_EMPTY,
                                  m_profile);
                RTC_PARANOID(("ON_BUFFER_EMPTY(InPort,OutPort), "
                    "ON_SENDER_EMPTY(InPort,OutPort) "
                    "callback called in direct mode."));
            }
            outport->read(data);
            m_outPortListeners->notifyOut(
                                  ConnectorDataListenerType::ON_BUFFER_READ,
                                  m_profile, data);
            RTC_TRACE(("ON_BUFFER_READ(OutPort), "));
            RTC_TRACE(("callback called in direct mode."));
            m_outPortListeners->notifyOut(ConnectorDataListenerType::ON_SEND,
                                          m_profile, data);
            RTC_TRACE(("ON_SEND(OutPort), "));
            RTC_TRACE(("callback called in direct mode."));
            m_listeners->notifyIn(ConnectorDataListenerType::ON_RECEIVED,
                                  m_profile, data);
            RTC_TRACE(("ON_RECEIVED(InPort), "));
            RTC_TRACE(("callback called in direct mode."));
            m_listeners->notifyIn(ConnectorDataListenerType::ON_SEND,
                                  m_profile, data);
            RTC_TRACE(("ON_BUFFER_WRITE(InPort), "));
            RTC_TRACE(("callback called in direct mode."));
 
 
            return true;
        }
        return false;
    }
 
    virtual void unsubscribeInterface(const coil::Properties& prop);
 
  protected:
    Logger rtclog;
    ConnectorInfo m_profile;
    ConnectorListenersBase* m_listeners;
    CdrBufferBase* m_buffer;
    bool m_littleEndian;
    ConnectorListenersBase* m_outPortListeners;
    PortBase* m_directOutPort;
 
    std::string m_marshaling_type;
 
    ByteDataStreamBase* m_cdr;
 
  };
} // namespace RTC
 
#endif  // RTC_INPORTCONNECTOR_H