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 }
static 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
	ORB_CONTROL
	THRU_POA
	Collocated calls will go thru POA.
	DIRECT
	Collocated calls invoke operation on Servant directly.
Public Member Functions
	TAO_ORB_Core (const char *id, ACE_Intrusive_Auto_Ptr< 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_Service_Context_Registry &	service_context_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_monitor (void)
	Resolve the Monitor 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)
CORBA::Object_ptr	poa_current (void)
	Accessor to the POA current.
void	optimize_collocation_objects (CORBA::Boolean opt)
	Set/get the collocation flags.
CORBA::Boolean	optimize_collocation_objects (void) const
	Set/get the collocation flags.
void	use_global_collocation (CORBA::Boolean opt)
	Set/get the collocation flags.
CORBA::Boolean	use_global_collocation (void) const
	Set/get the collocation flags.
CORBA::ULong	get_collocation_strategy (void) const
	Set/get the collocation flags.
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)
	Set/Get the IOR of the Implementation Repository service.
void	implrepo_service (const CORBA::Object_ptr ir)
	Set/Get the IOR of the Implementation Repository service.
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.
CORBA::Boolean	ft_send_extended_sc (void)
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
static void	set_resource_factory (const char *resource_factory_name)
	Sets the value of TAO_ORB_Core::resource_factory_.
static void	set_gui_resource_factory (TAO::GUIResource_Factory *gui_factory)
static void	set_network_priority_protocols_hooks (const char *network_priority_protocols_hooks_name)
	Sets the value of TAO_ORB_Core::network_priority_protocols_hooks_.
static void	dynamic_adapter_name (const char *name)
	Sets the value of TAO_ORB_Core::dynamic_adapter_name_.
static const char *	dynamic_adapter_name (void)
	Gets the value of TAO_ORB_Core::dynamic_adapter_name_.
static void	ifr_client_adapter_name (const char *name)
	Sets the value of TAO_ORB_Core::ifr_client_adapter_name_.
static const char *	ifr_client_adapter_name (void)
	Gets the value of TAO_ORB_Core::ifr_client_adapter_name_.
static void	typecodefactory_adapter_name (const char *name)
	Sets the value of TAO_ORB_Core::typecodefactory_adapter_name_.
static const char *	typecodefactory_adapter_name (void)
	Gets the value of TAO_ORB_Core::typecodefactory_adapter_name_.
static void	iorinterceptor_adapter_factory_name (const char *name)
	Sets the value of TAO_ORB_Core::iorinterceptor_adapter_factory_name_.
static const char *	iorinterceptor_adapter_factory_name (void)
	Gets the value of TAO_ORB_Core::iorinterceptor_adapter_factory_name_.
static void	valuetype_adapter_factory_name (const char *name)
	Sets the value of TAO_ORB_Core::valuetype_adapter_factory_name.
static const char *	valuetype_adapter_factory_name (void)
	Gets the value of TAO_ORB_Core::valuetype_adapter_factory_name.
static 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	resolve_monitor_i (void)
	Obtain and cache the Monitor 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_ptr	monitor_
	The cached object reference for the Monitor.
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	ft_send_extended_sc_
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.
TAO_Service_Context_Registry	service_context_registry_
	Registry containing all service context handlers.
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_Intrusive_Auto_Ptr< 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_
	The value of the timeout if the flag above is not zero.
ACE_Time_Value	thread_per_connection_timeout_
	The value of the timeout if the flag above is not zero.
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 &)
	The ORB Core should not be copied.
void	operator= (const TAO_ORB_Core &)
	The ORB Core should not be copied.
Private Attributes
bool	use_local_memory_pool_
Friends
class	TAO_ORB_Core_Auto_Ptr
CORBA::ORB_ptr	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 159 of file ORB_Core.h.

---

Member Typedef Documentation

typedef ACE_Array_Map<ACE_CString, ACE_CString> TAO_ORB_Core::InitRefMap

Definition at line 860 of file ORB_Core.h.

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

Definition at line 529 of file ORB_Core.h.

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

Define the Timeout_Hook signature.

Definition at line 470 of file ORB_Core.h.

---

Member Enumeration Documentation

anonymous enum

Enumerator:

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 226 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_Intrusive_Auto_Ptr< ACE_Service_Gestalt >	g
	)

Constructor.

Definition at line 183 of file ORB_Core.cpp.

References ACE_NEW, and TAO_POLICY_ORB_SCOPE.

  : 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 ()),
    monitor_ (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),
    ft_send_extended_sc_ (false),
    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 294 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(), orb_, orbinitializer_registry_, policy_current_, policy_factory_registry_, policy_manager_, CORBA::release(), 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_);

}

TAO_ORB_Core::TAO_ORB_Core

(

const TAO_ORB_Core &

)

[private]

The ORB Core should not be copied.

---

Member Function Documentation

ACE_INLINE unsigned long TAO_ORB_Core::_decr_refcnt

(

void

)

Definition at line 23 of file ORB_Core.inl.

References fini(), and refcount_.

