CorbaNaming.h

[詳解]

// -*- C++ -*-
#ifndef RTC_CORBANAMING_H
#define RTC_CORBANAMING_H
 
#include <rtm/RTC.h>
 
// STL includes
#include <map>
#include <string>
#include <vector>
 
namespace RTC
{
  class CorbaNaming
  {
  public:
    explicit CorbaNaming(CORBA::ORB_ptr orb);
 
    CorbaNaming(CORBA::ORB_ptr orb, const char* name_server);
 
    virtual ~CorbaNaming();
 
    void init(const char* name_server);
 
    bool isAlive();
 
    using SystemException = CORBA::SystemException;
    using NotFound = CosNaming::NamingContext::NotFound;
    using CannotProceed = CosNaming::NamingContext::CannotProceed;
    using InvalidName = CosNaming::NamingContext::InvalidName;
    using AlreadyBound = CosNaming::NamingContext::AlreadyBound;
    using NotEmpty = CosNaming::NamingContext::NotEmpty;
    using InvalidAddress = CosNaming::NamingContextExt::InvalidAddress;
    using ObjectList = std::vector<CORBA::Object_ptr>;
 
    void bind(const CosNaming::Name& name, CORBA::Object_ptr obj,
              bool force = true);
 
    void bindByString(const char* string_name, CORBA::Object_ptr obj,
                      bool force = true);
 
    void bindRecursive(CosNaming::NamingContext_ptr context,
                       const CosNaming::Name& name,
                       CORBA::Object_ptr obj);
 
    void rebind(const CosNaming::Name& name, CORBA::Object_ptr obj,
                bool force = true);
 
    void rebindByString(const char* string_name, CORBA::Object_ptr obj,
                        bool force = true);
 
    static void rebindRecursive(CosNaming::NamingContext_ptr context,
                         const CosNaming::Name& name,
                         CORBA::Object_ptr obj);
 
    void bindContext(const CosNaming::Name& name,
                     CosNaming::NamingContext_ptr name_cxt,
                     bool force = true);
 
    void bindContext(const char* string_name,
                     CosNaming::NamingContext_ptr name_cxt,
                     bool force = true);
 
    void bindContextRecursive(CosNaming::NamingContext_ptr context,
                              const CosNaming::Name& name,
                              CosNaming::NamingContext_ptr name_cxt);
 
    void rebindContext(const CosNaming::Name& name,
                       CosNaming::NamingContext_ptr name_cxt,
                       bool force = true);
 
    void rebindContext(const char* string_name,
                       CosNaming::NamingContext_ptr name_cxt,
                       bool force = true);
 
    static void rebindContextRecursive(CosNaming::NamingContext_ptr context,
                                const CosNaming::Name& name,
                                CosNaming::NamingContext_ptr name_cxt);
 
    CORBA::Object_ptr resolve(const CosNaming::Name& name);
 
    CORBA::Object_ptr resolve(const char* string_name);
 
    void unbind(const CosNaming::Name& name);
 
    void unbind(const char* string_name);
 
    CosNaming::NamingContext_ptr newContext();
 
    CosNaming::NamingContext_ptr
    bindNewContext(const CosNaming::Name& name, bool force = true);
 
    CosNaming::NamingContext_ptr
    bindNewContext(const char* string_name, bool force = true);
 
    static void destroy(CosNaming::NamingContext_ptr context);
 
    void destroyRecursive(CosNaming::NamingContext_ptr context);
 
    void clearAll();
 
    static void list(CosNaming::NamingContext_ptr name_cxt,
              CORBA::ULong how_many,
              CosNaming::BindingList_var& bl,
              CosNaming::BindingIterator_var& bi);
    void list(const char* string_name,
              CosNaming::BindingList_var& bl);
 
    void listByKind(const char* string_name,
                    const char* string_kind,
                    CosNaming::BindingList_var& bl);
 
    //============================================================
    // interface of NamingContextExt
    //============================================================
    static char* toString(const CosNaming::Name& name);
 
    static CosNaming::Name toName(const char* sname);
 
    char* toUrl(char* addr, char* string_name);
 
    CORBA::Object_ptr resolveStr(const char* string_name);
 
    //============================================================
    // Find functions
    //============================================================
 
    //    ObjectList find(const char* name, const char* kind);
    //    ObjectList findById(const char* name, const char* kind);
    //    ObjectList findByKind(const char* name, const char* kind);
 
    static CORBA::Object_ptr bindOrResolve(CosNaming::NamingContext_ptr context,
                                    const CosNaming::Name& name,
                                    CORBA::Object_ptr obj);
 
    static CosNaming::NamingContext_ptr
    bindOrResolveContext(CosNaming::NamingContext_ptr context,
                         const CosNaming::Name& name,
                         CosNaming::NamingContext_ptr new_context);
 
    CosNaming::NamingContext_ptr
    bindOrResolveContext(CosNaming::NamingContext_ptr context,
                         const CosNaming::Name& name);
 
    const char* getNameServer();
 
    CosNaming::NamingContext_ptr getRootContext();
 
    static bool isNamingContext(CORBA::Object_ptr obj);
 
    bool isNamingContext(const CosNaming::Name& name);
 
    bool isNamingContext(const char* string_name);
 
    static CosNaming::Name subName(const CosNaming::Name& name,
                            CORBA::Long begin,
                            CORBA::Long end = -1);
 
  protected:
    static void nameToString(const CosNaming::Name& name, char* string_name,
                      CORBA::ULong slen);
    static CORBA::ULong getNameLength(const CosNaming::Name& name);
 
    static unsigned int split(const std::string& input,
                       const std::string& delimiter,
                       std::vector<std::string>& results);
 
    CORBA::ORB_ptr m_ptrORB;
 
    std::string m_nameServer;
    CosNaming::NamingContextExt_var m_rootContext;
 
  private:
    CORBA::ULong m_blLength;
 
  };  // class CorbaNaming
} // namespace RTC
 
#endif  // end of RTC_CORBANAMING_H