| CORBA::_TAO_ConstructionPolicy_Proxy_Broker | |
| CORBA::_TAO_ConstructionPolicy_Proxy_Impl | |
| CORBA::_TAO_ConstructionPolicy_Remote_Proxy_Broker | |
| CORBA::_TAO_ConstructionPolicy_Remote_Proxy_Impl | |
| CORBA::_TAO_DomainManager_Proxy_Broker | |
| CORBA::_TAO_DomainManager_Proxy_Impl | |
| CORBA::_TAO_DomainManager_Remote_Proxy_Broker | |
| CORBA::_TAO_DomainManager_Remote_Proxy_Impl | |
| CORBA::_TAO_Policy_Proxy_Broker | |
| CORBA::_TAO_Policy_Proxy_Impl | |
| CORBA::_TAO_Policy_Remote_Proxy_Broker | |
| CORBA::_TAO_Policy_Remote_Proxy_Impl | |
| CORBA::_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList | |
| CORBA::_TAO_Unbounded_Object_Sequence_CORBA_PolicyList | |
| Dynamic::_TAO_Unbounded_Object_Sequence_Dynamic_ExceptionList | |
| CORBA::_TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq | |
| Dynamic::_TAO_Unbounded_Sequence_Dynamic_ParameterList | |
| IIOP::_TAO_Unbounded_Sequence_IIOP_ListenPointList | |
| IOP::_TAO_Unbounded_Sequence_IOP_MultipleComponentProfile | |
| IOP::_TAO_Unbounded_Sequence_IOP_ServiceContextList | |
| IOP::_TAO_Unbounded_Sequence_IOP_TaggedComponentList | |
| IOP::_TAO_Unbounded_Sequence_IOP_TaggedComponentSeq | |
| Messaging::_TAO_Unbounded_Sequence_Messaging_PolicyValueSeq | |
| _TAO_Unbounded_Sequence_TAO_IIOPEndpointSequence | |
| PortableInterceptor::_TAO_Unbounded_Valuetype_Sequence_PortableInterceptor_ObjectReferenceTemplateSeq | |
| IIOP::BiDirIIOPServiceContext | |
| IIOP::BiDirIIOPServiceContext_out | |
| IIOP::BiDirIIOPServiceContext_var | |
| CORBA::Bounds | UserException for NVList::item() |
| TAO::BufferingConstraint | |
| TAO::BufferingConstraint_var | |
| TAO::BufferingConstraintPolicy | |
| TAO::BufferingConstraintPolicy_out | |
| TAO::BufferingConstraintPolicy_var | |
| PortableInterceptor::ClientRequestInfo | |
| PortableInterceptor::ClientRequestInfo_out | |
| PortableInterceptor::ClientRequestInfo_var | |
| PortableInterceptor::ClientRequestInterceptor | |
| PortableInterceptor::ClientRequestInterceptor_out | |
| PortableInterceptor::ClientRequestInterceptor_var | |
| IOP::Codec | |
| IOP::Codec::FormatMismatch | |
| IOP::Codec::InvalidTypeForEncoding | |
| IOP::Codec::TypeMismatch | |
| IOP::Codec_out | |
| IOP::Codec_var | |
| IOP::CodecFactory | |
| IOP::CodecFactory::UnknownEncoding | |
| IOP::CodecFactory_out | |
| IOP::CodecFactory_var | |
| CONV_FRAME::CodeSetComponent | |
| CONV_FRAME::CodeSetComponent::_tao_seq_CodeSetId | |
| CONV_FRAME::CodeSetComponent::_tao_seq_CodeSetId_out | |
| CONV_FRAME::CodeSetComponent::_tao_seq_CodeSetId_var | |
| CONV_FRAME::CodeSetComponent::_TAO_Unbounded_Sequence_CONV_FRAME_CodeSetComponent__tao_seq_CodeSetId | |
| CONV_FRAME::CodeSetComponent_out | |
| CONV_FRAME::CodeSetComponent_var | |
| CONV_FRAME::CodeSetComponentInfo | |
| CONV_FRAME::CodeSetComponentInfo_out | |
| CONV_FRAME::CodeSetComponentInfo_var | |
| CONV_FRAME::CodeSetContext | |
| CONV_FRAME::CodeSetContext_var | |
| CORBA::ConstructionPolicy | |
| CORBA::ConstructionPolicy_out | |
| CORBA::ConstructionPolicy_var | |
| CORBA_AbstractBase | Abstract base class for Interfaces and Valuetypes |
| CORBA_AbstractBase_out | _out class for AbstractBase |
| CORBA_AbstractBase_var | _var class for AbstractBase |
| CORBA_Any | Class "Any" can wrap values of any type, with the assistance of a TypeCode to describe that type |
| CORBA_Any::to_abstract_base | |
| CORBA_Any::to_object | |
| CORBA_Any::to_value | |
| 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 | Implementation of a CORBA object reference |
| 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_ServiceDetail | |
| CORBA_ServiceDetail::_tao_seq_Octet | |
| CORBA_ServiceDetail::_tao_seq_Octet_out | |
| CORBA_ServiceDetail::_tao_seq_Octet_var | |
| CORBA_ServiceDetail_out | |
| CORBA_ServiceDetail_var | |
| CORBA_ServiceInformation | |
| CORBA_ServiceInformation::_tao_seq_ServiceDetail | |
| CORBA_ServiceInformation::_tao_seq_ServiceDetail_out | |
| CORBA_ServiceInformation::_tao_seq_ServiceDetail_var | |
| CORBA_ServiceInformation::_tao_seq_ServiceOption | |
| CORBA_ServiceInformation::_tao_seq_ServiceOption_out | |
| CORBA_ServiceInformation::_tao_seq_ServiceOption_var | |
| CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail | |
| CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption | |
| CORBA_ServiceInformation_out | |
| CORBA_ServiceInformation_var | |
| 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_ValueBase_out | _out class for ValueBase |
| CORBA_ValueBase_var | _var class for ValueBase |
| CORBA_ValueFactoryBase | |
| CORBA_ValueFactoryBase_var | _var class for 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 | |
| PortableInterceptor::Current | |
| CORBA::Current | |
| PortableInterceptor::Current_out | |
| PortableInterceptor::Current_var | |
| CORBA::DIIPollable | |
| CORBA::DIIPollable_out | |
| CORBA::DIIPollable_var | |
| CORBA::DomainManager | |
| CORBA::DomainManager_out | |
| CORBA::DomainManager_var | |
| CORBA::DomainManagerList | |
| CORBA::DomainManagerList_out | |
| CORBA::DomainManagerList_var | |
| IOP::Encoding | |
| IOP::Encoding_var | |
| Dynamic::ExceptionList | |
| Dynamic::ExceptionList_out | |
| Dynamic::ExceptionList_var | |
| PortableInterceptor::ForwardRequest | |
| PortableInterceptor::Interceptor | |
| PortableInterceptor::Interceptor_out | |
| PortableInterceptor::Interceptor_var | |
| TimeBase::IntervalT | An UTC time interval |
| TimeBase::IntervalT_var | |
| CORBA::InvalidPolicies | |
| CORBA::InvalidPolicies::_tao_seq_UShort | |
| CORBA::InvalidPolicies::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort | |
| PortableInterceptor::InvalidSlot | |
| IOP::IOR | |
| IOP::IOR::_tao_seq_TaggedProfile | |
| IOP::IOR::_TAO_Unbounded_Sequence_IOP_IOR__tao_seq_TaggedProfile | |
| IOP::IOR_out | |
| IOP::IOR_var | |
| GIOP::IORAddressingInfo | |
| GIOP::IORAddressingInfo_out | |
| GIOP::IORAddressingInfo_var | |
| PortableInterceptor::IORInfo | |
| PortableInterceptor::IORInfo_out | |
| PortableInterceptor::IORInfo_var | |
| PortableInterceptor::IORInterceptor | |
| PortableInterceptor::IORInterceptor_out | |
| PortableInterceptor::IORInterceptor_var | |
| IIOP::ListenPoint | |
| IIOP::ListenPoint_out | |
| IIOP::ListenPoint_var | |
| IIOP::ListenPointList | |
| IIOP::ListenPointList_out | |
| IIOP::ListenPointList_var | |
| IOP::MultipleComponentProfile | |
| IOP::MultipleComponentProfile_out | |
| IOP::MultipleComponentProfile_var | |
| CORBA::Object | |
| PortableInterceptor::ObjectReferenceFactory | |
| PortableInterceptor::ObjectReferenceFactory_out | |
| PortableInterceptor::ObjectReferenceFactory_var | |
| PortableInterceptor::ObjectReferenceTemplate | |
| PortableInterceptor::ObjectReferenceTemplate_out | |
| PortableInterceptor::ObjectReferenceTemplate_var | |
| PortableInterceptor::ObjectReferenceTemplateSeq | |
| PortableInterceptor::ObjectReferenceTemplateSeq_out | |
| PortableInterceptor::ObjectReferenceTemplateSeq_var | |
| CORBA::ORB | |
| CORBA::ORB::InvalidName | UserException for resolve_initial_references() |
| PortableInterceptor::ORBInitializer | |
| PortableInterceptor::ORBInitializer_out | |
| PortableInterceptor::ORBInitializer_var | |
| PortableInterceptor::ORBInitInfo | |
| PortableInterceptor::ORBInitInfo::DuplicateName | |
| PortableInterceptor::ORBInitInfo::InvalidName | |
| PortableInterceptor::ORBInitInfo_out | |
| PortableInterceptor::ORBInitInfo_var | |
| Dynamic::Parameter | |
| Dynamic::Parameter_out | |
| Dynamic::Parameter_var | |
| Dynamic::ParameterList | |
| Dynamic::ParameterList_out | |
| Dynamic::ParameterList_var | |
| CORBA::Policy | |
| CORBA::Policy_out | |
| CORBA::Policy_var | |
| CORBA::PolicyCurrent | |
| CORBA::PolicyCurrent_out | |
| CORBA::PolicyCurrent_var | |
| CORBA::PolicyError | |
| PortableInterceptor::PolicyFactory | |
| PortableInterceptor::PolicyFactory_out | |
| PortableInterceptor::PolicyFactory_var | |
| CORBA::PolicyList | |
| CORBA::PolicyList_out | |
| CORBA::PolicyList_var | |
| CORBA::PolicyManager | |
| CORBA::PolicyManager_out | |
| CORBA::PolicyManager_var | |
| CORBA::PolicyTypeSeq | |
| CORBA::PolicyTypeSeq_out | |
| CORBA::PolicyTypeSeq_var | |
| Messaging::PolicyValue | |
| Messaging::PolicyValue::_tao_seq_Octet | |
| Messaging::PolicyValue_out | |
| Messaging::PolicyValue_var | |
| Messaging::PolicyValueSeq | |
| Messaging::PolicyValueSeq_out | |
| Messaging::PolicyValueSeq_var | |
| CORBA::Pollable | |
| CORBA::Pollable_out | |
| CORBA::Pollable_var | |
| CORBA::PollableSet | |
| CORBA::PollableSet::NoPossiblePollable | |
| CORBA::PollableSet::UnknownPollable | |
| CORBA::PollableSet_out | |
| CORBA::PollableSet_var | |
| PortableInterceptor::RequestInfo | |
| PortableInterceptor::RequestInfo_out | |
| PortableInterceptor::RequestInfo_var | |
| PortableInterceptor::ServerRequestInfo | |
| PortableInterceptor::ServerRequestInfo_out | |
| PortableInterceptor::ServerRequestInfo_var | |
| PortableInterceptor::ServerRequestInterceptor | |
| PortableInterceptor::ServerRequestInterceptor_out | |
| PortableInterceptor::ServerRequestInterceptor_var | |
| IOP::ServiceContext | |
| IOP::ServiceContext::_tao_seq_Octet | |
| IOP::ServiceContext_out | |
| IOP::ServiceContext_var | |
| IOP::ServiceContextList | |
| IOP::ServiceContextList_out | |
| IOP::ServiceContextList_var | |
| IOP::TaggedComponent | |
| IOP::TaggedComponent::_tao_seq_Octet | |
| IOP::TaggedComponent_out | |
| IOP::TaggedComponent_var | |
| IOP::TaggedComponentList | |
| IOP::TaggedComponentList_out | |
| IOP::TaggedComponentList_var | |
| IOP::TaggedComponentSeq | |
| IOP::TaggedComponentSeq_out | |
| IOP::TaggedComponentSeq_var | |
| IOP::TaggedProfile | |
| IOP::TaggedProfile::_tao_seq_Octet | |
| IOP::TaggedProfile_out | |
| IOP::TaggedProfile_var | |
| TAO_Abstract_Manager< T, T_var > | Manager for abstract intefaces |
| TAO_Abstract_ServantBase | |
| TAO_Accept_Strategy< SVC_HANDLER, > | |
| TAO_Acceptor | Abstract Acceptor class used for pluggable transports |
| 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_Base | Base class for TAO_Asynch_Reply_Dispatcher and TAO_DII_Deferred_Reply_Dispatcher |
| 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_Blocked_Connect_Strategy | Concrete implementation of a connect strategy that blocks during connects |
| TAO_Bounded_Abstract_Sequence< T, T_var, MAX > | Parametric sequence for types that require managers |
| 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 | Implementation class for TAO-specific 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 | @brief 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 |
| 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_Condition< MUTEX > | Same as to the ACE_Condition variable wrapper |
| TAO_Connect_Concurrency_Strategy< SVC_HANDLER > | Concurrency strategy helper |
| TAO_Connect_Creation_Strategy< SVC_HANDLER > | Creation strategy helper |
| TAO_Connect_Strategy | Define the interface for the connect strategy, i.e. the algorithm that controls how does the ORB establishes remote connections |
| 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 | Default strategy for endpoint selection |
| 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 | This class is a factory whose product is the plain TAO_Stub used by TAO |
| 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 | If the queue is empty the transport will try to send immediately |
| 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 | Description of a single exception |
| TAO_Exceptions | This class is a namespace for exception-related static data and methods |
| TAO_Exclusive_TMS | Using this strategy only one request can be pending at a time in a connection |
| 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 | Hold the relevant information for every type of Locate mesg |
| 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_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 portable interceptor lists |
| 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_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_Connect_Strategy | Concrete implementation of a connect strategy that waits on the leader-follower during asynch connects |
| 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 | This class adds default reference counting to local objects |
| 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_MProfile | This class implements the basic interface for supporting multiple profiles |
| TAO_Muxed_TMS | Using this strategy a single connection can have multiple outstanding requests |
| TAO_New_Leader_Generator | |
| TAO_Notify_Handler | Represents the handler used by the notify calls to the reactor within the ORB |
| 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 | CORBA 2.3: 15.3.4 |
| 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 |
| 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_Connect_Strategy | Concrete implementation of a connect strategy that waits on the reactor during asynch connects |
| TAO_Reactive_Flushing_Strategy | Implement a flushing strategy that uses the reactor |
| TAO_Remote_Object_Proxy_Broker | |
| TAO_Remote_Object_Proxy_Impl | TAO_Remote_Object_Proxy_Impl |
| TAO_Reply_Dispatcher | Different invocation modes process the Reply messages in different ways |
| 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 | Helper class for managing the service context list information |
| 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 | This class is a factory whose product is the plain TAO_Stub used by TAO |
| TAO_Sync_Strategy | The low-level I/O components in the ORB use this strategy to determine when messages must be queued, immediately sent or flushed |
| 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 | Definition for a synchronised refcountable interface |
| 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_Abstract_Sequence< T, T_var > | Parametric sequence for abstract interfaces |
| 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 | Unbounded sequence of strings |
| TAO_Unbounded_Valuetype_Sequence< T, T_var > | Parametric sequence for valuetypes |
| TAO_Unbounded_WString_Sequence | Unbounded sequence of wstrings |
| 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 | Simply block on read() to wait for the reply |
| 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 |
| GIOP::TargetAddress | |
| GIOP::TargetAddress_out | |
| GIOP::TargetAddress_var | |
| TC_Private_State | Private state of the TypeCode |
| TimeBase::UtcT | A timestamp in UTC time |
| TimeBase::UtcT_var | |
| GIOP::Version | |
| GIOP::Version_var | |
| CORBA::WrongTransaction | UserException for DII requests |