{
  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.

References refcount_.

Referenced by TAO::ORB_Table::find(), and TAO::Collocated_Invocation::invoke().

{
  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 166 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 3138 of file ORB_Core.cpp.

References ACE_ERROR, ACE_TEXT, and LM_ERROR.

{
  if (this->ior_interceptor_adapter ())
    {
      this->ior_interceptor_adapter_->add_interceptor (interceptor);
    }
  else
    {
      ACE_ERROR ((LM_ERROR,
                  ACE_TEXT ("TAO (%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 3288 of file ORB_Core.cpp.

References ACE_ERROR, ACE_TEXT, and LM_ERROR.

{
  if (this->serverrequestinterceptor_adapter_i ())
    {
      this->server_request_interceptor_adapter_->add_interceptor (
        interceptor,
        policies);

    }
  else
    {
      ACE_ERROR ((LM_ERROR,
                  ACE_TEXT ("TAO (%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 3264 of file ORB_Core.cpp.

References ACE_ERROR, ACE_TEXT, and LM_ERROR.

{
  if (this->clientrequestinterceptor_adapter_i ())
    {
      this->client_request_interceptor_adapter_->add_interceptor (
        interceptor,
        policies);

    }
  else
    {
      ACE_ERROR ((LM_ERROR,
                  ACE_TEXT ("TAO (%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 3243 of file ORB_Core.cpp.

References ACE_ERROR, ACE_TEXT, and LM_ERROR.

{
  if (this->serverrequestinterceptor_adapter_i ())
    {
      this->server_request_interceptor_adapter_->add_interceptor (interceptor);
    }
  else
    {
      ACE_ERROR ((LM_ERROR,
                  ACE_TEXT ("TAO (%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 3194 of file ORB_Core.cpp.

References ACE_ERROR, ACE_TEXT, and LM_ERROR.

{
  if (this->clientrequestinterceptor_adapter_i ())
    {
      this->client_request_interceptor_adapter_->add_interceptor (interceptor);
    }
  else
    {
      ACE_ERROR ((LM_ERROR,
                  ACE_TEXT ("TAO (%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 2939 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_.

{
  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 2889 of file ORB_Core.cpp.

References sync_scope_hook_.

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 2945 of file ORB_Core.cpp.

References 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 2278 of file ORB_Core.cpp.

References CORBA::COMPLETED_NO, and CORBA::OMGVMCID.

{
  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 1733 of file ORB_Core.cpp.

References ACE_TEXT, client_factory_, and ACE_Dynamic_Service< TYPE >::instance().

Referenced by TAO_Connector::create_connect_strategy(), TAO::Transport_Cache_Manager::find_transport(), TAO_Muxed_TMS::TAO_Muxed_TMS(), TAO_Transport::TAO_Transport(), and TAO::Profile_Transport_Resolver::use_parallel_connect().

{
  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 592 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 3215 of file ORB_Core.cpp.

References ACE_GUARD_RETURN, ACE_TEXT, client_request_interceptor_adapter_, TAO_ClientRequestInterceptor_Adapter_Factory::create(), ACE_Dynamic_Service< TYPE >::instance(), and TAO_SYNCH_MUTEX.

{
  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 423 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_Transport::generate_request_header(), and TAO_GIOP_Message_Base::process_request().

{
  if (this->orb_params()->negotiate_codesets() == 0)
    return 0;
  if (this->codeset_manager_ == 0)
    {
      // This causes a factory to be loaded which will call
      // the codeset_manager setter in this thread.
      this->codeset_manager_ =
        this->resource_factory()->codeset_manager();
      if (this->codeset_manager_ == 0)
        this->orb_params()->negotiate_codesets(false);
    }
  return this->codeset_manager_;
}

TAO_Collocation_Resolver & TAO_ORB_Core::collocation_resolver

(

void

)

Returns a pointer to the Collocation Resolver.

Definition at line 1540 of file ORB_Core.cpp.

References ACE_TEXT_CHAR_TO_TCHAR, collocation_resolver_, and ACE_Dynamic_Service< TYPE >::instance().

{
  // 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 3421 of file ORB_Core.cpp.

References CORBA::Object::_servant(), CORBA::Object::_stubobj(), ACE_ASSERT, DIRECT, TAO_Pseudo_Var_T< T >::in(), CORBA::is_nil(), TAO_Stub::servant_orb_var(), TAO::TAO_CS_DIRECT_STRATEGY, TAO::TAO_CS_REMOTE_STRATEGY, TAO::TAO_CS_THRU_POA_STRATEGY, 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.

References config_, and ACE_Intrusive_Auto_Ptr< X >::get().

Referenced by TAO::LocateRequest_Invocation_Adapter::invoke(), TAO::Invocation_Adapter::invoke_i(), 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_monitor_i(), resolve_picurrent_i(), resolve_poa_current_i(), resolve_typecodefactory_i(), and root_poa().

{
  return this->config_.get ();
}

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 2960 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 ACE_Time_Value::zero.

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 2997 of file ORB_Core.cpp.

References ACE_DEBUG, ACE_TEXT, LM_DEBUG, TAO_debug_level, 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 2835 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 2811 of file ORB_Core.cpp.

References ACE_NEW_MALLOC_RETURN, ACE_Allocator::malloc(), and ACE_Message_Block::MB_DATA.

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 2787 of file ORB_Core.cpp.

References create_data_block_i(), input_cdr_buffer_allocator(), and input_cdr_dblock_allocator().

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 1900 of file ORB_Core.cpp.

References CORBA::Object::_nil(), ACE_GUARD_RETURN, ACE_NEW_RETURN, adapter_registry(), TAO_Stub::base_profiles(), TAO_ORB_Core_Auto_Ptr::get(), 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 1833 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.

Initialize a TAO_Stub object with the mprofile thats passed.

Definition at line 1851 of file ORB_Core.cpp.

References TAO_Stub::base_profiles(), create_stub(), TAO_MProfile::get_profile(), TAO_Profile::policies(), TAO_MProfile::policy_list(), and TAO_MProfile::profile_count().

{
  // Add the Polices contained in "policy_list" to each profile so
  // that those policies will be exposed to the client in the IOR.  In
  // particular each CORBA::Policy has to be converted in to
  // Messaging::PolicyValue, and then all the Messaging::PolicyValue
  // should be embedded inside a Messaging::PolicyValueSeq which
  // became in turns the "body" of the IOP::TaggedComponent. This
  // conversion is a responsability of the CORBA::Profile class.  (See
  // orbos\98-05-05.pdf Section 5.4)
  if (policy_list->length () != 0)
    {
      TAO_Profile * profile = 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 3132 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 3126 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 2251 of file ORB_Core.cpp.

References destroy_interceptors(), 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 2291 of file ORB_Core.cpp.

References ACE_DEBUG, ACE_GUARD, ACE_TEXT, client_request_interceptor_adapter_, TAO_IORInterceptor_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 1436 of file ORB_Core.cpp.

References ACE_String_Base< CHAR >::c_str(), TAO_ORB_Core_Static_Resources::dynamic_adapter_name_, and TAO_ORB_Core_Static_Resources::instance().

Referenced by CORBA::Object::_create_request(), CORBA::Object::_request(), and CORBA::ORB::create_exception_list().

{
  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 1430 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 1638 of file ORB_Core.cpp.

References ACE_TEXT_CHAR_TO_TCHAR, endpoint_selector_factory_, TAO_ORB_Parameters::endpoint_selector_factory_name(), ACE_Dynamic_Service< TYPE >::instance(), 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 1345 of file ORB_Core.cpp.

References ACE_DEBUG, ACE_TEXT, ACE_TEXT_CHAR_TO_TCHAR, ACE_String_Base< CHAR >::c_str(), codec_factory_, dynany_factory_, TAO_Thread_Lane_Resources_Manager::finalize(), ior_manip_factory_, ior_table_, LM_DEBUG, monitor_, object_key_table_, orbid_, CORBA::release(), shutdown(), TAO_debug_level, thread_lane_resources_manager_, and typecode_factory_.

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->typecode_factory_);

  ::CORBA::release (this->codec_factory_);

  ::CORBA::release (this->dynany_factory_);

  ::CORBA::release (this->ior_manip_factory_);

  ::CORBA::release (this->ior_table_);

  ::CORBA::release (this->monitor_);

  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 2844 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 ());
}

ACE_INLINE CORBA::Boolean TAO_ORB_Core::ft_send_extended_sc

(

void

)

Transmit the entire TAG_FT_GROUP component data from a server IOGR as a FT_GROUP_VERSION tagged service context on requests to that IOGR instead of just the group version.

Definition at line 148 of file ORB_Core.inl.

References ft_send_extended_sc_.

{
  return this->ft_send_extended_sc_;
}

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 3090 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(), and policy_manager().

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 3109 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(), and policy_current().

{
  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

Set/get the collocation flags.

Definition at line 222 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 544 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 3056 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(), and policy_manager().

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 3075 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(), and policy_current().

{
  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 2907 of file ORB_Core.cpp.

References delayed_transport_queueing_strategy_, eager_transport_queueing_strategy_, and flush_transport_queueing_strategy_.

{
  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 269 of file ORB_Core.inl.

References get_tss_resources(), ACE_Array_Base< T >::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 263 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(), and set_tss_resource().

{
  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 1511 of file ORB_Core.cpp.

References TAO_TSS_Resources::gui_resource_factory_, and TAO_TSS_Resources::instance().

{
  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 328 of file ORB_Core.inl.

References has_shutdown_.

{
  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.

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 1448 of file ORB_Core.cpp.

References ACE_String_Base< CHAR >::c_str(), TAO_ORB_Core_Static_Resources::ifr_client_adapter_name_, and TAO_ORB_Core_Static_Resources::instance().

Referenced by TAO::Remote_Object_Proxy_Broker::_get_interface(), and CORBA::ORB::create_operation_list().

{
  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 1442 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

)

Set/Get the IOR of the Implementation Repository service.

Definition at line 347 of file ORB_Core.inl.

References implrepo_service_.

{
  this->implrepo_service_ = ir;
}

CORBA::Object_ptr TAO_ORB_Core::implrepo_service

(

void

)

Set/Get the IOR of the Implementation Repository service.

Definition at line 2859 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(), orb_, CORBA::ORB::resolve_initial_references(), and TAO_SYNCH_MUTEX.

{
  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 359 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 336 of file ORB_Core.cpp.

References CORBA::ORB::_tao_make_ORB(), CORBA::SystemException::_tao_minor_code(), CORBA::ORB::_use_omg_ior_format(), TAO_ORB_Parameters::accept_error_delay(), ACE_DEBUG, ACE_DEFAULT_CDR_MEMCPY_TRADEOFF, ACE_ERROR, ACE_GUARD_RETURN, ACE_LOG_MSG, ACE_NEW_THROW_EX, ACE_TEXT, ACE_TEXT_ALWAYS_CHAR, ACE_TEXT_CHAR_TO_TCHAR, TAO_ORB_Parameters::add_endpoints(), TAO_ORB_Parameters::ami_collication(), ACE_OS::atoi(), ACE_String_Base< CHAR >::c_str(), TAO_ORB_Parameters::cache_incoming_by_dotted_decimal_address(), TAO_ORB_Parameters::cdr_memcpy_tradeoff(), ACE_Log_Msg::clr_flags(), collocation_strategy_, CORBA::COMPLETED_NO, 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(), ft_send_extended_sc_, 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_Network_Priority_Protocols_Hooks::init_hooks(), TAO_Protocols_Hooks::init_hooks(), TAO_Resource_Factory::init_protocol_factories(), TAO_ORB_Core_Static_Resources::instance(), ACE_Dynamic_Service< TYPE >::instance(), TAO_ORB_Parameters::linger(), LM_DEBUG, LM_ERROR, LM_WARNING, ACE_Log_Msg::LOGGER, TAO_ORB_Parameters::max_message_size(), TAO_ORB_Parameters::mcast_discovery_endpoint(), TAO::MCAST_IMPLREPOSERVICE, TAO::MCAST_NAMESERVICE, TAO::MCAST_TRADINGSERVICE, TAO_ORB_Parameters::negotiate_codesets(), negotiate_codesets, network_priority_protocols_hooks_, TAO_ORB_Parameters::nodelay(), TAO_Server_Strategy_Factory::open(), TAO_Parser_Registry::open(), opt_for_collocation_, orb_, orb_params(), orb_params_, ACE_Log_Msg::OSTREAM, TAO_ORB_Parameters::parallel_connect_delay(), parser_registry_, TAO_ORB_Parameters::poa_factory_name(), protocol_factories_, protocols_hooks_, TAO_ORB_Parameters::protocols_hooks_name(), reactor(), resource_factory(), server_factory(), server_id_, TAO_ORB_Parameters::service_port(), services_callbacks_init(), ACE_String_Base< CHAR >::set(), set_endpoint_helper(), ACE_Log_Msg::set_flags(), 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_Log_Msg::STDERR, 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(), thread_per_connection_timeout_, thread_per_connection_use_timeout_, THRU_POA, tm_, TAO_ORB_Parameters::use_dotted_decimal_addresses(), use_global_collocation_, use_implrepo_, TAO_Resource_Factory::use_local_memory_pool(), use_local_memory_pool_, TAO_ORB_Parameters::use_parallel_connects(), ACE_Log_Msg::VERBOSE, ACE_Log_Msg::VERBOSE_LITE, 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;
  time_t accept_error_delay = 5;
  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("-ORBAcceptErrorDelay"))))
        {
          accept_error_delay = 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 ();
        }
      else if (0 != (current_arg = arg_shifter.get_the_parameter
                (ACE_TEXT("-ORBFTSendFullGroupTC"))))
        {
          this->ft_send_extended_sc_ = 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 ("TAO (%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 ("TAO (%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 ("TAO (%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 ()->accept_error_delay (accept_error_delay);
  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 178 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 1957 of file ORB_Core.cpp.

References TAO_Stub::base_profiles(), and initialize_object_i().

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 1976 of file ORB_Core.cpp.

References ACE_GUARD_RETURN, adapter_registry(), TAO_ORB_Core_Auto_Ptr::get(), TAO_Adapter_Registry::initialize_collocated_object(), 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 2747 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 2741 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 2753 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 3157 of file ORB_Core.cpp.

References ACE_GUARD_RETURN, ACE_TEXT_CHAR_TO_TCHAR, TAO_IORInterceptor_Adapter_Factory::create(), ACE_Dynamic_Service< TYPE >::instance(), ior_interceptor_adapter_, iorinterceptor_adapter_factory_name(), and TAO_SYNCH_MUTEX.

{
  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 1472 of file ORB_Core.cpp.

References ACE_String_Base< CHAR >::c_str(), TAO_ORB_Core_Static_Resources::instance(), and TAO_ORB_Core_Static_Resources::iorinterceptor_adapter_factory_name_.

Referenced by ior_interceptor_adapter().

{
  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 1466 of file ORB_Core.cpp.

References TAO_ORB_Core_Static_Resources::instance(), and TAO_ORB_Core_Static_Resources::iorinterceptor_adapter_factory_name_.

{
  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 2043 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 2019 of file ORB_Core.cpp.

References TAO_MProfile::add_profile(), is_collocated(), optimize_collocation_objects(), and use_global_collocation().

{
  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 609 of file ORB_Core.inl.

References TAO_Service_Callbacks::is_permanent_forward_condition().

Referenced by TAO::Synch_Twoway_Invocation::check_reply_status(), and TAO_ServerRequest::init_reply().

{
  const TAO_Service_Callbacks *service_callback =
      this->fault_tolerance_service ().service_callback ();

  // Since forward location is allowed to be nil then check for it.
  CORBA::Boolean const permanent_forward_condition =
      service_callback && obj &&
      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 TAO_Service_Callbacks::DONT_KNOW.

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 2339 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::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 2062 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 2068 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 2683 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::current_size(), ACE_Array_Map< Key, Value, EqualTo >::end(), TAO_Object_Ref_Table::end(), init_ref_map_, object_ref_table_, 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 1885 of file ORB_Core.cpp.

References ACE_TEXT, bidir_adapter_, ACE_Dynamic_Service< TYPE >::instance(), 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.

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 191 of file ORB_Core.inl.

{
  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.

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(), 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]

The ORB Core should not be copied.

ACE_INLINE CORBA::Boolean TAO_ORB_Core::optimize_collocation_objects

(

void

)

const

Set/get the collocation flags.

Definition at line 204 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

)

Set/get the collocation flags.

Definition at line 198 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 160 of file ORB_Core.inl.

References orb_.

Referenced by 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 228 of file ORB_Core.inl.

References orb_params_.

Referenced by TAO_IIOP_Connection_Handler::close_connection(), codeset_manager(), TAO_Profile::create_tagged_profile(), TAO_IIOP_Profile::decode_profile(), TAO_Profile::encode(), endpoint_selector_factory(), TAO_IIOP_Acceptor::hostname(), init(), TAO_IIOP_Connector::make_parallel_connection(), TAO_IIOP_Endpoint::next_filtered(), CORBA::ORB::object_to_string(), TAO_IIOP_Connection_Handler::open(), TAO_Acceptor_Registry::open_default(), TAO_Default_Thread_Lane_Resources_Manager::open_default_resources(), 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(), stub_factory(), TAO_ServerRequest::tao_send_reply_exception(), thread_lane_resources_manager(), and TAO::Profile_Transport_Resolver::use_parallel_connect().

{
  return &(this->orb_params_);
}

ACE_INLINE const char * TAO_ORB_Core::orbid

(

void

)

const

Return ORBid string.

Definition at line 341 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 440 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 1587 of file ORB_Core.cpp.

References ACE_DYNAMIC_SERVICE_DIRECTIVE, ACE_TEXT, configuration(), ACE_Dynamic_Service< TYPE >::instance(), orbinitializer_registry_, and ACE_Service_Gestalt::process_directive().

Referenced by orbinitializer_registry().

{
  // @todo The ORBInitializer_Registry is supposed to be a singleton.

  // If not, lookup it up.
  this->orbinitializer_registry_ =
    ACE_Dynamic_Service<TAO::ORBInitializer_Registry_Adapter>::instance
      (this->configuration (),
       ACE_TEXT ("ORBInitializer_Registry"));

#if !defined (TAO_AS_STATIC_LIBS) && !(defined (ACE_VXWORKS) && !defined (__RTP__))
      // 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)
    {
      this->configuration ()->process_directive (
        ACE_DYNAMIC_SERVICE_DIRECTIVE ("ORBInitializer_Registry",
                                       "TAO_PI",
                                       "_make_ORBInitializer_Registry",
                                       ""));
      this->orbinitializer_registry_ =
        ACE_Dynamic_Service<TAO::ORBInitializer_Registry_Adapter>::instance
          (this->configuration (),
           ACE_TEXT ("ORBInitializer_Registry"));
    }
#endif /* !TAO_AS_STATIC_LIBS && !(ACE_VXWORKS && !__RTP__) */

  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 2766 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 2759 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 2773 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 245 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 584 of file ORB_Core.inl.

References 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 574 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 1818 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

)

Accessor to the POA current.

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 522 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 458 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 1556 of file ORB_Core.cpp.

References ACE_DYNAMIC_SERVICE_DIRECTIVE, ACE_TEXT, configuration(), TAO_PolicyFactory_Registry_Factory::create(), ACE_Dynamic_Service< TYPE >::instance(), 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 255 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 239 of file ORB_Core.inl.

References TAO_OC_RETRIEVE.

Referenced by TAO_Connector_Registry::open(), TAO_Acceptor_Registry::open(), and TAO_Acceptor_Registry::open_default().

{
  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 2853 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(), init(), TAO_Transport::notify_reactor(), TAO_Transport::register_handler(), run(), 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 1968 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 <handle> 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 1842 of file ORB_Core.cpp.

References request_dispatcher(), and 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 172 of file ORB_Core.inl.

References request_dispatcher_.

Referenced by TAO::Collocated_Invocation::invoke(), TAO_GIOP_Message_Base::process_locate_request(), TAO_GIOP_Message_Base::process_request(), and request_dispatcher().

{
  return this->request_dispatcher_;
}

ACE_INLINE CORBA::Object_ptr TAO_ORB_Core::resolve_codecfactory

(

void

)

Resolve the CodecFactory DLL.

Definition at line 393 of file ORB_Core.inl.

References CORBA::Object::_duplicate(), CORBA::Object::_nil(), 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 2378 of file ORB_Core.cpp.

References ACE_DYNAMIC_SERVICE_DIRECTIVE, ACE_TEXT, codec_factory_, configuration(), TAO_Object_Loader::create_object(), ACE_Dynamic_Service< TYPE >::instance(), 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 405 of file ORB_Core.inl.

References CORBA::Object::_duplicate(), CORBA::Object::_nil(), 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 2405 of file ORB_Core.cpp.

References ACE_DYNAMIC_SERVICE_DIRECTIVE, ACE_TEXT, compression_manager_, configuration(), TAO_Object_Loader::create_object(), ACE_Dynamic_Service< TYPE >::instance(), 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 470 of file ORB_Core.inl.

References CORBA::Object::_duplicate(), CORBA::Object::_nil(), 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 2491 of file ORB_Core.cpp.

References ACE_DYNAMIC_SERVICE_DIRECTIVE, ACE_TEXT, configuration(), TAO_Object_Loader::create_object(), dynany_factory_, ACE_Dynamic_Service< TYPE >::instance(), 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 482 of file ORB_Core.inl.

References CORBA::Object::_duplicate(), CORBA::Object::_nil(), 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 494 of file ORB_Core.inl.

References CORBA::Object::_duplicate(), CORBA::Object::_nil(), 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 2544 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(), TAO_Adapter_Registry::insert(), ACE_Dynamic_Service< TYPE >::instance(), ior_table_, and ACE_Service_Gestalt::process_directive().

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 2518 of file ORB_Core.cpp.

References ACE_DYNAMIC_SERVICE_DIRECTIVE, ACE_TEXT, configuration(), TAO_Object_Loader::create_object(), ACE_Dynamic_Service< TYPE >::instance(), 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_monitor

(

void

)

Resolve the Monitor reference for this ORB.

Definition at line 506 of file ORB_Core.inl.

References CORBA::Object::_duplicate(), CORBA::Object::_nil(), ACE_GUARD_RETURN, CORBA::is_nil(), resolve_monitor_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->monitor_))
    {
      this->resolve_monitor_i ();
    }
  return CORBA::Object::_duplicate (this->monitor_);
}

void TAO_ORB_Core::resolve_monitor_i

(

void

)

[protected]

Obtain and cache the Monitor object reference.

Definition at line 2579 of file ORB_Core.cpp.

References ACE_DYNAMIC_SERVICE_DIRECTIVE, ACE_TEXT, configuration(), TAO_Object_Loader::create_object(), ACE_Dynamic_Service< TYPE >::instance(), monitor_, and ACE_Service_Gestalt::process_directive().

Referenced by resolve_monitor().

{
  TAO_Object_Loader *loader =
    ACE_Dynamic_Service<TAO_Object_Loader>::instance
      (this->configuration (),
       ACE_TEXT ("Monitor_Init"));

  if (loader == 0)
    {
      this->configuration ()->process_directive
        (ACE_DYNAMIC_SERVICE_DIRECTIVE("Monitor_Init",
                                       "TAO_Monitor",
                                       "_make_TAO_Monitor_Init",
                                       ""));
      loader =
        ACE_Dynamic_Service<TAO_Object_Loader>::instance
        (this->configuration (),
         ACE_TEXT ("Monitor_Init"));
    }

  if (loader != 0)
    {
      this->monitor_ = loader->create_object (this->orb_, 0, 0);
    }
}

ACE_INLINE CORBA::Object_ptr TAO_ORB_Core::resolve_picurrent

(

void

)

Resolve the PICurrent.

Definition at line 379 of file ORB_Core.inl.

References CORBA::Object::_duplicate(), CORBA::Object::_nil(), 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 2460 of file ORB_Core.cpp.

References ACE_DYNAMIC_SERVICE_DIRECTIVE, ACE_TEXT, configuration(), TAO_Object_Loader::create_object(), ACE_Dynamic_Service< TYPE >::instance(), 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 530 of file ORB_Core.inl.

References CORBA::Object::_duplicate(), CORBA::Object::_nil(), 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 2431 of file ORB_Core.cpp.

References ACE_DYNAMIC_SERVICE_DIRECTIVE, ACE_TEXT, configuration(), TAO_Object_Loader::create_object(), ACE_Dynamic_Service< TYPE >::instance(), 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 2626 of file ORB_Core.cpp.

References CORBA::Object::_nil(), connector_registry(), TAO_ORB_Parameters::default_init_ref(), TAO_Connector_Registry::object_key_delimiter(), orb(), orb_params(), CORBA::ORB::string_to_object(), 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 553 of file ORB_Core.inl.

References CORBA::Object::_duplicate(), CORBA::Object::_nil(), 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 365 of file ORB_Core.inl.

References CORBA::Object::_duplicate(), CORBA::Object::_nil(), 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 2345 of file ORB_Core.cpp.

References ACE_DYNAMIC_SERVICE_DIRECTIVE, ACE_ERROR, ACE_TEXT, configuration(), TAO_Object_Loader::create_object(), ACE_Dynamic_Service< TYPE >::instance(), 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 1490 of file ORB_Core.cpp.

References ACE_TEXT_CHAR_TO_TCHAR, ACE_String_Base< CHAR >::c_str(), ACE_Dynamic_Service< TYPE >::instance(), 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(), codeset_manager(), TAO_Thread_Lane_Resources::connector_registry(), TAO::demarshal_sequence(), fragmentation_strategy(), init(), TAO::ObjectKey_Table::init(), CORBA::Object::Object(), TAO_Parser_Registry::open(), operator>>(), TAO_Leader_Follower::reactor(), TAO_Thread_Lane_Resources::resource_factory(), TAO_Leader_Follower::set_client_thread(), and TAO::Transport_Cache_Manager::Transport_Cache_Manager().

{
  // 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 1763 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_Registry::insert(), ACE_Dynamic_Service< TYPE >::instance(), CORBA::is_nil(), TAO_Adapter::open(), orb_params(), poa_adapter(), TAO_ORB_Parameters::poa_factory_name(), ACE_Service_Gestalt::process_directive(), TAO_Adapter::root(), root_poa_, and TAO_SYNCH_MUTEX.

Referenced by CORBA::ORB::resolve_initial_references().

{
  // DCL ..
  if (CORBA::is_nil (this->root_poa_.in ()))
    {
      // Making sure the initialization process in the current thread uses
      // the correct service repository (ours), instead of the global one.
      ACE_Service_Config_Guard scg (this->configuration ());

      TAO_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 2074 of file ORB_Core.cpp.

References ACE_DEBUG, ACE_TEXT, TAO_Server_Strategy_Factory::activate_server_connections(), TAO_LF_Event_Loop_Thread_Helper::event_loop_return(), ACE_Reactor::handle_events(), leader_follower(), lf_strategy(), LM_DEBUG, ACE_Reactor::owner(), reactor(), ACE_Thread::self(), server_factory_, TAO_debug_level, and ACE_Time_Value::zero.

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(), and CORBA::ORB::run().

{
  // 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 1748 of file ORB_Core.cpp.

References ACE_TEXT, ACE_Dynamic_Service< TYPE >::instance(), 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 417 of file ORB_Core.inl.

References ACE_String_Base< CHAR >::c_str(), and 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 598 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 3312 of file ORB_Core.cpp.

References ACE_GUARD_RETURN, ACE_TEXT, TAO_ServerRequestInterceptor_Adapter_Factory::create(), ACE_Dynamic_Service< TYPE >::instance(), server_request_interceptor_adapter_, and TAO_SYNCH_MUTEX.

{
  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 1712 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 TAO_Service_Context_Registry & TAO_ORB_Core::service_context_registry

(

void

)

Definition at line 452 of file ORB_Core.inl.

References service_context_registry_.

Referenced by TAO_GIOP_Message_Generator_Parser_12::parse_request_header().

{
  return this->service_context_registry_;
}

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 <profile>.

Definition at line 85 of file ORB_Core.inl.

{
  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 1678 of file ORB_Core.cpp.

References CORBA::SystemException::_tao_minor_code(), CORBA::COMPLETED_MAYBE, 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 1697 of file ORB_Core.cpp.

References TAO::TAO_INVOKE_FAILURE.

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 1667 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 184 of file ORB_Core.inl.

{
  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 651 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 643 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 -ORBListenEndpoints options.

Definition at line 2606 of file ORB_Core.cpp.

References CORBA::SystemException::_tao_minor_code(), ACE_ERROR, ACE_TEXT, ACE_TEXT_CHAR_TO_TCHAR, ACE_String_Base< CHAR >::c_str(), CORBA::COMPLETED_NO, LM_ERROR, 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 1414 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 1657 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 1407 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 626 of file ORB_Core.inl.

References sync_scope_hook_.

{
  this->sync_scope_hook_ = hook;
}

ACE_INLINE void TAO_ORB_Core::set_timeout_hook

(

Timeout_Hook

hook

)

Definition at line 633 of file ORB_Core.inl.

References 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 281 of file ORB_Core.inl.

References get_tss_resources(), TAO_ORB_Core_TSS_Resources::orb_core_, ACE_Array_Base< T >::size(), and TAO_ORB_Core_TSS_Resources::ts_objects_.

{
  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 2189 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_, implrepo_service_, 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 == true)
    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 ();

  // Release implrepo_service_ if one existed. If everything went
  // fine then this must release reference from implrepo_service_
  // object to this orb core.
  ::CORBA::release (this->implrepo_service_);
  this->implrepo_service_ = CORBA::Object::_nil ();

#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 1619 of file ORB_Core.cpp.

References ACE_TEXT_CHAR_TO_TCHAR, ACE_Dynamic_Service< TYPE >::instance(), 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 154 of file ORB_Core.inl.

References tm_.

Referenced by 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 1518 of file ORB_Core.cpp.

References ACE_TEXT_CHAR_TO_TCHAR, TAO_Thread_Lane_Resources_Manager_Factory::create_thread_lane_resources_manager(), ACE_Dynamic_Service< TYPE >::instance(), 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 <timeout> 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 334 of file ORB_Core.inl.

References thread_per_connection_timeout_, and thread_per_connection_use_timeout_.

{
  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 2780 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 322 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 1460 of file ORB_Core.cpp.

References ACE_String_Base< CHAR >::c_str(), TAO_ORB_Core_Static_Resources::instance(), and TAO_ORB_Core_Static_Resources::typecodefactory_adapter_name_.

Referenced by CORBA::ORB::create_abstract_interface_tc(), CORBA::ORB::create_alias_tc(), CORBA::ORB::create_array_tc(), CORBA::ORB::create_component_tc(), CORBA::ORB::create_enum_tc(), CORBA::ORB::create_event_tc(), CORBA::ORB::create_exception_tc(), CORBA::ORB::create_fixed_tc(), CORBA::ORB::create_home_tc(), CORBA::ORB::create_interface_tc(), CORBA::ORB::create_local_interface_tc(), CORBA::ORB::create_native_tc(), CORBA::ORB::create_recursive_tc(), CORBA::ORB::create_sequence_tc(), CORBA::ORB::create_string_tc(), CORBA::ORB::create_struct_tc(), CORBA::ORB::create_union_tc(), CORBA::ORB::create_value_box_tc(), CORBA::ORB::create_value_tc(), and CORBA::ORB::create_wstring_tc().

{
  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 1454 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

Set/get the collocation flags.

Definition at line 216 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

)

Set/get the collocation flags.

Definition at line 210 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 353 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 3342 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 1484 of file ORB_Core.cpp.

References ACE_String_Base< CHAR >::c_str(), TAO_ORB_Core_Static_Resources::instance(), and TAO_ORB_Core_Static_Resources::valuetype_adapter_factory_name_.

Referenced by valuetype_adapter().

{
  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 1478 of file ORB_Core.cpp.

References TAO_ORB_Core_Static_Resources::instance(), and TAO_ORB_Core_Static_Resources::valuetype_adapter_factory_name_.

{
  TAO_ORB_Core_Static_Resources::instance ()->valuetype_adapter_factory_name_ = name;
}

---

Friends And Related Function Documentation

CORBA::ORB_ptr ORB_init	(	int &	argc,
		char *	argv[],
		const char *	orb_name = 0
	)			[friend]

ORB Initialization

Definition at line 1187 of file ORB.cpp.

{
  // It doesn't make sense for argc to be zero and argv to be
  // non-empty/zero, or for argc to be greater than zero and argv be
  // zero.
  size_t const argv0_len = (argv ? (*argv
                                        ? ACE_OS::strlen (*argv)
                                        : 0)
                                     : 0);

  if ((argc == 0 && argv0_len != 0)
      || (argc != 0  && (argv == 0 || argv[0] == 0)))
    {
      throw ::CORBA::BAD_PARAM (
        CORBA::SystemException::_tao_minor_code (
          0,
          EINVAL),
        CORBA::COMPLETED_NO);
    }

  // Copy command line parameter not to corrupt the original.
  ACE_Argv_Type_Converter command_line(argc, argv);
  int tmpargc = command_line.get_argc ();
  ACE_TCHAR **tmpargv = command_line.get_TCHAR_argv ();

  // Scan the parameters to find any we could interpret to
  // use for initializing the global context. Note that if
  // the global context has been initialized already, the
  // parameters may either be ignored, or later used to initialize
  // a local configuration context. The chosen action depends on
  // weather we want the ORB to share the global context or
  // have its own, private (or local) context.
  if (TAO::ORB::open_global_services (tmpargc, tmpargv) == -1)
    {
        return CORBA::ORB::_nil ();
    }

  // Make sure the following is done after the global ORB
  // initialization since we need to have exceptions initialized.

  // Use this string variable to hold the orbid
  ACE_CString orbid_string (orbid);
  TAO::parse_orb_opt (command_line, ACE_TEXT("-ORBid"), orbid_string);

  // Get ORB Core
  TAO_ORB_Core_Auto_Ptr oc (TAO::ORB_Table::instance ()->find (orbid_string.c_str ()));

    // The ORB was already initialized.  Just return that one.
  if (oc.get () != 0)
    {
      return CORBA::ORB::_duplicate (oc->orb ());
    }


  // Determine the service object registry this ORB will use. The choises
  // are: (a) the legacy (global); (b) its own, local, or (c) share somebody
  // else's configuration. By default use the process-wide (global) context
    // Use this string variable to hold the configuration identity key
  ACE_CString orbconfig_string;
  TAO::parse_orb_opt (command_line, ACE_TEXT("-ORBGestalt"), orbconfig_string);
  ACE_Intrusive_Auto_Ptr<ACE_Service_Gestalt> gestalt = TAO::find_orb_context (orbconfig_string);

  // An ORB corresponding to the desired ORBid doesn't exist so create
  // a new one.
  TAO_ORB_Core * tmp = 0;
  ACE_NEW_THROW_EX (tmp,
                    TAO_ORB_Core (orbid_string.c_str (), gestalt),
                    CORBA::NO_MEMORY (
                      CORBA::SystemException::_tao_minor_code (0,
                                                               ENOMEM),
                      CORBA::COMPLETED_NO));

  // The ORB table increases the reference count on the ORB Core
  // so do not release it here.  Allow the TAO_ORB_Core_Auto_Ptr
  // to decrease the reference count on the ORB Core when it goes
  // out of scope.
  oc.reset (tmp);

  // Having the ORB's default static services be shared among all ORBs
  // is tempting from the point of view of reducing the dynamic
  // footprint. However, if the ORB in a DLL and the rest of that
  // application most likely neither cares, nor wishes to know about
  // them. Furthermore, if the ORB DLL gets unloaded, the static
  // services it had registered globaly will no longer be accesible,
  // which will have disastrous consequences at the process
  // shutdown. Hence, the ACE_Service_Config_Guard ensures that for
  // the current thread, any references to the global
  // ACE_Service_Config will be re-routed to this ORB's service gestalt.

  ACE_Service_Config_Guard scg (oc->configuration ());

  // Initialize the Service Configurator.  This must occur before the
  // ORBInitializer::pre_init() method is invoked on each registered
  // ORB initializer.
  int result = TAO::ORB::open_services (oc->configuration (),
                                        command_line.get_argc (),
                                        command_line.get_TCHAR_argv ());

  // Check for errors returned from <TAO_Internal::open_services>.
  if (result != 0 && errno != ENOENT)
    {
      ACE_ERROR ((LM_ERROR,
                  ACE_TEXT ("(%P|%t) %p\n"),
                  ACE_TEXT ("Unable to initialize the ")
                  ACE_TEXT ("Service Configurator")));
      throw ::CORBA::INITIALIZE (
        CORBA::SystemException::_tao_minor_code (
          TAO_ORB_CORE_INIT_LOCATION_CODE,
          0),
        CORBA::COMPLETED_NO);
    }

  TAO::ORBInitializer_Registry_Adapter * orbinitializer_registry =
    oc.get ()->orbinitializer_registry ();

  PortableInterceptor::SlotId slotid = 0;
  size_t pre_init_count = 0;

  if (orbinitializer_registry != 0)
    {
      pre_init_count =
        orbinitializer_registry->pre_init (oc.get (),
                                           command_line.get_argc(),
                                           command_line.get_ASCII_argv(),
                                           slotid);
    }

  // Initialize the ORB Core instance.
  result = oc->init (command_line.get_argc(),
                     command_line.get_ASCII_argv());

  if (orbinitializer_registry != 0)
    {
      orbinitializer_registry->post_init (pre_init_count,
                                          oc.get (),
                                          command_line.get_argc(),
                                          command_line.get_ASCII_argv(),
                                          slotid);
    }

  if (TAO_debug_level > 2)
    {
      ACE_DEBUG ((LM_DEBUG,
                  ACE_TEXT("TAO (%P|%t) created new ORB <%s>\n"),
                  ACE_TEXT_CHAR_TO_TCHAR (orbid_string.c_str ())));
    }

  // Before returning remember to store the ORB into the table...
  if (TAO::ORB_Table::instance ()->bind (orbid_string.c_str (),
                                         oc.get ()) != 0)
    throw ::CORBA::INTERNAL (0, CORBA::COMPLETED_NO);

  // Return a duplicate since the ORB_Core should release the last
  // reference to the ORB.
  return CORBA::ORB::_duplicate (oc->orb ());
}

friend class TAO_ORB_Core_Auto_Ptr [friend]

Definition at line 161 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 1141 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 1230 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 1233 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 1088 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 1213 of file ORB_Core.h.

Referenced by 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 1024 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 1239 of file ORB_Core.h.

Referenced by codeset_manager(), and ~TAO_ORB_Core().

TAO_Collocation_Resolver* TAO_ORB_Core::collocation_resolver_ [protected]

Definition at line 1004 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 1117 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 1027 of file ORB_Core.h.

Referenced by resolve_compression_manager_i().

ACE_Intrusive_Auto_Ptr<ACE_Service_Gestalt> TAO_ORB_Core::config_ [protected]

ORB's service configuration.

Definition at line 1242 of file ORB_Core.h.

Referenced by configuration().

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

TAO_Policy_Set* TAO_ORB_Core::default_policies_ [protected]

The default policies.

Definition at line 1125 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 1188 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 1179 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 1030 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 1176 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 1171 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 1183 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 1236 of file ORB_Core.h.

Referenced by flushing_strategy(), init(), and ~TAO_ORB_Core().

CORBA::Boolean TAO_ORB_Core::ft_send_extended_sc_ [protected]

TRUE transmits a full TAG_FT_GROUP component in place of the FT_GROUP_VERSION context on FT requests. This is contrary to the spec but enables more effective fault tolerant stuff.

Todo:

reference to OMG issue. Default false.

Definition at line 1106 of file ORB_Core.h.

Referenced by ft_send_extended_sc(), and init().

TAO_Fault_Tolerance_Service TAO_ORB_Core::ft_service_ [protected]

Fault Tolerant service hook.

Definition at line 1099 of file ORB_Core.h.

Referenced by fault_tolerance_service(), and services_callbacks_init().

bool TAO_ORB_Core::has_shutdown_ [protected]

Flag which denotes that the ORB has been shutdown.

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

Referenced by implrepo_service(), and shutdown().

int TAO_ORB_Core::imr_endpoints_in_ior_ [protected]

Flag for whether to put the ImR endpoints into our object refs.

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

Referenced by init_ref_map(), and list_initial_references().

TAO_IORInterceptor_Adapter* TAO_ORB_Core::ior_interceptor_adapter_ [protected]

IORInterceptor adapter.

Definition at line 1221 of file ORB_Core.h.

Referenced by 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 1033 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 1036 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 1000 of file ORB_Core.h.

CORBA::Object_ptr TAO_ORB_Core::monitor_ [protected]

The cached object reference for the Monitor.

Definition at line 1039 of file ORB_Core.h.

Referenced by fini(), and resolve_monitor_i().

TAO_Network_Priority_Protocols_Hooks* TAO_ORB_Core::network_priority_protocols_hooks_

Handle to the factory for network_priority_protocols_hooks_..

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

Referenced by fini(), and object_key_table().

TAO_Object_Ref_Table TAO_ORB_Core::object_ref_table_ [protected]

Table that maps object key/name to (de-stringified) object reference. It is needed for supporting local objects in the resolve_initial_references() mechanism.

Definition at line 1073 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 1169 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 1110 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 1057 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 1065 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 1079 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 1197 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 1227 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 1210 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 1144 of file ORB_Core.h.

Referenced by poa_adapter().

CORBA::Object_var TAO_ORB_Core::poa_current_ [protected]

POA current.

Definition at line 1138 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 1128 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 1194 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 1122 of file ORB_Core.h.

Referenced by policy_manager(), and ~TAO_ORB_Core().

TAO_ProtocolFactorySet* TAO_ORB_Core::protocol_factories_ [protected]

Definition at line 1008 of file ORB_Core.h.

Referenced by init().

TAO_Protocols_Hooks* TAO_ORB_Core::protocols_hooks_

Handle to the factory for protocols_hooks_..

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

Referenced by _decr_refcnt(), and _incr_refcnt().

TAO_Request_Dispatcher* TAO_ORB_Core::request_dispatcher_ [protected]

The request dispatching strategy.

Definition at line 1133 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 1082 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 1062 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 1046 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 1043 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 1091 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 1085 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 1216 of file ORB_Core.h.

Referenced by destroy_interceptors(), serverrequestinterceptor_adapter(), and serverrequestinterceptor_adapter_i().

TAO_Service_Context_Registry TAO_ORB_Core::service_context_registry_ [protected]

Registry containing all service context handlers.

Definition at line 1200 of file ORB_Core.h.

Referenced by service_context_registry().

TAO_Stub_Factory* TAO_ORB_Core::stub_factory_ [protected]

Definition at line 1006 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 1245 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 1002 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]

The value of the timeout if the flag above is not zero.

Definition at line 1165 of file ORB_Core.h.

Referenced by init(), and thread_per_connection_timeout().

int TAO_ORB_Core::thread_per_connection_use_timeout_ [protected]

The value of the timeout if the flag above is not zero.

Definition at line 1164 of file ORB_Core.h.

Referenced by init(), and thread_per_connection_timeout().

Timeout_Hook TAO_ORB_Core::timeout_hook_ [protected]

The hook to be set for the RelativeRoundtripTimeoutPolicy.

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

Referenced by init(), and thr_mgr().

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

Referenced by add_tss_cleanup_func(), and tss_cleanup_funcs().

CORBA::Object_ptr TAO_ORB_Core::typecode_factory_ [protected]

The cached IOR for the TypeCodeFactory DLL.

Definition at line 1021 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 1114 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 1015 of file ORB_Core.h.

Referenced by init(), and use_implrepo().

bool TAO_ORB_Core::use_local_memory_pool_ [private]

Definition at line 995 of file ORB_Core.h.

Referenced by init().

TAO_Valuetype_Adapter* TAO_ORB_Core::valuetype_adapter_ [protected]

Pointer to the valuetype adapter.

Definition at line 1224 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

---