[#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; 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&period; If `isUnconstructed` is `false`, then the value (`d&lowbar;value`) refers to a valid object&period; If `isUnconstructed` is `true` then `d&lowbar;value` does not refer to a valid object, it does not represent a value in this queue, and the destructor of `d&lowbar;value` should not be called&period; 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&hyphen;time&period; If `RECLAIMABLE` is `false` then it can be determined at compile time that the construction of `TYPE` will uncoditionally succeed (e&period;g&period;, it `IsBitwiseCopyable`), and the `isUnconstructed` property does not require a data member to be accessed at run&hyphen;time&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`] 
| This class implements a proctor that, on destruction, restores the queue to its state at the time of the proctor&apos;s creation&period; We assume that the only change to the queue is that 0 or more items have been added to the end&period; If `release` has been called, the destructor takes no action&period;
| xref:BloombergLP/bdlcc/Cache_TestUtil.adoc[`Cache&lowbar;TestUtil`] 
| This class implements a test utility that gives the test driver access to the lock &sol; unlock method of the RW mutex&period; Its purpose is to allow testing that the locking actually happens as planned&period;
| xref:BloombergLP/bdlcc/Deque.adoc[`Deque`] 
| This class provides a fully thread&hyphen;safe implementation of an efficient, in&hyphen;place, indexable, double&hyphen;ended queue of (template parameter) `TYPE` values&period; Direct access to the underlying `bsl&colon;&colon;deque&lt;TYPE&gt;` object is provided through the nested `Proctor` and `ConstProctor` classes&period; While this class is not value&hyphen;semantic, the underlying `bsl&colon;&colon;deque&lt;TYPE&gt;` class is&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`] 
| This class implements a circular buffer of atomic state variables&period; These are intended to synchronize access to another (non&hyphen;atomic) indexed data structure so that the other data structure can be used as a thread&hyphen;enabled fixed&hyphen;size queue&period;
| xref:BloombergLP/bdlcc/FixedQueue_PopGuard.adoc[`FixedQueue&lowbar;PopGuard`] 
| This class provides a guard that, upon its destruction, will remove (pop) the indicated element from the `FixedQueue` object supplied at construction&period; Note that this guard is used to provide exception safety when popping an element from a `FixedQueue` object&period;
| xref:BloombergLP/bdlcc/FixedQueue_PushProctor.adoc[`FixedQueue&lowbar;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&hyphen;buffer into a valid empty state) upon the proctor&apos;s destruction&period; Note that this guard is used to provide exception safety when pushing an element into a `FixedQueue`&period;
| xref:BloombergLP/bdlcc/MultipriorityQueue.adoc[`MultipriorityQueue`] 
| This class implements a thread&hyphen;enabled multipriority queue whose priorities are restricted to a (small) set of contiguous `N` integer values, `&lsqb; 0 &period;&period; N &hyphen; 1 &rsqb;`, with 0 being the most urgent&period;
| xref:BloombergLP/bdlcc/MultipriorityQueue_Node.adoc[`MultipriorityQueue&lowbar;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&period; This class is not to be used from outside this component&period;
| xref:BloombergLP/bdlcc/ObjectCatalog.adoc[`ObjectCatalog`] 
| This class defines an efficient indexed object catalog of `TYPE` objects&period; This container is _exception_ _neutral_ with no guarantee of rollback&colon; if an exception is thrown during the invocation of a method on a pre&hyphen;existing instance, the object is left in a valid but undefined state&period; In no event is memory leaked or a mutex left in a locked state&period;
| xref:BloombergLP/bdlcc/ObjectCatalogIter.adoc[`ObjectCatalogIter`] 
| Provide thread safe iteration through all the objects of an object catalog of parameterized `TYPE`&period; The order of the iteration is implementation defined&period; An iterator is _valid_ if it is associated with an object in the catalog, otherwise it is _invalid_&period; Thread&hyphen;safe iteration is provided by (read)locking the object catalog during the iterator&apos;s construction and unlocking it at the iterator&apos;s destruction&period; This guarantees that during the life time of an iterator, the object catalog can&apos;t be modified (nevertheless, multiple threads can concurrently read the object catalog)&period;
| xref:BloombergLP/bdlcc/ObjectCatalog_AutoCleanup.adoc[`ObjectCatalog&lowbar;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&period;
| xref:BloombergLP/bdlcc/ObjectPool.adoc[`ObjectPool`] 
| This class provides a thread&hyphen;safe pool of reusable objects&period; It also implements the `bdlma&colon;&colon;Factory` protocol&colon; &quot;creating&quot; objects gets them from the pool and &quot;deleting&quot; objects returns them to the pool&period;
| xref:BloombergLP/bdlcc/ObjectPoolFunctors.adoc[`ObjectPoolFunctors`] 
| This struct provides several functors that are suitable `RESETTER` parameter types for `ObjectPool`&period; It also provides a `typedef` that specifies the default `CREATOR` parameter type for `ObjectPool`&period;
| xref:BloombergLP/bdlcc/ObjectPool_CreatorConverter-07.adoc[`ObjectPool&lowbar;CreatorConverter`] 
| The purpose of this private class is to avoid ambiguity between different template instantiations of `bsl&colon;&colon;function` accepted by the constructors of `ObjectPool`&period; It should not be used directly&period;
| xref:BloombergLP/bdlcc/ObjectPool_DefaultProxy.adoc[`ObjectPool&lowbar;DefaultProxy`] 
| This private class template provides a default constructor that creates a proxied `bsl&colon;&colon;function` object that invokes the default constructor of the parameterized `TYPE` with placement `new`&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 implementation of an efficient, in&hyphen;place, indexable, double&hyphen;ended queue of parameterized `TYPE` values&period; Very efficient access to the underlying `bdlc&colon;&colon;Queue` object is provided, as well as to a `bslmt&colon;&colon;Mutex` and a `bslmt&colon;&colon;Condition` variable, to facilitate thread&hyphen;safe use of the `bdlc&colon;&colon;Queue`&period; Note that `Queue` is not a value&hyphen;semantic type, but the underlying `bdlc&colon;&colon;Queue` is&period; In this regard, `Queue` is a thread&hyphen;enabled handle for a `bdlc&colon;&colon;Queue`&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`] 
| This class provides a generic thread&hyphen;safe Skip List (an ordered associative container)&period; It supports an almost complete set of _value_ _semantic_ operations, including copy construction, assignment, equality comparison, and `ostream` printing (but not BDEX serialization)&period;
| xref:BloombergLP/bdlcc/SkipListPair.adoc[`SkipListPair`] 
| Pointers to objects of this class are used in the &quot;raw&quot; API of `SkipList`&semi; however, objects of the class are never constructed as the class serves only to provide type&hyphen;safe pointers&period;
| xref:BloombergLP/bdlcc/SkipListPairHandle.adoc[`SkipListPairHandle`] 
| Objects of this class refer to an association (pair) in a `SkipList`&period; A `bdlcc&colon;&colon;SkipListPairHandle` is implicitly convertible to a `const Pair&ast;` and thus may be used anywhere in the `SkipList` API that a `const Pair&ast;` is expected&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`] 
| This class implements a test utility that gives the test driver access to the lock &sol; unlock method of the Read&sol;Write mutex&period; Its purpose is to allow testing that the locking actually happens as planned&period;
| xref:BloombergLP/bdlcc/StripedUnorderedMap.adoc[`StripedUnorderedMap`] 
| This class template defines a fully thread&hyphen;safe container that provides a mapping from keys (of template parameter type `KEY`) to their associated mapped values (of template parameter type `VALUE`)&period;
| xref:BloombergLP/bdlcc/StripedUnorderedMultiMap.adoc[`StripedUnorderedMultiMap`] 
| This class template defines a fully thread&hyphen;safe container that provides a mapping from keys (of template parameter type `KEY`) to their associated mapped values (of template parameter type `VALUE`)&period;
| xref:BloombergLP/bdlcc/TimeQueue-09c.adoc[`TimeQueue`] 
| This parameterized class provides a public interface which is similar in structure and intent to `Queue&lt;DATA&gt;`, with the exception that each item stored in the `TimeQueue` has an associated time value&period; Items are retrieved or exchanged by proxy of a `TimeQueueItem&lt;DATA&gt;`, and are referred to by an opaque data type `TimeQueue&colon;&colon;Handle` which serves to identify an individual element on the Time Queue&period; Idiomatic usage of `TimeQueue` includes the member function `popLE`, which finds all items on the queue whose `bsls&colon;&colon;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&period;
| xref:BloombergLP/bdlcc/TimeQueueItem.adoc[`TimeQueueItem`] 
| This parameterized structure holds a time, data and associated handle&period; This structure is used in the interface of `TimeQueue&lt;DATA&gt;` to provide thread&hyphen;safe access to individual elements on the queue&period; Note that `DATA` must be default&hyphen;constructible&period;
|===


== Functions

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bdlcc/operator_lshift.adoc[`operator&lt;&lt;`] 
| Write the specified `list` to the specified output `stream` and return a reference to the modifiable `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 the specified `lhs` is smaller than the specified `rhs` in the order of stripe, and data&period;
|===



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