TAO_ORB_Core Class Reference

Encapsulates the state of an ORB. More...

#include <ORB_Core.h>

Collaboration diagram for TAO_ORB_Core:

Collaboration graph
[legend]
List of all members.

Collocation Strategies

enum  { ORB_CONTROL, THRU_POA, DIRECT }
static TAO::Collocation_Strategy collocation_strategy (CORBA::Object_ptr object ACE_ENV_ARG_DECL)

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_Hash_Map_Manager_Ex<
ACE_CString, ACE_CString,
ACE_Hash< ACE_CString >,
ACE_Equal_To< ACE_CString >,
ACE_Null_Mutex
InitRefMap

Public Member Functions

 TAO_ORB_Core (const char *id)
 Constructor.
TAO_ORB_Parametersorb_params (void)
 Accessor for the ORB parameters.
TAO_Connector_Registryconnector_registry (ACE_ENV_SINGLE_ARG_DECL)
 Get the connector registry.
TAO_Parser_Registryparser_registry (void)
 Get the IOR parser registry.
TAO_PolicyFactory_Registrypolicy_factory_registry (void)
TAO_ProtocolFactorySetprotocol_factories (void)
 Get the protocol factories.
CORBA::ORB_ptr orb (void)
 Get pointer to the ORB.
ACE_Reactorreactor (void)
 Wrappers that forward the request to the concurrency strategy.
ACE_Thread_Managerthr_mgr (void)
 Get the ACE_Thread_Manager.
CORBA::Object_ptr root_poa (ACE_ENV_SINGLE_ARG_DECL)
 Return the RootPOA, or try to load it if not initialized already.
TAO_Adapter_Registryadapter_registry (void)
 Get the adapter registry.
TAO_Adapterpoa_adapter (void)
TAO_Protocols_Hooksget_protocols_hooks (void)
 Gets the value of TAO_ORB_Core::protocols_hooks__.
int is_collocated (const TAO_MProfile &mprofile)
ACE_Allocatoroutput_cdr_dblock_allocator (void)
ACE_Allocatoroutput_cdr_buffer_allocator (void)
ACE_Allocatoroutput_cdr_msgblock_allocator (void)
ACE_Allocatorinput_cdr_dblock_allocator (void)
ACE_Allocatorinput_cdr_buffer_allocator (void)
ACE_Allocatorinput_cdr_msgblock_allocator (void)
ACE_Allocatortransport_message_buffer_allocator (void)
ACE_Data_Blockcreate_input_cdr_data_block (size_t size)
ACE_Locklocking_strategy (void)
 Return the locking strategy used for the data blocks.
TAO_Policy_Setget_default_policies (void)
 Accessor method for the default_policies_.
CORBA::Policy_ptr get_policy (CORBA::PolicyType type ACE_ENV_ARG_DECL)
CORBA::Policy_ptr get_policy_including_current (CORBA::PolicyType type ACE_ENV_ARG_DECL)
CORBA::Policy_ptr get_cached_policy (TAO_Cached_Policy_Type type ACE_ENV_ARG_DECL)
CORBA::Policy_ptr get_cached_policy_including_current (TAO_Cached_Policy_Type type ACE_ENV_ARG_DECL)
TAO_Policy_Managerpolicy_manager (void)
 Return the Policy_Manager for this ORB.
TAO_Policy_Currentpolicy_current (void)
void call_timeout_hook (TAO_Stub *stub, bool &has_timeout, ACE_Time_Value &time_value)
 Invoke the timeout hook if present.
void connection_timeout (TAO_Stub *stub, bool &has_timeout, ACE_Time_Value &time_value)
 Invoke the timeout hook if present.
void call_sync_scope_hook (TAO_Stub *stub, bool &has_synchronization, Messaging::SyncScope &scope)
TAO_Sync_Strategyget_sync_strategy (TAO_Stub *stub, Messaging::SyncScope &scope)
TAO_Transport_Sync_Strategytransport_sync_strategy (void)
 This strategy will sync with the transport.
TAO_ORB_Core_TSS_Resourcesget_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_Registrytss_cleanup_funcs (void)
 Return the underlying TSS cleanup function registry.
TAO_Leader_Followerleader_follower (void)
 Get access to the leader_follower class.
TAO_LF_Strategylf_strategy (void)
 Get access to the leader follower strategy.
TAO_Thread_Lane_Resourceslane_resources (void)
 Get access to the thread lane resources.
int run (ACE_Time_Value *tv, int perform_work ACE_ENV_ARG_DECL)
 Run the event loop.
void shutdown (CORBA::Boolean wait_for_completion ACE_ENV_ARG_DECL) throw ()
 End the event loop.
int has_shutdown (void)
 Get the shutdown flag value.
void destroy (ACE_ENV_SINGLE_ARG_DECL)
 Shutdown the ORB and free resources.
void check_shutdown (ACE_ENV_SINGLE_ARG_DECL)
 Check if ORB has shutdown. If it has, throw an exception.
int thread_per_connection_timeout (ACE_Time_Value &timeout) const
TAO_Stubcreate_stub_object (TAO_MProfile &mprofile, const char *type_id, CORBA::PolicyList *policy_list ACE_ENV_ARG_DECL)
TAO_Stubcreate_stub (const char *repository_id, const TAO_MProfile &profiles ACE_ENV_ARG_DECL)
CORBA::Object_ptr create_object (TAO_Stub *the_stub)
CORBA::Long initialize_object (TAO_Stub *the_stub, CORBA::Object_ptr obj)
const char * orbid (void) const
 Return ORBid string.
CORBA::Object_ptr resolve_typecodefactory (ACE_ENV_SINGLE_ARG_DECL)
 Resolve the TypeCodeFactory DLL.
CORBA::Object_ptr resolve_dynanyfactory (ACE_ENV_SINGLE_ARG_DECL)
 Resolve the Dynamic Any Factory.
CORBA::Object_ptr resolve_ior_manipulation (ACE_ENV_SINGLE_ARG_DECL)
 Resolve the IOR Manipulation reference for this ORB.
