CorbaNaming.h

Go to the documentation of this file.

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

#include <rtm/RTC.h>

// STL includes
#include <map>
#include <string>
#include <vector>

#ifdef WIN32
#pragma warning( disable : 4290 )
#endif

namespace RTC
{
  class CorbaNaming
  {
  public:
    CorbaNaming(CORBA::ORB_ptr orb);
    
    CorbaNaming(CORBA::ORB_ptr orb, const char* name_server);
    
    virtual ~CorbaNaming(void){};
    
    void init(const char* name_server);

    bool isAlive();
    
    typedef CORBA::SystemException SystemException;
    typedef CosNaming::NamingContext::NotFound      NotFound;
    typedef CosNaming::NamingContext::CannotProceed CannotProceed;
    typedef CosNaming::NamingContext::InvalidName   InvalidName;
    typedef CosNaming::NamingContext::AlreadyBound  AlreadyBound;
    typedef CosNaming::NamingContext::NotEmpty      NotEmpty;
    typedef CosNaming::NamingContextExt::InvalidAddress InvalidAddress;
    typedef std::vector<CORBA::Object_ptr> ObjectList;
    
    void bind(const CosNaming::Name& name, CORBA::Object_ptr obj,
              const bool force = 1)
      throw (SystemException, NotFound, CannotProceed,
             InvalidName, AlreadyBound);
    
    void bindByString(const char* string_name, CORBA::Object_ptr obj,
                      const bool force = 1)
      throw (SystemException, NotFound, CannotProceed,
             InvalidName, AlreadyBound);
    
    void bindRecursive(CosNaming::NamingContext_ptr context,
                       const CosNaming::Name& name,
                       CORBA::Object_ptr obj)
      throw (SystemException, CannotProceed, InvalidName, AlreadyBound);
    
    void rebind(const CosNaming::Name& name, CORBA::Object_ptr obj,
                const bool force = 1)
      throw (SystemException, NotFound, CannotProceed, InvalidName);
    
    void rebindByString(const char* string_name, CORBA::Object_ptr obj,
                        const bool force = 1)
      throw (SystemException, NotFound, CannotProceed, InvalidName);
    
    void rebindRecursive(CosNaming::NamingContext_ptr context,
                         const CosNaming::Name& name,
                         CORBA::Object_ptr obj)
      throw (SystemException, CannotProceed, InvalidName);
    
    void bindContext(const CosNaming::Name& name,
                     CosNaming::NamingContext_ptr name_cxt,
                     const bool force = 1)
      throw (SystemException, NotFound, CannotProceed,
             InvalidName, AlreadyBound);
    
    void bindContext(const char* string_name,
                     CosNaming::NamingContext_ptr name_cxt,
                     const bool force = 1)
      throw (SystemException, NotFound, CannotProceed,
             InvalidName, AlreadyBound);
    
    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,
                       const bool force = 1)
      throw (SystemException, NotFound, CannotProceed, InvalidName);
    
    void rebindContext(const char* string_name,
                       CosNaming::NamingContext_ptr name_cxt,
                       const bool force = 1)
      throw (SystemException, NotFound, CannotProceed, InvalidName);
    
    void rebindContextRecursive(CosNaming::NamingContext_ptr context,
                                const CosNaming::Name& name,
                                CosNaming::NamingContext_ptr name_cxt);
    
    CORBA::Object_ptr resolve(const CosNaming::Name& name)
      throw (SystemException, NotFound, CannotProceed, InvalidName);
    
    CORBA::Object_ptr resolve(const char* string_name)
      throw (SystemException, NotFound, CannotProceed, InvalidName);
    
    void unbind(const CosNaming::Name& name)
      throw (SystemException, NotFound, CannotProceed, InvalidName);
    
    void unbind(const char* string_name)
      throw (SystemException, NotFound, CannotProceed, InvalidName);
    
    CosNaming::NamingContext_ptr newContext();
    
    CosNaming::NamingContext_ptr
    bindNewContext(const CosNaming::Name& name, bool force = true)
      throw (SystemException, NotFound, CannotProceed,
             InvalidName, AlreadyBound);
    
    CosNaming::NamingContext_ptr
    bindNewContext(const char* string_name, bool force = true)
      throw (SystemException, NotFound, CannotProceed,
             InvalidName, AlreadyBound);
    
    void destroy(CosNaming::NamingContext_ptr context)
      throw (SystemException, NotEmpty);
    
    void destroyRecursive(CosNaming::NamingContext_ptr context)
      throw (SystemException, NotEmpty, NotFound, CannotProceed, InvalidName);
    
    void clearAll();
    
    void list(CosNaming::NamingContext_ptr name_cxt,
              CORBA::ULong how_many,
              CosNaming::BindingList_var& bl,
              CosNaming::BindingIterator_var& bi);
    
    //============================================================
    // interface of NamingContextExt
    //============================================================
    char* toString(const CosNaming::Name& name)
      throw (SystemException, InvalidName);
    
    CosNaming::Name toName(const char* string_name)
      throw (SystemException, InvalidName);
    
    char* toUrl(char* addr, char* string_name)
      throw (SystemException, InvalidAddress, InvalidName);
    
    CORBA::Object_ptr resolveStr(const char* string_name)
      throw (SystemException, NotFound, CannotProceed,
             InvalidName, AlreadyBound);
    
    //============================================================
    // 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);
    
    CORBA::Object_ptr bindOrResolve(CosNaming::NamingContext_ptr context,
                                    const CosNaming::Name& name,
                                    CORBA::Object_ptr obj);
    
    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();
    
    bool isNamingContext(CORBA::Object_ptr obj);
    
    bool isNamingContext(const CosNaming::Name& name);
    
    bool isNamingContext(const char* string_name);
    
    CosNaming::Name subName(const CosNaming::Name& name,
                            CORBA::Long begin,
                            CORBA::Long end = -1);
    
  protected:
    void nameToString(const CosNaming::Name& name, char* string_name,
                      CORBA::ULong slen);
    CORBA::ULong getNameLength(const CosNaming::Name& name);
    
    unsigned int split(const std::string& input,
                       const std::string& delimiter,
                       std::vector<std::string>& results);
    
    CORBA::ORB_var m_varORB;
    
    std::string m_nameServer;
    CosNaming::NamingContextExt_var m_rootContext;
    
  private:
    CORBA::ULong m_blLength;
    
  }; // class CorbaNaming
}; // namespace RTC

#ifdef WIN32
#pragma warning( default : 4290 )
#endif

#endif // end of RTC_CORBANAMING_H