Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Namespace Members | Class Members | File Members | Related Pages | Search for 

TAO_Active_Object_Map Class Reference

Map of object ids to servants. More...

#include <Active_Object_Map.h>

Collaboration diagram for TAO_Active_Object_Map:

Collaboration graph
[legend]
List of all members.

Public Types

typedef ACE_Map< PortableServer::ObjectId,
TAO_Active_Object_Map_Entry * > 		user_id_map
 Base class of the id map.

typedef ACE_Hash_Map_Manager_Ex_Adapter<
PortableServer::ObjectId,
TAO_Active_Object_Map_Entry *,
TAO_ObjectId_Hash, ACE_Equal_To<
PortableServer::ObjectId >,
TAO_Incremental_Key_Generator > 		user_id_hash_map
 Id hash map.

typedef ACE_Map_Manager_Adapter<
PortableServer::ObjectId,
TAO_Active_Object_Map_Entry *,
TAO_Incremental_Key_Generator > 		user_id_linear_map
 Id linear map.

typedef ACE_Active_Map_Manager_Adapter<
PortableServer::ObjectId,
TAO_Active_Object_Map_Entry *,
TAO_Ignore_Original_Key_Adapter > 		user_id_active_map
 Id active map.

typedef ACE_Map< PortableServer::Servant,
TAO_Active_Object_Map_Entry * > 		servant_map
 Base class of the servant map.

typedef ACE_Hash_Map_Manager_Ex_Adapter<
PortableServer::Servant,
TAO_Active_Object_Map_Entry *,
TAO_Servant_Hash, ACE_Equal_To<
PortableServer::Servant >,
ACE_Noop_Key_Generator< PortableServer::Servant > > 		servant_hash_map
 Servant hash map.

typedef ACE_Map_Manager_Adapter<
PortableServer::Servant,
TAO_Active_Object_Map_Entry *,
ACE_Noop_Key_Generator< PortableServer::Servant > > 		servant_linear_map
 Servant linear map.


Public Member Functions

 TAO_Active_Object_Map (int user_id_policy, int unique_id_policy, int persistent_id_policy, const TAO_Server_Strategy_Factory::Active_Object_Map_Creation_Parameters &creation_parameters)
 Constructor.

 ~TAO_Active_Object_Map (void)
 Destructor.

int is_servant_in_map (PortableServer::Servant servant, int &deactivated)
 Must be used with UNIQUE_ID policy.

int is_user_id_in_map (const PortableServer::ObjectId &user_id, CORBA::Short priority, int &priorities_match, int &deactivated)
int bind_using_system_id_returning_system_id (PortableServer::Servant servant, CORBA::Short priority, PortableServer::ObjectId_out system_id)
 Must be used with SYSTEM_ID policy.

int bind_using_system_id_returning_user_id (PortableServer::Servant servant, CORBA::Short priority, PortableServer::ObjectId_out user_id)
 Must be used with SYSTEM_ID policy.

int bind_using_user_id (PortableServer::Servant servant, const PortableServer::ObjectId &user_id, CORBA::Short priority)
int find_system_id_using_user_id (const PortableServer::ObjectId &user_id, CORBA::Short priority, PortableServer::ObjectId_out system_id)
int rebind_using_user_id_and_system_id (PortableServer::Servant servant, const PortableServer::ObjectId &user_id, const PortableServer::ObjectId &system_id, TAO_Active_Object_Map_Entry *&entry)
 Can be used with any policy.

int unbind_using_user_id (const PortableServer::ObjectId &user_id)
int find_user_id_using_servant (PortableServer::Servant servant, PortableServer::ObjectId_out user_id)
int find_system_id_using_servant (PortableServer::Servant servant, PortableServer::ObjectId_out system_id, CORBA::Short &priority)
int find_servant_using_user_id (const PortableServer::ObjectId &user_id, PortableServer::Servant &servant)
int find_servant_using_system_id_and_user_id (const PortableServer::ObjectId &system_id, const PortableServer::ObjectId &user_id, PortableServer::Servant &servant, TAO_Active_Object_Map_Entry *&entry)
 Can be used with any policy.

int find_servant_and_system_id_using_user_id (const PortableServer::ObjectId &user_id, PortableServer::Servant &servant, PortableServer::ObjectId_out system_id, CORBA::Short &priority)
int find_entry_using_user_id (const PortableServer::ObjectId &user_id, TAO_Active_Object_Map_Entry *&entry)
int find_user_id_using_system_id (const PortableServer::ObjectId &system_id, PortableServer::ObjectId_out user_id)
int find_user_id_using_system_id (const PortableServer::ObjectId &system_id, PortableServer::ObjectId &user_id)
CORBA::Boolean remaining_activations (PortableServer::Servant servant)
size_t current_size (void)
 Size of the map.


Static Public Member Functions

size_t system_id_size (void)
 Can be used with any policy.

void set_system_id_size (const TAO_Server_Strategy_Factory::Active_Object_Map_Creation_Parameters &creation_parameters)
 Set the system id size.


Public Attributes

user_id_map * user_id_map_
 Id map.

servant_map * servant_map_
 Servant map.

TAO_Id_Uniqueness_Strategy * id_uniqueness_strategy_
 Id uniqueness strategy.

