Map.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_CASC_MAP

Macros
#define	KEY_LENGTH_STRING   0xFFFFFFFF

Typedefs
typedef struct _CASC_MAP	CASC_MAP
typedef struct _CASC_MAP *	PCASC_MAP
typedef bool(*	MAP_COMPARE )(PCASC_MAP pMap, void *pvObject, void *pvKey)

Functions
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)
const char *	Map_FindString (PCASC_MAP pMap, const char *szString, const char *szStringEnd)
bool	Map_InsertString (PCASC_MAP pMap, const char *szString, bool bCutExtension)
void	Map_Free (PCASC_MAP pMap)

Macro Definition Documentation

#define KEY_LENGTH_STRING   0xFFFFFFFF

Typedef Documentation

typedef struct _CASC_MAP CASC_MAP

typedef bool(* MAP_COMPARE)(PCASC_MAP pMap, void *pvObject, void *pvKey)

typedef struct _CASC_MAP * PCASC_MAP

Function Documentation

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: