listdoc.h

Go to the documentation of this file.

/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_INHERITDATA_LIST1_H
#define GWEN_INHERITDATA_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_INHERITDATA_LIST_ELEMENT {
    uint32_t id;
    GWEN_INHERITDATA *nextObject;
  } GWEN_INHERITDATA_LIST__ELEMENT;

  typedef struct GWEN_INHERITDATA_LIST GWEN_INHERITDATA_LIST;

  typedef int GWENHYWFAR_CB (*GWEN_INHERITDATA_LIST_SORT_FN)(const GWEN_INHERITDATA *a, const GWEN_INHERITDATA *b, int ascending);


  struct GWEN_INHERITDATA_LIST {
    GWEN_INHERITDATA *first;
    uint32_t count;
    uint32_t id;
  } GWEN_INHERITDATA_LIST;

  void GWEN_InheritData_List_AddList(GWEN_INHERITDATA_LIST *dst, GWEN_INHERITDATA_LIST *l);

  void GWEN_InheritData_List_Add(GWEN_INHERITDATA *element, GWEN_INHERITDATA_LIST *list);

  void GWEN_InheritData_List_Insert(GWEN_INHERITDATA *element, GWEN_INHERITDATA_LIST *list);

  void GWEN_InheritData_List_Del(GWEN_INHERITDATA *element);

  GWEN_INHERITDATA* GWEN_InheritData_List_First(const GWEN_INHERITDATA_LIST *l);

  GWEN_INHERITDATA* GWEN_InheritData_List_Last(const GWEN_INHERITDATA_LIST *l);

  void GWEN_InheritData_List_Clear(GWEN_INHERITDATA_LIST *l);

  GWEN_INHERITDATA_LIST* GWEN_InheritData_List_new();

  void GWEN_InheritData_List_free(GWEN_INHERITDATA_LIST *l);

  GWEN_INHERITDATA* GWEN_InheritData_List_Next(const GWEN_INHERITDATA *element);

  GWEN_INHERITDATA* GWEN_InheritData_List_Previous(const GWEN_INHERITDATA *element);

  uint32_t GWEN_InheritData_List_GetCount(const GWEN_INHERITDATA_LIST *l);

  GWEN_INHERITDATA_LIST_SORT_FN GWEN_InheritData_List_SetSortFn(GWEN_INHERITDATA_LIST *l, GWEN_INHERITDATA_LIST_SORT_FN fn);

  void GWEN_InheritData_List_Sort(GWEN_INHERITDATA_LIST *l, int ascending);


#ifdef __cplusplus
}
#endif


#endif



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef t_LIST1_H
#define t_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct t_LIST_ELEMENT {
    uint32_t id;
    t *nextObject;
  } t_LIST__ELEMENT;

  typedef struct t_LIST t_LIST;

  typedef int GWENHYWFAR_CB (*t_LIST_SORT_FN)(const t *a, const t *b, int ascending);


  struct t_LIST {
    t *first;
    uint32_t count;
    uint32_t id;
  } t_LIST;

  void pr_List_AddList(t_LIST *dst, t_LIST *l);

  void pr_List_Add(t *element, t_LIST *list);

  void pr_List_Insert(t *element, t_LIST *list);

  void pr_List_Del(t *element);

  t* pr_List_First(const t_LIST *l);

  t* pr_List_Last(const t_LIST *l);

  void pr_List_Clear(t_LIST *l);

  t_LIST* pr_List_new();

  void pr_List_free(t_LIST *l);

  t* pr_List_Next(const t *element);

  t* pr_List_Previous(const t *element);

  uint32_t pr_List_GetCount(const t_LIST *l);

  t_LIST_SORT_FN pr_List_SetSortFn(t_LIST *l, t_LIST_SORT_FN fn);

  void pr_List_Sort(t_LIST *l, int ascending);


#ifdef __cplusplus
}
#endif


#endif



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef MYSTRUCT_LIST1_H
#define MYSTRUCT_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct MYSTRUCT_LIST_ELEMENT {
    uint32_t id;
    MYSTRUCT *nextObject;
  } MYSTRUCT_LIST__ELEMENT;

  typedef struct MYSTRUCT_LIST MYSTRUCT_LIST;

  typedef int GWENHYWFAR_CB (*MYSTRUCT_LIST_SORT_FN)(const MYSTRUCT *a, const MYSTRUCT *b, int ascending);


  struct MYSTRUCT_LIST {
    MYSTRUCT *first;
    uint32_t count;
    uint32_t id;
  } MYSTRUCT_LIST;

  void MyStruct_List_AddList(MYSTRUCT_LIST *dst, MYSTRUCT_LIST *l);

  void MyStruct_List_Add(MYSTRUCT *element, MYSTRUCT_LIST *list);

  void MyStruct_List_Insert(MYSTRUCT *element, MYSTRUCT_LIST *list);

  void MyStruct_List_Del(MYSTRUCT *element);

  MYSTRUCT* MyStruct_List_First(const MYSTRUCT_LIST *l);

  MYSTRUCT* MyStruct_List_Last(const MYSTRUCT_LIST *l);

  void MyStruct_List_Clear(MYSTRUCT_LIST *l);

  MYSTRUCT_LIST* MyStruct_List_new();

  void MyStruct_List_free(MYSTRUCT_LIST *l);

  MYSTRUCT* MyStruct_List_Next(const MYSTRUCT *element);

  MYSTRUCT* MyStruct_List_Previous(const MYSTRUCT *element);

  uint32_t MyStruct_List_GetCount(const MYSTRUCT_LIST *l);

  MYSTRUCT_LIST_SORT_FN MyStruct_List_SetSortFn(MYSTRUCT_LIST *l, MYSTRUCT_LIST_SORT_FN fn);

  void MyStruct_List_Sort(MYSTRUCT_LIST *l, int ascending);


#ifdef __cplusplus
}
#endif


#endif



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef t_LIST2_H
#define t_LIST2_H


#ifdef __cplusplus
extern "C" {
#endif

  typedef struct t_LIST2 t_LIST2;

  typedef struct t_LIST2_ITERATOR t_LIST2_ITERATOR;

  typedef t* (t_LIST2_FOREACH)(t *element,
                                                 void *user_data);

  t_LIST2 *pr_List2_new(); 

  void pr_List2_free(t_LIST2 *l); 

  void pr_List2_Dump(t_LIST2 *l, FILE *f, unsigned int indent); 

  void pr_List2_PushBack(t_LIST2 *l, t *p); 
   
  void pr_List2_PushFront(t_LIST2 *l, t *p); 

  t *pr_List2_GetFront(t_LIST2 *l); 
   
  t *pr_List2_GetBack(t_LIST2 *l); 

  void pr_List2_Erase(t_LIST2 *l,
                               t_LIST2_ITERATOR *it);

  unsigned int pr_List2_GetSize(t_LIST2 *l); 

  void pr_List2_PopBack(t_LIST2 *l); 
   
  void pr_List2_PopFront(t_LIST2 *l); 

  void pr_List2_Clear(t_LIST2 *l); 

  t_LIST2_ITERATOR *pr_List2_First(t_LIST2 *l); 
   
  t_LIST2_ITERATOR *pr_List2_Last(t_LIST2 *l); 

  t_LIST2_ITERATOR *pr_List2Iterator_new(t_LIST2 *l);

  void pr_List2Iterator_free(t_LIST2_ITERATOR *li); 

  t *pr_List2Iterator_Previous(t_LIST2_ITERATOR *li); 
   
  t *pr_List2Iterator_Next(t_LIST2_ITERATOR *li); 

  t *pr_List2Iterator_Data(t_LIST2_ITERATOR *li); 

  t *pr_List2_ForEach(t_LIST2 *list,
                                        t_LIST2_FOREACH func,
                                        void *user_data);


  typedef struct t_CONSTLIST2 t_CONSTLIST2; 
  typedef struct t_CONSTLIST2_ITERATOR t_CONSTLIST2_ITERATOR; 
  typedef const t*
    (t_CONSTLIST2_FOREACH)(const t *element,
                                    void *user_data);
  
   
  t_CONSTLIST2 *pr_ConstList2_new(); 
   
  void pr_ConstList2_free(t_CONSTLIST2 *l); 
   
  void pr_ConstList2_PushBack(t_CONSTLIST2 *l, const t *p); 
   
  void pr_ConstList2_PushFront(t_CONSTLIST2 *l, const t *p); 
   
  const t *pr_ConstList2_GetFront(t_CONSTLIST2 *l); 
   
  const t *pr_ConstList2_GetBack(t_CONSTLIST2 *l); 
   
  unsigned int pr_ConstList2_GetSize(t_CONSTLIST2 *l); 
   
  void pr_ConstList2_PopBack(t_CONSTLIST2 *l); 
   
  void pr_ConstList2_PopFront(t_CONSTLIST2 *l); 
   
  void pr_ConstList2_Clear(t_CONSTLIST2 *l); 
   
  t_CONSTLIST2_ITERATOR *pr_ConstList2_First(t_CONSTLIST2 *l); 
   
  t_CONSTLIST2_ITERATOR *pr_ConstList2_Last(t_CONSTLIST2 *l); 
   
  t_CONSTLIST2_ITERATOR *pr_ConstList2Iterator_new(t_CONSTLIST2 *l); 
   
  void pr_ConstList2Iterator_free(t_CONSTLIST2_ITERATOR *li); 
   
  const t *pr_ConstList2Iterator_Previous(t_CONSTLIST2_ITERATOR *li); 
   
  const t *pr_ConstList2Iterator_Next(t_CONSTLIST2_ITERATOR *li); 
   
  const t *pr_ConstList2Iterator_Data(t_CONSTLIST2_ITERATOR *li); 
   
  const t *pr_ConstList2_ForEach(t_CONSTLIST2 *list,
        t_CONSTLIST2_FOREACH func, void *user_data);


#ifdef __cplusplus
}
#endif


#endif /* t_LIST_H */



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef t_LIST2_H
#define t_LIST2_H


#ifdef __cplusplus
extern "C" {
#endif

  typedef struct t_LIST2 t_LIST2;

  typedef struct t_LIST2_ITERATOR t_LIST2_ITERATOR;

  typedef t* (t_LIST2_FOREACH)(t *element,
                                                 void *user_data);

  t_LIST2 *pr_List2_new(); 

  void pr_List2_free(t_LIST2 *l); 

  void pr_List2_Dump(t_LIST2 *l, FILE *f, unsigned int indent); 

  void pr_List2_PushBack(t_LIST2 *l, t *p); 
   
  void pr_List2_PushFront(t_LIST2 *l, t *p); 

  t *pr_List2_GetFront(t_LIST2 *l); 
   
  t *pr_List2_GetBack(t_LIST2 *l); 

  void pr_List2_Erase(t_LIST2 *l,
                               t_LIST2_ITERATOR *it);

  unsigned int pr_List2_GetSize(t_LIST2 *l); 

  void pr_List2_PopBack(t_LIST2 *l); 
   
  void pr_List2_PopFront(t_LIST2 *l); 

  void pr_List2_Clear(t_LIST2 *l); 

  t_LIST2_ITERATOR *pr_List2_First(t_LIST2 *l); 
   
  t_LIST2_ITERATOR *pr_List2_Last(t_LIST2 *l); 

  t_LIST2_ITERATOR *pr_List2Iterator_new(t_LIST2 *l);

  void pr_List2Iterator_free(t_LIST2_ITERATOR *li); 

  t *pr_List2Iterator_Previous(t_LIST2_ITERATOR *li); 
   
  t *pr_List2Iterator_Next(t_LIST2_ITERATOR *li); 

  t *pr_List2Iterator_Data(t_LIST2_ITERATOR *li); 

  t *pr_List2_ForEach(t_LIST2 *list,
                                        t_LIST2_FOREACH func,
                                        void *user_data);


  typedef struct t_CONSTLIST2 t_CONSTLIST2; 
  typedef struct t_CONSTLIST2_ITERATOR t_CONSTLIST2_ITERATOR; 
  typedef const t*
    (t_CONSTLIST2_FOREACH)(const t *element,
                                    void *user_data);
  
   
  t_CONSTLIST2 *pr_ConstList2_new(); 
   
  void pr_ConstList2_free(t_CONSTLIST2 *l); 
   
  void pr_ConstList2_PushBack(t_CONSTLIST2 *l, const t *p); 
   
  void pr_ConstList2_PushFront(t_CONSTLIST2 *l, const t *p); 
   
  const t *pr_ConstList2_GetFront(t_CONSTLIST2 *l); 
   
  const t *pr_ConstList2_GetBack(t_CONSTLIST2 *l); 
   
  unsigned int pr_ConstList2_GetSize(t_CONSTLIST2 *l); 
   
  void pr_ConstList2_PopBack(t_CONSTLIST2 *l); 
   
  void pr_ConstList2_PopFront(t_CONSTLIST2 *l); 
   
  void pr_ConstList2_Clear(t_CONSTLIST2 *l); 
   
  t_CONSTLIST2_ITERATOR *pr_ConstList2_First(t_CONSTLIST2 *l); 
   
  t_CONSTLIST2_ITERATOR *pr_ConstList2_Last(t_CONSTLIST2 *l); 
   
  t_CONSTLIST2_ITERATOR *pr_ConstList2Iterator_new(t_CONSTLIST2 *l); 
   
  void pr_ConstList2Iterator_free(t_CONSTLIST2_ITERATOR *li); 
   
  const t *pr_ConstList2Iterator_Previous(t_CONSTLIST2_ITERATOR *li); 
   
  const t *pr_ConstList2Iterator_Next(t_CONSTLIST2_ITERATOR *li); 
   
  const t *pr_ConstList2Iterator_Data(t_CONSTLIST2_ITERATOR *li); 
   
  const t *pr_ConstList2_ForEach(t_CONSTLIST2 *list,
        t_CONSTLIST2_FOREACH func, void *user_data);


#ifdef __cplusplus
}
#endif


#endif /* t_LIST_H */



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_PARAM_LIST2_H
#define GWEN_PARAM_LIST2_H


