InPortBase.h

[詳解]

// -*- C++ -*-
#ifndef RTC_INPORTBASE_H
#define RTC_INPORTBASE_H
 
#include <rtm/PortBase.h>
#include <rtm/DataPortStatus.h>
#include <rtm/CdrBufferBase.h>
#include <rtm/ConnectorListener.h>
#include <rtm/OutPortBase.h>
 
namespace RTC
{
  class InPortProvider;
  class OutPortConsumer;
  class InPortConnector;
 
  class InPortBase
    : public PortBase
  {
  public:
 
    using ConnectorList = std::vector<InPortConnector*>;
 
    InPortBase(const char* name, const char* data_type);
 
    ~InPortBase() override;
 
    virtual void init(coil::Properties& prop);
 
    virtual bool read(std::string name="") = 0;
 
    coil::Properties& properties();
 
    const std::vector<InPortConnector*>& connectors();
 
    ConnectorInfoList getConnectorProfiles();
 
    coil::vstring getConnectorIds();
 
    coil::vstring getConnectorNames();
 
    InPortConnector* getConnectorById(const char* id);
 
    InPortConnector* getConnectorByName(const char* name);
 
    bool getConnectorProfileById(const char* id,
                                 ConnectorInfo& prof);
 
    bool getConnectorProfileByName(const char* name,
                                   ConnectorInfo& prof);
 
 
    void activateInterfaces() override;
 
    void deactivateInterfaces() override;
 
    void addConnectorDataListener(ConnectorDataListenerType type,
                                  ConnectorDataListener* listener,
                                  bool autoclean = true);
 
 
    void removeConnectorDataListener(ConnectorDataListenerType type,
                                     ConnectorDataListener* listener);
 
 
    void addConnectorListener(ConnectorListenerType type,
                              ConnectorListener* listener,
                              bool autoclean = true);
 
    void removeConnectorListener(ConnectorListenerType type,
                                 ConnectorListener* listener);
 
    bool isLittleEndian();
 
    ReturnCode_t
    connect(ConnectorProfile& connector_profile) override;
 
    virtual ConnectorListenersBase* getListeners();
    ReturnCode_t notify_connect(ConnectorProfile& connector_profile) override;
  protected:
    ReturnCode_t
    publishInterfaces(ConnectorProfile& cprof) override;
 
    ReturnCode_t
    subscribeInterfaces(const ConnectorProfile& cprof) override;
 
    void
    unsubscribeInterfaces(const ConnectorProfile& connector_profile) override;
 
 
    void initProviders();
 
    void initConsumers();
 
    bool checkEndian(const coil::Properties& prop, bool& littleEndian);
 
    InPortProvider*
    createProvider(ConnectorProfile& cprof, coil::Properties& prop);
 
    OutPortConsumer*
    createConsumer(const ConnectorProfile& cprof, coil::Properties& prop);
 
    InPortConnector*
    createConnector(ConnectorProfile& cprof, coil::Properties& prop,
                    InPortProvider* provider);
    InPortConnector*
    createConnector(const ConnectorProfile& cprof, coil::Properties& prop,
                    OutPortConsumer* consumer);
    OutPortBase* getLocalOutPort(const ConnectorInfo& profile);
 
    virtual void initConnectorListeners();
    bool m_singlebuffer;
    CdrBufferBase* m_thebuffer;
    coil::vstring m_providerTypes;
    coil::vstring m_consumerTypes;
    ConnectorList m_connectors;
    bool m_littleEndian;
 
    ConnectorListenersBase* m_listeners;
  };
} // namespace RTC
 
#endif // RTC_INPORTBASE_H