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 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;
  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);

#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_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;
  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);

#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;
  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);

#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;
  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);

#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_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;
  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);

#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;
  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);

#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_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;
  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);

#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_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;
  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);

#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_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;
  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);

#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_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;
  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);

#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_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_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_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;
  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);

#ifdef __cplusplus
}
#endif


#endif

---