TAO_POA_Manager Class Reference

#include <POAManager.h>

Inheritance diagram for TAO_POA_Manager:

Inheritance graph
[legend]
Collaboration diagram for TAO_POA_Manager:

Collaboration graph
[legend]
List of all members.

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_Locklock (void)
int remove_poa (TAO_Root_POA *poa)
int register_poa (TAO_Root_POA *poa)

Protected Attributes

PortableServer::POAManager::State state_
ACE_Locklock_
POA_COLLECTION poa_collection_
TAO_Object_Adapterobject_adapter_
CORBA::String_var id_
TAO_POAManager_Factorypoa_manager_factory_
CORBA::PolicyList policies_

Private Member Functions

char * generate_manager_id (void) const

Friends

class TAO_Root_POA
class TAO_Object_Adapter

Detailed Description

Definition at line 56 of file POAManager.h.


Member Typedef Documentation

typedef ACE_Unbounded_Set<TAO_Root_POA *> TAO_POA_Manager::POA_COLLECTION [protected]

Definition at line 135 of file POAManager.h.


Constructor & Destructor Documentation

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 }


Member Function Documentation

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.

Returns:
A value that uniquely identifies the POAManager within a given process.
Note:
: The id_ has the ownership of the memory allocated in this method.

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 }


Friends And Related Function Documentation

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.


Member Data Documentation

CORBA::String_var TAO_POA_Manager::id_ [protected]

Definition at line 141 of file POAManager.h.

ACE_Lock& TAO_POA_Manager::lock_ [protected]

Definition at line 133 of file POAManager.h.

Referenced by lock().

TAO_Object_Adapter& TAO_POA_Manager::object_adapter_ [protected]

Definition at line 139 of file POAManager.h.

Referenced by adapter_manager_state_changed().

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

TAO_POAManager_Factory& TAO_POA_Manager::poa_manager_factory_ [protected]

Definition at line 145 of file POAManager.h.

CORBA::PolicyList TAO_POA_Manager::policies_ [protected]

Definition at line 146 of file POAManager.h.

Referenced by get_policies().

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


The documentation for this class was generated from the following files:
Generated on Tue Feb 2 17:41:32 2010 for TAO_PortableServer by  doxygen 1.4.7