NamingManager.h

Go to the documentation of this file.

// -*- C++ -*-
#ifndef RTC_NAMINGMANAGER_H
#define RTC_NAMINGMANAGER_H
 
#include <rtm/RTC.h>
 
#include <coil/Task.h>
#include <mutex>
#include <rtm/CorbaNaming.h>
#include <rtm/RTObject.h>
#include <rtm/SystemLogger.h>
#include <rtm/ManagerServant.h>
 
#include <string>
#include <vector>
 
namespace RTC
{
  class Manager;
  class NamingBase
  {
  public:
    NamingBase() = default;
 
    virtual ~NamingBase() = default;
 
    virtual void bindObject(const char* name, const PortBase* port) = 0;
    virtual void bindObject(const char* name, const RTObject_impl* rtobj) = 0;
 
    virtual void bindObject(const char* name,
                            const RTM::ManagerServant* mgr) = 0;
 
    virtual void unbindObject(const char* name) = 0;
 
    virtual bool isAlive() = 0;
    virtual RTC::RTCList string_to_component(std::string name) = 0;
  };
 
  class NamingService
  {
  public:
    NamingService(const char* meth, const char* name, NamingBase* naming)
      : method(meth), nsname(name), ns(naming)
    {
    }
 
    ~NamingService()
    {
      delete ns;
    }
 
    std::string method;
    std::string nsname;
    NamingBase* ns;
  };
 
  class NamingOnCorba
    : public virtual NamingBase
  {
  public:
    NamingOnCorba(CORBA::ORB_ptr orb, const char* names);
 
    ~NamingOnCorba() override = default;
 
    void bindObject(const char* name, const RTObject_impl* rtobj) override;
    void bindObject(const char* name, const PortBase* port) override;
 
    void bindObject(const char* name, const RTM::ManagerServant* mgr) override;
 
    void unbindObject(const char* name) override;
 
    bool isAlive() override;
    void getComponentByName(CosNaming::NamingContext_ptr context, const std::string& name, RTC::RTCList& rtcs);
    RTC::RTCList string_to_component(std::string name) override;
    CorbaNaming& getCorbaNaming() { return m_cosnaming; }
 
  private:
    Logger rtclog;
    CorbaNaming m_cosnaming;
    std::string m_endpoint;
    bool m_replaceEndpoint;
  };
 
 
 
  class NamingOnManager
    : public virtual NamingBase
  {
  public:
    NamingOnManager(CORBA::ORB_ptr orb, Manager* mgr);
    
    ~NamingOnManager() override = default;
    
    void bindObject(const char* name, const RTObject_impl* rtobj) override;
    void bindObject(const char* name, const PortBase* port) override;
 
    void bindObject(const char* name, const RTM::ManagerServant* mgr) override;
 
    void unbindObject(const char* name) override;
 
    bool isAlive() override;
    RTC::RTCList string_to_component(std::string name) override;
    RTM::Manager_ptr getManager(const std::string& name);
 
  private:
    Logger rtclog;
    CORBA::ORB_ptr m_orb;
    Manager* m_mgr;
  };
  
  class NamingManager
  {
  public:
    explicit NamingManager(Manager* manager);
 
    virtual ~NamingManager();
 
    void registerNameServer(const char* method, const char* name_server);
 
    void bindObject(const char* name, const PortBase* port);
    void bindObject(const char* name, const RTObject_impl* rtobj);
 
    void bindObject(const char* name, const RTM::ManagerServant* mgr);
 
    void update();
 
    void unbindObject(const char* name);
 
    void unbindAll();
 
    std::vector<RTObject_impl*> getObjects();
    std::vector<NamingService*>& getNameServices() { return m_names; }
 
    RTCList string_to_component(const std::string& name);
    
  protected:
    NamingBase* createNamingObj(const char* method, const char* name_server);
 
    void bindCompsTo(NamingBase* ns);
 
    void registerCompName(const char* name, const RTObject_impl* rtobj);
 
    void registerPortName(const char* name, const PortBase* port);
 
    void registerMgrName(const char* name, const RTM::ManagerServant* mgr);
 
    void unregisterCompName(const char* name);
    void unregisterPortName(const char* name);
 
    void unregisterMgrName(const char* name);
 
    void retryConnection(NamingService* ns);
 
 
 
  protected:
    // Name Servers' method/name and object
    std::vector<NamingService*> m_names;
    std::mutex m_namesMutex;
 
    // Components' name and object
    struct Comps
    {
      Comps(const char* n, const RTObject_impl* obj)
        : name(n), rtobj(obj)
      {}
      std::string name;
      const RTObject_impl* rtobj;
    };
    struct Port
    {
      Port(const char* n, const PortBase* p)
        : name(n), port(p)
      {}
      std::string name;
      const PortBase* port;
    };
    struct Mgr
    {
      Mgr(const char* n, const RTM::ManagerServant* obj)
        : name(n), mgr(obj)
      {}
      std::string name;
      const RTM::ManagerServant* mgr;
    };
    std::vector<Comps*> m_compNames;
    std::mutex m_compNamesMutex;
    std::vector<Port*> m_portNames;
    std::mutex m_portNamesMutex;
    std::vector<Mgr*> m_mgrNames;
    std::mutex m_mgrNamesMutex;
 
    Manager* m_manager;
 
    Logger rtclog;
  };  // class NamingManager
} // namespace RTC
 
#endif  // RTC_NAMINGMANAGER_H