TAO_Storable_Naming_Context Class Reference

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

#include <Storable_Naming_Context.h>

Inheritance diagram for TAO_Storable_Naming_Context:

[legend]Collaboration diagram for TAO_Storable_Naming_Context:

[legend]List of all members.

Public Types
typedef TAO_Storable_Bindings_Map::HASH_MAP	HASH_MAP
	Underlying data structure - typedef for ease of use.
Public Member Functions
	TAO_Storable_Naming_Context (CORBA::ORB_ptr orb, PortableServer::POA_ptr poa, const char *poa_id, TAO_Naming_Service_Persistence_Factory *factory, const ACE_TCHAR *persistence_directory, size_t hash_table_size=ACE_DEFAULT_MAP_SIZE)
	Constructor.
virtual	~TAO_Storable_Naming_Context (void)
	Destructor.
virtual CosNaming::NamingContext_ptr	new_context (ACE_ENV_SINGLE_ARG_DECL)
virtual void	list (CORBA::ULong how_many, CosNaming::BindingList_out &bl, CosNaming::BindingIterator_out &bi ACE_ENV_ARG_DECL)
virtual void	rebind (const CosNaming::Name &n, CORBA::Object_ptr obj ACE_ENV_ARG_DECL)
virtual void	bind (const CosNaming::Name &n, CORBA::Object_ptr obj ACE_ENV_ARG_DECL)
virtual void	bind_context (const CosNaming::Name &n, CosNaming::NamingContext_ptr nc ACE_ENV_ARG_DECL)
virtual void	rebind_context (const CosNaming::Name &n, CosNaming::NamingContext_ptr nc ACE_ENV_ARG_DECL)
virtual CORBA::Object_ptr	resolve (const CosNaming::Name &n ACE_ENV_ARG_DECL)
virtual void	unbind (const CosNaming::Name &n ACE_ENV_ARG_DECL)
virtual CosNaming::NamingContext_ptr	bind_new_context (const CosNaming::Name &n ACE_ENV_ARG_DECL)
virtual void	destroy (ACE_ENV_SINGLE_ARG_DECL)
Static Public Member Functions
CosNaming::NamingContext_ptr	make_new_context (CORBA::ORB_ptr orb, PortableServer::POA_ptr poa, const char *poa_id, size_t context_size, TAO_Naming_Service_Persistence_Factory *factory, const ACE_TCHAR *persistence_directory, TAO_Storable_Naming_Context **new_context ACE_ENV_ARG_DECL)
CosNaming::NamingContext_ptr	recreate_all (CORBA::ORB_ptr orb, PortableServer::POA_ptr poa, const char *poa_id, size_t context_size, int reentering, TAO_Naming_Service_Persistence_Factory *factory, const ACE_TCHAR *persistence_directory, int use_redundancy ACE_ENV_ARG_DECL)
Protected Member Functions
int	load_map (File_Open_Lock_and_Check *flck ACE_ENV_ARG_DECL)
void	Write (TAO_Storable_Base &wrtr)
Protected Attributes
ACE_UINT32	counter_
	Counter used for generation of transients.
TAO_Storable_Bindings_Map *	storable_context_
CORBA::ORB_var	orb_
ACE_CString	name_
PortableServer::POA_var	poa_
	POA we are registered with.
TAO_Naming_Service_Persistence_Factory *	factory_
ACE_CString	persistence_directory_
	The directory in which to store the files.
size_t	hash_table_size_
	Save the hash table initial size.
time_t	last_changed_
	Disk time that match current memory state.
Static Protected Attributes
ACE_UINT32	gcounter_
int	redundant_
	Flag to tell use whether we are redundant or not.
const char *	root_name_
ACE_Auto_Ptr< TAO_Storable_Base >	gfl_
	The pointer to the global file used to allocate new contexts.
Friends
class	File_Open_Lock_and_Check

---

Detailed Description

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

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

Definition at line 219 of file Storable_Naming_Context.h.

---

Member Typedef Documentation

typedef TAO_Storable_Bindings_Map::HASH_MAP TAO_Storable_Naming_Context::HASH_MAP

Underlying data structure - typedef for ease of use. Definition at line 225 of file Storable_Naming_Context.h.

---

Constructor & Destructor Documentation

TAO_Storable_Naming_Context::TAO_Storable_Naming_Context (  CORBA::ORB_ptr  orb, PortableServer::POA_ptr  poa, const char *  poa_id, TAO_Naming_Service_Persistence_Factory *  factory, const ACE_TCHAR *  persistence_directory, size_t  hash_table_size = ACE_DEFAULT_MAP_SIZE )

Constructor. Definition at line 522 of file Storable_Naming_Context.cpp. References ACE_TEXT_ALWAYS_CHAR, and ACE_TRACE. : TAO_Hash_Naming_Context (poa, poa_id), counter_ (0), storable_context_ (0), orb_(CORBA::ORB::_duplicate (orb)), name_ (poa_id), poa_ (PortableServer::POA::_duplicate (poa)), factory_(factory), persistence_directory_ (ACE_TEXT_ALWAYS_CHAR(persistence_directory)), hash_table_size_(hash_table_size), last_changed_(0) { ACE_TRACE("TAO_Storable_Naming_Context"); }

TAO_Storable_Naming_Context::~TAO_Storable_Naming_Context (  void   )  [virtual]

