HashSet< T, HASH, ENTRY_HANDLER, ALLOCATOR, MODE, INITIAL_CAPACITY, LOAD_FACTOR > Class Template Reference

#include <hashmap.h>

Inheritance diagram for HashSet< T, HASH, ENTRY_HANDLER, ALLOCATOR, MODE, INITIAL_CAPACITY, LOAD_FACTOR >:

Detailed Description

template<typename T, typename HASH = DefaultCompare, typename ENTRY_HANDLER = HashMapKeyValuePair, typename ALLOCATOR = DefaultAllocator, HASHMAP_MODE MODE = HASHMAP_MODE::DEFAULT, Int INITIAL_CAPACITY = 16, Int LOAD_FACTOR = (MODE == HASHMAP_MODE::SYNCHRONIZED) ? 0 : 10>
class maxon::HashSet< T, HASH, ENTRY_HANDLER, ALLOCATOR, MODE, INITIAL_CAPACITY, LOAD_FACTOR >

A HashSet is an implementation of a set based on hash codes for the elements. Internally, it is just a HashMap with no values. See HashMap for the details of hash code computation, load factors, performance etc.

This example shows the basic usage of HashSet:

HashSet<String> names;
if (!names.Insert("Alice"_s))
... allocation failed ...;
Bool added = false;
if (!names.Insert("Bob"_s, added))
... allocation failed ...;
if (added)
... "Bob" didn't exist before in names ...;
if (names.Contains("Cindy"_s))
... "Cindy" is in the set ...;
names.Erase("Bob"_s);
maxon::Bool Bool
Definition: ge_sys_math.h:55

To iterate over the entries of a HashSet, use Iterator, ConstIterator or a ranged-based for loop:

for (HashSet<String>::ConstIterator i = names.Begin(); i != names.End(); ++i)
{
DiagnosticOutput("Names contains @ ", *i);
}
for (const String& n : names)
{
DiagnosticOutput("Names contains @ ", n);
}
Definition: c4d_string.h:39
typename Super::ConstKeyIterator ConstIterator
Definition: hashmap.h:3156
#define DiagnosticOutput(formatString,...)
Definition: debugdiagnostics.h:176
Template Parameters
TType of elements of the set.
HASHClass to be used to compute the hash code of elements, and to compare elements for equality (DefaultCompare by default)
ENTRY_HANDLERUse this class to select the memory layout of entries (either the default HashMapKeyValuePair or HashMapKeyHashValuePair).
ALLOCATORClass for memory allocation.
See also
HashMap
$ref sets

Classes

struct  LambdaEntryConstructor
 

Public Types

using MapType = HashMap< T, UnitType, HASH, ENTRY_HANDLER, ALLOCATOR, MODE, INITIAL_CAPACITY, LOAD_FACTOR >
 
using Super = SetBase< HashSet, T, Protected< MapType >, HASH >
 
using IsHashMap = std::true_type
 
using IsHashSet = std::true_type
 
using Iterator = typename Super::KeyIterator
 
using ConstIterator = typename Super::ConstKeyIterator
 
- Public Types inherited from SetBase0< COLLECTION, VALUETYPE, SUPER, HASH >
using SetType = COLLECTION
 
- Public Types inherited from Collection< COLLECTION, VALUETYPE, SUPER >
using Super = BaseCollection< COLLECTION, SUPER >
 
using ValueType = VALUETYPE
 
- Public Types inherited from BaseCollection< COLLECTION, SUPER >
using IsCollection = std::true_type
 
using IsBaseArray = std::false_type
 

Public Member Functions

 HashSet (const ALLOCATOR &alloc)
 
 HashSet ()=default
 
 HashSet (HashSet &&src)
 
 MAXON_OPERATOR_MOVE_ASSIGNMENT (HashSet)
 
HashInt GetHashCode () const
 
MapTypeGetMap ()
 
const MapTypeGetMap () const
 
Bool Contains (typename ByValueParam< T >::type value) const
 
template<typename KEY , typename KEYHASH >
Bool Contains (const KEY &key) const
 
void Insert () const
 
ResultRef< typename Super::Entry > Insert (const T &value, Bool &added=BoolLValue())
 
