FreeRDP/winpr/libwinpr/utils/collections/HashTable.c
2024-09-02 16:20:20 +02:00

872 lines
17 KiB
C

/**
* WinPR: Windows Portable Runtime
* System.Collections.Hashtable
*
* Copyright 2014 Marc-Andre Moreau <marcandre.moreau@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <winpr/config.h>
#include <winpr/crt.h>
#include <winpr/assert.h>
#include <winpr/collections.h>
/**
* This implementation is based on the public domain
* hash table implementation made by Keith Pomakis:
*
* http://www.pomakis.com/hashtable/hashtable.c
* http://www.pomakis.com/hashtable/hashtable.h
*/
typedef struct s_wKeyValuePair wKeyValuePair;
struct s_wKeyValuePair
{
void* key;
void* value;
wKeyValuePair* next;
BOOL markedForRemove;
};
struct s_wHashTable
{
BOOL synchronized;
CRITICAL_SECTION lock;
size_t numOfBuckets;
size_t numOfElements;
float idealRatio;
float lowerRehashThreshold;
float upperRehashThreshold;
wKeyValuePair** bucketArray;
HASH_TABLE_HASH_FN hash;
wObject key;
wObject value;
DWORD foreachRecursionLevel;
DWORD pendingRemoves;
};
BOOL HashTable_PointerCompare(const void* pointer1, const void* pointer2)
{
return (pointer1 == pointer2);
}
UINT32 HashTable_PointerHash(const void* pointer)
{
return ((UINT32)(UINT_PTR)pointer) >> 4;
}
BOOL HashTable_StringCompare(const void* string1, const void* string2)
{
if (!string1 || !string2)
return (string1 == string2);
return (strcmp((const char*)string1, (const char*)string2) == 0);
}
UINT32 HashTable_StringHash(const void* key)
{
UINT32 c = 0;
UINT32 hash = 5381;
const BYTE* str = (const BYTE*)key;
/* djb2 algorithm */
while ((c = *str++) != '\0')
hash = (hash * 33) + c;
return hash;
}
void* HashTable_StringClone(const void* str)
{
return winpr_ObjectStringClone(str);
}
void HashTable_StringFree(void* str)
{
winpr_ObjectStringFree(str);
}
static INLINE BOOL HashTable_IsProbablePrime(size_t oddNumber)
{
for (size_t i = 3; i < 51; i += 2)
{
if (oddNumber == i)
return TRUE;
else if (oddNumber % i == 0)
return FALSE;
}
return TRUE; /* maybe */
}
static INLINE size_t HashTable_CalculateIdealNumOfBuckets(wHashTable* table)
{
WINPR_ASSERT(table);
const float tmp = (table->numOfElements / table->idealRatio);
size_t idealNumOfBuckets = (size_t)tmp;
if (idealNumOfBuckets < 5)
idealNumOfBuckets = 5;
else
idealNumOfBuckets |= 0x01;
while (!HashTable_IsProbablePrime(idealNumOfBuckets))
idealNumOfBuckets += 2;
return idealNumOfBuckets;
}
static INLINE void HashTable_Rehash(wHashTable* table, size_t numOfBuckets)
{
UINT32 hashValue = 0;
wKeyValuePair* nextPair = NULL;
wKeyValuePair** newBucketArray = NULL;
WINPR_ASSERT(table);
if (numOfBuckets == 0)
numOfBuckets = HashTable_CalculateIdealNumOfBuckets(table);
if (numOfBuckets == table->numOfBuckets)
return; /* already the right size! */
newBucketArray = (wKeyValuePair**)calloc(numOfBuckets, sizeof(wKeyValuePair*));
if (!newBucketArray)
{
/*
* Couldn't allocate memory for the new array.
* This isn't a fatal error; we just can't perform the rehash.
*/
return;
}
for (size_t index = 0; index < table->numOfBuckets; index++)
{
wKeyValuePair* pair = table->bucketArray[index];
while (pair)
{
nextPair = pair->next;
hashValue = table->hash(pair->key) % numOfBuckets;
pair->next = newBucketArray[hashValue];
newBucketArray[hashValue] = pair;
pair = nextPair;
}
}
free(table->bucketArray);
table->bucketArray = newBucketArray;
table->numOfBuckets = numOfBuckets;
}
static INLINE BOOL HashTable_Equals(wHashTable* table, const wKeyValuePair* pair, const void* key)
{
WINPR_ASSERT(table);
WINPR_ASSERT(pair);
WINPR_ASSERT(key);
return table->key.fnObjectEquals(key, pair->key);
}
static INLINE wKeyValuePair* HashTable_Get(wHashTable* table, const void* key)
{
UINT32 hashValue = 0;
wKeyValuePair* pair = NULL;
WINPR_ASSERT(table);
if (!key)
return NULL;
hashValue = table->hash(key) % table->numOfBuckets;
pair = table->bucketArray[hashValue];
while (pair && !HashTable_Equals(table, pair, key))
pair = pair->next;
return pair;
}
static INLINE void disposeKey(wHashTable* table, void* key)
{
WINPR_ASSERT(table);
if (table->key.fnObjectFree)
table->key.fnObjectFree(key);
}
static INLINE void disposeValue(wHashTable* table, void* value)
{
WINPR_ASSERT(table);
if (table->value.fnObjectFree)
table->value.fnObjectFree(value);
}
static INLINE void disposePair(wHashTable* table, wKeyValuePair* pair)
{
WINPR_ASSERT(table);
if (!pair)
return;
disposeKey(table, pair->key);
disposeValue(table, pair->value);
free(pair);
}
static INLINE void setKey(wHashTable* table, wKeyValuePair* pair, const void* key)
{
WINPR_ASSERT(table);
if (!pair)
return;
disposeKey(table, pair->key);
if (table->key.fnObjectNew)
pair->key = table->key.fnObjectNew(key);
else
{
union
{
const void* cpv;
void* pv;
} cnv;
cnv.cpv = key;
pair->key = cnv.pv;
}
}
static INLINE void setValue(wHashTable* table, wKeyValuePair* pair, const void* value)
{
WINPR_ASSERT(table);
if (!pair)
return;
disposeValue(table, pair->value);
if (table->value.fnObjectNew)
pair->value = table->value.fnObjectNew(value);
else
{
union
{
const void* cpv;
void* pv;
} cnv;
cnv.cpv = value;
pair->value = cnv.pv;
}
}
/**
* C equivalent of the C# Hashtable Class:
* http://msdn.microsoft.com/en-us/library/system.collections.hashtable.aspx
*/
/**
* Properties
*/
/**
* Gets the number of key/value pairs contained in the HashTable.
*/
size_t HashTable_Count(wHashTable* table)
{
WINPR_ASSERT(table);
return table->numOfElements;
}
/**
* Methods
*/
/**
* Adds an element with the specified key and value into the HashTable.
*/
#if defined(WITH_WINPR_DEPRECATED)
int HashTable_Add(wHashTable* table, const void* key, const void* value)
{
if (!HashTable_Insert(table, key, value))
return -1;
return 0;
}
#endif
BOOL HashTable_Insert(wHashTable* table, const void* key, const void* value)
{
BOOL rc = FALSE;
UINT32 hashValue = 0;
wKeyValuePair* pair = NULL;
wKeyValuePair* newPair = NULL;
WINPR_ASSERT(table);
if (!key || !value)
return FALSE;
if (table->synchronized)
EnterCriticalSection(&table->lock);
hashValue = table->hash(key) % table->numOfBuckets;
pair = table->bucketArray[hashValue];
while (pair && !HashTable_Equals(table, pair, key))
pair = pair->next;
if (pair)
{
if (pair->markedForRemove)
{
/* this entry was set to be removed but will be recycled instead */
table->pendingRemoves--;
pair->markedForRemove = FALSE;
table->numOfElements++;
}
if (pair->key != key)
{
setKey(table, pair, key);
}
if (pair->value != value)
{
setValue(table, pair, value);
}
rc = TRUE;
}
else
{
newPair = (wKeyValuePair*)calloc(1, sizeof(wKeyValuePair));
if (newPair)
{
setKey(table, newPair, key);
setValue(table, newPair, value);
newPair->next = table->bucketArray[hashValue];
newPair->markedForRemove = FALSE;
table->bucketArray[hashValue] = newPair;
table->numOfElements++;
if (!table->foreachRecursionLevel && table->upperRehashThreshold > table->idealRatio)
{
float elementToBucketRatio =
(float)table->numOfElements / (float)table->numOfBuckets;
if (elementToBucketRatio > table->upperRehashThreshold)
HashTable_Rehash(table, 0);
}
rc = TRUE;
}
}
if (table->synchronized)
LeaveCriticalSection(&table->lock);
return rc;
}
/**
* Removes the element with the specified key from the HashTable.
*/
BOOL HashTable_Remove(wHashTable* table, const void* key)
{
UINT32 hashValue = 0;
BOOL status = TRUE;
wKeyValuePair* pair = NULL;
wKeyValuePair* previousPair = NULL;
WINPR_ASSERT(table);
if (!key)
return FALSE;
if (table->synchronized)
EnterCriticalSection(&table->lock);
hashValue = table->hash(key) % table->numOfBuckets;
pair = table->bucketArray[hashValue];
while (pair && !HashTable_Equals(table, pair, key))
{
previousPair = pair;
pair = pair->next;
}
if (!pair)
{
status = FALSE;
goto out;
}
if (table->foreachRecursionLevel)
{
/* if we are running a HashTable_Foreach, just mark the entry for removal */
pair->markedForRemove = TRUE;
table->pendingRemoves++;
table->numOfElements--;
goto out;
}
if (previousPair)
previousPair->next = pair->next;
else
table->bucketArray[hashValue] = pair->next;
disposePair(table, pair);
table->numOfElements--;
if (!table->foreachRecursionLevel && table->lowerRehashThreshold > 0.0f)
{
float elementToBucketRatio = (float)table->numOfElements / (float)table->numOfBuckets;
if (elementToBucketRatio < table->lowerRehashThreshold)
HashTable_Rehash(table, 0);
}
out:
if (table->synchronized)
LeaveCriticalSection(&table->lock);
return status;
}
/**
* Get an item value using key
*/
void* HashTable_GetItemValue(wHashTable* table, const void* key)
{
void* value = NULL;
wKeyValuePair* pair = NULL;
WINPR_ASSERT(table);
if (!key)
return NULL;
if (table->synchronized)
EnterCriticalSection(&table->lock);
pair = HashTable_Get(table, key);
if (pair && !pair->markedForRemove)
value = pair->value;
if (table->synchronized)
LeaveCriticalSection(&table->lock);
return value;
}
/**
* Set an item value using key
*/
BOOL HashTable_SetItemValue(wHashTable* table, const void* key, const void* value)
{
BOOL status = TRUE;
wKeyValuePair* pair = NULL;
WINPR_ASSERT(table);
if (!key)
return FALSE;
if (table->synchronized)
EnterCriticalSection(&table->lock);
pair = HashTable_Get(table, key);
if (!pair || pair->markedForRemove)
status = FALSE;
else
{
setValue(table, pair, value);
}
if (table->synchronized)
LeaveCriticalSection(&table->lock);
return status;
}
/**
* Removes all elements from the HashTable.
*/
void HashTable_Clear(wHashTable* table)
{
wKeyValuePair* nextPair = NULL;
WINPR_ASSERT(table);
if (table->synchronized)
EnterCriticalSection(&table->lock);
for (size_t index = 0; index < table->numOfBuckets; index++)
{
wKeyValuePair* pair = table->bucketArray[index];
while (pair)
{
nextPair = pair->next;
if (table->foreachRecursionLevel)
{
/* if we're in a foreach we just mark the entry for removal */
pair->markedForRemove = TRUE;
table->pendingRemoves++;
}
else
{
disposePair(table, pair);
pair = nextPair;
}
}
table->bucketArray[index] = NULL;
}
table->numOfElements = 0;
if (table->foreachRecursionLevel == 0)
HashTable_Rehash(table, 5);
if (table->synchronized)
LeaveCriticalSection(&table->lock);
}
/**
* Gets the list of keys as an array
*/
size_t HashTable_GetKeys(wHashTable* table, ULONG_PTR** ppKeys)
{
size_t iKey = 0;
size_t count = 0;
ULONG_PTR* pKeys = NULL;
wKeyValuePair* nextPair = NULL;
WINPR_ASSERT(table);
if (table->synchronized)
EnterCriticalSection(&table->lock);
iKey = 0;
count = table->numOfElements;
if (ppKeys)
*ppKeys = NULL;
if (count < 1)
{
if (table->synchronized)
LeaveCriticalSection(&table->lock);
return 0;
}
pKeys = (ULONG_PTR*)calloc(count, sizeof(ULONG_PTR));
if (!pKeys)
{
if (table->synchronized)
LeaveCriticalSection(&table->lock);
return 0;
}
for (size_t index = 0; index < table->numOfBuckets; index++)
{
wKeyValuePair* pair = table->bucketArray[index];
while (pair)
{
nextPair = pair->next;
if (!pair->markedForRemove)
pKeys[iKey++] = (ULONG_PTR)pair->key;
pair = nextPair;
}
}
if (table->synchronized)
LeaveCriticalSection(&table->lock);
if (ppKeys)
*ppKeys = pKeys;
else
free(pKeys);
return count;
}
BOOL HashTable_Foreach(wHashTable* table, HASH_TABLE_FOREACH_FN fn, VOID* arg)
{
BOOL ret = TRUE;
WINPR_ASSERT(table);
WINPR_ASSERT(fn);
if (table->synchronized)
EnterCriticalSection(&table->lock);
table->foreachRecursionLevel++;
for (size_t index = 0; index < table->numOfBuckets; index++)
{
for (wKeyValuePair* pair = table->bucketArray[index]; pair; pair = pair->next)
{
if (!pair->markedForRemove && !fn(pair->key, pair->value, arg))
{
ret = FALSE;
goto out;
}
}
}
table->foreachRecursionLevel--;
if (!table->foreachRecursionLevel && table->pendingRemoves)
{
/* if we're the last recursive foreach call, let's do the cleanup if needed */
wKeyValuePair** prevPtr = NULL;
for (size_t index = 0; index < table->numOfBuckets; index++)
{
wKeyValuePair* nextPair = NULL;
prevPtr = &table->bucketArray[index];
for (wKeyValuePair* pair = table->bucketArray[index]; pair;)
{
nextPair = pair->next;
if (pair->markedForRemove)
{
disposePair(table, pair);
*prevPtr = nextPair;
}
else
{
prevPtr = &pair->next;
}
pair = nextPair;
}
}
table->pendingRemoves = 0;
}
out:
if (table->synchronized)
LeaveCriticalSection(&table->lock);
return ret;
}
/**
* Determines whether the HashTable contains a specific key.
*/
BOOL HashTable_Contains(wHashTable* table, const void* key)
{
BOOL status = 0;
wKeyValuePair* pair = NULL;
WINPR_ASSERT(table);
if (!key)
return FALSE;
if (table->synchronized)
EnterCriticalSection(&table->lock);
pair = HashTable_Get(table, key);
status = (pair && !pair->markedForRemove);
if (table->synchronized)
LeaveCriticalSection(&table->lock);
return status;
}
/**
* Determines whether the HashTable contains a specific key.
*/
BOOL HashTable_ContainsKey(wHashTable* table, const void* key)
{
BOOL status = 0;
wKeyValuePair* pair = NULL;
WINPR_ASSERT(table);
if (!key)
return FALSE;
if (table->synchronized)
EnterCriticalSection(&table->lock);
pair = HashTable_Get(table, key);
status = (pair && !pair->markedForRemove);
if (table->synchronized)
LeaveCriticalSection(&table->lock);
return status;
}
/**
* Determines whether the HashTable contains a specific value.
*/
BOOL HashTable_ContainsValue(wHashTable* table, const void* value)
{
BOOL status = FALSE;
WINPR_ASSERT(table);
if (!value)
return FALSE;
if (table->synchronized)
EnterCriticalSection(&table->lock);
for (size_t index = 0; index < table->numOfBuckets; index++)
{
wKeyValuePair* pair = table->bucketArray[index];
while (pair)
{
if (!pair->markedForRemove && HashTable_Equals(table, pair, value))
{
status = TRUE;
break;
}
pair = pair->next;
}
if (status)
break;
}
if (table->synchronized)
LeaveCriticalSection(&table->lock);
return status;
}
/**
* Construction, Destruction
*/
wHashTable* HashTable_New(BOOL synchronized)
{
wHashTable* table = (wHashTable*)calloc(1, sizeof(wHashTable));
if (!table)
goto fail;
table->synchronized = synchronized;
InitializeCriticalSectionAndSpinCount(&(table->lock), 4000);
table->numOfBuckets = 64;
table->numOfElements = 0;
table->bucketArray = (wKeyValuePair**)calloc(table->numOfBuckets, sizeof(wKeyValuePair*));
if (!table->bucketArray)
goto fail;
table->idealRatio = 3.0f;
table->lowerRehashThreshold = 0.0f;
table->upperRehashThreshold = 15.0f;
table->hash = HashTable_PointerHash;
table->key.fnObjectEquals = HashTable_PointerCompare;
table->value.fnObjectEquals = HashTable_PointerCompare;
return table;
fail:
WINPR_PRAGMA_DIAG_PUSH
WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
HashTable_Free(table);
WINPR_PRAGMA_DIAG_POP
return NULL;
}
void HashTable_Free(wHashTable* table)
{
wKeyValuePair* pair = NULL;
wKeyValuePair* nextPair = NULL;
if (!table)
return;
if (table->bucketArray)
{
for (size_t index = 0; index < table->numOfBuckets; index++)
{
pair = table->bucketArray[index];
while (pair)
{
nextPair = pair->next;
disposePair(table, pair);
pair = nextPair;
}
}
free(table->bucketArray);
}
DeleteCriticalSection(&(table->lock));
free(table);
}
void HashTable_Lock(wHashTable* table)
{
WINPR_ASSERT(table);
EnterCriticalSection(&table->lock);
}
void HashTable_Unlock(wHashTable* table)
{
WINPR_ASSERT(table);
LeaveCriticalSection(&table->lock);
}
wObject* HashTable_KeyObject(wHashTable* table)
{
WINPR_ASSERT(table);
return &table->key;
}
wObject* HashTable_ValueObject(wHashTable* table)
{
WINPR_ASSERT(table);
return &table->value;
}
BOOL HashTable_SetHashFunction(wHashTable* table, HASH_TABLE_HASH_FN fn)
{
WINPR_ASSERT(table);
table->hash = fn;
return fn != NULL;
}
BOOL HashTable_SetupForStringData(wHashTable* table, BOOL stringValues)
{
wObject* obj = NULL;
if (!HashTable_SetHashFunction(table, HashTable_StringHash))
return FALSE;
obj = HashTable_KeyObject(table);
obj->fnObjectEquals = HashTable_StringCompare;
obj->fnObjectNew = HashTable_StringClone;
obj->fnObjectFree = HashTable_StringFree;
if (stringValues)
{
obj = HashTable_ValueObject(table);
obj->fnObjectEquals = HashTable_StringCompare;
obj->fnObjectNew = HashTable_StringClone;
obj->fnObjectFree = HashTable_StringFree;
}
return TRUE;
}