OutPortBase.h

Go to the documentation of this file.

// -*- C++ -*-
#ifndef RTC_OUTPORTBASE_H
#define RTC_OUTPORTBASE_H
 
#include <coil/Properties.h>
#include <coil/stringutil.h>
 
#include <rtm/PortBase.h>
#include <rtm/InPortConsumer.h>
#include <rtm/OutPortProvider.h>
#include <rtm/ConnectorBase.h>
#include <rtm/CdrBufferBase.h>
#include <rtm/SystemLogger.h>
#include <rtm/ConnectorListener.h>
 
namespace RTC
{
  class PublisherBase;
  class ConnectorBase;
  class OutPortConnector;
 
  class OutPortBase
    : public PortBase
  {
  public:
 
    using ConnectorList = std::vector<OutPortConnector*>;
 
    OutPortBase(const char* name, const char* data_type);
 
    ~OutPortBase() override;
 
    void init(coil::Properties& prop);
 
    virtual bool write() = 0;
 
    coil::Properties& properties();
 
    const std::vector<OutPortConnector*>& connectors();
 
    ConnectorInfoList getConnectorProfiles();
 
    coil::vstring getConnectorIds();
 
    coil::vstring getConnectorNames();
 
    OutPortConnector* getConnectorById(const char* id);
 
    OutPortConnector* 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();
 
 
  protected:
    void configure();
 
    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);
 
    OutPortProvider* createProvider(ConnectorProfile& cprof,
                                    coil::Properties& prop);
    InPortConsumer* createConsumer(const ConnectorProfile& cprof,
                                   coil::Properties& prop);
 
    OutPortConnector* createConnector(const ConnectorProfile& cprof,
                                      coil::Properties& prop,
                                      InPortConsumer* consumer);
    OutPortConnector* createConnector(const ConnectorProfile& cprof,
                                      coil::Properties& prop,
                                      OutPortProvider* provider);
 
    ReturnCode_t notify_connect(ConnectorProfile& connector_profile) override;
 
  protected:
    InPortBase* getLocalInPort(const ConnectorInfo& profile);
    virtual void initConnectorListeners();
 
    
 
    std::vector<OutPortConnector*> m_connectors;
    coil::vstring m_providerTypes;
    coil::vstring m_consumerTypes;
    bool m_littleEndian;
    ConnectorListenersBase* m_listeners;
 
    struct provider_cleanup;
 
    struct connector_cleanup;
  };
} // End of namespace RTC
 
#endif // RTC_RTCOUTPORTBASE_H