ResultRef< typename Super::Entry > Insert (T &&value, Bool &added=BoolLValue())
 
ResultRef< const T > InsertKey (const T &value, Bool &added=BoolLValue())
 
ResultRef< const T > InsertKey (T &&value, Bool &added=BoolLValue())
 
template<typename KEYHASH = HASH, typename KEY , typename LAMBDA >
Result< Entry * > InsertLambda (KEY &&key, LAMBDA &&lambda)
 
ResultOk< BoolErase (const T &value)
 
ResultOk< void > Erase (const Entry *entry)
 
ConstIterator Begin () const
 
ConstIterator End () const
 
Iterator Begin ()
 
Iterator End ()
 
Iterator Erase (const Iterator &it)
 
template<typename KEYHASH = HASH, typename KEY >
Entry * Find (const KEY &key)
 
template<typename KEYHASH = HASH, typename KEY >
const Entry * Find (const KEY &key) const
 
ResultRef< Entry > InsertEntry (const K &key, Bool &created=BoolLValue())
 
ResultRef< Entry > InsertEntry (K &&key, Bool &created=BoolLValue())
 
template<typename KEYHASH = HASH, typename KEY >
ResultRef< Entry > InsertEntry (KEY &&key, Bool &created=BoolLValue())
 
template<typename KEYHASH = HASH, typename KEY , typename C >
Result< Entry * > InsertCtor (KEY &&key, C &&constructor, Bool &created=BoolLValue())
 
Int GetCount () const
 
Int GetOperationCountForSearch () const
 
ResultMem SetCapacityHint (Int capacity, COLLECTION_RESIZE_FLAGS resizeFlags=COLLECTION_RESIZE_FLAGS::ON_GROW_RESERVE_CAPACITY)
 
ResultMem ResizeTable (Int capacity)
 
void Reset ()
 
void Flush ()
 
template<typename SET >
Result< void > IntersectImpl (SET &&set, OverloadRank0)
 
Int GetMemorySize () const
 
- Public Member Functions inherited from SetBase< HashSet< T, DefaultCompare, HashMapKeyValuePair, DefaultAllocator, HASHMAP_MODE::DEFAULT, 16,(HASHMAP_MODE::DEFAULT==HASHMAP_MODE::SYNCHRONIZED) ? 0 :10 >, T, Protected< HashMap< T, UnitType, DefaultCompare, HashMapKeyValuePair, DefaultAllocator, HASHMAP_MODE::DEFAULT, 16,(HASHMAP_MODE::DEFAULT==HASHMAP_MODE::SYNCHRONIZED) ? 0 :10 > >, DefaultCompare >
MAXON_ATTRIBUTE_FORCE_INLINE SetBase (ARGS &&... args)
 
SetImpl< HashSet< T, DefaultCompare, HashMapKeyValuePair, DefaultAllocator, HASHMAP_MODE::DEFAULT, 16,(HASHMAP_MODE::DEFAULT==HASHMAP_MODE::SYNCHRONIZED) ? 0 :10 > & > ToSet ()
 
SetImpl< const HashSet< T, DefaultCompare, HashMapKeyValuePair, DefaultAllocator, HASHMAP_MODE::DEFAULT, 16,(HASHMAP_MODE::DEFAULT==HASHMAP_MODE::SYNCHRONIZED) ? 0 :10 > & > ToSet () const
 
MAXON_ATTRIBUTE_FORCE_INLINE operator SetImpl< HashSet< T, DefaultCompare, HashMapKeyValuePair, DefaultAllocator, HASHMAP_MODE::DEFAULT, 16,(HASHMAP_MODE::DEFAULT==HASHMAP_MODE::SYNCHRONIZED) ? 0 :10 > & > ()
 
MAXON_ATTRIBUTE_FORCE_INLINE operator SetImpl< const HashSet< T, DefaultCompare, HashMapKeyValuePair, DefaultAllocator, HASHMAP_MODE::DEFAULT, 16,(HASHMAP_MODE::DEFAULT==HASHMAP_MODE::SYNCHRONIZED) ? 0 :10 > & > () const
 
- Public Member Functions inherited from SetBase0< COLLECTION, VALUETYPE, SUPER, HASH >
template<typename... ARGS>
MAXON_ATTRIBUTE_FORCE_INLINE SetBase0 (ARGS &&... args)
 
MAXON_ATTRIBUTE_FORCE_INLINE ResultRef< const VALUETYPEAppend (typename ByValueParam< VALUETYPE >::type v)
 
template<typename COLLECTION2 >
Bool ContainsAllImpl (COLLECTION2 &&other, OverloadRank0) const
 
template<typename COLLECTION2 >
MAXON_ATTRIBUTE_FORCE_INLINE Result< void > Add (COLLECTION2 &&other, COLLECTION_RESIZE_FLAGS resizeFlags=COLLECTION_RESIZE_FLAGS::ON_GROW_RESERVE_CAPACITY)
 
template<typename COLLECTION2 >
MAXON_ATTRIBUTE_FORCE_INLINE Result< void > AppendAll (COLLECTION2 &&other, COLLECTION_RESIZE_FLAGS resizeFlags=COLLECTION_RESIZE_FLAGS::ON_GROW_RESERVE_CAPACITY)
 
template<typename COLLECTION2 >
MAXON_ATTRIBUTE_FORCE_INLINE Result< void > CopyFrom (COLLECTION2 &&other, COLLECTION_RESIZE_FLAGS resizeFlags=COLLECTION_RESIZE_FLAGS::FIT_TO_SIZE)
 
template<typename COLLECTION2 >
Result< void > SubtractImpl (COLLECTION2 &&other, OverloadRank0)
 
template<typename COLLECTION2 , typename COMPARE >
Bool IsEqualImpl (const COLLECTION2 &other, COMPARE &&cmp, OverloadRank0) const
 
HashInt GetHashCode () const
 
- Public Member Functions inherited from Collection< COLLECTION, VALUETYPE, SUPER >
template<typename... ARGS>
MAXON_ATTRIBUTE_FORCE_INLINE Collection (ARGS &&... args)
 
ResultOk< void > VariadicAppend ()
 
template<typename V , typename... VALUES>
Result< void > VariadicAppend (V &&value, VALUES &&... rest)
 
 operator ValueReceiver< const VALUETYPE & > ()
 
 operator ValueReceiver< VALUETYPE && > ()
 
 operator ValueReceiver< typename std::conditional< STD_IS_REPLACEMENT (scalar, VALUETYPE)
 
DummyParamType & type ()
 
template<typename FN >
Result< BoolForEach (FN &&callback) const
 
template<typename FN >
Result< BoolForEach (FN &&callback)
 
template<typename H = COLLECTION>
H::Iterator Find (typename ByValueParam< VALUETYPE >::type v)
 
template<typename H = COLLECTION>
H::ConstIterator Find (typename ByValueParam< VALUETYPE >::type v) const
 
Int FindIndex (typename ByValueParam< VALUETYPE >::type v) const
 
MAXON_ATTRIBUTE_FORCE_INLINE Bool Contains (typename ByValueParam< VALUETYPE >::type v) const
 
- Public Member Functions inherited from BaseCollection< COLLECTION, SUPER >
template<typename... ARGS>
MAXON_ATTRIBUTE_FORCE_INLINE BaseCollection (ARGS &&... args)
 
template<typename COLLECTION2 >
MAXON_ATTRIBUTE_FORCE_INLINE std::enable_if< maxon::IsCollection< COLLECTION2 >::value, Bool >::type operator== (const COLLECTION2 &other) const
 
template<typename COLLECTION2 >
MAXON_ATTRIBUTE_FORCE_INLINE std::enable_if< maxon::IsCollection< COLLECTION2 >::value, Bool >::type operator!= (const COLLECTION2 &other) const
 
template<typename COMPARE = EqualityCompare, typename COLLECTION2 >
MAXON_ATTRIBUTE_FORCE_INLINE std::enable_if< maxon::IsCollection< COLLECTION2 >::value &&!STD_IS_REPLACEMENT(same, typename std::decay< COMPARE >::type, EQUALITY), Bool >::type IsEqual (const COLLECTION2 &other, COMPARE &&cmp=COMPARE()) const
 
template<typename COLLECTION2 >
MAXON_ATTRIBUTE_FORCE_INLINE Result< void > AppendAll (COLLECTION2 &&other, COLLECTION_RESIZE_FLAGS resizeFlags=COLLECTION_RESIZE_FLAGS::ON_GROW_RESERVE_CAPACITY)
 