TAO_Lifespan_Strategy * lifespan_strategy_
 Lifespan strategy.

TAO_Id_Assignment_Strategy * id_assignment_strategy_
 Id assignment strategy.

TAO_Id_Hint_Strategy * id_hint_strategy_
 Id hint strategy.

int using_active_maps_

Static Public Attributes

size_t system_id_size_ = 0
 Size of the system id produced by the map.

Detailed Description

Map of object ids to servants.

Implementation to be used by the POA.

Definition at line 45 of file Active_Object_Map.h.

Member Typedef Documentation

typedef ACE_Hash_Map_Manager_Ex_Adapter< PortableServer::Servant, TAO_Active_Object_Map_Entry *, TAO_Servant_Hash, ACE_Equal_To<PortableServer::Servant>, ACE_Noop_Key_Generator<PortableServer::Servant> > TAO_Active_Object_Map::servant_hash_map
 

Servant hash map.

Definition at line 201 of file Active_Object_Map.h.

Referenced by TAO_Active_Object_Map().

typedef ACE_Map_Manager_Adapter< PortableServer::Servant, TAO_Active_Object_Map_Entry *, ACE_Noop_Key_Generator<PortableServer::Servant> > TAO_Active_Object_Map::servant_linear_map
 

Servant linear map.

Definition at line 208 of file Active_Object_Map.h.

Referenced by TAO_Active_Object_Map().

typedef ACE_Map< PortableServer::Servant, TAO_Active_Object_Map_Entry *> TAO_Active_Object_Map::servant_map
 

Base class of the servant map.

Definition at line 193 of file Active_Object_Map.h.

Referenced by TAO_Active_Object_Map().

typedef ACE_Active_Map_Manager_Adapter< PortableServer::ObjectId, TAO_Active_Object_Map_Entry *, TAO_Ignore_Original_Key_Adapter> TAO_Active_Object_Map::user_id_active_map
 

Id active map.

Definition at line 188 of file Active_Object_Map.h.

Referenced by TAO_Active_Object_Map().

typedef ACE_Hash_Map_Manager_Ex_Adapter< PortableServer::ObjectId, TAO_Active_Object_Map_Entry *, TAO_ObjectId_Hash, ACE_Equal_To<PortableServer::ObjectId>, TAO_Incremental_Key_Generator> TAO_Active_Object_Map::user_id_hash_map
 

Id hash map.

Definition at line 174 of file Active_Object_Map.h.

Referenced by TAO_Active_Object_Map().

typedef ACE_Map_Manager_Adapter< PortableServer::ObjectId, TAO_Active_Object_Map_Entry *, TAO_Incremental_Key_Generator> TAO_Active_Object_Map::user_id_linear_map
 

Id linear map.

Definition at line 181 of file Active_Object_Map.h.

Referenced by TAO_Active_Object_Map().

typedef ACE_Map< PortableServer::ObjectId, TAO_Active_Object_Map_Entry *> TAO_Active_Object_Map::user_id_map
 

Base class of the id map.

Definition at line 166 of file Active_Object_Map.h.

Referenced by TAO_Active_Object_Map().

Constructor & Destructor Documentation

TAO_Active_Object_Map::TAO_Active_Object_Map (  int  user_id_policy,
int  unique_id_policy,
int  persistent_id_policy,
const TAO_Server_Strategy_Factory::Active_Object_Map_Creation_Parameters &  creation_parameters
) 
 

Constructor.

Definition at line 78 of file Active_Object_Map.cpp.

References ACE_CHECK, ACE_ERROR, ACE_NEW_THROW_EX, id_assignment_strategy_, id_hint_strategy_, id_uniqueness_strategy_, lifespan_strategy_, LM_ERROR, ACE_Auto_Basic_Ptr< X >::release(), servant_hash_map, servant_linear_map, servant_map, servant_map_, TAO_Id_Assignment_Strategy::set_active_object_map(), TAO_Lifespan_Strategy::set_active_object_map(), TAO_Id_Uniqueness_Strategy::set_active_object_map(), set_system_id_size(), TAO_ACTIVE_DEMUX, TAO_DYNAMIC_HASH, TAO_LINEAR, user_id_active_map, user_id_hash_map, user_id_linear_map, user_id_map, user_id_map_, and using_active_maps_. 

