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

GATList.c Go to the documentation of this file. /** @file GATList_i.c * Source file for the GATList implementation functions. * * GATList is a set of functions for implementing double linked lists of * objects of arbitrary type. * * @date Sat Sep 27 2003 * * @version $Header: /export/cvs-gridlab/wp-1/Codes/GATEngine/C-reference/src/GATList.c,v 1.30 2004/04/02 12:31:57 hartmutkaiser Exp $ * * Copyright (C) Hartmut Kaiser * This file is part of the GAT Engine. * Contributed by Hartmut Kaiser <hartmutkaiser [at] t-online [dot] de>. * * 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) */ static const char *rcsid = "$Header: /export/cvs-gridlab/wp-1/Codes/GATEngine/C-reference/src/GATList.c,v 1.30 2004/04/02 12:31:57 hartmutkaiser Exp $"; #include <stdlib.h> #include <assert.h> #include <string.h> #include "GATUtil.h" #include "GATInternal.h" #include "GATErrors.h" #include "GATType.h" #include "GATObject.h" #include "GATString.h" #include "GATList.h" #include "GATXdsWrapper.h" #include "GATMemoryStream.h" #define MAGIC_GATLIST 0x12345678UL #define MAGIC_GATLISTNODE 0x87654321UL /* define the vtable types */ GATOBJECT_DEFINE_VTABLE(GATList); GATSERIALISABLE_DEFINE_VTABLE(GATList); /* Declare the converters to/from GATObject */ GATOBJECT_DEFINE_CONVERTERS(GATList); GATOBJECT_DEFINE_CONVERTERS_QUALIFIED(extern, GATList_String, GATType_GATList); /* * This is the internal structure, which represents a GATListNode object. */ typedef struct GATListNode_S { unsigned long magic; /* magic number (set to MAGIC_GATLISTNODE) */ struct GATListNode_S *next; /* next node in the chain */ struct GATListNode_S *prev; /* previous node in the chain */ char *data; /* dynamically allocated data held by this */ } GATListNode_S; /* * This is the internal structure, which represents a GATList object. */ typedef struct GATList_S { /* the GATObject vtable for this object */ GATList_vtable *GATObject__vtable; /* the GATSerialisable vtable for this object */ GATList_ISerialisable_vtable *GATSerialisable__vtable; unsigned long magic; /* magic number (set to MAGIC_GATLIST) */ GATType element_type; /* the GATType of the list elements */ GATuint32 nodesize; /* size of data, held by this list */ GATListNode_S *begin; /* first node of the chain */ GATuint32 num_of_elements; /* number of elements in this list */ GATBool isdirty; /* dirty status (changed since last write) */ } GATList_S; /* static function declarations */ static GATResult GATList_i_Compare(GATType type, GATuint32 size, GATListIterator_const lhs_first, GATListIterator_const lhs_last, GATListIterator_const rhs_first, GATBool *isequal); static GATListNode_S * GATListNode_Create(size_t nodesize); static GATListNode_S * GATList_Splice(GATList_S *dest, GATListNode_S *iter, GATList_S *src, GATListNode_S *first, GATListNode_S *last, size_t count); static size_t GATList_Distance(GATListIterator_const first, GATListIterator_const last); static GATResult GATList_i_SerialiseItems(GATList_const list, GATXds xds, GATXdsScope flag, void **buffer, size_t *buffer_size, GATBool clear_dirty); static GATResult GATList_DeSerialise_Create(GATContext context, GATXds xds, GATType element_type, GATuint32 nodesize, GATuint32 num_of_elements, GATList *list); static GATResult GATList_DeSerialise_Items(GATContext context, GATList new_list, GATXds xds, GATObject stream, GATType element_type, GATuint32 num_of_elements); /* File scope variables */ static GATList_vtable GATList__vtable = { GATList_i_GetType, GATList_i_Destroy, GATList_i_Equals, GATList_i_Clone, GATList_i_GetInterface, NULL }; static GATList_ISerialisable_vtable GATList_ISerialisable__vtable = { GATList_i_Serialise, GATList_i_DeSerialise, GATList_i_GetIsDirty }; /* external functions */ /** GATList_Register_GATSerialisable * The GATList_Register_GATSerialisable function registers the serialization * vtable with the GAT engine to allow generic object creation. * This function is called by the GAT engine, there is no need to use it * directly. */ GATResult GATList_Register_GATSerialisable() { return GATObject_Register_GATSerialisable(GATType_GATList, &GATList_ISerialisable__vtable); } /** GATList GATList_i_Create(GATType type, size_t nodesize) * @internal This function belongs to the internal GATList API, do not use it * directly. * @brief Creates a new generic list * * The function @c GATList_i_Create creates a new generic list @c GATList, which * holds arbitrary objects of the given @c nodesize. * * @param type The type identifier of the data to be stored in this list. * @param nodesize Is the size of one data item to be held by this list. * * @return Returns a handle to the newly created list. If an error occures * 0 (zero) is returned. */ GATList GATList_i_Create(GATType type, size_t nodesize) { GATListNode_S *newnode = NULL; GATList_S *newlist = NULL; /* validate parameters */ assert(nodesize != 0); if (nodesize != 0) { /* allocate a new list head structure */ newlist = (struct GATList_S *)malloc(sizeof(GATList_S)); if (NULL != newlist) { /* initialize members */ memset(newlist, 0, sizeof(GATList_S)); newlist->GATObject__vtable = &GATList__vtable; newlist->GATSerialisable__vtable = &GATList_ISerialisable__vtable; newlist->magic = MAGIC_GATLIST; newlist->element_type = type; newlist->nodesize = nodesize; newlist->isdirty = GATFalse; /* allocate the end of list node */ newnode = GATListNode_Create(0); if (NULL == newnode) { free(newlist); newlist = NULL; } else { newnode->next = newnode->prev = newnode; newlist->begin = newnode; } } } return (GATList) newlist; } /** int GATList_i_Equals(GATList_const lhs, GATList_const rhs, GATBool *isequal) * @internal This function belongs to the internal GATList API, do not use it * directly. * @brief Compares two generic lists * * The function @c GATList_i_Equals compares two generic lists @c #GATList. * * @param lhs The first list to compare * @param rhs The second list to compare * @param isequal The pointer to the GATBool variable, which should receive * the result if the comparision * * @return An error code. */ GATResult GATList_i_Equals(GATList_const lhs, GATList_const rhs, GATBool *isequal) { GATList_S const *lhs_list = lhs; GATList_S const *rhs_list = rhs; GATResult result = GAT_INVALID_PARAMETER; if (NULL != lhs_list && NULL != rhs_list && NULL != isequal) { assert(MAGIC_GATLIST == lhs_list->magic && MAGIC_GATLIST == rhs_list->magic); if (lhs_list->magic != MAGIC_GATLIST || rhs_list->magic != MAGIC_GATLIST) { result = GAT_INVALID_HANDLE; } else { if (lhs_list->element_type == rhs_list->element_type && lhs_list->num_of_elements == rhs_list->num_of_elements) { /* types and sizes match, so make a deep compare */ result = GATList_i_Compare(lhs_list->element_type, lhs_list->nodesize, GATList_i_Begin(lhs_list), GATList_i_End(lhs_list), GATList_i_Begin(rhs_list), isequal); } else { *isequal = GATFalse; result = GAT_SUCCESS; } } } return result; } /** int GATList_i_GetType(GATList_const listhandle) * @internal This function belongs to the internal GATList API, do not use it * directly. * @brief Return the type of the GATList * * The function @c GATList_type_GetType always returns GATType_GATList. * * @param object The object to inspect * * @return returns always @c #GATType_GATList. */ GATType GATList_i_GetType(GATList_const list) { GAT_UNUSED_PARAMETER(list); return GATType_GATList; } /** int GATList_i_Clone(GATList_const list, GATList *new_list) * @internal This function belongs to the internal GATList API, do not use it * directly. * @brief Clone the given list * * The function @c GATList_type_Clone generates a (deep) copy of the given * list. * * @param listhandle The object to clone * @param new_listhandle The pointer, through which the result is to be * returned. * * @return An error type. */ GATResult GATList_i_Clone(GATList_const listhandle, GATList *new_listhandle) { GATResult result = GAT_INVALID_HANDLE; if (NULL != listhandle) { GATList_S const*list = listhandle; GATList new_list = GATList_i_Create(list->element_type, list->nodesize); if (NULL == new_list) { result = GAT_MEMORYFAILURE; } else { GATListIterator it = GATList_i_Begin(listhandle); GATListIterator end = GATList_i_End(listhandle); result = GAT_SUCCESS; /* empty lists should be copied correctly */ for (/**/; it != end; it = GATList_i_Next(it)) { switch(list->element_type) { case GATType_GATint32: case GATType_GATint16: case GATType_GATfloat32: case GATType_GATdouble64: case GATType_PlainOldData: result = (NULL != GATList_i_Insert(new_list, GATList_i_End(new_list), GATList_i_Get(it))) ? GAT_SUCCESS : GAT_MEMORYFAILURE; break; default: if (list->element_type & GATType_GATObject) { /* GATList_i_Insert clones GATObject's */ result = (NULL != GATList_i_Insert(new_list, GATList_i_End(new_list), GATList_i_Get(it))) ? GAT_SUCCESS : GAT_MEMORYFAILURE; } else { result = GAT_NOTIMPL; } } if (GAT_SUCCESS != result) { break; } } if (GAT_SUCCESS == result) { new_list->isdirty = GATFalse; *new_listhandle = new_list; } else { /* destroy, what's allocated so far */ GATList_i_Destroy(&new_list); } } } return result; } /** int GATList_GetInterface(GATList_const list, GATInterface iftype, void const **ifp) * @brief Get an interface supported by a GATList * * The function GATList_GetInterface allows to get a pointer to an * additional interface supported by this GATList. * * @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 GATList_i_GetInterface(GATList_const list, GATInterface iftype, void const **ifp) { GATResult retval = GAT_INVALID_PARAMETER; if (NULL != ifp && NULL != list) { *ifp = NULL; if (GATInterface_ISerialisable == iftype) { *ifp = (void const *) &list->GATSerialisable__vtable; retval = GAT_SUCCESS; } else { retval = GAT_NO_INTERFACE; } } return retval; } /** int GATList_i_Destroy(GATList *listhandle) * @internal This function belongs to the internal GATList API, do not use it * directly. * @brief Destroy the given list and all of its contents * * The function @c GATList_i_Destroy destroys the given list and all of its * elements. If during creation time of this list there was specified a * @c destroyfunc, this function will be called for every element to be * destroyed. * * @param listhandle The list to be destroyed. If this parameter is 0 (zero) * the function does nothing, but returns @c #GAT_SUCCESS. * * @return Returns @c #GAT_SUCCESS if the list was destroyed successfully or * if the listhandle parameter was 0 (zero). If the given parameter was * not a valid list (but not equal zero), then @c #GAT_INVALID_HANDLE * is returned. */ void GATList_i_Destroy(GATList *listhandle) { GATListNode_S *nextnode = NULL; GATListNode_S *current_node = NULL; /* if the given listhandle is 0 (zero), then do nothing */ if (NULL != listhandle && NULL != *listhandle) { GATList_S *list = *listhandle; /* validate parameters */ assert(list->magic == MAGIC_GATLIST); if (list->magic == MAGIC_GATLIST) { /* erase all remaining elements */ current_node = list->begin->next; list->begin->next = list->begin; list->begin->prev = list->begin; list->num_of_elements = 0; for (/**/; current_node != list->begin; current_node = nextnode) { /* delete one element */ nextnode = current_node->next; /* deallocate node */ switch(list->element_type) { case GATType_GATint16: case GATType_GATint32: case GATType_GATfloat32: case GATType_GATdouble64: case GATType_PlainOldData: /* nothing special to do here */ break; default: if (GATType_GATObject & list->element_type) { /* destroy this object */ GATObject_Destroy((GATObject *) current_node->data); } else { /* this should not happen */ assert(GATType_GATObject & list->element_type); } break; } free(current_node); } free(list->begin); /* free the head node */ free(list); /* free the list structure itself */ *listhandle = NULL; } } } /** size_t GATList_i_Size(GATList listhandle) * @internal This function belongs to the internal GATList API, do not use it * directly. * @brief Return the number of elements stored inside a list * * The function @c GATList_i_Size returns the number of elements, currently * stored inside the given list. * * @param listhandle The list to be queried for its number of elements * * @return If successful, the number of elements is returned. If an error * occures, (size_t)(-1) is returned. */ size_t GATList_i_Size(GATList_const listhandle) { GATList_S const *list = listhandle; size_t size = (size_t)(-1); /* validate parameters */ assert(list->magic == MAGIC_GATLIST); if (list->magic == MAGIC_GATLIST) { /* just return the number of elements */ size = list->num_of_elements; } return size; } /** GATListIterator GATList_i_Begin(GATList listhandle) * @internal This function belongs to the internal GATList API, do not use it * directly. * @brief Return a pointer to the first element of the list * * The function @c GATList_i_Begin returns a @c GATListIterator * pointing to the first element of the inspected list. * * @param listhandle The list to be queried for its begin iterator * * @return If successful, the function returns the begin iterator of the list. * If an error occures, 0 (zero) is returned. */ GATListIterator GATList_i_Begin(GATList_const listhandle) { GATList_S const *list = listhandle; GATListIterator begin = NULL; /* validate parameters */ assert(list->magic == MAGIC_GATLIST); if (list->magic == MAGIC_GATLIST) { begin = list->begin->next; } return begin; } /** GATListIterator GATList_i_End(GATList listhandle) * @internal This function belongs to the internal GATList API, do not use it * directly. * @brief Return a pointer to the first element beyond the last element of the * list. * * The function @c GATList_i_End returns a @c GATListIterator * pointing to the first element beyond the last of element of the the * inspected list. Please note, that the returned @c GATListIterator may * @b not be used for accessing a valid element of the list, it may be used * for testing against the end of list condition only. * * @param listhandle The list to be queried for its begin iterator * * @return If successful, the function returns the end iterator of the list. * If an error occures, 0 (zero) is returned. */ GATListIterator GATList_i_End(GATList_const listhandle) { GATList_S const *list = listhandle; GATListIterator end = NULL; /* validate parameters */ assert(list->magic == MAGIC_GATLIST); if (list->magic == MAGIC_GATLIST) { end = list->begin; } return end; } /** GATListIterator GATList_i_Next(GATListIterator iter) * @internal This function belongs to the internal GATList API, do not use it * directly. * @brief Return a pointer to the next element beyond the given iterator. * * The function @c GATList_i_Next returns a @c GATListIterator * pointing to the list element following the element, to which points the * given iterator. * * @param iter The iterator, which is to be incremented * * @return If successful, the function returns the next iterator of the given * one. If the end of the list is reached, the function returns an * iterator, which has the same value as the iterator returned by the * function @c #GATList_i_End. * If an error occures, 0 (zero) is returned. * * @remark Calling this function with an end iterator of a list will result in * undefined behaviour. */ GATListIterator GATList_i_Next(GATListIterator_const iterator) { GATListNode_S const *current_node = iterator; GATListIterator next = NULL; /* validate parameters */ assert(current_node->magic == MAGIC_GATLISTNODE); if (current_node->magic == MAGIC_GATLISTNODE) { next = current_node->next; } return next; } /** GATListIterator GATList_i_Previous(GATListIterator iter) * @internal This function belongs to the internal GATList API, do not use it * directly. * @brief Return a pointer to the element preceeding the given iterator. * * The function @c GATList_i_Previous returns a @c GATListIterator * pointing to the list element preceeding the element, to which points the * given iterator. * * @param iter The iterator, which is to be decremented * * @return If successful, the function returns the previous iterator of the * given one. * If an error occures, 0 (zero) is returned. * * @remark Calling this function with an begin iterator of a list will result * in undefined behaviour. */ GATListIterator GATList_i_Previous(GATListIterator_const iterator) { GATListNode_S const *current_node = iterator; GATListIterator prev = NULL; /* validate parameters */ assert(current_node->magic == MAGIC_GATLISTNODE); if (current_node->magic == MAGIC_GATLISTNODE) { prev = current_node->prev; } return prev; } /** GATListIterator GATList_i_Insert(GATList list, GATListIterator where, void *data) * @internal This function belongs to the internal GATList API, do not use it * directly. * @brief Insert a new element into a list. * * The function @c GATList_i_Insert inserts the new element pointed to by * @c data into the given list. The new element is inerted just before the * element pointed to by the iterator @c where. * * @param list The list, into which the new element is to be inserted. * @param where The position inside the list, where the new element is to be * inserted. * @param data The pointer to the new element, a copy of which is to be * inserted into the list. * * @return If successful, the function returns an iterator pointing to the * newly inserted element * If an error occures, 0 (zero) is returned. */ GATListIterator GATList_i_Insert(GATList listhandle, GATListIterator iterator, void const *data) { GATListNode_S *newnode = NULL; GATList_S *list = listhandle; GATListNode_S *current_node = iterator; /* validate parameters */ assert(list->magic == MAGIC_GATLIST); assert(current_node->magic == MAGIC_GATLISTNODE); if ((list->magic == MAGIC_GATLIST) && (current_node->magic == MAGIC_GATLISTNODE)) { /* allocate the end of list node */ newnode = GATListNode_Create(list->nodesize); if (NULL != newnode) { if (list->element_type & GATType_GATObject) { /* GATObject's have to be cloned before inserting into the list */ GATObject new_object = NULL; GATObject_Clone(*(GATObject const *) data, &new_object); if (NULL != new_object) { memcpy(newnode->data, &new_object, list->nodesize); } else { /* something went wrong :-( */ free(newnode); newnode = NULL; } } else { /* copy the data into the node */ memcpy(newnode->data, data, list->nodesize); } if (NULL != newnode) { /* link the new node into the chain */ newnode->next = current_node; newnode->prev = current_node->prev; current_node->prev = newnode; newnode->prev->next = newnode; /* adjust list size */ ++list->num_of_elements; list->isdirty = GATTrue; } } } return (GATListIterator) newnode; } /** GATListIterator GATList_i_Erase(GATList list, GATListIterator where) * @internal This function belongs to the internal GATList API, do not use it * directly. * @brief Remove an existing element from a list. * * The function @c GATList_i_Erase removes the existing element pointed to * by the iterator @c where from the given list. If during creation time of * the list there was specified a @c destroyfunc, this function will be called * for the element to be destroyed. * * @param list The list, from which the existing element is to be removed. * @param where The position inside the list, where the new element is to be * inserted. * * @return If successful, the function returns an iterator pointing to the * next element adjacent to the removed element. * If an error occures, 0 (zero) is returned. */ GATListIterator GATList_i_Erase(GATList listhandle, GATListIterator iterator) { GATList_S *list = listhandle; GATListNode_S *current_node = iterator; GATListNode_S *next_node = NULL; /* validate parameters */ assert(list->magic == MAGIC_GATLIST); assert(current_node->magic == MAGIC_GATLISTNODE); if ((list->magic == MAGIC_GATLIST) && (current_node->magic == MAGIC_GATLISTNODE)) { next_node = current_node->next; if (current_node != list->begin) { /* not the list head, so it's safe to erase it */ current_node->prev->next = current_node->next; current_node->next->prev = current_node->prev; /* adjust list size */ --list->num_of_elements; list->isdirty = GATTrue; /* deallocate node */ switch(list->element_type) { case GATType_GATint16: case GATType_GATint32: case GATType_GATfloat32: case GATType_GATdouble64: case GATType_PlainOldData: /* nothing special to do here */ break; default: if (GATType_GATObject & list->element_type) { /* destroy this object */ GATObject_Destroy((GATObject *) current_node->data); } else { /* this should not happen */ assert(GATType_GATObject & list->element_type); } break; } free(current_node); } } return next_node; } /** void *GATList_i_Get(GATList_type_Iterator where) * @internal This function belongs to the internal GATList API, do not use it * directly. * @brief Access the data of a stored element of a list. * * The function @c GATList_i_Get allows to access the data stored inside an * element of a list. It returns a pointer to the contained data. * * @param where The position inside the list, from which the stored data is to * be returned. * * @return If successful, the function returns a pointer to the data stored * inside the referenced list element. * If an error occures, 0 (zero) is returned. */ void * GATList_i_Get(GATListIterator_const iterator) { GATListNode_S const *current_node = iterator; void *data = NULL; /* validate parameters */ assert(current_node->magic == MAGIC_GATLISTNODE); if (current_node->magic == MAGIC_GATLISTNODE) { data = current_node->data; } return data; } /** GATListIterator GATList_i_Splice(GATList dest, GATListIterator where, GATList source, GATListIterator first, GATListIterator last, size_t count) * @internal This function belongs to the internal GATList API, do not use it * directly. * @brief Removes elements from the source list and inserts them into the * destination list. * * The function @c GATList_i_Splice allows to remove a sequence of elements * from an source list and inserts this sequence into a destination list. The * source and the destination list may refer to be the same list. * * @param dest The destination list, where the sequence is to be inserted. * @param where The position inside the destination list, where the sequence * is to be inserted. * @param source The source list, from where the sequence is to be taken. * @param first The starting position inside the source list of the sequence * to transfer. * @param last The end position inside the source list of the sequence to * transfer. This parameter may be 0 (zero), in which case the end of * the source list is assumed. * @param count The number of elements in the sequence to transfer. This * parameter is an optimization aid and may be set to 0 (zero), in which * case the number of elements to transfer is determined. * * @return If successful, the function returns an iterator pointing to the * first element beyond the newliy inserted sequence. * If an error occures, 0 (zero) is returned. */ GATListIterator_const GATList_i_Splice( GATList desthandle, GATListIterator herehandle, GATList srchandle, GATListIterator firsthandle, GATListIterator lasthandle, size_t count) { GATList_S *dest = desthandle; GATList_S *src = srchandle; GATListNode_S *here = herehandle; GATListNode_S *first = firsthandle; GATListNode_S *last = lasthandle; /* validate parameters */ assert(dest->magic == MAGIC_GATLIST); assert(src->magic == MAGIC_GATLIST); assert(here->magic == MAGIC_GATLISTNODE); assert(first->magic == MAGIC_GATLISTNODE); assert((NULL == last) || (last->magic == MAGIC_GATLISTNODE)); if ((src->magic == MAGIC_GATLIST) && (dest->magic == MAGIC_GATLIST) && (here->magic == MAGIC_GATLISTNODE) && (first->magic == MAGIC_GATLISTNODE) && ((NULL == last) || (last->magic == MAGIC_GATLISTNODE))) { /* fill in default parameter last, if appropriate */ if (NULL == last) { last = src->begin; } /* test, whether it's worth doing something */ if (first != last && ((dest != src) || (here != last))) { /* fill in default parameter count, if appropriate */ if (0 == count) { if (dest == src) { /* rearrange the list */ } else if (first == src->begin->next && last == src->begin) { /* splice in the whole list */ count = src->num_of_elements; } else { /* splice in partial list */ count = GATList_Distance(first, last); } } GATList_Splice(dest, here, src, first, last, count); dest->isdirty = GATTrue; src->isdirty = GATTrue; } } else { here = NULL; } return here; } /* GATAdvertiseable API */ /** int GATList_Serialise(GATList_const list, GATObject stream, GATBool clear_dirty) * @brief Serialise a GATList object * * The function GATList_Serialise serialises the given GATList object into the * given stream. * * @param file The GATList 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 this object is to be reset (no used here) * * @return An error code. */ GATResult GATList_i_Serialise(GATList list, GATObject stream, GATBool clear_dirty) { int retval = GAT_INVALID_HANDLE; if (NULL != list) { 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 uint32", GATLIST_VERSION1, list->element_type, list->nodesize, list->num_of_elements)) && GAT_SUCCESS == (retval = GATList_i_SerialiseItems(list, 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 GATList instance data */ assert(NULL != xds_buffer); retval = GATStreamable_Write(stream, xds_buffer, xds_buffer_size, 0); } if (GAT_SUCCESS == retval) { /* write the GATList item data */ retval = GATStreamable_Write(stream, xds_item_buffer, xds_item_buffer_size, 0); if (GAT_SUCCESS == retval && clear_dirty) { list->isdirty = GATFalse; /* clear the dirty flag of this list */ } } } free(xds_size_buffer); } free(xds_item_buffer); free(xds_buffer); GATXds_Destroy(&xds); } return retval; } /** GATList GATList_DeSerialise(GATContext context, GATObject stream, GATBool clear_dirty) * @brief De-serialise a GATList object * * The function GATList_DeSerialise de-serialises a streamed GATList 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 GATList object. */ GATList GATList_i_DeSerialise(GATContext context, GATObject stream, GATResult *result) { GATList list = NULL; char buffer[64]; /* seems to be sufficient for a GATuint32 value */ GATuint32 xds_read_bytes = 0; GATResult retval = GATStreamable_Read(stream, buffer, sizeof(buffer), &xds_read_bytes); if (GAT_SUCCESS == retval) { GATXds xds = NULL; if (GAT_SUCCESS == (retval = GATXds_Init(&xds, GATXdsType_Decode))) { GATuint32 xds_buffer_size = 0; /* read the expected size of the stream for this 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 & ~GATSTRING_MINOR_MASK) > GATSTRING_LASTVERSION) { retval = GAT_UNKNOWN_FORMAT; } else { /* read the data */ GATType element_type = GATType_NoType; GATuint32 num_of_elements = 0; GATuint32 nodesize = 0; retval = GATXds_Decode(xds, (GATXdsScope)0, 0, 0, "uint32 uint32 uint32", &element_type, &nodesize, &num_of_elements); if (GAT_SUCCESS == retval) { /* construct the new object */ retval = GATList_DeSerialise_Create(context, xds, element_type, nodesize, num_of_elements, &list); } } } } } } GATXds_Destroy(&xds); /* FIXME: GATStatus(retval); */ } if (NULL != result) { *result = retval; } return list; } /** GATList_GetIsDirty * * The function GATList_GetIsDirty retrieves the status of the dirty flag of * this GATList object. * * @param file The GATList object to inspect for its dirty status. * @param isdirty The pointer to a variable, which receives the dirty status. * * @return An error code. */ GATResult GATList_i_GetIsDirty(GATList_const list, GATBool *isdirty) { GATResult retval = GAT_INVALID_HANDLE; if (NULL != list) { if (NULL != isdirty) { *isdirty = list->isdirty; retval = GAT_SUCCESS; } else { retval = GAT_INVALID_PARAMETER; } } return retval; } /* * Special list interface for the datatype 'const char *' */ GATList_String GATList_String_Create(void) { return (GATList_String) GATList_i_Create(GATType_GATString, sizeof(GATString)); } GATResult GATList_String_Equals(GATList_String_const lhs, GATList_String_const rhs, GATBool *isequal) { return GATList_i_Equals((GATList_const) lhs, (GATList_const) rhs, isequal); } GATType GATList_String_GetType(GATList_String_const list) { return GATList_i_GetType((GATList_const) list); } GATResult GATList_String_Clone(GATList_String_const list, GATList_String *new_list) { return GATList_i_Clone((GATList_const) list, (GATList *)new_list); } GATResult GATList_String_GetInterface(GATList_String_const list, GATInterface iftype, void const **ifp) { return GATList_i_GetInterface((GATList_const) list, iftype, ifp); } void GATList_String_Destroy(GATList_String *list) { GATList_i_Destroy((GATList *) list); } size_t GATList_String_Size(GATList_String_const list) { return GATList_i_Size((GATList_const) list); } GATList_String_Iterator GATList_String_Begin(GATList_String_const list) { return (GATList_String_Iterator) GATList_i_Begin((GATList_const)list); } GATList_String_Iterator GATList_String_End(GATList_String_const list) { return (GATList_String_Iterator) GATList_i_End((GATList_const) list); } GATList_String_Iterator GATList_String_Next( GATList_String_Iterator_const iterator) { return (GATList_String_Iterator) GATList_i_Next( (GATListIterator_const) iterator); } GATList_String_Iterator GATList_String_Previous( GATList_String_Iterator_const iterator) { return (GATList_String_Iterator) GATList_i_Previous( (GATListIterator_const) iterator); } GATList_String_Iterator GATList_String_Insert( GATList_String list, GATList_String_Iterator iterator, char const *data) { GATListIterator result = NULL; GATString item = GATString_Create(data, strlen(data)+1, "ASCII"); if (NULL != item) { result = GATList_i_Insert((GATList)list, (GATListIterator) iterator, (void const *) &item); GATString_Destroy(&item); /* was cloned inside */ } return (GATList_String_Iterator) result; } GATList_String_Iterator GATList_String_Erase( GATList_String list, GATList_String_Iterator iterator) { return (GATList_String_Iterator) GATList_i_Erase((GATList)list, (GATListIterator) iterator); } char const * GATList_String_Get(GATList_String_Iterator_const iterator) { GATString_const *string = (GATString_const *)GATList_i_Get( (GATListIterator_const) iterator); return (NULL != string) ? GATString_GetBuffer(*string) : 0; } GATList_String_Iterator_const GATList_String_Splice( GATList_String dest, GATList_String_Iterator here, GATList_String src, GATList_String_Iterator first, GATList_String_Iterator last, size_t count) { return (GATList_String_Iterator_const) GATList_i_Splice( (GATList) dest, (GATListIterator) here, (GATList) src, (GATListIterator) first, (GATListIterator) last, count); } /* GATAdvertiseable API */ /* Serialise a GATList object */ GATResult GATList_String_Serialise(GATList_String list, GATObject stream, GATBool clear_dirty) { return GATList_i_Serialise((GATList) list, stream, clear_dirty); } /* De-serialise a GATList object */ GATList_String GATList_String_DeSerialise(GATContext context, GATObject stream, GATResult *result) { return (GATList_String) GATList_i_DeSerialise(context, stream, result); } /* Retrieves the status of the dirty flag of a GATList object.`*/ GATResult GATList_String_GetIsDirty(GATList_String_const list, GATBool *isdirty) { return GATList_i_GetIsDirty((GATList_const) list, isdirty); } /* static functions */ /* * Create a new listnode */ static GATListNode_S * GATListNode_Create(size_t nodesize) { GATListNode_S *newnode = (GATListNode_S *)malloc(sizeof(GATListNode_S) + nodesize); if (NULL != newnode) { /* initialize members */ memset(newnode, 0, sizeof(GATListNode_S)); newnode->magic = MAGIC_GATLISTNODE; newnode->data = (char *)(newnode+1); } return newnode; } /* * Helper function, which splices a given sub-list before the given iterator */ static GATListNode_S * GATList_Splice(GATList_S *dest, GATListNode_S *iter, GATList_S *src, GATListNode_S *first, GATListNode_S *last, size_t count) { GATListNode_S *node = NULL; if (dest != src) { /* not the same list, adjust element counts */ dest->num_of_elements += count; src->num_of_elements -= count; } first->prev->next = last; last->prev->next = iter; iter->prev->next = first; node = iter->prev; iter->prev = last->prev; last->prev = first->prev; first->prev = node; return iter; } /* * Helper function, which calculates the distance between two given Iterators */ static size_t GATList_Distance(GATListIterator_const first, GATListIterator_const last) { size_t count = 0; while(first != last) { first = first->next; ++count; } return count; } /* * Helper function to compare the actual list elements */ static GATResult GATList_i_Compare(GATType type, GATuint32 size, GATListIterator_const lhs_first, GATListIterator_const lhs_last, GATListIterator_const rhs_first, GATBool *isequal) { GATResult result = GAT_SUCCESS; int break_while = 0; assert(NULL != isequal); while (lhs_first != lhs_last && !break_while) { void *lhs_data = GATList_i_Get(lhs_first); void *rhs_data = GATList_i_Get(rhs_first); if (NULL != lhs_data && NULL != rhs_data) { switch(type) { case GATType_GATint16: *isequal = (*(GATint16 *)lhs_data == *(GATint16 *)rhs_data) ? GATTrue : GATFalse; break; case GATType_GATint32: *isequal = (*(GATint32 *)lhs_data == *(GATint32 *)rhs_data) ? GATTrue : GATFalse; break; case GATType_GATfloat32: *isequal = (*(float *)lhs_data == *(float *)rhs_data) ? GATTrue : GATFalse; break; case GATType_GATdouble64: *isequal = (*(double *)lhs_data == *(double *)rhs_data) ? GATTrue : GATFalse; break; default: if (GATType_GATObject & type) { /* we have to compare two GATObject's */ result = GATObject_Equals(*(GATObject *) lhs_data, *(GATObject *) rhs_data, isequal); if (GAT_SUCCESS != result) { break_while = 1; } } else if (GATType_PlainOldData == type) { result = (0 == memcmp(lhs_data, rhs_data, size)) ? GATTrue : GATFalse; } else { result = GAT_FAIL; break_while = 1; } break; } } else { /* * This should not happen, because memory allocation errors should have * been detected earlier. */ assert(NULL != lhs_data && NULL != rhs_data); result = GAT_FAIL; } if (GATTrue != *isequal) { result = GAT_SUCCESS; break; /* break on the first different element or on error */ } /* advance to next list elements */ lhs_first = GATList_i_Next(lhs_first); rhs_first = GATList_i_Next(rhs_first); } return result; } /* Serialize the items stored in the given list */ static GATResult GATList_i_SerialiseItems(GATList_const list, GATXds xds, GATXdsScope flag, void **buffer, size_t *buffer_size, GATBool clear_dirty) { GATResult retval = GAT_SUCCESS; GATListIterator it = GATList_i_Begin(list); GATListIterator end = GATList_i_End(list); GATMemoryStream memory_stream = NULL; GATObject memory_stream_obj = NULL; if (GATType_GATObject & list->element_type) { memory_stream = GATMemoryStream_Create(0, 0, GATFalse); if (NULL == memory_stream) { retval = GAT_MEMORYFAILURE; } else { memory_stream_obj = GATMemoryStream_ToGATObject(memory_stream); } } if (GAT_SUCCESS == retval) { for (/**/; it != end; it = GATList_i_Next(it)) { if (NULL == GATList_i_Get(it)) { retval = GAT_FAIL; /* completely unexpected */ break; } switch(list->element_type) { case GATType_GATint32: retval = GATXds_Encode(xds, (GATXdsScope)0, 0, 0, "int32", *(GATint32 *)GATList_i_Get(it)); break; case GATType_GATint16: retval = GATXds_Encode(xds, (GATXdsScope)0, 0, 0, "int32", (GATint32)*(GATint16 *)GATList_i_Get(it)); break; case GATType_GATfloat32: retval = GATXds_Encode(xds, (GATXdsScope)0, 0, 0, "double", *(float *)GATList_i_Get(it)); break; case GATType_GATdouble64: retval = GATXds_Encode(xds, (GATXdsScope)0, 0, 0, "double", *(double *)GATList_i_Get(it)); break; default: if (list->element_type & GATType_GATObject) { retval = GATSerialisable_Serialise(*(GATObject *)GATList_i_Get(it), memory_stream_obj, clear_dirty); } else { retval = GAT_NOTIMPL; } } if (GAT_SUCCESS != retval) { break; } } if (GATType_GATObject & list->element_type) { if (GAT_SUCCESS == retval) { *buffer = GATMemoryStream_GetBuffer(memory_stream, (GATuint32 *) buffer_size, GATTrue); retval = (NULL != *buffer) ? GAT_SUCCESS : GAT_MEMORYFAILURE; } GATMemoryStream_Destroy(&memory_stream); } else if (GAT_SUCCESS == retval) { retval = GATXds_GetBuffer(xds, flag, buffer, buffer_size); } } return retval; } /** GATList_DeSerialise_Create * * The function GATList_DeSerialise_Create creates a new GATList 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 element_type This is the type of the items contained in the new * list. * @param nodesize This is the size of one item as it is stored in the list. * @param num_of_elements The number of elements to read from the stream. * @param new_object The pointer to the variable, which should receive the * newly constructed GATList object. * * @return An error code. */ static GATResult GATList_DeSerialise_Create(GATContext context, GATXds xds, GATType element_type, GATuint32 nodesize, GATuint32 num_of_elements, GATList *new_object) { GATResult retval = GAT_MEMORYFAILURE; GATList new_list = (GATList) malloc(sizeof(struct GATList_S)); if(NULL != new_list) { GATListNode_S *newnode = NULL; GATMemoryStream memory_stream = NULL; GATObject memory_stream_obj = NULL; /* initialise the main list members */ memset(new_list, 0, sizeof(struct GATList_S)); new_list->magic = MAGIC_GATLIST; new_list->GATObject__vtable = &GATList__vtable; new_list->GATSerialisable__vtable = &GATList_ISerialisable__vtable; new_list->element_type = element_type; new_list->nodesize = nodesize; /* if we have to read GATObject's, then initialise a memory stream */ if (GATType_GATObject & element_type) { void *buffer = NULL; size_t used_buffer = 0; size_t buffer_size = GATXds_GetBufferCapacity(xds); retval = GATXds_GetBuffer(xds, GATXdsScope_Gift, &buffer, &used_buffer); if (GAT_SUCCESS == retval) { memory_stream = GATMemoryStream_Create(buffer, buffer_size, GATTrue); if (NULL == memory_stream) { retval = GAT_MEMORYFAILURE; } else { memory_stream_obj = GATMemoryStream_ToGATObject(memory_stream); retval = GAT_SUCCESS; } } if (GAT_SUCCESS == retval) { /* reposition the memory stream to start with the actual object data */ retval = GATMemoryStream_Seek(memory_stream, GATOrigin_Set, used_buffer, 0); } } else { retval = GAT_SUCCESS; } if (GAT_SUCCESS == retval) { /* allocate the end of list node */ newnode = GATListNode_Create(0); if (NULL == newnode) { retval = GAT_MEMORYFAILURE; } else { /* link in the end of list node */ newnode->next = newnode->prev = newnode; new_list->begin = newnode; /* de-serialise all the items in this list */ retval = GATList_DeSerialise_Items(context, new_list, xds, memory_stream_obj, element_type, num_of_elements); } if (GATType_GATObject & element_type) { GATMemoryStream_Destroy(&memory_stream); } } } if (GAT_SUCCESS == retval) { if (NULL != new_object) { *new_object = new_list; } else { GATList_i_Destroy(&new_list); retval = GAT_INVALID_PARAMETER; } } else { GATList_i_Destroy(&new_list); } return retval; } static GATResult GATList_DeSerialise_Items(GATContext context, GATList new_list, GATXds xds, GATObject stream, GATType element_type, GATuint32 num_of_elements) { GATuint32 i = 0; GATResult retval = GAT_SUCCESS; /* zero elements is ok */ for (/**/; i < num_of_elements; ++i) { switch(element_type) { case GATType_GATint32: { GATint32 data = 0; retval = GATXds_Decode(xds, (GATXdsScope)0, 0, 0, "int32", &data); if (GAT_SUCCESS == retval) { retval = (NULL != GATList_i_Insert(new_list, GATList_i_End(new_list), &data)) ? GAT_SUCCESS : GAT_MEMORYFAILURE; } } break; case GATType_GATint16: { GATint32 data = 0; retval = GATXds_Decode(xds, (GATXdsScope)0, 0, 0, "int32", &data); if (GAT_SUCCESS == retval) { GATint16 real_data = (GATint16) data; retval = (NULL != GATList_i_Insert(new_list, GATList_i_End(new_list), &real_data)) ? GAT_SUCCESS : GAT_MEMORYFAILURE; } } break; case GATType_GATfloat32: { double data = 0; retval = GATXds_Decode(xds, (GATXdsScope)0, 0, 0, "double", &data); if (GAT_SUCCESS == retval) { float real_data = (float) data; retval = (NULL != GATList_i_Insert(new_list, GATList_i_End(new_list), &real_data)) ? GAT_SUCCESS : GAT_MEMORYFAILURE; } } break; case GATType_GATdouble64: { double data = 0; retval = GATXds_Decode(xds, (GATXdsScope)0, 0, 0, "double", &data); if (GAT_SUCCESS == retval) { retval = (NULL != GATList_i_Insert(new_list, GATList_i_End(new_list), &data)) ? GAT_SUCCESS : GAT_MEMORYFAILURE; } } break; default: if (element_type & GATType_GATObject) { GATObject obj = GATSerialisable_DeSerialise(context, stream, &retval); if (NULL != obj) { retval = (NULL != GATList_i_Insert(new_list, GATList_i_End(new_list), &obj)) ? GAT_SUCCESS : GAT_MEMORYFAILURE; GATObject_Destroy(&obj); } } else { retval = GAT_NOTIMPL; } } if (GAT_SUCCESS != retval) { break; } } return retval; }