Map.cpp File Reference

#include "../CascLib.h"
#include "../CascCommon.h"

Include dependency graph for Map.cpp:

Macros
#define	__CASCLIB_SELF__

Functions
static const char *	String_GetExtension (const char *szString)
static DWORD	CalcHashIndex_Key (PCASC_MAP pMap, void *pvKey)
static DWORD	CalcHashIndex_String (PCASC_MAP pMap, const char *szString, const char *szStringEnd)
static bool	CompareObject_Key (PCASC_MAP pMap, void *pvObject, void *pvKey)
static bool	CompareObject_String (PCASC_MAP pMap, const char *szExistingString, const char *szString, const char *szStringEnd)
PCASC_MAP	Map_Create (DWORD dwMaxItems, DWORD dwKeyLength, DWORD dwKeyOffset)
size_t	Map_EnumObjects (PCASC_MAP pMap, void **ppvArray)
void *	Map_FindObject (PCASC_MAP pMap, void *pvKey, PDWORD PtrIndex)
bool	Map_InsertObject (PCASC_MAP pMap, void *pvNewObject, void *pvKey)
bool	Map_InsertString (PCASC_MAP pMap, const char *szString, bool bCutExtension)
const char *	Map_FindString (PCASC_MAP pMap, const char *szString, const char *szStringEnd)
void	Map_Free (PCASC_MAP pMap)

Macro Definition Documentation

#define __CASCLIB_SELF__

Function Documentation

static DWORD CalcHashIndex_Key ( PCASC_MAP  pMap, void *  pvKey  )

static

{
 LPBYTE pbKey = (LPBYTE)pvKey;
 DWORD dwHash = 0x7EEE7EEE;

 // Construct the hash from the first 8 digits
 dwHash = (dwHash >> 24) ^ (dwHash << 5) ^ dwHash ^ pbKey[0];
 dwHash = (dwHash >> 24) ^ (dwHash << 5) ^ dwHash ^ pbKey[1];
 dwHash = (dwHash >> 24) ^ (dwHash << 5) ^ dwHash ^ pbKey[2];
 dwHash = (dwHash >> 24) ^ (dwHash << 5) ^ dwHash ^ pbKey[3];
 dwHash = (dwHash >> 24) ^ (dwHash << 5) ^ dwHash ^ pbKey[4];
 dwHash = (dwHash >> 24) ^ (dwHash << 5) ^ dwHash ^ pbKey[5];
 dwHash = (dwHash >> 24) ^ (dwHash << 5) ^ dwHash ^ pbKey[6];
 dwHash = (dwHash >> 24) ^ (dwHash << 5) ^ dwHash ^ pbKey[7];

 // Return the hash limited by the table size
 return (dwHash % pMap->TableSize);
}

Here is the caller graph for this function:

static DWORD CalcHashIndex_String ( PCASC_MAP  pMap, const char *  szString, const char *  szStringEnd  )

static

{
 LPBYTE pbKeyEnd = (LPBYTE)szStringEnd;
 LPBYTE pbKey = (LPBYTE)szString;
 DWORD dwHash = 0x7EEE7EEE;

 // Hash the string itself
 while(pbKey < pbKeyEnd)
 {
 dwHash = (dwHash >> 24) ^ (dwHash << 5) ^ dwHash ^ AsciiToUpperTable_BkSlash[pbKey[0]];
 pbKey++;
 }

 // Return the hash limited by the table size
 return (dwHash % pMap->TableSize);
}

Here is the caller graph for this function:

static bool CompareObject_Key ( PCASC_MAP  pMap, void *  pvObject, void *  pvKey  )

static

{
 LPBYTE pbObjectKey = (LPBYTE)pvObject + pMap->KeyOffset;

 return (memcmp(pbObjectKey, pvKey, pMap->KeyLength) == 0);
}

Here is the caller graph for this function:

static bool CompareObject_String ( PCASC_MAP  pMap, const char *  szExistingString, const char *  szString, const char *  szStringEnd  )

static

{
 // Keep compiler happy
 CASCLIB_UNUSED(pMap);

 // Compare the whole part, case insensitive
 while(szString < szStringEnd)
 {
 if(AsciiToUpperTable_BkSlash[*szExistingString] != AsciiToUpperTable_BkSlash[*szString])
 return false;

 szExistingString++;
 szString++;
 }

 return true;
}

Here is the caller graph for this function:

PCASC_MAP Map_Create	(	DWORD	dwMaxItems,
		DWORD	dwKeyLength,
		DWORD	dwKeyOffset
	)

{
 PCASC_MAP pMap;
 size_t cbToAllocate;
 size_t dwTableSize;

 // Calculate the size of the table
 dwTableSize = (dwMaxItems * 3 / 2) | 0x01;

 // Allocate new map for the objects
 cbToAllocate = sizeof(CASC_MAP) + (dwTableSize * sizeof(void *));
 pMap = (PCASC_MAP)CASC_ALLOC(LPBYTE, cbToAllocate);
 if(pMap != NULL)
 {
 memset(pMap, 0, cbToAllocate);
 pMap->KeyLength = dwKeyLength;
 pMap->TableSize = dwTableSize;
 pMap->KeyOffset = dwKeyOffset;
 }

 // Return the allocated map
 return pMap;
}

