aqbanking
5.0.24.0-git
|
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 AB_JOBQUEUE_LIST1_H 00030 #define AB_JOBQUEUE_LIST1_H 00031 00032 #ifdef __cplusplus 00033 extern "C" { 00034 #endif 00035 00037 typedef struct AB_JOBQUEUE_LIST_ELEMENT { 00038 uint32_t id; 00039 AB_JOBQUEUE *nextObject; 00040 } AB_JOBQUEUE_LIST__ELEMENT; 00041 00048 typedef struct AB_JOBQUEUE_LIST AB_JOBQUEUE_LIST; 00049 00053 typedef int GWENHYWFAR_CB (*AB_JOBQUEUE_LIST_SORT_FN)(const AB_JOBQUEUE *a, const AB_JOBQUEUE *b, int ascending); 00054 00055 00057 struct AB_JOBQUEUE_LIST { 00058 AB_JOBQUEUE *first; 00059 uint32_t count; 00060 uint32_t id; 00061 } AB_JOBQUEUE_LIST; 00062 00067 void AB_JobQueue_List_AddList(AB_JOBQUEUE_LIST *dst, AB_JOBQUEUE_LIST *l); 00068 00072 void AB_JobQueue_List_Add(AB_JOBQUEUE *element, AB_JOBQUEUE_LIST *list); 00073 00078 void AB_JobQueue_List_Insert(AB_JOBQUEUE *element, AB_JOBQUEUE_LIST *list); 00079 00086 void AB_JobQueue_List_Del(AB_JOBQUEUE *element); 00087 00091 AB_JOBQUEUE* AB_JobQueue_List_First(const AB_JOBQUEUE_LIST *l); 00092 00096 AB_JOBQUEUE* AB_JobQueue_List_Last(const AB_JOBQUEUE_LIST *l); 00097 00102 void AB_JobQueue_List_Clear(AB_JOBQUEUE_LIST *l); 00103 00107 AB_JOBQUEUE_LIST* AB_JobQueue_List_new(); 00108 00112 void AB_JobQueue_List_free(AB_JOBQUEUE_LIST *l); 00113 00117 AB_JOBQUEUE* AB_JobQueue_List_Next(const AB_JOBQUEUE *element); 00118 00122 AB_JOBQUEUE* AB_JobQueue_List_Previous(const AB_JOBQUEUE *element); 00123 00127 uint32_t AB_JobQueue_List_GetCount(const AB_JOBQUEUE_LIST *l); 00128 00132 AB_JOBQUEUE_LIST_SORT_FN AB_JobQueue_List_SetSortFn(AB_JOBQUEUE_LIST *l, AB_JOBQUEUE_LIST_SORT_FN fn); 00133 00139 void AB_JobQueue_List_Sort(AB_JOBQUEUE_LIST *l, int ascending); 00140 00141 00142 #ifdef __cplusplus 00143 } 00144 #endif 00145 00146 00147 #endif 00148 00149 00150 00151 /*************************************************************************** 00152 $RCSfile$ 00153 ------------------- 00154 cvs : $Id$ 00155 begin : Sat Jun 28 2003 00156 copyright : (C) 2003 by Martin Preuss 00157 email : martin@libchipcard.de 00158 00159 *************************************************************************** 00160 * * 00161 * This library is free software; you can redistribute it and/or * 00162 * modify it under the terms of the GNU Lesser General Public * 00163 * License as published by the Free Software Foundation; either * 00164 * version 2.1 of the License, or (at your option) any later version. * 00165 * * 00166 * This library is distributed in the hope that it will be useful, * 00167 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 00168 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 00169 * Lesser General Public License for more details. * 00170 * * 00171 * You should have received a copy of the GNU Lesser General Public * 00172 * License along with this library; if not, write to the Free Software * 00173 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 00174 * MA 02111-1307 USA * 00175 * * 00176 ***************************************************************************/ 00177 00178 00179 #ifndef AB_BANKINFO_SERVICE_LIST2_H 00180 #define AB_BANKINFO_SERVICE_LIST2_H 00181 00182 00183 #ifdef __cplusplus 00184 extern "C" { 00185 #endif 00186 00193 typedef struct AB_BANKINFO_SERVICE_LIST2 AB_BANKINFO_SERVICE_LIST2; 00194 00198 typedef struct AB_BANKINFO_SERVICE_LIST2_ITERATOR AB_BANKINFO_SERVICE_LIST2_ITERATOR; 00199 00203 typedef AB_BANKINFO_SERVICE* (AB_BANKINFO_SERVICE_LIST2_FOREACH)(AB_BANKINFO_SERVICE *element, 00204 void *user_data); 00205 00209 AB_BANKINFO_SERVICE_LIST2 *AB_BankInfoService_List2_new(); 00210 00214 void AB_BankInfoService_List2_free(AB_BANKINFO_SERVICE_LIST2 *l); 00215 00219 void AB_BankInfoService_List2_Dump(AB_BANKINFO_SERVICE_LIST2 *l, FILE *f, unsigned int indent); 00220 00224 void AB_BankInfoService_List2_PushBack(AB_BANKINFO_SERVICE_LIST2 *l, AB_BANKINFO_SERVICE *p); 00225 00230 void AB_BankInfoService_List2_PushFront(AB_BANKINFO_SERVICE_LIST2 *l, AB_BANKINFO_SERVICE *p); 00231 00236 AB_BANKINFO_SERVICE *AB_BankInfoService_List2_GetFront(AB_BANKINFO_SERVICE_LIST2 *l); 00237 00242 AB_BANKINFO_SERVICE *AB_BankInfoService_List2_GetBack(AB_BANKINFO_SERVICE_LIST2 *l); 00243 00248 void AB_BankInfoService_List2_Erase(AB_BANKINFO_SERVICE_LIST2 *l, 00249 AB_BANKINFO_SERVICE_LIST2_ITERATOR *it); 00250 00256 unsigned int AB_BankInfoService_List2_GetSize(AB_BANKINFO_SERVICE_LIST2 *l); 00257 00262 void AB_BankInfoService_List2_PopBack(AB_BANKINFO_SERVICE_LIST2 *l); 00263 00268 void AB_BankInfoService_List2_PopFront(AB_BANKINFO_SERVICE_LIST2 *l); 00269 00273 void AB_BankInfoService_List2_Clear(AB_BANKINFO_SERVICE_LIST2 *l); 00274 00278 AB_BANKINFO_SERVICE_LIST2_ITERATOR *AB_BankInfoService_List2_First(AB_BANKINFO_SERVICE_LIST2 *l); 00279 00283 AB_BANKINFO_SERVICE_LIST2_ITERATOR *AB_BankInfoService_List2_Last(AB_BANKINFO_SERVICE_LIST2 *l); 00284 00288 AB_BANKINFO_SERVICE_LIST2_ITERATOR *AB_BankInfoService_List2Iterator_new(AB_BANKINFO_SERVICE_LIST2 *l); 00289 00293 void AB_BankInfoService_List2Iterator_free(AB_BANKINFO_SERVICE_LIST2_ITERATOR *li); 00294 00299 AB_BANKINFO_SERVICE *AB_BankInfoService_List2Iterator_Previous(AB_BANKINFO_SERVICE_LIST2_ITERATOR *li); 00300 00305 AB_BANKINFO_SERVICE *AB_BankInfoService_List2Iterator_Next(AB_BANKINFO_SERVICE_LIST2_ITERATOR *li); 00306 00311 AB_BANKINFO_SERVICE *AB_BankInfoService_List2Iterator_Data(AB_BANKINFO_SERVICE_LIST2_ITERATOR *li); 00312 00324 AB_BANKINFO_SERVICE *AB_BankInfoService_List2_ForEach(AB_BANKINFO_SERVICE_LIST2 *list, 00325 AB_BANKINFO_SERVICE_LIST2_FOREACH func, 00326 void *user_data); 00327 00328 00329 typedef struct AB_BANKINFO_SERVICE_CONSTLIST2 AB_BANKINFO_SERVICE_CONSTLIST2; 00330 typedef struct AB_BANKINFO_SERVICE_CONSTLIST2_ITERATOR AB_BANKINFO_SERVICE_CONSTLIST2_ITERATOR; 00331 typedef const AB_BANKINFO_SERVICE* 00332 (AB_BANKINFO_SERVICE_CONSTLIST2_FOREACH)(const AB_BANKINFO_SERVICE *element, 00333 void *user_data); 00334 00335 00336 AB_BANKINFO_SERVICE_CONSTLIST2 *AB_BankInfoService_ConstList2_new(); 00337 00338 void AB_BankInfoService_ConstList2_free(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 00339 00340 void AB_BankInfoService_ConstList2_PushBack(AB_BANKINFO_SERVICE_CONSTLIST2 *l, const AB_BANKINFO_SERVICE *p); 00341 00342 void AB_BankInfoService_ConstList2_PushFront(AB_BANKINFO_SERVICE_CONSTLIST2 *l, const AB_BANKINFO_SERVICE *p); 00343 00344 const AB_BANKINFO_SERVICE *AB_BankInfoService_ConstList2_GetFront(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 00345 00346 const AB_BANKINFO_SERVICE *AB_BankInfoService_ConstList2_GetBack(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 00347 00348 unsigned int AB_BankInfoService_ConstList2_GetSize(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 00349 00350 void AB_BankInfoService_ConstList2_PopBack(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 00351 00352 void AB_BankInfoService_ConstList2_PopFront(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 00353 00354 void AB_BankInfoService_ConstList2_Clear(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 00355 00356 AB_BANKINFO_SERVICE_CONSTLIST2_ITERATOR *AB_BankInfoService_ConstList2_First(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 00357 00358 AB_BANKINFO_SERVICE_CONSTLIST2_ITERATOR *AB_BankInfoService_ConstList2_Last(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 00359 00360 AB_BANKINFO_SERVICE_CONSTLIST2_ITERATOR *AB_BankInfoService_ConstList2Iterator_new(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 00361 00362 void AB_BankInfoService_ConstList2Iterator_free(AB_BANKINFO_SERVICE_CONSTLIST2_ITERATOR *li); 00363 00364 const AB_BANKINFO_SERVICE *AB_BankInfoService_ConstList2Iterator_Previous(AB_BANKINFO_SERVICE_CONSTLIST2_ITERATOR *li); 00365 00366 const AB_BANKINFO_SERVICE *AB_BankInfoService_ConstList2Iterator_Next(AB_BANKINFO_SERVICE_CONSTLIST2_ITERATOR *li); 00367 00368 const AB_BANKINFO_SERVICE *AB_BankInfoService_ConstList2Iterator_Data(AB_BANKINFO_SERVICE_CONSTLIST2_ITERATOR *li); 00369 00381 const AB_BANKINFO_SERVICE *AB_BankInfoService_ConstList2_ForEach(AB_BANKINFO_SERVICE_CONSTLIST2 *list, 00382 AB_BANKINFO_SERVICE_CONSTLIST2_FOREACH func, void *user_data); 00383 00384 00385 #ifdef __cplusplus 00386 } 00387 #endif 00388 00389 00390 #endif /* AB_BANKINFO_SERVICE_LIST_H */ 00391 00392 00393 00394 /*************************************************************************** 00395 $RCSfile$ 00396 ------------------- 00397 cvs : $Id$ 00398 begin : Sat Jun 28 2003 00399 copyright : (C) 2003 by Martin Preuss 00400 email : martin@libchipcard.de 00401 00402 *************************************************************************** 00403 * * 00404 * This library is free software; you can redistribute it and/or * 00405 * modify it under the terms of the GNU Lesser General Public * 00406 * License as published by the Free Software Foundation; either * 00407 * version 2.1 of the License, or (at your option) any later version. * 00408 * * 00409 * This library is distributed in the hope that it will be useful, * 00410 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 00411 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 00412 * Lesser General Public License for more details. * 00413 * * 00414 * You should have received a copy of the GNU Lesser General Public * 00415 * License along with this library; if not, write to the Free Software * 00416 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 00417 * MA 02111-1307 USA * 00418 * * 00419 ***************************************************************************/ 00420 00421 00422 #ifndef AB_BANKINFO_SERVICE_LIST1_H 00423 #define AB_BANKINFO_SERVICE_LIST1_H 00424 00425 #ifdef __cplusplus 00426 extern "C" { 00427 #endif 00428 00430 typedef struct AB_BANKINFO_SERVICE_LIST_ELEMENT { 00431 uint32_t id; 00432 AB_BANKINFO_SERVICE *nextObject; 00433 } AB_BANKINFO_SERVICE_LIST__ELEMENT; 00434 00441 typedef struct AB_BANKINFO_SERVICE_LIST AB_BANKINFO_SERVICE_LIST; 00442 00446 typedef int GWENHYWFAR_CB (*AB_BANKINFO_SERVICE_LIST_SORT_FN)(const AB_BANKINFO_SERVICE *a, const AB_BANKINFO_SERVICE *b, int ascending); 00447 00448 00450 struct AB_BANKINFO_SERVICE_LIST { 00451 AB_BANKINFO_SERVICE *first; 00452 uint32_t count; 00453 uint32_t id; 00454 } AB_BANKINFO_SERVICE_LIST; 00455 00460 void AB_BankInfoService_List_AddList(AB_BANKINFO_SERVICE_LIST *dst, AB_BANKINFO_SERVICE_LIST *l); 00461 00465 void AB_BankInfoService_List_Add(AB_BANKINFO_SERVICE *element, AB_BANKINFO_SERVICE_LIST *list); 00466 00471 void AB_BankInfoService_List_Insert(AB_BANKINFO_SERVICE *element, AB_BANKINFO_SERVICE_LIST *list); 00472 00479 void AB_BankInfoService_List_Del(AB_BANKINFO_SERVICE *element); 00480 00484 AB_BANKINFO_SERVICE* AB_BankInfoService_List_First(const AB_BANKINFO_SERVICE_LIST *l); 00485 00489 AB_BANKINFO_SERVICE* AB_BankInfoService_List_Last(const AB_BANKINFO_SERVICE_LIST *l); 00490 00495 void AB_BankInfoService_List_Clear(AB_BANKINFO_SERVICE_LIST *l); 00496 00500 AB_BANKINFO_SERVICE_LIST* AB_BankInfoService_List_new(); 00501 00505 void AB_BankInfoService_List_free(AB_BANKINFO_SERVICE_LIST *l); 00506 00510 AB_BANKINFO_SERVICE* AB_BankInfoService_List_Next(const AB_BANKINFO_SERVICE *element); 00511 00515 AB_BANKINFO_SERVICE* AB_BankInfoService_List_Previous(const AB_BANKINFO_SERVICE *element); 00516 00520 uint32_t AB_BankInfoService_List_GetCount(const AB_BANKINFO_SERVICE_LIST *l); 00521 00525 AB_BANKINFO_SERVICE_LIST_SORT_FN AB_BankInfoService_List_SetSortFn(AB_BANKINFO_SERVICE_LIST *l, AB_BANKINFO_SERVICE_LIST_SORT_FN fn); 00526 00532 void AB_BankInfoService_List_Sort(AB_BANKINFO_SERVICE_LIST *l, int ascending); 00533 00534 00535 #ifdef __cplusplus 00536 } 00537 #endif 00538 00539 00540 #endif 00541 00542 00543 00544 /*************************************************************************** 00545 $RCSfile$ 00546 ------------------- 00547 cvs : $Id$ 00548 begin : Sat Jun 28 2003 00549 copyright : (C) 2003 by Martin Preuss 00550 email : martin@libchipcard.de 00551 00552 *************************************************************************** 00553 * * 00554 * This library is free software; you can redistribute it and/or * 00555 * modify it under the terms of the GNU Lesser General Public * 00556 * License as published by the Free Software Foundation; either * 00557 * version 2.1 of the License, or (at your option) any later version. * 00558 * * 00559 * This library is distributed in the hope that it will be useful, * 00560 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 00561 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 00562 * Lesser General Public License for more details. * 00563 * * 00564 * You should have received a copy of the GNU Lesser General Public * 00565 * License along with this library; if not, write to the Free Software * 00566 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 00567 * MA 02111-1307 USA * 00568 * * 00569 ***************************************************************************/ 00570 00571 00572 #ifndef AB_ACCOUNT_LIST2_H 00573 #define AB_ACCOUNT_LIST2_H 00574 00575 00576 #ifdef __cplusplus 00577 extern "C" { 00578 #endif 00579 00586 typedef struct AB_ACCOUNT_LIST2 AB_ACCOUNT_LIST2; 00587 00591 typedef struct AB_ACCOUNT_LIST2_ITERATOR AB_ACCOUNT_LIST2_ITERATOR; 00592 00596 typedef AB_ACCOUNT* (AB_ACCOUNT_LIST2_FOREACH)(AB_ACCOUNT *element, 00597 void *user_data); 00598 00602 AB_ACCOUNT_LIST2 *AB_Account_List2_new(); 00603 00607 void AB_Account_List2_free(AB_ACCOUNT_LIST2 *l); 00608 00612 void AB_Account_List2_Dump(AB_ACCOUNT_LIST2 *l, FILE *f, unsigned int indent); 00613 00617 void AB_Account_List2_PushBack(AB_ACCOUNT_LIST2 *l, AB_ACCOUNT *p); 00618 00623 void AB_Account_List2_PushFront(AB_ACCOUNT_LIST2 *l, AB_ACCOUNT *p); 00624 00629 AB_ACCOUNT *AB_Account_List2_GetFront(AB_ACCOUNT_LIST2 *l); 00630 00635 AB_ACCOUNT *AB_Account_List2_GetBack(AB_ACCOUNT_LIST2 *l); 00636 00641 void AB_Account_List2_Erase(AB_ACCOUNT_LIST2 *l, 00642 AB_ACCOUNT_LIST2_ITERATOR *it); 00643 00649 unsigned int AB_Account_List2_GetSize(AB_ACCOUNT_LIST2 *l); 00650 00655 void AB_Account_List2_PopBack(AB_ACCOUNT_LIST2 *l); 00656 00661 void AB_Account_List2_PopFront(AB_ACCOUNT_LIST2 *l); 00662 00666 void AB_Account_List2_Clear(AB_ACCOUNT_LIST2 *l); 00667 00671 AB_ACCOUNT_LIST2_ITERATOR *AB_Account_List2_First(AB_ACCOUNT_LIST2 *l); 00672 00676 AB_ACCOUNT_LIST2_ITERATOR *AB_Account_List2_Last(AB_ACCOUNT_LIST2 *l); 00677 00681 AB_ACCOUNT_LIST2_ITERATOR *AB_Account_List2Iterator_new(AB_ACCOUNT_LIST2 *l); 00682 00686 void AB_Account_List2Iterator_free(AB_ACCOUNT_LIST2_ITERATOR *li); 00687 00692 AB_ACCOUNT *AB_Account_List2Iterator_Previous(AB_ACCOUNT_LIST2_ITERATOR *li); 00693 00698 AB_ACCOUNT *AB_Account_List2Iterator_Next(AB_ACCOUNT_LIST2_ITERATOR *li); 00699 00704 AB_ACCOUNT *AB_Account_List2Iterator_Data(AB_ACCOUNT_LIST2_ITERATOR *li); 00705 00717 AB_ACCOUNT *AB_Account_List2_ForEach(AB_ACCOUNT_LIST2 *list, 00718 AB_ACCOUNT_LIST2_FOREACH func, 00719 void *user_data); 00720 00721 00722 typedef struct AB_ACCOUNT_CONSTLIST2 AB_ACCOUNT_CONSTLIST2; 00723 typedef struct AB_ACCOUNT_CONSTLIST2_ITERATOR AB_ACCOUNT_CONSTLIST2_ITERATOR; 00724 typedef const AB_ACCOUNT* 00725 (AB_ACCOUNT_CONSTLIST2_FOREACH)(const AB_ACCOUNT *element, 00726 void *user_data); 00727 00728 00729 AB_ACCOUNT_CONSTLIST2 *AB_Account_ConstList2_new(); 00730 00731 void AB_Account_ConstList2_free(AB_ACCOUNT_CONSTLIST2 *l); 00732 00733 void AB_Account_ConstList2_PushBack(AB_ACCOUNT_CONSTLIST2 *l, const AB_ACCOUNT *p); 00734 00735 void AB_Account_ConstList2_PushFront(AB_ACCOUNT_CONSTLIST2 *l, const AB_ACCOUNT *p); 00736 00737 const AB_ACCOUNT *AB_Account_ConstList2_GetFront(AB_ACCOUNT_CONSTLIST2 *l); 00738 00739 const AB_ACCOUNT *AB_Account_ConstList2_GetBack(AB_ACCOUNT_CONSTLIST2 *l); 00740 00741 unsigned int AB_Account_ConstList2_GetSize(AB_ACCOUNT_CONSTLIST2 *l); 00742 00743 void AB_Account_ConstList2_PopBack(AB_ACCOUNT_CONSTLIST2 *l); 00744 00745 void AB_Account_ConstList2_PopFront(AB_ACCOUNT_CONSTLIST2 *l); 00746 00747 void AB_Account_ConstList2_Clear(AB_ACCOUNT_CONSTLIST2 *l); 00748 00749 AB_ACCOUNT_CONSTLIST2_ITERATOR *AB_Account_ConstList2_First(AB_ACCOUNT_CONSTLIST2 *l); 00750 00751 AB_ACCOUNT_CONSTLIST2_ITERATOR *AB_Account_ConstList2_Last(AB_ACCOUNT_CONSTLIST2 *l); 00752 00753 AB_ACCOUNT_CONSTLIST2_ITERATOR *AB_Account_ConstList2Iterator_new(AB_ACCOUNT_CONSTLIST2 *l); 00754 00755 void AB_Account_ConstList2Iterator_free(AB_ACCOUNT_CONSTLIST2_ITERATOR *li); 00756 00757 const AB_ACCOUNT *AB_Account_ConstList2Iterator_Previous(AB_ACCOUNT_CONSTLIST2_ITERATOR *li); 00758 00759 const AB_ACCOUNT *AB_Account_ConstList2Iterator_Next(AB_ACCOUNT_CONSTLIST2_ITERATOR *li); 00760 00761 const AB_ACCOUNT *AB_Account_ConstList2Iterator_Data(AB_ACCOUNT_CONSTLIST2_ITERATOR *li); 00762 00774 const AB_ACCOUNT *AB_Account_ConstList2_ForEach(AB_ACCOUNT_CONSTLIST2 *list, 00775 AB_ACCOUNT_CONSTLIST2_FOREACH func, void *user_data); 00776 00777 00778 #ifdef __cplusplus 00779 } 00780 #endif 00781 00782 00783 #endif /* AB_ACCOUNT_LIST_H */ 00784 00785 00786 00787 /*************************************************************************** 00788 $RCSfile$ 00789 ------------------- 00790 cvs : $Id$ 00791 begin : Sat Jun 28 2003 00792 copyright : (C) 2003 by Martin Preuss 00793 email : martin@libchipcard.de 00794 00795 *************************************************************************** 00796 * * 00797 * This library is free software; you can redistribute it and/or * 00798 * modify it under the terms of the GNU Lesser General Public * 00799 * License as published by the Free Software Foundation; either * 00800 * version 2.1 of the License, or (at your option) any later version. * 00801 * * 00802 * This library is distributed in the hope that it will be useful, * 00803 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 00804 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 00805 * Lesser General Public License for more details. * 00806 * * 00807 * You should have received a copy of the GNU Lesser General Public * 00808 * License along with this library; if not, write to the Free Software * 00809 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 00810 * MA 02111-1307 USA * 00811 * * 00812 ***************************************************************************/ 00813 00814 00815 #ifndef AB_BANKINFO_LIST2_H 00816 #define AB_BANKINFO_LIST2_H 00817 00818 00819 #ifdef __cplusplus 00820 extern "C" { 00821 #endif 00822 00829 typedef struct AB_BANKINFO_LIST2 AB_BANKINFO_LIST2; 00830 00834 typedef struct AB_BANKINFO_LIST2_ITERATOR AB_BANKINFO_LIST2_ITERATOR; 00835 00839 typedef AB_BANKINFO* (AB_BANKINFO_LIST2_FOREACH)(AB_BANKINFO *element, 00840 void *user_data); 00841 00845 AB_BANKINFO_LIST2 *AB_BankInfo_List2_new(); 00846 00850 void AB_BankInfo_List2_free(AB_BANKINFO_LIST2 *l); 00851 00855 void AB_BankInfo_List2_Dump(AB_BANKINFO_LIST2 *l, FILE *f, unsigned int indent); 00856 00860 void AB_BankInfo_List2_PushBack(AB_BANKINFO_LIST2 *l, AB_BANKINFO *p); 00861 00866 void AB_BankInfo_List2_PushFront(AB_BANKINFO_LIST2 *l, AB_BANKINFO *p); 00867 00872 AB_BANKINFO *AB_BankInfo_List2_GetFront(AB_BANKINFO_LIST2 *l); 00873 00878 AB_BANKINFO *AB_BankInfo_List2_GetBack(AB_BANKINFO_LIST2 *l); 00879 00884 void AB_BankInfo_List2_Erase(AB_BANKINFO_LIST2 *l, 00885 AB_BANKINFO_LIST2_ITERATOR *it); 00886 00892 unsigned int AB_BankInfo_List2_GetSize(AB_BANKINFO_LIST2 *l); 00893 00898 void AB_BankInfo_List2_PopBack(AB_BANKINFO_LIST2 *l); 00899 00904 void AB_BankInfo_List2_PopFront(AB_BANKINFO_LIST2 *l); 00905 00909 void AB_BankInfo_List2_Clear(AB_BANKINFO_LIST2 *l); 00910 00914 AB_BANKINFO_LIST2_ITERATOR *AB_BankInfo_List2_First(AB_BANKINFO_LIST2 *l); 00915 00919 AB_BANKINFO_LIST2_ITERATOR *AB_BankInfo_List2_Last(AB_BANKINFO_LIST2 *l); 00920 00924 AB_BANKINFO_LIST2_ITERATOR *AB_BankInfo_List2Iterator_new(AB_BANKINFO_LIST2 *l); 00925 00929 void AB_BankInfo_List2Iterator_free(AB_BANKINFO_LIST2_ITERATOR *li); 00930 00935 AB_BANKINFO *AB_BankInfo_List2Iterator_Previous(AB_BANKINFO_LIST2_ITERATOR *li); 00936 00941 AB_BANKINFO *AB_BankInfo_List2Iterator_Next(AB_BANKINFO_LIST2_ITERATOR *li); 00942 00947 AB_BANKINFO *AB_BankInfo_List2Iterator_Data(AB_BANKINFO_LIST2_ITERATOR *li); 00948 00960 AB_BANKINFO *AB_BankInfo_List2_ForEach(AB_BANKINFO_LIST2 *list, 00961 AB_BANKINFO_LIST2_FOREACH func, 00962 void *user_data); 00963 00964 00965 typedef struct AB_BANKINFO_CONSTLIST2 AB_BANKINFO_CONSTLIST2; 00966 typedef struct AB_BANKINFO_CONSTLIST2_ITERATOR AB_BANKINFO_CONSTLIST2_ITERATOR; 00967 typedef const AB_BANKINFO* 00968 (AB_BANKINFO_CONSTLIST2_FOREACH)(const AB_BANKINFO *element, 00969 void *user_data); 00970 00971 00972 AB_BANKINFO_CONSTLIST2 *AB_BankInfo_ConstList2_new(); 00973 00974 void AB_BankInfo_ConstList2_free(AB_BANKINFO_CONSTLIST2 *l); 00975 00976 void AB_BankInfo_ConstList2_PushBack(AB_BANKINFO_CONSTLIST2 *l, const AB_BANKINFO *p); 00977 00978 void AB_BankInfo_ConstList2_PushFront(AB_BANKINFO_CONSTLIST2 *l, const AB_BANKINFO *p); 00979 00980 const AB_BANKINFO *AB_BankInfo_ConstList2_GetFront(AB_BANKINFO_CONSTLIST2 *l); 00981 00982 const AB_BANKINFO *AB_BankInfo_ConstList2_GetBack(AB_BANKINFO_CONSTLIST2 *l); 00983 00984 unsigned int AB_BankInfo_ConstList2_GetSize(AB_BANKINFO_CONSTLIST2 *l); 00985 00986 void AB_BankInfo_ConstList2_PopBack(AB_BANKINFO_CONSTLIST2 *l); 00987 00988 void AB_BankInfo_ConstList2_PopFront(AB_BANKINFO_CONSTLIST2 *l); 00989 00990 void AB_BankInfo_ConstList2_Clear(AB_BANKINFO_CONSTLIST2 *l); 00991 00992 AB_BANKINFO_CONSTLIST2_ITERATOR *AB_BankInfo_ConstList2_First(AB_BANKINFO_CONSTLIST2 *l); 00993 00994 AB_BANKINFO_CONSTLIST2_ITERATOR *AB_BankInfo_ConstList2_Last(AB_BANKINFO_CONSTLIST2 *l); 00995 00996 AB_BANKINFO_CONSTLIST2_ITERATOR *AB_BankInfo_ConstList2Iterator_new(AB_BANKINFO_CONSTLIST2 *l); 00997 00998 void AB_BankInfo_ConstList2Iterator_free(AB_BANKINFO_CONSTLIST2_ITERATOR *li); 00999 01000 const AB_BANKINFO *AB_BankInfo_ConstList2Iterator_Previous(AB_BANKINFO_CONSTLIST2_ITERATOR *li); 01001 01002 const AB_BANKINFO *AB_BankInfo_ConstList2Iterator_Next(AB_BANKINFO_CONSTLIST2_ITERATOR *li); 01003 01004 const AB_BANKINFO *AB_BankInfo_ConstList2Iterator_Data(AB_BANKINFO_CONSTLIST2_ITERATOR *li); 01005 01017 const AB_BANKINFO *AB_BankInfo_ConstList2_ForEach(AB_BANKINFO_CONSTLIST2 *list, 01018 AB_BANKINFO_CONSTLIST2_FOREACH func, void *user_data); 01019 01020 01021 #ifdef __cplusplus 01022 } 01023 #endif 01024 01025 01026 #endif /* AB_BANKINFO_LIST_H */ 01027 01028 01029 01030 /*************************************************************************** 01031 $RCSfile$ 01032 ------------------- 01033 cvs : $Id$ 01034 begin : Sat Jun 28 2003 01035 copyright : (C) 2003 by Martin Preuss 01036 email : martin@libchipcard.de 01037 01038 *************************************************************************** 01039 * * 01040 * This library is free software; you can redistribute it and/or * 01041 * modify it under the terms of the GNU Lesser General Public * 01042 * License as published by the Free Software Foundation; either * 01043 * version 2.1 of the License, or (at your option) any later version. * 01044 * * 01045 * This library is distributed in the hope that it will be useful, * 01046 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 01047 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 01048 * Lesser General Public License for more details. * 01049 * * 01050 * You should have received a copy of the GNU Lesser General Public * 01051 * License along with this library; if not, write to the Free Software * 01052 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 01053 * MA 02111-1307 USA * 01054 * * 01055 ***************************************************************************/ 01056 01057 01058 #ifndef AB_BANKINFO_LIST1_H 01059 #define AB_BANKINFO_LIST1_H 01060 01061 #ifdef __cplusplus 01062 extern "C" { 01063 #endif 01064 01066 typedef struct AB_BANKINFO_LIST_ELEMENT { 01067 uint32_t id; 01068 AB_BANKINFO *nextObject; 01069 } AB_BANKINFO_LIST__ELEMENT; 01070 01077 typedef struct AB_BANKINFO_LIST AB_BANKINFO_LIST; 01078 01082 typedef int GWENHYWFAR_CB (*AB_BANKINFO_LIST_SORT_FN)(const AB_BANKINFO *a, const AB_BANKINFO *b, int ascending); 01083 01084 01086 struct AB_BANKINFO_LIST { 01087 AB_BANKINFO *first; 01088 uint32_t count; 01089 uint32_t id; 01090 } AB_BANKINFO_LIST; 01091 01096 void AB_BankInfo_List_AddList(AB_BANKINFO_LIST *dst, AB_BANKINFO_LIST *l); 01097 01101 void AB_BankInfo_List_Add(AB_BANKINFO *element, AB_BANKINFO_LIST *list); 01102 01107 void AB_BankInfo_List_Insert(AB_BANKINFO *element, AB_BANKINFO_LIST *list); 01108 01115 void AB_BankInfo_List_Del(AB_BANKINFO *element); 01116 01120 AB_BANKINFO* AB_BankInfo_List_First(const AB_BANKINFO_LIST *l); 01121 01125 AB_BANKINFO* AB_BankInfo_List_Last(const AB_BANKINFO_LIST *l); 01126 01131 void AB_BankInfo_List_Clear(AB_BANKINFO_LIST *l); 01132 01136 AB_BANKINFO_LIST* AB_BankInfo_List_new(); 01137 01141 void AB_BankInfo_List_free(AB_BANKINFO_LIST *l); 01142 01146 AB_BANKINFO* AB_BankInfo_List_Next(const AB_BANKINFO *element); 01147 01151 AB_BANKINFO* AB_BankInfo_List_Previous(const AB_BANKINFO *element); 01152 01156 uint32_t AB_BankInfo_List_GetCount(const AB_BANKINFO_LIST *l); 01157 01161 AB_BANKINFO_LIST_SORT_FN AB_BankInfo_List_SetSortFn(AB_BANKINFO_LIST *l, AB_BANKINFO_LIST_SORT_FN fn); 01162 01168 void AB_BankInfo_List_Sort(AB_BANKINFO_LIST *l, int ascending); 01169 01170 01171 #ifdef __cplusplus 01172 } 01173 #endif 01174 01175 01176 #endif 01177 01178 01179 01180 /*************************************************************************** 01181 $RCSfile$ 01182 ------------------- 01183 cvs : $Id$ 01184 begin : Sat Jun 28 2003 01185 copyright : (C) 2003 by Martin Preuss 01186 email : martin@libchipcard.de 01187 01188 *************************************************************************** 01189 * * 01190 * This library is free software; you can redistribute it and/or * 01191 * modify it under the terms of the GNU Lesser General Public * 01192 * License as published by the Free Software Foundation; either * 01193 * version 2.1 of the License, or (at your option) any later version. * 01194 * * 01195 * This library is distributed in the hope that it will be useful, * 01196 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 01197 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 01198 * Lesser General Public License for more details. * 01199 * * 01200 * You should have received a copy of the GNU Lesser General Public * 01201 * License along with this library; if not, write to the Free Software * 01202 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 01203 * MA 02111-1307 USA * 01204 * * 01205 ***************************************************************************/ 01206 01207 01208 #ifndef AB_TRANSACTION_LIST2_H 01209 #define AB_TRANSACTION_LIST2_H 01210 01211 01212 #ifdef __cplusplus 01213 extern "C" { 01214 #endif 01215 01222 typedef struct AB_TRANSACTION_LIST2 AB_TRANSACTION_LIST2; 01223 01227 typedef struct AB_TRANSACTION_LIST2_ITERATOR AB_TRANSACTION_LIST2_ITERATOR; 01228 01232 typedef AB_TRANSACTION* (AB_TRANSACTION_LIST2_FOREACH)(AB_TRANSACTION *element, 01233 void *user_data); 01234 01238 AB_TRANSACTION_LIST2 *AB_Transaction_List2_new(); 01239 01243 void AB_Transaction_List2_free(AB_TRANSACTION_LIST2 *l); 01244 01248 void AB_Transaction_List2_Dump(AB_TRANSACTION_LIST2 *l, FILE *f, unsigned int indent); 01249 01253 void AB_Transaction_List2_PushBack(AB_TRANSACTION_LIST2 *l, AB_TRANSACTION *p); 01254 01259 void AB_Transaction_List2_PushFront(AB_TRANSACTION_LIST2 *l, AB_TRANSACTION *p); 01260 01265 AB_TRANSACTION *AB_Transaction_List2_GetFront(AB_TRANSACTION_LIST2 *l); 01266 01271 AB_TRANSACTION *AB_Transaction_List2_GetBack(AB_TRANSACTION_LIST2 *l); 01272 01277 void AB_Transaction_List2_Erase(AB_TRANSACTION_LIST2 *l, 01278 AB_TRANSACTION_LIST2_ITERATOR *it); 01279 01285 unsigned int AB_Transaction_List2_GetSize(AB_TRANSACTION_LIST2 *l); 01286 01291 void AB_Transaction_List2_PopBack(AB_TRANSACTION_LIST2 *l); 01292 01297 void AB_Transaction_List2_PopFront(AB_TRANSACTION_LIST2 *l); 01298 01302 void AB_Transaction_List2_Clear(AB_TRANSACTION_LIST2 *l); 01303 01307 AB_TRANSACTION_LIST2_ITERATOR *AB_Transaction_List2_First(AB_TRANSACTION_LIST2 *l); 01308 01312 AB_TRANSACTION_LIST2_ITERATOR *AB_Transaction_List2_Last(AB_TRANSACTION_LIST2 *l); 01313 01317 AB_TRANSACTION_LIST2_ITERATOR *AB_Transaction_List2Iterator_new(AB_TRANSACTION_LIST2 *l); 01318 01322 void AB_Transaction_List2Iterator_free(AB_TRANSACTION_LIST2_ITERATOR *li); 01323 01328 AB_TRANSACTION *AB_Transaction_List2Iterator_Previous(AB_TRANSACTION_LIST2_ITERATOR *li); 01329 01334 AB_TRANSACTION *AB_Transaction_List2Iterator_Next(AB_TRANSACTION_LIST2_ITERATOR *li); 01335 01340 AB_TRANSACTION *AB_Transaction_List2Iterator_Data(AB_TRANSACTION_LIST2_ITERATOR *li); 01341 01353 AB_TRANSACTION *AB_Transaction_List2_ForEach(AB_TRANSACTION_LIST2 *list, 01354 AB_TRANSACTION_LIST2_FOREACH func, 01355 void *user_data); 01356 01357 01358 typedef struct AB_TRANSACTION_CONSTLIST2 AB_TRANSACTION_CONSTLIST2; 01359 typedef struct AB_TRANSACTION_CONSTLIST2_ITERATOR AB_TRANSACTION_CONSTLIST2_ITERATOR; 01360 typedef const AB_TRANSACTION* 01361 (AB_TRANSACTION_CONSTLIST2_FOREACH)(const AB_TRANSACTION *element, 01362 void *user_data); 01363 01364 01365 AB_TRANSACTION_CONSTLIST2 *AB_Transaction_ConstList2_new(); 01366 01367 void AB_Transaction_ConstList2_free(AB_TRANSACTION_CONSTLIST2 *l); 01368 01369 void AB_Transaction_ConstList2_PushBack(AB_TRANSACTION_CONSTLIST2 *l, const AB_TRANSACTION *p); 01370 01371 void AB_Transaction_ConstList2_PushFront(AB_TRANSACTION_CONSTLIST2 *l, const AB_TRANSACTION *p); 01372 01373 const AB_TRANSACTION *AB_Transaction_ConstList2_GetFront(AB_TRANSACTION_CONSTLIST2 *l); 01374 01375 const AB_TRANSACTION *AB_Transaction_ConstList2_GetBack(AB_TRANSACTION_CONSTLIST2 *l); 01376 01377 unsigned int AB_Transaction_ConstList2_GetSize(AB_TRANSACTION_CONSTLIST2 *l); 01378 01379 void AB_Transaction_ConstList2_PopBack(AB_TRANSACTION_CONSTLIST2 *l); 01380 01381 void AB_Transaction_ConstList2_PopFront(AB_TRANSACTION_CONSTLIST2 *l); 01382 01383 void AB_Transaction_ConstList2_Clear(AB_TRANSACTION_CONSTLIST2 *l); 01384 01385 AB_TRANSACTION_CONSTLIST2_ITERATOR *AB_Transaction_ConstList2_First(AB_TRANSACTION_CONSTLIST2 *l); 01386 01387 AB_TRANSACTION_CONSTLIST2_ITERATOR *AB_Transaction_ConstList2_Last(AB_TRANSACTION_CONSTLIST2 *l); 01388 01389 AB_TRANSACTION_CONSTLIST2_ITERATOR *AB_Transaction_ConstList2Iterator_new(AB_TRANSACTION_CONSTLIST2 *l); 01390 01391 void AB_Transaction_ConstList2Iterator_free(AB_TRANSACTION_CONSTLIST2_ITERATOR *li); 01392 01393 const AB_TRANSACTION *AB_Transaction_ConstList2Iterator_Previous(AB_TRANSACTION_CONSTLIST2_ITERATOR *li); 01394 01395 const AB_TRANSACTION *AB_Transaction_ConstList2Iterator_Next(AB_TRANSACTION_CONSTLIST2_ITERATOR *li); 01396 01397 const AB_TRANSACTION *AB_Transaction_ConstList2Iterator_Data(AB_TRANSACTION_CONSTLIST2_ITERATOR *li); 01398 01410 const AB_TRANSACTION *AB_Transaction_ConstList2_ForEach(AB_TRANSACTION_CONSTLIST2 *list, 01411 AB_TRANSACTION_CONSTLIST2_FOREACH func, void *user_data); 01412 01413 01414 #ifdef __cplusplus 01415 } 01416 #endif 01417 01418 01419 #endif /* AB_TRANSACTION_LIST_H */ 01420 01421 01422 01423 /*************************************************************************** 01424 $RCSfile$ 01425 ------------------- 01426 cvs : $Id$ 01427 begin : Sat Jun 28 2003 01428 copyright : (C) 2003 by Martin Preuss 01429 email : martin@libchipcard.de 01430 01431 *************************************************************************** 01432 * * 01433 * This library is free software; you can redistribute it and/or * 01434 * modify it under the terms of the GNU Lesser General Public * 01435 * License as published by the Free Software Foundation; either * 01436 * version 2.1 of the License, or (at your option) any later version. * 01437 * * 01438 * This library is distributed in the hope that it will be useful, * 01439 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 01440 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 01441 * Lesser General Public License for more details. * 01442 * * 01443 * You should have received a copy of the GNU Lesser General Public * 01444 * License along with this library; if not, write to the Free Software * 01445 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 01446 * MA 02111-1307 USA * 01447 * * 01448 ***************************************************************************/ 01449 01450 01451 #ifndef AB_TEXTKEY_DESCR_LIST2_H 01452 #define AB_TEXTKEY_DESCR_LIST2_H 01453 01454 01455 #ifdef __cplusplus 01456 extern "C" { 01457 #endif 01458 01465 typedef struct AB_TEXTKEY_DESCR_LIST2 AB_TEXTKEY_DESCR_LIST2; 01466 01470 typedef struct AB_TEXTKEY_DESCR_LIST2_ITERATOR AB_TEXTKEY_DESCR_LIST2_ITERATOR; 01471 01475 typedef AB_TEXTKEY_DESCR* (AB_TEXTKEY_DESCR_LIST2_FOREACH)(AB_TEXTKEY_DESCR *element, 01476 void *user_data); 01477 01481 AB_TEXTKEY_DESCR_LIST2 *AB_TextKeyDescr_List2_new(); 01482 01486 void AB_TextKeyDescr_List2_free(AB_TEXTKEY_DESCR_LIST2 *l); 01487 01491 void AB_TextKeyDescr_List2_Dump(AB_TEXTKEY_DESCR_LIST2 *l, FILE *f, unsigned int indent); 01492 01496 void AB_TextKeyDescr_List2_PushBack(AB_TEXTKEY_DESCR_LIST2 *l, AB_TEXTKEY_DESCR *p); 01497 01502 void AB_TextKeyDescr_List2_PushFront(AB_TEXTKEY_DESCR_LIST2 *l, AB_TEXTKEY_DESCR *p); 01503 01508 AB_TEXTKEY_DESCR *AB_TextKeyDescr_List2_GetFront(AB_TEXTKEY_DESCR_LIST2 *l); 01509 01514 AB_TEXTKEY_DESCR *AB_TextKeyDescr_List2_GetBack(AB_TEXTKEY_DESCR_LIST2 *l); 01515 01520 void AB_TextKeyDescr_List2_Erase(AB_TEXTKEY_DESCR_LIST2 *l, 01521 AB_TEXTKEY_DESCR_LIST2_ITERATOR *it); 01522 01528 unsigned int AB_TextKeyDescr_List2_GetSize(AB_TEXTKEY_DESCR_LIST2 *l); 01529 01534 void AB_TextKeyDescr_List2_PopBack(AB_TEXTKEY_DESCR_LIST2 *l); 01535 01540 void AB_TextKeyDescr_List2_PopFront(AB_TEXTKEY_DESCR_LIST2 *l); 01541 01545 void AB_TextKeyDescr_List2_Clear(AB_TEXTKEY_DESCR_LIST2 *l); 01546 01550 AB_TEXTKEY_DESCR_LIST2_ITERATOR *AB_TextKeyDescr_List2_First(AB_TEXTKEY_DESCR_LIST2 *l); 01551 01555 AB_TEXTKEY_DESCR_LIST2_ITERATOR *AB_TextKeyDescr_List2_Last(AB_TEXTKEY_DESCR_LIST2 *l); 01556 01560 AB_TEXTKEY_DESCR_LIST2_ITERATOR *AB_TextKeyDescr_List2Iterator_new(AB_TEXTKEY_DESCR_LIST2 *l); 01561 01565 void AB_TextKeyDescr_List2Iterator_free(AB_TEXTKEY_DESCR_LIST2_ITERATOR *li); 01566 01571 AB_TEXTKEY_DESCR *AB_TextKeyDescr_List2Iterator_Previous(AB_TEXTKEY_DESCR_LIST2_ITERATOR *li); 01572 01577 AB_TEXTKEY_DESCR *AB_TextKeyDescr_List2Iterator_Next(AB_TEXTKEY_DESCR_LIST2_ITERATOR *li); 01578 01583 AB_TEXTKEY_DESCR *AB_TextKeyDescr_List2Iterator_Data(AB_TEXTKEY_DESCR_LIST2_ITERATOR *li); 01584 01596 AB_TEXTKEY_DESCR *AB_TextKeyDescr_List2_ForEach(AB_TEXTKEY_DESCR_LIST2 *list, 01597 AB_TEXTKEY_DESCR_LIST2_FOREACH func, 01598 void *user_data); 01599 01600 01601 typedef struct AB_TEXTKEY_DESCR_CONSTLIST2 AB_TEXTKEY_DESCR_CONSTLIST2; 01602 typedef struct AB_TEXTKEY_DESCR_CONSTLIST2_ITERATOR AB_TEXTKEY_DESCR_CONSTLIST2_ITERATOR; 01603 typedef const AB_TEXTKEY_DESCR* 01604 (AB_TEXTKEY_DESCR_CONSTLIST2_FOREACH)(const AB_TEXTKEY_DESCR *element, 01605 void *user_data); 01606 01607 01608 AB_TEXTKEY_DESCR_CONSTLIST2 *AB_TextKeyDescr_ConstList2_new(); 01609 01610 void AB_TextKeyDescr_ConstList2_free(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 01611 01612 void AB_TextKeyDescr_ConstList2_PushBack(AB_TEXTKEY_DESCR_CONSTLIST2 *l, const AB_TEXTKEY_DESCR *p); 01613 01614 void AB_TextKeyDescr_ConstList2_PushFront(AB_TEXTKEY_DESCR_CONSTLIST2 *l, const AB_TEXTKEY_DESCR *p); 01615 01616 const AB_TEXTKEY_DESCR *AB_TextKeyDescr_ConstList2_GetFront(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 01617 01618 const AB_TEXTKEY_DESCR *AB_TextKeyDescr_ConstList2_GetBack(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 01619 01620 unsigned int AB_TextKeyDescr_ConstList2_GetSize(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 01621 01622 void AB_TextKeyDescr_ConstList2_PopBack(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 01623 01624 void AB_TextKeyDescr_ConstList2_PopFront(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 01625 01626 void AB_TextKeyDescr_ConstList2_Clear(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 01627 01628 AB_TEXTKEY_DESCR_CONSTLIST2_ITERATOR *AB_TextKeyDescr_ConstList2_First(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 01629 01630 AB_TEXTKEY_DESCR_CONSTLIST2_ITERATOR *AB_TextKeyDescr_ConstList2_Last(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 01631 01632 AB_TEXTKEY_DESCR_CONSTLIST2_ITERATOR *AB_TextKeyDescr_ConstList2Iterator_new(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 01633 01634 void AB_TextKeyDescr_ConstList2Iterator_free(AB_TEXTKEY_DESCR_CONSTLIST2_ITERATOR *li); 01635 01636 const AB_TEXTKEY_DESCR *AB_TextKeyDescr_ConstList2Iterator_Previous(AB_TEXTKEY_DESCR_CONSTLIST2_ITERATOR *li); 01637 01638 const AB_TEXTKEY_DESCR *AB_TextKeyDescr_ConstList2Iterator_Next(AB_TEXTKEY_DESCR_CONSTLIST2_ITERATOR *li); 01639 01640 const AB_TEXTKEY_DESCR *AB_TextKeyDescr_ConstList2Iterator_Data(AB_TEXTKEY_DESCR_CONSTLIST2_ITERATOR *li); 01641 01653 const AB_TEXTKEY_DESCR *AB_TextKeyDescr_ConstList2_ForEach(AB_TEXTKEY_DESCR_CONSTLIST2 *list, 01654 AB_TEXTKEY_DESCR_CONSTLIST2_FOREACH func, void *user_data); 01655 01656 01657 #ifdef __cplusplus 01658 } 01659 #endif 01660 01661 01662 #endif /* AB_TEXTKEY_DESCR_LIST_H */ 01663 01664 01665 01666 /*************************************************************************** 01667 $RCSfile$ 01668 ------------------- 01669 cvs : $Id$ 01670 begin : Sat Jun 28 2003 01671 copyright : (C) 2003 by Martin Preuss 01672 email : martin@libchipcard.de 01673 01674 *************************************************************************** 01675 * * 01676 * This library is free software; you can redistribute it and/or * 01677 * modify it under the terms of the GNU Lesser General Public * 01678 * License as published by the Free Software Foundation; either * 01679 * version 2.1 of the License, or (at your option) any later version. * 01680 * * 01681 * This library is distributed in the hope that it will be useful, * 01682 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 01683 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 01684 * Lesser General Public License for more details. * 01685 * * 01686 * You should have received a copy of the GNU Lesser General Public * 01687 * License along with this library; if not, write to the Free Software * 01688 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 01689 * MA 02111-1307 USA * 01690 * * 01691 ***************************************************************************/ 01692 01693 01694 #ifndef AB_TEXTKEY_DESCR_LIST1_H 01695 #define AB_TEXTKEY_DESCR_LIST1_H 01696 01697 #ifdef __cplusplus 01698 extern "C" { 01699 #endif 01700 01702 typedef struct AB_TEXTKEY_DESCR_LIST_ELEMENT { 01703 uint32_t id; 01704 AB_TEXTKEY_DESCR *nextObject; 01705 } AB_TEXTKEY_DESCR_LIST__ELEMENT; 01706 01713 typedef struct AB_TEXTKEY_DESCR_LIST AB_TEXTKEY_DESCR_LIST; 01714 01718 typedef int GWENHYWFAR_CB (*AB_TEXTKEY_DESCR_LIST_SORT_FN)(const AB_TEXTKEY_DESCR *a, const AB_TEXTKEY_DESCR *b, int ascending); 01719 01720 01722 struct AB_TEXTKEY_DESCR_LIST { 01723 AB_TEXTKEY_DESCR *first; 01724 uint32_t count; 01725 uint32_t id; 01726 } AB_TEXTKEY_DESCR_LIST; 01727 01732 void AB_TextKeyDescr_List_AddList(AB_TEXTKEY_DESCR_LIST *dst, AB_TEXTKEY_DESCR_LIST *l); 01733 01737 void AB_TextKeyDescr_List_Add(AB_TEXTKEY_DESCR *element, AB_TEXTKEY_DESCR_LIST *list); 01738 01743 void AB_TextKeyDescr_List_Insert(AB_TEXTKEY_DESCR *element, AB_TEXTKEY_DESCR_LIST *list); 01744 01751 void AB_TextKeyDescr_List_Del(AB_TEXTKEY_DESCR *element); 01752 01756 AB_TEXTKEY_DESCR* AB_TextKeyDescr_List_First(const AB_TEXTKEY_DESCR_LIST *l); 01757 01761 AB_TEXTKEY_DESCR* AB_TextKeyDescr_List_Last(const AB_TEXTKEY_DESCR_LIST *l); 01762 01767 void AB_TextKeyDescr_List_Clear(AB_TEXTKEY_DESCR_LIST *l); 01768 01772 AB_TEXTKEY_DESCR_LIST* AB_TextKeyDescr_List_new(); 01773 01777 void AB_TextKeyDescr_List_free(AB_TEXTKEY_DESCR_LIST *l); 01778 01782 AB_TEXTKEY_DESCR* AB_TextKeyDescr_List_Next(const AB_TEXTKEY_DESCR *element); 01783 01787 AB_TEXTKEY_DESCR* AB_TextKeyDescr_List_Previous(const AB_TEXTKEY_DESCR *element); 01788 01792 uint32_t AB_TextKeyDescr_List_GetCount(const AB_TEXTKEY_DESCR_LIST *l); 01793 01797 AB_TEXTKEY_DESCR_LIST_SORT_FN AB_TextKeyDescr_List_SetSortFn(AB_TEXTKEY_DESCR_LIST *l, AB_TEXTKEY_DESCR_LIST_SORT_FN fn); 01798 01804 void AB_TextKeyDescr_List_Sort(AB_TEXTKEY_DESCR_LIST *l, int ascending); 01805 01806 01807 #ifdef __cplusplus 01808 } 01809 #endif 01810 01811 01812 #endif 01813 01814 01815 01816 /*************************************************************************** 01817 $RCSfile$ 01818 ------------------- 01819 cvs : $Id$ 01820 begin : Sat Jun 28 2003 01821 copyright : (C) 2003 by Martin Preuss 01822 email : martin@libchipcard.de 01823 01824 *************************************************************************** 01825 * * 01826 * This library is free software; you can redistribute it and/or * 01827 * modify it under the terms of the GNU Lesser General Public * 01828 * License as published by the Free Software Foundation; either * 01829 * version 2.1 of the License, or (at your option) any later version. * 01830 * * 01831 * This library is distributed in the hope that it will be useful, * 01832 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 01833 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 01834 * Lesser General Public License for more details. * 01835 * * 01836 * You should have received a copy of the GNU Lesser General Public * 01837 * License along with this library; if not, write to the Free Software * 01838 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 01839 * MA 02111-1307 USA * 01840 * * 01841 ***************************************************************************/ 01842 01843 01844 #ifndef AB_ACCOUNTQUEUE_LIST1_H 01845 #define AB_ACCOUNTQUEUE_LIST1_H 01846 01847 #ifdef __cplusplus 01848 extern "C" { 01849 #endif 01850 01852 typedef struct AB_ACCOUNTQUEUE_LIST_ELEMENT { 01853 uint32_t id; 01854 AB_ACCOUNTQUEUE *nextObject; 01855 } AB_ACCOUNTQUEUE_LIST__ELEMENT; 01856 01863 typedef struct AB_ACCOUNTQUEUE_LIST AB_ACCOUNTQUEUE_LIST; 01864 01868 typedef int GWENHYWFAR_CB (*AB_ACCOUNTQUEUE_LIST_SORT_FN)(const AB_ACCOUNTQUEUE *a, const AB_ACCOUNTQUEUE *b, int ascending); 01869 01870 01872 struct AB_ACCOUNTQUEUE_LIST { 01873 AB_ACCOUNTQUEUE *first; 01874 uint32_t count; 01875 uint32_t id; 01876 } AB_ACCOUNTQUEUE_LIST; 01877 01882 void AB_AccountQueue_List_AddList(AB_ACCOUNTQUEUE_LIST *dst, AB_ACCOUNTQUEUE_LIST *l); 01883 01887 void AB_AccountQueue_List_Add(AB_ACCOUNTQUEUE *element, AB_ACCOUNTQUEUE_LIST *list); 01888 01893 void AB_AccountQueue_List_Insert(AB_ACCOUNTQUEUE *element, AB_ACCOUNTQUEUE_LIST *list); 01894 01901 void AB_AccountQueue_List_Del(AB_ACCOUNTQUEUE *element); 01902 01906 AB_ACCOUNTQUEUE* AB_AccountQueue_List_First(const AB_ACCOUNTQUEUE_LIST *l); 01907 01911 AB_ACCOUNTQUEUE* AB_AccountQueue_List_Last(const AB_ACCOUNTQUEUE_LIST *l); 01912 01917 void AB_AccountQueue_List_Clear(AB_ACCOUNTQUEUE_LIST *l); 01918 01922 AB_ACCOUNTQUEUE_LIST* AB_AccountQueue_List_new(); 01923 01927 void AB_AccountQueue_List_free(AB_ACCOUNTQUEUE_LIST *l); 01928 01932 AB_ACCOUNTQUEUE* AB_AccountQueue_List_Next(const AB_ACCOUNTQUEUE *element); 01933 01937 AB_ACCOUNTQUEUE* AB_AccountQueue_List_Previous(const AB_ACCOUNTQUEUE *element); 01938 01942 uint32_t AB_AccountQueue_List_GetCount(const AB_ACCOUNTQUEUE_LIST *l); 01943 01947 AB_ACCOUNTQUEUE_LIST_SORT_FN AB_AccountQueue_List_SetSortFn(AB_ACCOUNTQUEUE_LIST *l, AB_ACCOUNTQUEUE_LIST_SORT_FN fn); 01948 01954 void AB_AccountQueue_List_Sort(AB_ACCOUNTQUEUE_LIST *l, int ascending); 01955 01956 01957 #ifdef __cplusplus 01958 } 01959 #endif 01960 01961 01962 #endif 01963 01964 01965 01966 /*************************************************************************** 01967 $RCSfile$ 01968 ------------------- 01969 cvs : $Id$ 01970 begin : Sat Jun 28 2003 01971 copyright : (C) 2003 by Martin Preuss 01972 email : martin@libchipcard.de 01973 01974 *************************************************************************** 01975 * * 01976 * This library is free software; you can redistribute it and/or * 01977 * modify it under the terms of the GNU Lesser General Public * 01978 * License as published by the Free Software Foundation; either * 01979 * version 2.1 of the License, or (at your option) any later version. * 01980 * * 01981 * This library is distributed in the hope that it will be useful, * 01982 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 01983 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 01984 * Lesser General Public License for more details. * 01985 * * 01986 * You should have received a copy of the GNU Lesser General Public * 01987 * License along with this library; if not, write to the Free Software * 01988 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 01989 * MA 02111-1307 USA * 01990 * * 01991 ***************************************************************************/ 01992 01993 01994 #ifndef AB_ACCOUNT_STATUS_LIST2_H 01995 #define AB_ACCOUNT_STATUS_LIST2_H 01996 01997 01998 #ifdef __cplusplus 01999 extern "C" { 02000 #endif 02001 02008 typedef struct AB_ACCOUNT_STATUS_LIST2 AB_ACCOUNT_STATUS_LIST2; 02009 02013 typedef struct AB_ACCOUNT_STATUS_LIST2_ITERATOR AB_ACCOUNT_STATUS_LIST2_ITERATOR; 02014 02018 typedef AB_ACCOUNT_STATUS* (AB_ACCOUNT_STATUS_LIST2_FOREACH)(AB_ACCOUNT_STATUS *element, 02019 void *user_data); 02020 02024 AB_ACCOUNT_STATUS_LIST2 *AB_AccountStatus_List2_new(); 02025 02029 void AB_AccountStatus_List2_free(AB_ACCOUNT_STATUS_LIST2 *l); 02030 02034 void AB_AccountStatus_List2_Dump(AB_ACCOUNT_STATUS_LIST2 *l, FILE *f, unsigned int indent); 02035 02039 void AB_AccountStatus_List2_PushBack(AB_ACCOUNT_STATUS_LIST2 *l, AB_ACCOUNT_STATUS *p); 02040 02045 void AB_AccountStatus_List2_PushFront(AB_ACCOUNT_STATUS_LIST2 *l, AB_ACCOUNT_STATUS *p); 02046 02051 AB_ACCOUNT_STATUS *AB_AccountStatus_List2_GetFront(AB_ACCOUNT_STATUS_LIST2 *l); 02052 02057 AB_ACCOUNT_STATUS *AB_AccountStatus_List2_GetBack(AB_ACCOUNT_STATUS_LIST2 *l); 02058 02063 void AB_AccountStatus_List2_Erase(AB_ACCOUNT_STATUS_LIST2 *l, 02064 AB_ACCOUNT_STATUS_LIST2_ITERATOR *it); 02065 02071 unsigned int AB_AccountStatus_List2_GetSize(AB_ACCOUNT_STATUS_LIST2 *l); 02072 02077 void AB_AccountStatus_List2_PopBack(AB_ACCOUNT_STATUS_LIST2 *l); 02078 02083 void AB_AccountStatus_List2_PopFront(AB_ACCOUNT_STATUS_LIST2 *l); 02084 02088 void AB_AccountStatus_List2_Clear(AB_ACCOUNT_STATUS_LIST2 *l); 02089 02093 AB_ACCOUNT_STATUS_LIST2_ITERATOR *AB_AccountStatus_List2_First(AB_ACCOUNT_STATUS_LIST2 *l); 02094 02098 AB_ACCOUNT_STATUS_LIST2_ITERATOR *AB_AccountStatus_List2_Last(AB_ACCOUNT_STATUS_LIST2 *l); 02099 02103 AB_ACCOUNT_STATUS_LIST2_ITERATOR *AB_AccountStatus_List2Iterator_new(AB_ACCOUNT_STATUS_LIST2 *l); 02104 02108 void AB_AccountStatus_List2Iterator_free(AB_ACCOUNT_STATUS_LIST2_ITERATOR *li); 02109 02114 AB_ACCOUNT_STATUS *AB_AccountStatus_List2Iterator_Previous(AB_ACCOUNT_STATUS_LIST2_ITERATOR *li); 02115 02120 AB_ACCOUNT_STATUS *AB_AccountStatus_List2Iterator_Next(AB_ACCOUNT_STATUS_LIST2_ITERATOR *li); 02121 02126 AB_ACCOUNT_STATUS *AB_AccountStatus_List2Iterator_Data(AB_ACCOUNT_STATUS_LIST2_ITERATOR *li); 02127 02139 AB_ACCOUNT_STATUS *AB_AccountStatus_List2_ForEach(AB_ACCOUNT_STATUS_LIST2 *list, 02140 AB_ACCOUNT_STATUS_LIST2_FOREACH func, 02141 void *user_data); 02142 02143 02144 typedef struct AB_ACCOUNT_STATUS_CONSTLIST2 AB_ACCOUNT_STATUS_CONSTLIST2; 02145 typedef struct AB_ACCOUNT_STATUS_CONSTLIST2_ITERATOR AB_ACCOUNT_STATUS_CONSTLIST2_ITERATOR; 02146 typedef const AB_ACCOUNT_STATUS* 02147 (AB_ACCOUNT_STATUS_CONSTLIST2_FOREACH)(const AB_ACCOUNT_STATUS *element, 02148 void *user_data); 02149 02150 02151 AB_ACCOUNT_STATUS_CONSTLIST2 *AB_AccountStatus_ConstList2_new(); 02152 02153 void AB_AccountStatus_ConstList2_free(AB_ACCOUNT_STATUS_CONSTLIST2 *l); 02154 02155 void AB_AccountStatus_ConstList2_PushBack(AB_ACCOUNT_STATUS_CONSTLIST2 *l, const AB_ACCOUNT_STATUS *p); 02156 02157 void AB_AccountStatus_ConstList2_PushFront(AB_ACCOUNT_STATUS_CONSTLIST2 *l, const AB_ACCOUNT_STATUS *p); 02158 02159 const AB_ACCOUNT_STATUS *AB_AccountStatus_ConstList2_GetFront(AB_ACCOUNT_STATUS_CONSTLIST2 *l); 02160 02161 const AB_ACCOUNT_STATUS *AB_AccountStatus_ConstList2_GetBack(AB_ACCOUNT_STATUS_CONSTLIST2 *l); 02162 02163 unsigned int AB_AccountStatus_ConstList2_GetSize(AB_ACCOUNT_STATUS_CONSTLIST2 *l); 02164 02165 void AB_AccountStatus_ConstList2_PopBack(AB_ACCOUNT_STATUS_CONSTLIST2 *l); 02166 02167 void AB_AccountStatus_ConstList2_PopFront(AB_ACCOUNT_STATUS_CONSTLIST2 *l); 02168 02169 void AB_AccountStatus_ConstList2_Clear(AB_ACCOUNT_STATUS_CONSTLIST2 *l); 02170 02171 AB_ACCOUNT_STATUS_CONSTLIST2_ITERATOR *AB_AccountStatus_ConstList2_First(AB_ACCOUNT_STATUS_CONSTLIST2 *l); 02172 02173 AB_ACCOUNT_STATUS_CONSTLIST2_ITERATOR *AB_AccountStatus_ConstList2_Last(AB_ACCOUNT_STATUS_CONSTLIST2 *l); 02174 02175 AB_ACCOUNT_STATUS_CONSTLIST2_ITERATOR *AB_AccountStatus_ConstList2Iterator_new(AB_ACCOUNT_STATUS_CONSTLIST2 *l); 02176 02177 void AB_AccountStatus_ConstList2Iterator_free(AB_ACCOUNT_STATUS_CONSTLIST2_ITERATOR *li); 02178 02179 const AB_ACCOUNT_STATUS *AB_AccountStatus_ConstList2Iterator_Previous(AB_ACCOUNT_STATUS_CONSTLIST2_ITERATOR *li); 02180 02181 const AB_ACCOUNT_STATUS *AB_AccountStatus_ConstList2Iterator_Next(AB_ACCOUNT_STATUS_CONSTLIST2_ITERATOR *li); 02182 02183 const AB_ACCOUNT_STATUS *AB_AccountStatus_ConstList2Iterator_Data(AB_ACCOUNT_STATUS_CONSTLIST2_ITERATOR *li); 02184 02196 const AB_ACCOUNT_STATUS *AB_AccountStatus_ConstList2_ForEach(AB_ACCOUNT_STATUS_CONSTLIST2 *list, 02197 AB_ACCOUNT_STATUS_CONSTLIST2_FOREACH func, void *user_data); 02198 02199 02200 #ifdef __cplusplus 02201 } 02202 #endif 02203 02204 02205 #endif /* AB_ACCOUNT_STATUS_LIST_H */ 02206 02207 02208 02209 /*************************************************************************** 02210 $RCSfile$ 02211 ------------------- 02212 cvs : $Id$ 02213 begin : Sat Jun 28 2003 02214 copyright : (C) 2003 by Martin Preuss 02215 email : martin@libchipcard.de 02216 02217 *************************************************************************** 02218 * * 02219 * This library is free software; you can redistribute it and/or * 02220 * modify it under the terms of the GNU Lesser General Public * 02221 * License as published by the Free Software Foundation; either * 02222 * version 2.1 of the License, or (at your option) any later version. * 02223 * * 02224 * This library is distributed in the hope that it will be useful, * 02225 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 02226 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 02227 * Lesser General Public License for more details. * 02228 * * 02229 * You should have received a copy of the GNU Lesser General Public * 02230 * License along with this library; if not, write to the Free Software * 02231 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 02232 * MA 02111-1307 USA * 02233 * * 02234 ***************************************************************************/ 02235 02236 02237 #ifndef AB_VALUE_LIST1_H 02238 #define AB_VALUE_LIST1_H 02239 02240 #ifdef __cplusplus 02241 extern "C" { 02242 #endif 02243 02245 typedef struct AB_VALUE_LIST_ELEMENT { 02246 uint32_t id; 02247 AB_VALUE *nextObject; 02248 } AB_VALUE_LIST__ELEMENT; 02249 02256 typedef struct AB_VALUE_LIST AB_VALUE_LIST; 02257 02261 typedef int GWENHYWFAR_CB (*AB_VALUE_LIST_SORT_FN)(const AB_VALUE *a, const AB_VALUE *b, int ascending); 02262 02263 02265 struct AB_VALUE_LIST { 02266 AB_VALUE *first; 02267 uint32_t count; 02268 uint32_t id; 02269 } AB_VALUE_LIST; 02270 02275 void AB_Value_List_AddList(AB_VALUE_LIST *dst, AB_VALUE_LIST *l); 02276 02280 void AB_Value_List_Add(AB_VALUE *element, AB_VALUE_LIST *list); 02281 02286 void AB_Value_List_Insert(AB_VALUE *element, AB_VALUE_LIST *list); 02287 02294 void AB_Value_List_Del(AB_VALUE *element); 02295 02299 AB_VALUE* AB_Value_List_First(const AB_VALUE_LIST *l); 02300 02304 AB_VALUE* AB_Value_List_Last(const AB_VALUE_LIST *l); 02305 02310 void AB_Value_List_Clear(AB_VALUE_LIST *l); 02311 02315 AB_VALUE_LIST* AB_Value_List_new(); 02316 02320 void AB_Value_List_free(AB_VALUE_LIST *l); 02321 02325 AB_VALUE* AB_Value_List_Next(const AB_VALUE *element); 02326 02330 AB_VALUE* AB_Value_List_Previous(const AB_VALUE *element); 02331 02335 uint32_t AB_Value_List_GetCount(const AB_VALUE_LIST *l); 02336 02340 AB_VALUE_LIST_SORT_FN AB_Value_List_SetSortFn(AB_VALUE_LIST *l, AB_VALUE_LIST_SORT_FN fn); 02341 02347 void AB_Value_List_Sort(AB_VALUE_LIST *l, int ascending); 02348 02349 02350 #ifdef __cplusplus 02351 } 02352 #endif 02353 02354 02355 #endif 02356 02357 02358 02359 /*************************************************************************** 02360 $RCSfile$ 02361 ------------------- 02362 cvs : $Id$ 02363 begin : Sat Jun 28 2003 02364 copyright : (C) 2003 by Martin Preuss 02365 email : martin@libchipcard.de 02366 02367 *************************************************************************** 02368 * * 02369 * This library is free software; you can redistribute it and/or * 02370 * modify it under the terms of the GNU Lesser General Public * 02371 * License as published by the Free Software Foundation; either * 02372 * version 2.1 of the License, or (at your option) any later version. * 02373 * * 02374 * This library is distributed in the hope that it will be useful, * 02375 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 02376 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 02377 * Lesser General Public License for more details. * 02378 * * 02379 * You should have received a copy of the GNU Lesser General Public * 02380 * License along with this library; if not, write to the Free Software * 02381 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 02382 * MA 02111-1307 USA * 02383 * * 02384 ***************************************************************************/ 02385 02386 02387 #ifndef AB_COUNTRY_LIST2_H 02388 #define AB_COUNTRY_LIST2_H 02389 02390 02391 #ifdef __cplusplus 02392 extern "C" { 02393 #endif 02394 02401 typedef struct AB_COUNTRY_LIST2 AB_COUNTRY_LIST2; 02402 02406 typedef struct AB_COUNTRY_LIST2_ITERATOR AB_COUNTRY_LIST2_ITERATOR; 02407 02411 typedef AB_COUNTRY* (AB_COUNTRY_LIST2_FOREACH)(AB_COUNTRY *element, 02412 void *user_data); 02413 02417 AB_COUNTRY_LIST2 *AB_Country_List2_new(); 02418 02422 void AB_Country_List2_free(AB_COUNTRY_LIST2 *l); 02423 02427 void AB_Country_List2_Dump(AB_COUNTRY_LIST2 *l, FILE *f, unsigned int indent); 02428 02432 void AB_Country_List2_PushBack(AB_COUNTRY_LIST2 *l, AB_COUNTRY *p); 02433 02438 void AB_Country_List2_PushFront(AB_COUNTRY_LIST2 *l, AB_COUNTRY *p); 02439 02444 AB_COUNTRY *AB_Country_List2_GetFront(AB_COUNTRY_LIST2 *l); 02445 02450 AB_COUNTRY *AB_Country_List2_GetBack(AB_COUNTRY_LIST2 *l); 02451 02456 void AB_Country_List2_Erase(AB_COUNTRY_LIST2 *l, 02457 AB_COUNTRY_LIST2_ITERATOR *it); 02458 02464 unsigned int AB_Country_List2_GetSize(AB_COUNTRY_LIST2 *l); 02465 02470 void AB_Country_List2_PopBack(AB_COUNTRY_LIST2 *l); 02471 02476 void AB_Country_List2_PopFront(AB_COUNTRY_LIST2 *l); 02477 02481 void AB_Country_List2_Clear(AB_COUNTRY_LIST2 *l); 02482 02486 AB_COUNTRY_LIST2_ITERATOR *AB_Country_List2_First(AB_COUNTRY_LIST2 *l); 02487 02491 AB_COUNTRY_LIST2_ITERATOR *AB_Country_List2_Last(AB_COUNTRY_LIST2 *l); 02492 02496 AB_COUNTRY_LIST2_ITERATOR *AB_Country_List2Iterator_new(AB_COUNTRY_LIST2 *l); 02497 02501 void AB_Country_List2Iterator_free(AB_COUNTRY_LIST2_ITERATOR *li); 02502 02507 AB_COUNTRY *AB_Country_List2Iterator_Previous(AB_COUNTRY_LIST2_ITERATOR *li); 02508 02513 AB_COUNTRY *AB_Country_List2Iterator_Next(AB_COUNTRY_LIST2_ITERATOR *li); 02514 02519 AB_COUNTRY *AB_Country_List2Iterator_Data(AB_COUNTRY_LIST2_ITERATOR *li); 02520 02532 AB_COUNTRY *AB_Country_List2_ForEach(AB_COUNTRY_LIST2 *list, 02533 AB_COUNTRY_LIST2_FOREACH func, 02534 void *user_data); 02535 02536 02537 typedef struct AB_COUNTRY_CONSTLIST2 AB_COUNTRY_CONSTLIST2; 02538 typedef struct AB_COUNTRY_CONSTLIST2_ITERATOR AB_COUNTRY_CONSTLIST2_ITERATOR; 02539 typedef const AB_COUNTRY* 02540 (AB_COUNTRY_CONSTLIST2_FOREACH)(const AB_COUNTRY *element, 02541 void *user_data); 02542 02543 02544 AB_COUNTRY_CONSTLIST2 *AB_Country_ConstList2_new(); 02545 02546 void AB_Country_ConstList2_free(AB_COUNTRY_CONSTLIST2 *l); 02547 02548 void AB_Country_ConstList2_PushBack(AB_COUNTRY_CONSTLIST2 *l, const AB_COUNTRY *p); 02549 02550 void AB_Country_ConstList2_PushFront(AB_COUNTRY_CONSTLIST2 *l, const AB_COUNTRY *p); 02551 02552 const AB_COUNTRY *AB_Country_ConstList2_GetFront(AB_COUNTRY_CONSTLIST2 *l); 02553 02554 const AB_COUNTRY *AB_Country_ConstList2_GetBack(AB_COUNTRY_CONSTLIST2 *l); 02555 02556 unsigned int AB_Country_ConstList2_GetSize(AB_COUNTRY_CONSTLIST2 *l); 02557 02558 void AB_Country_ConstList2_PopBack(AB_COUNTRY_CONSTLIST2 *l); 02559 02560 void AB_Country_ConstList2_PopFront(AB_COUNTRY_CONSTLIST2 *l); 02561 02562 void AB_Country_ConstList2_Clear(AB_COUNTRY_CONSTLIST2 *l); 02563 02564 AB_COUNTRY_CONSTLIST2_ITERATOR *AB_Country_ConstList2_First(AB_COUNTRY_CONSTLIST2 *l); 02565 02566 AB_COUNTRY_CONSTLIST2_ITERATOR *AB_Country_ConstList2_Last(AB_COUNTRY_CONSTLIST2 *l); 02567 02568 AB_COUNTRY_CONSTLIST2_ITERATOR *AB_Country_ConstList2Iterator_new(AB_COUNTRY_CONSTLIST2 *l); 02569 02570 void AB_Country_ConstList2Iterator_free(AB_COUNTRY_CONSTLIST2_ITERATOR *li); 02571 02572 const AB_COUNTRY *AB_Country_ConstList2Iterator_Previous(AB_COUNTRY_CONSTLIST2_ITERATOR *li); 02573 02574 const AB_COUNTRY *AB_Country_ConstList2Iterator_Next(AB_COUNTRY_CONSTLIST2_ITERATOR *li); 02575 02576 const AB_COUNTRY *AB_Country_ConstList2Iterator_Data(AB_COUNTRY_CONSTLIST2_ITERATOR *li); 02577 02589 const AB_COUNTRY *AB_Country_ConstList2_ForEach(AB_COUNTRY_CONSTLIST2 *list, 02590 AB_COUNTRY_CONSTLIST2_FOREACH func, void *user_data); 02591 02592 02593 #ifdef __cplusplus 02594 } 02595 #endif 02596 02597 02598 #endif /* AB_COUNTRY_LIST_H */ 02599 02600 02601 02602 /*************************************************************************** 02603 $RCSfile$ 02604 ------------------- 02605 cvs : $Id$ 02606 begin : Sat Jun 28 2003 02607 copyright : (C) 2003 by Martin Preuss 02608 email : martin@libchipcard.de 02609 02610 *************************************************************************** 02611 * * 02612 * This library is free software; you can redistribute it and/or * 02613 * modify it under the terms of the GNU Lesser General Public * 02614 * License as published by the Free Software Foundation; either * 02615 * version 2.1 of the License, or (at your option) any later version. * 02616 * * 02617 * This library is distributed in the hope that it will be useful, * 02618 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 02619 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 02620 * Lesser General Public License for more details. * 02621 * * 02622 * You should have received a copy of the GNU Lesser General Public * 02623 * License along with this library; if not, write to the Free Software * 02624 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 02625 * MA 02111-1307 USA * 02626 * * 02627 ***************************************************************************/ 02628 02629 02630 #ifndef AB_PROVIDER_DESCRIPTION_LIST2_H 02631 #define AB_PROVIDER_DESCRIPTION_LIST2_H 02632 02633 02634 #ifdef __cplusplus 02635 extern "C" { 02636 #endif 02637 02644 typedef struct AB_PROVIDER_DESCRIPTION_LIST2 AB_PROVIDER_DESCRIPTION_LIST2; 02645 02649 typedef struct AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR; 02650 02654 typedef AB_PROVIDER_DESCRIPTION* (AB_PROVIDER_DESCRIPTION_LIST2_FOREACH)(AB_PROVIDER_DESCRIPTION *element, 02655 void *user_data); 02656 02660 AB_PROVIDER_DESCRIPTION_LIST2 *AB_ProviderDescription_List2_new(); 02661 02665 void AB_ProviderDescription_List2_free(AB_PROVIDER_DESCRIPTION_LIST2 *l); 02666 02670 void AB_ProviderDescription_List2_Dump(AB_PROVIDER_DESCRIPTION_LIST2 *l, FILE *f, unsigned int indent); 02671 02675 void AB_ProviderDescription_List2_PushBack(AB_PROVIDER_DESCRIPTION_LIST2 *l, AB_PROVIDER_DESCRIPTION *p); 02676 02681 void AB_ProviderDescription_List2_PushFront(AB_PROVIDER_DESCRIPTION_LIST2 *l, AB_PROVIDER_DESCRIPTION *p); 02682 02687 AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_List2_GetFront(AB_PROVIDER_DESCRIPTION_LIST2 *l); 02688 02693 AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_List2_GetBack(AB_PROVIDER_DESCRIPTION_LIST2 *l); 02694 02699 void AB_ProviderDescription_List2_Erase(AB_PROVIDER_DESCRIPTION_LIST2 *l, 02700 AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR *it); 02701 02707 unsigned int AB_ProviderDescription_List2_GetSize(AB_PROVIDER_DESCRIPTION_LIST2 *l); 02708 02713 void AB_ProviderDescription_List2_PopBack(AB_PROVIDER_DESCRIPTION_LIST2 *l); 02714 02719 void AB_ProviderDescription_List2_PopFront(AB_PROVIDER_DESCRIPTION_LIST2 *l); 02720 02724 void AB_ProviderDescription_List2_Clear(AB_PROVIDER_DESCRIPTION_LIST2 *l); 02725 02729 AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR *AB_ProviderDescription_List2_First(AB_PROVIDER_DESCRIPTION_LIST2 *l); 02730 02734 AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR *AB_ProviderDescription_List2_Last(AB_PROVIDER_DESCRIPTION_LIST2 *l); 02735 02739 AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR *AB_ProviderDescription_List2Iterator_new(AB_PROVIDER_DESCRIPTION_LIST2 *l); 02740 02744 void AB_ProviderDescription_List2Iterator_free(AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR *li); 02745 02750 AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_List2Iterator_Previous(AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR *li); 02751 02756 AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_List2Iterator_Next(AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR *li); 02757 02762 AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_List2Iterator_Data(AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR *li); 02763 02775 AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_List2_ForEach(AB_PROVIDER_DESCRIPTION_LIST2 *list, 02776 AB_PROVIDER_DESCRIPTION_LIST2_FOREACH func, 02777 void *user_data); 02778 02779 02780 typedef struct AB_PROVIDER_DESCRIPTION_CONSTLIST2 AB_PROVIDER_DESCRIPTION_CONSTLIST2; 02781 typedef struct AB_PROVIDER_DESCRIPTION_CONSTLIST2_ITERATOR AB_PROVIDER_DESCRIPTION_CONSTLIST2_ITERATOR; 02782 typedef const AB_PROVIDER_DESCRIPTION* 02783 (AB_PROVIDER_DESCRIPTION_CONSTLIST2_FOREACH)(const AB_PROVIDER_DESCRIPTION *element, 02784 void *user_data); 02785 02786 02787 AB_PROVIDER_DESCRIPTION_CONSTLIST2 *AB_ProviderDescription_ConstList2_new(); 02788 02789 void AB_ProviderDescription_ConstList2_free(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 02790 02791 void AB_ProviderDescription_ConstList2_PushBack(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l, const AB_PROVIDER_DESCRIPTION *p); 02792 02793 void AB_ProviderDescription_ConstList2_PushFront(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l, const AB_PROVIDER_DESCRIPTION *p); 02794 02795 const AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_ConstList2_GetFront(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 02796 02797 const AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_ConstList2_GetBack(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 02798 02799 unsigned int AB_ProviderDescription_ConstList2_GetSize(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 02800 02801 void AB_ProviderDescription_ConstList2_PopBack(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 02802 02803 void AB_ProviderDescription_ConstList2_PopFront(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 02804 02805 void AB_ProviderDescription_ConstList2_Clear(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 02806 02807 AB_PROVIDER_DESCRIPTION_CONSTLIST2_ITERATOR *AB_ProviderDescription_ConstList2_First(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 02808 02809 AB_PROVIDER_DESCRIPTION_CONSTLIST2_ITERATOR *AB_ProviderDescription_ConstList2_Last(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 02810 02811 AB_PROVIDER_DESCRIPTION_CONSTLIST2_ITERATOR *AB_ProviderDescription_ConstList2Iterator_new(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 02812 02813 void AB_ProviderDescription_ConstList2Iterator_free(AB_PROVIDER_DESCRIPTION_CONSTLIST2_ITERATOR *li); 02814 02815 const AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_ConstList2Iterator_Previous(AB_PROVIDER_DESCRIPTION_CONSTLIST2_ITERATOR *li); 02816 02817 const AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_ConstList2Iterator_Next(AB_PROVIDER_DESCRIPTION_CONSTLIST2_ITERATOR *li); 02818 02819 const AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_ConstList2Iterator_Data(AB_PROVIDER_DESCRIPTION_CONSTLIST2_ITERATOR *li); 02820 02832 const AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_ConstList2_ForEach(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *list, 02833 AB_PROVIDER_DESCRIPTION_CONSTLIST2_FOREACH func, void *user_data); 02834 02835 02836 #ifdef __cplusplus 02837 } 02838 #endif 02839 02840 02841 #endif /* AB_PROVIDER_DESCRIPTION_LIST_H */ 02842 02843 02844 02845 /*************************************************************************** 02846 $RCSfile$ 02847 ------------------- 02848 cvs : $Id$ 02849 begin : Sat Jun 28 2003 02850 copyright : (C) 2003 by Martin Preuss 02851 email : martin@libchipcard.de 02852 02853 *************************************************************************** 02854 * * 02855 * This library is free software; you can redistribute it and/or * 02856 * modify it under the terms of the GNU Lesser General Public * 02857 * License as published by the Free Software Foundation; either * 02858 * version 2.1 of the License, or (at your option) any later version. * 02859 * * 02860 * This library is distributed in the hope that it will be useful, * 02861 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 02862 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 02863 * Lesser General Public License for more details. * 02864 * * 02865 * You should have received a copy of the GNU Lesser General Public * 02866 * License along with this library; if not, write to the Free Software * 02867 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 02868 * MA 02111-1307 USA * 02869 * * 02870 ***************************************************************************/ 02871 02872 02873 #ifndef AB_PROVIDER_DESCRIPTION_LIST1_H 02874 #define AB_PROVIDER_DESCRIPTION_LIST1_H 02875 02876 #ifdef __cplusplus 02877 extern "C" { 02878 #endif 02879 02881 typedef struct AB_PROVIDER_DESCRIPTION_LIST_ELEMENT { 02882 uint32_t id; 02883 AB_PROVIDER_DESCRIPTION *nextObject; 02884 } AB_PROVIDER_DESCRIPTION_LIST__ELEMENT; 02885 02892 typedef struct AB_PROVIDER_DESCRIPTION_LIST AB_PROVIDER_DESCRIPTION_LIST; 02893 02897 typedef int GWENHYWFAR_CB (*AB_PROVIDER_DESCRIPTION_LIST_SORT_FN)(const AB_PROVIDER_DESCRIPTION *a, const AB_PROVIDER_DESCRIPTION *b, int ascending); 02898 02899 02901 struct AB_PROVIDER_DESCRIPTION_LIST { 02902 AB_PROVIDER_DESCRIPTION *first; 02903 uint32_t count; 02904 uint32_t id; 02905 } AB_PROVIDER_DESCRIPTION_LIST; 02906 02911 void AB_ProviderDescription_List_AddList(AB_PROVIDER_DESCRIPTION_LIST *dst, AB_PROVIDER_DESCRIPTION_LIST *l); 02912 02916 void AB_ProviderDescription_List_Add(AB_PROVIDER_DESCRIPTION *element, AB_PROVIDER_DESCRIPTION_LIST *list); 02917 02922 void AB_ProviderDescription_List_Insert(AB_PROVIDER_DESCRIPTION *element, AB_PROVIDER_DESCRIPTION_LIST *list); 02923 02930 void AB_ProviderDescription_List_Del(AB_PROVIDER_DESCRIPTION *element); 02931 02935 AB_PROVIDER_DESCRIPTION* AB_ProviderDescription_List_First(const AB_PROVIDER_DESCRIPTION_LIST *l); 02936 02940 AB_PROVIDER_DESCRIPTION* AB_ProviderDescription_List_Last(const AB_PROVIDER_DESCRIPTION_LIST *l); 02941 02946 void AB_ProviderDescription_List_Clear(AB_PROVIDER_DESCRIPTION_LIST *l); 02947 02951 AB_PROVIDER_DESCRIPTION_LIST* AB_ProviderDescription_List_new(); 02952 02956 void AB_ProviderDescription_List_free(AB_PROVIDER_DESCRIPTION_LIST *l); 02957 02961 AB_PROVIDER_DESCRIPTION* AB_ProviderDescription_List_Next(const AB_PROVIDER_DESCRIPTION *element); 02962 02966 AB_PROVIDER_DESCRIPTION* AB_ProviderDescription_List_Previous(const AB_PROVIDER_DESCRIPTION *element); 02967 02971 uint32_t AB_ProviderDescription_List_GetCount(const AB_PROVIDER_DESCRIPTION_LIST *l); 02972 02976 AB_PROVIDER_DESCRIPTION_LIST_SORT_FN AB_ProviderDescription_List_SetSortFn(AB_PROVIDER_DESCRIPTION_LIST *l, AB_PROVIDER_DESCRIPTION_LIST_SORT_FN fn); 02977 02983 void AB_ProviderDescription_List_Sort(AB_PROVIDER_DESCRIPTION_LIST *l, int ascending); 02984 02985 02986 #ifdef __cplusplus 02987 } 02988 #endif 02989 02990 02991 #endif 02992 02993 02994 02995 /*************************************************************************** 02996 $RCSfile$ 02997 ------------------- 02998 cvs : $Id$ 02999 begin : Sat Jun 28 2003 03000 copyright : (C) 2003 by Martin Preuss 03001 email : martin@libchipcard.de 03002 03003 *************************************************************************** 03004 * * 03005 * This library is free software; you can redistribute it and/or * 03006 * modify it under the terms of the GNU Lesser General Public * 03007 * License as published by the Free Software Foundation; either * 03008 * version 2.1 of the License, or (at your option) any later version. * 03009 * * 03010 * This library is distributed in the hope that it will be useful, * 03011 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 03012 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 03013 * Lesser General Public License for more details. * 03014 * * 03015 * You should have received a copy of the GNU Lesser General Public * 03016 * License along with this library; if not, write to the Free Software * 03017 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 03018 * MA 02111-1307 USA * 03019 * * 03020 ***************************************************************************/ 03021 03022 03023 #ifndef AB_CELLPHONE_PRODUCT_LIST2_H 03024 #define AB_CELLPHONE_PRODUCT_LIST2_H 03025 03026 03027 #ifdef __cplusplus 03028 extern "C" { 03029 #endif 03030 03037 typedef struct AB_CELLPHONE_PRODUCT_LIST2 AB_CELLPHONE_PRODUCT_LIST2; 03038 03042 typedef struct AB_CELLPHONE_PRODUCT_LIST2_ITERATOR AB_CELLPHONE_PRODUCT_LIST2_ITERATOR; 03043 03047 typedef AB_CELLPHONE_PRODUCT* (AB_CELLPHONE_PRODUCT_LIST2_FOREACH)(AB_CELLPHONE_PRODUCT *element, 03048 void *user_data); 03049 03053 AB_CELLPHONE_PRODUCT_LIST2 *AB_CellPhoneProduct_List2_new(); 03054 03058 void AB_CellPhoneProduct_List2_free(AB_CELLPHONE_PRODUCT_LIST2 *l); 03059 03063 void AB_CellPhoneProduct_List2_Dump(AB_CELLPHONE_PRODUCT_LIST2 *l, FILE *f, unsigned int indent); 03064 03068 void AB_CellPhoneProduct_List2_PushBack(AB_CELLPHONE_PRODUCT_LIST2 *l, AB_CELLPHONE_PRODUCT *p); 03069 03074 void AB_CellPhoneProduct_List2_PushFront(AB_CELLPHONE_PRODUCT_LIST2 *l, AB_CELLPHONE_PRODUCT *p); 03075 03080 AB_CELLPHONE_PRODUCT *AB_CellPhoneProduct_List2_GetFront(AB_CELLPHONE_PRODUCT_LIST2 *l); 03081 03086 AB_CELLPHONE_PRODUCT *AB_CellPhoneProduct_List2_GetBack(AB_CELLPHONE_PRODUCT_LIST2 *l); 03087 03092 void AB_CellPhoneProduct_List2_Erase(AB_CELLPHONE_PRODUCT_LIST2 *l, 03093 AB_CELLPHONE_PRODUCT_LIST2_ITERATOR *it); 03094 03100 unsigned int AB_CellPhoneProduct_List2_GetSize(AB_CELLPHONE_PRODUCT_LIST2 *l); 03101 03106 void AB_CellPhoneProduct_List2_PopBack(AB_CELLPHONE_PRODUCT_LIST2 *l); 03107 03112 void AB_CellPhoneProduct_List2_PopFront(AB_CELLPHONE_PRODUCT_LIST2 *l); 03113 03117 void AB_CellPhoneProduct_List2_Clear(AB_CELLPHONE_PRODUCT_LIST2 *l); 03118 03122 AB_CELLPHONE_PRODUCT_LIST2_ITERATOR *AB_CellPhoneProduct_List2_First(AB_CELLPHONE_PRODUCT_LIST2 *l); 03123 03127 AB_CELLPHONE_PRODUCT_LIST2_ITERATOR *AB_CellPhoneProduct_List2_Last(AB_CELLPHONE_PRODUCT_LIST2 *l); 03128 03132 AB_CELLPHONE_PRODUCT_LIST2_ITERATOR *AB_CellPhoneProduct_List2Iterator_new(AB_CELLPHONE_PRODUCT_LIST2 *l); 03133 03137 void AB_CellPhoneProduct_List2Iterator_free(AB_CELLPHONE_PRODUCT_LIST2_ITERATOR *li); 03138 03143 AB_CELLPHONE_PRODUCT *AB_CellPhoneProduct_List2Iterator_Previous(AB_CELLPHONE_PRODUCT_LIST2_ITERATOR *li); 03144 03149 AB_CELLPHONE_PRODUCT *AB_CellPhoneProduct_List2Iterator_Next(AB_CELLPHONE_PRODUCT_LIST2_ITERATOR *li); 03150 03155 AB_CELLPHONE_PRODUCT *AB_CellPhoneProduct_List2Iterator_Data(AB_CELLPHONE_PRODUCT_LIST2_ITERATOR *li); 03156 03168 AB_CELLPHONE_PRODUCT *AB_CellPhoneProduct_List2_ForEach(AB_CELLPHONE_PRODUCT_LIST2 *list, 03169 AB_CELLPHONE_PRODUCT_LIST2_FOREACH func, 03170 void *user_data); 03171 03172 03173 typedef struct AB_CELLPHONE_PRODUCT_CONSTLIST2 AB_CELLPHONE_PRODUCT_CONSTLIST2; 03174 typedef struct AB_CELLPHONE_PRODUCT_CONSTLIST2_ITERATOR AB_CELLPHONE_PRODUCT_CONSTLIST2_ITERATOR; 03175 typedef const AB_CELLPHONE_PRODUCT* 03176 (AB_CELLPHONE_PRODUCT_CONSTLIST2_FOREACH)(const AB_CELLPHONE_PRODUCT *element, 03177 void *user_data); 03178 03179 03180 AB_CELLPHONE_PRODUCT_CONSTLIST2 *AB_CellPhoneProduct_ConstList2_new(); 03181 03182 void AB_CellPhoneProduct_ConstList2_free(AB_CELLPHONE_PRODUCT_CONSTLIST2 *l); 03183 03184 void AB_CellPhoneProduct_ConstList2_PushBack(AB_CELLPHONE_PRODUCT_CONSTLIST2 *l, const AB_CELLPHONE_PRODUCT *p); 03185 03186 void AB_CellPhoneProduct_ConstList2_PushFront(AB_CELLPHONE_PRODUCT_CONSTLIST2 *l, const AB_CELLPHONE_PRODUCT *p); 03187 03188 const AB_CELLPHONE_PRODUCT *AB_CellPhoneProduct_ConstList2_GetFront(AB_CELLPHONE_PRODUCT_CONSTLIST2 *l); 03189 03190 const AB_CELLPHONE_PRODUCT *AB_CellPhoneProduct_ConstList2_GetBack(AB_CELLPHONE_PRODUCT_CONSTLIST2 *l); 03191 03192 unsigned int AB_CellPhoneProduct_ConstList2_GetSize(AB_CELLPHONE_PRODUCT_CONSTLIST2 *l); 03193 03194 void AB_CellPhoneProduct_ConstList2_PopBack(AB_CELLPHONE_PRODUCT_CONSTLIST2 *l); 03195 03196 void AB_CellPhoneProduct_ConstList2_PopFront(AB_CELLPHONE_PRODUCT_CONSTLIST2 *l); 03197 03198 void AB_CellPhoneProduct_ConstList2_Clear(AB_CELLPHONE_PRODUCT_CONSTLIST2 *l); 03199 03200 AB_CELLPHONE_PRODUCT_CONSTLIST2_ITERATOR *AB_CellPhoneProduct_ConstList2_First(AB_CELLPHONE_PRODUCT_CONSTLIST2 *l); 03201 03202 AB_CELLPHONE_PRODUCT_CONSTLIST2_ITERATOR *AB_CellPhoneProduct_ConstList2_Last(AB_CELLPHONE_PRODUCT_CONSTLIST2 *l); 03203 03204 AB_CELLPHONE_PRODUCT_CONSTLIST2_ITERATOR *AB_CellPhoneProduct_ConstList2Iterator_new(AB_CELLPHONE_PRODUCT_CONSTLIST2 *l); 03205 03206 void AB_CellPhoneProduct_ConstList2Iterator_free(AB_CELLPHONE_PRODUCT_CONSTLIST2_ITERATOR *li); 03207 03208 const AB_CELLPHONE_PRODUCT *AB_CellPhoneProduct_ConstList2Iterator_Previous(AB_CELLPHONE_PRODUCT_CONSTLIST2_ITERATOR *li); 03209 03210 const AB_CELLPHONE_PRODUCT *AB_CellPhoneProduct_ConstList2Iterator_Next(AB_CELLPHONE_PRODUCT_CONSTLIST2_ITERATOR *li); 03211 03212 const AB_CELLPHONE_PRODUCT *AB_CellPhoneProduct_ConstList2Iterator_Data(AB_CELLPHONE_PRODUCT_CONSTLIST2_ITERATOR *li); 03213 03225 const AB_CELLPHONE_PRODUCT *AB_CellPhoneProduct_ConstList2_ForEach(AB_CELLPHONE_PRODUCT_CONSTLIST2 *list, 03226 AB_CELLPHONE_PRODUCT_CONSTLIST2_FOREACH func, void *user_data); 03227 03228 03229 #ifdef __cplusplus 03230 } 03231 #endif 03232 03233 03234 #endif /* AB_CELLPHONE_PRODUCT_LIST_H */ 03235 03236 03237 03238 /*************************************************************************** 03239 $RCSfile$ 03240 ------------------- 03241 cvs : $Id$ 03242 begin : Sat Jun 28 2003 03243 copyright : (C) 2003 by Martin Preuss 03244 email : martin@libchipcard.de 03245 03246 *************************************************************************** 03247 * * 03248 * This library is free software; you can redistribute it and/or * 03249 * modify it under the terms of the GNU Lesser General Public * 03250 * License as published by the Free Software Foundation; either * 03251 * version 2.1 of the License, or (at your option) any later version. * 03252 * * 03253 * This library is distributed in the hope that it will be useful, * 03254 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 03255 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 03256 * Lesser General Public License for more details. * 03257 * * 03258 * You should have received a copy of the GNU Lesser General Public * 03259 * License along with this library; if not, write to the Free Software * 03260 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 03261 * MA 02111-1307 USA * 03262 * * 03263 ***************************************************************************/ 03264 03265 03266 #ifndef AB_CELLPHONE_PRODUCT_LIST1_H 03267 #define AB_CELLPHONE_PRODUCT_LIST1_H 03268 03269 #ifdef __cplusplus 03270 extern "C" { 03271 #endif 03272 03274 typedef struct AB_CELLPHONE_PRODUCT_LIST_ELEMENT { 03275 uint32_t id; 03276 AB_CELLPHONE_PRODUCT *nextObject; 03277 } AB_CELLPHONE_PRODUCT_LIST__ELEMENT; 03278 03285 typedef struct AB_CELLPHONE_PRODUCT_LIST AB_CELLPHONE_PRODUCT_LIST; 03286 03290 typedef int GWENHYWFAR_CB (*AB_CELLPHONE_PRODUCT_LIST_SORT_FN)(const AB_CELLPHONE_PRODUCT *a, const AB_CELLPHONE_PRODUCT *b, int ascending); 03291 03292 03294 struct AB_CELLPHONE_PRODUCT_LIST { 03295 AB_CELLPHONE_PRODUCT *first; 03296 uint32_t count; 03297 uint32_t id; 03298 } AB_CELLPHONE_PRODUCT_LIST; 03299 03304 void AB_CellPhoneProduct_List_AddList(AB_CELLPHONE_PRODUCT_LIST *dst, AB_CELLPHONE_PRODUCT_LIST *l); 03305 03309 void AB_CellPhoneProduct_List_Add(AB_CELLPHONE_PRODUCT *element, AB_CELLPHONE_PRODUCT_LIST *list); 03310 03315 void AB_CellPhoneProduct_List_Insert(AB_CELLPHONE_PRODUCT *element, AB_CELLPHONE_PRODUCT_LIST *list); 03316 03323 void AB_CellPhoneProduct_List_Del(AB_CELLPHONE_PRODUCT *element); 03324 03328 AB_CELLPHONE_PRODUCT* AB_CellPhoneProduct_List_First(const AB_CELLPHONE_PRODUCT_LIST *l); 03329 03333 AB_CELLPHONE_PRODUCT* AB_CellPhoneProduct_List_Last(const AB_CELLPHONE_PRODUCT_LIST *l); 03334 03339 void AB_CellPhoneProduct_List_Clear(AB_CELLPHONE_PRODUCT_LIST *l); 03340 03344 AB_CELLPHONE_PRODUCT_LIST* AB_CellPhoneProduct_List_new(); 03345 03349 void AB_CellPhoneProduct_List_free(AB_CELLPHONE_PRODUCT_LIST *l); 03350 03354 AB_CELLPHONE_PRODUCT* AB_CellPhoneProduct_List_Next(const AB_CELLPHONE_PRODUCT *element); 03355 03359 AB_CELLPHONE_PRODUCT* AB_CellPhoneProduct_List_Previous(const AB_CELLPHONE_PRODUCT *element); 03360 03364 uint32_t AB_CellPhoneProduct_List_GetCount(const AB_CELLPHONE_PRODUCT_LIST *l); 03365 03369 AB_CELLPHONE_PRODUCT_LIST_SORT_FN AB_CellPhoneProduct_List_SetSortFn(AB_CELLPHONE_PRODUCT_LIST *l, AB_CELLPHONE_PRODUCT_LIST_SORT_FN fn); 03370 03376 void AB_CellPhoneProduct_List_Sort(AB_CELLPHONE_PRODUCT_LIST *l, int ascending); 03377 03378 03379 #ifdef __cplusplus 03380 } 03381 #endif 03382 03383 03384 #endif 03385 03386 03387 03388 /*************************************************************************** 03389 $RCSfile$ 03390 ------------------- 03391 cvs : $Id$ 03392 begin : Sat Jun 28 2003 03393 copyright : (C) 2003 by Martin Preuss 03394 email : martin@libchipcard.de 03395 03396 *************************************************************************** 03397 * * 03398 * This library is free software; you can redistribute it and/or * 03399 * modify it under the terms of the GNU Lesser General Public * 03400 * License as published by the Free Software Foundation; either * 03401 * version 2.1 of the License, or (at your option) any later version. * 03402 * * 03403 * This library is distributed in the hope that it will be useful, * 03404 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 03405 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 03406 * Lesser General Public License for more details. * 03407 * * 03408 * You should have received a copy of the GNU Lesser General Public * 03409 * License along with this library; if not, write to the Free Software * 03410 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 03411 * MA 02111-1307 USA * 03412 * * 03413 ***************************************************************************/ 03414 03415 03416 #ifndef AB_JOB_LIST2_H 03417 #define AB_JOB_LIST2_H 03418 03419 03420 #ifdef __cplusplus 03421 extern "C" { 03422 #endif 03423 03430 typedef struct AB_JOB_LIST2 AB_JOB_LIST2; 03431 03435 typedef struct AB_JOB_LIST2_ITERATOR AB_JOB_LIST2_ITERATOR; 03436 03440 typedef AB_JOB* (AB_JOB_LIST2_FOREACH)(AB_JOB *element, 03441 void *user_data); 03442 03446 AB_JOB_LIST2 *AB_Job_List2_new(); 03447 03451 void AB_Job_List2_free(AB_JOB_LIST2 *l); 03452 03456 void AB_Job_List2_Dump(AB_JOB_LIST2 *l, FILE *f, unsigned int indent); 03457 03461 void AB_Job_List2_PushBack(AB_JOB_LIST2 *l, AB_JOB *p); 03462 03467 void AB_Job_List2_PushFront(AB_JOB_LIST2 *l, AB_JOB *p); 03468 03473 AB_JOB *AB_Job_List2_GetFront(AB_JOB_LIST2 *l); 03474 03479 AB_JOB *AB_Job_List2_GetBack(AB_JOB_LIST2 *l); 03480 03485 void AB_Job_List2_Erase(AB_JOB_LIST2 *l, 03486 AB_JOB_LIST2_ITERATOR *it); 03487 03493 unsigned int AB_Job_List2_GetSize(AB_JOB_LIST2 *l); 03494 03499 void AB_Job_List2_PopBack(AB_JOB_LIST2 *l); 03500 03505 void AB_Job_List2_PopFront(AB_JOB_LIST2 *l); 03506 03510 void AB_Job_List2_Clear(AB_JOB_LIST2 *l); 03511 03515 AB_JOB_LIST2_ITERATOR *AB_Job_List2_First(AB_JOB_LIST2 *l); 03516 03520 AB_JOB_LIST2_ITERATOR *AB_Job_List2_Last(AB_JOB_LIST2 *l); 03521 03525 AB_JOB_LIST2_ITERATOR *AB_Job_List2Iterator_new(AB_JOB_LIST2 *l); 03526 03530 void AB_Job_List2Iterator_free(AB_JOB_LIST2_ITERATOR *li); 03531 03536 AB_JOB *AB_Job_List2Iterator_Previous(AB_JOB_LIST2_ITERATOR *li); 03537 03542 AB_JOB *AB_Job_List2Iterator_Next(AB_JOB_LIST2_ITERATOR *li); 03543 03548 AB_JOB *AB_Job_List2Iterator_Data(AB_JOB_LIST2_ITERATOR *li); 03549 03561 AB_JOB *AB_Job_List2_ForEach(AB_JOB_LIST2 *list, 03562 AB_JOB_LIST2_FOREACH func, 03563 void *user_data); 03564 03565 03566 typedef struct AB_JOB_CONSTLIST2 AB_JOB_CONSTLIST2; 03567 typedef struct AB_JOB_CONSTLIST2_ITERATOR AB_JOB_CONSTLIST2_ITERATOR; 03568 typedef const AB_JOB* 03569 (AB_JOB_CONSTLIST2_FOREACH)(const AB_JOB *element, 03570 void *user_data); 03571 03572 03573 AB_JOB_CONSTLIST2 *AB_Job_ConstList2_new(); 03574 03575 void AB_Job_ConstList2_free(AB_JOB_CONSTLIST2 *l); 03576 03577 void AB_Job_ConstList2_PushBack(AB_JOB_CONSTLIST2 *l, const AB_JOB *p); 03578 03579 void AB_Job_ConstList2_PushFront(AB_JOB_CONSTLIST2 *l, const AB_JOB *p); 03580 03581 const AB_JOB *AB_Job_ConstList2_GetFront(AB_JOB_CONSTLIST2 *l); 03582 03583 const AB_JOB *AB_Job_ConstList2_GetBack(AB_JOB_CONSTLIST2 *l); 03584 03585 unsigned int AB_Job_ConstList2_GetSize(AB_JOB_CONSTLIST2 *l); 03586 03587 void AB_Job_ConstList2_PopBack(AB_JOB_CONSTLIST2 *l); 03588 03589 void AB_Job_ConstList2_PopFront(AB_JOB_CONSTLIST2 *l); 03590 03591 void AB_Job_ConstList2_Clear(AB_JOB_CONSTLIST2 *l); 03592 03593 AB_JOB_CONSTLIST2_ITERATOR *AB_Job_ConstList2_First(AB_JOB_CONSTLIST2 *l); 03594 03595 AB_JOB_CONSTLIST2_ITERATOR *AB_Job_ConstList2_Last(AB_JOB_CONSTLIST2 *l); 03596 03597 AB_JOB_CONSTLIST2_ITERATOR *AB_Job_ConstList2Iterator_new(AB_JOB_CONSTLIST2 *l); 03598 03599 void AB_Job_ConstList2Iterator_free(AB_JOB_CONSTLIST2_ITERATOR *li); 03600 03601 const AB_JOB *AB_Job_ConstList2Iterator_Previous(AB_JOB_CONSTLIST2_ITERATOR *li); 03602 03603 const AB_JOB *AB_Job_ConstList2Iterator_Next(AB_JOB_CONSTLIST2_ITERATOR *li); 03604 03605 const AB_JOB *AB_Job_ConstList2Iterator_Data(AB_JOB_CONSTLIST2_ITERATOR *li); 03606 03618 const AB_JOB *AB_Job_ConstList2_ForEach(AB_JOB_CONSTLIST2 *list, 03619 AB_JOB_CONSTLIST2_FOREACH func, void *user_data); 03620 03621 03622 #ifdef __cplusplus 03623 } 03624 #endif 03625 03626 03627 #endif /* AB_JOB_LIST_H */ 03628 03629 03630 03631 /*************************************************************************** 03632 $RCSfile$ 03633 ------------------- 03634 cvs : $Id$ 03635 begin : Sat Jun 28 2003 03636 copyright : (C) 2003 by Martin Preuss 03637 email : martin@libchipcard.de 03638 03639 *************************************************************************** 03640 * * 03641 * This library is free software; you can redistribute it and/or * 03642 * modify it under the terms of the GNU Lesser General Public * 03643 * License as published by the Free Software Foundation; either * 03644 * version 2.1 of the License, or (at your option) any later version. * 03645 * * 03646 * This library is distributed in the hope that it will be useful, * 03647 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 03648 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 03649 * Lesser General Public License for more details. * 03650 * * 03651 * You should have received a copy of the GNU Lesser General Public * 03652 * License along with this library; if not, write to the Free Software * 03653 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 03654 * MA 02111-1307 USA * 03655 * * 03656 ***************************************************************************/ 03657 03658 03659 #ifndef AB_BANKINFO_PLUGIN_LIST2_H 03660 #define AB_BANKINFO_PLUGIN_LIST2_H 03661 03662 03663 #ifdef __cplusplus 03664 extern "C" { 03665 #endif 03666 03673 typedef struct AB_BANKINFO_PLUGIN_LIST2 AB_BANKINFO_PLUGIN_LIST2; 03674 03678 typedef struct AB_BANKINFO_PLUGIN_LIST2_ITERATOR AB_BANKINFO_PLUGIN_LIST2_ITERATOR; 03679 03683 typedef AB_BANKINFO_PLUGIN* (AB_BANKINFO_PLUGIN_LIST2_FOREACH)(AB_BANKINFO_PLUGIN *element, 03684 void *user_data); 03685 03689 AB_BANKINFO_PLUGIN_LIST2 *AB_BankInfoPlugin_List2_new(); 03690 03694 void AB_BankInfoPlugin_List2_free(AB_BANKINFO_PLUGIN_LIST2 *l); 03695 03699 void AB_BankInfoPlugin_List2_Dump(AB_BANKINFO_PLUGIN_LIST2 *l, FILE *f, unsigned int indent); 03700 03704 void AB_BankInfoPlugin_List2_PushBack(AB_BANKINFO_PLUGIN_LIST2 *l, AB_BANKINFO_PLUGIN *p); 03705 03710 void AB_BankInfoPlugin_List2_PushFront(AB_BANKINFO_PLUGIN_LIST2 *l, AB_BANKINFO_PLUGIN *p); 03711 03716 AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_List2_GetFront(AB_BANKINFO_PLUGIN_LIST2 *l); 03717 03722 AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_List2_GetBack(AB_BANKINFO_PLUGIN_LIST2 *l); 03723 03728 void AB_BankInfoPlugin_List2_Erase(AB_BANKINFO_PLUGIN_LIST2 *l, 03729 AB_BANKINFO_PLUGIN_LIST2_ITERATOR *it); 03730 03736 unsigned int AB_BankInfoPlugin_List2_GetSize(AB_BANKINFO_PLUGIN_LIST2 *l); 03737 03742 void AB_BankInfoPlugin_List2_PopBack(AB_BANKINFO_PLUGIN_LIST2 *l); 03743 03748 void AB_BankInfoPlugin_List2_PopFront(AB_BANKINFO_PLUGIN_LIST2 *l); 03749 03753 void AB_BankInfoPlugin_List2_Clear(AB_BANKINFO_PLUGIN_LIST2 *l); 03754 03758 AB_BANKINFO_PLUGIN_LIST2_ITERATOR *AB_BankInfoPlugin_List2_First(AB_BANKINFO_PLUGIN_LIST2 *l); 03759 03763 AB_BANKINFO_PLUGIN_LIST2_ITERATOR *AB_BankInfoPlugin_List2_Last(AB_BANKINFO_PLUGIN_LIST2 *l); 03764 03768 AB_BANKINFO_PLUGIN_LIST2_ITERATOR *AB_BankInfoPlugin_List2Iterator_new(AB_BANKINFO_PLUGIN_LIST2 *l); 03769 03773 void AB_BankInfoPlugin_List2Iterator_free(AB_BANKINFO_PLUGIN_LIST2_ITERATOR *li); 03774 03779 AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_List2Iterator_Previous(AB_BANKINFO_PLUGIN_LIST2_ITERATOR *li); 03780 03785 AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_List2Iterator_Next(AB_BANKINFO_PLUGIN_LIST2_ITERATOR *li); 03786 03791 AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_List2Iterator_Data(AB_BANKINFO_PLUGIN_LIST2_ITERATOR *li); 03792 03804 AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_List2_ForEach(AB_BANKINFO_PLUGIN_LIST2 *list, 03805 AB_BANKINFO_PLUGIN_LIST2_FOREACH func, 03806 void *user_data); 03807 03808 03809 typedef struct AB_BANKINFO_PLUGIN_CONSTLIST2 AB_BANKINFO_PLUGIN_CONSTLIST2; 03810 typedef struct AB_BANKINFO_PLUGIN_CONSTLIST2_ITERATOR AB_BANKINFO_PLUGIN_CONSTLIST2_ITERATOR; 03811 typedef const AB_BANKINFO_PLUGIN* 03812 (AB_BANKINFO_PLUGIN_CONSTLIST2_FOREACH)(const AB_BANKINFO_PLUGIN *element, 03813 void *user_data); 03814 03815 03816 AB_BANKINFO_PLUGIN_CONSTLIST2 *AB_BankInfoPlugin_ConstList2_new(); 03817 03818 void AB_BankInfoPlugin_ConstList2_free(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 03819 03820 void AB_BankInfoPlugin_ConstList2_PushBack(AB_BANKINFO_PLUGIN_CONSTLIST2 *l, const AB_BANKINFO_PLUGIN *p); 03821 03822 void AB_BankInfoPlugin_ConstList2_PushFront(AB_BANKINFO_PLUGIN_CONSTLIST2 *l, const AB_BANKINFO_PLUGIN *p); 03823 03824 const AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_ConstList2_GetFront(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 03825 03826 const AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_ConstList2_GetBack(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 03827 03828 unsigned int AB_BankInfoPlugin_ConstList2_GetSize(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 03829 03830 void AB_BankInfoPlugin_ConstList2_PopBack(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 03831 03832 void AB_BankInfoPlugin_ConstList2_PopFront(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 03833 03834 void AB_BankInfoPlugin_ConstList2_Clear(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 03835 03836 AB_BANKINFO_PLUGIN_CONSTLIST2_ITERATOR *AB_BankInfoPlugin_ConstList2_First(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 03837 03838 AB_BANKINFO_PLUGIN_CONSTLIST2_ITERATOR *AB_BankInfoPlugin_ConstList2_Last(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 03839 03840 AB_BANKINFO_PLUGIN_CONSTLIST2_ITERATOR *AB_BankInfoPlugin_ConstList2Iterator_new(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 03841 03842 void AB_BankInfoPlugin_ConstList2Iterator_free(AB_BANKINFO_PLUGIN_CONSTLIST2_ITERATOR *li); 03843 03844 const AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_ConstList2Iterator_Previous(AB_BANKINFO_PLUGIN_CONSTLIST2_ITERATOR *li); 03845 03846 const AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_ConstList2Iterator_Next(AB_BANKINFO_PLUGIN_CONSTLIST2_ITERATOR *li); 03847 03848 const AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_ConstList2Iterator_Data(AB_BANKINFO_PLUGIN_CONSTLIST2_ITERATOR *li); 03849 03861 const AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_ConstList2_ForEach(AB_BANKINFO_PLUGIN_CONSTLIST2 *list, 03862 AB_BANKINFO_PLUGIN_CONSTLIST2_FOREACH func, void *user_data); 03863 03864 03865 #ifdef __cplusplus 03866 } 03867 #endif 03868 03869 03870 #endif /* AB_BANKINFO_PLUGIN_LIST_H */ 03871 03872 03873 03874 /*************************************************************************** 03875 $RCSfile$ 03876 ------------------- 03877 cvs : $Id$ 03878 begin : Sat Jun 28 2003 03879 copyright : (C) 2003 by Martin Preuss 03880 email : martin@libchipcard.de 03881 03882 *************************************************************************** 03883 * * 03884 * This library is free software; you can redistribute it and/or * 03885 * modify it under the terms of the GNU Lesser General Public * 03886 * License as published by the Free Software Foundation; either * 03887 * version 2.1 of the License, or (at your option) any later version. * 03888 * * 03889 * This library is distributed in the hope that it will be useful, * 03890 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 03891 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 03892 * Lesser General Public License for more details. * 03893 * * 03894 * You should have received a copy of the GNU Lesser General Public * 03895 * License along with this library; if not, write to the Free Software * 03896 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 03897 * MA 02111-1307 USA * 03898 * * 03899 ***************************************************************************/ 03900 03901 03902 #ifndef AB_TRANSACTION_LIMITS_LIST2_H 03903 #define AB_TRANSACTION_LIMITS_LIST2_H 03904 03905 03906 #ifdef __cplusplus 03907 extern "C" { 03908 #endif 03909 03916 typedef struct AB_TRANSACTION_LIMITS_LIST2 AB_TRANSACTION_LIMITS_LIST2; 03917 03921 typedef struct AB_TRANSACTION_LIMITS_LIST2_ITERATOR AB_TRANSACTION_LIMITS_LIST2_ITERATOR; 03922 03926 typedef AB_TRANSACTION_LIMITS* (AB_TRANSACTION_LIMITS_LIST2_FOREACH)(AB_TRANSACTION_LIMITS *element, 03927 void *user_data); 03928 03932 AB_TRANSACTION_LIMITS_LIST2 *AB_TransactionLimits_List2_new(); 03933 03937 void AB_TransactionLimits_List2_free(AB_TRANSACTION_LIMITS_LIST2 *l); 03938 03942 void AB_TransactionLimits_List2_Dump(AB_TRANSACTION_LIMITS_LIST2 *l, FILE *f, unsigned int indent); 03943 03947 void AB_TransactionLimits_List2_PushBack(AB_TRANSACTION_LIMITS_LIST2 *l, AB_TRANSACTION_LIMITS *p); 03948 03953 void AB_TransactionLimits_List2_PushFront(AB_TRANSACTION_LIMITS_LIST2 *l, AB_TRANSACTION_LIMITS *p); 03954 03959 AB_TRANSACTION_LIMITS *AB_TransactionLimits_List2_GetFront(AB_TRANSACTION_LIMITS_LIST2 *l); 03960 03965 AB_TRANSACTION_LIMITS *AB_TransactionLimits_List2_GetBack(AB_TRANSACTION_LIMITS_LIST2 *l); 03966 03971 void AB_TransactionLimits_List2_Erase(AB_TRANSACTION_LIMITS_LIST2 *l, 03972 AB_TRANSACTION_LIMITS_LIST2_ITERATOR *it); 03973 03979 unsigned int AB_TransactionLimits_List2_GetSize(AB_TRANSACTION_LIMITS_LIST2 *l); 03980 03985 void AB_TransactionLimits_List2_PopBack(AB_TRANSACTION_LIMITS_LIST2 *l); 03986 03991 void AB_TransactionLimits_List2_PopFront(AB_TRANSACTION_LIMITS_LIST2 *l); 03992 03996 void AB_TransactionLimits_List2_Clear(AB_TRANSACTION_LIMITS_LIST2 *l); 03997 04001 AB_TRANSACTION_LIMITS_LIST2_ITERATOR *AB_TransactionLimits_List2_First(AB_TRANSACTION_LIMITS_LIST2 *l); 04002 04006 AB_TRANSACTION_LIMITS_LIST2_ITERATOR *AB_TransactionLimits_List2_Last(AB_TRANSACTION_LIMITS_LIST2 *l); 04007 04011 AB_TRANSACTION_LIMITS_LIST2_ITERATOR *AB_TransactionLimits_List2Iterator_new(AB_TRANSACTION_LIMITS_LIST2 *l); 04012 04016 void AB_TransactionLimits_List2Iterator_free(AB_TRANSACTION_LIMITS_LIST2_ITERATOR *li); 04017 04022 AB_TRANSACTION_LIMITS *AB_TransactionLimits_List2Iterator_Previous(AB_TRANSACTION_LIMITS_LIST2_ITERATOR *li); 04023 04028 AB_TRANSACTION_LIMITS *AB_TransactionLimits_List2Iterator_Next(AB_TRANSACTION_LIMITS_LIST2_ITERATOR *li); 04029 04034 AB_TRANSACTION_LIMITS *AB_TransactionLimits_List2Iterator_Data(AB_TRANSACTION_LIMITS_LIST2_ITERATOR *li); 04035 04047 AB_TRANSACTION_LIMITS *AB_TransactionLimits_List2_ForEach(AB_TRANSACTION_LIMITS_LIST2 *list, 04048 AB_TRANSACTION_LIMITS_LIST2_FOREACH func, 04049 void *user_data); 04050 04051 04052 typedef struct AB_TRANSACTION_LIMITS_CONSTLIST2 AB_TRANSACTION_LIMITS_CONSTLIST2; 04053 typedef struct AB_TRANSACTION_LIMITS_CONSTLIST2_ITERATOR AB_TRANSACTION_LIMITS_CONSTLIST2_ITERATOR; 04054 typedef const AB_TRANSACTION_LIMITS* 04055 (AB_TRANSACTION_LIMITS_CONSTLIST2_FOREACH)(const AB_TRANSACTION_LIMITS *element, 04056 void *user_data); 04057 04058 04059 AB_TRANSACTION_LIMITS_CONSTLIST2 *AB_TransactionLimits_ConstList2_new(); 04060 04061 void AB_TransactionLimits_ConstList2_free(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 04062 04063 void AB_TransactionLimits_ConstList2_PushBack(AB_TRANSACTION_LIMITS_CONSTLIST2 *l, const AB_TRANSACTION_LIMITS *p); 04064 04065 void AB_TransactionLimits_ConstList2_PushFront(AB_TRANSACTION_LIMITS_CONSTLIST2 *l, const AB_TRANSACTION_LIMITS *p); 04066 04067 const AB_TRANSACTION_LIMITS *AB_TransactionLimits_ConstList2_GetFront(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 04068 04069 const AB_TRANSACTION_LIMITS *AB_TransactionLimits_ConstList2_GetBack(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 04070 04071 unsigned int AB_TransactionLimits_ConstList2_GetSize(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 04072 04073 void AB_TransactionLimits_ConstList2_PopBack(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 04074 04075 void AB_TransactionLimits_ConstList2_PopFront(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 04076 04077 void AB_TransactionLimits_ConstList2_Clear(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 04078 04079 AB_TRANSACTION_LIMITS_CONSTLIST2_ITERATOR *AB_TransactionLimits_ConstList2_First(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 04080 04081 AB_TRANSACTION_LIMITS_CONSTLIST2_ITERATOR *AB_TransactionLimits_ConstList2_Last(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 04082 04083 AB_TRANSACTION_LIMITS_CONSTLIST2_ITERATOR *AB_TransactionLimits_ConstList2Iterator_new(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 04084 04085 void AB_TransactionLimits_ConstList2Iterator_free(AB_TRANSACTION_LIMITS_CONSTLIST2_ITERATOR *li); 04086 04087 const AB_TRANSACTION_LIMITS *AB_TransactionLimits_ConstList2Iterator_Previous(AB_TRANSACTION_LIMITS_CONSTLIST2_ITERATOR *li); 04088 04089 const AB_TRANSACTION_LIMITS *AB_TransactionLimits_ConstList2Iterator_Next(AB_TRANSACTION_LIMITS_CONSTLIST2_ITERATOR *li); 04090 04091 const AB_TRANSACTION_LIMITS *AB_TransactionLimits_ConstList2Iterator_Data(AB_TRANSACTION_LIMITS_CONSTLIST2_ITERATOR *li); 04092 04104 const AB_TRANSACTION_LIMITS *AB_TransactionLimits_ConstList2_ForEach(AB_TRANSACTION_LIMITS_CONSTLIST2 *list, 04105 AB_TRANSACTION_LIMITS_CONSTLIST2_FOREACH func, void *user_data); 04106 04107 04108 #ifdef __cplusplus 04109 } 04110 #endif 04111 04112 04113 #endif /* AB_TRANSACTION_LIMITS_LIST_H */ 04114 04115 04116 04117 /*************************************************************************** 04118 $RCSfile$ 04119 ------------------- 04120 cvs : $Id$ 04121 begin : Sat Jun 28 2003 04122 copyright : (C) 2003 by Martin Preuss 04123 email : martin@libchipcard.de 04124 04125 *************************************************************************** 04126 * * 04127 * This library is free software; you can redistribute it and/or * 04128 * modify it under the terms of the GNU Lesser General Public * 04129 * License as published by the Free Software Foundation; either * 04130 * version 2.1 of the License, or (at your option) any later version. * 04131 * * 04132 * This library is distributed in the hope that it will be useful, * 04133 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 04134 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 04135 * Lesser General Public License for more details. * 04136 * * 04137 * You should have received a copy of the GNU Lesser General Public * 04138 * License along with this library; if not, write to the Free Software * 04139 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 04140 * MA 02111-1307 USA * 04141 * * 04142 ***************************************************************************/ 04143 04144 04145 #ifndef AB_TRANSACTION_LIMITS_LIST1_H 04146 #define AB_TRANSACTION_LIMITS_LIST1_H 04147 04148 #ifdef __cplusplus 04149 extern "C" { 04150 #endif 04151 04153 typedef struct AB_TRANSACTION_LIMITS_LIST_ELEMENT { 04154 uint32_t id; 04155 AB_TRANSACTION_LIMITS *nextObject; 04156 } AB_TRANSACTION_LIMITS_LIST__ELEMENT; 04157 04164 typedef struct AB_TRANSACTION_LIMITS_LIST AB_TRANSACTION_LIMITS_LIST; 04165 04169 typedef int GWENHYWFAR_CB (*AB_TRANSACTION_LIMITS_LIST_SORT_FN)(const AB_TRANSACTION_LIMITS *a, const AB_TRANSACTION_LIMITS *b, int ascending); 04170 04171 04173 struct AB_TRANSACTION_LIMITS_LIST { 04174 AB_TRANSACTION_LIMITS *first; 04175 uint32_t count; 04176 uint32_t id; 04177 } AB_TRANSACTION_LIMITS_LIST; 04178 04183 void AB_TransactionLimits_List_AddList(AB_TRANSACTION_LIMITS_LIST *dst, AB_TRANSACTION_LIMITS_LIST *l); 04184 04188 void AB_TransactionLimits_List_Add(AB_TRANSACTION_LIMITS *element, AB_TRANSACTION_LIMITS_LIST *list); 04189 04194 void AB_TransactionLimits_List_Insert(AB_TRANSACTION_LIMITS *element, AB_TRANSACTION_LIMITS_LIST *list); 04195 04202 void AB_TransactionLimits_List_Del(AB_TRANSACTION_LIMITS *element); 04203 04207 AB_TRANSACTION_LIMITS* AB_TransactionLimits_List_First(const AB_TRANSACTION_LIMITS_LIST *l); 04208 04212 AB_TRANSACTION_LIMITS* AB_TransactionLimits_List_Last(const AB_TRANSACTION_LIMITS_LIST *l); 04213 04218 void AB_TransactionLimits_List_Clear(AB_TRANSACTION_LIMITS_LIST *l); 04219 04223 AB_TRANSACTION_LIMITS_LIST* AB_TransactionLimits_List_new(); 04224 04228 void AB_TransactionLimits_List_free(AB_TRANSACTION_LIMITS_LIST *l); 04229 04233 AB_TRANSACTION_LIMITS* AB_TransactionLimits_List_Next(const AB_TRANSACTION_LIMITS *element); 04234 04238 AB_TRANSACTION_LIMITS* AB_TransactionLimits_List_Previous(const AB_TRANSACTION_LIMITS *element); 04239 04243 uint32_t AB_TransactionLimits_List_GetCount(const AB_TRANSACTION_LIMITS_LIST *l); 04244 04248 AB_TRANSACTION_LIMITS_LIST_SORT_FN AB_TransactionLimits_List_SetSortFn(AB_TRANSACTION_LIMITS_LIST *l, AB_TRANSACTION_LIMITS_LIST_SORT_FN fn); 04249 04255 void AB_TransactionLimits_List_Sort(AB_TRANSACTION_LIMITS_LIST *l, int ascending); 04256 04257 04258 #ifdef __cplusplus 04259 } 04260 #endif 04261 04262 04263 #endif 04264 04265 04266 04267 /*************************************************************************** 04268 $RCSfile$ 04269 ------------------- 04270 cvs : $Id$ 04271 begin : Sat Jun 28 2003 04272 copyright : (C) 2003 by Martin Preuss 04273 email : martin@libchipcard.de 04274 04275 *************************************************************************** 04276 * * 04277 * This library is free software; you can redistribute it and/or * 04278 * modify it under the terms of the GNU Lesser General Public * 04279 * License as published by the Free Software Foundation; either * 04280 * version 2.1 of the License, or (at your option) any later version. * 04281 * * 04282 * This library is distributed in the hope that it will be useful, * 04283 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 04284 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 04285 * Lesser General Public License for more details. * 04286 * * 04287 * You should have received a copy of the GNU Lesser General Public * 04288 * License along with this library; if not, write to the Free Software * 04289 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 04290 * MA 02111-1307 USA * 04291 * * 04292 ***************************************************************************/ 04293 04294 04295 #ifndef AB_SECURITY_LIST2_H 04296 #define AB_SECURITY_LIST2_H 04297 04298 04299 #ifdef __cplusplus 04300 extern "C" { 04301 #endif 04302 04309 typedef struct AB_SECURITY_LIST2 AB_SECURITY_LIST2; 04310 04314 typedef struct AB_SECURITY_LIST2_ITERATOR AB_SECURITY_LIST2_ITERATOR; 04315 04319 typedef AB_SECURITY* (AB_SECURITY_LIST2_FOREACH)(AB_SECURITY *element, 04320 void *user_data); 04321 04325 AB_SECURITY_LIST2 *AB_Security_List2_new(); 04326 04330 void AB_Security_List2_free(AB_SECURITY_LIST2 *l); 04331 04335 void AB_Security_List2_Dump(AB_SECURITY_LIST2 *l, FILE *f, unsigned int indent); 04336 04340 void AB_Security_List2_PushBack(AB_SECURITY_LIST2 *l, AB_SECURITY *p); 04341 04346 void AB_Security_List2_PushFront(AB_SECURITY_LIST2 *l, AB_SECURITY *p); 04347 04352 AB_SECURITY *AB_Security_List2_GetFront(AB_SECURITY_LIST2 *l); 04353 04358 AB_SECURITY *AB_Security_List2_GetBack(AB_SECURITY_LIST2 *l); 04359 04364 void AB_Security_List2_Erase(AB_SECURITY_LIST2 *l, 04365 AB_SECURITY_LIST2_ITERATOR *it); 04366 04372 unsigned int AB_Security_List2_GetSize(AB_SECURITY_LIST2 *l); 04373 04378 void AB_Security_List2_PopBack(AB_SECURITY_LIST2 *l); 04379 04384 void AB_Security_List2_PopFront(AB_SECURITY_LIST2 *l); 04385 04389 void AB_Security_List2_Clear(AB_SECURITY_LIST2 *l); 04390 04394 AB_SECURITY_LIST2_ITERATOR *AB_Security_List2_First(AB_SECURITY_LIST2 *l); 04395 04399 AB_SECURITY_LIST2_ITERATOR *AB_Security_List2_Last(AB_SECURITY_LIST2 *l); 04400 04404 AB_SECURITY_LIST2_ITERATOR *AB_Security_List2Iterator_new(AB_SECURITY_LIST2 *l); 04405 04409 void AB_Security_List2Iterator_free(AB_SECURITY_LIST2_ITERATOR *li); 04410 04415 AB_SECURITY *AB_Security_List2Iterator_Previous(AB_SECURITY_LIST2_ITERATOR *li); 04416 04421 AB_SECURITY *AB_Security_List2Iterator_Next(AB_SECURITY_LIST2_ITERATOR *li); 04422 04427 AB_SECURITY *AB_Security_List2Iterator_Data(AB_SECURITY_LIST2_ITERATOR *li); 04428 04440 AB_SECURITY *AB_Security_List2_ForEach(AB_SECURITY_LIST2 *list, 04441 AB_SECURITY_LIST2_FOREACH func, 04442 void *user_data); 04443 04444 04445 typedef struct AB_SECURITY_CONSTLIST2 AB_SECURITY_CONSTLIST2; 04446 typedef struct AB_SECURITY_CONSTLIST2_ITERATOR AB_SECURITY_CONSTLIST2_ITERATOR; 04447 typedef const AB_SECURITY* 04448 (AB_SECURITY_CONSTLIST2_FOREACH)(const AB_SECURITY *element, 04449 void *user_data); 04450 04451 04452 AB_SECURITY_CONSTLIST2 *AB_Security_ConstList2_new(); 04453 04454 void AB_Security_ConstList2_free(AB_SECURITY_CONSTLIST2 *l); 04455 04456 void AB_Security_ConstList2_PushBack(AB_SECURITY_CONSTLIST2 *l, const AB_SECURITY *p); 04457 04458 void AB_Security_ConstList2_PushFront(AB_SECURITY_CONSTLIST2 *l, const AB_SECURITY *p); 04459 04460 const AB_SECURITY *AB_Security_ConstList2_GetFront(AB_SECURITY_CONSTLIST2 *l); 04461 04462 const AB_SECURITY *AB_Security_ConstList2_GetBack(AB_SECURITY_CONSTLIST2 *l); 04463 04464 unsigned int AB_Security_ConstList2_GetSize(AB_SECURITY_CONSTLIST2 *l); 04465 04466 void AB_Security_ConstList2_PopBack(AB_SECURITY_CONSTLIST2 *l); 04467 04468 void AB_Security_ConstList2_PopFront(AB_SECURITY_CONSTLIST2 *l); 04469 04470 void AB_Security_ConstList2_Clear(AB_SECURITY_CONSTLIST2 *l); 04471 04472 AB_SECURITY_CONSTLIST2_ITERATOR *AB_Security_ConstList2_First(AB_SECURITY_CONSTLIST2 *l); 04473 04474 AB_SECURITY_CONSTLIST2_ITERATOR *AB_Security_ConstList2_Last(AB_SECURITY_CONSTLIST2 *l); 04475 04476 AB_SECURITY_CONSTLIST2_ITERATOR *AB_Security_ConstList2Iterator_new(AB_SECURITY_CONSTLIST2 *l); 04477 04478 void AB_Security_ConstList2Iterator_free(AB_SECURITY_CONSTLIST2_ITERATOR *li); 04479 04480 const AB_SECURITY *AB_Security_ConstList2Iterator_Previous(AB_SECURITY_CONSTLIST2_ITERATOR *li); 04481 04482 const AB_SECURITY *AB_Security_ConstList2Iterator_Next(AB_SECURITY_CONSTLIST2_ITERATOR *li); 04483 04484 const AB_SECURITY *AB_Security_ConstList2Iterator_Data(AB_SECURITY_CONSTLIST2_ITERATOR *li); 04485 04497 const AB_SECURITY *AB_Security_ConstList2_ForEach(AB_SECURITY_CONSTLIST2 *list, 04498 AB_SECURITY_CONSTLIST2_FOREACH func, void *user_data); 04499 04500 04501 #ifdef __cplusplus 04502 } 04503 #endif 04504 04505 04506 #endif /* AB_SECURITY_LIST_H */ 04507 04508 04509 04510 /*************************************************************************** 04511 $RCSfile$ 04512 ------------------- 04513 cvs : $Id$ 04514 begin : Sat Jun 28 2003 04515 copyright : (C) 2003 by Martin Preuss 04516 email : martin@libchipcard.de 04517 04518 *************************************************************************** 04519 * * 04520 * This library is free software; you can redistribute it and/or * 04521 * modify it under the terms of the GNU Lesser General Public * 04522 * License as published by the Free Software Foundation; either * 04523 * version 2.1 of the License, or (at your option) any later version. * 04524 * * 04525 * This library is distributed in the hope that it will be useful, * 04526 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 04527 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 04528 * Lesser General Public License for more details. * 04529 * * 04530 * You should have received a copy of the GNU Lesser General Public * 04531 * License along with this library; if not, write to the Free Software * 04532 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 04533 * MA 02111-1307 USA * 04534 * * 04535 ***************************************************************************/ 04536 04537 04538 #ifndef AB_SECURITY_LIST1_H 04539 #define AB_SECURITY_LIST1_H 04540 04541 #ifdef __cplusplus 04542 extern "C" { 04543 #endif 04544 04546 typedef struct AB_SECURITY_LIST_ELEMENT { 04547 uint32_t id; 04548 AB_SECURITY *nextObject; 04549 } AB_SECURITY_LIST__ELEMENT; 04550 04557 typedef struct AB_SECURITY_LIST AB_SECURITY_LIST; 04558 04562 typedef int GWENHYWFAR_CB (*AB_SECURITY_LIST_SORT_FN)(const AB_SECURITY *a, const AB_SECURITY *b, int ascending); 04563 04564 04566 struct AB_SECURITY_LIST { 04567 AB_SECURITY *first; 04568 uint32_t count; 04569 uint32_t id; 04570 } AB_SECURITY_LIST; 04571 04576 void AB_Security_List_AddList(AB_SECURITY_LIST *dst, AB_SECURITY_LIST *l); 04577 04581 void AB_Security_List_Add(AB_SECURITY *element, AB_SECURITY_LIST *list); 04582 04587 void AB_Security_List_Insert(AB_SECURITY *element, AB_SECURITY_LIST *list); 04588 04595 void AB_Security_List_Del(AB_SECURITY *element); 04596 04600 AB_SECURITY* AB_Security_List_First(const AB_SECURITY_LIST *l); 04601 04605 AB_SECURITY* AB_Security_List_Last(const AB_SECURITY_LIST *l); 04606 04611 void AB_Security_List_Clear(AB_SECURITY_LIST *l); 04612 04616 AB_SECURITY_LIST* AB_Security_List_new(); 04617 04621 void AB_Security_List_free(AB_SECURITY_LIST *l); 04622 04626 AB_SECURITY* AB_Security_List_Next(const AB_SECURITY *element); 04627 04631 AB_SECURITY* AB_Security_List_Previous(const AB_SECURITY *element); 04632 04636 uint32_t AB_Security_List_GetCount(const AB_SECURITY_LIST *l); 04637 04641 AB_SECURITY_LIST_SORT_FN AB_Security_List_SetSortFn(AB_SECURITY_LIST *l, AB_SECURITY_LIST_SORT_FN fn); 04642 04648 void AB_Security_List_Sort(AB_SECURITY_LIST *l, int ascending); 04649 04650 04651 #ifdef __cplusplus 04652 } 04653 #endif 04654 04655 04656 #endif 04657 04658 04659 04660 /*************************************************************************** 04661 $RCSfile$ 04662 ------------------- 04663 cvs : $Id$ 04664 begin : Sat Jun 28 2003 04665 copyright : (C) 2003 by Martin Preuss 04666 email : martin@libchipcard.de 04667 04668 *************************************************************************** 04669 * * 04670 * This library is free software; you can redistribute it and/or * 04671 * modify it under the terms of the GNU Lesser General Public * 04672 * License as published by the Free Software Foundation; either * 04673 * version 2.1 of the License, or (at your option) any later version. * 04674 * * 04675 * This library is distributed in the hope that it will be useful, * 04676 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 04677 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 04678 * Lesser General Public License for more details. * 04679 * * 04680 * You should have received a copy of the GNU Lesser General Public * 04681 * License along with this library; if not, write to the Free Software * 04682 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 04683 * MA 02111-1307 USA * 04684 * * 04685 ***************************************************************************/ 04686 04687 04688 #ifndef AB_ACCOUNT_LIST1_H 04689 #define AB_ACCOUNT_LIST1_H 04690 04691 #ifdef __cplusplus 04692 extern "C" { 04693 #endif 04694 04696 typedef struct AB_ACCOUNT_LIST_ELEMENT { 04697 uint32_t id; 04698 AB_ACCOUNT *nextObject; 04699 } AB_ACCOUNT_LIST__ELEMENT; 04700 04707 typedef struct AB_ACCOUNT_LIST AB_ACCOUNT_LIST; 04708 04712 typedef int GWENHYWFAR_CB (*AB_ACCOUNT_LIST_SORT_FN)(const AB_ACCOUNT *a, const AB_ACCOUNT *b, int ascending); 04713 04714 04716 struct AB_ACCOUNT_LIST { 04717 AB_ACCOUNT *first; 04718 uint32_t count; 04719 uint32_t id; 04720 } AB_ACCOUNT_LIST; 04721 04726 void AB_Account_List_AddList(AB_ACCOUNT_LIST *dst, AB_ACCOUNT_LIST *l); 04727 04731 void AB_Account_List_Add(AB_ACCOUNT *element, AB_ACCOUNT_LIST *list); 04732 04737 void AB_Account_List_Insert(AB_ACCOUNT *element, AB_ACCOUNT_LIST *list); 04738 04745 void AB_Account_List_Del(AB_ACCOUNT *element); 04746 04750 AB_ACCOUNT* AB_Account_List_First(const AB_ACCOUNT_LIST *l); 04751 04755 AB_ACCOUNT* AB_Account_List_Last(const AB_ACCOUNT_LIST *l); 04756 04761 void AB_Account_List_Clear(AB_ACCOUNT_LIST *l); 04762 04766 AB_ACCOUNT_LIST* AB_Account_List_new(); 04767 04771 void AB_Account_List_free(AB_ACCOUNT_LIST *l); 04772 04776 AB_ACCOUNT* AB_Account_List_Next(const AB_ACCOUNT *element); 04777 04781 AB_ACCOUNT* AB_Account_List_Previous(const AB_ACCOUNT *element); 04782 04786 uint32_t AB_Account_List_GetCount(const AB_ACCOUNT_LIST *l); 04787 04791 AB_ACCOUNT_LIST_SORT_FN AB_Account_List_SetSortFn(AB_ACCOUNT_LIST *l, AB_ACCOUNT_LIST_SORT_FN fn); 04792 04798 void AB_Account_List_Sort(AB_ACCOUNT_LIST *l, int ascending); 04799 04800 04801 #ifdef __cplusplus 04802 } 04803 #endif 04804 04805 04806 #endif 04807 04808 04809 04810 /*************************************************************************** 04811 $RCSfile$ 04812 ------------------- 04813 cvs : $Id$ 04814 begin : Sat Jun 28 2003 04815 copyright : (C) 2003 by Martin Preuss 04816 email : martin@libchipcard.de 04817 04818 *************************************************************************** 04819 * * 04820 * This library is free software; you can redistribute it and/or * 04821 * modify it under the terms of the GNU Lesser General Public * 04822 * License as published by the Free Software Foundation; either * 04823 * version 2.1 of the License, or (at your option) any later version. * 04824 * * 04825 * This library is distributed in the hope that it will be useful, * 04826 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 04827 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 04828 * Lesser General Public License for more details. * 04829 * * 04830 * You should have received a copy of the GNU Lesser General Public * 04831 * License along with this library; if not, write to the Free Software * 04832 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 04833 * MA 02111-1307 USA * 04834 * * 04835 ***************************************************************************/ 04836 04837 04838 #ifndef AB_EUTRANSFER_INFO_LIST2_H 04839 #define AB_EUTRANSFER_INFO_LIST2_H 04840 04841 04842 #ifdef __cplusplus 04843 extern "C" { 04844 #endif 04845 04852 typedef struct AB_EUTRANSFER_INFO_LIST2 AB_EUTRANSFER_INFO_LIST2; 04853 04857 typedef struct AB_EUTRANSFER_INFO_LIST2_ITERATOR AB_EUTRANSFER_INFO_LIST2_ITERATOR; 04858 04862 typedef AB_EUTRANSFER_INFO* (AB_EUTRANSFER_INFO_LIST2_FOREACH)(AB_EUTRANSFER_INFO *element, 04863 void *user_data); 04864 04868 AB_EUTRANSFER_INFO_LIST2 *AB_EuTransferInfo_List2_new(); 04869 04873 void AB_EuTransferInfo_List2_free(AB_EUTRANSFER_INFO_LIST2 *l); 04874 04878 void AB_EuTransferInfo_List2_Dump(AB_EUTRANSFER_INFO_LIST2 *l, FILE *f, unsigned int indent); 04879 04883 void AB_EuTransferInfo_List2_PushBack(AB_EUTRANSFER_INFO_LIST2 *l, AB_EUTRANSFER_INFO *p); 04884 04889 void AB_EuTransferInfo_List2_PushFront(AB_EUTRANSFER_INFO_LIST2 *l, AB_EUTRANSFER_INFO *p); 04890 04895 AB_EUTRANSFER_INFO *AB_EuTransferInfo_List2_GetFront(AB_EUTRANSFER_INFO_LIST2 *l); 04896 04901 AB_EUTRANSFER_INFO *AB_EuTransferInfo_List2_GetBack(AB_EUTRANSFER_INFO_LIST2 *l); 04902 04907 void AB_EuTransferInfo_List2_Erase(AB_EUTRANSFER_INFO_LIST2 *l, 04908 AB_EUTRANSFER_INFO_LIST2_ITERATOR *it); 04909 04915 unsigned int AB_EuTransferInfo_List2_GetSize(AB_EUTRANSFER_INFO_LIST2 *l); 04916 04921 void AB_EuTransferInfo_List2_PopBack(AB_EUTRANSFER_INFO_LIST2 *l); 04922 04927 void AB_EuTransferInfo_List2_PopFront(AB_EUTRANSFER_INFO_LIST2 *l); 04928 04932 void AB_EuTransferInfo_List2_Clear(AB_EUTRANSFER_INFO_LIST2 *l); 04933 04937 AB_EUTRANSFER_INFO_LIST2_ITERATOR *AB_EuTransferInfo_List2_First(AB_EUTRANSFER_INFO_LIST2 *l); 04938 04942 AB_EUTRANSFER_INFO_LIST2_ITERATOR *AB_EuTransferInfo_List2_Last(AB_EUTRANSFER_INFO_LIST2 *l); 04943 04947 AB_EUTRANSFER_INFO_LIST2_ITERATOR *AB_EuTransferInfo_List2Iterator_new(AB_EUTRANSFER_INFO_LIST2 *l); 04948 04952 void AB_EuTransferInfo_List2Iterator_free(AB_EUTRANSFER_INFO_LIST2_ITERATOR *li); 04953 04958 AB_EUTRANSFER_INFO *AB_EuTransferInfo_List2Iterator_Previous(AB_EUTRANSFER_INFO_LIST2_ITERATOR *li); 04959 04964 AB_EUTRANSFER_INFO *AB_EuTransferInfo_List2Iterator_Next(AB_EUTRANSFER_INFO_LIST2_ITERATOR *li); 04965 04970 AB_EUTRANSFER_INFO *AB_EuTransferInfo_List2Iterator_Data(AB_EUTRANSFER_INFO_LIST2_ITERATOR *li); 04971 04983 AB_EUTRANSFER_INFO *AB_EuTransferInfo_List2_ForEach(AB_EUTRANSFER_INFO_LIST2 *list, 04984 AB_EUTRANSFER_INFO_LIST2_FOREACH func, 04985 void *user_data); 04986 04987 04988 typedef struct AB_EUTRANSFER_INFO_CONSTLIST2 AB_EUTRANSFER_INFO_CONSTLIST2; 04989 typedef struct AB_EUTRANSFER_INFO_CONSTLIST2_ITERATOR AB_EUTRANSFER_INFO_CONSTLIST2_ITERATOR; 04990 typedef const AB_EUTRANSFER_INFO* 04991 (AB_EUTRANSFER_INFO_CONSTLIST2_FOREACH)(const AB_EUTRANSFER_INFO *element, 04992 void *user_data); 04993 04994 04995 AB_EUTRANSFER_INFO_CONSTLIST2 *AB_EuTransferInfo_ConstList2_new(); 04996 04997 void AB_EuTransferInfo_ConstList2_free(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 04998 04999 void AB_EuTransferInfo_ConstList2_PushBack(AB_EUTRANSFER_INFO_CONSTLIST2 *l, const AB_EUTRANSFER_INFO *p); 05000 05001 void AB_EuTransferInfo_ConstList2_PushFront(AB_EUTRANSFER_INFO_CONSTLIST2 *l, const AB_EUTRANSFER_INFO *p); 05002 05003 const AB_EUTRANSFER_INFO *AB_EuTransferInfo_ConstList2_GetFront(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 05004 05005 const AB_EUTRANSFER_INFO *AB_EuTransferInfo_ConstList2_GetBack(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 05006 05007 unsigned int AB_EuTransferInfo_ConstList2_GetSize(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 05008 05009 void AB_EuTransferInfo_ConstList2_PopBack(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 05010 05011 void AB_EuTransferInfo_ConstList2_PopFront(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 05012 05013 void AB_EuTransferInfo_ConstList2_Clear(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 05014 05015 AB_EUTRANSFER_INFO_CONSTLIST2_ITERATOR *AB_EuTransferInfo_ConstList2_First(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 05016 05017 AB_EUTRANSFER_INFO_CONSTLIST2_ITERATOR *AB_EuTransferInfo_ConstList2_Last(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 05018 05019 AB_EUTRANSFER_INFO_CONSTLIST2_ITERATOR *AB_EuTransferInfo_ConstList2Iterator_new(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 05020 05021 void AB_EuTransferInfo_ConstList2Iterator_free(AB_EUTRANSFER_INFO_CONSTLIST2_ITERATOR *li); 05022 05023 const AB_EUTRANSFER_INFO *AB_EuTransferInfo_ConstList2Iterator_Previous(AB_EUTRANSFER_INFO_CONSTLIST2_ITERATOR *li); 05024 05025 const AB_EUTRANSFER_INFO *AB_EuTransferInfo_ConstList2Iterator_Next(AB_EUTRANSFER_INFO_CONSTLIST2_ITERATOR *li); 05026 05027 const AB_EUTRANSFER_INFO *AB_EuTransferInfo_ConstList2Iterator_Data(AB_EUTRANSFER_INFO_CONSTLIST2_ITERATOR *li); 05028 05040 const AB_EUTRANSFER_INFO *AB_EuTransferInfo_ConstList2_ForEach(AB_EUTRANSFER_INFO_CONSTLIST2 *list, 05041 AB_EUTRANSFER_INFO_CONSTLIST2_FOREACH func, void *user_data); 05042 05043 05044 #ifdef __cplusplus 05045 } 05046 #endif 05047 05048 05049 #endif /* AB_EUTRANSFER_INFO_LIST_H */ 05050 05051 05052 05053 /*************************************************************************** 05054 $RCSfile$ 05055 ------------------- 05056 cvs : $Id$ 05057 begin : Sat Jun 28 2003 05058 copyright : (C) 2003 by Martin Preuss 05059 email : martin@libchipcard.de 05060 05061 *************************************************************************** 05062 * * 05063 * This library is free software; you can redistribute it and/or * 05064 * modify it under the terms of the GNU Lesser General Public * 05065 * License as published by the Free Software Foundation; either * 05066 * version 2.1 of the License, or (at your option) any later version. * 05067 * * 05068 * This library is distributed in the hope that it will be useful, * 05069 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 05070 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 05071 * Lesser General Public License for more details. * 05072 * * 05073 * You should have received a copy of the GNU Lesser General Public * 05074 * License along with this library; if not, write to the Free Software * 05075 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 05076 * MA 02111-1307 USA * 05077 * * 05078 ***************************************************************************/ 05079 05080 05081 #ifndef AB_EUTRANSFER_INFO_LIST1_H 05082 #define AB_EUTRANSFER_INFO_LIST1_H 05083 05084 #ifdef __cplusplus 05085 extern "C" { 05086 #endif 05087 05089 typedef struct AB_EUTRANSFER_INFO_LIST_ELEMENT { 05090 uint32_t id; 05091 AB_EUTRANSFER_INFO *nextObject; 05092 } AB_EUTRANSFER_INFO_LIST__ELEMENT; 05093 05100 typedef struct AB_EUTRANSFER_INFO_LIST AB_EUTRANSFER_INFO_LIST; 05101 05105 typedef int GWENHYWFAR_CB (*AB_EUTRANSFER_INFO_LIST_SORT_FN)(const AB_EUTRANSFER_INFO *a, const AB_EUTRANSFER_INFO *b, int ascending); 05106 05107 05109 struct AB_EUTRANSFER_INFO_LIST { 05110 AB_EUTRANSFER_INFO *first; 05111 uint32_t count; 05112 uint32_t id; 05113 } AB_EUTRANSFER_INFO_LIST; 05114 05119 void AB_EuTransferInfo_List_AddList(AB_EUTRANSFER_INFO_LIST *dst, AB_EUTRANSFER_INFO_LIST *l); 05120 05124 void AB_EuTransferInfo_List_Add(AB_EUTRANSFER_INFO *element, AB_EUTRANSFER_INFO_LIST *list); 05125 05130 void AB_EuTransferInfo_List_Insert(AB_EUTRANSFER_INFO *element, AB_EUTRANSFER_INFO_LIST *list); 05131 05138 void AB_EuTransferInfo_List_Del(AB_EUTRANSFER_INFO *element); 05139 05143 AB_EUTRANSFER_INFO* AB_EuTransferInfo_List_First(const AB_EUTRANSFER_INFO_LIST *l); 05144 05148 AB_EUTRANSFER_INFO* AB_EuTransferInfo_List_Last(const AB_EUTRANSFER_INFO_LIST *l); 05149 05154 void AB_EuTransferInfo_List_Clear(AB_EUTRANSFER_INFO_LIST *l); 05155 05159 AB_EUTRANSFER_INFO_LIST* AB_EuTransferInfo_List_new(); 05160 05164 void AB_EuTransferInfo_List_free(AB_EUTRANSFER_INFO_LIST *l); 05165 05169 AB_EUTRANSFER_INFO* AB_EuTransferInfo_List_Next(const AB_EUTRANSFER_INFO *element); 05170 05174 AB_EUTRANSFER_INFO* AB_EuTransferInfo_List_Previous(const AB_EUTRANSFER_INFO *element); 05175 05179 uint32_t AB_EuTransferInfo_List_GetCount(const AB_EUTRANSFER_INFO_LIST *l); 05180 05184 AB_EUTRANSFER_INFO_LIST_SORT_FN AB_EuTransferInfo_List_SetSortFn(AB_EUTRANSFER_INFO_LIST *l, AB_EUTRANSFER_INFO_LIST_SORT_FN fn); 05185 05191 void AB_EuTransferInfo_List_Sort(AB_EUTRANSFER_INFO_LIST *l, int ascending); 05192 05193 05194 #ifdef __cplusplus 05195 } 05196 #endif 05197 05198 05199 #endif 05200 05201 05202 05203 /*************************************************************************** 05204 $RCSfile$ 05205 ------------------- 05206 cvs : $Id$ 05207 begin : Sat Jun 28 2003 05208 copyright : (C) 2003 by Martin Preuss 05209 email : martin@libchipcard.de 05210 05211 *************************************************************************** 05212 * * 05213 * This library is free software; you can redistribute it and/or * 05214 * modify it under the terms of the GNU Lesser General Public * 05215 * License as published by the Free Software Foundation; either * 05216 * version 2.1 of the License, or (at your option) any later version. * 05217 * * 05218 * This library is distributed in the hope that it will be useful, * 05219 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 05220 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 05221 * Lesser General Public License for more details. * 05222 * * 05223 * You should have received a copy of the GNU Lesser General Public * 05224 * License along with this library; if not, write to the Free Software * 05225 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 05226 * MA 02111-1307 USA * 05227 * * 05228 ***************************************************************************/ 05229 05230 05231 #ifndef AB_USER_LIST2_H 05232 #define AB_USER_LIST2_H 05233 05234 05235 #ifdef __cplusplus 05236 extern "C" { 05237 #endif 05238 05245 typedef struct AB_USER_LIST2 AB_USER_LIST2; 05246 05250 typedef struct AB_USER_LIST2_ITERATOR AB_USER_LIST2_ITERATOR; 05251 05255 typedef AB_USER* (AB_USER_LIST2_FOREACH)(AB_USER *element, 05256 void *user_data); 05257 05261 AB_USER_LIST2 *AB_User_List2_new(); 05262 05266 void AB_User_List2_free(AB_USER_LIST2 *l); 05267 05271 void AB_User_List2_Dump(AB_USER_LIST2 *l, FILE *f, unsigned int indent); 05272 05276 void AB_User_List2_PushBack(AB_USER_LIST2 *l, AB_USER *p); 05277 05282 void AB_User_List2_PushFront(AB_USER_LIST2 *l, AB_USER *p); 05283 05288 AB_USER *AB_User_List2_GetFront(AB_USER_LIST2 *l); 05289 05294 AB_USER *AB_User_List2_GetBack(AB_USER_LIST2 *l); 05295 05300 void AB_User_List2_Erase(AB_USER_LIST2 *l, 05301 AB_USER_LIST2_ITERATOR *it); 05302 05308 unsigned int AB_User_List2_GetSize(AB_USER_LIST2 *l); 05309 05314 void AB_User_List2_PopBack(AB_USER_LIST2 *l); 05315 05320 void AB_User_List2_PopFront(AB_USER_LIST2 *l); 05321 05325 void AB_User_List2_Clear(AB_USER_LIST2 *l); 05326 05330 AB_USER_LIST2_ITERATOR *AB_User_List2_First(AB_USER_LIST2 *l); 05331 05335 AB_USER_LIST2_ITERATOR *AB_User_List2_Last(AB_USER_LIST2 *l); 05336 05340 AB_USER_LIST2_ITERATOR *AB_User_List2Iterator_new(AB_USER_LIST2 *l); 05341 05345 void AB_User_List2Iterator_free(AB_USER_LIST2_ITERATOR *li); 05346 05351 AB_USER *AB_User_List2Iterator_Previous(AB_USER_LIST2_ITERATOR *li); 05352 05357 AB_USER *AB_User_List2Iterator_Next(AB_USER_LIST2_ITERATOR *li); 05358 05363 AB_USER *AB_User_List2Iterator_Data(AB_USER_LIST2_ITERATOR *li); 05364 05376 AB_USER *AB_User_List2_ForEach(AB_USER_LIST2 *list, 05377 AB_USER_LIST2_FOREACH func, 05378 void *user_data); 05379 05380 05381 typedef struct AB_USER_CONSTLIST2 AB_USER_CONSTLIST2; 05382 typedef struct AB_USER_CONSTLIST2_ITERATOR AB_USER_CONSTLIST2_ITERATOR; 05383 typedef const AB_USER* 05384 (AB_USER_CONSTLIST2_FOREACH)(const AB_USER *element, 05385 void *user_data); 05386 05387 05388 AB_USER_CONSTLIST2 *AB_User_ConstList2_new(); 05389 05390 void AB_User_ConstList2_free(AB_USER_CONSTLIST2 *l); 05391 05392 void AB_User_ConstList2_PushBack(AB_USER_CONSTLIST2 *l, const AB_USER *p); 05393 05394 void AB_User_ConstList2_PushFront(AB_USER_CONSTLIST2 *l, const AB_USER *p); 05395 05396 const AB_USER *AB_User_ConstList2_GetFront(AB_USER_CONSTLIST2 *l); 05397 05398 const AB_USER *AB_User_ConstList2_GetBack(AB_USER_CONSTLIST2 *l); 05399 05400 unsigned int AB_User_ConstList2_GetSize(AB_USER_CONSTLIST2 *l); 05401 05402 void AB_User_ConstList2_PopBack(AB_USER_CONSTLIST2 *l); 05403 05404 void AB_User_ConstList2_PopFront(AB_USER_CONSTLIST2 *l); 05405 05406 void AB_User_ConstList2_Clear(AB_USER_CONSTLIST2 *l); 05407 05408 AB_USER_CONSTLIST2_ITERATOR *AB_User_ConstList2_First(AB_USER_CONSTLIST2 *l); 05409 05410 AB_USER_CONSTLIST2_ITERATOR *AB_User_ConstList2_Last(AB_USER_CONSTLIST2 *l); 05411 05412 AB_USER_CONSTLIST2_ITERATOR *AB_User_ConstList2Iterator_new(AB_USER_CONSTLIST2 *l); 05413 05414 void AB_User_ConstList2Iterator_free(AB_USER_CONSTLIST2_ITERATOR *li); 05415 05416 const AB_USER *AB_User_ConstList2Iterator_Previous(AB_USER_CONSTLIST2_ITERATOR *li); 05417 05418 const AB_USER *AB_User_ConstList2Iterator_Next(AB_USER_CONSTLIST2_ITERATOR *li); 05419 05420 const AB_USER *AB_User_ConstList2Iterator_Data(AB_USER_CONSTLIST2_ITERATOR *li); 05421 05433 const AB_USER *AB_User_ConstList2_ForEach(AB_USER_CONSTLIST2 *list, 05434 AB_USER_CONSTLIST2_FOREACH func, void *user_data); 05435 05436 05437 #ifdef __cplusplus 05438 } 05439 #endif 05440 05441 05442 #endif /* AB_USER_LIST_H */ 05443 05444 05445 05446 /*************************************************************************** 05447 $RCSfile$ 05448 ------------------- 05449 cvs : $Id$ 05450 begin : Sat Jun 28 2003 05451 copyright : (C) 2003 by Martin Preuss 05452 email : martin@libchipcard.de 05453 05454 *************************************************************************** 05455 * * 05456 * This library is free software; you can redistribute it and/or * 05457 * modify it under the terms of the GNU Lesser General Public * 05458 * License as published by the Free Software Foundation; either * 05459 * version 2.1 of the License, or (at your option) any later version. * 05460 * * 05461 * This library is distributed in the hope that it will be useful, * 05462 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 05463 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 05464 * Lesser General Public License for more details. * 05465 * * 05466 * You should have received a copy of the GNU Lesser General Public * 05467 * License along with this library; if not, write to the Free Software * 05468 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 05469 * MA 02111-1307 USA * 05470 * * 05471 ***************************************************************************/ 05472 05473 05474 #ifndef AB_USERQUEUE_LIST1_H 05475 #define AB_USERQUEUE_LIST1_H 05476 05477 #ifdef __cplusplus 05478 extern "C" { 05479 #endif 05480 05482 typedef struct AB_USERQUEUE_LIST_ELEMENT { 05483 uint32_t id; 05484 AB_USERQUEUE *nextObject; 05485 } AB_USERQUEUE_LIST__ELEMENT; 05486 05493 typedef struct AB_USERQUEUE_LIST AB_USERQUEUE_LIST; 05494 05498 typedef int GWENHYWFAR_CB (*AB_USERQUEUE_LIST_SORT_FN)(const AB_USERQUEUE *a, const AB_USERQUEUE *b, int ascending); 05499 05500 05502 struct AB_USERQUEUE_LIST { 05503 AB_USERQUEUE *first; 05504 uint32_t count; 05505 uint32_t id; 05506 } AB_USERQUEUE_LIST; 05507 05512 void AB_UserQueue_List_AddList(AB_USERQUEUE_LIST *dst, AB_USERQUEUE_LIST *l); 05513 05517 void AB_UserQueue_List_Add(AB_USERQUEUE *element, AB_USERQUEUE_LIST *list); 05518 05523 void AB_UserQueue_List_Insert(AB_USERQUEUE *element, AB_USERQUEUE_LIST *list); 05524 05531 void AB_UserQueue_List_Del(AB_USERQUEUE *element); 05532 05536 AB_USERQUEUE* AB_UserQueue_List_First(const AB_USERQUEUE_LIST *l); 05537 05541 AB_USERQUEUE* AB_UserQueue_List_Last(const AB_USERQUEUE_LIST *l); 05542 05547 void AB_UserQueue_List_Clear(AB_USERQUEUE_LIST *l); 05548 05552 AB_USERQUEUE_LIST* AB_UserQueue_List_new(); 05553 05557 void AB_UserQueue_List_free(AB_USERQUEUE_LIST *l); 05558 05562 AB_USERQUEUE* AB_UserQueue_List_Next(const AB_USERQUEUE *element); 05563 05567 AB_USERQUEUE* AB_UserQueue_List_Previous(const AB_USERQUEUE *element); 05568 05572 uint32_t AB_UserQueue_List_GetCount(const AB_USERQUEUE_LIST *l); 05573 05577 AB_USERQUEUE_LIST_SORT_FN AB_UserQueue_List_SetSortFn(AB_USERQUEUE_LIST *l, AB_USERQUEUE_LIST_SORT_FN fn); 05578 05584 void AB_UserQueue_List_Sort(AB_USERQUEUE_LIST *l, int ascending); 05585 05586 05587 #ifdef __cplusplus 05588 } 05589 #endif 05590 05591 05592 #endif 05593 05594 05595 05596 /*************************************************************************** 05597 $RCSfile$ 05598 ------------------- 05599 cvs : $Id$ 05600 begin : Sat Jun 28 2003 05601 copyright : (C) 2003 by Martin Preuss 05602 email : martin@libchipcard.de 05603 05604 *************************************************************************** 05605 * * 05606 * This library is free software; you can redistribute it and/or * 05607 * modify it under the terms of the GNU Lesser General Public * 05608 * License as published by the Free Software Foundation; either * 05609 * version 2.1 of the License, or (at your option) any later version. * 05610 * * 05611 * This library is distributed in the hope that it will be useful, * 05612 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 05613 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 05614 * Lesser General Public License for more details. * 05615 * * 05616 * You should have received a copy of the GNU Lesser General Public * 05617 * License along with this library; if not, write to the Free Software * 05618 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 05619 * MA 02111-1307 USA * 05620 * * 05621 ***************************************************************************/ 05622 05623 05624 #ifndef AB_MESSAGE_LIST2_H 05625 #define AB_MESSAGE_LIST2_H 05626 05627 05628 #ifdef __cplusplus 05629 extern "C" { 05630 #endif 05631 05638 typedef struct AB_MESSAGE_LIST2 AB_MESSAGE_LIST2; 05639 05643 typedef struct AB_MESSAGE_LIST2_ITERATOR AB_MESSAGE_LIST2_ITERATOR; 05644 05648 typedef AB_MESSAGE* (AB_MESSAGE_LIST2_FOREACH)(AB_MESSAGE *element, 05649 void *user_data); 05650 05654 AB_MESSAGE_LIST2 *AB_Message_List2_new(); 05655 05659 void AB_Message_List2_free(AB_MESSAGE_LIST2 *l); 05660 05664 void AB_Message_List2_Dump(AB_MESSAGE_LIST2 *l, FILE *f, unsigned int indent); 05665 05669 void AB_Message_List2_PushBack(AB_MESSAGE_LIST2 *l, AB_MESSAGE *p); 05670 05675 void AB_Message_List2_PushFront(AB_MESSAGE_LIST2 *l, AB_MESSAGE *p); 05676 05681 AB_MESSAGE *AB_Message_List2_GetFront(AB_MESSAGE_LIST2 *l); 05682 05687 AB_MESSAGE *AB_Message_List2_GetBack(AB_MESSAGE_LIST2 *l); 05688 05693 void AB_Message_List2_Erase(AB_MESSAGE_LIST2 *l, 05694 AB_MESSAGE_LIST2_ITERATOR *it); 05695 05701 unsigned int AB_Message_List2_GetSize(AB_MESSAGE_LIST2 *l); 05702 05707 void AB_Message_List2_PopBack(AB_MESSAGE_LIST2 *l); 05708 05713 void AB_Message_List2_PopFront(AB_MESSAGE_LIST2 *l); 05714 05718 void AB_Message_List2_Clear(AB_MESSAGE_LIST2 *l); 05719 05723 AB_MESSAGE_LIST2_ITERATOR *AB_Message_List2_First(AB_MESSAGE_LIST2 *l); 05724 05728 AB_MESSAGE_LIST2_ITERATOR *AB_Message_List2_Last(AB_MESSAGE_LIST2 *l); 05729 05733 AB_MESSAGE_LIST2_ITERATOR *AB_Message_List2Iterator_new(AB_MESSAGE_LIST2 *l); 05734 05738 void AB_Message_List2Iterator_free(AB_MESSAGE_LIST2_ITERATOR *li); 05739 05744 AB_MESSAGE *AB_Message_List2Iterator_Previous(AB_MESSAGE_LIST2_ITERATOR *li); 05745 05750 AB_MESSAGE *AB_Message_List2Iterator_Next(AB_MESSAGE_LIST2_ITERATOR *li); 05751 05756 AB_MESSAGE *AB_Message_List2Iterator_Data(AB_MESSAGE_LIST2_ITERATOR *li); 05757 05769 AB_MESSAGE *AB_Message_List2_ForEach(AB_MESSAGE_LIST2 *list, 05770 AB_MESSAGE_LIST2_FOREACH func, 05771 void *user_data); 05772 05773 05774 typedef struct AB_MESSAGE_CONSTLIST2 AB_MESSAGE_CONSTLIST2; 05775 typedef struct AB_MESSAGE_CONSTLIST2_ITERATOR AB_MESSAGE_CONSTLIST2_ITERATOR; 05776 typedef const AB_MESSAGE* 05777 (AB_MESSAGE_CONSTLIST2_FOREACH)(const AB_MESSAGE *element, 05778 void *user_data); 05779 05780 05781 AB_MESSAGE_CONSTLIST2 *AB_Message_ConstList2_new(); 05782 05783 void AB_Message_ConstList2_free(AB_MESSAGE_CONSTLIST2 *l); 05784 05785 void AB_Message_ConstList2_PushBack(AB_MESSAGE_CONSTLIST2 *l, const AB_MESSAGE *p); 05786 05787 void AB_Message_ConstList2_PushFront(AB_MESSAGE_CONSTLIST2 *l, const AB_MESSAGE *p); 05788 05789 const AB_MESSAGE *AB_Message_ConstList2_GetFront(AB_MESSAGE_CONSTLIST2 *l); 05790 05791 const AB_MESSAGE *AB_Message_ConstList2_GetBack(AB_MESSAGE_CONSTLIST2 *l); 05792 05793 unsigned int AB_Message_ConstList2_GetSize(AB_MESSAGE_CONSTLIST2 *l); 05794 05795 void AB_Message_ConstList2_PopBack(AB_MESSAGE_CONSTLIST2 *l); 05796 05797 void AB_Message_ConstList2_PopFront(AB_MESSAGE_CONSTLIST2 *l); 05798 05799 void AB_Message_ConstList2_Clear(AB_MESSAGE_CONSTLIST2 *l); 05800 05801 AB_MESSAGE_CONSTLIST2_ITERATOR *AB_Message_ConstList2_First(AB_MESSAGE_CONSTLIST2 *l); 05802 05803 AB_MESSAGE_CONSTLIST2_ITERATOR *AB_Message_ConstList2_Last(AB_MESSAGE_CONSTLIST2 *l); 05804 05805 AB_MESSAGE_CONSTLIST2_ITERATOR *AB_Message_ConstList2Iterator_new(AB_MESSAGE_CONSTLIST2 *l); 05806 05807 void AB_Message_ConstList2Iterator_free(AB_MESSAGE_CONSTLIST2_ITERATOR *li); 05808 05809 const AB_MESSAGE *AB_Message_ConstList2Iterator_Previous(AB_MESSAGE_CONSTLIST2_ITERATOR *li); 05810 05811 const AB_MESSAGE *AB_Message_ConstList2Iterator_Next(AB_MESSAGE_CONSTLIST2_ITERATOR *li); 05812 05813 const AB_MESSAGE *AB_Message_ConstList2Iterator_Data(AB_MESSAGE_CONSTLIST2_ITERATOR *li); 05814 05826 const AB_MESSAGE *AB_Message_ConstList2_ForEach(AB_MESSAGE_CONSTLIST2 *list, 05827 AB_MESSAGE_CONSTLIST2_FOREACH func, void *user_data); 05828 05829 05830 #ifdef __cplusplus 05831 } 05832 #endif 05833 05834 05835 #endif /* AB_MESSAGE_LIST_H */ 05836 05837 05838 05839 /*************************************************************************** 05840 $RCSfile$ 05841 ------------------- 05842 cvs : $Id$ 05843 begin : Sat Jun 28 2003 05844 copyright : (C) 2003 by Martin Preuss 05845 email : martin@libchipcard.de 05846 05847 *************************************************************************** 05848 * * 05849 * This library is free software; you can redistribute it and/or * 05850 * modify it under the terms of the GNU Lesser General Public * 05851 * License as published by the Free Software Foundation; either * 05852 * version 2.1 of the License, or (at your option) any later version. * 05853 * * 05854 * This library is distributed in the hope that it will be useful, * 05855 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 05856 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 05857 * Lesser General Public License for more details. * 05858 * * 05859 * You should have received a copy of the GNU Lesser General Public * 05860 * License along with this library; if not, write to the Free Software * 05861 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 05862 * MA 02111-1307 USA * 05863 * * 05864 ***************************************************************************/ 05865 05866 05867 #ifndef AB_MESSAGE_LIST1_H 05868 #define AB_MESSAGE_LIST1_H 05869 05870 #ifdef __cplusplus 05871 extern "C" { 05872 #endif 05873 05875 typedef struct AB_MESSAGE_LIST_ELEMENT { 05876 uint32_t id; 05877 AB_MESSAGE *nextObject; 05878 } AB_MESSAGE_LIST__ELEMENT; 05879 05886 typedef struct AB_MESSAGE_LIST AB_MESSAGE_LIST; 05887 05891 typedef int GWENHYWFAR_CB (*AB_MESSAGE_LIST_SORT_FN)(const AB_MESSAGE *a, const AB_MESSAGE *b, int ascending); 05892 05893 05895 struct AB_MESSAGE_LIST { 05896 AB_MESSAGE *first; 05897 uint32_t count; 05898 uint32_t id; 05899 } AB_MESSAGE_LIST; 05900 05905 void AB_Message_List_AddList(AB_MESSAGE_LIST *dst, AB_MESSAGE_LIST *l); 05906 05910 void AB_Message_List_Add(AB_MESSAGE *element, AB_MESSAGE_LIST *list); 05911 05916 void AB_Message_List_Insert(AB_MESSAGE *element, AB_MESSAGE_LIST *list); 05917 05924 void AB_Message_List_Del(AB_MESSAGE *element); 05925 05929 AB_MESSAGE* AB_Message_List_First(const AB_MESSAGE_LIST *l); 05930 05934 AB_MESSAGE* AB_Message_List_Last(const AB_MESSAGE_LIST *l); 05935 05940 void AB_Message_List_Clear(AB_MESSAGE_LIST *l); 05941 05945 AB_MESSAGE_LIST* AB_Message_List_new(); 05946 05950 void AB_Message_List_free(AB_MESSAGE_LIST *l); 05951 05955 AB_MESSAGE* AB_Message_List_Next(const AB_MESSAGE *element); 05956 05960 AB_MESSAGE* AB_Message_List_Previous(const AB_MESSAGE *element); 05961 05965 uint32_t AB_Message_List_GetCount(const AB_MESSAGE_LIST *l); 05966 05970 AB_MESSAGE_LIST_SORT_FN AB_Message_List_SetSortFn(AB_MESSAGE_LIST *l, AB_MESSAGE_LIST_SORT_FN fn); 05971 05977 void AB_Message_List_Sort(AB_MESSAGE_LIST *l, int ascending); 05978 05979 05980 #ifdef __cplusplus 05981 } 05982 #endif 05983 05984 05985 #endif 05986 05987 05988 05989 /*************************************************************************** 05990 $RCSfile$ 05991 ------------------- 05992 cvs : $Id$ 05993 begin : Sat Jun 28 2003 05994 copyright : (C) 2003 by Martin Preuss 05995 email : martin@libchipcard.de 05996 05997 *************************************************************************** 05998 * * 05999 * This library is free software; you can redistribute it and/or * 06000 * modify it under the terms of the GNU Lesser General Public * 06001 * License as published by the Free Software Foundation; either * 06002 * version 2.1 of the License, or (at your option) any later version. * 06003 * * 06004 * This library is distributed in the hope that it will be useful, * 06005 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 06006 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 06007 * Lesser General Public License for more details. * 06008 * * 06009 * You should have received a copy of the GNU Lesser General Public * 06010 * License along with this library; if not, write to the Free Software * 06011 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 06012 * MA 02111-1307 USA * 06013 * * 06014 ***************************************************************************/ 06015 06016 06017 #ifndef OH_INSTITUTE_SPEC_LIST2_H 06018 #define OH_INSTITUTE_SPEC_LIST2_H 06019 06020 06021 #ifdef __cplusplus 06022 extern "C" { 06023 #endif 06024 06031 typedef struct OH_INSTITUTE_SPEC_LIST2 OH_INSTITUTE_SPEC_LIST2; 06032 06036 typedef struct OH_INSTITUTE_SPEC_LIST2_ITERATOR OH_INSTITUTE_SPEC_LIST2_ITERATOR; 06037 06041 typedef OH_INSTITUTE_SPEC* (OH_INSTITUTE_SPEC_LIST2_FOREACH)(OH_INSTITUTE_SPEC *element, 06042 void *user_data); 06043 06047 OH_INSTITUTE_SPEC_LIST2 *OH_InstituteSpec_List2_new(); 06048 06052 void OH_InstituteSpec_List2_free(OH_INSTITUTE_SPEC_LIST2 *l); 06053 06057 void OH_InstituteSpec_List2_Dump(OH_INSTITUTE_SPEC_LIST2 *l, FILE *f, unsigned int indent); 06058 06062 void OH_InstituteSpec_List2_PushBack(OH_INSTITUTE_SPEC_LIST2 *l, OH_INSTITUTE_SPEC *p); 06063 06068 void OH_InstituteSpec_List2_PushFront(OH_INSTITUTE_SPEC_LIST2 *l, OH_INSTITUTE_SPEC *p); 06069 06074 OH_INSTITUTE_SPEC *OH_InstituteSpec_List2_GetFront(OH_INSTITUTE_SPEC_LIST2 *l); 06075 06080 OH_INSTITUTE_SPEC *OH_InstituteSpec_List2_GetBack(OH_INSTITUTE_SPEC_LIST2 *l); 06081 06086 void OH_InstituteSpec_List2_Erase(OH_INSTITUTE_SPEC_LIST2 *l, 06087 OH_INSTITUTE_SPEC_LIST2_ITERATOR *it); 06088 06094 unsigned int OH_InstituteSpec_List2_GetSize(OH_INSTITUTE_SPEC_LIST2 *l); 06095 06100 void OH_InstituteSpec_List2_PopBack(OH_INSTITUTE_SPEC_LIST2 *l); 06101 06106 void OH_InstituteSpec_List2_PopFront(OH_INSTITUTE_SPEC_LIST2 *l); 06107 06111 void OH_InstituteSpec_List2_Clear(OH_INSTITUTE_SPEC_LIST2 *l); 06112 06116 OH_INSTITUTE_SPEC_LIST2_ITERATOR *OH_InstituteSpec_List2_First(OH_INSTITUTE_SPEC_LIST2 *l); 06117 06121 OH_INSTITUTE_SPEC_LIST2_ITERATOR *OH_InstituteSpec_List2_Last(OH_INSTITUTE_SPEC_LIST2 *l); 06122 06126 OH_INSTITUTE_SPEC_LIST2_ITERATOR *OH_InstituteSpec_List2Iterator_new(OH_INSTITUTE_SPEC_LIST2 *l); 06127 06131 void OH_InstituteSpec_List2Iterator_free(OH_INSTITUTE_SPEC_LIST2_ITERATOR *li); 06132 06137 OH_INSTITUTE_SPEC *OH_InstituteSpec_List2Iterator_Previous(OH_INSTITUTE_SPEC_LIST2_ITERATOR *li); 06138 06143 OH_INSTITUTE_SPEC *OH_InstituteSpec_List2Iterator_Next(OH_INSTITUTE_SPEC_LIST2_ITERATOR *li); 06144 06149 OH_INSTITUTE_SPEC *OH_InstituteSpec_List2Iterator_Data(OH_INSTITUTE_SPEC_LIST2_ITERATOR *li); 06150 06162 OH_INSTITUTE_SPEC *OH_InstituteSpec_List2_ForEach(OH_INSTITUTE_SPEC_LIST2 *list, 06163 OH_INSTITUTE_SPEC_LIST2_FOREACH func, 06164 void *user_data); 06165 06166 06167 typedef struct OH_INSTITUTE_SPEC_CONSTLIST2 OH_INSTITUTE_SPEC_CONSTLIST2; 06168 typedef struct OH_INSTITUTE_SPEC_CONSTLIST2_ITERATOR OH_INSTITUTE_SPEC_CONSTLIST2_ITERATOR; 06169 typedef const OH_INSTITUTE_SPEC* 06170 (OH_INSTITUTE_SPEC_CONSTLIST2_FOREACH)(const OH_INSTITUTE_SPEC *element, 06171 void *user_data); 06172 06173 06174 OH_INSTITUTE_SPEC_CONSTLIST2 *OH_InstituteSpec_ConstList2_new(); 06175 06176 void OH_InstituteSpec_ConstList2_free(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 06177 06178 void OH_InstituteSpec_ConstList2_PushBack(OH_INSTITUTE_SPEC_CONSTLIST2 *l, const OH_INSTITUTE_SPEC *p); 06179 06180 void OH_InstituteSpec_ConstList2_PushFront(OH_INSTITUTE_SPEC_CONSTLIST2 *l, const OH_INSTITUTE_SPEC *p); 06181 06182 const OH_INSTITUTE_SPEC *OH_InstituteSpec_ConstList2_GetFront(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 06183 06184 const OH_INSTITUTE_SPEC *OH_InstituteSpec_ConstList2_GetBack(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 06185 06186 unsigned int OH_InstituteSpec_ConstList2_GetSize(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 06187 06188 void OH_InstituteSpec_ConstList2_PopBack(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 06189 06190 void OH_InstituteSpec_ConstList2_PopFront(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 06191 06192 void OH_InstituteSpec_ConstList2_Clear(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 06193 06194 OH_INSTITUTE_SPEC_CONSTLIST2_ITERATOR *OH_InstituteSpec_ConstList2_First(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 06195 06196 OH_INSTITUTE_SPEC_CONSTLIST2_ITERATOR *OH_InstituteSpec_ConstList2_Last(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 06197 06198 OH_INSTITUTE_SPEC_CONSTLIST2_ITERATOR *OH_InstituteSpec_ConstList2Iterator_new(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 06199 06200 void OH_InstituteSpec_ConstList2Iterator_free(OH_INSTITUTE_SPEC_CONSTLIST2_ITERATOR *li); 06201 06202 const OH_INSTITUTE_SPEC *OH_InstituteSpec_ConstList2Iterator_Previous(OH_INSTITUTE_SPEC_CONSTLIST2_ITERATOR *li); 06203 06204 const OH_INSTITUTE_SPEC *OH_InstituteSpec_ConstList2Iterator_Next(OH_INSTITUTE_SPEC_CONSTLIST2_ITERATOR *li); 06205 06206 const OH_INSTITUTE_SPEC *OH_InstituteSpec_ConstList2Iterator_Data(OH_INSTITUTE_SPEC_CONSTLIST2_ITERATOR *li); 06207 06219 const OH_INSTITUTE_SPEC *OH_InstituteSpec_ConstList2_ForEach(OH_INSTITUTE_SPEC_CONSTLIST2 *list, 06220 OH_INSTITUTE_SPEC_CONSTLIST2_FOREACH func, void *user_data); 06221 06222 06223 #ifdef __cplusplus 06224 } 06225 #endif 06226 06227 06228 #endif /* OH_INSTITUTE_SPEC_LIST_H */ 06229 06230 06231 06232 /*************************************************************************** 06233 $RCSfile$ 06234 ------------------- 06235 cvs : $Id$ 06236 begin : Sat Jun 28 2003 06237 copyright : (C) 2003 by Martin Preuss 06238 email : martin@libchipcard.de 06239 06240 *************************************************************************** 06241 * * 06242 * This library is free software; you can redistribute it and/or * 06243 * modify it under the terms of the GNU Lesser General Public * 06244 * License as published by the Free Software Foundation; either * 06245 * version 2.1 of the License, or (at your option) any later version. * 06246 * * 06247 * This library is distributed in the hope that it will be useful, * 06248 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 06249 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 06250 * Lesser General Public License for more details. * 06251 * * 06252 * You should have received a copy of the GNU Lesser General Public * 06253 * License along with this library; if not, write to the Free Software * 06254 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 06255 * MA 02111-1307 USA * 06256 * * 06257 ***************************************************************************/ 06258 06259 06260 #ifndef OH_INSTITUTE_SPEC_LIST1_H 06261 #define OH_INSTITUTE_SPEC_LIST1_H 06262 06263 #ifdef __cplusplus 06264 extern "C" { 06265 #endif 06266 06268 typedef struct OH_INSTITUTE_SPEC_LIST_ELEMENT { 06269 uint32_t id; 06270 OH_INSTITUTE_SPEC *nextObject; 06271 } OH_INSTITUTE_SPEC_LIST__ELEMENT; 06272 06279 typedef struct OH_INSTITUTE_SPEC_LIST OH_INSTITUTE_SPEC_LIST; 06280 06284 typedef int GWENHYWFAR_CB (*OH_INSTITUTE_SPEC_LIST_SORT_FN)(const OH_INSTITUTE_SPEC *a, const OH_INSTITUTE_SPEC *b, int ascending); 06285 06286 06288 struct OH_INSTITUTE_SPEC_LIST { 06289 OH_INSTITUTE_SPEC *first; 06290 uint32_t count; 06291 uint32_t id; 06292 } OH_INSTITUTE_SPEC_LIST; 06293 06298 void OH_InstituteSpec_List_AddList(OH_INSTITUTE_SPEC_LIST *dst, OH_INSTITUTE_SPEC_LIST *l); 06299 06303 void OH_InstituteSpec_List_Add(OH_INSTITUTE_SPEC *element, OH_INSTITUTE_SPEC_LIST *list); 06304 06309 void OH_InstituteSpec_List_Insert(OH_INSTITUTE_SPEC *element, OH_INSTITUTE_SPEC_LIST *list); 06310 06317 void OH_InstituteSpec_List_Del(OH_INSTITUTE_SPEC *element); 06318 06322 OH_INSTITUTE_SPEC* OH_InstituteSpec_List_First(const OH_INSTITUTE_SPEC_LIST *l); 06323 06327 OH_INSTITUTE_SPEC* OH_InstituteSpec_List_Last(const OH_INSTITUTE_SPEC_LIST *l); 06328 06333 void OH_InstituteSpec_List_Clear(OH_INSTITUTE_SPEC_LIST *l); 06334 06338 OH_INSTITUTE_SPEC_LIST* OH_InstituteSpec_List_new(); 06339 06343 void OH_InstituteSpec_List_free(OH_INSTITUTE_SPEC_LIST *l); 06344 06348 OH_INSTITUTE_SPEC* OH_InstituteSpec_List_Next(const OH_INSTITUTE_SPEC *element); 06349 06353 OH_INSTITUTE_SPEC* OH_InstituteSpec_List_Previous(const OH_INSTITUTE_SPEC *element); 06354 06358 uint32_t OH_InstituteSpec_List_GetCount(const OH_INSTITUTE_SPEC_LIST *l); 06359 06363 OH_INSTITUTE_SPEC_LIST_SORT_FN OH_InstituteSpec_List_SetSortFn(OH_INSTITUTE_SPEC_LIST *l, OH_INSTITUTE_SPEC_LIST_SORT_FN fn); 06364 06370 void OH_InstituteSpec_List_Sort(OH_INSTITUTE_SPEC_LIST *l, int ascending); 06371 06372 06373 #ifdef __cplusplus 06374 } 06375 #endif 06376 06377 06378 #endif 06379 06380 06381 06382 /*************************************************************************** 06383 $RCSfile$ 06384 ------------------- 06385 cvs : $Id$ 06386 begin : Sat Jun 28 2003 06387 copyright : (C) 2003 by Martin Preuss 06388 email : martin@libchipcard.de 06389 06390 *************************************************************************** 06391 * * 06392 * This library is free software; you can redistribute it and/or * 06393 * modify it under the terms of the GNU Lesser General Public * 06394 * License as published by the Free Software Foundation; either * 06395 * version 2.1 of the License, or (at your option) any later version. * 06396 * * 06397 * This library is distributed in the hope that it will be useful, * 06398 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 06399 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 06400 * Lesser General Public License for more details. * 06401 * * 06402 * You should have received a copy of the GNU Lesser General Public * 06403 * License along with this library; if not, write to the Free Software * 06404 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 06405 * MA 02111-1307 USA * 06406 * * 06407 ***************************************************************************/ 06408 06409 06410 #ifndef OH_INSTITUTE_DATA_LIST2_H 06411 #define OH_INSTITUTE_DATA_LIST2_H 06412 06413 06414 #ifdef __cplusplus 06415 extern "C" { 06416 #endif 06417 06424 typedef struct OH_INSTITUTE_DATA_LIST2 OH_INSTITUTE_DATA_LIST2; 06425 06429 typedef struct OH_INSTITUTE_DATA_LIST2_ITERATOR OH_INSTITUTE_DATA_LIST2_ITERATOR; 06430 06434 typedef OH_INSTITUTE_DATA* (OH_INSTITUTE_DATA_LIST2_FOREACH)(OH_INSTITUTE_DATA *element, 06435 void *user_data); 06436 06440 OH_INSTITUTE_DATA_LIST2 *OH_InstituteData_List2_new(); 06441 06445 void OH_InstituteData_List2_free(OH_INSTITUTE_DATA_LIST2 *l); 06446 06450 void OH_InstituteData_List2_Dump(OH_INSTITUTE_DATA_LIST2 *l, FILE *f, unsigned int indent); 06451 06455 void OH_InstituteData_List2_PushBack(OH_INSTITUTE_DATA_LIST2 *l, OH_INSTITUTE_DATA *p); 06456 06461 void OH_InstituteData_List2_PushFront(OH_INSTITUTE_DATA_LIST2 *l, OH_INSTITUTE_DATA *p); 06462 06467 OH_INSTITUTE_DATA *OH_InstituteData_List2_GetFront(OH_INSTITUTE_DATA_LIST2 *l); 06468 06473 OH_INSTITUTE_DATA *OH_InstituteData_List2_GetBack(OH_INSTITUTE_DATA_LIST2 *l); 06474 06479 void OH_InstituteData_List2_Erase(OH_INSTITUTE_DATA_LIST2 *l, 06480 OH_INSTITUTE_DATA_LIST2_ITERATOR *it); 06481 06487 unsigned int OH_InstituteData_List2_GetSize(OH_INSTITUTE_DATA_LIST2 *l); 06488 06493 void OH_InstituteData_List2_PopBack(OH_INSTITUTE_DATA_LIST2 *l); 06494 06499 void OH_InstituteData_List2_PopFront(OH_INSTITUTE_DATA_LIST2 *l); 06500 06504 void OH_InstituteData_List2_Clear(OH_INSTITUTE_DATA_LIST2 *l); 06505 06509 OH_INSTITUTE_DATA_LIST2_ITERATOR *OH_InstituteData_List2_First(OH_INSTITUTE_DATA_LIST2 *l); 06510 06514 OH_INSTITUTE_DATA_LIST2_ITERATOR *OH_InstituteData_List2_Last(OH_INSTITUTE_DATA_LIST2 *l); 06515 06519 OH_INSTITUTE_DATA_LIST2_ITERATOR *OH_InstituteData_List2Iterator_new(OH_INSTITUTE_DATA_LIST2 *l); 06520 06524 void OH_InstituteData_List2Iterator_free(OH_INSTITUTE_DATA_LIST2_ITERATOR *li); 06525 06530 OH_INSTITUTE_DATA *OH_InstituteData_List2Iterator_Previous(OH_INSTITUTE_DATA_LIST2_ITERATOR *li); 06531 06536 OH_INSTITUTE_DATA *OH_InstituteData_List2Iterator_Next(OH_INSTITUTE_DATA_LIST2_ITERATOR *li); 06537 06542 OH_INSTITUTE_DATA *OH_InstituteData_List2Iterator_Data(OH_INSTITUTE_DATA_LIST2_ITERATOR *li); 06543 06555 OH_INSTITUTE_DATA *OH_InstituteData_List2_ForEach(OH_INSTITUTE_DATA_LIST2 *list, 06556 OH_INSTITUTE_DATA_LIST2_FOREACH func, 06557 void *user_data); 06558 06559 06560 typedef struct OH_INSTITUTE_DATA_CONSTLIST2 OH_INSTITUTE_DATA_CONSTLIST2; 06561 typedef struct OH_INSTITUTE_DATA_CONSTLIST2_ITERATOR OH_INSTITUTE_DATA_CONSTLIST2_ITERATOR; 06562 typedef const OH_INSTITUTE_DATA* 06563 (OH_INSTITUTE_DATA_CONSTLIST2_FOREACH)(const OH_INSTITUTE_DATA *element, 06564 void *user_data); 06565 06566 06567 OH_INSTITUTE_DATA_CONSTLIST2 *OH_InstituteData_ConstList2_new(); 06568 06569 void OH_InstituteData_ConstList2_free(OH_INSTITUTE_DATA_CONSTLIST2 *l); 06570 06571 void OH_InstituteData_ConstList2_PushBack(OH_INSTITUTE_DATA_CONSTLIST2 *l, const OH_INSTITUTE_DATA *p); 06572 06573 void OH_InstituteData_ConstList2_PushFront(OH_INSTITUTE_DATA_CONSTLIST2 *l, const OH_INSTITUTE_DATA *p); 06574 06575 const OH_INSTITUTE_DATA *OH_InstituteData_ConstList2_GetFront(OH_INSTITUTE_DATA_CONSTLIST2 *l); 06576 06577 const OH_INSTITUTE_DATA *OH_InstituteData_ConstList2_GetBack(OH_INSTITUTE_DATA_CONSTLIST2 *l); 06578 06579 unsigned int OH_InstituteData_ConstList2_GetSize(OH_INSTITUTE_DATA_CONSTLIST2 *l); 06580 06581 void OH_InstituteData_ConstList2_PopBack(OH_INSTITUTE_DATA_CONSTLIST2 *l); 06582 06583 void OH_InstituteData_ConstList2_PopFront(OH_INSTITUTE_DATA_CONSTLIST2 *l); 06584 06585 void OH_InstituteData_ConstList2_Clear(OH_INSTITUTE_DATA_CONSTLIST2 *l); 06586 06587 OH_INSTITUTE_DATA_CONSTLIST2_ITERATOR *OH_InstituteData_ConstList2_First(OH_INSTITUTE_DATA_CONSTLIST2 *l); 06588 06589 OH_INSTITUTE_DATA_CONSTLIST2_ITERATOR *OH_InstituteData_ConstList2_Last(OH_INSTITUTE_DATA_CONSTLIST2 *l); 06590 06591 OH_INSTITUTE_DATA_CONSTLIST2_ITERATOR *OH_InstituteData_ConstList2Iterator_new(OH_INSTITUTE_DATA_CONSTLIST2 *l); 06592 06593 void OH_InstituteData_ConstList2Iterator_free(OH_INSTITUTE_DATA_CONSTLIST2_ITERATOR *li); 06594 06595 const OH_INSTITUTE_DATA *OH_InstituteData_ConstList2Iterator_Previous(OH_INSTITUTE_DATA_CONSTLIST2_ITERATOR *li); 06596 06597 const OH_INSTITUTE_DATA *OH_InstituteData_ConstList2Iterator_Next(OH_INSTITUTE_DATA_CONSTLIST2_ITERATOR *li); 06598 06599 const OH_INSTITUTE_DATA *OH_InstituteData_ConstList2Iterator_Data(OH_INSTITUTE_DATA_CONSTLIST2_ITERATOR *li); 06600 06612 const OH_INSTITUTE_DATA *OH_InstituteData_ConstList2_ForEach(OH_INSTITUTE_DATA_CONSTLIST2 *list, 06613 OH_INSTITUTE_DATA_CONSTLIST2_FOREACH func, void *user_data); 06614 06615 06616 #ifdef __cplusplus 06617 } 06618 #endif 06619 06620 06621 #endif /* OH_INSTITUTE_DATA_LIST_H */ 06622 06623 06624 06625 /*************************************************************************** 06626 $RCSfile$ 06627 ------------------- 06628 cvs : $Id$ 06629 begin : Sat Jun 28 2003 06630 copyright : (C) 2003 by Martin Preuss 06631 email : martin@libchipcard.de 06632 06633 *************************************************************************** 06634 * * 06635 * This library is free software; you can redistribute it and/or * 06636 * modify it under the terms of the GNU Lesser General Public * 06637 * License as published by the Free Software Foundation; either * 06638 * version 2.1 of the License, or (at your option) any later version. * 06639 * * 06640 * This library is distributed in the hope that it will be useful, * 06641 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 06642 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 06643 * Lesser General Public License for more details. * 06644 * * 06645 * You should have received a copy of the GNU Lesser General Public * 06646 * License along with this library; if not, write to the Free Software * 06647 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 06648 * MA 02111-1307 USA * 06649 * * 06650 ***************************************************************************/ 06651 06652 06653 #ifndef OH_INSTITUTE_DATA_LIST1_H 06654 #define OH_INSTITUTE_DATA_LIST1_H 06655 06656 #ifdef __cplusplus 06657 extern "C" { 06658 #endif 06659 06661 typedef struct OH_INSTITUTE_DATA_LIST_ELEMENT { 06662 uint32_t id; 06663 OH_INSTITUTE_DATA *nextObject; 06664 } OH_INSTITUTE_DATA_LIST__ELEMENT; 06665 06672 typedef struct OH_INSTITUTE_DATA_LIST OH_INSTITUTE_DATA_LIST; 06673 06677 typedef int GWENHYWFAR_CB (*OH_INSTITUTE_DATA_LIST_SORT_FN)(const OH_INSTITUTE_DATA *a, const OH_INSTITUTE_DATA *b, int ascending); 06678 06679 06681 struct OH_INSTITUTE_DATA_LIST { 06682 OH_INSTITUTE_DATA *first; 06683 uint32_t count; 06684 uint32_t id; 06685 } OH_INSTITUTE_DATA_LIST; 06686 06691 void OH_InstituteData_List_AddList(OH_INSTITUTE_DATA_LIST *dst, OH_INSTITUTE_DATA_LIST *l); 06692 06696 void OH_InstituteData_List_Add(OH_INSTITUTE_DATA *element, OH_INSTITUTE_DATA_LIST *list); 06697 06702 void OH_InstituteData_List_Insert(OH_INSTITUTE_DATA *element, OH_INSTITUTE_DATA_LIST *list); 06703 06710 void OH_InstituteData_List_Del(OH_INSTITUTE_DATA *element); 06711 06715 OH_INSTITUTE_DATA* OH_InstituteData_List_First(const OH_INSTITUTE_DATA_LIST *l); 06716 06720 OH_INSTITUTE_DATA* OH_InstituteData_List_Last(const OH_INSTITUTE_DATA_LIST *l); 06721 06726 void OH_InstituteData_List_Clear(OH_INSTITUTE_DATA_LIST *l); 06727 06731 OH_INSTITUTE_DATA_LIST* OH_InstituteData_List_new(); 06732 06736 void OH_InstituteData_List_free(OH_INSTITUTE_DATA_LIST *l); 06737 06741 OH_INSTITUTE_DATA* OH_InstituteData_List_Next(const OH_INSTITUTE_DATA *element); 06742 06746 OH_INSTITUTE_DATA* OH_InstituteData_List_Previous(const OH_INSTITUTE_DATA *element); 06747 06751 uint32_t OH_InstituteData_List_GetCount(const OH_INSTITUTE_DATA_LIST *l); 06752 06756 OH_INSTITUTE_DATA_LIST_SORT_FN OH_InstituteData_List_SetSortFn(OH_INSTITUTE_DATA_LIST *l, OH_INSTITUTE_DATA_LIST_SORT_FN fn); 06757 06763 void OH_InstituteData_List_Sort(OH_INSTITUTE_DATA_LIST *l, int ascending); 06764 06765 06766 #ifdef __cplusplus 06767 } 06768 #endif 06769 06770 06771 #endif 06772 06773 06774 06775 /*************************************************************************** 06776 $RCSfile$ 06777 ------------------- 06778 cvs : $Id$ 06779 begin : Sat Jun 28 2003 06780 copyright : (C) 2003 by Martin Preuss 06781 email : martin@libchipcard.de 06782 06783 *************************************************************************** 06784 * * 06785 * This library is free software; you can redistribute it and/or * 06786 * modify it under the terms of the GNU Lesser General Public * 06787 * License as published by the Free Software Foundation; either * 06788 * version 2.1 of the License, or (at your option) any later version. * 06789 * * 06790 * This library is distributed in the hope that it will be useful, * 06791 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 06792 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 06793 * Lesser General Public License for more details. * 06794 * * 06795 * You should have received a copy of the GNU Lesser General Public * 06796 * License along with this library; if not, write to the Free Software * 06797 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 06798 * MA 02111-1307 USA * 06799 * * 06800 ***************************************************************************/ 06801 06802 06803 #ifndef AH_TAN_METHOD_LIST2_H 06804 #define AH_TAN_METHOD_LIST2_H 06805 06806 06807 #ifdef __cplusplus 06808 extern "C" { 06809 #endif 06810 06817 typedef struct AH_TAN_METHOD_LIST2 AH_TAN_METHOD_LIST2; 06818 06822 typedef struct AH_TAN_METHOD_LIST2_ITERATOR AH_TAN_METHOD_LIST2_ITERATOR; 06823 06827 typedef AH_TAN_METHOD* (AH_TAN_METHOD_LIST2_FOREACH)(AH_TAN_METHOD *element, 06828 void *user_data); 06829 06833 AH_TAN_METHOD_LIST2 *AH_TanMethod_List2_new(); 06834 06838 void AH_TanMethod_List2_free(AH_TAN_METHOD_LIST2 *l); 06839 06843 void AH_TanMethod_List2_Dump(AH_TAN_METHOD_LIST2 *l, FILE *f, unsigned int indent); 06844 06848 void AH_TanMethod_List2_PushBack(AH_TAN_METHOD_LIST2 *l, AH_TAN_METHOD *p); 06849 06854 void AH_TanMethod_List2_PushFront(AH_TAN_METHOD_LIST2 *l, AH_TAN_METHOD *p); 06855 06860 AH_TAN_METHOD *AH_TanMethod_List2_GetFront(AH_TAN_METHOD_LIST2 *l); 06861 06866 AH_TAN_METHOD *AH_TanMethod_List2_GetBack(AH_TAN_METHOD_LIST2 *l); 06867 06872 void AH_TanMethod_List2_Erase(AH_TAN_METHOD_LIST2 *l, 06873 AH_TAN_METHOD_LIST2_ITERATOR *it); 06874 06880 unsigned int AH_TanMethod_List2_GetSize(AH_TAN_METHOD_LIST2 *l); 06881 06886 void AH_TanMethod_List2_PopBack(AH_TAN_METHOD_LIST2 *l); 06887 06892 void AH_TanMethod_List2_PopFront(AH_TAN_METHOD_LIST2 *l); 06893 06897 void AH_TanMethod_List2_Clear(AH_TAN_METHOD_LIST2 *l); 06898 06902 AH_TAN_METHOD_LIST2_ITERATOR *AH_TanMethod_List2_First(AH_TAN_METHOD_LIST2 *l); 06903 06907 AH_TAN_METHOD_LIST2_ITERATOR *AH_TanMethod_List2_Last(AH_TAN_METHOD_LIST2 *l); 06908 06912 AH_TAN_METHOD_LIST2_ITERATOR *AH_TanMethod_List2Iterator_new(AH_TAN_METHOD_LIST2 *l); 06913 06917 void AH_TanMethod_List2Iterator_free(AH_TAN_METHOD_LIST2_ITERATOR *li); 06918 06923 AH_TAN_METHOD *AH_TanMethod_List2Iterator_Previous(AH_TAN_METHOD_LIST2_ITERATOR *li); 06924 06929 AH_TAN_METHOD *AH_TanMethod_List2Iterator_Next(AH_TAN_METHOD_LIST2_ITERATOR *li); 06930 06935 AH_TAN_METHOD *AH_TanMethod_List2Iterator_Data(AH_TAN_METHOD_LIST2_ITERATOR *li); 06936 06948 AH_TAN_METHOD *AH_TanMethod_List2_ForEach(AH_TAN_METHOD_LIST2 *list, 06949 AH_TAN_METHOD_LIST2_FOREACH func, 06950 void *user_data); 06951 06952 06953 typedef struct AH_TAN_METHOD_CONSTLIST2 AH_TAN_METHOD_CONSTLIST2; 06954 typedef struct AH_TAN_METHOD_CONSTLIST2_ITERATOR AH_TAN_METHOD_CONSTLIST2_ITERATOR; 06955 typedef const AH_TAN_METHOD* 06956 (AH_TAN_METHOD_CONSTLIST2_FOREACH)(const AH_TAN_METHOD *element, 06957 void *user_data); 06958 06959 06960 AH_TAN_METHOD_CONSTLIST2 *AH_TanMethod_ConstList2_new(); 06961 06962 void AH_TanMethod_ConstList2_free(AH_TAN_METHOD_CONSTLIST2 *l); 06963 06964 void AH_TanMethod_ConstList2_PushBack(AH_TAN_METHOD_CONSTLIST2 *l, const AH_TAN_METHOD *p); 06965 06966 void AH_TanMethod_ConstList2_PushFront(AH_TAN_METHOD_CONSTLIST2 *l, const AH_TAN_METHOD *p); 06967 06968 const AH_TAN_METHOD *AH_TanMethod_ConstList2_GetFront(AH_TAN_METHOD_CONSTLIST2 *l); 06969 06970 const AH_TAN_METHOD *AH_TanMethod_ConstList2_GetBack(AH_TAN_METHOD_CONSTLIST2 *l); 06971 06972 unsigned int AH_TanMethod_ConstList2_GetSize(AH_TAN_METHOD_CONSTLIST2 *l); 06973 06974 void AH_TanMethod_ConstList2_PopBack(AH_TAN_METHOD_CONSTLIST2 *l); 06975 06976 void AH_TanMethod_ConstList2_PopFront(AH_TAN_METHOD_CONSTLIST2 *l); 06977 06978 void AH_TanMethod_ConstList2_Clear(AH_TAN_METHOD_CONSTLIST2 *l); 06979 06980 AH_TAN_METHOD_CONSTLIST2_ITERATOR *AH_TanMethod_ConstList2_First(AH_TAN_METHOD_CONSTLIST2 *l); 06981 06982 AH_TAN_METHOD_CONSTLIST2_ITERATOR *AH_TanMethod_ConstList2_Last(AH_TAN_METHOD_CONSTLIST2 *l); 06983 06984 AH_TAN_METHOD_CONSTLIST2_ITERATOR *AH_TanMethod_ConstList2Iterator_new(AH_TAN_METHOD_CONSTLIST2 *l); 06985 06986 void AH_TanMethod_ConstList2Iterator_free(AH_TAN_METHOD_CONSTLIST2_ITERATOR *li); 06987 06988 const AH_TAN_METHOD *AH_TanMethod_ConstList2Iterator_Previous(AH_TAN_METHOD_CONSTLIST2_ITERATOR *li); 06989 06990 const AH_TAN_METHOD *AH_TanMethod_ConstList2Iterator_Next(AH_TAN_METHOD_CONSTLIST2_ITERATOR *li); 06991 06992 const AH_TAN_METHOD *AH_TanMethod_ConstList2Iterator_Data(AH_TAN_METHOD_CONSTLIST2_ITERATOR *li); 06993 07005 const AH_TAN_METHOD *AH_TanMethod_ConstList2_ForEach(AH_TAN_METHOD_CONSTLIST2 *list, 07006 AH_TAN_METHOD_CONSTLIST2_FOREACH func, void *user_data); 07007 07008 07009 #ifdef __cplusplus 07010 } 07011 #endif 07012 07013 07014 #endif /* AH_TAN_METHOD_LIST_H */ 07015 07016 07017 07018 /*************************************************************************** 07019 $RCSfile$ 07020 ------------------- 07021 cvs : $Id$ 07022 begin : Sat Jun 28 2003 07023 copyright : (C) 2003 by Martin Preuss 07024 email : martin@libchipcard.de 07025 07026 *************************************************************************** 07027 * * 07028 * This library is free software; you can redistribute it and/or * 07029 * modify it under the terms of the GNU Lesser General Public * 07030 * License as published by the Free Software Foundation; either * 07031 * version 2.1 of the License, or (at your option) any later version. * 07032 * * 07033 * This library is distributed in the hope that it will be useful, * 07034 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 07035 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 07036 * Lesser General Public License for more details. * 07037 * * 07038 * You should have received a copy of the GNU Lesser General Public * 07039 * License along with this library; if not, write to the Free Software * 07040 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 07041 * MA 02111-1307 USA * 07042 * * 07043 ***************************************************************************/ 07044 07045 07046 #ifndef AH_TAN_METHOD_LIST1_H 07047 #define AH_TAN_METHOD_LIST1_H 07048 07049 #ifdef __cplusplus 07050 extern "C" { 07051 #endif 07052 07054 typedef struct AH_TAN_METHOD_LIST_ELEMENT { 07055 uint32_t id; 07056 AH_TAN_METHOD *nextObject; 07057 } AH_TAN_METHOD_LIST__ELEMENT; 07058 07065 typedef struct AH_TAN_METHOD_LIST AH_TAN_METHOD_LIST; 07066 07070 typedef int GWENHYWFAR_CB (*AH_TAN_METHOD_LIST_SORT_FN)(const AH_TAN_METHOD *a, const AH_TAN_METHOD *b, int ascending); 07071 07072 07074 struct AH_TAN_METHOD_LIST { 07075 AH_TAN_METHOD *first; 07076 uint32_t count; 07077 uint32_t id; 07078 } AH_TAN_METHOD_LIST; 07079 07084 void AH_TanMethod_List_AddList(AH_TAN_METHOD_LIST *dst, AH_TAN_METHOD_LIST *l); 07085 07089 void AH_TanMethod_List_Add(AH_TAN_METHOD *element, AH_TAN_METHOD_LIST *list); 07090 07095 void AH_TanMethod_List_Insert(AH_TAN_METHOD *element, AH_TAN_METHOD_LIST *list); 07096 07103 void AH_TanMethod_List_Del(AH_TAN_METHOD *element); 07104 07108 AH_TAN_METHOD* AH_TanMethod_List_First(const AH_TAN_METHOD_LIST *l); 07109 07113 AH_TAN_METHOD* AH_TanMethod_List_Last(const AH_TAN_METHOD_LIST *l); 07114 07119 void AH_TanMethod_List_Clear(AH_TAN_METHOD_LIST *l); 07120 07124 AH_TAN_METHOD_LIST* AH_TanMethod_List_new(); 07125 07129 void AH_TanMethod_List_free(AH_TAN_METHOD_LIST *l); 07130 07134 AH_TAN_METHOD* AH_TanMethod_List_Next(const AH_TAN_METHOD *element); 07135 07139 AH_TAN_METHOD* AH_TanMethod_List_Previous(const AH_TAN_METHOD *element); 07140 07144 uint32_t AH_TanMethod_List_GetCount(const AH_TAN_METHOD_LIST *l); 07145 07149 AH_TAN_METHOD_LIST_SORT_FN AH_TanMethod_List_SetSortFn(AH_TAN_METHOD_LIST *l, AH_TAN_METHOD_LIST_SORT_FN fn); 07150 07156 void AH_TanMethod_List_Sort(AH_TAN_METHOD_LIST *l, int ascending); 07157 07158 07159 #ifdef __cplusplus 07160 } 07161 #endif 07162 07163 07164 #endif 07165 07166 07167