Hash map with Robin Hood hashing for bounded probe distances. More...

#include <nfx/containers/FastHashMap.h>

Classes
class	Iterator
	Iterator for HashMap that skips empty buckets. More...
class	ConstIterator
	Const iterator for HashMap that skips empty buckets. More...

Public Types
using	key_type = TKey
	Type alias for key type.
using	mapped_type = TValue
	Type alias for mapped value type.
using	value_type = std::pair<const TKey, TValue>
	Type alias for key-value pair type.
using	hasher = THasher
	Type alias for hasher type.
using	key_equal = KeyEqual
	Type alias for key equality comparator.
using	hash_type = HashType
	Type alias for hash type (uint32_t or uint64_t).
using	size_type = size_t
	Type alias for size type.
using	difference_type = std::ptrdiff_t
	Type alias for difference type.
using	iterator = Iterator
	Type alias for iterator.
using	const_iterator = ConstIterator
	Type alias for const iterator.

Public Member Functions
	FastHashMap ()
	Default constructor with initial capacity of 32 elements.
	FastHashMap (std::initializer_list< std::pair< TKey, TValue > > init)
	Construct map from initializer_list.
template<typename InputIt>
	FastHashMap (InputIt first, InputIt last)
	Construct map from iterator range.
	FastHashMap (size_t initialCapacity)
	Constructor with specified initial capacity.
	FastHashMap (FastHashMap &&) noexcept
	Move constructor.
FastHashMap &	operator= (FastHashMap &&) noexcept
	Move assignment operator.
	FastHashMap (const FastHashMap &)=default
	Copy constructor.
FastHashMap &	operator= (const FastHashMap &)=default
	Copy assignment operator.
	~FastHashMap ()=default
	Destructor.
template<typename KeyType = TKey>
TValue *	find (const KeyType &key) noexcept
	Fast lookup with heterogeneous key types (C++ idiom: pointer return).
template<typename KeyType = TKey>
const TValue *	find (const KeyType &key) const noexcept
	Fast const lookup with heterogeneous key types (C++ idiom: pointer return).
template<typename KeyType = TKey>
bool	contains (const KeyType &key) const noexcept
	Check if a key exists in the map.
TValue &	at (const TKey &key)
	Checked element access with bounds checking.
const TValue &	at (const TKey &key) const
	Checked const element access with bounds checking.
TValue &	operator[] (const TKey &key)
	STL-compatible subscript operator (insert-if-missing).
TValue &	operator[] (TKey &&key)
	STL-compatible subscript operator with move semantics.
template<typename KeyType = TKey>
TValue &	at (const KeyType &key)
	Checked element access with bounds checking.
template<typename KeyType = TKey>
const TValue &	at (const KeyType &key) const
	Checked const element access with bounds checking.
bool	insert (const TKey &key, const TValue &value)
	Insert a key-value pair only if key doesn't exist (copy semantics).
bool	insert (const TKey &key, TValue &&value)
	Insert a key-value pair only if key doesn't exist (move semantics).
bool	insert (TKey &&key, TValue &&value)
	Insert a key-value pair only if key doesn't exist (perfect forwarding).
void	insertOrAssign (const TKey &key, TValue &&value)
	Insert or update a key-value pair (move semantics).
void	insertOrAssign (const TKey &key, const TValue &value)
	Insert or update a key-value pair (copy semantics).
void	insertOrAssign (TKey &&key, TValue &&value)
	Insert or update a key-value pair (perfect forwarding for both key and value).
template<typename... Args>
void	emplace (const TKey &key, Args &&... args)
	Emplace a value in-place for the given key.
template<typename... Args>
void	emplace (TKey &&key, Args &&... args)
	Emplace a value in-place for the given key (move key).
template<typename... Args>
std::pair< Iterator, bool >	tryEmplace (const TKey &key, Args &&... args)
	Try to emplace a value if key doesn't exist.
template<typename... Args>
std::pair< Iterator, bool >	tryEmplace (TKey &&key, Args &&... args)
	Try to emplace a value if key doesn't exist.
void	reserve (size_t minCapacity)
	Reserve capacity for at least the specified number of elements.
template<typename KeyType = TKey>
bool	erase (const KeyType &key) noexcept
	Remove a key-value pair from the map.
Iterator	erase (ConstIterator pos) noexcept
	Erase element at iterator position.
Iterator	erase (ConstIterator first, ConstIterator last) noexcept
	Erase range of elements.
void	clear () noexcept
	Clear all elements from the map.
template<typename KeyType = TKey>
std::optional< std::pair< TKey, TValue > >	extract (const KeyType &key)
	Extract a key-value pair from the map without destroying it.
void	merge (FastHashMap &other)
	Merge another FastHashMap into this one.
void	merge (FastHashMap &&other)
	Merge another FastHashMap into this one (rvalue overload).
size_t	size () const noexcept
	Get the number of elements in the map.
size_t	capacity () const noexcept
	Get the current capacity of the hash table.
bool	isEmpty () const noexcept
	Check if the map is empty.
void	swap (FastHashMap &other) noexcept
	Swap contents with another map.
Iterator	begin () noexcept
	Get iterator to beginning of occupied buckets.
ConstIterator	begin () const noexcept
	Get const iterator to beginning of occupied buckets.
Iterator	end () noexcept
	Get iterator to end (past last occupied bucket).
ConstIterator	end () const noexcept
	Get const iterator to end (past last occupied bucket).
ConstIterator	cbegin () const noexcept
	Get const iterator to beginning of occupied buckets (explicit const).
ConstIterator	cend () const noexcept
	Get const iterator to end (explicit const).
bool	operator== (const FastHashMap &other) const noexcept
	Compare two HashMaps for equality.

Detailed Description

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>
class nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >

Hash map with Robin Hood hashing for bounded probe distances.

Template Parameters

TKey	Key type (supports heterogeneous lookup for compatible types)
TValue	Value type
HashType	Hash type - uint32_t or uint64_t (default: uint32_t)
Seed	Hash seed value for initialization (default: FNV offset basis for HashType)
THasher	Hash functor type (default: hashing::Hasher<HashType, Seed>)
KeyEqual	Key equality comparator (default: std::equal_to<> for transparent comparison)

Definition at line 74 of file FastHashMap.h.

Member Typedef Documentation

◆ const_iterator

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

using nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::const_iterator = ConstIterator

Type alias for const iterator.

Definition at line 129 of file FastHashMap.h.

◆ difference_type

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

using nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::difference_type = std::ptrdiff_t

Type alias for difference type.

Definition at line 123 of file FastHashMap.h.

◆ hash_type

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

using nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::hash_type = HashType

Type alias for hash type (uint32_t or uint64_t).

Definition at line 117 of file FastHashMap.h.

◆ hasher

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

using nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::hasher = THasher

Type alias for hasher type.

Definition at line 111 of file FastHashMap.h.

◆ iterator

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

using nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::iterator = Iterator

Type alias for iterator.

Definition at line 126 of file FastHashMap.h.

◆ key_equal

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

using nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::key_equal = KeyEqual

Type alias for key equality comparator.

Definition at line 114 of file FastHashMap.h.

◆ key_type

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

using nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::key_type = TKey

Type alias for key type.

Definition at line 102 of file FastHashMap.h.

◆ mapped_type

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

using nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::mapped_type = TValue

Type alias for mapped value type.

Definition at line 105 of file FastHashMap.h.

◆ size_type

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

using nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::size_type = size_t

Type alias for size type.

Definition at line 120 of file FastHashMap.h.

◆ value_type

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

using nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::value_type = std::pair<const TKey, TValue>

Type alias for key-value pair type.

Definition at line 108 of file FastHashMap.h.

Constructor & Destructor Documentation

◆ FastHashMap() [1/3]

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::FastHashMap ( std::initializer_list< std::pair< TKey, TValue > > init )

inline

Construct map from initializer_list.

Parameters

init	Initializer list of key/value pairs

◆ FastHashMap() [2/3]

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

template<typename InputIt>

nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::FastHashMap	(	InputIt	first,
		InputIt	last )

inline

Construct map from iterator range.

Template Parameters

InputIt Input iterator type (must dereference to std::pair-like type)

Parameters

first	Beginning of range to copy from
last	End of range (exclusive)

◆ FastHashMap() [3/3]

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::FastHashMap ( size_t initialCapacity )

inlineexplicit

Constructor with specified initial capacity.

Parameters

initialCapacity Minimum initial capacity (rounded up to power of 2)

Member Function Documentation

◆ at() [1/4]

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

template<typename KeyType = TKey>

TValue & nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::at ( const KeyType & key )

inline

Checked element access with bounds checking.

Template Parameters

KeyType Key type (supports heterogeneous lookup)

Parameters

key	The key to access

Returns: Reference to the value associated with the key

Exceptions

std::out_of_range if key is not found

◆ at() [2/4]

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

template<typename KeyType = TKey>

const TValue & nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::at ( const KeyType & key ) const

inline

