Grid Application Toolkit A simple API for Grid Applications

Menu Home API-Specification API-Overview Status C Reference Manual Download Java Java-Reference General GridLab - WP-1 Links

GATTable.c Go to the documentation of this file. /** @file GATTable.c * Main file for the GATTable class. * * The GATTable is the object used for hash tables. * It uses a table of elements, which is an array * of linked lists. Keys must be strings. * * @date Tue Sep 24 2003 * * @version $Header: /export/cvs-gridlab/wp-1/Codes/GATEngine/C-reference/src/GATTable.c,v 1.53 2004/04/02 12:31:58 hartmutkaiser Exp $ * * Copyright (C) Gavin Powell * This file is part of the GAT Engine. * Contributed by Gavin Powell <powell@cs.cf.ac.uk>. * * Use, modification and distribution is subject to the Gridlab Software * License. (See accompanying file GLlicense.txt or copy at * http://www.gridlab.org/GLlicense.txt) */ #if defined(sccs) static const char *rcsid = "$Header: /export/cvs-gridlab/wp-1/Codes/GATEngine/C-reference/src/GATTable.c,v 1.53 2004/04/02 12:31:58 hartmutkaiser Exp $"; #endif /* system header files */ #include <stdlib.h> #include <stdio.h> #include <string.h> /* GAT header files */ #include "GATInternal.h" #include "GATType.h" #include "GATTable.h" #include "GATTableAnyKey.h" #include "GATErrors.h" #include "GATXdsWrapper.h" #include "GATUtil.h" /* macros */ /* structures, unions and enums */ typedef struct Hash_String_S { char *data; } *Hash_String; typedef struct Hash_float_S { float data; } *Hash_float; typedef struct Hash_int_S { int32_t data; } *Hash_int; typedef struct Hash_short_S { int16_t data; } *Hash_short; typedef struct Hash_double_S { double data; } *Hash_double; typedef struct Hash_GATObject_S { GATObject data; } *Hash_GATObject; typedef struct Hash_Element_S { GATType type; void *value; char *key; unsigned long hash; struct Hash_Element_S *next; }*Hash_Element; /* define the internal GATTable data structure */ GATOBJECT_DEFINE_VTABLE(GATTable); GATSERIALISABLE_DEFINE_VTABLE(GATTable); struct GATTable_S { /* the GATObject vtable for table object */ GATTable_vtable *GATObject__vtable; /* the GATSerialisable vtable for table object */ GATTable_ISerialisable_vtable *GATSerialisable__vtable; /* genericity support */ GATTable_GetKeySizeProc get_key_size; GATTable_EqualKeysProc equal_keys; GATTable_CloneKeyProc clone_key; GATTable_GetHashProc get_hash; GATTable_DestroyKeyProc destroy_key; /* instance data */ GATuint32 table_length; Hash_Element *table; GATuint32 element_count; GATuint32 load_limit; GATBool isdirty; /* dirty status (changed since last write) */ }; /* Declare the converters to/from GATObject */ GATOBJECT_DEFINE_CONVERTERS(GATTable) /* Static function prototypes */ static GATBool GATTable_Internal_Equal_Keys(GATTable_const table, void const *key1, const void *key2); static unsigned long GATTable_Internal_Hash_sdbm(GATTable_const table, void const *key); static GATuint32 GATTable_Internal_Get_KeySize(GATTable_const table, void const *key); static GATResult GATTable_Internal_CloneKey(GATTable_const table, void const *src, void **dest); static void GATTable_Internal_Destroy_Key(GATTable_const table, void **key); static GATuint32 GATTable_Internal_Index(GATuint32 table_length, unsigned long hash_value); static GATResult GATTable_Internal_Expand(GATTable table); static GATResult GATTable_Internal_Add(GATTable table, const void *key, void *value, GATType type); static GATResult GATTable_SerialiseItems(GATTable_const list, GATXds xds, GATXdsScope flag, void **buffer, size_t *buffer_size, GATBool clear_dirty); static GATResult GATTable_DeSerialise_Create(GATXds xds, GATuint32 table_length, GATuint32 element_count, GATTable *table); /* default callback functions for string keys */ static GATBool GATTable_Internal_Equal_Keys_String(GATTable_const table, void const *key1, const void *key2); static GATuint32 GATTable_Internal_Get_KeySize_String(GATTable_const table, void const *key); static GATResult GATTable_Internal_CloneKey_String(GATTable_const table, void const *src, void **dest); /* compiler generated vtable */ static GATTable_vtable GATTable__vtable = { GATTable_GetType, GATTable_Destroy, GATTable_Equals, GATTable_Clone, GATTable_GetInterface, NULL }; static GATTable_ISerialisable_vtable GATTable_ISerialisable__vtable = { GATTable_Serialise, GATTable_DeSerialise, GATTable_GetIsDirty }; /* External functions */ /** GATTable_Register_GATSerialisable * The GATTable_Register_GATSerialisable function registers the serialization * vtable with the GAT engine to allow generic object creation. * table function is called by the GAT engine, there is no need to use it * directly. */ GATResult GATTable_Register_GATSerialisable() { return GATObject_Register_GATSerialisable(GATType_GATTable, &GATTable_ISerialisable__vtable); } /** GATTable_Create * Create the GATTable object. * This is the method used by any application code to create the GATTable * object. * * @param void. * * @return The GATTable object */ GATTable GATTable_Create(void) { return GATTable_CreateAnyKey(GATTable_Internal_Get_KeySize_String, GATTable_Internal_Equal_Keys_String, GATTable_Internal_CloneKey_String, GATTable_Default_Hash_sdbm, GATTable_Default_Destroy_Key); } /** GATTable_CreateAnyKey * @brief Create the GATTable object. * * This is the method used by any application code to create a GATTable * object, which used the provided callback functions. * * Note though, that objects of this type may not be used for serialisation. * * @param get_keysize The callback function to calculate the size of a given * key. This parameter must be supplied. * @param equalkeys The callback function to compare two keys for equality. If * this param is 0 (zero) the default callback function will be used * (GATTable_Default_Equal_Keys). * @param get_hash The callback function to calculate the hash value for a * given key. If this param is 0 (zero) the default callback function * will be used used (GATTable_Default_Hash_sdbm). * @param destroy_key The callback function to destroy a key (deallocate all * associated memory). If this parameter is 0 (zero), the default * callback function will be used (GATTable_Default_Destroy_Key). * * @return The GATTable object */ GATTable GATTable_CreateAnyKey(GATTable_GetKeySizeProc get_keysize, GATTable_EqualKeysProc equalkeys, GATTable_CloneKeyProc copykey, GATTable_GetHashProc get_hash, GATTable_DestroyKeyProc destroy_key) { GATTable table; /* the hash structure */ GATuint32 i; /* counter */ GATuint32 size = 1u; /* power of 2 sizing constraint */ GATuint32 minsize = 16; /* start size of table */ float const maxloadfactor = 0.75f; /* loading for table expand */ /* Enforce size as power of 2 */ while (size < minsize) size <<= 1; if ((table = (GATTable) malloc(sizeof (struct GATTable_S))) != NULL) { memset(table, 0, sizeof(struct GATTable_S)); table->GATObject__vtable = &GATTable__vtable; table->GATSerialisable__vtable = &GATTable_ISerialisable__vtable; table->get_key_size = get_keysize; table->equal_keys = (NULL != equalkeys) ? equalkeys : GATTable_Default_Equal_Keys; table->clone_key = (NULL != copykey) ? copykey : GATTable_Default_Clone_Key; table->get_hash = (NULL != get_hash) ? get_hash : GATTable_Default_Hash_sdbm; table->destroy_key = (NULL != destroy_key) ? destroy_key : GATTable_Default_Destroy_Key; if ((table->table = (Hash_Element *) malloc(sizeof (Hash_Element) * size)) == NULL) { free(table); table = NULL; } else { /* initiate the table pointers */ for (i = 0; i < size; i++) { table->table[i] = NULL; } table->table_length = size; table->element_count = 0; table->load_limit = (GATuint32) ((float) size * maxloadfactor); } } return table; } /** GATTable_GetType * Return the type of the GATTable object. * table is the method used by any * application code to return the type of a given GATTable * object. * * @param GATTable The table to analyze. * * @return Always returns GATType_GATTable */ GATType GATTable_GetType(GATTable_const table) { GAT_UNUSED_PARAMETER(table); return GATType_GATTable; } /** GATTable_Clone * Clone the GATTable object. * table is the method used by any * application code to clone a GATTable * object. * * @param GATTable The table to copy. * * @return The cloned GATTable object */ GATResult GATTable_Clone(GATTable_const table, GATTable *new_table) { GATTable clone; /* the cloned hash structure */ GATuint32 i; /* counter */ Hash_Element element; /* element to copy across */ GATResult result; /* error checking */ result = GAT_SUCCESS; *new_table = NULL; if ((clone = (GATTable) malloc(sizeof (struct GATTable_S))) != NULL) /* create the table */ { memset(clone, 0, sizeof(struct GATTable_S)); clone->GATObject__vtable = &GATTable__vtable; clone->GATSerialisable__vtable = &GATTable_ISerialisable__vtable; clone->equal_keys = table->equal_keys; clone->get_hash = table->get_hash; clone->clone_key = table->clone_key; clone->get_key_size = table->get_key_size; clone->destroy_key = table->destroy_key; if ((clone->table = (Hash_Element *) malloc(sizeof (Hash_Element) * table->table_length)) != NULL) { memset(clone->table, 0, sizeof (Hash_Element) * table->table_length); clone->table_length = table->table_length; clone->element_count = 0; clone->load_limit = table->load_limit; for(i=0; i<table->table_length;i++) /* copy data across */ { for(element = table->table[i];;) { if(element == NULL) { break; } else switch(element->type) { case GATType_GATint32: result = GATTable_Add_int(clone, element->key, ((Hash_int)element->value)->data); break; case GATType_GATint16: result = GATTable_Add_short(clone, element->key, ((Hash_short)element->value)->data); break; case GATType_GATdouble64: result = GATTable_Add_double(clone, element->key, ((Hash_double)element->value)->data); break; case GATType_String: result = GATTable_Add_String(clone, element->key, ((Hash_String)element->value)->data); break; case GATType_GATfloat32: result = GATTable_Add_float(clone, element->key, ((Hash_float)element->value)->data); break; default: if (GATType_GATObject & element->type) { result = GATTable_Add_GATObject(clone, element->key, ((Hash_GATObject) element->value)->data); } else { result = GAT_KEY_TYPE_ERROR; } break; } if(result != GAT_SUCCESS) { GATTable_Destroy(&clone); clone = NULL; break; } else { element = element->next; } } if(result != GAT_SUCCESS) { break; } } } } if (GAT_SUCCESS == result) { *new_table = clone; } return result; } /** GATTable_Equals * @brief Compares two tables * * The function @c GATTable_Equals compares two tables @c GATTable, * which hold arbitrary data. * * @param lhs The first table to compare * @param rhs The second table to compare * * @return GAT_SUCCESS on equality, and GAT_FALSE otherwise. May return other * error codes too. */ GATResult GATTable_Equals(GATTable_const lhs, GATTable_const rhs, GATBool *isequal) { GATResult result = GAT_SUCCESS; *isequal = GATFalse; if (NULL == lhs || NULL == rhs || NULL == isequal) { /* one of the parameters is 0 (zero) */ result = GAT_INVALID_HANDLE; } else { if (lhs->element_count != rhs->element_count || lhs->table_length != rhs->table_length) { /* element count is different */ result = GAT_SUCCESS; } else { GATuint32 i = 0; for(/**/; i < lhs->table_length; ++i) { Hash_Element lhs_e = lhs->table[i]; Hash_Element rhs_e = rhs->table[i]; *isequal = GATTrue; for(/**/; NULL != lhs_e; lhs_e = lhs_e->next, rhs_e = rhs_e->next) { if (NULL == rhs_e || lhs_e->type != rhs_e->type) { break; } switch(lhs_e->type) { case GATType_GATint16: *isequal = (((Hash_short) lhs_e->value)->data == ((Hash_short) rhs_e->value)->data) ? GATTrue : GATFalse; break; case GATType_GATint32: *isequal = (((Hash_int) lhs_e->value)->data == ((Hash_int) rhs_e->value)->data) ? GATTrue : GATFalse; break; case GATType_GATfloat32: *isequal = (((Hash_float) lhs_e->value)->data == ((Hash_float) rhs_e->value)->data) ? GATTrue : GATFalse; break; case GATType_GATdouble64: *isequal = (((Hash_double) lhs_e->value)->data == ((Hash_double) rhs_e->value)->data) ? GATTrue : GATFalse; break; case GATType_String: *isequal = GATTable_Internal_Equal_Keys(lhs, ((Hash_String) lhs_e->value)->data, ((Hash_String) rhs_e->value)->data); break; default: if (GATType_GATObject & lhs_e->type) { /* we have to compare two GATObject's */ result = GATObject_Equals(((Hash_GATObject) lhs_e->value)->data, ((Hash_GATObject) rhs_e->value)->data, isequal); } else { result = GAT_KEY_TYPE_ERROR; } break; } if(result != GAT_SUCCESS || GATFalse == *isequal) { break; } } /* inner for() */ if(result != GAT_SUCCESS || GATFalse == *isequal) { break; } } /* outer for */ } } return result; } /** GATTable_Destroy * Destroy a hash table and free all memory. * * @param table Pointer to the hash table. * * @return void */ void GATTable_Destroy(GATTable * table) { if (NULL != table && NULL != *table) { GATuint32 i; Hash_Element e; /* element to free */ Hash_Element f; /* remember last element to free */ Hash_Element *t = (*table)->table; for (i = 0; i < (*table)->table_length; i++) { e = t[i]; while (NULL != e) { f = e; /* copy pointer across */ e = e->next; /* iterate list */ if (f->type == GATType_String) { free(((Hash_String) f->value)->data); } else if (f->type & GATType_GATObject) { GATObject_Destroy(&((Hash_GATObject) f->value)->data); } GATTable_Internal_Destroy_Key(*table, (void **) &f->key); free(f->value); free(f); } } free((*table)->table); free(*table); *table = NULL; } } /** int GATTable_GetInterface(GATTable_const table, GATInterface iftype, void const **ifp) * @brief Get an interface supported by a GATTable * * The function GATTable_GetInterface allows to get a pointer to an * additional interface supported by table GATTable. * * @param object The object to be asked for the new interface. * @param iftype The interface the object is to be asked for. * @param ifp The pointer, through which the result is to be returned. * * @return An error type. */ GATResult GATTable_GetInterface(GATTable_const table, GATInterface iftype, void const **ifp) { GATResult retval = GAT_INVALID_PARAMETER; if (NULL != ifp && NULL != table) { *ifp = NULL; if (GATInterface_ISerialisable == iftype) { *ifp = (void const *) &table->GATSerialisable__vtable; retval = GAT_SUCCESS; } else { retval = GAT_NO_INTERFACE; } } return retval; } /* GATTable API functions */ /** GATTable_Remove * Remove a key,value pair from the hash table. * * @param table The hash table to remove from. * @param key The the key for the key,value pair to be removed * * @return GAT error code */ GATResult GATTable_Remove(GATTable table, const void *key) { Hash_Element e; /* element to remove */ Hash_Element *pE; GATResult result; GATuint32 table_index = GATTable_Internal_Index(table->table_length, GATTable_Internal_Hash_sdbm(table, key)); pE = &(table->table[table_index]); e = *pE; result = GAT_KEY_NOT_FOUND; while (NULL != e) { if (GATTrue == GATTable_Internal_Equal_Keys(table, key, e->key)) { table->element_count--; table->isdirty = GATTrue; *pE = e->next; if (e->type == GATType_String) { free(((Hash_String) e->value)->data); } else if (e->type & GATType_GATObject) { GATObject_Destroy(&((Hash_GATObject) e->value)->data); } GATTable_Internal_Destroy_Key(table, (void **) &e->key); free(e->value); free(e); result = GAT_SUCCESS; break; } pE = &(e->next); /* join the list back up */ e = e->next; } return result; } /** GATTable_Add_Int * Add a type int to the hash table. * * @param table The hash table to add the data to. * @param key The key value to associate the data to. * @param data The int data to be added * * @return GAT error code */ GATResult GATTable_Add_int(GATTable table, const void *key, GATint32 data) { Hash_int p_int; /* pointer to Hash_int struct */ GATResult result; if ((p_int = (Hash_int) malloc(sizeof (struct Hash_int_S))) != NULL) { p_int->data = data; /* data to Add */ result = GATTable_Internal_Add(table, key, p_int, GATType_GATint32); if (GAT_SUCCESS != result) { free(p_int); } } else { result = GAT_MEMORYFAILURE; } return result; } /** GATTable_Add_Short * Add a type short to the hash table. * * @param table The hash table to add the data to. * @param key The key value to associate the data to. * @param data The short data to be added * * @return GAT error code */ GATResult GATTable_Add_short(GATTable table, const void *key, GATint16 data) { Hash_short p_short; /* pointer to gat short struct */ GATResult result; if ((p_short = (Hash_short) malloc(sizeof (struct Hash_short_S))) != NULL) { p_short->data = data; /* data to Add */ result = GATTable_Internal_Add(table, key, p_short, GATType_GATint16); if (GAT_SUCCESS != result) { free(p_short); } } else { result = GAT_MEMORYFAILURE; } return result; } /** GATTable_Add_Double * Add a type double to the hash table. * * @param table The hash table to add the data to. * @param key The key value to associate the data to. * @param data The double data to be added * * @return GAT error code */ GATResult GATTable_Add_double(GATTable table, const void *key, GATdouble64 data) { Hash_double p_double; /* pointer to gat double struct */ GATResult result; if ((p_double = (Hash_double) malloc(sizeof (struct Hash_double_S))) != NULL) { p_double->data = data; /* data to Add */ result = GATTable_Internal_Add(table, key, p_double, GATType_GATdouble64); if (GAT_SUCCESS != result) { free(p_double); } } else { result = GAT_MEMORYFAILURE; } return result; } /** GATTable_Add_Float * Add a type float to the hash table. * * @param table The hash table to add the data to. * @param key The key value to associate the data to. * @param data The float data to be added * * @return GAT error code */ GATResult GATTable_Add_float(GATTable table, const void *key, GATfloat32 data) { Hash_float p_float; /* pointer to Hash_float struct */ GATResult result; if ((p_float = (Hash_float) malloc(sizeof (struct Hash_float_S))) != NULL) { p_float->data = data; /* data to Add */ result = GATTable_Internal_Add(table, key, p_float, GATType_GATfloat32); if (GAT_SUCCESS != result) { free(p_float); } } else { result = GAT_MEMORYFAILURE; } return result; } /** GATTable_Add_String * Add a type string to the hash table. * * @param table The hash table to add the data to. * @param key The key value to associate the data to. * @param data The string data to be added * * @return GAT error code */ GATResult GATTable_Add_String(GATTable table, const void *key, const char *data) { Hash_String p_string; /* pointer to Hash_String struct */ GATResult result; if ((p_string = (Hash_String) malloc(sizeof (struct Hash_String_S))) == NULL) { result = GAT_MEMORYFAILURE; } else if ((p_string->data = (char *) malloc(sizeof (char) * (strlen(data)+1))) == NULL) { free(p_string); result = GAT_MEMORYFAILURE; } else { strcpy(p_string->data, data); /* data to Add */ result = GATTable_Internal_Add(table, key, p_string, GATType_String); if (GAT_SUCCESS != result) { free(p_string->data); free(p_string); } } return result; } /** GATTable_Add_GATObject * Add a type GATObject to the hash table. * * @param table The hash table to add the data to. * @param key The key value to associate the data to. * @param data The float data to be added * * @return GAT error code */ GATResult GATTable_Add_GATObject(GATTable table, const void *key, GATObject_const data) { Hash_GATObject p_object; /* pointer to Hash_GATObject struct */ GATResult result; if ((p_object = (Hash_GATObject) malloc(sizeof (struct Hash_GATObject_S))) != NULL) { result = GATObject_Clone(data, &p_object->data); /* data to Add */ if (GAT_SUCCESS == result) { result = GATTable_Internal_Add(table, key, p_object, GATType_GATObject); if (GAT_SUCCESS != result) { GATObject_Destroy(&p_object->data); free(p_object); } } else { free(p_object); } } else { result = GAT_MEMORYFAILURE; } return result; } /** GATTable_Get_ElementType * Get the type associated with a key. * * @param table The hash table to get the type from. * @param key The key value associated with the data type. * * @return GATType */ GATType GATTable_Get_ElementType(GATTable_const table, const void *key) { Hash_Element e; /* element to get type for */ unsigned long hash_value; GATuint32 table_index; GATType result; hash_value = GATTable_Internal_Hash_sdbm(table, key); table_index = GATTable_Internal_Index(table->table_length, hash_value); e = table->table[table_index]; result = GATType_NoType; while (NULL != e) { if ((hash_value == e->hash) && (GATTrue == GATTable_Internal_Equal_Keys(table, key, e->key))) { result = e->type; break; } e = e->next; } return result; } /** GATTable_GetKeys * Get a list of all the current keys in the hash table. The key list is * terminated by a NULL * * @param table The hash table to get the keys from. * * @return the list of keys */ void **GATTable_GetKeys(GATTable_const table) { void **list = NULL; /* list of keys */ GATuint32 i = 0; GATuint32 key_no = 0; /* key found counter */ int retval = GAT_SUCCESS; list = (void **)malloc(sizeof(void *) * (table->element_count+1)); if (NULL != list) { memset(list, 0, sizeof(void *) * (table->element_count+1)); for (/**/; i < table->table_length; ++i) { if (NULL != table->table[i]) { Hash_Element hold = table->table[i]; retval = GAT_SUCCESS; do { retval = GATTable_Internal_CloneKey(table, hold->key, &list[key_no++]); if (GAT_SUCCESS != retval) { break; } } while (NULL != (hold = hold->next)); } } list[key_no] = NULL; /* list terminator */ } else { retval = GAT_MEMORYFAILURE; } if (GAT_SUCCESS != retval) { /* on error all the allocated memory should be free'd */ for (i = 0, key_no = 0; i < table->table_length; ++i) { free(list[key_no++]); } free(list); list = NULL; } return list; } /** * * */ void GATTable_ReleaseKeys(GATTable_const this, void ***keys) { GAT_UNUSED_PARAMETER(this); if (NULL != keys && NULL != *keys) { GATuint32 i = 0; for (/**/; NULL != (*keys)[i]; ++i) { free((*keys)[i]); } free(*keys); *keys = NULL; } } /** GATTable_Get_Int * Get the int type data associated with a key. * * @param table The hash table get the data from. * @param key The key value to associate the data to. * @param data The recovered int data * * @return GAT error code */ GATResult GATTable_Get_int(GATTable_const table, const void *key, GATint32 *data) { GATResult result = GAT_INVALID_HANDLE; if (NULL != table) { Hash_Element e; /* element to add */ unsigned long hash_value; /* has value for key */ GATuint32 table_index; /* index of hash */ hash_value = GATTable_Internal_Hash_sdbm(table, key); table_index = GATTable_Internal_Index(table->table_length, hash_value); e = table->table[table_index]; result = GAT_KEY_NOT_FOUND; while (NULL != e) { if ((hash_value == e->hash) && (GATTrue == GATTable_Internal_Equal_Keys(table, key, e->key))) { if (e->type == GATType_GATint32) { if (NULL != data) { *data = ((Hash_int) e->value)->data; result = GAT_SUCCESS; } else { result = GAT_INVALID_PARAMETER; } break; } else { result = GAT_KEY_TYPE_ERROR; break; } } e = e->next; } } return result; } /** GATTable_Get_Short * Get the short type data associated with a key. * * @param table The hash table get the data from. * @param key The key value to associate the data to. * @param data The recovered short data * * @return GAT error code */ GATResult GATTable_Get_short(GATTable_const table, const void *key, GATint16 *data) { GATResult result = GAT_INVALID_HANDLE; if (NULL != table) { Hash_Element e; /* element to add */ unsigned long hash_value; /* has value for key */ GATuint32 table_index; /* index of hash */ hash_value = GATTable_Internal_Hash_sdbm(table, key); table_index = GATTable_Internal_Index(table->table_length, hash_value); e = table->table[table_index]; result = GAT_KEY_NOT_FOUND; while (NULL != e) { if ((hash_value == e->hash) && (GATTrue == GATTable_Internal_Equal_Keys(table, key, e->key))) { if (e->type == GATType_GATint16) { if (NULL != data) { *data = ((Hash_short) e->value)->data; result = GAT_SUCCESS; } else { result = GAT_INVALID_PARAMETER; } break; } else { result = GAT_KEY_TYPE_ERROR; break; } } e = e->next; } } return result; } /** GATTable_Get_Double * Get the double type data associated with a key. * * @param table The hash table get the data from. * @param key The key value to associate the data to. * @param data The recovered double data * * @return GAT error code */ GATResult GATTable_Get_double(GATTable_const table, const void *key, double *data) { GATResult result = GAT_INVALID_HANDLE; if (NULL != table) { Hash_Element e; /* element to add */ unsigned long hash_value; /* has value for key */ GATuint32 table_index; /* index of hash */ hash_value = GATTable_Internal_Hash_sdbm(table, key); table_index = GATTable_Internal_Index(table->table_length, hash_value); e = table->table[table_index]; result = GAT_KEY_NOT_FOUND; while (NULL != e) { if ((hash_value == e->hash) && (GATTrue == GATTable_Internal_Equal_Keys(table, key, e->key))) { if (e->type == GATType_GATdouble64) { if (NULL != data) { *data = ((Hash_double) e->value)->data; result = GAT_SUCCESS; } else { result = GAT_INVALID_PARAMETER; } break; } else { result = GAT_KEY_TYPE_ERROR; break; } } e = e->next; } } return result; } /** GATTable_Get_Float * Get the float type data associated with a key. * * @param table The hash table get the data from. * @param key The key value to associate the data to. * @param data The recovered float data * * @return GAT error code */ GATResult GATTable_Get_float(GATTable_const table, const void *key, float *data) { GATResult result = GAT_INVALID_HANDLE; if (NULL != table) { Hash_Element e; /* element to add */ unsigned long hash_value; /* has value for key */ GATuint32 table_index; /* index of hash */ hash_value = GATTable_Internal_Hash_sdbm(table, key); table_index = GATTable_Internal_Index(table->table_length, hash_value); e = table->table[table_index]; result = GAT_KEY_NOT_FOUND; while (NULL != e) { if ((hash_value == e->hash) && (GATTrue == GATTable_Internal_Equal_Keys(table, key, e->key))) { if (e->type == GATType_GATfloat32) { if (NULL != data) { *data = ((Hash_float) e->value)->data; result = GAT_SUCCESS; } else { result = GAT_INVALID_PARAMETER; } break; } else { result = GAT_KEY_TYPE_ERROR; break; } } e = e->next; } } return result; } /** GATTable_Get_String * Get the string type data associated with a key. * * @param table The hash table get the data from. * @param key The key value to associate the data to. * @param data The recovered string data. If table parameter is 0 (zero), the * function does not try to recover the data but simply returns the * required size of the buffer needed to recover the data. * @param length length of the string buffer arg data * * @return length of string found or error code */ GATResult GATTable_Get_String(GATTable_const table, const void *key, char *data, GATuint32 length) { GATResult result = GAT_INVALID_HANDLE; if (NULL != table) { Hash_Element e; /* element to add */ unsigned long hash_value; /* has value for key */ GATuint32 table_index; /* index of hash */ GATuint32 element_length; hash_value = GATTable_Internal_Hash_sdbm(table, key); table_index = GATTable_Internal_Index(table->table_length, hash_value); e = table->table[table_index]; result = GAT_KEY_NOT_FOUND; while (NULL != e) { if ((hash_value == e->hash) && (GATTrue == GATTable_Internal_Equal_Keys(table, key, e->key))) { if (e->type == GATType_String) { element_length = strlen(((Hash_String) e->value)->data); if (NULL != data) { if (element_length >= length) /* remember the null char */ { memcpy(data, ((Hash_String) e->value)->data, (sizeof (char) * (length-1))); data[length-1] = '\0'; /* make sure! */ } else { memcpy(data, ((Hash_String) e->value)->data, (sizeof (char) * element_length)); data[element_length] = '\0'; } } result = element_length; break; } else { result = GAT_KEY_TYPE_ERROR; break; } } e = e->next; } } return result; } /** GATTable_Get_GATObject * Get the GATObject type data associated with a key. * * @param table The hash table get the data from. * @param key The key value to associate the data to. * @param data The recovered GATObject data * * @return GAT error code */ GATResult GATTable_Get_GATObject(GATTable_const table, const void *key, GATObject_const *data) { GATResult result = GAT_INVALID_HANDLE; if (NULL != table) { Hash_Element e; /* element to add */ unsigned long hash_value; /* has value for key */ GATuint32 table_index; /* index of hash */ hash_value = GATTable_Internal_Hash_sdbm(table, key); table_index = GATTable_Internal_Index(table->table_length, hash_value); e = table->table[table_index]; result = GAT_KEY_NOT_FOUND; while (NULL != e) { if ((hash_value == e->hash) && (GATTrue == GATTable_Internal_Equal_Keys(table, key, e->key))) { if (e->type == GATType_GATObject) { if (NULL != data) { *data = ((Hash_GATObject) e->value)->data; result = GAT_SUCCESS; } else { result = GAT_INVALID_PARAMETER; } break; } else { result = GAT_KEY_TYPE_ERROR; break; } } e = e->next; } } return result; } /* GATTable_internal_Get_GATObjectRef * * The functions GATTable_internal_Get_GATObjectRef allows to access a * GATObject stored inside a GATTable without copying it. * * @param table The hash table get the data from. * @param key The key value to associate the data to. * @param data The recovered reference to the GATObject data * * @remark This is an internal function, do not use it directly. * * @return An error code. */ GATResult GATTable_internal_Get_GATObjectRef(GATTable_const table, const void *key, GATObject *object) { GATResult result = GAT_INVALID_HANDLE;; if (NULL != table) { Hash_Element e; /* element to add */ unsigned long hash_value; /* has value for key */ GATuint32 table_index; /* index of hash */ hash_value = GATTable_Internal_Hash_sdbm(table, key); table_index = GATTable_Internal_Index(table->table_length, hash_value); e = table->table[table_index]; result = GAT_KEY_NOT_FOUND; while (NULL != e) { if ((hash_value == e->hash) && (GATTrue == GATTable_Internal_Equal_Keys(table, key, e->key))) { if (e->type == GATType_GATObject) { if (NULL != object) { *object = ((Hash_GATObject) e->value)->data; result = GAT_SUCCESS; } else { result = GAT_INVALID_PARAMETER; } break; } else { result = GAT_KEY_TYPE_ERROR; break; } } e = e->next; } } return result; } /* GATAdvertiseable API */ /** int GATTable_Serialise(GATTable_const table, GATObject stream, GATBool clear_dirty) * @brief Serialise a GATTable object * * The function GATTable_Serialise serialises the given GATTable object into * the given stream. * * @param file The GATTable object to serialise. * @param stream The stream interface to use for the serialisation. * @param clear_dirty If the clear_dirty parameter is set to GATTrue, the * internal dirty flag of table object is to be reset (no used here) * * @return An error code. */ GATResult GATTable_Serialise(GATTable table, GATObject stream, GATBool clear_dirty) { GATResult retval = GAT_INVALID_HANDLE; if (NULL != table) { GATXds xds = NULL; void *xds_buffer = NULL; GATuint32 xds_buffer_size = 0; void *xds_item_buffer = NULL; GATuint32 xds_item_buffer_size = 0; if (GAT_SUCCESS == (retval = GATXds_Init(&xds, GATXdsType_Encode)) && GAT_SUCCESS == (retval = GATXds_Encode(xds, GATXdsScope_Gift, &xds_buffer, (size_t *) &xds_buffer_size, "uint32 uint32 uint32", GATTABLE_VERSION1, table->table_length, table->element_count)) && GAT_SUCCESS == (retval = GATTable_SerialiseItems(table, xds, GATXdsScope_Gift, &xds_item_buffer, (size_t *) &xds_item_buffer_size, clear_dirty))) { /* write the buffer len to ease de-serialisation */ void *xds_size_buffer = NULL; GATuint32 xds_size_buffer_size = 0; if (GAT_SUCCESS == (retval = GATXds_Encode(xds, GATXdsScope_Gift, &xds_size_buffer, (size_t *) &xds_size_buffer_size, "uint32", xds_buffer_size + xds_item_buffer_size))) { assert(NULL != xds_size_buffer); retval = GATStreamable_Write(stream, xds_size_buffer, xds_size_buffer_size, 0); if (GAT_SUCCESS == retval) { /* write the GATTable instance data */ assert(NULL != xds_buffer); retval = GATStreamable_Write(stream, xds_buffer, xds_buffer_size, 0); } if (GAT_SUCCESS == retval) { /* write the GATTable item data */ retval = GATStreamable_Write(stream, xds_item_buffer, xds_item_buffer_size, 0); if (GAT_SUCCESS == retval && clear_dirty) { table->isdirty = GATFalse; /* clear the dirty flag of table table */ } } } free(xds_size_buffer); } free(xds_item_buffer); free(xds_buffer); GATXds_Destroy(&xds); } return retval; } /** GATTable GATTable_DeSerialise(GATContext context, GATObject stream, GATBool clear_dirty) * @brief De-serialise a GATTable object * * The function GATTable_DeSerialise de-serialises a streamed GATTable object * from the given stream It constructs a new instance of the de-serialised * object. * * @param context The GAT context to be used for object construction. * @param stream The stream interface to use for the serialisation. * @param result The pointer to a variable, which receives the status code of * the operation. * * @return The newly constructed GATTable object. */ GATTable GATTable_DeSerialise(GATContext context, GATObject stream, GATResult *result) { GATTable table = NULL; char buffer[64]; /* seems to be sufficient for a GATuint32 value */ GATuint32 xds_read_bytes = 0; int retval = GATStreamable_Read(stream, buffer, sizeof(buffer), &xds_read_bytes); if (GAT_SUCCESS == retval) { GATXds xds = NULL; if (GAT_SUCCESS == (retval = GATXds_InitEx(&xds, GATXdsType_Decode, context))) { GATuint32 xds_buffer_size = 0; /* read the expected size of the stream for table object */ retval = GATXds_Decode(xds, GATXdsScope_Loan, buffer, sizeof(buffer), "uint32", &xds_buffer_size); if (GAT_SUCCESS == retval) { /* reposition the input stream to start with the real object data */ retval = GATStreamable_Seek(stream, GATOrigin_Current, GATXds_GetBufferLen(xds) - xds_read_bytes, 0); if (GAT_SUCCESS == retval) { /* read the object data itself */ char *xds_buffer = (char *)malloc(xds_buffer_size); if (NULL == xds_buffer) { retval = GAT_MEMORYFAILURE; } else if (GAT_SUCCESS == (retval = GATStreamable_Read(stream, xds_buffer, xds_buffer_size, 0))) { /* read the version */ GATuint32 version = 0; retval = GATXds_Decode(xds, GATXdsScope_Gift, xds_buffer, xds_buffer_size, "uint32", &version); if (GAT_SUCCESS != retval || (version & ~GATTABLE_MINOR_MASK) > GATTABLE_LASTVERSION) { retval = GAT_UNKNOWN_FORMAT; } else { /* read the data */ GATuint32 table_length = 0; GATuint32 element_count = 0; retval = GATXds_Decode(xds, (GATXdsScope)0, 0, 0, "uint32 uint32", &table_length, &element_count); if (GAT_SUCCESS == retval) { /* construct the new object */ retval = GATTable_DeSerialise_Create(xds, table_length, element_count, &table); } } } } } } GATXds_Destroy(&xds); /* FIXME: GATStatus(retval); */ } if (NULL != result) { *result = retval; } return table; } /** GATTable_GetIsDirty * * The function GATTable_GetIsDirty retrieves the status of the dirty flag of * table GATTable object. * * @param file The GATTable object to inspect for its dirty status. * @param isdirty The pointer to a variable, which receives the dirty status. * * @return An error code. */ GATResult GATTable_GetIsDirty(GATTable_const table, GATBool *isdirty) { GATResult retval = GAT_INVALID_HANDLE; if (NULL != table) { if (NULL != isdirty) { *isdirty = table->isdirty; retval = GAT_SUCCESS; } else { retval = GAT_INVALID_PARAMETER; } } return retval; } /** GATTable_Default_Hash_sdbm * * The function GATTable_Default_Hash_sdbm is the default callback function * which is used to calculate the hash value for a given key. * This function calculates the hash value based on the plain memory * representation of the key. * * @param table The table, for which this hash value is to be calculated. * @param key The key to create a hash from. * * @return the hash value */ unsigned long GATTable_Default_Hash_sdbm(GATTable_const table, void const *key) { GATuint32 key_size = GATTable_Internal_Get_KeySize(table, key); unsigned long hash = 0; /*int c = *((int8_t *) key)++; */ int8_t* tmp = (int8_t *) key; int8_t c = *tmp++; GATuint32 i = 1; for (/**/; i < key_size; ++i) { hash = c + (hash << 6) + (hash << 16) - hash; if (i < key_size) { /* c = *((int8_t *) key)++; */ c = *tmp++; } } return hash; } /** GATTable_Default_Clone_Key * * The function GATTable_Default_Clone_Key is the default callback function * which is used to copy a key to a new location. * This function calculates copies the key with the help of the function * memcpy. * * @param table The table, into which this key is to be inserted. * @param src The source memory area, where the key is to be copied from. * @param dest The destination area, which receives the new key. * * @return A GAT error code. */ GATResult GATTable_Default_Clone_Key(GATTable_const table, void const *src, void **dest) { GATuint32 key_size = GATTable_Internal_Get_KeySize(table, src); *dest = GATUtil_memdup(src, key_size); return (NULL != *dest) ? GAT_SUCCESS : GAT_MEMORYFAILURE; } /** GATTable_Default_Equal_Keys * * The function GATTable_Default_Equal_Keys is the default callback function * which is used to compare two different keys of a GATTableAnyKey for * equality. * This function compares the keys with the help of the function memcmp. * * @param table The table, for which these keys are to be used. * @param key1 first key for comparison. * @param key2 second key for comparison. * * @return GATTrue for equal keys, GATFalse for non equal keys */ GATBool GATTable_Default_Equal_Keys(GATTable_const table, void const *key1, void const *key2) { GATuint32 key_size1 = GATTable_Internal_Get_KeySize(table, key1); GATuint32 key_size2 = GATTable_Internal_Get_KeySize(table, key2); GATBool retval = GATFalse; if (key_size1 == key_size2) { retval = (0 == memcmp(key1, key2, key_size1)) ? GATTrue : GATFalse; } return retval; } /** GATTable_Default_Destroy_Key * * The function GATTable_Default_Destroy_Key is the default callback function * which is used to destroy a key (deallocate all associated memory). * This function compares free's the key with the std function free(). * * @param table The table, for which these keys are to be used. * @param key The pointer to the key to deallocate. */ void GATTable_Default_Destroy_Key(GATTable_const table, void **key) { GAT_UNUSED_PARAMETER(table); if (NULL != key && NULL != *key) { free(*key); *key = NULL; } } /** GATTable_Size * @brief Return the number of elements stored inside a table * * The function @c GATTable_Size returns the number of elements, currently * stored inside the given table. * * @param table The table to be queried for its number of elements * * @return If successful, the function returns number of elements. If an error * occures, (size_t)(-1) is returned. */ GATuint32 GATTable_Size(GATTable_const table) { GATuint32 retval = (GATuint32)(-1); if (NULL != table) { retval = table->element_count; } return retval; } /* Local functions */ /** GATTable_Internal_Equal_keys * Compare the values of two hash keys. * * @param table The table, for which these keys are to be used. * @param key1 first key for comparison * @param key2 second key for comparison * * @return GATTrue for equal keys, GATFalse for non equal keys */ static GATBool GATTable_Internal_Equal_Keys(GATTable_const table, void const *key1, void const *key2) { return table->equal_keys(table, key1, key2); } static GATBool GATTable_Internal_Equal_Keys_String(GATTable_const table, void const *key1, void const *key2) { GAT_UNUSED_PARAMETER(table); return (0 == strcmp((char const *) key1, (char const *) key2)) ? GATTrue : GATFalse; } /** GATTable_Internal_Hash_sdbm * Creates a hash from a key using sdbm. * * @param table The table, for which this hash value is to be calculated. * @param key The key to create a hash from. * * @return the hash value */ static unsigned long GATTable_Internal_Hash_sdbm(GATTable_const table, void const *key) { return table->get_hash(table, key); } /** GATTable_Internal_Get_KeySize * * The function GATTable_Internal_Get_KeySize returns the size to be allocated * for the given key. * * @param table The table, into which this key is to be inserted. * @param key The key to calculate the size for */ static GATuint32 GATTable_Internal_Get_KeySize(GATTable_const table, void const *key) { return table->get_key_size(table, key); } static GATuint32 GATTable_Internal_Get_KeySize_String(GATTable_const table, void const *key) { GAT_UNUSED_PARAMETER(table); return strlen((char const *) key) + 1; } /** GATTable_Internal_CloneKey * * The function GATTable_Internal_CloneKey is used to copy a key. * * @param table The table, into which this key is to be inserted. * @param dest The destination area, where the new key is to be constructed * (the memory was allocated already). * @param src The source memory area, where the key is to be copied from. * * @return A GAT error code. */ static GATResult GATTable_Internal_CloneKey(GATTable_const table, void const *src, void **dest) { return table->clone_key(table, src, dest); } static GATResult GATTable_Internal_CloneKey_String(GATTable_const table, void const *src, void **dest) { GAT_UNUSED_PARAMETER(table); *dest = GATUtil_strdup((char const *)src); return (NULL != *dest) ? GAT_SUCCESS : GAT_MEMORYFAILURE; } /** GATTable_Internal_Destroy_Key * * The function GATTable_Default_Destroy_Key is the default callback function * which is used to destroy a key (deallocate all associated memory). * This function compares free's the key with the std function free(). * * @param table The table, for which these keys are to be used. * @param key The pointer to the key to deallocate. */ static void GATTable_Internal_Destroy_Key(GATTable_const table, void **key) { table->destroy_key(table, key); } /** GATTable_Internal_Index * Find the hash table index for a given hash value. * The table must be of 2^n * * @param table_length The length of the hash table. * @param hash_value The hash value that the index is required for * * @return the index for the hash value */ static GATuint32 GATTable_Internal_Index(GATuint32 table_length, unsigned long hash_value) { return (hash_value & (table_length - 1u)); /* Only works if * tablelength == 2^N */ } /** GATTable_Internal_Expand * Expands the hash table by a 2^n+1. * * @param table The hash table to expand. * * @return GAT error code */ static GATResult GATTable_Internal_Expand(GATTable table) { GATuint32 new_size = table->table_length << 1; GATuint32 table_index; GATResult result; /* Check table fullness */ if (0 == new_size) { result = GAT_MEMORYFAILURE; } else { Hash_Element *new_table = (Hash_Element *) realloc(table->table, new_size * sizeof (Hash_Element)); if (NULL == new_table) { result = GAT_MEMORYFAILURE; /* should new_table be free'd? */ } else { GATuint32 i = table->table_length; table->table = new_table; /* clean contents */ for (/**/; i < new_size; i++) { new_table[i] = NULL; } for (i = 0; i < table->table_length; i++) /* copy */ { Hash_Element *pE; /* pointer to a table element */ Hash_Element e; /* a table element */ for (pE = &(new_table[i]), e = *pE; e != NULL; e = *pE) { table_index = GATTable_Internal_Index(new_size, e->hash); if (table_index == i) { pE = &(e->next); } else { *pE = e->next; e->next = new_table[table_index]; new_table[table_index] = e; } } } table->table_length = new_size; table->load_limit <<= 1; result = GAT_SUCCESS; } } return result; } /** GATTable_Internal_Add * Add any type to the hash table * Uses void* as the type and the type is defined * as a GATType * * @param table The hash table to enter the value into. * @param key the hash key to use for adding table value * @param value the value of the data to be added * @param type the type of data to be added * * @return GAT error code */ static GATResult GATTable_Internal_Add(GATTable table, const void *key, void *value, GATType type) { GATuint32 table_index = 0; Hash_Element e = NULL; /* element to add */ GATResult result = GAT_FAIL; /* check table fullness */ if ((++(table->element_count) > table->load_limit) && (GATTable_Internal_Expand(table) == GAT_MEMORYFAILURE)) { result = GAT_MEMORYFAILURE; } else if ((e = (Hash_Element) malloc(sizeof (struct Hash_Element_S))) == NULL) { result = GAT_MEMORYFAILURE; } else { /* copy data to element */ memset(e, 0, sizeof(struct Hash_Element_S)); e->type = type; e->hash = GATTable_Internal_Hash_sdbm(table, key); table_index = GATTable_Internal_Index(table->table_length, e->hash); table->isdirty = GATTrue; e->value = value; e->next = NULL; result = GATTable_Internal_CloneKey(table, key, (void **) &e->key); if (GAT_SUCCESS == result) { /* chain it as index is taken */ if (NULL != table->table[table_index]) { /* get to end of list */ Hash_Element hold = NULL; for (hold = table->table[table_index]; /**/; hold = hold->next) { if (GATTrue == GATTable_Internal_Equal_Keys(table, key, hold->key)) { /* table key already exists in the table */ result = GAT_KEY_ALREADY_EXISTS; break; } if (NULL == hold->next) { break; } } if (GAT_SUCCESS == result) { hold->next = e; } } else { /* a free index space */ table->table[table_index] = e; } } } if (GAT_SUCCESS != result) { /* error inserting an item */ --table->element_count; if (NULL != e) { GATTable_Internal_Destroy_Key(table, (void **) &e->key); } free(e); } return result; } /* Serialize the items stored in the given table */ static GATResult GATTable_SerialiseItems(GATTable_const table, GATXds xds, GATXdsScope flag, void **buffer, size_t *buffer_size, GATBool clear_dirty) { GATResult retval = GAT_SUCCESS; GATuint32 i = 0; GAT_UNUSED_PARAMETER(flag); GAT_UNUSED_PARAMETER(clear_dirty); if (table->equal_keys != GATTable_Internal_Equal_Keys_String || table->get_hash != GATTable_Default_Hash_sdbm || table->get_key_size != GATTable_Internal_Get_KeySize_String || table->clone_key != GATTable_Internal_CloneKey_String || table->destroy_key != GATTable_Default_Destroy_Key) { /* serialising of GATTableAnyKey objects isn't supported yet, sorry */ retval = GAT_NO_INTERFACE; } else { for(/**/; i < table->table_length; ++i) { Hash_Element element = table->table[i]; /* write the elements of table bucket */ for(/**/; NULL != element; element = element->next) { retval = GATXds_Encode(xds, (GATXdsScope)0, 0, 0, "uint32", (GATuint32)element->type); if (GAT_SUCCESS != retval) { break; } switch(element->type) { case GATType_GATint32: retval = GATXds_Encode(xds, (GATXdsScope)0, 0, 0, "string int32", element->key, ((Hash_int) element->value)->data); break; case GATType_GATint16: retval = GATXds_Encode(xds, (GATXdsScope)0, 0, 0, "string int32", element->key, ((Hash_short) element->value)->data); break; case GATType_GATdouble64: retval = GATXds_Encode(xds,(GATXdsScope) 0, 0, 0, "string double", element->key, ((Hash_double) element->value)->data); break; case GATType_GATfloat32: retval = GATXds_Encode(xds, (GATXdsScope)0, 0, 0, "string double", element->key, (double)((Hash_float) element->value)->data); break; case GATType_String: retval = GATXds_Encode(xds, (GATXdsScope)0, 0, 0, "string string", element->key, ((Hash_String) element->value)->data); break; default: if (GATType_GATObject & element->type) { retval = GATXds_Encode(xds, (GATXdsScope)0, 0, 0, "string object", element->key, ((Hash_GATObject) element->value)->data, clear_dirty); } else { retval = GAT_KEY_TYPE_ERROR; } break; } if(GAT_SUCCESS != retval) { break; } } if (GAT_SUCCESS != retval) { break; } } } if (GAT_SUCCESS == retval) { retval = GATXds_GetBuffer(xds, GATXdsScope_Gift, buffer, buffer_size); } return retval; } /** GATTable_DeSerialise_Create * * The function GATTable_DeSerialise_Create creates a new GATTable object and * fills it from the given stream. * * @param context The GAT context to be used for object construction. * @param xds The XDS engine to use for decoding. * @param table_length table is size of the internal table data structure. * @param element_count table is the expected table element count. * @param table The pointer to the variable, which should receive the * newly constructed GATTable object. * * @return An error code. */ static GATResult GATTable_DeSerialise_Create(GATXds xds, GATuint32 table_length, GATuint32 element_count, GATTable *table) { GATResult retval = GAT_MEMORYFAILURE; GATTable new_table = (GATTable) malloc(sizeof(struct GATTable_S)); if (NULL != new_table) { GATuint32 i = 0; memset(new_table, 0, sizeof(struct GATTable_S)); new_table->GATObject__vtable = &GATTable__vtable; new_table->GATSerialisable__vtable = &GATTable_ISerialisable__vtable; new_table->equal_keys = GATTable_Internal_Equal_Keys_String; new_table->get_hash = GATTable_Default_Hash_sdbm; new_table->get_key_size = GATTable_Internal_Get_KeySize_String; new_table->clone_key = GATTable_Internal_CloneKey_String; new_table->destroy_key = GATTable_Default_Destroy_Key; new_table->table = (Hash_Element *) malloc(sizeof(Hash_Element) * table_length); if (NULL == new_table) { free(new_table); new_table = NULL; retval = GAT_MEMORYFAILURE; } else { /* initiate the table pointers */ double const maxloadfactor = 0.75f; /* loading for table expand */ for (i = 0; i < table_length; i++) { new_table->table[i] = NULL; } new_table->table_length = table_length; new_table->element_count = 0; new_table->load_limit = (GATuint32) (table_length * maxloadfactor); } for(i = 0; i < element_count; ++i) { /* read the type of the next element */ GATuint32 type = GATType_NoType; char *key = NULL; retval = GATXds_Decode(xds, (GATXdsScope)0, 0, 0, "uint32", &type); if (GAT_SUCCESS != retval) { break; } switch(type) { case GATType_GATint32: { int data = 0; retval = GATXds_Decode(xds, (GATXdsScope)0, 0, 0, "string int32", &key, &data); if (GAT_SUCCESS == retval) { retval = GATTable_Add_int(new_table, key, data); } } break; case GATType_GATint16: { int data = 0; retval = GATXds_Decode(xds, (GATXdsScope)0, 0, 0, "string int32", &key, &data); if (GAT_SUCCESS == retval) { retval = GATTable_Add_short(new_table, key, data); } } break; case GATType_GATdouble64: { double data = 0; retval = GATXds_Decode(xds, (GATXdsScope)0, 0, 0, "string double", &key, &data); if (GAT_SUCCESS == retval) { retval = GATTable_Add_double(new_table, key, data); } } break; case GATType_GATfloat32: { double data = 0; retval = GATXds_Decode(xds, (GATXdsScope)0, 0, 0, "string double", &key, &data); if (GAT_SUCCESS == retval) { retval = GATTable_Add_float(new_table, key, (float) data); } } break; case GATType_String: { char *data = NULL; retval = GATXds_Decode(xds, (GATXdsScope)0, 0, 0, "string string", &key, &data); if (GAT_SUCCESS == retval) { retval = GATTable_Add_String(new_table, key, data); free(data); } } break; default: if (GATType_GATObject & type) { GATObject data = NULL; retval = GATXds_Decode(xds, (GATXdsScope)0, 0, 0, "string object", &key, &data); if (GAT_SUCCESS == retval) { retval = GATTable_Add_GATObject(new_table, key, data); GATObject_Destroy(&data); } } else { retval = GAT_KEY_TYPE_ERROR; } break; } free(key); if (GAT_SUCCESS != retval) { break; } } if (GAT_SUCCESS == retval) { if (NULL != table) { *table = new_table; } else { GATTable_Destroy(&new_table); retval = GAT_INVALID_PARAMETER; } } else { GATTable_Destroy(&new_table); } } return retval; }