CORBA::Object_ptr resolve_ior_table (ACE_ENV_SINGLE_ARG_DECL)
 Resolve the IOR Table reference for this ORB.
CORBA::Object_ptr resolve_rir (const char *name ACE_ENV_ARG_DECL)
 Resolve an initial reference via the -ORBInitRef and.
CORBA::Object_ptr resolve_rt_orb (ACE_ENV_SINGLE_ARG_DECL)
 Resolve the RT ORB reference for this ORB.
const char * server_id (void) const
CORBA::Object_ptr resolve_rt_current (ACE_ENV_SINGLE_ARG_DECL)
CORBA::ORB_ObjectIdListlist_initial_references (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
 List all the service known by the ORB.
CORBA::ULong _incr_refcnt (void)
 Reference counting...
CORBA::ULong _decr_refcnt (void)
int register_handle (ACE_HANDLE handle)
int remove_handle (ACE_HANDLE handle)
TAO_Valuetype_Adapter *& valuetype_adapter (void)
 Return the valuetype adapter.
TAO_IORInterceptor_Adapterior_interceptor_adapter (void)
CORBA::Boolean bidir_giop_policy (void)
void bidir_giop_policy (CORBA::Boolean)
TAO_Object_Ref_Tableobject_ref_table (void)
TAO::ObjectKey_Tableobject_key_table (void)
 Acceessor to the table that stores the object_keys.
TAO_Request_Dispatcherrequest_dispatcher (void)
 Return the current request dispatcher strategy.
void request_dispatcher (TAO_Request_Dispatcher *rd)
void load_policy_validators (TAO_Policy_Validator &validator ACE_ENV_ARG_DECL)
TAO_Flushing_Strategyflushing_strategy (void)
 Return the flushing strategy.
TAO_Codeset_Managercodeset_manager (void)
 Get Code Set Manager.
InitRefMapinit_ref_map (void)
 Return a pointer to the -ORBInitRef map.
void set_default (const char *orb_id)
void not_default (const char *orb_id)
CORBA::Object_ptr poa_current (void)
 Accessor to the POA current.
void poa_current (CORBA::Object_ptr poa_current)
 Accessor to the POA current.
void optimize_collocation_objects (CORBA::Boolean opt)
 Set/get the collocation flags.
CORBA::Boolean optimize_collocation_objects (void) const
 Set/get the collocation flags.
void use_global_collocation (CORBA::Boolean opt)
 Set/get the collocation flags.
CORBA::Boolean use_global_collocation (void) const
 Set/get the collocation flags.
CORBA::ULong get_collocation_strategy (void) const
 Set/get the collocation flags.
Access to Factories
These factories are not thread-specific, and are presented here in order to have one place to get useful information. Often, the instances to which the return pointers are stored in the Service Repository.

TAO_Resource_Factoryresource_factory (void)
 Returns pointer to the resource factory.
TAO_Client_Strategy_Factoryclient_factory (void)
 Returns pointer to the client factory.
TAO_Server_Strategy_Factoryserver_factory (void)
 Returns pointer to the server factory.
TAO_Protocols_Hooksprotocols_hooks (void)
 Returns pointer to the Protocols_Hooks.
TAO_Thread_Lane_Resources_Managerthread_lane_resources_manager (void)
 Returns a pointer to the Thread Lane Resources Manager.
TAO_Collocation_Resolvercollocation_resolver (void)
 Returns a pointer to the Collocation Resolver.
TAO_Stub_Factorystub_factory (void)
 Returns a pointer to the Stub factory.
TAO_Endpoint_Selector_Factoryendpoint_selector_factory (void)
 Returns a pointer to the endpoint selector factory.
CORBA::Environmentdefault_environment (void) const
void default_environment (CORBA::Environment *)
TAO_Eager_Buffering_Sync_Strategyeager_buffering_sync_strategy (void)
 This strategy will buffer messages.
TAO_Delayed_Buffering_Sync_Strategydelayed_buffering_sync_strategy (void)
 This strategy will buffer messages.
CORBA::Object_ptr implrepo_service (void)
 Set/Get the IOR of the Implementation Repository service.
void implrepo_service (const CORBA::Object_ptr ir)
 Set/Get the IOR of the Implementation Repository service.
ORB Core Service Hooks
These methods would represent the hooks in the ORB Core. These hooks would be used to call back on the services or other features that are dynamically loaded.

CORBA::Boolean service_profile_selection (TAO_MProfile &mprofile, TAO_Profile *&profile)
CORBA::Boolean service_profile_reselection (TAO_Stub *stub, TAO_Profile *&profile)
void reset_service_profile_flags (void)
 Reset the flags in the loaded services.
CORBA::Boolean object_is_nil (CORBA::Object_ptr object)
CORBA::Boolean is_profile_equivalent (const TAO_Profile *this_p, const TAO_Profile *that_p)
CORBA::ULong hash_service (TAO_Profile *this_p, CORBA::ULong max)
void service_context_list (TAO_Stub *stub, TAO_Service_Context &service_context, CORBA::Boolean retstart ACE_ENV_ARG_DECL)
TAO_Fault_Tolerance_Servicefault_tolerance_service (void)
 Return a reference to the Fault Tolerant service object.
TAO::Invocation_Status service_raise_comm_failure (IOP::ServiceContextList &clist, TAO_Profile *profile ACE_ENV_ARG_DECL)
TAO::Invocation_Status service_raise_transient_failure (IOP::ServiceContextList &clist, TAO_Profile *profile ACE_ENV_ARG_DECL)
Portable Interceptor Related Methods
These are support methods for interceptor registration and interceptor set (an array) access, in addition to PICurrent access.

TAO::PICurrentpi_current (void)
 Return a pointer to the cached TAO::PICurrent object.
void pi_current (TAO::PICurrent *current)
 Set the pointer to the cached TAO::PICurrent object.
void add_interceptor (PortableInterceptor::ClientRequestInterceptor_ptr interceptor ACE_ENV_ARG_DECL)
 Register a client request interceptor.
void add_interceptor (PortableInterceptor::ServerRequestInterceptor_ptr interceptor ACE_ENV_ARG_DECL)
 Register a server request interceptor.
TAO_ClientRequestInterceptor_List::TYPEclient_request_interceptors (void)
TAO_ServerRequestInterceptor_List::TYPEserver_request_interceptors (void)
void add_interceptor (PortableInterceptor::IORInterceptor_ptr interceptor ACE_ENV_ARG_DECL)
 Register an IOR interceptor.

Static Public Member Functions

static void set_thread_lane_resources_manager_factory (const char *thread_lane_resources_manager_factory_name)
static void set_collocation_resolver (const char *collocation_resolver_name)
 Sets the value of TAO_ORB_Core::collocation_resolver_name_.
static void set_stub_factory (const char *stub_factory_name)
 Sets the value of TAO_ORB_Core::stub_factory_name_.
static void set_resource_factory (const char *resource_factory_name)
 Sets the value of TAO_ORB_Core::resource_factory_.
static void set_protocols_hooks (const char *protocols_hooks_name)
 Sets the value of TAO_ORB_Core::protocols_hooks_.
static void set_endpoint_selector_factory (const char *endpoint_selector_factory_name)
 Sets the value of TAO_ORB_Core::endpoint_selector_factory_.
static void set_poa_factory (const char *poa_factory_name, const char *poa_factory_directive)
static const ACE_CStringpoa_factory_name (void)
 Access the POA factory name.
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_name (const char *name)
 Sets the value of TAO_ORB_Core::valuetype_adapter_name.
static const char * valuetype_adapter_name (void)
 Gets the value of TAO_ORB_Core::valuetype_adapter_name.
static void set_timeout_hook (Timeout_Hook hook)
static void connection_timeout_hook (Timeout_Hook hook)
 Define the Timeout_Hook signature.
static void set_sync_scope_hook (Sync_Scope_Hook hook)

Public Attributes

TAO_Protocols_Hooksprotocols_hooks_
 Handle to the factory for protocols_hooks_..

Protected Member Functions

 ~TAO_ORB_Core (void)
int init (int &argc, char **argv ACE_ENV_ARG_DECL)
int fini (void)
ACE_Data_Blockcreate_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 (ACE_ENV_SINGLE_ARG_DECL)
 Obtain and cache the dynamic any factory object reference.
void resolve_dynanyfactory_i (ACE_ENV_SINGLE_ARG_DECL)
 Obtain and cache the dynamic any factory object reference.
void resolve_iormanipulation_i (ACE_ENV_SINGLE_ARG_DECL)
 Obtain and cache the IORManipulation factory object reference.
int bidirectional_giop_init (ACE_ENV_SINGLE_ARG_DECL)
void services_callbacks_init (void)
void destroy_interceptors (ACE_ENV_SINGLE_ARG_DECL) throw ()
int set_endpoint_helper (const ACE_CString &lane, const ACE_CString &endpoints ACE_ENV_ARG_DECL)
 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_Managerthread_lane_resources_manager_
TAO_Collocation_Resolvercollocation_resolver_
TAO_Stub_Factorystub_factory_
TAO_ProtocolFactorySetprotocol_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.
CORBA::Object_ptr typecode_factory_
 The cached IOR for the TypeCodeFactory DLL.
CORBA::Object_ptr dynany_factory_
 The cached object reference for the DynAnyFactory.
CORBA::Object_ptr ior_manip_factory_
 The cached object reference for the IORManipulataion.
CORBA::Object_ptr ior_table_
 The cached object reference for the IORTable.
CORBA::Object_var rt_orb_
 The cached object reference for the RTCORBA::RTORB.
CORBA::Object_var rt_current_
 The cached object reference for the RTCORBA::Current interface.
CORBA::ORB_ptr orb_
CORBA::Object_var root_poa_
TAO_ORB_Parameters orb_params_
 Parameters used by the ORB.
InitRefMap init_ref_map_
 Return InitRefMap to find if a particular object id is present.
TAO_Object_Ref_Table object_ref_table_
TAO::ObjectKey_Table object_key_table_
 Table that stores the object key instead of caching one per-profile.
char * orbid_
 The ORBid for this ORB.
TAO_Resource_Factoryresource_factory_
 Handle to the factory for resource information..
ACE_CString server_id_
 The server_id_ that was passed via -ORBServerId option.
TAO_Client_Strategy_Factoryclient_factory_
 Handle to the factory for Client-side strategies.
TAO_Server_Strategy_Factoryserver_factory_
 Handle to the factory for Server-side strategies.
CORBA::Boolean opt_for_collocation_
CORBA::Boolean use_global_collocation_
CORBA::ULong collocation_strategy_
 Default collocation policy. This should never be ORB_CONTROL.
TAO_Policy_Managerpolicy_manager_
 The Policy_Manager for this ORB.
TAO_Policy_Setdefault_policies_
 The default policies.
TAO_Policy_Currentpolicy_current_
 Policy current.
TAO_Request_Dispatcherrequest_dispatcher_
 The request dispatching strategy.
CORBA::Object_var poa_current_
TAO_Adapter_Registry adapter_registry_
 The list of Adapters used in this ORB.
TAO_Adapterpoa_adapter_
 An optimization for the POA.
ACE_Thread_Manager tm_
 The Thread Manager.
ACE_Lock_Adapter< TAO_SYNCH_MUTEX > data_block_lock_
 The data block reference counts are locked using this mutex.
TAO_Cleanup_Func_Registry tss_cleanup_funcs_
int has_shutdown_
 Flag which denotes that the ORB has been shutdown.
TAO_SYNCH_MUTEX open_lock_
 Mutual exclusion for calling open.
int open_called_
 Flag which denotes that the open method was called.
TAO_Endpoint_Selector_Factoryendpoint_selector_factory_
TAO_Eager_Buffering_Sync_Strategyeager_buffering_sync_strategy_
 This strategy will buffer messages.
TAO_Delayed_Buffering_Sync_Strategydelayed_buffering_sync_strategy_
 This strategy will buffer messages.
TAO_Transport_Sync_Strategytransport_sync_strategy_
 This strategy will sync with the transport.
CORBA::ULong refcount_
 Number of outstanding references to this object.
TAO_PolicyFactory_Registry policy_factory_registry_
 Registry containing all registered policy factories.
TAO::PICurrentpi_current_
 Cached pointer/reference to the PICurrent object.
TAO_ClientRequestInterceptor_List client_request_interceptors_
 Client request interceptor registry.
TAO_ServerRequestInterceptor_List server_request_interceptors_
 Server request interceptor registry.
TAO_IORInterceptor_Adapterior_interceptor_adapter_
 IORInterceptor adapter.
TAO_Valuetype_Adaptervaluetype_adapter_
 Pointer to the valuetype adapter.
TAO_Parser_Registry parser_registry_
 The IOR parser registry.
TAO_BiDir_Adapterbidir_adapter_
 BiDirectional GIOP factory.
CORBA::Boolean bidir_giop_policy_
 Bir Dir GIOP policy value.
TAO_Flushing_Strategyflushing_strategy_
 Hold the flushing strategy.
TAO_Codeset_Managercodeset_manager_
 Code Set Manager - points to object owned by resource factory.
Service Level Hooks
TAO_Fault_Tolerance_Service ft_service_
 Fault Tolerant service hook.
int thread_per_connection_use_timeout_
 The value of the timeout if the flag above is not zero.
ACE_Time_Value thread_per_connection_timeout_
 The value of the timeout if the flag above is not zero.

Private Member Functions

void resolve_ior_table_i (ACE_ENV_SINGLE_ARG_DECL)
 Obtain and cache the dynamic any factory object reference.
CORBA::Boolean is_collocation_enabled (TAO_ORB_Core *other_orb, const TAO_MProfile &mp)
 TAO_ORB_Core (const TAO_ORB_Core &)
 The ORB Core should not be copied.
void operator= (const TAO_ORB_Core &)
 The ORB Core should not be copied.

Friends

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

Detailed Description

Encapsulates the state of an ORB.

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

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


Member Typedef Documentation

typedef ACE_Hash_Map_Manager_Ex<ACE_CString, ACE_CString, ACE_Hash<ACE_CString>, ACE_Equal_To<ACE_CString>, ACE_Null_Mutex> TAO_ORB_Core::InitRefMap
 

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

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

Define the Timeout_Hook signature.


Member Enumeration Documentation

anonymous enum
 

Enumerator:
ORB_CONTROL  Indicate object should refer to ORB for either one of the following strategies.
THRU_POA  Collocated calls will go thru POA.
DIRECT  Collocated calls invoke operation on Servant directly.


Constructor & Destructor Documentation

TAO_ORB_Core::TAO_ORB_Core const char *  id  ) 
 

