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.h Go to the documentation of this file. /** @file GATList.h * Header file for the type specific GATList interface declaration. * * GATList is a set of functions for implementing double linked lists of * objects of arbitrary type. * * @date Fri Sep 26 2003 * * @version: $Header: /export/cvs-gridlab/wp-1/Codes/GATEngine/C-reference/src/GATList.h,v 1.25 2004/03/24 19:30:58 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) */ #if !defined(_GATLIST_H_) #define _GATLIST_H_ 1 #include <stdlib.h> #include "GATObject.h" #include "GATType.h" /** GATList_type GATList_type_Create() * @brief Create a new list of @c type's * * The function @c GATList_type_Create creates a new list @c GATList_type, * which holds objects of the given @c type. * * @return Returns a handle to the newly created list. If an error occures * 0 (zero) is returned. * * @remark The concrete function name to use is determined by the type to be * stored inside the list. For instance, a list containing @c int's * would be created with the function @c GATList_int_Create. */ #if defined(DOXYGEN) GATList_type GATList_type_Create(); #endif /** int GATList_type_Equals(GATList_type const lhs, GATList_type const rhs, GATBool *isequal) * @brief Compare two lists of @c type's * * The function @c GATList_type_Equals compares two lists @c GATList_type, * which holds objects of the given @c type. * * @param lhs The first list to compare * @param rhs The second list to compare * @param isequal The pointer, through which the result is to be returned * * @return An error code. * * @remark The concrete function name to use is determined by the type to be * stored inside the lists. For instance, a list containing @c int's * would be compared with the function @c GATList_int_Equals. */ #if defined(DOXYGEN) GATList_type GATList_type_Equals(GATList_type const lhs, GATList_type const rhs, GATBool *isequal); #endif /** GATType GATList_type_GetType(GATList_type const object) * @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. * * @remark The concrete function name to use is determined by the type to be * stored inside the lists. For instance, a list containing @c int's * would be return its type with @c GATList_int_GetType. */ #if defined(DOXYGEN) GATType GATList_type_GetType(GATList_type const lhs); #endif /** GATType GATList_type_Clone(GATList_type const list, GATList *new_list) * @brief Clone the given list * * The function @c GATList_type_Clone generates a (deep) copy of the given * list. * * @param list The object to clone * @param new_object The pointer, through which the result is to be returned. * * @return An error type. * * @remark The concrete function name to use is determined by the type to be * stored inside the lists. For instance, a list containing @c int's * would be return its type with @c GATList_int_GetType. */ #if defined(DOXYGEN) GATResult GATList_type_Clone(GATList_type const list, GATList *new_list); #endif /** int GATList_type_GetInterface(GATList_const file, 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. * * @remark The concrete function name to use is determined by the type to be * stored inside the lists. For instance, a list containing @c int's * would be return its type with @c GATList_int_GetType. */ #if defined(DOXYGEN) GATResult GATList_type_GetInterface(GATList_const file, GATInterface iftype, void const **ifp); #endif /** void GATList_type_Destroy(GATList_type list) * @brief Destroy the given list and all of its contents * * The function @c GATList_type_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 list The list to be destroyed * * @return Returns @c GAT_SUCCESS if the list was destroyed successfully. If * the given parameter was not a valid list, then @c GAT_INVALID_HANLDE * is returned. * * @remark The concrete function name to use is determined by the type to be * stored inside the list. For instance, a list containing @c int's * would be destroyed with the function @c GATList_int_Destroy. */ #if defined(DOXYGEN) void GATList_type_Destroy(GATList_type *list); #endif /** size_t GATList_type_Size(GATList_type list) * @brief Return the number of elements stored inside a list * * The function @c GATList_type_Size returns the number of elements, currently * stored inside the given list. * * @param list The list 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. * * @remark The concrete function name to use is determined by the type to be * stored inside the list. For instance, a list containing @c int's * would be queried for its number of stored elements with the function * @c GATList_int_Size. */ #if defined(DOXYGEN) size_t GATList_type_Size(GATList_type list); #endif /** GATList_type_Iterator GATList_type_Begin(GATList_type list) * @brief Return a pointer to the first element of the list * * The function @c GATList_type_Begin returns a @c GATList_type_Iterator * pointing to the first element of the inspected list. * * @param list 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. * * @remark The concrete function name to use is determined by the type to be * stored inside the list. For instance, a list containing @c int's * would be queried for its begin iterator with the function * @c GATList_int_Begin. */ #if defined(DOXYGEN) GATList_type_Iterator GATList_type_Begin(GATList_type list); #endif /** GATList_type_Iterator GATList_type_End(GATList_type listhandle) * @brief Return a pointer to the first element beyond the last element of the * list. * * The function @c GATList_type_End returns a @c GATList_type_Iterator * pointing to the first element beyond the last of element of the the * inspected list. Please note, that the returned @c GATList_type_Iterator 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. * * @remark The concrete function name to use is determined by the type to be * stored inside the list. For instance, a list containing @c int's * would be queried for its end iterator with the function * @c GATList_int_End. */ #if defined(DOXYGEN) GATList_type_Iterator GATList_type_End(GATList_type list); #endif /** GATList_type_Iterator GATList_type_Next(GATList_type_Iterator iter) * @brief Return a pointer to the next element beyond the given iterator. * * The function @c GATList_type_Next returns a @c GATList_type_Iterator * 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_type_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. * @remark The concrete function name to use is determined by the type to be * stored inside the list. For instance, a list containing @c int's * would be queried for its next iterator with the function * @c GATList_int_Next. */ #if defined(DOXYGEN) GATList_type_Iterator GATList_type_Next(GATList_type_Iterator iter); #endif /** GATList_type_Iterator GATList_type_Previous(GATList_type_Iterator iter) * @brief Return a pointer to the element preceeding the given iterator. * * The function @c GATList_type_Previous returns a @c GATList_type_Iterator * 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. * @remark The concrete function name to use is determined by the type to be * stored inside the list. For instance, a list containing @c int's * would be queried for its previous iterator with the function * @c GATList_int_Previous. */ #if defined(DOXYGEN) GATList_type_Iterator GATList_type_Previous(GATList_type_Iterator iter); #endif /** GATList_type_Iterator GATList_type_Insert(GATList_type list, GATList_type_Iterator where, type data) * @brief Insert a new element into a list. * * The function @c GATList_type_Insert inserts the new element @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 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. * * @remark If the given position @c where is the begin iterator of the list * the new element is inserted as the first element, if the position is * the end iterator of the list, the new element is inserted as the last * element. * @remark The concrete function name to use is determined by the type to be * stored inside the list. For instance, to insert a new element into a * list containing @c int's the function @c GATList_int_Insert would be * used. */ #if defined(DOXYGEN) GATList_type_Iterator GATList_type_Insert(GATList_type list, GATList_type_Iterator where, type data); #endif /** GATList_type_Iterator GATList_type_Erase(GATList_type list, GATList_type_Iterator where) * @brief Remove an existing element from a list. * * The function @c GATList_type_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. * * @remark Calling this function with an end iterator of a list will result in * undefined behaviour. * @remark The concrete function name to use is determined by the type to be * stored inside the list. For instance, to remove an existing element * from a list containing @c int's the function @c GATList_int_Erase * would be used. */ #if defined(DOXYGEN) GATList_type_Iterator GATList_type_Erase(GATList_type list, GATList_type_Iterator where); #endif /** type *GATList_type_Get(GATList_type_Iterator where) * @brief Access the data of a stored element of a list. * * The function @c GATList_type_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. * * @remark Calling this function with an end iterator of a list will result in * undefined behaviour. * @remark The concrete function name to use is determined by the type to be * stored inside the list. For instance, to access an element * inside a list containing @c int's the function @c GATList_int_Get * would be used. */ #if defined(DOXYGEN) type * GATList_type_Get(GATList_type_Iterator where); #endif /** GATList_type_Iterator GATList_type_Splice(GATList_type dest, GATList_type_Iterator where, GATList_type source, GATList_type_Iterator first, GATList_type_Iterator last, size_t count) * @brief Removes elements from the source list and inserts them into the * destination list. * * The function @c GATList_type_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. * * @remark Using lists of different element type for the source and * destination lists will result in undefined behaviour. * @remark The concrete function name to use is determined by the type to be * stored inside the list. For instance, to splice a sequence * from a list containing @c int's the function @c GATList_int_Splice * would be used. */ #if defined(DOXYGEN) GATList_type_Iterator GATList_type_Splice( GATList_type dest, GATList_type_Iterator here, GATList_type src, GATList_type_Iterator first, GATList_type_Iterator last, size_t count); #endif /** int GATList_type_Serialise(GATList 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. * * @remark The concrete function name to use is determined by the type to be * stored inside the list. For instance, to serialise * a list containing @c int's the function @c GATList_int_Serialise * would be used. */ #if defined(DOXYGEN) GATResult GATList_type_Serialise(GATList list, GATObject stream, GATBool clear_dirty); #endif /** GATList GATList_type_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. * * @remark The concrete function name to use is determined by the type to be * stored inside the list. For instance, to deserialise * a list containing @c int's the function @c GATList_int_DeSerialise * would be used. */ #if defined(DOXYGEN) GATList GATList_type_DeSerialise(GATContext context, GATObject stream, GATResult *result); #endif /** GATList_GetIsDirty * * The function GATList_type_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. * * @remark The concrete function name to use is determined by the type to be * stored inside the list. For instance, to get the dirty status from * a list containing @c int's the function @c GATList_int_GetIsDirty * would be used. */ #if defined(DOXYGEN) GATResult GATList_type_GetIsDirty(GATList_const list, GATBool *isdirty); #endif #if (__STDC_VERSION__ >= 199901) || defined(__cplusplus) /* use C99 or C++ */ #define GAT_INLINE_FUNC inline #else #define GAT_INLINE_FUNC static #endif /* (__STDC_VERSION__ >= 199901) || defined(__cplusplus) */ /** @def GATHANDLE_DECLARE(handletype) * @hideinitializer * * Helper macro used internally to define the handletype of type specific * lists and iterators for this lists. */ #define GATHANDLE_DECLARE(handletype) \ struct handletype ## _handle { int dummy; }; \ typedef struct handletype ## _handle *handletype; \ typedef struct handletype ## _handle const *handletype ## _const \ /**/ /* Helper macro to declare the type specific list function prototypes */ #define GATLIST_PROTOTYPES(qualifier, type, listtype) \ \ GATOBJECT_DECLARE_CONVERTERS_QUALIFIED(qualifier, listtype); \ \ qualifier listtype listtype ## _Create(void); \ qualifier GATResult listtype ## _Equals(listtype ## _const lhs, \ listtype ## _const rhs, GATBool *isequal); \ qualifier void listtype ## _Destroy(listtype *list); \ qualifier GATType listtype ## _GetType(listtype ## _const object); \ qualifier GATResult listtype ## _Clone(listtype ## _const object, \ listtype *new_obj); \ qualifier GATResult listtype ## _GetInterface(listtype ## _const file, \ GATInterface iftype, void const **ifp); \ \ qualifier size_t listtype ## _Size(listtype ## _const list); \ qualifier listtype ## _Iterator listtype ## _Begin(listtype ## _const list); \ qualifier listtype ## _Iterator listtype ## _End(listtype ## _const list); \ qualifier listtype ## _Iterator listtype ## _Next( \ listtype ## _Iterator_const iterator); \ qualifier listtype ## _Iterator listtype ## _Previous( \ listtype ## _Iterator_const iterator); \ qualifier listtype ## _Iterator listtype ## _Insert( \ listtype list, listtype ## _Iterator iterator, type const data); \ qualifier listtype ## _Iterator listtype ## _Erase( \ listtype list, listtype ## _Iterator iterator); \ qualifier type *listtype ## _Get( \ listtype ## _Iterator_const iterator); \ \ qualifier listtype ## _Iterator_const listtype ## _Splice( \ listtype dest, listtype ## _Iterator here, \ listtype src, listtype ## _Iterator first, \ listtype ## _Iterator last, size_t count); \ \ qualifier GATResult listtype ## _Serialise(listtype list, \ GATObject stream, GATBool clear_dirty); \ qualifier listtype listtype ## _DeSerialise(GATContext context, \ GATObject stream, GATResult *result); \ qualifier GATResult listtype ## _GetIsDirty(listtype ## _const list, \ GATBool *isdirty) \ /**/ /* Helper macro to define the type specific list function prototypes */ #define GATLIST_IMPLEMENT(qualifier, type, listtype, gattype) \ \ qualifier listtype listtype ## _Create(void) \ { \ return (listtype) GATList_i_Create(gattype, sizeof(type)); \ } \ \ qualifier GATResult listtype ## _Equals(listtype ## _const lhs, \ listtype ## _const rhs, GATBool *isequal) \ { \ return GATList_i_Equals((GATList_const) lhs, (GATList_const) rhs, \ isequal); \ } \ \ qualifier void listtype ## _Destroy(listtype *list) \ { \ GATList_i_Destroy((GATList *) list); \ } \ \ qualifier GATType listtype ## _GetType(listtype ## _const list) \ { \ return GATList_i_GetType((GATList_const) list); \ } \ \ qualifier GATResult listtype ## _Clone(listtype ## _const list, \ listtype *new_list) \ { \ return GATList_i_Clone((GATList_const) list, (GATList *)new_list); \ } \ \ qualifier GATResult listtype ## _GetInterface(listtype ## _const list, \ GATInterface iftype, void const **ifp) \ { \ return GATList_i_GetInterface((GATList_const) list, iftype, ifp); \ } \ \ qualifier size_t listtype ## _Size(listtype ## _const list) \ { \ return GATList_i_Size((GATList_const) list); \ } \ \ qualifier listtype ## _Iterator listtype ## _Begin(listtype ## _const list) \ { \ return (listtype ## _Iterator) GATList_i_Begin((GATList_const)list); \ } \ \ qualifier listtype ## _Iterator listtype ## _End(listtype ## _const list) \ { \ return (listtype ## _Iterator) GATList_i_End((GATList_const) list); \ } \ \ qualifier listtype ## _Iterator listtype ## _Next( \ listtype ## _Iterator_const iterator) \ { \ return (listtype ## _Iterator) GATList_i_Next( \ (GATListIterator_const) iterator); \ } \ \ qualifier listtype ## _Iterator listtype ## _Previous( \ listtype ## _Iterator_const iterator) \ { \ return (listtype ## _Iterator) GATList_i_Previous( \ (GATListIterator_const) iterator); \ } \ \ qualifier listtype ## _Iterator listtype ## _Insert( \ listtype list, listtype ## _Iterator iterator, type const data) \ { \ return (listtype ## _Iterator) GATList_i_Insert((GATList)list, \ (GATListIterator) iterator, &data); \ } \ \ qualifier listtype ## _Iterator listtype ## _Erase( \ listtype list, listtype ## _Iterator iterator) \ { \ return (listtype ## _Iterator) GATList_i_Erase((GATList)list, \ (GATListIterator) iterator); \ } \ \ qualifier type *listtype ## _Get( \ listtype ## _Iterator_const iterator) \ { \ return (type *) GATList_i_Get((GATListIterator_const) iterator); \ } \ \ qualifier listtype ## _Iterator_const listtype ## _Splice( \ listtype dest, listtype ## _Iterator here, \ listtype src, listtype ## _Iterator first, \ listtype ## _Iterator last, size_t count) \ { \ return (listtype ## _Iterator_const) GATList_i_Splice( \ (GATList) dest, (GATListIterator) here, \ (GATList) src, (GATListIterator) first, \ (GATListIterator) last, count); \ } \ \ qualifier GATResult listtype ## _Serialise(listtype list, \ GATObject stream, GATBool clear_dirty) \ { \ return GATList_i_Serialise((GATList) list, stream, clear_dirty); \ } \ \ qualifier listtype listtype ## _DeSerialise(GATContext context, \ GATObject stream, GATResult *result) \ { \ return (listtype) GATList_i_DeSerialise(context, stream, result); \ } \ \ qualifier GATResult listtype ## _GetIsDirty(listtype ## _const list, \ GATBool *isdirty) \ { \ return GATList_i_GetIsDirty((GATList_const) list, isdirty); \ } \ /**/ /** @def GATLIST_DECLARE(type) * Helper macros for declaring @a type specific lists on top of the * generic list implementation. * You must use this macro to declare a type specific list for a given * @a type in every translation unit, which uses this list of @a types. * This macro generates the access functions for the required list, which * follow some specific naming conventions. The list type itself is named * @c GATList_type and the access functions are named @c GATList_type_whatever. */ #define GATLIST_DECLARE_QUALIFIED(qualifier, type, name) \ GATHANDLE_DECLARE(name); \ GATHANDLE_DECLARE(name ## _Iterator); \ GATLIST_PROTOTYPES(qualifier, type, name) \ /**/ #define GATLIST_DECLARE(type) \ GATLIST_DECLARE_QUALIFIED(GAT_INLINE_FUNC, type, GATList_ ## type) \ /**/ #define GATLIST_DECLARE_LIST(type) \ GATLIST_DECLARE_QUALIFIED(GAT_INLINE_FUNC, type, GATList_ ## type) \ /**/ /** @def GATLIST_DECLARE(type) * Helper macros for defining @a type specific lists on top of the * generic list implementation. * You must use this macro to define a type specific list for a given * @a type in every translation unit, which uses this list of @a types. * This macro generates the access functions for the required list, which * follow some specific naming conventions. The list type itself is named * @c GATList_type and the access functions are named @c GATList_type_whatever. */ #define GATLIST_DEFINE_QUALIFIED(qualifier, type, name, gattype) \ GATLIST_DECLARE_QUALIFIED(qualifier, type, name); \ GATLIST_IMPLEMENT(qualifier, type, name, gattype) \ /**/ #define GATLIST_DEFINE(type) \ GATLIST_DEFINE_QUALIFIED(GAT_INLINE_FUNC, type, GATList_ ## type, \ GATType_ ## type) \ /**/ #define GATLIST_DEFINE_LIST(type) \ GATLIST_DEFINE_QUALIFIED(GAT_INLINE_FUNC, type, GATList_ ## type, \ GATType_GATList) \ /**/ /* Versioning for the GATAdvertisable API */ #define GATLIST_VERSION1 0x0100 #define GATLIST_LASTVERSION GATLIST_VERSION1 #define GATLIST_MINOR_MASK 0x00ff /* * Special list interface for the datatype 'const char *' */ GATHANDLE_DECLARE(GATList_String); GATHANDLE_DECLARE(GATList_String_Iterator); /* Versioning information for the Serializable interface */ #define GATLIST_VERSION1 0x0100 #define GATLIST_LASTVERSION GATLIST_VERSION1 #define GATLIST_MINOR_MASK 0x00ff /* Prototypes */ #if defined(__cplusplus) extern "C" { #endif /* defined(__cplusplus) */ /* Declare the converters to/from GATObject */ GATOBJECT_DECLARE_CONVERTERS(GATList); GATOBJECT_DECLARE_CONVERTERS(GATList_String); /* * Generic list interface - do not use directly! */ /* Create a new generic list */ GATList GATList_i_Create(GATType type, size_t size); /* compare two lists */ GATResult GATList_i_Equals(GATList_const lhs, GATList_const rhs, GATBool *isequal); /* get the type of a list */ GATType GATList_i_GetType(GATList_const list); /* make a copy of a list */ GATResult GATList_i_Clone(GATList_const list, GATList *new_list); /* get an interface of this list instance */ GATResult GATList_i_GetInterface(GATList_const file, GATInterface iftype, void const **ifp); /* destroy a generic list */ void GATList_i_Destroy(GATList *listhandle); /* return the current list size (element count) */ size_t GATList_i_Size(GATList_const listhandle); /* * Generic list iterator interface - do not use directly! */ /* * Return the Iterator to the first and last (one past the end) elements of * a list, further, return the next and previous elements of a given element */ GATListIterator GATList_i_Begin(GATList_const listhandle); GATListIterator GATList_i_End(GATList_const listhandle); GATListIterator GATList_i_Next(GATListIterator_const iterator); GATListIterator GATList_i_Previous(GATListIterator_const iterator); /* Add a new element to a generic list */ GATListIterator GATList_i_Insert(GATList listhandle, GATListIterator iterator, void const *data); /* Remove an element from a generic list */ GATListIterator GATList_i_Erase(GATList listhandle, GATListIterator iterator); /* Access the data of an element */ void * GATList_i_Get(GATListIterator_const iterator); /* * Generic list algorithms - do not call directly! */ /* * Splice a given sub-list into the target list right before the given * position */ GATListIterator_const GATList_i_Splice(GATList dest, GATListIterator here, GATList src, GATListIterator first, GATListIterator last, size_t count); /* GATAdvertiseable API */ /* Serialise a GATList object */ GATResult GATList_i_Serialise(GATList list, GATObject stream, GATBool clear_dirty); /* De-serialise a GATList object */ GATList GATList_i_DeSerialise(GATContext context, GATObject stream, GATResult *result); /* Retrieves the status of the dirty flag of a GATList object. */ GATResult GATList_i_GetIsDirty(GATList_const list, GATBool *isdirty); /* * Special list interface for the datatype 'const char *' */ /* Create a new list of strings */ GATList_String GATList_String_Create(void); /* return the type of a list of strings */ GATType GATList_String_GetType(GATList_String_const list); /* make a copy of a slist of strings */ GATResult GATList_String_Clone(GATList_String_const list, GATList_String *new_list); /* get an interface of this list instance */ GATResult GATList_String_GetInterface(GATList_String_const list, GATInterface iftype, void const **ifp); /* compare two lists of strings */ GATResult GATList_String_Equals(GATList_String_const lhs, GATList_String_const rhs, GATBool *isequal); /* destroy a list of strings */ void GATList_String_Destroy(GATList_String *list); /* return the current list size (element count) */ size_t GATList_String_Size(GATList_String_const list); /* * Return the Iterator to the first and last (one past the end) elements of * a list, further, return the next and previous elements of a given element */ GATList_String_Iterator GATList_String_Begin(GATList_String_const list); GATList_String_Iterator GATList_String_End(GATList_String_const list); GATList_String_Iterator GATList_String_Next( GATList_String_Iterator_const iter); GATList_String_Iterator GATList_String_Previous( GATList_String_Iterator_const iter); /* Add a new string to a list of strings */ GATList_String_Iterator GATList_String_Insert(GATList_String list, GATList_String_Iterator iterator, char const *data); /* Remove a string from a list of strings */ GATList_String_Iterator GATList_String_Erase(GATList_String list, GATList_String_Iterator iterator); /* Access the stored string (do not free!) */ char const * GATList_String_Get(GATList_String_Iterator_const iterator); /* * Splice a given sub-list into the target list right before the given * position */ 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); /* GATAdvertiseable API */ /* Serialise a GATList object */ GATResult GATList_String_Serialise(GATList_String list, GATObject stream, GATBool clear_dirty); /* De-serialise a GATList object */ GATList_String GATList_String_DeSerialise(GATContext context, GATObject stream, GATResult *result); /* Retrieves the status of the dirty flag of a GATList object.`*/ GATResult GATList_String_GetIsDirty(GATList_String_const list, GATBool *isdirty); #if defined(__cplusplus) } /* extern "C" */ #endif /* defined(__cplusplus) */ #endif /* !defined(_GATLIST_H_) */