#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_PARAM_LIST2 GWEN_PARAM_LIST2;

  typedef struct GWEN_PARAM_LIST2_ITERATOR GWEN_PARAM_LIST2_ITERATOR;

  typedef GWEN_PARAM* (GWEN_PARAM_LIST2_FOREACH)(GWEN_PARAM *element,
                                                 void *user_data);

  GWEN_PARAM_LIST2 *GWEN_Param_List2_new(); 

  void GWEN_Param_List2_free(GWEN_PARAM_LIST2 *l); 

  void GWEN_Param_List2_Dump(GWEN_PARAM_LIST2 *l, FILE *f, unsigned int indent); 

  void GWEN_Param_List2_PushBack(GWEN_PARAM_LIST2 *l, GWEN_PARAM *p); 
   
  void GWEN_Param_List2_PushFront(GWEN_PARAM_LIST2 *l, GWEN_PARAM *p); 

  GWEN_PARAM *GWEN_Param_List2_GetFront(GWEN_PARAM_LIST2 *l); 
   
  GWEN_PARAM *GWEN_Param_List2_GetBack(GWEN_PARAM_LIST2 *l); 

  void GWEN_Param_List2_Erase(GWEN_PARAM_LIST2 *l,
                               GWEN_PARAM_LIST2_ITERATOR *it);

  unsigned int GWEN_Param_List2_GetSize(GWEN_PARAM_LIST2 *l); 

  void GWEN_Param_List2_PopBack(GWEN_PARAM_LIST2 *l); 
   
  void GWEN_Param_List2_PopFront(GWEN_PARAM_LIST2 *l); 

  void GWEN_Param_List2_Clear(GWEN_PARAM_LIST2 *l); 

  GWEN_PARAM_LIST2_ITERATOR *GWEN_Param_List2_First(GWEN_PARAM_LIST2 *l); 
   
  GWEN_PARAM_LIST2_ITERATOR *GWEN_Param_List2_Last(GWEN_PARAM_LIST2 *l); 

  GWEN_PARAM_LIST2_ITERATOR *GWEN_Param_List2Iterator_new(GWEN_PARAM_LIST2 *l);

  void GWEN_Param_List2Iterator_free(GWEN_PARAM_LIST2_ITERATOR *li); 

  GWEN_PARAM *GWEN_Param_List2Iterator_Previous(GWEN_PARAM_LIST2_ITERATOR *li); 
   
  GWEN_PARAM *GWEN_Param_List2Iterator_Next(GWEN_PARAM_LIST2_ITERATOR *li); 

  GWEN_PARAM *GWEN_Param_List2Iterator_Data(GWEN_PARAM_LIST2_ITERATOR *li); 

  GWEN_PARAM *GWEN_Param_List2_ForEach(GWEN_PARAM_LIST2 *list,
                                        GWEN_PARAM_LIST2_FOREACH func,
                                        void *user_data);


  typedef struct GWEN_PARAM_CONSTLIST2 GWEN_PARAM_CONSTLIST2; 
  typedef struct GWEN_PARAM_CONSTLIST2_ITERATOR GWEN_PARAM_CONSTLIST2_ITERATOR; 
  typedef const GWEN_PARAM*
    (GWEN_PARAM_CONSTLIST2_FOREACH)(const GWEN_PARAM *element,
                                    void *user_data);
  
   
  GWEN_PARAM_CONSTLIST2 *GWEN_Param_ConstList2_new(); 
   
  void GWEN_Param_ConstList2_free(GWEN_PARAM_CONSTLIST2 *l); 
   
  void GWEN_Param_ConstList2_PushBack(GWEN_PARAM_CONSTLIST2 *l, const GWEN_PARAM *p); 
   
  void GWEN_Param_ConstList2_PushFront(GWEN_PARAM_CONSTLIST2 *l, const GWEN_PARAM *p); 
   
  const GWEN_PARAM *GWEN_Param_ConstList2_GetFront(GWEN_PARAM_CONSTLIST2 *l); 
   
  const GWEN_PARAM *GWEN_Param_ConstList2_GetBack(GWEN_PARAM_CONSTLIST2 *l); 
   
  unsigned int GWEN_Param_ConstList2_GetSize(GWEN_PARAM_CONSTLIST2 *l); 
   
  void GWEN_Param_ConstList2_PopBack(GWEN_PARAM_CONSTLIST2 *l); 
   
  void GWEN_Param_ConstList2_PopFront(GWEN_PARAM_CONSTLIST2 *l); 
   
  void GWEN_Param_ConstList2_Clear(GWEN_PARAM_CONSTLIST2 *l); 
   
  GWEN_PARAM_CONSTLIST2_ITERATOR *GWEN_Param_ConstList2_First(GWEN_PARAM_CONSTLIST2 *l); 
   
  GWEN_PARAM_CONSTLIST2_ITERATOR *GWEN_Param_ConstList2_Last(GWEN_PARAM_CONSTLIST2 *l); 
   
  GWEN_PARAM_CONSTLIST2_ITERATOR *GWEN_Param_ConstList2Iterator_new(GWEN_PARAM_CONSTLIST2 *l); 
   
  void GWEN_Param_ConstList2Iterator_free(GWEN_PARAM_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_PARAM *GWEN_Param_ConstList2Iterator_Previous(GWEN_PARAM_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_PARAM *GWEN_Param_ConstList2Iterator_Next(GWEN_PARAM_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_PARAM *GWEN_Param_ConstList2Iterator_Data(GWEN_PARAM_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_PARAM *GWEN_Param_ConstList2_ForEach(GWEN_PARAM_CONSTLIST2 *list,
        GWEN_PARAM_CONSTLIST2_FOREACH func, void *user_data);


#ifdef __cplusplus
}
#endif


#endif /* GWEN_PARAM_LIST_H */



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_PARAM_LIST1_H
#define GWEN_PARAM_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_PARAM_LIST_ELEMENT {
    uint32_t id;
    GWEN_PARAM *nextObject;
  } GWEN_PARAM_LIST__ELEMENT;

  typedef struct GWEN_PARAM_LIST GWEN_PARAM_LIST;

  typedef int GWENHYWFAR_CB (*GWEN_PARAM_LIST_SORT_FN)(const GWEN_PARAM *a, const GWEN_PARAM *b, int ascending);


  struct GWEN_PARAM_LIST {
    GWEN_PARAM *first;
    uint32_t count;
    uint32_t id;
  } GWEN_PARAM_LIST;

  void GWEN_Param_List_AddList(GWEN_PARAM_LIST *dst, GWEN_PARAM_LIST *l);

  void GWEN_Param_List_Add(GWEN_PARAM *element, GWEN_PARAM_LIST *list);

  void GWEN_Param_List_Insert(GWEN_PARAM *element, GWEN_PARAM_LIST *list);

  void GWEN_Param_List_Del(GWEN_PARAM *element);

  GWEN_PARAM* GWEN_Param_List_First(const GWEN_PARAM_LIST *l);

  GWEN_PARAM* GWEN_Param_List_Last(const GWEN_PARAM_LIST *l);

  void GWEN_Param_List_Clear(GWEN_PARAM_LIST *l);

  GWEN_PARAM_LIST* GWEN_Param_List_new();

  void GWEN_Param_List_free(GWEN_PARAM_LIST *l);

  GWEN_PARAM* GWEN_Param_List_Next(const GWEN_PARAM *element);

  GWEN_PARAM* GWEN_Param_List_Previous(const GWEN_PARAM *element);

  uint32_t GWEN_Param_List_GetCount(const GWEN_PARAM_LIST *l);

  GWEN_PARAM_LIST_SORT_FN GWEN_Param_List_SetSortFn(GWEN_PARAM_LIST *l, GWEN_PARAM_LIST_SORT_FN fn);

  void GWEN_Param_List_Sort(GWEN_PARAM_LIST *l, int ascending);


#ifdef __cplusplus
}
#endif


#endif



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_PLUGIN_DESCRIPTION_LIST2_H
#define GWEN_PLUGIN_DESCRIPTION_LIST2_H


#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_PLUGIN_DESCRIPTION_LIST2 GWEN_PLUGIN_DESCRIPTION_LIST2;

  typedef struct GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR;

  typedef GWEN_PLUGIN_DESCRIPTION* (GWEN_PLUGIN_DESCRIPTION_LIST2_FOREACH)(GWEN_PLUGIN_DESCRIPTION *element,
                                                 void *user_data);

  GWEN_PLUGIN_DESCRIPTION_LIST2 *GWEN_PluginDescription_List2_new(); 

  void GWEN_PluginDescription_List2_free(GWEN_PLUGIN_DESCRIPTION_LIST2 *l); 

  void GWEN_PluginDescription_List2_Dump(GWEN_PLUGIN_DESCRIPTION_LIST2 *l, FILE *f, unsigned int indent); 

  void GWEN_PluginDescription_List2_PushBack(GWEN_PLUGIN_DESCRIPTION_LIST2 *l, GWEN_PLUGIN_DESCRIPTION *p); 
   
  void GWEN_PluginDescription_List2_PushFront(GWEN_PLUGIN_DESCRIPTION_LIST2 *l, GWEN_PLUGIN_DESCRIPTION *p); 

  GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_List2_GetFront(GWEN_PLUGIN_DESCRIPTION_LIST2 *l); 
   
  GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_List2_GetBack(GWEN_PLUGIN_DESCRIPTION_LIST2 *l); 

  void GWEN_PluginDescription_List2_Erase(GWEN_PLUGIN_DESCRIPTION_LIST2 *l,
                               GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *it);

  unsigned int GWEN_PluginDescription_List2_GetSize(GWEN_PLUGIN_DESCRIPTION_LIST2 *l); 

  void GWEN_PluginDescription_List2_PopBack(GWEN_PLUGIN_DESCRIPTION_LIST2 *l); 
   
  void GWEN_PluginDescription_List2_PopFront(GWEN_PLUGIN_DESCRIPTION_LIST2 *l); 

  void GWEN_PluginDescription_List2_Clear(GWEN_PLUGIN_DESCRIPTION_LIST2 *l); 

  GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *GWEN_PluginDescription_List2_First(GWEN_PLUGIN_DESCRIPTION_LIST2 *l); 
   
  GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *GWEN_PluginDescription_List2_Last(GWEN_PLUGIN_DESCRIPTION_LIST2 *l); 

  GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *GWEN_PluginDescription_List2Iterator_new(GWEN_PLUGIN_DESCRIPTION_LIST2 *l);

  void GWEN_PluginDescription_List2Iterator_free(GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *li); 

  GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_List2Iterator_Previous(GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *li); 
   
  GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_List2Iterator_Next(GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *li); 

  GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_List2Iterator_Data(GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *li); 

  GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_List2_ForEach(GWEN_PLUGIN_DESCRIPTION_LIST2 *list,
                                        GWEN_PLUGIN_DESCRIPTION_LIST2_FOREACH func,
                                        void *user_data);


  typedef struct GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 GWEN_PLUGIN_DESCRIPTION_CONSTLIST2; 
  typedef struct GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR; 
  typedef const GWEN_PLUGIN_DESCRIPTION*
    (GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_FOREACH)(const GWEN_PLUGIN_DESCRIPTION *element,
                                    void *user_data);
  
   
  GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *GWEN_PluginDescription_ConstList2_new(); 
   
  void GWEN_PluginDescription_ConstList2_free(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l); 
   
  void GWEN_PluginDescription_ConstList2_PushBack(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l, const GWEN_PLUGIN_DESCRIPTION *p); 
   
  void GWEN_PluginDescription_ConstList2_PushFront(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l, const GWEN_PLUGIN_DESCRIPTION *p); 
   
  const GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_ConstList2_GetFront(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l); 
   
  const GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_ConstList2_GetBack(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l); 
   
  unsigned int GWEN_PluginDescription_ConstList2_GetSize(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l); 
   
  void GWEN_PluginDescription_ConstList2_PopBack(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l); 
   
  void GWEN_PluginDescription_ConstList2_PopFront(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l); 
   
  void GWEN_PluginDescription_ConstList2_Clear(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l); 
   
  GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *GWEN_PluginDescription_ConstList2_First(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l); 
   
  GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *GWEN_PluginDescription_ConstList2_Last(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l); 
   
  GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *GWEN_PluginDescription_ConstList2Iterator_new(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l); 
   
  void GWEN_PluginDescription_ConstList2Iterator_free(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_ConstList2Iterator_Previous(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_ConstList2Iterator_Next(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_ConstList2Iterator_Data(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_ConstList2_ForEach(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *list,
        GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_FOREACH func, void *user_data);


#ifdef __cplusplus
}
#endif


#endif /* GWEN_PLUGIN_DESCRIPTION_LIST_H */



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_PLUGIN_DESCRIPTION_LIST1_H
#define GWEN_PLUGIN_DESCRIPTION_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_PLUGIN_DESCRIPTION_LIST_ELEMENT {
    uint32_t id;
    GWEN_PLUGIN_DESCRIPTION *nextObject;
  } GWEN_PLUGIN_DESCRIPTION_LIST__ELEMENT;

  typedef struct GWEN_PLUGIN_DESCRIPTION_LIST GWEN_PLUGIN_DESCRIPTION_LIST;

  typedef int GWENHYWFAR_CB (*GWEN_PLUGIN_DESCRIPTION_LIST_SORT_FN)(const GWEN_PLUGIN_DESCRIPTION *a, const GWEN_PLUGIN_DESCRIPTION *b, int ascending);


  struct GWEN_PLUGIN_DESCRIPTION_LIST {
    GWEN_PLUGIN_DESCRIPTION *first;
    uint32_t count;
    uint32_t id;
  } GWEN_PLUGIN_DESCRIPTION_LIST;

  void GWEN_PluginDescription_List_AddList(GWEN_PLUGIN_DESCRIPTION_LIST *dst, GWEN_PLUGIN_DESCRIPTION_LIST *l);

  void GWEN_PluginDescription_List_Add(GWEN_PLUGIN_DESCRIPTION *element, GWEN_PLUGIN_DESCRIPTION_LIST *list);

  void GWEN_PluginDescription_List_Insert(GWEN_PLUGIN_DESCRIPTION *element, GWEN_PLUGIN_DESCRIPTION_LIST *list);

  void GWEN_PluginDescription_List_Del(GWEN_PLUGIN_DESCRIPTION *element);

  GWEN_PLUGIN_DESCRIPTION* GWEN_PluginDescription_List_First(const GWEN_PLUGIN_DESCRIPTION_LIST *l);

  GWEN_PLUGIN_DESCRIPTION* GWEN_PluginDescription_List_Last(const GWEN_PLUGIN_DESCRIPTION_LIST *l);

  void GWEN_PluginDescription_List_Clear(GWEN_PLUGIN_DESCRIPTION_LIST *l);

  GWEN_PLUGIN_DESCRIPTION_LIST* GWEN_PluginDescription_List_new();

  void GWEN_PluginDescription_List_free(GWEN_PLUGIN_DESCRIPTION_LIST *l);

  GWEN_PLUGIN_DESCRIPTION* GWEN_PluginDescription_List_Next(const GWEN_PLUGIN_DESCRIPTION *element);

  GWEN_PLUGIN_DESCRIPTION* GWEN_PluginDescription_List_Previous(const GWEN_PLUGIN_DESCRIPTION *element);

  uint32_t GWEN_PluginDescription_List_GetCount(const GWEN_PLUGIN_DESCRIPTION_LIST *l);

  GWEN_PLUGIN_DESCRIPTION_LIST_SORT_FN GWEN_PluginDescription_List_SetSortFn(GWEN_PLUGIN_DESCRIPTION_LIST *l, GWEN_PLUGIN_DESCRIPTION_LIST_SORT_FN fn);

  void GWEN_PluginDescription_List_Sort(GWEN_PLUGIN_DESCRIPTION_LIST *l, int ascending);


#ifdef __cplusplus
}
#endif


#endif



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_CRYPT_CRYPTALGO_LIST2_H
#define GWEN_CRYPT_CRYPTALGO_LIST2_H


#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_CRYPT_CRYPTALGO_LIST2 GWEN_CRYPT_CRYPTALGO_LIST2;

  typedef struct GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR;

  typedef GWEN_CRYPT_CRYPTALGO* (GWEN_CRYPT_CRYPTALGO_LIST2_FOREACH)(GWEN_CRYPT_CRYPTALGO *element,
                                                 void *user_data);

  GWEN_CRYPT_CRYPTALGO_LIST2 *GWEN_Crypt_CryptAlgo_List2_new(); 

  void GWEN_Crypt_CryptAlgo_List2_free(GWEN_CRYPT_CRYPTALGO_LIST2 *l); 

  void GWEN_Crypt_CryptAlgo_List2_Dump(GWEN_CRYPT_CRYPTALGO_LIST2 *l, FILE *f, unsigned int indent); 

  void GWEN_Crypt_CryptAlgo_List2_PushBack(GWEN_CRYPT_CRYPTALGO_LIST2 *l, GWEN_CRYPT_CRYPTALGO *p); 
   
  void GWEN_Crypt_CryptAlgo_List2_PushFront(GWEN_CRYPT_CRYPTALGO_LIST2 *l, GWEN_CRYPT_CRYPTALGO *p); 

  GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_List2_GetFront(GWEN_CRYPT_CRYPTALGO_LIST2 *l); 
   
  GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_List2_GetBack(GWEN_CRYPT_CRYPTALGO_LIST2 *l); 

  void GWEN_Crypt_CryptAlgo_List2_Erase(GWEN_CRYPT_CRYPTALGO_LIST2 *l,
                               GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *it);

  unsigned int GWEN_Crypt_CryptAlgo_List2_GetSize(GWEN_CRYPT_CRYPTALGO_LIST2 *l); 

  void GWEN_Crypt_CryptAlgo_List2_PopBack(GWEN_CRYPT_CRYPTALGO_LIST2 *l); 
   
  void GWEN_Crypt_CryptAlgo_List2_PopFront(GWEN_CRYPT_CRYPTALGO_LIST2 *l); 

  void GWEN_Crypt_CryptAlgo_List2_Clear(GWEN_CRYPT_CRYPTALGO_LIST2 *l); 

  GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *GWEN_Crypt_CryptAlgo_List2_First(GWEN_CRYPT_CRYPTALGO_LIST2 *l); 
   
  GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *GWEN_Crypt_CryptAlgo_List2_Last(GWEN_CRYPT_CRYPTALGO_LIST2 *l); 

  GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *GWEN_Crypt_CryptAlgo_List2Iterator_new(GWEN_CRYPT_CRYPTALGO_LIST2 *l);

  void GWEN_Crypt_CryptAlgo_List2Iterator_free(GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *li); 

  GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_List2Iterator_Previous(GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *li); 
   
  GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_List2Iterator_Next(GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *li); 

  GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_List2Iterator_Data(GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *li); 

  GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_List2_ForEach(GWEN_CRYPT_CRYPTALGO_LIST2 *list,
                                        GWEN_CRYPT_CRYPTALGO_LIST2_FOREACH func,
                                        void *user_data);


  typedef struct GWEN_CRYPT_CRYPTALGO_CONSTLIST2 GWEN_CRYPT_CRYPTALGO_CONSTLIST2; 
  typedef struct GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR; 
  typedef const GWEN_CRYPT_CRYPTALGO*
    (GWEN_CRYPT_CRYPTALGO_CONSTLIST2_FOREACH)(const GWEN_CRYPT_CRYPTALGO *element,
                                    void *user_data);
  
   
  GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *GWEN_Crypt_CryptAlgo_ConstList2_new(); 
   
  void GWEN_Crypt_CryptAlgo_ConstList2_free(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l); 
   
  void GWEN_Crypt_CryptAlgo_ConstList2_PushBack(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l, const GWEN_CRYPT_CRYPTALGO *p); 
   
  void GWEN_Crypt_CryptAlgo_ConstList2_PushFront(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l, const GWEN_CRYPT_CRYPTALGO *p); 
   
  const GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_ConstList2_GetFront(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l); 
   
  const GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_ConstList2_GetBack(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l); 
   
  unsigned int GWEN_Crypt_CryptAlgo_ConstList2_GetSize(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l); 
   
  void GWEN_Crypt_CryptAlgo_ConstList2_PopBack(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l); 
   
  void GWEN_Crypt_CryptAlgo_ConstList2_PopFront(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l); 
   
  void GWEN_Crypt_CryptAlgo_ConstList2_Clear(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l); 
   
  GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_CryptAlgo_ConstList2_First(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l); 
   
  GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_CryptAlgo_ConstList2_Last(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l); 
   
  GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_CryptAlgo_ConstList2Iterator_new(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l); 
   
  void GWEN_Crypt_CryptAlgo_ConstList2Iterator_free(GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_ConstList2Iterator_Previous(GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_ConstList2Iterator_Next(GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_ConstList2Iterator_Data(GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_ConstList2_ForEach(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *list,
        GWEN_CRYPT_CRYPTALGO_CONSTLIST2_FOREACH func, void *user_data);


#ifdef __cplusplus
}
#endif


#endif /* GWEN_CRYPT_CRYPTALGO_LIST_H */



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_CRYPT_KEY_LIST2_H
#define GWEN_CRYPT_KEY_LIST2_H


#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_CRYPT_KEY_LIST2 GWEN_CRYPT_KEY_LIST2;

  typedef struct GWEN_CRYPT_KEY_LIST2_ITERATOR GWEN_CRYPT_KEY_LIST2_ITERATOR;

  typedef GWEN_CRYPT_KEY* (GWEN_CRYPT_KEY_LIST2_FOREACH)(GWEN_CRYPT_KEY *element,
                                                 void *user_data);

  GWEN_CRYPT_KEY_LIST2 *GWEN_Crypt_Key_List2_new(); 

  void GWEN_Crypt_Key_List2_free(GWEN_CRYPT_KEY_LIST2 *l); 

  void GWEN_Crypt_Key_List2_Dump(GWEN_CRYPT_KEY_LIST2 *l, FILE *f, unsigned int indent); 

  void GWEN_Crypt_Key_List2_PushBack(GWEN_CRYPT_KEY_LIST2 *l, GWEN_CRYPT_KEY *p); 
   
  void GWEN_Crypt_Key_List2_PushFront(GWEN_CRYPT_KEY_LIST2 *l, GWEN_CRYPT_KEY *p); 

  GWEN_CRYPT_KEY *GWEN_Crypt_Key_List2_GetFront(GWEN_CRYPT_KEY_LIST2 *l); 
   
  GWEN_CRYPT_KEY *GWEN_Crypt_Key_List2_GetBack(GWEN_CRYPT_KEY_LIST2 *l); 

  void GWEN_Crypt_Key_List2_Erase(GWEN_CRYPT_KEY_LIST2 *l,
                               GWEN_CRYPT_KEY_LIST2_ITERATOR *it);

  unsigned int GWEN_Crypt_Key_List2_GetSize(GWEN_CRYPT_KEY_LIST2 *l); 

  void GWEN_Crypt_Key_List2_PopBack(GWEN_CRYPT_KEY_LIST2 *l); 
   
  void GWEN_Crypt_Key_List2_PopFront(GWEN_CRYPT_KEY_LIST2 *l); 

  void GWEN_Crypt_Key_List2_Clear(GWEN_CRYPT_KEY_LIST2 *l); 

  GWEN_CRYPT_KEY_LIST2_ITERATOR *GWEN_Crypt_Key_List2_First(GWEN_CRYPT_KEY_LIST2 *l); 
   
  GWEN_CRYPT_KEY_LIST2_ITERATOR *GWEN_Crypt_Key_List2_Last(GWEN_CRYPT_KEY_LIST2 *l); 

  GWEN_CRYPT_KEY_LIST2_ITERATOR *GWEN_Crypt_Key_List2Iterator_new(GWEN_CRYPT_KEY_LIST2 *l);

  void GWEN_Crypt_Key_List2Iterator_free(GWEN_CRYPT_KEY_LIST2_ITERATOR *li); 

  GWEN_CRYPT_KEY *GWEN_Crypt_Key_List2Iterator_Previous(GWEN_CRYPT_KEY_LIST2_ITERATOR *li); 
   
  GWEN_CRYPT_KEY *GWEN_Crypt_Key_List2Iterator_Next(GWEN_CRYPT_KEY_LIST2_ITERATOR *li); 

  GWEN_CRYPT_KEY *GWEN_Crypt_Key_List2Iterator_Data(GWEN_CRYPT_KEY_LIST2_ITERATOR *li); 

  GWEN_CRYPT_KEY *GWEN_Crypt_Key_List2_ForEach(GWEN_CRYPT_KEY_LIST2 *list,
                                        GWEN_CRYPT_KEY_LIST2_FOREACH func,
                                        void *user_data);


  typedef struct GWEN_CRYPT_KEY_CONSTLIST2 GWEN_CRYPT_KEY_CONSTLIST2; 
  typedef struct GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR; 
  typedef const GWEN_CRYPT_KEY*
    (GWEN_CRYPT_KEY_CONSTLIST2_FOREACH)(const GWEN_CRYPT_KEY *element,
                                    void *user_data);
  
   
  GWEN_CRYPT_KEY_CONSTLIST2 *GWEN_Crypt_Key_ConstList2_new(); 
   
  void GWEN_Crypt_Key_ConstList2_free(GWEN_CRYPT_KEY_CONSTLIST2 *l); 
   
  void GWEN_Crypt_Key_ConstList2_PushBack(GWEN_CRYPT_KEY_CONSTLIST2 *l, const GWEN_CRYPT_KEY *p); 
   
  void GWEN_Crypt_Key_ConstList2_PushFront(GWEN_CRYPT_KEY_CONSTLIST2 *l, const GWEN_CRYPT_KEY *p); 
   
  const GWEN_CRYPT_KEY *GWEN_Crypt_Key_ConstList2_GetFront(GWEN_CRYPT_KEY_CONSTLIST2 *l); 
   
  const GWEN_CRYPT_KEY *GWEN_Crypt_Key_ConstList2_GetBack(GWEN_CRYPT_KEY_CONSTLIST2 *l); 
   
  unsigned int GWEN_Crypt_Key_ConstList2_GetSize(GWEN_CRYPT_KEY_CONSTLIST2 *l); 
   
  void GWEN_Crypt_Key_ConstList2_PopBack(GWEN_CRYPT_KEY_CONSTLIST2 *l); 
   
  void GWEN_Crypt_Key_ConstList2_PopFront(GWEN_CRYPT_KEY_CONSTLIST2 *l); 
   
  void GWEN_Crypt_Key_ConstList2_Clear(GWEN_CRYPT_KEY_CONSTLIST2 *l); 
   
  GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR *GWEN_Crypt_Key_ConstList2_First(GWEN_CRYPT_KEY_CONSTLIST2 *l); 
   
  GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR *GWEN_Crypt_Key_ConstList2_Last(GWEN_CRYPT_KEY_CONSTLIST2 *l); 
   
  GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR *GWEN_Crypt_Key_ConstList2Iterator_new(GWEN_CRYPT_KEY_CONSTLIST2 *l); 
   
  void GWEN_Crypt_Key_ConstList2Iterator_free(GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_CRYPT_KEY *GWEN_Crypt_Key_ConstList2Iterator_Previous(GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_CRYPT_KEY *GWEN_Crypt_Key_ConstList2Iterator_Next(GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_CRYPT_KEY *GWEN_Crypt_Key_ConstList2Iterator_Data(GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_CRYPT_KEY *GWEN_Crypt_Key_ConstList2_ForEach(GWEN_CRYPT_KEY_CONSTLIST2 *list,
        GWEN_CRYPT_KEY_CONSTLIST2_FOREACH func, void *user_data);


#ifdef __cplusplus
}
#endif


#endif /* GWEN_CRYPT_KEY_LIST_H */



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_CRYPT_KEY_LIST1_H
#define GWEN_CRYPT_KEY_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_CRYPT_KEY_LIST_ELEMENT {
    uint32_t id;
    GWEN_CRYPT_KEY *nextObject;
  } GWEN_CRYPT_KEY_LIST__ELEMENT;

  typedef struct GWEN_CRYPT_KEY_LIST GWEN_CRYPT_KEY_LIST;

  typedef int GWENHYWFAR_CB (*GWEN_CRYPT_KEY_LIST_SORT_FN)(const GWEN_CRYPT_KEY *a, const GWEN_CRYPT_KEY *b, int ascending);


  struct GWEN_CRYPT_KEY_LIST {
    GWEN_CRYPT_KEY *first;
    uint32_t count;
    uint32_t id;
  } GWEN_CRYPT_KEY_LIST;

  void GWEN_Crypt_Key_List_AddList(GWEN_CRYPT_KEY_LIST *dst, GWEN_CRYPT_KEY_LIST *l);

  void GWEN_Crypt_Key_List_Add(GWEN_CRYPT_KEY *element, GWEN_CRYPT_KEY_LIST *list);

  void GWEN_Crypt_Key_List_Insert(GWEN_CRYPT_KEY *element, GWEN_CRYPT_KEY_LIST *list);

  void GWEN_Crypt_Key_List_Del(GWEN_CRYPT_KEY *element);

  GWEN_CRYPT_KEY* GWEN_Crypt_Key_List_First(const GWEN_CRYPT_KEY_LIST *l);

  GWEN_CRYPT_KEY* GWEN_Crypt_Key_List_Last(const GWEN_CRYPT_KEY_LIST *l);

  void GWEN_Crypt_Key_List_Clear(GWEN_CRYPT_KEY_LIST *l);

  GWEN_CRYPT_KEY_LIST* GWEN_Crypt_Key_List_new();

  void GWEN_Crypt_Key_List_free(GWEN_CRYPT_KEY_LIST *l);

  GWEN_CRYPT_KEY* GWEN_Crypt_Key_List_Next(const GWEN_CRYPT_KEY *element);

  GWEN_CRYPT_KEY* GWEN_Crypt_Key_List_Previous(const GWEN_CRYPT_KEY *element);

  uint32_t GWEN_Crypt_Key_List_GetCount(const GWEN_CRYPT_KEY_LIST *l);

  GWEN_CRYPT_KEY_LIST_SORT_FN GWEN_Crypt_Key_List_SetSortFn(GWEN_CRYPT_KEY_LIST *l, GWEN_CRYPT_KEY_LIST_SORT_FN fn);

  void GWEN_Crypt_Key_List_Sort(GWEN_CRYPT_KEY_LIST *l, int ascending);


#ifdef __cplusplus
}
#endif


#endif



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_CRYPT_HASHALGO_LIST2_H
#define GWEN_CRYPT_HASHALGO_LIST2_H


#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_CRYPT_HASHALGO_LIST2 GWEN_CRYPT_HASHALGO_LIST2;

  typedef struct GWEN_CRYPT_HASHALGO_LIST2_ITERATOR GWEN_CRYPT_HASHALGO_LIST2_ITERATOR;

  typedef GWEN_CRYPT_HASHALGO* (GWEN_CRYPT_HASHALGO_LIST2_FOREACH)(GWEN_CRYPT_HASHALGO *element,
                                                 void *user_data);

  GWEN_CRYPT_HASHALGO_LIST2 *GWEN_Crypt_HashAlgo_List2_new(); 

  void GWEN_Crypt_HashAlgo_List2_free(GWEN_CRYPT_HASHALGO_LIST2 *l); 

  void GWEN_Crypt_HashAlgo_List2_Dump(GWEN_CRYPT_HASHALGO_LIST2 *l, FILE *f, unsigned int indent); 

  void GWEN_Crypt_HashAlgo_List2_PushBack(GWEN_CRYPT_HASHALGO_LIST2 *l, GWEN_CRYPT_HASHALGO *p); 
   
  void GWEN_Crypt_HashAlgo_List2_PushFront(GWEN_CRYPT_HASHALGO_LIST2 *l, GWEN_CRYPT_HASHALGO *p); 

  GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_List2_GetFront(GWEN_CRYPT_HASHALGO_LIST2 *l); 
   
  GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_List2_GetBack(GWEN_CRYPT_HASHALGO_LIST2 *l); 

  void GWEN_Crypt_HashAlgo_List2_Erase(GWEN_CRYPT_HASHALGO_LIST2 *l,
                               GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *it);

  unsigned int GWEN_Crypt_HashAlgo_List2_GetSize(GWEN_CRYPT_HASHALGO_LIST2 *l); 

  void GWEN_Crypt_HashAlgo_List2_PopBack(GWEN_CRYPT_HASHALGO_LIST2 *l); 
   
  void GWEN_Crypt_HashAlgo_List2_PopFront(GWEN_CRYPT_HASHALGO_LIST2 *l); 

  void GWEN_Crypt_HashAlgo_List2_Clear(GWEN_CRYPT_HASHALGO_LIST2 *l); 

  GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *GWEN_Crypt_HashAlgo_List2_First(GWEN_CRYPT_HASHALGO_LIST2 *l); 
   
  GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *GWEN_Crypt_HashAlgo_List2_Last(GWEN_CRYPT_HASHALGO_LIST2 *l); 

  GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *GWEN_Crypt_HashAlgo_List2Iterator_new(GWEN_CRYPT_HASHALGO_LIST2 *l);

  void GWEN_Crypt_HashAlgo_List2Iterator_free(GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *li); 

  GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_List2Iterator_Previous(GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *li); 
   
  GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_List2Iterator_Next(GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *li); 

  GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_List2Iterator_Data(GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *li); 

  GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_List2_ForEach(GWEN_CRYPT_HASHALGO_LIST2 *list,
                                        GWEN_CRYPT_HASHALGO_LIST2_FOREACH func,
                                        void *user_data);


  typedef struct GWEN_CRYPT_HASHALGO_CONSTLIST2 GWEN_CRYPT_HASHALGO_CONSTLIST2; 
  typedef struct GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR; 
  typedef const GWEN_CRYPT_HASHALGO*
    (GWEN_CRYPT_HASHALGO_CONSTLIST2_FOREACH)(const GWEN_CRYPT_HASHALGO *element,
                                    void *user_data);
  
   
  GWEN_CRYPT_HASHALGO_CONSTLIST2 *GWEN_Crypt_HashAlgo_ConstList2_new(); 
   
  void GWEN_Crypt_HashAlgo_ConstList2_free(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l); 
   
  void GWEN_Crypt_HashAlgo_ConstList2_PushBack(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l, const GWEN_CRYPT_HASHALGO *p); 
   
  void GWEN_Crypt_HashAlgo_ConstList2_PushFront(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l, const GWEN_CRYPT_HASHALGO *p); 
   
  const GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_ConstList2_GetFront(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l); 
   
  const GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_ConstList2_GetBack(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l); 
   
  unsigned int GWEN_Crypt_HashAlgo_ConstList2_GetSize(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l); 
   
  void GWEN_Crypt_HashAlgo_ConstList2_PopBack(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l); 
   
  void GWEN_Crypt_HashAlgo_ConstList2_PopFront(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l); 
   
  void GWEN_Crypt_HashAlgo_ConstList2_Clear(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l); 
   
  GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_HashAlgo_ConstList2_First(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l); 
   
  GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_HashAlgo_ConstList2_Last(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l); 
   
  GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_HashAlgo_ConstList2Iterator_new(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l); 
   
  void GWEN_Crypt_HashAlgo_ConstList2Iterator_free(GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_ConstList2Iterator_Previous(GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_ConstList2Iterator_Next(GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_ConstList2Iterator_Data(GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_ConstList2_ForEach(GWEN_CRYPT_HASHALGO_CONSTLIST2 *list,
        GWEN_CRYPT_HASHALGO_CONSTLIST2_FOREACH func, void *user_data);


#ifdef __cplusplus
}
#endif


#endif /* GWEN_CRYPT_HASHALGO_LIST_H */



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_MDIGEST_LIST2_H
#define GWEN_MDIGEST_LIST2_H


#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_MDIGEST_LIST2 GWEN_MDIGEST_LIST2;

  typedef struct GWEN_MDIGEST_LIST2_ITERATOR GWEN_MDIGEST_LIST2_ITERATOR;

  typedef GWEN_MDIGEST* (GWEN_MDIGEST_LIST2_FOREACH)(GWEN_MDIGEST *element,
                                                 void *user_data);

  GWEN_MDIGEST_LIST2 *GWEN_MDigest_List2_new(); 

  void GWEN_MDigest_List2_free(GWEN_MDIGEST_LIST2 *l); 

  void GWEN_MDigest_List2_Dump(GWEN_MDIGEST_LIST2 *l, FILE *f, unsigned int indent); 

  void GWEN_MDigest_List2_PushBack(GWEN_MDIGEST_LIST2 *l, GWEN_MDIGEST *p); 
   
  void GWEN_MDigest_List2_PushFront(GWEN_MDIGEST_LIST2 *l, GWEN_MDIGEST *p); 

  GWEN_MDIGEST *GWEN_MDigest_List2_GetFront(GWEN_MDIGEST_LIST2 *l); 
   
  GWEN_MDIGEST *GWEN_MDigest_List2_GetBack(GWEN_MDIGEST_LIST2 *l); 

  void GWEN_MDigest_List2_Erase(GWEN_MDIGEST_LIST2 *l,
                               GWEN_MDIGEST_LIST2_ITERATOR *it);

  unsigned int GWEN_MDigest_List2_GetSize(GWEN_MDIGEST_LIST2 *l); 

  void GWEN_MDigest_List2_PopBack(GWEN_MDIGEST_LIST2 *l); 
   
  void GWEN_MDigest_List2_PopFront(GWEN_MDIGEST_LIST2 *l); 

  void GWEN_MDigest_List2_Clear(GWEN_MDIGEST_LIST2 *l); 

  GWEN_MDIGEST_LIST2_ITERATOR *GWEN_MDigest_List2_First(GWEN_MDIGEST_LIST2 *l); 
   
  GWEN_MDIGEST_LIST2_ITERATOR *GWEN_MDigest_List2_Last(GWEN_MDIGEST_LIST2 *l); 

  GWEN_MDIGEST_LIST2_ITERATOR *GWEN_MDigest_List2Iterator_new(GWEN_MDIGEST_LIST2 *l);

  void GWEN_MDigest_List2Iterator_free(GWEN_MDIGEST_LIST2_ITERATOR *li); 

  GWEN_MDIGEST *GWEN_MDigest_List2Iterator_Previous(GWEN_MDIGEST_LIST2_ITERATOR *li); 
   
  GWEN_MDIGEST *GWEN_MDigest_List2Iterator_Next(GWEN_MDIGEST_LIST2_ITERATOR *li); 

  GWEN_MDIGEST *GWEN_MDigest_List2Iterator_Data(GWEN_MDIGEST_LIST2_ITERATOR *li); 

  GWEN_MDIGEST *GWEN_MDigest_List2_ForEach(GWEN_MDIGEST_LIST2 *list,
                                        GWEN_MDIGEST_LIST2_FOREACH func,
                                        void *user_data);


  typedef struct GWEN_MDIGEST_CONSTLIST2 GWEN_MDIGEST_CONSTLIST2; 
  typedef struct GWEN_MDIGEST_CONSTLIST2_ITERATOR GWEN_MDIGEST_CONSTLIST2_ITERATOR; 
  typedef const GWEN_MDIGEST*
    (GWEN_MDIGEST_CONSTLIST2_FOREACH)(const GWEN_MDIGEST *element,
                                    void *user_data);
  
   
  GWEN_MDIGEST_CONSTLIST2 *GWEN_MDigest_ConstList2_new(); 
   
  void GWEN_MDigest_ConstList2_free(GWEN_MDIGEST_CONSTLIST2 *l); 
   
  void GWEN_MDigest_ConstList2_PushBack(GWEN_MDIGEST_CONSTLIST2 *l, const GWEN_MDIGEST *p); 
   
  void GWEN_MDigest_ConstList2_PushFront(GWEN_MDIGEST_CONSTLIST2 *l, const GWEN_MDIGEST *p); 
   
  const GWEN_MDIGEST *GWEN_MDigest_ConstList2_GetFront(GWEN_MDIGEST_CONSTLIST2 *l); 
   
  const GWEN_MDIGEST *GWEN_MDigest_ConstList2_GetBack(GWEN_MDIGEST_CONSTLIST2 *l); 
   
  unsigned int GWEN_MDigest_ConstList2_GetSize(GWEN_MDIGEST_CONSTLIST2 *l); 
   
  void GWEN_MDigest_ConstList2_PopBack(GWEN_MDIGEST_CONSTLIST2 *l); 
   
  void GWEN_MDigest_ConstList2_PopFront(GWEN_MDIGEST_CONSTLIST2 *l); 
   
  void GWEN_MDigest_ConstList2_Clear(GWEN_MDIGEST_CONSTLIST2 *l); 
   
  GWEN_MDIGEST_CONSTLIST2_ITERATOR *GWEN_MDigest_ConstList2_First(GWEN_MDIGEST_CONSTLIST2 *l); 
   
  GWEN_MDIGEST_CONSTLIST2_ITERATOR *GWEN_MDigest_ConstList2_Last(GWEN_MDIGEST_CONSTLIST2 *l); 
   
  GWEN_MDIGEST_CONSTLIST2_ITERATOR *GWEN_MDigest_ConstList2Iterator_new(GWEN_MDIGEST_CONSTLIST2 *l); 
   
  void GWEN_MDigest_ConstList2Iterator_free(GWEN_MDIGEST_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_MDIGEST *GWEN_MDigest_ConstList2Iterator_Previous(GWEN_MDIGEST_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_MDIGEST *GWEN_MDigest_ConstList2Iterator_Next(GWEN_MDIGEST_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_MDIGEST *GWEN_MDigest_ConstList2Iterator_Data(GWEN_MDIGEST_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_MDIGEST *GWEN_MDigest_ConstList2_ForEach(GWEN_MDIGEST_CONSTLIST2 *list,
        GWEN_MDIGEST_CONSTLIST2_FOREACH func, void *user_data);


#ifdef __cplusplus
}
#endif


#endif /* GWEN_MDIGEST_LIST_H */



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_MDIGEST_LIST1_H
#define GWEN_MDIGEST_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_MDIGEST_LIST_ELEMENT {
    uint32_t id;
    GWEN_MDIGEST *nextObject;
  } GWEN_MDIGEST_LIST__ELEMENT;

  typedef struct GWEN_MDIGEST_LIST GWEN_MDIGEST_LIST;

  typedef int GWENHYWFAR_CB (*GWEN_MDIGEST_LIST_SORT_FN)(const GWEN_MDIGEST *a, const GWEN_MDIGEST *b, int ascending);


  struct GWEN_MDIGEST_LIST {
    GWEN_MDIGEST *first;
    uint32_t count;
    uint32_t id;
  } GWEN_MDIGEST_LIST;

  void GWEN_MDigest_List_AddList(GWEN_MDIGEST_LIST *dst, GWEN_MDIGEST_LIST *l);

  void GWEN_MDigest_List_Add(GWEN_MDIGEST *element, GWEN_MDIGEST_LIST *list);

  void GWEN_MDigest_List_Insert(GWEN_MDIGEST *element, GWEN_MDIGEST_LIST *list);

  void GWEN_MDigest_List_Del(GWEN_MDIGEST *element);

  GWEN_MDIGEST* GWEN_MDigest_List_First(const GWEN_MDIGEST_LIST *l);

  GWEN_MDIGEST* GWEN_MDigest_List_Last(const GWEN_MDIGEST_LIST *l);

  void GWEN_MDigest_List_Clear(GWEN_MDIGEST_LIST *l);

  GWEN_MDIGEST_LIST* GWEN_MDigest_List_new();

  void GWEN_MDigest_List_free(GWEN_MDIGEST_LIST *l);

  GWEN_MDIGEST* GWEN_MDigest_List_Next(const GWEN_MDIGEST *element);

  GWEN_MDIGEST* GWEN_MDigest_List_Previous(const GWEN_MDIGEST *element);

  uint32_t GWEN_MDigest_List_GetCount(const GWEN_MDIGEST_LIST *l);

  GWEN_MDIGEST_LIST_SORT_FN GWEN_MDigest_List_SetSortFn(GWEN_MDIGEST_LIST *l, GWEN_MDIGEST_LIST_SORT_FN fn);

  void GWEN_MDigest_List_Sort(GWEN_MDIGEST_LIST *l, int ascending);


#ifdef __cplusplus
}
#endif


#endif



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_CRYPT_PADDALGO_LIST2_H
#define GWEN_CRYPT_PADDALGO_LIST2_H


#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_CRYPT_PADDALGO_LIST2 GWEN_CRYPT_PADDALGO_LIST2;

  typedef struct GWEN_CRYPT_PADDALGO_LIST2_ITERATOR GWEN_CRYPT_PADDALGO_LIST2_ITERATOR;

  typedef GWEN_CRYPT_PADDALGO* (GWEN_CRYPT_PADDALGO_LIST2_FOREACH)(GWEN_CRYPT_PADDALGO *element,
                                                 void *user_data);

  GWEN_CRYPT_PADDALGO_LIST2 *GWEN_Crypt_PaddAlgo_List2_new(); 

  void GWEN_Crypt_PaddAlgo_List2_free(GWEN_CRYPT_PADDALGO_LIST2 *l); 

  void GWEN_Crypt_PaddAlgo_List2_Dump(GWEN_CRYPT_PADDALGO_LIST2 *l, FILE *f, unsigned int indent); 

  void GWEN_Crypt_PaddAlgo_List2_PushBack(GWEN_CRYPT_PADDALGO_LIST2 *l, GWEN_CRYPT_PADDALGO *p); 
   
  void GWEN_Crypt_PaddAlgo_List2_PushFront(GWEN_CRYPT_PADDALGO_LIST2 *l, GWEN_CRYPT_PADDALGO *p); 

  GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_List2_GetFront(GWEN_CRYPT_PADDALGO_LIST2 *l); 
   
  GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_List2_GetBack(GWEN_CRYPT_PADDALGO_LIST2 *l); 

  void GWEN_Crypt_PaddAlgo_List2_Erase(GWEN_CRYPT_PADDALGO_LIST2 *l,
                               GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *it);

  unsigned int GWEN_Crypt_PaddAlgo_List2_GetSize(GWEN_CRYPT_PADDALGO_LIST2 *l); 

  void GWEN_Crypt_PaddAlgo_List2_PopBack(GWEN_CRYPT_PADDALGO_LIST2 *l); 
   
  void GWEN_Crypt_PaddAlgo_List2_PopFront(GWEN_CRYPT_PADDALGO_LIST2 *l); 

  void GWEN_Crypt_PaddAlgo_List2_Clear(GWEN_CRYPT_PADDALGO_LIST2 *l); 

  GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *GWEN_Crypt_PaddAlgo_List2_First(GWEN_CRYPT_PADDALGO_LIST2 *l); 
   
  GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *GWEN_Crypt_PaddAlgo_List2_Last(GWEN_CRYPT_PADDALGO_LIST2 *l); 

  GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *GWEN_Crypt_PaddAlgo_List2Iterator_new(GWEN_CRYPT_PADDALGO_LIST2 *l);

  void GWEN_Crypt_PaddAlgo_List2Iterator_free(GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *li); 

  GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_List2Iterator_Previous(GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *li); 
   
  GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_List2Iterator_Next(GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *li); 

  GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_List2Iterator_Data(GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *li); 

  GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_List2_ForEach(GWEN_CRYPT_PADDALGO_LIST2 *list,
                                        GWEN_CRYPT_PADDALGO_LIST2_FOREACH func,
                                        void *user_data);


  typedef struct GWEN_CRYPT_PADDALGO_CONSTLIST2 GWEN_CRYPT_PADDALGO_CONSTLIST2; 
  typedef struct GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR; 
  typedef const GWEN_CRYPT_PADDALGO*
    (GWEN_CRYPT_PADDALGO_CONSTLIST2_FOREACH)(const GWEN_CRYPT_PADDALGO *element,
                                    void *user_data);
  
   
  GWEN_CRYPT_PADDALGO_CONSTLIST2 *GWEN_Crypt_PaddAlgo_ConstList2_new(); 
   
  void GWEN_Crypt_PaddAlgo_ConstList2_free(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l); 
   
  void GWEN_Crypt_PaddAlgo_ConstList2_PushBack(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l, const GWEN_CRYPT_PADDALGO *p); 
   
  void GWEN_Crypt_PaddAlgo_ConstList2_PushFront(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l, const GWEN_CRYPT_PADDALGO *p); 
   
  const GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_ConstList2_GetFront(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l); 
   
  const GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_ConstList2_GetBack(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l); 
   
  unsigned int GWEN_Crypt_PaddAlgo_ConstList2_GetSize(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l); 
   
  void GWEN_Crypt_PaddAlgo_ConstList2_PopBack(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l); 
   
  void GWEN_Crypt_PaddAlgo_ConstList2_PopFront(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l); 
   
  void GWEN_Crypt_PaddAlgo_ConstList2_Clear(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l); 
   
  GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_PaddAlgo_ConstList2_First(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l); 
   
  GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_PaddAlgo_ConstList2_Last(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l); 
   
  GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_PaddAlgo_ConstList2Iterator_new(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l); 
   
  void GWEN_Crypt_PaddAlgo_ConstList2Iterator_free(GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_ConstList2Iterator_Previous(GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_ConstList2Iterator_Next(GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_ConstList2Iterator_Data(GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_ConstList2_ForEach(GWEN_CRYPT_PADDALGO_CONSTLIST2 *list,
        GWEN_CRYPT_PADDALGO_CONSTLIST2_FOREACH func, void *user_data);


#ifdef __cplusplus
}
#endif


#endif /* GWEN_CRYPT_PADDALGO_LIST_H */



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_CRYPTHEAD_LIST1_H
#define GWEN_CRYPTHEAD_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_CRYPTHEAD_LIST_ELEMENT {
    uint32_t id;
    GWEN_CRYPTHEAD *nextObject;
  } GWEN_CRYPTHEAD_LIST__ELEMENT;

  typedef struct GWEN_CRYPTHEAD_LIST GWEN_CRYPTHEAD_LIST;

  typedef int GWENHYWFAR_CB (*GWEN_CRYPTHEAD_LIST_SORT_FN)(const GWEN_CRYPTHEAD *a, const GWEN_CRYPTHEAD *b, int ascending);


  struct GWEN_CRYPTHEAD_LIST {
    GWEN_CRYPTHEAD *first;
    uint32_t count;
    uint32_t id;
  } GWEN_CRYPTHEAD_LIST;

  void GWEN_CryptHead_List_AddList(GWEN_CRYPTHEAD_LIST *dst, GWEN_CRYPTHEAD_LIST *l);

  void GWEN_CryptHead_List_Add(GWEN_CRYPTHEAD *element, GWEN_CRYPTHEAD_LIST *list);

  void GWEN_CryptHead_List_Insert(GWEN_CRYPTHEAD *element, GWEN_CRYPTHEAD_LIST *list);

  void GWEN_CryptHead_List_Del(GWEN_CRYPTHEAD *element);

  GWEN_CRYPTHEAD* GWEN_CryptHead_List_First(const GWEN_CRYPTHEAD_LIST *l);

  GWEN_CRYPTHEAD* GWEN_CryptHead_List_Last(const GWEN_CRYPTHEAD_LIST *l);

  void GWEN_CryptHead_List_Clear(GWEN_CRYPTHEAD_LIST *l);

  GWEN_CRYPTHEAD_LIST* GWEN_CryptHead_List_new();

  void GWEN_CryptHead_List_free(GWEN_CRYPTHEAD_LIST *l);

  GWEN_CRYPTHEAD* GWEN_CryptHead_List_Next(const GWEN_CRYPTHEAD *element);

  GWEN_CRYPTHEAD* GWEN_CryptHead_List_Previous(const GWEN_CRYPTHEAD *element);

  uint32_t GWEN_CryptHead_List_GetCount(const GWEN_CRYPTHEAD_LIST *l);

  GWEN_CRYPTHEAD_LIST_SORT_FN GWEN_CryptHead_List_SetSortFn(GWEN_CRYPTHEAD_LIST *l, GWEN_CRYPTHEAD_LIST_SORT_FN fn);

  void GWEN_CryptHead_List_Sort(GWEN_CRYPTHEAD_LIST *l, int ascending);


#ifdef __cplusplus
}
#endif


#endif



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_SIGHEAD_LIST1_H
#define GWEN_SIGHEAD_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_SIGHEAD_LIST_ELEMENT {
    uint32_t id;
    GWEN_SIGHEAD *nextObject;
  } GWEN_SIGHEAD_LIST__ELEMENT;

  typedef struct GWEN_SIGHEAD_LIST GWEN_SIGHEAD_LIST;

  typedef int GWENHYWFAR_CB (*GWEN_SIGHEAD_LIST_SORT_FN)(const GWEN_SIGHEAD *a, const GWEN_SIGHEAD *b, int ascending);


  struct GWEN_SIGHEAD_LIST {
    GWEN_SIGHEAD *first;
    uint32_t count;
    uint32_t id;
  } GWEN_SIGHEAD_LIST;

  void GWEN_SigHead_List_AddList(GWEN_SIGHEAD_LIST *dst, GWEN_SIGHEAD_LIST *l);

  void GWEN_SigHead_List_Add(GWEN_SIGHEAD *element, GWEN_SIGHEAD_LIST *list);

  void GWEN_SigHead_List_Insert(GWEN_SIGHEAD *element, GWEN_SIGHEAD_LIST *list);

  void GWEN_SigHead_List_Del(GWEN_SIGHEAD *element);

  GWEN_SIGHEAD* GWEN_SigHead_List_First(const GWEN_SIGHEAD_LIST *l);

  GWEN_SIGHEAD* GWEN_SigHead_List_Last(const GWEN_SIGHEAD_LIST *l);

  void GWEN_SigHead_List_Clear(GWEN_SIGHEAD_LIST *l);

  GWEN_SIGHEAD_LIST* GWEN_SigHead_List_new();

  void GWEN_SigHead_List_free(GWEN_SIGHEAD_LIST *l);

  GWEN_SIGHEAD* GWEN_SigHead_List_Next(const GWEN_SIGHEAD *element);

  GWEN_SIGHEAD* GWEN_SigHead_List_Previous(const GWEN_SIGHEAD *element);

  uint32_t GWEN_SigHead_List_GetCount(const GWEN_SIGHEAD_LIST *l);

  GWEN_SIGHEAD_LIST_SORT_FN GWEN_SigHead_List_SetSortFn(GWEN_SIGHEAD_LIST *l, GWEN_SIGHEAD_LIST_SORT_FN fn);

  void GWEN_SigHead_List_Sort(GWEN_SIGHEAD_LIST *l, int ascending);


#ifdef __cplusplus
}
#endif


#endif



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_SIGTAIL_LIST1_H
#define GWEN_SIGTAIL_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_SIGTAIL_LIST_ELEMENT {
    uint32_t id;
    GWEN_SIGTAIL *nextObject;
  } GWEN_SIGTAIL_LIST__ELEMENT;

  typedef struct GWEN_SIGTAIL_LIST GWEN_SIGTAIL_LIST;

  typedef int GWENHYWFAR_CB (*GWEN_SIGTAIL_LIST_SORT_FN)(const GWEN_SIGTAIL *a, const GWEN_SIGTAIL *b, int ascending);


  struct GWEN_SIGTAIL_LIST {
    GWEN_SIGTAIL *first;
    uint32_t count;
    uint32_t id;
  } GWEN_SIGTAIL_LIST;

  void GWEN_SigTail_List_AddList(GWEN_SIGTAIL_LIST *dst, GWEN_SIGTAIL_LIST *l);

  void GWEN_SigTail_List_Add(GWEN_SIGTAIL *element, GWEN_SIGTAIL_LIST *list);

  void GWEN_SigTail_List_Insert(GWEN_SIGTAIL *element, GWEN_SIGTAIL_LIST *list);

  void GWEN_SigTail_List_Del(GWEN_SIGTAIL *element);

  GWEN_SIGTAIL* GWEN_SigTail_List_First(const GWEN_SIGTAIL_LIST *l);

  GWEN_SIGTAIL* GWEN_SigTail_List_Last(const GWEN_SIGTAIL_LIST *l);

  void GWEN_SigTail_List_Clear(GWEN_SIGTAIL_LIST *l);

  GWEN_SIGTAIL_LIST* GWEN_SigTail_List_new();

  void GWEN_SigTail_List_free(GWEN_SIGTAIL_LIST *l);

  GWEN_SIGTAIL* GWEN_SigTail_List_Next(const GWEN_SIGTAIL *element);

  GWEN_SIGTAIL* GWEN_SigTail_List_Previous(const GWEN_SIGTAIL *element);

  uint32_t GWEN_SigTail_List_GetCount(const GWEN_SIGTAIL_LIST *l);

  GWEN_SIGTAIL_LIST_SORT_FN GWEN_SigTail_List_SetSortFn(GWEN_SIGTAIL_LIST *l, GWEN_SIGTAIL_LIST_SORT_FN fn);

  void GWEN_SigTail_List_Sort(GWEN_SIGTAIL_LIST *l, int ascending);


#ifdef __cplusplus
}
#endif


#endif



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_CRYPT_TOKEN_LIST2_H
#define GWEN_CRYPT_TOKEN_LIST2_H


#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_CRYPT_TOKEN_LIST2 GWEN_CRYPT_TOKEN_LIST2;

  typedef struct GWEN_CRYPT_TOKEN_LIST2_ITERATOR GWEN_CRYPT_TOKEN_LIST2_ITERATOR;

  typedef GWEN_CRYPT_TOKEN* (GWEN_CRYPT_TOKEN_LIST2_FOREACH)(GWEN_CRYPT_TOKEN *element,
                                                 void *user_data);

  GWEN_CRYPT_TOKEN_LIST2 *GWEN_Crypt_Token_List2_new(); 

  void GWEN_Crypt_Token_List2_free(GWEN_CRYPT_TOKEN_LIST2 *l); 

  void GWEN_Crypt_Token_List2_Dump(GWEN_CRYPT_TOKEN_LIST2 *l, FILE *f, unsigned int indent); 

  void GWEN_Crypt_Token_List2_PushBack(GWEN_CRYPT_TOKEN_LIST2 *l, GWEN_CRYPT_TOKEN *p); 
   
  void GWEN_Crypt_Token_List2_PushFront(GWEN_CRYPT_TOKEN_LIST2 *l, GWEN_CRYPT_TOKEN *p); 

  GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_List2_GetFront(GWEN_CRYPT_TOKEN_LIST2 *l); 
   
  GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_List2_GetBack(GWEN_CRYPT_TOKEN_LIST2 *l); 

  void GWEN_Crypt_Token_List2_Erase(GWEN_CRYPT_TOKEN_LIST2 *l,
                               GWEN_CRYPT_TOKEN_LIST2_ITERATOR *it);

  unsigned int GWEN_Crypt_Token_List2_GetSize(GWEN_CRYPT_TOKEN_LIST2 *l); 

  void GWEN_Crypt_Token_List2_PopBack(GWEN_CRYPT_TOKEN_LIST2 *l); 
   
  void GWEN_Crypt_Token_List2_PopFront(GWEN_CRYPT_TOKEN_LIST2 *l); 

  void GWEN_Crypt_Token_List2_Clear(GWEN_CRYPT_TOKEN_LIST2 *l); 

  GWEN_CRYPT_TOKEN_LIST2_ITERATOR *GWEN_Crypt_Token_List2_First(GWEN_CRYPT_TOKEN_LIST2 *l); 
   
  GWEN_CRYPT_TOKEN_LIST2_ITERATOR *GWEN_Crypt_Token_List2_Last(GWEN_CRYPT_TOKEN_LIST2 *l); 

  GWEN_CRYPT_TOKEN_LIST2_ITERATOR *GWEN_Crypt_Token_List2Iterator_new(GWEN_CRYPT_TOKEN_LIST2 *l);

  void GWEN_Crypt_Token_List2Iterator_free(GWEN_CRYPT_TOKEN_LIST2_ITERATOR *li); 

  GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_List2Iterator_Previous(GWEN_CRYPT_TOKEN_LIST2_ITERATOR *li); 
   
  GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_List2Iterator_Next(GWEN_CRYPT_TOKEN_LIST2_ITERATOR *li); 

  GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_List2Iterator_Data(GWEN_CRYPT_TOKEN_LIST2_ITERATOR *li); 

  GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_List2_ForEach(GWEN_CRYPT_TOKEN_LIST2 *list,
                                        GWEN_CRYPT_TOKEN_LIST2_FOREACH func,
                                        void *user_data);


  typedef struct GWEN_CRYPT_TOKEN_CONSTLIST2 GWEN_CRYPT_TOKEN_CONSTLIST2; 
  typedef struct GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR; 
  typedef const GWEN_CRYPT_TOKEN*
    (GWEN_CRYPT_TOKEN_CONSTLIST2_FOREACH)(const GWEN_CRYPT_TOKEN *element,
                                    void *user_data);
  
   
  GWEN_CRYPT_TOKEN_CONSTLIST2 *GWEN_Crypt_Token_ConstList2_new(); 
   
  void GWEN_Crypt_Token_ConstList2_free(GWEN_CRYPT_TOKEN_CONSTLIST2 *l); 
   
  void GWEN_Crypt_Token_ConstList2_PushBack(GWEN_CRYPT_TOKEN_CONSTLIST2 *l, const GWEN_CRYPT_TOKEN *p); 
   
  void GWEN_Crypt_Token_ConstList2_PushFront(GWEN_CRYPT_TOKEN_CONSTLIST2 *l, const GWEN_CRYPT_TOKEN *p); 
   
  const GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_ConstList2_GetFront(GWEN_CRYPT_TOKEN_CONSTLIST2 *l); 
   
  const GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_ConstList2_GetBack(GWEN_CRYPT_TOKEN_CONSTLIST2 *l); 
   
  unsigned int GWEN_Crypt_Token_ConstList2_GetSize(GWEN_CRYPT_TOKEN_CONSTLIST2 *l); 
   
  void GWEN_Crypt_Token_ConstList2_PopBack(GWEN_CRYPT_TOKEN_CONSTLIST2 *l); 
   
  void GWEN_Crypt_Token_ConstList2_PopFront(GWEN_CRYPT_TOKEN_CONSTLIST2 *l); 
   
  void GWEN_Crypt_Token_ConstList2_Clear(GWEN_CRYPT_TOKEN_CONSTLIST2 *l); 
   
  GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_ConstList2_First(GWEN_CRYPT_TOKEN_CONSTLIST2 *l); 
   
  GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_ConstList2_Last(GWEN_CRYPT_TOKEN_CONSTLIST2 *l); 
   
  GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_ConstList2Iterator_new(GWEN_CRYPT_TOKEN_CONSTLIST2 *l); 
   
  void GWEN_Crypt_Token_ConstList2Iterator_free(GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_ConstList2Iterator_Previous(GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_ConstList2Iterator_Next(GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_ConstList2Iterator_Data(GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_ConstList2_ForEach(GWEN_CRYPT_TOKEN_CONSTLIST2 *list,
        GWEN_CRYPT_TOKEN_CONSTLIST2_FOREACH func, void *user_data);


#ifdef __cplusplus
}
#endif


#endif /* GWEN_CRYPT_TOKEN_LIST_H */



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_CRYPT_TOKEN_LIST1_H
#define GWEN_CRYPT_TOKEN_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_CRYPT_TOKEN_LIST_ELEMENT {
    uint32_t id;
    GWEN_CRYPT_TOKEN *nextObject;
  } GWEN_CRYPT_TOKEN_LIST__ELEMENT;

  typedef struct GWEN_CRYPT_TOKEN_LIST GWEN_CRYPT_TOKEN_LIST;

  typedef int GWENHYWFAR_CB (*GWEN_CRYPT_TOKEN_LIST_SORT_FN)(const GWEN_CRYPT_TOKEN *a, const GWEN_CRYPT_TOKEN *b, int ascending);


  struct GWEN_CRYPT_TOKEN_LIST {
    GWEN_CRYPT_TOKEN *first;
    uint32_t count;
    uint32_t id;
  } GWEN_CRYPT_TOKEN_LIST;

  void GWEN_Crypt_Token_List_AddList(GWEN_CRYPT_TOKEN_LIST *dst, GWEN_CRYPT_TOKEN_LIST *l);

  void GWEN_Crypt_Token_List_Add(GWEN_CRYPT_TOKEN *element, GWEN_CRYPT_TOKEN_LIST *list);

  void GWEN_Crypt_Token_List_Insert(GWEN_CRYPT_TOKEN *element, GWEN_CRYPT_TOKEN_LIST *list);

  void GWEN_Crypt_Token_List_Del(GWEN_CRYPT_TOKEN *element);

  GWEN_CRYPT_TOKEN* GWEN_Crypt_Token_List_First(const GWEN_CRYPT_TOKEN_LIST *l);

  GWEN_CRYPT_TOKEN* GWEN_Crypt_Token_List_Last(const GWEN_CRYPT_TOKEN_LIST *l);

  void GWEN_Crypt_Token_List_Clear(GWEN_CRYPT_TOKEN_LIST *l);

  GWEN_CRYPT_TOKEN_LIST* GWEN_Crypt_Token_List_new();

  void GWEN_Crypt_Token_List_free(GWEN_CRYPT_TOKEN_LIST *l);

  GWEN_CRYPT_TOKEN* GWEN_Crypt_Token_List_Next(const GWEN_CRYPT_TOKEN *element);

  GWEN_CRYPT_TOKEN* GWEN_Crypt_Token_List_Previous(const GWEN_CRYPT_TOKEN *element);

  uint32_t GWEN_Crypt_Token_List_GetCount(const GWEN_CRYPT_TOKEN_LIST *l);

  GWEN_CRYPT_TOKEN_LIST_SORT_FN GWEN_Crypt_Token_List_SetSortFn(GWEN_CRYPT_TOKEN_LIST *l, GWEN_CRYPT_TOKEN_LIST_SORT_FN fn);

  void GWEN_Crypt_Token_List_Sort(GWEN_CRYPT_TOKEN_LIST *l, int ascending);


#ifdef __cplusplus
}
#endif


#endif



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_CRYPT_TOKEN_CONTEXT_LIST2_H
#define GWEN_CRYPT_TOKEN_CONTEXT_LIST2_H


#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_CRYPT_TOKEN_CONTEXT_LIST2 GWEN_CRYPT_TOKEN_CONTEXT_LIST2;

  typedef struct GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR;

  typedef GWEN_CRYPT_TOKEN_CONTEXT* (GWEN_CRYPT_TOKEN_CONTEXT_LIST2_FOREACH)(GWEN_CRYPT_TOKEN_CONTEXT *element,
                                                 void *user_data);

  GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *GWEN_Crypt_Token_Context_List2_new(); 

  void GWEN_Crypt_Token_Context_List2_free(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l); 

  void GWEN_Crypt_Token_Context_List2_Dump(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l, FILE *f, unsigned int indent); 

  void GWEN_Crypt_Token_Context_List2_PushBack(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l, GWEN_CRYPT_TOKEN_CONTEXT *p); 
   
  void GWEN_Crypt_Token_Context_List2_PushFront(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l, GWEN_CRYPT_TOKEN_CONTEXT *p); 

  GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_List2_GetFront(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l); 
   
  GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_List2_GetBack(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l); 

  void GWEN_Crypt_Token_Context_List2_Erase(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l,
                               GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *it);

  unsigned int GWEN_Crypt_Token_Context_List2_GetSize(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l); 

  void GWEN_Crypt_Token_Context_List2_PopBack(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l); 
   
  void GWEN_Crypt_Token_Context_List2_PopFront(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l); 

  void GWEN_Crypt_Token_Context_List2_Clear(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l); 

  GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *GWEN_Crypt_Token_Context_List2_First(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l); 
   
  GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *GWEN_Crypt_Token_Context_List2_Last(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l); 

  GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *GWEN_Crypt_Token_Context_List2Iterator_new(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l);

  void GWEN_Crypt_Token_Context_List2Iterator_free(GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *li); 

  GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_List2Iterator_Previous(GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *li); 
   
  GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_List2Iterator_Next(GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *li); 

  GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_List2Iterator_Data(GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *li); 

  GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_List2_ForEach(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *list,
                                        GWEN_CRYPT_TOKEN_CONTEXT_LIST2_FOREACH func,
                                        void *user_data);


  typedef struct GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2; 
  typedef struct GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR; 
  typedef const GWEN_CRYPT_TOKEN_CONTEXT*
    (GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_FOREACH)(const GWEN_CRYPT_TOKEN_CONTEXT *element,
                                    void *user_data);
  
   
  GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *GWEN_Crypt_Token_Context_ConstList2_new(); 
   
  void GWEN_Crypt_Token_Context_ConstList2_free(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l); 
   
  void GWEN_Crypt_Token_Context_ConstList2_PushBack(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l, const GWEN_CRYPT_TOKEN_CONTEXT *p); 
   
  void GWEN_Crypt_Token_Context_ConstList2_PushFront(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l, const GWEN_CRYPT_TOKEN_CONTEXT *p); 
   
  const GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_ConstList2_GetFront(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l); 
   
  const GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_ConstList2_GetBack(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l); 
   
  unsigned int GWEN_Crypt_Token_Context_ConstList2_GetSize(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l); 
   
  void GWEN_Crypt_Token_Context_ConstList2_PopBack(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l); 
   
  void GWEN_Crypt_Token_Context_ConstList2_PopFront(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l); 
   
  void GWEN_Crypt_Token_Context_ConstList2_Clear(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l); 
   
  GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_Context_ConstList2_First(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l); 
   
  GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_Context_ConstList2_Last(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l); 
   
  GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_Context_ConstList2Iterator_new(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l); 
   
  void GWEN_Crypt_Token_Context_ConstList2Iterator_free(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_ConstList2Iterator_Previous(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_ConstList2Iterator_Next(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_ConstList2Iterator_Data(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_ConstList2_ForEach(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *list,
        GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_FOREACH func, void *user_data);


#ifdef __cplusplus
}
#endif


#endif /* GWEN_CRYPT_TOKEN_CONTEXT_LIST_H */



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_CRYPT_TOKEN_CONTEXT_LIST1_H
#define GWEN_CRYPT_TOKEN_CONTEXT_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_CRYPT_TOKEN_CONTEXT_LIST_ELEMENT {
    uint32_t id;
    GWEN_CRYPT_TOKEN_CONTEXT *nextObject;
  } GWEN_CRYPT_TOKEN_CONTEXT_LIST__ELEMENT;

  typedef struct GWEN_CRYPT_TOKEN_CONTEXT_LIST GWEN_CRYPT_TOKEN_CONTEXT_LIST;

  typedef int GWENHYWFAR_CB (*GWEN_CRYPT_TOKEN_CONTEXT_LIST_SORT_FN)(const GWEN_CRYPT_TOKEN_CONTEXT *a, const GWEN_CRYPT_TOKEN_CONTEXT *b, int ascending);


  struct GWEN_CRYPT_TOKEN_CONTEXT_LIST {
    GWEN_CRYPT_TOKEN_CONTEXT *first;
    uint32_t count;
    uint32_t id;
  } GWEN_CRYPT_TOKEN_CONTEXT_LIST;

  void GWEN_Crypt_Token_Context_List_AddList(GWEN_CRYPT_TOKEN_CONTEXT_LIST *dst, GWEN_CRYPT_TOKEN_CONTEXT_LIST *l);

  void GWEN_Crypt_Token_Context_List_Add(GWEN_CRYPT_TOKEN_CONTEXT *element, GWEN_CRYPT_TOKEN_CONTEXT_LIST *list);

  void GWEN_Crypt_Token_Context_List_Insert(GWEN_CRYPT_TOKEN_CONTEXT *element, GWEN_CRYPT_TOKEN_CONTEXT_LIST *list);

  void GWEN_Crypt_Token_Context_List_Del(GWEN_CRYPT_TOKEN_CONTEXT *element);

  GWEN_CRYPT_TOKEN_CONTEXT* GWEN_Crypt_Token_Context_List_First(const GWEN_CRYPT_TOKEN_CONTEXT_LIST *l);

  GWEN_CRYPT_TOKEN_CONTEXT* GWEN_Crypt_Token_Context_List_Last(const GWEN_CRYPT_TOKEN_CONTEXT_LIST *l);

  void GWEN_Crypt_Token_Context_List_Clear(GWEN_CRYPT_TOKEN_CONTEXT_LIST *l);

  GWEN_CRYPT_TOKEN_CONTEXT_LIST* GWEN_Crypt_Token_Context_List_new();

  void GWEN_Crypt_Token_Context_List_free(GWEN_CRYPT_TOKEN_CONTEXT_LIST *l);

  GWEN_CRYPT_TOKEN_CONTEXT* GWEN_Crypt_Token_Context_List_Next(const GWEN_CRYPT_TOKEN_CONTEXT *element);

  GWEN_CRYPT_TOKEN_CONTEXT* GWEN_Crypt_Token_Context_List_Previous(const GWEN_CRYPT_TOKEN_CONTEXT *element);

  uint32_t GWEN_Crypt_Token_Context_List_GetCount(const GWEN_CRYPT_TOKEN_CONTEXT_LIST *l);

  GWEN_CRYPT_TOKEN_CONTEXT_LIST_SORT_FN GWEN_Crypt_Token_Context_List_SetSortFn(GWEN_CRYPT_TOKEN_CONTEXT_LIST *l, GWEN_CRYPT_TOKEN_CONTEXT_LIST_SORT_FN fn);

  void GWEN_Crypt_Token_Context_List_Sort(GWEN_CRYPT_TOKEN_CONTEXT_LIST *l, int ascending);


#ifdef __cplusplus
}
#endif


#endif



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_CRYPT_TOKEN_KEYINFO_LIST2_H
#define GWEN_CRYPT_TOKEN_KEYINFO_LIST2_H


#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_CRYPT_TOKEN_KEYINFO_LIST2 GWEN_CRYPT_TOKEN_KEYINFO_LIST2;

  typedef struct GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR;

  typedef GWEN_CRYPT_TOKEN_KEYINFO* (GWEN_CRYPT_TOKEN_KEYINFO_LIST2_FOREACH)(GWEN_CRYPT_TOKEN_KEYINFO *element,
                                                 void *user_data);

  GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *GWEN_Crypt_Token_KeyInfo_List2_new(); 

  void GWEN_Crypt_Token_KeyInfo_List2_free(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l); 

  void GWEN_Crypt_Token_KeyInfo_List2_Dump(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l, FILE *f, unsigned int indent); 

  void GWEN_Crypt_Token_KeyInfo_List2_PushBack(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l, GWEN_CRYPT_TOKEN_KEYINFO *p); 
   
  void GWEN_Crypt_Token_KeyInfo_List2_PushFront(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l, GWEN_CRYPT_TOKEN_KEYINFO *p); 

  GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_List2_GetFront(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l); 
   
  GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_List2_GetBack(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l); 

  void GWEN_Crypt_Token_KeyInfo_List2_Erase(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l,
                               GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *it);

  unsigned int GWEN_Crypt_Token_KeyInfo_List2_GetSize(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l); 

  void GWEN_Crypt_Token_KeyInfo_List2_PopBack(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l); 
   
  void GWEN_Crypt_Token_KeyInfo_List2_PopFront(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l); 

  void GWEN_Crypt_Token_KeyInfo_List2_Clear(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l); 

  GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *GWEN_Crypt_Token_KeyInfo_List2_First(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l); 
   
  GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *GWEN_Crypt_Token_KeyInfo_List2_Last(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l); 

  GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *GWEN_Crypt_Token_KeyInfo_List2Iterator_new(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l);

  void GWEN_Crypt_Token_KeyInfo_List2Iterator_free(GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *li); 

  GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_List2Iterator_Previous(GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *li); 
   
  GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_List2Iterator_Next(GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *li); 

  GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_List2Iterator_Data(GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *li); 

  GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_List2_ForEach(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *list,
                                        GWEN_CRYPT_TOKEN_KEYINFO_LIST2_FOREACH func,
                                        void *user_data);


  typedef struct GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2; 
  typedef struct GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR; 
  typedef const GWEN_CRYPT_TOKEN_KEYINFO*
    (GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_FOREACH)(const GWEN_CRYPT_TOKEN_KEYINFO *element,
                                    void *user_data);
  
   
  GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *GWEN_Crypt_Token_KeyInfo_ConstList2_new(); 
   
  void GWEN_Crypt_Token_KeyInfo_ConstList2_free(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l); 
   
  void GWEN_Crypt_Token_KeyInfo_ConstList2_PushBack(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l, const GWEN_CRYPT_TOKEN_KEYINFO *p); 
   
  void GWEN_Crypt_Token_KeyInfo_ConstList2_PushFront(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l, const GWEN_CRYPT_TOKEN_KEYINFO *p); 
   
  const GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_ConstList2_GetFront(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l); 
   
  const GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_ConstList2_GetBack(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l); 
   
  unsigned int GWEN_Crypt_Token_KeyInfo_ConstList2_GetSize(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l); 
   
  void GWEN_Crypt_Token_KeyInfo_ConstList2_PopBack(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l); 
   
  void GWEN_Crypt_Token_KeyInfo_ConstList2_PopFront(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l); 
   
  void GWEN_Crypt_Token_KeyInfo_ConstList2_Clear(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l); 
   
  GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_KeyInfo_ConstList2_First(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l); 
   
  GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_KeyInfo_ConstList2_Last(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l); 
   
  GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_KeyInfo_ConstList2Iterator_new(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l); 
   
  void GWEN_Crypt_Token_KeyInfo_ConstList2Iterator_free(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_ConstList2Iterator_Previous(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_ConstList2Iterator_Next(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_ConstList2Iterator_Data(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_ConstList2_ForEach(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *list,
        GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_FOREACH func, void *user_data);


#ifdef __cplusplus
}
#endif


#endif /* GWEN_CRYPT_TOKEN_KEYINFO_LIST_H */



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_CRYPT_TOKEN_KEYINFO_LIST1_H
#define GWEN_CRYPT_TOKEN_KEYINFO_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_CRYPT_TOKEN_KEYINFO_LIST_ELEMENT {
    uint32_t id;
    GWEN_CRYPT_TOKEN_KEYINFO *nextObject;
  } GWEN_CRYPT_TOKEN_KEYINFO_LIST__ELEMENT;

  typedef struct GWEN_CRYPT_TOKEN_KEYINFO_LIST GWEN_CRYPT_TOKEN_KEYINFO_LIST;

  typedef int GWENHYWFAR_CB (*GWEN_CRYPT_TOKEN_KEYINFO_LIST_SORT_FN)(const GWEN_CRYPT_TOKEN_KEYINFO *a, const GWEN_CRYPT_TOKEN_KEYINFO *b, int ascending);


  struct GWEN_CRYPT_TOKEN_KEYINFO_LIST {
    GWEN_CRYPT_TOKEN_KEYINFO *first;
    uint32_t count;
    uint32_t id;
  } GWEN_CRYPT_TOKEN_KEYINFO_LIST;

  void GWEN_Crypt_Token_KeyInfo_List_AddList(GWEN_CRYPT_TOKEN_KEYINFO_LIST *dst, GWEN_CRYPT_TOKEN_KEYINFO_LIST *l);

  void GWEN_Crypt_Token_KeyInfo_List_Add(GWEN_CRYPT_TOKEN_KEYINFO *element, GWEN_CRYPT_TOKEN_KEYINFO_LIST *list);

  void GWEN_Crypt_Token_KeyInfo_List_Insert(GWEN_CRYPT_TOKEN_KEYINFO *element, GWEN_CRYPT_TOKEN_KEYINFO_LIST *list);

  void GWEN_Crypt_Token_KeyInfo_List_Del(GWEN_CRYPT_TOKEN_KEYINFO *element);

  GWEN_CRYPT_TOKEN_KEYINFO* GWEN_Crypt_Token_KeyInfo_List_First(const GWEN_CRYPT_TOKEN_KEYINFO_LIST *l);

  GWEN_CRYPT_TOKEN_KEYINFO* GWEN_Crypt_Token_KeyInfo_List_Last(const GWEN_CRYPT_TOKEN_KEYINFO_LIST *l);

  void GWEN_Crypt_Token_KeyInfo_List_Clear(GWEN_CRYPT_TOKEN_KEYINFO_LIST *l);

  GWEN_CRYPT_TOKEN_KEYINFO_LIST* GWEN_Crypt_Token_KeyInfo_List_new();

  void GWEN_Crypt_Token_KeyInfo_List_free(GWEN_CRYPT_TOKEN_KEYINFO_LIST *l);

  GWEN_CRYPT_TOKEN_KEYINFO* GWEN_Crypt_Token_KeyInfo_List_Next(const GWEN_CRYPT_TOKEN_KEYINFO *element);

  GWEN_CRYPT_TOKEN_KEYINFO* GWEN_Crypt_Token_KeyInfo_List_Previous(const GWEN_CRYPT_TOKEN_KEYINFO *element);

  uint32_t GWEN_Crypt_Token_KeyInfo_List_GetCount(const GWEN_CRYPT_TOKEN_KEYINFO_LIST *l);

  GWEN_CRYPT_TOKEN_KEYINFO_LIST_SORT_FN GWEN_Crypt_Token_KeyInfo_List_SetSortFn(GWEN_CRYPT_TOKEN_KEYINFO_LIST *l, GWEN_CRYPT_TOKEN_KEYINFO_LIST_SORT_FN fn);

  void GWEN_Crypt_Token_KeyInfo_List_Sort(GWEN_CRYPT_TOKEN_KEYINFO_LIST *l, int ascending);


#ifdef __cplusplus
}
#endif


#endif



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_SSLCERTDESCR_LIST2_H
#define GWEN_SSLCERTDESCR_LIST2_H


#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_SSLCERTDESCR_LIST2 GWEN_SSLCERTDESCR_LIST2;

  typedef struct GWEN_SSLCERTDESCR_LIST2_ITERATOR GWEN_SSLCERTDESCR_LIST2_ITERATOR;

  typedef GWEN_SSLCERTDESCR* (GWEN_SSLCERTDESCR_LIST2_FOREACH)(GWEN_SSLCERTDESCR *element,
                                                 void *user_data);

  GWEN_SSLCERTDESCR_LIST2 *GWEN_SslCertDescr_List2_new(); 

  void GWEN_SslCertDescr_List2_free(GWEN_SSLCERTDESCR_LIST2 *l); 

  void GWEN_SslCertDescr_List2_Dump(GWEN_SSLCERTDESCR_LIST2 *l, FILE *f, unsigned int indent); 

  void GWEN_SslCertDescr_List2_PushBack(GWEN_SSLCERTDESCR_LIST2 *l, GWEN_SSLCERTDESCR *p); 
   
  void GWEN_SslCertDescr_List2_PushFront(GWEN_SSLCERTDESCR_LIST2 *l, GWEN_SSLCERTDESCR *p); 

  GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2_GetFront(GWEN_SSLCERTDESCR_LIST2 *l); 
   
  GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2_GetBack(GWEN_SSLCERTDESCR_LIST2 *l); 

  void GWEN_SslCertDescr_List2_Erase(GWEN_SSLCERTDESCR_LIST2 *l,
                               GWEN_SSLCERTDESCR_LIST2_ITERATOR *it);

  unsigned int GWEN_SslCertDescr_List2_GetSize(GWEN_SSLCERTDESCR_LIST2 *l); 

  void GWEN_SslCertDescr_List2_PopBack(GWEN_SSLCERTDESCR_LIST2 *l); 
   
  void GWEN_SslCertDescr_List2_PopFront(GWEN_SSLCERTDESCR_LIST2 *l); 

  void GWEN_SslCertDescr_List2_Clear(GWEN_SSLCERTDESCR_LIST2 *l); 

  GWEN_SSLCERTDESCR_LIST2_ITERATOR *GWEN_SslCertDescr_List2_First(GWEN_SSLCERTDESCR_LIST2 *l); 
   
  GWEN_SSLCERTDESCR_LIST2_ITERATOR *GWEN_SslCertDescr_List2_Last(GWEN_SSLCERTDESCR_LIST2 *l); 

  GWEN_SSLCERTDESCR_LIST2_ITERATOR *GWEN_SslCertDescr_List2Iterator_new(GWEN_SSLCERTDESCR_LIST2 *l);

  void GWEN_SslCertDescr_List2Iterator_free(GWEN_SSLCERTDESCR_LIST2_ITERATOR *li); 

  GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2Iterator_Previous(GWEN_SSLCERTDESCR_LIST2_ITERATOR *li); 
   
  GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2Iterator_Next(GWEN_SSLCERTDESCR_LIST2_ITERATOR *li); 

  GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2Iterator_Data(GWEN_SSLCERTDESCR_LIST2_ITERATOR *li); 

  GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2_ForEach(GWEN_SSLCERTDESCR_LIST2 *list,
                                        GWEN_SSLCERTDESCR_LIST2_FOREACH func,
                                        void *user_data);


  typedef struct GWEN_SSLCERTDESCR_CONSTLIST2 GWEN_SSLCERTDESCR_CONSTLIST2; 
  typedef struct GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR; 
  typedef const GWEN_SSLCERTDESCR*
    (GWEN_SSLCERTDESCR_CONSTLIST2_FOREACH)(const GWEN_SSLCERTDESCR *element,
                                    void *user_data);
  
   
  GWEN_SSLCERTDESCR_CONSTLIST2 *GWEN_SslCertDescr_ConstList2_new(); 
   
  void GWEN_SslCertDescr_ConstList2_free(GWEN_SSLCERTDESCR_CONSTLIST2 *l); 
   
  void GWEN_SslCertDescr_ConstList2_PushBack(GWEN_SSLCERTDESCR_CONSTLIST2 *l, const GWEN_SSLCERTDESCR *p); 
   
  void GWEN_SslCertDescr_ConstList2_PushFront(GWEN_SSLCERTDESCR_CONSTLIST2 *l, const GWEN_SSLCERTDESCR *p); 
   
  const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2_GetFront(GWEN_SSLCERTDESCR_CONSTLIST2 *l); 
   
  const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2_GetBack(GWEN_SSLCERTDESCR_CONSTLIST2 *l); 
   
  unsigned int GWEN_SslCertDescr_ConstList2_GetSize(GWEN_SSLCERTDESCR_CONSTLIST2 *l); 
   
  void GWEN_SslCertDescr_ConstList2_PopBack(GWEN_SSLCERTDESCR_CONSTLIST2 *l); 
   
  void GWEN_SslCertDescr_ConstList2_PopFront(GWEN_SSLCERTDESCR_CONSTLIST2 *l); 
   
  void GWEN_SslCertDescr_ConstList2_Clear(GWEN_SSLCERTDESCR_CONSTLIST2 *l); 
   
  GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *GWEN_SslCertDescr_ConstList2_First(GWEN_SSLCERTDESCR_CONSTLIST2 *l); 
   
  GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *GWEN_SslCertDescr_ConstList2_Last(GWEN_SSLCERTDESCR_CONSTLIST2 *l); 
   
  GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *GWEN_SslCertDescr_ConstList2Iterator_new(GWEN_SSLCERTDESCR_CONSTLIST2 *l); 
   
  void GWEN_SslCertDescr_ConstList2Iterator_free(GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2Iterator_Previous(GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2Iterator_Next(GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2Iterator_Data(GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2_ForEach(GWEN_SSLCERTDESCR_CONSTLIST2 *list,
        GWEN_SSLCERTDESCR_CONSTLIST2_FOREACH func, void *user_data);


#ifdef __cplusplus
}
#endif


#endif /* GWEN_SSLCERTDESCR_LIST_H */



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_SSLCERTDESCR_LIST1_H
#define GWEN_SSLCERTDESCR_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_SSLCERTDESCR_LIST_ELEMENT {
    uint32_t id;
    GWEN_SSLCERTDESCR *nextObject;
  } GWEN_SSLCERTDESCR_LIST__ELEMENT;

  typedef struct GWEN_SSLCERTDESCR_LIST GWEN_SSLCERTDESCR_LIST;

  typedef int GWENHYWFAR_CB (*GWEN_SSLCERTDESCR_LIST_SORT_FN)(const GWEN_SSLCERTDESCR *a, const GWEN_SSLCERTDESCR *b, int ascending);


  struct GWEN_SSLCERTDESCR_LIST {
    GWEN_SSLCERTDESCR *first;
    uint32_t count;
    uint32_t id;
  } GWEN_SSLCERTDESCR_LIST;

  void GWEN_SslCertDescr_List_AddList(GWEN_SSLCERTDESCR_LIST *dst, GWEN_SSLCERTDESCR_LIST *l);

  void GWEN_SslCertDescr_List_Add(GWEN_SSLCERTDESCR *element, GWEN_SSLCERTDESCR_LIST *list);

  void GWEN_SslCertDescr_List_Insert(GWEN_SSLCERTDESCR *element, GWEN_SSLCERTDESCR_LIST *list);

  void GWEN_SslCertDescr_List_Del(GWEN_SSLCERTDESCR *element);

  GWEN_SSLCERTDESCR* GWEN_SslCertDescr_List_First(const GWEN_SSLCERTDESCR_LIST *l);

  GWEN_SSLCERTDESCR* GWEN_SslCertDescr_List_Last(const GWEN_SSLCERTDESCR_LIST *l);

  void GWEN_SslCertDescr_List_Clear(GWEN_SSLCERTDESCR_LIST *l);

  GWEN_SSLCERTDESCR_LIST* GWEN_SslCertDescr_List_new();

  void GWEN_SslCertDescr_List_free(GWEN_SSLCERTDESCR_LIST *l);

  GWEN_SSLCERTDESCR* GWEN_SslCertDescr_List_Next(const GWEN_SSLCERTDESCR *element);

  GWEN_SSLCERTDESCR* GWEN_SslCertDescr_List_Previous(const GWEN_SSLCERTDESCR *element);

  uint32_t GWEN_SslCertDescr_List_GetCount(const GWEN_SSLCERTDESCR_LIST *l);

  GWEN_SSLCERTDESCR_LIST_SORT_FN GWEN_SslCertDescr_List_SetSortFn(GWEN_SSLCERTDESCR_LIST *l, GWEN_SSLCERTDESCR_LIST_SORT_FN fn);

  void GWEN_SslCertDescr_List_Sort(GWEN_SSLCERTDESCR_LIST *l, int ascending);


#ifdef __cplusplus
}
#endif


#endif



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_SYNCIO_LIST1_H
#define GWEN_SYNCIO_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_SYNCIO_LIST_ELEMENT {
    uint32_t id;
    GWEN_SYNCIO *nextObject;
  } GWEN_SYNCIO_LIST__ELEMENT;

  typedef struct GWEN_SYNCIO_LIST GWEN_SYNCIO_LIST;

  typedef int GWENHYWFAR_CB (*GWEN_SYNCIO_LIST_SORT_FN)(const GWEN_SYNCIO *a, const GWEN_SYNCIO *b, int ascending);


  struct GWEN_SYNCIO_LIST {
    GWEN_SYNCIO *first;
    uint32_t count;
    uint32_t id;
  } GWEN_SYNCIO_LIST;

  void GWEN_SyncIo_List_AddList(GWEN_SYNCIO_LIST *dst, GWEN_SYNCIO_LIST *l);

  void GWEN_SyncIo_List_Add(GWEN_SYNCIO *element, GWEN_SYNCIO_LIST *list);

  void GWEN_SyncIo_List_Insert(GWEN_SYNCIO *element, GWEN_SYNCIO_LIST *list);

  void GWEN_SyncIo_List_Del(GWEN_SYNCIO *element);

  GWEN_SYNCIO* GWEN_SyncIo_List_First(const GWEN_SYNCIO_LIST *l);

  GWEN_SYNCIO* GWEN_SyncIo_List_Last(const GWEN_SYNCIO_LIST *l);

  void GWEN_SyncIo_List_Clear(GWEN_SYNCIO_LIST *l);

  GWEN_SYNCIO_LIST* GWEN_SyncIo_List_new();

  void GWEN_SyncIo_List_free(GWEN_SYNCIO_LIST *l);

  GWEN_SYNCIO* GWEN_SyncIo_List_Next(const GWEN_SYNCIO *element);

  GWEN_SYNCIO* GWEN_SyncIo_List_Previous(const GWEN_SYNCIO *element);

  uint32_t GWEN_SyncIo_List_GetCount(const GWEN_SYNCIO_LIST *l);

  GWEN_SYNCIO_LIST_SORT_FN GWEN_SyncIo_List_SetSortFn(GWEN_SYNCIO_LIST *l, GWEN_SYNCIO_LIST_SORT_FN fn);

  void GWEN_SyncIo_List_Sort(GWEN_SYNCIO_LIST *l, int ascending);


#ifdef __cplusplus
}
#endif


#endif



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_FSLOCK_LIST2_H
#define GWEN_FSLOCK_LIST2_H


#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_FSLOCK_LIST2 GWEN_FSLOCK_LIST2;

  typedef struct GWEN_FSLOCK_LIST2_ITERATOR GWEN_FSLOCK_LIST2_ITERATOR;

  typedef GWEN_FSLOCK* (GWEN_FSLOCK_LIST2_FOREACH)(GWEN_FSLOCK *element,
                                                 void *user_data);

  GWEN_FSLOCK_LIST2 *GWEN_FSLock_List2_new(); 

  void GWEN_FSLock_List2_free(GWEN_FSLOCK_LIST2 *l); 

  void GWEN_FSLock_List2_Dump(GWEN_FSLOCK_LIST2 *l, FILE *f, unsigned int indent); 

  void GWEN_FSLock_List2_PushBack(GWEN_FSLOCK_LIST2 *l, GWEN_FSLOCK *p); 
   
  void GWEN_FSLock_List2_PushFront(GWEN_FSLOCK_LIST2 *l, GWEN_FSLOCK *p); 

  GWEN_FSLOCK *GWEN_FSLock_List2_GetFront(GWEN_FSLOCK_LIST2 *l); 
   
  GWEN_FSLOCK *GWEN_FSLock_List2_GetBack(GWEN_FSLOCK_LIST2 *l); 

  void GWEN_FSLock_List2_Erase(GWEN_FSLOCK_LIST2 *l,
                               GWEN_FSLOCK_LIST2_ITERATOR *it);

  unsigned int GWEN_FSLock_List2_GetSize(GWEN_FSLOCK_LIST2 *l); 

  void GWEN_FSLock_List2_PopBack(GWEN_FSLOCK_LIST2 *l); 
   
  void GWEN_FSLock_List2_PopFront(GWEN_FSLOCK_LIST2 *l); 

  void GWEN_FSLock_List2_Clear(GWEN_FSLOCK_LIST2 *l); 

  GWEN_FSLOCK_LIST2_ITERATOR *GWEN_FSLock_List2_First(GWEN_FSLOCK_LIST2 *l); 
   
  GWEN_FSLOCK_LIST2_ITERATOR *GWEN_FSLock_List2_Last(GWEN_FSLOCK_LIST2 *l); 

  GWEN_FSLOCK_LIST2_ITERATOR *GWEN_FSLock_List2Iterator_new(GWEN_FSLOCK_LIST2 *l);

  void GWEN_FSLock_List2Iterator_free(GWEN_FSLOCK_LIST2_ITERATOR *li); 

  GWEN_FSLOCK *GWEN_FSLock_List2Iterator_Previous(GWEN_FSLOCK_LIST2_ITERATOR *li); 
   
  GWEN_FSLOCK *GWEN_FSLock_List2Iterator_Next(GWEN_FSLOCK_LIST2_ITERATOR *li); 

  GWEN_FSLOCK *GWEN_FSLock_List2Iterator_Data(GWEN_FSLOCK_LIST2_ITERATOR *li); 

  GWEN_FSLOCK *GWEN_FSLock_List2_ForEach(GWEN_FSLOCK_LIST2 *list,
                                        GWEN_FSLOCK_LIST2_FOREACH func,
                                        void *user_data);


  typedef struct GWEN_FSLOCK_CONSTLIST2 GWEN_FSLOCK_CONSTLIST2; 
  typedef struct GWEN_FSLOCK_CONSTLIST2_ITERATOR GWEN_FSLOCK_CONSTLIST2_ITERATOR; 
  typedef const GWEN_FSLOCK*
    (GWEN_FSLOCK_CONSTLIST2_FOREACH)(const GWEN_FSLOCK *element,
                                    void *user_data);
  
   
  GWEN_FSLOCK_CONSTLIST2 *GWEN_FSLock_ConstList2_new(); 
   
  void GWEN_FSLock_ConstList2_free(GWEN_FSLOCK_CONSTLIST2 *l); 
   
  void GWEN_FSLock_ConstList2_PushBack(GWEN_FSLOCK_CONSTLIST2 *l, const GWEN_FSLOCK *p); 
   
  void GWEN_FSLock_ConstList2_PushFront(GWEN_FSLOCK_CONSTLIST2 *l, const GWEN_FSLOCK *p); 
   
  const GWEN_FSLOCK *GWEN_FSLock_ConstList2_GetFront(GWEN_FSLOCK_CONSTLIST2 *l); 
   
  const GWEN_FSLOCK *GWEN_FSLock_ConstList2_GetBack(GWEN_FSLOCK_CONSTLIST2 *l); 
   
  unsigned int GWEN_FSLock_ConstList2_GetSize(GWEN_FSLOCK_CONSTLIST2 *l); 
   
  void GWEN_FSLock_ConstList2_PopBack(GWEN_FSLOCK_CONSTLIST2 *l); 
   
  void GWEN_FSLock_ConstList2_PopFront(GWEN_FSLOCK_CONSTLIST2 *l); 
   
  void GWEN_FSLock_ConstList2_Clear(GWEN_FSLOCK_CONSTLIST2 *l); 
   
  GWEN_FSLOCK_CONSTLIST2_ITERATOR *GWEN_FSLock_ConstList2_First(GWEN_FSLOCK_CONSTLIST2 *l); 
   
  GWEN_FSLOCK_CONSTLIST2_ITERATOR *GWEN_FSLock_ConstList2_Last(GWEN_FSLOCK_CONSTLIST2 *l); 
   
  GWEN_FSLOCK_CONSTLIST2_ITERATOR *GWEN_FSLock_ConstList2Iterator_new(GWEN_FSLOCK_CONSTLIST2 *l); 
   
  void GWEN_FSLock_ConstList2Iterator_free(GWEN_FSLOCK_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_FSLOCK *GWEN_FSLock_ConstList2Iterator_Previous(GWEN_FSLOCK_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_FSLOCK *GWEN_FSLock_ConstList2Iterator_Next(GWEN_FSLOCK_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_FSLOCK *GWEN_FSLock_ConstList2Iterator_Data(GWEN_FSLOCK_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_FSLOCK *GWEN_FSLock_ConstList2_ForEach(GWEN_FSLOCK_CONSTLIST2 *list,
        GWEN_FSLOCK_CONSTLIST2_FOREACH func, void *user_data);


#ifdef __cplusplus
}
#endif


#endif /* GWEN_FSLOCK_LIST_H */



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_FSLOCK_LIST1_H
#define GWEN_FSLOCK_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_FSLOCK_LIST_ELEMENT {
    uint32_t id;
    GWEN_FSLOCK *nextObject;
  } GWEN_FSLOCK_LIST__ELEMENT;

  typedef struct GWEN_FSLOCK_LIST GWEN_FSLOCK_LIST;

  typedef int GWENHYWFAR_CB (*GWEN_FSLOCK_LIST_SORT_FN)(const GWEN_FSLOCK *a, const GWEN_FSLOCK *b, int ascending);


  struct GWEN_FSLOCK_LIST {
    GWEN_FSLOCK *first;
    uint32_t count;
    uint32_t id;
  } GWEN_FSLOCK_LIST;

  void GWEN_FSLock_List_AddList(GWEN_FSLOCK_LIST *dst, GWEN_FSLOCK_LIST *l);

  void GWEN_FSLock_List_Add(GWEN_FSLOCK *element, GWEN_FSLOCK_LIST *list);

  void GWEN_FSLock_List_Insert(GWEN_FSLOCK *element, GWEN_FSLOCK_LIST *list);

  void GWEN_FSLock_List_Del(GWEN_FSLOCK *element);

  GWEN_FSLOCK* GWEN_FSLock_List_First(const GWEN_FSLOCK_LIST *l);

  GWEN_FSLOCK* GWEN_FSLock_List_Last(const GWEN_FSLOCK_LIST *l);

  void GWEN_FSLock_List_Clear(GWEN_FSLOCK_LIST *l);

  GWEN_FSLOCK_LIST* GWEN_FSLock_List_new();

  void GWEN_FSLock_List_free(GWEN_FSLOCK_LIST *l);

  GWEN_FSLOCK* GWEN_FSLock_List_Next(const GWEN_FSLOCK *element);

  GWEN_FSLOCK* GWEN_FSLock_List_Previous(const GWEN_FSLOCK *element);

  uint32_t GWEN_FSLock_List_GetCount(const GWEN_FSLOCK_LIST *l);

  GWEN_FSLOCK_LIST_SORT_FN GWEN_FSLock_List_SetSortFn(GWEN_FSLOCK_LIST *l, GWEN_FSLOCK_LIST_SORT_FN fn);

  void GWEN_FSLock_List_Sort(GWEN_FSLOCK_LIST *l, int ascending);


#ifdef __cplusplus
}
#endif


#endif



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_SOCKET_LIST2_H
#define GWEN_SOCKET_LIST2_H


#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_SOCKET_LIST2 GWEN_SOCKET_LIST2;

  typedef struct GWEN_SOCKET_LIST2_ITERATOR GWEN_SOCKET_LIST2_ITERATOR;

  typedef GWEN_SOCKET* (GWEN_SOCKET_LIST2_FOREACH)(GWEN_SOCKET *element,
                                                 void *user_data);

  GWEN_SOCKET_LIST2 *GWEN_Socket_List2_new(); 

  void GWEN_Socket_List2_free(GWEN_SOCKET_LIST2 *l); 

  void GWEN_Socket_List2_Dump(GWEN_SOCKET_LIST2 *l, FILE *f, unsigned int indent); 

  void GWEN_Socket_List2_PushBack(GWEN_SOCKET_LIST2 *l, GWEN_SOCKET *p); 
   
  void GWEN_Socket_List2_PushFront(GWEN_SOCKET_LIST2 *l, GWEN_SOCKET *p); 

  GWEN_SOCKET *GWEN_Socket_List2_GetFront(GWEN_SOCKET_LIST2 *l); 
   
  GWEN_SOCKET *GWEN_Socket_List2_GetBack(GWEN_SOCKET_LIST2 *l); 

  void GWEN_Socket_List2_Erase(GWEN_SOCKET_LIST2 *l,
                               GWEN_SOCKET_LIST2_ITERATOR *it);

  unsigned int GWEN_Socket_List2_GetSize(GWEN_SOCKET_LIST2 *l); 

  void GWEN_Socket_List2_PopBack(GWEN_SOCKET_LIST2 *l); 
   
  void GWEN_Socket_List2_PopFront(GWEN_SOCKET_LIST2 *l); 

  void GWEN_Socket_List2_Clear(GWEN_SOCKET_LIST2 *l); 

  GWEN_SOCKET_LIST2_ITERATOR *GWEN_Socket_List2_First(GWEN_SOCKET_LIST2 *l); 
   
  GWEN_SOCKET_LIST2_ITERATOR *GWEN_Socket_List2_Last(GWEN_SOCKET_LIST2 *l); 

  GWEN_SOCKET_LIST2_ITERATOR *GWEN_Socket_List2Iterator_new(GWEN_SOCKET_LIST2 *l);

  void GWEN_Socket_List2Iterator_free(GWEN_SOCKET_LIST2_ITERATOR *li); 

  GWEN_SOCKET *GWEN_Socket_List2Iterator_Previous(GWEN_SOCKET_LIST2_ITERATOR *li); 
   
  GWEN_SOCKET *GWEN_Socket_List2Iterator_Next(GWEN_SOCKET_LIST2_ITERATOR *li); 

  GWEN_SOCKET *GWEN_Socket_List2Iterator_Data(GWEN_SOCKET_LIST2_ITERATOR *li); 

  GWEN_SOCKET *GWEN_Socket_List2_ForEach(GWEN_SOCKET_LIST2 *list,
                                        GWEN_SOCKET_LIST2_FOREACH func,
                                        void *user_data);


  typedef struct GWEN_SOCKET_CONSTLIST2 GWEN_SOCKET_CONSTLIST2; 
  typedef struct GWEN_SOCKET_CONSTLIST2_ITERATOR GWEN_SOCKET_CONSTLIST2_ITERATOR; 
  typedef const GWEN_SOCKET*
    (GWEN_SOCKET_CONSTLIST2_FOREACH)(const GWEN_SOCKET *element,
                                    void *user_data);
  
   
  GWEN_SOCKET_CONSTLIST2 *GWEN_Socket_ConstList2_new(); 
   
  void GWEN_Socket_ConstList2_free(GWEN_SOCKET_CONSTLIST2 *l); 
   
  void GWEN_Socket_ConstList2_PushBack(GWEN_SOCKET_CONSTLIST2 *l, const GWEN_SOCKET *p); 
   
  void GWEN_Socket_ConstList2_PushFront(GWEN_SOCKET_CONSTLIST2 *l, const GWEN_SOCKET *p); 
   
  const GWEN_SOCKET *GWEN_Socket_ConstList2_GetFront(GWEN_SOCKET_CONSTLIST2 *l); 
   
  const GWEN_SOCKET *GWEN_Socket_ConstList2_GetBack(GWEN_SOCKET_CONSTLIST2 *l); 
   
  unsigned int GWEN_Socket_ConstList2_GetSize(GWEN_SOCKET_CONSTLIST2 *l); 
   
  void GWEN_Socket_ConstList2_PopBack(GWEN_SOCKET_CONSTLIST2 *l); 
   
  void GWEN_Socket_ConstList2_PopFront(GWEN_SOCKET_CONSTLIST2 *l); 
   
  void GWEN_Socket_ConstList2_Clear(GWEN_SOCKET_CONSTLIST2 *l); 
   
  GWEN_SOCKET_CONSTLIST2_ITERATOR *GWEN_Socket_ConstList2_First(GWEN_SOCKET_CONSTLIST2 *l); 
   
  GWEN_SOCKET_CONSTLIST2_ITERATOR *GWEN_Socket_ConstList2_Last(GWEN_SOCKET_CONSTLIST2 *l); 
   
  GWEN_SOCKET_CONSTLIST2_ITERATOR *GWEN_Socket_ConstList2Iterator_new(GWEN_SOCKET_CONSTLIST2 *l); 
   
  void GWEN_Socket_ConstList2Iterator_free(GWEN_SOCKET_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_SOCKET *GWEN_Socket_ConstList2Iterator_Previous(GWEN_SOCKET_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_SOCKET *GWEN_Socket_ConstList2Iterator_Next(GWEN_SOCKET_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_SOCKET *GWEN_Socket_ConstList2Iterator_Data(GWEN_SOCKET_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_SOCKET *GWEN_Socket_ConstList2_ForEach(GWEN_SOCKET_CONSTLIST2 *list,
        GWEN_SOCKET_CONSTLIST2_FOREACH func, void *user_data);


#ifdef __cplusplus
}
#endif


#endif /* GWEN_SOCKET_LIST_H */



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_SOCKET_LIST1_H
#define GWEN_SOCKET_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_SOCKET_LIST_ELEMENT {
    uint32_t id;
    GWEN_SOCKET *nextObject;
  } GWEN_SOCKET_LIST__ELEMENT;

  typedef struct GWEN_SOCKET_LIST GWEN_SOCKET_LIST;

  typedef int GWENHYWFAR_CB (*GWEN_SOCKET_LIST_SORT_FN)(const GWEN_SOCKET *a, const GWEN_SOCKET *b, int ascending);


  struct GWEN_SOCKET_LIST {
    GWEN_SOCKET *first;
    uint32_t count;
    uint32_t id;
  } GWEN_SOCKET_LIST;

  void GWEN_Socket_List_AddList(GWEN_SOCKET_LIST *dst, GWEN_SOCKET_LIST *l);

  void GWEN_Socket_List_Add(GWEN_SOCKET *element, GWEN_SOCKET_LIST *list);

  void GWEN_Socket_List_Insert(GWEN_SOCKET *element, GWEN_SOCKET_LIST *list);

  void GWEN_Socket_List_Del(GWEN_SOCKET *element);

  GWEN_SOCKET* GWEN_Socket_List_First(const GWEN_SOCKET_LIST *l);

  GWEN_SOCKET* GWEN_Socket_List_Last(const GWEN_SOCKET_LIST *l);

  void GWEN_Socket_List_Clear(GWEN_SOCKET_LIST *l);

  GWEN_SOCKET_LIST* GWEN_Socket_List_new();

  void GWEN_Socket_List_free(GWEN_SOCKET_LIST *l);

  GWEN_SOCKET* GWEN_Socket_List_Next(const GWEN_SOCKET *element);

  GWEN_SOCKET* GWEN_Socket_List_Previous(const GWEN_SOCKET *element);

  uint32_t GWEN_Socket_List_GetCount(const GWEN_SOCKET_LIST *l);

  GWEN_SOCKET_LIST_SORT_FN GWEN_Socket_List_SetSortFn(GWEN_SOCKET_LIST *l, GWEN_SOCKET_LIST_SORT_FN fn);

  void GWEN_Socket_List_Sort(GWEN_SOCKET_LIST *l, int ascending);


#ifdef __cplusplus
}
#endif


#endif



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_DIALOG_LIST2_H
#define GWEN_DIALOG_LIST2_H


#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_DIALOG_LIST2 GWEN_DIALOG_LIST2;

  typedef struct GWEN_DIALOG_LIST2_ITERATOR GWEN_DIALOG_LIST2_ITERATOR;

  typedef GWEN_DIALOG* (GWEN_DIALOG_LIST2_FOREACH)(GWEN_DIALOG *element,
                                                 void *user_data);

  GWEN_DIALOG_LIST2 *GWEN_Dialog_List2_new(); 

  void GWEN_Dialog_List2_free(GWEN_DIALOG_LIST2 *l); 

  void GWEN_Dialog_List2_Dump(GWEN_DIALOG_LIST2 *l, FILE *f, unsigned int indent); 

  void GWEN_Dialog_List2_PushBack(GWEN_DIALOG_LIST2 *l, GWEN_DIALOG *p); 
   
  void GWEN_Dialog_List2_PushFront(GWEN_DIALOG_LIST2 *l, GWEN_DIALOG *p); 

  GWEN_DIALOG *GWEN_Dialog_List2_GetFront(GWEN_DIALOG_LIST2 *l); 
   
  GWEN_DIALOG *GWEN_Dialog_List2_GetBack(GWEN_DIALOG_LIST2 *l); 

  void GWEN_Dialog_List2_Erase(GWEN_DIALOG_LIST2 *l,
                               GWEN_DIALOG_LIST2_ITERATOR *it);

  unsigned int GWEN_Dialog_List2_GetSize(GWEN_DIALOG_LIST2 *l); 

  void GWEN_Dialog_List2_PopBack(GWEN_DIALOG_LIST2 *l); 
   
  void GWEN_Dialog_List2_PopFront(GWEN_DIALOG_LIST2 *l); 

  void GWEN_Dialog_List2_Clear(GWEN_DIALOG_LIST2 *l); 

  GWEN_DIALOG_LIST2_ITERATOR *GWEN_Dialog_List2_First(GWEN_DIALOG_LIST2 *l); 
   
  GWEN_DIALOG_LIST2_ITERATOR *GWEN_Dialog_List2_Last(GWEN_DIALOG_LIST2 *l); 

  GWEN_DIALOG_LIST2_ITERATOR *GWEN_Dialog_List2Iterator_new(GWEN_DIALOG_LIST2 *l);

  void GWEN_Dialog_List2Iterator_free(GWEN_DIALOG_LIST2_ITERATOR *li); 

  GWEN_DIALOG *GWEN_Dialog_List2Iterator_Previous(GWEN_DIALOG_LIST2_ITERATOR *li); 
   
  GWEN_DIALOG *GWEN_Dialog_List2Iterator_Next(GWEN_DIALOG_LIST2_ITERATOR *li); 

  GWEN_DIALOG *GWEN_Dialog_List2Iterator_Data(GWEN_DIALOG_LIST2_ITERATOR *li); 

  GWEN_DIALOG *GWEN_Dialog_List2_ForEach(GWEN_DIALOG_LIST2 *list,
                                        GWEN_DIALOG_LIST2_FOREACH func,
                                        void *user_data);


  typedef struct GWEN_DIALOG_CONSTLIST2 GWEN_DIALOG_CONSTLIST2; 
  typedef struct GWEN_DIALOG_CONSTLIST2_ITERATOR GWEN_DIALOG_CONSTLIST2_ITERATOR; 
  typedef const GWEN_DIALOG*
    (GWEN_DIALOG_CONSTLIST2_FOREACH)(const GWEN_DIALOG *element,
                                    void *user_data);
  
   
  GWEN_DIALOG_CONSTLIST2 *GWEN_Dialog_ConstList2_new(); 
   
  void GWEN_Dialog_ConstList2_free(GWEN_DIALOG_CONSTLIST2 *l); 
   
  void GWEN_Dialog_ConstList2_PushBack(GWEN_DIALOG_CONSTLIST2 *l, const GWEN_DIALOG *p); 
   
  void GWEN_Dialog_ConstList2_PushFront(GWEN_DIALOG_CONSTLIST2 *l, const GWEN_DIALOG *p); 
   
  const GWEN_DIALOG *GWEN_Dialog_ConstList2_GetFront(GWEN_DIALOG_CONSTLIST2 *l); 
   
  const GWEN_DIALOG *GWEN_Dialog_ConstList2_GetBack(GWEN_DIALOG_CONSTLIST2 *l); 
   
  unsigned int GWEN_Dialog_ConstList2_GetSize(GWEN_DIALOG_CONSTLIST2 *l); 
   
  void GWEN_Dialog_ConstList2_PopBack(GWEN_DIALOG_CONSTLIST2 *l); 
   
  void GWEN_Dialog_ConstList2_PopFront(GWEN_DIALOG_CONSTLIST2 *l); 
   
  void GWEN_Dialog_ConstList2_Clear(GWEN_DIALOG_CONSTLIST2 *l); 
   
  GWEN_DIALOG_CONSTLIST2_ITERATOR *GWEN_Dialog_ConstList2_First(GWEN_DIALOG_CONSTLIST2 *l); 
   
  GWEN_DIALOG_CONSTLIST2_ITERATOR *GWEN_Dialog_ConstList2_Last(GWEN_DIALOG_CONSTLIST2 *l); 
   
  GWEN_DIALOG_CONSTLIST2_ITERATOR *GWEN_Dialog_ConstList2Iterator_new(GWEN_DIALOG_CONSTLIST2 *l); 
   
  void GWEN_Dialog_ConstList2Iterator_free(GWEN_DIALOG_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_DIALOG *GWEN_Dialog_ConstList2Iterator_Previous(GWEN_DIALOG_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_DIALOG *GWEN_Dialog_ConstList2Iterator_Next(GWEN_DIALOG_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_DIALOG *GWEN_Dialog_ConstList2Iterator_Data(GWEN_DIALOG_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_DIALOG *GWEN_Dialog_ConstList2_ForEach(GWEN_DIALOG_CONSTLIST2 *list,
        GWEN_DIALOG_CONSTLIST2_FOREACH func, void *user_data);


#ifdef __cplusplus
}
#endif


#endif /* GWEN_DIALOG_LIST_H */



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_DIALOG_LIST1_H
#define GWEN_DIALOG_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_DIALOG_LIST_ELEMENT {
    uint32_t id;
    GWEN_DIALOG *nextObject;
  } GWEN_DIALOG_LIST__ELEMENT;

  typedef struct GWEN_DIALOG_LIST GWEN_DIALOG_LIST;

  typedef int GWENHYWFAR_CB (*GWEN_DIALOG_LIST_SORT_FN)(const GWEN_DIALOG *a, const GWEN_DIALOG *b, int ascending);


  struct GWEN_DIALOG_LIST {
    GWEN_DIALOG *first;
    uint32_t count;
    uint32_t id;
  } GWEN_DIALOG_LIST;

  void GWEN_Dialog_List_AddList(GWEN_DIALOG_LIST *dst, GWEN_DIALOG_LIST *l);

  void GWEN_Dialog_List_Add(GWEN_DIALOG *element, GWEN_DIALOG_LIST *list);

  void GWEN_Dialog_List_Insert(GWEN_DIALOG *element, GWEN_DIALOG_LIST *list);

  void GWEN_Dialog_List_Del(GWEN_DIALOG *element);

  GWEN_DIALOG* GWEN_Dialog_List_First(const GWEN_DIALOG_LIST *l);

  GWEN_DIALOG* GWEN_Dialog_List_Last(const GWEN_DIALOG_LIST *l);

  void GWEN_Dialog_List_Clear(GWEN_DIALOG_LIST *l);

  GWEN_DIALOG_LIST* GWEN_Dialog_List_new();

  void GWEN_Dialog_List_free(GWEN_DIALOG_LIST *l);

  GWEN_DIALOG* GWEN_Dialog_List_Next(const GWEN_DIALOG *element);

  GWEN_DIALOG* GWEN_Dialog_List_Previous(const GWEN_DIALOG *element);

  uint32_t GWEN_Dialog_List_GetCount(const GWEN_DIALOG_LIST *l);

  GWEN_DIALOG_LIST_SORT_FN GWEN_Dialog_List_SetSortFn(GWEN_DIALOG_LIST *l, GWEN_DIALOG_LIST_SORT_FN fn);

  void GWEN_Dialog_List_Sort(GWEN_DIALOG_LIST *l, int ascending);


#ifdef __cplusplus
}
#endif


#endif



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef HTML_FONT_LIST1_H
#define HTML_FONT_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct HTML_FONT_LIST_ELEMENT {
    uint32_t id;
    HTML_FONT *nextObject;
  } HTML_FONT_LIST__ELEMENT;

  typedef struct HTML_FONT_LIST HTML_FONT_LIST;

  typedef int GWENHYWFAR_CB (*HTML_FONT_LIST_SORT_FN)(const HTML_FONT *a, const HTML_FONT *b, int ascending);


  struct HTML_FONT_LIST {
    HTML_FONT *first;
    uint32_t count;
    uint32_t id;
  } HTML_FONT_LIST;

  void HtmlFont_List_AddList(HTML_FONT_LIST *dst, HTML_FONT_LIST *l);

  void HtmlFont_List_Add(HTML_FONT *element, HTML_FONT_LIST *list);

  void HtmlFont_List_Insert(HTML_FONT *element, HTML_FONT_LIST *list);

  void HtmlFont_List_Del(HTML_FONT *element);

  HTML_FONT* HtmlFont_List_First(const HTML_FONT_LIST *l);

  HTML_FONT* HtmlFont_List_Last(const HTML_FONT_LIST *l);

  void HtmlFont_List_Clear(HTML_FONT_LIST *l);

  HTML_FONT_LIST* HtmlFont_List_new();

  void HtmlFont_List_free(HTML_FONT_LIST *l);

  HTML_FONT* HtmlFont_List_Next(const HTML_FONT *element);

  HTML_FONT* HtmlFont_List_Previous(const HTML_FONT *element);

  uint32_t HtmlFont_List_GetCount(const HTML_FONT_LIST *l);

  HTML_FONT_LIST_SORT_FN HtmlFont_List_SetSortFn(HTML_FONT_LIST *l, HTML_FONT_LIST_SORT_FN fn);

  void HtmlFont_List_Sort(HTML_FONT_LIST *l, int ascending);


#ifdef __cplusplus
}
#endif


#endif



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef HTML_IMAGE_LIST1_H
#define HTML_IMAGE_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct HTML_IMAGE_LIST_ELEMENT {
    uint32_t id;
    HTML_IMAGE *nextObject;
  } HTML_IMAGE_LIST__ELEMENT;

  typedef struct HTML_IMAGE_LIST HTML_IMAGE_LIST;

  typedef int GWENHYWFAR_CB (*HTML_IMAGE_LIST_SORT_FN)(const HTML_IMAGE *a, const HTML_IMAGE *b, int ascending);


  struct HTML_IMAGE_LIST {
    HTML_IMAGE *first;
    uint32_t count;
    uint32_t id;
  } HTML_IMAGE_LIST;

  void HtmlImage_List_AddList(HTML_IMAGE_LIST *dst, HTML_IMAGE_LIST *l);

  void HtmlImage_List_Add(HTML_IMAGE *element, HTML_IMAGE_LIST *list);

  void HtmlImage_List_Insert(HTML_IMAGE *element, HTML_IMAGE_LIST *list);

  void HtmlImage_List_Del(HTML_IMAGE *element);

  HTML_IMAGE* HtmlImage_List_First(const HTML_IMAGE_LIST *l);

  HTML_IMAGE* HtmlImage_List_Last(const HTML_IMAGE_LIST *l);

  void HtmlImage_List_Clear(HTML_IMAGE_LIST *l);

  HTML_IMAGE_LIST* HtmlImage_List_new();

  void HtmlImage_List_free(HTML_IMAGE_LIST *l);

  HTML_IMAGE* HtmlImage_List_Next(const HTML_IMAGE *element);

  HTML_IMAGE* HtmlImage_List_Previous(const HTML_IMAGE *element);

  uint32_t HtmlImage_List_GetCount(const HTML_IMAGE_LIST *l);

  HTML_IMAGE_LIST_SORT_FN HtmlImage_List_SetSortFn(HTML_IMAGE_LIST *l, HTML_IMAGE_LIST_SORT_FN fn);

  void HtmlImage_List_Sort(HTML_IMAGE_LIST *l, int ascending);


#ifdef __cplusplus
}
#endif


#endif



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_DBIO_LIST1_H
#define GWEN_DBIO_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_DBIO_LIST_ELEMENT {
    uint32_t id;
    GWEN_DBIO *nextObject;
  } GWEN_DBIO_LIST__ELEMENT;

  typedef struct GWEN_DBIO_LIST GWEN_DBIO_LIST;

  typedef int GWENHYWFAR_CB (*GWEN_DBIO_LIST_SORT_FN)(const GWEN_DBIO *a, const GWEN_DBIO *b, int ascending);


  struct GWEN_DBIO_LIST {
    GWEN_DBIO *first;
    uint32_t count;
    uint32_t id;
  } GWEN_DBIO_LIST;

  void GWEN_DBIO_List_AddList(GWEN_DBIO_LIST *dst, GWEN_DBIO_LIST *l);

  void GWEN_DBIO_List_Add(GWEN_DBIO *element, GWEN_DBIO_LIST *list);

  void GWEN_DBIO_List_Insert(GWEN_DBIO *element, GWEN_DBIO_LIST *list);

  void GWEN_DBIO_List_Del(GWEN_DBIO *element);

  GWEN_DBIO* GWEN_DBIO_List_First(const GWEN_DBIO_LIST *l);

  GWEN_DBIO* GWEN_DBIO_List_Last(const GWEN_DBIO_LIST *l);

  void GWEN_DBIO_List_Clear(GWEN_DBIO_LIST *l);

  GWEN_DBIO_LIST* GWEN_DBIO_List_new();

  void GWEN_DBIO_List_free(GWEN_DBIO_LIST *l);

  GWEN_DBIO* GWEN_DBIO_List_Next(const GWEN_DBIO *element);

  GWEN_DBIO* GWEN_DBIO_List_Previous(const GWEN_DBIO *element);

  uint32_t GWEN_DBIO_List_GetCount(const GWEN_DBIO_LIST *l);

  GWEN_DBIO_LIST_SORT_FN GWEN_DBIO_List_SetSortFn(GWEN_DBIO_LIST *l, GWEN_DBIO_LIST_SORT_FN fn);

  void GWEN_DBIO_List_Sort(GWEN_DBIO_LIST *l, int ascending);


#ifdef __cplusplus
}
#endif


#endif



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_TAG16_LIST1_H
#define GWEN_TAG16_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_TAG16_LIST_ELEMENT {
    uint32_t id;
    GWEN_TAG16 *nextObject;
  } GWEN_TAG16_LIST__ELEMENT;

  typedef struct GWEN_TAG16_LIST GWEN_TAG16_LIST;

  typedef int GWENHYWFAR_CB (*GWEN_TAG16_LIST_SORT_FN)(const GWEN_TAG16 *a, const GWEN_TAG16 *b, int ascending);


  struct GWEN_TAG16_LIST {
    GWEN_TAG16 *first;
    uint32_t count;
    uint32_t id;
  } GWEN_TAG16_LIST;

  void GWEN_Tag16_List_AddList(GWEN_TAG16_LIST *dst, GWEN_TAG16_LIST *l);

  void GWEN_Tag16_List_Add(GWEN_TAG16 *element, GWEN_TAG16_LIST *list);

  void GWEN_Tag16_List_Insert(GWEN_TAG16 *element, GWEN_TAG16_LIST *list);

  void GWEN_Tag16_List_Del(GWEN_TAG16 *element);

  GWEN_TAG16* GWEN_Tag16_List_First(const GWEN_TAG16_LIST *l);

  GWEN_TAG16* GWEN_Tag16_List_Last(const GWEN_TAG16_LIST *l);

  void GWEN_Tag16_List_Clear(GWEN_TAG16_LIST *l);

  GWEN_TAG16_LIST* GWEN_Tag16_List_new();

  void GWEN_Tag16_List_free(GWEN_TAG16_LIST *l);

  GWEN_TAG16* GWEN_Tag16_List_Next(const GWEN_TAG16 *element);

  GWEN_TAG16* GWEN_Tag16_List_Previous(const GWEN_TAG16 *element);

  uint32_t GWEN_Tag16_List_GetCount(const GWEN_TAG16_LIST *l);

  GWEN_TAG16_LIST_SORT_FN GWEN_Tag16_List_SetSortFn(GWEN_TAG16_LIST *l, GWEN_TAG16_LIST_SORT_FN fn);

  void GWEN_Tag16_List_Sort(GWEN_TAG16_LIST *l, int ascending);


#ifdef __cplusplus
}
#endif


#endif



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_TLV_LIST1_H
#define GWEN_TLV_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_TLV_LIST_ELEMENT {
    uint32_t id;
    GWEN_TLV *nextObject;
  } GWEN_TLV_LIST__ELEMENT;

  typedef struct GWEN_TLV_LIST GWEN_TLV_LIST;

  typedef int GWENHYWFAR_CB (*GWEN_TLV_LIST_SORT_FN)(const GWEN_TLV *a, const GWEN_TLV *b, int ascending);


  struct GWEN_TLV_LIST {
    GWEN_TLV *first;
    uint32_t count;
    uint32_t id;
  } GWEN_TLV_LIST;

  void GWEN_TLV_List_AddList(GWEN_TLV_LIST *dst, GWEN_TLV_LIST *l);

  void GWEN_TLV_List_Add(GWEN_TLV *element, GWEN_TLV_LIST *list);

  void GWEN_TLV_List_Insert(GWEN_TLV *element, GWEN_TLV_LIST *list);

  void GWEN_TLV_List_Del(GWEN_TLV *element);

  GWEN_TLV* GWEN_TLV_List_First(const GWEN_TLV_LIST *l);

  GWEN_TLV* GWEN_TLV_List_Last(const GWEN_TLV_LIST *l);

  void GWEN_TLV_List_Clear(GWEN_TLV_LIST *l);

  GWEN_TLV_LIST* GWEN_TLV_List_new();

  void GWEN_TLV_List_free(GWEN_TLV_LIST *l);

  GWEN_TLV* GWEN_TLV_List_Next(const GWEN_TLV *element);

  GWEN_TLV* GWEN_TLV_List_Previous(const GWEN_TLV *element);

  uint32_t GWEN_TLV_List_GetCount(const GWEN_TLV_LIST *l);

  GWEN_TLV_LIST_SORT_FN GWEN_TLV_List_SetSortFn(GWEN_TLV_LIST *l, GWEN_TLV_LIST_SORT_FN fn);

  void GWEN_TLV_List_Sort(GWEN_TLV_LIST *l, int ascending);


#ifdef __cplusplus
}
#endif


#endif



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_URL_LIST2_H
#define GWEN_URL_LIST2_H


#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_URL_LIST2 GWEN_URL_LIST2;

  typedef struct GWEN_URL_LIST2_ITERATOR GWEN_URL_LIST2_ITERATOR;

  typedef GWEN_URL* (GWEN_URL_LIST2_FOREACH)(GWEN_URL *element,
                                                 void *user_data);

  GWEN_URL_LIST2 *GWEN_Url_List2_new(); 

  void GWEN_Url_List2_free(GWEN_URL_LIST2 *l); 

  void GWEN_Url_List2_Dump(GWEN_URL_LIST2 *l, FILE *f, unsigned int indent); 

  void GWEN_Url_List2_PushBack(GWEN_URL_LIST2 *l, GWEN_URL *p); 
   
  void GWEN_Url_List2_PushFront(GWEN_URL_LIST2 *l, GWEN_URL *p); 

  GWEN_URL *GWEN_Url_List2_GetFront(GWEN_URL_LIST2 *l); 
   
  GWEN_URL *GWEN_Url_List2_GetBack(GWEN_URL_LIST2 *l); 

  void GWEN_Url_List2_Erase(GWEN_URL_LIST2 *l,
                               GWEN_URL_LIST2_ITERATOR *it);

  unsigned int GWEN_Url_List2_GetSize(GWEN_URL_LIST2 *l); 

  void GWEN_Url_List2_PopBack(GWEN_URL_LIST2 *l); 
   
  void GWEN_Url_List2_PopFront(GWEN_URL_LIST2 *l); 

  void GWEN_Url_List2_Clear(GWEN_URL_LIST2 *l); 

  GWEN_URL_LIST2_ITERATOR *GWEN_Url_List2_First(GWEN_URL_LIST2 *l); 
   
  GWEN_URL_LIST2_ITERATOR *GWEN_Url_List2_Last(GWEN_URL_LIST2 *l); 

  GWEN_URL_LIST2_ITERATOR *GWEN_Url_List2Iterator_new(GWEN_URL_LIST2 *l);

  void GWEN_Url_List2Iterator_free(GWEN_URL_LIST2_ITERATOR *li); 

  GWEN_URL *GWEN_Url_List2Iterator_Previous(GWEN_URL_LIST2_ITERATOR *li); 
   
  GWEN_URL *GWEN_Url_List2Iterator_Next(GWEN_URL_LIST2_ITERATOR *li); 

  GWEN_URL *GWEN_Url_List2Iterator_Data(GWEN_URL_LIST2_ITERATOR *li); 

  GWEN_URL *GWEN_Url_List2_ForEach(GWEN_URL_LIST2 *list,
                                        GWEN_URL_LIST2_FOREACH func,
                                        void *user_data);


  typedef struct GWEN_URL_CONSTLIST2 GWEN_URL_CONSTLIST2; 
  typedef struct GWEN_URL_CONSTLIST2_ITERATOR GWEN_URL_CONSTLIST2_ITERATOR; 
  typedef const GWEN_URL*
    (GWEN_URL_CONSTLIST2_FOREACH)(const GWEN_URL *element,
                                    void *user_data);
  
   
  GWEN_URL_CONSTLIST2 *GWEN_Url_ConstList2_new(); 
   
  void GWEN_Url_ConstList2_free(GWEN_URL_CONSTLIST2 *l); 
   
  void GWEN_Url_ConstList2_PushBack(GWEN_URL_CONSTLIST2 *l, const GWEN_URL *p); 
   
  void GWEN_Url_ConstList2_PushFront(GWEN_URL_CONSTLIST2 *l, const GWEN_URL *p); 
   
  const GWEN_URL *GWEN_Url_ConstList2_GetFront(GWEN_URL_CONSTLIST2 *l); 
   
  const GWEN_URL *GWEN_Url_ConstList2_GetBack(GWEN_URL_CONSTLIST2 *l); 
   
  unsigned int GWEN_Url_ConstList2_GetSize(GWEN_URL_CONSTLIST2 *l); 
   
  void GWEN_Url_ConstList2_PopBack(GWEN_URL_CONSTLIST2 *l); 
   
  void GWEN_Url_ConstList2_PopFront(GWEN_URL_CONSTLIST2 *l); 
   
  void GWEN_Url_ConstList2_Clear(GWEN_URL_CONSTLIST2 *l); 
   
  GWEN_URL_CONSTLIST2_ITERATOR *GWEN_Url_ConstList2_First(GWEN_URL_CONSTLIST2 *l); 
   
  GWEN_URL_CONSTLIST2_ITERATOR *GWEN_Url_ConstList2_Last(GWEN_URL_CONSTLIST2 *l); 
   
  GWEN_URL_CONSTLIST2_ITERATOR *GWEN_Url_ConstList2Iterator_new(GWEN_URL_CONSTLIST2 *l); 
   
  void GWEN_Url_ConstList2Iterator_free(GWEN_URL_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_URL *GWEN_Url_ConstList2Iterator_Previous(GWEN_URL_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_URL *GWEN_Url_ConstList2Iterator_Next(GWEN_URL_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_URL *GWEN_Url_ConstList2Iterator_Data(GWEN_URL_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_URL *GWEN_Url_ConstList2_ForEach(GWEN_URL_CONSTLIST2 *list,
        GWEN_URL_CONSTLIST2_FOREACH func, void *user_data);


#ifdef __cplusplus
}
#endif


#endif /* GWEN_URL_LIST_H */



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_URL_LIST1_H
#define GWEN_URL_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_URL_LIST_ELEMENT {
    uint32_t id;
    GWEN_URL *nextObject;
  } GWEN_URL_LIST__ELEMENT;

  typedef struct GWEN_URL_LIST GWEN_URL_LIST;

  typedef int GWENHYWFAR_CB (*GWEN_URL_LIST_SORT_FN)(const GWEN_URL *a, const GWEN_URL *b, int ascending);


  struct GWEN_URL_LIST {
    GWEN_URL *first;
    uint32_t count;
    uint32_t id;
  } GWEN_URL_LIST;

  void GWEN_Url_List_AddList(GWEN_URL_LIST *dst, GWEN_URL_LIST *l);

  void GWEN_Url_List_Add(GWEN_URL *element, GWEN_URL_LIST *list);

  void GWEN_Url_List_Insert(GWEN_URL *element, GWEN_URL_LIST *list);

  void GWEN_Url_List_Del(GWEN_URL *element);

  GWEN_URL* GWEN_Url_List_First(const GWEN_URL_LIST *l);

  GWEN_URL* GWEN_Url_List_Last(const GWEN_URL_LIST *l);

  void GWEN_Url_List_Clear(GWEN_URL_LIST *l);

  GWEN_URL_LIST* GWEN_Url_List_new();

  void GWEN_Url_List_free(GWEN_URL_LIST *l);

  GWEN_URL* GWEN_Url_List_Next(const GWEN_URL *element);

  GWEN_URL* GWEN_Url_List_Previous(const GWEN_URL *element);

  uint32_t GWEN_Url_List_GetCount(const GWEN_URL_LIST *l);

  GWEN_URL_LIST_SORT_FN GWEN_Url_List_SetSortFn(GWEN_URL_LIST *l, GWEN_URL_LIST_SORT_FN fn);

  void GWEN_Url_List_Sort(GWEN_URL_LIST *l, int ascending);


#ifdef __cplusplus
}
#endif


#endif



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_XMLNODE_NAMESPACE_LIST1_H
#define GWEN_XMLNODE_NAMESPACE_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_XMLNODE_NAMESPACE_LIST_ELEMENT {
    uint32_t id;
    GWEN_XMLNODE_NAMESPACE *nextObject;
  } GWEN_XMLNODE_NAMESPACE_LIST__ELEMENT;

  typedef struct GWEN_XMLNODE_NAMESPACE_LIST GWEN_XMLNODE_NAMESPACE_LIST;

  typedef int GWENHYWFAR_CB (*GWEN_XMLNODE_NAMESPACE_LIST_SORT_FN)(const GWEN_XMLNODE_NAMESPACE *a, const GWEN_XMLNODE_NAMESPACE *b, int ascending);


  struct GWEN_XMLNODE_NAMESPACE_LIST {
    GWEN_XMLNODE_NAMESPACE *first;
    uint32_t count;
    uint32_t id;
  } GWEN_XMLNODE_NAMESPACE_LIST;

  void GWEN_XMLNode_NameSpace_List_AddList(GWEN_XMLNODE_NAMESPACE_LIST *dst, GWEN_XMLNODE_NAMESPACE_LIST *l);

  void GWEN_XMLNode_NameSpace_List_Add(GWEN_XMLNODE_NAMESPACE *element, GWEN_XMLNODE_NAMESPACE_LIST *list);

  void GWEN_XMLNode_NameSpace_List_Insert(GWEN_XMLNODE_NAMESPACE *element, GWEN_XMLNODE_NAMESPACE_LIST *list);

  void GWEN_XMLNode_NameSpace_List_Del(GWEN_XMLNODE_NAMESPACE *element);

  GWEN_XMLNODE_NAMESPACE* GWEN_XMLNode_NameSpace_List_First(const GWEN_XMLNODE_NAMESPACE_LIST *l);

  GWEN_XMLNODE_NAMESPACE* GWEN_XMLNode_NameSpace_List_Last(const GWEN_XMLNODE_NAMESPACE_LIST *l);

  void GWEN_XMLNode_NameSpace_List_Clear(GWEN_XMLNODE_NAMESPACE_LIST *l);

  GWEN_XMLNODE_NAMESPACE_LIST* GWEN_XMLNode_NameSpace_List_new();

  void GWEN_XMLNode_NameSpace_List_free(GWEN_XMLNODE_NAMESPACE_LIST *l);

  GWEN_XMLNODE_NAMESPACE* GWEN_XMLNode_NameSpace_List_Next(const GWEN_XMLNODE_NAMESPACE *element);

  GWEN_XMLNODE_NAMESPACE* GWEN_XMLNode_NameSpace_List_Previous(const GWEN_XMLNODE_NAMESPACE *element);

  uint32_t GWEN_XMLNode_NameSpace_List_GetCount(const GWEN_XMLNODE_NAMESPACE_LIST *l);

  GWEN_XMLNODE_NAMESPACE_LIST_SORT_FN GWEN_XMLNode_NameSpace_List_SetSortFn(GWEN_XMLNODE_NAMESPACE_LIST *l, GWEN_XMLNODE_NAMESPACE_LIST_SORT_FN fn);

  void GWEN_XMLNode_NameSpace_List_Sort(GWEN_XMLNODE_NAMESPACE_LIST *l, int ascending);


#ifdef __cplusplus
}
#endif


#endif



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_XMLNODE_LIST2_H
#define GWEN_XMLNODE_LIST2_H


#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_XMLNODE_LIST2 GWEN_XMLNODE_LIST2;

  typedef struct GWEN_XMLNODE_LIST2_ITERATOR GWEN_XMLNODE_LIST2_ITERATOR;

  typedef GWEN_XMLNODE* (GWEN_XMLNODE_LIST2_FOREACH)(GWEN_XMLNODE *element,
                                                 void *user_data);

  GWEN_XMLNODE_LIST2 *GWEN_XMLNode_List2_new(); 

  void GWEN_XMLNode_List2_free(GWEN_XMLNODE_LIST2 *l); 

  void GWEN_XMLNode_List2_Dump(GWEN_XMLNODE_LIST2 *l, FILE *f, unsigned int indent); 

  void GWEN_XMLNode_List2_PushBack(GWEN_XMLNODE_LIST2 *l, GWEN_XMLNODE *p); 
   
  void GWEN_XMLNode_List2_PushFront(GWEN_XMLNODE_LIST2 *l, GWEN_XMLNODE *p); 

  GWEN_XMLNODE *GWEN_XMLNode_List2_GetFront(GWEN_XMLNODE_LIST2 *l); 
   
  GWEN_XMLNODE *GWEN_XMLNode_List2_GetBack(GWEN_XMLNODE_LIST2 *l); 

  void GWEN_XMLNode_List2_Erase(GWEN_XMLNODE_LIST2 *l,
                               GWEN_XMLNODE_LIST2_ITERATOR *it);

  unsigned int GWEN_XMLNode_List2_GetSize(GWEN_XMLNODE_LIST2 *l); 

  void GWEN_XMLNode_List2_PopBack(GWEN_XMLNODE_LIST2 *l); 
   
  void GWEN_XMLNode_List2_PopFront(GWEN_XMLNODE_LIST2 *l); 

  void GWEN_XMLNode_List2_Clear(GWEN_XMLNODE_LIST2 *l); 

  GWEN_XMLNODE_LIST2_ITERATOR *GWEN_XMLNode_List2_First(GWEN_XMLNODE_LIST2 *l); 
   
  GWEN_XMLNODE_LIST2_ITERATOR *GWEN_XMLNode_List2_Last(GWEN_XMLNODE_LIST2 *l); 

  GWEN_XMLNODE_LIST2_ITERATOR *GWEN_XMLNode_List2Iterator_new(GWEN_XMLNODE_LIST2 *l);

  void GWEN_XMLNode_List2Iterator_free(GWEN_XMLNODE_LIST2_ITERATOR *li); 

  GWEN_XMLNODE *GWEN_XMLNode_List2Iterator_Previous(GWEN_XMLNODE_LIST2_ITERATOR *li); 
   
  GWEN_XMLNODE *GWEN_XMLNode_List2Iterator_Next(GWEN_XMLNODE_LIST2_ITERATOR *li); 

  GWEN_XMLNODE *GWEN_XMLNode_List2Iterator_Data(GWEN_XMLNODE_LIST2_ITERATOR *li); 

  GWEN_XMLNODE *GWEN_XMLNode_List2_ForEach(GWEN_XMLNODE_LIST2 *list,
                                        GWEN_XMLNODE_LIST2_FOREACH func,
                                        void *user_data);


  typedef struct GWEN_XMLNODE_CONSTLIST2 GWEN_XMLNODE_CONSTLIST2; 
  typedef struct GWEN_XMLNODE_CONSTLIST2_ITERATOR GWEN_XMLNODE_CONSTLIST2_ITERATOR; 
  typedef const GWEN_XMLNODE*
    (GWEN_XMLNODE_CONSTLIST2_FOREACH)(const GWEN_XMLNODE *element,
                                    void *user_data);
  
   
  GWEN_XMLNODE_CONSTLIST2 *GWEN_XMLNode_ConstList2_new(); 
   
  void GWEN_XMLNode_ConstList2_free(GWEN_XMLNODE_CONSTLIST2 *l); 
   
  void GWEN_XMLNode_ConstList2_PushBack(GWEN_XMLNODE_CONSTLIST2 *l, const GWEN_XMLNODE *p); 
   
  void GWEN_XMLNode_ConstList2_PushFront(GWEN_XMLNODE_CONSTLIST2 *l, const GWEN_XMLNODE *p); 
   
  const GWEN_XMLNODE *GWEN_XMLNode_ConstList2_GetFront(GWEN_XMLNODE_CONSTLIST2 *l); 
   
  const GWEN_XMLNODE *GWEN_XMLNode_ConstList2_GetBack(GWEN_XMLNODE_CONSTLIST2 *l); 
   
  unsigned int GWEN_XMLNode_ConstList2_GetSize(GWEN_XMLNODE_CONSTLIST2 *l); 
   
  void GWEN_XMLNode_ConstList2_PopBack(GWEN_XMLNODE_CONSTLIST2 *l); 
   
  void GWEN_XMLNode_ConstList2_PopFront(GWEN_XMLNODE_CONSTLIST2 *l); 
   
  void GWEN_XMLNode_ConstList2_Clear(GWEN_XMLNODE_CONSTLIST2 *l); 
   
  GWEN_XMLNODE_CONSTLIST2_ITERATOR *GWEN_XMLNode_ConstList2_First(GWEN_XMLNODE_CONSTLIST2 *l); 
   
  GWEN_XMLNODE_CONSTLIST2_ITERATOR *GWEN_XMLNode_ConstList2_Last(GWEN_XMLNODE_CONSTLIST2 *l); 
   
  GWEN_XMLNODE_CONSTLIST2_ITERATOR *GWEN_XMLNode_ConstList2Iterator_new(GWEN_XMLNODE_CONSTLIST2 *l); 
   
  void GWEN_XMLNode_ConstList2Iterator_free(GWEN_XMLNODE_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_XMLNODE *GWEN_XMLNode_ConstList2Iterator_Previous(GWEN_XMLNODE_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_XMLNODE *GWEN_XMLNode_ConstList2Iterator_Next(GWEN_XMLNODE_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_XMLNODE *GWEN_XMLNode_ConstList2Iterator_Data(GWEN_XMLNODE_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_XMLNODE *GWEN_XMLNode_ConstList2_ForEach(GWEN_XMLNODE_CONSTLIST2 *list,
        GWEN_XMLNODE_CONSTLIST2_FOREACH func, void *user_data);


#ifdef __cplusplus
}
#endif


#endif /* GWEN_XMLNODE_LIST_H */



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_XMLNODE_LIST1_H
#define GWEN_XMLNODE_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_XMLNODE_LIST_ELEMENT {
    uint32_t id;
    GWEN_XMLNODE *nextObject;
  } GWEN_XMLNODE_LIST__ELEMENT;

  typedef struct GWEN_XMLNODE_LIST GWEN_XMLNODE_LIST;

  typedef int GWENHYWFAR_CB (*GWEN_XMLNODE_LIST_SORT_FN)(const GWEN_XMLNODE *a, const GWEN_XMLNODE *b, int ascending);


  struct GWEN_XMLNODE_LIST {
    GWEN_XMLNODE *first;
    uint32_t count;
    uint32_t id;
  } GWEN_XMLNODE_LIST;

  void GWEN_XMLNode_List_AddList(GWEN_XMLNODE_LIST *dst, GWEN_XMLNODE_LIST *l);

  void GWEN_XMLNode_List_Add(GWEN_XMLNODE *element, GWEN_XMLNODE_LIST *list);

  void GWEN_XMLNode_List_Insert(GWEN_XMLNODE *element, GWEN_XMLNODE_LIST *list);

  void GWEN_XMLNode_List_Del(GWEN_XMLNODE *element);

  GWEN_XMLNODE* GWEN_XMLNode_List_First(const GWEN_XMLNODE_LIST *l);

  GWEN_XMLNODE* GWEN_XMLNode_List_Last(const GWEN_XMLNODE_LIST *l);

  void GWEN_XMLNode_List_Clear(GWEN_XMLNODE_LIST *l);

  GWEN_XMLNODE_LIST* GWEN_XMLNode_List_new();

  void GWEN_XMLNode_List_free(GWEN_XMLNODE_LIST *l);

  GWEN_XMLNODE* GWEN_XMLNode_List_Next(const GWEN_XMLNODE *element);

  GWEN_XMLNODE* GWEN_XMLNode_List_Previous(const GWEN_XMLNODE *element);

  uint32_t GWEN_XMLNode_List_GetCount(const GWEN_XMLNODE_LIST *l);

  GWEN_XMLNODE_LIST_SORT_FN GWEN_XMLNode_List_SetSortFn(GWEN_XMLNODE_LIST *l, GWEN_XMLNODE_LIST_SORT_FN fn);

  void GWEN_XMLNode_List_Sort(GWEN_XMLNODE_LIST *l, int ascending);


#ifdef __cplusplus
}
#endif


#endif



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_XSD_NODE_LIST1_H
#define GWEN_XSD_NODE_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_XSD_NODE_LIST_ELEMENT {
    uint32_t id;
    GWEN_XSD_NODE *nextObject;
  } GWEN_XSD_NODE_LIST__ELEMENT;

  typedef struct GWEN_XSD_NODE_LIST GWEN_XSD_NODE_LIST;

  typedef int GWENHYWFAR_CB (*GWEN_XSD_NODE_LIST_SORT_FN)(const GWEN_XSD_NODE *a, const GWEN_XSD_NODE *b, int ascending);


  struct GWEN_XSD_NODE_LIST {
    GWEN_XSD_NODE *first;
    uint32_t count;
    uint32_t id;
  } GWEN_XSD_NODE_LIST;

  void GWEN_XsdNode_List_AddList(GWEN_XSD_NODE_LIST *dst, GWEN_XSD_NODE_LIST *l);

  void GWEN_XsdNode_List_Add(GWEN_XSD_NODE *element, GWEN_XSD_NODE_LIST *list);

  void GWEN_XsdNode_List_Insert(GWEN_XSD_NODE *element, GWEN_XSD_NODE_LIST *list);

  void GWEN_XsdNode_List_Del(GWEN_XSD_NODE *element);

  GWEN_XSD_NODE* GWEN_XsdNode_List_First(const GWEN_XSD_NODE_LIST *l);

  GWEN_XSD_NODE* GWEN_XsdNode_List_Last(const GWEN_XSD_NODE_LIST *l);

  void GWEN_XsdNode_List_Clear(GWEN_XSD_NODE_LIST *l);

  GWEN_XSD_NODE_LIST* GWEN_XsdNode_List_new();

  void GWEN_XsdNode_List_free(GWEN_XSD_NODE_LIST *l);

  GWEN_XSD_NODE* GWEN_XsdNode_List_Next(const GWEN_XSD_NODE *element);

  GWEN_XSD_NODE* GWEN_XsdNode_List_Previous(const GWEN_XSD_NODE *element);

  uint32_t GWEN_XsdNode_List_GetCount(const GWEN_XSD_NODE_LIST *l);

  GWEN_XSD_NODE_LIST_SORT_FN GWEN_XsdNode_List_SetSortFn(GWEN_XSD_NODE_LIST *l, GWEN_XSD_NODE_LIST_SORT_FN fn);

  void GWEN_XsdNode_List_Sort(GWEN_XSD_NODE_LIST *l, int ascending);


#ifdef __cplusplus
}
#endif