Here is the caller graph for this function:

size_t Map_EnumObjects	(	PCASC_MAP	pMap,
		void **	ppvArray
	)

{
 size_t nIndex = 0;

 // Verify pointer to the map
 if(pMap != NULL && ppvArray != NULL)
 {
 // Enumerate all items in main table
 for(size_t i = 0; i < pMap->TableSize; i++)
 {
 // Is that cell valid?
 if(pMap->HashTable[i] != NULL)
 {
 ppvArray[nIndex++] = pMap->HashTable[i];
 }
 }
 }

 return pMap->ItemCount;
}

void* Map_FindObject	(	PCASC_MAP	pMap,
		void *	pvKey,
		PDWORD	PtrIndex
	)

{
 void * pvObject;
 DWORD dwHashIndex;

 // Verify pointer to the map
 if(pMap != NULL)
 {
 // Construct the main index
 dwHashIndex = CalcHashIndex_Key(pMap, pvKey);
 while(pMap->HashTable[dwHashIndex] != NULL)
 {
 // Get the pointer at that position
 pvObject = pMap->HashTable[dwHashIndex];

 // Compare the hash
 if(CompareObject_Key(pMap, pvObject, pvKey))
 {
 if(PtrIndex != NULL)
 PtrIndex[0] = dwHashIndex;
 return pvObject;
 }

 // Move to the next entry
 dwHashIndex = (dwHashIndex + 1) % pMap->TableSize;
 }
 }

 // Not found, sorry
 return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

const char* Map_FindString	(	PCASC_MAP	pMap,
		const char *	szString,
		const char *	szStringEnd
	)

{
 const char * szExistingString;
 DWORD dwHashIndex;

 // Verify pointer to the map
 if(pMap != NULL)
 {
 // Construct the main index
 dwHashIndex = CalcHashIndex_String(pMap, szString, szStringEnd);
 while(pMap->HashTable[dwHashIndex] != NULL)
 {
 // Get the pointer at that position
 szExistingString = (const char *)pMap->HashTable[dwHashIndex];

 // Compare the hash
 if(CompareObject_String(pMap, szExistingString, szString, szStringEnd))
 return szExistingString;

 // Move to the next entry
 dwHashIndex = (dwHashIndex + 1) % pMap->TableSize;
 }
 }

 // Not found, sorry
 return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Map_Free

(

PCASC_MAP

pMap

)

{
 if(pMap != NULL)
 {
 CASC_FREE(pMap);
 }
}

Here is the caller graph for this function:

bool Map_InsertObject	(	PCASC_MAP	pMap,
		void *	pvNewObject,
		void *	pvKey
	)

{
 void * pvExistingObject;
 DWORD dwHashIndex;

 // Verify pointer to the map
 if(pMap != NULL)
 {
 // Limit check
 if((pMap->ItemCount + 1) >= pMap->TableSize)
 return false;

 // Construct the hash index
 dwHashIndex = CalcHashIndex_Key(pMap, pvKey);
 while(pMap->HashTable[dwHashIndex] != NULL)
 {
 // Get the pointer at that position
 pvExistingObject = pMap->HashTable[dwHashIndex];

 // Check if hash being inserted conflicts with an existing hash
 if(CompareObject_Key(pMap, pvExistingObject, pvKey))
 return false;

 // Move to the next entry
 dwHashIndex = (dwHashIndex + 1) % pMap->TableSize;
 }

 // Insert at that position
 pMap->HashTable[dwHashIndex] = pvNewObject;
 pMap->ItemCount++;
 return true;
 }

 // Failed
 return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Map_InsertString	(	PCASC_MAP	pMap,
		const char *	szString,
		bool	bCutExtension
	)

{
 const char * szExistingString;
 const char * szStringEnd = NULL;
 DWORD dwHashIndex;

 // Verify pointer to the map
 if(pMap != NULL)
 {
 // Limit check
 if((pMap->ItemCount + 1) >= pMap->TableSize)
 return false;

 // Retrieve the length of the string without extension
 if(bCutExtension)
 szStringEnd = String_GetExtension(szString);
 if(szStringEnd == NULL)
 szStringEnd = szString + strlen(szString);

 // Construct the hash index
 dwHashIndex = CalcHashIndex_String(pMap, szString, szStringEnd);
 while(pMap->HashTable[dwHashIndex] != NULL)
 {
 // Get the pointer at that position
 szExistingString = (const char *)pMap->HashTable[dwHashIndex];

 // Check if hash being inserted conflicts with an existing hash
 if(CompareObject_String(pMap, szExistingString, szString, szStringEnd))
 return false;

 // Move to the next entry
 dwHashIndex = (dwHashIndex + 1) % pMap->TableSize;
 }

 // Insert at that position
 pMap->HashTable[dwHashIndex] = (void *)szString;
 pMap->ItemCount++;
 return true;
 }

 // Failed
 return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static const char* String_GetExtension ( const char *  szString )

static

{
 const char * szExtension = strrchr(szString, '.');
 return (szExtension != NULL) ? szExtension + 1 : NULL;
}

Here is the caller graph for this function: