OutPortBase.h

[詳解]

// -*- C++ -*-
#ifndef RTC_OUTPORTBASE_H
#define RTC_OUTPORTBASE_H

#include <vector>
#include <string>

#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>

#ifdef WIN32
#pragma warning( push ) 
#pragma warning( disable : 4290 )
#endif

namespace RTC
{
  class PublisherBase;
  class ConnectorBase;
  class OutPortConnector;

  class OutPortBase
    : public PortBase, public DataPortStatus
  {
  public:
    DATAPORTSTATUS_ENUM

    typedef std::vector<OutPortConnector*> ConnectorList;

    OutPortBase(const char* name, const char* data_type);
    
    virtual ~OutPortBase(void);
    
    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);

    
    virtual void activateInterfaces();

    virtual void deactivateInterfaces();


    void addConnectorDataListener(ConnectorDataListenerType listener_type,
                                  ConnectorDataListener* listener,
                                  bool autoclean = true);


    void removeConnectorDataListener(ConnectorDataListenerType listener_type,
                                     ConnectorDataListener* listener);
    

    void addConnectorListener(ConnectorListenerType callback_type,
                              ConnectorListener* listener,
                              bool autoclean = true);

    void removeConnectorListener(ConnectorListenerType callback_type,
                                 ConnectorListener* listener);

    bool isLittleEndian();

    virtual ReturnCode_t
    connect(ConnectorProfile& connector_profile)
      throw (CORBA::SystemException);

    virtual ConnectorListeners& getListeners();


  protected:
    void configure();

    virtual ReturnCode_t
    publishInterfaces(ConnectorProfile& connector_profile);
    
    virtual ReturnCode_t
    subscribeInterfaces(const ConnectorProfile& connector_profile);
    
    virtual void
    unsubscribeInterfaces(const ConnectorProfile& connector_profile);

    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);

    virtual ReturnCode_t notify_connect(ConnectorProfile& connector_profile)
        throw (CORBA::SystemException);


  protected:
    InPortBase* getLocalInPort(const ConnectorInfo& profile);


    

    std::vector<OutPortConnector*> m_connectors;
    coil::vstring m_providerTypes;
    coil::vstring m_consumerTypes;
    bool m_littleEndian;
    ConnectorListeners m_listeners;
   
    struct provider_cleanup;

    struct connector_cleanup;
  };
}; // End of namespace RTC

#ifdef WIN32
#pragma warning( pop )
#endif

#endif // RTC_RTCOUTPORTBASE_H