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, ACE_Service_Gestalt *g)
	Constructor.
TAO_ORB_Parameters *	orb_params (void)
	Accessor for the ORB parameters.
TAO_Connector_Registry *	connector_registry (void)
	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 (void)
	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__.
TAO_Network_Priority_Protocols_Hooks *	get_network_priority_protocols_hooks (void)
	Gets the value of TAO_ORB_Core::network_priority_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	set_timeout_hook (Timeout_Hook hook)
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)
void	set_sync_scope_hook (Sync_Scope_Hook hook)
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.
bool	has_shutdown (void) const
	Get the shutdown flag value.
void	destroy (void)
	Shutdown the ORB and free resources.
void	check_shutdown (void)
	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 (void)
	Resolve the TypeCodeFactory DLL.
CORBA::Object_ptr	resolve_picurrent (void)
	Resolve the PICurrent.
CORBA::Object_ptr	resolve_poa_current (void)
	Resolve POA Current.
CORBA::Object_ptr	resolve_codecfactory (void)
	Resolve the CodecFactory DLL.
CORBA::Object_ptr	resolve_compression_manager (void)
	Resolve the Compression DLL.
CORBA::Object_ptr	resolve_dynanyfactory (void)
	Resolve the Dynamic Any Factory.
CORBA::Object_ptr	resolve_ior_manipulation (void)
	Resolve the IOR Manipulation reference for this ORB.
CORBA::Object_ptr	resolve_ior_table (void)
	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 (void)
	List all the service known by the ORB.
unsigned long	_incr_refcnt (void)
	Reference counting...
unsigned long	_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.
void	set_eager_transport_queueing_strategy (TAO::Transport_Queueing_Strategy *strategy)
void	set_delayed_transport_queueing_strategy (TAO::Transport_Queueing_Strategy *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 (const TAO_MProfile &mprofile, TAO_Profile *&profile)
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_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_network_priority_protocols_hooks (const char *network_priority_protocols_hooks_name)
	Sets the value of TAO_ORB_Core::network_priority_protocols_hooks_.
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	connection_timeout_hook (Timeout_Hook hook)
	Define the Timeout_Hook signature.
Public Attributes
TAO_Protocols_Hooks *	protocols_hooks_
	Handle to the factory for protocols_hooks_..
TAO_Network_Priority_Protocols_Hooks *	network_priority_protocols_hooks_
	Handle to the factory for network_priority_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 (void)
	Obtain and cache the typecode factory object reference.
void	resolve_poa_current_i (void)
	Obtain and cache the poa current.
void	resolve_picurrent_i (void)
	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 (void)
	Obtain and cache the codec factory object reference.
void	resolve_compression_manager_i (void)
	Obtain and cache the compression manager object reference.
void	resolve_dynanyfactory_i (void)
	Obtain and cache the dynamic any factory object reference.
void	resolve_iormanipulation_i (void)
	Obtain and cache the IORManipulation factory object reference.
void	services_callbacks_init (void)
void	destroy_interceptors (void)
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	compression_manager_
	The cached IOR for the Compression 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_
bool	has_shutdown_
	Flag which denotes that the ORB has been shutdown.
TAO_SYNCH_MUTEX	open_lock_
	Mutual exclusion for calling open.
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.
ACE_Atomic_Op< TAO_SYNCH_MUTEX, unsigned long >	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, received from the Resource Factory.
ACE_Service_Gestalt *	config_
	ORB's service configuration.
Sync_Scope_Hook	sync_scope_hook_
	The hook to be set for the SyncScopePolicy.
Timeout_Hook	timeout_hook_
	The hook to be set for the RelativeRoundtripTimeoutPolicy.
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 (void)
	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 &)
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 *)

---

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 849 of file ORB_Core.h.

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

Definition at line 526 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 467 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 223 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, ACE_Service_Gestalt *  g )

Constructor. Definition at line 183 of file ORB_Core.cpp. References ACE_NEW, 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), network_priority_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 ()), compression_manager_ (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_ (true), use_global_collocation_ (true), 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_ (true), // 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 */ 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), config_ (gestalt), sync_scope_hook_ (0), timeout_hook_ (0) { #if (TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1) 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 */ // Initialize the default request dispatcher. ACE_NEW (this->request_dispatcher_, TAO_Request_Dispatcher); }

TAO_ORB_Core::~TAO_ORB_Core (  void   )  [protected]

Destructor is protected since the ORB Core is a reference counted object. Definition at line 292 of file ORB_Core.cpp. References TAO::ORB::close_services(), codeset_manager_, default_policies_, delayed_transport_queueing_strategy_, eager_transport_queueing_strategy_, flush_transport_queueing_strategy_, flushing_strategy_, ACE_OS::free(), ACE_Service_Config::global(), 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->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->codeset_manager_; this->codeset_manager_ = 0; // This will destroy the service repository for this core (void) TAO::ORB::close_services (this->config_); if (this->config_ != ACE_Service_Config::global()) delete this->config_; this->config_ = 0; }

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

---

Member Function Documentation

ACE_INLINE unsigned long TAO_ORB_Core::_decr_refcnt (  void   )

Definition at line 23 of file ORB_Core.inl. References fini(). 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(). { unsigned long count = --this->refcount_; if (count != 0) return count; this->fini (); return 0; }

ACE_INLINE unsigned long TAO_ORB_Core::_incr_refcnt (  void   )

Reference counting... Definition at line 17 of file ORB_Core.inl. Referenced by TAO::ORB_Table::find(), initialize_object_i(), TAO::Collocated_Invocation::invoke(), and TAO::ORB_Core_Ref_Counter::ORB_Core_Ref_Counter(). { 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 160 of file ORB_Core.inl. References adapter_registry_. Referenced by create_object(), TAO_Request_Dispatcher::dispatch(), and initialize_object_i(). { return &this->adapter_registry_; }

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

Register an IOR interceptor. Definition at line 3109 of file ORB_Core.cpp. References ACE_ERROR, ACE_TEXT, 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); } 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"))); 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 3259 of file ORB_Core.cpp. References ACE_ERROR, ACE_TEXT, TAO::ServerRequestInterceptor_Adapter::add_interceptor(), LM_ERROR, CORBA::PolicyList, 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); } 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"))); 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 3235 of file ORB_Core.cpp. References ACE_ERROR, ACE_TEXT, TAO::ClientRequestInterceptor_Adapter::add_interceptor(), client_request_interceptor_adapter_, clientrequestinterceptor_adapter_i(), PortableInterceptor::ClientRequestInterceptor_ptr, LM_ERROR, and CORBA::PolicyList. { if (this->clientrequestinterceptor_adapter_i ()) { this->client_request_interceptor_adapter_->add_interceptor ( interceptor, policies); } 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"))); throw ::CORBA::INTERNAL (); } }

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

Register a server request interceptor. Definition at line 3214 of file ORB_Core.cpp. References ACE_ERROR, ACE_TEXT, 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); } 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"))); throw ::CORBA::INTERNAL (); } }

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

Register a client request interceptor. Definition at line 3165 of file ORB_Core.cpp. References ACE_ERROR, ACE_TEXT, 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); } 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"))); 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 2910 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 49 of file ORB_Core.inl. 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 43 of file ORB_Core.inl. 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 2860 of file ORB_Core.cpp. References Sync_Scope_Hook, sync_scope_hook_, and Messaging::SyncScope. Referenced by TAO::Invocation_Adapter::set_response_flags(). { Sync_Scope_Hook sync_scope_hook = this->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 2916 of file ORB_Core.cpp. References Timeout_Hook, and timeout_hook_. Referenced by TAO::LocateRequest_Invocation_Adapter::get_timeout(), and TAO::Invocation_Adapter::get_timeout(). { Timeout_Hook timeout_hook = this->timeout_hook_; if (timeout_hook == 0) { has_timeout = false; return; } (*timeout_hook) (this, stub, has_timeout, time_value); }

void TAO_ORB_Core::check_shutdown (  void   )

Check if ORB has shutdown. If it has, throw an exception. Definition at line 2275 of file ORB_Core.cpp. References 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. 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 1730 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_Muxed_TMS::TAO_Muxed_TMS(), 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 568 of file ORB_Core.inl. 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 3186 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 417 of file ORB_Core.inl. References TAO_Resource_Factory::codeset_manager(), 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(), init(), TAO_GIOP_Message_Base::process_request(), and TAO::Profile_Transport_Resolver::resolve(). { 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 1535 of file ORB_Core.cpp. References ACE_TEXT_CHAR_TO_TCHAR, collocation_resolver_, and configuration(). 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. this->collocation_resolver_ = ACE_Dynamic_Service<TAO_Collocation_Resolver>::instance (this->configuration (), ACE_TEXT_CHAR_TO_TCHAR (this->orb_params ()->collocation_resolver_name ())); 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 3393 of file ORB_Core.cpp. References CORBA::Object::_servant(), CORBA::Object::_stubobj(), ACE_ASSERT, collocation_resolver(), DIRECT, TAO_Pseudo_Var_T< T >::in(), TAO_Collocation_Resolver::is_collocated(), CORBA::is_nil(), CORBA::Object_ptr, TAO_Stub::servant_orb_var(), and THRU_POA. 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); 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.inl. Referenced by client_factory(), clientrequestinterceptor_adapter_i(), collocation_resolver(), endpoint_selector_factory(), init(), TAO::LocateRequest_Invocation_Adapter::invoke(), TAO::Invocation_Adapter::invoke_i(), 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_compression_manager_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 2931 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 2968 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 (  void   )