Checked const element access with bounds checking.

Template Parameters

KeyType Key type (supports heterogeneous lookup)

Parameters

key	The key to access

Returns: Const reference to the value associated with the key

Exceptions

std::out_of_range if key is not found

◆ at() [3/4]

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

TValue & nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::at ( const TKey & key )

inline

Checked element access with bounds checking.

Parameters

key	The key to access

Returns: Reference to the value associated with the key

Exceptions

std::out_of_range if key is not found

◆ at() [4/4]

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

const TValue & nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::at ( const TKey & key ) const

inline

Checked const element access with bounds checking.

Parameters

key	The key to access

Returns: Const reference to the value associated with the key

Exceptions

std::out_of_range if key is not found

◆ begin() [1/2]

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

ConstIterator nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::begin ( ) const

nodiscardnoexcept

Get const iterator to beginning of occupied buckets.

Returns: Const iterator pointing to first key-value pair

Note: This function is marked [[nodiscard]] - the return value should not be ignored

◆ begin() [2/2]

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

Iterator nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::begin ( )

nodiscardnoexcept

Get iterator to beginning of occupied buckets.

Returns: Iterator pointing to first key-value pair

Note: This function is marked [[nodiscard]] - the return value should not be ignored

◆ capacity()

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

size_t nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::capacity ( ) const

inlinenodiscardnoexcept

Get the current capacity of the hash table.

Returns: Maximum elements before resize (always power of 2)

◆ cbegin()

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

ConstIterator nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::cbegin ( ) const

nodiscardnoexcept

Get const iterator to beginning of occupied buckets (explicit const).

Returns: Const iterator pointing to first key-value pair

Note: This function is marked [[nodiscard]] - the return value should not be ignored

◆ cend()

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

ConstIterator nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::cend ( ) const

nodiscardnoexcept

Get const iterator to end (explicit const).

Returns: Const iterator pointing past the last key-value pair

Note: This function is marked [[nodiscard]] - the return value should not be ignored

◆ contains()

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

template<typename KeyType = TKey>

bool nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::contains ( const KeyType & key ) const

inlinenodiscardnoexcept

Check if a key exists in the map.

Template Parameters

KeyType Key type (supports heterogeneous lookup for compatible types)

Parameters

key	The key to search for

Returns: true if key exists, false otherwise

Note: This function is marked [[nodiscard]] - the return value should not be ignored

◆ emplace() [1/2]

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

template<typename... Args>

void nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::emplace	(	const TKey &	key,
		Args &&...	args )

inline

Emplace a value in-place for the given key.

Template Parameters

Args	Variadic template for value constructor arguments

Parameters

key	The key to insert or update
args	Arguments forwarded to TValue constructor

◆ emplace() [2/2]

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

template<typename... Args>

void nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::emplace	(	TKey &&	key,
		Args &&...	args )

inline

Emplace a value in-place for the given key (move key).

Template Parameters

Args	Variadic template for value constructor arguments

Parameters

key	The key to insert or update (rvalue reference - moved)
args	Arguments forwarded to TValue constructor

◆ end() [1/2]

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

ConstIterator nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::end ( ) const

nodiscardnoexcept

Get const iterator to end (past last occupied bucket).

Returns: Const iterator pointing past the last key-value pair

Note: This function is marked [[nodiscard]] - the return value should not be ignored

◆ end() [2/2]

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

Iterator nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::end ( )

nodiscardnoexcept

Get iterator to end (past last occupied bucket).

Returns: Iterator pointing past the last key-value pair

Note: This function is marked [[nodiscard]] - the return value should not be ignored

◆ erase() [1/3]

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

template<typename KeyType = TKey>

bool nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::erase ( const KeyType & key )

inlinenoexcept

Remove a key-value pair from the map.

Template Parameters

KeyType Key type (supports heterogeneous lookup for compatible types)

Parameters

key	The key to remove

Returns: true if the key was found and removed, false otherwise

◆ erase() [2/3]

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

Iterator nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::erase	(	ConstIterator	first,
		ConstIterator	last )

inlinenoexcept

Erase range of elements.

Parameters

first	Beginning of range to erase
last	End of range to erase (exclusive)

Returns: Iterator to the element following the last erased element

◆ erase() [3/3]

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

Iterator nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::erase ( ConstIterator pos )

inlinenoexcept

Erase element at iterator position.

Parameters

pos	Iterator to element to erase

Returns: Iterator to the element following the erased element

Note: Iterator becomes invalid after erase

◆ extract()

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

template<typename KeyType = TKey>

