OutPortProvider.h

[詳解]

// -*- C++ -*-
#ifndef RTC_OUTPORTPROVIDER_H
#define RTC_OUTPORTPROVIDER_H
 
#include <coil/Factory.h>
#include <rtm/BufferBase.h>
#include <rtm/NVUtil.h>
#include <rtm/SystemLogger.h>
#include <rtm/DataPortStatus.h>
#include <rtm/OutPortConnector.h>
 
#include <string>
 
namespace RTC
{
  class ConnectorListeners;
  class OutPortProvider
  {
  public:
    virtual ~OutPortProvider();
 
    virtual void init(coil::Properties& prop);
 
    virtual void setBuffer(CdrBufferBase* buffer) = 0;
 
    virtual void setListener(ConnectorInfo& info,
                             ConnectorListenersBase* listeners) = 0;
 
    virtual void setConnector(OutPortConnector* connector) = 0;
 
    virtual void publishInterfaceProfile(SDOPackage::NVList& prop);
 
    virtual bool publishInterface(SDOPackage::NVList& prop);
 
  protected:
    void setPortType(const char* port_type);
 
    void setDataType(const char* data_type);
 
    void setInterfaceType(const char* interface_type);
 
    void setDataFlowType(const char* dataflow_type);
 
    void setSubscriptionType(const char* subs_type);
 
  protected:
    SDOPackage::NVList m_properties;
    mutable Logger rtclog;
 
  private:
    std::string m_portType;
    std::string m_dataType;
    std::string m_interfaceType;
    std::string m_dataflowType;
    std::string m_subscriptionType;
 
 
  public:
    struct publishInterfaceProfileFunc
    {
      explicit publishInterfaceProfileFunc(SDOPackage::NVList& prop)
             : m_prop(prop) {}
      void operator()(OutPortProvider* provider)
      {
        provider->publishInterfaceProfile(m_prop);
      }
      SDOPackage::NVList& m_prop;
    };
 
    struct publishInterfaceFunc
    {
      explicit publishInterfaceFunc(SDOPackage::NVList& prop)
        : m_prop(prop), provider_(nullptr) {}
      void operator()(OutPortProvider* provider)
      {
        if (provider->publishInterface(m_prop))
          {
            provider_ = provider;
          }
      }
      SDOPackage::NVList& m_prop;
      OutPortProvider* provider_;
    };
  };
 
  using OutPortProviderFactory = ::coil::GlobalFactory<OutPortProvider>;
} // namespace RTC
 
#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
EXTERN template class DLL_PLUGIN coil::GlobalFactory<RTC::OutPortProvider>;
#elif defined(__GNUC__)
EXTERN template class coil::GlobalFactory<RTC::OutPortProvider>;
#endif
 
#endif  // RTC_OUTPORTPROVIDER_H