Get the connector registry. Definition at line 2806 of file ORB_Core.cpp. References TAO_Thread_Lane_Resources::connector_registry(), and lane_resources(). Referenced by operator>>(), TAO_CORBALOC_Parser::parse_string(), 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 (); 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 2782 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 2758 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_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 1898 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 TAO_CORBALOC_Parser::make_stub_from_mprofile(), 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 1831 of file ORB_Core.cpp. References TAO_Stub_Factory::create_stub(), and stub_factory(). Referenced by create_stub_object(), TAO_CORBALOC_Parser::make_stub_from_mprofile(), 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); 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 1849 of file ORB_Core.cpp. References TAO_Stub::base_profiles(), create_stub(), TAO_MProfile::get_profile(), TAO_Profile::policies(), TAO_MProfile::policy_list(), CORBA::PolicyList, 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 = 0; CORBA::ULong const 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); } } /// Initialize a TAO_Stub object with the mprofile thats passed. TAO_Stub *stub = this->create_stub (type_id, mprofile); 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 3103 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 3097 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_; }

TAO::Transport_Queueing_Strategy* TAO_ORB_Core::default_transport_queueing_strategy (  void   )

This strategy is the default, no explicit queueing and no explicit flush

void TAO_ORB_Core::destroy (  void   )

Shutdown the ORB and free resources. Definition at line 2247 of file ORB_Core.cpp. References 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); // Invoke Interceptor::destroy() on all registered interceptors. this->destroy_interceptors (); // 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 (  void   )  [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 2288 of file ORB_Core.cpp. References ACE_DEBUG, ACE_GUARD, ACE_TEXT, 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(). { 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 (); 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 (); 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 (); this->ior_interceptor_adapter_ = 0; } } catch (...) { // .. 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"))); } } return; }

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

Gets the value of TAO_ORB_Core::dynamic_adapter_name_. Definition at line 1431 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 1425 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; }

TAO_Endpoint_Selector_Factory * TAO_ORB_Core::endpoint_selector_factory (  void   )

Returns a pointer to the endpoint selector factory. Definition at line 1635 of file ORB_Core.cpp. References ACE_TEXT_CHAR_TO_TCHAR, configuration(), endpoint_selector_factory_, TAO_ORB_Parameters::endpoint_selector_factory_name(), and orb_params(). Referenced by TAO::Profile_Transport_Resolver::resolve(). { // 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 char* endpoint_selector_factory_name = this->orb_params ()->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)); 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 142 of file ORB_Core.inl. References ft_service_. { return this->ft_service_; }

int TAO_ORB_Core::fini (  void   )  [protected]

Final termination hook, typically called by CORBA::ORB's destructor. Definition at line 1340 of file ORB_Core.cpp. References ACE_CString, ACE_DEBUG, ACE_TEXT, ACE_TEXT_CHAR_TO_TCHAR, 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(). { try { // Shutdown the ORB and block until the shutdown is complete. this->shutdown (1); } catch (const ::CORBA::Exception& ex) { ACE_CString message = "Exception caught in trying to shutdown "; message += this->orbid_; message += "\n"; ex._tao_print_exception (message.c_str ()); } // 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 (); // Destroy the object_key table this->object_key_table_.destroy (); delete this; return 0; }

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 67 of file ORB_Core.inl. References flushing_strategy_. Referenced by TAO_Transport::drain_queue(), TAO_Transport::handle_timeout(), 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 2815 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 3061 of file ORB_Core.cpp. References TAO_Objref_Var_T< T >::_retn(), 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); } if (CORBA::is_nil (result.in ())) { result = this->get_default_policies ()->get_cached_policy (type); } 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 3080 of file ORB_Core.cpp. References TAO_Objref_Var_T< T >::_retn(), 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); if (CORBA::is_nil (result.in ())) { result = this->get_cached_policy (type); } return result._retn (); }

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

Definition at line 216 of file ORB_Core.inl. 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 520 of file ORB_Core.inl. References default_policies_. Referenced by get_cached_policy(), and get_policy(). { return this->default_policies_; }

ACE_INLINE TAO_Network_Priority_Protocols_Hooks * TAO_ORB_Core::get_network_priority_protocols_hooks (  void   )

Gets the value of TAO_ORB_Core::network_priority_protocols_hooks__. Definition at line 79 of file ORB_Core.inl. References network_priority_protocols_hooks_. { return this->network_priority_protocols_hooks_; }

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 3027 of file ORB_Core.cpp. References TAO_Objref_Var_T< T >::_retn(), 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); } if (CORBA::is_nil (result.in ())) { result = this->get_default_policies ()->get_policy (type); } 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 3046 of file ORB_Core.cpp. References TAO_Objref_Var_T< T >::_retn(), 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); if (CORBA::is_nil (result.in ())) { result = this->get_policy (type); } 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 73 of file ORB_Core.inl. 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 2878 of file ORB_Core.cpp. References delayed_transport_queueing_strategy_, eager_transport_queueing_strategy_, flush_transport_queueing_strategy_, and Messaging::SyncScope. { switch (scope) { case Messaging::SYNC_WITH_TRANSPORT: case Messaging::SYNC_WITH_SERVER: case Messaging::SYNC_WITH_TARGET: { return this->flush_transport_queueing_strategy_; } break; case Messaging::SYNC_NONE: { return this->eager_transport_queueing_strategy_; } break; case TAO::SYNC_DELAYED_BUFFERING: { return this->delayed_transport_queueing_strategy_; } break; default: { return 0; } } }

ACE_INLINE void * TAO_ORB_Core::get_tss_resource (  size_t  slot_id  )

Obtain the TSS resource in the given slot. Definition at line 263 of file ORB_Core.inl. 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 257 of file ORB_Core.inl. 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 1506 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 bool TAO_ORB_Core::has_shutdown (  void   )  const

Get the shutdown flag value. Definition at line 322 of file ORB_Core.inl. 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 131 of file ORB_Core.inl. 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 1443 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 1437 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 341 of file ORB_Core.inl. References implrepo_service_, and CORBA::Object_ptr. { this->implrepo_service_ = ir; }

CORBA::Object_ptr TAO_ORB_Core::implrepo_service (  void   )

