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

Components providing a compact, value‐semantic bit array.

== Types

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bdlc/BitArray.adoc[`BitArray`] 
| This class implements an efficient, value‐semantic array of boolean (a.k.a. bit, i.e., binary digit) values stored in contiguous memory. The physical capacity of this array may grow, but never shrinks. Capacity may be reserved initially via a constructor, or at any time thereafter by using the `reserveCapacity` method; otherwise, capacity will be increased automatically as needed. Note that capacity is not a _salient_ attribute of this object, and, as such, does not contribute to overall value. Also note that this class provides an implicit no‐throw guarantee for all methods (including manipulators) that do not attempt to alter capacity.
| xref:BloombergLP/bdlc/CompactedArray.adoc[`CompactedArray`] 
| This space‐efficient, value‐semantic array class represents a sequence of `TYPE` elements. The interface provides functionality similar to a `vector<TYPE>`, however, modifiable references to individual elements are not provided. This class provides accessors that return iterators that provide non‐modifiable access to its elements. The returned iterators, unlike those returned by a `vector<TYPE>`, are _not_ invalidated upon reallocation.
| xref:BloombergLP/bdlc/CompactedArray_ConstIterator.adoc[`CompactedArray_ConstIterator`] 
| This value‐semantic class represents a random access iterator providing non‐modifiable access to the elements of a `CompactedArray`. This class provides all functionality of a random access iterator, as defined by the standard, but is _not_ compatible with most standard methods requiring a bidirectional `const_iterator`.
| xref:BloombergLP/bdlc/CompactedArray_CountedValue.adoc[`CompactedArray_CountedValue`] 
| This `struct` represents a reference‐counted value. Note that comparison of `d_count` is intentionally omitted from the free equality‐comparison operators of this class.
| xref:BloombergLP/bdlc/CompactedArray_RemoveAllProctor.adoc[`CompactedArray_RemoveAllProctor`] 
| This class implements a proctor that, unless its `release` method has previously been invoked, automatically invokes `removeAll` on a `CompactedArray` upon destruction.
| xref:BloombergLP/bdlc/FlatHashMap.adoc[`FlatHashMap`] 
| This class template implements a value‐semantic container type holding an unordered map of `KEY‐VALUE` pairs having unique keys that provides a mapping from keys of (template parameter) type `KEY` to their associated mapped values of (template parameter) type `VALUE`. The (template parameter) type `HASH` is a functor providing the hash value for `KEY`. The (template parameter) type `EQUAL` is a functor providing the equality function for two `KEY` values. See {Requirements on `KEY`, `HASH`, and `EQUAL`} for more information.
| xref:BloombergLP/bdlc/FlatHashMap_EntryUtil.adoc[`FlatHashMap_EntryUtil`] 
| This templated utility provides methods to construct an `ENTRY` and a method to extract the key from an `ENTRY`.
| xref:BloombergLP/bdlc/FlatHashSet.adoc[`FlatHashSet`] 
| This class template implements a value‐semantic container type holding an unordered set of unique values of (template parameter) type `KEY`. The (template parameter) type `HASH` is a functor providing the hash value for `KEY`. The (template parameter) type `EQUAL` is a functor providing the equality function for two `KEY` values. See {Requirements on `KEY`, `HASH`, and `EQUAL`} for more information.
| xref:BloombergLP/bdlc/FlatHashSet_EntryUtil.adoc[`FlatHashSet_EntryUtil`] 
| This templated utility provides methods to construct an `ENTRY` and a method to extract the key from an `ENTRY` (which is, identically, the `ENTRY`).
| xref:BloombergLP/bdlc/FlatHashTable.adoc[`FlatHashTable`] 
| This class template provides a flat hash table implementation useful for implementing a flat hash set and flat hash map.
| xref:BloombergLP/bdlc/FlatHashTable_GroupControl.adoc[`FlatHashTable_GroupControl`] 
| This class provides methods for making inquires to the data of a group control loading during construction.
| xref:BloombergLP/bdlc/FlatHashTable_IteratorImp.adoc[`FlatHashTable_IteratorImp`] 
| This class implements the methods required by `bsl::ForwardIterator` to provide forward iterators. As such, an instance of this class represents a position within a flat hash table. This class uses no features of the `ENTRY` type except for addresses of `ENTRY` objects.
| xref:BloombergLP/bdlc/HashTable.adoc[`HashTable`] 
| This class is a double‐hashed table. The `VALUE` template parameter is optional. The `capacityHint` specified at construction time will be used to compute the number of buckets (capacity) in this object. Also, two hash functions may optionally be specified at construction time. Elements can be inserted using the `insert` method. If the `VALUE` parameter is not `bslmf::Nil`, then both key and value must be supplied to the `insert` method. Otherwise, only the key should be supplied. The `find` method can be used to lookup elements by a specified key. The optional `TRAITS` parameter can be used to classify "null" and "removed" values. See the component‐level documentation for more details.
| xref:BloombergLP/bdlc/HashTableDefaultHash1.adoc[`HashTableDefaultHash1`] 
| Default hash function provided by this component. See component‐level documentation for more details. Note that this class is not intended to be used by clients, but the name of this struct must be public so that clients can explicitly specify this struct when default hash function is needed. Note that this functor is implemented using `bdlb::HashUtil::hash1`.
| xref:BloombergLP/bdlc/HashTableDefaultHash2.adoc[`HashTableDefaultHash2`] 
| Default hash function provided by this component. See component‐level documentation for more details. Note that this class is not intended to be used by clients, but the name of this struct must be public so that clients can explicitly specify this struct when default hash function is needed. Note that this functor is implemented using `bdlb::HashUtil::hash2`.
| xref:BloombergLP/bdlc/HashTableDefaultTraits.adoc[`HashTableDefaultTraits`] 
| Default traits provided by this component. See component‐level documentation for more details. Note that this class is not intended to be used by clients, but the name of this struct must be public so that clients can explicitly specify this struct when default traits are needed.
| xref:BloombergLP/bdlc/IndexClerk.adoc[`IndexClerk`] 
| This class defines an efficient, value‐semantic manager type for reusable, non‐negative integer indices. The class invariants are that the all decommissioned indices must be non‐negative, less than the next new index, and unique.
| xref:BloombergLP/bdlc/IndexClerkIter.adoc[`IndexClerkIter`] 
| This class defines an in‐core value‐semantic iterator providing sequential read‐only access to the decommissioned indices of a `IndexClerk`. The order of iteration is implementation dependent.
| xref:BloombergLP/bdlc/PackedIntArray-0b.adoc[`PackedIntArray`] 
| This space‐efficient value‐semantic array class represents a sequence of `TYPE` elements; `TYPE` must be convertible to either a signed or unsigned 64‐bit integer using `static_cast`. The interface provides functionality similar to a `vector<int>` however references to individual elements are not provided. This class provides accessors that return iterators that provide non‐modifiable access to its elements. The returned iterators, unlike those returned by a `vector<int>` are _not_ invalidated upon reallocation.
| xref:BloombergLP/bdlc/PackedIntArrayConstIterator.adoc[`PackedIntArrayConstIterator`] 
| This unconstrained (value‐semantic) class represents a random access iterator providing non‐modifiable access to the elements of a `PackedIntArray`. This class provides all functionality of a random access iterator, as defined by the standard, but is _not_ compatible with most standard methods requiring a bidirectional const_iterator.
| xref:BloombergLP/bdlc/PackedIntArrayImp-0a.adoc[`PackedIntArrayImp`] 
| This space‐efficient value‐semantic array class represents a sequence of `STORAGE::EightByteStorageType` elements; `STORAGE::EightByteStorageType` must be convertible to either a signed or unsigned 64‐bit integer using `static_cast`. The interface provides functionality similar to a `vector<int>` however references to individual elements are not provided.
| xref:BloombergLP/bdlc/PackedIntArrayImpType-0d.adoc[`PackedIntArrayImpType`] 
| This meta‐function selects `PackedIntArrayImp<PackedIntArrayImp_Unsigned>` if `TYPE` should be stored as an unsigned integer, and `PackedIntArrayImp<PackedIntArrayImp_Signed>` otherwise.
| xref:BloombergLP/bdlc/PackedIntArrayImp_Signed.adoc[`PackedIntArrayImp_Signed`] 
| This `struct` provides a namespace for types and methods used to implement a space‐efficient value‐semantic array class representing a sequence of `TYPE` elements; `TYPE` must be convertible to either a `bsl::int64_t`. Specifically, it defines the types used to store the array's data, methods needed to externalize and unexternalize the array, and a method to determine the storage size to use for a given value.
| xref:BloombergLP/bdlc/PackedIntArrayImp_Unsigned.adoc[`PackedIntArrayImp_Unsigned`] 
| This `struct` provides a namespace for types and methods used to implement a space‐efficient value‐semantic array class representing a sequence of `TYPE` elements; `TYPE` must be convertible to either a `bsl::uint64_t`. Specifically, it defines the types used to store the array's data, methods needed to externalize and unexternalize the array, and a method to determine the storage size to use for a given value.
| xref:BloombergLP/bdlc/PackedIntArrayUtil.adoc[`PackedIntArrayUtil`] 
| This `struct` provides a namespace for utility functions that provide non‐primitive operations on `bdlc::PackedIntArray`.
| xref:BloombergLP/bdlc/Queue.adoc[`Queue`] 
| This class implements an efficient, in‐place double‐ended queue of values of parameterized type `T`. The physical capacity of this queue may grow, but never shrinks. Capacity may be reserved initially via a constructor, or at any time thereafter by using the `reserveCapacity` and `reserveCapacityRaw` methods. Note that there is no guarantee of contiguous storage of consecutive elements.
|===


