TAO_Hash_Naming_Context Class Reference

This class factors out common code for two 'ConcreteImplementors' in the Bridge pattern architecture of the CosNaming::NamingContext implementation. More...

#include <Hash_Naming_Context.h>

Inheritance diagram for TAO_Hash_Naming_Context:

[legend]Collaboration diagram for TAO_Hash_Naming_Context:

[legend]List of all members.

Public Member Functions
	TAO_Hash_Naming_Context (PortableServer::POA_ptr poa, const char *poa_id)
	Constructor.
void	interface (TAO_Naming_Context *i)
	Set our pointer.
virtual	~TAO_Hash_Naming_Context (void)
	Destructor.
TAO_Naming_Context *	interface (void)
	Get the pointer to our .
int	root (void)
int	destroyed (void)
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	bind_new_context (const CosNaming::Name &n)
virtual void	destroy (void)
virtual PortableServer::POA_ptr	_default_POA (void)
	Returns the Default POA of this Servant object.
Protected Member Functions
CosNaming::NamingContext_ptr	get_context (const CosNaming::Name &name)
Protected Attributes
TAO_Bindings_Map *	context_
TAO_Naming_Context *	interface_
TAO_SYNCH_RECURSIVE_MUTEX	lock_
	Lock used to serialize access to the underlying data structure.
int	destroyed_
PortableServer::POA_var	poa_
	POA we are registered with.
ACE_CString	poa_id_

---

Detailed Description

This class factors out common code for two 'ConcreteImplementors' in the Bridge pattern architecture of the CosNaming::NamingContext implementation.

This class contains 'algorithm' code that is common to two hash-table-based implementations of the NamingContext: TAO_Transient_Naming_Context and TAO_Persistent_Naming_Context. To help achieve this 'templatization', we use the abstract base class TAO_Bindings_Map, which provides a common interface to the data structures used in TAO_Persistent_Namng_Context and TAO_Transient_Naming_Context.

Definition at line 116 of file Hash_Naming_Context.h.

---

Constructor & Destructor Documentation

TAO_Hash_Naming_Context::TAO_Hash_Naming_Context (  PortableServer::POA_ptr  poa, const char *  poa_id )

Constructor. Definition at line 31 of file Hash_Naming_Context.cpp. : context_ (0), interface_ (0), destroyed_ (0), poa_ (PortableServer::POA::_duplicate (poa)), poa_id_ (poa_id) { }

TAO_Hash_Naming_Context::~TAO_Hash_Naming_Context (  void   )  [virtual]

Destructor. Definition at line 47 of file Hash_Naming_Context.cpp. { delete context_; }

---

Member Function Documentation

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

Returns the Default POA of this Servant object. Implements TAO_Naming_Context_Impl. Definition at line 53 of file Hash_Naming_Context.cpp. Referenced by TAO_Storable_Naming_Context::destroy(), and destroy(). { return PortableServer::POA::_duplicate (this->poa_.in ()); }

void TAO_Hash_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. Implements TAO_Naming_Context_Impl. Reimplemented in TAO_Storable_Naming_Context. Definition at line 107 of file Hash_Naming_Context.cpp. References ACE_GUARD_THROW_EX, TAO_Bindings_Map::bind(), get_context(), CosNaming::Name, and TAO_SYNCH_RECURSIVE_MUTEX. { ACE_GUARD_THROW_EX (TAO_SYNCH_RECURSIVE_MUTEX, ace_mon, this->lock_, CORBA::INTERNAL ()); // Check to make sure this object didn't have <destroy> method // invoked on it. if (this->destroyed_) throw CORBA::OBJECT_NOT_EXIST (); // Get the length of the name. CORBA::ULong const name_len = n.length (); // Check for invalid name. if (name_len == 0) throw CosNaming::NamingContext::InvalidName(); // If we received compound name, resolve it to get the context in // which the binding should take place, then perform the binding on // target context. if (name_len > 1) { CosNaming::NamingContext_var context = this->get_context (n); CosNaming::Name simple_name; simple_name.length (1); simple_name[0] = n[name_len - 1]; try { context->bind (simple_name, obj); } catch (const CORBA::SystemException&) { throw CosNaming::NamingContext::CannotProceed( context.in (), simple_name); } } // If we received a simple name, we need to bind it in this context. else { // Try binding the name. int result = this->context_->bind (n[0].id, n[0].kind, obj, CosNaming::nobject); if (result == 1) throw CosNaming::NamingContext::AlreadyBound(); // Something went wrong with the internal structure else if (result == -1) throw CORBA::INTERNAL (); } }

void TAO_Hash_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. Implements TAO_Naming_Context_Impl. Reimplemented in TAO_Storable_Naming_Context. Definition at line 221 of file Hash_Naming_Context.cpp. References ACE_GUARD_THROW_EX, TAO_Bindings_Map::bind(), get_context(), CORBA::is_nil(), CosNaming::Name, and TAO_SYNCH_RECURSIVE_MUTEX. Referenced by bind_new_context(). { ACE_GUARD_THROW_EX (TAO_SYNCH_RECURSIVE_MUTEX, ace_mon, this->lock_, CORBA::INTERNAL ()); // Check to make sure this object didn't have <destroy> method // invoked on it. if (this->destroyed_) throw CORBA::OBJECT_NOT_EXIST (); // Do not allow binding of nil context reference. if (CORBA::is_nil (nc)) throw CORBA::BAD_PARAM (); // Get the length of the name. CORBA::ULong const name_len = n.length (); // Check for invalid name. if (name_len == 0) throw CosNaming::NamingContext::InvalidName(); // If we received compound name, resolve it to get the context in // which the binding should take place, then perform the binding on // target context. if (name_len > 1) { CosNaming::NamingContext_var context = get_context (n); CosNaming::Name simple_name; simple_name.length (1); simple_name[0] = n[name_len - 1]; try { context->bind_context (simple_name, nc); } catch (const CORBA::SystemException&) { throw CosNaming::NamingContext::CannotProceed( context.in (), simple_name); } } // If we received a simple name, we need to bind it in this context. else { // Try binding the name. int result = this->context_->bind (n[0].id, n[0].kind, nc, CosNaming::ncontext); if (result == 1) throw CosNaming::NamingContext::AlreadyBound(); // Something went wrong with the internal structure else if (result == -1) throw CORBA::INTERNAL (); } }

CosNaming::NamingContext_ptr TAO_Hash_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). Implements TAO_Naming_Context_Impl. Reimplemented in TAO_Storable_Naming_Context. Definition at line 482 of file Hash_Naming_Context.cpp. References ACE_GUARD_THROW_EX, bind_context(), get_context(), CosNaming::Name, TAO_Naming_Context_Impl::new_context(), and TAO_SYNCH_RECURSIVE_MUTEX. { ACE_GUARD_THROW_EX (TAO_SYNCH_RECURSIVE_MUTEX, ace_mon, this->lock_, CORBA::INTERNAL ()); // Check to make sure this object didn't have <destroy> method // invoked on it. if (this->destroyed_) throw CORBA::OBJECT_NOT_EXIST (); // Get the length of the name. CORBA::ULong name_len = n.length (); // Check for invalid name. if (name_len == 0) throw CosNaming::NamingContext::InvalidName(); // If we received compound name, resolve it to get the context in // which the binding should take place, then perform the operation on // target context. if (name_len > 1) { CosNaming::NamingContext_var context = get_context (n); CosNaming::Name simple_name; simple_name.length (1); simple_name[0] = n[name_len - 1]; return context->bind_new_context (simple_name); } // If we received a simple name, we need to bind it in this context. // Stores our new Naming Context. CosNaming::NamingContext_var result = CosNaming::NamingContext::_nil (); // Create new context. result = new_context (); // Bind the new context to the name. try { bind_context (n, result.in ()); } catch (const CORBA::Exception&) { // If the bind() operation fails we must destroy the recently // created context, should any exceptions be raised by the // destroy() operation we want to ignore them. { try { result->destroy (); } catch (const CORBA::Exception&) { } } // Re-raise the exception in bind_context() throw; } return result._retn (); }

void TAO_Hash_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. Implements TAO_Naming_Context_Impl. Reimplemented in TAO_Storable_Naming_Context. Definition at line 550 of file Hash_Naming_Context.cpp. References _default_POA(), ACE_GUARD_THROW_EX, TAO_Bindings_Map::current_size(), poa_id_, root(), and TAO_SYNCH_RECURSIVE_MUTEX. { ACE_GUARD_THROW_EX (TAO_SYNCH_RECURSIVE_MUTEX, ace_mon, this->lock_, CORBA::INTERNAL ()); // Check to make sure this object didn't have <destroy> method // invoked on it. if (this->destroyed_) throw CORBA::OBJECT_NOT_EXIST (); if (this->context_->current_size () != 0) throw CosNaming::NamingContext::NotEmpty(); // Destroy is a no-op on a root context. if (root ()) return; else { this->destroyed_ = 2; // Remove self from POA. Because of reference counting, the POA // will automatically delete the servant when all pending requests // on this servant are complete. PortableServer::POA_var poa = this->_default_POA (); PortableServer::ObjectId_var id = PortableServer::string_to_ObjectId (poa_id_.fast_rep ()); poa->deactivate_object (id.in ()); } }

int TAO_Hash_Naming_Context::destroyed (  void   )

Returns true if this context had operation invoked on it, and false otherwise. Definition at line 595 of file Hash_Naming_Context.cpp. Referenced by TAO_Bindings_Iterator< ITERATOR, TABLE_ENTRY >::next_n(), and TAO_Bindings_Iterator< ITERATOR, TABLE_ENTRY >::next_one(). { return this->destroyed_; }

CosNaming::NamingContext_ptr TAO_Hash_Naming_Context::get_context (  const CosNaming::Name &  name  )  [protected]

is used by methods that need to resolve a compound name before performing the actual operation (e.g., bind, unbind, etc.) takes a full name (including the last component that doesn't need to be resolved), and returns a pointer to the target context. Definition at line 59 of file Hash_Naming_Context.cpp. References CORBA::is_nil(), CosNaming::Name, and resolve(). Referenced by TAO_Storable_Naming_Context::bind(), bind(), TAO_Storable_Naming_Context::bind_context(), bind_context(), TAO_Storable_Naming_Context::bind_new_context(), bind_new_context(), TAO_Storable_Naming_Context::rebind(), rebind(), TAO_Storable_Naming_Context::rebind_context(), rebind_context(), TAO_Storable_Naming_Context::unbind(), and unbind(). { // Naming context we will return. CosNaming::NamingContext_var result = CosNaming::NamingContext::_nil (); // Create compound name to be resolved, i.e., // (<name> - last component). To avoid copying, we can just reuse // <name>'s buffer, since we will not be modifying it. CORBA::ULong name_len = name.length (); CosNaming::Name comp_name (name.maximum (), name_len - 1, const_cast<CosNaming::NameComponent*> (name.get_buffer ())); try { // Resolve the name. CORBA::Object_var context = resolve (comp_name); // Try narrowing object reference to the NamingContext type. result = CosNaming::NamingContext::_narrow (context.in ()); } catch (CosNaming::NamingContext::NotFound& ex) { // Add the last component of the name, which was stripped before // the call to resolve. CORBA::ULong rest_len = ex.rest_of_name.length () + 1; ex.rest_of_name.length (rest_len); ex.rest_of_name[rest_len - 1] = name[name_len - 1]; throw; } if (CORBA::is_nil (result.in ())) { CosNaming::Name rest; rest.length (2); rest[0] = name[name_len - 2]; rest[1] = name[name_len - 1]; throw CosNaming::NamingContext::NotFound( CosNaming::NamingContext::not_context, rest); } // Finally, if everything went smoothly, just return the resolved // context. return result._retn (); }

TAO_Naming_Context * TAO_Hash_Naming_Context::interface (  void   )

Get the pointer to our . Definition at line 601 of file Hash_Naming_Context.cpp. References interface_. { return this->interface_; }

void TAO_Hash_Naming_Context::interface (  TAO_Naming_Context *  i  )

Set our pointer. Definition at line 42 of file Hash_Naming_Context.cpp. References interface_. Referenced by TAO_Bindings_Iterator< ITERATOR, TABLE_ENTRY >::~TAO_Bindings_Iterator(). { this->interface_ = i; }

void TAO_Hash_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. Implements TAO_Naming_Context_Impl. Reimplemented in TAO_Storable_Naming_Context. Definition at line 163 of file Hash_Naming_Context.cpp. References ACE_GUARD_THROW_EX, get_context(), CosNaming::Name, TAO_Bindings_Map::rebind(), and TAO_SYNCH_RECURSIVE_MUTEX. { ACE_GUARD_THROW_EX (TAO_SYNCH_RECURSIVE_MUTEX, ace_mon, this->lock_, CORBA::INTERNAL ()); // Check to make sure this object didn't have <destroy> method // invoked on it. if (this->destroyed_) throw CORBA::OBJECT_NOT_EXIST (); // Get the length of the name. CORBA::ULong const name_len = n.length (); // Check for invalid name. if (name_len == 0) throw CosNaming::NamingContext::InvalidName(); // If we received compound name, resolve it to get the context in // which the rebinding should take place, then perform the rebinding // on target context. if (name_len > 1) { CosNaming::NamingContext_var context = get_context (n); CosNaming::Name simple_name; simple_name.length (1); simple_name[0] = n[name_len - 1]; try { context->rebind (simple_name, obj); } catch (const CORBA::SystemException&) { throw CosNaming::NamingContext::CannotProceed( context.in (), simple_name); } } else // If we received a simple name, we need to rebind it in this // context. { int result = this->context_->rebind (n[0].id, n[0].kind, obj, CosNaming::nobject); // Check for error conditions. if (result == -1) throw CORBA::INTERNAL (); else if (result == -2) throw CosNaming::NamingContext::NotFound( CosNaming::NamingContext::not_object, n); } }

void TAO_Hash_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. Implements TAO_Naming_Context_Impl. Reimplemented in TAO_Storable_Naming_Context. Definition at line 282 of file Hash_Naming_Context.cpp. References ACE_GUARD_THROW_EX, get_context(), CosNaming::Name, TAO_Bindings_Map::rebind(), and TAO_SYNCH_RECURSIVE_MUTEX. { ACE_GUARD_THROW_EX (TAO_SYNCH_RECURSIVE_MUTEX, ace_mon, this->lock_, CORBA::INTERNAL ()); // Check to make sure this object didn't have <destroy> method // invoked on it. if (this->destroyed_) throw CORBA::OBJECT_NOT_EXIST (); // Get the length of the name. CORBA::ULong const name_len = n.length (); // Check for invalid name. if (name_len == 0) throw CosNaming::NamingContext::InvalidName(); // If we received compound name, resolve it to get the context in // which the rebinding should take place, then perform the rebinding // on target context. if (name_len > 1) { CosNaming::NamingContext_var context = get_context (n); CosNaming::Name simple_name; simple_name.length (1); simple_name[0] = n[name_len - 1]; try { context->rebind_context (simple_name, nc); } catch (const CORBA::SystemException&) { throw CosNaming::NamingContext::CannotProceed( context.in (), simple_name); } } else // If we received a simple name, we need to rebind it in this // context. { int result = this->context_->rebind (n[0].id, n[0].kind, nc, CosNaming::ncontext); // Check for error conditions. if (result == -1) throw CORBA::INTERNAL (); else if (result == -2) throw CosNaming::NamingContext::NotFound( CosNaming::NamingContext::not_context, n); } }

CORBA::Object_ptr TAO_Hash_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. Implements TAO_Naming_Context_Impl. Reimplemented in TAO_Storable_Naming_Context. Definition at line 342 of file Hash_Naming_Context.cpp. References ACE_GUARD_THROW_EX, TAO_Bindings_Map::find(), CORBA::is_nil(), CosNaming::Name, and TAO_SYNCH_RECURSIVE_MUTEX. Referenced by get_context(). { ACE_GUARD_THROW_EX (TAO_SYNCH_RECURSIVE_MUTEX, ace_mon, this->lock_, CORBA::INTERNAL ()); // Check to make sure this object didn't have <destroy> method // invoked on it. if (this->destroyed_) throw CORBA::OBJECT_NOT_EXIST (); // Get the length of the name. CORBA::ULong const name_len = n.length (); // Check for invalid name. if (name_len == 0) throw CosNaming::NamingContext::InvalidName(); // Resolve the first component of the name. // Stores the binding type for the first name component. CosNaming::BindingType type; // Stores the object reference bound to the first name component. CORBA::Object_var result; if (this->context_->find (n[0].id, n[0].kind, result.out (), type) == -1) throw CosNaming::NamingContext::NotFound( CosNaming::NamingContext::missing_node, n); // If the name we have to resolve is a compound name, we need to // resolve it recursively. if (name_len > 1) { CosNaming::NamingContext_var context = CosNaming::NamingContext::_nil (); if (type == CosNaming::ncontext) { // Narrow to NamingContext. context = CosNaming::NamingContext::_narrow (result.in ()); } else // The first name component wasn't bound to a NamingContext. throw CosNaming::NamingContext::NotFound( CosNaming::NamingContext::not_context, n); // If narrow failed... if (CORBA::is_nil (context.in ())) throw CosNaming::NamingContext::NotFound( CosNaming::NamingContext::not_context, n); else { // Successfully resolved the first name component, need to // recursively call resolve on <n> without the first component. // We need a name just like <n> but without the first // component. Instead of copying data we can reuse <n>'s // buffer since we will only be using it for 'in' parameters // (no modifications). CosNaming::Name rest_of_name (n.maximum () - 1, n.length () - 1, const_cast<CosNaming::NameComponent*> (n.get_buffer ()) + 1); // If there are any exceptions, they will propagate up. try { CORBA::Object_ptr resolved_ref; resolved_ref = context->resolve (rest_of_name); return resolved_ref; } catch (const CORBA::SystemException&) { throw CosNaming::NamingContext::CannotProceed( context.in (), rest_of_name); } } } // If the name we had to resolve was simple, we just need to return // the result. return result._retn (); }

int TAO_Hash_Naming_Context::root (  void   )

Returns true if this Naming Context is a root Naming Context for the server, and false otherwise. Definition at line 588 of file Hash_Naming_Context.cpp. References ACE_OS::strcmp(), and TAO_ROOT_NAMING_CONTEXT. Referenced by TAO_Storable_Naming_Context::destroy(), and destroy(). { return (ACE_OS::strcmp (this->poa_id_.fast_rep (), TAO_ROOT_NAMING_CONTEXT) == 0); }

void TAO_Hash_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 () Implements TAO_Naming_Context_Impl. Reimplemented in TAO_Storable_Naming_Context. Definition at line 433 of file Hash_Naming_Context.cpp. References ACE_GUARD_THROW_EX, get_context(), CosNaming::Name, TAO_SYNCH_RECURSIVE_MUTEX, and TAO_Bindings_Map::unbind(). { ACE_GUARD_THROW_EX (TAO_SYNCH_RECURSIVE_MUTEX, ace_mon, this->lock_, CORBA::INTERNAL ()); // Check to make sure this object didn't have <destroy> method // invoked on it. if (this->destroyed_) throw CORBA::OBJECT_NOT_EXIST (); // Get the length of the name. CORBA::ULong const name_len = n.length (); // Check for invalid name. if (name_len == 0) throw CosNaming::NamingContext::InvalidName(); // If we received compound name, resolve it to get the context in // which the unbinding should take place, then perform the unbinding // on target context. if (name_len > 1) { CosNaming::NamingContext_var context = get_context (n); CosNaming::Name simple_name; simple_name.length (1); simple_name[0] = n[name_len - 1]; try { context->unbind (simple_name); } catch (const CORBA::SystemException&) { throw CosNaming::NamingContext::CannotProceed( context.in (), simple_name); } } // If we received a simple name, we need to unbind it in this // context. else if (this->context_->unbind (n[0].id, n[0].kind) == -1) throw CosNaming::NamingContext::NotFound( CosNaming::NamingContext::missing_node, n); }

---

Member Data Documentation

TAO_Bindings_Map* TAO_Hash_Naming_Context::context_ [protected]

Pointer to the data structure used to store this Naming Context's bindings. is initialized with a concrete data structure by subclasses, which know which data structure to use. Definition at line 236 of file Hash_Naming_Context.h. Referenced by TAO_Storable_Naming_Context::new_context(), and TAO_Storable_Naming_Context::recreate_all().

int TAO_Hash_Naming_Context::destroyed_ [protected]

Flag indicating whether this Naming Context is no longer valid. This flag is necessary because immediate destruction might not be possible if there are pending requests on this servant in the POA. Definition at line 255 of file Hash_Naming_Context.h.

TAO_Naming_Context* TAO_Hash_Naming_Context::interface_ [protected]

Pointer to the object for which we serve as a , i.e., the object that delegates to us all client CosNaming::NamingContext CORBA calls. We need this pointer for reference counting. Definition at line 244 of file Hash_Naming_Context.h. Referenced by interface().

TAO_SYNCH_RECURSIVE_MUTEX TAO_Hash_Naming_Context::lock_ [protected]

Lock used to serialize access to the underlying data structure. Definition at line 247 of file Hash_Naming_Context.h.

PortableServer::POA_var TAO_Hash_Naming_Context::poa_ [protected]

POA we are registered with. Reimplemented in TAO_Storable_Naming_Context. Definition at line 258 of file Hash_Naming_Context.h.

ACE_CString TAO_Hash_Naming_Context::poa_id_ [protected]

ID with which we are registered with . Note, if is equivalent to TAO_ROOT_NAMING_CONTEXT, then this Naming Context is the root Naming Context for the server, i.e., it is un<destroy>able. Definition at line 265 of file Hash_Naming_Context.h. Referenced by destroy(), and TAO_Persistent_Naming_Context::make_new_context().

---

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

• Hash_Naming_Context.h
• Hash_Naming_Context.cpp

---