BloombergLP::bdlc::FlatHashSet

Synopsis

Declared in <bdlc_flathashset.h>

template<
    class KEY,
    class HASH = bslh::FibonacciBadHashWrapper<bsl::hash<KEY>>,
    class EQUAL = bsl::equal_to<KEY>>
class FlatHashSet;

Type Aliases

Name	Description
`const_iterator`	Const iterator over elements.
`const_pointer`	Pointer to a non-modifiable value.
`const_reference`	Reference to a non-modifiable value.
`difference_type`	Signed type used for iterator distances.
`hasher`	Hash functor type.
`iterator`	Iterator over elements (const, since set values are immutable).
`key_compare`	Key equality predicate type.
`key_type`	Key type of this set (also the element type).
`pointer`	Pointer to a modifiable value.
`reference`	Reference to a modifiable value.
`size_type`	Unsigned type used for sizes and capacities.
`value_compare`	Value equality predicate type (same as `key_compare`).
`value_type`	Element type stored by this set.

Member Functions

Name	Description
`FlatHashSet` [constructor]	Constructors
`~FlatHashSet` [destructor]	Destroy this object and each of its elements.
`operator=`	Assignment operators
`allocator`	Return the allocator used by this flat hash set to supply memory.
`begin`	Return a `const_iterator` to the first element in the sequence of elements maintained by this set, or the `end` iterator if this set is empty.
`capacity`	Return the number of elements this set could hold if the load factor were 1.
`cbegin`	Return a `const_iterator` to the first element in the sequence of elements maintained by this set, or the `end` iterator if this set is empty.
`cend`	Return a `const_iterator` to the past-the-end element in the sequence of `KEY` elements maintained by this set.
`clear`	Remove all elements from this set. Note that this set will be empty after calling this method, but allocated memory may be retained for future use. See the `capacity` method.
`contains`	`contains` overloads
`count`	`count` overloads
`emplace`	Insert into this set a newly created `value_type` object, constructed by forwarding `get_allocator()` (if required) and the specified (variable number of) `args` to the corresponding constructor of `value_type`, if a key equivalent to such a value does not already exist in this set; otherwise, this method has no effect (other than possibly creating a temporary `value_type` object). Return a pair whose `first` member is an iterator referring to the (possibly newly created and inserted) object in this set whose value is equivalent to that of an object constructed from `arguments`, and whose `second` member is `true` if a new value was inserted, and `false` if an equivalent key was already present.
`emplace_hint`	Insert into this set a newly created `value_type` object, constructed by forwarding `get_allocator()` (if required) and the specified (variable number of) `args` to the corresponding constructor of `value_type`, if a key equivalent to such a value does not already exists in this set; otherwise, this method has no effect (other than possibly creating a temporary `value_type` object). Return an iterator referring to the (possibly newly created and inserted) object in this set whose value is equivalent to that of an object constructed from `arguments`. The average and worst case complexity of this operation is not affected by the specified `hint`. Note that `hint` is ignored (other than possibly asserting its validity in some build modes).
`empty`	Return `true` if this set contains no elements, and `false` otherwise.
`end`	Return a `const_iterator` to the past-the-end element in the sequence of `KEY` elements maintained by this set.
`equal_range`	`equal_range` overloads
`erase`	`erase` overloads
`find`	Return a `const_iterator` referring to the element in this set having the specified `key`, or `end()` if no such entry exists in this set.
`hash_function`	Return (a copy of) the unary hash functor used by this set to generate a hash value (of type `bsl::size_t`) for a `KEY` object.
`insert`	`insert` overloads
`key_eq`	Return (a copy of) the binary key-equality functor that returns `true` if the value of two `KEY` objects are equivalent, and `false` otherwise.
`load_factor`	Return the current ratio between the number of elements in this container and its capacity.
`max_load_factor`	Return the maximum load factor allowed for this set. Note that if an insert operation would cause the load factor to exceed `max_load_factor()`, that same insert operation will increase the capacity and rehash the entries of the container (see {Load Factor and Resizing}). Also note that the value returned by `max_load_factor` is implementation defined and cannot be changed by the user.
`print`	Format this object to the specified output `stream` at the (absolute value of) the optionally specified indentation `level`, and return a reference to the modifiable `stream`. If `level` is specified, optionally specify `spacesPerLevel`, the number of spaces per indentation level for this and all of its nested objects. If `level` is negative, suppress indentation of the first line. If `spacesPerLevel` is negative, format the entire output on one line, suppressing all but the initial indentation (as governed by `level`). If `stream` is not valid on entry, this operation has no effect.
`rehash`	Change the capacity of this set to at least the specified `minimumCapacity`, and redistribute all the contained elements into a new sequence of entries according to their hash values. If `0 == minimumCapacity` and `0 == size()`, the set is returned to the default constructed state. After this call, `load_factor()` will be less than or equal to `max_load_factor()` and all iterators, pointers, and references to elements of this set are invalidated.
`reserve`	Change the capacity of this set to at least a capacity that can accommodate the specified `numEntries` (accounting for the load factor invariant), and redistribute all the contained elements into a new sequence of entries according to their hash values. If `0 == numEntries` and `0 == size()`, the set is returned to the default constructed state. After this call, `load_factor()` will be less than or equal to `max_load_factor()` and all iterators, pointers, and references to elements of this set are invalidated. Note that this method is effectively equivalent to: ` rehash(bsl::ceil(numEntries / max_load_factor())) `
`reset`	Remove all elements from this set and release all memory from this set, returning the set to the default constructed state.
`size`	Return the number of elements in this set.
`swap`	Exchange the value of this object as well as its hasher and equality functors with those of the specified `other` object. The behavior is undefined unless this object was created with the same allocator as `other`.

Friends

Name	Description
`BloombergLP::bdlc::swap`	Exchange the contents of the two sets.
`BloombergLP::bdlc::operator!=`	Return whether the sets differ in contents.
`BloombergLP::bdlc::operator==`	Return whether the sets have the same contents.

Non-Member Functions

Name	Description
`operator!=`	Return `true` if the specified `lhs` and `rhs` objects do not have the same value, and `false` otherwise. Two `FlatHashSet` objects do not have the same value if their sizes are different or one contains an element equal to no element of the other. The hash and equality functors are not involved in the comparison.
`operator==`	Return `true` if the specified `lhs` and `rhs` objects have the same value, and `false` otherwise. Two `FlatHashSet` objects have the same value if their sizes are the same and each element contained in one is equal to an element of the other. The hash and equality functors are not involved in the comparison.
`swap`	Exchange the value, the hasher, and the key-equality functor of the specified `a` and `b` objects. This function provides the no-throw exception-safety guarantee if the two objects were created with the same allocator and the basic guarantee otherwise.