CppUtils::Container::FlatHashMap<class Key, class Value, class Hasher = Type::HashT, class KeyEqual = std::equal_to<Key>>

Public types

key_type

using CppUtils::Container::FlatHashMap<Key, Value, Hasher, KeyEqual>::key_type = Key;

mapped_type

using CppUtils::Container::FlatHashMap<Key, Value, Hasher, KeyEqual>::mapped_type = Value;

value_type

using CppUtils::Container::FlatHashMap<Key, Value, Hasher, KeyEqual>::value_type = std::pair<Key, Value>;

size_type

using CppUtils::Container::FlatHashMap<Key, Value, Hasher, KeyEqual>::size_type = std::size_t;

difference_type

using CppUtils::Container::FlatHashMap<Key, Value, Hasher, KeyEqual>::difference_type = std::ptrdiff_t;

hasher

using CppUtils::Container::FlatHashMap<Key, Value, Hasher, KeyEqual>::hasher = Hasher;

key_equal

using CppUtils::Container::FlatHashMap<Key, Value, Hasher, KeyEqual>::key_equal = KeyEqual;

iterator

using CppUtils::Container::FlatHashMap<Key, Value, Hasher, KeyEqual>::iterator = Iterator<false>;

const_iterator

using CppUtils::Container::FlatHashMap<Key, Value, Hasher, KeyEqual>::const_iterator = Iterator<true>;

Public methods

constexpr FlatHashMap::FlatHashMap() = default;

constexpr explicit FlatHashMap::FlatHashMap(std::size_t initialCapacity, const Hasher& hasher = Hasher{}, const KeyEqual& keyEqual = KeyEqual{});

constexpr FlatHashMap::FlatHashMap(std::initializer_list<std::pair<Key, Value>> initialValues, const Hasher& hasher = Hasher{}, const KeyEqual& keyEqual = KeyEqual{});

template <std::input_iterator InputIterator>
constexpr FlatHashMap::FlatHashMap(InputIterator first, InputIterator last, const Hasher& hasher = Hasher{}, const KeyEqual& keyEqual = KeyEqual{});

constexpr FlatHashMap::FlatHashMap(const FlatHashMap&) = default;

constexpr FlatHashMap::FlatHashMap(FlatHashMap&&) noexcept = default;

constexpr auto FlatHashMap::operator=(const FlatHashMap&) -> FlatHashMap& = default;

constexpr auto FlatHashMap::operator=(FlatHashMap&&) noexcept -> FlatHashMap& = default;

[[nodiscard]] constexpr auto FlatHashMap::begin(this auto&& self) noexcept;

[[nodiscard]] constexpr auto FlatHashMap::cbegin() const noexcept -> const_iterator;

[[nodiscard]] constexpr auto FlatHashMap::end(this auto&& self) noexcept;

[[nodiscard]] constexpr auto FlatHashMap::cend() const noexcept -> const_iterator;

[[nodiscard]] constexpr auto FlatHashMap::size() const noexcept -> std::size_t;

[[nodiscard]] constexpr auto FlatHashMap::empty() const noexcept -> bool;

[[nodiscard]] constexpr auto FlatHashMap::capacity() const noexcept -> std::size_t;

[[nodiscard]] constexpr auto FlatHashMap::loadFactor() const noexcept -> float;

constexpr auto FlatHashMap::clear() noexcept -> void;

constexpr auto FlatHashMap::rehash(std::size_t newCapacity) -> void;

constexpr auto FlatHashMap::reserve(std::size_t desiredCapacity) -> void;

[[nodiscard]] constexpr auto FlatHashMap::contains(const auto& key) const noexcept -> bool;

[[nodiscard]] constexpr auto FlatHashMap::count(const auto& key) const noexcept -> std::size_t;

[[nodiscard]] constexpr auto FlatHashMap::find(this auto&& self, const auto& key) noexcept;

[[nodiscard]] constexpr auto FlatHashMap::at(this auto&& self, const auto& key) -> decltype(auto);

[[nodiscard]] constexpr auto FlatHashMap::operator[](auto&& key) -> Value& requires std::default_initializable<Value>;

constexpr auto FlatHashMap::try_emplace(auto&& key, auto&&... valueArguments) -> std::pair<iterator, bool>;

constexpr auto FlatHashMap::insert(const std::pair<Key, Value>& pair) -> std::pair<iterator, bool>;

constexpr auto FlatHashMap::insert(std::pair<Key, Value>&& pair) -> std::pair<iterator, bool>;

constexpr auto FlatHashMap::insert(auto&& argumentPair) -> std::pair<iterator, bool> requires std::is_constructible_v<std::pair<Key, Value>, decltype(argumentPair)>;

constexpr auto FlatHashMap::emplace(auto&&... arguments) -> std::pair<iterator, bool>;

constexpr auto FlatHashMap::insert_or_assign(auto&& key, auto&& value) -> std::pair<iterator, bool>;

constexpr auto FlatHashMap::erase(const_iterator position) -> iterator;

constexpr auto FlatHashMap::erase(iterator position) -> iterator;

constexpr auto FlatHashMap::erase(const auto& key) -> std::size_t requires (not std::same_as<std::decay_t<decltype(key)>, iterator> and not std::same_as<std::decay_t<decltype(key)>, const_iterator>);