| _dbghelp_functions | |
| _WSANETWORKEVENTS | |
| ACE_Abstract_Timer_Queue< TYPE > | Base class for all timer queues of a single type |
| ACE_Accept_QoS_Params | Wrapper class that simplifies the information passed to the QoS enabled <ACE_OS::accept> method |
| ACE_Accept_Strategy< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 > | Defines the interface for specifying a passive connection acceptance strategy for a SVC_HANDLER |
| ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 > | Abstract factory for creating a service handler (SVC_HANDLER), accepting into the SVC_HANDLER, and activating the SVC_HANDLER |
| 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_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_T< CHAR_TYPE > | This ADT operates on a specified set of arguments (argv). As known arguments are scanned, they are shifted to the back of the argv vector, so deeper levels of argument parsing can locate the yet unprocessed arguments at the beginning of the vector |
| ACE_ARGV_Queue_Entry_T< CHAR_TYPE > | An entry in the queue which keeps user supplied arguments |
| ACE_ARGV_T< CHAR_TYPE > | Builds a counted argument vector (ala argc/argv) from either a string or a set of separate tokens. This class preserves whitespace within tokens only if the whitespace-containing token is enclosed in either single (') or double (") quotes. This is consistent with the expected behavior if an argument vector obtained using this class is passed to, for example, ACE_Get_Opt |
| 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_Ascii_To_Wide | A lightweight char* to wchar* string conversion class |
| ACE_Async_Timer_Queue_Adapter< TQ, TYPE > | Adapts an ACE timer queue to be driven asynchronously using signals |
| 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_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_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_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_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_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_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_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_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 initiating asynchronous writes on a connected TCP/IP stream. This class forwards all methods to its 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> |
| ACE_Auto_String_Free | Simple class to automatically de-allocate strings |
| ACE_bad_alloc_class | |
| 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, ACE_PEER_CONNECTOR_1, CACHING_STRATEGY, ATTRIBUTES, MUTEX > | A connection strategy which caches connections to peers (represented by SVC_HANDLER instances), thereby allowing subsequent re-use of unused, but available, connections. This strategy should be used when the cache is bounded by maximum size |
| ACE_Bounded_Set< T > | Implement a simple unordered set of {T} with maximum set at creation time |
| 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< ACE_PEER_STREAM_1, ACE_SYNCH_DECL > | 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, ACE_PEER_CONNECTOR_1, MUTEX > | A connection strategy which caches connections to peers (represented by SVC_HANDLER instances), thereby allowing subsequent re-use of unused, but available, connections |
| ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER, ACE_PEER_CONNECTOR_1, CACHING_STRATEGY, ATTRIBUTES, MUTEX > | A connection strategy which caches connections to peers (represented by SVC_HANDLER instances), thereby allowing subsequent re-use of unused, but available, connections |
| 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_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_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_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, ACE_PEER_CONNECTOR_1 > | 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, ACE_PEER_CONNECTOR_1 > | 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_Copy_Disabled | Helper class to disable copy construction and assignment |
| ACE_Countdown_Time | Keeps track of the amount of elapsed time |
| ACE_Countdown_Time_T< TIME_POLICY > | |
| 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_Delegating_Time_Policy | Implement a time policy that delegates to a dynamic time policy |
| 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_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_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_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< ACE_SYNCH_DECL > | A derived class which adapts the ACE_Message_Queue class in order to maintain dynamic priorities for enqueued <ACE_Message_Blocks> and manage the queue order according to these dynamic priorities |
| 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_Blocks dynamically |
| 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_Dynamic_Service_Dependency | Provides a way to declare dependency on specific service, thus helping to avoid order of initialization issues with instances of an objects whose implementation code resides in dynamically loaded services |
| ACE_Dynamic_Time_Policy_Base | |
| ACE_Dynamic_Time_Policy_base | Abstract base class for dynamically loaded and/or shared time policies |
| ACE_EH_Dispatch_Info | This structure contains information of the activated event handler |
| ACE_Profile_Timer::ACE_Elapsed_Time | Keeps track of the various user, system, and elapsed (real) times |
| 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< std::string > | Function object for determining whether two std::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_Handler | Provides an abstract interface for handling various types of I/O, timer, and signal events |
| ACE_Event_Handler_Handle_Timeout_Upcall | 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_FPointer_Time_Policy | |
| ACE_FPointer_Timer_Policy | Implement a time policy based on a function pointer |
| 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_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 that allows the values of a collection of ACE_Future objects to be accessed by reader threads as they become available. The caller(s) provide the ACE_Future_Set (i.e. the observer...) with the collection of ACE_Future objects (i.e. the subjects...) that are to be observed using the the ACE_Future_Set::insert() method. The caller(s) may then iterate over the collection in the order in which they become readable using the ACE_Future_Set::next_readable() method |
| 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 acquisition 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_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< std::string > | Function object for hashing a std::string |
| 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_Const_Reverse_Iterator_Ex< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK > | Const reverse 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 type objects with INT_ID type objects |
| 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_Hash_Multi_Map_Bucket_Iterator< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK > | Forward iterator for the ACE_Hash_Multi_Map_Manager which only traverses a particular bucket. The particular bucket is specified by the EXT_ID parameter specified in the constructor |
| ACE_Hash_Multi_Map_Const_Iterator< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK > | Const forward iterator for the ACE_Hash_Multi_Map_Manager |
| ACE_Hash_Multi_Map_Const_Iterator_Base< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK > | Base const iterator for the ACE_Hash_Multi_Map_Manager |
| ACE_Hash_Multi_Map_Entry< EXT_ID, INT_ID > | Define an entry in the hash table |
| ACE_Hash_Multi_Map_Iterator< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK > | Forward iterator for the ACE_Hash_Multi_Map_Manager |
| ACE_Hash_Multi_Map_Iterator_Base< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK > | Base iterator for the ACE_Hash_Multi_Map_Manager |
| ACE_Hash_Multi_Map_Manager< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK > | Define a multi-map abstraction that efficiently associates the keys with their different values |
| ACE_Hash_Multi_Map_Reverse_Iterator< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK > | Reverse iterator for the ACE_Hash_Multi_Map_Manager |
| 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_HR_Time_Policy | Implement a time policy based on the ACE Highres timer |
| 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 demarshalling CDR-encoded data |
| ACE_IntCapEntry | This class implement the ACE Integer Capability subclass |
| ACE_Intrusive_Auto_Ptr< X > | This class implements support for a reference counted auto_ptr. It assumes reference counting abilities of the parameterizing class |
| 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< std::string > | 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_MEM_POOL_1, 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_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 | Defines the interface for ACE_Log_Msg back end processing |
| 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 a way to dynamically configure the ACE logging mechanism at run time as well as enable the mechanisms for limiting log file size and log file backup/rotation capability |
| 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 a fully specified (sometimes called "connected") UNIX-domain 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_MEM_POOL_1, ACE_LOCK > | |
| ACE_Malloc_FIFO_Iterator< ACE_MEM_POOL_1, ACE_LOCK > | |
| ACE_Malloc_FIFO_Iterator_T< ACE_MEM_POOL_1, ACE_LOCK, ACE_CB > | FIFO iterator for names stored in Malloc'd memory |
| 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_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_Malloc_LIFO_Iterator< ACE_MEM_POOL_1, ACE_LOCK > | |
| ACE_Malloc_LIFO_Iterator_T< ACE_MEM_POOL_1, 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 > | Template specialization of ACE_Malloc_Lock_Adapter_T for the 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_MEM_POOL_1, ACE_LOCK, ACE_CB > | A class template that uses parameterized types to provide an extensible mechanism for encapsulating various dynamic memory management strategies |
| 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_IDs with INT_IDs |
| 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_Member_Function_Command< RECEIVER > | Defines a class template that allows us to invoke a member function using the GoF command style callback |
| ACE_Message_Block | Stores messages for use throughout ACE (particularly in an ACE_Message_Queue) |
| ACE_Message_Queue< ACE_SYNCH_DECL > | A message queueing facility with parameterized synchronization capability. ACE_Message_Queue is modeled after the queueing facilities in System V STREAMs |
| 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, ACE_SYNCH_DECL > | A threaded message queueing facility, modeled after the queueing facilities in System V STREAMs |
| ACE_Message_Queue_Ex_Iterator< ACE_MESSAGE_TYPE, ACE_SYNCH_DECL > | Iterator for the ACE_Message_Queue_Ex |
| ACE_Message_Queue_Ex_N< ACE_MESSAGE_TYPE, ACE_SYNCH_DECL > | A threaded message queueing facility, modeled after the queueing facilities in System V STREAMs which can enqueue multiple messages in one call |
| ACE_Message_Queue_Ex_Reverse_Iterator< ACE_MESSAGE_TYPE, ACE_SYNCH_DECL > | |
| ACE_Message_Queue_Factory< ACE_SYNCH_DECL > | ACE_Message_Queue_Factory is a static factory class template which provides a separate factory method for each of the major kinds of priority based message dispatching: static, earliest deadline first (EDF), and minimum laxity first (MLF) |
| ACE_Message_Queue_Iterator< ACE_SYNCH_DECL > | Iterator for the ACE_Message_Queue |
| ACE_Message_Queue_NT | Message Queue implementation using IO completion port on NT |
| ACE_Message_Queue_Reverse_Iterator< ACE_SYNCH_DECL > | 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_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< ACE_SYNCH_DECL > | 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_Log_Cleanup | |
| ACE_Msg_WFMO_Reactor | An OO event demultiplexor and event handler dispatcher for Win32 <MsgWaitForMultipleObjects> |
| ACE_MT_MEM_IO | |
| 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)). In general, however, we recommend using ACE_Process_Mutex or ACE_Thread_Mutex rather than ACE_Mutex |
| 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_PI_Control_Block::ACE_Name_Node | This class supports "named memory regions" within ACE_Malloc |
| ACE_Control_Block::ACE_Name_Node | This class supports "named memory regions" within ACE_Malloc |
| 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_Request | Message format for delivering requests to the ACE_Name Server |
| 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, C > | 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_Command | |
| 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_Masks between threads |
| ACE_Notification_Queue | Implements a user-space queue to send Reactor notifications |
| ACE_Notification_Queue_Node | Helper class |
| 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_Numeric_Limits< T > | |
| 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_Obstack_T< ACE_CHAR_T > | 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_Oneshot_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 > | Generic factory for passively connecting clients and creating exactly one service handler of the type SVC_HANDLER specified in the template |
| 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 marshalling data, most often for transmission to another system which may or may not have the same byte order |
| 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_Options | Helper class for Pagefile Memory Pool constructor options |
| ACE_Pair_Caching_Utility< KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES > | Defines a helper class for the Caching Strategies |
| ACE_PI_Control_Block | This information is stored in memory allocated by the Memory_Pool |
| 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 |
| ACE_POSIX_Asynch_Write_Dgram | This class is a factory for starting off asynchronous writes on a UDP socket. The UDP socket must be "connected", as there is no facility for specifying the destination address on each send operation |
| ACE_POSIX_Asynch_Write_Dgram_Result | |
| ACE_POSIX_Asynch_Write_File | |
| ACE_POSIX_Asynch_Write_File_Result | This class provides implementation for <ACE_Asynch_Write_File_Result> for POSIX platforms |
| ACE_POSIX_Asynch_Write_Stream | This class implements <ACE_Asynch_Write_Stream> for all POSIX implementations of ACE_Proactor |
| ACE_POSIX_Asynch_Write_Stream_Result | This class provides concrete implementation for <ACE_Asynch_Write_Stream::Result> on POSIX platforms |
| ACE_POSIX_CB_Proactor | Implementation of Callback-based Proactor }; |
| ACE_POSIX_Proactor | POSIX implementation of the Proactor |
| 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 | A Handler for timer. It helps in the management of timers registered with the Proactor |
| ACE_Process | Process |
| 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_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_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, where all upcalls to handle_*() methods run in the reactor's thread of control |
| ACE_Reactor | This class forwards 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_Reactor_Timer_Interface | Interface for timer related methods on the Reactor |
| ACE_Reactor_Token_T< ACE_TOKEN_TYPE > | Used as a synchronization mechanism to coordinate concurrent access to an ACE_Reactor_Impl object |
| ACE_Read_Buffer | Efficiently reads an arbitrarily large buffer from an input stream up to and including a termination character. Also performs search/replace on single occurrences a character in the buffer using the principles of Integrated Layer Processing |
| 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 > | Template specialization of ACE_Read)Guard for the ACE_Null_Mutex |
| ACE_recursive_mutex_state | |
| 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_T< ACE_LOCK > | |
| 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 object encapsulates a pointer to an object of type X. It uses a lock object of type ACE_LOCK to protect access to the reference count |
| 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_ImpExp | Configuration object that imports/exports data to a file formatted using the Win32 Registry file export format. This format looks like [Section] "key"="String Data" "key"=dword: numeric data in hexadecimal format "key"=hex: binary data |
| ACE_Remote_Mutex | Proxy for acquiring, renewing, and releasing a distributed mutex |
| ACE_Remote_Name_Space | Maintaining accesses Remote Name Server Database. Allows to add NameBindings, change them, remove them and resolve NameBindings |
| ACE_Remote_RLock | Proxy for acquiring, renewing, and releasing a distributed readers lock |
| ACE_Remote_Token_Proxy | Proxy for acquiring, renewing, and releasing a distributed synchronization token |
| ACE_Remote_WLock | Proxy for acquiring, renewing, and releasing a distributed writers lock |
| 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_RW_Token | Class that acquires, renews, and releases a process-local synchronization token |
| ACE_RWLock_Invariants | RWLock Invariants |
| 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_SDM_helpers | |
| 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_HANDLEs 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_Semaphore | Wrapper for Dijkstra style general semaphores |
| ACE_Service_Config | Supplies common server operations for dynamic and static configuration of service |
| ACE_Service_Config_Guard | A guard class, designed to be instantiated on the stack |
| ACE_Service_Gestalt | 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_Dynamic_Guard | A forward service declaration guard |
| 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_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_SizeCDR | A CDR stream for calculating size of the representation |
| 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_Streams passively |
| ACE_SOCK_CODgram | Defines the member functions for the ACE_SOCK connected datagram abstraction |
| 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 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_SEQPACK_Acceptor | Defines a factory that creates new ACE_Associations passively |
| ACE_SOCK_SEQPACK_Association | Defines the methods in the ACE_SOCK_SEQPACK_Association abstraction |
| ACE_SOCK_SEQPACK_Connector | Defines a factory that actively connects to a remote IP address and TCP port, creating a new ACE_SOCK_SEQPACK_Association object |
| 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 | A factory class that produces ACE_SPIPE_Stream objects |
| ACE_SPIPE_Addr | Defines the SVR4 STREAM pipe address family address format |
| ACE_SPIPE_Connector | Defines an active connection factory for ACE_SPIPE_Stream. On Windows this is mapped to Named Pipes, whereas on UNIX it is mapped to STREAM pipes |
| ACE_SPIPE_Stream | Defines the methods in the ACE_SPIPE_Stream abstraction |
| 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_Stack_Trace | Encapsulate a string representation of a stack trace on supported platforms. Stack traces for code built with optimize=1 (or "Release" configs on Visual Studio) may be misleading (missng frames) due to inlining performed by the compiler, which is indepenent of the inline=0 / inline=1 build option and the __ACE_INLINE__ / ACE_NO_INLINE macros |
| 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_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, ACE_PEER_ACCEPTOR_1 > | Abstract factory for creating a service handler (SVC_HANDLER), accepting into the SVC_HANDLER, and activating the SVC_HANDLER |
| ACE_Strategy_Connector< SVC_HANDLER, ACE_PEER_CONNECTOR_1 > | Abstract factory for creating a service handler (SVC_HANDLER), connecting the SVC_HANDLER, and activating the SVC_HANDLER |
| ACE_Stream< ACE_SYNCH_DECL > | This class is the primary abstraction for the ASX framework. It is moduled after System V Stream |
| ACE_Stream_Head< ACE_SYNCH_DECL > | Standard task that acts as reader or writer at the head of an ACE_Stream |
| ACE_Stream_Iterator< ACE_SYNCH_DECL > | Iterate through an ACE_Stream |
| ACE_Stream_Tail< ACE_SYNCH_DECL > | Standard module that acts as the head of a stream |
| 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< ACE_CHAR_T > | This class provides a wrapper facade for C strings |
| ACE_String_Base_Const | This class defines a constant for ACE_String_Base which originally was there to circumvent a bug in SunCC 6.0. This could be moved to ACE_String_Base but that adds a lot of footprint to the user applications which is not something we want |
| ACE_String_Base_Const_Iterator< ACE_CHAR_T > | Const iterator class for the ACE_String_Base class |
| ACE_String_Base_Iterator< ACE_CHAR_T > | Iterator class for the ACE_String_Base class |
| 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 |
| ACE_Sub_Barrier | |
| 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_Param | An instance of this object will be passed down to the yyparse() and yylex() functions |
| ACE_Svc_Handler< ACE_PEER_STREAM_1, ACE_SYNCH_DECL > | Defines the interface for a service that exchanges data with its connected peer |
| 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_System_Time_Policy | Implement the system time policy for ACE |
| ACE_Task< ACE_SYNCH_DECL > | 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_Ex< ACE_SYNCH_DECL, ACE_MESSAGE_TYPE > | Primary interface for application message processing, as well as input and output message queueing |
| 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 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 class. Note that this class should be defined within the scope of a thread, rather than at global scope! |
| 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, TYPE > | Adapts an ACE timer queue using a separate thread for dispatching |
| ACE_Threading_Helper< LOCK > | Encapsulates responsibility for allocating, destroying and manipulating the value, associated with a thread-specific key. Relates to the ability of the created thread to inherit the parent thread's gestalt. Designed to be used as an instance member of ACE_Service_Config |
| ACE_Threading_Helper< ACE_Null_Mutex > | |
| ACE_Threading_Helper< ACE_Thread_Mutex > | |
| ACE_Throughput_Stats | A simple class to make throughput and latency analysis |
| ACE_Thru_Task< ACE_SYNCH_DECL > | Standard module that acts as a "no op", simply passing on all data to its adjacent neighbor |
| ACE_Time_Policy_T< TIME_POLICY > | Template class implementing a dynamic time policy based on another time policy |
| ACE_Time_Value | Operations on "timeval" structures, which express time in seconds (secs) and microseconds (usecs) |
| ACE_Timer_Hash_Iterator_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET, TIME_POLICY > | Iterates over an ACE_Timer_Hash_T |
| ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET, TIME_POLICY > | Provides a hash table of BUCKETs 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, TIME_POLICY > | Iterates over an ACE_Timer_Heap_T |
| ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY > | Provides a very fast and predictable timer implementation |
| ACE_Timer_List_Iterator_T< TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY > | Iterates over an ACE_Timer_List |
| ACE_Timer_List_T< TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY > | 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 > | Generic interface for iterating over a subclass of ACE_Timer_Queue |
| ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY > | Provides an interface to timers |
| ACE_Timer_Queue_Upcall_Base< TYPE, FUNCTOR > | |
| ACE_Timer_Wheel_Iterator_T< TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY > | Iterates over an ACE_Timer_Wheel |
| ACE_Timer_Wheel_T< TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY > | Provides a Timing Wheel version of ACE_Timer_Queue |
| 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/LIFO ordering and that also supports (1) recursion and (2) readers/writer semantics |
| ACE_Token_Collection | Allows atomic token group operations AND provides a ACE_Token manager interface |
| ACE_TOKEN_CONST | Not a public interface |
| ACE_Token_Invariant_Manager | Token Invariants |
| ACE_Token_Manager | Manages all tokens in a process space |
| ACE_Token_Name | Allows Token_Manger to identify tokens |
| ACE_Token_Proxy | Abstract representation of ACE tokens |
| ACE_Token_Proxy_Queue | Token waiter list |
| ACE_Token::ACE_Token_Queue | |
| ACE_Token::ACE_Token_Queue_Entry | |
| ACE_Token_Reply | Message format for delivering replies from the ACE_Token Server |
| ACE_Token_Request | Message format for delivering requests to the ACE_Token Server |
| ACE_Tokenizer_T< ACE_CHAR_T > | Tokenizer |
| ACE_Tokens | Abstract representation of ACE tokens |
| ACE_TP_Reactor | Specialization of ACE_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_TPQ_Entry | Token Proxy Queue entry. Used in the ACE_Token_Proxy_Queue |
| ACE_TPQ_Iterator | Iterates through ACE_Token_Proxy_Queues |
| 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 |
| ACE_TSS_Cleanup | Singleton that helps to manage the lifetime of TSS objects and keys |
| ACE_TSS_Connection | Class for providing a connection per thread |
| 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_TPQ_Entry | ACE_TSS_TPQ_Entry |
| 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_Type_Traits< TYPE > | |
| ACE_Type_Traits< bool > | |
| ACE_Type_Traits< char > | |
| ACE_Type_Traits< double > | |
| ACE_Type_Traits< float > | |
| ACE_Type_Traits< int > | |
| ACE_Type_Traits< long > | |
| ACE_Type_Traits< long double > | |
| ACE_Type_Traits< long long > | |
| ACE_Type_Traits< short > | |
| ACE_Type_Traits< signed char > | |
| ACE_Type_Traits< TYPE * > | |
| ACE_Type_Traits< unsigned char > | |
| ACE_Type_Traits< unsigned int > | |
| ACE_Type_Traits< unsigned long > | |
| ACE_Type_Traits< unsigned long long > | |
| ACE_Type_Traits< unsigned short > | |
| 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 > | Compatibility wrapper for ACE_Unbounded_Set_Ex |
| ACE_Unbounded_Set_Const_Iterator< T > | Compatibility wrapper for ACE_Unbounded_Set_Ex_Const_Iterator |
| ACE_Unbounded_Set_Default_Comparator< T > | Simple comparator that evaluates equality using == operator |
| ACE_Unbounded_Set_Ex< T, C > | Implement a simple unordered set of <T> of unbounded size |
| ACE_Unbounded_Set_Ex_Const_Iterator< T, C > | Implement an const iterator over an unbounded set |
| ACE_Unbounded_Set_Ex_Iterator< T, C > | Implement an iterator over an unbounded set |
| ACE_Unbounded_Set_Iterator< T > | Compatibility wrapper for ACE_Unbounded_Set_Ex_Iterator |
| 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_UUID | |
| ACE_UUID_Generator | |
| ACE_Vector< T, DEFAULT_SIZE > | Defines an STL-like vector container |
| ACE_Vector_Iterator< T, DEFAULT_SIZE > | Implement an iterator over an ACE_Vector |
| 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 |
| ACE_WFMO_Reactor | An object oriented event demultiplexor and event handler. ACE_WFMO_Reactor is a Windows-only implementation of the ACE_Reactor interface that uses the WaitForMultipleObjects() event demultiplexer |
| ACE_WFMO_Reactor_Handler_Repository | Used to map ACE_HANDLEs onto the appropriate ACE_Event_Handler * and other information |
| ACE_WFMO_Reactor_Notify | Unblock the <ACE_WFMO_Reactor> from its event loop, passing it an optional ACE_Event_Handler to dispatch |
| ACE_Wide_To_Ascii | A lightweight wchar* to char* string conversion class |
| 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_Proactor | A manager for asynchronous event demultiplexing on Win32 |
| 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 > | Template specialization of ACE_Write_Guard for the ACE_Null_Mutex |
| ACE_XML_Svc_Conf | This abstract class defines the common operations ACE_Service_Config expects when using the XML Service Config Parser |
| Admin | Accesses monitor points or groups and manages the registries |
| ACE_Utils::Auto_Functor< X, Functor > | Helper template to implement auto_ptr<>-like classes, but executing a functor in the destructor, instead of always deleting things |
| ACE_Utils::Auto_Functor_Ref< X, Functor > | Helper class to implement assignment and copy-construction as expected |
| auto_ptr< X > | Implements the draft C++ standard auto_ptr abstraction |
| ACE_Registry::Binding | |
| ACE_Registry::Binding_Iterator | An iterator |
| cancel_state | |
| ACE_MT_MEM_IO::Channel | |
| 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_Utils::Comparator< LEFT, RIGHT > | Structure that provides optimal comparison operation for given types |
| ACE::Monitor_Control::Monitor_Control_Types::Constraint | Bundles the constrain string with its associated trigger action |
| ACE_Registry::Binding_Iterator::Context_Iteration | |
| ACE::Monitor_Control::Control_Action | |
| ACE_Pagefile_Memory_Pool::Control_Block | Attributes that are meaningful in local storage only |
| ControlAction | Base class for control actions initiated by the application or by constraint evaluation trigger |
| cpu_set_t | |
| ACE_WFMO_Reactor_Handler_Repository::Current_Info | This structure inherits from the common structure to add information for current entries |
| ACE_Utils::UUID::data | Data Members for Class Attributes |
| ACE::Monitor_Control::Monitor_Control_Types::Data | An instance is contained by each enabled monitor point |
| ACE_Tokenizer_T< ACE_CHAR_T >::Delimiter_Entry | Delimiter Entry |
| dirent | |
| ACE_CDR::Double | |
| ACE_Dev_Poll_Reactor::Event_Tuple | Struct that collects event registration information for a handle |
| ACE_Utils::Fast_Comparator< LEFT, RIGHT > | Quick comparison of types that can be safely promoted and/or converted to each other |
| ACE_CDR::Float | |
| frame_state | |
| 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_Dev_Poll_Reactor::Handler_Repository | Used to map ACE_HANDLEs onto the appropriate Event_Tuple |
| Hash_Token< TYPE > | |
| 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 |
| icmp | |
| If_Then_Else | Select of type Ta if boolean value is true |
| If_Then_Else | Compile-time selection of type based on a boolean value |
| If_Then_Else | Select of type Tb if boolean value is false |
| ACE::If_Then_Else< false, Ta, Tb > | |
| ACE::If_Then_Else< true, Ta, Tb > | |
| ip | |
| ACE_Registry::Binding_Iterator::Iteration_Complete | |
| ACE_Registry::Binding_Iterator::Iteration_State | |
| ACE_Active_Map_Manager_Key::key_data | Data for the Active Object Map Key |
| ACE_CDR::LongDouble | |
| ACE_OS::macaddr_node_t | |
| ACE::Monitor_Control::Monitor_Admin | |
| ACE::Monitor_Control::Monitor_Admin_Manager | Repsonsible for creating and destroying the global (per process) instance of the Admin class |
| ACE::Monitor_Control::Monitor_Base | Base class from which the template monitor point class is derived |
| ACE::Monitor_Control::Monitor_Control_Types | |
| ACE::Monitor_Control::Monitor_Point_Auto_Updater | Automates periodic updating of monitor point classes |
| ACE::Monitor_Control::Monitor_Point_Registry | Storage for instantiated monitor points |
| ACE_MT_MEM_IO::MQ_Struct | |
| msghdr | |
| ACE_Registry::Name_Component | International string |
| ACE_Registry::Naming_Context | An context representation |
| ACE_Utils::Noop_Truncator< FROM, TO > | No-op truncation |
| ACE_Delegating_Time_Policy::NULL_Time_Policy | |
| ACE_Registry::Object | An object representation |
| ACE_Registry::Binding_Iterator::Object_Iteration | |
| ACE_Event_Handler::Policy | Base class for all handler policies |
| ACE_Tokenizer_T< ACE_CHAR_T >::Preserve_Entry | Preserve Entry |
| ACE_Process_Manager::Process_Descriptor | Information describing each process that's controlled by an ACE_Process_Manager |
| ACE_Service_Gestalt::Processed_Static_Svc | |
| ACE_Handler::Proxy | Acts as a proxy for dispatch of completions to operations issued for the associated handler. It allows the handler to be deleted while operations are outstanding. The proxy must be used to get the ACE_Handler pointer for dispatching, and if it's 0, the handler is no longer valid and the result should not be dispatched |
| ACE_Event_Handler::Reference_Counting_Policy | This policy dictates the reference counting requirements for the handler |
| ACE_Codeset_Registry::registry_entry | |
| ACE_Asynch_Connect::Result | This is that class which will be passed back to the handler when the asynchronous connect completes |
| 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::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_Read_Stream::Result | This is the class which will be passed back to the ACE_Handler::handle_read_stream when the asynchronous read completes. This class forwards all the methods to the implementation classes |
| 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_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_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_Accept::Result | This is that class which will be passed back to the {handler} when the asynchronous accept completes |
| ACE_Asynch_Write_Stream::Result | This is that class which will be passed back to the ACE_Handler when the asynchronous write completes. This class forwards all the methods to the implementation class |
| rusage | |
| Safe_Comparator | Conservative comparison of types that may not be safely promoted and/or converted to each other |
| ACE_Utils::Safe_Comparator< LEFT, RIGHT, false, false > | |
| ACE_Utils::Safe_Comparator< LEFT, RIGHT, false, true > | |
| ACE_Utils::Safe_Comparator< LEFT, RIGHT, true, false > | |
| ACE_Utils::Safe_Comparator< LEFT, RIGHT, true, true > | |
| ACE_Bounded_Set< T >::Search_Structure | |
| semun | |
| ACE_TTY_IO::Serial_Params | |
| ACE_Pagefile_Memory_Pool::Control_Block::Shared_Control_Block | Pool statistics |
| ACE_Shared_Memory_Pool::SHM_TABLE | Keeps track of all the segments being used |
| siginfo_t | |
| ACE_Utils::Sign_Check< signed char > | |
| ACE_Utils::Sign_Check< signed int > | |
| ACE_Utils::Sign_Check< signed long > | |
| ACE_Utils::Sign_Check< signed long long > | |
| ACE_Utils::Sign_Check< signed short > | |
| ACE_Utils::Sign_Check< unsigned char > | |
| ACE_Utils::Sign_Check< unsigned int > | |
| ACE_Utils::Sign_Check< unsigned long > | |
| ACE_Utils::Sign_Check< unsigned long long > | |
| ACE_Utils::Sign_Check< unsigned short > | |
| ACE_MT_MEM_IO::Simple_Queue | |
| ACE::Monitor_Control::Size_Monitor | Base class from which ACE monitors of size are derived |
| ACE_SPIPE_Addr::SPIPE_Addr | Contains security attributes |
| strbuf | |
| ACE_WFMO_Reactor_Handler_Repository::Suspended_Info | This structure inherits from the common structure to add information for suspended entries |
| timespec | |
| 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_InputCDR::to_boolean | |
| ACE_InputCDR::to_char | |
| ACE_InputCDR::to_octet | |
| ACE_InputCDR::to_string | |
| To_Unsigned | |
| ACE_Utils::To_Unsigned< signed char > | |
| ACE_Utils::To_Unsigned< signed int > | |
| ACE_Utils::To_Unsigned< signed long > | |
| ACE_Utils::To_Unsigned< signed long long > | |
| ACE_Utils::To_Unsigned< signed short > | |
| ACE_Utils::To_Unsigned< unsigned char > | |
| ACE_Utils::To_Unsigned< unsigned int > | |
| ACE_Utils::To_Unsigned< unsigned long > | |
| ACE_Utils::To_Unsigned< unsigned long long > | |
| ACE_Utils::To_Unsigned< unsigned short > | |
| ACE_InputCDR::to_wchar | |
| ACE_InputCDR::to_wstring | |
| 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_Name_Reply::Transfer | |
| ACE_Name_Request::Transfer | |
| ACE_Token_Request::Transfer | |
| ACE_Token_Reply::Transfer | |
| ACE_InputCDR::Transfer_Contents | |
| truncate_cast | Helper function to truncate an integral value to the maximum value of the given type |
| ACE_Utils::Truncator< FROM, TO > | Truncate value of type FROM to value of type TO |
| ACE_Utils::Truncator< T, T > | |
| TSS_Cleanup_Instance | |
| ACE_ODB::Tuple | |
| ACE_Utils::UUID | |
| ACE_Utils::UUID_Generator | |
| ACE_Utils::UUID_Node | Holds the MAC-address of the UUID |
| ACE_Utils::UUID_Generator::UUID_State | |
| ACE::Value_Ptr< T > | Smart pointer implementation designed for use as a class member |
| ACE::VP_traits< T > | Value_Ptr traits template structure |
1.7.5.1
