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.

Public Types
typedef void(*	Timeout_Hook )(TAO_ORB_Core *, TAO_Stub *, bool &, ACE_Time_Value &)
	Define the Timeout_Hook signature.
typedef void(*	Sync_Scope_Hook )(TAO_ORB_Core *, TAO_Stub *, bool &, Messaging::SyncScope &)
typedef ACE_Array_Map < ACE_CString, ACE_CString >	InitRefMap
Public Member Functions
	TAO_ORB_Core (const char *id, ACE_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_ZIOP_Adapter *	ziop_adapter () const
void	ziop_adapter (TAO_ZIOP_Adapter *adapter)
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.
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)
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_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.
TAO_ZIOP_Adapter *	ziop_adapter_i (void)
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.
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)
unsigned long	_refcnt (void) const
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.
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.
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.
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)
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.
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_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::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_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_
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.
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_ZIOP_Adapter *	ziop_adapter_
	ZIOP Adapter.
CORBA::Boolean	ziop_enabled_
	ZIOP enabled or not.
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.
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)
Private Attributes
bool	use_local_memory_pool_
Friends
class	TAO_ORB_Core_Auto_Ptr
CORBA::ORB_ptr	CORBA::ORB_init (int &, ACE_TCHAR *argv[], const char *)
Collocation Strategies
enum	{ ORB_CONTROL, THRU_POA, DIRECT }
static TAO::Collocation_Strategy	collocation_strategy (CORBA::Object_ptr object)
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.
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
	The value of the timeout if the flag above is not zero.
void	use_global_collocation (CORBA::Boolean opt)
	The value of the timeout if the flag above is not zero.
CORBA::Boolean	use_global_collocation (void) const
	The value of the timeout if the flag above is not zero.
CORBA::ULong	get_collocation_strategy (void) const
	The value of the timeout if the flag above is not zero.
CORBA::Environment *	default_environment (void) const
void	default_environment (CORBA::Environment *)
	The value of the timeout if the flag above is not zero.
CORBA::Object_ptr	implrepo_service (void)
	Set/Get the IOR of the Implementation Repository service.
void	implrepo_service (const CORBA::Object_ptr ir)
	The value of the timeout if the flag above is not zero.
	TAO_ORB_Core (const TAO_ORB_Core &)
	The ORB Core should not be copied.
void	operator= (const TAO_ORB_Core &)
	The value of the timeout if the flag above is not zero.

---

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

---

Member Typedef Documentation

typedef ACE_Array_Map<ACE_CString, ACE_CString> TAO_ORB_Core::InitRefMap

Definition at line 861 of file ORB_Core.h.

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

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

---

Member Enumeration Documentation

anonymous enum

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.

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

  : 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),
    ziop_adapter_ (0),
    ziop_enabled_ (false),
    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 299 of file ORB_Core.cpp.

{
  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

unsigned long TAO_ORB_Core::_decr_refcnt

(

void

)

Definition at line 29 of file ORB_Core.inl.

{
  unsigned long const count = --this->refcount_;
  if (count != 0)
    return count;

  this->fini ();
  return 0;
}

unsigned long TAO_ORB_Core::_incr_refcnt

(

void

)

Reference counting...

Definition at line 17 of file ORB_Core.inl.

{
  return this->refcount_++;
}

unsigned long TAO_ORB_Core::_refcnt

(

void

)

const

Definition at line 23 of file ORB_Core.inl.

{
  return this->refcount_.value ();
}

TAO_ORB_Core::ACE_TSS_TYPE

(

TAO_ORB_Core_TSS_Resources

)

[protected]

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

TAO_Adapter_Registry & TAO_ORB_Core::adapter_registry

(

void

)

Get the adapter registry.

Definition at line 172 of file ORB_Core.inl.

{
  return this->adapter_registry_;
}

void TAO_ORB_Core::add_interceptor

(

PortableInterceptor::IORInterceptor_ptr

interceptor

)

Register an IOR interceptor.

Definition at line 3216 of file ORB_Core.cpp.

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

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

{
  return this->tss_cleanup_funcs_.register_cleanup_function (cleanup, slot_id);
}

void TAO_ORB_Core::bidir_giop_policy

(

CORBA::Boolean

val

)

Definition at line 55 of file ORB_Core.inl.

{
  this->bidir_giop_policy_ = val;
}

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

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

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

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

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

{
  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_;
}

TAO_Codeset_Manager * TAO_ORB_Core::codeset_manager

(

void

)

Get Code Set Manager.

Definition at line 429 of file ORB_Core.inl.

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

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

{
  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 ();

      if (orb_core->collocation_resolver ().is_collocated (object))
        {
          switch (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;
}

ACE_Service_Gestalt * TAO_ORB_Core::configuration

(

void

)

const

Configuration accessor method.

Definition at line 11 of file ORB_Core.inl.

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

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

{
  // 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 connection ")
                      ACE_TEXT("timeout 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 connection ")
                      ACE_TEXT("timeout 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 ")
                    ACE_TEXT ("connection timeout hook. It is %@"),
                    TOCSRi->alt_connection_timeout_hook_));
      }

#undef TOCSRi
}

