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_CRYPT_PADDALGO_LIST2_H
00030 #define GWEN_CRYPT_PADDALGO_LIST2_H
00031 
00032 
00033 #ifdef __cplusplus
00034 extern "C" {
00035 #endif
00036 
00043   typedef struct GWEN_CRYPT_PADDALGO_LIST2 GWEN_CRYPT_PADDALGO_LIST2;
00044 
00048   typedef struct GWEN_CRYPT_PADDALGO_LIST2_ITERATOR GWEN_CRYPT_PADDALGO_LIST2_ITERATOR;
00049 
00053   typedef GWEN_CRYPT_PADDALGO* (GWEN_CRYPT_PADDALGO_LIST2_FOREACH)(GWEN_CRYPT_PADDALGO *element,
00054                                                  void *user_data);
00055 
00059   GWEN_CRYPT_PADDALGO_LIST2 *GWEN_Crypt_PaddAlgo_List2_new(); 
00060 
00064   void GWEN_Crypt_PaddAlgo_List2_free(GWEN_CRYPT_PADDALGO_LIST2 *l); 
00065 
00069   void GWEN_Crypt_PaddAlgo_List2_Dump(GWEN_CRYPT_PADDALGO_LIST2 *l, FILE *f, unsigned int indent); 
00070 
00074   void GWEN_Crypt_PaddAlgo_List2_PushBack(GWEN_CRYPT_PADDALGO_LIST2 *l, GWEN_CRYPT_PADDALGO *p); 
00075    
00080   void GWEN_Crypt_PaddAlgo_List2_PushFront(GWEN_CRYPT_PADDALGO_LIST2 *l, GWEN_CRYPT_PADDALGO *p); 
00081 
00086   GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_List2_GetFront(GWEN_CRYPT_PADDALGO_LIST2 *l); 
00087    
00092   GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_List2_GetBack(GWEN_CRYPT_PADDALGO_LIST2 *l); 
00093 
00098   void GWEN_Crypt_PaddAlgo_List2_Erase(GWEN_CRYPT_PADDALGO_LIST2 *l,
00099                                GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *it);
00100 
00106   unsigned int GWEN_Crypt_PaddAlgo_List2_GetSize(GWEN_CRYPT_PADDALGO_LIST2 *l); 
00107 
00112   void GWEN_Crypt_PaddAlgo_List2_PopBack(GWEN_CRYPT_PADDALGO_LIST2 *l); 
00113    
00118   void GWEN_Crypt_PaddAlgo_List2_PopFront(GWEN_CRYPT_PADDALGO_LIST2 *l); 
00119 
00123   void GWEN_Crypt_PaddAlgo_List2_Clear(GWEN_CRYPT_PADDALGO_LIST2 *l); 
00124 
00128   GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *GWEN_Crypt_PaddAlgo_List2_First(GWEN_CRYPT_PADDALGO_LIST2 *l); 
00129    
00133   GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *GWEN_Crypt_PaddAlgo_List2_Last(GWEN_CRYPT_PADDALGO_LIST2 *l); 
00134 
00138   GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *GWEN_Crypt_PaddAlgo_List2Iterator_new(GWEN_CRYPT_PADDALGO_LIST2 *l);
00139 
00143   void GWEN_Crypt_PaddAlgo_List2Iterator_free(GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *li); 
00144 
00149   GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_List2Iterator_Previous(GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *li); 
00150    
00155   GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_List2Iterator_Next(GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *li); 
00156 
00161   GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_List2Iterator_Data(GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *li); 
00162 
00174   GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_List2_ForEach(GWEN_CRYPT_PADDALGO_LIST2 *list,
00175                                         GWEN_CRYPT_PADDALGO_LIST2_FOREACH func,
00176                                         void *user_data);
00177 
00178 
00179   typedef struct GWEN_CRYPT_PADDALGO_CONSTLIST2 GWEN_CRYPT_PADDALGO_CONSTLIST2; 
00180   typedef struct GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR; 
00181   typedef const GWEN_CRYPT_PADDALGO*
00182     (GWEN_CRYPT_PADDALGO_CONSTLIST2_FOREACH)(const GWEN_CRYPT_PADDALGO *element,
00183                                     void *user_data);
00184   
00185    
00186   GWEN_CRYPT_PADDALGO_CONSTLIST2 *GWEN_Crypt_PaddAlgo_ConstList2_new(); 
00187    
00188   void GWEN_Crypt_PaddAlgo_ConstList2_free(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l); 
00189    
00190   void GWEN_Crypt_PaddAlgo_ConstList2_PushBack(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l, const GWEN_CRYPT_PADDALGO *p); 
00191    
00192   void GWEN_Crypt_PaddAlgo_ConstList2_PushFront(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l, const GWEN_CRYPT_PADDALGO *p); 
00193    
00194   const GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_ConstList2_GetFront(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l); 
00195    
00196   const GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_ConstList2_GetBack(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l); 
00197    
00198   unsigned int GWEN_Crypt_PaddAlgo_ConstList2_GetSize(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l); 
00199    
00200   void GWEN_Crypt_PaddAlgo_ConstList2_PopBack(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l); 
00201    
00202   void GWEN_Crypt_PaddAlgo_ConstList2_PopFront(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l); 
00203    
00204   void GWEN_Crypt_PaddAlgo_ConstList2_Clear(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l); 
00205    
00206   GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_PaddAlgo_ConstList2_First(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l); 
00207    
00208   GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_PaddAlgo_ConstList2_Last(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l); 
00209    
00210   GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_PaddAlgo_ConstList2Iterator_new(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l); 
00211    
00212   void GWEN_Crypt_PaddAlgo_ConstList2Iterator_free(GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR *li); 
00213    
00214   const GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_ConstList2Iterator_Previous(GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR *li); 
00215    
00216   const GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_ConstList2Iterator_Next(GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR *li); 
00217    
00218   const GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_ConstList2Iterator_Data(GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR *li); 
00219    
00231   const GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_ConstList2_ForEach(GWEN_CRYPT_PADDALGO_CONSTLIST2 *list,
00232         GWEN_CRYPT_PADDALGO_CONSTLIST2_FOREACH func, void *user_data);
00233 
00234 
00235 #ifdef __cplusplus
00236 }
00237 #endif
00238 
00239 
00240 #endif /* GWEN_CRYPT_PADDALGO_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_XMLNODE_NAMESPACE_LIST1_H
00273 #define GWEN_XMLNODE_NAMESPACE_LIST1_H
00274 
00275 #ifdef __cplusplus
00276 extern "C" {
00277 #endif
00278 
00280   typedef struct GWEN_XMLNODE_NAMESPACE_LIST_ELEMENT {
00281     uint32_t id;
00282     GWEN_XMLNODE_NAMESPACE *nextObject;
00283   } GWEN_XMLNODE_NAMESPACE_LIST__ELEMENT;
00284 
00291   typedef struct GWEN_XMLNODE_NAMESPACE_LIST GWEN_XMLNODE_NAMESPACE_LIST;
00293   struct GWEN_XMLNODE_NAMESPACE_LIST {
00294     GWEN_XMLNODE_NAMESPACE *first;
00295     uint32_t count;
00296     uint32_t id;
00297   } GWEN_XMLNODE_NAMESPACE_LIST;
00298 
00303   void GWEN_XMLNode_NameSpace_List_AddList(GWEN_XMLNODE_NAMESPACE_LIST *dst, GWEN_XMLNODE_NAMESPACE_LIST *l);
00304 
00308   void GWEN_XMLNode_NameSpace_List_Add(GWEN_XMLNODE_NAMESPACE *element, GWEN_XMLNODE_NAMESPACE_LIST *list);
00309 
00314   void GWEN_XMLNode_NameSpace_List_Insert(GWEN_XMLNODE_NAMESPACE *element, GWEN_XMLNODE_NAMESPACE_LIST *list);
00315 
00322   void GWEN_XMLNode_NameSpace_List_Del(GWEN_XMLNODE_NAMESPACE *element);
00323 
00327   GWEN_XMLNODE_NAMESPACE* GWEN_XMLNode_NameSpace_List_First(const GWEN_XMLNODE_NAMESPACE_LIST *l);
00328 
00332   GWEN_XMLNODE_NAMESPACE* GWEN_XMLNode_NameSpace_List_Last(const GWEN_XMLNODE_NAMESPACE_LIST *l);
00333 
00338   void GWEN_XMLNode_NameSpace_List_Clear(GWEN_XMLNODE_NAMESPACE_LIST *l);
00339 
00343   GWEN_XMLNODE_NAMESPACE_LIST* GWEN_XMLNode_NameSpace_List_new();
00344 
00348   void GWEN_XMLNode_NameSpace_List_free(GWEN_XMLNODE_NAMESPACE_LIST *l);
00349 
00353   GWEN_XMLNODE_NAMESPACE* GWEN_XMLNode_NameSpace_List_Next(const GWEN_XMLNODE_NAMESPACE *element);
00354 
00358   GWEN_XMLNODE_NAMESPACE* GWEN_XMLNode_NameSpace_List_Previous(const GWEN_XMLNODE_NAMESPACE *element);
00359 
00363   uint32_t GWEN_XMLNode_NameSpace_List_GetCount(const GWEN_XMLNODE_NAMESPACE_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_XMLNODE_LIST2_H
00403 #define GWEN_XMLNODE_LIST2_H
00404 
00405 
00406 #ifdef __cplusplus
00407 extern "C" {
00408 #endif
00409 
00416   typedef struct GWEN_XMLNODE_LIST2 GWEN_XMLNODE_LIST2;
00417 
00421   typedef struct GWEN_XMLNODE_LIST2_ITERATOR GWEN_XMLNODE_LIST2_ITERATOR;
00422 
00426   typedef GWEN_XMLNODE* (GWEN_XMLNODE_LIST2_FOREACH)(GWEN_XMLNODE *element,
00427                                                  void *user_data);
00428 
00432   GWEN_XMLNODE_LIST2 *GWEN_XMLNode_List2_new(); 
00433 
00437   void GWEN_XMLNode_List2_free(GWEN_XMLNODE_LIST2 *l); 
00438 
00442   void GWEN_XMLNode_List2_Dump(GWEN_XMLNODE_LIST2 *l, FILE *f, unsigned int indent); 
00443 
00447   void GWEN_XMLNode_List2_PushBack(GWEN_XMLNODE_LIST2 *l, GWEN_XMLNODE *p); 
00448    
00453   void GWEN_XMLNode_List2_PushFront(GWEN_XMLNODE_LIST2 *l, GWEN_XMLNODE *p); 
00454 
00459   GWEN_XMLNODE *GWEN_XMLNode_List2_GetFront(GWEN_XMLNODE_LIST2 *l); 
00460    
00465   GWEN_XMLNODE *GWEN_XMLNode_List2_GetBack(GWEN_XMLNODE_LIST2 *l); 
00466 
00471   void GWEN_XMLNode_List2_Erase(GWEN_XMLNODE_LIST2 *l,
00472                                GWEN_XMLNODE_LIST2_ITERATOR *it);
00473 
00479   unsigned int GWEN_XMLNode_List2_GetSize(GWEN_XMLNODE_LIST2 *l); 
00480 
00485   void GWEN_XMLNode_List2_PopBack(GWEN_XMLNODE_LIST2 *l); 
00486    
00491   void GWEN_XMLNode_List2_PopFront(GWEN_XMLNODE_LIST2 *l); 
00492 
00496   void GWEN_XMLNode_List2_Clear(GWEN_XMLNODE_LIST2 *l); 
00497 
00501   GWEN_XMLNODE_LIST2_ITERATOR *GWEN_XMLNode_List2_First(GWEN_XMLNODE_LIST2 *l); 
00502    
00506   GWEN_XMLNODE_LIST2_ITERATOR *GWEN_XMLNode_List2_Last(GWEN_XMLNODE_LIST2 *l); 
00507 
00511   GWEN_XMLNODE_LIST2_ITERATOR *GWEN_XMLNode_List2Iterator_new(GWEN_XMLNODE_LIST2 *l);
00512 
00516   void GWEN_XMLNode_List2Iterator_free(GWEN_XMLNODE_LIST2_ITERATOR *li); 
00517 
00522   GWEN_XMLNODE *GWEN_XMLNode_List2Iterator_Previous(GWEN_XMLNODE_LIST2_ITERATOR *li); 
00523    
00528   GWEN_XMLNODE *GWEN_XMLNode_List2Iterator_Next(GWEN_XMLNODE_LIST2_ITERATOR *li); 
00529 
00534   GWEN_XMLNODE *GWEN_XMLNode_List2Iterator_Data(GWEN_XMLNODE_LIST2_ITERATOR *li); 
00535 
00547   GWEN_XMLNODE *GWEN_XMLNode_List2_ForEach(GWEN_XMLNODE_LIST2 *list,
00548                                         GWEN_XMLNODE_LIST2_FOREACH func,
00549                                         void *user_data);
00550 
00551 
00552   typedef struct GWEN_XMLNODE_CONSTLIST2 GWEN_XMLNODE_CONSTLIST2; 
00553   typedef struct GWEN_XMLNODE_CONSTLIST2_ITERATOR GWEN_XMLNODE_CONSTLIST2_ITERATOR; 
00554   typedef const GWEN_XMLNODE*
00555     (GWEN_XMLNODE_CONSTLIST2_FOREACH)(const GWEN_XMLNODE *element,
00556                                     void *user_data);
00557   
00558    
00559   GWEN_XMLNODE_CONSTLIST2 *GWEN_XMLNode_ConstList2_new(); 
00560    
00561   void GWEN_XMLNode_ConstList2_free(GWEN_XMLNODE_CONSTLIST2 *l); 
00562    
00563   void GWEN_XMLNode_ConstList2_PushBack(GWEN_XMLNODE_CONSTLIST2 *l, const GWEN_XMLNODE *p); 
00564    
00565   void GWEN_XMLNode_ConstList2_PushFront(GWEN_XMLNODE_CONSTLIST2 *l, const GWEN_XMLNODE *p); 
00566    
00567   const GWEN_XMLNODE *GWEN_XMLNode_ConstList2_GetFront(GWEN_XMLNODE_CONSTLIST2 *l); 
00568    
00569   const GWEN_XMLNODE *GWEN_XMLNode_ConstList2_GetBack(GWEN_XMLNODE_CONSTLIST2 *l); 
00570    
00571   unsigned int GWEN_XMLNode_ConstList2_GetSize(GWEN_XMLNODE_CONSTLIST2 *l); 
00572    
00573   void GWEN_XMLNode_ConstList2_PopBack(GWEN_XMLNODE_CONSTLIST2 *l); 
00574    
00575   void GWEN_XMLNode_ConstList2_PopFront(GWEN_XMLNODE_CONSTLIST2 *l); 
00576    
00577   void GWEN_XMLNode_ConstList2_Clear(GWEN_XMLNODE_CONSTLIST2 *l); 
00578    
00579   GWEN_XMLNODE_CONSTLIST2_ITERATOR *GWEN_XMLNode_ConstList2_First(GWEN_XMLNODE_CONSTLIST2 *l); 
00580    
00581   GWEN_XMLNODE_CONSTLIST2_ITERATOR *GWEN_XMLNode_ConstList2_Last(GWEN_XMLNODE_CONSTLIST2 *l); 
00582    
00583   GWEN_XMLNODE_CONSTLIST2_ITERATOR *GWEN_XMLNode_ConstList2Iterator_new(GWEN_XMLNODE_CONSTLIST2 *l); 
00584    
00585   void GWEN_XMLNode_ConstList2Iterator_free(GWEN_XMLNODE_CONSTLIST2_ITERATOR *li); 
00586    
00587   const GWEN_XMLNODE *GWEN_XMLNode_ConstList2Iterator_Previous(GWEN_XMLNODE_CONSTLIST2_ITERATOR *li); 
00588    
00589   const GWEN_XMLNODE *GWEN_XMLNode_ConstList2Iterator_Next(GWEN_XMLNODE_CONSTLIST2_ITERATOR *li); 
00590    
00591   const GWEN_XMLNODE *GWEN_XMLNode_ConstList2Iterator_Data(GWEN_XMLNODE_CONSTLIST2_ITERATOR *li); 
00592    
00604   const GWEN_XMLNODE *GWEN_XMLNode_ConstList2_ForEach(GWEN_XMLNODE_CONSTLIST2 *list,
00605         GWEN_XMLNODE_CONSTLIST2_FOREACH func, void *user_data);
00606 
00607 
00608 #ifdef __cplusplus
00609 }
00610 #endif
00611 
00612 
00613 #endif /* GWEN_XMLNODE_LIST_H */
00614 
00615 
00616 
00617 /***************************************************************************
00618  $RCSfile$
00619  -------------------
00620  cvs         : $Id$
00621  begin       : Sat Jun 28 2003
00622  copyright   : (C) 2003 by Martin Preuss
00623  email       : martin@libchipcard.de
00624 
00625  ***************************************************************************
00626  *                                                                         *
00627  *   This library is free software; you can redistribute it and/or         *
00628  *   modify it under the terms of the GNU Lesser General Public            *
00629  *   License as published by the Free Software Foundation; either          *
00630  *   version 2.1 of the License, or (at your option) any later version.    *
00631  *                                                                         *
00632  *   This library is distributed in the hope that it will be useful,       *
00633  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
00634  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
00635  *   Lesser General Public License for more details.                       *
00636  *                                                                         *
00637  *   You should have received a copy of the GNU Lesser General Public      *
00638  *   License along with this library; if not, write to the Free Software   *
00639  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
00640  *   MA  02111-1307  USA                                                   *
00641  *                                                                         *
00642  ***************************************************************************/
00643 
00644 
00645 #ifndef GWEN_XMLNODE_LIST1_H
00646 #define GWEN_XMLNODE_LIST1_H
00647 
00648 #ifdef __cplusplus
00649 extern "C" {
00650 #endif
00651 
00653   typedef struct GWEN_XMLNODE_LIST_ELEMENT {
00654     uint32_t id;
00655     GWEN_XMLNODE *nextObject;
00656   } GWEN_XMLNODE_LIST__ELEMENT;
00657 
00664   typedef struct GWEN_XMLNODE_LIST GWEN_XMLNODE_LIST;
00666   struct GWEN_XMLNODE_LIST {
00667     GWEN_XMLNODE *first;
00668     uint32_t count;
00669     uint32_t id;
00670   } GWEN_XMLNODE_LIST;
00671 
00676   void GWEN_XMLNode_List_AddList(GWEN_XMLNODE_LIST *dst, GWEN_XMLNODE_LIST *l);
00677 
00681   void GWEN_XMLNode_List_Add(GWEN_XMLNODE *element, GWEN_XMLNODE_LIST *list);
00682 
00687   void GWEN_XMLNode_List_Insert(GWEN_XMLNODE *element, GWEN_XMLNODE_LIST *list);
00688 
00695   void GWEN_XMLNode_List_Del(GWEN_XMLNODE *element);
00696 
00700   GWEN_XMLNODE* GWEN_XMLNode_List_First(const GWEN_XMLNODE_LIST *l);
00701 
00705   GWEN_XMLNODE* GWEN_XMLNode_List_Last(const GWEN_XMLNODE_LIST *l);
00706 
00711   void GWEN_XMLNode_List_Clear(GWEN_XMLNODE_LIST *l);
00712 
00716   GWEN_XMLNODE_LIST* GWEN_XMLNode_List_new();
00717 
00721   void GWEN_XMLNode_List_free(GWEN_XMLNODE_LIST *l);
00722 
00726   GWEN_XMLNODE* GWEN_XMLNode_List_Next(const GWEN_XMLNODE *element);
00727 
00731   GWEN_XMLNODE* GWEN_XMLNode_List_Previous(const GWEN_XMLNODE *element);
00732 
00736   uint32_t GWEN_XMLNode_List_GetCount(const GWEN_XMLNODE_LIST *l);
00737 
00738 #ifdef __cplusplus
00739 }
00740 #endif
00741 
00742 
00743 #endif
00744 
00745 
00746 
00747 /***************************************************************************
00748  $RCSfile$
00749  -------------------
00750  cvs         : $Id$
00751  begin       : Sat Jun 28 2003
00752  copyright   : (C) 2003 by Martin Preuss
00753  email       : martin@libchipcard.de
00754 
00755  ***************************************************************************
00756  *                                                                         *
00757  *   This library is free software; you can redistribute it and/or         *
00758  *   modify it under the terms of the GNU Lesser General Public            *
00759  *   License as published by the Free Software Foundation; either          *
00760  *   version 2.1 of the License, or (at your option) any later version.    *
00761  *                                                                         *
00762  *   This library is distributed in the hope that it will be useful,       *
00763  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
00764  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
00765  *   Lesser General Public License for more details.                       *
00766  *                                                                         *
00767  *   You should have received a copy of the GNU Lesser General Public      *
00768  *   License along with this library; if not, write to the Free Software   *
00769  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
00770  *   MA  02111-1307  USA                                                   *
00771  *                                                                         *
00772  ***************************************************************************/
00773 
00774 
00775 #ifndef GWEN_CRYPT_TOKEN_LIST2_H
00776 #define GWEN_CRYPT_TOKEN_LIST2_H
00777 
00778 
00779 #ifdef __cplusplus
00780 extern "C" {
00781 #endif
00782 
00789   typedef struct GWEN_CRYPT_TOKEN_LIST2 GWEN_CRYPT_TOKEN_LIST2;
00790 
00794   typedef struct GWEN_CRYPT_TOKEN_LIST2_ITERATOR GWEN_CRYPT_TOKEN_LIST2_ITERATOR;
00795 
00799   typedef GWEN_CRYPT_TOKEN* (GWEN_CRYPT_TOKEN_LIST2_FOREACH)(GWEN_CRYPT_TOKEN *element,
00800                                                  void *user_data);
00801 
00805   GWEN_CRYPT_TOKEN_LIST2 *GWEN_Crypt_Token_List2_new(); 
00806 
00810   void GWEN_Crypt_Token_List2_free(GWEN_CRYPT_TOKEN_LIST2 *l); 
00811 
00815   void GWEN_Crypt_Token_List2_Dump(GWEN_CRYPT_TOKEN_LIST2 *l, FILE *f, unsigned int indent); 
00816 
00820   void GWEN_Crypt_Token_List2_PushBack(GWEN_CRYPT_TOKEN_LIST2 *l, GWEN_CRYPT_TOKEN *p); 
00821    
00826   void GWEN_Crypt_Token_List2_PushFront(GWEN_CRYPT_TOKEN_LIST2 *l, GWEN_CRYPT_TOKEN *p); 
00827 
00832   GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_List2_GetFront(GWEN_CRYPT_TOKEN_LIST2 *l); 
00833    
00838   GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_List2_GetBack(GWEN_CRYPT_TOKEN_LIST2 *l); 
00839 
00844   void GWEN_Crypt_Token_List2_Erase(GWEN_CRYPT_TOKEN_LIST2 *l,
00845                                GWEN_CRYPT_TOKEN_LIST2_ITERATOR *it);
00846 
00852   unsigned int GWEN_Crypt_Token_List2_GetSize(GWEN_CRYPT_TOKEN_LIST2 *l); 
00853 
00858   void GWEN_Crypt_Token_List2_PopBack(GWEN_CRYPT_TOKEN_LIST2 *l); 
00859    
00864   void GWEN_Crypt_Token_List2_PopFront(GWEN_CRYPT_TOKEN_LIST2 *l); 
00865 
00869   void GWEN_Crypt_Token_List2_Clear(GWEN_CRYPT_TOKEN_LIST2 *l); 
00870 
00874   GWEN_CRYPT_TOKEN_LIST2_ITERATOR *GWEN_Crypt_Token_List2_First(GWEN_CRYPT_TOKEN_LIST2 *l); 
00875    
00879   GWEN_CRYPT_TOKEN_LIST2_ITERATOR *GWEN_Crypt_Token_List2_Last(GWEN_CRYPT_TOKEN_LIST2 *l); 
00880 
00884   GWEN_CRYPT_TOKEN_LIST2_ITERATOR *GWEN_Crypt_Token_List2Iterator_new(GWEN_CRYPT_TOKEN_LIST2 *l);
00885 
00889   void GWEN_Crypt_Token_List2Iterator_free(GWEN_CRYPT_TOKEN_LIST2_ITERATOR *li); 
00890 
00895   GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_List2Iterator_Previous(GWEN_CRYPT_TOKEN_LIST2_ITERATOR *li); 
00896    
00901   GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_List2Iterator_Next(GWEN_CRYPT_TOKEN_LIST2_ITERATOR *li); 
00902 
00907   GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_List2Iterator_Data(GWEN_CRYPT_TOKEN_LIST2_ITERATOR *li); 
00908 
00920   GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_List2_ForEach(GWEN_CRYPT_TOKEN_LIST2 *list,
00921                                         GWEN_CRYPT_TOKEN_LIST2_FOREACH func,
00922                                         void *user_data);
00923 
00924 
00925   typedef struct GWEN_CRYPT_TOKEN_CONSTLIST2 GWEN_CRYPT_TOKEN_CONSTLIST2; 
00926   typedef struct GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR; 
00927   typedef const GWEN_CRYPT_TOKEN*
00928     (GWEN_CRYPT_TOKEN_CONSTLIST2_FOREACH)(const GWEN_CRYPT_TOKEN *element,
00929                                     void *user_data);
00930   
00931    
00932   GWEN_CRYPT_TOKEN_CONSTLIST2 *GWEN_Crypt_Token_ConstList2_new(); 
00933    
00934   void GWEN_Crypt_Token_ConstList2_free(GWEN_CRYPT_TOKEN_CONSTLIST2 *l); 
00935    
00936   void GWEN_Crypt_Token_ConstList2_PushBack(GWEN_CRYPT_TOKEN_CONSTLIST2 *l, const GWEN_CRYPT_TOKEN *p); 
00937    
00938   void GWEN_Crypt_Token_ConstList2_PushFront(GWEN_CRYPT_TOKEN_CONSTLIST2 *l, const GWEN_CRYPT_TOKEN *p); 
00939    
00940   const GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_ConstList2_GetFront(GWEN_CRYPT_TOKEN_CONSTLIST2 *l); 
00941    
00942   const GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_ConstList2_GetBack(GWEN_CRYPT_TOKEN_CONSTLIST2 *l); 
00943    
00944   unsigned int GWEN_Crypt_Token_ConstList2_GetSize(GWEN_CRYPT_TOKEN_CONSTLIST2 *l); 
00945    
00946   void GWEN_Crypt_Token_ConstList2_PopBack(GWEN_CRYPT_TOKEN_CONSTLIST2 *l); 
00947    
00948   void GWEN_Crypt_Token_ConstList2_PopFront(GWEN_CRYPT_TOKEN_CONSTLIST2 *l); 
00949    
00950   void GWEN_Crypt_Token_ConstList2_Clear(GWEN_CRYPT_TOKEN_CONSTLIST2 *l); 
00951    
00952   GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_ConstList2_First(GWEN_CRYPT_TOKEN_CONSTLIST2 *l); 
00953    
00954   GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_ConstList2_Last(GWEN_CRYPT_TOKEN_CONSTLIST2 *l); 
00955    
00956   GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_ConstList2Iterator_new(GWEN_CRYPT_TOKEN_CONSTLIST2 *l); 
00957    
00958   void GWEN_Crypt_Token_ConstList2Iterator_free(GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *li); 
00959    
00960   const GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_ConstList2Iterator_Previous(GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *li); 
00961    
00962   const GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_ConstList2Iterator_Next(GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *li); 
00963    
00964   const GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_ConstList2Iterator_Data(GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *li); 
00965    
00977   const GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_ConstList2_ForEach(GWEN_CRYPT_TOKEN_CONSTLIST2 *list,
00978         GWEN_CRYPT_TOKEN_CONSTLIST2_FOREACH func, void *user_data);
00979 
00980 
00981 #ifdef __cplusplus
00982 }
00983 #endif
00984 
00985 
00986 #endif /* GWEN_CRYPT_TOKEN_LIST_H */
00987 
00988 
00989 
00990 /***************************************************************************
00991  $RCSfile$
00992  -------------------
00993  cvs         : $Id$
00994  begin       : Sat Jun 28 2003
00995  copyright   : (C) 2003 by Martin Preuss
00996  email       : martin@libchipcard.de
00997 
00998  ***************************************************************************
00999  *                                                                         *
01000  *   This library is free software; you can redistribute it and/or         *
01001  *   modify it under the terms of the GNU Lesser General Public            *
01002  *   License as published by the Free Software Foundation; either          *
01003  *   version 2.1 of the License, or (at your option) any later version.    *
01004  *                                                                         *
01005  *   This library is distributed in the hope that it will be useful,       *
01006  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
01007  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
01008  *   Lesser General Public License for more details.                       *
01009  *                                                                         *
01010  *   You should have received a copy of the GNU Lesser General Public      *
01011  *   License along with this library; if not, write to the Free Software   *
01012  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
01013  *   MA  02111-1307  USA                                                   *
01014  *                                                                         *
01015  ***************************************************************************/
01016 
01017 
01018 #ifndef GWEN_CRYPT_TOKEN_LIST1_H
01019 #define GWEN_CRYPT_TOKEN_LIST1_H
01020 
01021 #ifdef __cplusplus
01022 extern "C" {
01023 #endif
01024 
01026   typedef struct GWEN_CRYPT_TOKEN_LIST_ELEMENT {
01027     uint32_t id;
01028     GWEN_CRYPT_TOKEN *nextObject;
01029   } GWEN_CRYPT_TOKEN_LIST__ELEMENT;
01030 
01037   typedef struct GWEN_CRYPT_TOKEN_LIST GWEN_CRYPT_TOKEN_LIST;
01039   struct GWEN_CRYPT_TOKEN_LIST {
01040     GWEN_CRYPT_TOKEN *first;
01041     uint32_t count;
01042     uint32_t id;
01043   } GWEN_CRYPT_TOKEN_LIST;
01044 
01049   void GWEN_Crypt_Token_List_AddList(GWEN_CRYPT_TOKEN_LIST *dst, GWEN_CRYPT_TOKEN_LIST *l);
01050 
01054   void GWEN_Crypt_Token_List_Add(GWEN_CRYPT_TOKEN *element, GWEN_CRYPT_TOKEN_LIST *list);
01055 
01060   void GWEN_Crypt_Token_List_Insert(GWEN_CRYPT_TOKEN *element, GWEN_CRYPT_TOKEN_LIST *list);
01061 
01068   void GWEN_Crypt_Token_List_Del(GWEN_CRYPT_TOKEN *element);
01069 
01073   GWEN_CRYPT_TOKEN* GWEN_Crypt_Token_List_First(const GWEN_CRYPT_TOKEN_LIST *l);
01074 
01078   GWEN_CRYPT_TOKEN* GWEN_Crypt_Token_List_Last(const GWEN_CRYPT_TOKEN_LIST *l);
01079 
01084   void GWEN_Crypt_Token_List_Clear(GWEN_CRYPT_TOKEN_LIST *l);
01085 
01089   GWEN_CRYPT_TOKEN_LIST* GWEN_Crypt_Token_List_new();
01090 
01094   void GWEN_Crypt_Token_List_free(GWEN_CRYPT_TOKEN_LIST *l);
01095 
01099   GWEN_CRYPT_TOKEN* GWEN_Crypt_Token_List_Next(const GWEN_CRYPT_TOKEN *element);
01100 
01104   GWEN_CRYPT_TOKEN* GWEN_Crypt_Token_List_Previous(const GWEN_CRYPT_TOKEN *element);
01105 
01109   uint32_t GWEN_Crypt_Token_List_GetCount(const GWEN_CRYPT_TOKEN_LIST *l);
01110 
01111 #ifdef __cplusplus
01112 }
01113 #endif
01114 
01115 
01116 #endif
01117 
01118 
01119 
01120 /***************************************************************************
01121  $RCSfile$
01122  -------------------
01123  cvs         : $Id$
01124  begin       : Sat Jun 28 2003
01125  copyright   : (C) 2003 by Martin Preuss
01126  email       : martin@libchipcard.de
01127 
01128  ***************************************************************************
01129  *                                                                         *
01130  *   This library is free software; you can redistribute it and/or         *
01131  *   modify it under the terms of the GNU Lesser General Public            *
01132  *   License as published by the Free Software Foundation; either          *
01133  *   version 2.1 of the License, or (at your option) any later version.    *
01134  *                                                                         *
01135  *   This library is distributed in the hope that it will be useful,       *
01136  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
01137  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
01138  *   Lesser General Public License for more details.                       *
01139  *                                                                         *
01140  *   You should have received a copy of the GNU Lesser General Public      *
01141  *   License along with this library; if not, write to the Free Software   *
01142  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
01143  *   MA  02111-1307  USA                                                   *
01144  *                                                                         *
01145  ***************************************************************************/
01146 
01147 
01148 #ifndef GWEN_IO_LAYER_LIST2_H
01149 #define GWEN_IO_LAYER_LIST2_H
01150 
01151 
01152 #ifdef __cplusplus
01153 extern "C" {
01154 #endif
01155 
01162   typedef struct GWEN_IO_LAYER_LIST2 GWEN_IO_LAYER_LIST2;
01163 
01167   typedef struct GWEN_IO_LAYER_LIST2_ITERATOR GWEN_IO_LAYER_LIST2_ITERATOR;
01168 
01172   typedef GWEN_IO_LAYER* (GWEN_IO_LAYER_LIST2_FOREACH)(GWEN_IO_LAYER *element,
01173                                                  void *user_data);
01174 
01178   GWEN_IO_LAYER_LIST2 *GWEN_Io_Layer_List2_new(); 
01179 
01183   void GWEN_Io_Layer_List2_free(GWEN_IO_LAYER_LIST2 *l); 
01184 
01188   void GWEN_Io_Layer_List2_Dump(GWEN_IO_LAYER_LIST2 *l, FILE *f, unsigned int indent); 
01189 
01193   void GWEN_Io_Layer_List2_PushBack(GWEN_IO_LAYER_LIST2 *l, GWEN_IO_LAYER *p); 
01194    
01199   void GWEN_Io_Layer_List2_PushFront(GWEN_IO_LAYER_LIST2 *l, GWEN_IO_LAYER *p); 
01200 
01205   GWEN_IO_LAYER *GWEN_Io_Layer_List2_GetFront(GWEN_IO_LAYER_LIST2 *l); 
01206    
01211   GWEN_IO_LAYER *GWEN_Io_Layer_List2_GetBack(GWEN_IO_LAYER_LIST2 *l); 
01212 
01217   void GWEN_Io_Layer_List2_Erase(GWEN_IO_LAYER_LIST2 *l,
01218                                GWEN_IO_LAYER_LIST2_ITERATOR *it);
01219 
01225   unsigned int GWEN_Io_Layer_List2_GetSize(GWEN_IO_LAYER_LIST2 *l); 
01226 
01231   void GWEN_Io_Layer_List2_PopBack(GWEN_IO_LAYER_LIST2 *l); 
01232    
01237   void GWEN_Io_Layer_List2_PopFront(GWEN_IO_LAYER_LIST2 *l); 
01238 
01242   void GWEN_Io_Layer_List2_Clear(GWEN_IO_LAYER_LIST2 *l); 
01243 
01247   GWEN_IO_LAYER_LIST2_ITERATOR *GWEN_Io_Layer_List2_First(GWEN_IO_LAYER_LIST2 *l); 
01248    
01252   GWEN_IO_LAYER_LIST2_ITERATOR *GWEN_Io_Layer_List2_Last(GWEN_IO_LAYER_LIST2 *l); 
01253 
01257   GWEN_IO_LAYER_LIST2_ITERATOR *GWEN_Io_Layer_List2Iterator_new(GWEN_IO_LAYER_LIST2 *l);
01258 
01262   void GWEN_Io_Layer_List2Iterator_free(GWEN_IO_LAYER_LIST2_ITERATOR *li); 
01263 
01268   GWEN_IO_LAYER *GWEN_Io_Layer_List2Iterator_Previous(GWEN_IO_LAYER_LIST2_ITERATOR *li); 
01269    
01274   GWEN_IO_LAYER *GWEN_Io_Layer_List2Iterator_Next(GWEN_IO_LAYER_LIST2_ITERATOR *li); 
01275 
01280   GWEN_IO_LAYER *GWEN_Io_Layer_List2Iterator_Data(GWEN_IO_LAYER_LIST2_ITERATOR *li); 
01281 
01293   GWEN_IO_LAYER *GWEN_Io_Layer_List2_ForEach(GWEN_IO_LAYER_LIST2 *list,
01294                                         GWEN_IO_LAYER_LIST2_FOREACH func,
01295                                         void *user_data);
01296 
01297 
01298   typedef struct GWEN_IO_LAYER_CONSTLIST2 GWEN_IO_LAYER_CONSTLIST2; 
01299   typedef struct GWEN_IO_LAYER_CONSTLIST2_ITERATOR GWEN_IO_LAYER_CONSTLIST2_ITERATOR; 
01300   typedef const GWEN_IO_LAYER*
01301     (GWEN_IO_LAYER_CONSTLIST2_FOREACH)(const GWEN_IO_LAYER *element,
01302                                     void *user_data);
01303   
01304    
01305   GWEN_IO_LAYER_CONSTLIST2 *GWEN_Io_Layer_ConstList2_new(); 
01306    
01307   void GWEN_Io_Layer_ConstList2_free(GWEN_IO_LAYER_CONSTLIST2 *l); 
01308    
01309   void GWEN_Io_Layer_ConstList2_PushBack(GWEN_IO_LAYER_CONSTLIST2 *l, const GWEN_IO_LAYER *p); 
01310    
01311   void GWEN_Io_Layer_ConstList2_PushFront(GWEN_IO_LAYER_CONSTLIST2 *l, const GWEN_IO_LAYER *p); 
01312    
01313   const GWEN_IO_LAYER *GWEN_Io_Layer_ConstList2_GetFront(GWEN_IO_LAYER_CONSTLIST2 *l); 
01314    
01315   const GWEN_IO_LAYER *GWEN_Io_Layer_ConstList2_GetBack(GWEN_IO_LAYER_CONSTLIST2 *l); 
01316    
01317   unsigned int GWEN_Io_Layer_ConstList2_GetSize(GWEN_IO_LAYER_CONSTLIST2 *l); 
01318    
01319   void GWEN_Io_Layer_ConstList2_PopBack(GWEN_IO_LAYER_CONSTLIST2 *l); 
01320    
01321   void GWEN_Io_Layer_ConstList2_PopFront(GWEN_IO_LAYER_CONSTLIST2 *l); 
01322    
01323   void GWEN_Io_Layer_ConstList2_Clear(GWEN_IO_LAYER_CONSTLIST2 *l); 
01324    
01325   GWEN_IO_LAYER_CONSTLIST2_ITERATOR *GWEN_Io_Layer_ConstList2_First(GWEN_IO_LAYER_CONSTLIST2 *l); 
01326    
01327   GWEN_IO_LAYER_CONSTLIST2_ITERATOR *GWEN_Io_Layer_ConstList2_Last(GWEN_IO_LAYER_CONSTLIST2 *l); 
01328    
01329   GWEN_IO_LAYER_CONSTLIST2_ITERATOR *GWEN_Io_Layer_ConstList2Iterator_new(GWEN_IO_LAYER_CONSTLIST2 *l); 
01330    
01331   void GWEN_Io_Layer_ConstList2Iterator_free(GWEN_IO_LAYER_CONSTLIST2_ITERATOR *li); 
01332    
01333   const GWEN_IO_LAYER *GWEN_Io_Layer_ConstList2Iterator_Previous(GWEN_IO_LAYER_CONSTLIST2_ITERATOR *li); 
01334    
01335   const GWEN_IO_LAYER *GWEN_Io_Layer_ConstList2Iterator_Next(GWEN_IO_LAYER_CONSTLIST2_ITERATOR *li); 
01336    
01337   const GWEN_IO_LAYER *GWEN_Io_Layer_ConstList2Iterator_Data(GWEN_IO_LAYER_CONSTLIST2_ITERATOR *li); 
01338    
01350   const GWEN_IO_LAYER *GWEN_Io_Layer_ConstList2_ForEach(GWEN_IO_LAYER_CONSTLIST2 *list,
01351         GWEN_IO_LAYER_CONSTLIST2_FOREACH func, void *user_data);
01352 
01353 
01354 #ifdef __cplusplus
01355 }
01356 #endif
01357 
01358 
01359 #endif /* GWEN_IO_LAYER_LIST_H */
01360 
01361 
01362 
01363 /***************************************************************************
01364  $RCSfile$
01365  -------------------
01366  cvs         : $Id$
01367  begin       : Sat Jun 28 2003
01368  copyright   : (C) 2003 by Martin Preuss
01369  email       : martin@libchipcard.de
01370 
01371  ***************************************************************************
01372  *                                                                         *
01373  *   This library is free software; you can redistribute it and/or         *
01374  *   modify it under the terms of the GNU Lesser General Public            *
01375  *   License as published by the Free Software Foundation; either          *
01376  *   version 2.1 of the License, or (at your option) any later version.    *
01377  *                                                                         *
01378  *   This library is distributed in the hope that it will be useful,       *
01379  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
01380  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
01381  *   Lesser General Public License for more details.                       *
01382  *                                                                         *
01383  *   You should have received a copy of the GNU Lesser General Public      *
01384  *   License along with this library; if not, write to the Free Software   *
01385  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
01386  *   MA  02111-1307  USA                                                   *
01387  *                                                                         *
01388  ***************************************************************************/
01389 
01390 
01391 #ifndef GWEN_CRYPT_HASHALGO_LIST2_H
01392 #define GWEN_CRYPT_HASHALGO_LIST2_H
01393 
01394 
01395 #ifdef __cplusplus
01396 extern "C" {
01397 #endif
01398 
01405   typedef struct GWEN_CRYPT_HASHALGO_LIST2 GWEN_CRYPT_HASHALGO_LIST2;
01406 
01410   typedef struct GWEN_CRYPT_HASHALGO_LIST2_ITERATOR GWEN_CRYPT_HASHALGO_LIST2_ITERATOR;
01411 
01415   typedef GWEN_CRYPT_HASHALGO* (GWEN_CRYPT_HASHALGO_LIST2_FOREACH)(GWEN_CRYPT_HASHALGO *element,
01416                                                  void *user_data);
01417 
01421   GWEN_CRYPT_HASHALGO_LIST2 *GWEN_Crypt_HashAlgo_List2_new(); 
01422 
01426   void GWEN_Crypt_HashAlgo_List2_free(GWEN_CRYPT_HASHALGO_LIST2 *l); 
01427 
01431   void GWEN_Crypt_HashAlgo_List2_Dump(GWEN_CRYPT_HASHALGO_LIST2 *l, FILE *f, unsigned int indent); 
01432 
01436   void GWEN_Crypt_HashAlgo_List2_PushBack(GWEN_CRYPT_HASHALGO_LIST2 *l, GWEN_CRYPT_HASHALGO *p); 
01437    
01442   void GWEN_Crypt_HashAlgo_List2_PushFront(GWEN_CRYPT_HASHALGO_LIST2 *l, GWEN_CRYPT_HASHALGO *p); 
01443 
01448   GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_List2_GetFront(GWEN_CRYPT_HASHALGO_LIST2 *l); 
01449    
01454   GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_List2_GetBack(GWEN_CRYPT_HASHALGO_LIST2 *l); 
01455 
01460   void GWEN_Crypt_HashAlgo_List2_Erase(GWEN_CRYPT_HASHALGO_LIST2 *l,
01461                                GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *it);
01462 
01468   unsigned int GWEN_Crypt_HashAlgo_List2_GetSize(GWEN_CRYPT_HASHALGO_LIST2 *l); 
01469 
01474   void GWEN_Crypt_HashAlgo_List2_PopBack(GWEN_CRYPT_HASHALGO_LIST2 *l); 
01475    
01480   void GWEN_Crypt_HashAlgo_List2_PopFront(GWEN_CRYPT_HASHALGO_LIST2 *l); 
01481 
01485   void GWEN_Crypt_HashAlgo_List2_Clear(GWEN_CRYPT_HASHALGO_LIST2 *l); 
01486 
01490   GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *GWEN_Crypt_HashAlgo_List2_First(GWEN_CRYPT_HASHALGO_LIST2 *l); 
01491    
01495   GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *GWEN_Crypt_HashAlgo_List2_Last(GWEN_CRYPT_HASHALGO_LIST2 *l); 
01496 
01500   GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *GWEN_Crypt_HashAlgo_List2Iterator_new(GWEN_CRYPT_HASHALGO_LIST2 *l);
01501 
01505   void GWEN_Crypt_HashAlgo_List2Iterator_free(GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *li); 
01506 
01511   GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_List2Iterator_Previous(GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *li); 
01512    
01517   GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_List2Iterator_Next(GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *li); 
01518 
01523   GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_List2Iterator_Data(GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *li); 
01524 
01536   GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_List2_ForEach(GWEN_CRYPT_HASHALGO_LIST2 *list,
01537                                         GWEN_CRYPT_HASHALGO_LIST2_FOREACH func,
01538                                         void *user_data);
01539 
01540 
01541   typedef struct GWEN_CRYPT_HASHALGO_CONSTLIST2 GWEN_CRYPT_HASHALGO_CONSTLIST2; 
01542   typedef struct GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR; 
01543   typedef const GWEN_CRYPT_HASHALGO*
01544     (GWEN_CRYPT_HASHALGO_CONSTLIST2_FOREACH)(const GWEN_CRYPT_HASHALGO *element,
01545                                     void *user_data);
01546   
01547    
01548   GWEN_CRYPT_HASHALGO_CONSTLIST2 *GWEN_Crypt_HashAlgo_ConstList2_new(); 
01549    
01550   void GWEN_Crypt_HashAlgo_ConstList2_free(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l); 
01551    
01552   void GWEN_Crypt_HashAlgo_ConstList2_PushBack(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l, const GWEN_CRYPT_HASHALGO *p); 
01553    
01554   void GWEN_Crypt_HashAlgo_ConstList2_PushFront(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l, const GWEN_CRYPT_HASHALGO *p); 
01555    
01556   const GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_ConstList2_GetFront(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l); 
01557    
01558   const GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_ConstList2_GetBack(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l); 
01559    
01560   unsigned int GWEN_Crypt_HashAlgo_ConstList2_GetSize(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l); 
01561    
01562   void GWEN_Crypt_HashAlgo_ConstList2_PopBack(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l); 
01563    
01564   void GWEN_Crypt_HashAlgo_ConstList2_PopFront(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l); 
01565    
01566   void GWEN_Crypt_HashAlgo_ConstList2_Clear(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l); 
01567    
01568   GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_HashAlgo_ConstList2_First(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l); 
01569    
01570   GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_HashAlgo_ConstList2_Last(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l); 
01571    
01572   GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_HashAlgo_ConstList2Iterator_new(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l); 
01573    
01574   void GWEN_Crypt_HashAlgo_ConstList2Iterator_free(GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR *li); 
01575    
01576   const GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_ConstList2Iterator_Previous(GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR *li); 
01577    
01578   const GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_ConstList2Iterator_Next(GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR *li); 
01579    
01580   const GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_ConstList2Iterator_Data(GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR *li); 
01581    
01593   const GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_ConstList2_ForEach(GWEN_CRYPT_HASHALGO_CONSTLIST2 *list,
01594         GWEN_CRYPT_HASHALGO_CONSTLIST2_FOREACH func, void *user_data);
01595 
01596 
01597 #ifdef __cplusplus
01598 }
01599 #endif
01600 
01601 
01602 #endif /* GWEN_CRYPT_HASHALGO_LIST_H */
01603 
01604 
01605 
01606 /***************************************************************************
01607  $RCSfile$
01608  -------------------
01609  cvs         : $Id$
01610  begin       : Sat Jun 28 2003
01611  copyright   : (C) 2003 by Martin Preuss
01612  email       : martin@libchipcard.de
01613 
01614  ***************************************************************************
01615  *                                                                         *
01616  *   This library is free software; you can redistribute it and/or         *
01617  *   modify it under the terms of the GNU Lesser General Public            *
01618  *   License as published by the Free Software Foundation; either          *
01619  *   version 2.1 of the License, or (at your option) any later version.    *
01620  *                                                                         *
01621  *   This library is distributed in the hope that it will be useful,       *
01622  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
01623  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
01624  *   Lesser General Public License for more details.                       *
01625  *                                                                         *
01626  *   You should have received a copy of the GNU Lesser General Public      *
01627  *   License along with this library; if not, write to the Free Software   *
01628  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
01629  *   MA  02111-1307  USA                                                   *
01630  *                                                                         *
01631  ***************************************************************************/
01632 
01633 
01634 #ifndef GWEN_TLV_LIST1_H
01635 #define GWEN_TLV_LIST1_H
01636 
01637 #ifdef __cplusplus
01638 extern "C" {
01639 #endif
01640 
01642   typedef struct GWEN_TLV_LIST_ELEMENT {
01643     uint32_t id;
01644     GWEN_TLV *nextObject;
01645   } GWEN_TLV_LIST__ELEMENT;
01646 
01653   typedef struct GWEN_TLV_LIST GWEN_TLV_LIST;
01655   struct GWEN_TLV_LIST {
01656     GWEN_TLV *first;
01657     uint32_t count;
01658     uint32_t id;
01659   } GWEN_TLV_LIST;
01660 
01665   void GWEN_TLV_List_AddList(GWEN_TLV_LIST *dst, GWEN_TLV_LIST *l);
01666 
01670   void GWEN_TLV_List_Add(GWEN_TLV *element, GWEN_TLV_LIST *list);
01671 
01676   void GWEN_TLV_List_Insert(GWEN_TLV *element, GWEN_TLV_LIST *list);
01677 
01684   void GWEN_TLV_List_Del(GWEN_TLV *element);
01685 
01689   GWEN_TLV* GWEN_TLV_List_First(const GWEN_TLV_LIST *l);
01690 
01694   GWEN_TLV* GWEN_TLV_List_Last(const GWEN_TLV_LIST *l);
01695 
01700   void GWEN_TLV_List_Clear(GWEN_TLV_LIST *l);
01701 
01705   GWEN_TLV_LIST* GWEN_TLV_List_new();
01706 
01710   void GWEN_TLV_List_free(GWEN_TLV_LIST *l);
01711 
01715   GWEN_TLV* GWEN_TLV_List_Next(const GWEN_TLV *element);
01716 
01720   GWEN_TLV* GWEN_TLV_List_Previous(const GWEN_TLV *element);
01721 
01725   uint32_t GWEN_TLV_List_GetCount(const GWEN_TLV_LIST *l);
01726 
01727 #ifdef __cplusplus
01728 }
01729 #endif
01730 
01731 
01732 #endif
01733 
01734 
01735 
01736 /***************************************************************************
01737  $RCSfile$
01738  -------------------
01739  cvs         : $Id$
01740  begin       : Sat Jun 28 2003
01741  copyright   : (C) 2003 by Martin Preuss
01742  email       : martin@libchipcard.de
01743 
01744  ***************************************************************************
01745  *                                                                         *
01746  *   This library is free software; you can redistribute it and/or         *
01747  *   modify it under the terms of the GNU Lesser General Public            *
01748  *   License as published by the Free Software Foundation; either          *
01749  *   version 2.1 of the License, or (at your option) any later version.    *
01750  *                                                                         *
01751  *   This library is distributed in the hope that it will be useful,       *
01752  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
01753  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
01754  *   Lesser General Public License for more details.                       *
01755  *                                                                         *
01756  *   You should have received a copy of the GNU Lesser General Public      *
01757  *   License along with this library; if not, write to the Free Software   *
01758  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
01759  *   MA  02111-1307  USA                                                   *
01760  *                                                                         *
01761  ***************************************************************************/
01762 
01763 
01764 #ifndef GWEN_FSLOCK_LIST2_H
01765 #define GWEN_FSLOCK_LIST2_H
01766 
01767 
01768 #ifdef __cplusplus
01769 extern "C" {
01770 #endif
01771 
01778   typedef struct GWEN_FSLOCK_LIST2 GWEN_FSLOCK_LIST2;
01779 
01783   typedef struct GWEN_FSLOCK_LIST2_ITERATOR GWEN_FSLOCK_LIST2_ITERATOR;
01784 
01788   typedef GWEN_FSLOCK* (GWEN_FSLOCK_LIST2_FOREACH)(GWEN_FSLOCK *element,
01789                                                  void *user_data);
01790 
01794   GWEN_FSLOCK_LIST2 *GWEN_FSLock_List2_new(); 
01795 
01799   void GWEN_FSLock_List2_free(GWEN_FSLOCK_LIST2 *l); 
01800 
01804   void GWEN_FSLock_List2_Dump(GWEN_FSLOCK_LIST2 *l, FILE *f, unsigned int indent); 
01805 
01809   void GWEN_FSLock_List2_PushBack(GWEN_FSLOCK_LIST2 *l, GWEN_FSLOCK *p); 
01810    
01815   void GWEN_FSLock_List2_PushFront(GWEN_FSLOCK_LIST2 *l, GWEN_FSLOCK *p); 
01816 
01821   GWEN_FSLOCK *GWEN_FSLock_List2_GetFront(GWEN_FSLOCK_LIST2 *l); 
01822    
01827   GWEN_FSLOCK *GWEN_FSLock_List2_GetBack(GWEN_FSLOCK_LIST2 *l); 
01828 
01833   void GWEN_FSLock_List2_Erase(GWEN_FSLOCK_LIST2 *l,
01834                                GWEN_FSLOCK_LIST2_ITERATOR *it);
01835 
01841   unsigned int GWEN_FSLock_List2_GetSize(GWEN_FSLOCK_LIST2 *l); 
01842 
01847   void GWEN_FSLock_List2_PopBack(GWEN_FSLOCK_LIST2 *l); 
01848    
01853   void GWEN_FSLock_List2_PopFront(GWEN_FSLOCK_LIST2 *l); 
01854 
01858   void GWEN_FSLock_List2_Clear(GWEN_FSLOCK_LIST2 *l); 
01859 
01863   GWEN_FSLOCK_LIST2_ITERATOR *GWEN_FSLock_List2_First(GWEN_FSLOCK_LIST2 *l); 
01864    
01868   GWEN_FSLOCK_LIST2_ITERATOR *GWEN_FSLock_List2_Last(GWEN_FSLOCK_LIST2 *l); 
01869 
01873   GWEN_FSLOCK_LIST2_ITERATOR *GWEN_FSLock_List2Iterator_new(GWEN_FSLOCK_LIST2 *l);
01874 
01878   void GWEN_FSLock_List2Iterator_free(GWEN_FSLOCK_LIST2_ITERATOR *li); 
01879 
01884   GWEN_FSLOCK *GWEN_FSLock_List2Iterator_Previous(GWEN_FSLOCK_LIST2_ITERATOR *li); 
01885    
01890   GWEN_FSLOCK *GWEN_FSLock_List2Iterator_Next(GWEN_FSLOCK_LIST2_ITERATOR *li); 
01891 
01896   GWEN_FSLOCK *GWEN_FSLock_List2Iterator_Data(GWEN_FSLOCK_LIST2_ITERATOR *li); 
01897 
01909   GWEN_FSLOCK *GWEN_FSLock_List2_ForEach(GWEN_FSLOCK_LIST2 *list,
01910                                         GWEN_FSLOCK_LIST2_FOREACH func,
01911                                         void *user_data);
01912 
01913 
01914   typedef struct GWEN_FSLOCK_CONSTLIST2 GWEN_FSLOCK_CONSTLIST2; 
01915   typedef struct GWEN_FSLOCK_CONSTLIST2_ITERATOR GWEN_FSLOCK_CONSTLIST2_ITERATOR; 
01916   typedef const GWEN_FSLOCK*
01917     (GWEN_FSLOCK_CONSTLIST2_FOREACH)(const GWEN_FSLOCK *element,
01918                                     void *user_data);
01919   
01920    
01921   GWEN_FSLOCK_CONSTLIST2 *GWEN_FSLock_ConstList2_new(); 
01922    
01923   void GWEN_FSLock_ConstList2_free(GWEN_FSLOCK_CONSTLIST2 *l); 
01924    
01925   void GWEN_FSLock_ConstList2_PushBack(GWEN_FSLOCK_CONSTLIST2 *l, const GWEN_FSLOCK *p); 
01926    
01927   void GWEN_FSLock_ConstList2_PushFront(GWEN_FSLOCK_CONSTLIST2 *l, const GWEN_FSLOCK *p); 
01928    
01929   const GWEN_FSLOCK *GWEN_FSLock_ConstList2_GetFront(GWEN_FSLOCK_CONSTLIST2 *l); 
01930    
01931   const GWEN_FSLOCK *GWEN_FSLock_ConstList2_GetBack(GWEN_FSLOCK_CONSTLIST2 *l); 
01932    
01933   unsigned int GWEN_FSLock_ConstList2_GetSize(GWEN_FSLOCK_CONSTLIST2 *l); 
01934    
01935   void GWEN_FSLock_ConstList2_PopBack(GWEN_FSLOCK_CONSTLIST2 *l); 
01936    
01937   void GWEN_FSLock_ConstList2_PopFront(GWEN_FSLOCK_CONSTLIST2 *l); 
01938    
01939   void GWEN_FSLock_ConstList2_Clear(GWEN_FSLOCK_CONSTLIST2 *l); 
01940    
01941   GWEN_FSLOCK_CONSTLIST2_ITERATOR *GWEN_FSLock_ConstList2_First(GWEN_FSLOCK_CONSTLIST2 *l); 
01942    
01943   GWEN_FSLOCK_CONSTLIST2_ITERATOR *GWEN_FSLock_ConstList2_Last(GWEN_FSLOCK_CONSTLIST2 *l); 
01944    
01945   GWEN_FSLOCK_CONSTLIST2_ITERATOR *GWEN_FSLock_ConstList2Iterator_new(GWEN_FSLOCK_CONSTLIST2 *l); 
01946    
01947   void GWEN_FSLock_ConstList2Iterator_free(GWEN_FSLOCK_CONSTLIST2_ITERATOR *li); 
01948    
01949   const GWEN_FSLOCK *GWEN_FSLock_ConstList2Iterator_Previous(GWEN_FSLOCK_CONSTLIST2_ITERATOR *li); 
01950    
01951   const GWEN_FSLOCK *GWEN_FSLock_ConstList2Iterator_Next(GWEN_FSLOCK_CONSTLIST2_ITERATOR *li); 
01952    
01953   const GWEN_FSLOCK *GWEN_FSLock_ConstList2Iterator_Data(GWEN_FSLOCK_CONSTLIST2_ITERATOR *li); 
01954    
01966   const GWEN_FSLOCK *GWEN_FSLock_ConstList2_ForEach(GWEN_FSLOCK_CONSTLIST2 *list,
01967         GWEN_FSLOCK_CONSTLIST2_FOREACH func, void *user_data);
01968 
01969 
01970 #ifdef __cplusplus
01971 }
01972 #endif
01973 
01974 
01975 #endif /* GWEN_FSLOCK_LIST_H */
01976 
01977 
01978 
01979 /***************************************************************************
01980  $RCSfile$
01981  -------------------
01982  cvs         : $Id$
01983  begin       : Sat Jun 28 2003
01984  copyright   : (C) 2003 by Martin Preuss
01985  email       : martin@libchipcard.de
01986 
01987  ***************************************************************************
01988  *                                                                         *
01989  *   This library is free software; you can redistribute it and/or         *
01990  *   modify it under the terms of the GNU Lesser General Public            *
01991  *   License as published by the Free Software Foundation; either          *
01992  *   version 2.1 of the License, or (at your option) any later version.    *
01993  *                                                                         *
01994  *   This library is distributed in the hope that it will be useful,       *
01995  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
01996  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
01997  *   Lesser General Public License for more details.                       *
01998  *                                                                         *
01999  *   You should have received a copy of the GNU Lesser General Public      *
02000  *   License along with this library; if not, write to the Free Software   *
02001  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
02002  *   MA  02111-1307  USA                                                   *
02003  *                                                                         *
02004  ***************************************************************************/
02005 
02006 
02007 #ifndef GWEN_FSLOCK_LIST1_H
02008 #define GWEN_FSLOCK_LIST1_H
02009 
02010 #ifdef __cplusplus
02011 extern "C" {
02012 #endif
02013 
02015   typedef struct GWEN_FSLOCK_LIST_ELEMENT {
02016     uint32_t id;
02017     GWEN_FSLOCK *nextObject;
02018   } GWEN_FSLOCK_LIST__ELEMENT;
02019 
02026   typedef struct GWEN_FSLOCK_LIST GWEN_FSLOCK_LIST;
02028   struct GWEN_FSLOCK_LIST {
02029     GWEN_FSLOCK *first;
02030     uint32_t count;
02031     uint32_t id;
02032   } GWEN_FSLOCK_LIST;
02033 
02038   void GWEN_FSLock_List_AddList(GWEN_FSLOCK_LIST *dst, GWEN_FSLOCK_LIST *l);
02039 
02043   void GWEN_FSLock_List_Add(GWEN_FSLOCK *element, GWEN_FSLOCK_LIST *list);
02044 
02049   void GWEN_FSLock_List_Insert(GWEN_FSLOCK *element, GWEN_FSLOCK_LIST *list);
02050 
02057   void GWEN_FSLock_List_Del(GWEN_FSLOCK *element);
02058 
02062   GWEN_FSLOCK* GWEN_FSLock_List_First(const GWEN_FSLOCK_LIST *l);
02063 
02067   GWEN_FSLOCK* GWEN_FSLock_List_Last(const GWEN_FSLOCK_LIST *l);
02068 
02073   void GWEN_FSLock_List_Clear(GWEN_FSLOCK_LIST *l);
02074 
02078   GWEN_FSLOCK_LIST* GWEN_FSLock_List_new();
02079 
02083   void GWEN_FSLock_List_free(GWEN_FSLOCK_LIST *l);
02084 
02088   GWEN_FSLOCK* GWEN_FSLock_List_Next(const GWEN_FSLOCK *element);
02089 
02093   GWEN_FSLOCK* GWEN_FSLock_List_Previous(const GWEN_FSLOCK *element);
02094 
02098   uint32_t GWEN_FSLock_List_GetCount(const GWEN_FSLOCK_LIST *l);
02099 
02100 #ifdef __cplusplus
02101 }
02102 #endif
02103 
02104 
02105 #endif
02106 
02107 
02108 
02109 /***************************************************************************
02110  $RCSfile$
02111  -------------------
02112  cvs         : $Id$
02113  begin       : Sat Jun 28 2003
02114  copyright   : (C) 2003 by Martin Preuss
02115  email       : martin@libchipcard.de
02116 
02117  ***************************************************************************
02118  *                                                                         *
02119  *   This library is free software; you can redistribute it and/or         *
02120  *   modify it under the terms of the GNU Lesser General Public            *
02121  *   License as published by the Free Software Foundation; either          *
02122  *   version 2.1 of the License, or (at your option) any later version.    *
02123  *                                                                         *
02124  *   This library is distributed in the hope that it will be useful,       *
02125  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
02126  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
02127  *   Lesser General Public License for more details.                       *
02128  *                                                                         *
02129  *   You should have received a copy of the GNU Lesser General Public      *
02130  *   License along with this library; if not, write to the Free Software   *
02131  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
02132  *   MA  02111-1307  USA                                                   *
02133  *                                                                         *
02134  ***************************************************************************/
02135 
02136 
02137 #ifndef GWEN_IO_REQUEST_LIST2_H
02138 #define GWEN_IO_REQUEST_LIST2_H
02139 
02140 
02141 #ifdef __cplusplus
02142 extern "C" {
02143 #endif
02144 
02151   typedef struct GWEN_IO_REQUEST_LIST2 GWEN_IO_REQUEST_LIST2;
02152 
02156   typedef struct GWEN_IO_REQUEST_LIST2_ITERATOR GWEN_IO_REQUEST_LIST2_ITERATOR;
02157 
02161   typedef GWEN_IO_REQUEST* (GWEN_IO_REQUEST_LIST2_FOREACH)(GWEN_IO_REQUEST *element,
02162                                                  void *user_data);
02163 
02167   GWEN_IO_REQUEST_LIST2 *GWEN_Io_Request_List2_new(); 
02168 
02172   void GWEN_Io_Request_List2_free(GWEN_IO_REQUEST_LIST2 *l); 
02173 
02177   void GWEN_Io_Request_List2_Dump(GWEN_IO_REQUEST_LIST2 *l, FILE *f, unsigned int indent); 
02178 
02182   void GWEN_Io_Request_List2_PushBack(GWEN_IO_REQUEST_LIST2 *l, GWEN_IO_REQUEST *p); 
02183    
02188   void GWEN_Io_Request_List2_PushFront(GWEN_IO_REQUEST_LIST2 *l, GWEN_IO_REQUEST *p); 
02189 
02194   GWEN_IO_REQUEST *GWEN_Io_Request_List2_GetFront(GWEN_IO_REQUEST_LIST2 *l); 
02195    
02200   GWEN_IO_REQUEST *GWEN_Io_Request_List2_GetBack(GWEN_IO_REQUEST_LIST2 *l); 
02201 
02206   void GWEN_Io_Request_List2_Erase(GWEN_IO_REQUEST_LIST2 *l,
02207                                GWEN_IO_REQUEST_LIST2_ITERATOR *it);
02208 
02214   unsigned int GWEN_Io_Request_List2_GetSize(GWEN_IO_REQUEST_LIST2 *l); 
02215 
02220   void GWEN_Io_Request_List2_PopBack(GWEN_IO_REQUEST_LIST2 *l); 
02221    
02226   void GWEN_Io_Request_List2_PopFront(GWEN_IO_REQUEST_LIST2 *l); 
02227 
02231   void GWEN_Io_Request_List2_Clear(GWEN_IO_REQUEST_LIST2 *l); 
02232 
02236   GWEN_IO_REQUEST_LIST2_ITERATOR *GWEN_Io_Request_List2_First(GWEN_IO_REQUEST_LIST2 *l); 
02237    
02241   GWEN_IO_REQUEST_LIST2_ITERATOR *GWEN_Io_Request_List2_Last(GWEN_IO_REQUEST_LIST2 *l); 
02242 
02246   GWEN_IO_REQUEST_LIST2_ITERATOR *GWEN_Io_Request_List2Iterator_new(GWEN_IO_REQUEST_LIST2 *l);
02247 
02251   void GWEN_Io_Request_List2Iterator_free(GWEN_IO_REQUEST_LIST2_ITERATOR *li); 
02252 
02257   GWEN_IO_REQUEST *GWEN_Io_Request_List2Iterator_Previous(GWEN_IO_REQUEST_LIST2_ITERATOR *li); 
02258    
02263   GWEN_IO_REQUEST *GWEN_Io_Request_List2Iterator_Next(GWEN_IO_REQUEST_LIST2_ITERATOR *li); 
02264 
02269   GWEN_IO_REQUEST *GWEN_Io_Request_List2Iterator_Data(GWEN_IO_REQUEST_LIST2_ITERATOR *li); 
02270 
02282   GWEN_IO_REQUEST *GWEN_Io_Request_List2_ForEach(GWEN_IO_REQUEST_LIST2 *list,
02283                                         GWEN_IO_REQUEST_LIST2_FOREACH func,
02284                                         void *user_data);
02285 
02286 
02287   typedef struct GWEN_IO_REQUEST_CONSTLIST2 GWEN_IO_REQUEST_CONSTLIST2; 
02288   typedef struct GWEN_IO_REQUEST_CONSTLIST2_ITERATOR GWEN_IO_REQUEST_CONSTLIST2_ITERATOR; 
02289   typedef const GWEN_IO_REQUEST*
02290     (GWEN_IO_REQUEST_CONSTLIST2_FOREACH)(const GWEN_IO_REQUEST *element,
02291                                     void *user_data);
02292   
02293    
02294   GWEN_IO_REQUEST_CONSTLIST2 *GWEN_Io_Request_ConstList2_new(); 
02295    
02296   void GWEN_Io_Request_ConstList2_free(GWEN_IO_REQUEST_CONSTLIST2 *l); 
02297    
02298   void GWEN_Io_Request_ConstList2_PushBack(GWEN_IO_REQUEST_CONSTLIST2 *l, const GWEN_IO_REQUEST *p); 
02299    
02300   void GWEN_Io_Request_ConstList2_PushFront(GWEN_IO_REQUEST_CONSTLIST2 *l, const GWEN_IO_REQUEST *p); 
02301    
02302   const GWEN_IO_REQUEST *GWEN_Io_Request_ConstList2_GetFront(GWEN_IO_REQUEST_CONSTLIST2 *l); 
02303    
02304   const GWEN_IO_REQUEST *GWEN_Io_Request_ConstList2_GetBack(GWEN_IO_REQUEST_CONSTLIST2 *l); 
02305    
02306   unsigned int GWEN_Io_Request_ConstList2_GetSize(GWEN_IO_REQUEST_CONSTLIST2 *l); 
02307    
02308   void GWEN_Io_Request_ConstList2_PopBack(GWEN_IO_REQUEST_CONSTLIST2 *l); 
02309    
02310   void GWEN_Io_Request_ConstList2_PopFront(GWEN_IO_REQUEST_CONSTLIST2 *l); 
02311    
02312   void GWEN_Io_Request_ConstList2_Clear(GWEN_IO_REQUEST_CONSTLIST2 *l); 
02313    
02314   GWEN_IO_REQUEST_CONSTLIST2_ITERATOR *GWEN_Io_Request_ConstList2_First(GWEN_IO_REQUEST_CONSTLIST2 *l); 
02315    
02316   GWEN_IO_REQUEST_CONSTLIST2_ITERATOR *GWEN_Io_Request_ConstList2_Last(GWEN_IO_REQUEST_CONSTLIST2 *l); 
02317    
02318   GWEN_IO_REQUEST_CONSTLIST2_ITERATOR *GWEN_Io_Request_ConstList2Iterator_new(GWEN_IO_REQUEST_CONSTLIST2 *l); 
02319    
02320   void GWEN_Io_Request_ConstList2Iterator_free(GWEN_IO_REQUEST_CONSTLIST2_ITERATOR *li); 
02321    
02322   const GWEN_IO_REQUEST *GWEN_Io_Request_ConstList2Iterator_Previous(GWEN_IO_REQUEST_CONSTLIST2_ITERATOR *li); 
02323    
02324   const GWEN_IO_REQUEST *GWEN_Io_Request_ConstList2Iterator_Next(GWEN_IO_REQUEST_CONSTLIST2_ITERATOR *li); 
02325    
02326   const GWEN_IO_REQUEST *GWEN_Io_Request_ConstList2Iterator_Data(GWEN_IO_REQUEST_CONSTLIST2_ITERATOR *li); 
02327    
02339   const GWEN_IO_REQUEST *GWEN_Io_Request_ConstList2_ForEach(GWEN_IO_REQUEST_CONSTLIST2 *list,
02340         GWEN_IO_REQUEST_CONSTLIST2_FOREACH func, void *user_data);
02341 
02342 
02343 #ifdef __cplusplus
02344 }
02345 #endif
02346 
02347 
02348 #endif /* GWEN_IO_REQUEST_LIST_H */
02349 
02350 
02351 
02352 /***************************************************************************
02353  $RCSfile$
02354  -------------------
02355  cvs         : $Id$
02356  begin       : Sat Jun 28 2003
02357  copyright   : (C) 2003 by Martin Preuss
02358  email       : martin@libchipcard.de
02359 
02360  ***************************************************************************
02361  *                                                                         *
02362  *   This library is free software; you can redistribute it and/or         *
02363  *   modify it under the terms of the GNU Lesser General Public            *
02364  *   License as published by the Free Software Foundation; either          *
02365  *   version 2.1 of the License, or (at your option) any later version.    *
02366  *                                                                         *
02367  *   This library is distributed in the hope that it will be useful,       *
02368  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
02369  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
02370  *   Lesser General Public License for more details.                       *
02371  *                                                                         *
02372  *   You should have received a copy of the GNU Lesser General Public      *
02373  *   License along with this library; if not, write to the Free Software   *
02374  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
02375  *   MA  02111-1307  USA                                                   *
02376  *                                                                         *
02377  ***************************************************************************/
02378 
02379 
02380 #ifndef GWEN_IPC_REQUEST_LIST2_H
02381 #define GWEN_IPC_REQUEST_LIST2_H
02382 
02383 
02384 #ifdef __cplusplus
02385 extern "C" {
02386 #endif
02387 
02394   typedef struct GWEN_IPC_REQUEST_LIST2 GWEN_IPC_REQUEST_LIST2;
02395 
02399   typedef struct GWEN_IPC_REQUEST_LIST2_ITERATOR GWEN_IPC_REQUEST_LIST2_ITERATOR;
02400 
02404   typedef GWEN_IPC_REQUEST* (GWEN_IPC_REQUEST_LIST2_FOREACH)(GWEN_IPC_REQUEST *element,
02405                                                  void *user_data);
02406 
02410   GWEN_IPC_REQUEST_LIST2 *GWEN_IpcRequest_List2_new(); 
02411 
02415   void GWEN_IpcRequest_List2_free(GWEN_IPC_REQUEST_LIST2 *l); 
02416 
02420   void GWEN_IpcRequest_List2_Dump(GWEN_IPC_REQUEST_LIST2 *l, FILE *f, unsigned int indent); 
02421 
02425   void GWEN_IpcRequest_List2_PushBack(GWEN_IPC_REQUEST_LIST2 *l, GWEN_IPC_REQUEST *p); 
02426    
02431   void GWEN_IpcRequest_List2_PushFront(GWEN_IPC_REQUEST_LIST2 *l, GWEN_IPC_REQUEST *p); 
02432 
02437   GWEN_IPC_REQUEST *GWEN_IpcRequest_List2_GetFront(GWEN_IPC_REQUEST_LIST2 *l); 
02438    
02443   GWEN_IPC_REQUEST *GWEN_IpcRequest_List2_GetBack(GWEN_IPC_REQUEST_LIST2 *l); 
02444 
02449   void GWEN_IpcRequest_List2_Erase(GWEN_IPC_REQUEST_LIST2 *l,
02450                                GWEN_IPC_REQUEST_LIST2_ITERATOR *it);
02451 
02457   unsigned int GWEN_IpcRequest_List2_GetSize(GWEN_IPC_REQUEST_LIST2 *l); 
02458 
02463   void GWEN_IpcRequest_List2_PopBack(GWEN_IPC_REQUEST_LIST2 *l); 
02464    
02469   void GWEN_IpcRequest_List2_PopFront(GWEN_IPC_REQUEST_LIST2 *l); 
02470 
02474   void GWEN_IpcRequest_List2_Clear(GWEN_IPC_REQUEST_LIST2 *l); 
02475 
02479   GWEN_IPC_REQUEST_LIST2_ITERATOR *GWEN_IpcRequest_List2_First(GWEN_IPC_REQUEST_LIST2 *l); 
02480    
02484   GWEN_IPC_REQUEST_LIST2_ITERATOR *GWEN_IpcRequest_List2_Last(GWEN_IPC_REQUEST_LIST2 *l); 
02485 
02489   GWEN_IPC_REQUEST_LIST2_ITERATOR *GWEN_IpcRequest_List2Iterator_new(GWEN_IPC_REQUEST_LIST2 *l);
02490 
02494   void GWEN_IpcRequest_List2Iterator_free(GWEN_IPC_REQUEST_LIST2_ITERATOR *li); 
02495 
02500   GWEN_IPC_REQUEST *GWEN_IpcRequest_List2Iterator_Previous(GWEN_IPC_REQUEST_LIST2_ITERATOR *li); 
02501    
02506   GWEN_IPC_REQUEST *GWEN_IpcRequest_List2Iterator_Next(GWEN_IPC_REQUEST_LIST2_ITERATOR *li); 
02507 
02512   GWEN_IPC_REQUEST *GWEN_IpcRequest_List2Iterator_Data(GWEN_IPC_REQUEST_LIST2_ITERATOR *li); 
02513 
02525   GWEN_IPC_REQUEST *GWEN_IpcRequest_List2_ForEach(GWEN_IPC_REQUEST_LIST2 *list,
02526                                         GWEN_IPC_REQUEST_LIST2_FOREACH func,
02527                                         void *user_data);
02528 
02529 
02530   typedef struct GWEN_IPC_REQUEST_CONSTLIST2 GWEN_IPC_REQUEST_CONSTLIST2; 
02531   typedef struct GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR; 
02532   typedef const GWEN_IPC_REQUEST*
02533     (GWEN_IPC_REQUEST_CONSTLIST2_FOREACH)(const GWEN_IPC_REQUEST *element,
02534                                     void *user_data);
02535   
02536    
02537   GWEN_IPC_REQUEST_CONSTLIST2 *GWEN_IpcRequest_ConstList2_new(); 
02538    
02539   void GWEN_IpcRequest_ConstList2_free(GWEN_IPC_REQUEST_CONSTLIST2 *l); 
02540    
02541   void GWEN_IpcRequest_ConstList2_PushBack(GWEN_IPC_REQUEST_CONSTLIST2 *l, const GWEN_IPC_REQUEST *p); 
02542    
02543   void GWEN_IpcRequest_ConstList2_PushFront(GWEN_IPC_REQUEST_CONSTLIST2 *l, const GWEN_IPC_REQUEST *p); 
02544    
02545   const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2_GetFront(GWEN_IPC_REQUEST_CONSTLIST2 *l); 
02546    
02547   const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2_GetBack(GWEN_IPC_REQUEST_CONSTLIST2 *l); 
02548    
02549   unsigned int GWEN_IpcRequest_ConstList2_GetSize(GWEN_IPC_REQUEST_CONSTLIST2 *l); 
02550    
02551   void GWEN_IpcRequest_ConstList2_PopBack(GWEN_IPC_REQUEST_CONSTLIST2 *l); 
02552    
02553   void GWEN_IpcRequest_ConstList2_PopFront(GWEN_IPC_REQUEST_CONSTLIST2 *l); 
02554    
02555   void GWEN_IpcRequest_ConstList2_Clear(GWEN_IPC_REQUEST_CONSTLIST2 *l); 
02556    
02557   GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *GWEN_IpcRequest_ConstList2_First(GWEN_IPC_REQUEST_CONSTLIST2 *l); 
02558    
02559   GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *GWEN_IpcRequest_ConstList2_Last(GWEN_IPC_REQUEST_CONSTLIST2 *l); 
02560    
02561   GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *GWEN_IpcRequest_ConstList2Iterator_new(GWEN_IPC_REQUEST_CONSTLIST2 *l); 
02562    
02563   void GWEN_IpcRequest_ConstList2Iterator_free(GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *li); 
02564    
02565   const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2Iterator_Previous(GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *li); 
02566    
02567   const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2Iterator_Next(GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *li); 
02568    
02569   const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2Iterator_Data(GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *li); 
02570    
02582   const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2_ForEach(GWEN_IPC_REQUEST_CONSTLIST2 *list,
02583         GWEN_IPC_REQUEST_CONSTLIST2_FOREACH func, void *user_data);
02584 
02585 
02586 #ifdef __cplusplus
02587 }
02588 #endif
02589 
02590 
02591 #endif /* GWEN_IPC_REQUEST_LIST_H */
02592 
02593 
02594 
02595 /***************************************************************************
02596  $RCSfile$
02597  -------------------
02598  cvs         : $Id$
02599  begin       : Sat Jun 28 2003
02600  copyright   : (C) 2003 by Martin Preuss
02601  email       : martin@libchipcard.de
02602 
02603  ***************************************************************************
02604  *                                                                         *
02605  *   This library is free software; you can redistribute it and/or         *
02606  *   modify it under the terms of the GNU Lesser General Public            *
02607  *   License as published by the Free Software Foundation; either          *
02608  *   version 2.1 of the License, or (at your option) any later version.    *
02609  *                                                                         *
02610  *   This library is distributed in the hope that it will be useful,       *
02611  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
02612  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
02613  *   Lesser General Public License for more details.                       *
02614  *                                                                         *
02615  *   You should have received a copy of the GNU Lesser General Public      *
02616  *   License along with this library; if not, write to the Free Software   *
02617  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
02618  *   MA  02111-1307  USA                                                   *
02619  *                                                                         *
02620  ***************************************************************************/
02621 
02622 
02623 #ifndef GWEN_IPC_REQUEST_LIST1_H
02624 #define GWEN_IPC_REQUEST_LIST1_H
02625 
02626 #ifdef __cplusplus
02627 extern "C" {
02628 #endif
02629 
02631   typedef struct GWEN_IPC_REQUEST_LIST_ELEMENT {
02632     uint32_t id;
02633     GWEN_IPC_REQUEST *nextObject;
02634   } GWEN_IPC_REQUEST_LIST__ELEMENT;
02635 
02642   typedef struct GWEN_IPC_REQUEST_LIST GWEN_IPC_REQUEST_LIST;
02644   struct GWEN_IPC_REQUEST_LIST {
02645     GWEN_IPC_REQUEST *first;
02646     uint32_t count;
02647     uint32_t id;
02648   } GWEN_IPC_REQUEST_LIST;
02649 
02654   void GWEN_IpcRequest_List_AddList(GWEN_IPC_REQUEST_LIST *dst, GWEN_IPC_REQUEST_LIST *l);
02655 
02659   void GWEN_IpcRequest_List_Add(GWEN_IPC_REQUEST *element, GWEN_IPC_REQUEST_LIST *list);
02660 
02665   void GWEN_IpcRequest_List_Insert(GWEN_IPC_REQUEST *element, GWEN_IPC_REQUEST_LIST *list);
02666 
02673   void GWEN_IpcRequest_List_Del(GWEN_IPC_REQUEST *element);
02674 
02678   GWEN_IPC_REQUEST* GWEN_IpcRequest_List_First(const GWEN_IPC_REQUEST_LIST *l);
02679 
02683   GWEN_IPC_REQUEST* GWEN_IpcRequest_List_Last(const GWEN_IPC_REQUEST_LIST *l);
02684 
02689   void GWEN_IpcRequest_List_Clear(GWEN_IPC_REQUEST_LIST *l);
02690 
02694   GWEN_IPC_REQUEST_LIST* GWEN_IpcRequest_List_new();
02695 
02699   void GWEN_IpcRequest_List_free(GWEN_IPC_REQUEST_LIST *l);
02700 
02704   GWEN_IPC_REQUEST* GWEN_IpcRequest_List_Next(const GWEN_IPC_REQUEST *element);
02705 
02709   GWEN_IPC_REQUEST* GWEN_IpcRequest_List_Previous(const GWEN_IPC_REQUEST *element);
02710 
02714   uint32_t GWEN_IpcRequest_List_GetCount(const GWEN_IPC_REQUEST_LIST *l);
02715 
02716 #ifdef __cplusplus
02717 }
02718 #endif
02719 
02720 
02721 #endif
02722 
02723 
02724 
02725 /***************************************************************************
02726  $RCSfile$
02727  -------------------
02728  cvs         : $Id$
02729  begin       : Sat Jun 28 2003
02730  copyright   : (C) 2003 by Martin Preuss
02731  email       : martin@libchipcard.de
02732 
02733  ***************************************************************************
02734  *                                                                         *
02735  *   This library is free software; you can redistribute it and/or         *
02736  *   modify it under the terms of the GNU Lesser General Public            *
02737  *   License as published by the Free Software Foundation; either          *
02738  *   version 2.1 of the License, or (at your option) any later version.    *
02739  *                                                                         *
02740  *   This library is distributed in the hope that it will be useful,       *
02741  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
02742  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
02743  *   Lesser General Public License for more details.                       *
02744  *                                                                         *
02745  *   You should have received a copy of the GNU Lesser General Public      *
02746  *   License along with this library; if not, write to the Free Software   *
02747  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
02748  *   MA  02111-1307  USA                                                   *
02749  *                                                                         *
02750  ***************************************************************************/
02751 
02752 
02753 #ifndef GWEN_SIGTAIL_LIST1_H
02754 #define GWEN_SIGTAIL_LIST1_H
02755 
02756 #ifdef __cplusplus
02757 extern "C" {
02758 #endif
02759 
02761   typedef struct GWEN_SIGTAIL_LIST_ELEMENT {
02762     uint32_t id;
02763     GWEN_SIGTAIL *nextObject;
02764   } GWEN_SIGTAIL_LIST__ELEMENT;
02765 
02772   typedef struct GWEN_SIGTAIL_LIST GWEN_SIGTAIL_LIST;
02774   struct GWEN_SIGTAIL_LIST {
02775     GWEN_SIGTAIL *first;
02776     uint32_t count;
02777     uint32_t id;
02778   } GWEN_SIGTAIL_LIST;
02779 
02784   void GWEN_SigTail_List_AddList(GWEN_SIGTAIL_LIST *dst, GWEN_SIGTAIL_LIST *l);
02785 
02789   void GWEN_SigTail_List_Add(GWEN_SIGTAIL *element, GWEN_SIGTAIL_LIST *list);
02790 
02795   void GWEN_SigTail_List_Insert(GWEN_SIGTAIL *element, GWEN_SIGTAIL_LIST *list);
02796 
02803   void GWEN_SigTail_List_Del(GWEN_SIGTAIL *element);
02804 
02808   GWEN_SIGTAIL* GWEN_SigTail_List_First(const GWEN_SIGTAIL_LIST *l);
02809 
02813   GWEN_SIGTAIL* GWEN_SigTail_List_Last(const GWEN_SIGTAIL_LIST *l);
02814 
02819   void GWEN_SigTail_List_Clear(GWEN_SIGTAIL_LIST *l);
02820 
02824   GWEN_SIGTAIL_LIST* GWEN_SigTail_List_new();
02825 
02829   void GWEN_SigTail_List_free(GWEN_SIGTAIL_LIST *l);
02830 
02834   GWEN_SIGTAIL* GWEN_SigTail_List_Next(const GWEN_SIGTAIL *element);
02835 
02839   GWEN_SIGTAIL* GWEN_SigTail_List_Previous(const GWEN_SIGTAIL *element);
02840 
02844   uint32_t GWEN_SigTail_List_GetCount(const GWEN_SIGTAIL_LIST *l);
02845 
02846 #ifdef __cplusplus
02847 }
02848 #endif
02849 
02850 
02851 #endif
02852 
02853 
02854 
02855 /***************************************************************************
02856  $RCSfile$
02857  -------------------
02858  cvs         : $Id$
02859  begin       : Sat Jun 28 2003
02860  copyright   : (C) 2003 by Martin Preuss
02861  email       : martin@libchipcard.de
02862 
02863  ***************************************************************************
02864  *                                                                         *
02865  *   This library is free software; you can redistribute it and/or         *
02866  *   modify it under the terms of the GNU Lesser General Public            *
02867  *   License as published by the Free Software Foundation; either          *
02868  *   version 2.1 of the License, or (at your option) any later version.    *
02869  *                                                                         *
02870  *   This library is distributed in the hope that it will be useful,       *
02871  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
02872  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
02873  *   Lesser General Public License for more details.                       *
02874  *                                                                         *
02875  *   You should have received a copy of the GNU Lesser General Public      *
02876  *   License along with this library; if not, write to the Free Software   *
02877  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
02878  *   MA  02111-1307  USA                                                   *
02879  *                                                                         *
02880  ***************************************************************************/
02881 
02882 
02883 #ifndef GWEN_TAG16_LIST1_H
02884 #define GWEN_TAG16_LIST1_H
02885 
02886 #ifdef __cplusplus
02887 extern "C" {
02888 #endif
02889 
02891   typedef struct GWEN_TAG16_LIST_ELEMENT {
02892     uint32_t id;
02893     GWEN_TAG16 *nextObject;
02894   } GWEN_TAG16_LIST__ELEMENT;
02895 
02902   typedef struct GWEN_TAG16_LIST GWEN_TAG16_LIST;
02904   struct GWEN_TAG16_LIST {
02905     GWEN_TAG16 *first;
02906     uint32_t count;
02907     uint32_t id;
02908   } GWEN_TAG16_LIST;
02909 
02914   void GWEN_Tag16_List_AddList(GWEN_TAG16_LIST *dst, GWEN_TAG16_LIST *l);
02915 
02919   void GWEN_Tag16_List_Add(GWEN_TAG16 *element, GWEN_TAG16_LIST *list);
02920 
02925   void GWEN_Tag16_List_Insert(GWEN_TAG16 *element, GWEN_TAG16_LIST *list);
02926 
02933   void GWEN_Tag16_List_Del(GWEN_TAG16 *element);
02934 
02938   GWEN_TAG16* GWEN_Tag16_List_First(const GWEN_TAG16_LIST *l);
02939 
02943   GWEN_TAG16* GWEN_Tag16_List_Last(const GWEN_TAG16_LIST *l);
02944 
02949   void GWEN_Tag16_List_Clear(GWEN_TAG16_LIST *l);
02950 
02954   GWEN_TAG16_LIST* GWEN_Tag16_List_new();
02955 
02959   void GWEN_Tag16_List_free(GWEN_TAG16_LIST *l);
02960 
02964   GWEN_TAG16* GWEN_Tag16_List_Next(const GWEN_TAG16 *element);
02965 
02969   GWEN_TAG16* GWEN_Tag16_List_Previous(const GWEN_TAG16 *element);
02970 
02974   uint32_t GWEN_Tag16_List_GetCount(const GWEN_TAG16_LIST *l);
02975 
02976 #ifdef __cplusplus
02977 }
02978 #endif
02979 
02980 
02981 #endif
02982 
02983 
02984 
02985 /***************************************************************************
02986  $RCSfile$
02987  -------------------
02988  cvs         : $Id$
02989  begin       : Sat Jun 28 2003
02990  copyright   : (C) 2003 by Martin Preuss
02991  email       : martin@libchipcard.de
02992 
02993  ***************************************************************************
02994  *                                                                         *
02995  *   This library is free software; you can redistribute it and/or         *
02996  *   modify it under the terms of the GNU Lesser General Public            *
02997  *   License as published by the Free Software Foundation; either          *
02998  *   version 2.1 of the License, or (at your option) any later version.    *
02999  *                                                                         *
03000  *   This library is distributed in the hope that it will be useful,       *
03001  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
03002  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
03003  *   Lesser General Public License for more details.                       *
03004  *                                                                         *
03005  *   You should have received a copy of the GNU Lesser General Public      *
03006  *   License along with this library; if not, write to the Free Software   *
03007  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
03008  *   MA  02111-1307  USA                                                   *
03009  *                                                                         *
03010  ***************************************************************************/
03011 
03012 
03013 #ifndef GWEN_CRYPT_TOKEN_CONTEXT_LIST2_H
03014 #define GWEN_CRYPT_TOKEN_CONTEXT_LIST2_H
03015 
03016 
03017 #ifdef __cplusplus
03018 extern "C" {
03019 #endif
03020 
03027   typedef struct GWEN_CRYPT_TOKEN_CONTEXT_LIST2 GWEN_CRYPT_TOKEN_CONTEXT_LIST2;
03028 
03032   typedef struct GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR;
03033 
03037   typedef GWEN_CRYPT_TOKEN_CONTEXT* (GWEN_CRYPT_TOKEN_CONTEXT_LIST2_FOREACH)(GWEN_CRYPT_TOKEN_CONTEXT *element,
03038                                                  void *user_data);
03039 
03043   GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *GWEN_Crypt_Token_Context_List2_new(); 
03044 
03048   void GWEN_Crypt_Token_Context_List2_free(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l); 
03049 
03053   void GWEN_Crypt_Token_Context_List2_Dump(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l, FILE *f, unsigned int indent); 
03054 
03058   void GWEN_Crypt_Token_Context_List2_PushBack(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l, GWEN_CRYPT_TOKEN_CONTEXT *p); 
03059    
03064   void GWEN_Crypt_Token_Context_List2_PushFront(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l, GWEN_CRYPT_TOKEN_CONTEXT *p); 
03065 
03070   GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_List2_GetFront(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l); 
03071    
03076   GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_List2_GetBack(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l); 
03077 
03082   void GWEN_Crypt_Token_Context_List2_Erase(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l,
03083                                GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *it);
03084 
03090   unsigned int GWEN_Crypt_Token_Context_List2_GetSize(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l); 
03091 
03096   void GWEN_Crypt_Token_Context_List2_PopBack(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l); 
03097    
03102   void GWEN_Crypt_Token_Context_List2_PopFront(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l); 
03103 
03107   void GWEN_Crypt_Token_Context_List2_Clear(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l); 
03108 
03112   GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *GWEN_Crypt_Token_Context_List2_First(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l); 
03113    
03117   GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *GWEN_Crypt_Token_Context_List2_Last(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l); 
03118 
03122   GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *GWEN_Crypt_Token_Context_List2Iterator_new(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l);
03123 
03127   void GWEN_Crypt_Token_Context_List2Iterator_free(GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *li); 
03128 
03133   GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_List2Iterator_Previous(GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *li); 
03134    
03139   GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_List2Iterator_Next(GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *li); 
03140 
03145   GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_List2Iterator_Data(GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *li); 
03146 
03158   GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_List2_ForEach(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *list,
03159                                         GWEN_CRYPT_TOKEN_CONTEXT_LIST2_FOREACH func,
03160                                         void *user_data);
03161 
03162 
03163   typedef struct GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2; 
03164   typedef struct GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR; 
03165   typedef const GWEN_CRYPT_TOKEN_CONTEXT*
03166     (GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_FOREACH)(const GWEN_CRYPT_TOKEN_CONTEXT *element,
03167                                     void *user_data);
03168   
03169    
03170   GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *GWEN_Crypt_Token_Context_ConstList2_new(); 
03171    
03172   void GWEN_Crypt_Token_Context_ConstList2_free(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l); 
03173    
03174   void GWEN_Crypt_Token_Context_ConstList2_PushBack(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l, const GWEN_CRYPT_TOKEN_CONTEXT *p); 
03175    
03176   void GWEN_Crypt_Token_Context_ConstList2_PushFront(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l, const GWEN_CRYPT_TOKEN_CONTEXT *p); 
03177    
03178   const GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_ConstList2_GetFront(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l); 
03179    
03180   const GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_ConstList2_GetBack(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l); 
03181    
03182   unsigned int GWEN_Crypt_Token_Context_ConstList2_GetSize(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l); 
03183    
03184   void GWEN_Crypt_Token_Context_ConstList2_PopBack(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l); 
03185    
03186   void GWEN_Crypt_Token_Context_ConstList2_PopFront(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l); 
03187    
03188   void GWEN_Crypt_Token_Context_ConstList2_Clear(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l); 
03189    
03190   GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_Context_ConstList2_First(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l); 
03191    
03192   GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_Context_ConstList2_Last(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l); 
03193    
03194   GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_Context_ConstList2Iterator_new(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l); 
03195    
03196   void GWEN_Crypt_Token_Context_ConstList2Iterator_free(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *li); 
03197    
03198   const GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_ConstList2Iterator_Previous(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *li); 
03199    
03200   const GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_ConstList2Iterator_Next(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *li); 
03201    
03202   const GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_ConstList2Iterator_Data(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *li); 
03203    
03215   const GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_ConstList2_ForEach(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *list,
03216         GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_FOREACH func, void *user_data);
03217 
03218 
03219 #ifdef __cplusplus
03220 }
03221 #endif
03222 
03223 
03224 #endif /* GWEN_CRYPT_TOKEN_CONTEXT_LIST_H */
03225 
03226 
03227 
03228 /***************************************************************************
03229  $RCSfile$
03230  -------------------
03231  cvs         : $Id$
03232  begin       : Sat Jun 28 2003
03233  copyright   : (C) 2003 by Martin Preuss
03234  email       : martin@libchipcard.de
03235 
03236  ***************************************************************************
03237  *                                                                         *
03238  *   This library is free software; you can redistribute it and/or         *
03239  *   modify it under the terms of the GNU Lesser General Public            *
03240  *   License as published by the Free Software Foundation; either          *
03241  *   version 2.1 of the License, or (at your option) any later version.    *
03242  *                                                                         *
03243  *   This library is distributed in the hope that it will be useful,       *
03244  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
03245  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
03246  *   Lesser General Public License for more details.                       *
03247  *                                                                         *
03248  *   You should have received a copy of the GNU Lesser General Public      *
03249  *   License along with this library; if not, write to the Free Software   *
03250  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
03251  *   MA  02111-1307  USA                                                   *
03252  *                                                                         *
03253  ***************************************************************************/
03254 
03255 
03256 #ifndef GWEN_CRYPT_TOKEN_CONTEXT_LIST1_H
03257 #define GWEN_CRYPT_TOKEN_CONTEXT_LIST1_H
03258 
03259 #ifdef __cplusplus
03260 extern "C" {
03261 #endif
03262 
03264   typedef struct GWEN_CRYPT_TOKEN_CONTEXT_LIST_ELEMENT {
03265     uint32_t id;
03266     GWEN_CRYPT_TOKEN_CONTEXT *nextObject;
03267   } GWEN_CRYPT_TOKEN_CONTEXT_LIST__ELEMENT;
03268 
03275   typedef struct GWEN_CRYPT_TOKEN_CONTEXT_LIST GWEN_CRYPT_TOKEN_CONTEXT_LIST;
03277   struct GWEN_CRYPT_TOKEN_CONTEXT_LIST {
03278     GWEN_CRYPT_TOKEN_CONTEXT *first;
03279     uint32_t count;
03280     uint32_t id;
03281   } GWEN_CRYPT_TOKEN_CONTEXT_LIST;
03282 
03287   void GWEN_Crypt_Token_Context_List_AddList(GWEN_CRYPT_TOKEN_CONTEXT_LIST *dst, GWEN_CRYPT_TOKEN_CONTEXT_LIST *l);
03288 
03292   void GWEN_Crypt_Token_Context_List_Add(GWEN_CRYPT_TOKEN_CONTEXT *element, GWEN_CRYPT_TOKEN_CONTEXT_LIST *list);
03293 
03298   void GWEN_Crypt_Token_Context_List_Insert(GWEN_CRYPT_TOKEN_CONTEXT *element, GWEN_CRYPT_TOKEN_CONTEXT_LIST *list);
03299 
03306   void GWEN_Crypt_Token_Context_List_Del(GWEN_CRYPT_TOKEN_CONTEXT *element);
03307 
03311   GWEN_CRYPT_TOKEN_CONTEXT* GWEN_Crypt_Token_Context_List_First(const GWEN_CRYPT_TOKEN_CONTEXT_LIST *l);
03312 
03316   GWEN_CRYPT_TOKEN_CONTEXT* GWEN_Crypt_Token_Context_List_Last(const GWEN_CRYPT_TOKEN_CONTEXT_LIST *l);
03317 
03322   void GWEN_Crypt_Token_Context_List_Clear(GWEN_CRYPT_TOKEN_CONTEXT_LIST *l);
03323 
03327   GWEN_CRYPT_TOKEN_CONTEXT_LIST* GWEN_Crypt_Token_Context_List_new();
03328 
03332   void GWEN_Crypt_Token_Context_List_free(GWEN_CRYPT_TOKEN_CONTEXT_LIST *l);
03333 
03337   GWEN_CRYPT_TOKEN_CONTEXT* GWEN_Crypt_Token_Context_List_Next(const GWEN_CRYPT_TOKEN_CONTEXT *element);
03338 
03342   GWEN_CRYPT_TOKEN_CONTEXT* GWEN_Crypt_Token_Context_List_Previous(const GWEN_CRYPT_TOKEN_CONTEXT *element);
03343 
03347   uint32_t GWEN_Crypt_Token_Context_List_GetCount(const GWEN_CRYPT_TOKEN_CONTEXT_LIST *l);
03348 
03349 #ifdef __cplusplus
03350 }
03351 #endif
03352 
03353 
03354 #endif
03355 
03356 
03357 
03358 /***************************************************************************
03359  $RCSfile$
03360  -------------------
03361  cvs         : $Id$
03362  begin       : Sat Jun 28 2003
03363  copyright   : (C) 2003 by Martin Preuss
03364  email       : martin@libchipcard.de
03365 
03366  ***************************************************************************
03367  *                                                                         *
03368  *   This library is free software; you can redistribute it and/or         *
03369  *   modify it under the terms of the GNU Lesser General Public            *
03370  *   License as published by the Free Software Foundation; either          *
03371  *   version 2.1 of the License, or (at your option) any later version.    *
03372  *                                                                         *
03373  *   This library is distributed in the hope that it will be useful,       *
03374  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
03375  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
03376  *   Lesser General Public License for more details.                       *
03377  *                                                                         *
03378  *   You should have received a copy of the GNU Lesser General Public      *
03379  *   License along with this library; if not, write to the Free Software   *
03380  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
03381  *   MA  02111-1307  USA                                                   *
03382  *                                                                         *
03383  ***************************************************************************/
03384 
03385 
03386 #ifndef GWEN_CRYPT_TOKEN_KEYINFO_LIST2_H
03387 #define GWEN_CRYPT_TOKEN_KEYINFO_LIST2_H
03388 
03389 
03390 #ifdef __cplusplus
03391 extern "C" {
03392 #endif
03393 
03400   typedef struct GWEN_CRYPT_TOKEN_KEYINFO_LIST2 GWEN_CRYPT_TOKEN_KEYINFO_LIST2;
03401 
03405   typedef struct GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR;
03406 
03410   typedef GWEN_CRYPT_TOKEN_KEYINFO* (GWEN_CRYPT_TOKEN_KEYINFO_LIST2_FOREACH)(GWEN_CRYPT_TOKEN_KEYINFO *element,
03411                                                  void *user_data);
03412 
03416   GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *GWEN_Crypt_Token_KeyInfo_List2_new(); 
03417 
03421   void GWEN_Crypt_Token_KeyInfo_List2_free(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l); 
03422 
03426   void GWEN_Crypt_Token_KeyInfo_List2_Dump(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l, FILE *f, unsigned int indent); 
03427 
03431   void GWEN_Crypt_Token_KeyInfo_List2_PushBack(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l, GWEN_CRYPT_TOKEN_KEYINFO *p); 
03432    
03437   void GWEN_Crypt_Token_KeyInfo_List2_PushFront(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l, GWEN_CRYPT_TOKEN_KEYINFO *p); 
03438 
03443   GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_List2_GetFront(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l); 
03444    
03449   GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_List2_GetBack(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l); 
03450 
03455   void GWEN_Crypt_Token_KeyInfo_List2_Erase(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l,
03456                                GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *it);
03457 
03463   unsigned int GWEN_Crypt_Token_KeyInfo_List2_GetSize(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l); 
03464 
03469   void GWEN_Crypt_Token_KeyInfo_List2_PopBack(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l); 
03470    
03475   void GWEN_Crypt_Token_KeyInfo_List2_PopFront(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l); 
03476 
03480   void GWEN_Crypt_Token_KeyInfo_List2_Clear(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l); 
03481 
03485   GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *GWEN_Crypt_Token_KeyInfo_List2_First(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l); 
03486    
03490   GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *GWEN_Crypt_Token_KeyInfo_List2_Last(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l); 
03491 
03495   GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *GWEN_Crypt_Token_KeyInfo_List2Iterator_new(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l);
03496 
03500   void GWEN_Crypt_Token_KeyInfo_List2Iterator_free(GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *li); 
03501 
03506   GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_List2Iterator_Previous(GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *li); 
03507    
03512   GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_List2Iterator_Next(GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *li); 
03513 
03518   GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_List2Iterator_Data(GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *li); 
03519 
03531   GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_List2_ForEach(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *list,
03532                                         GWEN_CRYPT_TOKEN_KEYINFO_LIST2_FOREACH func,
03533                                         void *user_data);
03534 
03535 
03536   typedef struct GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2; 
03537   typedef struct GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR; 
03538   typedef const GWEN_CRYPT_TOKEN_KEYINFO*
03539     (GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_FOREACH)(const GWEN_CRYPT_TOKEN_KEYINFO *element,
03540                                     void *user_data);
03541   
03542    
03543   GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *GWEN_Crypt_Token_KeyInfo_ConstList2_new(); 
03544    
03545   void GWEN_Crypt_Token_KeyInfo_ConstList2_free(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l); 
03546    
03547   void GWEN_Crypt_Token_KeyInfo_ConstList2_PushBack(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l, const GWEN_CRYPT_TOKEN_KEYINFO *p); 
03548    
03549   void GWEN_Crypt_Token_KeyInfo_ConstList2_PushFront(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l, const GWEN_CRYPT_TOKEN_KEYINFO *p); 
03550    
03551   const GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_ConstList2_GetFront(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l); 
03552    
03553   const GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_ConstList2_GetBack(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l); 
03554    
03555   unsigned int GWEN_Crypt_Token_KeyInfo_ConstList2_GetSize(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l); 
03556    
03557   void GWEN_Crypt_Token_KeyInfo_ConstList2_PopBack(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l); 
03558    
03559   void GWEN_Crypt_Token_KeyInfo_ConstList2_PopFront(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l); 
03560    
03561   void GWEN_Crypt_Token_KeyInfo_ConstList2_Clear(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l); 
03562    
03563   GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_KeyInfo_ConstList2_First(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l); 
03564    
03565   GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_KeyInfo_ConstList2_Last(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l); 
03566    
03567   GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_KeyInfo_ConstList2Iterator_new(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l); 
03568    
03569   void GWEN_Crypt_Token_KeyInfo_ConstList2Iterator_free(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *li); 
03570    
03571   const GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_ConstList2Iterator_Previous(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *li); 
03572    
03573   const GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_ConstList2Iterator_Next(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *li); 
03574    
03575   const GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_ConstList2Iterator_Data(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *li); 
03576    
03588   const GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_ConstList2_ForEach(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *list,
03589         GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_FOREACH func, void *user_data);
03590 
03591 
03592 #ifdef __cplusplus
03593 }
03594 #endif
03595 
03596 
03597 #endif /* GWEN_CRYPT_TOKEN_KEYINFO_LIST_H */
03598 
03599 
03600 
03601 /***************************************************************************
03602  $RCSfile$
03603  -------------------
03604  cvs         : $Id$
03605  begin       : Sat Jun 28 2003
03606  copyright   : (C) 2003 by Martin Preuss
03607  email       : martin@libchipcard.de
03608 
03609  ***************************************************************************
03610  *                                                                         *
03611  *   This library is free software; you can redistribute it and/or         *
03612  *   modify it under the terms of the GNU Lesser General Public            *
03613  *   License as published by the Free Software Foundation; either          *
03614  *   version 2.1 of the License, or (at your option) any later version.    *
03615  *                                                                         *
03616  *   This library is distributed in the hope that it will be useful,       *
03617  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
03618  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
03619  *   Lesser General Public License for more details.                       *
03620  *                                                                         *
03621  *   You should have received a copy of the GNU Lesser General Public      *
03622  *   License along with this library; if not, write to the Free Software   *
03623  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
03624  *   MA  02111-1307  USA                                                   *
03625  *                                                                         *
03626  ***************************************************************************/
03627 
03628 
03629 #ifndef GWEN_CRYPT_TOKEN_KEYINFO_LIST1_H
03630 #define GWEN_CRYPT_TOKEN_KEYINFO_LIST1_H
03631 
03632 #ifdef __cplusplus
03633 extern "C" {
03634 #endif
03635 
03637   typedef struct GWEN_CRYPT_TOKEN_KEYINFO_LIST_ELEMENT {
03638     uint32_t id;
03639     GWEN_CRYPT_TOKEN_KEYINFO *nextObject;
03640   } GWEN_CRYPT_TOKEN_KEYINFO_LIST__ELEMENT;
03641 
03648   typedef struct GWEN_CRYPT_TOKEN_KEYINFO_LIST GWEN_CRYPT_TOKEN_KEYINFO_LIST;
03650   struct GWEN_CRYPT_TOKEN_KEYINFO_LIST {
03651     GWEN_CRYPT_TOKEN_KEYINFO *first;
03652     uint32_t count;
03653     uint32_t id;
03654   } GWEN_CRYPT_TOKEN_KEYINFO_LIST;
03655 
03660   void GWEN_Crypt_Token_KeyInfo_List_AddList(GWEN_CRYPT_TOKEN_KEYINFO_LIST *dst, GWEN_CRYPT_TOKEN_KEYINFO_LIST *l);
03661 
03665   void GWEN_Crypt_Token_KeyInfo_List_Add(GWEN_CRYPT_TOKEN_KEYINFO *element, GWEN_CRYPT_TOKEN_KEYINFO_LIST *list);
03666 
03671   void GWEN_Crypt_Token_KeyInfo_List_Insert(GWEN_CRYPT_TOKEN_KEYINFO *element, GWEN_CRYPT_TOKEN_KEYINFO_LIST *list);
03672 
03679   void GWEN_Crypt_Token_KeyInfo_List_Del(GWEN_CRYPT_TOKEN_KEYINFO *element);
03680 
03684   GWEN_CRYPT_TOKEN_KEYINFO* GWEN_Crypt_Token_KeyInfo_List_First(const GWEN_CRYPT_TOKEN_KEYINFO_LIST *l);
03685 
03689   GWEN_CRYPT_TOKEN_KEYINFO* GWEN_Crypt_Token_KeyInfo_List_Last(const GWEN_CRYPT_TOKEN_KEYINFO_LIST *l);
03690 
03695   void GWEN_Crypt_Token_KeyInfo_List_Clear(GWEN_CRYPT_TOKEN_KEYINFO_LIST *l);
03696 
03700   GWEN_CRYPT_TOKEN_KEYINFO_LIST* GWEN_Crypt_Token_KeyInfo_List_new();
03701 
03705   void GWEN_Crypt_Token_KeyInfo_List_free(GWEN_CRYPT_TOKEN_KEYINFO_LIST *l);
03706 
03710   GWEN_CRYPT_TOKEN_KEYINFO* GWEN_Crypt_Token_KeyInfo_List_Next(const GWEN_CRYPT_TOKEN_KEYINFO *element);
03711 
03715   GWEN_CRYPT_TOKEN_KEYINFO* GWEN_Crypt_Token_KeyInfo_List_Previous(const GWEN_CRYPT_TOKEN_KEYINFO *element);
03716 
03720   uint32_t GWEN_Crypt_Token_KeyInfo_List_GetCount(const GWEN_CRYPT_TOKEN_KEYINFO_LIST *l);
03721 
03722 #ifdef __cplusplus
03723 }
03724 #endif
03725 
03726 
03727 #endif
03728 
03729 
03730 
03731 /***************************************************************************
03732  $RCSfile$
03733  -------------------
03734  cvs         : $Id$
03735  begin       : Sat Jun 28 2003
03736  copyright   : (C) 2003 by Martin Preuss
03737  email       : martin@libchipcard.de
03738 
03739  ***************************************************************************
03740  *                                                                         *
03741  *   This library is free software; you can redistribute it and/or         *
03742  *   modify it under the terms of the GNU Lesser General Public            *
03743  *   License as published by the Free Software Foundation; either          *
03744  *   version 2.1 of the License, or (at your option) any later version.    *
03745  *                                                                         *
03746  *   This library is distributed in the hope that it will be useful,       *
03747  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
03748  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
03749  *   Lesser General Public License for more details.                       *
03750  *                                                                         *
03751  *   You should have received a copy of the GNU Lesser General Public      *
03752  *   License along with this library; if not, write to the Free Software   *
03753  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
03754  *   MA  02111-1307  USA                                                   *
03755  *                                                                         *
03756  ***************************************************************************/
03757 
03758 
03759 #ifndef GWEN_IO_REQUEST_LIST1_H
03760 #define GWEN_IO_REQUEST_LIST1_H
03761 
03762 #ifdef __cplusplus
03763 extern "C" {
03764 #endif
03765 
03767   typedef struct GWEN_IO_REQUEST_LIST_ELEMENT {
03768     uint32_t id;
03769     GWEN_IO_REQUEST *nextObject;
03770   } GWEN_IO_REQUEST_LIST__ELEMENT;
03771 
03778   typedef struct GWEN_IO_REQUEST_LIST GWEN_IO_REQUEST_LIST;
03780   struct GWEN_IO_REQUEST_LIST {
03781     GWEN_IO_REQUEST *first;
03782     uint32_t count;
03783     uint32_t id;
03784   } GWEN_IO_REQUEST_LIST;
03785 
03790   void GWEN_Io_Request_List_AddList(GWEN_IO_REQUEST_LIST *dst, GWEN_IO_REQUEST_LIST *l);
03791 
03795   void GWEN_Io_Request_List_Add(GWEN_IO_REQUEST *element, GWEN_IO_REQUEST_LIST *list);
03796 
03801   void GWEN_Io_Request_List_Insert(GWEN_IO_REQUEST *element, GWEN_IO_REQUEST_LIST *list);
03802 
03809   void GWEN_Io_Request_List_Del(GWEN_IO_REQUEST *element);
03810 
03814   GWEN_IO_REQUEST* GWEN_Io_Request_List_First(const GWEN_IO_REQUEST_LIST *l);
03815 
03819   GWEN_IO_REQUEST* GWEN_Io_Request_List_Last(const GWEN_IO_REQUEST_LIST *l);
03820 
03825   void GWEN_Io_Request_List_Clear(GWEN_IO_REQUEST_LIST *l);
03826 
03830   GWEN_IO_REQUEST_LIST* GWEN_Io_Request_List_new();
03831 
03835   void GWEN_Io_Request_List_free(GWEN_IO_REQUEST_LIST *l);
03836 
03840   GWEN_IO_REQUEST* GWEN_Io_Request_List_Next(const GWEN_IO_REQUEST *element);
03841 
03845   GWEN_IO_REQUEST* GWEN_Io_Request_List_Previous(const GWEN_IO_REQUEST *element);
03846 
03850   uint32_t GWEN_Io_Request_List_GetCount(const GWEN_IO_REQUEST_LIST *l);
03851 
03852 #ifdef __cplusplus
03853 }
03854 #endif
03855 
03856 
03857 #endif
03858 
03859 
03860 
03861 /***************************************************************************
03862  $RCSfile$
03863  -------------------
03864  cvs         : $Id$
03865  begin       : Sat Jun 28 2003
03866  copyright   : (C) 2003 by Martin Preuss
03867  email       : martin@libchipcard.de
03868 
03869  ***************************************************************************
03870  *                                                                         *
03871  *   This library is free software; you can redistribute it and/or         *
03872  *   modify it under the terms of the GNU Lesser General Public            *
03873  *   License as published by the Free Software Foundation; either          *
03874  *   version 2.1 of the License, or (at your option) any later version.    *
03875  *                                                                         *
03876  *   This library is distributed in the hope that it will be useful,       *
03877  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
03878  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
03879  *   Lesser General Public License for more details.                       *
03880  *                                                                         *
03881  *   You should have received a copy of the GNU Lesser General Public      *
03882  *   License along with this library; if not, write to the Free Software   *
03883  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
03884  *   MA  02111-1307  USA                                                   *
03885  *                                                                         *
03886  ***************************************************************************/
03887 
03888 
03889 #ifndef GWEN_CRYPT_KEY_LIST2_H
03890 #define GWEN_CRYPT_KEY_LIST2_H
03891 
03892 
03893 #ifdef __cplusplus
03894 extern "C" {
03895 #endif
03896 
03903   typedef struct GWEN_CRYPT_KEY_LIST2 GWEN_CRYPT_KEY_LIST2;
03904 
03908   typedef struct GWEN_CRYPT_KEY_LIST2_ITERATOR GWEN_CRYPT_KEY_LIST2_ITERATOR;
03909 
03913   typedef GWEN_CRYPT_KEY* (GWEN_CRYPT_KEY_LIST2_FOREACH)(GWEN_CRYPT_KEY *element,
03914                                                  void *user_data);
03915 
03919   GWEN_CRYPT_KEY_LIST2 *GWEN_Crypt_Key_List2_new(); 
03920 
03924   void GWEN_Crypt_Key_List2_free(GWEN_CRYPT_KEY_LIST2 *l); 
03925 
03929   void GWEN_Crypt_Key_List2_Dump(GWEN_CRYPT_KEY_LIST2 *l, FILE *f, unsigned int indent); 
03930 
03934   void GWEN_Crypt_Key_List2_PushBack(GWEN_CRYPT_KEY_LIST2 *l, GWEN_CRYPT_KEY *p); 
03935    
03940   void GWEN_Crypt_Key_List2_PushFront(GWEN_CRYPT_KEY_LIST2 *l, GWEN_CRYPT_KEY *p); 
03941 
03946   GWEN_CRYPT_KEY *GWEN_Crypt_Key_List2_GetFront(GWEN_CRYPT_KEY_LIST2 *l); 
03947    
03952   GWEN_CRYPT_KEY *GWEN_Crypt_Key_List2_GetBack(GWEN_CRYPT_KEY_LIST2 *l); 
03953 
03958   void GWEN_Crypt_Key_List2_Erase(GWEN_CRYPT_KEY_LIST2 *l,
03959                                GWEN_CRYPT_KEY_LIST2_ITERATOR *it);
03960 
03966   unsigned int GWEN_Crypt_Key_List2_GetSize(GWEN_CRYPT_KEY_LIST2 *l); 
03967 
03972   void GWEN_Crypt_Key_List2_PopBack(GWEN_CRYPT_KEY_LIST2 *l); 
03973    
03978   void GWEN_Crypt_Key_List2_PopFront(GWEN_CRYPT_KEY_LIST2 *l); 
03979 
03983   void GWEN_Crypt_Key_List2_Clear(GWEN_CRYPT_KEY_LIST2 *l); 
03984 
03988   GWEN_CRYPT_KEY_LIST2_ITERATOR *GWEN_Crypt_Key_List2_First(GWEN_CRYPT_KEY_LIST2 *l); 
03989    
03993   GWEN_CRYPT_KEY_LIST2_ITERATOR *GWEN_Crypt_Key_List2_Last(GWEN_CRYPT_KEY_LIST2 *l); 
03994 
03998   GWEN_CRYPT_KEY_LIST2_ITERATOR *GWEN_Crypt_Key_List2Iterator_new(GWEN_CRYPT_KEY_LIST2 *l);
03999 
04003   void GWEN_Crypt_Key_List2Iterator_free(GWEN_CRYPT_KEY_LIST2_ITERATOR *li); 
04004 
04009   GWEN_CRYPT_KEY *GWEN_Crypt_Key_List2Iterator_Previous(GWEN_CRYPT_KEY_LIST2_ITERATOR *li); 
04010    
04015   GWEN_CRYPT_KEY *GWEN_Crypt_Key_List2Iterator_Next(GWEN_CRYPT_KEY_LIST2_ITERATOR *li); 
04016 
04021   GWEN_CRYPT_KEY *GWEN_Crypt_Key_List2Iterator_Data(GWEN_CRYPT_KEY_LIST2_ITERATOR *li); 
04022 
04034   GWEN_CRYPT_KEY *GWEN_Crypt_Key_List2_ForEach(GWEN_CRYPT_KEY_LIST2 *list,
04035                                         GWEN_CRYPT_KEY_LIST2_FOREACH func,
04036                                         void *user_data);
04037 
04038 
04039   typedef struct GWEN_CRYPT_KEY_CONSTLIST2 GWEN_CRYPT_KEY_CONSTLIST2; 
04040   typedef struct GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR; 
04041   typedef const GWEN_CRYPT_KEY*
04042     (GWEN_CRYPT_KEY_CONSTLIST2_FOREACH)(const GWEN_CRYPT_KEY *element,
04043                                     void *user_data);
04044   
04045    
04046   GWEN_CRYPT_KEY_CONSTLIST2 *GWEN_Crypt_Key_ConstList2_new(); 
04047    
04048   void GWEN_Crypt_Key_ConstList2_free(GWEN_CRYPT_KEY_CONSTLIST2 *l); 
04049    
04050   void GWEN_Crypt_Key_ConstList2_PushBack(GWEN_CRYPT_KEY_CONSTLIST2 *l, const GWEN_CRYPT_KEY *p); 
04051    
04052   void GWEN_Crypt_Key_ConstList2_PushFront(GWEN_CRYPT_KEY_CONSTLIST2 *l, const GWEN_CRYPT_KEY *p); 
04053    
04054   const GWEN_CRYPT_KEY *GWEN_Crypt_Key_ConstList2_GetFront(GWEN_CRYPT_KEY_CONSTLIST2 *l); 
04055    
04056   const GWEN_CRYPT_KEY *GWEN_Crypt_Key_ConstList2_GetBack(GWEN_CRYPT_KEY_CONSTLIST2 *l); 
04057    
04058   unsigned int GWEN_Crypt_Key_ConstList2_GetSize(GWEN_CRYPT_KEY_CONSTLIST2 *l); 
04059    
04060   void GWEN_Crypt_Key_ConstList2_PopBack(GWEN_CRYPT_KEY_CONSTLIST2 *l); 
04061    
04062   void GWEN_Crypt_Key_ConstList2_PopFront(GWEN_CRYPT_KEY_CONSTLIST2 *l); 
04063    
04064   void GWEN_Crypt_Key_ConstList2_Clear(GWEN_CRYPT_KEY_CONSTLIST2 *l); 
04065    
04066   GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR *GWEN_Crypt_Key_ConstList2_First(GWEN_CRYPT_KEY_CONSTLIST2 *l); 
04067    
04068   GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR *GWEN_Crypt_Key_ConstList2_Last(GWEN_CRYPT_KEY_CONSTLIST2 *l); 
04069    
04070   GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR *GWEN_Crypt_Key_ConstList2Iterator_new(GWEN_CRYPT_KEY_CONSTLIST2 *l); 
04071    
04072   void GWEN_Crypt_Key_ConstList2Iterator_free(GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR *li); 
04073    
04074   const GWEN_CRYPT_KEY *GWEN_Crypt_Key_ConstList2Iterator_Previous(GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR *li); 
04075    
04076   const GWEN_CRYPT_KEY *GWEN_Crypt_Key_ConstList2Iterator_Next(GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR *li); 
04077    
04078   const GWEN_CRYPT_KEY *GWEN_Crypt_Key_ConstList2Iterator_Data(GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR *li); 
04079    
04091   const GWEN_CRYPT_KEY *GWEN_Crypt_Key_ConstList2_ForEach(GWEN_CRYPT_KEY_CONSTLIST2 *list,
04092         GWEN_CRYPT_KEY_CONSTLIST2_FOREACH func, void *user_data);
04093 
04094 
04095 #ifdef __cplusplus
04096 }
04097 #endif
04098 
04099 
04100 #endif /* GWEN_CRYPT_KEY_LIST_H */
04101 
04102 
04103 
04104 /***************************************************************************
04105  $RCSfile$
04106  -------------------
04107  cvs         : $Id$
04108  begin       : Sat Jun 28 2003
04109  copyright   : (C) 2003 by Martin Preuss
04110  email       : martin@libchipcard.de
04111 
04112  ***************************************************************************
04113  *                                                                         *
04114  *   This library is free software; you can redistribute it and/or         *
04115  *   modify it under the terms of the GNU Lesser General Public            *
04116  *   License as published by the Free Software Foundation; either          *
04117  *   version 2.1 of the License, or (at your option) any later version.    *
04118  *                                                                         *
04119  *   This library is distributed in the hope that it will be useful,       *
04120  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
04121  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
04122  *   Lesser General Public License for more details.                       *
04123  *                                                                         *
04124  *   You should have received a copy of the GNU Lesser General Public      *
04125  *   License along with this library; if not, write to the Free Software   *
04126  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
04127  *   MA  02111-1307  USA                                                   *
04128  *                                                                         *
04129  ***************************************************************************/
04130 
04131 
04132 #ifndef GWEN_CRYPT_KEY_LIST1_H
04133 #define GWEN_CRYPT_KEY_LIST1_H
04134 
04135 #ifdef __cplusplus
04136 extern "C" {
04137 #endif
04138 
04140   typedef struct GWEN_CRYPT_KEY_LIST_ELEMENT {
04141     uint32_t id;
04142     GWEN_CRYPT_KEY *nextObject;
04143   } GWEN_CRYPT_KEY_LIST__ELEMENT;
04144 
04151   typedef struct GWEN_CRYPT_KEY_LIST GWEN_CRYPT_KEY_LIST;
04153   struct GWEN_CRYPT_KEY_LIST {
04154     GWEN_CRYPT_KEY *first;
04155     uint32_t count;
04156     uint32_t id;
04157   } GWEN_CRYPT_KEY_LIST;
04158 
04163   void GWEN_Crypt_Key_List_AddList(GWEN_CRYPT_KEY_LIST *dst, GWEN_CRYPT_KEY_LIST *l);
04164 
04168   void GWEN_Crypt_Key_List_Add(GWEN_CRYPT_KEY *element, GWEN_CRYPT_KEY_LIST *list);
04169 
04174   void GWEN_Crypt_Key_List_Insert(GWEN_CRYPT_KEY *element, GWEN_CRYPT_KEY_LIST *list);
04175 
04182   void GWEN_Crypt_Key_List_Del(GWEN_CRYPT_KEY *element);
04183 
04187   GWEN_CRYPT_KEY* GWEN_Crypt_Key_List_First(const GWEN_CRYPT_KEY_LIST *l);
04188 
04192   GWEN_CRYPT_KEY* GWEN_Crypt_Key_List_Last(const GWEN_CRYPT_KEY_LIST *l);
04193 
04198   void GWEN_Crypt_Key_List_Clear(GWEN_CRYPT_KEY_LIST *l);
04199 
04203   GWEN_CRYPT_KEY_LIST* GWEN_Crypt_Key_List_new();
04204 
04208   void GWEN_Crypt_Key_List_free(GWEN_CRYPT_KEY_LIST *l);
04209 
04213   GWEN_CRYPT_KEY* GWEN_Crypt_Key_List_Next(const GWEN_CRYPT_KEY *element);
04214 
04218   GWEN_CRYPT_KEY* GWEN_Crypt_Key_List_Previous(const GWEN_CRYPT_KEY *element);
04219 
04223   uint32_t GWEN_Crypt_Key_List_GetCount(const GWEN_CRYPT_KEY_LIST *l);
04224 
04225 #ifdef __cplusplus
04226 }
04227 #endif
04228 
04229 
04230 #endif
04231 
04232 
04233 
04234 /***************************************************************************
04235  $RCSfile$
04236  -------------------
04237  cvs         : $Id$
04238  begin       : Sat Jun 28 2003
04239  copyright   : (C) 2003 by Martin Preuss
04240  email       : martin@libchipcard.de
04241 
04242  ***************************************************************************
04243  *                                                                         *
04244  *   This library is free software; you can redistribute it and/or         *
04245  *   modify it under the terms of the GNU Lesser General Public            *
04246  *   License as published by the Free Software Foundation; either          *
04247  *   version 2.1 of the License, or (at your option) any later version.    *
04248  *                                                                         *
04249  *   This library is distributed in the hope that it will be useful,       *
04250  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
04251  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
04252  *   Lesser General Public License for more details.                       *
04253  *                                                                         *
04254  *   You should have received a copy of the GNU Lesser General Public      *
04255  *   License along with this library; if not, write to the Free Software   *
04256  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
04257  *   MA  02111-1307  USA                                                   *
04258  *                                                                         *
04259  ***************************************************************************/
04260 
04261 
04262 #ifndef GWEN_SSLCERTDESCR_LIST2_H
04263 #define GWEN_SSLCERTDESCR_LIST2_H
04264 
04265 
04266 #ifdef __cplusplus
04267 extern "C" {
04268 #endif
04269 
04276   typedef struct GWEN_SSLCERTDESCR_LIST2 GWEN_SSLCERTDESCR_LIST2;
04277 
04281   typedef struct GWEN_SSLCERTDESCR_LIST2_ITERATOR GWEN_SSLCERTDESCR_LIST2_ITERATOR;
04282 
04286   typedef GWEN_SSLCERTDESCR* (GWEN_SSLCERTDESCR_LIST2_FOREACH)(GWEN_SSLCERTDESCR *element,
04287                                                  void *user_data);
04288 
04292   GWEN_SSLCERTDESCR_LIST2 *GWEN_SslCertDescr_List2_new(); 
04293 
04297   void GWEN_SslCertDescr_List2_free(GWEN_SSLCERTDESCR_LIST2 *l); 
04298 
04302   void GWEN_SslCertDescr_List2_Dump(GWEN_SSLCERTDESCR_LIST2 *l, FILE *f, unsigned int indent); 
04303 
04307   void GWEN_SslCertDescr_List2_PushBack(GWEN_SSLCERTDESCR_LIST2 *l, GWEN_SSLCERTDESCR *p); 
04308    
04313   void GWEN_SslCertDescr_List2_PushFront(GWEN_SSLCERTDESCR_LIST2 *l, GWEN_SSLCERTDESCR *p); 
04314 
04319   GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2_GetFront(GWEN_SSLCERTDESCR_LIST2 *l); 
04320    
04325   GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2_GetBack(GWEN_SSLCERTDESCR_LIST2 *l); 
04326 
04331   void GWEN_SslCertDescr_List2_Erase(GWEN_SSLCERTDESCR_LIST2 *l,
04332                                GWEN_SSLCERTDESCR_LIST2_ITERATOR *it);
04333 
04339   unsigned int GWEN_SslCertDescr_List2_GetSize(GWEN_SSLCERTDESCR_LIST2 *l); 
04340 
04345   void GWEN_SslCertDescr_List2_PopBack(GWEN_SSLCERTDESCR_LIST2 *l); 
04346    
04351   void GWEN_SslCertDescr_List2_PopFront(GWEN_SSLCERTDESCR_LIST2 *l); 
04352 
04356   void GWEN_SslCertDescr_List2_Clear(GWEN_SSLCERTDESCR_LIST2 *l); 
04357 
04361   GWEN_SSLCERTDESCR_LIST2_ITERATOR *GWEN_SslCertDescr_List2_First(GWEN_SSLCERTDESCR_LIST2 *l); 
04362    
04366   GWEN_SSLCERTDESCR_LIST2_ITERATOR *GWEN_SslCertDescr_List2_Last(GWEN_SSLCERTDESCR_LIST2 *l); 
04367 
04371   GWEN_SSLCERTDESCR_LIST2_ITERATOR *GWEN_SslCertDescr_List2Iterator_new(GWEN_SSLCERTDESCR_LIST2 *l);
04372 
04376   void GWEN_SslCertDescr_List2Iterator_free(GWEN_SSLCERTDESCR_LIST2_ITERATOR *li); 
04377 
04382   GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2Iterator_Previous(GWEN_SSLCERTDESCR_LIST2_ITERATOR *li); 
04383    
04388   GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2Iterator_Next(GWEN_SSLCERTDESCR_LIST2_ITERATOR *li); 
04389 
04394   GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2Iterator_Data(GWEN_SSLCERTDESCR_LIST2_ITERATOR *li); 
04395 
04407   GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2_ForEach(GWEN_SSLCERTDESCR_LIST2 *list,
04408                                         GWEN_SSLCERTDESCR_LIST2_FOREACH func,
04409                                         void *user_data);
04410 
04411 
04412   typedef struct GWEN_SSLCERTDESCR_CONSTLIST2 GWEN_SSLCERTDESCR_CONSTLIST2; 
04413   typedef struct GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR; 
04414   typedef const GWEN_SSLCERTDESCR*
04415     (GWEN_SSLCERTDESCR_CONSTLIST2_FOREACH)(const GWEN_SSLCERTDESCR *element,
04416                                     void *user_data);
04417   
04418    
04419   GWEN_SSLCERTDESCR_CONSTLIST2 *GWEN_SslCertDescr_ConstList2_new(); 
04420    
04421   void GWEN_SslCertDescr_ConstList2_free(GWEN_SSLCERTDESCR_CONSTLIST2 *l); 
04422    
04423   void GWEN_SslCertDescr_ConstList2_PushBack(GWEN_SSLCERTDESCR_CONSTLIST2 *l, const GWEN_SSLCERTDESCR *p); 
04424    
04425   void GWEN_SslCertDescr_ConstList2_PushFront(GWEN_SSLCERTDESCR_CONSTLIST2 *l, const GWEN_SSLCERTDESCR *p); 
04426    
04427   const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2_GetFront(GWEN_SSLCERTDESCR_CONSTLIST2 *l); 
04428    
04429   const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2_GetBack(GWEN_SSLCERTDESCR_CONSTLIST2 *l); 
04430    
04431   unsigned int GWEN_SslCertDescr_ConstList2_GetSize(GWEN_SSLCERTDESCR_CONSTLIST2 *l); 
04432    
04433   void GWEN_SslCertDescr_ConstList2_PopBack(GWEN_SSLCERTDESCR_CONSTLIST2 *l); 
04434    
04435   void GWEN_SslCertDescr_ConstList2_PopFront(GWEN_SSLCERTDESCR_CONSTLIST2 *l); 
04436    
04437   void GWEN_SslCertDescr_ConstList2_Clear(GWEN_SSLCERTDESCR_CONSTLIST2 *l); 
04438    
04439   GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *GWEN_SslCertDescr_ConstList2_First(GWEN_SSLCERTDESCR_CONSTLIST2 *l); 
04440    
04441   GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *GWEN_SslCertDescr_ConstList2_Last(GWEN_SSLCERTDESCR_CONSTLIST2 *l); 
04442    
04443   GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *GWEN_SslCertDescr_ConstList2Iterator_new(GWEN_SSLCERTDESCR_CONSTLIST2 *l); 
04444    
04445   void GWEN_SslCertDescr_ConstList2Iterator_free(GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *li); 
04446    
04447   const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2Iterator_Previous(GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *li); 
04448    
04449   const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2Iterator_Next(GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *li); 
04450    
04451   const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2Iterator_Data(GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *li); 
04452    
04464   const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2_ForEach(GWEN_SSLCERTDESCR_CONSTLIST2 *list,
04465         GWEN_SSLCERTDESCR_CONSTLIST2_FOREACH func, void *user_data);
04466 
04467 
04468 #ifdef __cplusplus
04469 }
04470 #endif
04471 
04472 
04473 #endif /* GWEN_SSLCERTDESCR_LIST_H */
04474 
04475 
04476 
04477 /***************************************************************************
04478  $RCSfile$
04479  -------------------
04480  cvs         : $Id$
04481  begin       : Sat Jun 28 2003
04482  copyright   : (C) 2003 by Martin Preuss
04483  email       : martin@libchipcard.de
04484 
04485  ***************************************************************************
04486  *                                                                         *
04487  *   This library is free software; you can redistribute it and/or         *
04488  *   modify it under the terms of the GNU Lesser General Public            *
04489  *   License as published by the Free Software Foundation; either          *
04490  *   version 2.1 of the License, or (at your option) any later version.    *
04491  *                                                                         *
04492  *   This library is distributed in the hope that it will be useful,       *
04493  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
04494  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
04495  *   Lesser General Public License for more details.                       *
04496  *                                                                         *
04497  *   You should have received a copy of the GNU Lesser General Public      *
04498  *   License along with this library; if not, write to the Free Software   *
04499  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
04500  *   MA  02111-1307  USA                                                   *
04501  *                                                                         *
04502  ***************************************************************************/
04503 
04504 
04505 #ifndef GWEN_SSLCERTDESCR_LIST1_H
04506 #define GWEN_SSLCERTDESCR_LIST1_H
04507 
04508 #ifdef __cplusplus
04509 extern "C" {
04510 #endif
04511 
04513   typedef struct GWEN_SSLCERTDESCR_LIST_ELEMENT {
04514     uint32_t id;
04515     GWEN_SSLCERTDESCR *nextObject;
04516   } GWEN_SSLCERTDESCR_LIST__ELEMENT;
04517 
04524   typedef struct GWEN_SSLCERTDESCR_LIST GWEN_SSLCERTDESCR_LIST;
04526   struct GWEN_SSLCERTDESCR_LIST {
04527     GWEN_SSLCERTDESCR *first;
04528     uint32_t count;
04529     uint32_t id;
04530   } GWEN_SSLCERTDESCR_LIST;
04531 
04536   void GWEN_SslCertDescr_List_AddList(GWEN_SSLCERTDESCR_LIST *dst, GWEN_SSLCERTDESCR_LIST *l);
04537 
04541   void GWEN_SslCertDescr_List_Add(GWEN_SSLCERTDESCR *element, GWEN_SSLCERTDESCR_LIST *list);
04542 
04547   void GWEN_SslCertDescr_List_Insert(GWEN_SSLCERTDESCR *element, GWEN_SSLCERTDESCR_LIST *list);
04548 
04555   void GWEN_SslCertDescr_List_Del(GWEN_SSLCERTDESCR *element);
04556 
04560   GWEN_SSLCERTDESCR* GWEN_SslCertDescr_List_First(const GWEN_SSLCERTDESCR_LIST *l);
04561 
04565   GWEN_SSLCERTDESCR* GWEN_SslCertDescr_List_Last(const GWEN_SSLCERTDESCR_LIST *l);
04566 
04571   void GWEN_SslCertDescr_List_Clear(GWEN_SSLCERTDESCR_LIST *l);
04572 
04576   GWEN_SSLCERTDESCR_LIST* GWEN_SslCertDescr_List_new();
04577 
04581   void GWEN_SslCertDescr_List_free(GWEN_SSLCERTDESCR_LIST *l);
04582 
04586   GWEN_SSLCERTDESCR* GWEN_SslCertDescr_List_Next(const GWEN_SSLCERTDESCR *element);
04587 
04591   GWEN_SSLCERTDESCR* GWEN_SslCertDescr_List_Previous(const GWEN_SSLCERTDESCR *element);
04592 
04596   uint32_t GWEN_SslCertDescr_List_GetCount(const GWEN_SSLCERTDESCR_LIST *l);
04597 
04598 #ifdef __cplusplus
04599 }
04600 #endif
04601 
04602 
04603 #endif
04604 
04605 
04606 
04607 /***************************************************************************
04608  $RCSfile$
04609  -------------------
04610  cvs         : $Id$
04611  begin       : Sat Jun 28 2003
04612  copyright   : (C) 2003 by Martin Preuss
04613  email       : martin@libchipcard.de
04614 
04615  ***************************************************************************
04616  *                                                                         *
04617  *   This library is free software; you can redistribute it and/or         *
04618  *   modify it under the terms of the GNU Lesser General Public            *
04619  *   License as published by the Free Software Foundation; either          *
04620  *   version 2.1 of the License, or (at your option) any later version.    *
04621  *                                                                         *
04622  *   This library is distributed in the hope that it will be useful,       *
04623  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
04624  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
04625  *   Lesser General Public License for more details.                       *
04626  *                                                                         *
04627  *   You should have received a copy of the GNU Lesser General Public      *
04628  *   License along with this library; if not, write to the Free Software   *
04629  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
04630  *   MA  02111-1307  USA                                                   *
04631  *                                                                         *
04632  ***************************************************************************/
04633 
04634 
04635 #ifndef t_LIST1_H
04636 #define t_LIST1_H
04637 
04638 #ifdef __cplusplus
04639 extern "C" {
04640 #endif
04641 
04643   typedef struct t_LIST_ELEMENT {
04644     uint32_t id;
04645     t *nextObject;
04646   } t_LIST__ELEMENT;
04647 
04654   typedef struct t_LIST t_LIST;
04656   struct t_LIST {
04657     t *first;
04658     uint32_t count;
04659     uint32_t id;
04660   } t_LIST;
04661 
04666   void pr_List_AddList(t_LIST *dst, t_LIST *l);
04667 
04671   void pr_List_Add(t *element, t_LIST *list);
04672 
04677   void pr_List_Insert(t *element, t_LIST *list);
04678 
04685   void pr_List_Del(t *element);
04686 
04690   t* pr_List_First(const t_LIST *l);
04691 
04695   t* pr_List_Last(const t_LIST *l);
04696 
04701   void pr_List_Clear(t_LIST *l);
04702 
04706   t_LIST* pr_List_new();
04707 
04711   void pr_List_free(t_LIST *l);
04712 
04716   t* pr_List_Next(const t *element);
04717 
04721   t* pr_List_Previous(const t *element);
04722 
04726   uint32_t pr_List_GetCount(const t_LIST *l);
04727 
04728 #ifdef __cplusplus
04729 }
04730 #endif
04731 
04732 
04733 #endif
04734 
04735 
04736 
04737 /***************************************************************************
04738  $RCSfile$
04739  -------------------
04740  cvs         : $Id$
04741  begin       : Sat Jun 28 2003
04742  copyright   : (C) 2003 by Martin Preuss
04743  email       : martin@libchipcard.de
04744 
04745  ***************************************************************************
04746  *                                                                         *
04747  *   This library is free software; you can redistribute it and/or         *
04748  *   modify it under the terms of the GNU Lesser General Public            *
04749  *   License as published by the Free Software Foundation; either          *
04750  *   version 2.1 of the License, or (at your option) any later version.    *
04751  *                                                                         *
04752  *   This library is distributed in the hope that it will be useful,       *
04753  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
04754  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
04755  *   Lesser General Public License for more details.                       *
04756  *                                                                         *
04757  *   You should have received a copy of the GNU Lesser General Public      *
04758  *   License along with this library; if not, write to the Free Software   *
04759  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
04760  *   MA  02111-1307  USA                                                   *
04761  *                                                                         *
04762  ***************************************************************************/
04763 
04764 
04765 #ifndef MYSTRUCT_LIST1_H
04766 #define MYSTRUCT_LIST1_H
04767 
04768 #ifdef __cplusplus
04769 extern "C" {
04770 #endif
04771 
04773   typedef struct MYSTRUCT_LIST_ELEMENT {
04774     uint32_t id;
04775     MYSTRUCT *nextObject;
04776   } MYSTRUCT_LIST__ELEMENT;
04777 
04784   typedef struct MYSTRUCT_LIST MYSTRUCT_LIST;
04786   struct MYSTRUCT_LIST {
04787     MYSTRUCT *first;
04788     uint32_t count;
04789     uint32_t id;
04790   } MYSTRUCT_LIST;
04791 
04796   void MyStruct_List_AddList(MYSTRUCT_LIST *dst, MYSTRUCT_LIST *l);
04797 
04801   void MyStruct_List_Add(MYSTRUCT *element, MYSTRUCT_LIST *list);
04802 
04807   void MyStruct_List_Insert(MYSTRUCT *element, MYSTRUCT_LIST *list);
04808 
04815   void MyStruct_List_Del(MYSTRUCT *element);
04816 
04820   MYSTRUCT* MyStruct_List_First(const MYSTRUCT_LIST *l);
04821 
04825   MYSTRUCT* MyStruct_List_Last(const MYSTRUCT_LIST *l);
04826 
04831   void MyStruct_List_Clear(MYSTRUCT_LIST *l);
04832 
04836   MYSTRUCT_LIST* MyStruct_List_new();
04837 
04841   void MyStruct_List_free(MYSTRUCT_LIST *l);
04842 
04846   MYSTRUCT* MyStruct_List_Next(const MYSTRUCT *element);
04847 
04851   MYSTRUCT* MyStruct_List_Previous(const MYSTRUCT *element);
04852 
04856   uint32_t MyStruct_List_GetCount(const MYSTRUCT_LIST *l);
04857 
04858 #ifdef __cplusplus
04859 }
04860 #endif
04861 
04862 
04863 #endif
04864 
04865 
04866 
04867 /***************************************************************************
04868  $RCSfile$
04869  -------------------
04870  cvs         : $Id$
04871  begin       : Sat Jun 28 2003
04872  copyright   : (C) 2003 by Martin Preuss
04873  email       : martin@libchipcard.de
04874 
04875  ***************************************************************************
04876  *                                                                         *
04877  *   This library is free software; you can redistribute it and/or         *
04878  *   modify it under the terms of the GNU Lesser General Public            *
04879  *   License as published by the Free Software Foundation; either          *
04880  *   version 2.1 of the License, or (at your option) any later version.    *
04881  *                                                                         *
04882  *   This library is distributed in the hope that it will be useful,       *
04883  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
04884  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
04885  *   Lesser General Public License for more details.                       *
04886  *                                                                         *
04887  *   You should have received a copy of the GNU Lesser General Public      *
04888  *   License along with this library; if not, write to the Free Software   *
04889  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
04890  *   MA  02111-1307  USA                                                   *
04891  *                                                                         *
04892  ***************************************************************************/
04893 
04894 
04895 #ifndef GWEN_INHERITDATA_LIST1_H
04896 #define GWEN_INHERITDATA_LIST1_H
04897 
04898 #ifdef __cplusplus
04899 extern "C" {
04900 #endif
04901 
04903   typedef struct GWEN_INHERITDATA_LIST_ELEMENT {
04904     uint32_t id;
04905     GWEN_INHERITDATA *nextObject;
04906   } GWEN_INHERITDATA_LIST__ELEMENT;
04907 
04914   typedef struct GWEN_INHERITDATA_LIST GWEN_INHERITDATA_LIST;
04916   struct GWEN_INHERITDATA_LIST {
04917     GWEN_INHERITDATA *first;
04918     uint32_t count;
04919     uint32_t id;
04920   } GWEN_INHERITDATA_LIST;
04921 
04926   void GWEN_InheritData_List_AddList(GWEN_INHERITDATA_LIST *dst, GWEN_INHERITDATA_LIST *l);
04927 
04931   void GWEN_InheritData_List_Add(GWEN_INHERITDATA *element, GWEN_INHERITDATA_LIST *list);
04932 
04937   void GWEN_InheritData_List_Insert(GWEN_INHERITDATA *element, GWEN_INHERITDATA_LIST *list);
04938 
04945   void GWEN_InheritData_List_Del(GWEN_INHERITDATA *element);
04946 
04950   GWEN_INHERITDATA* GWEN_InheritData_List_First(const GWEN_INHERITDATA_LIST *l);
04951 
04955   GWEN_INHERITDATA* GWEN_InheritData_List_Last(const GWEN_INHERITDATA_LIST *l);
04956 
04961   void GWEN_InheritData_List_Clear(GWEN_INHERITDATA_LIST *l);
04962 
04966   GWEN_INHERITDATA_LIST* GWEN_InheritData_List_new();
04967 
04971   void GWEN_InheritData_List_free(GWEN_INHERITDATA_LIST *l);
04972 
04976   GWEN_INHERITDATA* GWEN_InheritData_List_Next(const GWEN_INHERITDATA *element);
04977 
04981   GWEN_INHERITDATA* GWEN_InheritData_List_Previous(const GWEN_INHERITDATA *element);
04982 
04986   uint32_t GWEN_InheritData_List_GetCount(const GWEN_INHERITDATA_LIST *l);
04987 
04988 #ifdef __cplusplus
04989 }
04990 #endif
04991 
04992 
04993 #endif
04994 
04995 
04996 
04997 /***************************************************************************
04998  $RCSfile$
04999  -------------------
05000  cvs         : $Id$
05001  begin       : Sat Jun 28 2003
05002  copyright   : (C) 2003 by Martin Preuss
05003  email       : martin@libchipcard.de
05004 
05005  ***************************************************************************
05006  *                                                                         *
05007  *   This library is free software; you can redistribute it and/or         *
05008  *   modify it under the terms of the GNU Lesser General Public            *
05009  *   License as published by the Free Software Foundation; either          *
05010  *   version 2.1 of the License, or (at your option) any later version.    *
05011  *                                                                         *
05012  *   This library is distributed in the hope that it will be useful,       *
05013  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
05014  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
05015  *   Lesser General Public License for more details.                       *
05016  *                                                                         *
05017  *   You should have received a copy of the GNU Lesser General Public      *
05018  *   License along with this library; if not, write to the Free Software   *
05019  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
05020  *   MA  02111-1307  USA                                                   *
05021  *                                                                         *
05022  ***************************************************************************/
05023 
05024 
05025 #ifndef GWEN_XSD_NODE_LIST1_H
05026 #define GWEN_XSD_NODE_LIST1_H
05027 
05028 #ifdef __cplusplus
05029 extern "C" {
05030 #endif
05031 
05033   typedef struct GWEN_XSD_NODE_LIST_ELEMENT {
05034     uint32_t id;
05035     GWEN_XSD_NODE *nextObject;
05036   } GWEN_XSD_NODE_LIST__ELEMENT;
05037 
05044   typedef struct GWEN_XSD_NODE_LIST GWEN_XSD_NODE_LIST;
05046   struct GWEN_XSD_NODE_LIST {
05047     GWEN_XSD_NODE *first;
05048     uint32_t count;
05049     uint32_t id;
05050   } GWEN_XSD_NODE_LIST;
05051 
05056   void GWEN_XsdNode_List_AddList(GWEN_XSD_NODE_LIST *dst, GWEN_XSD_NODE_LIST *l);
05057 
05061   void GWEN_XsdNode_List_Add(GWEN_XSD_NODE *element, GWEN_XSD_NODE_LIST *list);
05062 
05067   void GWEN_XsdNode_List_Insert(GWEN_XSD_NODE *element, GWEN_XSD_NODE_LIST *list);
05068 
05075   void GWEN_XsdNode_List_Del(GWEN_XSD_NODE *element);
05076 
05080   GWEN_XSD_NODE* GWEN_XsdNode_List_First(const GWEN_XSD_NODE_LIST *l);
05081 
05085   GWEN_XSD_NODE* GWEN_XsdNode_List_Last(const GWEN_XSD_NODE_LIST *l);
05086 
05091   void GWEN_XsdNode_List_Clear(GWEN_XSD_NODE_LIST *l);
05092 
05096   GWEN_XSD_NODE_LIST* GWEN_XsdNode_List_new();
05097 
05101   void GWEN_XsdNode_List_free(GWEN_XSD_NODE_LIST *l);
05102 
05106   GWEN_XSD_NODE* GWEN_XsdNode_List_Next(const GWEN_XSD_NODE *element);
05107 
05111   GWEN_XSD_NODE* GWEN_XsdNode_List_Previous(const GWEN_XSD_NODE *element);
05112 
05116   uint32_t GWEN_XsdNode_List_GetCount(const GWEN_XSD_NODE_LIST *l);
05117 
05118 #ifdef __cplusplus
05119 }
05120 #endif
05121 
05122 
05123 #endif
05124 
05125 
05126 
05127 /***************************************************************************
05128  $RCSfile$
05129  -------------------
05130  cvs         : $Id$
05131  begin       : Sat Jun 28 2003
05132  copyright   : (C) 2003 by Martin Preuss
05133  email       : martin@libchipcard.de
05134 
05135  ***************************************************************************
05136  *                                                                         *
05137  *   This library is free software; you can redistribute it and/or         *
05138  *   modify it under the terms of the GNU Lesser General Public            *
05139  *   License as published by the Free Software Foundation; either          *
05140  *   version 2.1 of the License, or (at your option) any later version.    *
05141  *                                                                         *
05142  *   This library is distributed in the hope that it will be useful,       *
05143  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
05144  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
05145  *   Lesser General Public License for more details.                       *
05146  *                                                                         *
05147  *   You should have received a copy of the GNU Lesser General Public      *
05148  *   License along with this library; if not, write to the Free Software   *
05149  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
05150  *   MA  02111-1307  USA                                                   *
05151  *                                                                         *
05152  ***************************************************************************/
05153 
05154 
05155 #ifndef GWEN_CRYPT_CRYPTALGO_LIST2_H
05156 #define GWEN_CRYPT_CRYPTALGO_LIST2_H
05157 
05158 
05159 #ifdef __cplusplus
05160 extern "C" {
05161 #endif
05162 
05169   typedef struct GWEN_CRYPT_CRYPTALGO_LIST2 GWEN_CRYPT_CRYPTALGO_LIST2;
05170 
05174   typedef struct GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR;
05175 
05179   typedef GWEN_CRYPT_CRYPTALGO* (GWEN_CRYPT_CRYPTALGO_LIST2_FOREACH)(GWEN_CRYPT_CRYPTALGO *element,
05180                                                  void *user_data);
05181 
05185   GWEN_CRYPT_CRYPTALGO_LIST2 *GWEN_Crypt_CryptAlgo_List2_new(); 
05186 
05190   void GWEN_Crypt_CryptAlgo_List2_free(GWEN_CRYPT_CRYPTALGO_LIST2 *l); 
05191 
05195   void GWEN_Crypt_CryptAlgo_List2_Dump(GWEN_CRYPT_CRYPTALGO_LIST2 *l, FILE *f, unsigned int indent); 
05196 
05200   void GWEN_Crypt_CryptAlgo_List2_PushBack(GWEN_CRYPT_CRYPTALGO_LIST2 *l, GWEN_CRYPT_CRYPTALGO *p); 
05201    
05206   void GWEN_Crypt_CryptAlgo_List2_PushFront(GWEN_CRYPT_CRYPTALGO_LIST2 *l, GWEN_CRYPT_CRYPTALGO *p); 
05207 
05212   GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_List2_GetFront(GWEN_CRYPT_CRYPTALGO_LIST2 *l); 
05213    
05218   GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_List2_GetBack(GWEN_CRYPT_CRYPTALGO_LIST2 *l); 
05219 
05224   void GWEN_Crypt_CryptAlgo_List2_Erase(GWEN_CRYPT_CRYPTALGO_LIST2 *l,
05225                                GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *it);
05226 
05232   unsigned int GWEN_Crypt_CryptAlgo_List2_GetSize(GWEN_CRYPT_CRYPTALGO_LIST2 *l); 
05233 
05238   void GWEN_Crypt_CryptAlgo_List2_PopBack(GWEN_CRYPT_CRYPTALGO_LIST2 *l); 
05239    
05244   void GWEN_Crypt_CryptAlgo_List2_PopFront(GWEN_CRYPT_CRYPTALGO_LIST2 *l); 
05245 
05249   void GWEN_Crypt_CryptAlgo_List2_Clear(GWEN_CRYPT_CRYPTALGO_LIST2 *l); 
05250 
05254   GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *GWEN_Crypt_CryptAlgo_List2_First(GWEN_CRYPT_CRYPTALGO_LIST2 *l); 
05255    
05259   GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *GWEN_Crypt_CryptAlgo_List2_Last(GWEN_CRYPT_CRYPTALGO_LIST2 *l); 
05260 
05264   GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *GWEN_Crypt_CryptAlgo_List2Iterator_new(GWEN_CRYPT_CRYPTALGO_LIST2 *l);
05265 
05269   void GWEN_Crypt_CryptAlgo_List2Iterator_free(GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *li); 
05270 
05275   GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_List2Iterator_Previous(GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *li); 
05276    
05281   GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_List2Iterator_Next(GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *li); 
05282 
05287   GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_List2Iterator_Data(GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *li); 
05288 
05300   GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_List2_ForEach(GWEN_CRYPT_CRYPTALGO_LIST2 *list,
05301                                         GWEN_CRYPT_CRYPTALGO_LIST2_FOREACH func,
05302                                         void *user_data);
05303 
05304 
05305   typedef struct GWEN_CRYPT_CRYPTALGO_CONSTLIST2 GWEN_CRYPT_CRYPTALGO_CONSTLIST2; 
05306   typedef struct GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR; 
05307   typedef const GWEN_CRYPT_CRYPTALGO*
05308     (GWEN_CRYPT_CRYPTALGO_CONSTLIST2_FOREACH)(const GWEN_CRYPT_CRYPTALGO *element,
05309                                     void *user_data);
05310   
05311    
05312   GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *GWEN_Crypt_CryptAlgo_ConstList2_new(); 
05313    
05314   void GWEN_Crypt_CryptAlgo_ConstList2_free(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l); 
05315    
05316   void GWEN_Crypt_CryptAlgo_ConstList2_PushBack(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l, const GWEN_CRYPT_CRYPTALGO *p); 
05317    
05318   void GWEN_Crypt_CryptAlgo_ConstList2_PushFront(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l, const GWEN_CRYPT_CRYPTALGO *p); 
05319    
05320   const GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_ConstList2_GetFront(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l); 
05321    
05322   const GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_ConstList2_GetBack(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l); 
05323    
05324   unsigned int GWEN_Crypt_CryptAlgo_ConstList2_GetSize(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l); 
05325    
05326   void GWEN_Crypt_CryptAlgo_ConstList2_PopBack(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l); 
05327    
05328   void GWEN_Crypt_CryptAlgo_ConstList2_PopFront(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l); 
05329    
05330   void GWEN_Crypt_CryptAlgo_ConstList2_Clear(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l); 
05331    
05332   GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_CryptAlgo_ConstList2_First(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l); 
05333    
05334   GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_CryptAlgo_ConstList2_Last(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l); 
05335    
05336   GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_CryptAlgo_ConstList2Iterator_new(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l); 
05337    
05338   void GWEN_Crypt_CryptAlgo_ConstList2Iterator_free(GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR *li); 
05339    
05340   const GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_ConstList2Iterator_Previous(GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR *li); 
05341    
05342   const GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_ConstList2Iterator_Next(GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR *li); 
05343    
05344   const GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_ConstList2Iterator_Data(GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR *li); 
05345    
05357   const GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_ConstList2_ForEach(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *list,
05358         GWEN_CRYPT_CRYPTALGO_CONSTLIST2_FOREACH func, void *user_data);
05359 
05360 
05361 #ifdef __cplusplus
05362 }
05363 #endif
05364 
05365 
05366 #endif /* GWEN_CRYPT_CRYPTALGO_LIST_H */
05367 
05368 
05369 
05370 /***************************************************************************
05371  $RCSfile$
05372  -------------------
05373  cvs         : $Id$
05374  begin       : Sat Jun 28 2003
05375  copyright   : (C) 2003 by Martin Preuss
05376  email       : martin@libchipcard.de
05377 
05378  ***************************************************************************
05379  *                                                                         *
05380  *   This library is free software; you can redistribute it and/or         *
05381  *   modify it under the terms of the GNU Lesser General Public            *
05382  *   License as published by the Free Software Foundation; either          *
05383  *   version 2.1 of the License, or (at your option) any later version.    *
05384  *                                                                         *
05385  *   This library is distributed in the hope that it will be useful,       *
05386  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
05387  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
05388  *   Lesser General Public License for more details.                       *
05389  *                                                                         *
05390  *   You should have received a copy of the GNU Lesser General Public      *
05391  *   License along with this library; if not, write to the Free Software   *
05392  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
05393  *   MA  02111-1307  USA                                                   *
05394  *                                                                         *
05395  ***************************************************************************/
05396 
05397 
05398 #ifndef GWEN_SIGHEAD_LIST1_H
05399 #define GWEN_SIGHEAD_LIST1_H
05400 
05401 #ifdef __cplusplus
05402 extern "C" {
05403 #endif
05404 
05406   typedef struct GWEN_SIGHEAD_LIST_ELEMENT {
05407     uint32_t id;
05408     GWEN_SIGHEAD *nextObject;
05409   } GWEN_SIGHEAD_LIST__ELEMENT;
05410 
05417   typedef struct GWEN_SIGHEAD_LIST GWEN_SIGHEAD_LIST;
05419   struct GWEN_SIGHEAD_LIST {
05420     GWEN_SIGHEAD *first;
05421     uint32_t count;
05422     uint32_t id;
05423   } GWEN_SIGHEAD_LIST;
05424 
05429   void GWEN_SigHead_List_AddList(GWEN_SIGHEAD_LIST *dst, GWEN_SIGHEAD_LIST *l);
05430 
05434   void GWEN_SigHead_List_Add(GWEN_SIGHEAD *element, GWEN_SIGHEAD_LIST *list);
05435 
05440   void GWEN_SigHead_List_Insert(GWEN_SIGHEAD *element, GWEN_SIGHEAD_LIST *list);
05441 
05448   void GWEN_SigHead_List_Del(GWEN_SIGHEAD *element);
05449 
05453   GWEN_SIGHEAD* GWEN_SigHead_List_First(const GWEN_SIGHEAD_LIST *l);
05454 
05458   GWEN_SIGHEAD* GWEN_SigHead_List_Last(const GWEN_SIGHEAD_LIST *l);
05459 
05464   void GWEN_SigHead_List_Clear(GWEN_SIGHEAD_LIST *l);
05465 
05469   GWEN_SIGHEAD_LIST* GWEN_SigHead_List_new();
05470 
05474   void GWEN_SigHead_List_free(GWEN_SIGHEAD_LIST *l);
05475 
05479   GWEN_SIGHEAD* GWEN_SigHead_List_Next(const GWEN_SIGHEAD *element);
05480 
05484   GWEN_SIGHEAD* GWEN_SigHead_List_Previous(const GWEN_SIGHEAD *element);
05485 
05489   uint32_t GWEN_SigHead_List_GetCount(const GWEN_SIGHEAD_LIST *l);
05490 
05491 #ifdef __cplusplus
05492 }
05493 #endif
05494 
05495 
05496 #endif
05497 
05498 
05499 
05500 /***************************************************************************
05501  $RCSfile$
05502  -------------------
05503  cvs         : $Id$
05504  begin       : Sat Jun 28 2003
05505  copyright   : (C) 2003 by Martin Preuss
05506  email       : martin@libchipcard.de
05507 
05508  ***************************************************************************
05509  *                                                                         *
05510  *   This library is free software; you can redistribute it and/or         *
05511  *   modify it under the terms of the GNU Lesser General Public            *
05512  *   License as published by the Free Software Foundation; either          *
05513  *   version 2.1 of the License, or (at your option) any later version.    *
05514  *                                                                         *
05515  *   This library is distributed in the hope that it will be useful,       *
05516  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
05517  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
05518  *   Lesser General Public License for more details.                       *
05519  *                                                                         *
05520  *   You should have received a copy of the GNU Lesser General Public      *
05521  *   License along with this library; if not, write to the Free Software   *
05522  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
05523  *   MA  02111-1307  USA                                                   *
05524  *                                                                         *
05525  ***************************************************************************/
05526 
05527 
05528 #ifndef GWEN_PLUGIN_DESCRIPTION_LIST2_H
05529 #define GWEN_PLUGIN_DESCRIPTION_LIST2_H
05530 
05531 
05532 #ifdef __cplusplus
05533 extern "C" {
05534 #endif
05535 
05542   typedef struct GWEN_PLUGIN_DESCRIPTION_LIST2 GWEN_PLUGIN_DESCRIPTION_LIST2;
05543 
05547   typedef struct GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR;
05548 
05552   typedef GWEN_PLUGIN_DESCRIPTION* (GWEN_PLUGIN_DESCRIPTION_LIST2_FOREACH)(GWEN_PLUGIN_DESCRIPTION *element,
05553                                                  void *user_data);
05554 
05558   GWEN_PLUGIN_DESCRIPTION_LIST2 *GWEN_PluginDescription_List2_new(); 
05559 
05563   void GWEN_PluginDescription_List2_free(GWEN_PLUGIN_DESCRIPTION_LIST2 *l); 
05564 
05568   void GWEN_PluginDescription_List2_Dump(GWEN_PLUGIN_DESCRIPTION_LIST2 *l, FILE *f, unsigned int indent); 
05569 
05573   void GWEN_PluginDescription_List2_PushBack(GWEN_PLUGIN_DESCRIPTION_LIST2 *l, GWEN_PLUGIN_DESCRIPTION *p); 
05574    
05579   void GWEN_PluginDescription_List2_PushFront(GWEN_PLUGIN_DESCRIPTION_LIST2 *l, GWEN_PLUGIN_DESCRIPTION *p); 
05580 
05585   GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_List2_GetFront(GWEN_PLUGIN_DESCRIPTION_LIST2 *l); 
05586    
05591   GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_List2_GetBack(GWEN_PLUGIN_DESCRIPTION_LIST2 *l); 
05592 
05597   void GWEN_PluginDescription_List2_Erase(GWEN_PLUGIN_DESCRIPTION_LIST2 *l,
05598                                GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *it);
05599 
05605   unsigned int GWEN_PluginDescription_List2_GetSize(GWEN_PLUGIN_DESCRIPTION_LIST2 *l); 
05606 
05611   void GWEN_PluginDescription_List2_PopBack(GWEN_PLUGIN_DESCRIPTION_LIST2 *l); 
05612    
05617   void GWEN_PluginDescription_List2_PopFront(GWEN_PLUGIN_DESCRIPTION_LIST2 *l); 
05618 
05622   void GWEN_PluginDescription_List2_Clear(GWEN_PLUGIN_DESCRIPTION_LIST2 *l); 
05623 
05627   GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *GWEN_PluginDescription_List2_First(GWEN_PLUGIN_DESCRIPTION_LIST2 *l); 
05628    
05632   GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *GWEN_PluginDescription_List2_Last(GWEN_PLUGIN_DESCRIPTION_LIST2 *l); 
05633 
05637   GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *GWEN_PluginDescription_List2Iterator_new(GWEN_PLUGIN_DESCRIPTION_LIST2 *l);
05638 
05642   void GWEN_PluginDescription_List2Iterator_free(GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *li); 
05643 
05648   GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_List2Iterator_Previous(GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *li); 
05649    
05654   GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_List2Iterator_Next(GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *li); 
05655 
05660   GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_List2Iterator_Data(GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *li); 
05661 
05673   GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_List2_ForEach(GWEN_PLUGIN_DESCRIPTION_LIST2 *list,
05674                                         GWEN_PLUGIN_DESCRIPTION_LIST2_FOREACH func,
05675                                         void *user_data);
05676 
05677 
05678   typedef struct GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 GWEN_PLUGIN_DESCRIPTION_CONSTLIST2; 
05679   typedef struct GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR; 
05680   typedef const GWEN_PLUGIN_DESCRIPTION*
05681     (GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_FOREACH)(const GWEN_PLUGIN_DESCRIPTION *element,
05682                                     void *user_data);
05683   
05684    
05685   GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *GWEN_PluginDescription_ConstList2_new(); 
05686    
05687   void GWEN_PluginDescription_ConstList2_free(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l); 
05688    
05689   void GWEN_PluginDescription_ConstList2_PushBack(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l, const GWEN_PLUGIN_DESCRIPTION *p); 
05690    
05691   void GWEN_PluginDescription_ConstList2_PushFront(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l, const GWEN_PLUGIN_DESCRIPTION *p); 
05692    
05693   const GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_ConstList2_GetFront(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l); 
05694    
05695   const GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_ConstList2_GetBack(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l); 
05696    
05697   unsigned int GWEN_PluginDescription_ConstList2_GetSize(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l); 
05698    
05699   void GWEN_PluginDescription_ConstList2_PopBack(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l); 
05700    
05701   void GWEN_PluginDescription_ConstList2_PopFront(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l); 
05702    
05703   void GWEN_PluginDescription_ConstList2_Clear(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l); 
05704    
05705   GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *GWEN_PluginDescription_ConstList2_First(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l); 
05706    
05707   GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *GWEN_PluginDescription_ConstList2_Last(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l); 
05708    
05709   GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *GWEN_PluginDescription_ConstList2Iterator_new(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l); 
05710    
05711   void GWEN_PluginDescription_ConstList2Iterator_free(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *li); 
05712    
05713   const GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_ConstList2Iterator_Previous(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *li); 
05714    
05715   const GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_ConstList2Iterator_Next(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *li); 
05716    
05717   const GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_ConstList2Iterator_Data(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *li); 
05718    
05730   const GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_ConstList2_ForEach(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *list,
05731         GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_FOREACH func, void *user_data);
05732 
05733 
05734 #ifdef __cplusplus
05735 }
05736 #endif
05737 
05738 
05739 #endif /* GWEN_PLUGIN_DESCRIPTION_LIST_H */
05740 
05741 
05742 
05743 /***************************************************************************
05744  $RCSfile$
05745  -------------------
05746  cvs         : $Id$
05747  begin       : Sat Jun 28 2003
05748  copyright   : (C) 2003 by Martin Preuss
05749  email       : martin@libchipcard.de
05750 
05751  ***************************************************************************
05752  *                                                                         *
05753  *   This library is free software; you can redistribute it and/or         *
05754  *   modify it under the terms of the GNU Lesser General Public            *
05755  *   License as published by the Free Software Foundation; either          *
05756  *   version 2.1 of the License, or (at your option) any later version.    *
05757  *                                                                         *
05758  *   This library is distributed in the hope that it will be useful,       *
05759  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
05760  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
05761  *   Lesser General Public License for more details.                       *
05762  *                                                                         *
05763  *   You should have received a copy of the GNU Lesser General Public      *
05764  *   License along with this library; if not, write to the Free Software   *
05765  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
05766  *   MA  02111-1307  USA                                                   *
05767  *                                                                         *
05768  ***************************************************************************/
05769 
05770 
05771 #ifndef GWEN_PLUGIN_DESCRIPTION_LIST1_H
05772 #define GWEN_PLUGIN_DESCRIPTION_LIST1_H
05773 
05774 #ifdef __cplusplus
05775 extern "C" {
05776 #endif
05777 
05779   typedef struct GWEN_PLUGIN_DESCRIPTION_LIST_ELEMENT {
05780     uint32_t id;
05781     GWEN_PLUGIN_DESCRIPTION *nextObject;
05782   } GWEN_PLUGIN_DESCRIPTION_LIST__ELEMENT;
05783 
05790   typedef struct GWEN_PLUGIN_DESCRIPTION_LIST GWEN_PLUGIN_DESCRIPTION_LIST;
05792   struct GWEN_PLUGIN_DESCRIPTION_LIST {
05793     GWEN_PLUGIN_DESCRIPTION *first;
05794     uint32_t count;
05795     uint32_t id;
05796   } GWEN_PLUGIN_DESCRIPTION_LIST;
05797 
05802   void GWEN_PluginDescription_List_AddList(GWEN_PLUGIN_DESCRIPTION_LIST *dst, GWEN_PLUGIN_DESCRIPTION_LIST *l);
05803 
05807   void GWEN_PluginDescription_List_Add(GWEN_PLUGIN_DESCRIPTION *element, GWEN_PLUGIN_DESCRIPTION_LIST *list);
05808 
05813   void GWEN_PluginDescription_List_Insert(GWEN_PLUGIN_DESCRIPTION *element, GWEN_PLUGIN_DESCRIPTION_LIST *list);
05814 
05821   void GWEN_PluginDescription_List_Del(GWEN_PLUGIN_DESCRIPTION *element);
05822 
05826   GWEN_PLUGIN_DESCRIPTION* GWEN_PluginDescription_List_First(const GWEN_PLUGIN_DESCRIPTION_LIST *l);
05827 
05831   GWEN_PLUGIN_DESCRIPTION* GWEN_PluginDescription_List_Last(const GWEN_PLUGIN_DESCRIPTION_LIST *l);
05832 
05837   void GWEN_PluginDescription_List_Clear(GWEN_PLUGIN_DESCRIPTION_LIST *l);
05838 
05842   GWEN_PLUGIN_DESCRIPTION_LIST* GWEN_PluginDescription_List_new();
05843 
05847   void GWEN_PluginDescription_List_free(GWEN_PLUGIN_DESCRIPTION_LIST *l);
05848 
05852   GWEN_PLUGIN_DESCRIPTION* GWEN_PluginDescription_List_Next(const GWEN_PLUGIN_DESCRIPTION *element);
05853 
05857   GWEN_PLUGIN_DESCRIPTION* GWEN_PluginDescription_List_Previous(const GWEN_PLUGIN_DESCRIPTION *element);
05858 
05862   uint32_t GWEN_PluginDescription_List_GetCount(const GWEN_PLUGIN_DESCRIPTION_LIST *l);
05863 
05864 #ifdef __cplusplus
05865 }
05866 #endif
05867 
05868 
05869 #endif
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_DBIO_LIST1_H
05902 #define GWEN_DBIO_LIST1_H
05903 
05904 #ifdef __cplusplus
05905 extern "C" {
05906 #endif
05907 
05909   typedef struct GWEN_DBIO_LIST_ELEMENT {
05910     uint32_t id;
05911     GWEN_DBIO *nextObject;
05912   } GWEN_DBIO_LIST__ELEMENT;
05913 
05920   typedef struct GWEN_DBIO_LIST GWEN_DBIO_LIST;
05922   struct GWEN_DBIO_LIST {
05923     GWEN_DBIO *first;
05924     uint32_t count;
05925     uint32_t id;
05926   } GWEN_DBIO_LIST;
05927 
05932   void GWEN_DBIO_List_AddList(GWEN_DBIO_LIST *dst, GWEN_DBIO_LIST *l);
05933 
05937   void GWEN_DBIO_List_Add(GWEN_DBIO *element, GWEN_DBIO_LIST *list);
05938 
05943   void GWEN_DBIO_List_Insert(GWEN_DBIO *element, GWEN_DBIO_LIST *list);
05944 
05951   void GWEN_DBIO_List_Del(GWEN_DBIO *element);
05952 
05956   GWEN_DBIO* GWEN_DBIO_List_First(const GWEN_DBIO_LIST *l);
05957 
05961   GWEN_DBIO* GWEN_DBIO_List_Last(const GWEN_DBIO_LIST *l);
05962 
05967   void GWEN_DBIO_List_Clear(GWEN_DBIO_LIST *l);
05968 
05972   GWEN_DBIO_LIST* GWEN_DBIO_List_new();
05973 
05977   void GWEN_DBIO_List_free(GWEN_DBIO_LIST *l);
05978 
05982   GWEN_DBIO* GWEN_DBIO_List_Next(const GWEN_DBIO *element);
05983 
05987   GWEN_DBIO* GWEN_DBIO_List_Previous(const GWEN_DBIO *element);
05988 
05992   uint32_t GWEN_DBIO_List_GetCount(const GWEN_DBIO_LIST *l);
05993 
05994 #ifdef __cplusplus
05995 }
05996 #endif
05997 
05998 
05999 #endif
06000 
06001 
06002 
06003 /***************************************************************************
06004  $RCSfile$
06005  -------------------
06006  cvs         : $Id$
06007  begin       : Sat Jun 28 2003
06008  copyright   : (C) 2003 by Martin Preuss
06009  email       : martin@libchipcard.de
06010 
06011  ***************************************************************************
06012  *                                                                         *
06013  *   This library is free software; you can redistribute it and/or         *
06014  *   modify it under the terms of the GNU Lesser General Public            *
06015  *   License as published by the Free Software Foundation; either          *
06016  *   version 2.1 of the License, or (at your option) any later version.    *
06017  *                                                                         *
06018  *   This library is distributed in the hope that it will be useful,       *
06019  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
06020  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
06021  *   Lesser General Public License for more details.                       *
06022  *                                                                         *
06023  *   You should have received a copy of the GNU Lesser General Public      *
06024  *   License along with this library; if not, write to the Free Software   *
06025  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
06026  *   MA  02111-1307  USA                                                   *
06027  *                                                                         *
06028  ***************************************************************************/
06029 
06030 
06031 #ifndef GWEN_CRYPTHEAD_LIST1_H
06032 #define GWEN_CRYPTHEAD_LIST1_H
06033 
06034 #ifdef __cplusplus
06035 extern "C" {
06036 #endif
06037 
06039   typedef struct GWEN_CRYPTHEAD_LIST_ELEMENT {
06040     uint32_t id;
06041     GWEN_CRYPTHEAD *nextObject;
06042   } GWEN_CRYPTHEAD_LIST__ELEMENT;
06043 
06050   typedef struct GWEN_CRYPTHEAD_LIST GWEN_CRYPTHEAD_LIST;
06052   struct GWEN_CRYPTHEAD_LIST {
06053     GWEN_CRYPTHEAD *first;
06054     uint32_t count;
06055     uint32_t id;
06056   } GWEN_CRYPTHEAD_LIST;
06057 
06062   void GWEN_CryptHead_List_AddList(GWEN_CRYPTHEAD_LIST *dst, GWEN_CRYPTHEAD_LIST *l);
06063 
06067   void GWEN_CryptHead_List_Add(GWEN_CRYPTHEAD *element, GWEN_CRYPTHEAD_LIST *list);
06068 
06073   void GWEN_CryptHead_List_Insert(GWEN_CRYPTHEAD *element, GWEN_CRYPTHEAD_LIST *list);
06074 
06081   void GWEN_CryptHead_List_Del(GWEN_CRYPTHEAD *element);
06082 
06086   GWEN_CRYPTHEAD* GWEN_CryptHead_List_First(const GWEN_CRYPTHEAD_LIST *l);
06087 
06091   GWEN_CRYPTHEAD* GWEN_CryptHead_List_Last(const GWEN_CRYPTHEAD_LIST *l);
06092 
06097   void GWEN_CryptHead_List_Clear(GWEN_CRYPTHEAD_LIST *l);
06098 
06102   GWEN_CRYPTHEAD_LIST* GWEN_CryptHead_List_new();
06103 
06107   void GWEN_CryptHead_List_free(GWEN_CRYPTHEAD_LIST *l);
06108 
06112   GWEN_CRYPTHEAD* GWEN_CryptHead_List_Next(const GWEN_CRYPTHEAD *element);
06113 
06117   GWEN_CRYPTHEAD* GWEN_CryptHead_List_Previous(const GWEN_CRYPTHEAD *element);
06118 
06122   uint32_t GWEN_CryptHead_List_GetCount(const GWEN_CRYPTHEAD_LIST *l);
06123 
06124 #ifdef __cplusplus
06125 }
06126 #endif
06127 
06128 
06129 #endif
06130 
06131 
06132 
06133 /***************************************************************************
06134  $RCSfile$
06135  -------------------
06136  cvs         : $Id$
06137  begin       : Sat Jun 28 2003
06138  copyright   : (C) 2003 by Martin Preuss
06139  email       : martin@libchipcard.de
06140 
06141  ***************************************************************************
06142  *                                                                         *
06143  *   This library is free software; you can redistribute it and/or         *
06144  *   modify it under the terms of the GNU Lesser General Public            *
06145  *   License as published by the Free Software Foundation; either          *
06146  *   version 2.1 of the License, or (at your option) any later version.    *
06147  *                                                                         *
06148  *   This library is distributed in the hope that it will be useful,       *
06149  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
06150  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
06151  *   Lesser General Public License for more details.                       *
06152  *                                                                         *
06153  *   You should have received a copy of the GNU Lesser General Public      *
06154  *   License along with this library; if not, write to the Free Software   *
06155  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
06156  *   MA  02111-1307  USA                                                   *
06157  *                                                                         *
06158  ***************************************************************************/
06159 
06160 
06161 #ifndef GWEN_MDIGEST_LIST2_H
06162 #define GWEN_MDIGEST_LIST2_H
06163 
06164 
06165 #ifdef __cplusplus
06166 extern "C" {
06167 #endif
06168 
06175   typedef struct GWEN_MDIGEST_LIST2 GWEN_MDIGEST_LIST2;
06176 
06180   typedef struct GWEN_MDIGEST_LIST2_ITERATOR GWEN_MDIGEST_LIST2_ITERATOR;
06181 
06185   typedef GWEN_MDIGEST* (GWEN_MDIGEST_LIST2_FOREACH)(GWEN_MDIGEST *element,
06186                                                  void *user_data);
06187 
06191   GWEN_MDIGEST_LIST2 *GWEN_MDigest_List2_new(); 
06192 
06196   void GWEN_MDigest_List2_free(GWEN_MDIGEST_LIST2 *l); 
06197 
06201   void GWEN_MDigest_List2_Dump(GWEN_MDIGEST_LIST2 *l, FILE *f, unsigned int indent); 
06202 
06206   void GWEN_MDigest_List2_PushBack(GWEN_MDIGEST_LIST2 *l, GWEN_MDIGEST *p); 
06207    
06212   void GWEN_MDigest_List2_PushFront(GWEN_MDIGEST_LIST2 *l, GWEN_MDIGEST *p); 
06213 
06218   GWEN_MDIGEST *GWEN_MDigest_List2_GetFront(GWEN_MDIGEST_LIST2 *l); 
06219    
06224   GWEN_MDIGEST *GWEN_MDigest_List2_GetBack(GWEN_MDIGEST_LIST2 *l); 
06225 
06230   void GWEN_MDigest_List2_Erase(GWEN_MDIGEST_LIST2 *l,
06231                                GWEN_MDIGEST_LIST2_ITERATOR *it);
06232 
06238   unsigned int GWEN_MDigest_List2_GetSize(GWEN_MDIGEST_LIST2 *l); 
06239 
06244   void GWEN_MDigest_List2_PopBack(GWEN_MDIGEST_LIST2 *l); 
06245    
06250   void GWEN_MDigest_List2_PopFront(GWEN_MDIGEST_LIST2 *l); 
06251 
06255   void GWEN_MDigest_List2_Clear(GWEN_MDIGEST_LIST2 *l); 
06256 
06260   GWEN_MDIGEST_LIST2_ITERATOR *GWEN_MDigest_List2_First(GWEN_MDIGEST_LIST2 *l); 
06261    
06265   GWEN_MDIGEST_LIST2_ITERATOR *GWEN_MDigest_List2_Last(GWEN_MDIGEST_LIST2 *l); 
06266 
06270   GWEN_MDIGEST_LIST2_ITERATOR *GWEN_MDigest_List2Iterator_new(GWEN_MDIGEST_LIST2 *l);
06271 
06275   void GWEN_MDigest_List2Iterator_free(GWEN_MDIGEST_LIST2_ITERATOR *li); 
06276 
06281   GWEN_MDIGEST *GWEN_MDigest_List2Iterator_Previous(GWEN_MDIGEST_LIST2_ITERATOR *li); 
06282    
06287   GWEN_MDIGEST *GWEN_MDigest_List2Iterator_Next(GWEN_MDIGEST_LIST2_ITERATOR *li); 
06288 
06293   GWEN_MDIGEST *GWEN_MDigest_List2Iterator_Data(GWEN_MDIGEST_LIST2_ITERATOR *li); 
06294 
06306   GWEN_MDIGEST *GWEN_MDigest_List2_ForEach(GWEN_MDIGEST_LIST2 *list,
06307                                         GWEN_MDIGEST_LIST2_FOREACH func,
06308                                         void *user_data);
06309 
06310 
06311   typedef struct GWEN_MDIGEST_CONSTLIST2 GWEN_MDIGEST_CONSTLIST2; 
06312   typedef struct GWEN_MDIGEST_CONSTLIST2_ITERATOR GWEN_MDIGEST_CONSTLIST2_ITERATOR; 
06313   typedef const GWEN_MDIGEST*
06314     (GWEN_MDIGEST_CONSTLIST2_FOREACH)(const GWEN_MDIGEST *element,
06315                                     void *user_data);
06316   
06317    
06318   GWEN_MDIGEST_CONSTLIST2 *GWEN_MDigest_ConstList2_new(); 
06319    
06320   void GWEN_MDigest_ConstList2_free(GWEN_MDIGEST_CONSTLIST2 *l); 
06321    
06322   void GWEN_MDigest_ConstList2_PushBack(GWEN_MDIGEST_CONSTLIST2 *l, const GWEN_MDIGEST *p); 
06323    
06324   void GWEN_MDigest_ConstList2_PushFront(GWEN_MDIGEST_CONSTLIST2 *l, const GWEN_MDIGEST *p); 
06325    
06326   const GWEN_MDIGEST *GWEN_MDigest_ConstList2_GetFront(GWEN_MDIGEST_CONSTLIST2 *l); 
06327    
06328   const GWEN_MDIGEST *GWEN_MDigest_ConstList2_GetBack(GWEN_MDIGEST_CONSTLIST2 *l); 
06329    
06330   unsigned int GWEN_MDigest_ConstList2_GetSize(GWEN_MDIGEST_CONSTLIST2 *l); 
06331    
06332   void GWEN_MDigest_ConstList2_PopBack(GWEN_MDIGEST_CONSTLIST2 *l); 
06333    
06334   void GWEN_MDigest_ConstList2_PopFront(GWEN_MDIGEST_CONSTLIST2 *l); 
06335    
06336   void GWEN_MDigest_ConstList2_Clear(GWEN_MDIGEST_CONSTLIST2 *l); 
06337    
06338   GWEN_MDIGEST_CONSTLIST2_ITERATOR *GWEN_MDigest_ConstList2_First(GWEN_MDIGEST_CONSTLIST2 *l); 
06339    
06340   GWEN_MDIGEST_CONSTLIST2_ITERATOR *GWEN_MDigest_ConstList2_Last(GWEN_MDIGEST_CONSTLIST2 *l); 
06341    
06342   GWEN_MDIGEST_CONSTLIST2_ITERATOR *GWEN_MDigest_ConstList2Iterator_new(GWEN_MDIGEST_CONSTLIST2 *l); 
06343    
06344   void GWEN_MDigest_ConstList2Iterator_free(GWEN_MDIGEST_CONSTLIST2_ITERATOR *li); 
06345    
06346   const GWEN_MDIGEST *GWEN_MDigest_ConstList2Iterator_Previous(GWEN_MDIGEST_CONSTLIST2_ITERATOR *li); 
06347    
06348   const GWEN_MDIGEST *GWEN_MDigest_ConstList2Iterator_Next(GWEN_MDIGEST_CONSTLIST2_ITERATOR *li); 
06349    
06350   const GWEN_MDIGEST *GWEN_MDigest_ConstList2Iterator_Data(GWEN_MDIGEST_CONSTLIST2_ITERATOR *li); 
06351    
06363   const GWEN_MDIGEST *GWEN_MDigest_ConstList2_ForEach(GWEN_MDIGEST_CONSTLIST2 *list,
06364         GWEN_MDIGEST_CONSTLIST2_FOREACH func, void *user_data);
06365 
06366 
06367 #ifdef __cplusplus
06368 }
06369 #endif
06370 
06371 
06372 #endif /* GWEN_MDIGEST_LIST_H */
06373 
06374 
06375 
06376 /***************************************************************************
06377  $RCSfile$
06378  -------------------
06379  cvs         : $Id$
06380  begin       : Sat Jun 28 2003
06381  copyright   : (C) 2003 by Martin Preuss
06382  email       : martin@libchipcard.de
06383 
06384  ***************************************************************************
06385  *                                                                         *
06386  *   This library is free software; you can redistribute it and/or         *
06387  *   modify it under the terms of the GNU Lesser General Public            *
06388  *   License as published by the Free Software Foundation; either          *
06389  *   version 2.1 of the License, or (at your option) any later version.    *
06390  *                                                                         *
06391  *   This library is distributed in the hope that it will be useful,       *
06392  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
06393  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
06394  *   Lesser General Public License for more details.                       *
06395  *                                                                         *
06396  *   You should have received a copy of the GNU Lesser General Public      *
06397  *   License along with this library; if not, write to the Free Software   *
06398  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
06399  *   MA  02111-1307  USA                                                   *
06400  *                                                                         *
06401  ***************************************************************************/
06402 
06403 
06404 #ifndef GWEN_MDIGEST_LIST1_H
06405 #define GWEN_MDIGEST_LIST1_H
06406 
06407 #ifdef __cplusplus
06408 extern "C" {
06409 #endif
06410 
06412   typedef struct GWEN_MDIGEST_LIST_ELEMENT {
06413     uint32_t id;
06414     GWEN_MDIGEST *nextObject;
06415   } GWEN_MDIGEST_LIST__ELEMENT;
06416 
06423   typedef struct GWEN_MDIGEST_LIST GWEN_MDIGEST_LIST;
06425   struct GWEN_MDIGEST_LIST {
06426     GWEN_MDIGEST *first;
06427     uint32_t count;
06428     uint32_t id;
06429   } GWEN_MDIGEST_LIST;
06430 
06435   void GWEN_MDigest_List_AddList(GWEN_MDIGEST_LIST *dst, GWEN_MDIGEST_LIST *l);
06436 
06440   void GWEN_MDigest_List_Add(GWEN_MDIGEST *element, GWEN_MDIGEST_LIST *list);
06441 
06446   void GWEN_MDigest_List_Insert(GWEN_MDIGEST *element, GWEN_MDIGEST_LIST *list);
06447 
06454   void GWEN_MDigest_List_Del(GWEN_MDIGEST *element);
06455 
06459   GWEN_MDIGEST* GWEN_MDigest_List_First(const GWEN_MDIGEST_LIST *l);
06460 
06464   GWEN_MDIGEST* GWEN_MDigest_List_Last(const GWEN_MDIGEST_LIST *l);
06465 
06470   void GWEN_MDigest_List_Clear(GWEN_MDIGEST_LIST *l);
06471 
06475   GWEN_MDIGEST_LIST* GWEN_MDigest_List_new();
06476 
06480   void GWEN_MDigest_List_free(GWEN_MDIGEST_LIST *l);
06481 
06485   GWEN_MDIGEST* GWEN_MDigest_List_Next(const GWEN_MDIGEST *element);
06486 
06490   GWEN_MDIGEST* GWEN_MDigest_List_Previous(const GWEN_MDIGEST *element);
06491 
06495   uint32_t GWEN_MDigest_List_GetCount(const GWEN_MDIGEST_LIST *l);
06496 
06497 #ifdef __cplusplus
06498 }
06499 #endif
06500 
06501 
06502 #endif
06503 
06504 
06505 
06506 /***************************************************************************
06507  $RCSfile$
06508  -------------------
06509  cvs         : $Id$
06510  begin       : Sat Jun 28 2003
06511  copyright   : (C) 2003 by Martin Preuss
06512  email       : martin@libchipcard.de
06513 
06514  ***************************************************************************
06515  *                                                                         *
06516  *   This library is free software; you can redistribute it and/or         *
06517  *   modify it under the terms of the GNU Lesser General Public            *
06518  *   License as published by the Free Software Foundation; either          *
06519  *   version 2.1 of the License, or (at your option) any later version.    *
06520  *                                                                         *
06521  *   This library is distributed in the hope that it will be useful,       *
06522  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
06523  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
06524  *   Lesser General Public License for more details.                       *
06525  *                                                                         *
06526  *   You should have received a copy of the GNU Lesser General Public      *
06527  *   License along with this library; if not, write to the Free Software   *
06528  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
06529  *   MA  02111-1307  USA                                                   *
06530  *                                                                         *
06531  ***************************************************************************/
06532 
06533 
06534 #ifndef GWEN_SOCKET_LIST2_H
06535 #define GWEN_SOCKET_LIST2_H
06536 
06537 
06538 #ifdef __cplusplus
06539 extern "C" {
06540 #endif
06541 
06548   typedef struct GWEN_SOCKET_LIST2 GWEN_SOCKET_LIST2;
06549 
06553   typedef struct GWEN_SOCKET_LIST2_ITERATOR GWEN_SOCKET_LIST2_ITERATOR;
06554 
06558   typedef GWEN_SOCKET* (GWEN_SOCKET_LIST2_FOREACH)(GWEN_SOCKET *element,
06559                                                  void *user_data);
06560 
06564   GWEN_SOCKET_LIST2 *GWEN_Socket_List2_new(); 
06565 
06569   void GWEN_Socket_List2_free(GWEN_SOCKET_LIST2 *l); 
06570 
06574   void GWEN_Socket_List2_Dump(GWEN_SOCKET_LIST2 *l, FILE *f, unsigned int indent); 
06575 
06579   void GWEN_Socket_List2_PushBack(GWEN_SOCKET_LIST2 *l, GWEN_SOCKET *p); 
06580    
06585   void GWEN_Socket_List2_PushFront(GWEN_SOCKET_LIST2 *l, GWEN_SOCKET *p); 
06586 
06591   GWEN_SOCKET *GWEN_Socket_List2_GetFront(GWEN_SOCKET_LIST2 *l); 
06592    
06597   GWEN_SOCKET *GWEN_Socket_List2_GetBack(GWEN_SOCKET_LIST2 *l); 
06598 
06603   void GWEN_Socket_List2_Erase(GWEN_SOCKET_LIST2 *l,
06604                                GWEN_SOCKET_LIST2_ITERATOR *it);
06605 
06611   unsigned int GWEN_Socket_List2_GetSize(GWEN_SOCKET_LIST2 *l); 
06612 
06617   void GWEN_Socket_List2_PopBack(GWEN_SOCKET_LIST2 *l); 
06618    
06623   void GWEN_Socket_List2_PopFront(GWEN_SOCKET_LIST2 *l); 
06624 
06628   void GWEN_Socket_List2_Clear(GWEN_SOCKET_LIST2 *l); 
06629 
06633   GWEN_SOCKET_LIST2_ITERATOR *GWEN_Socket_List2_First(GWEN_SOCKET_LIST2 *l); 
06634    
06638   GWEN_SOCKET_LIST2_ITERATOR *GWEN_Socket_List2_Last(GWEN_SOCKET_LIST2 *l); 
06639 
06643   GWEN_SOCKET_LIST2_ITERATOR *GWEN_Socket_List2Iterator_new(GWEN_SOCKET_LIST2 *l);
06644 
06648   void GWEN_Socket_List2Iterator_free(GWEN_SOCKET_LIST2_ITERATOR *li); 
06649 
06654   GWEN_SOCKET *GWEN_Socket_List2Iterator_Previous(GWEN_SOCKET_LIST2_ITERATOR *li); 
06655    
06660   GWEN_SOCKET *GWEN_Socket_List2Iterator_Next(GWEN_SOCKET_LIST2_ITERATOR *li); 
06661 
06666   GWEN_SOCKET *GWEN_Socket_List2Iterator_Data(GWEN_SOCKET_LIST2_ITERATOR *li); 
06667 
06679   GWEN_SOCKET *GWEN_Socket_List2_ForEach(GWEN_SOCKET_LIST2 *list,
06680                                         GWEN_SOCKET_LIST2_FOREACH func,
06681                                         void *user_data);
06682 
06683 
06684   typedef struct GWEN_SOCKET_CONSTLIST2 GWEN_SOCKET_CONSTLIST2; 
06685   typedef struct GWEN_SOCKET_CONSTLIST2_ITERATOR GWEN_SOCKET_CONSTLIST2_ITERATOR; 
06686   typedef const GWEN_SOCKET*
06687     (GWEN_SOCKET_CONSTLIST2_FOREACH)(const GWEN_SOCKET *element,
06688                                     void *user_data);
06689   
06690    
06691   GWEN_SOCKET_CONSTLIST2 *GWEN_Socket_ConstList2_new(); 
06692    
06693   void GWEN_Socket_ConstList2_free(GWEN_SOCKET_CONSTLIST2 *l); 
06694    
06695   void GWEN_Socket_ConstList2_PushBack(GWEN_SOCKET_CONSTLIST2 *l, const GWEN_SOCKET *p); 
06696    
06697   void GWEN_Socket_ConstList2_PushFront(GWEN_SOCKET_CONSTLIST2 *l, const GWEN_SOCKET *p); 
06698    
06699   const GWEN_SOCKET *GWEN_Socket_ConstList2_GetFront(GWEN_SOCKET_CONSTLIST2 *l); 
06700    
06701   const GWEN_SOCKET *GWEN_Socket_ConstList2_GetBack(GWEN_SOCKET_CONSTLIST2 *l); 
06702    
06703   unsigned int GWEN_Socket_ConstList2_GetSize(GWEN_SOCKET_CONSTLIST2 *l); 
06704    
06705   void GWEN_Socket_ConstList2_PopBack(GWEN_SOCKET_CONSTLIST2 *l); 
06706    
06707   void GWEN_Socket_ConstList2_PopFront(GWEN_SOCKET_CONSTLIST2 *l); 
06708    
06709   void GWEN_Socket_ConstList2_Clear(GWEN_SOCKET_CONSTLIST2 *l); 
06710    
06711   GWEN_SOCKET_CONSTLIST2_ITERATOR *GWEN_Socket_ConstList2_First(GWEN_SOCKET_CONSTLIST2 *l); 
06712    
06713   GWEN_SOCKET_CONSTLIST2_ITERATOR *GWEN_Socket_ConstList2_Last(GWEN_SOCKET_CONSTLIST2 *l); 
06714    
06715   GWEN_SOCKET_CONSTLIST2_ITERATOR *GWEN_Socket_ConstList2Iterator_new(GWEN_SOCKET_CONSTLIST2 *l); 
06716    
06717   void GWEN_Socket_ConstList2Iterator_free(GWEN_SOCKET_CONSTLIST2_ITERATOR *li); 
06718    
06719   const GWEN_SOCKET *GWEN_Socket_ConstList2Iterator_Previous(GWEN_SOCKET_CONSTLIST2_ITERATOR *li); 
06720    
06721   const GWEN_SOCKET *GWEN_Socket_ConstList2Iterator_Next(GWEN_SOCKET_CONSTLIST2_ITERATOR *li); 
06722    
06723   const GWEN_SOCKET *GWEN_Socket_ConstList2Iterator_Data(GWEN_SOCKET_CONSTLIST2_ITERATOR *li); 
06724    
06736   const GWEN_SOCKET *GWEN_Socket_ConstList2_ForEach(GWEN_SOCKET_CONSTLIST2 *list,
06737         GWEN_SOCKET_CONSTLIST2_FOREACH func, void *user_data);
06738 
06739 
06740 #ifdef __cplusplus
06741 }
06742 #endif
06743 
06744 
06745 #endif /* GWEN_SOCKET_LIST_H */
06746 
06747 
06748 
06749 /***************************************************************************
06750  $RCSfile$
06751  -------------------
06752  cvs         : $Id$
06753  begin       : Sat Jun 28 2003
06754  copyright   : (C) 2003 by Martin Preuss
06755  email       : martin@libchipcard.de
06756 
06757  ***************************************************************************
06758  *                                                                         *
06759  *   This library is free software; you can redistribute it and/or         *
06760  *   modify it under the terms of the GNU Lesser General Public            *
06761  *   License as published by the Free Software Foundation; either          *
06762  *   version 2.1 of the License, or (at your option) any later version.    *
06763  *                                                                         *
06764  *   This library is distributed in the hope that it will be useful,       *
06765  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
06766  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
06767  *   Lesser General Public License for more details.                       *
06768  *                                                                         *
06769  *   You should have received a copy of the GNU Lesser General Public      *
06770  *   License along with this library; if not, write to the Free Software   *
06771  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
06772  *   MA  02111-1307  USA                                                   *
06773  *                                                                         *
06774  ***************************************************************************/
06775 
06776 
06777 #ifndef GWEN_SOCKET_LIST1_H
06778 #define GWEN_SOCKET_LIST1_H
06779 
06780 #ifdef __cplusplus
06781 extern "C" {
06782 #endif
06783 
06785   typedef struct GWEN_SOCKET_LIST_ELEMENT {
06786     uint32_t id;
06787     GWEN_SOCKET *nextObject;
06788   } GWEN_SOCKET_LIST__ELEMENT;
06789 
06796   typedef struct GWEN_SOCKET_LIST GWEN_SOCKET_LIST;
06798   struct GWEN_SOCKET_LIST {
06799     GWEN_SOCKET *first;
06800     uint32_t count;
06801     uint32_t id;
06802   } GWEN_SOCKET_LIST;
06803 
06808   void GWEN_Socket_List_AddList(GWEN_SOCKET_LIST *dst, GWEN_SOCKET_LIST *l);
06809 
06813   void GWEN_Socket_List_Add(GWEN_SOCKET *element, GWEN_SOCKET_LIST *list);
06814 
06819   void GWEN_Socket_List_Insert(GWEN_SOCKET *element, GWEN_SOCKET_LIST *list);
06820 
06827   void GWEN_Socket_List_Del(GWEN_SOCKET *element);
06828 
06832   GWEN_SOCKET* GWEN_Socket_List_First(const GWEN_SOCKET_LIST *l);
06833 
06837   GWEN_SOCKET* GWEN_Socket_List_Last(const GWEN_SOCKET_LIST *l);
06838 
06843   void GWEN_Socket_List_Clear(GWEN_SOCKET_LIST *l);
06844 
06848   GWEN_SOCKET_LIST* GWEN_Socket_List_new();
06849 
06853   void GWEN_Socket_List_free(GWEN_SOCKET_LIST *l);
06854 
06858   GWEN_SOCKET* GWEN_Socket_List_Next(const GWEN_SOCKET *element);
06859 
06863   GWEN_SOCKET* GWEN_Socket_List_Previous(const GWEN_SOCKET *element);
06864 
06868   uint32_t GWEN_Socket_List_GetCount(const GWEN_SOCKET_LIST *l);
06869 
06870 #ifdef __cplusplus
06871 }
06872 #endif
06873 
06874 
06875 #endif
06876 
06877 
06878 
06879 /***************************************************************************
06880  $RCSfile$
06881  -------------------
06882  cvs         : $Id$
06883  begin       : Sat Jun 28 2003
06884  copyright   : (C) 2003 by Martin Preuss
06885  email       : martin@libchipcard.de
06886 
06887  ***************************************************************************
06888  *                                                                         *
06889  *   This library is free software; you can redistribute it and/or         *
06890  *   modify it under the terms of the GNU Lesser General Public            *
06891  *   License as published by the Free Software Foundation; either          *
06892  *   version 2.1 of the License, or (at your option) any later version.    *
06893  *                                                                         *
06894  *   This library is distributed in the hope that it will be useful,       *
06895  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
06896  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
06897  *   Lesser General Public License for more details.                       *
06898  *                                                                         *
06899  *   You should have received a copy of the GNU Lesser General Public      *
06900  *   License along with this library; if not, write to the Free Software   *
06901  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
06902  *   MA  02111-1307  USA                                                   *
06903  *                                                                         *
06904  ***************************************************************************/
06905 
06906 
06907 #ifndef GWEN_URL_LIST2_H
06908 #define GWEN_URL_LIST2_H
06909 
06910 
06911 #ifdef __cplusplus
06912 extern "C" {
06913 #endif
06914 
06921   typedef struct GWEN_URL_LIST2 GWEN_URL_LIST2;
06922 
06926   typedef struct GWEN_URL_LIST2_ITERATOR GWEN_URL_LIST2_ITERATOR;
06927 
06931   typedef GWEN_URL* (GWEN_URL_LIST2_FOREACH)(GWEN_URL *element,
06932                                                  void *user_data);
06933 
06937   GWEN_URL_LIST2 *GWEN_Url_List2_new(); 
06938 
06942   void GWEN_Url_List2_free(GWEN_URL_LIST2 *l); 
06943 
06947   void GWEN_Url_List2_Dump(GWEN_URL_LIST2 *l, FILE *f, unsigned int indent); 
06948 
06952   void GWEN_Url_List2_PushBack(GWEN_URL_LIST2 *l, GWEN_URL *p); 
06953    
06958   void GWEN_Url_List2_PushFront(GWEN_URL_LIST2 *l, GWEN_URL *p); 
06959 
06964   GWEN_URL *GWEN_Url_List2_GetFront(GWEN_URL_LIST2 *l); 
06965    
06970   GWEN_URL *GWEN_Url_List2_GetBack(GWEN_URL_LIST2 *l); 
06971 
06976   void GWEN_Url_List2_Erase(GWEN_URL_LIST2 *l,
06977                                GWEN_URL_LIST2_ITERATOR *it);
06978 
06984   unsigned int GWEN_Url_List2_GetSize(GWEN_URL_LIST2 *l); 
06985 
06990   void GWEN_Url_List2_PopBack(GWEN_URL_LIST2 *l); 
06991    
06996   void GWEN_Url_List2_PopFront(GWEN_URL_LIST2 *l); 
06997 
07001   void GWEN_Url_List2_Clear(GWEN_URL_LIST2 *l); 
07002 
07006   GWEN_URL_LIST2_ITERATOR *GWEN_Url_List2_First(GWEN_URL_LIST2 *l); 
07007    
07011   GWEN_URL_LIST2_ITERATOR *GWEN_Url_List2_Last(GWEN_URL_LIST2 *l); 
07012 
07016   GWEN_URL_LIST2_ITERATOR *GWEN_Url_List2Iterator_new(GWEN_URL_LIST2 *l);
07017 
07021   void GWEN_Url_List2Iterator_free(GWEN_URL_LIST2_ITERATOR *li); 
07022 
07027   GWEN_URL *GWEN_Url_List2Iterator_Previous(GWEN_URL_LIST2_ITERATOR *li); 
07028    
07033   GWEN_URL *GWEN_Url_List2Iterator_Next(GWEN_URL_LIST2_ITERATOR *li); 
07034 
07039   GWEN_URL *GWEN_Url_List2Iterator_Data(GWEN_URL_LIST2_ITERATOR *li); 
07040 
07052   GWEN_URL *GWEN_Url_List2_ForEach(GWEN_URL_LIST2 *list,
07053                                         GWEN_URL_LIST2_FOREACH func,
07054                                         void *user_data);
07055 
07056 
07057   typedef struct GWEN_URL_CONSTLIST2 GWEN_URL_CONSTLIST2; 
07058   typedef struct GWEN_URL_CONSTLIST2_ITERATOR GWEN_URL_CONSTLIST2_ITERATOR; 
07059   typedef const GWEN_URL*
07060     (GWEN_URL_CONSTLIST2_FOREACH)(const GWEN_URL *element,
07061                                     void *user_data);
07062   
07063    
07064   GWEN_URL_CONSTLIST2 *GWEN_Url_ConstList2_new(); 
07065    
07066   void GWEN_Url_ConstList2_free(GWEN_URL_CONSTLIST2 *l); 
07067    
07068   void GWEN_Url_ConstList2_PushBack(GWEN_URL_CONSTLIST2 *l, const GWEN_URL *p); 
07069    
07070   void GWEN_Url_ConstList2_PushFront(GWEN_URL_CONSTLIST2 *l, const GWEN_URL *p); 
07071    
07072   const GWEN_URL *GWEN_Url_ConstList2_GetFront(GWEN_URL_CONSTLIST2 *l); 
07073    
07074   const GWEN_URL *GWEN_Url_ConstList2_GetBack(GWEN_URL_CONSTLIST2 *l); 
07075    
07076   unsigned int GWEN_Url_ConstList2_GetSize(GWEN_URL_CONSTLIST2 *l); 
07077    
07078   void GWEN_Url_ConstList2_PopBack(GWEN_URL_CONSTLIST2 *l); 
07079    
07080   void GWEN_Url_ConstList2_PopFront(GWEN_URL_CONSTLIST2 *l); 
07081    
07082   void GWEN_Url_ConstList2_Clear(GWEN_URL_CONSTLIST2 *l); 
07083    
07084   GWEN_URL_CONSTLIST2_ITERATOR *GWEN_Url_ConstList2_First(GWEN_URL_CONSTLIST2 *l); 
07085    
07086   GWEN_URL_CONSTLIST2_ITERATOR *GWEN_Url_ConstList2_Last(GWEN_URL_CONSTLIST2 *l); 
07087    
07088   GWEN_URL_CONSTLIST2_ITERATOR *GWEN_Url_ConstList2Iterator_new(GWEN_URL_CONSTLIST2 *l); 
07089    
07090   void GWEN_Url_ConstList2Iterator_free(GWEN_URL_CONSTLIST2_ITERATOR *li); 
07091    
07092   const GWEN_URL *GWEN_Url_ConstList2Iterator_Previous(GWEN_URL_CONSTLIST2_ITERATOR *li); 
07093    
07094   const GWEN_URL *GWEN_Url_ConstList2Iterator_Next(GWEN_URL_CONSTLIST2_ITERATOR *li); 
07095    
07096   const GWEN_URL *GWEN_Url_ConstList2Iterator_Data(GWEN_URL_CONSTLIST2_ITERATOR *li); 
07097    
07109   const GWEN_URL *GWEN_Url_ConstList2_ForEach(GWEN_URL_CONSTLIST2 *list,
07110         GWEN_URL_CONSTLIST2_FOREACH func, void *user_data);
07111 
07112 
07113 #ifdef __cplusplus
07114 }
07115 #endif
07116 
07117 
07118 #endif /* GWEN_URL_LIST_H */
07119 
07120 
07121 
07122 /***************************************************************************
07123  $RCSfile$
07124  -------------------
07125  cvs         : $Id$
07126  begin       : Sat Jun 28 2003
07127  copyright   : (C) 2003 by Martin Preuss
07128  email       : martin@libchipcard.de
07129 
07130  ***************************************************************************
07131  *                                                                         *
07132  *   This library is free software; you can redistribute it and/or         *
07133  *   modify it under the terms of the GNU Lesser General Public            *
07134  *   License as published by the Free Software Foundation; either          *
07135  *   version 2.1 of the License, or (at your option) any later version.    *
07136  *                                                                         *
07137  *   This library is distributed in the hope that it will be useful,       *
07138  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
07139  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
07140  *   Lesser General Public License for more details.                       *
07141  *                                                                         *
07142  *   You should have received a copy of the GNU Lesser General Public      *
07143  *   License along with this library; if not, write to the Free Software   *
07144  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
07145  *   MA  02111-1307  USA                                                   *
07146  *                                                                         *
07147  ***************************************************************************/
07148 
07149 
07150 #ifndef GWEN_URL_LIST1_H
07151 #define GWEN_URL_LIST1_H
07152 
07153 #ifdef __cplusplus
07154 extern "C" {
07155 #endif
07156 
07158   typedef struct GWEN_URL_LIST_ELEMENT {
07159     uint32_t id;
07160     GWEN_URL *nextObject;
07161   } GWEN_URL_LIST__ELEMENT;
07162 
07169   typedef struct GWEN_URL_LIST GWEN_URL_LIST;
07171   struct GWEN_URL_LIST {
07172     GWEN_URL *first;
07173     uint32_t count;
07174     uint32_t id;
07175   } GWEN_URL_LIST;
07176 
07181   void GWEN_Url_List_AddList(GWEN_URL_LIST *dst, GWEN_URL_LIST *l);
07182 
07186   void GWEN_Url_List_Add(GWEN_URL *element, GWEN_URL_LIST *list);
07187 
07192   void GWEN_Url_List_Insert(GWEN_URL *element, GWEN_URL_LIST *list);
07193 
07200   void GWEN_Url_List_Del(GWEN_URL *element);
07201 
07205   GWEN_URL* GWEN_Url_List_First(const GWEN_URL_LIST *l);
07206 
07210   GWEN_URL* GWEN_Url_List_Last(const GWEN_URL_LIST *l);
07211 
07216   void GWEN_Url_List_Clear(GWEN_URL_LIST *l);
07217 
07221   GWEN_URL_LIST* GWEN_Url_List_new();
07222 
07226   void GWEN_Url_List_free(GWEN_URL_LIST *l);
07227 
07231   GWEN_URL* GWEN_Url_List_Next(const GWEN_URL *element);
07232 
07236   GWEN_URL* GWEN_Url_List_Previous(const GWEN_URL *element);
07237 
07241   uint32_t GWEN_Url_List_GetCount(const GWEN_URL_LIST *l);
07242 
07243 #ifdef __cplusplus
07244 }
07245 #endif
07246 
07247 
07248 #endif
07249 
07250 
07251 
07252 /***************************************************************************
07253  $RCSfile$
07254  -------------------
07255  cvs         : $Id$
07256  begin       : Sat Jun 28 2003
07257  copyright   : (C) 2003 by Martin Preuss
07258  email       : martin@libchipcard.de
07259 
07260  ***************************************************************************
07261  *                                                                         *
07262  *   This library is free software; you can redistribute it and/or         *
07263  *   modify it under the terms of the GNU Lesser General Public            *
07264  *   License as published by the Free Software Foundation; either          *
07265  *   version 2.1 of the License, or (at your option) any later version.    *
07266  *                                                                         *
07267  *   This library is distributed in the hope that it will be useful,       *
07268  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
07269  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
07270  *   Lesser General Public License for more details.                       *
07271  *                                                                         *
07272  *   You should have received a copy of the GNU Lesser General Public      *
07273  *   License along with this library; if not, write to the Free Software   *
07274  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
07275  *   MA  02111-1307  USA                                                   *
07276  *                                                                         *
07277  ***************************************************************************/
07278 
07279 
07280 #ifndef t_LIST2_H
07281 #define t_LIST2_H
07282 
07283 
07284 #ifdef __cplusplus
07285 extern "C" {
07286 #endif
07287 
07294   typedef struct t_LIST2 t_LIST2;
07295 
07299   typedef struct t_LIST2_ITERATOR t_LIST2_ITERATOR;
07300 
07304   typedef t* (t_LIST2_FOREACH)(t *element,
07305                                                  void *user_data);
07306 
07310   t_LIST2 *pr_List2_new(); 
07311 
07315   void pr_List2_free(t_LIST2 *l); 
07316 
07320   void pr_List2_Dump(t_LIST2 *l, FILE *f, unsigned int indent); 
07321 
07325   void pr_List2_PushBack(t_LIST2 *l, t *p); 
07326    
07331   void pr_List2_PushFront(t_LIST2 *l, t *p); 
07332 
07337   t *pr_List2_GetFront(t_LIST2 *l); 
07338    
07343   t *pr_List2_GetBack(t_LIST2 *l); 
07344 
07349   void pr_List2_Erase(t_LIST2 *l,
07350                                t_LIST2_ITERATOR *it);
07351 
07357   unsigned int pr_List2_GetSize(t_LIST2 *l); 
07358 
07363   void pr_List2_PopBack(t_LIST2 *l); 
07364    
07369   void pr_List2_PopFront(t_LIST2 *l); 
07370 
07374   void pr_List2_Clear(t_LIST2 *l); 
07375 
07379   t_LIST2_ITERATOR *pr_List2_First(t_LIST2 *l); 
07380    
07384   t_LIST2_ITERATOR *pr_List2_Last(t_LIST2 *l); 
07385 
07389   t_LIST2_ITERATOR *pr_List2Iterator_new(t_LIST2 *l);
07390 
07394   void pr_List2Iterator_free(t_LIST2_ITERATOR *li); 
07395 
07400   t *pr_List2Iterator_Previous(t_LIST2_ITERATOR *li); 
07401    
07406   t *pr_List2Iterator_Next(t_LIST2_ITERATOR *li); 
07407 
07412   t *pr_List2Iterator_Data(t_LIST2_ITERATOR *li); 
07413 
07425   t *pr_List2_ForEach(t_LIST2 *list,
07426                                         t_LIST2_FOREACH func,
07427                                         void *user_data);
07428 
07429 
07430   typedef struct t_CONSTLIST2 t_CONSTLIST2; 
07431   typedef struct t_CONSTLIST2_ITERATOR t_CONSTLIST2_ITERATOR; 
07432   typedef const t*
07433     (t_CONSTLIST2_FOREACH)(const t *element,
07434                                     void *user_data);
07435   
07436    
07437   t_CONSTLIST2 *pr_ConstList2_new(); 
07438    
07439   void pr_ConstList2_free(t_CONSTLIST2 *l); 
07440    
07441   void pr_ConstList2_PushBack(t_CONSTLIST2 *l, const t *p); 
07442    
07443   void pr_ConstList2_PushFront(t_CONSTLIST2 *l, const t *p); 
07444    
07445   const t *pr_ConstList2_GetFront(t_CONSTLIST2 *l); 
07446    
07447   const t *pr_ConstList2_GetBack(t_CONSTLIST2 *l); 
07448    
07449   unsigned int pr_ConstList2_GetSize(t_CONSTLIST2 *l); 
07450    
07451   void pr_ConstList2_PopBack(t_CONSTLIST2 *l); 
07452    
07453   void pr_ConstList2_PopFront(t_CONSTLIST2 *l); 
07454    
07455   void pr_ConstList2_Clear(t_CONSTLIST2 *l); 
07456    
07457   t_CONSTLIST2_ITERATOR *pr_ConstList2_First(t_CONSTLIST2 *l); 
07458    
07459   t_CONSTLIST2_ITERATOR *pr_ConstList2_Last(t_CONSTLIST2 *l); 
07460    
07461   t_CONSTLIST2_ITERATOR *pr_ConstList2Iterator_new(t_CONSTLIST2 *l); 
07462    
07463   void pr_ConstList2Iterator_free(t_CONSTLIST2_ITERATOR *li); 
07464    
07465   const t *pr_ConstList2Iterator_Previous(t_CONSTLIST2_ITERATOR *li); 
07466    
07467   const t *pr_ConstList2Iterator_Next(t_CONSTLIST2_ITERATOR *li); 
07468    
07469   const t *pr_ConstList2Iterator_Data(t_CONSTLIST2_ITERATOR *li); 
07470    
07482   const t *pr_ConstList2_ForEach(t_CONSTLIST2 *list,
07483         t_CONSTLIST2_FOREACH func, void *user_data);
07484 
07485 
07486 #ifdef __cplusplus
07487 }
07488 #endif
07489 
07490 
07491 #endif /* t_LIST_H */
07492 
07493 
07494 
07495 /***************************************************************************
07496  $RCSfile$
07497  -------------------
07498  cvs         : $Id$
07499  begin       : Sat Jun 28 2003
07500  copyright   : (C) 2003 by Martin Preuss
07501  email       : martin@libchipcard.de
07502 
07503  ***************************************************************************
07504  *                                                                         *
07505  *   This library is free software; you can redistribute it and/or         *
07506  *   modify it under the terms of the GNU Lesser General Public            *
07507  *   License as published by the Free Software Foundation; either          *
07508  *   version 2.1 of the License, or (at your option) any later version.    *
07509  *                                                                         *
07510  *   This library is distributed in the hope that it will be useful,       *
07511  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
07512  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
07513  *   Lesser General Public License for more details.                       *
07514  *                                                                         *
07515  *   You should have received a copy of the GNU Lesser General Public      *
07516  *   License along with this library; if not, write to the Free Software   *
07517  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
07518  *   MA  02111-1307  USA                                                   *
07519  *                                                                         *
07520  ***************************************************************************/
07521 
07522 
07523 #ifndef t_LIST2_H
07524 #define t_LIST2_H
07525 
07526 
07527 #ifdef __cplusplus
07528 extern "C" {
07529 #endif
07530 
07537   typedef struct t_LIST2 t_LIST2;
07538 
07542   typedef struct t_LIST2_ITERATOR t_LIST2_ITERATOR;
07543 
07547   typedef t* (t_LIST2_FOREACH)(t *element,
07548                                                  void *user_data);
07549 
07553   t_LIST2 *pr_List2_new(); 
07554 
07558   void pr_List2_free(t_LIST2 *l); 
07559 
07563   void pr_List2_Dump(t_LIST2 *l, FILE *f, unsigned int indent); 
07564 
07568   void pr_List2_PushBack(t_LIST2 *l, t *p); 
07569    
07574   void pr_List2_PushFront(t_LIST2 *l, t *p); 
07575 
07580   t *pr_List2_GetFront(t_LIST2 *l); 
07581    
07586   t *pr_List2_GetBack(t_LIST2 *l); 
07587 
07592   void pr_List2_Erase(t_LIST2 *l,
07593                                t_LIST2_ITERATOR *it);
07594 
07600   unsigned int pr_List2_GetSize(t_LIST2 *l); 
07601 
07606   void pr_List2_PopBack(t_LIST2 *l); 
07607    
07612   void pr_List2_PopFront(t_LIST2 *l); 
07613 
07617   void pr_List2_Clear(t_LIST2 *l); 
07618 
07622   t_LIST2_ITERATOR *pr_List2_First(t_LIST2 *l); 
07623    
07627   t_LIST2_ITERATOR *pr_List2_Last(t_LIST2 *l); 
07628 
07632   t_LIST2_ITERATOR *pr_List2Iterator_new(t_LIST2 *l);
07633 
07637   void pr_List2Iterator_free(t_LIST2_ITERATOR *li); 
07638 
07643   t *pr_List2Iterator_Previous(t_LIST2_ITERATOR *li); 
07644    
07649   t *pr_List2Iterator_Next(t_LIST2_ITERATOR *li); 
07650 
07655   t *pr_List2Iterator_Data(t_LIST2_ITERATOR *li); 
07656 
07668   t *pr_List2_ForEach(t_LIST2 *list,
07669                                         t_LIST2_FOREACH func,
07670                                         void *user_data);
07671 
07672 
07673   typedef struct t_CONSTLIST2 t_CONSTLIST2; 
07674   typedef struct t_CONSTLIST2_ITERATOR t_CONSTLIST2_ITERATOR; 
07675   typedef const t*
07676     (t_CONSTLIST2_FOREACH)(const t *element,
07677                                     void *user_data);
07678   
07679    
07680   t_CONSTLIST2 *pr_ConstList2_new(); 
07681    
07682   void pr_ConstList2_free(t_CONSTLIST2 *l); 
07683    
07684   void pr_ConstList2_PushBack(t_CONSTLIST2 *l, const t *p); 
07685    
07686   void pr_ConstList2_PushFront(t_CONSTLIST2 *l, const t *p); 
07687    
07688   const t *pr_ConstList2_GetFront(t_CONSTLIST2 *l); 
07689    
07690   const t *pr_ConstList2_GetBack(t_CONSTLIST2 *l); 
07691    
07692   unsigned int pr_ConstList2_GetSize(t_CONSTLIST2 *l); 
07693    
07694   void pr_ConstList2_PopBack(t_CONSTLIST2 *l); 
07695    
07696   void pr_ConstList2_PopFront(t_CONSTLIST2 *l); 
07697    
07698   void pr_ConstList2_Clear(t_CONSTLIST2 *l); 
07699    
07700   t_CONSTLIST2_ITERATOR *pr_ConstList2_First(t_CONSTLIST2 *l); 
07701    
07702   t_CONSTLIST2_ITERATOR *pr_ConstList2_Last(t_CONSTLIST2 *l); 
07703    
07704   t_CONSTLIST2_ITERATOR *pr_ConstList2Iterator_new(t_CONSTLIST2 *l); 
07705    
07706   void pr_ConstList2Iterator_free(t_CONSTLIST2_ITERATOR *li); 
07707    
07708   const t *pr_ConstList2Iterator_Previous(t_CONSTLIST2_ITERATOR *li); 
07709    
07710   const t *pr_ConstList2Iterator_Next(t_CONSTLIST2_ITERATOR *li); 
07711    
07712   const t *pr_ConstList2Iterator_Data(t_CONSTLIST2_ITERATOR *li); 
07713    
07725   const t *pr_ConstList2_ForEach(t_CONSTLIST2 *list,
07726         t_CONSTLIST2_FOREACH func, void *user_data);
07727 
07728 
07729 #ifdef __cplusplus
07730 }
07731 #endif
07732 
07733 
07734 #endif /* t_LIST_H */
07735 
07736 
07737