00083   : user_id_map_ (0),
00084     servant_map_ (0),
00085     id_uniqueness_strategy_ (0),
00086     lifespan_strategy_ (0),
00087     id_assignment_strategy_ (0),
00088     id_hint_strategy_ (0),
00089     using_active_maps_ (0)
00090 {
00091   TAO_Active_Object_Map::set_system_id_size (creation_parameters);
00092 
00093   TAO_Id_Uniqueness_Strategy *id_uniqueness_strategy = 0;
00094 
00095   if (unique_id_policy)
00096     {
00097       ACE_NEW_THROW_EX (id_uniqueness_strategy,
00098                         TAO_Unique_Id_Strategy,
00099                         CORBA::NO_MEMORY ());
00100       ACE_CHECK;
00101     }
00102   else
00103     {
00104       ACE_NEW_THROW_EX (id_uniqueness_strategy,
00105                         TAO_Multiple_Id_Strategy,
00106                         CORBA::NO_MEMORY ());
00107       ACE_CHECK;
00108     }
00109 
00110   // Give ownership to the auto pointer.
00111   auto_ptr<TAO_Id_Uniqueness_Strategy> new_id_uniqueness_strategy (id_uniqueness_strategy);
00112 
00113   TAO_Lifespan_Strategy *lifespan_strategy = 0;
00114 
00115   if (persistent_id_policy)
00116     {
00117       ACE_NEW_THROW_EX (lifespan_strategy,
00118                         TAO_Persistent_Strategy,
00119                         CORBA::NO_MEMORY ());
00120       ACE_CHECK;
00121     }
00122   else
00123     {
00124       ACE_NEW_THROW_EX (lifespan_strategy,
00125                         TAO_Transient_Strategy,
00126                         CORBA::NO_MEMORY ());
00127       ACE_CHECK;
00128     }
00129 
00130   // Give ownership to the auto pointer.
00131   auto_ptr<TAO_Lifespan_Strategy> new_lifespan_strategy (lifespan_strategy);
00132 
00133   TAO_Id_Assignment_Strategy *id_assignment_strategy = 0;
00134 
00135   if (user_id_policy)
00136     {
00137       ACE_NEW_THROW_EX (id_assignment_strategy,
00138                         TAO_User_Id_Strategy,
00139                         CORBA::NO_MEMORY ());
00140       ACE_CHECK;
00141     }
00142   else if (unique_id_policy)
00143     {
00144       ACE_NEW_THROW_EX (id_assignment_strategy,
00145                         TAO_System_Id_With_Unique_Id_Strategy,
00146                         CORBA::NO_MEMORY ());
00147       ACE_CHECK;
00148     }
00149   else
00150     {
00151       ACE_NEW_THROW_EX (id_assignment_strategy,
00152                         TAO_System_Id_With_Multiple_Id_Strategy,
00153                         CORBA::NO_MEMORY ());
00154       ACE_CHECK;
00155     }
00156 
00157   // Give ownership to the auto pointer.
00158   auto_ptr<TAO_Id_Assignment_Strategy> new_id_assignment_strategy (id_assignment_strategy);
00159 
00160   TAO_Id_Hint_Strategy *id_hint_strategy = 0;
00161   if ((user_id_policy
00162        || creation_parameters.allow_reactivation_of_system_ids_)
00163       && creation_parameters.use_active_hint_in_ids_)
00164     {
00165       this->using_active_maps_ = 1;
00166 
00167       ACE_NEW_THROW_EX (id_hint_strategy,
00168                         TAO_Active_Hint_Strategy (creation_parameters.active_object_map_size_),
00169                         CORBA::NO_MEMORY ());
00170       ACE_CHECK;
00171     }
00172   else
00173     {
00174       ACE_NEW_THROW_EX (id_hint_strategy,
00175                         TAO_No_Hint_Strategy,
00176                         CORBA::NO_MEMORY ());
00177       ACE_CHECK;
00178     }
00179 
00180   // Give ownership to the auto pointer.
00181   auto_ptr<TAO_Id_Hint_Strategy> new_id_hint_strategy (id_hint_strategy);
00182 
00183   servant_map *sm = 0;
00184   if (unique_id_policy)
00185     {
00186       switch (creation_parameters.reverse_object_lookup_strategy_for_unique_id_policy_)
00187         {
00188         case TAO_LINEAR:
00189 #if (TAO_HAS_MINIMUM_POA_MAPS == 0)
00190           ACE_NEW_THROW_EX (sm,
00191                             servant_linear_map (creation_parameters.active_object_map_size_),
00192                             CORBA::NO_MEMORY ());
00193           ACE_CHECK;
00194           break;
00195 #else
00196           ACE_ERROR ((LM_ERROR,
00197                       "linear option for -ORBUniqueidPolicyReverseDemuxStrategy "
00198                       "not supported with minimum POA maps. "
00199                       "Ingoring option to use default... \n"));
00200           /* FALL THROUGH */
00201 #endif /* TAO_HAS_MINIMUM_POA_MAPS == 0 */
00202 
00203         case TAO_DYNAMIC_HASH:
00204         default:
00205           ACE_NEW_THROW_EX (sm,
00206                             servant_hash_map (creation_parameters.active_object_map_size_),
00207                             CORBA::NO_MEMORY ());
00208           ACE_CHECK;
00209           break;
00210         }
00211     }
00212 
00213   // Give ownership to the auto pointer.
00214   auto_ptr<servant_map> new_servant_map (sm);
00215 
00216   user_id_map *uim = 0;
00217   if (user_id_policy
00218       || creation_parameters.allow_reactivation_of_system_ids_)
00219     {
00220       switch (creation_parameters.object_lookup_strategy_for_user_id_policy_)
00221         {
00222         case TAO_LINEAR:
00223 #if (TAO_HAS_MINIMUM_POA_MAPS == 0)
00224           ACE_NEW_THROW_EX (uim,
00225                             user_id_linear_map (creation_parameters.active_object_map_size_),
00226                             CORBA::NO_MEMORY ());
00227           ACE_CHECK;
00228           break;
00229 #else
00230           ACE_ERROR ((LM_ERROR,
00231                       "linear option for -ORBUseridPolicyDemuxStrategy "
00232                       "not supported with minimum POA maps. "
00233                       "Ingoring option to use default... \n"));
00234           /* FALL THROUGH */
00235 #endif /* TAO_HAS_MINIMUM_POA_MAPS == 0 */
00236 
00237         case TAO_DYNAMIC_HASH:
00238         default:
00239           ACE_NEW_THROW_EX (uim,
00240                             user_id_hash_map (creation_parameters.active_object_map_size_),
00241                             CORBA::NO_MEMORY ());
00242           ACE_CHECK;
00243           break;
00244         }
00245     }
00246   else
00247     {
00248       switch (creation_parameters.object_lookup_strategy_for_system_id_policy_)
00249         {
00250 #if (TAO_HAS_MINIMUM_POA_MAPS == 0)
00251         case TAO_LINEAR:
00252           ACE_NEW_THROW_EX (uim,
00253                             user_id_linear_map (creation_parameters.active_object_map_size_),
00254                             CORBA::NO_MEMORY ());
00255           ACE_CHECK;
00256           break;
00257 
00258         case TAO_DYNAMIC_HASH:
00259           ACE_NEW_THROW_EX (uim,
00260                             user_id_hash_map (creation_parameters.active_object_map_size_),
00261                             CORBA::NO_MEMORY ());
00262           ACE_CHECK;
00263           break;
00264 #else
00265         case TAO_LINEAR:
00266         case TAO_DYNAMIC_HASH:
00267           ACE_ERROR ((LM_ERROR,
00268                       "linear and dynamic options for -ORBSystemidPolicyDemuxStrategy "
00269                       "are not supported with minimum POA maps. "
00270                       "Ingoring option to use default... \n"));
00271           /* FALL THROUGH */
00272 #endif /* TAO_HAS_MINIMUM_POA_MAPS == 0 */
00273 
00274         case TAO_ACTIVE_DEMUX:
00275         default:
00276 
00277           this->using_active_maps_ = 1;
00278 
00279           ACE_NEW_THROW_EX (uim,
00280                             user_id_active_map (creation_parameters.active_object_map_size_),
00281                             CORBA::NO_MEMORY ());
00282           ACE_CHECK;
00283           break;
00284         }
00285     }
00286 
00287   // Give ownership to the auto pointer.
00288   auto_ptr<user_id_map> new_user_id_map (uim);
00289 
00290   id_uniqueness_strategy->set_active_object_map (this);
00291   lifespan_strategy->set_active_object_map (this);
00292   id_assignment_strategy->set_active_object_map (this);
00293 
00294   // Finally everything is fine.  Make sure to take ownership away
00295   // from the auto pointer.
00296   this->id_uniqueness_strategy_ = new_id_uniqueness_strategy.release ();
00297   this->lifespan_strategy_ = new_lifespan_strategy.release ();
00298   this->id_assignment_strategy_ = new_id_assignment_strategy.release ();
00299   this->id_hint_strategy_ = new_id_hint_strategy.release ();
00300   this->servant_map_ = new_servant_map.release ();
00301   this->user_id_map_ = new_user_id_map.release ();
00302 }

