NamingManager.h

[詳解]

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

#include <rtm/RTC.h>

#include <coil/Task.h>
#include <coil/Mutex.h>
#include <coil/Guard.h>
#include <rtm/CorbaNaming.h>
#include <rtm/RTObject.h>
#include <rtm/SystemLogger.h>
#include <rtm/ManagerServant.h>

namespace RTC
{
  class Manager;
  class NamingBase
  {
    typedef coil::Mutex Mutex;
    typedef coil::Guard<Mutex> Guard;
  public:
    NamingBase() {};
    
    virtual ~NamingBase(void) {};
    
    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);
    
    virtual ~NamingOnCorba(void){};
    
    virtual void bindObject(const char* name, const RTObject_impl* rtobj);
    virtual void bindObject(const char* name, const PortBase* port);

    virtual void bindObject(const char* name, const RTM::ManagerServant* mgr);

    virtual void unbindObject(const char* name);

    virtual bool isAlive();
    void getComponentByName(CosNaming::NamingContext_ptr context, std::string name, RTC::RTCList& rtcs);
    virtual RTC::RTCList string_to_component(std::string name);
    CorbaNaming& getCorbaNaming() { return m_cosnaming; }

  private:
    Logger rtclog;
    CorbaNaming m_cosnaming;
    std::string m_endpoint;
    bool m_replaceEndpoint;
    //    std::map<std::string, RTObject_impl*> m_names;
  };



  class NamingOnManager
    : public virtual NamingBase
  {
  public:
     NamingOnManager(CORBA::ORB_ptr orb, Manager* mgr);
    
     virtual ~NamingOnManager(void){};
    
    virtual void bindObject(const char* name, const RTObject_impl* rtobj);
    virtual void bindObject(const char* name, const PortBase* port);

    virtual void bindObject(const char* name, const RTM::ManagerServant* mgr);

    virtual void unbindObject(const char* name);

    virtual bool isAlive();
    RTC::RTCList string_to_component(std::string name);
    RTM::Manager_ptr getManager(std::string name);

  private:
    Logger rtclog;
    CORBA::ORB_ptr m_orb;
    Manager* m_mgr;
    //    std::map<std::string, RTObject_impl*> m_names;
  };
  
  class NamingManager
  {
    typedef coil::Mutex Mutex;
    typedef coil::Guard<Mutex> Guard;
  public:
    NamingManager(Manager* manager);
    
    virtual ~NamingManager(void);
    
    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(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;
    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;
    Mutex m_compNamesMutex;
    std::vector<Port*> m_portNames;
    Mutex m_portNamesMutex;
    std::vector<Mgr*> m_mgrNames;
    Mutex m_mgrNamesMutex;
    
    Manager* m_manager;
    
    Logger rtclog;
  }; // class NamingManager
}; // namespace RTC

#endif // RTC_NAMINGMANAGER_H