Constructor.

TAO_ORB_Core::~TAO_ORB_Core void   )  [protected]
 

Destructor is protected since the ORB Core is a reference counted object.

TAO_ORB_Core::TAO_ORB_Core const TAO_ORB_Core  )  [private]
 

The ORB Core should not be copied.


Member Function Documentation

ACE_INLINE CORBA::ULong TAO_ORB_Core::_decr_refcnt void   ) 
 

ACE_INLINE CORBA::ULong TAO_ORB_Core::_incr_refcnt void   ) 
 

Reference counting...

TAO_ORB_Core::ACE_TSS_TYPE TAO_ORB_Core_TSS_Resources   )  [protected]
 

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

ACE_INLINE TAO_Adapter_Registry * TAO_ORB_Core::adapter_registry void   ) 
 

Get the adapter registry.

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

Register an IOR interceptor.

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

Register a server request interceptor.

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

Register a client request interceptor.

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

ACE_INLINE void TAO_ORB_Core::bidir_giop_policy CORBA::Boolean   ) 
 

ACE_INLINE CORBA::Boolean TAO_ORB_Core::bidir_giop_policy void   ) 
 

Set and Get methods to indicate whether a BiDir IIOP policy has been set in the POA.

Note:
At present, the value will be true even if one of the POA's is set with the Bi Dir GIOP policy.