Destructor. Definition at line 544 of file Storable_Naming_Context.cpp. References ACE_CString, ACE_DEBUG, ACE_TEXT, ACE_TRACE, ACE_Auto_Basic_Ptr< X >::get(), LM_DEBUG, and TAO_debug_level. { ACE_TRACE("~TAO_Storable_Naming_Context"); // If we're in the DTOR as a result of the destroy() operation, // then we go ahead and delete the file. Otherwise, we leave the // file around because they need to be there for persistence. if (this->destroyed_) { // Make sure we delete the associated stream ACE_CString file_name (this->persistence_directory_); file_name += "/"; file_name += this->name_; // Now delete the file ACE_Auto_Ptr<TAO_Storable_Base> fl ( this->factory_->create_stream(file_name.c_str(), ACE_TEXT("r")) ); if (fl.get()) { if (TAO_debug_level > 5) ACE_DEBUG ((LM_DEBUG, "(%P|%t) NameService: removing file %s\n", file_name.fast_rep())); fl->remove (); } } }

---

Member Function Documentation

void TAO_Storable_Naming_Context::bind (  const CosNaming::Name &  n, CORBA::Object_ptr obj  ACE_ENV_ARG_DECL )  [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. Reimplemented from TAO_Hash_Naming_Context. Definition at line 1259 of file Storable_Naming_Context.cpp. References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_GUARD_THROW_EX, ACE_SYNCH_RECURSIVE_MUTEX, ACE_THROW, ACE_TRACE, TAO_Bindings_Map::bind(), TAO_Hash_Naming_Context::get_context(), TAO_Storable_Naming_Context::File_Open_Lock_and_Check::peer(), TAO_Storable_Naming_Context::File_Open_Lock_and_Check::release(), and Write(). { ACE_TRACE("TAO_Storable_Naming_Context::bind"); // Get the length of the name. CORBA::ULong name_len = n.length (); // Check for invalid name. if (name_len == 0) ACE_THROW (CosNaming::NamingContext::InvalidName()); // we didn't need a lock to check the input arg, but now we do ACE_GUARD_THROW_EX (ACE_SYNCH_RECURSIVE_MUTEX, ace_mon, this->lock_, CORBA::INTERNAL ()); ACE_CHECK; // Open the backing file File_Open_Lock_and_Check flck(this, name_len > 1 ? "r" : "rw" ACE_ENV_ARG_PARAMETER); ACE_CHECK; // Check to make sure this object didn't have <destroy> method // invoked on it. if (this->destroyed_) ACE_THROW (CORBA::OBJECT_NOT_EXIST ()); // 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) { // This had been a read on the file so now we are done with it flck.release(); CosNaming::NamingContext_var context = get_context (n ACE_ENV_ARG_PARAMETER); ACE_CHECK; CosNaming::Name simple_name; simple_name.length (1); simple_name[0] = n[name_len - 1]; context->bind (simple_name, obj ACE_ENV_ARG_PARAMETER); ACE_CHECK; } // 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) ACE_THROW (CosNaming::NamingContext::AlreadyBound()); // Something went wrong with the internal structure else if (result == -1) ACE_THROW (CORBA::INTERNAL ()); this->Write(flck.peer()); } }

void TAO_Storable_Naming_Context::bind_context (  const CosNaming::Name &  n, CosNaming::NamingContext_ptr nc  ACE_ENV_ARG_DECL )  [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. Reimplemented from TAO_Hash_Naming_Context. Definition at line 816 of file Storable_Naming_Context.cpp. References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_GUARD_THROW_EX, ACE_SYNCH_RECURSIVE_MUTEX, ACE_THROW, ACE_TRACE, TAO_Bindings_Map::bind(), TAO_Hash_Naming_Context::get_context(), CORBA::is_nil(), TAO_Storable_Naming_Context::File_Open_Lock_and_Check::peer(), TAO_Storable_Naming_Context::File_Open_Lock_and_Check::release(), and Write(). Referenced by bind_new_context(). { ACE_TRACE("TAO_Storable_Naming_Context::bind_context"); // Get the length of the name. CORBA::ULong name_len = n.length (); // Check for invalid name. if (name_len == 0) ACE_THROW (CosNaming::NamingContext::InvalidName()); // Do not allow binding of nil context reference. if (CORBA::is_nil (nc)) ACE_THROW (CORBA::BAD_PARAM ()); // we didn't need a lock to check the input arg, but now we do ACE_GUARD_THROW_EX (ACE_SYNCH_RECURSIVE_MUTEX, ace_mon, this->lock_, CORBA::INTERNAL ()); ACE_CHECK; // Open the backing file File_Open_Lock_and_Check flck(this, name_len > 1 ? "r" : "rw" ACE_ENV_ARG_PARAMETER); ACE_CHECK; // Check to make sure this object didn't have <destroy> method // invoked on it. if (this->destroyed_) ACE_THROW (CORBA::OBJECT_NOT_EXIST ()); // 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) { // This had been a read on the file so now we are done with it flck.release(); CosNaming::NamingContext_var context = get_context (n ACE_ENV_ARG_PARAMETER); ACE_CHECK; CosNaming::Name simple_name; simple_name.length (1); simple_name[0] = n[name_len - 1]; context->bind_context (simple_name, nc ACE_ENV_ARG_PARAMETER); ACE_CHECK; } // 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) ACE_THROW (CosNaming::NamingContext::AlreadyBound()); // Something went wrong with the internal structure else if (result == -1) ACE_THROW (CORBA::INTERNAL ()); this->Write(flck.peer()); } }

CosNaming::NamingContext_ptr TAO_Storable_Naming_Context::bind_new_context (  const CosNaming::Name &n  ACE_ENV_ARG_DECL  )  [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). Reimplemented from TAO_Hash_Naming_Context. Definition at line 1109 of file Storable_Naming_Context.cpp. References ACE_CATCHANY, ACE_CHECK_RETURN, ACE_DECLARE_NEW_CORBA_ENV, ACE_ENDTRY, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_GUARD_THROW_EX, ACE_RE_THROW, ACE_SYNCH_RECURSIVE_MUTEX, ACE_THROW_RETURN, ACE_TRACE, ACE_TRY, ACE_TRY_CHECK, ACE_TRY_CHECK_EX, ACE_TRY_EX, bind_context(), TAO_Hash_Naming_Context::get_context(), new_context(), and TAO_Storable_Naming_Context::File_Open_Lock_and_Check::release(). { ACE_TRACE("bind_new_context"); // Get the length of the name. CORBA::ULong name_len = n.length (); // Check for invalid name. if (name_len == 0) ACE_THROW_RETURN (CosNaming::NamingContext::InvalidName(), CosNaming::NamingContext::_nil ()); ACE_GUARD_THROW_EX (ACE_SYNCH_RECURSIVE_MUTEX, ace_mon, this->lock_, CORBA::INTERNAL ()); ACE_CHECK_RETURN (CosNaming::NamingContext::_nil ()); // Check to make sure this object didn't have <destroy> method // invoked on it. if (this->destroyed_) ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (), CosNaming::NamingContext::_nil ()); // Open the backing file File_Open_Lock_and_Check flck(this, name_len > 1 ? "r" : "rw" ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (CosNaming::NamingContext::_nil ()); // Check to make sure this object didn't have <destroy> method // invoked on it. if (this->destroyed_) ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (), CosNaming::NamingContext::_nil ()); // 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) { // This had been a read on the file so now we are done with it flck.release(); CosNaming::NamingContext_var context = get_context (n ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (CosNaming::NamingContext::_nil ()); CosNaming::Name simple_name; simple_name.length (1); simple_name[0] = n[name_len - 1]; return context->bind_new_context (simple_name ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (CosNaming::NamingContext::_nil ()); } // If we received a simple name, we need to bind it in this context. // This had been a read on the file so now we are done with it flck.release(); // Stores our new Naming Context. CosNaming::NamingContext_var result = CosNaming::NamingContext::_nil (); // Create new context. result = new_context (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (CosNaming::NamingContext::_nil ()); // Bind the new context to the name. ACE_TRY { bind_context (n, result.in () ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY { { ACE_DECLARE_NEW_CORBA_ENV; ACE_TRY_EX(DESTROY) { result->destroy (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK_EX(DESTROY); } ACE_CATCHANY { // Do nothing? } ACE_ENDTRY; } // Re-raise the exception in bind_context() ACE_RE_THROW; } ACE_ENDTRY; ACE_CHECK_RETURN (CosNaming::NamingContext::_nil ()); return result._retn (); }

void TAO_Storable_Naming_Context::destroy (  ACE_ENV_SINGLE_ARG_DECL   )  [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. Reimplemented from TAO_Hash_Naming_Context. Definition at line 1207 of file Storable_Naming_Context.cpp. References TAO_Hash_Naming_Context::_default_POA(), ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_GUARD_THROW_EX, ACE_SYNCH_RECURSIVE_MUTEX, ACE_THROW, ACE_TRACE, TAO_Bindings_Map::current_size(), TAO_Storable_Naming_Context::File_Open_Lock_and_Check::peer(), TAO_Hash_Naming_Context::root(), and Write(). { ACE_TRACE("destroy"); ACE_GUARD_THROW_EX (ACE_SYNCH_RECURSIVE_MUTEX, ace_mon, this->lock_, CORBA::INTERNAL ()); ACE_CHECK; // Open the backing file File_Open_Lock_and_Check flck(this, "rw" ACE_ENV_ARG_PARAMETER); ACE_CHECK; // Check to make sure this object didn't have <destroy> method // invoked on it. if (this->destroyed_) ACE_THROW (CORBA::OBJECT_NOT_EXIST ()); if (this->context_->current_size () != 0) ACE_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 ()); ACE_CHECK; poa->deactivate_object (id.in () ACE_ENV_ARG_PARAMETER); ACE_CHECK; this->Write(flck.peer()); } }

void TAO_Storable_Naming_Context::list (  CORBA::ULong  how_many, CosNaming::BindingList_out &  bl, CosNaming::BindingIterator_out &bi  ACE_ENV_ARG_DECL )  [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. Implements TAO_Naming_Context_Impl. Definition at line 1326 of file Storable_Naming_Context.cpp. References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_GUARD_THROW_EX, ACE_NEW_THROW_EX, ACE_SYNCH_RECURSIVE_MUTEX, ACE_THROW, ACE_TRACE, CosNaming::BindingList, TAO_Bindings_Map::current_size(), TAO_Storable_Bindings_Map::map(), ACE_Auto_Basic_Ptr< X >::release(), TAO_Storable_Naming_Context::File_Open_Lock_and_Check::release(), ACE_OS::sprintf(), and storable_context_. { ACE_TRACE("list"); // 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 ()); ACE_CHECK; // Obtain a lock before we proceed with the operation. ACE_GUARD_THROW_EX (ACE_SYNCH_RECURSIVE_MUTEX, ace_mon, this->lock_, CORBA::INTERNAL ()); ACE_CHECK; // Open the backing file File_Open_Lock_and_Check flck(this, "r" ACE_ENV_ARG_PARAMETER); ACE_CHECK; // Check to make sure this object didn't have <destroy> method // invoked on it. if (this->destroyed_) ACE_THROW (CORBA::OBJECT_NOT_EXIST ()); // We have the map in memory, let the disk go flck.release(); // Dynamically allocate iterator for traversing the underlying hash map. HASH_MAP::ITERATOR *hash_iter = 0; ACE_NEW_THROW_EX (hash_iter, HASH_MAP::ITERATOR (storable_context_->map ()), CORBA::NO_MEMORY ()); ACE_CHECK; // 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_Manager<TAO_Storable_ExtId, TAO_Storable_IntId, ACE_Null_Mutex>::ITERATOR ITER_DEF; typedef ACE_Hash_Map_Manager<TAO_Storable_ExtId, TAO_Storable_IntId, ACE_Null_Mutex>::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 <bl>. 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 the hash map iterator to populate <bl> 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) ACE_THROW (CORBA::NO_MEMORY()); } // Now we are done with the BindingsList, and we can follow up on // the BindingIterator business. // If we do not need to pass back BindingIterator. if (this->context_->current_size () <= how_many) return; else { // *** This is a problem. Is there an exception we can throw? *** ACE_UNUSED_ARG (bind_iter); ACE_THROW (CORBA::NO_IMPLEMENT ()); #if 0 // Create a BindingIterator for return. ACE_NEW_THROW_EX (bind_iter, ITER_SERVANT (this, hash_iter, this->poa_.in (), this->lock_), CORBA::NO_MEMORY ()); ACE_CHECK; // Release <hash_iter> from auto pointer, and start using // 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 (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; // 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 ACE_ENV_ARG_PARAMETER); ACE_CHECK; bi = bind_iter->_this (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; #endif /* 0 */ } }

int TAO_Storable_Naming_Context::load_map (  File_Open_Lock_and_Check *flck  ACE_ENV_ARG_DECL  )  [protected]

Definition at line 325 of file Storable_Naming_Context.cpp. References ACE_NEW_THROW_EX, ACE_THROW_RETURN, ACE_TRACE, TAO_Storable_Bindings_Map::bind(), TAO_NS_Persistence_Header::destroyed(), hash_table_size_, TAO_NS_Persistence_Record::id(), TAO_NS_Persistence_Record::kind(), TAO_NS_Persistence_Record::ref(), TAO_NS_Persistence_Header::size(), storable_context_, and TAO_NS_Persistence_Record::type(). Referenced by TAO_Storable_Naming_Context::File_Open_Lock_and_Check::File_Open_Lock_and_Check(). { ACE_TRACE("load_map"); // assume file already open for reading TAO_Storable_Bindings_Map *bindings_map; // create the new bindings map ACE_NEW_THROW_EX (bindings_map, TAO_Storable_Bindings_Map (hash_table_size_,orb_.in()), CORBA::NO_MEMORY ()); // get the data for this bindings map from the file TAO_NS_Persistence_Header header; TAO_NS_Persistence_Record record; // we are only using the size from this header flck->peer() >> header; if (!flck->peer ().good ()) { flck->peer ().clear (); ACE_THROW_RETURN (CORBA::INTERNAL (), -1); } // reset the destroyed flag this->destroyed_ = header.destroyed(); // read in the data for the map for (unsigned int i=0; i<header.size(); i++) { flck->peer() >> record; if (!flck->peer ().good ()) { flck->peer ().clear (); ACE_THROW_RETURN (CORBA::INTERNAL (), -1); } if( record.type() == TAO_NS_Persistence_Record::NCONTEXT ) { PortableServer::ObjectId_var id = PortableServer::string_to_ObjectId(record.ref().c_str()); const char * intf = interface_->_interface_repository_id(); CORBA::Object_var objref = poa_->create_reference_with_id ( id.in (), intf ); bindings_map->bind( record.id().c_str(), record.kind().c_str(), objref.in(), CosNaming::ncontext ); } else { CORBA::Object_var objref = orb_->string_to_object (record.ref().c_str()); bindings_map->bind( record.id().c_str(), record.kind().c_str(), objref.in(), CosNaming::nobject ); } } storable_context_ = bindings_map; context_ = storable_context_; return 0; }

CosNaming::NamingContext_ptr TAO_Storable_Naming_Context::make_new_context (  CORBA::ORB_ptr  orb, PortableServer::POA_ptr  poa, const char *  poa_id, size_t  context_size, TAO_Naming_Service_Persistence_Factory *  factory, const ACE_TCHAR *  persistence_directory, TAO_Storable_Naming_Context **new_context  ACE_ENV_ARG_DECL )  [static]

This utility method factors out the code needed to create a new Storable 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., ), and from outside (e.g., Naming_Utils.cpp). Definition at line 575 of file Storable_Naming_Context.cpp. References ACE_CATCH, ACE_CHECK_RETURN, ACE_ENDTRY, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_NEW_THROW_EX, ACE_THROW_RETURN, ACE_TRACE, ACE_TRY, ACE_TRY_CHECK, and ACE_Auto_Basic_Ptr< X >::release(). Referenced by new_context(), and recreate_all(). { ACE_TRACE("make_new_context"); // Store the stub we will return here. CosNaming::NamingContext_var result; // Put together a servant for the new Naming Context. TAO_Storable_Naming_Context *context_impl = 0; ACE_NEW_THROW_EX (context_impl, TAO_Storable_Naming_Context (orb, poa, poa_id, factory, persistence_directory, context_size), CORBA::NO_MEMORY ()); ACE_CHECK_RETURN (result._retn ()); // Put <context_impl> into the auto pointer temporarily, in case next // allocation fails. ACE_Auto_Basic_Ptr<TAO_Storable_Naming_Context> temp (context_impl); TAO_Naming_Context *context = 0; ACE_NEW_THROW_EX (context, TAO_Naming_Context (context_impl), CORBA::NO_MEMORY ()); ACE_CHECK_RETURN (result._retn ()); // 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); // If we try to register a naming context that is already registered, // the following activation causes a POA::ObjectAlreadyActive exception be // thrown which is transmitted as a CORBA::UNKNOWN on the wire. To rectify // this problem, we explicitly throw the correct INS exception in // this situation. ACE_TRY { poa->activate_object_with_id (id.in (), context ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCH (PortableServer::POA::ObjectAlreadyActive, ex) { ACE_THROW_RETURN (CosNaming::NamingContext::AlreadyBound(), CosNaming::NamingContext::_nil ()); } ACE_ENDTRY; ACE_CHECK_RETURN (result._retn ()); result = context->_this (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (CosNaming::NamingContext::_nil ()); // return the address of the new context object so that caller can finish *new_context = context_impl; return result._retn (); }

CosNaming::NamingContext_ptr TAO_Storable_Naming_Context::new_context (  ACE_ENV_SINGLE_ARG_DECL   )  [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 655 of file Storable_Naming_Context.cpp. References ACE_CHECK_RETURN, ACE_ENV_ARG_PARAMETER, ACE_GUARD_THROW_EX, ACE_NEW_THROW_EX, ACE_SYNCH_RECURSIVE_MUTEX, ACE_TEXT_CHAR_TO_TCHAR, ACE_THROW_RETURN, ACE_TRACE, TAO_Hash_Naming_Context::context_, TAO_NS_Persistence_Global::counter(), gcounter_, ACE_Auto_Basic_Ptr< X >::get(), gfl_, hash_table_size_, make_new_context(), TAO_Storable_Naming_Context::File_Open_Lock_and_Check::peer(), redundant_, ACE_Auto_Basic_Ptr< X >::release(), root_name_, ACE_OS::sprintf(), storable_context_, TAO_Storable_Bindings_Map::total_size(), and Write(). Referenced by bind_new_context(). { ACE_TRACE("new_context"); ACE_GUARD_THROW_EX (ACE_SYNCH_RECURSIVE_MUTEX, ace_mon, this->lock_, CORBA::INTERNAL ()); ACE_CHECK_RETURN (CosNaming::NamingContext::_nil ()); { // Open the backing file File_Open_Lock_and_Check flck(this, "r" ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (CosNaming::NamingContext::_nil ()); // Check to make sure this object didn't have <destroy> method // invoked on it. if (this->destroyed_) ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (), CosNaming::NamingContext::_nil ()); } TAO_NS_Persistence_Global global; // Generate a POA id for the new context. if(redundant_) { // acquire a lock on the file that holds our counter if (gfl_->open() != 0) { delete gfl_.release(); ACE_THROW_RETURN(CORBA::PERSIST_STORE(), CosNaming::NamingContext::_nil ()); } if (gfl_ -> flock(0, 0, 0) != 0) ACE_THROW_RETURN (CORBA::INTERNAL(), CosNaming::NamingContext::_nil ()); // get the counter from disk *gfl_.get() >> global; if (!gfl_.get ()->good () && gfl_.get ()->rdstate () != TAO_Storable_Base::eofbit) { gfl_.get ()->clear (); ACE_THROW_RETURN (CORBA::INTERNAL (), 0); } gcounter_ = global.counter(); // use it to generate a new name } char poa_id[BUFSIZ]; ACE_OS::sprintf (poa_id, "%s_%d", root_name_, gcounter_++); // then save it back on disk global.counter(gcounter_); *gfl_.get() << global; if(redundant_) { // and release our lock if (gfl_ -> flock(0, 0, 0) != 0) ACE_THROW_RETURN(CORBA::INTERNAL(), CosNaming::NamingContext::_nil ()); gfl_->close(); } // Create a new context. TAO_Storable_Naming_Context *new_context = 0; CosNaming::NamingContext_var result = make_new_context (this->orb_.in (), this->poa_.in (), poa_id, this->storable_context_->total_size (), this->factory_, ACE_TEXT_CHAR_TO_TCHAR (this->persistence_directory_.c_str ()), &new_context ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (CosNaming::NamingContext::_nil ()); // Since this is a new context, make an empty map in it ACE_NEW_THROW_EX (new_context->storable_context_, TAO_Storable_Bindings_Map (hash_table_size_,orb_.in ()), CORBA::NO_MEMORY ()); ACE_CHECK_RETURN (CosNaming::NamingContext::_nil ()); new_context->context_ = new_context->storable_context_; File_Open_Lock_and_Check flck(new_context, "wc" ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (CosNaming::NamingContext::_nil ()); new_context->Write(flck.peer()); return result._retn (); }

void TAO_Storable_Naming_Context::rebind (  const CosNaming::Name &  n, CORBA::Object_ptr obj  ACE_ENV_ARG_DECL )  [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. Reimplemented from TAO_Hash_Naming_Context. Definition at line 748 of file Storable_Naming_Context.cpp. References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_GUARD_THROW_EX, ACE_SYNCH_RECURSIVE_MUTEX, ACE_THROW, ACE_TRACE, TAO_Hash_Naming_Context::get_context(), TAO_Storable_Naming_Context::File_Open_Lock_and_Check::peer(), TAO_Bindings_Map::rebind(), TAO_Storable_Naming_Context::File_Open_Lock_and_Check::release(), and Write(). { ACE_TRACE("rebind"); // Get the length of the name. CORBA::ULong name_len = n.length (); // Check for invalid name. if (name_len == 0) ACE_THROW (CosNaming::NamingContext::InvalidName()); // we didn't need a lock to check the input arg, but now we do ACE_GUARD_THROW_EX (ACE_SYNCH_RECURSIVE_MUTEX, ace_mon, this->lock_, CORBA::INTERNAL ()); ACE_CHECK; // Open the backing file File_Open_Lock_and_Check flck(this, name_len > 1 ? "r" : "rw" ACE_ENV_ARG_PARAMETER); ACE_CHECK; // Check to make sure this object didn't have <destroy> method // invoked on it. if (this->destroyed_) ACE_THROW (CORBA::OBJECT_NOT_EXIST ()); // 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) { // This had been a read on the file so now we are done with it flck.release(); CosNaming::NamingContext_var context = get_context (n ACE_ENV_ARG_PARAMETER); ACE_CHECK; CosNaming::Name simple_name; simple_name.length (1); simple_name[0] = n[name_len - 1]; context->rebind (simple_name, obj ACE_ENV_ARG_PARAMETER); ACE_CHECK; } // If we received a simple name, we need to rebind it in this // context. else { int result = this->context_->rebind (n[0].id, n[0].kind, obj, CosNaming::nobject); // Check for error conditions. if (result == -1) ACE_THROW (CORBA::INTERNAL ()); else if (result == -2) ACE_THROW (CosNaming::NamingContext::NotFound (CosNaming::NamingContext::not_object, n)); this->Write(flck.peer()); } }

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

This is a version of specifically for naming contexts, so that they can participate in name resolution when compound names are passed. Reimplemented from TAO_Hash_Naming_Context. Definition at line 886 of file Storable_Naming_Context.cpp. References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_GUARD_THROW_EX, ACE_SYNCH_RECURSIVE_MUTEX, ACE_THROW, ACE_TRACE, TAO_Hash_Naming_Context::get_context(), TAO_Storable_Naming_Context::File_Open_Lock_and_Check::peer(), TAO_Bindings_Map::rebind(), TAO_Storable_Naming_Context::File_Open_Lock_and_Check::release(), and Write(). { ACE_TRACE("rebind_context"); // Get the length of the name. CORBA::ULong name_len = n.length (); // Check for invalid name. if (name_len == 0) ACE_THROW (CosNaming::NamingContext::InvalidName()); // we didn't need a lock to check the input arg, but now we do ACE_GUARD_THROW_EX (ACE_SYNCH_RECURSIVE_MUTEX, ace_mon, this->lock_, CORBA::INTERNAL ()); ACE_CHECK; // Open the backing file File_Open_Lock_and_Check flck(this, name_len > 1 ? "r" : "rw" ACE_ENV_ARG_PARAMETER); ACE_CHECK; // Check to make sure this object didn't have <destroy> method // invoked on it. if (this->destroyed_) ACE_THROW (CORBA::OBJECT_NOT_EXIST ()); // 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) { // This had been a read on the file so now we are done with it flck.release(); CosNaming::NamingContext_var context = get_context (n ACE_ENV_ARG_PARAMETER); ACE_CHECK; CosNaming::Name simple_name; simple_name.length (1); simple_name[0] = n[name_len - 1]; context->rebind_context (simple_name, nc ACE_ENV_ARG_PARAMETER); ACE_CHECK; } // If we received a simple name, we need to rebind it in this // context. else { int result = this->context_->rebind (n[0].id, n[0].kind, nc, CosNaming::ncontext); // Check for error conditions. if (result == -1) ACE_THROW (CORBA::INTERNAL ()); else if (result == -2) ACE_THROW (CosNaming::NamingContext::NotFound (CosNaming::NamingContext::not_context, n)); this->Write(flck.peer()); } }

TAO_END_VERSIONED_NAMESPACE_DECL TAO_BEGIN_VERSIONED_NAMESPACE_DECL CosNaming::NamingContext_ptr TAO_Storable_Naming_Context::recreate_all (  CORBA::ORB_ptr  orb, PortableServer::POA_ptr  poa, const char *  poa_id, size_t  context_size, int  reentering, TAO_Naming_Service_Persistence_Factory *  factory, const ACE_TCHAR *  persistence_directory, int use_redundancy  ACE_ENV_ARG_DECL )  [static]

Definition at line 1465 of file Storable_Naming_Context.cpp. References ACE_CHECK_RETURN, ACE_ENV_ARG_PARAMETER, ACE_NEW_THROW_EX, ACE_TEXT, ACE_TEXT_ALWAYS_CHAR, ACE_TEXT_CHAR_TO_TCHAR, ACE_THROW_RETURN, ACE_TRACE, ACE_TString, TAO_Hash_Naming_Context::context_, TAO_NS_Persistence_Global::counter(), TAO_Naming_Service_Persistence_Factory::create_stream(), gcounter_, ACE_Auto_Basic_Ptr< X >::get(), gfl_, make_new_context(), TAO_Storable_Naming_Context::File_Open_Lock_and_Check::peer(), redundant_, ACE_Auto_Basic_Ptr< X >::release(), ACE_Auto_Basic_Ptr< X >::reset(), root_name_, storable_context_, and Write(). Referenced by TAO_Naming_Server::init_new_naming(). { ACE_TRACE("recreate_all"); ACE_UNUSED_ARG (reentering); // Whether we are redundant is global redundant_ = use_redundancy; // Save the root name for later use root_name_ = poa_id; // Create a new context. TAO_Storable_Naming_Context *new_context = 0; CosNaming::NamingContext_var result = make_new_context (orb, poa, poa_id, context_size, factory, persistence_directory, &new_context ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (CosNaming::NamingContext::_nil ()); // Now does this already exist on disk? ACE_TString file_name(persistence_directory); file_name += ACE_TEXT("/"); file_name += ACE_TEXT_CHAR_TO_TCHAR(poa_id); ACE_Auto_Ptr<TAO_Storable_Base> fl (factory->create_stream(ACE_TEXT_ALWAYS_CHAR(file_name.c_str()), ACE_TEXT("r"))); if (fl->exists()) { // Load the map from disk File_Open_Lock_and_Check flck(new_context, "r" ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (CosNaming::NamingContext::_nil ()); } else { // Since this is a new context, make and empty map in it ACE_NEW_THROW_EX (new_context->storable_context_, TAO_Storable_Bindings_Map (context_size,orb), CORBA::NO_MEMORY ()); ACE_CHECK_RETURN (CosNaming::NamingContext::_nil ()); new_context->context_ = new_context->storable_context_; File_Open_Lock_and_Check flck(new_context, "wc" ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (CosNaming::NamingContext::_nil ()); new_context->Write(flck.peer()); } // build the global file name file_name += ACE_TEXT("_global"); // Create the stream for the counter used to uniquely creat context names gfl_.reset(factory->create_stream(ACE_TEXT_ALWAYS_CHAR(file_name.c_str()), ACE_TEXT("crw"))); if (gfl_->open() != 0) { delete gfl_.release(); ACE_THROW_RETURN(CORBA::PERSIST_STORE(), CosNaming::NamingContext::_nil ()); } // get the counter from disk TAO_NS_Persistence_Global global; *gfl_.get() >> global; if (!gfl_.get ()->good () && gfl_.get ()->rdstate () != TAO_Storable_Base::eofbit) { gfl_.get ()->clear (); ACE_THROW_RETURN (CORBA::INTERNAL (), 0); } gcounter_ = global.counter(); if(redundant_) gfl_->close(); return result._retn (); }

CORBA::Object_ptr TAO_Storable_Naming_Context::resolve (  const CosNaming::Name &n  ACE_ENV_ARG_DECL  )  [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. Reimplemented from TAO_Hash_Naming_Context. Definition at line 952 of file Storable_Naming_Context.cpp. References CORBA::Object::_nil(), ACE_CHECK_RETURN, ACE_ENV_ARG_PARAMETER, ACE_GUARD_THROW_EX, ACE_SYNCH_RECURSIVE_MUTEX, ACE_THROW_RETURN, ACE_TRACE, TAO_Bindings_Map::find(), CORBA::is_nil(), and TAO_Storable_Naming_Context::File_Open_Lock_and_Check::release(). { ACE_TRACE("resolve"); // Get the length of the name. CORBA::ULong name_len = n.length (); // Check for invalid name. if (name_len == 0) ACE_THROW_RETURN (CosNaming::NamingContext::InvalidName(), CORBA::Object::_nil ()); // we didn't need a lock to check the input arg, but now we do ACE_GUARD_THROW_EX (ACE_SYNCH_RECURSIVE_MUTEX, ace_mon, this->lock_, CORBA::INTERNAL ()); ACE_CHECK_RETURN (CORBA::Object::_nil ()); // Open the backing file File_Open_Lock_and_Check flck(this, "r" ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (CORBA::Object::_nil ()); // Check to make sure this object didn't have <destroy> method // invoked on it. if (this->destroyed_) ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (), CORBA::Object::_nil ()); // Resolve the first component of the name. flck.release(); // Stores the binding type for the first name component. CosNaming::BindingType type; // Stores the object reference bound to the first name component. CORBA::Object_ptr obj = CORBA::Object::_nil (); if (this->context_->find (n[0].id, n[0].kind, obj, type) == -1) ACE_THROW_RETURN (CosNaming::NamingContext::NotFound (CosNaming::NamingContext::missing_node, n), CORBA::Object::_nil ()); // Store the value in var to avoid memory leaks. CORBA::Object_var result = obj; // 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 () ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (result._retn ()); } else // The first name component wasn't bound to a NamingContext. ACE_THROW_RETURN (CosNaming::NamingContext::NotFound (CosNaming::NamingContext::not_context, n), CORBA::Object::_nil ()); // If narrow failed... if (CORBA::is_nil (context.in ())) ACE_THROW_RETURN (CosNaming::NamingContext::NotFound (CosNaming::NamingContext::not_context, n), CORBA::Object::_nil ()); 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. return context->resolve (rest_of_name ACE_ENV_ARG_PARAMETER); } } // If the name we had to resolve was simple, we just need to return // the result. return result._retn (); }

void TAO_Storable_Naming_Context::unbind (  const CosNaming::Name &n  ACE_ENV_ARG_DECL  )  [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 () Reimplemented from TAO_Hash_Naming_Context. Definition at line 1050 of file Storable_Naming_Context.cpp. References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_GUARD_THROW_EX, ACE_SYNCH_RECURSIVE_MUTEX, ACE_THROW, ACE_TRACE, TAO_Hash_Naming_Context::get_context(), TAO_Storable_Naming_Context::File_Open_Lock_and_Check::peer(), TAO_Storable_Naming_Context::File_Open_Lock_and_Check::release(), TAO_Bindings_Map::unbind(), and Write(). { ACE_TRACE("unbind"); // Get the length of the name. CORBA::ULong name_len = n.length (); // Check for invalid name. if (name_len == 0) ACE_THROW (CosNaming::NamingContext::InvalidName()); // we didn't need a lock to check the input arg, but now we do ACE_GUARD_THROW_EX (ACE_SYNCH_RECURSIVE_MUTEX, ace_mon, this->lock_, CORBA::INTERNAL ()); ACE_CHECK; // Open the backing file File_Open_Lock_and_Check flck(this, name_len > 1 ? "r" : "rw" ACE_ENV_ARG_PARAMETER); ACE_CHECK; // Check to make sure this object didn't have <destroy> method // invoked on it. if (this->destroyed_) ACE_THROW (CORBA::OBJECT_NOT_EXIST ()); // 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) { // This had been a read on the file so now we are done with it flck.release(); CosNaming::NamingContext_var context = get_context (n ACE_ENV_ARG_PARAMETER); ACE_CHECK; CosNaming::Name simple_name; simple_name.length (1); simple_name[0] = n[name_len - 1]; context->unbind (simple_name ACE_ENV_ARG_PARAMETER); ACE_CHECK; } // 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) ACE_THROW (CosNaming::NamingContext::NotFound (CosNaming::NamingContext::missing_node, n)); this->Write(flck.peer()); } }

void TAO_Storable_Naming_Context::Write (  TAO_Storable_Base &  wrtr  )  [protected]

Definition at line 259 of file Storable_Naming_Context.cpp. References ACE_CString, ACE_TRACE, TAO_Storable_Bindings_Map::current_size(), TAO_NS_Persistence_Header::destroyed(), TAO_NS_Persistence_Record::id(), TAO_NS_Persistence_Record::kind(), TAO_Storable_Bindings_Map::map(), TAO_NS_Persistence_Record::ref(), TAO_NS_Persistence_Header::size(), storable_context_, and TAO_NS_Persistence_Record::type(). Referenced by bind(), bind_context(), destroy(), new_context(), rebind(), rebind_context(), recreate_all(), and unbind(). { ACE_TRACE("Write"); TAO_NS_Persistence_Header header; header.size (static_cast<unsigned int> (storable_context_->current_size())); header.destroyed (destroyed_); wrtr << header; if( storable_context_->current_size() == 0 ) return; ACE_Hash_Map_Iterator<TAO_Storable_ExtId,TAO_Storable_IntId, ACE_Null_Mutex> it = storable_context_->map().begin(); ACE_Hash_Map_Iterator<TAO_Storable_ExtId,TAO_Storable_IntId, ACE_Null_Mutex> itend = storable_context_->map().end(); ACE_Hash_Map_Entry<TAO_Storable_ExtId,TAO_Storable_IntId> ent = *it; while (!(it == itend)) { TAO_NS_Persistence_Record record; CosNaming::BindingType bt = (*it).int_id_.type_; if (bt == CosNaming::ncontext) record.type(TAO_NS_Persistence_Record::NCONTEXT); else if (bt == CosNaming::nobject) record.type(TAO_NS_Persistence_Record::OBJREF); //else //there shouldn't be any other, can there be ?? //ignore for now // todo - are we using this i ?? //int i = storable_context_->current_size(); const char *myid = (*it).ext_id_.id(); ACE_CString id(myid); record.id(id); const char *mykind = (*it).ext_id_.kind(); ACE_CString kind(mykind); record.kind(kind); ACE_CString name; if (bt == CosNaming::nobject) { name.set((*it).int_id_.ref_.in()); } else { CORBA::Object_var obj = orb_->string_to_object((*it).int_id_.ref_.in()); PortableServer::ObjectId_var oid = poa_->reference_to_id(obj.in()); CORBA::String_var nm = PortableServer::ObjectId_to_string(oid.in()); const char *newname = nm.in(); name.set(newname); } record.ref(name); wrtr << record; it.advance(); } }

---

Friends And Related Function Documentation

friend class File_Open_Lock_and_Check [friend]

Definition at line 463 of file Storable_Naming_Context.h.

---

Member Data Documentation

ACE_UINT32 TAO_Storable_Naming_Context::counter_ [protected]

Counter used for generation of transients. Definition at line 372 of file Storable_Naming_Context.h.

TAO_Naming_Service_Persistence_Factory* TAO_Storable_Naming_Context::factory_ [protected]

Definition at line 389 of file Storable_Naming_Context.h. Referenced by TAO_Storable_Naming_Context::File_Open_Lock_and_Check::File_Open_Lock_and_Check().

ACE_UINT32 TAO_Storable_Naming_Context::gcounter_ [static, protected]

Global counter used for generation of POA ids for children Naming Contexts. Definition at line 27 of file Storable_Naming_Context.cpp. Referenced by new_context(), and recreate_all().

ACE_Auto_Ptr< TAO_Storable_Base > TAO_Storable_Naming_Context::gfl_ [static, protected]

The pointer to the global file used to allocate new contexts. Definition at line 28 of file Storable_Naming_Context.cpp. Referenced by new_context(), and recreate_all().

size_t TAO_Storable_Naming_Context::hash_table_size_ [protected]

Save the hash table initial size. Definition at line 395 of file Storable_Naming_Context.h. Referenced by load_map(), and new_context().

time_t TAO_Storable_Naming_Context::last_changed_ [protected]

Disk time that match current memory state. Definition at line 398 of file Storable_Naming_Context.h. Referenced by TAO_Storable_Naming_Context::File_Open_Lock_and_Check::File_Open_Lock_and_Check().

ACE_CString TAO_Storable_Naming_Context::name_ [protected]

Definition at line 385 of file Storable_Naming_Context.h. Referenced by TAO_Storable_Naming_Context::File_Open_Lock_and_Check::File_Open_Lock_and_Check().

CORBA::ORB_var TAO_Storable_Naming_Context::orb_ [protected]

Definition at line 383 of file Storable_Naming_Context.h.

ACE_CString TAO_Storable_Naming_Context::persistence_directory_ [protected]

The directory in which to store the files. Definition at line 392 of file Storable_Naming_Context.h. Referenced by TAO_Storable_Naming_Context::File_Open_Lock_and_Check::File_Open_Lock_and_Check().

PortableServer::POA_var TAO_Storable_Naming_Context::poa_ [protected]

POA we are registered with. Reimplemented from TAO_Hash_Naming_Context. Definition at line 387 of file Storable_Naming_Context.h.

int TAO_Storable_Naming_Context::redundant_ [static, protected]

Flag to tell use whether we are redundant or not. Definition at line 29 of file Storable_Naming_Context.cpp. Referenced by TAO_Storable_Naming_Context::File_Open_Lock_and_Check::File_Open_Lock_and_Check(), new_context(), recreate_all(), and TAO_Storable_Naming_Context::File_Open_Lock_and_Check::release().

TAO_BEGIN_VERSIONED_NAMESPACE_DECL const char * TAO_Storable_Naming_Context::root_name_ [static, protected]

Definition at line 26 of file Storable_Naming_Context.cpp. Referenced by new_context(), and recreate_all().

TAO_Storable_Bindings_Map* TAO_Storable_Naming_Context::storable_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 381 of file Storable_Naming_Context.h. Referenced by TAO_Storable_Naming_Context::File_Open_Lock_and_Check::File_Open_Lock_and_Check(), list(), load_map(), new_context(), recreate_all(), and Write().

---

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

• Storable_Naming_Context.h
• Storable_Naming_Context.cpp

---