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:

CORBA::Any | Generic container for IDL types
CORBA::Any::to_abstract_base |
CORBA::Any::to_object | These are not in ACE
CORBA::Any::to_value |
TAO::Any_Array_Impl_T< T_slice, T_forany > | Template Any class for array types
TAO::Any_Basic_Impl | Non-template class for all the basic types
TAO::Any_Basic_Impl_T< T > | Template Any class for basic types
TAO::Any_Dual_Impl_T< T > | Template Any class for IDL types with 2 modes of insertion
TAO::Any_Exception | Template Any class for IDL types with 2 modes of insertion
TAO::Any_Impl | Base class for the Any template subclasses
TAO::Any_Impl_T< T > | Template Any class for pointer types
Any_out | CORBA::Any_out
CORBA::Any_out |
TAO::Any_Special_Impl_T< T, from_T, to_T > | Template Any class for bounded IDL (w)strings
TAO::Any_SystemException |
Any_var | Provide for automatic storage deallocation on going out of scope
CORBA::Any_var |
TAO::ARDB_Refcount_Functor | Functor for refcounting of Asynch_Reply_Dispatcher_Base
TAO::Arg_Traits< T > | Base class for all stub arg traits specializations
TAO::Arg_Traits< ACE_InputCDR::to_boolean > |
TAO::Arg_Traits< ACE_InputCDR::to_char > | Specializations for (w)char, octet and boolean
TAO::Arg_Traits< ACE_InputCDR::to_octet > |
TAO::Arg_Traits< ACE_InputCDR::to_wchar > |
TAO::Arg_Traits< CORBA::Char * > | Specializatons for unbounded (w)strings
TAO::Arg_Traits< CORBA::Double > |
TAO::Arg_Traits< CORBA::Float > |
TAO::Arg_Traits< CORBA::InterfaceDef > |
TAO::Arg_Traits< CORBA::Long > |
TAO::Arg_Traits< CORBA::LongDouble > |
TAO::Arg_Traits< CORBA::LongLong > |
TAO::Arg_Traits< CORBA::Object > |
TAO::Arg_Traits< CORBA::Policy > |
TAO::Arg_Traits< CORBA::Short > | Specializations for basic stub arg types, except (w)char/boolean/octet
TAO::Arg_Traits< CORBA::TypeCode > | Used in generated code if CORBA::TypeCode is an argument or return type
TAO::Arg_Traits< CORBA::ULong > |
TAO::Arg_Traits< CORBA::ULongLong > |
TAO::Arg_Traits< CORBA::UShort > |
TAO::Arg_Traits< CORBA::WChar * > |
TAO::Arg_Traits< void > | Specialization for void return type
TAO::Argument | Base class for template argument classes
TAO::Array_Traits< T, T_slice > | Specialized for each array in generated code
TAO::Utils::Auto_Functor< X, Functor > | Helper template to implement auto_ptr<>-like classes, but executing a functor in the destructor, instead of always deleting things
TAO::Utils::Auto_Functor_Ref< X, Functor > | Helper class to implement assignment and copy-construction as expected
TAO::Basic_Arg_Traits_T< T > | Template class for stub argument traits of basic IDL types
TAO::Basic_SArg_Traits_T< T > | Template class for skeleton argument traits of basic IDL types
TAO::Basic_Tag | Struct for basic IDL type arguments id tag
TAO::BD_String_Arg_Traits< BOUND > | Specializations for bounded (w)strings
TAO::BD_String_Arg_Traits_T< T, T_var, T_out, to_T, from_T, BOUND > |
TAO::BD_String_SArg_Traits_T< T, T_var, T_out, to_T, from_T, BOUND > |
TAO::BD_String_Tag | Struct for bounded (w)string arguments id tag
TAO::BD_StringS_Arg_Traits< BOUND > | Specializations for bounded (w)strings
TAO::BD_WString_Arg_Traits< BOUND > |
TAO::BD_WString_SArg_Traits< BOUND > |
IIOP::BiDirIIOPServiceContext |
CORBA::Bounds |
TAO::BufferingConstraint |
TAO::BufferingConstraintPolicy |
PortableInterceptor::ClientRequestInfo |
PortableInterceptor::ClientRequestInterceptor |
TAO::ClientRequestInterceptor_Adapter | A convenient helper class to invoke registered client request interceptors
IOP::Codec |
IOP::Codec::FormatMismatch |
IOP::Codec::InvalidTypeForEncoding |
IOP::Codec::TypeMismatch |
IOP::CodecFactory |
IOP::CodecFactory::UnknownEncoding |
CONV_FRAME::CodeSetComponent |
CONV_FRAME::CodeSetComponent::_tao_seq_CONV_FRAME_CodeSetId_ |
CONV_FRAME::CodeSetComponentInfo |
CONV_FRAME::CodeSetContext |
TAO::Collocated_Invocation | Class for Collocated invocations
TAO::Collocation_Proxy_Broker |
CORBA::ConstructionPolicy |
PortableInterceptor::Current |
CORBA::Current |
CORBA::DIIPollable |
CORBA::DomainManager |
CORBA::DomainManagerList |
IOP::Encoding |
CORBA::Environment | Environment
CORBA::Exception | Exception
TAO::Exception_Data | Description of a single exception
Dynamic::ExceptionList |
TAO::Fixed_Array_Arg_Traits_T< T, T_slice, T_var, T_forany > | Argument traits of fixed size element array
TAO::Fixed_Array_SArg_Traits_T< T, T_slice, T_var, T_forany > |
TAO::Fixed_Array_Tag | Struct for fixed size element array argument id tag
TAO::Fixed_Size_Arg_Traits_T< T > |
TAO::Fixed_Size_SArg_Traits_T< T > |
TAO::Fixed_Size_Tag |
PortableInterceptor::ForwardRequest |
TAO::IIOP_Endpoint_Info |
TAO::IIOPEndpointSequence |
TAO::In_Basic_Argument_T< S > | Template class for IN stub argument of basic IDL types
TAO::In_Basic_SArgument_T< S > | Template class for IN skeleton argument of basic IDL types
TAO::In_BD_String_Argument_T< S, to_S, from_S, BOUND > | Template class for IN bounded (w)string argument
TAO::In_BD_String_SArgument_T< S, S_var, to_S, from_S, BOUND > | Template class for IN skeleton bd (w)string argument
TAO::In_Fixed_Array_Argument_T< S, S_slice, S_forany > | IN stub argument of fixed size element array
TAO::In_Fixed_Array_SArgument_T< S, S_forany > | IN skeleton argument of fixed size element array
TAO::In_Fixed_Size_Argument_T< S > | Template class for IN stub argument of fixed size IDL types
TAO::In_Fixed_Size_SArgument_T< S > | Template class for IN skeleton argument of fixed size IDL types
TAO::In_Object_Argument_T< S_ptr > | Template class for IN object argument
TAO::In_Object_SArgument_T< S_ptr, S_var > | Template class for IN skeleton object argument
TAO::In_Special_Basic_Argument_T< S, to_S, from_S > | Template class for IN stub argument of (w)char/boolean/octet
TAO::In_Special_Basic_SArgument_T< S, to_S, from_S > | Template class for IN skeleton argument of (w)char/boolean/octet
TAO::In_UB_String_Argument_T< S > | Template class for IN unbounded (w)string argument
TAO::In_UB_String_SArgument_T< S, S_var > | Template class for IN skeleton UB (w)string argument
TAO::In_Var_Array_Argument_T< S, S_slice, S_forany > | IN stub argument of variable size element array
TAO::In_Var_Array_SArgument_T< S, S_forany > | IN skeleton argument of variable size element array
TAO::In_Var_Size_Argument_T< S > | Template class for IN stub argument of fixed size IDL types
TAO::In_Var_Size_SArgument_T< S > | Template class for IN skeleton argument of fixed size IDL types
TAO::Inout_Basic_Argument_T< S > | Template class for INOUT stub argument of basic IDL types
TAO::Inout_Basic_SArgument_T< S > | Template class for INOUT skeleton argument of basic IDL types
TAO::Inout_BD_String_Argument_T< S, to_S, from_S, BOUND > | Template class for INOUT bounded (w)string argument
TAO::Inout_BD_String_SArgument_T< S, S_var, to_S, from_S, BOUND > | Template class for INOUT skeleton bd (w)string argument
TAO::Inout_Fixed_Array_Argument_T< S, S_slice, S_forany > | INOUT stub argument of fixed size element array
TAO::Inout_Fixed_Array_SArgument_T< S, S_forany > | INOUT skeleton argument of fixed size element array
TAO::Inout_Fixed_Size_Argument_T< S > | Template class for INOUT stub argument of fixed size IDL types
TAO::Inout_Fixed_Size_SArgument_T< S > | Template class for INOUT skeleton arg of fixed size IDL types
TAO::Inout_Object_Argument_T< S_ptr, S_traits > | Template class for INOUT object argument
TAO::Inout_Object_SArgument_T< S_ptr, S_var > | Template class for INOUT skeleton object argument
TAO::Inout_Special_Basic_Argument_T< S, to_S, from_S > | Template class for INOUT stub argument of (w)char/boolean/octet
TAO::Inout_Special_Basic_SArgument_T< S, to_S, from_S > | Template class for INOUT (w)char/boolean/octet skeleton argument
TAO::Inout_UB_String_Argument_T< S > | Template class for INOUT unbounded (w)string argument
TAO::Inout_UB_String_SArgument_T< S, S_var > | Template class for INOUT skeleton UB (w)string argument
TAO::Inout_Var_Array_Argument_T< S, S_slice, S_forany > | INOUT stub argument of variable size element array
TAO::Inout_Var_Array_SArgument_T< S, S_forany > | INOUT skeleton argument of variable size element array
TAO::Inout_Var_Size_Argument_T< S > | Template class for INOUT stub argument of fixed size IDL types
TAO::Inout_Var_Size_SArgument_T< S > | Template class for INOUT skeleton arg of fixed size IDL types
PortableInterceptor::Interceptor |
TimeBase::IntervalT |
CORBA::InvalidPolicies |
CORBA::InvalidPolicies::_tao_seq_CORBA_UShort_ |
PortableInterceptor::InvalidSlot |
TAO::Invocation_Adapter | Generic interface for the invocation object visible to the IDL compiler
TAO::Invocation_Base | The base class for the invocation object
IOP::IOR |
IOP::IOR::_tao_seq_IOP_TaggedProfile_ |
GIOP::IORAddressingInfo |
TAO::Less_Than_ObjectKey |
IIOP::ListenPoint |
IIOP::ListenPointList |
CORBA::LocalObject |
TAO::LocateRequest_Invocation | Object created bu TAO::LocateRequest_Invocation_Adapter to create and send LocateRequest invocation
TAO::LocateRequest_Invocation_Adapter | Adapter class for locate request invocations
IOP::MultipleComponentProfile |
CORBA::NamedValue | CORBA Name/value pair implementation
TAO::Narrow_Utils< T > |
CORBA::NVList | CORBA::NVList implementation
CORBA::Object | Implementation of a CORBA object reference
TAO::Object_Arg_Traits_T< T_ptr, T_var, T_out, T_traits > |
TAO::Object_Proxy_Broker | Object_Proxy_Broker
TAO::Object_SArg_Traits_T< T_ptr, T_var, T_out > |
TAO::Object_Tag | Struct for object arguments id tag
TAO::ObjectKey |
TAO::ObjectKey_Table | : Compares the length and then the contents of ObjectKeys
TAO::Objref_Traits< T > | Specialized for each interface in generated code
TAO::Objref_Traits< CORBA::ConstructionPolicy > |
TAO::Objref_Traits< CORBA::Current > |
TAO::Objref_Traits< CORBA::DIIPollable > |
TAO::Objref_Traits< CORBA::DomainManager > |
TAO::Objref_Traits< CORBA::Object > |
TAO::Objref_Traits< CORBA::Policy > |
TAO::Objref_Traits< CORBA::PolicyCurrent > |
TAO::Objref_Traits< CORBA::PolicyManager > |
TAO::Objref_Traits< CORBA::Pollable > |
TAO::Objref_Traits< CORBA::PollableSet > |
TAO::Objref_Traits< CORBA::TypeCode > |
TAO::Objref_Traits< IOP::Codec > |
TAO::Objref_Traits< IOP::CodecFactory > |
TAO::Objref_Traits< PortableInterceptor::ClientRequestInfo > |
TAO::Objref_Traits< PortableInterceptor::ClientRequestInterceptor > |
TAO::Objref_Traits< PortableInterceptor::Current > |
TAO::Objref_Traits< PortableInterceptor::Interceptor > |
TAO::Objref_Traits< PortableInterceptor::ORBInitializer > |
TAO::Objref_Traits< PortableInterceptor::ORBInitInfo > |
TAO::Objref_Traits< PortableInterceptor::PolicyFactory > |
TAO::Objref_Traits< PortableInterceptor::RequestInfo > |
TAO::Objref_Traits< PortableInterceptor::ServerRequestInfo > |
TAO::Objref_Traits< PortableInterceptor::ServerRequestInterceptor > |
TAO::Objref_Traits< TAO::BufferingConstraintPolicy > |
TAO::Objref_Traits< TAO_ORBInitInfo > |
CORBA::OctetSeq |
CORBA::ORB | ORB pseudo-object
CORBA::ORB::InvalidName |
CORBA::ORB_ObjectIdList |
PortableInterceptor::ORBInitializer |
PortableInterceptor::ORBInitInfo |
PortableInterceptor::ORBInitInfo::DuplicateName |
PortableInterceptor::ORBInitInfo::InvalidName |
TAO::Out_Basic_Argument_T< S > | Template class for OUT stub argument of basic IDL types
TAO::Out_Basic_SArgument_T< S > | Template class for OUT skeleton argument of basic IDL types
TAO::Out_BD_String_Argument_T< S, S_out, to_S, from_S, BOUND > | Template class for INOUT bounded (w)string argument
TAO::Out_BD_String_SArgument_T< S, S_var, S_out, to_S, from_S, BOUND > | Template class for INOUT skeleton bd (w)string argument
TAO::Out_Fixed_Array_Argument_T< S, S_slice, S_forany > | OUT stub argument of fixed size element array
TAO::Out_Fixed_Array_SArgument_T< S, S_forany > | OUT skeleton argument of fixed size element array
TAO::Out_Fixed_Size_Argument_T< S > | Template class for OUT stub argument of fixed size IDL types
TAO::Out_Fixed_Size_SArgument_T< S > | Template class for OUT skeleton argument of fixed size IDL types
TAO::Out_Object_Argument_T< S_ptr, S_out > | Template class for INOUT object argument
TAO::Out_Object_SArgument_T< S_ptr, S_var, S_out > | Template class for INOUT skeleton object argument
TAO::Out_Special_Basic_Argument_T< S, to_S, from_S > | Template class for OUT stub argument of (w)char/boolean/octet
TAO::Out_Special_Basic_SArgument_T< S, to_S, from_S > | Template class for OUT skeleton argument of (w)char/boolean/octet
TAO::Out_UB_String_Argument_T< S, S_out > | Template class for INOUT unbounded (w)string argument
TAO::Out_UB_String_SArgument_T< S, S_var > | Template class for INOUT skeleton UB (w)string argument
TAO::Out_Var_Array_Argument_T< S, S_slice, S_var, S_out, S_forany > | OUT stub argument of variable size element array
TAO::Out_Var_Array_SArgument_T< S_slice, S_var, S_forany > | OUT skeleton argument of variable size element array
TAO::Out_Var_Size_Argument_T< S, S_out > | Template class for OUT stub argument of fixed size IDL types
TAO::Out_Var_Size_SArgument_T< S, S_var > | Template class for OUT skeleton argument of fixed size IDL types
Dynamic::Parameter |
Dynamic::ParameterList |
CORBA::Policy |
CORBA::PolicyCurrent |
CORBA::PolicyError |
PortableInterceptor::PolicyFactory |
CORBA::PolicyList |
CORBA::PolicyManager |
CORBA::PolicyTypeSeq |
Messaging::PolicyValue |
Messaging::PolicyValueSeq |
CORBA::Pollable |
CORBA::PollableSet |
CORBA::PollableSet::NoPossiblePollable |
CORBA::PollableSet::UnknownPollable |
CORBA::Principal | A "Principal" identifies an authenticated entity in the network administration framework
TAO::Profile_Transport_Resolver | Chooses the profile and a transport for a target object on which an invocation can be made
TAO::Refcounted_ObjectKey | A wrapper class that ties together a refcount to an ObjectKey
TAO::Remote_Invocation | Base class for remote invocations
TAO::Remote_Object_Proxy_Broker | Remote_Object_Proxy_Broker
TAO::Reply_Guard | A guard class used for storing and forwarding the reply status to the portable interceptors
PortableInterceptor::RequestInfo |
TAO::Ret_Basic_Argument_T< S > | Template class for return stub value of basic IDL types
TAO::Ret_Basic_SArgument_T< S > | Template class for return skeleton value of basic IDL types
TAO::Ret_BD_String_Argument_T< S, S_var, to_S, from_S, BOUND > | Template class for return stub value of bd (w)string argument
TAO::Ret_BD_String_SArgument_T< S, S_var, to_S, from_S, BOUND > | Template class for return skeleton value of bd (w)string
TAO::Ret_Fixed_Array_Argument_T< S, S_slice, S_var, S_forany > | Return stub value of fixed size element array
TAO::Ret_Fixed_Array_SArgument_T< S_slice, S_var, S_forany > | Skeleton value of fixed size element array
TAO::Ret_Fixed_Size_Argument_T< S > | Template class for return stub value of fixed size IDL types
TAO::Ret_Fixed_Size_SArgument_T< S > | Template class for return skeleton value of fixed size IDL types
TAO::Ret_Object_Argument_T< S_ptr, S_var > | Specialization for CORBA::Object, necessitated since we don't have an Any insertion operator for Object
TAO::Ret_Object_Argument_T< CORBA::Object_ptr, CORBA::Object_var > |
TAO::Ret_Object_SArgument_T< S_ptr, S_var > | Template class for return skeleton value of object
TAO::Ret_Special_Basic_Argument_T< S, to_S, from_S > |
TAO::Ret_Special_Basic_SArgument_T< S, to_S, from_S > |
TAO::Ret_UB_String_Argument_T< S, S_var > | Template class for return stub value of ub (w)string argument
TAO::Ret_UB_String_SArgument_T< S, S_var > | Template class for return skeleton value of UB (w)string
TAO::Ret_Var_Array_Argument_T< S, S_slice, S_var, S_forany > | Return stub value of variable size element array
TAO::Ret_Var_Array_SArgument_T< S_slice, S_var, S_forany > | Skeleton value of variable size element array
TAO::Ret_Var_Size_Argument_T< S, S_var > | Template class for return stub value of fixed size IDL types
TAO::Ret_Var_Size_SArgument_T< S, S_var > | Template class for return skeleton value of fixed size IDL types
TAO::SArg_Traits< T > | Base class for all skeleton arg traits specializations
TAO::SArg_Traits< ACE_InputCDR::to_boolean > |
TAO::SArg_Traits< ACE_InputCDR::to_char > | Specializations for (w)char, octet and boolean
TAO::SArg_Traits< ACE_InputCDR::to_octet > |
TAO::SArg_Traits< ACE_InputCDR::to_wchar > |
TAO::SArg_Traits< CORBA::Char * > | Specializatons for unbounded (w)strings
TAO::SArg_Traits< CORBA::Double > |
TAO::SArg_Traits< CORBA::Float > |
TAO::SArg_Traits< CORBA::Long > |
TAO::SArg_Traits< CORBA::LongDouble > |
TAO::SArg_Traits< CORBA::LongLong > |
TAO::SArg_Traits< CORBA::Short > | Specializations for basic skeleton arg types, except (w)char/boolean/octet
TAO::SArg_Traits< CORBA::ULong > |
TAO::SArg_Traits< CORBA::ULongLong > |
TAO::SArg_Traits< CORBA::UShort > |
TAO::SArg_Traits< CORBA::WChar * > |
TAO::SArg_Traits< void > | Specialization for void return type
PortableInterceptor::ServerRequestInfo |
PortableInterceptor::ServerRequestInterceptor |
IOP::ServiceContext |
IOP::ServiceContextList |
CORBA::ServiceDetail |
CORBA::ServiceInformation |
CORBA::ServiceInformation::_tao_seq_CORBA_ServiceDetail_ |
CORBA::ServiceInformation::_tao_seq_CORBA_ServiceOption_ |
TAO::Special_Basic_Arg_Traits_T< T, to_T, from_T > |
TAO::Special_Basic_SArg_Traits_T< T, to_T, from_T > |
TAO::Special_Basic_Tag | Struct for basic IDL type arguments id tag
TAO::Special_Basic_Traits_T | Template class for stub argument traits of (w)char/boolean/octet
CORBA::String_out | String_out
CORBA::String_var | CORBA::String var class
CORBA::StringSeq |
TAO::Synch_Oneway_Invocation | All the action for a synchronous oneway invocation happen here
TAO::Synch_Twoway_Invocation | All the action for a synchronous twoway invocation happen here
CORBA::SystemException | SystemException
IOP::TaggedComponent |
IOP::TaggedComponentList |
IOP::TaggedComponentSeq |
IOP::TaggedProfile |
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_Array_Forany_T< T, T_slice > | Parametrized implementation of _forany class for arrays
TAO_Array_Out_T< T, T_var, T_slice > | Parametrized implementation of _out class for arrays
TAO_Array_Var_Base_T< T, T_slice > | Parametrized implementation of _var base class for arrays
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_Array_Sequence< T, T_slice, 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, 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_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 | 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_Guard | Guard for exception safe TAO_ClientRequestInfo_i pointer swapping
TAO_ClientRequestInfo_i | Implementation of the PortableInterceptor::ClientRequestInfo interface
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_Codeset_Item | A single element in the list of Codeset Translator Factories
TAO_Codeset_Manager | The encapsulation of logic for codeset negotiation
TAO_Codeset_Translator_Factory | Abstract base class for factories providing codeset translators
TAO_Codeset_Translator_Factory_T< NCS_TO_TCS > | Template for translator factory classes
TAO_Collocation_Resolver | This class helps in resolving if a CORBA:Object is collocated
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 |
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 | Deprecated 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_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_Fixed_Var_T< T > | Parametrized implementation of _var class for structs, unions, and exceptions with members of fixed size
TAO_FixedArray_Var_T< T, T_slice > | Parametrized implementation of _var class for arrays with elements of fixed size
TAO_FixedSeq_Var_T< T, T_elem > | Parametrized implementation of _var class for sequences whose element is of fixed size.
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_Locate_Request_Header | Location service support
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_ReplyHeader | This class embodies the header of a GIOP reply. @Not used. Could be used in future
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_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_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_Adapter | TAO_IORInterceptor_Adapter
TAO_IORInterceptor_Adapter_Factory | TAO_IORInterceptor_Adapter_Factory
TAO_Leader_Follower | TAO_Leader_Follower
TAO_Leader_Follower_Flushing_Strategy | Implement a flushing strategy that uses the Leader/Follower set
TAO_LF_CH_Event | Use the Leader/Follower loop to wait for one specific event in the invocation path
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_Invocation_Event | Use the Leader/Follower loop to wait for one specific event in the invocation path
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_MngSeq_Out_T< T, T_var, T_elem > | Parametrized implementation of _out class for sequences having managed types
TAO_MngSeq_Var_T< T, T_elem > | Parametrized implementation of _var class for sequences whose element is of a managed type - string, wstring, valuetype, interface, abstract interface and pseudo object
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_Impl | TAO_Object_Proxy_Impl
TAO_Object_Ref_Table | Keep a table de-stringified object references registered with the ORB
TAO_Objref_Out_T< T > | Parametrized implementation of _out class for object references
TAO_Objref_Var_T< T > | Parameterized implementation of `_var` class for object references
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_Static_Resources | The static (global) resoures of all ORB cores
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_Out_T< T, T_var > | Parametrized implementation of _out class for structs, unions and exceptions.
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 PortableInterceptor::PolicyFactory registry
TAO_Profile | Defines the Profile interface
TAO_Protocol_Factory |
TAO_Protocol_Item |
TAO_Protocols_Hooks |
TAO_Pseudo_Object_Manager< T > | Manager for Pseudo Objects
TAO_Pseudo_Out_T< T, T_var > | Parametrized implementation of _out class for TypeCode, Object, AbstractBase, NamedValue, NVList, Principal, Request, Context, ORB, LocalObject, and Environment
TAO_Pseudo_Var_T< T > | Parametrized implementation of _var class for TypeCode, Object, AbstractBase, NamedValue, NVList, Principal, Request, Context, ORB, LocalObject, and Environment
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_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_Seq_Out_T< T, T_var, T_elem > | Parametrized implementation of _out class for sequences
TAO_Seq_Var_Base_T< T, T_elem > | Parametrized implementation of _var base class for sequences
TAO_Seq_Var_Base_T< PolicyList, TAO_Object_Manager< Policy, Policy_var >> |
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 |
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 | 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_Thread_Per_Connection_Handler | Definition for the thread-per-connection strategy
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_Refcount_Guard | Helper class that increments the refount on construction and decrements the refcount on destruction
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_Unbounded_Array_Sequence< T, T_slice > | 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 > | 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_WString_Sequence | Unbounded sequence of wstrings
TAO_Unknown_Profile | A TAO_Profile class to handle foreign profiles
TAO_Valuetype_Adapter | TAO_Valuetype_Adapter
TAO_Var_Base_T< T > | Parametrized implementation of _var base class for structs, unions and exceptions
TAO_Var_Var_T< T > | Parametrized implementation of _var class for structs, unions, and exceptions with members of variable size
TAO_VarArray_Var_T< T, T_slice > |
TAO_VarSeq_Var_T< T, T_elem > | Parametrized implementation of _var class for sequences whose element is of variable size.
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
GIOP::TargetAddress |
TAO::TC_Private_State | Private state of the TypeCode
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 |
TAO::TypeCode_Constants | This class is a namespace for TypeCode-related static data that is owned by the ORB
TAO::UB_String_Arg_Traits_T< T, T_var, T_out > | Template class for argument traits of unbounded (w)strings
TAO::UB_String_SArg_Traits_T< T, T_var, T_out > | Template class for argument traits of unbounded (w)strings
TAO::UB_String_Tag | Struct for unbounded (w)string arguments id tag
TAO::Unknown_IDL_Type | CDR-based Any impl class
CORBA::UserException | User exceptions are those defined by application developers using OMG-IDL
TimeBase::UtcT |
TAO::Var_Array_Arg_Traits_T< T, T_slice, T_var, T_out, T_forany > | Argument traits of variable size element array
TAO::Var_Array_SArg_Traits_T< T, T_slice, T_var, T_out, T_forany > | Argument traits of variable size element array
TAO::Var_Array_Tag | Struct for variable size element array argument id tag
TAO::Var_Size_Arg_Traits_T< T, T_var, T_out > |
TAO::Var_Size_SArg_Traits_T< T, T_var, T_out > |
TAO::Var_Size_Tag |
GIOP::Version |
CORBA::WrongTransaction |
CORBA::WString_out | WString_out
CORBA::WString_var | CORBA::WString var class
CORBA::WStringSeq |