| C_dbghelp_functions | |
| C_WSANETWORKEVENTS | |
| ►CACE_Abstract_Timer_Queue< TYPE > | Base class for all timer queues of a single type |
| ►CACE_Timer_Queue_Upcall_Base< TYPE, FUNCTOR > | |
| ►CACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY > | Provides an interface to timers |
| CACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET, TIME_POLICY > | Provides a hash table of BUCKETs as an implementation for a timer queue |
| CACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY > | Provides a very fast and predictable timer implementation |
| CACE_Timer_List_T< TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY > | Provides a simple implementation of timers |
| CACE_Timer_Wheel_T< TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY > | Provides a Timing Wheel version of ACE_Timer_Queue |
| CACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK > | |
| CACE_Accept_QoS_Params | Wrapper class that simplifies the information passed to the QoS enabled <ACE_OS::accept> method |
| CACE_Accept_Strategy< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 > | Defines the interface for specifying a passive connection acceptance strategy for a SVC_HANDLER |
| CACE_Activation_Queue | Reifies a method into a request. Subclasses typically represent necessary state and behavior |
| CACE_Active_Map_Manager_Key | Key used in the Active Object Map |
| ►CACE_Addr | Defines the base class for the "address family independent" address format |
| CACE_ATM_Addr | Defines the ATM domain address family address format |
| CACE_DEV_Addr | Defines device address family address format |
| CACE_FILE_Addr | Defines the FILE address family address format |
| ►CACE_INET_Addr | Defines a C++ wrapper facade for the Internet domain address family format |
| CACE_Multihomed_INET_Addr | Extends ACE_INET_Addr with support for multi-homed addresses |
| CACE_MEM_Addr | Defines a C++ wrapper facade for the shared memory transport address family format |
| CACE_SPIPE_Addr | Defines the SVR4 STREAM pipe address family address format |
| CACE_UNIX_Addr | Defines the ``UNIX domain address family'' address format |
| ►CACE_Allocator | Interface for a dynamic memory allocator that uses inheritance and dynamic binding to provide extensible mechanisms for allocating and deallocating memory |
| CACE_Allocator_Adapter< MALLOC > | This class is an adapter that allows the ACE_Allocator to use the ACE_Malloc class below |
| ►CACE_New_Allocator | Defines a class that provided a simple implementation of memory allocation |
| CACE_Cached_Allocator< T, ACE_LOCK > | A fixed-size allocator that caches items for quicker access |
| CACE_Dynamic_Cached_Allocator< ACE_LOCK > | A size-based allocator that caches blocks for quicker access |
| ►CACE_Static_Allocator_Base | Defines a class that provided a highly optimized memory management scheme for allocating memory statically |
| CACE_Static_Allocator< POOL_SIZE > | Defines a class that provided a highly optimized memory management scheme for allocating memory statically |
| CACE_Arg_Shifter_T< CHAR_TYPE > | This ADT operates on a specified set of arguments (argv). As known arguments are scanned, they are shifted to the back of the argv vector, so deeper levels of argument parsing can locate the yet unprocessed arguments at the beginning of the vector |
| CACE_ARGV_Queue_Entry_T< CHAR_TYPE > | An entry in the queue which keeps user supplied arguments |
| CACE_ARGV_T< CHAR_TYPE > | Builds a counted argument vector (ala argc/argv) from either a string or a set of separate tokens. This class preserves whitespace within tokens only if the whitespace-containing token is enclosed in either single (') or double (") quotes. This is consistent with the expected behavior if an argument vector obtained using this class is passed to, for example, ACE_Get_Opt |
| CACE_Argv_Type_Converter | To convert 'char' input/command line parameter to 'wchar_t' |
| ►CACE_Array_Base< T > | Implement a simple dynamic array |
| ►CACE_Array< T > | A dynamic array class |
| CACE_Vector< T, DEFAULT_SIZE > | Defines an STL-like vector container |
| ►CACE_Array_Base< ACE_Get_Opt::ACE_Get_Opt_Long_Option * > | |
| CACE_Array< ACE_Get_Opt::ACE_Get_Opt_Long_Option * > | |
| ►CACE_Array_Base< ACE_INET_Addr > | |
| CACE_Array< ACE_INET_Addr > | |
| CACE_Array_Base< char * > | |
| CACE_Array_Iterator< T > | Implement an iterator over an ACE_Array |
| CACE_Array_Map< Key, Value, EqualTo > | Light weight array-based map with fast iteration, but linear (i.e. O(n)) search times |
| CACE_Array_Map< size_t, const ACE_Service_Type * > | |
| CACE_Ascii_To_Wide | A lightweight char* to wchar* string conversion class |
| ►CACE_Asynch_Operation | This is an interface base class for all asynch operations. The resposiblility of this class is to forward all methods to its delegation/implementation class, e.g., ACE_WIN32_Asynch_Operation or ACE_POSIX_Asynch_Operation |
| CACE_Asynch_Accept | This class is a factory for starting off asynchronous accepts on a listen handle. This class forwards all methods to its implementation class |
| CACE_Asynch_Connect | This class is a factory for starting off asynchronous connects This class forwards all methods to its implementation class |
| CACE_Asynch_Read_Dgram | This class is a factory for starting off asynchronous reads on a UDP socket. This class forwards all methods to its implementation class |
| ►CACE_Asynch_Read_Stream | This class is a factory for starting off asynchronous reads on a stream. This class forwards all methods to its implementation class |
| CACE_Asynch_Read_File | This class is a factory for starting off asynchronous reads on a file. This class forwards all methods to its implementation class |
| CACE_Asynch_Transmit_File | This class is a factory for starting off asynchronous transmit files on a stream |
| CACE_Asynch_Write_Dgram | This class is a factory for starting off asynchronous writes on a UDP socket. This class forwards all methods to its implementation class |
| ►CACE_Asynch_Write_Stream | This class is a factory for initiating asynchronous writes on a connected TCP/IP stream. This class forwards all methods to its implementation class |
| CACE_Asynch_Write_File | This class is a factory for starting off asynchronous writes on a file. This class forwards all methods to its implementation class |
| ►CACE_Asynch_Operation_Impl | Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Operation |
| ►CACE_Asynch_Accept_Impl | Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Accept |
| CACE_POSIX_Asynch_Accept | For the POSIX implementation this class is common for all Proactors (AIOCB/SIG/SUN) |
| ►CACE_Asynch_Connect_Impl | Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Connect |
| CACE_POSIX_Asynch_Connect | |
| ►CACE_Asynch_Read_Dgram_Impl | Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Read_Dgram |
| CACE_POSIX_Asynch_Read_Dgram | This class is a factory for starting off asynchronous reads on a UDP socket |
| ►CACE_Asynch_Read_Stream_Impl | Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Read_Stream |
| ►CACE_Asynch_Read_File_Impl | Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Read_File::Result |
| CACE_POSIX_Asynch_Read_File | This class is a factory for starting off asynchronous reads on a file. This class implements <ACE_Asynch_Read_File> for all POSIX implementations of Proactor |
| ►CACE_POSIX_Asynch_Read_Stream | |
| CACE_POSIX_Asynch_Read_File | This class is a factory for starting off asynchronous reads on a file. This class implements <ACE_Asynch_Read_File> for all POSIX implementations of Proactor |
| ►CACE_Asynch_Transmit_File_Impl | Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Transmit_File |
| CACE_POSIX_Asynch_Transmit_File | Implementation for transmit_file will make use of POSIX_Asynch_Transmit_Handler |
| ►CACE_Asynch_Write_Dgram_Impl | Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Write_Dgram class |
| CACE_POSIX_Asynch_Write_Dgram | This class is a factory for starting off asynchronous writes on a UDP socket. The UDP socket must be "connected", as there is no facility for specifying the destination address on each send operation |
| ►CACE_Asynch_Write_Stream_Impl | Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Write_Stream class |
| ►CACE_Asynch_Write_File_Impl | Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Write_File |
| CACE_POSIX_Asynch_Write_File | |
| ►CACE_POSIX_Asynch_Write_Stream | This class implements <ACE_Asynch_Write_Stream> for all POSIX implementations of ACE_Proactor |
| CACE_POSIX_Asynch_Write_File | |
| ►CACE_POSIX_Asynch_Operation | This class implements ACE_Asynch_Operation for all implementations of Proactor (AIOCB, SIG, SUN) Specific future implementations can derive from this class |
| CACE_POSIX_Asynch_Accept | For the POSIX implementation this class is common for all Proactors (AIOCB/SIG/SUN) |
| CACE_POSIX_Asynch_Connect | |
| CACE_POSIX_Asynch_Read_Dgram | This class is a factory for starting off asynchronous reads on a UDP socket |
| CACE_POSIX_Asynch_Read_Stream | |
| CACE_POSIX_Asynch_Transmit_File | Implementation for transmit_file will make use of POSIX_Asynch_Transmit_Handler |
| CACE_POSIX_Asynch_Write_Dgram | This class is a factory for starting off asynchronous writes on a UDP socket. The UDP socket must be "connected", as there is no facility for specifying the destination address on each send operation |
| CACE_POSIX_Asynch_Write_Stream | This class implements <ACE_Asynch_Write_Stream> for all POSIX implementations of ACE_Proactor |
| ►CACE_Asynch_Result | An interface base class which allows users access to common information related to an asynchronous operation |
| CACE_Asynch_Accept::Result | This is that class which will be passed back to the {handler} when the asynchronous accept completes |
| CACE_Asynch_Connect::Result | This is that class which will be passed back to the handler when the asynchronous connect completes |
| CACE_Asynch_Read_Dgram::Result | This is the class which will be passed back to the {handler} when the asynchronous read completes. This class forwards all the methods to the implementation classes |
| ►CACE_Asynch_Read_Stream::Result | This is the class which will be passed back to the ACE_Handler::handle_read_stream when the asynchronous read completes. This class forwards all the methods to the implementation classes |
| CACE_Asynch_Read_File::Result | This is that class which will be passed back to the {handler} when the asynchronous read completes. This class forwards all the methods to the implementation class |
| CACE_Asynch_Transmit_File::Result | This is that class which will be passed back to the {handler} when the asynchronous transmit file completes |
| CACE_Asynch_Write_Dgram::Result | This is that class which will be passed back to the {handler} when the asynchronous write completes. This class forwards all the methods to the implementation class |
| ►CACE_Asynch_Write_Stream::Result | This is that class which will be passed back to the ACE_Handler when the asynchronous write completes. This class forwards all the methods to the implementation class |
| CACE_Asynch_Write_File::Result | This is that class which will be passed back to the {handler} when the asynchronous write completes. This class forwards all the methods to the implementation class |
| ►CACE_Asynch_Result_Impl | Abstract base class for the all the classes that provide concrete implementations for ACE_Asynch_Result |
| ►CACE_Asynch_Accept_Result_Impl | Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Accept |
| CACE_POSIX_Asynch_Accept_Result | This is that class which will be passed back to the handler when the asynchronous accept completes |
| ►CACE_Asynch_Connect_Result_Impl | Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Connect |
| CACE_POSIX_Asynch_Connect_Result | This is that class which will be passed back to the completion handler when the asynchronous connect completes |
| ►CACE_Asynch_Read_Dgram_Result_Impl | Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Read_Dgram::Result class |
| CACE_POSIX_Asynch_Read_Dgram_Result | This is class provides concrete implementation for ACE_Asynch_Read_Dgram::Result class |
| ►CACE_Asynch_Read_Stream_Result_Impl | Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Read_Stream::Result class |
| ►CACE_Asynch_Read_File_Result_Impl | This is the abstract base class for all the concrete implementation classes for ACE_Asynch_Read_File::Result |
| CACE_POSIX_Asynch_Read_File_Result | This class provides concrete implementation for <ACE_Asynch_Read_File::Result> class for POSIX platforms |
| ►CACE_POSIX_Asynch_Read_Stream_Result | This class provides concrete implementation for <ACE_Asynch_Read_Stream::Result> class for POSIX platforms |
| CACE_POSIX_Asynch_Read_File_Result | This class provides concrete implementation for <ACE_Asynch_Read_File::Result> class for POSIX platforms |
| ►CACE_Asynch_Transmit_File_Result_Impl | Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Transmit_File::Result |
| CACE_POSIX_Asynch_Transmit_File_Result | This is that class which will be passed back to the <handler> when the asynchronous transmit file completes |
| ►CACE_Asynch_Write_Dgram_Result_Impl | Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Write_Dgram::Result class |
| CACE_POSIX_Asynch_Write_Dgram_Result | |
| ►CACE_Asynch_Write_Stream_Result_Impl | Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Write_Stream::Result |
| ►CACE_Asynch_Write_File_Result_Impl | This is the abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Write_File::Result |
| CACE_POSIX_Asynch_Write_File_Result | This class provides implementation for <ACE_Asynch_Write_File_Result> for POSIX platforms |
| ►CACE_POSIX_Asynch_Write_Stream_Result | This class provides concrete implementation for <ACE_Asynch_Write_Stream::Result> on POSIX platforms |
| CACE_POSIX_Asynch_Write_File_Result | This class provides implementation for <ACE_Asynch_Write_File_Result> for POSIX platforms |
| ►CACE_POSIX_Asynch_Result | |
| CACE_POSIX_Asynch_Accept_Result | This is that class which will be passed back to the handler when the asynchronous accept completes |
| CACE_POSIX_Asynch_Connect_Result | This is that class which will be passed back to the completion handler when the asynchronous connect completes |
| CACE_POSIX_Asynch_Read_Dgram_Result | This is class provides concrete implementation for ACE_Asynch_Read_Dgram::Result class |
| CACE_POSIX_Asynch_Read_Stream_Result | This class provides concrete implementation for <ACE_Asynch_Read_Stream::Result> class for POSIX platforms |
| CACE_POSIX_Asynch_Timer | This class is posted to the completion port when a timer expires. When the complete() method of this object is called, the handler's handle_timeout() method will be called |
| CACE_POSIX_Asynch_Transmit_File_Result | This is that class which will be passed back to the <handler> when the asynchronous transmit file completes |
| CACE_POSIX_Asynch_Write_Dgram_Result | |
| CACE_POSIX_Asynch_Write_Stream_Result | This class provides concrete implementation for <ACE_Asynch_Write_Stream::Result> on POSIX platforms |
| CACE_POSIX_Wakeup_Completion | |
| ►CACE_At_Thread_Exit | Contains a method to be applied when a thread is terminated |
| CACE_At_Thread_Exit_Func | |
| CACE_ATM_Acceptor | Defines the member functions for ACE_ATM_Acceptor abstraction |
| CACE_ATM_Connector | Defines an active connection factory for the ACE_ATM C++ wrappers |
| CACE_ATM_Params | Wrapper class that simplifies the information passed to the ATM enabled ACE_ATM_Connector class |
| CACE_ATM_QoS | Define the QoS parameters for ATM |
| CACE_ATM_Stream | Defines the member functions for ACE_ATM_Stream abstraction |
| CACE_Atomic_Op< ACE_LOCK, TYPE > | Transparently parameterizes synchronization into basic arithmetic operations |
| CACE_Atomic_Op< ACE_LOCK, long > | |
| CACE_Atomic_Op< ACE_Null_Mutex, long > | |
| CACE_Atomic_Op< ACE_SYNCH_MUTEX, long > | |
| CACE_Atomic_Op< ACE_SYNCH_MUTEX, Reference_Count > | |
| CACE_Atomic_Op_Ex< ACE_LOCK, TYPE > | Transparently parameterizes synchronization into basic arithmetic operations |
| CACE_Atomic_Op_Ex< ACE_LOCK, long > | |
| CACE_Atomic_Op_Ex< ACE_Null_Mutex, long > | |
| CACE_Atomic_Op_Ex< ACE_SYNCH_MUTEX, long > | |
| CACE_Atomic_Op_Ex< ACE_SYNCH_MUTEX, Reference_Count > | |
| ►CACE_Auto_Basic_Array_Ptr< X > | Implements an extension to the draft C++ standard auto_ptr abstraction. This class allows one to work on non-object (basic) types that must be treated as an array, e.g., deallocated via "delete [] foo" |
| CACE_Auto_Array_Ptr< X > | Implements an extension to the draft C++ standard auto_ptr abstraction |
| ►CACE_Auto_Basic_Ptr< X > | Implements the draft C++ standard auto_ptr abstraction. This class allows one to work on non-object (basic) types |
| CACE_Auto_Ptr< X > | Implements the draft C++ standard auto_ptr abstraction. This version can be used instead of auto_ptr<T> |
| Cauto_ptr< X > | Implements the draft C++ standard auto_ptr abstraction |
| ►CACE_Auto_Basic_Ptr< ACE_String_Base > | |
| CACE_Auto_Ptr< ACE_String_Base > | |
| CACE_Auto_IncDec< ACE_SAFELY_INCREMENTABLE_DECREMENTABLE > | This class automatically increments and decrements a parameterized counter |
| CACE_Auto_String_Free | Simple class to automatically de-allocate strings |
| CACE_bad_alloc_class | |
| ►CACE_Barrier | Implements "barrier synchronization" |
| CACE_Thread_Barrier | Implements "barrier synchronization" using ACE_Thread_Mutexes! |
| CACE_Base64 | Encode/Decode a stream of bytes according to Base64 encoding |
| ►CACE_Base_Thread_Adapter | Base class for all the Thread_Adapters |
| CACE_OS_Thread_Adapter | Converts a C++ function into a function that can be called from a thread creation routine (e.g., pthread_create() or _beginthreadex()) that expects an extern "C" entry point. This class also makes it possible to transparently provide hooks to register a thread with an ACE_Thread_Manager |
| CACE_Thread_Adapter | Converts a C++ function into a function that can be called from a thread creation routine (e.g., pthread_create() or _beginthreadex()) that expects an extern "C" entry point. This class also makes it possible to transparently provide hooks to register a thread with an ACE_Thread_Manager |
| ►CACE_Based_Pointer_Basic< CONCRETE > | A proxy that keeps track of the relative offset of a "pointer" from its base address. This class makes it possible to transparently use "pointers" in shared memory as easily as programming with pointers to local memory. In particular, we don't need to ensure that the base addresses of all the pointers are mapped into separate processes at the same absolute memory base address |
| CACE_Based_Pointer< CONCRETE > | A smart proxy that keeps track of the relative offset of a "pointer" from its base address |
| ►CACE_Based_Pointer_Basic< ACE_Malloc_Header > | |
| CACE_Based_Pointer< ACE_Malloc_Header > | |
| ►CACE_Based_Pointer_Basic< ACE_MEM_SAP_Node > | |
| CACE_Based_Pointer< ACE_MEM_SAP_Node > | |
| ►CACE_Based_Pointer_Basic< ACE_Name_Node > | |
| CACE_Based_Pointer< ACE_Name_Node > | |
| CACE_Based_Pointer_Basic< char > | |
| CACE_Based_Pointer_Repository | Maps pointers to the base address of the region to which each pointer belongs |
| CACE_Based_Pointer_Repository_Rep | Implementation for the ACE_Based_Pointer_Repository |
| ►CACE_Basic_Stats | Collect basic stats about a series of samples |
| CACE_Throughput_Stats | A simple class to make throughput and latency analysis |
| CACE_Bcast_Node | Linked list of broadcast interfaces |
| CACE_Bound_Ptr_Counter< ACE_LOCK > | An ACE_Bound_Ptr_Counter<ACE_LOCK> object encapsulates an object reference count |
| CACE_Bounded_Set< T > | Implement a simple unordered set of {T} with maximum set at creation time |
| CACE_Bounded_Set_Iterator< T > | Iterates through an unordered set |
| CACE_Bounded_Stack< T > | Implement a generic LIFO abstract data type |
| CACE_Cache_Map_Iterator< KEY, VALUE, IMPLEMENTATION, CACHING_STRATEGY, ATTRIBUTES > | Defines a iterator for the Cache_Map_Manager |
| CACE_Cache_Map_Manager< KEY, VALUE, CMAP_TYPE, ITERATOR_IMPL, REVERSE_ITERATOR_IMPL, CACHING_STRATEGY, ATTRIBUTES > | Defines a abstraction that will purge entries from a map |
| ►CACE_Cache_Map_Manager< KEY, VALUE, ACE_Hash_Map_Manager_Ex< KEY, std::pair< VALUE, ATTRIBUTES >, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex >, ACE_Hash_Map_Iterator_Ex< KEY, std::pair< VALUE, ATTRIBUTES >, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex >, ACE_Hash_Map_Reverse_Iterator_Ex< KEY, std::pair< VALUE, ATTRIBUTES >, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex >, CACHING_STRATEGY, ATTRIBUTES > | |
| CACE_Hash_Cache_Map_Manager< KEY, VALUE, HASH_KEY, COMPARE_KEYS, CACHING_STRATEGY, ATTRIBUTES > | Defines a abstraction which will purge entries from a map. The map considered is the ACE_Hash_Map_Manager_Ex |
| ►CACE_Cache_Map_Manager< REFCOUNTED_HASH_RECYCLABLE_ADDRESS, SVC_HANDLER *, ACE_Hash_Map_Manager_Ex< REFCOUNTED_HASH_RECYCLABLE_ADDRESS, std::pair< SVC_HANDLER *, ATTRIBUTES >, ACE_Hash< REFCOUNTED_HASH_RECYCLABLE_ADDRESS >, ACE_Equal_To< REFCOUNTED_HASH_RECYCLABLE_ADDRESS >, ACE_Null_Mutex >, ACE_Hash_Map_Iterator_Ex< REFCOUNTED_HASH_RECYCLABLE_ADDRESS, std::pair< SVC_HANDLER *, ATTRIBUTES >, ACE_Hash< REFCOUNTED_HASH_RECYCLABLE_ADDRESS >, ACE_Equal_To< REFCOUNTED_HASH_RECYCLABLE_ADDRESS >, ACE_Null_Mutex >, ACE_Hash_Map_Reverse_Iterator_Ex< REFCOUNTED_HASH_RECYCLABLE_ADDRESS, std::pair< SVC_HANDLER *, ATTRIBUTES >, ACE_Hash< REFCOUNTED_HASH_RECYCLABLE_ADDRESS >, ACE_Equal_To< REFCOUNTED_HASH_RECYCLABLE_ADDRESS >, ACE_Null_Mutex >, CACHING_STRATEGY, ATTRIBUTES > | |
| CACE_Hash_Cache_Map_Manager< REFCOUNTED_HASH_RECYCLABLE_ADDRESS, SVC_HANDLER *, ACE_Hash< REFCOUNTED_HASH_RECYCLABLE_ADDRESS >, ACE_Equal_To< REFCOUNTED_HASH_RECYCLABLE_ADDRESS >, CACHING_STRATEGY, ATTRIBUTES > | |
| CACE_Cache_Map_Reverse_Iterator< KEY, VALUE, REVERSE_IMPLEMENTATION, CACHING_STRATEGY, ATTRIBUTES > | Defines a reverse iterator for the Cache_Map_Manager |
| CACE_Cached_Mem_Pool_Node< T > | ACE_Cached_Mem_Pool_Node keeps unused memory within a free list |
| CACE_Cached_Mem_Pool_Node< char > | |
| ►CACE_Caching_Strategy< ATTRIBUTES, CACHING_UTILITY > | This class is an abstract base class for a caching strategy |
| CACE_Caching_Strategy_Adapter< ATTRIBUTES, CACHING_UTILITY, IMPLEMENTATION > | This class follows the Adaptor pattern and is used to provide External Polymorphism by deriving from ACE_Caching_Strategy |
| CACE_Capabilities | This class implement the ACE Capabilities |
| ►CACE_CapEntry | This class is the base class for all ACE Capabilities entry subclasses |
| CACE_BoolCapEntry | This class implement the ACE Bool Capability subclass |
| CACE_IntCapEntry | This class implement the ACE Integer Capability subclass |
| CACE_StringCapEntry | This class implement the ACE String Capability subclass |
| CACE_CDR | Keep constants and some routines common to both Output and Input CDR streams |
| CACE_Char_Codeset_Translator | Codeset translation routines common to both Output and Input CDR streams |
| ►CACE_Cleanup | Base class for objects that are cleaned by ACE_Object_Manager |
| CACE_Cleanup_Adapter< TYPE > | Adapter for ACE_Cleanup objects that allows them to be readily managed by the ACE_Object_Manager |
| ►CACE_Cleanup_Adapter< ACE_Log_Msg > | |
| CACE_Msg_Log_Cleanup | |
| ►CACE_Singleton< TYPE, ACE_LOCK > | A Singleton Adapter uses the Adapter pattern to turn ordinary classes into Singletons optimized with the Double-Checked Locking optimization pattern |
| CACE_Unmanaged_Singleton< TYPE, ACE_LOCK > | Same as ACE_Singleton, except does not register with ACE_Object_Manager for destruction |
| CACE_Token_Invariant_Manager | Token Invariants |
| CACE_Token_Manager | Manages all tokens in a process space |
| ►CACE_TSS_Singleton< TYPE, ACE_LOCK > | This class uses the Adapter pattern to turn ordinary classes into Thread-specific Singletons optimized with the Double-Checked Locking optimization pattern |
| CACE_Unmanaged_TSS_Singleton< TYPE, ACE_LOCK > | Same as ACE_TSS_Singleton, except does not register with ACE_Object_Manager for destruction |
| ►CACE_Cleanup_Strategy< KEY, VALUE, CONTAINER > | Defines a default strategy to be followed for cleaning up entries from a map which is the container |
| CACE_Handler_Cleanup_Strategy< KEY, VALUE, CONTAINER > | Defines a strategy to be followed for cleaning up entries which are svc_handlers from a container |
| CACE_Null_Cleanup_Strategy< KEY, VALUE, CONTAINER > | Defines a do-nothing implementation of the cleanup strategy |
| CACE_Recyclable_Handler_Cleanup_Strategy< KEY, VALUE, CONTAINER > | Defines a strategy to be followed for cleaning up entries which are svc_handlers from a container |
| CACE_Refcounted_Recyclable_Handler_Cleanup_Strategy< KEY, VALUE, CONTAINER > | Defines a strategy to be followed for cleaning up entries which are svc_handlers from a container |
| CACE_Codeset_Registry | |
| ►CACE_Command_Base | Defines an abstract class that allows us to invoke commands without knowing anything about the implementation |
| CACE_Command_Callback< RECEIVER, ACTION > | Defines a class template that allows us to invoke a GOF command style callback to an object without knowing anything about the object except its type |
| CACE_Member_Function_Command< RECEIVER > | Defines a class template that allows us to invoke a member function using the GoF command style callback |
| CACE_Noop_Command | |
| ►CACE_Concurrency_Strategy< SVC_HANDLER > | Defines the interface for specifying a concurrency strategy for a SVC_HANDLER |
| CACE_NOOP_Concurrency_Strategy< SVC_HANDLER > | Implements a no-op activation strategy in order to avoid calling open on a svc_handler multiple times |
| CACE_Process_Strategy< SVC_HANDLER > | Defines the interface for specifying a concurrency strategy for a SVC_HANDLER based on multiprocessing |
| CACE_Reactive_Strategy< SVC_HANDLER > | Defines the interface for specifying a reactive concurrency strategy for a SVC_HANDLER, where all upcalls to handle_*() methods run in the reactor's thread of control |
| CACE_Thread_Strategy< SVC_HANDLER > | Defines the interface for specifying a concurrency strategy for a SVC_HANDLER based on multithreading |
| ►CACE_Condition< MUTEX > | ACE_Condition variable wrapper, which allows threads to block until shared data changes state |
| CACE_Thread_Condition< MUTEX > | ACE_Condition variable wrapper that works within processes |
| CACE_Condition< ACE_Null_Mutex > | ACE_Condition template specialization written using ACE_Null_Mutexes. Implements a do nothing ACE_Condition specialization, i.e., all methods are no ops |
| CACE_Condition< ACE_Recursive_Thread_Mutex > | ACE_Condition template specialization written using ACE_Recursive_Thread_Mutex. This allows threads to block until shared data changes state using recursive mutexes |
| CACE_Condition< ACE_Thread_Mutex > | ACE_Condition template specialization written using ACE_Mutexes. This allows threads to block until shared data changes state. A condition variable enables threads to atomically block and test the condition under the protection of a mutual exclu- sion lock (mutex) until the condition is satisfied. That is, the mutex must have been held by the thread before calling wait or signal on the condition. If the condition is false, a thread blocks on a condition variable and atomically releases the mutex that is waiting for the condition to change. If another thread changes the condition, it may wake up waiting threads by signaling the associated condition variable. The waiting threads, upon awakening, reacquire the mutex and re-evaluate the condition |
| ►CACE_Condition_Attributes | |
| CACE_Condition_Attributes_T< TIME_POLICY > | |
| CACE_Condition_Attributes_T< ACE_Monotonic_Time_Policy > | |
| CACE_Condition_Attributes_T< ACE_System_Time_Policy > | |
| ►CACE_Config_ImpExp_Base | Base class for file import/export configuration |
| CACE_Ini_ImpExp | Imports the configuration database from filename as strings. Allows non-typed values. (no #, dword: hex:, etc. prefixes) and skips whitespace (tabs and spaces) as in standard .ini and .conf files. Values (to right of equal sign) can be double quote delimited to embed tabs and spaces in the string. Caller must convert string to type |
| CACE_Registry_ImpExp | Configuration object that imports/exports data to a file formatted using the Win32 Registry file export format. This format looks like [Section] "key"="String Data" "key"=dword: numeric data in hexadecimal format "key"=hex: binary data |
| ►CACE_Configuration | Base class for configuration databases |
| CACE_Configuration_Heap | The concrete implementation of a allocator based configuration database |
| CACE_Configuration_Win32Registry | The win32 registry implementation of a configuration database |
| CACE_Configuration_ExtId | External ID for the section and value hash |
| CACE_Configuration_Section_IntId | The internal ID for a section hash table |
| CACE_Configuration_Section_Key | Reference counted wrapper for ACE_Section_Key_Internal |
| CACE_Configuration_Value_IntId | The section hash table internal value class |
| CACE_Connect_Strategy< SVC_HANDLER, ACE_PEER_CONNECTOR_1 > | Defines the interface for specifying an active connection establishment strategy for a SVC_HANDLER |
| ►CACE_Connect_Strategy< SVC_HANDLER, ACE_PEER_CONNECTOR_2 > | |
| CACE_Cached_Connect_Strategy< SVC_HANDLER, ACE_PEER_CONNECTOR_1, MUTEX > | A connection strategy which caches connections to peers (represented by SVC_HANDLER instances), thereby allowing subsequent re-use of unused, but available, connections |
| ►CACE_Cached_Connect_Strategy< SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX > | |
| CACE_Cached_Connect_Strategy_Ex< SVC_HANDLER, ACE_PEER_CONNECTOR_1, CACHING_STRATEGY, ATTRIBUTES, MUTEX > | A connection strategy which caches connections to peers (represented by SVC_HANDLER instances), thereby allowing subsequent re-use of unused, but available, connections |
| ►CACE_Cached_Connect_Strategy_Ex< SVC_HANDLER, ACE_PEER_CONNECTOR_2, CACHING_STRATEGY, ATTRIBUTES, MUTEX > | |
| CACE_Bounded_Cached_Connect_Strategy< SVC_HANDLER, ACE_PEER_CONNECTOR_1, CACHING_STRATEGY, ATTRIBUTES, MUTEX > | A connection strategy which caches connections to peers (represented by SVC_HANDLER instances), thereby allowing subsequent re-use of unused, but available, connections. This strategy should be used when the cache is bounded by maximum size |
| ►CACE_Connection_Recycling_Strategy | Defines the interface for a connection recycler |
| CACE_Cached_Connect_Strategy< SVC_HANDLER, ACE_PEER_CONNECTOR_1, MUTEX > | A connection strategy which caches connections to peers (represented by SVC_HANDLER instances), thereby allowing subsequent re-use of unused, but available, connections |
| CACE_Cached_Connect_Strategy< SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX > | |
| ►CACE_Connector_Base< SVC_HANDLER > | This base interface allows ACE_NonBlocking_Connect_Handler to only care about the SVC_HANDLER template parameter of the ACE_Connector. Otherwise, ACE_NonBlocking_Connect_Handler would have to be configured with all the template parameters that ACE_Connector is configured with |
| ►CACE_Connector< SVC_HANDLER, PEER_CONNECTOR > | Generic factory for actively connecting clients and creating service handlers (SVC_HANDLERs) |
| CACE_Strategy_Connector< SVC_HANDLER, PEER_CONNECTOR > | Abstract factory for creating a service handler (SVC_HANDLER), connecting the SVC_HANDLER, and activating the SVC_HANDLER |
| CACE_Control_Block | This information is stored in memory allocated by the <Memory_Pool> |
| ►CACE_Copy_Disabled | Helper class to disable copy construction and assignment |
| CACE_Countdown_Time_T< TIME_POLICY > | |
| CACE_Env_Value< T > | Environment Variable Value |
| CACE_Event_Handler_Handle_Timeout_Upcall | Functor for Timer_Queues |
| ►CACE_Framework_Component | Base class that defines a uniform interface for all managed framework components |
| CACE_Framework_Component_T< Concrete > | This class inherits the interface of the abstract ACE_Framework_Component class and is instantiated with the implementation of the concrete component class class Concrete |
| CACE_Framework_Repository | Contains all framework components used by an application |
| CACE_Future_Set< T > | This class implements a mechanism that allows the values of a collection of ACE_Future objects to be accessed by reader threads as they become available. The caller(s) provide the ACE_Future_Set (i.e. the observer...) with the collection of ACE_Future objects (i.e. the subjects...) that are to be observed using the the ACE_Future_Set::insert() method. The caller(s) may then iterate over the collection in the order in which they become readable using the ACE_Future_Set::next_readable() method |
| CACE_Handler_Caching_Utility< KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES > | Defines a helper class for the Caching Strategies |
| CACE_Mem_Map | C++ interface OS memory mapping system call |
| CACE_Notification_Queue | Implements a user-space queue to send Reactor notifications |
| CACE_Null_Caching_Utility< KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES > | Defines a dummy helper class for the Caching Strategies |
| CACE_Pair_Caching_Utility< KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES > | Defines a helper class for the Caching Strategies |
| CACE_Recyclable_Handler_Caching_Utility< KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES > | Defines a helper class for the Caching Strategies |
| CACE_Refcounted_Recyclable_Handler_Caching_Utility< KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES > | Defines a helper class for the Caching Strategies |
| CACE_Service_Gestalt | Supplies common server operations for dynamic and static configuration of services |
| CACE_Task_Ex< ACE_SYNCH_DECL, ACE_MESSAGE_TYPE, TIME_POLICY > | Primary interface for application message processing, as well as input and output message queueing |
| CACE_Timer_Hash_Upcall< TYPE, FUNCTOR, ACE_LOCK > | Functor for Timer_Hash |
| CACE_Timer_Queue_Upcall_Base< TYPE, FUNCTOR > | |
| CACE_TSS< TYPE > | Allows objects that are "physically" in thread specific storage (i.e., private to a thread) to be accessed as though they were "logically" global to a program |
| ►CACE_TSS< ACE_SOCK_Stream > | |
| CACE_TSS_Connection | Class for providing a connection per thread |
| CACE_Countdown_Time | Keeps track of the amount of elapsed time |
| ►CACE_Creation_Strategy< SVC_HANDLER > | Defines the interface for specifying a creation strategy for a SVC_HANDLER |
| CACE_DLL_Strategy< SVC_HANDLER > | Defines the interface for specifying a creation strategy for a SVC_HANDLER based on dynamic linking of the SVC_HANDLER |
| CACE_NOOP_Creation_Strategy< SVC_HANDLER > | Implements a no-op creation strategy in order to defer decisions regarding creation to some later point in time, such as in connect or accept strategy |
| CACE_Singleton_Strategy< SVC_HANDLER > | Defines the interface for specifying a creation strategy for a SVC_HANDLER that always returns the same SVC_HANDLER (i.e., it's a Singleton) |
| ►CACE_Data_Block | Stores the data payload that is accessed via one or more ACE_Message_Block's |
| CACE_Locked_Data_Block< ACE_LOCK > | A Data_Block with a concrete locking strategy |
| CACE_Date_Time | System independent representation of date and time |
| CACE_Delegating_Time_Policy | Implement a time policy that delegates to a dynamic time policy |
| CACE_DEV_Connector | Defines an active connection factory for the ACE_DEV wrappers |
| CACE_Dev_Poll_Handler_Guard | Class used to make event handler reference count manipulation exception-safe |
| CACE_Dirent | Define a portable C++ directory-entry iterator based on the POSIX API |
| CACE_Dirent_Selector | Define a portable C++ directory-entry iterator based on the POSIX scandir API |
| CACE_DLL | Provides an abstract interface for handling various DLL operations |
| CACE_DLL_Handle | Provides an abstract interface for handling various DLL operations |
| CACE_DLL_Manager | This class is a singleton and serves as a factory and repository for instances of ACE_DLL_Handle |
| CACE_DLL_Singleton_T< TYPE, ACE_LOCK > | Same as ACE_Singleton, except that it registers for destruction with the ACE_Framework_Repository instead of with the ACE_Object_Manager directly |
| CACE_DLList_Node | Base implementation of element in a DL list. Needed for ACE_Double_Linked_List |
| CACE_DNode< T > | Implementation element in a bilinked list |
| CACE_Double_Linked_List< T > | A double-linked list implementation |
| ►CACE_Double_Linked_List< ACE_DLList_Node > | |
| CACE_DLList< T > | A double-linked list container class |
| CACE_Double_Linked_List< ACE_Thread_Descriptor > | |
| CACE_Double_Linked_List< ACE_Thread_Descriptor_Base > | |
| ►CACE_Double_Linked_List_Iterator_Base< T > | Implements a common base class for iterators for a double linked list ADT |
| CACE_Double_Linked_List_Iterator< T > | Implements an iterator for a double linked list ADT |
| CACE_Double_Linked_List_Reverse_Iterator< T > | Implements a reverse iterator for a double linked list ADT |
| ►CACE_Double_Linked_List_Iterator_Base< ACE_DLList_Node > | |
| ►CACE_Double_Linked_List_Iterator< ACE_DLList_Node > | |
| CACE_DLList_Iterator< T > | A double-linked list container class iterator |
| ►CACE_Double_Linked_List_Reverse_Iterator< ACE_DLList_Node > | |
| CACE_DLList_Reverse_Iterator< T > | A double-linked list container class iterator |
| ►CACE_Dumpable | Base class that defines a uniform interface for all object dumping |
| CACE_Dumpable_Adapter< Concrete > | This class inherits the interface of the abstract ACE_Dumpable class and is instantiated with the implementation of the concrete component class <class concrete>=""> |
| CACE_Dumpable_Ptr | A smart pointer stored in the in-memory object database ACE_ODB. The pointee (if any) is deleted when reassigned |
| CACE_Dynamic | Checks to see if an object was dynamically allocated |
| ►CACE_Dynamic_Message_Strategy | An abstract base class which provides dynamic priority evaluation methods for use by the ACE_Dynamic_Message_Queue class or any other class which needs to manage the priorities of a collection of ACE_Message_Blocks dynamically |
| CACE_Deadline_Message_Strategy | Deadline based message priority strategy |
| CACE_Laxity_Message_Strategy | Laxity based message priority strategy |
| ►CACE_Dynamic_Service_Base | Base class for all ACE_Dynamic_Service instantiations |
| CACE_Dynamic_Service< TYPE > | Provides a general interface to retrieve arbitrary objects from the ACE service repository |
| CACE_Dynamic_Service_Dependency | Provides a way to declare dependency on specific service, thus helping to avoid order of initialization issues with instances of an objects whose implementation code resides in dynamically loaded services |
| CACE_Dynamic_Time_Policy_base | Abstract base class for dynamically loaded and/or shared time policies |
| ►CACE_Dynamic_Time_Policy_Base | |
| CACE_Time_Policy_T< TIME_POLICY > | Template class implementing a dynamic time policy based on another time policy |
| CNULL_Time_Policy | |
| CACE_EH_Dispatch_Info | This structure contains information of the activated event handler |
| CACE_Profile_Timer::ACE_Elapsed_Time | Keeps track of the various user, system, and elapsed (real) times |
| CACE_Equal_To< TYPE > | Function object for comparing two objects of the given type for equality |
| CACE_Equal_To< ACE_CString > | Function object for determining whether two ACE_CStrings are equal |
| CACE_Equal_To< ACE_INT16 > | Function object for determining whether two 16 bit ints are equal |
| CACE_Equal_To< ACE_INT32 > | Function object for determining whether two 32 bit ints are equal |
| CACE_Equal_To< ACE_TString > | |
| CACE_Equal_To< ACE_UINT16 > | Function object for determining whether two unsigned 16 bit ints are equal |
| CACE_Equal_To< ACE_UINT32 > | Function object for determining whether two unsigned 32 bit ints are equal |
| CACE_Equal_To< ACE_UINT64 > | Function object for determining whether two unsigned 64 bit ints are equal |
| CACE_Equal_To< char * > | Function object for determining whether two non-const strings are equal |
| CACE_Equal_To< const ACE_TCHAR * > | |
| CACE_Equal_To< const char * > | Function object for determining whether two const strings are equal |
| CACE_Equal_To< const wchar_t * > | Function object for determining whether two const strings are equal |
| CACE_Equal_To< EXT_ID > | |
| CACE_Equal_To< REFCOUNTED_HASH_RECYCLABLE_ADDRESS > | |
| CACE_Equal_To< std::string > | Function object for determining whether two std::strings are equal |
| CACE_Equal_To< wchar_t * > | Function object for determining whether two non-const strings are equal |
| CACE_Errno_Guard | Provides a wrapper to improve performance when thread-specific errno must be saved and restored in a block of code |
| ►CACE_Event_Base | A base class for wrappers around the Win32 event locking mechanism |
| ►CACE_Event_T< TIME_POLICY > | A wrapper around the Win32 event locking mechanism |
| CACE_Auto_Event_T< TIME_POLICY > | |
| CACE_Manual_Event_T< TIME_POLICY > | |
| ►CACE_Event_T< ACE_System_Time_Policy > | |
| ►CACE_Auto_Event_T< ACE_System_Time_Policy > | |
| CACE_Auto_Event | Auto Events |
| ►CACE_Manual_Event_T< ACE_System_Time_Policy > | |
| CACE_Manual_Event | Manual Events |
| ►CACE_Event_Handler | Provides an abstract interface for handling various types of I/O, timer, and signal events |
| CACE::Monitor_Control::Monitor_Point_Auto_Updater | Automates periodic updating of monitor point classes |
| CACE_Async_Timer_Queue_Adapter< TQ, TYPE > | Adapts an ACE timer queue to be driven asynchronously using signals |
| CACE_Event_Handler_T< T > | Enable a class that doesn't inherit from the ACE_Event_Handler to be incorporated into the ACE_Reactor framework. Thanks to Greg Lavender (g.lav.nosp@m.ende.nosp@m.r@iso.nosp@m.de.c.nosp@m.om) for sharing this idea |
| ►CACE_MMAP_Memory_Pool | Make a memory pool that is based on mmap(2). This implementation allows memory to be shared between processes |
| CACE_Lite_MMAP_Memory_Pool | Make a ``lighter-weight'' memory pool based ACE_Mem_Map |
| CACE_Name_Proxy | Proxy for dealing with remote server process managing NET_LOCAL NameBindings |
| CACE_NonBlocking_Connect_Handler< SVC_HANDLER > | Performs non-blocking connects on behalf of the Connector |
| CACE_POSIX_Asynch_Accept | For the POSIX implementation this class is common for all Proactors (AIOCB/SIG/SUN) |
| CACE_POSIX_Asynch_Connect | |
| ►CACE_Proactor_Impl | A manager for asynchronous event demultiplexing. This class is the base class for all the concrete implementation classes |
| ►CACE_POSIX_Proactor | POSIX implementation of the Proactor |
| ►CACE_POSIX_AIOCB_Proactor | This Proactor makes use of Asynchronous I/O Control Blocks (AIOCB) to notify/get the completion status of the <aio_> operations issued |
| CACE_POSIX_CB_Proactor | Implementation of Callback-based Proactor }; |
| CACE_WIN32_Proactor | A manager for asynchronous event demultiplexing on Win32 |
| CACE_Process_Manager | Manages a group of processes |
| ►CACE_Reactor_Notify | Abstract class for unblocking an ACE_Reactor_Impl from its event loop |
| CACE_Dev_Poll_Reactor_Notify | Event handler used for unblocking the ACE_Dev_Poll_Reactor from its event loop |
| CACE_Select_Reactor_Notify | Unblock the ACE_Select_Reactor from its event loop |
| CACE_WFMO_Reactor_Notify | Unblock the ACE_WFMO_Reactor from its event loop, passing it an optional ACE_Event_Handler to dispatch |
| ►CACE_Service_Object | Provide the abstract base class common to all service implementations |
| CACE::Monitor_Control::Monitor_Admin_Manager | Repsonsible for creating and destroying the global (per process) instance of the Admin class |
| ►CACE_Acceptor< SVC_HANDLER, PEER_ACCEPTOR > | Abstract factory for creating a service handler (SVC_HANDLER), accepting into the SVC_HANDLER, and activating the SVC_HANDLER |
| CACE_Strategy_Acceptor< SVC_HANDLER, PEER_ACCEPTOR > | Abstract factory for creating a service handler (SVC_HANDLER), accepting into the SVC_HANDLER, and activating the SVC_HANDLER |
| CACE_Connector< SVC_HANDLER, PEER_CONNECTOR > | Generic factory for actively connecting clients and creating service handlers (SVC_HANDLERs) |
| CACE_Logging_Strategy | This class provides a way to dynamically configure the ACE logging mechanism at run time as well as enable the mechanisms for limiting log file size and log file backup/rotation capability |
| CACE_Naming_Context | Maintaining accesses Name Server Databases. Allows to add NameBindings, change them, remove them and resolve NameBindings |
| CACE_Oneshot_Acceptor< SVC_HANDLER, PEER_ACCEPTOR > | Generic factory for passively connecting clients and creating exactly one service handler of the type SVC_HANDLER specified in the template |
| CACE_Service_Manager | Provide a standard ACE service for managing all the services configured in an ACE_Service_Repository |
| ►CACE_Task_Base | Direct base class for the ACE_Task template |
| CACE_Task< ACE_SYNCH_DECL, TIME_POLICY > | Primary interface for application message processing, as well as input and output message queueing |
| ►CACE_Task< ACE_MT_SYNCH > | |
| CACE_NT_Service | Provide the base class which defines the interface for controlling an NT service |
| ►CACE_Task< ACE_NULL_SYNCH > | |
| CACE_Asynch_Pseudo_Task | |
| CACE_Proactor_Timer_Handler | A Handler for timer. It helps in the management of timers registered with the Proactor |
| CACE_Task< ACE_SYNCH_USE, ACE_System_Time_Policy > | |
| CACE_Task< ACE_SYNCH_USE, TIME_POLICY > | |
| ►CACE_Task< SYNCH_TRAITS > | |
| ►CACE_Svc_Handler< PEER_STREAM, SYNCH_TRAITS > | Defines the interface for a service that exchanges data with its connected peer |
| CACE_Buffered_Svc_Handler< PEER_STREAM, SYNCH_TRAITS > | Defines the interface for a service that exchanges data with its connected peer and supports buffering |
| CACE_Task_Ex< ACE_SYNCH_DECL, ACE_MESSAGE_TYPE, TIME_POLICY > | Primary interface for application message processing, as well as input and output message queueing |
| CACE_Thread_Timer_Queue_Adapter< TQ, TYPE > | Adapts an ACE timer queue using a separate thread for dispatching |
| CACE_Shared_Memory_Pool | Make a memory pool that is based on System V shared memory (shmget(2) etc.). This implementation allows memory to be shared between processes. If your platform doesn't support System V shared memory (e.g., Win32 and many RTOS platforms do not) then you should use ACE_MMAP_Memory_Pool instead of this class. In fact, you should probably use ACE_MMAP_Memory_Pool on platforms that do support System V shared memory since it provides more powerful features, such as persistent backing store and greatly scalability |
| CACE_Sig_Adapter | Provide an adapter that transforms various types of signal handlers into the scheme used by the ACE_Reactor |
| CACE_Test_and_Set< ACE_LOCK, TYPE > | Implements the classic ``test and set'' operation |
| CACE_Wakeup_All_Threads_Handler | This is a helper class whose sole purpose is to handle events on <ACE_WFMO_Reactor->wakeup_all_threads_> |
| CACE_Event_Handler_var | Auto pointer like class for Event Handlers |
| CACE_Event_Tuple | An ACE_Event_Handler and its associated ACE_HANDLE |
| CACE_FIFO_Caching_Strategy< ATTRIBUTES, CACHING_UTILITY > | The First In First Out strategy is implemented wherein each item is ordered |
| CACE_FILE_Connector | Defines an active connection factory for the ACE_FILE wrappers |
| CACE_FILE_Info | Abstracts basic OS FILE information |
| CACE_File_Lock | A wrapper around the UNIX file locking mechanism |
| CACE_Filecache | A hash table holding the information about entry point into the Cached Virtual Filesystem. On insertion, the reference count is incremented. On destruction, reference count is decremented |
| CACE_Filecache_Handle | Abstraction over a real file. This is meant to be the entry point into the Cached Virtual Filesystem |
| CACE_Filecache_Object | Abstraction over a real file. This is what the Virtual Filesystem contains. This class is not intended for general consumption. Please consult a physician before attempting to use this class |
| CACE_Fixed_Set< T, ACE_SIZE > | Implement a simple unordered set of {T} with maximum {ACE_SIZE} |
| ►CACE_Fixed_Set_Iterator_Base< T, ACE_SIZE > | Implements a common base class for iterators for a unordered set |
| CACE_Fixed_Set_Const_Iterator< T, ACE_SIZE > | Iterates through a const unordered set |
| CACE_Fixed_Set_Iterator< T, ACE_SIZE > | Iterates through an unordered set |
| CACE_Fixed_Stack< T, ACE_SIZE > | Implement a generic LIFO abstract data type |
| CACE_OS::ace_flock_t | OS file locking structure |
| CACE_Flow_Spec | Wrapper class that defines the flow spec QoS information, which is used by IntServ (RSVP) and DiffServ |
| CACE_FPointer_Time_Policy | |
| CACE_FPointer_Timer_Policy | Implement a time policy based on a function pointer |
| ►CACE_Free_List< T > | Implements a free list |
| CACE_Locked_Free_List< T, ACE_LOCK > | Implements a free list |
| ►CACE_Free_List< ACE_Cached_Mem_Pool_Node< char > > | |
| CACE_Locked_Free_List< ACE_Cached_Mem_Pool_Node< char >, ACE_LOCK > | |
| ►CACE_Free_List< ACE_Cached_Mem_Pool_Node< T > > | |
| CACE_Locked_Free_List< ACE_Cached_Mem_Pool_Node< T >, ACE_LOCK > | |
| ►CACE_Free_List< ACE_Thread_Descriptor > | |
| CACE_Locked_Free_List< ACE_Thread_Descriptor, ACE_SYNCH_MUTEX > | |
| CACE_Free_List< ACE_Timer_Node_T< TYPE > > | |
| ►CACE_Free_List< Hash_Token< TYPE > > | |
| CACE_Locked_Free_List< Hash_Token< TYPE >, ACE_Null_Mutex > | |
| CACE_Future< T > | This class implements a ``single write, multiple read'' pattern that can be used to return results from asynchronous method invocations |
| CACE_Future_Holder< T > | Implementation of object that holds an ACE_Future |
| ►CACE_Future_Observer< T > | ACE_Future_Observer<T> |
| CACE_Future_Set< T > | This class implements a mechanism that allows the values of a collection of ACE_Future objects to be accessed by reader threads as they become available. The caller(s) provide the ACE_Future_Set (i.e. the observer...) with the collection of ACE_Future objects (i.e. the subjects...) that are to be observed using the the ACE_Future_Set::insert() method. The caller(s) may then iterate over the collection in the order in which they become readable using the ACE_Future_Set::next_readable() method |
| CACE_Future_Rep< T > | ACE_Future_Rep<T> |
| CACE_Get_Opt | Iterator for parsing command-line arguments |
| CACE_Get_Opt::ACE_Get_Opt_Long_Option | |
| ►CACE_Guard< ACE_LOCK > | This data structure is meant to be used within a method or function... It performs automatic acquisition and release of a parameterized synchronization object ACE_LOCK |
| CACE_Read_Guard< ACE_LOCK > | This class is similar to class ACE_Guard, though it acquires/releases a read lock automatically (naturally, the <ACE_LOCK> it is instantiated with must support the appropriate API) |
| CACE_Write_Guard< ACE_LOCK > | This class is similar to class ACE_Guard, though it acquires/releases a write lock automatically (naturally, the <ACE_LOCK> it is instantiated with must support the appropriate API) |
| ►CACE_Guard< ACE_Null_Mutex > | Template specialization of ACE_Guard for the ACE_Null_Mutex |
| CACE_Read_Guard< ACE_Null_Mutex > | Template specialization of ACE_Read)Guard for the ACE_Null_Mutex |
| CACE_Write_Guard< ACE_Null_Mutex > | Template specialization of ACE_Write_Guard for the ACE_Null_Mutex |
| CACE_Handle_Gobbler | This class gobbles up handles |
| CACE_Handle_Set | C++ wrapper facade for the socket fd_set abstraction |
| CACE_Handle_Set_Iterator | Iterator for the ACE_Handle_Set abstraction |
| ►CACE_Handler | This base class defines the interface for receiving the results of asynchronous operations |
| CACE_AIOCB_Notify_Pipe_Manager | This class manages the notify pipe of the AIOCB Proactor |
| CACE_Asynch_Acceptor< HANDLER > | This class is an example of the Acceptor Pattern. This class will accept new connections and create new HANDLER to handle the new connections |
| CACE_Asynch_Connector< HANDLER > | This class is an example of the Connector pattern. This class will establish new connections and create new HANDLER objects to handle the new connections |
| CACE_POSIX_Asynch_Transmit_Handler | Auxillary handler for doing <Asynch_Transmit_File> in Unix. <ACE_POSIX_Asynch_Transmit_File> internally uses this |
| CACE_Service_Handler | This base class defines the interface for the ACE_Asynch_Acceptor to call into when new connection are accepted |
| CACE_Hash< TYPE > | Function object for hashing |
| CACE_Hash< ACE_CString > | Function object for hashing a ACE_CString |
| CACE_Hash< ACE_INT64 > | Function object for hashing a signed 64-bit number |
| CACE_Hash< ACE_TString > | |
| CACE_Hash< ACE_UINT64 > | Function object for hashing an unsigned 64-bit number |
| CACE_Hash< char * > | Function object for hashing a string |
| CACE_Hash< char > | Function object for hashing a char |
| CACE_Hash< const ACE_TCHAR * > | |
| CACE_Hash< const char * > | Function object for hashing a const string |
| CACE_Hash< const wchar_t * > | Function object for hashing a const string |
| CACE_Hash< EXT_ID > | |
| CACE_Hash< int > | Function object for hashing an int number |
| CACE_Hash< key_type > | |
| CACE_Hash< long > | Function object for hashing a long number |
| CACE_Hash< REFCOUNTED_HASH_RECYCLABLE_ADDRESS > | |
| CACE_Hash< short > | Function object for hashing a short number |
| CACE_Hash< signed char > | Function object for hashing a signed char |
| CACE_Hash< std::string > | Function object for hashing a std::string |
| CACE_Hash< unsigned char > | Function object for hashing an unsigned char |
| CACE_Hash< unsigned int > | Function object for hashing an unsigned int number |
| CACE_Hash< unsigned long > | Function object for hashing an unsigned long number |
| CACE_Hash< unsigned short > | Function object for hashing an unsigned short number |
| CACE_Hash< void * > | Function object for hashing a void |
| CACE_Hash< wchar_t * > | Function object for hashing a string |
| CACE_Hash< wchar_t > | Function object for hashing a wchar_t |
| CACE_Hash_Map_Bucket_Iterator< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK > | Forward iterator for the ACE_Hash_Map_Manager_Ex which only traverses a particular bucket. The particular bucket is specified by the <EXT_ID> parameter specified in the constructor |
| ►CACE_Hash_Map_Const_Iterator_Base_Ex< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK > | Base const iterator for the ACE_Hash_Map_Manager_Ex |
| CACE_Hash_Map_Const_Iterator_Ex< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK > | Const forward iterator for the ACE_Hash_Map_Manager_Ex |
| CACE_Hash_Map_Const_Reverse_Iterator_Ex< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK > | Const reverse iterator for the ACE_Hash_Map_Manager_Ex |
| ►CACE_Hash_Map_Const_Iterator_Base_Ex< EXT_ID, INT_ID, ACE_Hash< EXT_ID >, ACE_Equal_To< EXT_ID >, ACE_LOCK > | |
| ►CACE_Hash_Map_Const_Iterator_Ex< EXT_ID, INT_ID, ACE_Hash< EXT_ID >, ACE_Equal_To< EXT_ID >, ACE_LOCK > | |
| CACE_Hash_Map_Const_Iterator< EXT_ID, INT_ID, ACE_LOCK > | Wrapper for backward compatibility |
| CACE_Hash_Map_Entry< EXT_ID, INT_ID > | Define an entry in the hash table |
| CACE_Hash_Map_Entry< ACE_CString, Monitor_Base * > | |
| CACE_Hash_Map_Entry< ACE_TString, ACE_CapEntry * > | |
| CACE_Hash_Map_Entry< const ACE_TCHAR *, ACE_Filecache_Object * > | |
| CACE_Hash_Map_Entry< FUTURE_REP *, FUTURE_HOLDER * > | |
| CACE_Hash_Map_Entry< KEY, std::pair< VALUE, ATTRIBUTES > > | |
| CACE_Hash_Map_Entry< KEY, VALUE > | |
| CACE_Hash_Map_Entry< key_type, value_type > | |
| CACE_Hash_Map_Entry< REFCOUNTED_HASH_RECYCLABLE_ADDRESS, std::pair< SVC_HANDLER *, ATTRIBUTES > > | |
| CACE_Hash_Map_Entry< REFCOUNTED_HASH_RECYCLABLE_ADDRESS, SVC_HANDLER * > | |
| ►CACE_Hash_Map_Iterator_Base_Ex< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK > | Base iterator for the ACE_Hash_Map_Manager_Ex |
| CACE_Hash_Map_Iterator_Ex< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK > | Forward iterator for the ACE_Hash_Map_Manager_Ex |
| CACE_Hash_Map_Reverse_Iterator_Ex< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK > | Reverse iterator for the ACE_Hash_Map_Manager_Ex |
| ►CACE_Hash_Map_Iterator_Base_Ex< EXT_ID, INT_ID, ACE_Hash< EXT_ID >, ACE_Equal_To< EXT_ID >, ACE_LOCK > | |
| ►CACE_Hash_Map_Iterator_Ex< EXT_ID, INT_ID, ACE_Hash< EXT_ID >, ACE_Equal_To< EXT_ID >, ACE_LOCK > | |
| CACE_Hash_Map_Iterator< EXT_ID, INT_ID, ACE_LOCK > | Wrapper for backward compatibility |
| ►CACE_Hash_Map_Reverse_Iterator_Ex< EXT_ID, INT_ID, ACE_Hash< EXT_ID >, ACE_Equal_To< EXT_ID >, ACE_LOCK > | |
| CACE_Hash_Map_Reverse_Iterator< EXT_ID, INT_ID, ACE_LOCK > | Wrapper for backward compatibility |
| ►CACE_Hash_Map_Iterator_Base_Ex< KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex > | |
| CACE_Hash_Map_Iterator_Ex< KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex > | |
| CACE_Hash_Map_Reverse_Iterator_Ex< KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex > | |
| ►CACE_Hash_Map_Manager_Ex< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK > | Define a map abstraction that efficiently associates EXT_ID type objects with INT_ID type objects |
| CACE_Name_Space_Map< ALLOCATOR > | This class serves as a Proxy that ensures our process always has the appropriate allocator in place for every operation that accesses or updates the Map Manager |
| CACE_Name_Space_Map< ACE_Allocator_Adapter > | |
| ►CACE_Hash_Map_Manager_Ex< ACE_CString, Monitor_Base *, ACE_Hash< ACE_CString >, ACE_Equal_To< ACE_CString >, ACE_SYNCH_NULL_MUTEX > | |
| CACE_Hash_Map_Manager< ACE_CString, Monitor_Base *, ACE_SYNCH_NULL_MUTEX > | |
| CACE_Hash_Map_Manager_Ex< ACE_TString, ACE_CapEntry *, ACE_Hash< ACE_TString >, ACE_Equal_To< ACE_TString >, ACE_Null_Mutex > | |
| CACE_Hash_Map_Manager_Ex< const ACE_TCHAR *, ACE_Filecache_Object *, ACE_Hash< const ACE_TCHAR * >, ACE_Equal_To< const ACE_TCHAR * >, ACE_Null_Mutex > | |
| ►CACE_Hash_Map_Manager_Ex< EXT_ID, INT_ID, ACE_Hash< EXT_ID >, ACE_Equal_To< EXT_ID >, ACE_LOCK > | |
| CACE_Hash_Map_Manager< EXT_ID, INT_ID, ACE_LOCK > | Wrapper for backward compatibility |
| ►CACE_Hash_Map_Manager_Ex< EXT_ID, INT_ID, ACE_Hash< EXT_ID >, ACE_Equal_To< EXT_ID >, ACE_Null_Mutex > | |
| CACE_Hash_Map_With_Allocator< EXT_ID, INT_ID > | This class is a thin wrapper around ACE_Hash_Map_Manager, which comes handy when ACE_Hash_Map_Manager is to be used with a non-nil ACE_Allocator. This wrapper insures that the appropriate allocator is in place for every operation that accesses or updates the hash map |
| CACE_Hash_Map_Manager_Ex< FUTURE_REP *, FUTURE_HOLDER *, FUTURE_REP_HASH, FUTURE_REP_COMPARE, ACE_Null_Mutex > | |
| CACE_Hash_Map_Manager_Ex< KEY, std::pair< VALUE, ATTRIBUTES >, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex > | |
| CACE_Hash_Map_Manager_Ex< KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex > | |
| CACE_Hash_Map_Manager_Ex< key_type, value_type, ACE_Hash< key_type >, std::equal_to< key_type >, ACE_Null_Mutex > | |
| CACE_Hash_Map_Manager_Ex< REFCOUNTED_HASH_RECYCLABLE_ADDRESS, std::pair< SVC_HANDLER *, ATTRIBUTES >, ACE_Hash< REFCOUNTED_HASH_RECYCLABLE_ADDRESS >, ACE_Equal_To< REFCOUNTED_HASH_RECYCLABLE_ADDRESS >, ACE_Null_Mutex > | |
| CACE_Hash_Map_Manager_Ex< REFCOUNTED_HASH_RECYCLABLE_ADDRESS, SVC_HANDLER *, ACE_Hash< REFCOUNTED_HASH_RECYCLABLE_ADDRESS >, ACE_Equal_To< REFCOUNTED_HASH_RECYCLABLE_ADDRESS >, ACE_Null_Mutex > | |
| CACE_Hash_Multi_Map_Bucket_Iterator< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK > | Forward iterator for the ACE_Hash_Multi_Map_Manager which only traverses a particular bucket. The particular bucket is specified by the EXT_ID parameter specified in the constructor |
| ►CACE_Hash_Multi_Map_Const_Iterator_Base< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK > | Base const iterator for the ACE_Hash_Multi_Map_Manager |
| CACE_Hash_Multi_Map_Const_Iterator< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK > | Const forward iterator for the ACE_Hash_Multi_Map_Manager |
| CACE_Hash_Multi_Map_Entry< EXT_ID, INT_ID > | Define an entry in the hash table |
| ►CACE_Hash_Multi_Map_Iterator_Base< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK > | Base iterator for the ACE_Hash_Multi_Map_Manager |
| CACE_Hash_Multi_Map_Iterator< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK > | Forward iterator for the ACE_Hash_Multi_Map_Manager |
| CACE_Hash_Multi_Map_Reverse_Iterator< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK > | Reverse iterator for the ACE_Hash_Multi_Map_Manager |
| CACE_Hash_Multi_Map_Manager< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK > | Define a multi-map abstraction that efficiently associates the keys with their different values |
| ►CACE_Hashable | ACE_Hashable |
| CACE_Refcounted_Hash_Recyclable< T > | |
| CACE_High_Res_Timer | A high resolution timer class wrapper that encapsulates OS-specific high-resolution timers, such as those found on Solaris, AIX, Win32/Pentium, and VxWorks |
| CACE_HR_Time_Policy | Implement a time policy based on the ACE Highres timer |
| CACE_Incremental_Key_Generator< T > | Defines a simple incremental key generator |
| CACE_InputCDR | A CDR stream for demarshalling CDR-encoded data |
| CACE_Intrusive_Auto_Ptr< X > | This class implements support for a reference counted auto_ptr. It assumes reference counting abilities of the parameterizing class |
| CACE_Intrusive_Auto_Ptr< ACE_Service_Gestalt > | |
| CACE_Intrusive_List< T > | Implement an intrusive double linked list |
| CACE_Intrusive_List< ACE_Cleanup_Info_Node > | |
| CACE_Intrusive_List< ACE_Notification_Queue_Node > | |
| CACE_Intrusive_List_Node< T > | Implement the requirements for ACE_Intrusive_List |
| ►CACE_Intrusive_List_Node< ACE_Cleanup_Info_Node > | |
| CACE_Cleanup_Info_Node | For maintaining a list of ACE_Cleanup_Info items |
| ►CACE_Intrusive_List_Node< ACE_Notification_Queue_Node > | |
| CACE_Notification_Queue_Node | Helper class |
| CACE_IO_Cntl_Msg | Data format for IOCTL messages |
| ►CACE_IO_SAP | Defines the methods for the base class of the ACE_IO_SAP abstraction, which includes ACE_FILE and ACE_DEV |
| ►CACE_DEV | Defines the member functions for the base class of the ACE_DEV abstraction |
| ►CACE_DEV_IO | Read/Write operations on Devices |
| CACE_TTY_IO | Class definitions for platform specific TTY features |
| ►CACE_FILE | Defines the core methods of the ACE_FILE abstraction |
| CACE_FILE_IO | Read/Write operations on Files |
| ►CACE_IPC_SAP | Defines the member functions for the base class of the ACE_IPC_SAP abstraction |
| ►CACE_FIFO | Abstract base class for UNIX FIFOs |
| ►CACE_FIFO_Recv | Receiver side of the bytestream C++ wrapper for UNIX FIFOs |
| CACE_FIFO_Recv_Msg | Receiver side for the record oriented C++ wrapper for UNIX FIFOs |
| ►CACE_FIFO_Send | Sender side for the bytestream C++ wrapper for UNIX FIFOs |
| CACE_FIFO_Send_Msg | Sender side for the Record oriented C++ wrapper for UNIX FIFOs |
| ►CACE_SOCK | An abstract class that forms the basis for more specific classes, such as ACE_SOCK_Acceptor and ACE_SOCK_Stream. Do not instantiate this class |
| ►CACE_ICMP_Socket | An abstract class that forms the basis for usage of the ICMP protocol (that is, support for things such as ping) |
| CACE_Ping_Socket | This class is useful to perform ICMP echo checks (pinging) on the party of your interest. It may be used as well to check LAN-adapters against 3rd parties |
| ►CACE_MEM_IO | Defines the methods for the ACE shared memeory wrapper I/O routines (e.g., send/recv). The shared memory transport uses ACE_SOCK_* class to implement the signaling mechanism so we can easily use the new mechanism with the Reactor pattern (which uses select under the hood.) ACE_MEM_Acceptor and ACE_MEM_Connector are used to establish connections. When a connection is established, ACE_MEM_Acceptor creates the MMAP file for data exchange and sends the location of the file (complete path name) to ACE_MEM_Connector thru the socket. ACE_MEM_Connector then reads the location of the file off the socket and opens up the same MMAP file. ACE_MEM_Stream at each side then contains a reference to the ACE_Mallo object using the same MMAP file. When sending information using methods provided in this class, ACE_MEM_IO requests a chunk of memory from the MALLOC_TYPE object, copy the data into the shared memory and send the memory offset (from the start of the ACE_Malloc) across the socket. This action also servers as a signal to the other end. The receiving side then reverses the procedures and copies the information into user buffer |
| CACE_MEM_Stream | Defines the methods in the ACE_MEM_Stream abstraction |
| ►CACE_SOCK_Acceptor | Defines a factory that creates new ACE_Streams passively |
| CACE_LOCK_SOCK_Acceptor< ACE_LOCK > | Specialize ACE_SOCK_Acceptor to lock around <accept>; |
| CACE_LSOCK_Acceptor | Defines the format and interface for the acceptor side of the local ACE_SOCK ACE_Stream |
| CACE_MEM_Acceptor | Defines the format and interface for the acceptor side of the local mmap stream |
| ►CACE_SOCK_Dgram | Defines the member functions for the ACE_SOCK datagram abstraction |
| CACE_LSOCK_Dgram | Create a Local ACE_SOCK datagram |
| CACE_SOCK_Dgram_Bcast | Defines the member functions for the ACE_SOCK datagram abstraction |
| CACE_SOCK_Dgram_Mcast | Defines the ACE socket wrapper for UDP/IP multicast |
| ►CACE_SOCK_IO | Defines the methods for the ACE socket wrapper I/O routines described below |
| ►CACE_SOCK_CODgram | Defines the member functions for the ACE_SOCK connected datagram abstraction |
| CACE_LSOCK_CODgram | Defines a fully specified (sometimes called "connected") UNIX-domain datagram abstraction |
| CACE_SOCK_SEQPACK_Association | Defines the methods in the ACE_SOCK_SEQPACK_Association abstraction |
| ►CACE_SOCK_Stream | Defines the methods in the ACE_SOCK_Stream abstraction |
| CACE_LSOCK_Stream | Create a Local ACE_SOCK stream |
| CACE_SOCK_SEQPACK_Acceptor | Defines a factory that creates new ACE_Associations passively |
| ►CACE_SPIPE | Defines the member functions for the base class of the ACE_SPIPE abstraction |
| ►CACE_SPIPE_Acceptor | A factory class that produces ACE_SPIPE_Stream objects |
| CACE_UPIPE_Acceptor | Defines the format and interface for the listener side of the ACE_UPIPE_Stream |
| CACE_SPIPE_Stream | Defines the methods in the ACE_SPIPE_Stream abstraction |
| CACE_UPIPE_Stream | Defines the method that transfer data on a UPIPE |
| ►CACE_TLI | Defines the member functions for the base class of the ACE_TLI abstraction |
| CACE_TLI_Acceptor | Defines the member functions for ACE_TLI_Acceptor abstraction |
| CACE_TLI_Stream | Defines the member functions for ACE_TLI_Stream abstraction |
| CACE_Iterator< T > | Defines the iterator interface |
| ►CACE_Iterator_Impl< T > | Defines a abstract iterator |
| CACE_Active_Map_Manager_Iterator_Adapter< T, VALUE > | Defines a iterator implementation for the Active_Map_Manager_Adapter |
| CACE_Hash_Map_Manager_Ex_Iterator_Adapter< T, KEY, VALUE, HASH_KEY, COMPARE_KEYS > | Defines a iterator implementation for the Hash_Map_Manager_Adapter |
| CACE_Map_Impl_Iterator_Adapter< T, IMPLEMENTATION, ENTRY > | Defines a iterator implementation for the Map_Impl class |
| CACE_Map_Manager_Iterator_Adapter< T, KEY, VALUE > | Defines a iterator implementation for the Map_Manager_Adapter |
| CACE_Less_Than< TYPE > | Function object for determining whether the first object of the given type is less than the second object of the same type |
| CACE_Less_Than< ACE_CString > | Function object for determining whether the first const string is less than the second const string |
| CACE_Less_Than< char * > | Function object for determining whether the first string is less than the second string |
| CACE_Less_Than< const char * > | Function object for determining whether the first const string is less than the second const string |
| CACE_Less_Than< const wchar_t * > | Function object for determining whether the first const string is less than the second const string |
| CACE_Less_Than< std::string > | Function object for determining whether the first const string is less than the second const string |
| CACE_Less_Than< wchar_t * > | Function object for determining whether the first string is less than the second string |
| CACE_LFU_Caching_Strategy< ATTRIBUTES, CACHING_UTILITY > | Defines a Least Frequently Used strategy for which will decide on the item to be removed from the cache |
| CACE_Local_Memory_Pool | Make a memory pool that is based on C++ new/delete. This is useful for integrating existing components that use new/delete into the ACE Malloc scheme.. |
| CACE_Local_Memory_Pool_Options | Helper class for Local Memory Pool constructor options |
| ►CACE_Lock | This is the abstract base class that contains the uniform locking API that is supported by all the ACE synchronization mechanisms |
| CACE_Adaptive_Lock | An adaptive general locking class that defers the decision of lock type to run time |
| CACE_Lock_Adapter< ACE_LOCKING_MECHANISM > | This is an adapter that allows applications to transparently combine the ACE_Lock abstract base class (which contains pure virtual methods) with any of the other concrete ACE synchronization classes (e.g., ACE_Mutex, ACE_Semaphore, ACE_RW_Mutex, etc.) |
| CACE_Lock_Adapter< ACE_Process_Mutex > | |
| CACE_Lock_Adapter< ACE_Reactor_Token_T< ACE_DEV_POLL_TOKEN > > | |
| CACE_Lock_Adapter< ACE_Select_Reactor_Token > | |
| CACE_Lock_Adapter< ACE_SELECT_REACTOR_TOKEN > | |
| CACE_Reverse_Lock< ACE_LOCKING_MECHANISM > | A reverse (or anti) lock |
| CACE_Log_Category | Provides a categorized message logging abstraction |
| CACE_Log_Category_TSS | The thread specific object for a ACE_Log_Categy object |
| CACE_Log_Msg | Provides a variable length argument message logging abstraction |
| ►CACE_Log_Msg_Backend | Defines the interface for ACE_Log_Msg back end processing |
| CACE_Log_Msg_IPC | Defines the interfaces for ACE_Log_Msg backend |
| CACE_Log_Msg_NT_Event_Log | Implements an ACE_Log_Msg_Backend that logs to the WinNT system event log |
| CACE_Log_Msg_UNIX_Syslog | Implements an ACE_Log_Msg_Backend that logs messages to a UNIX system's syslog facility |
| CACE_Log_Msg_Callback | An interface class used to get logging callbacks |
| CACE_Log_Msg_Manager | Synchronize output operations |
| CACE_Log_Record | Defines the structure of an ACE logging record |
| CACE_LRU_Caching_Strategy< ATTRIBUTES, CACHING_UTILITY > | Defines a Least Recently Used strategy which will decide on the item to be removed from the cache |
| ►CACE_LSOCK | Create a Local ACE_SOCK, which is used for passing file descriptors |
| CACE_LSOCK_CODgram | Defines a fully specified (sometimes called "connected") UNIX-domain datagram abstraction |
| CACE_LSOCK_Dgram | Create a Local ACE_SOCK datagram |
| CACE_LSOCK_Stream | Create a Local ACE_SOCK stream |
| CACE_Malloc_FIFO_Iterator_T< ACE_MEM_POOL_1, ACE_LOCK, ACE_CB > | FIFO iterator for names stored in Malloc'd memory |
| ►CACE_Malloc_FIFO_Iterator_T< ACE_MEM_POOL_2, ACE_LOCK, ACE_Control_Block > | |
| CACE_Malloc_FIFO_Iterator< ACE_MEM_POOL_1, ACE_LOCK > | |
| CACE_Control_Block::ACE_Malloc_Header | This is the control block header. It's used by <ACE_Malloc> to keep track of each chunk of data when it's in the free list or in use |
| CACE_PI_Control_Block::ACE_Malloc_Header | This is the control block header. It's used by ACE_Malloc to keep track of each chunk of data when it's in the free list or in use |
| CACE_Malloc_LIFO_Iterator_T< ACE_MEM_POOL_1, ACE_LOCK, ACE_CB > | LIFO iterator for names stored in Malloc'd memory |
| ►CACE_Malloc_LIFO_Iterator_T< ACE_MEM_POOL_2, ACE_LOCK, ACE_Control_Block > | |
| CACE_Malloc_LIFO_Iterator< ACE_MEM_POOL_1, ACE_LOCK > | |
| CACE_Malloc_Lock_Adapter_T< ACE_LOCK > | Template functor adapter for lock strategies used with ACE_Malloc_T |
| CACE_Malloc_Lock_Adapter_T< ACE_Null_Mutex > | Template specialization of ACE_Malloc_Lock_Adapter_T for the ACE_Null_Mutex |
| CACE_Malloc_Lock_Adapter_T< ACE_Process_Semaphore > | Template specialization of ACE_Malloc_Lock_Adapter_T for ACE_Process_Semaphore |
| CACE_Malloc_Lock_Adapter_T< ACE_Thread_Semaphore > | Template specialization of ACE_Malloc_Lock_Adapter_T for ACE_Thread_Semaphore |
| CACE_Malloc_T< ACE_MEM_POOL_1, ACE_LOCK, ACE_CB > | A class template that uses parameterized types to provide an extensible mechanism for encapsulating various dynamic memory management strategies |
| CACE_Malloc_T< ACE_MEM_POOL_2, ACE_LOCK, ACE_CB > | |
| ►CACE_Malloc_T< ACE_MEM_POOL_2, ACE_LOCK, ACE_Control_Block > | |
| CACE_Malloc< ACE_MEM_POOL_1, ACE_LOCK > | |
| CACE_Managed_Object< TYPE > | Wrapper for interface to allocate an object managed by the ACE_Object_Manager |
| ►CACE_Map< KEY, VALUE > | Defines a map interface |
| CACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER > | Defines a map implementation |
| CACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR > | Defines a map implementation |
| CACE_Map_Impl< KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY > | Defines a map implementation |
| CACE_Map_Manager_Adapter< KEY, VALUE, KEY_GENERATOR > | Defines a map implementation |
| ►CACE_Map_Const_Iterator_Base< EXT_ID, INT_ID, ACE_LOCK > | Const iterator for the ACE_Map_Manager |
| CACE_Map_Const_Iterator< EXT_ID, INT_ID, ACE_LOCK > | Forward const iterator for the ACE_Map_Manager |
| CACE_Map_Entry< EXT_ID, INT_ID > | An entry in the Map |
| CACE_Map_Entry< ACE_Active_Map_Manager_Key, std::pair< KEY, VALUE > > | |
| CACE_Map_Entry< ACE_Active_Map_Manager_Key, T > | |
| CACE_Map_Entry< ACE_Active_Map_Manager_Key, VALUE > | |
| CACE_Map_Entry< ACE_HANDLE, ACE_POSIX_Asynch_Connect_Result * > | |
| CACE_Map_Entry< KEY, VALUE > | |
| CACE_Map_Entry< TOKEN_NAME, ACE_Mutex_Invariants * > | |
| CACE_Map_Entry< TOKEN_NAME, ACE_RWLock_Invariants * > | |
| CACE_Map_Entry< TOKEN_NAME, ACE_Token_Proxy * > | |
| CACE_Map_Entry< TOKEN_NAME, ACE_Tokens * > | |
| CACE_Map_Entry< void *, size_t > | |
| ►CACE_Map_Iterator_Base< EXT_ID, INT_ID, ACE_LOCK > | Iterator for the ACE_Map_Manager |
| CACE_Map_Iterator< EXT_ID, INT_ID, ACE_LOCK > | Forward iterator for the ACE_Map_Manager |
| CACE_Map_Reverse_Iterator< EXT_ID, INT_ID, ACE_LOCK > | Reverse Iterator for the ACE_Map_Manager |
| ►CACE_Map_Iterator_Base< ACE_Active_Map_Manager_Key, VALUE, ACE_Null_Mutex > | |
| CACE_Map_Iterator< ACE_Active_Map_Manager_Key, VALUE, ACE_Null_Mutex > | |
| CACE_Map_Reverse_Iterator< ACE_Active_Map_Manager_Key, VALUE, ACE_Null_Mutex > | |
| ►CACE_Map_Iterator_Base< KEY, VALUE, ACE_Null_Mutex > | |
| CACE_Map_Iterator< KEY, VALUE, ACE_Null_Mutex > | |
| CACE_Map_Reverse_Iterator< KEY, VALUE, ACE_Null_Mutex > | |
| CACE_Map_Manager< EXT_ID, INT_ID, ACE_LOCK > | Define a map abstraction that associates EXT_IDs with INT_IDs |
| ►CACE_Map_Manager< ACE_Active_Map_Manager_Key, std::pair< KEY, VALUE >, ACE_Null_Mutex > | |
| CACE_Active_Map_Manager< std::pair< KEY, VALUE > > | |
| ►CACE_Map_Manager< ACE_Active_Map_Manager_Key, T, ACE_Null_Mutex > | |
| CACE_Active_Map_Manager< T > | Define a map abstraction that associates system generated keys with user specified values |
| CACE_Map_Manager< ACE_Active_Map_Manager_Key, VALUE, ACE_Null_Mutex > | |
| CACE_Map_Manager< ACE_HANDLE, ACE_POSIX_Asynch_Connect_Result *, ACE_SYNCH_NULL_MUTEX > | |
| CACE_Map_Manager< KEY, VALUE, ACE_Null_Mutex > | |
| CACE_Map_Manager< TOKEN_NAME, ACE_Mutex_Invariants *, ACE_Null_Mutex > | |
| CACE_Map_Manager< TOKEN_NAME, ACE_RWLock_Invariants *, ACE_Null_Mutex > | |
| CACE_Map_Manager< TOKEN_NAME, ACE_Token_Proxy *, ACE_Null_Mutex > | |
| CACE_Map_Manager< TOKEN_NAME, ACE_Tokens *, ACE_Null_Mutex > | |
| CACE_Map_Manager< void *, size_t, ACE_Null_Mutex > | |
| CACE_max_align_info | |
| ►CACE_MEM_SAP | Defines the methods of shared memory management for shared memory transport |
| CACE_MT_MEM_IO | |
| CACE_Reactive_MEM_IO | |
| CACE_MEM_SAP_Node | |
| CACE_Message_Block | Stores messages for use throughout ACE (particularly in an ACE_Message_Queue) |
| ►CACE_Message_Queue_Base | Base class for ACE_Message_Queue, which is the central queuing facility for messages in the ACE framework |
| CACE_Message_Queue< ACE_SYNCH_DECL, TIME_POLICY > | A message queuing facility with parameterized synchronization capability. ACE_Message_Queue is modeled after the queueing facilities in System V STREAMs |
| CACE_Message_Queue< ACE_MT_SYNCH > | |
| CACE_Message_Queue< ACE_SYNCH > | |
| CACE_Message_Queue< ACE_SYNCH_USE, ACE_System_Time_Policy > | |
| ►CACE_Message_Queue< ACE_SYNCH_USE, TIME_POLICY > | |
| CACE_Dynamic_Message_Queue< ACE_SYNCH_DECL, TIME_POLICY > | A derived class which adapts the ACE_Message_Queue class in order to maintain dynamic priorities for enqueued <ACE_Message_Blocks> and manage the queue order according to these dynamic priorities |
| CACE_Message_Queue_NT | Message Queue implementation using IO completion port on NT |
| CACE_Message_Queue_Ex< ACE_MESSAGE_TYPE, ACE_SYNCH_DECL, TIME_POLICY > | A threaded message queueing facility, modeled after the queueing facilities in System V STREAMs |
| ►CACE_Message_Queue_Ex< ACE_MESSAGE_TYPE, ACE_SYNCH_USE, TIME_POLICY > | |
| CACE_Message_Queue_Ex_N< ACE_MESSAGE_TYPE, ACE_SYNCH_DECL, TIME_POLICY > | A threaded message queueing facility, modeled after the queueing facilities in System V STREAMs which can enqueue multiple messages in one call |
| CACE_Message_Queue_Ex_Iterator< ACE_MESSAGE_TYPE, ACE_SYNCH_DECL, TIME_POLICY > | Iterator for the ACE_Message_Queue_Ex |
| CACE_Message_Queue_Ex_Reverse_Iterator< ACE_MESSAGE_TYPE, ACE_SYNCH_DECL, TIME_POLICY > | |
| CACE_Message_Queue_Factory< ACE_SYNCH_DECL, TIME_POLICY > | ACE_Message_Queue_Factory is a static factory class template which provides a separate factory method for each of the major kinds of priority based message dispatching: static, earliest deadline first (EDF), and minimum laxity first (MLF) |
| CACE_Message_Queue_Iterator< ACE_SYNCH_DECL, TIME_POLICY > | Iterator for the ACE_Message_Queue |
| CACE_Message_Queue_Iterator< ACE_SYNCH_USE, TIME_POLICY > | |
| CACE_Message_Queue_Reverse_Iterator< ACE_SYNCH_DECL, TIME_POLICY > | Reverse Iterator for the ACE_Message_Queue |
| CACE_Message_Queue_Reverse_Iterator< ACE_SYNCH_USE, TIME_POLICY > | |
| CACE_Method_Request | Reifies a method into a request. Subclasses must provide the necessary state and behavior |
| CACE_MMAP_Memory_Pool_Options | Helper class for MMAP Memory Pool constructor options |
| ►CACE_Module_Base | Workaround HP/C++ compiler bug with enums in templates |
| CACE_Module< ACE_SYNCH_DECL, TIME_POLICY > | An abstraction for managing a bi-directional flow of messages |
| CACE_Module< ACE_SYNCH_USE, ACE_System_Time_Policy > | |
| CACE_Module< ACE_SYNCH_USE, TIME_POLICY > | |
| CACE_Monotonic_Time_Policy | Implement a monotonic time policy for ACE |
| CACE_MT_SYNCH | Implement a default thread safe synchronization wrapper that typedefs the ACE_Condition and ACE_Mutex to the ACE_Condition and ACE_Mutex versions |
| CACE_Mutex | ACE_Mutex wrapper (valid in same process or across processes (depending on TYPE flag)). In general, however, we recommend using ACE_Process_Mutex or ACE_Thread_Mutex rather than ACE_Mutex |
| CACE_Mutex_Invariants | Mutex Invariants = INVARIANTS |
| CACE_Name_Binding | Maintains a mapping from name to value and type |
| CACE_Control_Block::ACE_Name_Node | This class supports "named memory regions" within ACE_Malloc |
| CACE_PI_Control_Block::ACE_Name_Node | This class supports "named memory regions" within ACE_Malloc |
| CACE_Name_Options | Manages the options for the ACE Name_Server |
| CACE_Name_Reply | Message format for delivering replies from the ACE_Name Server |
| CACE_Name_Request | Message format for delivering requests to the ACE_Name Server |
| ►CACE_Name_Space | Abstract base class that provides an abstract interface to the database without exposing any implemenation details |
| CACE_Local_Name_Space< ACE_MEM_POOL_1, ACE_LOCK > | Maintaining accesses Local Name Server Database. Allows to add NameBindings, change them, remove them and resolve NameBindings |
| CACE_Remote_Name_Space | Maintaining accesses Remote Name Server Database. Allows to add NameBindings, change them, remove them and resolve NameBindings |
| CACE_Node< T, C > | Implementation element in a Queue, Set, and Stack |
| CACE_Node< ACE_ARGV_Queue_Entry_T< CHAR_TYPE > > | |
| CACE_Node< ACE_INT32 > | |
| CACE_Node< ACE_Notification_Queue_Node * > | |
| CACE_Node< ACE_POSIX_Asynch_Accept_Result * > | |
| CACE_Node< ACE_POSIX_Asynch_Result * > | |
| CACE_Node< ACE_Thread_Descriptor * > | |
| CACE_Node< T > | |
| CACE_Node< T, ACE_Unbounded_Set_Default_Comparator< T > > | |
| CACE_Noop_Key_Generator< T > | Defines a noop key generator |
| CACE_Notification_Buffer | Simple wrapper for passing ACE_Event_Handler *s and ACE_Reactor_Masks between threads |
| ►CACE_Notification_Strategy | Abstract class used for notifying an interested party |
| CACE_Reactor_Notification_Strategy | Used to notify an ACE_Reactor |
| CACE_NS_Internal | This class and ACE_NS_String are used as Adapters to work with the Map_Manager |
| CACE_NS_String | This class and ACE_NS_Internal are used as Adapters to work with the Map_Manager |
| CACE_Null_Barrier | Implements "NULL barrier synchronization" |
| CACE_Null_Caching_Strategy< ATTRIBUTES, CACHING_UTILITY > | The is a special caching strategy which doesnt have the purging feature |
| ►CACE_Null_Mutex | Implement a do nothing ACE_Mutex, i.e., all the methods are no ops |
| ►CACE_Noop_Token | |
| CACE_Reactor_Token_T< ACE_DEV_POLL_TOKEN > | |
| CACE_Null_Semaphore | Implement a do nothing ACE_Semaphore, i.e., all the methods are no ops |
| CACE_NULL_SYNCH | Implement a do nothing Synchronization wrapper that typedefs the ACE_Condition and ACE_Mutex to the Null* versions |
| CACE_Numeric_Limits< T > | |
| CACE_Obchunk | Defines the state that represents a "chunk" of memory. Evenything in this class is public because it is designed as an internal structure of Obstack_T and users are not supposed to use this class directly |
| ►CACE_Object_Manager_Base | Base class for ACE_Object_Manager(s) |
| CACE_Object_Manager | Manager for ACE library services and singleton cleanup |
| CACE_OS_Object_Manager | |
| CACE_Object_Manager_Manager | Ensure that the ACE_Object_Manager gets initialized at program startup, and destroyed at program termination |
| CACE_Object_Manager_Preallocations | Performs preallocations of certain statically allocated services needed by ACE |
| CACE_Obstack_T< ACE_CHAR_T > | Define a simple "mark and release" memory allocation utility |
| CACE_Obstack_T< ACE_TCHAR > | |
| CACE_ODB | This is the object database (ODB) that keeps track of all live ACE objects |
| CACE_Ordered_MultiSet< T > | Implement a simple ordered multiset of {T} of unbounded size that allows duplicates. This class template requires that < operator semantics be defined for the parameterized type {T}, but does not impose any restriction on how that ordering operator is implemented. The set is implemented as a linked list |
| CACE_Ordered_MultiSet_Iterator< T > | Implement a bidirectional iterator over an ordered multiset. This class template requires that < operator semantics be defined for the parameterized type {T}, but does not impose any restriction on how that ordering operator is implemented |
| CACE_OS_Exit_Info | Hold Object Manager cleanup (exit) information |
| CACE_OS_Log_Msg_Attributes | The attributes required by ACE_Log_Msg |
| CACE_OS_Object_Manager_Manager | Ensure that the ACE_OS_Object_Manager gets initialized at program startup, and destroyed at program termination |
| ►CACE_OS_Thread_Descriptor | Parent class of all ACE_Thread_Descriptor classes |
| ►CACE_Thread_Descriptor_Base | Basic information for thread descriptors. These information gets extracted out because we need it after a thread is terminated |
| CACE_Thread_Descriptor | Information for controlling threads that run under the control of the <Thread_Manager> |
| CACE_OutputCDR | A CDR stream for marshalling data, most often for transmission to another system which may or may not have the same byte order |
| CACE_Pagefile_Memory_Pool | Make a memory pool that is based on "anonymous" memory regions allocated from the Win32 page file |
| CACE_Pagefile_Memory_Pool_Options | Helper class for Pagefile Memory Pool constructor options |
| CACE_PI_Control_Block | This information is stored in memory allocated by the Memory_Pool |
| CACE_Pipe | Provides a portable bidirectional "pipe" abstraction |
| CACE_Pointer_Hash< TYPE > | Function object for hashing pointers |
| CACE_POSIX__Asynch_Write_Dgram_Result | This is class provides concrete implementation for ACE_Asynch_Write_Dgram::Result class |
| CACE_Predefined_Naming_Contexts | A factory for predefined registries, which exist by default on Win32 platforms |
| CACE_Proactor | A manager for asynchronous event demultiplexing |
| CACE_Proactor_Handle_Timeout_Upcall | Functor for ACE_Timer_Queue |
| ►CACE_Process | A portable encapsulation for creating and managing new processes |
| CACE_Managed_Process | A process easily managed by ACE_Process_Manager |
| CACE_Process_Mutex | A wrapper for mutexes that can be used across processes on the same host machine, as well as within a process, of course |
| CACE_Process_Options | Process Options |
| CACE_Process_Semaphore | Wrapper for Dijkstra style general semaphores that work across processes |
| CACE_Profile_Timer | This class provides both a timing mechanism and a mechanism for reporting the resource usage of a process |
| CACE_Protocol_Info | |
| CACE_QoS | Wrapper class that holds the sender and receiver flow spec information, which is used by IntServ (RSVP) and DiffServ |
| CACE_QoS_Params | Wrapper class that simplifies the information passed to the QoS enabled <ACE_OS::connect> and <ACE_OS::join_leaf> methods |
| ►CACE_RB_Tree_Base | |
| CACE_RB_Tree< EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK > | Implements a Red-Black Tree ADT, according to T. H. Corman, C. E. Leiserson, and R. L. Rivest, "Introduction to Algorithms" 1990, MIT, chapter 14 |
| ►CACE_RB_Tree_Iterator_Base< EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK > | Implements a common base class for iterators for a Red-Black Tree ADT |
| CACE_RB_Tree_Iterator< EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK > | Implements an iterator for a Red-Black Tree ADT |
| CACE_RB_Tree_Reverse_Iterator< EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK > | Implements a reverse iterator for a Red-Black Tree ADT |
| ►CACE_RB_Tree_Node_Base | |
| CACE_RB_Tree_Node< EXT_ID, INT_ID > | Implements a node in a Red-Black Tree ADT |
| ►CACE_Reactor_Impl | An abstract class for implementing the Reactor Pattern |
| CACE_Dev_Poll_Reactor | A `/dev/poll' or `/dev/epoll' based Reactor implemenatation |
| ►CACE_Select_Reactor_Impl | This class simply defines how Select_Reactor's basic interface functions should look like and provides a common base class for Select_Reactor using various locking mechanism |
| CACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN > | An object oriented event demultiplexor and event handler dispatcher |
| ►CACE_Select_Reactor_T< ACE_Select_Reactor_Token > | |
| CACE_Priority_Reactor | Implements priority based dispatching |
| CACE_TP_Reactor | Specialization of ACE_Select_Reactor to support thread-pool based event dispatching |
| ►CACE_WFMO_Reactor | An object oriented event demultiplexor and event handler. ACE_WFMO_Reactor is a Windows-only implementation of the ACE_Reactor interface that uses the WaitForMultipleObjects() event demultiplexer |
| CACE_Msg_WFMO_Reactor | An OO event demultiplexor and event handler dispatcher for Win32 <MsgWaitForMultipleObjects> |
| ►CACE_Reactor_Timer_Interface | Interface for timer related methods on the Reactor |
| CACE_Reactor | This class forwards all methods to its delegation/implementation class, e.g., ACE_Select_Reactor or ACE_WFMO_Reactor |
| CACE_Read_Buffer | Efficiently reads an arbitrarily large buffer from an input stream up to and including a termination character. Also performs search/replace on single occurrences a character in the buffer using the principles of Integrated Layer Processing |
| CACE_recursive_mutex_state | |
| CACE_Recursive_Thread_Mutex | Implement a C++ wrapper that allows nested acquisition and release of a mutex that occurs in the same thread |
| CACE_recursive_thread_mutex_t | Implement a thin C++ wrapper that allows nested acquisition and release of a mutex that occurs in the same thread |
| ►CACE_Recyclable | |
| CACE_Refcounted_Hash_Recyclable< T > | |
| CACE_Recycling_Strategy< SVC_HANDLER > | Defines the interface (and default implementation) for specifying a recycling strategy for a SVC_HANDLER |
| CACE_Refcountable_T< ACE_LOCK > | |
| ►CACE_Refcountable_T< ACE_Null_Mutex > | |
| CACE_Refcounted_Hash_Recyclable< T > | |
| ►CACE_Refcountable_T< ACE_SYNCH_MUTEX > | |
| CACE::Monitor_Control::Control_Action | |
| ►CACE::Monitor_Control::Monitor_Base | Base class from which the template monitor point class is derived |
| CACE::Monitor_Control::Size_Monitor | Base class from which ACE monitors of size are derived |
| CACE_Refcounted_Auto_Ptr< X, ACE_LOCK > | This class implements support for a reference counted auto_ptr. Assigning or copying instances of an ACE_Refcounted_Auto_Ptr will automatically increment the reference count. When the last instance that references a ACE_Refcounted_Auto_Ptr instance is destroyed or overwritten, it will invoke delete on its underlying pointer |
| CACE_Refcounted_Auto_Ptr< ACE_Handler::Proxy, ACE_SYNCH_MUTEX > | |
| CACE_Refcounted_Auto_Ptr< Proxy, ACE_SYNCH_MUTEX > | |
| CACE_Refcounted_Auto_Ptr_Rep< X, ACE_LOCK > | An ACE_Refcounted_Auto_Ptr_Rep object encapsulates a pointer to an object of type X. It uses a lock object of type ACE_LOCK to protect access to the reference count |
| CACE_Reference_Pair< T1, T2 > | Defines a pair that only hold references |
| CACE_Registry | A Name Server implementation |
| CACE_Reverse_Iterator< T > | Defines the reverse iterator interface |
| ►CACE_Reverse_Iterator_Impl< T > | Defines a abstract reverse iterator |
| CACE_Active_Map_Manager_Reverse_Iterator_Adapter< T, VALUE > | Defines a reverse iterator implementation for the Active_Map_Manager_Adapter |
| CACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter< T, KEY, VALUE, HASH_KEY, COMPARE_KEYS > | Defines a reverse iterator implementation for the Hash_Map_Manager_Adapter |
| CACE_Map_Impl_Reverse_Iterator_Adapter< T, IMPLEMENTATION, ENTRY > | Defines a reverse iterator implementation for the Map_Impl class |
| CACE_Map_Manager_Reverse_Iterator_Adapter< T, KEY, VALUE > | Defines a reverse iterator implementation for the Map Manager |
| ►CACE_RW_Mutex | Wrapper for readers/writer locks |
| CACE_RW_Thread_Mutex | Wrapper for readers/writer locks that exist within a process |
| CACE_RW_Process_Mutex | Wrapper for readers/writer locks that exist across processes |
| CACE_RWLock_Invariants | RWLock Invariants |
| CACE_Sample_History | Save multiple samples in an array |
| CACE_Sbrk_Memory_Pool | Make a memory pool that is based on <sbrk(2)> |
| CACE_Sbrk_Memory_Pool_Options | Helper class for Sbrk Memory Pool constructor options |
| CACE_Sched_Params | Container for scheduling-related parameters |
| CACE_Sched_Priority_Iterator | An iterator over the OS-defined scheduling priorities |
| ►CACE_Scheduling_Strategy< SVC_HANDLER > | Defines the interface for specifying how to suspend and resume a service |
| CACE_Schedule_All_Reactive_Strategy< SVC_HANDLER > | Defines the interface for specifying how to suspend and resume a single-threaded reactive service |
| CACE_Schedule_All_Threaded_Strategy< SVC_HANDLER > | Defines the interface for specifying how to suspend and resume a multithreaded service |
| CACE_SDM_helpers | |
| ►CACE_Section_Key_Internal | A base class for internal handles to section keys for configuration implementations |
| CACE_Configuration_Section_Key_Heap | Internal section key class for heap based configuration database |
| CACE_Section_Key_Win32 | The Win32 registry implementation of an internal section key |
| CACE_Select_Reactor_Handle_Set | Track handles we are interested for various events |
| CACE_Select_Reactor_Handler_Repository | Used to map ACE_HANDLEs onto the appropriate ACE_Event_Handler * |
| CACE_Select_Reactor_Handler_Repository_Iterator | Iterate through the ACE_Select_Reactor_Handler_Repository |
| ►CACE_Semaphore | Wrapper for Dijkstra style general semaphores |
| CACE_Thread_Semaphore | Wrapper for Dijkstra style general semaphores that work only within one process |
| CACE_Service_Config | Supplies common server operations for dynamic and static configuration of service |
| CACE_Service_Config_Guard | A guard class, designed to be instantiated on the stack |
| CACE_Service_Object_Ptr | This is a smart pointer that holds onto the associated ACE_Service_Object * until the current scope is left, at which point the object's fini() hook is called and the service_object_ gets deleted |
| CACE_Service_Repository | Contains all the services offered by a Service Configurator-based application |
| CACE_Service_Repository_Iterator | Iterate through the ACE_Service_Repository |
| CACE_Service_Type | Keeps track of information related to the various ACE_Service_Type_Impl subclasses |
| CACE_Service_Type_Dynamic_Guard | A forward service declaration guard |
| ►CACE_Service_Type_Impl | The abstract base class of the hierarchy that defines the contents of the ACE_Service_Repository. The subclasses of this class allow the configuration of ACE_Service_Objects, ACE_Modules, and ACE_Streams |
| CACE_Module_Type | Define the methods for handling the configuration of ACE_Modules |
| CACE_Service_Object_Type | Define the methods for handling the configuration of ACE_Service_Objects |
| CACE_Stream_Type | Define the methods for handling the configuration of ACE_Streams |
| ►CACE_Shared_Memory | This base class adapts both System V shared memory and "BSD" mmap to a common API |
| CACE_Shared_Memory_MM | Shared memory wrapper based on MMAP |
| CACE_Shared_Memory_SV | Shared memory wrapper based on System V shared memory |
| CACE_Shared_Memory_Pool_Options | Helper class for Shared Memory Pool constructor options |
| ►CACE_Shared_Object | Provide the abstract base class used to access dynamic linking facilities |
| CACE_Service_Object | Provide the abstract base class common to all service implementations |
| CACE_Sig_Action | C++ wrapper facade for the sigaction struct |
| CACE_Sig_Guard | Hold signals in MASK for duration of a C++ statement block. Note that a "0" for mask causes all signals to be held |
| ►CACE_Sig_Handler | This is the main dispatcher of signals for ACE. It improves the existing UNIX signal handling mechanism by allowing C++ objects to handle signals in a way that avoids the use of global/static variables and functions |
| CACE_Sig_Handlers | This is an alternative signal handling dispatcher for ACE. It allows a list of signal handlers to be registered for each signal. It also makes SA_RESTART the default mode |
| CACE_Sig_Handlers_Set | |
| CACE_Sig_Set | Provide a C++ wrapper for the C sigset_t interface |
| CACE_SizeCDR | A CDR stream for calculating size of the representation |
| ►CACE_SOCK_Connector | Defines a factory that actively connects to a remote IP address and TCP port, creating a new ACE_SOCK_Stream object |
| CACE_LSOCK_Connector | Defines the format and interface for the connector side of the ACE_LSOCK_Stream |
| CACE_MEM_Connector | Defines the format and interface for connecting to a peer on a ACE_MEM_Stream object |
| CACE_SOCK_SEQPACK_Connector | Defines a factory that actively connects to a remote IP address and TCP port, creating a new ACE_SOCK_SEQPACK_Association object |
| CACE_SPIPE_Connector | Defines an active connection factory for ACE_SPIPE_Stream. On Windows this is mapped to Named Pipes, whereas on UNIX it is mapped to STREAM pipes |
| CACE_SString | A very Simple String ACE_SString class. This is not a general-purpose string class, and you should probably consider using ACE_CString is you don't understand why this class exists.. |
| CACE_Stack_Trace | Encapsulate a string representation of a stack trace on supported platforms. Stack traces for code built with optimize=1 (or "Release" configs on Visual Studio) may be misleading (missng frames) due to inlining performed by the compiler, which is indepenent of the inline=0 / inline=1 build option and the ACE_INLINE / ACE_NO_INLINE macros |
| CACE_Static_Object_Lock | Provide an interface to access a global lock |
| CACE_Static_Svc_Descriptor | Holds the information necessary to describe a statically linked Svc |
| CACE_Stats | Provides simple statistical analysis |
| CACE_Stats_Value | Helper class for ACE_Stats |
| CACE_Stream< ACE_SYNCH_DECL, TIME_POLICY > | This class is the primary abstraction for the ASX framework. It is moduled after System V Stream |
| CACE_Stream< ACE_SYNCH > | |
| CACE_Stream_Iterator< ACE_SYNCH_DECL, TIME_POLICY > | Iterate through an ACE_Stream |
| ►CACE_String_Base_Const | This class defines a constant for ACE_String_Base which originally was there to circumvent a bug in SunCC 6.0. This could be moved to ACE_String_Base but that adds a lot of footprint to the user applications which is not something we want |
| ►CACE_String_Base< ACE_CHAR_T > | This class provides a wrapper facade for C strings |
| CACE_NS_WString | This class retain the backward compatibility for ACE_Naming_Context and related classes. The only addition to ACE_WString is a very naive "wchar" to "char" conversion function |
| CACE_String_Base< char > | |
| CACE_String_Base_Const_Iterator< ACE_CHAR_T > | Const iterator class for the ACE_String_Base class |
| CACE_String_Base_Iterator< ACE_CHAR_T > | Iterator class for the ACE_String_Base class |
| CACE_Strong_Bound_Ptr< X, ACE_LOCK > | This class implements support for a reference counted pointer |
| CACE_Sub_Barrier | |
| CACE_SV_Message | Defines the header file for the C++ wrapper for message queues |
| CACE_SV_Message_Queue | Defines the header file for the C++ wrapper for System V IPC message queues |
| ►CACE_SV_Semaphore_Simple | This is a simple semaphore package that assumes there are no race conditions for initialization (i.e., the order of process startup must be well defined) |
| CACE_SV_Semaphore_Complex | This is a more complex semaphore wrapper that handles race conditions for initialization correctly.. |
| CACE_SV_Shared_Memory | This is a wrapper for System V shared memory |
| CACE_Svc_Conf_Param | An instance of this object will be passed down to the yyparse() and yylex() functions |
| CACE_Synch_Options | Contains the values of options used to determine the synchronous and asynchronous behavior |
| CACE_System_Time | Defines the timer services of the OS interface to access the system time either on the local host or on the central time server in the network |
| CACE_System_Time_Policy | Implement the system time policy for ACE |
| CACE_Task_Flags | These flags are used within the ACE_Task |
| CACE_Thread | Provides a wrapper for threads |
| CACE_Thread_Control | Used to keep track of a thread's activities within its entry point function |
| CACE_Thread_Exit | Keep exit information for a Thread in thread specific storage. so that the thread-specific exit hooks will get called no matter how the thread exits (e.g., via <ACE_Thread::exit>, C++ or Win32 exception, "falling off the end" of the thread entry point function, etc.) |
| CACE_Thread_Exit_Maybe | A version of ACE_Thread_Exit that is created dynamically under the hood if the flag is set to TRUE |
| CACE_Thread_Hook | This class makes it possible to provide user-defined "start" hooks that are called before the thread entry point function is invoked |
| CACE_Thread_ID | Defines a platform-independent thread ID class. Note that this class should be defined within the scope of a thread, rather than at global scope! |
| CACE_Thread_Manager | Manages a pool of threads |
| CACE_Thread_Mutex | ACE_Thread_Mutex wrapper (only valid for threads in the same process) |
| CACE_Threading_Helper< LOCK > | Encapsulates responsibility for allocating, destroying and manipulating the value, associated with a thread-specific key. Relates to the ability of the created thread to inherit the parent thread's gestalt. Designed to be used as an instance member of ACE_Service_Config |
| CACE_Threading_Helper< ACE_Null_Mutex > | |
| CACE_Threading_Helper< ACE_SYNCH_MUTEX > | |
| CACE_Threading_Helper< ACE_Thread_Mutex > | |
| ►CACE_Time_Value | Operations on "timeval" structures, which express time in seconds (secs) and microseconds (usecs) |
| CACE_Time_Value_T< TIME_POLICY > | |
| CACE_Timer_Node_Dispatch_Info_T< TYPE > | Maintains generated dispatch information for Timer nodes |
| CACE_Timer_Node_T< TYPE > | Maintains the state associated with a Timer entry |
| ►CACE_Timer_Queue_Iterator_T< TYPE > | Generic interface for iterating over a subclass of ACE_Timer_Queue |
| CACE_Timer_Hash_Iterator_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET, TIME_POLICY > | Iterates over an ACE_Timer_Hash_T |
| CACE_Timer_Heap_Iterator_T< TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY > | Iterates over an ACE_Timer_Heap_T |
| CACE_Timer_List_Iterator_T< TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY > | Iterates over an ACE_Timer_List |
| CACE_Timer_Wheel_Iterator_T< TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY > | Iterates over an ACE_Timer_Wheel |
| CACE_TLI_Connector | Defines an active connection factory for the ACE_TLI C++ wrappers |
| CACE_TLI_Request | |
| CACE_TLI_Request_Queue | |
| CACE_Token | Class that acquires, renews, and releases a synchronization token that is serviced in strict FIFO/LIFO ordering and that also supports (1) recursion and (2) readers/writer semantics |
| CACE_TOKEN_CONST | Not a public interface |
| CACE_Token_Name | Allows Token_Manger to identify tokens |
| ►CACE_Token_Proxy | Abstract representation of ACE tokens |
| CACE_Local_Mutex | Class that acquires, renews, and releases a synchronization token local to the process |
| CACE_Local_RLock | Class that acquires, renews, and releases a readers lock that is local to the process |
| CACE_Local_WLock | Class that acquires, renews, and releases a writer lock that is local to the process |
| CACE_Null_Token | No op class for nonthreaded platform protocols |
| ►CACE_Remote_Token_Proxy | Proxy for acquiring, renewing, and releasing a distributed synchronization token |
| CACE_Remote_Mutex | Proxy for acquiring, renewing, and releasing a distributed mutex |
| CACE_Remote_RLock | Proxy for acquiring, renewing, and releasing a distributed readers lock |
| CACE_Remote_WLock | Proxy for acquiring, renewing, and releasing a distributed writers lock |
| CACE_Token_Collection | Allows atomic token group operations AND provides a ACE_Token manager interface |
| CACE_Token_Proxy_Queue | Token waiter list |
| CACE_Token::ACE_Token_Queue | |
| CACE_Token::ACE_Token_Queue_Entry | |
| CACE_Token_Reply | Message format for delivering replies from the ACE_Token Server |
| CACE_Token_Request | Message format for delivering requests to the ACE_Token Server |
| CACE_Tokenizer_T< ACE_CHAR_T > | Tokenizer |
| ►CACE_Tokens | Abstract representation of ACE tokens |
| CACE_Mutex_Token | Class that acquires, renews, and releases a process-local synchronization token |
| CACE_RW_Token | Class that acquires, renews, and releases a process-local synchronization token |
| CACE_TP_Token_Guard | A helper class that helps grabbing, releasing and waiting on tokens for a thread that tries calling handle_events () |
| ►CACE_TPQ_Entry | Token Proxy Queue entry. Used in the ACE_Token_Proxy_Queue |
| CACE_TSS_TPQ_Entry | ACE_TSS_TPQ_Entry |
| CACE_TPQ_Iterator | Iterates through ACE_Token_Proxy_Queues |
| CACE_Trace | A C++ trace facility that keeps track of which methods are entered and exited |
| CACE_TSS_Adapter | This class encapsulates a TSS object and its associated C++ destructor function. It is used by the ACE_TSS... methods (in Synch_T.cpp) in order to allow an extern "C" cleanup routine to be used |
| CACE_TSS_Cleanup | Singleton that helps to manage the lifetime of TSS objects and keys |
| CACE_TSS_Info | Thread Specific Key management |
| CACE_TSS_Keys | Collection of in-use flags for a thread's TSS keys. For internal use only by ACE_TSS_Cleanup; it is public because some compilers can't use nested classes for template instantiation parameters |
| CACE_TSS_Ref | "Reference count" for thread-specific storage keys |
| CACE_TSS_Type_Adapter< TYPE > | Adapter that allows built-in types to be used with ACE_TSS |
| CACE_Type_Traits< TYPE > | |
| CACE_Type_Traits< bool > | |
| CACE_Type_Traits< char > | |
| CACE_Type_Traits< double > | |
| CACE_Type_Traits< float > | |
| CACE_Type_Traits< int > | |
| CACE_Type_Traits< long > | |
| CACE_Type_Traits< long double > | |
| CACE_Type_Traits< long long > | |
| CACE_Type_Traits< short > | |
| CACE_Type_Traits< signed char > | |
| CACE_Type_Traits< TYPE * > | |
| CACE_Type_Traits< unsigned char > | |
| CACE_Type_Traits< unsigned int > | |
| CACE_Type_Traits< unsigned long > | |
| CACE_Type_Traits< unsigned long long > | |
| CACE_Type_Traits< unsigned short > | |
| CACE_Typed_SV_Message< T > | Defines the header file for the C++ wrapper for System V message queues |
| CACE_Typed_SV_Message_Queue< T > | Defines the header file for the C++ wrapper facade for typed message queues |
| CACE_Unbounded_Queue< T > | A Queue of "infinite" length |
| CACE_Unbounded_Queue< ACE_ARGV_Queue_Entry_T< CHAR_TYPE > > | |
| CACE_Unbounded_Queue< ACE_INT32 > | |
| CACE_Unbounded_Queue< ACE_Notification_Queue_Node * > | |
| CACE_Unbounded_Queue< ACE_POSIX_Asynch_Accept_Result * > | |
| CACE_Unbounded_Queue< ACE_POSIX_Asynch_Result * > | |
| CACE_Unbounded_Queue< ACE_Thread_Descriptor * > | |
| CACE_Unbounded_Queue_Const_Iterator< T > | Implement an iterator over an const unbounded queue |
| CACE_Unbounded_Queue_Iterator< T > | Implement an iterator over an unbounded queue |
| CACE_Unbounded_Set_Default_Comparator< T > | Simple comparator that evaluates equality using == operator |
| CACE_Unbounded_Set_Default_Comparator< ACE_HANDLE > | |
| CACE_Unbounded_Set_Default_Comparator< ACE_Timer_Node_T< TYPE > * > | |
| CACE_Unbounded_Set_Default_Comparator< char * > | |
| CACE_Unbounded_Set_Default_Comparator< INT_ID > | |
| CACE_Unbounded_Set_Default_Comparator< OBSERVER * > | |
| CACE_Unbounded_Set_Ex< T, C > | Implement a simple unordered set of <T> of unbounded size |
| ►CACE_Unbounded_Set_Ex< ACE_HANDLE, ACE_Unbounded_Set_Default_Comparator< ACE_HANDLE > > | |
| CACE_Unbounded_Set< ACE_HANDLE > | |
| ►CACE_Unbounded_Set_Ex< ACE_Timer_Node_T< TYPE > *, ACE_Unbounded_Set_Default_Comparator< ACE_Timer_Node_T< TYPE > * > > | |
| CACE_Unbounded_Set< ACE_Timer_Node_T< TYPE > * > | |
| ►CACE_Unbounded_Set_Ex< char *, ACE_Unbounded_Set_Default_Comparator< char * > > | |
| CACE_Unbounded_Set< char * > | |
| ►CACE_Unbounded_Set_Ex< INT_ID, ACE_Unbounded_Set_Default_Comparator< INT_ID > > | |
| CACE_Unbounded_Set< INT_ID > | |
| ►CACE_Unbounded_Set_Ex< OBSERVER *, ACE_Unbounded_Set_Default_Comparator< OBSERVER * > > | |
| CACE_Unbounded_Set< OBSERVER * > | |
| ►CACE_Unbounded_Set_Ex< T, ACE_Unbounded_Set_Default_Comparator< T > > | |
| CACE_Unbounded_Set< T > | Compatibility wrapper for ACE_Unbounded_Set_Ex |
| CACE_Unbounded_Set_Ex_Const_Iterator< T, C > | Implement an const iterator over an unbounded set |
| ►CACE_Unbounded_Set_Ex_Const_Iterator< T, ACE_Unbounded_Set_Default_Comparator< T > > | |
| CACE_Unbounded_Set_Const_Iterator< T > | Compatibility wrapper for ACE_Unbounded_Set_Ex_Const_Iterator |
| CACE_Unbounded_Set_Ex_Iterator< T, C > | Implement an iterator over an unbounded set |
| ►CACE_Unbounded_Set_Ex_Iterator< T, ACE_Unbounded_Set_Default_Comparator< T > > | |
| CACE_Unbounded_Set_Iterator< T > | Compatibility wrapper for ACE_Unbounded_Set_Ex_Iterator |
| CACE_Unbounded_Stack< T > | Implement a generic LIFO abstract data type |
| CACE_Unbounded_Stack_Iterator< T > | Implement an iterator over an unbounded Stack |
| CACE_UPIPE_Connector | Defines an active connection factory for the ACE_UPIPE_STREAM wrappers |
| CACE_UUID | |
| CACE_UUID_Generator | |
| CACE_Vector_Iterator< T, DEFAULT_SIZE > | Implement an iterator over an ACE_Vector |
| CACE_WChar_Codeset_Translator | Codeset translation routines common to both Output and Input CDR streams |
| CACE_Weak_Bound_Ptr< X, ACE_LOCK > | This class implements support for a weak pointer that complements ACE_Strong_Bound_Ptr |
| CACE_WFMO_Reactor_Handler_Repository | Used to map ACE_HANDLEs onto the appropriate ACE_Event_Handler * and other information |
| CACE_Wide_To_Ascii | A lightweight wchar* to char* string conversion class |
| ►CACE_WIN32_Asynch_Result | |
| CACE_WIN32_Asynch_Timer | This class is posted to the completion port when a timer expires. When the complete method of this object is called, the handler's handle_timeout method will be called |
| CACE_WIN32_Wakeup_Completion | |
| CACE_XML_Svc_Conf | This abstract class defines the common operations ACE_Service_Config expects when using the XML Service Config Parser |
| CAdmin | Accesses monitor points or groups and manages the registries |
| ►Caiocb | |
| CACE_POSIX_Asynch_Result | |
| CACE_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 |
| CACE_Utils::Auto_Functor_Ref< X, Functor > | Helper class to implement assignment and copy-construction as expected |
| CACE_Registry::Binding | |
| CACE_Registry::Binding_Iterator | An iterator |
| Ccancel_state | |
| CACE_MT_MEM_IO::Channel | |
| ►CACE_WFMO_Reactor_Handler_Repository::Common_Info | This struct contains the necessary information for every Event_Handler entry. The reason the event is not in this structure is because we need to pass an event array into WaitForMultipleObjects and therefore keeping the events separate makes sense |
| CACE_WFMO_Reactor_Handler_Repository::Current_Info | This structure inherits from the common structure to add information for current entries |
| CACE_WFMO_Reactor_Handler_Repository::Suspended_Info | This structure inherits from the common structure to add information for suspended entries |
| CACE_WFMO_Reactor_Handler_Repository::To_Be_Added_Info | This structure inherits from the common structure to add information for <to_be_added> entries |
| CACE_Utils::Comparator< LEFT, RIGHT > | Structure that provides optimal comparison operation for given types |
| CACE::Monitor_Control::Monitor_Control_Types::Constraint | Bundles the constrain string with its associated trigger action |
| CACE_Pagefile_Memory_Pool::Control_Block | Attributes that are meaningful in local storage only |
| CControlAction | Base class for control actions initiated by the application or by constraint evaluation trigger |
| Ccpu_set_t | |
| CACE::Monitor_Control::Monitor_Control_Types::Data | An instance is contained by each enabled monitor point |
| CACE_Utils::UUID::data | Data Members for Class Attributes |
| CACE_Tokenizer_T< ACE_CHAR_T >::Delimiter_Entry | Delimiter Entry |
| Cdirent | |
| CACE_CDR::Double | |
| CACE_Dev_Poll_Reactor::Event_Tuple | Struct that collects event registration information for a handle |
| CACE_Utils::Fast_Comparator< LEFT, RIGHT > | Quick comparison of types that can be safely promoted and/or converted to each other |
| CACE_CDR::Fixed | |
| CACE_CDR::Float | |
| Cframe_state | |
| CACE_OutputCDR::from_boolean | |
| CACE_OutputCDR::from_char | |
| CACE_OutputCDR::from_octet | |
| CACE_OutputCDR::from_string | |
| CACE_OutputCDR::from_wchar | |
| CACE_OutputCDR::from_wstring | |
| CACE_Dev_Poll_Reactor::Handler_Repository | Used to map ACE_HANDLEs onto the appropriate Event_Tuple |
| CHash_Token< TYPE > | |
| CACE_Asynch_Transmit_File::Header_And_Trailer | The class defines a data structure that contains pointers to data to send before and after the file data is sent |
| Cicmp | |
| CACE::If_Then_Else< C, Ta, Tb > | Compile-time selection of type based on a boolean value |
| CACE::If_Then_Else< false, Ta, Tb > | |
| CACE::If_Then_Else< true, Ta, Tb > | |
| ►Ciostream | |
| CACE_IOStream< STREAM > | A template adapter for creating an iostream-like object using an ACE IPC Stream for the actual I/O. Iostreams use an underlying streambuf object for the IO interface. The iostream class and derivatives provide you with a host of convenient operators that access the streambuf |
| Cip | |
| CACE_INET_Addr::ip46 | |
| ►CACE_Registry::Binding_Iterator::Iteration_State | |
| CACE_Registry::Binding_Iterator::Context_Iteration | |
| CACE_Registry::Binding_Iterator::Iteration_Complete | |
| CACE_Registry::Binding_Iterator::Object_Iteration | |
| ►Citerator | |
| CACE_CDR::Fixed::ConstIterator | |
| CACE_CDR::Fixed::Iterator | |
| ►CACE_CDR::Fixed::IteratorBase | |
| CACE_CDR::Fixed::ConstIterator | |
| CACE_CDR::Fixed::Iterator | |
| CACE_Active_Map_Manager_Key::key_data | Data for the Active Object Map Key |
| CACE_CDR::LongDouble | |
| CACE_OS::macaddr_node_t | |
| CACE::Monitor_Control::Monitor_Admin | |
| CACE::Monitor_Control::Monitor_Control_Types | |
| CACE::Monitor_Control::Monitor_Point_Registry | Storage for instantiated monitor points |
| CACE_MT_MEM_IO::MQ_Struct | |
| Cmsghdr | |
| CACE_Registry::Name_Component | International string |
| CACE_Registry::Naming_Context | An context representation |
| CACE_Utils::Noop_Truncator< FROM, TO > | No-op truncation |
| CACE_Registry::Object | An object representation |
| ►CACE_Event_Handler::Policy | Base class for all handler policies |
| CACE_Event_Handler::Reference_Counting_Policy | This policy dictates the reference counting requirements for the handler |
| CACE_Tokenizer_T< ACE_CHAR_T >::Preserve_Entry | Preserve Entry |
| CACE_Process_Manager::Process_Descriptor | Information describing each process that's controlled by an ACE_Process_Manager |
| CACE_Service_Gestalt::Processed_Static_Svc | |
| CACE_Handler::Proxy | Acts as a proxy for dispatch of completions to operations issued for the associated handler. It allows the handler to be deleted while operations are outstanding. The proxy must be used to get the ACE_Handler pointer for dispatching, and if it's 0, the handler is no longer valid and the result should not be dispatched |
| CACE_CDR::Fixed::Proxy | |
| CACE_Codeset_Registry::registry_entry | |
| Crusage | |
| CACE_Utils::Safe_Comparator< LEFT, RIGHT, IS_LEFT_SIGNED, IS_RIGHT_SIGNED > | Conservative comparison of types that may not be safely promoted and/or converted to each other |
| CACE_Utils::Safe_Comparator< LEFT, RIGHT, false, false > | |
| CACE_Utils::Safe_Comparator< LEFT, RIGHT, false, true > | |
| CACE_Utils::Safe_Comparator< LEFT, RIGHT, true, false > | |
| CACE_Utils::Safe_Comparator< LEFT, RIGHT, true, true > | |
| CACE_Bounded_Set< T >::Search_Structure | |
| Csemun | |
| CACE_TTY_IO::Serial_Params | |
| CACE_Pagefile_Memory_Pool::Control_Block::Shared_Control_Block | Pool statistics |
| CACE_Shared_Memory_Pool::SHM_TABLE | Keeps track of all the segments being used |
| Csiginfo_t | |
| CACE_Utils::Sign_Check< T > | |
| CACE_Utils::Sign_Check< signed char > | |
| CACE_Utils::Sign_Check< signed int > | |
| CACE_Utils::Sign_Check< signed long > | |
| CACE_Utils::Sign_Check< signed long long > | |
| CACE_Utils::Sign_Check< signed short > | |
| CACE_Utils::Sign_Check< unsigned char > | |
| CACE_Utils::Sign_Check< unsigned int > | |
| CACE_Utils::Sign_Check< unsigned long > | |
| CACE_Utils::Sign_Check< unsigned long long > | |
| CACE_Utils::Sign_Check< unsigned short > | |
| CACE_MT_MEM_IO::Simple_Queue | |
| CACE_SPIPE_Addr::SPIPE_Addr | Contains security attributes |
| ►Cstrbuf | |
| CACE_Str_Buf | Simple wrapper for STREAM pipes strbuf |
| ►CSTREAM | |
| CACE_IOStream< STREAM > | A template adapter for creating an iostream-like object using an ACE IPC Stream for the actual I/O. Iostreams use an underlying streambuf object for the IO interface. The iostream class and derivatives provide you with a host of convenient operators that access the streambuf |
| CACE_SOCK_Dgram_SC< STREAM > | "Dgram_SC" is short for "Datagram Self-Contained." |
| ►Cstreambuf | |
| ►CACE_Streambuf | Create your custom streambuf by providing and ACE_*_Stream object to this template. I have tested it with ACE_SOCK_Stream and it should work fine for others as well |
| CACE_Streambuf_T< STREAM > | |
| Ctimespec | |
| CACE_InputCDR::to_boolean | |
| CACE_InputCDR::to_char | |
| CACE_InputCDR::to_octet | |
| CACE_InputCDR::to_string | |
| CACE_Utils::To_Unsigned< T > | Retrieve unsigned counterpart to given type or value |
| CACE_Utils::To_Unsigned< signed char > | |
| CACE_Utils::To_Unsigned< signed int > | |
| CACE_Utils::To_Unsigned< signed long > | |
| CACE_Utils::To_Unsigned< signed long long > | |
| CACE_Utils::To_Unsigned< signed short > | |
| CACE_Utils::To_Unsigned< unsigned char > | |
| CACE_Utils::To_Unsigned< unsigned int > | |
| CACE_Utils::To_Unsigned< unsigned long > | |
| CACE_Utils::To_Unsigned< unsigned long long > | |
| CACE_Utils::To_Unsigned< unsigned short > | |
| CACE_InputCDR::to_wchar | |
| CACE_InputCDR::to_wstring | |
| CACE_Dev_Poll_Reactor::Token_Guard | A helper class that helps grabbing, releasing and waiting on tokens for a thread that needs access to the reactor's token |
| CACE_Token_Reply::Transfer | |
| CACE_Token_Request::Transfer | |
| CACE_Name_Reply::Transfer | |
| CACE_Name_Request::Transfer | |
| CACE_InputCDR::Transfer_Contents | |
| Ctruncate_cast | Helper function to truncate an integral value to the maximum value of the given type |
| CACE_Utils::Truncator< FROM, TO > | Truncate value of type FROM to value of type TO |
| CACE_Utils::Truncator< T, T > | |
| CTSS_Cleanup_Instance | |
| CACE_ODB::Tuple | |
| ►CTYPE | |
| CACE_DLL_Singleton_Adapter_T< TYPE > | |
| CACE_Utils::UUID | |
| CACE_Utils::UUID_Generator | |
| CACE_Utils::UUID_Node | Holds the MAC-address of the UUID |
| CACE_Utils::UUID_Generator::UUID_State | |
| CACE::Value_Ptr< T > | Smart pointer implementation designed for use as a class member |
| CACE::VP_traits< T > | Value_Ptr traits template structure |
| ►CACE_TOKEN_TYPE | |
| CACE_Reactor_Token_T< ACE_TOKEN_TYPE > | Used as a synchronization mechanism to coordinate concurrent access to an ACE_Reactor_Impl object |
1.8.9.1
