349 lines
9.1 KiB
C
349 lines
9.1 KiB
C
/*
|
|
* ***************************************************************************
|
|
* NOTE:
|
|
* Merge of the icl_hash.h icl_hash.c files from PLASMA 2.5.2 (October 2013).
|
|
* http://icl.cs.utk.edu/plasma/software/
|
|
* ***************************************************************************
|
|
*
|
|
* Dependency free hash table implementation.
|
|
*
|
|
* This simple hash table implementation should be easy to drop into
|
|
* any other peice of code, it does not depend on anything else :-)
|
|
*/
|
|
/*
|
|
*
|
|
* Aauthor Keith Seymour
|
|
* Aauthor Asim YarKhan
|
|
*/
|
|
|
|
|
|
#include <cstdlib>
|
|
#include <cstdio>
|
|
#include <cstring>
|
|
#include <cassert>
|
|
#include <limits.h>
|
|
|
|
#ifndef icl_hash_h
|
|
#define icl_hash_h
|
|
|
|
typedef struct icl_entry_s {
|
|
void* key;
|
|
void *data;
|
|
struct icl_entry_s* next;
|
|
} icl_entry_t;
|
|
|
|
typedef struct icl_hash_s {
|
|
int nbuckets;
|
|
int nentries;
|
|
icl_entry_t **buckets;
|
|
unsigned int (*hash_function)(void*);
|
|
int (*hash_key_compare)(void*, void*);
|
|
} icl_hash_t;
|
|
|
|
#define icl_hash_foreach(ht, tmpint, tmpent, kp, dp) \
|
|
for (tmpint=0;tmpint<ht->nbuckets; tmpint++) \
|
|
for (tmpent=ht->buckets[tmpint]; \
|
|
tmpent!=NULL&&((kp=tmpent->key)!=NULL)&&((dp=tmpent->data)!=NULL); \
|
|
tmpent=tmpent->next)
|
|
|
|
|
|
|
|
#define BITS_IN_int ( sizeof(int) * CHAR_BIT )
|
|
#define THREE_QUARTERS ((int) ((BITS_IN_int * 3) / 4))
|
|
#define ONE_EIGHTH ((int) (BITS_IN_int / 8))
|
|
#define HIGH_BITS ( ~((unsigned int)(~0) >> ONE_EIGHTH ))
|
|
|
|
|
|
/**
|
|
* A simple string hash.
|
|
*
|
|
* An adaptation of Peter Weinberger's (PJW) generic hashing
|
|
* algorithm based on Allen Holub's version. Accepts a pointer
|
|
* to a datum to be hashed and returns an unsigned integer.
|
|
* From: Keith Seymour's proxy library code
|
|
*
|
|
* @param[in] key -- the string to be hashed
|
|
*
|
|
* @returns the hash index
|
|
*/
|
|
static inline unsigned int
|
|
hash_pjw(void* key)
|
|
{
|
|
char *datum = (char *)key;
|
|
unsigned int hash_value, i;
|
|
|
|
if(!datum) return 0;
|
|
|
|
for (hash_value = 0; *datum; ++datum) {
|
|
hash_value = (hash_value << ONE_EIGHTH) + *datum;
|
|
if ((i = hash_value & HIGH_BITS) != 0)
|
|
hash_value = (hash_value ^ (i >> THREE_QUARTERS)) & ~HIGH_BITS;
|
|
}
|
|
return (hash_value);
|
|
}
|
|
|
|
static inline int string_compare(void* a, void* b)
|
|
{
|
|
return (strcmp( (char*)a, (char*)b ) == 0);
|
|
}
|
|
|
|
|
|
/**
|
|
* Create a new hash table.
|
|
*
|
|
* @param[in] nbuckets -- number of buckets to create
|
|
* @param[in] hash_function -- pointer to the hashing function to be used
|
|
* @param[in] hash_key_compare -- pointer to the hash key comparison function to be used
|
|
*
|
|
* @returns pointer to new hash table.
|
|
*/
|
|
|
|
static inline icl_hash_t *
|
|
icl_hash_create( int nbuckets, unsigned int (*hash_function)(void*), int (*hash_key_compare)(void*, void*) )
|
|
{
|
|
icl_hash_t *ht;
|
|
int i;
|
|
|
|
ht = (icl_hash_t*) malloc(sizeof(icl_hash_t));
|
|
assert(ht!=NULL);
|
|
if(!ht) return NULL;
|
|
|
|
ht->nentries = 0;
|
|
ht->buckets = (icl_entry_t**)malloc(nbuckets * sizeof(icl_entry_t*));
|
|
assert(ht->buckets!=NULL);
|
|
if(!ht->buckets) return NULL;
|
|
|
|
ht->nbuckets = nbuckets;
|
|
for(i=0;i<ht->nbuckets;i++)
|
|
ht->buckets[i] = NULL;
|
|
|
|
ht->hash_function = hash_function ? hash_function : hash_pjw;
|
|
ht->hash_key_compare = hash_key_compare ? hash_key_compare : string_compare;
|
|
|
|
return ht;
|
|
}
|
|
|
|
/**
|
|
* Search for an entry in a hash table.
|
|
*
|
|
* @param ht -- the hash table to be searched
|
|
* @param key -- the key of the item to search for
|
|
*
|
|
* @returns pointer to the data corresponding to the key.
|
|
* If the key was not found, returns NULL.
|
|
*/
|
|
|
|
static inline void *
|
|
icl_hash_find(icl_hash_t *ht, void* key)
|
|
{
|
|
icl_entry_t* curr;
|
|
unsigned int hash_val;
|
|
|
|
if(!ht || !key) return NULL;
|
|
|
|
hash_val = (* ht->hash_function)(key) % ht->nbuckets;
|
|
|
|
for (curr=ht->buckets[hash_val]; curr != NULL; curr=curr->next)
|
|
if ( ht->hash_key_compare(curr->key, key))
|
|
return(curr->data);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* Insert an item into the hash table.
|
|
*
|
|
* @param ht -- the hash table
|
|
* @param key -- the key of the new item
|
|
* @param data -- pointer to the new item's data
|
|
*
|
|
* @returns pointer to the new item. Returns NULL on error.
|
|
*/
|
|
|
|
static inline icl_entry_t *
|
|
icl_hash_insert(icl_hash_t *ht, void* key, void *data)
|
|
{
|
|
icl_entry_t *curr;
|
|
unsigned int hash_val;
|
|
|
|
if(!ht || !key) return NULL;
|
|
|
|
hash_val = (* ht->hash_function)(key) % ht->nbuckets;
|
|
|
|
for (curr=ht->buckets[hash_val]; curr != NULL; curr=curr->next)
|
|
if ( ht->hash_key_compare(curr->key, key))
|
|
return(NULL); /* key already exists */
|
|
|
|
/* if key was not found */
|
|
curr = (icl_entry_t*)malloc(sizeof(icl_entry_t));
|
|
assert(curr != NULL);
|
|
if(!curr) return NULL;
|
|
|
|
curr->key = key;
|
|
curr->data = data;
|
|
curr->next = ht->buckets[hash_val]; /* add at start */
|
|
|
|
ht->buckets[hash_val] = curr;
|
|
ht->nentries++;
|
|
|
|
return curr;
|
|
}
|
|
|
|
/**
|
|
* Replace entry in hash table with the given entry.
|
|
*
|
|
* @param ht -- the hash table
|
|
* @param key -- the key of the new item
|
|
* @param data -- pointer to the new item's data
|
|
* @param olddata -- pointer to the old item's data (set upon return)
|
|
*
|
|
* @returns pointer to the new item. Returns NULL on error.
|
|
*/
|
|
|
|
static inline icl_entry_t *
|
|
icl_hash_update_insert(icl_hash_t *ht, void* key, void *data) //, void **olddata)
|
|
{
|
|
icl_entry_t *curr, *prev;
|
|
unsigned int hash_val;
|
|
|
|
if(!ht || !key) return NULL;
|
|
|
|
hash_val = (* ht->hash_function)(key) % ht->nbuckets;
|
|
|
|
/* Scan bucket[hash_val] for key */
|
|
for (prev=NULL,curr=ht->buckets[hash_val]; curr != NULL; prev=curr, curr=curr->next)
|
|
/* If key found, remove node from list, free old key, and setup olddata for the return */
|
|
if ( ht->hash_key_compare(curr->key, key)) {
|
|
/* if (olddata != NULL) { */
|
|
/* *olddata = curr->data; */
|
|
/* free(curr->key); */
|
|
/* } */
|
|
|
|
if (prev == NULL)
|
|
ht->buckets[hash_val] = curr->next;
|
|
else
|
|
prev->next = curr->next;
|
|
}
|
|
|
|
/* Since key was either not found, or found-and-removed, create and prepend new node */
|
|
curr = (icl_entry_t*)malloc(sizeof(icl_entry_t));
|
|
assert(curr!=NULL);
|
|
if(curr == NULL) return NULL; /* out of memory */
|
|
|
|
curr->key = key;
|
|
curr->data = data;
|
|
curr->next = ht->buckets[hash_val]; /* add at start */
|
|
|
|
ht->buckets[hash_val] = curr;
|
|
ht->nentries++;
|
|
|
|
/* if(olddata!=NULL && *olddata!=NULL) */
|
|
/* *olddata = NULL; */
|
|
|
|
return curr;
|
|
}
|
|
|
|
/**
|
|
* Free one hash table entry located by key (key and data are freed using functions).
|
|
*
|
|
* @param ht -- the hash table to be freed
|
|
* @param key -- the key of the new item
|
|
* @param free_key -- pointer to function that frees the key
|
|
* @param free_data -- pointer to function that frees the data
|
|
*
|
|
* @returns 0 on success, -1 on failure.
|
|
*/
|
|
static inline int icl_hash_delete(icl_hash_t *ht, void* key, void (*free_key)(void*), void (*free_data)(void*))
|
|
{
|
|
icl_entry_t *curr, *prev;
|
|
unsigned int hash_val;
|
|
|
|
if(!ht || !key) return -1;
|
|
hash_val = (* ht->hash_function)(key) % ht->nbuckets;
|
|
|
|
prev = NULL;
|
|
for (curr=ht->buckets[hash_val]; curr != NULL; ) {
|
|
if ( ht->hash_key_compare(curr->key, key)) {
|
|
if (prev == NULL) {
|
|
ht->buckets[hash_val] = curr->next;
|
|
} else {
|
|
prev->next = curr->next;
|
|
}
|
|
if (*free_key && curr->key) (*free_key)(curr->key);
|
|
if (*free_data && curr->data) (*free_data)(curr->data);
|
|
ht->nentries++;
|
|
free(curr);
|
|
return 0;
|
|
}
|
|
prev = curr;
|
|
curr = curr->next;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Free hash table structures (key and data are freed using functions).
|
|
*
|
|
* @param ht -- the hash table to be freed
|
|
* @param free_key -- pointer to function that frees the key
|
|
* @param free_data -- pointer to function that frees the data
|
|
*
|
|
* @returns 0 on success, -1 on failure.
|
|
*/
|
|
static inline int
|
|
icl_hash_destroy(icl_hash_t *ht, void (*free_key)(void*), void (*free_data)(void*))
|
|
{
|
|
icl_entry_t *bucket, *curr, *next;
|
|
int i;
|
|
|
|
if(!ht) return -1;
|
|
|
|
for (i=0; i<ht->nbuckets; i++) {
|
|
bucket = ht->buckets[i];
|
|
for (curr=bucket; curr!=NULL; ) {
|
|
next=curr->next;
|
|
if (*free_key && curr->key) (*free_key)(curr->key);
|
|
if (*free_data && curr->data) (*free_data)(curr->data);
|
|
free(curr);
|
|
curr=next;
|
|
}
|
|
}
|
|
|
|
if(ht->buckets) free(ht->buckets);
|
|
if(ht) free(ht);
|
|
|
|
return 0;
|
|
}
|
|
|
|
#if 0
|
|
/**
|
|
* Dump the hash table's contents to the given file pointer.
|
|
*
|
|
* @param stream -- the file to which the hash table should be dumped
|
|
* @param ht -- the hash table to be dumped
|
|
*
|
|
* @returns 0 on success, -1 on failure.
|
|
*/
|
|
|
|
static inline int
|
|
icl_hash_dump(FILE* stream, icl_hash_t* ht)
|
|
{
|
|
icl_entry_t *bucket, *curr;
|
|
int i;
|
|
|
|
if(!ht) return -1;
|
|
|
|
for(i=0; i<ht->nbuckets; i++) {
|
|
bucket = ht->buckets[i];
|
|
for(curr=bucket; curr!=NULL; ) {
|
|
if(curr->key)
|
|
fprintf(stream, "icl_hash_dump: %s: %p\n", (char *)curr->key, curr->data);
|
|
curr=curr->next;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
#endif /* icl_hash_h */
|