TAO_Persistent_Naming_Context Class Reference

This class plays a role of a 'ConcreteImplementor' in the Bridge pattern architecture of the CosNaming::NamingContext implementation. More...

#include <Persistent_Naming_Context.h>

Inheritance diagram for TAO_Persistent_Naming_Context:

[legend]Collaboration diagram for TAO_Persistent_Naming_Context:

[legend]List of all members.

Public Types
typedef TAO_Persistent_Bindings_Map::HASH_MAP	HASH_MAP
	Underlying data structure - typedef for ease of use.
Public Member Functions
	TAO_Persistent_Naming_Context (PortableServer::POA_ptr poa, const char *poa_id, TAO_Persistent_Context_Index *context_index)
int	init (size_t hash_table_size=ACE_DEFAULT_MAP_SIZE)
	TAO_Persistent_Naming_Context (PortableServer::POA_ptr poa, const char *poa_id, TAO_Persistent_Context_Index *context_index, HASH_MAP *map, ACE_UINT32 *counter)
virtual	~TAO_Persistent_Naming_Context (void)
	Destructor.
virtual CosNaming::NamingContext_ptr	new_context (void)
virtual void	list (CORBA::ULong how_many, CosNaming::BindingList_out &bl, CosNaming::BindingIterator_out &bi)
Static Public Member Functions
static CosNaming::NamingContext_ptr	make_new_context (PortableServer::POA_ptr poa, const char *poa_id, size_t context_size, TAO_Persistent_Context_Index *ind)
Protected Member Functions
void	set_cleanup_level (int level)
Protected Attributes
ACE_UINT32 *	counter_
TAO_Persistent_Bindings_Map *	persistent_context_
TAO_Persistent_Context_Index *	index_

---

Detailed Description

This class plays a role of a 'ConcreteImplementor' in the Bridge pattern architecture of the CosNaming::NamingContext implementation.

This class provides a persistent implementation of the NamingContext functionality, i.e., the state is preserved across process boundaries. Derives from TAO_Hash_Naming_Context and uses TAO_Persistent_Bindings_Map to store name to object bindings.

Definition at line 164 of file Persistent_Naming_Context.h.

---

Member Typedef Documentation

typedef TAO_Persistent_Bindings_Map::HASH_MAP TAO_Persistent_Naming_Context::HASH_MAP

Underlying data structure - typedef for ease of use.

Definition at line 168 of file Persistent_Naming_Context.h.

---

Constructor & Destructor Documentation

TAO_Persistent_Naming_Context::TAO_Persistent_Naming_Context	(	PortableServer::POA_ptr	poa,
		const char *	poa_id,
		TAO_Persistent_Context_Index *	context_index
	)

Constructor. MUST be followed up by <init> to allocate the underlying data structure from persistent storage!

Definition at line 239 of file Persistent_Naming_Context.cpp.

References ACE_NEW, TAO_Hash_Naming_Context::context_, TAO_Persistent_Context_Index::orb(), and persistent_context_.

  : TAO_Hash_Naming_Context (poa,
                             poa_id),
    counter_ (0),
    persistent_context_ (0),
    index_ (context_index)
{
  ACE_NEW (this->persistent_context_,
           TAO_Persistent_Bindings_Map (context_index->orb ()));

  // Set the superclass pointer.
  context_ = persistent_context_;
}

TAO_Persistent_Naming_Context::TAO_Persistent_Naming_Context	(	PortableServer::POA_ptr	poa,
		const char *	poa_id,
		TAO_Persistent_Context_Index *	context_index,
		HASH_MAP *	map,
		ACE_UINT32 *	counter
	)

Constructor that takes in preallocated data structure and takes ownership of it. This constructor is for 'recreating' servants from persistent state.

Definition at line 256 of file Persistent_Naming_Context.cpp.

References ACE_NEW, TAO_Persistent_Context_Index::allocator(), TAO_Hash_Naming_Context::context_, index_, TAO_Persistent_Context_Index::orb(), persistent_context_, and TAO_Persistent_Bindings_Map::set().

  : TAO_Hash_Naming_Context (poa,
                             poa_id),
    counter_ (counter),
    persistent_context_ (0),
    index_ (context_index)
{
  ACE_NEW (this->persistent_context_,
           TAO_Persistent_Bindings_Map (context_index->orb ()));

  // Set the superclass pointer.
  context_ = persistent_context_;

  persistent_context_->set (map, index_->allocator ());
}

TAO_Persistent_Naming_Context::~TAO_Persistent_Naming_Context

(

void

)

[virtual]

Destructor.

Definition at line 282 of file Persistent_Naming_Context.cpp.

References ACE_String_Base< CHAR >::c_str(), TAO_Persistent_Bindings_Map::destroy(), index_, persistent_context_, TAO_Hash_Naming_Context::poa_id_, and TAO_Persistent_Context_Index::unbind().

{
  // Perform appropriate cleanup based on the destruction level specified.

  if (this->destroyed_ > 1)
    {
      // Remove ourselves from context index.
      index_->unbind (poa_id_.c_str ());
      // Remove the underlying data structure from persistent storage.
      persistent_context_->destroy ();
    }
  else if (this->destroyed_ == 1)
    // Remove the underlying data structure from persistent storage.
    persistent_context_->destroy ();
}

---

Member Function Documentation

int TAO_Persistent_Naming_Context::init

(

size_t

hash_table_size = ACE_DEFAULT_MAP_SIZE

)

Allocate the underlying data structure from persistent storage. Returns 0 on success and -1 on failure.

Definition at line 277 of file Persistent_Naming_Context.cpp.

References TAO_Persistent_Context_Index::allocator(), index_, TAO_Persistent_Bindings_Map::open(), and persistent_context_.

Referenced by make_new_context().

{
  return persistent_context_->open (hash_table_size, index_->allocator ());
}

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

Returns at most the requested number of bindings <how_many> in <bl>. If the naming context contains additional bindings, they are returned with a BindingIterator. In the naming context does not contain any additional bindings <bi> returned as null.

Implements TAO_Naming_Context_Impl.

Definition at line 399 of file Persistent_Naming_Context.cpp.

References ACE_GUARD_THROW_EX, ACE_NEW_THROW_EX, TAO_Hash_Naming_Context::context_, counter_, TAO_Bindings_Map::current_size(), TAO_Hash_Naming_Context::interface_, TAO_Hash_Naming_Context::lock_, TAO_Persistent_Bindings_Map::map(), persistent_context_, TAO_Hash_Naming_Context::poa_, ACE_OS::sprintf(), and TAO_SYNCH_RECURSIVE_MUTEX.

{
  // Allocate nil out parameters in case we won't be able to complete
  // the operation.
  bi = CosNaming::BindingIterator::_nil ();
  ACE_NEW_THROW_EX (bl,
                    CosNaming::BindingList (0),
                    CORBA::NO_MEMORY ());

  // Obtain a lock before we proceed with the operation.
  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 ();

  // Dynamically allocate hash map iterator.
  HASH_MAP::ITERATOR *hash_iter = 0;
  ACE_NEW_THROW_EX (hash_iter,
                    HASH_MAP::ITERATOR
                    (*persistent_context_->map ()),
                    CORBA::NO_MEMORY ());

  // Store <hash_iter temporarily in auto pointer, in case we'll have
  // some failures and throw an exception.
  ACE_Auto_Basic_Ptr<HASH_MAP::ITERATOR> temp (hash_iter);

  // Silliness below is required because of broken old g++!!!  E.g.,
  // without it, we could have just said HASH_MAP::ITERATOR everywhere we use ITER_DEF.
  typedef ACE_Hash_Map_With_Allocator<TAO_Persistent_ExtId, TAO_Persistent_IntId>::ITERATOR ITER_DEF;
  typedef ACE_Hash_Map_With_Allocator<TAO_Persistent_ExtId, TAO_Persistent_IntId>::ENTRY ENTRY_DEF;

  // Typedef to the type of BindingIterator servant for ease of use.
  typedef TAO_Bindings_Iterator<ITER_DEF, ENTRY_DEF> ITER_SERVANT;

  // A pointer to BindingIterator servant.
  ITER_SERVANT *bind_iter = 0;

  // Number of bindings that will go into the BindingList.
  CORBA::ULong n;

  // Calculate number of bindings that will go into bl.
  if (this->context_->current_size () > how_many)
    n = how_many;
  else
    n = static_cast<CORBA::ULong> (this->context_->current_size ());

  // Use hash iterator to populate a BindingList with bindings.
  bl->length (n);

  ENTRY_DEF *hash_entry = 0;

  for (CORBA::ULong i = 0; i < n; i++)
    {
      hash_iter->next (hash_entry);
      hash_iter->advance ();

      if (ITER_SERVANT::populate_binding (hash_entry, bl[i]) == 0)
          throw CORBA::NO_MEMORY();
    }

  // Now we are done with the BindingsList, and we can follow up on
  // the iterator business.

  // If we do not need to pass back BindingIterator.
  if (this->context_->current_size () <= how_many)
    return;
  else
    {
      // Create a BindingIterator for return.
      ACE_NEW_THROW_EX (bind_iter,
                        ITER_SERVANT (this, hash_iter, this->poa_.in (), this->lock_),
                        CORBA::NO_MEMORY ());

      // Release <hash_iter> from auto pointer, and start using the
      // reference counting to control our servant.
      temp.release ();
      PortableServer::ServantBase_var iter = bind_iter;

      // Increment reference count on this Naming Context, so it doesn't get
      // deleted before the BindingIterator servant gets deleted.
      interface_->_add_ref ();

      // Register with the POA.
      char poa_id[BUFSIZ];
      ACE_OS::sprintf (poa_id,
                       "%s_%d",
                       this->poa_id_.c_str (),
                       (*this->counter_)++);
      PortableServer::ObjectId_var id =
        PortableServer::string_to_ObjectId (poa_id);

      this->poa_->activate_object_with_id (id.in (),
                                           bind_iter);

      bi = bind_iter->_this ();
    }
}

CosNaming::NamingContext_ptr TAO_Persistent_Naming_Context::make_new_context	(	PortableServer::POA_ptr	poa,
		const char *	poa_id,
		size_t	context_size,
		TAO_Persistent_Context_Index *	ind
	)			[static]

This utility method factors out the code needed to create a new Persistent Naming Context servant and activate it under the specified POA with the specified id. This function is static so that the code can be used, both from inside the class (e.g., <new_context>), and from outside (e.g., Naming_Utils.cpp).

Definition at line 305 of file Persistent_Naming_Context.cpp.

References ACE_NEW_THROW_EX, TAO_Persistent_Context_Index::bind(), ACE_String_Base< CHAR >::c_str(), counter_, init(), TAO_Persistent_Bindings_Map::map(), persistent_context_, TAO_Hash_Naming_Context::poa_id_, ACE_Auto_Basic_Ptr< X >::release(), and set_cleanup_level().

Referenced by TAO_Persistent_Context_Index::init(), and new_context().

{
  // Store the stub we will return here.
  CosNaming::NamingContext_var result;

  // Put together a servant for the new Naming Context.

  TAO_Persistent_Naming_Context *context_impl = 0;
  ACE_NEW_THROW_EX (context_impl,
                    TAO_Persistent_Naming_Context (poa,
                                                   poa_id,
                                                   ind),
                    CORBA::NO_MEMORY ());

  // Put <context_impl> into the auto pointer temporarily, in case next
  // allocation fails.
  ACE_Auto_Basic_Ptr<TAO_Persistent_Naming_Context> temp (context_impl);

  if (context_impl->init (context_size) == -1)
    throw CORBA::NO_MEMORY ();

  // Insure appropriate cleanup in case of exception conditions ahead.
  context_impl->set_cleanup_level (1);

  // Register with the index of Naming Contexts.
  if (ind->bind (context_impl->poa_id_.c_str (),
                 context_impl->counter_,
                 context_impl->persistent_context_->map ()) == -1)
    throw CORBA::INTERNAL ();

  // Insure appropriate cleanup in case of exception conditions ahead.
  context_impl->set_cleanup_level (2);

  TAO_Naming_Context *context = 0;
  ACE_NEW_THROW_EX (context,
                    TAO_Naming_Context (context_impl),
                    CORBA::NO_MEMORY ());

  // Let <implementation> know about it's <interface>.
  context_impl->interface (context);

  // Release auto pointer, and start using reference counting to
  // control our servant.
  temp.release ();
  PortableServer::ServantBase_var s = context;

  // Register the new context with the POA.
  PortableServer::ObjectId_var id =
    PortableServer::string_to_ObjectId (poa_id);

  poa->activate_object_with_id (id.in (),
                                context);

  result = context->_this ();

  // Everything went smoothly, without errors - we don't need any cleanup.
  context_impl->set_cleanup_level (0);

  return result._retn ();
}

