OutPortConnector.h

[詳解]

// -*- C++ -*-
#ifndef RTC_OUTPORTCONNECTOR_H
#define RTC_OUTPORTCONNECTOR_H
 
#include <rtm/SystemLogger.h>
#include <rtm/ConnectorBase.h>
#include <rtm/ConnectorListener.h>
#include <rtm/DirectInPortBase.h>
#include <rtm/PortBase.h>
#include <rtm/CORBA_CdrMemoryStream.h>
#include <rtm/ByteData.h>
 
 
 
namespace RTC
{
  class InPortBase;
  class OutPortConnector
    : public ConnectorBase
  {
  public:
 
    OutPortConnector(ConnectorInfo& info, ConnectorListenersBase* listeners);
 
    ~OutPortConnector() override;
    const ConnectorInfo& profile() override;
 
    const char* id() override;
 
    const char* name() override;
 
    DataPortStatus disconnect() override = 0;
 
    CdrBufferBase* getBuffer() override = 0;
 
    virtual DataPortStatus write(ByteDataStreamBase* data) = 0;
 
    virtual void setEndian(bool endian_type);
 
    virtual bool isLittleEndian();
 
    template <class DataType>
    DataPortStatus write(DataType& data)
    {
 
      if (m_directInPort != nullptr)
        {
          DirectInPortBase<DataType>* inport = dynamic_cast<DirectInPortBase<DataType>*>(m_directInPort->getDirectPort());
          if(inport)
            {
              if (inport->isNew())
                {
                  // ON_BUFFER_OVERWRITE(In,Out), ON_RECEIVER_FULL(In,Out) callback
                  m_listeners->notifyOut(ConnectorDataListenerType::ON_BUFFER_OVERWRITE, m_profile, data);
                  m_inPortListeners->notifyIn(ConnectorDataListenerType::ON_BUFFER_OVERWRITE, m_profile, data);
                  m_listeners->notifyOut(ConnectorDataListenerType::ON_RECEIVER_FULL, m_profile, data);
                  m_inPortListeners->notifyIn(ConnectorDataListenerType::ON_RECEIVER_FULL, m_profile, data);
                  RTC_PARANOID(("ON_BUFFER_OVERWRITE(InPort,OutPort), "
                                "ON_RECEIVER_FULL(InPort,OutPort) "
                                "callback called in direct mode."));
                }
              // ON_BUFFER_WRITE(In,Out) callback
              m_listeners->notifyOut(ConnectorDataListenerType::ON_BUFFER_WRITE, m_profile, data);
              m_inPortListeners->notifyIn(ConnectorDataListenerType::ON_BUFFER_WRITE, m_profile, data);
              RTC_PARANOID(("ON_BUFFER_WRITE(InPort,OutPort), "
                                "callback called in direct mode."));
              inport->write(data);  // write to InPort variable!!
              // ON_RECEIVED(In,Out) callback
              m_listeners->notifyOut(ConnectorDataListenerType::ON_RECEIVED, m_profile, data);
              m_inPortListeners->notifyIn(ConnectorDataListenerType::ON_RECEIVED, m_profile, data);
              RTC_PARANOID(("ON_RECEIVED(InPort,OutPort), "
                            "callback called in direct mode."));
              
              return DataPortStatus::PORT_OK;
            }
        }
      // normal case
      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());
      cdr->serialize(data);
      RTC_TRACE(("connector endian: %s", isLittleEndian() ? "little":"big"));
      
      // NOTE: need cast to ByteDataStreamBase* to call the another write()
      DataPortStatus ret = write((ByteDataStreamBase*)cdr);
 
      return ret;
    }
 
    virtual BufferStatus read(ByteData &data);
 
    bool setInPort(InPortBase* directInPort);
    virtual void setPullDirectMode();
    virtual bool pullDirectMode();
    virtual void unsubscribeInterface(const coil::Properties& prop);
  protected:
    Logger rtclog;
    ConnectorInfo m_profile;
    bool m_littleEndian;
    
 
 
    PortBase* m_directInPort;
 
    ConnectorListenersBase* m_listeners;
 
    ConnectorListenersBase* m_inPortListeners;
 
    bool m_directMode;
 
    std::string m_marshaling_type;
    ByteDataStreamBase* m_cdr;
 
  };
} // namespace RTC
 
#endif  // RTC_CONNECTORBASE_H