int TAO_ORB_Core::bidirectional_giop_init ACE_ENV_SINGLE_ARG_DECL   )  [protected]
 

Search the Dynamic service list for BiDirectional options that can be dynamically loaded.

void TAO_ORB_Core::call_sync_scope_hook TAO_Stub stub,
bool &  has_synchronization,
Messaging::SyncScope 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.

void TAO_ORB_Core::check_shutdown ACE_ENV_SINGLE_ARG_DECL   ) 
 

Check if ORB has shutdown. If it has, throw an exception.

TAO_Client_Strategy_Factory * TAO_ORB_Core::client_factory void   ) 
 

Returns pointer to the client factory.

TAO_ClientRequestInterceptor_List::TYPE& TAO_ORB_Core::client_request_interceptors void   ) 
 

Return the array of client-side interceptors specific to this ORB.

ACE_INLINE TAO_Codeset_Manager * TAO_ORB_Core::codeset_manager void   ) 
 

Get Code Set Manager.

TAO_Collocation_Resolver & TAO_ORB_Core::collocation_resolver void   ) 
 

Returns a pointer to the Collocation Resolver.

TAO::Collocation_Strategy TAO_ORB_Core::collocation_strategy CORBA::Object_ptr object  ACE_ENV_ARG_DECL  )  [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.

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.

void TAO_ORB_Core::connection_timeout_hook Timeout_Hook  hook  )  [static]
 

Define the Timeout_Hook signature.

TAO_Connector_Registry * TAO_ORB_Core::connector_registry ACE_ENV_SINGLE_ARG_DECL   ) 
 

Get the connector registry.

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.

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.

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.

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

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.

TAO_Stub * TAO_ORB_Core::create_stub_object TAO_MProfile mprofile,
const char *  type_id,
CORBA::PolicyList *policy_list  ACE_ENV_ARG_DECL
 

Makes sure that the ORB is open and then creates a TAO_Stub based on the endpoint.

void TAO_ORB_Core::default_environment CORBA::Environment  ) 
 

The thread has a default environment to simplify porting between platforms that support native C++ exceptions and those that don't. This is a TSS resource (always), but with a twist: if the user creates a new environment the old one is "pushed" (actually the new one remembers it), eventually the new environment destructor pops itself from the stack and we recover the old environment.

