BloombergLP::bdlc::FlatHashMap::FlatHashMap

Synopses

Declared in <bdlc_flathashmap.h>

Create an empty FlatHashMap object. Optionally specify a capacity indicating the minimum initial size of the underlying array of entries of this container. If capacity is not supplied or is 0, no memory is allocated. Optionally specify a hash functor used to generate the hash values associated with the keys of elements in this container. If hash is not supplied, a default-constructed object of the (template parameter) type HASH is used. Optionally specify an equality functor equal used to determine whether the keys of two elements are equivalent. If equal is not supplied, a default-constructed object of the (template parameter) type EQUAL is used. Optionally specify a basicAllocator used to supply memory. If basicAllocator is not supplied or is 0, the currently installed default allocator is used.

FlatHashMap();

Create an empty map with at least the specified capacity.

explicit
FlatHashMap(std::size_t capacity);

Create a FlatHashMap object having the same value, hasher, equality comparator, and allocator as the specified original object. The contents of original are moved (in constant time) to this object, original is left in a (valid) unspecified state, and no exceptions will be thrown.

FlatHashMap(bslmf::MovableRef<FlatHashMap> original);

Create an empty map using the specified basicAllocator.

explicit
FlatHashMap(bslma::Allocator* basicAllocator);

Create an empty map with at least the specified capacity, using the specified basicAllocator.

FlatHashMap(
    std::size_t capacity,
    bslma::Allocator* basicAllocator);

Create a FlatHashMap object having the same value, hasher, and equality comparator as the specified original object, using the specified basicAllocator to supply memory. If basicAllocator is 0, the currently installed default allocator is used. The allocator of original remains unchanged. If original and the newly created object have the same allocator then the contents of original are moved (in constant time) to this object, original is left in a (valid) unspecified state, and no exceptions will be thrown; otherwise, original is unchanged (and an exception may be thrown).

FlatHashMap(
    bslmf::MovableRef<FlatHashMap> original,
    bslma::Allocator* basicAllocator);

Create a FlatHashMap object initialized by insertion of the specified values. Optionally specify a capacity indicating the minimum initial size of the underlying array of entries of this container. If capacity is not supplied or is 0, no memory is allocated. Optionally specify a hash functor used to generate hash values associated with the keys of elements in this container. If hash is not supplied, a default-constructed object of the (template parameter) type HASH is used. Optionally specify an equality functor equal used to determine whether the keys of two elements are equivalent. If equal is not supplied, a default-constructed object of the (template parameter) type EQUAL is used. Optionally specify a basicAllocator used to supply memory. If basicAllocator is not supplied or is 0, the currently installed default allocator is used. Note that if a member of values has an equivalent key to an earlier member, the later member will not be inserted.

FlatHashMap(
    bsl::initializer_list<value_type> values,
    bslma::Allocator* basicAllocator = 0);

Create a FlatHashMap object having the same value, hasher, and equality comparator as the specified original object. Optionally specify a basicAllocator used to supply memory. If basicAllocator is not specified or is 0, the currently installed default allocator is used.

FlatHashMap(
    FlatHashMap const& original,
    bslma::Allocator* basicAllocator = 0);

Create an empty map with at least the specified capacity and hash functor; optionally use basicAllocator.

FlatHashMap(
    std::size_t capacity,
    HASH const& hash,
    bslma::Allocator* basicAllocator = 0);

Same as the preceding overload, also requesting at least the specified capacity.

FlatHashMap(
    bsl::initializer_list<value_type> values,
    std::size_t capacity,
    bslma::Allocator* basicAllocator = 0);

Create a FlatHashMap object initialized by insertion of the values from the input iterator range specified by first through last (including first, excluding last). Optionally specify a capacity indicating the minimum initial size of the underlying array of entries of this container. If capacity is not supplied or is 0, no memory is allocated. Optionally specify a hash functor used to generate hash values associated with the keys of the elements in this container. If hash is not supplied, a default-constructed object of the (template parameter) type HASH is used. Optionally specify an equality functor equal used to determine whether the keys of two elements are equivalent. If equal is not supplied, a default-constructed object of the (template parameter) type EQUAL is used. Optionally specify a basicAllocator used to supply memory. If basicAllocator is not supplied or is 0, the currently installed default allocator is used. The behavior is undefined unless first and last refer to a sequence of valid values where first is at a position at or before last. Note that if a member of the input sequence has an equivalent key to an earlier member, the later member will not be inserted.

template<class INPUT_ITERATOR>
FlatHashMap(
    INPUT_ITERATOR first,
    INPUT_ITERATOR last,
    bslma::Allocator* basicAllocator = 0);

Create an empty map with at least the specified capacity, hash, and equal predicate; optionally use basicAllocator.

FlatHashMap(
    std::size_t capacity,
    HASH const& hash,
    EQUAL const& equal,
    bslma::Allocator* basicAllocator = 0);

Same as the preceding overload, also using the specified hash.

FlatHashMap(
    bsl::initializer_list<value_type> values,
    std::size_t capacity,
    HASH const& hash,
    bslma::Allocator* basicAllocator = 0);

Same as the preceding overload, also requesting at least the specified capacity.

template<class INPUT_ITERATOR>
FlatHashMap(
    INPUT_ITERATOR first,
    INPUT_ITERATOR last,
    std::size_t capacity,
    bslma::Allocator* basicAllocator = 0);

Same as the preceding overload, also using the specified equal.

FlatHashMap(
    bsl::initializer_list<value_type> values,
    std::size_t capacity,
    HASH const& hash,
    EQUAL const& equal,
    bslma::Allocator* basicAllocator = 0);

Same as the preceding overload, also using the specified hash.

template<class INPUT_ITERATOR>
FlatHashMap(
    INPUT_ITERATOR first,
    INPUT_ITERATOR last,
    std::size_t capacity,
    HASH const& hash,
    bslma::Allocator* basicAllocator = 0);

Same as the preceding overload, also using the specified equal.

template<class INPUT_ITERATOR>
FlatHashMap(
    INPUT_ITERATOR first,
    INPUT_ITERATOR last,
    std::size_t capacity,
    HASH const& hash,
    EQUAL const& equal,
    bslma::Allocator* basicAllocator = 0);