#endif



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_PARSER_ELEMENT_LIST2_H
#define GWEN_PARSER_ELEMENT_LIST2_H


#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_PARSER_ELEMENT_LIST2 GWEN_PARSER_ELEMENT_LIST2;

  typedef struct GWEN_PARSER_ELEMENT_LIST2_ITERATOR GWEN_PARSER_ELEMENT_LIST2_ITERATOR;

  typedef GWEN_PARSER_ELEMENT* (GWEN_PARSER_ELEMENT_LIST2_FOREACH)(GWEN_PARSER_ELEMENT *element,
                                                 void *user_data);

  GWEN_PARSER_ELEMENT_LIST2 *GWEN_ParserElement_List2_new(); 

  void GWEN_ParserElement_List2_free(GWEN_PARSER_ELEMENT_LIST2 *l); 

  void GWEN_ParserElement_List2_Dump(GWEN_PARSER_ELEMENT_LIST2 *l, FILE *f, unsigned int indent); 

  void GWEN_ParserElement_List2_PushBack(GWEN_PARSER_ELEMENT_LIST2 *l, GWEN_PARSER_ELEMENT *p); 
   
  void GWEN_ParserElement_List2_PushFront(GWEN_PARSER_ELEMENT_LIST2 *l, GWEN_PARSER_ELEMENT *p); 

  GWEN_PARSER_ELEMENT *GWEN_ParserElement_List2_GetFront(GWEN_PARSER_ELEMENT_LIST2 *l); 
   
  GWEN_PARSER_ELEMENT *GWEN_ParserElement_List2_GetBack(GWEN_PARSER_ELEMENT_LIST2 *l); 

  void GWEN_ParserElement_List2_Erase(GWEN_PARSER_ELEMENT_LIST2 *l,
                               GWEN_PARSER_ELEMENT_LIST2_ITERATOR *it);

  unsigned int GWEN_ParserElement_List2_GetSize(GWEN_PARSER_ELEMENT_LIST2 *l); 

  void GWEN_ParserElement_List2_PopBack(GWEN_PARSER_ELEMENT_LIST2 *l); 
   
  void GWEN_ParserElement_List2_PopFront(GWEN_PARSER_ELEMENT_LIST2 *l); 

  void GWEN_ParserElement_List2_Clear(GWEN_PARSER_ELEMENT_LIST2 *l); 

  GWEN_PARSER_ELEMENT_LIST2_ITERATOR *GWEN_ParserElement_List2_First(GWEN_PARSER_ELEMENT_LIST2 *l); 
   
  GWEN_PARSER_ELEMENT_LIST2_ITERATOR *GWEN_ParserElement_List2_Last(GWEN_PARSER_ELEMENT_LIST2 *l); 

  GWEN_PARSER_ELEMENT_LIST2_ITERATOR *GWEN_ParserElement_List2Iterator_new(GWEN_PARSER_ELEMENT_LIST2 *l);

  void GWEN_ParserElement_List2Iterator_free(GWEN_PARSER_ELEMENT_LIST2_ITERATOR *li); 

  GWEN_PARSER_ELEMENT *GWEN_ParserElement_List2Iterator_Previous(GWEN_PARSER_ELEMENT_LIST2_ITERATOR *li); 
   
  GWEN_PARSER_ELEMENT *GWEN_ParserElement_List2Iterator_Next(GWEN_PARSER_ELEMENT_LIST2_ITERATOR *li); 

  GWEN_PARSER_ELEMENT *GWEN_ParserElement_List2Iterator_Data(GWEN_PARSER_ELEMENT_LIST2_ITERATOR *li); 

  GWEN_PARSER_ELEMENT *GWEN_ParserElement_List2_ForEach(GWEN_PARSER_ELEMENT_LIST2 *list,
                                        GWEN_PARSER_ELEMENT_LIST2_FOREACH func,
                                        void *user_data);


  typedef struct GWEN_PARSER_ELEMENT_CONSTLIST2 GWEN_PARSER_ELEMENT_CONSTLIST2; 
  typedef struct GWEN_PARSER_ELEMENT_CONSTLIST2_ITERATOR GWEN_PARSER_ELEMENT_CONSTLIST2_ITERATOR; 
  typedef const GWEN_PARSER_ELEMENT*
    (GWEN_PARSER_ELEMENT_CONSTLIST2_FOREACH)(const GWEN_PARSER_ELEMENT *element,
                                    void *user_data);
  
   
  GWEN_PARSER_ELEMENT_CONSTLIST2 *GWEN_ParserElement_ConstList2_new(); 
   
  void GWEN_ParserElement_ConstList2_free(GWEN_PARSER_ELEMENT_CONSTLIST2 *l); 
   
  void GWEN_ParserElement_ConstList2_PushBack(GWEN_PARSER_ELEMENT_CONSTLIST2 *l, const GWEN_PARSER_ELEMENT *p); 
   
  void GWEN_ParserElement_ConstList2_PushFront(GWEN_PARSER_ELEMENT_CONSTLIST2 *l, const GWEN_PARSER_ELEMENT *p); 
   
  const GWEN_PARSER_ELEMENT *GWEN_ParserElement_ConstList2_GetFront(GWEN_PARSER_ELEMENT_CONSTLIST2 *l); 
   
  const GWEN_PARSER_ELEMENT *GWEN_ParserElement_ConstList2_GetBack(GWEN_PARSER_ELEMENT_CONSTLIST2 *l); 
   
  unsigned int GWEN_ParserElement_ConstList2_GetSize(GWEN_PARSER_ELEMENT_CONSTLIST2 *l); 
   
  void GWEN_ParserElement_ConstList2_PopBack(GWEN_PARSER_ELEMENT_CONSTLIST2 *l); 
   
  void GWEN_ParserElement_ConstList2_PopFront(GWEN_PARSER_ELEMENT_CONSTLIST2 *l); 
   
  void GWEN_ParserElement_ConstList2_Clear(GWEN_PARSER_ELEMENT_CONSTLIST2 *l); 
   
  GWEN_PARSER_ELEMENT_CONSTLIST2_ITERATOR *GWEN_ParserElement_ConstList2_First(GWEN_PARSER_ELEMENT_CONSTLIST2 *l); 
   
  GWEN_PARSER_ELEMENT_CONSTLIST2_ITERATOR *GWEN_ParserElement_ConstList2_Last(GWEN_PARSER_ELEMENT_CONSTLIST2 *l); 
   
  GWEN_PARSER_ELEMENT_CONSTLIST2_ITERATOR *GWEN_ParserElement_ConstList2Iterator_new(GWEN_PARSER_ELEMENT_CONSTLIST2 *l); 
   
  void GWEN_ParserElement_ConstList2Iterator_free(GWEN_PARSER_ELEMENT_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_PARSER_ELEMENT *GWEN_ParserElement_ConstList2Iterator_Previous(GWEN_PARSER_ELEMENT_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_PARSER_ELEMENT *GWEN_ParserElement_ConstList2Iterator_Next(GWEN_PARSER_ELEMENT_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_PARSER_ELEMENT *GWEN_ParserElement_ConstList2Iterator_Data(GWEN_PARSER_ELEMENT_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_PARSER_ELEMENT *GWEN_ParserElement_ConstList2_ForEach(GWEN_PARSER_ELEMENT_CONSTLIST2 *list,
        GWEN_PARSER_ELEMENT_CONSTLIST2_FOREACH func, void *user_data);


#ifdef __cplusplus
}
#endif


#endif /* GWEN_PARSER_ELEMENT_LIST_H */



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_PARSER_ELEMENT_LIST1_H
#define GWEN_PARSER_ELEMENT_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_PARSER_ELEMENT_LIST_ELEMENT {
    uint32_t id;
    GWEN_PARSER_ELEMENT *nextObject;
  } GWEN_PARSER_ELEMENT_LIST__ELEMENT;

  typedef struct GWEN_PARSER_ELEMENT_LIST GWEN_PARSER_ELEMENT_LIST;

  typedef int GWENHYWFAR_CB (*GWEN_PARSER_ELEMENT_LIST_SORT_FN)(const GWEN_PARSER_ELEMENT *a, const GWEN_PARSER_ELEMENT *b, int ascending);


  struct GWEN_PARSER_ELEMENT_LIST {
    GWEN_PARSER_ELEMENT *first;
    uint32_t count;
    uint32_t id;
  } GWEN_PARSER_ELEMENT_LIST;

  void GWEN_ParserElement_List_AddList(GWEN_PARSER_ELEMENT_LIST *dst, GWEN_PARSER_ELEMENT_LIST *l);

  void GWEN_ParserElement_List_Add(GWEN_PARSER_ELEMENT *element, GWEN_PARSER_ELEMENT_LIST *list);

  void GWEN_ParserElement_List_Insert(GWEN_PARSER_ELEMENT *element, GWEN_PARSER_ELEMENT_LIST *list);

  void GWEN_ParserElement_List_Del(GWEN_PARSER_ELEMENT *element);

  GWEN_PARSER_ELEMENT* GWEN_ParserElement_List_First(const GWEN_PARSER_ELEMENT_LIST *l);

  GWEN_PARSER_ELEMENT* GWEN_ParserElement_List_Last(const GWEN_PARSER_ELEMENT_LIST *l);

  void GWEN_ParserElement_List_Clear(GWEN_PARSER_ELEMENT_LIST *l);

  GWEN_PARSER_ELEMENT_LIST* GWEN_ParserElement_List_new();

  void GWEN_ParserElement_List_free(GWEN_PARSER_ELEMENT_LIST *l);

  GWEN_PARSER_ELEMENT* GWEN_ParserElement_List_Next(const GWEN_PARSER_ELEMENT *element);

  GWEN_PARSER_ELEMENT* GWEN_ParserElement_List_Previous(const GWEN_PARSER_ELEMENT *element);

  uint32_t GWEN_ParserElement_List_GetCount(const GWEN_PARSER_ELEMENT_LIST *l);

  GWEN_PARSER_ELEMENT_LIST_SORT_FN GWEN_ParserElement_List_SetSortFn(GWEN_PARSER_ELEMENT_LIST *l, GWEN_PARSER_ELEMENT_LIST_SORT_FN fn);

  void GWEN_ParserElement_List_Sort(GWEN_PARSER_ELEMENT_LIST *l, int ascending);


#ifdef __cplusplus
}
#endif


#endif



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_SAR_FILEHEADER_LIST2_H
#define GWEN_SAR_FILEHEADER_LIST2_H


#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_SAR_FILEHEADER_LIST2 GWEN_SAR_FILEHEADER_LIST2;

  typedef struct GWEN_SAR_FILEHEADER_LIST2_ITERATOR GWEN_SAR_FILEHEADER_LIST2_ITERATOR;

  typedef GWEN_SAR_FILEHEADER* (GWEN_SAR_FILEHEADER_LIST2_FOREACH)(GWEN_SAR_FILEHEADER *element,
                                                 void *user_data);

  GWEN_SAR_FILEHEADER_LIST2 *GWEN_SarFileHeader_List2_new(); 

  void GWEN_SarFileHeader_List2_free(GWEN_SAR_FILEHEADER_LIST2 *l); 

  void GWEN_SarFileHeader_List2_Dump(GWEN_SAR_FILEHEADER_LIST2 *l, FILE *f, unsigned int indent); 

  void GWEN_SarFileHeader_List2_PushBack(GWEN_SAR_FILEHEADER_LIST2 *l, GWEN_SAR_FILEHEADER *p); 
   
  void GWEN_SarFileHeader_List2_PushFront(GWEN_SAR_FILEHEADER_LIST2 *l, GWEN_SAR_FILEHEADER *p); 

  GWEN_SAR_FILEHEADER *GWEN_SarFileHeader_List2_GetFront(GWEN_SAR_FILEHEADER_LIST2 *l); 
   
  GWEN_SAR_FILEHEADER *GWEN_SarFileHeader_List2_GetBack(GWEN_SAR_FILEHEADER_LIST2 *l); 

  void GWEN_SarFileHeader_List2_Erase(GWEN_SAR_FILEHEADER_LIST2 *l,
                               GWEN_SAR_FILEHEADER_LIST2_ITERATOR *it);

  unsigned int GWEN_SarFileHeader_List2_GetSize(GWEN_SAR_FILEHEADER_LIST2 *l); 

  void GWEN_SarFileHeader_List2_PopBack(GWEN_SAR_FILEHEADER_LIST2 *l); 
   
  void GWEN_SarFileHeader_List2_PopFront(GWEN_SAR_FILEHEADER_LIST2 *l); 

  void GWEN_SarFileHeader_List2_Clear(GWEN_SAR_FILEHEADER_LIST2 *l); 

  GWEN_SAR_FILEHEADER_LIST2_ITERATOR *GWEN_SarFileHeader_List2_First(GWEN_SAR_FILEHEADER_LIST2 *l); 
   
  GWEN_SAR_FILEHEADER_LIST2_ITERATOR *GWEN_SarFileHeader_List2_Last(GWEN_SAR_FILEHEADER_LIST2 *l); 

  GWEN_SAR_FILEHEADER_LIST2_ITERATOR *GWEN_SarFileHeader_List2Iterator_new(GWEN_SAR_FILEHEADER_LIST2 *l);

  void GWEN_SarFileHeader_List2Iterator_free(GWEN_SAR_FILEHEADER_LIST2_ITERATOR *li); 

  GWEN_SAR_FILEHEADER *GWEN_SarFileHeader_List2Iterator_Previous(GWEN_SAR_FILEHEADER_LIST2_ITERATOR *li); 
   
  GWEN_SAR_FILEHEADER *GWEN_SarFileHeader_List2Iterator_Next(GWEN_SAR_FILEHEADER_LIST2_ITERATOR *li); 

  GWEN_SAR_FILEHEADER *GWEN_SarFileHeader_List2Iterator_Data(GWEN_SAR_FILEHEADER_LIST2_ITERATOR *li); 

  GWEN_SAR_FILEHEADER *GWEN_SarFileHeader_List2_ForEach(GWEN_SAR_FILEHEADER_LIST2 *list,
                                        GWEN_SAR_FILEHEADER_LIST2_FOREACH func,
                                        void *user_data);


  typedef struct GWEN_SAR_FILEHEADER_CONSTLIST2 GWEN_SAR_FILEHEADER_CONSTLIST2; 
  typedef struct GWEN_SAR_FILEHEADER_CONSTLIST2_ITERATOR GWEN_SAR_FILEHEADER_CONSTLIST2_ITERATOR; 
  typedef const GWEN_SAR_FILEHEADER*
    (GWEN_SAR_FILEHEADER_CONSTLIST2_FOREACH)(const GWEN_SAR_FILEHEADER *element,
                                    void *user_data);
  
   
  GWEN_SAR_FILEHEADER_CONSTLIST2 *GWEN_SarFileHeader_ConstList2_new(); 
   
  void GWEN_SarFileHeader_ConstList2_free(GWEN_SAR_FILEHEADER_CONSTLIST2 *l); 
   
  void GWEN_SarFileHeader_ConstList2_PushBack(GWEN_SAR_FILEHEADER_CONSTLIST2 *l, const GWEN_SAR_FILEHEADER *p); 
   
  void GWEN_SarFileHeader_ConstList2_PushFront(GWEN_SAR_FILEHEADER_CONSTLIST2 *l, const GWEN_SAR_FILEHEADER *p); 
   
  const GWEN_SAR_FILEHEADER *GWEN_SarFileHeader_ConstList2_GetFront(GWEN_SAR_FILEHEADER_CONSTLIST2 *l); 
   
  const GWEN_SAR_FILEHEADER *GWEN_SarFileHeader_ConstList2_GetBack(GWEN_SAR_FILEHEADER_CONSTLIST2 *l); 
   
  unsigned int GWEN_SarFileHeader_ConstList2_GetSize(GWEN_SAR_FILEHEADER_CONSTLIST2 *l); 
   
  void GWEN_SarFileHeader_ConstList2_PopBack(GWEN_SAR_FILEHEADER_CONSTLIST2 *l); 
   
  void GWEN_SarFileHeader_ConstList2_PopFront(GWEN_SAR_FILEHEADER_CONSTLIST2 *l); 
   
  void GWEN_SarFileHeader_ConstList2_Clear(GWEN_SAR_FILEHEADER_CONSTLIST2 *l); 
   
  GWEN_SAR_FILEHEADER_CONSTLIST2_ITERATOR *GWEN_SarFileHeader_ConstList2_First(GWEN_SAR_FILEHEADER_CONSTLIST2 *l); 
   
  GWEN_SAR_FILEHEADER_CONSTLIST2_ITERATOR *GWEN_SarFileHeader_ConstList2_Last(GWEN_SAR_FILEHEADER_CONSTLIST2 *l); 
   
  GWEN_SAR_FILEHEADER_CONSTLIST2_ITERATOR *GWEN_SarFileHeader_ConstList2Iterator_new(GWEN_SAR_FILEHEADER_CONSTLIST2 *l); 
   
  void GWEN_SarFileHeader_ConstList2Iterator_free(GWEN_SAR_FILEHEADER_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_SAR_FILEHEADER *GWEN_SarFileHeader_ConstList2Iterator_Previous(GWEN_SAR_FILEHEADER_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_SAR_FILEHEADER *GWEN_SarFileHeader_ConstList2Iterator_Next(GWEN_SAR_FILEHEADER_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_SAR_FILEHEADER *GWEN_SarFileHeader_ConstList2Iterator_Data(GWEN_SAR_FILEHEADER_CONSTLIST2_ITERATOR *li); 
   
  const GWEN_SAR_FILEHEADER *GWEN_SarFileHeader_ConstList2_ForEach(GWEN_SAR_FILEHEADER_CONSTLIST2 *list,
        GWEN_SAR_FILEHEADER_CONSTLIST2_FOREACH func, void *user_data);


#ifdef __cplusplus
}
#endif


#endif /* GWEN_SAR_FILEHEADER_LIST_H */



/***************************************************************************
 $RCSfile$
 -------------------
 cvs         : $Id$
 begin       : Sat Jun 28 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GWEN_SAR_FILEHEADER_LIST1_H
#define GWEN_SAR_FILEHEADER_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct GWEN_SAR_FILEHEADER_LIST_ELEMENT {
    uint32_t id;
    GWEN_SAR_FILEHEADER *nextObject;
  } GWEN_SAR_FILEHEADER_LIST__ELEMENT;

  typedef struct GWEN_SAR_FILEHEADER_LIST GWEN_SAR_FILEHEADER_LIST;

  typedef int GWENHYWFAR_CB (*GWEN_SAR_FILEHEADER_LIST_SORT_FN)(const GWEN_SAR_FILEHEADER *a, const GWEN_SAR_FILEHEADER *b, int ascending);


  struct GWEN_SAR_FILEHEADER_LIST {
    GWEN_SAR_FILEHEADER *first;
    uint32_t count;
    uint32_t id;
  } GWEN_SAR_FILEHEADER_LIST;

  void GWEN_SarFileHeader_List_AddList(GWEN_SAR_FILEHEADER_LIST *dst, GWEN_SAR_FILEHEADER_LIST *l);

  void GWEN_SarFileHeader_List_Add(GWEN_SAR_FILEHEADER *element, GWEN_SAR_FILEHEADER_LIST *list);

  void GWEN_SarFileHeader_List_Insert(GWEN_SAR_FILEHEADER *element, GWEN_SAR_FILEHEADER_LIST *list);

  void GWEN_SarFileHeader_List_Del(GWEN_SAR_FILEHEADER *element);

  GWEN_SAR_FILEHEADER* GWEN_SarFileHeader_List_First(const GWEN_SAR_FILEHEADER_LIST *l);

  GWEN_SAR_FILEHEADER* GWEN_SarFileHeader_List_Last(const GWEN_SAR_FILEHEADER_LIST *l);

  void GWEN_SarFileHeader_List_Clear(GWEN_SAR_FILEHEADER_LIST *l);

  GWEN_SAR_FILEHEADER_LIST* GWEN_SarFileHeader_List_new();

  void GWEN_SarFileHeader_List_free(GWEN_SAR_FILEHEADER_LIST *l);

  GWEN_SAR_FILEHEADER* GWEN_SarFileHeader_List_Next(const GWEN_SAR_FILEHEADER *element);

  GWEN_SAR_FILEHEADER* GWEN_SarFileHeader_List_Previous(const GWEN_SAR_FILEHEADER *element);

  uint32_t GWEN_SarFileHeader_List_GetCount(const GWEN_SAR_FILEHEADER_LIST *l);

  GWEN_SAR_FILEHEADER_LIST_SORT_FN GWEN_SarFileHeader_List_SetSortFn(GWEN_SAR_FILEHEADER_LIST *l, GWEN_SAR_FILEHEADER_LIST_SORT_FN fn);

  void GWEN_SarFileHeader_List_Sort(GWEN_SAR_FILEHEADER_LIST *l, int ascending);


#ifdef __cplusplus
}
#endif


#endif