PortBase.h

Go to the documentation of this file.

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

#include <rtm/RTC.h>

#include <string>
#include <vector>
#include <coil/Guard.h>
#include <coil/Mutex.h>
#include <rtm/idl/RTCSkel.h>
#include <rtm/CORBA_SeqUtil.h>
#include <rtm/NVUtil.h>
#include <rtm/SystemLogger.h>
#include <rtm/PortConnectListener.h>
#include <iostream>
#include <rtm/DirectPortBase.h>

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

namespace RTC
{
  class ConnectionCallback;

  class PortBase
    : public virtual POA_RTC::PortService,
      public virtual PortableServer::RefCountServantBase
  {
  public:
    PortBase(const char* name = "");
    
    virtual ~PortBase(void);
    
    virtual PortProfile* get_port_profile()
      throw (CORBA::SystemException);
    
    const PortProfile& getPortProfile() const;
    
    virtual ConnectorProfileList* get_connector_profiles()
      throw (CORBA::SystemException);
    
    virtual ConnectorProfile* get_connector_profile(const char* connector_id)
      throw (CORBA::SystemException);
    
    virtual ReturnCode_t connect(ConnectorProfile& connector_profile)
      throw (CORBA::SystemException);
    
    virtual ReturnCode_t notify_connect(ConnectorProfile& connector_profile)
      throw (CORBA::SystemException);
    
    virtual ReturnCode_t disconnect(const char* connector_id)
      throw (CORBA::SystemException);
    
    virtual ReturnCode_t notify_disconnect(const char* connector_id)
      throw (CORBA::SystemException);
    
    virtual ReturnCode_t disconnect_all()
      throw (CORBA::SystemException);
    
    //============================================================
    // Local operations
    //============================================================
    virtual void activateInterfaces() = 0;

    virtual void deactivateInterfaces() = 0;

    void setName(const char* name);

   const char* getName() const;

    const PortProfile& getProfile() const;
    
    void setPortRef(PortService_ptr port_ref);
    
    PortService_ptr getPortRef() const;
    
    void setOwner(RTObject_ptr owner);

    //============================================================
    // callbacks
    //============================================================
    void setOnPublishInterfaces(ConnectionCallback* on_publish);

    void setOnSubscribeInterfaces(ConnectionCallback* on_subscribe);

    void setOnConnected(ConnectionCallback* on_connected);

    void setOnUnsubscribeInterfaces(ConnectionCallback* on_subscribe);

    void setOnDisconnected(ConnectionCallback* on_disconnected);

    void setOnConnectionLost(ConnectionCallback* on_connection_lost);

    void setPortConnectListenerHolder(PortConnectListeners* portconnListeners);

    virtual DirectPortBase* getDirectPort();
    //============================================================
    // protected operations
    //============================================================
  protected:
    virtual ReturnCode_t
    publishInterfaces(ConnectorProfile& connector_profile) = 0;
    
    virtual ReturnCode_t connectNext(ConnectorProfile& connector_profile);
    
    virtual ReturnCode_t disconnectNext(ConnectorProfile& connector_profile);
    
    virtual ReturnCode_t
    subscribeInterfaces(const ConnectorProfile& connector_profile) = 0;
    
    virtual void
    unsubscribeInterfaces(const ConnectorProfile& connector_profile) = 0;

    virtual void setConnectionLimit(int limit_value);
    
    virtual ReturnCode_t _publishInterfaces(void);
    //============================================================
    // protected utility functions
    //============================================================
    bool isEmptyId(const ConnectorProfile& connector_profile) const;
    
    const std::string getUUID() const;
    
    void setUUID(ConnectorProfile& connector_profile) const;
    
    bool isExistingConnId(const char* id);
    
    ConnectorProfile findConnProfile(const char* id);
    
    CORBA::Long findConnProfileIndex(const char* id);
    
    void updateConnectorProfile(const ConnectorProfile& connector_profile);
    
    bool eraseConnectorProfile(const char* id);
    
    bool appendInterface(const char* name, const char* type_name,
             PortInterfacePolarity pol);
    
    bool deleteInterface(const char* name, PortInterfacePolarity pol);
    
    template <class ValueType>
    void addProperty(const char* key, ValueType value)
    {
      CORBA_SeqUtil::push_back(m_profile.properties,
                   NVUtil::newNV(key, value));
    }

    void appendProperty(const char* key, const char* value)
    {
      NVUtil::appendStringValue(m_profile.properties, key, value);
    }
    coil::Properties m_properties;
  protected:
    void updateConnectors();

#ifndef ORB_IS_RTORB
    bool checkPorts(::RTC::PortServiceList& ports);
#else // ORB_IS_RTORB
    bool checkPorts(RTC_PortServiceList& ports);
#endif // ORB_IS_RTORB


    inline void onNotifyConnect(const char* portname,
                                RTC::ConnectorProfile& profile)
    {
      if (m_portconnListeners != NULL)
        {
          m_portconnListeners->
            portconnect_[ON_NOTIFY_CONNECT].notify(portname, profile);
        }
    }

    inline void onNotifyDisconnect(const char* portname,
                                   RTC::ConnectorProfile& profile)
    {
      if (m_portconnListeners != NULL)
        {
          m_portconnListeners->
            portconnect_[ON_NOTIFY_DISCONNECT].notify(portname, profile);
        }
    }
    inline void onUnsubscribeInterfaces(const char* portname,
                                        RTC::ConnectorProfile& profile)
    {
      if (m_portconnListeners != NULL)
        {
          m_portconnListeners->
            portconnect_[ON_UNSUBSCRIBE_INTERFACES].notify(portname, profile);
        }
    }

    inline void onPublishInterfaces(const char* portname,
                                    RTC::ConnectorProfile& profile,
                                    ReturnCode_t ret)
    {
      if (m_portconnListeners != NULL)
        {
          m_portconnListeners->
            portconnret_[ON_PUBLISH_INTERFACES].notify(portname,
                                                       profile, ret);
        }
    }

    inline void onConnectNextport(const char* portname,
                                  RTC::ConnectorProfile& profile,
                                  ReturnCode_t ret)
    {
      if (m_portconnListeners != NULL)
        {
          m_portconnListeners->
            portconnret_[ON_CONNECT_NEXTPORT].notify(portname,
                                                     profile, ret);
        }
    }

    inline void onSubscribeInterfaces(const char* portname,
                                      RTC::ConnectorProfile& profile,
                                      ReturnCode_t ret)
    {
      if (m_portconnListeners != NULL)
        {
          m_portconnListeners->
            portconnret_[ON_SUBSCRIBE_INTERFACES].notify(portname,
                                                         profile, ret);
        }
    }

    inline void onConnected(const char* portname,
                            RTC::ConnectorProfile& profile,
                            ReturnCode_t ret)
    {
      if (m_portconnListeners != NULL)
        {
          m_portconnListeners->
            portconnret_[ON_CONNECTED].notify(portname, profile, ret);
        }
    }

    inline void onDisconnectNextport(const char* portname,
                                 RTC::ConnectorProfile& profile,
                                 ReturnCode_t ret)
    {
      if (m_portconnListeners != NULL)
        {
          m_portconnListeners->
            portconnret_[ON_DISCONNECT_NEXT].notify(portname, profile, ret);
        }
    }

    inline void onDisconnected(const char* portname,
                               RTC::ConnectorProfile& profile,
                               ReturnCode_t ret)
    {
      if (m_portconnListeners != NULL)
        {
          m_portconnListeners->
            portconnret_[ON_DISCONNECTED].notify(portname, profile, ret);
        }
    }

  protected:
    mutable Logger rtclog;
    PortProfile m_profile;
    
    RTC::PortService_var m_objref;
    mutable coil::Mutex m_profile_mutex;
    mutable coil::Mutex m_connectorsMutex;
    typedef coil::Guard<coil::Mutex> Guard;

    std::string m_ownerInstanceName;

    int m_connectionLimit;
    
    ConnectionCallback* m_onPublishInterfaces;
    ConnectionCallback* m_onSubscribeInterfaces;
    ConnectionCallback* m_onConnected;
    ConnectionCallback* m_onUnsubscribeInterfaces;
    ConnectionCallback* m_onDisconnected;

    ConnectionCallback* m_onConnectionLost;

    PortConnectListeners* m_portconnListeners;

    DirectPortBase *m_directport;

    //============================================================
    // Functor
    //============================================================
    struct find_conn_id
    {
      find_conn_id(const char* id) : m_id(id) {};
      bool operator()(const ConnectorProfile& cprof)
      {
    return m_id == std::string(cprof.connector_id);
      }
      std::string m_id;
    };  // struct find_conn_id
    
    struct find_port_ref
    {
      find_port_ref(PortService_ptr port_ref) : m_port(port_ref) {};
      bool operator()(PortService_ptr port_ref)
      {
    return m_port->_is_equivalent(port_ref);
      }
      PortService_ptr m_port;
    };  // struct find_port_ref
    
    struct find_interface
    {
      find_interface(const char* name, PortInterfacePolarity pol)
    : m_name(name), m_pol(pol)
      {}
      
      bool operator()(const PortInterfaceProfile& prof)
      {
    CORBA::String_var name(CORBA::string_dup(prof.instance_name));
    return ((m_name == (const char *)name) && (m_pol == prof.polarity));
      }
      std::string m_name;
      PortInterfacePolarity m_pol;
    };  // struct find_interface
  };  // class PortBase
};  // namespace RTC

#ifdef WIN32
#pragma warning( default : 4290 )
#endif

#endif // RTC_PORTBASE_H