QuantumLibrary
Class Hierarchy
This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 1234]
 CBloomberg::quantum::Allocator< AllocType >
 Callocator
 CBloomberg::quantum::StlAllocator< T >
 CBloomberg::quantum::AllocatorTraitsAllows application-wide settings for the various allocators used by Quantum
 Cbasic_fixedsize_stack
 CBloomberg::quantum::BoostAllocator< Traits >
 CBloomberg::quantum::Buffer< T, ALLOCATOR >Container which allows buffered access to a series of values. Values are pushed-in (written) by a producer(s) and pulled-out (read) by a consumer(s)
 CBloomberg::quantum::Buffer< T >
 CBloomberg::quantum::Capture< FUNC, ARGS >Class allowing lambda parameter captures
 CclassConfiguration parameters for the Quantum library
 CBloomberg::quantum::ConditionVariableThis class represents a coroutine-compatible implementation of the std::condition_variable. Most methods of the latter have been recreated with the same behavior. This object will yield instead of blocking if called from a coroutine
 CBloomberg::quantum::Configuration
 CBloomberg::quantum::ContiguousPoolManager< T >Provides fast (quasi zero-time) in-place allocation for STL containers. Objects are allocated from a contiguous buffer (aka object pool). When the buffer is exhausted, allocation is delegated to the heap. The default buffer size is 1000
 CBloomberg::quantum::HeapAllocator< T >Provides a heap-based object pool to the underlying ContiguousPoolManager. The default buffer size is 1000
 CBloomberg::quantum::StackAllocator< T, SIZE >Provides a stack-based object pool to the underlying ContiguousPoolManager. The default buffer size is 1000
 CBloomberg::quantum::CoroContextTag
 CBloomberg::quantum::CoroutinePoolAllocator< STACK_TRAITS >Provides fast (quasi zero-time) in-place allocation for coroutines. Coroutine stacks are pre-allocated from separate (i.e. non-contiguous) heap blocks and maintained in a reusable list
 CBloomberg::quantum::CoroutinePoolAllocatorProxy< STACK_TRAITS >
 CBloomberg::quantum::Traits::DerivedFrom< D, THIS, B >
 CBloomberg::quantum::Traits::DerivedFrom< PROMISE< T >, ICoroPromise< PROMISE, T >, IPromiseBase >
 CBloomberg::quantum::ICoroPromise< PROMISE, T >Exposes methods to access and manipulate a coroutine-compatible promise
 CBloomberg::quantum::Traits::DerivedFrom< Promise< T >, ICoroPromise< Promise, T >, IPromiseBase >
 CBloomberg::quantum::ICoroPromise< Promise, T >
 CBloomberg::quantum::Traits::DerivedFrom< Promise< T >, IThreadPromise< Promise, T >, IPromiseBase >
 CBloomberg::quantum::IThreadPromise< Promise, T >
 CBloomberg::quantum::Traits::DerivedFrom< PROMISE< T >, IThreadPromise< PROMISE, T >, IPromiseBase >
 CBloomberg::quantum::IThreadPromise< PROMISE, T >Exposes methods to access and manipulate a non-coroutine promise (i.e. used in a thread)
 Cenable_shared_from_this
 CBloomberg::quantum::Context< RET >Concrete class representing a coroutine or a thread context
 CBloomberg::quantum::TaskRunnable object representing a coroutine
 Cexception
 CBloomberg::quantum::FutureExceptionException thrown by a Future or Promise object during various errors
 Cfalse_type
 CBloomberg::quantum::Traits::IsBuffer< T >
 CBloomberg::quantum::Function< RET, ARGS >Similar implementation to std::function except that it allows capture of non-copyable types
 CBloomberg::quantum::Function< int()>
 CBloomberg::quantum::Function< RET(ARGS...)>
 CBloomberg::quantum::FunctionsContains typedefs for various functions
 CBloomberg::quantum::FutureJoiner< T >Utility class that joins N futures into a single one
 CMutex::GuardRAII-style mechanism for mutex ownership. Acquires a mutex on construction and releases it inside the destructor
 CBloomberg::quantum::ITerminate::Guard
 CITerminate::GuardRAII-style mechanism for ensuring an object is terminated at the end of a scope. Acquires an ITerminate interface on construction and terminates the object in the destructor
 CSpinLock::GuardRAII-style mechanism for SpinLock ownership. Acquires a SpinLock on construction and releases it inside the destructor
 CBloomberg::quantum::Mutex::Guard
 CBloomberg::quantum::SpinLock::Guard
 CBloomberg::quantum::IContextBaseThis interface exposes shared functionality between IThreadContext and ICoroContext
 CBloomberg::quantum::ICoroContextBaseExposes methods to manipulate the coroutine context, especially future wait methods
 CBloomberg::quantum::IThreadContextBaseExposes methods to manipulate the thread context, especially future wait methods
 CBloomberg::quantum::ICoroFutureBaseExposes methods to access a coroutine-compatible future
 CBloomberg::quantum::ICoroFuture< T >Exposes methods to access a coroutine-compatible future
 CBloomberg::quantum::ICoroSyncProvides an interface to facilitate 'implicit' coroutine yielding within other primitives such as mutexes and condition variables or to allow 'explicit' cooperative yielding by the user
 CBloomberg::quantum::ICoroContextBaseExposes methods to manipulate the coroutine context, especially future wait methods
 CBloomberg::quantum::IQueueStatisticsInterface to access and manipulate a QueueStatistics object
 CBloomberg::quantum::QueueStatisticsProvides various counters related to queues and task execution
 CBloomberg::quantum::ITerminateRepresents an object which can be terminated. This interface allows certain objects to be explicitly disposed of before their destructors are called
 CBloomberg::quantum::DispatcherParallel execution engine used to run coroutines or IO tasks asynchronously. This class is the main entry point into the library
 CBloomberg::quantum::DispatcherCoreClass implementing the dispatching logic unto worker threads. Used for both coroutines and IO tasks
 CBloomberg::quantum::IPromiseBaseExposes methods to manipulate and access a promise
 CBloomberg::quantum::IQueueInterface to a task queue. For internal use only
 CBloomberg::quantum::ITaskInterface to a task. For internal use only
 CBloomberg::quantum::ITaskAccessorInterface to a task accessor. For internal use only
 CBloomberg::quantum::IThreadFutureBase
 CBloomberg::quantum::IThreadFuture< T >
 CBloomberg::quantum::MutexCoroutine-compatible implementation of a mutex
 CBloomberg::quantum::StackAllocator< T, SIZE >::rebind< U >
 CBloomberg::quantum::HeapAllocator< T >::rebind< U >
 CBloomberg::quantum::ReturnOf< FUNC, ARGS >
 CSpinLock::ReverseGuardOpposite form of RAII-style mechanism for SpinLock ownership. Releases a SpinLock on construction and acquires it inside the destructor
 CBloomberg::quantum::SpinLock::ReverseGuard
 CMutex::ReverseGuardOpposite form of RAII-style mechanism for mutex ownership. Releases a mutex on construction and acquires it inside the destructor
 CBloomberg::quantum::Mutex::ReverseGuard
 CBloomberg::quantum::SequenceKeyData
 CBloomberg::quantum::SequenceKeyStatisticsImplementation of a statistics collection for a SequenceKey in Sequencer
 CBloomberg::quantum::SequenceKeyStatisticsWriter
 CBloomberg::quantum::Sequencer< SequenceKey, Hash, KeyEqual, Allocator >Implementation of a key-based task sequencing with quantum
 CBloomberg::quantum::SequencerConfiguration< SequenceKey, Hash, KeyEqual, Allocator >Implementation of a configuration class for Sequencer
 CBloomberg::quantum::SharedState< T >Shared state used between a Promise and a Future to exchange values
 CBloomberg::quantum::SharedState< Buffer< T > >
 CBloomberg::quantum::SpinLockCoroutine-compatible spinlock. Used internally for mutexes since threads running coroutines cannot block
 CBloomberg::quantum::StackTraitsAllows application-wide overrides for the coroutine stack traits which are used internally by boost::coroutines2
 CBloomberg::quantum::StackTraitsProxy
 CBloomberg::quantum::ThreadContextTag
 CBloomberg::quantum::ThreadTraitsAllows application-wide settings for the various thread settings used by Quantum
 CBloomberg::quantum::TraitsContains definitions for various traits used by this library. For internal use only
 Ctrue_type
 CBloomberg::quantum::Traits::IsBuffer< Buffer< T > >
 CBloomberg::quantum::UtilUtility to bind a user callable function unto a coroutine or an IO task
 CBloomberg::quantum::YieldingThreadDuration< DURATION >This class provides the same functionality as a coroutine yield when called from a thread context