InPortBase.h

Go to the documentation of this file.

// -*- 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>

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


namespace RTC
{
  class InPortProvider;
  class OutPortConsumer;
  class InPortConnector;

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

    typedef std::vector<InPortConnector*> ConnectorList;

    InPortBase(const char* name, const char* data_type);
    
    virtual ~InPortBase(void);

    void init(coil::Properties& prop);

    virtual bool read() = 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);


    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();
    virtual ReturnCode_t notify_connect(ConnectorProfile& connector_profile)
        throw (CORBA::SystemException);

  protected:

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

    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);
  protected:
      OutPortBase* getLocalOutPort(const ConnectorInfo& profile);
    bool m_singlebuffer;
    CdrBufferBase* m_thebuffer;
    coil::vstring m_providerTypes;
    coil::vstring m_consumerTypes;
    ConnectorList m_connectors;
    bool m_littleEndian;

    ConnectorListeners m_listeners;
  };
}; // namespace RTC

#ifdef WIN32
#pragma warning( pop )
#endif

#endif // RTC_INPORTBASE_H