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 OH_INSTITUTE_SPEC_LIST2_H
#define OH_INSTITUTE_SPEC_LIST2_H


#ifdef __cplusplus
extern "C" {
#endif

  typedef struct OH_INSTITUTE_SPEC_LIST2 OH_INSTITUTE_SPEC_LIST2;

  typedef struct OH_INSTITUTE_SPEC_LIST2_ITERATOR OH_INSTITUTE_SPEC_LIST2_ITERATOR;

  typedef OH_INSTITUTE_SPEC* (OH_INSTITUTE_SPEC_LIST2_FOREACH)(OH_INSTITUTE_SPEC *element,
                                                 void *user_data);

  OH_INSTITUTE_SPEC_LIST2 *OH_InstituteSpec_List2_new(); 

  void OH_InstituteSpec_List2_free(OH_INSTITUTE_SPEC_LIST2 *l); 

  void OH_InstituteSpec_List2_Dump(OH_INSTITUTE_SPEC_LIST2 *l, FILE *f, unsigned int indent); 

  void OH_InstituteSpec_List2_PushBack(OH_INSTITUTE_SPEC_LIST2 *l, OH_INSTITUTE_SPEC *p); 
   
  void OH_InstituteSpec_List2_PushFront(OH_INSTITUTE_SPEC_LIST2 *l, OH_INSTITUTE_SPEC *p); 

  OH_INSTITUTE_SPEC *OH_InstituteSpec_List2_GetFront(OH_INSTITUTE_SPEC_LIST2 *l); 
   
  OH_INSTITUTE_SPEC *OH_InstituteSpec_List2_GetBack(OH_INSTITUTE_SPEC_LIST2 *l); 

  void OH_InstituteSpec_List2_Erase(OH_INSTITUTE_SPEC_LIST2 *l,
                               OH_INSTITUTE_SPEC_LIST2_ITERATOR *it);

  unsigned int OH_InstituteSpec_List2_GetSize(OH_INSTITUTE_SPEC_LIST2 *l); 

  void OH_InstituteSpec_List2_PopBack(OH_INSTITUTE_SPEC_LIST2 *l); 
   
  void OH_InstituteSpec_List2_PopFront(OH_INSTITUTE_SPEC_LIST2 *l); 

  void OH_InstituteSpec_List2_Clear(OH_INSTITUTE_SPEC_LIST2 *l); 

  OH_INSTITUTE_SPEC_LIST2_ITERATOR *OH_InstituteSpec_List2_First(OH_INSTITUTE_SPEC_LIST2 *l); 
   
  OH_INSTITUTE_SPEC_LIST2_ITERATOR *OH_InstituteSpec_List2_Last(OH_INSTITUTE_SPEC_LIST2 *l); 

  OH_INSTITUTE_SPEC_LIST2_ITERATOR *OH_InstituteSpec_List2Iterator_new(OH_INSTITUTE_SPEC_LIST2 *l);

  void OH_InstituteSpec_List2Iterator_free(OH_INSTITUTE_SPEC_LIST2_ITERATOR *li); 

  OH_INSTITUTE_SPEC *OH_InstituteSpec_List2Iterator_Previous(OH_INSTITUTE_SPEC_LIST2_ITERATOR *li); 
   
  OH_INSTITUTE_SPEC *OH_InstituteSpec_List2Iterator_Next(OH_INSTITUTE_SPEC_LIST2_ITERATOR *li); 

  OH_INSTITUTE_SPEC *OH_InstituteSpec_List2Iterator_Data(OH_INSTITUTE_SPEC_LIST2_ITERATOR *li); 

  OH_INSTITUTE_SPEC *OH_InstituteSpec_List2_ForEach(OH_INSTITUTE_SPEC_LIST2 *list,
                                        OH_INSTITUTE_SPEC_LIST2_FOREACH func,
                                        void *user_data);


  typedef struct OH_INSTITUTE_SPEC_CONSTLIST2 OH_INSTITUTE_SPEC_CONSTLIST2; 
  typedef struct OH_INSTITUTE_SPEC_CONSTLIST2_ITERATOR OH_INSTITUTE_SPEC_CONSTLIST2_ITERATOR; 
  typedef const OH_INSTITUTE_SPEC*
    (OH_INSTITUTE_SPEC_CONSTLIST2_FOREACH)(const OH_INSTITUTE_SPEC *element,
                                    void *user_data);
  
   
  OH_INSTITUTE_SPEC_CONSTLIST2 *OH_InstituteSpec_ConstList2_new(); 
   
  void OH_InstituteSpec_ConstList2_free(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 
   
  void OH_InstituteSpec_ConstList2_PushBack(OH_INSTITUTE_SPEC_CONSTLIST2 *l, const OH_INSTITUTE_SPEC *p); 
   
  void OH_InstituteSpec_ConstList2_PushFront(OH_INSTITUTE_SPEC_CONSTLIST2 *l, const OH_INSTITUTE_SPEC *p); 
   
  const OH_INSTITUTE_SPEC *OH_InstituteSpec_ConstList2_GetFront(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 
   
  const OH_INSTITUTE_SPEC *OH_InstituteSpec_ConstList2_GetBack(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 
   
  unsigned int OH_InstituteSpec_ConstList2_GetSize(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 
   
  void OH_InstituteSpec_ConstList2_PopBack(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 
   
  void OH_InstituteSpec_ConstList2_PopFront(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 
   
  void OH_InstituteSpec_ConstList2_Clear(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 
   
  OH_INSTITUTE_SPEC_CONSTLIST2_ITERATOR *OH_InstituteSpec_ConstList2_First(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 
   
  OH_INSTITUTE_SPEC_CONSTLIST2_ITERATOR *OH_InstituteSpec_ConstList2_Last(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 
   
  OH_INSTITUTE_SPEC_CONSTLIST2_ITERATOR *OH_InstituteSpec_ConstList2Iterator_new(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 
   
  void OH_InstituteSpec_ConstList2Iterator_free(OH_INSTITUTE_SPEC_CONSTLIST2_ITERATOR *li); 
   
  const OH_INSTITUTE_SPEC *OH_InstituteSpec_ConstList2Iterator_Previous(OH_INSTITUTE_SPEC_CONSTLIST2_ITERATOR *li); 
   
  const OH_INSTITUTE_SPEC *OH_InstituteSpec_ConstList2Iterator_Next(OH_INSTITUTE_SPEC_CONSTLIST2_ITERATOR *li); 
   
  const OH_INSTITUTE_SPEC *OH_InstituteSpec_ConstList2Iterator_Data(OH_INSTITUTE_SPEC_CONSTLIST2_ITERATOR *li); 
   
  const OH_INSTITUTE_SPEC *OH_InstituteSpec_ConstList2_ForEach(OH_INSTITUTE_SPEC_CONSTLIST2 *list,
        OH_INSTITUTE_SPEC_CONSTLIST2_FOREACH func, void *user_data);


#ifdef __cplusplus
}
#endif


#endif /* OH_INSTITUTE_SPEC_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 OH_INSTITUTE_SPEC_LIST1_H
#define OH_INSTITUTE_SPEC_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct OH_INSTITUTE_SPEC_LIST_ELEMENT {
    uint32_t id;
    OH_INSTITUTE_SPEC *nextObject;
  } OH_INSTITUTE_SPEC_LIST__ELEMENT;

  typedef struct OH_INSTITUTE_SPEC_LIST OH_INSTITUTE_SPEC_LIST;

  typedef int GWENHYWFAR_CB (*OH_INSTITUTE_SPEC_LIST_SORT_FN)(const OH_INSTITUTE_SPEC *a, const OH_INSTITUTE_SPEC *b, int ascending);


  struct OH_INSTITUTE_SPEC_LIST {
    OH_INSTITUTE_SPEC *first;
    uint32_t count;
    uint32_t id;
  } OH_INSTITUTE_SPEC_LIST;

  void OH_InstituteSpec_List_AddList(OH_INSTITUTE_SPEC_LIST *dst, OH_INSTITUTE_SPEC_LIST *l);

  void OH_InstituteSpec_List_Add(OH_INSTITUTE_SPEC *element, OH_INSTITUTE_SPEC_LIST *list);

  void OH_InstituteSpec_List_Insert(OH_INSTITUTE_SPEC *element, OH_INSTITUTE_SPEC_LIST *list);

  void OH_InstituteSpec_List_Del(OH_INSTITUTE_SPEC *element);

  OH_INSTITUTE_SPEC* OH_InstituteSpec_List_First(const OH_INSTITUTE_SPEC_LIST *l);

  OH_INSTITUTE_SPEC* OH_InstituteSpec_List_Last(const OH_INSTITUTE_SPEC_LIST *l);

  void OH_InstituteSpec_List_Clear(OH_INSTITUTE_SPEC_LIST *l);

  OH_INSTITUTE_SPEC_LIST* OH_InstituteSpec_List_new();

  void OH_InstituteSpec_List_free(OH_INSTITUTE_SPEC_LIST *l);

  OH_INSTITUTE_SPEC* OH_InstituteSpec_List_Next(const OH_INSTITUTE_SPEC *element);

  OH_INSTITUTE_SPEC* OH_InstituteSpec_List_Previous(const OH_INSTITUTE_SPEC *element);

  uint32_t OH_InstituteSpec_List_GetCount(const OH_INSTITUTE_SPEC_LIST *l);

  OH_INSTITUTE_SPEC_LIST_SORT_FN OH_InstituteSpec_List_SetSortFn(OH_INSTITUTE_SPEC_LIST *l, OH_INSTITUTE_SPEC_LIST_SORT_FN fn);

  void OH_InstituteSpec_List_Sort(OH_INSTITUTE_SPEC_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 OH_INSTITUTE_DATA_LIST2_H
#define OH_INSTITUTE_DATA_LIST2_H


#ifdef __cplusplus
extern "C" {
#endif

  typedef struct OH_INSTITUTE_DATA_LIST2 OH_INSTITUTE_DATA_LIST2;

  typedef struct OH_INSTITUTE_DATA_LIST2_ITERATOR OH_INSTITUTE_DATA_LIST2_ITERATOR;

  typedef OH_INSTITUTE_DATA* (OH_INSTITUTE_DATA_LIST2_FOREACH)(OH_INSTITUTE_DATA *element,
                                                 void *user_data);

  OH_INSTITUTE_DATA_LIST2 *OH_InstituteData_List2_new(); 

  void OH_InstituteData_List2_free(OH_INSTITUTE_DATA_LIST2 *l); 

  void OH_InstituteData_List2_Dump(OH_INSTITUTE_DATA_LIST2 *l, FILE *f, unsigned int indent); 

  void OH_InstituteData_List2_PushBack(OH_INSTITUTE_DATA_LIST2 *l, OH_INSTITUTE_DATA *p); 
   
  void OH_InstituteData_List2_PushFront(OH_INSTITUTE_DATA_LIST2 *l, OH_INSTITUTE_DATA *p); 

  OH_INSTITUTE_DATA *OH_InstituteData_List2_GetFront(OH_INSTITUTE_DATA_LIST2 *l); 
   
  OH_INSTITUTE_DATA *OH_InstituteData_List2_GetBack(OH_INSTITUTE_DATA_LIST2 *l); 

  void OH_InstituteData_List2_Erase(OH_INSTITUTE_DATA_LIST2 *l,
                               OH_INSTITUTE_DATA_LIST2_ITERATOR *it);

  unsigned int OH_InstituteData_List2_GetSize(OH_INSTITUTE_DATA_LIST2 *l); 

  void OH_InstituteData_List2_PopBack(OH_INSTITUTE_DATA_LIST2 *l); 
   
  void OH_InstituteData_List2_PopFront(OH_INSTITUTE_DATA_LIST2 *l); 

  void OH_InstituteData_List2_Clear(OH_INSTITUTE_DATA_LIST2 *l); 

  OH_INSTITUTE_DATA_LIST2_ITERATOR *OH_InstituteData_List2_First(OH_INSTITUTE_DATA_LIST2 *l); 
   
  OH_INSTITUTE_DATA_LIST2_ITERATOR *OH_InstituteData_List2_Last(OH_INSTITUTE_DATA_LIST2 *l); 

  OH_INSTITUTE_DATA_LIST2_ITERATOR *OH_InstituteData_List2Iterator_new(OH_INSTITUTE_DATA_LIST2 *l);

  void OH_InstituteData_List2Iterator_free(OH_INSTITUTE_DATA_LIST2_ITERATOR *li); 

  OH_INSTITUTE_DATA *OH_InstituteData_List2Iterator_Previous(OH_INSTITUTE_DATA_LIST2_ITERATOR *li); 
   
  OH_INSTITUTE_DATA *OH_InstituteData_List2Iterator_Next(OH_INSTITUTE_DATA_LIST2_ITERATOR *li); 

  OH_INSTITUTE_DATA *OH_InstituteData_List2Iterator_Data(OH_INSTITUTE_DATA_LIST2_ITERATOR *li); 

  OH_INSTITUTE_DATA *OH_InstituteData_List2_ForEach(OH_INSTITUTE_DATA_LIST2 *list,
                                        OH_INSTITUTE_DATA_LIST2_FOREACH func,
                                        void *user_data);


  typedef struct OH_INSTITUTE_DATA_CONSTLIST2 OH_INSTITUTE_DATA_CONSTLIST2; 
  typedef struct OH_INSTITUTE_DATA_CONSTLIST2_ITERATOR OH_INSTITUTE_DATA_CONSTLIST2_ITERATOR; 
  typedef const OH_INSTITUTE_DATA*
    (OH_INSTITUTE_DATA_CONSTLIST2_FOREACH)(const OH_INSTITUTE_DATA *element,
                                    void *user_data);
  
   
  OH_INSTITUTE_DATA_CONSTLIST2 *OH_InstituteData_ConstList2_new(); 
   
  void OH_InstituteData_ConstList2_free(OH_INSTITUTE_DATA_CONSTLIST2 *l); 
   
  void OH_InstituteData_ConstList2_PushBack(OH_INSTITUTE_DATA_CONSTLIST2 *l, const OH_INSTITUTE_DATA *p); 
   
  void OH_InstituteData_ConstList2_PushFront(OH_INSTITUTE_DATA_CONSTLIST2 *l, const OH_INSTITUTE_DATA *p); 
   
  const OH_INSTITUTE_DATA *OH_InstituteData_ConstList2_GetFront(OH_INSTITUTE_DATA_CONSTLIST2 *l); 
   
  const OH_INSTITUTE_DATA *OH_InstituteData_ConstList2_GetBack(OH_INSTITUTE_DATA_CONSTLIST2 *l); 
   
  unsigned int OH_InstituteData_ConstList2_GetSize(OH_INSTITUTE_DATA_CONSTLIST2 *l); 
   
  void OH_InstituteData_ConstList2_PopBack(OH_INSTITUTE_DATA_CONSTLIST2 *l); 
   
  void OH_InstituteData_ConstList2_PopFront(OH_INSTITUTE_DATA_CONSTLIST2 *l); 
   
  void OH_InstituteData_ConstList2_Clear(OH_INSTITUTE_DATA_CONSTLIST2 *l); 
   
  OH_INSTITUTE_DATA_CONSTLIST2_ITERATOR *OH_InstituteData_ConstList2_First(OH_INSTITUTE_DATA_CONSTLIST2 *l); 
   
  OH_INSTITUTE_DATA_CONSTLIST2_ITERATOR *OH_InstituteData_ConstList2_Last(OH_INSTITUTE_DATA_CONSTLIST2 *l); 
   
  OH_INSTITUTE_DATA_CONSTLIST2_ITERATOR *OH_InstituteData_ConstList2Iterator_new(OH_INSTITUTE_DATA_CONSTLIST2 *l); 
   
  void OH_InstituteData_ConstList2Iterator_free(OH_INSTITUTE_DATA_CONSTLIST2_ITERATOR *li); 
   
  const OH_INSTITUTE_DATA *OH_InstituteData_ConstList2Iterator_Previous(OH_INSTITUTE_DATA_CONSTLIST2_ITERATOR *li); 
   
  const OH_INSTITUTE_DATA *OH_InstituteData_ConstList2Iterator_Next(OH_INSTITUTE_DATA_CONSTLIST2_ITERATOR *li); 
   
  const OH_INSTITUTE_DATA *OH_InstituteData_ConstList2Iterator_Data(OH_INSTITUTE_DATA_CONSTLIST2_ITERATOR *li); 
   
  const OH_INSTITUTE_DATA *OH_InstituteData_ConstList2_ForEach(OH_INSTITUTE_DATA_CONSTLIST2 *list,
        OH_INSTITUTE_DATA_CONSTLIST2_FOREACH func, void *user_data);


#ifdef __cplusplus
}
#endif


#endif /* OH_INSTITUTE_DATA_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 OH_INSTITUTE_DATA_LIST1_H
#define OH_INSTITUTE_DATA_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct OH_INSTITUTE_DATA_LIST_ELEMENT {
    uint32_t id;
    OH_INSTITUTE_DATA *nextObject;
  } OH_INSTITUTE_DATA_LIST__ELEMENT;

  typedef struct OH_INSTITUTE_DATA_LIST OH_INSTITUTE_DATA_LIST;

  typedef int GWENHYWFAR_CB (*OH_INSTITUTE_DATA_LIST_SORT_FN)(const OH_INSTITUTE_DATA *a, const OH_INSTITUTE_DATA *b, int ascending);


  struct OH_INSTITUTE_DATA_LIST {
    OH_INSTITUTE_DATA *first;
    uint32_t count;
    uint32_t id;
  } OH_INSTITUTE_DATA_LIST;

  void OH_InstituteData_List_AddList(OH_INSTITUTE_DATA_LIST *dst, OH_INSTITUTE_DATA_LIST *l);

  void OH_InstituteData_List_Add(OH_INSTITUTE_DATA *element, OH_INSTITUTE_DATA_LIST *list);

  void OH_InstituteData_List_Insert(OH_INSTITUTE_DATA *element, OH_INSTITUTE_DATA_LIST *list);

  void OH_InstituteData_List_Del(OH_INSTITUTE_DATA *element);

  OH_INSTITUTE_DATA* OH_InstituteData_List_First(const OH_INSTITUTE_DATA_LIST *l);

  OH_INSTITUTE_DATA* OH_InstituteData_List_Last(const OH_INSTITUTE_DATA_LIST *l);

  void OH_InstituteData_List_Clear(OH_INSTITUTE_DATA_LIST *l);

  OH_INSTITUTE_DATA_LIST* OH_InstituteData_List_new();

  void OH_InstituteData_List_free(OH_INSTITUTE_DATA_LIST *l);

  OH_INSTITUTE_DATA* OH_InstituteData_List_Next(const OH_INSTITUTE_DATA *element);

  OH_INSTITUTE_DATA* OH_InstituteData_List_Previous(const OH_INSTITUTE_DATA *element);

  uint32_t OH_InstituteData_List_GetCount(const OH_INSTITUTE_DATA_LIST *l);

  OH_INSTITUTE_DATA_LIST_SORT_FN OH_InstituteData_List_SetSortFn(OH_INSTITUTE_DATA_LIST *l, OH_INSTITUTE_DATA_LIST_SORT_FN fn);

  void OH_InstituteData_List_Sort(OH_INSTITUTE_DATA_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 EB_EU_LIST1_H
#define EB_EU_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct EB_EU_LIST_ELEMENT {
    uint32_t id;
    EB_EU *nextObject;
  } EB_EU_LIST__ELEMENT;

  typedef struct EB_EU_LIST EB_EU_LIST;

  typedef int GWENHYWFAR_CB (*EB_EU_LIST_SORT_FN)(const EB_EU *a, const EB_EU *b, int ascending);


  struct EB_EU_LIST {
    EB_EU *first;
    uint32_t count;
    uint32_t id;
  } EB_EU_LIST;

  void EB_Eu_List_AddList(EB_EU_LIST *dst, EB_EU_LIST *l);

  void EB_Eu_List_Add(EB_EU *element, EB_EU_LIST *list);

  void EB_Eu_List_Insert(EB_EU *element, EB_EU_LIST *list);

  void EB_Eu_List_Del(EB_EU *element);

  EB_EU* EB_Eu_List_First(const EB_EU_LIST *l);

  EB_EU* EB_Eu_List_Last(const EB_EU_LIST *l);

  void EB_Eu_List_Clear(EB_EU_LIST *l);

  EB_EU_LIST* EB_Eu_List_new();

  void EB_Eu_List_free(EB_EU_LIST *l);

  EB_EU* EB_Eu_List_Next(const EB_EU *element);

  EB_EU* EB_Eu_List_Previous(const EB_EU *element);

  uint32_t EB_Eu_List_GetCount(const EB_EU_LIST *l);

  EB_EU_LIST_SORT_FN EB_Eu_List_SetSortFn(EB_EU_LIST *l, EB_EU_LIST_SORT_FN fn);

  void EB_Eu_List_Sort(EB_EU_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 AH_TAN_METHOD_LIST2_H
#define AH_TAN_METHOD_LIST2_H


#ifdef __cplusplus
extern "C" {
#endif

  typedef struct AH_TAN_METHOD_LIST2 AH_TAN_METHOD_LIST2;

  typedef struct AH_TAN_METHOD_LIST2_ITERATOR AH_TAN_METHOD_LIST2_ITERATOR;

  typedef AH_TAN_METHOD* (AH_TAN_METHOD_LIST2_FOREACH)(AH_TAN_METHOD *element,
                                                 void *user_data);

  AH_TAN_METHOD_LIST2 *AH_TanMethod_List2_new(); 

  void AH_TanMethod_List2_free(AH_TAN_METHOD_LIST2 *l); 

  void AH_TanMethod_List2_Dump(AH_TAN_METHOD_LIST2 *l, FILE *f, unsigned int indent); 

  void AH_TanMethod_List2_PushBack(AH_TAN_METHOD_LIST2 *l, AH_TAN_METHOD *p); 
   
  void AH_TanMethod_List2_PushFront(AH_TAN_METHOD_LIST2 *l, AH_TAN_METHOD *p); 

  AH_TAN_METHOD *AH_TanMethod_List2_GetFront(AH_TAN_METHOD_LIST2 *l); 
   
  AH_TAN_METHOD *AH_TanMethod_List2_GetBack(AH_TAN_METHOD_LIST2 *l); 

  void AH_TanMethod_List2_Erase(AH_TAN_METHOD_LIST2 *l,
                               AH_TAN_METHOD_LIST2_ITERATOR *it);

  unsigned int AH_TanMethod_List2_GetSize(AH_TAN_METHOD_LIST2 *l); 

  void AH_TanMethod_List2_PopBack(AH_TAN_METHOD_LIST2 *l); 
   
  void AH_TanMethod_List2_PopFront(AH_TAN_METHOD_LIST2 *l); 

  void AH_TanMethod_List2_Clear(AH_TAN_METHOD_LIST2 *l); 

  AH_TAN_METHOD_LIST2_ITERATOR *AH_TanMethod_List2_First(AH_TAN_METHOD_LIST2 *l); 
   
  AH_TAN_METHOD_LIST2_ITERATOR *AH_TanMethod_List2_Last(AH_TAN_METHOD_LIST2 *l); 

  AH_TAN_METHOD_LIST2_ITERATOR *AH_TanMethod_List2Iterator_new(AH_TAN_METHOD_LIST2 *l);

  void AH_TanMethod_List2Iterator_free(AH_TAN_METHOD_LIST2_ITERATOR *li); 

  AH_TAN_METHOD *AH_TanMethod_List2Iterator_Previous(AH_TAN_METHOD_LIST2_ITERATOR *li); 
   
  AH_TAN_METHOD *AH_TanMethod_List2Iterator_Next(AH_TAN_METHOD_LIST2_ITERATOR *li); 

  AH_TAN_METHOD *AH_TanMethod_List2Iterator_Data(AH_TAN_METHOD_LIST2_ITERATOR *li); 

  AH_TAN_METHOD *AH_TanMethod_List2_ForEach(AH_TAN_METHOD_LIST2 *list,
                                        AH_TAN_METHOD_LIST2_FOREACH func,
                                        void *user_data);


  typedef struct AH_TAN_METHOD_CONSTLIST2 AH_TAN_METHOD_CONSTLIST2; 
  typedef struct AH_TAN_METHOD_CONSTLIST2_ITERATOR AH_TAN_METHOD_CONSTLIST2_ITERATOR; 
  typedef const AH_TAN_METHOD*
    (AH_TAN_METHOD_CONSTLIST2_FOREACH)(const AH_TAN_METHOD *element,
                                    void *user_data);
  
   
  AH_TAN_METHOD_CONSTLIST2 *AH_TanMethod_ConstList2_new(); 
   
  void AH_TanMethod_ConstList2_free(AH_TAN_METHOD_CONSTLIST2 *l); 
   
  void AH_TanMethod_ConstList2_PushBack(AH_TAN_METHOD_CONSTLIST2 *l, const AH_TAN_METHOD *p); 
   
  void AH_TanMethod_ConstList2_PushFront(AH_TAN_METHOD_CONSTLIST2 *l, const AH_TAN_METHOD *p); 
   
  const AH_TAN_METHOD *AH_TanMethod_ConstList2_GetFront(AH_TAN_METHOD_CONSTLIST2 *l); 
   
  const AH_TAN_METHOD *AH_TanMethod_ConstList2_GetBack(AH_TAN_METHOD_CONSTLIST2 *l); 
   
  unsigned int AH_TanMethod_ConstList2_GetSize(AH_TAN_METHOD_CONSTLIST2 *l); 
   
  void AH_TanMethod_ConstList2_PopBack(AH_TAN_METHOD_CONSTLIST2 *l); 
   
  void AH_TanMethod_ConstList2_PopFront(AH_TAN_METHOD_CONSTLIST2 *l); 
   
  void AH_TanMethod_ConstList2_Clear(AH_TAN_METHOD_CONSTLIST2 *l); 
   
  AH_TAN_METHOD_CONSTLIST2_ITERATOR *AH_TanMethod_ConstList2_First(AH_TAN_METHOD_CONSTLIST2 *l); 
   
  AH_TAN_METHOD_CONSTLIST2_ITERATOR *AH_TanMethod_ConstList2_Last(AH_TAN_METHOD_CONSTLIST2 *l); 
   
  AH_TAN_METHOD_CONSTLIST2_ITERATOR *AH_TanMethod_ConstList2Iterator_new(AH_TAN_METHOD_CONSTLIST2 *l); 
   
  void AH_TanMethod_ConstList2Iterator_free(AH_TAN_METHOD_CONSTLIST2_ITERATOR *li); 
   
  const AH_TAN_METHOD *AH_TanMethod_ConstList2Iterator_Previous(AH_TAN_METHOD_CONSTLIST2_ITERATOR *li); 
   
  const AH_TAN_METHOD *AH_TanMethod_ConstList2Iterator_Next(AH_TAN_METHOD_CONSTLIST2_ITERATOR *li); 
   
  const AH_TAN_METHOD *AH_TanMethod_ConstList2Iterator_Data(AH_TAN_METHOD_CONSTLIST2_ITERATOR *li); 
   
  const AH_TAN_METHOD *AH_TanMethod_ConstList2_ForEach(AH_TAN_METHOD_CONSTLIST2 *list,
        AH_TAN_METHOD_CONSTLIST2_FOREACH func, void *user_data);


#ifdef __cplusplus
}
#endif


#endif /* AH_TAN_METHOD_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 AH_TAN_METHOD_LIST1_H
#define AH_TAN_METHOD_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct AH_TAN_METHOD_LIST_ELEMENT {
    uint32_t id;
    AH_TAN_METHOD *nextObject;
  } AH_TAN_METHOD_LIST__ELEMENT;

  typedef struct AH_TAN_METHOD_LIST AH_TAN_METHOD_LIST;

  typedef int GWENHYWFAR_CB (*AH_TAN_METHOD_LIST_SORT_FN)(const AH_TAN_METHOD *a, const AH_TAN_METHOD *b, int ascending);


  struct AH_TAN_METHOD_LIST {
    AH_TAN_METHOD *first;
    uint32_t count;
    uint32_t id;
  } AH_TAN_METHOD_LIST;

  void AH_TanMethod_List_AddList(AH_TAN_METHOD_LIST *dst, AH_TAN_METHOD_LIST *l);

  void AH_TanMethod_List_Add(AH_TAN_METHOD *element, AH_TAN_METHOD_LIST *list);

  void AH_TanMethod_List_Insert(AH_TAN_METHOD *element, AH_TAN_METHOD_LIST *list);

  void AH_TanMethod_List_Del(AH_TAN_METHOD *element);

  AH_TAN_METHOD* AH_TanMethod_List_First(const AH_TAN_METHOD_LIST *l);

  AH_TAN_METHOD* AH_TanMethod_List_Last(const AH_TAN_METHOD_LIST *l);

  void AH_TanMethod_List_Clear(AH_TAN_METHOD_LIST *l);

  AH_TAN_METHOD_LIST* AH_TanMethod_List_new();

  void AH_TanMethod_List_free(AH_TAN_METHOD_LIST *l);

  AH_TAN_METHOD* AH_TanMethod_List_Next(const AH_TAN_METHOD *element);

  AH_TAN_METHOD* AH_TanMethod_List_Previous(const AH_TAN_METHOD *element);

  uint32_t AH_TanMethod_List_GetCount(const AH_TAN_METHOD_LIST *l);

  AH_TAN_METHOD_LIST_SORT_FN AH_TanMethod_List_SetSortFn(AH_TAN_METHOD_LIST *l, AH_TAN_METHOD_LIST_SORT_FN fn);

  void AH_TanMethod_List_Sort(AH_TAN_METHOD_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 AB_JOBQUEUE_LIST1_H
#define AB_JOBQUEUE_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct AB_JOBQUEUE_LIST_ELEMENT {
    uint32_t id;
    AB_JOBQUEUE *nextObject;
  } AB_JOBQUEUE_LIST__ELEMENT;

  typedef struct AB_JOBQUEUE_LIST AB_JOBQUEUE_LIST;

  typedef int GWENHYWFAR_CB (*AB_JOBQUEUE_LIST_SORT_FN)(const AB_JOBQUEUE *a, const AB_JOBQUEUE *b, int ascending);


  struct AB_JOBQUEUE_LIST {
    AB_JOBQUEUE *first;
    uint32_t count;
    uint32_t id;
  } AB_JOBQUEUE_LIST;

  void AB_JobQueue_List_AddList(AB_JOBQUEUE_LIST *dst, AB_JOBQUEUE_LIST *l);

  void AB_JobQueue_List_Add(AB_JOBQUEUE *element, AB_JOBQUEUE_LIST *list);

  void AB_JobQueue_List_Insert(AB_JOBQUEUE *element, AB_JOBQUEUE_LIST *list);

  void AB_JobQueue_List_Del(AB_JOBQUEUE *element);

  AB_JOBQUEUE* AB_JobQueue_List_First(const AB_JOBQUEUE_LIST *l);

  AB_JOBQUEUE* AB_JobQueue_List_Last(const AB_JOBQUEUE_LIST *l);

  void AB_JobQueue_List_Clear(AB_JOBQUEUE_LIST *l);

  AB_JOBQUEUE_LIST* AB_JobQueue_List_new();

  void AB_JobQueue_List_free(AB_JOBQUEUE_LIST *l);

  AB_JOBQUEUE* AB_JobQueue_List_Next(const AB_JOBQUEUE *element);

  AB_JOBQUEUE* AB_JobQueue_List_Previous(const AB_JOBQUEUE *element);

  uint32_t AB_JobQueue_List_GetCount(const AB_JOBQUEUE_LIST *l);

  AB_JOBQUEUE_LIST_SORT_FN AB_JobQueue_List_SetSortFn(AB_JOBQUEUE_LIST *l, AB_JOBQUEUE_LIST_SORT_FN fn);

  void AB_JobQueue_List_Sort(AB_JOBQUEUE_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 AB_CELLPHONE_PRODUCT_LIST2_H
#define AB_CELLPHONE_PRODUCT_LIST2_H


#ifdef __cplusplus
extern "C" {
#endif

  typedef struct AB_CELLPHONE_PRODUCT_LIST2 AB_CELLPHONE_PRODUCT_LIST2;

  typedef struct AB_CELLPHONE_PRODUCT_LIST2_ITERATOR AB_CELLPHONE_PRODUCT_LIST2_ITERATOR;

  typedef AB_CELLPHONE_PRODUCT* (AB_CELLPHONE_PRODUCT_LIST2_FOREACH)(AB_CELLPHONE_PRODUCT *element,
                                                 void *user_data);

  AB_CELLPHONE_PRODUCT_LIST2 *AB_CellPhoneProduct_List2_new(); 

  void AB_CellPhoneProduct_List2_free(AB_CELLPHONE_PRODUCT_LIST2 *l); 

  void AB_CellPhoneProduct_List2_Dump(AB_CELLPHONE_PRODUCT_LIST2 *l, FILE *f, unsigned int indent); 

  void AB_CellPhoneProduct_List2_PushBack(AB_CELLPHONE_PRODUCT_LIST2 *l, AB_CELLPHONE_PRODUCT *p); 
   
  void AB_CellPhoneProduct_List2_PushFront(AB_CELLPHONE_PRODUCT_LIST2 *l, AB_CELLPHONE_PRODUCT *p); 

  AB_CELLPHONE_PRODUCT *AB_CellPhoneProduct_List2_GetFront(AB_CELLPHONE_PRODUCT_LIST2 *l); 
   
  AB_CELLPHONE_PRODUCT *AB_CellPhoneProduct_List2_GetBack(AB_CELLPHONE_PRODUCT_LIST2 *l); 

  void AB_CellPhoneProduct_List2_Erase(AB_CELLPHONE_PRODUCT_LIST2 *l,
                               AB_CELLPHONE_PRODUCT_LIST2_ITERATOR *it);

  unsigned int AB_CellPhoneProduct_List2_GetSize(AB_CELLPHONE_PRODUCT_LIST2 *l); 

  void AB_CellPhoneProduct_List2_PopBack(AB_CELLPHONE_PRODUCT_LIST2 *l); 
   
  void AB_CellPhoneProduct_List2_PopFront(AB_CELLPHONE_PRODUCT_LIST2 *l); 

  void AB_CellPhoneProduct_List2_Clear(AB_CELLPHONE_PRODUCT_LIST2 *l); 

  AB_CELLPHONE_PRODUCT_LIST2_ITERATOR *AB_CellPhoneProduct_List2_First(AB_CELLPHONE_PRODUCT_LIST2 *l); 
   
  AB_CELLPHONE_PRODUCT_LIST2_ITERATOR *AB_CellPhoneProduct_List2_Last(AB_CELLPHONE_PRODUCT_LIST2 *l); 

  AB_CELLPHONE_PRODUCT_LIST2_ITERATOR *AB_CellPhoneProduct_List2Iterator_new(AB_CELLPHONE_PRODUCT_LIST2 *l);

  void AB_CellPhoneProduct_List2Iterator_free(AB_CELLPHONE_PRODUCT_LIST2_ITERATOR *li); 

  AB_CELLPHONE_PRODUCT *AB_CellPhoneProduct_List2Iterator_Previous(AB_CELLPHONE_PRODUCT_LIST2_ITERATOR *li); 
   
  AB_CELLPHONE_PRODUCT *AB_CellPhoneProduct_List2Iterator_Next(AB_CELLPHONE_PRODUCT_LIST2_ITERATOR *li); 

  AB_CELLPHONE_PRODUCT *AB_CellPhoneProduct_List2Iterator_Data(AB_CELLPHONE_PRODUCT_LIST2_ITERATOR *li); 

  AB_CELLPHONE_PRODUCT *AB_CellPhoneProduct_List2_ForEach(AB_CELLPHONE_PRODUCT_LIST2 *list,
                                        AB_CELLPHONE_PRODUCT_LIST2_FOREACH func,
                                        void *user_data);


  typedef struct AB_CELLPHONE_PRODUCT_CONSTLIST2 AB_CELLPHONE_PRODUCT_CONSTLIST2; 
  typedef struct AB_CELLPHONE_PRODUCT_CONSTLIST2_ITERATOR AB_CELLPHONE_PRODUCT_CONSTLIST2_ITERATOR; 
  typedef const AB_CELLPHONE_PRODUCT*
    (AB_CELLPHONE_PRODUCT_CONSTLIST2_FOREACH)(const AB_CELLPHONE_PRODUCT *element,
                                    void *user_data);
  
   
  AB_CELLPHONE_PRODUCT_CONSTLIST2 *AB_CellPhoneProduct_ConstList2_new(); 
   
  void AB_CellPhoneProduct_ConstList2_free(AB_CELLPHONE_PRODUCT_CONSTLIST2 *l); 
   
  void AB_CellPhoneProduct_ConstList2_PushBack(AB_CELLPHONE_PRODUCT_CONSTLIST2 *l, const AB_CELLPHONE_PRODUCT *p); 
   
  void AB_CellPhoneProduct_ConstList2_PushFront(AB_CELLPHONE_PRODUCT_CONSTLIST2 *l, const AB_CELLPHONE_PRODUCT *p); 
   
  const AB_CELLPHONE_PRODUCT *AB_CellPhoneProduct_ConstList2_GetFront(AB_CELLPHONE_PRODUCT_CONSTLIST2 *l); 
   
  const AB_CELLPHONE_PRODUCT *AB_CellPhoneProduct_ConstList2_GetBack(AB_CELLPHONE_PRODUCT_CONSTLIST2 *l); 
   
  unsigned int AB_CellPhoneProduct_ConstList2_GetSize(AB_CELLPHONE_PRODUCT_CONSTLIST2 *l); 
   
  void AB_CellPhoneProduct_ConstList2_PopBack(AB_CELLPHONE_PRODUCT_CONSTLIST2 *l); 
   
  void AB_CellPhoneProduct_ConstList2_PopFront(AB_CELLPHONE_PRODUCT_CONSTLIST2 *l); 
   
  void AB_CellPhoneProduct_ConstList2_Clear(AB_CELLPHONE_PRODUCT_CONSTLIST2 *l); 
   
  AB_CELLPHONE_PRODUCT_CONSTLIST2_ITERATOR *AB_CellPhoneProduct_ConstList2_First(AB_CELLPHONE_PRODUCT_CONSTLIST2 *l); 
   
  AB_CELLPHONE_PRODUCT_CONSTLIST2_ITERATOR *AB_CellPhoneProduct_ConstList2_Last(AB_CELLPHONE_PRODUCT_CONSTLIST2 *l); 
   
  AB_CELLPHONE_PRODUCT_CONSTLIST2_ITERATOR *AB_CellPhoneProduct_ConstList2Iterator_new(AB_CELLPHONE_PRODUCT_CONSTLIST2 *l); 
   
  void AB_CellPhoneProduct_ConstList2Iterator_free(AB_CELLPHONE_PRODUCT_CONSTLIST2_ITERATOR *li); 
   
  const AB_CELLPHONE_PRODUCT *AB_CellPhoneProduct_ConstList2Iterator_Previous(AB_CELLPHONE_PRODUCT_CONSTLIST2_ITERATOR *li); 
   
  const AB_CELLPHONE_PRODUCT *AB_CellPhoneProduct_ConstList2Iterator_Next(AB_CELLPHONE_PRODUCT_CONSTLIST2_ITERATOR *li); 
   
  const AB_CELLPHONE_PRODUCT *AB_CellPhoneProduct_ConstList2Iterator_Data(AB_CELLPHONE_PRODUCT_CONSTLIST2_ITERATOR *li); 
   
  const AB_CELLPHONE_PRODUCT *AB_CellPhoneProduct_ConstList2_ForEach(AB_CELLPHONE_PRODUCT_CONSTLIST2 *list,
        AB_CELLPHONE_PRODUCT_CONSTLIST2_FOREACH func, void *user_data);


#ifdef __cplusplus
}
#endif


#endif /* AB_CELLPHONE_PRODUCT_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 AB_CELLPHONE_PRODUCT_LIST1_H
#define AB_CELLPHONE_PRODUCT_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct AB_CELLPHONE_PRODUCT_LIST_ELEMENT {
    uint32_t id;
    AB_CELLPHONE_PRODUCT *nextObject;
  } AB_CELLPHONE_PRODUCT_LIST__ELEMENT;

  typedef struct AB_CELLPHONE_PRODUCT_LIST AB_CELLPHONE_PRODUCT_LIST;

  typedef int GWENHYWFAR_CB (*AB_CELLPHONE_PRODUCT_LIST_SORT_FN)(const AB_CELLPHONE_PRODUCT *a, const AB_CELLPHONE_PRODUCT *b, int ascending);


  struct AB_CELLPHONE_PRODUCT_LIST {
    AB_CELLPHONE_PRODUCT *first;
    uint32_t count;
    uint32_t id;
  } AB_CELLPHONE_PRODUCT_LIST;

  void AB_CellPhoneProduct_List_AddList(AB_CELLPHONE_PRODUCT_LIST *dst, AB_CELLPHONE_PRODUCT_LIST *l);

  void AB_CellPhoneProduct_List_Add(AB_CELLPHONE_PRODUCT *element, AB_CELLPHONE_PRODUCT_LIST *list);

  void AB_CellPhoneProduct_List_Insert(AB_CELLPHONE_PRODUCT *element, AB_CELLPHONE_PRODUCT_LIST *list);

  void AB_CellPhoneProduct_List_Del(AB_CELLPHONE_PRODUCT *element);

  AB_CELLPHONE_PRODUCT* AB_CellPhoneProduct_List_First(const AB_CELLPHONE_PRODUCT_LIST *l);

  AB_CELLPHONE_PRODUCT* AB_CellPhoneProduct_List_Last(const AB_CELLPHONE_PRODUCT_LIST *l);

  void AB_CellPhoneProduct_List_Clear(AB_CELLPHONE_PRODUCT_LIST *l);

  AB_CELLPHONE_PRODUCT_LIST* AB_CellPhoneProduct_List_new();

  void AB_CellPhoneProduct_List_free(AB_CELLPHONE_PRODUCT_LIST *l);

  AB_CELLPHONE_PRODUCT* AB_CellPhoneProduct_List_Next(const AB_CELLPHONE_PRODUCT *element);

  AB_CELLPHONE_PRODUCT* AB_CellPhoneProduct_List_Previous(const AB_CELLPHONE_PRODUCT *element);

  uint32_t AB_CellPhoneProduct_List_GetCount(const AB_CELLPHONE_PRODUCT_LIST *l);

  AB_CELLPHONE_PRODUCT_LIST_SORT_FN AB_CellPhoneProduct_List_SetSortFn(AB_CELLPHONE_PRODUCT_LIST *l, AB_CELLPHONE_PRODUCT_LIST_SORT_FN fn);

  void AB_CellPhoneProduct_List_Sort(AB_CELLPHONE_PRODUCT_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 AB_USERQUEUE_LIST1_H
#define AB_USERQUEUE_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct AB_USERQUEUE_LIST_ELEMENT {
    uint32_t id;
    AB_USERQUEUE *nextObject;
  } AB_USERQUEUE_LIST__ELEMENT;

  typedef struct AB_USERQUEUE_LIST AB_USERQUEUE_LIST;

  typedef int GWENHYWFAR_CB (*AB_USERQUEUE_LIST_SORT_FN)(const AB_USERQUEUE *a, const AB_USERQUEUE *b, int ascending);


  struct AB_USERQUEUE_LIST {
    AB_USERQUEUE *first;
    uint32_t count;
    uint32_t id;
  } AB_USERQUEUE_LIST;

  void AB_UserQueue_List_AddList(AB_USERQUEUE_LIST *dst, AB_USERQUEUE_LIST *l);

  void AB_UserQueue_List_Add(AB_USERQUEUE *element, AB_USERQUEUE_LIST *list);

  void AB_UserQueue_List_Insert(AB_USERQUEUE *element, AB_USERQUEUE_LIST *list);

  void AB_UserQueue_List_Del(AB_USERQUEUE *element);

  AB_USERQUEUE* AB_UserQueue_List_First(const AB_USERQUEUE_LIST *l);

  AB_USERQUEUE* AB_UserQueue_List_Last(const AB_USERQUEUE_LIST *l);

  void AB_UserQueue_List_Clear(AB_USERQUEUE_LIST *l);

  AB_USERQUEUE_LIST* AB_UserQueue_List_new();

  void AB_UserQueue_List_free(AB_USERQUEUE_LIST *l);

  AB_USERQUEUE* AB_UserQueue_List_Next(const AB_USERQUEUE *element);

  AB_USERQUEUE* AB_UserQueue_List_Previous(const AB_USERQUEUE *element);

  uint32_t AB_UserQueue_List_GetCount(const AB_USERQUEUE_LIST *l);

  AB_USERQUEUE_LIST_SORT_FN AB_UserQueue_List_SetSortFn(AB_USERQUEUE_LIST *l, AB_USERQUEUE_LIST_SORT_FN fn);

  void AB_UserQueue_List_Sort(AB_USERQUEUE_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 AB_ACCOUNTQUEUE_LIST1_H
#define AB_ACCOUNTQUEUE_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct AB_ACCOUNTQUEUE_LIST_ELEMENT {
    uint32_t id;
    AB_ACCOUNTQUEUE *nextObject;
  } AB_ACCOUNTQUEUE_LIST__ELEMENT;

  typedef struct AB_ACCOUNTQUEUE_LIST AB_ACCOUNTQUEUE_LIST;

  typedef int GWENHYWFAR_CB (*AB_ACCOUNTQUEUE_LIST_SORT_FN)(const AB_ACCOUNTQUEUE *a, const AB_ACCOUNTQUEUE *b, int ascending);


  struct AB_ACCOUNTQUEUE_LIST {
    AB_ACCOUNTQUEUE *first;
    uint32_t count;
    uint32_t id;
  } AB_ACCOUNTQUEUE_LIST;

  void AB_AccountQueue_List_AddList(AB_ACCOUNTQUEUE_LIST *dst, AB_ACCOUNTQUEUE_LIST *l);

  void AB_AccountQueue_List_Add(AB_ACCOUNTQUEUE *element, AB_ACCOUNTQUEUE_LIST *list);

  void AB_AccountQueue_List_Insert(AB_ACCOUNTQUEUE *element, AB_ACCOUNTQUEUE_LIST *list);

  void AB_AccountQueue_List_Del(AB_ACCOUNTQUEUE *element);

  AB_ACCOUNTQUEUE* AB_AccountQueue_List_First(const AB_ACCOUNTQUEUE_LIST *l);

  AB_ACCOUNTQUEUE* AB_AccountQueue_List_Last(const AB_ACCOUNTQUEUE_LIST *l);

  void AB_AccountQueue_List_Clear(AB_ACCOUNTQUEUE_LIST *l);

  AB_ACCOUNTQUEUE_LIST* AB_AccountQueue_List_new();

  void AB_AccountQueue_List_free(AB_ACCOUNTQUEUE_LIST *l);

  AB_ACCOUNTQUEUE* AB_AccountQueue_List_Next(const AB_ACCOUNTQUEUE *element);

  AB_ACCOUNTQUEUE* AB_AccountQueue_List_Previous(const AB_ACCOUNTQUEUE *element);

  uint32_t AB_AccountQueue_List_GetCount(const AB_ACCOUNTQUEUE_LIST *l);

  AB_ACCOUNTQUEUE_LIST_SORT_FN AB_AccountQueue_List_SetSortFn(AB_ACCOUNTQUEUE_LIST *l, AB_ACCOUNTQUEUE_LIST_SORT_FN fn);

  void AB_AccountQueue_List_Sort(AB_ACCOUNTQUEUE_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 AB_TRANSACTION_LIST2_H
#define AB_TRANSACTION_LIST2_H


#ifdef __cplusplus
extern "C" {
#endif

  typedef struct AB_TRANSACTION_LIST2 AB_TRANSACTION_LIST2;

  typedef struct AB_TRANSACTION_LIST2_ITERATOR AB_TRANSACTION_LIST2_ITERATOR;

  typedef AB_TRANSACTION* (AB_TRANSACTION_LIST2_FOREACH)(AB_TRANSACTION *element,
                                                 void *user_data);

  AB_TRANSACTION_LIST2 *AB_Transaction_List2_new(); 

  void AB_Transaction_List2_free(AB_TRANSACTION_LIST2 *l); 

  void AB_Transaction_List2_Dump(AB_TRANSACTION_LIST2 *l, FILE *f, unsigned int indent); 

  void AB_Transaction_List2_PushBack(AB_TRANSACTION_LIST2 *l, AB_TRANSACTION *p); 
   
  void AB_Transaction_List2_PushFront(AB_TRANSACTION_LIST2 *l, AB_TRANSACTION *p); 

  AB_TRANSACTION *AB_Transaction_List2_GetFront(AB_TRANSACTION_LIST2 *l); 
   
  AB_TRANSACTION *AB_Transaction_List2_GetBack(AB_TRANSACTION_LIST2 *l); 

  void AB_Transaction_List2_Erase(AB_TRANSACTION_LIST2 *l,
                               AB_TRANSACTION_LIST2_ITERATOR *it);

  unsigned int AB_Transaction_List2_GetSize(AB_TRANSACTION_LIST2 *l); 

  void AB_Transaction_List2_PopBack(AB_TRANSACTION_LIST2 *l); 
   
  void AB_Transaction_List2_PopFront(AB_TRANSACTION_LIST2 *l); 

  void AB_Transaction_List2_Clear(AB_TRANSACTION_LIST2 *l); 

  AB_TRANSACTION_LIST2_ITERATOR *AB_Transaction_List2_First(AB_TRANSACTION_LIST2 *l); 
   
  AB_TRANSACTION_LIST2_ITERATOR *AB_Transaction_List2_Last(AB_TRANSACTION_LIST2 *l); 

  AB_TRANSACTION_LIST2_ITERATOR *AB_Transaction_List2Iterator_new(AB_TRANSACTION_LIST2 *l);

  void AB_Transaction_List2Iterator_free(AB_TRANSACTION_LIST2_ITERATOR *li); 

  AB_TRANSACTION *AB_Transaction_List2Iterator_Previous(AB_TRANSACTION_LIST2_ITERATOR *li); 
   
  AB_TRANSACTION *AB_Transaction_List2Iterator_Next(AB_TRANSACTION_LIST2_ITERATOR *li); 

  AB_TRANSACTION *AB_Transaction_List2Iterator_Data(AB_TRANSACTION_LIST2_ITERATOR *li); 

  AB_TRANSACTION *AB_Transaction_List2_ForEach(AB_TRANSACTION_LIST2 *list,
                                        AB_TRANSACTION_LIST2_FOREACH func,
                                        void *user_data);


  typedef struct AB_TRANSACTION_CONSTLIST2 AB_TRANSACTION_CONSTLIST2; 
  typedef struct AB_TRANSACTION_CONSTLIST2_ITERATOR AB_TRANSACTION_CONSTLIST2_ITERATOR; 
  typedef const AB_TRANSACTION*
    (AB_TRANSACTION_CONSTLIST2_FOREACH)(const AB_TRANSACTION *element,
                                    void *user_data);
  
   
  AB_TRANSACTION_CONSTLIST2 *AB_Transaction_ConstList2_new(); 
   
  void AB_Transaction_ConstList2_free(AB_TRANSACTION_CONSTLIST2 *l); 
   
  void AB_Transaction_ConstList2_PushBack(AB_TRANSACTION_CONSTLIST2 *l, const AB_TRANSACTION *p); 
   
  void AB_Transaction_ConstList2_PushFront(AB_TRANSACTION_CONSTLIST2 *l, const AB_TRANSACTION *p); 
   
  const AB_TRANSACTION *AB_Transaction_ConstList2_GetFront(AB_TRANSACTION_CONSTLIST2 *l); 
   
  const AB_TRANSACTION *AB_Transaction_ConstList2_GetBack(AB_TRANSACTION_CONSTLIST2 *l); 
   
  unsigned int AB_Transaction_ConstList2_GetSize(AB_TRANSACTION_CONSTLIST2 *l); 
   
  void AB_Transaction_ConstList2_PopBack(AB_TRANSACTION_CONSTLIST2 *l); 
   
  void AB_Transaction_ConstList2_PopFront(AB_TRANSACTION_CONSTLIST2 *l); 
   
  void AB_Transaction_ConstList2_Clear(AB_TRANSACTION_CONSTLIST2 *l); 
   
  AB_TRANSACTION_CONSTLIST2_ITERATOR *AB_Transaction_ConstList2_First(AB_TRANSACTION_CONSTLIST2 *l); 
   
  AB_TRANSACTION_CONSTLIST2_ITERATOR *AB_Transaction_ConstList2_Last(AB_TRANSACTION_CONSTLIST2 *l); 
   
  AB_TRANSACTION_CONSTLIST2_ITERATOR *AB_Transaction_ConstList2Iterator_new(AB_TRANSACTION_CONSTLIST2 *l); 
   
  void AB_Transaction_ConstList2Iterator_free(AB_TRANSACTION_CONSTLIST2_ITERATOR *li); 
   
  const AB_TRANSACTION *AB_Transaction_ConstList2Iterator_Previous(AB_TRANSACTION_CONSTLIST2_ITERATOR *li); 
   
  const AB_TRANSACTION *AB_Transaction_ConstList2Iterator_Next(AB_TRANSACTION_CONSTLIST2_ITERATOR *li); 
   
  const AB_TRANSACTION *AB_Transaction_ConstList2Iterator_Data(AB_TRANSACTION_CONSTLIST2_ITERATOR *li); 
   
  const AB_TRANSACTION *AB_Transaction_ConstList2_ForEach(AB_TRANSACTION_CONSTLIST2 *list,
        AB_TRANSACTION_CONSTLIST2_FOREACH func, void *user_data);


#ifdef __cplusplus
}
#endif


#endif /* AB_TRANSACTION_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 AB_TRANSACTION_LIST1_H
#define AB_TRANSACTION_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct AB_TRANSACTION_LIST_ELEMENT {
    uint32_t id;
    AB_TRANSACTION *nextObject;
  } AB_TRANSACTION_LIST__ELEMENT;

  typedef struct AB_TRANSACTION_LIST AB_TRANSACTION_LIST;

  typedef int GWENHYWFAR_CB (*AB_TRANSACTION_LIST_SORT_FN)(const AB_TRANSACTION *a, const AB_TRANSACTION *b, int ascending);


  struct AB_TRANSACTION_LIST {
    AB_TRANSACTION *first;
    uint32_t count;
    uint32_t id;
  } AB_TRANSACTION_LIST;

  void AB_Transaction_List_AddList(AB_TRANSACTION_LIST *dst, AB_TRANSACTION_LIST *l);

  void AB_Transaction_List_Add(AB_TRANSACTION *element, AB_TRANSACTION_LIST *list);

  void AB_Transaction_List_Insert(AB_TRANSACTION *element, AB_TRANSACTION_LIST *list);

  void AB_Transaction_List_Del(AB_TRANSACTION *element);

  AB_TRANSACTION* AB_Transaction_List_First(const AB_TRANSACTION_LIST *l);

  AB_TRANSACTION* AB_Transaction_List_Last(const AB_TRANSACTION_LIST *l);

  void AB_Transaction_List_Clear(AB_TRANSACTION_LIST *l);

  AB_TRANSACTION_LIST* AB_Transaction_List_new();

  void AB_Transaction_List_free(AB_TRANSACTION_LIST *l);

  AB_TRANSACTION* AB_Transaction_List_Next(const AB_TRANSACTION *element);

  AB_TRANSACTION* AB_Transaction_List_Previous(const AB_TRANSACTION *element);

  uint32_t AB_Transaction_List_GetCount(const AB_TRANSACTION_LIST *l);

  AB_TRANSACTION_LIST_SORT_FN AB_Transaction_List_SetSortFn(AB_TRANSACTION_LIST *l, AB_TRANSACTION_LIST_SORT_FN fn);

  void AB_Transaction_List_Sort(AB_TRANSACTION_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 AB_PROVIDER_DESCRIPTION_LIST2_H
#define AB_PROVIDER_DESCRIPTION_LIST2_H


#ifdef __cplusplus
extern "C" {
#endif

  typedef struct AB_PROVIDER_DESCRIPTION_LIST2 AB_PROVIDER_DESCRIPTION_LIST2;

  typedef struct AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR;

  typedef AB_PROVIDER_DESCRIPTION* (AB_PROVIDER_DESCRIPTION_LIST2_FOREACH)(AB_PROVIDER_DESCRIPTION *element,
                                                 void *user_data);

  AB_PROVIDER_DESCRIPTION_LIST2 *AB_ProviderDescription_List2_new(); 

  void AB_ProviderDescription_List2_free(AB_PROVIDER_DESCRIPTION_LIST2 *l); 

  void AB_ProviderDescription_List2_Dump(AB_PROVIDER_DESCRIPTION_LIST2 *l, FILE *f, unsigned int indent); 

  void AB_ProviderDescription_List2_PushBack(AB_PROVIDER_DESCRIPTION_LIST2 *l, AB_PROVIDER_DESCRIPTION *p); 
   
  void AB_ProviderDescription_List2_PushFront(AB_PROVIDER_DESCRIPTION_LIST2 *l, AB_PROVIDER_DESCRIPTION *p); 

  AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_List2_GetFront(AB_PROVIDER_DESCRIPTION_LIST2 *l); 
   
  AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_List2_GetBack(AB_PROVIDER_DESCRIPTION_LIST2 *l); 

  void AB_ProviderDescription_List2_Erase(AB_PROVIDER_DESCRIPTION_LIST2 *l,
                               AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR *it);

  unsigned int AB_ProviderDescription_List2_GetSize(AB_PROVIDER_DESCRIPTION_LIST2 *l); 

  void AB_ProviderDescription_List2_PopBack(AB_PROVIDER_DESCRIPTION_LIST2 *l); 
   
  void AB_ProviderDescription_List2_PopFront(AB_PROVIDER_DESCRIPTION_LIST2 *l); 

  void AB_ProviderDescription_List2_Clear(AB_PROVIDER_DESCRIPTION_LIST2 *l); 

  AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR *AB_ProviderDescription_List2_First(AB_PROVIDER_DESCRIPTION_LIST2 *l); 
   
  AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR *AB_ProviderDescription_List2_Last(AB_PROVIDER_DESCRIPTION_LIST2 *l); 

  AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR *AB_ProviderDescription_List2Iterator_new(AB_PROVIDER_DESCRIPTION_LIST2 *l);

  void AB_ProviderDescription_List2Iterator_free(AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR *li); 

  AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_List2Iterator_Previous(AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR *li); 
   
  AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_List2Iterator_Next(AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR *li); 

  AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_List2Iterator_Data(AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR *li); 

  AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_List2_ForEach(AB_PROVIDER_DESCRIPTION_LIST2 *list,
                                        AB_PROVIDER_DESCRIPTION_LIST2_FOREACH func,
                                        void *user_data);


  typedef struct AB_PROVIDER_DESCRIPTION_CONSTLIST2 AB_PROVIDER_DESCRIPTION_CONSTLIST2; 
  typedef struct AB_PROVIDER_DESCRIPTION_CONSTLIST2_ITERATOR AB_PROVIDER_DESCRIPTION_CONSTLIST2_ITERATOR; 
  typedef const AB_PROVIDER_DESCRIPTION*
    (AB_PROVIDER_DESCRIPTION_CONSTLIST2_FOREACH)(const AB_PROVIDER_DESCRIPTION *element,
                                    void *user_data);
  
   
  AB_PROVIDER_DESCRIPTION_CONSTLIST2 *AB_ProviderDescription_ConstList2_new(); 
   
  void AB_ProviderDescription_ConstList2_free(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 
   
  void AB_ProviderDescription_ConstList2_PushBack(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l, const AB_PROVIDER_DESCRIPTION *p); 
   
  void AB_ProviderDescription_ConstList2_PushFront(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l, const AB_PROVIDER_DESCRIPTION *p); 
   
  const AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_ConstList2_GetFront(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 
   
  const AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_ConstList2_GetBack(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 
   
  unsigned int AB_ProviderDescription_ConstList2_GetSize(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 
   
  void AB_ProviderDescription_ConstList2_PopBack(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 
   
  void AB_ProviderDescription_ConstList2_PopFront(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 
   
  void AB_ProviderDescription_ConstList2_Clear(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 
   
  AB_PROVIDER_DESCRIPTION_CONSTLIST2_ITERATOR *AB_ProviderDescription_ConstList2_First(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 
   
  AB_PROVIDER_DESCRIPTION_CONSTLIST2_ITERATOR *AB_ProviderDescription_ConstList2_Last(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 
   
  AB_PROVIDER_DESCRIPTION_CONSTLIST2_ITERATOR *AB_ProviderDescription_ConstList2Iterator_new(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 
   
  void AB_ProviderDescription_ConstList2Iterator_free(AB_PROVIDER_DESCRIPTION_CONSTLIST2_ITERATOR *li); 
   
  const AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_ConstList2Iterator_Previous(AB_PROVIDER_DESCRIPTION_CONSTLIST2_ITERATOR *li); 
   
  const AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_ConstList2Iterator_Next(AB_PROVIDER_DESCRIPTION_CONSTLIST2_ITERATOR *li); 
   
  const AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_ConstList2Iterator_Data(AB_PROVIDER_DESCRIPTION_CONSTLIST2_ITERATOR *li); 
   
  const AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_ConstList2_ForEach(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *list,
        AB_PROVIDER_DESCRIPTION_CONSTLIST2_FOREACH func, void *user_data);


#ifdef __cplusplus
}
#endif


#endif /* AB_PROVIDER_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 AB_PROVIDER_DESCRIPTION_LIST1_H
#define AB_PROVIDER_DESCRIPTION_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct AB_PROVIDER_DESCRIPTION_LIST_ELEMENT {
    uint32_t id;
    AB_PROVIDER_DESCRIPTION *nextObject;
  } AB_PROVIDER_DESCRIPTION_LIST__ELEMENT;

  typedef struct AB_PROVIDER_DESCRIPTION_LIST AB_PROVIDER_DESCRIPTION_LIST;

  typedef int GWENHYWFAR_CB (*AB_PROVIDER_DESCRIPTION_LIST_SORT_FN)(const AB_PROVIDER_DESCRIPTION *a, const AB_PROVIDER_DESCRIPTION *b, int ascending);


  struct AB_PROVIDER_DESCRIPTION_LIST {
    AB_PROVIDER_DESCRIPTION *first;
    uint32_t count;
    uint32_t id;
  } AB_PROVIDER_DESCRIPTION_LIST;

  void AB_ProviderDescription_List_AddList(AB_PROVIDER_DESCRIPTION_LIST *dst, AB_PROVIDER_DESCRIPTION_LIST *l);

  void AB_ProviderDescription_List_Add(AB_PROVIDER_DESCRIPTION *element, AB_PROVIDER_DESCRIPTION_LIST *list);

  void AB_ProviderDescription_List_Insert(AB_PROVIDER_DESCRIPTION *element, AB_PROVIDER_DESCRIPTION_LIST *list);

  void AB_ProviderDescription_List_Del(AB_PROVIDER_DESCRIPTION *element);

  AB_PROVIDER_DESCRIPTION* AB_ProviderDescription_List_First(const AB_PROVIDER_DESCRIPTION_LIST *l);

  AB_PROVIDER_DESCRIPTION* AB_ProviderDescription_List_Last(const AB_PROVIDER_DESCRIPTION_LIST *l);

  void AB_ProviderDescription_List_Clear(AB_PROVIDER_DESCRIPTION_LIST *l);

  AB_PROVIDER_DESCRIPTION_LIST* AB_ProviderDescription_List_new();

  void AB_ProviderDescription_List_free(AB_PROVIDER_DESCRIPTION_LIST *l);

  AB_PROVIDER_DESCRIPTION* AB_ProviderDescription_List_Next(const AB_PROVIDER_DESCRIPTION *element);

  AB_PROVIDER_DESCRIPTION* AB_ProviderDescription_List_Previous(const AB_PROVIDER_DESCRIPTION *element);

  uint32_t AB_ProviderDescription_List_GetCount(const AB_PROVIDER_DESCRIPTION_LIST *l);

  AB_PROVIDER_DESCRIPTION_LIST_SORT_FN AB_ProviderDescription_List_SetSortFn(AB_PROVIDER_DESCRIPTION_LIST *l, AB_PROVIDER_DESCRIPTION_LIST_SORT_FN fn);

  void AB_ProviderDescription_List_Sort(AB_PROVIDER_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 AB_TRANSACTION_LIMITS_LIST2_H
#define AB_TRANSACTION_LIMITS_LIST2_H


#ifdef __cplusplus
extern "C" {
#endif

  typedef struct AB_TRANSACTION_LIMITS_LIST2 AB_TRANSACTION_LIMITS_LIST2;

  typedef struct AB_TRANSACTION_LIMITS_LIST2_ITERATOR AB_TRANSACTION_LIMITS_LIST2_ITERATOR;

  typedef AB_TRANSACTION_LIMITS* (AB_TRANSACTION_LIMITS_LIST2_FOREACH)(AB_TRANSACTION_LIMITS *element,
                                                 void *user_data);

  AB_TRANSACTION_LIMITS_LIST2 *AB_TransactionLimits_List2_new(); 

  void AB_TransactionLimits_List2_free(AB_TRANSACTION_LIMITS_LIST2 *l); 

  void AB_TransactionLimits_List2_Dump(AB_TRANSACTION_LIMITS_LIST2 *l, FILE *f, unsigned int indent); 

  void AB_TransactionLimits_List2_PushBack(AB_TRANSACTION_LIMITS_LIST2 *l, AB_TRANSACTION_LIMITS *p); 
   
  void AB_TransactionLimits_List2_PushFront(AB_TRANSACTION_LIMITS_LIST2 *l, AB_TRANSACTION_LIMITS *p); 

  AB_TRANSACTION_LIMITS *AB_TransactionLimits_List2_GetFront(AB_TRANSACTION_LIMITS_LIST2 *l); 
   
  AB_TRANSACTION_LIMITS *AB_TransactionLimits_List2_GetBack(AB_TRANSACTION_LIMITS_LIST2 *l); 

  void AB_TransactionLimits_List2_Erase(AB_TRANSACTION_LIMITS_LIST2 *l,
                               AB_TRANSACTION_LIMITS_LIST2_ITERATOR *it);

  unsigned int AB_TransactionLimits_List2_GetSize(AB_TRANSACTION_LIMITS_LIST2 *l); 

  void AB_TransactionLimits_List2_PopBack(AB_TRANSACTION_LIMITS_LIST2 *l); 
   
  void AB_TransactionLimits_List2_PopFront(AB_TRANSACTION_LIMITS_LIST2 *l); 

  void AB_TransactionLimits_List2_Clear(AB_TRANSACTION_LIMITS_LIST2 *l); 

  AB_TRANSACTION_LIMITS_LIST2_ITERATOR *AB_TransactionLimits_List2_First(AB_TRANSACTION_LIMITS_LIST2 *l); 
   
  AB_TRANSACTION_LIMITS_LIST2_ITERATOR *AB_TransactionLimits_List2_Last(AB_TRANSACTION_LIMITS_LIST2 *l); 

  AB_TRANSACTION_LIMITS_LIST2_ITERATOR *AB_TransactionLimits_List2Iterator_new(AB_TRANSACTION_LIMITS_LIST2 *l);

  void AB_TransactionLimits_List2Iterator_free(AB_TRANSACTION_LIMITS_LIST2_ITERATOR *li); 

  AB_TRANSACTION_LIMITS *AB_TransactionLimits_List2Iterator_Previous(AB_TRANSACTION_LIMITS_LIST2_ITERATOR *li); 
   
  AB_TRANSACTION_LIMITS *AB_TransactionLimits_List2Iterator_Next(AB_TRANSACTION_LIMITS_LIST2_ITERATOR *li); 

  AB_TRANSACTION_LIMITS *AB_TransactionLimits_List2Iterator_Data(AB_TRANSACTION_LIMITS_LIST2_ITERATOR *li); 

  AB_TRANSACTION_LIMITS *AB_TransactionLimits_List2_ForEach(AB_TRANSACTION_LIMITS_LIST2 *list,
                                        AB_TRANSACTION_LIMITS_LIST2_FOREACH func,
                                        void *user_data);


  typedef struct AB_TRANSACTION_LIMITS_CONSTLIST2 AB_TRANSACTION_LIMITS_CONSTLIST2; 
  typedef struct AB_TRANSACTION_LIMITS_CONSTLIST2_ITERATOR AB_TRANSACTION_LIMITS_CONSTLIST2_ITERATOR; 
  typedef const AB_TRANSACTION_LIMITS*
    (AB_TRANSACTION_LIMITS_CONSTLIST2_FOREACH)(const AB_TRANSACTION_LIMITS *element,
                                    void *user_data);
  
   
  AB_TRANSACTION_LIMITS_CONSTLIST2 *AB_TransactionLimits_ConstList2_new(); 
   
  void AB_TransactionLimits_ConstList2_free(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 
   
  void AB_TransactionLimits_ConstList2_PushBack(AB_TRANSACTION_LIMITS_CONSTLIST2 *l, const AB_TRANSACTION_LIMITS *p); 
   
  void AB_TransactionLimits_ConstList2_PushFront(AB_TRANSACTION_LIMITS_CONSTLIST2 *l, const AB_TRANSACTION_LIMITS *p); 
   
  const AB_TRANSACTION_LIMITS *AB_TransactionLimits_ConstList2_GetFront(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 
   
  const AB_TRANSACTION_LIMITS *AB_TransactionLimits_ConstList2_GetBack(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 
   
  unsigned int AB_TransactionLimits_ConstList2_GetSize(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 
   
  void AB_TransactionLimits_ConstList2_PopBack(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 
   
  void AB_TransactionLimits_ConstList2_PopFront(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 
   
  void AB_TransactionLimits_ConstList2_Clear(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 
   
  AB_TRANSACTION_LIMITS_CONSTLIST2_ITERATOR *AB_TransactionLimits_ConstList2_First(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 
   
  AB_TRANSACTION_LIMITS_CONSTLIST2_ITERATOR *AB_TransactionLimits_ConstList2_Last(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 
   
  AB_TRANSACTION_LIMITS_CONSTLIST2_ITERATOR *AB_TransactionLimits_ConstList2Iterator_new(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 
   
  void AB_TransactionLimits_ConstList2Iterator_free(AB_TRANSACTION_LIMITS_CONSTLIST2_ITERATOR *li); 
   
  const AB_TRANSACTION_LIMITS *AB_TransactionLimits_ConstList2Iterator_Previous(AB_TRANSACTION_LIMITS_CONSTLIST2_ITERATOR *li); 
   
  const AB_TRANSACTION_LIMITS *AB_TransactionLimits_ConstList2Iterator_Next(AB_TRANSACTION_LIMITS_CONSTLIST2_ITERATOR *li); 
   
  const AB_TRANSACTION_LIMITS *AB_TransactionLimits_ConstList2Iterator_Data(AB_TRANSACTION_LIMITS_CONSTLIST2_ITERATOR *li); 
   
  const AB_TRANSACTION_LIMITS *AB_TransactionLimits_ConstList2_ForEach(AB_TRANSACTION_LIMITS_CONSTLIST2 *list,
        AB_TRANSACTION_LIMITS_CONSTLIST2_FOREACH func, void *user_data);


#ifdef __cplusplus
}
#endif


#endif /* AB_TRANSACTION_LIMITS_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 AB_TRANSACTION_LIMITS_LIST1_H
#define AB_TRANSACTION_LIMITS_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct AB_TRANSACTION_LIMITS_LIST_ELEMENT {
    uint32_t id;
    AB_TRANSACTION_LIMITS *nextObject;
  } AB_TRANSACTION_LIMITS_LIST__ELEMENT;

  typedef struct AB_TRANSACTION_LIMITS_LIST AB_TRANSACTION_LIMITS_LIST;

  typedef int GWENHYWFAR_CB (*AB_TRANSACTION_LIMITS_LIST_SORT_FN)(const AB_TRANSACTION_LIMITS *a, const AB_TRANSACTION_LIMITS *b, int ascending);


  struct AB_TRANSACTION_LIMITS_LIST {
    AB_TRANSACTION_LIMITS *first;
    uint32_t count;
    uint32_t id;
  } AB_TRANSACTION_LIMITS_LIST;

  void AB_TransactionLimits_List_AddList(AB_TRANSACTION_LIMITS_LIST *dst, AB_TRANSACTION_LIMITS_LIST *l);

  void AB_TransactionLimits_List_Add(AB_TRANSACTION_LIMITS *element, AB_TRANSACTION_LIMITS_LIST *list);

  void AB_TransactionLimits_List_Insert(AB_TRANSACTION_LIMITS *element, AB_TRANSACTION_LIMITS_LIST *list);

  void AB_TransactionLimits_List_Del(AB_TRANSACTION_LIMITS *element);

  AB_TRANSACTION_LIMITS* AB_TransactionLimits_List_First(const AB_TRANSACTION_LIMITS_LIST *l);

  AB_TRANSACTION_LIMITS* AB_TransactionLimits_List_Last(const AB_TRANSACTION_LIMITS_LIST *l);

  void AB_TransactionLimits_List_Clear(AB_TRANSACTION_LIMITS_LIST *l);

  AB_TRANSACTION_LIMITS_LIST* AB_TransactionLimits_List_new();

  void AB_TransactionLimits_List_free(AB_TRANSACTION_LIMITS_LIST *l);

  AB_TRANSACTION_LIMITS* AB_TransactionLimits_List_Next(const AB_TRANSACTION_LIMITS *element);

  AB_TRANSACTION_LIMITS* AB_TransactionLimits_List_Previous(const AB_TRANSACTION_LIMITS *element);

  uint32_t AB_TransactionLimits_List_GetCount(const AB_TRANSACTION_LIMITS_LIST *l);

  AB_TRANSACTION_LIMITS_LIST_SORT_FN AB_TransactionLimits_List_SetSortFn(AB_TRANSACTION_LIMITS_LIST *l, AB_TRANSACTION_LIMITS_LIST_SORT_FN fn);

  void AB_TransactionLimits_List_Sort(AB_TRANSACTION_LIMITS_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 AB_ACCOUNT_STATUS_LIST2_H
#define AB_ACCOUNT_STATUS_LIST2_H


#ifdef __cplusplus
extern "C" {
#endif

  typedef struct AB_ACCOUNT_STATUS_LIST2 AB_ACCOUNT_STATUS_LIST2;

  typedef struct AB_ACCOUNT_STATUS_LIST2_ITERATOR AB_ACCOUNT_STATUS_LIST2_ITERATOR;

  typedef AB_ACCOUNT_STATUS* (AB_ACCOUNT_STATUS_LIST2_FOREACH)(AB_ACCOUNT_STATUS *element,
                                                 void *user_data);

  AB_ACCOUNT_STATUS_LIST2 *AB_AccountStatus_List2_new(); 

  void AB_AccountStatus_List2_free(AB_ACCOUNT_STATUS_LIST2 *l); 

  void AB_AccountStatus_List2_Dump(AB_ACCOUNT_STATUS_LIST2 *l, FILE *f, unsigned int indent); 

  void AB_AccountStatus_List2_PushBack(AB_ACCOUNT_STATUS_LIST2 *l, AB_ACCOUNT_STATUS *p); 
   
  void AB_AccountStatus_List2_PushFront(AB_ACCOUNT_STATUS_LIST2 *l, AB_ACCOUNT_STATUS *p); 

  AB_ACCOUNT_STATUS *AB_AccountStatus_List2_GetFront(AB_ACCOUNT_STATUS_LIST2 *l); 
   
  AB_ACCOUNT_STATUS *AB_AccountStatus_List2_GetBack(AB_ACCOUNT_STATUS_LIST2 *l); 

  void AB_AccountStatus_List2_Erase(AB_ACCOUNT_STATUS_LIST2 *l,
                               AB_ACCOUNT_STATUS_LIST2_ITERATOR *it);

  unsigned int AB_AccountStatus_List2_GetSize(AB_ACCOUNT_STATUS_LIST2 *l); 

  void AB_AccountStatus_List2_PopBack(AB_ACCOUNT_STATUS_LIST2 *l); 
   
  void AB_AccountStatus_List2_PopFront(AB_ACCOUNT_STATUS_LIST2 *l); 

  void AB_AccountStatus_List2_Clear(AB_ACCOUNT_STATUS_LIST2 *l); 

  AB_ACCOUNT_STATUS_LIST2_ITERATOR *AB_AccountStatus_List2_First(AB_ACCOUNT_STATUS_LIST2 *l); 
   
  AB_ACCOUNT_STATUS_LIST2_ITERATOR *AB_AccountStatus_List2_Last(AB_ACCOUNT_STATUS_LIST2 *l); 

  AB_ACCOUNT_STATUS_LIST2_ITERATOR *AB_AccountStatus_List2Iterator_new(AB_ACCOUNT_STATUS_LIST2 *l);

  void AB_AccountStatus_List2Iterator_free(AB_ACCOUNT_STATUS_LIST2_ITERATOR *li); 

  AB_ACCOUNT_STATUS *AB_AccountStatus_List2Iterator_Previous(AB_ACCOUNT_STATUS_LIST2_ITERATOR *li); 
   
  AB_ACCOUNT_STATUS *AB_AccountStatus_List2Iterator_Next(AB_ACCOUNT_STATUS_LIST2_ITERATOR *li); 

  AB_ACCOUNT_STATUS *AB_AccountStatus_List2Iterator_Data(AB_ACCOUNT_STATUS_LIST2_ITERATOR *li); 

  AB_ACCOUNT_STATUS *AB_AccountStatus_List2_ForEach(AB_ACCOUNT_STATUS_LIST2 *list,
                                        AB_ACCOUNT_STATUS_LIST2_FOREACH func,
                                        void *user_data);


  typedef struct AB_ACCOUNT_STATUS_CONSTLIST2 AB_ACCOUNT_STATUS_CONSTLIST2; 
  typedef struct AB_ACCOUNT_STATUS_CONSTLIST2_ITERATOR AB_ACCOUNT_STATUS_CONSTLIST2_ITERATOR; 
  typedef const AB_ACCOUNT_STATUS*
    (AB_ACCOUNT_STATUS_CONSTLIST2_FOREACH)(const AB_ACCOUNT_STATUS *element,
                                    void *user_data);
  
   
  AB_ACCOUNT_STATUS_CONSTLIST2 *AB_AccountStatus_ConstList2_new(); 
   
  void AB_AccountStatus_ConstList2_free(AB_ACCOUNT_STATUS_CONSTLIST2 *l); 
   
  void AB_AccountStatus_ConstList2_PushBack(AB_ACCOUNT_STATUS_CONSTLIST2 *l, const AB_ACCOUNT_STATUS *p); 
   
  void AB_AccountStatus_ConstList2_PushFront(AB_ACCOUNT_STATUS_CONSTLIST2 *l, const AB_ACCOUNT_STATUS *p); 
   
  const AB_ACCOUNT_STATUS *AB_AccountStatus_ConstList2_GetFront(AB_ACCOUNT_STATUS_CONSTLIST2 *l); 
   
  const AB_ACCOUNT_STATUS *AB_AccountStatus_ConstList2_GetBack(AB_ACCOUNT_STATUS_CONSTLIST2 *l); 
   
  unsigned int AB_AccountStatus_ConstList2_GetSize(AB_ACCOUNT_STATUS_CONSTLIST2 *l); 
   
  void AB_AccountStatus_ConstList2_PopBack(AB_ACCOUNT_STATUS_CONSTLIST2 *l); 
   
  void AB_AccountStatus_ConstList2_PopFront(AB_ACCOUNT_STATUS_CONSTLIST2 *l); 
   
  void AB_AccountStatus_ConstList2_Clear(AB_ACCOUNT_STATUS_CONSTLIST2 *l); 
   
  AB_ACCOUNT_STATUS_CONSTLIST2_ITERATOR *AB_AccountStatus_ConstList2_First(AB_ACCOUNT_STATUS_CONSTLIST2 *l); 
   
  AB_ACCOUNT_STATUS_CONSTLIST2_ITERATOR *AB_AccountStatus_ConstList2_Last(AB_ACCOUNT_STATUS_CONSTLIST2 *l); 
   
  AB_ACCOUNT_STATUS_CONSTLIST2_ITERATOR *AB_AccountStatus_ConstList2Iterator_new(AB_ACCOUNT_STATUS_CONSTLIST2 *l); 
   
  void AB_AccountStatus_ConstList2Iterator_free(AB_ACCOUNT_STATUS_CONSTLIST2_ITERATOR *li); 
   
  const AB_ACCOUNT_STATUS *AB_AccountStatus_ConstList2Iterator_Previous(AB_ACCOUNT_STATUS_CONSTLIST2_ITERATOR *li); 
   
  const AB_ACCOUNT_STATUS *AB_AccountStatus_ConstList2Iterator_Next(AB_ACCOUNT_STATUS_CONSTLIST2_ITERATOR *li); 
   
  const AB_ACCOUNT_STATUS *AB_AccountStatus_ConstList2Iterator_Data(AB_ACCOUNT_STATUS_CONSTLIST2_ITERATOR *li); 
   
  const AB_ACCOUNT_STATUS *AB_AccountStatus_ConstList2_ForEach(AB_ACCOUNT_STATUS_CONSTLIST2 *list,
        AB_ACCOUNT_STATUS_CONSTLIST2_FOREACH func, void *user_data);


#ifdef __cplusplus
}
#endif


#endif /* AB_ACCOUNT_STATUS_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 AB_ACCOUNT_LIST1_H
#define AB_ACCOUNT_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct AB_ACCOUNT_LIST_ELEMENT {
    uint32_t id;
    AB_ACCOUNT *nextObject;
  } AB_ACCOUNT_LIST__ELEMENT;

  typedef struct AB_ACCOUNT_LIST AB_ACCOUNT_LIST;

  typedef int GWENHYWFAR_CB (*AB_ACCOUNT_LIST_SORT_FN)(const AB_ACCOUNT *a, const AB_ACCOUNT *b, int ascending);


  struct AB_ACCOUNT_LIST {
    AB_ACCOUNT *first;
    uint32_t count;
    uint32_t id;
  } AB_ACCOUNT_LIST;

  void AB_Account_List_AddList(AB_ACCOUNT_LIST *dst, AB_ACCOUNT_LIST *l);

  void AB_Account_List_Add(AB_ACCOUNT *element, AB_ACCOUNT_LIST *list);

  void AB_Account_List_Insert(AB_ACCOUNT *element, AB_ACCOUNT_LIST *list);

  void AB_Account_List_Del(AB_ACCOUNT *element);

  AB_ACCOUNT* AB_Account_List_First(const AB_ACCOUNT_LIST *l);

  AB_ACCOUNT* AB_Account_List_Last(const AB_ACCOUNT_LIST *l);

  void AB_Account_List_Clear(AB_ACCOUNT_LIST *l);

  AB_ACCOUNT_LIST* AB_Account_List_new();

  void AB_Account_List_free(AB_ACCOUNT_LIST *l);

  AB_ACCOUNT* AB_Account_List_Next(const AB_ACCOUNT *element);

  AB_ACCOUNT* AB_Account_List_Previous(const AB_ACCOUNT *element);

  uint32_t AB_Account_List_GetCount(const AB_ACCOUNT_LIST *l);

  AB_ACCOUNT_LIST_SORT_FN AB_Account_List_SetSortFn(AB_ACCOUNT_LIST *l, AB_ACCOUNT_LIST_SORT_FN fn);

  void AB_Account_List_Sort(AB_ACCOUNT_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 AB_MESSAGE_LIST2_H
#define AB_MESSAGE_LIST2_H


#ifdef __cplusplus
extern "C" {
#endif

  typedef struct AB_MESSAGE_LIST2 AB_MESSAGE_LIST2;

  typedef struct AB_MESSAGE_LIST2_ITERATOR AB_MESSAGE_LIST2_ITERATOR;

  typedef AB_MESSAGE* (AB_MESSAGE_LIST2_FOREACH)(AB_MESSAGE *element,
                                                 void *user_data);

  AB_MESSAGE_LIST2 *AB_Message_List2_new(); 

  void AB_Message_List2_free(AB_MESSAGE_LIST2 *l); 

  void AB_Message_List2_Dump(AB_MESSAGE_LIST2 *l, FILE *f, unsigned int indent); 

  void AB_Message_List2_PushBack(AB_MESSAGE_LIST2 *l, AB_MESSAGE *p); 
   
  void AB_Message_List2_PushFront(AB_MESSAGE_LIST2 *l, AB_MESSAGE *p); 

  AB_MESSAGE *AB_Message_List2_GetFront(AB_MESSAGE_LIST2 *l); 
   
  AB_MESSAGE *AB_Message_List2_GetBack(AB_MESSAGE_LIST2 *l); 

  void AB_Message_List2_Erase(AB_MESSAGE_LIST2 *l,
                               AB_MESSAGE_LIST2_ITERATOR *it);

  unsigned int AB_Message_List2_GetSize(AB_MESSAGE_LIST2 *l); 

  void AB_Message_List2_PopBack(AB_MESSAGE_LIST2 *l); 
   
  void AB_Message_List2_PopFront(AB_MESSAGE_LIST2 *l); 

  void AB_Message_List2_Clear(AB_MESSAGE_LIST2 *l); 

  AB_MESSAGE_LIST2_ITERATOR *AB_Message_List2_First(AB_MESSAGE_LIST2 *l); 
   
  AB_MESSAGE_LIST2_ITERATOR *AB_Message_List2_Last(AB_MESSAGE_LIST2 *l); 

  AB_MESSAGE_LIST2_ITERATOR *AB_Message_List2Iterator_new(AB_MESSAGE_LIST2 *l);

  void AB_Message_List2Iterator_free(AB_MESSAGE_LIST2_ITERATOR *li); 

  AB_MESSAGE *AB_Message_List2Iterator_Previous(AB_MESSAGE_LIST2_ITERATOR *li); 
   
  AB_MESSAGE *AB_Message_List2Iterator_Next(AB_MESSAGE_LIST2_ITERATOR *li); 

  AB_MESSAGE *AB_Message_List2Iterator_Data(AB_MESSAGE_LIST2_ITERATOR *li); 

  AB_MESSAGE *AB_Message_List2_ForEach(AB_MESSAGE_LIST2 *list,
                                        AB_MESSAGE_LIST2_FOREACH func,
                                        void *user_data);


  typedef struct AB_MESSAGE_CONSTLIST2 AB_MESSAGE_CONSTLIST2; 
  typedef struct AB_MESSAGE_CONSTLIST2_ITERATOR AB_MESSAGE_CONSTLIST2_ITERATOR; 
  typedef const AB_MESSAGE*
    (AB_MESSAGE_CONSTLIST2_FOREACH)(const AB_MESSAGE *element,
                                    void *user_data);
  
   
  AB_MESSAGE_CONSTLIST2 *AB_Message_ConstList2_new(); 
   
  void AB_Message_ConstList2_free(AB_MESSAGE_CONSTLIST2 *l); 
   
  void AB_Message_ConstList2_PushBack(AB_MESSAGE_CONSTLIST2 *l, const AB_MESSAGE *p); 
   
  void AB_Message_ConstList2_PushFront(AB_MESSAGE_CONSTLIST2 *l, const AB_MESSAGE *p); 
   
  const AB_MESSAGE *AB_Message_ConstList2_GetFront(AB_MESSAGE_CONSTLIST2 *l); 
   
  const AB_MESSAGE *AB_Message_ConstList2_GetBack(AB_MESSAGE_CONSTLIST2 *l); 
   
  unsigned int AB_Message_ConstList2_GetSize(AB_MESSAGE_CONSTLIST2 *l); 
   
  void AB_Message_ConstList2_PopBack(AB_MESSAGE_CONSTLIST2 *l); 
   
  void AB_Message_ConstList2_PopFront(AB_MESSAGE_CONSTLIST2 *l); 
   
  void AB_Message_ConstList2_Clear(AB_MESSAGE_CONSTLIST2 *l); 
   
  AB_MESSAGE_CONSTLIST2_ITERATOR *AB_Message_ConstList2_First(AB_MESSAGE_CONSTLIST2 *l); 
   
  AB_MESSAGE_CONSTLIST2_ITERATOR *AB_Message_ConstList2_Last(AB_MESSAGE_CONSTLIST2 *l); 
   
  AB_MESSAGE_CONSTLIST2_ITERATOR *AB_Message_ConstList2Iterator_new(AB_MESSAGE_CONSTLIST2 *l); 
   
  void AB_Message_ConstList2Iterator_free(AB_MESSAGE_CONSTLIST2_ITERATOR *li); 
   
  const AB_MESSAGE *AB_Message_ConstList2Iterator_Previous(AB_MESSAGE_CONSTLIST2_ITERATOR *li); 
   
  const AB_MESSAGE *AB_Message_ConstList2Iterator_Next(AB_MESSAGE_CONSTLIST2_ITERATOR *li); 
   
  const AB_MESSAGE *AB_Message_ConstList2Iterator_Data(AB_MESSAGE_CONSTLIST2_ITERATOR *li); 
   
  const AB_MESSAGE *AB_Message_ConstList2_ForEach(AB_MESSAGE_CONSTLIST2 *list,
        AB_MESSAGE_CONSTLIST2_FOREACH func, void *user_data);


#ifdef __cplusplus
}
#endif


#endif /* AB_MESSAGE_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 AB_MESSAGE_LIST1_H
#define AB_MESSAGE_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct AB_MESSAGE_LIST_ELEMENT {
    uint32_t id;
    AB_MESSAGE *nextObject;
  } AB_MESSAGE_LIST__ELEMENT;

  typedef struct AB_MESSAGE_LIST AB_MESSAGE_LIST;

  typedef int GWENHYWFAR_CB (*AB_MESSAGE_LIST_SORT_FN)(const AB_MESSAGE *a, const AB_MESSAGE *b, int ascending);


  struct AB_MESSAGE_LIST {
    AB_MESSAGE *first;
    uint32_t count;
    uint32_t id;
  } AB_MESSAGE_LIST;

  void AB_Message_List_AddList(AB_MESSAGE_LIST *dst, AB_MESSAGE_LIST *l);

  void AB_Message_List_Add(AB_MESSAGE *element, AB_MESSAGE_LIST *list);

  void AB_Message_List_Insert(AB_MESSAGE *element, AB_MESSAGE_LIST *list);

  void AB_Message_List_Del(AB_MESSAGE *element);

  AB_MESSAGE* AB_Message_List_First(const AB_MESSAGE_LIST *l);

  AB_MESSAGE* AB_Message_List_Last(const AB_MESSAGE_LIST *l);

  void AB_Message_List_Clear(AB_MESSAGE_LIST *l);

  AB_MESSAGE_LIST* AB_Message_List_new();

  void AB_Message_List_free(AB_MESSAGE_LIST *l);

  AB_MESSAGE* AB_Message_List_Next(const AB_MESSAGE *element);

  AB_MESSAGE* AB_Message_List_Previous(const AB_MESSAGE *element);

  uint32_t AB_Message_List_GetCount(const AB_MESSAGE_LIST *l);

  AB_MESSAGE_LIST_SORT_FN AB_Message_List_SetSortFn(AB_MESSAGE_LIST *l, AB_MESSAGE_LIST_SORT_FN fn);

  void AB_Message_List_Sort(AB_MESSAGE_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 AB_COUNTRY_LIST2_H
#define AB_COUNTRY_LIST2_H


#ifdef __cplusplus
extern "C" {
#endif

  typedef struct AB_COUNTRY_LIST2 AB_COUNTRY_LIST2;

  typedef struct AB_COUNTRY_LIST2_ITERATOR AB_COUNTRY_LIST2_ITERATOR;

  typedef AB_COUNTRY* (AB_COUNTRY_LIST2_FOREACH)(AB_COUNTRY *element,
                                                 void *user_data);

  AB_COUNTRY_LIST2 *AB_Country_List2_new(); 

  void AB_Country_List2_free(AB_COUNTRY_LIST2 *l); 

  void AB_Country_List2_Dump(AB_COUNTRY_LIST2 *l, FILE *f, unsigned int indent); 

  void AB_Country_List2_PushBack(AB_COUNTRY_LIST2 *l, AB_COUNTRY *p); 
   
  void AB_Country_List2_PushFront(AB_COUNTRY_LIST2 *l, AB_COUNTRY *p); 

  AB_COUNTRY *AB_Country_List2_GetFront(AB_COUNTRY_LIST2 *l); 
   
  AB_COUNTRY *AB_Country_List2_GetBack(AB_COUNTRY_LIST2 *l); 

  void AB_Country_List2_Erase(AB_COUNTRY_LIST2 *l,
                               AB_COUNTRY_LIST2_ITERATOR *it);

  unsigned int AB_Country_List2_GetSize(AB_COUNTRY_LIST2 *l); 

  void AB_Country_List2_PopBack(AB_COUNTRY_LIST2 *l); 
   
  void AB_Country_List2_PopFront(AB_COUNTRY_LIST2 *l); 

  void AB_Country_List2_Clear(AB_COUNTRY_LIST2 *l); 

  AB_COUNTRY_LIST2_ITERATOR *AB_Country_List2_First(AB_COUNTRY_LIST2 *l); 
   
  AB_COUNTRY_LIST2_ITERATOR *AB_Country_List2_Last(AB_COUNTRY_LIST2 *l); 

  AB_COUNTRY_LIST2_ITERATOR *AB_Country_List2Iterator_new(AB_COUNTRY_LIST2 *l);

  void AB_Country_List2Iterator_free(AB_COUNTRY_LIST2_ITERATOR *li); 

  AB_COUNTRY *AB_Country_List2Iterator_Previous(AB_COUNTRY_LIST2_ITERATOR *li); 
   
  AB_COUNTRY *AB_Country_List2Iterator_Next(AB_COUNTRY_LIST2_ITERATOR *li); 

  AB_COUNTRY *AB_Country_List2Iterator_Data(AB_COUNTRY_LIST2_ITERATOR *li); 

  AB_COUNTRY *AB_Country_List2_ForEach(AB_COUNTRY_LIST2 *list,
                                        AB_COUNTRY_LIST2_FOREACH func,
                                        void *user_data);


  typedef struct AB_COUNTRY_CONSTLIST2 AB_COUNTRY_CONSTLIST2; 
  typedef struct AB_COUNTRY_CONSTLIST2_ITERATOR AB_COUNTRY_CONSTLIST2_ITERATOR; 
  typedef const AB_COUNTRY*
    (AB_COUNTRY_CONSTLIST2_FOREACH)(const AB_COUNTRY *element,
                                    void *user_data);
  
   
  AB_COUNTRY_CONSTLIST2 *AB_Country_ConstList2_new(); 
   
  void AB_Country_ConstList2_free(AB_COUNTRY_CONSTLIST2 *l); 
   
  void AB_Country_ConstList2_PushBack(AB_COUNTRY_CONSTLIST2 *l, const AB_COUNTRY *p); 
   
  void AB_Country_ConstList2_PushFront(AB_COUNTRY_CONSTLIST2 *l, const AB_COUNTRY *p); 
   
  const AB_COUNTRY *AB_Country_ConstList2_GetFront(AB_COUNTRY_CONSTLIST2 *l); 
   
  const AB_COUNTRY *AB_Country_ConstList2_GetBack(AB_COUNTRY_CONSTLIST2 *l); 
   
  unsigned int AB_Country_ConstList2_GetSize(AB_COUNTRY_CONSTLIST2 *l); 
   
  void AB_Country_ConstList2_PopBack(AB_COUNTRY_CONSTLIST2 *l); 
   
  void AB_Country_ConstList2_PopFront(AB_COUNTRY_CONSTLIST2 *l); 
   
  void AB_Country_ConstList2_Clear(AB_COUNTRY_CONSTLIST2 *l); 
   
  AB_COUNTRY_CONSTLIST2_ITERATOR *AB_Country_ConstList2_First(AB_COUNTRY_CONSTLIST2 *l); 
   
  AB_COUNTRY_CONSTLIST2_ITERATOR *AB_Country_ConstList2_Last(AB_COUNTRY_CONSTLIST2 *l); 
   
  AB_COUNTRY_CONSTLIST2_ITERATOR *AB_Country_ConstList2Iterator_new(AB_COUNTRY_CONSTLIST2 *l); 
   
  void AB_Country_ConstList2Iterator_free(AB_COUNTRY_CONSTLIST2_ITERATOR *li); 
   
  const AB_COUNTRY *AB_Country_ConstList2Iterator_Previous(AB_COUNTRY_CONSTLIST2_ITERATOR *li); 
   
  const AB_COUNTRY *AB_Country_ConstList2Iterator_Next(AB_COUNTRY_CONSTLIST2_ITERATOR *li); 
   
  const AB_COUNTRY *AB_Country_ConstList2Iterator_Data(AB_COUNTRY_CONSTLIST2_ITERATOR *li); 
   
  const AB_COUNTRY *AB_Country_ConstList2_ForEach(AB_COUNTRY_CONSTLIST2 *list,
        AB_COUNTRY_CONSTLIST2_FOREACH func, void *user_data);


#ifdef __cplusplus
}
#endif


#endif /* AB_COUNTRY_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 AB_TEXTKEY_DESCR_LIST2_H
#define AB_TEXTKEY_DESCR_LIST2_H


#ifdef __cplusplus
extern "C" {
#endif

  typedef struct AB_TEXTKEY_DESCR_LIST2 AB_TEXTKEY_DESCR_LIST2;

  typedef struct AB_TEXTKEY_DESCR_LIST2_ITERATOR AB_TEXTKEY_DESCR_LIST2_ITERATOR;

  typedef AB_TEXTKEY_DESCR* (AB_TEXTKEY_DESCR_LIST2_FOREACH)(AB_TEXTKEY_DESCR *element,
                                                 void *user_data);

  AB_TEXTKEY_DESCR_LIST2 *AB_TextKeyDescr_List2_new(); 

  void AB_TextKeyDescr_List2_free(AB_TEXTKEY_DESCR_LIST2 *l); 

  void AB_TextKeyDescr_List2_Dump(AB_TEXTKEY_DESCR_LIST2 *l, FILE *f, unsigned int indent); 

  void AB_TextKeyDescr_List2_PushBack(AB_TEXTKEY_DESCR_LIST2 *l, AB_TEXTKEY_DESCR *p); 
   
  void AB_TextKeyDescr_List2_PushFront(AB_TEXTKEY_DESCR_LIST2 *l, AB_TEXTKEY_DESCR *p); 

  AB_TEXTKEY_DESCR *AB_TextKeyDescr_List2_GetFront(AB_TEXTKEY_DESCR_LIST2 *l); 
   
  AB_TEXTKEY_DESCR *AB_TextKeyDescr_List2_GetBack(AB_TEXTKEY_DESCR_LIST2 *l); 

  void AB_TextKeyDescr_List2_Erase(AB_TEXTKEY_DESCR_LIST2 *l,
                               AB_TEXTKEY_DESCR_LIST2_ITERATOR *it);

  unsigned int AB_TextKeyDescr_List2_GetSize(AB_TEXTKEY_DESCR_LIST2 *l); 

  void AB_TextKeyDescr_List2_PopBack(AB_TEXTKEY_DESCR_LIST2 *l); 
   
  void AB_TextKeyDescr_List2_PopFront(AB_TEXTKEY_DESCR_LIST2 *l); 

  void AB_TextKeyDescr_List2_Clear(AB_TEXTKEY_DESCR_LIST2 *l); 

  AB_TEXTKEY_DESCR_LIST2_ITERATOR *AB_TextKeyDescr_List2_First(AB_TEXTKEY_DESCR_LIST2 *l); 
   
  AB_TEXTKEY_DESCR_LIST2_ITERATOR *AB_TextKeyDescr_List2_Last(AB_TEXTKEY_DESCR_LIST2 *l); 

  AB_TEXTKEY_DESCR_LIST2_ITERATOR *AB_TextKeyDescr_List2Iterator_new(AB_TEXTKEY_DESCR_LIST2 *l);

  void AB_TextKeyDescr_List2Iterator_free(AB_TEXTKEY_DESCR_LIST2_ITERATOR *li); 

  AB_TEXTKEY_DESCR *AB_TextKeyDescr_List2Iterator_Previous(AB_TEXTKEY_DESCR_LIST2_ITERATOR *li); 
   
  AB_TEXTKEY_DESCR *AB_TextKeyDescr_List2Iterator_Next(AB_TEXTKEY_DESCR_LIST2_ITERATOR *li); 

  AB_TEXTKEY_DESCR *AB_TextKeyDescr_List2Iterator_Data(AB_TEXTKEY_DESCR_LIST2_ITERATOR *li); 

  AB_TEXTKEY_DESCR *AB_TextKeyDescr_List2_ForEach(AB_TEXTKEY_DESCR_LIST2 *list,
                                        AB_TEXTKEY_DESCR_LIST2_FOREACH func,
                                        void *user_data);


  typedef struct AB_TEXTKEY_DESCR_CONSTLIST2 AB_TEXTKEY_DESCR_CONSTLIST2; 
  typedef struct AB_TEXTKEY_DESCR_CONSTLIST2_ITERATOR AB_TEXTKEY_DESCR_CONSTLIST2_ITERATOR; 
  typedef const AB_TEXTKEY_DESCR*
    (AB_TEXTKEY_DESCR_CONSTLIST2_FOREACH)(const AB_TEXTKEY_DESCR *element,
                                    void *user_data);
  
   
  AB_TEXTKEY_DESCR_CONSTLIST2 *AB_TextKeyDescr_ConstList2_new(); 
   
  void AB_TextKeyDescr_ConstList2_free(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 
   
  void AB_TextKeyDescr_ConstList2_PushBack(AB_TEXTKEY_DESCR_CONSTLIST2 *l, const AB_TEXTKEY_DESCR *p); 
   
  void AB_TextKeyDescr_ConstList2_PushFront(AB_TEXTKEY_DESCR_CONSTLIST2 *l, const AB_TEXTKEY_DESCR *p); 
   
  const AB_TEXTKEY_DESCR *AB_TextKeyDescr_ConstList2_GetFront(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 
   
  const AB_TEXTKEY_DESCR *AB_TextKeyDescr_ConstList2_GetBack(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 
   
  unsigned int AB_TextKeyDescr_ConstList2_GetSize(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 
   
  void AB_TextKeyDescr_ConstList2_PopBack(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 
   
  void AB_TextKeyDescr_ConstList2_PopFront(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 
   
  void AB_TextKeyDescr_ConstList2_Clear(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 
   
  AB_TEXTKEY_DESCR_CONSTLIST2_ITERATOR *AB_TextKeyDescr_ConstList2_First(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 
   
  AB_TEXTKEY_DESCR_CONSTLIST2_ITERATOR *AB_TextKeyDescr_ConstList2_Last(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 
   
  AB_TEXTKEY_DESCR_CONSTLIST2_ITERATOR *AB_TextKeyDescr_ConstList2Iterator_new(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 
   
  void AB_TextKeyDescr_ConstList2Iterator_free(AB_TEXTKEY_DESCR_CONSTLIST2_ITERATOR *li); 
   
  const AB_TEXTKEY_DESCR *AB_TextKeyDescr_ConstList2Iterator_Previous(AB_TEXTKEY_DESCR_CONSTLIST2_ITERATOR *li); 
   
  const AB_TEXTKEY_DESCR *AB_TextKeyDescr_ConstList2Iterator_Next(AB_TEXTKEY_DESCR_CONSTLIST2_ITERATOR *li); 
   
  const AB_TEXTKEY_DESCR *AB_TextKeyDescr_ConstList2Iterator_Data(AB_TEXTKEY_DESCR_CONSTLIST2_ITERATOR *li); 
   
  const AB_TEXTKEY_DESCR *AB_TextKeyDescr_ConstList2_ForEach(AB_TEXTKEY_DESCR_CONSTLIST2 *list,
        AB_TEXTKEY_DESCR_CONSTLIST2_FOREACH func, void *user_data);


#ifdef __cplusplus
}
#endif


#endif /* AB_TEXTKEY_DESCR_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 AB_TEXTKEY_DESCR_LIST1_H
#define AB_TEXTKEY_DESCR_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct AB_TEXTKEY_DESCR_LIST_ELEMENT {
    uint32_t id;
    AB_TEXTKEY_DESCR *nextObject;
  } AB_TEXTKEY_DESCR_LIST__ELEMENT;

  typedef struct AB_TEXTKEY_DESCR_LIST AB_TEXTKEY_DESCR_LIST;

  typedef int GWENHYWFAR_CB (*AB_TEXTKEY_DESCR_LIST_SORT_FN)(const AB_TEXTKEY_DESCR *a, const AB_TEXTKEY_DESCR *b, int ascending);


  struct AB_TEXTKEY_DESCR_LIST {
    AB_TEXTKEY_DESCR *first;
    uint32_t count;
    uint32_t id;
  } AB_TEXTKEY_DESCR_LIST;

  void AB_TextKeyDescr_List_AddList(AB_TEXTKEY_DESCR_LIST *dst, AB_TEXTKEY_DESCR_LIST *l);

  void AB_TextKeyDescr_List_Add(AB_TEXTKEY_DESCR *element, AB_TEXTKEY_DESCR_LIST *list);

  void AB_TextKeyDescr_List_Insert(AB_TEXTKEY_DESCR *element, AB_TEXTKEY_DESCR_LIST *list);

  void AB_TextKeyDescr_List_Del(AB_TEXTKEY_DESCR *element);

  AB_TEXTKEY_DESCR* AB_TextKeyDescr_List_First(const AB_TEXTKEY_DESCR_LIST *l);

  AB_TEXTKEY_DESCR* AB_TextKeyDescr_List_Last(const AB_TEXTKEY_DESCR_LIST *l);

  void AB_TextKeyDescr_List_Clear(AB_TEXTKEY_DESCR_LIST *l);

  AB_TEXTKEY_DESCR_LIST* AB_TextKeyDescr_List_new();

  void AB_TextKeyDescr_List_free(AB_TEXTKEY_DESCR_LIST *l);

  AB_TEXTKEY_DESCR* AB_TextKeyDescr_List_Next(const AB_TEXTKEY_DESCR *element);

  AB_TEXTKEY_DESCR* AB_TextKeyDescr_List_Previous(const AB_TEXTKEY_DESCR *element);

  uint32_t AB_TextKeyDescr_List_GetCount(const AB_TEXTKEY_DESCR_LIST *l);

  AB_TEXTKEY_DESCR_LIST_SORT_FN AB_TextKeyDescr_List_SetSortFn(AB_TEXTKEY_DESCR_LIST *l, AB_TEXTKEY_DESCR_LIST_SORT_FN fn);

  void AB_TextKeyDescr_List_Sort(AB_TEXTKEY_DESCR_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 AB_JOB_LIST2_H
#define AB_JOB_LIST2_H


#ifdef __cplusplus
extern "C" {
#endif

  typedef struct AB_JOB_LIST2 AB_JOB_LIST2;

  typedef struct AB_JOB_LIST2_ITERATOR AB_JOB_LIST2_ITERATOR;

  typedef AB_JOB* (AB_JOB_LIST2_FOREACH)(AB_JOB *element,
                                                 void *user_data);

  AB_JOB_LIST2 *AB_Job_List2_new(); 

  void AB_Job_List2_free(AB_JOB_LIST2 *l); 

  void AB_Job_List2_Dump(AB_JOB_LIST2 *l, FILE *f, unsigned int indent); 

  void AB_Job_List2_PushBack(AB_JOB_LIST2 *l, AB_JOB *p); 
   
  void AB_Job_List2_PushFront(AB_JOB_LIST2 *l, AB_JOB *p); 

  AB_JOB *AB_Job_List2_GetFront(AB_JOB_LIST2 *l); 
   
  AB_JOB *AB_Job_List2_GetBack(AB_JOB_LIST2 *l); 

  void AB_Job_List2_Erase(AB_JOB_LIST2 *l,
                               AB_JOB_LIST2_ITERATOR *it);

  unsigned int AB_Job_List2_GetSize(AB_JOB_LIST2 *l); 

  void AB_Job_List2_PopBack(AB_JOB_LIST2 *l); 
   
  void AB_Job_List2_PopFront(AB_JOB_LIST2 *l); 

  void AB_Job_List2_Clear(AB_JOB_LIST2 *l); 

  AB_JOB_LIST2_ITERATOR *AB_Job_List2_First(AB_JOB_LIST2 *l); 
   
  AB_JOB_LIST2_ITERATOR *AB_Job_List2_Last(AB_JOB_LIST2 *l); 

  AB_JOB_LIST2_ITERATOR *AB_Job_List2Iterator_new(AB_JOB_LIST2 *l);

  void AB_Job_List2Iterator_free(AB_JOB_LIST2_ITERATOR *li); 

  AB_JOB *AB_Job_List2Iterator_Previous(AB_JOB_LIST2_ITERATOR *li); 
   
  AB_JOB *AB_Job_List2Iterator_Next(AB_JOB_LIST2_ITERATOR *li); 

  AB_JOB *AB_Job_List2Iterator_Data(AB_JOB_LIST2_ITERATOR *li); 

  AB_JOB *AB_Job_List2_ForEach(AB_JOB_LIST2 *list,
                                        AB_JOB_LIST2_FOREACH func,
                                        void *user_data);


  typedef struct AB_JOB_CONSTLIST2 AB_JOB_CONSTLIST2; 
  typedef struct AB_JOB_CONSTLIST2_ITERATOR AB_JOB_CONSTLIST2_ITERATOR; 
  typedef const AB_JOB*
    (AB_JOB_CONSTLIST2_FOREACH)(const AB_JOB *element,
                                    void *user_data);
  
   
  AB_JOB_CONSTLIST2 *AB_Job_ConstList2_new(); 
   
  void AB_Job_ConstList2_free(AB_JOB_CONSTLIST2 *l); 
   
  void AB_Job_ConstList2_PushBack(AB_JOB_CONSTLIST2 *l, const AB_JOB *p); 
   
  void AB_Job_ConstList2_PushFront(AB_JOB_CONSTLIST2 *l, const AB_JOB *p); 
   
  const AB_JOB *AB_Job_ConstList2_GetFront(AB_JOB_CONSTLIST2 *l); 
   
  const AB_JOB *AB_Job_ConstList2_GetBack(AB_JOB_CONSTLIST2 *l); 
   
  unsigned int AB_Job_ConstList2_GetSize(AB_JOB_CONSTLIST2 *l); 
   
  void AB_Job_ConstList2_PopBack(AB_JOB_CONSTLIST2 *l); 
   
  void AB_Job_ConstList2_PopFront(AB_JOB_CONSTLIST2 *l); 
   
  void AB_Job_ConstList2_Clear(AB_JOB_CONSTLIST2 *l); 
   
  AB_JOB_CONSTLIST2_ITERATOR *AB_Job_ConstList2_First(AB_JOB_CONSTLIST2 *l); 
   
  AB_JOB_CONSTLIST2_ITERATOR *AB_Job_ConstList2_Last(AB_JOB_CONSTLIST2 *l); 
   
  AB_JOB_CONSTLIST2_ITERATOR *AB_Job_ConstList2Iterator_new(AB_JOB_CONSTLIST2 *l); 
   
  void AB_Job_ConstList2Iterator_free(AB_JOB_CONSTLIST2_ITERATOR *li); 
   
  const AB_JOB *AB_Job_ConstList2Iterator_Previous(AB_JOB_CONSTLIST2_ITERATOR *li); 
   
  const AB_JOB *AB_Job_ConstList2Iterator_Next(AB_JOB_CONSTLIST2_ITERATOR *li); 
   
  const AB_JOB *AB_Job_ConstList2Iterator_Data(AB_JOB_CONSTLIST2_ITERATOR *li); 
   
  const AB_JOB *AB_Job_ConstList2_ForEach(AB_JOB_CONSTLIST2 *list,
        AB_JOB_CONSTLIST2_FOREACH func, void *user_data);


#ifdef __cplusplus
}
#endif


#endif /* AB_JOB_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 AB_USER_LIST2_H
#define AB_USER_LIST2_H


#ifdef __cplusplus
extern "C" {
#endif

  typedef struct AB_USER_LIST2 AB_USER_LIST2;

  typedef struct AB_USER_LIST2_ITERATOR AB_USER_LIST2_ITERATOR;

  typedef AB_USER* (AB_USER_LIST2_FOREACH)(AB_USER *element,
                                                 void *user_data);

  AB_USER_LIST2 *AB_User_List2_new(); 

  void AB_User_List2_free(AB_USER_LIST2 *l); 

  void AB_User_List2_Dump(AB_USER_LIST2 *l, FILE *f, unsigned int indent); 

  void AB_User_List2_PushBack(AB_USER_LIST2 *l, AB_USER *p); 
   
  void AB_User_List2_PushFront(AB_USER_LIST2 *l, AB_USER *p); 

  AB_USER *AB_User_List2_GetFront(AB_USER_LIST2 *l); 
   
  AB_USER *AB_User_List2_GetBack(AB_USER_LIST2 *l); 

  void AB_User_List2_Erase(AB_USER_LIST2 *l,
                               AB_USER_LIST2_ITERATOR *it);

  unsigned int AB_User_List2_GetSize(AB_USER_LIST2 *l); 

  void AB_User_List2_PopBack(AB_USER_LIST2 *l); 
   
  void AB_User_List2_PopFront(AB_USER_LIST2 *l); 

  void AB_User_List2_Clear(AB_USER_LIST2 *l); 

  AB_USER_LIST2_ITERATOR *AB_User_List2_First(AB_USER_LIST2 *l); 
   
  AB_USER_LIST2_ITERATOR *AB_User_List2_Last(AB_USER_LIST2 *l); 

  AB_USER_LIST2_ITERATOR *AB_User_List2Iterator_new(AB_USER_LIST2 *l);

  void AB_User_List2Iterator_free(AB_USER_LIST2_ITERATOR *li); 

  AB_USER *AB_User_List2Iterator_Previous(AB_USER_LIST2_ITERATOR *li); 
   
  AB_USER *AB_User_List2Iterator_Next(AB_USER_LIST2_ITERATOR *li); 

  AB_USER *AB_User_List2Iterator_Data(AB_USER_LIST2_ITERATOR *li); 

  AB_USER *AB_User_List2_ForEach(AB_USER_LIST2 *list,
                                        AB_USER_LIST2_FOREACH func,
                                        void *user_data);


  typedef struct AB_USER_CONSTLIST2 AB_USER_CONSTLIST2; 
  typedef struct AB_USER_CONSTLIST2_ITERATOR AB_USER_CONSTLIST2_ITERATOR; 
  typedef const AB_USER*
    (AB_USER_CONSTLIST2_FOREACH)(const AB_USER *element,
                                    void *user_data);
  
   
  AB_USER_CONSTLIST2 *AB_User_ConstList2_new(); 
   
  void AB_User_ConstList2_free(AB_USER_CONSTLIST2 *l); 
   
  void AB_User_ConstList2_PushBack(AB_USER_CONSTLIST2 *l, const AB_USER *p); 
   
  void AB_User_ConstList2_PushFront(AB_USER_CONSTLIST2 *l, const AB_USER *p); 
   
  const AB_USER *AB_User_ConstList2_GetFront(AB_USER_CONSTLIST2 *l); 
   
  const AB_USER *AB_User_ConstList2_GetBack(AB_USER_CONSTLIST2 *l); 
   
  unsigned int AB_User_ConstList2_GetSize(AB_USER_CONSTLIST2 *l); 
   
  void AB_User_ConstList2_PopBack(AB_USER_CONSTLIST2 *l); 
   
  void AB_User_ConstList2_PopFront(AB_USER_CONSTLIST2 *l); 
   
  void AB_User_ConstList2_Clear(AB_USER_CONSTLIST2 *l); 
   
  AB_USER_CONSTLIST2_ITERATOR *AB_User_ConstList2_First(AB_USER_CONSTLIST2 *l); 
   
  AB_USER_CONSTLIST2_ITERATOR *AB_User_ConstList2_Last(AB_USER_CONSTLIST2 *l); 
   
  AB_USER_CONSTLIST2_ITERATOR *AB_User_ConstList2Iterator_new(AB_USER_CONSTLIST2 *l); 
   
  void AB_User_ConstList2Iterator_free(AB_USER_CONSTLIST2_ITERATOR *li); 
   
  const AB_USER *AB_User_ConstList2Iterator_Previous(AB_USER_CONSTLIST2_ITERATOR *li); 
   
  const AB_USER *AB_User_ConstList2Iterator_Next(AB_USER_CONSTLIST2_ITERATOR *li); 
   
  const AB_USER *AB_User_ConstList2Iterator_Data(AB_USER_CONSTLIST2_ITERATOR *li); 
   
  const AB_USER *AB_User_ConstList2_ForEach(AB_USER_CONSTLIST2 *list,
        AB_USER_CONSTLIST2_FOREACH func, void *user_data);


#ifdef __cplusplus
}
#endif


#endif /* AB_USER_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 AB_BANKINFO_PLUGIN_LIST2_H
#define AB_BANKINFO_PLUGIN_LIST2_H


#ifdef __cplusplus
extern "C" {
#endif

  typedef struct AB_BANKINFO_PLUGIN_LIST2 AB_BANKINFO_PLUGIN_LIST2;

  typedef struct AB_BANKINFO_PLUGIN_LIST2_ITERATOR AB_BANKINFO_PLUGIN_LIST2_ITERATOR;

  typedef AB_BANKINFO_PLUGIN* (AB_BANKINFO_PLUGIN_LIST2_FOREACH)(AB_BANKINFO_PLUGIN *element,
                                                 void *user_data);

  AB_BANKINFO_PLUGIN_LIST2 *AB_BankInfoPlugin_List2_new(); 

  void AB_BankInfoPlugin_List2_free(AB_BANKINFO_PLUGIN_LIST2 *l); 

  void AB_BankInfoPlugin_List2_Dump(AB_BANKINFO_PLUGIN_LIST2 *l, FILE *f, unsigned int indent); 

  void AB_BankInfoPlugin_List2_PushBack(AB_BANKINFO_PLUGIN_LIST2 *l, AB_BANKINFO_PLUGIN *p); 
   
  void AB_BankInfoPlugin_List2_PushFront(AB_BANKINFO_PLUGIN_LIST2 *l, AB_BANKINFO_PLUGIN *p); 

  AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_List2_GetFront(AB_BANKINFO_PLUGIN_LIST2 *l); 
   
  AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_List2_GetBack(AB_BANKINFO_PLUGIN_LIST2 *l); 

  void AB_BankInfoPlugin_List2_Erase(AB_BANKINFO_PLUGIN_LIST2 *l,
                               AB_BANKINFO_PLUGIN_LIST2_ITERATOR *it);

  unsigned int AB_BankInfoPlugin_List2_GetSize(AB_BANKINFO_PLUGIN_LIST2 *l); 

  void AB_BankInfoPlugin_List2_PopBack(AB_BANKINFO_PLUGIN_LIST2 *l); 
   
  void AB_BankInfoPlugin_List2_PopFront(AB_BANKINFO_PLUGIN_LIST2 *l); 

  void AB_BankInfoPlugin_List2_Clear(AB_BANKINFO_PLUGIN_LIST2 *l); 

  AB_BANKINFO_PLUGIN_LIST2_ITERATOR *AB_BankInfoPlugin_List2_First(AB_BANKINFO_PLUGIN_LIST2 *l); 
   
  AB_BANKINFO_PLUGIN_LIST2_ITERATOR *AB_BankInfoPlugin_List2_Last(AB_BANKINFO_PLUGIN_LIST2 *l); 

  AB_BANKINFO_PLUGIN_LIST2_ITERATOR *AB_BankInfoPlugin_List2Iterator_new(AB_BANKINFO_PLUGIN_LIST2 *l);

  void AB_BankInfoPlugin_List2Iterator_free(AB_BANKINFO_PLUGIN_LIST2_ITERATOR *li); 

  AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_List2Iterator_Previous(AB_BANKINFO_PLUGIN_LIST2_ITERATOR *li); 
   
  AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_List2Iterator_Next(AB_BANKINFO_PLUGIN_LIST2_ITERATOR *li); 

  AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_List2Iterator_Data(AB_BANKINFO_PLUGIN_LIST2_ITERATOR *li); 

  AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_List2_ForEach(AB_BANKINFO_PLUGIN_LIST2 *list,
                                        AB_BANKINFO_PLUGIN_LIST2_FOREACH func,
                                        void *user_data);


  typedef struct AB_BANKINFO_PLUGIN_CONSTLIST2 AB_BANKINFO_PLUGIN_CONSTLIST2; 
  typedef struct AB_BANKINFO_PLUGIN_CONSTLIST2_ITERATOR AB_BANKINFO_PLUGIN_CONSTLIST2_ITERATOR; 
  typedef const AB_BANKINFO_PLUGIN*
    (AB_BANKINFO_PLUGIN_CONSTLIST2_FOREACH)(const AB_BANKINFO_PLUGIN *element,
                                    void *user_data);
  
   
  AB_BANKINFO_PLUGIN_CONSTLIST2 *AB_BankInfoPlugin_ConstList2_new(); 
   
  void AB_BankInfoPlugin_ConstList2_free(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 
   
  void AB_BankInfoPlugin_ConstList2_PushBack(AB_BANKINFO_PLUGIN_CONSTLIST2 *l, const AB_BANKINFO_PLUGIN *p); 
   
  void AB_BankInfoPlugin_ConstList2_PushFront(AB_BANKINFO_PLUGIN_CONSTLIST2 *l, const AB_BANKINFO_PLUGIN *p); 
   
  const AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_ConstList2_GetFront(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 
   
  const AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_ConstList2_GetBack(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 
   
  unsigned int AB_BankInfoPlugin_ConstList2_GetSize(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 
   
  void AB_BankInfoPlugin_ConstList2_PopBack(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 
   
  void AB_BankInfoPlugin_ConstList2_PopFront(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 
   
  void AB_BankInfoPlugin_ConstList2_Clear(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 
   
  AB_BANKINFO_PLUGIN_CONSTLIST2_ITERATOR *AB_BankInfoPlugin_ConstList2_First(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 
   
  AB_BANKINFO_PLUGIN_CONSTLIST2_ITERATOR *AB_BankInfoPlugin_ConstList2_Last(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 
   
  AB_BANKINFO_PLUGIN_CONSTLIST2_ITERATOR *AB_BankInfoPlugin_ConstList2Iterator_new(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 
   
  void AB_BankInfoPlugin_ConstList2Iterator_free(AB_BANKINFO_PLUGIN_CONSTLIST2_ITERATOR *li); 
   
  const AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_ConstList2Iterator_Previous(AB_BANKINFO_PLUGIN_CONSTLIST2_ITERATOR *li); 
   
  const AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_ConstList2Iterator_Next(AB_BANKINFO_PLUGIN_CONSTLIST2_ITERATOR *li); 
   
  const AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_ConstList2Iterator_Data(AB_BANKINFO_PLUGIN_CONSTLIST2_ITERATOR *li); 
   
  const AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_ConstList2_ForEach(AB_BANKINFO_PLUGIN_CONSTLIST2 *list,
        AB_BANKINFO_PLUGIN_CONSTLIST2_FOREACH func, void *user_data);


#ifdef __cplusplus
}
#endif


#endif /* AB_BANKINFO_PLUGIN_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 AB_VALUE_LIST1_H
#define AB_VALUE_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct AB_VALUE_LIST_ELEMENT {
    uint32_t id;
    AB_VALUE *nextObject;
  } AB_VALUE_LIST__ELEMENT;

  typedef struct AB_VALUE_LIST AB_VALUE_LIST;

  typedef int GWENHYWFAR_CB (*AB_VALUE_LIST_SORT_FN)(const AB_VALUE *a, const AB_VALUE *b, int ascending);


  struct AB_VALUE_LIST {
    AB_VALUE *first;
    uint32_t count;
    uint32_t id;
  } AB_VALUE_LIST;

  void AB_Value_List_AddList(AB_VALUE_LIST *dst, AB_VALUE_LIST *l);

  void AB_Value_List_Add(AB_VALUE *element, AB_VALUE_LIST *list);

  void AB_Value_List_Insert(AB_VALUE *element, AB_VALUE_LIST *list);

  void AB_Value_List_Del(AB_VALUE *element);

  AB_VALUE* AB_Value_List_First(const AB_VALUE_LIST *l);

  AB_VALUE* AB_Value_List_Last(const AB_VALUE_LIST *l);

  void AB_Value_List_Clear(AB_VALUE_LIST *l);

  AB_VALUE_LIST* AB_Value_List_new();

  void AB_Value_List_free(AB_VALUE_LIST *l);

  AB_VALUE* AB_Value_List_Next(const AB_VALUE *element);

  AB_VALUE* AB_Value_List_Previous(const AB_VALUE *element);

  uint32_t AB_Value_List_GetCount(const AB_VALUE_LIST *l);

  AB_VALUE_LIST_SORT_FN AB_Value_List_SetSortFn(AB_VALUE_LIST *l, AB_VALUE_LIST_SORT_FN fn);

  void AB_Value_List_Sort(AB_VALUE_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 AB_SECURITY_LIST2_H
#define AB_SECURITY_LIST2_H


#ifdef __cplusplus
extern "C" {
#endif

  typedef struct AB_SECURITY_LIST2 AB_SECURITY_LIST2;

  typedef struct AB_SECURITY_LIST2_ITERATOR AB_SECURITY_LIST2_ITERATOR;

  typedef AB_SECURITY* (AB_SECURITY_LIST2_FOREACH)(AB_SECURITY *element,
                                                 void *user_data);

  AB_SECURITY_LIST2 *AB_Security_List2_new(); 

  void AB_Security_List2_free(AB_SECURITY_LIST2 *l); 

  void AB_Security_List2_Dump(AB_SECURITY_LIST2 *l, FILE *f, unsigned int indent); 

  void AB_Security_List2_PushBack(AB_SECURITY_LIST2 *l, AB_SECURITY *p); 
   
  void AB_Security_List2_PushFront(AB_SECURITY_LIST2 *l, AB_SECURITY *p); 

  AB_SECURITY *AB_Security_List2_GetFront(AB_SECURITY_LIST2 *l); 
   
  AB_SECURITY *AB_Security_List2_GetBack(AB_SECURITY_LIST2 *l); 

  void AB_Security_List2_Erase(AB_SECURITY_LIST2 *l,
                               AB_SECURITY_LIST2_ITERATOR *it);

  unsigned int AB_Security_List2_GetSize(AB_SECURITY_LIST2 *l); 

  void AB_Security_List2_PopBack(AB_SECURITY_LIST2 *l); 
   
  void AB_Security_List2_PopFront(AB_SECURITY_LIST2 *l); 

  void AB_Security_List2_Clear(AB_SECURITY_LIST2 *l); 

  AB_SECURITY_LIST2_ITERATOR *AB_Security_List2_First(AB_SECURITY_LIST2 *l); 
   
  AB_SECURITY_LIST2_ITERATOR *AB_Security_List2_Last(AB_SECURITY_LIST2 *l); 

  AB_SECURITY_LIST2_ITERATOR *AB_Security_List2Iterator_new(AB_SECURITY_LIST2 *l);

  void AB_Security_List2Iterator_free(AB_SECURITY_LIST2_ITERATOR *li); 

  AB_SECURITY *AB_Security_List2Iterator_Previous(AB_SECURITY_LIST2_ITERATOR *li); 
   
  AB_SECURITY *AB_Security_List2Iterator_Next(AB_SECURITY_LIST2_ITERATOR *li); 

  AB_SECURITY *AB_Security_List2Iterator_Data(AB_SECURITY_LIST2_ITERATOR *li); 

  AB_SECURITY *AB_Security_List2_ForEach(AB_SECURITY_LIST2 *list,
                                        AB_SECURITY_LIST2_FOREACH func,
                                        void *user_data);


  typedef struct AB_SECURITY_CONSTLIST2 AB_SECURITY_CONSTLIST2; 
  typedef struct AB_SECURITY_CONSTLIST2_ITERATOR AB_SECURITY_CONSTLIST2_ITERATOR; 
  typedef const AB_SECURITY*
    (AB_SECURITY_CONSTLIST2_FOREACH)(const AB_SECURITY *element,
                                    void *user_data);
  
   
  AB_SECURITY_CONSTLIST2 *AB_Security_ConstList2_new(); 
   
  void AB_Security_ConstList2_free(AB_SECURITY_CONSTLIST2 *l); 
   
  void AB_Security_ConstList2_PushBack(AB_SECURITY_CONSTLIST2 *l, const AB_SECURITY *p); 
   
  void AB_Security_ConstList2_PushFront(AB_SECURITY_CONSTLIST2 *l, const AB_SECURITY *p); 
   
  const AB_SECURITY *AB_Security_ConstList2_GetFront(AB_SECURITY_CONSTLIST2 *l); 
   
  const AB_SECURITY *AB_Security_ConstList2_GetBack(AB_SECURITY_CONSTLIST2 *l); 
   
  unsigned int AB_Security_ConstList2_GetSize(AB_SECURITY_CONSTLIST2 *l); 
   
  void AB_Security_ConstList2_PopBack(AB_SECURITY_CONSTLIST2 *l); 
   
  void AB_Security_ConstList2_PopFront(AB_SECURITY_CONSTLIST2 *l); 
   
  void AB_Security_ConstList2_Clear(AB_SECURITY_CONSTLIST2 *l); 
   
  AB_SECURITY_CONSTLIST2_ITERATOR *AB_Security_ConstList2_First(AB_SECURITY_CONSTLIST2 *l); 
   
  AB_SECURITY_CONSTLIST2_ITERATOR *AB_Security_ConstList2_Last(AB_SECURITY_CONSTLIST2 *l); 
   
  AB_SECURITY_CONSTLIST2_ITERATOR *AB_Security_ConstList2Iterator_new(AB_SECURITY_CONSTLIST2 *l); 
   
  void AB_Security_ConstList2Iterator_free(AB_SECURITY_CONSTLIST2_ITERATOR *li); 
   
  const AB_SECURITY *AB_Security_ConstList2Iterator_Previous(AB_SECURITY_CONSTLIST2_ITERATOR *li); 
   
  const AB_SECURITY *AB_Security_ConstList2Iterator_Next(AB_SECURITY_CONSTLIST2_ITERATOR *li); 
   
  const AB_SECURITY *AB_Security_ConstList2Iterator_Data(AB_SECURITY_CONSTLIST2_ITERATOR *li); 
   
  const AB_SECURITY *AB_Security_ConstList2_ForEach(AB_SECURITY_CONSTLIST2 *list,
        AB_SECURITY_CONSTLIST2_FOREACH func, void *user_data);


#ifdef __cplusplus
}
#endif


#endif /* AB_SECURITY_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 AB_SECURITY_LIST1_H
#define AB_SECURITY_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct AB_SECURITY_LIST_ELEMENT {
    uint32_t id;
    AB_SECURITY *nextObject;
  } AB_SECURITY_LIST__ELEMENT;

  typedef struct AB_SECURITY_LIST AB_SECURITY_LIST;

  typedef int GWENHYWFAR_CB (*AB_SECURITY_LIST_SORT_FN)(const AB_SECURITY *a, const AB_SECURITY *b, int ascending);


  struct AB_SECURITY_LIST {
    AB_SECURITY *first;
    uint32_t count;
    uint32_t id;
  } AB_SECURITY_LIST;

  void AB_Security_List_AddList(AB_SECURITY_LIST *dst, AB_SECURITY_LIST *l);

  void AB_Security_List_Add(AB_SECURITY *element, AB_SECURITY_LIST *list);

  void AB_Security_List_Insert(AB_SECURITY *element, AB_SECURITY_LIST *list);

  void AB_Security_List_Del(AB_SECURITY *element);

  AB_SECURITY* AB_Security_List_First(const AB_SECURITY_LIST *l);

  AB_SECURITY* AB_Security_List_Last(const AB_SECURITY_LIST *l);

  void AB_Security_List_Clear(AB_SECURITY_LIST *l);

  AB_SECURITY_LIST* AB_Security_List_new();

  void AB_Security_List_free(AB_SECURITY_LIST *l);

  AB_SECURITY* AB_Security_List_Next(const AB_SECURITY *element);

  AB_SECURITY* AB_Security_List_Previous(const AB_SECURITY *element);

  uint32_t AB_Security_List_GetCount(const AB_SECURITY_LIST *l);

  AB_SECURITY_LIST_SORT_FN AB_Security_List_SetSortFn(AB_SECURITY_LIST *l, AB_SECURITY_LIST_SORT_FN fn);

  void AB_Security_List_Sort(AB_SECURITY_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 AB_BANKINFO_SERVICE_LIST2_H
#define AB_BANKINFO_SERVICE_LIST2_H


#ifdef __cplusplus
extern "C" {
#endif

  typedef struct AB_BANKINFO_SERVICE_LIST2 AB_BANKINFO_SERVICE_LIST2;

  typedef struct AB_BANKINFO_SERVICE_LIST2_ITERATOR AB_BANKINFO_SERVICE_LIST2_ITERATOR;

  typedef AB_BANKINFO_SERVICE* (AB_BANKINFO_SERVICE_LIST2_FOREACH)(AB_BANKINFO_SERVICE *element,
                                                 void *user_data);

  AB_BANKINFO_SERVICE_LIST2 *AB_BankInfoService_List2_new(); 

  void AB_BankInfoService_List2_free(AB_BANKINFO_SERVICE_LIST2 *l); 

  void AB_BankInfoService_List2_Dump(AB_BANKINFO_SERVICE_LIST2 *l, FILE *f, unsigned int indent); 

  void AB_BankInfoService_List2_PushBack(AB_BANKINFO_SERVICE_LIST2 *l, AB_BANKINFO_SERVICE *p); 
   
  void AB_BankInfoService_List2_PushFront(AB_BANKINFO_SERVICE_LIST2 *l, AB_BANKINFO_SERVICE *p); 

  AB_BANKINFO_SERVICE *AB_BankInfoService_List2_GetFront(AB_BANKINFO_SERVICE_LIST2 *l); 
   
  AB_BANKINFO_SERVICE *AB_BankInfoService_List2_GetBack(AB_BANKINFO_SERVICE_LIST2 *l); 

  void AB_BankInfoService_List2_Erase(AB_BANKINFO_SERVICE_LIST2 *l,
                               AB_BANKINFO_SERVICE_LIST2_ITERATOR *it);

  unsigned int AB_BankInfoService_List2_GetSize(AB_BANKINFO_SERVICE_LIST2 *l); 

  void AB_BankInfoService_List2_PopBack(AB_BANKINFO_SERVICE_LIST2 *l); 
   
  void AB_BankInfoService_List2_PopFront(AB_BANKINFO_SERVICE_LIST2 *l); 

  void AB_BankInfoService_List2_Clear(AB_BANKINFO_SERVICE_LIST2 *l); 

  AB_BANKINFO_SERVICE_LIST2_ITERATOR *AB_BankInfoService_List2_First(AB_BANKINFO_SERVICE_LIST2 *l); 
   
  AB_BANKINFO_SERVICE_LIST2_ITERATOR *AB_BankInfoService_List2_Last(AB_BANKINFO_SERVICE_LIST2 *l); 

  AB_BANKINFO_SERVICE_LIST2_ITERATOR *AB_BankInfoService_List2Iterator_new(AB_BANKINFO_SERVICE_LIST2 *l);

  void AB_BankInfoService_List2Iterator_free(AB_BANKINFO_SERVICE_LIST2_ITERATOR *li); 

  AB_BANKINFO_SERVICE *AB_BankInfoService_List2Iterator_Previous(AB_BANKINFO_SERVICE_LIST2_ITERATOR *li); 
   
  AB_BANKINFO_SERVICE *AB_BankInfoService_List2Iterator_Next(AB_BANKINFO_SERVICE_LIST2_ITERATOR *li); 

  AB_BANKINFO_SERVICE *AB_BankInfoService_List2Iterator_Data(AB_BANKINFO_SERVICE_LIST2_ITERATOR *li); 

  AB_BANKINFO_SERVICE *AB_BankInfoService_List2_ForEach(AB_BANKINFO_SERVICE_LIST2 *list,
                                        AB_BANKINFO_SERVICE_LIST2_FOREACH func,
                                        void *user_data);


  typedef struct AB_BANKINFO_SERVICE_CONSTLIST2 AB_BANKINFO_SERVICE_CONSTLIST2; 
  typedef struct AB_BANKINFO_SERVICE_CONSTLIST2_ITERATOR AB_BANKINFO_SERVICE_CONSTLIST2_ITERATOR; 
  typedef const AB_BANKINFO_SERVICE*
    (AB_BANKINFO_SERVICE_CONSTLIST2_FOREACH)(const AB_BANKINFO_SERVICE *element,
                                    void *user_data);
  
   
  AB_BANKINFO_SERVICE_CONSTLIST2 *AB_BankInfoService_ConstList2_new(); 
   
  void AB_BankInfoService_ConstList2_free(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 
   
  void AB_BankInfoService_ConstList2_PushBack(AB_BANKINFO_SERVICE_CONSTLIST2 *l, const AB_BANKINFO_SERVICE *p); 
   
  void AB_BankInfoService_ConstList2_PushFront(AB_BANKINFO_SERVICE_CONSTLIST2 *l, const AB_BANKINFO_SERVICE *p); 
   
  const AB_BANKINFO_SERVICE *AB_BankInfoService_ConstList2_GetFront(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 
   
  const AB_BANKINFO_SERVICE *AB_BankInfoService_ConstList2_GetBack(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 
   
  unsigned int AB_BankInfoService_ConstList2_GetSize(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 
   
  void AB_BankInfoService_ConstList2_PopBack(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 
   
  void AB_BankInfoService_ConstList2_PopFront(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 
   
  void AB_BankInfoService_ConstList2_Clear(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 
   
  AB_BANKINFO_SERVICE_CONSTLIST2_ITERATOR *AB_BankInfoService_ConstList2_First(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 
   
  AB_BANKINFO_SERVICE_CONSTLIST2_ITERATOR *AB_BankInfoService_ConstList2_Last(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 
   
  AB_BANKINFO_SERVICE_CONSTLIST2_ITERATOR *AB_BankInfoService_ConstList2Iterator_new(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 
   
  void AB_BankInfoService_ConstList2Iterator_free(AB_BANKINFO_SERVICE_CONSTLIST2_ITERATOR *li); 
   
  const AB_BANKINFO_SERVICE *AB_BankInfoService_ConstList2Iterator_Previous(AB_BANKINFO_SERVICE_CONSTLIST2_ITERATOR *li); 
   
  const AB_BANKINFO_SERVICE *AB_BankInfoService_ConstList2Iterator_Next(AB_BANKINFO_SERVICE_CONSTLIST2_ITERATOR *li); 
   
  const AB_BANKINFO_SERVICE *AB_BankInfoService_ConstList2Iterator_Data(AB_BANKINFO_SERVICE_CONSTLIST2_ITERATOR *li); 
   
  const AB_BANKINFO_SERVICE *AB_BankInfoService_ConstList2_ForEach(AB_BANKINFO_SERVICE_CONSTLIST2 *list,
        AB_BANKINFO_SERVICE_CONSTLIST2_FOREACH func, void *user_data);


#ifdef __cplusplus
}
#endif


#endif /* AB_BANKINFO_SERVICE_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 AB_BANKINFO_SERVICE_LIST1_H
#define AB_BANKINFO_SERVICE_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct AB_BANKINFO_SERVICE_LIST_ELEMENT {
    uint32_t id;
    AB_BANKINFO_SERVICE *nextObject;
  } AB_BANKINFO_SERVICE_LIST__ELEMENT;

  typedef struct AB_BANKINFO_SERVICE_LIST AB_BANKINFO_SERVICE_LIST;

  typedef int GWENHYWFAR_CB (*AB_BANKINFO_SERVICE_LIST_SORT_FN)(const AB_BANKINFO_SERVICE *a, const AB_BANKINFO_SERVICE *b, int ascending);


  struct AB_BANKINFO_SERVICE_LIST {
    AB_BANKINFO_SERVICE *first;
    uint32_t count;
    uint32_t id;
  } AB_BANKINFO_SERVICE_LIST;

  void AB_BankInfoService_List_AddList(AB_BANKINFO_SERVICE_LIST *dst, AB_BANKINFO_SERVICE_LIST *l);

  void AB_BankInfoService_List_Add(AB_BANKINFO_SERVICE *element, AB_BANKINFO_SERVICE_LIST *list);

  void AB_BankInfoService_List_Insert(AB_BANKINFO_SERVICE *element, AB_BANKINFO_SERVICE_LIST *list);

  void AB_BankInfoService_List_Del(AB_BANKINFO_SERVICE *element);

  AB_BANKINFO_SERVICE* AB_BankInfoService_List_First(const AB_BANKINFO_SERVICE_LIST *l);

  AB_BANKINFO_SERVICE* AB_BankInfoService_List_Last(const AB_BANKINFO_SERVICE_LIST *l);

  void AB_BankInfoService_List_Clear(AB_BANKINFO_SERVICE_LIST *l);

  AB_BANKINFO_SERVICE_LIST* AB_BankInfoService_List_new();

  void AB_BankInfoService_List_free(AB_BANKINFO_SERVICE_LIST *l);

  AB_BANKINFO_SERVICE* AB_BankInfoService_List_Next(const AB_BANKINFO_SERVICE *element);

  AB_BANKINFO_SERVICE* AB_BankInfoService_List_Previous(const AB_BANKINFO_SERVICE *element);

  uint32_t AB_BankInfoService_List_GetCount(const AB_BANKINFO_SERVICE_LIST *l);

  AB_BANKINFO_SERVICE_LIST_SORT_FN AB_BankInfoService_List_SetSortFn(AB_BANKINFO_SERVICE_LIST *l, AB_BANKINFO_SERVICE_LIST_SORT_FN fn);

  void AB_BankInfoService_List_Sort(AB_BANKINFO_SERVICE_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 AB_BANKINFO_LIST2_H
#define AB_BANKINFO_LIST2_H


#ifdef __cplusplus
extern "C" {
#endif

  typedef struct AB_BANKINFO_LIST2 AB_BANKINFO_LIST2;

  typedef struct AB_BANKINFO_LIST2_ITERATOR AB_BANKINFO_LIST2_ITERATOR;

  typedef AB_BANKINFO* (AB_BANKINFO_LIST2_FOREACH)(AB_BANKINFO *element,
                                                 void *user_data);

  AB_BANKINFO_LIST2 *AB_BankInfo_List2_new(); 

  void AB_BankInfo_List2_free(AB_BANKINFO_LIST2 *l); 

  void AB_BankInfo_List2_Dump(AB_BANKINFO_LIST2 *l, FILE *f, unsigned int indent); 

  void AB_BankInfo_List2_PushBack(AB_BANKINFO_LIST2 *l, AB_BANKINFO *p); 
   
  void AB_BankInfo_List2_PushFront(AB_BANKINFO_LIST2 *l, AB_BANKINFO *p); 

  AB_BANKINFO *AB_BankInfo_List2_GetFront(AB_BANKINFO_LIST2 *l); 
   
  AB_BANKINFO *AB_BankInfo_List2_GetBack(AB_BANKINFO_LIST2 *l); 

  void AB_BankInfo_List2_Erase(AB_BANKINFO_LIST2 *l,
                               AB_BANKINFO_LIST2_ITERATOR *it);

  unsigned int AB_BankInfo_List2_GetSize(AB_BANKINFO_LIST2 *l); 

  void AB_BankInfo_List2_PopBack(AB_BANKINFO_LIST2 *l); 
   
  void AB_BankInfo_List2_PopFront(AB_BANKINFO_LIST2 *l); 

  void AB_BankInfo_List2_Clear(AB_BANKINFO_LIST2 *l); 

  AB_BANKINFO_LIST2_ITERATOR *AB_BankInfo_List2_First(AB_BANKINFO_LIST2 *l); 
   
  AB_BANKINFO_LIST2_ITERATOR *AB_BankInfo_List2_Last(AB_BANKINFO_LIST2 *l); 

  AB_BANKINFO_LIST2_ITERATOR *AB_BankInfo_List2Iterator_new(AB_BANKINFO_LIST2 *l);

  void AB_BankInfo_List2Iterator_free(AB_BANKINFO_LIST2_ITERATOR *li); 

  AB_BANKINFO *AB_BankInfo_List2Iterator_Previous(AB_BANKINFO_LIST2_ITERATOR *li); 
   
  AB_BANKINFO *AB_BankInfo_List2Iterator_Next(AB_BANKINFO_LIST2_ITERATOR *li); 

  AB_BANKINFO *AB_BankInfo_List2Iterator_Data(AB_BANKINFO_LIST2_ITERATOR *li); 

  AB_BANKINFO *AB_BankInfo_List2_ForEach(AB_BANKINFO_LIST2 *list,
                                        AB_BANKINFO_LIST2_FOREACH func,
                                        void *user_data);


  typedef struct AB_BANKINFO_CONSTLIST2 AB_BANKINFO_CONSTLIST2; 
  typedef struct AB_BANKINFO_CONSTLIST2_ITERATOR AB_BANKINFO_CONSTLIST2_ITERATOR; 
  typedef const AB_BANKINFO*
    (AB_BANKINFO_CONSTLIST2_FOREACH)(const AB_BANKINFO *element,
                                    void *user_data);
  
   
  AB_BANKINFO_CONSTLIST2 *AB_BankInfo_ConstList2_new(); 
   
  void AB_BankInfo_ConstList2_free(AB_BANKINFO_CONSTLIST2 *l); 
   
  void AB_BankInfo_ConstList2_PushBack(AB_BANKINFO_CONSTLIST2 *l, const AB_BANKINFO *p); 
   
  void AB_BankInfo_ConstList2_PushFront(AB_BANKINFO_CONSTLIST2 *l, const AB_BANKINFO *p); 
   
  const AB_BANKINFO *AB_BankInfo_ConstList2_GetFront(AB_BANKINFO_CONSTLIST2 *l); 
   
  const AB_BANKINFO *AB_BankInfo_ConstList2_GetBack(AB_BANKINFO_CONSTLIST2 *l); 
   
  unsigned int AB_BankInfo_ConstList2_GetSize(AB_BANKINFO_CONSTLIST2 *l); 
   
  void AB_BankInfo_ConstList2_PopBack(AB_BANKINFO_CONSTLIST2 *l); 
   
  void AB_BankInfo_ConstList2_PopFront(AB_BANKINFO_CONSTLIST2 *l); 
   
  void AB_BankInfo_ConstList2_Clear(AB_BANKINFO_CONSTLIST2 *l); 
   
  AB_BANKINFO_CONSTLIST2_ITERATOR *AB_BankInfo_ConstList2_First(AB_BANKINFO_CONSTLIST2 *l); 
   
  AB_BANKINFO_CONSTLIST2_ITERATOR *AB_BankInfo_ConstList2_Last(AB_BANKINFO_CONSTLIST2 *l); 
   
  AB_BANKINFO_CONSTLIST2_ITERATOR *AB_BankInfo_ConstList2Iterator_new(AB_BANKINFO_CONSTLIST2 *l); 
   
  void AB_BankInfo_ConstList2Iterator_free(AB_BANKINFO_CONSTLIST2_ITERATOR *li); 
   
  const AB_BANKINFO *AB_BankInfo_ConstList2Iterator_Previous(AB_BANKINFO_CONSTLIST2_ITERATOR *li); 
   
  const AB_BANKINFO *AB_BankInfo_ConstList2Iterator_Next(AB_BANKINFO_CONSTLIST2_ITERATOR *li); 
   
  const AB_BANKINFO *AB_BankInfo_ConstList2Iterator_Data(AB_BANKINFO_CONSTLIST2_ITERATOR *li); 
   
  const AB_BANKINFO *AB_BankInfo_ConstList2_ForEach(AB_BANKINFO_CONSTLIST2 *list,
        AB_BANKINFO_CONSTLIST2_FOREACH func, void *user_data);


#ifdef __cplusplus
}
#endif


#endif /* AB_BANKINFO_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 AB_BANKINFO_LIST1_H
#define AB_BANKINFO_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct AB_BANKINFO_LIST_ELEMENT {
    uint32_t id;
    AB_BANKINFO *nextObject;
  } AB_BANKINFO_LIST__ELEMENT;

  typedef struct AB_BANKINFO_LIST AB_BANKINFO_LIST;

  typedef int GWENHYWFAR_CB (*AB_BANKINFO_LIST_SORT_FN)(const AB_BANKINFO *a, const AB_BANKINFO *b, int ascending);


  struct AB_BANKINFO_LIST {
    AB_BANKINFO *first;
    uint32_t count;
    uint32_t id;
  } AB_BANKINFO_LIST;

  void AB_BankInfo_List_AddList(AB_BANKINFO_LIST *dst, AB_BANKINFO_LIST *l);

  void AB_BankInfo_List_Add(AB_BANKINFO *element, AB_BANKINFO_LIST *list);

  void AB_BankInfo_List_Insert(AB_BANKINFO *element, AB_BANKINFO_LIST *list);

  void AB_BankInfo_List_Del(AB_BANKINFO *element);

  AB_BANKINFO* AB_BankInfo_List_First(const AB_BANKINFO_LIST *l);

  AB_BANKINFO* AB_BankInfo_List_Last(const AB_BANKINFO_LIST *l);

  void AB_BankInfo_List_Clear(AB_BANKINFO_LIST *l);

  AB_BANKINFO_LIST* AB_BankInfo_List_new();

  void AB_BankInfo_List_free(AB_BANKINFO_LIST *l);

  AB_BANKINFO* AB_BankInfo_List_Next(const AB_BANKINFO *element);

  AB_BANKINFO* AB_BankInfo_List_Previous(const AB_BANKINFO *element);

  uint32_t AB_BankInfo_List_GetCount(const AB_BANKINFO_LIST *l);

  AB_BANKINFO_LIST_SORT_FN AB_BankInfo_List_SetSortFn(AB_BANKINFO_LIST *l, AB_BANKINFO_LIST_SORT_FN fn);

  void AB_BankInfo_List_Sort(AB_BANKINFO_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 AB_ACCOUNT_LIST2_H
#define AB_ACCOUNT_LIST2_H


#ifdef __cplusplus
extern "C" {
#endif

  typedef struct AB_ACCOUNT_LIST2 AB_ACCOUNT_LIST2;

  typedef struct AB_ACCOUNT_LIST2_ITERATOR AB_ACCOUNT_LIST2_ITERATOR;

  typedef AB_ACCOUNT* (AB_ACCOUNT_LIST2_FOREACH)(AB_ACCOUNT *element,
                                                 void *user_data);

  AB_ACCOUNT_LIST2 *AB_Account_List2_new(); 

  void AB_Account_List2_free(AB_ACCOUNT_LIST2 *l); 

  void AB_Account_List2_Dump(AB_ACCOUNT_LIST2 *l, FILE *f, unsigned int indent); 

  void AB_Account_List2_PushBack(AB_ACCOUNT_LIST2 *l, AB_ACCOUNT *p); 
   
  void AB_Account_List2_PushFront(AB_ACCOUNT_LIST2 *l, AB_ACCOUNT *p); 

  AB_ACCOUNT *AB_Account_List2_GetFront(AB_ACCOUNT_LIST2 *l); 
   
  AB_ACCOUNT *AB_Account_List2_GetBack(AB_ACCOUNT_LIST2 *l); 

  void AB_Account_List2_Erase(AB_ACCOUNT_LIST2 *l,
                               AB_ACCOUNT_LIST2_ITERATOR *it);

  unsigned int AB_Account_List2_GetSize(AB_ACCOUNT_LIST2 *l); 

  void AB_Account_List2_PopBack(AB_ACCOUNT_LIST2 *l); 
   
  void AB_Account_List2_PopFront(AB_ACCOUNT_LIST2 *l); 

  void AB_Account_List2_Clear(AB_ACCOUNT_LIST2 *l); 

  AB_ACCOUNT_LIST2_ITERATOR *AB_Account_List2_First(AB_ACCOUNT_LIST2 *l); 
   
  AB_ACCOUNT_LIST2_ITERATOR *AB_Account_List2_Last(AB_ACCOUNT_LIST2 *l); 

  AB_ACCOUNT_LIST2_ITERATOR *AB_Account_List2Iterator_new(AB_ACCOUNT_LIST2 *l);

  void AB_Account_List2Iterator_free(AB_ACCOUNT_LIST2_ITERATOR *li); 

  AB_ACCOUNT *AB_Account_List2Iterator_Previous(AB_ACCOUNT_LIST2_ITERATOR *li); 
   
  AB_ACCOUNT *AB_Account_List2Iterator_Next(AB_ACCOUNT_LIST2_ITERATOR *li); 

  AB_ACCOUNT *AB_Account_List2Iterator_Data(AB_ACCOUNT_LIST2_ITERATOR *li); 

  AB_ACCOUNT *AB_Account_List2_ForEach(AB_ACCOUNT_LIST2 *list,
                                        AB_ACCOUNT_LIST2_FOREACH func,
                                        void *user_data);


  typedef struct AB_ACCOUNT_CONSTLIST2 AB_ACCOUNT_CONSTLIST2; 
  typedef struct AB_ACCOUNT_CONSTLIST2_ITERATOR AB_ACCOUNT_CONSTLIST2_ITERATOR; 
  typedef const AB_ACCOUNT*
    (AB_ACCOUNT_CONSTLIST2_FOREACH)(const AB_ACCOUNT *element,
                                    void *user_data);
  
   
  AB_ACCOUNT_CONSTLIST2 *AB_Account_ConstList2_new(); 
   
  void AB_Account_ConstList2_free(AB_ACCOUNT_CONSTLIST2 *l); 
   
  void AB_Account_ConstList2_PushBack(AB_ACCOUNT_CONSTLIST2 *l, const AB_ACCOUNT *p); 
   
  void AB_Account_ConstList2_PushFront(AB_ACCOUNT_CONSTLIST2 *l, const AB_ACCOUNT *p); 
   
  const AB_ACCOUNT *AB_Account_ConstList2_GetFront(AB_ACCOUNT_CONSTLIST2 *l); 
   
  const AB_ACCOUNT *AB_Account_ConstList2_GetBack(AB_ACCOUNT_CONSTLIST2 *l); 
   
  unsigned int AB_Account_ConstList2_GetSize(AB_ACCOUNT_CONSTLIST2 *l); 
   
  void AB_Account_ConstList2_PopBack(AB_ACCOUNT_CONSTLIST2 *l); 
   
  void AB_Account_ConstList2_PopFront(AB_ACCOUNT_CONSTLIST2 *l); 
   
  void AB_Account_ConstList2_Clear(AB_ACCOUNT_CONSTLIST2 *l); 
   
  AB_ACCOUNT_CONSTLIST2_ITERATOR *AB_Account_ConstList2_First(AB_ACCOUNT_CONSTLIST2 *l); 
   
  AB_ACCOUNT_CONSTLIST2_ITERATOR *AB_Account_ConstList2_Last(AB_ACCOUNT_CONSTLIST2 *l); 
   
  AB_ACCOUNT_CONSTLIST2_ITERATOR *AB_Account_ConstList2Iterator_new(AB_ACCOUNT_CONSTLIST2 *l); 
   
  void AB_Account_ConstList2Iterator_free(AB_ACCOUNT_CONSTLIST2_ITERATOR *li); 
   
  const AB_ACCOUNT *AB_Account_ConstList2Iterator_Previous(AB_ACCOUNT_CONSTLIST2_ITERATOR *li); 
   
  const AB_ACCOUNT *AB_Account_ConstList2Iterator_Next(AB_ACCOUNT_CONSTLIST2_ITERATOR *li); 
   
  const AB_ACCOUNT *AB_Account_ConstList2Iterator_Data(AB_ACCOUNT_CONSTLIST2_ITERATOR *li); 
   
  const AB_ACCOUNT *AB_Account_ConstList2_ForEach(AB_ACCOUNT_CONSTLIST2 *list,
        AB_ACCOUNT_CONSTLIST2_FOREACH func, void *user_data);


#ifdef __cplusplus
}
#endif


#endif /* AB_ACCOUNT_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 AB_EUTRANSFER_INFO_LIST2_H
#define AB_EUTRANSFER_INFO_LIST2_H


#ifdef __cplusplus
extern "C" {
#endif

  typedef struct AB_EUTRANSFER_INFO_LIST2 AB_EUTRANSFER_INFO_LIST2;

  typedef struct AB_EUTRANSFER_INFO_LIST2_ITERATOR AB_EUTRANSFER_INFO_LIST2_ITERATOR;

  typedef AB_EUTRANSFER_INFO* (AB_EUTRANSFER_INFO_LIST2_FOREACH)(AB_EUTRANSFER_INFO *element,
                                                 void *user_data);

  AB_EUTRANSFER_INFO_LIST2 *AB_EuTransferInfo_List2_new(); 

  void AB_EuTransferInfo_List2_free(AB_EUTRANSFER_INFO_LIST2 *l); 

  void AB_EuTransferInfo_List2_Dump(AB_EUTRANSFER_INFO_LIST2 *l, FILE *f, unsigned int indent); 

  void AB_EuTransferInfo_List2_PushBack(AB_EUTRANSFER_INFO_LIST2 *l, AB_EUTRANSFER_INFO *p); 
   
  void AB_EuTransferInfo_List2_PushFront(AB_EUTRANSFER_INFO_LIST2 *l, AB_EUTRANSFER_INFO *p); 

  AB_EUTRANSFER_INFO *AB_EuTransferInfo_List2_GetFront(AB_EUTRANSFER_INFO_LIST2 *l); 
   
  AB_EUTRANSFER_INFO *AB_EuTransferInfo_List2_GetBack(AB_EUTRANSFER_INFO_LIST2 *l); 

  void AB_EuTransferInfo_List2_Erase(AB_EUTRANSFER_INFO_LIST2 *l,
                               AB_EUTRANSFER_INFO_LIST2_ITERATOR *it);

  unsigned int AB_EuTransferInfo_List2_GetSize(AB_EUTRANSFER_INFO_LIST2 *l); 

  void AB_EuTransferInfo_List2_PopBack(AB_EUTRANSFER_INFO_LIST2 *l); 
   
  void AB_EuTransferInfo_List2_PopFront(AB_EUTRANSFER_INFO_LIST2 *l); 

  void AB_EuTransferInfo_List2_Clear(AB_EUTRANSFER_INFO_LIST2 *l); 

  AB_EUTRANSFER_INFO_LIST2_ITERATOR *AB_EuTransferInfo_List2_First(AB_EUTRANSFER_INFO_LIST2 *l); 
   
  AB_EUTRANSFER_INFO_LIST2_ITERATOR *AB_EuTransferInfo_List2_Last(AB_EUTRANSFER_INFO_LIST2 *l); 

  AB_EUTRANSFER_INFO_LIST2_ITERATOR *AB_EuTransferInfo_List2Iterator_new(AB_EUTRANSFER_INFO_LIST2 *l);

  void AB_EuTransferInfo_List2Iterator_free(AB_EUTRANSFER_INFO_LIST2_ITERATOR *li); 

  AB_EUTRANSFER_INFO *AB_EuTransferInfo_List2Iterator_Previous(AB_EUTRANSFER_INFO_LIST2_ITERATOR *li); 
   
  AB_EUTRANSFER_INFO *AB_EuTransferInfo_List2Iterator_Next(AB_EUTRANSFER_INFO_LIST2_ITERATOR *li); 

  AB_EUTRANSFER_INFO *AB_EuTransferInfo_List2Iterator_Data(AB_EUTRANSFER_INFO_LIST2_ITERATOR *li); 

  AB_EUTRANSFER_INFO *AB_EuTransferInfo_List2_ForEach(AB_EUTRANSFER_INFO_LIST2 *list,
                                        AB_EUTRANSFER_INFO_LIST2_FOREACH func,
                                        void *user_data);


  typedef struct AB_EUTRANSFER_INFO_CONSTLIST2 AB_EUTRANSFER_INFO_CONSTLIST2; 
  typedef struct AB_EUTRANSFER_INFO_CONSTLIST2_ITERATOR AB_EUTRANSFER_INFO_CONSTLIST2_ITERATOR; 
  typedef const AB_EUTRANSFER_INFO*
    (AB_EUTRANSFER_INFO_CONSTLIST2_FOREACH)(const AB_EUTRANSFER_INFO *element,
                                    void *user_data);
  
   
  AB_EUTRANSFER_INFO_CONSTLIST2 *AB_EuTransferInfo_ConstList2_new(); 
   
  void AB_EuTransferInfo_ConstList2_free(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 
   
  void AB_EuTransferInfo_ConstList2_PushBack(AB_EUTRANSFER_INFO_CONSTLIST2 *l, const AB_EUTRANSFER_INFO *p); 
   
  void AB_EuTransferInfo_ConstList2_PushFront(AB_EUTRANSFER_INFO_CONSTLIST2 *l, const AB_EUTRANSFER_INFO *p); 
   
  const AB_EUTRANSFER_INFO *AB_EuTransferInfo_ConstList2_GetFront(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 
   
  const AB_EUTRANSFER_INFO *AB_EuTransferInfo_ConstList2_GetBack(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 
   
  unsigned int AB_EuTransferInfo_ConstList2_GetSize(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 
   
  void AB_EuTransferInfo_ConstList2_PopBack(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 
   
  void AB_EuTransferInfo_ConstList2_PopFront(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 
   
  void AB_EuTransferInfo_ConstList2_Clear(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 
   
  AB_EUTRANSFER_INFO_CONSTLIST2_ITERATOR *AB_EuTransferInfo_ConstList2_First(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 
   
  AB_EUTRANSFER_INFO_CONSTLIST2_ITERATOR *AB_EuTransferInfo_ConstList2_Last(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 
   
  AB_EUTRANSFER_INFO_CONSTLIST2_ITERATOR *AB_EuTransferInfo_ConstList2Iterator_new(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 
   
  void AB_EuTransferInfo_ConstList2Iterator_free(AB_EUTRANSFER_INFO_CONSTLIST2_ITERATOR *li); 
   
  const AB_EUTRANSFER_INFO *AB_EuTransferInfo_ConstList2Iterator_Previous(AB_EUTRANSFER_INFO_CONSTLIST2_ITERATOR *li); 
   
  const AB_EUTRANSFER_INFO *AB_EuTransferInfo_ConstList2Iterator_Next(AB_EUTRANSFER_INFO_CONSTLIST2_ITERATOR *li); 
   
  const AB_EUTRANSFER_INFO *AB_EuTransferInfo_ConstList2Iterator_Data(AB_EUTRANSFER_INFO_CONSTLIST2_ITERATOR *li); 
   
  const AB_EUTRANSFER_INFO *AB_EuTransferInfo_ConstList2_ForEach(AB_EUTRANSFER_INFO_CONSTLIST2 *list,
        AB_EUTRANSFER_INFO_CONSTLIST2_FOREACH func, void *user_data);


#ifdef __cplusplus
}
#endif


#endif /* AB_EUTRANSFER_INFO_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 AB_EUTRANSFER_INFO_LIST1_H
#define AB_EUTRANSFER_INFO_LIST1_H

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct AB_EUTRANSFER_INFO_LIST_ELEMENT {
    uint32_t id;
    AB_EUTRANSFER_INFO *nextObject;
  } AB_EUTRANSFER_INFO_LIST__ELEMENT;

  typedef struct AB_EUTRANSFER_INFO_LIST AB_EUTRANSFER_INFO_LIST;

  typedef int GWENHYWFAR_CB (*AB_EUTRANSFER_INFO_LIST_SORT_FN)(const AB_EUTRANSFER_INFO *a, const AB_EUTRANSFER_INFO *b, int ascending);


  struct AB_EUTRANSFER_INFO_LIST {
    AB_EUTRANSFER_INFO *first;
    uint32_t count;
    uint32_t id;
  } AB_EUTRANSFER_INFO_LIST;

  void AB_EuTransferInfo_List_AddList(AB_EUTRANSFER_INFO_LIST *dst, AB_EUTRANSFER_INFO_LIST *l);

  void AB_EuTransferInfo_List_Add(AB_EUTRANSFER_INFO *element, AB_EUTRANSFER_INFO_LIST *list);

  void AB_EuTransferInfo_List_Insert(AB_EUTRANSFER_INFO *element, AB_EUTRANSFER_INFO_LIST *list);

  void AB_EuTransferInfo_List_Del(AB_EUTRANSFER_INFO *element);

  AB_EUTRANSFER_INFO* AB_EuTransferInfo_List_First(const AB_EUTRANSFER_INFO_LIST *l);

  AB_EUTRANSFER_INFO* AB_EuTransferInfo_List_Last(const AB_EUTRANSFER_INFO_LIST *l);

  void AB_EuTransferInfo_List_Clear(AB_EUTRANSFER_INFO_LIST *l);

  AB_EUTRANSFER_INFO_LIST* AB_EuTransferInfo_List_new();

  void AB_EuTransferInfo_List_free(AB_EUTRANSFER_INFO_LIST *l);

  AB_EUTRANSFER_INFO* AB_EuTransferInfo_List_Next(const AB_EUTRANSFER_INFO *element);

  AB_EUTRANSFER_INFO* AB_EuTransferInfo_List_Previous(const AB_EUTRANSFER_INFO *element);

  uint32_t AB_EuTransferInfo_List_GetCount(const AB_EUTRANSFER_INFO_LIST *l);

  AB_EUTRANSFER_INFO_LIST_SORT_FN AB_EuTransferInfo_List_SetSortFn(AB_EUTRANSFER_INFO_LIST *l, AB_EUTRANSFER_INFO_LIST_SORT_FN fn);

  void AB_EuTransferInfo_List_Sort(AB_EUTRANSFER_INFO_LIST *l, int ascending);


#ifdef __cplusplus
}
#endif


#endif