TAO_Active_Object_Map::~TAO_Active_Object_Map (  void   ) 
 

Destructor.

Definition at line 304 of file Active_Object_Map.cpp.

References ACE_Map< KEY, VALUE >::begin(), ACE_Map< KEY, VALUE >::end(), id_assignment_strategy_, id_hint_strategy_, id_uniqueness_strategy_, lifespan_strategy_, servant_map_, and user_id_map_. 

00305 {
00306   user_id_map::iterator iterator = this->user_id_map_->begin ();
00307   user_id_map::iterator end = this->user_id_map_->end ();
00308 
00309   for (;
00310        iterator != end;
00311        ++iterator)
00312     {
00313       user_id_map::value_type map_entry = *iterator;
00314       delete map_entry.second ();
00315     }
00316 
00317   delete this->id_uniqueness_strategy_;
00318   delete this->lifespan_strategy_;
00319   delete this->id_assignment_strategy_;
00320   delete this->id_hint_strategy_;
00321   delete this->servant_map_;
00322   delete this->user_id_map_;
00323 }

Member Function Documentation

ACE_INLINE int TAO_Active_Object_Map::bind_using_system_id_returning_system_id (  PortableServer::Servant  servant,
CORBA::Short  priority,
PortableServer::ObjectId_out  system_id
) 
 

Must be used with SYSTEM_ID policy.

Definition at line 18 of file Active_Object_Map.i.

References ACE_NEW_RETURN, TAO_Id_Assignment_Strategy::bind_using_system_id(), ACE_Map< KEY, VALUE >::create_key(), id_assignment_strategy_, id_hint_strategy_, TAO_Id_Hint_Strategy::system_id(), user_id_map_, and using_active_maps_. 

00021 {
00022   if (servant == 0 &&
00023       !this->using_active_maps_)
00024     {
00025       PortableServer::ObjectId id;
00026 
00027       int result =
00028         this->user_id_map_->create_key (id);
00029 
00030       if (result == 0)
00031         {
00032           ACE_NEW_RETURN (system_id,
00033                           PortableServer::ObjectId (id),
00034                           -1);
00035         }
00036 
00037       return result;
00038     }
00039 
00040   TAO_Active_Object_Map_Entry *entry = 0;
00041 
00042   int result = this->id_assignment_strategy_->bind_using_system_id (servant,
00043                                                                     priority,
00044                                                                     entry);
00045 
00046   if (result == 0)
00047     result = this->id_hint_strategy_->system_id (system_id,
00048                                                  *entry);
00049   return result;
00050 }