template<typename COLLECTION2 >
MAXON_ATTRIBUTE_FORCE_INLINE Result< void > CopyFrom (COLLECTION2 &&other, COLLECTION_RESIZE_FLAGS resizeFlags=COLLECTION_RESIZE_FLAGS::FIT_TO_SIZE)
 
template<typename COLLECTION2 >
MAXON_ATTRIBUTE_FORCE_INLINE Result< void > Subtract (COLLECTION2 &&other)
 
template<typename COLLECTION2 >
MAXON_ATTRIBUTE_FORCE_INLINE Result< void > Intersect (const COLLECTION2 &other)
 
template<typename COLLECTION2 >
Bool Intersects (const COLLECTION2 &other) const
 
template<typename COLLECTION2 >
MAXON_ATTRIBUTE_FORCE_INLINE Result< void > CopyFromImpl (COLLECTION2 &&other, COLLECTION_RESIZE_FLAGS resizeFlags, OverloadRank0)
 
template<typename COLLECTION2 >
Result< void > AppendAllImpl (COLLECTION2 &&other, COLLECTION_RESIZE_FLAGS resizeFlags, Bool overwrite, OverloadRank0)
 
template<typename COLLECTION2 >
Result< void > IntersectImpl (COLLECTION2 &&other, OverloadRank0)
 
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsEmpty () const
 
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsPopulated () const
 
String ToString (const FormatStatement *formatStatement=nullptr) const
 
template<typename COLLECTION2 >
MAXON_ATTRIBUTE_FORCE_INLINE Bool ContainsAll (COLLECTION2 &&other) const
 
template<typename COLLECTION2 >
Bool ContainsAllImpl (COLLECTION2 &&other, OverloadRank0) const
 

Public Attributes

friend MapType
 
- Public Attributes inherited from Collection< COLLECTION, VALUETYPE, SUPER >
 VALUETYPE
 

Private Member Functions

 MAXON_DISALLOW_COPY_AND_ASSIGN (HashSet)
 

Additional Inherited Members

- Static Public Member Functions inherited from Collection< COLLECTION, VALUETYPE, SUPER >
static const VALUETYPEGetMapKey (const VALUETYPE &key)
 
- Static Public Attributes inherited from SetBase0< COLLECTION, VALUETYPE, SUPER, HASH >
static const COLLECTION_KIND KIND
 

Member Typedef Documentation

◆ MapType

using MapType = HashMap<T, UnitType, HASH, ENTRY_HANDLER, ALLOCATOR, MODE, INITIAL_CAPACITY, LOAD_FACTOR>

◆ Super

using Super = SetBase<HashSet, T, Protected<MapType>, HASH>

◆ IsHashMap

using IsHashMap = std::true_type

◆ IsHashSet

using IsHashSet = std::true_type

◆ Iterator

using Iterator = typename Super::KeyIterator

◆ ConstIterator

using ConstIterator = typename Super::ConstKeyIterator

Constructor & Destructor Documentation

◆ HashSet() [1/3]

HashSet ( const ALLOCATOR &  alloc)
explicit

Initializes the underlying allocator and constructs a new HashSet with an optional load factor. This will not allocate any memory. Memory allocation can be done explicitly by SetCapacityHint(), or it will be done implicitly when needed.

Parameters
[in]allocUsed to initialize the underlying allocator by its copy constructor.

◆ HashSet() [2/3]

HashSet ( )
default

Constructs a new HashSet with an optional load factor. This will not allocate any memory. Memory allocation can be done explicitly by SetCapacityHint(), or it will be done implicitly when needed.

◆ HashSet() [3/3]

HashSet ( HashSet< T, HASH, ENTRY_HANDLER, ALLOCATOR, MODE, INITIAL_CAPACITY, LOAD_FACTOR > &&  src)

Member Function Documentation

◆ MAXON_DISALLOW_COPY_AND_ASSIGN()

MAXON_DISALLOW_COPY_AND_ASSIGN ( HashSet< T, HASH, ENTRY_HANDLER, ALLOCATOR, MODE, INITIAL_CAPACITY, LOAD_FACTOR >  )
private

