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, bool &deactivated)
 Must be used with UNIQUE_ID policy.

bool is_user_id_in_map (const PortableServer::ObjectId &user_id, CORBA::Short priority, bool &priorities_match, bool &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.

bool 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 199 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 206 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 191 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 186 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 180 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 80 of file Active_Object_Map.cpp.

References ACE_ERROR, ACE_NEW_THROW_EX, TAO_Server_Strategy_Factory::Active_Object_Map_Creation_Parameters::active_object_map_size_, TAO_Server_Strategy_Factory::Active_Object_Map_Creation_Parameters::allow_reactivation_of_system_ids_, id_assignment_strategy_, id_hint_strategy_, id_uniqueness_strategy_, lifespan_strategy_, LM_ERROR, TAO_Server_Strategy_Factory::Active_Object_Map_Creation_Parameters::object_lookup_strategy_for_system_id_policy_, TAO_Server_Strategy_Factory::Active_Object_Map_Creation_Parameters::object_lookup_strategy_for_user_id_policy_, ACE_Auto_Basic_Ptr< X >::release(), TAO_Server_Strategy_Factory::Active_Object_Map_Creation_Parameters::reverse_object_lookup_strategy_for_unique_id_policy_, 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, TAO_Server_Strategy_Factory::Active_Object_Map_Creation_Parameters::use_active_hint_in_ids_, user_id_active_map, user_id_hash_map, user_id_linear_map, user_id_map, user_id_map_, and using_active_maps_. 

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

TAO_Active_Object_Map::~TAO_Active_Object_Map (  void   ) 
 

Destructor.

Definition at line 310 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_. 

00311 {
00312   user_id_map::iterator iterator = this->user_id_map_->begin ();
00313   user_id_map::iterator end = this->user_id_map_->end ();
00314 
00315   for (;
00316        iterator != end;
00317        ++iterator)
00318     {
00319       user_id_map::value_type map_entry = *iterator;
00320       delete map_entry.second ();
00321     }
00322 
00323   delete this->id_uniqueness_strategy_;
00324   delete this->lifespan_strategy_;
00325   delete this->id_assignment_strategy_;
00326   delete this->id_hint_strategy_;
00327   delete this->servant_map_;
00328   delete this->user_id_map_;
00329 }

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

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

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

References TAO_Id_Uniqueness_Strategy::bind_using_user_id(), and id_uniqueness_strategy_.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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,
bool &  deactivated
) 
 

Must be used with UNIQUE_ID policy.

Definition at line 10 of file Active_Object_Map.inl.

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 }

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

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

Definition at line 332 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(). 

00336 {
00337   TAO_Active_Object_Map_Entry *entry = 0;
00338   bool result = false;
00339   int const find_result = this->user_id_map_->find (user_id, entry);
00340   if (find_result == 0)
00341     {
00342       if (entry->servant_ == 0)
00343         {
00344           if (entry->priority_ != priority)
00345             priorities_match = false;
00346         }
00347       else
00348         {
00349           result = true;
00350           if (entry->deactivated_)
00351             {
00352               deactivated = true;
00353             }
00354         }
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.inl.

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

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 26 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(). 

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

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

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

References id_uniqueness_strategy_, and TAO_Id_Uniqueness_Strategy::unbind_using_user_id().

Referenced by TAO::Portable_Server::ServantRetentionStrategyRetain::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 222 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 225 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 216 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 219 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 213 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 22 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 210 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(), TAO::Portable_Server::ServantRetentionStrategyRetain::deactivate_all_objects(), 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().

bool TAO_Active_Object_Map::using_active_maps_
 

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

Definition at line 229 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 Sun Jan 27 13:27:05 2008 for TAO_PortableServer by doxygen 1.3.6