gwenhywfar: listdoc.h Source File

00001 /***************************************************************************
00002  $RCSfile$
00003  -------------------
00004  cvs         : $Id$
00005  begin       : Sat Jun 28 2003
00006  copyright   : (C) 2003 by Martin Preuss
00007  email       : martin@libchipcard.de
00008 
00009  ***************************************************************************
00010  *                                                                         *
00011  *   This library is free software; you can redistribute it and/or         *
00012  *   modify it under the terms of the GNU Lesser General Public            *
00013  *   License as published by the Free Software Foundation; either          *
00014  *   version 2.1 of the License, or (at your option) any later version.    *
00015  *                                                                         *
00016  *   This library is distributed in the hope that it will be useful,       *
00017  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
00018  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
00019  *   Lesser General Public License for more details.                       *
00020  *                                                                         *
00021  *   You should have received a copy of the GNU Lesser General Public      *
00022  *   License along with this library; if not, write to the Free Software   *
00023  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
00024  *   MA  02111-1307  USA                                                   *
00025  *                                                                         *
00026  ***************************************************************************/
00027 
00028 
00029 #ifndef GWEN_MDIGEST_LIST2_H
00030 #define GWEN_MDIGEST_LIST2_H
00031 
00032 
00033 #ifdef __cplusplus
00034 extern "C" {
00035 #endif
00036 
00043   typedef struct GWEN_MDIGEST_LIST2 GWEN_MDIGEST_LIST2;
00044 
00048   typedef struct GWEN_MDIGEST_LIST2_ITERATOR GWEN_MDIGEST_LIST2_ITERATOR;
00049 
00053   typedef GWEN_MDIGEST* (GWEN_MDIGEST_LIST2_FOREACH)(GWEN_MDIGEST *element,
00054                                                  void *user_data);
00055 
00059   GWEN_MDIGEST_LIST2 *GWEN_MDigest_List2_new(); 
00060 
00064   void GWEN_MDigest_List2_free(GWEN_MDIGEST_LIST2 *l); 
00065 
00069   void GWEN_MDigest_List2_Dump(GWEN_MDIGEST_LIST2 *l, FILE *f, unsigned int indent); 
00070 
00074   void GWEN_MDigest_List2_PushBack(GWEN_MDIGEST_LIST2 *l, GWEN_MDIGEST *p); 
00075    
00080   void GWEN_MDigest_List2_PushFront(GWEN_MDIGEST_LIST2 *l, GWEN_MDIGEST *p); 
00081 
00086   GWEN_MDIGEST *GWEN_MDigest_List2_GetFront(GWEN_MDIGEST_LIST2 *l); 
00087    
00092   GWEN_MDIGEST *GWEN_MDigest_List2_GetBack(GWEN_MDIGEST_LIST2 *l); 
00093 
00098   void GWEN_MDigest_List2_Erase(GWEN_MDIGEST_LIST2 *l,
00099                                GWEN_MDIGEST_LIST2_ITERATOR *it);
00100 
00106   unsigned int GWEN_MDigest_List2_GetSize(GWEN_MDIGEST_LIST2 *l); 
00107 
00112   void GWEN_MDigest_List2_PopBack(GWEN_MDIGEST_LIST2 *l); 
00113    
00118   void GWEN_MDigest_List2_PopFront(GWEN_MDIGEST_LIST2 *l); 
00119 
00123   void GWEN_MDigest_List2_Clear(GWEN_MDIGEST_LIST2 *l); 
00124 
00128   GWEN_MDIGEST_LIST2_ITERATOR *GWEN_MDigest_List2_First(GWEN_MDIGEST_LIST2 *l); 
00129    
00133   GWEN_MDIGEST_LIST2_ITERATOR *GWEN_MDigest_List2_Last(GWEN_MDIGEST_LIST2 *l); 
00134 
00138   GWEN_MDIGEST_LIST2_ITERATOR *GWEN_MDigest_List2Iterator_new(GWEN_MDIGEST_LIST2 *l);
00139 
00143   void GWEN_MDigest_List2Iterator_free(GWEN_MDIGEST_LIST2_ITERATOR *li); 
00144 
00149   GWEN_MDIGEST *GWEN_MDigest_List2Iterator_Previous(GWEN_MDIGEST_LIST2_ITERATOR *li); 
00150    
00155   GWEN_MDIGEST *GWEN_MDigest_List2Iterator_Next(GWEN_MDIGEST_LIST2_ITERATOR *li); 
00156 
00161   GWEN_MDIGEST *GWEN_MDigest_List2Iterator_Data(GWEN_MDIGEST_LIST2_ITERATOR *li); 
00162 
00174   GWEN_MDIGEST *GWEN_MDigest_List2_ForEach(GWEN_MDIGEST_LIST2 *list,
00175                                         GWEN_MDIGEST_LIST2_FOREACH func,
00176                                         void *user_data);
00177 
00178 
00179   typedef struct GWEN_MDIGEST_CONSTLIST2 GWEN_MDIGEST_CONSTLIST2; 
00180   typedef struct GWEN_MDIGEST_CONSTLIST2_ITERATOR GWEN_MDIGEST_CONSTLIST2_ITERATOR; 
00181   typedef const GWEN_MDIGEST*
00182     (GWEN_MDIGEST_CONSTLIST2_FOREACH)(const GWEN_MDIGEST *element,
00183                                     void *user_data);
00184   
00185    
00186   GWEN_MDIGEST_CONSTLIST2 *GWEN_MDigest_ConstList2_new(); 
00187    
00188   void GWEN_MDigest_ConstList2_free(GWEN_MDIGEST_CONSTLIST2 *l); 
00189    
00190   void GWEN_MDigest_ConstList2_PushBack(GWEN_MDIGEST_CONSTLIST2 *l, const GWEN_MDIGEST *p); 
00191    
00192   void GWEN_MDigest_ConstList2_PushFront(GWEN_MDIGEST_CONSTLIST2 *l, const GWEN_MDIGEST *p); 
00193    
00194   const GWEN_MDIGEST *GWEN_MDigest_ConstList2_GetFront(GWEN_MDIGEST_CONSTLIST2 *l); 
00195    
00196   const GWEN_MDIGEST *GWEN_MDigest_ConstList2_GetBack(GWEN_MDIGEST_CONSTLIST2 *l); 
00197    
00198   unsigned int GWEN_MDigest_ConstList2_GetSize(GWEN_MDIGEST_CONSTLIST2 *l); 
00199    
00200   void GWEN_MDigest_ConstList2_PopBack(GWEN_MDIGEST_CONSTLIST2 *l); 
00201    
00202   void GWEN_MDigest_ConstList2_PopFront(GWEN_MDIGEST_CONSTLIST2 *l); 
00203    
00204   void GWEN_MDigest_ConstList2_Clear(GWEN_MDIGEST_CONSTLIST2 *l); 
00205    
00206   GWEN_MDIGEST_CONSTLIST2_ITERATOR *GWEN_MDigest_ConstList2_First(GWEN_MDIGEST_CONSTLIST2 *l); 
00207    
00208   GWEN_MDIGEST_CONSTLIST2_ITERATOR *GWEN_MDigest_ConstList2_Last(GWEN_MDIGEST_CONSTLIST2 *l); 
00209    
00210   GWEN_MDIGEST_CONSTLIST2_ITERATOR *GWEN_MDigest_ConstList2Iterator_new(GWEN_MDIGEST_CONSTLIST2 *l); 
00211    
00212   void GWEN_MDigest_ConstList2Iterator_free(GWEN_MDIGEST_CONSTLIST2_ITERATOR *li); 
00213    
00214   const GWEN_MDIGEST *GWEN_MDigest_ConstList2Iterator_Previous(GWEN_MDIGEST_CONSTLIST2_ITERATOR *li); 
00215    
00216   const GWEN_MDIGEST *GWEN_MDigest_ConstList2Iterator_Next(GWEN_MDIGEST_CONSTLIST2_ITERATOR *li); 
00217    
00218   const GWEN_MDIGEST *GWEN_MDigest_ConstList2Iterator_Data(GWEN_MDIGEST_CONSTLIST2_ITERATOR *li); 
00219    
00231   const GWEN_MDIGEST *GWEN_MDigest_ConstList2_ForEach(GWEN_MDIGEST_CONSTLIST2 *list,
00232         GWEN_MDIGEST_CONSTLIST2_FOREACH func, void *user_data);
00233 
00234 
00235 #ifdef __cplusplus
00236 }
00237 #endif
00238 
00239 
00240 #endif /* GWEN_MDIGEST_LIST_H */
00241 
00242 
00243 
00244 /***************************************************************************
00245  $RCSfile$
00246  -------------------
00247  cvs         : $Id$
00248  begin       : Sat Jun 28 2003
00249  copyright   : (C) 2003 by Martin Preuss
00250  email       : martin@libchipcard.de
00251 
00252  ***************************************************************************
00253  *                                                                         *
00254  *   This library is free software; you can redistribute it and/or         *
00255  *   modify it under the terms of the GNU Lesser General Public            *
00256  *   License as published by the Free Software Foundation; either          *
00257  *   version 2.1 of the License, or (at your option) any later version.    *
00258  *                                                                         *
00259  *   This library is distributed in the hope that it will be useful,       *
00260  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
00261  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
00262  *   Lesser General Public License for more details.                       *
00263  *                                                                         *
00264  *   You should have received a copy of the GNU Lesser General Public      *
00265  *   License along with this library; if not, write to the Free Software   *
00266  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
00267  *   MA  02111-1307  USA                                                   *
00268  *                                                                         *
00269  ***************************************************************************/
00270 
00271 
00272 #ifndef GWEN_MDIGEST_LIST1_H
00273 #define GWEN_MDIGEST_LIST1_H
00274 
00275 #ifdef __cplusplus
00276 extern "C" {
00277 #endif
00278 
00280   typedef struct GWEN_MDIGEST_LIST_ELEMENT {
00281     uint32_t id;
00282     GWEN_MDIGEST *nextObject;
00283   } GWEN_MDIGEST_LIST__ELEMENT;
00284 
00291   typedef struct GWEN_MDIGEST_LIST GWEN_MDIGEST_LIST;
00293   struct GWEN_MDIGEST_LIST {
00294     GWEN_MDIGEST *first;
00295     uint32_t count;
00296     uint32_t id;
00297   } GWEN_MDIGEST_LIST;
00298 
00303   void GWEN_MDigest_List_AddList(GWEN_MDIGEST_LIST *dst, GWEN_MDIGEST_LIST *l);
00304 
00308   void GWEN_MDigest_List_Add(GWEN_MDIGEST *element, GWEN_MDIGEST_LIST *list);
00309 
00314   void GWEN_MDigest_List_Insert(GWEN_MDIGEST *element, GWEN_MDIGEST_LIST *list);
00315 
00322   void GWEN_MDigest_List_Del(GWEN_MDIGEST *element);
00323 
00327   GWEN_MDIGEST* GWEN_MDigest_List_First(const GWEN_MDIGEST_LIST *l);
00328 
00332   GWEN_MDIGEST* GWEN_MDigest_List_Last(const GWEN_MDIGEST_LIST *l);
00333 
00338   void GWEN_MDigest_List_Clear(GWEN_MDIGEST_LIST *l);
00339 
00343   GWEN_MDIGEST_LIST* GWEN_MDigest_List_new();
00344 
00348   void GWEN_MDigest_List_free(GWEN_MDIGEST_LIST *l);
00349 
00353   GWEN_MDIGEST* GWEN_MDigest_List_Next(const GWEN_MDIGEST *element);
00354 
00358   GWEN_MDIGEST* GWEN_MDigest_List_Previous(const GWEN_MDIGEST *element);
00359 
00363   uint32_t GWEN_MDigest_List_GetCount(const GWEN_MDIGEST_LIST *l);
00364 
00365 #ifdef __cplusplus
00366 }
00367 #endif
00368 
00369 
00370 #endif
00371 
00372 
00373 
00374 /***************************************************************************
00375  $RCSfile$
00376  -------------------
00377  cvs         : $Id$
00378  begin       : Sat Jun 28 2003
00379  copyright   : (C) 2003 by Martin Preuss
00380  email       : martin@libchipcard.de
00381 
00382  ***************************************************************************
00383  *                                                                         *
00384  *   This library is free software; you can redistribute it and/or         *
00385  *   modify it under the terms of the GNU Lesser General Public            *
00386  *   License as published by the Free Software Foundation; either          *
00387  *   version 2.1 of the License, or (at your option) any later version.    *
00388  *                                                                         *
00389  *   This library is distributed in the hope that it will be useful,       *
00390  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
00391  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
00392  *   Lesser General Public License for more details.                       *
00393  *                                                                         *
00394  *   You should have received a copy of the GNU Lesser General Public      *
00395  *   License along with this library; if not, write to the Free Software   *
00396  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
00397  *   MA  02111-1307  USA                                                   *
00398  *                                                                         *
00399  ***************************************************************************/
00400 
00401 
00402 #ifndef GWEN_TAG16_LIST1_H
00403 #define GWEN_TAG16_LIST1_H
00404 
00405 #ifdef __cplusplus
00406 extern "C" {
00407 #endif
00408 
00410   typedef struct GWEN_TAG16_LIST_ELEMENT {
00411     uint32_t id;
00412     GWEN_TAG16 *nextObject;
00413   } GWEN_TAG16_LIST__ELEMENT;
00414 
00421   typedef struct GWEN_TAG16_LIST GWEN_TAG16_LIST;
00423   struct GWEN_TAG16_LIST {
00424     GWEN_TAG16 *first;
00425     uint32_t count;
00426     uint32_t id;
00427   } GWEN_TAG16_LIST;
00428 
00433   void GWEN_Tag16_List_AddList(GWEN_TAG16_LIST *dst, GWEN_TAG16_LIST *l);
00434 
00438   void GWEN_Tag16_List_Add(GWEN_TAG16 *element, GWEN_TAG16_LIST *list);
00439 
00444   void GWEN_Tag16_List_Insert(GWEN_TAG16 *element, GWEN_TAG16_LIST *list);
00445 
00452   void GWEN_Tag16_List_Del(GWEN_TAG16 *element);
00453 
00457   GWEN_TAG16* GWEN_Tag16_List_First(const GWEN_TAG16_LIST *l);
00458 
00462   GWEN_TAG16* GWEN_Tag16_List_Last(const GWEN_TAG16_LIST *l);
00463 
00468   void GWEN_Tag16_List_Clear(GWEN_TAG16_LIST *l);
00469 
00473   GWEN_TAG16_LIST* GWEN_Tag16_List_new();
00474 
00478   void GWEN_Tag16_List_free(GWEN_TAG16_LIST *l);
00479 
00483   GWEN_TAG16* GWEN_Tag16_List_Next(const GWEN_TAG16 *element);
00484 
00488   GWEN_TAG16* GWEN_Tag16_List_Previous(const GWEN_TAG16 *element);
00489 
00493   uint32_t GWEN_Tag16_List_GetCount(const GWEN_TAG16_LIST *l);
00494 
00495 #ifdef __cplusplus
00496 }
00497 #endif
00498 
00499 
00500 #endif
00501 
00502 
00503 
00504 /***************************************************************************
00505  $RCSfile$
00506  -------------------
00507  cvs         : $Id$
00508  begin       : Sat Jun 28 2003
00509  copyright   : (C) 2003 by Martin Preuss
00510  email       : martin@libchipcard.de
00511 
00512  ***************************************************************************
00513  *                                                                         *
00514  *   This library is free software; you can redistribute it and/or         *
00515  *   modify it under the terms of the GNU Lesser General Public            *
00516  *   License as published by the Free Software Foundation; either          *
00517  *   version 2.1 of the License, or (at your option) any later version.    *
00518  *                                                                         *
00519  *   This library is distributed in the hope that it will be useful,       *
00520  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
00521  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
00522  *   Lesser General Public License for more details.                       *
00523  *                                                                         *
00524  *   You should have received a copy of the GNU Lesser General Public      *
00525  *   License along with this library; if not, write to the Free Software   *
00526  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
00527  *   MA  02111-1307  USA                                                   *
00528  *                                                                         *
00529  ***************************************************************************/
00530 
00531 
00532 #ifndef GWEN_INHERITDATA_LIST1_H
00533 #define GWEN_INHERITDATA_LIST1_H
00534 
00535 #ifdef __cplusplus
00536 extern "C" {
00537 #endif
00538 
00540   typedef struct GWEN_INHERITDATA_LIST_ELEMENT {
00541     uint32_t id;
00542     GWEN_INHERITDATA *nextObject;
00543   } GWEN_INHERITDATA_LIST__ELEMENT;
00544 
00551   typedef struct GWEN_INHERITDATA_LIST GWEN_INHERITDATA_LIST;
00553   struct GWEN_INHERITDATA_LIST {
00554     GWEN_INHERITDATA *first;
00555     uint32_t count;
00556     uint32_t id;
00557   } GWEN_INHERITDATA_LIST;
00558 
00563   void GWEN_InheritData_List_AddList(GWEN_INHERITDATA_LIST *dst, GWEN_INHERITDATA_LIST *l);
00564 
00568   void GWEN_InheritData_List_Add(GWEN_INHERITDATA *element, GWEN_INHERITDATA_LIST *list);
00569 
00574   void GWEN_InheritData_List_Insert(GWEN_INHERITDATA *element, GWEN_INHERITDATA_LIST *list);
00575 
00582   void GWEN_InheritData_List_Del(GWEN_INHERITDATA *element);
00583 
00587   GWEN_INHERITDATA* GWEN_InheritData_List_First(const GWEN_INHERITDATA_LIST *l);
00588 
00592   GWEN_INHERITDATA* GWEN_InheritData_List_Last(const GWEN_INHERITDATA_LIST *l);
00593 
00598   void GWEN_InheritData_List_Clear(GWEN_INHERITDATA_LIST *l);
00599 
00603   GWEN_INHERITDATA_LIST* GWEN_InheritData_List_new();
00604 
00608   void GWEN_InheritData_List_free(GWEN_INHERITDATA_LIST *l);
00609 
00613   GWEN_INHERITDATA* GWEN_InheritData_List_Next(const GWEN_INHERITDATA *element);
00614 
00618   GWEN_INHERITDATA* GWEN_InheritData_List_Previous(const GWEN_INHERITDATA *element);
00619 
00623   uint32_t GWEN_InheritData_List_GetCount(const GWEN_INHERITDATA_LIST *l);
00624 
00625 #ifdef __cplusplus
00626 }
00627 #endif
00628 
00629 
00630 #endif
00631 
00632 
00633 
00634 /***************************************************************************
00635  $RCSfile$
00636  -------------------
00637  cvs         : $Id$
00638  begin       : Sat Jun 28 2003
00639  copyright   : (C) 2003 by Martin Preuss
00640  email       : martin@libchipcard.de
00641 
00642  ***************************************************************************
00643  *                                                                         *
00644  *   This library is free software; you can redistribute it and/or         *
00645  *   modify it under the terms of the GNU Lesser General Public            *
00646  *   License as published by the Free Software Foundation; either          *
00647  *   version 2.1 of the License, or (at your option) any later version.    *
00648  *                                                                         *
00649  *   This library is distributed in the hope that it will be useful,       *
00650  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
00651  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
00652  *   Lesser General Public License for more details.                       *
00653  *                                                                         *
00654  *   You should have received a copy of the GNU Lesser General Public      *
00655  *   License along with this library; if not, write to the Free Software   *
00656  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
00657  *   MA  02111-1307  USA                                                   *
00658  *                                                                         *
00659  ***************************************************************************/
00660 
00661 
00662 #ifndef GWEN_CRYPT_HASHALGO_LIST2_H
00663 #define GWEN_CRYPT_HASHALGO_LIST2_H
00664 
00665 
00666 #ifdef __cplusplus
00667 extern "C" {
00668 #endif
00669 
00676   typedef struct GWEN_CRYPT_HASHALGO_LIST2 GWEN_CRYPT_HASHALGO_LIST2;
00677 
00681   typedef struct GWEN_CRYPT_HASHALGO_LIST2_ITERATOR GWEN_CRYPT_HASHALGO_LIST2_ITERATOR;
00682 
00686   typedef GWEN_CRYPT_HASHALGO* (GWEN_CRYPT_HASHALGO_LIST2_FOREACH)(GWEN_CRYPT_HASHALGO *element,
00687                                                  void *user_data);
00688 
00692   GWEN_CRYPT_HASHALGO_LIST2 *GWEN_Crypt_HashAlgo_List2_new(); 
00693 
00697   void GWEN_Crypt_HashAlgo_List2_free(GWEN_CRYPT_HASHALGO_LIST2 *l); 
00698 
00702   void GWEN_Crypt_HashAlgo_List2_Dump(GWEN_CRYPT_HASHALGO_LIST2 *l, FILE *f, unsigned int indent); 
00703 
00707   void GWEN_Crypt_HashAlgo_List2_PushBack(GWEN_CRYPT_HASHALGO_LIST2 *l, GWEN_CRYPT_HASHALGO *p); 
00708    
00713   void GWEN_Crypt_HashAlgo_List2_PushFront(GWEN_CRYPT_HASHALGO_LIST2 *l, GWEN_CRYPT_HASHALGO *p); 
00714 
00719   GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_List2_GetFront(GWEN_CRYPT_HASHALGO_LIST2 *l); 
00720    
00725   GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_List2_GetBack(GWEN_CRYPT_HASHALGO_LIST2 *l); 
00726 
00731   void GWEN_Crypt_HashAlgo_List2_Erase(GWEN_CRYPT_HASHALGO_LIST2 *l,
00732                                GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *it);
00733 
00739   unsigned int GWEN_Crypt_HashAlgo_List2_GetSize(GWEN_CRYPT_HASHALGO_LIST2 *l); 
00740 
00745   void GWEN_Crypt_HashAlgo_List2_PopBack(GWEN_CRYPT_HASHALGO_LIST2 *l); 
00746    
00751   void GWEN_Crypt_HashAlgo_List2_PopFront(GWEN_CRYPT_HASHALGO_LIST2 *l); 
00752 
00756   void GWEN_Crypt_HashAlgo_List2_Clear(GWEN_CRYPT_HASHALGO_LIST2 *l); 
00757 
00761   GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *GWEN_Crypt_HashAlgo_List2_First(GWEN_CRYPT_HASHALGO_LIST2 *l); 
00762    
00766   GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *GWEN_Crypt_HashAlgo_List2_Last(GWEN_CRYPT_HASHALGO_LIST2 *l); 
00767 
00771   GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *GWEN_Crypt_HashAlgo_List2Iterator_new(GWEN_CRYPT_HASHALGO_LIST2 *l);
00772 
00776   void GWEN_Crypt_HashAlgo_List2Iterator_free(GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *li); 
00777 
00782   GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_List2Iterator_Previous(GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *li); 
00783    
00788   GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_List2Iterator_Next(GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *li); 
00789 
00794   GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_List2Iterator_Data(GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *li); 
00795 
00807   GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_List2_ForEach(GWEN_CRYPT_HASHALGO_LIST2 *list,
00808                                         GWEN_CRYPT_HASHALGO_LIST2_FOREACH func,
00809                                         void *user_data);
00810 
00811 
00812   typedef struct GWEN_CRYPT_HASHALGO_CONSTLIST2 GWEN_CRYPT_HASHALGO_CONSTLIST2; 
00813   typedef struct GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR; 
00814   typedef const GWEN_CRYPT_HASHALGO*
00815     (GWEN_CRYPT_HASHALGO_CONSTLIST2_FOREACH)(const GWEN_CRYPT_HASHALGO *element,
00816                                     void *user_data);
00817   
00818    
00819   GWEN_CRYPT_HASHALGO_CONSTLIST2 *GWEN_Crypt_HashAlgo_ConstList2_new(); 
00820    
00821   void GWEN_Crypt_HashAlgo_ConstList2_free(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l); 
00822    
00823   void GWEN_Crypt_HashAlgo_ConstList2_PushBack(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l, const GWEN_CRYPT_HASHALGO *p); 
00824    
00825   void GWEN_Crypt_HashAlgo_ConstList2_PushFront(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l, const GWEN_CRYPT_HASHALGO *p); 
00826    
00827   const GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_ConstList2_GetFront(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l); 
00828    
00829   const GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_ConstList2_GetBack(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l); 
00830    
00831   unsigned int GWEN_Crypt_HashAlgo_ConstList2_GetSize(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l); 
00832    
00833   void GWEN_Crypt_HashAlgo_ConstList2_PopBack(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l); 
00834    
00835   void GWEN_Crypt_HashAlgo_ConstList2_PopFront(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l); 
00836    
00837   void GWEN_Crypt_HashAlgo_ConstList2_Clear(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l); 
00838    
00839   GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_HashAlgo_ConstList2_First(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l); 
00840    
00841   GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_HashAlgo_ConstList2_Last(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l); 
00842    
00843   GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_HashAlgo_ConstList2Iterator_new(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l); 
00844    
00845   void GWEN_Crypt_HashAlgo_ConstList2Iterator_free(GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR *li); 
00846    
00847   const GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_ConstList2Iterator_Previous(GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR *li); 
00848    
00849   const GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_ConstList2Iterator_Next(GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR *li); 
00850    
00851   const GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_ConstList2Iterator_Data(GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR *li); 
00852    
00864   const GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_ConstList2_ForEach(GWEN_CRYPT_HASHALGO_CONSTLIST2 *list,
00865         GWEN_CRYPT_HASHALGO_CONSTLIST2_FOREACH func, void *user_data);
00866 
00867 
00868 #ifdef __cplusplus
00869 }
00870 #endif
00871 
00872 
00873 #endif /* GWEN_CRYPT_HASHALGO_LIST_H */
00874 
00875 
00876 
00877 /***************************************************************************
00878  $RCSfile$
00879  -------------------
00880  cvs         : $Id$
00881  begin       : Sat Jun 28 2003
00882  copyright   : (C) 2003 by Martin Preuss
00883  email       : martin@libchipcard.de
00884 
00885  ***************************************************************************
00886  *                                                                         *
00887  *   This library is free software; you can redistribute it and/or         *
00888  *   modify it under the terms of the GNU Lesser General Public            *
00889  *   License as published by the Free Software Foundation; either          *
00890  *   version 2.1 of the License, or (at your option) any later version.    *
00891  *                                                                         *
00892  *   This library is distributed in the hope that it will be useful,       *
00893  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
00894  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
00895  *   Lesser General Public License for more details.                       *
00896  *                                                                         *
00897  *   You should have received a copy of the GNU Lesser General Public      *
00898  *   License along with this library; if not, write to the Free Software   *
00899  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
00900  *   MA  02111-1307  USA                                                   *
00901  *                                                                         *
00902  ***************************************************************************/
00903 
00904 
00905 #ifndef t_LIST1_H
00906 #define t_LIST1_H
00907 
00908 #ifdef __cplusplus
00909 extern "C" {
00910 #endif
00911 
00913   typedef struct t_LIST_ELEMENT {
00914     uint32_t id;
00915     t *nextObject;
00916   } t_LIST__ELEMENT;
00917 
00924   typedef struct t_LIST t_LIST;
00926   struct t_LIST {
00927     t *first;
00928     uint32_t count;
00929     uint32_t id;
00930   } t_LIST;
00931 
00936   void pr_List_AddList(t_LIST *dst, t_LIST *l);
00937 
00941   void pr_List_Add(t *element, t_LIST *list);
00942 
00947   void pr_List_Insert(t *element, t_LIST *list);
00948 
00955   void pr_List_Del(t *element);
00956 
00960   t* pr_List_First(const t_LIST *l);
00961 
00965   t* pr_List_Last(const t_LIST *l);
00966 
00971   void pr_List_Clear(t_LIST *l);
00972 
00976   t_LIST* pr_List_new();
00977 
00981   void pr_List_free(t_LIST *l);
00982 
00986   t* pr_List_Next(const t *element);
00987 
00991   t* pr_List_Previous(const t *element);
00992 
00996   uint32_t pr_List_GetCount(const t_LIST *l);
00997 
00998 #ifdef __cplusplus
00999 }
01000 #endif
01001 
01002 
01003 #endif
01004 
01005 
01006 
01007 /***************************************************************************
01008  $RCSfile$
01009  -------------------
01010  cvs         : $Id$
01011  begin       : Sat Jun 28 2003
01012  copyright   : (C) 2003 by Martin Preuss
01013  email       : martin@libchipcard.de
01014 
01015  ***************************************************************************
01016  *                                                                         *
01017  *   This library is free software; you can redistribute it and/or         *
01018  *   modify it under the terms of the GNU Lesser General Public            *
01019  *   License as published by the Free Software Foundation; either          *
01020  *   version 2.1 of the License, or (at your option) any later version.    *
01021  *                                                                         *
01022  *   This library is distributed in the hope that it will be useful,       *
01023  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
01024  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
01025  *   Lesser General Public License for more details.                       *
01026  *                                                                         *
01027  *   You should have received a copy of the GNU Lesser General Public      *
01028  *   License along with this library; if not, write to the Free Software   *
01029  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
01030  *   MA  02111-1307  USA                                                   *
01031  *                                                                         *
01032  ***************************************************************************/
01033 
01034 
01035 #ifndef MYSTRUCT_LIST1_H
01036 #define MYSTRUCT_LIST1_H
01037 
01038 #ifdef __cplusplus
01039 extern "C" {
01040 #endif
01041 
01043   typedef struct MYSTRUCT_LIST_ELEMENT {
01044     uint32_t id;
01045     MYSTRUCT *nextObject;
01046   } MYSTRUCT_LIST__ELEMENT;
01047 
01054   typedef struct MYSTRUCT_LIST MYSTRUCT_LIST;
01056   struct MYSTRUCT_LIST {
01057     MYSTRUCT *first;
01058     uint32_t count;
01059     uint32_t id;
01060   } MYSTRUCT_LIST;
01061 
01066   void MyStruct_List_AddList(MYSTRUCT_LIST *dst, MYSTRUCT_LIST *l);
01067 
01071   void MyStruct_List_Add(MYSTRUCT *element, MYSTRUCT_LIST *list);
01072 
01077   void MyStruct_List_Insert(MYSTRUCT *element, MYSTRUCT_LIST *list);
01078 
01085   void MyStruct_List_Del(MYSTRUCT *element);
01086 
01090   MYSTRUCT* MyStruct_List_First(const MYSTRUCT_LIST *l);
01091 
01095   MYSTRUCT* MyStruct_List_Last(const MYSTRUCT_LIST *l);
01096 
01101   void MyStruct_List_Clear(MYSTRUCT_LIST *l);
01102 
01106   MYSTRUCT_LIST* MyStruct_List_new();
01107 
01111   void MyStruct_List_free(MYSTRUCT_LIST *l);
01112 
01116   MYSTRUCT* MyStruct_List_Next(const MYSTRUCT *element);
01117 
01121   MYSTRUCT* MyStruct_List_Previous(const MYSTRUCT *element);
01122 
01126   uint32_t MyStruct_List_GetCount(const MYSTRUCT_LIST *l);
01127 
01128 #ifdef __cplusplus
01129 }
01130 #endif
01131 
01132 
01133 #endif
01134 
01135 
01136 
01137 /***************************************************************************
01138  $RCSfile$
01139  -------------------
01140  cvs         : $Id$
01141  begin       : Sat Jun 28 2003
01142  copyright   : (C) 2003 by Martin Preuss
01143  email       : martin@libchipcard.de
01144 
01145  ***************************************************************************
01146  *                                                                         *
01147  *   This library is free software; you can redistribute it and/or         *
01148  *   modify it under the terms of the GNU Lesser General Public            *
01149  *   License as published by the Free Software Foundation; either          *
01150  *   version 2.1 of the License, or (at your option) any later version.    *
01151  *                                                                         *
01152  *   This library is distributed in the hope that it will be useful,       *
01153  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
01154  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
01155  *   Lesser General Public License for more details.                       *
01156  *                                                                         *
01157  *   You should have received a copy of the GNU Lesser General Public      *
01158  *   License along with this library; if not, write to the Free Software   *
01159  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
01160  *   MA  02111-1307  USA                                                   *
01161  *                                                                         *
01162  ***************************************************************************/
01163 
01164 
01165 #ifndef GWEN_IPC_REQUEST_LIST2_H
01166 #define GWEN_IPC_REQUEST_LIST2_H
01167 
01168 
01169 #ifdef __cplusplus
01170 extern "C" {
01171 #endif
01172 
01179   typedef struct GWEN_IPC_REQUEST_LIST2 GWEN_IPC_REQUEST_LIST2;
01180 
01184   typedef struct GWEN_IPC_REQUEST_LIST2_ITERATOR GWEN_IPC_REQUEST_LIST2_ITERATOR;
01185 
01189   typedef GWEN_IPC_REQUEST* (GWEN_IPC_REQUEST_LIST2_FOREACH)(GWEN_IPC_REQUEST *element,
01190                                                  void *user_data);
01191 
01195   GWEN_IPC_REQUEST_LIST2 *GWEN_IpcRequest_List2_new(); 
01196 
01200   void GWEN_IpcRequest_List2_free(GWEN_IPC_REQUEST_LIST2 *l); 
01201 
01205   void GWEN_IpcRequest_List2_Dump(GWEN_IPC_REQUEST_LIST2 *l, FILE *f, unsigned int indent); 
01206 
01210   void GWEN_IpcRequest_List2_PushBack(GWEN_IPC_REQUEST_LIST2 *l, GWEN_IPC_REQUEST *p); 
01211    
01216   void GWEN_IpcRequest_List2_PushFront(GWEN_IPC_REQUEST_LIST2 *l, GWEN_IPC_REQUEST *p); 
01217 
01222   GWEN_IPC_REQUEST *GWEN_IpcRequest_List2_GetFront(GWEN_IPC_REQUEST_LIST2 *l); 
01223    
01228   GWEN_IPC_REQUEST *GWEN_IpcRequest_List2_GetBack(GWEN_IPC_REQUEST_LIST2 *l); 
01229 
01234   void GWEN_IpcRequest_List2_Erase(GWEN_IPC_REQUEST_LIST2 *l,
01235                                GWEN_IPC_REQUEST_LIST2_ITERATOR *it);
01236 
01242   unsigned int GWEN_IpcRequest_List2_GetSize(GWEN_IPC_REQUEST_LIST2 *l); 
01243 
01248   void GWEN_IpcRequest_List2_PopBack(GWEN_IPC_REQUEST_LIST2 *l); 
01249    
01254   void GWEN_IpcRequest_List2_PopFront(GWEN_IPC_REQUEST_LIST2 *l); 
01255 
01259   void GWEN_IpcRequest_List2_Clear(GWEN_IPC_REQUEST_LIST2 *l); 
01260 
01264   GWEN_IPC_REQUEST_LIST2_ITERATOR *GWEN_IpcRequest_List2_First(GWEN_IPC_REQUEST_LIST2 *l); 
01265    
01269   GWEN_IPC_REQUEST_LIST2_ITERATOR *GWEN_IpcRequest_List2_Last(GWEN_IPC_REQUEST_LIST2 *l); 
01270 
01274   GWEN_IPC_REQUEST_LIST2_ITERATOR *GWEN_IpcRequest_List2Iterator_new(GWEN_IPC_REQUEST_LIST2 *l);
01275 
01279   void GWEN_IpcRequest_List2Iterator_free(GWEN_IPC_REQUEST_LIST2_ITERATOR *li); 
01280 
01285   GWEN_IPC_REQUEST *GWEN_IpcRequest_List2Iterator_Previous(GWEN_IPC_REQUEST_LIST2_ITERATOR *li); 
01286    
01291   GWEN_IPC_REQUEST *GWEN_IpcRequest_List2Iterator_Next(GWEN_IPC_REQUEST_LIST2_ITERATOR *li); 
01292 
01297   GWEN_IPC_REQUEST *GWEN_IpcRequest_List2Iterator_Data(GWEN_IPC_REQUEST_LIST2_ITERATOR *li); 
01298 
01310   GWEN_IPC_REQUEST *GWEN_IpcRequest_List2_ForEach(GWEN_IPC_REQUEST_LIST2 *list,
01311                                         GWEN_IPC_REQUEST_LIST2_FOREACH func,
01312                                         void *user_data);
01313 
01314 
01315   typedef struct GWEN_IPC_REQUEST_CONSTLIST2 GWEN_IPC_REQUEST_CONSTLIST2; 
01316   typedef struct GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR; 
01317   typedef const GWEN_IPC_REQUEST*
01318     (GWEN_IPC_REQUEST_CONSTLIST2_FOREACH)(const GWEN_IPC_REQUEST *element,
01319                                     void *user_data);
01320   
01321    
01322   GWEN_IPC_REQUEST_CONSTLIST2 *GWEN_IpcRequest_ConstList2_new(); 
01323    
01324   void GWEN_IpcRequest_ConstList2_free(GWEN_IPC_REQUEST_CONSTLIST2 *l); 
01325    
01326   void GWEN_IpcRequest_ConstList2_PushBack(GWEN_IPC_REQUEST_CONSTLIST2 *l, const GWEN_IPC_REQUEST *p); 
01327    
01328   void GWEN_IpcRequest_ConstList2_PushFront(GWEN_IPC_REQUEST_CONSTLIST2 *l, const GWEN_IPC_REQUEST *p); 
01329    
01330   const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2_GetFront(GWEN_IPC_REQUEST_CONSTLIST2 *l); 
01331    
01332   const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2_GetBack(GWEN_IPC_REQUEST_CONSTLIST2 *l); 
01333    
01334   unsigned int GWEN_IpcRequest_ConstList2_GetSize(GWEN_IPC_REQUEST_CONSTLIST2 *l); 
01335    
01336   void GWEN_IpcRequest_ConstList2_PopBack(GWEN_IPC_REQUEST_CONSTLIST2 *l); 
01337    
01338   void GWEN_IpcRequest_ConstList2_PopFront(GWEN_IPC_REQUEST_CONSTLIST2 *l); 
01339    
01340   void GWEN_IpcRequest_ConstList2_Clear(GWEN_IPC_REQUEST_CONSTLIST2 *l); 
01341    
01342   GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *GWEN_IpcRequest_ConstList2_First(GWEN_IPC_REQUEST_CONSTLIST2 *l); 
01343    
01344   GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *GWEN_IpcRequest_ConstList2_Last(GWEN_IPC_REQUEST_CONSTLIST2 *l); 
01345    
01346   GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *GWEN_IpcRequest_ConstList2Iterator_new(GWEN_IPC_REQUEST_CONSTLIST2 *l); 
01347    
01348   void GWEN_IpcRequest_ConstList2Iterator_free(GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *li); 
01349    
01350   const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2Iterator_Previous(GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *li); 
01351    
01352   const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2Iterator_Next(GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *li); 
01353    
01354   const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2Iterator_Data(GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *li); 
01355    
01367   const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2_ForEach(GWEN_IPC_REQUEST_CONSTLIST2 *list,
01368         GWEN_IPC_REQUEST_CONSTLIST2_FOREACH func, void *user_data);
01369 
01370 
01371 #ifdef __cplusplus
01372 }
01373 #endif
01374 
01375 
01376 #endif /* GWEN_IPC_REQUEST_LIST_H */
01377 
01378 
01379 
01380 /***************************************************************************
01381  $RCSfile$
01382  -------------------
01383  cvs         : $Id$
01384  begin       : Sat Jun 28 2003
01385  copyright   : (C) 2003 by Martin Preuss
01386  email       : martin@libchipcard.de
01387 
01388  ***************************************************************************
01389  *                                                                         *
01390  *   This library is free software; you can redistribute it and/or         *
01391  *   modify it under the terms of the GNU Lesser General Public            *
01392  *   License as published by the Free Software Foundation; either          *
01393  *   version 2.1 of the License, or (at your option) any later version.    *
01394  *                                                                         *
01395  *   This library is distributed in the hope that it will be useful,       *
01396  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
01397  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
01398  *   Lesser General Public License for more details.                       *
01399  *                                                                         *
01400  *   You should have received a copy of the GNU Lesser General Public      *
01401  *   License along with this library; if not, write to the Free Software   *
01402  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
01403  *   MA  02111-1307  USA                                                   *
01404  *                                                                         *
01405  ***************************************************************************/
01406 
01407 
01408 #ifndef GWEN_IPC_REQUEST_LIST1_H
01409 #define GWEN_IPC_REQUEST_LIST1_H
01410 
01411 #ifdef __cplusplus
01412 extern "C" {
01413 #endif
01414 
01416   typedef struct GWEN_IPC_REQUEST_LIST_ELEMENT {
01417     uint32_t id;
01418     GWEN_IPC_REQUEST *nextObject;
01419   } GWEN_IPC_REQUEST_LIST__ELEMENT;
01420 
01427   typedef struct GWEN_IPC_REQUEST_LIST GWEN_IPC_REQUEST_LIST;
01429   struct GWEN_IPC_REQUEST_LIST {
01430     GWEN_IPC_REQUEST *first;
01431     uint32_t count;
01432     uint32_t id;
01433   } GWEN_IPC_REQUEST_LIST;
01434 
01439   void GWEN_IpcRequest_List_AddList(GWEN_IPC_REQUEST_LIST *dst, GWEN_IPC_REQUEST_LIST *l);
01440 
01444   void GWEN_IpcRequest_List_Add(GWEN_IPC_REQUEST *element, GWEN_IPC_REQUEST_LIST *list);
01445 
01450   void GWEN_IpcRequest_List_Insert(GWEN_IPC_REQUEST *element, GWEN_IPC_REQUEST_LIST *list);
01451 
01458   void GWEN_IpcRequest_List_Del(GWEN_IPC_REQUEST *element);
01459 
01463   GWEN_IPC_REQUEST* GWEN_IpcRequest_List_First(const GWEN_IPC_REQUEST_LIST *l);
01464 
01468   GWEN_IPC_REQUEST* GWEN_IpcRequest_List_Last(const GWEN_IPC_REQUEST_LIST *l);
01469 
01474   void GWEN_IpcRequest_List_Clear(GWEN_IPC_REQUEST_LIST *l);
01475 
01479   GWEN_IPC_REQUEST_LIST* GWEN_IpcRequest_List_new();
01480 
01484   void GWEN_IpcRequest_List_free(GWEN_IPC_REQUEST_LIST *l);
01485 
01489   GWEN_IPC_REQUEST* GWEN_IpcRequest_List_Next(const GWEN_IPC_REQUEST *element);
01490 
01494   GWEN_IPC_REQUEST* GWEN_IpcRequest_List_Previous(const GWEN_IPC_REQUEST *element);
01495 
01499   uint32_t GWEN_IpcRequest_List_GetCount(const GWEN_IPC_REQUEST_LIST *l);
01500 
01501 #ifdef __cplusplus
01502 }
01503 #endif
01504 
01505 
01506 #endif
01507 
01508 
01509 
01510 /***************************************************************************
01511  $RCSfile$
01512  -------------------
01513  cvs         : $Id$
01514  begin       : Sat Jun 28 2003
01515  copyright   : (C) 2003 by Martin Preuss
01516  email       : martin@libchipcard.de
01517 
01518  ***************************************************************************
01519  *                                                                         *
01520  *   This library is free software; you can redistribute it and/or         *
01521  *   modify it under the terms of the GNU Lesser General Public            *
01522  *   License as published by the Free Software Foundation; either          *
01523  *   version 2.1 of the License, or (at your option) any later version.    *
01524  *                                                                         *
01525  *   This library is distributed in the hope that it will be useful,       *
01526  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
01527  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
01528  *   Lesser General Public License for more details.                       *
01529  *                                                                         *
01530  *   You should have received a copy of the GNU Lesser General Public      *
01531  *   License along with this library; if not, write to the Free Software   *
01532  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
01533  *   MA  02111-1307  USA                                                   *
01534  *                                                                         *
01535  ***************************************************************************/
01536 
01537 
01538 #ifndef GWEN_TLV_LIST1_H
01539 #define GWEN_TLV_LIST1_H
01540 
01541 #ifdef __cplusplus
01542 extern "C" {
01543 #endif
01544 
01546   typedef struct GWEN_TLV_LIST_ELEMENT {
01547     uint32_t id;
01548     GWEN_TLV *nextObject;
01549   } GWEN_TLV_LIST__ELEMENT;
01550 
01557   typedef struct GWEN_TLV_LIST GWEN_TLV_LIST;
01559   struct GWEN_TLV_LIST {
01560     GWEN_TLV *first;
01561     uint32_t count;
01562     uint32_t id;
01563   } GWEN_TLV_LIST;
01564 
01569   void GWEN_TLV_List_AddList(GWEN_TLV_LIST *dst, GWEN_TLV_LIST *l);
01570 
01574   void GWEN_TLV_List_Add(GWEN_TLV *element, GWEN_TLV_LIST *list);
01575 
01580   void GWEN_TLV_List_Insert(GWEN_TLV *element, GWEN_TLV_LIST *list);
01581 
01588   void GWEN_TLV_List_Del(GWEN_TLV *element);
01589 
01593   GWEN_TLV* GWEN_TLV_List_First(const GWEN_TLV_LIST *l);
01594 
01598   GWEN_TLV* GWEN_TLV_List_Last(const GWEN_TLV_LIST *l);
01599 
01604   void GWEN_TLV_List_Clear(GWEN_TLV_LIST *l);
01605 
01609   GWEN_TLV_LIST* GWEN_TLV_List_new();
01610 
01614   void GWEN_TLV_List_free(GWEN_TLV_LIST *l);
01615 
01619   GWEN_TLV* GWEN_TLV_List_Next(const GWEN_TLV *element);
01620 
01624   GWEN_TLV* GWEN_TLV_List_Previous(const GWEN_TLV *element);
01625 
01629   uint32_t GWEN_TLV_List_GetCount(const GWEN_TLV_LIST *l);
01630 
01631 #ifdef __cplusplus
01632 }
01633 #endif
01634 
01635 
01636 #endif
01637 
01638 
01639 
01640 /***************************************************************************
01641  $RCSfile$
01642  -------------------
01643  cvs         : $Id$
01644  begin       : Sat Jun 28 2003
01645  copyright   : (C) 2003 by Martin Preuss
01646  email       : martin@libchipcard.de
01647 
01648  ***************************************************************************
01649  *                                                                         *
01650  *   This library is free software; you can redistribute it and/or         *
01651  *   modify it under the terms of the GNU Lesser General Public            *
01652  *   License as published by the Free Software Foundation; either          *
01653  *   version 2.1 of the License, or (at your option) any later version.    *
01654  *                                                                         *
01655  *   This library is distributed in the hope that it will be useful,       *
01656  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
01657  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
01658  *   Lesser General Public License for more details.                       *
01659  *                                                                         *
01660  *   You should have received a copy of the GNU Lesser General Public      *
01661  *   License along with this library; if not, write to the Free Software   *
01662  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
01663  *   MA  02111-1307  USA                                                   *
01664  *                                                                         *
01665  ***************************************************************************/
01666 
01667 
01668 #ifndef GWEN_SIGTAIL_LIST1_H
01669 #define GWEN_SIGTAIL_LIST1_H
01670 
01671 #ifdef __cplusplus
01672 extern "C" {
01673 #endif
01674 
01676   typedef struct GWEN_SIGTAIL_LIST_ELEMENT {
01677     uint32_t id;
01678     GWEN_SIGTAIL *nextObject;
01679   } GWEN_SIGTAIL_LIST__ELEMENT;
01680 
01687   typedef struct GWEN_SIGTAIL_LIST GWEN_SIGTAIL_LIST;
01689   struct GWEN_SIGTAIL_LIST {
01690     GWEN_SIGTAIL *first;
01691     uint32_t count;
01692     uint32_t id;
01693   } GWEN_SIGTAIL_LIST;
01694 
01699   void GWEN_SigTail_List_AddList(GWEN_SIGTAIL_LIST *dst, GWEN_SIGTAIL_LIST *l);
01700 
01704   void GWEN_SigTail_List_Add(GWEN_SIGTAIL *element, GWEN_SIGTAIL_LIST *list);
01705 
01710   void GWEN_SigTail_List_Insert(GWEN_SIGTAIL *element, GWEN_SIGTAIL_LIST *list);
01711 
01718   void GWEN_SigTail_List_Del(GWEN_SIGTAIL *element);
01719 
01723   GWEN_SIGTAIL* GWEN_SigTail_List_First(const GWEN_SIGTAIL_LIST *l);
01724 
01728   GWEN_SIGTAIL* GWEN_SigTail_List_Last(const GWEN_SIGTAIL_LIST *l);
01729 
01734   void GWEN_SigTail_List_Clear(GWEN_SIGTAIL_LIST *l);
01735 
01739   GWEN_SIGTAIL_LIST* GWEN_SigTail_List_new();
01740 
01744   void GWEN_SigTail_List_free(GWEN_SIGTAIL_LIST *l);
01745 
01749   GWEN_SIGTAIL* GWEN_SigTail_List_Next(const GWEN_SIGTAIL *element);
01750 
01754   GWEN_SIGTAIL* GWEN_SigTail_List_Previous(const GWEN_SIGTAIL *element);
01755 
01759   uint32_t GWEN_SigTail_List_GetCount(const GWEN_SIGTAIL_LIST *l);
01760 
01761 #ifdef __cplusplus
01762 }
01763 #endif
01764 
01765 
01766 #endif
01767 
01768 
01769 
01770 /***************************************************************************
01771  $RCSfile$
01772  -------------------
01773  cvs         : $Id$
01774  begin       : Sat Jun 28 2003
01775  copyright   : (C) 2003 by Martin Preuss
01776  email       : martin@libchipcard.de
01777 
01778  ***************************************************************************
01779  *                                                                         *
01780  *   This library is free software; you can redistribute it and/or         *
01781  *   modify it under the terms of the GNU Lesser General Public            *
01782  *   License as published by the Free Software Foundation; either          *
01783  *   version 2.1 of the License, or (at your option) any later version.    *
01784  *                                                                         *
01785  *   This library is distributed in the hope that it will be useful,       *
01786  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
01787  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
01788  *   Lesser General Public License for more details.                       *
01789  *                                                                         *
01790  *   You should have received a copy of the GNU Lesser General Public      *
01791  *   License along with this library; if not, write to the Free Software   *
01792  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
01793  *   MA  02111-1307  USA                                                   *
01794  *                                                                         *
01795  ***************************************************************************/
01796 
01797 
01798 #ifndef GWEN_CRYPTHEAD_LIST1_H
01799 #define GWEN_CRYPTHEAD_LIST1_H
01800 
01801 #ifdef __cplusplus
01802 extern "C" {
01803 #endif
01804 
01806   typedef struct GWEN_CRYPTHEAD_LIST_ELEMENT {
01807     uint32_t id;
01808     GWEN_CRYPTHEAD *nextObject;
01809   } GWEN_CRYPTHEAD_LIST__ELEMENT;
01810 
01817   typedef struct GWEN_CRYPTHEAD_LIST GWEN_CRYPTHEAD_LIST;
01819   struct GWEN_CRYPTHEAD_LIST {
01820     GWEN_CRYPTHEAD *first;
01821     uint32_t count;
01822     uint32_t id;
01823   } GWEN_CRYPTHEAD_LIST;
01824 
01829   void GWEN_CryptHead_List_AddList(GWEN_CRYPTHEAD_LIST *dst, GWEN_CRYPTHEAD_LIST *l);
01830 
01834   void GWEN_CryptHead_List_Add(GWEN_CRYPTHEAD *element, GWEN_CRYPTHEAD_LIST *list);
01835 
01840   void GWEN_CryptHead_List_Insert(GWEN_CRYPTHEAD *element, GWEN_CRYPTHEAD_LIST *list);
01841 
01848   void GWEN_CryptHead_List_Del(GWEN_CRYPTHEAD *element);
01849 
01853   GWEN_CRYPTHEAD* GWEN_CryptHead_List_First(const GWEN_CRYPTHEAD_LIST *l);
01854 
01858   GWEN_CRYPTHEAD* GWEN_CryptHead_List_Last(const GWEN_CRYPTHEAD_LIST *l);
01859 
01864   void GWEN_CryptHead_List_Clear(GWEN_CRYPTHEAD_LIST *l);
01865 
01869   GWEN_CRYPTHEAD_LIST* GWEN_CryptHead_List_new();
01870 
01874   void GWEN_CryptHead_List_free(GWEN_CRYPTHEAD_LIST *l);
01875 
01879   GWEN_CRYPTHEAD* GWEN_CryptHead_List_Next(const GWEN_CRYPTHEAD *element);
01880 
01884   GWEN_CRYPTHEAD* GWEN_CryptHead_List_Previous(const GWEN_CRYPTHEAD *element);
01885 
01889   uint32_t GWEN_CryptHead_List_GetCount(const GWEN_CRYPTHEAD_LIST *l);
01890 
01891 #ifdef __cplusplus
01892 }
01893 #endif
01894 
01895 
01896 #endif
01897 
01898 
01899 
01900 /***************************************************************************
01901  $RCSfile$
01902  -------------------
01903  cvs         : $Id$
01904  begin       : Sat Jun 28 2003
01905  copyright   : (C) 2003 by Martin Preuss
01906  email       : martin@libchipcard.de
01907 
01908  ***************************************************************************
01909  *                                                                         *
01910  *   This library is free software; you can redistribute it and/or         *
01911  *   modify it under the terms of the GNU Lesser General Public            *
01912  *   License as published by the Free Software Foundation; either          *
01913  *   version 2.1 of the License, or (at your option) any later version.    *
01914  *                                                                         *
01915  *   This library is distributed in the hope that it will be useful,       *
01916  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
01917  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
01918  *   Lesser General Public License for more details.                       *
01919  *                                                                         *
01920  *   You should have received a copy of the GNU Lesser General Public      *
01921  *   License along with this library; if not, write to the Free Software   *
01922  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
01923  *   MA  02111-1307  USA                                                   *
01924  *                                                                         *
01925  ***************************************************************************/
01926 
01927 
01928 #ifndef GWEN_CRYPT_PADDALGO_LIST2_H
01929 #define GWEN_CRYPT_PADDALGO_LIST2_H
01930 
01931 
01932 #ifdef __cplusplus
01933 extern "C" {
01934 #endif
01935 
01942   typedef struct GWEN_CRYPT_PADDALGO_LIST2 GWEN_CRYPT_PADDALGO_LIST2;
01943 
01947   typedef struct GWEN_CRYPT_PADDALGO_LIST2_ITERATOR GWEN_CRYPT_PADDALGO_LIST2_ITERATOR;
01948 
01952   typedef GWEN_CRYPT_PADDALGO* (GWEN_CRYPT_PADDALGO_LIST2_FOREACH)(GWEN_CRYPT_PADDALGO *element,
01953                                                  void *user_data);
01954 
01958   GWEN_CRYPT_PADDALGO_LIST2 *GWEN_Crypt_PaddAlgo_List2_new(); 
01959 
01963   void GWEN_Crypt_PaddAlgo_List2_free(GWEN_CRYPT_PADDALGO_LIST2 *l); 
01964 
01968   void GWEN_Crypt_PaddAlgo_List2_Dump(GWEN_CRYPT_PADDALGO_LIST2 *l, FILE *f, unsigned int indent); 
01969 
01973   void GWEN_Crypt_PaddAlgo_List2_PushBack(GWEN_CRYPT_PADDALGO_LIST2 *l, GWEN_CRYPT_PADDALGO *p); 
01974    
01979   void GWEN_Crypt_PaddAlgo_List2_PushFront(GWEN_CRYPT_PADDALGO_LIST2 *l, GWEN_CRYPT_PADDALGO *p); 
01980 
01985   GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_List2_GetFront(GWEN_CRYPT_PADDALGO_LIST2 *l); 
01986    
01991   GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_List2_GetBack(GWEN_CRYPT_PADDALGO_LIST2 *l); 
01992 
01997   void GWEN_Crypt_PaddAlgo_List2_Erase(GWEN_CRYPT_PADDALGO_LIST2 *l,
01998                                GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *it);
01999 
02005   unsigned int GWEN_Crypt_PaddAlgo_List2_GetSize(GWEN_CRYPT_PADDALGO_LIST2 *l); 
02006 
02011   void GWEN_Crypt_PaddAlgo_List2_PopBack(GWEN_CRYPT_PADDALGO_LIST2 *l); 
02012    
02017   void GWEN_Crypt_PaddAlgo_List2_PopFront(GWEN_CRYPT_PADDALGO_LIST2 *l); 
02018 
02022   void GWEN_Crypt_PaddAlgo_List2_Clear(GWEN_CRYPT_PADDALGO_LIST2 *l); 
02023 
02027   GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *GWEN_Crypt_PaddAlgo_List2_First(GWEN_CRYPT_PADDALGO_LIST2 *l); 
02028    
02032   GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *GWEN_Crypt_PaddAlgo_List2_Last(GWEN_CRYPT_PADDALGO_LIST2 *l); 
02033 
02037   GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *GWEN_Crypt_PaddAlgo_List2Iterator_new(GWEN_CRYPT_PADDALGO_LIST2 *l);
02038 
02042   void GWEN_Crypt_PaddAlgo_List2Iterator_free(GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *li); 
02043 
02048   GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_List2Iterator_Previous(GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *li); 
02049    
02054   GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_List2Iterator_Next(GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *li); 
02055 
02060   GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_List2Iterator_Data(GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *li); 
02061 
02073   GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_List2_ForEach(GWEN_CRYPT_PADDALGO_LIST2 *list,
02074                                         GWEN_CRYPT_PADDALGO_LIST2_FOREACH func,
02075                                         void *user_data);
02076 
02077 
02078   typedef struct GWEN_CRYPT_PADDALGO_CONSTLIST2 GWEN_CRYPT_PADDALGO_CONSTLIST2; 
02079   typedef struct GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR; 
02080   typedef const GWEN_CRYPT_PADDALGO*
02081     (GWEN_CRYPT_PADDALGO_CONSTLIST2_FOREACH)(const GWEN_CRYPT_PADDALGO *element,
02082                                     void *user_data);
02083   
02084    
02085   GWEN_CRYPT_PADDALGO_CONSTLIST2 *GWEN_Crypt_PaddAlgo_ConstList2_new(); 
02086    
02087   void GWEN_Crypt_PaddAlgo_ConstList2_free(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l); 
02088    
02089   void GWEN_Crypt_PaddAlgo_ConstList2_PushBack(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l, const GWEN_CRYPT_PADDALGO *p); 
02090    
02091   void GWEN_Crypt_PaddAlgo_ConstList2_PushFront(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l, const GWEN_CRYPT_PADDALGO *p); 
02092    
02093   const GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_ConstList2_GetFront(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l); 
02094    
02095   const GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_ConstList2_GetBack(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l); 
02096    
02097   unsigned int GWEN_Crypt_PaddAlgo_ConstList2_GetSize(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l); 
02098    
02099   void GWEN_Crypt_PaddAlgo_ConstList2_PopBack(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l); 
02100    
02101   void GWEN_Crypt_PaddAlgo_ConstList2_PopFront(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l); 
02102    
02103   void GWEN_Crypt_PaddAlgo_ConstList2_Clear(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l); 
02104    
02105   GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_PaddAlgo_ConstList2_First(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l); 
02106    
02107   GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_PaddAlgo_ConstList2_Last(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l); 
02108    
02109   GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_PaddAlgo_ConstList2Iterator_new(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l); 
02110    
02111   void GWEN_Crypt_PaddAlgo_ConstList2Iterator_free(GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR *li); 
02112    
02113   const GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_ConstList2Iterator_Previous(GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR *li); 
02114    
02115   const GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_ConstList2Iterator_Next(GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR *li); 
02116    
02117   const GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_ConstList2Iterator_Data(GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR *li); 
02118    
02130   const GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_ConstList2_ForEach(GWEN_CRYPT_PADDALGO_CONSTLIST2 *list,
02131         GWEN_CRYPT_PADDALGO_CONSTLIST2_FOREACH func, void *user_data);
02132 
02133 
02134 #ifdef __cplusplus
02135 }
02136 #endif
02137 
02138 
02139 #endif /* GWEN_CRYPT_PADDALGO_LIST_H */
02140 
02141 
02142 
02143 /***************************************************************************
02144  $RCSfile$
02145  -------------------
02146  cvs         : $Id$
02147  begin       : Sat Jun 28 2003
02148  copyright   : (C) 2003 by Martin Preuss
02149  email       : martin@libchipcard.de
02150 
02151  ***************************************************************************
02152  *                                                                         *
02153  *   This library is free software; you can redistribute it and/or         *
02154  *   modify it under the terms of the GNU Lesser General Public            *
02155  *   License as published by the Free Software Foundation; either          *
02156  *   version 2.1 of the License, or (at your option) any later version.    *
02157  *                                                                         *
02158  *   This library is distributed in the hope that it will be useful,       *
02159  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
02160  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
02161  *   Lesser General Public License for more details.                       *
02162  *                                                                         *
02163  *   You should have received a copy of the GNU Lesser General Public      *
02164  *   License along with this library; if not, write to the Free Software   *
02165  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
02166  *   MA  02111-1307  USA                                                   *
02167  *                                                                         *
02168  ***************************************************************************/
02169 
02170 
02171 #ifndef GWEN_SIGHEAD_LIST1_H
02172 #define GWEN_SIGHEAD_LIST1_H
02173 
02174 #ifdef __cplusplus
02175 extern "C" {
02176 #endif
02177 
02179   typedef struct GWEN_SIGHEAD_LIST_ELEMENT {
02180     uint32_t id;
02181     GWEN_SIGHEAD *nextObject;
02182   } GWEN_SIGHEAD_LIST__ELEMENT;
02183 
02190   typedef struct GWEN_SIGHEAD_LIST GWEN_SIGHEAD_LIST;
02192   struct GWEN_SIGHEAD_LIST {
02193     GWEN_SIGHEAD *first;
02194     uint32_t count;
02195     uint32_t id;
02196   } GWEN_SIGHEAD_LIST;
02197 
02202   void GWEN_SigHead_List_AddList(GWEN_SIGHEAD_LIST *dst, GWEN_SIGHEAD_LIST *l);
02203 
02207   void GWEN_SigHead_List_Add(GWEN_SIGHEAD *element, GWEN_SIGHEAD_LIST *list);
02208 
02213   void GWEN_SigHead_List_Insert(GWEN_SIGHEAD *element, GWEN_SIGHEAD_LIST *list);
02214 
02221   void GWEN_SigHead_List_Del(GWEN_SIGHEAD *element);
02222 
02226   GWEN_SIGHEAD* GWEN_SigHead_List_First(const GWEN_SIGHEAD_LIST *l);
02227 
02231   GWEN_SIGHEAD* GWEN_SigHead_List_Last(const GWEN_SIGHEAD_LIST *l);
02232 
02237   void GWEN_SigHead_List_Clear(GWEN_SIGHEAD_LIST *l);
02238 
02242   GWEN_SIGHEAD_LIST* GWEN_SigHead_List_new();
02243 
02247   void GWEN_SigHead_List_free(GWEN_SIGHEAD_LIST *l);
02248 
02252   GWEN_SIGHEAD* GWEN_SigHead_List_Next(const GWEN_SIGHEAD *element);
02253 
02257   GWEN_SIGHEAD* GWEN_SigHead_List_Previous(const GWEN_SIGHEAD *element);
02258 
02262   uint32_t GWEN_SigHead_List_GetCount(const GWEN_SIGHEAD_LIST *l);
02263 
02264 #ifdef __cplusplus
02265 }
02266 #endif
02267 
02268 
02269 #endif
02270 
02271 
02272 
02273 /***************************************************************************
02274  $RCSfile$
02275  -------------------
02276  cvs         : $Id$
02277  begin       : Sat Jun 28 2003
02278  copyright   : (C) 2003 by Martin Preuss
02279  email       : martin@libchipcard.de
02280 
02281  ***************************************************************************
02282  *                                                                         *
02283  *   This library is free software; you can redistribute it and/or         *
02284  *   modify it under the terms of the GNU Lesser General Public            *
02285  *   License as published by the Free Software Foundation; either          *
02286  *   version 2.1 of the License, or (at your option) any later version.    *
02287  *                                                                         *
02288  *   This library is distributed in the hope that it will be useful,       *
02289  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
02290  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
02291  *   Lesser General Public License for more details.                       *
02292  *                                                                         *
02293  *   You should have received a copy of the GNU Lesser General Public      *
02294  *   License along with this library; if not, write to the Free Software   *
02295  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
02296  *   MA  02111-1307  USA                                                   *
02297  *                                                                         *
02298  ***************************************************************************/
02299 
02300 
02301 #ifndef GWEN_PLUGIN_DESCRIPTION_LIST2_H
02302 #define GWEN_PLUGIN_DESCRIPTION_LIST2_H
02303 
02304 
02305 #ifdef __cplusplus
02306 extern "C" {
02307 #endif
02308 
02315   typedef struct GWEN_PLUGIN_DESCRIPTION_LIST2 GWEN_PLUGIN_DESCRIPTION_LIST2;
02316 
02320   typedef struct GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR;
02321 
02325   typedef GWEN_PLUGIN_DESCRIPTION* (GWEN_PLUGIN_DESCRIPTION_LIST2_FOREACH)(GWEN_PLUGIN_DESCRIPTION *element,
02326                                                  void *user_data);
02327 
02331   GWEN_PLUGIN_DESCRIPTION_LIST2 *GWEN_PluginDescription_List2_new(); 
02332 
02336   void GWEN_PluginDescription_List2_free(GWEN_PLUGIN_DESCRIPTION_LIST2 *l); 
02337 
02341   void GWEN_PluginDescription_List2_Dump(GWEN_PLUGIN_DESCRIPTION_LIST2 *l, FILE *f, unsigned int indent); 
02342 
02346   void GWEN_PluginDescription_List2_PushBack(GWEN_PLUGIN_DESCRIPTION_LIST2 *l, GWEN_PLUGIN_DESCRIPTION *p); 
02347    
02352   void GWEN_PluginDescription_List2_PushFront(GWEN_PLUGIN_DESCRIPTION_LIST2 *l, GWEN_PLUGIN_DESCRIPTION *p); 
02353 
02358   GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_List2_GetFront(GWEN_PLUGIN_DESCRIPTION_LIST2 *l); 
02359    
02364   GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_List2_GetBack(GWEN_PLUGIN_DESCRIPTION_LIST2 *l); 
02365 
02370   void GWEN_PluginDescription_List2_Erase(GWEN_PLUGIN_DESCRIPTION_LIST2 *l,
02371                                GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *it);
02372 
02378   unsigned int GWEN_PluginDescription_List2_GetSize(GWEN_PLUGIN_DESCRIPTION_LIST2 *l); 
02379 
02384   void GWEN_PluginDescription_List2_PopBack(GWEN_PLUGIN_DESCRIPTION_LIST2 *l); 
02385    
02390   void GWEN_PluginDescription_List2_PopFront(GWEN_PLUGIN_DESCRIPTION_LIST2 *l); 
02391 
02395   void GWEN_PluginDescription_List2_Clear(GWEN_PLUGIN_DESCRIPTION_LIST2 *l); 
02396 
02400   GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *GWEN_PluginDescription_List2_First(GWEN_PLUGIN_DESCRIPTION_LIST2 *l); 
02401    
02405   GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *GWEN_PluginDescription_List2_Last(GWEN_PLUGIN_DESCRIPTION_LIST2 *l); 
02406 
02410   GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *GWEN_PluginDescription_List2Iterator_new(GWEN_PLUGIN_DESCRIPTION_LIST2 *l);
02411 
02415   void GWEN_PluginDescription_List2Iterator_free(GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *li); 
02416 
02421   GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_List2Iterator_Previous(GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *li); 
02422    
02427   GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_List2Iterator_Next(GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *li); 
02428 
02433   GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_List2Iterator_Data(GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *li); 
02434 
02446   GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_List2_ForEach(GWEN_PLUGIN_DESCRIPTION_LIST2 *list,
02447                                         GWEN_PLUGIN_DESCRIPTION_LIST2_FOREACH func,
02448                                         void *user_data);
02449 
02450 
02451   typedef struct GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 GWEN_PLUGIN_DESCRIPTION_CONSTLIST2; 
02452   typedef struct GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR; 
02453   typedef const GWEN_PLUGIN_DESCRIPTION*
02454     (GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_FOREACH)(const GWEN_PLUGIN_DESCRIPTION *element,
02455                                     void *user_data);
02456   
02457    
02458   GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *GWEN_PluginDescription_ConstList2_new(); 
02459    
02460   void GWEN_PluginDescription_ConstList2_free(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l); 
02461    
02462   void GWEN_PluginDescription_ConstList2_PushBack(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l, const GWEN_PLUGIN_DESCRIPTION *p); 
02463    
02464   void GWEN_PluginDescription_ConstList2_PushFront(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l, const GWEN_PLUGIN_DESCRIPTION *p); 
02465    
02466   const GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_ConstList2_GetFront(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l); 
02467    
02468   const GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_ConstList2_GetBack(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l); 
02469    
02470   unsigned int GWEN_PluginDescription_ConstList2_GetSize(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l); 
02471    
02472   void GWEN_PluginDescription_ConstList2_PopBack(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l); 
02473    
02474   void GWEN_PluginDescription_ConstList2_PopFront(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l); 
02475    
02476   void GWEN_PluginDescription_ConstList2_Clear(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l); 
02477    
02478   GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *GWEN_PluginDescription_ConstList2_First(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l); 
02479    
02480   GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *GWEN_PluginDescription_ConstList2_Last(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l); 
02481    
02482   GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *GWEN_PluginDescription_ConstList2Iterator_new(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l); 
02483    
02484   void GWEN_PluginDescription_ConstList2Iterator_free(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *li); 
02485    
02486   const GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_ConstList2Iterator_Previous(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *li); 
02487    
02488   const GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_ConstList2Iterator_Next(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *li); 
02489    
02490   const GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_ConstList2Iterator_Data(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *li); 
02491    
02503   const GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_ConstList2_ForEach(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *list,
02504         GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_FOREACH func, void *user_data);
02505 
02506 
02507 #ifdef __cplusplus
02508 }
02509 #endif
02510 
02511 
02512 #endif /* GWEN_PLUGIN_DESCRIPTION_LIST_H */
02513 
02514 
02515 
02516 /***************************************************************************
02517  $RCSfile$
02518  -------------------
02519  cvs         : $Id$
02520  begin       : Sat Jun 28 2003
02521  copyright   : (C) 2003 by Martin Preuss
02522  email       : martin@libchipcard.de
02523 
02524  ***************************************************************************
02525  *                                                                         *
02526  *   This library is free software; you can redistribute it and/or         *
02527  *   modify it under the terms of the GNU Lesser General Public            *
02528  *   License as published by the Free Software Foundation; either          *
02529  *   version 2.1 of the License, or (at your option) any later version.    *
02530  *                                                                         *
02531  *   This library is distributed in the hope that it will be useful,       *
02532  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
02533  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
02534  *   Lesser General Public License for more details.                       *
02535  *                                                                         *
02536  *   You should have received a copy of the GNU Lesser General Public      *
02537  *   License along with this library; if not, write to the Free Software   *
02538  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
02539  *   MA  02111-1307  USA                                                   *
02540  *                                                                         *
02541  ***************************************************************************/
02542 
02543 
02544 #ifndef GWEN_PLUGIN_DESCRIPTION_LIST1_H
02545 #define GWEN_PLUGIN_DESCRIPTION_LIST1_H
02546 
02547 #ifdef __cplusplus
02548 extern "C" {
02549 #endif
02550 
02552   typedef struct GWEN_PLUGIN_DESCRIPTION_LIST_ELEMENT {
02553     uint32_t id;
02554     GWEN_PLUGIN_DESCRIPTION *nextObject;
02555   } GWEN_PLUGIN_DESCRIPTION_LIST__ELEMENT;
02556 
02563   typedef struct GWEN_PLUGIN_DESCRIPTION_LIST GWEN_PLUGIN_DESCRIPTION_LIST;
02565   struct GWEN_PLUGIN_DESCRIPTION_LIST {
02566     GWEN_PLUGIN_DESCRIPTION *first;
02567     uint32_t count;
02568     uint32_t id;
02569   } GWEN_PLUGIN_DESCRIPTION_LIST;
02570 
02575   void GWEN_PluginDescription_List_AddList(GWEN_PLUGIN_DESCRIPTION_LIST *dst, GWEN_PLUGIN_DESCRIPTION_LIST *l);
02576 
02580   void GWEN_PluginDescription_List_Add(GWEN_PLUGIN_DESCRIPTION *element, GWEN_PLUGIN_DESCRIPTION_LIST *list);
02581 
02586   void GWEN_PluginDescription_List_Insert(GWEN_PLUGIN_DESCRIPTION *element, GWEN_PLUGIN_DESCRIPTION_LIST *list);
02587 
02594   void GWEN_PluginDescription_List_Del(GWEN_PLUGIN_DESCRIPTION *element);
02595 
02599   GWEN_PLUGIN_DESCRIPTION* GWEN_PluginDescription_List_First(const GWEN_PLUGIN_DESCRIPTION_LIST *l);
02600 
02604   GWEN_PLUGIN_DESCRIPTION* GWEN_PluginDescription_List_Last(const GWEN_PLUGIN_DESCRIPTION_LIST *l);
02605 
02610   void GWEN_PluginDescription_List_Clear(GWEN_PLUGIN_DESCRIPTION_LIST *l);
02611 
02615   GWEN_PLUGIN_DESCRIPTION_LIST* GWEN_PluginDescription_List_new();
02616 
02620   void GWEN_PluginDescription_List_free(GWEN_PLUGIN_DESCRIPTION_LIST *l);
02621 
02625   GWEN_PLUGIN_DESCRIPTION* GWEN_PluginDescription_List_Next(const GWEN_PLUGIN_DESCRIPTION *element);
02626 
02630   GWEN_PLUGIN_DESCRIPTION* GWEN_PluginDescription_List_Previous(const GWEN_PLUGIN_DESCRIPTION *element);
02631 
02635   uint32_t GWEN_PluginDescription_List_GetCount(const GWEN_PLUGIN_DESCRIPTION_LIST *l);
02636 
02637 #ifdef __cplusplus
02638 }
02639 #endif
02640 
02641 
02642 #endif
02643 
02644 
02645 
02646 /***************************************************************************
02647  $RCSfile$
02648  -------------------
02649  cvs         : $Id$
02650  begin       : Sat Jun 28 2003
02651  copyright   : (C) 2003 by Martin Preuss
02652  email       : martin@libchipcard.de
02653 
02654  ***************************************************************************
02655  *                                                                         *
02656  *   This library is free software; you can redistribute it and/or         *
02657  *   modify it under the terms of the GNU Lesser General Public            *
02658  *   License as published by the Free Software Foundation; either          *
02659  *   version 2.1 of the License, or (at your option) any later version.    *
02660  *                                                                         *
02661  *   This library is distributed in the hope that it will be useful,       *
02662  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
02663  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
02664  *   Lesser General Public License for more details.                       *
02665  *                                                                         *
02666  *   You should have received a copy of the GNU Lesser General Public      *
02667  *   License along with this library; if not, write to the Free Software   *
02668  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
02669  *   MA  02111-1307  USA                                                   *
02670  *                                                                         *
02671  ***************************************************************************/
02672 
02673 
02674 #ifndef GWEN_IO_REQUEST_LIST1_H
02675 #define GWEN_IO_REQUEST_LIST1_H
02676 
02677 #ifdef __cplusplus
02678 extern "C" {
02679 #endif
02680 
02682   typedef struct GWEN_IO_REQUEST_LIST_ELEMENT {
02683     uint32_t id;
02684     GWEN_IO_REQUEST *nextObject;
02685   } GWEN_IO_REQUEST_LIST__ELEMENT;
02686 
02693   typedef struct GWEN_IO_REQUEST_LIST GWEN_IO_REQUEST_LIST;
02695   struct GWEN_IO_REQUEST_LIST {
02696     GWEN_IO_REQUEST *first;
02697     uint32_t count;
02698     uint32_t id;
02699   } GWEN_IO_REQUEST_LIST;
02700 
02705   void GWEN_Io_Request_List_AddList(GWEN_IO_REQUEST_LIST *dst, GWEN_IO_REQUEST_LIST *l);
02706 
02710   void GWEN_Io_Request_List_Add(GWEN_IO_REQUEST *element, GWEN_IO_REQUEST_LIST *list);
02711 
02716   void GWEN_Io_Request_List_Insert(GWEN_IO_REQUEST *element, GWEN_IO_REQUEST_LIST *list);
02717 
02724   void GWEN_Io_Request_List_Del(GWEN_IO_REQUEST *element);
02725 
02729   GWEN_IO_REQUEST* GWEN_Io_Request_List_First(const GWEN_IO_REQUEST_LIST *l);
02730 
02734   GWEN_IO_REQUEST* GWEN_Io_Request_List_Last(const GWEN_IO_REQUEST_LIST *l);
02735 
02740   void GWEN_Io_Request_List_Clear(GWEN_IO_REQUEST_LIST *l);
02741 
02745   GWEN_IO_REQUEST_LIST* GWEN_Io_Request_List_new();
02746 
02750   void GWEN_Io_Request_List_free(GWEN_IO_REQUEST_LIST *l);
02751 
02755   GWEN_IO_REQUEST* GWEN_Io_Request_List_Next(const GWEN_IO_REQUEST *element);
02756 
02760   GWEN_IO_REQUEST* GWEN_Io_Request_List_Previous(const GWEN_IO_REQUEST *element);
02761 
02765   uint32_t GWEN_Io_Request_List_GetCount(const GWEN_IO_REQUEST_LIST *l);
02766 
02767 #ifdef __cplusplus
02768 }
02769 #endif
02770 
02771 
02772 #endif
02773 
02774 
02775 
02776 /***************************************************************************
02777  $RCSfile$
02778  -------------------
02779  cvs         : $Id$
02780  begin       : Sat Jun 28 2003
02781  copyright   : (C) 2003 by Martin Preuss
02782  email       : martin@libchipcard.de
02783 
02784  ***************************************************************************
02785  *                                                                         *
02786  *   This library is free software; you can redistribute it and/or         *
02787  *   modify it under the terms of the GNU Lesser General Public            *
02788  *   License as published by the Free Software Foundation; either          *
02789  *   version 2.1 of the License, or (at your option) any later version.    *
02790  *                                                                         *
02791  *   This library is distributed in the hope that it will be useful,       *
02792  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
02793  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
02794  *   Lesser General Public License for more details.                       *
02795  *                                                                         *
02796  *   You should have received a copy of the GNU Lesser General Public      *
02797  *   License along with this library; if not, write to the Free Software   *
02798  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
02799  *   MA  02111-1307  USA                                                   *
02800  *                                                                         *
02801  ***************************************************************************/
02802 
02803 
02804 #ifndef GWEN_URL_LIST2_H
02805 #define GWEN_URL_LIST2_H
02806 
02807 
02808 #ifdef __cplusplus
02809 extern "C" {
02810 #endif
02811 
02818   typedef struct GWEN_URL_LIST2 GWEN_URL_LIST2;
02819 
02823   typedef struct GWEN_URL_LIST2_ITERATOR GWEN_URL_LIST2_ITERATOR;
02824 
02828   typedef GWEN_URL* (GWEN_URL_LIST2_FOREACH)(GWEN_URL *element,
02829                                                  void *user_data);
02830 
02834   GWEN_URL_LIST2 *GWEN_Url_List2_new(); 
02835 
02839   void GWEN_Url_List2_free(GWEN_URL_LIST2 *l); 
02840 
02844   void GWEN_Url_List2_Dump(GWEN_URL_LIST2 *l, FILE *f, unsigned int indent); 
02845 
02849   void GWEN_Url_List2_PushBack(GWEN_URL_LIST2 *l, GWEN_URL *p); 
02850    
02855   void GWEN_Url_List2_PushFront(GWEN_URL_LIST2 *l, GWEN_URL *p); 
02856 
02861   GWEN_URL *GWEN_Url_List2_GetFront(GWEN_URL_LIST2 *l); 
02862    
02867   GWEN_URL *GWEN_Url_List2_GetBack(GWEN_URL_LIST2 *l); 
02868 
02873   void GWEN_Url_List2_Erase(GWEN_URL_LIST2 *l,
02874                                GWEN_URL_LIST2_ITERATOR *it);
02875 
02881   unsigned int GWEN_Url_List2_GetSize(GWEN_URL_LIST2 *l); 
02882 
02887   void GWEN_Url_List2_PopBack(GWEN_URL_LIST2 *l); 
02888    
02893   void GWEN_Url_List2_PopFront(GWEN_URL_LIST2 *l); 
02894 
02898   void GWEN_Url_List2_Clear(GWEN_URL_LIST2 *l); 
02899 
02903   GWEN_URL_LIST2_ITERATOR *GWEN_Url_List2_First(GWEN_URL_LIST2 *l); 
02904    
02908   GWEN_URL_LIST2_ITERATOR *GWEN_Url_List2_Last(GWEN_URL_LIST2 *l); 
02909 
02913   GWEN_URL_LIST2_ITERATOR *GWEN_Url_List2Iterator_new(GWEN_URL_LIST2 *l);
02914 
02918   void GWEN_Url_List2Iterator_free(GWEN_URL_LIST2_ITERATOR *li); 
02919 
02924   GWEN_URL *GWEN_Url_List2Iterator_Previous(GWEN_URL_LIST2_ITERATOR *li); 
02925    
02930   GWEN_URL *GWEN_Url_List2Iterator_Next(GWEN_URL_LIST2_ITERATOR *li); 
02931 
02936   GWEN_URL *GWEN_Url_List2Iterator_Data(GWEN_URL_LIST2_ITERATOR *li); 
02937 
02949   GWEN_URL *GWEN_Url_List2_ForEach(GWEN_URL_LIST2 *list,
02950                                         GWEN_URL_LIST2_FOREACH func,
02951                                         void *user_data);
02952 
02953 
02954   typedef struct GWEN_URL_CONSTLIST2 GWEN_URL_CONSTLIST2; 
02955   typedef struct GWEN_URL_CONSTLIST2_ITERATOR GWEN_URL_CONSTLIST2_ITERATOR; 
02956   typedef const GWEN_URL*
02957     (GWEN_URL_CONSTLIST2_FOREACH)(const GWEN_URL *element,
02958                                     void *user_data);
02959   
02960    
02961   GWEN_URL_CONSTLIST2 *GWEN_Url_ConstList2_new(); 
02962    
02963   void GWEN_Url_ConstList2_free(GWEN_URL_CONSTLIST2 *l); 
02964    
02965   void GWEN_Url_ConstList2_PushBack(GWEN_URL_CONSTLIST2 *l, const GWEN_URL *p); 
02966    
02967   void GWEN_Url_ConstList2_PushFront(GWEN_URL_CONSTLIST2 *l, const GWEN_URL *p); 
02968    
02969   const GWEN_URL *GWEN_Url_ConstList2_GetFront(GWEN_URL_CONSTLIST2 *l); 
02970    
02971   const GWEN_URL *GWEN_Url_ConstList2_GetBack(GWEN_URL_CONSTLIST2 *l); 
02972    
02973   unsigned int GWEN_Url_ConstList2_GetSize(GWEN_URL_CONSTLIST2 *l); 
02974    
02975   void GWEN_Url_ConstList2_PopBack(GWEN_URL_CONSTLIST2 *l); 
02976    
02977   void GWEN_Url_ConstList2_PopFront(GWEN_URL_CONSTLIST2 *l); 
02978    
02979   void GWEN_Url_ConstList2_Clear(GWEN_URL_CONSTLIST2 *l); 
02980    
02981   GWEN_URL_CONSTLIST2_ITERATOR *GWEN_Url_ConstList2_First(GWEN_URL_CONSTLIST2 *l); 
02982    
02983   GWEN_URL_CONSTLIST2_ITERATOR *GWEN_Url_ConstList2_Last(GWEN_URL_CONSTLIST2 *l); 
02984    
02985   GWEN_URL_CONSTLIST2_ITERATOR *GWEN_Url_ConstList2Iterator_new(GWEN_URL_CONSTLIST2 *l); 
02986    
02987   void GWEN_Url_ConstList2Iterator_free(GWEN_URL_CONSTLIST2_ITERATOR *li); 
02988    
02989   const GWEN_URL *GWEN_Url_ConstList2Iterator_Previous(GWEN_URL_CONSTLIST2_ITERATOR *li); 
02990    
02991   const GWEN_URL *GWEN_Url_ConstList2Iterator_Next(GWEN_URL_CONSTLIST2_ITERATOR *li); 
02992    
02993   const GWEN_URL *GWEN_Url_ConstList2Iterator_Data(GWEN_URL_CONSTLIST2_ITERATOR *li); 
02994    
03006   const GWEN_URL *GWEN_Url_ConstList2_ForEach(GWEN_URL_CONSTLIST2 *list,
03007         GWEN_URL_CONSTLIST2_FOREACH func, void *user_data);
03008 
03009 
03010 #ifdef __cplusplus
03011 }
03012 #endif
03013 
03014 
03015 #endif /* GWEN_URL_LIST_H */
03016 
03017 
03018 
03019 /***************************************************************************
03020  $RCSfile$
03021  -------------------
03022  cvs         : $Id$
03023  begin       : Sat Jun 28 2003
03024  copyright   : (C) 2003 by Martin Preuss
03025  email       : martin@libchipcard.de
03026 
03027  ***************************************************************************
03028  *                                                                         *
03029  *   This library is free software; you can redistribute it and/or         *
03030  *   modify it under the terms of the GNU Lesser General Public            *
03031  *   License as published by the Free Software Foundation; either          *
03032  *   version 2.1 of the License, or (at your option) any later version.    *
03033  *                                                                         *
03034  *   This library is distributed in the hope that it will be useful,       *
03035  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
03036  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
03037  *   Lesser General Public License for more details.                       *
03038  *                                                                         *
03039  *   You should have received a copy of the GNU Lesser General Public      *
03040  *   License along with this library; if not, write to the Free Software   *
03041  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
03042  *   MA  02111-1307  USA                                                   *
03043  *                                                                         *
03044  ***************************************************************************/
03045 
03046 
03047 #ifndef GWEN_URL_LIST1_H
03048 #define GWEN_URL_LIST1_H
03049 
03050 #ifdef __cplusplus
03051 extern "C" {
03052 #endif
03053 
03055   typedef struct GWEN_URL_LIST_ELEMENT {
03056     uint32_t id;
03057     GWEN_URL *nextObject;
03058   } GWEN_URL_LIST__ELEMENT;
03059 
03066   typedef struct GWEN_URL_LIST GWEN_URL_LIST;
03068   struct GWEN_URL_LIST {
03069     GWEN_URL *first;
03070     uint32_t count;
03071     uint32_t id;
03072   } GWEN_URL_LIST;
03073 
03078   void GWEN_Url_List_AddList(GWEN_URL_LIST *dst, GWEN_URL_LIST *l);
03079 
03083   void GWEN_Url_List_Add(GWEN_URL *element, GWEN_URL_LIST *list);
03084 
03089   void GWEN_Url_List_Insert(GWEN_URL *element, GWEN_URL_LIST *list);
03090 
03097   void GWEN_Url_List_Del(GWEN_URL *element);
03098 
03102   GWEN_URL* GWEN_Url_List_First(const GWEN_URL_LIST *l);
03103 
03107   GWEN_URL* GWEN_Url_List_Last(const GWEN_URL_LIST *l);
03108 
03113   void GWEN_Url_List_Clear(GWEN_URL_LIST *l);
03114 
03118   GWEN_URL_LIST* GWEN_Url_List_new();
03119 
03123   void GWEN_Url_List_free(GWEN_URL_LIST *l);
03124 
03128   GWEN_URL* GWEN_Url_List_Next(const GWEN_URL *element);
03129 
03133   GWEN_URL* GWEN_Url_List_Previous(const GWEN_URL *element);
03134 
03138   uint32_t GWEN_Url_List_GetCount(const GWEN_URL_LIST *l);
03139 
03140 #ifdef __cplusplus
03141 }
03142 #endif
03143 
03144 
03145 #endif
03146 
03147 
03148 
03149 /***************************************************************************
03150  $RCSfile$
03151  -------------------
03152  cvs         : $Id$
03153  begin       : Sat Jun 28 2003
03154  copyright   : (C) 2003 by Martin Preuss
03155  email       : martin@libchipcard.de
03156 
03157  ***************************************************************************
03158  *                                                                         *
03159  *   This library is free software; you can redistribute it and/or         *
03160  *   modify it under the terms of the GNU Lesser General Public            *
03161  *   License as published by the Free Software Foundation; either          *
03162  *   version 2.1 of the License, or (at your option) any later version.    *
03163  *                                                                         *
03164  *   This library is distributed in the hope that it will be useful,       *
03165  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
03166  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
03167  *   Lesser General Public License for more details.                       *
03168  *                                                                         *
03169  *   You should have received a copy of the GNU Lesser General Public      *
03170  *   License along with this library; if not, write to the Free Software   *
03171  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
03172  *   MA  02111-1307  USA                                                   *
03173  *                                                                         *
03174  ***************************************************************************/
03175 
03176 
03177 #ifndef GWEN_CRYPT_TOKEN_CONTEXT_LIST2_H
03178 #define GWEN_CRYPT_TOKEN_CONTEXT_LIST2_H
03179 
03180 
03181 #ifdef __cplusplus
03182 extern "C" {
03183 #endif
03184 
03191   typedef struct GWEN_CRYPT_TOKEN_CONTEXT_LIST2 GWEN_CRYPT_TOKEN_CONTEXT_LIST2;
03192 
03196   typedef struct GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR;
03197 
03201   typedef GWEN_CRYPT_TOKEN_CONTEXT* (GWEN_CRYPT_TOKEN_CONTEXT_LIST2_FOREACH)(GWEN_CRYPT_TOKEN_CONTEXT *element,
03202                                                  void *user_data);
03203 
03207   GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *GWEN_Crypt_Token_Context_List2_new(); 
03208 
03212   void GWEN_Crypt_Token_Context_List2_free(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l); 
03213 
03217   void GWEN_Crypt_Token_Context_List2_Dump(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l, FILE *f, unsigned int indent); 
03218 
03222   void GWEN_Crypt_Token_Context_List2_PushBack(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l, GWEN_CRYPT_TOKEN_CONTEXT *p); 
03223    
03228   void GWEN_Crypt_Token_Context_List2_PushFront(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l, GWEN_CRYPT_TOKEN_CONTEXT *p); 
03229 
03234   GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_List2_GetFront(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l); 
03235    
03240   GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_List2_GetBack(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l); 
03241 
03246   void GWEN_Crypt_Token_Context_List2_Erase(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l,
03247                                GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *it);
03248 
03254   unsigned int GWEN_Crypt_Token_Context_List2_GetSize(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l); 
03255 
03260   void GWEN_Crypt_Token_Context_List2_PopBack(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l); 
03261    
03266   void GWEN_Crypt_Token_Context_List2_PopFront(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l); 
03267 
03271   void GWEN_Crypt_Token_Context_List2_Clear(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l); 
03272 
03276   GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *GWEN_Crypt_Token_Context_List2_First(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l); 
03277    
03281   GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *GWEN_Crypt_Token_Context_List2_Last(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l); 
03282 
03286   GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *GWEN_Crypt_Token_Context_List2Iterator_new(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l);
03287 
03291   void GWEN_Crypt_Token_Context_List2Iterator_free(GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *li); 
03292 
03297   GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_List2Iterator_Previous(GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *li); 
03298    
03303   GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_List2Iterator_Next(GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *li); 
03304 
03309   GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_List2Iterator_Data(GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *li); 
03310 
03322   GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_List2_ForEach(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *list,
03323                                         GWEN_CRYPT_TOKEN_CONTEXT_LIST2_FOREACH func,
03324                                         void *user_data);
03325 
03326 
03327   typedef struct GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2; 
03328   typedef struct GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR; 
03329   typedef const GWEN_CRYPT_TOKEN_CONTEXT*
03330     (GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_FOREACH)(const GWEN_CRYPT_TOKEN_CONTEXT *element,
03331                                     void *user_data);
03332   
03333    
03334   GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *GWEN_Crypt_Token_Context_ConstList2_new(); 
03335    
03336   void GWEN_Crypt_Token_Context_ConstList2_free(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l); 
03337    
03338   void GWEN_Crypt_Token_Context_ConstList2_PushBack(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l, const GWEN_CRYPT_TOKEN_CONTEXT *p); 
03339    
03340   void GWEN_Crypt_Token_Context_ConstList2_PushFront(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l, const GWEN_CRYPT_TOKEN_CONTEXT *p); 
03341    
03342   const GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_ConstList2_GetFront(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l); 
03343    
03344   const GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_ConstList2_GetBack(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l); 
03345    
03346   unsigned int GWEN_Crypt_Token_Context_ConstList2_GetSize(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l); 
03347    
03348   void GWEN_Crypt_Token_Context_ConstList2_PopBack(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l); 
03349    
03350   void GWEN_Crypt_Token_Context_ConstList2_PopFront(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l); 
03351    
03352   void GWEN_Crypt_Token_Context_ConstList2_Clear(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l); 
03353    
03354   GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_Context_ConstList2_First(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l); 
03355    
03356   GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_Context_ConstList2_Last(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l); 
03357    
03358   GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_Context_ConstList2Iterator_new(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l); 
03359    
03360   void GWEN_Crypt_Token_Context_ConstList2Iterator_free(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *li); 
03361    
03362   const GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_ConstList2Iterator_Previous(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *li); 
03363    
03364   const GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_ConstList2Iterator_Next(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *li); 
03365    
03366   const GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_ConstList2Iterator_Data(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *li); 
03367    
03379   const GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_ConstList2_ForEach(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *list,
03380         GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_FOREACH func, void *user_data);
03381 
03382 
03383 #ifdef __cplusplus
03384 }
03385 #endif
03386 
03387 
03388 #endif /* GWEN_CRYPT_TOKEN_CONTEXT_LIST_H */
03389 
03390 
03391 
03392 /***************************************************************************
03393  $RCSfile$
03394  -------------------
03395  cvs         : $Id$
03396  begin       : Sat Jun 28 2003
03397  copyright   : (C) 2003 by Martin Preuss
03398  email       : martin@libchipcard.de
03399 
03400  ***************************************************************************
03401  *                                                                         *
03402  *   This library is free software; you can redistribute it and/or         *
03403  *   modify it under the terms of the GNU Lesser General Public            *
03404  *   License as published by the Free Software Foundation; either          *
03405  *   version 2.1 of the License, or (at your option) any later version.    *
03406  *                                                                         *
03407  *   This library is distributed in the hope that it will be useful,       *
03408  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
03409  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
03410  *   Lesser General Public License for more details.                       *
03411  *                                                                         *
03412  *   You should have received a copy of the GNU Lesser General Public      *
03413  *   License along with this library; if not, write to the Free Software   *
03414  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
03415  *   MA  02111-1307  USA                                                   *
03416  *                                                                         *
03417  ***************************************************************************/
03418 
03419 
03420 #ifndef GWEN_CRYPT_TOKEN_CONTEXT_LIST1_H
03421 #define GWEN_CRYPT_TOKEN_CONTEXT_LIST1_H
03422 
03423 #ifdef __cplusplus
03424 extern "C" {
03425 #endif
03426 
03428   typedef struct GWEN_CRYPT_TOKEN_CONTEXT_LIST_ELEMENT {
03429     uint32_t id;
03430     GWEN_CRYPT_TOKEN_CONTEXT *nextObject;
03431   } GWEN_CRYPT_TOKEN_CONTEXT_LIST__ELEMENT;
03432 
03439   typedef struct GWEN_CRYPT_TOKEN_CONTEXT_LIST GWEN_CRYPT_TOKEN_CONTEXT_LIST;
03441   struct GWEN_CRYPT_TOKEN_CONTEXT_LIST {
03442     GWEN_CRYPT_TOKEN_CONTEXT *first;
03443     uint32_t count;
03444     uint32_t id;
03445   } GWEN_CRYPT_TOKEN_CONTEXT_LIST;
03446 
03451   void GWEN_Crypt_Token_Context_List_AddList(GWEN_CRYPT_TOKEN_CONTEXT_LIST *dst, GWEN_CRYPT_TOKEN_CONTEXT_LIST *l);
03452 
03456   void GWEN_Crypt_Token_Context_List_Add(GWEN_CRYPT_TOKEN_CONTEXT *element, GWEN_CRYPT_TOKEN_CONTEXT_LIST *list);
03457 
03462   void GWEN_Crypt_Token_Context_List_Insert(GWEN_CRYPT_TOKEN_CONTEXT *element, GWEN_CRYPT_TOKEN_CONTEXT_LIST *list);
03463 
03470   void GWEN_Crypt_Token_Context_List_Del(GWEN_CRYPT_TOKEN_CONTEXT *element);
03471 
03475   GWEN_CRYPT_TOKEN_CONTEXT* GWEN_Crypt_Token_Context_List_First(const GWEN_CRYPT_TOKEN_CONTEXT_LIST *l);
03476 
03480   GWEN_CRYPT_TOKEN_CONTEXT* GWEN_Crypt_Token_Context_List_Last(const GWEN_CRYPT_TOKEN_CONTEXT_LIST *l);
03481 
03486   void GWEN_Crypt_Token_Context_List_Clear(GWEN_CRYPT_TOKEN_CONTEXT_LIST *l);
03487 
03491   GWEN_CRYPT_TOKEN_CONTEXT_LIST* GWEN_Crypt_Token_Context_List_new();
03492 
03496   void GWEN_Crypt_Token_Context_List_free(GWEN_CRYPT_TOKEN_CONTEXT_LIST *l);
03497 
03501   GWEN_CRYPT_TOKEN_CONTEXT* GWEN_Crypt_Token_Context_List_Next(const GWEN_CRYPT_TOKEN_CONTEXT *element);
03502 
03506   GWEN_CRYPT_TOKEN_CONTEXT* GWEN_Crypt_Token_Context_List_Previous(const GWEN_CRYPT_TOKEN_CONTEXT *element);
03507 
03511   uint32_t GWEN_Crypt_Token_Context_List_GetCount(const GWEN_CRYPT_TOKEN_CONTEXT_LIST *l);
03512 
03513 #ifdef __cplusplus
03514 }
03515 #endif
03516 
03517 
03518 #endif
03519 
03520 
03521 
03522 /***************************************************************************
03523  $RCSfile$
03524  -------------------
03525  cvs         : $Id$
03526  begin       : Sat Jun 28 2003
03527  copyright   : (C) 2003 by Martin Preuss
03528  email       : martin@libchipcard.de
03529 
03530  ***************************************************************************
03531  *                                                                         *
03532  *   This library is free software; you can redistribute it and/or         *
03533  *   modify it under the terms of the GNU Lesser General Public            *
03534  *   License as published by the Free Software Foundation; either          *
03535  *   version 2.1 of the License, or (at your option) any later version.    *
03536  *                                                                         *
03537  *   This library is distributed in the hope that it will be useful,       *
03538  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
03539  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
03540  *   Lesser General Public License for more details.                       *
03541  *                                                                         *
03542  *   You should have received a copy of the GNU Lesser General Public      *
03543  *   License along with this library; if not, write to the Free Software   *
03544  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
03545  *   MA  02111-1307  USA                                                   *
03546  *                                                                         *
03547  ***************************************************************************/
03548 
03549 
03550 #ifndef GWEN_CRYPT_TOKEN_LIST2_H
03551 #define GWEN_CRYPT_TOKEN_LIST2_H
03552 
03553 
03554 #ifdef __cplusplus
03555 extern "C" {
03556 #endif
03557 
03564   typedef struct GWEN_CRYPT_TOKEN_LIST2 GWEN_CRYPT_TOKEN_LIST2;
03565 
03569   typedef struct GWEN_CRYPT_TOKEN_LIST2_ITERATOR GWEN_CRYPT_TOKEN_LIST2_ITERATOR;
03570 
03574   typedef GWEN_CRYPT_TOKEN* (GWEN_CRYPT_TOKEN_LIST2_FOREACH)(GWEN_CRYPT_TOKEN *element,
03575                                                  void *user_data);
03576 
03580   GWEN_CRYPT_TOKEN_LIST2 *GWEN_Crypt_Token_List2_new(); 
03581 
03585   void GWEN_Crypt_Token_List2_free(GWEN_CRYPT_TOKEN_LIST2 *l); 
03586 
03590   void GWEN_Crypt_Token_List2_Dump(GWEN_CRYPT_TOKEN_LIST2 *l, FILE *f, unsigned int indent); 
03591 
03595   void GWEN_Crypt_Token_List2_PushBack(GWEN_CRYPT_TOKEN_LIST2 *l, GWEN_CRYPT_TOKEN *p); 
03596    
03601   void GWEN_Crypt_Token_List2_PushFront(GWEN_CRYPT_TOKEN_LIST2 *l, GWEN_CRYPT_TOKEN *p); 
03602 
03607   GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_List2_GetFront(GWEN_CRYPT_TOKEN_LIST2 *l); 
03608    
03613   GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_List2_GetBack(GWEN_CRYPT_TOKEN_LIST2 *l); 
03614 
03619   void GWEN_Crypt_Token_List2_Erase(GWEN_CRYPT_TOKEN_LIST2 *l,
03620                                GWEN_CRYPT_TOKEN_LIST2_ITERATOR *it);
03621 
03627   unsigned int GWEN_Crypt_Token_List2_GetSize(GWEN_CRYPT_TOKEN_LIST2 *l); 
03628 
03633   void GWEN_Crypt_Token_List2_PopBack(GWEN_CRYPT_TOKEN_LIST2 *l); 
03634    
03639   void GWEN_Crypt_Token_List2_PopFront(GWEN_CRYPT_TOKEN_LIST2 *l); 
03640 
03644   void GWEN_Crypt_Token_List2_Clear(GWEN_CRYPT_TOKEN_LIST2 *l); 
03645 
03649   GWEN_CRYPT_TOKEN_LIST2_ITERATOR *GWEN_Crypt_Token_List2_First(GWEN_CRYPT_TOKEN_LIST2 *l); 
03650    
03654   GWEN_CRYPT_TOKEN_LIST2_ITERATOR *GWEN_Crypt_Token_List2_Last(GWEN_CRYPT_TOKEN_LIST2 *l); 
03655 
03659   GWEN_CRYPT_TOKEN_LIST2_ITERATOR *GWEN_Crypt_Token_List2Iterator_new(GWEN_CRYPT_TOKEN_LIST2 *l);
03660 
03664   void GWEN_Crypt_Token_List2Iterator_free(GWEN_CRYPT_TOKEN_LIST2_ITERATOR *li); 
03665 
03670   GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_List2Iterator_Previous(GWEN_CRYPT_TOKEN_LIST2_ITERATOR *li); 
03671    
03676   GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_List2Iterator_Next(GWEN_CRYPT_TOKEN_LIST2_ITERATOR *li); 
03677 
03682   GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_List2Iterator_Data(GWEN_CRYPT_TOKEN_LIST2_ITERATOR *li); 
03683 
03695   GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_List2_ForEach(GWEN_CRYPT_TOKEN_LIST2 *list,
03696                                         GWEN_CRYPT_TOKEN_LIST2_FOREACH func,
03697                                         void *user_data);
03698 
03699 
03700   typedef struct GWEN_CRYPT_TOKEN_CONSTLIST2 GWEN_CRYPT_TOKEN_CONSTLIST2; 
03701   typedef struct GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR; 
03702   typedef const GWEN_CRYPT_TOKEN*
03703     (GWEN_CRYPT_TOKEN_CONSTLIST2_FOREACH)(const GWEN_CRYPT_TOKEN *element,
03704                                     void *user_data);
03705   
03706    
03707   GWEN_CRYPT_TOKEN_CONSTLIST2 *GWEN_Crypt_Token_ConstList2_new(); 
03708    
03709   void GWEN_Crypt_Token_ConstList2_free(GWEN_CRYPT_TOKEN_CONSTLIST2 *l); 
03710    
03711   void GWEN_Crypt_Token_ConstList2_PushBack(GWEN_CRYPT_TOKEN_CONSTLIST2 *l, const GWEN_CRYPT_TOKEN *p); 
03712    
03713   void GWEN_Crypt_Token_ConstList2_PushFront(GWEN_CRYPT_TOKEN_CONSTLIST2 *l, const GWEN_CRYPT_TOKEN *p); 
03714    
03715   const GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_ConstList2_GetFront(GWEN_CRYPT_TOKEN_CONSTLIST2 *l); 
03716    
03717   const GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_ConstList2_GetBack(GWEN_CRYPT_TOKEN_CONSTLIST2 *l); 
03718    
03719   unsigned int GWEN_Crypt_Token_ConstList2_GetSize(GWEN_CRYPT_TOKEN_CONSTLIST2 *l); 
03720    
03721   void GWEN_Crypt_Token_ConstList2_PopBack(GWEN_CRYPT_TOKEN_CONSTLIST2 *l); 
03722    
03723   void GWEN_Crypt_Token_ConstList2_PopFront(GWEN_CRYPT_TOKEN_CONSTLIST2 *l); 
03724    
03725   void GWEN_Crypt_Token_ConstList2_Clear(GWEN_CRYPT_TOKEN_CONSTLIST2 *l); 
03726    
03727   GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_ConstList2_First(GWEN_CRYPT_TOKEN_CONSTLIST2 *l); 
03728    
03729   GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_ConstList2_Last(GWEN_CRYPT_TOKEN_CONSTLIST2 *l); 
03730    
03731   GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_ConstList2Iterator_new(GWEN_CRYPT_TOKEN_CONSTLIST2 *l); 
03732    
03733   void GWEN_Crypt_Token_ConstList2Iterator_free(GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *li); 
03734    
03735   const GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_ConstList2Iterator_Previous(GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *li); 
03736    
03737   const GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_ConstList2Iterator_Next(GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *li); 
03738    
03739   const GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_ConstList2Iterator_Data(GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *li); 
03740    
03752   const GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_ConstList2_ForEach(GWEN_CRYPT_TOKEN_CONSTLIST2 *list,
03753         GWEN_CRYPT_TOKEN_CONSTLIST2_FOREACH func, void *user_data);
03754 
03755 
03756 #ifdef __cplusplus
03757 }
03758 #endif
03759 
03760 
03761 #endif /* GWEN_CRYPT_TOKEN_LIST_H */
03762 
03763 
03764 
03765 /***************************************************************************
03766  $RCSfile$
03767  -------------------
03768  cvs         : $Id$
03769  begin       : Sat Jun 28 2003
03770  copyright   : (C) 2003 by Martin Preuss
03771  email       : martin@libchipcard.de
03772 
03773  ***************************************************************************
03774  *                                                                         *
03775  *   This library is free software; you can redistribute it and/or         *
03776  *   modify it under the terms of the GNU Lesser General Public            *
03777  *   License as published by the Free Software Foundation; either          *
03778  *   version 2.1 of the License, or (at your option) any later version.    *
03779  *                                                                         *
03780  *   This library is distributed in the hope that it will be useful,       *
03781  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
03782  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
03783  *   Lesser General Public License for more details.                       *
03784  *                                                                         *
03785  *   You should have received a copy of the GNU Lesser General Public      *
03786  *   License along with this library; if not, write to the Free Software   *
03787  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
03788  *   MA  02111-1307  USA                                                   *
03789  *                                                                         *
03790  ***************************************************************************/
03791 
03792 
03793 #ifndef GWEN_CRYPT_TOKEN_LIST1_H
03794 #define GWEN_CRYPT_TOKEN_LIST1_H
03795 
03796 #ifdef __cplusplus
03797 extern "C" {
03798 #endif
03799 
03801   typedef struct GWEN_CRYPT_TOKEN_LIST_ELEMENT {
03802     uint32_t id;
03803     GWEN_CRYPT_TOKEN *nextObject;
03804   } GWEN_CRYPT_TOKEN_LIST__ELEMENT;
03805 
03812   typedef struct GWEN_CRYPT_TOKEN_LIST GWEN_CRYPT_TOKEN_LIST;
03814   struct GWEN_CRYPT_TOKEN_LIST {
03815     GWEN_CRYPT_TOKEN *first;
03816     uint32_t count;
03817     uint32_t id;
03818   } GWEN_CRYPT_TOKEN_LIST;
03819 
03824   void GWEN_Crypt_Token_List_AddList(GWEN_CRYPT_TOKEN_LIST *dst, GWEN_CRYPT_TOKEN_LIST *l);
03825 
03829   void GWEN_Crypt_Token_List_Add(GWEN_CRYPT_TOKEN *element, GWEN_CRYPT_TOKEN_LIST *list);
03830 
03835   void GWEN_Crypt_Token_List_Insert(GWEN_CRYPT_TOKEN *element, GWEN_CRYPT_TOKEN_LIST *list);
03836 
03843   void GWEN_Crypt_Token_List_Del(GWEN_CRYPT_TOKEN *element);
03844 
03848   GWEN_CRYPT_TOKEN* GWEN_Crypt_Token_List_First(const GWEN_CRYPT_TOKEN_LIST *l);
03849 
03853   GWEN_CRYPT_TOKEN* GWEN_Crypt_Token_List_Last(const GWEN_CRYPT_TOKEN_LIST *l);
03854 
03859   void GWEN_Crypt_Token_List_Clear(GWEN_CRYPT_TOKEN_LIST *l);
03860 
03864   GWEN_CRYPT_TOKEN_LIST* GWEN_Crypt_Token_List_new();
03865 
03869   void GWEN_Crypt_Token_List_free(GWEN_CRYPT_TOKEN_LIST *l);
03870 
03874   GWEN_CRYPT_TOKEN* GWEN_Crypt_Token_List_Next(const GWEN_CRYPT_TOKEN *element);
03875 
03879   GWEN_CRYPT_TOKEN* GWEN_Crypt_Token_List_Previous(const GWEN_CRYPT_TOKEN *element);
03880 
03884   uint32_t GWEN_Crypt_Token_List_GetCount(const GWEN_CRYPT_TOKEN_LIST *l);
03885 
03886 #ifdef __cplusplus
03887 }
03888 #endif
03889 
03890 
03891 #endif
03892 
03893 
03894 
03895 /***************************************************************************
03896  $RCSfile$
03897  -------------------
03898  cvs         : $Id$
03899  begin       : Sat Jun 28 2003
03900  copyright   : (C) 2003 by Martin Preuss
03901  email       : martin@libchipcard.de
03902 
03903  ***************************************************************************
03904  *                                                                         *
03905  *   This library is free software; you can redistribute it and/or         *
03906  *   modify it under the terms of the GNU Lesser General Public            *
03907  *   License as published by the Free Software Foundation; either          *
03908  *   version 2.1 of the License, or (at your option) any later version.    *
03909  *                                                                         *
03910  *   This library is distributed in the hope that it will be useful,       *
03911  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
03912  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
03913  *   Lesser General Public License for more details.                       *
03914  *                                                                         *
03915  *   You should have received a copy of the GNU Lesser General Public      *
03916  *   License along with this library; if not, write to the Free Software   *
03917  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
03918  *   MA  02111-1307  USA                                                   *
03919  *                                                                         *
03920  ***************************************************************************/
03921 
03922 
03923 #ifndef GWEN_SSLCERTDESCR_LIST2_H
03924 #define GWEN_SSLCERTDESCR_LIST2_H
03925 
03926 
03927 #ifdef __cplusplus
03928 extern "C" {
03929 #endif
03930 
03937   typedef struct GWEN_SSLCERTDESCR_LIST2 GWEN_SSLCERTDESCR_LIST2;
03938 
03942   typedef struct GWEN_SSLCERTDESCR_LIST2_ITERATOR GWEN_SSLCERTDESCR_LIST2_ITERATOR;
03943 
03947   typedef GWEN_SSLCERTDESCR* (GWEN_SSLCERTDESCR_LIST2_FOREACH)(GWEN_SSLCERTDESCR *element,
03948                                                  void *user_data);
03949 
03953   GWEN_SSLCERTDESCR_LIST2 *GWEN_SslCertDescr_List2_new(); 
03954 
03958   void GWEN_SslCertDescr_List2_free(GWEN_SSLCERTDESCR_LIST2 *l); 
03959 
03963   void GWEN_SslCertDescr_List2_Dump(GWEN_SSLCERTDESCR_LIST2 *l, FILE *f, unsigned int indent); 
03964 
03968   void GWEN_SslCertDescr_List2_PushBack(GWEN_SSLCERTDESCR_LIST2 *l, GWEN_SSLCERTDESCR *p); 
03969    
03974   void GWEN_SslCertDescr_List2_PushFront(GWEN_SSLCERTDESCR_LIST2 *l, GWEN_SSLCERTDESCR *p); 
03975 
03980   GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2_GetFront(GWEN_SSLCERTDESCR_LIST2 *l); 
03981    
03986   GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2_GetBack(GWEN_SSLCERTDESCR_LIST2 *l); 
03987 
03992   void GWEN_SslCertDescr_List2_Erase(GWEN_SSLCERTDESCR_LIST2 *l,
03993                                GWEN_SSLCERTDESCR_LIST2_ITERATOR *it);
03994 
04000   unsigned int GWEN_SslCertDescr_List2_GetSize(GWEN_SSLCERTDESCR_LIST2 *l); 
04001 
04006   void GWEN_SslCertDescr_List2_PopBack(GWEN_SSLCERTDESCR_LIST2 *l); 
04007    
04012   void GWEN_SslCertDescr_List2_PopFront(GWEN_SSLCERTDESCR_LIST2 *l); 
04013 
04017   void GWEN_SslCertDescr_List2_Clear(GWEN_SSLCERTDESCR_LIST2 *l); 
04018 
04022   GWEN_SSLCERTDESCR_LIST2_ITERATOR *GWEN_SslCertDescr_List2_First(GWEN_SSLCERTDESCR_LIST2 *l); 
04023    
04027   GWEN_SSLCERTDESCR_LIST2_ITERATOR *GWEN_SslCertDescr_List2_Last(GWEN_SSLCERTDESCR_LIST2 *l); 
04028 
04032   GWEN_SSLCERTDESCR_LIST2_ITERATOR *GWEN_SslCertDescr_List2Iterator_new(GWEN_SSLCERTDESCR_LIST2 *l);
04033 
04037   void GWEN_SslCertDescr_List2Iterator_free(GWEN_SSLCERTDESCR_LIST2_ITERATOR *li); 
04038 
04043   GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2Iterator_Previous(GWEN_SSLCERTDESCR_LIST2_ITERATOR *li); 
04044    
04049   GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2Iterator_Next(GWEN_SSLCERTDESCR_LIST2_ITERATOR *li); 
04050 
04055   GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2Iterator_Data(GWEN_SSLCERTDESCR_LIST2_ITERATOR *li); 
04056 
04068   GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2_ForEach(GWEN_SSLCERTDESCR_LIST2 *list,
04069                                         GWEN_SSLCERTDESCR_LIST2_FOREACH func,
04070                                         void *user_data);
04071 
04072 
04073   typedef struct GWEN_SSLCERTDESCR_CONSTLIST2 GWEN_SSLCERTDESCR_CONSTLIST2; 
04074   typedef struct GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR; 
04075   typedef const GWEN_SSLCERTDESCR*
04076     (GWEN_SSLCERTDESCR_CONSTLIST2_FOREACH)(const GWEN_SSLCERTDESCR *element,
04077                                     void *user_data);
04078   
04079    
04080   GWEN_SSLCERTDESCR_CONSTLIST2 *GWEN_SslCertDescr_ConstList2_new(); 
04081    
04082   void GWEN_SslCertDescr_ConstList2_free(GWEN_SSLCERTDESCR_CONSTLIST2 *l); 
04083    
04084   void GWEN_SslCertDescr_ConstList2_PushBack(GWEN_SSLCERTDESCR_CONSTLIST2 *l, const GWEN_SSLCERTDESCR *p); 
04085    
04086   void GWEN_SslCertDescr_ConstList2_PushFront(GWEN_SSLCERTDESCR_CONSTLIST2 *l, const GWEN_SSLCERTDESCR *p); 
04087    
04088   const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2_GetFront(GWEN_SSLCERTDESCR_CONSTLIST2 *l); 
04089    
04090   const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2_GetBack(GWEN_SSLCERTDESCR_CONSTLIST2 *l); 
04091    
04092   unsigned int GWEN_SslCertDescr_ConstList2_GetSize(GWEN_SSLCERTDESCR_CONSTLIST2 *l); 
04093    
04094   void GWEN_SslCertDescr_ConstList2_PopBack(GWEN_SSLCERTDESCR_CONSTLIST2 *l); 
04095    
04096   void GWEN_SslCertDescr_ConstList2_PopFront(GWEN_SSLCERTDESCR_CONSTLIST2 *l); 
04097    
04098   void GWEN_SslCertDescr_ConstList2_Clear(GWEN_SSLCERTDESCR_CONSTLIST2 *l); 
04099    
04100   GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *GWEN_SslCertDescr_ConstList2_First(GWEN_SSLCERTDESCR_CONSTLIST2 *l); 
04101    
04102   GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *GWEN_SslCertDescr_ConstList2_Last(GWEN_SSLCERTDESCR_CONSTLIST2 *l); 
04103    
04104   GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *GWEN_SslCertDescr_ConstList2Iterator_new(GWEN_SSLCERTDESCR_CONSTLIST2 *l); 
04105    
04106   void GWEN_SslCertDescr_ConstList2Iterator_free(GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *li); 
04107    
04108   const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2Iterator_Previous(GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *li); 
04109    
04110   const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2Iterator_Next(GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *li); 
04111    
04112   const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2Iterator_Data(GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *li); 
04113    
04125   const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2_ForEach(GWEN_SSLCERTDESCR_CONSTLIST2 *list,
04126         GWEN_SSLCERTDESCR_CONSTLIST2_FOREACH func, void *user_data);
04127 
04128 
04129 #ifdef __cplusplus
04130 }
04131 #endif
04132 
04133 
04134 #endif /* GWEN_SSLCERTDESCR_LIST_H */
04135 
04136 
04137 
04138 /***************************************************************************
04139  $RCSfile$
04140  -------------------
04141  cvs         : $Id$
04142  begin       : Sat Jun 28 2003
04143  copyright   : (C) 2003 by Martin Preuss
04144  email       : martin@libchipcard.de
04145 
04146  ***************************************************************************
04147  *                                                                         *
04148  *   This library is free software; you can redistribute it and/or         *
04149  *   modify it under the terms of the GNU Lesser General Public            *
04150  *   License as published by the Free Software Foundation; either          *
04151  *   version 2.1 of the License, or (at your option) any later version.    *
04152  *                                                                         *
04153  *   This library is distributed in the hope that it will be useful,       *
04154  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
04155  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
04156  *   Lesser General Public License for more details.                       *
04157  *                                                                         *
04158  *   You should have received a copy of the GNU Lesser General Public      *
04159  *   License along with this library; if not, write to the Free Software   *
04160  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
04161  *   MA  02111-1307  USA                                                   *
04162  *                                                                         *
04163  ***************************************************************************/
04164 
04165 
04166 #ifndef GWEN_SSLCERTDESCR_LIST1_H
04167 #define GWEN_SSLCERTDESCR_LIST1_H
04168 
04169 #ifdef __cplusplus
04170 extern "C" {
04171 #endif
04172 
04174   typedef struct GWEN_SSLCERTDESCR_LIST_ELEMENT {
04175     uint32_t id;
04176     GWEN_SSLCERTDESCR *nextObject;
04177   } GWEN_SSLCERTDESCR_LIST__ELEMENT;
04178 
04185   typedef struct GWEN_SSLCERTDESCR_LIST GWEN_SSLCERTDESCR_LIST;
04187   struct GWEN_SSLCERTDESCR_LIST {
04188     GWEN_SSLCERTDESCR *first;
04189     uint32_t count;
04190     uint32_t id;
04191   } GWEN_SSLCERTDESCR_LIST;
04192 
04197   void GWEN_SslCertDescr_List_AddList(GWEN_SSLCERTDESCR_LIST *dst, GWEN_SSLCERTDESCR_LIST *l);
04198 
04202   void GWEN_SslCertDescr_List_Add(GWEN_SSLCERTDESCR *element, GWEN_SSLCERTDESCR_LIST *list);
04203 
04208   void GWEN_SslCertDescr_List_Insert(GWEN_SSLCERTDESCR *element, GWEN_SSLCERTDESCR_LIST *list);
04209 
04216   void GWEN_SslCertDescr_List_Del(GWEN_SSLCERTDESCR *element);
04217 
04221   GWEN_SSLCERTDESCR* GWEN_SslCertDescr_List_First(const GWEN_SSLCERTDESCR_LIST *l);
04222 
04226   GWEN_SSLCERTDESCR* GWEN_SslCertDescr_List_Last(const GWEN_SSLCERTDESCR_LIST *l);
04227 
04232   void GWEN_SslCertDescr_List_Clear(GWEN_SSLCERTDESCR_LIST *l);
04233 
04237   GWEN_SSLCERTDESCR_LIST* GWEN_SslCertDescr_List_new();
04238 
04242   void GWEN_SslCertDescr_List_free(GWEN_SSLCERTDESCR_LIST *l);
04243 
04247   GWEN_SSLCERTDESCR* GWEN_SslCertDescr_List_Next(const GWEN_SSLCERTDESCR *element);
04248 
04252   GWEN_SSLCERTDESCR* GWEN_SslCertDescr_List_Previous(const GWEN_SSLCERTDESCR *element);
04253 
04257   uint32_t GWEN_SslCertDescr_List_GetCount(const GWEN_SSLCERTDESCR_LIST *l);
04258 
04259 #ifdef __cplusplus
04260 }
04261 #endif
04262 
04263 
04264 #endif
04265 
04266 
04267 
04268 /***************************************************************************
04269  $RCSfile$
04270  -------------------
04271  cvs         : $Id$
04272  begin       : Sat Jun 28 2003
04273  copyright   : (C) 2003 by Martin Preuss
04274  email       : martin@libchipcard.de
04275 
04276  ***************************************************************************
04277  *                                                                         *
04278  *   This library is free software; you can redistribute it and/or         *
04279  *   modify it under the terms of the GNU Lesser General Public            *
04280  *   License as published by the Free Software Foundation; either          *
04281  *   version 2.1 of the License, or (at your option) any later version.    *
04282  *                                                                         *
04283  *   This library is distributed in the hope that it will be useful,       *
04284  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
04285  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
04286  *   Lesser General Public License for more details.                       *
04287  *                                                                         *
04288  *   You should have received a copy of the GNU Lesser General Public      *
04289  *   License along with this library; if not, write to the Free Software   *
04290  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
04291  *   MA  02111-1307  USA                                                   *
04292  *                                                                         *
04293  ***************************************************************************/
04294 
04295 
04296 #ifndef GWEN_CRYPT_TOKEN_KEYINFO_LIST2_H
04297 #define GWEN_CRYPT_TOKEN_KEYINFO_LIST2_H
04298 
04299 
04300 #ifdef __cplusplus
04301 extern "C" {
04302 #endif
04303 
04310   typedef struct GWEN_CRYPT_TOKEN_KEYINFO_LIST2 GWEN_CRYPT_TOKEN_KEYINFO_LIST2;
04311 
04315   typedef struct GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR;
04316 
04320   typedef GWEN_CRYPT_TOKEN_KEYINFO* (GWEN_CRYPT_TOKEN_KEYINFO_LIST2_FOREACH)(GWEN_CRYPT_TOKEN_KEYINFO *element,
04321                                                  void *user_data);
04322 
04326   GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *GWEN_Crypt_Token_KeyInfo_List2_new(); 
04327 
04331   void GWEN_Crypt_Token_KeyInfo_List2_free(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l); 
04332 
04336   void GWEN_Crypt_Token_KeyInfo_List2_Dump(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l, FILE *f, unsigned int indent); 
04337 
04341   void GWEN_Crypt_Token_KeyInfo_List2_PushBack(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l, GWEN_CRYPT_TOKEN_KEYINFO *p); 
04342    
04347   void GWEN_Crypt_Token_KeyInfo_List2_PushFront(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l, GWEN_CRYPT_TOKEN_KEYINFO *p); 
04348 
04353   GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_List2_GetFront(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l); 
04354    
04359   GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_List2_GetBack(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l); 
04360 
04365   void GWEN_Crypt_Token_KeyInfo_List2_Erase(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l,
04366                                GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *it);
04367 
04373   unsigned int GWEN_Crypt_Token_KeyInfo_List2_GetSize(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l); 
04374 
04379   void GWEN_Crypt_Token_KeyInfo_List2_PopBack(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l); 
04380    
04385   void GWEN_Crypt_Token_KeyInfo_List2_PopFront(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l); 
04386 
04390   void GWEN_Crypt_Token_KeyInfo_List2_Clear(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l); 
04391 
04395   GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *GWEN_Crypt_Token_KeyInfo_List2_First(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l); 
04396    
04400   GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *GWEN_Crypt_Token_KeyInfo_List2_Last(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l); 
04401 
04405   GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *GWEN_Crypt_Token_KeyInfo_List2Iterator_new(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l);
04406 
04410   void GWEN_Crypt_Token_KeyInfo_List2Iterator_free(GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *li); 
04411 
04416   GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_List2Iterator_Previous(GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *li); 
04417    
04422   GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_List2Iterator_Next(GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *li); 
04423 
04428   GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_List2Iterator_Data(GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *li); 
04429 
04441   GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_List2_ForEach(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *list,
04442                                         GWEN_CRYPT_TOKEN_KEYINFO_LIST2_FOREACH func,
04443                                         void *user_data);
04444 
04445 
04446   typedef struct GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2; 
04447   typedef struct GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR; 
04448   typedef const GWEN_CRYPT_TOKEN_KEYINFO*
04449     (GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_FOREACH)(const GWEN_CRYPT_TOKEN_KEYINFO *element,
04450                                     void *user_data);
04451   
04452    
04453   GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *GWEN_Crypt_Token_KeyInfo_ConstList2_new(); 
04454    
04455   void GWEN_Crypt_Token_KeyInfo_ConstList2_free(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l); 
04456    
04457   void GWEN_Crypt_Token_KeyInfo_ConstList2_PushBack(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l, const GWEN_CRYPT_TOKEN_KEYINFO *p); 
04458    
04459   void GWEN_Crypt_Token_KeyInfo_ConstList2_PushFront(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l, const GWEN_CRYPT_TOKEN_KEYINFO *p); 
04460    
04461   const GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_ConstList2_GetFront(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l); 
04462    
04463   const GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_ConstList2_GetBack(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l); 
04464    
04465   unsigned int GWEN_Crypt_Token_KeyInfo_ConstList2_GetSize(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l); 
04466    
04467   void GWEN_Crypt_Token_KeyInfo_ConstList2_PopBack(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l); 
04468    
04469   void GWEN_Crypt_Token_KeyInfo_ConstList2_PopFront(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l); 
04470    
04471   void GWEN_Crypt_Token_KeyInfo_ConstList2_Clear(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l); 
04472    
04473   GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_KeyInfo_ConstList2_First(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l); 
04474    
04475   GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_KeyInfo_ConstList2_Last(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l); 
04476    
04477   GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_KeyInfo_ConstList2Iterator_new(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l); 
04478    
04479   void GWEN_Crypt_Token_KeyInfo_ConstList2Iterator_free(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *li); 
04480    
04481   const GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_ConstList2Iterator_Previous(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *li); 
04482    
04483   const GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_ConstList2Iterator_Next(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *li); 
04484    
04485   const GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_ConstList2Iterator_Data(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *li); 
04486    
04498   const GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_ConstList2_ForEach(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *list,
04499         GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_FOREACH func, void *user_data);
04500 
04501 
04502 #ifdef __cplusplus
04503 }
04504 #endif
04505 
04506 
04507 #endif /* GWEN_CRYPT_TOKEN_KEYINFO_LIST_H */
04508 
04509 
04510 
04511 /***************************************************************************
04512  $RCSfile$
04513  -------------------
04514  cvs         : $Id$
04515  begin       : Sat Jun 28 2003
04516  copyright   : (C) 2003 by Martin Preuss
04517  email       : martin@libchipcard.de
04518 
04519  ***************************************************************************
04520  *                                                                         *
04521  *   This library is free software; you can redistribute it and/or         *
04522  *   modify it under the terms of the GNU Lesser General Public            *
04523  *   License as published by the Free Software Foundation; either          *
04524  *   version 2.1 of the License, or (at your option) any later version.    *
04525  *                                                                         *
04526  *   This library is distributed in the hope that it will be useful,       *
04527  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
04528  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
04529  *   Lesser General Public License for more details.                       *
04530  *                                                                         *
04531  *   You should have received a copy of the GNU Lesser General Public      *
04532  *   License along with this library; if not, write to the Free Software   *
04533  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
04534  *   MA  02111-1307  USA                                                   *
04535  *                                                                         *
04536  ***************************************************************************/
04537 
04538 
04539 #ifndef GWEN_CRYPT_TOKEN_KEYINFO_LIST1_H
04540 #define GWEN_CRYPT_TOKEN_KEYINFO_LIST1_H
04541 
04542 #ifdef __cplusplus
04543 extern "C" {
04544 #endif
04545 
04547   typedef struct GWEN_CRYPT_TOKEN_KEYINFO_LIST_ELEMENT {
04548     uint32_t id;
04549     GWEN_CRYPT_TOKEN_KEYINFO *nextObject;
04550   } GWEN_CRYPT_TOKEN_KEYINFO_LIST__ELEMENT;
04551 
04558   typedef struct GWEN_CRYPT_TOKEN_KEYINFO_LIST GWEN_CRYPT_TOKEN_KEYINFO_LIST;
04560   struct GWEN_CRYPT_TOKEN_KEYINFO_LIST {
04561     GWEN_CRYPT_TOKEN_KEYINFO *first;
04562     uint32_t count;
04563     uint32_t id;
04564   } GWEN_CRYPT_TOKEN_KEYINFO_LIST;
04565 
04570   void GWEN_Crypt_Token_KeyInfo_List_AddList(GWEN_CRYPT_TOKEN_KEYINFO_LIST *dst, GWEN_CRYPT_TOKEN_KEYINFO_LIST *l);
04571 
04575   void GWEN_Crypt_Token_KeyInfo_List_Add(GWEN_CRYPT_TOKEN_KEYINFO *element, GWEN_CRYPT_TOKEN_KEYINFO_LIST *list);
04576 
04581   void GWEN_Crypt_Token_KeyInfo_List_Insert(GWEN_CRYPT_TOKEN_KEYINFO *element, GWEN_CRYPT_TOKEN_KEYINFO_LIST *list);
04582 
04589   void GWEN_Crypt_Token_KeyInfo_List_Del(GWEN_CRYPT_TOKEN_KEYINFO *element);
04590 
04594   GWEN_CRYPT_TOKEN_KEYINFO* GWEN_Crypt_Token_KeyInfo_List_First(const GWEN_CRYPT_TOKEN_KEYINFO_LIST *l);
04595 
04599   GWEN_CRYPT_TOKEN_KEYINFO* GWEN_Crypt_Token_KeyInfo_List_Last(const GWEN_CRYPT_TOKEN_KEYINFO_LIST *l);
04600 
04605   void GWEN_Crypt_Token_KeyInfo_List_Clear(GWEN_CRYPT_TOKEN_KEYINFO_LIST *l);
04606 
04610   GWEN_CRYPT_TOKEN_KEYINFO_LIST* GWEN_Crypt_Token_KeyInfo_List_new();
04611 
04615   void GWEN_Crypt_Token_KeyInfo_List_free(GWEN_CRYPT_TOKEN_KEYINFO_LIST *l);
04616 
04620   GWEN_CRYPT_TOKEN_KEYINFO* GWEN_Crypt_Token_KeyInfo_List_Next(const GWEN_CRYPT_TOKEN_KEYINFO *element);
04621 
04625   GWEN_CRYPT_TOKEN_KEYINFO* GWEN_Crypt_Token_KeyInfo_List_Previous(const GWEN_CRYPT_TOKEN_KEYINFO *element);
04626 
04630   uint32_t GWEN_Crypt_Token_KeyInfo_List_GetCount(const GWEN_CRYPT_TOKEN_KEYINFO_LIST *l);
04631 
04632 #ifdef __cplusplus
04633 }
04634 #endif
04635 
04636 
04637 #endif
04638 
04639 
04640 
04641 /***************************************************************************
04642  $RCSfile$
04643  -------------------
04644  cvs         : $Id$
04645  begin       : Sat Jun 28 2003
04646  copyright   : (C) 2003 by Martin Preuss
04647  email       : martin@libchipcard.de
04648 
04649  ***************************************************************************
04650  *                                                                         *
04651  *   This library is free software; you can redistribute it and/or         *
04652  *   modify it under the terms of the GNU Lesser General Public            *
04653  *   License as published by the Free Software Foundation; either          *
04654  *   version 2.1 of the License, or (at your option) any later version.    *
04655  *                                                                         *
04656  *   This library is distributed in the hope that it will be useful,       *
04657  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
04658  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
04659  *   Lesser General Public License for more details.                       *
04660  *                                                                         *
04661  *   You should have received a copy of the GNU Lesser General Public      *
04662  *   License along with this library; if not, write to the Free Software   *
04663  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
04664  *   MA  02111-1307  USA                                                   *
04665  *                                                                         *
04666  ***************************************************************************/
04667 
04668 
04669 #ifndef GWEN_SOCKET_LIST2_H
04670 #define GWEN_SOCKET_LIST2_H
04671 
04672 
04673 #ifdef __cplusplus
04674 extern "C" {
04675 #endif
04676 
04683   typedef struct GWEN_SOCKET_LIST2 GWEN_SOCKET_LIST2;
04684 
04688   typedef struct GWEN_SOCKET_LIST2_ITERATOR GWEN_SOCKET_LIST2_ITERATOR;
04689 
04693   typedef GWEN_SOCKET* (GWEN_SOCKET_LIST2_FOREACH)(GWEN_SOCKET *element,
04694                                                  void *user_data);
04695 
04699   GWEN_SOCKET_LIST2 *GWEN_Socket_List2_new(); 
04700 
04704   void GWEN_Socket_List2_free(GWEN_SOCKET_LIST2 *l); 
04705 
04709   void GWEN_Socket_List2_Dump(GWEN_SOCKET_LIST2 *l, FILE *f, unsigned int indent); 
04710 
04714   void GWEN_Socket_List2_PushBack(GWEN_SOCKET_LIST2 *l, GWEN_SOCKET *p); 
04715    
04720   void GWEN_Socket_List2_PushFront(GWEN_SOCKET_LIST2 *l, GWEN_SOCKET *p); 
04721 
04726   GWEN_SOCKET *GWEN_Socket_List2_GetFront(GWEN_SOCKET_LIST2 *l); 
04727    
04732   GWEN_SOCKET *GWEN_Socket_List2_GetBack(GWEN_SOCKET_LIST2 *l); 
04733 
04738   void GWEN_Socket_List2_Erase(GWEN_SOCKET_LIST2 *l,
04739                                GWEN_SOCKET_LIST2_ITERATOR *it);
04740 
04746   unsigned int GWEN_Socket_List2_GetSize(GWEN_SOCKET_LIST2 *l); 
04747 
04752   void GWEN_Socket_List2_PopBack(GWEN_SOCKET_LIST2 *l); 
04753    
04758   void GWEN_Socket_List2_PopFront(GWEN_SOCKET_LIST2 *l); 
04759 
04763   void GWEN_Socket_List2_Clear(GWEN_SOCKET_LIST2 *l); 
04764 
04768   GWEN_SOCKET_LIST2_ITERATOR *GWEN_Socket_List2_First(GWEN_SOCKET_LIST2 *l); 
04769    
04773   GWEN_SOCKET_LIST2_ITERATOR *GWEN_Socket_List2_Last(GWEN_SOCKET_LIST2 *l); 
04774 
04778   GWEN_SOCKET_LIST2_ITERATOR *GWEN_Socket_List2Iterator_new(GWEN_SOCKET_LIST2 *l);
04779 
04783   void GWEN_Socket_List2Iterator_free(GWEN_SOCKET_LIST2_ITERATOR *li); 
04784 
04789   GWEN_SOCKET *GWEN_Socket_List2Iterator_Previous(GWEN_SOCKET_LIST2_ITERATOR *li); 
04790    
04795   GWEN_SOCKET *GWEN_Socket_List2Iterator_Next(GWEN_SOCKET_LIST2_ITERATOR *li); 
04796 
04801   GWEN_SOCKET *GWEN_Socket_List2Iterator_Data(GWEN_SOCKET_LIST2_ITERATOR *li); 
04802 
04814   GWEN_SOCKET *GWEN_Socket_List2_ForEach(GWEN_SOCKET_LIST2 *list,
04815                                         GWEN_SOCKET_LIST2_FOREACH func,
04816                                         void *user_data);
04817 
04818 
04819   typedef struct GWEN_SOCKET_CONSTLIST2 GWEN_SOCKET_CONSTLIST2; 
04820   typedef struct GWEN_SOCKET_CONSTLIST2_ITERATOR GWEN_SOCKET_CONSTLIST2_ITERATOR; 
04821   typedef const GWEN_SOCKET*
04822     (GWEN_SOCKET_CONSTLIST2_FOREACH)(const GWEN_SOCKET *element,
04823                                     void *user_data);
04824   
04825    
04826   GWEN_SOCKET_CONSTLIST2 *GWEN_Socket_ConstList2_new(); 
04827    
04828   void GWEN_Socket_ConstList2_free(GWEN_SOCKET_CONSTLIST2 *l); 
04829    
04830   void GWEN_Socket_ConstList2_PushBack(GWEN_SOCKET_CONSTLIST2 *l, const GWEN_SOCKET *p); 
04831    
04832   void GWEN_Socket_ConstList2_PushFront(GWEN_SOCKET_CONSTLIST2 *l, const GWEN_SOCKET *p); 
04833    
04834   const GWEN_SOCKET *GWEN_Socket_ConstList2_GetFront(GWEN_SOCKET_CONSTLIST2 *l); 
04835    
04836   const GWEN_SOCKET *GWEN_Socket_ConstList2_GetBack(GWEN_SOCKET_CONSTLIST2 *l); 
04837    
04838   unsigned int GWEN_Socket_ConstList2_GetSize(GWEN_SOCKET_CONSTLIST2 *l); 
04839    
04840   void GWEN_Socket_ConstList2_PopBack(GWEN_SOCKET_CONSTLIST2 *l); 
04841    
04842   void GWEN_Socket_ConstList2_PopFront(GWEN_SOCKET_CONSTLIST2 *l); 
04843    
04844   void GWEN_Socket_ConstList2_Clear(GWEN_SOCKET_CONSTLIST2 *l); 
04845    
04846   GWEN_SOCKET_CONSTLIST2_ITERATOR *GWEN_Socket_ConstList2_First(GWEN_SOCKET_CONSTLIST2 *l); 
04847    
04848   GWEN_SOCKET_CONSTLIST2_ITERATOR *GWEN_Socket_ConstList2_Last(GWEN_SOCKET_CONSTLIST2 *l); 
04849    
04850   GWEN_SOCKET_CONSTLIST2_ITERATOR *GWEN_Socket_ConstList2Iterator_new(GWEN_SOCKET_CONSTLIST2 *l); 
04851    
04852   void GWEN_Socket_ConstList2Iterator_free(GWEN_SOCKET_CONSTLIST2_ITERATOR *li); 
04853    
04854   const GWEN_SOCKET *GWEN_Socket_ConstList2Iterator_Previous(GWEN_SOCKET_CONSTLIST2_ITERATOR *li); 
04855    
04856   const GWEN_SOCKET *GWEN_Socket_ConstList2Iterator_Next(GWEN_SOCKET_CONSTLIST2_ITERATOR *li); 
04857    
04858   const GWEN_SOCKET *GWEN_Socket_ConstList2Iterator_Data(GWEN_SOCKET_CONSTLIST2_ITERATOR *li); 
04859    
04871   const GWEN_SOCKET *GWEN_Socket_ConstList2_ForEach(GWEN_SOCKET_CONSTLIST2 *list,
04872         GWEN_SOCKET_CONSTLIST2_FOREACH func, void *user_data);
04873 
04874 
04875 #ifdef __cplusplus
04876 }
04877 #endif
04878 
04879 
04880 #endif /* GWEN_SOCKET_LIST_H */
04881 
04882 
04883 
04884 /***************************************************************************
04885  $RCSfile$
04886  -------------------
04887  cvs         : $Id$
04888  begin       : Sat Jun 28 2003
04889  copyright   : (C) 2003 by Martin Preuss
04890  email       : martin@libchipcard.de
04891 
04892  ***************************************************************************
04893  *                                                                         *
04894  *   This library is free software; you can redistribute it and/or         *
04895  *   modify it under the terms of the GNU Lesser General Public            *
04896  *   License as published by the Free Software Foundation; either          *
04897  *   version 2.1 of the License, or (at your option) any later version.    *
04898  *                                                                         *
04899  *   This library is distributed in the hope that it will be useful,       *
04900  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
04901  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
04902  *   Lesser General Public License for more details.                       *
04903  *                                                                         *
04904  *   You should have received a copy of the GNU Lesser General Public      *
04905  *   License along with this library; if not, write to the Free Software   *
04906  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
04907  *   MA  02111-1307  USA                                                   *
04908  *                                                                         *
04909  ***************************************************************************/
04910 
04911 
04912 #ifndef GWEN_SOCKET_LIST1_H
04913 #define GWEN_SOCKET_LIST1_H
04914 
04915 #ifdef __cplusplus
04916 extern "C" {
04917 #endif
04918 
04920   typedef struct GWEN_SOCKET_LIST_ELEMENT {
04921     uint32_t id;
04922     GWEN_SOCKET *nextObject;
04923   } GWEN_SOCKET_LIST__ELEMENT;
04924 
04931   typedef struct GWEN_SOCKET_LIST GWEN_SOCKET_LIST;
04933   struct GWEN_SOCKET_LIST {
04934     GWEN_SOCKET *first;
04935     uint32_t count;
04936     uint32_t id;
04937   } GWEN_SOCKET_LIST;
04938 
04943   void GWEN_Socket_List_AddList(GWEN_SOCKET_LIST *dst, GWEN_SOCKET_LIST *l);
04944 
04948   void GWEN_Socket_List_Add(GWEN_SOCKET *element, GWEN_SOCKET_LIST *list);
04949 
04954   void GWEN_Socket_List_Insert(GWEN_SOCKET *element, GWEN_SOCKET_LIST *list);
04955 
04962   void GWEN_Socket_List_Del(GWEN_SOCKET *element);
04963 
04967   GWEN_SOCKET* GWEN_Socket_List_First(const GWEN_SOCKET_LIST *l);
04968 
04972   GWEN_SOCKET* GWEN_Socket_List_Last(const GWEN_SOCKET_LIST *l);
04973 
04978   void GWEN_Socket_List_Clear(GWEN_SOCKET_LIST *l);
04979 
04983   GWEN_SOCKET_LIST* GWEN_Socket_List_new();
04984 
04988   void GWEN_Socket_List_free(GWEN_SOCKET_LIST *l);
04989 
04993   GWEN_SOCKET* GWEN_Socket_List_Next(const GWEN_SOCKET *element);
04994 
04998   GWEN_SOCKET* GWEN_Socket_List_Previous(const GWEN_SOCKET *element);
04999 
05003   uint32_t GWEN_Socket_List_GetCount(const GWEN_SOCKET_LIST *l);
05004 
05005 #ifdef __cplusplus
05006 }
05007 #endif
05008 
05009 
05010 #endif
05011 
05012 
05013 
05014 /***************************************************************************
05015  $RCSfile$
05016  -------------------
05017  cvs         : $Id$
05018  begin       : Sat Jun 28 2003
05019  copyright   : (C) 2003 by Martin Preuss
05020  email       : martin@libchipcard.de
05021 
05022  ***************************************************************************
05023  *                                                                         *
05024  *   This library is free software; you can redistribute it and/or         *
05025  *   modify it under the terms of the GNU Lesser General Public            *
05026  *   License as published by the Free Software Foundation; either          *
05027  *   version 2.1 of the License, or (at your option) any later version.    *
05028  *                                                                         *
05029  *   This library is distributed in the hope that it will be useful,       *
05030  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
05031  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
05032  *   Lesser General Public License for more details.                       *
05033  *                                                                         *
05034  *   You should have received a copy of the GNU Lesser General Public      *
05035  *   License along with this library; if not, write to the Free Software   *
05036  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
05037  *   MA  02111-1307  USA                                                   *
05038  *                                                                         *
05039  ***************************************************************************/
05040 
05041 
05042 #ifndef GWEN_IO_LAYER_LIST2_H
05043 #define GWEN_IO_LAYER_LIST2_H
05044 
05045 
05046 #ifdef __cplusplus
05047 extern "C" {
05048 #endif
05049 
05056   typedef struct GWEN_IO_LAYER_LIST2 GWEN_IO_LAYER_LIST2;
05057 
05061   typedef struct GWEN_IO_LAYER_LIST2_ITERATOR GWEN_IO_LAYER_LIST2_ITERATOR;
05062 
05066   typedef GWEN_IO_LAYER* (GWEN_IO_LAYER_LIST2_FOREACH)(GWEN_IO_LAYER *element,
05067                                                  void *user_data);
05068 
05072   GWEN_IO_LAYER_LIST2 *GWEN_Io_Layer_List2_new(); 
05073 
05077   void GWEN_Io_Layer_List2_free(GWEN_IO_LAYER_LIST2 *l); 
05078 
05082   void GWEN_Io_Layer_List2_Dump(GWEN_IO_LAYER_LIST2 *l, FILE *f, unsigned int indent); 
05083 
05087   void GWEN_Io_Layer_List2_PushBack(GWEN_IO_LAYER_LIST2 *l, GWEN_IO_LAYER *p); 
05088    
05093   void GWEN_Io_Layer_List2_PushFront(GWEN_IO_LAYER_LIST2 *l, GWEN_IO_LAYER *p); 
05094 
05099   GWEN_IO_LAYER *GWEN_Io_Layer_List2_GetFront(GWEN_IO_LAYER_LIST2 *l); 
05100    
05105   GWEN_IO_LAYER *GWEN_Io_Layer_List2_GetBack(GWEN_IO_LAYER_LIST2 *l); 
05106 
05111   void GWEN_Io_Layer_List2_Erase(GWEN_IO_LAYER_LIST2 *l,
05112                                GWEN_IO_LAYER_LIST2_ITERATOR *it);
05113 
05119   unsigned int GWEN_Io_Layer_List2_GetSize(GWEN_IO_LAYER_LIST2 *l); 
05120 
05125   void GWEN_Io_Layer_List2_PopBack(GWEN_IO_LAYER_LIST2 *l); 
05126    
05131   void GWEN_Io_Layer_List2_PopFront(GWEN_IO_LAYER_LIST2 *l); 
05132 
05136   void GWEN_Io_Layer_List2_Clear(GWEN_IO_LAYER_LIST2 *l); 
05137 
05141   GWEN_IO_LAYER_LIST2_ITERATOR *GWEN_Io_Layer_List2_First(GWEN_IO_LAYER_LIST2 *l); 
05142    
05146   GWEN_IO_LAYER_LIST2_ITERATOR *GWEN_Io_Layer_List2_Last(GWEN_IO_LAYER_LIST2 *l); 
05147 
05151   GWEN_IO_LAYER_LIST2_ITERATOR *GWEN_Io_Layer_List2Iterator_new(GWEN_IO_LAYER_LIST2 *l);
05152 
05156   void GWEN_Io_Layer_List2Iterator_free(GWEN_IO_LAYER_LIST2_ITERATOR *li); 
05157 
05162   GWEN_IO_LAYER *GWEN_Io_Layer_List2Iterator_Previous(GWEN_IO_LAYER_LIST2_ITERATOR *li); 
05163    
05168   GWEN_IO_LAYER *GWEN_Io_Layer_List2Iterator_Next(GWEN_IO_LAYER_LIST2_ITERATOR *li); 
05169 
05174   GWEN_IO_LAYER *GWEN_Io_Layer_List2Iterator_Data(GWEN_IO_LAYER_LIST2_ITERATOR *li); 
05175 
05187   GWEN_IO_LAYER *GWEN_Io_Layer_List2_ForEach(GWEN_IO_LAYER_LIST2 *list,
05188                                         GWEN_IO_LAYER_LIST2_FOREACH func,
05189                                         void *user_data);
05190 
05191 
05192   typedef struct GWEN_IO_LAYER_CONSTLIST2 GWEN_IO_LAYER_CONSTLIST2; 
05193   typedef struct GWEN_IO_LAYER_CONSTLIST2_ITERATOR GWEN_IO_LAYER_CONSTLIST2_ITERATOR; 
05194   typedef const GWEN_IO_LAYER*
05195     (GWEN_IO_LAYER_CONSTLIST2_FOREACH)(const GWEN_IO_LAYER *element,
05196                                     void *user_data);
05197   
05198    
05199   GWEN_IO_LAYER_CONSTLIST2 *GWEN_Io_Layer_ConstList2_new(); 
05200    
05201   void GWEN_Io_Layer_ConstList2_free(GWEN_IO_LAYER_CONSTLIST2 *l); 
05202    
05203   void GWEN_Io_Layer_ConstList2_PushBack(GWEN_IO_LAYER_CONSTLIST2 *l, const GWEN_IO_LAYER *p); 
05204    
05205   void GWEN_Io_Layer_ConstList2_PushFront(GWEN_IO_LAYER_CONSTLIST2 *l, const GWEN_IO_LAYER *p); 
05206    
05207   const GWEN_IO_LAYER *GWEN_Io_Layer_ConstList2_GetFront(GWEN_IO_LAYER_CONSTLIST2 *l); 
05208    
05209   const GWEN_IO_LAYER *GWEN_Io_Layer_ConstList2_GetBack(GWEN_IO_LAYER_CONSTLIST2 *l); 
05210    
05211   unsigned int GWEN_Io_Layer_ConstList2_GetSize(GWEN_IO_LAYER_CONSTLIST2 *l); 
05212    
05213   void GWEN_Io_Layer_ConstList2_PopBack(GWEN_IO_LAYER_CONSTLIST2 *l); 
05214    
05215   void GWEN_Io_Layer_ConstList2_PopFront(GWEN_IO_LAYER_CONSTLIST2 *l); 
05216    
05217   void GWEN_Io_Layer_ConstList2_Clear(GWEN_IO_LAYER_CONSTLIST2 *l); 
05218    
05219   GWEN_IO_LAYER_CONSTLIST2_ITERATOR *GWEN_Io_Layer_ConstList2_First(GWEN_IO_LAYER_CONSTLIST2 *l); 
05220    
05221   GWEN_IO_LAYER_CONSTLIST2_ITERATOR *GWEN_Io_Layer_ConstList2_Last(GWEN_IO_LAYER_CONSTLIST2 *l); 
05222    
05223   GWEN_IO_LAYER_CONSTLIST2_ITERATOR *GWEN_Io_Layer_ConstList2Iterator_new(GWEN_IO_LAYER_CONSTLIST2 *l); 
05224    
05225   void GWEN_Io_Layer_ConstList2Iterator_free(GWEN_IO_LAYER_CONSTLIST2_ITERATOR *li); 
05226    
05227   const GWEN_IO_LAYER *GWEN_Io_Layer_ConstList2Iterator_Previous(GWEN_IO_LAYER_CONSTLIST2_ITERATOR *li); 
05228    
05229   const GWEN_IO_LAYER *GWEN_Io_Layer_ConstList2Iterator_Next(GWEN_IO_LAYER_CONSTLIST2_ITERATOR *li); 
05230    
05231   const GWEN_IO_LAYER *GWEN_Io_Layer_ConstList2Iterator_Data(GWEN_IO_LAYER_CONSTLIST2_ITERATOR *li); 
05232    
05244   const GWEN_IO_LAYER *GWEN_Io_Layer_ConstList2_ForEach(GWEN_IO_LAYER_CONSTLIST2 *list,
05245         GWEN_IO_LAYER_CONSTLIST2_FOREACH func, void *user_data);
05246 
05247 
05248 #ifdef __cplusplus
05249 }
05250 #endif
05251 
05252 
05253 #endif /* GWEN_IO_LAYER_LIST_H */
05254 
05255 
05256 
05257 /***************************************************************************
05258  $RCSfile$
05259  -------------------
05260  cvs         : $Id$
05261  begin       : Sat Jun 28 2003
05262  copyright   : (C) 2003 by Martin Preuss
05263  email       : martin@libchipcard.de
05264 
05265  ***************************************************************************
05266  *                                                                         *
05267  *   This library is free software; you can redistribute it and/or         *
05268  *   modify it under the terms of the GNU Lesser General Public            *
05269  *   License as published by the Free Software Foundation; either          *
05270  *   version 2.1 of the License, or (at your option) any later version.    *
05271  *                                                                         *
05272  *   This library is distributed in the hope that it will be useful,       *
05273  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
05274  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
05275  *   Lesser General Public License for more details.                       *
05276  *                                                                         *
05277  *   You should have received a copy of the GNU Lesser General Public      *
05278  *   License along with this library; if not, write to the Free Software   *
05279  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
05280  *   MA  02111-1307  USA                                                   *
05281  *                                                                         *
05282  ***************************************************************************/
05283 
05284 
05285 #ifndef GWEN_DBIO_LIST1_H
05286 #define GWEN_DBIO_LIST1_H
05287 
05288 #ifdef __cplusplus
05289 extern "C" {
05290 #endif
05291 
05293   typedef struct GWEN_DBIO_LIST_ELEMENT {
05294     uint32_t id;
05295     GWEN_DBIO *nextObject;
05296   } GWEN_DBIO_LIST__ELEMENT;
05297 
05304   typedef struct GWEN_DBIO_LIST GWEN_DBIO_LIST;
05306   struct GWEN_DBIO_LIST {
05307     GWEN_DBIO *first;
05308     uint32_t count;
05309     uint32_t id;
05310   } GWEN_DBIO_LIST;
05311 
05316   void GWEN_DBIO_List_AddList(GWEN_DBIO_LIST *dst, GWEN_DBIO_LIST *l);
05317 
05321   void GWEN_DBIO_List_Add(GWEN_DBIO *element, GWEN_DBIO_LIST *list);
05322 
05327   void GWEN_DBIO_List_Insert(GWEN_DBIO *element, GWEN_DBIO_LIST *list);
05328 
05335   void GWEN_DBIO_List_Del(GWEN_DBIO *element);
05336 
05340   GWEN_DBIO* GWEN_DBIO_List_First(const GWEN_DBIO_LIST *l);
05341 
05345   GWEN_DBIO* GWEN_DBIO_List_Last(const GWEN_DBIO_LIST *l);
05346 
05351   void GWEN_DBIO_List_Clear(GWEN_DBIO_LIST *l);
05352 
05356   GWEN_DBIO_LIST* GWEN_DBIO_List_new();
05357 
05361   void GWEN_DBIO_List_free(GWEN_DBIO_LIST *l);
05362 
05366   GWEN_DBIO* GWEN_DBIO_List_Next(const GWEN_DBIO *element);
05367 
05371   GWEN_DBIO* GWEN_DBIO_List_Previous(const GWEN_DBIO *element);
05372 
05376   uint32_t GWEN_DBIO_List_GetCount(const GWEN_DBIO_LIST *l);
05377 
05378 #ifdef __cplusplus
05379 }
05380 #endif
05381 
05382 
05383 #endif
05384 
05385 
05386 
05387 /***************************************************************************
05388  $RCSfile$
05389  -------------------
05390  cvs         : $Id$
05391  begin       : Sat Jun 28 2003
05392  copyright   : (C) 2003 by Martin Preuss
05393  email       : martin@libchipcard.de
05394 
05395  ***************************************************************************
05396  *                                                                         *
05397  *   This library is free software; you can redistribute it and/or         *
05398  *   modify it under the terms of the GNU Lesser General Public            *
05399  *   License as published by the Free Software Foundation; either          *
05400  *   version 2.1 of the License, or (at your option) any later version.    *
05401  *                                                                         *
05402  *   This library is distributed in the hope that it will be useful,       *
05403  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
05404  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
05405  *   Lesser General Public License for more details.                       *
05406  *                                                                         *
05407  *   You should have received a copy of the GNU Lesser General Public      *
05408  *   License along with this library; if not, write to the Free Software   *
05409  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
05410  *   MA  02111-1307  USA                                                   *
05411  *                                                                         *
05412  ***************************************************************************/
05413 
05414 
05415 #ifndef t_LIST2_H
05416 #define t_LIST2_H
05417 
05418 
05419 #ifdef __cplusplus
05420 extern "C" {
05421 #endif
05422 
05429   typedef struct t_LIST2 t_LIST2;
05430 
05434   typedef struct t_LIST2_ITERATOR t_LIST2_ITERATOR;
05435 
05439   typedef t* (t_LIST2_FOREACH)(t *element,
05440                                                  void *user_data);
05441 
05445   t_LIST2 *pr_List2_new(); 
05446 
05450   void pr_List2_free(t_LIST2 *l); 
05451 
05455   void pr_List2_Dump(t_LIST2 *l, FILE *f, unsigned int indent); 
05456 
05460   void pr_List2_PushBack(t_LIST2 *l, t *p); 
05461    
05466   void pr_List2_PushFront(t_LIST2 *l, t *p); 
05467 
05472   t *pr_List2_GetFront(t_LIST2 *l); 
05473    
05478   t *pr_List2_GetBack(t_LIST2 *l); 
05479 
05484   void pr_List2_Erase(t_LIST2 *l,
05485                                t_LIST2_ITERATOR *it);
05486 
05492   unsigned int pr_List2_GetSize(t_LIST2 *l); 
05493 
05498   void pr_List2_PopBack(t_LIST2 *l); 
05499    
05504   void pr_List2_PopFront(t_LIST2 *l); 
05505 
05509   void pr_List2_Clear(t_LIST2 *l); 
05510 
05514   t_LIST2_ITERATOR *pr_List2_First(t_LIST2 *l); 
05515    
05519   t_LIST2_ITERATOR *pr_List2_Last(t_LIST2 *l); 
05520 
05524   t_LIST2_ITERATOR *pr_List2Iterator_new(t_LIST2 *l);
05525 
05529   void pr_List2Iterator_free(t_LIST2_ITERATOR *li); 
05530 
05535   t *pr_List2Iterator_Previous(t_LIST2_ITERATOR *li); 
05536    
05541   t *pr_List2Iterator_Next(t_LIST2_ITERATOR *li); 
05542 
05547   t *pr_List2Iterator_Data(t_LIST2_ITERATOR *li); 
05548 
05560   t *pr_List2_ForEach(t_LIST2 *list,
05561                                         t_LIST2_FOREACH func,
05562                                         void *user_data);
05563 
05564 
05565   typedef struct t_CONSTLIST2 t_CONSTLIST2; 
05566   typedef struct t_CONSTLIST2_ITERATOR t_CONSTLIST2_ITERATOR; 
05567   typedef const t*
05568     (t_CONSTLIST2_FOREACH)(const t *element,
05569                                     void *user_data);
05570   
05571    
05572   t_CONSTLIST2 *pr_ConstList2_new(); 
05573    
05574   void pr_ConstList2_free(t_CONSTLIST2 *l); 
05575    
05576   void pr_ConstList2_PushBack(t_CONSTLIST2 *l, const t *p); 
05577    
05578   void pr_ConstList2_PushFront(t_CONSTLIST2 *l, const t *p); 
05579    
05580   const t *pr_ConstList2_GetFront(t_CONSTLIST2 *l); 
05581    
05582   const t *pr_ConstList2_GetBack(t_CONSTLIST2 *l); 
05583    
05584   unsigned int pr_ConstList2_GetSize(t_CONSTLIST2 *l); 
05585    
05586   void pr_ConstList2_PopBack(t_CONSTLIST2 *l); 
05587    
05588   void pr_ConstList2_PopFront(t_CONSTLIST2 *l); 
05589    
05590   void pr_ConstList2_Clear(t_CONSTLIST2 *l); 
05591    
05592   t_CONSTLIST2_ITERATOR *pr_ConstList2_First(t_CONSTLIST2 *l); 
05593    
05594   t_CONSTLIST2_ITERATOR *pr_ConstList2_Last(t_CONSTLIST2 *l); 
05595    
05596   t_CONSTLIST2_ITERATOR *pr_ConstList2Iterator_new(t_CONSTLIST2 *l); 
05597    
05598   void pr_ConstList2Iterator_free(t_CONSTLIST2_ITERATOR *li); 
05599    
05600   const t *pr_ConstList2Iterator_Previous(t_CONSTLIST2_ITERATOR *li); 
05601    
05602   const t *pr_ConstList2Iterator_Next(t_CONSTLIST2_ITERATOR *li); 
05603    
05604   const t *pr_ConstList2Iterator_Data(t_CONSTLIST2_ITERATOR *li); 
05605    
05617   const t *pr_ConstList2_ForEach(t_CONSTLIST2 *list,
05618         t_CONSTLIST2_FOREACH func, void *user_data);
05619 
05620 
05621 #ifdef __cplusplus
05622 }
05623 #endif
05624 
05625 
05626 #endif /* t_LIST_H */
05627 
05628 
05629 
05630 /***************************************************************************
05631  $RCSfile$
05632  -------------------
05633  cvs         : $Id$
05634  begin       : Sat Jun 28 2003
05635  copyright   : (C) 2003 by Martin Preuss
05636  email       : martin@libchipcard.de
05637 
05638  ***************************************************************************
05639  *                                                                         *
05640  *   This library is free software; you can redistribute it and/or         *
05641  *   modify it under the terms of the GNU Lesser General Public            *
05642  *   License as published by the Free Software Foundation; either          *
05643  *   version 2.1 of the License, or (at your option) any later version.    *
05644  *                                                                         *
05645  *   This library is distributed in the hope that it will be useful,       *
05646  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
05647  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
05648  *   Lesser General Public License for more details.                       *
05649  *                                                                         *
05650  *   You should have received a copy of the GNU Lesser General Public      *
05651  *   License along with this library; if not, write to the Free Software   *
05652  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
05653  *   MA  02111-1307  USA                                                   *
05654  *                                                                         *
05655  ***************************************************************************/
05656 
05657 
05658 #ifndef t_LIST2_H
05659 #define t_LIST2_H
05660 
05661 
05662 #ifdef __cplusplus
05663 extern "C" {
05664 #endif
05665 
05672   typedef struct t_LIST2 t_LIST2;
05673 
05677   typedef struct t_LIST2_ITERATOR t_LIST2_ITERATOR;
05678 
05682   typedef t* (t_LIST2_FOREACH)(t *element,
05683                                                  void *user_data);
05684 
05688   t_LIST2 *pr_List2_new(); 
05689 
05693   void pr_List2_free(t_LIST2 *l); 
05694 
05698   void pr_List2_Dump(t_LIST2 *l, FILE *f, unsigned int indent); 
05699 
05703   void pr_List2_PushBack(t_LIST2 *l, t *p); 
05704    
05709   void pr_List2_PushFront(t_LIST2 *l, t *p); 
05710 
05715   t *pr_List2_GetFront(t_LIST2 *l); 
05716    
05721   t *pr_List2_GetBack(t_LIST2 *l); 
05722 
05727   void pr_List2_Erase(t_LIST2 *l,
05728                                t_LIST2_ITERATOR *it);
05729 
05735   unsigned int pr_List2_GetSize(t_LIST2 *l); 
05736 
05741   void pr_List2_PopBack(t_LIST2 *l); 
05742    
05747   void pr_List2_PopFront(t_LIST2 *l); 
05748 
05752   void pr_List2_Clear(t_LIST2 *l); 
05753 
05757   t_LIST2_ITERATOR *pr_List2_First(t_LIST2 *l); 
05758    
05762   t_LIST2_ITERATOR *pr_List2_Last(t_LIST2 *l); 
05763 
05767   t_LIST2_ITERATOR *pr_List2Iterator_new(t_LIST2 *l);
05768 
05772   void pr_List2Iterator_free(t_LIST2_ITERATOR *li); 
05773 
05778   t *pr_List2Iterator_Previous(t_LIST2_ITERATOR *li); 
05779    
05784   t *pr_List2Iterator_Next(t_LIST2_ITERATOR *li); 
05785 
05790   t *pr_List2Iterator_Data(t_LIST2_ITERATOR *li); 
05791 
05803   t *pr_List2_ForEach(t_LIST2 *list,
05804                                         t_LIST2_FOREACH func,
05805                                         void *user_data);
05806 
05807 
05808   typedef struct t_CONSTLIST2 t_CONSTLIST2; 
05809   typedef struct t_CONSTLIST2_ITERATOR t_CONSTLIST2_ITERATOR; 
05810   typedef const t*
05811     (t_CONSTLIST2_FOREACH)(const t *element,
05812                                     void *user_data);
05813   
05814    
05815   t_CONSTLIST2 *pr_ConstList2_new(); 
05816    
05817   void pr_ConstList2_free(t_CONSTLIST2 *l); 
05818    
05819   void pr_ConstList2_PushBack(t_CONSTLIST2 *l, const t *p); 
05820    
05821   void pr_ConstList2_PushFront(t_CONSTLIST2 *l, const t *p); 
05822    
05823   const t *pr_ConstList2_GetFront(t_CONSTLIST2 *l); 
05824    
05825   const t *pr_ConstList2_GetBack(t_CONSTLIST2 *l); 
05826    
05827   unsigned int pr_ConstList2_GetSize(t_CONSTLIST2 *l); 
05828    
05829   void pr_ConstList2_PopBack(t_CONSTLIST2 *l); 
05830    
05831   void pr_ConstList2_PopFront(t_CONSTLIST2 *l); 
05832    
05833   void pr_ConstList2_Clear(t_CONSTLIST2 *l); 
05834    
05835   t_CONSTLIST2_ITERATOR *pr_ConstList2_First(t_CONSTLIST2 *l); 
05836    
05837   t_CONSTLIST2_ITERATOR *pr_ConstList2_Last(t_CONSTLIST2 *l); 
05838    
05839   t_CONSTLIST2_ITERATOR *pr_ConstList2Iterator_new(t_CONSTLIST2 *l); 
05840    
05841   void pr_ConstList2Iterator_free(t_CONSTLIST2_ITERATOR *li); 
05842    
05843   const t *pr_ConstList2Iterator_Previous(t_CONSTLIST2_ITERATOR *li); 
05844    
05845   const t *pr_ConstList2Iterator_Next(t_CONSTLIST2_ITERATOR *li); 
05846    
05847   const t *pr_ConstList2Iterator_Data(t_CONSTLIST2_ITERATOR *li); 
05848    
05860   const t *pr_ConstList2_ForEach(t_CONSTLIST2 *list,
05861         t_CONSTLIST2_FOREACH func, void *user_data);
05862 
05863 
05864 #ifdef __cplusplus
05865 }
05866 #endif
05867 
05868 
05869 #endif /* t_LIST_H */
05870 
05871 
05872 
05873 /***************************************************************************
05874  $RCSfile$
05875  -------------------
05876  cvs         : $Id$
05877  begin       : Sat Jun 28 2003
05878  copyright   : (C) 2003 by Martin Preuss
05879  email       : martin@libchipcard.de
05880 
05881  ***************************************************************************
05882  *                                                                         *
05883  *   This library is free software; you can redistribute it and/or         *
05884  *   modify it under the terms of the GNU Lesser General Public            *
05885  *   License as published by the Free Software Foundation; either          *
05886  *   version 2.1 of the License, or (at your option) any later version.    *
05887  *                                                                         *
05888  *   This library is distributed in the hope that it will be useful,       *
05889  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
05890  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
05891  *   Lesser General Public License for more details.                       *
05892  *                                                                         *
05893  *   You should have received a copy of the GNU Lesser General Public      *
05894  *   License along with this library; if not, write to the Free Software   *
05895  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
05896  *   MA  02111-1307  USA                                                   *
05897  *                                                                         *
05898  ***************************************************************************/
05899 
05900 
05901 #ifndef GWEN_CRYPT_CRYPTALGO_LIST2_H
05902 #define GWEN_CRYPT_CRYPTALGO_LIST2_H
05903 
05904 
05905 #ifdef __cplusplus
05906 extern "C" {
05907 #endif
05908 
05915   typedef struct GWEN_CRYPT_CRYPTALGO_LIST2 GWEN_CRYPT_CRYPTALGO_LIST2;
05916 
05920   typedef struct GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR;
05921 
05925   typedef GWEN_CRYPT_CRYPTALGO* (GWEN_CRYPT_CRYPTALGO_LIST2_FOREACH)(GWEN_CRYPT_CRYPTALGO *element,
05926                                                  void *user_data);
05927 
05931   GWEN_CRYPT_CRYPTALGO_LIST2 *GWEN_Crypt_CryptAlgo_List2_new(); 
05932 
05936   void GWEN_Crypt_CryptAlgo_List2_free(GWEN_CRYPT_CRYPTALGO_LIST2 *l); 
05937 
05941   void GWEN_Crypt_CryptAlgo_List2_Dump(GWEN_CRYPT_CRYPTALGO_LIST2 *l, FILE *f, unsigned int indent); 
05942 
05946   void GWEN_Crypt_CryptAlgo_List2_PushBack(GWEN_CRYPT_CRYPTALGO_LIST2 *l, GWEN_CRYPT_CRYPTALGO *p); 
05947    
05952   void GWEN_Crypt_CryptAlgo_List2_PushFront(GWEN_CRYPT_CRYPTALGO_LIST2 *l, GWEN_CRYPT_CRYPTALGO *p); 
05953 
05958   GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_List2_GetFront(GWEN_CRYPT_CRYPTALGO_LIST2 *l); 
05959    
05964   GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_List2_GetBack(GWEN_CRYPT_CRYPTALGO_LIST2 *l); 
05965 
05970   void GWEN_Crypt_CryptAlgo_List2_Erase(GWEN_CRYPT_CRYPTALGO_LIST2 *l,
05971                                GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *it);
05972 
05978   unsigned int GWEN_Crypt_CryptAlgo_List2_GetSize(GWEN_CRYPT_CRYPTALGO_LIST2 *l); 
05979 
05984   void GWEN_Crypt_CryptAlgo_List2_PopBack(GWEN_CRYPT_CRYPTALGO_LIST2 *l); 
05985    
05990   void GWEN_Crypt_CryptAlgo_List2_PopFront(GWEN_CRYPT_CRYPTALGO_LIST2 *l); 
05991 
05995   void GWEN_Crypt_CryptAlgo_List2_Clear(GWEN_CRYPT_CRYPTALGO_LIST2 *l); 
05996 
06000   GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *GWEN_Crypt_CryptAlgo_List2_First(GWEN_CRYPT_CRYPTALGO_LIST2 *l); 
06001    
06005   GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *GWEN_Crypt_CryptAlgo_List2_Last(GWEN_CRYPT_CRYPTALGO_LIST2 *l); 
06006 
06010   GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *GWEN_Crypt_CryptAlgo_List2Iterator_new(GWEN_CRYPT_CRYPTALGO_LIST2 *l);
06011 
06015   void GWEN_Crypt_CryptAlgo_List2Iterator_free(GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *li); 
06016 
06021   GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_List2Iterator_Previous(GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *li); 
06022    
06027   GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_List2Iterator_Next(GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *li); 
06028 
06033   GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_List2Iterator_Data(GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *li); 
06034 
06046   GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_List2_ForEach(GWEN_CRYPT_CRYPTALGO_LIST2 *list,
06047                                         GWEN_CRYPT_CRYPTALGO_LIST2_FOREACH func,
06048                                         void *user_data);
06049 
06050 
06051   typedef struct GWEN_CRYPT_CRYPTALGO_CONSTLIST2 GWEN_CRYPT_CRYPTALGO_CONSTLIST2; 
06052   typedef struct GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR; 
06053   typedef const GWEN_CRYPT_CRYPTALGO*
06054     (GWEN_CRYPT_CRYPTALGO_CONSTLIST2_FOREACH)(const GWEN_CRYPT_CRYPTALGO *element,
06055                                     void *user_data);
06056   
06057    
06058   GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *GWEN_Crypt_CryptAlgo_ConstList2_new(); 
06059    
06060   void GWEN_Crypt_CryptAlgo_ConstList2_free(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l); 
06061    
06062   void GWEN_Crypt_CryptAlgo_ConstList2_PushBack(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l, const GWEN_CRYPT_CRYPTALGO *p); 
06063    
06064   void GWEN_Crypt_CryptAlgo_ConstList2_PushFront(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l, const GWEN_CRYPT_CRYPTALGO *p); 
06065    
06066   const GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_ConstList2_GetFront(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l); 
06067    
06068   const GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_ConstList2_GetBack(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l); 
06069    
06070   unsigned int GWEN_Crypt_CryptAlgo_ConstList2_GetSize(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l); 
06071    
06072   void GWEN_Crypt_CryptAlgo_ConstList2_PopBack(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l); 
06073    
06074   void GWEN_Crypt_CryptAlgo_ConstList2_PopFront(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l); 
06075    
06076   void GWEN_Crypt_CryptAlgo_ConstList2_Clear(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l); 
06077    
06078   GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_CryptAlgo_ConstList2_First(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l); 
06079    
06080   GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_CryptAlgo_ConstList2_Last(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l); 
06081    
06082   GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_CryptAlgo_ConstList2Iterator_new(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l); 
06083    
06084   void GWEN_Crypt_CryptAlgo_ConstList2Iterator_free(GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR *li); 
06085    
06086   const GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_ConstList2Iterator_Previous(GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR *li); 
06087    
06088   const GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_ConstList2Iterator_Next(GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR *li); 
06089    
06090   const GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_ConstList2Iterator_Data(GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR *li); 
06091    
06103   const GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_ConstList2_ForEach(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *list,
06104         GWEN_CRYPT_CRYPTALGO_CONSTLIST2_FOREACH func, void *user_data);
06105 
06106 
06107 #ifdef __cplusplus
06108 }
06109 #endif
06110 
06111 
06112 #endif /* GWEN_CRYPT_CRYPTALGO_LIST_H */
06113 
06114 
06115 
06116 /***************************************************************************
06117  $RCSfile$
06118  -------------------
06119  cvs         : $Id$
06120  begin       : Sat Jun 28 2003
06121  copyright   : (C) 2003 by Martin Preuss
06122  email       : martin@libchipcard.de
06123 
06124  ***************************************************************************
06125  *                                                                         *
06126  *   This library is free software; you can redistribute it and/or         *
06127  *   modify it under the terms of the GNU Lesser General Public            *
06128  *   License as published by the Free Software Foundation; either          *
06129  *   version 2.1 of the License, or (at your option) any later version.    *
06130  *                                                                         *
06131  *   This library is distributed in the hope that it will be useful,       *
06132  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
06133  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
06134  *   Lesser General Public License for more details.                       *
06135  *                                                                         *
06136  *   You should have received a copy of the GNU Lesser General Public      *
06137  *   License along with this library; if not, write to the Free Software   *
06138  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
06139  *   MA  02111-1307  USA                                                   *
06140  *                                                                         *
06141  ***************************************************************************/
06142 
06143 
06144 #ifndef GWEN_IO_REQUEST_LIST2_H
06145 #define GWEN_IO_REQUEST_LIST2_H
06146 
06147 
06148 #ifdef __cplusplus
06149 extern "C" {
06150 #endif
06151 
06158   typedef struct GWEN_IO_REQUEST_LIST2 GWEN_IO_REQUEST_LIST2;
06159 
06163   typedef struct GWEN_IO_REQUEST_LIST2_ITERATOR GWEN_IO_REQUEST_LIST2_ITERATOR;
06164 
06168   typedef GWEN_IO_REQUEST* (GWEN_IO_REQUEST_LIST2_FOREACH)(GWEN_IO_REQUEST *element,
06169                                                  void *user_data);
06170 
06174   GWEN_IO_REQUEST_LIST2 *GWEN_Io_Request_List2_new(); 
06175 
06179   void GWEN_Io_Request_List2_free(GWEN_IO_REQUEST_LIST2 *l); 
06180 
06184   void GWEN_Io_Request_List2_Dump(GWEN_IO_REQUEST_LIST2 *l, FILE *f, unsigned int indent); 
06185 
06189   void GWEN_Io_Request_List2_PushBack(GWEN_IO_REQUEST_LIST2 *l, GWEN_IO_REQUEST *p); 
06190    
06195   void GWEN_Io_Request_List2_PushFront(GWEN_IO_REQUEST_LIST2 *l, GWEN_IO_REQUEST *p); 
06196 
06201   GWEN_IO_REQUEST *GWEN_Io_Request_List2_GetFront(GWEN_IO_REQUEST_LIST2 *l); 
06202    
06207   GWEN_IO_REQUEST *GWEN_Io_Request_List2_GetBack(GWEN_IO_REQUEST_LIST2 *l); 
06208 
06213   void GWEN_Io_Request_List2_Erase(GWEN_IO_REQUEST_LIST2 *l,
06214                                GWEN_IO_REQUEST_LIST2_ITERATOR *it);
06215 
06221   unsigned int GWEN_Io_Request_List2_GetSize(GWEN_IO_REQUEST_LIST2 *l); 
06222 
06227   void GWEN_Io_Request_List2_PopBack(GWEN_IO_REQUEST_LIST2 *l); 
06228    
06233   void GWEN_Io_Request_List2_PopFront(GWEN_IO_REQUEST_LIST2 *l); 
06234 
06238   void GWEN_Io_Request_List2_Clear(GWEN_IO_REQUEST_LIST2 *l); 
06239 
06243   GWEN_IO_REQUEST_LIST2_ITERATOR *GWEN_Io_Request_List2_First(GWEN_IO_REQUEST_LIST2 *l); 
06244    
06248   GWEN_IO_REQUEST_LIST2_ITERATOR *GWEN_Io_Request_List2_Last(GWEN_IO_REQUEST_LIST2 *l); 
06249 
06253   GWEN_IO_REQUEST_LIST2_ITERATOR *GWEN_Io_Request_List2Iterator_new(GWEN_IO_REQUEST_LIST2 *l);
06254 
06258   void GWEN_Io_Request_List2Iterator_free(GWEN_IO_REQUEST_LIST2_ITERATOR *li); 
06259 
06264   GWEN_IO_REQUEST *GWEN_Io_Request_List2Iterator_Previous(GWEN_IO_REQUEST_LIST2_ITERATOR *li); 
06265    
06270   GWEN_IO_REQUEST *GWEN_Io_Request_List2Iterator_Next(GWEN_IO_REQUEST_LIST2_ITERATOR *li); 
06271 
06276   GWEN_IO_REQUEST *GWEN_Io_Request_List2Iterator_Data(GWEN_IO_REQUEST_LIST2_ITERATOR *li); 
06277 
06289   GWEN_IO_REQUEST *GWEN_Io_Request_List2_ForEach(GWEN_IO_REQUEST_LIST2 *list,
06290                                         GWEN_IO_REQUEST_LIST2_FOREACH func,
06291                                         void *user_data);
06292 
06293 
06294   typedef struct GWEN_IO_REQUEST_CONSTLIST2 GWEN_IO_REQUEST_CONSTLIST2; 
06295   typedef struct GWEN_IO_REQUEST_CONSTLIST2_ITERATOR GWEN_IO_REQUEST_CONSTLIST2_ITERATOR; 
06296   typedef const GWEN_IO_REQUEST*
06297     (GWEN_IO_REQUEST_CONSTLIST2_FOREACH)(const GWEN_IO_REQUEST *element,
06298                                     void *user_data);
06299   
06300    
06301   GWEN_IO_REQUEST_CONSTLIST2 *GWEN_Io_Request_ConstList2_new(); 
06302    
06303   void GWEN_Io_Request_ConstList2_free(GWEN_IO_REQUEST_CONSTLIST2 *l); 
06304    
06305   void GWEN_Io_Request_ConstList2_PushBack(GWEN_IO_REQUEST_CONSTLIST2 *l, const GWEN_IO_REQUEST *p); 
06306    
06307   void GWEN_Io_Request_ConstList2_PushFront(GWEN_IO_REQUEST_CONSTLIST2 *l, const GWEN_IO_REQUEST *p); 
06308    
06309   const GWEN_IO_REQUEST *GWEN_Io_Request_ConstList2_GetFront(GWEN_IO_REQUEST_CONSTLIST2 *l); 
06310    
06311   const GWEN_IO_REQUEST *GWEN_Io_Request_ConstList2_GetBack(GWEN_IO_REQUEST_CONSTLIST2 *l); 
06312    
06313   unsigned int GWEN_Io_Request_ConstList2_GetSize(GWEN_IO_REQUEST_CONSTLIST2 *l); 
06314    
06315   void GWEN_Io_Request_ConstList2_PopBack(GWEN_IO_REQUEST_CONSTLIST2 *l); 
06316    
06317   void GWEN_Io_Request_ConstList2_PopFront(GWEN_IO_REQUEST_CONSTLIST2 *l); 
06318    
06319   void GWEN_Io_Request_ConstList2_Clear(GWEN_IO_REQUEST_CONSTLIST2 *l); 
06320    
06321   GWEN_IO_REQUEST_CONSTLIST2_ITERATOR *GWEN_Io_Request_ConstList2_First(GWEN_IO_REQUEST_CONSTLIST2 *l); 
06322    
06323   GWEN_IO_REQUEST_CONSTLIST2_ITERATOR *GWEN_Io_Request_ConstList2_Last(GWEN_IO_REQUEST_CONSTLIST2 *l); 
06324    
06325   GWEN_IO_REQUEST_CONSTLIST2_ITERATOR *GWEN_Io_Request_ConstList2Iterator_new(GWEN_IO_REQUEST_CONSTLIST2 *l); 
06326    
06327   void GWEN_Io_Request_ConstList2Iterator_free(GWEN_IO_REQUEST_CONSTLIST2_ITERATOR *li); 
06328    
06329   const GWEN_IO_REQUEST *GWEN_Io_Request_ConstList2Iterator_Previous(GWEN_IO_REQUEST_CONSTLIST2_ITERATOR *li); 
06330    
06331   const GWEN_IO_REQUEST *GWEN_Io_Request_ConstList2Iterator_Next(GWEN_IO_REQUEST_CONSTLIST2_ITERATOR *li); 
06332    
06333   const GWEN_IO_REQUEST *GWEN_Io_Request_ConstList2Iterator_Data(GWEN_IO_REQUEST_CONSTLIST2_ITERATOR *li); 
06334    
06346   const GWEN_IO_REQUEST *GWEN_Io_Request_ConstList2_ForEach(GWEN_IO_REQUEST_CONSTLIST2 *list,
06347         GWEN_IO_REQUEST_CONSTLIST2_FOREACH func, void *user_data);
06348 
06349 
06350 #ifdef __cplusplus
06351 }
06352 #endif
06353 
06354 
06355 #endif /* GWEN_IO_REQUEST_LIST_H */
06356 
06357 
06358 
06359 /***************************************************************************
06360  $RCSfile$
06361  -------------------
06362  cvs         : $Id$
06363  begin       : Sat Jun 28 2003
06364  copyright   : (C) 2003 by Martin Preuss
06365  email       : martin@libchipcard.de
06366 
06367  ***************************************************************************
06368  *                                                                         *
06369  *   This library is free software; you can redistribute it and/or         *
06370  *   modify it under the terms of the GNU Lesser General Public            *
06371  *   License as published by the Free Software Foundation; either          *
06372  *   version 2.1 of the License, or (at your option) any later version.    *
06373  *                                                                         *
06374  *   This library is distributed in the hope that it will be useful,       *
06375  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
06376  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
06377  *   Lesser General Public License for more details.                       *
06378  *                                                                         *
06379  *   You should have received a copy of the GNU Lesser General Public      *
06380  *   License along with this library; if not, write to the Free Software   *
06381  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
06382  *   MA  02111-1307  USA                                                   *
06383  *                                                                         *
06384  ***************************************************************************/
06385 
06386 
06387 #ifndef GWEN_XMLNODE_NAMESPACE_LIST1_H
06388 #define GWEN_XMLNODE_NAMESPACE_LIST1_H
06389 
06390 #ifdef __cplusplus
06391 extern "C" {
06392 #endif
06393 
06395   typedef struct GWEN_XMLNODE_NAMESPACE_LIST_ELEMENT {
06396     uint32_t id;
06397     GWEN_XMLNODE_NAMESPACE *nextObject;
06398   } GWEN_XMLNODE_NAMESPACE_LIST__ELEMENT;
06399 
06406   typedef struct GWEN_XMLNODE_NAMESPACE_LIST GWEN_XMLNODE_NAMESPACE_LIST;
06408   struct GWEN_XMLNODE_NAMESPACE_LIST {
06409     GWEN_XMLNODE_NAMESPACE *first;
06410     uint32_t count;
06411     uint32_t id;
06412   } GWEN_XMLNODE_NAMESPACE_LIST;
06413 
06418   void GWEN_XMLNode_NameSpace_List_AddList(GWEN_XMLNODE_NAMESPACE_LIST *dst, GWEN_XMLNODE_NAMESPACE_LIST *l);
06419 
06423   void GWEN_XMLNode_NameSpace_List_Add(GWEN_XMLNODE_NAMESPACE *element, GWEN_XMLNODE_NAMESPACE_LIST *list);
06424 
06429   void GWEN_XMLNode_NameSpace_List_Insert(GWEN_XMLNODE_NAMESPACE *element, GWEN_XMLNODE_NAMESPACE_LIST *list);
06430 
06437   void GWEN_XMLNode_NameSpace_List_Del(GWEN_XMLNODE_NAMESPACE *element);
06438 
06442   GWEN_XMLNODE_NAMESPACE* GWEN_XMLNode_NameSpace_List_First(const GWEN_XMLNODE_NAMESPACE_LIST *l);
06443 
06447   GWEN_XMLNODE_NAMESPACE* GWEN_XMLNode_NameSpace_List_Last(const GWEN_XMLNODE_NAMESPACE_LIST *l);
06448 
06453   void GWEN_XMLNode_NameSpace_List_Clear(GWEN_XMLNODE_NAMESPACE_LIST *l);
06454 
06458   GWEN_XMLNODE_NAMESPACE_LIST* GWEN_XMLNode_NameSpace_List_new();
06459 
06463   void GWEN_XMLNode_NameSpace_List_free(GWEN_XMLNODE_NAMESPACE_LIST *l);
06464 
06468   GWEN_XMLNODE_NAMESPACE* GWEN_XMLNode_NameSpace_List_Next(const GWEN_XMLNODE_NAMESPACE *element);
06469 
06473   GWEN_XMLNODE_NAMESPACE* GWEN_XMLNode_NameSpace_List_Previous(const GWEN_XMLNODE_NAMESPACE *element);
06474 
06478   uint32_t GWEN_XMLNode_NameSpace_List_GetCount(const GWEN_XMLNODE_NAMESPACE_LIST *l);
06479 
06480 #ifdef __cplusplus
06481 }
06482 #endif
06483 
06484 
06485 #endif
06486 
06487 
06488 
06489 /***************************************************************************
06490  $RCSfile$
06491  -------------------
06492  cvs         : $Id$
06493  begin       : Sat Jun 28 2003
06494  copyright   : (C) 2003 by Martin Preuss
06495  email       : martin@libchipcard.de
06496 
06497  ***************************************************************************
06498  *                                                                         *
06499  *   This library is free software; you can redistribute it and/or         *
06500  *   modify it under the terms of the GNU Lesser General Public            *
06501  *   License as published by the Free Software Foundation; either          *
06502  *   version 2.1 of the License, or (at your option) any later version.    *
06503  *                                                                         *
06504  *   This library is distributed in the hope that it will be useful,       *
06505  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
06506  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
06507  *   Lesser General Public License for more details.                       *
06508  *                                                                         *
06509  *   You should have received a copy of the GNU Lesser General Public      *
06510  *   License along with this library; if not, write to the Free Software   *
06511  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
06512  *   MA  02111-1307  USA                                                   *
06513  *                                                                         *
06514  ***************************************************************************/
06515 
06516 
06517 #ifndef GWEN_XMLNODE_LIST2_H
06518 #define GWEN_XMLNODE_LIST2_H
06519 
06520 
06521 #ifdef __cplusplus
06522 extern "C" {
06523 #endif
06524 
06531   typedef struct GWEN_XMLNODE_LIST2 GWEN_XMLNODE_LIST2;
06532 
06536   typedef struct GWEN_XMLNODE_LIST2_ITERATOR GWEN_XMLNODE_LIST2_ITERATOR;
06537 
06541   typedef GWEN_XMLNODE* (GWEN_XMLNODE_LIST2_FOREACH)(GWEN_XMLNODE *element,
06542                                                  void *user_data);
06543 
06547   GWEN_XMLNODE_LIST2 *GWEN_XMLNode_List2_new(); 
06548 
06552   void GWEN_XMLNode_List2_free(GWEN_XMLNODE_LIST2 *l); 
06553 
06557   void GWEN_XMLNode_List2_Dump(GWEN_XMLNODE_LIST2 *l, FILE *f, unsigned int indent); 
06558 
06562   void GWEN_XMLNode_List2_PushBack(GWEN_XMLNODE_LIST2 *l, GWEN_XMLNODE *p); 
06563    
06568   void GWEN_XMLNode_List2_PushFront(GWEN_XMLNODE_LIST2 *l, GWEN_XMLNODE *p); 
06569 
06574   GWEN_XMLNODE *GWEN_XMLNode_List2_GetFront(GWEN_XMLNODE_LIST2 *l); 
06575    
06580   GWEN_XMLNODE *GWEN_XMLNode_List2_GetBack(GWEN_XMLNODE_LIST2 *l); 
06581 
06586   void GWEN_XMLNode_List2_Erase(GWEN_XMLNODE_LIST2 *l,
06587                                GWEN_XMLNODE_LIST2_ITERATOR *it);
06588 
06594   unsigned int GWEN_XMLNode_List2_GetSize(GWEN_XMLNODE_LIST2 *l); 
06595 
06600   void GWEN_XMLNode_List2_PopBack(GWEN_XMLNODE_LIST2 *l); 
06601    
06606   void GWEN_XMLNode_List2_PopFront(GWEN_XMLNODE_LIST2 *l); 
06607 
06611   void GWEN_XMLNode_List2_Clear(GWEN_XMLNODE_LIST2 *l); 
06612 
06616   GWEN_XMLNODE_LIST2_ITERATOR *GWEN_XMLNode_List2_First(GWEN_XMLNODE_LIST2 *l); 
06617    
06621   GWEN_XMLNODE_LIST2_ITERATOR *GWEN_XMLNode_List2_Last(GWEN_XMLNODE_LIST2 *l); 
06622 
06626   GWEN_XMLNODE_LIST2_ITERATOR *GWEN_XMLNode_List2Iterator_new(GWEN_XMLNODE_LIST2 *l);
06627 
06631   void GWEN_XMLNode_List2Iterator_free(GWEN_XMLNODE_LIST2_ITERATOR *li); 
06632 
06637   GWEN_XMLNODE *GWEN_XMLNode_List2Iterator_Previous(GWEN_XMLNODE_LIST2_ITERATOR *li); 
06638    
06643   GWEN_XMLNODE *GWEN_XMLNode_List2Iterator_Next(GWEN_XMLNODE_LIST2_ITERATOR *li); 
06644 
06649   GWEN_XMLNODE *GWEN_XMLNode_List2Iterator_Data(GWEN_XMLNODE_LIST2_ITERATOR *li); 
06650 
06662   GWEN_XMLNODE *GWEN_XMLNode_List2_ForEach(GWEN_XMLNODE_LIST2 *list,
06663                                         GWEN_XMLNODE_LIST2_FOREACH func,
06664                                         void *user_data);
06665 
06666 
06667   typedef struct GWEN_XMLNODE_CONSTLIST2 GWEN_XMLNODE_CONSTLIST2; 
06668   typedef struct GWEN_XMLNODE_CONSTLIST2_ITERATOR GWEN_XMLNODE_CONSTLIST2_ITERATOR; 
06669   typedef const GWEN_XMLNODE*
06670     (GWEN_XMLNODE_CONSTLIST2_FOREACH)(const GWEN_XMLNODE *element,
06671                                     void *user_data);
06672   
06673    
06674   GWEN_XMLNODE_CONSTLIST2 *GWEN_XMLNode_ConstList2_new(); 
06675    
06676   void GWEN_XMLNode_ConstList2_free(GWEN_XMLNODE_CONSTLIST2 *l); 
06677    
06678   void GWEN_XMLNode_ConstList2_PushBack(GWEN_XMLNODE_CONSTLIST2 *l, const GWEN_XMLNODE *p); 
06679    
06680   void GWEN_XMLNode_ConstList2_PushFront(GWEN_XMLNODE_CONSTLIST2 *l, const GWEN_XMLNODE *p); 
06681    
06682   const GWEN_XMLNODE *GWEN_XMLNode_ConstList2_GetFront(GWEN_XMLNODE_CONSTLIST2 *l); 
06683    
06684   const GWEN_XMLNODE *GWEN_XMLNode_ConstList2_GetBack(GWEN_XMLNODE_CONSTLIST2 *l); 
06685    
06686   unsigned int GWEN_XMLNode_ConstList2_GetSize(GWEN_XMLNODE_CONSTLIST2 *l); 
06687    
06688   void GWEN_XMLNode_ConstList2_PopBack(GWEN_XMLNODE_CONSTLIST2 *l); 
06689    
06690   void GWEN_XMLNode_ConstList2_PopFront(GWEN_XMLNODE_CONSTLIST2 *l); 
06691    
06692   void GWEN_XMLNode_ConstList2_Clear(GWEN_XMLNODE_CONSTLIST2 *l); 
06693    
06694   GWEN_XMLNODE_CONSTLIST2_ITERATOR *GWEN_XMLNode_ConstList2_First(GWEN_XMLNODE_CONSTLIST2 *l); 
06695    
06696   GWEN_XMLNODE_CONSTLIST2_ITERATOR *GWEN_XMLNode_ConstList2_Last(GWEN_XMLNODE_CONSTLIST2 *l); 
06697    
06698   GWEN_XMLNODE_CONSTLIST2_ITERATOR *GWEN_XMLNode_ConstList2Iterator_new(GWEN_XMLNODE_CONSTLIST2 *l); 
06699    
06700   void GWEN_XMLNode_ConstList2Iterator_free(GWEN_XMLNODE_CONSTLIST2_ITERATOR *li); 
06701    
06702   const GWEN_XMLNODE *GWEN_XMLNode_ConstList2Iterator_Previous(GWEN_XMLNODE_CONSTLIST2_ITERATOR *li); 
06703    
06704   const GWEN_XMLNODE *GWEN_XMLNode_ConstList2Iterator_Next(GWEN_XMLNODE_CONSTLIST2_ITERATOR *li); 
06705    
06706   const GWEN_XMLNODE *GWEN_XMLNode_ConstList2Iterator_Data(GWEN_XMLNODE_CONSTLIST2_ITERATOR *li); 
06707    
06719   const GWEN_XMLNODE *GWEN_XMLNode_ConstList2_ForEach(GWEN_XMLNODE_CONSTLIST2 *list,
06720         GWEN_XMLNODE_CONSTLIST2_FOREACH func, void *user_data);
06721 
06722 
06723 #ifdef __cplusplus
06724 }
06725 #endif
06726 
06727 
06728 #endif /* GWEN_XMLNODE_LIST_H */
06729 
06730 
06731 
06732 /***************************************************************************
06733  $RCSfile$
06734  -------------------
06735  cvs         : $Id$
06736  begin       : Sat Jun 28 2003
06737  copyright   : (C) 2003 by Martin Preuss
06738  email       : martin@libchipcard.de
06739 
06740  ***************************************************************************
06741  *                                                                         *
06742  *   This library is free software; you can redistribute it and/or         *
06743  *   modify it under the terms of the GNU Lesser General Public            *
06744  *   License as published by the Free Software Foundation; either          *
06745  *   version 2.1 of the License, or (at your option) any later version.    *
06746  *                                                                         *
06747  *   This library is distributed in the hope that it will be useful,       *
06748  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
06749  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
06750  *   Lesser General Public License for more details.                       *
06751  *                                                                         *
06752  *   You should have received a copy of the GNU Lesser General Public      *
06753  *   License along with this library; if not, write to the Free Software   *
06754  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
06755  *   MA  02111-1307  USA                                                   *
06756  *                                                                         *
06757  ***************************************************************************/
06758 
06759 
06760 #ifndef GWEN_XMLNODE_LIST1_H
06761 #define GWEN_XMLNODE_LIST1_H
06762 
06763 #ifdef __cplusplus
06764 extern "C" {
06765 #endif
06766 
06768   typedef struct GWEN_XMLNODE_LIST_ELEMENT {
06769     uint32_t id;
06770     GWEN_XMLNODE *nextObject;
06771   } GWEN_XMLNODE_LIST__ELEMENT;
06772 
06779   typedef struct GWEN_XMLNODE_LIST GWEN_XMLNODE_LIST;
06781   struct GWEN_XMLNODE_LIST {
06782     GWEN_XMLNODE *first;
06783     uint32_t count;
06784     uint32_t id;
06785   } GWEN_XMLNODE_LIST;
06786 
06791   void GWEN_XMLNode_List_AddList(GWEN_XMLNODE_LIST *dst, GWEN_XMLNODE_LIST *l);
06792 
06796   void GWEN_XMLNode_List_Add(GWEN_XMLNODE *element, GWEN_XMLNODE_LIST *list);
06797 
06802   void GWEN_XMLNode_List_Insert(GWEN_XMLNODE *element, GWEN_XMLNODE_LIST *list);
06803 
06810   void GWEN_XMLNode_List_Del(GWEN_XMLNODE *element);
06811 
06815   GWEN_XMLNODE* GWEN_XMLNode_List_First(const GWEN_XMLNODE_LIST *l);
06816 
06820   GWEN_XMLNODE* GWEN_XMLNode_List_Last(const GWEN_XMLNODE_LIST *l);
06821 
06826   void GWEN_XMLNode_List_Clear(GWEN_XMLNODE_LIST *l);
06827 
06831   GWEN_XMLNODE_LIST* GWEN_XMLNode_List_new();
06832 
06836   void GWEN_XMLNode_List_free(GWEN_XMLNODE_LIST *l);
06837 
06841   GWEN_XMLNODE* GWEN_XMLNode_List_Next(const GWEN_XMLNODE *element);
06842 
06846   GWEN_XMLNODE* GWEN_XMLNode_List_Previous(const GWEN_XMLNODE *element);
06847 
06851   uint32_t GWEN_XMLNode_List_GetCount(const GWEN_XMLNODE_LIST *l);
06852 
06853 #ifdef __cplusplus
06854 }
06855 #endif
06856 
06857 
06858 #endif
06859 
06860 
06861 
06862 /***************************************************************************
06863  $RCSfile$
06864  -------------------
06865  cvs         : $Id$
06866  begin       : Sat Jun 28 2003
06867  copyright   : (C) 2003 by Martin Preuss
06868  email       : martin@libchipcard.de
06869 
06870  ***************************************************************************
06871  *                                                                         *
06872  *   This library is free software; you can redistribute it and/or         *
06873  *   modify it under the terms of the GNU Lesser General Public            *
06874  *   License as published by the Free Software Foundation; either          *
06875  *   version 2.1 of the License, or (at your option) any later version.    *
06876  *                                                                         *
06877  *   This library is distributed in the hope that it will be useful,       *
06878  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
06879  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
06880  *   Lesser General Public License for more details.                       *
06881  *                                                                         *
06882  *   You should have received a copy of the GNU Lesser General Public      *
06883  *   License along with this library; if not, write to the Free Software   *
06884  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
06885  *   MA  02111-1307  USA                                                   *
06886  *                                                                         *
06887  ***************************************************************************/
06888 
06889 
06890 #ifndef GWEN_FSLOCK_LIST2_H
06891 #define GWEN_FSLOCK_LIST2_H
06892 
06893 
06894 #ifdef __cplusplus
06895 extern "C" {
06896 #endif
06897 
06904   typedef struct GWEN_FSLOCK_LIST2 GWEN_FSLOCK_LIST2;
06905 
06909   typedef struct GWEN_FSLOCK_LIST2_ITERATOR GWEN_FSLOCK_LIST2_ITERATOR;
06910 
06914   typedef GWEN_FSLOCK* (GWEN_FSLOCK_LIST2_FOREACH)(GWEN_FSLOCK *element,
06915                                                  void *user_data);
06916 
06920   GWEN_FSLOCK_LIST2 *GWEN_FSLock_List2_new(); 
06921 
06925   void GWEN_FSLock_List2_free(GWEN_FSLOCK_LIST2 *l); 
06926 
06930   void GWEN_FSLock_List2_Dump(GWEN_FSLOCK_LIST2 *l, FILE *f, unsigned int indent); 
06931 
06935   void GWEN_FSLock_List2_PushBack(GWEN_FSLOCK_LIST2 *l, GWEN_FSLOCK *p); 
06936    
06941   void GWEN_FSLock_List2_PushFront(GWEN_FSLOCK_LIST2 *l, GWEN_FSLOCK *p); 
06942 
06947   GWEN_FSLOCK *GWEN_FSLock_List2_GetFront(GWEN_FSLOCK_LIST2 *l); 
06948    
06953   GWEN_FSLOCK *GWEN_FSLock_List2_GetBack(GWEN_FSLOCK_LIST2 *l); 
06954 
06959   void GWEN_FSLock_List2_Erase(GWEN_FSLOCK_LIST2 *l,
06960                                GWEN_FSLOCK_LIST2_ITERATOR *it);
06961 
06967   unsigned int GWEN_FSLock_List2_GetSize(GWEN_FSLOCK_LIST2 *l); 
06968 
06973   void GWEN_FSLock_List2_PopBack(GWEN_FSLOCK_LIST2 *l); 
06974    
06979   void GWEN_FSLock_List2_PopFront(GWEN_FSLOCK_LIST2 *l); 
06980 
06984   void GWEN_FSLock_List2_Clear(GWEN_FSLOCK_LIST2 *l); 
06985 
06989   GWEN_FSLOCK_LIST2_ITERATOR *GWEN_FSLock_List2_First(GWEN_FSLOCK_LIST2 *l); 
06990    
06994   GWEN_FSLOCK_LIST2_ITERATOR *GWEN_FSLock_List2_Last(GWEN_FSLOCK_LIST2 *l); 
06995 
06999   GWEN_FSLOCK_LIST2_ITERATOR *GWEN_FSLock_List2Iterator_new(GWEN_FSLOCK_LIST2 *l);
07000 
07004   void GWEN_FSLock_List2Iterator_free(GWEN_FSLOCK_LIST2_ITERATOR *li); 
07005 
07010   GWEN_FSLOCK *GWEN_FSLock_List2Iterator_Previous(GWEN_FSLOCK_LIST2_ITERATOR *li); 
07011    
07016   GWEN_FSLOCK *GWEN_FSLock_List2Iterator_Next(GWEN_FSLOCK_LIST2_ITERATOR *li); 
07017 
07022   GWEN_FSLOCK *GWEN_FSLock_List2Iterator_Data(GWEN_FSLOCK_LIST2_ITERATOR *li); 
07023 
07035   GWEN_FSLOCK *GWEN_FSLock_List2_ForEach(GWEN_FSLOCK_LIST2 *list,
07036                                         GWEN_FSLOCK_LIST2_FOREACH func,
07037                                         void *user_data);
07038 
07039 
07040   typedef struct GWEN_FSLOCK_CONSTLIST2 GWEN_FSLOCK_CONSTLIST2; 
07041   typedef struct GWEN_FSLOCK_CONSTLIST2_ITERATOR GWEN_FSLOCK_CONSTLIST2_ITERATOR; 
07042   typedef const GWEN_FSLOCK*
07043     (GWEN_FSLOCK_CONSTLIST2_FOREACH)(const GWEN_FSLOCK *element,
07044                                     void *user_data);
07045   
07046    
07047   GWEN_FSLOCK_CONSTLIST2 *GWEN_FSLock_ConstList2_new(); 
07048    
07049   void GWEN_FSLock_ConstList2_free(GWEN_FSLOCK_CONSTLIST2 *l); 
07050    
07051   void GWEN_FSLock_ConstList2_PushBack(GWEN_FSLOCK_CONSTLIST2 *l, const GWEN_FSLOCK *p); 
07052    
07053   void GWEN_FSLock_ConstList2_PushFront(GWEN_FSLOCK_CONSTLIST2 *l, const GWEN_FSLOCK *p); 
07054    
07055   const GWEN_FSLOCK *GWEN_FSLock_ConstList2_GetFront(GWEN_FSLOCK_CONSTLIST2 *l); 
07056    
07057   const GWEN_FSLOCK *GWEN_FSLock_ConstList2_GetBack(GWEN_FSLOCK_CONSTLIST2 *l); 
07058    
07059   unsigned int GWEN_FSLock_ConstList2_GetSize(GWEN_FSLOCK_CONSTLIST2 *l); 
07060    
07061   void GWEN_FSLock_ConstList2_PopBack(GWEN_FSLOCK_CONSTLIST2 *l); 
07062    
07063   void GWEN_FSLock_ConstList2_PopFront(GWEN_FSLOCK_CONSTLIST2 *l); 
07064    
07065   void GWEN_FSLock_ConstList2_Clear(GWEN_FSLOCK_CONSTLIST2 *l); 
07066    
07067   GWEN_FSLOCK_CONSTLIST2_ITERATOR *GWEN_FSLock_ConstList2_First(GWEN_FSLOCK_CONSTLIST2 *l); 
07068    
07069   GWEN_FSLOCK_CONSTLIST2_ITERATOR *GWEN_FSLock_ConstList2_Last(GWEN_FSLOCK_CONSTLIST2 *l); 
07070    
07071   GWEN_FSLOCK_CONSTLIST2_ITERATOR *GWEN_FSLock_ConstList2Iterator_new(GWEN_FSLOCK_CONSTLIST2 *l); 
07072    
07073   void GWEN_FSLock_ConstList2Iterator_free(GWEN_FSLOCK_CONSTLIST2_ITERATOR *li); 
07074    
07075   const GWEN_FSLOCK *GWEN_FSLock_ConstList2Iterator_Previous(GWEN_FSLOCK_CONSTLIST2_ITERATOR *li); 
07076    
07077   const GWEN_FSLOCK *GWEN_FSLock_ConstList2Iterator_Next(GWEN_FSLOCK_CONSTLIST2_ITERATOR *li); 
07078    
07079   const GWEN_FSLOCK *GWEN_FSLock_ConstList2Iterator_Data(GWEN_FSLOCK_CONSTLIST2_ITERATOR *li); 
07080    
07092   const GWEN_FSLOCK *GWEN_FSLock_ConstList2_ForEach(GWEN_FSLOCK_CONSTLIST2 *list,
07093         GWEN_FSLOCK_CONSTLIST2_FOREACH func, void *user_data);
07094 
07095 
07096 #ifdef __cplusplus
07097 }
07098 #endif
07099 
07100 
07101 #endif /* GWEN_FSLOCK_LIST_H */
07102 
07103 
07104 
07105 /***************************************************************************
07106  $RCSfile$
07107  -------------------
07108  cvs         : $Id$
07109  begin       : Sat Jun 28 2003
07110  copyright   : (C) 2003 by Martin Preuss
07111  email       : martin@libchipcard.de
07112 
07113  ***************************************************************************
07114  *                                                                         *
07115  *   This library is free software; you can redistribute it and/or         *
07116  *   modify it under the terms of the GNU Lesser General Public            *
07117  *   License as published by the Free Software Foundation; either          *
07118  *   version 2.1 of the License, or (at your option) any later version.    *
07119  *                                                                         *
07120  *   This library is distributed in the hope that it will be useful,       *
07121  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
07122  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
07123  *   Lesser General Public License for more details.                       *
07124  *                                                                         *
07125  *   You should have received a copy of the GNU Lesser General Public      *
07126  *   License along with this library; if not, write to the Free Software   *
07127  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
07128  *   MA  02111-1307  USA                                                   *
07129  *                                                                         *
07130  ***************************************************************************/
07131 
07132 
07133 #ifndef GWEN_FSLOCK_LIST1_H
07134 #define GWEN_FSLOCK_LIST1_H
07135 
07136 #ifdef __cplusplus
07137 extern "C" {
07138 #endif
07139 
07141   typedef struct GWEN_FSLOCK_LIST_ELEMENT {
07142     uint32_t id;
07143     GWEN_FSLOCK *nextObject;
07144   } GWEN_FSLOCK_LIST__ELEMENT;
07145 
07152   typedef struct GWEN_FSLOCK_LIST GWEN_FSLOCK_LIST;
07154   struct GWEN_FSLOCK_LIST {
07155     GWEN_FSLOCK *first;
07156     uint32_t count;
07157     uint32_t id;
07158   } GWEN_FSLOCK_LIST;
07159 
07164   void GWEN_FSLock_List_AddList(GWEN_FSLOCK_LIST *dst, GWEN_FSLOCK_LIST *l);
07165 
07169   void GWEN_FSLock_List_Add(GWEN_FSLOCK *element, GWEN_FSLOCK_LIST *list);
07170 
07175   void GWEN_FSLock_List_Insert(GWEN_FSLOCK *element, GWEN_FSLOCK_LIST *list);
07176 
07183   void GWEN_FSLock_List_Del(GWEN_FSLOCK *element);
07184 
07188   GWEN_FSLOCK* GWEN_FSLock_List_First(const GWEN_FSLOCK_LIST *l);
07189 
07193   GWEN_FSLOCK* GWEN_FSLock_List_Last(const GWEN_FSLOCK_LIST *l);
07194 
07199   void GWEN_FSLock_List_Clear(GWEN_FSLOCK_LIST *l);
07200 
07204   GWEN_FSLOCK_LIST* GWEN_FSLock_List_new();
07205 
07209   void GWEN_FSLock_List_free(GWEN_FSLOCK_LIST *l);
07210 
07214   GWEN_FSLOCK* GWEN_FSLock_List_Next(const GWEN_FSLOCK *element);
07215 
07219   GWEN_FSLOCK* GWEN_FSLock_List_Previous(const GWEN_FSLOCK *element);
07220 
07224   uint32_t GWEN_FSLock_List_GetCount(const GWEN_FSLOCK_LIST *l);
07225 
07226 #ifdef __cplusplus
07227 }
07228 #endif
07229 
07230 
07231 #endif
07232 
07233 
07234 
07235 /***************************************************************************
07236  $RCSfile$
07237  -------------------
07238  cvs         : $Id$
07239  begin       : Sat Jun 28 2003
07240  copyright   : (C) 2003 by Martin Preuss
07241  email       : martin@libchipcard.de
07242 
07243  ***************************************************************************
07244  *                                                                         *
07245  *   This library is free software; you can redistribute it and/or         *
07246  *   modify it under the terms of the GNU Lesser General Public            *
07247  *   License as published by the Free Software Foundation; either          *
07248  *   version 2.1 of the License, or (at your option) any later version.    *
07249  *                                                                         *
07250  *   This library is distributed in the hope that it will be useful,       *
07251  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
07252  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
07253  *   Lesser General Public License for more details.                       *
07254  *                                                                         *
07255  *   You should have received a copy of the GNU Lesser General Public      *
07256  *   License along with this library; if not, write to the Free Software   *
07257  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
07258  *   MA  02111-1307  USA                                                   *
07259  *                                                                         *
07260  ***************************************************************************/
07261 
07262 
07263 #ifndef GWEN_XSD_NODE_LIST1_H
07264 #define GWEN_XSD_NODE_LIST1_H
07265 
07266 #ifdef __cplusplus
07267 extern "C" {
07268 #endif
07269 
07271   typedef struct GWEN_XSD_NODE_LIST_ELEMENT {
07272     uint32_t id;
07273     GWEN_XSD_NODE *nextObject;
07274   } GWEN_XSD_NODE_LIST__ELEMENT;
07275 
07282   typedef struct GWEN_XSD_NODE_LIST GWEN_XSD_NODE_LIST;
07284   struct GWEN_XSD_NODE_LIST {
07285     GWEN_XSD_NODE *first;
07286     uint32_t count;
07287     uint32_t id;
07288   } GWEN_XSD_NODE_LIST;
07289 
07294   void GWEN_XsdNode_List_AddList(GWEN_XSD_NODE_LIST *dst, GWEN_XSD_NODE_LIST *l);
07295 
07299   void GWEN_XsdNode_List_Add(GWEN_XSD_NODE *element, GWEN_XSD_NODE_LIST *list);
07300 
07305   void GWEN_XsdNode_List_Insert(GWEN_XSD_NODE *element, GWEN_XSD_NODE_LIST *list);
07306 
07313   void GWEN_XsdNode_List_Del(GWEN_XSD_NODE *element);
07314 
07318   GWEN_XSD_NODE* GWEN_XsdNode_List_First(const GWEN_XSD_NODE_LIST *l);
07319 
07323   GWEN_XSD_NODE* GWEN_XsdNode_List_Last(const GWEN_XSD_NODE_LIST *l);
07324 
07329   void GWEN_XsdNode_List_Clear(GWEN_XSD_NODE_LIST *l);
07330 
07334   GWEN_XSD_NODE_LIST* GWEN_XsdNode_List_new();
07335 
07339   void GWEN_XsdNode_List_free(GWEN_XSD_NODE_LIST *l);
07340 
07344   GWEN_XSD_NODE* GWEN_XsdNode_List_Next(const GWEN_XSD_NODE *element);
07345 
07349   GWEN_XSD_NODE* GWEN_XsdNode_List_Previous(const GWEN_XSD_NODE *element);
07350 
07354   uint32_t GWEN_XsdNode_List_GetCount(const GWEN_XSD_NODE_LIST *l);
07355 
07356 #ifdef __cplusplus
07357 }
07358 #endif
07359 
07360 
07361 #endif
07362 
07363 
07364 
07365 /***************************************************************************
07366  $RCSfile$
07367  -------------------
07368  cvs         : $Id$
07369  begin       : Sat Jun 28 2003
07370  copyright   : (C) 2003 by Martin Preuss
07371  email       : martin@libchipcard.de
07372 
07373  ***************************************************************************
07374  *                                                                         *
07375  *   This library is free software; you can redistribute it and/or         *
07376  *   modify it under the terms of the GNU Lesser General Public            *
07377  *   License as published by the Free Software Foundation; either          *
07378  *   version 2.1 of the License, or (at your option) any later version.    *
07379  *                                                                         *
07380  *   This library is distributed in the hope that it will be useful,       *
07381  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
07382  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
07383  *   Lesser General Public License for more details.                       *
07384  *                                                                         *
07385  *   You should have received a copy of the GNU Lesser General Public      *
07386  *   License along with this library; if not, write to the Free Software   *
07387  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
07388  *   MA  02111-1307  USA                                                   *
07389  *                                                                         *
07390  ***************************************************************************/
07391 
07392 
07393 #ifndef GWEN_CRYPT_KEY_LIST2_H
07394 #define GWEN_CRYPT_KEY_LIST2_H
07395 
07396 
07397 #ifdef __cplusplus
07398 extern "C" {
07399 #endif
07400 
07407   typedef struct GWEN_CRYPT_KEY_LIST2 GWEN_CRYPT_KEY_LIST2;
07408 
07412   typedef struct GWEN_CRYPT_KEY_LIST2_ITERATOR GWEN_CRYPT_KEY_LIST2_ITERATOR;
07413 
07417   typedef GWEN_CRYPT_KEY* (GWEN_CRYPT_KEY_LIST2_FOREACH)(GWEN_CRYPT_KEY *element,
07418                                                  void *user_data);
07419 
07423   GWEN_CRYPT_KEY_LIST2 *GWEN_Crypt_Key_List2_new(); 
07424 
07428   void GWEN_Crypt_Key_List2_free(GWEN_CRYPT_KEY_LIST2 *l); 
07429 
07433   void GWEN_Crypt_Key_List2_Dump(GWEN_CRYPT_KEY_LIST2 *l, FILE *f, unsigned int indent); 
07434 
07438   void GWEN_Crypt_Key_List2_PushBack(GWEN_CRYPT_KEY_LIST2 *l, GWEN_CRYPT_KEY *p); 
07439    
07444   void GWEN_Crypt_Key_List2_PushFront(GWEN_CRYPT_KEY_LIST2 *l, GWEN_CRYPT_KEY *p); 
07445 
07450   GWEN_CRYPT_KEY *GWEN_Crypt_Key_List2_GetFront(GWEN_CRYPT_KEY_LIST2 *l); 
07451    
07456   GWEN_CRYPT_KEY *GWEN_Crypt_Key_List2_GetBack(GWEN_CRYPT_KEY_LIST2 *l); 
07457 
07462   void GWEN_Crypt_Key_List2_Erase(GWEN_CRYPT_KEY_LIST2 *l,
07463                                GWEN_CRYPT_KEY_LIST2_ITERATOR *it);
07464 
07470   unsigned int GWEN_Crypt_Key_List2_GetSize(GWEN_CRYPT_KEY_LIST2 *l); 
07471 
07476   void GWEN_Crypt_Key_List2_PopBack(GWEN_CRYPT_KEY_LIST2 *l); 
07477    
07482   void GWEN_Crypt_Key_List2_PopFront(GWEN_CRYPT_KEY_LIST2 *l); 
07483 
07487   void GWEN_Crypt_Key_List2_Clear(GWEN_CRYPT_KEY_LIST2 *l); 
07488 
07492   GWEN_CRYPT_KEY_LIST2_ITERATOR *GWEN_Crypt_Key_List2_First(GWEN_CRYPT_KEY_LIST2 *l); 
07493    
07497   GWEN_CRYPT_KEY_LIST2_ITERATOR *GWEN_Crypt_Key_List2_Last(GWEN_CRYPT_KEY_LIST2 *l); 
07498 
07502   GWEN_CRYPT_KEY_LIST2_ITERATOR *GWEN_Crypt_Key_List2Iterator_new(GWEN_CRYPT_KEY_LIST2 *l);
07503 
07507   void GWEN_Crypt_Key_List2Iterator_free(GWEN_CRYPT_KEY_LIST2_ITERATOR *li); 
07508 
07513   GWEN_CRYPT_KEY *GWEN_Crypt_Key_List2Iterator_Previous(GWEN_CRYPT_KEY_LIST2_ITERATOR *li); 
07514    
07519   GWEN_CRYPT_KEY *GWEN_Crypt_Key_List2Iterator_Next(GWEN_CRYPT_KEY_LIST2_ITERATOR *li); 
07520 
07525   GWEN_CRYPT_KEY *GWEN_Crypt_Key_List2Iterator_Data(GWEN_CRYPT_KEY_LIST2_ITERATOR *li); 
07526 
07538   GWEN_CRYPT_KEY *GWEN_Crypt_Key_List2_ForEach(GWEN_CRYPT_KEY_LIST2 *list,
07539                                         GWEN_CRYPT_KEY_LIST2_FOREACH func,
07540                                         void *user_data);
07541 
07542 
07543   typedef struct GWEN_CRYPT_KEY_CONSTLIST2 GWEN_CRYPT_KEY_CONSTLIST2; 
07544   typedef struct GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR; 
07545   typedef const GWEN_CRYPT_KEY*
07546     (GWEN_CRYPT_KEY_CONSTLIST2_FOREACH)(const GWEN_CRYPT_KEY *element,
07547                                     void *user_data);
07548   
07549    
07550   GWEN_CRYPT_KEY_CONSTLIST2 *GWEN_Crypt_Key_ConstList2_new(); 
07551    
07552   void GWEN_Crypt_Key_ConstList2_free(GWEN_CRYPT_KEY_CONSTLIST2 *l); 
07553    
07554   void GWEN_Crypt_Key_ConstList2_PushBack(GWEN_CRYPT_KEY_CONSTLIST2 *l, const GWEN_CRYPT_KEY *p); 
07555    
07556   void GWEN_Crypt_Key_ConstList2_PushFront(GWEN_CRYPT_KEY_CONSTLIST2 *l, const GWEN_CRYPT_KEY *p); 
07557    
07558   const GWEN_CRYPT_KEY *GWEN_Crypt_Key_ConstList2_GetFront(GWEN_CRYPT_KEY_CONSTLIST2 *l); 
07559    
07560   const GWEN_CRYPT_KEY *GWEN_Crypt_Key_ConstList2_GetBack(GWEN_CRYPT_KEY_CONSTLIST2 *l); 
07561    
07562   unsigned int GWEN_Crypt_Key_ConstList2_GetSize(GWEN_CRYPT_KEY_CONSTLIST2 *l); 
07563    
07564   void GWEN_Crypt_Key_ConstList2_PopBack(GWEN_CRYPT_KEY_CONSTLIST2 *l); 
07565    
07566   void GWEN_Crypt_Key_ConstList2_PopFront(GWEN_CRYPT_KEY_CONSTLIST2 *l); 
07567    
07568   void GWEN_Crypt_Key_ConstList2_Clear(GWEN_CRYPT_KEY_CONSTLIST2 *l); 
07569    
07570   GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR *GWEN_Crypt_Key_ConstList2_First(GWEN_CRYPT_KEY_CONSTLIST2 *l); 
07571    
07572   GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR *GWEN_Crypt_Key_ConstList2_Last(GWEN_CRYPT_KEY_CONSTLIST2 *l); 
07573    
07574   GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR *GWEN_Crypt_Key_ConstList2Iterator_new(GWEN_CRYPT_KEY_CONSTLIST2 *l); 
07575    
07576   void GWEN_Crypt_Key_ConstList2Iterator_free(GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR *li); 
07577    
07578   const GWEN_CRYPT_KEY *GWEN_Crypt_Key_ConstList2Iterator_Previous(GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR *li); 
07579    
07580   const GWEN_CRYPT_KEY *GWEN_Crypt_Key_ConstList2Iterator_Next(GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR *li); 
07581    
07582   const GWEN_CRYPT_KEY *GWEN_Crypt_Key_ConstList2Iterator_Data(GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR *li); 
07583    
07595   const GWEN_CRYPT_KEY *GWEN_Crypt_Key_ConstList2_ForEach(GWEN_CRYPT_KEY_CONSTLIST2 *list,
07596         GWEN_CRYPT_KEY_CONSTLIST2_FOREACH func, void *user_data);
07597 
07598 
07599 #ifdef __cplusplus
07600 }
07601 #endif
07602 
07603 
07604 #endif /* GWEN_CRYPT_KEY_LIST_H */
07605 
07606 
07607 
07608 /***************************************************************************
07609  $RCSfile$
07610  -------------------
07611  cvs         : $Id$
07612  begin       : Sat Jun 28 2003
07613  copyright   : (C) 2003 by Martin Preuss
07614  email       : martin@libchipcard.de
07615 
07616  ***************************************************************************
07617  *                                                                         *
07618  *   This library is free software; you can redistribute it and/or         *
07619  *   modify it under the terms of the GNU Lesser General Public            *
07620  *   License as published by the Free Software Foundation; either          *
07621  *   version 2.1 of the License, or (at your option) any later version.    *
07622  *                                                                         *
07623  *   This library is distributed in the hope that it will be useful,       *
07624  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
07625  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
07626  *   Lesser General Public License for more details.                       *
07627  *                                                                         *
07628  *   You should have received a copy of the GNU Lesser General Public      *
07629  *   License along with this library; if not, write to the Free Software   *
07630  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
07631  *   MA  02111-1307  USA                                                   *
07632  *                                                                         *
07633  ***************************************************************************/
07634 
07635 
07636 #ifndef GWEN_CRYPT_KEY_LIST1_H
07637 #define GWEN_CRYPT_KEY_LIST1_H
07638 
07639 #ifdef __cplusplus
07640 extern "C" {
07641 #endif
07642 
07644   typedef struct GWEN_CRYPT_KEY_LIST_ELEMENT {
07645     uint32_t id;
07646     GWEN_CRYPT_KEY *nextObject;
07647   } GWEN_CRYPT_KEY_LIST__ELEMENT;
07648 
07655   typedef struct GWEN_CRYPT_KEY_LIST GWEN_CRYPT_KEY_LIST;
07657   struct GWEN_CRYPT_KEY_LIST {
07658     GWEN_CRYPT_KEY *first;
07659     uint32_t count;
07660     uint32_t id;
07661   } GWEN_CRYPT_KEY_LIST;
07662 
07667   void GWEN_Crypt_Key_List_AddList(GWEN_CRYPT_KEY_LIST *dst, GWEN_CRYPT_KEY_LIST *l);
07668 
07672   void GWEN_Crypt_Key_List_Add(GWEN_CRYPT_KEY *element, GWEN_CRYPT_KEY_LIST *list);
07673 
07678   void GWEN_Crypt_Key_List_Insert(GWEN_CRYPT_KEY *element, GWEN_CRYPT_KEY_LIST *list);
07679 
07686   void GWEN_Crypt_Key_List_Del(GWEN_CRYPT_KEY *element);
07687 
07691   GWEN_CRYPT_KEY* GWEN_Crypt_Key_List_First(const GWEN_CRYPT_KEY_LIST *l);
07692 
07696   GWEN_CRYPT_KEY* GWEN_Crypt_Key_List_Last(const GWEN_CRYPT_KEY_LIST *l);
07697 
07702   void GWEN_Crypt_Key_List_Clear(GWEN_CRYPT_KEY_LIST *l);
07703 
07707   GWEN_CRYPT_KEY_LIST* GWEN_Crypt_Key_List_new();
07708 
07712   void GWEN_Crypt_Key_List_free(GWEN_CRYPT_KEY_LIST *l);
07713 
07717   GWEN_CRYPT_KEY* GWEN_Crypt_Key_List_Next(const GWEN_CRYPT_KEY *element);
07718 
07722   GWEN_CRYPT_KEY* GWEN_Crypt_Key_List_Previous(const GWEN_CRYPT_KEY *element);
07723 
07727   uint32_t GWEN_Crypt_Key_List_GetCount(const GWEN_CRYPT_KEY_LIST *l);
07728 
07729 #ifdef __cplusplus
07730 }
07731 #endif
07732 
07733 
07734 #endif
07735 
07736 
07737