Definition at line 2830 of file ORB_Core.cpp. References CORBA::Object::_duplicate(), CORBA::Object::_nil(), TAO_Pseudo_Var_T< T >::_retn(), ACE_GUARD_RETURN, 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_)) { try { CORBA::Object_var temp = this->orb_->resolve_initial_references ("ImplRepoService"); 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 (); } catch (const ::CORBA::Exception&) { // Just make sure that we have a null pointer. Ignore the exception // anyway. this->implrepo_service_ = CORBA::Object::_nil (); } } 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 353 of file ORB_Core.inl. 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>. Definition at line 338 of file ORB_Core.cpp. References CORBA::ORB::_tao_make_ORB(), CORBA::ORB::_use_omg_ior_format(), ACE_Arg_Shifter, ACE_CString, ACE_DEBUG, ACE_DEFAULT_CDR_MEMCPY_TRADEOFF, ACE_ERROR, ACE_GUARD_RETURN, ACE_LOG_MSG, ACE_NEW_THROW_EX, ACE_SignalHandler, ACE_TCHAR, ACE_TEXT, ACE_TEXT_ALWAYS_CHAR, ACE_TEXT_CHAR_TO_TCHAR, ACE_Time_Value, TAO_ORB_Parameters::add_endpoints(), TAO_ORB_Parameters::ami_collication(), ACE_OS::atoi(), TAO_ORB_Parameters::cache_incoming_by_dotted_decimal_address(), TAO_ORB_Parameters::cdr_memcpy_tradeoff(), codeset_manager(), codeset_manager_, collocation_strategy_, configuration(), TAO_ORB_Parameters::connect_ipv6_only(), TAO_Resource_Factory::create_flushing_strategy(), TAO_ORB_Parameters::default_init_ref(), DIRECT, TAO_ORB_Parameters::disable_rt_collocation_resolver(), TAO_ORB_Parameters::enforce_pref_interfaces(), flushing_strategy_, ACE_OS::fopen(), ACE_Argv_Type_Converter::get_argc(), TAO_Resource_Factory::get_protocol_factories(), ACE_Argv_Type_Converter::get_TCHAR_argv(), ACE_OS::getenv(), has_shutdown_, imr_endpoints_in_ior_, ACE_Shared_Object::init(), TAO::ObjectKey_Table::init(), TAO_Network_Priority_Protocols_Hooks::init_hooks(), TAO_Protocols_Hooks::init_hooks(), TAO_Resource_Factory::init_protocol_factories(), init_ref_map_, ACE_Array_Map< Key, Value, EqualTo >::insert(), TAO_ORB_Core_Static_Resources::instance(), ACE_Dynamic_Service< TYPE >::instance(), TAO_ORB_Parameters::linger(), LM_DEBUG, LM_ERROR, LM_WARNING, TAO_ORB_Parameters::max_message_size(), TAO_ORB_Parameters::mcast_discovery_endpoint(), TAO_ORB_Parameters::negotiate_codesets(), network_priority_protocols_hooks_, TAO_ORB_Parameters::nodelay(), object_key_table_, TAO_Codeset_Manager::open(), TAO_Server_Strategy_Factory::open(), TAO_Parser_Registry::open(), opt_for_collocation_, orb_, orb_params(), orb_params_, TAO_ORB_Parameters::parallel_connect_delay(), parser_registry_, TAO_ORB_Parameters::poa_factory_name(), TAO_ORB_Parameters::prefer_ipv6_interfaces(), TAO_ORB_Parameters::preferred_interfaces(), protocols_hooks_, TAO_ORB_Parameters::protocols_hooks_name(), reactor(), resource_factory(), server_factory(), server_id_, TAO_ORB_Parameters::service_port(), services_callbacks_init(), set_endpoint_helper(), TAO_ORB_Parameters::shared_profile(), SIG_IGN, ACE_OS::signal(), SIGPIPE, TAO_ORB_Parameters::single_read_optimization(), ACE_OS::snprintf(), TAO_ORB_Parameters::sock_dontroute(), TAO_ORB_Parameters::sock_keepalive(), TAO_ORB_Parameters::sock_rcvbuf_size(), TAO_ORB_Parameters::sock_sndbuf_size(), TAO_ORB_Parameters::std_profile_components(), ACE_OS::strcasecmp(), ACE_OS::strchr(), TAO_debug_level, TAO_DEFAULT_LANE, TAO_DEFAULT_THREAD_PER_CONNECTION_TIMEOUT, TAO_ORB_CORE_INIT_LOCATION_CODE, TAO_SYNCH_MUTEX, TAO_Server_Strategy_Factory::thread_per_connection_timeout(), THRU_POA, TAO_ORB_Parameters::use_dotted_decimal_addresses(), use_global_collocation_, use_implrepo_, TAO_ORB_Parameters::use_ipv6_link_local(), TAO_Resource_Factory::use_local_memory_pool(), TAO_ORB_Parameters::use_parallel_connects(), and ACE_Thread_Manager::wait_on_exit(). { // Right now, this code expects to begin parsing in argv[1] rather // than argv[0]. I don't think that's wise. I think we need to // change that convention to argv[0] and let the initializing code // make any necessary shifts. // // Parse arguments to the ORB. Typically the ORB is passed // arguments straight from the command line, so we will simply pass // through them and respond to the ones we understand and ignore // those we don't. // // In some instances, we may actually build another vector of // arguments and stash it for use initializing other components such // as the RootPOA. bool use_ior = true; int cdr_tradeoff = ACE_DEFAULT_CDR_MEMCPY_TRADEOFF; // The following things should be changed to use the ACE_Env_Value<> // template sometime. // Name Service port use for Multicast unsigned short ns_port = 0; // Trading Service port used for Multicast unsigned short ts_port = 0; // Implementation Repository Service port #. unsigned short ir_port = 0; // Buffer sizes for kernel socket buffers // @@ should be a default defined for each protocol implementation? // since we may have protocols loaded which use shared memory of // some form, fredk int rcv_sock_size = -1; int snd_sock_size = -1; // Use TCP_NODELAY. int nodelay = 1; // Use SO_KEEPALIVE (default 0). int so_keepalive = 0; // Use SO_DONTROUTE (default 0) int so_dontroute = 0; // Use dotted decimal addresses // @@ This option will be treated as a suggestion to each loaded // protocol to use a character representation for the numeric // address, otherwise use a logical name. fredk #if (TAO_USE_DOTTED_DECIMAL_ADDRESSES == 1) int dotted_decimal_addresses = 1; #else int dotted_decimal_addresses = 0; #endif /* TAO_USE_DOTTED_DECIMAL_ADDRESSES */ // Disable looking up the host name for incoming connections. int no_server_side_name_lookups = 0; #if defined (TAO_STD_PROFILE_COMPONENTS) int std_profile_components = 1; #else int std_profile_components = 0; #endif /* TAO_STD_PROFILE_COMPONENTS */ int linger = -1; int use_parallel_connects = 0; // Copy command line parameter not to use original. ACE_Argv_Type_Converter command_line (argc, argv); ACE_Arg_Shifter arg_shifter (command_line.get_argc (), command_line.get_TCHAR_argv ()); ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, monitor, this->lock_, -1); #if (TAO_NEGOTIATE_CODESETS == 1) int negotiate_codesets = 1; #else int negotiate_codesets = 0; #endif /* TAO_NEGOTIATE_CODESETS */ // Pick up the value of the use_implrepo_ flag from an environment variable // called "TAO_USE_IMR". Do it here so that it can be overridden by // the "-ORBUseIMR" command line argument. // char* const use_IMR_env_var_value = ACE_OS::getenv ("TAO_USE_IMR") ; if (use_IMR_env_var_value != 0) { this->use_implrepo_ = ACE_OS::atoi (use_IMR_env_var_value) ; } while (arg_shifter.is_anything_left ()) { const ACE_TCHAR *current_arg = 0; //////////////////////////////////////////////////////////////// // begin with the 'parameterless' flags // //////////////////////////////////////////////////////////////// if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBDottedDecimalAddresses")))) { // Use dotted decimal addresses // @@ this should be renamed. See above comment. fredk dotted_decimal_addresses = ACE_OS::atoi (current_arg); arg_shifter.consume_arg (); } else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBNoServerSideNameLookups")))) { // Don't look up the host name for incoming connections no_server_side_name_lookups = ACE_OS::atoi (current_arg); arg_shifter.consume_arg (); } else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBNameServicePort")))) { // Specify the port number for the NameService. // Unrelated to ORB Protocols, this is used for multicast. ns_port = static_cast <CORBA::UShort> (ACE_OS::atoi (current_arg)); arg_shifter.consume_arg (); } else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBMulticastDiscoveryEndpoint")))) { // Specify mcast address:port@network_interface for the // Naming Service Multicast Discovery Protocol. // If there is no colon, its only the port no. // If there is a '@' also, it means that the network // interface name is specified. this->orb_params ()->mcast_discovery_endpoint ( ACE_TEXT_ALWAYS_CHAR(current_arg)); arg_shifter.consume_arg (); } else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBNodelay")))) { // Use TCP_NODELAY or not. nodelay = ACE_OS::atoi (current_arg); arg_shifter.consume_arg (); } else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBKeepalive")))) { // Use SO_KEEPALIVE or not. so_keepalive = ACE_OS::atoi (current_arg); arg_shifter.consume_arg (); } else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBDontRoute")))) { // Use SO_DONTROUTE or not. so_dontroute = ACE_OS::atoi (current_arg); arg_shifter.consume_arg (); } else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBTradingServicePort")))) { // Specify the port number for the TradingService. ts_port = static_cast <CORBA::UShort> (ACE_OS::atoi (current_arg)); arg_shifter.consume_arg (); } else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBImplRepoServicePort")))) { // Specify the multicast port number for the Implementation // Repository. ir_port = static_cast <CORBA::UShort> (ACE_OS::atoi (current_arg)); arg_shifter.consume_arg (); } else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBRcvSock")))) { // @@ All protocol implementation may not use sockets, so // this can either be a generic I/O Buffer size or // Buffer info can be a per protocol specification, fredk // Specify the size of the socket's receive buffer rcv_sock_size = ACE_OS::atoi (current_arg); arg_shifter.consume_arg (); } else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBSndSock")))) { // @@ All protocol implementation may not use sockets, so // this can either be a generic I/O Buffer size or // Buffer info can be a per protocol specification, fredk // Specify the size of the socket's send buffer snd_sock_size = ACE_OS::atoi (current_arg); arg_shifter.consume_arg (); } else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBObjRefStyle")))) { // Specifies the style of printed objrefs: URL or IOR // // BEGIN COMMENTS FROM IIOP-1.4 On Win32, we should be // collecting information from the Registry such as what // ORBs are configured, specific configuration details like // whether they generate IOR or URL style stringified // objrefs and which addresses they listen to (e.g. allowing // multihomed hosts to implement firewalls), user-meaningful // orb names (they will normally indicate domains), and // more. // // On UNIX, we should collect that from some private config // file. // // Instead, this just treats the "internet" ORB name // specially and makes it always use URL-style stringified // objrefs, where the hostname and TCP port number are // explicit (and the whole objref is readable by mortals). // BEGIN COMMENTS FROM IIOP-1.4 const ACE_TCHAR *opt = current_arg; if (ACE_OS::strcasecmp (opt, ACE_TEXT("URL")) == 0) use_ior = false; else if (ACE_OS::strcasecmp (opt, ACE_TEXT("IOR")) == 0) use_ior = true; arg_shifter.consume_arg (); } else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBCollocationStrategy")))) { // Specify which collocation policy we want to use. const ACE_TCHAR *opt = current_arg; if (ACE_OS::strcasecmp (opt, ACE_TEXT("thru_poa")) == 0) this->collocation_strategy_ = THRU_POA; else if (ACE_OS::strcasecmp (opt, ACE_TEXT("direct")) == 0) this->collocation_strategy_ = DIRECT; arg_shifter.consume_arg (); } else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBCollocation")))) { // Specify whether we want to optimize against collocation // objects. Valid arguments are: "global", "no", and "per-orb". // Default is global. const ACE_TCHAR *opt = current_arg; if (ACE_OS::strcasecmp (opt, ACE_TEXT("global")) == 0) { this->opt_for_collocation_ = true; this->use_global_collocation_ = true; } else if (ACE_OS::strcasecmp (opt, ACE_TEXT("NO")) == 0) { this->opt_for_collocation_ = false; this->use_global_collocation_ = false; } else if (ACE_OS::strcasecmp (opt, ACE_TEXT("per-orb")) == 0) { this->opt_for_collocation_ = true; this->use_global_collocation_ = false; } else { ACE_DEBUG ((LM_WARNING, ACE_TEXT ("WARNING: Unknown option to ") ACE_TEXT ("'-ORBCollocation': %s\n"), opt)); } arg_shifter.consume_arg (); } else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBPreferredInterfaces")))) { if (this->orb_params ()->preferred_interfaces ( ACE_TEXT_ALWAYS_CHAR (current_arg)) == false) throw ::CORBA::INTERNAL ( CORBA::SystemException::_tao_minor_code ( TAO_ORB_CORE_INIT_LOCATION_CODE, 0), CORBA::COMPLETED_NO); arg_shifter.consume_arg (); } else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBEnforcePreferredInterfaces")))) { int enforce_pref_interfaces = ACE_OS::atoi (current_arg); if (enforce_pref_interfaces) this->orb_params ()->enforce_pref_interfaces (false); else this->orb_params ()->enforce_pref_interfaces (true); arg_shifter.consume_arg (); } #if defined (ACE_HAS_IPV6) else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBPreferIPV6Interfaces")))) { int prefer_ipv6_interfaces = ACE_OS::atoi (current_arg); if (prefer_ipv6_interfaces) this->orb_params ()->prefer_ipv6_interfaces (true); else this->orb_params ()->prefer_ipv6_interfaces (false); arg_shifter.consume_arg (); } else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBConnectIPV6Only")))) { int connect_ipv6_only = ACE_OS::atoi (current_arg); if (connect_ipv6_only) this->orb_params ()->connect_ipv6_only (true); else this->orb_params ()->connect_ipv6_only (false); arg_shifter.consume_arg (); } else if ((current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBUseIPV6LinkLocal")))) { int use_ipv6_link_local = ACE_OS::atoi (current_arg); if (use_ipv6_link_local) this->orb_params ()->use_ipv6_link_local (true); else this->orb_params ()->use_ipv6_link_local (false); arg_shifter.consume_arg (); } #endif /* ACE_HAS_IPV6 */ else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBCDRTradeoff")))) { cdr_tradeoff = ACE_OS::atoi (current_arg); arg_shifter.consume_arg (); } // A new <ObjectID>:<IOR> mapping has been specified. This will be // used by the resolve_initial_references (). else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBInitRef")))) { const ACE_TCHAR *pos = ACE_OS::strchr (current_arg, '='); if (pos == 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Invalid ORBInitRef argument '%s'") ACE_TEXT ("format is ObjectID=IOR\n"), current_arg)); throw ::CORBA::INTERNAL ( CORBA::SystemException::_tao_minor_code ( TAO_ORB_CORE_INIT_LOCATION_CODE, 0), CORBA::COMPLETED_NO); } ACE_CString object_id (ACE_TEXT_ALWAYS_CHAR(current_arg), pos - current_arg); ACE_CString IOR (ACE_TEXT_ALWAYS_CHAR(pos + 1)); if (!this->init_ref_map_.insert ( std::make_pair (InitRefMap::key_type (object_id), InitRefMap::data_type (IOR))).second) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Duplicate -ORBInitRef ") ACE_TEXT ("argument '%s'\n"), current_arg)); throw ::CORBA::INTERNAL ( CORBA::SystemException::_tao_minor_code ( TAO_ORB_CORE_INIT_LOCATION_CODE, 0), CORBA::COMPLETED_NO); } arg_shifter.consume_arg (); } else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBDefaultInitRef")))) { // Set the list of prefixes from -ORBDefaultInitRef. this->orb_params ()->default_init_ref (ACE_TEXT_ALWAYS_CHAR(current_arg)); arg_shifter.consume_arg (); } else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBStdProfileComponents")))) { std_profile_components = ACE_OS::atoi (current_arg); arg_shifter.consume_arg (); } else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBAMICollocation")))) { int ami_collocation = ACE_OS::atoi (current_arg); if (ami_collocation) this->orb_params ()->ami_collication (true); else this->orb_params ()->ami_collication (false); arg_shifter.consume_arg (); } else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBResources")))) { ACE_DEBUG ((LM_WARNING, ACE_TEXT ("\"-ORBResources\" has been ") ACE_TEXT ("deprecated.\n"))); arg_shifter.consume_arg (); } else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBLogFile")))) { // redirect all ACE_DEBUG and ACE_ERROR output to a file // USAGE: -ORBLogFile <file> // default: if <file> is present = append // if <file> is not present = create const ACE_TCHAR *file_name = current_arg; arg_shifter.consume_arg (); // would rather use ACE_OSTREAM_TYPE out here.. // but need ACE_FSTREAM_TYPE to call ->open(...) // and haven't found such a macro to rep FILE* and/or fstream* #if defined (ACE_LACKS_IOSTREAM_TOTALLY) FILE* output_stream = ACE_OS::fopen (file_name, ACE_TEXT ("a")); ACE_LOG_MSG->msg_ostream (output_stream, 1); #else /* ! ACE_LACKS_IOSTREAM_TOTALLY */ ofstream* output_stream = 0; // // note: we are allocating dynamic memory here....but // I assume it will persist for the life of the program // ACE_NEW_THROW_EX (output_stream, ofstream (), CORBA::NO_MEMORY ( CORBA::SystemException::_tao_minor_code ( TAO_ORB_CORE_INIT_LOCATION_CODE, ENOMEM), CORBA::COMPLETED_NO)); output_stream->open (ACE_TEXT_ALWAYS_CHAR (file_name), ios::out | ios::app); if (!output_stream->bad ()) { ACE_LOG_MSG->msg_ostream (output_stream, 1); } #endif /* ACE_LACKS_IOSTREAM_TOTALLY */ ACE_LOG_MSG->clr_flags (ACE_Log_Msg::STDERR | ACE_Log_Msg::LOGGER); ACE_LOG_MSG->set_flags (ACE_Log_Msg::OSTREAM); } else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBVerboseLogging")))) { unsigned long verbose_logging = ACE_OS::atoi (current_arg); arg_shifter.consume_arg (); typedef void (ACE_Log_Msg::*PTMF)(u_long); PTMF flagop = &ACE_Log_Msg::set_flags; u_long value; switch (verbose_logging) { case 0: flagop = &ACE_Log_Msg::clr_flags; value = ACE_Log_Msg::VERBOSE | ACE_Log_Msg::VERBOSE_LITE; break; case 1: value = ACE_Log_Msg::VERBOSE_LITE; break; default: value = ACE_Log_Msg::VERBOSE; break; } (ACE_LOG_MSG->*flagop)(value); } else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBUseIMR")))) { // Use IR or not. this->use_implrepo_ = ACE_OS::atoi (current_arg); arg_shifter.consume_arg (); } else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBIMREndpointsInIOR")))) { this->imr_endpoints_in_ior_ = ACE_OS::atoi (current_arg); arg_shifter.consume_arg (); } else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBid")))) { // The ORBid is actually set in ORB_init(), and then passed // to the TAO_ORB_Core() constructor. However, in the case // where the ORBid third argument to ORB_init() is not zero, // any "-ORBid" arguments in the argv argument list are // supposed to be ignored, according to the CORBA spec. As // such, "-ORBid" must be removed from the argument list // since ORB_init() must remove all "-ORB" option // arguments. // We obtain a lock on the ORB table when setting the // ORBid. For this reason we should *not* set the ORBid // here. CORBA::ORB_init() does all of the proper locking // and setting. arg_shifter.consume_arg (); } else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBServerId")))) { // The this->server_id_ is to uniquely identify a server to // an IMR. // Fill in later. this->server_id_.set(ACE_TEXT_ALWAYS_CHAR(current_arg)); arg_shifter.consume_arg (); } else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBLingerTimeout")))) { linger = ACE_OS::atoi (current_arg); arg_shifter.consume_arg (); } else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBEndpoint")))) { // Each "endpoint" is of the form: // // protocol://V.v@addr1,addr2,...,addrN // // or: // // protocol://addr1,addr2,...,addrN // // where "V.v" is an optional protocol version for each // addr. All endpoint strings should be of the above // form(s). // // Multiple sets of endpoint may be seperated by a semi-colon `;'. // For example: // // corbaloc:space:2001,1.2@odyssey:2010;uiop://foo,bar // // All endpoint strings should be of the above form(s). this->set_endpoint_helper (TAO_DEFAULT_LANE, ACE_TEXT_ALWAYS_CHAR (current_arg) ); arg_shifter.consume_arg (); } else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBListenEndpoints")))) { // This option is similar to the -ORBEndPoint option. May be // ORBEndpoint option will be deprecated in future. But, for // now, I (Priyanka) am leaving so that both options can be // used. this->set_endpoint_helper (TAO_DEFAULT_LANE, ACE_TEXT_ALWAYS_CHAR (current_arg) ); arg_shifter.consume_arg (); } else if ((0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBLaneEndpoint")))) || (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBLaneListenEndpoints"))))) { // This option is similar to the -ORBEndPoint option but // specifies endpoints for each lane. if (arg_shifter.is_option_next ()) return -1; ACE_CString lane (ACE_TEXT_ALWAYS_CHAR (current_arg)); arg_shifter.consume_arg (); if (arg_shifter.is_option_next ()) return -1; ACE_CString endpoints (ACE_TEXT_ALWAYS_CHAR (arg_shifter.get_current ())); arg_shifter.consume_arg (); this->set_endpoint_helper (lane, endpoints ); } else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBNoProprietaryActivation")))) { // This option can be used to set to not use any proprietary // activation framework. The only TAO proprietary activation // framework is IMR. So, by setting this option in TAO, the // IMR shouldnt be used .. even if the ORBUseIMR option is // set. // Fill in later // @@ To do later: Priyanka. throw ::CORBA::NO_IMPLEMENT (); } else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBUseSharedProfile")))) { this->orb_params ()->shared_profile (ACE_OS::atoi (current_arg)); arg_shifter.consume_arg (); } else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBNegotiateCodesets")))) { negotiate_codesets = (ACE_OS::atoi (current_arg)); arg_shifter.consume_arg (); } else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBUseParallelConnects")))) { use_parallel_connects = ACE_OS::atoi (current_arg); arg_shifter.consume_arg (); } else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBParallelConnectDelay")))) { this->orb_params ()->parallel_connect_delay (ACE_OS::atoi (current_arg)); arg_shifter.consume_arg (); } else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBSingleReadOptimization")))) { this->orb_params ()->single_read_optimization (ACE_OS::atoi (current_arg)); arg_shifter.consume_arg (); } else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBDisableRTCollocation")))) { int disable_rt_collocation = ACE_OS::atoi (current_arg); if (disable_rt_collocation) this->orb_params ()->disable_rt_collocation_resolver (true); else this->orb_params ()->disable_rt_collocation_resolver (false); arg_shifter.consume_arg (); } else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBUseLocalMemoryPool")))) { this->use_local_memory_pool_ = (0 != ACE_OS::atoi (current_arg)); arg_shifter.consume_arg (); } else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ORBMaxMessageSize")))) { this->orb_params_.max_message_size (ACE_OS::atoi (current_arg)); arg_shifter.consume_arg (); } //////////////////////////////////////////////////////////////// // catch any unknown -ORB args // //////////////////////////////////////////////////////////////// else if (arg_shifter.cur_arg_strncasecmp (ACE_TEXT("-ORB")) != -1) { if (TAO_debug_level > 0) { current_arg = arg_shifter.get_current (); ACE_ERROR ((LM_ERROR, ACE_TEXT ("ERROR: Unknown \"-ORB\" option ") ACE_TEXT ("<%s>.\n"), ((current_arg == 0) ? ACE_TEXT("<NULL>") : current_arg))); } throw ::CORBA::BAD_PARAM ( CORBA::SystemException::_tao_minor_code ( TAO_ORB_CORE_INIT_LOCATION_CODE, EINVAL), CORBA::COMPLETED_NO); } //////////////////////////////////////////////////////////////// // ok, we can't interpret this argument, move to next argument// //////////////////////////////////////////////////////////////// else { // Any arguments that don't match are ignored so that the // caller can still use them. arg_shifter.ignore_arg (); } } const char *env_endpoint = ACE_OS::getenv ("TAO_ORBENDPOINT"); if (env_endpoint != 0) { int result = this->orb_params ()->add_endpoints (TAO_DEFAULT_LANE, env_endpoint); if (result != 0) { if (TAO_debug_level > 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("ERROR: Environment variable ") ACE_TEXT ("TAO_ORBENDPOINT set to invalid value ") ACE_TEXT ("<%s>.\n"), env_endpoint)); } throw ::CORBA::BAD_PARAM ( CORBA::SystemException::_tao_minor_code ( TAO_ORB_CORE_INIT_LOCATION_CODE, EINVAL), CORBA::COMPLETED_NO); } } #if defined (SIGPIPE) && !defined (ACE_LACKS_UNIX_SIGNALS) // There's really no way to deal with this in a portable manner, so // we just have to suck it up and get preprocessor conditional and // ugly. // // Impractical to have each call to the ORB protect against the // implementation artifact of potential writes to dead connections, // as it'd be way expensive. Do it here; who cares about SIGPIPE in // these kinds of applications, anyway? (void) ACE_OS::signal (SIGPIPE, (ACE_SignalHandler) SIG_IGN); #endif /* SIGPIPE */ // Calling the open method here so that the svc.conf file is // opened and TAO_default_resource_factory::init () is called by the // time this method is called. this->parser_registry_.open (this); // Initialize the pointers to resources in the ORB Core instance, // e.g., reactor, connector, etc. Must do this after we open // services because we'll load the factory from there. TAO_Resource_Factory *trf = this->resource_factory (); if (trf == 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) %p\n"), ACE_TEXT ("ORB Core unable to find a ") ACE_TEXT ("Resource Factory instance"))); throw ::CORBA::INTERNAL ( CORBA::SystemException::_tao_minor_code ( TAO_ORB_CORE_INIT_LOCATION_CODE, 0), CORBA::COMPLETED_NO); } // Set whether or not to use the local memory pool for the cdr allocators. trf->use_local_memory_pool (this->use_local_memory_pool_); // @@ ???? // Make sure the reactor is initialized... ACE_Reactor *reactor = this->reactor (); if (reactor == 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) %p\n"), ACE_TEXT ("ORB Core unable to initialize reactor"))); throw ::CORBA::INITIALIZE ( CORBA::SystemException::_tao_minor_code ( TAO_ORB_CORE_INIT_LOCATION_CODE, 0), CORBA::COMPLETED_NO); } TAO_Server_Strategy_Factory *ssf = this->server_factory (); if (ssf == 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) %p\n"), ACE_TEXT ("ORB Core unable to find a ") ACE_TEXT ("Server Strategy Factory instance"))); throw ::CORBA::INTERNAL ( CORBA::SystemException::_tao_minor_code ( TAO_ORB_CORE_INIT_LOCATION_CODE, 0), CORBA::COMPLETED_NO); } ssf->open (this); // Open the ObjectKey_Table (void) this->object_key_table_.init (this); // Obtain the timeout value for the thread-per-connection model this->thread_per_connection_use_timeout_ = ssf->thread_per_connection_timeout (this->thread_per_connection_timeout_); if (thread_per_connection_use_timeout_ == -1) { if (ACE_OS::strcasecmp (TAO_DEFAULT_THREAD_PER_CONNECTION_TIMEOUT, "INFINITE") == 0) { this->thread_per_connection_use_timeout_ = 0; } else { this->thread_per_connection_use_timeout_ = 1; int milliseconds = ACE_OS::atoi (TAO_DEFAULT_THREAD_PER_CONNECTION_TIMEOUT); // Use a temporary to obtain automatic normalization. this->thread_per_connection_timeout_ = ACE_Time_Value (0, 1000 * milliseconds); } } if (this->thread_per_connection_use_timeout_ == 0) { // Do not wait for the server threads because they may block // forever. this->tm_.wait_on_exit (0); } // Initialize the "ORB" pseudo-object now. this->orb_ = CORBA::ORB::_tao_make_ORB (this); // This should probably move into the ORB Core someday rather then // being done at this level. this->orb_->_use_omg_ior_format (use_ior); // Set all kinds of orb parameters whose setting needed to be // deferred until after the service config entries had been // determined. this->orb_params ()->service_port (TAO::MCAST_NAMESERVICE, ns_port); if (ns_port != 0) { static char const mcast_fmt[] = "mcast://:%d::"; static size_t const PORT_BUF_SIZE = 256; char def_init_ref[PORT_BUF_SIZE] = { 0 }; ACE_OS::snprintf (def_init_ref, PORT_BUF_SIZE, mcast_fmt, ns_port); this->orb_params ()->default_init_ref (def_init_ref); } this->orb_params ()->service_port (TAO::MCAST_TRADINGSERVICE, ts_port); this->orb_params ()->service_port (TAO::MCAST_IMPLREPOSERVICE, ir_port); this->orb_params ()->use_dotted_decimal_addresses (dotted_decimal_addresses); // When caching incoming transports don't use the host name if // -ORBDottedDecimalAddresses or -ORBNoServerSideNameLookups is true. this->orb_params ()->cache_incoming_by_dotted_decimal_address (no_server_side_name_lookups || dotted_decimal_addresses); this->orb_params ()->use_parallel_connects (use_parallel_connects != 0); this->orb_params ()->linger (linger); this->orb_params ()->nodelay (nodelay); this->orb_params ()->sock_keepalive (so_keepalive); this->orb_params ()->sock_dontroute (so_dontroute); if (rcv_sock_size >= 0) this->orb_params ()->sock_rcvbuf_size (rcv_sock_size); if (snd_sock_size >= 0) this->orb_params ()->sock_sndbuf_size (snd_sock_size); if (cdr_tradeoff >= 0) this->orb_params ()->cdr_memcpy_tradeoff (cdr_tradeoff); this->orb_params ()->std_profile_components (std_profile_components); this->orb_params ()->negotiate_codesets (negotiate_codesets); if (this->codeset_manager()) this->codeset_manager_->open(); else if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, ACE_TEXT("TAO (%P|%t) ORB_Core: ") ACE_TEXT("Codeset Manager not available\n"))); // Set up the pluggable protocol infrastructure. First get a // pointer to the protocol factories set, then obtain pointers to // all factories loaded by the service configurator. // Load all protocol factories! if (trf->init_protocol_factories () == -1) throw ::CORBA::INITIALIZE ( CORBA::SystemException::_tao_minor_code ( TAO_ORB_CORE_INIT_LOCATION_CODE, 0), CORBA::COMPLETED_NO); // init the ORB core's pointer this->protocol_factories_ = trf->get_protocol_factories (); // Initialize the flushing strategy this->flushing_strategy_ = trf->create_flushing_strategy (); // Look in the service repository for an instance of the Protocol Hooks. const char *protocols_hooks_name = this->orb_params ()->protocols_hooks_name (); this->protocols_hooks_ = ACE_Dynamic_Service<TAO_Protocols_Hooks>::instance (this->configuration (), ACE_TEXT_CHAR_TO_TCHAR (protocols_hooks_name)); if (this->protocols_hooks_ != 0) { // Initialize the protocols hooks instance. this->protocols_hooks_->init_hooks (this); } // If available, allow the Adapter Factory to setup. ACE_Service_Object *adapter_factory = ACE_Dynamic_Service<ACE_Service_Object>::instance ( this->configuration (), this->orb_params ()->poa_factory_name ()); if (adapter_factory != 0) { adapter_factory->init (0, 0); } // Look in the service repository for an instance of the // Network Priority Protocol Hooks. const ACE_CString &network_priority_protocols_hooks_name = TAO_ORB_Core_Static_Resources::instance ()-> network_priority_protocols_hooks_name_; this->network_priority_protocols_hooks_ = ACE_Dynamic_Service<TAO_Network_Priority_Protocols_Hooks>::instance (this->configuration (), ACE_TEXT_CHAR_TO_TCHAR (network_priority_protocols_hooks_name.c_str())); if (this->network_priority_protocols_hooks_ != 0) { // Initialize the protocols hooks instance. this->network_priority_protocols_hooks_->init_hooks (this); } // As a last step perform initializations of the service callbacks this->services_callbacks_init (); // The ORB has been initialized, meaning that the ORB is no longer // in the shutdown state. this->has_shutdown_ = false; return 0; }

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

Return a pointer to the -ORBInitRef map. Definition at line 172 of file ORB_Core.inl. 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 1955 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 1974 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 2718 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 2712 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 2724 of file ORB_Core.cpp. References TAO_Thread_Lane_Resources::input_cdr_msgblock_allocator(), and lane_resources(). Referenced by TAO_GIOP_Message_Base::make_queued_data(), 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 3128 of file ORB_Core.cpp. References ACE_GUARD_RETURN, ACE_TEXT_CHAR_TO_TCHAR, 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) { 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 (); } } catch (const ::CORBA::Exception& ex) { ex._tao_print_exception ( "Cannot initialize the ior_interceptor_adapter \n"); } } } 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 1467 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 1461 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 2041 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 2017 of file ORB_Core.cpp. References TAO_MProfile::add_profile(), is_collocated(), optimize_collocation_objects(), service_profile_selection(), and use_global_collocation(). Referenced by create_object(), and initialize_object_i(). { TAO_MProfile mp_temp; TAO_Profile* profile = 0; if (this->service_profile_selection(mp, profile) && profile) { mp_temp.add_profile(profile); } if (!orb_core->optimize_collocation_objects ()) return 0; if (!orb_core->use_global_collocation () && orb_core != this) return 0; if (!orb_core->is_collocated (profile ? mp_temp : 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 585 of file ORB_Core.inl. 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 (); CORBA::Boolean const 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 114 of file ORB_Core.inl. 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 2336 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 2060 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 2066 of file ORB_Core.cpp. References TAO_Thread_Lane_Resources_Manager::lf_strategy(), and thread_lane_resources_manager(). Referenced by 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 (  void   )

List all the service known by the ORB. Definition at line 2654 of file ORB_Core.cpp. References TAO_Seq_Var_Base_T< T >::_retn(), 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 ()); 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 1883 of file ORB_Core.cpp. References 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_INLINE ACE_Lock * TAO_ORB_Core::locking_strategy (  void   )

Return the locking strategy used for the data blocks. Definition at line 34 of file ORB_Core.inl. 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 185 of file ORB_Core.inl. 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 102 of file ORB_Core.inl. 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 = false; 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 61 of file ORB_Core.inl. 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 55 of file ORB_Core.inl. 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 198 of file ORB_Core.inl. References opt_for_collocation_. { return this->opt_for_collocation_; }

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

Definition at line 192 of file ORB_Core.inl. 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 154 of file ORB_Core.inl. 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 222 of file ORB_Core.inl. 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(), endpoint_selector_factory(), TAO_Transport::handle_input_parse_data(), TAO_IIOP_Acceptor::hostname(), init(), 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_CORBALOC_Parser::parse_string(), TAO_IIOP_Acceptor::probe_interfaces(), TAO_GIOP_Message_Base::process_request_message(), resolve_rir(), CORBA::ORB::resolve_service(), root_poa(), TAO_ServerRequest::send_cached_reply(), set_endpoint_helper(), stub_factory(), TAO_ServerRequest::tao_send_reply_exception(), thread_lane_resources_manager(), 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 335 of file ORB_Core.inl. 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 434 of file ORB_Core.inl. 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 1582 of file ORB_Core.cpp. References ACE_DYNAMIC_SERVICE_DIRECTIVE, ACE_TEXT, configuration(), and orbinitializer_registry_. Referenced by orbinitializer_registry(). { // @todo The ORBInitializer_Registry is supposed to be a singleton. ACE_Service_Gestalt * const config = this->configuration (); // If not, lookup it up. this->orbinitializer_registry_ = ACE_Dynamic_Service<TAO::ORBInitializer_Registry_Adapter>::instance (config, 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 (this->orbinitializer_registry_ == 0) { config->process_directive ( ACE_DYNAMIC_SERVICE_DIRECTIVE ("ORBInitializer_Registry", "TAO_PI", "_make_ORBInitializer_Registry", "")); this->orbinitializer_registry_ = ACE_Dynamic_Service<TAO::ORBInitializer_Registry_Adapter>::instance (config, 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 2737 of file ORB_Core.cpp. References lane_resources(), and TAO_Thread_Lane_Resources::output_cdr_buffer_allocator(). { 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 2730 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_ServerRequest::send_cached_reply(), 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 2744 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_ServerRequest::send_cached_reply(), 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 239 of file ORB_Core.inl. 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 560 of file ORB_Core.inl. 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 550 of file ORB_Core.inl. 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 1816 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.

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 498 of file ORB_Core.inl. 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 446 of file ORB_Core.inl. 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 1551 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 249 of file ORB_Core.inl. 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 233 of file ORB_Core.inl. 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 2824 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(), init(), 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 1966 of file ORB_Core.cpp. References TAO_Stub::base_profiles(), TAO_Stub::forward_profiles(), and initialize_object_i(). Referenced by CORBA::Object::_set_policy_overrides(). { 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 1840 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 166 of file ORB_Core.inl. 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 CORBA::Object_ptr TAO_ORB_Core::resolve_codecfactory (  void   )

Resolve the CodecFactory DLL. Definition at line 387 of file ORB_Core.inl. References CORBA::Object::_duplicate(), 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 (); } return CORBA::Object::_duplicate (this->codec_factory_); }

void TAO_ORB_Core::resolve_codecfactory_i (  void   )  [protected]

Obtain and cache the codec factory object reference. Definition at line 2375 of file ORB_Core.cpp. References ACE_DYNAMIC_SERVICE_DIRECTIVE, 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_INLINE CORBA::Object_ptr TAO_ORB_Core::resolve_compression_manager (  void   )

Resolve the Compression DLL. Definition at line 399 of file ORB_Core.inl. References CORBA::Object::_duplicate(), ACE_GUARD_RETURN, CORBA::is_nil(), resolve_compression_manager_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->compression_manager_)) { this->resolve_compression_manager_i (); } return CORBA::Object::_duplicate (this->compression_manager_); }

