TAO  2.1.7
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
[detail level 123]
oNCORBAFUZZ: disable check_for_include/
oNDynamicForward declarations
oNORBThis namespace encapsulates some private behaviors and global data structures used internal to TAO. No application should EVER see them which is why they are not exported
oNstdSTL namespace
oNTAODefine symbolic names for the ORB collocation strategies as used at runtime
oCArray_TraitsSpecialized for each array in generated code
oCIntervalTAn UTC time interval
oCTAO_AcceptorAbstract Acceptor class used for pluggable transports
oCTAO_Acceptor_FilterInterface for mprofile creation strategies
oCTAO_Acceptor_RegistryAcceptor Registry and Generic Acceptor interface definitions. All loaded ESIOP or GIOP acceptor bridges must register with this object
oCTAO_Array_Forany_TParametrized implementation of _forany class for arrays
oCTAO_Array_Out_TParametrized implementation of _out class for arrays
oCTAO_Array_Var_Base_TParametrized implementation of _var base class for arrays
oCTAO_Asynch_Queued_MessageSpecialize TAO_Queued_Message for asynch requests, i.e. oneways sent with SYNC_NONE policy
oCTAO_Asynch_Reply_Dispatcher_BaseBase class for TAO_Asynch_Reply_Dispatcher and TAO_DII_Deferred_Reply_Dispatcher
oCTAO_Auto_ReferenceTAO_Auto_Reference acts as a "smart pointer" for reference-countable instances
oCTAO_Base_Transport_PropertyA concrete implementation for connnection property
oCTAO_Block_Flushing_StrategyImplement a flushing strategy that blocks on write to flush
oCTAO_Blocked_Connect_StrategyConcrete implementation of a connect strategy that blocks during connects
oCTAO_Cleanup_Func_RegistryThis is a helper class that is designed to perform cleanup on thread-specific objects registered in the ORB Core TSS resources by invoking the corresponding cleanup function on each object. Hence, there is a tight coupling between this class and the TAO ORB Core
oCTAO_Client_Strategy_FactoryAbstract factory used by the client to manufacture various strategies used on the client-side
oCTAO_Codeset_ManagerThe encapsulation of logic for codeset negotiation
oCTAO_Codeset_Manager_Factory_BaseBase class for creating instances of the codeset manager
oCTAO_Codeset_ParametersA simple storage class for the native codeset and any translators that must be configured when creating an instance of codeset manager
oCTAO_Codeset_Translator_BaseAbstract base Translator component for interaction with TAO
oCTAO_Collocation_ResolverThis class helps in resolving if a CORBA:Object is collocated
oCTAO_Concurrency_StrategyActivates the Svc_Handler, and then if specified by the TAO_Server_Strategy_Factory, it activates the Svc_Handler to run in its own thread
oCTAO_ConditionSame as to the ACE_Condition variable wrapper
oCTAO_Connect_Concurrency_StrategyConcurrency strategy helper
oCTAO_Connect_Creation_StrategyCreation strategy helper
oCTAO_Connect_StrategyDefine the interface for the connect strategy, i.e. the algorithm that controls how does the ORB establishes remote connections
oCTAO_Connection_Purging_StrategyThe base class for all purging strategies
oCTAO_ConnectorGeneric Connector interface definitions
oCTAO_Connector_RegistryPer-ORB TAO Connector Registry
oCTAO_CORBALOC_ParserImplements the <corbaloc:> IOR format
oCTAO_CORBANAME_ParserImplements the <corbaname:> IOR format
oCTAO_Creation_StrategyCreates a Svc_Handler and set the ORB_Core pointer on it
oCTAO_Default_Client_Strategy_FactoryThis is the "default" client strategy factor for TAO. It includes strategies that are configured through command-line options so that everything operates as if there were no dynamically-linkable strategies
oCTAO_Default_Collocation_ResolverSimple resolver used to decide if a CORBA::Object is collocated
oCTAO_Default_Endpoint_SelectorDefault strategy for endpoint selection
oCTAO_Default_Endpoint_Selector_FactoryFactory for initializing <Endpoint_Selection_State> and obtaining appropriate <Invocation_Endpoint_Selector>
oCTAO_Default_Resource_FactoryTAO's default resource factory
oCTAO_Default_Server_Strategy_FactoryThis is the default strategy factory for CORBA servers. It allows developers to choose strategies via argument flags. This design gives substantial freedom for experimentation
oCTAO_Default_Thread_Lane_Resources_ManagerSimple manager for thread lane resources
oCTAO_Default_Thread_Lane_Resources_Manager_FactoryThis class is a factory for managers of thread resources
oCTAO_DLL_ParserImplment the parser for the DLL-style IORs
oCTAO_EndpointDefines the Endpoint interface in the Pluggable Protocol framework
oCTAO_Endpoint_Selector_FactoryFactory for initializing <Endpoint_Selection_State> and obtaining appropriate <Invocation_Endpoint_Selector>
oCTAO_Event_Handler_Array_varAuto pointer like class for an array of Event Handlers
oCTAO_FILE_ParserImplements the <file:> IOR format
oCTAO_Fixed_Var_TParametrized implementation of _var class for structs, unions, and exceptions with members of fixed size
oCTAO_FixedArray_Var_TParametrized implementation of _var class for arrays with elements of fixed size
oCTAO_FixedSeq_Var_TParametrized implementation of _var class for sequences whose element is of fixed size.
oCTAO_Flushing_StrategyDefine the interface for the flushing strategy, i.e. the algorithm that controls how does the ORB flush outgoing data
oCTAO_GIOP_Fragmenation_StrategyAbstract base class that defines TAO fragmentation strategy interface
oCTAO_GIOP_Locate_Request_HeaderLocation service support
oCTAO_GIOP_Locate_Status_MsgHold the relevant information for every type of Locate msg
oCTAO_GIOP_Message_BaseDefinitions of the GIOP specific stuff
oCTAO_GIOP_Message_Generator_ParserBase class for the GIOP Message generator and parser
oCTAO_GIOP_Message_Generator_Parser_10Implementation for GIOP v1.0
oCTAO_GIOP_Message_Generator_Parser_11Implementation for GIOP v1.1
oCTAO_GIOP_Message_Generator_Parser_12Implementation for GIOP v1.2
oCTAO_GIOP_Message_Generator_Parser_ImplThis class holds all the different GIOP message generators and parsers
oCTAO_GIOP_Message_StateGeneric definitions for Message States
oCTAO_GIOP_Message_VersionMajor and Minor version number of the Inter-ORB Protocol
oCTAO_HR_Time_Policy_StrategyTime policy strategy providing Highres time
oCTAO_HTTP_ClientHTTP_Client is intended to provide application API to classes that wish to do network i/o at a very high level of abstraction
oCTAO_HTTP_ParserImplements the <http:> IOR format
oCTAO_IIOP_Connection_HandlerHandles requests on a single connection
oCTAO_IIOP_ConnectorIIOP-specific Connector bridge for pluggable protocols
oCTAO_IIOP_ProfileThis class defines the protocol specific attributes required for locating ORBs over a TCP/IP network
oCTAO_Incoming_Message_QueueA queue of the messages in the incoming data path
oCTAO_InputCDRA CDR stream for reading, i.e. for demarshalling
oCTAO_Intrusive_Ref_Count_BaseTemplate base class to provide intrusive reference-counting to subclasses. This makes the subclass capable of using a TAO_Intrusive_Ref_Count_Handle<X> class as a smart-pointer to an X object. In this case, X is a sub-class of this class, TAO_Intrusive_Ref_Count_Base<ACE_LOCK>. The ACE_LOCK type is used to protect the atomic reference count data member
oCTAO_Intrusive_Ref_Count_HandleTemplate class for smart-pointer to (intrusively) ref-counted object
oCTAO_Intrusive_Ref_Count_ObjectTemplate class as wrapper of a non reference counted data type but provide intrusive reference-counting feature by inherited from TAO_Intrusive_Ref_Count_Base. This makes the parameterized type data be smart pointer by using a TAO_Intrusive_Ref_Count_Handle<X> to an this wrapper object
oCTAO_Invocation_Endpoint_SelectorDefines the interface for policy-based endpoint selection strategies
oCTAO_IOR_ParserDefines the interface for the pluggable IOR parser components
oCTAO_Leader_Follower_Flushing_StrategyImplement a flushing strategy that uses the Leader/Follower set
oCTAO_LF_CH_EventUse the Leader/Follower loop to wait for one specific event in the invocation path
oCTAO_LF_Connect_StrategyConcrete implementation of a connect strategy that waits on the leader-follower during asynchronous connects
oCTAO_LF_EventUse the Leader/Follower loop to wait for one specific event
oCTAO_LF_Event_BinderImplement an auto_ptr-like class for the TAO_LF_Followers allocated via a TAO_Leader_Follower set
oCTAO_LF_Event_Loop_Thread_HelperHelper class to enter and exit the Leader/Followers event loop
oCTAO_LF_FollowerRepresent a thread blocked, as a follower, in the Leader/Followers set
oCTAO_LF_Follower_Auto_AdderImplement an auto_adder-like class for the TAO_LF_Followers allocated via a TAO_Leader_Follower set
oCTAO_LF_Follower_Auto_PtrImplement an auto_ptr-like class for the TAO_LF_Followers allocated via a TAO_Leader_Follower set
oCTAO_LF_Invocation_EventUse the Leader/Follower loop to wait for one specific event in the invocation path
oCTAO_LF_Multi_EventUse the Leader/Follower loop to wait for one specific event in the invocation path
oCTAO_LF_StrategyStrategize Leader/Follower manipulations in the ORB event loop
oCTAO_LF_Strategy_CompleteA concrete TAO_LF_Strategy for ORB configurations that use the Leader/Followers event loop
oCTAO_LRU_Connection_Purging_StrategyThe Least Recently Used connection purging strategy
oCTAO_MProfileThis class implements the basic interface for supporting multiple profiles
oCTAO_New_Leader_GeneratorClass for creating dynamic threads
oCTAO_Null_Fragmenation_StrategyNull GIOP message fragmentation strategy
oCTAO_Object_LoaderA class to dynamically load object implementations into an ORB
oCTAO_Object_Ref_TableKeep a table de-stringified object references registered with the ORB
oCTAO_Objref_Out_TParametrized implementation of _out class for object references
oCTAO_Objref_Var_TParameterized implementation of _var class for object references
oCTAO_On_Demand_Fragmenation_StrategyOn Demand GIOP message fragmentation strategy
oCTAO_Operation_DetailsClass with operation details
oCTAO_ORB_CoreEncapsulates the state of an ORB
oCTAO_ORB_Core_Auto_PtrDefine a TAO_ORB_Core auto_ptr class
oCTAO_ORB_Core_Static_ResourcesThe static (global) resoures of all ORB cores
oCTAO_ORB_Core_TSS_ResourcesThe TSS resoures of an ORB core
oCTAO_ORB_ParametersParameters that are specific to the ORB. These parameters can be for the client, the server, or for both
oCTAO_Out_TParametrized implementation of _out class for structs, unions and exceptions.
oCTAO_OutputCDRA CDR stream for writing, i.e. for marshalling
oCTAO_Parser_RegistryMaintain the collection of known IOR format parsers
oCTAO_Policy_SetThe policy manager implementation
oCTAO_Policy_ValidatorAn abstract class for plugging in different Policy Validator mechanisms
oCTAO_ProfileDefines the Profile interface
oCTAO_Pseudo_Out_TParametrized implementation of _out class for TypeCode, Object, AbstractBase, NamedValue, NVList, Principal, Request, Context, ORB, LocalObject, and Environment
oCTAO_Pseudo_Var_TParametrized implementation of _var class for TypeCode, Object, AbstractBase, NamedValue, NVList, Principal, Request, Context, ORB, LocalObject, and Environment
oCTAO_Queued_DataRepresents a node in the queue of incoming messages
oCTAO_Queued_MessageRepresent messages queued in the outgoing data path of the TAO_Transport class
oCTAO_Reactive_Connect_StrategyConcrete implementation of a connect strategy that waits on the reactor during asynch connects
oCTAO_Reactive_Flushing_StrategyImplement a flushing strategy that uses the reactor
oCTAO_Request_DispatcherA class that strategizes the request dispatching procedure
oCTAO_Resource_FactoryFactory which manufacturers resources for use by the ORB Core
oCTAO_Resume_HandleA utility class that helps in resuming handlers if TAO uses a TP Reactor from ACE
oCTAO_RSF_Timer_Queue_PtrA simple auto_ptr like class to manage timer queues dynamically allocated by a time policy
oCTAO_Seq_Out_TParametrized implementation of _out class for sequences
oCTAO_Seq_Var_Base_TParametrized implementation of _var base class for sequences
oCTAO_Server_Strategy_FactoryBase class for the server's abstract factory that manufactures various strategies of special utility to it. This simply serves as an interface to a subclass that REALLY gets specified and loaded by the Service Configurator
oCTAO_ServerRequestClass representing a ServerRequest object
oCTAO_Service_CallbacksAn Abstract Base class for the hooks in the ORB
oCTAO_Service_ContextHelper class for managing the service context list information
oCTAO_Services_ActivateA class to dynamically load callback implementations in to an ORB
oCTAO_SingletonTAO-specific Singleton class
oCTAO_Singleton_ManagerManager for TAO library services and singleton cleanup
oCTAO_Stub_Auto_PtrImplements the draft C++ standard auto_ptr abstraction. This class allows one to work Stub Objects Only!
oCTAO_Synch_Queued_MessageSpecialize TAO_Queued_Message for synchronous requests, i.e. twoways and oneways sent with reliability better than SYNC_NONE
oCTAO_Synch_Reply_DispatcherReply dispatcher for Synchronous Method Invocation (SMI)s
oCTAO_System_Time_Policy_StrategyTime policy strategy providing Highres time
oCTAO_Tagged_ComponentsThe policy manager implementation
oCTAO_Tagged_ProfileThis class is used to manipulate and access the target address field of a GIOP 1.2 request
oCTAO_Target_SpecificationA class to encapsulate all the ways of specifying targets
oCTAO_Thread_Lane_ResourcesClass representing a thread lane's resources
oCTAO_Thread_Lane_Resources_ManagerThis class is a manager for thread resources
oCTAO_Thread_Lane_Resources_Manager_FactoryThis class is a factory for managers of thread resources
oCTAO_Thread_Per_Connection_HandlerDefinition for the thread-per-connection strategy
oCTAO_Time_Policy_StrategyAbstract base class for time policy strategy services
oCTAO_TransportGeneric definitions for the Transport class
oCTAO_Transport_Descriptor_InterfaceAn abstract base class for Transport Property
oCTAO_Transport_Mux_StrategyStrategy to determine whether the connection should be multiplexed for multiple requests or it is exclusive for a single request at a time
oCTAO_Transport_TimerAllows TAO_Transport instances to receive timeout notifications from the Reactor. In other words, implements the Adapter Role, of the Adapter Pattern, where the Adaptee is a TAO_Transport and the client is the Reactor
oCTAO_TSS_ResourcesThe TSS resoures shared by all the ORBs
oCTAO_TSS_SingletonTAO-specific Singleton class
oCTAO_Unknown_ProfileA TAO_Profile class to handle foreign profiles
oCTAO_Var_Base_TParametrized implementation of _var base class for structs, unions and exceptions
oCTAO_Var_Var_TParametrized implementation of _var class for structs, unions, and exceptions with members of variable size
oCTAO_VarArray_Var_TParametrized implementation of _var class for arrays with elements of variable size
oCTAO_VarSeq_Var_TParametrized implementation of _var class for sequences whose element is of variable size.
oCTAO_Wait_On_Leader_FollowerWait according to the Leader-Follower model. Leader does the event loop of the Reactor and the Followers wait on the condition variable
oCTAO_Wait_On_LF_No_UpcallWait according to the Leader-Follower model (like TAO_Wait_On_Leader_Follower), but do not allow nested upcalls
oCTAO_Wait_StrategyStrategy for waiting for the reply
oCTime_Policy_ManagerManager service for time policy strategy services
\CUtcTA timestamp in UTC time