This means that if the user create a new environment and somebody calls a function using the default one the exception will still be received in the environment created by the user. The only drawback is that environments life time must nest properly, this shouldn't be a problem because environments are usually created on the stack, but, the spec allows their creation on the heap and/or as class members; we need to investigate the tradeoffs and take a decision.

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.

TAO_Delayed_Buffering_Sync_Strategy& TAO_ORB_Core::delayed_buffering_sync_strategy void   ) 
 

This strategy will buffer messages.

void TAO_ORB_Core::destroy ACE_ENV_SINGLE_ARG_DECL   ) 
 

Shutdown the ORB and free resources.

void TAO_ORB_Core::destroy_interceptors ACE_ENV_SINGLE_ARG_DECL   )  throw () [protected]
 

Helper method that invokes Interceptor::destroy() on all registered interceptors when ORB::destroy() is called. Prevents exceptions from propagating up the call chain.

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

Gets the value of TAO_ORB_Core::dynamic_adapter_name_.

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

Sets the value of TAO_ORB_Core::dynamic_adapter_name_.

TAO_Eager_Buffering_Sync_Strategy& TAO_ORB_Core::eager_buffering_sync_strategy void   ) 
 

This strategy will buffer messages.

TAO_Endpoint_Selector_Factory * TAO_ORB_Core::endpoint_selector_factory void   ) 
 

Returns a pointer to the endpoint selector factory.

ACE_INLINE TAO_Fault_Tolerance_Service & TAO_ORB_Core::fault_tolerance_service void   ) 
 

Return a reference to the Fault Tolerant service object.

int TAO_ORB_Core::fini void   )  [protected]
 

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

ACE_INLINE TAO_Flushing_Strategy * TAO_ORB_Core::flushing_strategy void   ) 
 

Return the flushing strategy.

The flushing strategy is created by the resource factory, and it is used by the ORB to control the mechanism used to flush the outgoing data queues. The flushing strategies are stateless, therefore, there is only one per ORB.

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

Get a cached policy. First, check the ORB-level Policy Manager, then check the ORB defaults.

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

Get a cached policy. First, check the thread current, then check the ORB-level Policy Manager, then check the ORB defaults.

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

Set/get the collocation flags.

TAO_Policy_Set* TAO_ORB_Core::get_default_policies void   ) 
 

Accessor method for the default_policies_.

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

Get a policy. First, check the ORB-level Policy Manager, then check the ORB defaults.

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

Get a policy. First, check the thread current, then check the ORB-level Policy Manager, then check the ORB defaults.

TAO_Protocols_Hooks * TAO_ORB_Core::get_protocols_hooks void   ) 
 

Gets the value of TAO_ORB_Core::protocols_hooks__.

TAO_Sync_Strategy & TAO_ORB_Core::get_sync_strategy TAO_Stub stub,
Messaging::SyncScope scope
 

ACE_INLINE void * TAO_ORB_Core::get_tss_resource size_t  slot_id  ) 
 

Obtain the TSS resource in the given slot.

ACE_INLINE TAO_ORB_Core_TSS_Resources * TAO_ORB_Core::get_tss_resources void   ) 
 

Obtain the TSS resources of this orb.

ACE_INLINE int TAO_ORB_Core::has_shutdown void   ) 
 

Get the shutdown flag value.

ACE_INLINE CORBA::ULong TAO_ORB_Core::hash_service TAO_Profile this_p,
CORBA::ULong  max
 

For details on how this is used please see the FT service

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

Gets the value of TAO_ORB_Core::ifr_client_adapter_name_.

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

Sets the value of TAO_ORB_Core::ifr_client_adapter_name_.

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

Set/Get the IOR of the Implementation Repository service.

CORBA::Object_ptr TAO_ORB_Core::implrepo_service void   ) 
 

Set/Get the IOR of the Implementation Repository service.

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

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

TAO_ORB_Core::InitRefMap * TAO_ORB_Core::init_ref_map void   ) 
 

Return a pointer to the -ORBInitRef 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.

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.

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.

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.

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.

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

Gets the value of TAO_ORB_Core::iorinterceptor_adapter_factory_name_.

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

Sets the value of TAO_ORB_Core::iorinterceptor_adapter_factory_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.

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>

ACE_INLINE CORBA::Boolean TAO_ORB_Core::is_profile_equivalent const TAO_Profile this_p,
const TAO_Profile that_p
 

For details on how this is used please see the FT service

TAO_Thread_Lane_Resources & TAO_ORB_Core::lane_resources void   ) 
 

Get access to the thread lane resources.

TAO_Leader_Follower & TAO_ORB_Core::leader_follower void   ) 
 

Get access to the leader_follower class.

TAO_LF_Strategy & TAO_ORB_Core::lf_strategy void   ) 
 

Get access to the leader follower strategy.

CORBA::ORB_ObjectIdList* TAO_ORB_Core::list_initial_references ACE_ENV_SINGLE_ARG_DECL_NOT_USED   ) 
 

List all the service known by the ORB.

void TAO_ORB_Core::load_policy_validators TAO_Policy_Validator &validator  ACE_ENV_ARG_DECL  ) 
 

Call the libraries to handover the validators if they havent registered yet with the list of validators.

ACE_INLINE ACE_Lock * TAO_ORB_Core::locking_strategy void   ) 
 

Return the locking strategy used for the data blocks.

void TAO_ORB_Core::not_default const char *  orb_id  ) 
 

Set to choose to be not a default ORB when there are more than one ORB.

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

The loaded service would determine if the CORBA::Object_ptr is actually nil or not. This would be useful to accomodate new enhanced definitions as defined by the service specification.

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

Acceessor to the table that stores the object_keys.

ACE_INLINE TAO_Object_Ref_Table & TAO_ORB_Core::object_ref_table void   ) 
 

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

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

The ORB Core should not be copied.

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

Set/get the collocation flags.

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

Set/get the collocation flags.

ACE_INLINE CORBA::ORB_ptr TAO_ORB_Core::orb void   ) 
 

