Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 1234]

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