TAO_Naming_Context Class Reference

This class plays a role of the 'Abstraction' (aka 'Interface') in the Bridge pattern architecture of the CosNaming::NamingContext implementation. More...

#include <Naming_Context_Interface.h>

Collaboration diagram for TAO_Naming_Context:

[legend]List of all members.

Public Member Functions
	TAO_Naming_Context (TAO_Naming_Context_Impl *impl)
	Constructor. Initializes with a concrete implementation.
	~TAO_Naming_Context (void)
	Destructor.
virtual void	bind (const CosNaming::Name &n, CORBA::Object_ptr obj)
virtual void	rebind (const CosNaming::Name &n, CORBA::Object_ptr obj)
virtual void	bind_context (const CosNaming::Name &n, CosNaming::NamingContext_ptr nc)
virtual void	rebind_context (const CosNaming::Name &n, CosNaming::NamingContext_ptr nc)
virtual CORBA::Object_ptr	resolve (const CosNaming::Name &n)
virtual void	unbind (const CosNaming::Name &n)
virtual CosNaming::NamingContext_ptr	new_context ()
virtual CosNaming::NamingContext_ptr	bind_new_context (const CosNaming::Name &n)
virtual void	destroy (void)
virtual void	list (CORBA::ULong how_many, CosNaming::BindingList_out bl, CosNaming::BindingIterator_out bi)
virtual char *	to_string (const CosNaming::Name &n)
virtual CosNaming::Name *	to_name (const char *sn)
virtual char *	to_url (const char *addr, const char *sn)
virtual CORBA::Object_ptr	resolve_str (const char *n)
virtual PortableServer::POA_ptr	_default_POA (void)
	Returns the Default POA of this Servant object.
Protected Attributes
TAO_Naming_Context_Impl *	impl_
	A concrete implementor of the NamingContext functions.
Private Types
enum	Hint { HINT_ID, HINT_KIND }
Private Member Functions
void	to_name_helper (char *dest, const char *&src, Hint hint)
void	to_string_helper_assign (char *&k, const char *&src)
void	to_string_helper_length (CORBA::ULong &len, const char *&src)
Static Private Member Functions
int	to_url_is_alnum_or_punctuation (char c)
size_t	to_url_validate_and_compute_size (const char *add, const char *sn)

---

Detailed Description

This class plays a role of the 'Abstraction' (aka 'Interface') in the Bridge pattern architecture of the CosNaming::NamingContext implementation.

This class simply forwards all client requests to a concrete NamingContext implementation through its pointer. See README file for more info. Comments for the idl methods describe methods semantics - actual actions are carried out by concrete implementors.

Definition at line 46 of file Naming_Context_Interface.h.

---

Member Enumeration Documentation

enum TAO_Naming_Context::Hint [private]

Enumeration values: HINT_ID  HINT_KIND  Definition at line 185 of file Naming_Context_Interface.h. { HINT_ID, HINT_KIND };

---

Constructor & Destructor Documentation

TAO_BEGIN_VERSIONED_NAMESPACE_DECL TAO_Naming_Context::TAO_Naming_Context (  TAO_Naming_Context_Impl *  impl  )

Constructor. Initializes with a concrete implementation. Definition at line 20 of file Naming_Context_Interface.cpp. : impl_ (impl) { }

TAO_Naming_Context::~TAO_Naming_Context (  void   )

Destructor. Definition at line 25 of file Naming_Context_Interface.cpp. { delete impl_; }

---

Member Function Documentation

PortableServer::POA_ptr TAO_Naming_Context::_default_POA (  void   )  [virtual]

Returns the Default POA of this Servant object. Definition at line 31 of file Naming_Context_Interface.cpp. References TAO_Naming_Context_Impl::_default_POA(). { return impl_->_default_POA (); }

void TAO_Naming_Context::bind (  const CosNaming::Name &  n, CORBA::Object_ptr  obj )  [virtual]

Create a binding for name and object in the naming context. Compound names are treated as follows: ctx->bind (<c1; c2; c3; cn>, obj) = (ctx->resolve (<c1; c2; cn-1>))->bind (, obj) if the there already exists a binding for the specified name, exception is thrown. Naming contexts should be bound using and in order to participate in name resolution later. Definition at line 37 of file Naming_Context_Interface.cpp. References TAO_Naming_Context_Impl::bind(), and CosNaming::Name. { impl_->bind (n, obj); }

void TAO_Naming_Context::bind_context (  const CosNaming::Name &  n, CosNaming::NamingContext_ptr  nc )  [virtual]

This is the version of specifically for binding naming contexts, so that they will participate in name resolution when compound names are passed to be resolved. Definition at line 49 of file Naming_Context_Interface.cpp. References TAO_Naming_Context_Impl::bind_context(), and CosNaming::Name. { impl_->bind_context (n, nc); }

