[#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.
| 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`] 
| Proctor that restores a cache queue on destruction.
| xref:BloombergLP/bdlcc/Cache_TestUtil.adoc[`Cache_TestUtil`] 
| Test utility that exposes the cache RW‐mutex lock methods.
| xref:BloombergLP/bdlcc/Deque.adoc[`Deque`] 
| Thread‐safe, indexable, double‐ended queue of `TYPE` values.
| 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`] 
| Thread‐enabled index manager for a fixed‐size circular buffer.
| xref:BloombergLP/bdlcc/FixedQueue_PopGuard.adoc[`FixedQueue_PopGuard`] 
| This class provides a destruction guard that pops an element from a `FixedQueue`.
| xref:BloombergLP/bdlcc/FixedQueue_PushProctor.adoc[`FixedQueue_PushProctor`] 
| This class provides a proctor that clears a `FixedQueue` on destruction unless released.
| xref:BloombergLP/bdlcc/MultipriorityQueue.adoc[`MultipriorityQueue`] 
| This class implements a thread‐enabled multipriority queue of `TYPE`.
| xref:BloombergLP/bdlcc/MultipriorityQueue_Node.adoc[`MultipriorityQueue_Node`] 
| This class stores one item of `TYPE` as a node in a linked list.
| xref:BloombergLP/bdlcc/ObjectCatalog.adoc[`ObjectCatalog`] 
| Thread‐safe indexed catalog of `TYPE` objects.
| xref:BloombergLP/bdlcc/ObjectCatalogIter.adoc[`ObjectCatalogIter`] 
| Thread‐safe iterator over an `ObjectCatalog` of `TYPE` objects.
| xref:BloombergLP/bdlcc/ObjectCatalog_AutoCleanup.adoc[`ObjectCatalog_AutoCleanup`] 
| Proctor that cleans up a managed `ObjectCatalog` node on destruction.
| xref:BloombergLP/bdlcc/ObjectPool.adoc[`ObjectPool`] 
| Thread‐safe pool of reusable objects that implements `bdlma::Factory`.
| xref:BloombergLP/bdlcc/ObjectPoolFunctors.adoc[`ObjectPoolFunctors`] 
| Namespace for resetter functors and the default creator type for `ObjectPool`.
| xref:BloombergLP/bdlcc/ObjectPool_CreatorConverter-07.adoc[`ObjectPool_CreatorConverter`] 
| Converter that adapts creator types for `ObjectPool` constructors.
| xref:BloombergLP/bdlcc/ObjectPool_DefaultProxy.adoc[`ObjectPool_DefaultProxy`] 
| Proxy for a creator that default‐constructs objects of `TYPE`.
| 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, double‐ended queue of `TYPE` values.
| 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`] 
| Thread‐safe ordered associative skip list of key/data pairs.
| xref:BloombergLP/bdlcc/SkipListPair.adoc[`SkipListPair`] 
| Type‐safe pointer to a key/data pair in a `SkipList`.
| xref:BloombergLP/bdlcc/SkipListPairHandle.adoc[`SkipListPairHandle`] 
| Managed handle to a key/data pair in a `SkipList`.
| 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`] 
| Test utility exposing stripe lock/unlock for the test driver.
| xref:BloombergLP/bdlcc/StripedUnorderedMap.adoc[`StripedUnorderedMap`] 
| Fully thread‐safe hash map from `KEY` to `VALUE`, partitioned into stripes.
| xref:BloombergLP/bdlcc/StripedUnorderedMultiMap.adoc[`StripedUnorderedMultiMap`] 
| Fully thread‐safe striped hash multimap from `KEY` to `VALUE`.
| xref:BloombergLP/bdlcc/TimeQueue-09c.adoc[`TimeQueue`] 
| Priority queue of `DATA` items ordered by associated time values.
| xref:BloombergLP/bdlcc/TimeQueueItem.adoc[`TimeQueueItem`] 
| Container for a time, data, handle, and key associated with a queue item.
|===


== Functions

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bdlcc/operator_lshift.adoc[`operator<<`] 
| Write the value of `list` to the specified output `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 `lhs` is ordered before `rhs` by stripe, then data.
|===



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