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. |
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. |
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. |
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. |
CompactedArray_RemoveAllProctor | This class implements a proctor that, unless its release method has previously been invoked, automatically invokes removeAll on a CompactedArray upon destruction. |
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. |
FlatHashMap_EntryUtil | This templated utility provides methods to construct an ENTRY and a method to extract the key from an ENTRY. |
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. |
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). |
FlatHashTable | This class template provides a flat hash table implementation useful for implementing a flat hash set and flat hash map. |
FlatHashTable_GroupControl | This class provides methods for making inquires to the data of a group control loading during construction. |
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. |
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. |
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. |
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. |
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. |
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. |
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. |
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. |
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. |
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. |
PackedIntArrayImpType | This meta-function selects PackedIntArrayImp<PackedIntArrayImp_Unsigned> if TYPE should be stored as an unsigned integer, and PackedIntArrayImp<PackedIntArrayImp_Signed> otherwise. |
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. |
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. |
PackedIntArrayUtil | This struct provides a namespace for utility functions that provide non-primitive operations on bdlc::PackedIntArray. |
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. |