void TAO_ORB_Core::resolve_compression_manager_i (  void   )  [protected]

Obtain and cache the compression manager object reference. Definition at line 2402 of file ORB_Core.cpp. References ACE_DYNAMIC_SERVICE_DIRECTIVE, ACE_TEXT, compression_manager_, configuration(), TAO_Object_Loader::create_object(), and ACE_Service_Gestalt::process_directive(). Referenced by resolve_compression_manager(). { TAO_Object_Loader *loader = ACE_Dynamic_Service<TAO_Object_Loader>::instance (this->configuration (), ACE_TEXT ("Compression_Loader")); if (loader == 0) { this->configuration()->process_directive (ACE_DYNAMIC_SERVICE_DIRECTIVE("Compression", "TAO_Compression", "_make_TAO_Compression_Loader", "")); loader = ACE_Dynamic_Service<TAO_Object_Loader>::instance (this->configuration (), ACE_TEXT ("Compression_Loader")); } if (loader != 0) { this->compression_manager_ = loader->create_object (this->orb_, 0, 0); } }

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

Resolve the Dynamic Any Factory. Definition at line 458 of file ORB_Core.inl. References CORBA::Object::_duplicate(), 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 (); } return CORBA::Object::_duplicate (this->dynany_factory_); }

void TAO_ORB_Core::resolve_dynanyfactory_i (  void   )  [protected]