std::optional< std::pair< TKey, TValue > > nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::extract ( const KeyType & key )

inlinenodiscard

Extract a key-value pair from the map without destroying it.

Template Parameters

KeyType Key type (supports heterogeneous lookup for compatible types)

Parameters

key	The key to extract

Returns: std::optional containing the extracted key-value pair if found, std::nullopt otherwise

Removes the element from the map and returns it without invoking destructors. This is useful for transferring ownership or moving elements between containers.

Note: This function is marked [[nodiscard]] - the return value should not be ignored

◆ find() [1/2]

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

template<typename KeyType = TKey>

const TValue * nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::find ( const KeyType & key ) const

inlinenodiscardnoexcept

Fast const lookup with heterogeneous key types (C++ idiom: pointer return).

Template Parameters

KeyType Key type (supports heterogeneous lookup for compatible types)

Parameters

key	The key to search for

Returns: Const pointer to the value if found, nullptr otherwise

◆ find() [2/2]

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

template<typename KeyType = TKey>

TValue * nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::find ( const KeyType & key )

inlinenodiscardnoexcept

Fast lookup with heterogeneous key types (C++ idiom: pointer return).

Template Parameters

KeyType Key type (supports heterogeneous lookup for compatible types)

Parameters

key	The key to search for

Returns: Pointer to the value if found, nullptr otherwise

◆ insert() [1/3]

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

bool nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::insert	(	const TKey &	key,
		const TValue &	value )

inline

Insert a key-value pair only if key doesn't exist (copy semantics).

Parameters

key	The key to insert
value	The value to associate with the key (copied)

Returns: true if key was inserted, false if key already exists (value unchanged)

Note: Does NOT overwrite existing values (unlike insertOrAssign)

◆ insert() [2/3]

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

bool nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::insert	(	const TKey &	key,
		TValue &&	value )

inline

Insert a key-value pair only if key doesn't exist (move semantics).

Parameters

key	The key to insert
value	The value to associate with the key (moved)

Returns: true if key was inserted, false if key already exists (value unchanged)

Note: Does NOT overwrite existing values (unlike insertOrAssign)

◆ insert() [3/3]

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

bool nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::insert	(	TKey &&	key,
		TValue &&	value )

inline

Insert a key-value pair only if key doesn't exist (perfect forwarding).

Parameters

key	The key to insert (moved)
value	The value to associate with the key (moved)

Returns: true if key was inserted, false if key already exists (value unchanged)

Note: Does NOT overwrite existing values (unlike insertOrAssign)

◆ insertOrAssign() [1/3]

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

void nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::insertOrAssign	(	const TKey &	key,
		const TValue &	value )

inline

Insert or update a key-value pair (copy semantics).

Parameters

key	The key to insert or update
value	The value to associate with the key (copied)

◆ insertOrAssign() [2/3]

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

void nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::insertOrAssign	(	const TKey &	key,
		TValue &&	value )

inline

Insert or update a key-value pair (move semantics).

Parameters

key	The key to insert or update
value	The value to associate with the key (moved)

◆ insertOrAssign() [3/3]

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

void nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::insertOrAssign	(	TKey &&	key,
		TValue &&	value )

inline

Insert or update a key-value pair (perfect forwarding for both key and value).

Parameters

key	The key to insert or update (forwarded)
value	The value to associate with the key (forwarded)

◆ isEmpty()

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

bool nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::isEmpty ( ) const

inlinenodiscardnoexcept

Check if the map is empty.

Returns: true if size() == 0, false otherwise

◆ merge() [1/2]

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

void nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::merge ( FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual > && other )

inline

Merge another FastHashMap into this one (rvalue overload).

Parameters

other The map to merge from (elements are moved)

Same as merge(FastHashMap&) but accepts rvalue references.

◆ merge() [2/2]

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

void nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::merge ( FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual > & other )

inline

Merge another FastHashMap into this one.

Parameters

other The map to merge from (elements are moved, not copied)

Attempts to insert each element from other into this map. Elements that already exist in this map are left in other. After the operation, other contains only elements that were not inserted.

◆ operator=() [1/2]

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

FastHashMap & nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::operator= ( const FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual > & )

default

Copy assignment operator.

Returns: Reference to this map

◆ operator=() [2/2]

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

FastHashMap & nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::operator= ( FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual > && )

noexcept

Move assignment operator.

Returns: Reference to this map

◆ operator==()

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

bool nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::operator== ( const FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual > & other ) const

nodiscardnoexcept

Compare two HashMaps for equality.

Parameters