CosNaming::NamingContext_ptr TAO_Naming_Context::bind_new_context (  const CosNaming::Name &  n  )  [virtual]

This operation creates a new context and binds it to the name supplied as an argument. The newly-created context is implemented by the same server as the context in which it was bound (the name argument excluding the last component). Definition at line 81 of file Naming_Context_Interface.cpp. References TAO_Naming_Context_Impl::bind_new_context(), and CosNaming::Name. { return impl_->bind_new_context (n); }

void TAO_Naming_Context::destroy (  void   )  [virtual]

Delete the naming context. The user should take care to any bindings in which the given context is bound to some names, to avoid dangling references when invoking operation. NOTE: is a no-op on the root context. NOTE: after is invoked on a Naming Context, all BindingIterators associated with that Naming Context are also destroyed. Definition at line 87 of file Naming_Context_Interface.cpp. References TAO_Naming_Context_Impl::destroy(). { impl_->destroy (); }

void TAO_Naming_Context::list (  CORBA::ULong  how_many, CosNaming::BindingList_out  bl, CosNaming::BindingIterator_out  bi )  [virtual]

Returns at most the requested number of bindings in . If the naming context contains additional bindings, they are returned with a BindingIterator. In the naming context does not contain any additional bindings returned as null. Definition at line 93 of file Naming_Context_Interface.cpp. References TAO_Naming_Context_Impl::list(). { impl_->list (how_many, bl, bi); }

CosNaming::NamingContext_ptr TAO_Naming_Context::new_context (   )  [virtual]

This operation returns a new naming context implemented by the same naming server in which the operation was invoked. The context is not bound. Definition at line 75 of file Naming_Context_Interface.cpp. References TAO_Naming_Context_Impl::new_context(). { return impl_->new_context (); }

void TAO_Naming_Context::rebind (  const CosNaming::Name &  n, CORBA::Object_ptr  obj )  [virtual]

This is similar to operation above, except for when the binding for the specified name already exists in the specified context. In that case, the existing binding is replaced with the new one. Definition at line 43 of file Naming_Context_Interface.cpp. References CosNaming::Name, and TAO_Naming_Context_Impl::rebind(). { impl_->rebind (n, obj); }

void TAO_Naming_Context::rebind_context (  const CosNaming::Name &  n, CosNaming::NamingContext_ptr  nc )  [virtual]

This is a version of specifically for naming contexts, so that they can participate in name resolution when compound names are passed. Definition at line 56 of file Naming_Context_Interface.cpp. References CosNaming::Name, and TAO_Naming_Context_Impl::rebind_context(). { impl_->rebind_context (n, nc); }

CORBA::Object_ptr TAO_Naming_Context::resolve (  const CosNaming::Name &  n  )  [virtual]

Return object reference that is bound to the name. Compound name resolve is defined as follows: ctx->resolve (<c1; c2; cn>) = ctx->resolve (<c1; c2 cn-1>)->resolve () The naming service does not return the type of the object. Clients are responsible for "narrowing" the object to the appropriate type. Definition at line 63 of file Naming_Context_Interface.cpp. References CosNaming::Name, and TAO_Naming_Context_Impl::resolve(). Referenced by resolve_str(). { return impl_->resolve (n); }

CORBA::Object_ptr TAO_Naming_Context::resolve_str (  const char *  n  )  [virtual]