ACE_INLINE int TAO_Active_Object_Map::bind_using_system_id_returning_user_id (  PortableServer::Servant  servant,
CORBA::Short  priority,
PortableServer::ObjectId_out  user_id
) 
 

Must be used with SYSTEM_ID policy.

Definition at line 53 of file Active_Object_Map.i.

References ACE_NEW_RETURN, TAO_Id_Assignment_Strategy::bind_using_system_id(), id_assignment_strategy_, and TAO_Active_Object_Map_Entry::user_id_. 

00056 {
00057   TAO_Active_Object_Map_Entry *entry = 0;
00058 
00059   int result = this->id_assignment_strategy_->bind_using_system_id (servant,
00060                                                                     priority,
00061                                                                     entry);
00062   if (result == 0)
00063     ACE_NEW_RETURN (user_id,
00064                     PortableServer::ObjectId (entry->user_id_),
00065                     -1);
00066   return result;
00067 }

ACE_INLINE int TAO_Active_Object_Map::bind_using_user_id (  PortableServer::Servant  servant,
const PortableServer::ObjectId &  user_id,
CORBA::Short  priority
) 
 

Can be used with any policy. With the SYSTEM_ID policy, user_id is actually system_id.

Definition at line 70 of file Active_Object_Map.i.

References TAO_Id_Uniqueness_Strategy::bind_using_user_id(), and id_uniqueness_strategy_. 

00073 {
00074   TAO_Active_Object_Map_Entry *entry = 0;
00075   return this->id_uniqueness_strategy_->bind_using_user_id (servant,
00076                                                             user_id,
00077                                                             priority,
00078                                                             entry);
00079 }

ACE_INLINE size_t TAO_Active_Object_Map::current_size (  void   ) 
 

Size of the map.

Definition at line 252 of file Active_Object_Map.i.

References ACE_Map< KEY, VALUE >::current_size(), and user_id_map_. 

00253 {
00254   return this->user_id_map_->current_size ();
00255 }

ACE_INLINE int TAO_Active_Object_Map::find_entry_using_user_id (  const PortableServer::ObjectId &  user_id,
TAO_Active_Object_Map_Entry *&  entry
) 
 

Return values:
-1 Entry is not found or is deactivated.
0 Entry is found.

Definition at line 177 of file Active_Object_Map.i.

References TAO_Active_Object_Map_Entry::deactivated_, ACE_Map< KEY, VALUE >::find(), and user_id_map_.

Referenced by find_servant_and_system_id_using_user_id(). 

00179 {
00180   int result = this->user_id_map_->find (user_id,
00181                                          entry);
00182 
00183   if (result == 0)
00184     {
00185       if (entry->deactivated_)
00186         result = -1;
00187     }
00188 
00189   return result;
00190 }

ACE_INLINE int TAO_Active_Object_Map::find_servant_and_system_id_using_user_id (  const PortableServer::ObjectId &  user_id,
PortableServer::Servant &  servant,
PortableServer::ObjectId_out  system_id,
CORBA::Short &  priority
) 
 

Can be used with any policy. With the SYSTEM_ID policy, user_id is identical to system_id.

Definition at line 193 of file Active_Object_Map.i.

References find_entry_using_user_id(), id_hint_strategy_, TAO_Active_Object_Map_Entry::priority_, TAO_Active_Object_Map_Entry::servant_, and TAO_Id_Hint_Strategy::system_id(). 

00197 {
00198   TAO_Active_Object_Map_Entry *entry = 0;
00199   int result = this->find_entry_using_user_id (user_id,
00200                                                entry);
00201 
00202   if (result == 0)
00203     {
00204       if (entry->servant_ == 0)
00205         {
00206           result = -1;
00207         }
00208       else
00209         {
00210           result = this->id_hint_strategy_->system_id (system_id,
00211                                                        *entry);
00212           if (result == 0)
00213             {
00214               servant = entry->servant_;
00215               priority = entry->priority_;
00216             }
00217         }
00218     }
00219 
00220   return result;
00221 }

ACE_INLINE int TAO_Active_Object_Map::find_servant_using_system_id_and_user_id (  const PortableServer::ObjectId &  system_id,
const PortableServer::ObjectId &  user_id,
PortableServer::Servant &  servant,
TAO_Active_Object_Map_Entry *&  entry
) 
 

Can be used with any policy.

Definition at line 165 of file Active_Object_Map.i.

References TAO_Lifespan_Strategy::find_servant_using_system_id_and_user_id(), and lifespan_strategy_. 

00169 {
00170   return this->lifespan_strategy_->find_servant_using_system_id_and_user_id (system_id,
00171                                                                              user_id,
00172                                                                              servant,
00173                                                                              entry);
00174 }

ACE_INLINE int TAO_Active_Object_Map::find_servant_using_user_id (  const PortableServer::ObjectId &  user_id,
PortableServer::Servant &  servant
) 
 

Can be used with any policy. With the SYSTEM_ID policy, user_id is actually system_id.

Definition at line 145 of file Active_Object_Map.i.

