PortBase.h

Go to the documentation of this file.

// -*- C++ -*-
#ifndef RTC_PORTBASE_H
#define RTC_PORTBASE_H
 
#include <rtm/RTC.h>
 
#include <mutex>
#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>
 
namespace RTC
{
  class ConnectionCallback;
 
  class PortBase
    : public virtual POA_RTC::PortService,
      public virtual PortableServer::RefCountServantBase
  {
  public:
    explicit PortBase(const char* name = "");
 
    ~PortBase() override;
 
    PortProfile* get_port_profile() override;
 
    const PortProfile& getPortProfile() const;
 
    ConnectorProfileList* get_connector_profiles() override;
 
    ConnectorProfile* get_connector_profile(const char* connector_id) override;
 
    ReturnCode_t connect(ConnectorProfile& connector_profile) override;
 
    ReturnCode_t notify_connect(ConnectorProfile& connector_profile) override;
 
    ReturnCode_t disconnect(const char* connector_id) override;
 
    ReturnCode_t notify_disconnect(const char* connector_id) override;
 
    ReturnCode_t disconnect_all() override;
 
    //============================================================
    // 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_unsubscribe);
 
    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& cprof);
 
    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();
    //============================================================
    // protected utility functions
    //============================================================
    static bool isEmptyId(const ConnectorProfile& connector_profile) ;
 
    static std::string getUUID() ;
 
    static void setUUID(ConnectorProfile& connector_profile) ;
 
    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* instance_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 != nullptr)
        {
          m_portconnListeners->notify(
            PortConnectListenerType::ON_NOTIFY_CONNECT, portname, profile);
        }
    }
 
    inline void onNotifyDisconnect(const char* portname,
                                   RTC::ConnectorProfile& profile)
    {
      if (m_portconnListeners != nullptr)
        {
          m_portconnListeners->notify(
            PortConnectListenerType::ON_NOTIFY_DISCONNECT, portname, profile);
        }
    }
    inline void onUnsubscribeInterfaces(const char* portname,
                                        RTC::ConnectorProfile& profile)
    {
      if (m_portconnListeners != nullptr)
        {
          m_portconnListeners->notify(
            PortConnectListenerType::ON_UNSUBSCRIBE_INTERFACES, portname, profile);
        }
    }
 
    inline void onPublishInterfaces(const char* portname,
                                    RTC::ConnectorProfile& profile,
                                    ReturnCode_t ret)
    {
      if (m_portconnListeners != nullptr)
        {
          m_portconnListeners->notify(
            PortConnectRetListenerType::ON_PUBLISH_INTERFACES, portname,
                                                       profile, ret);
        }
    }
 
    inline void onConnectNextport(const char* portname,
                                  RTC::ConnectorProfile& profile,
                                  ReturnCode_t ret)
    {
      if (m_portconnListeners != nullptr)
        {
          m_portconnListeners->notify(
            PortConnectRetListenerType::ON_CONNECT_NEXTPORT, portname,
                                                     profile, ret);
        }
    }
 
    inline void onSubscribeInterfaces(const char* portname,
                                      RTC::ConnectorProfile& profile,
                                      ReturnCode_t ret)
    {
      if (m_portconnListeners != nullptr)
        {
          m_portconnListeners->notify(
            PortConnectRetListenerType::ON_SUBSCRIBE_INTERFACES, portname,
                                                         profile, ret);
        }
    }
 
    inline void onConnected(const char* portname,
                            RTC::ConnectorProfile& profile,
                            ReturnCode_t ret)
    {
      if (m_portconnListeners != nullptr)
        {
          m_portconnListeners->notify(
            PortConnectRetListenerType::ON_CONNECTED, portname, profile, ret);
        }
    }
 
    inline void onDisconnectNextport(const char* portname,
                                 RTC::ConnectorProfile& profile,
                                 ReturnCode_t ret)
    {
      if (m_portconnListeners != nullptr)
        {
          m_portconnListeners->notify(
            PortConnectRetListenerType::ON_DISCONNECT_NEXT, portname, profile, ret);
        }
    }
 
    inline void onDisconnected(const char* portname,
                               RTC::ConnectorProfile& profile,
                               ReturnCode_t ret)
    {
      if (m_portconnListeners != nullptr)
        {
          m_portconnListeners->notify(
            PortConnectRetListenerType::ON_DISCONNECTED, portname, profile, ret);
        }
    }
 
  protected:
    bool isExistingMarshalingType(coil::Properties& con_prop);
    mutable Logger rtclog;
    PortProfile m_profile;
 
    RTC::PortService_var m_objref;
    mutable std::mutex m_profile_mutex;
    mutable std::mutex m_connectorsMutex;
 
    std::string m_ownerInstanceName = "unknown";
 
    int m_connectionLimit{-1};
 
    ConnectionCallback* m_onPublishInterfaces{nullptr};
    ConnectionCallback* m_onSubscribeInterfaces{nullptr};
    ConnectionCallback* m_onConnected{nullptr};
    ConnectionCallback* m_onUnsubscribeInterfaces{nullptr};
    ConnectionCallback* m_onDisconnected{nullptr};
 
    ConnectionCallback* m_onConnectionLost{nullptr};
 
    PortConnectListeners* m_portconnListeners{nullptr};
 
    DirectPortBase *m_directport{nullptr};
 
    //============================================================
    // Functor
    //============================================================
    struct find_conn_id
    {
      explicit 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
    {
      explicit find_port_ref(PortService_ptr port_ref) : m_port(port_ref) {}
#ifdef ORB_IS_ORBEXPRESS
      bool operator()(PortService_var port_ref)
      {
        return m_port->_is_equivalent(port_ref.in());
      }
#else
      bool operator()(PortService_ptr port_ref)
      {
        return m_port->_is_equivalent(port_ref);
      }
#endif
      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 == static_cast<const char *>(name)) 
              && (m_pol == prof.polarity));
      }
      std::string m_name;
      PortInterfacePolarity m_pol;
    };  // struct find_interface
  };  // class PortBase
} // namespace RTC
 
#endif  // RTC_PORTBASE_H