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

  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 RTM::ManagerServant* mgr);
    
    virtual void unbindObject(const char* name);
    
    virtual bool isAlive();

  private:
    Logger rtclog;
    CorbaNaming m_cosnaming;
    std::string m_endpoint;
    bool m_replaceEndpoint;
    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 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();
    
  protected:
    NamingBase* createNamingObj(const char* method, const char* name_server);
    
    void bindCompsTo(NamingBase* ns);
    
    void registerCompName(const char* name, const RTObject_impl* rtobj);

    void registerMgrName(const char* name, const RTM::ManagerServant* mgr);
    
    void unregisterCompName(const char* name);

    void unregisterMgrName(const char* name);

    class Names;
    void retryConnection(Names* ns);
    
  protected:
    // Name Servers' method/name and object
    class Names
    {
    public:
      Names(const char* meth, const char* name, NamingBase* naming)
        : method(meth), nsname(name), ns(naming)
      {
      }
      
      ~Names()
      {
        delete ns;
      }
      
      std::string method;
      std::string nsname;
      NamingBase* ns;
    };
    std::vector<Names*> 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 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<Mgr*> m_mgrNames;
    Mutex m_mgrNamesMutex;
    
    Manager* m_manager;
    
    Logger rtclog;
  }; // class NamingManager
}; // namespace RTC

#endif // RTC_NAMINGMANAGER_H