CosNaming::NamingContext_ptr TAO_Persistent_Naming_Context::new_context

(

void

)

[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.

Implements TAO_Naming_Context_Impl.

Definition at line 370 of file Persistent_Naming_Context.cpp.

References ACE_GUARD_THROW_EX, counter_, index_, make_new_context(), persistent_context_, ACE_OS::sprintf(), TAO_SYNCH_RECURSIVE_MUTEX, and TAO_Persistent_Bindings_Map::total_size().

{
  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 ();

  // Generate a POA id for the new context.
  char poa_id[BUFSIZ];
  ACE_OS::sprintf (poa_id,
                   "%s_%d",
                   this->poa_id_.c_str (),
                   (*this->counter_)++);

  CosNaming::NamingContext_var result =
    make_new_context (this->poa_.in (),
                      poa_id,
                      this->persistent_context_->total_size (),
                      this->index_);

  return result._retn ();
}

void TAO_Persistent_Naming_Context::set_cleanup_level

(

int

level

)

[protected]

Set <destroyed_> flag (inherited from TAO_Hash_Naming_Context) to <level>. Legal values for <destroyed_> are 0, 1, and 2. The values specify the extent of cleanup that should take place in the context's destructor: '0' - no cleanup (e.g., if the context goes out of scope, but it's state is to remain in persistent storage); '1' - free up the underlying data structure in persistent storage (e.g., if the initialization of this context was only partially completed due to some failures, and we need to roll back); '2' - free up the underlying data structure, and deregister this naming context from its <index_> (e.g., if the context had <destroy> method invoked and needs to be completely removed from existence).

Definition at line 299 of file Persistent_Naming_Context.cpp.

References TAO_Hash_Naming_Context::destroyed_.

Referenced by make_new_context().

{
  this->destroyed_ = level;
}

---

Member Data Documentation

ACE_UINT32* TAO_Persistent_Naming_Context::counter_ [protected]

Counter used for generation of POA ids for children Naming Contexts.

Definition at line 248 of file Persistent_Naming_Context.h.

Referenced by list(), make_new_context(), and new_context().

TAO_Persistent_Context_Index* TAO_Persistent_Naming_Context::index_ [protected]

A pointer to the index object of this naming service: it keeps track of all the naming contexts created. Every time we make a new context or destroy one, we need to make an entry there. Also, we get the allocator needed to initialize us from this guy.

Definition at line 265 of file Persistent_Naming_Context.h.

Referenced by init(), new_context(), TAO_Persistent_Naming_Context(), and ~TAO_Persistent_Naming_Context().

TAO_Persistent_Bindings_Map* TAO_Persistent_Naming_Context::persistent_context_ [protected]

A pointer to the underlying data structure used to store name bindings. While our superclass (TAO_Hash_Naming_Context) also maintains a pointer to the data structure, keeping this pointer around saves us from the need to downcast when invoking non-virtual methods.

Definition at line 257 of file Persistent_Naming_Context.h.

Referenced by init(), list(), make_new_context(), new_context(), TAO_Persistent_Naming_Context(), and ~TAO_Persistent_Naming_Context().

---

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

• Persistent_Naming_Context.h
• Persistent_Naming_Context.cpp

---