TAO_ORB_Core Class Reference

Encapsulates the state of an ORB. More...

#include <ORB_Core.h>

Collaboration diagram for TAO_ORB_Core:

[legend]List of all members.

Collocation Strategies
enum	{ ORB_CONTROL, THRU_POA, DIRECT }
TAO::Collocation_Strategy	collocation_strategy (CORBA::Object_ptr object)
Public Types
typedef void(*	Timeout_Hook )(TAO_ORB_Core *, TAO_Stub *, bool &, ACE_Time_Value &)
	Define the Timeout_Hook signature.
typedef void(*	Sync_Scope_Hook )(TAO_ORB_Core *, TAO_Stub *, bool &, Messaging::SyncScope &)
typedef ACE_Array_Map< ACE_CString, ACE_CString >	InitRefMap
Public Member Functions
	TAO_ORB_Core (const char *id)
	Constructor.
TAO_ORB_Parameters *	orb_params (void)
	Accessor for the ORB parameters.
TAO_Connector_Registry *	connector_registry ()
	Get the connector registry.
TAO_Parser_Registry *	parser_registry (void)
	Get the IOR parser registry.
TAO::PolicyFactory_Registry_Adapter *	policy_factory_registry (void)
TAO::ORBInitializer_Registry_Adapter *	orbinitializer_registry (void)
TAO_ProtocolFactorySet *	protocol_factories (void)
	Get the protocol factories.
CORBA::ORB_ptr	orb (void)
	Get pointer to the ORB.
ACE_Reactor *	reactor (void)
	Wrappers that forward the request to the concurrency strategy.
ACE_Thread_Manager *	thr_mgr (void)
	Get the ACE_Thread_Manager.
CORBA::Object_ptr	root_poa ()
	Return the RootPOA, or try to load it if not initialized already.
TAO_Adapter_Registry *	adapter_registry (void)
	Get the adapter registry.
TAO_Adapter *	poa_adapter (void)
TAO_Protocols_Hooks *	get_protocols_hooks (void)
	Gets the value of TAO_ORB_Core::protocols_hooks__.
int	is_collocated (const TAO_MProfile &mprofile)
ACE_Allocator *	output_cdr_dblock_allocator (void)
ACE_Allocator *	output_cdr_buffer_allocator (void)
ACE_Allocator *	output_cdr_msgblock_allocator (void)
ACE_Allocator *	input_cdr_dblock_allocator (void)
ACE_Allocator *	input_cdr_buffer_allocator (void)
ACE_Allocator *	input_cdr_msgblock_allocator (void)
ACE_Allocator *	transport_message_buffer_allocator (void)
ACE_Data_Block *	create_input_cdr_data_block (size_t size)
ACE_Lock *	locking_strategy (void)
	Return the locking strategy used for the data blocks.
TAO_Policy_Set *	get_default_policies (void)
	Accessor method for the default_policies_.
CORBA::Policy_ptr	get_policy (CORBA::PolicyType type)
CORBA::Policy_ptr	get_policy_including_current (CORBA::PolicyType type)
CORBA::Policy_ptr	get_cached_policy (TAO_Cached_Policy_Type type)
CORBA::Policy_ptr	get_cached_policy_including_current (TAO_Cached_Policy_Type type)
TAO_Policy_Manager *	policy_manager (void)
	Return the Policy_Manager for this ORB.
TAO_Policy_Current &	policy_current (void)
void	call_timeout_hook (TAO_Stub *stub, bool &has_timeout, ACE_Time_Value &time_value)
	Invoke the timeout hook if present.
void	connection_timeout (TAO_Stub *stub, bool &has_timeout, ACE_Time_Value &time_value)
	Invoke the timeout hook if present.
void	call_sync_scope_hook (TAO_Stub *stub, bool &has_synchronization, Messaging::SyncScope &scope)
TAO::Transport_Queueing_Strategy &	get_transport_queueing_strategy (TAO_Stub *stub, Messaging::SyncScope &scope)
TAO_ORB_Core_TSS_Resources *	get_tss_resources (void)
	Obtain the TSS resources of this orb.
void *	get_tss_resource (size_t slot_id)
	Obtain the TSS resource in the given slot.
int	set_tss_resource (size_t slot_id, void *)
int	add_tss_cleanup_func (ACE_CLEANUP_FUNC cleanup, size_t &slot_id)
TAO_Cleanup_Func_Registry *	tss_cleanup_funcs (void)
	Return the underlying TSS cleanup function registry.
TAO_Leader_Follower &	leader_follower (void)
	Get access to the leader_follower class.
TAO_LF_Strategy &	lf_strategy (void)
	Get access to the leader follower strategy.
TAO_Thread_Lane_Resources &	lane_resources (void)
	Get access to the thread lane resources.
int	run (ACE_Time_Value *tv, int perform_work)
	Run the event loop.
void	shutdown (CORBA::Boolean wait_for_completion)
	End the event loop.
int	has_shutdown (void)
	Get the shutdown flag value.
void	destroy ()
	Shutdown the ORB and free resources.
void	check_shutdown ()
	Check if ORB has shutdown. If it has, throw an exception.
int	thread_per_connection_timeout (ACE_Time_Value &timeout) const
TAO_Stub *	create_stub_object (TAO_MProfile &mprofile, const char *type_id, CORBA::PolicyList *policy_list)
TAO_Stub *	create_stub (const char *repository_id, const TAO_MProfile &profiles)
CORBA::Object_ptr	create_object (TAO_Stub *the_stub)
CORBA::Long	initialize_object (TAO_Stub *the_stub, CORBA::Object_ptr obj)
CORBA::Long	reinitialize_object (TAO_Stub *stub)
const char *	orbid (void) const
	Return ORBid string.
CORBA::Boolean	use_implrepo (void)
	Do we attempt to register with the Implementation Repository.
CORBA::Boolean	imr_endpoints_in_ior (void)
	Do we put the ImR's endpoints into persistent object references we create.
CORBA::Object_ptr	resolve_typecodefactory ()
	Resolve the TypeCodeFactory DLL.
CORBA::Object_ptr	resolve_picurrent ()
	Resolve the PICurrent.
CORBA::Object_ptr	resolve_poa_current ()
	Resolve POA Current.
CORBA::Object_ptr	resolve_codecfactory ()
	Resolve the CodecFactory DLL.
CORBA::Object_ptr	resolve_dynanyfactory ()
	Resolve the Dynamic Any Factory.
CORBA::Object_ptr	resolve_ior_manipulation ()
	Resolve the IOR Manipulation reference for this ORB.
CORBA::Object_ptr	resolve_ior_table ()
	Resolve the IOR Table reference for this ORB.
CORBA::Object_ptr	resolve_rir (const char *name)
	Resolve an initial reference via the -ORBInitRef and.
CORBA::Object_ptr	resolve_rt_orb (void)
	Resolve the RT ORB reference for this ORB.
const char *	server_id (void) const
CORBA::ORB_ObjectIdList *	list_initial_references ()
	List all the service known by the ORB.
CORBA::ULong	_incr_refcnt (void)
	Reference counting...
CORBA::ULong	_decr_refcnt (void)
int	register_handle (ACE_HANDLE handle)
int	remove_handle (ACE_HANDLE handle)
TAO_Valuetype_Adapter *	valuetype_adapter (void)
	Return the valuetype adapter.
TAO_IORInterceptor_Adapter *	ior_interceptor_adapter (void)
CORBA::Boolean	bidir_giop_policy (void)
void	bidir_giop_policy (CORBA::Boolean)
TAO_Object_Ref_Table &	object_ref_table (void)
TAO::ObjectKey_Table &	object_key_table (void)
	Acceessor to the table that stores the object_keys.
TAO_Request_Dispatcher *	request_dispatcher (void)
	Return the current request dispatcher strategy.
void	request_dispatcher (TAO_Request_Dispatcher *rd)
void	load_policy_validators (TAO_Policy_Validator &validator)
TAO_Flushing_Strategy *	flushing_strategy (void)
	Return the flushing strategy.
TAO_Codeset_Manager *	codeset_manager (void)
	Get Code Set Manager.
InitRefMap *	init_ref_map (void)
	Return a pointer to the -ORBInitRef map.
void	set_default (const char *orb_id)
void	not_default (const char *orb_id)
	Choose to be not a default ORB when there is more than one ORB.
TAO::Transport_Queueing_Strategy &	default_transport_queueing_strategy (void)
CORBA::Boolean	is_permanent_forward_condition (const CORBA::Object_ptr obj, const TAO_Service_Context &service_context)
ACE_Service_Gestalt *	configuration () const
	Configuration accessor method.
auto_ptr< TAO_GIOP_Fragmentation_Strategy >	fragmentation_strategy (TAO_Transport *transport)
	Get outgoing fragmentation strategy.
Helper methods used by the Invocation classes.
CORBA::Object_ptr	poa_current (void)
void	optimize_collocation_objects (CORBA::Boolean opt)
CORBA::Boolean	optimize_collocation_objects (void) const
void	use_global_collocation (CORBA::Boolean opt)
CORBA::Boolean	use_global_collocation (void) const
CORBA::ULong	get_collocation_strategy (void) const
Access to Factories
These factories are not thread-specific, and are presented here in order to have one place to get useful information. Often, the instances to which the return pointers are stored in the Service Repository.
TAO_Resource_Factory *	resource_factory (void)
	Returns pointer to the resource factory.
TAO::GUIResource_Factory *	gui_resource_factory (void)
	Returns pointer to the factory for creating gui resources.
TAO_Client_Strategy_Factory *	client_factory (void)
	Returns pointer to the client factory.
TAO_Server_Strategy_Factory *	server_factory (void)
	Returns pointer to the server factory.
TAO_Protocols_Hooks *	protocols_hooks (void)
	Returns pointer to the Protocols_Hooks.
TAO_Thread_Lane_Resources_Manager &	thread_lane_resources_manager (void)
	Returns a pointer to the Thread Lane Resources Manager.
TAO_Collocation_Resolver &	collocation_resolver (void)
	Returns a pointer to the Collocation Resolver.
TAO_Stub_Factory *	stub_factory (void)
	Returns a pointer to the Stub factory.
TAO_Endpoint_Selector_Factory *	endpoint_selector_factory (void)
	Returns a pointer to the endpoint selector factory.
CORBA::Environment *	default_environment (void) const
void	default_environment (CORBA::Environment *)
CORBA::Object_ptr	implrepo_service (void)
void	implrepo_service (const CORBA::Object_ptr ir)
ORB Core Service Hooks
These methods would represent the hooks in the ORB Core. These hooks would be used to call back on the services or other features that are dynamically loaded.
CORBA::Boolean	service_profile_selection (TAO_MProfile &mprofile, TAO_Profile *&profile)
CORBA::Boolean	service_profile_reselection (TAO_Stub *stub, TAO_Profile *&profile)
void	reset_service_profile_flags (void)
	Reset the flags in the loaded services.
CORBA::Boolean	object_is_nil (CORBA::Object_ptr object)
TAO_Service_Callbacks::Profile_Equivalence	is_profile_equivalent (const TAO_Profile *this_p, const TAO_Profile *that_p)
CORBA::ULong	hash_service (TAO_Profile *this_p, CORBA::ULong max)
void	service_context_list (TAO_Stub *stub, TAO_Service_Context &service_context, CORBA::Boolean retstart)
TAO_Fault_Tolerance_Service &	fault_tolerance_service (void)
	Return a reference to the Fault Tolerant service object.
TAO::Invocation_Status	service_raise_comm_failure (IOP::ServiceContextList &clist, TAO_Profile *profile)
TAO::Invocation_Status	service_raise_transient_failure (IOP::ServiceContextList &clist, TAO_Profile *profile)
Portable Interceptor Related Methods
These are support methods for interceptor registration and interceptor set (an array) access, in addition to PICurrent access.
CORBA::Object_ptr	pi_current (void)
	Return a pointer to the cached TAO::PICurrent object.
void	pi_current (CORBA::Object_ptr current)
	Set the pointer to the cached TAO::PICurrent object.
void	add_interceptor (PortableInterceptor::ClientRequestInterceptor_ptr interceptor)
	Register a client request interceptor.
void	add_interceptor (PortableInterceptor::ServerRequestInterceptor_ptr interceptor)
	Register a server request interceptor.
void	add_interceptor (PortableInterceptor::ClientRequestInterceptor_ptr interceptor, const CORBA::PolicyList &policies)
	Register a client request interceptor with policies.
void	add_interceptor (PortableInterceptor::ServerRequestInterceptor_ptr interceptor, const CORBA::PolicyList &policies)
	Register a server request interceptor with policies.
TAO::ClientRequestInterceptor_Adapter *	clientrequestinterceptor_adapter (void)
TAO::ServerRequestInterceptor_Adapter *	serverrequestinterceptor_adapter (void)
void	add_interceptor (PortableInterceptor::IORInterceptor_ptr interceptor)
	Register an IOR interceptor.
Static Public Member Functions
void	set_thread_lane_resources_manager_factory (const char *thread_lane_resources_manager_factory_name)
void	set_collocation_resolver (const char *collocation_resolver_name)
	Sets the value of TAO_ORB_Core::collocation_resolver_name_.
void	set_stub_factory (const char *stub_factory_name)
	Sets the value of TAO_ORB_Core::stub_factory_name_.
void	set_resource_factory (const char *resource_factory_name)
	Sets the value of TAO_ORB_Core::resource_factory_.
void	set_gui_resource_factory (TAO::GUIResource_Factory *gui_factory)
void	set_protocols_hooks (const char *protocols_hooks_name)
	Sets the value of TAO_ORB_Core::protocols_hooks_.
void	set_endpoint_selector_factory (const char *endpoint_selector_factory_name)
	Sets the value of TAO_ORB_Core::endpoint_selector_factory_.
void	set_poa_factory (const char *poa_factory_name, const char *poa_factory_directive)
const ACE_CString &	poa_factory_name (void)
	Access the POA factory name.
void	dynamic_adapter_name (const char *name)
	Sets the value of TAO_ORB_Core::dynamic_adapter_name_.
const char *	dynamic_adapter_name (void)
	Gets the value of TAO_ORB_Core::dynamic_adapter_name_.
void	ifr_client_adapter_name (const char *name)
	Sets the value of TAO_ORB_Core::ifr_client_adapter_name_.
const char *	ifr_client_adapter_name (void)
	Gets the value of TAO_ORB_Core::ifr_client_adapter_name_.
void	typecodefactory_adapter_name (const char *name)
	Sets the value of TAO_ORB_Core::typecodefactory_adapter_name_.
const char *	typecodefactory_adapter_name (void)
	Gets the value of TAO_ORB_Core::typecodefactory_adapter_name_.
void	iorinterceptor_adapter_factory_name (const char *name)
	Sets the value of TAO_ORB_Core::iorinterceptor_adapter_factory_name_.
const char *	iorinterceptor_adapter_factory_name (void)
	Gets the value of TAO_ORB_Core::iorinterceptor_adapter_factory_name_.
void	valuetype_adapter_factory_name (const char *name)
	Sets the value of TAO_ORB_Core::valuetype_adapter_factory_name.
const char *	valuetype_adapter_factory_name (void)
	Gets the value of TAO_ORB_Core::valuetype_adapter_factory_name.
void	set_timeout_hook (Timeout_Hook hook)
void	connection_timeout_hook (Timeout_Hook hook)
	Define the Timeout_Hook signature.
void	set_sync_scope_hook (Sync_Scope_Hook hook)
Public Attributes
TAO_Protocols_Hooks *	protocols_hooks_
	Handle to the factory for protocols_hooks_..
Protected Member Functions
	~TAO_ORB_Core (void)
int	init (int &argc, char **argv)
int	fini (void)
ACE_Data_Block *	create_data_block_i (size_t size, ACE_Allocator *buffer_allocator, ACE_Allocator *dblock_allocator, ACE_Lock *lock)
	Routine that creates a ACE_Data_Block given the lock and allocators.
void	resolve_typecodefactory_i ()
	Obtain and cache the typecode factory object reference.
void	resolve_poa_current_i ()
	Obtain and cache the poa current.
void	resolve_picurrent_i ()
	Obtain and cache the picurrent factory object reference.
TAO::ClientRequestInterceptor_Adapter *	clientrequestinterceptor_adapter_i (void)
TAO::ServerRequestInterceptor_Adapter *	serverrequestinterceptor_adapter_i (void)
void	resolve_codecfactory_i ()
	Obtain and cache the codec factory object reference.
void	resolve_dynanyfactory_i ()
	Obtain and cache the dynamic any factory object reference.
void	resolve_iormanipulation_i ()
	Obtain and cache the IORManipulation factory object reference.
void	services_callbacks_init (void)
void	destroy_interceptors ()
int	set_endpoint_helper (const ACE_CString &lane, const ACE_CString &endpoints)
TAO::PolicyFactory_Registry_Adapter *	policy_factory_registry_i (void)
TAO::ORBInitializer_Registry_Adapter *	orbinitializer_registry_i (void)
CORBA::Long	initialize_object_i (TAO_Stub *the_stub, const TAO_MProfile &mprofile)
	Common code from ::initialize_object and ::reinitialize_object.
	ACE_TSS_TYPE (TAO_ORB_Core_TSS_Resources) tss_resources_
	This is where the tss resources for this ORB are stored.
Protected Attributes
TAO_SYNCH_MUTEX	lock_
	Synchronize internal state...
TAO_Thread_Lane_Resources_Manager *	thread_lane_resources_manager_
TAO_Collocation_Resolver *	collocation_resolver_
TAO_Stub_Factory *	stub_factory_
TAO_ProtocolFactorySet *	protocol_factories_
CORBA::Object_ptr	implrepo_service_
	The cached IOR for the Implementation Repository.
int	use_implrepo_
	Flag for whether the implrepo support is enabled or not.
int	imr_endpoints_in_ior_
	Flag for whether to put the ImR endpoints into our object refs.
CORBA::Object_ptr	typecode_factory_
	The cached IOR for the TypeCodeFactory DLL.
CORBA::Object_ptr	codec_factory_
	The cached IOR for the CodecFactory DLL.
CORBA::Object_ptr	dynany_factory_
	The cached object reference for the DynAnyFactory.
CORBA::Object_ptr	ior_manip_factory_
	The cached object reference for the IORManipulataion.
CORBA::Object_ptr	ior_table_
	The cached object reference for the IORTable.
CORBA::Object_var	rt_orb_
	The cached object reference for the RTCORBA::RTORB.
CORBA::Object_var	rt_current_
	The cached object reference for the RTCORBA::Current interface.
CORBA::ORB_ptr	orb_
CORBA::Object_var	root_poa_
TAO_ORB_Parameters	orb_params_
	Parameters used by the ORB.
InitRefMap	init_ref_map_
	Return InitRefMap to find if a particular object id is present.
TAO_Object_Ref_Table	object_ref_table_
TAO::ObjectKey_Table	object_key_table_
	Table that stores the object key instead of caching one per-profile.
char *	orbid_
	The ORBid for this ORB.
TAO_Resource_Factory *	resource_factory_
	Handle to the factory for resource information..
ACE_CString	server_id_
	The server_id_ that was passed via -ORBServerId option.
TAO_Client_Strategy_Factory *	client_factory_
	Handle to the factory for Client-side strategies.
TAO_Server_Strategy_Factory *	server_factory_
	Handle to the factory for Server-side strategies.
CORBA::Boolean	opt_for_collocation_
CORBA::Boolean	use_global_collocation_
CORBA::ULong	collocation_strategy_
	Default collocation policy. This should never be ORB_CONTROL.
TAO_Policy_Manager *	policy_manager_
	The Policy_Manager for this ORB.
TAO_Policy_Set *	default_policies_
	The default policies.
TAO_Policy_Current *	policy_current_
	Policy current.
TAO_Request_Dispatcher *	request_dispatcher_
	The request dispatching strategy.
CORBA::Object_var	poa_current_
TAO_Adapter_Registry	adapter_registry_
	The list of Adapters used in this ORB.
TAO_Adapter *	poa_adapter_
	An optimization for the POA.
ACE_Thread_Manager	tm_
	The Thread Manager.
ACE_Lock_Adapter< TAO_SYNCH_MUTEX >	data_block_lock_
	The data block reference counts are locked using this mutex.
TAO_Cleanup_Func_Registry	tss_cleanup_funcs_
int	has_shutdown_
	Flag which denotes that the ORB has been shutdown.
TAO_SYNCH_MUTEX	open_lock_
	Mutual exclusion for calling open.
int	open_called_
	Flag which denotes that the open method was called.
TAO_Endpoint_Selector_Factory *	endpoint_selector_factory_
TAO::Transport_Queueing_Strategy *	eager_transport_queueing_strategy_
	This strategy will buffer messages.
TAO::Transport_Queueing_Strategy *	delayed_transport_queueing_strategy_
	This strategy will buffer messages.
TAO::Transport_Queueing_Strategy *	flush_transport_queueing_strategy_
TAO::Transport_Queueing_Strategy *	default_transport_queueing_strategy_
	This strategy will not queue by default and not flush.
CORBA::ULong	refcount_
	Number of outstanding references to this object.
TAO::PolicyFactory_Registry_Adapter *	policy_factory_registry_
	Registry containing all registered policy factories.
TAO::ORBInitializer_Registry_Adapter *	orbinitializer_registry_
	Registry containing all orb initializers.
CORBA::Object_ptr	pi_current_
	Cached pointer/reference to the PICurrent object.
TAO::ClientRequestInterceptor_Adapter *	client_request_interceptor_adapter_
	The adapter for handling client request interceptors.
TAO::ServerRequestInterceptor_Adapter *	server_request_interceptor_adapter_
	The adapter for handling server request interceptors.
TAO_IORInterceptor_Adapter *	ior_interceptor_adapter_
	IORInterceptor adapter.
TAO_Valuetype_Adapter *	valuetype_adapter_
	Pointer to the valuetype adapter.
TAO_Parser_Registry	parser_registry_
	The IOR parser registry.
TAO_BiDir_Adapter *	bidir_adapter_
	BiDirectional GIOP factory.
CORBA::Boolean	bidir_giop_policy_
	Bir Dir GIOP policy value.
TAO_Flushing_Strategy *	flushing_strategy_
	Hold the flushing strategy.
TAO_Codeset_Manager *	codeset_manager_
	Code Set Manager - points to service object in the service repo.
ACE_Service_Gestalt *	config_
	ORB's service configuration.
Service Level Hooks
TAO_Fault_Tolerance_Service	ft_service_
	Fault Tolerant service hook.
int	thread_per_connection_use_timeout_
ACE_Time_Value	thread_per_connection_timeout_
Private Member Functions
void	resolve_ior_table_i ()
	Obtain and cache the dynamic any factory object reference.
CORBA::Boolean	is_collocation_enabled (TAO_ORB_Core *other_orb, const TAO_MProfile &mp)
	TAO_ORB_Core (const TAO_ORB_Core &)
void	operator= (const TAO_ORB_Core &)
TAO::Transport_Queueing_Strategy &	eager_transport_queueing_strategy (void)
TAO::Transport_Queueing_Strategy &	delayed_transport_queueing_strategy (void)
TAO::Transport_Queueing_Strategy &	flush_transport_queueing_strategy (void)
Private Attributes
bool	use_local_memory_pool_
Friends
class	TAO_ORB_Core_Auto_Ptr
CORBA::ORB_ptr	CORBA::ORB_init (int &, char *argv[], const char *, CORBA::Environment &)

---

Detailed Description

Encapsulates the state of an ORB.

This is the implementation class for the CORBA::ORB interface. The class also encapsulates the access to the ORB resources and its state.

Some resources can be TSS or global, those resources are always accessed through a TSS interface, but are allocated using the Resource_Factory. If the resource is really global the Resource_Factory will simply return a pointer to the global instance.

Definition at line 158 of file ORB_Core.h.

---

Member Typedef Documentation

typedef ACE_Array_Map<ACE_CString, ACE_CString> TAO_ORB_Core::InitRefMap

Definition at line 900 of file ORB_Core.h.

typedef void(* TAO_ORB_Core::Sync_Scope_Hook)(TAO_ORB_Core *, TAO_Stub *, bool &, Messaging::SyncScope &)

Definition at line 551 of file ORB_Core.h. Referenced by call_sync_scope_hook(), and set_sync_scope_hook().

typedef void(* TAO_ORB_Core::Timeout_Hook)(TAO_ORB_Core *, TAO_Stub *, bool&, ACE_Time_Value&)

Define the Timeout_Hook signature. Definition at line 492 of file ORB_Core.h. Referenced by call_timeout_hook(), connection_timeout(), connection_timeout_hook(), and set_timeout_hook().

---

Member Enumeration Documentation

anonymous enum

Enumeration values: ORB_CONTROL  Indicate object should refer to ORB for either one of the following strategies. THRU_POA  Collocated calls will go thru POA. DIRECT  Collocated calls invoke operation on Servant directly. Definition at line 224 of file ORB_Core.h. { /// Indicate object should refer to ORB for either one of the /// following strategies. ORB_CONTROL, /// Collocated calls will go thru POA. THRU_POA, /// Collocated calls invoke operation on Servant directly. DIRECT };

---

Constructor & Destructor Documentation

TAO_ORB_Core::TAO_ORB_Core (  const char *  id  )

Constructor. Definition at line 204 of file ORB_Core.cpp. References ACE_NEW, ACE_OS::strnlen(), TAO_DEFAULT_OBJECT_REF_TABLE_SIZE, TAO_HAS_BUFFERING_CONSTRAINT_POLICY, TAO_HAS_CORBA_MESSAGING, TAO_POLICY_ORB_SCOPE, and TAO_USE_LOCAL_MEMORY_POOL. : protocols_hooks_ (0), #if TAO_USE_LOCAL_MEMORY_POOL == 1 use_local_memory_pool_ (true), #else use_local_memory_pool_ (false), #endif lock_ (), thread_lane_resources_manager_ (0), collocation_resolver_ (0), stub_factory_ (0), protocol_factories_ (0), implrepo_service_ (CORBA::Object::_nil ()), use_implrepo_ (0), imr_endpoints_in_ior_ (1), typecode_factory_ (CORBA::Object::_nil ()), codec_factory_ (CORBA::Object::_nil ()), dynany_factory_ (CORBA::Object::_nil ()), ior_manip_factory_ (CORBA::Object::_nil ()), ior_table_ (CORBA::Object::_nil ()), orb_ (CORBA::ORB::_nil ()), root_poa_ (), orb_params_ (), init_ref_map_ (TAO_DEFAULT_OBJECT_REF_TABLE_SIZE), object_ref_table_ (), object_key_table_ (), orbid_ (ACE_OS::strdup (orbid ? orbid : "")), resource_factory_ (0), client_factory_ (0), server_factory_ (0), opt_for_collocation_ (1), use_global_collocation_ (1), collocation_strategy_ (THRU_POA), #if (TAO_HAS_CORBA_MESSAGING == 1) policy_manager_ (0), default_policies_ (0), policy_current_ (0), #endif /* TAO_HAS_CORBA_MESSAGING == 1 */ poa_current_ (), adapter_registry_ (this), poa_adapter_ (0), tm_ (), tss_cleanup_funcs_ (), tss_resources_ (), has_shutdown_ (1), // Start the ORB in a "shutdown" state. Only // after CORBA::ORB_init() is called will the // ORB no longer be shutdown. This does not // mean that the ORB can be reinitialized. It // can only be initialized once. thread_per_connection_use_timeout_ (1), open_lock_ (), endpoint_selector_factory_ (0), #if (TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1) eager_transport_queueing_strategy_ (0), delayed_transport_queueing_strategy_ (0), flush_transport_queueing_strategy_ (0), #endif /* TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1 */ default_transport_queueing_strategy_ (0), refcount_ (1), policy_factory_registry_ (0), orbinitializer_registry_ (0), #if (TAO_HAS_INTERCEPTORS == 1) pi_current_ (CORBA::Object::_nil ()), client_request_interceptor_adapter_ (0), server_request_interceptor_adapter_ (0), #endif /* TAO_HAS_INTERCEPTORS == 1 */ ior_interceptor_adapter_ (0), valuetype_adapter_ (0), parser_registry_ (), bidir_adapter_ (0), bidir_giop_policy_ (0), flushing_strategy_ (0), codeset_manager_ (0) { #if (TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1) ACE_NEW (this->eager_transport_queueing_strategy_, TAO::Eager_Transport_Queueing_Strategy); ACE_NEW (this->delayed_transport_queueing_strategy_, TAO::Delayed_Transport_Queueing_Strategy); ACE_NEW (this->flush_transport_queueing_strategy_, TAO::Flush_Transport_Queueing_Strategy); #endif /* TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1 */ #if (TAO_HAS_CORBA_MESSAGING == 1) ACE_NEW (this->policy_manager_, TAO_Policy_Manager); ACE_NEW (this->default_policies_, TAO_Policy_Set (TAO_POLICY_ORB_SCOPE)); ACE_NEW (this->policy_current_, TAO_Policy_Current); #endif /* TAO_HAS_CORBA_MESSAGING == 1 */ ACE_NEW (this->default_transport_queueing_strategy_, TAO::Default_Transport_Queueing_Strategy); // Initialize the default request dispatcher. ACE_NEW (this->request_dispatcher_, TAO_Request_Dispatcher); // @TODO: Can this be dynamic container instead? if (ACE_OS::strnlen (this->orbid_, 1) == 0) { ACE_NEW (this->config_, ACE_Service_Gestalt (ACE_Service_Gestalt::MAX_SERVICES, false)); // (Re)use the process-global repository } else { ACE_NEW (this->config_, ACE_Service_Gestalt (ACE_Service_Gestalt::MAX_SERVICES / 4, true)); // Use our own service repository } }

TAO_ORB_Core::~TAO_ORB_Core (  void   )  [protected]

Destructor is protected since the ORB Core is a reference counted object. Definition at line 330 of file ORB_Core.cpp. References default_policies_, default_transport_queueing_strategy_, delayed_transport_queueing_strategy_, eager_transport_queueing_strategy_, flush_transport_queueing_strategy_, flushing_strategy_, ACE_OS::free(), orb_, orbinitializer_registry_, policy_current_, policy_factory_registry_, policy_manager_, request_dispatcher_, and thread_lane_resources_manager_. { delete this->thread_lane_resources_manager_; delete this->flushing_strategy_; ACE_OS::free (this->orbid_); #if (TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1) delete this->eager_transport_queueing_strategy_; delete this->delayed_transport_queueing_strategy_; delete this->flush_transport_queueing_strategy_; #endif /* TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1 */ #if (TAO_HAS_CORBA_MESSAGING == 1) ::CORBA::release (this->policy_manager_); delete this->default_policies_; ::CORBA::release (this->policy_current_); #endif /* TAO_HAS_CORBA_MESSAGING == 1 */ delete this->default_transport_queueing_strategy_; delete this->request_dispatcher_; delete this->policy_factory_registry_; // Don't delete, is a process wide singleton shared by all orbs orbinitializer_registry_ = 0; ::CORBA::release (this->orb_); delete this->config_; this->config_ = 0; }

TAO_ORB_Core::TAO_ORB_Core (  const TAO_ORB_Core &   )  [private]

---

Member Function Documentation

ACE_INLINE CORBA::ULong TAO_ORB_Core::_decr_refcnt (  void   )

Definition at line 24 of file ORB_Core.i. References ACE_GUARD_RETURN, fini(), and TAO_SYNCH_MUTEX. Referenced by TAO_ORB_Core_Auto_Ptr::reset(), TAO::ORB_Core_Ref_Counter::~ORB_Core_Ref_Counter(), and TAO_ORB_Core_Auto_Ptr::~TAO_ORB_Core_Auto_Ptr(). { { ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, mon, this->lock_, 0); --this->refcount_; if (this->refcount_ != 0) return this->refcount_; } this->fini (); return 0; }

ACE_INLINE CORBA::ULong TAO_ORB_Core::_incr_refcnt (  void   )

Reference counting... Definition at line 17 of file ORB_Core.i. References ACE_GUARD_RETURN, and TAO_SYNCH_MUTEX. Referenced by TAO::ORB_Table::find(), initialize_object_i(), TAO::Collocated_Invocation::invoke(), and TAO::ORB_Core_Ref_Counter::ORB_Core_Ref_Counter(). { ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, guard, this->lock_, 0); return this->refcount_++; }

TAO_ORB_Core::ACE_TSS_TYPE (  TAO_ORB_Core_TSS_Resources   )  [protected]

This is where the tss resources for this ORB are stored.

ACE_INLINE TAO_Adapter_Registry * TAO_ORB_Core::adapter_registry (  void   )

Get the adapter registry. Definition at line 192 of file ORB_Core.i. References adapter_registry_. Referenced by create_object(), TAO_Request_Dispatcher::dispatch(), initialize_object_i(), TAO_GIOP_Message_Lite::process_locate_request(), and TAO_GIOP_Message_Lite::process_request(). { return &this->adapter_registry_; }

void TAO_ORB_Core::add_interceptor (  PortableInterceptor::IORInterceptor_ptr  interceptor  )

Register an IOR interceptor. Definition at line 3227 of file ORB_Core.cpp. References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_ERROR, ACE_TEXT, ACE_THROW, TAO_IORInterceptor_Adapter::add_interceptor(), ior_interceptor_adapter(), ior_interceptor_adapter_, PortableInterceptor::IORInterceptor_ptr, and LM_ERROR. { if (this->ior_interceptor_adapter ()) { this->ior_interceptor_adapter_->add_interceptor (interceptor ACE_ENV_ARG_PARAMETER); ACE_CHECK; } else { ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) %p\n"), ACE_TEXT ("ERROR: ORB Core unable to find the ") ACE_TEXT ("IORInterceptor Adapter Factory instance"))); ACE_THROW (CORBA::INTERNAL ()); } }

void TAO_ORB_Core::add_interceptor (  PortableInterceptor::ServerRequestInterceptor_ptr  interceptor, const CORBA::PolicyList &  policies )

Register a server request interceptor with policies. Definition at line 3393 of file ORB_Core.cpp. References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_ERROR, ACE_TEXT, ACE_THROW, TAO::ServerRequestInterceptor_Adapter::add_interceptor(), LM_ERROR, server_request_interceptor_adapter_, serverrequestinterceptor_adapter_i(), and PortableInterceptor::ServerRequestInterceptor_ptr. { if (this->serverrequestinterceptor_adapter_i ()) { this->server_request_interceptor_adapter_->add_interceptor ( interceptor, policies ACE_ENV_ARG_PARAMETER); ACE_CHECK; } else { ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) %p\n"), ACE_TEXT ("ERROR: ORB Core unable to find the ") ACE_TEXT ("Server Request Interceptor Adapter Factory ") ACE_TEXT ("instance"))); ACE_THROW (CORBA::INTERNAL ()); } }

void TAO_ORB_Core::add_interceptor (  PortableInterceptor::ClientRequestInterceptor_ptr  interceptor, const CORBA::PolicyList &  policies )

Register a client request interceptor with policies. Definition at line 3366 of file ORB_Core.cpp. References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_ERROR, ACE_TEXT, ACE_THROW, TAO::ClientRequestInterceptor_Adapter::add_interceptor(), client_request_interceptor_adapter_, clientrequestinterceptor_adapter_i(), PortableInterceptor::ClientRequestInterceptor_ptr, and LM_ERROR. { if (this->clientrequestinterceptor_adapter_i ()) { this->client_request_interceptor_adapter_->add_interceptor ( interceptor, policies ACE_ENV_ARG_PARAMETER); ACE_CHECK; } else { ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) %p\n"), ACE_TEXT ("ERROR: ORB Core unable to find the ") ACE_TEXT ("Client Request Interceptor Adapter Factory ") ACE_TEXT ("instance"))); ACE_THROW (CORBA::INTERNAL ()); } }

void TAO_ORB_Core::add_interceptor (  PortableInterceptor::ServerRequestInterceptor_ptr  interceptor  )

Register a server request interceptor. Definition at line 3343 of file ORB_Core.cpp. References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_ERROR, ACE_TEXT, ACE_THROW, TAO::ServerRequestInterceptor_Adapter::add_interceptor(), LM_ERROR, server_request_interceptor_adapter_, serverrequestinterceptor_adapter_i(), and PortableInterceptor::ServerRequestInterceptor_ptr. { if (this->serverrequestinterceptor_adapter_i ()) { this->server_request_interceptor_adapter_->add_interceptor (interceptor ACE_ENV_ARG_PARAMETER); ACE_CHECK; } else { ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) %p\n"), ACE_TEXT ("ERROR: ORB Core unable to find the ") ACE_TEXT ("Server Request Interceptor Adapter Factory ") ACE_TEXT ("instance"))); ACE_THROW (CORBA::INTERNAL ()); } }

void TAO_ORB_Core::add_interceptor (  PortableInterceptor::ClientRequestInterceptor_ptr  interceptor  )

Register a client request interceptor. Definition at line 3292 of file ORB_Core.cpp. References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_ERROR, ACE_TEXT, ACE_THROW, TAO::ClientRequestInterceptor_Adapter::add_interceptor(), client_request_interceptor_adapter_, clientrequestinterceptor_adapter_i(), PortableInterceptor::ClientRequestInterceptor_ptr, and LM_ERROR. { if (this->clientrequestinterceptor_adapter_i ()) { this->client_request_interceptor_adapter_->add_interceptor (interceptor ACE_ENV_ARG_PARAMETER); ACE_CHECK; } else { ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) %p\n"), ACE_TEXT ("ERROR: ORB Core unable to find the ") ACE_TEXT ("Client Request Interceptor Adapter Factory ") ACE_TEXT ("instance"))); ACE_THROW (CORBA::INTERNAL ()); } }

int TAO_ORB_Core::add_tss_cleanup_func (  ACE_CLEANUP_FUNC  cleanup, size_t &  slot_id )

Register a TSS cleanup function. The slot ID for the corresponding ORB core TSS resource is returned by the reference argument. This method return 0 on success, and -1 on failure. Definition at line 2993 of file ORB_Core.cpp. References TAO_Cleanup_Func_Registry::register_cleanup_function(), and tss_cleanup_funcs_. { return this->tss_cleanup_funcs_.register_cleanup_function (cleanup, slot_id); }

ACE_INLINE void TAO_ORB_Core::bidir_giop_policy (  CORBA::Boolean   )

Definition at line 53 of file ORB_Core.i. References bidir_giop_policy_. { this->bidir_giop_policy_ = val; }

ACE_INLINE CORBA::Boolean TAO_ORB_Core::bidir_giop_policy (  void   )

Set and Get methods to indicate whether a BiDir IIOP policy has been set in the POA. Note: At present, the value will be true even if one of the POA's is set with the Bi Dir GIOP policy. Definition at line 47 of file ORB_Core.i. References bidir_giop_policy_. Referenced by TAO_IIOP_Transport::generate_request_header(), and TAO_GIOP_Message_Generator_Parser_12::parse_request_header(). { return this->bidir_giop_policy_; }

void TAO_ORB_Core::call_sync_scope_hook (  TAO_Stub *  stub, bool &  has_synchronization, Messaging::SyncScope &  scope )

Definition at line 2940 of file ORB_Core.cpp. References TAO_ORB_Core_Static_Resources::instance(), Sync_Scope_Hook, TAO_ORB_Core_Static_Resources::sync_scope_hook_, and Messaging::SyncScope. Referenced by TAO::Invocation_Adapter::set_response_flags(). { Sync_Scope_Hook sync_scope_hook = TAO_ORB_Core_Static_Resources::instance ()->sync_scope_hook_; if (sync_scope_hook == 0) { has_synchronization = false; return; } (*sync_scope_hook) (this, stub, has_synchronization, scope); }

void TAO_ORB_Core::call_timeout_hook (  TAO_Stub *  stub, bool &  has_timeout, ACE_Time_Value &  time_value )

Invoke the timeout hook if present. The timeout hook is used to determine if the timeout policy is set and with what value. If the ORB is compiled without support for Messaging this feature does not take effect Parameters: has_timeout  returns 0 if there is no timeout policy set. time_value  returns the timeout value in effect for the object, thread and current ORB. Definition at line 3001 of file ORB_Core.cpp. References TAO_ORB_Core_Static_Resources::instance(), Timeout_Hook, and TAO_ORB_Core_Static_Resources::timeout_hook_. Referenced by TAO::LocateRequest_Invocation_Adapter::get_timeout(), and TAO::Invocation_Adapter::get_timeout(). { Timeout_Hook timeout_hook = TAO_ORB_Core_Static_Resources::instance ()->timeout_hook_; if (timeout_hook == 0) { has_timeout = false; return; } (*timeout_hook) (this, stub, has_timeout, time_value); }

void TAO_ORB_Core::check_shutdown (   )

Check if ORB has shutdown. If it has, throw an exception. Definition at line 2352 of file ORB_Core.cpp. References ACE_THROW, and has_shutdown(). Referenced by CORBA::ORB::check_shutdown(). { if (this->has_shutdown ()) { // As defined by the CORBA 2.3 specification, throw a // CORBA::BAD_INV_ORDER exception with minor code 4 if the ORB // has shutdown by the time an ORB function is called. ACE_THROW (CORBA::BAD_INV_ORDER (CORBA::OMGVMCID | 4, CORBA::COMPLETED_NO)); } }

TAO_Client_Strategy_Factory * TAO_ORB_Core::client_factory (  void   )

Returns pointer to the client factory. Definition at line 1783 of file ORB_Core.cpp. References ACE_TEXT, client_factory_, and configuration(). Referenced by TAO_Connector::create_connect_strategy(), TAO::Transport_Cache_Manager::find_transport(), TAO_Fault_Tolerance_Service::init(), TAO_Muxed_TMS::TAO_Muxed_TMS(), TAO_Profile::TAO_Profile(), TAO_Transport::TAO_Transport(), TAO::Profile_Transport_Resolver::use_parallel_connect(), and TAO_Wait_On_Read::wait(). { if (this->client_factory_ == 0) { // Look in the service repository for an instance. this->client_factory_ = ACE_Dynamic_Service<TAO_Client_Strategy_Factory>::instance (this->configuration (), ACE_TEXT ("Client_Strategy_Factory")); } return this->client_factory_; }

ACE_INLINE TAO::ClientRequestInterceptor_Adapter * TAO_ORB_Core::clientrequestinterceptor_adapter (  void   )

Get the Client Request Interceptor adapter. Will not create a new one if not available yet. Definition at line 621 of file ORB_Core.i. References client_request_interceptor_adapter_. { return this->client_request_interceptor_adapter_; }

TAO::ClientRequestInterceptor_Adapter * TAO_ORB_Core::clientrequestinterceptor_adapter_i (  void   )  [protected]

Get the Client Request Interceptor adapter. If not created, this method will try to create one if needed. Definition at line 3315 of file ORB_Core.cpp. References ACE_GUARD_RETURN, ACE_TEXT, client_request_interceptor_adapter_, configuration(), TAO_ClientRequestInterceptor_Adapter_Factory::create(), and TAO_SYNCH_MUTEX. Referenced by add_interceptor(). { if (this->client_request_interceptor_adapter_ == 0) { ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->lock_, 0); if (this->client_request_interceptor_adapter_ == 0) { TAO_ClientRequestInterceptor_Adapter_Factory *factory = ACE_Dynamic_Service<TAO_ClientRequestInterceptor_Adapter_Factory>::instance (this->configuration (), ACE_TEXT ("ClientRequestInterceptor_Adapter_Factory")); if (factory) { this->client_request_interceptor_adapter_ = factory->create (); } } } return this->client_request_interceptor_adapter_; }

ACE_INLINE TAO_Codeset_Manager * TAO_ORB_Core::codeset_manager (  void   )

Get Code Set Manager. Definition at line 440 of file ORB_Core.i. References TAO_Resource_Factory::codeset_manager(), TAO_ORB_Parameters::negotiate_codesets(), orb_params(), and resource_factory(). Referenced by TAO_IIOP_Acceptor::create_new_profile(), TAO_IIOP_Acceptor::create_shared_profile(), TAO_Transport::generate_request_header(), TAO_GIOP_Message_Lite::process_request(), and TAO_GIOP_Message_Base::process_request(). { if (this->orb_params()->negotiate_codesets() == 0) return 0; if (this->codeset_manager_ == 0) { // This causes a factory to be loaded which will call // the codeset_manager setter in this thread. this->codeset_manager_ = this->resource_factory()->codeset_manager(); if (this->codeset_manager_ == 0) this->orb_params()->negotiate_codesets(false); } return this->codeset_manager_; }

TAO_Collocation_Resolver & TAO_ORB_Core::collocation_resolver (  void   )

Returns a pointer to the Collocation Resolver. Definition at line 1568 of file ORB_Core.cpp. References ACE_CString, ACE_TEXT_CHAR_TO_TCHAR, collocation_resolver_, TAO_ORB_Core_Static_Resources::collocation_resolver_name_, configuration(), and TAO_ORB_Core_Static_Resources::instance(). Referenced by collocation_strategy(). { // Check if there is a cached reference. if (this->collocation_resolver_ != 0) return *this->collocation_resolver_; // If not, lookup it up. const ACE_CString &collocation_resolver_name = TAO_ORB_Core_Static_Resources::instance ()->collocation_resolver_name_; this->collocation_resolver_ = ACE_Dynamic_Service<TAO_Collocation_Resolver>::instance (this->configuration (), ACE_TEXT_CHAR_TO_TCHAR (collocation_resolver_name.c_str())); return *this->collocation_resolver_; }

TAO::Collocation_Strategy TAO_ORB_Core::collocation_strategy (  CORBA::Object_ptr  object  )  [static]

This method returns the right collocation strategy, if any, to be used to perform a method invocation on the given object. Note: No-Collocation is a special case of collocation. Definition at line 3540 of file ORB_Core.cpp. References ACE_ASSERT, ACE_CHECK_RETURN, ACE_ENV_ARG_PARAMETER, collocation_resolver(), DIRECT, TAO_Pseudo_Var_T< T >::in(), TAO_Collocation_Resolver::is_collocated(), CORBA::is_nil(), CORBA::Object_ptr, and TAO_Stub::servant_orb_var(). Referenced by TAO::Invocation_Adapter::invoke_i(). { TAO_Stub *stub = object->_stubobj (); if (!CORBA::is_nil (stub->servant_orb_var ().in ()) && stub->servant_orb_var ()->orb_core () != 0) { TAO_ORB_Core *orb_core = stub->servant_orb_var ()->orb_core (); const int collocated = orb_core->collocation_resolver ().is_collocated (object ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (TAO::TAO_CS_REMOTE_STRATEGY); if (collocated) { switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ()) { case THRU_POA: return TAO::TAO_CS_THRU_POA_STRATEGY; case DIRECT: { ///////////////////////////////////////////////////////////// // If the servant is null and you are collocated this means // that the POA policy NON-RETAIN is set, and with that policy // using the DIRECT collocation strategy is just insane. ///////////////////////////////////////////////////////////// ACE_ASSERT (object->_servant () != 0); return TAO::TAO_CS_DIRECT_STRATEGY; } } } } // In this case the Object is a client. return TAO::TAO_CS_REMOTE_STRATEGY; }

TAO_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE ACE_Service_Gestalt * TAO_ORB_Core::configuration (   )  const

Configuration accessor method. Definition at line 11 of file ORB_Core.i. Referenced by client_factory(), clientrequestinterceptor_adapter_i(), collocation_resolver(), endpoint_selector_factory(), ior_interceptor_adapter(), load_policy_validators(), TAO_Parser_Registry::open(), orbinitializer_registry_i(), TAO_DLL_Parser::parse_string(), policy_factory_registry_i(), resolve_codecfactory_i(), resolve_dynanyfactory_i(), resolve_ior_table_i(), resolve_iormanipulation_i(), resolve_picurrent_i(), resolve_poa_current_i(), resolve_typecodefactory_i(), resource_factory(), root_poa(), server_factory(), serverrequestinterceptor_adapter_i(), stub_factory(), and thread_lane_resources_manager(). { return this->config_; }

void TAO_ORB_Core::connection_timeout (  TAO_Stub *  stub, bool &  has_timeout, ACE_Time_Value &  time_value )

Invoke the timeout hook if present. The timeout hook is used to determine if the timeout policy is set and with what value. If the ORB is compiled without support for Messaging this feature does not take effect Parameters: has_timeout  returns 0 if there is no timeout policy set. time_value  returns the timeout value in effect for the object, thread and current ORB. Definition at line 3024 of file ORB_Core.cpp. References TAO_ORB_Core_Static_Resources::alt_connection_timeout_hook_, connection_timeout_hook(), TAO_ORB_Core_Static_Resources::connection_timeout_hook_, TAO_ORB_Core_Static_Resources::instance(), and Timeout_Hook. Referenced by TAO::Profile_Transport_Resolver::get_connection_timeout(). { Timeout_Hook connection_timeout_hook = TAO_ORB_Core_Static_Resources::instance ()->connection_timeout_hook_; if (connection_timeout_hook == 0) { has_timeout = false; return; } (*connection_timeout_hook) (this, stub, has_timeout, time_value); Timeout_Hook alt_connection_timeout_hook = TAO_ORB_Core_Static_Resources::instance ()->alt_connection_timeout_hook_; if (alt_connection_timeout_hook == 0) return; if (!has_timeout || time_value == ACE_Time_Value::zero ) { (*alt_connection_timeout_hook) (this, stub, has_timeout,time_value); return; } // At this point, both the primary and alternate hooks are defined, and // the primary did indeed set a value ACE_Time_Value tv1; bool ht1; (*alt_connection_timeout_hook) (this, stub, ht1,tv1); if (ht1 && tv1 > ACE_Time_Value::zero && tv1 < time_value) time_value = tv1; }

void TAO_ORB_Core::connection_timeout_hook (  Timeout_Hook  hook  )  [static]

Define the Timeout_Hook signature. The connection timeout hook was originally defined to allow the TAO Messaging code to be factored out of the core TAO library and placed in to an optional library. Since then, a new invocation endpoint selector, the optimised connection endpoint selector (see Strategies/OC_Endpoint_Selector.h) reused this connection timeout hook. However, this set up a problem when both the Messaging library and OCES are being used in the same application. The solution was to add a new connection timeout hook attribute (see alt_connection_timeout_hook_ below). This method now checks to see if the connection timeout hook is already set, and if so assigns the supplied hook value to the alternate connection timeout hook. This functionality has a side-effect of assuming that hooks are NEVER unloaded or actively replaced. IOW, no one will call this method with a 0 or some other pointer value to replace an existing hook. If such functionality as unloading a hook pointer is required, then this method must be extended to give some kind of identity for the hook. Additional changes to the definition of the hook will also be necessary to support such identity and manipulation. Definition at line 3061 of file ORB_Core.cpp. References ACE_DEBUG, ACE_TEXT, LM_DEBUG, TAO_debug_level, Timeout_Hook, and TOCSRi. Referenced by connection_timeout(). { // Saving the hook pointer so that we can use it later when needed. // For now there are only two entry points that may supply a connection // timeout hook. But there might be future entry points, so this should // probably be addressed by a more sophisticated mechanism. #define TOCSRi TAO_ORB_Core_Static_Resources::instance () // A consern was raised that since this function is called by two // different initializers there may be a race condition that might // require a lock. We are not using a lock at this time because of // two callers, one happens only during service directive processing // and the other only during ORB Initialization time. The former // happens when the OC_Endpoint_Selector_Factory is loaded, the // latter is part of the messaging library. The messaging library // calls this function as part of pre_init processing, and this call // happes for every ORB instance. This was the case before these The // latter call occurs when the messaging library is loaded. The // redundant calls occured then as well. Second, it isn't clear how // a lock in this static method would react in the face of windows // dlls, shared memory segments, etc. Therefore we are continuing to // keep this code lockless as it always was, assuming no // simultanious overwrite will occur. if (TOCSRi->connection_timeout_hook_ == 0) { if (TAO_debug_level > 2) ACE_DEBUG ((LM_DEBUG, ACE_TEXT("TAO (%P|%t) setting primary hook\n"))); TOCSRi->connection_timeout_hook_ = hook; } else if (TOCSRi->connection_timeout_hook_ != hook && TOCSRi->alt_connection_timeout_hook_ == 0) { if (TAO_debug_level > 2) ACE_DEBUG ((LM_DEBUG, ACE_TEXT("TAO (%P|%t) setting alternate hook\n"))); TOCSRi->alt_connection_timeout_hook_ = hook; } else if (TAO_debug_level > 2) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) not overwriting alternate hook.") ACE_TEXT (" Is it still null? %d\n"), TOCSRi->alt_connection_timeout_hook_ == 0)); #undef TOCSRi }

TAO_Connector_Registry * TAO_ORB_Core::connector_registry (   )

Get the connector registry. Definition at line 2883 of file ORB_Core.cpp. References ACE_CHECK_RETURN, ACE_ENV_SINGLE_ARG_PARAMETER, TAO_Thread_Lane_Resources::connector_registry(), and lane_resources(). Referenced by operator>>(), resolve_rir(), CORBA::Object::tao_object_initialize(), TAO::Profile_Transport_Resolver::try_connect_i(), and CORBA::ORB::url_ior_string_to_object(). { TAO_Connector_Registry *conn = this->lane_resources ().connector_registry (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (0); return conn; }

ACE_Data_Block * TAO_ORB_Core::create_data_block_i (  size_t  size, ACE_Allocator *  buffer_allocator, ACE_Allocator *  dblock_allocator, ACE_Lock *  lock )  [protected]

Routine that creates a ACE_Data_Block given the lock and allocators. Definition at line 2859 of file ORB_Core.cpp. References ACE_Data_Block, ACE_NEW_MALLOC_RETURN, and ACE_Allocator::malloc(). Referenced by create_input_cdr_data_block(). { ACE_Data_Block *nb = 0; ACE_NEW_MALLOC_RETURN ( nb, static_cast<ACE_Data_Block*> ( dblock_allocator->malloc (sizeof (ACE_Data_Block))), ACE_Data_Block (size, ACE_Message_Block::MB_DATA, 0, buffer_allocator, lock_strategy, 0, dblock_allocator), 0); return nb; }

ACE_Data_Block * TAO_ORB_Core::create_input_cdr_data_block (  size_t  size  )

The Message Blocks used for input CDRs must have appropiate locking strategies. Definition at line 2835 of file ORB_Core.cpp. References create_data_block_i(), data_block_lock_, input_cdr_buffer_allocator(), input_cdr_dblock_allocator(), resource_factory(), and TAO_Resource_Factory::use_locked_data_blocks(). Referenced by TAO_GIOP_Message_Lite::make_queued_data(), and TAO_GIOP_Message_Base::make_queued_data(). { ACE_Allocator *dblock_allocator = 0; ACE_Allocator *buffer_allocator = 0; dblock_allocator = this->input_cdr_dblock_allocator (); buffer_allocator = this->input_cdr_buffer_allocator (); ACE_Lock* lock_strategy = 0; if (this->resource_factory ()->use_locked_data_blocks ()) { lock_strategy = &this->data_block_lock_; } return this->create_data_block_i (size, buffer_allocator, dblock_allocator, lock_strategy); }

CORBA::Object_ptr TAO_ORB_Core::create_object (  TAO_Stub *  the_stub  )

Create a new object, use the adapter registry to create a collocated object, if not possible then create a regular object. Definition at line 1969 of file ORB_Core.cpp. References ACE_GUARD_RETURN, ACE_NEW_RETURN, adapter_registry(), TAO_Stub::base_profiles(), TAO::ORB_Table::begin(), TAO_Adapter_Registry::create_collocated_object(), TAO::ORB_Table::end(), TAO_ORB_Core_Auto_Ptr::get(), TAO::ORB_Table::instance(), is_collocation_enabled(), CORBA::Object_ptr, and TAO_SYNCH_MUTEX. Referenced by operator>>(), and CORBA::ORB::url_ior_string_to_object(). { // @@ What about forwarding. With this approach we are never forwarded // when we use collocation! const TAO_MProfile &mprofile = stub->base_profiles (); // @@ We should thow CORBA::NO_MEMORY in platforms with exceptions, // but we are stuck in platforms without exceptions! TAO_ORB_Core_Auto_Ptr collocated_orb_core; CORBA::Object_ptr x = 0; { // Lock the ORB_Table against concurrent modification while we // iterate through the ORBs. ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, guard, TAO::ORB_Table::instance()->lock_, CORBA::Object::_nil ()); TAO::ORB_Table * const table = TAO::ORB_Table::instance (); TAO::ORB_Table::iterator const end = table->end (); for (TAO::ORB_Table::iterator i = table->begin (); i != end; ++i) { ::TAO_ORB_Core * const other_core = (*i).second.core (); if (this->is_collocation_enabled (other_core, mprofile)) { other_core->_incr_refcnt(); TAO_ORB_Core_Auto_Ptr tmp_auto_ptr (other_core); collocated_orb_core = tmp_auto_ptr; break; } } } if (collocated_orb_core.get ()) { TAO_Adapter_Registry *ar = collocated_orb_core.get ()->adapter_registry (); x = ar->create_collocated_object (stub, mprofile); } if (!x) { // The constructor sets the proxy broker as the // Remote one. ACE_NEW_RETURN (x, CORBA::Object (stub, 0), 0); } return x; }

TAO_Stub * TAO_ORB_Core::create_stub (  const char *  repository_id, const TAO_MProfile &  profiles )

Factory method that create the "right" Stub depending on wheather RTCORBA is loaded or not. The factory used to create the stub, is loaded at ORB initialization, and its type depends on the fact that RTCORBA is being used or not. Definition at line 1892 of file ORB_Core.cpp. References ACE_CHECK_RETURN, ACE_ENV_ARG_PARAMETER, TAO_Stub_Factory::create_stub(), and stub_factory(). Referenced by create_stub_object(), operator>>(), CORBA::Object::tao_object_initialize(), and CORBA::ORB::url_ior_string_to_object(). { TAO_Stub *retval = this->stub_factory ()->create_stub (repository_id, profiles, this ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN(0); return retval; }

TAO_Stub * TAO_ORB_Core::create_stub_object (  TAO_MProfile &  mprofile, const char *  type_id, CORBA::PolicyList *  policy_list )

Makes sure that the ORB is open and then creates a TAO_Stub based on the endpoint. Definition at line 1915 of file ORB_Core.cpp. References ACE_CHECK_RETURN, ACE_ENV_ARG_PARAMETER, TAO_Stub::base_profiles(), create_stub(), TAO_MProfile::get_profile(), TAO_Profile::policies(), TAO_MProfile::policy_list(), and TAO_MProfile::profile_count(). { // Add the Polices contained in "policy_list" to each profile so // that those policies will be exposed to the client in the IOR. In // particular each CORBA::Policy has to be converted in to // Messaging::PolicyValue, and then all the Messaging::PolicyValue // should be embedded inside a Messaging::PolicyValueSeq which // became in turns the "body" of the IOP::TaggedComponent. This // conversion is a responsability of the CORBA::Profile class. (See // orbos\98-05-05.pdf Section 5.4) if (policy_list->length () != 0) { TAO_Profile * profile; const CORBA::ULong count = mprofile.profile_count (); for (CORBA::ULong i = 0; i < count; ++i) { // Get the ith profile profile = mprofile.get_profile (i); profile->policies (policy_list ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (0); } } /// Initialize a TAO_Stub object with the mprofile thats passed. TAO_Stub *stub = this->create_stub (type_id, mprofile ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (stub); stub->base_profiles ().policy_list (policy_list); return stub; }

void TAO_ORB_Core::default_environment (  CORBA::Environment *   )

The thread has a default environment to simplify porting between platforms that support native C++ exceptions and those that don't. This is a TSS resource (always), but with a twist: if the user creates a new environment the old one is "pushed" (actually the new one remembers it), eventually the new environment destructor pops itself from the stack and we recover the old environment. This means that if the user create a new environment and somebody calls a function using the default one the exception will still be received in the environment created by the user. The only drawback is that environments life time must nest properly, this shouldn't be a problem because environments are usually created on the stack, but, the spec allows their creation on the heap and/or as class members; we need to investigate the tradeoffs and take a decision. Definition at line 3221 of file ORB_Core.cpp. References TAO_TSS_Resources::default_environment_, and TAO_TSS_Resources::instance(). { TAO_TSS_Resources::instance ()->default_environment_ = env; }

CORBA::Environment * TAO_ORB_Core::default_environment (  void   )  const

The thread has a default environment to simplify porting between platforms that support native C++ exceptions and those that don't. This is a TSS resource (always), but with a twist: if the user creates a new environment the old one is "pushed" (actually the new one remembers it), eventually the new environment destructor pops itself from the stack and we recover the old environment. This means that if the user create a new environment and somebody calls a function using the default one the exception will still be received in the environment created by the user. The only drawback is that environments life time must nest properly, this shouldn't be a problem because environments are usually created on the stack, but, the spec allows their creation on the heap and/or as class members; we need to investigate the tradeoffs and take a decision. Definition at line 3215 of file ORB_Core.cpp. References TAO_TSS_Resources::default_environment_, and TAO_TSS_Resources::instance(). Referenced by CORBA::Environment::default_environment(), CORBA::Environment::Environment(), and CORBA::Environment::~Environment(). { return TAO_TSS_Resources::instance ()->default_environment_; }

ACE_INLINE TAO::Transport_Queueing_Strategy & TAO_ORB_Core::default_transport_queueing_strategy (  void   )

This strategy is the default, no explicit queueing and no explicit flush Definition at line 544 of file ORB_Core.i. References default_transport_queueing_strategy_. Referenced by get_transport_queueing_strategy(). { return *this->default_transport_queueing_strategy_; }

ACE_INLINE TAO::Transport_Queueing_Strategy & TAO_ORB_Core::delayed_transport_queueing_strategy (  void   )  [private]

Definition at line 530 of file ORB_Core.i. References delayed_transport_queueing_strategy_. Referenced by get_transport_queueing_strategy(). { return *this->delayed_transport_queueing_strategy_; }

void TAO_ORB_Core::destroy (   )

Shutdown the ORB and free resources. Definition at line 2322 of file ORB_Core.cpp. References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, destroy_interceptors(), TAO::ORB_Table::instance(), and shutdown(). Referenced by CORBA::ORB::destroy(). { // // All destroy() should do is (a) call shutdown() and (b) unbind() // from the ORB table. Nothing else should really be added to this // method. Everything else should go to the shutdown() method. // Remember when the ORB Core is finally removed from the ORB table, // the reference count goes to zero and fini() is called. fini() // calls shutdown() and does not call destroy() since destroy() will // try to unbind from the ORB table again. Additional code should // not be added to destroy() since there is no guarantee that // orb->destroy() will ever be called by the user. Since TAO // guarantees that shutdown() will be called, all cleanup code // should go there. // // Shutdown the ORB and block until the shutdown is complete. this->shutdown (1 ACE_ENV_ARG_PARAMETER); ACE_CHECK; // Invoke Interceptor::destroy() on all registered interceptors. this->destroy_interceptors (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; // Now remove it from the ORB table so that it's ORBid may be // reused. TAO::ORB_Table::instance ()->unbind (this->orbid_); }

void TAO_ORB_Core::destroy_interceptors (   )  [protected]

Helper method that invokes Interceptor::destroy() on all registered interceptors when ORB::destroy() is called. Prevents exceptions from propagating up the call chain. Definition at line 2366 of file ORB_Core.cpp. References ACE_CATCHALL, ACE_DEBUG, ACE_ENDTRY, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_GUARD, ACE_TEXT, ACE_TRY, ACE_TRY_CHECK, client_request_interceptor_adapter_, TAO_IORInterceptor_Adapter::destroy_interceptors(), TAO::ServerRequestInterceptor_Adapter::destroy_interceptors(), TAO::ClientRequestInterceptor_Adapter::destroy_interceptors(), ior_interceptor_adapter_, LM_DEBUG, server_request_interceptor_adapter_, TAO_debug_level, and TAO_SYNCH_MUTEX. Referenced by destroy(). { ACE_TRY { ACE_GUARD (TAO_SYNCH_MUTEX, monitor, this->lock_); #if TAO_HAS_INTERCEPTORS == 1 if (this->client_request_interceptor_adapter_ != 0) { this->client_request_interceptor_adapter_->destroy_interceptors ( ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; delete this->client_request_interceptor_adapter_; this->client_request_interceptor_adapter_ = 0; } if (this->server_request_interceptor_adapter_ != 0) { this->server_request_interceptor_adapter_->destroy_interceptors ( ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; delete this->server_request_interceptor_adapter_; this->server_request_interceptor_adapter_ = 0; } #endif /* TAO_HAS_INTERCEPTORS == 1 */ if (this->ior_interceptor_adapter_ != 0) { this->ior_interceptor_adapter_->destroy_interceptors ( ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; this->ior_interceptor_adapter_ = 0; } } ACE_CATCHALL { // .. catch all the exceptions.. if (TAO_debug_level > 3) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) - Exception in TAO_ORB_Core") ACE_TEXT ("::destroy_interceptors () \n"))); } } ACE_ENDTRY; return; }

const char * TAO_ORB_Core::dynamic_adapter_name (  void   )  [static]

Gets the value of TAO_ORB_Core::dynamic_adapter_name_. Definition at line 1464 of file ORB_Core.cpp. References TAO_ORB_Core_Static_Resources::dynamic_adapter_name_, and TAO_ORB_Core_Static_Resources::instance(). { return TAO_ORB_Core_Static_Resources::instance ()->dynamic_adapter_name_.c_str(); }

void TAO_ORB_Core::dynamic_adapter_name (  const char *  name  )  [static]

Sets the value of TAO_ORB_Core::dynamic_adapter_name_. Definition at line 1458 of file ORB_Core.cpp. References TAO_ORB_Core_Static_Resources::dynamic_adapter_name_, and TAO_ORB_Core_Static_Resources::instance(). { TAO_ORB_Core_Static_Resources::instance ()->dynamic_adapter_name_ = name; }

ACE_INLINE TAO::Transport_Queueing_Strategy & TAO_ORB_Core::eager_transport_queueing_strategy (  void   )  [private]

Definition at line 524 of file ORB_Core.i. References eager_transport_queueing_strategy_. Referenced by get_transport_queueing_strategy(). { return *this->eager_transport_queueing_strategy_; }

TAO_Endpoint_Selector_Factory * TAO_ORB_Core::endpoint_selector_factory (  void   )

Returns a pointer to the endpoint selector factory. Definition at line 1690 of file ORB_Core.cpp. References ACE_CString, ACE_TEXT_CHAR_TO_TCHAR, configuration(), endpoint_selector_factory_, TAO_ORB_Core_Static_Resources::endpoint_selector_factory_name_, and TAO_ORB_Core_Static_Resources::instance(). { // Check if there is a cached reference. if (this->endpoint_selector_factory_ != 0) return this->endpoint_selector_factory_; // If not, look in the service repository for an instance. const ACE_CString &endpoint_selector_factory_name = TAO_ORB_Core_Static_Resources::instance ()->endpoint_selector_factory_name_; this->endpoint_selector_factory_ = ACE_Dynamic_Service<TAO_Endpoint_Selector_Factory>::instance (this->configuration (), ACE_TEXT_CHAR_TO_TCHAR (endpoint_selector_factory_name.c_str())); return this->endpoint_selector_factory_; }

ACE_INLINE TAO_Fault_Tolerance_Service & TAO_ORB_Core::fault_tolerance_service (  void   )

Return a reference to the Fault Tolerant service object. Definition at line 174 of file ORB_Core.i. References ft_service_. Referenced by CORBA::ORB::_tao_ft_client_id(). { return this->ft_service_; }

int TAO_ORB_Core::fini (  void   )  [protected]

Final termination hook, typically called by CORBA::ORB's destructor. Definition at line 1348 of file ORB_Core.cpp. References ACE_ANY_EXCEPTION, ACE_CATCHANY, ACE_CString, ACE_DEBUG, ACE_ENDTRY, ACE_ENV_ARG_PARAMETER, ACE_PRINT_EXCEPTION, ACE_TEXT, ACE_TEXT_CHAR_TO_TCHAR, ACE_TRY_CHECK, ACE_TRY_NEW_ENV, TAO::ORB::close_services(), codec_factory_, TAO::ObjectKey_Table::destroy(), dynany_factory_, TAO_Thread_Lane_Resources_Manager::finalize(), implrepo_service_, ior_manip_factory_, ior_table_, LM_DEBUG, object_key_table_, orbid_, shutdown(), TAO_debug_level, thr_mgr(), thread_lane_resources_manager_, typecode_factory_, and ACE_Thread_Manager::wait(). Referenced by _decr_refcnt(). { ACE_TRY_NEW_ENV { // Shutdown the ORB and block until the shutdown is complete. this->shutdown (1 ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY { ACE_CString message = "Exception caught in trying to shutdown "; message += this->orbid_; message += "\n"; ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, message.c_str ()); } ACE_ENDTRY; // Wait for any server threads, ignoring any failures. (void) this->thr_mgr ()->wait (); ::CORBA::release (this->implrepo_service_); ::CORBA::release (this->typecode_factory_); ::CORBA::release (this->codec_factory_); ::CORBA::release (this->dynany_factory_); ::CORBA::release (this->ior_manip_factory_); ::CORBA::release (this->ior_table_); if (TAO_debug_level > 2) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Destroying ORB <%s>\n"), ACE_TEXT_CHAR_TO_TCHAR (this->orbid_))); } // Finalize lane resources. // // @@ Do not call this->thread_lane_resources_manager().finalize(). // this->thread_lane_manager_resources() can seg fault if the // factory method it invokes returns a zero pointer, which can // easily occur if the ORB is partially initialized due to a Service // Configurator initialization failure. Instead check if the // cached pointer is non-zero and then finalize. // // @todo Fix potential seg fault in // TAO_ORB_Core::thread_lane_resources_manager(). if (this->thread_lane_resources_manager_ != 0) this->thread_lane_resources_manager_->finalize (); (void) TAO::ORB::close_services (this->configuration ()); // Destroy the object_key table this->object_key_table_.destroy (); delete this; return 0; }

ACE_INLINE TAO::Transport_Queueing_Strategy & TAO_ORB_Core::flush_transport_queueing_strategy (  void   )  [private]

Definition at line 536 of file ORB_Core.i. References flush_transport_queueing_strategy_. Referenced by get_transport_queueing_strategy(). { return *this->flush_transport_queueing_strategy_; }

ACE_INLINE TAO_Flushing_Strategy * TAO_ORB_Core::flushing_strategy (  void   )

Return the flushing strategy. The flushing strategy is created by the resource factory, and it is used by the ORB to control the mechanism used to flush the outgoing data queues. The flushing strategies are stateless, therefore, there is only one per ORB. Definition at line 71 of file ORB_Core.i. References flushing_strategy_. Referenced by TAO_Transport::drain_queue(), TAO_Transport::handle_timeout(), TAO_Transport::post_open(), TAO_Transport::send_asynchronous_message_i(), TAO_Transport::send_reply_message_i(), and TAO_Transport::send_synchronous_message_i(). { return this->flushing_strategy_; }

auto_ptr< TAO_GIOP_Fragmentation_Strategy > TAO_ORB_Core::fragmentation_strategy (  TAO_Transport *  transport  )

Get outgoing fragmentation strategy. Definition at line 2893 of file ORB_Core.cpp. References TAO_Resource_Factory::create_fragmentation_strategy(), and resource_factory(). { return this->resource_factory ()->create_fragmentation_strategy ( transport, this->orb_params_.max_message_size ()); }

CORBA::Policy_ptr TAO_ORB_Core::get_cached_policy (  TAO_Cached_Policy_Type  type  )

Get a cached policy. First, check the ORB-level Policy Manager, then check the ORB defaults. Definition at line 3162 of file ORB_Core.cpp. References TAO_Objref_Var_T< T >::_retn(), ACE_CHECK_RETURN, ACE_ENV_ARG_PARAMETER, TAO_Policy_Set::get_cached_policy(), TAO_Policy_Manager::get_cached_policy(), get_default_policies(), TAO_Objref_Var_T< T >::in(), CORBA::is_nil(), policy_manager(), and CORBA::Policy_var. Referenced by get_cached_policy_including_current(). { CORBA::Policy_var result; TAO_Policy_Manager *policy_manager = this->policy_manager (); if (policy_manager != 0) { result = policy_manager->get_cached_policy (type ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (CORBA::Policy::_nil ()); } if (CORBA::is_nil (result.in ())) { result = this->get_default_policies ()->get_cached_policy (type ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (CORBA::Policy::_nil ()); } return result._retn (); }

CORBA::Policy_ptr TAO_ORB_Core::get_cached_policy_including_current (  TAO_Cached_Policy_Type  type  )

Get a cached policy. First, check the thread current, then check the ORB-level Policy Manager, then check the ORB defaults. Definition at line 3189 of file ORB_Core.cpp. References TAO_Objref_Var_T< T >::_retn(), ACE_CHECK, ACE_CHECK_RETURN, ACE_ENV_ARG_PARAMETER, get_cached_policy(), TAO_Policy_Current::get_cached_policy(), TAO_Objref_Var_T< T >::in(), CORBA::is_nil(), policy_current(), and CORBA::Policy_var. { TAO_Policy_Current &policy_current = this->policy_current (); CORBA::Policy_var result = policy_current.get_cached_policy (type ACE_ENV_ARG_PARAMETER); ACE_CHECK (CORBA::Policy::_nil ()); if (CORBA::is_nil (result.in ())) { result = this->get_cached_policy (type ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (CORBA::Policy::_nil ()); } return result._retn (); }

ACE_INLINE CORBA::ULong TAO_ORB_Core::get_collocation_strategy (  void   )  const

Definition at line 248 of file ORB_Core.i. References collocation_strategy_. { return this->collocation_strategy_; }

ACE_INLINE TAO_Policy_Set * TAO_ORB_Core::get_default_policies (  void   )

Accessor method for the default_policies_. Definition at line 575 of file ORB_Core.i. References default_policies_. Referenced by get_cached_policy(), and get_policy(). { return this->default_policies_; }

CORBA::Policy_ptr TAO_ORB_Core::get_policy (  CORBA::PolicyType  type  )

Get a policy. First, check the ORB-level Policy Manager, then check the ORB defaults. Definition at line 3114 of file ORB_Core.cpp. References TAO_Objref_Var_T< T >::_retn(), ACE_CHECK_RETURN, ACE_ENV_ARG_PARAMETER, get_default_policies(), TAO_Policy_Set::get_policy(), TAO_Policy_Manager::get_policy(), TAO_Objref_Var_T< T >::in(), CORBA::is_nil(), policy_manager(), CORBA::Policy_var, and CORBA::PolicyType. Referenced by get_policy_including_current(). { CORBA::Policy_var result; TAO_Policy_Manager *policy_manager = this->policy_manager (); if (policy_manager != 0) { result = policy_manager->get_policy (type ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (CORBA::Policy::_nil ()); } if (CORBA::is_nil (result.in ())) { result = this->get_default_policies ()->get_policy (type ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (CORBA::Policy::_nil ()); } return result._retn (); }

CORBA::Policy_ptr TAO_ORB_Core::get_policy_including_current (  CORBA::PolicyType  type  )

Get a policy. First, check the thread current, then check the ORB-level Policy Manager, then check the ORB defaults. Definition at line 3140 of file ORB_Core.cpp. References TAO_Objref_Var_T< T >::_retn(), ACE_CHECK_RETURN, ACE_ENV_ARG_PARAMETER, get_policy(), TAO_Policy_Current::get_policy(), TAO_Objref_Var_T< T >::in(), CORBA::is_nil(), policy_current(), CORBA::Policy_var, and CORBA::PolicyType. { TAO_Policy_Current &policy_current = this->policy_current (); CORBA::Policy_var result = policy_current.get_policy (type ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (CORBA::Policy::_nil ()); if (CORBA::is_nil (result.in ())) { result = this->get_policy (type ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (CORBA::Policy::_nil ()); } return result._retn (); }

ACE_INLINE TAO_Protocols_Hooks * TAO_ORB_Core::get_protocols_hooks (  void   )

Gets the value of TAO_ORB_Core::protocols_hooks__. Definition at line 77 of file ORB_Core.i. References protocols_hooks_. Referenced by TAO_IIOP_Connection_Handler::open(), TAO::Remote_Invocation::send_message(), and TAO_IIOP_Connection_Handler::set_dscp_codepoint(). { return this->protocols_hooks_; }

TAO::Transport_Queueing_Strategy & TAO_ORB_Core::get_transport_queueing_strategy (  TAO_Stub *  stub, Messaging::SyncScope &  scope )

Definition at line 2959 of file ORB_Core.cpp. References default_transport_queueing_strategy(), delayed_transport_queueing_strategy(), eager_transport_queueing_strategy(), flush_transport_queueing_strategy(), and Messaging::SyncScope. { if (scope == Messaging::SYNC_WITH_TRANSPORT || scope == Messaging::SYNC_WITH_SERVER || scope == Messaging::SYNC_WITH_TARGET) { return this->flush_transport_queueing_strategy (); } if (scope == Messaging::SYNC_NONE || scope == TAO::SYNC_EAGER_BUFFERING) { return this->eager_transport_queueing_strategy (); } if (scope == TAO::SYNC_DELAYED_BUFFERING) { return this->delayed_transport_queueing_strategy (); } return this->default_transport_queueing_strategy (); }

ACE_INLINE void * TAO_ORB_Core::get_tss_resource (  size_t  slot_id  )

Obtain the TSS resource in the given slot. Definition at line 295 of file ORB_Core.i. References get_tss_resources(), ACE_Array_Base< void * >::size(), and TAO_ORB_Core_TSS_Resources::ts_objects_. { TAO_ORB_Core_TSS_Resources *tss_resources = this->get_tss_resources (); if (slot_id >= tss_resources->ts_objects_.size ()) return 0; return tss_resources->ts_objects_[slot_id]; }

ACE_INLINE TAO_ORB_Core_TSS_Resources * TAO_ORB_Core::get_tss_resources (  void   )

Obtain the TSS resources of this orb. Definition at line 289 of file ORB_Core.i. References ACE_TSS_GET. Referenced by TAO::Wait_On_LF_No_Upcall::can_process_upcalls(), get_tss_resource(), TAO_Leader_Follower::get_tss_resources(), TAO::Nested_Upcall_Guard::Nested_Upcall_Guard(), set_tss_resource(), and TAO::Nested_Upcall_Guard::~Nested_Upcall_Guard(). { return ACE_TSS_GET (&this->tss_resources_,TAO_ORB_Core_TSS_Resources); }

TAO::GUIResource_Factory * TAO_ORB_Core::gui_resource_factory (  void   )

Returns pointer to the factory for creating gui resources. Definition at line 1539 of file ORB_Core.cpp. References TAO_TSS_Resources::gui_resource_factory_, and TAO_TSS_Resources::instance(). Referenced by TAO_Leader_Follower::reactor(), and TAO_Leader_Follower::~TAO_Leader_Follower(). { return TAO_TSS_Resources::instance ()->gui_resource_factory_; }

ACE_INLINE int TAO_ORB_Core::has_shutdown (  void   )

Get the shutdown flag value. Definition at line 354 of file ORB_Core.i. References has_shutdown_. Referenced by check_shutdown(), TAO_Connection_Handler::close_connection_eh(), TAO_Leader_Follower::reset_client_thread(), run(), TAO_Leader_Follower::set_client_thread(), shutdown(), and TAO_Connection_Handler::svc_i(). { return this->has_shutdown_; }

ACE_INLINE CORBA::ULong TAO_ORB_Core::hash_service (  TAO_Profile *  this_p, CORBA::ULong  max )

For details on how this is used please see the FT service Definition at line 162 of file ORB_Core.i. References ft_service_, TAO_Service_Callbacks::hash_ft(), and TAO_Fault_Tolerance_Service::service_callback(). Referenced by TAO_Profile::hash_service_i(). { if (this->ft_service_.service_callback ()) { return this->ft_service_.service_callback ()->hash_ft (p, m); } return 0; }

const char * TAO_ORB_Core::ifr_client_adapter_name (  void   )  [static]

Gets the value of TAO_ORB_Core::ifr_client_adapter_name_. Definition at line 1476 of file ORB_Core.cpp. References TAO_ORB_Core_Static_Resources::ifr_client_adapter_name_, and TAO_ORB_Core_Static_Resources::instance(). { return TAO_ORB_Core_Static_Resources::instance ()->ifr_client_adapter_name_.c_str(); }

void TAO_ORB_Core::ifr_client_adapter_name (  const char *  name  )  [static]

Sets the value of TAO_ORB_Core::ifr_client_adapter_name_. Definition at line 1470 of file ORB_Core.cpp. References TAO_ORB_Core_Static_Resources::ifr_client_adapter_name_, and TAO_ORB_Core_Static_Resources::instance(). { TAO_ORB_Core_Static_Resources::instance ()->ifr_client_adapter_name_ = name; }

ACE_INLINE void TAO_ORB_Core::implrepo_service (  const CORBA::Object_ptr  ir  )

Definition at line 373 of file ORB_Core.i. References implrepo_service_, and CORBA::Object_ptr. { this->implrepo_service_ = ir; }

CORBA::Object_ptr TAO_ORB_Core::implrepo_service (  void   )

Definition at line 2908 of file ORB_Core.cpp. References CORBA::Object::_duplicate(), CORBA::Object::_nil(), TAO_Pseudo_Var_T< T >::_retn(), ACE_CATCHANY, ACE_ENDTRY, ACE_ENV_ARG_PARAMETER, ACE_GUARD_RETURN, ACE_TRY_CHECK, ACE_TRY_NEW_ENV, implrepo_service_, CORBA::is_nil(), CORBA::Object_var, orb_, CORBA::ORB::resolve_initial_references(), TAO_SYNCH_MUTEX, and use_implrepo_. { if (!this->use_implrepo_) return CORBA::Object::_nil (); if (CORBA::is_nil (this->implrepo_service_)) { ACE_TRY_NEW_ENV { CORBA::Object_var temp = this->orb_->resolve_initial_references ("ImplRepoService" ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->lock_, CORBA::Object::_nil ()); // @@ Worry about assigning a different IOR? (brunsch) this->implrepo_service_ = temp._retn (); } ACE_CATCHANY { // Just make sure that we have a null pointer. Ignore the exception // anyway. this->implrepo_service_ = CORBA::Object::_nil (); } ACE_ENDTRY; } return CORBA::Object::_duplicate (this->implrepo_service_); }

ACE_INLINE CORBA::Boolean TAO_ORB_Core::imr_endpoints_in_ior (  void   )

Do we put the ImR's endpoints into persistent object references we create. Definition at line 385 of file ORB_Core.i. References imr_endpoints_in_ior_. { return imr_endpoints_in_ior_; }

int TAO_ORB_Core::init (  int &  argc, char **  argv )  [protected]

Initialize the guts of the ORB Core. It is intended that this be called by <CORBA::ORB_init>.

ACE_INLINE TAO_ORB_Core::InitRefMap * TAO_ORB_Core::init_ref_map (  void   )

Return a pointer to the -ORBInitRef map. Definition at line 204 of file ORB_Core.i. References init_ref_map_. Referenced by CORBA::ORB::resolve_initial_references(). { return &this->init_ref_map_; }

CORBA::Long TAO_ORB_Core::initialize_object (  TAO_Stub *  the_stub, CORBA::Object_ptr  obj )

Initialize a new object, use the adapter registry to initialize a collocated object, if not possible then initialize a regular object. NOTE: Why would this method be required? The answer is if the user decides to use lazy initialization of CORBA object, then this is the route that we have to take to do the initialization. Definition at line 2028 of file ORB_Core.cpp. References TAO_Stub::base_profiles(), initialize_object_i(), and CORBA::Object_ptr. Referenced by CORBA::Object::tao_object_initialize(). { // @@ What about forwarding. With this approach we are never forwarded // when we use collocation! const TAO_MProfile &mprofile = stub->base_profiles (); return initialize_object_i (stub, mprofile); }

CORBA::Long TAO_ORB_Core::initialize_object_i (  TAO_Stub *  the_stub, const TAO_MProfile &  mprofile )  [protected]

Common code from ::initialize_object and ::reinitialize_object. Definition at line 2049 of file ORB_Core.cpp. References _incr_refcnt(), ACE_GUARD_RETURN, adapter_registry(), TAO::ORB_Table::begin(), TAO::ORB_Table::end(), TAO_ORB_Core_Auto_Ptr::get(), TAO_Adapter_Registry::initialize_collocated_object(), TAO::ORB_Table::instance(), is_collocation_enabled(), and TAO_SYNCH_MUTEX. Referenced by initialize_object(), and reinitialize_object(). { CORBA::Long retval = 0; TAO_ORB_Core_Auto_Ptr collocated_orb_core; { // Lock the ORB_Table against concurrent modification while we // iterate through the ORBs. ACE_MT (ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, guard, TAO::ORB_Table::instance()->lock_, 0)); TAO::ORB_Table * const table = TAO::ORB_Table::instance (); TAO::ORB_Table::iterator const end = table->end (); for (TAO::ORB_Table::iterator i = table->begin (); i != end; ++i) { TAO_ORB_Core * const other_core = (*i).second.core (); if (this->is_collocation_enabled (other_core, mprofile)) { other_core->_incr_refcnt (); TAO_ORB_Core_Auto_Ptr tmp_auto_ptr (other_core); collocated_orb_core = tmp_auto_ptr; break; } } } if (collocated_orb_core.get ()) { TAO_Adapter_Registry *ar = collocated_orb_core.get ()->adapter_registry (); retval = ar->initialize_collocated_object (stub); } return retval; }

ACE_Allocator * TAO_ORB_Core::input_cdr_buffer_allocator (  void   )

This allocator is always global and has no locks. It is intended for allocating the buffers used in *incoming* CDR streams. Definition at line 2795 of file ORB_Core.cpp. References TAO_Thread_Lane_Resources::input_cdr_buffer_allocator(), and lane_resources(). Referenced by create_input_cdr_data_block(), and CORBA::Object::tao_object_initialize(). { return this->lane_resources ().input_cdr_buffer_allocator (); }

ACE_Allocator * TAO_ORB_Core::input_cdr_dblock_allocator (  void   )

This allocator is global, may or may not have locks. It is intended for allocating the ACE_Data_Blocks used in *incoming* CDR streams. Definition at line 2789 of file ORB_Core.cpp. References TAO_Thread_Lane_Resources::input_cdr_dblock_allocator(), and lane_resources(). Referenced by create_input_cdr_data_block(), TAO_Transport::handle_input_parse_data(), TAO_GIOP_Message_Base::process_request_message(), and CORBA::Object::tao_object_initialize(). { return this->lane_resources ().input_cdr_dblock_allocator (); }

ACE_Allocator * TAO_ORB_Core::input_cdr_msgblock_allocator (  void   )

This allocator is always global and has no locks. It is intended for allocating the buffers used in *incoming* CDR streams. Definition at line 2801 of file ORB_Core.cpp. References TAO_Thread_Lane_Resources::input_cdr_msgblock_allocator(), and lane_resources(). Referenced by TAO_GIOP_Message_Lite::make_queued_data(), TAO_GIOP_Message_Base::make_queued_data(), TAO_GIOP_Message_Base::process_request_message(), and CORBA::Object::tao_object_initialize(). { return this->lane_resources ().input_cdr_msgblock_allocator (); }

TAO_IORInterceptor_Adapter * TAO_ORB_Core::ior_interceptor_adapter (  void   )

Get the IOR Interceptor adapter. If not created, this method will try to create one. Definition at line 3249 of file ORB_Core.cpp. References ACE_ANY_EXCEPTION, ACE_CATCHANY, ACE_CHECK_RETURN, ACE_DECLARE_NEW_CORBA_ENV, ACE_ENDTRY, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_GUARD_RETURN, ACE_PRINT_EXCEPTION, ACE_TEXT_CHAR_TO_TCHAR, ACE_TRY, ACE_TRY_CHECK, configuration(), TAO_IORInterceptor_Adapter_Factory::create(), ior_interceptor_adapter_, iorinterceptor_adapter_factory_name(), and TAO_SYNCH_MUTEX. Referenced by add_interceptor(). { if (this->ior_interceptor_adapter_ == 0) { ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->lock_, 0); if (this->ior_interceptor_adapter_ == 0) { ACE_DECLARE_NEW_CORBA_ENV; ACE_TRY { TAO_IORInterceptor_Adapter_Factory * ior_ap_factory = ACE_Dynamic_Service<TAO_IORInterceptor_Adapter_Factory>::instance (this->configuration (), ACE_TEXT_CHAR_TO_TCHAR (TAO_ORB_Core::iorinterceptor_adapter_factory_name ())); if (ior_ap_factory) { this->ior_interceptor_adapter_ = ior_ap_factory->create (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } } ACE_CATCHANY { ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Cannot initialize the " "ior_interceptor_adapter \n"); } ACE_ENDTRY; ACE_CHECK_RETURN(0); } } return this->ior_interceptor_adapter_; }

const char * TAO_ORB_Core::iorinterceptor_adapter_factory_name (  void   )  [static]

Gets the value of TAO_ORB_Core::iorinterceptor_adapter_factory_name_. Definition at line 1500 of file ORB_Core.cpp. References TAO_ORB_Core_Static_Resources::instance(), and TAO_ORB_Core_Static_Resources::iorinterceptor_adapter_factory_name_. { return TAO_ORB_Core_Static_Resources::instance ()->iorinterceptor_adapter_factory_name_.c_str(); }

void TAO_ORB_Core::iorinterceptor_adapter_factory_name (  const char *  name  )  [static]

Sets the value of TAO_ORB_Core::iorinterceptor_adapter_factory_name_. Definition at line 1494 of file ORB_Core.cpp. References TAO_ORB_Core_Static_Resources::instance(), and TAO_ORB_Core_Static_Resources::iorinterceptor_adapter_factory_name_. Referenced by ior_interceptor_adapter(). { TAO_ORB_Core_Static_Resources::instance ()->iorinterceptor_adapter_factory_name_ = name; }

int TAO_ORB_Core::is_collocated (  const TAO_MProfile &  mprofile  )

See if we have a collocated address, if yes, return the POA associated with the address. Definition at line 2109 of file ORB_Core.cpp. References TAO_Thread_Lane_Resources_Manager::is_collocated(), and thread_lane_resources_manager(). Referenced by is_collocation_enabled(). { // @@ Lots of issues arise when dealing with collocation. What about // forwarding or what if this is a multi-profile IOR where the order is // significant and only one of the profiles is collocated. For example // when using a multiple servers for fault tolerance. For now, we just // look through all profiles and if any are colocated then we assume // the object is collocated. // @@ Note, if collocated we can not be forwarded! // Also, acceptor_registry_->is_collocated (...) will check the // address (ORB Host) but not the object_key. This should be checked // also. return this->thread_lane_resources_manager ().is_collocated (mprofile); }

CORBA::Boolean TAO_ORB_Core::is_collocation_enabled (  TAO_ORB_Core *  other_orb, const TAO_MProfile &  mp )  [private]

Checks to see whether collocation optimizations have to be applied on objects in the other_orb Definition at line 2093 of file ORB_Core.cpp. References is_collocated(), optimize_collocation_objects(), and use_global_collocation(). Referenced by create_object(), and initialize_object_i(). { if (!orb_core->optimize_collocation_objects ()) return 0; if (!orb_core->use_global_collocation () && orb_core != this) return 0; if (!orb_core->is_collocated (mp)) return 0; return 1; }

ACE_INLINE CORBA::Boolean TAO_ORB_Core::is_permanent_forward_condition (  const CORBA::Object_ptr  obj, const TAO_Service_Context &  service_context )

Verify condition for permanent forward is given, both parameters must provide group attributes. Definition at line 638 of file ORB_Core.i. References TAO_Service_Callbacks::is_permanent_forward_condition(), and CORBA::Object_ptr. Referenced by TAO::Synch_Twoway_Invocation::check_reply_status(), TAO_ServerRequest::init_reply(), and TAO_GIOP_Message_Base::process_request(). { const TAO_Service_Callbacks *service_callback = this->fault_tolerance_service ().service_callback (); const CORBA::Boolean permanent_forward_condition = service_callback && service_callback->is_permanent_forward_condition (obj, service_context); return permanent_forward_condition; }

ACE_INLINE TAO_Service_Callbacks::Profile_Equivalence TAO_ORB_Core::is_profile_equivalent (  const TAO_Profile *  this_p, const TAO_Profile *  that_p )

For details on how this is used please see the FT service Definition at line 145 of file ORB_Core.i. References ft_service_, TAO_Service_Callbacks::is_profile_equivalent(), and TAO_Fault_Tolerance_Service::service_callback(). Referenced by TAO_Profile::is_equivalent_hook(). { TAO_Service_Callbacks::Profile_Equivalence retval = TAO_Service_Callbacks::DONT_KNOW; if (this->ft_service_.service_callback ()) { retval = this->ft_service_.service_callback ()->is_profile_equivalent (this_p, that_p); } return retval; }

TAO_Thread_Lane_Resources & TAO_ORB_Core::lane_resources (  void   )

Get access to the thread lane resources. Definition at line 2421 of file ORB_Core.cpp. References TAO_Thread_Lane_Resources_Manager::lane_resources(), and thread_lane_resources_manager(). Referenced by TAO_IIOP_Connection_Handler::add_transport_to_cache(), TAO_Connector::connect(), connector_registry(), TAO_Tagged_Profile::extract_object_key(), TAO::Profile_Transport_Resolver::find_transport(), input_cdr_buffer_allocator(), input_cdr_dblock_allocator(), input_cdr_msgblock_allocator(), leader_follower(), TAO_Creation_Strategy< SVC_HANDLER >::make_svc_handler(), output_cdr_buffer_allocator(), output_cdr_dblock_allocator(), output_cdr_msgblock_allocator(), TAO_Connector::parallel_connect(), TAO_IIOP_Transport::set_bidir_context_info(), TAO_Transport::transport_cache_manager(), and transport_message_buffer_allocator(). { return this->thread_lane_resources_manager ().lane_resources (); }

TAO_Leader_Follower & TAO_ORB_Core::leader_follower (  void   )

Get access to the leader_follower class. Definition at line 2128 of file ORB_Core.cpp. References lane_resources(), and TAO_Thread_Lane_Resources::leader_follower(). Referenced by TAO_Leader_Follower_Flushing_Strategy::flush_message(), reactor(), run(), TAO_Wait_On_Leader_Follower::wait(), and TAO_LF_Connect_Strategy::wait_i(). { return this->lane_resources ().leader_follower (); }

TAO_LF_Strategy & TAO_ORB_Core::lf_strategy (  void   )

Get access to the leader follower strategy. Definition at line 2134 of file ORB_Core.cpp. References TAO_Thread_Lane_Resources_Manager::lf_strategy(), and thread_lane_resources_manager(). Referenced by TAO_GIOP_Message_Lite::process_request_message(), TAO_GIOP_Message_Base::process_request_message(), and run(). { return this->thread_lane_resources_manager ().lf_strategy (); }

CORBA::ORB::ObjectIdList * TAO_ORB_Core::list_initial_references (   )

List all the service known by the ORB. Definition at line 2730 of file ORB_Core.cpp. References TAO_Seq_Var_Base_T< T >::_retn(), ACE_CHECK_RETURN, ACE_NEW_THROW_EX, ACE_Array_Map< Key, Value, EqualTo >::begin(), TAO_Object_Ref_Table::begin(), TAO_Object_Ref_Table::current_size(), ACE_Array_Map< Key, Value, EqualTo >::end(), TAO_Object_Ref_Table::end(), init_ref_map_, object_ref_table_, CORBA::ORB::ObjectIdList, CORBA::ORB::ObjectIdList_var, ACE_Array_Map< Key, Value, EqualTo >::size(), CORBA::string_dup(), and TAO_LIST_OF_INITIAL_SERVICES. Referenced by CORBA::ORB::list_initial_services(). { // Unsupported initial services should NOT be included in the below list! static const char *initial_services[] = { TAO_LIST_OF_INITIAL_SERVICES }; // Make sure the "terminating" zero is the last array element so // that there is a stop condition when iterating through the list. static const size_t initial_services_size = sizeof (initial_services) / sizeof (initial_services[0]); const size_t total_size = initial_services_size + this->init_ref_map_.size () + this->object_ref_table_.current_size (); CORBA::ORB::ObjectIdList *tmp = 0; ACE_NEW_THROW_EX (tmp, CORBA::ORB::ObjectIdList ( static_cast<CORBA::ULong> (total_size)), CORBA::NO_MEMORY ()); ACE_CHECK_RETURN (0); CORBA::ORB::ObjectIdList_var list (tmp); list->length (static_cast<CORBA::ULong> (total_size)); CORBA::ULong index = 0; // Index for ObjectIdList members. // Iterate over the registered initial references. for (index = 0; index < initial_services_size; ++index) list[index] = initial_services[index]; // Now iterate over the initial references created by the user and // add them to the sequence. // References registered via // ORBInitInfo::register_initial_reference(). TAO_Object_Ref_Table::iterator const obj_ref_end = this->object_ref_table_.end (); for (TAO_Object_Ref_Table::iterator i = this->object_ref_table_.begin (); i != obj_ref_end; ++i, ++index) list[index] = CORBA::string_dup ((*i).first.in ()); // References registered via INS. InitRefMap::iterator const end = this->init_ref_map_.end (); for (InitRefMap::iterator j = this-> init_ref_map_.begin (); j != end; ++j, ++index) list[index] = (*j).second.c_str (); return list._retn (); }

void TAO_ORB_Core::load_policy_validators (  TAO_Policy_Validator &  validator  )

Call the libraries to handover the validators if they havent registered yet with the list of validators. Definition at line 1953 of file ORB_Core.cpp. References ACE_ENV_ARG_PARAMETER, ACE_TEXT, bidir_adapter_, configuration(), and TAO_BiDir_Adapter::load_policy_validators(). { if (this->bidir_adapter_ == 0) { this->bidir_adapter_ = ACE_Dynamic_Service<TAO_BiDir_Adapter>::instance (this->configuration (), ACE_TEXT ("BiDirGIOP_Loader")); } // Call the BiDir library if it has been loaded if (this->bidir_adapter_) this->bidir_adapter_->load_policy_validators (validator ACE_ENV_ARG_PARAMETER); }

ACE_INLINE ACE_Lock * TAO_ORB_Core::locking_strategy (  void   )

Return the locking strategy used for the data blocks. Definition at line 38 of file ORB_Core.i. References data_block_lock_, resource_factory(), and TAO_Resource_Factory::use_locked_data_blocks(). Referenced by TAO_Transport::handle_input_parse_data(). { if (this->resource_factory ()->use_locked_data_blocks ()) return &this->data_block_lock_; return 0; }

ACE_INLINE void TAO_ORB_Core::not_default (  const char *  orb_id  )

Choose to be not a default ORB when there is more than one ORB. Definition at line 217 of file ORB_Core.i. References TAO::ORB_Table::instance(), and TAO::ORB_Table::not_default(). { TAO::ORB_Table * const table = TAO::ORB_Table::instance (); table->not_default (orb_id); }

ACE_INLINE CORBA::Boolean TAO_ORB_Core::object_is_nil (  CORBA::Object_ptr  object  )

The loaded service would determine if the CORBA::Object_ptr is actually nil or not. This would be useful to accomodate new enhanced definitions as defined by the service specification. Definition at line 132 of file ORB_Core.i. References ft_service_, TAO_Service_Callbacks::object_is_nil(), CORBA::Object_ptr, and TAO_Fault_Tolerance_Service::service_callback(). Referenced by CORBA::Object::is_nil_i(). { CORBA::Boolean retval = 0; if (this->ft_service_.service_callback ()) { retval = this->ft_service_.service_callback ()->object_is_nil (obj); } return retval; }

ACE_INLINE TAO::ObjectKey_Table & TAO_ORB_Core::object_key_table (  void   )

Acceessor to the table that stores the object_keys. Definition at line 65 of file ORB_Core.i. References object_key_table_. Referenced by TAO_Profile::decode(), TAO_IIOP_Profile::parse_string_i(), TAO_Profile::TAO_Profile(), and TAO_Profile::~TAO_Profile(). { return this->object_key_table_; }

ACE_INLINE TAO_Object_Ref_Table & TAO_ORB_Core::object_ref_table (  void   )

Return the table that maps object key/name to de-stringified object reference. It is needed for supporting local objects in the resolve_initial_references() mechanism. Definition at line 59 of file ORB_Core.i. References object_ref_table_. Referenced by CORBA::ORB::register_initial_reference(), CORBA::ORB::resolve_initial_references(), and resolve_rt_orb(). { return this->object_ref_table_; }

void TAO_ORB_Core::operator= (  const TAO_ORB_Core &   )  [private]

ACE_INLINE CORBA::Boolean TAO_ORB_Core::optimize_collocation_objects (  void   )  const

Definition at line 230 of file ORB_Core.i. References opt_for_collocation_. { return this->opt_for_collocation_; }

ACE_INLINE void TAO_ORB_Core::optimize_collocation_objects (  CORBA::Boolean  opt  )

Definition at line 224 of file ORB_Core.i. References opt_for_collocation_. Referenced by is_collocation_enabled(). { this->opt_for_collocation_ = opt; }

ACE_INLINE CORBA::ORB_ptr TAO_ORB_Core::orb (  void   )

Get pointer to the ORB. Definition at line 186 of file ORB_Core.i. References orb_. Referenced by TAO_Profile::get_policies(), TAO_ServerRequest::orb(), resolve_rir(), and TAO_Profile::verify_orb_configuration(). { return this->orb_; }

ACE_INLINE TAO_ORB_Parameters * TAO_ORB_Core::orb_params (  void   )

Accessor for the ORB parameters. Definition at line 254 of file ORB_Core.i. References orb_params_. Referenced by TAO_IIOP_Connection_Handler::close_connection(), codeset_manager(), TAO_IIOP_Acceptor::create_new_profile(), TAO_IIOP_Acceptor::create_profile(), TAO_IIOP_Acceptor::create_shared_profile(), TAO_Profile::create_tagged_profile(), TAO_IIOP_Profile::decode_profile(), TAO_Profile::encode(), TAO_Transport::handle_input_parse_data(), TAO_IIOP_Acceptor::hostname(), TAO_IIOP_Connector::make_parallel_connection(), TAO_MCAST_Parser::multicast_query(), TAO_IIOP_Endpoint::next_filtered(), CORBA::ORB::object_to_string(), TAO_IIOP_Connection_Handler::open(), TAO_IIOP_Acceptor::open(), TAO_Acceptor_Registry::open_default(), TAO_Default_Thread_Lane_Resources_Manager::open_default_resources(), TAO_IIOP_Acceptor::open_i(), TAO_IIOP_Acceptor::probe_interfaces(), TAO_GIOP_Message_Lite::process_request_message(), TAO_GIOP_Message_Base::process_request_message(), resolve_rir(), CORBA::ORB::resolve_service(), TAO_ServerRequest::send_cached_reply(), TAO_GIOP_Message_Lite::send_reply_exception(), set_endpoint_helper(), TAO_ServerRequest::tao_send_reply_exception(), TAO::Profile_Transport_Resolver::use_parallel_connect(), and TAO_Profile::verify_orb_configuration(). { return &(this->orb_params_); }

ACE_INLINE const char * TAO_ORB_Core::orbid (  void   )  const

Return ORBid string. Definition at line 367 of file ORB_Core.i. References orbid_. { return this->orbid_; }

ACE_INLINE TAO::ORBInitializer_Registry_Adapter * TAO_ORB_Core::orbinitializer_registry (  void   )

Return pointer to the orb initializer registry associated with this ORB core. Tries to load the PI library if it is not loaded yet Definition at line 457 of file ORB_Core.i. References ACE_GUARD_RETURN, orbinitializer_registry_, orbinitializer_registry_i(), and TAO_SYNCH_MUTEX. Referenced by CORBA::ORB_init(). { ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, mon, this->lock_, 0); if (orbinitializer_registry_ == 0) { return this->orbinitializer_registry_i (); } return this->orbinitializer_registry_; }

TAO::ORBInitializer_Registry_Adapter * TAO_ORB_Core::orbinitializer_registry_i (  void   )  [protected]

Return pointer to the orb initializer registry associated with this ORB core. Definition at line 1618 of file ORB_Core.cpp. References ACE_DYNAMIC_SERVICE_DIRECTIVE, ACE_TEXT, configuration(), orbinitializer_registry_, and ACE_Service_Gestalt::process_directive(). Referenced by orbinitializer_registry(). { // If not, lookup it up. this->orbinitializer_registry_ = ACE_Dynamic_Service<TAO::ORBInitializer_Registry_Adapter>::instance (this->configuration (), ACE_TEXT ("ORBInitializer_Registry")); #if !defined (TAO_AS_STATIC_LIBS) // In case we build shared, try to load the PI Client library, in a // static build we just can't do this, so don't try it, lower layers // output an error then. if (orbinitializer_registry_ == 0) { this->configuration ()->process_directive ( ACE_DYNAMIC_SERVICE_DIRECTIVE("ORBInitializer_Registry", "TAO_PI", "_make_ORBInitializer_Registry", "")); orbinitializer_registry_ = ACE_Dynamic_Service<TAO::ORBInitializer_Registry_Adapter>::instance (this->configuration (), ACE_TEXT ("ORBInitializer_Registry")); } #endif /* !TAO_AS_STATIC_LIBS */ return this->orbinitializer_registry_; }

ACE_Allocator * TAO_ORB_Core::output_cdr_buffer_allocator (  void   )

This allocator is always TSS and has no locks. It is intended for allocating the buffers used in *outgoing* CDR streams. Definition at line 2814 of file ORB_Core.cpp. References lane_resources(), and TAO_Thread_Lane_Resources::output_cdr_buffer_allocator(). Referenced by TAO_GIOP_Message_Lite::send_reply_exception(). { return this->lane_resources ().output_cdr_buffer_allocator (); }

ACE_Allocator * TAO_ORB_Core::output_cdr_dblock_allocator (  void   )

This allocator is always TSS and has no locks. It is intended for allocating the ACE_Data_Blocks used in *outgoing* CDR streams. Definition at line 2807 of file ORB_Core.cpp. References lane_resources(), and TAO_Thread_Lane_Resources::output_cdr_dblock_allocator(). Referenced by TAO_Profile::create_tagged_profile(), TAO_Profile::encode(), CORBA::ORB::object_to_string(), TAO_GIOP_Message_Lite::process_request_message(), TAO_ServerRequest::send_cached_reply(), TAO_GIOP_Message_Lite::send_reply_exception(), and TAO_ServerRequest::tao_send_reply_exception(). { return this->lane_resources ().output_cdr_dblock_allocator (); }

ACE_Allocator * TAO_ORB_Core::output_cdr_msgblock_allocator (  void   )

This allocator is always TSS and has no locks. It is intended for allocating the ACE_Data_Blocks used in *outgoing* CDR streams. Definition at line 2821 of file ORB_Core.cpp. References lane_resources(), and TAO_Thread_Lane_Resources::output_cdr_msgblock_allocator(). Referenced by TAO_Profile::create_tagged_profile(), TAO_Profile::encode(), CORBA::ORB::object_to_string(), TAO_GIOP_Message_Lite::process_request_message(), TAO_ServerRequest::send_cached_reply(), TAO_GIOP_Message_Lite::send_reply_exception(), and TAO_ServerRequest::tao_send_reply_exception(). { return this->lane_resources ().output_cdr_msgblock_allocator (); }

ACE_INLINE TAO_Parser_Registry * TAO_ORB_Core::parser_registry (  void   )

Get the IOR parser registry. Definition at line 271 of file ORB_Core.i. References parser_registry_. Referenced by CORBA::ORB::string_to_object(). { return &this->parser_registry_; }

ACE_INLINE void TAO_ORB_Core::pi_current (  CORBA::Object_ptr  current  )

Set the pointer to the cached TAO::PICurrent object. Definition at line 613 of file ORB_Core.i. References CORBA::Object_ptr, and pi_current_. { // Not duplicated since the ORB Core's "object_ref_table" already // contains a duplicate of the PICurrent object. this->pi_current_ = current; }

ACE_INLINE CORBA::Object_ptr TAO_ORB_Core::pi_current (  void   )

Return a pointer to the cached TAO::PICurrent object. Definition at line 603 of file ORB_Core.i. References pi_current_. { // A pointer/reference to PICurrent is cached in the ORB Core since // it is accessed in the critical path (i.e. the request invocation // path). Caching it prevents additional overhead to due object // resolution from occurring. return this->pi_current_; }

TAO_Adapter * TAO_ORB_Core::poa_adapter (  void   )

Get the adapter named "RootPOA" and cache the result, this is an optimization for the POA. Definition at line 1877 of file ORB_Core.cpp. References ACE_GUARD_RETURN, adapter_registry_, TAO_Adapter_Registry::find_adapter(), poa_adapter_, and TAO_SYNCH_MUTEX. Referenced by root_poa(). { if (this->poa_adapter_ == 0) { ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->lock_, 0); if (this->poa_adapter_ == 0) { this->poa_adapter_ = this->adapter_registry_.find_adapter ("RootPOA"); } } return this->poa_adapter_; }

CORBA::Object_ptr TAO_ORB_Core::poa_current (  void   )

Todo: In the future this hook should change, instead of hardcoding the object we should add a "Resolver" to the ORB, so the "POACurrent" object returns a per-ORB object. Similarly, each ORB should implement the TSS pattern to put the POA_Current_Impl in a void* slot. The current approach *does* decouple the POA from the ORB, but it cannot add new adapters or other components transparently.

const ACE_CString & TAO_ORB_Core::poa_factory_name (  void   )  [static]

Access the POA factory name. Definition at line 1677 of file ORB_Core.cpp. References TAO_ORB_Core_Static_Resources::instance(), and TAO_ORB_Core_Static_Resources::poa_factory_name_. { return TAO_ORB_Core_Static_Resources::instance ()->poa_factory_name_; }

ACE_INLINE TAO_Policy_Current & TAO_ORB_Core::policy_current (  void   )

Accesors to the policy current, this object should be kept in TSS storage. The POA has to reset the policy current object on every upcall. Definition at line 552 of file ORB_Core.i. References policy_current_. Referenced by get_cached_policy_including_current(), get_policy_including_current(), and CORBA::ORB::resolve_policy_current(). { return *this->policy_current_; }

ACE_INLINE TAO::PolicyFactory_Registry_Adapter * TAO_ORB_Core::policy_factory_registry (  void   )

Return pointer to the policy factory registry associated with this ORB core. Definition at line 469 of file ORB_Core.i. References ACE_GUARD_RETURN, policy_factory_registry_, policy_factory_registry_i(), and TAO_SYNCH_MUTEX. Referenced by CORBA::ORB::_create_policy(), and CORBA::ORB::create_policy(). { ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, mon, this->lock_, 0); if (policy_factory_registry_ == 0) { return this->policy_factory_registry_i (); } return this->policy_factory_registry_; }

TAO::PolicyFactory_Registry_Adapter * TAO_ORB_Core::policy_factory_registry_i (  void   )  [protected]

Return pointer to the policy factory registry associated with this ORB core. Definition at line 1587 of file ORB_Core.cpp. References ACE_DYNAMIC_SERVICE_DIRECTIVE, ACE_TEXT, configuration(), TAO_PolicyFactory_Registry_Factory::create(), policy_factory_registry_, and ACE_Service_Gestalt::process_directive(). Referenced by policy_factory_registry(). { TAO_PolicyFactory_Registry_Factory *loader = ACE_Dynamic_Service<TAO_PolicyFactory_Registry_Factory>::instance (this->configuration (), ACE_TEXT ("PolicyFactory_Loader")); if (loader == 0) { this->configuration ()->process_directive ( ACE_DYNAMIC_SERVICE_DIRECTIVE("PolicyFactory_Loader", "TAO_PI", "_make_TAO_PolicyFactory_Loader", "")); loader = ACE_Dynamic_Service<TAO_PolicyFactory_Registry_Factory>::instance (this->configuration (), ACE_TEXT ("PolicyFactory_Loader")); } if (loader != 0) { this->policy_factory_registry_ = loader->create (); } return this->policy_factory_registry_; }

ACE_INLINE TAO_Policy_Manager * TAO_ORB_Core::policy_manager (  void   )

Return the Policy_Manager for this ORB. Definition at line 281 of file ORB_Core.i. References policy_manager_. Referenced by get_cached_policy(), get_policy(), and CORBA::ORB::resolve_policy_manager(). { return this->policy_manager_; }

ACE_INLINE TAO_ProtocolFactorySet * TAO_ORB_Core::protocol_factories (  void   )

Get the protocol factories. Definition at line 265 of file ORB_Core.i. References protocol_factories(), and TAO_OC_RETRIEVE. Referenced by TAO_Connector_Registry::open(), TAO_Acceptor_Registry::open(), TAO_Acceptor_Registry::open_default(), and protocol_factories(). { return TAO_OC_RETRIEVE (protocol_factories); }

TAO_Protocols_Hooks* TAO_ORB_Core::protocols_hooks (  void   )

Returns pointer to the Protocols_Hooks.

ACE_Reactor * TAO_ORB_Core::reactor (  void   )

Wrappers that forward the request to the concurrency strategy. Definition at line 2902 of file ORB_Core.cpp. References leader_follower(), and TAO_Leader_Follower::reactor(). Referenced by TAO_Connection_Handler::close_connection_eh(), TAO::Transport_Cache_Manager::find_transport(), TAO_Resume_Handle::handle_input_return_value_hook(), TAO_Transport::notify_reactor(), TAO_Transport::register_handler(), TAO_Leader_Follower::reset_client_thread(), TAO_Resume_Handle::resume_handle(), run(), TAO_Leader_Follower::set_client_thread(), TAO_Wait_On_Read::wait(), TAO_Wait_On_Reactor::wait(), and CORBA::ORB::work_pending(). { return this->leader_follower ().reactor (); }

int TAO_ORB_Core::register_handle (  ACE_HANDLE  handle  )

Register the handle of an open connection with the ORB Core handle set. This handle set will be used to explicitly remove corresponding event handlers from the reactor.

CORBA::Long TAO_ORB_Core::reinitialize_object (  TAO_Stub *  stub  )

Reinitialise a stub after the effective profile has changed. This will happen after a location forward has been received or if a location forward supplied new target subsequently fails. Definition at line 2041 of file ORB_Core.cpp. References TAO_Stub::base_profiles(), TAO_Stub::forward_profiles(), and initialize_object_i(). { return initialize_object_i (stub, stub->forward_profiles () ? *(stub->forward_profiles ()) : stub->base_profiles ()); }

int TAO_ORB_Core::remove_handle (  ACE_HANDLE  handle  )

Remove from the ORB Core's handle set so that it isn't included in the set that is passed to the reactor upon ORB destruction.

void TAO_ORB_Core::request_dispatcher (  TAO_Request_Dispatcher *  rd  )

Set a new request dispatcher. The ORB Core retains ownership of the request dispatcher once it gets it. Currently, this only gets called at initialization. Definition at line 1906 of file ORB_Core.cpp. References request_dispatcher_. { // Assume ownership of the request dispatcher. TAO_Request_Dispatcher *tmp = this->request_dispatcher_; this->request_dispatcher_ = request_dispatcher; delete tmp; }

ACE_INLINE TAO_Request_Dispatcher * TAO_ORB_Core::request_dispatcher (  void   )

Return the current request dispatcher strategy. Definition at line 198 of file ORB_Core.i. References request_dispatcher_. Referenced by TAO::Collocated_Invocation::invoke(), TAO_GIOP_Message_Base::process_locate_request(), and TAO_GIOP_Message_Base::process_request(). { return this->request_dispatcher_; }

ACE_INLINE void TAO_ORB_Core::reset_service_profile_flags (  void   )

Reset the flags in the loaded services. Definition at line 117 of file ORB_Core.i. References ft_service_, TAO_Service_Callbacks::reset_profile_flags(), and TAO_Fault_Tolerance_Service::service_callback(). { // @@ If different services have the same feature we may want to // prioritise them here. We need to decide here whose selection of // profile is more important. if (this->ft_service_.service_callback ()) { this->ft_service_.service_callback ()->reset_profile_flags (); } return; }

ACE_INLINE CORBA::Object_ptr TAO_ORB_Core::resolve_codecfactory (   )

Resolve the CodecFactory DLL. Definition at line 421 of file ORB_Core.i. References CORBA::Object::_duplicate(), ACE_CHECK_RETURN, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_GUARD_RETURN, CORBA::is_nil(), resolve_codecfactory_i(), and TAO_SYNCH_MUTEX. Referenced by CORBA::ORB::resolve_initial_references(). { ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, mon, this->lock_, CORBA::Object::_nil ()); if (CORBA::is_nil (this->codec_factory_)) { this->resolve_codecfactory_i (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (CORBA::Object::_nil ()); } return CORBA::Object::_duplicate (this->codec_factory_); }

void TAO_ORB_Core::resolve_codecfactory_i (   )  [protected]

Obtain and cache the codec factory object reference. Definition at line 2460 of file ORB_Core.cpp. References ACE_CHECK, ACE_DYNAMIC_SERVICE_DIRECTIVE, ACE_ENV_ARG_PARAMETER, ACE_TEXT, codec_factory_, configuration(), TAO_Object_Loader::create_object(), and ACE_Service_Gestalt::process_directive(). Referenced by resolve_codecfactory(). { TAO_Object_Loader *loader = ACE_Dynamic_Service<TAO_Object_Loader>::instance (this->configuration (), ACE_TEXT ("CodecFactory_Loader")); if (loader == 0) { this->configuration()->process_directive (ACE_DYNAMIC_SERVICE_DIRECTIVE("CodecFactory", "TAO_CodecFactory", "_make_TAO_CodecFactory_Loader", "")); loader = ACE_Dynamic_Service<TAO_Object_Loader>::instance (this->configuration (), ACE_TEXT ("CodecFactory_Loader")); } if (loader != 0) { this->codec_factory_ = loader->create_object (this->orb_, 0, 0 ACE_ENV_ARG_PARAMETER); ACE_CHECK; } }

ACE_INLINE CORBA::Object_ptr TAO_ORB_Core::resolve_dynanyfactory (   )

Resolve the Dynamic Any Factory. Definition at line 481 of file ORB_Core.i. References CORBA::Object::_duplicate(), ACE_CHECK_RETURN, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_GUARD_RETURN, CORBA::is_nil(), resolve_dynanyfactory_i(), and TAO_SYNCH_MUTEX. Referenced by CORBA::ORB::resolve_initial_references(). { ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, mon, this->lock_, CORBA::Object::_nil ()); if (CORBA::is_nil (this->dynany_factory_)) { this->resolve_dynanyfactory_i (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (CORBA::Object::_nil ()); } return CORBA::Object::_duplicate (this->dynany_factory_); }

void TAO_ORB_Core::resolve_dynanyfactory_i (   )  [protected]

Obtain and cache the dynamic any factory object reference. Definition at line 2552 of file ORB_Core.cpp. References ACE_CHECK, ACE_DYNAMIC_SERVICE_DIRECTIVE, ACE_ENV_ARG_PARAMETER, ACE_TEXT, configuration(), TAO_Object_Loader::create_object(), dynany_factory_, and ACE_Service_Gestalt::process_directive(). Referenced by resolve_dynanyfactory(). { TAO_Object_Loader *loader = ACE_Dynamic_Service<TAO_Object_Loader>::instance (this->configuration (), ACE_TEXT ("DynamicAny_Loader")); if (loader == 0) { this->configuration ()->process_directive (ACE_DYNAMIC_SERVICE_DIRECTIVE("DynamicAny_Loader", "TAO_DynamicAny", "_make_TAO_DynamicAny_Loader", "")); loader = ACE_Dynamic_Service<TAO_Object_Loader>::instance (this->configuration (), ACE_TEXT ("DynamicAny_Loader")); } if (loader != 0) { this->dynany_factory_ = loader->create_object (this->orb_, 0, 0 ACE_ENV_ARG_PARAMETER); ACE_CHECK; } }

ACE_INLINE CORBA::Object_ptr TAO_ORB_Core::resolve_ior_manipulation (   )

Resolve the IOR Manipulation reference for this ORB. Definition at line 494 of file ORB_Core.i. References CORBA::Object::_duplicate(), ACE_CHECK_RETURN, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_GUARD_RETURN, CORBA::is_nil(), resolve_iormanipulation_i(), and TAO_SYNCH_MUTEX. Referenced by CORBA::ORB::resolve_initial_references(). { ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, mon, this->lock_, CORBA::Object::_nil ()); if (CORBA::is_nil (this->ior_manip_factory_)) { this->resolve_iormanipulation_i (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (CORBA::Object::_nil ()); } return CORBA::Object::_duplicate (this->ior_manip_factory_); }

ACE_INLINE CORBA::Object_ptr TAO_ORB_Core::resolve_ior_table (   )

Resolve the IOR Table reference for this ORB. Definition at line 507 of file ORB_Core.i. References CORBA::Object::_duplicate(), ACE_CHECK_RETURN, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_GUARD_RETURN, CORBA::is_nil(), resolve_ior_table_i(), and TAO_SYNCH_MUTEX. Referenced by CORBA::ORB::resolve_initial_references(). { ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, mon, this->lock_, CORBA::Object::_nil ()); if (CORBA::is_nil (this->ior_table_)) { this->resolve_ior_table_i (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (CORBA::Object::_nil ()); } return CORBA::Object::_duplicate (this->ior_table_); }

void TAO_ORB_Core::resolve_ior_table_i (   )  [private]

Obtain and cache the dynamic any factory object reference. Definition at line 2609 of file ORB_Core.cpp. References TAO_Pseudo_Var_T< T >::_retn(), ACE_CHECK, ACE_DYNAMIC_SERVICE_DIRECTIVE, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_TEXT, adapter_registry_, configuration(), TAO_Adapter_Factory::create(), ACE_Auto_Basic_Ptr< X >::get(), TAO_Adapter_Registry::insert(), ior_table_, CORBA::Object_var, ACE_Service_Gestalt::process_directive(), and ACE_Auto_Basic_Ptr< X >::release(). Referenced by resolve_ior_table(). { TAO_Adapter_Factory *factory = ACE_Dynamic_Service<TAO_Adapter_Factory>::instance (this->configuration (), ACE_TEXT ("TAO_IORTable")); if (factory == 0) { this->configuration ()->process_directive (ACE_DYNAMIC_SERVICE_DIRECTIVE("TAO_IORTable", "TAO_IORTable", "_make_TAO_Table_Adapter_Factory", "")); factory = ACE_Dynamic_Service<TAO_Adapter_Factory>::instance (this->configuration (), ACE_TEXT ("TAO_IORTable")); } if (factory != 0) { ACE_Auto_Ptr <TAO_Adapter> iortable_adapter (factory->create (this)); iortable_adapter->open (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; CORBA::Object_var tmp_root = iortable_adapter->root (); this->adapter_registry_.insert (iortable_adapter.get () ACE_ENV_ARG_PARAMETER); ACE_CHECK; // It is now (exception) safe to release ownership from the auto pointers this->ior_table_= tmp_root._retn (); iortable_adapter.release (); } }

void TAO_ORB_Core::resolve_iormanipulation_i (   )  [protected]

Obtain and cache the IORManipulation factory object reference. Definition at line 2581 of file ORB_Core.cpp. References ACE_CHECK, ACE_DYNAMIC_SERVICE_DIRECTIVE, ACE_ENV_ARG_PARAMETER, ACE_TEXT, configuration(), TAO_Object_Loader::create_object(), ior_manip_factory_, and ACE_Service_Gestalt::process_directive(). Referenced by resolve_ior_manipulation(). { TAO_Object_Loader *loader = ACE_Dynamic_Service<TAO_Object_Loader>::instance (this->configuration (), ACE_TEXT ("IORManip_Loader")); if (loader == 0) { this->configuration()->process_directive (ACE_DYNAMIC_SERVICE_DIRECTIVE("IORManip_Loader", "TAO_IORManip", "_make_TAO_IORManip_Loader", "")); loader = ACE_Dynamic_Service<TAO_Object_Loader>::instance (this->configuration (), ACE_TEXT ("IORManip_Loader")); } if (loader != 0) { this->ior_manip_factory_ = loader->create_object (this->orb_, 0, 0 ACE_ENV_ARG_PARAMETER); ACE_CHECK; } }

ACE_INLINE CORBA::Object_ptr TAO_ORB_Core::resolve_picurrent (   )

Resolve the PICurrent. Definition at line 406 of file ORB_Core.i. References CORBA::Object::_duplicate(), ACE_CHECK_RETURN, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_GUARD_RETURN, CORBA::is_nil(), resolve_picurrent_i(), and TAO_SYNCH_MUTEX. Referenced by CORBA::ORB::resolve_initial_references(). { ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, mon, this->lock_, CORBA::Object::_nil ()); if (CORBA::is_nil (this->pi_current_)) { this->resolve_picurrent_i (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (CORBA::Object::_nil ()); } return CORBA::Object::_duplicate (this->pi_current_); }

void TAO_ORB_Core::resolve_picurrent_i (   )  [protected]

Obtain and cache the picurrent factory object reference. Definition at line 2519 of file ORB_Core.cpp. References ACE_CHECK, ACE_DYNAMIC_SERVICE_DIRECTIVE, ACE_ENV_ARG_PARAMETER, ACE_TEXT, configuration(), TAO_Object_Loader::create_object(), CORBA::Object_ptr, pi_current_, and ACE_Service_Gestalt::process_directive(). Referenced by resolve_picurrent(). { TAO_Object_Loader *loader = ACE_Dynamic_Service<TAO_Object_Loader>::instance (this->configuration (), ACE_TEXT ("PICurrent_Loader")); if (loader == 0) { this->configuration ()->process_directive (ACE_DYNAMIC_SERVICE_DIRECTIVE("PICurrent_Loader", "TAO_PI", "_make_TAO_PICurrent_Loader", "")); loader = ACE_Dynamic_Service<TAO_Object_Loader>::instance (this->configuration (), ACE_TEXT ("PICurrent_Loader")); } if (loader != 0) { CORBA::Object_ptr pi = loader->create_object (this->orb_, 0, 0 ACE_ENV_ARG_PARAMETER); ACE_CHECK; this->pi_current_ = pi; } }

ACE_INLINE CORBA::Object_ptr TAO_ORB_Core::resolve_poa_current (   )

Resolve POA Current. Definition at line 560 of file ORB_Core.i. References CORBA::Object::_duplicate(), ACE_CHECK_RETURN, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_GUARD_RETURN, CORBA::is_nil(), resolve_poa_current_i(), and TAO_SYNCH_MUTEX. Referenced by CORBA::ORB::resolve_initial_references(). { ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, mon, this->lock_, CORBA::Object::_nil ()); if (CORBA::is_nil (this->poa_current_.in ())) { this->resolve_poa_current_i (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (CORBA::Object::_nil ()); } return CORBA::Object::_duplicate (this->poa_current_.in ()); }

void TAO_ORB_Core::resolve_poa_current_i (   )  [protected]

Obtain and cache the poa current. Definition at line 2488 of file ORB_Core.cpp. References ACE_CHECK, ACE_DYNAMIC_SERVICE_DIRECTIVE, ACE_ENV_ARG_PARAMETER, ACE_TEXT, configuration(), TAO_Object_Loader::create_object(), poa_current_, and ACE_Service_Gestalt::process_directive(). Referenced by resolve_poa_current(). { TAO_Object_Loader *loader = ACE_Dynamic_Service<TAO_Object_Loader>::instance (this->configuration(), ACE_TEXT ("TAO_POA_Current_Factory")); if (loader == 0) { this->configuration()->process_directive (ACE_DYNAMIC_SERVICE_DIRECTIVE("TAO_POA_Current_Factory", "TAO_PortableServer", "_make_TAO_POA_Current_Factory", "")); loader = ACE_Dynamic_Service<TAO_Object_Loader>::instance (this->configuration(), ACE_TEXT ("TAO_POA_Current_Factory")); } if (loader != 0) { this->poa_current_ = loader->create_object (this->orb_, 0, 0 ACE_ENV_ARG_PARAMETER); ACE_CHECK; } }

CORBA::Object_ptr TAO_ORB_Core::resolve_rir (  const char *  name  )

Resolve an initial reference via the -ORBInitRef and. Definition at line 2669 of file ORB_Core.cpp. References CORBA::Object::_nil(), ACE_CHECK_RETURN, ACE_CString, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, connector_registry(), TAO_ORB_Parameters::default_init_ref(), TAO::String_var< charT >::in(), TAO_Connector_Registry::object_key_delimiter(), orb(), orb_params(), CORBA::ORB::string_to_object(), CORBA::String_var, ACE_OS::strlen(), and ACE_OS::strncmp(). Referenced by CORBA::ORB::resolve_initial_references(). { // Get the table of initial references specified through // -ORBInitRef. ACE_CString ior; ACE_CString object_id ((const char *) name); // Get the list of initial reference prefixes specified through // -ORBDefaultInitRef. CORBA::String_var default_init_ref = this->orb_params ()->default_init_ref (); // Check if a DefaultInitRef was specified. if (ACE_OS::strlen (default_init_ref.in ()) != 0) { static const char corbaloc_prefix[] = "corbaloc:"; static const char mcast_prefix[] = "mcast:"; char object_key_delimiter = 0; ACE_CString list_of_profiles (default_init_ref.in ()); // Check if the protocol is corbaloc: or mcast:. // If it is, set the object_key_delimiter. if ((ACE_OS::strncmp (default_init_ref.in (), corbaloc_prefix, sizeof corbaloc_prefix -1) == 0) || (ACE_OS::strncmp (default_init_ref.in (), mcast_prefix, sizeof mcast_prefix -1) == 0)) { object_key_delimiter = '/'; } else { TAO_Connector_Registry *conn_reg = this->connector_registry (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (0); // Obtain the appropriate object key delimiter for the // specified protocol. object_key_delimiter = conn_reg->object_key_delimiter (list_of_profiles.c_str ()); } // Make sure that the default initial reference doesn't end // with the object key delimiter character. if (list_of_profiles[list_of_profiles.length() - 1] != object_key_delimiter) list_of_profiles += ACE_CString (object_key_delimiter); list_of_profiles += object_id; return this->orb ()->string_to_object (list_of_profiles.c_str () ACE_ENV_ARG_PARAMETER); } return CORBA::Object::_nil (); }

ACE_INLINE CORBA::Object_ptr TAO_ORB_Core::resolve_rt_orb (  void   )

Resolve the RT ORB reference for this ORB. Definition at line 583 of file ORB_Core.i. References CORBA::Object::_duplicate(), ACE_GUARD_RETURN, CORBA::is_nil(), object_ref_table(), TAO_Object_Ref_Table::resolve_initial_reference(), rt_orb_, TAO_OBJID_RTORB, and TAO_SYNCH_MUTEX. { if (CORBA::is_nil (this->rt_orb_.in ())) { ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, mon, this->lock_, CORBA::Object::_nil ()); if (CORBA::is_nil (this->rt_orb_.in ())) { // Save a reference to the priority mapping manager. this->rt_orb_ = this->object_ref_table ().resolve_initial_reference ( TAO_OBJID_RTORB); } } return CORBA::Object::_duplicate (this->rt_orb_.in ()); }

ACE_INLINE CORBA::Object_ptr TAO_ORB_Core::resolve_typecodefactory (   )

Resolve the TypeCodeFactory DLL. Definition at line 391 of file ORB_Core.i. References CORBA::Object::_duplicate(), ACE_CHECK_RETURN, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_GUARD_RETURN, CORBA::is_nil(), resolve_typecodefactory_i(), and TAO_SYNCH_MUTEX. Referenced by CORBA::ORB::resolve_initial_references(). { ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, mon, this->lock_, CORBA::Object::_nil ()); if (CORBA::is_nil (this->typecode_factory_)) { this->resolve_typecodefactory_i (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (CORBA::Object::_nil ()); } return CORBA::Object::_duplicate (this->typecode_factory_); }

void TAO_ORB_Core::resolve_typecodefactory_i (   )  [protected]

Obtain and cache the typecode factory object reference. Definition at line 2427 of file ORB_Core.cpp. References ACE_DYNAMIC_SERVICE_DIRECTIVE, ACE_ENV_ARG_PARAMETER, ACE_ERROR, ACE_TEXT, ACE_THROW, configuration(), TAO_Object_Loader::create_object(), LM_ERROR, ACE_Service_Gestalt::process_directive(), and typecode_factory_. Referenced by resolve_typecodefactory(). { TAO_Object_Loader *loader = ACE_Dynamic_Service<TAO_Object_Loader>::instance (this->configuration (), ACE_TEXT ("TypeCodeFactory_Loader")); if (loader == 0) { this->configuration ()->process_directive (ACE_DYNAMIC_SERVICE_DIRECTIVE("TypeCodeFactory", "TAO_TypeCodeFactory", "_make_TAO_TypeCodeFactory_Loader", "")); loader = ACE_Dynamic_Service<TAO_Object_Loader>::instance (this->configuration (), ACE_TEXT ("TypeCodeFactory_Loader")); if (loader == 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) Unable to instantiate ") ACE_TEXT ("a TypeCodeFactory_Loader\n"))); ACE_THROW (CORBA::ORB::InvalidName ()); } } this->typecode_factory_ = loader->create_object (this->orb_, 0, 0 ACE_ENV_ARG_PARAMETER); }

TAO_Resource_Factory * TAO_ORB_Core::resource_factory (  void   )

Returns pointer to the resource factory. Definition at line 1518 of file ORB_Core.cpp. References ACE_CString, ACE_TEXT_CHAR_TO_TCHAR, configuration(), TAO_ORB_Core_Static_Resources::instance(), resource_factory_, and TAO_ORB_Core_Static_Resources::resource_factory_name_. Referenced by TAO_Thread_Lane_Resources::acceptor_registry(), TAO_Thread_Lane_Resources::cleanup_rw_transports(), codeset_manager(), TAO_Thread_Lane_Resources::connector_registry(), create_input_cdr_data_block(), TAO::demarshal_sequence(), fragmentation_strategy(), TAO::ObjectKey_Table::init(), locking_strategy(), CORBA::Object::Object(), TAO_Parser_Registry::open(), operator>>(), TAO_Leader_Follower::reactor(), TAO_Thread_Lane_Resources::resource_factory(), TAO_Leader_Follower::set_client_thread(), TAO_Thread_Lane_Resources::shutdown_reactor(), TAO_Asynch_Reply_Dispatcher_Base::TAO_Asynch_Reply_Dispatcher_Base(), TAO_Connection_Handler::TAO_Connection_Handler(), TAO_Thread_Lane_Resources_Manager::TAO_Thread_Lane_Resources_Manager(), TAO::Transport_Cache_Manager::Transport_Cache_Manager(), and TAO_Leader_Follower::~TAO_Leader_Follower(). { // Check if there is a cached reference. if (this->resource_factory_ != 0) { return this->resource_factory_; } // Look in the service repository for an instance. ACE_CString &resource_factory_name = TAO_ORB_Core_Static_Resources::instance ()->resource_factory_name_; this->resource_factory_ = ACE_Dynamic_Service<TAO_Resource_Factory>::instance (this->configuration (), ACE_TEXT_CHAR_TO_TCHAR (resource_factory_name.c_str())); return this->resource_factory_; }

CORBA::Object_ptr TAO_ORB_Core::root_poa (   )

Return the RootPOA, or try to load it if not initialized already. Definition at line 1813 of file ORB_Core.cpp. References CORBA::Object::_duplicate(), CORBA::Object::_nil(), ACE_CHECK_RETURN, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_GUARD_RETURN, ACE_TEXT_CHAR_TO_TCHAR, adapter_registry_, configuration(), TAO_Adapter_Factory::create(), TAO_Adapter_Registry::insert(), TAO_ORB_Core_Static_Resources::instance(), CORBA::is_nil(), TAO_Adapter::open(), poa_adapter(), TAO_ORB_Core_Static_Resources::poa_factory_directive_, TAO_ORB_Core_Static_Resources::poa_factory_name_, ACE_Service_Gestalt::process_directive(), TAO_Adapter::root(), root_poa_, and TAO_SYNCH_MUTEX. Referenced by CORBA::ORB::resolve_initial_references(). { // DCL .. if (CORBA::is_nil (this->root_poa_.in ())) { // Making sure the initialization process in the current thread uses // the correct service repository (ours), instead of the global one. ACE_Service_Config_Guard scg (this->configuration ()); TAO_ORB_Core_Static_Resources* static_resources = TAO_ORB_Core_Static_Resources::instance (); TAO_Adapter_Factory *factory = ACE_Dynamic_Service<TAO_Adapter_Factory>::instance (this->configuration (), static_resources->poa_factory_name_.c_str()); if (factory == 0) { this->configuration()->process_directive ( ACE_TEXT_CHAR_TO_TCHAR ( static_resources->poa_factory_directive_.c_str())); factory = ACE_Dynamic_Service<TAO_Adapter_Factory>::instance (this->configuration (), static_resources->poa_factory_name_.c_str()); } if (factory == 0) { return CORBA::Object::_nil (); } ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, monitor, this->open_lock_, 0); if (CORBA::is_nil (this->root_poa_.in ())) { // @@ Not exception safe TAO_Adapter *poa_adapter = factory->create (this); poa_adapter->open (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (CORBA::Object::_nil ()); // @@ Not exception safe this->root_poa_ = poa_adapter->root (); this->adapter_registry_.insert (poa_adapter ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (CORBA::Object::_nil ()); } } return CORBA::Object::_duplicate (this->root_poa_.in ()); }

int TAO_ORB_Core::run (  ACE_Time_Value *  tv, int  perform_work )

Run the event loop. Definition at line 2140 of file ORB_Core.cpp. References ACE_DEBUG, ACE_TEXT, TAO_Server_Strategy_Factory::activate_server_connections(), ETIME, TAO_LF_Event_Loop_Thread_Helper::event_loop_return(), ACE_Reactor::handle_events(), has_shutdown(), leader_follower(), lf_strategy(), LM_DEBUG, ACE_Reactor::owner(), reactor(), server_factory_, TAO_debug_level, and ACE_Thread_Manager::wait(). Referenced by TAO_Reactive_Flushing_Strategy::flush_message(), TAO_Reactive_Flushing_Strategy::flush_transport(), TAO_Leader_Follower_Flushing_Strategy::flush_transport(), CORBA::ORB::perform_work(), CORBA::ORB::run(), and TAO_Reactive_Connect_Strategy::wait_i(). { // ORB::run may be called from a thread, different from the one that // did the ORB_init, consequently we must establish the Service // Gestalt, this thread will consider "global" ACE_Service_Config_Guard use_orbs (this->configuration()); if (TAO_debug_level > 2) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) - ORB_Core::run, ") ACE_TEXT ("start [%s]\n"), perform_work?ACE_TEXT("perform_work"):ACE_TEXT("run"))); } // Fetch the Reactor ACE_Reactor *r = this->reactor (); int result = 1; // 1 to detect that nothing went wrong // Loop handling client requests until the ORB is shutdown. // We could use the leader-follower lock to check for the state // if this variable or use the lock <create_event_loop_lock> in // the server strategy factory. // We don't need to do this because we use the Reactor // mechanisms to shutdown in a thread-safe way. while (this->has_shutdown () == 0) { // Every time we perform an interation we have to become the // leader again, because it is possible that a client has // acquired the leader role... TAO_Leader_Follower &leader_follower = this->leader_follower (); TAO_LF_Strategy &lf_strategy = this->lf_strategy (); TAO_LF_Event_Loop_Thread_Helper helper (leader_follower, lf_strategy, tv); result = helper.event_loop_return (); if (result != 0) { if (errno == ETIME) return 0; else return result; } // Set the owning thread of the Reactor to the one which we're // currently in. This is necessary b/c it's possible that the // application is calling us from a thread other than that in which // the Reactor's CTOR (which sets the owner) was called. // // We need to do this on every iteration because the reactor may be // acquired by one of the client threads in the LF waiting // strategy r->owner (ACE_Thread::self ()); if (TAO_debug_level > 2) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) - ORB_Core::run, ") ACE_TEXT ( "calling handle_events()\n"))); } result = r->handle_events (tv); if (TAO_debug_level > 2) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) - ORB_Core::run, ") ACE_TEXT ("handle_events() returns %d\n"), result)); } if (result == -1) { // An error, terminate the loop break; } if (result == 0 && tv != 0 && *tv == ACE_Time_Value::zero) { // A timeout, terminate the loop... break; } if (perform_work) { // This is running on behalf of a perform_work() call, // The loop should run only once. break; } // Otherwise just continue.. } if (this->has_shutdown () == 1 && this->server_factory_->activate_server_connections ()) this->tm_.wait (); if (TAO_debug_level > 2) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) - ORB_Core::run, ") ACE_TEXT ("ends with result = %d\n"), result)); } return result; }

TAO_Server_Strategy_Factory * TAO_ORB_Core::server_factory (  void   )

Returns pointer to the server factory. Definition at line 1798 of file ORB_Core.cpp. References ACE_TEXT, configuration(), and server_factory_. Referenced by TAO_Concurrency_Strategy< SVC_HANDLER >::activate_svc_handler(). { if (this->server_factory_ == 0) { // Look in the service repository for an instance. this->server_factory_ = ACE_Dynamic_Service<TAO_Server_Strategy_Factory>::instance (this->configuration (), ACE_TEXT ("Server_Strategy_Factory")); } return this->server_factory_; }

ACE_INLINE const char * TAO_ORB_Core::server_id (  void   )  const

Resolve the RT Current flyweight for this ORB. Return server_id string. Definition at line 434 of file ORB_Core.i. References server_id_. { return this->server_id_.c_str(); }

ACE_INLINE TAO::ServerRequestInterceptor_Adapter * TAO_ORB_Core::serverrequestinterceptor_adapter (  void   )

Get the Server Request Interceptor adapter. Will not create a new one if not available yet. Definition at line 627 of file ORB_Core.i. References server_request_interceptor_adapter_. Referenced by TAO_ServerRequest::rs_pi_current(), and TAO_ServerRequest::~TAO_ServerRequest(). { return this->server_request_interceptor_adapter_; }

TAO::ServerRequestInterceptor_Adapter * TAO_ORB_Core::serverrequestinterceptor_adapter_i (  void   )  [protected]

Get the Server Request Interceptor adapter. If not created, this method will try to create one if needed. Definition at line 3420 of file ORB_Core.cpp. References ACE_GUARD_RETURN, ACE_TEXT, configuration(), TAO_ServerRequestInterceptor_Adapter_Factory::create(), server_request_interceptor_adapter_, and TAO_SYNCH_MUTEX. Referenced by add_interceptor(). { if (this->server_request_interceptor_adapter_ == 0) { ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->lock_, 0); if (this->server_request_interceptor_adapter_ == 0) { TAO_ServerRequestInterceptor_Adapter_Factory *factory = ACE_Dynamic_Service<TAO_ServerRequestInterceptor_Adapter_Factory>::instance (this->configuration (), ACE_TEXT ("ServerRequestInterceptor_Adapter_Factory")); if (factory) { this->server_request_interceptor_adapter_ = factory->create (); } } } return this->server_request_interceptor_adapter_; }

void TAO_ORB_Core::service_context_list (  TAO_Stub *  stub, TAO_Service_Context &  service_context, CORBA::Boolean  retstart )

Call the service layers with the Service Context to check whether they would like to add something to the list. Definition at line 1768 of file ORB_Core.cpp. References ACE_CHECK, ACE_ENV_ARG_PARAMETER, protocols_hooks_, and TAO_Protocols_Hooks::rt_service_context(). Referenced by TAO::Remote_Invocation::init_target_spec(). { // @NOTE: Can use Interceptors instead.. this->protocols_hooks_->rt_service_context (stub, service_context, restart ACE_ENV_ARG_PARAMETER); ACE_CHECK; }

ACE_INLINE CORBA::Boolean TAO_ORB_Core::service_profile_reselection (  TAO_Stub *  stub, TAO_Profile *&  profile )

The loaded service in the ORB_Core would determine if the profile reselection is going to be made by the services or not. If the services do make the reselection they would return the selected profile through . The reselction is for the multi-profile IORS. Definition at line 100 of file ORB_Core.i. References ft_service_, TAO_Service_Callbacks::reselect_profile(), and TAO_Fault_Tolerance_Service::service_callback(). { CORBA::Boolean retval = 0; // @@ If different services have the same feature we may want to // prioritise them here. We need to decide here whose selection of // profile is more important. if (this->ft_service_.service_callback ()) { retval = this->ft_service_.service_callback ()->reselect_profile (stub, profile); } return retval; }

ACE_INLINE CORBA::Boolean TAO_ORB_Core::service_profile_selection (  TAO_MProfile &  mprofile, TAO_Profile *&  profile )

The loaded service in the ORB_Core would determine if the profile selection is going to be made by the services or not. If the services do make the selection they would return the selected profile through . Definition at line 83 of file ORB_Core.i. References ft_service_, TAO_Service_Callbacks::select_profile(), and TAO_Fault_Tolerance_Service::service_callback(). { CORBA::Boolean retval = 0; // @@ If different services have the same feature we may want to // prioritise them here. We need to decide here whose selection of // profile is more important. if (this->ft_service_.service_callback ()) { retval = this->ft_service_.service_callback ()->select_profile (&mprofile, profile); } return retval; }

TAO::Invocation_Status TAO_ORB_Core::service_raise_comm_failure (  IOP::ServiceContextList &  clist, TAO_Profile *  profile )

Raise a comm failure exception if a service is not loaded, else delegate to the service to see what the service has to do for this case. Definition at line 1728 of file ORB_Core.cpp. References ACE_ENV_ARG_PARAMETER, ACE_THROW_RETURN, ft_service_, TAO_Fault_Tolerance_Service::service_callback(), and TAO_INVOCATION_RECV_REQUEST_MINOR_CODE. { if (this->ft_service_.service_callback ()) { return this->ft_service_.service_callback ()-> raise_comm_failure (clist, profile ACE_ENV_ARG_PARAMETER); } ACE_THROW_RETURN (CORBA::COMM_FAILURE ( CORBA::SystemException::_tao_minor_code ( TAO_INVOCATION_RECV_REQUEST_MINOR_CODE, errno), CORBA::COMPLETED_MAYBE), TAO::TAO_INVOKE_SYSTEM_EXCEPTION); }

TAO::Invocation_Status TAO_ORB_Core::service_raise_transient_failure (  IOP::ServiceContextList &  clist, TAO_Profile *  profile )

Raise a transient failure exception if a service is not loaded, else delegate to the service to see what the service has to do for this case. Definition at line 1751 of file ORB_Core.cpp. References ACE_ENV_ARG_PARAMETER, ft_service_, TAO_Service_Callbacks::raise_transient_failure(), and TAO_Fault_Tolerance_Service::service_callback(). { if (this->ft_service_.service_callback ()) { return this->ft_service_.service_callback ()->raise_transient_failure (clist, profile ACE_ENV_ARG_PARAMETER); } return TAO::TAO_INVOKE_FAILURE; }

void TAO_ORB_Core::services_callbacks_init (  void   )  [protected]

Search the Dynamic service list for well known services that has callbacks which can be dynamically loaded. Definition at line 1717 of file ORB_Core.cpp. References ft_service_, and TAO_Fault_Tolerance_Service::init(). { // We (should) know what are the services that would need // callbacks. So, what we do is go through the Service Configurator // list for looking at the services that we want to load. this->ft_service_.init (this); // @@ Other service callbacks can be added here }

void TAO_ORB_Core::set_collocation_resolver (  const char *  collocation_resolver_name  )  [static]

Sets the value of TAO_ORB_Core::collocation_resolver_name_. Definition at line 1423 of file ORB_Core.cpp. References TAO_ORB_Core_Static_Resources::collocation_resolver_name_, and TAO_ORB_Core_Static_Resources::instance(). { TAO_ORB_Core_Static_Resources::instance ()->collocation_resolver_name_ = collocation_resolver_name; }

ACE_INLINE void TAO_ORB_Core::set_default (  const char *  orb_id  )

Set the ORB related to the orb_id as the default ORB and not the ORB that is first binded in the ORB Table Definition at line 210 of file ORB_Core.i. References TAO::ORB_Table::instance(), and TAO::ORB_Table::set_default(). { TAO::ORB_Table * const table = TAO::ORB_Table::instance (); table->set_default (orb_id); }

int TAO_ORB_Core::set_endpoint_helper (  const ACE_CString &  lane, const ACE_CString &  endpoints )  [protected]

Pointer to the list of protocol loaded into this ORB instance. Helper method to hold the common code part for -ORBEndpoint and -ORBListenEndpoint options. Definition at line 2646 of file ORB_Core.cpp. References ACE_ERROR, ACE_TEXT, ACE_TEXT_CHAR_TO_TCHAR, ACE_THROW_RETURN, TAO_ORB_Parameters::add_endpoints(), LM_ERROR, orb_params(), and TAO_ORB_CORE_INIT_LOCATION_CODE. { if (this->orb_params ()->add_endpoints (lane, endpoints) != 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t)\n") ACE_TEXT ("Invalid endpoint(s) specified:\n%s\n"), ACE_TEXT_CHAR_TO_TCHAR(endpoints.c_str ()))); ACE_THROW_RETURN (CORBA::BAD_PARAM ( CORBA::SystemException::_tao_minor_code ( TAO_ORB_CORE_INIT_LOCATION_CODE, EINVAL), CORBA::COMPLETED_NO), -1); } return 0; }

void TAO_ORB_Core::set_endpoint_selector_factory (  const char *  endpoint_selector_factory_name  )  [static]

Sets the value of TAO_ORB_Core::endpoint_selector_factory_. Definition at line 1683 of file ORB_Core.cpp. References TAO_ORB_Core_Static_Resources::endpoint_selector_factory_name_, and TAO_ORB_Core_Static_Resources::instance(). { TAO_ORB_Core_Static_Resources::instance ()->endpoint_selector_factory_name_ = endpoint_selector_factory_name; }

void TAO_ORB_Core::set_gui_resource_factory (  TAO::GUIResource_Factory *  gui_factory  )  [static]

Sets the value of TAO_ORB_Core::gui_resource_factory_. Sets the value of gui_resource_factory in TSS. ORB_Core is responsible for releasing this factory if needed. Definition at line 1444 of file ORB_Core.cpp. References ACE_DEBUG, TAO_TSS_Resources::gui_resource_factory_, TAO_TSS_Resources::instance(), and LM_WARNING. Referenced by TAO::FlResource_Loader::FlResource_Loader(), TAO::QtResource_Loader::QtResource_Loader(), TAO::TkResource_Loader::TkResource_Loader(), and TAO::XtResource_Loader::XtResource_Loader(). { if (TAO_TSS_Resources::instance ()->gui_resource_factory_ != 0) { ACE_DEBUG ((LM_WARNING, "TAO (%P|%t) - Deleting old gui_resource_factory.\n")); delete TAO_TSS_Resources::instance ()->gui_resource_factory_; } TAO_TSS_Resources::instance ()->gui_resource_factory_ = gui_resource_factory; }

void TAO_ORB_Core::set_poa_factory (  const char *  poa_factory_name, const char *  poa_factory_directive )  [static]

Sets the name of the POA factory and the dynamic service configurator directive to load it if needed. Definition at line 1667 of file ORB_Core.cpp. References TAO_ORB_Core_Static_Resources::instance(), TAO_ORB_Core_Static_Resources::poa_factory_directive_, and TAO_ORB_Core_Static_Resources::poa_factory_name_. { TAO_ORB_Core_Static_Resources::instance ()->poa_factory_name_ = poa_factory_name; TAO_ORB_Core_Static_Resources::instance ()->poa_factory_directive_ = poa_factory_directive; }

void TAO_ORB_Core::set_protocols_hooks (  const char *  protocols_hooks_name  )  [static]

Sets the value of TAO_ORB_Core::protocols_hooks_. Definition at line 1709 of file ORB_Core.cpp. References TAO_ORB_Core_Static_Resources::instance(), and TAO_ORB_Core_Static_Resources::protocols_hooks_name_. { // Is synchronization necessary? TAO_ORB_Core_Static_Resources::instance ()->protocols_hooks_name_ = protocols_hooks_name; }

void TAO_ORB_Core::set_resource_factory (  const char *  resource_factory_name  )  [static]

Sets the value of TAO_ORB_Core::resource_factory_. Definition at line 1437 of file ORB_Core.cpp. References TAO_ORB_Core_Static_Resources::instance(), and TAO_ORB_Core_Static_Resources::resource_factory_name_. { TAO_ORB_Core_Static_Resources::instance ()->resource_factory_name_ = resource_factory_name; }

void TAO_ORB_Core::set_stub_factory (  const char *  stub_factory_name  )  [static]

Sets the value of TAO_ORB_Core::stub_factory_name_. Definition at line 1430 of file ORB_Core.cpp. References TAO_ORB_Core_Static_Resources::instance(), and TAO_ORB_Core_Static_Resources::stub_factory_name_. { TAO_ORB_Core_Static_Resources::instance ()->stub_factory_name_ = stub_factory_name; }

void TAO_ORB_Core::set_sync_scope_hook (  Sync_Scope_Hook  hook  )  [static]

Definition at line 2987 of file ORB_Core.cpp. References TAO_ORB_Core_Static_Resources::instance(), and Sync_Scope_Hook. { TAO_ORB_Core_Static_Resources::instance ()-> sync_scope_hook_ = hook; }

void TAO_ORB_Core::set_thread_lane_resources_manager_factory (  const char *  thread_lane_resources_manager_factory_name  )  [static]

Sets the value of TAO_ORB_Core::thread_lane_resources_manager_factory_name_ Definition at line 1416 of file ORB_Core.cpp. References TAO_ORB_Core_Static_Resources::instance(), and TAO_ORB_Core_Static_Resources::thread_lane_resources_manager_factory_name_. { TAO_ORB_Core_Static_Resources::instance ()->thread_lane_resources_manager_factory_name_ = thread_lane_resources_manager_factory_name; }

void TAO_ORB_Core::set_timeout_hook (  Timeout_Hook  hook  )  [static]

Definition at line 3017 of file ORB_Core.cpp. References TAO_ORB_Core_Static_Resources::instance(), Timeout_Hook, and TAO_ORB_Core_Static_Resources::timeout_hook_. { // Saving the hook pointer so that we can use it later when needed. TAO_ORB_Core_Static_Resources::instance ()->timeout_hook_ = hook; }

ACE_INLINE int TAO_ORB_Core::set_tss_resource (  size_t  slot_id, void *  )

Set the TSS resource at the given slot. Returns 0 on success, and -1 on failure. Definition at line 307 of file ORB_Core.i. References get_tss_resources(), TAO_ORB_Core_TSS_Resources::orb_core_, ACE_Array_Base< void * >::size(), TAO_Cleanup_Func_Registry::size(), TAO_ORB_Core_TSS_Resources::ts_objects_, and tss_cleanup_funcs_. { TAO_ORB_Core_TSS_Resources *tss_resources = this->get_tss_resources (); // The number of allocated slots is equal to the number of // registered TSS cleanup functions, *not* the size of the array in // the ORB core TSS resources. if (slot_id >= this->tss_cleanup_funcs_.size ()) { errno = EINVAL; return -1; } // If the TSS array isn't large enough, then increase its size. // We're guaranteed not to exceed the number of allocated slots by // the above check. const size_t old_size = tss_resources->ts_objects_.size (); const size_t new_size = slot_id + 1; if (slot_id >= old_size && tss_resources->ts_objects_.size (new_size) != 0) return -1; // Initialize intermediate array elements to zero, since they // haven't been initialized yet. This ensures that garbage is not // returned when accessing any of those elements at a later point in // time. for (size_t i = old_size; i < slot_id; ++i) tss_resources->ts_objects_[i] = 0; tss_resources->ts_objects_[slot_id] = ts_object; // Make sure the ORB core pointer is set in the ORB core's TSS // resources so that the TSS cleanup functions stored in the ORB // core can be invoked. tss_resources->orb_core_ = this; return 0; }

void TAO_ORB_Core::shutdown (  CORBA::Boolean  wait_for_completion  )

End the event loop. Definition at line 2261 of file ORB_Core.cpp. References CORBA::Object::_nil(), ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_GUARD, adapter_registry_, ACE_Thread_Manager::cancel_all(), TAO_Adapter_Registry::check_close(), TAO_Thread_Lane_Resources_Manager::cleanup_rw_transports(), TAO_Adapter_Registry::close(), TAO_Object_Ref_Table::destroy(), has_shutdown(), has_shutdown_, object_ref_table_, pi_current_, CORBA::release(), TAO_Thread_Lane_Resources_Manager::shutdown_reactor(), TAO_SYNCH_MUTEX, thr_mgr(), thread_lane_resources_manager(), valuetype_adapter_, and ACE_Thread_Manager::wait(). Referenced by destroy(), fini(), and CORBA::ORB::shutdown(). { { ACE_GUARD (TAO_SYNCH_MUTEX, monitor, this->lock_); if (this->has_shutdown () != 0) return; // Check if we are on the right state, i.e. do not accept // shutdowns with the 'wait_for_completion' flag set in the middle // of an upcall (because those deadlock). this->adapter_registry_.check_close (wait_for_completion ACE_ENV_ARG_PARAMETER); ACE_CHECK; // Set the 'has_shutdown' flag, so any further attempt to shutdown // becomes a noop. this->has_shutdown_ = 1; // need to release the mutex, because some of the shutdown // operations invoke application code, that could (and in practice // does!) callback into ORB Core code. } this->adapter_registry_.close (wait_for_completion ACE_ENV_ARG_PARAMETER); ACE_CHECK; // Shutdown reactor. this->thread_lane_resources_manager ().shutdown_reactor (); // Cleanup transports that use the RW strategies this->thread_lane_resources_manager ().cleanup_rw_transports (); // Grab the thread manager ACE_Thread_Manager *tm = this->thr_mgr (); // Try to cancel all the threads in the ORB. tm->cancel_all (); // If <wait_for_completion> is set, wait for all threads to exit. if (wait_for_completion != 0) tm->wait (); // Explicitly destroy the valuetype adapter delete this->valuetype_adapter_; this->valuetype_adapter_ = 0; // Explicitly destroy the object reference table since it // contains references to objects, which themselves may contain // reference to this ORB. this->object_ref_table_.destroy (); #if (TAO_HAS_INTERCEPTORS == 1) CORBA::release (this->pi_current_); this->pi_current_ = CORBA::Object::_nil (); #endif /* TAO_HAS_INTERCEPTORS == 1 */ }

TAO_Stub_Factory * TAO_ORB_Core::stub_factory (  void   )

Returns a pointer to the Stub factory. Definition at line 1648 of file ORB_Core.cpp. References ACE_CString, ACE_TEXT_CHAR_TO_TCHAR, configuration(), TAO_ORB_Core_Static_Resources::instance(), stub_factory_, and TAO_ORB_Core_Static_Resources::stub_factory_name_. Referenced by create_stub(). { // Check if there is a cached reference. if (this->stub_factory_ != 0) return this->stub_factory_; // If not, look in the service repository for an instance. const ACE_CString &stub_factory_name = TAO_ORB_Core_Static_Resources::instance ()->stub_factory_name_; this->stub_factory_ = ACE_Dynamic_Service<TAO_Stub_Factory>::instance (this->configuration (), ACE_TEXT_CHAR_TO_TCHAR (stub_factory_name.c_str())); return this->stub_factory_; }

ACE_INLINE ACE_Thread_Manager * TAO_ORB_Core::thr_mgr (  void   )

Get the ACE_Thread_Manager. Definition at line 180 of file ORB_Core.i. Referenced by fini(), TAO_IIOP_Connector::open(), and shutdown(). { return &this->tm_; }

TAO_Thread_Lane_Resources_Manager & TAO_ORB_Core::thread_lane_resources_manager (  void   )

Returns a pointer to the Thread Lane Resources Manager. Definition at line 1546 of file ORB_Core.cpp. References ACE_CString, ACE_TEXT_CHAR_TO_TCHAR, configuration(), TAO_Thread_Lane_Resources_Manager_Factory::create_thread_lane_resources_manager(), TAO_ORB_Core_Static_Resources::instance(), thread_lane_resources_manager_, and TAO_ORB_Core_Static_Resources::thread_lane_resources_manager_factory_name_. Referenced by is_collocated(), lane_resources(), lf_strategy(), and shutdown(). { // Check if there is a cached reference. if (this->thread_lane_resources_manager_ != 0) return *this->thread_lane_resources_manager_; // If not, lookup the corresponding factory and ask it to make one. const ACE_CString &thread_lane_resources_manager_factory_name = TAO_ORB_Core_Static_Resources::instance ()->thread_lane_resources_manager_factory_name_; TAO_Thread_Lane_Resources_Manager_Factory *factory = ACE_Dynamic_Service<TAO_Thread_Lane_Resources_Manager_Factory>::instance (this->configuration (), ACE_TEXT_CHAR_TO_TCHAR (thread_lane_resources_manager_factory_name.c_str())); this->thread_lane_resources_manager_ = factory->create_thread_lane_resources_manager (*this); return *this->thread_lane_resources_manager_; }

ACE_INLINE int TAO_ORB_Core::thread_per_connection_timeout (  ACE_Time_Value &  timeout  )  const

Returns the value used by the server threads to poll the shutdown flag. If the return value is zero then the server threads block forever. Definition at line 360 of file ORB_Core.i. Referenced by TAO_Connection_Handler::svc_i(). { timeout = this->thread_per_connection_timeout_; return this->thread_per_connection_use_timeout_; }

ACE_Allocator * TAO_ORB_Core::transport_message_buffer_allocator (  void   )

This allocator is always global and has no locks. It is intended for allocating the buffers used to queue messages in transports. Definition at line 2828 of file ORB_Core.cpp. References lane_resources(), and TAO_Thread_Lane_Resources::transport_message_buffer_allocator(). { return this->lane_resources ().transport_message_buffer_allocator (); }

ACE_INLINE TAO_Cleanup_Func_Registry * TAO_ORB_Core::tss_cleanup_funcs (  void   )

Return the underlying TSS cleanup function registry. Definition at line 348 of file ORB_Core.i. References tss_cleanup_funcs_. { return &(this->tss_cleanup_funcs_); }

const char * TAO_ORB_Core::typecodefactory_adapter_name (  void   )  [static]

Gets the value of TAO_ORB_Core::typecodefactory_adapter_name_. Definition at line 1488 of file ORB_Core.cpp. References TAO_ORB_Core_Static_Resources::instance(), and TAO_ORB_Core_Static_Resources::typecodefactory_adapter_name_. { return TAO_ORB_Core_Static_Resources::instance ()->typecodefactory_adapter_name_.c_str(); }

void TAO_ORB_Core::typecodefactory_adapter_name (  const char *  name  )  [static]

Sets the value of TAO_ORB_Core::typecodefactory_adapter_name_. Definition at line 1482 of file ORB_Core.cpp. References TAO_ORB_Core_Static_Resources::instance(), and TAO_ORB_Core_Static_Resources::typecodefactory_adapter_name_. { TAO_ORB_Core_Static_Resources::instance ()->typecodefactory_adapter_name_ = name; }

ACE_INLINE CORBA::Boolean TAO_ORB_Core::use_global_collocation (  void   )  const

Definition at line 242 of file ORB_Core.i. References use_global_collocation_. { return this->use_global_collocation_; }

ACE_INLINE void TAO_ORB_Core::use_global_collocation (  CORBA::Boolean  opt  )

Definition at line 236 of file ORB_Core.i. References use_global_collocation_. Referenced by is_collocation_enabled(). { this->use_global_collocation_ = opt; }

ACE_INLINE CORBA::Boolean TAO_ORB_Core::use_implrepo (  void   )

Do we attempt to register with the Implementation Repository. Definition at line 379 of file ORB_Core.i. References use_implrepo_. { return use_implrepo_; }

TAO_Valuetype_Adapter * TAO_ORB_Core::valuetype_adapter (  void   )

Return the valuetype adapter. Definition at line 3450 of file ORB_Core.cpp. References ACE_ANY_EXCEPTION, ACE_CATCHANY, ACE_CHECK_RETURN, ACE_DECLARE_NEW_CORBA_ENV, ACE_ENDTRY, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_GUARD_RETURN, ACE_PRINT_EXCEPTION, ACE_THROW_RETURN, ACE_TRY, ACE_TRY_CHECK, TAO_Valuetype_Adapter_Factory::create(), ACE_Dynamic_Service< TYPE >::instance(), TAO_SYNCH_MUTEX, valuetype_adapter_, and valuetype_adapter_factory_name(). Referenced by CORBA::ORB::lookup_value_factory(), CORBA::ORB::register_value_factory(), and CORBA::ORB::unregister_value_factory(). { if (this->valuetype_adapter_ == 0) { ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->lock_, 0); if (this->valuetype_adapter_ == 0) { ACE_DECLARE_NEW_CORBA_ENV; ACE_TRY { TAO_Valuetype_Adapter_Factory * vt_ap_factory = ACE_Dynamic_Service<TAO_Valuetype_Adapter_Factory>::instance ( TAO_ORB_Core::valuetype_adapter_factory_name () ); if (vt_ap_factory) { this->valuetype_adapter_ = vt_ap_factory->create (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } } ACE_CATCHANY { ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Cannot initialize the " "valuetype_adapter \n"); } ACE_ENDTRY; ACE_CHECK_RETURN(0); } if (this->valuetype_adapter_ == 0) { ACE_THROW_RETURN (CORBA::INTERNAL (), 0); } } return this->valuetype_adapter_; }

const char * TAO_ORB_Core::valuetype_adapter_factory_name (  void   )  [static]

Gets the value of TAO_ORB_Core::valuetype_adapter_factory_name. Definition at line 1512 of file ORB_Core.cpp. References TAO_ORB_Core_Static_Resources::instance(), and TAO_ORB_Core_Static_Resources::valuetype_adapter_factory_name_. { return TAO_ORB_Core_Static_Resources::instance ()->valuetype_adapter_factory_name_.c_str(); }

void TAO_ORB_Core::valuetype_adapter_factory_name (  const char *  name  )  [static]

Sets the value of TAO_ORB_Core::valuetype_adapter_factory_name. Definition at line 1506 of file ORB_Core.cpp. References TAO_ORB_Core_Static_Resources::instance(), and TAO_ORB_Core_Static_Resources::valuetype_adapter_factory_name_. Referenced by valuetype_adapter(). { TAO_ORB_Core_Static_Resources::instance ()->valuetype_adapter_factory_name_ = name; }

---

Friends And Related Function Documentation

CORBA::ORB_ptr CORBA::ORB_init (  int &  , char *  argv[], const char *  , CORBA::Environment &  )  [friend]

friend class TAO_ORB_Core_Auto_Ptr [friend]

Definition at line 160 of file ORB_Core.h.

---

Member Data Documentation

TAO_Adapter_Registry TAO_ORB_Core::adapter_registry_ [protected]

The list of Adapters used in this ORB. Definition at line 1167 of file ORB_Core.h. Referenced by adapter_registry(), poa_adapter(), resolve_ior_table_i(), root_poa(), and shutdown().

TAO_BiDir_Adapter* TAO_ORB_Core::bidir_adapter_ [protected]

BiDirectional GIOP factory. Definition at line 1256 of file ORB_Core.h. Referenced by load_policy_validators().

CORBA::Boolean TAO_ORB_Core::bidir_giop_policy_ [protected]

Bir Dir GIOP policy value. Definition at line 1259 of file ORB_Core.h. Referenced by bidir_giop_policy().

TAO_Client_Strategy_Factory* TAO_ORB_Core::client_factory_ [protected]

Handle to the factory for Client-side strategies. Definition at line 1118 of file ORB_Core.h. Referenced by client_factory().

TAO::ClientRequestInterceptor_Adapter* TAO_ORB_Core::client_request_interceptor_adapter_ [protected]

The adapter for handling client request interceptors. Definition at line 1239 of file ORB_Core.h. Referenced by add_interceptor(), clientrequestinterceptor_adapter(), clientrequestinterceptor_adapter_i(), and destroy_interceptors().

CORBA::Object_ptr TAO_ORB_Core::codec_factory_ [protected]

The cached IOR for the CodecFactory DLL. Definition at line 1062 of file ORB_Core.h. Referenced by fini(), and resolve_codecfactory_i().

TAO_Codeset_Manager* TAO_ORB_Core::codeset_manager_ [protected]

Code Set Manager - points to service object in the service repo. Definition at line 1265 of file ORB_Core.h.

TAO_Collocation_Resolver* TAO_ORB_Core::collocation_resolver_ [protected]

Definition at line 1042 of file ORB_Core.h. Referenced by collocation_resolver().

CORBA::ULong TAO_ORB_Core::collocation_strategy_ [protected]

Default collocation policy. This should never be ORB_CONTROL. Definition at line 1142 of file ORB_Core.h. Referenced by get_collocation_strategy().

ACE_Service_Gestalt* TAO_ORB_Core::config_ [protected]

ORB's service configuration. Definition at line 1268 of file ORB_Core.h.

ACE_Lock_Adapter<TAO_SYNCH_MUTEX> TAO_ORB_Core::data_block_lock_ [protected]

The data block reference counts are locked using this mutex. Definition at line 1176 of file ORB_Core.h. Referenced by create_input_cdr_data_block(), and locking_strategy().

TAO_Policy_Set* TAO_ORB_Core::default_policies_ [protected]

The default policies. Definition at line 1151 of file ORB_Core.h. Referenced by get_default_policies(), and ~TAO_ORB_Core().

TAO::Transport_Queueing_Strategy* TAO_ORB_Core::default_transport_queueing_strategy_ [protected]

This strategy will not queue by default and not flush. Definition at line 1217 of file ORB_Core.h. Referenced by default_transport_queueing_strategy(), and ~TAO_ORB_Core().

TAO::Transport_Queueing_Strategy* TAO_ORB_Core::delayed_transport_queueing_strategy_ [protected]

This strategy will buffer messages. Definition at line 1208 of file ORB_Core.h. Referenced by delayed_transport_queueing_strategy(), and ~TAO_ORB_Core().

CORBA::Object_ptr TAO_ORB_Core::dynany_factory_ [protected]

The cached object reference for the DynAnyFactory. Definition at line 1065 of file ORB_Core.h. Referenced by fini(), and resolve_dynanyfactory_i().

TAO::Transport_Queueing_Strategy* TAO_ORB_Core::eager_transport_queueing_strategy_ [protected]

This strategy will buffer messages. Definition at line 1205 of file ORB_Core.h. Referenced by eager_transport_queueing_strategy(), and ~TAO_ORB_Core().

TAO_Endpoint_Selector_Factory* TAO_ORB_Core::endpoint_selector_factory_ [protected]

Definition at line 1200 of file ORB_Core.h. Referenced by endpoint_selector_factory().

TAO::Transport_Queueing_Strategy* TAO_ORB_Core::flush_transport_queueing_strategy_ [protected]

This strategy will not queue by default, but will flush the queue each time Definition at line 1212 of file ORB_Core.h. Referenced by flush_transport_queueing_strategy(), and ~TAO_ORB_Core().

TAO_Flushing_Strategy* TAO_ORB_Core::flushing_strategy_ [protected]

Hold the flushing strategy. Definition at line 1262 of file ORB_Core.h. Referenced by flushing_strategy(), and ~TAO_ORB_Core().

TAO_Fault_Tolerance_Service TAO_ORB_Core::ft_service_ [protected]

Fault Tolerant service hook. Definition at line 1129 of file ORB_Core.h. Referenced by fault_tolerance_service(), hash_service(), is_profile_equivalent(), object_is_nil(), reset_service_profile_flags(), service_profile_reselection(), service_profile_selection(), service_raise_comm_failure(), service_raise_transient_failure(), and services_callbacks_init().

int TAO_ORB_Core::has_shutdown_ [protected]

Flag which denotes that the ORB has been shutdown. Definition at line 1186 of file ORB_Core.h. Referenced by has_shutdown(), and shutdown().

CORBA::Object_ptr TAO_ORB_Core::implrepo_service_ [protected]

The cached IOR for the Implementation Repository. Definition at line 1050 of file ORB_Core.h. Referenced by fini(), and implrepo_service().

int TAO_ORB_Core::imr_endpoints_in_ior_ [protected]

Flag for whether to put the ImR endpoints into our object refs. Definition at line 1056 of file ORB_Core.h. Referenced by imr_endpoints_in_ior().

InitRefMap TAO_ORB_Core::init_ref_map_ [protected]

Return InitRefMap to find if a particular object id is present. Definition at line 1098 of file ORB_Core.h. Referenced by init_ref_map(), and list_initial_references().

TAO_IORInterceptor_Adapter* TAO_ORB_Core::ior_interceptor_adapter_ [protected]

IORInterceptor adapter. Definition at line 1247 of file ORB_Core.h. Referenced by add_interceptor(), destroy_interceptors(), and ior_interceptor_adapter().

CORBA::Object_ptr TAO_ORB_Core::ior_manip_factory_ [protected]

The cached object reference for the IORManipulataion. Definition at line 1068 of file ORB_Core.h. Referenced by fini(), and resolve_iormanipulation_i().

CORBA::Object_ptr TAO_ORB_Core::ior_table_ [protected]

The cached object reference for the IORTable. Definition at line 1071 of file ORB_Core.h. Referenced by fini(), and resolve_ior_table_i().

TAO_SYNCH_MUTEX TAO_ORB_Core::lock_ [protected]

Synchronize internal state... Definition at line 1038 of file ORB_Core.h.

TAO::ObjectKey_Table TAO_ORB_Core::object_key_table_ [protected]

Table that stores the object key instead of caching one per-profile. Definition at line 1106 of file ORB_Core.h. Referenced by fini(), and object_key_table().

TAO_Object_Ref_Table TAO_ORB_Core::object_ref_table_ [protected]

Table that maps object key/name to (de-stringified) object reference. It is needed for supporting local objects in the resolve_initial_references() mechanism. Definition at line 1103 of file ORB_Core.h. Referenced by list_initial_references(), object_ref_table(), and shutdown().

int TAO_ORB_Core::open_called_ [protected]

Flag which denotes that the open method was called. Definition at line 1198 of file ORB_Core.h.

TAO_SYNCH_MUTEX TAO_ORB_Core::open_lock_ [protected]

Mutual exclusion for calling open. Definition at line 1195 of file ORB_Core.h.

CORBA::Boolean TAO_ORB_Core::opt_for_collocation_ [protected]

TRUE if we want to take advantage of collocation optimization in this ORB. Definition at line 1135 of file ORB_Core.h. Referenced by optimize_collocation_objects().

CORBA::ORB_ptr TAO_ORB_Core::orb_ [protected]

Note: Should we keep a single ORB pointer? This is good because multiple calls to ORB_init() with the same ORBid can use the same object, but maybe don't want so much coupling. Pointer to the ORB. Definition at line 1087 of file ORB_Core.h. Referenced by implrepo_service(), orb(), and ~TAO_ORB_Core().

TAO_ORB_Parameters TAO_ORB_Core::orb_params_ [protected]

Parameters used by the ORB. Definition at line 1095 of file ORB_Core.h. Referenced by orb_params().

char* TAO_ORB_Core::orbid_ [protected]

The ORBid for this ORB. Definition at line 1109 of file ORB_Core.h. Referenced by fini(), and orbid().

TAO::ORBInitializer_Registry_Adapter* TAO_ORB_Core::orbinitializer_registry_ [protected]

Registry containing all orb initializers. Definition at line 1226 of file ORB_Core.h. Referenced by orbinitializer_registry(), orbinitializer_registry_i(), and ~TAO_ORB_Core().

TAO_Parser_Registry TAO_ORB_Core::parser_registry_ [protected]

The IOR parser registry. Definition at line 1253 of file ORB_Core.h. Referenced by parser_registry().

CORBA::Object_ptr TAO_ORB_Core::pi_current_ [protected]

Cached pointer/reference to the PICurrent object. A pointer/reference to the PICurrent object is cached in the ORB Core since it is accessed in the critical path (i.e. the request invocation path). Caching it prevents additional overhead to due object resolution from occurring. Definition at line 1236 of file ORB_Core.h. Referenced by pi_current(), resolve_picurrent_i(), and shutdown().

TAO_Adapter* TAO_ORB_Core::poa_adapter_ [protected]

An optimization for the POA. Definition at line 1170 of file ORB_Core.h. Referenced by poa_adapter().

CORBA::Object_var TAO_ORB_Core::poa_current_ [protected]

POA current. Definition at line 1164 of file ORB_Core.h. Referenced by resolve_poa_current_i().

TAO_Policy_Current* TAO_ORB_Core::policy_current_ [protected]

Policy current. Definition at line 1154 of file ORB_Core.h. Referenced by policy_current(), and ~TAO_ORB_Core().

TAO::PolicyFactory_Registry_Adapter* TAO_ORB_Core::policy_factory_registry_ [protected]

Registry containing all registered policy factories. Definition at line 1223 of file ORB_Core.h. Referenced by policy_factory_registry(), policy_factory_registry_i(), and ~TAO_ORB_Core().

TAO_Policy_Manager* TAO_ORB_Core::policy_manager_ [protected]

The Policy_Manager for this ORB. Definition at line 1148 of file ORB_Core.h. Referenced by policy_manager(), and ~TAO_ORB_Core().

TAO_ProtocolFactorySet* TAO_ORB_Core::protocol_factories_ [protected]

Definition at line 1046 of file ORB_Core.h.

TAO_Protocols_Hooks* TAO_ORB_Core::protocols_hooks_

Handle to the factory for protocols_hooks_.. Definition at line 559 of file ORB_Core.h. Referenced by get_protocols_hooks(), and service_context_list().

CORBA::ULong TAO_ORB_Core::refcount_ [protected]

Number of outstanding references to this object. Definition at line 1220 of file ORB_Core.h.

TAO_Request_Dispatcher* TAO_ORB_Core::request_dispatcher_ [protected]

The request dispatching strategy. Definition at line 1159 of file ORB_Core.h. Referenced by request_dispatcher(), and ~TAO_ORB_Core().

TAO_Resource_Factory* TAO_ORB_Core::resource_factory_ [protected]

Handle to the factory for resource information.. Definition at line 1112 of file ORB_Core.h. Referenced by resource_factory().

CORBA::Object_var TAO_ORB_Core::root_poa_ [protected]

Object reference to the root POA. It will eventually be the object reference returned by calls to CORBA::ORB::resolve_initial_references ("RootPOA"). Definition at line 1092 of file ORB_Core.h. Referenced by root_poa().

CORBA::Object_var TAO_ORB_Core::rt_current_ [protected]

The cached object reference for the RTCORBA::Current interface. Definition at line 1077 of file ORB_Core.h.

CORBA::Object_var TAO_ORB_Core::rt_orb_ [protected]

The cached object reference for the RTCORBA::RTORB. Definition at line 1074 of file ORB_Core.h. Referenced by resolve_rt_orb().

TAO_Server_Strategy_Factory* TAO_ORB_Core::server_factory_ [protected]

Handle to the factory for Server-side strategies. Definition at line 1121 of file ORB_Core.h. Referenced by run(), and server_factory().

ACE_CString TAO_ORB_Core::server_id_ [protected]

The server_id_ that was passed via -ORBServerId option. Definition at line 1115 of file ORB_Core.h. Referenced by server_id().

TAO::ServerRequestInterceptor_Adapter* TAO_ORB_Core::server_request_interceptor_adapter_ [protected]

The adapter for handling server request interceptors. Definition at line 1242 of file ORB_Core.h. Referenced by add_interceptor(), destroy_interceptors(), serverrequestinterceptor_adapter(), and serverrequestinterceptor_adapter_i().

TAO_Stub_Factory* TAO_ORB_Core::stub_factory_ [protected]

Definition at line 1044 of file ORB_Core.h. Referenced by stub_factory().

TAO_Thread_Lane_Resources_Manager* TAO_ORB_Core::thread_lane_resources_manager_ [protected]

Definition at line 1040 of file ORB_Core.h. Referenced by fini(), thread_lane_resources_manager(), and ~TAO_ORB_Core().

ACE_Time_Value TAO_ORB_Core::thread_per_connection_timeout_ [protected]

Definition at line 1191 of file ORB_Core.h.

int TAO_ORB_Core::thread_per_connection_use_timeout_ [protected]

Definition at line 1190 of file ORB_Core.h.

ACE_Thread_Manager TAO_ORB_Core::tm_ [protected]

The Thread Manager. Definition at line 1173 of file ORB_Core.h.

TAO_Cleanup_Func_Registry TAO_ORB_Core::tss_cleanup_funcs_ [protected]

TSS Object cleanup functions. These correspond to the TSS objects stored in TAO's TSS resources. Definition at line 1180 of file ORB_Core.h. Referenced by add_tss_cleanup_func(), set_tss_resource(), and tss_cleanup_funcs().

CORBA::Object_ptr TAO_ORB_Core::typecode_factory_ [protected]

The cached IOR for the TypeCodeFactory DLL. Definition at line 1059 of file ORB_Core.h. Referenced by fini(), and resolve_typecodefactory_i().

CORBA::Boolean TAO_ORB_Core::use_global_collocation_ [protected]

TRUE if we want to consider all ORBs in this address space collocated. Definition at line 1139 of file ORB_Core.h. Referenced by use_global_collocation().

int TAO_ORB_Core::use_implrepo_ [protected]

Flag for whether the implrepo support is enabled or not. Definition at line 1053 of file ORB_Core.h. Referenced by implrepo_service(), and use_implrepo().

bool TAO_ORB_Core::use_local_memory_pool_ [private]

Definition at line 1033 of file ORB_Core.h.

TAO_Valuetype_Adapter* TAO_ORB_Core::valuetype_adapter_ [protected]

Pointer to the valuetype adapter. Definition at line 1250 of file ORB_Core.h. Referenced by shutdown(), and valuetype_adapter().

---

The documentation for this class was generated from the following files:

• ORB_Core.h
• ORB_Core.cpp
• ORB_Core.i

---