TAO_CosNaming: TAO_Persistent_Bindings

00084   : allocator_ (0),
00085     map_ (0),
00086     orb_ (CORBA::ORB::_duplicate (orb))
00087 {
00088 }

00048 {
00049   return this->shared_bind (id, kind, obj, type, 0);
00050 }

00115 {
00116   return map_->current_size ();
00117 }

00096 {
00097   this->map_->ACE_Hash_Map_With_Allocator<TAO_Persistent_ExtId, TAO_Persistent_IntId>::~ACE_Hash_Map_With_Allocator ();
00098   this->allocator_->free (map_);
00099 }

00066 {
00067   TAO_Persistent_ExtId name (id, kind);
00068   TAO_Persistent_IntId entry;
00069 
00070   if (this->map_->find (name,
00071                         entry,
00072                         this->allocator_) != 0)
00073     return -1;
00074   else
00075     {
00076       obj = orb_->string_to_object (entry.ref_);
00077       type = entry.type_;
00078 
00079       return 0;
00080     }
00081 }

00103 {
00104   return this->map_;
00105 }

00122 {
00123   allocator_ = alloc;
00124 
00125   // Use allocator to allocate space for the hash map.
00126   void *hash_map = 0;
00127   size_t map_size = sizeof (HASH_MAP);
00128   hash_map = this->allocator_->malloc (map_size);
00129 
00130   // If allocation failed ...
00131   if (hash_map == 0)
00132     return -1;
00133 
00134   // Initialize allocated hash map through placement new.
00135   if (open_helper (hash_table_size, hash_map) == -1)
00136     this->allocator_->free (hash_map);
00137 
00138   return 0;
00139 }

00144 {
00145   this->map_ = new (buffer) HASH_MAP (hash_table_size, this->allocator_);
00146   return 0;
00147 }

00057 {
00058   return this->shared_bind (id, kind, obj, type, 1);
00059 }

00152 {
00153   allocator_ = alloc;
00154   map_ = map;
00155 }

00163 {
00164   // Obtain a stringified ior of <obj> (i.e., the representation we can store).
00165   CORBA::String_var ref = orb_->object_to_string (obj);
00166 
00167   // Calculate and allocate the memory we need to store this name to
00168   // object binding.
00169   size_t id_len = ACE_OS::strlen (id) + 1;
00170   size_t kind_len = ACE_OS::strlen (kind) + 1;
00171   size_t ref_len = ACE_OS::strlen (ref.in ()) + 1;
00172   size_t total_len = id_len + kind_len + ref_len;
00173   char *ptr = (char *) this->allocator_->malloc (total_len);
00174 
00175   // Allocation failed - bail out.
00176   if (ptr == 0)
00177     return -1;
00178 
00179   // Allocation succeded - place the data into the allocated memory
00180   // and procceed.
00181   else
00182     {
00183       // Note that the <ref> *must* come first to make sure we can
00184       // retrieve this pointer later on in unbind().
00185       char * ref_ptr = ptr;
00186       char * id_ptr =  ptr + ref_len;
00187       char * kind_ptr = ptr + ref_len + id_len;
00188       ACE_OS::strcpy (ref_ptr, ref.in ());
00189       ACE_OS::strcpy (id_ptr, id);
00190       ACE_OS::strcpy (kind_ptr, kind);
00191 
00192       TAO_Persistent_ExtId new_name (id_ptr, kind_ptr);
00193       TAO_Persistent_IntId new_entry (ref_ptr, type);
00194       int result = -1;
00195 
00196       if (rebind == 0)
00197         {
00198           // Do a normal bind.  This will fail if there's already an
00199           // <new_internal> with the same name.
00200           result = this->map_->bind (new_name, new_entry, this->allocator_);
00201 
00202           if (result == 1)
00203             {
00204               // Entry already existed so bind failed. Free our
00205               // dynamically allocated  memory.
00206               this->allocator_->free ((void *) ptr);
00207               return result;
00208             }
00209         }
00210       else
00211         // Rebind.
00212         {
00213           TAO_Persistent_ExtId old_name;
00214           TAO_Persistent_IntId old_entry;
00215 
00216           // Check that the types of old and new entries match.
00217           if (this->map_->find (new_name,
00218                                 old_entry,
00219                                 this->allocator_) == 0
00220               && type != old_entry.type_)
00221             result = -2;
00222 
00223           // If types match, perform rebind.
00224           else
00225             result = this->map_->rebind (new_name, new_entry,
00226                                          old_name, old_entry,
00227                                          this->allocator_);
00228           if (result == 1)
00229             {
00230               // Free up the old binding's memory, if it was replaced.
00231               // Note, this assumes that the "ref" pointer comes
00232               // first, and that the id, kind, and ref are contiguously
00233               // allocated (see beginning of this method for details).
00234               this->allocator_->free ((void *) old_entry.ref_);
00235             }
00236         }
00237 
00238       // Check for failures, and clean up dynamically allocated memory
00239       // if necessary.
00240       if (result < 0)
00241         this->allocator_->free ((void *) ptr);
00242 
00243       else
00244         // If bind() or rebind() succeeded, they will automatically sync
00245         // up the map manager entry.  However, we must sync up our
00246         // name/value memory.
00247         this->allocator_->sync (ptr, total_len);
00248 
00249       return result;
00250     }
00251 }

00109 {
00110   return this->map_->total_size ();
00111 }

00027 {
00028   TAO_Persistent_ExtId name (id, kind);
00029   TAO_Persistent_IntId entry;
00030   if (this->map_->unbind (name, entry, this->allocator_) != 0)
00031     return -1;
00032   else
00033     {
00034       // Free up the memory we allocated in shared_bind().  Note that
00035       // this assumes that the "ref" pointer comes first and that
00036       // the ref, id and kind are contiguously allocated (see
00037       // shared_bind() for details).
00038       this->allocator_->free ((void *) (entry.ref_));
00039       return 0;
00040     }
00041 }


Public Types
typedef ACE_Hash_Map_With_Allocator< TAO_Persistent_ExtId, TAO_Persistent_IntId >	HASH_MAP
	Underlying data structure - typedef for ease of use.
Public Member Functions
	TAO_Persistent_Bindings_Map (CORBA::ORB_ptr orb)
	Constructor.
int	open (size_t hash_map_size, ACE_Allocator *alloc)
void	set (HASH_MAP map, ACE_Allocator alloc)
virtual	~TAO_Persistent_Bindings_Map (void)
void	destroy (void)
HASH_MAP *	map (void)
	Get a pointer to the underlying hash map.
size_t	total_size (void)
	Return the size of the underlying hash table.
virtual size_t	current_size (void)
	Return the size of the underlying hash table.
virtual int	bind (const char id, const char kind, CORBA::Object_ptr obj, CosNaming::BindingType type)
virtual int	rebind (const char id, const char kind, CORBA::Object_ptr obj, CosNaming::BindingType type)
virtual int	unbind (const char id, const char kind)
virtual int	find (const char id, const char kind, CORBA::Object_ptr &obj, CosNaming::BindingType &type)
Protected Member Functions
int	open_helper (size_t hash_table_size, void *buffer)
int	shared_bind (const char id, const char kind, CORBA::Object_ptr obj, CosNaming::BindingType type, int rebind)
	Helper: factors common code from and .
Protected Attributes
ACE_Allocator *	allocator_
	Pointer to the allocator we use to make bindings persistent.
HASH_MAP *	map_
	Pointer to the underlying hash map.
CORBA::ORB_var	orb_
	Pointer to the orb. We need it to do string/object conversions.

TAO_Persistent_Bindings_Map Class Reference

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation