Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   File Members   Related Pages  

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 }
int collocation_strategy (CORBA::Object_ptr object ACE_ENV_ARG_DECL)

Public Types

typedef void(* Timeout_Hook )(TAO_ORB_Core *, TAO_Stub *, int &, ACE_Time_Value &)
 Define the Timeout_Hook signature. More...

typedef void(* Sync_Scope_Hook )(TAO_ORB_Core *, TAO_Stub *, int &, 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 Methods

 TAO_ORB_Core (const char *id)
 Constructor. More...

TAO_ORB_Parametersorb_params (void)
 Accessor for the ORB parameters. More...

TAO_Connector_Registryconnector_registry (ACE_ENV_SINGLE_ARG_DECL)
 Get the connector registry. More...

TAO_Parser_Registryparser_registry (void)
 Get the IOR parser registry. More...

TAO_PolicyFactory_Registrypolicy_factory_registry (void)
 Return pointer to the policy factory registry associated with this ORB core. More...

TAO_ProtocolFactorySetprotocol_factories (void)
 Get the protocol factories. More...

CORBA::ORB_ptr orb (void)
 Get pointer to the ORB. More...

ACE_Reactorreactor (void)
 Wrappers that forward the request to the concurrency strategy. More...

ACE_Thread_Managerthr_mgr (void)
 Get the ACE_Thread_Manager. More...

CORBA::Object_ptr root_poa (ACE_ENV_SINGLE_ARG_DECL)
 Return the RootPOA, or try to load it if not initialized already. More...

TAO_Adapter_Registryadapter_registry (void)
 Get the adapter registry. More...

TAO_Adapterpoa_adapter (void)
 Get the adapter named "RootPOA" and cache the result, this is an optimization for the POA. More...

int inherit_from_parent_thread (TAO_ORB_Core_TSS_Resources *tss_resources)
 A spawned thread needs to inherit some properties/objects from the spawning thread in order to serve requests. Return 0 if it successfully inherits from the parent, -1 otherwise. More...

TAO_Protocols_Hooksget_protocols_hooks (ACE_ENV_SINGLE_ARG_DECL)
 Gets the value of TAO_ORB_Core::protocols_hooks__. More...

int is_collocated (const TAO_MProfile &mprofile)
 See if we have a collocated address, if yes, return the POA associated with the address. More...

ACE_Allocatoroutput_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. More...

ACE_Allocatoroutput_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. More...

ACE_Allocatoroutput_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. More...

ACE_Allocatorinput_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. More...

ACE_Allocatorinput_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. More...

ACE_Allocatorinput_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. More...

ACE_Allocatortransport_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. More...

ACE_Data_Blockcreate_input_cdr_data_block (size_t size)
 The Message Blocks used for input CDRs must have appropiate locking strategies. More...

ACE_Locklocking_strategy (void)
 Return the locking strategy used for the data blocks. More...

TAO_Policy_Setget_default_policies (void)
 Accessor method for the default_policies_. More...

CORBA::Policy_ptr get_cached_policy (TAO_Cached_Policy_Type type)
 Get a cached policy. First, check the ORB-level Policy Manager, and then check the ORB defaults. More...

TAO_Policy_Managerpolicy_manager (void)
 Return the Policy_Manager for this ORB. More...

TAO_Policy_Currentpolicy_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. More...

void call_timeout_hook (TAO_Stub *stub, int &has_timeout, ACE_Time_Value &time_value)
 Invoke the timeout hook if present. More...

CORBA::Policy_ptr stubless_relative_roundtrip_timeout (void)
 Access to the RoundtripTimeoutPolicy policy set on the thread or on the ORB. In this method, we do not consider the stub since we do not have access to it. More...

void connection_timeout (TAO_Stub *stub, int &has_timeout, ACE_Time_Value &time_value)
 Invoke the timeout hook if present. More...

CORBA::Policy_ptr stubless_connection_timeout (void)
 Access to the connection timeout policy set on the thread or on the ORB. In this method, we do not consider the stub since we do not have access to it. More...

void call_sync_scope_hook (TAO_Stub *stub, int &has_synchronization, Messaging::SyncScope &scope)
TAO_Sync_Strategyget_sync_strategy (TAO_Stub *stub, Messaging::SyncScope &scope)
CORBA::Policy_ptr stubless_sync_scope (void)
CORBA::Policy_ptr default_buffering_constraint (void) const
TAO_Transport_Sync_Strategytransport_sync_strategy (void)
 This strategy will sync with the transport. More...

TAO_ORB_Core_TSS_Resourcesget_tss_resources (void)
 Obtain the TSS resources of this orb. More...

void * get_tss_resource (size_t slot_id)
 Obtain the TSS resource in the given slot. More...

int set_tss_resource (size_t slot_id, void *)
 Set the TSS resource at the given slot. Returns 0 on success, and -1 on failure. More...

int 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. More...

TAO_Cleanup_Func_Registrytss_cleanup_funcs (void)
 Return the underlying TSS cleanup function registry. More...

TAO_Leader_Followerleader_follower (void)
 Get access to the leader_follower class. More...

TAO_LF_Strategylf_strategy (void)
 Get access to the leader follower strategy. More...

TAO_Thread_Lane_Resourceslane_resources (void)
 Get access to the thread lane resources. More...

int run (ACE_Time_Value *tv, int perform_work ACE_ENV_ARG_DECL)
 Run the event loop. More...

void shutdown (CORBA::Boolean wait_for_completion ACE_ENV_ARG_DECL) throw ()
 End the event loop. More...

int has_shutdown (void)
 Get the shutdown flag value. More...

void destroy (ACE_ENV_SINGLE_ARG_DECL)
 Shutdown the ORB and free resources. More...

void check_shutdown (ACE_ENV_SINGLE_ARG_DECL)
 Check if ORB has shutdown. If it has, throw an exception. More...

int 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. More...

TAO_Stubcreate_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. More...

TAO_Stubcreate_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. More...

CORBA::Object_ptr 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. More...

const char * orbid (void) const
 Return ORBid string. More...

CORBA::Object_ptr resolve_typecodefactory (ACE_ENV_SINGLE_ARG_DECL)
 Resolve the TypeCodeFactory DLL. More...

CORBA::Object_ptr resolve_dynanyfactory (ACE_ENV_SINGLE_ARG_DECL)
 Resolve the Dynamic Any Factory. More...

CORBA::Object_ptr resolve_ior_manipulation (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
 Resolve the IOR Manipulation reference for this ORB. More...

CORBA::Object_ptr resolve_ior_table (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
 Resolve the IOR Table reference for this ORB. More...

CORBA::Object_ptr resolve_rir (const char *name ACE_ENV_ARG_DECL_NOT_USED)
 Resolve an initial reference via the -ORBInitRef and. More...

CORBA::Object_ptr resolve_rt_orb (ACE_ENV_SINGLE_ARG_DECL)
 Resolve the RT ORB reference for this ORB. More...

const char * server_id (void) const
 Resolve the RT Current flyweight for this ORB. Return server_id string. More...

CORBA::Object_ptr resolve_rt_current (ACE_ENV_SINGLE_ARG_DECL)
TAO_POA_PortableGroup_Hooks * portable_group_poa_hooks (void) const
 Set/Get the current PortableGroup POA hooks. More...

void portable_group_poa_hooks (TAO_POA_PortableGroup_Hooks *poa_hooks)
CORBA_ORB_ObjectIdList_ptr list_initial_references (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
 List all the service known by the ORB. More...

CORBA::ULong _incr_refcnt (void)
 Reference counting... More...

CORBA::ULong _decr_refcnt (void)
int 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. More...

int 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. More...

TAO_Transport_Cache_Managertransport_cache (void)
 Return the underlying transport cache. More...

CORBA::Boolean 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.
More...


void bidir_giop_policy (CORBA::Boolean)
TAO_Object_Ref_Tableobject_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. More...

TAO_Request_Dispatcherrequest_dispatcher (void)
 Return the current request dispatcher strategy. More...

void 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. More...

void load_policy_validators (TAO_Policy_Validator &validator)
 Call the libraries to handover the validators if they havent registered yet with the list of validators. More...

TAO_Flushing_Strategyflushing_strategy (void)
 Return the flushing strategy. More...

TAO_Codeset_Managercodeset_manager (void)
 Get Code Set Manager. More...

InitRefMapinit_ref_map (void)
 Return a pointer to the -ORBInitRef map. More...

void 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. More...

void not_default (const char *orb_id)
 Set to choose to be not a default ORB when there are more than one ORB. More...

CORBA::Object_ptr poa_current (void)
void poa_current (CORBA::Object_ptr poa_current)
Default Code Set Translators
Get the default codeset translators.

In most configurations these are just <nil> objects, but they can be set to something different if the native character sets are not ISO8869 (aka Latin/1, UTF-8) and UNICODE (aka UTF-16).

Note:
This is just note on how the translator database coule be implemented: use the Service Configurator to load the translator, and then use the CodesetId (an unsigned long) to translate the character set code into the Service Object name.

The default resource factory could parse command line options like:

  • -ORBcharcodeset 0x00010001=ISO8859
  • -ORBcharcodeset 0x10020417=IBM1047
  • -ORBwcharcodeset 0x00010106=ISOIEC10646 that would let the user experiment with different translators and plug them in on demand.

We should also think about how translators will report conversion failures and how to simplify the implementation of char translators (it would seem like just a couple of arrays are needed, maybe the arrays should be dynamically loaded and the implementation would remain constant? Just a thought.

ACE_Char_Codeset_Translatorfrom_iso8859 (void) const
 Convert from ISO8859 to the native character set. More...

ACE_Char_Codeset_Translatorto_iso8859 (void) const
 Convert from the native character set to ISO8859. More...

ACE_WChar_Codeset_Translatorfrom_unicode (void) const
 Convert from UNICODE to the native wide character set. More...

ACE_WChar_Codeset_Translatorto_unicode (void) const
 Convert from the native wide character set to UNICODE. More...

void optimize_collocation_objects (CORBA::Boolean opt)
CORBA::Boolean optimize_collocation_objects (void) const
void use_global_collocation (CORBA::Boolean opt)
CORBA::Boolean use_global_collocation (void) const
CORBA::ULong get_collocation_strategy (void) const
Access to Factories
These factories are not thread-specific, and are presented here in order to have one place to get useful information. Often, the instances to which the return pointers are stored in the Service Repository.

TAO_Resource_Factoryresource_factory (void)
 Returns pointer to the resource factory. More...

TAO_Client_Strategy_Factoryclient_factory (void)
 Returns pointer to the client factory. More...

TAO_Server_Strategy_Factoryserver_factory (void)
 Returns pointer to the server factory. More...

TAO_Protocols_Hooksprotocols_hooks (void)
 Returns pointer to the Protocols_Hooks. More...

TAO_Thread_Lane_Resources_Managerthread_lane_resources_manager (void)
 Returns a pointer to the Thread Lane Resources Manager. More...

TAO_Collocation_Resolvercollocation_resolver (void)
 Returns a pointer to the Collocation Resolver. More...

TAO_Stub_Factorystub_factory (void)
 Returns a pointer to the Stub factory. More...

TAO_Endpoint_Selector_Factoryendpoint_selector_factory (void)
 Returns a pointer to the endpoint selector factory. More...

CORBA_Environmentdefault_environment (void) const
void default_environment (CORBA_Environment *)
TAO_Eager_Buffering_Sync_Strategyeager_buffering_sync_strategy (void)
TAO_Delayed_Buffering_Sync_Strategydelayed_buffering_sync_strategy (void)
CORBA::Object_ptr implrepo_service (void)
void implrepo_service (const CORBA::Object_ptr ir)
ORB Core Service Hooks
These methods would represent the hooks in the ORB Core. These hooks would be used to call back on the services or other features that are dynamically loaded.

CORBA::Boolean service_profile_selection (TAO_MProfile &mprofile, TAO_Profile *&profile)
CORBA::Boolean service_profile_reselection (TAO_Stub *stub, TAO_Profile *&profile)
void reset_service_profile_flags (void)
 Reset the flags in the loaded services. More...

CORBA::Boolean object_is_nil (CORBA::Object_ptr object)
void 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. More...

TAO_Fault_Tolerance_Servicefault_tolerance_service (void)
 Return a reference to the Fault Tolerant service object. More...

int service_raise_comm_failure (TAO_GIOP_Invocation *invoke, 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. More...

int service_raise_transient_failure (TAO_GIOP_Invocation *invoke, 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. More...

void services_log_msg_rcv (TAO_Message_State_Factory &state)
 Hook for logging of messages by the Logging & Recovery service of an FT service. More...

void services_log_msg_pre_upcall (TAO_ServerRequest &req)
 Hook for logging of messages by the Logging & Recovery service of an FT service. More...

void services_log_msg_post_upcall (TAO_ServerRequest &req)
 Hook for logging of messages by the Logging & Recovery service of an FT service. More...

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

void pi_current (TAO_PICurrent *current)
 Set the pointer to the cached TAO_PICurrent object. More...

void add_interceptor (PortableInterceptor::ClientRequestInterceptor_ptr interceptor ACE_ENV_ARG_DECL)
 Register a client request interceptor. More...

void add_interceptor (PortableInterceptor::ServerRequestInterceptor_ptr interceptor ACE_ENV_ARG_DECL)
 Register a server request interceptor. More...

TAO_ClientRequestInterceptor_List::TYPEclient_request_interceptors (void)
 Return the array of client-side interceptors specific to this ORB. More...

TAO_ServerRequestInterceptor_List::TYPEserver_request_interceptors (void)
 Return the array of server-side interceptors specific to this ORB. More...

void add_interceptor (PortableInterceptor::IORInterceptor_ptr interceptor ACE_ENV_ARG_DECL)
 Register an IOR interceptor. More...

TAO_IORInterceptor_List::TYPEior_interceptors (void)
 Return the array of IOR interceptors specific to this ORB. More...


Static Public Methods

void set_thread_lane_resources_manager_factory (const char *thread_lane_resources_manager_factory_name)
 Sets the value of TAO_ORB_Core::thread_lane_resources_manager_factory_name_. More...

void set_collocation_resolver (const char *collocation_resolver_name)
 Sets the value of TAO_ORB_Core::collocation_resolver_name_. More...

void set_stub_factory (const char *stub_factory_name)
 Sets the value of TAO_ORB_Core::stub_factory_name_. More...

void set_resource_factory (const char *resource_factory_name)
 Sets the value of TAO_ORB_Core::resource_factory_. More...

void set_protocols_hooks (const char *protocols_hooks_name)
 Sets the value of TAO_ORB_Core::protocols_hooks_. More...

void set_endpoint_selector_factory (const char *endpoint_selector_factory_name)
 Sets the value of TAO_ORB_Core::endpoint_selector_factory_. More...

void set_poa_factory (const char *poa_factory_name, const char *poa_factory_directive)
 Sets the name of the POA factory and the dynamic service configurator directive to load it if needed. More...

const ACE_CStringpoa_factory_name (void)
 Access the POA factory name. More...

void dynamic_adapter_name (const char *name)
 Sets the value of TAO_ORB_Core::dynamic_adapter_name_. More...

const char * dynamic_adapter_name (void)
 Gets the value of TAO_ORB_Core::dynamic_adapter_name_. More...

void ifr_client_adapter_name (const char *name)
 Sets the value of TAO_ORB_Core::ifr_client_adapter_name_. More...

const char * ifr_client_adapter_name (void)
 Gets the value of TAO_ORB_Core::ifr_client_adapter_name_. More...

void typecodefactory_adapter_name (const char *name)
 Sets the value of TAO_ORB_Core::typecodefactory_adapter_name_. More...

const char * typecodefactory_adapter_name (void)
 Gets the value of TAO_ORB_Core::typecodefactory_adapter_name_. More...

void set_timeout_hook (Timeout_Hook hook)
void connection_timeout_hook (Timeout_Hook hook)
 Define the Timeout_Hook signature. More...

void set_sync_scope_hook (Sync_Scope_Hook hook)

Public Attributes

TAO_Protocols_Hooksprotocols_hooks_
 Handle to the factory for protocols_hooks_.. More...


Protected Methods

 ~TAO_ORB_Core (void)
 Destructor is protected since the ORB Core is a reference counted object. More...

int init (int &argc, char **argv ACE_ENV_ARG_DECL)
 Initialize the guts of the ORB Core. It is intended that this be called by <CORBA::ORB_init>. More...

int fini (void)
 Final termination hook, typically called by CORBA::ORB's destructor. More...

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

void resolve_typecodefactory_i (ACE_ENV_SINGLE_ARG_DECL)
 Obtain and cache the dynamic any factory object reference. More...

void resolve_dynanyfactory_i (ACE_ENV_SINGLE_ARG_DECL)
 Obtain and cache the dynamic any factory object reference. More...

void resolve_iormanipulation_i (ACE_ENV_SINGLE_ARG_DECL)
 Obtain and cache the IORManipulation factory object reference. More...

int bidirectional_giop_init (ACE_ENV_SINGLE_ARG_DECL)
 Search the Dynamic service list for BiDirectional options that can be dynamically loaded. More...

void services_callbacks_init (void)
 Search the Dynamic service list for well known services that has callbacks which can be dynamically loaded. More...

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

int set_endpoint_helper (const char *current_arg ACE_ENV_ARG_DECL)
 Pointer to the list of protocol loaded into this ORB instance. Helper method to hold the common code part for -ORBEndpoint and -ORBListenEndpoint options. More...

 ACE_TSS_TYPE (TAO_ORB_Core_TSS_Resources) tss_resources_
 This is where the tss resources for this ORB are stored. More...


Protected Attributes

TAO_SYNCH_MUTEX lock_
 Synchronize internal state... More...

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

int use_implrepo_
 Flag for whether the implrepo support is enabled or not. More...

CORBA::Object_ptr typecode_factory_
 The cached IOR for the TypeCodeFactory DLL. More...

CORBA::Object_ptr dynany_factory_
 The cached object reference for the DynAnyFactory. More...

CORBA::Object_ptr ior_manip_factory_
 The cached object reference for the IORManipulataion. More...

CORBA::Object_ptr ior_table_
 The cached object reference for the IORTable. More...

CORBA::Object_var rt_orb_
 The cached object reference for the RTCORBA::RTORB. More...

CORBA::Object_var rt_current_
 The cached object reference for the RTCORBA::Current interface. More...

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

TAO_POA_PortableGroup_Hooks * portable_group_poa_hooks_
TAO_ORB_Parameters orb_params_
 Parameters used by the ORB. More...

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

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

char * orbid_
 The ORBid for this ORB. More...

TAO_Resource_Factoryresource_factory_
 Handle to the factory for resource information.. More...

ACE_CString server_id_
 The server_id_ that was passed via -ORBServerId option. More...

TAO_Client_Strategy_Factoryclient_factory_
 Handle to the factory for Client-side strategies. More...

TAO_Server_Strategy_Factoryserver_factory_
 Handle to the factory for Server-side strategies. More...

CORBA::Boolean opt_for_collocation_
 TRUE if we want to take advantage of collocation optimization in this ORB. More...

CORBA::Boolean use_global_collocation_
 TRUE if we want to consider all ORBs in this address space collocated. More...

CORBA::ULong collocation_strategy_
 Default collocation policy. This should never be ORB_CONTROL. More...

TAO_Policy_Managerpolicy_manager_
 The Policy_Manager for this ORB. More...

TAO_Policy_Setdefault_policies_
 The default policies. More...

TAO_Policy_Currentpolicy_current_
 Policy current. More...

TAO_Request_Dispatcherrequest_dispatcher_
 The request dispatching strategy. More...

CORBA::Object_var poa_current_
TAO_Adapter_Registry adapter_registry_
 The list of Adapters used in this ORB. More...

TAO_Adapterpoa_adapter_
 An optimization for the POA. More...

ACE_Thread_Manager tm_
 The Thread Manager. More...

ACE_Lock_Adapter< TAO_SYNCH_MUTEX > data_block_lock_
 The data block reference counts are locked using this mutex. More...

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

TAO_ORB_Core_TSS_Resources orb_resources_
 If the resources are per-ORB (as opposed to per-ORB-per-thread) then they are stored here... More...

int has_shutdown_
 Flag which denotes that the ORB has been shutdown. More...

TAO_SYNCH_MUTEX open_lock_
 Mutual exclusion for calling open. More...

int open_called_
 Flag which denotes that the open method was called. More...

TAO_Endpoint_Selector_Factoryendpoint_selector_factory_
TAO_Eager_Buffering_Sync_Strategyeager_buffering_sync_strategy_
 This strategy will buffer messages. More...

TAO_Delayed_Buffering_Sync_Strategydelayed_buffering_sync_strategy_
 This strategy will buffer messages. More...

TAO_Transport_Sync_Strategytransport_sync_strategy_
 This strategy will sync with the transport. More...

CORBA::ULong refcount_
 Number of outstanding references to this object. More...

TAO_PolicyFactory_Registry policy_factory_registry_
 Registry containing all registered policy factories. More...

TAO_PICurrentpi_current_
 Cached pointer/reference to the PICurrent object. More...

TAO_ClientRequestInterceptor_List client_request_interceptors_
 Client request interceptor registry. More...

TAO_ServerRequestInterceptor_List server_request_interceptors_
 Server request interceptor registry. More...

TAO_IORInterceptor_List ior_interceptors_
 IOR interceptor registry. More...

TAO_Parser_Registry parser_registry_
 The IOR parser registry. More...

TAO_BiDir_Adapterbidir_adapter_
 BiDirectional GIOP factory. More...

CORBA::Boolean bidir_giop_policy_
 Bir Dir GIOP policy value. More...

TAO_Flushing_Strategyflushing_strategy_
 Hold the flushing strategy. More...

TAO_Codeset_Managercodeset_manager_
 Code Set Manager. More...

Service Level Hooks
TAO_Fault_Tolerance_Service ft_service_
 Fault Tolerant service hook. More...

int thread_per_connection_use_timeout_
ACE_Time_Value thread_per_connection_timeout_

Private Methods

void resolve_ior_table_i (ACE_ENV_SINGLE_ARG_DECL)
 Obtain and cache the dynamic any factory object reference. More...

CORBA::Object_ptr create_collocated_object (TAO_Stub *the_stub, TAO_ORB_Core *other_orb, const TAO_MProfile &mprofile)
 Try to create a new collocated object, using <other_orb> as the target ORB. If not possible return 0. More...

 TAO_ORB_Core (const TAO_ORB_Core &)
void operator= (const TAO_ORB_Core &)

Friends

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

Detailed Description

Encapsulates the state of an ORB.

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

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

Definition at line 192 of file ORB_Core.h.


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
 

Definition at line 927 of file ORB_Core.h.

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

Definition at line 608 of file ORB_Core.h.

Referenced by call_sync_scope_hook.

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

Define the Timeout_Hook signature.

Definition at line 566 of file ORB_Core.h.

Referenced by call_timeout_hook, and connection_timeout.


Member Enumeration Documentation

anonymous enum
 

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

Definition at line 255 of file ORB_Core.h.

00256   {
00257     /// Indicate object should refer to ORB for either one of the
00258     /// following strategies.
00259     ORB_CONTROL,
00260 
00261     /// Collocated calls will go thru POA.
00262     THRU_POA,
00263 
00264     /// Collocated calls invoke operation on Servant directly.
00265     DIRECT
00266   };


Constructor & Destructor Documentation

TAO_ORB_Core::TAO_ORB_Core const char *    id
 

Constructor.

Definition at line 125 of file ORB_Core.cpp.

References ACE_NEW, CORBA::Object, TAO_DEFAULT_OBJECT_REF_TABLE_SIZE, TAO_HAS_BUFFERING_CONSTRAINT_POLICY, TAO_HAS_CORBA_MESSAGING, and TAO_POLICY_ORB_SCOPE.

00126   : protocols_hooks_ (0),
00127     lock_ (),
00128     thread_lane_resources_manager_ (0),
00129     collocation_resolver_ (0),
00130     stub_factory_ (0),
00131     protocol_factories_ (0),
00132     implrepo_service_ (CORBA::Object::_nil ()),
00133     use_implrepo_ (0),
00134     typecode_factory_ (CORBA::Object::_nil ()),
00135     dynany_factory_ (CORBA::Object::_nil ()),
00136     ior_manip_factory_ (CORBA::Object::_nil ()),
00137     ior_table_ (CORBA::Object::_nil ()),
00138     orb_ (),
00139     root_poa_ (),
00140     portable_group_poa_hooks_ (0),
00141     orb_params_ (),
00142     init_ref_map_ (TAO_DEFAULT_OBJECT_REF_TABLE_SIZE),
00143     object_ref_table_ (),
00144     orbid_ (ACE_OS::strdup (orbid ? orbid : "")),
00145     resource_factory_ (0),
00146 #if 0
00147     /// @@todo:Need to go one day
00148     message_block_dblock_allocator_ (0),
00149     message_block_buffer_allocator_ (0),
00150     message_block_msgblock_allocator_ (0),
00151 #endif /*if 0*/
00152 //    server_id_ (0),
00153     client_factory_ (0),
00154     server_factory_ (0),
00155     opt_for_collocation_ (1),
00156     use_global_collocation_ (1),
00157     collocation_strategy_ (THRU_POA),
00158 
00159 #if (TAO_HAS_CORBA_MESSAGING == 1)
00160 
00161     policy_manager_ (0),
00162     default_policies_ (0),
00163     policy_current_ (0),
00164 
00165 #endif /* TAO_HAS_CORBA_MESSAGING == 1 */
00166 
00167     poa_current_ (),
00168     adapter_registry_ (this),
00169     poa_adapter_ (0),
00170     tm_ (),
00171     tss_cleanup_funcs_ (),
00172     tss_resources_ (),
00173     orb_resources_ (),
00174     has_shutdown_ (1),  // Start the ORB in a  "shutdown" state.  Only
00175                         // after CORBA::ORB_init() is called will the
00176                         // ORB no longer be shutdown.  This does not
00177                         // mean that the ORB can be reinitialized.  It
00178                         // can only be initialized once.
00179     thread_per_connection_use_timeout_ (1),
00180     endpoint_selector_factory_ (0),
00181 #if (TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1)
00182     eager_buffering_sync_strategy_ (0),
00183     delayed_buffering_sync_strategy_ (0),
00184 #endif /* TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1 */
00185     transport_sync_strategy_ (0),
00186     refcount_ (1),
00187     policy_factory_registry_ (),
00188 #if (TAO_HAS_INTERCEPTORS == 1)
00189     pi_current_ (0),
00190     client_request_interceptors_ (),
00191     server_request_interceptors_ (),
00192 #endif  /* TAO_HAS_INTERCEPTORS == 1 */
00193     ior_interceptors_ (),
00194     parser_registry_ (),
00195     bidir_adapter_ (0),
00196     bidir_giop_policy_ (0),
00197     flushing_strategy_ (0),
00198     codeset_manager_ (0)
00199 {
00200 #if (TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1)
00201 
00202   ACE_NEW (this->eager_buffering_sync_strategy_,
00203            TAO_Eager_Buffering_Sync_Strategy);
00204 
00205   ACE_NEW (this->delayed_buffering_sync_strategy_,
00206            TAO_Delayed_Buffering_Sync_Strategy);
00207 
00208 #endif /* TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1 */
00209 
00210 #if (TAO_HAS_CORBA_MESSAGING == 1)
00211 
00212   ACE_NEW (this->policy_manager_,
00213            TAO_Policy_Manager);
00214 
00215   ACE_NEW (this->default_policies_,
00216            TAO_Policy_Set (TAO_POLICY_ORB_SCOPE));
00217 
00218   ACE_NEW (this->policy_current_,
00219            TAO_Policy_Current);
00220 
00221 #endif /* TAO_HAS_CORBA_MESSAGING == 1 */
00222 
00223   ACE_NEW (this->transport_sync_strategy_,
00224            TAO_Transport_Sync_Strategy);
00225 
00226   // Initialize the default request dispatcher.
00227   ACE_NEW (this->request_dispatcher_,
00228            TAO_Request_Dispatcher);
00229 }

TAO_ORB_Core::~TAO_ORB_Core void    [protected]
 

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

Definition at line 231 of file ORB_Core.cpp.

References default_policies_, delayed_buffering_sync_strategy_, eager_buffering_sync_strategy_, flushing_strategy_, ACE_OS_Memory::free, CORBA::release, request_dispatcher_, thread_lane_resources_manager_, and transport_sync_strategy_.

00232 {
00233   delete this->thread_lane_resources_manager_;
00234 
00235   delete this->flushing_strategy_;
00236 
00237   ACE_OS::free (this->orbid_);
00238 
00239 #if (TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1)
00240 
00241   delete this->eager_buffering_sync_strategy_;
00242   delete this->delayed_buffering_sync_strategy_;
00243 
00244 #endif /* TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1 */
00245 
00246 #if (TAO_HAS_CORBA_MESSAGING == 1)
00247 
00248   CORBA::release (this->policy_manager_);
00249   delete this->default_policies_;
00250   CORBA::release (this->policy_current_);
00251 
00252 #endif /* TAO_HAS_CORBA_MESSAGING == 1 */
00253 
00254   delete this->transport_sync_strategy_;
00255 
00256   delete this->request_dispatcher_;
00257 }

TAO_ORB_Core::TAO_ORB_Core const TAO_ORB_Core &    [private]
 


Member Function Documentation

ACE_INLINE CORBA::ULong TAO_ORB_Core::_decr_refcnt void   
 

Definition at line 12 of file ORB_Core.i.

References ACE_GUARD_RETURN, fini, refcount_, and TAO_SYNCH_MUTEX.

Referenced by TAO_ORB_Core_Auto_Ptr::reset, TAO_ORB_Table::unbind, and TAO_ORB_Core_Auto_Ptr::~TAO_ORB_Core_Auto_Ptr.

00013 {
00014   {
00015     ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, mon, this->lock_, 0);
00016     this->refcount_--;
00017     if (this->refcount_ != 0)
00018       return this->refcount_;
00019   }
00020 
00021   this->fini ();
00022   return 0;
00023 }

ACE_INLINE CORBA::ULong TAO_ORB_Core::_incr_refcnt void   
 

Reference counting...

Definition at line 5 of file ORB_Core.i.

References ACE_GUARD_RETURN, refcount_, and TAO_SYNCH_MUTEX.

Referenced by TAO_ORB_Table::bind.

00006 {
00007   ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, guard, this->lock_, 0);
00008   return this->refcount_++;
00009 }

TAO_ORB_Core::ACE_TSS_TYPE TAO_ORB_Core_TSS_Resources    [protected]
 

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

ACE_INLINE TAO_Adapter_Registry * TAO_ORB_Core::adapter_registry void   
 

Get the adapter registry.

Definition at line 169 of file ORB_Core.i.

References adapter_registry_.

Referenced by create_collocated_object.

00170 {
00171   return &this->adapter_registry_;
00172 }

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

Register an IOR interceptor.

Definition at line 609 of file ORB_Core.i.

References ACE_ENV_ARG_DECL, ACE_ENV_ARG_PARAMETER, TAO_IORInterceptor_List::add_interceptor, and ior_interceptors_.

00612 {
00613   this->ior_interceptors_.add_interceptor (interceptor
00614                                             ACE_ENV_ARG_PARAMETER);
00615 }

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.

Definition at line 316 of file ORB_Core.i.

References ACE_CLEANUP_FUNC, TAO_Cleanup_Func_Registry::register_cleanup_function, and tss_cleanup_funcs_.

00318 {
00319   return this->tss_cleanup_funcs_.register_cleanup_function (cleanup,
00320                                                              slot_id);
00321 }

ACE_INLINE void TAO_ORB_Core::bidir_giop_policy CORBA::Boolean   
 

Definition at line 41 of file ORB_Core.i.

References bidir_giop_policy_.

00042 {
00043   this->bidir_giop_policy_ = val;
00044 }

ACE_INLINE CORBA::Boolean TAO_ORB_Core::bidir_giop_policy void   
 

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

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

Definition at line 35 of file ORB_Core.i.

References bidir_giop_policy_.

Referenced by TAO_IIOP_Transport::generate_request_header, and TAO_GIOP_Message_Generator_Parser_12::parse_request_header.

00036 {
00037   return this->bidir_giop_policy_;
00038 }

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.

Definition at line 1349 of file ORB_Core.cpp.

References ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_DECL, TAO_BiDir_Adapter::activate, bidir_adapter_, and ACE_Dynamic_Service::instance.

01350 {
01351   if (this->bidir_adapter_ == 0)
01352     {
01353       this->bidir_adapter_ =
01354         ACE_Dynamic_Service<TAO_BiDir_Adapter>::instance ("BiDirGIOP_Loader");
01355     }
01356 
01357   if (this->bidir_adapter_)
01358     return this->bidir_adapter_->activate (this->orb_.in (),
01359                                            0,
01360                                            0
01361                                            ACE_ENV_ARG_PARAMETER);
01362   else
01363     return 0;
01364 }

void TAO_ORB_Core::call_sync_scope_hook TAO_Stub   stub,
int &    has_synchronization,
Messaging::SyncScope   scope
 

Definition at line 2487 of file ORB_Core.cpp.

References TAO_ORB_Core_Static_Resources::instance, Sync_Scope_Hook, and TAO_ORB_Core_Static_Resources::sync_scope_hook_.

Referenced by TAO_GIOP_Oneway_Invocation::TAO_GIOP_Oneway_Invocation.

02490 {
02491   Sync_Scope_Hook sync_scope_hook =
02492     TAO_ORB_Core_Static_Resources::instance ()->sync_scope_hook_;
02493 
02494   if (sync_scope_hook == 0)
02495     {
02496       has_synchronization = 0;
02497       return;
02498     }
02499 
02500   (*sync_scope_hook) (this, stub, has_synchronization, scope);
02501 }

void TAO_ORB_Core::call_timeout_hook TAO_Stub   stub,
int &    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 2567 of file ORB_Core.cpp.

References TAO_ORB_Core_Static_Resources::instance, Timeout_Hook, and TAO_ORB_Core_Static_Resources::timeout_hook_.

02570 {
02571   Timeout_Hook timeout_hook =
02572     TAO_ORB_Core_Static_Resources::instance ()->timeout_hook_;
02573 
02574   if (timeout_hook == 0)
02575     {
02576       has_timeout = 0;
02577       return;
02578     }
02579   (*timeout_hook) (this, stub, has_timeout, time_value);
02580 }

ACE_INLINE void TAO_ORB_Core::check_shutdown ACE_ENV_SINGLE_ARG_DECL   
 

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

Definition at line 336 of file ORB_Core.i.

References ACE_ENV_SINGLE_ARG_DECL, ACE_THROW, and has_shutdown.

Referenced by CORBA_ORB::check_shutdown.

00337 {
00338   if (this->has_shutdown ())
00339     {
00340       // As defined by the CORBA 2.3 specification, throw a
00341       // CORBA::BAD_INV_ORDER exception with minor code 4 if the ORB
00342       // has shutdown by the time an ORB function is called.
00343 
00344       ACE_THROW (CORBA::BAD_INV_ORDER (CORBA::OMGVMCID | 4,
00345                                        CORBA::COMPLETED_NO));
00346     }
00347 }

TAO_Client_Strategy_Factory * TAO_ORB_Core::client_factory void   
 

Returns pointer to the client factory.

Definition at line 1451 of file ORB_Core.cpp.

References client_factory_, and ACE_Dynamic_Service::instance.

Referenced by TAO_Connector::create_connect_strategy, TAO_Fault_Tolerance_Service::init, and TAO_Transport::TAO_Transport.

01452 {
01453   if (this->client_factory_ == 0)
01454     {
01455       // Look in the service repository for an instance.
01456       this->client_factory_ =
01457         ACE_Dynamic_Service<TAO_Client_Strategy_Factory>::instance ("Client_Strategy_Factory");
01458     }
01459 
01460   return this->client_factory_;
01461 }

TAO_ClientRequestInterceptor_List::TYPE& TAO_ORB_Core::client_request_interceptors void   
 

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

Referenced by CORBA::_TAO_Policy_Remote_Proxy_Impl::copy, CORBA::_TAO_Policy_Remote_Proxy_Impl::destroy, CORBA::_TAO_DomainManager_Remote_Proxy_Impl::get_domain_policy, CORBA::_TAO_ConstructionPolicy_Remote_Proxy_Impl::make_domain_manager, and CORBA::_TAO_Policy_Remote_Proxy_Impl::policy_type.

ACE_INLINE TAO_Codeset_Manager * TAO_ORB_Core::codeset_manager void   
 

Get Code Set Manager.

Definition at line 239 of file ORB_Core.i.

References codeset_manager_.

Referenced by TAO_IIOP_Acceptor::create_new_profile, TAO_IIOP_Acceptor::create_shared_profile, TAO_Transport::generate_request_header, and TAO_GIOP_Invocation::perform_call.

00240 {
00241   return this->codeset_manager_;
00242 }

TAO_Collocation_Resolver & TAO_ORB_Core::collocation_resolver void   
 

Returns a pointer to the Collocation Resolver.

Definition at line 1254 of file ORB_Core.cpp.

References collocation_resolver_, TAO_ORB_Core_Static_Resources::collocation_resolver_name_, and TAO_ORB_Core_Static_Resources::instance.

Referenced by collocation_strategy.

01255 {
01256   // Check if there is a cached reference.
01257   if (this->collocation_resolver_ != 0)
01258     return *this->collocation_resolver_;
01259 
01260   // If not, lookup it up.
01261   this->collocation_resolver_ =
01262     ACE_Dynamic_Service<TAO_Collocation_Resolver>::instance
01263     (TAO_ORB_Core_Static_Resources::instance ()->collocation_resolver_name_.c_str());
01264 
01265   return *this->collocation_resolver_;
01266 }

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

Definition at line 2828 of file ORB_Core.cpp.

References ACE_CHECK_RETURN, ACE_ENV_ARG_DECL, ACE_ENV_ARG_PARAMETER, collocation_resolver, TAO_Collocation_Strategies::CS_DIRECT_STRATEGY, TAO_Collocation_Strategies::CS_REMOTE_STRATEGY, TAO_Collocation_Strategies::CS_THRU_POA_STRATEGY, DIRECT, TAO_Collocation_Resolver::is_collocated, CORBA::is_nil, TAO_Stub::servant_orb_var, and THRU_POA.

02830 {
02831 
02832   TAO_Stub *stub = object->_stubobj ();
02833   if (!CORBA::is_nil (stub->servant_orb_var ().in ()) &&
02834       stub->servant_orb_var ()->orb_core () != 0)
02835     {
02836       TAO_ORB_Core *orb_core =
02837         stub->servant_orb_var ()->orb_core ();
02838 
02839       int collocated =
02840         orb_core->collocation_resolver ().is_collocated (object
02841                                                          ACE_ENV_ARG_PARAMETER);
02842       ACE_CHECK_RETURN (-1);
02843 
02844       if (collocated)
02845         {
02846           switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
02847             {
02848             case THRU_POA:
02849               return TAO_Collocation_Strategies::CS_THRU_POA_STRATEGY;
02850 
02851             case DIRECT:
02852               {
02853                 /////////////////////////////////////////////////////////////
02854                 // If the servant is null and you are collocated this means
02855                 // that the POA policy NON-RETAIN is set, and with that policy
02856                 // using the DIRECT collocation strategy is just insane.
02857                 /////////////////////////////////////////////////////////////
02858                 ACE_ASSERT (object->_servant () != 0);
02859                 return TAO_Collocation_Strategies::CS_DIRECT_STRATEGY;
02860               }
02861             }
02862         }
02863     }
02864 
02865   // In this case the Object is a client.
02866   return TAO_Collocation_Strategies::CS_REMOTE_STRATEGY;
02867 }

void TAO_ORB_Core::connection_timeout TAO_Stub   stub,
int &    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 2629 of file ORB_Core.cpp.

References connection_timeout_hook, TAO_ORB_Core_Static_Resources::connection_timeout_hook_, TAO_ORB_Core_Static_Resources::instance, and Timeout_Hook.

Referenced by TAO_GIOP_Invocation::perform_call.

02632 {
02633   Timeout_Hook connection_timeout_hook =
02634     TAO_ORB_Core_Static_Resources::instance ()->connection_timeout_hook_;
02635 
02636   if (connection_timeout_hook == 0)
02637     {
02638       has_timeout = 0;
02639       return;
02640     }
02641   (*connection_timeout_hook) (this, stub, has_timeout, time_value);
02642 }

void TAO_ORB_Core::connection_timeout_hook Timeout_Hook    hook [static]
 

Define the Timeout_Hook signature.

Definition at line 2645 of file ORB_Core.cpp.

References TAO_ORB_Core_Static_Resources::connection_timeout_hook_, and TAO_ORB_Core_Static_Resources::instance.

Referenced by connection_timeout.

02646 {
02647   // Saving the hook pointer so that we can use it later when needed.
02648   TAO_ORB_Core_Static_Resources::instance ()->connection_timeout_hook_ = hook;
02649 }

TAO_Connector_Registry * TAO_ORB_Core::connector_registry ACE_ENV_SINGLE_ARG_DECL   
 

Get the connector registry.

Definition at line 2441 of file ORB_Core.cpp.

References ACE_CHECK_RETURN, ACE_ENV_SINGLE_ARG_DECL, ACE_ENV_SINGLE_ARG_PARAMETER, TAO_Thread_Lane_Resources::connector_registry, and lane_resources.

Referenced by operator>>, TAO_GIOP_Invocation::perform_call, and resolve_rir.

02442 {
02443   TAO_Connector_Registry *conn =
02444     this->lane_resources ().connector_registry (ACE_ENV_SINGLE_ARG_PARAMETER);
02445   ACE_CHECK_RETURN (0);
02446 
02447   return conn;
02448 }

CORBA::Object_ptr TAO_ORB_Core::create_collocated_object TAO_Stub   the_stub,
TAO_ORB_Core *    other_orb,
const TAO_MProfile   mprofile
[private]
 

Try to create a new collocated object, using <other_orb> as the target ORB. If not possible return 0.

Definition at line 1658 of file ORB_Core.cpp.

References adapter_registry, TAO_Adapter_Registry::create_collocated_object, is_collocated, optimize_collocation_objects, and use_global_collocation.

Referenced by create_object.

01661 {
01662   if (!orb_core->optimize_collocation_objects ())
01663     return 0;
01664 
01665   if (!orb_core->use_global_collocation () && orb_core != this)
01666     return 0;
01667 
01668   if (!orb_core->is_collocated (mprofile))
01669     return 0;
01670 
01671   // OK, the target ORB and the mprofile match, use the Adapter
01672   // Registry of each ORB to find the right one.
01673 
01674   return orb_core->adapter_registry ()->create_collocated_object (stub,
01675                                                                   mprofile);
01676 }

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

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

Referenced by create_input_cdr_data_block.

02421 {
02422   ACE_Data_Block *nb = 0;
02423 
02424   ACE_NEW_MALLOC_RETURN (
02425                          nb,
02426                          ACE_static_cast(ACE_Data_Block*,
02427                                          dblock_allocator->malloc (sizeof (ACE_Data_Block))),
02428                          ACE_Data_Block (size,
02429                                          ACE_Message_Block::MB_DATA,
02430                                          0,
02431                                          buffer_allocator,
02432                                          lock_strategy,
02433                                          0,
02434                                          dblock_allocator),
02435                          0);
02436 
02437   return nb;
02438 }

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

References create_data_block_i, data_block_lock_, input_cdr_buffer_allocator, input_cdr_dblock_allocator, resource_factory, and TAO_Resource_Factory::use_locked_data_blocks.

02322 {
02323 
02324   ACE_Allocator *dblock_allocator;
02325   ACE_Allocator *buffer_allocator;
02326 
02327   dblock_allocator =
02328     this->input_cdr_dblock_allocator ();
02329   buffer_allocator =
02330     this->input_cdr_buffer_allocator ();
02331 
02332   ACE_Lock* lock_strategy = 0;
02333   if (this->resource_factory ()->use_locked_data_blocks ())
02334     {
02335       lock_strategy = &this->data_block_lock_;
02336     }
02337 
02338   return this->create_data_block_i (size,
02339                                     buffer_allocator,
02340                                     dblock_allocator,
02341                                     lock_strategy);
02342 }

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

References ACE_GUARD_RETURN, ACE_MT, ACE_NEW_RETURN, TAO_Stub::base_profiles, TAO_ORB_Table::begin, create_collocated_object, TAO_ORB_Table::end, TAO_ORB_Table::instance, ACE_Static_Object_Lock::instance, TAO_ORB_Table::Iterator, and TAO_SYNCH_RECURSIVE_MUTEX.

Referenced by CORBA_AbstractBase::_to_object, and operator>>.

01616 {
01617   // @@ What about forwarding.  With this approach we are never forwarded
01618   //    when we use collocation!
01619   const TAO_MProfile &mprofile = stub->base_profiles ();
01620 
01621   {
01622     // @@ Ossama: maybe we need another lock for the table, to
01623     //    reduce contention on the Static_Object_Lock below, if so
01624     //    then we need to use that lock in the ORB_init() function.
01625     ACE_MT (ACE_GUARD_RETURN (TAO_SYNCH_RECURSIVE_MUTEX, guard,
01626                               *ACE_Static_Object_Lock::instance (),
01627                               0));
01628 
01629     TAO_ORB_Table *table = TAO_ORB_Table::instance ();
01630     TAO_ORB_Table::Iterator end = table->end ();
01631     for (TAO_ORB_Table::Iterator i = table->begin ();
01632          i != end;
01633          ++i)
01634       {
01635         TAO_ORB_Core *other_core = (*i).int_id_;
01636         CORBA::Object_ptr x =
01637           this->create_collocated_object (stub,
01638                                           other_core,
01639                                           mprofile);
01640         if (x != 0)
01641           return x;
01642       }
01643   }
01644 
01645   // @@ We should thow CORBA::NO_MEMORY in platforms with exceptions,
01646   // but we are stuck in platforms without exceptions!
01647   CORBA::Object_ptr x;
01648 
01649   // The constructor sets the proxy broker as the
01650   // Remote one.
01651   ACE_NEW_RETURN (x,
01652                   CORBA_Object (stub, 0),
01653                   0);
01654   return x;
01655 }

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.

Definition at line 1547 of file ORB_Core.cpp.

References ACE_CHECK_RETURN, ACE_ENV_ARG_DECL, ACE_ENV_ARG_PARAMETER, TAO_Stub_Factory::create_stub, and stub_factory.

Referenced by create_stub_object, and operator>>.

01550 {
01551   TAO_Stub *retval =
01552     this->stub_factory ()->create_stub (repository_id,
01553                                         profiles,
01554                                         this
01555                                         ACE_ENV_ARG_PARAMETER);
01556   ACE_CHECK_RETURN(0);
01557   return retval;
01558 }

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.

Definition at line 1570 of file ORB_Core.cpp.

References ACE_CHECK_RETURN, ACE_ENV_ARG_DECL, ACE_ENV_ARG_PARAMETER, TAO_Stub::base_profiles, create_stub, TAO_MProfile::get_profile, TAO_Profile::policies, TAO_MProfile::policy_list, TAO_MProfile::profile_count, and TAO_ENV_ARG_PARAMETER.

01574 {
01575   // Add the Polices contained in "policy_list" to each profile so
01576   // that those policies will be exposed to the client in the IOR.  In
01577   // particular each CORBA::Policy has to be converted in to
01578   // Messaging::PolicyValue, and then all the Messaging::PolicyValue
01579   // should be embedded inside a Messaging::PolicyValueSeq which
01580   // became in turns the "body" of the IOP::TaggedComponent. This
01581   // conversion is a responsability of the CORBA::Profile class.  (See
01582   // orbos\98-05-05.pdf Section 5.4)
01583   if (policy_list->length () != 0)
01584     {
01585       TAO_Profile * profile;
01586 
01587       for (CORBA::ULong i = 0; i < mprofile.profile_count (); ++i)
01588         {
01589           // Get the ith profile
01590           profile = mprofile.get_profile (i);
01591           profile->policies (policy_list TAO_ENV_ARG_PARAMETER);
01592           ACE_CHECK_RETURN (0);
01593         }
01594     }
01595 
01596   /// Initialize a TAO_Stub object with the mprofile thats passed.
01597   TAO_Stub *stub =
01598     this->create_stub (type_id, mprofile ACE_ENV_ARG_PARAMETER);
01599   ACE_CHECK_RETURN (stub);
01600 
01601   stub->base_profiles ().policy_list (policy_list);
01602 
01603   return stub;
01604 }

CORBA::Policy_ptr TAO_ORB_Core::default_buffering_constraint void    const
 

Definition at line 262 of file ORB_Core.cpp.

References default_policies_, get_cached_policy, and TAO_CACHED_POLICY_BUFFERING_CONSTRAINT.

00263 {
00264   return this->default_policies_->
00265               get_cached_policy (TAO_CACHED_POLICY_BUFFERING_CONSTRAINT);
00266 }

ACE_INLINE void TAO_ORB_Core::default_environment CORBA_Environment  
 

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

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

Definition at line 504 of file ORB_Core.i.

References TAO_TSS_Singleton::instance.

00505 {
00506   TAO_TSS_RESOURCES::instance ()->default_environment_ = env;
00507 }

ACE_INLINE 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 498 of file ORB_Core.i.

References TAO_TSS_Singleton::instance.

Referenced by CORBA_Environment::default_environment, and CORBA_Environment::~CORBA_Environment.

00499 {
00500   return TAO_TSS_RESOURCES::instance ()->default_environment_;
00501 }

TAO_Delayed_Buffering_Sync_Strategy& TAO_ORB_Core::delayed_buffering_sync_strategy void   
 

Referenced by get_sync_strategy.

void TAO_ORB_Core::destroy ACE_ENV_SINGLE_ARG_DECL   
 

Shutdown the ORB and free resources.

Definition at line 1883 of file ORB_Core.cpp.

References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_DECL, ACE_GUARD, ACE_MT, TAO_ORB_Table::instance, ACE_Static_Object_Lock::instance, shutdown, TAO_SYNCH_RECURSIVE_MUTEX, and TAO_ORB_Table::unbind.

Referenced by CORBA_ORB::destroy.

01884 {
01885   //
01886   // All destroy() should do is (a) call shutdown() and (b) unbind()
01887   // from the ORB table.  Nothing else should really be added to this
01888   // method.  Everything else should go to the shutdown() method.
01889   // Remember when the ORB Core is finally removed from the ORB table,
01890   // the reference count goes to zero and fini() is called.  fini()
01891   // calls shutdown() and does not call destroy() since destroy() will
01892   // try to unbind from the ORB table again.  Additional code should
01893   // not be added to destroy() since there is no guarantee that
01894   // orb->destroy() will ever be called by the user.  Since TAO
01895   // guarantees that shutdown() will be called, all cleanup code
01896   // should go there.
01897   //
01898 
01899   // Shutdown the ORB and block until the shutdown is complete.
01900   this->shutdown (1
01901                   ACE_ENV_ARG_PARAMETER);
01902   ACE_CHECK;
01903 
01904   // Now remove it from the ORB table so that it's ORBid may be
01905   // reused.
01906   {
01907     ACE_MT (ACE_GUARD (TAO_SYNCH_RECURSIVE_MUTEX, guard,
01908                        *ACE_Static_Object_Lock::instance ()));
01909     TAO_ORB_Table::instance ()->unbind (this->orbid_);
01910   }
01911 }

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.

Definition at line 1914 of file ORB_Core.cpp.

References ACE_CATCHALL, ACE_DEBUG, ACE_ENDTRY, ACE_ENV_SINGLE_ARG_DECL, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_LIB_TEXT, ACE_TRY, ACE_TRY_CHECK, LM_DEBUG, TAO_IORInterceptor_List::TYPE, TAO_ServerRequestInterceptor_List::TYPE, and TAO_ClientRequestInterceptor_List::TYPE.

01916 {
01917   size_t len = 0;   // The length of the interceptor array.
01918   size_t ilen = 0;  // The incremental length of the interceptor array.
01919 
01920   ACE_TRY
01921     {
01922 #if TAO_HAS_INTERCEPTORS == 1
01923       TAO_ClientRequestInterceptor_List::TYPE &client_interceptors =
01924         this->client_request_interceptors_.interceptors ();
01925 
01926       len = client_interceptors.size ();
01927       ilen = len;
01928       for (size_t i = 0; i < len; ++i)
01929         {
01930           // Destroy the interceptors in reverse order in case the array
01931           // list is only partially destroyed and another invocation
01932           // occurs afterwards.
01933           --ilen;
01934 
01935           client_interceptors[ilen]->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
01936           ACE_TRY_CHECK;
01937 
01938           // Since Interceptor::destroy() can throw an exception, decrease
01939           // the size of the interceptor array incrementally since some
01940           // interceptors may not have been destroyed yet.  Note that this
01941           // size reduction is fast since no memory is actually
01942           // deallocated.
01943           client_interceptors.size (ilen);
01944         }
01945 
01946       TAO_ServerRequestInterceptor_List::TYPE &server_interceptors =
01947         this->server_request_interceptors_.interceptors ();
01948 
01949       len = server_interceptors.size ();
01950       ilen = len;
01951       for (size_t j = 0; j < len; ++j)
01952         {
01953           // Destroy the interceptors in reverse order in case the array
01954           // list is only partially destroyed and another invocation
01955           // occurs afterwards.
01956           --ilen;
01957 
01958           server_interceptors[ilen]->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
01959           ACE_TRY_CHECK;
01960 
01961           // Since Interceptor::destroy() can throw an exception, decrease
01962           // the size of the interceptor array incrementally since some
01963           // interceptors may not have been destroyed yet.  Note that this
01964           // size reduction is fast since no memory is actually
01965           // deallocated.
01966           server_interceptors.size (ilen);
01967         }
01968 
01969 #endif  /* TAO_HAS_INTERCEPTORS == 1 */
01970 
01971       TAO_IORInterceptor_List::TYPE &ior_interceptors =
01972         this->ior_interceptors_.interceptors ();
01973 
01974       len = ior_interceptors.size ();
01975       ilen = len;
01976       for (size_t k = 0; k < len; ++k)
01977         {
01978           // Destroy the interceptors in reverse order in case the array
01979           // list is only partially destroyed and another invocation
01980           // occurs afterwards.
01981           --ilen;
01982 
01983           ior_interceptors[ilen]->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
01984           ACE_TRY_CHECK;
01985 
01986           // Since Interceptor::destroy() can throw an exception, decrease
01987           // the size of the interceptor array incrementally since some
01988           // interceptors may not have been destroyed yet.  Note that this
01989           // size reduction is fast since no memory is actually
01990           // deallocated.
01991           ior_interceptors.size (ilen);
01992         }
01993     }
01994   ACE_CATCHALL
01995     {
01996       // .. catch all the exceptions..
01997       if (TAO_debug_level > 3)
01998         ACE_DEBUG ((LM_DEBUG,
01999                     ACE_LIB_TEXT ("(%P|%t) Exception in TAO_ORB_Core::destroy_interceptors () \n")));
02000     }
02001   ACE_ENDTRY;
02002 
02003   return;
02004 }

const char * TAO_ORB_Core::dynamic_adapter_name void    [static]
 

Gets the value of TAO_ORB_Core::dynamic_adapter_name_.

Definition at line 1191 of file ORB_Core.cpp.

References TAO_ORB_Core_Static_Resources::dynamic_adapter_name_, and TAO_ORB_Core_Static_Resources::instance.

01192 {
01193   return TAO_ORB_Core_Static_Resources::instance ()->dynamic_adapter_name_.c_str();
01194 }

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

Sets the value of TAO_ORB_Core::dynamic_adapter_name_.

Definition at line 1185 of file ORB_Core.cpp.

References TAO_ORB_Core_Static_Resources::dynamic_adapter_name_, and TAO_ORB_Core_Static_Resources::instance.

Referenced by CORBA_Object::_create_request, and CORBA_Object::_request.

TAO_Eager_Buffering_Sync_Strategy& TAO_ORB_Core::eager_buffering_sync_strategy void   
 

Referenced by get_sync_strategy.

TAO_Endpoint_Selector_Factory * TAO_ORB_Core::endpoint_selector_factory void   
 

Returns a pointer to the endpoint selector factory.

Definition at line 1307 of file ORB_Core.cpp.

References endpoint_selector_factory_, TAO_ORB_Core_Static_Resources::endpoint_selector_factory_name_, and TAO_ORB_Core_Static_Resources::instance.

01308 {
01309   // Check if there is a cached reference.
01310   if (this->endpoint_selector_factory_ != 0)
01311     return this->endpoint_selector_factory_;
01312 
01313   // If not, look in the service repository for an instance.
01314   this->endpoint_selector_factory_ =
01315     ACE_Dynamic_Service<TAO_Endpoint_Selector_Factory>::instance
01316     (TAO_ORB_Core_Static_Resources::instance ()->endpoint_selector_factory_name_.c_str());
01317 
01318   return this->endpoint_selector_factory_;
01319 }

ACE_INLINE TAO_Fault_Tolerance_Service & TAO_ORB_Core::fault_tolerance_service void   
 

Return a reference to the Fault Tolerant service object.

Definition at line 150 of file ORB_Core.i.

References ft_service_.

Referenced by CORBA_ORB::_tao_ft_client_id.

00151 {
00152   return this->ft_service_;
00153 }

int TAO_ORB_Core::fini void    [protected]
 

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

Definition at line 1079 of file ORB_Core.cpp.

References ACE_ANY_EXCEPTION, ACE_CATCHANY, ACE_CString, ACE_DEBUG, ACE_ENDTRY, ACE_ENV_ARG_PARAMETER, ACE_LIB_TEXT, ACE_PRINT_EXCEPTION, ACE_TRY_CHECK, ACE_TRY_NEW_ENV, TAO_Internal::close_services, TAO_Thread_Lane_Resources_Manager::finalize, LM_DEBUG, orbid_, CORBA::release, shutdown, thr_mgr, thread_lane_resources_manager_, and ACE_Thread_Manager::wait.

Referenced by _decr_refcnt.

01080 {
01081   ACE_TRY_NEW_ENV
01082     {
01083       // Shutdown the ORB and block until the shutdown is complete.
01084       this->shutdown (1
01085                       ACE_ENV_ARG_PARAMETER);
01086       ACE_TRY_CHECK;
01087     }
01088   ACE_CATCHANY
01089     {
01090       ACE_CString message =
01091         "Exception caught in trying to shutdown ";
01092       message += this->orbid_;
01093       message += "\n";
01094 
01095       ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
01096                            message.c_str ());
01097     }
01098   ACE_ENDTRY;
01099 
01100   // Wait for any server threads, ignoring any failures.
01101   (void) this->thr_mgr ()->wait ();
01102 
01103   CORBA::release (this->implrepo_service_);
01104 
01105   CORBA::release (this->typecode_factory_);
01106 
01107   CORBA::release (this->dynany_factory_);
01108 
01109   CORBA::release (this->ior_manip_factory_);
01110 
01111   CORBA::release (this->ior_table_);
01112 
01113   if (TAO_debug_level >= 3)
01114     {
01115       ACE_DEBUG ((LM_DEBUG,
01116                   ACE_LIB_TEXT ("Destroying ORB <%s>\n"),
01117                   this->orbid_));
01118     }
01119 
01120   // Finalize lane resources.
01121   //
01122   // @@ Do not call this->thread_lane_resources_manager().finalize().
01123   // this->thread_lane_manager_resources() can seg fault if the
01124   // factory method it invokes returns a zero pointer, which can
01125   // easily occur if the ORB is partially initialized due to a Service
01126   // Configurator initialization failure.  Instead check if the
01127   // cached pointer is non-zero and then finalize.
01128   //
01129   // @todo Fix potential seg fault in
01130   //       TAO_ORB_Core::thread_lane_resources_manager().
01131   if (this->thread_lane_resources_manager_ != 0)
01132     this->thread_lane_resources_manager_->finalize ();
01133 
01134   (void) TAO_Internal::close_services ();
01135 
01136 #if 0
01137   // @@todo: Need to go someday!
01138   if (this->message_block_dblock_allocator_)
01139     this->message_block_dblock_allocator_->remove ();
01140   delete this->message_block_dblock_allocator_;
01141 
01142   if (this-> message_block_buffer_allocator_)
01143     this->message_block_buffer_allocator_->remove ();
01144   delete this->message_block_buffer_allocator_;
01145 
01146   if (this->message_block_msgblock_allocator_)
01147     this->message_block_msgblock_allocator_->remove ();
01148   delete this->message_block_msgblock_allocator_;
01149 #endif /*if 0*/
01150 
01151   delete this;
01152 
01153   return 0;
01154 }

ACE_INLINE TAO_Flushing_Strategy * TAO_ORB_Core::flushing_strategy void   
 

Return the flushing strategy.

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

Definition at line 53 of file ORB_Core.i.

References flushing_strategy_.

Referenced by TAO_Transport::drain_queue, TAO_Transport::handle_timeout, TAO_Transport::send_message_shared_i, TAO_Transport::send_reply_message_i, and TAO_Transport::send_synchronous_message_i.

00054 {
00055   return this->flushing_strategy_;
00056 }

ACE_Char_Codeset_Translator* TAO_ORB_Core::from_iso8859 void    const
 

Convert from ISO8859 to the native character set.

ACE_WChar_Codeset_Translator* TAO_ORB_Core::from_unicode void    const
 

Convert from UNICODE to the native wide character set.

CORBA::Policy_ptr TAO_ORB_Core::get_cached_policy TAO_Cached_Policy_Type    type
 

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

Definition at line 2691 of file ORB_Core.cpp.

References CORBA::Policy_var::_retn, TAO_Policy_Set::get_cached_policy, TAO_Policy_Manager::get_cached_policy, get_default_policies, CORBA::Policy_var::in, CORBA::is_nil, policy_manager, and TAO_Cached_Policy_Type.

Referenced by default_buffering_constraint.

02692 {
02693   CORBA::Policy_var result;
02694 
02695   // @@ Must lock, but is is harder to implement than just modifying
02696   //    this call: the ORB does take a lock to modify the policy
02697   //    manager
02698   TAO_Policy_Manager *policy_manager =
02699     this->policy_manager ();
02700   if (policy_manager != 0)
02701     result = policy_manager->get_cached_policy (type);
02702 
02703   if (CORBA::is_nil (result.in ()))
02704     result = this->get_default_policies ()->get_cached_policy (type);
02705 
02706   return result._retn ();
02707 }

ACE_INLINE CORBA::ULong TAO_ORB_Core::get_collocation_strategy void    const
 

Definition at line 205 of file ORB_Core.i.

References collocation_strategy_.

00206 {
00207   return this->collocation_strategy_;
00208 }

TAO_Policy_Set* TAO_ORB_Core::get_default_policies void   
 

Accessor method for the default_policies_.

Referenced by get_cached_policy.

TAO_Protocols_Hooks * TAO_ORB_Core::get_protocols_hooks ACE_ENV_SINGLE_ARG_DECL   
 

Gets the value of TAO_ORB_Core::protocols_hooks__.

Definition at line 1329 of file ORB_Core.cpp.

References ACE_CHECK_RETURN, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_DECL, TAO_Protocols_Hooks::init_hooks, TAO_ORB_Core_Static_Resources::instance, protocols_hooks_, and TAO_ORB_Core_Static_Resources::protocols_hooks_name_.

Referenced by TAO_IIOP_Connector::init_tcp_properties, TAO_IIOP_Acceptor::init_tcp_properties, TAO_IIOP_Transport::send_request, and TAO_IIOP_Connection_Handler::set_dscp_codepoint.

01330 {
01331   // Check if there is a cached reference.
01332   if (this->protocols_hooks_ != 0)
01333     return this->protocols_hooks_;
01334 
01335   // If not, look in the service repository for an instance.
01336   this->protocols_hooks_ =
01337     ACE_Dynamic_Service<TAO_Protocols_Hooks>::instance
01338     (TAO_ORB_Core_Static_Resources::instance ()->protocols_hooks_name_.c_str());
01339 
01340   // Initialize the protocols hooks instance.
01341   this->protocols_hooks_->init_hooks (this
01342                                       ACE_ENV_ARG_PARAMETER);
01343   ACE_CHECK_RETURN (0);
01344 
01345   return this->protocols_hooks_;
01346 }

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

Definition at line 2504 of file ORB_Core.cpp.

References delayed_buffering_sync_strategy, eager_buffering_sync_strategy, and transport_sync_strategy.

02506 {
02507 
02508   if (scope == Messaging::SYNC_WITH_TRANSPORT
02509       || scope == Messaging::SYNC_WITH_SERVER
02510       || scope == Messaging::SYNC_WITH_TARGET)
02511     return this->transport_sync_strategy ();
02512 
02513 #if (TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1)
02514 
02515   if (scope == Messaging::SYNC_NONE
02516       || scope == TAO::SYNC_EAGER_BUFFERING)
02517     return this->eager_buffering_sync_strategy ();
02518 
02519   if (scope == TAO::SYNC_DELAYED_BUFFERING)
02520     return this->delayed_buffering_sync_strategy ();
02521 
02522 #endif /* TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1 */
02523 
02524   return this->transport_sync_strategy ();
02525 }

ACE_INLINE void * TAO_ORB_Core::get_tss_resource size_t    slot_id
 

Obtain the TSS resource in the given slot.

Definition at line 263 of file ORB_Core.i.

References get_tss_resources, ACE_Array_Base< void * >::size, and TAO_ORB_Core_TSS_Resources::ts_objects_.

00264 {
00265   TAO_ORB_Core_TSS_Resources *tss_resources =
00266     this->get_tss_resources ();
00267 
00268   if (slot_id >= tss_resources->ts_objects_.size ())
00269     return 0;
00270 
00271   return tss_resources->ts_objects_[slot_id];
00272 }

ACE_INLINE TAO_ORB_Core_TSS_Resources * TAO_ORB_Core::get_tss_resources void   
 

Obtain the TSS resources of this orb.

Definition at line 257 of file ORB_Core.i.

References ACE_TSS_GET.

Referenced by get_tss_resource, TAO_Leader_Follower::get_tss_resources, output_cdr_buffer_allocator, output_cdr_dblock_allocator, output_cdr_msgblock_allocator, set_tss_resource, and TAO_PICurrent::tsc.

00258 {
00259   return ACE_TSS_GET (&this->tss_resources_,TAO_ORB_Core_TSS_Resources);
00260 }

ACE_INLINE int TAO_ORB_Core::has_shutdown void   
 

Get the shutdown flag value.

Definition at line 330 of file ORB_Core.i.

References has_shutdown_.

Referenced by check_shutdown, TAO_Connection_Handler::close_connection_eh, TAO_Leader_Follower::reset_client_thread, run, TAO_Leader_Follower::set_client_thread, and TAO_Connection_Handler::svc_i.

00331 {
00332   return this->has_shutdown_;
00333 }

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

References TAO_ORB_Core_Static_Resources::ifr_client_adapter_name_, and TAO_ORB_Core_Static_Resources::instance.

01204 {
01205   return TAO_ORB_Core_Static_Resources::instance ()->ifr_client_adapter_name_.c_str();
01206 }

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

References TAO_ORB_Core_Static_Resources::ifr_client_adapter_name_, and TAO_ORB_Core_Static_Resources::instance.

Referenced by TAO_Remote_Object_Proxy_Impl::_get_interface, and CORBA::_TAO_ConstructionPolicy_Remote_Proxy_Impl::make_domain_manager.

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

Definition at line 364 of file ORB_Core.i.

References implrepo_service_.

00365 {
00366   this->implrepo_service_ = ir;
00367 }

CORBA::Object_ptr TAO_ORB_Core::implrepo_service void   
 

Definition at line 2457 of file ORB_Core.cpp.

References ACE_CATCHANY, ACE_ENDTRY, ACE_ENV_ARG_PARAMETER, ACE_GUARD_RETURN, ACE_TRY_CHECK, ACE_TRY_NEW_ENV, implrepo_service_, CORBA::is_nil, orb_, TAO_SYNCH_MUTEX, and use_implrepo_.

02458 {
02459   if (!this->use_implrepo_)
02460     return CORBA::Object::_nil ();
02461 
02462   if (CORBA::is_nil (this->implrepo_service_))
02463     {
02464 
02465       ACE_TRY_NEW_ENV
02466         {
02467           CORBA::Object_var temp = this->orb_->resolve_initial_references ("ImplRepoService" ACE_ENV_ARG_PARAMETER);
02468           ACE_TRY_CHECK;
02469 
02470           ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->lock_, CORBA::Object::_nil ());
02471 
02472           // @@ Worry about assigning a different IOR? (brunsch)
02473           this->implrepo_service_ = temp._retn ();
02474         }
02475       ACE_CATCHANY
02476         {
02477           // Just make sure that we have a null pointer.  Ignore the exception anyway.
02478           this->implrepo_service_ = CORBA::Object::_nil ();
02479         }
02480       ACE_ENDTRY;
02481     }
02482 
02483   return CORBA::Object::_duplicate (this->implrepo_service_);
02484 }

int TAO_ORB_Core::inherit_from_parent_thread TAO_ORB_Core_TSS_Resources   tss_resources
 

A spawned thread needs to inherit some properties/objects from the spawning thread in order to serve requests. Return 0 if it successfully inherits from the parent, -1 otherwise.

Definition at line 1479 of file ORB_Core.cpp.

Referenced by TAO_Connection_Handler::svc_i.

01481 {
01482   // Inherit properties/objects used in ORB_Core from the
01483   // parent thread.  Stuff inherited here must already exist
01484   // in the "parent" orbcore.
01485   // This is used in the thread-per-connection concurrency model where
01486   // each ORB spawned thread must use the resources of the spawning
01487   // thread...
01488 
01489   if (tss_resources == 0)
01490     return -1;
01491   return 0;
01492 }

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.

Definition at line 2870 of file ORB_Core.cpp.

References init_ref_map_.

Referenced by CORBA_ORB::resolve_initial_references.

02871 {
02872   return &this->init_ref_map_;
02873 }

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

References TAO_Thread_Lane_Resources::input_cdr_buffer_allocator, and lane_resources.

Referenced by create_input_cdr_data_block.

02244 {
02245   return this->lane_resources ().input_cdr_buffer_allocator ();
02246 }

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

References TAO_Thread_Lane_Resources::input_cdr_dblock_allocator, and lane_resources.

Referenced by create_input_cdr_data_block, and TAO_Transport::handle_input_i.

02238 {
02239   return this->lane_resources ().input_cdr_dblock_allocator ();
02240 }

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

References TAO_Thread_Lane_Resources::input_cdr_msgblock_allocator, and lane_resources.

02250 {
02251   return this->lane_resources ().input_cdr_msgblock_allocator ();
02252 }

ACE_INLINE TAO_IORInterceptor_List::TYPE & TAO_ORB_Core::ior_interceptors void   
 

Return the array of IOR interceptors specific to this ORB.

Definition at line 618 of file ORB_Core.i.

References TAO_IORInterceptor_List::interceptors, and ior_interceptors_.

00619 {
00620   return this->ior_interceptors_.interceptors ();
00621 }

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

References TAO_Thread_Lane_Resources_Manager::is_collocated, and thread_lane_resources_manager.

Referenced by create_collocated_object.

01680 {
01681   // @@ Lots of issues arise when dealing with collocation.  What about
01682   //    forwarding or what if this is a multi-profile IOR where the order is
01683   //    significant and only one of the profiles is collocated.  For example
01684   //    when using a multiple servers for fault tolerance.  For now, we just
01685   //    look through all profiles and if any are colocated then we assume
01686   //    the object is collocated.
01687   // @@ Note, if collocated we can not be forwarded!
01688   //    Also, acceptor_registry_->is_collocated (...) will check the
01689   //    address (ORB Host) but not the object_key.  This should be checked
01690   //    also.
01691 
01692   return this->thread_lane_resources_manager ().is_collocated (mprofile);
01693 }

TAO_Thread_Lane_Resources & TAO_ORB_Core::lane_resources void   
 

Get access to the thread lane resources.

Definition at line 2007 of file ORB_Core.cpp.

References TAO_Thread_Lane_Resources_Manager::lane_resources, and thread_lane_resources_manager.

Referenced by TAO_IIOP_Connection_Handler::add_transport_to_cache, TAO_Connector::connect, connector_registry, TAO_Tagged_Profile::extract_object_key, input_cdr_buffer_allocator, input_cdr_dblock_allocator, input_cdr_msgblock_allocator, leader_follower, TAO_IIOP_Connector::make_connection, TAO_Creation_Strategy::make_svc_handler, TAO_IIOP_Transport::set_bidir_context_info, TAO_Transport::transport_cache_manager, and transport_message_buffer_allocator.

02008 {
02009   return this->thread_lane_resources_manager ().lane_resources ();
02010 }

TAO_Leader_Follower & TAO_ORB_Core::leader_follower void   
 

Get access to the leader_follower class.

Definition at line 1698 of file ORB_Core.cpp.

References lane_resources, and TAO_Thread_Lane_Resources::leader_follower.

Referenced by TAO_Transport::close_connection_shared, TAO_Leader_Follower_Flushing_Strategy::flush_message, reactor, run, TAO_Wait_On_Leader_Follower::wait, and TAO_LF_Connect_Strategy::wait.

01699 {
01700   return this->lane_resources ().leader_follower ();
01701 }

TAO_LF_Strategy & TAO_ORB_Core::lf_strategy void   
 

Get access to the leader follower strategy.

Definition at line 1704 of file ORB_Core.cpp.

References TAO_Thread_Lane_Resources_Manager::lf_strategy, and thread_lane_resources_manager.

Referenced by run.

01705 {
01706   return this->thread_lane_resources_manager ().lf_strategy ();
01707 }

CORBA::ORB::ObjectIdList_ptr TAO_ORB_Core::list_initial_references ACE_ENV_SINGLE_ARG_DECL_NOT_USED   
 

List all the service known by the ORB.

Definition at line 2178 of file ORB_Core.cpp.

References ACE_CHECK_RETURN, ACE_ENV_SINGLE_ARG_DECL, ACE_NEW_THROW_EX, ACE_Hash_Map_Manager_Ex< ACE_CString, ACE_CString, ACE_Hash< ACE_CString >, ACE_Equal_To< ACE_CString >, ACE_Null_Mutex >::begin, TAO_Object_Ref_Table::begin, TAO_Object_Ref_Table::current_size, ACE_Hash_Map_Manager_Ex< ACE_CString, ACE_CString, ACE_Hash< ACE_CString >, ACE_Equal_To< ACE_CString >, ACE_Null_Mutex >::current_size, ACE_Hash_Map_Manager_Ex< ACE_CString, ACE_CString, ACE_Hash< ACE_CString >, ACE_Equal_To< ACE_CString >, ACE_Null_Mutex >::end, TAO_Object_Ref_Table::end, init_ref_map_, TAO_Object_Ref_Table::Iterator, object_ref_table_, CORBA::string_dup, and TAO_LIST_OF_INITIAL_SERVICES.

Referenced by CORBA_ORB::list_initial_services.

02179 {
02180   // Unsupported initial services should NOT be included in the below list!
02181   const char *initial_services[] = { TAO_LIST_OF_INITIAL_SERVICES };
02182   // Make sure the "terminating" zero is the last array element so
02183   // that there is a stop condition when iterating through the list.
02184 
02185   const size_t initial_services_size =
02186     sizeof (initial_services) / sizeof (initial_services[0]);
02187 
02188   const size_t total_size =
02189     initial_services_size
02190     + this->init_ref_map_.current_size ()
02191     + this->object_ref_table_.current_size ();
02192 
02193   CORBA::ORB::ObjectIdList_ptr tmp = 0;
02194 
02195   ACE_NEW_THROW_EX (tmp,
02196                     CORBA_ORB_ObjectIdList (
02197                       ACE_static_cast(CORBA::ULong, total_size)),
02198                     CORBA::NO_MEMORY ());
02199   ACE_CHECK_RETURN (0);
02200 
02201   CORBA::ORB::ObjectIdList_var list = tmp;
02202   list->length (ACE_static_cast(CORBA::ULong, total_size));
02203 
02204   CORBA::ULong index = 0;
02205   // Index for ObjectIdList members.
02206 
02207   // Iterate over the registered initial references.
02208   for (index = 0; index < initial_services_size; ++index)
02209     list[index] = initial_services[index];
02210 
02211   // Now iterate over the initial references created by the user and
02212   // add them to the sequence.
02213 
02214   // References registered via
02215   // ORBInitInfo::register_initial_reference().
02216   TAO_Object_Ref_Table::Iterator obj_ref_end =
02217     this->object_ref_table_.end ();
02218 
02219   for (TAO_Object_Ref_Table::Iterator i = this->object_ref_table_.begin ();
02220        i != obj_ref_end;
02221        ++i, ++index)
02222     list[index] = CORBA::string_dup ((*i).ext_id_);
02223 
02224   // References registered via INS.
02225   InitRefMap::iterator end = this->init_ref_map_.end ();
02226 
02227   for (InitRefMap::iterator j = this-> init_ref_map_.begin ();
02228        j != end;
02229        ++j, ++index)
02230     list[index] = (*j).ext_id_.c_str ();
02231 
02232   return list._retn ();
02233 }

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

References bidir_adapter_, and TAO_BiDir_Adapter::load_policy_validators.

01608 {
01609   // Call the BiDir library if it has been loaded
01610   if (this->bidir_adapter_)
01611     this->bidir_adapter_->load_policy_validators (validator);
01612 }

ACE_INLINE ACE_Lock * TAO_ORB_Core::locking_strategy void   
 

Return the locking strategy used for the data blocks.

Definition at line 26 of file ORB_Core.i.

References data_block_lock_, resource_factory, and TAO_Resource_Factory::use_locked_data_blocks.

Referenced by TAO_Transport::handle_input_i.

00027 {
00028   if (this->resource_factory ()->use_locked_data_blocks ())
00029     return &this->data_block_lock_;
00030 
00031   return 0;
00032 }

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.

Definition at line 2883 of file ORB_Core.cpp.

References TAO_ORB_Table::instance, and TAO_ORB_Table::not_default.

02884 {
02885   TAO_ORB_Table *table = TAO_ORB_Table::instance ();
02886   table->not_default (orb_id);
02887 }

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

The loaded service would determineif the CORBA::Object_ptr is actually nill 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.i.

References ft_service_, TAO_Service_Callbacks::object_is_nil, and TAO_Fault_Tolerance_Service::service_callback.

00109 {
00110   CORBA::Boolean retval = 0;
00111   if (this->ft_service_.service_callback ())
00112     {
00113       retval =
00114         this->ft_service_.service_callback ()->object_is_nil (obj);
00115     }
00116   return retval;
00117 }

ACE_INLINE TAO_Object_Ref_Table & TAO_ORB_Core::object_ref_table void   
 

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

Definition at line 47 of file ORB_Core.i.

References object_ref_table_.

Referenced by CORBA_ORB::register_initial_reference, CORBA_ORB::resolve_initial_references, resolve_rt_current, and resolve_rt_orb.

00048 {
00049   return this->object_ref_table_;
00050 }

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

ACE_INLINE CORBA::Boolean TAO_ORB_Core::optimize_collocation_objects void    const
 

Definition at line 187 of file ORB_Core.i.

References opt_for_collocation_.

00188 {
00189   return this->opt_for_collocation_;
00190 }

ACE_INLINE void TAO_ORB_Core::optimize_collocation_objects CORBA::Boolean    opt
 

Definition at line 181 of file ORB_Core.i.

References opt_for_collocation_.

Referenced by CORBA_ORB::_optimize_collocation_objects, create_collocated_object, and operator>>.

00182 {
00183   this->opt_for_collocation_ = opt;
00184 }

ACE_INLINE CORBA::ORB_ptr TAO_ORB_Core::orb void   
 

Get pointer to the ORB.

Definition at line 163 of file ORB_Core.i.

References orb_.

Referenced by CORBA_ValueBase::_tao_unmarshal_pre, operator>>, TAO_ServerRequest::orb, TAO_Profile::policies, resolve_rir, and TAO_Profile::verify_orb_configuration.

00164 {
00165   return this->orb_.in ();
00166 }

ACE_INLINE TAO_ORB_Parameters * TAO_ORB_Core::orb_params void   
 

Accessor for the ORB parameters.

Definition at line 211 of file ORB_Core.i.

References orb_params_.

Referenced by TAO_IIOP_Acceptor::create_new_profile, TAO_IIOP_Acceptor::create_shared_profile, TAO_IIOP_Profile::create_tagged_profile, TAO_IIOP_Profile::encode, TAO_Transport::handle_input_i, TAO_IIOP_Acceptor::hostname, TAO_IIOP_Connector::init_tcp_properties, TAO_IIOP_Acceptor::init_tcp_properties, CORBA_ORB::object_to_string, resolve_rir, set_endpoint_helper, TAO_ServerRequest::tao_send_reply_exception, and TAO_Profile::verify_orb_configuration.

00212 {
00213   return &(this->orb_params_);
00214 }

ACE_INLINE const char * TAO_ORB_Core::orbid void    const
 

Return ORBid string.

Definition at line 358 of file ORB_Core.i.

References orbid_.

00359 {
00360   return this->orbid_;
00361 }

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

References ACE_ERROR_RETURN, ACE_LIB_TEXT, get_tss_resources, LM_ERROR, TAO_Resource_Factory::output_cdr_buffer_allocator, TAO_ORB_Core_TSS_Resources::output_cdr_buffer_allocator_, and resource_factory.

02277 {
02278   TAO_ORB_Core_TSS_Resources *tss = this->get_tss_resources ();
02279   if (tss == 0)
02280     ACE_ERROR_RETURN ((LM_ERROR,
02281                        ACE_LIB_TEXT ("(%P|%t) %p\n"),
02282                        ACE_LIB_TEXT ("TAO_ORB_Core::input_cdr_buffer_allocator (); ")
02283                        ACE_LIB_TEXT ("no more TSS keys")),
02284                       0);
02285 
02286   if (tss->output_cdr_buffer_allocator_ == 0)
02287     tss->output_cdr_buffer_allocator_ =
02288       this->resource_factory ()->output_cdr_buffer_allocator ();
02289 
02290   return tss->output_cdr_buffer_allocator_;
02291 }

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

References ACE_ERROR_RETURN, ACE_LIB_TEXT, get_tss_resources, LM_ERROR, TAO_Resource_Factory::output_cdr_dblock_allocator, TAO_ORB_Core_TSS_Resources::output_cdr_dblock_allocator_, and resource_factory.

Referenced by TAO_IIOP_Profile::create_tagged_profile, TAO_IIOP_Profile::encode, CORBA_ORB::object_to_string, and TAO_ServerRequest::tao_send_reply_exception.

02256 {
02257 
02258   // Allocating memory here confuses purify a bit. We do delete this
02259   // memory when TSS delete
02260   TAO_ORB_Core_TSS_Resources *tss = this->get_tss_resources ();
02261   if (tss == 0)
02262     ACE_ERROR_RETURN ((LM_ERROR,
02263                        ACE_LIB_TEXT ("(%P|%t) %p\n"),
02264                        ACE_LIB_TEXT ("TAO_ORB_Core::output_cdr_dblock_allocator (); ")
02265                        ACE_LIB_TEXT ("no more TSS keys")),
02266                       0);
02267 
02268   if (tss->output_cdr_dblock_allocator_ == 0)
02269     tss->output_cdr_dblock_allocator_ =
02270       this->resource_factory ()->output_cdr_dblock_allocator ();
02271 
02272   return tss->output_cdr_dblock_allocator_;
02273 }

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

References ACE_ERROR_RETURN, ACE_LIB_TEXT, get_tss_resources, LM_ERROR, TAO_Resource_Factory::output_cdr_msgblock_allocator, TAO_ORB_Core_TSS_Resources::output_cdr_msgblock_allocator_, and resource_factory.

Referenced by TAO_IIOP_Profile::create_tagged_profile, TAO_IIOP_Profile::encode, CORBA_ORB::object_to_string, and TAO_ServerRequest::tao_send_reply_exception.

02296 {
02297   TAO_ORB_Core_TSS_Resources *tss = this->get_tss_resources ();
02298   if (tss == 0)
02299     ACE_ERROR_RETURN ((LM_ERROR,
02300                        ACE_LIB_TEXT ("(%P|%t) %p\n"),
02301                        ACE_LIB_TEXT ("TAO_ORB_Core::output_cdr_msgblock_allocator (); ")
02302                        ACE_LIB_TEXT ("no more TSS keys")),
02303                       0);
02304 
02305   if (tss->output_cdr_msgblock_allocator_ == 0)
02306     tss->output_cdr_msgblock_allocator_ =
02307       this->resource_factory ()->output_cdr_msgblock_allocator ();
02308 
02309   return tss->output_cdr_msgblock_allocator_;
02310 }

ACE_INLINE TAO_Parser_Registry * TAO_ORB_Core::parser_registry void   
 

Get the IOR parser registry.

Definition at line 226 of file ORB_Core.i.

References parser_registry_.

Referenced by CORBA_ORB::string_to_object.

00227 {
00228   return &this->parser_registry_;
00229 }

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.

Referenced by TAO_ClientRequestInfo_i::setup_picurrent, and TAO_PICurrent_Guard::TAO_PICurrent_Guard.

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

References ACE_GUARD_RETURN, adapter_registry_, TAO_Adapter_Registry::find_adapter, poa_adapter_, and TAO_SYNCH_MUTEX.

Referenced by root_poa.

01533 {
01534   if (this->poa_adapter_ == 0)
01535     {
01536       ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->lock_, 0);
01537       if (this->poa_adapter_ == 0)
01538         {
01539           this->poa_adapter_ =
01540             this->adapter_registry_.find_adapter ("RootPOA");
01541         }
01542     }
01543   return this->poa_adapter_;
01544 }

ACE_INLINE void TAO_ORB_Core::poa_current CORBA::Object_ptr    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.

Definition at line 480 of file ORB_Core.i.

References ACE_GUARD, poa_current_, and TAO_SYNCH_MUTEX.

00481 {
00482   ACE_GUARD (TAO_SYNCH_MUTEX, mon, this->lock_);
00483   this->poa_current_ =
00484     CORBA::Object::_duplicate (current);
00485 }

ACE_INLINE CORBA::Object_ptr TAO_ORB_Core::poa_current void   
 

Todo:
In the future this hook should change, instead of hardcoding the object we should add a "Resolver" to the ORB, so the "POACurrent" object returns a per-ORB object.

Similarly, each ORB should implement the TSS pattern to put the POA_Current_Impl in a void* slot. The current approach *does* decouple the POA from the ORB, but it cannot add new adapters or other components transparently.

Definition at line 474 of file ORB_Core.i.

Referenced by CORBA_ORB::resolve_poa_current.

00475 {
00476   return CORBA::Object::_duplicate (this->poa_current_.in ());
00477 }

const ACE_CString & TAO_ORB_Core::poa_factory_name void    [static]
 

Access the POA factory name.

Definition at line 1294 of file ORB_Core.cpp.

References TAO_ORB_Core_Static_Resources::instance, and TAO_ORB_Core_Static_Resources::poa_factory_name_.

Referenced by TAO_Internal::open_services_i, and set_poa_factory.

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.

Referenced by CORBA_ORB::resolve_policy_current, stubless_connection_timeout, stubless_relative_roundtrip_timeout, and stubless_sync_scope.

ACE_INLINE TAO_PolicyFactory_Registry * TAO_ORB_Core::policy_factory_registry void   
 

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

Definition at line 232 of file ORB_Core.i.

References policy_factory_registry_.

00233 {
00234   return &this->policy_factory_registry_;
00235 }

TAO_Policy_Manager* TAO_ORB_Core::policy_manager void   
 

Return the Policy_Manager for this ORB.

Referenced by get_cached_policy, CORBA_ORB::resolve_policy_manager, stubless_connection_timeout, stubless_relative_roundtrip_timeout, and stubless_sync_scope.

ACE_INLINE void TAO_ORB_Core::portable_group_poa_hooks TAO_POA_PortableGroup_Hooks *    poa_hooks
 

Definition at line 395 of file ORB_Core.i.

References portable_group_poa_hooks_.

00396 {
00397   this->portable_group_poa_hooks_ = poa_hooks;
00398 }

ACE_INLINE TAO_POA_PortableGroup_Hooks * TAO_ORB_Core::portable_group_poa_hooks void    const
 

Set/Get the current PortableGroup POA hooks.

Definition at line 389 of file ORB_Core.i.

References portable_group_poa_hooks_.

00390 {
00391   return this->portable_group_poa_hooks_;
00392 }

ACE_INLINE TAO_ProtocolFactorySet * TAO_ORB_Core::protocol_factories void   
 

Get the protocol factories.

Definition at line 220 of file ORB_Core.i.

References protocol_factories, and TAO_OC_RETRIEVE.

Referenced by TAO_Connector_Registry::open, TAO_Acceptor_Registry::open_default, and protocol_factories.

00221 {
00222   return TAO_OC_RETRIEVE (protocol_factories);
00223 }

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

References leader_follower, and TAO_Leader_Follower::reactor.

Referenced by TAO_Connection_Handler::close_connection_eh, TAO_Transport::notify_reactor, TAO_IIOP_Transport::register_handler_i, TAO_Leader_Follower::reset_client_thread, TAO_Resume_Handle::resume_handle, run, TAO_Leader_Follower::set_client_thread, TAO_Wait_On_Reactor::wait, and CORBA_ORB::work_pending.

02452 {
02453   return this->leader_follower ().reactor ();
02454 }

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.

Definition at line 1561 of file ORB_Core.cpp.

References request_dispatcher_.

01562 {
01563   // Assume ownership of the request dispatcher.
01564   TAO_Request_Dispatcher *tmp = this->request_dispatcher_;
01565   this->request_dispatcher_ = request_dispatcher;
01566   delete tmp;
01567 }

ACE_INLINE TAO_Request_Dispatcher * TAO_ORB_Core::request_dispatcher void   
 

Return the current request dispatcher strategy.

Definition at line 175 of file ORB_Core.i.

References request_dispatcher_.

00176 {
00177   return this->request_dispatcher_;
00178 }

ACE_INLINE void TAO_ORB_Core::reset_service_profile_flags void   
 

Reset the flags in the loaded services.

Definition at line 93 of file ORB_Core.i.

References ft_service_, TAO_Service_Callbacks::reset_profile_flags, and TAO_Fault_Tolerance_Service::service_callback.

00094 {
00095   // @@ If different services have the same feature we may want to
00096   // prioritise them here. We need to decide here whose selection of
00097   // profile is more important.
00098 
00099   if (this->ft_service_.service_callback ())
00100     {
00101       this->ft_service_.service_callback ()->reset_profile_flags ();
00102     }
00103   return;
00104 }

ACE_INLINE CORBA::Object_ptr TAO_ORB_Core::resolve_dynanyfactory ACE_ENV_SINGLE_ARG_DECL   
 

Resolve the Dynamic Any Factory.

Definition at line 401 of file ORB_Core.i.

References ACE_CHECK_RETURN, ACE_ENV_SINGLE_ARG_DECL, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_GUARD_RETURN, CORBA::is_nil, resolve_dynanyfactory_i, and TAO_SYNCH_MUTEX.

Referenced by CORBA_ORB::resolve_initial_references.

00402 {
00403   ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, mon, this->lock_,
00404                     CORBA::Object::_nil ());
00405   if (CORBA::is_nil (this->dynany_factory_))
00406     {
00407       this->resolve_dynanyfactory_i (ACE_ENV_SINGLE_ARG_PARAMETER);
00408       ACE_CHECK_RETURN (CORBA::Object::_nil ());
00409     }
00410   return CORBA::Object::_duplicate (this->dynany_factory_);
00411 }

void TAO_ORB_Core::resolve_dynanyfactory_i ACE_ENV_SINGLE_ARG_DECL    [protected]
 

Obtain and cache the dynamic any factory object reference.

Definition at line 2031 of file ORB_Core.cpp.

References ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_DECL, ACE_LIB_TEXT, ACE_THROW, TAO_Object_Loader::create_object, dynany_factory_, ACE_Dynamic_Service::instance, and ACE_Service_Config::process_directive.

Referenced by resolve_dynanyfactory.

02032 {
02033   TAO_Object_Loader *loader =
02034     ACE_Dynamic_Service<TAO_Object_Loader>::instance ("DynamicAny_Loader");
02035   if (loader == 0)
02036     {
02037       ACE_Service_Config::process_directive (ACE_LIB_TEXT("dynamic DynamicAny_Loader Service_Object *")
02038                                              ACE_LIB_TEXT("TAO_DynamicAny:_make_TAO_DynamicAny_Loader()"));
02039       loader =
02040         ACE_Dynamic_Service<TAO_Object_Loader>::instance ("DynamicAny_Loader");
02041       if (loader == 0)
02042         ACE_THROW (CORBA::ORB::InvalidName ());
02043     }
02044   this->dynany_factory_ =
02045     loader->create_object (this->orb_.in (), 0, 0 ACE_ENV_ARG_PARAMETER);
02046 }

ACE_INLINE CORBA::Object_ptr TAO_ORB_Core::resolve_ior_manipulation ACE_ENV_SINGLE_ARG_DECL_NOT_USED   
 

Resolve the IOR Manipulation reference for this ORB.

Definition at line 414 of file ORB_Core.i.

References ACE_CHECK_RETURN, ACE_ENV_SINGLE_ARG_DECL, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_GUARD_RETURN, CORBA::is_nil, resolve_iormanipulation_i, and TAO_SYNCH_MUTEX.

Referenced by CORBA_ORB::resolve_initial_references.

00415 {
00416   ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, mon, this->lock_,
00417                     CORBA::Object::_nil ());
00418   if (CORBA::is_nil (this->ior_manip_factory_))
00419     {
00420       this->resolve_iormanipulation_i (ACE_ENV_SINGLE_ARG_PARAMETER);
00421       ACE_CHECK_RETURN (CORBA::Object::_nil ());
00422     }
00423   return CORBA::Object::_duplicate (this->ior_manip_factory_);
00424 }

ACE_INLINE CORBA::Object_ptr TAO_ORB_Core::resolve_ior_table ACE_ENV_SINGLE_ARG_DECL_NOT_USED   
 

Resolve the IOR Table reference for this ORB.

Definition at line 427 of file ORB_Core.i.

References ACE_CHECK_RETURN, ACE_ENV_SINGLE_ARG_DECL, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_GUARD_RETURN, CORBA::is_nil, resolve_ior_table_i, and TAO_SYNCH_MUTEX.

Referenced by CORBA_ORB::resolve_initial_references.

00428 {
00429   ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, mon, this->lock_,
00430                     CORBA::Object::_nil ());
00431   if (CORBA::is_nil (this->ior_table_))
00432     {
00433       this->resolve_ior_table_i (ACE_ENV_SINGLE_ARG_PARAMETER);
00434       ACE_CHECK_RETURN (CORBA::Object::_nil ());
00435     }
00436   return CORBA::Object::_duplicate (this->ior_table_);
00437 }

void TAO_ORB_Core::resolve_ior_table_i ACE_ENV_SINGLE_ARG_DECL    [private]
 

Obtain and cache the dynamic any factory object reference.

Definition at line 2068 of file ORB_Core.cpp.

References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_DECL, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_LIB_TEXT, ACE_THROW, adapter_registry_, TAO_Adapter_Factory::create, TAO_Adapter_Registry::insert, ACE_Dynamic_Service::instance, ior_table_, TAO_Adapter::open, ACE_Service_Config::process_directive, and TAO_Adapter::root.

Referenced by resolve_ior_table.

02069 {
02070   TAO_Adapter_Factory *factory =
02071     ACE_Dynamic_Service<TAO_Adapter_Factory>::instance ("TAO_IORTable");
02072   if (factory == 0)
02073     {
02074       ACE_Service_Config::process_directive (ACE_LIB_TEXT("dynamic TAO_IORTable Service_Object *")
02075                                              ACE_LIB_TEXT("TAO_IORTable:_make_TAO_Table_Adapter_Factory()"));
02076       factory =
02077         ACE_Dynamic_Service<TAO_Adapter_Factory>::instance ("TAO_IORTable");
02078     }
02079   if (factory == 0)
02080     ACE_THROW (CORBA::ORB::InvalidName ());
02081 
02082   // @@ Not exception safe
02083   TAO_Adapter *iortable_adapter = factory->create (this);
02084   this->adapter_registry_.insert (iortable_adapter ACE_ENV_ARG_PARAMETER);
02085   ACE_CHECK;
02086 
02087   iortable_adapter->open (ACE_ENV_SINGLE_ARG_PARAMETER);
02088   ACE_CHECK;
02089 
02090   this->ior_table_ = iortable_adapter->root ();
02091 }

void TAO_ORB_Core::resolve_iormanipulation_i ACE_ENV_SINGLE_ARG_DECL    [protected]
 

Obtain and cache the IORManipulation factory object reference.

Definition at line 2049 of file ORB_Core.cpp.

References ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_DECL, ACE_LIB_TEXT, ACE_THROW, TAO_Object_Loader::create_object, ACE_Dynamic_Service::instance, ior_manip_factory_, and ACE_Service_Config::process_directive.

Referenced by resolve_ior_manipulation.

02050 {
02051   TAO_Object_Loader *loader =
02052     ACE_Dynamic_Service<TAO_Object_Loader>::instance ("IORManip_Loader");
02053 
02054   if (loader == 0)
02055     {
02056       ACE_Service_Config::process_directive (ACE_LIB_TEXT("dynamic IORManip_Loader Service_Object *")
02057                                              ACE_LIB_TEXT("TAO_IORManip:_make_TAO_IORManip_Loader()"));
02058       loader =
02059         ACE_Dynamic_Service<TAO_Object_Loader>::instance ("IORManip_Loader");
02060       if (loader == 0)
02061         ACE_THROW (CORBA::ORB::InvalidName ());
02062     }
02063   this->ior_manip_factory_ =
02064     loader->create_object (this->orb_.in (), 0, 0 ACE_ENV_ARG_PARAMETER);
02065 }

CORBA::Object_ptr TAO_ORB_Core::resolve_rir const char *name    ACE_ENV_ARG_DECL_NOT_USED
 

Resolve an initial reference via the -ORBInitRef and.

Definition at line 2117 of file ORB_Core.cpp.

References ACE_CHECK_RETURN, ACE_CString, ACE_ENV_ARG_DECL, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, connector_registry, TAO_ORB_Parameters::default_init_ref, TAO_Connector_Registry::object_key_delimiter, orb, orb_params, ACE_OS_String::strlen, and ACE_OS_String::strncmp.

Referenced by CORBA_ORB::resolve_initial_references.

02119 {
02120   // Get the table of initial references specified through
02121   // -ORBInitRef.
02122   ACE_CString ior;
02123   ACE_CString object_id ((const char *) name);
02124 
02125   // Get the list of initial reference prefixes specified through
02126   // -ORBDefaultInitRef.
02127   CORBA::String_var default_init_ref =
02128     this->orb_params ()->default_init_ref ();
02129 
02130   // Check if a DefaultInitRef was specified.
02131   if (ACE_OS::strlen (default_init_ref.in ()) != 0)
02132     {
02133       static const char corbaloc_prefix[] = "corbaloc:";
02134       static const char mcast_prefix[] = "mcast:";
02135       char object_key_delimiter = 0;
02136 
02137       ACE_CString list_of_profiles (default_init_ref.in ());
02138 
02139       // Check if the protocol is corbaloc: or mcast:.
02140       // If it is, set the object_key_delimiter.
02141       if ((ACE_OS::strncmp (default_init_ref.in (),
02142                             corbaloc_prefix,
02143                             sizeof corbaloc_prefix -1) == 0) ||
02144           (ACE_OS::strncmp (default_init_ref.in (),
02145                             mcast_prefix,
02146                             sizeof mcast_prefix -1) == 0))
02147         {
02148           object_key_delimiter = '/';
02149         }
02150       else
02151         {
02152           TAO_Connector_Registry *conn_reg =
02153             this->connector_registry (ACE_ENV_SINGLE_ARG_PARAMETER);
02154           ACE_CHECK_RETURN (0);
02155 
02156           // Obtain the appropriate object key delimiter for the
02157           // specified protocol.
02158           object_key_delimiter =
02159             conn_reg->object_key_delimiter (list_of_profiles.c_str ());
02160         }
02161 
02162       // Make sure that the default initial reference doesn't end
02163       // with the object key delimiter character.
02164       if (list_of_profiles[list_of_profiles.length() - 1] !=
02165           object_key_delimiter)
02166             list_of_profiles += ACE_CString (object_key_delimiter);
02167 
02168       list_of_profiles += object_id;
02169 
02170       return this->orb ()->string_to_object (list_of_profiles.c_str ()
02171                                              ACE_ENV_ARG_PARAMETER);
02172     }
02173 
02174   return CORBA::Object::_nil ();
02175 }

ACE_INLINE CORBA::Object_ptr TAO_ORB_Core::resolve_rt_current ACE_ENV_SINGLE_ARG_DECL   
 

Definition at line 531 of file ORB_Core.i.

References ACE_CHECK_RETURN, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_DECL, ACE_GUARD_RETURN, CORBA::is_nil, object_ref_table, TAO_Object_Ref_Table::resolve_initial_references, rt_current_, TAO_OBJID_RTCURRENT, and TAO_SYNCH_MUTEX.

00532 {
00533   if (CORBA::is_nil (this->rt_current_.in ()))
00534     {
00535       ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, mon, this->lock_,
00536                         CORBA::Object::_nil ());
00537       if (CORBA::is_nil (this->rt_current_.in ()))
00538         {
00539           // Save a reference to the priority mapping manager.
00540           this->rt_current_ =
00541               this->object_ref_table ().resolve_initial_references (
00542               TAO_OBJID_RTCURRENT
00543                ACE_ENV_ARG_PARAMETER);
00544           ACE_CHECK_RETURN (CORBA::Object::_nil ());
00545         }
00546     }
00547   return CORBA::Object::_duplicate (this->rt_current_.in ());
00548 }

ACE_INLINE CORBA::Object_ptr TAO_ORB_Core::resolve_rt_orb ACE_ENV_SINGLE_ARG_DECL   
 

Resolve the RT ORB reference for this ORB.

Definition at line 510 of file ORB_Core.i.

References ACE_CHECK_RETURN, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_DECL, ACE_GUARD_RETURN, CORBA::is_nil, object_ref_table, TAO_Object_Ref_Table::resolve_initial_references, rt_orb_, TAO_OBJID_RTORB, and TAO_SYNCH_MUTEX.

00511 {
00512   if (CORBA::is_nil (this->rt_orb_.in ()))
00513     {
00514       ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, mon, this->lock_,
00515                         CORBA::Object::_nil ());
00516       if (CORBA::is_nil (this->rt_orb_.in ()))
00517         {
00518           // Save a reference to the priority mapping manager.
00519           this->rt_orb_ =
00520               this->object_ref_table ().resolve_initial_references (
00521               TAO_OBJID_RTORB
00522                ACE_ENV_ARG_PARAMETER);
00523           ACE_CHECK_RETURN (CORBA::Object::_nil ());
00524         }
00525     }
00526 
00527   return CORBA::Object::_duplicate (this->rt_orb_.in ());
00528 }

ACE_INLINE CORBA::Object_ptr TAO_ORB_Core::resolve_typecodefactory ACE_ENV_SINGLE_ARG_DECL   
 

Resolve the TypeCodeFactory DLL.

Definition at line 370 of file ORB_Core.i.

References ACE_CHECK_RETURN, ACE_ENV_SINGLE_ARG_DECL, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_GUARD_RETURN, CORBA::is_nil, resolve_typecodefactory_i, and TAO_SYNCH_MUTEX.

Referenced by CORBA_ORB::resolve_initial_references.

00371 {
00372   ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, mon, this->lock_,
00373                     CORBA::Object::_nil ());
00374   if (CORBA::is_nil (this->typecode_factory_))
00375     {
00376       this->resolve_typecodefactory_i (ACE_ENV_SINGLE_ARG_PARAMETER);
00377       ACE_CHECK_RETURN (CORBA::Object::_nil ());
00378     }
00379   return CORBA::Object::_duplicate (this->typecode_factory_);
00380 }

void TAO_ORB_Core::resolve_typecodefactory_i ACE_ENV_SINGLE_ARG_DECL    [protected]
 

Obtain and cache the dynamic any factory object reference.

Definition at line 2013 of file ORB_Core.cpp.

References ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_DECL, ACE_LIB_TEXT, ACE_THROW, TAO_Object_Loader::create_object, ACE_Dynamic_Service::instance, ACE_Service_Config::process_directive, and typecode_factory_.

Referenced by resolve_typecodefactory.

02014 {
02015   TAO_Object_Loader *loader =
02016     ACE_Dynamic_Service<TAO_Object_Loader>::instance ("TypeCodeFactory_Loader");
02017   if (loader == 0)
02018     {
02019       ACE_Service_Config::process_directive (ACE_LIB_TEXT("dynamic TypeCodeFactory Service_Object *")
02020                                              ACE_LIB_TEXT("TAO_TypeCodeFactory:_make_TAO_TypeCodeFactory_Loader()"));
02021       loader =
02022         ACE_Dynamic_Service<TAO_Object_Loader>::instance ("TypeCodeFactory_Loader");
02023       if (loader == 0)
02024         ACE_THROW (CORBA::ORB::InvalidName ());
02025     }
02026   this->typecode_factory_ =
02027     loader->create_object (this->orb_.in (), 0, 0 ACE_ENV_ARG_PARAMETER);
02028 }

TAO_Resource_Factory * TAO_ORB_Core::resource_factory void   
 

Returns pointer to the resource factory.

Definition at line 1221 of file ORB_Core.cpp.

References TAO_ORB_Core_Static_Resources::instance, resource_factory_, and TAO_ORB_Core_Static_Resources::resource_factory_name_.

Referenced by TAO_Thread_Lane_Resources::acceptor_registry, TAO_Thread_Lane_Resources::connector_registry, create_input_cdr_data_block, locking_strategy, TAO_Parser_Registry::open, operator>>, output_cdr_buffer_allocator, output_cdr_dblock_allocator, output_cdr_msgblock_allocator, TAO_Leader_Follower::reactor, TAO_Thread_Lane_Resources::resource_factory, TAO_Connection_Handler::TAO_Connection_Handler, TAO_Thread_Lane_Resources_Manager::TAO_Thread_Lane_Resources_Manager, TAO_Transport::TAO_Transport, and TAO_Leader_Follower::~TAO_Leader_Follower.

01222 {
01223   // Check if there is a cached reference.
01224   if (this->resource_factory_ != 0)
01225     return this->resource_factory_;
01226 
01227   // Look in the service repository for an instance.
01228   this->resource_factory_ =
01229     ACE_Dynamic_Service<TAO_Resource_Factory>::instance
01230     (TAO_ORB_Core_Static_Resources::instance ()->resource_factory_name_.c_str());
01231 
01232   return this->resource_factory_;
01233 }

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.

Definition at line 1495 of file ORB_Core.cpp.

References ACE_CHECK_RETURN, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_DECL, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_TEXT_CHAR_TO_TCHAR, ACE_THROW_RETURN, adapter_registry_, TAO_Adapter_Factory::create, TAO_Adapter_Registry::insert, ACE_Dynamic_Service::instance, TAO_ORB_Core_Static_Resources::instance, CORBA::is_nil, TAO_Adapter::open, poa_adapter, TAO_ORB_Core_Static_Resources::poa_factory_directive_, TAO_ORB_Core_Static_Resources::poa_factory_name_, ACE_Service_Config::process_directive, TAO_Adapter::root, and root_poa_.

Referenced by CORBA_ORB::resolve_root_poa.

01496 {
01497   if (!CORBA::is_nil (this->root_poa_.in ()))
01498     return CORBA::Object::_duplicate (this->root_poa_.in ());
01499 
01500   TAO_ORB_Core_Static_Resources* static_resources =
01501     TAO_ORB_Core_Static_Resources::instance ();
01502   TAO_Adapter_Factory *factory =
01503     ACE_Dynamic_Service<TAO_Adapter_Factory>::instance (static_resources->poa_factory_name_.c_str());
01504   if (factory == 0)
01505     {
01506       ACE_Service_Config::process_directive (ACE_TEXT_CHAR_TO_TCHAR(static_resources->poa_factory_directive_.c_str()));
01507       factory =
01508         ACE_Dynamic_Service<TAO_Adapter_Factory>::instance (static_resources->poa_factory_name_.c_str());
01509     }
01510 
01511   if (factory == 0)
01512     {
01513       // It really failed, raise an exception!
01514       ACE_THROW_RETURN (CORBA::ORB::InvalidName (),
01515                         CORBA::Object::_nil ());
01516     }
01517 
01518   // @@ Not exception safe
01519   TAO_Adapter *poa_adapter = factory->create (this);
01520   poa_adapter->open (ACE_ENV_SINGLE_ARG_PARAMETER);
01521   ACE_CHECK_RETURN (CORBA::Object::_nil ());
01522 
01523   this->root_poa_ = poa_adapter->root ();
01524 
01525   this->adapter_registry_.insert (poa_adapter ACE_ENV_ARG_PARAMETER);
01526   ACE_CHECK_RETURN (CORBA::Object::_nil ());
01527 
01528   return CORBA::Object::_duplicate (this->root_poa_.in ());
01529 }

int TAO_ORB_Core::run ACE_Time_Value   tv,
int perform_work    ACE_ENV_ARG_DECL
 

Run the event loop.

Definition at line 1710 of file ORB_Core.cpp.

References ACE_DEBUG, ACE_ENV_ARG_DECL_NOT_USED, ACE_LIB_TEXT, ETIME, TAO_LF_Event_Loop_Thread_Helper::event_loop_return, ACE_Reactor::handle_events, has_shutdown, leader_follower, lf_strategy, LM_DEBUG, ACE_Reactor::owner, reactor, ACE_Thread::self, and ACE_Time_Value::zero.

Referenced by TAO_Reactive_Flushing_Strategy::flush_message, TAO_Reactive_Flushing_Strategy::flush_transport, TAO_Leader_Follower_Flushing_Strategy::flush_transport, CORBA_ORB::run, and TAO_Reactive_Connect_Strategy::wait.

01713 {
01714   if (TAO_debug_level >= 3)
01715     ACE_DEBUG ((LM_DEBUG,
01716                 "TAO (%P|%t) - ORB_Core::run, "
01717                 "start [%s]\n",
01718                 perform_work?"perform_work":"run"));
01719 
01720   // Fetch the Reactor
01721   ACE_Reactor *r = this->reactor ();
01722 
01723   int result = 1;
01724   // 1 to detect that nothing went wrong
01725 
01726   // Loop handling client requests until the ORB is shutdown.
01727 
01728   // We could use the leader-follower lock to check for the state
01729   // if this variable or use the lock <create_event_loop_lock> in
01730   // the server strategy factory.
01731   // We don't need to do this because we use the Reactor
01732   // mechanisms to shutdown in a thread-safe way.
01733 
01734   while (this->has_shutdown () == 0)
01735     {
01736       // Every time we perform an interation we have to become the
01737       // leader again, because it is possible that a client has
01738       // acquired the leader role...
01739       TAO_Leader_Follower &leader_follower =
01740         this->leader_follower ();
01741 
01742       TAO_LF_Strategy &lf_strategy =
01743         this->lf_strategy ();
01744 
01745       TAO_LF_Event_Loop_Thread_Helper helper (leader_follower,
01746                                               lf_strategy,
01747                                               tv);
01748       int result = helper.event_loop_return ();
01749       if (result != 0)
01750         {
01751           if (errno == ETIME)
01752             return 0;
01753           else
01754             return result;
01755         }
01756 
01757       // Set the owning thread of the Reactor to the one which we're
01758       // currently in.  This is necessary b/c it's possible that the
01759       // application is calling us from a thread other than that in which
01760       // the Reactor's CTOR (which sets the owner) was called.
01761       //
01762       // We need to do this on every iteration because the reactor may be
01763       // acquired by one of the client threads in the LF waiting
01764       // strategy
01765       r->owner (ACE_Thread::self ());
01766 
01767       if (TAO_debug_level >= 3)
01768         ACE_DEBUG ((LM_DEBUG,
01769                     ACE_LIB_TEXT ("TAO (%P|%t) - ORB_Core::run, "
01770                                   "calling handle_events()\n")));
01771 
01772       result = r->handle_events (tv);
01773 
01774       if (TAO_debug_level >= 3)
01775         ACE_DEBUG ((LM_DEBUG,
01776                     ACE_LIB_TEXT ("TAO (%P|%t) - ORB_Core::run, "
01777                                   "handle_events() returns %d\n"),
01778                     result));
01779 
01780       if (result == -1)
01781         {
01782           // An error, terminate the loop
01783           break;
01784         }
01785       if (result == 0
01786           && tv != 0
01787           && *tv == ACE_Time_Value::zero)
01788         {
01789           // A timeout, terminate the loop...
01790           break;
01791         }
01792       if (perform_work)
01793         {
01794           // This is running on behalf of a perform_work() call,
01795           // The loop should run only once.
01796           break;
01797         }
01798       // Otherwise just continue..
01799     }
01800 
01801   if (TAO_debug_level >= 3)
01802     ACE_DEBUG ((LM_DEBUG,
01803                 ACE_LIB_TEXT ("TAO (%P|%t) - ORB_Core::run, ")
01804                 ACE_LIB_TEXT ("ends with result = %d\n"),
01805                 result));
01806 
01807   return result;
01808 }

TAO_Server_Strategy_Factory * TAO_ORB_Core::server_factory void   
 

Returns pointer to the server factory.

Definition at line 1464 of file ORB_Core.cpp.

References ACE_Dynamic_Service::instance, and server_factory_.

Referenced by TAO_Concurrency_Strategy::activate_svc_handler.

01465 {
01466   if (this->server_factory_ == 0)
01467     {
01468       // Look in the service repository for an instance.
01469       this->server_factory_ =
01470         ACE_Dynamic_Service<TAO_Server_Strategy_Factory>::instance ("Server_Strategy_Factory");
01471     }
01472 
01473   return this->server_factory_;
01474 }

ACE_INLINE const char * TAO_ORB_Core::server_id void    const
 

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

Definition at line 383 of file ORB_Core.i.

References server_id_.

00384 {
00385   return this->server_id_.c_str();
00386 }

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.

Definition at line 76 of file ORB_Core.i.

References ft_service_, TAO_Service_Callbacks::reselect_profile, and TAO_Fault_Tolerance_Service::service_callback.

00078 {
00079   CORBA::Boolean retval = 0;
00080   // @@ If different services have the same feature we may want to
00081   // prioritise them here. We need to decide here whose selection of
00082   // profile is more important.
00083   if (this->ft_service_.service_callback ())
00084     {
00085       retval =
00086         this->ft_service_.service_callback ()->reselect_profile (stub,
00087                                                                  profile);
00088     }
00089   return retval;
00090 }

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

Definition at line 59 of file ORB_Core.i.

References ft_service_, TAO_Service_Callbacks::select_profile, and TAO_Fault_Tolerance_Service::service_callback.

00061 {
00062   CORBA::Boolean retval = 0;
00063   // @@ If different services have the same feature we may want to
00064   // prioritise them here. We need to decide here whose selection of
00065   // profile is more important.
00066   if (this->ft_service_.service_callback ())
00067     {
00068       retval =
00069         this->ft_service_.service_callback ()->select_profile (&mprofile,
00070                                                                 profile);
00071     }
00072   return retval;
00073 }

int TAO_ORB_Core::service_raise_comm_failure TAO_GIOP_Invocation   invoke,
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.

Definition at line 1378 of file ORB_Core.cpp.

References CORBA_SystemException::_tao_minor_code, ACE_ENV_ARG_DECL, ACE_ENV_ARG_PARAMETER, ACE_THROW_RETURN, TAO_GIOP_Invocation::close_connection, ft_service_, TAO_Fault_Tolerance_Service::service_callback, TAO_INVOCATION_RECV_REQUEST_MINOR_CODE, and TAO_INVOKE_EXCEPTION.

01381 {
01382   if (this->ft_service_.service_callback ())
01383     {
01384       return this->ft_service_.service_callback ()->
01385                  raise_comm_failure (invoke,
01386                                      profile
01387                                      ACE_ENV_ARG_PARAMETER);
01388     }
01389 
01390   invoke->close_connection ();
01391 
01392   ACE_THROW_RETURN (CORBA::COMM_FAILURE (
01393       CORBA_SystemException::_tao_minor_code (
01394           TAO_INVOCATION_RECV_REQUEST_MINOR_CODE,
01395           errno),
01396       CORBA::COMPLETED_MAYBE),
01397       TAO_INVOKE_EXCEPTION);
01398 }

int TAO_ORB_Core::service_raise_transient_failure TAO_GIOP_Invocation   invoke,
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.

Definition at line 1401 of file ORB_Core.cpp.

References CORBA_SystemException::_tao_minor_code, ACE_ENV_ARG_DECL, ACE_ENV_ARG_PARAMETER, ACE_THROW_RETURN, ft_service_, TAO_Fault_Tolerance_Service::service_callback, TAO_INVOCATION_SEND_REQUEST_MINOR_CODE, and TAO_INVOKE_EXCEPTION.

01404 {
01405   if (this->ft_service_.service_callback ())
01406     {
01407       return this->ft_service_.service_callback ()->
01408                  raise_transient_failure (invoke,
01409                                           profile
01410                                           ACE_ENV_ARG_PARAMETER);
01411     }
01412 
01413   ACE_THROW_RETURN (CORBA::TRANSIENT (
01414         CORBA_SystemException::_tao_minor_code (
01415           TAO_INVOCATION_SEND_REQUEST_MINOR_CODE,
01416           errno),
01417         CORBA::COMPLETED_MAYBE),
01418         TAO_INVOKE_EXCEPTION);
01419 }

void TAO_ORB_Core::services_callbacks_init void    [protected]
 

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

Definition at line 1367 of file ORB_Core.cpp.

References ft_service_, and TAO_Fault_Tolerance_Service::init.

01368 {
01369   // We (should) know what are the services that would need
01370   // callbacks. So, what we do is go through the Service Configurator
01371   // list for looking at the services that we want to load.
01372   this->ft_service_.init (this);
01373 
01374   // @@ Other service callbacks can be added here
01375 }

ACE_INLINE void TAO_ORB_Core::services_log_msg_post_upcall TAO_ServerRequest   req
 

Hook for logging of messages by the Logging & Recovery service of an FT service.

Definition at line 140 of file ORB_Core.i.

References ft_service_, TAO_Fault_Tolerance_Service::service_callback, and TAO_Service_Callbacks::service_log_msg_post_upcall.

00141 {
00142     if (this->ft_service_.service_callback ())
00143       {
00144         this->ft_service_.service_callback ()->service_log_msg_post_upcall (req);
00145       }
00146 }

ACE_INLINE void TAO_ORB_Core::services_log_msg_pre_upcall TAO_ServerRequest   req
 

Hook for logging of messages by the Logging & Recovery service of an FT service.

Definition at line 131 of file ORB_Core.i.

References ft_service_, TAO_Fault_Tolerance_Service::service_callback, and TAO_Service_Callbacks::service_log_msg_pre_upcall.

00132 {
00133     if (this->ft_service_.service_callback ())
00134       {
00135         this->ft_service_.service_callback ()->service_log_msg_pre_upcall (req);
00136       }
00137 }

ACE_INLINE void TAO_ORB_Core::services_log_msg_rcv TAO_Message_State_Factory &    state
 

Hook for logging of messages by the Logging & Recovery service of an FT service.

Definition at line 122 of file ORB_Core.i.

References ft_service_, TAO_Fault_Tolerance_Service::service_callback, and TAO_Service_Callbacks::service_log_msg_rcv.

00123 {
00124     if (this->ft_service_.service_callback ())
00125       {
00126         this->ft_service_.service_callback ()->service_log_msg_rcv (state);
00127       }
00128 }

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

Sets the value of TAO_ORB_Core::collocation_resolver_name_.

Definition at line 1164 of file ORB_Core.cpp.

References TAO_ORB_Core_Static_Resources::collocation_resolver_name_, and TAO_ORB_Core_Static_Resources::instance.

01165 {
01166   TAO_ORB_Core_Static_Resources::instance ()->collocation_resolver_name_ =
01167     collocation_resolver_name;
01168 }

void TAO_ORB_Core::set_default const char *    orb_id
 

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

Definition at line 2876 of file ORB_Core.cpp.

References TAO_ORB_Table::instance, and TAO_ORB_Table::set_default.

02877 {
02878   TAO_ORB_Table *table = TAO_ORB_Table::instance ();
02879   table->set_default (orb_id);
02880 }

int TAO_ORB_Core::set_endpoint_helper const char *current_arg    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.

Definition at line 2094 of file ORB_Core.cpp.

References ACE_CString, ACE_ENV_ARG_DECL, ACE_ERROR, ACE_LIB_TEXT, ACE_TEXT_CHAR_TO_TCHAR, ACE_THROW_RETURN, TAO_ORB_Parameters::endpoints, LM_ERROR, orb_params, and TAO_ORB_CORE_INIT_LOCATION_CODE.

02096 {
02097   ACE_CString endpts (current_arg);
02098 
02099   if (this->orb_params ()->endpoints (endpts) != 0)
02100     {
02101       ACE_ERROR ((LM_ERROR,
02102                   ACE_LIB_TEXT ("(%P|%t)\n")
02103                   ACE_LIB_TEXT ("Invalid endpoint(s) specified:\n%s\n"),
02104                   ACE_TEXT_CHAR_TO_TCHAR(endpts.c_str ())));
02105       ACE_THROW_RETURN (CORBA::BAD_PARAM (
02106                            CORBA::SystemException::_tao_minor_code (
02107                               TAO_ORB_CORE_INIT_LOCATION_CODE,
02108                               EINVAL),
02109                            CORBA::COMPLETED_NO),
02110                         -1);
02111     }
02112 
02113   return 0;
02114 }

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

Sets the value of TAO_ORB_Core::endpoint_selector_factory_.

Definition at line 1300 of file ORB_Core.cpp.

References TAO_ORB_Core_Static_Resources::endpoint_selector_factory_name_, and TAO_ORB_Core_Static_Resources::instance.

01301 {
01302   TAO_ORB_Core_Static_Resources::instance ()->endpoint_selector_factory_name_ =
01303     endpoint_selector_factory_name;
01304 }

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

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

Definition at line 1284 of file ORB_Core.cpp.

References TAO_ORB_Core_Static_Resources::instance, TAO_ORB_Core_Static_Resources::poa_factory_directive_, poa_factory_name, and TAO_ORB_Core_Static_Resources::poa_factory_name_.

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

Sets the value of TAO_ORB_Core::protocols_hooks_.

Definition at line 1322 of file ORB_Core.cpp.

References TAO_ORB_Core_Static_Resources::instance, and TAO_ORB_Core_Static_Resources::protocols_hooks_name_.

01323 {
01324   TAO_ORB_Core_Static_Resources::instance ()->protocols_hooks_name_ =
01325     protocols_hooks_name;
01326 }

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

Sets the value of TAO_ORB_Core::resource_factory_.

Definition at line 1178 of file ORB_Core.cpp.

References TAO_ORB_Core_Static_Resources::instance, and TAO_ORB_Core_Static_Resources::resource_factory_name_.

01179 {
01180   TAO_ORB_Core_Static_Resources::instance ()->resource_factory_name_ =
01181     resource_factory_name;
01182 }

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

Sets the value of TAO_ORB_Core::stub_factory_name_.

Definition at line 1171 of file ORB_Core.cpp.

References TAO_ORB_Core_Static_Resources::instance, and TAO_ORB_Core_Static_Resources::stub_factory_name_.

01172 {
01173   TAO_ORB_Core_Static_Resources::instance ()->stub_factory_name_ =
01174     stub_factory_name;
01175 }

void TAO_ORB_Core::set_sync_scope_hook Sync_Scope_Hook    hook [static]
 

Definition at line 2528 of file ORB_Core.cpp.

References TAO_ORB_Core_Static_Resources::instance.

02529 {
02530   TAO_ORB_Core_Static_Resources::instance ()-> sync_scope_hook_ = hook;
02531 }

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

Sets the value of TAO_ORB_Core::thread_lane_resources_manager_factory_name_.

Definition at line 1157 of file ORB_Core.cpp.

References TAO_ORB_Core_Static_Resources::instance, and TAO_ORB_Core_Static_Resources::thread_lane_resources_manager_factory_name_.

01158 {
01159   TAO_ORB_Core_Static_Resources::instance ()->thread_lane_resources_manager_factory_name_ =
01160     thread_lane_resources_manager_factory_name;
01161 }

void TAO_ORB_Core::set_timeout_hook Timeout_Hook    hook [static]
 

Definition at line 2583 of file ORB_Core.cpp.

References TAO_ORB_Core_Static_Resources::instance, and TAO_ORB_Core_Static_Resources::timeout_hook_.

02584 {
02585   TAO_ORB_Core_Static_Resources::instance ()->timeout_hook_ = hook;
02586   // Saving the hook pointer so that we can use it later when needed.
02587 
02588   return;
02589 }

ACE_INLINE int TAO_ORB_Core::set_tss_resource size_t    slot_id,
void *   
 

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

Definition at line 275 of file ORB_Core.i.

References get_tss_resources, TAO_ORB_Core_TSS_Resources::orb_core_, ACE_Array_Base< void * >::size, TAO_Cleanup_Func_Registry::size, TAO_ORB_Core_TSS_Resources::ts_objects_, and tss_cleanup_funcs_.

00276 {
00277   TAO_ORB_Core_TSS_Resources *tss_resources =
00278     this->get_tss_resources ();
00279 
00280   // The number of allocated slots is equal to the number of
00281   // registered TSS cleanup functions, *not* the size of the array in
00282   // the ORB core TSS resources.
00283   if (slot_id >= this->tss_cleanup_funcs_.size ())
00284     {
00285       errno = EINVAL;
00286       return -1;
00287     }
00288 
00289   // If the TSS array isn't large enough, then increase its size.
00290   // We're guaranteed not to exceed the number of allocated slots by
00291   // the above check.
00292   size_t old_size = tss_resources->ts_objects_.size ();
00293   size_t new_size = slot_id + 1;
00294   if (slot_id >= old_size
00295       && tss_resources->ts_objects_.size (new_size) != 0)
00296     return -1;
00297 
00298   // Initialize intermediate array elements to zero, since they
00299   // haven't been initialized yet.  This ensures that garbage is not
00300   // returned when accessing any of those elements at a later point in
00301   // time.
00302   for (size_t i = old_size; i < slot_id; ++i)
00303     tss_resources->ts_objects_[i] = 0;
00304 
00305   tss_resources->ts_objects_[slot_id] = ts_object;
00306 
00307   // Make sure the ORB core pointer is set in the ORB core's TSS
00308   // resources so that the TSS cleanup functions stored in the ORB
00309   // core can be invoked.
00310   tss_resources->orb_core_ = this;
00311 
00312   return 0;
00313 }

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

End the event loop.

Definition at line 1812 of file ORB_Core.cpp.

References ACE_CATCHALL, ACE_ENDTRY, ACE_ENV_ARG_DECL, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_GUARD, ACE_TRY, ACE_TRY_CHECK, ACE_Thread_Manager::cancel_all, TAO_SYNCH_MUTEX, and ACE_Thread_Manager::wait.

Referenced by destroy, fini, and CORBA_ORB::shutdown.

01815 {
01816   ACE_TRY
01817     {
01818       {
01819         ACE_GUARD (TAO_SYNCH_MUTEX, monitor, this->lock_);
01820 
01821         if (this->has_shutdown () != 0)
01822           return;
01823 
01824         // Check if we are on the right state, i.e. do not accept
01825         // shutdowns with the 'wait_for_completion' flag set in the middle
01826         // of an upcall (because those deadlock).
01827         this->adapter_registry_.check_close (wait_for_completion
01828                                              ACE_ENV_ARG_PARAMETER);
01829         ACE_TRY_CHECK;
01830 
01831         // Set the 'has_shutdown' flag, so any further attempt to shutdown
01832         // becomes a noop.
01833         this->has_shutdown_ = 1;
01834 
01835         // need to release the mutex, because some of the shutdown
01836         // operations invoke application code, that could (and in practice
01837         // does!) callback into ORB Core code.
01838       }
01839 
01840       this->adapter_registry_.close (wait_for_completion
01841                                      ACE_ENV_ARG_PARAMETER);
01842       ACE_TRY_CHECK;
01843 
01844       // Shutdown reactor.
01845       this->thread_lane_resources_manager ().shutdown_reactor ();
01846 
01847       // Grab the thread manager
01848       ACE_Thread_Manager *tm = this->thr_mgr ();
01849 
01850       // Try to cancel all the threads in the ORB.
01851       tm->cancel_all ();
01852 
01853       // If <wait_for_completion> is set, wait for all threads to exit.
01854       if (wait_for_completion != 0)
01855         tm->wait ();
01856 
01857       // Invoke Interceptor::destroy() on all registered interceptors.
01858       this->destroy_interceptors (ACE_ENV_SINGLE_ARG_PARAMETER);
01859       ACE_TRY_CHECK;
01860 
01861       // Explicitly destroy the object reference table since it
01862       // contains references to objects, which themselves may contain
01863       // reference to this ORB.
01864       this->object_ref_table_.destroy ();
01865 
01866 #if (TAO_HAS_INTERCEPTORS == 1)
01867       this->pi_current_ = 0;  // For the sake of consistency.
01868 #endif  /* TAO_HAS_INTERCEPTORS == 1 */
01869     }
01870   ACE_CATCHALL
01871     {
01872       // Do not allow exceptions to escape.. So catch all the
01873       // exceptions.
01874       // @@ Not sure what to print here for the users..
01875 
01876     }
01877   ACE_ENDTRY;
01878 
01879   return;
01880 }

TAO_Stub_Factory * TAO_ORB_Core::stub_factory void   
 

Returns a pointer to the Stub factory.

Definition at line 1269 of file ORB_Core.cpp.

References TAO_ORB_Core_Static_Resources::instance, stub_factory_, and TAO_ORB_Core_Static_Resources::stub_factory_name_.

Referenced by create_stub.

01270 {
01271   // Check if there is a cached reference.
01272   if (this->stub_factory_ != 0)
01273     return this->stub_factory_;
01274 
01275   // If not, look in the service repository for an instance.
01276   this->stub_factory_ =
01277     ACE_Dynamic_Service<TAO_Stub_Factory>::instance
01278     (TAO_ORB_Core_Static_Resources::instance ()->stub_factory_name_.c_str());
01279 
01280   return this->stub_factory_;
01281 }

CORBA::Policy_ptr TAO_ORB_Core::stubless_connection_timeout void   
 

Access to the connection timeout policy set on the thread or on the ORB. In this method, we do not consider the stub since we do not have access to it.

Definition at line 2652 of file ORB_Core.cpp.

References CORBA::Policy_var::_retn, default_policies_, TAO_Policy_Set::get_cached_policy, TAO_Policy_Manager::get_cached_policy, TAO_Policy_Current::get_cached_policy, CORBA::Policy_var::in, CORBA::is_nil, policy_current, policy_manager, and TAO_CACHED_POLICY_CONNECTION_TIMEOUT.

02653 {
02654   CORBA::Policy_var result;
02655 
02656 #if (TAO_HAS_CORBA_MESSAGING == 1 \
02657      && TAO_HAS_CONNECTION_TIMEOUT_POLICY == 1)
02658 
02659   // No need to lock, the object is in TSS storage....
02660   TAO_Policy_Current &policy_current =
02661     this->policy_current ();
02662   result = policy_current.get_cached_policy (
02663              TAO_CACHED_POLICY_CONNECTION_TIMEOUT);
02664 
02665   // @@ Must lock, but is is harder to implement than just modifying
02666   //    this call: the ORB does take a lock to modify the policy
02667   //    manager
02668   if (CORBA::is_nil (result.in ()))
02669     {
02670       TAO_Policy_Manager *policy_manager =
02671         this->policy_manager ();
02672       if (policy_manager != 0)
02673         result = policy_manager->get_cached_policy (
02674           TAO_CACHED_POLICY_CONNECTION_TIMEOUT);
02675     }
02676 
02677   if (CORBA::is_nil (result.in ()))
02678     result = this->default_policies_->get_cached_policy (
02679                TAO_CACHED_POLICY_CONNECTION_TIMEOUT);
02680 
02681 #endif /* TAO_HAS_CORBA_MESSAGING == 1
02682           && TAO_HAS_CONNECTION_TIMEOUT_POLICY == 1 */
02683 
02684   return result._retn ();
02685 }

CORBA::Policy_ptr TAO_ORB_Core::stubless_relative_roundtrip_timeout void   
 

Access to the RoundtripTimeoutPolicy policy set on the thread or on the ORB. In this method, we do not consider the stub since we do not have access to it.

Definition at line 2592 of file ORB_Core.cpp.

References CORBA::Policy_var::_retn, default_policies_, TAO_Policy_Set::get_cached_policy, TAO_Policy_Manager::get_cached_policy, TAO_Policy_Current::get_cached_policy, CORBA::Policy_var::in, CORBA::is_nil, policy_current, policy_manager, and TAO_CACHED_POLICY_RELATIVE_ROUNDTRIP_TIMEOUT.

02593 {
02594   CORBA::Policy_var result;
02595 
02596 #if (TAO_HAS_CORBA_MESSAGING == 1 \
02597      && TAO_HAS_RELATIVE_ROUNDTRIP_TIMEOUT_POLICY == 1)
02598 
02599   // No need to lock, the object is in TSS storage....
02600   TAO_Policy_Current &policy_current =
02601     this->policy_current ();
02602   result = policy_current.get_cached_policy (
02603              TAO_CACHED_POLICY_RELATIVE_ROUNDTRIP_TIMEOUT);
02604 
02605   // @@ Must lock, but is is harder to implement than just modifying
02606   //    this call: the ORB does take a lock to modify the policy
02607   //    manager
02608   if (CORBA::is_nil (result.in ()))
02609     {
02610       TAO_Policy_Manager *policy_manager =
02611         this->policy_manager ();
02612       if (policy_manager != 0)
02613         result = policy_manager->get_cached_policy (
02614           TAO_CACHED_POLICY_RELATIVE_ROUNDTRIP_TIMEOUT);
02615     }
02616 
02617   if (CORBA::is_nil (result.in ()))
02618     result = this->default_policies_->get_cached_policy (
02619                TAO_CACHED_POLICY_RELATIVE_ROUNDTRIP_TIMEOUT);
02620 
02621 #endif /* TAO_HAS_CORBA_MESSAGING == 1
02622           && TAO_HAS_RELATIVE_ROUNDTRIP_TIMEOUT_POLICY == 1 */
02623 
02624   return result._retn ();
02625 }

CORBA::Policy_ptr TAO_ORB_Core::stubless_sync_scope void   
 

Definition at line 2536 of file ORB_Core.cpp.

References CORBA::Policy_var::_retn, default_policies_, TAO_Policy_Set::get_cached_policy, TAO_Policy_Manager::get_cached_policy, TAO_Policy_Current::get_cached_policy, CORBA::Policy_var::in, CORBA::is_nil, policy_current, policy_manager, and TAO_CACHED_POLICY_SYNC_SCOPE.

02537 {
02538   CORBA::Policy_var result;
02539 
02540   // No need to lock, the object is in TSS storage....
02541   TAO_Policy_Current &policy_current =
02542     this->policy_current ();
02543   result = policy_current.get_cached_policy (TAO_CACHED_POLICY_SYNC_SCOPE);
02544 
02545   // @@ Must lock, but is is harder to implement than just modifying
02546   //    this call: the ORB does take a lock to modify the policy
02547   //    manager
02548   if (CORBA::is_nil (result.in ()))
02549     {
02550       TAO_Policy_Manager *policy_manager =
02551         this->policy_manager ();
02552       if (policy_manager != 0)
02553         result = policy_manager->get_cached_policy (
02554                    TAO_CACHED_POLICY_SYNC_SCOPE);
02555     }
02556 
02557   if (CORBA::is_nil (result.in ()))
02558     result = this->default_policies_->get_cached_policy (
02559                TAO_CACHED_POLICY_SYNC_SCOPE);
02560 
02561   return result._retn ();
02562 }

ACE_INLINE ACE_Thread_Manager * TAO_ORB_Core::thr_mgr void   
 

Get the ACE_Thread_Manager.

Definition at line 157 of file ORB_Core.i.

References tm_.

Referenced by fini, and TAO_IIOP_Connector::open.

00158 {
00159   return &this->tm_;
00160 }

TAO_Thread_Lane_Resources_Manager & TAO_ORB_Core::thread_lane_resources_manager void   
 

Returns a pointer to the Thread Lane Resources Manager.

Definition at line 1236 of file ORB_Core.cpp.

References TAO_Thread_Lane_Resources_Manager_Factory::create_thread_lane_resources_manager, TAO_ORB_Core_Static_Resources::instance, thread_lane_resources_manager_, and TAO_ORB_Core_Static_Resources::thread_lane_resources_manager_factory_name_.

Referenced by is_collocated, lane_resources, and lf_strategy.

01237 {
01238   // Check if there is a cached reference.
01239   if (this->thread_lane_resources_manager_ != 0)
01240     return *this->thread_lane_resources_manager_;
01241 
01242   // If not, lookup the corresponding factory and ask it to make one.
01243   TAO_Thread_Lane_Resources_Manager_Factory *factory =
01244     ACE_Dynamic_Service<TAO_Thread_Lane_Resources_Manager_Factory>::instance
01245     (TAO_ORB_Core_Static_Resources::instance ()->thread_lane_resources_manager_factory_name_.c_str());
01246 
01247   this->thread_lane_resources_manager_ =
01248     factory->create_thread_lane_resources_manager (*this);
01249 
01250   return *this->thread_lane_resources_manager_;
01251 }

ACE_INLINE int TAO_ORB_Core::thread_per_connection_timeout ACE_Time_Value   timeout const
 

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

Definition at line 351 of file ORB_Core.i.

References thread_per_connection_timeout_, and thread_per_connection_use_timeout_.

Referenced by TAO_Connection_Handler::svc_i.

00352 {
00353   timeout = this->thread_per_connection_timeout_;
00354   return this->thread_per_connection_use_timeout_;
00355 }

ACE_Char_Codeset_Translator* TAO_ORB_Core::to_iso8859 void    const
 

Convert from the native character set to ISO8859.

ACE_WChar_Codeset_Translator* TAO_ORB_Core::to_unicode void    const
 

Convert from the native wide character set to UNICODE.

TAO_Transport_Cache_Manager* TAO_ORB_Core::transport_cache void   
 

Return the underlying transport cache.

ACE_Allocator * TAO_ORB_Core::transport_message_buffer_allocator void   
 

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

Definition at line 2314 of file ORB_Core.cpp.

References lane_resources, and TAO_Thread_Lane_Resources::transport_message_buffer_allocator.

Referenced by TAO_Transport::notify_reactor.

02315 {
02316   return this->lane_resources ().transport_message_buffer_allocator ();
02317 }

ACE_INLINE TAO_Transport_Sync_Strategy & TAO_ORB_Core::transport_sync_strategy void   
 

This strategy will sync with the transport.

Definition at line 458 of file ORB_Core.i.

References transport_sync_strategy_.

Referenced by get_sync_strategy.

00459 {
00460   return *this->transport_sync_strategy_;
00461 }

ACE_INLINE TAO_Cleanup_Func_Registry * TAO_ORB_Core::tss_cleanup_funcs void   
 

Return the underlying TSS cleanup function registry.

Definition at line 324 of file ORB_Core.i.

References tss_cleanup_funcs_.

00325 {
00326   return &(this->tss_cleanup_funcs_);
00327 }

const char * TAO_ORB_Core::typecodefactory_adapter_name void    [static]
 

Gets the value of TAO_ORB_Core::typecodefactory_adapter_name_.

Definition at line 1215 of file ORB_Core.cpp.

References TAO_ORB_Core_Static_Resources::instance, and TAO_ORB_Core_Static_Resources::typecodefactory_adapter_name_.

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

Sets the value of TAO_ORB_Core::typecodefactory_adapter_name_.

Definition at line 1209 of file ORB_Core.cpp.

References TAO_ORB_Core_Static_Resources::instance, and TAO_ORB_Core_Static_Resources::typecodefactory_adapter_name_.

Referenced by CORBA_ORB::create_abstract_interface_tc, CORBA_ORB::create_alias_tc, CORBA_ORB::create_array_tc, CORBA_ORB::create_fixed_tc, CORBA_ORB::create_interface_tc, CORBA_ORB::create_native_tc, CORBA_ORB::create_recursive_tc, CORBA_ORB::create_sequence_tc, CORBA_ORB::create_string_tc, CORBA_ORB::create_value_box_tc, and CORBA_ORB::create_wstring_tc.

ACE_INLINE CORBA::Boolean TAO_ORB_Core::use_global_collocation void    const
 

Definition at line 199 of file ORB_Core.i.

References use_global_collocation_.

00200 {
00201   return this->use_global_collocation_;
00202 }

ACE_INLINE void TAO_ORB_Core::use_global_collocation CORBA::Boolean    opt
 

Definition at line 193 of file ORB_Core.i.

References use_global_collocation_.

Referenced by create_collocated_object.

00194 {
00195   this->use_global_collocation_ = opt;
00196 }


Friends And Related Function Documentation

CORBA::ORB_ptr CORBA::ORB_init int &   ,
char *    argv[],
const char *   ,
CORBA_Environment  
[friend]
 

friend class TAO_ORB_Core_Auto_Ptr [friend]
 

Definition at line 194 of file ORB_Core.h.

friend class TAO_ORB_Table [friend]
 

Definition at line 195 of file ORB_Core.h.


Member Data Documentation

TAO_Adapter_Registry TAO_ORB_Core::adapter_registry_ [protected]
 

The list of Adapters used in this ORB.

Definition at line 1159 of file ORB_Core.h.

Referenced by adapter_registry, poa_adapter, resolve_ior_table_i, and root_poa.

TAO_BiDir_Adapter* TAO_ORB_Core::bidir_adapter_ [protected]
 

BiDirectional GIOP factory.

Definition at line 1241 of file ORB_Core.h.

Referenced by bidirectional_giop_init, and load_policy_validators.

CORBA::Boolean TAO_ORB_Core::bidir_giop_policy_ [protected]
 

Bir Dir GIOP policy value.

Definition at line 1244 of file ORB_Core.h.

Referenced by bidir_giop_policy.

TAO_Client_Strategy_Factory* TAO_ORB_Core::client_factory_ [protected]
 

Handle to the factory for Client-side strategies.

Definition at line 1106 of file ORB_Core.h.

Referenced by client_factory.

TAO_ClientRequestInterceptor_List TAO_ORB_Core::client_request_interceptors_ [protected]
 

Client request interceptor registry.

Definition at line 1228 of file ORB_Core.h.

TAO_Codeset_Manager* TAO_ORB_Core::codeset_manager_ [protected]
 

Code Set Manager.

Definition at line 1250 of file ORB_Core.h.

Referenced by codeset_manager.

TAO_Collocation_Resolver* TAO_ORB_Core::collocation_resolver_ [protected]
 

Definition at line 1025 of file ORB_Core.h.

Referenced by collocation_resolver.

CORBA::ULong TAO_ORB_Core::collocation_strategy_ [protected]
 

Default collocation policy. This should never be ORB_CONTROL.

Definition at line 1130 of file ORB_Core.h.

Referenced by get_collocation_strategy.

ACE_Lock_Adapter<TAO_SYNCH_MUTEX> TAO_ORB_Core::data_block_lock_ [protected]
 

The data block reference counts are locked using this mutex.

Definition at line 1168 of file ORB_Core.h.

Referenced by create_input_cdr_data_block, and locking_strategy.

TAO_Policy_Set* TAO_ORB_Core::default_policies_ [protected]
 

The default policies.

Definition at line 1139 of file ORB_Core.h.

Referenced by default_buffering_constraint, stubless_connection_timeout, stubless_relative_roundtrip_timeout, stubless_sync_scope, and ~TAO_ORB_Core.

TAO_Delayed_Buffering_Sync_Strategy* TAO_ORB_Core::delayed_buffering_sync_strategy_ [protected]
 

This strategy will buffer messages.

Definition at line 1204 of file ORB_Core.h.

Referenced by ~TAO_ORB_Core.

CORBA::Object_ptr TAO_ORB_Core::dynany_factory_ [protected]
 

The cached object reference for the DynAnyFactory.

Definition at line 1042 of file ORB_Core.h.

Referenced by resolve_dynanyfactory_i.

TAO_Eager_Buffering_Sync_Strategy* TAO_ORB_Core::eager_buffering_sync_strategy_ [protected]
 

This strategy will buffer messages.

Definition at line 1201 of file ORB_Core.h.

Referenced by ~TAO_ORB_Core.

TAO_Endpoint_Selector_Factory* TAO_ORB_Core::endpoint_selector_factory_ [protected]
 

Definition at line 1196 of file ORB_Core.h.

Referenced by endpoint_selector_factory.

TAO_Flushing_Strategy* TAO_ORB_Core::flushing_strategy_ [protected]
 

Hold the flushing strategy.

Definition at line 1247 of file ORB_Core.h.

Referenced by flushing_strategy, and ~TAO_ORB_Core.

TAO_Fault_Tolerance_Service TAO_ORB_Core::ft_service_ [protected]
 

Fault Tolerant service hook.

Definition at line 1117 of file ORB_Core.h.

Referenced by fault_tolerance_service, object_is_nil, reset_service_profile_flags, service_profile_reselection, service_profile_selection, service_raise_comm_failure, service_raise_transient_failure, services_callbacks_init, services_log_msg_post_upcall, services_log_msg_pre_upcall, and services_log_msg_rcv.

int TAO_ORB_Core::has_shutdown_ [protected]
 

Flag which denotes that the ORB has been shutdown.

Definition at line 1182 of file ORB_Core.h.

Referenced by has_shutdown.

CORBA::Object_ptr TAO_ORB_Core::implrepo_service_ [protected]
 

The cached IOR for the Implementation Repository.

Definition at line 1033 of file ORB_Core.h.

Referenced by implrepo_service.

InitRefMap TAO_ORB_Core::init_ref_map_ [protected]
 

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

Definition at line 1079 of file ORB_Core.h.

Referenced by init_ref_map, and list_initial_references.

TAO_IORInterceptor_List TAO_ORB_Core::ior_interceptors_ [protected]
 

IOR interceptor registry.

Definition at line 1235 of file ORB_Core.h.

Referenced by add_interceptor, and ior_interceptors.

CORBA::Object_ptr TAO_ORB_Core::ior_manip_factory_ [protected]
 

The cached object reference for the IORManipulataion.

Definition at line 1045 of file ORB_Core.h.

Referenced by resolve_iormanipulation_i.

CORBA::Object_ptr TAO_ORB_Core::ior_table_ [protected]
 

The cached object reference for the IORTable.

Definition at line 1048 of file ORB_Core.h.

Referenced by resolve_ior_table_i.

TAO_SYNCH_MUTEX TAO_ORB_Core::lock_ [protected]
 

Synchronize internal state...

Definition at line 1021 of file ORB_Core.h.

TAO_Object_Ref_Table TAO_ORB_Core::object_ref_table_ [protected]
 

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

Definition at line 1084 of file ORB_Core.h.

Referenced by list_initial_references, and object_ref_table.

int TAO_ORB_Core::open_called_ [protected]
 

Flag which denotes that the open method was called.

Definition at line 1194 of file ORB_Core.h.

TAO_SYNCH_MUTEX TAO_ORB_Core::open_lock_ [protected]
 

Mutual exclusion for calling open.

Definition at line 1191 of file ORB_Core.h.

CORBA::Boolean TAO_ORB_Core::opt_for_collocation_ [protected]
 

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

Definition at line 1123 of file ORB_Core.h.

Referenced by optimize_collocation_objects.

CORBA::ORB_var TAO_ORB_Core::orb_ [protected]
 

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

Definition at line 1064 of file ORB_Core.h.

Referenced by implrepo_service, and orb.

TAO_ORB_Parameters TAO_ORB_Core::orb_params_ [protected]
 

Parameters used by the ORB.

Definition at line 1076 of file ORB_Core.h.

Referenced by orb_params.

TAO_ORB_Core_TSS_Resources TAO_ORB_Core::orb_resources_ [protected]
 

If the resources are per-ORB (as opposed to per-ORB-per-thread) then they are stored here...

Definition at line 1179 of file ORB_Core.h.

char* TAO_ORB_Core::orbid_ [protected]
 

The ORBid for this ORB.

Definition at line 1087 of file ORB_Core.h.

Referenced by fini, and orbid.

TAO_Parser_Registry TAO_ORB_Core::parser_registry_ [protected]
 

The IOR parser registry.

Definition at line 1238 of file ORB_Core.h.

Referenced by 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.

Definition at line 1225 of file ORB_Core.h.

TAO_Adapter* TAO_ORB_Core::poa_adapter_ [protected]
 

An optimization for the POA.

Definition at line 1162 of file ORB_Core.h.

Referenced by poa_adapter.

CORBA::Object_var TAO_ORB_Core::poa_current_ [protected]
 

POA current.

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

Definition at line 1156 of file ORB_Core.h.

Referenced by poa_current.

TAO_Policy_Current* TAO_ORB_Core::policy_current_ [protected]
 

Policy current.

Definition at line 1142 of file ORB_Core.h.

TAO_PolicyFactory_Registry TAO_ORB_Core::policy_factory_registry_ [protected]
 

Registry containing all registered policy factories.

Definition at line 1215 of file ORB_Core.h.

Referenced by policy_factory_registry.

TAO_Policy_Manager* TAO_ORB_Core::policy_manager_ [protected]
 

The Policy_Manager for this ORB.

Definition at line 1136 of file ORB_Core.h.

TAO_POA_PortableGroup_Hooks* TAO_ORB_Core::portable_group_poa_hooks_ [protected]
 

Definition at line 1073 of file ORB_Core.h.

Referenced by portable_group_poa_hooks.

TAO_ProtocolFactorySet* TAO_ORB_Core::protocol_factories_ [protected]
 

Definition at line 1029 of file ORB_Core.h.

TAO_Protocols_Hooks* TAO_ORB_Core::protocols_hooks_
 

Handle to the factory for protocols_hooks_..

Definition at line 634 of file ORB_Core.h.

Referenced by get_protocols_hooks.

CORBA::ULong TAO_ORB_Core::refcount_ [protected]
 

Number of outstanding references to this object.

Definition at line 1212 of file ORB_Core.h.

Referenced by _decr_refcnt, and _incr_refcnt.

TAO_Request_Dispatcher* TAO_ORB_Core::request_dispatcher_ [protected]
 

The request dispatching strategy.

Definition at line 1147 of file ORB_Core.h.

Referenced by request_dispatcher, and ~TAO_ORB_Core.

TAO_Resource_Factory* TAO_ORB_Core::resource_factory_ [protected]
 

Handle to the factory for resource information..

Definition at line 1090 of file ORB_Core.h.

Referenced by resource_factory.

CORBA::Object_var TAO_ORB_Core::root_poa_ [protected]
 

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

Definition at line 1069 of file ORB_Core.h.

Referenced by root_poa.

CORBA::Object_var TAO_ORB_Core::rt_current_ [protected]
 

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

Definition at line 1054 of file ORB_Core.h.

Referenced by resolve_rt_current.

CORBA::Object_var TAO_ORB_Core::rt_orb_ [protected]
 

The cached object reference for the RTCORBA::RTORB.

Definition at line 1051 of file ORB_Core.h.

Referenced by resolve_rt_orb.

TAO_Server_Strategy_Factory* TAO_ORB_Core::server_factory_ [protected]
 

Handle to the factory for Server-side strategies.

Definition at line 1109 of file ORB_Core.h.

Referenced by server_factory.

ACE_CString TAO_ORB_Core::server_id_ [protected]
 

The server_id_ that was passed via -ORBServerId option.

Definition at line 1103 of file ORB_Core.h.

Referenced by server_id.

TAO_ServerRequestInterceptor_List TAO_ORB_Core::server_request_interceptors_ [protected]
 

Server request interceptor registry.

Definition at line 1231 of file ORB_Core.h.

TAO_Stub_Factory* TAO_ORB_Core::stub_factory_ [protected]
 

Definition at line 1027 of file ORB_Core.h.

Referenced by stub_factory.

TAO_Thread_Lane_Resources_Manager* TAO_ORB_Core::thread_lane_resources_manager_ [protected]
 

Definition at line 1023 of file ORB_Core.h.

Referenced by fini, thread_lane_resources_manager, and ~TAO_ORB_Core.

ACE_Time_Value TAO_ORB_Core::thread_per_connection_timeout_ [protected]
 

Definition at line 1187 of file ORB_Core.h.

Referenced by thread_per_connection_timeout.

int TAO_ORB_Core::thread_per_connection_use_timeout_ [protected]
 

Definition at line 1186 of file ORB_Core.h.

Referenced by thread_per_connection_timeout.

ACE_Thread_Manager TAO_ORB_Core::tm_ [protected]
 

The Thread Manager.

Definition at line 1165 of file ORB_Core.h.

Referenced by thr_mgr.

TAO_Transport_Sync_Strategy* TAO_ORB_Core::transport_sync_strategy_ [protected]
 

This strategy will sync with the transport.

Definition at line 1209 of file ORB_Core.h.

Referenced by transport_sync_strategy, and ~TAO_ORB_Core.

TAO_Cleanup_Func_Registry TAO_ORB_Core::tss_cleanup_funcs_ [protected]
 

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

Definition at line 1172 of file ORB_Core.h.

Referenced by add_tss_cleanup_func, set_tss_resource, and tss_cleanup_funcs.

CORBA::Object_ptr TAO_ORB_Core::typecode_factory_ [protected]
 

The cached IOR for the TypeCodeFactory DLL.

Definition at line 1039 of file ORB_Core.h.

Referenced by resolve_typecodefactory_i.

CORBA::Boolean TAO_ORB_Core::use_global_collocation_ [protected]
 

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

Definition at line 1127 of file ORB_Core.h.

Referenced by use_global_collocation.

int TAO_ORB_Core::use_implrepo_ [protected]
 

Flag for whether the implrepo support is enabled or not.

Definition at line 1036 of file ORB_Core.h.

Referenced by implrepo_service.


The documentation for this class was generated from the following files:
Generated on Mon Jun 16 15:30:31 2003 for TAO by doxygen1.2.14 written by Dimitri van Heesch, © 1997-2002