3 Library functions

ac

• 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.
• ACE_Select_Reactor_T An object oriented event demultiplexor and event handler dispatcher.
• ACE_Select_Reactor_Token_T Used as a synchronization mechanism to coordinate concurrent access to a Select_Reactor object.
• ACE_sema_t This is used to implement semaphores for platforms that support POSIX pthreads, but do *not* support POSIX semaphores, i.e., it's a different type than the POSIX sem_t.
• ACE_Semaphore Wrapper for Dijkstra style general semaphores.
• ACE_Service_Config Supplies common server operations for dynamic and static configuration of services.
• ACE_Service_Handler This base class defines the interface for the ACE_Asynch_Acceptor to call into when new connection are accepted.
• ACE_Service_Manager Provide a standard ACE service for managing all the services configured in an ACE_Service_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_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.
• 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_Set Provide a C++ wrapper for the C sigset_t interface.
• ACE_Singleton A Singleton Adapter uses the Adapter pattern to turn ordinary classes into Singletons optimized with the Double-Checked Locking optimization pattern.
• ACE_Singleton_Strategy Defines the interface for specifying a creation strategy for a SVC_HANDLER that always returns the same SVC_HANDLER (i.e., it's a Singleton).
• ACE_SOCK An abstract class that forms the basis for more specific classes, such as 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 creates new ACE_Streams actively.
• ACE_SOCK_Dgram Defines the member functions for the ACE_SOCK datagram abstraction.
• ACE_SOCK_Dgram_Bcast Defines the member functions for the ACE_SOCK datagram abstraction.
• ACE_SOCK_Dgram_Mcast Defines the member functions for the ACE socket wrapper for UDP/IP multicast.
• ACE_SOCK_Dgram_SC "Dgram_SC" is short for "Datagram Self-Contained."
• ACE_SOCK_IO Defines the methods for the ACE socket wrapper I/O routines (e.g., send/recv).
• ACE_SOCK_Stream Defines the methods in the ACE_SOCK_Stream abstraction.
• ACE_SPIPE Defines the member functions for the base class of the ACE_SPIPE abstraction.
• ACE_SPIPE_Acceptor Defines the format and interface for the listener side of the ACE_SPIPE_Stream.
• ACE_SPIPE_Addr Defines the SVR4 STREAM pipe address family address format.
• ACE_SPIPE_Connector Defines an active connection factory for the STREAM pipe wrappers.
• ACE_SPIPE_Stream Define an ACE_SPIPE_Stream.
• ACE_SString A very Simple String 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_ST_CORBA_Handler Handle single-threaded Orbix requests in conjunction with the ACE_Reactor.
• ACE_Static_Allocator Defines a class that provided a highly optimized memory management scheme for allocating memory statically.
• ACE_Static_Allocator_Base Defines a class that provided a highly optimized memory management scheme for allocating memory statically.
• ACE_Static_Function_Node Keeps track of the symbol name for a function that is not linked in from a DLL, but is statically linked with the application.
• ACE_Static_Node Handle a statically linked node.
• ACE_Static_Object_Lock Provide an interface to access a global lock.
• ACE_Static_Svc_Descriptor Holds the information necessary to describe a statically linked Svc.
• ACE_Stats Provides simple statistical analysis.
• ACE_Stats_Value Helper class for ACE_Stats.
• ACE_Str_Buf Simple wrapper for STREAM pipes strbuf.
• ACE_Strategy_Acceptor Abstract factory for creating a service handler (SVC_HANDLER), accepting into the SVC_HANDLER, and activating the SVC_HANDLER.
• ACE_Strategy_Connector Abstract factory for creating a service handler (SVC_HANDLER), connecting the SVC_HANDLER, and activating the SVC_HANDLER.
• ACE_Stream This class is the primary abstraction for the ASX framework. It is moduled after System V Stream.
• ACE_Stream_Head Standard module that acts as the head of a ustream.
• ACE_Stream_Iterator Iterate through an ACE_Stream.
• ACE_Stream_Node Handle a Stream.
• ACE_Stream_Tail Standard module that acts as the head of a ustream.
• ACE_Stream_Type Define the methods for handling the configuration of ACE_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
• ACE_Sub_Barrier
• ACE_Suspend_Node Suspend a Service Node.
• ACE_SV_Message Defines the header file for the C++ wrapper for message queues. */
• ACE_SV_Message_Queue Defines the header file for the C++ wrapper for System V IPC message queues.
• ACE_SV_Semaphore_Complex This is a more complex semaphore wrapper that handles race conditions for initialization correctly...
• ACE_SV_Semaphore_Simple This is a simple semaphore package that assumes there are no race conditions for initialization (i.e., the order of process startup must be well defined).
• ACE_SV_Shared_Memory This is a wrapper for System V shared memory.
• ACE_Svc_Handler Defines the interface for a service that exchanges data with its connected peer.
• ACE_Svc_Tuple Holds the ACE_Svc_Handler and its argument and ACE_Timer_Handle until an asynchronous connection completes.
• ACE_Synch_Options Contains the values of options used to determine the synchronous and asynchronous behavior.
• ACE_System_Time Defines the timer services of the OS interface to access the system time either on the local host or on the central time server in the network.
• ACE_Task Primary interface for application message processing, as well as input and output message queueing.