_dbghelp_functions | |
ACE_Accept_QoS_Params | Wrapper class that simplifies the information passed to the QoS enabled <ACE_OS::accept> method |
ACE_Accept_Strategy< SVC_HANDLER, > | Defines the interface for specifying a passive connection acceptance strategy for a SVC_HANDLER |
ACE_Acceptor< SVC_HANDLER, > | Abstract factory for creating a service handler (SVC_HANDLER), accepting into the SVC_HANDLER, and activating the SVC_HANDLER |
ACE_Activation_Queue | Reifies a method into a request. Subclasses typically represent necessary state and behavior |
ACE_Active_Map_Manager< T > | Define a map abstraction that associates system generated keys with user specified values |
ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER > | Defines a map implementation |
ACE_Active_Map_Manager_Iterator_Adapter< T, VALUE > | Defines a iterator implementation for the Active_Map_Manager_Adapter |
ACE_Active_Map_Manager_Key | Key used in the Active Object Map |
ACE_Active_Map_Manager_Key::key_data | Data for the Active Object Map Key |
ACE_Active_Map_Manager_Reverse_Iterator_Adapter< T, VALUE > | Defines a reverse iterator implementation for the Active_Map_Manager_Adapter |
ACE_Adaptive_Lock | An adaptive general locking class that defers the decision of lock type to run time |
ACE_Addr | Defines the base class for the "address family independent" address format |
ACE_Allocator | Interface for a dynamic memory allocator that uses inheritance and dynamic binding to provide extensible mechanisms for allocating and deallocating memory |
ACE_Allocator_Adapter< MALLOC > | This class is an adapter that allows the ACE_Allocator to use the ACE_Malloc class below |
ACE_Arg_Shifter_T< CHAR_TYPE > | This ADT operates on a specified set of arguments (argv). As known arguments are scanned, they are shifted to the back of the argv vector, so deeper levels of argument parsing can locate the yet unprocessed arguments at the beginning of the vector |
ACE_ARGV_Queue_Entry_T< CHAR_TYPE > | An entry in the queue which keeps user supplied arguments |
ACE_ARGV_T< CHAR_TYPE > | Builds a counted argument vector (ala argc/argv) from either a string or a set of separate tokens. This class preserves whitespace within tokens only if the whitespace-containing token is enclosed in either single (') or double (") quotes. This is consistent with the expected behavior if an argument vector obtained using this class is passed to, for example, ACE_Get_Opt |
ACE_Argv_Type_Converter | To convert 'char' input/command line parameter to 'wchar_t' |
ACE_Array< T > | A dynamic array class |
ACE_Array_Base< T > | Implement a simple dynamic array |
ACE_Array_Iterator< T > | Implement an iterator over an ACE_Array |
ACE_Array_Map< Key, Value, EqualTo > | Light weight array-based map with fast iteration, but linear (i.e. O(n)) search times |
ACE_Ascii_To_Wide | A lightweight char* to wchar* string conversion class |
ACE_Async_Timer_Queue_Adapter< TQ > | Adapts an ACE timer queue to be driven asynchronously using signals |
ACE_Asynch_Pseudo_Task | |
ACE_At_Thread_Exit | Contains 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_Event | Auto Events |
ACE_Auto_IncDec< ACE_SAFELY_INCREMENTABLE_DECREMENTABLE > | This class automatically increments and decrements a parameterized counter |
ACE_Auto_Ptr< X > | Implements the draft C++ standard auto_ptr abstraction. This version can be used instead of auto_ptr<T>, and obviates the need for the ACE_AUTO_PTR_RESET macro on platforms like VC6 where the auto_ptr<T> is broken |
ACE_Auto_String_Free | Simple class to automatically de-allocate strings |
ACE_Barrier | This is a no-op to make ACE "syntactically consistent." |
ACE_Base64 | Encode/Decode a stream of bytes according to Base64 encoding |
ACE_Base_Thread_Adapter | Base class for all the Thread_Adapters |
ACE_Based_Pointer< CONCRETE > | A smart proxy that keeps track of the relative offset of a "pointer" from its base address |
ACE_Based_Pointer_Basic< CONCRETE > | A proxy that keeps track of the relative offset of a "pointer" from its base address. This class makes it possible to transparently use "pointers" in shared memory as easily as programming with pointers to local memory. In particular, we don't need to ensure that the base addresses of all the pointers are mapped into separate processes at the same absolute memory base address |
ACE_Based_Pointer_Repository | Maps pointers to the base address of the region to which each pointer belongs |
ACE_Based_Pointer_Repository_Rep | Implementation for the ACE_Based_Pointer_Repository |
ACE_Basic_Stats | Collect basic stats about a series of samples |
ACE_Bcast_Node | Linked list of broadcast interfaces |
ACE_BoolCapEntry | This class implement the ACE Bool Capability subclass |
ACE_Bound_Ptr_Counter< ACE_LOCK > | An ACE_Bound_Ptr_Counter<ACE_LOCK> object encapsulates an object reference count |
ACE_Bounded_Cached_Connect_Strategy< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX > | A connection strategy which caches connections to peers (represented by SVC_HANDLER instances), thereby allowing subsequent re-use of unused, but available, connections. This strategy should be used when the cache is bounded by maximum size |
ACE_Bounded_Set< T > | Implement a simple unordered set of {T} with maximum set at creation time |
ACE_Bounded_Set< T >::Search_Structure | |
ACE_Bounded_Set_Iterator< T > | Iterates through an unordered set |
ACE_Bounded_Stack< T > | Implement a generic LIFO abstract data type |
ACE_Buffered_Svc_Handler<, > | Defines the interface for a service that exchanges data with its connected peer and supports buffering |
ACE_Cache_Map_Iterator< KEY, VALUE, IMPLEMENTATION, CACHING_STRATEGY, ATTRIBUTES > | Defines a iterator for the Cache_Map_Manager |
ACE_Cache_Map_Manager< KEY, VALUE, CMAP_TYPE, ITERATOR_IMPL, REVERSE_ITERATOR_IMPL, CACHING_STRATEGY, ATTRIBUTES > | Defines a abstraction that will purge entries from a map |
ACE_Cache_Map_Reverse_Iterator< KEY, VALUE, REVERSE_IMPLEMENTATION, CACHING_STRATEGY, ATTRIBUTES > | Defines a reverse iterator for the Cache_Map_Manager |
ACE_Cached_Allocator< T, ACE_LOCK > | A fixed-size allocator that caches items for quicker access |
ACE_Cached_Connect_Strategy< SVC_HANDLER,, MUTEX > | A connection strategy which caches connections to peers (represented by SVC_HANDLER instances), thereby allowing subsequent re-use of unused, but available, connections |
ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX > | A connection strategy which caches connections to peers (represented by SVC_HANDLER instances), thereby allowing subsequent re-use of unused, but available, connections |
ACE_Cached_Mem_Pool_Node< T > | ACE_Cached_Mem_Pool_Node keeps unused memory within a free list |
ACE_Caching_Strategy< ATTRIBUTES, CACHING_UTILITY > | This class is an abstract base class for a caching strategy |
ACE_Caching_Strategy_Adapter< ATTRIBUTES, CACHING_UTILITY, IMPLEMENTATION > | This class follows the Adaptor pattern and is used to provide External Polymorphism by deriving from ACE_Caching_Strategy |
ACE_Capabilities | This class implement the ACE Capabilities |
ACE_CapEntry | This class is the base class for all ACE Capabilities entry subclasses |
ACE_CDR | Keep constants and some routines common to both Output and Input CDR streams |
ACE_CDR::Double | |
ACE_CDR::Float | |
ACE_CDR::LongDouble | |
ACE_Char_Codeset_Translator | Codeset translation routines common to both Output and Input CDR streams |
ACE_Cleanup | Base class for objects that are cleaned by ACE_Object_Manager |
ACE_Cleanup_Adapter< TYPE > | Adapter for ACE_Cleanup objects that allows them to be readily managed by the ACE_Object_Manager |
ACE_Cleanup_Info | Hold cleanup information for thread/process |
ACE_Cleanup_Info_Node | For maintaining a list of ACE_Cleanup_Info items |
ACE_Cleanup_Strategy< KEY, VALUE, CONTAINER > | Defines a default strategy to be followed for cleaning up entries from a map which is the container |
ACE_Codeset_Registry | |
ACE_Codeset_Registry::registry_entry | |
ACE_Command_Base | Defines an abstract class that allows us to invoke commands without knowing anything about the implementation |
ACE_Command_Callback< RECEIVER, ACTION > | Defines a class template that allows us to invoke a GOF command style callback to an object without knowing anything about the object except its type |
ACE_Concurrency_Strategy< SVC_HANDLER > | Defines the interface for specifying a concurrency strategy for a SVC_HANDLER |
ACE_Condition< MUTEX > | ACE_Condition variable wrapper, which allows threads to block until shared data changes state |
ACE_Config_ImpExp_Base | Base class for file import/export configuration |
ACE_Configuration | Base class for configuration databases |
ACE_Configuration_ExtId | External ID for the section and value hash |
ACE_Configuration_Heap | The concrete implementation of a allocator based configuration database |
ACE_Configuration_Section_IntId | The internal ID for a section hash table |
ACE_Configuration_Section_Key | Reference counted wrapper for ACE_Section_Key_Internal |
ACE_Configuration_Section_Key_Heap | Internal section key class for heap based configuration database |
ACE_Configuration_Value_IntId | The section hash table internal value class |
ACE_Configuration_Win32Registry | The win32 registry implementation of a configuration database |
ACE_Connect_Strategy< SVC_HANDLER, > | Defines the interface for specifying an active connection establishment strategy for a SVC_HANDLER |
ACE_Connection_Recycling_Strategy | Defines the interface for a connection recycler |
ACE_Connector< SVC_HANDLER, > | Generic factory for actively connecting clients and creating service handlers (SVC_HANDLERs) |
ACE_Connector_Base< SVC_HANDLER > | This base interface allows ACE_NonBlocking_Connect_Handler to only care about the SVC_HANDLER template parameter of the ACE_Connector. Otherwise, ACE_NonBlocking_Connect_Handler would have to be configured with all the template parameters that ACE_Connector is configured with |
ACE_Control_Block | This information is stored in memory allocated by the <Memory_Pool> |
ACE_Control_Block::ACE_Malloc_Header | This is the control block header. It's used by <ACE_Malloc> to keep track of each chunk of data when it's in the free list or in use |
ACE_Control_Block::ACE_Name_Node | This class supports "named memory regions" within ACE_Malloc |
ACE_Copy_Disabled | Helper class to disable copy construction and assignment |
ACE_Countdown_Time | Keeps track of the amount of elapsed time |
ACE_Creation_Strategy< SVC_HANDLER > | Defines the interface for specifying a creation strategy for a SVC_HANDLER |
ACE_Data_Block | Stores the data payload that is accessed via one or more ACE_Message_Block's |
ACE_Date_Time | System independent representation of date and time |
ACE_Deadline_Message_Strategy | Deadline based message priority strategy |
ACE_DEV | Defines the member functions for the base class of the ACE_DEV abstraction |
ACE_DEV_Addr | Defines device address family address format |
ACE_DEV_Connector | Defines an active connection factory for the ACE_DEV wrappers |
ACE_DEV_IO | Read/Write operations on Devices |
ACE_Dirent | Define a portable C++ directory-entry iterator based on the POSIX API |
ACE_Dirent_Selector | Define a portable C++ directory-entry iterator based on the POSIX scandir API |
ACE_DLL | Provides an abstract interface for handling various DLL operations |
ACE_DLL_Handle | Provides an abstract interface for handling various DLL operations |
ACE_DLL_Manager | This class is a singleton and serves as a factory and repository for instances of ACE_DLL_Handle |
ACE_DLL_Singleton_Adapter_T< TYPE > | |
ACE_DLL_Singleton_T< TYPE, ACE_LOCK > | Same as ACE_Singleton, except that it registers for destruction with the ACE_Framework_Repository instead of with the ACE_Object_Manager directly |
ACE_DLL_Strategy< SVC_HANDLER > | Defines the interface for specifying a creation strategy for a SVC_HANDLER based on dynamic linking of the SVC_HANDLER |
ACE_DLList< T > | A double-linked list container class |
ACE_DLList_Iterator< T > | A double-linked list container class iterator |
ACE_DLList_Node | Base implementation of element in a DL list. Needed for ACE_Double_Linked_List |
ACE_DLList_Reverse_Iterator< T > | A double-linked list container class iterator |
ACE_DNode< T > | Implementation element in a bilinked list |
ACE_Double_Linked_List< T > | A double-linked list implementation |
ACE_Double_Linked_List_Iterator< T > | Implements an iterator for a double linked list ADT |
ACE_Double_Linked_List_Iterator_Base< T > | Implements a common base class for iterators for a double linked list ADT |
ACE_Double_Linked_List_Reverse_Iterator< T > | Implements a reverse iterator for a double linked list ADT |
ACE_Dumpable | Base class that defines a uniform interface for all object dumping |
ACE_Dumpable_Adapter< Concrete > | This class inherits the interface of the abstract ACE_Dumpable class and is instantiated with the implementation of the concrete component class <class concrete>=""> |
ACE_Dumpable_Ptr | A smart pointer stored in the in-memory object database ACE_ODB. The pointee (if any) is deleted when reassigned |
ACE_Dynamic | Checks to see if an object was dynamically allocated |
ACE_Dynamic_Cached_Allocator< ACE_LOCK > | A size-based allocator that caches blocks for quicker access |
ACE_Dynamic_Message_Queue<> | A derived class which adapts the ACE_Message_Queue class in order to maintain dynamic priorities for enqueued <ACE_Message_Blocks> and manage the queue order according to these dynamic priorities |
ACE_Dynamic_Message_Strategy | An abstract base class which provides dynamic priority evaluation methods for use by the ACE_Dynamic_Message_Queue class or any other class which needs to manage the priorities of a collection of ACE_Message_Blocks dynamically |
ACE_Dynamic_Service< TYPE > | Provides a general interface to retrieve arbitrary objects from the ACE service repository |
ACE_Dynamic_Service_Base | Base class for all ACE_Dynamic_Service instantiations |
ACE_Dynamic_Service_Dependency | Provides a way to declare dependency on specific service, thus helping to avoid order of initialization issues with instances of an objects whose implementation code resides in dynamically loaded services |
ACE_EH_Dispatch_Info | This structure contains information of the activated event handler |
ACE_Env_Value< T > | Environment Variable Value |
ACE_Equal_To< TYPE > | Function object for 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_Guard | Provides a wrapper to improve performance when thread-specific errno must be saved and restored in a block of code |
ACE_Event | A wrapper around the Win32 event locking mechanism |
ACE_Event_Descriptions | Event Descriptions |
ACE_Event_Handler | Provides an abstract interface for handling various types of I/O, timer, and signal events |
ACE_Event_Handler::Policy | Base class for all handler policies |
ACE_Event_Handler::Reference_Counting_Policy | This policy dictates the reference counting requirements for the handler |
ACE_Event_Handler_Handle_Timeout_Upcall< ACE_LOCK > | Functor for Timer_Queues |
ACE_Event_Handler_T< T > | Enable a class that doesn't inherit from the ACE_Event_Handler to be incorporated into the ACE_Reactor framework. Thanks to Greg Lavender (g.lavender@isode.com) for sharing this idea |
ACE_Event_Handler_var | Auto pointer like class for Event Handlers |
ACE_Event_Tuple | An ACE_Event_Handler and its associated ACE_HANDLE |
ACE_FIFO | Abstract base class for UNIX FIFOs |
ACE_FIFO_Caching_Strategy< ATTRIBUTES, CACHING_UTILITY > | The First In First Out strategy is implemented wherein each item is ordered |
ACE_FIFO_Recv | Receiver side of the bytestream C++ wrapper for UNIX FIFOs |
ACE_FIFO_Recv_Msg | Receiver side for the record oriented C++ wrapper for UNIX FIFOs |
ACE_FIFO_Send | Sender side for the bytestream C++ wrapper for UNIX FIFOs |
ACE_FIFO_Send_Msg | Sender side for the Record oriented C++ wrapper for UNIX FIFOs |
ACE_FILE | Defines the core methods of the ACE_FILE abstraction |
ACE_FILE_Addr | Defines the FILE address family address format |
ACE_FILE_Connector | Defines an active connection factory for the ACE_FILE wrappers |
ACE_FILE_Info | Abstracts basic OS FILE information |
ACE_FILE_IO | Read/Write operations on Files |
ACE_File_Lock | A wrapper around the UNIX file locking mechanism |
ACE_Filecache | A hash table holding the information about entry point into the Cached Virtual Filesystem. On insertion, the reference count is incremented. On destruction, reference count is decremented |
ACE_Filecache_Handle | Abstraction over a real file. This is meant to be the entry point into the Cached Virtual Filesystem |
ACE_Filecache_Object | Abstraction over a real file. This is what the Virtual Filesystem contains. This class is not intended for general consumption. Please consult a physician before attempting to use this class |
ACE_Fixed_Set< T, ACE_SIZE > | Implement a simple unordered set of {T} with maximum {ACE_SIZE} |
ACE_Fixed_Set_Const_Iterator< T, ACE_SIZE > | Iterates through a const unordered set |
ACE_Fixed_Set_Iterator< T, ACE_SIZE > | Iterates through an unordered set |
ACE_Fixed_Set_Iterator_Base< T, ACE_SIZE > | Implements a common base class for iterators for a unordered set |
ACE_Fixed_Stack< T, ACE_SIZE > | Implement a generic LIFO abstract data type |
ACE_OS::ace_flock_t | OS file locking structure |
ACE_Flow_Spec | Wrapper class that defines the flow spec QoS information, which is used by IntServ (RSVP) and DiffServ |
ACE_Framework_Component | Base class that defines a uniform interface for all managed framework components |
ACE_Framework_Component_T< Concrete > | This class inherits the interface of the abstract ACE_Framework_Component class and is instantiated with the implementation of the concrete component class class Concrete |
ACE_Framework_Repository | Contains all framework components used by an application |
ACE_Free_List< T > | Implements a free list |
ACE_Future< T > | This class implements a ``single write, multiple read'' pattern that can be used to return results from asynchronous method invocations |
ACE_Future_Holder< T > | Implementation of object that holds an ACE_Future |
ACE_Future_Observer< T > | ACE_Future_Observer<T> |
ACE_Future_Rep< T > | ACE_Future_Rep<T> |
ACE_Future_Set< T > | This class implements a mechanism which allows the values of a collection of ACE_Future objects to be accessed by reader threads as they become available. The caller(s) provide the ACE_Future_Set (i.e. the observer...) with the collection of ACE_Future objects (i.e. the subjects...) that are to be observed using the the ACE_Future_Set::insert() method. The caller(s) may then iterate over the collection in the order in which they become readable using the ACE_Future_Set::next_readable() method |
ACE_Get_Opt | Iterator for parsing command-line arguments |
ACE_Get_Opt::ACE_Get_Opt_Long_Option | |
ACE_Guard< ACE_LOCK > | This data structure is meant to be used within a method or function... It performs automatic aquisition and release of a parameterized synchronization object <ACE_LOCK> |
ACE_Guard< ACE_Null_Mutex > | |
ACE_Handle_Gobbler | This class gobbles up handles |
ACE_Handle_Set | C++ wrapper facade for the socket fd_set abstraction |
ACE_Handle_Set_Iterator | Iterator for the ACE_Handle_Set abstraction |
ACE_Handler_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_Hashable | ACE_Hashable |
ACE_High_Res_Timer | A high resolution timer class wrapper that encapsulates OS-specific high-resolution timers, such as those found on Solaris, AIX, Win32/Pentium, and VxWorks |
ACE_Incremental_Key_Generator< T > | Defines a simple incremental key generator |
ACE_INET_Addr | Defines a C++ wrapper facade for the Internet domain address family format |
ACE_Ini_ImpExp | Imports the configuration database from filename as strings. Allows non-typed values. (no #, dword: hex:, etc. prefixes) and skips whitespace (tabs and spaces) as in standard .ini and .conf files. Values (to right of equal sign) can be double quote delimited to embed tabs and spaces in the string. Caller must convert string to type |
ACE_InputCDR | A CDR stream for demarshalling CDR-encoded data |
ACE_InputCDR::to_boolean | |
ACE_InputCDR::to_char | |
ACE_InputCDR::to_octet | |
ACE_InputCDR::to_string | |
ACE_InputCDR::to_wchar | |
ACE_InputCDR::to_wstring | |
ACE_InputCDR::Transfer_Contents | |
ACE_IntCapEntry | This class implement the ACE Integer Capability subclass |
ACE_Intrusive_Auto_Ptr< X > | This class implements support for a reference counted auto_ptr. It assumes reference counting abilities of the parameterizing class |
ACE_Intrusive_List< T > | Implement an intrusive double linked list |
ACE_Intrusive_List_Node< T > | Implement the requirements for ACE_Intrusive_List |
ACE_IO_Cntl_Msg | Data format for IOCTL messages |
ACE_IO_SAP | Defines the methods for the base class of the ACE_IO_SAP abstraction, which includes ACE_FILE and ACE_DEV |
ACE_IOStream< STREAM > | A template adapter for creating an iostream-like object using an ACE IPC Stream for the actual I/O. Iostreams use an underlying streambuf object for the IO interface. The iostream class and derivatives provide you with a host of convenient operators that access the streambuf |
ACE_IPC_SAP | Defines the member functions for the base class of the ACE_IPC_SAP abstraction |
ACE_Iterator< T > | Defines the iterator interface |
ACE_Iterator_Impl< T > | Defines a abstract iterator |
ACE_Laxity_Message_Strategy | Laxity based message priority strategy |
ACE_Less_Than< TYPE > | Function object for determining whether the first 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_Pool | Make a ``lighter-weight'' memory pool based ACE_Mem_Map |
ACE_Local_Memory_Pool | Make a memory pool that is based on C++ new/delete. This is useful for integrating existing components that use new/delete into the ACE Malloc scheme.. |
ACE_Local_Memory_Pool_Options | Helper class for Local Memory Pool constructor options |
ACE_Local_Name_Space<, ACE_LOCK > | Maintaining accesses Local Name Server Database. Allows to add NameBindings, change them, remove them and resolve NameBindings |
ACE_Lock | This is the abstract base class that contains the uniform locking API that is supported by all the ACE synchronization mechanisms |
ACE_Lock_Adapter< ACE_LOCKING_MECHANISM > | This is an adapter that allows applications to transparently combine the <ACE_Lock> abstract base class (which contains pure virtual methods) with any of the other concrete ACE synchronization classes (e.g., ACE_Mutex, ACE_Semaphore, ACE_RW_Mutex, etc.) |
ACE_LOCK_SOCK_Acceptor< ACE_LOCK > | Specialize ACE_SOCK_Acceptor to lock around <accept>; |
ACE_Locked_Data_Block< ACE_LOCK > | A Data_Block with a concrete locking strategy |
ACE_Locked_Free_List< T, ACE_LOCK > | Implements a free list |
ACE_Log_Msg | Provides a variable length argument message logging abstraction |
ACE_Log_Msg_Backend | Defines the interface for ACE_Log_Msg back end processing |
ACE_Log_Msg_Callback | An interface class used to get logging callbacks |
ACE_Log_Msg_IPC | Defines the interfaces for ACE_Log_Msg backend |
ACE_Log_Msg_Manager | Synchronize output operations |
ACE_Log_Msg_UNIX_Syslog | Implements an ACE_Log_Msg_Backend that logs messages to a UNIX system's syslog facility |
ACE_Log_Record | Defines the structure of an ACE logging record |
ACE_Logging_Strategy | This class provides a way to dynamically configure the ACE logging mechanism at run time as well as enable the mechanisms for limiting log file size and log file backup/rotation capability |
ACE_LRU_Caching_Strategy< ATTRIBUTES, CACHING_UTILITY > | Defines a Least Recently Used strategy which will decide on the item to be removed from the cache |
ACE_LSOCK | Create a Local ACE_SOCK, which is used for passing file descriptors |
ACE_LSOCK_Acceptor | Defines the format and interface for the acceptor side of the local ACE_SOCK ACE_Stream |
ACE_LSOCK_CODgram | Defines the member functions for the <ACE_LSOCK> connected datagram abstraction |
ACE_LSOCK_Connector | Defines the format and interface for the connector side of the ACE_LSOCK_Stream |
ACE_LSOCK_Dgram | Create a Local ACE_SOCK datagram |
ACE_LSOCK_Stream | Create a Local ACE_SOCK stream |
ACE_Malloc<, ACE_LOCK > | |
ACE_Malloc_FIFO_Iterator<, ACE_LOCK > | |
ACE_Malloc_FIFO_Iterator_T<, ACE_LOCK, ACE_CB > | FIFO iterator for names stored in Malloc'd memory |
ACE_Malloc_LIFO_Iterator<, ACE_LOCK > | |
ACE_Malloc_LIFO_Iterator_T<, ACE_LOCK, ACE_CB > | LIFO iterator for names stored in Malloc'd memory |
ACE_Malloc_Lock_Adapter_T< ACE_LOCK > | Template functor adapter for lock strategies used with ACE_Malloc_T |
ACE_Malloc_Lock_Adapter_T< ACE_Null_Mutex > | |
ACE_Malloc_Lock_Adapter_T< ACE_Process_Semaphore > | |
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_Process | A process easily managed by ACE_Process_Manager |
ACE_Manual_Event | Manual Events |
ACE_Map< KEY, VALUE > | Defines a map interface |
ACE_Map_Const_Iterator< EXT_ID, INT_ID, ACE_LOCK > | Forward const iterator for the ACE_Map_Manager |
ACE_Map_Const_Iterator_Base< EXT_ID, INT_ID, ACE_LOCK > | Const iterator for the ACE_Map_Manager |
ACE_Map_Entry< EXT_ID, INT_ID > | An entry in the Map |
ACE_Map_Impl< KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY > | Defines a map implementation |
ACE_Map_Impl_Iterator_Adapter< T, IMPLEMENTATION, ENTRY > | Defines a iterator implementation for the Map_Impl class |
ACE_Map_Impl_Reverse_Iterator_Adapter< T, IMPLEMENTATION, ENTRY > | Defines a reverse iterator implementation for the Map_Impl class |
ACE_Map_Iterator< EXT_ID, INT_ID, ACE_LOCK > | Forward iterator for the ACE_Map_Manager |
ACE_Map_Iterator_Base< EXT_ID, INT_ID, ACE_LOCK > | Iterator for the ACE_Map_Manager |
ACE_Map_Manager< EXT_ID, INT_ID, ACE_LOCK > | Define a map abstraction that associates <EXT_ID>s with <INT_ID>s |
ACE_Map_Manager_Adapter< KEY, VALUE, KEY_GENERATOR > | Defines a map implementation |
ACE_Map_Manager_Iterator_Adapter< T, KEY, VALUE > | Defines a iterator implementation for the Map_Manager_Adapter |
ACE_Map_Manager_Reverse_Iterator_Adapter< T, KEY, VALUE > | Defines a reverse iterator implementation for the Map Manager |
ACE_Map_Reverse_Iterator< EXT_ID, INT_ID, ACE_LOCK > | Reverse Iterator for the ACE_Map_Manager |
ACE_max_align_info | |
ACE_MEM_Acceptor | Defines the format and interface for the acceptor side of the local mmap stream |
ACE_Mem_Map | C++ interface OS memory mapping system call |
ACE_Message_Block | Stores messages for use throughout ACE (particularly in an ACE_Message_Queue) |
ACE_Message_Queue<> | A message queueing facility with parameterized synchronization capability. ACE_Message_Queue is modeled after the queueing facilities in System V STREAMs |
ACE_Message_Queue_Base | Base class for ACE_Message_Queue, which is the central queueing facility for messages in the ACE framework |
ACE_Message_Queue_Ex< ACE_MESSAGE_TYPE, > | A threaded message queueing facility, modeled after the queueing facilities in System V STREAMs |
ACE_Message_Queue_Ex_Iterator< ACE_MESSAGE_TYPE, > | Iterator for the ACE_Message_Queue_Ex |
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_Ex_Reverse_Iterator< ACE_MESSAGE_TYPE, > | |
ACE_Message_Queue_Factory<> | ACE_Message_Queue_Factory is a static factory class template which provides a separate factory method for each of the major kinds of priority based message dispatching: static, earliest deadline first (EDF), and minimum laxity first (MLF) |
ACE_Message_Queue_Iterator<> | Iterator for the ACE_Message_Queue |
ACE_Message_Queue_Reverse_Iterator<> | Reverse Iterator for the ACE_Message_Queue |
ACE_Method_Request | Reifies a method into a request. Subclasses must provide the necessary state and behavior |
ACE_MMAP_Memory_Pool | Make a memory pool that is based on mmap(2) . This implementation allows memory to be shared between processes |
ACE_MMAP_Memory_Pool_Options | Helper class for MMAP Memory Pool constructor options |
ACE_Module<> | An abstraction for managing a bi-directional flow of messages |
ACE_Module_Base | Workaround HP/C++ compiler bug with enums in templates |
ACE_Module_Type | Define the methods for handling the configuration of ACE_Modules |
ACE_Msg_Log_Cleanup | |
ACE_Multihomed_INET_Addr | Extends ACE_INET_Addr with support for multi-homed addresses |
ACE_Mutex | ACE_Mutex wrapper (valid in same process or across processes (depending on TYPE flag)). In general, however, we recommend using ACE_Process_Mutex or ACE_Thread_Mutex rather than ACE_Mutex |
ACE_Name_Binding | Maintains a mapping from name to value and type |
ACE_Name_Options | Manages the options for the ACE Name_Server |
ACE_Name_Proxy | Proxy for dealing with remote server process managing NET_LOCAL NameBindings |
ACE_Name_Reply | Message format for delivering replies from the ACE_Name Server |
ACE_Name_Reply::Transfer | |
ACE_Name_Request | Message format for delivering requests to the ACE_Name Server |
ACE_Name_Request::Transfer | |
ACE_Name_Space | Abstract base class that provides an abstract interface to the database without exposing any implemenation details |
ACE_Name_Space_Map< ALLOCATOR > | This class serves as a Proxy that ensures our process always has the appropriate allocator in place for every operation that accesses or updates the Map Manager |
ACE_Naming_Context | Maintaining accesses Name Server Databases. Allows to add NameBindings, change them, remove them and resolve NameBindings |
ACE_New_Allocator | Defines a class that provided a simple implementation of memory allocation |
ACE_Node< T, C > | Implementation element in a Queue, Set, and Stack |
ACE_NonBlocking_Connect_Handler< SVC_HANDLER > | Performs non-blocking connects on behalf of the Connector |
ACE_NOOP_Concurrency_Strategy< SVC_HANDLER > | Implements a no-op activation strategy in order to avoid calling open on a svc_handler multiple times |
ACE_NOOP_Creation_Strategy< SVC_HANDLER > | Implements a no-op creation strategy in order to defer decisions regarding creation to some later point in time, such as in connect or accept strategy |
ACE_Noop_Key_Generator< T > | Defines a noop key generator |
ACE_Noop_Token | |
ACE_Notification_Buffer | Simple wrapper for passing <ACE_Event_Handler *>s and ACE_Reactor_Masks between threads |
ACE_Notification_Queue | Implements a user-space queue to send Reactor notifications |
ACE_Notification_Queue_Node | Helper class |
ACE_Notification_Strategy | Abstract class used for notifying an interested party |
ACE_NS_Internal | This class and ACE_NS_String are used as Adapters to work with the Map_Manager |
ACE_NS_String | This class and ACE_NS_Internal are used as Adapters to work with the Map_Manager |
ACE_NS_WString | This class retain the backward compatibility for ACE_Naming_Context and related classes. The only addition to ACE_WString is a very naive "wchar" to "char" conversion function |
ACE_Null_Barrier | Implements "NULL barrier synchronization" |
ACE_Null_Caching_Strategy< ATTRIBUTES, CACHING_UTILITY > | The is a special caching strategy which doesnt have the purging feature |
ACE_Null_Caching_Utility< KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES > | Defines a dummy helper class for the Caching Strategies |
ACE_Null_Cleanup_Strategy< KEY, VALUE, CONTAINER > | Defines a do-nothing implementation of the cleanup strategy |
ACE_Null_Condition | Implement a do nothing ACE_Condition variable wrapper, i.e., all methods are no ops. This class is necessary since some C++ compilers are *very* lame.. |
ACE_Null_Mutex | Implement a do nothing ACE_Mutex, i.e., all the methods are no ops |
ACE_Null_Semaphore | Implement a do nothing ACE_Semaphore, i.e., all the methods are no ops |
ACE_Numeric_Limits< T > | |
ACE_Obchunk | Defines the state that represents a "chunk" of memory. Evenything in this class is public because it is designed as an internal structure of Obstack_T and users are not supposed to use this class directly |
ACE_Object_Manager | Manager for ACE library services and singleton cleanup |
ACE_Object_Manager_Base | Base class for ACE_Object_Manager(s) |
ACE_Object_Manager_Manager | Ensure that the ACE_Object_Manager gets initialized at program startup, and destroyed at program termination |
ACE_Object_Manager_Preallocations | Performs preallocations of certain statically allocated services needed by ACE |
ACE_Obstack_T< CHAR > | Define a simple "mark and release" memory allocation utility |
ACE_ODB | This is the object database (ODB) that keeps track of all live ACE objects |
ACE_ODB::Tuple | |
ACE_Oneshot_Acceptor< SVC_HANDLER, > | Generic factory for passively connecting clients and creating exactly one service handler (SVC_HANDLER) |
ACE_Ordered_MultiSet< T > | Implement a simple ordered multiset of {T} of unbounded size that allows duplicates. This class template requires that < operator semantics be defined for the parameterized type {T}, but does not impose any restriction on how that ordering operator is implemented. The set is implemented as a linked list |
ACE_Ordered_MultiSet_Iterator< T > | Implement a bidirectional iterator over an ordered multiset. This class template requires that < operator semantics be defined for the parameterized type {T}, but does not impose any restriction on how that ordering operator is implemented |
ACE_OS_Exit_Info | Hold Object Manager cleanup (exit) information |
ACE_OS_Log_Msg_Attributes | The attributes required by ACE_Log_Msg |
ACE_OS_Object_Manager | |
ACE_OS_Object_Manager_Manager | Ensure that the ACE_OS_Object_Manager gets initialized at program startup, and destroyed at program termination |
ACE_OS_Thread_Adapter | Converts a C++ function into a function that can be called from a thread creation routine (e.g., pthread_create() or _beginthreadex()) that expects an extern "C" entry point. This class also makes it possible to transparently provide hooks to register a thread with an ACE_Thread_Manager |
ACE_OS_Thread_Descriptor | Parent class of all ACE_Thread_Descriptor classes. = Container for ACE_Thread_Descriptor members that are used in ACE_OS |
ACE_OutputCDR | A CDR stream for marshalling data, most often for transmission to another system which may or may not have the same byte order |
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_Pipe | Provides a portable bidirectional "pipe" abstraction |
ACE_Pointer_Hash< TYPE > | Function object for hashing pointers |
ACE_Priority_Reactor | Implements priority based dispatching |
ACE_Proactor | |
ACE_Proactor::Timer_Queue | |
ACE_Proactor_Timer_Handler | A Handler for timer. It helps in the management of timers registered with the Proactor |
ACE_Process | Process |
ACE_Process_Manager | Manages a group of processes |
ACE_Process_Manager::Process_Descriptor | Information describing each process that's controlled by an ACE_Process_Manager |
ACE_Process_Mutex | A wrapper for mutexes that can be used across processes on the same host machine, as well as within a process, of course |
ACE_Process_Options | Process Options |
ACE_Process_Semaphore | Wrapper for Dijkstra style general semaphores that work across processes |
ACE_Process_Strategy< SVC_HANDLER > | Defines the interface for specifying a concurrency strategy for a SVC_HANDLER based on multiprocessing |
ACE_Profile_Timer | This class provides both a timing mechanism and a mechanism for reporting the resource usage of a process |
ACE_Profile_Timer::ACE_Elapsed_Time | Keeps track of the various user, system, and elapsed (real) times |
ACE_Protocol_Info | |
ACE_QoS | Wrapper class that holds the sender and receiver flow spec information, which is used by IntServ (RSVP) and DiffServ |
ACE_QoS_Params | Wrapper class that simplifies the information passed to the QoS enabled <ACE_OS::connect> and <ACE_OS::join_leaf> methods |
ACE_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_Reactor | This class forwards all methods to its delegation/implementation class, e.g., ACE_Select_Reactor or ACE_WFMO_Reactor |
ACE_Reactor_Impl | An abstract class for implementing the Reactor Pattern |
ACE_Reactor_Notification_Strategy | Used to notify an ACE_Reactor |
ACE_Reactor_Notify | Abstract class for unblocking an ACE_Reactor_Impl from its event loop |
ACE_Reactor_Timer_Interface | Interface for timer related methods on the Reactor |
ACE_Reactor_Token_T< ACE_TOKEN_TYPE > | Used as a synchronization mechanism to coordinate concurrent access to an ACE_Reactor_Impl object |
ACE_Read_Buffer | Efficiently reads an 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_t | Implement a thin C++ wrapper that allows nested acquisition and release of a mutex that occurs in the same thread |
ACE_Recyclable | |
ACE_Recyclable_Handler_Caching_Utility< KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES > | Defines a helper class for the Caching Strategies |
ACE_Recyclable_Handler_Cleanup_Strategy< KEY, VALUE, CONTAINER > | Defines a strategy to be followed for cleaning up entries which are svc_handlers from a container |
ACE_Recycling_Strategy< SVC_HANDLER > | Defines the interface (and default implementation) for specifying a recycling strategy for a SVC_HANDLER |
ACE_Refcountable_T< ACE_LOCK > | |
ACE_Refcounted_Auto_Ptr< X, ACE_LOCK > | This class implements support for a reference counted auto_ptr. Assigning or copying instances of an ACE_Refcounted_Auto_Ptr will automatically increment the reference count. When the last instance that references a ACE_Refcounted_Auto_Ptr instance is destroyed or overwritten, it will invoke delete on its underlying pointer |
ACE_Refcounted_Auto_Ptr_Rep< X, ACE_LOCK > | An ACE_Refcounted_Auto_Ptr_Rep object encapsulates a pointer to an object of type X. It uses a lock object of type ACE_LOCK to protect access to the reference count |
ACE_Refcounted_Hash_Recyclable< T > | |
ACE_Refcounted_Recyclable_Handler_Caching_Utility< KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES > | Defines a helper class for the Caching Strategies |
ACE_Refcounted_Recyclable_Handler_Cleanup_Strategy< KEY, VALUE, CONTAINER > | Defines a strategy to be followed for cleaning up entries which are svc_handlers from a container |
ACE_Reference_Pair< T1, T2 > | Defines a pair that only hold references |
ACE_Registry_ImpExp | Configuration object that imports/exports data to a file formatted using the Win32 Registry file export format. This format looks like [Section] "key"="String Data" "key"=dword: numeric data in hexidecimal format "key"=hex: binary data |
ACE_Remote_Mutex | Proxy for acquiring, renewing, and releasing a distributed mutex |
ACE_Remote_Name_Space | Maintaining accesses Remote Name Server Database. Allows to add NameBindings, change them, remove them and resolve NameBindings |
ACE_Remote_RLock | Proxy for acquiring, renewing, and releasing a distributed readers lock |
ACE_Remote_Token_Proxy | Proxy for acquiring, renewing, and releasing a distributed synchronization token |
ACE_Remote_WLock | Proxy for acquiring, renewing, and releasing a distributed writers lock |
ACE_Reverse_Iterator< T > | Defines the reverse iterator interface |
ACE_Reverse_Iterator_Impl< T > | Defines a abstract reverse iterator |
ACE_Reverse_Lock< ACE_LOCKING_MECHANISM > | A reverse (or anti) lock |
ACE_RW_Process_Mutex | Wrapper for readers/writer locks that exist across processes |
ACE_Sample_History | Save multiple samples in an array |
ACE_Sbrk_Memory_Pool | Make a memory pool that is based on <sbrk(2)> |
ACE_Sbrk_Memory_Pool_Options | Helper class for Sbrk Memory Pool constructor options |
ACE_Sched_Params | Container for scheduling-related parameters |
ACE_Sched_Priority_Iterator | An iterator over the OS-defined scheduling priorities |
ACE_Schedule_All_Reactive_Strategy< SVC_HANDLER > | Defines the interface for specifying how to suspend and resume a single-threaded reactive service |
ACE_Schedule_All_Threaded_Strategy< SVC_HANDLER > | Defines the interface for specifying how to suspend and resume a multithreaded service |
ACE_Scheduling_Strategy< SVC_HANDLER > | Defines the interface for specifying how to suspend and resume a service |
ACE_SDM_helpers | |
ACE_Section_Key_Internal | A base class for internal handles to section keys for configuration implementations |
ACE_Section_Key_Win32 | The Win32 registry implementation of an internal section key |
ACE_Select_Reactor_Handle_Set | Track handles we are interested for various events |
ACE_Select_Reactor_Handler_Repository | Used to map ACE_HANDLEs onto the appropriate ACE_Event_Handler * |
ACE_Select_Reactor_Handler_Repository_Iterator | Iterate through the ACE_Select_Reactor_Handler_Repository |
ACE_Select_Reactor_Impl | This class simply defines how Select_Reactor's basic interface functions should look like and provides a common base class for Select_Reactor using various locking mechanism |
ACE_Select_Reactor_Notify | Unblock the ACE_Select_Reactor from its event loop |
ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN > | An object oriented event demultiplexor and event handler dispatcher |
ACE_Semaphore | Wrapper for Dijkstra style general semaphores |
ACE_Service_Config | Supplies common server operations for dynamic and static configuration of service |
ACE_Service_Config_Guard | A guard class, designed to be instantiated on the stack |
ACE_Service_Gestalt | Supplies common server operations for dynamic and static configuration of services |
ACE_Service_Gestalt::Processed_Static_Svc | |
ACE_Service_Manager | Provide a standard ACE service for managing all the services configured in an ACE_Service_Repository |
ACE_Service_Object | Provide the abstract base class common to all service implementations |
ACE_Service_Object_Ptr | This is a smart pointer that holds onto the associated ACE_Service_Object * until the current scope is left, at which point the object's <fini> hook is called and the service_object_ gets deleted |
ACE_Service_Object_Type | Define the methods for handling the configuration of ACE_Service_Objects |
ACE_Service_Repository | Contains all the services offered by a Service Configurator-based application |
ACE_Service_Repository_Iterator | Iterate through the ACE_Service_Repository |
ACE_Service_Type | Keeps track of information related to the various ACE_Service_Type_Impl subclasses |
ACE_Service_Type_Dynamic_Guard | A forward service declaration guard |
ACE_Service_Type_Impl | The abstract base class of the hierarchy that defines the contents of the ACE_Service_Repository. The subclasses of this class allow the configuration of ACE_Service_Objects, ACE_Modules, and ACE_Streams |
ACE_Shared_Memory | This base class adapts both System V shared memory and "BSD" mmap to a common API |
ACE_Shared_Memory_MM | Shared memory wrapper based on MMAP |
ACE_Shared_Memory_Pool | Make a memory pool that is based on System V shared memory (shmget(2) etc.). This implementation allows memory to be shared between processes. If your platform doesn't support System V shared memory (e.g., Win32 and many RTOS platforms do not) then you should use ACE_MMAP_Memory_Pool instead of this class. In fact, you should probably use ACE_MMAP_Memory_Pool on platforms that *do* support System V shared memory since it provides more powerful features, such as persistent backing store and greatly scalability |
ACE_Shared_Memory_Pool::SHM_TABLE | Keeps track of all the segments being used |
ACE_Shared_Memory_Pool_Options | Helper class for Shared Memory Pool constructor options |
ACE_Shared_Memory_SV | Shared memory wrapper based on System V shared memory |
ACE_Shared_Object | Provide the abstract base class used to access dynamic linking facilities |
ACE_Sig_Action | C++ wrapper facade for the sigaction struct |
ACE_Sig_Adapter | Provide an adapter that transforms various types of signal handlers into the scheme used by the ACE_Reactor |
ACE_Sig_Guard | Hold signals in MASK for duration of a C++ statement block. Note that a "0" for mask causes all signals to be held |
ACE_Sig_Handler | This is the main dispatcher of signals for ACE. It improves the existing UNIX signal handling mechanism by allowing C++ objects to handle signals in a way that avoids the use of global/static variables and functions |
ACE_Sig_Handlers | This is an alternative signal handling dispatcher for ACE. It allows a list of signal handlers to be registered for each signal. It also makes SA_RESTART the default mode |
ACE_Sig_Handlers_Set | |
ACE_Sig_Set | Provide a C++ wrapper for the C sigset_t interface |
ACE_Singleton< TYPE, ACE_LOCK > | A Singleton Adapter uses the Adapter pattern to turn ordinary classes into Singletons optimized with the Double-Checked Locking optimization pattern |
ACE_Singleton_Strategy< SVC_HANDLER > | Defines the interface for specifying a creation strategy for a SVC_HANDLER that always returns the same SVC_HANDLER (i.e., it's a Singleton) |
ACE_SizeCDR | A CDR stream for calculating size of the representation |
ACE_SOCK | An abstract class that forms the basis for more specific classes, such as ACE_SOCK_Acceptor and ACE_SOCK_Stream. Do not instantiate this class |
ACE_SOCK_Acceptor | Defines a factory that creates new ACE_Streams passively |
ACE_SOCK_CODgram | Defines the member functions for the ACE_SOCK connected datagram abstraction |
ACE_SOCK_Connector | Defines a factory that actively connects to a remote IP address and TCP port, creating a new ACE_SOCK_Stream object |
ACE_SOCK_Dgram | Defines the member functions for the ACE_SOCK datagram abstraction |
ACE_SOCK_Dgram_Bcast | Defines the member functions for the ACE_SOCK datagram abstraction |
ACE_SOCK_Dgram_Mcast | Defines the ACE socket wrapper for UDP/IP multicast |
ACE_SOCK_Dgram_SC< STREAM > | "Dgram_SC" is short for "Datagram Self-Contained." |
ACE_SOCK_IO | Defines the methods for the ACE socket wrapper I/O routines (e.g., send/recv) |
ACE_SOCK_SEQPACK_Acceptor | Defines a factory that creates new ACE_Associations passively |
ACE_SOCK_SEQPACK_Association | Defines the methods in the ACE_SOCK_SEQPACK_Association abstraction |
ACE_SOCK_SEQPACK_Connector | Defines a factory that actively connects to a remote IP address and TCP port, creating a new ACE_SOCK_SEQPACK_Association object |
ACE_SOCK_Stream | Defines the methods in the ACE_SOCK_Stream abstraction |
ACE_SPIPE | Defines the member functions for the base class of the ACE_SPIPE abstraction |
ACE_SPIPE_Acceptor | A factory class that produces ACE_SPIPE_Stream objects |
ACE_SPIPE_Addr | Defines the SVR4 STREAM pipe address family address format |
ACE_SPIPE_Addr::SPIPE_Addr | Contains security attributes |
ACE_SPIPE_Connector | Defines an active connection factory for ACE_SPIPE_Stream. On Windows this is mapped to Named Pipes, whereas on UNIX it is mapped to STREAM pipes |
ACE_SPIPE_Stream | Defines the methods in the ACE_SPIPE_Stream abstraction |
ACE_SString | A very Simple String ACE_SString class. This is not a general-purpose string class, and you should probably consider using ACE_CString is you don't understand why this class exists.. |
ACE_Stack_Trace | Encapsulate a string representation of a stack trace on supported platforms. Stack traces for code built with optimize=1 (or "Release" configs on Visual Studio) may be misleading (missng frames) due to inlining performed by the compiler, which is indepenent of the inline=0 / inline=1 build option and the __ACE_INLINE__ / ACE_NO_INLINE macros |
ACE_Static_Allocator< POOL_SIZE > | Defines a class that provided a highly optimized memory management scheme for allocating memory statically |
ACE_Static_Allocator_Base | Defines a class that provided a highly optimized memory management scheme for allocating memory statically |
ACE_Static_Svc_Descriptor | Holds the information necessary to describe a statically linked Svc |
ACE_Stats | Provides simple statistical analysis |
ACE_Stats_Value | Helper class for ACE_Stats |
ACE_Str_Buf | Simple wrapper for STREAM pipes strbuf |
ACE_Strategy_Acceptor< SVC_HANDLER, > | Abstract factory for creating a service handler (SVC_HANDLER), accepting into the SVC_HANDLER, and activating the SVC_HANDLER |
ACE_Strategy_Connector< SVC_HANDLER, > | Abstract factory for creating a service handler (SVC_HANDLER), connecting the SVC_HANDLER, and activating the SVC_HANDLER |
ACE_Stream<> | This class is the primary abstraction for the ASX framework. It is moduled after System V Stream |
ACE_Stream_Head<> | Standard 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_Type | Define the methods for handling the configuration of ACE_Streams |
ACE_Streambuf | Create your custom streambuf by providing and ACE_*_Stream object to this template. I have tested it with ACE_SOCK_Stream and it should work fine for others as well |
ACE_Streambuf_T< STREAM > | |
ACE_String_Base< CHAR > | This class provides a wrapper facade for C strings |
ACE_String_Base_Const | This class defines a constant for ACE_String_Base 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_StringCapEntry | This class implement the ACE String Capability subclass |
ACE_Strong_Bound_Ptr< X, ACE_LOCK > | This class implements support for a reference counted pointer |
ACE_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 | |
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_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_Ex<, ACE_MESSAGE_TYPE > | Primary interface for application message processing, as well as input and output message queueing |
ACE_Task_Flags | These flags are used within the ACE_Task |
ACE_Test_and_Set< ACE_LOCK, TYPE > | Implements the classic ``test and set'' operation |
ACE_Thread | Provides a wrapper for threads |
ACE_Thread_Adapter | Converts a C++ function into a function that can be called from a thread creation routine (e.g., pthread_create() or _beginthreadex()) that expects an extern "C" entry point. This class also makes it possible to transparently provide hooks to register a thread with an ACE_Thread_Manager |
ACE_Thread_Condition< MUTEX > | ACE_Condition variable wrapper that works within processes |
ACE_Thread_Control | Used to keep track of a thread's activities within its entry point function |
ACE_Thread_Descriptor | Information for controlling threads that run under the control of the <Thread_Manager> |
ACE_Thread_Descriptor_Base | Basic information for thread descriptors. These information gets extracted out because we need it after a thread is terminated |
ACE_Thread_Exit | Keep exit information for a Thread in thread specific storage. so that the thread-specific exit hooks will get called no matter how the thread exits (e.g., via <ACE_Thread::exit>, C++ or Win32 exception, "falling off the end" of the thread entry point function, etc.) |
ACE_Thread_Exit_Maybe | A version of ACE_Thread_Exit that is created dynamically under the hood if the flag is set to TRUE |
ACE_Thread_Hook | This class makes it possible to provide user-defined "start" hooks that are called before the thread entry point function is invoked |
ACE_Thread_ID | Defines a platform-independent thread ID class. Note that this class should be defined within the scope of a thread, rather than at global scope! |
ACE_Thread_Manager | Manages a pool of threads |
ACE_Thread_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_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_Value | Operations on "timeval" structures, which express time in seconds (secs) and microseconds (usecs) |
ACE_timeprobe_t | Time probe record |
ACE_timeprobe_t::event | Events 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_TLI | Defines the member functions for the base class of the ACE_TLI abstraction |
ACE_TLI_Acceptor | Defines the member functions for ACE_TLI_Acceptor abstraction |
ACE_TLI_Connector | Defines an active connection factory for the ACE_TLI C++ wrappers |
ACE_TLI_Request | |
ACE_TLI_Request_Queue | |
ACE_TLI_Stream | Defines the member functions for ACE_TLI_Stream abstraction |
ACE_Token | Class that acquires, renews, and releases a synchronization token that is serviced in strict FIFO/LIFO ordering and that also supports (1) recursion and (2) readers/writer semantics |
ACE_Token::ACE_Token_Queue | |
ACE_Token::ACE_Token_Queue_Entry | |
ACE_Token_Collection | Allows atomic token group operations AND provides a ACE_Token manager interface |
ACE_Tokenizer | Tokenizer |
ACE_Tokenizer::Delimiter_Entry | Delimiter Entry |
ACE_Tokenizer::Preserve_Entry | Preserve Entry |
ACE_TP_Reactor | Specialization of ACE_Select_Reactor to support thread-pool based event dispatching |
ACE_TP_Token_Guard | A helper class that helps grabbing, releasing and waiting on tokens for a thread that tries calling handle_events () |
ACE_Trace | A C++ trace facility that keeps track of which methods are entered and exited |
ACE_TSS< TYPE > | Allows objects that are "physically" in thread specific storage (i.e., private to a thread) to be accessed as though they were "logically" global to a program |
ACE_TSS_Adapter | This class encapsulates a TSS object and its associated C++ destructor function. It is used by the ACE_TSS... methods (in Synch_T.cpp) in order to allow an extern "C" cleanup routine to be used. Needed by the "frigging" MVS C++ compiler |
ACE_TSS_Cleanup | Singleton that helps to manage the lifetime of TSS objects and keys |
ACE_TSS_Connection | Class for providing a connection per thread |
ACE_TSS_Info | Thread Specific Key management |
ACE_TSS_Keys | Collection of in-use flags for a thread's TSS keys. For internal use only by ACE_TSS_Cleanup; it is public because some compilers can't use nested classes for template instantiation parameters |
ACE_TSS_Ref | "Reference count" for thread-specific storage keys |
ACE_TSS_Singleton< TYPE, ACE_LOCK > | This class uses the Adapter pattern to turn ordinary classes into Thread-specific Singletons optimized with the Double-Checked Locking optimization pattern |
ACE_TSS_Type_Adapter< TYPE > | Adapter that allows built-in types to be used with ACE_TSS |
ACE_TTY_IO | Class definitions for platform specific TTY features |
ACE_TTY_IO::Serial_Params | |
ACE_Type_Traits< TYPE > | |
ACE_Type_Traits< bool > | |
ACE_Type_Traits< char > | |
ACE_Type_Traits< double > | |
ACE_Type_Traits< float > | |
ACE_Type_Traits< int > | |
ACE_Type_Traits< long > | |
ACE_Type_Traits< long double > | |
ACE_Type_Traits< long long > | |
ACE_Type_Traits< short > | |
ACE_Type_Traits< signed char > | |
ACE_Type_Traits< TYPE * > | |
ACE_Type_Traits< unsigned char > | |
ACE_Type_Traits< unsigned int > | |
ACE_Type_Traits< unsigned long > | |
ACE_Type_Traits< unsigned long long > | |
ACE_Type_Traits< unsigned short > | |
ACE_Typed_SV_Message< T > | Defines the header file for the C++ wrapper for System V message queues |
ACE_Typed_SV_Message_Queue< T > | Defines the header file for the C++ wrapper facade for typed message queues |
ACE_Unbounded_Queue< T > | A Queue of "infinite" length |
ACE_Unbounded_Queue_Const_Iterator< T > | Implement an iterator over an const unbounded queue |
ACE_Unbounded_Queue_Iterator< T > | Implement an iterator over an unbounded queue |
ACE_Unbounded_Set< T > | Compatibility wrapper for ACE_Unbounded_Set_Ex |
ACE_Unbounded_Set_Const_Iterator< T > | Compatibility wrapper for ACE_Unbounded_Set_Ex_Const_Iterator |
ACE_Unbounded_Set_Default_Comparator< T > | Simple comparator that evaluates equality using == operator |
ACE_Unbounded_Set_Ex< T, C > | Implement a simple unordered set of <T> of unbounded size |
ACE_Unbounded_Set_Ex_Const_Iterator< T, C > | Implement an const iterator over an unbounded set |
ACE_Unbounded_Set_Ex_Iterator< T, C > | Implement an iterator over an unbounded set |
ACE_Unbounded_Set_Iterator< T > | Compatibility wrapper for ACE_Unbounded_Set_Ex_Iterator |
ACE_Unbounded_Stack< T > | Implement a generic LIFO abstract data type |
ACE_Unbounded_Stack_Iterator< T > | Implement an iterator over an unbounded Stack |
ACE_UNIX_Addr | Defines the ``UNIX domain address family'' address format |
ACE_Unmanaged_Singleton< TYPE, ACE_LOCK > | Same as ACE_Singleton, except does _not_ register with ACE_Object_Manager for destruction |
ACE_Unmanaged_TSS_Singleton< TYPE, ACE_LOCK > | Same as ACE_TSS_Singleton, except does _not_ register with ACE_Object_Manager for destruction |
ACE_UPIPE_Acceptor | Defines the format and interface for the listener side of the ACE_UPIPE_Stream |
ACE_UPIPE_Connector | Defines an active connection factory for the ACE_UPIPE_STREAM wrappers |
ACE_UPIPE_Stream | Defines the method that transfer data on a UPIPE |
ACE_UUID | |
ACE_UUID_Generator | |
ACE_Vector< T, DEFAULT_SIZE > | Defines an STL-like vector container |
ACE_Vector_Iterator< T, DEFAULT_SIZE > | Implement an iterator over an ACE_Vector |
ACE_WChar_Codeset_Translator | Codeset translation routines common to both Output and Input CDR streams |
ACE_Weak_Bound_Ptr< X, ACE_LOCK > | This class implements support for a weak pointer that complements ACE_Strong_Bound_Ptr |
ACE_Wide_To_Ascii | A 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_Conf | This abstract class defines the common operations ACE_Service_Config expects when using the XML Service Config Parser |
ace_yy_buffer_state | |
ACMM | |
Admin | Accesses monitor points or groups and manages the registries |
ACE_Utils::Auto_Functor< X, Functor > | Helper template to implement auto_ptr<>-like classes, but executing a functor in the destructor, instead of always deleting things |
ACE_Utils::Auto_Functor_Ref< X, Functor > | Helper class to implement assignment and copy-construction as expected |
auto_ptr< X > | Implements the draft C++ standard auto_ptr abstraction |
cancel_state | |
ACE_Utils::Comparator< LEFT, RIGHT > | Structure that provides optimal comparison operation for given types |
ACE::Monitor_Control::Control_Action | |
ControlAction | Base class for control actions initiated by the application or by constraint evaluation trigger |
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 |
frame_state | |
Hash_Token< TYPE > | |
If_Then_Else | Compile-time selection of type based on a boolean value |
If_Then_Else | Select of type Ta if boolean value is true |
If_Then_Else | Select of type Tb if boolean value is false |
ACE::ACE::If_Then_Else< false, Ta, Tb > | |
ACE::ACE::If_Then_Else< true, Ta, Tb > | |
ACE_OS::macaddr_node_t | |
MAP_MANAGER | |
ACE::Monitor_Control::Monitor_Admin | |
ACE::Monitor_Control::Monitor_Admin_Manager | Repsonsible for creating and destroying the global (per process) instance of the Admin class |
ACE::Monitor_Control::Monitor_Base | Base class from which the template monitor point class is derived |
ACE::Monitor_Control::Monitor_Control_Types | |
ACE::Monitor_Control::Monitor_Control_Types::Constraint | Bundles the constrain string with its associated trigger action |
ACE::Monitor_Control::Monitor_Control_Types::Data | An instance is contained by each enabled monitor point |
ACE::Monitor_Control::Monitor_Point_Auto_Updater | Automates periodic updating of monitor point classes |
ACE::Monitor_Control::Monitor_Point_Registry | Storage for instantiated monitor points |
msghdr | |
ACE_Utils::Noop_Truncator< FROM, TO > | No-op truncation |
rusage | |
Safe_Comparator | Conservative 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 > | |
ACE::Monitor_Control::Size_Monitor | Base class from which ACE monitors of size are derived |
strbuf | |
timespec | |
To_Unsigned | Retrieve 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_cast | Helper function to truncate an integral value to the maximum value of the given type |
ACE_Utils::Truncator< FROM, TO > | Truncate value of type FROM to value of type TO |
ACE_Utils::ACE_Utils::Truncator< T, T > | |
TSS_Cleanup_Instance | |
ACE_Utils::UUID | |
ACE_Utils::UUID_Generator | |
ACE_Utils::UUID_Generator::UUID_State | |
ACE_Utils::UUID_Node | Class 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 | |