TAO_Connector_Registry * TAO_ORB_Core::connector_registry

(

void

)

Get the connector registry.

Definition at line 2911 of file ORB_Core.cpp.

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

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

{

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

{
  // @@ 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 ())
    {
      x = collocated_orb_core.get ()->adapter_registry ().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 1904 of file ORB_Core.cpp.

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

{
  // 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 *

env

)

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

Definition at line 3210 of file ORB_Core.cpp.

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

{
  return TAO_TSS_Resources::instance ()->default_environment_;
}

void TAO_ORB_Core::destroy

(

void

)

Shutdown the ORB and free resources.

Definition at line 2327 of file ORB_Core.cpp.

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

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

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

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

{
  // 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_;
}

TAO_Fault_Tolerance_Service & TAO_ORB_Core::fault_tolerance_service

(

void

)

Return a reference to the Fault Tolerant service object.

Definition at line 148 of file ORB_Core.inl.

{
  return this->ft_service_;
}

int TAO_ORB_Core::fini

(

void

)

[protected]

Final termination hook, typically called by CORBA::ORB's destructor.

Definition at line 1423 of file ORB_Core.cpp.

{
  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 ("TAO (%P|%t) - Destroying ORB <%C>\n"),
                  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;
}

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

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

{
  return
    this->resource_factory ()->create_fragmentation_strategy (
      transport,
      this->orb_params_.max_message_size ());
}

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

{
  return this->ft_send_extended_sc_;
}

CORBA::ULong TAO_ORB_Core::get_collocation_strategy

(

void

)

const

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

Definition at line 228 of file ORB_Core.inl.

{
  return this->collocation_strategy_;
}

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

{
  return this->network_priority_protocols_hooks_;
}

TAO_Protocols_Hooks * TAO_ORB_Core::get_protocols_hooks

(

void

)

Gets the value of TAO_ORB_Core::protocols_hooks__.

Definition at line 79 of file ORB_Core.inl.

{
  return this->protocols_hooks_;
}

void * TAO_ORB_Core::get_tss_resource

(

size_t

slot_id

)

Obtain the TSS resource in the given slot.

Definition at line 275 of file ORB_Core.inl.

{
  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];
}

TAO_ORB_Core_TSS_Resources * TAO_ORB_Core::get_tss_resources

(

void

)

Obtain the TSS resources of this orb.

Definition at line 269 of file ORB_Core.inl.

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

{
  return TAO_TSS_Resources::instance ()->gui_resource_factory_;
}

bool TAO_ORB_Core::has_shutdown

(

void

)

const

Get the shutdown flag value.

Definition at line 334 of file ORB_Core.inl.

{
  return this->has_shutdown_;
}

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

Hook for the services to determine the <hash> value of a profile. For details on how this is used please see the FT service

Definition at line 137 of file ORB_Core.inl.

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

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

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

void TAO_ORB_Core::implrepo_service

(

const CORBA::Object_ptr

ir

)

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

Definition at line 353 of file ORB_Core.inl.

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

{
  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_);
}

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

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

{
  // 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;

  // Number of hops for a datagram sent through socket.
  int ip_hoplimit = -1;

  // Use IP_MILTICAST_LOOP (default 1).
  int ip_multicastloop = 1;

  // 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)
  bool std_profile_components = true;
#else
  bool std_profile_components = false;
#endif /* TAO_STD_PROFILE_COMPONENTS */

  int linger = TAO_SO_LINGER;
  time_t accept_error_delay = TAO_ACCEPT_ERROR_DELAY;
  bool use_parallel_connects = TAO_USE_PARALLEL_CONNECT;

  // 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)
  bool negotiate_codesets = true;
#else
  bool negotiate_codesets = false;
#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("-ORBIPHopLimit"))))
        {
          // Number of IP hops.
          ip_hoplimit =
            ACE_OS::atoi (current_arg);

          arg_shifter.consume_arg ();
        }
      else if (0 != (current_arg = arg_shifter.get_the_parameter
                (ACE_TEXT("-ORBIPMulticastLoop"))))
        {
          // Use IP_MULTICAST_LOOP or not.
          ip_multicastloop =
            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 const 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 ();
        }
      else if (0 != (current_arg = arg_shifter.get_the_parameter
                (ACE_TEXT("-ORBForwardInvocationOnObjectNotExist"))))
        {
          int forward = ACE_OS::atoi (current_arg);
          if (forward)
            this->orb_params_.forward_invocation_on_object_not_exist (true);
          else
            this->orb_params_.forward_invocation_on_object_not_exist (false);

          arg_shifter.consume_arg ();
        }
      else if (0 != (current_arg = arg_shifter.get_the_parameter
                (ACE_TEXT("-ORBForwardOnceOnObjectNotExist"))))
        {
          int forward = ACE_OS::atoi (current_arg);
          if (forward)
            this->orb_params_.forward_once_exception (TAO::FOE_OBJECT_NOT_EXIST);

          arg_shifter.consume_arg ();
        }
      else if (0 != (current_arg = arg_shifter.get_the_parameter
                (ACE_TEXT("-ORBForwardOnceOnCommFailure"))))
        {
          int forward = ACE_OS::atoi (current_arg);
          if (forward)
            this->orb_params_.forward_once_exception (TAO::FOE_COMM_FAILURE);

          arg_shifter.consume_arg ();
        }
      else if (0 != (current_arg = arg_shifter.get_the_parameter
                (ACE_TEXT("-ORBForwardOnceOnTransient"))))
        {
          int forward = ACE_OS::atoi (current_arg);
          if (forward)
            this->orb_params_.forward_once_exception (TAO::FOE_TRANSIENT);

          arg_shifter.consume_arg ();
        }
      else if (0 != (current_arg = arg_shifter.get_the_parameter
                (ACE_TEXT("-ORBForwardOnceOnInvObjref"))))
        {
          int forward = ACE_OS::atoi (current_arg);
          if (forward)
            this->orb_params_.forward_once_exception (TAO::FOE_INV_OBJREF);

          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 ("<%C>.\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);
  this->orb_params ()->ip_hoplimit (ip_hoplimit);
  this->orb_params ()->ip_multicastloop (ip_multicastloop);
  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(*this);
  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;
}

TAO_ORB_Core::InitRefMap * TAO_ORB_Core::init_ref_map

(

void

)

Return a pointer to the -ORBInitRef map.

Definition at line 184 of file ORB_Core.inl.

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

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

{
  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 ())
    {
      retval = collocated_orb_core.get ()->adapter_registry ().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 2823 of file ORB_Core.cpp.

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

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

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

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

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

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

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

{
  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;
}

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

{
  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;
}

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

Hook for the services to determine whether the profiles are equivalent or not. For details on how this is used please see the FT service

Definition at line 120 of file ORB_Core.inl.

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

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

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

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

{
  // 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).first.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 1956 of file ORB_Core.cpp.

{
  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);
    }

  // Call the ZIOP library if it has been loaded
  if (this->ziop_adapter_)
    {
      this->ziop_adapter_->load_policy_validators (validator);
    }
}

ACE_Lock * TAO_ORB_Core::locking_strategy

(

void

)

Return the locking strategy used for the data blocks.

Definition at line 40 of file ORB_Core.inl.

{
  if (this->resource_factory ()->use_locked_data_blocks ())
    return &this->data_block_lock_;

  return 0;
}

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

{
  TAO::ORB_Table * const table = TAO::ORB_Table::instance ();
  table->not_default (orb_id);
}

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

{
  CORBA::Boolean retval = false;
  if (this->ft_service_.service_callback ())
    {
      retval = this->ft_service_.service_callback ()->object_is_nil (obj);
    }
  return retval;
}

TAO::ObjectKey_Table & TAO_ORB_Core::object_key_table

(

void

)

Acceessor to the table that stores the object_keys.

Definition at line 67 of file ORB_Core.inl.

{
  return this->object_key_table_;
}

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

{
  return this->object_ref_table_;
}

void TAO_ORB_Core::operator=

(

const TAO_ORB_Core &

)

[private]

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

CORBA::Boolean TAO_ORB_Core::optimize_collocation_objects

(

void

)

const

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

Definition at line 210 of file ORB_Core.inl.

{
  return this->opt_for_collocation_;
}

void TAO_ORB_Core::optimize_collocation_objects

(

CORBA::Boolean

opt

)

Set/get the collocation flags.

Definition at line 204 of file ORB_Core.inl.

{
  this->opt_for_collocation_ = opt;
}

CORBA::ORB_ptr TAO_ORB_Core::orb

(

void

)

Get pointer to the ORB.

Definition at line 166 of file ORB_Core.inl.

{
  return this->orb_;
}

TAO_ORB_Parameters * TAO_ORB_Core::orb_params

(

void

)

Accessor for the ORB parameters.

Definition at line 234 of file ORB_Core.inl.

{
  return &(this->orb_params_);
}

const char * TAO_ORB_Core::orbid

(

void

)

const

Return ORBid string.

Definition at line 347 of file ORB_Core.inl.

{
  return this->orbid_;
}

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

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

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

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

{

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

{
  return this->lane_resources ().output_cdr_msgblock_allocator ();
}

TAO_Parser_Registry * TAO_ORB_Core::parser_registry

(

void

)

Get the IOR parser registry.

Definition at line 251 of file ORB_Core.inl.

{
  return &this->parser_registry_;
}

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

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

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

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

{

  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_;
}

TAO_ProtocolFactorySet * TAO_ORB_Core::protocol_factories

(

void

)

Get the protocol factories.

Definition at line 245 of file ORB_Core.inl.

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

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

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

{
  // Assume ownership of the request dispatcher.
  TAO_Request_Dispatcher *tmp = this->request_dispatcher_;
  this->request_dispatcher_ = request_dispatcher;
  delete tmp;
}

TAO_Request_Dispatcher * TAO_ORB_Core::request_dispatcher

(

void

)

Return the current request dispatcher strategy.

Definition at line 178 of file ORB_Core.inl.

{
  return this->request_dispatcher_;
}

CORBA::Object_ptr TAO_ORB_Core::resolve_codecfactory

(

void

)

Resolve the CodecFactory DLL.

Definition at line 399 of file ORB_Core.inl.

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

{
  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);
    }
}

CORBA::Object_ptr TAO_ORB_Core::resolve_compression_manager

(

void

)

Resolve the Compression DLL.

Definition at line 411 of file ORB_Core.inl.

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

{
  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);
    }
}

CORBA::Object_ptr TAO_ORB_Core::resolve_dynanyfactory

(

void

)

Resolve the Dynamic Any Factory.

Definition at line 488 of file ORB_Core.inl.

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

{
  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);
    }
}

CORBA::Object_ptr TAO_ORB_Core::resolve_ior_manipulation

(

void

)

Resolve the IOR Manipulation reference for this ORB.

Definition at line 500 of file ORB_Core.inl.

{
  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_);
}

CORBA::Object_ptr TAO_ORB_Core::resolve_ior_table

(

void

)

Resolve the IOR Table reference for this ORB.

Definition at line 512 of file ORB_Core.inl.

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

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

{
  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);
    }
}

CORBA::Object_ptr TAO_ORB_Core::resolve_monitor

(

void

)

Resolve the Monitor reference for this ORB.

Definition at line 524 of file ORB_Core.inl.

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

{
  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);
    }
}

CORBA::Object_ptr TAO_ORB_Core::resolve_poa_current

(

void

)

Resolve POA Current.

Definition at line 548 of file ORB_Core.inl.

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

{
  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