hcq/MaxScale
hcq/MaxScale
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

New routines for key/value copy and free in hash tables

Browse Source 
With the routines for key/value copy and free it is possible to
duplicate or free different data types in the hash tables.

The user_alloc() routine is the first example.
This commit is contained in:
MassimilianoPinto 2014-01-08 17:02:59 +01:00
parent a6dbb20aa9
commit dfc224c292
3 changed files with 48 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
server/core/hashtable.c
View File

@ -49,9 +49,12 @@
* @verbatim
* Revision History
*
* Date Who Description
* 23/06/13 Mark Riddoch Initial implementation
* 23/07/13 Mark Riddoch Addition of hashtable iterator
* Date Who Description
* 23/06/2013 Mark Riddoch Initial implementation
* 23/07/2013 Mark Riddoch Addition of hashtable iterator
* 08/01/2014 Massimiliano Pinto Added copy and free funtion pointers for keys and values:
* it's possible to copy and free different data types via
* kcopyfn/kfreefn, vcopyfn/vfreefn
*
* @endverbatim
*/
@ -98,8 +101,10 @@ HASHTABLE *rval;
rval->hashsize = size;
rval->hashfn = hashfn;
rval->cmpfn = cmpfn;
rval->copyfn = nullfn;
rval->freefn = nullfn;
rval->kcopyfn = nullfn;
rval->vcopyfn = nullfn;
rval->kfreefn = nullfn;
rval->vfreefn = nullfn;
rval->n_readers = 0;
rval->writelock = 0;
spinlock_init(&rval->spin);
@ -131,8 +136,8 @@ HASHENTRIES *entry, *ptr;
while (entry)
{
ptr = entry->next;
table->freefn(entry->key);
table->freefn(entry->value);
table->kfreefn(entry->key);
table->vfreefn(entry->value);
free(entry);
entry = ptr;
}
@ -144,17 +149,25 @@ HASHENTRIES *entry, *ptr;
/**
* Provide memory management functions to the hash table. This allows
* function pointers to be registered that can make copies of the
* key and value.
* key and value and free them as well.
*
* @param table The hash table
* @param copyfn The copy function
* @param freefn The free function
* @param kcopyfn The copy function for the key
* @param vcopyfn The copy function for the value
* @param kfreefn The free function for the key
* @param vfreefn The free function for the value
*/
void
hashtable_memory_fns(HASHTABLE *table, HASHMEMORYFN copyfn, HASHMEMORYFN freefn)
hashtable_memory_fns(HASHTABLE *table, HASHMEMORYFN kcopyfn, HASHMEMORYFN vcopyfn, HASHMEMORYFN kfreefn, HASHMEMORYFN vfreefn)
{
table->copyfn = copyfn;
table->freefn = freefn;
if (kcopyfn != NULL)
table->kcopyfn = kcopyfn;
if (vcopyfn != NULL)
table->vcopyfn = vcopyfn;
if (kfreefn != NULL)
table->kfreefn = kfreefn;
if (vfreefn != NULL)
table->vfreefn = vfreefn;
}
/**
@ -196,8 +209,8 @@ hashtable_add(HASHTABLE *table, void *key, void *value)
hashtable_write_unlock(table);
return 0;
}
ptr->key = table->copyfn(key);
ptr->value = table->copyfn(value);
ptr->key = table->kcopyfn(key);
ptr->value = table->vcopyfn(value);
ptr->next = table->entries[hashkey % table->hashsize];
table->entries[hashkey % table->hashsize] = ptr;
}
@ -235,8 +248,8 @@ HASHENTRIES *entry, *ptr;
{
/* We are removing from the first entry */
table->entries[hashkey % table->hashsize] = entry->next;
table->freefn(entry->key);
table->freefn(entry->value);
table->kfreefn(entry->key);
table->vfreefn(entry->value);
if (entry->next != NULL) {
entry->key = entry->next->key;
@ -258,8 +271,8 @@ HASHENTRIES *entry, *ptr;
return 0; /* This should never happen */
}
ptr->next = entry->next;
table->freefn(entry->key);
table->freefn(entry->value);
table->kfreefn(entry->key);
table->vfreefn(entry->value);
free(entry);
}
hashtable_write_unlock(table);

9
server/core/users.c
View File

@ -27,8 +27,11 @@
* @verbatim
* Revision History
*
* Date Who Description
* 23/06/13 Mark Riddoch Initial implementation
* Date Who Description
* 23/06/2013 Mark Riddoch Initial implementation
* 08/01/2014 Massimiliano Pinto In user_alloc now we can pass function pointers for
* copying/freeing keys and values independently via
* hashtable_memory_fns() routine
*
* @endverbatim
*/
@ -64,7 +67,7 @@ USERS *rval;
return NULL;
}
hashtable_memory_fns(rval->data, (HASHMEMORYFN)strdup, (HASHMEMORYFN)free);
hashtable_memory_fns(rval->data, (HASHMEMORYFN)strdup, (HASHMEMORYFN)strdup, (HASHMEMORYFN)free, (HASHMEMORYFN)free);
return rval;
}

16
server/include/hashtable.h
View File

@ -25,9 +25,11 @@
* @verbatim
* Revision History
*
* Date Who Description
* 23/06/13 Mark Riddoch Initial implementation
* 23/07/13 Mark Riddoch Addition of iterator mechanism
* Date Who Description
* 23/06/2013 Mark Riddoch Initial implementation
* 23/07/2013 Mark Riddoch Addition of iterator mechanism
* 08/01/2014 Massimiliano Pinto Added function pointers for key/value copy and free
* the routine hashtable_memory_fns() changed accordingly
*
* @endverbatim
*/
@ -75,8 +77,10 @@ typedef struct hashtable {
HASHENTRIES **entries; /**< The entries themselves */
int (*hashfn)(void *); /**< The hash function */
int (*cmpfn)(void *, void *); /**< The key comparison function */
HASHMEMORYFN copyfn; /**< Optional copy function */
HASHMEMORYFN freefn; /**< Optional free function */
HASHMEMORYFN kcopyfn; /**< Optional key copy function */
HASHMEMORYFN vcopyfn; /**< Optional value copy function */
HASHMEMORYFN kfreefn; /**< Optional key free function */
HASHMEMORYFN vfreefn; /**< Optional value free function */
SPINLOCK spin; /**< Internal spinlock for the hashtable */
int n_readers; /**< Number of clients reading the table */
int writelock; /**< The table is locked by a writer */
@ -87,7 +91,7 @@ typedef struct hashtable {
extern HASHTABLE *hashtable_alloc(int, int (*hashfn)(), int (*cmpfn)());
/**< Allocate a hashtable */
extern void hashtable_memory_fns(HASHTABLE *, HASHMEMORYFN, HASHMEMORYFN);
extern void hashtable_memory_fns(HASHTABLE *, HASHMEMORYFN, HASHMEMORYFN, HASHMEMORYFN, HASHMEMORYFN);
/**< Provide an interface to control key/value memory
* manipulation
*/