Obtain and cache the dynamic any factory object reference. Definition at line 2488 of file ORB_Core.cpp. References ACE_DYNAMIC_SERVICE_DIRECTIVE, 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_INLINE CORBA::Object_ptr TAO_ORB_Core::resolve_ior_manipulation (  void   )

Resolve the IOR Manipulation reference for this ORB. Definition at line 470 of file ORB_Core.inl. References CORBA::Object::_duplicate(), 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 (); } return CORBA::Object::_duplicate (this->ior_manip_factory_); }

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

Resolve the IOR Table reference for this ORB. Definition at line 482 of file ORB_Core.inl. References CORBA::Object::_duplicate(), 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 (); } return CORBA::Object::_duplicate (this->ior_table_); }

void TAO_ORB_Core::resolve_ior_table_i (  void   )  [private]

Obtain and cache the dynamic any factory object reference. Definition at line 2541 of file ORB_Core.cpp. References TAO_Pseudo_Var_T< T >::_retn(), ACE_DYNAMIC_SERVICE_DIRECTIVE, 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 (); CORBA::Object_var tmp_root = iortable_adapter->root (); this->adapter_registry_.insert (iortable_adapter.get ()); // 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 (  void   )  [protected]

Obtain and cache the IORManipulation factory object reference. Definition at line 2515 of file ORB_Core.cpp. References ACE_DYNAMIC_SERVICE_DIRECTIVE, 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_INLINE CORBA::Object_ptr TAO_ORB_Core::resolve_picurrent (  void   )