== Functions

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bdlc/hashAppend-0f.adoc[`hashAppend`] 
| `hashAppend` overloads
| xref:BloombergLP/bdlc/operator_bitand.adoc[`operator&`] 
| Return the value that is the bitwise AND of the specified `lhs` and `rhs` arrays. The length of the resulting bit array will be the maximum of that of `lhs` and `rhs`, with any unmatched high‐order bits set to 0. Note that this behavior is consistent with zero‐extending a copy of the shorter array.
| xref:BloombergLP/bdlc/operator_plus-04.adoc[`operator+`] 
| Addition operators
| xref:BloombergLP/bdlc/operator_inc-0c.adoc[`operator++`] 
| Increment operators
| xref:BloombergLP/bdlc/operator_minus-0a4.adoc[`operator‐`] 
| Subtraction operators
| xref:BloombergLP/bdlc/operator_dec-0a.adoc[`operator‐‐`] 
| Decrement operators
| xref:BloombergLP/bdlc/operator_rshift.adoc[`operator>>`] 
| Return the value of the specified `array` right‐shifted by the specified `numBits` positions, having filled the higher‐index positions with zeros. The behavior is undefined unless `numBits <= array.length()`. Note that the length of the result equals the length of the original array, and that the lowest‐order `numBits` are discarded in the result.
| xref:BloombergLP/bdlc/operator_xor.adoc[`operatorˆ`] 
| Return the value that is the bitwise XOR of the specified `lhs` and `rhs` arrays. The length of the resulting bit array will be the maximum of that of `lhs` and `rhs`, with any unmatched high‐order bits copied unchanged. Note that this behavior is consistent with zero‐extending a copy of the shorter array.
| xref:BloombergLP/bdlc/operator_bitor.adoc[`operator|`] 
| Return the value that is the bitwise OR of the specified `lhs` and `rhs` arrays. The length of the resulting bit array will be the maximum of that of `lhs` and `rhs`, with any unmatched high‐order bits copied unchanged. Note that this behavior is consistent with zero‐extending a copy of the shorter array.
| xref:BloombergLP/bdlc/operator_bitnot.adoc[`operator~`] 
| Return the bitwise complement ("toggle") of the specified `array`.
| xref:BloombergLP/bdlc/swap-00f.adoc[`swap`] 
| `swap` overloads
| xref:BloombergLP/bdlc/operator_lshift-0683.adoc[`operator<<`] 
| Left shift operators
| xref:BloombergLP/bdlc/operator_eq-043.adoc[`operator==`] 
| Equality operators
| xref:BloombergLP/bdlc/operator_not_eq-0e.adoc[`operator!=`] 
| Inequality operators
| xref:BloombergLP/bdlc/operator_lt-0e.adoc[`operator<`] 
| Less‐than operators
| xref:BloombergLP/bdlc/operator_le-01.adoc[`operator<=`] 
| Less‐than‐or‐equal operators
| xref:BloombergLP/bdlc/operator_gt-06.adoc[`operator>`] 
| Greater‐than operators
| xref:BloombergLP/bdlc/operator_ge-05.adoc[`operator>=`] 
| Greater‐than‐or‐equal operators
|===



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