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