ACE  6.1.2
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 123456]
oC_dbghelp_functions
oC_WSANETWORKEVENTS
oCACE_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
|  oCACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET, TIME_POLICY >Provides a hash table of BUCKETs as an implementation for a timer queue
|  oCACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY >Provides a very fast and predictable timer implementation
|  oCACE_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
oCACE_Accept_QoS_ParamsWrapper class that simplifies the information passed to the QoS enabled <ACE_OS::accept> method
oCACE_Accept_Strategy< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >Defines the interface for specifying a passive connection acceptance strategy for a SVC_HANDLER
oCACE_Active_Map_Manager_KeyKey used in the Active Object Map
oCACE_AddrDefines the base class for the "address family independent" address format
|oCACE_ATM_AddrDefines the ATM domain address family address format
|oCACE_DEV_AddrDefines device address family address format
|oCACE_FILE_AddrDefines the FILE address family address format
|oCACE_INET_AddrDefines a C++ wrapper facade for the Internet domain address family format
||\CACE_Multihomed_INET_AddrExtends ACE_INET_Addr with support for multi-homed addresses
|oCACE_MEM_AddrDefines a C++ wrapper facade for the shared memory transport address family format
|oCACE_SPIPE_AddrDefines the SVR4 STREAM pipe address family address format
|\CACE_UNIX_AddrDefines the ``UNIX domain address family'' address format
oCACE_AllocatorInterface for a dynamic memory allocator that uses inheritance and dynamic binding to provide extensible mechanisms for allocating and deallocating memory
|oCACE_Allocator_Adapter< MALLOC >This class is an adapter that allows the ACE_Allocator to use the ACE_Malloc class below
|oCACE_New_AllocatorDefines a class that provided a simple implementation of memory allocation
||oCACE_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_BaseDefines 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
oCACE_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
oCACE_ARGV_Queue_Entry_T< CHAR_TYPE >An entry in the queue which keeps user supplied arguments
oCACE_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
oCACE_Argv_Type_ConverterTo convert 'char' input/command line parameter to 'wchar_t'
oCACE_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
oCACE_Array_Iterator< T >Implement an iterator over an ACE_Array
oCACE_Array_Map< Key, Value, EqualTo >Light weight array-based map with fast iteration, but linear (i.e. O(n)) search times
oCACE_Ascii_To_WideA lightweight char* to wchar* string conversion class
oCACE_Asynch_OperationThis 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
|oCACE_Asynch_AcceptThis class is a factory for starting off asynchronous accepts on a listen handle. This class forwards all methods to its implementation class
|oCACE_Asynch_ConnectThis class is a factory for starting off asynchronous connects This class forwards all methods to its implementation class
|oCACE_Asynch_Read_DgramThis class is a factory for starting off asynchronous reads on a UDP socket. This class forwards all methods to its implementation class
|oCACE_Asynch_Read_StreamThis class is a factory for starting off asynchronous reads on a stream. This class forwards all methods to its implementation class
||\CACE_Asynch_Read_FileThis class is a factory for starting off asynchronous reads on a file. This class forwards all methods to its implementation class
|oCACE_Asynch_Transmit_FileThis class is a factory for starting off asynchronous transmit files on a stream
|oCACE_Asynch_Write_DgramThis 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_StreamThis 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_FileThis class is a factory for starting off asynchronous writes on a file. This class forwards all methods to its implementation class
oCACE_Asynch_Operation_ImplAbstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Operation
|oCACE_Asynch_Accept_ImplAbstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Accept
||\CACE_POSIX_Asynch_AcceptFor the POSIX implementation this class is common for all Proactors (AIOCB/SIG/SUN)
|oCACE_Asynch_Connect_ImplAbstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Connect
||\CACE_POSIX_Asynch_Connect
|oCACE_Asynch_Read_Dgram_ImplAbstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Read_Dgram
||\CACE_POSIX_Asynch_Read_DgramThis class is a factory for starting off asynchronous reads on a UDP socket
|oCACE_Asynch_Read_Stream_ImplAbstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Read_Stream
||oCACE_Asynch_Read_File_ImplAbstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Read_File::Result
|||\CACE_POSIX_Asynch_Read_FileThis 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_FileThis 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
|oCACE_Asynch_Transmit_File_ImplAbstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Transmit_File
||\CACE_POSIX_Asynch_Transmit_FileImplementation for transmit_file will make use of POSIX_Asynch_Transmit_Handler
|oCACE_Asynch_Write_Dgram_ImplAbstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Write_Dgram class
||\CACE_POSIX_Asynch_Write_DgramThis 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
|oCACE_Asynch_Write_Stream_ImplAbstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Write_Stream class
||oCACE_Asynch_Write_File_ImplAbstract 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_StreamThis class implements <ACE_Asynch_Write_Stream> for all POSIX implementations of ACE_Proactor
|| \CACE_POSIX_Asynch_Write_File
|\CACE_POSIX_Asynch_OperationThis class implements ACE_Asynch_Operation for all implementations of Proactor (AIOCB, SIG, SUN) Specific future implementations can derive from this class
| oCACE_POSIX_Asynch_AcceptFor the POSIX implementation this class is common for all Proactors (AIOCB/SIG/SUN)
| oCACE_POSIX_Asynch_Connect
| oCACE_POSIX_Asynch_Read_DgramThis class is a factory for starting off asynchronous reads on a UDP socket
| oCACE_POSIX_Asynch_Read_Stream
| oCACE_POSIX_Asynch_Transmit_FileImplementation for transmit_file will make use of POSIX_Asynch_Transmit_Handler
| oCACE_POSIX_Asynch_Write_DgramThis 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_StreamThis class implements <ACE_Asynch_Write_Stream> for all POSIX implementations of ACE_Proactor
oCACE_Asynch_ResultAn interface base class which allows users access to common information related to an asynchronous operation
|oCACE_Asynch_Accept::ResultThis is that class which will be passed back to the {handler} when the asynchronous accept completes
|oCACE_Asynch_Connect::ResultThis is that class which will be passed back to the handler when the asynchronous connect completes
|oCACE_Asynch_Read_Dgram::ResultThis 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
|oCACE_Asynch_Read_Stream::ResultThis 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::ResultThis 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
|oCACE_Asynch_Transmit_File::ResultThis is that class which will be passed back to the {handler} when the asynchronous transmit file completes
|oCACE_Asynch_Write_Dgram::ResultThis 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::ResultThis 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::ResultThis 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
oCACE_Asynch_Result_ImplAbstract base class for the all the classes that provide concrete implementations for ACE_Asynch_Result
|oCACE_Asynch_Accept_Result_ImplAbstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Accept
||\CACE_POSIX_Asynch_Accept_ResultThis is that class which will be passed back to the handler when the asynchronous accept completes
|oCACE_Asynch_Connect_Result_ImplAbstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Connect
||\CACE_POSIX_Asynch_Connect_ResultThis is that class which will be passed back to the completion handler when the asynchronous connect completes
|oCACE_Asynch_Read_Dgram_Result_ImplAbstract 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_ResultThis is class provides concrete implementation for ACE_Asynch_Read_Dgram::Result class
|oCACE_Asynch_Read_Stream_Result_ImplAbstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Read_Stream::Result class
||oCACE_Asynch_Read_File_Result_ImplThis is the abstract base class for all the concrete implementation classes for ACE_Asynch_Read_File::Result
|||\CACE_POSIX_Asynch_Read_File_ResultThis class provides concrete implementation for <ACE_Asynch_Read_File::Result> class for POSIX platforms
||\CACE_POSIX_Asynch_Read_Stream_ResultThis class provides concrete implementation for <ACE_Asynch_Read_Stream::Result> class for POSIX platforms
|| \CACE_POSIX_Asynch_Read_File_ResultThis class provides concrete implementation for <ACE_Asynch_Read_File::Result> class for POSIX platforms
|oCACE_Asynch_Transmit_File_Result_ImplAbstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Transmit_File::Result
||\CACE_POSIX_Asynch_Transmit_File_ResultThis is that class which will be passed back to the <handler> when the asynchronous transmit file completes
|oCACE_Asynch_Write_Dgram_Result_ImplAbstract 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
|oCACE_Asynch_Write_Stream_Result_ImplAbstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Write_Stream::Result
||oCACE_Asynch_Write_File_Result_ImplThis 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_ResultThis class provides implementation for <ACE_Asynch_Write_File_Result> for POSIX platforms
||\CACE_POSIX_Asynch_Write_Stream_ResultThis class provides concrete implementation for <ACE_Asynch_Write_Stream::Result> on POSIX platforms
|| \CACE_POSIX_Asynch_Write_File_ResultThis class provides implementation for <ACE_Asynch_Write_File_Result> for POSIX platforms
|\CACE_POSIX_Asynch_Result
| oCACE_POSIX_Asynch_Accept_ResultThis is that class which will be passed back to the handler when the asynchronous accept completes
| oCACE_POSIX_Asynch_Connect_ResultThis is that class which will be passed back to the completion handler when the asynchronous connect completes
| oCACE_POSIX_Asynch_Read_Dgram_ResultThis is class provides concrete implementation for ACE_Asynch_Read_Dgram::Result class
| oCACE_POSIX_Asynch_Read_Stream_ResultThis class provides concrete implementation for <ACE_Asynch_Read_Stream::Result> class for POSIX platforms
| oCACE_POSIX_Asynch_TimerThis 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
| oCACE_POSIX_Asynch_Transmit_File_ResultThis is that class which will be passed back to the <handler> when the asynchronous transmit file completes
| oCACE_POSIX_Asynch_Write_Dgram_Result
| oCACE_POSIX_Asynch_Write_Stream_ResultThis class provides concrete implementation for <ACE_Asynch_Write_Stream::Result> on POSIX platforms
| \CACE_POSIX_Wakeup_Completion
oCACE_At_Thread_ExitContains a method to be applied when a thread is terminated
|\CACE_At_Thread_Exit_Func
oCACE_ATM_AcceptorDefines the member functions for ACE_ATM_Acceptor abstraction
oCACE_ATM_ConnectorDefines an active connection factory for the ACE_ATM C++ wrappers
oCACE_ATM_ParamsWrapper class that simplifies the information passed to the ATM enabled ACE_ATM_Connector class
oCACE_ATM_QoSDefine the QoS parameters for ATM
oCACE_ATM_StreamDefines the member functions for ACE_ATM_Stream abstraction
oCACE_Atomic_Op< ACE_LOCK, TYPE >Transparently parameterizes synchronization into basic arithmetic operations
oCACE_Atomic_Op< ACE_Null_Mutex, long >
oCACE_Atomic_Op< ACE_SYNCH_MUTEX, long >
oCACE_Atomic_Op_Ex< ACE_LOCK, TYPE >Transparently parameterizes synchronization into basic arithmetic operations
oCACE_Atomic_Op_Ex< ACE_Null_Mutex, long >
oCACE_Atomic_Op_Ex< ACE_SYNCH_MUTEX, long >
oCACE_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
oCACE_Auto_Basic_Ptr< X >Implements the draft C++ standard auto_ptr abstraction. This class allows one to work on non-object (basic) types
|oCACE_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
oCACE_Auto_String_FreeSimple class to automatically de-allocate strings
oCACE_bad_alloc_class
oCACE_BarrierImplements "barrier synchronization"
|\CACE_Thread_BarrierImplements "barrier synchronization" using ACE_Thread_Mutexes!
oCACE_Base64Encode/Decode a stream of bytes according to Base64 encoding
oCACE_Base_Thread_AdapterBase class for all the Thread_Adapters
|oCACE_OS_Thread_AdapterConverts 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_AdapterConverts 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
oCACE_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
oCACE_Based_Pointer_RepositoryMaps pointers to the base address of the region to which each pointer belongs
oCACE_Based_Pointer_Repository_RepImplementation for the ACE_Based_Pointer_Repository
oCACE_Basic_StatsCollect basic stats about a series of samples
|\CACE_Throughput_StatsA simple class to make throughput and latency analysis
oCACE_Bcast_NodeLinked list of broadcast interfaces
oCACE_Bound_Ptr_Counter< ACE_LOCK >An ACE_Bound_Ptr_Counter<ACE_LOCK> object encapsulates an object reference count
oCACE_Bounded_Set< T >Implement a simple unordered set of {T} with maximum set at creation time
oCACE_Bounded_Set_Iterator< T >Iterates through an unordered set
oCACE_Bounded_Stack< T >Implement a generic LIFO abstract data type
oCACE_Cache_Map_Iterator< KEY, VALUE, IMPLEMENTATION, CACHING_STRATEGY, ATTRIBUTES >Defines a iterator for the Cache_Map_Manager
oCACE_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
oCACE_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
oCACE_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 >
oCACE_Cache_Map_Reverse_Iterator< KEY, VALUE, REVERSE_IMPLEMENTATION, CACHING_STRATEGY, ATTRIBUTES >Defines a reverse iterator for the Cache_Map_Manager
oCACE_Cached_Mem_Pool_Node< T >ACE_Cached_Mem_Pool_Node keeps unused memory within a free list
oCACE_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
oCACE_CapabilitiesThis class implement the ACE Capabilities
oCACE_CapEntryThis class is the base class for all ACE Capabilities entry subclasses
|oCACE_BoolCapEntryThis class implement the ACE Bool Capability subclass
|oCACE_IntCapEntryThis class implement the ACE Integer Capability subclass
|\CACE_StringCapEntryThis class implement the ACE String Capability subclass
oCACE_CDRKeep constants and some routines common to both Output and Input CDR streams
oCACE_Char_Codeset_TranslatorCodeset translation routines common to both Output and Input CDR streams
oCACE_CleanupBase class for objects that are cleaned by ACE_Object_Manager
|oCACE_Cleanup_Adapter< TYPE >Adapter for ACE_Cleanup objects that allows them to be readily managed by the ACE_Object_Manager
|oCACE_Cleanup_Adapter< ACE_Log_Msg >
||\CACE_Msg_Log_Cleanup
|oCACE_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
|oCACE_Token_Invariant_ManagerToken Invariants
|oCACE_Token_ManagerManages 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
oCACE_Cleanup_Strategy< KEY, VALUE, CONTAINER >Defines a default strategy to be followed for cleaning up entries from a map which is the container
|oCACE_Handler_Cleanup_Strategy< KEY, VALUE, CONTAINER >Defines a strategy to be followed for cleaning up entries which are svc_handlers from a container
|oCACE_Null_Cleanup_Strategy< KEY, VALUE, CONTAINER >Defines a do-nothing implementation of the cleanup strategy
|oCACE_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
oCACE_Codeset_Registry
oCACE_Command_BaseDefines an abstract class that allows us to invoke commands without knowing anything about the implementation
|oCACE_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
|oCACE_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
oCACE_Concurrency_Strategy< SVC_HANDLER >Defines the interface for specifying a concurrency strategy for a SVC_HANDLER
|oCACE_NOOP_Concurrency_Strategy< SVC_HANDLER >Implements a no-op activation strategy in order to avoid calling open on a svc_handler multiple times
|oCACE_Process_Strategy< SVC_HANDLER >Defines the interface for specifying a concurrency strategy for a SVC_HANDLER based on multiprocessing
|oCACE_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
oCACE_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
oCACE_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_Recursive_Thread_Mutex
oCACE_Condition_Attributes
oCACE_Condition_Thread_MutexACE_Condition variable wrapper 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
oCACE_Config_ImpExp_BaseBase class for file import/export configuration
|oCACE_Ini_ImpExpImports 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_ImpExpConfiguration 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
oCACE_ConfigurationBase class for configuration databases
|oCACE_Configuration_HeapThe concrete implementation of a allocator based configuration database
|\CACE_Configuration_Win32RegistryThe win32 registry implementation of a configuration database
oCACE_Configuration_ExtIdExternal ID for the section and value hash
oCACE_Configuration_Section_IntIdThe internal ID for a section hash table
oCACE_Configuration_Section_KeyReference counted wrapper for ACE_Section_Key_Internal
oCACE_Configuration_Value_IntIdThe section hash table internal value class
oCACE_Connect_Strategy< SVC_HANDLER, ACE_PEER_CONNECTOR_1 >Defines the interface for specifying an active connection establishment strategy for a SVC_HANDLER
oCACE_Connect_Strategy< SVC_HANDLER, ACE_PEER_CONNECTOR_2 >
|oCACE_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 >
| oCACE_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
oCACE_Connection_Recycling_StrategyDefines the interface for a connection recycler
|oCACE_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 >
oCACE_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
|oCACE_Connector< SVC_HANDLER, ACE_PEER_CONNECTOR_1 >Generic factory for actively connecting clients and creating service handlers (SVC_HANDLERs)
|\CACE_Connector< SVC_HANDLER, ACE_PEER_CONNECTOR_2 >
| \CACE_Strategy_Connector< SVC_HANDLER, ACE_PEER_CONNECTOR_1 >Abstract factory for creating a service handler (SVC_HANDLER), connecting the SVC_HANDLER, and activating the SVC_HANDLER
oCACE_Control_BlockThis information is stored in memory allocated by the <Memory_Pool>
oCACE_Copy_DisabledHelper class to disable copy construction and assignment
|oCACE_Activation_QueueReifies a method into a request. Subclasses typically represent necessary state and behavior
|oCACE_Auto_IncDec< ACE_SAFELY_INCREMENTABLE_DECREMENTABLE >This class automatically increments and decrements a parameterized counter
|oCACE_Countdown_Time_T< TIME_POLICY >
|oCACE_Env_Value< T >Environment Variable Value
|oCACE_Event_Handler_Handle_Timeout_UpcallFunctor for Timer_Queues
|oCACE_Framework_ComponentBase 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
|oCACE_Framework_RepositoryContains all framework components used by an application
|oCACE_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
|oCACE_Handler_Caching_Utility< KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES >Defines a helper class for the Caching Strategies
|oCACE_Mem_MapC++ interface OS memory mapping system call
|oCACE_Notification_QueueImplements a user-space queue to send Reactor notifications
|oCACE_Null_Caching_Utility< KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES >Defines a dummy helper class for the Caching Strategies
|oCACE_OS_Log_Msg_AttributesThe attributes required by ACE_Log_Msg
|oCACE_Pair_Caching_Utility< KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES >Defines a helper class for the Caching Strategies
|oCACE_Recyclable_Handler_Caching_Utility< KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES >Defines a helper class for the Caching Strategies
|oCACE_Refcounted_Recyclable_Handler_Caching_Utility< KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES >Defines a helper class for the Caching Strategies
|oCACE_Service_GestaltSupplies common server operations for dynamic and static configuration of services
|oCACE_Task_Ex< ACE_SYNCH_DECL, ACE_MESSAGE_TYPE >Primary interface for application message processing, as well as input and output message queueing
|oCACE_Timer_Hash_Upcall< TYPE, FUNCTOR, ACE_LOCK >Functor for Timer_Hash
|oCACE_Timer_Queue_Upcall_Base< TYPE, FUNCTOR >
|oCACE_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_ConnectionClass for providing a connection per thread
oCACE_Countdown_TimeKeeps track of the amount of elapsed time
oCACE_Creation_Strategy< SVC_HANDLER >Defines the interface for specifying a creation strategy for a SVC_HANDLER
|oCACE_DLL_Strategy< SVC_HANDLER >Defines the interface for specifying a creation strategy for a SVC_HANDLER based on dynamic linking of the SVC_HANDLER
|oCACE_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)
oCACE_Data_BlockStores 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
oCACE_Date_TimeSystem independent representation of date and time
oCACE_Delegating_Time_PolicyImplement a time policy that delegates to a dynamic time policy
oCACE_DEV_ConnectorDefines an active connection factory for the ACE_DEV wrappers
oCACE_Dev_Poll_Handler_GuardClass used to make event handler reference count manipulation exception-safe
oCACE_DirentDefine a portable C++ directory-entry iterator based on the POSIX API
oCACE_Dirent_SelectorDefine a portable C++ directory-entry iterator based on the POSIX scandir API
oCACE_DLLProvides an abstract interface for handling various DLL operations
oCACE_DLL_HandleProvides an abstract interface for handling various DLL operations
oCACE_DLL_ManagerThis class is a singleton and serves as a factory and repository for instances of ACE_DLL_Handle
oCACE_DLL_Singleton_Adapter_T< TYPE >
oCACE_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
oCACE_DLList_NodeBase implementation of element in a DL list. Needed for ACE_Double_Linked_List
oCACE_DNode< T >Implementation element in a bilinked list
oCACE_Double_Linked_List< T >A double-linked list implementation
oCACE_Double_Linked_List< ACE_DLList_Node >
|\CACE_DLList< T >A double-linked list container class
oCACE_Double_Linked_List_Iterator_Base< T >Implements a common base class for iterators for a double linked list ADT
|oCACE_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_DLList_Reverse_Iterator< T >A double-linked list container class iterator
oCACE_Double_Linked_List_Iterator_Base< ACE_DLList_Node >
|oCACE_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 >
oCACE_DumpableBase 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>="">
oCACE_Dumpable_PtrA smart pointer stored in the in-memory object database ACE_ODB. The pointee (if any) is deleted when reassigned
oCACE_DynamicChecks to see if an object was dynamically allocated
oCACE_Dynamic_Message_StrategyAn 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
|oCACE_Deadline_Message_StrategyDeadline based message priority strategy
|\CACE_Laxity_Message_StrategyLaxity based message priority strategy
oCACE_Dynamic_Service_BaseBase class for all ACE_Dynamic_Service instantiations
|\CACE_Dynamic_Service< TYPE >Provides a general interface to retrieve arbitrary objects from the ACE service repository
oCACE_Dynamic_Service_DependencyProvides 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
oCACE_Dynamic_Time_Policy_Base
|oCACE_Delegating_Time_Policy::NULL_Time_Policy
|\CACE_Time_Policy_T< TIME_POLICY >Template class implementing a dynamic time policy based on another time policy
oCACE_Dynamic_Time_Policy_baseAbstract base class for dynamically loaded and/or shared time policies
oCACE_EH_Dispatch_InfoThis structure contains information of the activated event handler
oCACE_Profile_Timer::ACE_Elapsed_TimeKeeps track of the various user, system, and elapsed (real) times
oCACE_Equal_To< TYPE >Function object for comparing two objects of the given type for equality
oCACE_Equal_To< ACE_CString >Function object for determining whether two ACE_CStrings are equal
oCACE_Equal_To< ACE_INT16 >Function object for determining whether two 16 bit ints are equal
oCACE_Equal_To< ACE_INT32 >Function object for determining whether two 32 bit ints are equal
oCACE_Equal_To< ACE_UINT16 >Function object for determining whether two unsigned 16 bit ints are equal
oCACE_Equal_To< ACE_UINT32 >Function object for determining whether two unsigned 32 bit ints are equal
oCACE_Equal_To< ACE_UINT64 >Function object for determining whether two unsigned 64 bit ints are equal
oCACE_Equal_To< char * >Function object for determining whether two non-const strings are equal
oCACE_Equal_To< const char * >Function object for determining whether two const strings are equal
oCACE_Equal_To< const wchar_t * >Function object for determining whether two const strings are equal
oCACE_Equal_To< EXT_ID >
oCACE_Equal_To< REFCOUNTED_HASH_RECYCLABLE_ADDRESS >
oCACE_Equal_To< std::string >Function object for determining whether two std::strings are equal
oCACE_Equal_To< wchar_t * >Function object for determining whether two non-const strings are equal
oCACE_Errno_GuardProvides a wrapper to improve performance when thread-specific errno must be saved and restored in a block of code
oCACE_EventA wrapper around the Win32 event locking mechanism
|oCACE_Auto_EventAuto Events
|\CACE_Manual_EventManual Events
oCACE_Event_HandlerProvides an abstract interface for handling various types of I/O, timer, and signal events
|oCACE::Monitor_Control::Monitor_Point_Auto_UpdaterAutomates periodic updating of monitor point classes
|oCACE_Async_Timer_Queue_Adapter< TQ, TYPE >Adapts an ACE timer queue to be driven asynchronously using signals
|oCACE_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
|oCACE_MMAP_Memory_PoolMake a memory pool that is based on mmap(2). This implementation allows memory to be shared between processes
||\CACE_Lite_MMAP_Memory_PoolMake a ``lighter-weight'' memory pool based ACE_Mem_Map
|oCACE_Name_ProxyProxy for dealing with remote server process managing NET_LOCAL NameBindings
|oCACE_NonBlocking_Connect_Handler< SVC_HANDLER >Performs non-blocking connects on behalf of the Connector
|oCACE_POSIX_Asynch_AcceptFor the POSIX implementation this class is common for all Proactors (AIOCB/SIG/SUN)
|oCACE_POSIX_Asynch_Connect
|oCACE_Proactor_ImplA manager for asynchronous event demultiplexing. This class is the base class for all the concrete implementation classes
||oCACE_POSIX_ProactorPOSIX implementation of the Proactor
|||\CACE_POSIX_AIOCB_ProactorThis Proactor makes use of Asynchronous I/O Control Blocks (AIOCB) to notify/get the completion status of the <aio_> operations issued
||| \CACE_POSIX_CB_ProactorImplementation of Callback-based Proactor };
||\CACE_WIN32_ProactorA manager for asynchronous event demultiplexing on Win32
|oCACE_Process_ManagerManages a group of processes
|oCACE_Reactor_NotifyAbstract class for unblocking an ACE_Reactor_Impl from its event loop
||oCACE_Dev_Poll_Reactor_NotifyEvent handler used for unblocking the ACE_Dev_Poll_Reactor from its event loop
||oCACE_Select_Reactor_NotifyUnblock the ACE_Select_Reactor from its event loop
||\CACE_WFMO_Reactor_NotifyUnblock the <ACE_WFMO_Reactor> from its event loop, passing it an optional ACE_Event_Handler to dispatch
|oCACE_Service_ObjectProvide the abstract base class common to all service implementations
||oCACE::Monitor_Control::Monitor_Admin_ManagerRepsonsible for creating and destroying the global (per process) instance of the Admin class
||oCACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >Abstract factory for creating a service handler (SVC_HANDLER), accepting into the SVC_HANDLER, and activating the SVC_HANDLER
||oCACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >
|||\CACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >Abstract factory for creating a service handler (SVC_HANDLER), accepting into the SVC_HANDLER, and activating the SVC_HANDLER
||oCACE_Connector< SVC_HANDLER, ACE_PEER_CONNECTOR_1 >Generic factory for actively connecting clients and creating service handlers (SVC_HANDLERs)
||oCACE_Connector< SVC_HANDLER, ACE_PEER_CONNECTOR_2 >
||oCACE_Logging_StrategyThis 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
||oCACE_Naming_ContextMaintaining accesses Name Server Databases. Allows to add NameBindings, change them, remove them and resolve NameBindings
||oCACE_Oneshot_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >Generic factory for passively connecting clients and creating exactly one service handler of the type SVC_HANDLER specified in the template
||oCACE_Service_ManagerProvide a standard ACE service for managing all the services configured in an ACE_Service_Repository
||\CACE_Task_BaseDirect base class for the ACE_Task template
|| oCACE_Task< ACE_SYNCH_DECL >Primary interface for application message processing, as well as input and output message queueing
|| oCACE_Task< ACE_MT_SYNCH >
|| |\CACE_NT_ServiceProvide the base class which defines the interface for controlling an NT service
|| oCACE_Task< ACE_NULL_SYNCH >
|| |oCACE_Asynch_Pseudo_Task
|| |\CACE_Proactor_Timer_HandlerA Handler for timer. It helps in the management of timers registered with the Proactor
|| oCACE_Task< ACE_SYNCH_USE >
|| |oCACE_Svc_Handler< ACE_PEER_STREAM_1, ACE_SYNCH_DECL >Defines the interface for a service that exchanges data with its connected peer
|| |\CACE_Svc_Handler< ACE_PEER_STREAM_2, ACE_SYNCH_USE >
|| | \CACE_Buffered_Svc_Handler< ACE_PEER_STREAM_1, ACE_SYNCH_DECL >Defines the interface for a service that exchanges data with its connected peer and supports buffering
|| oCACE_Task_Ex< ACE_SYNCH_DECL, ACE_MESSAGE_TYPE >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
|oCACE_Shared_Memory_PoolMake 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
|oCACE_Sig_AdapterProvide an adapter that transforms various types of signal handlers into the scheme used by the ACE_Reactor
|oCACE_Test_and_Set< ACE_LOCK, TYPE >Implements the classic ``test and set'' operation
|\CACE_Wakeup_All_Threads_HandlerThis is a helper class whose sole purpose is to handle events on <ACE_WFMO_Reactor->wakeup_all_threads_>
oCACE_Event_Handler_varAuto pointer like class for Event Handlers
oCACE_Event_TupleAn ACE_Event_Handler and its associated ACE_HANDLE
oCACE_FIFO_Caching_Strategy< ATTRIBUTES, CACHING_UTILITY >The First In First Out strategy is implemented wherein each item is ordered
oCACE_FILE_ConnectorDefines an active connection factory for the ACE_FILE wrappers
oCACE_FILE_InfoAbstracts basic OS FILE information
oCACE_File_LockA wrapper around the UNIX file locking mechanism
oCACE_FilecacheA 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
oCACE_Filecache_HandleAbstraction over a real file. This is meant to be the entry point into the Cached Virtual Filesystem
oCACE_Filecache_ObjectAbstraction 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
oCACE_Fixed_Set< T, ACE_SIZE >Implement a simple unordered set of {T} with maximum {ACE_SIZE}
oCACE_Fixed_Set_Iterator_Base< T, ACE_SIZE >Implements a common base class for iterators for a unordered set
|oCACE_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
oCACE_Fixed_Stack< T, ACE_SIZE >Implement a generic LIFO abstract data type
oCACE_OS::ace_flock_tOS file locking structure
oCACE_Flow_SpecWrapper class that defines the flow spec QoS information, which is used by IntServ (RSVP) and DiffServ
oCACE_FPointer_Time_Policy
oCACE_FPointer_Timer_PolicyImplement a time policy based on a function pointer
oCACE_Free_List< T >Implements a free list
|\CACE_Locked_Free_List< T, ACE_LOCK >Implements a free list
oCACE_Future< T >This class implements a ``single write, multiple read'' pattern that can be used to return results from asynchronous method invocations
oCACE_Future_Holder< T >Implementation of object that holds an ACE_Future
oCACE_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
oCACE_Future_Rep< T >ACE_Future_Rep<T>
oCACE_Get_OptIterator for parsing command-line arguments
oCACE_Get_Opt::ACE_Get_Opt_Long_Option
oCACE_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
|oCACE_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)
oCACE_Guard< ACE_Null_Mutex >Template specialization of ACE_Guard for the ACE_Null_Mutex
|oCACE_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
oCACE_Handle_GobblerThis class gobbles up handles
oCACE_Handle_SetC++ wrapper facade for the socket fd_set abstraction
oCACE_Handle_Set_IteratorIterator for the ACE_Handle_Set abstraction
oCACE_HandlerThis base class defines the interface for receiving the results of asynchronous operations
|oCACE_AIOCB_Notify_Pipe_ManagerThis class manages the notify pipe of the AIOCB Proactor
|oCACE_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
|oCACE_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
|oCACE_POSIX_Asynch_Transmit_HandlerAuxillary handler for doing <Asynch_Transmit_File> in Unix. <ACE_POSIX_Asynch_Transmit_File> internally uses this
|\CACE_Service_HandlerThis base class defines the interface for the ACE_Asynch_Acceptor to call into when new connection are accepted
oCACE_Hash< TYPE >Function object for hashing
oCACE_Hash< ACE_CString >Function object for hashing a ACE_CString
oCACE_Hash< ACE_INT64 >Function object for hashing a signed 64-bit number
oCACE_Hash< ACE_UINT64 >Function object for hashing an unsigned 64-bit number
oCACE_Hash< char * >Function object for hashing a string
oCACE_Hash< char >Function object for hashing a char
oCACE_Hash< const char * >Function object for hashing a const string
oCACE_Hash< const wchar_t * >Function object for hashing a const string
oCACE_Hash< EXT_ID >
oCACE_Hash< int >Function object for hashing an int number
oCACE_Hash< long >Function object for hashing a long number
oCACE_Hash< REFCOUNTED_HASH_RECYCLABLE_ADDRESS >
oCACE_Hash< short >Function object for hashing a short number
oCACE_Hash< signed char >Function object for hashing a signed char
oCACE_Hash< std::string >Function object for hashing a std::string
oCACE_Hash< unsigned char >Function object for hashing an unsigned char
oCACE_Hash< unsigned int >Function object for hashing an unsigned int number
oCACE_Hash< unsigned long >Function object for hashing an unsigned long number
oCACE_Hash< unsigned short >Function object for hashing an unsigned short number
oCACE_Hash< void * >Function object for hashing a void *
oCACE_Hash< wchar_t * >Function object for hashing a string
oCACE_Hash< wchar_t >Function object for hashing a wchar_t
oCACE_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
oCACE_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
|oCACE_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
oCACE_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
oCACE_Hash_Map_Entry< EXT_ID, INT_ID >Define an entry in the hash table
oCACE_Hash_Map_Entry< KEY, std::pair< VALUE, ATTRIBUTES > >
oCACE_Hash_Map_Entry< REFCOUNTED_HASH_RECYCLABLE_ADDRESS, std::pair< SVC_HANDLER *, ATTRIBUTES > >
oCACE_Hash_Map_Entry< REFCOUNTED_HASH_RECYCLABLE_ADDRESS, SVC_HANDLER * >
oCACE_Hash_Map_Iterator_Base_Ex< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK >Base iterator for the ACE_Hash_Map_Manager_Ex
|oCACE_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
oCACE_Hash_Map_Iterator_Base_Ex< EXT_ID, INT_ID, ACE_Hash< EXT_ID >, ACE_Equal_To< EXT_ID >, ACE_LOCK >
|oCACE_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
oCACE_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
oCACE_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
oCACE_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
oCACE_Hash_Map_Manager_Ex< KEY, std::pair< VALUE, ATTRIBUTES >, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex >
oCACE_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 >
oCACE_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 >
oCACE_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
oCACE_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
oCACE_Hash_Multi_Map_Entry< EXT_ID, INT_ID >Define an entry in the hash table
oCACE_Hash_Multi_Map_Iterator_Base< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK >Base iterator for the ACE_Hash_Multi_Map_Manager
|oCACE_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
oCACE_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
oCACE_HashableACE_Hashable
|\CACE_Refcounted_Hash_Recyclable< T >
oCACE_High_Res_TimerA high resolution timer class wrapper that encapsulates OS-specific high-resolution timers, such as those found on Solaris, AIX, Win32/Pentium, and VxWorks
oCACE_HR_Time_PolicyImplement a time policy based on the ACE Highres timer
oCACE_Incremental_Key_Generator< T >Defines a simple incremental key generator
oCACE_InputCDRA CDR stream for demarshalling CDR-encoded data
oCACE_Intrusive_Auto_Ptr< X >This class implements support for a reference counted auto_ptr. It assumes reference counting abilities of the parameterizing class
oCACE_Intrusive_List< T >Implement an intrusive double linked list
oCACE_Intrusive_List_Node< T >Implement the requirements for ACE_Intrusive_List
oCACE_Intrusive_List_Node< ACE_Cleanup_Info_Node >
|\CACE_Cleanup_Info_NodeFor maintaining a list of ACE_Cleanup_Info items
oCACE_Intrusive_List_Node< ACE_Notification_Queue_Node >
|\CACE_Notification_Queue_NodeHelper class
oCACE_IO_Cntl_MsgData format for IOCTL messages
oCACE_IO_SAPDefines the methods for the base class of the ACE_IO_SAP abstraction, which includes ACE_FILE and ACE_DEV
|oCACE_DEVDefines the member functions for the base class of the ACE_DEV abstraction
||\CACE_DEV_IORead/Write operations on Devices
|| \CACE_TTY_IOClass definitions for platform specific TTY features
|\CACE_FILEDefines the core methods of the ACE_FILE abstraction
| \CACE_FILE_IORead/Write operations on Files
oCACE_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
oCACE_IPC_SAPDefines the member functions for the base class of the ACE_IPC_SAP abstraction
|oCACE_FIFOAbstract base class for UNIX FIFOs
||oCACE_FIFO_RecvReceiver side of the bytestream C++ wrapper for UNIX FIFOs
|||\CACE_FIFO_Recv_MsgReceiver side for the record oriented C++ wrapper for UNIX FIFOs
||\CACE_FIFO_SendSender side for the bytestream C++ wrapper for UNIX FIFOs
|| \CACE_FIFO_Send_MsgSender side for the Record oriented C++ wrapper for UNIX FIFOs
|oCACE_SOCKAn abstract class that forms the basis for more specific classes, such as ACE_SOCK_Acceptor and ACE_SOCK_Stream. Do not instantiate this class
||oCACE_ICMP_SocketAn abstract class that forms the basis for usage of the ICMP protocol (that is, support for things such as ping)
|||\CACE_Ping_SocketThis 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
||oCACE_MEM_IODefines 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_StreamDefines the methods in the ACE_MEM_Stream abstraction
||oCACE_SOCK_AcceptorDefines a factory that creates new ACE_Streams passively
|||oCACE_LOCK_SOCK_Acceptor< ACE_LOCK >Specialize ACE_SOCK_Acceptor to lock around <accept>;
|||oCACE_LSOCK_AcceptorDefines the format and interface for the acceptor side of the local ACE_SOCK ACE_Stream
|||\CACE_MEM_AcceptorDefines the format and interface for the acceptor side of the local mmap stream
||oCACE_SOCK_DgramDefines the member functions for the ACE_SOCK datagram abstraction
|||oCACE_LSOCK_DgramCreate a Local ACE_SOCK datagram
|||oCACE_SOCK_Dgram_BcastDefines the member functions for the ACE_SOCK datagram abstraction
|||\CACE_SOCK_Dgram_McastDefines the ACE socket wrapper for UDP/IP multicast
||oCACE_SOCK_IODefines the methods for the ACE socket wrapper I/O routines (e.g., send/recv)
|||oCACE_SOCK_CODgramDefines the member functions for the ACE_SOCK connected datagram abstraction
||||\CACE_LSOCK_CODgramDefines a fully specified (sometimes called "connected") UNIX-domain datagram abstraction
|||oCACE_SOCK_SEQPACK_AssociationDefines the methods in the ACE_SOCK_SEQPACK_Association abstraction
|||\CACE_SOCK_StreamDefines the methods in the ACE_SOCK_Stream abstraction
||| \CACE_LSOCK_StreamCreate a Local ACE_SOCK stream
||\CACE_SOCK_SEQPACK_AcceptorDefines a factory that creates new ACE_Associations passively
|oCACE_SPIPEDefines the member functions for the base class of the ACE_SPIPE abstraction
||oCACE_SPIPE_AcceptorA factory class that produces ACE_SPIPE_Stream objects
|||\CACE_UPIPE_AcceptorDefines the format and interface for the listener side of the ACE_UPIPE_Stream
||oCACE_SPIPE_StreamDefines the methods in the ACE_SPIPE_Stream abstraction
||\CACE_UPIPE_StreamDefines the method that transfer data on a UPIPE
|\CACE_TLIDefines the member functions for the base class of the ACE_TLI abstraction
| oCACE_TLI_AcceptorDefines the member functions for ACE_TLI_Acceptor abstraction
| \CACE_TLI_StreamDefines the member functions for ACE_TLI_Stream abstraction
oCACE_Iterator< T >Defines the iterator interface
oCACE_Iterator_Impl< T >Defines a abstract iterator
|oCACE_Active_Map_Manager_Iterator_Adapter< T, VALUE >Defines a iterator implementation for the Active_Map_Manager_Adapter
|oCACE_Hash_Map_Manager_Ex_Iterator_Adapter< T, KEY, VALUE, HASH_KEY, COMPARE_KEYS >Defines a iterator implementation for the Hash_Map_Manager_Adapter
|oCACE_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
oCACE_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
oCACE_Less_Than< ACE_CString >Function object for determining whether the first const string is less than the second const string
oCACE_Less_Than< char * >Function object for determining whether the first string is less than the second string
oCACE_Less_Than< const char * >Function object for determining whether the first const string is less than the second const string
oCACE_Less_Than< const wchar_t * >Function object for determining whether the first const string is less than the second const string
oCACE_Less_Than< std::string >Function object for determining whether the first const string is less than the second const string
oCACE_Less_Than< wchar_t * >Function object for determining whether the first string is less than the second string
oCACE_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
oCACE_Local_Memory_PoolMake 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..
oCACE_Local_Memory_Pool_OptionsHelper class for Local Memory Pool constructor options
oCACE_LockThis is the abstract base class that contains the uniform locking API that is supported by all the ACE synchronization mechanisms
|oCACE_Adaptive_LockAn adaptive general locking class that defers the decision of lock type to run time
|oCACE_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_Reverse_Lock< ACE_LOCKING_MECHANISM >A reverse (or anti) lock
oCACE_Log_MsgProvides a variable length argument message logging abstraction
oCACE_Log_Msg_BackendDefines the interface for ACE_Log_Msg back end processing
|oCACE_Log_Msg_IPCDefines the interfaces for ACE_Log_Msg backend
|oCACE_Log_Msg_NT_Event_LogImplements an ACE_Log_Msg_Backend that logs to the WinNT system event log
|\CACE_Log_Msg_UNIX_SyslogImplements an ACE_Log_Msg_Backend that logs messages to a UNIX system's syslog facility
oCACE_Log_Msg_CallbackAn interface class used to get logging callbacks
oCACE_Log_Msg_ManagerSynchronize output operations
oCACE_Log_RecordDefines the structure of an ACE logging record
oCACE_LRU_Caching_Strategy< ATTRIBUTES, CACHING_UTILITY >Defines a Least Recently Used strategy which will decide on the item to be removed from the cache
oCACE_LSOCKCreate a Local ACE_SOCK, which is used for passing file descriptors
|oCACE_LSOCK_CODgramDefines a fully specified (sometimes called "connected") UNIX-domain datagram abstraction
|oCACE_LSOCK_DgramCreate a Local ACE_SOCK datagram
|\CACE_LSOCK_StreamCreate a Local ACE_SOCK stream
oCACE_Malloc_FIFO_Iterator_T< ACE_MEM_POOL_1, ACE_LOCK, ACE_CB >FIFO iterator for names stored in Malloc'd memory
oCACE_Malloc_FIFO_Iterator_T< ACE_MEM_POOL_2, ACE_LOCK, ACE_Control_Block >
|\CACE_Malloc_FIFO_Iterator< ACE_MEM_POOL_1, ACE_LOCK >
oCACE_PI_Control_Block::ACE_Malloc_HeaderThis 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
oCACE_Control_Block::ACE_Malloc_HeaderThis 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
oCACE_Malloc_LIFO_Iterator_T< ACE_MEM_POOL_1, ACE_LOCK, ACE_CB >LIFO iterator for names stored in Malloc'd memory
oCACE_Malloc_LIFO_Iterator_T< ACE_MEM_POOL_2, ACE_LOCK, ACE_Control_Block >
|\CACE_Malloc_LIFO_Iterator< ACE_MEM_POOL_1, ACE_LOCK >
oCACE_Malloc_Lock_Adapter_T< ACE_LOCK >Template functor adapter for lock strategies used with ACE_Malloc_T
oCACE_Malloc_Lock_Adapter_T< ACE_Null_Mutex >Template specialization of ACE_Malloc_Lock_Adapter_T for the ACE_Null_Mutex
oCACE_Malloc_Lock_Adapter_T< ACE_Process_Semaphore >Template specialization of ACE_Malloc_Lock_Adapter_T for ACE_Process_Semaphore
oCACE_Malloc_Lock_Adapter_T< ACE_Thread_Semaphore >Template specialization of ACE_Malloc_Lock_Adapter_T for ACE_Thread_Semaphore
oCACE_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
oCACE_Malloc_T< ACE_MEM_POOL_2, ACE_LOCK, ACE_Control_Block >
|\CACE_Malloc< ACE_MEM_POOL_1, ACE_LOCK >
oCACE_Managed_Object< TYPE >Wrapper for interface to allocate an object managed by the ACE_Object_Manager
oCACE_Map< KEY, VALUE >Defines a map interface
|oCACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >Defines a map implementation
|oCACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >Defines a map implementation
|oCACE_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
oCACE_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
oCACE_Map_Entry< EXT_ID, INT_ID >An entry in the Map
oCACE_Map_Entry< ACE_Active_Map_Manager_Key, T >
oCACE_Map_Iterator_Base< EXT_ID, INT_ID, ACE_LOCK >Iterator for the ACE_Map_Manager
|oCACE_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
oCACE_Map_Manager< EXT_ID, INT_ID, ACE_LOCK >Define a map abstraction that associates EXT_IDs with INT_IDs
oCACE_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
oCACE_max_align_info
oCACE_MEM_SAPDefines the methods of shared memory management for shared memory transport
|oCACE_MT_MEM_IO
|\CACE_Reactive_MEM_IO
oCACE_MEM_SAP_Node
oCACE_Message_BlockStores messages for use throughout ACE (particularly in an ACE_Message_Queue)
oCACE_Message_Queue_BaseBase class for ACE_Message_Queue, which is the central queueing facility for messages in the ACE framework
|oCACE_Message_Queue< ACE_SYNCH_DECL >A message queueing facility with parameterized synchronization capability. ACE_Message_Queue is modeled after the queueing facilities in System V STREAMs
|oCACE_Message_Queue< ACE_SYNCH_USE >
||\CACE_Dynamic_Message_Queue< ACE_SYNCH_DECL >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_NTMessage Queue implementation using IO completion port on NT
oCACE_Message_Queue_Ex< ACE_MESSAGE_TYPE, ACE_SYNCH_DECL >A threaded message queueing facility, modeled after the queueing facilities in System V STREAMs
oCACE_Message_Queue_Ex< ACE_MESSAGE_TYPE, ACE_SYNCH_USE >
|\CACE_Message_Queue_Ex_N< ACE_MESSAGE_TYPE, ACE_SYNCH_DECL >A threaded message queueing facility, modeled after the queueing facilities in System V STREAMs which can enqueue multiple messages in one call
oCACE_Message_Queue_Ex_Iterator< ACE_MESSAGE_TYPE, ACE_SYNCH_DECL >Iterator for the ACE_Message_Queue_Ex
oCACE_Message_Queue_Ex_Reverse_Iterator< ACE_MESSAGE_TYPE, ACE_SYNCH_DECL >
oCACE_Message_Queue_Factory< ACE_SYNCH_DECL >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)
oCACE_Message_Queue_Iterator< ACE_SYNCH_DECL >Iterator for the ACE_Message_Queue
oCACE_Message_Queue_Reverse_Iterator< ACE_SYNCH_DECL >Reverse Iterator for the ACE_Message_Queue
oCACE_Method_RequestReifies a method into a request. Subclasses must provide the necessary state and behavior
oCACE_MMAP_Memory_Pool_OptionsHelper class for MMAP Memory Pool constructor options
oCACE_Module_BaseWorkaround HP/C++ compiler bug with enums in templates
|oCACE_Module< ACE_SYNCH_DECL >An abstraction for managing a bi-directional flow of messages
|\CACE_Module< ACE_SYNCH_USE >
oCACE_MT_SYNCHImplement a default thread safe synchronization wrapper that typedefs the ACE_Condition and ACE_Mutex to the ACE_Condition and ACE_Mutex versions
oCACE_MutexACE_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
oCACE_Mutex_InvariantsMutex Invariants = INVARIANTS
oCACE_Name_BindingMaintains a mapping from name to value and type
oCACE_PI_Control_Block::ACE_Name_NodeThis class supports "named memory regions" within ACE_Malloc
oCACE_Control_Block::ACE_Name_NodeThis class supports "named memory regions" within ACE_Malloc
oCACE_Name_OptionsManages the options for the ACE Name_Server
oCACE_Name_ReplyMessage format for delivering replies from the ACE_Name Server
oCACE_Name_RequestMessage format for delivering requests to the ACE_Name Server
oCACE_Name_SpaceAbstract base class that provides an abstract interface to the database without exposing any implemenation details
|oCACE_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_SpaceMaintaining accesses Remote Name Server Database. Allows to add NameBindings, change them, remove them and resolve NameBindings
oCACE_Node< T, C >Implementation element in a Queue, Set, and Stack
oCACE_Node< T, ACE_Unbounded_Set_Default_Comparator< T > >
oCACE_Noop_Key_Generator< T >Defines a noop key generator
oCACE_Notification_BufferSimple wrapper for passing <ACE_Event_Handler *>s and ACE_Reactor_Masks between threads
oCACE_Notification_StrategyAbstract class used for notifying an interested party
|\CACE_Reactor_Notification_StrategyUsed to notify an ACE_Reactor
oCACE_NS_InternalThis class and ACE_NS_String are used as Adapters to work with the Map_Manager
oCACE_NS_StringThis class and ACE_NS_Internal are used as Adapters to work with the Map_Manager
oCACE_Null_BarrierImplements "NULL barrier synchronization"
oCACE_Null_Caching_Strategy< ATTRIBUTES, CACHING_UTILITY >The is a special caching strategy which doesnt have the purging feature
oCACE_Null_ConditionImplement a do nothing ACE_Condition variable wrapper, i.e., all methods are no ops. This class is necessary since some C++ compilers are very lame..
oCACE_Null_MutexImplement a do nothing ACE_Mutex, i.e., all the methods are no ops
|\CACE_Noop_Token
oCACE_Null_SemaphoreImplement a do nothing ACE_Semaphore, i.e., all the methods are no ops
oCACE_NULL_SYNCHImplement a do nothing Synchronization wrapper that typedefs the ACE_Condition and ACE_Mutex to the Null* versions
oCACE_Numeric_Limits< T >
oCACE_ObchunkDefines 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
oCACE_Object_Manager_BaseBase class for ACE_Object_Manager(s)
|oCACE_Object_ManagerManager for ACE library services and singleton cleanup
|\CACE_OS_Object_Manager
oCACE_Object_Manager_ManagerEnsure that the ACE_Object_Manager gets initialized at program startup, and destroyed at program termination
oCACE_Object_Manager_PreallocationsPerforms preallocations of certain statically allocated services needed by ACE
oCACE_Obstack_T< ACE_CHAR_T >Define a simple "mark and release" memory allocation utility
oCACE_ODBThis is the object database (ODB) that keeps track of all live ACE objects
oCACE_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
oCACE_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
oCACE_OS_Exit_InfoHold Object Manager cleanup (exit) information
oCACE_OS_Object_Manager_ManagerEnsure that the ACE_OS_Object_Manager gets initialized at program startup, and destroyed at program termination
oCACE_OS_Thread_DescriptorParent class of all ACE_Thread_Descriptor classes
|\CACE_Thread_Descriptor_BaseBasic information for thread descriptors. These information gets extracted out because we need it after a thread is terminated
| \CACE_Thread_DescriptorInformation for controlling threads that run under the control of the <Thread_Manager>
oCACE_OutputCDRA CDR stream for marshalling data, most often for transmission to another system which may or may not have the same byte order
oCACE_Pagefile_Memory_PoolMake a memory pool that is based on "anonymous" memory regions allocated from the Win32 page file
oCACE_Pagefile_Memory_Pool_OptionsHelper class for Pagefile Memory Pool constructor options
oCACE_PI_Control_BlockThis information is stored in memory allocated by the Memory_Pool
oCACE_PipeProvides a portable bidirectional "pipe" abstraction
oCACE_Pointer_Hash< TYPE >Function object for hashing pointers
oCACE_POSIX__Asynch_Write_Dgram_ResultThis is class provides concrete implementation for ACE_Asynch_Write_Dgram::Result class
oCACE_Predefined_Naming_ContextsA factory for predefined registries, which exist by default on Win32 platforms
oCACE_Priority_ReactorImplements priority based dispatching
oCACE_ProactorA manager for asynchronous event demultiplexing
oCACE_Proactor_Handle_Timeout_UpcallFunctor for ACE_Timer_Queue
oCACE_ProcessProcess
|\CACE_Managed_ProcessA process easily managed by ACE_Process_Manager
oCACE_Process_MutexA wrapper for mutexes that can be used across processes on the same host machine, as well as within a process, of course
oCACE_Process_OptionsProcess Options
oCACE_Process_SemaphoreWrapper for Dijkstra style general semaphores that work across processes
oCACE_Profile_TimerThis class provides both a timing mechanism and a mechanism for reporting the resource usage of a process
oCACE_Protocol_Info
oCACE_QoSWrapper class that holds the sender and receiver flow spec information, which is used by IntServ (RSVP) and DiffServ
oCACE_QoS_ParamsWrapper class that simplifies the information passed to the QoS enabled <ACE_OS::connect> and <ACE_OS::join_leaf> methods
oCACE_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
oCACE_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
|oCACE_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
oCACE_RB_Tree_Node_Base
|\CACE_RB_Tree_Node< EXT_ID, INT_ID >Implements a node in a Red-Black Tree ADT
oCACE_Reactor_ImplAn abstract class for implementing the Reactor Pattern
|oCACE_Dev_Poll_ReactorA `/dev/poll' or `/dev/epoll' based Reactor implemenatation
|oCACE_Select_Reactor_ImplThis 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_WFMO_ReactorAn 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_ReactorAn OO event demultiplexor and event handler dispatcher for Win32 <MsgWaitForMultipleObjects>
oCACE_Reactor_Timer_InterfaceInterface for timer related methods on the Reactor
|\CACE_ReactorThis class forwards all methods to its delegation/implementation class, e.g., ACE_Select_Reactor or ACE_WFMO_Reactor
oCACE_Reactor_Token_T< ACE_TOKEN_TYPE >Used as a synchronization mechanism to coordinate concurrent access to an ACE_Reactor_Impl object
oCACE_Read_BufferEfficiently 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
oCACE_recursive_mutex_state
oCACE_Recursive_Thread_MutexImplement a C++ wrapper that allows nested acquisition and release of a mutex that occurs in the same thread
oCACE_recursive_thread_mutex_tImplement a thin C++ wrapper that allows nested acquisition and release of a mutex that occurs in the same thread
oCACE_Recyclable
|\CACE_Refcounted_Hash_Recyclable< T >
oCACE_Recycling_Strategy< SVC_HANDLER >Defines the interface (and default implementation) for specifying a recycling strategy for a SVC_HANDLER
oCACE_Refcountable_T< ACE_LOCK >
oCACE_Refcountable_T< ACE_Null_Mutex >
|\CACE_Refcounted_Hash_Recyclable< T >
oCACE_Refcountable_T< ACE_SYNCH_MUTEX >
|oCACE::Monitor_Control::Control_Action
|\CACE::Monitor_Control::Monitor_BaseBase class from which the template monitor point class is derived
| \CACE::Monitor_Control::Size_MonitorBase class from which ACE monitors of size are derived
oCACE_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
oCACE_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
oCACE_Reference_Pair< T1, T2 >Defines a pair that only hold references
oCACE_RegistryA Name Server implementation
oCACE_Reverse_Iterator< T >Defines the reverse iterator interface
oCACE_Reverse_Iterator_Impl< T >Defines a abstract reverse iterator
|oCACE_Active_Map_Manager_Reverse_Iterator_Adapter< T, VALUE >Defines a reverse iterator implementation for the Active_Map_Manager_Adapter
|oCACE_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
|oCACE_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
oCACE_RW_MutexWrapper for readers/writer locks
|\CACE_RW_Thread_MutexWrapper for readers/writer locks that exist within a process
oCACE_RW_Process_MutexWrapper for readers/writer locks that exist across processes
oCACE_RWLock_InvariantsRWLock Invariants
oCACE_Sample_HistorySave multiple samples in an array
oCACE_Sbrk_Memory_PoolMake a memory pool that is based on <sbrk(2)>
oCACE_Sbrk_Memory_Pool_OptionsHelper class for Sbrk Memory Pool constructor options
oCACE_Sched_ParamsContainer for scheduling-related parameters
oCACE_Sched_Priority_IteratorAn iterator over the OS-defined scheduling priorities
oCACE_Scheduling_Strategy< SVC_HANDLER >Defines the interface for specifying how to suspend and resume a service
|oCACE_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
oCACE_SDM_helpers
oCACE_Section_Key_InternalA base class for internal handles to section keys for configuration implementations
|oCACE_Configuration_Section_Key_HeapInternal section key class for heap based configuration database
|\CACE_Section_Key_Win32The Win32 registry implementation of an internal section key
oCACE_Select_Reactor_Handle_SetTrack handles we are interested for various events
oCACE_Select_Reactor_Handler_RepositoryUsed to map ACE_HANDLEs onto the appropriate ACE_Event_Handler *
oCACE_Select_Reactor_Handler_Repository_IteratorIterate through the ACE_Select_Reactor_Handler_Repository
oCACE_SemaphoreWrapper for Dijkstra style general semaphores
|\CACE_Thread_SemaphoreWrapper for Dijkstra style general semaphores that work only within one process
oCACE_Service_ConfigSupplies common server operations for dynamic and static configuration of service
oCACE_Service_Config_GuardA guard class, designed to be instantiated on the stack
oCACE_Service_Object_PtrThis 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
oCACE_Service_RepositoryContains all the services offered by a Service Configurator-based application
oCACE_Service_Repository_IteratorIterate through the ACE_Service_Repository
oCACE_Service_TypeKeeps track of information related to the various ACE_Service_Type_Impl subclasses
oCACE_Service_Type_Dynamic_GuardA forward service declaration guard
oCACE_Service_Type_ImplThe 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
|oCACE_Module_TypeDefine the methods for handling the configuration of ACE_Modules
|oCACE_Service_Object_TypeDefine the methods for handling the configuration of ACE_Service_Objects
|\CACE_Stream_TypeDefine the methods for handling the configuration of ACE_Streams
oCACE_Shared_MemoryThis base class adapts both System V shared memory and "BSD" mmap to a common API
|oCACE_Shared_Memory_MMShared memory wrapper based on MMAP
|\CACE_Shared_Memory_SVShared memory wrapper based on System V shared memory
oCACE_Shared_Memory_Pool_OptionsHelper class for Shared Memory Pool constructor options
oCACE_Shared_ObjectProvide the abstract base class used to access dynamic linking facilities
|\CACE_Service_ObjectProvide the abstract base class common to all service implementations
oCACE_Sig_ActionC++ wrapper facade for the sigaction struct
oCACE_Sig_GuardHold signals in MASK for duration of a C++ statement block. Note that a "0" for mask causes all signals to be held
oCACE_Sig_HandlerThis 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_HandlersThis 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
oCACE_Sig_Handlers_Set
oCACE_Sig_SetProvide a C++ wrapper for the C sigset_t interface
oCACE_SizeCDRA CDR stream for calculating size of the representation
oCACE_SOCK_ConnectorDefines a factory that actively connects to a remote IP address and TCP port, creating a new ACE_SOCK_Stream object
|oCACE_LSOCK_ConnectorDefines the format and interface for the connector side of the ACE_LSOCK_Stream
|\CACE_MEM_ConnectorDefines the format and interface for connecting to a peer on a ACE_MEM_Stream object
oCACE_SOCK_Dgram_SC< STREAM >"Dgram_SC" is short for "Datagram Self-Contained."
oCACE_SOCK_SEQPACK_ConnectorDefines a factory that actively connects to a remote IP address and TCP port, creating a new ACE_SOCK_SEQPACK_Association object
oCACE_SPIPE_ConnectorDefines 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
oCACE_SStringA 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..
oCACE_Stack_TraceEncapsulate 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
oCACE_Static_Object_LockProvide an interface to access a global lock
oCACE_Static_Svc_DescriptorHolds the information necessary to describe a statically linked Svc
oCACE_StatsProvides simple statistical analysis
oCACE_Stats_ValueHelper class for ACE_Stats
oCACE_Stream< ACE_SYNCH_DECL >This class is the primary abstraction for the ASX framework. It is moduled after System V Stream
oCACE_Stream_Iterator< ACE_SYNCH_DECL >Iterate through an ACE_Stream
oCACE_StreambufCreate 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 >
oCACE_String_Base_ConstThis 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_WStringThis 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
oCACE_String_Base_Const_Iterator< ACE_CHAR_T >Const iterator class for the ACE_String_Base class
oCACE_String_Base_Iterator< ACE_CHAR_T >Iterator class for the ACE_String_Base class
oCACE_Strong_Bound_Ptr< X, ACE_LOCK >This class implements support for a reference counted pointer
oCACE_Sub_Barrier
oCACE_SV_MessageDefines the header file for the C++ wrapper for message queues
oCACE_SV_Message_QueueDefines the header file for the C++ wrapper for System V IPC message queues
oCACE_SV_Semaphore_SimpleThis 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_ComplexThis is a more complex semaphore wrapper that handles race conditions for initialization correctly..
oCACE_SV_Shared_MemoryThis is a wrapper for System V shared memory
oCACE_Svc_Conf_ParamAn instance of this object will be passed down to the yyparse() and yylex() functions
oCACE_Synch_OptionsContains the values of options used to determine the synchronous and asynchronous behavior
oCACE_System_TimeDefines 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
oCACE_System_Time_PolicyImplement the system time policy for ACE
oCACE_Task_FlagsThese flags are used within the ACE_Task
oCACE_ThreadProvides a wrapper for threads
oCACE_Thread_ControlUsed to keep track of a thread's activities within its entry point function
oCACE_Thread_ExitKeep 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.)
oCACE_Thread_Exit_MaybeA version of ACE_Thread_Exit that is created dynamically under the hood if the flag is set to TRUE
oCACE_Thread_HookThis class makes it possible to provide user-defined "start" hooks that are called before the thread entry point function is invoked
oCACE_Thread_IDDefines a platform-independent thread ID class. Note that this class should be defined within the scope of a thread, rather than at global scope!
oCACE_Thread_ManagerManages a pool of threads
oCACE_Thread_MutexACE_Thread_Mutex wrapper (only valid for threads in the same process)
oCACE_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
oCACE_Threading_Helper< ACE_Null_Mutex >
oCACE_Threading_Helper< ACE_Thread_Mutex >
oCACE_Time_ValueOperations on "timeval" structures, which express time in seconds (secs) and microseconds (usecs)
oCACE_Timer_Node_Dispatch_Info_T< TYPE >Maintains generated dispatch information for Timer nodes
oCACE_Timer_Node_T< TYPE >Maintains the state associated with a Timer entry
oCACE_Timer_Queue_Iterator_T< TYPE >Generic interface for iterating over a subclass of ACE_Timer_Queue
|oCACE_Timer_Hash_Iterator_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET, TIME_POLICY >Iterates over an ACE_Timer_Hash_T
|oCACE_Timer_Heap_Iterator_T< TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY >Iterates over an ACE_Timer_Heap_T
|oCACE_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
oCACE_TLI_ConnectorDefines an active connection factory for the ACE_TLI C++ wrappers
oCACE_TLI_Request
oCACE_TLI_Request_Queue
oCACE_TokenClass 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
oCACE_TOKEN_CONSTNot a public interface
oCACE_Token_NameAllows Token_Manger to identify tokens
oCACE_Token_ProxyAbstract representation of ACE tokens
|oCACE_Local_MutexClass that acquires, renews, and releases a synchronization token local to the process
|oCACE_Local_RLockClass that acquires, renews, and releases a readers lock that is local to the process
|oCACE_Local_WLockClass that acquires, renews, and releases a writer lock that is local to the process
|oCACE_Null_TokenNo op class for nonthreaded platform protocols
|oCACE_Remote_Token_ProxyProxy for acquiring, renewing, and releasing a distributed synchronization token
||oCACE_Remote_MutexProxy for acquiring, renewing, and releasing a distributed mutex
||oCACE_Remote_RLockProxy for acquiring, renewing, and releasing a distributed readers lock
||\CACE_Remote_WLockProxy for acquiring, renewing, and releasing a distributed writers lock
|\CACE_Token_CollectionAllows atomic token group operations AND provides a ACE_Token manager interface
oCACE_Token_Proxy_QueueToken waiter list
oCACE_Token::ACE_Token_Queue
oCACE_Token::ACE_Token_Queue_Entry
oCACE_Token_ReplyMessage format for delivering replies from the ACE_Token Server
oCACE_Token_RequestMessage format for delivering requests to the ACE_Token Server
oCACE_Tokenizer_T< ACE_CHAR_T >Tokenizer
oCACE_TokensAbstract representation of ACE tokens
|oCACE_Mutex_TokenClass that acquires, renews, and releases a process-local synchronization token
|\CACE_RW_TokenClass that acquires, renews, and releases a process-local synchronization token
oCACE_TP_ReactorSpecialization of ACE_Select_Reactor to support thread-pool based event dispatching
oCACE_TP_Token_GuardA helper class that helps grabbing, releasing and waiting on tokens for a thread that tries calling handle_events ()
oCACE_TPQ_EntryToken Proxy Queue entry. Used in the ACE_Token_Proxy_Queue
|\CACE_TSS_TPQ_EntryACE_TSS_TPQ_Entry
oCACE_TPQ_IteratorIterates through ACE_Token_Proxy_Queues
oCACE_TraceA C++ trace facility that keeps track of which methods are entered and exited
oCACE_TSS_AdapterThis 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
oCACE_TSS_CleanupSingleton that helps to manage the lifetime of TSS objects and keys
oCACE_TSS_InfoThread Specific Key management
oCACE_TSS_KeysCollection 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
oCACE_TSS_Ref"Reference count" for thread-specific storage keys
oCACE_TSS_Type_Adapter< TYPE >Adapter that allows built-in types to be used with ACE_TSS
oCACE_Type_Traits< TYPE >
oCACE_Type_Traits< bool >
oCACE_Type_Traits< char >
oCACE_Type_Traits< double >
oCACE_Type_Traits< float >
oCACE_Type_Traits< int >
oCACE_Type_Traits< long >
oCACE_Type_Traits< long double >
oCACE_Type_Traits< long long >
oCACE_Type_Traits< short >
oCACE_Type_Traits< signed char >
oCACE_Type_Traits< TYPE * >
oCACE_Type_Traits< unsigned char >
oCACE_Type_Traits< unsigned int >
oCACE_Type_Traits< unsigned long >
oCACE_Type_Traits< unsigned long long >
oCACE_Type_Traits< unsigned short >
oCACE_Typed_SV_Message< T >Defines the header file for the C++ wrapper for System V message queues
oCACE_Typed_SV_Message_Queue< T >Defines the header file for the C++ wrapper facade for typed message queues
oCACE_Unbounded_Queue< T >A Queue of "infinite" length
oCACE_Unbounded_Queue_Const_Iterator< T >Implement an iterator over an const unbounded queue
oCACE_Unbounded_Queue_Iterator< T >Implement an iterator over an unbounded queue
oCACE_Unbounded_Set_Default_Comparator< T >Simple comparator that evaluates equality using == operator
oCACE_Unbounded_Set_Default_Comparator< ACE_HANDLE >
oCACE_Unbounded_Set_Ex< T, C >Implement a simple unordered set of <T> of unbounded size
oCACE_Unbounded_Set_Ex< ACE_HANDLE, ACE_Unbounded_Set_Default_Comparator< ACE_HANDLE > >
|\CACE_Unbounded_Set< ACE_HANDLE >
oCACE_Unbounded_Set_Ex< T, ACE_Unbounded_Set_Default_Comparator< T > >
|\CACE_Unbounded_Set< T >Compatibility wrapper for ACE_Unbounded_Set_Ex
oCACE_Unbounded_Set_Ex_Const_Iterator< T, C >Implement an const iterator over an unbounded set
oCACE_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
oCACE_Unbounded_Set_Ex_Iterator< T, C >Implement an iterator over an unbounded set
oCACE_Unbounded_Set_Ex_Iterator< T, ACE_Unbounded_Set_Default_Comparator< T > >
|\CACE_Unbounded_Set_Iterator< T >Compatibility wrapper for ACE_Unbounded_Set_Ex_Iterator
oCACE_Unbounded_Stack< T >Implement a generic LIFO abstract data type
oCACE_Unbounded_Stack_Iterator< T >Implement an iterator over an unbounded Stack
oCACE_UPIPE_ConnectorDefines an active connection factory for the ACE_UPIPE_STREAM wrappers
oCACE_UUID
oCACE_UUID_Generator
oCACE_Vector_Iterator< T, DEFAULT_SIZE >Implement an iterator over an ACE_Vector
oCACE_WChar_Codeset_TranslatorCodeset translation routines common to both Output and Input CDR streams
oCACE_Weak_Bound_Ptr< X, ACE_LOCK >This class implements support for a weak pointer that complements ACE_Strong_Bound_Ptr
oCACE_WFMO_Reactor_Handler_RepositoryUsed to map ACE_HANDLEs onto the appropriate ACE_Event_Handler * and other information
oCACE_Wide_To_AsciiA lightweight wchar* to char* string conversion class
oCACE_WIN32_Asynch_TimerThis 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
oCACE_WIN32_Wakeup_Completion
oCACE_XML_Svc_ConfThis abstract class defines the common operations ACE_Service_Config expects when using the XML Service Config Parser
oCAdminAccesses monitor points or groups and manages the registries
oCACE_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
oCACE_Utils::Auto_Functor_Ref< X, Functor >Helper class to implement assignment and copy-construction as expected
oCACE_Registry::Binding
oCACE_Registry::Binding_IteratorAn iterator
oCcancel_state
oCACE_MT_MEM_IO::Channel
oCACE_WFMO_Reactor_Handler_Repository::Common_InfoThis 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 seperate makes sense
|oCACE_WFMO_Reactor_Handler_Repository::Current_InfoThis structure inherits from the common structure to add information for current entries
|oCACE_WFMO_Reactor_Handler_Repository::Suspended_InfoThis structure inherits from the common structure to add information for suspended entries
|\CACE_WFMO_Reactor_Handler_Repository::To_Be_Added_InfoThis structure inherits from the common structure to add information for <to_be_added> entries
oCACE_Utils::Comparator< LEFT, RIGHT >Structure that provides optimal comparison operation for given types
oCACE::Monitor_Control::Monitor_Control_Types::ConstraintBundles the constrain string with its associated trigger action
oCACE_Pagefile_Memory_Pool::Control_BlockAttributes that are meaningful in local storage only
oCControlActionBase class for control actions initiated by the application or by constraint evaluation trigger
oCcpu_set_t
oCACE::Monitor_Control::Monitor_Control_Types::DataAn instance is contained by each enabled monitor point
oCACE_Utils::UUID::dataData Members for Class Attributes
oCACE_Tokenizer_T< ACE_CHAR_T >::Delimiter_EntryDelimiter Entry
oCdirent
oCACE_CDR::Double
oCACE_Dev_Poll_Reactor::Event_TupleStruct that collects event registration information for a handle
oCACE_Utils::Fast_Comparator< LEFT, RIGHT >Quick comparison of types that can be safely promoted and/or converted to each other
oCACE_CDR::Float
oCframe_state
oCACE_OutputCDR::from_boolean
oCACE_OutputCDR::from_char
oCACE_OutputCDR::from_octet
oCACE_OutputCDR::from_string
oCACE_OutputCDR::from_wchar
oCACE_OutputCDR::from_wstring
oCACE_Dev_Poll_Reactor::Handler_RepositoryUsed to map ACE_HANDLEs onto the appropriate Event_Tuple
oCHash_Token< TYPE >
oCACE_Asynch_Transmit_File::Header_And_TrailerThe class defines a data structure that contains pointers to data to send before and after the file data is sent
oCicmp
oCIf_Then_ElseCompile-time selection of type based on a boolean value
oCIf_Then_ElseSelect of type Ta if boolean value is true
oCIf_Then_ElseSelect of type Tb if boolean value is false
oCACE::If_Then_Else< false, Ta, Tb >
oCACE::If_Then_Else< true, Ta, Tb >
oCip
oCACE_Registry::Binding_Iterator::Iteration_State
|oCACE_Registry::Binding_Iterator::Context_Iteration
|oCACE_Registry::Binding_Iterator::Iteration_Complete
|\CACE_Registry::Binding_Iterator::Object_Iteration
oCACE_Active_Map_Manager_Key::key_dataData for the Active Object Map Key
oCACE_CDR::LongDouble
oCACE_OS::macaddr_node_t
oCACE::Monitor_Control::Monitor_Admin
oCACE::Monitor_Control::Monitor_Control_Types
oCACE::Monitor_Control::Monitor_Point_RegistryStorage for instantiated monitor points
oCACE_MT_MEM_IO::MQ_Struct
oCmsghdr
oCACE_Registry::Name_ComponentInternational string
oCACE_Registry::Naming_ContextAn context representation
oCACE_Utils::Noop_Truncator< FROM, TO >No-op truncation
oCACE_Registry::ObjectAn object representation
oCACE_Event_Handler::PolicyBase class for all handler policies
|\CACE_Event_Handler::Reference_Counting_PolicyThis policy dictates the reference counting requirements for the handler
oCACE_Tokenizer_T< ACE_CHAR_T >::Preserve_EntryPreserve Entry
oCACE_Process_Manager::Process_DescriptorInformation describing each process that's controlled by an ACE_Process_Manager
oCACE_Service_Gestalt::Processed_Static_Svc
oCACE_Handler::ProxyActs 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
oCACE_Codeset_Registry::registry_entry
oCrusage
oCSafe_ComparatorConservative comparison of types that may not be safely promoted and/or converted to each other
oCACE_Utils::Safe_Comparator< LEFT, RIGHT, false, false >
oCACE_Utils::Safe_Comparator< LEFT, RIGHT, false, true >
oCACE_Utils::Safe_Comparator< LEFT, RIGHT, true, false >
oCACE_Utils::Safe_Comparator< LEFT, RIGHT, true, true >
oCACE_Bounded_Set< T >::Search_Structure
oCsemun
oCACE_TTY_IO::Serial_Params
oCACE_Pagefile_Memory_Pool::Control_Block::Shared_Control_BlockPool statistics
oCACE_Shared_Memory_Pool::SHM_TABLEKeeps track of all the segments being used
oCsiginfo_t
oCACE_Utils::Sign_Check< signed char >
oCACE_Utils::Sign_Check< signed int >
oCACE_Utils::Sign_Check< signed long >
oCACE_Utils::Sign_Check< signed long long >
oCACE_Utils::Sign_Check< signed short >
oCACE_Utils::Sign_Check< unsigned char >
oCACE_Utils::Sign_Check< unsigned int >
oCACE_Utils::Sign_Check< unsigned long >
oCACE_Utils::Sign_Check< unsigned long long >
oCACE_Utils::Sign_Check< unsigned short >
oCACE_MT_MEM_IO::Simple_Queue
oCACE_SPIPE_Addr::SPIPE_AddrContains security attributes
oCstrbuf
|\CACE_Str_BufSimple wrapper for STREAM pipes strbuf
oCtimespec
oCACE_InputCDR::to_boolean
oCACE_InputCDR::to_char
oCACE_InputCDR::to_octet
oCACE_InputCDR::to_string
oCTo_Unsigned
oCACE_Utils::To_Unsigned< signed char >
oCACE_Utils::To_Unsigned< signed int >
oCACE_Utils::To_Unsigned< signed long >
oCACE_Utils::To_Unsigned< signed long long >
oCACE_Utils::To_Unsigned< signed short >
oCACE_Utils::To_Unsigned< unsigned char >
oCACE_Utils::To_Unsigned< unsigned int >
oCACE_Utils::To_Unsigned< unsigned long >
oCACE_Utils::To_Unsigned< unsigned long long >
oCACE_Utils::To_Unsigned< unsigned short >
oCACE_InputCDR::to_wchar
oCACE_InputCDR::to_wstring
oCACE_Dev_Poll_Reactor::Token_GuardA helper class that helps grabbing, releasing and waiting on tokens for a thread that needs access to the reactor's token
oCACE_Token_Request::Transfer
oCACE_Name_Reply::Transfer
oCACE_Token_Reply::Transfer
oCACE_Name_Request::Transfer
oCACE_InputCDR::Transfer_Contents
oCtruncate_castHelper function to truncate an integral value to the maximum value of the given type
oCACE_Utils::Truncator< FROM, TO >Truncate value of type FROM to value of type TO
oCACE_Utils::Truncator< T, T >
oCTSS_Cleanup_Instance
oCACE_ODB::Tuple
oCACE_Utils::UUID
oCACE_Utils::UUID_Generator
oCACE_Utils::UUID_NodeHolds the MAC-address of the UUID
oCACE_Utils::UUID_Generator::UUID_State
oCACE::Value_Ptr< T >Smart pointer implementation designed for use as a class member
\CACE::VP_traits< T >Value_Ptr traits template structure