#include <POAManager.h>
Inheritance diagram for TAO_POA_Manager:
Public Member Functions | |
void | activate (void) |
void | hold_requests (CORBA::Boolean wait_for_completion) |
void | discard_requests (CORBA::Boolean wait_for_completion) |
void | deactivate (CORBA::Boolean etherealize_objects, CORBA::Boolean wait_for_completion) |
PortableServer::POAManager::State | get_state (void) |
char * | get_id (void) |
TAO_POA_Manager (TAO_Object_Adapter &object_adapter, const char *id, const ::CORBA::PolicyList &policies, PortableServer::POAManagerFactory_ptr poa_manager_factory) | |
~TAO_POA_Manager (void) | |
void | check_state (void) |
Check the state of this POA manager. | |
PortableServer::POAManager::State | get_state_i () |
virtual CORBA::ORB_ptr | _get_orb (void) |
CORBA::PolicyList & | get_policies (void) |
Protected Types | |
typedef ACE_Unbounded_Set< TAO_Root_POA * > | POA_COLLECTION |
Protected Member Functions | |
void | activate_i (void) |
void | deactivate_i (CORBA::Boolean etherealize_objects, CORBA::Boolean wait_for_completion) |
void | adapter_manager_state_changed (PortableServer::POAManager::State state) |
void | hold_requests_i (CORBA::Boolean wait_for_completion) |
void | discard_requests_i (CORBA::Boolean wait_for_completion) |
ACE_Lock & | lock (void) |
int | remove_poa (TAO_Root_POA *poa) |
int | register_poa (TAO_Root_POA *poa) |
Protected Attributes | |
PortableServer::POAManager::State | state_ |
ACE_Lock & | lock_ |
POA_COLLECTION | poa_collection_ |
TAO_Object_Adapter & | object_adapter_ |
CORBA::String_var | id_ |
TAO_POAManager_Factory & | poa_manager_factory_ |
CORBA::PolicyList | policies_ |
Private Member Functions | |
char * | generate_manager_id (void) const |
Friends | |
class | TAO_Root_POA |
class | TAO_Object_Adapter |
Definition at line 56 of file POAManager.h.
typedef ACE_Unbounded_Set<TAO_Root_POA *> TAO_POA_Manager::POA_COLLECTION [protected] |
Definition at line 135 of file POAManager.h.
TAO_BEGIN_VERSIONED_NAMESPACE_DECL TAO_POA_Manager::TAO_POA_Manager | ( | TAO_Object_Adapter & | object_adapter, | |
const char * | id, | |||
const ::CORBA::PolicyList & | policies, | |||
PortableServer::POAManagerFactory_ptr | poa_manager_factory | |||
) |
Definition at line 21 of file POAManager.cpp.
00030 : state_ (PortableServer::POAManager::HOLDING), 00031 lock_ (object_adapter.lock ()), 00032 poa_collection_ (), 00033 object_adapter_ (object_adapter), 00034 #if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO) 00035 id_ (id == 0 ? this->generate_manager_id () : CORBA::string_dup (id)), 00036 poa_manager_factory_ (* dynamic_cast <TAO_POAManager_Factory*> (poa_manager_factory)), 00037 policies_ (policies) 00038 { 00039 poa_manager_factory_._add_ref (); 00040 }
TAO_POA_Manager::~TAO_POA_Manager | ( | void | ) |
Definition at line 48 of file POAManager.cpp.
00049 { 00050 #if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO) 00051 poa_manager_factory_._remove_ref (); 00052 #endif 00053 }
CORBA::ORB_ptr TAO_POA_Manager::_get_orb | ( | void | ) | [virtual] |
Reimplemented from CORBA::LocalObject.
Definition at line 379 of file POAManager.cpp.
References CORBA::ORB::_duplicate().
00380 { 00381 return CORBA::ORB::_duplicate (this->object_adapter_.orb_core ().orb ()); 00382 }
ACE_INLINE void TAO_POA_Manager::activate | ( | void | ) |
Definition at line 17 of file POAManager.inl.
References activate_i(), and TAO_OBJECT_ADAPTER_GUARD.
00018 { 00019 // Lock access to the POAManager for the duration of this transaction 00020 TAO_OBJECT_ADAPTER_GUARD; 00021 00022 this->activate_i (); 00023 }
void TAO_POA_Manager::activate_i | ( | void | ) | [protected] |
Definition at line 62 of file POAManager.cpp.
References adapter_manager_state_changed(), ACE_Unbounded_Set_Ex< T, C >::end(), poa_collection_, and state_.
Referenced by activate().
00063 { 00064 // This operation changes the state of the POA manager to active. If 00065 // issued while the POA manager is in the inactive state, the 00066 // AdapterInactive exception is raised. Entering the active state 00067 // enables the associated POAs to process requests. 00068 00069 if (this->state_ == PortableServer::POAManager::INACTIVE) 00070 { 00071 throw PortableServer::POAManager::AdapterInactive (); 00072 } 00073 else 00074 { 00075 this->state_ = PortableServer::POAManager::ACTIVE; 00076 // Find the poas that applied the custom servant dispatching 00077 // strategy to launch the dispatching threads. 00078 00079 for (POA_COLLECTION::iterator iterator = this->poa_collection_.begin (); 00080 iterator != this->poa_collection_.end (); 00081 ++iterator) 00082 { 00083 (*iterator)->poa_activated_hook (); 00084 } 00085 } 00086 00087 this->adapter_manager_state_changed (this->state_); 00088 }
void TAO_POA_Manager::adapter_manager_state_changed | ( | PortableServer::POAManager::State | state | ) | [protected] |
Method needed for notifying the IORInterceptors that the state of POAManager changed.
Definition at line 160 of file POAManager.cpp.
References TAO_IORInterceptor_Adapter::adapter_manager_state_changed(), TAO_ORB_Core::ior_interceptor_adapter(), object_adapter_, and TAO_Object_Adapter::orb_core().
Referenced by activate_i(), deactivate_i(), discard_requests_i(), and hold_requests_i().
00161 { 00162 PortableInterceptor::AdapterState adapter_state = 00163 static_cast<PortableInterceptor::AdapterState> (state); 00164 00165 TAO_IORInterceptor_Adapter *ior_adapter = 00166 this->object_adapter_.orb_core ().ior_interceptor_adapter (); 00167 00168 if (ior_adapter) 00169 { 00170 ior_adapter->adapter_manager_state_changed (this->id_.in (), 00171 adapter_state); 00172 } 00173 }
void TAO_POA_Manager::check_state | ( | void | ) |
Check the state of this POA manager.
Definition at line 313 of file POAManager.cpp.
References CORBA::SystemException::_tao_minor_code(), CORBA::COMPLETED_NO, state_, TAO_POA_DISCARDING, TAO_POA_HOLDING, and TAO_POA_INACTIVE.
Referenced by TAO::Portable_Server::LifespanStrategyTransient::check_state(), and TAO::Portable_Server::LifespanStrategyPersistent::check_state().
00314 { 00315 if (state_ == PortableServer::POAManager::ACTIVE) 00316 { 00317 // When a POA manager is in the active state, the associated 00318 // POAs will receive and start processing requests (assuming 00319 // that appropriate thread resources are available). 00320 return; 00321 } 00322 00323 if (state_ == PortableServer::POAManager::DISCARDING) 00324 { 00325 // When a POA manager is in the discarding state, the associated 00326 // POAs will discard all incoming requests (whose processing has 00327 // not yet begun). When a request is discarded, the TRANSIENT 00328 // system exception, with standard minor code 1, must be 00329 // returned to the client-side to indicate that the request 00330 // should be re-issued. (Of course, an ORB may always reject a 00331 // request for other reasons and raise some other system 00332 // exception.) 00333 throw 00334 CORBA::TRANSIENT ( 00335 CORBA::SystemException::_tao_minor_code ( 00336 TAO_POA_DISCARDING, 00337 1), 00338 CORBA::COMPLETED_NO); 00339 } 00340 00341 if (state_ == PortableServer::POAManager::HOLDING) 00342 { 00343 // When a POA manager is in the holding state, the associated 00344 // POAs will queue incoming requests. The number of requests 00345 // that can be queued is an implementation limit. If this limit 00346 // is reached, the POAs may discard requests and return the 00347 // TRANSIENT system exception, with standard minor code 1, to 00348 // the client to indicate that the client should reissue the 00349 // request. (Of course, an ORB may always reject a request for 00350 // other reasons and raise some other system exception.) 00351 00352 // Since there is no queuing in TAO, we immediately raise a 00353 // TRANSIENT exception. 00354 throw ::CORBA::TRANSIENT ( 00355 CORBA::SystemException::_tao_minor_code (TAO_POA_HOLDING, 1), 00356 CORBA::COMPLETED_NO); 00357 } 00358 00359 if (state_ == PortableServer::POAManager::INACTIVE) 00360 { 00361 // The inactive state is entered when the associated POAs are to 00362 // be shut down. Unlike the discarding state, the inactive state 00363 // is not a temporary state. When a POA manager is in the 00364 // inactive state, the associated POAs will reject new 00365 // requests. The rejection mechanism used is specific to the 00366 // vendor. The GIOP location forwarding mechanism and 00367 // CloseConnection message are examples of mechanisms that could 00368 // be used to indicate the rejection. If the client is 00369 // co-resident in the same process, the ORB could raise the 00370 // OBJ_ADAPTER system exception, with standard minor code 1, to 00371 // indicate that the object implementation is unavailable. 00372 throw ::CORBA::OBJ_ADAPTER ( 00373 CORBA::SystemException::_tao_minor_code (TAO_POA_INACTIVE, 1), 00374 CORBA::COMPLETED_NO); 00375 } 00376 }
ACE_INLINE void TAO_POA_Manager::deactivate | ( | CORBA::Boolean | etherealize_objects, | |
CORBA::Boolean | wait_for_completion | |||
) |
Definition at line 46 of file POAManager.inl.
References deactivate_i(), and TAO_OBJECT_ADAPTER_GUARD.
00048 { 00049 // Lock access to the POAManager for the duration of this transaction 00050 TAO_OBJECT_ADAPTER_GUARD; 00051 00052 this->deactivate_i (etherealize_objects, wait_for_completion); 00053 }
void TAO_POA_Manager::deactivate_i | ( | CORBA::Boolean | etherealize_objects, | |
CORBA::Boolean | wait_for_completion | |||
) | [protected] |
Definition at line 91 of file POAManager.cpp.
References adapter_manager_state_changed(), TAO_Root_POA::check_for_valid_wait_for_completions(), ACE_Unbounded_Set_Ex< T, C >::end(), poa_collection_, and state_.
Referenced by deactivate().
00093 { 00094 // Is the <wait_for_completion> semantics for this thread correct? 00095 TAO_Root_POA::check_for_valid_wait_for_completions (this->object_adapter_.orb_core (), 00096 wait_for_completion); 00097 00098 // This operation changes the state of the POA manager to 00099 // inactive. If issued while the POA manager is in the inactive 00100 // state, the AdapterInactive exception is raised. Entering the 00101 // inactive state causes the associated POAs to reject requests that 00102 // have not begun to be executed as well as any new requests. 00103 00104 if (this->state_ == PortableServer::POAManager::INACTIVE) 00105 { 00106 throw PortableServer::POAManager::AdapterInactive (); 00107 } 00108 else 00109 { 00110 this->state_ = PortableServer::POAManager::INACTIVE; 00111 } 00112 00113 // After changing the state, if the etherealize_objects parameter is: 00114 // 00115 // a) TRUE - the POA manager will cause all associated POAs that 00116 // have the RETAIN and USE_SERVANT_MANAGER policies to perform the 00117 // etherealize operation on the associated servant manager for all 00118 // active objects. 00119 // 00120 // b) FALSE - the etherealize operation is not called. The purpose 00121 // is to provide developers with a means to shut down POAs in a 00122 // crisis (for example, unrecoverable error) situation. 00123 00124 // If the wait_for_completion parameter is FALSE, this operation 00125 // will return immediately after changing the state. If the 00126 // parameter is TRUE and the current thread is not in an invocation 00127 // context dispatched by some POA belonging to the same ORB as this 00128 // POA, this operation does not return until there are no actively 00129 // executing requests in any of the POAs associated with this POA 00130 // manager (that is, all requests that were started prior to the 00131 // state change have completed) and, in the case of a TRUE 00132 // etherealize_objects, all invocations of etherealize have 00133 // completed for POAs having the RETAIN and USE_SERVANT_MANAGER 00134 // policies. If the parameter is TRUE and the current thread is in 00135 // an invocation context dispatched by some POA belonging to the 00136 // same ORB as this POA the BAD_INV_ORDER exception is raised and 00137 // the state is not changed. 00138 00139 for (POA_COLLECTION::iterator iterator = this->poa_collection_.begin (); 00140 iterator != this->poa_collection_.end (); 00141 ++iterator) 00142 { 00143 TAO_Root_POA *poa = *iterator; 00144 // Notify the poas that applied the custom servant dispatching 00145 // strategy to stop the dispatching threads. 00146 poa->poa_deactivated_hook (); 00147 00148 poa->deactivate_all_objects_i (etherealize_objects, wait_for_completion); 00149 } 00150 00151 // If the ORB::shutdown operation is called, it makes a call on 00152 // deactivate with a TRUE etherealize_objects parameter for each POA 00153 // manager known in the process; the wait_for_completion parameter 00154 // to deactivate will be the same as the similarly named parameter 00155 // of ORB::shutdown. 00156 this->adapter_manager_state_changed (this->state_); 00157 }
ACE_INLINE void TAO_POA_Manager::discard_requests | ( | CORBA::Boolean | wait_for_completion | ) |
Definition at line 37 of file POAManager.inl.
References discard_requests_i(), and TAO_OBJECT_ADAPTER_GUARD.
00038 { 00039 // Lock access to the POAManager for the duration of this transaction 00040 TAO_OBJECT_ADAPTER_GUARD; 00041 00042 this->discard_requests_i (wait_for_completion); 00043 }
void TAO_POA_Manager::discard_requests_i | ( | CORBA::Boolean | wait_for_completion | ) | [protected] |
Definition at line 229 of file POAManager.cpp.
References adapter_manager_state_changed(), TAO_Root_POA::check_for_valid_wait_for_completions(), ACE_Unbounded_Set_Ex< T, C >::end(), poa_collection_, and state_.
Referenced by discard_requests().
00230 { 00231 // Is the <wait_for_completion> semantics for this thread correct? 00232 TAO_Root_POA::check_for_valid_wait_for_completions (this->object_adapter_.orb_core (), 00233 wait_for_completion); 00234 00235 // This operation changes the state of the POA manager to 00236 // discarding. If issued while the POA manager is in the inactive 00237 // state, the AdapterInactive exception is raised. Entering the 00238 // discarding state causes the associated POAs to discard incoming 00239 // requests. In addition, any requests that have been queued but 00240 // have not started executing are discarded. When a request is 00241 // discarded, a TRANSIENT system exception is returned to the 00242 // client. 00243 00244 if (this->state_ == PortableServer::POAManager::INACTIVE) 00245 { 00246 throw PortableServer::POAManager::AdapterInactive (); 00247 } 00248 else 00249 { 00250 this->state_ = PortableServer::POAManager::DISCARDING; 00251 } 00252 00253 // If the wait_for_completion parameter is FALSE, this operation 00254 // returns immediately after changing the state. If the 00255 // parameter is TRUE and the current thread is not in an 00256 // invocation context dispatched by some POA belonging to the 00257 // same ORB as this POA, this operation does not return until 00258 // either there are no actively executing requests in any of the 00259 // POAs associated with this POA manager (that is, all requests 00260 // that were started prior to the state change have completed) 00261 // or the state of the POA manager is changed to a state other 00262 // than discarding. If the parameter is TRUE and the current 00263 // thread is in an invocation context dispatched by some POA 00264 // belonging to the same ORB as this POA the BAD_INV_ORDER 00265 // exception is raised and the state is not changed. 00266 00267 if (wait_for_completion) 00268 { 00269 for (POA_COLLECTION::iterator iterator = this->poa_collection_.begin (); 00270 iterator != this->poa_collection_.end (); 00271 ++iterator) 00272 { 00273 TAO_Root_POA *poa = *iterator; 00274 poa->wait_for_completions (wait_for_completion); 00275 } 00276 } 00277 00278 this->adapter_manager_state_changed (this->state_); 00279 }
ACE_INLINE char * TAO_POA_Manager::generate_manager_id | ( | void | ) | const [private] |
Generate an id for this POAManager.
Definition at line 73 of file POAManager.inl.
References ACE_OS::sprintf().
00074 { 00075 // The AdapterManagerId must be unique across all Adapter Managers 00076 // (e.g. POAManagers) within a given process. To avoid locking 00077 // overhead, the address of the POAManager object is used as the 00078 // AdapterManagerId. This guarantees that the AdapterManagerId is 00079 // unique. 00080 // 00081 // For 64-bit platforms, only the lower 32 bits are used. Hopefully 00082 // that will be enough to ensure uniqueness. 00083 00084 // This is basically the same trick used in 00085 // TAO_GIOP_Invocation::generate_request_id(). However, no right 00086 // shifting of 64 bit addresses is performed since the 00087 // TAO_POA_Manager object is not large enough to allow that trick. 00088 00089 CORBA::Long id = 0; 00090 00091 // Note that we reinterpret_cast to an "unsigned long" instead of 00092 // CORBA::ULong since we need to first cast to an integer large 00093 // enough to hold an address to avoid compile-time warnings on some 00094 // 64-bit platforms. 00095 00096 if (sizeof (this) == 4) // 32 bit address 00097 id = reinterpret_cast <ptrdiff_t> (this); 00098 00099 else if (sizeof (this) == 8) // 64 bit address -- use lower 32 bits 00100 id = reinterpret_cast <ptrdiff_t> (this) & 0xFFFFFFFFu; 00101 00102 // @@ If we ever hit a platform where neither of the above cases are 00103 // satisfied, we're up the creek! 00104 00105 // else 00106 // // Fallback on an atomically incremented variable specific to the 00107 // // ORB, or perhaps specific to the process. 00108 // id = ...GENERATE_ID_ATOMICALLY...; // Fallback 00109 00110 char* buf = new char [25]; 00111 ACE_OS::sprintf (buf, "POAManager%d", id); 00112 return buf; 00113 }
char * TAO_POA_Manager::get_id | ( | void | ) |
Definition at line 56 of file POAManager.cpp.
References CORBA::string_dup().
00057 { 00058 return CORBA::string_dup (this->id_.in ()); 00059 }
ACE_INLINE CORBA::PolicyList & TAO_POA_Manager::get_policies | ( | void | ) |
Definition at line 119 of file POAManager.inl.
References policies_.
00120 { 00121 return this->policies_; 00122 }
ACE_INLINE PortableServer::POAManager::State TAO_POA_Manager::get_state | ( | void | ) |
Definition at line 64 of file POAManager.inl.
References get_state_i(), and TAO_OBJECT_ADAPTER_GUARD_RETURN.
00065 { 00066 // Lock access to the POAManager for the duration of this transaction 00067 TAO_OBJECT_ADAPTER_GUARD_RETURN (this->state_); 00068 00069 return this->get_state_i (); 00070 }
ACE_INLINE PortableServer::POAManager::State TAO_POA_Manager::get_state_i | ( | ) |
Definition at line 58 of file POAManager.inl.
References state_.
Referenced by get_state().
00059 { 00060 return this->state_; 00061 }
ACE_INLINE void TAO_POA_Manager::hold_requests | ( | CORBA::Boolean | wait_for_completion | ) |
Definition at line 28 of file POAManager.inl.
References hold_requests_i(), and TAO_OBJECT_ADAPTER_GUARD.
00029 { 00030 // Lock access to the POAManager for the duration of this transaction 00031 TAO_OBJECT_ADAPTER_GUARD; 00032 00033 this->hold_requests_i (wait_for_completion); 00034 }
void TAO_POA_Manager::hold_requests_i | ( | CORBA::Boolean | wait_for_completion | ) | [protected] |
Definition at line 178 of file POAManager.cpp.
References adapter_manager_state_changed(), TAO_Root_POA::check_for_valid_wait_for_completions(), ACE_Unbounded_Set_Ex< T, C >::end(), poa_collection_, and state_.
Referenced by hold_requests().
00179 { 00180 // Is the <wait_for_completion> semantics for this thread correct? 00181 TAO_Root_POA::check_for_valid_wait_for_completions (this->object_adapter_.orb_core (), 00182 wait_for_completion); 00183 00184 // This operation changes the state of the POA manager to 00185 // holding. If issued while the POA manager is in the inactive 00186 // state, the AdapterInactive exception is raised. Entering the 00187 // holding state causes the associated POAs to queue incoming 00188 // requests. Any requests that have been queued but have not 00189 // started executing will continue to be queued while in the holding 00190 // state. 00191 00192 if (this->state_ == PortableServer::POAManager::INACTIVE) 00193 { 00194 throw PortableServer::POAManager::AdapterInactive (); 00195 } 00196 else 00197 { 00198 this->state_ = PortableServer::POAManager::HOLDING; 00199 } 00200 00201 // If the wait_for_completion parameter is FALSE, this operation 00202 // returns immediately after changing the state. If the parameter is 00203 // TRUE and the current thread is not in an invocation context 00204 // dispatched by some POA belonging to the same ORB as this POA, 00205 // this operation does not return until either there are no actively 00206 // executing requests in any of the POAs associated with this POA 00207 // manager (that is, all requests that were started prior to the 00208 // state change have completed) or the state of the POA manager is 00209 // changed to a state other than holding. If the parameter is TRUE 00210 // and the current thread is in an invocation context dispatched by 00211 // some POA belonging to the same ORB as this POA the BAD_INV_ORDER 00212 // exception is raised and the state is not changed. 00213 00214 if (wait_for_completion) 00215 { 00216 for (POA_COLLECTION::iterator iterator = this->poa_collection_.begin (); 00217 iterator != this->poa_collection_.end (); 00218 ++iterator) 00219 { 00220 TAO_Root_POA *poa = *iterator; 00221 poa->wait_for_completions (wait_for_completion); 00222 } 00223 } 00224 00225 this->adapter_manager_state_changed (this->state_); 00226 }
TAO_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE ACE_Lock & TAO_POA_Manager::lock | ( | void | ) | [protected] |
Definition at line 11 of file POAManager.inl.
References lock_.
00012 { 00013 return this->lock_; 00014 }
int TAO_POA_Manager::register_poa | ( | TAO_Root_POA * | poa | ) | [protected] |
Definition at line 307 of file POAManager.cpp.
References ACE_Unbounded_Set_Ex< T, C >::insert(), and poa_collection_.
Referenced by TAO_Root_POA::TAO_Root_POA().
00308 { 00309 return this->poa_collection_.insert (poa); 00310 }
int TAO_POA_Manager::remove_poa | ( | TAO_Root_POA * | poa | ) | [protected] |
Definition at line 284 of file POAManager.cpp.
References poa_collection_, and ACE_Unbounded_Set_Ex< T, C >::remove().
Referenced by TAO_Root_POA::TAO_Root_POA().
00285 { 00286 int const result = this->poa_collection_.remove (poa); 00287 00288 // The #if really only needs to go around the 00289 // "this->poa_manager_factory_.remove_poamanager (this);" line, but it's 00290 // moved out as an optimization for now. If additional non-CORBA/e and 00291 // non-minimum POA code needs to go in that clause the #if would have to 00292 // move back in. 00293 00294 #if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO) 00295 if (result == 0) 00296 { 00297 if (this->poa_collection_.is_empty ()) 00298 { 00299 this->poa_manager_factory_.remove_poamanager (this); 00300 } 00301 } 00302 #endif 00303 return result; 00304 }
friend class TAO_Object_Adapter [friend] |
Definition at line 61 of file POAManager.h.
friend class TAO_Root_POA [friend] |
Definition at line 60 of file POAManager.h.
CORBA::String_var TAO_POA_Manager::id_ [protected] |
Definition at line 141 of file POAManager.h.
ACE_Lock& TAO_POA_Manager::lock_ [protected] |
TAO_Object_Adapter& TAO_POA_Manager::object_adapter_ [protected] |
POA_COLLECTION TAO_POA_Manager::poa_collection_ [protected] |
Definition at line 137 of file POAManager.h.
Referenced by activate_i(), deactivate_i(), discard_requests_i(), hold_requests_i(), register_poa(), and remove_poa().
Definition at line 145 of file POAManager.h.
CORBA::PolicyList TAO_POA_Manager::policies_ [protected] |
PortableServer::POAManager::State TAO_POA_Manager::state_ [protected] |
Definition at line 131 of file POAManager.h.
Referenced by activate_i(), check_state(), deactivate_i(), discard_requests_i(), get_state_i(), and hold_requests_i().