Resolve the PICurrent. Definition at line 373 of file ORB_Core.inl. References CORBA::Object::_duplicate(), 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 (); } return CORBA::Object::_duplicate (this->pi_current_); }

void TAO_ORB_Core::resolve_picurrent_i (  void   )  [protected]

Obtain and cache the picurrent factory object reference. Definition at line 2457 of file ORB_Core.cpp. References ACE_DYNAMIC_SERVICE_DIRECTIVE, 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); this->pi_current_ = pi; } }

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

Resolve POA Current. Definition at line 506 of file ORB_Core.inl. References CORBA::Object::_duplicate(), 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 (); } return CORBA::Object::_duplicate (this->poa_current_.in ()); }

void TAO_ORB_Core::resolve_poa_current_i (  void   )  [protected]

Obtain and cache the poa current. Definition at line 2428 of file ORB_Core.cpp. References ACE_DYNAMIC_SERVICE_DIRECTIVE, 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); } }

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

Resolve an initial reference via the -ORBInitRef and. Definition at line 2597 of file ORB_Core.cpp. References CORBA::Object::_nil(), ACE_CString, 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 (); // 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 ()); } 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 529 of file ORB_Core.inl. 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 (  void   )

Resolve the TypeCodeFactory DLL. Definition at line 359 of file ORB_Core.inl. References CORBA::Object::_duplicate(), 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 (); } return CORBA::Object::_duplicate (this->typecode_factory_); }

void TAO_ORB_Core::resolve_typecodefactory_i (  void   )  [protected]

Obtain and cache the typecode factory object reference. Definition at line 2342 of file ORB_Core.cpp. References ACE_DYNAMIC_SERVICE_DIRECTIVE, ACE_ERROR, ACE_TEXT, 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"))); throw ::CORBA::ORB::InvalidName (); } } this->typecode_factory_ = loader->create_object (this->orb_, 0, 0); }

TAO_Resource_Factory * TAO_ORB_Core::resource_factory (  void   )

Returns pointer to the resource factory. Definition at line 1485 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(), init(), 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 (  void   )

Return the RootPOA, or try to load it if not initialized already. Definition at line 1760 of file ORB_Core.cpp. References CORBA::Object::_duplicate(), CORBA::Object::_nil(), ACE_GUARD_RETURN, ACE_TEXT_CHAR_TO_TCHAR, adapter_registry_, configuration(), TAO_Adapter_Factory::create(), ACE_Auto_Basic_Ptr< X >::get(), TAO_Adapter_Registry::insert(), CORBA::is_nil(), orb_params(), poa_adapter(), TAO_ORB_Parameters::poa_factory_name(), ACE_Service_Gestalt::process_directive(), ACE_Auto_Basic_Ptr< X >::release(), 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_Adapter_Factory *factory = ACE_Dynamic_Service<TAO_Adapter_Factory>::instance (this->configuration (), this->orb_params ()->poa_factory_name ()); if (factory == 0) { this->configuration()->process_directive ( ACE_TEXT_CHAR_TO_TCHAR ( this->orb_params ()->poa_factory_directive ())); factory = ACE_Dynamic_Service<TAO_Adapter_Factory>::instance (this->configuration (), this->orb_params ()->poa_factory_name ()); } 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 ())) { auto_ptr<TAO_Adapter> poa_adapter (factory->create (this)); poa_adapter->open (); // @@ Not exception safe this->root_poa_ = poa_adapter->root (); this->adapter_registry_.insert (poa_adapter.get ()); poa_adapter.release (); } } 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 2072 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 () == false) { // 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 () == true && 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 1745 of file ORB_Core.cpp. References ACE_TEXT, configuration(), and server_factory_. Referenced by TAO_Concurrency_Strategy< SVC_HANDLER >::activate_svc_handler(), and init(). { 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 411 of file ORB_Core.inl. 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 574 of file ORB_Core.inl. 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 3283 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 1709 of file ORB_Core.cpp. References network_priority_protocols_hooks_, TAO_Network_Priority_Protocols_Hooks::np_service_context(), protocols_hooks_, and TAO_Protocols_Hooks::rt_service_context(). Referenced by TAO::Remote_Invocation::init_target_spec(). { // @NOTE: Can use Interceptors instead.. if (this->protocols_hooks_ != 0) { this->protocols_hooks_->rt_service_context (stub, service_context, restart); } // call the network priority protocols hooks that has been // registered. if (network_priority_protocols_hooks_ != 0) { this->network_priority_protocols_hooks_->np_service_context (stub, service_context, restart); } }

ACE_INLINE CORBA::Boolean TAO_ORB_Core::service_profile_selection (  const 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 85 of file ORB_Core.inl. References ft_service_, TAO_Service_Callbacks::select_profile(), and TAO_Fault_Tolerance_Service::service_callback(). Referenced by is_collocation_enabled(). { CORBA::Boolean retval = false; // @@ 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 1675 of file ORB_Core.cpp. References ft_service_, TAO_Fault_Tolerance_Service::service_callback(), IOP::ServiceContextList, and TAO_INVOCATION_RECV_REQUEST_MINOR_CODE. Referenced by TAO::Synch_Twoway_Invocation::wait_for_reply(). { if (this->ft_service_.service_callback ()) { return this->ft_service_.service_callback ()-> raise_comm_failure (clist, profile); } throw ::CORBA::COMM_FAILURE ( CORBA::SystemException::_tao_minor_code ( TAO_INVOCATION_RECV_REQUEST_MINOR_CODE, errno), CORBA::COMPLETED_MAYBE); }

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 1694 of file ORB_Core.cpp. References ft_service_, TAO_Service_Callbacks::raise_transient_failure(), TAO_Fault_Tolerance_Service::service_callback(), and IOP::ServiceContextList. Referenced by TAO::Synch_Twoway_Invocation::handle_system_exception(). { if (this->ft_service_.service_callback ()) { return this->ft_service_.service_callback ()->raise_transient_failure (clist, profile); } 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 1664 of file ORB_Core.cpp. References ft_service_, and TAO_Fault_Tolerance_Service::init(). Referenced by 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 }

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 178 of file ORB_Core.inl. 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); }

ACE_INLINE void TAO_ORB_Core::set_delayed_transport_queueing_strategy (  TAO::Transport_Queueing_Strategy *  strategy  )

Definition at line 626 of file ORB_Core.inl. References delayed_transport_queueing_strategy_. { this->delayed_transport_queueing_strategy_ = strategy; }

ACE_INLINE void TAO_ORB_Core::set_eager_transport_queueing_strategy (  TAO::Transport_Queueing_Strategy *  strategy  )

Definition at line 618 of file ORB_Core.inl. References eager_transport_queueing_strategy_. { this->eager_transport_queueing_strategy_ = strategy; }

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 2576 of file ORB_Core.cpp. References ACE_ERROR, ACE_TEXT, ACE_TEXT_CHAR_TO_TCHAR, TAO_ORB_Parameters::add_endpoints(), LM_ERROR, orb_params(), and TAO_ORB_CORE_INIT_LOCATION_CODE. Referenced by init(). { 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 ()))); throw ::CORBA::BAD_PARAM ( CORBA::SystemException::_tao_minor_code ( TAO_ORB_CORE_INIT_LOCATION_CODE, EINVAL), CORBA::COMPLETED_NO); } return 0; }

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 1409 of file ORB_Core.cpp. References ACE_DEBUG, TAO_TSS_Resources::gui_resource_factory_, TAO_TSS_Resources::instance(), LM_DEBUG, and TAO_debug_level. { if (TAO_TSS_Resources::instance ()->gui_resource_factory_ != 0) { if (TAO_debug_level > 2) { ACE_DEBUG ((LM_DEBUG, "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_network_priority_protocols_hooks (  const char *  network_priority_protocols_hooks_name  )  [static]

Sets the value of TAO_ORB_Core::network_priority_protocols_hooks_. Definition at line 1654 of file ORB_Core.cpp. References TAO_ORB_Core_Static_Resources::instance(). { // Is synchronization necessary? TAO_ORB_Core_Static_Resources::instance ()-> network_priority_protocols_hooks_name_ = network_priority_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 1402 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; }

ACE_INLINE void TAO_ORB_Core::set_sync_scope_hook (  Sync_Scope_Hook  hook  )

Definition at line 601 of file ORB_Core.inl. References Sync_Scope_Hook, and sync_scope_hook_. { this->sync_scope_hook_ = hook; }

ACE_INLINE void TAO_ORB_Core::set_timeout_hook (  Timeout_Hook  hook  )

Definition at line 608 of file ORB_Core.inl. References Timeout_Hook, and timeout_hook_. { // Saving the hook pointer so that we can use it later when needed. this->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 275 of file ORB_Core.inl. 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 2191 of file ORB_Core.cpp. References CORBA::Object::_nil(), 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 () == true) 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); // Set the 'has_shutdown' flag, so any further attempt to shutdown // becomes a noop. this->has_shutdown_ = true; // 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); // 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 1616 of file ORB_Core.cpp. References ACE_TEXT_CHAR_TO_TCHAR, configuration(), orb_params(), stub_factory_, and TAO_ORB_Parameters::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 char *stub_factory_name = this->orb_params ()->stub_factory_name (); this->stub_factory_ = ACE_Dynamic_Service<TAO_Stub_Factory>::instance (this->configuration (), ACE_TEXT_CHAR_TO_TCHAR (stub_factory_name)); return this->stub_factory_; }

ACE_INLINE ACE_Thread_Manager * TAO_ORB_Core::thr_mgr (  void   )

Get the ACE_Thread_Manager. Definition at line 148 of file ORB_Core.inl. 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 1513 of file ORB_Core.cpp. References ACE_TEXT_CHAR_TO_TCHAR, configuration(), TAO_Thread_Lane_Resources_Manager_Factory::create_thread_lane_resources_manager(), orb_params(), thread_lane_resources_manager_, and TAO_ORB_Parameters::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 char *thread_lane_resources_manager_factory_name = this->orb_params ()->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)); 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 328 of file ORB_Core.inl. 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 2751 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 316 of file ORB_Core.inl. 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 1455 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 1449 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 210 of file ORB_Core.inl. References use_global_collocation_. { return this->use_global_collocation_; }

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

Definition at line 204 of file ORB_Core.inl. 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 347 of file ORB_Core.inl. References use_implrepo_. { return use_implrepo_; }

TAO_Valuetype_Adapter * TAO_ORB_Core::valuetype_adapter (  void   )

Return the valuetype adapter. Definition at line 3313 of file ORB_Core.cpp. References ACE_GUARD_RETURN, 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) { 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 (); } } catch (const ::CORBA::Exception& ex) { ex._tao_print_exception ( "Cannot initialize the valuetype_adapter \n"); } } if (this->valuetype_adapter_ == 0) { throw ::CORBA::INTERNAL (); } } 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 1479 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 1473 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 *  )  [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 1119 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 1205 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 1208 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 1071 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 1188 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 1010 of file ORB_Core.h. Referenced by fini(), and resolve_codecfactory_i().

TAO_Codeset_Manager* TAO_ORB_Core::codeset_manager_ [protected]

Code Set Manager, received from the Resource Factory. Definition at line 1214 of file ORB_Core.h. Referenced by codeset_manager(), init(), and ~TAO_ORB_Core().

TAO_Collocation_Resolver* TAO_ORB_Core::collocation_resolver_ [protected]

Definition at line 990 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 1095 of file ORB_Core.h. Referenced by get_collocation_strategy(), and init().

CORBA::Object_ptr TAO_ORB_Core::compression_manager_ [protected]

The cached IOR for the Compression DLL. Definition at line 1013 of file ORB_Core.h. Referenced by resolve_compression_manager_i().

ACE_Service_Gestalt* TAO_ORB_Core::config_ [protected]

ORB's service configuration. Definition at line 1217 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 1128 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 1103 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 1166 of file ORB_Core.h.

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

This strategy will buffer messages. Definition at line 1157 of file ORB_Core.h. Referenced by get_transport_queueing_strategy(), set_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 1016 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 1154 of file ORB_Core.h. Referenced by get_transport_queueing_strategy(), set_eager_transport_queueing_strategy(), and ~TAO_ORB_Core().

TAO_Endpoint_Selector_Factory* TAO_ORB_Core::endpoint_selector_factory_ [protected]

Definition at line 1149 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 1161 of file ORB_Core.h. Referenced by get_transport_queueing_strategy(), and ~TAO_ORB_Core().

TAO_Flushing_Strategy* TAO_ORB_Core::flushing_strategy_ [protected]

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

TAO_Fault_Tolerance_Service TAO_ORB_Core::ft_service_ [protected]

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

bool TAO_ORB_Core::has_shutdown_ [protected]

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

CORBA::Object_ptr TAO_ORB_Core::implrepo_service_ [protected]

The cached IOR for the Implementation Repository. Definition at line 998 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 1004 of file ORB_Core.h. Referenced by imr_endpoints_in_ior(), and init().

InitRefMap TAO_ORB_Core::init_ref_map_ [protected]

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

TAO_IORInterceptor_Adapter* TAO_ORB_Core::ior_interceptor_adapter_ [protected]

IORInterceptor adapter. Definition at line 1196 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 1019 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 1022 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 986 of file ORB_Core.h.

TAO_Network_Priority_Protocols_Hooks* TAO_ORB_Core::network_priority_protocols_hooks_

Handle to the factory for network_priority_protocols_hooks_.. Definition at line 537 of file ORB_Core.h. Referenced by get_network_priority_protocols_hooks(), init(), and service_context_list().

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 1059 of file ORB_Core.h. Referenced by fini(), init(), 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 1056 of file ORB_Core.h. Referenced by list_initial_references(), object_ref_table(), and shutdown().

TAO_SYNCH_MUTEX TAO_ORB_Core::open_lock_ [protected]

Mutual exclusion for calling open. Definition at line 1147 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 1088 of file ORB_Core.h. Referenced by init(), and 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 1040 of file ORB_Core.h. Referenced by implrepo_service(), init(), orb(), and ~TAO_ORB_Core().

TAO_ORB_Parameters TAO_ORB_Core::orb_params_ [protected]

Parameters used by the ORB. Definition at line 1048 of file ORB_Core.h. Referenced by init(), and orb_params().

char* TAO_ORB_Core::orbid_ [protected]

The ORBid for this ORB. Definition at line 1062 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 1175 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 1202 of file ORB_Core.h. Referenced by init(), and 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 1185 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 1122 of file ORB_Core.h. Referenced by poa_adapter().

CORBA::Object_var TAO_ORB_Core::poa_current_ [protected]

POA current. Definition at line 1116 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 1106 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 1172 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 1100 of file ORB_Core.h. Referenced by policy_manager(), and ~TAO_ORB_Core().

TAO_ProtocolFactorySet* TAO_ORB_Core::protocol_factories_ [protected]

Definition at line 994 of file ORB_Core.h.

TAO_Protocols_Hooks* TAO_ORB_Core::protocols_hooks_

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

ACE_Atomic_Op<TAO_SYNCH_MUTEX, unsigned long> TAO_ORB_Core::refcount_ [protected]

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

TAO_Request_Dispatcher* TAO_ORB_Core::request_dispatcher_ [protected]

The request dispatching strategy. Definition at line 1111 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 1065 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 1045 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 1029 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 1026 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 1074 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 1068 of file ORB_Core.h. Referenced by init(), and server_id().

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

The adapter for handling server request interceptors. Definition at line 1191 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 992 of file ORB_Core.h. Referenced by stub_factory().

Sync_Scope_Hook TAO_ORB_Core::sync_scope_hook_ [protected]

The hook to be set for the SyncScopePolicy. Definition at line 1220 of file ORB_Core.h. Referenced by call_sync_scope_hook(), and set_sync_scope_hook().

TAO_Thread_Lane_Resources_Manager* TAO_ORB_Core::thread_lane_resources_manager_ [protected]

Definition at line 988 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 1143 of file ORB_Core.h.

int TAO_ORB_Core::thread_per_connection_use_timeout_ [protected]

Definition at line 1142 of file ORB_Core.h.

Timeout_Hook TAO_ORB_Core::timeout_hook_ [protected]

The hook to be set for the RelativeRoundtripTimeoutPolicy. Definition at line 1223 of file ORB_Core.h. Referenced by call_timeout_hook(), and set_timeout_hook().

ACE_Thread_Manager TAO_ORB_Core::tm_ [protected]

The Thread Manager. Definition at line 1125 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 1132 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 1007 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 1092 of file ORB_Core.h. Referenced by init(), and use_global_collocation().

int TAO_ORB_Core::use_implrepo_ [protected]

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

bool TAO_ORB_Core::use_local_memory_pool_ [private]

Definition at line 981 of file ORB_Core.h.

TAO_Valuetype_Adapter* TAO_ORB_Core::valuetype_adapter_ [protected]

Pointer to the valuetype adapter. Definition at line 1199 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.inl

---