Main Page Class Hierarchy Alphabetical List Compound List File List Compound Members File Members Related Pages

# ACE Compound List

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

_WSANETWORKEVENTS |
ACE | Contains value added ACE methods that extend the behavior of the UNIX and Win32 OS calls
ACE_Accept_QoS_Params | Wrapper class that simplifies the information passed to the QoS enabled <ACE_OS::accept> method
ACE_Accept_Strategy< SVC_HANDLER, > | Defines the interface for specifying a passive connection acceptance strategy for a SVC_HANDLER
ACE_Acceptor< SVC_HANDLER, > | Abstract factory for creating a service handler (SVC_HANDLER), accepting into the SVC_HANDLER, and activating the SVC_HANDLER
ACE_Acquire_Method | An enum class
ACE_Activation_Queue | Reifies a method into a request. Subclasses typically represent necessary state and behavior
ACE_Active_Map_Manager< T > | Define a map abstraction that associates system generated keys with user specified values
ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER > | Defines a map implementation
ACE_Active_Map_Manager_Iterator_Adapter< T, VALUE > | Defines a iterator implementation for the Active_Map_Manager_Adapter
ACE_Active_Map_Manager_Key | Key used in the Active Object Map
ACE_Active_Map_Manager_Key::key_data | Data for the Active Object Map Key
ACE_Active_Map_Manager_Reverse_Iterator_Adapter< T, VALUE > | Defines a reverse iterator implementation for the Active_Map_Manager_Adapter
ACE_Adaptive_Lock | An adaptive general locking class that defers the decision of lock type to run time
ACE_Addr | Defines the base class for the "address family independent" address format
ACE_AIOCB_Notify_Pipe_Manager |
ACE_Allocator | Interface for a dynamic memory allocator that uses inheritance and dynamic binding to provide extensible mechanisms for allocating and deallocating memory
ACE_Allocator_Adapter< MALLOC > | This class is an Adapter that allows the <ACE_Allocator> to use the <Malloc> class below
ACE_Arg_Shifter | 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
ACE_ARGV | Transforms a string <buf> into an <argv> style vector of strings or an <argv> style vector of string <buf>, performing environment variable substitutions if necessary
ACE_Array< T > | Implement a dynamic array class
ACE_Array_Base< T > | Implement a simple dynamic array
ACE_Array_Iterator< T > | Implement an iterator over an ACE_Array
ACE_Async_Timer_Queue_Adapter< TQ > | Adapts a <TQ> to be run asynchronously
ACE_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
ACE_Asynch_Accept::Result | This is that class which will be passed back to the <handler> when the asynchronous accept completes
ACE_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
ACE_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>
ACE_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
ACE_Asynch_Read_Dgram::Result | This is the class which will be passed back to the <handler> when the asynchronous read completes. This class forwards all the methods to the implementation classes
ACE_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
ACE_Asynch_Read_File::Result | This is that class which will be passed back to the <handler> when the asynchronous read completes. This class forwards all the methods to the implementation class
ACE_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
ACE_Asynch_Read_Stream::Result | This is the class which will be passed back to the <handler> when the asynchronous read completes. This class forwards all the methods to the implementation classes
ACE_Asynch_Result | An interface base class which allows users access to common information related to an asynchronous operation
ACE_Asynch_Transmit_File | This class is a factory for starting off asynchronous transmit files on a stream
ACE_Asynch_Transmit_File::Header_And_Trailer | The class defines a data structure that contains pointers to data to send before and after the file data is sent
ACE_Asynch_Transmit_File::Result | This is that class which will be passed back to the <handler> when the asynchronous transmit file completes
ACE_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
ACE_Asynch_Write_Dgram::Result | This is that class which will be passed back to the <handler> when the asynchronous write completes. This class forwards all the methods to the implementation class
ACE_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
ACE_Asynch_Write_File::Result | This is that class which will be passed back to the <handler> when the asynchronous write completes. This class forwards all the methods to the implementation class
ACE_Asynch_Write_Stream | This class is a factory for starting off asynchronous writes on a stream. This class forwards all methods to its implementation class
ACE_Asynch_Write_Stream::Result | This is that class which will be passed back to the <handler> when the asynchronous write completes. This class forwards all the methods to the implementation class
ACE_At_Thread_Exit | Contains a method to be applied when a thread is terminated
ACE_At_Thread_Exit_Func |
ACE_ATM_Addr | Defines the ATM domain address family address format
ACE_Atomic_Op< ACE_LOCK, TYPE > |
ACE_Atomic_Op_Ex< ACE_LOCK, TYPE > | Transparently parameterizes synchronization into basic arithmetic operations
ACE_Auto_Array_Ptr< X > | Implements an extension to the draft C++ standard auto_ptr abstraction
ACE_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"
ACE_Auto_Basic_Ptr< X > | Implements the draft C++ standard auto_ptr abstraction. This class allows one to work on non-object (basic) types
ACE_Auto_Event | Auto Events
ACE_Auto_IncDec< ACE_SAFELY_INCREMENTABLE_DECREMENTABLE > | This class automatically increments and decrements a parameterized counter
ACE_Auto_String_Free | Simple class to automatically de-allocate strings
ACE_Barrier | Implements "barrier synchronization"
ACE_Base_Thread_Adapter | Base class for all the Thread_Adapters
ACE_Based_Pointer< CONCRETE > | A smart proxy that keeps track of the relative offset of a "pointer" from its base address
ACE_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
ACE_Based_Pointer_Repository | Maps pointers to the base address of the region to which each pointer belongs
ACE_Based_Pointer_Repository_Rep |
ACE_Basic_Stats | Collect basic stats about a series of samples
ACE_Bcast_Node | Linked list of broadcast interfaces
ACE_BoolCapEntry | This class implement the ACE Bool Capability subclass
ACE_Bound_Ptr_Counter< ACE_LOCK > | An ACE_Bound_Ptr_Counter<ACE_LOCK> object encapsulates an object reference count. Do not use this class directly, use ACE_Strong_Bound_Ptr or ACE_Weak_Bound_Ptr instead
ACE_Bounded_Cached_Connect_Strategy< SVC_HANDLER,, 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
ACE_Bounded_Set< T > | Implement a simple unordered set of <T> with maximum set at creation time
ACE_Bounded_Set< T >::Search_Structure |
ACE_Bounded_Set_Iterator< T > | Iterates through an unordered set
ACE_Bounded_Stack< T > | Implement a generic LIFO abstract data type
ACE_Buffered_Svc_Handler<, > | Defines the interface for a service that exchanges data with its connected peer and supports buffering
ACE_Cache_Map_Iterator< KEY, VALUE, IMPLEMENTATION, CACHING_STRATEGY, ATTRIBUTES > | Defines a iterator for the Cache_Map_Manager
ACE_Cache_Map_Manager<> | Defines a abstraction that will purge entries from a map
ACE_Cache_Map_Reverse_Iterator< KEY, VALUE, REVERSE_IMPLEMENTATION, CACHING_STRATEGY, ATTRIBUTES > | Defines a reverse iterator for the Cache_Map_Manager
ACE_Cached_Allocator< T, ACE_LOCK > | Create a cached memory poll with <n_chunks> chunks each with sizeof (TYPE) size
ACE_Cached_Connect_Strategy< SVC_HANDLER,, MUTEX > | A connection strategy which caches connections to peers (represented by <SVC_HANDLER> instances), thereby allowing subsequent re-use of unused, but available, connections
ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, 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
ACE_Cached_Mem_Pool_Node< T > | <ACE_Cached_Mem_Pool_Node> keeps unused memory within a free list
ACE_Caching_Strategy< ATTRIBUTES, CACHING_UTILITY > | This class is an abstract base class for a caching strategy
ACE_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
ACE_Capabilities | This class implement the ACE Capabilities
ACE_CapEntry | This class is the base class for all ACE Capabilities entry subclasses
ACE_CDR | Keep constants and some routines common to both Output and Input CDR streams
ACE_CDR::Double |
ACE_CDR::Float |
ACE_CDR::LongDouble |
ACE_Char_Codeset_Translator | Codeset translation routines common to both Output and Input CDR streams
ACE_Cleanup | Base class for objects that are cleaned by ACE_Object_Manager
ACE_Cleanup_Adapter< TYPE > | Adapter for ACE_Cleanup objects that allows them to be readily managed by the ACE_Object_Manager
ACE_Cleanup_Info | Hold cleanup information for thread/process
ACE_Cleanup_Info_Node |
ACE_Cleanup_Strategy< KEY, VALUE, CONTAINER > | Defines a default strategy to be followed for cleaning up entries from a map which is the container
ACE_Command_Base | Defines an abstract class that allows us to invoke commands without knowing anything about the implementation
ACE_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
ACE_Concurrency_Strategy< SVC_HANDLER > | Defines the interface for specifying a concurrency strategy for a SVC_HANDLER
ACE_Condition< MUTEX > | ACE_Condition variable wrapper, which allows threads to block until shared data changes state
ACE_Condition_Attributes |
ACE_Condition_Thread_Mutex | ACE_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
ACE_Config_ImpExp_Base | Base class for file import/export configuration
ACE_Configuration | Base class for configuration databases
ACE_Configuration_ExtId | External ID for the section and value hash
ACE_Configuration_Heap | The concrete implementation of a allocator based configuration database
ACE_Configuration_Section_IntId | The internal ID for a section hash table
ACE_Configuration_Section_Key | Referenced counted wrapper for <ACE_Section_Key_Internal>
ACE_Configuration_Section_Key_Heap | Internal section key class for heap based configuration database
ACE_Configuration_Value_IntId | The section hash table internal value class
ACE_Configuration_Win32Registry | The win32 registry implementation of a configuration database
ACE_Connect_Strategy< SVC_HANDLER, > | Defines the interface for specifying an active connection establishment strategy for a SVC_HANDLER
ACE_Connection_Recycling_Strategy | Defines the interface for a connection recycler
ACE_Connector< SVC_HANDLER, > | Generic factory for actively connecting clients and creating service handlers (SVC_HANDLERs)
ACE_Control_Block | This information is stored in memory allocated by the <Memory_Pool>
ACE_Control_Block::ACE_Malloc_Header | This is the control block header. It's used by <ACE_Malloc> to keep track of each chunk of data when it's in the free list or in use
ACE_Control_Block::ACE_Name_Node | This class supports "named memory regions" within <ACE_Malloc>
ACE_Countdown_Time | Keeps track of the amount of elapsed time
ACE_Creation_Strategy< SVC_HANDLER > | Defines the interface for specifying a creation strategy for a SVC_HANDLER
ACE_Data_Block | Stores the data payload that is accessed via one or more <ACE_Message_Block>s
ACE_Date_Time | System independent representation of date and time
ACE_Deadline_Message_Strategy | Deadline based message priority strategy
ACE_DEV | Defines the member functions for the base class of the ACE_DEV abstraction
ACE_DEV_Addr | Defines device address family address format
ACE_DEV_Connector | Defines an active connection factory for the ACE_DEV wrappers
ACE_DEV_IO | Read/Write operations on Devices
ACE_Dirent | Define a portable C++ directory-entry iterator based on the POSIX API
ACE_Dirent_Selector |
ACE_DLL | Provides an abstract interface for handling various DLL operations
ACE_DLL_Strategy< SVC_HANDLER > | Defines the interface for specifying a creation strategy for a SVC_HANDLER based on dynamic linking of the SVC_HANDLER
ACE_DLList< T > | A double-linked list container class
ACE_DLList_Iterator< T > | A double-linked list container class iterator
ACE_DLList_Node | Base implementation of element in a DL list. Needed for ACE_Double_Linked_List
ACE_DLList_Reverse_Iterator< T > | A double-linked list container class iterator
ACE_DNode< T > | Implementation element in a bilinked list
ACE_Double_Linked_List< T > | A double-linked list implementation
ACE_Double_Linked_List_Iterator< T > | Implements an iterator for a double linked list ADT
ACE_Double_Linked_List_Iterator_Base< T > | Implements a common base class for iterators for a double linked list ADT
ACE_Double_Linked_List_Reverse_Iterator< T > | Implements a reverse iterator for a double linked list ADT
ACE_Dummy_Node | I forget why this is here... ;-)
ACE_Dumpable | Base class that defines a uniform interface for all object dumping
ACE_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>
ACE_Dumpable_Ptr | A smart pointer stored in the in-memory object database ACE_ODB. The pointee (if any) is deleted when reassigned
ACE_Dynamic | Checks to see if an object was dynamically allocated
ACE_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
ACE_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_Block>s dynamically
ACE_Dynamic_Node | Handle a dynamically linked node
ACE_Dynamic_Service< TYPE > | Provides a general interface to retrieve arbitrary objects from the ACE service repository
ACE_Dynamic_Service_Base | Base class for all ACE_Dynamic_Service instantiations
ACE_EH_Dispatch_Info | This structure contains information of the activated event handler
ACE_Env_Value< T > | Enviroment Variable Value
ACE_Equal_To< TYPE > | Function object for comparing two objects of the given type for equality
ACE_Errno_Guard | Provides a wrapper to improve performance when thread-specific errno must be saved and restored in a block of code
ACE_Event | A wrapper around the Win32 event locking mechanism
ACE_Event_Handler | Provides an abstract interface for handling various types of I/O, timer, and signal events
ACE_Event_Handler_Handle_Timeout_Upcall< ACE_LOCK > | Functor for Timer_Queues
ACE_Event_Tuple | An ACE_Event_Handler and its associated ACE_HANDLE
ACE_FIFO | Abstract base class for UNIX FIFOs
ACE_FIFO_Caching_Strategy< ATTRIBUTES, CACHING_UTILITY > | The First In First Out strategy is implemented wherein each item is ordered
ACE_FIFO_Recv | Receiver side of the bytestream C++ wrapper for UNIX FIFOs
ACE_FIFO_Recv_Msg | Receiver side for the record oriented C++ wrapper for UNIX FIFOs
ACE_FIFO_Send | Sender side for the bytestream C++ wrapper for UNIX FIFOs
ACE_FIFO_Send_Msg | Sender side for the Record oriented C++ wrapper for UNIX FIFOs
ACE_FILE | Defines the core methods of the <ACE_FILE> abstraction
ACE_FILE_Addr | Defines the FILE address family address format
ACE_FILE_Connector | Defines an active connection factory for the ACE_FILE wrappers
ACE_FILE_Info | Abstracts basic OS FILE information
ACE_FILE_IO | Read/Write operations on Files
ACE_File_Lock | A wrapper around the UNIX file locking mechanism
ACE_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
ACE_Filecache_Handle | Abstraction over a real file. This is meant to be the entry point into the Cached Virtual Filesystem
ACE_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
ACE_Fixed_Set< T, ACE_SIZE > | Implement a simple unordered set of <T> with maximum <ACE_SIZE>
ACE_Fixed_Set_Const_Iterator< T, ACE_SIZE > | Iterates through a const unordered set
ACE_Fixed_Set_Iterator< T, ACE_SIZE > | Iterates through an unordered set
ACE_Fixed_Stack< T, ACE_SIZE > | Implement a generic LIFO abstract data type
ACE_Flag_Manip |
ACE_Flow_Spec | Wrapper class that defines the flow spec QoS information, which is used by IntServ (RSVP) and DiffServ
ACE_FlReactor | A Reactor implementation that uses the Fast-Light (FL) toolkit for event demultiplexing. This will let us integrate the FL toolkit with ACE and/or TAO
ACE_Framework_Component | Base class that defines a uniform interface for all managed framework components
ACE_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>
ACE_Framework_Repository | Contains all framework components used by an application
ACE_Free_List< T > | Implements a free list
ACE_Free_List< ACE_Cached_Mem_Pool_Node< T >> |
ACE_Function_Node | Keeps track of the symbol name of for a shared function
ACE_Future< T > | This class implements a ``single write, multiple read'' pattern that can be used to return results from asynchronous method invocations
ACE_Future_Holder< T > | Implementation of object which has holds ACE_Future
ACE_Future_Observer< T > | ACE_Future_Observer<T>
ACE_Future_Rep< T > | ACE_Future_Rep<T>
ACE_Future_Set< T > | This class implements a mechanism which 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
ACE_Get_Opt | Iterator for parsing command-line arguments
ACE_Get_Opt::ACE_Get_Opt_Long_Option |
ACE_Guard< ACE_LOCK > | This data structure is meant to be used within a method or function... It performs automatic aquisition and release of a parameterized synchronization object <ACE_LOCK>
ACE_Guard< ACE_Null_Mutex > | Template specialization of <ACE_Guard> for the <ACE_Null_Mutex>
ACE_Guard< ACE_Select_Reactor_Token_T< ACE_Noop_Token > > | Template specialization of <ACE_Guard> for the <ACE_Null_Mutex>
ACE_Handle_Gobbler | This class gobbles up handles
ACE_Handle_Ops |
ACE_Handle_Set | C++ wrapper facade for the socket <fd_set> abstraction
ACE_Handle_Set_Iterator | Iterator for the <ACE_Handle_Set> abstraction
ACE_Handler | This base class defines the interface for receiving the results of asynchronous operations
ACE_Handler_Caching_Utility< KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES > | Defines a helper class for the Caching Strategies
ACE_Handler_Cleanup_Strategy< KEY, VALUE, CONTAINER > | Defines a strategy to be followed for cleaning up entries which are svc_handlers from a container
ACE_Hash< TYPE > | Function object for hashing
ACE_Hash< char > | Function object for hashing a char
ACE_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
ACE_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
ACE_Hash_Map_Const_Iterator< EXT_ID, INT_ID, ACE_LOCK > | Wrapper for backward compatibility
ACE_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>
ACE_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>
ACE_Hash_Map_Entry< EXT_ID, INT_ID > | Define an entry in the hash table
ACE_Hash_Map_Iterator< EXT_ID, INT_ID, ACE_LOCK > | Wrapper for backward compatibility
ACE_Hash_Map_Iterator_Base_Ex< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK > | Base iterator for the <ACE_Hash_Map_Manager_Ex>
ACE_Hash_Map_Iterator_Ex< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK > | Forward iterator for the <ACE_Hash_Map_Manager_Ex>
ACE_Hash_Map_Manager< EXT_ID, INT_ID, ACE_LOCK > | Wrapper for backward compatibility
ACE_Hash_Map_Manager_Ex< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK > | Define a map abstraction that efficiently associates <EXT_ID>s with <INT_ID>s
ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR > | Defines a map implementation
ACE_Hash_Map_Manager_Ex_Iterator_Adapter< T, KEY, VALUE, HASH_KEY, COMPARE_KEYS > | Defines a iterator implementation for the Hash_Map_Manager_Adapter
ACE_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
ACE_Hash_Map_Reverse_Iterator< EXT_ID, INT_ID, ACE_LOCK > | Wrapper for backward compatibility
ACE_Hash_Map_Reverse_Iterator_Ex< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK > | Reverse iterator for the <ACE_Hash_Map_Manager_Ex>
ACE_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
ACE_Hashable |
ACE_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
ACE_Incremental_Key_Generator< T > | Defines a simple incremental key generator
ACE_INET_Addr | Defines a C++ wrapper facade for the Internet domain address family format
ACE_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
ACE_Init_ACE | Initialize ACE library services. Can be called only once per program invocation
ACE_InputCDR | A CDR stream for reading, i.e. for demarshalling
ACE_InputCDR::to_boolean |
ACE_InputCDR::to_char |
ACE_InputCDR::to_octet |
ACE_InputCDR::to_string |
ACE_InputCDR::to_wchar |
ACE_InputCDR::to_wstring |
ACE_InputCDR::Transfer_Contents | Helper class to transfer the contents from one input CDR to another without requiring any extra memory allocations, data copies or too many temporaries
ACE_IntCapEntry | This class implement the ACE Integer Capability subclass
ACE_Intrusive_List< T > | Implement an intrusive double linked list
ACE_Intrusive_List_Node< T > | Implement the requirements for ACE_Intrusive_List
ACE_IO_Cntl_Msg | Data format for IOCTL messages
ACE_IO_SAP | Defines the methods for the base class of the <ACE_IO_SAP> abstraction, which includes <ACE_FILE> and <ACE_DEV>
ACE_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
ACE_IPC_SAP | Defines the member functions for the base class of the ACE_IPC_SAP abstraction
ACE_Iterator< T > | Defines the iterator interface
ACE_Iterator_Impl< T > | Defines a abstract iterator
ACE_Laxity_Message_Strategy | Laxity based message priority strategy
ACE_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
ACE_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
ACE_Lib_Find |
ACE_Lite_MMAP_Memory_Pool | Make a ``lighter-weight'' memory pool based <ACE_Mem_Map>
ACE_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..
ACE_Local_Memory_Pool_Options | Helper class for Local Memory Pool constructor options
ACE_Local_Name_Space<, ACE_LOCK > | Maintaining accesses Local Name Server Database. Allows to add NameBindings, change them, remove them and resolve NameBindings
ACE_Location_Node | Keep track of where a shared library is located
ACE_Lock | This is the abstract base class that contains the uniform locking API that is supported by all the ACE synchronization mechanisms
ACE_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.)
ACE_LOCK_SOCK_Acceptor< ACE_LOCK > | Specialize <ACE_SOCK_Acceptor> to lock around <accept>;
ACE_Locked_Data_Block< ACE_LOCK > | A Data_Block with a concrete locking strategy
ACE_Locked_Free_List< T, ACE_LOCK > | Implements a free list
ACE_Log_Msg | Provides a variable length argument message logging abstraction
ACE_Log_Msg_Backend | Define the interface for ACE_Log_Msg backend strategies
ACE_Log_Msg_Callback | An interface class used to get logging callbacks
ACE_Log_Msg_IPC | Defines the interfaces for ACE_Log_Msg backend
ACE_Log_Msg_Manager |
ACE_Log_Record | Defines the structure of an ACE logging record
ACE_Logging_Strategy | This class provides the hooks to control the output produced by any of the network services
ACE_LRU_Caching_Strategy< ATTRIBUTES, CACHING_UTILITY > | Defines a Least Recently Used strategy which will decide on the item to be removed from the cache
ACE_LSOCK | Create a Local ACE_SOCK, which is used for passing file descriptors
ACE_LSOCK_Acceptor | Defines the format and interface for the acceptor side of the local ACE_SOCK ACE_Stream
ACE_LSOCK_CODgram | Defines the member functions for the <ACE_LSOCK> connected datagram abstraction
ACE_LSOCK_Connector | Defines the format and interface for the connector side of the <ACE_LSOCK_Stream>
ACE_LSOCK_Dgram | Create a Local ACE_SOCK datagram
ACE_LSOCK_Stream | Create a Local ACE_SOCK stream
ACE_Malloc<, ACE_LOCK > |
ACE_Malloc_FIFO_Iterator<, ACE_LOCK > |
ACE_Malloc_FIFO_Iterator_T<, ACE_LOCK, ACE_CB > | FIFO iterator for names stored in Malloc'd memory
ACE_Malloc_LIFO_Iterator<, ACE_LOCK > |
ACE_Malloc_LIFO_Iterator_T<, ACE_LOCK, ACE_CB > | LIFO iterator for names stored in Malloc'd memory
ACE_Malloc_T<, ACE_LOCK, ACE_CB > | Define a C++ class that uses parameterized types to provide an extensible mechanism for encapsulating various of dynamic memory management strategies
ACE_Managed_Object< TYPE > | Wrapper for interface to allocate an object managed by the ACE_Object_Manager
ACE_Managed_Process | A process easily managed by ACE_Process_Manager
ACE_Manual_Event | Manual Events
ACE_Map< KEY, VALUE > | Defines a map interface
ACE_Map_Const_Iterator< EXT_ID, INT_ID, ACE_LOCK > | Forward const iterator for the <ACE_Map_Manager>
ACE_Map_Const_Iterator_Base< EXT_ID, INT_ID, ACE_LOCK > | Const iterator for the <ACE_Map_Manager>
ACE_Map_Entry< EXT_ID, INT_ID > | An entry in the Map
ACE_Map_Impl< KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY > | Defines a map implementation
ACE_Map_Impl_Iterator_Adapter< T, IMPLEMENTATION, ENTRY > | Defines a iterator implementation for the Map_Impl class
ACE_Map_Impl_Reverse_Iterator_Adapter< T, IMPLEMENTATION, ENTRY > | Defines a reverse iterator implementation for the Map_Impl class
ACE_Map_Iterator< EXT_ID, INT_ID, ACE_LOCK > | Forward iterator for the <ACE_Map_Manager>
ACE_Map_Iterator_Base< EXT_ID, INT_ID, ACE_LOCK > | Iterator for the <ACE_Map_Manager>
ACE_Map_Manager< EXT_ID, INT_ID, ACE_LOCK > | Define a map abstraction that associates <EXT_ID>s with <INT_ID>s
ACE_Map_Manager_Adapter< KEY, VALUE, KEY_GENERATOR > | Defines a map implementation
ACE_Map_Manager_Iterator_Adapter< T, KEY, VALUE > | Defines a iterator implementation for the Map_Manager_Adapter
ACE_Map_Manager_Reverse_Iterator_Adapter< T, KEY, VALUE > | Defines a reverse iterator implementation for the Map Manager
ACE_Map_Reverse_Iterator< EXT_ID, INT_ID, ACE_LOCK > | Reverse Iterator for the <ACE_Map_Manager>
ACE_MEM_Acceptor | Defines the format and interface for the acceptor side of the local mmap stream
ACE_MEM_Addr | Defines a C++ wrapper facade for the shared memory transport address family format
ACE_MEM_Connector | Defines the format and interface for connecting to a peer on a `ACE_MEM_Stream` object
ACE_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
ACE_Mem_Map | C++ interface OS memory mapping system call
ACE_MEM_SAP | Defines the methods of shared memory management for shared memory transport
ACE_MEM_SAP_Node |
ACE_MEM_Stream | Defines the methods in the <ACE_MEM_Stream> abstraction
ACE_Message_Block | Stores messages for use throughout ACE (particularly <ACE_Message_Queue>)
ACE_Message_Queue<> | A threaded message queueing facility, modeled after the queueing facilities in System V STREAMs
ACE_Message_Queue_Base | Base class for <ACE_Message_Queue>, which is the central queueing facility for messages in the ACE framework
ACE_Message_Queue_Ex< ACE_MESSAGE_TYPE, > | A threaded message queueing facility, modeled after the queueing facilities in System V STREAMs
ACE_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)
ACE_Message_Queue_Iterator<> | Iterator for the <ACE_Message_Queue>
ACE_Message_Queue_Reverse_Iterator<> | Reverse Iterator for the <ACE_Message_Queue>
ACE_Method_Request | Reifies a method into a request. Subclasses provide the necessary state and behavior
ACE_MMAP_Memory_Pool | Make a memory pool that is based on <mmap(2)>. This implementation allows memory to be shared between processes
ACE_MMAP_Memory_Pool_Options | Helper class for MMAP Memory Pool constructor options
ACE_Module<> | An abstraction for managing a bi-directional flow of messages
ACE_Module_Base | Workaround HP/C++ compiler bug with enums in templates
ACE_Module_Type | Define the methods for handling the configuration of <ACE_Modules>
ACE_Msg_WFMO_Reactor | An OO event demultiplexor and event handler dispatcher for Win32 <MsgWaitForMultipleObjects>
ACE_MT_MEM_IO |
ACE_MT_MEM_IO::Channel |
ACE_MT_MEM_IO::MQ_Struct |
ACE_MT_MEM_IO::Simple_Queue |
ACE_Mutex | <ACE_Mutex> wrapper (valid in same process or across processes (depending on TYPE flag))
ACE_Name_Binding | Maintains a mapping from name to value and type
ACE_Name_Options | Manages the options for the ACE Name_Server
ACE_Name_Proxy | Proxy for dealing with remote server process managing NET_LOCAL NameBindings
ACE_Name_Reply | Message format for delivering replies from the ACE_Name Server
ACE_Name_Reply::Transfer |
ACE_Name_Request | Message format for delivering requests to the ACE_Name Server
ACE_Name_Request::Transfer |
ACE_Name_Space | Abstract base class that provides an abstract interface to the database without exposing any implemenation details
ACE_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
ACE_Naming_Context | Maintaining accesses Name Server Databases. Allows to add NameBindings, change them, remove them and resolve NameBindings
ACE_New_Allocator | Defines a class that provided a simple implementation of memory allocation
ACE_Node< T > | Implementation element in a Queue, Set, and Stack
ACE_NOOP_Concurrency_Strategy< SVC_HANDLER > | Implements a no-op activation strategy in order to avoid calling open on a svc_handler multiple times
ACE_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
ACE_Noop_Key_Generator< T > | Defines a noop key generator
ACE_Noop_Token |
ACE_Notification_Buffer | Simple wrapper for passing <ACE_Event_Handler *>s and <ACE_Reactor_Mask>s between threads
ACE_Notification_Strategy | Abstract class used for notifying an interested party
ACE_NS_Internal | This class and ACE_NS_String are used as Adapters to work with the Map_Manager
ACE_NS_String | This class and ACE_NS_Internal are used as Adapters to work with the Map_Manager
ACE_NS_WString | This class retain the backward compatibility for Naming_Conext and related classes. The only addition to ACE_WString is a very naive "wchar" to "char" conversion function
ACE_NT_Service | Provide the base class which defines the interface for controlling an NT service
ACE_Null_Barrier | Implements "NULL barrier synchronization"
ACE_Null_Caching_Strategy< ATTRIBUTES, CACHING_UTILITY > | The is a special caching strategy which doesnt have the purging feature
ACE_Null_Caching_Utility< KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES > | Defines a dummy helper class for the Caching Strategies
ACE_Null_Cleanup_Strategy< KEY, VALUE, CONTAINER > | Defines a do-nothing implementation of the cleanup strategy
ACE_Null_Condition | Implement 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..
ACE_Null_Mutex | Implement a do nothing <ACE_Mutex>, i.e., all the methods are no ops
ACE_Null_Semaphore | Implement a do nothing <ACE_Semaphore>, i.e., all the methods are no ops
ACE_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
ACE_Object_Manager | Manager for ACE library services and singleton cleanup
ACE_Object_Manager_Base | Base class for ACE_Object_Manager(s)
ACE_Object_Manager_Manager |
ACE_Object_Manager_Preallocations |
ACE_Object_Node | Keeps track of the symbol name for a shared object
ACE_Obstack | Define a simple "mark and release" memory allocation utility
ACE_Obstack_T< CHAR > |
ACE_ODB | This is the object database (ODB) that keeps track of all live ACE objects
ACE_ODB::Tuple |
ACE_Oneshot_Acceptor< SVC_HANDLER, > | Generic factory for passively connecting clients and creating exactly one service handler (SVC_HANDLER)
ACE_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
ACE_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
ACE_OS | This class 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
ACE_OS::ace_flock_t | OS file locking structure
ACE_OS_Dirent | This class is a wrapper for the dirent.h operations
ACE_OS_Exit_Info | Hold Object Manager cleanup (exit) information
ACE_OS_Log_Msg_Attributes | The attributes required by ACE_Log_Msg
ACE_OS_Memory | This class is a wrapper for dynamic memory operations
ACE_OS_Object_Manager |
ACE_OS_Object_Manager_Manager |
ACE_OS_String | This class includes functions available in string.h and ctype.h
ACE_OS_Thread_Adapter | Converts a C++ function into a function <ace_thread_adapter> 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>
ACE_OS_Thread_Descriptor | Parent class of all ACE_Thread_Descriptor classes. = Container for ACE_Thread_Descriptor members that are used in ACE_OS
ACE_OS_TLI | This class is a wrapper for the TLI operations
ACE_OutputCDR | A CDR stream for writing, i.e. for marshalling
ACE_OutputCDR::from_boolean |
ACE_OutputCDR::from_char |
ACE_OutputCDR::from_octet |
ACE_OutputCDR::from_string |
ACE_OutputCDR::from_wchar |
ACE_OutputCDR::from_wstring |
ACE_Pagefile_Memory_Pool | Make a memory pool that is based on "anonymous" memory regions allocated from the Win32 page file
ACE_Pagefile_Memory_Pool::Control_Block | Attributes that are meaningful in local storage only
ACE_Pagefile_Memory_Pool::Control_Block::Shared_Control_Block | Pool statistics
ACE_Pagefile_Memory_Pool_Options | Helper class for Pagefile Memory Pool constructor options
ACE_Pair< T1, T2 > | Defines a pair
ACE_Pair_Caching_Utility< KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES > | Defines a helper class for the Caching Strategies
ACE_Parse_Node | Provide the base of the object hierarchy that defines the parse tree of Service Nodes
ACE_PI_Control_Block | This information is stored in memory allocated by the <Memory_Pool>
ACE_PI_Control_Block::ACE_Malloc_Header | This is the control block header. It's used by <ACE_Malloc> to keep track of each chunk of data when it's in the free list or in use
ACE_PI_Control_Block::ACE_Name_Node | This class supports "named memory regions" within <ACE_Malloc>
ACE_Pipe | Provides a bidirectional "pipe" abstraction that is portable to Windows NT, SVR4 UNIX, and BSD UNIX
ACE_Pointer_Hash< TYPE > | Function object for hashing pointers
ACE_POSIX__Asynch_Write_Dgram_Result | This is class provides concrete implementation for ACE_Asynch_Write_Dgram::Result class
ACE_POSIX_AIOCB_Asynch_Operation | This class implements <ACE_Asynch_Operation> for <AIOCB> (Asynchronous I/O Control Blocks) based implementation of Proactor
ACE_POSIX_AIOCB_Asynch_Read_Dgram | This class is a factory for starting off asynchronous reads on a UDP socket
ACE_POSIX_AIOCB_Asynch_Read_File | This class is a factory for starting off asynchronous reads on a file. This class implements <ACE_Asynch_Read_File> for <AIOCB> (Asynchronous I/O Control Blocks) based implementation of Proactor
ACE_POSIX_AIOCB_Asynch_Read_Stream |
ACE_POSIX_AIOCB_Asynch_Transmit_File | Implementation for transmit_file will make use of POSIX_AIOCB_Asynch_Transmit_Handler
ACE_POSIX_AIOCB_Asynch_Transmit_Handler |
ACE_POSIX_AIOCB_Asynch_Write_Dgram | This class is a factory for starting off asynchronous writes on a UDP socket
ACE_POSIX_AIOCB_Asynch_Write_File |
ACE_POSIX_AIOCB_Asynch_Write_Stream | This class implements <ACE_Asynch_Write_Stream> for <AIOCB> (Asynchronous I/O Control Blocks) based implementation of Proactor
ACE_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
ACE_POSIX_Asynch_Accept |
ACE_POSIX_Asynch_Accept_Handler |
ACE_POSIX_Asynch_Accept_Result | This is that class which will be passed back to the <handler> when the asynchronous accept completes
ACE_POSIX_Asynch_Operation | This class abstracts out the common things needed for implementing <Asynch_Operation> for POSIX platforms. Specific implementations such as <POSIX_AIOCB_Asynch_Operation> can derive from this class
ACE_POSIX_Asynch_Read_Dgram_Result | This is class provides concrete implementation for ACE_Asynch_Read_Dgram::Result class
ACE_POSIX_Asynch_Read_File_Result | This class provides concrete implementation for <ACE_Asynch_Read_File::Result> class for POSIX platforms
ACE_POSIX_Asynch_Read_Stream_Result | This class provides concrete implementation for <ACE_Asynch_Read_Stream::Result> class for POSIX platforms
ACE_POSIX_Asynch_Result |
ACE_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
ACE_POSIX_Asynch_Transmit_File_Result | This is that class which will be passed back to the <handler> when the asynchronous transmit file completes
ACE_POSIX_Asynch_Transmit_Handler |
ACE_POSIX_Asynch_Write_Dgram_Result |
ACE_POSIX_Asynch_Write_File_Result | This class provides implementation for <ACE_Asynch_Write_File_Result> for POSIX platforms
ACE_POSIX_Asynch_Write_Stream_Result | This class provides concrete implementation for <ACE_Asynch_Write_Stream::Result> on POSIX platforms
ACE_POSIX_Proactor | POSIX implementation of the Proactor
ACE_POSIX_SIG_Proactor | This Proactor implementation does compeltion querying using POSIX Real Time signals. <sigtimedwait>/<sigwaitinfo> call is used to get the notify/get the completions. The real-time signals that are going to be used with this Proactor should be given apriori in the constructor, so that those signals can be masked from asynchornous delivery
ACE_POSIX_Wakeup_Completion |
ACE_Predefined_Naming_Contexts | A factory for predefined registries, which exist by default on Win32 platforms
ACE_Priority_Reactor | Implements priority based dispatching
ACE_Proactor | A manager for asynchronous event demultiplexing
ACE_Proactor_Handle_Timeout_Upcall | Functor for <ACE_Timer_Queue>
ACE_Proactor_Impl | A manager for asynchronous event demultiplexing. This class is the base class for all the concrete implementation classes
ACE_Proactor_Timer_Handler |
ACE_Process | Process
ACE_Process_Descriptor | Information describing each process that's controlled by an <ACE_Process_Manager>
ACE_Process_Manager | Manages a group of processes
ACE_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
ACE_Process_Options | Process Options
ACE_Process_Semaphore | Wrapper for Dijkstra style general semaphores that work across processes
ACE_Process_Strategy< SVC_HANDLER > | Defines the interface for specifying a concurrency strategy for a <SVC_HANDLER> based on multiprocessing
ACE_Profile_Timer | This class provides both a timing mechanism and a mechanism for reporting the resource usage of a process
ACE_Profile_Timer::ACE_Elapsed_Time | Keeps track of the various user, system, and elapsed (real) times
ACE_Protocol_Info |
ACE_QoS | Wrapper class that holds the sender and receiver flow spec information, which is used by IntServ (RSVP) and DiffServ
ACE_QoS_Params | Wrapper class that simplifies the information passed to the QoS enabled <ACE_OS::connect> and <ACE_OS::join_leaf> methods
ACE_QtReactor | An object-oriented event demultiplexor and event handler dispatcher that uses the Qt Library. This class declaration also uses the extension facilities provided by the Qt. So, readers of the class declaration should not be upset with the appearence of the Keywords like Q_OBJECT, private slots etc. They are specific to Qt which uses these as a call back methods implementation mechanism
ACE_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
ACE_RB_Tree_Base |
ACE_RB_Tree_Iterator< EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK > | Implements an iterator for a Red-Black Tree ADT
ACE_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
ACE_RB_Tree_Node< EXT_ID, INT_ID > | Implements a node in a Red-Black Tree ADT
ACE_RB_Tree_Node_Base |
ACE_RB_Tree_Reverse_Iterator< EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK > | Implements a reverse iterator for a Red-Black Tree ADT
ACE_Reactive_MEM_IO |
ACE_Reactive_Strategy< SVC_HANDLER > | Defines the interface for specifying a Reactive concurrency strategy for a SVC_HANDLER
ACE_Reactor | The responsibility of this class is to forward all methods to its delegation/implementation class, e.g., <ACE_Select_Reactor> or <ACE_WFMO_Reactor>
ACE_Reactor_Impl | An abstract class for implementing the Reactor Pattern
ACE_Reactor_Notification_Strategy | Used to notify an ACE_Reactor
ACE_Reactor_Notify | Abstract class for unblocking an <ACE_Reactor_Impl> from its event loop
ACE_Read_Buffer | Efficiently reads an artibrarily 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
ACE_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)
ACE_Read_Guard< ACE_Null_Mutex > |
ACE_Recursive_Thread_Mutex | Implement a C++ wrapper that allows nested acquisition and release of a mutex that occurs in the same thread
ACE_recursive_thread_mutex_t | Implement a thin C++ wrapper that allows nested acquisition and release of a mutex that occurs in the same thread
ACE_Recyclable |
ACE_Recyclable_Handler_Caching_Utility< KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES > | Defines a helper class for the Caching Strategies
ACE_Recyclable_Handler_Cleanup_Strategy< KEY, VALUE, CONTAINER > | Defines a strategy to be followed for cleaning up entries which are svc_handlers from a container
ACE_Recycling_Strategy< SVC_HANDLER > | Defines the interface (and default implementation) for specifying a recycling strategy for a SVC_HANDLER
ACE_Refcountable |
ACE_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
ACE_Refcounted_Auto_Ptr_Rep< X, ACE_LOCK > | An ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK> object incapsulates a pointer to an object of type X. It is pointed to by ACE_Refcounted_Auto_Ptr<X, ACE_LOCK> object[s] and only accessible through them
ACE_Refcounted_Hash_Recyclable< T > |
ACE_Refcounted_Recyclable_Handler_Caching_Utility< KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES > | Defines a helper class for the Caching Strategies
ACE_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
ACE_Reference_Pair< T1, T2 > | Defines a pair that only hold references
ACE_Registry | A Name Server implementation
ACE_Registry::Binding |
ACE_Registry::Binding_Iterator | An iterator
ACE_Registry::Binding_Iterator::Context_Iteration |
ACE_Registry::Binding_Iterator::Iteration_Complete |
ACE_Registry::Binding_Iterator::Iteration_State |
ACE_Registry::Binding_Iterator::Object_Iteration |
ACE_Registry::Name_Component | International string
ACE_Registry::Naming_Context | An context representation
ACE_Registry::Object | An object representation
ACE_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 "key"=hex: binary data
ACE_Remote_Name_Space | Maintaining accesses Remote Name Server Database. Allows to add NameBindings, change them, remove them and resolve NameBindings
ACE_Remove_Node | Remove a Service Node
ACE_Resume_Node | Resume a Service Node
ACE_Reverse_Iterator< T > | Defines the reverse iterator interface
ACE_Reverse_Iterator_Impl< T > | Defines a abstract reverse iterator
ACE_Reverse_Lock< ACE_LOCKING_MECHANISM > | A reverse (or anti) lock
ACE_RW_Mutex | Wrapper for readers/writer locks
ACE_RW_Process_Mutex | Wrapper for readers/writer locks that exist across processes
ACE_RW_Thread_Mutex | Wrapper for readers/writer locks that exist within a process
ACE_Sample_History | Save multiple samples in an array
ACE_Sbrk_Memory_Pool | Make a memory pool that is based on <sbrk(2)>
ACE_Sbrk_Memory_Pool_Options | Helper class for Sbrk Memory Pool constructor options
ACE_Sched_Params | Container for scheduling-related parameters
ACE_Sched_Priority_Iterator | An iterator over the OS-defined scheduling priorities
ACE_Schedule_All_Reactive_Strategy< SVC_HANDLER > | Defines the interface for specifying how to suspend and resume a single-threaded reactive service
ACE_Schedule_All_Threaded_Strategy< SVC_HANDLER > | Defines the interface for specifying how to suspend and resume a multithreaded service
ACE_Scheduling_Strategy< SVC_HANDLER > | Defines the interface for specifying how to suspend and resume a service
ACE_Section_Key_Internal | A base class for internal handles to section keys for configuration implementations
ACE_Section_Key_Win32 | The Win32 registry implementation of an internal section key
ACE_Select_Reactor_Handle_Set | Track handles we are interested for various events
ACE_Select_Reactor_Handler_Repository | Used to map <ACE_HANDLE>s onto the appropriate <ACE_Event_Handler> *
ACE_Select_Reactor_Handler_Repository_Iterator | Iterate through the <ACE_Select_Reactor_Handler_Repository>
ACE_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
ACE_Select_Reactor_Notify | Unblock the <ACE_Select_Reactor> from its event loop
ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN > | An object oriented event demultiplexor and event handler dispatcher
ACE_Select_Reactor_Token_T< ACE_SELECT_REACTOR_MUTEX > | Used as a synchronization mechanism to coordinate concurrent access to a Select_Reactor object
ACE_Semaphore | Wrapper for Dijkstra style general semaphores
ACE_Service_Config | Supplies common server operations for dynamic and static configuration of services
ACE_Service_Handler | This base class defines the interface for the ACE_Asynch_Acceptor to call into when new connection are accepted
ACE_Service_Manager | Provide a standard ACE service for managing all the services configured in an <ACE_Service_Repository>
ACE_Service_Object | Provide the abstract base class common to all service implementations
ACE_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
ACE_Service_Object_Type | Define the methods for handling the configuration of <ACE_Service_Objects>
ACE_Service_Repository | Contains all the services offered by a Service Configurator-based application
ACE_Service_Repository_Iterator | Iterate through the <ACE_Service_Repository>
ACE_Service_Type | Keeps track of information related to the various <ACE_Service_Type_Impl> subclasses
ACE_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>
ACE_Shared_Memory | This base class adapts both System V shared memory and "BSD" mmap to a common API
ACE_Shared_Memory_MM | Shared memory wrapper based on MMAP
ACE_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
ACE_Shared_Memory_Pool::SHM_TABLE |
ACE_Shared_Memory_Pool_Options | Helper class for Shared Memory Pool constructor options
ACE_Shared_Memory_SV | Shared memory wrapper based on System V shared memory
ACE_Shared_Object | Provide the abstract base class used to access dynamic linking facilities
ACE_Sig_Action | C++ wrapper facade for the <sigaction> struct
ACE_Sig_Adapter | Provide an adapter that transforms various types of signal handlers into the scheme used by the <ACE_Reactor>
ACE_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
ACE_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
ACE_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
ACE_Sig_Handlers_Set |
ACE_Sig_Set | Provide a C++ wrapper for the C sigset_t interface
ACE_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
ACE_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)
ACE_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
ACE_SOCK_Acceptor | Defines a factory that creates new <ACE_Stream>s passively
ACE_SOCK_CODgram | Defines the member functions for the ACE_SOCK connected datagram abstraction
ACE_Sock_Connect |
ACE_SOCK_Connector | Defines a factory that actively connects to a remote IP address and TCP port, creating a new `ACE_SOCK_Stream` object
ACE_SOCK_Dgram | Defines the member functions for the ACE_SOCK datagram abstraction
ACE_SOCK_Dgram_Bcast | Defines the member functions for the ACE_SOCK datagram abstraction
ACE_SOCK_Dgram_Mcast | Defines the member functions for the ACE socket wrapper for UDP/IP multicast
ACE_SOCK_Dgram_SC< STREAM > | "Dgram_SC" is short for "Datagram Self-Contained."
ACE_SOCK_IO | Defines the methods for the ACE socket wrapper I/O routines (e.g., send/recv)
ACE_SOCK_Stream | Defines the methods in the <ACE_SOCK_Stream> abstraction
ACE_SPIPE | Defines the member functions for the base class of the ACE_SPIPE abstraction
ACE_SPIPE_Acceptor | Defines the format and interface for the listener side of the ACE_SPIPE_Stream
ACE_SPIPE_Addr | Defines the SVR4 STREAM pipe address family address format
ACE_SPIPE_Addr::SPIPE_Addr | Contains security attributes
ACE_SPIPE_Connector | Defines an active connection factory for the STREAM pipe wrappers
ACE_SPIPE_Stream | Define an ACE_SPIPE_Stream
ACE_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..
ACE_Static_Allocator< POOL_SIZE > | Defines a class that provided a highly optimized memory management scheme for allocating memory statically
ACE_Static_Allocator_Base | Defines a class that provided a highly optimized memory management scheme for allocating memory statically
ACE_Static_Function_Node | Keeps track of the symbol name for a function that is not linked in from a DLL, but is statically linked with the application
ACE_Static_Node | Handle a statically linked node
ACE_Static_Object_Lock | Provide an interface to access a global lock
ACE_Static_Svc_Descriptor | Holds the information necessary to describe a statically linked Svc
ACE_Stats | Provides simple statistical analysis
ACE_Stats_Value | Helper class for ACE_Stats
ACE_Str_Buf | Simple wrapper for STREAM pipes strbuf
ACE_Strategy_Acceptor< SVC_HANDLER, > | Abstract factory for creating a service handler (SVC_HANDLER), accepting into the SVC_HANDLER, and activating the SVC_HANDLER
ACE_Strategy_Connector< SVC_HANDLER, > | Abstract factory for creating a service handler (SVC_HANDLER), connecting the SVC_HANDLER, and activating the SVC_HANDLER
ACE_Stream<> | This class is the primary abstraction for the ASX framework. It is moduled after System V Stream
ACE_Stream_Head<> | Standard module that acts as the head of a ustream
ACE_Stream_Iterator<> | Iterate through an <ACE_Stream>
ACE_Stream_Node | Handle a Stream
ACE_Stream_Tail<> | Standard module that acts as the head of a ustream
ACE_Stream_Type | Define the methods for handling the configuration of <ACE_Streams>
ACE_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
ACE_Streambuf_T< STREAM > |
ACE_String_Base< CHAR > | This class provides a wrapper facade for C strings
ACE_String_Base_Const | This class defines a constant for ACE_String_Base to circumvent a bug in SunCC 6.0
ACE_StringCapEntry | This class implement the ACE String Capability subclass
ACE_Strong_Bound_Ptr< X, ACE_LOCK > | This class implements support for a reference counted pointer. Assigning or copying instances of an ACE_Strong_Bound_Ptr will automatically increment the reference count of the underlying object. When the last instance of an ACE_Strong_Bound_Ptr that references a particular object is destroyed or overwritten, it will invoke delete on its underlying pointer
ACE_Sub_Barrier |
ACE_Suspend_Node | Suspend a Service Node
ACE_SV_Message | Defines the header file for the C++ wrapper for message queues
ACE_SV_Message_Queue | Defines the header file for the C++ wrapper for System V IPC message queues
ACE_SV_Semaphore_Complex | This is a more complex semaphore wrapper that handles race conditions for initialization correctly..
ACE_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)
ACE_SV_Shared_Memory | This is a wrapper for System V shared memory
ACE_Svc_Conf_Lexer_Guard | "Guard" that ensures lexer buffer switching is exception-safe
ACE_Svc_Conf_Param | An instance of this object will be passed down to the yyparse() and yylex() functions
ACE_Svc_Handler<, > | Defines the interface for a service that exchanges data with its connected peer
ACE_Svc_Tuple< SVC_HANDLER > | Holds the ACE_Svc_Handler and its argument and <ACE_Timer_Handle> until an asynchronous connection completes
ACE_Synch_Options | Contains the values of options used to determine the synchronous and asynchronous behavior
ACE_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
ACE_Task<> | Primary interface for application message processing, as well as input and output message queueing
ACE_Task_Base | Direct base class for the ACE_Task template
ACE_Task_Flags | These flags are used within the ACE_Task
ACE_Test_and_Set< ACE_LOCK, TYPE > | Implements the classic ``test and set'' operation
ACE_Thread | Provides a wrapper for threads
ACE_Thread_Adapter | Converts a C++ function into a function <ace_thread_adapter> 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>
ACE_Thread_Barrier | Implements "barrier synchronization" using ACE_Thread_Mutexes!
ACE_Thread_Condition< MUTEX > | ACE_Condition variable wrapper that works within processes
ACE_Thread_Control | Used to keep track of a thread's activities within its entry point function
ACE_Thread_Descriptor | Information for controlling threads that run under the control of the <Thread_Manager>
ACE_Thread_Descriptor_Base | Basic information for thread descriptors. These information gets extracted out because we need it after a thread is terminated
ACE_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.)
ACE_Thread_Exit_Maybe | A version of ACE_Thread_Exit that is created dynamically under the hood if the flag is set to TRUE
ACE_Thread_Hook | This class makes it possible to provide user-defined "start" hooks that are called before the thread entry point function is invoked
ACE_Thread_ID | Defines a platform-independent thread ID
ACE_Thread_Manager | Manages a pool of threads
ACE_Thread_Mutex | ACE_Thread_Mutex wrapper (only valid for threads in the same process)
ACE_Thread_Semaphore | Wrapper for Dijkstra style general semaphores that work only within one process
ACE_Thread_Strategy< SVC_HANDLER > | Defines the interface for specifying a concurrency strategy for a <SVC_HANDLER> based on multithreading
ACE_Thread_Timer_Queue_Adapter< TQ > | Adapts a Timer_Queue using a separate thread for dispatching
ACE_Throughput_Stats | A simple class to make throughput and latency analysis
ACE_Thru_Task<> | Standard module that acts as a "no op", simply passing on all data to its adjacent neighbor
ACE_Time_Request | Message format for delivering requests to the ACE_Time Server
ACE_Time_Request::Transfer |
ACE_Time_Value | Operations on "timeval" structures, which express time in <secs> and <usecs>
ACE_Timer_Hash_Iterator_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET > | Iterates over an <ACE_Timer_Hash>
ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET > | Provides a hash table of <BUCKET>s as an implementation for a timer queue
ACE_Timer_Hash_Upcall< TYPE, FUNCTOR, ACE_LOCK > | Functor for Timer_Hash
ACE_Timer_Heap_Iterator_T< TYPE, FUNCTOR, ACE_LOCK > | Iterates over an <ACE_Timer_Heap_T>
ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK > | Provides a very fast and predictable timer implementation
ACE_Timer_List_Iterator_T< TYPE, FUNCTOR, ACE_LOCK > | Iterates over an <ACE_Timer_List>
ACE_Timer_List_T< TYPE, FUNCTOR, ACE_LOCK > | Provides a simple implementation of timers
ACE_Timer_Node_Dispatch_Info_T< TYPE > | Maintains generated dispatch information for Timer nodes
ACE_Timer_Node_T< TYPE > | Maintains the state associated with a Timer entry
ACE_Timer_Queue_Iterator_T< TYPE, FUNCTOR, ACE_LOCK > | Generic interface for iterating over a subclass of <ACE_Timer_Queue>
ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK > | Provides an interface to timers
ACE_Timer_Wheel_Iterator_T< TYPE, FUNCTOR, ACE_LOCK > | Iterates over an <ACE_Timer_Wheel>
ACE_Timer_Wheel_T< TYPE, FUNCTOR, ACE_LOCK > | Provides a Timing Wheel version of Timer Queue
ACE_TkReactor | An object-oriented event demultiplexor and event handler dispatcher that uses the Tk functions
ACE_TkReactor_Input_Callback |
ACE_TkReactorID | This little class is necessary due to the way that Microsoft implements sockets to be pointers rather than indices
ACE_TLI | Defines the member functions for the base class of the ACE_TLI abstraction
ACE_TLI_Acceptor | Defines the member functions for ACE_TLI_Acceptor abstraction
ACE_TLI_Connector | Defines an active connection factory for the ACE_TLI C++ wrappers
ACE_TLI_Request |
ACE_TLI_Request_Queue |
ACE_TLI_Stream | Defines the member functions for ACE_TLI_Stream abstraction
ACE_Token | Class that acquires, renews, and releases a synchronization token that is serviced in strict FIFO ordering and that also supports (1) recursion and (2) readers/writer semantics
ACE_Token::ACE_Token_Queue |
ACE_Token::ACE_Token_Queue_Entry |
ACE_Tokenizer | Tokenizer
ACE_Tokenizer::Delimiter_Entry | Delimiter Entry
ACE_Tokenizer::Preserve_Entry | Preserve Entry
ACE_TP_Reactor | Specialization of Select Reactor to support thread-pool based event dispatching
ACE_TP_Token_Guard | A helper class that helps grabbing, releasing and waiting on tokens for a thread that tries calling handle_events ()
ACE_Trace | A C++ trace facility that keeps track of which methods are entered and exited
ACE_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
ACE_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. Needed by the "frigging" MVS C++ compiler
ACE_TSS_Cleanup |
ACE_TSS_Info | Thread Specific Key management
ACE_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
ACE_TSS_Ref | "Reference count" for thread-specific storage keys
ACE_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
ACE_TSS_Type_Adapter< TYPE > | Adapter that allows built-in types to be used with ACE_TSS
ACE_TTY_IO | Class definitions for platform specific TTY features
ACE_TTY_IO::Serial_Params |
ACE_Typed_SV_Message< T > | Defines the header file for the C++ wrapper for System V message queues
ACE_Typed_SV_Message_Queue< T > | Defines the header file for the C++ wrapper facade for typed message queues
ACE_Unbounded_Queue< T > | A Queue of "infinite" length
ACE_Unbounded_Queue_Const_Iterator< T > | Implement an iterator over an const unbounded queue
ACE_Unbounded_Queue_Iterator< T > | Implement an iterator over an unbounded queue
ACE_Unbounded_Set< T > | Implement a simple unordered set of <T> of unbounded size
ACE_Unbounded_Set_Const_Iterator< T > | Implement an const iterator over an unbounded set
ACE_Unbounded_Set_Iterator< T > | Implement an iterator over an unbounded set
ACE_Unbounded_Stack< T > | Implement a generic LIFO abstract data type
ACE_Unbounded_Stack_Iterator< T > | Implement an iterator over an unbounded Stack
ACE_UNIX_Addr | Defines the ``UNIX domain address family'' address format
ACE_Unmanaged_Singleton< TYPE, ACE_LOCK > | Same as <ACE_Singleton>, except does _not_ register with <ACE_Object_Manager> for destruction
ACE_Unmanaged_TSS_Singleton< TYPE, ACE_LOCK > | Same as <ACE_TSS_Singleton>, except does _not_ register with <ACE_Object_Manager> for destruction
ACE_UPIPE_Acceptor | Defines the format and interface for the listener side of the ACE_UPIPE_Stream
ACE_UPIPE_Connector | Defines an active connection factory for the <ACE_UPIPE_STREAM> wrappers
ACE_UPIPE_Stream | Defines the method that transfer data on a UPIPE
ACE_Vector< T, DEFAULT_SIZE > | Defines an STL-like vector container
ACE_Wakeup_All_Threads_Handler | This is a helper class whose sole purpose is to handle events on <ACE_WFMO_Reactor->wakeup_all_threads_>
ACE_WChar_Codeset_Translator | Codeset translation routines common to both Output and Input CDR streams
ACE_Weak_Bound_Ptr< X, ACE_LOCK > | This class implements support for a weak pointer that complements ACE_Strong_Bound_Ptr. Unlike ACE_Strong_Bound_Ptr, assigning or copying instances of an ACE_Weak_Bound_Ptr will not automatically increment the reference count of the underlying object. What ACE_Weak_Bound_Ptr does is preserve the knowledge that the object is in fact reference counted, and thus provides an alternative to raw pointers where non-ownership associations must be maintained. When the last instance of an ACE_Strong_Bound_Ptr that references a particular object is destroyed or overwritten, the corresponding ACE_Weak_Bound_Ptr instances are set to null
ACE_WFMO_Reactor | An object oriented event demultiplexor and event handler WFMO_Reactor for Win32 WaitForMultipleObjects
ACE_WFMO_Reactor_Handler_Repository | Used to map <ACE_HANDLE>s onto the appropriate <ACE_Event_Handler> * and other information
ACE_WFMO_Reactor_Handler_Repository::Common_Info | This struct contains the necessary information for every <Event_Handler> entry. The reason the event is not in this structure is because we need to pass an event array into WaitForMultipleObjects and therefore keeping the events seperate makes sense
ACE_WFMO_Reactor_Handler_Repository::Current_Info | This structure inherits from the common structure to add information for current entries
ACE_WFMO_Reactor_Handler_Repository::Suspended_Info | This structure inherits from the common structure to add information for suspended entries
ACE_WFMO_Reactor_Handler_Repository::To_Be_Added_Info | This structure inherits from the common structure to add information for <to_be_added> entries
ACE_WFMO_Reactor_Notify | Unblock the <ACE_WFMO_Reactor> from its event loop, passing it an optional <ACE_Event_Handler> to dispatch
ACE_WIN32_Asynch_Accept | This class is a factory for starting off asynchronous accepts on a listen handle
ACE_WIN32_Asynch_Accept_Result | This class implements ACE_Asynch_Accept::Result for WIN32 platform
ACE_WIN32_Asynch_Operation | This class abstracts out the common things needed for implementing Asynch_Operation for WIN32 platform
ACE_WIN32_Asynch_Read_Dgram | This class is a factory for starting off asynchronous reads on a UDP socket
ACE_WIN32_Asynch_Read_Dgram_Result | This is class provides concrete implementation for ACE_Asynch_Read_Dgram::Result class
ACE_WIN32_Asynch_Read_File | This class is a factory for starting off asynchronous reads on a file
ACE_WIN32_Asynch_Read_File_Result | This is class provides concrete implementation for ACE_Asynch_Read_File::Result class
ACE_WIN32_Asynch_Read_Stream | This class is a factory for starting off asynchronous reads on a stream
ACE_WIN32_Asynch_Read_Stream_Result | This is class provides concrete implementation for ACE_Asynch_Read_Stream::Result class
ACE_WIN32_Asynch_Result | An abstract class which adds information to the OVERLAPPED structure to make it more useful
ACE_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
ACE_WIN32_Asynch_Transmit_File | This class is a factory for starting off asynchronous transmit files on a stream
ACE_WIN32_Asynch_Transmit_File_Result | This class implements ACE_Asynch_Transmit_File::Result for WIN32 platforms
ACE_WIN32_Asynch_Write_Dgram | This class is a factory for starting off asynchronous writes on a UDP socket
ACE_WIN32_Asynch_Write_Dgram_Result | This is class provides concrete implementation for ACE_Asynch_Write_Dgram::Result class
ACE_WIN32_Asynch_Write_File | This class is a factory for starting off asynchronous writes on a file
ACE_WIN32_Asynch_Write_File_Result | This class provides implementation for ACE_Asynch_Write_File_Result for WIN32 platforms
ACE_WIN32_Asynch_Write_Stream | This class is a factory for starting off asynchronous writes on a stream
ACE_WIN32_Asynch_Write_Stream_Result | This is class provides concrete implementation for ACE_Asynch_Write_Stream::Result class
ACE_WIN32_Proactor | A manager for asynchronous event demultiplexing
ACE_WIN32_Wakeup_Completion |
ACE_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)
ACE_Write_Guard< ACE_Null_Mutex > |
ACE_XtReactor | An object-oriented event demultiplexor and event handler dispatcher that uses the X Toolkit functions
ACE_XtReactorID | This little class is necessary due to the way that Microsoft implements sockets to be pointers rather than indices
ace_yy_buffer_state |
ACE_YYSTYPE |
ACMM |
auto_ptr< X > | Implements the draft C++ standard auto_ptr abstraction
cancel_state |
dirent |
Hash_Token |
iovec |
ip_mreq |
msghdr |
msqid_ds |
rusage |
semun |
shmaddr |
siginfo_t |
strbuf |
timespec |