| _WSANETWORKEVENTS | |
| 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_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 | This class manages the notify pipe of the AIOCB Proactor |
| 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 ACE_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 | Builds a counted argument vector (ala argc/argv) from either a string or a set of separate tokens. Can substitute environment variable values for tokens that are environment variable references |
| ACE_Argv_Type_Converter | To convert 'char' input/command line parameter to 'wchar_t' |
| ACE_Array< T > | 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_Array_Map< Key, Value, EqualTo > | Light weight array-based map with fast iteration, but linear (i.e. O(n)) search times |
| 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_Accept_Impl | Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Accept |
| ACE_Asynch_Accept_Result_Impl | Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Accept |
| 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_Connect | This class is a factory for starting off asynchronous connects This class forwards all methods to its implementation class |
| ACE_Asynch_Connect::Result | This is that class which will be passed back to the handler when the asynchronous connect completes |
| ACE_Asynch_Connect_Impl | Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Connect |
| ACE_Asynch_Connect_Result_Impl | Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Connect |
| ACE_Asynch_Connector< HANDLER > | This class is an example of the Connector pattern. This class will establish new connections and create new HANDLER objects to handle the new connections |
| 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_Operation_Impl | Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Operation |
| ACE_Asynch_Pseudo_Task | |
| 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_Dgram_Impl | Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Read_Dgram |
| ACE_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 |
| 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_File_Impl | Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Read_File::Result |
| ACE_Asynch_Read_File_Result_Impl | This is the abstract base class for all the concrete implementation classes for ACE_Asynch_Read_File::Result |
| 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_Read_Stream_Impl | Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Read_Stream |
| ACE_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 |
| ACE_Asynch_Result | An interface base class which allows users access to common information related to an asynchronous operation |
| ACE_Asynch_Result_Impl | Abstract base class for the all the classes that provide concrete implementations for ACE_Asynch_Result |
| 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_Transmit_File_Impl | Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Transmit_File |
| ACE_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 |
| 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_Dgram_Impl | Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Write_Dgram class |
| ACE_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 |
| 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_File_Impl | Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Write_File |
| ACE_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 |
| 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_Asynch_Write_Stream_Impl | Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Write_Stream class |
| ACE_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 |
| ACE_At_Thread_Exit | Contains a method to be applied when a thread is terminated |
| ACE_At_Thread_Exit_Func | |
| ACE_ATM_Acceptor | Defines the member functions for ACE_ATM_Acceptor abstraction |
| ACE_ATM_Addr | Defines the ATM domain address family address format |
| ACE_ATM_Connector | Defines an active connection factory for the ACE_ATM C++ wrappers |
| ACE_ATM_Params | Wrapper class that simplifies the information passed to the ATM enabled ACE_ATM_Connector class |
| ACE_ATM_QoS | Define the QoS parameters for ATM |
| ACE_ATM_Stream | Defines the member functions for ACE_ATM_Stream abstraction |
| ACE_Atomic_Op< ACE_LOCK, TYPE > | Transparently parameterizes synchronization into basic arithmetic operations |
| 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_Ptr< X > | Implements the draft C++ standard auto_ptr abstraction. This version can be used instead of auto_ptr<T>, and obviates the need for the ACE_AUTO_PTR_RESET macro on platforms like VC6 where the auto_ptr<T> is broken |
| ACE_Auto_String_Free | Simple class to automatically de-allocate strings |
| ACE_Barrier | Implements "barrier synchronization" |
| ACE_Base64 | Encode/Decode a stream of bytes according to Base64 encoding |
| 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 | Implementation for the ACE_Based_Pointer_Repository |
| 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 |
| 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< KEY, VALUE, CMAP_TYPE, ITERATOR_IMPL, REVERSE_ITERATOR_IMPL, CACHING_STRATEGY, ATTRIBUTES > | 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 > | A fixed-size allocator that caches items for quicker access |
| 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 | For maintaining a list of ACE_Cleanup_Info items |
| 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_Codeset_Registry | |
| ACE_Codeset_Registry::registry_entry | |
| 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< 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 |
| ACE_Condition_Attributes | |
| ACE_Condition_Recursive_Thread_Mutex | |
| 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 | Reference 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_Connector_Base< SVC_HANDLER > | This base interface allows ACE_NonBlocking_Connect_Handler to only care about the SVC_HANDLER template parameter of the ACE_Connector. Otherwise, ACE_NonBlocking_Connect_Handler would have to be configured with all the template parameters that ACE_Connector is configured with |
| 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_Copy_Disabled | Helper class to disable copy construction and assignment |
| 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_Dev_Poll_Event_Tuple | Class that associates specific event mask with a given event handler |
| ACE_Dev_Poll_Handler_Guard | Class used to make event handler reference count manipulation exception-safe |
| ACE_Dev_Poll_Reactor | A `/dev/poll' or `/dev/epoll' based Reactor implemenatation |
| ACE_Dev_Poll_Reactor::Token_Guard | A helper class that helps grabbing, releasing and waiting on tokens for a thread that needs access to the reactor's token |
| ACE_Dev_Poll_Reactor_Handler_Repository | Used to map ACE_HANDLEs onto the appropriate ACE_Event_Handler * |
| ACE_Dev_Poll_Reactor_Notify | Event handler used for unblocking the ACE_Dev_Poll_Reactor from its event loop |
| ACE_Dirent | Define a portable C++ directory-entry iterator based on the POSIX API |
| ACE_Dirent_Selector | Define a portable C++ directory-entry iterator based on the POSIX scandir API |
| ACE_DLL | Provides an abstract interface for handling various DLL operations |
| ACE_DLL_Handle | Provides an abstract interface for handling various DLL operations |
| ACE_DLL_Manager | This class is a singleton and serves as a factory and repository for instances of ACE_DLL_Handle |
| ACE_DLL_Singleton_Adapter_T< TYPE > | |
| ACE_DLL_Singleton_T< TYPE, ACE_LOCK > | Same as ACE_Singleton, except that it registers for destruction with the ACE_Framework_Repository instead of with the ACE_Object_Manager directly |
| 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_Cached_Allocator< ACE_LOCK > | A size-based allocator that caches blocks for quicker access |
| 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 > | Environment Variable Value |
| ACE_Equal_To< TYPE > | Function object for comparing two objects of the given type for equality |
| ACE_Equal_To< ACE_CString > | Function object for determining whether two ACE_CStrings are equal |
| ACE_Equal_To< ACE_INT16 > | Function object for determining whether two 16 bit ints are equal |
| ACE_Equal_To< ACE_INT32 > | Function object for determining whether two 32 bit ints are equal |
| ACE_Equal_To< ACE_UINT16 > | Function object for determining whether two unsigned 16 bit ints are equal |
| ACE_Equal_To< ACE_UINT32 > | Function object for determining whether two unsigned 32 bit ints are equal |
| ACE_Equal_To< ACE_UINT64 > | Function object for determining whether two unsigned 64 bit ints are equal |
| ACE_Equal_To< char * > | Function object for determining whether two non-const strings are equal |
| ACE_Equal_To< const char * > | Function object for determining whether two const strings are equal |
| ACE_Equal_To< const wchar_t * > | Function object for determining whether two const strings are equal |
| ACE_Equal_To< wchar_t * > | Function object for determining whether two non-const strings are equal |
| 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_Descriptions | Event Descriptions |
| ACE_Event_Handler | Provides an abstract interface for handling various types of I/O, timer, and signal events |
| ACE_Event_Handler::Policy | Base class for all handler policies |
| ACE_Event_Handler::Reference_Counting_Policy | This policy dictates the reference counting requirements for the handler |
| ACE_Event_Handler_Handle_Timeout_Upcall< ACE_LOCK > | Functor for Timer_Queues |
| ACE_Event_Handler_T< T > | Enable a class that doesn't inherit from the ACE_Event_Handler to be incorporated into the ACE_Reactor framework. Thanks to Greg Lavender (g.lavender@isode.com) for sharing this idea |
| ACE_Event_Handler_var | Auto pointer like class for Event Handlers |
| 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_Set_Iterator_Base< T, ACE_SIZE > | Implements a common base class for iterators for a unordered set |
| ACE_Fixed_Stack< T, ACE_SIZE > | Implement a generic LIFO abstract data type |
| ACE_OS::ace_flock_t | OS file locking structure |
| 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_Function_Node | Keeps track of the symbol name of for a shared function |
| ACE_Function_Timeprobe< Timeprobe > | Auto pointer like time probes. It will record <event> on construction and <event + 1> on destruction |
| 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 that holds an 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_Handle_Gobbler | This class gobbles up handles |
| 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::Proxy | The Proxy class 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 |
| 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< ACE_CString > | Function object for hashing a ACE_CString |
| ACE_Hash< ACE_INT64 > | Function object for hashing a signed 64-bit number |
| ACE_Hash< ACE_UINT64 > | Function object for hashing an unsigned 64-bit number |
| ACE_Hash< char * > | Function object for hashing a string |
| ACE_Hash< char > | Function object for hashing a char |
| ACE_Hash< const char * > | Function object for hashing a const string |
| ACE_Hash< const wchar_t * > | Function object for hashing a const string |
| ACE_Hash< int > | Function object for hashing an int number |
| ACE_Hash< long > | Function object for hashing a long number |
| ACE_Hash< short > | Function object for hashing a short number |
| ACE_Hash< signed char > | Function object for hashing a signed char |
| ACE_Hash< unsigned char > | Function object for hashing an unsigned char |
| ACE_Hash< unsigned int > | Function object for hashing an unsigned int number |
| ACE_Hash< unsigned long > | Function object for hashing an unsigned long number |
| ACE_Hash< unsigned short > | Function object for hashing an unsigned short number |
| ACE_Hash< void * > | Function object for hashing a void * |
| ACE_Hash< wchar_t * > | Function object for hashing a string |
| ACE_Hash< wchar_t > | Function object for hashing a wchar_t |
| 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_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_ICMP_Socket | An abstract class that forms the basis for usage of the ICMP protocol (that is, support for things such as ping) |
| 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_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 | |
| 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_Less_Than< ACE_CString > | Function object for determining whether the first const string is less than the second const string |
| ACE_Less_Than< char * > | Function object for determining whether the first string is less than the second string |
| ACE_Less_Than< const char * > | Function object for determining whether the first const string is less than the second const string |
| ACE_Less_Than< const wchar_t * > | Function object for determining whether the first const string is less than the second const string |
| ACE_Less_Than< wchar_t * > | Function object for determining whether the first string is less than the second string |
| 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_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_Mutex | Class that acquires, renews, and releases a synchronization token local to the process |
| ACE_Local_Name_Space<, ACE_LOCK > | Maintaining accesses Local Name Server Database. Allows to add NameBindings, change them, remove them and resolve NameBindings |
| ACE_Local_RLock | Class that acquires, renews, and releases a readers lock that is local to the process |
| ACE_Local_WLock | Class that acquires, renews, and releases a writer lock that is local to the process |
| 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 | Synchronize output operations |
| ACE_Log_Msg_NT_Event_Log | Implements an ACE_Log_Msg_Backend that logs to the WinNT system event log |
| ACE_Log_Msg_UNIX_Syslog | Implements an ACE_Log_Msg_Backend that logs messages to a UNIX system's syslog facility |
| 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_Lock_Adapter_T< ACE_LOCK > | Template functor adapter for lock strategies used with ACE_Malloc_T |
| ACE_Malloc_Lock_Adapter_T< ACE_Null_Mutex > | |
| ACE_Malloc_Lock_Adapter_T< ACE_Process_Semaphore > | Template specialization of ACE_Malloc_Lock_Adapter_T for ACE_Process_Semaphore |
| ACE_Malloc_Lock_Adapter_T< ACE_Thread_Semaphore > | Template specialization of ACE_Malloc_Lock_Adapter_T for ACE_Thread_Semaphore |
| 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_max_align_info | |
| 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 in an ACE_Message_Queue) |
| ACE_Message_Queue<> | A message queueing facility with parameterized synchronization capability. ACE_Message_Queue is 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 must provide the necessary state and behavior |
| ACE_Metrics_Cache< ACE_LOCK, ALLOCATOR > | This class implements a cache for metrics timeprobe data |
| ACE_Metrics_Timeprobe< ACE_LOCK, ALLOCATOR > | This class implements a timeprobe for use in a Metrics framework |
| 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_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 |
| ACE_Multihomed_INET_Addr | Extends ACE_INET_Addr with support for multi-homed addresses |
| ACE_Mutex | ACE_Mutex wrapper (valid in same process or across processes (depending on TYPE flag)) |
| ACE_Mutex_Invariants | Mutex Invariants = INVARIANTS 1. Only one owner at a time |
| ACE_Mutex_Token | Class that acquires, renews, and releases a process-local synchronization token |
| 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_NonBlocking_Connect_Handler< SVC_HANDLER > | Performs non-blocking connects on behalf of the Connector |
| 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 ACE_Naming_Context 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_NULL_SYNCH | Implement a do nothing Synchronization wrapper that typedefs the ACE_Condition and ACE_Mutex to the Null* versions |
| ACE_Null_Token | No op class for nonthreaded platform protocols |
| 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 | Ensure that the ACE_Object_Manager gets initialized at program startup, and destroyed at program termination |
| ACE_Object_Manager_Preallocations | Performs preallocations of certain statically allocated services needed by ACE |
| ACE_Object_Node | Keeps track of the symbol name for a shared object |
| ACE_Obstack_T< CHAR > | Define a simple "mark and release" memory allocation utility |
| 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. The set is implemented as a linked list |
| 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_Exit_Info | Hold Object Manager cleanup (exit) information |
| ACE_OS_Log_Msg_Attributes | The attributes required by ACE_Log_Msg |
| ACE_OS_Object_Manager | |
| ACE_OS_Object_Manager_Manager | Ensure that the ACE_OS_Object_Manager gets initialized at program startup, and destroyed at program termination |
| ACE_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 |
| 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_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_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 |
| ACE_Pipe | Provides a portable bidirectional "pipe" abstraction |
| 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_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 | For the POSIX implementation this class is common for all Proactors (AIOCB/SIG/SUN) |
| 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_Connect | |
| ACE_POSIX_Asynch_Connect_Result | This is that class which will be passed back to the completion handler when the asynchronous connect completes |
| ACE_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 |
| ACE_POSIX_Asynch_Read_Dgram | This class is a factory for starting off asynchronous reads on a UDP socket |
| ACE_POSIX_Asynch_Read_Dgram_Result | This is class provides concrete implementation for ACE_Asynch_Read_Dgram::Result class |
| ACE_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 |
| 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 | |
| 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 | Implementation for transmit_file will make use of POSIX_Asynch_Transmit_Handler |
| 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 | Auxillary handler for doing <asynch_transmit_file> in Unix. <ace_posix_asynch_transmit_file> internally uses this |
|