◆ MAXON_OPERATOR_MOVE_ASSIGNMENT()

MAXON_OPERATOR_MOVE_ASSIGNMENT ( HashSet< T, HASH, ENTRY_HANDLER, ALLOCATOR, MODE, INITIAL_CAPACITY, LOAD_FACTOR >  )

◆ GetHashCode()

HashInt GetHashCode ( ) const

◆ GetMap() [1/2]

MapType& GetMap ( )

◆ GetMap() [2/2]

const MapType& GetMap ( ) const

◆ Contains() [1/2]

Bool Contains ( typename ByValueParam< T >::type  value) const

Checks if this set contains value.

Parameters
[in]valueThe value to check.
Returns
True if this set contains value.

◆ Contains() [2/2]

Bool Contains ( const KEY &  key) const

Checks if this set contains key. The type KEY of the given key need not be the same as V, but then you have to provide an additional class KEYHASH to compute the hash code of the specified key (function KEYHASH::GetHashCode(const KEY&)), and to compare a key of type KEY with a key of type V for equality (function KEYHASH::IsEqual(const KEY&, const V&)) unless the default HASH class is already able to do so.

Template Parameters
KEYHASHHash class to compute the hash code of key, and to compare key with the map's keys. Default is HASH.
KEYType of key.
Parameters
[in]keyThe value to check.
Returns
True if this set contains value.

◆ Insert() [1/3]

void Insert ( ) const

◆ Insert() [2/3]

ResultRef<typename Super::Entry> Insert ( const T &  value,
Bool added = BoolLValue() 
)

Adds value to this set. If value is already contained in this set, nothing happens, and added is set to false.

Parameters
[in]valueValue to add to this set.
[out]addedThis will be set to true if the element didn't exist before in the set and it could be added successfully, otherwise it will be set to false.
Returns
Element reference or OutOfMemoryError if the allocation failed.

◆ Insert() [3/3]

ResultRef<typename Super::Entry> Insert ( T &&  value,
Bool added = BoolLValue() 
)

Adds value to this set. If value is already contained in this set, nothing happens, and added is set to false.

Parameters
[in]valueValue to add to this set. When a new element has to be added, value will be moved into the new element.
[out]addedThis will be set to true if the element didn't exist before in the set and it could be added successfully, otherwise it will be set to false.
Returns
Element reference or OutOfMemoryError if the allocation failed.

◆ InsertKey() [1/2]

ResultRef<const T> InsertKey ( const T &  value,
Bool added = BoolLValue() 
)

Adds value to this set. If value is already contained in this set, nothing happens, and added is set to false.

Parameters
[in]valueValue to add to this set.
[out]addedThis will be set to true if the element didn't exist before in the set and it could be added successfully, otherwise it will be set to false.
Returns
Pointer to the value in the set, or nullptr if the element had to be added, but the allocation failed.

◆ InsertKey() [2/2]

ResultRef<const T> InsertKey ( T &&  value,
Bool added = BoolLValue() 
)

Adds value to this set. If value is already contained in this set, nothing happens, and added is set to false.

Parameters
[in]valueValue to add to this set. When a new element has to be added, value will be moved into the new element.
[out]addedThis will be set to true if the element didn't exist before in the set and it could be added successfully, otherwise it will be set to false.
Returns
Pointer to the value in the set, or nullptr if the element had to be added, but the allocation failed.

◆ InsertLambda()

Result<Entry*> InsertLambda ( KEY &&  key,
LAMBDA &&  lambda 
)

Adds an entry corresponding to the given key if such an entry doesn't exist yet. If a new entry has to be created, the passed lambda function is invoked with the key as first argument and the value (of type T&) of the newly created entry as second argument. The lambda then has to initialize the value correctly. The lambda function has to return Result<void>.

The type KEY of the given key need not be the same as T, but then you have to provide an additional class KEYHASH to compute the hash code of the specified key (function KEYHASH::GetHashCode(const KEY&)), and to compare a key of type KEY with a key of type T for equality (function KEYHASH::IsEqual(const KEY&, const T&)) unless the default HASH class is already able to do so.

Within the lambda you must not make any additional change to the hash set.