References TAO_Active_Object_Map_Entry::deactivated_, ACE_Map< KEY, VALUE >::find(), TAO_Active_Object_Map_Entry::servant_, and user_id_map_. 

00147 {
00148   TAO_Active_Object_Map_Entry *entry = 0;
00149   int result = this->user_id_map_->find (user_id,
00150                                          entry);
00151   if (result == 0)
00152     {
00153       if (entry->deactivated_)
00154         result = -1;
00155       else if (entry->servant_ == 0)
00156         result = -1;
00157       else
00158         servant = entry->servant_;
00159     }
00160 
00161   return result;
00162 }

ACE_INLINE int TAO_Active_Object_Map::find_system_id_using_servant (  PortableServer::Servant  servant,
PortableServer::ObjectId_out  system_id,
CORBA::Short &  priority
) 
 

Must be used with UNIQUE_ID policy. With the SYSTEM_ID policy, user_id is actually system_id.

Definition at line 135 of file Active_Object_Map.i.

References TAO_Id_Uniqueness_Strategy::find_system_id_using_servant(), and id_uniqueness_strategy_. 

00138 {
00139   return this->id_uniqueness_strategy_->find_system_id_using_servant (servant,
00140                                                                       system_id,
00141                                                                       priority);
00142 }

ACE_INLINE int TAO_Active_Object_Map::find_system_id_using_user_id (  const PortableServer::ObjectId &  user_id,
CORBA::Short  priority,
PortableServer::ObjectId_out  system_id
) 
 

Can be used with any policy. With the SYSTEM_ID policy, user_id is actually system_id.

Definition at line 82 of file Active_Object_Map.i.

References ACE_NEW_RETURN, TAO_Id_Uniqueness_Strategy::bind_using_user_id(), id_hint_strategy_, id_uniqueness_strategy_, TAO_Id_Hint_Strategy::system_id(), and using_active_maps_. 

00085 {
00086   if (!this->using_active_maps_)
00087     {
00088       ACE_NEW_RETURN (system_id,
00089                       PortableServer::ObjectId (user_id),
00090                       -1);
00091 
00092       return 0;
00093     }
00094 
00095   TAO_Active_Object_Map_Entry *entry = 0;
00096   int result = this->id_uniqueness_strategy_->bind_using_user_id (0,
00097                                                                   user_id,
00098                                                                   priority,
00099                                                                   entry);
00100   if (result == 0)
00101     result = this->id_hint_strategy_->system_id (system_id,
00102                                                  *entry);
00103   return result;
00104 }

ACE_INLINE int TAO_Active_Object_Map::find_user_id_using_servant (  PortableServer::Servant  servant,
PortableServer::ObjectId_out  user_id
) 
 

Must be used with UNIQUE_ID policy. With the SYSTEM_ID policy, user_id is actually system_id.

Definition at line 127 of file Active_Object_Map.i.

References TAO_Id_Uniqueness_Strategy::find_user_id_using_servant(), and id_uniqueness_strategy_. 

00129 {
00130   return this->id_uniqueness_strategy_->find_user_id_using_servant (servant,
00131                                                                     user_id);
00132 }

ACE_INLINE int TAO_Active_Object_Map::find_user_id_using_system_id (  const PortableServer::ObjectId &  system_id,
PortableServer::ObjectId &  user_id
) 
 

Can be used with any policy. When the SYSTEM_ID policy is used, the is identical to .

Definition at line 238 of file Active_Object_Map.i.

References id_hint_strategy_, and TAO_Id_Hint_Strategy::recover_key(). 

00240 {
00241   return this->id_hint_strategy_->recover_key (system_id,
00242                                                user_id);
00243 }

ACE_INLINE int TAO_Active_Object_Map::find_user_id_using_system_id (  const PortableServer::ObjectId &  system_id,
PortableServer::ObjectId_out  user_id
) 
 

Can be used with any policy. When the SYSTEM_ID policy is used, the is identical to .

Definition at line 224 of file Active_Object_Map.i.

References ACE_NEW_RETURN, id_hint_strategy_, and TAO_Id_Hint_Strategy::recover_key(). 

00226 {
00227   PortableServer::ObjectId id;
00228   int result = this->id_hint_strategy_->recover_key (system_id,
00229                                                      id);
00230   if (result == 0)
00231     ACE_NEW_RETURN (user_id,
00232                     PortableServer::ObjectId (id),
00233                     -1);
00234   return 0;
00235 }

TAO_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE int TAO_Active_Object_Map::is_servant_in_map (  PortableServer::Servant  servant,
int &  deactivated
) 
 

Must be used with UNIQUE_ID policy.

Definition at line 10 of file Active_Object_Map.i.

References id_uniqueness_strategy_, and TAO_Id_Uniqueness_Strategy::is_servant_in_map().

Referenced by TAO::Portable_Server::ServantRetentionStrategyRetain::is_servant_in_map(). 

00012 {
00013   return this->id_uniqueness_strategy_->is_servant_in_map (servant,
00014                                                            deactivated);
00015 }

int TAO_Active_Object_Map::is_user_id_in_map (  const PortableServer::ObjectId &  user_id,
CORBA::Short  priority,
int &  priorities_match,
int &  deactivated
) 
 

Can be used with any policy. With the SYSTEM_ID policy, user_id is actually system_id.

