[#BloombergLP-bdlcc]
= xref:BloombergLP.adoc[BloombergLP]::bdlcc
:relfileprefix: ../
:mrdocs:

Namespace for concurrent container components.

== Types

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bdlcc/BoundedQueue.adoc[`BoundedQueue`] 
| This class provides a thread‐safe bounded queue of values.
| xref:BloombergLP/bdlcc/BoundedQueue_Node-0a.adoc[`BoundedQueue_Node`] 
| This class implements the queue's node. A node stores an instance of the specified (template parameter) `TYPE`, and provides an accessor `isUnconstructed` that indicates whether the value of the node was correctly constructed. If `isUnconstructed` is `false`, then the value (`d_value`) refers to a valid object. If `isUnconstructed` is `true` then `d_value` does not refer to a valid object, it does not represent a value in this queue, and the destructor of `d_value` should not be called. The specified (template parameter) type `RECLAIMABLE` is used to provide a compile time optimization for the footprint of this template when the value of `isUnconstructed` is known at compile‐time. If `RECLAIMABLE` is `false` then it can be determined at compile time that the construction of `TYPE` will uncoditionally succeed (e.g., it `IsBitwiseCopyable`), and the `isUnconstructed` property does not require a data member to be accessed at run‐time.
| xref:BloombergLP/bdlcc/BoundedQueue_PopCompleteGuard.adoc[`BoundedQueue_PopCompleteGuard`] 
| This class implements a guard that invokes `TYPE::popComplete` on a `NODE` upon destruction.
| xref:BloombergLP/bdlcc/BoundedQueue_PushExceptionCompleteProctor.adoc[`BoundedQueue_PushExceptionCompleteProctor`] 
| This class implements a proctor that invokes `TYPE::pushExceptionComplete` upon destruction unless `release` has been called.
| xref:BloombergLP/bdlcc/Cache.adoc[`Cache`] 
| This class represents a simple in‐process key‐value store supporting a variety of eviction policies.
| xref:BloombergLP/bdlcc/CacheEvictionPolicy.adoc[`CacheEvictionPolicy`] 
| Namespace for enumerating cache eviction policies.
| xref:BloombergLP/bdlcc/Cache_QueueProctor.adoc[`Cache_QueueProctor`] 
| This class implements a proctor that, on destruction, restores the queue to its state at the time of the proctor's creation. We assume that the only change to the queue is that 0 or more items have been added to the end. If `release` has been called, the destructor takes no action.
| xref:BloombergLP/bdlcc/Cache_TestUtil.adoc[`Cache_TestUtil`] 
| This class implements a test utility that gives the test driver access to the lock / unlock method of the RW mutex. Its purpose is to allow testing that the locking actually happens as planned.
| xref:BloombergLP/bdlcc/Deque.adoc[`Deque`] 
| This class provides a fully thread‐safe implementation of an efficient, in‐place, indexable, double‐ended queue of (template parameter) `TYPE` values. Direct access to the underlying `bsl::deque<TYPE>` object is provided through the nested `Proctor` and `ConstProctor` classes. While this class is not value‐semantic, the underlying `bsl::deque<TYPE>` class is.
| xref:BloombergLP/bdlcc/FixedQueue.adoc[`FixedQueue`] 
| This class provides a thread‐aware, lock‐free, fixed‐size queue of values.
| xref:BloombergLP/bdlcc/FixedQueueIndexManager.adoc[`FixedQueueIndexManager`] 
| This class implements a circular buffer of atomic state variables. These are intended to synchronize access to another (non‐atomic) indexed data structure so that the other data structure can be used as a thread‐enabled fixed‐size queue.
| xref:BloombergLP/bdlcc/FixedQueue_PopGuard.adoc[`FixedQueue_PopGuard`] 
| This class provides a guard that, upon its destruction, will remove (pop) the indicated element from the `FixedQueue` object supplied at construction. Note that this guard is used to provide exception safety when popping an element from a `FixedQueue` object.
| xref:BloombergLP/bdlcc/FixedQueue_PushProctor.adoc[`FixedQueue_PushProctor`] 
| This class provides a proctor that, unless the `release` method has been previously invoked, will remove and destroy all the elements from a `FixedQueue` object supplied at construction (putting that ring‐buffer into a valid empty state) upon the proctor's destruction. Note that this guard is used to provide exception safety when pushing an element into a `FixedQueue`.
| xref:BloombergLP/bdlcc/MultipriorityQueue.adoc[`MultipriorityQueue`] 
| This class implements a thread‐enabled multipriority queue whose priorities are restricted to a (small) set of contiguous `N` integer values, `[ 0 .. N ‐ 1 ]`, with 0 being the most urgent.
| xref:BloombergLP/bdlcc/MultipriorityQueue_Node.adoc[`MultipriorityQueue_Node`] 
| This class handles storage of one item of parameterized `TYPE` as a node in a linked list of items stored in a multipriority queue for a given priority. This class is not to be used from outside this component.
| xref:BloombergLP/bdlcc/ObjectCatalog.adoc[`ObjectCatalog`] 
| This class defines an efficient indexed object catalog of `TYPE` objects. This container is _exception_ _neutral_ with no guarantee of rollback: if an exception is thrown during the invocation of a method on a pre‐existing instance, the object is left in a valid but undefined state. In no event is memory leaked or a mutex left in a locked state.
| xref:BloombergLP/bdlcc/ObjectCatalogIter.adoc[`ObjectCatalogIter`] 
| Provide thread safe iteration through all the objects of an object catalog of parameterized `TYPE`. The order of the iteration is implementation defined. An iterator is _valid_ if it is associated with an object in the catalog, otherwise it is _invalid_. Thread‐safe iteration is provided by (read)locking the object catalog during the iterator's construction and unlocking it at the iterator's destruction. This guarantees that during the life time of an iterator, the object catalog can't be modified (nevertheless, multiple threads can concurrently read the object catalog).
| xref:BloombergLP/bdlcc/ObjectCatalog_AutoCleanup.adoc[`ObjectCatalog_AutoCleanup`] 
| This class provides a specialized proctor object that, upon destruction and unless the `release` method is called (1) removes a managed node from the `ObjectCatalog`, and (2) deallocates all associated memory as necessary.
| xref:BloombergLP/bdlcc/ObjectPool.adoc[`ObjectPool`] 
| This class provides a thread‐safe pool of reusable objects. It also implements the `bdlma::Factory` protocol: "creating" objects gets them from the pool and "deleting" objects returns them to the pool.
| xref:BloombergLP/bdlcc/ObjectPoolFunctors.adoc[`ObjectPoolFunctors`] 
| This struct provides several functors that are suitable `RESETTER` parameter types for `ObjectPool`. It also provides a `typedef` that specifies the default `CREATOR` parameter type for `ObjectPool`.
| xref:BloombergLP/bdlcc/ObjectPool_CreatorConverter-07.adoc[`ObjectPool_CreatorConverter`] 
| The purpose of this private class is to avoid ambiguity between different template instantiations of `bsl::function` accepted by the constructors of `ObjectPool`. It should not be used directly.
| xref:BloombergLP/bdlcc/ObjectPool_DefaultProxy.adoc[`ObjectPool_DefaultProxy`] 
| This private class template provides a default constructor that creates a proxied `bsl::function` object that invokes the default constructor of the parameterized `TYPE` with placement `new`.
| xref:BloombergLP/bdlcc/ObjectPool_GeneralProxy.adoc[`ObjectPool_GeneralProxy`] 
| This private class template provides a default constructor which simply invokes the default constructor of the parameterized `TYPE`.
| xref:BloombergLP/bdlcc/ObjectPool_ProxyPicker-05.adoc[`ObjectPool_ProxyPicker`] 
| For a `CREATOR` type other than the specialization below, provide a metafunction that returns `ObjectPool_GeneralProxy<CREATOR>` as the creator proxy for all types.
| xref:BloombergLP/bdlcc/Queue.adoc[`Queue`] 
| This class provides a thread‐enabled implementation of an efficient, in‐place, indexable, double‐ended queue of parameterized `TYPE` values. Very efficient access to the underlying `bdlc::Queue` object is provided, as well as to a `bslmt::Mutex` and a `bslmt::Condition` variable, to facilitate thread‐safe use of the `bdlc::Queue`. Note that `Queue` is not a value‐semantic type, but the underlying `bdlc::Queue` is. In this regard, `Queue` is a thread‐enabled handle for a `bdlc::Queue`.
| xref:BloombergLP/bdlcc/SharedObjectPool.adoc[`SharedObjectPool`] 
| This class provides a thread‐safe pool of `bsl::shared_ptr` objects.
| xref:BloombergLP/bdlcc/SharedObjectPool_Rep.adoc[`SharedObjectPool_Rep`] 
| Shared pointer representation object used by `SharedObjectPool`.
| xref:BloombergLP/bdlcc/SingleConsumerQueue.adoc[`SingleConsumerQueue`] 
| This class provides a thread‐safe unbounded queue of values that assumes a single consumer thread.
| xref:BloombergLP/bdlcc/SingleConsumerQueueImpl.adoc[`SingleConsumerQueueImpl`] 
| This class provides a thread‐safe unbounded queue of values that assumes a single consumer thread.
| xref:BloombergLP/bdlcc/SingleConsumerQueueImpl_AllocateLockGuard.adoc[`SingleConsumerQueueImpl_AllocateLockGuard`] 
| This class implements a guard that automatically invokes `releaseAllocateLock` on the managed queue upon destruction.
| xref:BloombergLP/bdlcc/SingleConsumerQueueImpl_MarkReclaimProctor.adoc[`SingleConsumerQueueImpl_MarkReclaimProctor`] 
| This class implements a proctor that, unless its `release` method has previously been invoked, automatically invokes `markReclaim` on a `NODE` upon destruction.
| xref:BloombergLP/bdlcc/SingleConsumerQueueImpl_PopCompleteGuard.adoc[`SingleConsumerQueueImpl_PopCompleteGuard`] 
| This class implements a guard that automatically invokes `popComplete` on the managed queue upon destruction.
| xref:BloombergLP/bdlcc/SingleProducerQueue.adoc[`SingleProducerQueue`] 
| This class provides a thread‐safe unbounded queue of values that assumes a single producer thread.
| xref:BloombergLP/bdlcc/SingleProducerQueueImpl.adoc[`SingleProducerQueueImpl`] 
| This class provides a thread‐safe unbounded queue of values that assumes a single producer thread.
| xref:BloombergLP/bdlcc/SingleProducerQueueImpl_PopCompleteGuard.adoc[`SingleProducerQueueImpl_PopCompleteGuard`] 
| This class implements a guard automatically invokes `popComplete` on a `NODE` upon destruction.
| xref:BloombergLP/bdlcc/SingleProducerQueueImpl_ReleaseAllRawProctor.adoc[`SingleProducerQueueImpl_ReleaseAllRawProctor`] 
| This class implements a proctor that, unless its `release` method has previously been invoked, automatically invokes `releaseAllRaw` on a `TYPE` upon destruction.
| xref:BloombergLP/bdlcc/SingleProducerSingleConsumerBoundedQueue.adoc[`SingleProducerSingleConsumerBoundedQueue`] 
| This class provides a thread‐safe bounded queue of values that supports a single producer and a single consumer.
| xref:BloombergLP/bdlcc/SingleProducerSingleConsumerBoundedQueue_PopCompleteGuard.adoc[`SingleProducerSingleConsumerBoundedQueue_PopCompleteGuard`] 
| This class implements a guard that invokes `TYPE::popComplete` on a `NODE` upon destruction.
| xref:BloombergLP/bdlcc/SkipList-0a.adoc[`SkipList`] 
| This class provides a generic thread‐safe Skip List (an ordered associative container). It supports an almost complete set of _value_ _semantic_ operations, including copy construction, assignment, equality comparison, and `ostream` printing (but not BDEX serialization).
| xref:BloombergLP/bdlcc/SkipListPair.adoc[`SkipListPair`] 
| Pointers to objects of this class are used in the "raw" API of `SkipList`; however, objects of the class are never constructed as the class serves only to provide type‐safe pointers.
| xref:BloombergLP/bdlcc/SkipListPairHandle.adoc[`SkipListPairHandle`] 
| Objects of this class refer to an association (pair) in a `SkipList`. A `bdlcc::SkipListPairHandle` is implicitly convertible to a `const Pair*` and thus may be used anywhere in the `SkipList` API that a `const Pair*` is expected.
| xref:BloombergLP/bdlcc/SkipList_DoubleLockGuard.adoc[`SkipList_DoubleLockGuard`] 
| RAII guard that locks two mutexes in address order to avoid deadlock.
| xref:BloombergLP/bdlcc/SkipList_Node.adoc[`SkipList_Node`] 
| This component‐private structure is a node in the SkipList.
| xref:BloombergLP/bdlcc/SkipList_NodeCreationHelper.adoc[`SkipList_NodeCreationHelper`] 
| This component‐private structure is a scoped guard that initializes new nodes and releases them in case of exception.
| xref:BloombergLP/bdlcc/SkipList_PoolManager.adoc[`SkipList_PoolManager`] 
| Component‐private manager for the lock‐free pool of skip‐list nodes.
| xref:BloombergLP/bdlcc/SkipList_PoolUtil.adoc[`SkipList_PoolUtil`] 
| This component‐private utility handles the lock‐free pool of list nodes.
| xref:BloombergLP/bdlcc/SkipList_RandomLevelGenerator.adoc[`SkipList_RandomLevelGenerator`] 
| This component‐private class handles randomizing the levelization of list nodes.
| xref:BloombergLP/bdlcc/StripedUnorderedContainerImpl.adoc[`StripedUnorderedContainerImpl`] 
| This class implements the logic for a striped hash multimap with logic that supports a (unique) map as a special case.
| xref:BloombergLP/bdlcc/StripedUnorderedContainerImplMaxLoadFactorFlag.adoc[`StripedUnorderedContainerImplMaxLoadFactorFlag`] 
| This struct is a constructor flag used to select the contructor that takes a `maxLoadFactor` value.
| xref:BloombergLP/bdlcc/StripedUnorderedContainerImpl_ArrayOfLocksWriteGuard.adoc[`StripedUnorderedContainerImpl_ArrayOfLocksWriteGuard`] 
| This class holds locks on an array of locks, established in sequential order, and unlocks them upon destruction in the RAII pattern.
| xref:BloombergLP/bdlcc/StripedUnorderedContainerImpl_Bucket.adoc[`StripedUnorderedContainerImpl_Bucket`] 
| This class represents a bucket of the hash map. This class template represents the head of in the singly‐linked list of `(KEY, VALUE)` elements in a hash map.
| xref:BloombergLP/bdlcc/StripedUnorderedContainerImpl_Constants.adoc[`StripedUnorderedContainerImpl_Constants`] 
| This class defines constant values used to represent the state of a `StripedUnorderedContainerImpl` object.
| xref:BloombergLP/bdlcc/StripedUnorderedContainerImpl_LockElement.adoc[`StripedUnorderedContainerImpl_LockElement`] 
| A mutex + support info; padded to cacheline size, one per stripe
| xref:BloombergLP/bdlcc/StripedUnorderedContainerImpl_LockElementReadGuard.adoc[`StripedUnorderedContainerImpl_LockElementReadGuard`] 
| A guard pattern on StripedUnorderedContainerImpl_LockElement, to release on exception, for a lock element locked as read.
| xref:BloombergLP/bdlcc/StripedUnorderedContainerImpl_LockElementWriteGuard.adoc[`StripedUnorderedContainerImpl_LockElementWriteGuard`] 
| A guard pattern on StripedUnorderedContainerImpl_LockElement, to release on exception, for a lock element locked as write.
| xref:BloombergLP/bdlcc/StripedUnorderedContainerImpl_Node.adoc[`StripedUnorderedContainerImpl_Node`] 
| This class template represents a node in the singly‐linked list of `(KEY, VALUE)` elements for each bucket of a hash map.
| xref:BloombergLP/bdlcc/StripedUnorderedContainerImpl_RehashBitSetGuard.adoc[`StripedUnorderedContainerImpl_RehashBitSetGuard`] 
| This class defines a proctor type that attempts to set the rehash bit of a state object, and if successful, clears that bit upon destruction.
| xref:BloombergLP/bdlcc/StripedUnorderedContainerImpl_SortItem.adoc[`StripedUnorderedContainerImpl_SortItem`] 
| A vector element needed for efficient sorting for the `insertBulk` and `eraseBulk` methods.
| xref:BloombergLP/bdlcc/StripedUnorderedContainerImpl_TestUtil.adoc[`StripedUnorderedContainerImpl_TestUtil`] 
| This class implements a test utility that gives the test driver access to the lock / unlock method of the Read/Write mutex. Its purpose is to allow testing that the locking actually happens as planned.
| xref:BloombergLP/bdlcc/StripedUnorderedMap.adoc[`StripedUnorderedMap`] 
| This class template defines a fully thread‐safe container that provides a mapping from keys (of template parameter type `KEY`) to their associated mapped values (of template parameter type `VALUE`).
| xref:BloombergLP/bdlcc/StripedUnorderedMultiMap.adoc[`StripedUnorderedMultiMap`] 
| This class template defines a fully thread‐safe container that provides a mapping from keys (of template parameter type `KEY`) to their associated mapped values (of template parameter type `VALUE`).
| xref:BloombergLP/bdlcc/TimeQueue-09c.adoc[`TimeQueue`] 
| This parameterized class provides a public interface which is similar in structure and intent to `Queue<DATA>`, with the exception that each item stored in the `TimeQueue` has an associated time value. Items are retrieved or exchanged by proxy of a `TimeQueueItem<DATA>`, and are referred to by an opaque data type `TimeQueue::Handle` which serves to identify an individual element on the Time Queue. Idiomatic usage of `TimeQueue` includes the member function `popLE`, which finds all items on the queue whose `bsls::TimeInterval` are less than a specified value and transfers those items to a provided vector of items, and the member function `update`, which can update the time value for a specific `TimeQueueItem` without removing it from the queue.
| xref:BloombergLP/bdlcc/TimeQueueItem.adoc[`TimeQueueItem`] 
| This parameterized structure holds a time, data and associated handle. This structure is used in the interface of `TimeQueue<DATA>` to provide thread‐safe access to individual elements on the queue. Note that `DATA` must be default‐constructible.
|===


== Functions

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bdlcc/operator_lshift.adoc[`operator<<`] 
| Write the specified `list` to the specified output `stream` and return a reference to the modifiable `stream`.
| xref:BloombergLP/bdlcc/operator_eq-0c.adoc[`operator==`] 
| Equality operators
| xref:BloombergLP/bdlcc/operator_not_eq-02.adoc[`operator!=`] 
| Inequality operators
| xref:BloombergLP/bdlcc/operator_lt.adoc[`operator<`] 
| Return `true` if the specified `lhs` is smaller than the specified `rhs` in the order of stripe, and data.
|===



[.small]#Created with https://www.mrdocs.com[MrDocs]#