Get pointer to the ORB.

ACE_INLINE TAO_ORB_Parameters * TAO_ORB_Core::orb_params void   ) 
 

Accessor for the ORB parameters.

ACE_INLINE const char * TAO_ORB_Core::orbid void   )  const
 

Return ORBid string.

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.

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.

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.

ACE_INLINE TAO_Parser_Registry * TAO_ORB_Core::parser_registry void   ) 
 

Get the IOR parser registry.

void TAO_ORB_Core::pi_current TAO::PICurrent current  ) 
 

Set the pointer to the cached TAO::PICurrent object.

TAO::PICurrent* TAO_ORB_Core::pi_current void   ) 
 

Return a pointer to the cached TAO::PICurrent object.

TAO_Adapter * TAO_ORB_Core::poa_adapter void   ) 
 

Get the adapter named "RootPOA" and cache the result, this is an optimization for the POA.

ACE_INLINE void TAO_ORB_Core::poa_current CORBA::Object_ptr  poa_current  ) 
 

Accessor to the POA current.

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

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

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

Access the POA factory name.

TAO_Policy_Current& TAO_ORB_Core::policy_current void   ) 
 

Accesors to the policy current, this object should be kept in TSS storage. The POA has to reset the policy current object on every upcall.

ACE_INLINE TAO_PolicyFactory_Registry * TAO_ORB_Core::policy_factory_registry void   ) 
 

Return pointer to the policy factory registry associated with this ORB core.

TAO_Policy_Manager* TAO_ORB_Core::policy_manager void   ) 
 

Return the Policy_Manager for this ORB.

ACE_INLINE TAO_ProtocolFactorySet * TAO_ORB_Core::protocol_factories void   ) 
 

Get the 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.

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.

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.

ACE_INLINE TAO_Request_Dispatcher * TAO_ORB_Core::request_dispatcher void   ) 
 

Return the current request dispatcher strategy.

ACE_INLINE void TAO_ORB_Core::reset_service_profile_flags void   ) 
 

Reset the flags in the loaded services.

ACE_INLINE CORBA::Object_ptr TAO_ORB_Core::resolve_dynanyfactory ACE_ENV_SINGLE_ARG_DECL   ) 
 

Resolve the Dynamic Any Factory.

void TAO_ORB_Core::resolve_dynanyfactory_i ACE_ENV_SINGLE_ARG_DECL   )  [protected]
 

Obtain and cache the dynamic any factory object reference.

ACE_INLINE CORBA::Object_ptr TAO_ORB_Core::resolve_ior_manipulation ACE_ENV_SINGLE_ARG_DECL   ) 
 

Resolve the IOR Manipulation reference for this ORB.

ACE_INLINE CORBA::Object_ptr TAO_ORB_Core::resolve_ior_table ACE_ENV_SINGLE_ARG_DECL   ) 
 

Resolve the IOR Table reference for this ORB.

void TAO_ORB_Core::resolve_ior_table_i ACE_ENV_SINGLE_ARG_DECL   )  [private]
 

Obtain and cache the dynamic any factory object reference.

void TAO_ORB_Core::resolve_iormanipulation_i ACE_ENV_SINGLE_ARG_DECL   )  [protected]
 

Obtain and cache the IORManipulation factory object reference.

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

Resolve an initial reference via the -ORBInitRef and.

ACE_INLINE CORBA::Object_ptr TAO_ORB_Core::resolve_rt_current ACE_ENV_SINGLE_ARG_DECL   ) 
 

ACE_INLINE CORBA::Object_ptr TAO_ORB_Core::resolve_rt_orb ACE_ENV_SINGLE_ARG_DECL   ) 
 

Resolve the RT ORB reference for this ORB.

ACE_INLINE CORBA::Object_ptr TAO_ORB_Core::resolve_typecodefactory ACE_ENV_SINGLE_ARG_DECL   ) 
 

Resolve the TypeCodeFactory DLL.

void TAO_ORB_Core::resolve_typecodefactory_i ACE_ENV_SINGLE_ARG_DECL   )  [protected]
 

Obtain and cache the dynamic any factory object reference.

TAO_Resource_Factory * TAO_ORB_Core::resource_factory void   ) 
 

Returns pointer to the resource factory.

CORBA::Object_ptr TAO_ORB_Core::root_poa ACE_ENV_SINGLE_ARG_DECL   ) 
 

Return the RootPOA, or try to load it if not initialized already.

int TAO_ORB_Core::run ACE_Time_Value tv,
int perform_work  ACE_ENV_ARG_DECL
 

Run the event loop.

TAO_Server_Strategy_Factory * TAO_ORB_Core::server_factory void   ) 
 

Returns pointer to the server factory.

ACE_INLINE const char * TAO_ORB_Core::server_id void   )  const
 

Resolve the RT Current flyweight for this ORB. Return server_id string.

TAO_ServerRequestInterceptor_List::TYPE& TAO_ORB_Core::server_request_interceptors void   ) 
 

Return the array of server-side interceptors specific to this ORB.

void TAO_ORB_Core::service_context_list TAO_Stub stub,
TAO_Service_Context service_context,
CORBA::Boolean retstart  ACE_ENV_ARG_DECL
 

Call the service layers with the Service Context to check whether they would like to add something to the list.

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

The loaded service in the ORB_Core would determine if the profile reselection is going to be made by the services or not. If the services do make the reselection they would return the selected profile through <profile>. The reselction is for the multi-profile IORS.

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

The loaded service in the ORB_Core would determine if the profile selection is going to be made by the services or not. If the services do make the selection they would return the selected profile through <profile>.

TAO::Invocation_Status TAO_ORB_Core::service_raise_comm_failure IOP::ServiceContextList clist,
TAO_Profile *profile  ACE_ENV_ARG_DECL
 

Raise a comm failure exception if a service is not loaded, else delegate to the service to see what the service has to do for this case.

TAO::Invocation_Status TAO_ORB_Core::service_raise_transient_failure IOP::ServiceContextList clist,
TAO_Profile *profile  ACE_ENV_ARG_DECL
 

