Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
ACE_Accept_QoS_ParamsWrapper class that simplifies the information passed to the QoS enabled <ACE_OS::accept> method
ACE_Accept_Strategy< SVC_HANDLER, >Defines the interface for specifying a passive connection acceptance strategy for a SVC_HANDLER
ACE_Acceptor< SVC_HANDLER, >Abstract factory for creating a service handler (SVC_HANDLER), accepting into the SVC_HANDLER, and activating the SVC_HANDLER
ACE_Activation_QueueReifies 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_KeyKey used in the Active Object Map
ACE_Active_Map_Manager_Key::key_dataData for the Active Object Map Key
ACE_Active_Map_Manager_Reverse_Iterator_Adapter< T, VALUE >Defines a reverse iterator implementation for the Active_Map_Manager_Adapter
ACE_Adaptive_LockAn adaptive general locking class that defers the decision of lock type to run time
ACE_AddrDefines the base class for the "address family independent" address format
ACE_AllocatorInterface 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_ConverterTo 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_WideA lightweight char* to wchar* string conversion class
ACE_Async_Timer_Queue_Adapter< TQ >Adapts an ACE timer queue to be driven asynchronously using signals
ACE_Asynch_Pseudo_Task
ACE_At_Thread_ExitContains a method to be applied when a thread is terminated
ACE_At_Thread_Exit_Func
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_EventAuto Events
ACE_Auto_IncDec< ACE_SAFELY_INCREMENTABLE_DECREMENTABLE >This class automatically increments and decrements a parameterized counter
ACE_Auto_Ptr< X >Implements the draft C++ standard auto_ptr abstraction. This version can be used instead of auto_ptr<T>, and obviates the need for the ACE_AUTO_PTR_RESET macro on platforms like VC6 where the auto_ptr<T> is broken
ACE_Auto_String_FreeSimple class to automatically de-allocate strings
ACE_BarrierThis is a no-op to make ACE "syntactically consistent."
ACE_Base64Encode/Decode a stream of bytes according to Base64 encoding
ACE_Base_Thread_AdapterBase 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_RepositoryMaps pointers to the base address of the region to which each pointer belongs
ACE_Based_Pointer_Repository_RepImplementation for the ACE_Based_Pointer_Repository
ACE_Basic_StatsCollect basic stats about a series of samples
ACE_Bcast_NodeLinked list of broadcast interfaces
ACE_BoolCapEntryThis class implement the ACE Bool Capability subclass
ACE_Bound_Ptr_Counter< ACE_LOCK >An ACE_Bound_Ptr_Counter<ACE_LOCK> object encapsulates an object reference count
ACE_Bounded_Cached_Connect_Strategy< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >A connection strategy which caches connections to peers (represented by SVC_HANDLER instances), thereby allowing subsequent re-use of unused, but available, connections. This strategy should be used when the cache is bounded by maximum size
ACE_Bounded_Set< T >Implement a simple unordered set of {T} with maximum set at creation time
ACE_Bounded_Set< T >::Search_Structure
ACE_Bounded_Set_Iterator< T >Iterates through an unordered set
ACE_Bounded_Stack< T >Implement a generic LIFO abstract data type
ACE_Buffered_Svc_Handler<, >Defines the interface for a service that exchanges data with its connected peer and supports buffering
ACE_Cache_Map_Iterator< KEY, VALUE, IMPLEMENTATION, CACHING_STRATEGY, ATTRIBUTES >Defines a iterator for the Cache_Map_Manager
ACE_Cache_Map_Manager< KEY, VALUE, CMAP_TYPE, ITERATOR_IMPL, REVERSE_ITERATOR_IMPL, CACHING_STRATEGY, ATTRIBUTES >Defines a abstraction that will purge entries from a map
ACE_Cache_Map_Reverse_Iterator< KEY, VALUE, REVERSE_IMPLEMENTATION, CACHING_STRATEGY, ATTRIBUTES >Defines a reverse iterator for the Cache_Map_Manager
ACE_Cached_Allocator< T, ACE_LOCK >A fixed-size allocator that caches items for quicker access
ACE_Cached_Connect_Strategy< SVC_HANDLER,, MUTEX >A connection strategy which caches connections to peers (represented by SVC_HANDLER instances), thereby allowing subsequent re-use of unused, but available, connections
ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >A connection strategy which caches connections to peers (represented by SVC_HANDLER instances), thereby allowing subsequent re-use of unused, but available, connections
ACE_Cached_Mem_Pool_Node< T >ACE_Cached_Mem_Pool_Node keeps unused memory within a free list
ACE_Caching_Strategy< ATTRIBUTES, CACHING_UTILITY >This class is an abstract base class for a caching strategy
ACE_Caching_Strategy_Adapter< ATTRIBUTES, CACHING_UTILITY, IMPLEMENTATION >This class follows the Adaptor pattern and is used to provide External Polymorphism by deriving from ACE_Caching_Strategy
ACE_CapabilitiesThis class implement the ACE Capabilities
ACE_CapEntryThis class is the base class for all ACE Capabilities entry subclasses
ACE_CDRKeep constants and some routines common to both Output and Input CDR streams
ACE_CDR::Double
ACE_CDR::Float
ACE_CDR::LongDouble
ACE_Char_Codeset_TranslatorCodeset translation routines common to both Output and Input CDR streams
ACE_CleanupBase 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_InfoHold cleanup information for thread/process
ACE_Cleanup_Info_NodeFor maintaining a list of ACE_Cleanup_Info items
ACE_Cleanup_Strategy< KEY, VALUE, CONTAINER >Defines a default strategy to be followed for cleaning up entries from a map which is the container
ACE_Codeset_Registry
ACE_Codeset_Registry::registry_entry
ACE_Command_BaseDefines 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_Config_ImpExp_BaseBase class for file import/export configuration
ACE_ConfigurationBase class for configuration databases
ACE_Configuration_ExtIdExternal ID for the section and value hash
ACE_Configuration_HeapThe concrete implementation of a allocator based configuration database
ACE_Configuration_Section_IntIdThe internal ID for a section hash table
ACE_Configuration_Section_KeyReference counted wrapper for ACE_Section_Key_Internal
ACE_Configuration_Section_Key_HeapInternal section key class for heap based configuration database
ACE_Configuration_Value_IntIdThe section hash table internal value class
ACE_Configuration_Win32RegistryThe win32 registry implementation of a configuration database
ACE_Connect_Strategy< SVC_HANDLER, >Defines the interface for specifying an active connection establishment strategy for a SVC_HANDLER
ACE_Connection_Recycling_StrategyDefines the interface for a connection recycler
ACE_Connector< SVC_HANDLER, >Generic factory for actively connecting clients and creating service handlers (SVC_HANDLERs)
ACE_Connector_Base< SVC_HANDLER >This base interface allows ACE_NonBlocking_Connect_Handler to only care about the SVC_HANDLER template parameter of the ACE_Connector. Otherwise, ACE_NonBlocking_Connect_Handler would have to be configured with all the template parameters that ACE_Connector is configured with
ACE_Control_BlockThis information is stored in memory allocated by the <Memory_Pool>
ACE_Control_Block::ACE_Malloc_HeaderThis is the control block header. It's used by <ACE_Malloc> to keep track of each chunk of data when it's in the free list or in use
ACE_Control_Block::ACE_Name_NodeThis class supports "named memory regions" within ACE_Malloc
ACE_Copy_DisabledHelper class to disable copy construction and assignment
ACE_Countdown_TimeKeeps track of the amount of elapsed time
ACE_Creation_Strategy< SVC_HANDLER >Defines the interface for specifying a creation strategy for a SVC_HANDLER
ACE_Data_BlockStores the data payload that is accessed via one or more ACE_Message_Block's
ACE_Date_TimeSystem independent representation of date and time
ACE_Deadline_Message_StrategyDeadline based message priority strategy
ACE_DEVDefines the member functions for the base class of the ACE_DEV abstraction
ACE_DEV_AddrDefines device address family address format
ACE_DEV_ConnectorDefines an active connection factory for the ACE_DEV wrappers
ACE_DEV_IORead/Write operations on Devices
ACE_DirentDefine a portable C++ directory-entry iterator based on the POSIX API
ACE_Dirent_SelectorDefine a portable C++ directory-entry iterator based on the POSIX scandir API
ACE_DLLProvides an abstract interface for handling various DLL operations
ACE_DLL_HandleProvides an abstract interface for handling various DLL operations
ACE_DLL_ManagerThis 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_NodeBase 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_DumpableBase 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_PtrA smart pointer stored in the in-memory object database ACE_ODB. The pointee (if any) is deleted when reassigned
ACE_DynamicChecks to see if an object was dynamically allocated
ACE_Dynamic_Cached_Allocator< ACE_LOCK >A size-based allocator that caches blocks for quicker access
ACE_Dynamic_Message_Queue<>A derived class which adapts the ACE_Message_Queue class in order to maintain dynamic priorities for enqueued <ACE_Message_Blocks> and manage the queue order according to these dynamic priorities
ACE_Dynamic_Message_StrategyAn 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_BaseBase class for all ACE_Dynamic_Service instantiations
ACE_Dynamic_Service_DependencyProvides 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_EH_Dispatch_InfoThis structure contains information of the activated event handler
ACE_Env_Value< T >Environment Variable Value
ACE_Equal_To< TYPE >Function object for determining whether two const strings are equal
ACE_Equal_To< ACE_CString >
ACE_Equal_To< ACE_INT16 >
ACE_Equal_To< ACE_INT32 >
ACE_Equal_To< ACE_UINT16 >
ACE_Equal_To< ACE_UINT32 >
ACE_Equal_To< ACE_UINT64 >
ACE_Equal_To< char * >
ACE_Equal_To< const char * >
ACE_Equal_To< const wchar_t * >
ACE_Equal_To< wchar_t * >
ACE_Errno_GuardProvides a wrapper to improve performance when thread-specific errno must be saved and restored in a block of code
ACE_EventA wrapper around the Win32 event locking mechanism
ACE_Event_DescriptionsEvent Descriptions
ACE_Event_HandlerProvides an abstract interface for handling various types of I/O, timer, and signal events
ACE_Event_Handler::PolicyBase class for all handler policies
ACE_Event_Handler::Reference_Counting_PolicyThis policy dictates the reference counting requirements for the handler
ACE_Event_Handler_Handle_Timeout_Upcall< ACE_LOCK >Functor for Timer_Queues
ACE_Event_Handler_T< T >Enable a class that doesn't inherit from the ACE_Event_Handler to be incorporated into the ACE_Reactor framework. Thanks to Greg Lavender (g.lavender@isode.com) for sharing this idea
ACE_Event_Handler_varAuto pointer like class for Event Handlers
ACE_Event_TupleAn ACE_Event_Handler and its associated ACE_HANDLE
ACE_FIFOAbstract 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_RecvReceiver side of the bytestream C++ wrapper for UNIX FIFOs
ACE_FIFO_Recv_MsgReceiver side for the record oriented C++ wrapper for UNIX FIFOs
ACE_FIFO_SendSender side for the bytestream C++ wrapper for UNIX FIFOs
ACE_FIFO_Send_MsgSender side for the Record oriented C++ wrapper for UNIX FIFOs
ACE_FILEDefines the core methods of the ACE_FILE abstraction
ACE_FILE_AddrDefines the FILE address family address format
ACE_FILE_ConnectorDefines an active connection factory for the ACE_FILE wrappers
ACE_FILE_InfoAbstracts basic OS FILE information
ACE_FILE_IORead/Write operations on Files
ACE_File_LockA wrapper around the UNIX file locking mechanism
ACE_FilecacheA 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_HandleAbstraction over a real file. This is meant to be the entry point into the Cached Virtual Filesystem
ACE_Filecache_ObjectAbstraction 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_tOS file locking structure
ACE_Flow_SpecWrapper class that defines the flow spec QoS information, which is used by IntServ (RSVP) and DiffServ
ACE_Framework_ComponentBase 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_RepositoryContains 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 which allows the values of a collection of ACE_Future objects to be accessed by reader threads as they become available. The caller(s) provide the ACE_Future_Set (i.e. the observer...) with the collection of ACE_Future objects (i.e. the subjects...) that are to be observed using the the ACE_Future_Set::insert() method. The caller(s) may then iterate over the collection in the order in which they become readable using the ACE_Future_Set::next_readable() method
ACE_Get_OptIterator for parsing command-line arguments
ACE_Get_Opt::ACE_Get_Opt_Long_Option
ACE_Guard< ACE_LOCK >This data structure is meant to be used within a method or function... It performs automatic aquisition and release of a parameterized synchronization object <ACE_LOCK>
ACE_Guard< ACE_Null_Mutex >
ACE_Handle_GobblerThis class gobbles up handles
ACE_Handle_SetC++ wrapper facade for the socket fd_set abstraction
ACE_Handle_Set_IteratorIterator for the ACE_Handle_Set abstraction
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 a char
ACE_Hash< ACE_CString >
ACE_Hash< ACE_INT64 >
ACE_Hash< ACE_UINT64 >
ACE_Hash< char * >
ACE_Hash< char >
ACE_Hash< const char * >
ACE_Hash< const wchar_t * >
ACE_Hash< int >
ACE_Hash< long >
ACE_Hash< short >
ACE_Hash< signed char >
ACE_Hash< unsigned char >
ACE_Hash< unsigned int >
ACE_Hash< unsigned long >
ACE_Hash< unsigned short >
ACE_Hash< void * >
ACE_Hash< wchar_t * >
ACE_Hash< 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_HashableACE_Hashable
ACE_High_Res_TimerA high resolution timer class wrapper that encapsulates OS-specific high-resolution timers, such as those found on Solaris, AIX, Win32/Pentium, and VxWorks
ACE_Incremental_Key_Generator< T >Defines a simple incremental key generator
ACE_INET_AddrDefines a C++ wrapper facade for the Internet domain address family format
ACE_Ini_ImpExpImports 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_InputCDRA CDR stream for reading, i.e. for demarshalling
ACE_InputCDR::to_boolean
ACE_InputCDR::to_char
ACE_InputCDR::to_octet
ACE_InputCDR::to_string
ACE_InputCDR::to_wchar
ACE_InputCDR::to_wstring
ACE_InputCDR::Transfer_Contents
ACE_IntCapEntryThis class implement the ACE Integer Capability subclass
ACE_Intrusive_Auto_Ptr< X >This class implements support for a reference counted auto_ptr. It assumes refernce 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_MsgData format for IOCTL messages
ACE_IO_SAPDefines 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_SAPDefines 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_StrategyLaxity based message priority strategy
ACE_Less_Than< TYPE >Function object for determining whether the first const string is less than the second const string
ACE_Less_Than< ACE_CString >
ACE_Less_Than< char * >
ACE_Less_Than< const char * >
ACE_Less_Than< const wchar_t * >
ACE_Less_Than< wchar_t * >
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_PoolMake a ``lighter-weight'' memory pool based ACE_Mem_Map
ACE_Local_Memory_PoolMake 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_OptionsHelper class for Local Memory Pool constructor options
ACE_Local_Name_Space<, ACE_LOCK >Maintaining accesses Local Name Server Database. Allows to add NameBindings, change them, remove them and resolve NameBindings
ACE_LockThis 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_MsgProvides a variable length argument message logging abstraction
ACE_Log_Msg_BackendDefines the interface for ACE_Log_Msg back end processing
ACE_Log_Msg_CallbackAn interface class used to get logging callbacks
ACE_Log_Msg_IPCDefines the interfaces for ACE_Log_Msg backend
ACE_Log_Msg_ManagerSynchronize output operations
ACE_Log_Msg_UNIX_SyslogImplements an ACE_Log_Msg_Backend that logs messages to a UNIX system's syslog facility
ACE_Log_RecordDefines the structure of an ACE logging record
ACE_Logging_StrategyThis 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_LSOCKCreate a Local ACE_SOCK, which is used for passing file descriptors
ACE_LSOCK_AcceptorDefines the format and interface for the acceptor side of the local ACE_SOCK ACE_Stream
ACE_LSOCK_CODgramDefines the member functions for the <ACE_LSOCK> connected datagram abstraction
ACE_LSOCK_ConnectorDefines the format and interface for the connector side of the ACE_LSOCK_Stream
ACE_LSOCK_DgramCreate a Local ACE_SOCK datagram
ACE_LSOCK_StreamCreate a Local ACE_SOCK stream
ACE_Malloc<, ACE_LOCK >
ACE_Malloc_FIFO_Iterator<, ACE_LOCK >
ACE_Malloc_FIFO_Iterator_T<, ACE_LOCK, ACE_CB >FIFO iterator for names stored in Malloc'd memory
ACE_Malloc_LIFO_Iterator<, ACE_LOCK >
ACE_Malloc_LIFO_Iterator_T<, ACE_LOCK, ACE_CB >LIFO iterator for names stored in Malloc'd memory
ACE_Malloc_Lock_Adapter_T< ACE_LOCK >Template functor adapter for lock strategies used with ACE_Malloc_T
ACE_Malloc_Lock_Adapter_T< ACE_Null_Mutex >
ACE_Malloc_Lock_Adapter_T< ACE_Process_Semaphore >
ACE_Malloc_T<, 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_ProcessA process easily managed by ACE_Process_Manager
ACE_Manual_EventManual Events
ACE_Map< KEY, VALUE >Defines a map interface
ACE_Map_Const_Iterator< EXT_ID, INT_ID, ACE_LOCK >Forward const iterator for the ACE_Map_Manager
ACE_Map_Const_Iterator_Base< EXT_ID, INT_ID, ACE_LOCK >Const iterator for the ACE_Map_Manager
ACE_Map_Entry< EXT_ID, INT_ID >An entry in the Map
ACE_Map_Impl< KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY >Defines a map implementation
ACE_Map_Impl_Iterator_Adapter< T, IMPLEMENTATION, ENTRY >Defines a iterator implementation for the Map_Impl class
ACE_Map_Impl_Reverse_Iterator_Adapter< T, IMPLEMENTATION, ENTRY >Defines a reverse iterator implementation for the Map_Impl class
ACE_Map_Iterator< EXT_ID, INT_ID, ACE_LOCK >Forward iterator for the ACE_Map_Manager
ACE_Map_Iterator_Base< EXT_ID, INT_ID, ACE_LOCK >Iterator for the ACE_Map_Manager
ACE_Map_Manager< EXT_ID, INT_ID, ACE_LOCK >Define a map abstraction that associates <EXT_ID>s with <INT_ID>s
ACE_Map_Manager_Adapter< KEY, VALUE, KEY_GENERATOR >Defines a map implementation
ACE_Map_Manager_Iterator_Adapter< T, KEY, VALUE >Defines a iterator implementation for the Map_Manager_Adapter
ACE_Map_Manager_Reverse_Iterator_Adapter< T, KEY, VALUE >Defines a reverse iterator implementation for the Map Manager
ACE_Map_Reverse_Iterator< EXT_ID, INT_ID, ACE_LOCK >Reverse Iterator for the ACE_Map_Manager
ACE_max_align_info
ACE_MEM_AcceptorDefines the format and interface for the acceptor side of the local mmap stream
ACE_Mem_MapC++ interface OS memory mapping system call
ACE_Message_BlockStores messages for use throughout ACE (particularly in an ACE_Message_Queue)
ACE_Message_Queue<>A message queueing facility with parameterized synchronization capability. ACE_Message_Queue is modeled after the queueing facilities in System V STREAMs
ACE_Message_Queue_BaseBase class for ACE_Message_Queue, which is the central queueing facility for messages in the ACE framework
ACE_Message_Queue_Ex< ACE_MESSAGE_TYPE, >A threaded message queueing facility, modeled after the queueing facilities in System V STREAMs
ACE_Message_Queue_Ex_N< ACE_MESSAGE_TYPE, >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_Factory<>ACE_Message_Queue_Factory is a static factory class template which provides a separate factory method for each of the major kinds of priority based message dispatching: static, earliest deadline first (EDF), and minimum laxity first (MLF)
ACE_Message_Queue_Iterator<>Iterator for the ACE_Message_Queue
ACE_Message_Queue_Reverse_Iterator<>Reverse Iterator for the ACE_Message_Queue
ACE_Method_RequestReifies a method into a request. Subclasses must provide the necessary state and behavior
ACE_MMAP_Memory_PoolMake a memory pool that is based on mmap(2). This implementation allows memory to be shared between processes
ACE_MMAP_Memory_Pool_OptionsHelper class for MMAP Memory Pool constructor options
ACE_Module<>An abstraction for managing a bi-directional flow of messages
ACE_Module_BaseWorkaround HP/C++ compiler bug with enums in templates
ACE_Module_TypeDefine the methods for handling the configuration of ACE_Modules
ACE_Msg_Log_Cleanup
ACE_Multihomed_INET_AddrExtends ACE_INET_Addr with support for multi-homed addresses
ACE_MutexACE_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_Name_BindingMaintains a mapping from name to value and type
ACE_Name_OptionsManages the options for the ACE Name_Server
ACE_Name_ProxyProxy for dealing with remote server process managing NET_LOCAL NameBindings
ACE_Name_ReplyMessage format for delivering replies from the ACE_Name Server
ACE_Name_Reply::Transfer
ACE_Name_RequestMessage format for delivering requests to the ACE_Name Server
ACE_Name_Request::Transfer
ACE_Name_SpaceAbstract 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_ContextMaintaining accesses Name Server Databases. Allows to add NameBindings, change them, remove them and resolve NameBindings
ACE_New_AllocatorDefines a class that provided a simple implementation of memory allocation
ACE_Node< T >Implementation element in a Queue, Set, and Stack
ACE_NonBlocking_Connect_Handler< SVC_HANDLER >Performs non-blocking connects on behalf of the Connector
ACE_NOOP_Concurrency_Strategy< SVC_HANDLER >Implements a no-op activation strategy in order to avoid calling open on a svc_handler multiple times
ACE_NOOP_Creation_Strategy< SVC_HANDLER >Implements a no-op creation strategy in order to defer decisions regarding creation to some later point in time, such as in connect or accept strategy
ACE_Noop_Key_Generator< T >Defines a noop key generator
ACE_Noop_Token
ACE_Notification_BufferSimple wrapper for passing <ACE_Event_Handler *>s and ACE_Reactor_Masks between threads
ACE_Notification_QueueImplements a user-space queue to send Reactor notifications
ACE_Notification_Queue_NodeHelper class
ACE_Notification_StrategyAbstract class used for notifying an interested party
ACE_NS_InternalThis class and ACE_NS_String are used as Adapters to work with the Map_Manager
ACE_NS_StringThis class and ACE_NS_Internal are used as Adapters to work with the Map_Manager
ACE_NS_WStringThis 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_Null_BarrierImplements "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_ConditionImplement 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_MutexImplement a do nothing ACE_Mutex, i.e., all the methods are no ops
ACE_Null_SemaphoreImplement a do nothing ACE_Semaphore, i.e., all the methods are no ops
ACE_Numeric_Limits< T >
ACE_ObchunkDefines 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_ManagerManager for ACE library services and singleton cleanup
ACE_Object_Manager_BaseBase class for ACE_Object_Manager(s)
ACE_Object_Manager_ManagerEnsure that the ACE_Object_Manager gets initialized at program startup, and destroyed at program termination
ACE_Object_Manager_PreallocationsPerforms preallocations of certain statically allocated services needed by ACE
ACE_Obstack_T< CHAR >Define a simple "mark and release" memory allocation utility
ACE_ODBThis is the object database (ODB) that keeps track of all live ACE objects
ACE_ODB::Tuple
ACE_Oneshot_Acceptor< SVC_HANDLER, >Generic factory for passively connecting clients and creating exactly one service handler (SVC_HANDLER)
ACE_Ordered_MultiSet< T >Implement a simple ordered multiset of {T} of unbounded size that allows duplicates. This class template requires that < operator semantics be defined for the parameterized type {T}, but does not impose any restriction on how that ordering operator is implemented. The set is implemented as a linked list
ACE_Ordered_MultiSet_Iterator< T >Implement a bidirectional iterator over an ordered multiset. This class template requires that < operator semantics be defined for the parameterized type {T}, but does not impose any restriction on how that ordering operator is implemented
ACE_OS_Exit_InfoHold Object Manager cleanup (exit) information
ACE_OS_Log_Msg_AttributesThe attributes required by ACE_Log_Msg
ACE_OS_Object_Manager
ACE_OS_Object_Manager_ManagerEnsure that the ACE_OS_Object_Manager gets initialized at program startup, and destroyed at program termination
ACE_OS_Thread_AdapterConverts 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_DescriptorParent class of all ACE_Thread_Descriptor classes. = Container for ACE_Thread_Descriptor members that are used in ACE_OS
ACE_OutputCDRA CDR stream for writing, i.e. for marshalling
ACE_OutputCDR::from_boolean
ACE_OutputCDR::from_char
ACE_OutputCDR::from_octet
ACE_OutputCDR::from_string
ACE_OutputCDR::from_wchar
ACE_OutputCDR::from_wstring
ACE_Pair< T1, T2 >Defines a pair
ACE_Pair_Caching_Utility< KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES >Defines a helper class for the Caching Strategies
ACE_PipeProvides a portable bidirectional "pipe" abstraction
ACE_Pointer_Hash< TYPE >Function object for hashing pointers
ACE_Priority_ReactorImplements priority based dispatching
ACE_Proactor
ACE_Proactor::Timer_Queue
ACE_Proactor_Timer_HandlerA Handler for timer. It helps in the management of timers registered with the Proactor
ACE_ProcessProcess
ACE_Process_ManagerManages a group of processes
ACE_Process_Manager::Process_DescriptorInformation describing each process that's controlled by an ACE_Process_Manager
ACE_Process_MutexA wrapper for mutexes that can be used across processes on the same host machine, as well as within a process, of course
ACE_Process_OptionsProcess Options
ACE_Process_SemaphoreWrapper 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_TimerThis class provides both a timing mechanism and a mechanism for reporting the resource usage of a process
ACE_Profile_Timer::ACE_Elapsed_TimeKeeps track of the various user, system, and elapsed (real) times
ACE_Protocol_Info
ACE_QoSWrapper class that holds the sender and receiver flow spec information, which is used by IntServ (RSVP) and DiffServ
ACE_QoS_ParamsWrapper 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_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_ReactorThe responsibility of this class is to forward all methods to its delegation/implementation class, e.g., ACE_Select_Reactor or ACE_WFMO_Reactor
ACE_Reactor_ImplAn abstract class for implementing the Reactor Pattern
ACE_Reactor_Notification_StrategyUsed to notify an ACE_Reactor
ACE_Reactor_NotifyAbstract class for unblocking an ACE_Reactor_Impl from its event loop
ACE_Reactor_Timer_InterfaceInterface 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_BufferEfficiently reads an artibrarily large buffer from an input stream up to and including a termination character. Also performs search/replace on single occurrences a character in the buffer using the principles of Integrated Layer Processing
ACE_Read_Guard< ACE_LOCK >This class is similar to class ACE_Guard, though it acquires/releases a read lock automatically (naturally, the <ACE_LOCK> it is instantiated with must support the appropriate API)
ACE_Read_Guard< ACE_Null_Mutex >
ACE_recursive_mutex_state
ACE_recursive_thread_mutex_tImplement a thin C++ wrapper that allows nested acquisition and release of a mutex that occurs in the same thread
ACE_Recyclable
ACE_Recyclable_Handler_Caching_Utility< KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES >Defines a helper class for the Caching Strategies
ACE_Recyclable_Handler_Cleanup_Strategy< KEY, VALUE, CONTAINER >Defines a strategy to be followed for cleaning up entries which are svc_handlers from a container
ACE_Recycling_Strategy< SVC_HANDLER >Defines the interface (and default implementation) for specifying a recycling strategy for a SVC_HANDLER
ACE_Refcountable
ACE_Refcounted_Auto_Ptr< X, ACE_LOCK >This class implements support for a reference counted auto_ptr. Assigning or copying instances of an ACE_Refcounted_Auto_Ptr will automatically increment the reference count. When the last instance that references a ACE_Refcounted_Auto_Ptr instance is destroyed or overwritten, it will invoke delete on its underlying pointer
ACE_Refcounted_Auto_Ptr_Rep< X, ACE_LOCK >An ACE_Refcounted_Auto_Ptr_Rep 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_ImpExpConfiguration 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 hexidecimal format "key"=hex: binary data
ACE_Remote_MutexProxy for acquiring, renewing, and releasing a distributed mutex
ACE_Remote_Name_SpaceMaintaining accesses Remote Name Server Database. Allows to add NameBindings, change them, remove them and resolve NameBindings
ACE_Remote_RLockProxy for acquiring, renewing, and releasing a distributed readers lock
ACE_Remote_Token_ProxyProxy for acquiring, renewing, and releasing a distributed synchronization token
ACE_Remote_WLockProxy 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_Process_MutexWrapper for readers/writer locks that exist across processes
ACE_Sample_HistorySave multiple samples in an array
ACE_Sbrk_Memory_PoolMake a memory pool that is based on <sbrk(2)>
ACE_Sbrk_Memory_Pool_OptionsHelper class for Sbrk Memory Pool constructor options
ACE_Sched_ParamsContainer for scheduling-related parameters
ACE_Sched_Priority_IteratorAn 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_InternalA base class for internal handles to section keys for configuration implementations
ACE_Section_Key_Win32The Win32 registry implementation of an internal section key
ACE_Select_Reactor_Handle_SetTrack handles we are interested for various events
ACE_Select_Reactor_Handler_RepositoryUsed to map ACE_HANDLEs onto the appropriate ACE_Event_Handler *
ACE_Select_Reactor_Handler_Repository_IteratorIterate through the ACE_Select_Reactor_Handler_Repository
ACE_Select_Reactor_ImplThis 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_NotifyUnblock 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_SemaphoreWrapper for Dijkstra style general semaphores
ACE_Service_ConfigSupplies common server operations for dynamic and static configuration of service
ACE_Service_Config_GuardA guard class, designed to be instantiated on the stack
ACE_Service_GestaltSupplies common server operations for dynamic and static configuration of services
ACE_Service_Gestalt::Processed_Static_Svc
ACE_Service_ManagerProvide a standard ACE service for managing all the services configured in an ACE_Service_Repository
ACE_Service_ObjectProvide the abstract base class common to all service implementations
ACE_Service_Object_PtrThis 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_TypeDefine the methods for handling the configuration of ACE_Service_Objects
ACE_Service_RepositoryContains all the services offered by a Service Configurator-based application
ACE_Service_Repository_IteratorIterate through the ACE_Service_Repository
ACE_Service_TypeKeeps track of information related to the various ACE_Service_Type_Impl subclasses
ACE_Service_Type_Dynamic_GuardA forward service declaration guard
ACE_Service_Type_ImplThe 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_MemoryThis base class adapts both System V shared memory and "BSD" mmap to a common API
ACE_Shared_Memory_MMShared memory wrapper based on MMAP
ACE_Shared_Memory_PoolMake a memory pool that is based on System V shared memory (shmget(2) etc.). This implementation allows memory to be shared between processes. If your platform doesn't support System V shared memory (e.g., Win32 and many RTOS platforms do not) then you should use ACE_MMAP_Memory_Pool instead of this class. In fact, you should probably use ACE_MMAP_Memory_Pool on platforms that *do* support System V shared memory since it provides more powerful features, such as persistent backing store and greatly scalability
ACE_Shared_Memory_Pool::SHM_TABLEKeeps track of all the segments being used
ACE_Shared_Memory_Pool_OptionsHelper class for Shared Memory Pool constructor options
ACE_Shared_Memory_SVShared memory wrapper based on System V shared memory
ACE_Shared_ObjectProvide the abstract base class used to access dynamic linking facilities
ACE_Sig_ActionC++ wrapper facade for the sigaction struct
ACE_Sig_AdapterProvide an adapter that transforms various types of signal handlers into the scheme used by the ACE_Reactor
ACE_Sig_GuardHold signals in MASK for duration of a C++ statement block. Note that a "0" for mask causes all signals to be held
ACE_Sig_HandlerThis 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_HandlersThis 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_SetProvide 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_SizeCDRA CDR stream for calculating size of the representation
ACE_SOCKAn 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_AcceptorDefines a factory that creates new ACE_Streams passively
ACE_SOCK_CODgramDefines the member functions for the ACE_SOCK connected datagram abstraction
ACE_SOCK_ConnectorDefines a factory that actively connects to a remote IP address and TCP port, creating a new ACE_SOCK_Stream object
ACE_SOCK_DgramDefines the member functions for the ACE_SOCK datagram abstraction
ACE_SOCK_Dgram_BcastDefines the member functions for the ACE_SOCK datagram abstraction
ACE_SOCK_Dgram_McastDefines the ACE socket wrapper for UDP/IP multicast
ACE_SOCK_Dgram_SC< STREAM >"Dgram_SC" is short for "Datagram Self-Contained."
ACE_SOCK_IODefines the methods for the ACE socket wrapper I/O routines (e.g., send/recv)
ACE_SOCK_SEQPACK_AcceptorDefines a factory that creates new ACE_Associations passively
ACE_SOCK_SEQPACK_AssociationDefines the methods in the ACE_SOCK_SEQPACK_Association abstraction
ACE_SOCK_SEQPACK_ConnectorDefines a factory that actively connects to a remote IP address and TCP port, creating a new ACE_SOCK_SEQPACK_Association object
ACE_SOCK_StreamDefines the methods in the ACE_SOCK_Stream abstraction
ACE_SPIPEDefines the member functions for the base class of the ACE_SPIPE abstraction
ACE_SPIPE_AcceptorA factory class that produces ACE_SPIPE_Stream objects
ACE_SPIPE_AddrDefines the SVR4 STREAM pipe address family address format
ACE_SPIPE_Addr::SPIPE_AddrContains security attributes
ACE_SPIPE_ConnectorDefines 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_StreamDefines the methods in the ACE_SPIPE_Stream abstraction
ACE_SStringA very Simple String ACE_SString class. This is not a general-purpose string class, and you should probably consider using ACE_CString is you don't understand why this class exists..
ACE_Static_Allocator< POOL_SIZE >Defines a class that provided a highly optimized memory management scheme for allocating memory statically
ACE_Static_Allocator_BaseDefines a class that provided a highly optimized memory management scheme for allocating memory statically
ACE_Static_Svc_DescriptorHolds the information necessary to describe a statically linked Svc
ACE_StatsProvides simple statistical analysis
ACE_Stats_ValueHelper class for ACE_Stats
ACE_Str_BufSimple wrapper for STREAM pipes strbuf
ACE_Strategy_Acceptor< SVC_HANDLER, >Abstract factory for creating a service handler (SVC_HANDLER), accepting into the SVC_HANDLER, and activating the SVC_HANDLER
ACE_Strategy_Connector< SVC_HANDLER, >Abstract factory for creating a service handler (SVC_HANDLER), connecting the SVC_HANDLER, and activating the SVC_HANDLER
ACE_Stream<>This class is the primary abstraction for the ASX framework. It is moduled after System V Stream
ACE_Stream_Head<>Standard task that acts as reader or writer at the head of an ACE_Stream
ACE_Stream_Iterator<>Iterate through an ACE_Stream
ACE_Stream_Tail<>Standard module that acts as the head of a stream
ACE_Stream_TypeDefine the methods for handling the configuration of ACE_Streams
ACE_StreambufCreate your custom streambuf by providing and ACE_*_Stream object to this template. I have tested it with ACE_SOCK_Stream and it should work fine for others as well
ACE_Streambuf_T< STREAM >
ACE_String_Base< CHAR >This class provides a wrapper facade for C strings
ACE_String_Base_ConstThis 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_StringCapEntryThis class implement the ACE String Capability subclass
ACE_Strong_Bound_Ptr< X, ACE_LOCK >This class implements support for a reference counted pointer
ACE_SV_MessageDefines the header file for the C++ wrapper for message queues
ACE_SV_Message_QueueDefines the header file for the C++ wrapper for System V IPC message queues
ACE_SV_Semaphore_ComplexThis is a more complex semaphore wrapper that handles race conditions for initialization correctly..
ACE_SV_Semaphore_SimpleThis 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_MemoryThis is a wrapper for System V shared memory
ACE_Svc_Conf_Lexer
ACE_Svc_Conf_ParamAn 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_Synch_OptionsContains the values of options used to determine the synchronous and asynchronous behavior
ACE_System_TimeDefines 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_BaseDirect base class for the ACE_Task template
ACE_Task_Ex<, ACE_MESSAGE_TYPE >Primary interface for application message processing, as well as input and output message queueing
ACE_Task_FlagsThese flags are used within the ACE_Task
ACE_Test_and_Set< ACE_LOCK, TYPE >Implements the classic ``test and set'' operation
ACE_ThreadProvides a wrapper for threads
ACE_Thread_AdapterConverts 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_Condition< MUTEX >ACE_Condition variable wrapper that works within processes
ACE_Thread_ControlUsed to keep track of a thread's activities within its entry point function
ACE_Thread_DescriptorInformation for controlling threads that run under the control of the <Thread_Manager>
ACE_Thread_Descriptor_BaseBasic information for thread descriptors. These information gets extracted out because we need it after a thread is terminated
ACE_Thread_ExitKeep 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_MaybeA version of ACE_Thread_Exit that is created dynamically under the hood if the flag is set to TRUE
ACE_Thread_HookThis class makes it possible to provide user-defined "start" hooks that are called before the thread entry point function is invoked
ACE_Thread_IDDefines 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_ManagerManages a pool of threads
ACE_Thread_Strategy< SVC_HANDLER >Defines the interface for specifying a concurrency strategy for a SVC_HANDLER based on multithreading
ACE_Thread_Timer_Queue_Adapter< TQ >Adapts 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_StatsA 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_ValueOperations on "timeval" structures, which express time in seconds (secs) and microseconds (usecs)
ACE_timeprobe_tTime probe record
ACE_timeprobe_t::eventEvents are record as strings or numbers
ACE_Timer_Hash_Iterator_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >Iterates over an ACE_Timer_Hash_T
ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >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 >Iterates over an ACE_Timer_Heap_T
ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >Provides a very fast and predictable timer implementation
ACE_Timer_List_Iterator_T< TYPE, FUNCTOR, ACE_LOCK >Iterates over an ACE_Timer_List
ACE_Timer_List_T< TYPE, FUNCTOR, ACE_LOCK >Provides a simple implementation of timers
ACE_Timer_Node_Dispatch_Info_T< TYPE >Maintains generated dispatch information for Timer nodes
ACE_Timer_Node_T< TYPE >Maintains the state associated with a Timer entry
ACE_Timer_Queue_Iterator_T< TYPE, FUNCTOR, ACE_LOCK >Generic interface for iterating over a subclass of ACE_Timer_Queue
ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >Provides an interface to timers
ACE_Timer_Wheel_Iterator_T< TYPE, FUNCTOR, ACE_LOCK >Iterates over an ACE_Timer_Wheel
ACE_Timer_Wheel_T< TYPE, FUNCTOR, ACE_LOCK >Provides a Timing Wheel version of ACE_Timer_Queue
ACE_TLIDefines the member functions for the base class of the ACE_TLI abstraction
ACE_TLI_AcceptorDefines the member functions for ACE_TLI_Acceptor abstraction
ACE_TLI_ConnectorDefines an active connection factory for the ACE_TLI C++ wrappers
ACE_TLI_Request
ACE_TLI_Request_Queue
ACE_TLI_StreamDefines the member functions for ACE_TLI_Stream abstraction
ACE_TokenClass 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::ACE_Token_Queue
ACE_Token::ACE_Token_Queue_Entry
ACE_Token_CollectionAllows atomic token group operations AND provides a ACE_Token manager interface
ACE_TokenizerTokenizer
ACE_Tokenizer::Delimiter_EntryDelimiter Entry
ACE_Tokenizer::Preserve_EntryPreserve Entry
ACE_TP_ReactorSpecialization of ACE_Select_Reactor to support thread-pool based event dispatching
ACE_TP_Token_GuardA helper class that helps grabbing, releasing and waiting on tokens for a thread that tries calling handle_events ()
ACE_TraceA 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_AdapterThis 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_CleanupSingleton that helps to manage the lifetime of TSS objects and keys
ACE_TSS_ConnectionClass for providing a connection per thread
ACE_TSS_InfoThread Specific Key management
ACE_TSS_KeysCollection of in-use flags for a thread's TSS keys. For internal use only by ACE_TSS_Cleanup; it is public because some compilers can't use nested classes for template instantiation parameters
ACE_TSS_Ref"Reference count" for thread-specific storage keys
ACE_TSS_Singleton< TYPE, ACE_LOCK >This class uses the Adapter pattern to turn ordinary classes into Thread-specific Singletons optimized with the Double-Checked Locking optimization pattern
ACE_TSS_Type_Adapter< TYPE >Adapter that allows built-in types to be used with ACE_TSS
ACE_TTY_IOClass definitions for platform specific TTY features
ACE_TTY_IO::Serial_Params
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 >Implement a simple unordered set of <T> of unbounded size
ACE_Unbounded_Set_Const_Iterator< T >Implement an const iterator over an unbounded set
ACE_Unbounded_Set_Iterator< T >Implement an iterator over an unbounded set
ACE_Unbounded_Stack< T >Implement a generic LIFO abstract data type
ACE_Unbounded_Stack_Iterator< T >Implement an iterator over an unbounded Stack
ACE_UNIX_AddrDefines 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_AcceptorDefines the format and interface for the listener side of the ACE_UPIPE_Stream
ACE_UPIPE_ConnectorDefines an active connection factory for the ACE_UPIPE_STREAM wrappers
ACE_UPIPE_StreamDefines 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_WChar_Codeset_TranslatorCodeset 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_Wide_To_AsciiA lightweight wchar* to char* string conversion class
ACE_Write_Guard< ACE_LOCK >This class is similar to class ACE_Guard, though it acquires/releases a write lock automatically (naturally, the <ACE_LOCK> it is instantiated with must support the appropriate API)
ACE_Write_Guard< ACE_Null_Mutex >
ACE_XML_Svc_ConfThis abstract class defines the common operations ACE_Service_Config expects when using the XML Service Config Parser
ace_yy_buffer_state
ACMM
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
cancel_state
ACE_Utils::Comparator< LEFT, RIGHT >Structure that provides optimal comparison operation for given types
cpu_set_t
dirent
ACE_Utils::Fast_Comparator< LEFT, RIGHT >Quick comparison of types that can be safely promoted and/or converted to each other
Hash_Token< TYPE >
If_Then_ElseSelect of type Ta if boolean value is true
If_Then_ElseSelect of type Tb if boolean value is false
If_Then_ElseCompile-time selection of type based on a boolean value
ACE::ACE::If_Then_Else< false, Ta, Tb >
ACE::ACE::If_Then_Else< true, Ta, Tb >
ACE_OS::macaddr_node_t
MAP_MANAGER
msghdr
ACE_Utils::Noop_Truncator< FROM, TO >No-op truncation
rusage
Safe_ComparatorConservative comparison of types that may not be safely promoted and/or converted to each other
ACE_Utils::ACE_Utils::Safe_Comparator< LEFT, RIGHT, false, false >
ACE_Utils::ACE_Utils::Safe_Comparator< LEFT, RIGHT, false, true >
ACE_Utils::ACE_Utils::Safe_Comparator< LEFT, RIGHT, true, false >
ACE_Utils::ACE_Utils::Safe_Comparator< LEFT, RIGHT, true, true >
semun
siginfo_t
ACE_Utils::ACE_Utils::Sign_Check< signed char >
ACE_Utils::ACE_Utils::Sign_Check< signed int >
ACE_Utils::ACE_Utils::Sign_Check< signed long >
ACE_Utils::ACE_Utils::Sign_Check< signed long long >
ACE_Utils::ACE_Utils::Sign_Check< signed short >
ACE_Utils::ACE_Utils::Sign_Check< unsigned char >
ACE_Utils::ACE_Utils::Sign_Check< unsigned int >
ACE_Utils::ACE_Utils::Sign_Check< unsigned long >
ACE_Utils::ACE_Utils::Sign_Check< unsigned long long >
ACE_Utils::ACE_Utils::Sign_Check< unsigned short >
strbuf
timespec
To_UnsignedRetrieve unsigned counterpart to given type or value
ACE_Utils::ACE_Utils::To_Unsigned< signed char >
ACE_Utils::ACE_Utils::To_Unsigned< signed int >
ACE_Utils::ACE_Utils::To_Unsigned< signed long >
ACE_Utils::ACE_Utils::To_Unsigned< signed long long >
ACE_Utils::ACE_Utils::To_Unsigned< signed short >
ACE_Utils::ACE_Utils::To_Unsigned< unsigned char >
ACE_Utils::ACE_Utils::To_Unsigned< unsigned int >
ACE_Utils::ACE_Utils::To_Unsigned< unsigned long >
ACE_Utils::ACE_Utils::To_Unsigned< unsigned long long >
ACE_Utils::ACE_Utils::To_Unsigned< unsigned short >
truncate_castHelper 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::ACE_Utils::Truncator< T, T >
TSS_Cleanup_Instance
ACE_Utils::UUID
ACE_Utils::UUID_Generator
ACE_Utils::UUID_Generator::UUID_State
ACE_Utils::UUID_NodeClass to hold a MAC address
ACE::Value_Ptr< T >Smart pointer implementation designed for use as a class member
ACE::VP_traits< T >Value_Ptr traits template structure
YYSTYPE

Generated on Wed Apr 23 02:37:49 2008 for ACE by  doxygen 1.5.5