Section 3

• a64l · convert between long and base-64
• aa_attrs · returns pointer to the text output buffer used by AA-lib.
• aa_autoinit · easy to use AA-lib initialization function.
• aa_autoinitkbd · easy to use AA-lib keyboard initialization function.
• aa_autoinitmouse · easy to use AA-lib mouse initialization function.
• aa_close · close the AA-lib context.
• aa_createedit · Simple interactive line editor provided as helper function.
• aa_currentfont · returns specification of the fonts used by AA-lib rendering routines.
• aa_defparams · default hardware paramters requested by AA-lib programs.
• aa_defrenderparams · default rendering parameters.
• aa_displayrecommended · List of recommended drivers.
• aa_dithernames · Names of dithering methods supported by AA-lib.
• aa_drivers · NULL-terminated array of output drivers available in AA-lib.
• aa_edit · Simple interactive line editor.
• aa_editkey · Notify the line editor about keypress.
• aa_fastrender · simple and fast AA-lib rendering function.
• aa_features · an opaque object representing a set of AppArmor kernel features aa_features_new - create a new aa_features object based on a path aa_features_new_from_string - create a new aa_features object based on a string aa_features_new_from_kernel - create a new aa_features object based on the current kernel aa_features_ref - increments the ref count of an aa_features object aa_features_unref - decrements the ref count and frees the aa_features object when 0 aa_features_write_to_fd - write a string representation of an aa_features object to a file descriptor aa_features_write_to_file - write a string representation of an aa_features object to a file aa_features_is_equal - equality test for two aa_features objects aa_features_supports - provides aa_features object support status aa_features_id - provides unique identifier for an aa_features object aa_features_value - the value associated with a given feature.
• aa_fonts · Null-terminated array of available fonts.
• aa_formats · NULL terminated array of save formats supported by AA-lib.
• aa_getevent · keyboard functions
• aa_getkey · return next keypress event from queue.
• aa_getmouse · Get mouse position as specified by last mouse event read by aa_getevent.
• aa_gotoxy · move the hardware cursor (if any) to specified position.
• aa_help · AA-lib help string for the default command line parser.
• aa_hidecursor · hide the hardware cursor.
• aa_hidemouse · hide the mouse cursor.
• aa_image · returns pointer to the framebuffer emulated by AA-lib.
• aa_imgheight · returns height of the emulated image in pixels.
• aa_imgwidth · returns width of the emulated image in pixels.
• aa_init · open the output display for AA-lib.
• aa_initkbd · initialize the AA-lib keyboard driver.
• aa_initmouse · initialize the AA-lib mouse driver.
• aa_kbddrivers · NULL-terminated array of keyboard drivers available in AA_lib.
• aa_kbdrecommended · List of recommended drivers.
• aa_kernel_interface · an opaque object representing the AppArmor kernel interface for policy loading, replacing, and removing aa_kernel_interface_new - create a new aa_kernel_interface object from an optional path aa_kernel_interface_ref - increments the ref count of an aa_kernel_interface object aa_kernel_interface_unref - decrements the ref count and frees the aa_kernel_interface object when 0 aa_kernel_interface_load_policy - load a policy from a buffer into the kernel aa_kernel_interface_load_policy_from_file - load a policy from a file into the kernel aa_kernel_interface_load_policy_from_fd - load a policy from a file descriptor into the kernel aa_kernel_interface_replace_policy - replace a policy in the kernel with a policy from a buffer aa_kernel_interface_replace_policy_from_file - replace a policy in the kernel with a policy from a file aa_kernel_interface_replace_policy_from_fd - replace a policy in the kernel with a policy from a file descriptor aa_kernel_interface_remove_policy - remove a policy from the kernel aa_kernel_interface_write_policy - write a policy to a file descriptor
• aa_mmheight · returns height of the output screen in millimeters.
• aa_mmwidth · returns width of the output screen in millimeters.
• aa_mousedrivers · NULL terminated array of mouse drivers supported by AA-lib.
• aa_mouserecommended · List of recommended drivers.
• aa_parseoptions · parse the standard command line options used by AA-lib.
• aa_policy_cache · an opaque object representing an AppArmor policy cache aa_policy_cache_new - create a new aa_policy_cache object from a path aa_policy_cache_ref - increments the ref count of an aa_policy_cache object aa_policy_cache_unref - decrements the ref count and frees the aa_policy_cache object when 0 aa_policy_cache_remove - removes all policy cache files under a path aa_policy_cache_replace_all - performs a kernel policy replacement of all cached policies aa_policy_cache_dir_path - returns the path to the aa_policy_cache directory aa_policy_cache_dir_path_preview - returns a preview of the path to the aa_policy_cache directory without an existing aa_policy_cache object
• aa_printf · print text to AA-lib output buffers.
• aa_putpixel · put pixel to emulated framebuffer
• aa_puts · output string to AA-lib output buffers.
• aa_recommendhi · insert the given driver on beggining of the list of recommended drivers.
• aa_recommendhidisplay · insert the given driver on beggining of the list of recommended display drivers.
• aa_recommendhikbd · insert the given driver on beggining of the list of recommended keyboard drivers.
• aa_recommendhimouse · insert the given driver on beggining of the list of recommended mouse drivers.
• aa_recommendlow · Add the given driver to the end of list of recommended drivers.
• aa_recommendlowdisplay · Add the given driver to the end of list of display recommended drivers.
• aa_recommendlowkbd · Add the given driver to the end of list of keyboard recommended drivers.
• aa_recommendlowmouse · Add the given driver to the end of list of mouse recommended drivers.
• aa_registerfont · add new font specification to aa_fonts array.
• aa_render · convert image buffer to ASCII-art.
• aa_resize · resize functions
• aa_resizehandler · Set user handler to be called on resize event.
• aa_scrheight · returns height of the output screen in characters.
• aa_scrwidth · returns width of the output screen in characters.
• aa_setfont · set font specification to be used by rendering functions.
• aa_setsupported · alter the "supported" field of hardware_params structure used by AA-lib
• aa_showcursor · show the hardware cursor.
• aa_showmouse · show the mouse cursor.
• aa_splitcon · split the confinement context into a label and mode
• aa_text · returns pointer to the text output buffer used by AA-lib.
• aa_uninitkbd · uninitialize the keyboard driver.
• aa_uninitmouse · uninitialize the mouse driver.
• abi::__forced_unwind · Thrown as part of forced unwinding.
• ablToBddCct · converts an ABL into a BDD within a circuit
• abort · cause abnormal process termination
• abort_handler_s · runtime-constraint violation handling
• ABS
• abs · compute the absolute value of an integer
• abs1 · abs1: | real( x ) | + | imag( x ) |
• abs2rel · make a relative path name from an absolute path name
• AbstractBankAccount · AbstractBankAccount provides the interface for all accounts used in this application.
• Access · check file permissions and other attributes
• accesstime · Meta data for a file or directory.
• AccountProxy · AccountProxy is a read/write access proxy that enables all of the methods for the underlying subject.
• ACE · Contains value added ACE methods that extend the behavior of the UNIX and Win32 OS calls.
• ACE_Accept_Strategy · Defines the interface for specifying a passive connection acceptance strategy for a SVC_HANDLER.
• ACE_Acceptor · Abstract factory for creating a service handler (SVC_HANDLER), accepting into the SVC_HANDLER, and activating the SVC_HANDLER.
• ACE_Activation_Queue · Reifies a method into a request. Subclasses typically represent necessary state and behavior.
• ACE_Active_Map_Manager · Define a map abstraction that associates system generated keys with user specified values.
• ACE_Active_Map_Manager_Adapter · Defines a map implementation.
• ACE_Active_Map_Manager_Iterator_Adapter · Defines a iterator implementation for the Active_Map_Manager_Adapter.
• ACE_Active_Map_Manager_Key · Key used in the Active Object Map.
• ACE_Active_Map_Manager_Reverse_Iterator_Adapter · Defines a reverse iterator implementation for the Active_Map_Manager_Adapter.
• ACE_Adaptive_Lock · An adaptive general locking class that defers the decision of lock type to run time.
• ACE_Addr · Defines the base class for the "address family independent" address format.
• ACE_Allocator · Interface for a dynamic memory allocator that uses inheritance and dynamic binding to provide extensible mechanisms for allocating and deallocating memory.
• ACE_Allocator_Adapter · This class is an Adapter that allows the ACE_Allocator to use the Malloc class below.
• ACE_Arg_Shifter · This ADT shifts known args to the back of the argv vector, so deeper levels of argument parsing can locate the yet unprocessed arguments at the beginning of the vector.
• ACE_ARGV · Transforms a string buf into an argv style vector of strings or an argv style vector of string buf, performing environment variable substitutions if necessary.
• ACE_Array · Implement a dynamic array class.
• ACE_Array_Base · Implement a simple dynamic array
• ACE_Array_Iterator · Implement an iterator over an ACE_Array.
• ACE_Async_Timer_Queue_Adapter
• ACE_Asynch_Accept · This class is a factory for starting off asynchronous accepts on a listen handle. This class forwards all methods to its implementation class.
• ACE_Asynch_Accept_Impl · Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Accept.
• ACE_Asynch_Accept_Result_Impl · Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Accept.
• ACE_Asynch_Acceptor · This class is an example of the Acceptor Pattern. This class will accept new connections and create new HANDLER to handle the new connections.
• ACE_Asynch_Operation · This is an interface base class for all asynch operations. The resposiblility of this class is to forward all methods to its delegation/implementation class, e.g., ACE_WIN32_Asynch_Operation or ACE_POSIX_Asynch_Operation.
• ACE_Asynch_Operation_Impl · Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Operation.
• ACE_Asynch_Read_File · This class is a factory for starting off asynchronous reads on a file. This class forwards all methods to its implementation class.
• ACE_Asynch_Read_File_Impl · Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Read_File::Result.
• ACE_Asynch_Read_File_Result_Impl · This is the abstract base class for all the concrete implementation classes for ACE_Asynch_Read_File::Result.
• ACE_Asynch_Read_Stream · This class is a factory for starting off asynchronous reads on a stream. This class forwards all methods to its implementation class.
• ACE_Asynch_Read_Stream_Impl · Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Read_Stream
• ACE_Asynch_Read_Stream_Result_Impl · Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Read_Stream::Result class.
• ACE_Asynch_Result · An interface base class which allows users access to common information related to an asynchronous operation.
• ACE_Asynch_Result_Impl · Abstract base class for the all the classes that provide concrete implementations for ACE_Asynch_Result.
• ACE_Asynch_Transmit_File · This class is a factory for starting off asynchronous transmit files on a stream.
• ACE_Asynch_Transmit_File_Impl · Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Transmit_File.
• ACE_Asynch_Transmit_File_Result_Impl · Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Transmit_File::Result.
• ACE_Asynch_Write_File · This class is a factory for starting off asynchronous writes on a file. This class forwards all methods to its implementation class.
• ACE_Asynch_Write_File_Impl · Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Write_File.
• ACE_Asynch_Write_File_Result_Impl · This is the abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Write_File::Result.
• ACE_Asynch_Write_Stream · This class is a factory for starting off asynchronous writes on a stream. This class forwards all methods to its implementation class.
• ACE_Asynch_Write_Stream_Impl · Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Write_Stream class.
• ACE_Asynch_Write_Stream_Result_Impl · Abstract base class for all the concrete implementation classes that provide different implementations for the ACE_Asynch_Write_Stream::Result.
• ACE_At_Thread_Exit · Contains a method to be applied when a thread is terminated.
• ACE_At_Thread_Exit_Func
• ACE_ATM_Acceptor · Defines the member functions for ACE_ATM_Acceptor abstraction.
• ACE_ATM_Addr · Defines the ATM domain address family address format.
• ACE_ATM_Connector · Defines an active connection factory for the ACE_ATM C++ wrappers.
• ACE_ATM_Params · Wrapper class that simplifies the information passed to the ATM enabled ACE_ATM_Connector class.
• ACE_ATM_QoS · Define the QoS parameters for ATM
• ACE_ATM_Stream · Defines the member functions for ACE_ATM_Stream abstraction.
• ACE_Atomic_Op · Transparently parameterizes synchronization into basic arithmetic operations.
• ACE_Auto_Array_Ptr · Implements an extension to the draft C++ standard auto_ptr abstraction.
• ACE_Auto_Basic_Array_Ptr · Implements an extension to the draft C++ standard auto_ptr abstraction. This class allows one to work on non-object (basic) types that must be treated as an array, e.g., deallocated via "delete [] foo".
• ACE_Auto_Basic_Ptr · Implements the draft C++ standard auto_ptr abstraction. This class allows one to work on non-object (basic) types
• ACE_Auto_Event · Auto Events.
• ACE_Auto_String_Free · Simple class to automatically de-allocate strings
• ACE_Barrier · This is a no-op to make ACE "syntactically consistent."
• ACE_Based_Pointer · A smart proxy that keeps track of the relative offset of a "pointer" from its base address.
• ACE_Based_Pointer_Basic · A proxy that keeps track of the relative offset of a "pointer" from its base address. This class makes it possible to transparently use "pointers" in shared memory as easily as programming with pointers to local memory. In particular, we don't need to ensure that the base addresses of all the pointers are mapped into separate processes at the same absolute memory base address.
• ACE_Based_Pointer_Repository · Maps pointers to the base address of the region to which each pointer belongs.
• ACE_Bcast_Node · Linked list of broadcast interfaces.
• ACE_Bounded_Set · Implement a simple unordered set of T with maximum set at creation time.
• ACE_Bounded_Set_Iterator · Interates through an unordered set.
• ACE_Bounded_Stack · Implement a generic LIFO abstract data type.
• ACE_Buffered_Svc_Handler · Defines the interface for a service that exchanges data with its connected peer and supports buffering.
• ACE_Cache_Map_Iterator · Defines a iterator for the Cache_Map_Manager.
• ACE_Cache_Map_Manager · Defines a abstraction that will purge entries from a map.
• ACE_Cache_Map_Reverse_Iterator · Defines a reverse iterator for the Cache_Map_Manager.
• ACE_Cached_Allocator · Create a cached memory poll with n_chunks chunks each with sizeof (TYPE) size.
• ACE_Cached_Connect_Strategy · A connection strategy which caches connections to peers (represented by SVC_HANDLER instances), thereby allowing subsequent re-use of unused, but available, connections.
• ACE_Cached_Connect_Strategy_Ex · A connection strategy which caches connections to peers (represented by SVC_HANDLER instances), thereby allowing subsequent re-use of unused, but available, connections.
• ACE_Cached_Mem_Pool_Node · ACE_Cached_Mem_Pool_Node keeps unused memory within a free list.
• ACE_Caching_Strategy · This class is an abstract base class for a caching strategy.
• ACE_Caching_Strategy_Adapter · This class follows the Adaptor pattern and is used to provide External Polymorphism by deriving from ACE_Caching_Strategy.
• ACE_CDR · Keep constants and some routines common to both Output and Input CDR streams.
• ACE_CE_Bridge · This class bridges between ACE's default text output windows and the original ACE program.
• ACE_CE_Errno
• ACE_Char_Codeset_Translator · Codeset translation routines common to both Output and Input CDR streams.
• ACE_Cleanup · Base class for objects that are cleaned by ACE_Object_Manager.
• ACE_Cleanup_Adapter · Adapter for ACE_Cleanup objects that allows them to be readily managed by the ACE_Object_Manager.
• ACE_Cleanup_Info · Hold cleanup information for thread/process
• ACE_Cleanup_Strategy · Defines a default strategy to be followed for cleaning up entries from a map which is the container.
• ACE_Command_Base · Defines an abstract class that allows us to invoke commands without knowing anything about the implementation.
• ACE_Command_Callback · Defines a class template that allows us to invoke a GOF command style callback to an object without knowing anything about the object except its type.
• ACE_Concurrency_Strategy · Defines the interface for specifying a concurrency strategy for a SVC_HANDLER.
• ACE_cond_t · This structure is used to implement condition variables on platforms that lack it natively, such as VxWorks, pSoS, and Win32.
• ACE_condattr_t
• ACE_Condition · ACE_Condition variable wrapper, which allows threads to block until shared data changes state.
• ACE_Condition_Attributes
• ACE_Condition_Thread_Mutex · ACE_Condition variable wrapper written using ACE_Mutexes This allows threads to block until shared data changes state. A condition variable enables threads to atomically block and test the condition under the protection of a mutual exclu- sion lock (mutex) until the condition is satisfied. That is, the mutex must have been held by the thread before calling wait or signal on the condition. If the condition is false, a thread blocks on a condition variable and atomically releases the mutex that is waiting for the condition to change. If another thread changes the condition, it may wake up waiting threads by signaling the associated condition variable. The waiting threads, upon awakening, reacquire the mutex and re-evaluate the condition.
• ACE_Connect_Strategy · Defines the interface for specifying an active connection establishment strategy for a SVC_HANDLER.
• ACE_Connection_Recycling_Strategy · Defines the interface for a connection recycler.
• ACE_Connector · Generic factory for actively connecting clients and creating service handlers (SVC_HANDLERs).
• ACE_Control_Block · This information is stored in memory allocated by the Memory_Pool.
• ACE_CORBA_Handler · Handle Orbix requests in conjunction with ACE.
• ACE_CORBA_Ref · A wrapper for helping with Orbix object references.
• ACE_Countdown_Time · Keeps track of the amount of elapsed time.
• ACE_Creation_Strategy · Defines the interface for specifying a creation strategy for a SVC_HANDLER.
• ACE_CString · This class provides a wrapper facade for C strings.
• ACE_Data_Block · Stores the data payload that is accessed via one or more ACE_Message_Blocks.
• 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 UNIX directory-entry iterator.
• ACE_DLL · Provides an abstract interface for handling various DLL operations.
• ACE_DLL_Strategy · Defines the interface for specifying a creation strategy for a SVC_HANDLER based on dynamic linking of the SVC_HANDLER.
• ACE_DLList · A double-linked list container class.
• ACE_DLList_Iterator · A double-linked list container class iterator.
• ACE_DLList_Node · Base implementation of element in a DL list. Needed for ACE_Double_Linked_List.
• ACE_DLList_Reverse_Iterator · A double-linked list container class iterator.
• ACE_DNode · Implementation element in a bilinked list.
• ACE_Double_Linked_List · A double-linked list implementation.
• ACE_Double_Linked_List_Iterator · Implements an iterator for a double linked list ADT
• ACE_Double_Linked_List_Iterator_Base · Implements a common base class for iterators for a double linked list ADT
• ACE_Double_Linked_List_Reverse_Iterator · Implements a reverse iterator for a double linked list ADT
• ACE_Driver
• ACE_Dummy_Node · I forget why this is here... ;-)
• ACE_Dumpable · Base class that defines a uniform interface for all object dumping.
• ACE_Dumpable_Adapter · This class inherits the interface of the abstract ACE_Dumpable class and is instantiated with the implementation of the concrete component class class Concrete.
• ACE_Dumpable_Ptr · A smart pointer stored in the in-memory object database ACE_ODB. The pointee (if any) is deleted when reassigned.
• ACE_Dynamic · Checks to see if an object was dynamically allocated.
• ACE_Dynamic_Message_Queue · A derived class which adapts the 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_Node · Handle a dynamically linked node.
• ACE_Dynamic_Service · Provides a general interface to retrieve arbitrary objects from the ACE service repository.
• ACE_EH_Dispatch_Info · This structure contains information of the activated event handler.
• ACE_Env_Value · Enviroment Variable Value
• ACE_Equal_To · Function object for comparing two objects of the given type for equality.
• ACE_Errno_Guard · Provides a wrapper to improve performance when thread-specific errno must be saved and restored in a block of code.
• ACE_Event · A wrapper around the Win32 event locking mechanism.
• ACE_Event_Descriptions · Event Descriptions.
• ACE_Event_Handler · Provides an abstract interface for handling various types of I/O, timer, and signal events.
• ACE_Event_Handler_Handle_Timeout_Upcall · Functor for Timer_Queues.
• ACE_Event_Handler_T · Enable a class that doesn't inherit from the ACE_Event_Handler to be incorporated into the ACE_Reactor framework. Thanks to Greg Lavender ([email protected]) for sharing this idea.
• ACE_event_t
• ACE_Event_Tuple · An ACE_Event_Handler and its associated ACE_HANDLE.
• ACE_Export
• ACE_FIFO · Abstract base class for UNIX FIFOs
• ACE_FIFO_Caching_Strategy · The First In First Out strategy is implemented wherein each item is ordered.
• ACE_FIFO_Recv · Receiver side of the bytestream C++ wrapper for UNIX FIFOs.
• ACE_FIFO_Recv_Msg · Receiver side for the record oriented C++ wrapper for UNIX FIFOs.
• ACE_FIFO_Send · Sender side for the bytestream C++ wrapper for UNIX FIFOs
• ACE_FIFO_Send_Msg · Sender side for the Record oriented C++ wrapper for UNIX FIFOs.
• ACE_FILE · Defines the core methods of the 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_Iterator · Interates through an unordered set.
• ACE_Fixed_Stack · Implement a generic LIFO abstract data type.
• ACE_Flow_Spec
• ACE_FlReactor · A Reactor implementation that uses the Fast-Light (FL) toolkit for event demultiplexing. This will let us integrate the FL toolkit with ACE and/or TAO.
• ACE_Free_List · Implements a free list.
• ACE_Function_Node · Keeps track of the symbol name of for a shared function.
• ACE_Function_Timeprobe · Auto pointer like time probes. It will record event on construction and event + 1 on destruction.
• ACE_Future · This class implements a ``single write, multiple read'' pattern that can be used to return results from asynchronous method invocations.
• ACE_Future_Observer · ACE_Future_ObserverT
• ACE_Future_Rep · ACE_Future_RepT
• ACE_Future_Set · This class implements a mechanism which allows the values of a collections of ACE_Future objects to be accessed by reader threads as they become available.
• ACE_Get_Opt · Iterator for parsing command-line arguments.
• ACE_Guard · This data structure is meant to be used within a method or function... It performs automatic aquisition and release of a parameterized synchronization object ACE_LOCK.
• ACE_Handle_Gobbler · This class gobbles up handles.
• ACE_Handle_Set · C++ wrapper facade for the socket fd_set abstraction.
• ACE_Handle_Set_Iterator · Iterator for the ACE_Handle_Set abstraction.
• ACE_Handler · This base class defines the interface for receiving the results of asynchronous operations.
• ACE_Handler_Caching_Utility · Defines a helper class for the Caching Strategies.
• ACE_Handler_Cleanup_Strategy · Defines a strategy to be followed for cleaning up entries which are svc_handlers from a container.
• ACE_Hash · Function object for hashing
• ACE_Hash_Cache_Map_Manager · Defines a abstraction which will purge entries from a map. The map considered is the ACE_Hash_Map_Manager_Ex.
• ACE_Hash_Map_Bucket_Iterator · Forward iterator for the 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_Entry · Define an entry in the hash table.
• ACE_Hash_Map_Iterator · Wrapper for backward compatibility.
• ACE_Hash_Map_Iterator_Base_Ex · Base iterator for the ACE_Hash_Map_Manager_Ex
• ACE_Hash_Map_Iterator_Ex · Forward iterator for the ACE_Hash_Map_Manager_Ex.
• ACE_Hash_Map_Manager · Wrapper for backward compatibility.
• ACE_Hash_Map_Manager_Ex · Define a map abstraction that efficiently associates EXT_IDs with INT_IDs.
• ACE_Hash_Map_Manager_Ex_Adapter · Defines a map implementation.
• ACE_Hash_Map_Manager_Ex_Iterator_Adapter · Defines a iterator implementation for the Hash_Map_Manager_Adapter.
• ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter · Defines a reverse iterator implementation for the Hash_Map_Manager_Adapter.
• ACE_Hash_Map_Reverse_Iterator · Wrapper for backward compatibility.
• ACE_Hash_Map_Reverse_Iterator_Ex · Reverse iterator for the ACE_Hash_Map_Manager_Ex.
• ACE_Hash_Map_With_Allocator · This class is a thin wrapper around ACE_Hash_Map_Manager, which comes handy when ACE_Hash_Map_Manager is to be used with a non-nil ACE_Allocator. This wrapper insures that the appropriate allocator is in place for every operation that accesses or updates the hash map.
• ACE_Hashable
• 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_IBM1047_ISO8859 · Codeset translation specialization.
• ACE_Incremental_Key_Generator · Defines a simple incremental key generator.
• ACE_INET_Addr · Defines a C++ wrapper facade for the Internet domain address family format.
• ACE_InputCDR · A CDR stream for reading, i.e. for demarshalling.
• 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 · 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_ISO8859_IBM1047 · Codeset translation specialization.
• ACE_Iterator · Defines the iterator interface.
• ACE_Iterator_Impl · Defines a abstract iterator.
• ACE_Laxity_Message_Strategy · Laxity based message priority strategy.
• ACE_Less_Than · Function object for determining whether the first object of the given type is less than the second object of the same type.
• ACE_LFU_Caching_Strategy · Defines a Least Frequently Used strategy for which will decide on the item to be removed from the cache.
• ACE_Lite_MMAP_Memory_Pool · Make a ``lighter-weight'' memory pool based ACE_Mem_Map.
• ACE_Local_Memory_Pool · Make a memory pool that is based on C++ new/delete. This is useful for integrating existing components that use new/delete into the ACE Malloc scheme...
• ACE_Local_Memory_Pool_Options · Helper class for Local Memory Pool constructor options.
• ACE_Local_Mutex · Class that acquires, renews, and releases a synchronization token local to the process.
• ACE_Local_Name_Space · Maintaining accesses Local Name Server Database. Allows to add NameBindings, change them, remove them and resolve NameBindings.
• ACE_Local_RLock · Class that acquires, renews, and releases a readers lock that is local to the process.
• ACE_Local_WLock · Class that acquires, renews, and releases a writer lock that is local to the process.
• ACE_Location_Node · Keep track of where a shared library is located.
• ACE_Lock · This is the abstract base class that contains the uniform locking API that is supported by all the ACE synchronization mechanisms.
• ACE_Lock_Adapter · 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 · Specialize ACE_SOCK_Acceptor to lock around accept;
• ACE_Locked_Data_Block · A Data_Block with a concrete locking strategy.
• ACE_Locked_Free_List · Implements a free list.
• ACE_Log_Msg · Provides a variable length argument message logging abstraction.
• ACE_Log_Msg_Callback · An interface class used for getting logging callbacks.
• ACE_Log_Record
• ACE_LRU_Caching_Strategy · Defines a Least Recently Used strategy which will decide on the item to be removed from the cache.
• ACE_LSOCK · Create a Local ACE_SOCK, which is used for passing file descriptors.
• ACE_LSOCK_Acceptor · Defines the format and interface for the acceptor side of the local ACE_SOCK ACE_Stream.
• ACE_LSOCK_CODgram · Defines the member functions for the 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 · Define a C++ class that uses parameterized types to provide an extensible mechanism for encapsulating various of dynamic memory management strategies.
• ACE_Malloc_FIFO_Iterator · FIFO iterator for names stored in Malloc'd memory.
• ACE_Malloc_Header · This is the control block header. It's used by ACE_Malloc to keep track of each chunk of data when it's in the free list or in use.
• ACE_Malloc_LIFO_Iterator · LIFO iterator for names stored in Malloc'd memory.
• ACE_Malloc_Stats
• ACE_Managed_Object · Wrapper for interface to allocate an object managed by the ACE_Object_Manager.
• ACE_Manual_Event · Manual Events.
• ACE_Map · Defines a map interface.
• ACE_Map_Entry · An entry in the Map.
• ACE_Map_Impl · Defines a map implementation.
• ACE_Map_Impl_Iterator_Adapter · Defines a iterator implementation for the Map_Impl class.
• ACE_Map_Impl_Reverse_Iterator_Adapter · Defines a reverse iterator implementation for the Map_Impl class.
• ACE_Map_Iterator · Forward iterator for the ACE_Map_Manager.
• ACE_Map_Iterator_Base · Iterator for the ACE_Map_Manager.
• ACE_Map_Manager · Define a map abstraction that associates EXT_IDs with INT_IDs.
• ACE_Map_Manager_Adapter · Defines a map implementation.
• ACE_Map_Manager_Iterator_Adapter · Defines a iterator implementation for the Map_Manager_Adapter.
• ACE_Map_Manager_Reverse_Iterator_Adapter · Defines a reverse iterator implementation for the Map Manager.
• ACE_Map_Reverse_Iterator · Reverse Iterator for the ACE_Map_Manager.
• ACE_Mem_Map · C++ interface OS memory mapping system call.
• ACE_Message_Block · Stores messages for use throughout ACE (particularly ACE_Message_Queue).
• ACE_Message_Queue · A threaded message queueing facility, modeled after the queueing facilities in System V STREAMs.
• ACE_Message_Queue_Base · Workaround HP/C++ compiler bug with enums in templates.
• ACE_Message_Queue_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_NT · Message Queue implementation using IO completion port on NT.
• ACE_Message_Queue_Reverse_Iterator · Reverse Iterator for the ACE_Message_Queue.
• ACE_Message_Queue_Vx · Wrapper for VxWorks message queues.
• ACE_Method_Request · Reifies a method into a request. Subclasses provide the necessary state and behavior.
• ACE_MMAP_Memory_Pool · Make a memory pool that is based on mmap(2). This implementation allows memory to be shared between processes.
• ACE_MMAP_Memory_Pool_Options · Helper class for MMAP Memory Pool constructor options.
• ACE_Module · An abstraction for managing a bi-directional flow of messages.
• ACE_Module_Base · Workaround HP/C++ compiler bug with enums in templates.
• ACE_Module_Type · Define the methods for handling the configuration of ACE_Modules.
• ACE_Msg_WFMO_Reactor · An OO event demultiplexor and event handler dispatcher for Win32 MsgWaitForMultipleObjects.
• ACE_MT_CORBA_Handler · Handle multi-threaded Orbix requests in conjunction with the ACE_Reactor.
• ACE_MT_SYNCH · Implement a default thread safe synchronization wrapper that typedefs the ACE_Condition and ACE_Mutex to the ACE_Condition and ACE_Mutex versions. Note that this should be a template, but SunC++ 4.0.1 complains about this...
• ACE_Multiplexor
• ACE_Mutex · ACE_Mutex wrapper (valid in same process or across processes (depending on TYPE flag)).
• ACE_Mutex_Invariants · Mutex Invariants
• ACE_Mutex_Token · Class that acquires, renews, and releases a process-local synchronization token.
• ACE_Name_Binding · Maintains a mapping from name to value and type.
• ACE_Name_Node · This class supports "named memory regions" within ACE_Malloc.
• ACE_Name_Options · Manages the options for the ACE Name_Server.
• ACE_Name_Proxy · Proxy for dealing with remote server process managing NET_LOCAL NameBindings.
• ACE_Name_Reply · Message format for delivering replies from the ACE_Name Server.
• ACE_Name_Request · Message format for delivering requests to the ACE_Name Server.
• ACE_Name_Space · Abstract base class that provides an abstract interface to the database without exposing any implemenation details.
• ACE_Name_Space_Map · 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_No_Heap_Check
• ACE_Node · Implementation element in a Queue, Set, and Stack.
• ACE_NOOP_Concurrency_Strategy · Implements a no-op activation strategy in order to avoid calling open on a svc_handler multiple times.
• ACE_NOOP_Creation_Strategy · Implements a no-op creation strategy in order to defer decisions regarding creation to some later point in time, such as in connect or accept strategy.
• ACE_Noop_Key_Generator · Defines a noop key generator.
• ACE_Noop_Token
• ACE_Notification_Buffer · Simple wrapper for passing ACE_Event_Handler *s and ACE_Reactor_Masks between threads.
• ACE_Notification_Strategy · Abstract class used for notifing an interested party
• ACE_NS_Internal · This class and ACE_NS_String are used as Adapters to work with the Map_Manager.
• ACE_NS_String · This class and ACE_NS_Internal are used as Adapters to work with the Map_Manager.
• ACE_NT_Service · Provide the base class which defines the interface for controlling an NT service.
• ACE_Null_Barrier · Implements "NULL barrier synchronization".
• ACE_Null_Caching_Strategy · The is a special caching strategy which doesnt have the purging feature.
• ACE_Null_Caching_Utility · Defines a dummy helper class for the Caching Strategies.
• ACE_Null_Cleanup_Strategy · Defines a do-nothing implementation of the cleanup strategy.
• ACE_Null_Condition · Implement a do nothing 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_Mutex_Guard · This data structure is meant to be used within a method or function... It performs automatic aquisition and release of an ACE_Null_Mutex.
• ACE_Null_Semaphore · Implement a do nothing ACE_Semaphore, i.e., all the methods are no ops.
• ACE_NULL_SYNCH · Implement a do nothing Synchronization wrapper that typedefs the ACE_Condition and ACE_Mutex to the Null* versions.
• ACE_Null_Token · No op class for nonthreaded platform protocols.
• ACE_Obchunk · Defines the state that represents a "chunk" of memory.
• ACE_Object_Manager · Manager for ACE library services and singleton cleanup.
• ACE_Object_Node · Keeps track of the symbol name for a shared object.
• ACE_Obstack · Define a simple "mark and release" memory allocation utility.
• ACE_ODB · This is the object database (ODB) that keeps track of all live ACE objects.
• ACE_Oneshot_Acceptor · Generic factory for passively connecting clients and creating exactly one service handler (SVC_HANDLER).
• ACE_Ordered_MultiSet · Implement a simple ordered multiset of T of unbounded size. This class template requires that operator semantics be defined for the parameterized type T, but does not impose any restriction on how that ordering operator is implemented.
• ACE_Ordered_MultiSet_Iterator · Implement a bidirectional iterator over an ordered multiset. This class template requires that operator semantics be defined for the parameterized type T, but does not impose any restriction on how that ordering operator is implemented.
• ACE_OS_CString · A lightweight char* to wchar* string conversion class.
• ACE_OS_Exit_Info · Hold Object Manager cleanup (exit) information.
• ACE_OS_Thread_Descriptor · Parent class of all ACE_Thread_Descriptor classes. = Container for ACE_Thread_Descriptor members that are used in ACE_OS.
• ACE_OS_WString · A lightweight wchar* to char* string conversion class.
• ACE_OutputCDR · A CDR stream for writing, i.e. for marshalling.
• ACE_OVERLAPPED
• ACE_Pagefile_Memory_Pool · Make a memory pool that is based on "anonymous" memory regions allocated from the Win32 page file.
• ACE_Pagefile_Memory_Pool_Options · Helper class for Pagefile Memory Pool constructor options.
• ACE_Pair
• ACE_Pair_Caching_Utility · Defines a helper class for the Caching Strategies.
• ACE_Parse_Node · Provide the base of the object hierarchy that defines the parse tree of Service Nodes.
• ACE_Pipe · Provides a bidirectional "pipe" abstraction that is portable to Windows NT, SVR4 UNIX, and BSD UNIX.
• ACE_Pointer_Hash · Function object for hashing pointers
• ACE_POSIX_AIOCB_Asynch_Accept
• ACE_POSIX_AIOCB_Asynch_Operation · This class implements ACE_Asynch_Operation for AIOCB (Asynchronous I/O Control Blocks) based implementation of Proactor.
• ACE_POSIX_AIOCB_Asynch_Read_File · This class is a factory for starting off asynchronous reads on a file. This class implements ACE_Asynch_Read_File for AIOCB (Asynchronous I/O Control Blocks) based implementation of Proactor.
• ACE_POSIX_AIOCB_Asynch_Read_Stream · This class implements ACE_Asynch_Read_Stream for AIOCB (Asynchronous I/O Control Blocks) based implementation of Proactor.
• ACE_POSIX_AIOCB_Asynch_Transmit_File
• ACE_POSIX_AIOCB_Asynch_Write_File · This class provides concrete implementation for ACE_Asynch_Write_File for POSIX platforms where the completion strategy for Proactor is based on AIOCB (AIO Control Blocks).
• ACE_POSIX_AIOCB_Asynch_Write_Stream · This class implements ACE_Asynch_Write_Stream for AIOCB (Asynchronous I/O Control Blocks) based implementation of Proactor.
• ACE_POSIX_AIOCB_Proactor · This Proactor makes use of Asynchronous I/O Control Blocks (AIOCB) to notify/get the completion status of the aio_ operations issued.
• ACE_POSIX_Asynch_Accept_Result · This is that class which will be passed back to the handler when the asynchronous accept completes.
• ACE_POSIX_Asynch_Operation · This class abstracts out the common things needed for implementing Asynch_Operation for POSIX platforms. Specific implementations such as POSIX_AIOCB_Asynch_Operation and POSIX_SIG_Asynch_Operation etc., can derive from this class.
• ACE_POSIX_Asynch_Read_File_Result · This class provides concrete implementation for ACE_Asynch_Read_File::Result class for POSIX platforms.
• ACE_POSIX_Asynch_Read_Stream_Result · This class provides concrete implementation for ACE_Asynch_Read_Stream::Result class for POSIX platforms.
• ACE_POSIX_Asynch_Result · This class provides concrete implementation for ACE_Asynch_Result for POSIX4 platforms. This class extends aiocb and makes it more useful.
• ACE_POSIX_Asynch_Timer · This class is posted to the completion port when a timer expires. When the complete method of this object is called, the handler's handle_timeout method will be called.
• ACE_POSIX_Asynch_Transmit_File_Result · This is that class which will be passed back to the handler when the asynchronous transmit file completes.
• ACE_POSIX_Asynch_Write_File_Result · This class provides implementation for ACE_Asynch_Write_File_Result for POSIX platforms.
• ACE_POSIX_Asynch_Write_Stream_Result · This class provides concrete implementation for ACE_Asynch_Write_Stream::Result on POSIX platforms.
• ACE_POSIX_Proactor · POSIX implementation of the Proactor.
• ACE_POSIX_SIG_Asynch_Accept · This class implements ACE_Asynch_Accept for Real-Time Signal (sigtimedwait) based implementation of Proactor.
• ACE_POSIX_SIG_Asynch_Operation · This class implements ACE_Asynch_Operation for Real-Time Signal (sigtimedwait) based implementation of Proactor.
• ACE_POSIX_SIG_Asynch_Read_File · This class is a factory for starting off asynchronous reads on a file. This class implements ACE_Asynch_Operation for Real-Time Signal (sigtimedwait) based implementation of Proactor.
• ACE_POSIX_SIG_Asynch_Read_Stream · This class implements ACE_Asynch_Read_Stream for Real-Time Signal (sigtimedwait) based implementation of Proactor.
• ACE_POSIX_SIG_Asynch_Transmit_File · This class implements ACE_Asynch_Transmit_File for Real-Time Signal (sigtimedwait) based implementation of Proactor.
• ACE_POSIX_SIG_Asynch_Write_File · This class is a factory for starting off asynchronous reads on a file. This class implements ACE_Asynch_Operation for Real-Time Signal (sigtimedwait) based implementation of Proactor.
• ACE_POSIX_SIG_Asynch_Write_Stream · This class implements ACE_Asynch_Write_Stream for Real-Time Signal (sigtimedwait) based implementation of Proactor.
• ACE_POSIX_SIG_Proactor · This Proactor implementation does compeltion querying using POSIX Real Time signals. sigtimedwait/sigwaitinfo call is used to get the notify/get the completions. The real-time signals that are going to be used with this Proactor should be given apriori in the constructor, so that those signals can be masked from asynchornous delivery.
• ACE_Predefined_Naming_Contexts · A factory for predefined registries, which exist by default on Win32 platforms
• ACE_Priority_Reactor · Implements priority based dispatching.
• ACE_Proactor · A manager for asynchronous event demultiplexing.
• ACE_Proactor_Handle_Timeout_Upcall · Functor for ACE_Timer_Queue.
• ACE_Proactor_Impl · A manager for asynchronous event demultiplexing. This class is the base class for all the concrete implementation classes.
• ACE_Process · Process
• ACE_Process_Barrier · Implements "barrier synchronization" using ACE_Process_Mutexes!
• ACE_Process_Condition · ACE_Condition variable wrapper that works across processes.
• ACE_Process_Descriptor · Information describing each process that's controlled by an ACE_Process_Manager.
• ACE_Process_Manager · Manages a group of processes.
• ACE_Process_Mutex · A wrapper for mutexes that can be used across processes on the same host machine, as well as within a process, of course.
• ACE_Process_Options · Process Options
• ACE_Process_Semaphore · Wrapper for Dijkstra style general semaphores that work across processes.
• ACE_Process_Strategy · Defines the interface for specifying a concurrency strategy for a SVC_HANDLER based on multiprocessing.
• ACE_Profile_Timer · This class provides both a timing mechanism and a mechanism for reporting the resource usage of a process.
• ACE_Protocol_Info
• ACE_PSOS_Time_t
• ACE_QoS · Wrapper class that holds the sender and receiver flow spec information, which is used by IntServ (RSVP) and DiffServ.
• ACE_QtReactor · An object-oriented event demultiplexor and event handler dispatcher that uses the Qt Library. This class declaration also uses the extnsion facilities provided by the Qt. So, readers of the class declaration should not be upset with the appearence of the Keywords like Q_OBJECT, private slots etc. They are specific to Qt which uses these as a call back methods implementation mechanism.
• ACE_Quoted_String
• ACE_RB_Tree · Implements a Red-Black Tree ADT, according to T. H. Corman, C. E. Leiserson, and R. L. Rivest, "Introduction to Algorithms" 1990, MIT, chapter 14.
• ACE_RB_Tree_Base
• ACE_RB_Tree_Iterator · Implements an iterator for a Red-Black Tree ADT.
• ACE_RB_Tree_Iterator_Base · Implements a common base class for iterators for a Red-Black Tree ADT.
• ACE_RB_Tree_Node · Implements a node in a Red-Black Tree ADT.
• ACE_RB_Tree_Node_Base
• ACE_RB_Tree_Reverse_Iterator · Implements a reverse iterator for a Red-Black Tree ADT.
• ACE_Reactive_Strategy · Defines the interface for specifying a Reactive concurrency strategy for a SVC_HANDLER.
• ACE_Reactor · The resposiblility of this class is to forward 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_Read_Buffer · Efficiently reads an artibrarily large buffer from an input stream up to and including a termination character. Also performs search/replace on single occurrences a character in the buffer using the principles of Integrated Layer Processing.
• ACE_Read_Guard · This class is similar to class ACE_Guard, though it acquires/releases a read lock automatically (naturally, the ACE_LOCK it is instantiated with must support the appropriate API).
• ACE_Recursive_Thread_Mutex · Implement a C++ wrapper that allows nested acquisition and release of a mutex that occurs in the same thread.
• ACE_recursive_thread_mutex_t · Implement a thin C++ wrapper that allows nested acquisition and release of a mutex that occurs in the same thread.
• ACE_Recyclable
• ACE_Recyclable_Handler_Caching_Utility · Defines a helper class for the Caching Strategies.
• ACE_Recyclable_Handler_Cleanup_Strategy · Defines a strategy to be followed for cleaning up entries which are svc_handlers from a container.
• ACE_Recycling_Strategy · Defines the interface (and default implementation) for specifying a recycling strategy for a SVC_HANDLER.
• ACE_Refcountable
• ACE_Refcounted_Hash_Recyclable
• ACE_Refcounted_Recyclable_Handler_Caching_Utility · Defines a helper class for the Caching Strategies.
• ACE_Refcounted_Recyclable_Handler_Cleanup_Strategy · Defines a strategy to be followed for cleaning up entries which are svc_handlers from a container.
• ACE_Reference_Pair
• ACE_Registry · A Name Server implementation
• ACE_Registry_Name_Space · Interface to a Name Server Database which is maintained by the Win32 Registry. Allows to add, change, remove and resolve NameBindings.
• 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_Remove_Node · Remove a Service Node.
• ACE_Resume_Node · Resume a Service Node.
• ACE_Reverse_Iterator · Defines the reverse iterator interface.
• ACE_Reverse_Iterator_Impl · Defines a abstract reverse iterator.
• ACE_Reverse_Lock · A reverse (or anti) lock.
• ACE_RW_Mutex · Wrapper for readers/writer locks.
• ACE_RW_Process_Mutex · Wrapper for readers/writer locks that exist across processes.
• ACE_RW_Thread_Mutex · Wrapper for readers/writer locks that exist within a process.
• ACE_RW_Token · Class that acquires, renews, and releases a process-local synchronization token.
• ACE_RWLock_Invariants · RWLock Invariants
• ACE_rwlock_t
• ACE_Sbrk_Memory_Pool · Make a memory pool that is based on sbrk(2).
• ACE_Sbrk_Memory_Pool_Options · Helper class for Sbrk Memory Pool constructor options.
• ACE_Sched_Params · Container for scheduling-related parameters.
• ACE_Sched_Priority_Iterator · An iterator over the OS-defined scheduling priorities.
• ACE_Schedule_All_Reactive_Strategy · Defines the interface for specifying how to suspend and resume a single-threaded reactive service .
• ACE_Schedule_All_Threaded_Strategy · Defines the interface for specifying how to suspend and resume a multithreaded service .
• ACE_Scheduling_Strategy · Defines the interface for specifying how to suspend and resume a service .
• ACE_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.