TAO_CosNaming: TAO_Persistent_Bindings

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

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

00117 {
00118   return map_->current_size ();
00119 }

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

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       ACE_DECLARE_NEW_CORBA_ENV;
00077       obj = orb_->string_to_object (entry.ref_ ACE_ENV_ARG_PARAMETER);
00078       ACE_CHECK_RETURN (-1);
00079       type = entry.type_;
00080 
00081       return 0;
00082     }
00083 }

00105 {
00106   return this->map_;
00107 }

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

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

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

00154 {
00155   allocator_ = alloc;
00156   map_ = map;
00157 }

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

00111 {
00112   return this->map_->total_size ();
00113 }

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