InPortProvider.h

[詳解]

// -*- C++ -*-
#ifndef RTC_INPORTPROVIDER_H
#define RTC_INPORTPROVIDER_H
 
#include <coil/Factory.h>
 
#include <rtm/BufferBase.h>
#include <rtm/NVUtil.h>
#include <rtm/SystemLogger.h>
#include <rtm/DataPortStatus.h>
#include <rtm/InPortConnector.h>
 
#include <string>
 
namespace RTC
{
  class ConnectorListeners;
  class ConnectorInfo;
 
  class InPortProvider
  {
  public:
    InPortProvider();
 
    virtual ~InPortProvider();
 
    virtual void init(coil::Properties& prop) = 0;
 
    virtual void setBuffer(BufferBase<ByteData>* buffer) = 0;
 
    virtual void setListener(ConnectorInfo& info,
                             ConnectorListenersBase* listeners) = 0;
 
    virtual void setConnector(InPortConnector* connector) = 0;
 
    virtual void publishInterfaceProfile(SDOPackage::NVList& prop);
 
    virtual bool publishInterface(SDOPackage::NVList& prop);
 
  protected:
    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_interfaceType;
    std::string m_dataflowType;
    std::string m_subscriptionType;
 
  public:
    // functors
    struct publishInterfaceProfileFunc
    {
      explicit publishInterfaceProfileFunc(SDOPackage::NVList& prop)
             : m_prop(prop) {}
      void operator()(InPortProvider* provider)
      {
        provider->publishInterfaceProfile(m_prop);
      }
      SDOPackage::NVList& m_prop;
    };
 
    struct publishInterfaceFunc
    {
      explicit publishInterfaceFunc(SDOPackage::NVList& prop)
        : m_prop(prop), provider_(nullptr) {}
      void operator()(InPortProvider* provider)
      {
        if (provider->publishInterface(m_prop))
          {
            provider_ = provider;
          }
      }
      SDOPackage::NVList& m_prop;
      InPortProvider* provider_;
    };
 
 
  };
 
  using InPortProviderFactory = ::coil::GlobalFactory<InPortProvider>;
} // namespace RTC
 
#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
EXTERN template class DLL_PLUGIN coil::GlobalFactory<RTC::InPortProvider>;
#elif defined(__GNUC__)
EXTERN template class coil::GlobalFactory<RTC::InPortProvider>;
#endif
 
#endif  // RTC_INPORTPROVIDER_H