#include <Object_Adapter.h>
Inheritance diagram for TAO_Object_Adapter:
This class will be used as a facade for the POAs in a server
Definition at line 74 of file Object_Adapter.h.
|
Id hash map.
Definition at line 375 of file Object_Adapter.h. Referenced by TAO_Object_Adapter(). |
|
|
Id linear map.
Definition at line 382 of file Object_Adapter.h. Referenced by TAO_Object_Adapter(). |
|
|
Base class of the name map.
Definition at line 367 of file Object_Adapter.h. Referenced by TAO_Object_Adapter(). |
|
|
Definition at line 81 of file Object_Adapter.h. Referenced by activate_poa(), bind_persistent_poa(), TAO_Object_Adapter::No_Hint_Strategy::bind_persistent_poa(), TAO_Object_Adapter::Active_Hint_Strategy::bind_persistent_poa(), bind_poa(), bind_transient_poa(), find_persistent_poa(), TAO_Object_Adapter::No_Hint_Strategy::find_persistent_poa(), TAO_Object_Adapter::Active_Hint_Strategy::find_persistent_poa(), find_poa(), find_transient_poa(), TAO_Root_POA::is_poa_generated(), TAO_Object_Adapter::iteratable_poa_name::iteratable_poa_name(), locate_poa(), TAO_Root_POA::parse_ir_object_key(), TAO_Root_POA::parse_key(), unbind_persistent_poa(), TAO_Object_Adapter::No_Hint_Strategy::unbind_persistent_poa(), TAO_Object_Adapter::Active_Hint_Strategy::unbind_persistent_poa(), unbind_poa(), and unbind_transient_poa(). |
|
|
Definition at line 83 of file Object_Adapter.h. Referenced by bind_persistent_poa(), TAO_Object_Adapter::No_Hint_Strategy::bind_persistent_poa(), TAO_Object_Adapter::Active_Hint_Strategy::bind_persistent_poa(), bind_poa(), and bind_transient_poa(). |
|
|
Definition at line 82 of file Object_Adapter.h. |
|
|
Id active map.
Definition at line 362 of file Object_Adapter.h. Referenced by TAO_Object_Adapter(). |
|
|
Id hash map.
Definition at line 347 of file Object_Adapter.h. Referenced by TAO_Object_Adapter(). |
|
|
Id linear map.
Definition at line 355 of file Object_Adapter.h. Referenced by TAO_Object_Adapter(). |
|
|
Base class of the id map.
Definition at line 338 of file Object_Adapter.h. Referenced by TAO_Object_Adapter(). |
|
||||||||||||
|
Constructor.
Definition at line 143 of file Object_Adapter.cpp. References ACE_ERROR, ACE_NEW, hint_strategy_, LM_ERROR, persistent_poa_name_hash_map, persistent_poa_name_linear_map, persistent_poa_name_map, persistent_poa_name_map_, TAO_Server_Strategy_Factory::Active_Object_Map_Creation_Parameters::poa_lookup_strategy_for_persistent_id_policy_, TAO_Server_Strategy_Factory::Active_Object_Map_Creation_Parameters::poa_lookup_strategy_for_transient_id_policy_, TAO_Server_Strategy_Factory::Active_Object_Map_Creation_Parameters::poa_map_size_, ACE_Auto_Basic_Ptr< X >::release(), set_transient_poa_name_size(), TAO_ACTIVE_DEMUX, TAO_DYNAMIC_HASH, TAO_HAS_MINIMUM_POA, TAO_LINEAR, transient_poa_active_map, transient_poa_hash_map, transient_poa_linear_map, transient_poa_map, transient_poa_map_, and TAO_Server_Strategy_Factory::Active_Object_Map_Creation_Parameters::use_active_hint_in_poa_names_.
00145 : hint_strategy_ (0), 00146 servant_dispatcher_ (0), 00147 persistent_poa_name_map_ (0), 00148 transient_poa_map_ (0), 00149 orb_core_ (orb_core), 00150 enable_locking_ (orb_core_.server_factory ()->enable_poa_locking ()), 00151 thread_lock_ (), 00152 lock_ (TAO_Object_Adapter::create_lock (enable_locking_, 00153 thread_lock_)), 00154 reverse_lock_ (*lock_), 00155 non_servant_upcall_condition_ (thread_lock_), 00156 non_servant_upcall_in_progress_ (0), 00157 non_servant_upcall_nesting_level_ (0), 00158 non_servant_upcall_thread_ (ACE_OS::NULL_thread), 00159 root_ (0), 00160 #if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO) 00161 poa_manager_factory_ (0), 00162 #endif 00163 default_validator_ (orb_core), 00164 default_poa_policies_ () 00165 { 00166 TAO_Object_Adapter::set_transient_poa_name_size (creation_parameters); 00167 00168 Hint_Strategy *hint_strategy = 0; 00169 if (creation_parameters.use_active_hint_in_poa_names_) 00170 ACE_NEW (hint_strategy, 00171 Active_Hint_Strategy (creation_parameters.poa_map_size_)); 00172 else 00173 ACE_NEW (hint_strategy, 00174 No_Hint_Strategy); 00175 00176 // Give ownership to the auto pointer. 00177 auto_ptr<Hint_Strategy> new_hint_strategy (hint_strategy); 00178 00179 new_hint_strategy->object_adapter (this); 00180 00181 persistent_poa_name_map *ppnm = 0; 00182 switch (creation_parameters.poa_lookup_strategy_for_persistent_id_policy_) 00183 { 00184 case TAO_LINEAR: 00185 #if (TAO_HAS_MINIMUM_POA_MAPS == 0) 00186 ACE_NEW (ppnm, 00187 persistent_poa_name_linear_map (creation_parameters.poa_map_size_)); 00188 00189 break; 00190 #else 00191 ACE_ERROR ((LM_ERROR, 00192 "linear option for -ORBPersistentidPolicyDemuxStrategy " 00193 "not supported with minimum POA maps. " 00194 "Ingoring option to use default... \n")); 00195 /* FALL THROUGH */ 00196 #endif /* TAO_HAS_MINIMUM_POA_MAPS == 0 */ 00197 case TAO_DYNAMIC_HASH: 00198 default: 00199 ACE_NEW (ppnm, 00200 persistent_poa_name_hash_map (creation_parameters.poa_map_size_)); 00201 break; 00202 } 00203 // Give ownership to the auto pointer. 00204 auto_ptr<persistent_poa_name_map> new_persistent_poa_name_map (ppnm); 00205 00206 transient_poa_map *tpm = 0; 00207 switch (creation_parameters.poa_lookup_strategy_for_transient_id_policy_) 00208 { 00209 #if (TAO_HAS_MINIMUM_POA_MAPS == 0) 00210 case TAO_LINEAR: 00211 ACE_NEW (tpm, 00212 transient_poa_linear_map (creation_parameters.poa_map_size_)); 00213 break; 00214 case TAO_DYNAMIC_HASH: 00215 ACE_NEW (tpm, 00216 transient_poa_hash_map (creation_parameters.poa_map_size_)); 00217 break; 00218 #else 00219 case TAO_LINEAR: 00220 case TAO_DYNAMIC_HASH: 00221 ACE_ERROR ((LM_ERROR, 00222 "linear and dynamic options for -ORBTransientidPolicyDemuxStrategy " 00223 "are not supported with minimum POA maps. " 00224 "Ingoring option to use default... \n")); 00225 /* FALL THROUGH */ 00226 #endif /* TAO_HAS_MINIMUM_POA_MAPS == 0 */ 00227 case TAO_ACTIVE_DEMUX: 00228 default: 00229 ACE_NEW (tpm, 00230 transient_poa_active_map (creation_parameters.poa_map_size_)); 00231 break; 00232 } 00233 // Give ownership to the auto pointer. 00234 auto_ptr<transient_poa_map> new_transient_poa_map (tpm); 00235 00236 this->hint_strategy_ = 00237 new_hint_strategy.release (); 00238 this->persistent_poa_name_map_ = 00239 new_persistent_poa_name_map.release (); 00240 this->transient_poa_map_ = 00241 new_transient_poa_map.release (); 00242 } |
|
|
Destructor.
Definition at line 294 of file Object_Adapter.cpp. References hint_strategy_, persistent_poa_name_map_, release_poa_manager_factory(), servant_dispatcher_, and transient_poa_map_.
00295 {
00296 delete this->hint_strategy_;
00297 delete this->persistent_poa_name_map_;
00298 delete this->transient_poa_map_;
00299 delete this->lock_;
00300
00301 delete this->servant_dispatcher_;
00302
00303 // This cleanup may have already occurred in the close() method. If
00304 // that is the case then this won't cause any harm since root_ and
00305 // poa_manager_factory_ would have been set to zero. But, if close
00306 // wasn't called, then these would be leaked. It may be better if
00307 // these pointers had a corresponding _var version so that this cleanup
00308 // could be automatic.
00309 ::CORBA::release (this->root_);
00310 #if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO)
00311 release_poa_manager_factory (this->poa_manager_factory_);
00312 #endif
00313 }
|
|
||||||||||||
|
Definition at line 436 of file Object_Adapter.cpp. References TAO_Object_Adapter::iteratable_poa_name::begin(), TAO_Object_Adapter::iteratable_poa_name::end(), TAO_Root_POA::find_POA_i(), TAO_Root_POA::name(), and poa_name. Referenced by TAO_Object_Adapter::No_Hint_Strategy::find_persistent_poa(), and TAO_Object_Adapter::Active_Hint_Strategy::find_persistent_poa().
00438 {
00439 int result = -1;
00440
00441 #if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_MICRO)
00442
00443 iteratable_poa_name ipn (folded_name);
00444 iteratable_poa_name::iterator iterator = ipn.begin ();
00445 iteratable_poa_name::iterator end = ipn.end ();
00446
00447 TAO_Root_POA *parent = this->root_;
00448 if (parent == 0 || parent->name () != *iterator)
00449 throw ::CORBA::OBJ_ADAPTER ();
00450 else
00451 ++iterator;
00452
00453 for (;
00454 iterator != end;
00455 ++iterator)
00456 {
00457 TAO_Root_POA *current = 0;
00458
00459 try
00460 {
00461 current = parent->find_POA_i (*iterator, 1);
00462 }
00463 catch (const PortableServer::POA::AdapterNonExistent&)
00464 {
00465 return -1;
00466 }
00467
00468 parent = current;
00469 }
00470
00471 poa = parent;
00472 result = 0;
00473 #else
00474 ACE_UNUSED_ARG (folded_name);
00475 ACE_UNUSED_ARG (poa);
00476 #endif /* TAO_HAS_MINIMUM_POA == 0 */
00477
00478 return result;
00479 }
|
|
||||||||||||||||
|
Definition at line 117 of file Object_Adapter.inl. References TAO_Object_Adapter::Hint_Strategy::bind_persistent_poa(), hint_strategy_, poa_name, and poa_name_out. Referenced by bind_poa().
00120 {
00121 return this->hint_strategy_->bind_persistent_poa (folded_name,
00122 poa,
00123 system_name);
00124 }
|
|
||||||||||||||||
|
Definition at line 506 of file Object_Adapter.cpp. References bind_persistent_poa(), bind_transient_poa(), TAO_Root_POA::persistent(), poa_name, and poa_name_out. Referenced by TAO_Root_POA::TAO_Root_POA().
00509 {
00510 if (poa->persistent ())
00511 return this->bind_persistent_poa (folded_name, poa, system_name);
00512 else
00513 return this->bind_transient_poa (poa, system_name);
00514 }
|
|
||||||||||||
|
Definition at line 100 of file Object_Adapter.inl. References ACE_NEW_RETURN, ACE_Map< poa_name, TAO_Root_POA * >::bind_create_key(), poa_name, poa_name_out, and transient_poa_map_. Referenced by bind_poa().
00102 {
00103 poa_name name;
00104 int result = this->transient_poa_map_->bind_create_key (poa, name);
00105
00106 if (result == 0)
00107 {
00108 ACE_NEW_RETURN (system_name,
00109 poa_name (name),
00110 -1);
00111 }
00112
00113 return result;
00114 }
|
|
|
Implements TAO_Adapter. Definition at line 701 of file Object_Adapter.cpp. References TAO_Root_POA::check_for_valid_wait_for_completions(). Referenced by close().
00702 {
00703 TAO_Root_POA::check_for_valid_wait_for_completions (this->orb_core (),
00704 wait_for_completion);
00705 }
|
|
|
Implements TAO_Adapter. Definition at line 662 of file Object_Adapter.cpp. References ACE_GUARD, check_close(), TAO_Root_POA::destroy(), poa_manager_factory_, and release_poa_manager_factory().
00663 {
00664 this->check_close (wait_for_completion);
00665
00666 // Shutting down the ORB causes all object adapters to be destroyed,
00667 // since they cannot exist in the absence of an ORB. Shut down is
00668 // complete when all ORB processing (including request processing
00669 // and object deactivation or other operations associated with
00670 // object adapters) has completed and the object adapters have been
00671 // destroyed. In the case of the POA, this means that all object
00672 // etherealizations have finished and root POA has been destroyed
00673 // (implying that all descendent POAs have also been destroyed).
00674 TAO_Root_POA *root = 0;
00675 #if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO)
00676 TAO_POAManager_Factory* factory = 0;
00677 #endif
00678 {
00679 ACE_GUARD (ACE_Lock, ace_mon, this->lock ());
00680 if (this->root_ == 0)
00681 return;
00682 root = this->root_;
00683 this->root_ = 0;
00684
00685 #if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO)
00686 if (this->poa_manager_factory_ == 0)
00687 return;
00688 factory = this->poa_manager_factory_;
00689 this->poa_manager_factory_ = 0;
00690 #endif
00691 }
00692 CORBA::Boolean etherealize_objects = true;
00693 root->destroy (etherealize_objects, wait_for_completion);
00694 ::CORBA::release (root);
00695 #if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO)
00696 release_poa_manager_factory (factory);
00697 #endif
00698 }
|
|
||||||||||||
|
Implements TAO_Adapter. Definition at line 856 of file Object_Adapter.cpp. References ACE_NEW_RETURN, get_collocated_servant(), and TAO_Stub::servant_orb().
00858 {
00859 TAO_ServantBase *sb = this->get_collocated_servant (mp);
00860
00861 // Set the servant ORB. Do not duplicate the ORB here since
00862 // TAO_Stub::servant_orb() duplicates it.
00863 stub->servant_orb (this->orb_core_.orb ());
00864
00865 // It is ok to create a collocated object even when <sb> is
00866 // zero. This constructor will set the stub collocated indicator and
00867 // the strategized proxy broker if required.
00868 CORBA::Object_ptr x;
00869 ACE_NEW_RETURN (x,
00870 CORBA::Object (stub,
00871 1,
00872 sb),
00873 CORBA::Object::_nil ());
00874
00875 // Success.
00876 return x;
00877 }
|
|
||||||||||||
|
Definition at line 317 of file Object_Adapter.cpp. References ACE_NEW_RETURN.
00319 {
00320 #if defined (ACE_HAS_THREADS)
00321 if (enable_locking)
00322 {
00323 ACE_Lock *the_lock = 0;
00324 ACE_NEW_RETURN (the_lock,
00325 ACE_Lock_Adapter<TAO_SYNCH_MUTEX> (thread_lock),
00326 0);
00327 return the_lock;
00328 }
00329 #else
00330 ACE_UNUSED_ARG (enable_locking);
00331 ACE_UNUSED_ARG (thread_lock);
00332 #endif /* ACE_HAS_THREADS */
00333
00334 ACE_Lock *the_lock = 0;
00335 ACE_NEW_RETURN (the_lock,
00336 ACE_Lock_Adapter<ACE_SYNCH_NULL_MUTEX> (),
00337 0);
00338 return the_lock;
00339 }
|
|
|
Return the set of default policies.
Definition at line 23 of file Object_Adapter.inl. References default_poa_policies_.
00024 {
00025 return this->default_poa_policies_;
00026 }
|
|
||||||||||||||||
|
Implements TAO_Adapter. Definition at line 714 of file Object_Adapter.cpp. References TAO_ServerRequest::caught_exception(), dispatch_servant(), TAO_ServerRequest::forward_location(), TAO::unbounded_value_sequence< T >::get_buffer(), CORBA::is_nil(), TAO::unbounded_value_sequence< T >::length(), ACE_OS::memcmp(), TAO::ServerRequestInterceptor_Adapter::receive_request_service_contexts(), TAO_ServerRequest::reply_status(), TAO_ServerRequest::send_cached_reply(), TAO::ServerRequestInterceptor_Adapter::send_exception(), TAO::ServerRequestInterceptor_Adapter::send_other(), and TAO_ORB_Core::serverrequestinterceptor_adapter().
00717 {
00718 if (key.length() < TAO_Root_POA::TAO_OBJECTKEY_PREFIX_SIZE
00719 || ACE_OS::memcmp (key.get_buffer (),
00720 &TAO_Root_POA::objectkey_prefix[0],
00721 TAO_Root_POA::TAO_OBJECTKEY_PREFIX_SIZE) != 0)
00722 {
00723 return TAO_Adapter::DS_MISMATCHED_KEY;
00724 }
00725
00726 int result = 0;
00727
00728 #if TAO_HAS_INTERCEPTORS == 1
00729 TAO::ServerRequestInterceptor_Adapter *sri_adapter =
00730 orb_core_.serverrequestinterceptor_adapter ();
00731
00732 try
00733 {
00734 if (sri_adapter != 0)
00735 {
00736 #if TAO_HAS_EXTENDED_FT_INTERCEPTORS == 1
00737 CORBA::OctetSeq_var ocs;
00738 sri_adapter->tao_ft_interception_point (request,
00739 0, // args
00740 0, // nargs
00741 0, // servant_upcall
00742 0, // exceptions
00743 0, // nexceptions
00744 ocs.out ());
00745
00746 /// If we have a cached result, just go ahead and send the reply
00747 /// and let us return
00748 if (ocs.ptr () != 0)
00749 {
00750 // request.result_seq (
00751 request.send_cached_reply (ocs.inout ());
00752
00753 return TAO_Adapter::DS_OK;
00754 }
00755
00756 // If a PortableInterceptor::ForwardRequest exception was
00757 // thrown, then set the forward_to object reference and return
00758 // with the appropriate return status.
00759 forward_to.ptr () = request.forward_location ();
00760 if (!CORBA::is_nil (request.forward_location ()))
00761 {
00762 return TAO_Adapter::DS_FORWARD;
00763 }
00764 #endif /*TAO_HAS_EXTENDED_FT_INTERCEPTORS*/
00765
00766 // The receive_request_service_contexts() interception point
00767 // must be invoked before the operation is dispatched to the
00768 // servant.
00769 sri_adapter->receive_request_service_contexts (request,
00770 0, // args
00771 0, // nargs
00772 0, // servant_upcall
00773 0, // exceptions
00774 0); // nexceptions
00775
00776 // If a PortableInterceptor::ForwardRequest exception was
00777 // thrown, then set the forward_to object reference and return
00778 // with the appropriate return status.
00779 forward_to.ptr () = request.forward_location ();
00780 if (!CORBA::is_nil (request.forward_location ()))
00781 {
00782 return TAO_Adapter::DS_FORWARD;
00783 }
00784 }
00785 #endif /* TAO_HAS_INTERCEPTORS == 1 */
00786
00787 result = this->dispatch_servant (key, request, forward_to);
00788
00789 #if TAO_HAS_INTERCEPTORS == 1
00790
00791 if (result == TAO_Adapter::DS_FORWARD)
00792 {
00793 request.forward_location (forward_to.ptr ());
00794 if (sri_adapter != 0)
00795 {
00796 sri_adapter->send_other (request,
00797 0, // args
00798 0, // nargs
00799 0, // servant_upcall
00800 0, // exceptions
00801 0 // nexceptions
00802 );
00803 }
00804 }
00805 }
00806 catch ( ::CORBA::Exception& ex)
00807 {
00808 // Just assume the current exception is a system exception, the
00809 // status can only change when the interceptor changes this
00810 // and this is only done when the sri_adapter is available. If we
00811 // don't have an sri_adapter we just rethrow the exception
00812 PortableInterceptor::ReplyStatus status =
00813 PortableInterceptor::SYSTEM_EXCEPTION;
00814
00815 if (sri_adapter != 0)
00816 {
00817 request.caught_exception (&ex);
00818
00819 sri_adapter->send_exception (request,
00820 0, // args
00821 0, // nargs
00822 0, // servant_upcall
00823 0, // exceptions
00824 0); // nexceptions
00825
00826 status = request.reply_status ();
00827 }
00828
00829 // Only re-throw the exception if it hasn't been transformed by
00830 // the send_exception() interception point (e.g. to a
00831 // LOCATION_FORWARD).
00832 if (status == PortableInterceptor::SYSTEM_EXCEPTION
00833 || status == PortableInterceptor::USER_EXCEPTION)
00834 {
00835 throw;
00836 }
00837 }
00838 #endif /* TAO_HAS_INTERCEPTORS == 1 */
00839
00840 return result;
00841 }
|
|
||||||||||||||||
|
Definition at line 342 of file Object_Adapter.cpp. References CORBA::Object::_duplicate(), ACE_FUNCTION_TIMEPROBE, TAO_ServerRequest::collocated(), do_dispatch(), TAO_ServerRequest::forward_location(), TAO_ServerRequest::operation(), TAO::Portable_Server::Servant_Upcall::pre_invoke_collocated_request(), TAO::Portable_Server::Servant_Upcall::pre_invoke_remote_request(), TAO::Portable_Server::Servant_Upcall::prepare_for_upcall(), and TAO_ServerRequest::reply_status(). Referenced by dispatch().
00345 {
00346 ACE_FUNCTION_TIMEPROBE (TAO_OBJECT_ADAPTER_DISPATCH_SERVANT_START);
00347
00348 // This object is magical, i.e., it has a non-trivial constructor
00349 // and destructor.
00350 TAO::Portable_Server::Servant_Upcall servant_upcall (&this->orb_core_);
00351
00352 // Set up state in the POA et al (including the POA Current), so
00353 // that we know that this servant is currently in an upcall.
00354 const char *operation = req.operation ();
00355 int result = servant_upcall.prepare_for_upcall (key, operation, forward_to);
00356
00357 if (result != TAO_Adapter::DS_OK)
00358 return result;
00359
00360 // Preprocess request.
00361 if (req.collocated ())
00362 {
00363 servant_upcall.pre_invoke_collocated_request ();
00364 }
00365 else
00366 {
00367 servant_upcall.pre_invoke_remote_request (req);
00368 }
00369
00370 // Servant dispatch.
00371 {
00372 ACE_FUNCTION_TIMEPROBE (TAO_SERVANT_DISPATCH_START);
00373
00374 do_dispatch (req, servant_upcall);
00375 }
00376
00377 #if TAO_HAS_INTERCEPTORS == 1
00378 // ServerInterceptor might have raised ForwardRequest. In case of
00379 // remote calls invocations the LocationForwardReply would have been
00380 // sent in earlier stage, but in colocal scenario no message is sent
00381 // and the LocationForward object must be passed over here to
00382 // calling operation's mem-space.
00383 if (req.collocated() && req.reply_status () == PortableInterceptor::LOCATION_FORWARD)
00384 {
00385 forward_to = CORBA::Object::_duplicate (req.forward_location ());
00386 result = TAO_Adapter::DS_FORWARD;
00387 }
00388 #endif
00389
00390 return result;
00391 }
|
|
||||||||||||||||
|
|
|
||||||||||||
|
Definition at line 1215 of file Object_Adapter.cpp. References TAO::Portable_Server::Servant_Upcall::servant(). Referenced by dispatch_servant().
01217 {
01218 upcall.servant ()->_dispatch(req, &upcall);
01219 }
|
|
|
Definition at line 17 of file Object_Adapter.inl. References enable_locking_. Referenced by TAO::Portable_Server::ServantRetentionStrategyRetain::is_servant_in_map(), and TAO::Portable_Server::ServantRetentionStrategyRetain::is_user_id_in_map().
00018 {
00019 return this->enable_locking_;
00020 }
|
|
||||||||||||
|
Definition at line 73 of file Object_Adapter.inl. References TAO_Object_Adapter::Hint_Strategy::find_persistent_poa(), hint_strategy_, and poa_name. Referenced by find_poa().
00075 {
00076 return this->hint_strategy_->find_persistent_poa (system_name, poa);
00077 }
|
|
||||||||||||||||||||||||
|
Definition at line 80 of file Object_Adapter.inl. References find_persistent_poa(), find_transient_poa(), and poa_name. Referenced by locate_poa().
00085 {
00086 if (activate_it)
00087 {
00088 return this->find_persistent_poa (system_name, poa);
00089 }
00090 else
00091 {
00092 return this->find_transient_poa (system_name,
00093 root,
00094 poa_creation_time,
00095 poa);
00096 }
00097 }
|
|
||||||||||||
|
Definition at line 63 of file Object_Adapter.inl. References find_servant_i(), TAO_OBJECT_ADAPTER_GUARD_RETURN, and TAO_SERVANT_NOT_FOUND. Referenced by get_collocated_servant().
00065 {
00066 // Lock access for the duration of this transaction.
00067 TAO_OBJECT_ADAPTER_GUARD_RETURN (TAO_SERVANT_NOT_FOUND);
00068
00069 return this->find_servant_i (key, servant);
00070 }
|
|
||||||||||||
|
Definition at line 557 of file Object_Adapter.cpp. References locate_poa(), and TAO_Root_POA::locate_servant_i(). Referenced by find_servant().
00559 {
00560 PortableServer::ObjectId id;
00561 TAO_Root_POA *poa = 0;
00562
00563 this->locate_poa (key, id, poa);
00564
00565 return poa->locate_servant_i (id, servant);
00566 }
|
|
||||||||||||||||||||
|
Definition at line 482 of file Object_Adapter.cpp. References ACE_Map< poa_name, TAO_Root_POA * >::find(), poa_name, transient_poa_map_, and TAO_Root_POA::validate_lifespan(). Referenced by find_poa().
00486 {
00487 int result = 0;
00488
00489 if (root)
00490 {
00491 poa = this->root_;
00492 }
00493 else
00494 {
00495 result = this->transient_poa_map_->find (system_name, poa);
00496 }
00497
00498 if (poa == 0
00499 || (result == 0 && !poa->validate_lifespan (false, poa_creation_time)))
00500 result = -1;
00501
00502 return result;
00503 }
|
|
|
Helper method to get collocated servant.
Definition at line 918 of file Object_Adapter.cpp. References TAO_Profile::_key(), find_servant(), TAO_MProfile::get_profile(), ACE_OS::memcmp(), TAO_MProfile::profile_count(), and TAO_PHandle. Referenced by create_collocated_object(), and initialize_collocated_object().
00919 {
00920 for (TAO_PHandle j = 0;
00921 j != mp.profile_count ();
00922 ++j)
00923 {
00924 const TAO_Profile *profile = mp.get_profile (j);
00925 TAO::ObjectKey_var objkey = profile->_key ();
00926
00927 if (objkey->length() < TAO_Root_POA::TAO_OBJECTKEY_PREFIX_SIZE
00928 || ACE_OS::memcmp (objkey->get_buffer (),
00929 &TAO_Root_POA::objectkey_prefix[0],
00930 TAO_Root_POA::TAO_OBJECTKEY_PREFIX_SIZE) != 0)
00931 continue;
00932
00933 TAO_ServantBase *servant = 0;
00934
00935 try
00936 {
00937 this->find_servant (objkey.in (), servant);
00938 }
00939 catch (const ::CORBA::Exception&)
00940 {
00941 }
00942
00943 return servant;
00944 }
00945
00946 return 0;
00947 }
|
|
|
Initialize the default set of POA policies.
Definition at line 245 of file Object_Adapter.cpp. References TAO_POA_Policy_Set::merge_policy(). Referenced by open().
00246 {
00247 // Initialize the default policies.
00248 #if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO)
00249
00250 TAO::Portable_Server::ThreadPolicy thread_policy (PortableServer::ORB_CTRL_MODEL);
00251 policies.merge_policy (&thread_policy);
00252
00253 #endif /* TAO_HAS_MINIMUM_POA == 0 */
00254
00255 #if !defined (CORBA_E_MICRO)
00256 // Lifespan policy.
00257 TAO::Portable_Server::LifespanPolicy lifespan_policy (PortableServer::TRANSIENT);
00258 policies.merge_policy (&lifespan_policy);
00259 #endif
00260
00261 #if !defined (CORBA_E_MICRO)
00262 // ID uniqueness policy.
00263 TAO::Portable_Server::IdUniquenessPolicy id_uniqueness_policy (PortableServer::UNIQUE_ID);
00264 policies.merge_policy (&id_uniqueness_policy);
00265 #endif
00266
00267 #if !defined (CORBA_E_MICRO)
00268 // ID assignment policy.
00269 TAO::Portable_Server::IdAssignmentPolicy id_assignment_policy (PortableServer::SYSTEM_ID);
00270 policies.merge_policy (&id_assignment_policy);
00271 #endif
00272
00273 #if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO)
00274 // Implicit activation policy.
00275 TAO::Portable_Server::ImplicitActivationPolicy implicit_activation_policy
00276 (PortableServer::NO_IMPLICIT_ACTIVATION);
00277 policies.merge_policy (&implicit_activation_policy);
00278
00279 // Servant retention policy.
00280 TAO::Portable_Server::ServantRetentionPolicy servant_retention_policy
00281 (PortableServer::RETAIN);
00282 policies.merge_policy (&servant_retention_policy);
00283
00284 // Request processing policy.
00285 TAO::Portable_Server::RequestProcessingPolicy request_processing_policy
00286 (PortableServer::USE_ACTIVE_OBJECT_MAP_ONLY);
00287 policies.merge_policy (&request_processing_policy);
00288 #endif /* TAO_HAS_MINIMUM_POA == 0 */
00289 #if defined (CORBA_E_MICRO)
00290 ACE_UNUSED_ARG (policies);
00291 #endif
00292 }
|
|
|
Implements TAO_Adapter. Definition at line 880 of file Object_Adapter.cpp. References TAO_Stub::base_profiles(), TAO_Stub::collocated_servant(), TAO_Stub::forward_profiles(), get_collocated_servant(), TAO_Stub::is_collocated(), and TAO_Stub::servant_orb().
00881 {
00882 // If we have been forwarded: use the forwarded profiles
00883 const TAO_MProfile &mp = stub->forward_profiles () ? *(stub->forward_profiles ())
00884 : stub->base_profiles ();
00885
00886 TAO_ServantBase *sb = this->get_collocated_servant (mp);
00887
00888 // Set the servant ORB. Do not duplicate the ORB here since
00889 // TAO_Stub::servant_orb() duplicates it.
00890 stub->servant_orb (this->orb_core_.orb ());
00891
00892 // It is ok to set the object as a collocated object even when
00893 // <sb> is zero.
00894 stub->collocated_servant (sb);
00895
00896 // Mark the stub as collocated. This will set the strategized object
00897 // proxy broker if required.
00898 stub->is_collocated (true);
00899
00900 // Return 0 (success) iff we found a servant.
00901 return ! sb;
00902 }
|
|
||||||||||||||||
|
Definition at line 394 of file Object_Adapter.cpp. References ACE_FUNCTION_TIMEPROBE, find_poa(), TAO_Root_POA::parse_key(), and poa_name. Referenced by find_servant_i(), locate_servant_i(), TAO::Portable_Server::Servant_Upcall::lookup_POA(), and TAO::Portable_Server::Servant_Upcall::prepare_for_upcall_i().
00397 {
00398 TAO_Object_Adapter::poa_name poa_system_name;
00399 CORBA::Boolean is_root = false;
00400 CORBA::Boolean is_persistent = false;
00401 CORBA::Boolean is_system_id = false;
00402 TAO::Portable_Server::Temporary_Creation_Time poa_creation_time;
00403
00404 int result = 0;
00405
00406 {
00407 ACE_FUNCTION_TIMEPROBE (TAO_POA_PARSE_KEY_START);
00408
00409 result = TAO_Root_POA::parse_key (key,
00410 poa_system_name,
00411 system_id,
00412 is_root,
00413 is_persistent,
00414 is_system_id,
00415 poa_creation_time);
00416 }
00417
00418 if (result != 0)
00419 throw ::CORBA::OBJ_ADAPTER ();
00420
00421 {
00422 ACE_FUNCTION_TIMEPROBE (TAO_OBJECT_ADAPTER_FIND_POA_START);
00423
00424 result = this->find_poa (poa_system_name,
00425 is_persistent,
00426 is_root,
00427 poa_creation_time,
00428 poa);
00429 }
00430
00431 if (result != 0)
00432 throw ::CORBA::OBJECT_NOT_EXIST (CORBA::OMGVMCID | 2, CORBA::COMPLETED_NO);
00433 }
|
|
|
Definition at line 54 of file Object_Adapter.inl. References locate_servant_i(), and TAO_OBJECT_ADAPTER_GUARD_RETURN.
00055 {
00056 // Lock access for the duration of this transaction.
00057 TAO_OBJECT_ADAPTER_GUARD_RETURN (-1);
00058
00059 return this->locate_servant_i (key);
00060 }
|
|
|
Definition at line 528 of file Object_Adapter.cpp. References ACE_FUNCTION_TIMEPROBE, locate_poa(), TAO_Root_POA::locate_servant_i(), TAO_DEFAULT_SERVANT, TAO_SERVANT_FOUND, TAO_SERVANT_LOCATION, TAO_SERVANT_MANAGER, and TAO_SERVANT_NOT_FOUND. Referenced by locate_servant().
00529 {
00530 ACE_FUNCTION_TIMEPROBE (TAO_POA_LOCATE_SERVANT_START);
00531
00532 PortableServer::ObjectId id;
00533 TAO_Root_POA *poa = 0;
00534
00535 this->locate_poa (key, id, poa);
00536
00537 PortableServer::Servant servant = 0;
00538 TAO_SERVANT_LOCATION servant_location =
00539 poa->locate_servant_i (id, servant);
00540
00541 switch (servant_location)
00542 {
00543 case TAO_SERVANT_FOUND:
00544 // Optimistic attitude
00545 case TAO_DEFAULT_SERVANT:
00546 case TAO_SERVANT_MANAGER:
00547 return 0;
00548
00549 case TAO_SERVANT_NOT_FOUND:
00550 return -1;
00551 }
00552
00553 return -1;
00554 }
|
|
|
Definition at line 29 of file Object_Adapter.inl. Referenced by TAO::Portable_Server::RequestProcessingStrategyServantLocator::locate_servant(), TAO::Portable_Server::Servant_Upcall::lookup_POA(), TAO::Portable_Server::Non_Servant_Upcall::Non_Servant_Upcall(), open(), TAO::Portable_Server::Servant_Upcall::prepare_for_upcall_i(), TAO::Portable_Server::Servant_Upcall::upcall_cleanup(), and TAO::Portable_Server::Non_Servant_Upcall::~Non_Servant_Upcall().
00030 {
00031 return *this->lock_;
00032 }
|
|
|
Implements TAO_Adapter. Definition at line 844 of file Object_Adapter.cpp. References TAO_OBJID_ROOTPOA.
00845 {
00846 return TAO_OBJID_ROOTPOA;
00847 }
|
|
|
Pointer to the non-servant upcall in progress. If no non-servant upcall is in progress, this pointer is zero. Definition at line 153 of file Object_Adapter.inl. References non_servant_upcall_in_progress_. Referenced by TAO_Root_POA::destroy_i().
00154 {
00155 return this->non_servant_upcall_in_progress_;
00156 }
|
|
|
Implements TAO_Adapter. Definition at line 569 of file Object_Adapter.cpp. References TAO_Local_RefCounted_Object::_add_ref(), ACE_NEW, ACE_NEW_THROW_EX, TAO_POAManager_Factory::create_POAManager(), TAO_Servant_Dispatcher::create_Root_POA(), TAO_Root_POA::establish_components(), init_default_policies(), lock(), TAO_Policy_Validator::merge_policies(), TAO_POA_Policy_Set::merge_policy(), TAO_Thread_Lane_Resources_Manager::open_default_resources(), poa_manager_factory_, PortableServer::POAManager_ptr, PortableServer::POAManager_var, TAO_POA_Policy_Set::policies(), servant_dispatcher_, TAO_Root_POA::String, TAO_DEFAULT_ROOTPOA_NAME, TAO_DEFAULT_ROOTPOAMANAGER_NAME, TAO_ORB_Core::thread_lane_resources_manager(), thread_lock(), TAO_POA_Policy_Set::validate_policies(), and validator().
00570 {
00571 // Add in the default POA policies to the default list.
00572 this->init_default_policies (this->default_poa_policies ());
00573
00574 // If a POA extension hasn't changed the servant dispatcher, initialize the
00575 // default one.
00576 if (this->servant_dispatcher_ == 0)
00577 {
00578 ACE_NEW (this->servant_dispatcher_,
00579 TAO_Default_Servant_Dispatcher);
00580 }
00581
00582 #if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO)
00583 ACE_NEW_THROW_EX (this->poa_manager_factory_,
00584 TAO_POAManager_Factory (*this),
00585 CORBA::NO_MEMORY ());
00586
00587 ::CORBA::PolicyList policy;
00588 PortableServer::POAManager_var poa_manager
00589 = poa_manager_factory_->create_POAManager (TAO_DEFAULT_ROOTPOAMANAGER_NAME,
00590 policy);
00591 #else
00592 PortableServer::POAManager_ptr poa_manager_ptr;
00593 ::CORBA::PolicyList policy_list;
00594 ACE_NEW_THROW_EX (poa_manager_ptr,
00595 TAO_POA_Manager (*this, TAO_DEFAULT_ROOTPOAMANAGER_NAME),
00596 CORBA::NO_MEMORY
00597 (CORBA::SystemException::_tao_minor_code (0, ENOMEM),
00598 CORBA::COMPLETED_NO));
00599
00600 PortableServer::POAManager_var poa_manager = poa_manager_ptr;
00601 // Keep reference of POAManager in TAO_Object_Adapter so the POAManager
00602 // object is destructed after RootPOA is destructed.
00603 the_poa_manager_ = poa_manager;
00604
00605 #endif
00606
00607 // This makes sure that the default resources are open when the Root
00608 // POA is created.
00609 this->orb_core_.thread_lane_resources_manager ().open_default_resources ();
00610
00611 TAO_POA_Policy_Set policies (this->default_poa_policies ());
00612
00613 #if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO)
00614 // Specify the implicit activation policy since it should
00615 // be different from the default. Note that merge_policy
00616 // takes a const reference and makes its own copy of the
00617 // policy. (Otherwise, we'd have to allocate the policy
00618 // on the heap.)
00619 // Implicit activation policy.
00620 TAO::Portable_Server::ImplicitActivationPolicy implicit_activation_policy
00621 (PortableServer::IMPLICIT_ACTIVATION);
00622 policies.merge_policy (&implicit_activation_policy);
00623 #endif /* TAO_HAS_MINIMUM_POA == 0 */
00624
00625 // Merge policies from the ORB level.
00626 this->validator ().merge_policies (policies.policies ());
00627
00628 // If any of the policy objects specified are not valid for the ORB
00629 // implementation, if conflicting policy objects are specified, or
00630 // if any of the specified policy objects require prior
00631 // administrative action that has not been performed, an
00632 // InvalidPolicy exception is raised containing the index in the
00633 // policies parameter value of the first offending policy object.
00634 policies.validate_policies (this->validator (), this->orb_core_);
00635
00636 // Construct a new POA
00637 TAO_Root_POA::String root_poa_name (TAO_DEFAULT_ROOTPOA_NAME);
00638 this->root_ =
00639 this->servant_dispatcher_->create_Root_POA (root_poa_name,
00640 poa_manager.in (),
00641 policies,
00642 this->lock (),
00643 this->thread_lock (),
00644 this->orb_core_,
00645 this);
00646
00647 // The Object_Adapter will keep a reference to the Root POA so that
00648 // on its destruction, it can check whether the Root POA has been
00649 // destroyed yet or not.
00650 this->root_->_add_ref ();
00651
00652 // Lock access for the duration of this transaction.
00653 TAO::Portable_Server::POA_Guard poa_guard (*this->root_);
00654
00655 // Iterate over the registered IOR interceptors so that they may be
00656 // given the opportunity to add tagged components to the profiles
00657 // for this servant.
00658 this->root_->establish_components ();
00659 }
|
|
|
Access to ORB Core.
Definition at line 147 of file Object_Adapter.inl. Referenced by TAO_POA_Manager::adapter_manager_state_changed(), and TAO_POAManager_Factory::create_POAManager().
00148 {
00149 return this->orb_core_;
00150 }
|
|
|
Implements TAO_Adapter. Definition at line 708 of file Object_Adapter.cpp.
00709 {
00710 return 0;
00711 }
|
|
|
Definition at line 906 of file Object_Adapter.cpp. References TAO_POAManager_Factory::remove_all_poamanagers(). Referenced by close(), and ~TAO_Object_Adapter().
00908 {
00909 if (factory != 0)
00910 {
00911 factory->remove_all_poamanagers ();
00912 ::CORBA::release (factory);
00913 }
00914 }
|
|
|
Definition at line 41 of file Object_Adapter.inl.
00042 {
00043 return this->reverse_lock_;
00044 }
|
|
|
Implements TAO_Adapter. Definition at line 850 of file Object_Adapter.cpp. References CORBA::Object::_duplicate().
00851 {
00852 return CORBA::Object::_duplicate (this->root_);
00853 }
|
|
|
Access the root poa.
Definition at line 141 of file Object_Adapter.inl.
00142 {
00143 return this->root_;
00144 }
|
|
|
Set the servant dispatcher method. Ownership is transferred to this Object Adapter. Note: This should only be called at initialization. Definition at line 1206 of file Object_Adapter.cpp. References servant_dispatcher_.
01207 {
01208 if (this->servant_dispatcher_)
01209 delete this->servant_dispatcher_;
01210
01211 this->servant_dispatcher_ = dispatcher;
01212 }
|
|
|
Definition at line 117 of file Object_Adapter.cpp. References TAO_Server_Strategy_Factory::Active_Object_Map_Creation_Parameters::poa_lookup_strategy_for_transient_id_policy_, ACE_Active_Map_Manager_Key::size(), TAO_ACTIVE_DEMUX, TAO_DYNAMIC_HASH, TAO_LINEAR, and transient_poa_name_size_. Referenced by TAO_Object_Adapter().
00118 {
00119 if (TAO_Object_Adapter::transient_poa_name_size_ == 0)
00120 {
00121 switch (creation_parameters.poa_lookup_strategy_for_transient_id_policy_)
00122 {
00123 #if (TAO_HAS_MINIMUM_POA_MAPS == 0)
00124 case TAO_LINEAR:
00125 TAO_Object_Adapter::transient_poa_name_size_ =
00126 sizeof (CORBA::ULong);
00127 break;
00128 case TAO_DYNAMIC_HASH:
00129 TAO_Object_Adapter::transient_poa_name_size_ =
00130 sizeof (CORBA::ULong);
00131 break;
00132 #endif /* TAO_HAS_MINIMUM_POA_MAPS == 0 */
00133 case TAO_ACTIVE_DEMUX:
00134 default:
00135 TAO_Object_Adapter::transient_poa_name_size_ =
00136 static_cast <CORBA::ULong>(
00137 ACE_Active_Map_Manager_Key::size ());
00138 break;
00139 }
00140 }
00141 }
|
|
|
Definition at line 35 of file Object_Adapter.inl. References thread_lock_. Referenced by TAO_Root_POA::create_POA_i(), and open().
00036 {
00037 return this->thread_lock_;
00038 }
|
|
|
Definition at line 48 of file Object_Adapter.inl. References transient_poa_name_size_. Referenced by TAO_Root_POA::parse_key().
00049 {
00050 return TAO_Object_Adapter::transient_poa_name_size_;
00051 }
|
|
||||||||||||
|
Definition at line 133 of file Object_Adapter.inl. References hint_strategy_, poa_name, and TAO_Object_Adapter::Hint_Strategy::unbind_persistent_poa(). Referenced by unbind_poa().
00135 {
00136 return this->hint_strategy_->unbind_persistent_poa (folded_name,
00137 system_name);
00138 }
|
|
||||||||||||||||
|
Definition at line 517 of file Object_Adapter.cpp. References TAO_Root_POA::persistent(), poa_name, unbind_persistent_poa(), and unbind_transient_poa(). Referenced by TAO_Root_POA::complete_destruction_i(), and TAO_Root_POA::TAO_Root_POA().
00520 {
00521 if (poa->persistent ())
00522 return this->unbind_persistent_poa (folded_name, system_name);
00523 else
00524 return this->unbind_transient_poa (system_name);
00525 }
|
|
|
Definition at line 127 of file Object_Adapter.inl. References poa_name, transient_poa_map_, and ACE_Map< poa_name, TAO_Root_POA * >::unbind(). Referenced by unbind_poa().
00128 {
00129 return this->transient_poa_map_->unbind (system_name);
00130 }
|
|
|
Return the validator.
Definition at line 11 of file Object_Adapter.inl. References default_validator_. Referenced by TAO_Root_POA::create_POA_i(), TAO_POAManager_Factory::create_POAManager(), and open().
00012 {
00013 return this->default_validator_;
00014 }
|
|
|
Wait for non-servant upcalls to complete.
Definition at line 1172 of file Object_Adapter.cpp. References enable_locking_, non_servant_upcall_condition_, non_servant_upcall_in_progress_, and ACE_OS::thr_equal(). Referenced by TAO::Portable_Server::Servant_Upcall::lookup_POA(), TAO::Portable_Server::POA_Guard::POA_Guard(), TAO::Portable_Server::Servant_Upcall::prepare_for_upcall_i(), and wait_for_non_servant_upcalls_to_complete_no_throw().
01173 {
01174 // Check if a non-servant upcall is in progress. If a non-servant
01175 // upcall is in progress, wait for it to complete. Unless of
01176 // course, the thread making the non-servant upcall is this thread.
01177 while (this->enable_locking_ &&
01178 this->non_servant_upcall_in_progress_ &&
01179 ! ACE_OS::thr_equal (this->non_servant_upcall_thread_,
01180 ACE_OS::thr_self ()))
01181 {
01182 // If so wait...
01183 int const result = this->non_servant_upcall_condition_.wait ();
01184 if (result == -1)
01185 throw ::CORBA::OBJ_ADAPTER ();
01186 }
01187 }
|
|
|
Non-exception throwing version.
Definition at line 1190 of file Object_Adapter.cpp. References ACE_ERROR, LM_ERROR, and wait_for_non_servant_upcalls_to_complete(). Referenced by TAO::Portable_Server::Servant_Upcall::upcall_cleanup().
01191 {
01192 // Non-exception throwing version.
01193 try
01194 {
01195 this->wait_for_non_servant_upcalls_to_complete ();
01196 }
01197 catch (const ::CORBA::Exception&)
01198 {
01199 ACE_ERROR ((LM_ERROR,
01200 "TAO_Object_Adapter::wait_for_non_servant_upcalls_to_complete "
01201 "threw exception it should not have!\n"));
01202 }
01203 }
|
|
|
Definition at line 299 of file Object_Adapter.h. |
|
|
Definition at line 329 of file Object_Adapter.h. |
|
|
Definition at line 465 of file Object_Adapter.h. |
|
|
Definition at line 467 of file Object_Adapter.h. |
|
|
Definition at line 79 of file Object_Adapter.h. |
|
|
Save a list of default policies that should be included in every POA (unless overridden). Definition at line 515 of file Object_Adapter.h. Referenced by default_poa_policies(). |
|
|
The default validator and the beginning of the chain of policy validators. Definition at line 511 of file Object_Adapter.h. Referenced by validator(). |
|
|
Definition at line 402 of file Object_Adapter.h. Referenced by enable_locking(), TAO::Portable_Server::Servant_Upcall::poa_cleanup(), TAO::Portable_Server::Servant_Upcall::servant_cleanup(), TAO_Root_POA::wait_for_completions(), wait_for_non_servant_upcalls_to_complete(), and TAO::Portable_Server::Non_Servant_Upcall::~Non_Servant_Upcall(). |
|
|
Definition at line 333 of file Object_Adapter.h. Referenced by bind_persistent_poa(), find_persistent_poa(), TAO_Object_Adapter(), unbind_persistent_poa(), and ~TAO_Object_Adapter(). |
|
|
Definition at line 406 of file Object_Adapter.h. |
|
|
Condition variable for waiting on non-servant upcalls to end.
Definition at line 486 of file Object_Adapter.h. Referenced by wait_for_non_servant_upcalls_to_complete(), and TAO::Portable_Server::Non_Servant_Upcall::~Non_Servant_Upcall(). |
|
|
Pointer to the non-servant upcall in progress. If no non-servant upcall is in progress, this pointer is zero. Definition at line 490 of file Object_Adapter.h. Referenced by TAO::Portable_Server::Non_Servant_Upcall::Non_Servant_Upcall(), non_servant_upcall_in_progress(), wait_for_non_servant_upcalls_to_complete(), and TAO::Portable_Server::Non_Servant_Upcall::~Non_Servant_Upcall(). |
|
|
Current nesting level of non_servant_upcalls.
Definition at line 493 of file Object_Adapter.h. Referenced by TAO::Portable_Server::Non_Servant_Upcall::Non_Servant_Upcall(), and TAO::Portable_Server::Non_Servant_Upcall::~Non_Servant_Upcall(). |
|
|
Id of thread making the non-servant upcall.
Definition at line 496 of file Object_Adapter.h. Referenced by TAO::Portable_Server::Non_Servant_Upcall::Non_Servant_Upcall(), and TAO::Portable_Server::Non_Servant_Upcall::~Non_Servant_Upcall(). |
|
|
Definition at line 400 of file Object_Adapter.h. |
|
|
Persistent POA map.
Definition at line 389 of file Object_Adapter.h. Referenced by TAO_Object_Adapter::No_Hint_Strategy::bind_persistent_poa(), TAO_Object_Adapter::Active_Hint_Strategy::bind_persistent_poa(), TAO_Object_Adapter::No_Hint_Strategy::find_persistent_poa(), TAO_Object_Adapter::Active_Hint_Strategy::find_persistent_poa(), TAO_Object_Adapter(), TAO_Object_Adapter::No_Hint_Strategy::unbind_persistent_poa(), TAO_Object_Adapter::Active_Hint_Strategy::unbind_persistent_poa(), and ~TAO_Object_Adapter(). |
|
|
The POAManager factory.
Definition at line 503 of file Object_Adapter.h. |
|
|
Definition at line 408 of file Object_Adapter.h. |
|
|
The Root POA.
Definition at line 499 of file Object_Adapter.h. |
|
|
Strategy for dispatching a request to a servant.
Definition at line 386 of file Object_Adapter.h. Referenced by open(), TAO::Portable_Server::Servant_Upcall::post_invoke(), TAO::Portable_Server::Servant_Upcall::pre_invoke_collocated_request(), TAO::Portable_Server::Servant_Upcall::pre_invoke_remote_request(), servant_dispatcher(), and ~TAO_Object_Adapter(). |
|
|
Definition at line 404 of file Object_Adapter.h. Referenced by thread_lock(). |
|
|
Transient POA map.
Definition at line 392 of file Object_Adapter.h. Referenced by bind_transient_poa(), find_transient_poa(), TAO_Object_Adapter(), unbind_transient_poa(), and ~TAO_Object_Adapter(). |
|
|
Definition at line 114 of file Object_Adapter.cpp. Referenced by set_transient_poa_name_size(), and transient_poa_name_size(). |
1.3.6