maki/openairinterface5g
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

reverting last 2 commits, do it later

Browse Source 
git-svn-id: http://svn.eurecom.fr/openair4G/trunk@7696 818b1a75-f10b-46b9-bf7c-635c3b92a50f
This commit is contained in:
gauthier
2015-07-07 13:31:05 +00:00
parent a458ab17c1
commit e7e95ce345
6 changed files with 42 additions and 196 deletions
Download Patch File Download Diff File Expand all files Collapse all files
common/utils/collection/hashtable/obj_hashtable.c
+17 -99
View File
@@ -30,7 +30,6 @@
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>
#include "obj_hashtable.h"
//-------------------------------------------------------------------------------------------------------------------------------
/*
@@ -39,11 +38,11 @@
* This is a simple/naive hash function which adds the key's ASCII char values. It will probably generate lots of collisions on large hash tables.
*/
static hash_size_t def_hashfunc(const void * const keyP, int key_sizeP)
static hash_size_t def_hashfunc(const void *keyP, int key_sizeP)
{
hash_size_t hash=0;
while(key_sizeP) hash^=((unsigned char*)keyP)[--key_sizeP];
while(key_sizeP) hash^=((unsigned char*)keyP)[key_sizeP --];
return hash;
}
@@ -55,7 +54,7 @@ static hash_size_t def_hashfunc(const void * const keyP, int key_sizeP)
* The user can also specify a hash function. If the hashfunc argument is NULL, a default hash function is used.
* If an error occurred, NULL is returned. All other values in the returned obj_hash_table_t pointer should be released with hashtable_destroy().
*/
obj_hash_table_t *obj_hashtable_create(const hash_size_t sizeP, hash_size_t (*hashfuncP)(const void*, int ), void (*freekeyfuncP)(void*), void (*freedatafuncP)(void*))
obj_hash_table_t *obj_hashtable_create(hash_size_t sizeP, hash_size_t (*hashfuncP)(const void*, int ), void (*freekeyfuncP)(void*), void (*freedatafuncP)(void*))
{
obj_hash_table_t *hashtbl;
@@ -84,7 +83,7 @@ obj_hash_table_t *obj_hashtable_create(const hash_size_t sizeP, hash_size_t (*ha
* Cleanup
* The hashtable_destroy() walks through the linked lists for each possible hash value, and releases the elements. It also releases the nodes array and the obj_hash_table_t.
*/
hashtable_rc_t obj_hashtable_destroy(obj_hash_table_t * const hashtblP)
hashtable_rc_t obj_hashtable_destroy(obj_hash_table_t *hashtblP)
{
hash_size_t n;
obj_hash_node_t *node, *oldnode;
@@ -104,7 +103,7 @@ hashtable_rc_t obj_hashtable_destroy(obj_hash_table_t * const hashtblP)
return HASH_TABLE_OK;
}
//-------------------------------------------------------------------------------------------------------------------------------
hashtable_rc_t obj_hashtable_is_key_exists (const obj_hash_table_t * const hashtblP, const void* const keyP, const int key_sizeP)
hashtable_rc_t obj_hashtable_is_key_exists (obj_hash_table_t *hashtblP, void* keyP, int key_sizeP)
//-------------------------------------------------------------------------------------------------------------------------------
{
obj_hash_node_t *node;
@@ -127,55 +126,12 @@ hashtable_rc_t obj_hashtable_is_key_exists (const obj_hash_table_t * const hasht
}
return HASH_TABLE_KEY_NOT_EXISTS;
}
//-------------------------------------------------------------------------------------------------------------------------------
hashtable_rc_t obj_hashtable_dump_content (
const obj_hash_table_t * const hashtblP,
char * const buffer_pP,
int * const remaining_bytes_in_buffer_pP)
//-------------------------------------------------------------------------------------------------------------------------------
{
obj_hash_node_t *node = NULL;
unsigned int i = 0;
unsigned int num_elements = 0;
int rc;
if (hashtblP == NULL) {
rc = snprintf(
buffer_pP,
*remaining_bytes_in_buffer_pP,
"HASH_TABLE_BAD_PARAMETER_HASHTABLE");
return HASH_TABLE_BAD_PARAMETER_HASHTABLE;
}
while ((i < hashtblP->size) && (*remaining_bytes_in_buffer_pP > 0)) {
if (hashtblP->nodes[i] != NULL) {
node=hashtblP->nodes[i];
while(node) {
rc = snprintf(
buffer_pP,
*remaining_bytes_in_buffer_pP,
"Hash 0x%x Key 0x%"PRIx64" Element %p\n",
i,
node->key,
node->data);
node=node->next;
if ((0 > rc) || (*remaining_bytes_in_buffer_pP < rc)) {
fprintf(stderr, "Error while dumping hashtable content");
} else {
*remaining_bytes_in_buffer_pP -= rc;
}
}
}
i += 1;
}
return HASH_TABLE_OK;
}
//-------------------------------------------------------------------------------------------------------------------------------
/*
* Adding a new element
* To make sure the hash value is not bigger than size, the result of the user provided hash function is used modulo size.
*/
hashtable_rc_t obj_hashtable_insert(obj_hash_table_t * const hashtblP, const void* const keyP, const int key_sizeP, void *dataP)
hashtable_rc_t obj_hashtable_insert(obj_hash_table_t *hashtblP, void* keyP, int key_sizeP, void *dataP)
{
obj_hash_node_t *node;
hash_size_t hash;
@@ -190,21 +146,15 @@ hashtable_rc_t obj_hashtable_insert(obj_hash_table_t * const hashtblP, const voi
if (node->data) {
hashtblP->freedatafunc(node->data);
}
node->data = dataP;
node->key_size = key_sizeP;
node->data=dataP;
// waste of memory here (keyP is lost) we should free it now
return HASH_TABLE_INSERT_OVERWRITTEN_DATA;
}
node=node->next;
}
if(!(node=malloc(sizeof(obj_hash_node_t)))) return -1;
if(!(node->key=malloc(key_sizeP))) {
free(node);
return -1;
}
memcpy(node->key, keyP, key_sizeP);
node->data = dataP;
node->key_size = key_sizeP;
node->key=keyP;
node->data=dataP;
if (hashtblP->nodes[hash]) {
node->next=hashtblP->nodes[hash];
} else {
@@ -212,12 +162,13 @@ hashtable_rc_t obj_hashtable_insert(obj_hash_table_t * const hashtblP, const voi
}
hashtblP->nodes[hash]=node;
return HASH_TABLE_OK;
}//-------------------------------------------------------------------------------------------------------------------------------
}
//-------------------------------------------------------------------------------------------------------------------------------
/*
* To remove an element from the hash table, we just search for it in the linked list for that hash value,
* and remove it if it is found. If it was not found, it is an error and -1 is returned.
*/
hashtable_rc_t obj_hashtable_free(obj_hash_table_t * const hashtblP, const void* const keyP, const int key_sizeP)
hashtable_rc_t obj_hashtable_remove(obj_hash_table_t *hashtblP, const void* keyP, int key_sizeP)
{
obj_hash_node_t *node, *prevnode=NULL;
hash_size_t hash;
@@ -246,44 +197,11 @@ hashtable_rc_t obj_hashtable_free(obj_hash_table_t * const hashtblP, const void*
return HASH_TABLE_KEY_NOT_EXISTS;
}
//-------------------------------------------------------------------------------------------------------------------------------
/*
* To remove an element from the hash table, we just search for it in the linked list for that hash value,
* and remove it if it is found. If it was not found, it is an error and -1 is returned.
*/
hashtable_rc_t obj_hashtable_remove(obj_hash_table_t * const hashtblP, const void* const keyP, const int key_sizeP, void** dataP)
{
obj_hash_node_t *node, *prevnode=NULL;
hash_size_t hash;
if (hashtblP == NULL) {
return HASH_TABLE_BAD_PARAMETER_HASHTABLE;
}
hash=hashtblP->hashfunc(keyP, key_sizeP)%hashtblP->size;
node=hashtblP->nodes[hash];
while(node) {
if ((node->key == keyP) || ((node->key_size == key_sizeP) && (memcmp(node->key, keyP, key_sizeP) == 0))){
if(prevnode) {
prevnode->next=node->next;
} else {
hashtblP->nodes[hash]=node->next;
}
hashtblP->freekeyfunc(node->key);
*dataP = node->data;
free(node);
return HASH_TABLE_OK;
}
prevnode=node;
node=node->next;
}
return HASH_TABLE_KEY_NOT_EXISTS;
}
//-------------------------------------------------------------------------------------------------------------------------------
/*
* Searching for an element is easy. We just search through the linked list for the corresponding hash value.
* NULL is returned if we didn't find it.
*/
hashtable_rc_t obj_hashtable_get(const obj_hash_table_t *const hashtblP, const void* const keyP, const int key_sizeP, void** dataP)
hashtable_rc_t obj_hashtable_get(obj_hash_table_t *hashtblP, const void* keyP, int key_sizeP, void** dataP)
{
obj_hash_node_t *node;
hash_size_t hash;
@@ -313,7 +231,7 @@ hashtable_rc_t obj_hashtable_get(const obj_hash_table_t *const hashtblP, const v
/*
* Function to return all keys of an object hash table
*/
hashtable_rc_t obj_hashtable_get_keys(const obj_hash_table_t * const hashtblP, void ** keysP, unsigned int * sizeP)
hashtable_rc_t obj_hashtable_get_keys(obj_hash_table_t *hashtblP, void ** keysP, unsigned int *sizeP)
{
size_t n = 0;
obj_hash_node_t *node = NULL;
@@ -340,10 +258,10 @@ hashtable_rc_t obj_hashtable_get_keys(const obj_hash_table_t * const hashtblP, v
* If the number of elements are reduced, the hash table will waste memory. That is why we provide a function for resizing the table.
* Resizing a hash table is not as easy as a realloc(). All hash values must be recalculated and each element must be inserted into its new position.
* We create a temporary obj_hash_table_t object (newtbl) to be used while building the new hashes.
* This allows us to reuse hashtable_insert() and hashtable_free(), when moving the elements to the new table.
* This allows us to reuse hashtable_insert() and hashtable_remove(), when moving the elements to the new table.
* After that, we can just free the old table and copy the elements from newtbl to hashtbl.
*/
hashtable_rc_t obj_hashtable_resize(obj_hash_table_t * const hashtblP, const hash_size_t sizeP)
hashtable_rc_t obj_hashtable_resize(obj_hash_table_t *hashtblP, hash_size_t sizeP)
{
obj_hash_table_t newtbl;
hash_size_t n;
@@ -362,7 +280,7 @@ hashtable_rc_t obj_hashtable_resize(obj_hash_table_t * const hashtblP, const has
for(node=hashtblP->nodes[n]; node; node=next) {
next = node->next;
obj_hashtable_insert(&newtbl, node->key, node->key_size, node->data);
obj_hashtable_free(hashtblP, node->key, node->key_size);
obj_hashtable_remove(hashtblP, node->key, node->key_size);
}
}