Raise a transient failure exception if a service is not loaded, else delegate to the service to see what the service has to do for this case.

void TAO_ORB_Core::services_callbacks_init void   )  [protected]
 

Search the Dynamic service list for well known services that has callbacks which can be dynamically loaded.

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

Sets the value of TAO_ORB_Core::collocation_resolver_name_.

void TAO_ORB_Core::set_default const char *  orb_id  ) 
 

Set the ORB related to the orb_id as the default ORB and not the ORB that is first binded in the ORB Table

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

Pointer to the list of protocol loaded into this ORB instance. Helper method to hold the common code part for -ORBEndpoint and -ORBListenEndpoint options.

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

Sets the value of TAO_ORB_Core::endpoint_selector_factory_.

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

Sets the name of the POA factory and the dynamic service configurator directive to load it if needed.

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

Sets the value of TAO_ORB_Core::protocols_hooks_.

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

Sets the value of TAO_ORB_Core::resource_factory_.

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

Sets the value of TAO_ORB_Core::stub_factory_name_.

void TAO_ORB_Core::set_sync_scope_hook Sync_Scope_Hook  hook  )  [static]
 

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

Sets the value of TAO_ORB_Core::thread_lane_resources_manager_factory_name_

void TAO_ORB_Core::set_timeout_hook Timeout_Hook  hook  )  [static]
 

ACE_INLINE int TAO_ORB_Core::set_tss_resource size_t  slot_id,
void * 
 

Set the TSS resource at the given slot. Returns 0 on success, and -1 on failure.

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

End the event loop.

TAO_Stub_Factory * TAO_ORB_Core::stub_factory void   ) 
 

Returns a pointer to the Stub factory.

ACE_INLINE ACE_Thread_Manager * TAO_ORB_Core::thr_mgr void   ) 
 

Get the ACE_Thread_Manager.

TAO_Thread_Lane_Resources_Manager & TAO_ORB_Core::thread_lane_resources_manager void   ) 
 

Returns a pointer to the Thread Lane Resources Manager.

ACE_INLINE int TAO_ORB_Core::thread_per_connection_timeout ACE_Time_Value timeout  )  const
 

Returns the <timeout> value used by the server threads to poll the shutdown flag. If the return value is zero then the server threads block forever.

ACE_Allocator * TAO_ORB_Core::transport_message_buffer_allocator void   ) 
 

This allocator is always global and has no locks. It is intended for allocating the buffers used to queue messages in transports.

ACE_INLINE TAO_Transport_Sync_Strategy & TAO_ORB_Core::transport_sync_strategy void   ) 
 

This strategy will sync with the transport.

ACE_INLINE TAO_Cleanup_Func_Registry * TAO_ORB_Core::tss_cleanup_funcs void   ) 
 

Return the underlying TSS cleanup function registry.

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

Gets the value of TAO_ORB_Core::typecodefactory_adapter_name_.

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

Sets the value of TAO_ORB_Core::typecodefactory_adapter_name_.

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

Set/get the collocation flags.

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

Set/get the collocation flags.

TAO_Valuetype_Adapter *& TAO_ORB_Core::valuetype_adapter void   ) 
 

Return the valuetype adapter.

const char * TAO_ORB_Core::valuetype_adapter_name void   )  [static]
 

Gets the value of TAO_ORB_Core::valuetype_adapter_name.

void TAO_ORB_Core::valuetype_adapter_name const char *  name  )  [static]
 

Sets the value of TAO_ORB_Core::valuetype_adapter_name.


Friends And Related Function Documentation

CORBA::ORB_ptr ORB_init int &  argc,
char *  argv[],
const char *  orb_name,
CORBA::Environment ACE_TRY_ENV
[friend]
 

friend class TAO_ORB_Core_Auto_Ptr [friend]
 


Member Data Documentation

TAO_Adapter_Registry TAO_ORB_Core::adapter_registry_ [protected]
 

The list of Adapters used in this ORB.

TAO_BiDir_Adapter* TAO_ORB_Core::bidir_adapter_ [protected]
 

BiDirectional GIOP factory.

CORBA::Boolean TAO_ORB_Core::bidir_giop_policy_ [protected]
 

Bir Dir GIOP policy value.

TAO_Client_Strategy_Factory* TAO_ORB_Core::client_factory_ [protected]
 

Handle to the factory for Client-side strategies.

TAO_ClientRequestInterceptor_List TAO_ORB_Core::client_request_interceptors_ [protected]
 

Client request interceptor registry.

TAO_Codeset_Manager* TAO_ORB_Core::codeset_manager_ [protected]
 

Code Set Manager - points to object owned by resource factory.

TAO_Collocation_Resolver* TAO_ORB_Core::collocation_resolver_ [protected]
 

CORBA::ULong TAO_ORB_Core::collocation_strategy_ [protected]
 

Default collocation policy. This should never be ORB_CONTROL.

ACE_Lock_Adapter<TAO_SYNCH_MUTEX> TAO_ORB_Core::data_block_lock_ [protected]
 

The data block reference counts are locked using this mutex.

TAO_Policy_Set* TAO_ORB_Core::default_policies_ [protected]
 

The default policies.

TAO_Delayed_Buffering_Sync_Strategy* TAO_ORB_Core::delayed_buffering_sync_strategy_ [protected]
 

This strategy will buffer messages.

CORBA::Object_ptr TAO_ORB_Core::dynany_factory_ [protected]
 

The cached object reference for the DynAnyFactory.

TAO_Eager_Buffering_Sync_Strategy* TAO_ORB_Core::eager_buffering_sync_strategy_ [protected]
 

This strategy will buffer messages.

TAO_Endpoint_Selector_Factory* TAO_ORB_Core::endpoint_selector_factory_ [protected]
 

TAO_Flushing_Strategy* TAO_ORB_Core::flushing_strategy_ [protected]
 

Hold the flushing strategy.

TAO_Fault_Tolerance_Service TAO_ORB_Core::ft_service_ [protected]
 

Fault Tolerant service hook.

int TAO_ORB_Core::has_shutdown_ [protected]
 

