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

Namespace for concurrent container components&period;

== Types

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bdlcc/BoundedQueue.adoc[`BoundedQueue`] 
| This class provides a thread&hyphen;safe bounded queue of values&period;
| xref:BloombergLP/bdlcc/BoundedQueue_Node-0a.adoc[`BoundedQueue&lowbar;Node`] 
| This class implements the queue&apos;s node&period;
| xref:BloombergLP/bdlcc/BoundedQueue_PopCompleteGuard.adoc[`BoundedQueue&lowbar;PopCompleteGuard`] 
| This class implements a guard that invokes `TYPE&colon;&colon;popComplete` on a `NODE` upon destruction&period;
| xref:BloombergLP/bdlcc/BoundedQueue_PushExceptionCompleteProctor.adoc[`BoundedQueue&lowbar;PushExceptionCompleteProctor`] 
| This class implements a proctor that invokes `TYPE&colon;&colon;pushExceptionComplete` upon destruction unless `release` has been called&period;
| xref:BloombergLP/bdlcc/Cache.adoc[`Cache`] 
| This class represents a simple in&hyphen;process key&hyphen;value store supporting a variety of eviction policies&period;
| xref:BloombergLP/bdlcc/CacheEvictionPolicy.adoc[`CacheEvictionPolicy`] 
| Namespace for enumerating cache eviction policies&period;
| xref:BloombergLP/bdlcc/Cache_QueueProctor.adoc[`Cache&lowbar;QueueProctor`] 
| Proctor that restores a cache queue on destruction&period;
| xref:BloombergLP/bdlcc/Cache_TestUtil.adoc[`Cache&lowbar;TestUtil`] 
| Test utility that exposes the cache RW&hyphen;mutex lock methods&period;
| xref:BloombergLP/bdlcc/Deque.adoc[`Deque`] 
| Thread&hyphen;safe, indexable, double&hyphen;ended queue of `TYPE` values&period;
| xref:BloombergLP/bdlcc/FixedQueue.adoc[`FixedQueue`] 
| This class provides a thread&hyphen;aware, lock&hyphen;free, fixed&hyphen;size queue of values&period;
| xref:BloombergLP/bdlcc/FixedQueueIndexManager.adoc[`FixedQueueIndexManager`] 
| Thread&hyphen;enabled index manager for a fixed&hyphen;size circular buffer&period;
| xref:BloombergLP/bdlcc/FixedQueue_PopGuard.adoc[`FixedQueue&lowbar;PopGuard`] 
| This class provides a destruction guard that pops an element from a `FixedQueue`&period;
| xref:BloombergLP/bdlcc/FixedQueue_PushProctor.adoc[`FixedQueue&lowbar;PushProctor`] 
| This class provides a proctor that clears a `FixedQueue` on destruction unless released&period;
| xref:BloombergLP/bdlcc/MultipriorityQueue.adoc[`MultipriorityQueue`] 
| This class implements a thread&hyphen;enabled multipriority queue of `TYPE`&period;
| xref:BloombergLP/bdlcc/MultipriorityQueue_Node.adoc[`MultipriorityQueue&lowbar;Node`] 
| This class stores one item of `TYPE` as a node in a linked list&period;
| xref:BloombergLP/bdlcc/ObjectCatalog.adoc[`ObjectCatalog`] 
| Thread&hyphen;safe indexed catalog of `TYPE` objects&period;
| xref:BloombergLP/bdlcc/ObjectCatalogIter.adoc[`ObjectCatalogIter`] 
| Thread&hyphen;safe iterator over an `ObjectCatalog` of `TYPE` objects&period;
| xref:BloombergLP/bdlcc/ObjectCatalog_AutoCleanup.adoc[`ObjectCatalog&lowbar;AutoCleanup`] 
| Proctor that cleans up a managed `ObjectCatalog` node on destruction&period;
| xref:BloombergLP/bdlcc/ObjectPool.adoc[`ObjectPool`] 
| Thread&hyphen;safe pool of reusable objects that implements `bdlma&colon;&colon;Factory`&period;
| xref:BloombergLP/bdlcc/ObjectPoolFunctors.adoc[`ObjectPoolFunctors`] 
| Namespace for resetter functors and the default creator type for `ObjectPool`&period;
| xref:BloombergLP/bdlcc/ObjectPool_CreatorConverter-07.adoc[`ObjectPool&lowbar;CreatorConverter`] 
| Converter that adapts creator types for `ObjectPool` constructors&period;
| xref:BloombergLP/bdlcc/ObjectPool_DefaultProxy.adoc[`ObjectPool&lowbar;DefaultProxy`] 
| Proxy for a creator that default&hyphen;constructs objects of `TYPE`&period;
| xref:BloombergLP/bdlcc/ObjectPool_GeneralProxy.adoc[`ObjectPool&lowbar;GeneralProxy`] 
| This private class template provides a default constructor which simply invokes the default constructor of the parameterized `TYPE`&period;
| xref:BloombergLP/bdlcc/ObjectPool_ProxyPicker-05.adoc[`ObjectPool&lowbar;ProxyPicker`] 
| For a `CREATOR` type other than the specialization below, provide a metafunction that returns `ObjectPool&lowbar;GeneralProxy&lt;CREATOR&gt;` as the creator proxy for all types&period;
| xref:BloombergLP/bdlcc/Queue.adoc[`Queue`] 
| This class provides a thread&hyphen;enabled, double&hyphen;ended queue of `TYPE` values&period;
| xref:BloombergLP/bdlcc/SharedObjectPool.adoc[`SharedObjectPool`] 
| This class provides a thread&hyphen;safe pool of `bsl&colon;&colon;shared&lowbar;ptr` objects&period;
| xref:BloombergLP/bdlcc/SharedObjectPool_Rep.adoc[`SharedObjectPool&lowbar;Rep`] 
| Shared pointer representation object used by `SharedObjectPool`&period;
| xref:BloombergLP/bdlcc/SingleConsumerQueue.adoc[`SingleConsumerQueue`] 
| This class provides a thread&hyphen;safe unbounded queue of values that assumes a single consumer thread&period;
| xref:BloombergLP/bdlcc/SingleConsumerQueueImpl.adoc[`SingleConsumerQueueImpl`] 
| This class provides a thread&hyphen;safe unbounded queue of values that assumes a single consumer thread&period;
| xref:BloombergLP/bdlcc/SingleConsumerQueueImpl_AllocateLockGuard.adoc[`SingleConsumerQueueImpl&lowbar;AllocateLockGuard`] 
| This class implements a guard that automatically invokes `releaseAllocateLock` on the managed queue upon destruction&period;
| xref:BloombergLP/bdlcc/SingleConsumerQueueImpl_MarkReclaimProctor.adoc[`SingleConsumerQueueImpl&lowbar;MarkReclaimProctor`] 
| This class implements a proctor that, unless its `release` method has previously been invoked, automatically invokes `markReclaim` on a `NODE` upon destruction&period;
| xref:BloombergLP/bdlcc/SingleConsumerQueueImpl_PopCompleteGuard.adoc[`SingleConsumerQueueImpl&lowbar;PopCompleteGuard`] 
| This class implements a guard that automatically invokes `popComplete` on the managed queue upon destruction&period;
| xref:BloombergLP/bdlcc/SingleProducerQueue.adoc[`SingleProducerQueue`] 
| This class provides a thread&hyphen;safe unbounded queue of values that assumes a single producer thread&period;
| xref:BloombergLP/bdlcc/SingleProducerQueueImpl.adoc[`SingleProducerQueueImpl`] 
| This class provides a thread&hyphen;safe unbounded queue of values that assumes a single producer thread&period;
| xref:BloombergLP/bdlcc/SingleProducerQueueImpl_PopCompleteGuard.adoc[`SingleProducerQueueImpl&lowbar;PopCompleteGuard`] 
| This class implements a guard automatically invokes `popComplete` on a `NODE` upon destruction&period;
| xref:BloombergLP/bdlcc/SingleProducerQueueImpl_ReleaseAllRawProctor.adoc[`SingleProducerQueueImpl&lowbar;ReleaseAllRawProctor`] 
| This class implements a proctor that, unless its `release` method has previously been invoked, automatically invokes `releaseAllRaw` on a `TYPE` upon destruction&period;
| xref:BloombergLP/bdlcc/SingleProducerSingleConsumerBoundedQueue.adoc[`SingleProducerSingleConsumerBoundedQueue`] 
| This class provides a thread&hyphen;safe bounded queue of values that supports a single producer and a single consumer&period;
| xref:BloombergLP/bdlcc/SingleProducerSingleConsumerBoundedQueue_PopCompleteGuard.adoc[`SingleProducerSingleConsumerBoundedQueue&lowbar;PopCompleteGuard`] 
| This class implements a guard that invokes `TYPE&colon;&colon;popComplete` on a `NODE` upon destruction&period;
| xref:BloombergLP/bdlcc/SkipList-0a.adoc[`SkipList`] 
| Thread&hyphen;safe ordered associative skip list of key&sol;data pairs&period;
| xref:BloombergLP/bdlcc/SkipListPair.adoc[`SkipListPair`] 
| Type&hyphen;safe pointer to a key&sol;data pair in a `SkipList`&period;
| xref:BloombergLP/bdlcc/SkipListPairHandle.adoc[`SkipListPairHandle`] 
| Managed handle to a key&sol;data pair in a `SkipList`&period;
| xref:BloombergLP/bdlcc/SkipList_DoubleLockGuard.adoc[`SkipList&lowbar;DoubleLockGuard`] 
| RAII guard that locks two mutexes in address order to avoid deadlock&period;
| xref:BloombergLP/bdlcc/SkipList_Node.adoc[`SkipList&lowbar;Node`] 
| This component&hyphen;private structure is a node in the SkipList&period;
| xref:BloombergLP/bdlcc/SkipList_NodeCreationHelper.adoc[`SkipList&lowbar;NodeCreationHelper`] 
| This component&hyphen;private structure is a scoped guard that initializes new nodes and releases them in case of exception&period;
| xref:BloombergLP/bdlcc/SkipList_PoolManager.adoc[`SkipList&lowbar;PoolManager`] 
| Component&hyphen;private manager for the lock&hyphen;free pool of skip&hyphen;list nodes&period;
| xref:BloombergLP/bdlcc/SkipList_PoolUtil.adoc[`SkipList&lowbar;PoolUtil`] 
| This component&hyphen;private utility handles the lock&hyphen;free pool of list nodes&period;
| xref:BloombergLP/bdlcc/SkipList_RandomLevelGenerator.adoc[`SkipList&lowbar;RandomLevelGenerator`] 
| This component&hyphen;private class handles randomizing the levelization of list nodes&period;
| 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&period;
| xref:BloombergLP/bdlcc/StripedUnorderedContainerImplMaxLoadFactorFlag.adoc[`StripedUnorderedContainerImplMaxLoadFactorFlag`] 
| This struct is a constructor flag used to select the contructor that takes a `maxLoadFactor` value&period;
| xref:BloombergLP/bdlcc/StripedUnorderedContainerImpl_ArrayOfLocksWriteGuard.adoc[`StripedUnorderedContainerImpl&lowbar;ArrayOfLocksWriteGuard`] 
| This class holds locks on an array of locks, established in sequential order, and unlocks them upon destruction in the RAII pattern&period;
| xref:BloombergLP/bdlcc/StripedUnorderedContainerImpl_Bucket.adoc[`StripedUnorderedContainerImpl&lowbar;Bucket`] 
| This class represents a bucket of the hash map&period; This class template represents the head of in the singly&hyphen;linked list of `(KEY, VALUE)` elements in a hash map&period;
| xref:BloombergLP/bdlcc/StripedUnorderedContainerImpl_Constants.adoc[`StripedUnorderedContainerImpl&lowbar;Constants`] 
| This class defines constant values used to represent the state of a `StripedUnorderedContainerImpl` object&period;
| xref:BloombergLP/bdlcc/StripedUnorderedContainerImpl_LockElement.adoc[`StripedUnorderedContainerImpl&lowbar;LockElement`] 
| A mutex &plus; support info&semi; padded to cacheline size, one per stripe
| xref:BloombergLP/bdlcc/StripedUnorderedContainerImpl_LockElementReadGuard.adoc[`StripedUnorderedContainerImpl&lowbar;LockElementReadGuard`] 
| A guard pattern on StripedUnorderedContainerImpl&lowbar;LockElement, to release on exception, for a lock element locked as read&period;
| xref:BloombergLP/bdlcc/StripedUnorderedContainerImpl_LockElementWriteGuard.adoc[`StripedUnorderedContainerImpl&lowbar;LockElementWriteGuard`] 
| A guard pattern on StripedUnorderedContainerImpl&lowbar;LockElement, to release on exception, for a lock element locked as write&period;
| xref:BloombergLP/bdlcc/StripedUnorderedContainerImpl_Node.adoc[`StripedUnorderedContainerImpl&lowbar;Node`] 
| This class template represents a node in the singly&hyphen;linked list of `(KEY, VALUE)` elements for each bucket of a hash map&period;
| xref:BloombergLP/bdlcc/StripedUnorderedContainerImpl_RehashBitSetGuard.adoc[`StripedUnorderedContainerImpl&lowbar;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&period;
| xref:BloombergLP/bdlcc/StripedUnorderedContainerImpl_SortItem.adoc[`StripedUnorderedContainerImpl&lowbar;SortItem`] 
| A vector element needed for efficient sorting for the `insertBulk` and `eraseBulk` methods&period;
| xref:BloombergLP/bdlcc/StripedUnorderedContainerImpl_TestUtil.adoc[`StripedUnorderedContainerImpl&lowbar;TestUtil`] 
| Test utility exposing stripe lock&sol;unlock for the test driver&period;
| xref:BloombergLP/bdlcc/StripedUnorderedMap.adoc[`StripedUnorderedMap`] 
| Fully thread&hyphen;safe hash map from `KEY` to `VALUE`, partitioned into stripes&period;
| xref:BloombergLP/bdlcc/StripedUnorderedMultiMap.adoc[`StripedUnorderedMultiMap`] 
| Fully thread&hyphen;safe striped hash multimap from `KEY` to `VALUE`&period;
| xref:BloombergLP/bdlcc/TimeQueue-09c.adoc[`TimeQueue`] 
| Priority queue of `DATA` items ordered by associated time values&period;
| xref:BloombergLP/bdlcc/TimeQueueItem.adoc[`TimeQueueItem`] 
| Container for a time, data, handle, and key associated with a queue item&period;
|===


== Functions

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bdlcc/operator_lshift.adoc[`operator&lt;&lt;`] 
| Write the value of `list` to the specified output `stream`&period;
| xref:BloombergLP/bdlcc/operator_eq-0c.adoc[`operator&equals;&equals;`] 
| Equality operators
| xref:BloombergLP/bdlcc/operator_not_eq-02.adoc[`operator!&equals;`] 
| Inequality operators
| xref:BloombergLP/bdlcc/operator_lt.adoc[`operator&lt;`] 
| Return `true` if `lhs` is ordered before `rhs` by stripe, then data&period;
|===



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