Similar to as in the CosNaming::NamingContext interface. It accepts a strigified name as an argument instead of a Name. Definition at line 452 of file Naming_Context_Interface.cpp. References resolve(), and to_name(). { // Similar to <resolve> above. It accepts a strigified name as an // argument instead of a Name. // Get the unstrigified name. CosNaming::Name_var name = this->to_name (n); // Pass this unstringified name to resolve and return an Object_ptr return this->resolve (name.in ()); }

CosNaming::Name * TAO_Naming_Context::to_name (  const char *  sn  )  [virtual]

The in parameter is an stringified name. This function removes the escape character '\' and destringifies the stringified name and returns it. Definition at line 243 of file Naming_Context_Interface.cpp. References HINT_ID, HINT_KIND, CosNaming::Name, CORBA::string_alloc(), and to_name_helper(). Referenced by resolve_str(). { // Returns the Name from its stringified form. CosNaming::Name n; // Total number of name components in the name CORBA::ULong ncomp = 0; // Total length of the unstrigified name CORBA::ULong len=0; for (const char *j = sn; *j != '\0'; ++j) { // Make a pass through the Name and count each character if (*j == '/') { ncomp++; } else if (*j == '\\') { ++j; if (*j == '\0') { // Case: The very last component ++len; } } // In all cases. ++len; } // Check for InvalidName i.e. Invalid stringified name // if (len == 0) throw CosNaming::NamingContext::InvalidName(); // Assign the length of the return unstringified name. // n.length (ncomp+1); // Keeps track of the number of the name component // CORBA::ULong count = 0; for (const char *k = sn; *k != '\0';) { if (count > ncomp) { throw CosNaming::NamingContext::InvalidName(); } char *id = CORBA::string_alloc (len); char *kind = CORBA::string_alloc (len); // Assign to the id. this->to_name_helper (id, k, HINT_ID); if (*k == '.') { k++; // Assign to kind this->to_name_helper (kind, k, HINT_KIND); } else { *kind = '\0'; } n[count].id = id; n[count].kind = kind; count++; // End if (*k == '\0') break; k++; } return new CosNaming::Name (n); }

void TAO_Naming_Context::to_name_helper (  char *  dest, const char *&  src, Hint  hint )  [private]

This private function is used as a helper to . It reads character by character from 'src' and depending on the character, either assigns it to 'dest' or returns back to the calling function. If the character is a seperator between the 'id' and 'kind' fields or a seperator between two name components, the control is returned back to the calling function . Definition at line 213 of file Naming_Context_Interface.cpp. References HINT_ID. Referenced by to_name(). { for (; *src != '\0'; ++src, ++dest) { if ((hint == HINT_ID && *src == '.') || *src == '/') { *dest = '\0'; return; } if (*src == '\\') { src++; if (*src == '\0') { // Case: The very last component *dest = '\0'; return; } } // In all cases. *dest = *src; } // Terminate. *dest = '\0'; }

char * TAO_Naming_Context::to_string (  const CosNaming::Name &  n  )  [virtual]

Stringify the name using '\' as the escape character. The characters '.' , '/' and '\' are to be escaped. If the input name is invalid i.e. if the number of characters in the name is zero, an InvalidName exception is to be raised. Definition at line 132 of file Naming_Context_Interface.cpp. References CosNaming::Name, CORBA::string_alloc(), to_string_helper_assign(), and to_string_helper_length(). { // Accepts a Name and returns a stringified name. // Check for invalid name. if (n.length () == 0) throw CosNaming::NamingContext::InvalidName(); // Length of the return string CORBA::ULong len = 0; CORBA::ULong i; for (i=0; i < n.length (); ++i) { const char *id = n[i].id.in (); // Count number of characters in id this->to_string_helper_length (len, id); const char *kind = n[i].kind.in (); // Count number of characters in kind this->to_string_helper_length (len, kind); } // Allocate memory to the return parameter // char *str_name = CORBA::string_alloc (len); // check for memory allocation // if (str_name == 0) { throw CORBA::NO_MEMORY (); } char *k = str_name; // Stringify the name for (i=0; i < n.length (); ++i) { // Stringify Id // const char *id = n[i].id.in (); this->to_string_helper_assign (k, id); const char *kind = n[i].kind.in (); if (*kind != '\0') { // If 'kind' is set, // Append a seperator between the id and kind. // *k = '.'; ++k; // Stringify Kind // this->to_string_helper_assign (k, kind); } // If this is not the last name component, add a seperator // between the name components // if (i != (n.length ()-1)) { *k = '/'; ++k; } } // Terminate *k = '\0'; ++k; return str_name; }

void TAO_Naming_Context::to_string_helper_assign (  char *&  k, const char *&  src )  [private]

This method functions similar to . If the character read is '.' or '/' or '\', an escape character '\' is prepended before the character. Definition at line 116 of file Naming_Context_Interface.cpp. Referenced by to_string(). { for (; *src != '\0'; ++src) { if (*src == '.' || *src == '\\' || *src == '/') { *k = '\\'; ++k; } *k = *src; ++k; } }

void TAO_Naming_Context::to_string_helper_length (  CORBA::ULong &  len, const char *&  src )  [private]

This method helps count the number of characters in 'src' so that memory can be allocated for the return parameter. For all '.' , '/' and '\', the count is incremented by 'one' to account for the escape character that needs to be added. Seperators between 'id' and 'kind' as well as seperators between the name components are also counted. Definition at line 102 of file Naming_Context_Interface.cpp. Referenced by to_string(). { for (const char *j =src; *j != '\0'; ++j) { ++len; if (*j == '.' || *j == '\\' || *j == '/') ++len; } ++len; // '.' seperator or '/' seperator }

char * TAO_Naming_Context::to_url (  const char *  addr, const char *  sn )  [virtual]

The in parameter addr refers to the address of the naming context and sn refers to the strigified name of the object in that context. This function returns a fully formed URL string like iiopname://1.1@myhost.555xyz.com:9999/a/b/c Definition at line 386 of file Naming_Context_Interface.cpp. References ACE::nibble2hex(), ACE_OS::strcat(), ACE_OS::strcpy(), CORBA::string_alloc(), ACE_OS::strlen(), to_url_is_alnum_or_punctuation(), and to_url_validate_and_compute_size(). { /// Compute how many characters will be required for the URL size_t no_char = TAO_Naming_Context::to_url_validate_and_compute_size (addr, sn); // The 'corbaname:' tag is to be prepended at the starting of the // return parameter. // char prefix []= "corbaname:"; // Allocate dynamic memory // char *str_url = CORBA::string_alloc (static_cast<CORBA::ULong> (no_char + sizeof (prefix))); // Copy 'prefix' to the return parameter. char *dest = ACE_OS::strcpy (str_url , prefix); /// move to end of dest string dest += ACE_OS::strlen(dest); // Concatenate the address dest = ACE_OS::strcat (dest, addr); /// Concatenate the seperator between the addr and Name dest += ACE_OS::strlen(dest); dest = ACE_OS::strcat (dest, "#"); /// move to end of dest string dest += ACE_OS::strlen(dest); // Now append the stringified object name to the return variable. // The percent '%' character is used as an escape. If a character // that requires escaping is present in a name component it is // encoded as two hexadecimal digits following a '%' character to // represent the octet. The first hexadecimal character represents // the low-order nibble of the octet and the second hexadecimal // character represents the low order nibble. for (const char *i = sn; *i != '\0'; ++i) { if (TAO_Naming_Context::to_url_is_alnum_or_punctuation (*i)) { // If the character is a US-ASCII Alphanumeric value... *dest = *i; ++dest; continue; } // this must be an escaped character *dest = '%'; ++dest; // Append the hexadecimal representation of the character. *dest = ACE::nibble2hex ((*i) >> 4); ++dest; *dest = ACE::nibble2hex (*i); ++dest; } // Terminate the string *dest = '\0'; // ACE_OS::strcat (str_url, dest); return str_url; }

int TAO_Naming_Context::to_url_is_alnum_or_punctuation (  char  c  )  [static, private]

Return 1 if the character is alphanumeric or a non-scaped punctuation. Definition at line 330 of file Naming_Context_Interface.cpp. References ACE_OS::ace_isalnum(). Referenced by to_url(), and to_url_validate_and_compute_size(). { if (ACE_OS::ace_isalnum (c)) return 1; // NON US-ASCII charcters excluding those in this array are the // characters that need to be escaped static char non_escaped_punctuation[] = { ';', '/', ':', '?', '@', '=', '+', '$', ',', '-', '_', '.', '!', '~', '*', '\'', '(', ')' }; const size_t non_escaped_punctuation_count = sizeof(non_escaped_punctuation)/sizeof(non_escaped_punctuation[0]); for (const char *j = non_escaped_punctuation; j != non_escaped_punctuation + non_escaped_punctuation_count; ++j) { // But if the character is one of the 18 non US-ASCII characters // and hence need not be escaped, then don't increment the // count. if (*j == c) return 1; } return 0; }

size_t TAO_Naming_Context::to_url_validate_and_compute_size (  const char *  add, const char *  sn )  [static, private]

Validate the to_url() method input, and compute the size of the returned URL address. Definition at line 356 of file Naming_Context_Interface.cpp. References ACE_OS::strlen(), and to_url_is_alnum_or_punctuation(). Referenced by to_url(). { size_t addr_len = ACE_OS::strlen (addr); // Check for invalid address if (addr_len == 0) throw CosNaming::NamingContextExt::InvalidAddress (); // Make a pass through the in string name to count the number of // characters and if the character // is to be escaped, increment the number of characters by 3. size_t sn_len = 0; for (const char *i = sn; *i != '\0'; ++i) { ++sn_len; if (TAO_Naming_Context::to_url_is_alnum_or_punctuation (*i)) continue; sn_len += 3; } if (sn_len == 0) throw CosNaming::NamingContextExt::InvalidName (); return addr_len + sn_len; }

void TAO_Naming_Context::unbind (  const CosNaming::Name &  n  )  [virtual]

Remove the name binding from the context. When compound names are used, unbind is defined as follows: ctx->unbind (<c1; c2; cn>) = (ctx->resolve (<c1; c2; cn-1>))->unbind () Definition at line 69 of file Naming_Context_Interface.cpp. References CosNaming::Name, and TAO_Naming_Context_Impl::unbind(). { impl_->unbind (n); }

---

Member Data Documentation

TAO_Naming_Context_Impl* TAO_Naming_Context::impl_ [protected]

A concrete implementor of the NamingContext functions. Definition at line 230 of file Naming_Context_Interface.h.

---

The documentation for this class was generated from the following files:

• Naming_Context_Interface.h
• Naming_Context_Interface.cpp

---