Definition at line 326 of file Active_Object_Map.cpp.

References TAO_Active_Object_Map_Entry::deactivated_, ACE_Map< KEY, VALUE >::find(), TAO_Active_Object_Map_Entry::priority_, TAO_Active_Object_Map_Entry::servant_, and user_id_map_.

Referenced by TAO::Portable_Server::ServantRetentionStrategyRetain::is_user_id_in_map(). 

00330 {
00331   TAO_Active_Object_Map_Entry *entry = 0;
00332   int result = this->user_id_map_->find (user_id,
00333                                          entry);
00334   if (result == 0)
00335     {
00336       if (entry->servant_ == 0)
00337         {
00338           result = 0;
00339 
00340           if (entry->priority_ != priority)
00341             priorities_match = 0;
00342         }
00343       else
00344         {
00345           result = 1;
00346           if (entry->deactivated_)
00347             {
00348               deactivated = 1;
00349             }
00350         }
00351     }
00352   else
00353     {
00354       result = 0;
00355     }
00356 
00357   return result;
00358 }

ACE_INLINE int TAO_Active_Object_Map::rebind_using_user_id_and_system_id (  PortableServer::Servant  servant,
const PortableServer::ObjectId &  user_id,
const PortableServer::ObjectId &  system_id,
TAO_Active_Object_Map_Entry *&  entry
) 
 

Can be used with any policy.

Definition at line 107 of file Active_Object_Map.i.

References TAO_Id_Uniqueness_Strategy::bind_using_user_id(), and id_uniqueness_strategy_. 

00111 {
00112   ACE_UNUSED_ARG (system_id);
00113 
00114   return this->id_uniqueness_strategy_->bind_using_user_id (servant,
00115                                                             user_id,
00116                                                             -1,
00117                                                             entry);
00118 }

ACE_INLINE CORBA::Boolean TAO_Active_Object_Map::remaining_activations (  PortableServer::Servant  servant  ) 
 

Are there any remaining activations of servant in the active object map? Can be used with any policy.

Definition at line 246 of file Active_Object_Map.i.

References id_uniqueness_strategy_, and TAO_Id_Uniqueness_Strategy::remaining_activations().

Referenced by TAO::Portable_Server::ServantRetentionStrategyRetain::servant_has_remaining_activations(). 

00247 {
00248   return this->id_uniqueness_strategy_->remaining_activations (servant);
00249 }

void TAO_Active_Object_Map::set_system_id_size (  const TAO_Server_Strategy_Factory::Active_Object_Map_Creation_Parameters &  creation_parameters  )  [static]
 

Set the system id size.

Definition at line 24 of file Active_Object_Map.cpp.

References ACE_Active_Map_Manager_Key::size(), system_id_size_, TAO_ACTIVE_DEMUX, TAO_DYNAMIC_HASH, and TAO_LINEAR.

Referenced by TAO_Active_Object_Map(). 

00025 {
00026   if (TAO_Active_Object_Map::system_id_size_ == 0)
00027     {
00028       if (creation_parameters.allow_reactivation_of_system_ids_)
00029         {
00030           switch (creation_parameters.object_lookup_strategy_for_system_id_policy_)
00031             {
00032 #if (TAO_HAS_MINIMUM_POA_MAPS == 0)
00033             case TAO_LINEAR:
00034               TAO_Active_Object_Map::system_id_size_ =
00035                 sizeof (CORBA::ULong);
00036               break;
00037 #endif /* TAO_HAS_MINIMUM_POA_MAPS == 0 */
00038 
00039             case TAO_DYNAMIC_HASH:
00040             default:
00041               TAO_Active_Object_Map::system_id_size_ = sizeof (CORBA::ULong);
00042               break;
00043             }
00044 
00045           size_t hint_size = 0;
00046 
00047           if (creation_parameters.use_active_hint_in_ids_)
00048             hint_size = ACE_Active_Map_Manager_Key::size ();
00049 
00050           TAO_Active_Object_Map::system_id_size_ += hint_size;
00051         }
00052       else
00053         {
00054           switch (creation_parameters.object_lookup_strategy_for_system_id_policy_)
00055             {
00056 #if (TAO_HAS_MINIMUM_POA_MAPS == 0)
00057             case TAO_LINEAR:
00058               TAO_Active_Object_Map::system_id_size_ =
00059                 sizeof (CORBA::ULong);
00060               break;
00061 
00062             case TAO_DYNAMIC_HASH:
00063               TAO_Active_Object_Map::system_id_size_ =
00064                 sizeof (CORBA::ULong);
00065               break;
00066 #endif /* TAO_HAS_MINIMUM_POA_MAPS == 0 */
00067 
00068             case TAO_ACTIVE_DEMUX:
00069             default:
00070               TAO_Active_Object_Map::system_id_size_ =
00071                 ACE_Active_Map_Manager_Key::size ();
00072               break;
00073             }
00074         }
00075     }
00076 }

ACE_INLINE size_t TAO_Active_Object_Map::system_id_size (  void   )  [static]
 

Can be used with any policy.

Definition at line 259 of file Active_Object_Map.i.

References system_id_size_.

Referenced by TAO_Root_POA::parse_key(). 

00260 {
00261   return TAO_Active_Object_Map::system_id_size_;
00262 }

