| POA_CORBA::_get_component_Policy_Upcall_Command | |
| POA_CORBA::_get_policy_type_Policy | |
| POA_CORBA::_is_a_Policy_Upcall_Command | |
| POA_CORBA::_non_existent_Policy_Upcall_Command | |
| POA_CORBA::_TAO_Policy_Direct_Proxy_Impl | |
| POA_CORBA::_TAO_Policy_Strategized_Proxy_Broker | |
| CORBA::AbstractBase | Abstract base class for Interfaces and Valuetypes |
| TAO::AbstractBase_Invocation_Adapter | |
| TAO::AbstractBase_Narrow_Utils< T > | |
| TAO_Object_Adapter::Active_Hint_Strategy | This class uses active demux hint for POA active hint strategy |
| TAO_Server_Strategy_Factory::Active_Object_Map_Creation_Parameters | |
| TAO::Portable_Server::Active_Policy_Strategies | |
| TAO::Portable_Server::Active_Policy_Strategies_Cleanup_Guard | |
| TAO::Portable_Server::Adapter_Activator | |
| TAO::TypeCode::Alias< StringType, TypeCodeType, RefCountPolicy > | CORBA::TypeCode implementation for an OMG IDL typedef |
| TAO::TypeCode::Alias< char const *, CORBA::TypeCode_ptr const *, TAO::Null_RefCount_Policy > | |
| CORBA::Any | Generic container for IDL types |
| 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_Impl | Base class for the Any template subclasses |
| TAO::Any_Impl_T< T > | Template Any class for pointer types |
| TAO::Any_Insert_Policy_AnyTypeCode_Adapter< S > | |
| TAO::Any_Insert_Policy_CORBA_Object< S > | |
| TAO::Any_Insert_Policy_IFR_Client_Adapter< S > | |
| TAO::Any_Insert_Policy_Noop< S > | |
| TAO::Any_Insert_Policy_Stream< S > | |
| 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 | Template Any class for IDL types with 2 modes of insertion |
| CORBA::Any_var | Provide for automatic storage deallocation on going out of scope |
| 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::AbstractBase > | |
| TAO::Arg_Traits< CORBA::Any > | |
| 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 > | |
| TAO::Arg_Traits< CORBA::ULong > | |
| TAO::Arg_Traits< CORBA::ULongLong > | |
| TAO::Arg_Traits< CORBA::UShort > | |
| TAO::Arg_Traits< CORBA::ValueBase > | |
| TAO::Arg_Traits< CORBA::WChar * > | |
| TAO::Arg_Traits< std::string > | |
| TAO::Arg_Traits< void > | Specialization for void return type |
| TAO::Argument | Base class for argument class templates |
| TAO::ARH_Refcount_Functor | Functor for refcounting of TAO_AMH_Response_Handler |
| TAO::details::array_traits< T_forany > | |
| Array_Traits | Specialized for each array in generated code |
| TAO::Asynch_Invocation_Adapter | Generic interface for the invocation object visible to the IDL compiler |
| TAO::Asynch_Remote_Invocation | |
| CORBA::TypeCode::BadKind | Invalid TypeCode operation exception |
| TAO::TypeCode::Base_Attributes< STRING_TYPE > | Attributes contained by most TypeCodes with complex parameter lists |
| TAO::BaseCompressor | |
| TAO::Basic_Arg_Traits_T< T, Insert_Policy > | Template class for stub argument traits of basic IDL types |
| TAO::Basic_SArg_Traits_T< T, Insert_Policy > | Template class for skeleton argument traits of basic IDL types |
| TAO::BasicTypeTraits< CORBA::Any > | |
| TAO::BasicTypeTraits< CORBA::AnySeq > | |
| TAO::BasicTypeTraits< CORBA::Boolean > | |
| TAO::BasicTypeTraits< CORBA::BooleanSeq > | |
| TAO::BasicTypeTraits< CORBA::Char * > | |
| TAO::BasicTypeTraits< CORBA::Char > | |
| TAO::BasicTypeTraits< CORBA::CharSeq > | |
| TAO::BasicTypeTraits< CORBA::Double > | |
| TAO::BasicTypeTraits< CORBA::DoubleSeq > | |
| TAO::BasicTypeTraits< CORBA::Float > | |
| TAO::BasicTypeTraits< CORBA::FloatSeq > | |
| TAO::BasicTypeTraits< CORBA::Long > | |
| TAO::BasicTypeTraits< CORBA::LongDouble > | |
| TAO::BasicTypeTraits< CORBA::LongDoubleSeq > | |
| TAO::BasicTypeTraits< CORBA::LongLong > | |
| TAO::BasicTypeTraits< CORBA::LongLongSeq > | |
| TAO::BasicTypeTraits< CORBA::LongSeq > | |
| TAO::BasicTypeTraits< CORBA::Object_ptr > | |
| TAO::BasicTypeTraits< CORBA::Octet > | |
| TAO::BasicTypeTraits< CORBA::OctetSeq > | |
| TAO::BasicTypeTraits< CORBA::Short > | |
| TAO::BasicTypeTraits< CORBA::ShortSeq > | |
| TAO::BasicTypeTraits< CORBA::TypeCode_ptr > | |
| TAO::BasicTypeTraits< CORBA::ULong > | |
| TAO::BasicTypeTraits< CORBA::ULongLong > | |
| TAO::BasicTypeTraits< CORBA::ULongLongSeq > | |
| TAO::BasicTypeTraits< CORBA::ULongSeq > | |
| TAO::BasicTypeTraits< CORBA::UShort > | |
| TAO::BasicTypeTraits< CORBA::UShortSeq > | |
| TAO::BasicTypeTraits< CORBA::WChar * > | |
| TAO::BasicTypeTraits< CORBA::WCharSeq > | |
| TAO::BD_String_Arg_Traits_T< T_var, BOUND, Insert_Policy > | Template class for stub argument traits of bounded (w)strings |
| TAO::BD_String_SArg_Traits_T< T_var, BOUND, Insert_Policy > | |
| TAO::details::bounded_array_allocation_traits< T, MAX, dummy > | |
| TAO::bounded_array_sequence< T_array, T_slice, T_tag, MAX > | |
| TAO::bounded_basic_string_sequence< charT, MAX > | |
| TAO::bounded_bd_string_sequence< charT, MAX, BD_STR_MAX > | |
| TAO::bounded_object_reference_sequence< object_t, object_t_var, MAX > | |
| TAO::details::bounded_reference_allocation_traits< T, ref_traits, MAX, dummy > | |
| TAO::details::bounded_value_allocation_traits< T, MAX, dummy > | |
| TAO::bounded_value_sequence< T, MAX > | |
| TAO::details::bounded_valuetype_allocation_traits< T, ref_traits, MAX, dummy > | |
| TAO::bounded_valuetype_sequence< object_t, object_t_var, MAX > | |
| CORBA::TypeCode::Bounds | Out-of-bounds member index exception |
| TAO::Bzip2_CompressorFactory | |
| TAO::Bzip2Compressor | |
| TAO::Cache_ExtId_T< TRANSPORT_DESCRIPTOR_TYPE > | 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_T< TRANSPORT_TYPE > | Helper class for TAO_Transport_Cache_Manager |
| TAO::Portable_Server::Cached_Policies | |
| TAO::TypeCode::Case< StringType, TypeCodeType > | Abstract base class for that represents an IDL union case/member |
| TAO::TypeCode::Case_Enum_T< StringType, TypeCodeType > | Representation of an OMG IDL defined union case for unions with Enum discriminators |
| TAO::TypeCode::Case_T< DiscriminatorType, StringType, TypeCodeType > | Representation of an OMG IDL defined union case |
| TAO::TypeCode::Case_Traits< T > | |
| TAO::TypeCode::Case_Traits< CORBA::Boolean > | |
| TAO::TypeCode::Case_Traits< CORBA::Char > | |
| Client_Interceptor | |
| TAO::ClientRequestDetails | The policy-driven details for a registered client request interceptor |
| TAO::ClientRequestInterceptor_Adapter | A convenient helper class to invoke registered client request interceptors |
| TAO::ClientRequestInterceptor_Adapter_Impl | |
| TAO::Collocated_Arguments_Converter | Collocated_Arguments_Converter |
| TAO::Collocated_Invocation | Class for Collocated invocations |
| TAO::Collocated_Object_Proxy_Broker | Collocated_Object_Proxy_Broker |
| TAO::Collocation_Proxy_Broker | |
| TAO::CompressionEnablingPolicy | Implementation of the ZIOP::CompressionEnablingPolicy |
| TAO::CompressionLowValuePolicy | Implementation of the ZIOP::CompressionLowValuePolicy |
| TAO::CompressionManager | |
| TAO::CompressionMinRatioPolicy | Implementation of the ZIOP::CompressionMinRatioPolicy |
| TAO::CompressorFactory | |
| TAO::CompressorIdLevelListPolicy | |
| CompressorIdPolicy | Implementation of the ZIOP::CompressorIdPolicy |
| CORBA::Context | CORBA::Context |
| CORBA::ContextList | ContextList definition taken from CORBA v2.3a Dec 1998 |
| POA_CORBA::copy_Policy | |
| TAO::CreateDynAnyUtils< DA_IMPL, ANY_TC > | |
| TAO::Portable_Server::Creation_Time | |
| TAO::Transport::Current | |
| TAO::Transport::IIOP::Current | |
| TAO::Transport::Current_Impl | |
| Current_impl | Implementation of the TAO::Transport::Current interface |
| TAO::Transport::Current_ORBInitializer< Impl > | |
| TAO::Transport::Current_ORBInitializer_Base | |
| CORBA::DefaultValueRefCountBase | |
| TAO::Delayed_Transport_Queueing_Strategy | Delay the buffering decision until the transport blocks |
| POA_CORBA::destroy_Policy | |
| TAO::DII_Asynch_Invocation_Adapter | This class is for asynchronous DII invocation |
| TAO::DII_Deferred_Invocation | |
| TAO::DII_Deferred_Invocation_Adapter | This class is for deferred DII invocation |
| TAO::DII_Invocation | |
| TAO::DII_Invocation_Adapter | Generic interface for the DII invocation object visible |
| TAO::DII_Oneway_Invocation_Adapter | This class is for oneway DII invocation |
| TAO::Direct_Collocation_Upcall_Wrapper | Wraps the activities direct collocation upcall |
| PortableInterceptor::DLL_Resident_ORB_Initializer | |
| TAO::Transport::Drain_Constraints | Encapsulate the flushing control parameters |
| TAO_Transport::Drain_Result | |
| DTTask | |
| TAO::DynAnyBasicTypeUtils< T > | |
| TAO::DynAnyFlagUtils< T > | |
| TAO::Eager_Transport_Queueing_Strategy | |
| TAO::TypeCode::Empty_Param | CORBA::TypeCode implementation for OMG IDL types with empty parameter lists |
| Endpoint_Value_Impl | Abstract base class to be mixed in to servants of protocol specific EndpointValues |
| TAO::TypeCode::Enum< StringType, EnumeratorArrayType, RefCountPolicy > | CORBA::TypeCode implementation for an OMG IDL enum |
| TAO::TypeCode::Enum< char const *, char const *const *, TAO::Null_RefCount_Policy > | |
| CORBA::Environment | Environment |
| TAO_LF_Multi_Event::Event_Node | |
| CORBA::Exception | Exception |
| TAO::Exception_Data | Description of a single exception |
| TAO::ExceptionHolder | |
| TAO::ExceptionHolderFactory | OBV factory implementation |
| CORBA::ExceptionList | ExceptionList definition taken from CORBA v2.2 Feb 1998 |
| TAO::First_Request_Guard | Auto pointer like class for first_request flag in transport |
| TAO::TypeCode::Fixed< RefCountPolicy > | CORBA::TypeCode implementation for the OMG IDL fixed types |
| TAO::Fixed_Array_Arg_Traits_T< T_var, T_forany, Insert_Policy > | Argument traits of fixed size element array |
| TAO::Fixed_Array_SArg_Traits_T< T_var, T_forany, Insert_Policy > | |
| TAO::Fixed_Size_Arg_Traits_T< T, Insert_Policy > | Template class for argument traits of fixed size IDL types |
| TAO::Fixed_Size_SArg_Traits_T< T, Insert_Policy > | Template class for argument traits of fixed size IDL types |
| TAO::FlResource_Factory | TAO_GUI_Resource_Factory for creating FlReactor |
| TAO::FlResource_Loader | Loads TAO resources related with Fl |
| TAO::Flush_Transport_Queueing_Strategy | |
| TAO::FoxResource_Factory | TAO_GUI_Resource_Factory for creating FoxReactor |
| TAO::FoxResource_Loader | Loads TAO resources related with Fox |
| TAO::CSD::FW_Server_Request_Wrapper | Wrapper around a TAO_Server_Request that will be cloned at the proper time |
| TAO::details::generic_sequence< T, ALLOCATION_TRAITS, ELEMENT_TRAITS > | |
| TAO::GUIResource_Factory | |
| TAO_Object_Adapter::Hint_Strategy | Base class for POA active hint strategy |
| TAO::Portable_Server::IdAssignmentPolicy | |
| TAO::Portable_Server::IdAssignmentStrategy | |
| TAO::Portable_Server::IdAssignmentStrategyFactory | |
| TAO::Portable_Server::IdAssignmentStrategyFactoryImpl | |
| TAO::Portable_Server::IdAssignmentStrategySystem | |
| TAO::Portable_Server::IdAssignmentStrategyUser | |
| TAO::Portable_Server::IdUniquenessPolicy | |
| TAO::Portable_Server::IdUniquenessStrategy | |
| TAO::Portable_Server::IdUniquenessStrategyFactory | |
| TAO::Portable_Server::IdUniquenessStrategyFactoryImpl | |
| TAO::Portable_Server::IdUniquenessStrategyMultiple | |
| TAO::Portable_Server::IdUniquenessStrategyUnique | |
| TAO::Portable_Server::IdUniquenessStrategyUniqueFactoryImpl | |
| IFR_Client_Adapter_Impl | IFR_Client_Adapter_Impl |
| TAO::Transport::IIOP_Current_Impl | Implementation of the TAO::Transport::IIOPCurrent interface |
| IIOPEndpointValue_i | Implementation of the IIOP-Specific endpoint policy value |
| TAO::Utils::Implicit_Deactivation_Functor | Implements a functor for the Implicit_Deactivator class |
| Implicit_Deactivator | Helper class to deactivate implicitly activated servants |
| TAO::Portable_Server::ImplicitActivationPolicy | |
| TAO::Portable_Server::ImplicitActivationStrategy | |
| TAO::Portable_Server::ImplicitActivationStrategyExplicit | |
| TAO::Portable_Server::ImplicitActivationStrategyFactory | |
| TAO::Portable_Server::ImplicitActivationStrategyFactoryImpl | |
| TAO::Portable_Server::ImplicitActivationStrategyImplicit | |
| TAO::Portable_Server::ImR_Client_Adapter | IFR_Client_Adapter |
| TAO::ImR_Client::ImR_Client_Adapter_Impl | |
| TAO::In_Basic_Argument_T< S, Insert_Policy > | Template class for IN stub argument of basic IDL types |
| TAO::In_Basic_Clonable_Argument_T< S, Insert_Policy > | Template class for IN stub argument of basic IDL types |
| TAO::In_Basic_SArgument_T< S, Insert_Policy > | Template class for IN skeleton argument of basic IDL types |
| TAO::In_BD_String_Argument_T< S_var, BOUND, Insert_Policy > | Template class for IN bounded (w)string argument |
| TAO::In_BD_String_Clonable_Argument_T< S_var, BOUND, Insert_Policy > | Template class for IN bounded (w)string argument |
| TAO::In_BD_String_SArgument_T< S_var, BOUND, Insert_Policy > | Template class for IN skeleton bd (w)string argument |
| TAO::In_Fixed_Array_Argument_T< S_forany, Insert_Policy > | IN stub argument of fixed size element array |
| TAO::In_Fixed_Array_Clonable_Argument_T< S_forany, Insert_Policy > | IN stub argument of fixed size element array |
| TAO::In_Fixed_Array_SArgument_T< S_forany, Insert_Policy > | IN skeleton argument of fixed size element array |
| TAO::In_Fixed_Size_Argument_T< S, Insert_Policy > | Template class for IN stub argument of fixed size IDL types |
| TAO::In_Fixed_Size_Clonable_Argument_T< S, Insert_Policy > | Template class for IN stub argument of fixed size IDL types |
| TAO::In_Fixed_Size_SArgument_T< S, Insert_Policy > | |
| TAO::In_Object_Argument_Cloner_T< S_ptr > | |
| TAO::In_Object_Argument_Cloner_T< CORBA::InterfaceDef_ptr > | |
| TAO::In_Object_Argument_Cloner_T< CORBA::TypeCode_ptr > | |
| TAO::In_Object_Argument_T< S_ptr, Insert_Policy > | Template class for IN object argument |
| TAO::In_Object_Clonable_Argument_T< S_ptr, Insert_Policy > | Template class for IN object argument |
| TAO::In_Object_SArgument_T< S_ptr, S_var, Insert_Policy > | Template class for IN skeleton object argument |
| TAO::In_Special_Basic_Argument_T< S, to_S, from_S, Insert_Policy > | Template class for IN stub argument of (w)char/boolean/octet |
| TAO::In_Special_Basic_Clonable_Argument_T< S, to_S, from_S, Insert_Policy > | Template class for IN stub argument of (w)char/boolean/octet |
| TAO::In_Special_Basic_SArgument_T< S, to_S, from_S, Insert_Policy > | Template class for IN skeleton argument of (w)char/boolean/octet |
| TAO::In_UB_String_Argument_T< S_var, Insert_Policy > | Template class for IN unbounded (w)string argument |
| TAO::In_UB_String_Clonable_Argument_T< S_var, Insert_Policy > | 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_forany, Insert_Policy > | IN stub argument of variable size element array |
| TAO::In_Var_Array_Clonable_Argument_T< S_forany, Insert_Policy > | IN stub argument of variable size element array |
| TAO::In_Var_Array_SArgument_T< S_forany, Insert_Policy > | IN skeleton argument of variable size element array |
| TAO::In_Var_Size_Argument_T< S, Insert_Policy > | Template class for IN stub argument of fixed size IDL types |
| TAO::In_Var_Size_Clonable_Argument_T< S, Insert_Policy > | Template class for IN stub argument of fixed size IDL types |
| TAO::In_Var_Size_SArgument_T< S, Insert_Policy > | Template class for IN skeleton argument of fixed size IDL types |
| TAO::In_Vector_Argument_T< S, Insert_Policy > | Template class for IN stub argument of unbounded sequence IDL types |
| TAO::In_Vector_Clonable_Argument_T< S, Insert_Policy > | Template class for IN stub argument of unbounded sequence IDL types |
| TAO::In_Vector_SArgument_T< S, Insert_Policy > | Template class for IN skeleton argument of unbounded sequence IDL types |
| TAO::InArgument | |
| TAO::Incoming_Message_Stack | Implements stack for TAO_Queued_Data |
| TAO::Inout_Basic_Argument_T< S, Insert_Policy > | Template class for INOUT stub argument of basic IDL types |
| TAO::Inout_Basic_SArgument_T< S, Insert_Policy > | Template class for INOUT skeleton argument of basic IDL types |
| TAO::Inout_BD_String_Argument_T< S_var, BOUND, Insert_Policy > | Template class for INOUT bounded (w)string argument |
| TAO::Inout_BD_String_SArgument_T< S_var, BOUND, Insert_Policy > | Template class for INOUT skeleton bd (w)string argument |
| TAO::Inout_Fixed_Array_Argument_T< S_forany, Insert_Policy > | INOUT stub argument of fixed size element array |
| TAO::Inout_Fixed_Array_SArgument_T< S_forany, Insert_Policy > | INOUT skeleton argument of fixed size element array |
| TAO::Inout_Fixed_Size_Argument_T< S, Insert_Policy > | Template class for INOUT stub argument of fixed size IDL types |
| TAO::Inout_Fixed_Size_SArgument_T< S, Insert_Policy > | Template class for INOUT skeleton arg of fixed size IDL types |
| TAO::Inout_Object_Argument_T< S_ptr, S_traits, Insert_Policy > | Template class for INOUT object argument |
| TAO::Inout_Object_SArgument_T< S_ptr, S_var, Insert_Policy > | Template class for INOUT skeleton object argument |
| TAO::Inout_Special_Basic_Argument_T< S, to_S, from_S, Insert_Policy > | Template class for INOUT stub argument of (w)char/boolean/octet |
| TAO::Inout_Special_Basic_SArgument_T< S, to_S, from_S, Insert_Policy > | Template class for INOUT (w)char/boolean/octet skeleton argument |
| TAO::Inout_UB_String_Argument_T< S_var, Insert_Policy > | 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_forany, Insert_Policy > | INOUT stub argument of variable size element array |
| TAO::Inout_Var_Array_SArgument_T< S_forany, Insert_Policy > | INOUT skeleton argument of variable size element array |
| TAO::Inout_Var_Size_Argument_T< S, Insert_Policy > | Template class for INOUT stub argument of fixed size IDL types |
| TAO::Inout_Var_Size_SArgument_T< S, Insert_Policy > | Template class for INOUT skeleton arg of fixed size IDL types |
| TAO::Inout_Vector_Argument_T< S, Insert_Policy > | Template class for INOUT stub argument of unbounded sequence IDL types |
| TAO::Inout_Vector_SArgument_T< S, Insert_Policy > | Template class for INOUT skeleton arg of unbounded sequence IDL types |
| TAO::InoutArgument | |
| TAO::Interceptor_List< InterceptorType, DetailsType > | Template for portable interceptor lists |
| IntervalT | An UTC time interval |
| CORBA::ORB::InvalidName | |
| CORBA::InvalidPolicies | |
| TAO::Invocation_Adapter | Generic interface for the invocation object visible to the IDL compiler |
| TAO::Invocation_Base | The base class for the invocation object |
| TAO::IORInterceptor_Details | The policy-driven details for a registered IOR interceptor |
| TAO_Object_Adapter::iteratable_poa_name | This class allows iteration over a folded poa name |
| TAO_Root_POA::Key_To_Object_Params | |
| TAO::Less_Than_ObjectKey | Compares the length and then the contents of ObjectKeys |
| TAO::Portable_Server::LifespanPolicy | |
| TAO::Portable_Server::LifespanStrategy | |
| TAO::Portable_Server::LifespanStrategyFactory | |
| TAO::Portable_Server::LifespanStrategyFactoryImpl | |
| TAO::Portable_Server::LifespanStrategyPersistent | |
| TAO::Portable_Server::LifespanStrategyPersistentFactoryImpl | |
| TAO::Portable_Server::LifespanStrategyTransient | |
| TAO::Portable_Server::LifespanStrategyTransientFactoryImpl | |
| CORBA::LocalObject | |
| TAO::LocateRequest_Invocation | Object created by TAO::LocateRequest_Invocation_Adapter to create and send LocateRequest invocation |
| TAO::LocateRequest_Invocation_Adapter | Adapter class for locate request invocations |
| TAO::Lzo_CompressorFactory | |
| TAO::LzoCompressor | |
| CORBA::NamedValue | CORBA Name/value pair implementation |
| TAO::NamedValue_Argument | Class for the return value of a CORBA::(Server)Request |
| TAO::Narrow_Utils< T > | |
| TAO::Nested_Upcall_Guard | : Magic class that sets the status of the thread in the TSS |
| TAO_Object_Adapter::No_Hint_Strategy | This class doesn't use any hints for POA active hint strategy |
| TAO::Transport::NoContext | |
| TAO::Portable_Server::Non_Servant_Upcall | This class helps us with a recursive thread lock without using a recursive thread lock. Non_Servant_Upcall has a magic constructor and destructor. We unlock the Object_Adapter lock for the duration of the non-servant (i.e., adapter activator and servant activator) upcalls; reacquiring once the upcalls complete. Even though we are releasing the lock, other threads will not be able to make progress since <Object_Adapter::non_servant_upcall_in_progress_> has been set |
| TAO::Null_RefCount_Policy | No-op reference counting policy |
| CORBA::NVList | CORBA::NVList implementation |
| TAO::NVList_Argument | Class for the argument list of a CORBA::(Server)Request |
| CORBA::Object | Implementation of a CORBA object reference |
| TAO::Object_Arg_Traits_T< T_ptr, T_var, T_out, T_traits, Insert_Policy > | Template class for stub argument traits of objects |
| TAO::Object_Proxy_Broker | Object_Proxy_Broker |
| TAO::details::object_reference_const_sequence_element< obj_ref_traits > | |
| TAO::details::object_reference_sequence_element< obj_ref_traits > | |
| TAO::details::object_reference_traits< object_t, object_t_var, dummy > | |
| TAO::details::object_reference_traits_base< object_t, object_t_var > | |
| TAO::details::object_reference_traits_decorator< object_t, object_t_var, derived > | |
| TAO::Object_SArg_Traits_T< T_ptr, T_var, T_out, Insert_Policy > | Template class for skeleton argument traits of objects |
| TAO::ObjectKey | |
| TAO::ObjectKey_Table | Table that maintains the set of ObjectKey's seen by the ORB |
| TAO::ObjectReferenceTemplate | Implementation of the PortableInterceptor::ObjectReferenceTemplate interface. This is a default implementation created to be returned by the IORInfo when the user requests the ORT or ORF |
| ObjectReferenceTemplate_Adapter_Impl | Implementation of the TAO::ORT_Adapter |
| TAO::TypeCode::Objref< StringType, RefCountPolicy > | CORBA::TypeCode implementation for an OMG IDL object and object-like types |
| TAO::TypeCode::Objref< char const *, TAO::Null_RefCount_Policy > | |
| Objref_Base | CORBA::TypeCode implementation for an OMG IDL object and object-like types |
| TAO::Objref_Traits< ::CORBA::Policy > | |
| TAO::Objref_Traits< ::CORBA::TypeCode > | |
| TAO::Objref_Traits< ::PortableInterceptor::PolicyFactory > | |
| TAO::Objref_Traits< ::PortableInterceptor::ServerRequestInfo > | |
| TAO::Objref_Traits< ::PortableInterceptor::ServerRequestInterceptor > | |
| TAO::Objref_Traits< ::RTCORBA::ProtocolProperties > | |
| TAO::Objref_Traits< CORBA::Object > | |
| TAO::Objref_Traits< TAO_IOR_Table_Impl > | |
| TAO::Objref_Traits< TAO_ORBInitInfo > | |
| Operation_Skeleton_Ptr | A logical aggregation of all the operation skeleton pointers in use |
| TAO::Operation_Skeletons | |
| CORBA::ORB | ORB pseudo-object |
| TAO::ORB_Core_Ref_Counter | |
| ORB_Destroyer | Helper class to destroy an ORB |
| TAO::Utils::ORB_Destroyer_Functor | Implements a functor for the ORB_Destroyer class |
| TAO::ORB_Table | Keep a table with all the ORBs in the system |
| ORB_Table_Ref_Counter | |
| TAO::ORBInitializer_Registry | Global list that contains all portable interceptor ORB initializers |
| TAO::ORBInitializer_Registry_Adapter | |
| TAO::ORT_Adapter | ORT_Adapter |
| TAO::ORT_Adapter_Factory | ORT_Adapter_Factory |
| TAO::ORT_Adapter_Factory_Impl | ORT_Adapter_Factory_Impl |
| TAO::ORT_Adapter_Impl | |
| TAO::Out_Basic_Argument_T< S, Insert_Policy > | Template class for OUT stub argument of basic IDL types |
| TAO::Out_Basic_SArgument_T< S, Insert_Policy > | Template class for OUT skeleton argument of basic IDL types |
| TAO::Out_BD_String_Argument_T< S_var, BOUND, Insert_Policy > | Template class for OUT bounded (w)string argument |
| TAO::Out_BD_String_SArgument_T< S_var, BOUND, Insert_Policy > | Template class for INOUT skeleton bd (w)string argument |
| TAO::Out_Fixed_Array_Argument_T< S_forany, Insert_Policy > | OUT stub argument of fixed size element array |
| TAO::Out_Fixed_Array_SArgument_T< S_forany, Insert_Policy > | OUT skeleton argument of fixed size element array |
| TAO::Out_Fixed_Size_Argument_T< S, Insert_Policy > | Template class for OUT stub argument of fixed size IDL types |
| TAO::Out_Fixed_Size_SArgument_T< S, Insert_Policy > | Template class for OUT skeleton argument of fixed size IDL types |
| TAO::Out_Object_Argument_T< S_ptr, S_out, Insert_Policy > | Template class for OUT object argument |
| TAO::Out_Object_SArgument_T< S_ptr, S_var, S_out, Insert_Policy > | Template class for INOUT skeleton object argument |
| TAO::Out_Special_Basic_Argument_T< S, to_S, from_S, Insert_Policy > | Template class for OUT stub argument of (w)char/boolean/octet |
| TAO::Out_Special_Basic_SArgument_T< S, to_S, from_S, Insert_Policy > | Template class for OUT skeleton argument of (w)char/boolean/octet |
| TAO::Out_UB_String_Argument_T< S_var, Insert_Policy > | Template class for OUT 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_out, S_forany, Insert_Policy > | OUT stub argument of variable size element array |
| TAO::Out_Var_Array_SArgument_T< S_var, S_forany, Insert_Policy > | OUT skeleton argument of variable size element array |
| TAO::Out_Var_Size_Argument_T< S, Insert_Policy > | Template class for OUT stub argument of fixed size IDL types |
| TAO::Out_Var_Size_SArgument_T< S, Insert_Policy > | Template class for OUT skeleton argument of fixed size IDL types |
| TAO::Out_Vector_Argument_T< S, Insert_Policy > | Template class for OUT stub argument of unbounded sequence IDL types |
| TAO::Out_Vector_SArgument_T< S, Insert_Policy > | Template class for OUT skeleton argument of unbounded sequence IDL types |
| TAO::OutArgument | |
| TAO_CORBALOC_Parser::parsed_endpoint | |
| 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::Portable_Server::POA_Current | |
| TAO::Portable_Server::POA_Current_Impl | Implementation of the PortableServer::Current object |
| TAO::Portable_Server::POA_Guard | POA_Guard |
| TAO_Object_Adapter::poa_name_iterator | Iterator for a folded poa name |
| CORBA::Policy | |
| POA_CORBA::Policy | |
| TAO::Portable_Server::Policy_Strategy | |
| POA_CORBA::Policy_tie< T > | |
| CORBA::PolicyError | |
| PortableInterceptor::PolicyFactory | |
| TAO::PolicyFactory_Registry_Adapter | ORB-specific PortableInterceptor::PolicyFactory registry |
| TAO::Utils::PolicyList_Destroyer | Automatically destroy all the policies set in a PolicyList |
| TAO::Portable_Server::Servant_Upcall::Pre_Invoke_State | This struct keeps track of state related to pre- and post-invoke operations |
| CORBA::Principal | A "Principal" identifies an authenticated entity in the network administration framework |
| TAO_IORManip_IIOP_Filter::Profile_Info | |
| TAO::Profile_Transport_Resolver | Chooses the profile and a transport for a target object on which an invocation can be made |
| RTCORBA::ProtocolProperties | |
| TAO::QtResource_Factory | TAO_GUI_Resource_Factory for creating QtReactor |
| TAO::QtResource_Loader | Loads TAO resources related with Qt |
| TAO::details::range_checking< T, dummy > | Configurable traits to tradeoff safety vs. performance in the implementation of TAO sequences |
| TAO::TypeCode::Recursive_Type< TypeCodeBase, TypeCodeType, MemberArrayType > | Recursive type TypeCode decorator template |
| TAO::TypeCodeFactory::Recursive_TypeCode | Recursive TypeCode placeholder |
| RefCount_Policy_Traits | No-op reference count policy traits |
| RefCount_Policy_Traits | Compile-time selection of RefCount_Policy operations, etc |
| TAO::RefCount_Policy_Traits< Null_RefCount_Policy, TypePtr > | |
| TAO::RefCount_Policy_Traits< True_RefCount_Policy, TypePtr > | |
| TAO::Refcounted_ObjectKey | A wrapper class that ties together a refcount to an ObjectKey |
| PortableServer::RefCountServantBase | |
| TAO::Interceptor_List< InterceptorType, DetailsType >::RegisteredInterceptor | |
| 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 |
| CORBA::Request | CORBA::Request |
| TAO::RequestInterceptor_Adapter | A base helper class to invoke registered request interceptors |
| TAO::Portable_Server::RequestProcessingPolicy | |
| TAO::Portable_Server::RequestProcessingStrategy | |
| TAO::Portable_Server::RequestProcessingStrategyAOMOnly | |
| TAO::Portable_Server::RequestProcessingStrategyAOMOnlyFactoryImpl | |
| TAO::Portable_Server::RequestProcessingStrategyDefaultServant | |
| TAO::Portable_Server::RequestProcessingStrategyDefaultServantFactoryImpl | |
| TAO::Portable_Server::RequestProcessingStrategyFactory | |
| TAO::Portable_Server::RequestProcessingStrategyFactoryImpl | |
| TAO::Portable_Server::RequestProcessingStrategyServantActivator | |
| TAO::Portable_Server::RequestProcessingStrategyServantActivatorFactoryImpl | |
| TAO::Portable_Server::RequestProcessingStrategyServantLocator | |
| TAO::Portable_Server::RequestProcessingStrategyServantLocatorFactoryImpl | |
| TAO::Portable_Server::RequestProcessingStrategyServantManager | |
| TAO::TypeCode::Recursive_Type< TypeCodeBase, TypeCodeType, MemberArrayType >::Reset | |
| TAO::Ret_Basic_Argument_T< S, Insert_Policy > | Template class for return stub value of basic IDL types |
| TAO::Ret_Basic_SArgument_T< S, Insert_Policy > | Template class for return skeleton value of basic IDL types |
| TAO::Ret_BD_String_Argument_T< S_var, BOUND, Insert_Policy > | Template class for return stub value of bd (w)string argument |
| TAO::Ret_BD_String_SArgument_T< S_var, BOUND, Insert_Policy > | Template class for return skeleton value of bd (w)string |
| TAO::Ret_Fixed_Array_Argument_T< S_var, S_forany, Insert_Policy > | Return stub value of fixed size element array |
| TAO::Ret_Fixed_Array_SArgument_T< S_var, S_forany, Insert_Policy > | Skeleton value of fixed size element array |
| TAO::Ret_Fixed_Size_Argument_T< S, Insert_Policy > | Template class for return stub value of fixed size IDL types |
| TAO::Ret_Fixed_Size_SArgument_T< S, Insert_Policy > | Template class for return skeleton value of fixed size IDL types |
| TAO::Ret_Object_Argument_T< S_ptr, S_var, Insert_Policy > | Template class for return stub value of object argument |
| TAO::Ret_Object_SArgument_T< S_ptr, S_var, Insert_Policy > | Template class for return skeleton value of object |
| TAO::Ret_Special_Basic_Argument_T< S, to_S, from_S, Insert_Policy > | |
| TAO::Ret_Special_Basic_SArgument_T< S, to_S, from_S, Insert_Policy > | |
| TAO::Ret_UB_String_Argument_T< S_var, Insert_Policy > | 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_var, S_forany, Insert_Policy > | Return stub value of variable size element array |
| TAO::Ret_Var_Array_SArgument_T< S_var, S_forany, Insert_Policy > | Skeleton value of variable size element array |
| TAO::Ret_Var_Size_Argument_T< S, Insert_Policy > | Template class for return stub value of fixed size IDL types |
| TAO::Ret_Var_Size_SArgument_T< S, Insert_Policy > | Template class for return skeleton value of fixed size IDL types |
| TAO::Ret_Vector_Argument_T< S, Insert_Policy > | Template class for return stub value of fixed size IDL types |
| TAO::Ret_Vector_SArgument_T< S, Insert_Policy > | Template class for return skeleton value of unbounded sequence IDL types |
| TAO::RetArgument | |
| TAO::Utils::RIR_Narrow< T > | Helper class to obtain an initial reference and narrow it to the proper object reference |
| RT_Endpoint_Selector_Factory | Factory for obtaining appropriate <Invocation_Selector> |
| RT_Endpoint_Utils | Commonly used utility methods used by the RT_Endpoint_Selectors |
| 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::Any > | |
| 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::Object > | |
| TAO::SArg_Traits< CORBA::Policy > | |
| TAO::SArg_Traits< CORBA::Short > | Specializations for basic skeleton arg types, except (w)char/boolean/octet |
| TAO::SArg_Traits< CORBA::TypeCode > | |
| TAO::SArg_Traits< CORBA::ULong > | |
| TAO::SArg_Traits< CORBA::ULongLong > | |
| TAO::SArg_Traits< CORBA::UShort > | |
| TAO::SArg_Traits< CORBA::WChar * > | |
| TAO::SArg_Traits< std::string > | |
| TAO::SArg_Traits< void > | Specialization for void return type |
| TAO::TypeCode::Sequence< TypeCodeType, RefCountPolicy > | CORBA::TypeCode implementation for OMG IDL sequence and array types |
| TAO::TypeCode::Sequence< CORBA::TypeCode_ptr const *, TAO::Null_RefCount_Policy > | |
| TAO::Portable_Server::Servant_Upcall | This class finds out the POA and the servant to perform an upcall. It can only be instantiated without the object adapter's lock held. For each upcall a new instance of this class is created |
| TAO::Utils::Servant_Var< T > | Provides a type safe counted reference to servants |
| PortableServer::Servant_var< T > | Provides a type safe counted reference to servants |
| TAO::Portable_Server::ServantRetentionPolicy | |
| TAO::Portable_Server::ServantRetentionStrategy | |
| TAO::Portable_Server::ServantRetentionStrategyFactory | |
| TAO::Portable_Server::ServantRetentionStrategyFactoryImpl | |
| TAO::Portable_Server::ServantRetentionStrategyNonRetain | |
| TAO::Portable_Server::ServantRetentionStrategyNonRetainFactoryImpl | |
| TAO::Portable_Server::ServantRetentionStrategyRetain | |
| TAO::Portable_Server::ServantRetentionStrategyRetainFactoryImpl | |
| Server_Interceptor | |
| TAO::Utils::Server_Main< SERVANT > | |
| ServerObject_i | Class for pinging a server. Implementation Repository uses this to communicate with the IMR registered servers |
| CORBA::ServerRequest | Class representing the CORBA ServerRequest pseudo-object |
| TAO::ServerRequestDetails | The policy-driven details for a registered server request interceptor |
| TAO::ServerRequestInfo | Implementation of the PortableInterceptor::ServerRequestInfo IDL interface |
| PortableInterceptor::ServerRequestInterceptor | |
| TAO::ServerRequestInterceptor_Adapter | |
| TAO::ServerRequestInterceptor_Adapter_Impl | ServerRequestInterceptor_Adapter_Impl |
| TAO::Special_Basic_Arg_Traits_T< T, to_T, from_T, Insert_Policy > | Template class for stub argument traits of (w)char/boolean/octet |
| TAO::Special_Basic_SArg_Traits_T< T, to_T, from_T, Insert_Policy > | Template class for skeleton argument traits of (w)char/boolean/octet |
| TAO::Special_Basic_Tag | Struct for basic IDL type arguments id tag |
| TAO::Transport::Stats | |
| TAO::CSD::Strategy_Base | Base class for all Custom Servant Dispatching Strategies |
| TAO_CSD_Strategy_Repository::Strategy_Node | |
| TAO::CSD::Strategy_Proxy | Proxy class for the Custom Servant Dispatching Strategy |
| TAO::Portable_Server::StrategyFactory | |
| TAO::TypeCode::String< RefCountPolicy > | CORBA::TypeCode implementation for OMG IDL string types |
| TAO::TypeCode::String< TAO::Null_RefCount_Policy > | |
| TAO::details::string_const_sequence_element< traits > | |
| TAO::String_Manager_T< charT > | |
| TAO::String_out< charT > | String_out |
| TAO::details::string_sequence_element< traits > | |
| TAO::details::string_traits< charT, dummy > | |
| TAO::TypeCodeFactory::String_Traits< CORBA::Any::from_string > | |
| TAO::TypeCodeFactory::String_Traits< CORBA::Any::from_wstring > | |
| TAO::details::string_traits_base< charT > | |
| TAO::details::string_traits_base< char > | |
| TAO::details::string_traits_base< CORBA::WChar > | |
| TAO::details::string_traits_decorator< char_type, derived > | |
| TAO::String_var< charT > | |
| TAO::String_Var_Equal_To | |
| TAO::TypeCode::Struct< StringType, TypeCodeType, FieldArrayType, RefCountPolicy > | CORBA::TypeCode implementation for an OMG IDL struct or exception |
| TAO::TypeCode::Struct< char const *, CORBA::TypeCode_ptr const *, Struct_Field< char const *, CORBA::TypeCode_ptr const * > const *, TAO::Null_RefCount_Policy > | |
| TAO::TypeCode::Struct_Field< StringType, TypeCodeType > | Name/type pair for fields of an OMG IDL defined structure or exception |
| 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 |
| TAO | |
| TAO_Abstract_ServantBase | |
| TAO_Accept_Strategy< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 > | |
| TAO_Acceptor | Abstract Acceptor class used for pluggable transports |
| TAO_Acceptor_Filter | Interface for mprofile creation strategies |
| TAO_Acceptor_Filter_Factory | Default class for factories providing the endpoint acceptor filter objects |
| TAO_Acceptor_Registry | Acceptor Registry and Generic Acceptor interface definitions. All loaded ESIOP or GIOP acceptor bridges must register with this object |
| TAO_Active_Hint_Strategy | Active hint strategy |
| TAO_Active_Object_Map | Map of object ids to servants |
| TAO_Active_Object_Map_Entry | Value field of the active object map |
| TAO_Adapter | |
| TAO_Adapter_Factory | |
| TAO_Adapter_Registry | |
| TAO_Advanced_Resource_Factory | TAO's default resource factory |
| TAO::TAO_Allocator< handler_type > | Abstract class for TAO allocators. This will be used for derived allocator templates that are capable of allocating a specific type of objects |
| TAO_AMH_DSI_Exception_Holder | This is the class for holding exception |
| TAO_AMH_DSI_Exception_Holder_out | The T_out class for exception holder |
| TAO_AMH_DSI_Exception_Holder_var | The T_var class for exception holder |
| TAO_AMH_DSI_Response_Handler | This is the main class for DSI using AMH |
| TAO_AMH_DSI_Response_Handler_var | The T_var class for response handler |
| TAO_AMH_Response_Handler | Class representing an Asynchronous-Method-Handling (AMH) ResponseHandler (RH) object |
| TAO_AMI_Arguments_Converter_Impl | TAO_AMI_Arguments_Converter_Impl |
| TAO_AnyTypeCode_Adapter | |
| TAO_AnyTypeCode_Adapter_Impl | |
| TAO_Array_Forany_T< T, T_slice, TAG > | Parametrized implementation of _forany class for arrays |
| TAO_Array_Out_T< T, T_var, T_slice, TAG > | Parametrized implementation of _out class for arrays |
| TAO_Array_Var_Base_T< T, T_slice, TAG > | 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 | 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 | Handler registered with the reactor in case of AMI timeouts |
| TAO_Auto_Reference< T > | TAO_Auto_Reference acts as a "smart pointer" for reference-countable instances |
| TAO_Base_Transport_Property | A concrete implementation for connnection property |
| TAO_Base_var | TAO_Base_var |
| TAO_BiDir_Adapter | TAO_BiDir_Adapter |
| TAO_BiDir_ORBInitializer | Messaging ORB initializer |
| TAO_BiDir_PolicyFactory | Policy factory for all Messaging related policies |
| TAO_BiDIR_Service_Context_Handler | |
| TAO_BidirectionalPolicy | Implementation of the BiDirPolicy::BidirectionalPolicy |
| TAO_BiDirGIOP_Loader | Class that loads the BiDir library |
| TAO_BiDirPolicy_Validator | Policy Validator for BiDir GIOP class |
| TAO_Binary_Search_OpTable | Helper class for using binary search operatin lookup strategy in the server skeletons |
| 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::TAO_Buffer_Allocator< handler_type, alloc_type > | Generic buffer allocator for TAO |
| TAO_CDR_Encaps_Codec | Implementation of a CDR encapsulation coder/decoder (Codec) |
| TAO_ChunkInfo | |
| 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_Network_Priority_Policy | Implementation class for TAO-specific Network Priority Policy |
| TAO_Client_Strategy_Factory | Abstract factory used by the client to manufacture various strategies used on the client-side |
| TAO_ClientProtocolPolicy | RTCORBA::ClientProtocolPolicy implementation |
| TAO_ClientRequestInfo | Implementation of the PortableInterceptor::ClientRequestInfo interface |
| TAO_ClientRequestInterceptor_Adapter_Factory | TAO_ClientRequestInterceptor_Adapter_Factory |
| TAO_ClientRequestInterceptor_Adapter_Factory_Impl | |
| TAO_CodecFactory | Implementation of the IOP::CodecFactory interface |
| TAO_CodecFactory_Loader | |
| TAO_Codeset_Descriptor | |
| TAO_Codeset_Descriptor_Base | |
| TAO_Codeset_Initializer | |
| TAO_Codeset_Manager | The encapsulation of logic for codeset negotiation |
| TAO_Codeset_Manager_Factory | Class loader for initializing a codeset manager |
| TAO_Codeset_Manager_Factory_Base | Base class for creating instances of the codeset manager |
| TAO_Codeset_Manager_i | |
| TAO_Codeset_Parameters | A simple storage class for the native codeset and any translators that must be configured when creating an instance of codeset manager |
| TAO_Codeset_Service_Context_Handler | |
| TAO_Codeset_Translator_Base | Abstract base Translator component for interaction with TAO |
| 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_Compression_Loader | Class that loads the Compression library |
| 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_Configurable_Refcount | Definition for a synchronised refcountable interface |
| 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_ConnectionTimeoutPolicy | |
| TAO_Connector | Generic Connector interface definitions |
| TAO_Connector_Registry | Per-ORB TAO Connector Registry |
| TAO_Continuous_Priority_Mapping | Maps the first n CORBA priorities to the range of native priorities, where n is the number of native priorities |
| TAO_CORBA_Policy_Perfect_Hash_OpTable | |
| 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_CSD_Default_Servant_Dispatcher | Interface for CSD_POA servant dispatching strategies |
| TAO_CSD_Framework_Loader | TAO_CSD_Framework_Loader |
| TAO_CSD_Object_Adapter | Defines the CSD version Object Adapter which overrides default dispatch implementation |
| TAO_CSD_Object_Adapter_Factory | |
| TAO_CSD_ORBInitializer | |
| TAO_CSD_POA | |
| TAO_CSD_Strategy_Factory | An ACE_Service_Object capable of creating TP_Strategy objects |
| TAO_CSD_Strategy_Repository | |
| TAO_CSD_ThreadPool | |
| TAO_Default_Acceptor_Filter | Default Acceptor_Filter |
| 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_Resource_Factory | TAO's default resource factory |
| TAO_Default_Servant_Dispatcher | Concrete instantiation of the Servant_Dispatcher strategy |
| 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_DiffServ_Network_Priority_Hook | |
| TAO_DiffServ_PolicyFactory | Policy factory for all DiffServ related policies |
| TAO_DiffServ_Service_Context_Handler | |
| TAO_DiffServPolicy_Initializer | |
| TAO_DiffServPolicy_ORBInitializer | DiffServ Policy ORB initializer |
| TAO_DII_Arguments_Converter_Impl | TAO_DII_Arguments_Converter_Impl |
| TAO_DII_Asynch_Reply_Dispatcher | Reply dispatcher for DII asynch requests |
| TAO_DII_Deferred_Reply_Dispatcher | Reply dispatcher for DII deferred requests |
| TAO_DII_Reply_Handler | The class for DII reply handler |
| TAO_DII_Reply_Handler_var | The T_var class for reply handler |
| TAO_DIOP_Acceptor | TAO_DIOP_Acceptor |
| TAO_DIOP_Connection_Handler | Handles requests on a single connection |
| TAO_DIOP_Connector | DIOP-specific Connector bridge for pluggable protocols |
| TAO_DIOP_Endpoint | TAO_DIOP_Endpoint |
| TAO_DIOP_Profile | This class defines the protocol specific attributes required for locating ORBs over a TCP/IP network |
| TAO_DIOP_Protocol_Factory | |
| TAO_DIOP_Protocol_Properties | |
| TAO_DIOP_Transport | Specialization of the base TAO_Transport class to handle the DIOP protocol |
| TAO_Direct_Priority_Mapping | A simple implementation of the Priority_Mapping interface |
| TAO_DistributableThread | |
| TAO_DistributableThread_Factory | |
| TAO_DLL_Parser | Implment the parser for the DLL-style IORs |
| TAO_DS_Network_Priority_Protocols_Hooks | |
| TAO_DTId_Hash | Hashing class for Distributable Thread Ids |
| TAO_Dynamic_Adapter | TAO_Dynamic_Adapter |
| TAO_Dynamic_Adapter_Impl | |
| TAO_Dynamic_Hash_OpTable | Dynamic Hashing scheme for CORBA IDL operation name lookup |
| TAO_Dynamic_Thread_Pool_Threads | Class representing a dynamic thread running in a thread lane |
| TAO_DynamicAny_Loader | |
| TAO_DynamicImplementation | Base class for DSI |
| TAO_DynAny_i | Implementation of the basic Dynamic Any datatype |
| TAO_DynAnyFactory | |
| TAO_DynArray_i | |
| TAO_DynCommon | |
| TAO_DynEnum_i | |
| TAO_DynSequence_i | |
| TAO_DynStruct_i | |
| TAO_DynUnion_i | |
| TAO_DynValue_i | Implementation of the DynValue class |
| TAO_DynValueBox_i | Implementation of the DynValueBox class |
| TAO_DynValueCommon_i | Implementation of the DynValueCommon class |
| TAO_Encodable | TAO_Encodable Interface |
| TAO_Endpoint | Defines the Endpoint interface in the Pluggable Protocol framework |
| TAO_Endpoint_Acceptor_Filter | Subclass of default Acceptor_Filter |
| TAO_Endpoint_Acceptor_Filter_Factory | The factory of the TAO_Endpoint_Acceptor_Filter objects |
| TAO_Endpoint_Selector_Factory | Factory for initializing <Endpoint_Selection_State> and obtaining appropriate <Invocation_Endpoint_Selector> |
| TAO_Endpoint_Value_Impl | |
| TAO_EndpointPolicy_Factory | Policy factory for the endpoint policies |
| TAO_EndpointPolicy_i | Implementation class for TAO-specific Endpoint Policy |
| TAO_EndpointPolicy_Initializer | |
| TAO_EndpointPolicy_ORBInitializer | EndpointPolicy ORB initializer |
| TAO_ETCL_Literal_Constraint | |
| TAO_Event_Handler_Array_var | Auto pointer like class for an array of Event Handlers |
| TAO_Exclusive_TMS | |
| TAO_Fault_Tolerance_Service | TAO_Fault_Tolerant_Service |
| TAO_FIFO_Connection_Purging_Strategy | The First In First Out connection purging strategy |
| 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, TAG > | Parametrized implementation of _var class for arrays with elements of fixed size |
| TAO_FixedSeq_Var_T< T > | 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::TAO_GIOP_DII_Asynch_Invocation | This class is responsible to send the asynchronous invocation |
| TAO_GIOP_Fragmenation_Strategy | Abstract base class that defines TAO fragmentation strategy interface |
| TAO_GIOP_Fragmentation_Strategy | |
| TAO_GIOP_Locate_Request_Header | Location service support |
| TAO_GIOP_Locate_Status_Msg | Hold the relevant information for every type of Locate 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_State | Generic definitions for Message States |
| TAO_GIOP_Message_Version | Major and Minor version number of the Inter-ORB Protocol |
| TAO_GIOP_Protocol_Properties | |
| TAO_HTTP_Client | HTTP_Client is intended to provide application API to classes that wish to do network i/o at a very high level of abstraction |
| TAO_HTTP_Handler | |
| TAO_HTTP_Parser | Implements the <http:> IOR format |
| TAO_HTTP_Reader | |
| TAO_Id_Assignment_Strategy | Id uniqueness strategy |
| TAO_Id_Hint_Strategy | Id uniqueness strategy |
| TAO_Id_Uniqueness_Strategy | Id uniqueness strategy |
| TAO_IFR_Client_Adapter | TAO_IFR_Client_Adapter |
| TAO_IFR_Client_Adapter_Impl | TAO_IFR_Client_Adapter_Impl |
| TAO_Ignore_Original_Key_Adapter | A key adapter (encode/decode) class |
| TAO_IIOP_Acceptor | TAO_IIOP_Acceptor |
| TAO_IIOP_Connection_Handler | Handles requests on a single connection |
| TAO_IIOP_Connection_Handler_Array_Guard | |
| TAO_IIOP_Connector | IIOP-specific Connector bridge for pluggable protocols |
| TAO_IIOP_Endpoint | TAO_IIOP_Endpoint |
| TAO_IIOP_Profile | This class defines the protocol specific attributes required for locating ORBs over a TCP/IP network |
| TAO_IIOP_Protocol_Factory | |
| TAO_IIOP_Protocol_Properties | |
| TAO_IIOP_Transport | |
| TAO_Incoming_Message_Queue | A queue of the messages in the incoming data path |
| TAO_Incremental_Key_Generator | Defines a key generator |
| TAO_InputCDR | A CDR stream for reading, i.e. for demarshalling |
| TAO_Intrusive_Ref_Count_Base< ACE_LOCK > | Template base class to provide intrusive reference-counting to subclasses. This makes the subclass capable of using a TAO_Intrusive_Ref_Count_Handle<X> class as a smart-pointer to an X object. In this case, X is a sub-class of this class, TAO_Intrusive_Ref_Count_Base<ACE_LOCK>. The ACE_LOCK type is used to protect the atomic reference count data member |
| TAO_Intrusive_Ref_Count_Handle< T > | Template class for smart-pointer to (intrusively) ref-counted object |
| TAO_Intrusive_Ref_Count_Object< OBJ, ACE_LOCK > | Template class as wrapper of a non reference counted data type but provide intrusive reference-counting feature by inherited from TAO_Intrusive_Ref_Count_Base. This makes the parameterized type data be smart pointer by using a TAO_Intrusive_Ref_Count_Handle<X> to an this wrapper object |
| TAO_Invocation_Endpoint_Selector | Defines the interface for policy-based endpoint selection strategies |
| TAO_IOR_Manipulation_impl | |
| TAO_IOR_Parser | Defines the interface for the pluggable IOR parser components |
| TAO_IOR_Table_Impl | |
| TAO_IORInfo | This class exposes an interface that allows IORInterceptors add tagged components to IORs |
| TAO_IORInterceptor_Adapter | TAO_IORInterceptor_Adapter |
| TAO_IORInterceptor_Adapter_Factory | TAO_IORInterceptor_Adapter_Factory |
| TAO_IORInterceptor_Adapter_Factory_Impl | TAO_IORInterceptor_Adapter_Factory_Impl |
| TAO_IORInterceptor_Adapter_Impl | TAO_IORInterceptor_Adapter_Impl |
| TAO_IORManip_Filter | |
| TAO_IORManip_IIOP_Filter | |
| TAO_IORManip_Loader | |
| TAO_IORTable_Initializer | |
| 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_Multi_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_LF_Strategy_Null | A concrete TAO_LF_Strategy for ORB configurations that do not use the Leader/Followers event loop |
| TAO_LFU_Connection_Purging_Strategy | The Least Frequently Used connection purging strategy |
| TAO_Lifespan_Strategy | Lifespan strategy |
| TAO_Linear_Network_Priority_Mapping | A simple implementation of the Network_Priority_Mapping interface |
| TAO_Linear_Priority_Mapping | A simple implementation of the Priority_Mapping interface |
| TAO_Linear_Search_OpTable | Operation table lookup strategy based on linear search. Not efficient, but it works |
| TAO_Local_RefCounted_Object | This class is there to keep backwards compatibility to the v1.1 C++ mapping |
| TAO_Local_ServantBase | Base class for local servants |
| 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_Messaging_Initializer | |
| TAO_Messaging_Loader | |
| 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_Multi_Priority_Mapping | An implementation of the Priority_Mapping interface for communication between different platforms |
| TAO_Multiple_Id_Strategy | Multiple id strategy |
| TAO_Muxed_TMS | |
| TAO_Named_RT_Mutex_Manager | Manages the names of named and unnamed RT Mutexes |
| TAO_Network_Priority_Hook | |
| TAO_Network_Priority_Mapping | The interface for priority mapping |
| TAO_Network_Priority_Mapping_Manager | Network_Priority_Mapping_Manager pseudo-objref |
| TAO_Network_Priority_Mapping_Manager_out | |
| TAO_Network_Priority_Mapping_Manager_var | |
| TAO_Network_Priority_Protocols_Hooks | |
| TAO_New_Leader_Generator | Class for creating dynamic threads |
| TAO_No_Hint_Strategy | No hint strategy |
| TAO_NULL_Connection_Purging_Strategy | The null connection purging strategy |
| TAO_Null_Fragmenation_Strategy | Null GIOP message fragmentation strategy |
| TAO_Null_Fragmentation_Strategy | |
| TAO_NVList_Adapter | |
| TAO_NVList_Adapter_Impl | |
| TAO_Object_Adapter | Defines the Object Adapter abstraction |
| TAO_Object_Adapter_Factory | |
| TAO_Object_Loader | A class to dynamically load object implementations into an ORB |
| TAO_Object_Ref_Table | Keep a table de-stringified object references registered with the ORB |
| TAO_ObjectId_Hash | Hashing class for Object Ids |
| 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_OC_Endpoint_Selector_Factory | Factory for initializing <Endpoint_Selection_State> and obtaining appropriate <Invocation_Endpoint_Selector> |
| TAO_OC_Endpoint_Selector_Loader | Static initializer used to ensure the Optimized Connector Endpoint Selector is available for use in static applications |
| TAO_On_Demand_Fragmenation_Strategy | On Demand GIOP message fragmentation strategy |
| TAO_On_Demand_Fragmentation_Strategy | |
| TAO_operation_db_entry | Define a table entry that holds an operation name and its corresponding skeleton. A table of such entries is used to initialize the different lookup strategies |
| TAO_Operation_Details | Class with operation details |
| TAO_Operation_Table | Abstract class for maintaining and lookup of CORBA IDL operation names |
| TAO_Optimized_Connection_Endpoint_Selector | More efficient connection strategy for endpoint selection |
| 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_Manager | Helper class for simple ORB/POA initialization and registering servants with the POA |
| TAO_ORB_Parameters | Parameters that are specific to the ORB. These parameters can be for the client, the server, or for both |
| TAO_ORBInitInfo | An implementation of the PortableInterceptor::ORBInitInfo_3_1 interface |
| TAO_Out_T< T > | 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_Perfect_Hash_OpTable | Helper class for use of perfect hashing operation lookup strategy |
| TAO_Persistent_Strategy | Persistent strategy |
| TAO_PI_Init | |
| TAO_PI_ORBInitializer | PortableServer ORB initializer |
| TAO_PI_PolicyFactory | Policy factory for all PortableInterceptor related policies |
| TAO_PI_Server_Init | |
| TAO_PI_Server_Loader | |
| TAO_PICurrent_Loader | |
| TAO_Pluggable_Reply_Params | TAO_Pluggable_Connector_Params |
| TAO_Pluggable_Reply_Params_Base | TAO_Pluggable_Reply_Params_Base |
| TAO_POA_Current_Factory | |
| TAO_POA_Default_Policy_Validator | |
| TAO_POA_Initializer | |
| TAO_POA_Manager | |
| TAO_POA_Policy_Set | |
| TAO_POA_RT_Policy_Validator | |
| TAO_POA_Static_Resources | The static (global) resoures of all POA's |
| TAO_POAManager_Factory | |
| 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_Loader | |
| TAO_PolicyFactory_Registry | ORB-specific PortableInterceptor::PolicyFactory registry |
| TAO_PolicyFactory_Registry_Factory | |
| TAO_PortableServer_ORBInitializer | PortableServer ORB initializer |
| TAO_PortableServer_PolicyFactory | Policy factory for all PortableServer related policies |
| TAO_Preserve_Original_Key_Adapter | A key adapter (encode/decode) class |
| TAO_Priority_Mapping | The interface for priority mapping |
| TAO_Priority_Mapping_Manager | Priority_Mapping_Manager pseudo-objref |
| TAO_Priority_Mapping_Manager_out | |
| TAO_Priority_Mapping_Manager_var | |
| TAO_PriorityBandedConnectionPolicy | RTCORBA::PriorityBandedConnectionPolicy implementation |
| TAO_PriorityModelPolicy | RTCORBA::PriorityModelPolicy implementation |
| TAO_PrivateConnectionPolicy | RTCORBA::PrivateConnectionPolicy implementation |
| TAO_ProcessingModePolicy | Implementation class for Portable Interceptor ProcessingModePolicy |
| TAO_Profile | Defines the Profile interface |
| TAO_Protocol_Factory | |
| TAO_Protocol_Item | |
| TAO_Protocol_Properties_Factory | |
| TAO_Protocols_Hooks | |
| TAO_Pseudo_Out_T< T > | 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_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_Regular_POA | |
| TAO_RelativeRoundtripTimeoutPolicy | |
| 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_RequestInterceptor_Adapter_Impl | A convenient helper class to invoke registered client request interceptors |
| TAO_Resource_Factory | Factory which manufacturers resources for use by the ORB Core |
| TAO_Resource_Factory_Changer | |
| TAO_Resume_Handle | A utility class that helps in resuming handlers if TAO uses a TP Reactor from ACE |
| TAO_Root_POA | |
| TAO_RT_Collocation_Resolver | This class helps decide on collocation among the maze of thread pools and lanes |
| TAO_RT_Current | RTCORBA::Current interface iplementation |
| TAO_RT_Endpoint_Utils | |
| TAO_RT_Invocation_Endpoint_Selector | TAO_RT_Invocation_Endpoint_Selector |
| TAO_RT_Mutex | Abstract base class for the TAO RT Mutex implementations |
| TAO_RT_New_Leader_Generator | Class for creating dynamic threads |
| TAO_RT_Object_Adapter_Factory | |
| TAO_RT_ORB | RTCORBA::RTORB implementation |
| TAO_RT_ORB_Loader | |
| TAO_RT_ORBInitializer | RTCORBA ORB initializer |
| TAO_RT_POA | |
| TAO_RT_PolicyFactory | Policy factory for all RTCORBA related policies |
| TAO_RT_Protocols_Hooks | |
| TAO_RT_Servant_Dispatcher | Concrete instantiation of the Servant_Dispatcher strategy |
| TAO_RT_Stub | |
| TAO_RT_Stub_Factory | |
| TAO_RT_Thread_Lane_Resources_Manager | Manager for thread lane resources |
| TAO_RT_Thread_Lane_Resources_Manager_Factory | This class is a factory for managers of thread resources |
| TAO_RT_Transport_Descriptor | Transport Descriptor for RTCORBA |
| TAO_RT_Transport_Descriptor_Banded_Connection_Property | Descriptor Property for Banded Connections |
| TAO_RT_Transport_Descriptor_Private_Connection_Property | Descriptor Property for Private Connections |
| TAO_RT_Transport_Descriptor_Property | Base RT Transport Descriptor Property that can be <insert> ed into the TAO_RT_Transport_Descriptor class |
| TAO_RTCORBA_Initializer | |
| TAO_RTPortableServer_Initializer | |
| TAO_RTScheduler_Current | |
| TAO_RTScheduler_Current_i | |
| TAO_RTScheduler_Current_var | |
| TAO_RTScheduler_Initializer | |
| TAO_RTScheduler_Loader | |
| TAO_RTScheduler_Manager | RTScheduler_Manager pseudo-objref |
| TAO_RTScheduler_Manager_out | |
| TAO_RTScheduler_Manager_var | |
| TAO_RTScheduler_ORB_Initializer | RTCORBA ORB initializer |
| TAO_SCIOP_Endpoint_Info | Stores information for a single SCIOP endpoint |
| TAO_SCIOP_Protocol_Properties | |
| TAO_Seq_Out_T< T > | Parametrized implementation of _out class for sequences |
| TAO_Seq_Var_Base_T< T > | Parametrized implementation of _var base class for sequences |
| TAO_Servant_Dispatcher | Interface for POA servant dispatching strategies |
| TAO_Servant_Hash | |
| TAO_ServantBase | Base class for skeletons and servants |
| TAO_Server_Network_Priority_Policy | Implementation class for TAO-specific Network Priority Policy |
| TAO_Server_Protocol_Acceptor_Filter | Populates mprofile with endpoints selected based on the RTCORBA::ServerProtocolPolicy |
| 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_ServerProtocolPolicy | RTCORBA::ServerProtocolPolicy implementation |
| TAO_ServerRequest | Class representing a ServerRequest object |
| TAO_ServerRequestInterceptor_Adapter_Factory | TAO_ServerRequestInterceptor_Adapter_Factory |
| TAO_ServerRequestInterceptor_Adapter_Factory_Impl | |
| 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_Service_Context_Handler | |
| TAO_Service_Context_Registry | |
| TAO_Services_Activate | A class to dynamically load callback implementations in to an ORB |
| TAO_SharedMemory_Protocol_Properties | RTCORBA::SharedMemoryProtocolProperties implementation |
| TAO_SHMIOP_Protocol_Properties | |
| TAO_Singleton< TYPE, ACE_LOCK > | TAO-specific Singleton class |
| TAO_Singleton_Manager | Manager for TAO library services and singleton cleanup |
| TAO_Smart_Proxy_Base | A base class for all TAO_IDL generated smart proxy base classes |
| TAO_Strategies_ORBInitializer | |
| TAO_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 > | |
| TAO_StreamControl_Protocol_Properties | RTCORBA::StreamControlProtocolProperties implementation |
| 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_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 Synchronous Method Invocation (SMI)s |
| TAO_System_Id_With_Multiple_Id_Strategy | System id strategy |
| TAO_System_Id_With_Unique_Id_Strategy | System id strategy |
| TAO_Table_Adapter | |
| TAO_Table_Adapter_Factory | |
| 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_TCP_Protocol_Properties | RTCORBA::TCPProtocolProperties implementation |
| TAO_Thread_Lane | Class representing the thread lane inside a thread pool |
| 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_Thread_Pool | Class representing the thread pool inside a thread pool manager |
| TAO_Thread_Pool_Manager | Class for managing thread pools |
| TAO_Thread_Pool_Threads | Class representing a static thread running in a thread lane |
| TAO_ThreadAction | |
| TAO_ThreadpoolPolicy | RTCORBA::ThreadpoolPolicy implementation |
| TAO_Transient_Strategy | Transient strategy |
| TAO_Transport | Generic definitions for the Transport class |
| 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_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_TypeCodeFactory_Adapter_Impl | TAO_TypeCodeFactory_Adapter_Impl |
| TAO_TypeCodeFactory_i | TAO_TypeCodeFactory_i |
| TAO_TypeCodeFactory_Loader | Create an instance of TypeCodeFactory and return it to the caller |
| TAO_UIOP_Acceptor | The UIOP-specific bridge class for the concrete acceptor |
| TAO_UIOP_Connection_Handler | Handles requests on a single connection |
| TAO_UIOP_Connector | UIOP-specific Connector bridge for pluggable protocols |
| TAO_UIOP_Endpoint | TAO_UIOP_Endpoint |
| TAO_UIOP_Endpoint_Info | Stores information for a single UIOP endpoint |
| TAO_UIOP_Profile | This class defines the protocol specific attributes required for locating ORBs over local IPC |
| TAO_UIOP_Protocol_Factory | |
| TAO_UIOP_Protocol_Properties | |
| TAO_UIOP_Transport | Specialization of the base TAO_Transport class to handle the UIOP protocol |
| TAO_Unique_Id_Strategy | Unique id strategy |
| TAO_UnixDomain_Protocol_Properties | RTCORBA::UnixDomainProtocolProperties implementation |
| TAO_Unknown_Profile | A TAO_Profile class to handle foreign profiles |
| TAO_User_Id_Strategy | User id strategy |
| TAO_UserDatagram_Protocol_Properties | RTCORBA::UserDatagramProtocolProperties implementation |
| TAO_UTF16_BOM_Factory | |
| TAO_UTF16_BOM_Translator | Codeset translation specialization - Manages Byte Order Marker |
| TAO_UTF8_Latin1_Factory | |
| TAO_UTF8_Latin1_Translator | |
| TAO_Value_Out_T< T > | |
| TAO_Value_Var_T< T > | Parametrized implementation of _var class for valuetypes |
| TAO_ValueFactory_Map | |
| TAO_Valuetype_Adapter | TAO_Valuetype_Adapter |
| TAO_Valuetype_Adapter_Factory | TAO_Valuetype_Adapter_Factory |
| TAO_Valuetype_Adapter_Factory_Impl | TAO_Valuetype_Adapter_Factory_Impl |
| TAO_Valuetype_Adapter_Impl | TAO_Valuetype_Adapter_Impl |
| 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, TAG > | Parametrized implementation of _var class for arrays with elements of variable size |
| TAO_VarSeq_Var_T< T > | 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_LF_No_Upcall | Wait according to the Leader-Follower model (like TAO_Wait_On_Leader_Follower), but do not allow nested upcalls |
| 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_ZIOP_Adapter | TAO_ZIOP_Adapter |
| TAO_ZIOP_Loader | Class that loads the BiDir library |
| TAO_ZIOP_ORBInitializer | ZIOP ORB initializer |
| TAO_ZIOP_PolicyFactory | Policy factory for all Messaging related policies |
| TAO_ZIOP_Stub | |
| TAO_ZIOP_Stub_Factory | |
| TAO_ZIOPPolicy_Validator | Policy Validator for ZIOP policies |
| TAO::TypeCodeFactory::TC_Info | |
| TAO::Portable_Server::Temporary_Creation_Time | |
| TAO::Portable_Server::ThreadPolicy | |
| TAO::Portable_Server::ThreadStrategy | |
| TAO::Portable_Server::ThreadStrategyFactory | |
| TAO::Portable_Server::ThreadStrategyFactoryImpl | |
| TAO::Portable_Server::ThreadStrategyORBControl | |
| TAO::Portable_Server::ThreadStrategySingle | |
| TAO::Portable_Server::ThreadStrategySingleFactoryImpl | |
| TAO::TkResource_Factory | TAO_GUI_Resource_Factory for creating TkReactor |
| TAO::TkResource_Loader | Loads TAO resources related with Tk |
| CORBA::Any::to_abstract_base | |
| CORBA::Any::to_object | These are not in ACE |
| CORBA::Any::to_value | |
| TAO::CSD::TP_Cancel_Visitor | Used to extract/cancel request(s) from the queue |
| TAO::CSD::TP_Collocated_Asynch_Request | Represents a "queue-able", collocated, asynchronous, CORBA request |
| TAO::CSD::TP_Collocated_Synch_Request | Represents a "queue-able", synchronous, collocated, CORBA request |
| TAO::CSD::TP_Collocated_Synch_With_Server_Request | Represents a "queue-able", one-way, collocated, CORBA request with a "Synch Scope" policy of SYNC_WITH_SERVER |
| TAO::CSD::TP_Corba_Request | Base class for "queue-able" CORBA requests |
| TAO::CSD::TP_Custom_Asynch_Request | Base class for "queue-able", Custom (non-CORBA), Synchronous requests |
| TAO::CSD::TP_Custom_Request | Base class for "queue-able" Custom (non-CORBA) requests |
| TAO::CSD::TP_Custom_Request_Operation | Base class for all custom request operations |
| TAO::CSD::TP_Custom_Synch_Request | Base class for "queue-able", Custom (non-CORBA), Synchronous requests |
| TAO::CSD::TP_Dispatchable_Visitor | Used to extract the first "dispatchable" request from the queue |
| TAO::CSD::TP_Queue | Queue of servant requests that need to be dispatched |
| TAO::CSD::TP_Queue_Visitor | Base class for vistors of the elements in the TP_Queue |
| TAO::CSD::TP_Remote_Request | Represents a "queue-able", remote, CORBA request. Both syncronous and asynchronous remote CORBA requests are represented by the class |
| TAO::CSD::TP_Request | Base class for "queue-able" requests |
| TAO::CSD::TP_Servant_State | Maintains state information for a particular servant |
| TAO::CSD::TP_Servant_State_Map | Map of Servant_State objects - one per servant |
| TAO::CSD::TP_Strategy | A simple custom Thread-Pool servant dispatching strategy class |
| TAO::CSD::TP_Strategy_Factory | An ACE_Service_Object capable of creating TP_Strategy objects |
| TP_Strategy_Factory | An ACE_Service_Object capable of creating TP_Strategy objects |
| TAO::CSD::TP_Synch_Helper | Helper class for synchronous requests to block the requesting thread until the appropriate time (when it will be un-blocked) |
| TAO::CSD::TP_Task | Active Object managing a queue of request objects |
| TAO::TypeCode::Traits< DYNAMIC_TYPECODE > | |
| TAO::TypeCode::Traits< STATIC_TYPECODE > | |
| TAO::TypeCode::Traits< Traits< DYNAMIC_TYPECODE >::typecode_type > | |
| TAO::TypeCode::Traits< Traits< STATIC_TYPECODE >::typecode_type > | |
| TAO_Codeset_Descriptor::Translator_Node | |
| TAO::Transport_Cache_Manager_T< TT, TRDT, PSTRAT > | The Transport Cache Manager for TAO |
| TAO::Transport_Queueing_Strategy | Define the interface for the Queueing Strategy |
| TAO::Transport_Selection_Guard | Used by the Transport Current feature to keep track of which Transport is currently active |
| TAO::True_RefCount_Policy | True reference counting policy |
| CORBA::TypeCode | A representation of the structure of a given OMG IDL-declared type |
| TAO::UB_String_Arg_Traits_T< T_var, Insert_Policy > | 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::details::unbounded_array_allocation_traits< T, dummy > | |
| TAO::unbounded_array_sequence< T_array, T_slice, T_tag > | |
| TAO::unbounded_basic_string_sequence< charT > | |
| TAO::unbounded_bd_string_sequence< charT, BD_STR_MAX > | |
| TAO::unbounded_object_reference_sequence< object_t, object_t_var > | |
| TAO::details::unbounded_reference_allocation_traits< T, ref_traits, dummy > | |
| TAO::details::unbounded_value_allocation_traits< T, dummy > | |
| TAO::unbounded_value_sequence< T > | |
| TAO::unbounded_value_sequence< CORBA::Octet > | |
| TAO::details::unbounded_valuetype_allocation_traits< T, ref_traits, dummy > | |
| TAO::unbounded_valuetype_sequence< object_t, object_t_var > | |
| TAO::TypeCode::Union< StringType, TypeCodeType, CaseArrayType, RefCountPolicy > | CORBA::TypeCode implementation for an OMG IDL union |
| TAO::TypeCode::Union< char const *, CORBA::TypeCode_ptr const *, Case< char const *, CORBA::TypeCode_ptr const * > const *const *, TAO::Null_RefCount_Policy > | |
| TAO::Unknown_IDL_Type | CDR-based Any impl class |
| CORBA::UnknownUserException | UnknownUserException |
| TAO::Upcall_Command | "ABC" that all operation-specific command objects must subclass |
| TAO::Upcall_Wrapper | Wraps the activities of the _skel operations |
| CORBA::UserException | Application- or OMG- defined CORBA exception sub-class |
| UtcT | A timestamp in UTC time |
| UTF8_Latin1_Translator | Codeset translation specialization - Manages Byte Order Marker |
| TAO::TypeCode::Value< StringType, TypeCodeType, FieldArrayType, RefCountPolicy > | CORBA::TypeCode implementation for an OMG IDL valuetype or event |
| TAO::TypeCode::Value< char const *, CORBA::TypeCode_ptr const *, Value_Field< char const *, CORBA::TypeCode_ptr const * > const *, TAO::Null_RefCount_Policy > | |
| TAO::TypeCode::Value_Field< StringType, TypeCodeType > | Name/type/visibility tuple fields of an OMG IDL defined valuetype or eventtype |
| TAO::details::value_traits< T, dummy > | |
| TAO::Value_Traits< CORBA::ValueBase > | |
| TAO::Value_Traits< CORBA::ValueFactoryBase > | Specializations needed for using with Value_Var_T |
| CORBA::ValueBase | Abstract baseclass for Valuetypes |
| CORBA::ValueFactoryBase | |
| TAO::details::valuetype_sequence_element< obj_ref_traits > | |
| TAO::details::valuetype_traits< object_t, object_t_var, dummy > | |
| TAO::details::valuetype_traits_base< object_t, object_t_var > | |
| TAO::details::valuetype_traits_decorator< object_t, object_t_var, derived > | |
| TAO::Var_Array_Arg_Traits_T< T_out, T_forany, Insert_Policy > | Argument traits of variable size element array |
| TAO::Var_Array_SArg_Traits_T< T_out, T_forany, Insert_Policy > | Argument traits of variable size element array |
| TAO::Var_Size_Arg_Traits_T< T, Insert_Policy > | Template class for stub argument traits of variable size IDL types |
| TAO::Var_Size_SArg_Traits_T< T, Insert_Policy > | Template class for skeleton argument traits of variable size IDL types |
| TAO::Vector_Arg_Traits_T< T, Insert_Policy > | Template class for stub argument traits of sequence IDL types, when the STL mapping is used by the IDL compiler. The ret_type and out_type typedefs are different from Vector_Arg_Traits_T |
| TAO::Vector_SArg_Traits_T< T, Insert_Policy > | Template class for skeleton argument traits of sequence IDL types, when the STL mapping is used by the IDL compiler. The ret_type and out_type typedefs are different from Vector_SArg_Traits_T |
| TAO::Void_Return_Argument | |
| ACE::VP_traits< TAO::TypeCode::Case_Dynamic > | |
| TAO::Wait_On_LF_No_Upcall | |
| CORBA::WrongTransaction | |
| TAO::XtResource_Factory | TAO_GUI_Resource_Factory for creating XtReactor |
| TAO::XtResource_Loader | Loads TAO resources related with Xt |
| TAO::Zlib_CompressorFactory | |
| TAO::ZlibCompressor | |
1.7.0
