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

# TAO Compound List

Here are the classes, structs, unions and interfaces with brief descriptions:

_TAO_Unbounded_Sequence_TAO_IIOPEndpointSequence |
IIOP::BiDirIIOPServiceContext |
CORBA::Bounds | UserException for NVList::item()
TAO::BufferingConstraint |
TAO::BufferingConstraintPolicy |
PortableInterceptor::ClientRequestInfo |
PortableInterceptor::ClientRequestInterceptor |
IOP::Codec |
IOP::Codec::FormatMismatch |
IOP::Codec::InvalidTypeForEncoding |
IOP::Codec::TypeMismatch |
IOP::CodecFactory |
IOP::CodecFactory::UnknownEncoding |
CONV_FRAME::CodeSetComponent |
CONV_FRAME::CodeSetComponentInfo |
CONV_FRAME::CodeSetContext |
CORBA::ConstructionPolicy |
CORBA_Any | Class "Any" can wrap values of any type, with the assistance of a TypeCode to describe that type
CORBA_Any::to_object |
CORBA_Any_out | CORBA_Any_out
CORBA_Any_var | Provide for automatic storage deallocation on going out of scope
CORBA_Current |
CORBA_Current_out |
CORBA_Current_var |
CORBA_DefaultValueRefCountBase | Default mix-in for reference count of a valuetype
CORBA_Environment | CORBA_Environment
CORBA_Environment_out | CORBA_Environment_out
CORBA_Environment_var | CORBA_Environment_var
CORBA_Exception | CORBA_Exception
CORBA_LocalObject |
CORBA_LocalObject_out |
CORBA_LocalObject_var |
CORBA_NamedValue | NamedValue ... these occur only in "NVList" (named value list) data structures. The binary form of the data structure is frozen and visible to programs using it (e.g. from C). The C++ class supports some programming discipline, e.g. to avoid memory leaks. They just represent parameters to calls. The name is optional, and the value is packaged as an Any. The flags indicate parameter mode, and some ownership rules for "top level" memory
CORBA_NamedValue_out | The T_out class for NamedValue
CORBA_NamedValue_var | The T_var class for NamedValue
CORBA_NVList | NVList ... this is used in the (client side) DII (Dynamic Invocation Interface) to hold parameters, except for the return parameter. It's used in the same role in the (server side) DSI (Dynamic Skeleton Interface)
CORBA_NVList_out | The T_out class for NVList
CORBA_NVList_var | The T_var class for NVList
CORBA_Object |
CORBA_Object_out |
CORBA_Object_var |
CORBA_OctetSeq |
CORBA_OctetSeq_out |
CORBA_OctetSeq_var |
CORBA_ORB | ORB pseudo-objref
CORBA_ORB::InvalidName |
CORBA_ORB_ObjectIdList |
CORBA_ORB_ObjectIdList_out |
CORBA_ORB_ObjectIdList_var |
CORBA_ORB_out |
CORBA_ORB_var |
CORBA_Principal | A "Principal" identifies an authenticated entity in the network administration framework. Identities are used to control acccess (authorization) as well as in audit trails (accountability)
CORBA_Principal_out | The T_out class for Principal
CORBA_Principal_var | The T_var class for Principal
CORBA_String_out | CORBA_String_out
CORBA_String_var | CORBA_String var class. Provides automatic deallocation of storage for the string once it goes out of scope
CORBA_StringSeq |
CORBA_StringSeq_out |
CORBA_StringSeq_var |
CORBA_SystemException | CORBA_SystemException
CORBA_TypeCode | The CORBA TypeCode class. It maintains the in-memory representation of any OMG CORBA IDL data type
CORBA_TypeCode::BadKind |
CORBA_TypeCode::Bounds |
CORBA_TypeCode_out | The _out class for TypeCode
CORBA_TypeCode_var | A smart pointer for TypeCodes
CORBA_UserException | User exceptions are those defined by application developers using OMG-IDL
CORBA_ValueBase | Abstract baseclass for Valuetypes (see CORBA 2.3 20.17.5)
CORBA_ValueFactoryBase |
CORBA_WString_out | CORBA_WString_out
CORBA_WString_var | CORBA_WString var class. Provides automatic deallocation of storage for wide strings
CORBA_WStringSeq |
CORBA_WStringSeq_out |
CORBA_WStringSeq_var |
CORBA::Current |
PortableInterceptor::Current |
CORBA::DIIPollable |
CORBA::DomainManager |
IOP::Encoding |
Messaging::ExceptionHolder |
PortableInterceptor::ForwardRequest |
PortableInterceptor::Interceptor |
TimeBase::IntervalT | An UTC time interval
CORBA::InvalidPolicies |
PortableInterceptor::InvalidSlot |
IOP::IOR |
GIOP::IORAddressingInfo |
PortableInterceptor::IORInfo |
PortableInterceptor::IORInterceptor |
IIOP::ListenPoint |
Messaging::MaxHopsPolicy |
CORBA::Object |
PortableInterceptor::ObjectReferenceFactory |
PortableInterceptor::ObjectReferenceTemplate |
CORBA::ORB |
CORBA::ORB::InvalidName | UserException for resolve_initial_references()
PortableInterceptor::ORBInitializer |
PortableInterceptor::ORBInitInfo |
PortableInterceptor::ORBInitInfo::DuplicateName |
PortableInterceptor::ORBInitInfo::InvalidName |
Dynamic::Parameter |
CORBA::Policy |
CORBA::PolicyCurrent |
CORBA::PolicyError |
PortableInterceptor::PolicyFactory |
CORBA::PolicyManager |
Messaging::PolicyValue |
CORBA::Pollable |
CORBA::PollableSet |
CORBA::PollableSet::NoPossiblePollable |
CORBA::PollableSet::UnknownPollable |
Messaging::PriorityRange |
Messaging::QueueOrderPolicy |
Messaging::RebindPolicy |
Messaging::RelativeRequestTimeoutPolicy |
Messaging::RelativeRoundtripTimeoutPolicy |
Messaging::ReplyEndTimePolicy |
Messaging::ReplyHandler |
Messaging::ReplyPriorityPolicy |
Messaging::ReplyStartTimePolicy |
Messaging::RequestEndTimePolicy |
PortableInterceptor::RequestInfo |
Messaging::RequestPriorityPolicy |
Messaging::RequestStartTimePolicy |
Messaging::RoutingPolicy |
Messaging::RoutingTypeRange |
PortableInterceptor::ServerRequestInfo |
PortableInterceptor::ServerRequestInterceptor |
Service_Context | Helper class for managing the service context list information
IOP::ServiceContext |
Messaging::SyncScopePolicy |
IOP::TaggedComponent |
IOP::TaggedProfile |
TAO_Abstract_ServantBase |
TAO_Accept_Strategy< SVC_HANDLER, > |
TAO_Acceptor | Abstract Acceptor class used for pluggable protocols
TAO_Acceptor_Filter | Interface for mprofile creation strategies
TAO_Acceptor_Registry | Acceptor Registry and Generic Acceptor interface definitions. All loaded ESIOP or GIOP acceptor bridges must register with this object
TAO_Adapter |
TAO_Adapter_Factory |
TAO_Adapter_Registry |
TAO_Asynch_Queued_Message | Specialize TAO_Queued_Message for asynch requests, i.e. oneways sent with SYNC_NONE policy
TAO_Asynch_Reply_Dispatcher | Reply dispatcher for Asynchoronous Method Invocation (AMI)s
TAO_Asynch_Reply_Dispatcher_Base | Base class for TAO_Asynch_Reply_Dispatcher and TAO_DII_Deferred_Reply_Dispatcher
TAO_Asynch_Timeout_Handler |
TAO_Base_Sequence | Base class for TAO sequences
TAO_Base_Transport_Property | A concrete implementation for connnection property
TAO_Base_var | TAO_Base_var
TAO_BiDir_Adapter | TAO_BiDir_Adapter
TAO_Bind_Dispatcher_Guard |
TAO_Block_Flushing_Strategy | Implement a flushing strategy that blocks on write to flush
TAO_Bounded_Array_Sequence< T, T_var, MAX > | Bounded version of TAO_Unbounded_Array_Sequence
TAO_Bounded_Base_Sequence | Base class for all bounded sequences
TAO_Bounded_Object_Sequence< T, T_var, MAX > | Parametric sequence for types that require managers
TAO_Bounded_Pseudo_Sequence< T, T_var, MAX > | Bounded version of TAO_Unbounded_Pseudo_Sequence
TAO_Bounded_Sequence< T, MAX > | Parametric bounded sequence
TAO_Bounded_String_Sequence< MAX > | Bounded sequence of strings
TAO_Bounded_Valuetype_Sequence< T, T_var, MAX > | Parametric sequence for types that require managers
TAO_Bounded_WString_Sequence< MAX > | Bounded sequence of wstrings
TAO_Buffering_Constraint_Policy |
TAO_Cache_ExtId | Helper class for TAO_Transport_Cache_Manager: unifies several data items, so they can be stored together as a <value> for a <key> in a hash table holding the state of the Transport Cache
TAO_Cache_IntId | Helper class for TAO_Transport_Cache_Manager
TAO_CDR_Encaps_Codec | Implementation of a CDR encapsulation coder/decoder (Codec)
TAO_Cleanup_Func_Registry | This 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
TAO_Client_Strategy_Factory | Abstract factory used by the client to manufacture various strategies used on the client-side
TAO_ClientRequestInfo | Implementation of the PortableInterceptor::ClientRequestInfo interface
TAO_ClientRequestInfo_CORBA_Policy_copy |
TAO_ClientRequestInfo_CORBA_Policy_destroy |
TAO_ClientRequestInfo_Guard | Guard for exception safe TAO_ClientRequestInfo_i pointer swapping
TAO_ClientRequestInfo_i | Implementation of the PortableInterceptor::ClientRequestInfo interface
TAO_ClientRequestInterceptor_Adapter | A convenient helper class to invoke registered client request interceptors in client stubs
TAO_ClientRequestInterceptor_List | Encapsulation for a list of client request interceptors
TAO_CodecFactory | Implementation of the IOP::CodecFactory interface
TAO_CodecFactory_ORBInitializer | ORBInitializer for the CodecFactory support
TAO_Collocation_Resolver | This class helps in resolving if a CORBA:Object is collocated
TAO_Collocation_Strategies | Define symbolic names for the ORB collocation strategies
TAO_Concurrency_Strategy< SVC_HANDLER > | Activates the Svc_Handler, and then if specified by the TAO_Server_Strategy_Factory, it activates the Svc_Handler to run in its own thread
TAO_Connect_Concurrency_Strategy< SVC_HANDLER > | Concurrency strategy helper
TAO_Connect_Creation_Strategy< SVC_HANDLER > | Creation strategy helper
TAO_Connection_Handler | TAO_Connection_Handler
TAO_Connection_Purging_Strategy | The base class for all purging strategies
TAO_Connector | Generic Connector interface definitions
TAO_Connector_Registry | Per-ORB TAO Connector Registry
TAO_CORBALOC_Parser | Implements the <corbaloc:> IOR format
TAO_CORBANAME_Parser | Implements the <corbaname:> IOR format
TAO_Creation_Strategy< SVC_HANDLER > | Creates a Svc_Handler and set the ORB_Core pointer on it
TAO_Default_Client_Strategy_Factory | This 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
TAO_Default_Collocation_Resolver | Simple resolver used to decide if a CORBA::Object is collocated
TAO_Default_Endpoint_Selector |
TAO_Default_Endpoint_Selector_Factory | Factory for initializing <Endpoint_Selection_State> and obtaining appropriate <Invocation_Endpoint_Selector>
TAO_Default_Protocols_Hooks |
TAO_Default_Resource_Factory | TAO's default resource factory
TAO_Default_Server_Strategy_Factory | This is the default strategy factory for CORBA servers. It allows developers to choose strategies via argument flags. This design gives substantial freedom for experimentation
TAO_Default_Stub_Factory |
TAO_Default_Thread_Lane_Resources_Manager | Simple manager for thread lane resources
TAO_Default_Thread_Lane_Resources_Manager_Factory | This class is a factory for managers of thread resources
TAO_Delayed_Buffering_Sync_Strategy | Delay the buffering decision until the transport blocks
TAO_DLL_ORB | Helper class that initializes an ORB when an instance of this class is dynamically loaded
TAO_DLL_Parser | Implment the parser for the DLL-style IORs
TAO_Dynamic_Adapter | TAO_Dynamic_Adapter
TAO_Eager_Buffering_Sync_Strategy |
TAO_Encodable | TAO_Encodable Interface
TAO_Endpoint | Defines the Endpoint interface in the Pluggable Protocol framework
TAO_Endpoint_Selector_Factory | Factory for initializing <Endpoint_Selection_State> and obtaining appropriate <Invocation_Endpoint_Selector>
TAO_Exception_Data |
TAO_Exceptions | This class is a namespace for exception-related static data and methods
TAO_Exclusive_TMS |
TAO_Fault_Tolerance_Service | TAO_Fault_Tolerant_Service
TAO_FILE_Parser | Implements the <file:> IOR format
TAO_Flushing_Strategy | Define the interface for the flushing strategy, i.e. the algorithm that controls how does the ORB flush outgoing data
TAO_GIOP_Asynch_Invocation | Base class for TAO_GIOP_Twoway_Asynch_Invocation and TAO_GIOP_DII_Deferred_Invocation
TAO_GIOP_Invocation | Encapsulates common behavior for both oneway and twoway invocations
TAO_GIOP_Locate_Request_Header | Location service support
TAO_GIOP_Locate_Request_Invocation | Sends a locate request message
TAO_GIOP_Locate_Status_Msg |
TAO_GIOP_Message_Base | Definitions of the GIOP specific stuff
TAO_GIOP_Message_Generator_Parser | Base class for the GIOP Message generator and parser
TAO_GIOP_Message_Generator_Parser_10 | Implementation for GIOP v1.0
TAO_GIOP_Message_Generator_Parser_11 | Implementation for GIOP v1.1
TAO_GIOP_Message_Generator_Parser_12 | Implementation for GIOP v1.2
TAO_GIOP_Message_Generator_Parser_Impl | This class holds all the different GIOP message generators and parsers
TAO_GIOP_Message_Lite | Definitions of GIOPLite specific stuff
TAO_GIOP_Message_State | Generic definitions for Message States
TAO_GIOP_Message_Version | Major and Minor version number of the Inter-ORB Protocol
TAO_GIOP_Oneway_Invocation | Encapsulate a one-way invocation
TAO_GIOP_ReplyHeader | This class embodies the header of a GIOP reply. @Not used. Could be used in future
TAO_GIOP_Synch_Invocation | TAO_GIOP_Synch_Invocation
TAO_GIOP_Twoway_Asynch_Invocation | Sends a two-way request does not expect the reply. This class connects (or lookups a connection from the cache) to the remote server, builds the CDR stream for the Request, send the CDR stream and returns
TAO_GIOP_Twoway_Invocation | Encapsulate a two-way invocation
TAO_GIOP_Utils | Utility class that has some commonly used methods for both GIOP Base & GIOP lite
TAO_IFR_Client_Adapter | TAO_IFR_Client_Adapter
TAO_IIOP_Acceptor | TAO_IIOP_Acceptor
TAO_IIOP_Connection_Handler | Handles requests on a single connection
TAO_IIOP_Connector | IIOP-specific Connector bridge for pluggable protocols
TAO_IIOP_Endpoint | TAO_IIOP_Endpoint
TAO_IIOP_Endpoint_Info |
TAO_IIOP_Lite_Protocol_Factory |
TAO_IIOP_Profile | This class defines the protocol specific attributes required for locating ORBs over a TCP/IP network
TAO_IIOP_Properties | TCP protocol properties specification for a set of connections
TAO_IIOP_Protocol_Factory |
TAO_IIOP_Transport | Specialization of the base TAO_Transport class to handle the IIOP protocol
TAO_IIOPEndpointSequence |
TAO_IIOPEndpointSequence_var |
TAO_Incoming_Message_Queue | A queue of the messages in the incoming data path
TAO_InputCDR | A CDR stream for reading, i.e. for demarshalling
TAO_Interceptor_List | Base class for the various portable interceptor lists used internally by TAO
TAO_Internal | This class encapsulates some private behaviors and global data structures used internal to TAO. No application should EVER see this class
TAO_Invocation_Endpoint_Selector | Defines the interface for policy-based endpoint selection strategies
TAO_IOP_IOR | InteroperableObjectReference
TAO_IOP_Tagged_Profile | One per protocol
TAO_IOP_TaggedComponent |
TAO_IOR_Parser | Defines the interface for the pluggable IOR parser components
TAO_IORInterceptor_List | Encapsulation for a list of IOR interceptors
TAO_Leader_Follower |
TAO_Leader_Follower_Flushing_Strategy | Implement a flushing strategy that uses the Leader/Follower set
TAO_LF_Client_Leader_Thread_Helper |
TAO_LF_Client_Thread_Helper |
TAO_LF_Event | Use the Leader/Follower loop to wait for one specific event
TAO_LF_Event_Binder | Implement an auto_ptr-like class for the TAO_LF_Followers allocated via a TAO_Leader_Follower set
TAO_LF_Event_Loop_Thread_Helper | Helper class to enter and exit the Leader/Followers event loop
TAO_LF_Follower | Represent a thread blocked, as a follower, in the Leader/Followers set
TAO_LF_Follower_Auto_Adder | Implement an auto_adder-like class for the TAO_LF_Followers allocated via a TAO_Leader_Follower set
TAO_LF_Follower_Auto_Ptr | Implement an auto_ptr-like class for the TAO_LF_Followers allocated via a TAO_Leader_Follower set
TAO_LF_Strategy | Strategize Leader/Follower manipulations in the ORB event loop
TAO_LF_Strategy_Complete | A concrete TAO_LF_Strategy for ORB configurations that use the Leader/Followers event loop
TAO_Local_RefCounted_Object |
TAO_LRU_Connection_Purging_Strategy | The Least Recently Used connection purging strategy
TAO_Marshal_Alias | TAO_Marshal_Alias
TAO_Marshal_Any | TAO_Marshal_Any
TAO_Marshal_Array | TAO_Marshal_Array
TAO_Marshal_Except | TAO_Marshal_Except
TAO_Marshal_Object | TAO_Marshal_Object
TAO_Marshal_ObjRef | TAO_Marshal_ObjRef
TAO_Marshal_Primitive | TAO_Marshal_Primitive
TAO_Marshal_Principal | TAO_Marshal_Principal
TAO_Marshal_Sequence | TAO_Marshal_Sequence
TAO_Marshal_String | TAO_Marshal_String
TAO_Marshal_Struct | TAO_Marshal_Struct
TAO_Marshal_TypeCode | TAO_Marshal_TypeCode
TAO_Marshal_Union | TAO_Marshal_Union
TAO_Marshal_Value | TAO_Marshal_Value
TAO_Marshal_WString | TAO_Marshal_WString
TAO_MCAST_Parser | Implements the <mcast:> IOR format
TAO_Messaging_ORBInitializer | Messaging ORB initializer
TAO_Messaging_PolicyFactory | Policy factory for all Messaging related policies
TAO_MProfile | This class implements the basic interface for supporting multiple profiles
TAO_Muxed_TMS |
TAO_New_Leader_Generator |
TAO_Object_Loader | A class to dynamically load object implementations into an ORB
TAO_Object_Manager< T, T_var > | Manager for Objects
TAO_Object_Proxy_Broker |
TAO_Object_Proxy_Impl | TAO_Object_Proxy_Impl
TAO_Object_Ref_Table | Keep a table de-stringified object references registered with the ORB
TAO_ObjectKey |
TAO_ObjectKey_out |
TAO_ObjectKey_var |
TAO_OBV_GIOP_Flags |
TAO_Operation_Details | Class with operation details
TAO_ORB_Core | Encapsulates the state of an ORB
TAO_ORB_Core_Auto_Ptr | Define a TAO_ORB_Core auto_ptr class
TAO_ORB_Core_TSS_Resources | The TSS resoures of an ORB core
TAO_ORB_Parameters | Parameters that are specific to the ORB. These parameters can be for the client, the server, or for both. = NOTE Some of the functions have inline definitions in the class header below. Please do not move them back to the .i file. cygnus-2.7.2-960126, distributed with Tornado 1.0.1, can't deal with returing a const reference here. It raises an internal compiler error at ace/Svc_Handler.cpp:46, of all places
TAO_ORB_Table | Keep a table with all the ORBs in the system
TAO_ORBInitializer_Registry | Global list that contains all portable interceptor ORB initializers
TAO_ORBInitInfo | An implementation of the PortableInterceptor::ORBInitInfo interface
TAO_ORBInitInfo_var |
TAO_OutputCDR | A CDR stream for writing, i.e. for marshalling
TAO_Parser_Registry | Maintain the collection of known IOR format parsers
TAO_PICurrent | Implementation of the PortableInterceptor::Current interface
TAO_PICurrent_Guard | Class used to make copying between request scope current and thread scope current exception-safe
TAO_PICurrent_Impl | Implementation of the PortableInterceptor::Current interface
TAO_PICurrent_ORBInitializer | ORBInitializer for the PICurrent support
TAO_Pluggable_Messaging | Generic definitions Messaging class
TAO_Pluggable_Reply_Params | TAO_Pluggable_Connector_Params
TAO_Pluggable_Reply_Params_Base | TAO_Pluggable_Acceptor_Params
TAO_Policy_Current |
TAO_Policy_Current_Impl |
TAO_Policy_Manager |
TAO_Policy_Set | The policy manager implementation
TAO_Policy_Validator | An abstract class for plugging in different Policy Validator mechanisms
TAO_PolicyFactory_Registry | ORB-specific registry that contains all portable interceptor policy factories
TAO_Profile | Defines the Profile interface
TAO_Protocol_Factory |
TAO_Protocol_Item |
TAO_Protocols_Hooks |
TAO_Pseudo_Object_Manager< T, T_var > | Manager for Pseudo Objects
TAO_QtResource_Factory | TAO's default resource factory
TAO_Queued_Data | Represents a node in the queue of incoming messages
TAO_Queued_Message | Represent messages queued in the outgoing data path of the TAO_Transport class
TAO_Reactive_Flushing_Strategy | Implement a flushing strategy that uses the reactor
TAO_RelativeRoundtripTimeoutPolicy |
TAO_Remote_Object_Proxy_Broker |
TAO_Remote_Object_Proxy_Impl | TAO_Remote_Object_Proxy_Impl
TAO_Reply_Dispatcher |
TAO_Request_Dispatcher | A class that strategizes the request dispatching procedure
TAO_RequestInfo_Util | Helper class that provides methods useful for both PortableInterceptor::ClientRequestInfo and PortableInterceptor::ServerRequestInfo objects
TAO_Resource_Factory | Factory which manufacturers resources for use by the ORB Core
TAO_Resume_Handle | A utility class that helps in resuming handlers if TAO uses a TP Reactor from ACE
TAO_RT_New_Leader_Generator | Class for creating dynamic threads
TAO_SeqElem_String_Manager | TAO_SeqElem_String_Manager
TAO_SeqElem_WString_Manager | TAO_SeqElem_WString_Manager
TAO_Server_Strategy_Factory | Base 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
TAO_Server_Strategy_Factory::Active_Object_Map_Creation_Parameters |
TAO_ServerRequest | Class representing a ServerRequest object
TAO_ServerRequestInterceptor_List | Encapsulation for a list of server request interceptors
TAO_Service_Callbacks | An Abstract Base class for the hooks in the ORB
TAO_Service_Context |
TAO_Services_Activate | A class to dynamically load callback implementations in to an ORB
TAO_Singleton< TYPE, ACE_LOCK > | TAO-specific Singleton class
TAO_Singleton_Manager | Manager for TAO library services and singleton cleanup
TAO_String_Manager | Manager for strings
TAO_Stub | TAO_Stub
TAO_Stub_Auto_Ptr | Implements the draft C++ standard auto_ptr abstraction. This class allows one to work Stub Objects *Only*!
TAO_Stub_Factory |
TAO_Sync_Scope_Policy |
TAO_Sync_Strategy | Define the interface for the Queueing Strategy
TAO_Synch_Queued_Message | Specialize TAO_Queued_Message for synchronous requests, i.e. twoways and oneways sent with reliability better than SYNC_NONE
TAO_Synch_Refcountable |
TAO_Synch_Reply_Dispatcher | Reply dispatcher for Synchoronous Method Invocation (SMI)s
TAO_Synchronous_Cancellation_Required |
TAO_Tagged_Components | The policy manager implementation
TAO_Tagged_Profile | This class is used to manipulate and access the target address field of a GIOP 1.2 request
TAO_Target_Specification | A class to encapsulate all the ways of specifying targets
TAO_Thread_Lane_Resources | Class representing a thread lane's resources
TAO_Thread_Lane_Resources_Manager | This class is a manager for thread resources
TAO_Thread_Lane_Resources_Manager_Factory | This class is a factory for managers of thread resources
TAO_Transport | Generic definitions for the Transport class
TAO_Transport_Cache_Manager | The Transport Cache Manager for TAO
TAO_Transport_Descriptor_Interface | An abstract base class for Transport Property
TAO_Transport_Mux_Strategy | Strategy to determine whether the connection should be multiplexed for multiple requests or it is exclusive for a single request at a time
TAO_Transport_Sync_Strategy |
TAO_Transport_Timer | Allows 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
TAO_TSS_Resources | The TSS resoures shared by all the ORBs
TAO_TSS_Singleton< TYPE, ACE_LOCK > | TAO-specific Singleton class
TAO_TypeCodeFactory_Adapter | TAO_TypeCodeFactory_Adapter
TAO_TypeCodes | This class is a namespace for TypeCode-related static data that is owned by the ORB
TAO_Unbounded_Array_Sequence< T, T_var > | Parametric sequence for arrays
TAO_Unbounded_Base_Sequence | Base class for all bounded sequences
TAO_Unbounded_Object_Sequence< T, T_var > | Parametric sequence for types that require managers
TAO_Unbounded_Pseudo_Sequence< T, T_var > | Parametric sequence for pseudo objects
TAO_Unbounded_Sequence< T > | Parametrized implementation of IDL unbounded sequences
TAO_Unbounded_Sequence< CORBA::Octet > | An unbounded sequence of Octets
TAO_Unbounded_String_Sequence |
TAO_Unbounded_Valuetype_Sequence< T, T_var > | Parametric sequence for valuetypes
TAO_Unbounded_WString_Sequence |
TAO_Unknown_Profile | A TAO_Profile class to handle foreign profiles
TAO_ValueFactory_Map |
TAO_Valuetype_Manager< T, T_var > | Manager for valuetypes
TAO_Wait_On_Leader_Follower | Wait according to the Leader-Follower model. Leader does the event loop of the Reactor and the Followers wait on the condition variable
TAO_Wait_On_Reactor | Wait on the Reactor. Happens in s Single Threaded client environment
TAO_Wait_On_Read |
TAO_Wait_Strategy | Strategy for waiting for the reply
TAO_WString_Manager | Manager for wide strings
TAO_XT_Resource_Factory | TAO's default resource factory
TC_Private_State | Private state of the TypeCode
TimeBase::UtcT | A timestamp in UTC time
GIOP::Version |
CORBA::WrongTransaction | UserException for DII requests