Template Parameters
KEYHASHHash class to compute the hash code of key, and to compare key with the map's keys. Default is HASH.
KEYType of key.
LAMBDAType of the function.
Parameters
[in]keyKey of the entry to find or create.
[in]lambdaThe function which will be invoked as return lambda(key, value); to initialize the value of a newly created entry.
Returns
Entry for the given key, or nullptr if the entry didn't exist and allocation of a new entry failed.

◆ Erase() [1/3]

ResultOk<Bool> Erase ( const T &  value)

Remove value from this set. If value isn't contained in this set, nothing happens.

Parameters
[in]valueValue to remove from this set.
Returns
True if an entry was found and removed for #value, otherwise false.

◆ Erase() [2/3]

ResultOk<void> Erase ( const Entry *  entry)

◆ Begin() [1/2]

ConstIterator Begin ( ) const

◆ End() [1/2]

ConstIterator End ( ) const

◆ Begin() [2/2]

Iterator Begin ( )

◆ End() [2/2]

Iterator End ( )

◆ Erase() [3/3]

Iterator Erase ( const Iterator it)

◆ Find() [1/2]

Entry* Find ( typename KEYHASH  = HASH,
typename KEY   
)

Finds the entry with the given key in this map. The type KEY of the given key need not be the same as K, but then you have to provide an additional class KEYHASH to compute the hash code of the specified key (function KEYHASH::GetHashCode(const KEY&)), and to compare a key of type KEY with a key of type K for equality (function KEYHASH::IsEqual(const KEY&, const K&)) unless the default HASH class is already able to do so.

Template Parameters
KEYHASHHash class to compute the hash code of key, and to compare key with the map's keys. Default is HASH.
KEYType of key.
Parameters
[in]keyKey to search for.
Returns
Entry having the given key, or nullptr if no such entry exists in this map.

◆ Find() [2/2]

const Entry* Find ( typename KEYHASH  = HASH,
typename KEY   
)

Finds the entry with the given key in this map. The type KEY of the given key need not be the same as K, but then you have to provide an additional class KEYHASH to compute the hash code of the specified key (function KEYHASH::GetHashCode(const KEY&)), and to compare a key of type KEY with a key of type K for equality (function KEYHASH::IsEqual(const KEY&, const K&)) unless the default HASH class is already able to do so.

Template Parameters
KEYHASHHash class to compute the hash code of key, and to compare key with the map's keys. Default is HASH.
KEYType of key.
Parameters
[in]keyKey to search for.
Returns
Entry having the given key, or nullptr if no such entry exists in this map.

◆ InsertEntry() [1/3]

ResultRef<Entry> InsertEntry

Finds the entry with the given key, or creates such an entry if it doesn't exist yet. The value of a new entry has to be initialized afterwards (but its default constructor has already been invoked).

Parameters
[in]keyKey of the entry to find or create.
[out]createdThis will be set to true if a new entry has been created successfully, otherwise it will be set to false.
Returns
Entry for the given key, or nullptr if the entry didn't exist and allocation of a new entry failed.

◆ InsertEntry() [2/3]

ResultRef<Entry> InsertEntry

Finds the entry with the given key, or creates such an entry if it doesn't exist yet. The value of a new entry has to be initialized afterwards (but its default constructor has already been invoked).

Parameters
[in]keyKey of the entry to find or create. If a new entry is created, its key will be constructed by move-semantics if possible.
[out]createdThis will be set to true if a new entry has been created successfully, otherwise it will be set to false.
Returns
Entry for the given key, or nullptr if the entry didn't exist and allocation of a new entry failed.

◆ InsertEntry() [3/3]

ResultRef<Entry> InsertEntry ( typename KEYHASH  = HASH,
typename KEY   
)

Finds the entry with the given key, or creates such an entry if it doesn't exist yet. The value of a new entry has to be initialized afterwards (but its default constructor has already been invoked). The type KEY of the given key need not be the same as K, but then you have to provide an additional class KEYHASH to compute the hash code of the specified key (function KEYHASH::GetHashCode(const KEY&)), and to compare a key of type KEY with a key of type K for equality (function KEYHASH::IsEqual(const KEY&, const K&)) unless the default HASH class is already able to do so.