ACE_INLINE int TAO_Active_Object_Map::unbind_using_user_id (  const PortableServer::ObjectId &  user_id  ) 
 

Can be used with any policy. With the SYSTEM_ID policy, user_id is actually system_id.

Definition at line 121 of file Active_Object_Map.i.

References id_uniqueness_strategy_, and TAO_Id_Uniqueness_Strategy::unbind_using_user_id(). 

00122 {
00123   return this->id_uniqueness_strategy_->unbind_using_user_id (user_id);
00124 }

Member Data Documentation

TAO_Id_Assignment_Strategy* TAO_Active_Object_Map::id_assignment_strategy_
 

Id assignment strategy.

Definition at line 224 of file Active_Object_Map.h.

Referenced by bind_using_system_id_returning_system_id(), bind_using_system_id_returning_user_id(), TAO_Active_Object_Map(), and ~TAO_Active_Object_Map().

TAO_Id_Hint_Strategy* TAO_Active_Object_Map::id_hint_strategy_
 

Id hint strategy.

Definition at line 227 of file Active_Object_Map.h.

Referenced by TAO_System_Id_With_Multiple_Id_Strategy::bind_using_system_id(), TAO_System_Id_With_Unique_Id_Strategy::bind_using_system_id(), bind_using_system_id_returning_system_id(), TAO_Multiple_Id_Strategy::bind_using_user_id(), TAO_Unique_Id_Strategy::bind_using_user_id(), find_servant_and_system_id_using_user_id(), TAO_Persistent_Strategy::find_servant_using_system_id_and_user_id(), TAO_Transient_Strategy::find_servant_using_system_id_and_user_id(), TAO_Unique_Id_Strategy::find_system_id_using_servant(), find_system_id_using_user_id(), find_user_id_using_system_id(), TAO_Active_Object_Map(), TAO_Multiple_Id_Strategy::unbind_using_user_id(), TAO_Unique_Id_Strategy::unbind_using_user_id(), and ~TAO_Active_Object_Map().

TAO_Id_Uniqueness_Strategy* TAO_Active_Object_Map::id_uniqueness_strategy_
 

Id uniqueness strategy.

Definition at line 218 of file Active_Object_Map.h.

Referenced by bind_using_user_id(), find_system_id_using_servant(), find_system_id_using_user_id(), find_user_id_using_servant(), is_servant_in_map(), rebind_using_user_id_and_system_id(), remaining_activations(), TAO_Active_Object_Map(), unbind_using_user_id(), and ~TAO_Active_Object_Map().

TAO_Lifespan_Strategy* TAO_Active_Object_Map::lifespan_strategy_
 

Lifespan strategy.

Definition at line 221 of file Active_Object_Map.h.

Referenced by find_servant_using_system_id_and_user_id(), TAO_Active_Object_Map(), and ~TAO_Active_Object_Map().

servant_map* TAO_Active_Object_Map::servant_map_
 

Servant map.

Definition at line 215 of file Active_Object_Map.h.

Referenced by TAO_System_Id_With_Unique_Id_Strategy::bind_using_system_id(), TAO_Unique_Id_Strategy::bind_using_user_id(), TAO_Unique_Id_Strategy::find_system_id_using_servant(), TAO_Unique_Id_Strategy::find_user_id_using_servant(), TAO_Unique_Id_Strategy::is_servant_in_map(), TAO_Active_Object_Map(), TAO_Unique_Id_Strategy::unbind_using_user_id(), and ~TAO_Active_Object_Map().

TAO_BEGIN_VERSIONED_NAMESPACE_DECL size_t TAO_Active_Object_Map::system_id_size_ = 0 [static]
 

Size of the system id produced by the map.

Definition at line 20 of file Active_Object_Map.cpp.

Referenced by set_system_id_size(), and system_id_size().

user_id_map* TAO_Active_Object_Map::user_id_map_
 

Id map.

Definition at line 212 of file Active_Object_Map.h.

Referenced by TAO_System_Id_With_Multiple_Id_Strategy::bind_using_system_id(), TAO_System_Id_With_Unique_Id_Strategy::bind_using_system_id(), bind_using_system_id_returning_system_id(), TAO_Multiple_Id_Strategy::bind_using_user_id(), TAO_Unique_Id_Strategy::bind_using_user_id(), current_size(), find_entry_using_user_id(), TAO_Persistent_Strategy::find_servant_using_system_id_and_user_id(), TAO_Transient_Strategy::find_servant_using_system_id_and_user_id(), find_servant_using_user_id(), is_user_id_in_map(), TAO_Multiple_Id_Strategy::remaining_activations(), TAO_Active_Object_Map(), TAO_Multiple_Id_Strategy::unbind_using_user_id(), TAO_Unique_Id_Strategy::unbind_using_user_id(), and ~TAO_Active_Object_Map().

int TAO_Active_Object_Map::using_active_maps_
 

Flag to see if we are using active maps in this active object map.

Definition at line 231 of file Active_Object_Map.h.

Referenced by bind_using_system_id_returning_system_id(), find_system_id_using_user_id(), and TAO_Active_Object_Map().

The documentation for this class was generated from the following files:
Generated on Thu Nov 9 12:45:21 2006 for TAO_PortableServer by doxygen 1.3.6