Flag which denotes that the ORB has been shutdown.

CORBA::Object_ptr TAO_ORB_Core::implrepo_service_ [protected]
 

The cached IOR for the Implementation Repository.

InitRefMap TAO_ORB_Core::init_ref_map_ [protected]
 

Return InitRefMap to find if a particular object id is present.

TAO_IORInterceptor_Adapter* TAO_ORB_Core::ior_interceptor_adapter_ [protected]
 

IORInterceptor adapter.

CORBA::Object_ptr TAO_ORB_Core::ior_manip_factory_ [protected]
 

The cached object reference for the IORManipulataion.

CORBA::Object_ptr TAO_ORB_Core::ior_table_ [protected]
 

The cached object reference for the IORTable.

TAO_SYNCH_MUTEX TAO_ORB_Core::lock_ [protected]
 

Synchronize internal state...

TAO::ObjectKey_Table TAO_ORB_Core::object_key_table_ [protected]
 

Table that stores the object key instead of caching one per-profile.

TAO_Object_Ref_Table TAO_ORB_Core::object_ref_table_ [protected]
 

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

int TAO_ORB_Core::open_called_ [protected]
 

Flag which denotes that the open method was called.

TAO_SYNCH_MUTEX TAO_ORB_Core::open_lock_ [protected]
 

Mutual exclusion for calling open.

CORBA::Boolean TAO_ORB_Core::opt_for_collocation_ [protected]
 

TRUE if we want to take advantage of collocation optimization in this ORB.

CORBA::ORB_ptr TAO_ORB_Core::orb_ [protected]
 

Note:
Should we keep a single ORB pointer? This is good because multiple calls to ORB_init() with the same ORBid can use the same object, but maybe don't want so much coupling.
Pointer to the ORB.

TAO_ORB_Parameters TAO_ORB_Core::orb_params_ [protected]
 

Parameters used by the ORB.

char* TAO_ORB_Core::orbid_ [protected]
 

The ORBid for this ORB.

TAO_Parser_Registry TAO_ORB_Core::parser_registry_ [protected]
 

The IOR parser registry.

TAO::PICurrent* TAO_ORB_Core::pi_current_ [protected]
 

Cached pointer/reference to the PICurrent object.

A pointer/reference to the PICurrent object is cached in the ORB Core since it is accessed in the critical path (i.e. the request invocation path). Caching it prevents additional overhead to due object resolution from occurring.

TAO_Adapter* TAO_ORB_Core::poa_adapter_ [protected]
 

An optimization for the POA.

CORBA::Object_var TAO_ORB_Core::poa_current_ [protected]
 

POA current.

Note:
This is a pointer in order to reduce the include file dependencies.

TAO_Policy_Current* TAO_ORB_Core::policy_current_ [protected]
 

Policy current.

TAO_PolicyFactory_Registry TAO_ORB_Core::policy_factory_registry_ [protected]
 

Registry containing all registered policy factories.

TAO_Policy_Manager* TAO_ORB_Core::policy_manager_ [protected]
 

The Policy_Manager for this ORB.

TAO_ProtocolFactorySet* TAO_ORB_Core::protocol_factories_ [protected]
 

TAO_Protocols_Hooks* TAO_ORB_Core::protocols_hooks_
 

Handle to the factory for protocols_hooks_..

CORBA::ULong TAO_ORB_Core::refcount_ [protected]
 

Number of outstanding references to this object.

TAO_Request_Dispatcher* TAO_ORB_Core::request_dispatcher_ [protected]
 

The request dispatching strategy.

TAO_Resource_Factory* TAO_ORB_Core::resource_factory_ [protected]
 

Handle to the factory for resource information..

CORBA::Object_var TAO_ORB_Core::root_poa_ [protected]
 

Object reference to the root POA. It will eventually be the object reference returned by calls to CORBA::ORB::resolve_initial_references ("RootPOA").

CORBA::Object_var TAO_ORB_Core::rt_current_ [protected]
 

The cached object reference for the RTCORBA::Current interface.

CORBA::Object_var TAO_ORB_Core::rt_orb_ [protected]
 

The cached object reference for the RTCORBA::RTORB.

TAO_Server_Strategy_Factory* TAO_ORB_Core::server_factory_ [protected]
 

Handle to the factory for Server-side strategies.

ACE_CString TAO_ORB_Core::server_id_ [protected]
 

The server_id_ that was passed via -ORBServerId option.

TAO_ServerRequestInterceptor_List TAO_ORB_Core::server_request_interceptors_ [protected]
 

Server request interceptor registry.

TAO_Stub_Factory* TAO_ORB_Core::stub_factory_ [protected]
 

TAO_Thread_Lane_Resources_Manager* TAO_ORB_Core::thread_lane_resources_manager_ [protected]
 

ACE_Time_Value TAO_ORB_Core::thread_per_connection_timeout_ [protected]
 

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

int TAO_ORB_Core::thread_per_connection_use_timeout_ [protected]
 

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

ACE_Thread_Manager TAO_ORB_Core::tm_ [protected]
 

The Thread Manager.

TAO_Transport_Sync_Strategy* TAO_ORB_Core::transport_sync_strategy_ [protected]
 

This strategy will sync with the transport.

TAO_Cleanup_Func_Registry TAO_ORB_Core::tss_cleanup_funcs_ [protected]
 

TSS Object cleanup functions. These correspond to the TSS objects stored in TAO's TSS resources.

CORBA::Object_ptr TAO_ORB_Core::typecode_factory_ [protected]
 

The cached IOR for the TypeCodeFactory DLL.

CORBA::Boolean TAO_ORB_Core::use_global_collocation_ [protected]
 

TRUE if we want to consider all ORBs in this address space collocated.

int TAO_ORB_Core::use_implrepo_ [protected]
 

Flag for whether the implrepo support is enabled or not.

TAO_Valuetype_Adapter* TAO_ORB_Core::valuetype_adapter_ [protected]
 

Pointer to the valuetype adapter.


The documentation for this class was generated from the following files:
Generated on Wed Nov 23 16:03:34 2005 for TAO by  doxygen 1.4.5