other The other HashMap to compare with

Returns: true if both maps contain the same key-value pairs

Note: This function is marked [[nodiscard]] - the return value should not be ignored

◆ operator[]() [1/2]

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

TValue & nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::operator[] ( const TKey & key )

inline

STL-compatible subscript operator (insert-if-missing).

Parameters

key	The key to access or insert

Returns: Reference to the value associated with the key

If key doesn't exist, inserts default-constructed value. Requires TValue to be default-constructible.

Note: This function is NOT marked noexcept as it may insert/resize

◆ operator[]() [2/2]

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

TValue & nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::operator[] ( TKey && key )

inline

STL-compatible subscript operator with move semantics.

Parameters

key	The key to access or insert (moved if new)

Returns: Reference to the value associated with the key

If key doesn't exist, inserts default-constructed value. Requires TValue to be default-constructible.

Note: This function is NOT marked noexcept as it may insert/resize

◆ reserve()

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

void nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::reserve ( size_t minCapacity )

inline

Reserve capacity for at least the specified number of elements.

Parameters

minCapacity Minimum capacity to reserve

◆ size()

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

size_t nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::size ( ) const

inlinenodiscardnoexcept

Get the number of elements in the map.

Returns: Current number of key-value pairs stored

◆ swap()

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

void nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::swap ( FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual > & other )

inlinenoexcept

Swap contents with another map.

Parameters

other Map to swap with

Note: noexcept operation - just swaps internal pointers/values

◆ tryEmplace() [1/2]

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

template<typename... Args>

std::pair< Iterator, bool > nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::tryEmplace	(	const TKey &	key,
		Args &&...	args )

inline

Try to emplace a value if key doesn't exist.

Template Parameters

Args	Variadic template for value constructor arguments

Parameters

key	The key to insert (const reference)
args	Arguments forwarded to TValue constructor (only used if key doesn't exist)

Returns: Pair of iterator to element and bool (true if inserted, false if key existed)

Note: More efficient than emplace() - doesn't construct value if key exists

◆ tryEmplace() [2/2]

template<typename TKey, typename TValue, hashing::Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? hashing::constants::FNV_OFFSET_BASIS_32 : hashing::constants::FNV_OFFSET_BASIS_64 ), typename THasher = hashing::Hasher<HashType, Seed>, typename KeyEqual = std::equal_to<>>

template<typename... Args>

std::pair< Iterator, bool > nfx::containers::FastHashMap< TKey, TValue, HashType, Seed, THasher, KeyEqual >::tryEmplace	(	TKey &&	key,
		Args &&...	args )

inline

Try to emplace a value if key doesn't exist.

Template Parameters

Args	Variadic template for value constructor arguments

Parameters

key	The key to insert (rvalue reference - moved only if inserted)
args	Arguments forwarded to TValue constructor (only used if key doesn't exist)

Returns: Pair of iterator to element and bool (true if inserted, false if key existed)

Note: More efficient than emplace() - doesn't construct value if key exists

The documentation for this class was generated from the following file:

FastHashMap.h

Classes

Public Types

Public Member Functions

Detailed Description

Member Typedef Documentation

◆ const_iterator

◆ difference_type

◆ hash_type

◆ hasher

◆ iterator

◆ key_equal

◆ key_type

◆ mapped_type

◆ size_type

◆ value_type

Constructor & Destructor Documentation

◆ FastHashMap() [1/3]

◆ FastHashMap() [2/3]

◆ FastHashMap() [3/3]

Member Function Documentation

◆ at() [1/4]

◆ at() [2/4]

◆ at() [3/4]

◆ at() [4/4]

◆ begin() [1/2]

◆ begin() [2/2]

◆ capacity()

◆ cbegin()

◆ cend()

◆ contains()

◆ emplace() [1/2]

◆ emplace() [2/2]

◆ end() [1/2]

◆ end() [2/2]

◆ erase() [1/3]

◆ erase() [2/3]

◆ erase() [3/3]

◆ extract()

◆ find() [1/2]

◆ find() [2/2]

◆ insert() [1/3]

◆ insert() [2/3]

◆ insert() [3/3]

◆ insertOrAssign() [1/3]

◆ insertOrAssign() [2/3]

◆ insertOrAssign() [3/3]

◆ isEmpty()

◆ merge() [1/2]

◆ merge() [2/2]

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ operator==()

◆ operator[]() [1/2]

◆ operator[]() [2/2]

◆ reserve()

◆ size()

◆ swap()

◆ tryEmplace() [1/2]

◆ tryEmplace() [2/2]