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

# ACE Compound List

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

- _WSANETWORKEVENTS (No description available)
- ACE (Contains value added ACE methods that extend the behavior of the UNIX and Win32 OS calls)
- ACE_Accept_QoS_Params (Wrapper class that simplifies the information passed to the QoS enabled method)
- ACE_Accept_Strategy (Defines the interface for specifying a passive connection acceptance strategy for a SVC_HANDLER)
- ACE_Acceptor (Abstract factory for creating a service handler (SVC_HANDLER), accepting into the SVC_HANDLER, and activating the SVC_HANDLER)
- ACE_Acquire_Method (An enum class)
- ACE_Activation_Queue (Reifies a method into a request. Subclasses typically represent necessary state and behavior)
- ACE_Active_Map_Manager (Define a map abstraction that associates system generated keys with user specified values)
- ACE_Active_Map_Manager_Adapter (Defines a map implementation)
- ACE_Active_Map_Manager_Iterator_Adapter (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 (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 (No description available)
- 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 (This class is an Adapter that allows the to use the <Malloc> class below)
- ACE_Arg_Shifter (This ADT operates on a specified set of arguments (argv). As known arguments are scanned, they are shifted to the back of the argv vector, so deeper levels of argument parsing can locate the yet unprocessed arguments at the beginning of the vector)
- ACE_ARGV (Transforms a string <buf> into an style vector of strings or an style vector of string <buf>, performing environment variable substitutions if necessary)
- ACE_Array (Implement a dynamic array class)
- ACE_Array_Base (Implement a simple dynamic array)
- ACE_Array_Iterator (Implement an iterator over an ACE_Array)
- ACE_Async_Timer_Queue_Adapter (Adapts a <TQ> to be run asynchronously)
- ACE_Asynch_Accept (This class is a factory for starting off asynchronous accepts on a listen handle. This class forwards all methods to its implementation class)
- ACE_Asynch_Accept_Impl (No description available)
- ACE_Asynch_Accept_Result_Impl (No description available)
- ACE_Asynch_Acceptor (This class is an example of the Acceptor Pattern. This class will accept new connections and create new HANDLER to handle the new connections)
- 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., or )
- ACE_Asynch_Operation_Impl (No description available)
- 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 (No description available)
- ACE_Asynch_Read_Dgram_Result_Impl (No description available)
- 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 (No description available)
- ACE_Asynch_Read_File_Result_Impl (No description available)
- 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 (No description available)
- ACE_Asynch_Read_Stream_Result_Impl (No description available)
- ACE_Asynch_Result (An interface base class which allows users access to common information related to an asynchronous operation)
- ACE_Asynch_Result_Impl (No description available)
- ACE_Asynch_Transmit_File (This class is a factory for starting off asynchronous transmit files on a stream)
- ACE_Asynch_Transmit_File_Impl (No description available)
- ACE_Asynch_Transmit_File_Result_Impl (No description available)
- 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 (No description available)
- ACE_Asynch_Write_Dgram_Result_Impl (No description available)
- 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 (No description available)
- ACE_Asynch_Write_File_Result_Impl (No description available)
- ACE_Asynch_Write_Stream (This class is a factory for starting off asynchronous writes on a stream. This class forwards all methods to its implementation class)
- ACE_Asynch_Write_Stream_Impl (No description available)
- ACE_Asynch_Write_Stream_Result_Impl (No description available)
- ACE_At_Thread_Exit (Contains a method to be applied when a thread is terminated)
- ACE_At_Thread_Exit_Func (No description available)
- ACE_ATM_Addr (Defines the ATM domain address family address format)
- ACE_Atomic_Op (Transparently parameterizes synchronization into basic arithmetic operations)
- ACE_Auto_Array_Ptr (Implements an extension to the draft C++ standard auto_ptr abstraction)
- ACE_Auto_Basic_Array_Ptr (Implements an extension to the draft C++ standard auto_ptr abstraction. This class allows one to work on non-object (basic) types that must be treated as an array, e.g., deallocated via "delete [] foo")
- ACE_Auto_Basic_Ptr (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 (This class automatically increments and decrements a parameterized counter)
- ACE_Auto_String_Free (Simple class to automatically de-allocate strings)
- ACE_Barrier (Implements "barrier synchronization")
- ACE_Base_Thread_Adapter (Base class for all the Thread_Adapters)
- ACE_Based_Pointer (A smart proxy that keeps track of the relative offset of a "pointer" from its base address)
- ACE_Based_Pointer_Basic (A proxy that keeps track of the relative offset of a "pointer" from its base address. This class makes it possible to transparently use "pointers" in shared memory as easily as programming with pointers to local memory. In particular, we don't need to ensure that the base addresses of all the pointers are mapped into separate processes at the same absolute memory base address)
- ACE_Based_Pointer_Repository (Maps pointers to the base address of the region to which each pointer belongs)
- ACE_Based_Pointer_Repository_Rep (No description available)
- 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 (An ACE_Bound_Ptr_Counter object encapsulates an object reference count. Do not use this class directly, use ACE_Strong_Bound_Ptr or ACE_Weak_Bound_Ptr instead)
- ACE_Bounded_Cached_Connect_Strategy (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 (Implement a simple unordered set of <T> with maximum set at creation time)
- ACE_Bounded_Set_Iterator (Interates through an unordered set)
- ACE_Bounded_Stack (Implement a generic LIFO abstract data type)
- ACE_Buffered_Svc_Handler (Defines the interface for a service that exchanges data with its connected peer and supports buffering)
- ACE_Cache_Map_Iterator (Defines a iterator for the Cache_Map_Manager)
- ACE_CACHE_MAP_MANAGER (No description available)
- ACE_Cache_Map_Manager (Defines a abstraction that will purge entries from a map)
- ACE_Cache_Map_Reverse_Iterator (Defines a reverse iterator for the Cache_Map_Manager)
- ACE_Cached_Allocator (Create a cached memory poll with <n_chunks> chunks each with sizeof (TYPE) size)
- ACE_Cached_Connect_Strategy (A connection strategy which caches connections to peers (represented by <SVC_HANDLER> instances), thereby allowing subsequent re-use of unused, but available, connections)
- ACE_Cached_Connect_Strategy_Ex (A connection strategy which caches connections to peers (represented by <SVC_HANDLER> instances), thereby allowing subsequent re-use of unused, but available, connections)
- ACE_Cached_Mem_Pool_Node ( keeps unused memory within a free list)
- ACE_Caching_Strategy (This class is an abstract base class for a caching strategy)
- ACE_Caching_Strategy_Adapter (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 (Adapter for ACE_Cleanup objects that allows them to be readily managed by the ACE_Object_Manager)
- ACE_Cleanup_Info (Hold cleanup information for thread/process)
- ACE_Cleanup_Info_Node (No description available)
- ACE_Cleanup_Strategy (Defines a default strategy to be followed for cleaning up entries from a map which is the container)
- ACE_Command_Base (Defines an abstract class that allows us to invoke commands without knowing anything about the implementation)
- ACE_Command_Callback (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 (Defines the interface for specifying a concurrency strategy for a SVC_HANDLER)
- ACE_Condition (ACE_Condition variable wrapper, which allows threads to block until shared data changes state)
- ACE_Condition_Attributes (No description available)
- ACE_Condition_Thread_Mutex (ACE_Condition variable wrapper written using ACE_Mutexes This allows threads to block until shared data changes state. A condition variable enables threads to atomically block and test the condition under the protection of a mutual exclu- sion lock (mutex) until the condition is satisfied. That is, the mutex must have been held by the thread before calling wait or signal on the condition. If the condition is false, a thread blocks on a condition variable and atomically releases the mutex that is waiting for the condition to change. If another thread changes the condition, it may wake up waiting threads by signaling the associated condition variable. The waiting threads, upon awakening, reacquire the mutex and re-evaluate the condition)
- ACE_Config_ImpExp_Base (Base class for file import/export configuration)
- ACE_Configuration (Base class for configuration databases)
- ACE_Configuration_ExtId (External ID for the section and value hash)
- ACE_Configuration_Heap (The concrete implementation of a allocator based configuration database)
- ACE_Configuration_Section_IntId (The internal ID for a section hash table)
- ACE_Configuration_Section_Key (Referenced counted wrapper for )
- ACE_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 (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 (Generic factory for actively connecting clients and creating service handlers (SVC_HANDLERs))
- ACE_Control_Block (This information is stored in memory allocated by the <Memory_Pool>)
- ACE_CORBA_Ref (A wrapper for helping with Orbix object references)
- ACE_Countdown_Time (Keeps track of the amount of elapsed time)
- ACE_Creation_Strategy (Defines the interface for specifying a creation strategy for a SVC_HANDLER)
- ACE_CString (This class provides a wrapper facade for C strings)
- ACE_Data_Block (Stores the data payload that is accessed via one or more s)
- ACE_Date_Time (System independent representation of date and time)
- ACE_Deadline_Message_Strategy (Deadline based message priority strategy)
- ACE_DEV (Defines the member functions for the base class of the ACE_DEV abstraction)
- ACE_DEV_Addr (Defines device address family address format)
- ACE_DEV_Connector (Defines an active connection factory for the ACE_DEV wrappers)
- ACE_DEV_IO (Read/Write operations on Devices)
- ACE_Dirent (Define a portable C++ directory-entry iterator based on the POSIX API)
- ACE_Dirent_Selector (No description available)
- ACE_DLL (Provides an abstract interface for handling various DLL operations)
- ACE_DLL_Strategy (Defines the interface for specifying a creation strategy for a SVC_HANDLER based on dynamic linking of the SVC_HANDLER)
- ACE_DLList (A double-linked list container class)
- ACE_DLList_Iterator (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 (A double-linked list container class iterator)
- ACE_DNode (Implementation element in a bilinked list)
- ACE_Double_Linked_List (A double-linked list implementation)
- ACE_Double_Linked_List_Iterator (Implements an iterator for a double linked list ADT)
- ACE_Double_Linked_List_Iterator_Base (Implements a common base class for iterators for a double linked list ADT)
- ACE_Double_Linked_List_Reverse_Iterator (Implements a reverse iterator for a double linked list ADT)
- ACE_Dummy_Node (I forget why this is here... ;-))
- ACE_Dumpable (Base class that defines a uniform interface for all object dumping)
- ACE_Dumpable_Adapter (This class inherits the interface of the abstract ACE_Dumpable class and is instantiated with the implementation of the concrete component class <class Concrete>)
- ACE_Dumpable_Ptr (A smart pointer stored in the in-memory object database ACE_ODB. The pointee (if any) is deleted when reassigned)
- ACE_Dynamic (Checks to see if an object was dynamically allocated)
- ACE_Dynamic_Message_Queue (A derived class which adapts the class in order to maintain dynamic priorities for enqueued 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 class or any other class which needs to manage the priorities of a collection of s dynamically)
- ACE_Dynamic_Node (Handle a dynamically linked node)
- ACE_Dynamic_Service (Provides a general interface to retrieve arbitrary objects from the ACE service repository)
- ACE_Dynamic_Service_Base (Base class for all ACE_Dynamic_Service instantiations)
- ACE_EH_Dispatch_Info (This structure contains information of the activated event handler)
- ACE_Profile_Timer::ACE_Elapsed_Time (Keeps track of the various user, system, and elapsed (real) times)
- ACE_Env_Value (Enviroment Variable Value)
- ACE_Equal_To (Function object for comparing two objects of the given type for equality)
- ACE_Errno_Guard (Provides a wrapper to improve performance when thread-specific errno must be saved and restored in a block of code)
- ACE_Event (A wrapper around the Win32 event locking mechanism)
- ACE_Event_Handler (Provides an abstract interface for handling various types of I/O, timer, and signal events)
- ACE_Event_Handler_Handle_Timeout_Upcall (Functor for Timer_Queues)
- ACE_Event_Tuple (An ACE_Event_Handler and its associated ACE_HANDLE)
- ACE_FIFO (Abstract base class for UNIX FIFOs)
- ACE_FIFO_Caching_Strategy (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 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 (Implement a simple unordered set of <T> with maximum )
- ACE_Fixed_Set_Iterator (Interates through an unordered set)
- ACE_Fixed_Stack (Implement a generic LIFO abstract data type)
- ACE_Flag_Manip (No description available)
- ACE_OS::ace_flock_t (OS file locking structure)
- ACE_Flow_Spec (Wrapper class that defines the flow spec QoS information, which is used by IntServ (RSVP) and DiffServ)
- ACE_FlReactor (A Reactor implementation that uses the Fast-Light (FL) toolkit for event demultiplexing. This will let us integrate the FL toolkit with ACE and/or TAO)
- ACE_Free_List (Implements a free list)
- ACE_Function_Node (Keeps track of the symbol name of for a shared function)
- ACE_Future (This class implements a ``single write, multiple read'' pattern that can be used to return results from asynchronous method invocations)
- ACE_Future_Holder (Implementation of object which has holds ACE_Future)
- ACE_Future_Observer (ACE_Future_Observer<T>)
- ACE_Future_Rep (ACE_Future_Rep<T>)
- ACE_Future_Set (This class implements a mechanism which allows the values of a collections of objects to be accessed by reader threads as they become available)
- ACE_Get_Opt (Iterator for parsing command-line arguments)
- ACE_Guard (This data structure is meant to be used within a method or function... It performs automatic aquisition and release of a parameterized synchronization object )
- ACE_Guard< ACE_Null_Mutex > (Template specialization of for the )
- ACE_Guard< ACE_Select_Reactor_Token_T< ACE_Noop_Token > > (Template specialization of for the )
- ACE_Handle_Gobbler (This class gobbles up handles)
- ACE_Handle_Ops (No description available)
- ACE_Handle_Set (C++ wrapper facade for the socket <fd_set> abstraction)
- ACE_Handle_Set_Iterator (Iterator for the abstraction)
- ACE_Handler (This base class defines the interface for receiving the results of asynchronous operations)
- ACE_Handler_Caching_Utility (Defines a helper class for the Caching Strategies)
- ACE_Handler_Cleanup_Strategy (Defines a strategy to be followed for cleaning up entries which are svc_handlers from a container)
- ACE_Hash (Function object for hashing)
- ACE_Hash< char > (Function object for hashing a char)
- ACE_Hash_Cache_Map_Manager (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 (Forward iterator for the 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 (Wrapper for backward compatibility)
- ACE_Hash_Map_Const_Iterator_Base_Ex (Base const iterator for the )
- ACE_Hash_Map_Const_Iterator_Ex (Const forward iterator for the )
- ACE_Hash_Map_Entry (Define an entry in the hash table)
- ACE_Hash_Map_Iterator (Wrapper for backward compatibility)
- ACE_Hash_Map_Iterator_Base_Ex (Base iterator for the )
- ACE_Hash_Map_Iterator_Ex (Forward iterator for the )
- ACE_Hash_Map_Manager (Wrapper for backward compatibility)
- ACE_Hash_Map_Manager_Ex (Define a map abstraction that efficiently associates <EXT_ID>s with <INT_ID>s)
- ACE_Hash_Map_Manager_Ex_Adapter (Defines a map implementation)
- ACE_Hash_Map_Manager_Ex_Iterator_Adapter (Defines a iterator implementation for the Hash_Map_Manager_Adapter)
- ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter (Defines a reverse iterator implementation for the Hash_Map_Manager_Adapter)
- ACE_Hash_Map_Reverse_Iterator (Wrapper for backward compatibility)
- ACE_Hash_Map_Reverse_Iterator_Ex (Reverse iterator for the )
- ACE_Hash_Map_With_Allocator (This class is a thin wrapper around ACE_Hash_Map_Manager, which comes handy when ACE_Hash_Map_Manager is to be used with a non-nil ACE_Allocator. This wrapper insures that the appropriate allocator is in place for every operation that accesses or updates the hash map)
- ACE_Hashable (No description available)
- ACE_High_Res_Timer (A high resolution timer class wrapper that encapsulates OS-specific high-resolution timers, such as those found on Solaris, AIX, Win32/Pentium, and VxWorks)
- ACE_Incremental_Key_Generator (Defines a simple incremental key generator)
- ACE_INET_Addr (Defines a C++ wrapper facade for the Internet domain address family format)
- ACE_Ini_ImpExp (Imports the configuration database from filename as strings. Allows non-typed values. (no #, dword: hex:, etc. prefixes) and skips whitespace (tabs and spaces) as in standard .ini and .conf files. Values (to right of equal sign) can be double quote delimited to embed tabs and spaces in the string. Caller must convert string to type)
- ACE_Init_ACE (Initialize ACE library services. Can be called only once per program invocation)
- ACE_InputCDR (A CDR stream for reading, i.e. for demarshalling)
- ACE_IntCapEntry (This class implement the ACE Integer Capability subclass)
- ACE_Intrusive_List (Implement an intrusive double linked list)
- ACE_Intrusive_List_Node (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 abstraction, which includes and )
- ACE_IOStream (A template adapter for creating an iostream-like object using an ACE IPC Stream for the actual I/O. Iostreams use an underlying streambuf object for the IO interface. The iostream class and derivatives provide you with a host of convenient operators that access the streambuf)
- ACE_IPC_SAP (Defines the member functions for the base class of the ACE_IPC_SAP abstraction)
- ACE_Iterator (Defines the iterator interface)
- ACE_Iterator_Impl (Defines a abstract iterator)
- ACE_Laxity_Message_Strategy (Laxity based message priority strategy)
- ACE_Less_Than (Function object for determining whether the first object of the given type is less than the second object of the same type)
- ACE_LFU_Caching_Strategy (Defines a Least Frequently Used strategy for which will decide on the item to be removed from the cache)
- ACE_Lib_Find (No description available)
- ACE_Lite_MMAP_Memory_Pool (Make a ``lighter-weight'' memory pool based )
- ACE_Local_Memory_Pool (Make a memory pool that is based on C++ new/delete. This is useful for integrating existing components that use new/delete into the ACE Malloc scheme..)
- ACE_Local_Memory_Pool_Options (Helper class for Local Memory Pool constructor options)
- ACE_Local_Name_Space (Maintaining accesses Local Name Server Database. Allows to add NameBindings, change them, remove them and resolve NameBindings)
- ACE_Location_Node (Keep track of where a shared library is located)
- ACE_Lock (This is the abstract base class that contains the uniform locking API that is supported by all the ACE synchronization mechanisms)
- ACE_Lock_Adapter (This is an adapter that allows applications to transparently combine the abstract base class (which contains pure virtual methods) with any of the other concrete ACE synchronization classes (e.g., , , , etc.))
- ACE_LOCK_SOCK_Acceptor (Specialize to lock around ;)
- ACE_Locked_Data_Block (A Data_Block with a concrete locking strategy)
- ACE_Locked_Free_List (Implements a free list)
- ACE_Log_Msg (Provides a variable length argument message logging abstraction)
- ACE_Log_Msg_Backend (Define the interface for ACE_Log_Msg backend strategies)
- ACE_Log_Msg_Callback (An interface class used to get logging callbacks)
- ACE_Log_Msg_IPC (Defines the interfaces for ACE_Log_Msg backend)
- ACE_Log_Record (Defines the structure of an ACE logging record)
- ACE_Logging_Strategy (This class provides the hooks to control the output produced by any of the network services)
- ACE_LRU_Caching_Strategy (Defines a Least Recently Used strategy which will decide on the item to be removed from the cache)
- ACE_LSOCK (Create a Local ACE_SOCK, which is used for passing file descriptors)
- ACE_LSOCK_Acceptor (Defines the format and interface for the acceptor side of the local ACE_SOCK ACE_Stream)
- ACE_LSOCK_CODgram (Defines the member functions for the connected datagram abstraction)
- ACE_LSOCK_Connector (Defines the format and interface for the connector side of the )
- ACE_LSOCK_Dgram (Create a Local ACE_SOCK datagram)
- ACE_LSOCK_Stream (Create a Local ACE_SOCK stream)
- ACE_Malloc (No description available)
- ACE_Malloc_FIFO_Iterator (No description available)
- ACE_Malloc_FIFO_Iterator_T (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 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 to keep track of each chunk of data when it's in the free list or in use)
- ACE_Malloc_LIFO_Iterator (No description available)
- ACE_Malloc_LIFO_Iterator_T (LIFO iterator for names stored in Malloc'd memory)
- ACE_Malloc_T (Define a C++ class that uses parameterized types to provide an extensible mechanism for encapsulating various of dynamic memory management strategies)
- ACE_Managed_Object (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 (Defines a map interface)
- ACE_Map_Const_Iterator (Forward const iterator for the )
- ACE_Map_Const_Iterator_Base (Const iterator for the )
- ACE_Map_Entry (An entry in the Map)
- ACE_Map_Impl (Defines a map implementation)
- ACE_Map_Impl_Iterator_Adapter (Defines a iterator implementation for the Map_Impl class)
- ACE_Map_Impl_Reverse_Iterator_Adapter (Defines a reverse iterator implementation for the Map_Impl class)
- ACE_Map_Iterator (Forward iterator for the )
- ACE_Map_Iterator_Base (Iterator for the )
- ACE_Map_Manager (Define a map abstraction that associates <EXT_ID>s with <INT_ID>s)
- ACE_Map_Manager_Adapter (Defines a map implementation)
- ACE_Map_Manager_Iterator_Adapter (Defines a iterator implementation for the Map_Manager_Adapter)
- ACE_Map_Manager_Reverse_Iterator_Adapter (Defines a reverse iterator implementation for the Map Manager)
- ACE_Map_Reverse_Iterator (Reverse Iterator for the )
- 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 the connector side of the )
- 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 (No description available)
- ACE_MEM_Stream (Defines the methods in the abstraction)
- ACE_Message_Block (Stores messages for use throughout ACE (particularly ))
- ACE_Message_Queue (A threaded message queueing facility, modeled after the queueing facilities in System V STREAMs)
- ACE_Message_Queue_Base (Workaround HP/C++ compiler bug with enums in templates)
- ACE_Message_Queue_Ex (A threaded message queueing facility, modeled after the queueing facilities in System V STREAMs)
- ACE_Message_Queue_Factory (ACE_Message_Queue_Factory is a static factory class template which provides a separate factory method for each of the major kinds of priority based message dispatching: static, earliest deadline first (EDF), and minimum laxity first (MLF))
- ACE_Message_Queue_Iterator (Iterator for the )
- ACE_Message_Queue_Reverse_Iterator (Reverse Iterator for the )
- ACE_Method_Request (Reifies a method into a request. Subclasses provide the necessary state and behavior)
- ACE_MMAP_Memory_Pool (Make a memory pool that is based on <mmap(2)>. This implementation allows memory to be shared between processes)
- ACE_MMAP_Memory_Pool_Options (Helper class for MMAP Memory Pool constructor options)
- ACE_Module (An abstraction for managing a bi-directional flow of messages)
- ACE_Module_Base (Workaround HP/C++ compiler bug with enums in templates)
- ACE_Module_Type (Define the methods for handling the configuration of )
- ACE_Msg_WFMO_Reactor (An OO event demultiplexor and event handler dispatcher for Win32 <MsgWaitForMultipleObjects>)
- ACE_MT_MEM_IO (No description available)
- ACE_Mutex ( wrapper (valid in same process or across processes (depending on TYPE flag)))
- ACE_Name_Binding (Maintains a mapping from name to value and type)
- ACE_PI_Control_Block::ACE_Name_Node (This class supports "named memory regions" within )
- ACE_Control_Block::ACE_Name_Node (This class supports "named memory regions" within )
- 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 (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 (Implementation element in a Queue, Set, and Stack)
- ACE_NOOP_Concurrency_Strategy (Implements a no-op activation strategy in order to avoid calling open on a svc_handler multiple times)
- ACE_NOOP_Creation_Strategy (Implements a no-op creation strategy in order to defer decisions regarding creation to some later point in time, such as in connect or accept strategy)
- ACE_Noop_Key_Generator (Defines a noop key generator)
- ACE_Noop_Token (No description available)
- ACE_Notification_Buffer (Simple wrapper for passing s and s between threads)
- ACE_Notification_Strategy (Abstract class used for notifing 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_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 (The is a special caching strategy which doesnt have the purging feature)
- ACE_Null_Caching_Utility (Defines a dummy helper class for the Caching Strategies)
- ACE_Null_Cleanup_Strategy (Defines a do-nothing implementation of the cleanup strategy)
- ACE_Null_Condition (Implement a do nothing 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 , i.e., all the methods are no ops)
- ACE_Null_Semaphore (Implement a do nothing , i.e., all the methods are no ops)
- ACE_Obchunk (Defines the state that represents a "chunk" of memory. Evenything in this class is public because it is designed as an internal structure of Obstack_T and users are not supposed to use this class directly)
- ACE_Object_Manager (Manager for ACE library services and singleton cleanup)
- ACE_Object_Manager_Base (Base class for ACE_Object_Manager(s))
- ACE_Object_Manager_Manager (No description available)
- ACE_Object_Manager_Preallocations (No description available)
- ACE_Object_Node (Keeps track of the symbol name for a shared object)
- ACE_Obstack (Define a simple "mark and release" memory allocation utility)
- ACE_Obstack_T (No description available)
- ACE_ODB (This is the object database (ODB) that keeps track of all live ACE objects)
- ACE_Oneshot_Acceptor (Generic factory for passively connecting clients and creating exactly one service handler (SVC_HANDLER))
- ACE_Ordered_MultiSet (Implement a simple ordered multiset of <T> of unbounded size that allows duplicates. This class template requires that < operator semantics be defined for the parameterized type <T>, but does not impose any restriction on how that ordering operator is implemented)
- ACE_Ordered_MultiSet_Iterator (Implement a bidirectional iterator over an ordered multiset. This class template requires that < operator semantics be defined for the parameterized type <T>, but does not impose any restriction on how that ordering operator is implemented)
- ACE_OS (This class defines an OS independent programming API that shields developers from nonportable aspects of writing efficient system programs on Win32, POSIX and other versions of UNIX, and various real-time operating systems)
- ACE_OS_Dirent (This class is a wrapper for the dirent.h operations)
- ACE_OS_Exit_Info (Hold Object Manager cleanup (exit) information)
- ACE_OS_Log_Msg_Attributes (The attributes required by ACE_Log_Msg)
- ACE_OS_Memory (This class is a wrapper for dynamic memory operations)
- ACE_OS_Object_Manager (No description available)
- ACE_OS_Object_Manager_Manager (No description available)
- ACE_OS_String (This class includes functions available in string.h and ctype.h)
- ACE_OS_Thread_Adapter (Converts a C++ function into a function 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_OS_Thread_Descriptor (Parent class of all ACE_Thread_Descriptor classes. = Container for ACE_Thread_Descriptor members that are used in ACE_OS)
- ACE_OS_TLI (This class is a wrapper for the TLI operations)
- ACE_OutputCDR (A CDR stream for writing, i.e. for marshalling)
- ACE_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 (Defines a pair)
- ACE_Pair_Caching_Utility (Defines a helper class for the Caching Strategies)
- ACE_Parse_Node (Provide the base of the object hierarchy that defines the parse tree of Service Nodes)
- ACE_PI_Control_Block (This information is stored in memory allocated by the <Memory_Pool>)
- ACE_Pipe (Provides a bidirectional "pipe" abstraction that is portable to Windows NT, SVR4 UNIX, and BSD UNIX)
- ACE_Pointer_Hash (Function object for hashing pointers)
- ACE_POSIX__Asynch_Write_Dgram_Result (This is class provides concrete implementation for ACE_Asynch_Write_Dgram::Result class)
- ACE_POSIX_AIOCB_Asynch_Operation (This class implements for (Asynchronous I/O Control Blocks) based implementation of Proactor)
- ACE_POSIX_AIOCB_Asynch_Read_Dgram (This class is a factory for starting off asynchronous reads on a UDP socket)
- ACE_POSIX_AIOCB_Asynch_Read_File (This class is a factory for starting off asynchronous reads on a file. This class implements for (Asynchronous I/O Control Blocks) based implementation of Proactor)
- ACE_POSIX_AIOCB_Asynch_Read_Stream (No description available)
- ACE_POSIX_AIOCB_Asynch_Transmit_File (Implementation for transmit_file will make use of POSIX_AIOCB_Asynch_Transmit_Handler)
- ACE_POSIX_AIOCB_Asynch_Transmit_Handler (No description available)
- ACE_POSIX_AIOCB_Asynch_Write_Dgram (This class is a factory for starting off asynchronous writes on a UDP socket)
- ACE_POSIX_AIOCB_Asynch_Write_File (No description available)
- ACE_POSIX_AIOCB_Asynch_Write_Stream (This class implements for (Asynchronous I/O Control Blocks) based implementation of Proactor)
- ACE_POSIX_AIOCB_Proactor (This Proactor makes use of Asynchronous I/O Control Blocks (AIOCB) to notify/get the completion status of the operations issued)
- ACE_POSIX_Asynch_Accept (No description available)
- ACE_POSIX_Asynch_Accept_Handler (No description available)
- ACE_POSIX_Asynch_Accept_Result (This is that class which will be passed back to the <handler> when the asynchronous accept completes)
- ACE_POSIX_Asynch_Operation (This class abstracts out the common things needed for implementing for POSIX platforms. Specific implementations such as <POSIX_AIOCB_Asynch_Operation> can derive from this class)
- ACE_POSIX_Asynch_Read_Dgram_Result (This is class provides concrete implementation for ACE_Asynch_Read_Dgram::Result class)
- ACE_POSIX_Asynch_Read_File_Result (This class provides concrete implementation for class for POSIX platforms)
- ACE_POSIX_Asynch_Read_Stream_Result (This class provides concrete implementation for class for POSIX platforms)
- ACE_POSIX_Asynch_Result (No description available)
- ACE_POSIX_Asynch_Timer (This class is posted to the completion port when a timer expires. When the <complete method> of this object is called, the <handler>'s <handle_timeout> method will be called)
- ACE_POSIX_Asynch_Transmit_File_Result (This is that class which will be passed back to the <handler> when the asynchronous transmit file completes)
- ACE_POSIX_Asynch_Transmit_Handler (No description available)
- ACE_POSIX_Asynch_Write_Dgram_Result (No description available)
- ACE_POSIX_Asynch_Write_File_Result (This class provides implementation for for POSIX platforms)
- ACE_POSIX_Asynch_Write_Stream_Result (This class provides concrete implementation for on POSIX platforms)
- ACE_POSIX_Proactor (POSIX implementation of the Proactor)
- ACE_POSIX_SIG_Proactor (This Proactor implementation does compeltion querying using POSIX Real Time signals. <sigtimedwait>/<sigwaitinfo> call is used to get the notify/get the completions. The real-time signals that are going to be used with this Proactor should be given apriori in the constructor, so that those signals can be masked from asynchornous delivery)
- ACE_POSIX_Wakeup_Completion (No description available)
- 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_Proactor_Impl (A manager for asynchronous event demultiplexing. This class is the base class for all the concrete implementation classes)
- ACE_Proactor_Timer_Handler (No description available)
- ACE_Process (Process)
- ACE_Process_Descriptor (Information describing each process that's controlled by an )
- 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 (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 (No description available)
- 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 and methods)
- ACE_QtReactor (An object-oriented event demultiplexor and event handler dispatcher that uses the Qt Library. This class declaration also uses the extension facilities provided by the Qt. So, readers of the class declaration should not be upset with the appearence of the Keywords like Q_OBJECT, private slots etc. They are specific to Qt which uses these as a call back methods implementation mechanism)
- ACE_RB_Tree (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 (No description available)
- ACE_RB_Tree_Iterator (Implements an iterator for a Red-Black Tree ADT)
- ACE_RB_Tree_Iterator_Base (Implements a common base class for iterators for a Red-Black Tree ADT)
- ACE_RB_Tree_Node (Implements a node in a Red-Black Tree ADT)
- ACE_RB_Tree_Node_Base (No description available)
- ACE_RB_Tree_Reverse_Iterator (Implements a reverse iterator for a Red-Black Tree ADT)
- ACE_Reactive_MEM_IO (No description available)
- ACE_Reactive_Strategy (Defines the interface for specifying a Reactive concurrency strategy for a SVC_HANDLER)
- ACE_Reactor (The responsibility of this class is to forward all methods to its delegation/implementation class, e.g., or )
- 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 from its event loop)
- ACE_Read_Buffer (Efficiently reads an artibrarily large buffer from an input stream up to and including a termination character. Also performs search/replace on single occurrences a character in the buffer using the principles of Integrated Layer Processing)
- ACE_Read_Guard (This class is similar to class , though it acquires/releases a read lock automatically (naturally, the it is instantiated with must support the appropriate API))
- ACE_Read_Guard< ACE_Null_Mutex > (No description available)
- 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 (No description available)
- ACE_Recyclable_Handler_Caching_Utility (Defines a helper class for the Caching Strategies)
- ACE_Recyclable_Handler_Cleanup_Strategy (Defines a strategy to be followed for cleaning up entries which are svc_handlers from a container)
- ACE_Recycling_Strategy (Defines the interface (and default implementation) for specifying a recycling strategy for a SVC_HANDLER)
- ACE_Refcountable (No description available)
- ACE_Refcounted_Auto_Ptr (This class implements support for a reference counted auto_ptr. Assigning or copying instances of an ACE_Refcounted_Auto_Ptr will automatically increment the reference count. When the last instance that references a ACE_Refcounted_Auto_Ptr instance is destroyed or overwritten, it will invoke delete on its underlying pointer)
- ACE_Refcounted_Auto_Ptr_Rep (An ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK> object incapsulates a pointer to an object of type X. It is pointed to by ACE_Refcounted_Auto_Ptr<X, ACE_LOCK> object[s] and only accessible through them)
- ACE_Refcounted_Hash_Recyclable (No description available)
- ACE_Refcounted_Recyclable_Handler_Caching_Utility (Defines a helper class for the Caching Strategies)
- ACE_Refcounted_Recyclable_Handler_Cleanup_Strategy (Defines a strategy to be followed for cleaning up entries which are svc_handlers from a container)
- ACE_Reference_Pair (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 "key"=hex: binary data)
- ACE_Remote_Name_Space (Maintaining accesses Remote Name Server Database. Allows to add NameBindings, change them, remove them and resolve NameBindings)
- ACE_Remove_Node (Remove a Service Node)
- ACE_Resume_Node (Resume a Service Node)
- ACE_Reverse_Iterator (Defines the reverse iterator interface)
- ACE_Reverse_Iterator_Impl (Defines a abstract reverse iterator)
- ACE_Reverse_Lock (A reverse (or anti) lock)
- ACE_RW_Mutex (Wrapper for readers/writer locks)
- ACE_RW_Process_Mutex (Wrapper for readers/writer locks that exist across processes)
- ACE_RW_Thread_Mutex (Wrapper for readers/writer locks that exist within a process)
- ACE_Sample_History (Save multiple samples in an array)
- ACE_Sbrk_Memory_Pool (Make a memory pool that is based on <sbrk(2)>)
- ACE_Sbrk_Memory_Pool_Options (Helper class for Sbrk Memory Pool constructor options)
- ACE_Sched_Params (Container for scheduling-related parameters)
- ACE_Sched_Priority_Iterator (An iterator over the OS-defined scheduling priorities)
- ACE_Schedule_All_Reactive_Strategy (Defines the interface for specifying how to suspend and resume a single-threaded reactive service )
- ACE_Schedule_All_Threaded_Strategy (Defines the interface for specifying how to suspend and resume a multithreaded service )
- ACE_Scheduling_Strategy (Defines the interface for specifying how to suspend and resume a service )
- ACE_Section_Key_Internal (A base class for internal handles to section keys for configuration implementations)
- ACE_Section_Key_Win32 (The Win32 registry implementation of an internal section key)
- ACE_Select_Reactor_Handle_Set (Track handles we are interested for various events)
- ACE_Select_Reactor_Handler_Repository (Used to map s onto the appropriate *)
- ACE_Select_Reactor_Handler_Repository_Iterator (Iterate through the )
- 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_MUTEX (No description available)
- ACE_Select_Reactor_Notify (Unblock the from its event loop)
- ACE_Select_Reactor_T (An object oriented event demultiplexor and event handler dispatcher)
- ACE_Select_Reactor_Token_T (Used as a synchronization mechanism to coordinate concurrent access to a Select_Reactor object)
- ACE_Semaphore (Wrapper for Dijkstra style general semaphores)
- ACE_Service_Config (Supplies common server operations for dynamic and static configuration of services)
- ACE_Service_Handler (This base class defines the interface for the ACE_Asynch_Acceptor to call into when new connection are accepted)
- ACE_Service_Manager (Provide a standard ACE service for managing all the services configured in an )
- ACE_Service_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 * 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_Repository (Contains all the services offered by a Service Configurator-based application)
- ACE_Service_Repository_Iterator (Iterate through the )
- ACE_Service_Type (Keeps track of information related to the various subclasses)
- ACE_Service_Type_Impl (The abstract base class of the hierarchy that defines the contents of the . The subclasses of this class allow the configuration of , , and )
- 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_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 (No description available)
- ACE_Sig_Set (Provide a C++ wrapper for the C sigset_t interface)
- ACE_Singleton (A Singleton Adapter uses the Adapter pattern to turn ordinary classes into Singletons optimized with the Double-Checked Locking optimization pattern)
- ACE_Singleton_Strategy (Defines the interface for specifying a creation strategy for a <SVC_HANDLER> that always returns the same <SVC_HANDLER> (i.e., it's a Singleton))
- ACE_SOCK (An abstract class that forms the basis for more specific classes, such as and . Do not instantiate this class)
- ACE_SOCK_Acceptor (Defines a factory that creates new s passively)
- ACE_SOCK_CODgram (Defines the member functions for the ACE_SOCK connected datagram abstraction)
- ACE_Sock_Connect (No description available)
- ACE_SOCK_Connector (Defines a factory that creates new s actively)
- ACE_SOCK_Dgram (Defines the member functions for the ACE_SOCK datagram abstraction)
- ACE_SOCK_Dgram_Bcast (Defines the member functions for the ACE_SOCK datagram abstraction)
- ACE_SOCK_Dgram_Mcast (Defines the member functions for the ACE socket wrapper for UDP/IP multicast)
- ACE_SOCK_Dgram_SC ("Dgram_SC" is short for "Datagram Self-Contained.")
- ACE_SOCK_IO (Defines the methods for the ACE socket wrapper I/O routines (e.g., send/recv))
- ACE_SOCK_Stream (Defines the methods in the abstraction)
- ACE_SPIPE (Defines the member functions for the base class of the ACE_SPIPE abstraction)
- ACE_SPIPE_Acceptor (Defines the format and interface for the listener side of the ACE_SPIPE_Stream)
- ACE_SPIPE_Addr (Defines the SVR4 STREAM pipe address family address format)
- ACE_SPIPE_Connector (Defines an active connection factory for the STREAM pipe wrappers)
- ACE_SPIPE_Stream (Define an ACE_SPIPE_Stream)
- ACE_SString (A very Simple String class. This is not a general-purpose string class, and you should probably consider using is you don't understand why this class exists..)
- ACE_Static_Allocator (Defines a class that provided a highly optimized memory management scheme for allocating memory statically)
- ACE_Static_Allocator_Base (Defines a class that provided a highly optimized memory management scheme for allocating memory statically)
- ACE_Static_Function_Node (Keeps track of the symbol name for a function that is not linked in from a DLL, but is statically linked with the application)
- ACE_Static_Node (Handle a statically linked node)
- ACE_Static_Object_Lock (Provide an interface to access a global lock)
- ACE_Static_Svc_Descriptor (Holds the information necessary to describe a statically linked Svc)
- ACE_Stats (Provides simple statistical analysis)
- ACE_Stats_Value (Helper class for ACE_Stats)
- ACE_Str_Buf (Simple wrapper for STREAM pipes strbuf)
- ACE_Strategy_Acceptor (Abstract factory for creating a service handler (SVC_HANDLER), accepting into the SVC_HANDLER, and activating the SVC_HANDLER)
- ACE_Strategy_Connector (Abstract factory for creating a service handler (SVC_HANDLER), connecting the SVC_HANDLER, and activating the SVC_HANDLER)
- ACE_Stream (This class is the primary abstraction for the ASX framework. It is moduled after System V Stream)
- ACE_Stream_Head (Standard module that acts as the head of a ustream)
- ACE_Stream_Iterator (Iterate through an )
- ACE_Stream_Node (Handle a Stream)
- ACE_Stream_Tail (Standard module that acts as the head of a ustream)
- ACE_Stream_Type (Define the methods for handling the configuration of )
- ACE_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 (No description available)
- ACE_StringCapEntry (This class implement the ACE String Capability subclass)
- ACE_Strong_Bound_Ptr (This class implements support for a reference counted pointer. Assigning or copying instances of an ACE_Strong_Bound_Ptr will automatically increment the reference count of the underlying object. When the last instance of an ACE_Strong_Bound_Ptr that references a particular object is destroyed or overwritten, it will invoke delete on its underlying pointer)
- ACE_Sub_Barrier (No description available)
- ACE_Suspend_Node (Suspend a Service Node)
- ACE_SV_Message (Defines the header file for the C++ wrapper for message queues)
- ACE_SV_Message_Queue (Defines the header file for the C++ wrapper for System V IPC message queues)
- ACE_SV_Semaphore_Complex (This is a more complex semaphore wrapper that handles race conditions for initialization correctly..)
- ACE_SV_Semaphore_Simple (This is a simple semaphore package that assumes there are no race conditions for initialization (i.e., the order of process startup must be well defined))
- ACE_SV_Shared_Memory (This is a wrapper for System V shared memory)
- ACE_Svc_Conf_Lexer_Guard ("Guard" that ensures lexer buffer switching is exception-safe)
- ACE_Svc_Conf_Param (An instance of this object will be passed down to the yyparse() and yylex() functions)
- ACE_Svc_Handler (Defines the interface for a service that exchanges data with its connected peer)
- ACE_Svc_Tuple (Holds the ACE_Svc_Handler and its argument and until an asynchronous connection completes)
- ACE_Synch_Options (Contains the values of options used to determine the synchronous and asynchronous behavior)
- ACE_System_Time (Defines the timer services of the OS interface to access the system time either on the local host or on the central time server in the network)
- ACE_Task (Primary interface for application message processing, as well as input and output message queueing)
- ACE_Task_Base (Direct base class for the ACE_Task template)
- ACE_Task_Flags (These flags are used within the ACE_Task)
- ACE_Test_and_Set (Implements the classic ``test and set'' operation)
- ACE_Thread (Provides a wrapper for threads)
- ACE_Thread_Adapter (Converts a C++ function into a function 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_Barrier (Implements "barrier synchronization" using ACE_Thread_Mutexes!)
- ACE_Thread_Condition (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 , C++ or Win32 exception, "falling off the end" of the thread entry point function, etc.))
- ACE_Thread_Exit_Maybe (A version of ACE_Thread_Exit that is created dynamically under the hood if the flag is set to TRUE)
- ACE_Thread_Hook (This class makes it possible to provide user-defined "start" hooks that are called before the thread entry point function is invoked)
- ACE_Thread_ID (Defines a platform-independent thread ID)
- ACE_Thread_Manager (Manages a pool of threads)
- ACE_Thread_Mutex (ACE_Thread_Mutex wrapper (only valid for threads in the same process))
- ACE_Thread_Semaphore (Wrapper for Dijkstra style general semaphores that work only within one process)
- ACE_Thread_Strategy (Defines the interface for specifying a concurrency strategy for a <SVC_HANDLER> based on multithreading)
- ACE_Thread_Timer_Queue_Adapter (Adapts a Timer_Queue using a separate thread for dispatching)
- ACE_Throughput_Stats (A simple class to make throughput and latency analysis)
- ACE_Thru_Task (Standard module that acts as a "no op", simply passing on all data to its adjacent neighbor)
- ACE_Time_Request (Message format for delivering requests to the ACE_Time Server)
- ACE_Time_Value (Operations on "timeval" structures, which express time in <secs> and <usecs>)
- ACE_Timer_Hash_Iterator_T (Iterates over an )
- ACE_Timer_Hash_T (Provides a hash table of <BUCKET>s as an implementation for a timer queue)
- ACE_Timer_Hash_Upcall (Functor for Timer_Hash)
- ACE_Timer_Heap_Iterator_T (Iterates over an )
- ACE_Timer_Heap_T (Provides a very fast and predictable timer implementation)
- ACE_Timer_List_Iterator_T (Iterates over an )
- ACE_Timer_List_T (Provides a simple implementation of timers)
- ACE_Timer_Node_Dispatch_Info_T (Maintains generated dispatch information for Timer nodes)
- ACE_Timer_Node_T (Maintains the state associated with a Timer entry)
- ACE_Timer_Queue_Iterator_T (Generic interface for iterating over a subclass of )
- ACE_Timer_Queue_T (Provides an interface to timers)
- ACE_Timer_Wheel_Iterator_T (Iterates over an )
- ACE_Timer_Wheel_T (Provides a Timing Wheel version of Timer Queue)
- ACE_TkReactor (An object-oriented event demultiplexor and event handler dispatcher that uses the Tk functions)
- ACE_TkReactor_Input_Callback (No description available)
- ACE_TkReactorID (This little class is necessary due to the way that Microsoft implements sockets to be pointers rather than indices)
- ACE_TLI (Defines the member functions for the base class of the ACE_TLI abstraction)
- ACE_TLI_Acceptor (Defines the member functions for ACE_TLI_Acceptor abstraction)
- ACE_TLI_Connector (Defines an active connection factory for the ACE_TLI C++ wrappers)
- ACE_TLI_Request (No description available)
- ACE_TLI_Request_Queue (No description available)
- ACE_TLI_Stream (Defines the member functions for ACE_TLI_Stream abstraction)
- ACE_Token (Class that acquires, renews, and releases a synchronization token that is serviced in strict FIFO ordering and that also supports (1) recursion and (2) readers/writer semantics)
- ACE_Token::ACE_Token_Queue (No description available)
- ACE_Token::ACE_Token_Queue_Entry (No description available)
- ACE_Tokenizer (Tokenizer)
- ACE_TP_Reactor (Specialization of Select Reactor to support thread-pool based event dispatching)
- ACE_TP_Token_Guard (A helper class that helps grabbing, releasing and waiting on tokens for a thread that tries calling handle_events ())
- ACE_Trace (A C++ trace facility that keeps track of which methods are entered and exited)
- ACE_TSS (Allows objects that are "physically" in thread specific storage (i.e., private to a thread) to be accessed as though they were "logically" global to a program)
- ACE_TSS_Adapter (This class encapsulates a TSS object and its associated C++ destructor function. It is used by the ACE_TSS... methods (in Synch_T.cpp) in order to allow an extern "C" cleanup routine to be used. Needed by the "frigging" MVS C++ compiler)
- ACE_TSS_Cleanup (No description available)
- 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 (This class uses the Adapter pattern to turn ordinary classes into Thread-specific Singletons optimized with the Double-Checked Locking optimization pattern)
- ACE_TSS_Type_Adapter (Adapter that allows built-in types to be used with ACE_TSS)
- ACE_TTY_IO (Class definitions for platform specific TTY features)
- ACE_Typed_SV_Message (Defines the header file for the C++ wrapper for System V message queues)
- ACE_Typed_SV_Message_Queue (Defines the header file for the C++ wrapper facade for typed message queues)
- ACE_Unbounded_Queue (A Queue of "infinite" length)
- ACE_Unbounded_Queue_Iterator (Implement an iterator over an unbounded queue)
- ACE_Unbounded_Set (Implement a simple unordered set of <T> of unbounded size)
- ACE_Unbounded_Set_Const_Iterator (Implement an const iterator over an unbounded set)
- ACE_Unbounded_Set_Iterator (Implement an iterator over an unbounded set)
- ACE_Unbounded_Stack (Implement a generic LIFO abstract data type)
- ACE_Unbounded_Stack_Iterator (Implement an iterator over an unbounded Stack)
- ACE_UNIX_Addr (Defines the ``UNIX domain address family'' address format)
- ACE_Unmanaged_Singleton (Same as , except does _not_ register with for destruction)
- ACE_Unmanaged_TSS_Singleton (Same as , except does _not_ register with 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 wrappers)
- ACE_UPIPE_Stream (Defines the method that transfer data on a UPIPE)
- ACE_Wakeup_All_Threads_Handler (This is a helper class whose sole purpose is to handle events on wakeup_all_threads_>)
- ACE_WChar_Codeset_Translator (Codeset translation routines common to both Output and Input CDR streams)
- ACE_Weak_Bound_Ptr (This class implements support for a weak pointer that complements ACE_Strong_Bound_Ptr. Unlike ACE_Strong_Bound_Ptr, assigning or copying instances of an ACE_Weak_Bound_Ptr will not automatically increment the reference count of the underlying object. What ACE_Weak_Bound_Ptr does is preserve the knowledge that the object is in fact reference counted, and thus provides an alternative to raw pointers where non-ownership associations must be maintained. When the last instance of an ACE_Strong_Bound_Ptr that references a particular object is destroyed or overwritten, the corresponding ACE_Weak_Bound_Ptr instances are set to null)
- ACE_WFMO_Reactor (An object oriented event demultiplexor and event handler WFMO_Reactor for Win32 WaitForMultipleObjects)
- ACE_WFMO_Reactor_Handler_Repository (Used to map s onto the appropriate * and other information)
- ACE_WFMO_Reactor_Notify (Unblock the from its event loop, passing it an optional to dispatch)
- ACE_WIN32_Asynch_Accept (This class is a factory for starting off asynchronous accepts on a listen handle)
- ACE_WIN32_Asynch_Accept_Result (This class implements ACE_Asynch_Accept::Result for WIN32 platform)
- ACE_WIN32_Asynch_Operation (This class abstracts out the common things needed for implementing Asynch_Operation for WIN32 platform)
- ACE_WIN32_Asynch_Read_Dgram (This class is a factory for starting off asynchronous reads on a UDP socket)
- ACE_WIN32_Asynch_Read_Dgram_Result (This is class provides concrete implementation for ACE_Asynch_Read_Dgram::Result class)
- ACE_WIN32_Asynch_Read_File (This class is a factory for starting off asynchronous reads on a file)
- ACE_WIN32_Asynch_Read_File_Result (This is class provides concrete implementation for ACE_Asynch_Read_File::Result class)
- ACE_WIN32_Asynch_Read_Stream (This class is a factory for starting off asynchronous reads on a stream)
- ACE_WIN32_Asynch_Read_Stream_Result (This is class provides concrete implementation for ACE_Asynch_Read_Stream::Result class)
- ACE_WIN32_Asynch_Result (An abstract class which adds information to the OVERLAPPED structure to make it more useful)
- ACE_WIN32_Asynch_Timer (This class is posted to the completion port when a timer expires. When the complete method of this object is called, the <handler>'s handle_timeout method will be called)
- ACE_WIN32_Asynch_Transmit_File (This class is a factory for starting off asynchronous transmit files on a stream)
- ACE_WIN32_Asynch_Transmit_File_Result (This class implements ACE_Asynch_Transmit_File::Result for WIN32 platforms)
- ACE_WIN32_Asynch_Write_Dgram (This class is a factory for starting off asynchronous writes on a UDP socket)
- ACE_WIN32_Asynch_Write_Dgram_Result (This is class provides concrete implementation for ACE_Asynch_Write_Dgram::Result class)
- ACE_WIN32_Asynch_Write_File (This class is a factory for starting off asynchronous writes on a file)
- ACE_WIN32_Asynch_Write_File_Result (This class provides implementation for ACE_Asynch_Write_File_Result for WIN32 platforms)
- ACE_WIN32_Asynch_Write_Stream (This class is a factory for starting off asynchronous writes on a stream)
- ACE_WIN32_Asynch_Write_Stream_Result (This is class provides concrete implementation for ACE_Asynch_Write_Stream::Result class)
- ACE_WIN32_Proactor (A manager for asynchronous event demultiplexing)
- ACE_WIN32_Wakeup_Completion (No description available)
- ACE_Write_Guard (This class is similar to class , though it acquires/releases a write lock automatically (naturally, the it is instantiated with must support the appropriate API))
- ACE_Write_Guard< ACE_Null_Mutex > (No description available)
- ACE_WString (This class provides a wrapper facade for C wide strings)
- ACE_XtReactor (An object-oriented event demultiplexor and event handler dispatcher that uses the X Toolkit functions)
- ACE_XtReactorID (This little class is necessary due to the way that Microsoft implements sockets to be pointers rather than indices)
- ace_yy_buffer_state (No description available)
- ACE_YYSTYPE (No description available)
- aiocb (No description available)
- auto_ptr (Implements the draft C++ standard auto_ptr abstraction)
- ACE_Registry::Binding (No description available)
- ACE_Registry::Binding_Iterator (An iterator)
- ACE_Asynch_Write_Dgram::brief (No description available)
- ACE_Asynch_Write_Stream::brief (No description available)
- cancel_state (No description available)
- ACE_MT_MEM_IO::Channel (No description available)
- 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_Registry::Binding_Iterator::Context_Iteration (No description available)
- ACE_Pagefile_Memory_Pool::Control_Block (Attributes that are meaningful in local storage only)
- ACE_WFMO_Reactor_Handler_Repository::Current_Info (This structure inherits from the common structure to add information for current entries)
- ACE_Tokenizer::Delimiter_Entry (Delimiter Entry)
- dirent (No description available)
- ACE_CDR::Double (No description available)
- ACE_CDR::Float (No description available)
- ACE_OutputCDR::from_boolean (No description available)
- ACE_OutputCDR::from_char (No description available)
- ACE_OutputCDR::from_octet (No description available)
- ACE_OutputCDR::from_string (No description available)
- ACE_OutputCDR::from_wchar (No description available)
- ACE_OutputCDR::from_wstring (No description available)
- Hash_Token (No description available)
- 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)
- iostream (No description available)
- iovec (No description available)
- ip_mreq (No description available)
- ACE_Registry::Binding_Iterator::Iteration_Complete (No description available)
- ACE_Registry::Binding_Iterator::Iteration_State (No description available)
- ACE_Active_Map_Manager_Key::key_data (Data for the Active Object Map Key)
- ACE_CDR::LongDouble (No description available)
- ACE_MT_MEM_IO::MQ_Struct (No description available)
- msghdr (No description available)
- msqid_ds (No description available)
- ACE_Registry::Name_Component (International string)
- ACE_Registry::Naming_Context (An context representation)
- ACE_Registry::Object (An object representation)
- ACE_Registry::Binding_Iterator::Object_Iteration (No description available)
- OVERLAPPED (No description available)
- ACE_Tokenizer::Preserve_Entry (Preserve Entry)
- QObject (No description available)
- ACE_Asynch_Write_Dgram::Result (No description available)
- 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_Transmit_File::Result (This is that class which will be passed back to the <handler> when the asynchronous transmit file completes)
- ACE_Asynch_Accept::Result (This is that class which will be passed back to the <handler> when the asynchronous accept completes)
- 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_Write_Stream::Result (No description available)
- ACE_Asynch_Read_Stream::Result (This is the class which will be passed back to the <handler> when the asynchronous read completes. This class forwards all the methods to the implementation classes)
- rusage (No description available)
- ACE_Bounded_Set::Search_Structure (No description available)
- semun (No description available)
- ACE_TTY_IO::Serial_Params (No description available)
- ACE_Pagefile_Memory_Pool::Control_Block::Shared_Control_Block (Pool statistics)
- ACE_Shared_Memory_Pool::SHM_TABLE (No description available)
- shmaddr (No description available)
- siginfo_t (No description available)
- ACE_MT_MEM_IO::Simple_Queue (No description available)
- ACE_SPIPE_Addr::SPIPE_Addr (Contains security attributes)
- strbuf (No description available)
- STREAM (No description available)
- streambuf (No description available)
- ACE_WFMO_Reactor_Handler_Repository::Suspended_Info (This structure inherits from the common structure to add information for suspended entries)
- timespec (No description available)
- 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 (No description available)
- ACE_InputCDR::to_char (No description available)
- ACE_InputCDR::to_octet (No description available)
- ACE_InputCDR::to_string (No description available)
- ACE_InputCDR::to_wchar (No description available)
- ACE_InputCDR::to_wstring (No description available)
- ACE_Time_Request::Transfer (No description available)
- ACE_Name_Reply::Transfer (No description available)
- ACE_Name_Request::Transfer (No description available)
- ACE_InputCDR::Transfer_Contents (Helper class to transfer the contents from one input CDR to another without requiring any extra memory allocations, data copies or too many temporaries)
- ACE_ODB::Tuple (No description available)