Template Parameters
KEYHASHHash class to compute the hash code of key, and to compare key with the map's keys. Default is HASH.
KEYType of key.
Parameters
[in]keyKey of the entry to find or create.
[out]createdThis will be set to true if a new entry has been created successfully, otherwise it will be set to false.
Returns
Entry for the given key, or nullptr if the entry didn't exist and allocation of a new entry failed.

◆ InsertCtor()

Result<Entry*> InsertCtor ( typename KEYHASH  = HASH,
typename KEY  ,
typename C   
)

Finds the entry with the given key, or creates such an entry if it doesn't exist yet. If a new entry has to be created, it is constructed with the help of the object passed to the constructor parameter: Its class C has to provide a function Int C::GetHashMapEntrySize(const K& key) to compute the size of a new entry for key and a function Result<void> C::ConstructHashMapEntry(void* ptr, HashInt hash, const K& key) which uses the memory in ptr to construct a new entry for the key. If the constructor does not initialize the value of the new entry, this has to be done afterwards.

The type KEY of the given key need not be the same as K, but then you have to provide an additional class KEYHASH to compute the hash code of the specified key (function KEYHASH::GetHashCode(const KEY&)), and to compare a key of type KEY with a key of type K for equality (function KEYHASH::IsEqual(const KEY&, const K&)) unless the default HASH class is already able to do so.

Template Parameters
KEYHASHHash class to compute the hash code of key, and to compare key with the map's keys. Default is HASH.
KEYType of key.
CType of the constructor argument.
Parameters
[in]keyKey of the entry to find or create.
[in]constructorThe functions constructor.GetHashMapEntrySize(ptr, hash, key) and constructor.ConstructHashMapEntry(ptr, hash, key) will be used to construct a new entry from the memory in ptr.
[out]createdThis will be set to true if a new entry has been created successfully, otherwise it will be set to false.
Returns
Entry for the given key, or nullptr if the entry didn't exist and allocation of a new entry failed.

◆ GetCount()

Int GetCount ( void  )

Returns the number of entries in this map.

Returns
Number of entries.

◆ GetOperationCountForSearch()

Int GetOperationCountForSearch

Returns an estimate of the number of operations needed to locate a given key in this map. This is used when two collections are compared: The iteration goes over the collection which would require more operations for search, and each entry is searched in the other collection.

Returns
Estimate for the number of operations.

◆ SetCapacityHint()

ResultMem SetCapacityHint

Ensures that the bucket table is large enough to hold at least capacity entries, taking into account the load factor (see explanation of the class HashMap itself).

Parameters
[in]capacityThe number of entries which can be stored without the need for re-hashing.
[in]resizeFlagsNot used by HashMap.
Returns
True if memory allocations succeeded.

◆ ResizeTable()

ResultMem ResizeTable

Resizes the bucket table of the HashMap. Usually, with a positive load factor, this is done automatically when needed. You can force a resize if you know that a large number of entries will be added, this will eliminate some intermediate resizing. For a non-positive load factor, you have to manually resize the table if advisable. This function can also be used to reduce the table size (it gets never reduced automatically).

Parameters
[in]capacityThe number of entries which can be stored without the need for re-hashing.
Returns
True if memory allocations succeeded. If not, the HashMap will still be in a valid state, but still with the previous table size.

◆ Reset()

void Reset ( void  )

Resets the map. This destructs all entries and frees any memory held by the map, so the map will be in a state as if it had been newly constructed.

See also
Flush()

◆ Flush()

void Flush ( void  )

Flushes the map. This destructs and frees all entries, but does not free the bucket table.

See also
Reset()

◆ IntersectImpl()

Result<void> IntersectImpl ( typename SET  )

Removes all entries from this map whose keys are not contained in set. A key is in set if set.Contains(key) returns true, or if that is not a valid expression, if set(key) returns true. I.e., you can use a lambda expression as set.

Parameters
[in]setA set with which this map gets intersected. Can be a lambda expression.
Template Parameters
SETType of set.

◆ GetMemorySize()

Int GetMemorySize ( void  )

Calculates the memory usage for this map. Keys and Values must have a public member GetMemorySize that return the element size.

Returns
Memory size in bytes.

Member Data Documentation

◆ MapType

friend MapType