aqbanking
5.0.22
|
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_ACCOUNT_LIST2_H 00030 #define AB_ACCOUNT_LIST2_H 00031 00032 00033 #ifdef __cplusplus 00034 extern "C" { 00035 #endif 00036 00043 typedef struct AB_ACCOUNT_LIST2 AB_ACCOUNT_LIST2; 00044 00048 typedef struct AB_ACCOUNT_LIST2_ITERATOR AB_ACCOUNT_LIST2_ITERATOR; 00049 00053 typedef AB_ACCOUNT* (AB_ACCOUNT_LIST2_FOREACH)(AB_ACCOUNT *element, 00054 void *user_data); 00055 00059 AB_ACCOUNT_LIST2 *AB_Account_List2_new(); 00060 00064 void AB_Account_List2_free(AB_ACCOUNT_LIST2 *l); 00065 00069 void AB_Account_List2_Dump(AB_ACCOUNT_LIST2 *l, FILE *f, unsigned int indent); 00070 00074 void AB_Account_List2_PushBack(AB_ACCOUNT_LIST2 *l, AB_ACCOUNT *p); 00075 00080 void AB_Account_List2_PushFront(AB_ACCOUNT_LIST2 *l, AB_ACCOUNT *p); 00081 00086 AB_ACCOUNT *AB_Account_List2_GetFront(AB_ACCOUNT_LIST2 *l); 00087 00092 AB_ACCOUNT *AB_Account_List2_GetBack(AB_ACCOUNT_LIST2 *l); 00093 00098 void AB_Account_List2_Erase(AB_ACCOUNT_LIST2 *l, 00099 AB_ACCOUNT_LIST2_ITERATOR *it); 00100 00106 unsigned int AB_Account_List2_GetSize(AB_ACCOUNT_LIST2 *l); 00107 00112 void AB_Account_List2_PopBack(AB_ACCOUNT_LIST2 *l); 00113 00118 void AB_Account_List2_PopFront(AB_ACCOUNT_LIST2 *l); 00119 00123 void AB_Account_List2_Clear(AB_ACCOUNT_LIST2 *l); 00124 00128 AB_ACCOUNT_LIST2_ITERATOR *AB_Account_List2_First(AB_ACCOUNT_LIST2 *l); 00129 00133 AB_ACCOUNT_LIST2_ITERATOR *AB_Account_List2_Last(AB_ACCOUNT_LIST2 *l); 00134 00138 AB_ACCOUNT_LIST2_ITERATOR *AB_Account_List2Iterator_new(AB_ACCOUNT_LIST2 *l); 00139 00143 void AB_Account_List2Iterator_free(AB_ACCOUNT_LIST2_ITERATOR *li); 00144 00149 AB_ACCOUNT *AB_Account_List2Iterator_Previous(AB_ACCOUNT_LIST2_ITERATOR *li); 00150 00155 AB_ACCOUNT *AB_Account_List2Iterator_Next(AB_ACCOUNT_LIST2_ITERATOR *li); 00156 00161 AB_ACCOUNT *AB_Account_List2Iterator_Data(AB_ACCOUNT_LIST2_ITERATOR *li); 00162 00174 AB_ACCOUNT *AB_Account_List2_ForEach(AB_ACCOUNT_LIST2 *list, 00175 AB_ACCOUNT_LIST2_FOREACH func, 00176 void *user_data); 00177 00178 00179 typedef struct AB_ACCOUNT_CONSTLIST2 AB_ACCOUNT_CONSTLIST2; 00180 typedef struct AB_ACCOUNT_CONSTLIST2_ITERATOR AB_ACCOUNT_CONSTLIST2_ITERATOR; 00181 typedef const AB_ACCOUNT* 00182 (AB_ACCOUNT_CONSTLIST2_FOREACH)(const AB_ACCOUNT *element, 00183 void *user_data); 00184 00185 00186 AB_ACCOUNT_CONSTLIST2 *AB_Account_ConstList2_new(); 00187 00188 void AB_Account_ConstList2_free(AB_ACCOUNT_CONSTLIST2 *l); 00189 00190 void AB_Account_ConstList2_PushBack(AB_ACCOUNT_CONSTLIST2 *l, const AB_ACCOUNT *p); 00191 00192 void AB_Account_ConstList2_PushFront(AB_ACCOUNT_CONSTLIST2 *l, const AB_ACCOUNT *p); 00193 00194 const AB_ACCOUNT *AB_Account_ConstList2_GetFront(AB_ACCOUNT_CONSTLIST2 *l); 00195 00196 const AB_ACCOUNT *AB_Account_ConstList2_GetBack(AB_ACCOUNT_CONSTLIST2 *l); 00197 00198 unsigned int AB_Account_ConstList2_GetSize(AB_ACCOUNT_CONSTLIST2 *l); 00199 00200 void AB_Account_ConstList2_PopBack(AB_ACCOUNT_CONSTLIST2 *l); 00201 00202 void AB_Account_ConstList2_PopFront(AB_ACCOUNT_CONSTLIST2 *l); 00203 00204 void AB_Account_ConstList2_Clear(AB_ACCOUNT_CONSTLIST2 *l); 00205 00206 AB_ACCOUNT_CONSTLIST2_ITERATOR *AB_Account_ConstList2_First(AB_ACCOUNT_CONSTLIST2 *l); 00207 00208 AB_ACCOUNT_CONSTLIST2_ITERATOR *AB_Account_ConstList2_Last(AB_ACCOUNT_CONSTLIST2 *l); 00209 00210 AB_ACCOUNT_CONSTLIST2_ITERATOR *AB_Account_ConstList2Iterator_new(AB_ACCOUNT_CONSTLIST2 *l); 00211 00212 void AB_Account_ConstList2Iterator_free(AB_ACCOUNT_CONSTLIST2_ITERATOR *li); 00213 00214 const AB_ACCOUNT *AB_Account_ConstList2Iterator_Previous(AB_ACCOUNT_CONSTLIST2_ITERATOR *li); 00215 00216 const AB_ACCOUNT *AB_Account_ConstList2Iterator_Next(AB_ACCOUNT_CONSTLIST2_ITERATOR *li); 00217 00218 const AB_ACCOUNT *AB_Account_ConstList2Iterator_Data(AB_ACCOUNT_CONSTLIST2_ITERATOR *li); 00219 00231 const AB_ACCOUNT *AB_Account_ConstList2_ForEach(AB_ACCOUNT_CONSTLIST2 *list, 00232 AB_ACCOUNT_CONSTLIST2_FOREACH func, void *user_data); 00233 00234 00235 #ifdef __cplusplus 00236 } 00237 #endif 00238 00239 00240 #endif /* AB_ACCOUNT_LIST_H */ 00241 00242 00243 00244 /*************************************************************************** 00245 $RCSfile$ 00246 ------------------- 00247 cvs : $Id$ 00248 begin : Sat Jun 28 2003 00249 copyright : (C) 2003 by Martin Preuss 00250 email : martin@libchipcard.de 00251 00252 *************************************************************************** 00253 * * 00254 * This library is free software; you can redistribute it and/or * 00255 * modify it under the terms of the GNU Lesser General Public * 00256 * License as published by the Free Software Foundation; either * 00257 * version 2.1 of the License, or (at your option) any later version. * 00258 * * 00259 * This library is distributed in the hope that it will be useful, * 00260 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 00261 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 00262 * Lesser General Public License for more details. * 00263 * * 00264 * You should have received a copy of the GNU Lesser General Public * 00265 * License along with this library; if not, write to the Free Software * 00266 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 00267 * MA 02111-1307 USA * 00268 * * 00269 ***************************************************************************/ 00270 00271 00272 #ifndef AB_ACCOUNT_LIST1_H 00273 #define AB_ACCOUNT_LIST1_H 00274 00275 #ifdef __cplusplus 00276 extern "C" { 00277 #endif 00278 00280 typedef struct AB_ACCOUNT_LIST_ELEMENT { 00281 uint32_t id; 00282 AB_ACCOUNT *nextObject; 00283 } AB_ACCOUNT_LIST__ELEMENT; 00284 00291 typedef struct AB_ACCOUNT_LIST AB_ACCOUNT_LIST; 00292 00296 typedef int GWENHYWFAR_CB (*AB_ACCOUNT_LIST_SORT_FN)(const AB_ACCOUNT *a, const AB_ACCOUNT *b, int ascending); 00297 00298 00300 struct AB_ACCOUNT_LIST { 00301 AB_ACCOUNT *first; 00302 uint32_t count; 00303 uint32_t id; 00304 } AB_ACCOUNT_LIST; 00305 00310 void AB_Account_List_AddList(AB_ACCOUNT_LIST *dst, AB_ACCOUNT_LIST *l); 00311 00315 void AB_Account_List_Add(AB_ACCOUNT *element, AB_ACCOUNT_LIST *list); 00316 00321 void AB_Account_List_Insert(AB_ACCOUNT *element, AB_ACCOUNT_LIST *list); 00322 00329 void AB_Account_List_Del(AB_ACCOUNT *element); 00330 00334 AB_ACCOUNT* AB_Account_List_First(const AB_ACCOUNT_LIST *l); 00335 00339 AB_ACCOUNT* AB_Account_List_Last(const AB_ACCOUNT_LIST *l); 00340 00345 void AB_Account_List_Clear(AB_ACCOUNT_LIST *l); 00346 00350 AB_ACCOUNT_LIST* AB_Account_List_new(); 00351 00355 void AB_Account_List_free(AB_ACCOUNT_LIST *l); 00356 00360 AB_ACCOUNT* AB_Account_List_Next(const AB_ACCOUNT *element); 00361 00365 AB_ACCOUNT* AB_Account_List_Previous(const AB_ACCOUNT *element); 00366 00370 uint32_t AB_Account_List_GetCount(const AB_ACCOUNT_LIST *l); 00371 00375 AB_ACCOUNT_LIST_SORT_FN AB_Account_List_SetSortFn(AB_ACCOUNT_LIST *l, AB_ACCOUNT_LIST_SORT_FN fn); 00376 00382 void AB_Account_List_Sort(AB_ACCOUNT_LIST *l, int ascending); 00383 00384 00385 #ifdef __cplusplus 00386 } 00387 #endif 00388 00389 00390 #endif 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_ACCOUNTQUEUE_LIST1_H 00423 #define AB_ACCOUNTQUEUE_LIST1_H 00424 00425 #ifdef __cplusplus 00426 extern "C" { 00427 #endif 00428 00430 typedef struct AB_ACCOUNTQUEUE_LIST_ELEMENT { 00431 uint32_t id; 00432 AB_ACCOUNTQUEUE *nextObject; 00433 } AB_ACCOUNTQUEUE_LIST__ELEMENT; 00434 00441 typedef struct AB_ACCOUNTQUEUE_LIST AB_ACCOUNTQUEUE_LIST; 00442 00446 typedef int GWENHYWFAR_CB (*AB_ACCOUNTQUEUE_LIST_SORT_FN)(const AB_ACCOUNTQUEUE *a, const AB_ACCOUNTQUEUE *b, int ascending); 00447 00448 00450 struct AB_ACCOUNTQUEUE_LIST { 00451 AB_ACCOUNTQUEUE *first; 00452 uint32_t count; 00453 uint32_t id; 00454 } AB_ACCOUNTQUEUE_LIST; 00455 00460 void AB_AccountQueue_List_AddList(AB_ACCOUNTQUEUE_LIST *dst, AB_ACCOUNTQUEUE_LIST *l); 00461 00465 void AB_AccountQueue_List_Add(AB_ACCOUNTQUEUE *element, AB_ACCOUNTQUEUE_LIST *list); 00466 00471 void AB_AccountQueue_List_Insert(AB_ACCOUNTQUEUE *element, AB_ACCOUNTQUEUE_LIST *list); 00472 00479 void AB_AccountQueue_List_Del(AB_ACCOUNTQUEUE *element); 00480 00484 AB_ACCOUNTQUEUE* AB_AccountQueue_List_First(const AB_ACCOUNTQUEUE_LIST *l); 00485 00489 AB_ACCOUNTQUEUE* AB_AccountQueue_List_Last(const AB_ACCOUNTQUEUE_LIST *l); 00490 00495 void AB_AccountQueue_List_Clear(AB_ACCOUNTQUEUE_LIST *l); 00496 00500 AB_ACCOUNTQUEUE_LIST* AB_AccountQueue_List_new(); 00501 00505 void AB_AccountQueue_List_free(AB_ACCOUNTQUEUE_LIST *l); 00506 00510 AB_ACCOUNTQUEUE* AB_AccountQueue_List_Next(const AB_ACCOUNTQUEUE *element); 00511 00515 AB_ACCOUNTQUEUE* AB_AccountQueue_List_Previous(const AB_ACCOUNTQUEUE *element); 00516 00520 uint32_t AB_AccountQueue_List_GetCount(const AB_ACCOUNTQUEUE_LIST *l); 00521 00525 AB_ACCOUNTQUEUE_LIST_SORT_FN AB_AccountQueue_List_SetSortFn(AB_ACCOUNTQUEUE_LIST *l, AB_ACCOUNTQUEUE_LIST_SORT_FN fn); 00526 00532 void AB_AccountQueue_List_Sort(AB_ACCOUNTQUEUE_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_JOBQUEUE_LIST1_H 00573 #define AB_JOBQUEUE_LIST1_H 00574 00575 #ifdef __cplusplus 00576 extern "C" { 00577 #endif 00578 00580 typedef struct AB_JOBQUEUE_LIST_ELEMENT { 00581 uint32_t id; 00582 AB_JOBQUEUE *nextObject; 00583 } AB_JOBQUEUE_LIST__ELEMENT; 00584 00591 typedef struct AB_JOBQUEUE_LIST AB_JOBQUEUE_LIST; 00592 00596 typedef int GWENHYWFAR_CB (*AB_JOBQUEUE_LIST_SORT_FN)(const AB_JOBQUEUE *a, const AB_JOBQUEUE *b, int ascending); 00597 00598 00600 struct AB_JOBQUEUE_LIST { 00601 AB_JOBQUEUE *first; 00602 uint32_t count; 00603 uint32_t id; 00604 } AB_JOBQUEUE_LIST; 00605 00610 void AB_JobQueue_List_AddList(AB_JOBQUEUE_LIST *dst, AB_JOBQUEUE_LIST *l); 00611 00615 void AB_JobQueue_List_Add(AB_JOBQUEUE *element, AB_JOBQUEUE_LIST *list); 00616 00621 void AB_JobQueue_List_Insert(AB_JOBQUEUE *element, AB_JOBQUEUE_LIST *list); 00622 00629 void AB_JobQueue_List_Del(AB_JOBQUEUE *element); 00630 00634 AB_JOBQUEUE* AB_JobQueue_List_First(const AB_JOBQUEUE_LIST *l); 00635 00639 AB_JOBQUEUE* AB_JobQueue_List_Last(const AB_JOBQUEUE_LIST *l); 00640 00645 void AB_JobQueue_List_Clear(AB_JOBQUEUE_LIST *l); 00646 00650 AB_JOBQUEUE_LIST* AB_JobQueue_List_new(); 00651 00655 void AB_JobQueue_List_free(AB_JOBQUEUE_LIST *l); 00656 00660 AB_JOBQUEUE* AB_JobQueue_List_Next(const AB_JOBQUEUE *element); 00661 00665 AB_JOBQUEUE* AB_JobQueue_List_Previous(const AB_JOBQUEUE *element); 00666 00670 uint32_t AB_JobQueue_List_GetCount(const AB_JOBQUEUE_LIST *l); 00671 00675 AB_JOBQUEUE_LIST_SORT_FN AB_JobQueue_List_SetSortFn(AB_JOBQUEUE_LIST *l, AB_JOBQUEUE_LIST_SORT_FN fn); 00676 00682 void AB_JobQueue_List_Sort(AB_JOBQUEUE_LIST *l, int ascending); 00683 00684 00685 #ifdef __cplusplus 00686 } 00687 #endif 00688 00689 00690 #endif 00691 00692 00693 00694 /*************************************************************************** 00695 $RCSfile$ 00696 ------------------- 00697 cvs : $Id$ 00698 begin : Sat Jun 28 2003 00699 copyright : (C) 2003 by Martin Preuss 00700 email : martin@libchipcard.de 00701 00702 *************************************************************************** 00703 * * 00704 * This library is free software; you can redistribute it and/or * 00705 * modify it under the terms of the GNU Lesser General Public * 00706 * License as published by the Free Software Foundation; either * 00707 * version 2.1 of the License, or (at your option) any later version. * 00708 * * 00709 * This library is distributed in the hope that it will be useful, * 00710 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 00711 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 00712 * Lesser General Public License for more details. * 00713 * * 00714 * You should have received a copy of the GNU Lesser General Public * 00715 * License along with this library; if not, write to the Free Software * 00716 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 00717 * MA 02111-1307 USA * 00718 * * 00719 ***************************************************************************/ 00720 00721 00722 #ifndef AB_USERQUEUE_LIST1_H 00723 #define AB_USERQUEUE_LIST1_H 00724 00725 #ifdef __cplusplus 00726 extern "C" { 00727 #endif 00728 00730 typedef struct AB_USERQUEUE_LIST_ELEMENT { 00731 uint32_t id; 00732 AB_USERQUEUE *nextObject; 00733 } AB_USERQUEUE_LIST__ELEMENT; 00734 00741 typedef struct AB_USERQUEUE_LIST AB_USERQUEUE_LIST; 00742 00746 typedef int GWENHYWFAR_CB (*AB_USERQUEUE_LIST_SORT_FN)(const AB_USERQUEUE *a, const AB_USERQUEUE *b, int ascending); 00747 00748 00750 struct AB_USERQUEUE_LIST { 00751 AB_USERQUEUE *first; 00752 uint32_t count; 00753 uint32_t id; 00754 } AB_USERQUEUE_LIST; 00755 00760 void AB_UserQueue_List_AddList(AB_USERQUEUE_LIST *dst, AB_USERQUEUE_LIST *l); 00761 00765 void AB_UserQueue_List_Add(AB_USERQUEUE *element, AB_USERQUEUE_LIST *list); 00766 00771 void AB_UserQueue_List_Insert(AB_USERQUEUE *element, AB_USERQUEUE_LIST *list); 00772 00779 void AB_UserQueue_List_Del(AB_USERQUEUE *element); 00780 00784 AB_USERQUEUE* AB_UserQueue_List_First(const AB_USERQUEUE_LIST *l); 00785 00789 AB_USERQUEUE* AB_UserQueue_List_Last(const AB_USERQUEUE_LIST *l); 00790 00795 void AB_UserQueue_List_Clear(AB_USERQUEUE_LIST *l); 00796 00800 AB_USERQUEUE_LIST* AB_UserQueue_List_new(); 00801 00805 void AB_UserQueue_List_free(AB_USERQUEUE_LIST *l); 00806 00810 AB_USERQUEUE* AB_UserQueue_List_Next(const AB_USERQUEUE *element); 00811 00815 AB_USERQUEUE* AB_UserQueue_List_Previous(const AB_USERQUEUE *element); 00816 00820 uint32_t AB_UserQueue_List_GetCount(const AB_USERQUEUE_LIST *l); 00821 00825 AB_USERQUEUE_LIST_SORT_FN AB_UserQueue_List_SetSortFn(AB_USERQUEUE_LIST *l, AB_USERQUEUE_LIST_SORT_FN fn); 00826 00832 void AB_UserQueue_List_Sort(AB_USERQUEUE_LIST *l, int ascending); 00833 00834 00835 #ifdef __cplusplus 00836 } 00837 #endif 00838 00839 00840 #endif 00841 00842 00843 00844 /*************************************************************************** 00845 $RCSfile$ 00846 ------------------- 00847 cvs : $Id$ 00848 begin : Sat Jun 28 2003 00849 copyright : (C) 2003 by Martin Preuss 00850 email : martin@libchipcard.de 00851 00852 *************************************************************************** 00853 * * 00854 * This library is free software; you can redistribute it and/or * 00855 * modify it under the terms of the GNU Lesser General Public * 00856 * License as published by the Free Software Foundation; either * 00857 * version 2.1 of the License, or (at your option) any later version. * 00858 * * 00859 * This library is distributed in the hope that it will be useful, * 00860 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 00861 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 00862 * Lesser General Public License for more details. * 00863 * * 00864 * You should have received a copy of the GNU Lesser General Public * 00865 * License along with this library; if not, write to the Free Software * 00866 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 00867 * MA 02111-1307 USA * 00868 * * 00869 ***************************************************************************/ 00870 00871 00872 #ifndef AB_BANKINFO_PLUGIN_LIST2_H 00873 #define AB_BANKINFO_PLUGIN_LIST2_H 00874 00875 00876 #ifdef __cplusplus 00877 extern "C" { 00878 #endif 00879 00886 typedef struct AB_BANKINFO_PLUGIN_LIST2 AB_BANKINFO_PLUGIN_LIST2; 00887 00891 typedef struct AB_BANKINFO_PLUGIN_LIST2_ITERATOR AB_BANKINFO_PLUGIN_LIST2_ITERATOR; 00892 00896 typedef AB_BANKINFO_PLUGIN* (AB_BANKINFO_PLUGIN_LIST2_FOREACH)(AB_BANKINFO_PLUGIN *element, 00897 void *user_data); 00898 00902 AB_BANKINFO_PLUGIN_LIST2 *AB_BankInfoPlugin_List2_new(); 00903 00907 void AB_BankInfoPlugin_List2_free(AB_BANKINFO_PLUGIN_LIST2 *l); 00908 00912 void AB_BankInfoPlugin_List2_Dump(AB_BANKINFO_PLUGIN_LIST2 *l, FILE *f, unsigned int indent); 00913 00917 void AB_BankInfoPlugin_List2_PushBack(AB_BANKINFO_PLUGIN_LIST2 *l, AB_BANKINFO_PLUGIN *p); 00918 00923 void AB_BankInfoPlugin_List2_PushFront(AB_BANKINFO_PLUGIN_LIST2 *l, AB_BANKINFO_PLUGIN *p); 00924 00929 AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_List2_GetFront(AB_BANKINFO_PLUGIN_LIST2 *l); 00930 00935 AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_List2_GetBack(AB_BANKINFO_PLUGIN_LIST2 *l); 00936 00941 void AB_BankInfoPlugin_List2_Erase(AB_BANKINFO_PLUGIN_LIST2 *l, 00942 AB_BANKINFO_PLUGIN_LIST2_ITERATOR *it); 00943 00949 unsigned int AB_BankInfoPlugin_List2_GetSize(AB_BANKINFO_PLUGIN_LIST2 *l); 00950 00955 void AB_BankInfoPlugin_List2_PopBack(AB_BANKINFO_PLUGIN_LIST2 *l); 00956 00961 void AB_BankInfoPlugin_List2_PopFront(AB_BANKINFO_PLUGIN_LIST2 *l); 00962 00966 void AB_BankInfoPlugin_List2_Clear(AB_BANKINFO_PLUGIN_LIST2 *l); 00967 00971 AB_BANKINFO_PLUGIN_LIST2_ITERATOR *AB_BankInfoPlugin_List2_First(AB_BANKINFO_PLUGIN_LIST2 *l); 00972 00976 AB_BANKINFO_PLUGIN_LIST2_ITERATOR *AB_BankInfoPlugin_List2_Last(AB_BANKINFO_PLUGIN_LIST2 *l); 00977 00981 AB_BANKINFO_PLUGIN_LIST2_ITERATOR *AB_BankInfoPlugin_List2Iterator_new(AB_BANKINFO_PLUGIN_LIST2 *l); 00982 00986 void AB_BankInfoPlugin_List2Iterator_free(AB_BANKINFO_PLUGIN_LIST2_ITERATOR *li); 00987 00992 AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_List2Iterator_Previous(AB_BANKINFO_PLUGIN_LIST2_ITERATOR *li); 00993 00998 AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_List2Iterator_Next(AB_BANKINFO_PLUGIN_LIST2_ITERATOR *li); 00999 01004 AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_List2Iterator_Data(AB_BANKINFO_PLUGIN_LIST2_ITERATOR *li); 01005 01017 AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_List2_ForEach(AB_BANKINFO_PLUGIN_LIST2 *list, 01018 AB_BANKINFO_PLUGIN_LIST2_FOREACH func, 01019 void *user_data); 01020 01021 01022 typedef struct AB_BANKINFO_PLUGIN_CONSTLIST2 AB_BANKINFO_PLUGIN_CONSTLIST2; 01023 typedef struct AB_BANKINFO_PLUGIN_CONSTLIST2_ITERATOR AB_BANKINFO_PLUGIN_CONSTLIST2_ITERATOR; 01024 typedef const AB_BANKINFO_PLUGIN* 01025 (AB_BANKINFO_PLUGIN_CONSTLIST2_FOREACH)(const AB_BANKINFO_PLUGIN *element, 01026 void *user_data); 01027 01028 01029 AB_BANKINFO_PLUGIN_CONSTLIST2 *AB_BankInfoPlugin_ConstList2_new(); 01030 01031 void AB_BankInfoPlugin_ConstList2_free(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 01032 01033 void AB_BankInfoPlugin_ConstList2_PushBack(AB_BANKINFO_PLUGIN_CONSTLIST2 *l, const AB_BANKINFO_PLUGIN *p); 01034 01035 void AB_BankInfoPlugin_ConstList2_PushFront(AB_BANKINFO_PLUGIN_CONSTLIST2 *l, const AB_BANKINFO_PLUGIN *p); 01036 01037 const AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_ConstList2_GetFront(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 01038 01039 const AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_ConstList2_GetBack(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 01040 01041 unsigned int AB_BankInfoPlugin_ConstList2_GetSize(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 01042 01043 void AB_BankInfoPlugin_ConstList2_PopBack(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 01044 01045 void AB_BankInfoPlugin_ConstList2_PopFront(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 01046 01047 void AB_BankInfoPlugin_ConstList2_Clear(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 01048 01049 AB_BANKINFO_PLUGIN_CONSTLIST2_ITERATOR *AB_BankInfoPlugin_ConstList2_First(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 01050 01051 AB_BANKINFO_PLUGIN_CONSTLIST2_ITERATOR *AB_BankInfoPlugin_ConstList2_Last(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 01052 01053 AB_BANKINFO_PLUGIN_CONSTLIST2_ITERATOR *AB_BankInfoPlugin_ConstList2Iterator_new(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 01054 01055 void AB_BankInfoPlugin_ConstList2Iterator_free(AB_BANKINFO_PLUGIN_CONSTLIST2_ITERATOR *li); 01056 01057 const AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_ConstList2Iterator_Previous(AB_BANKINFO_PLUGIN_CONSTLIST2_ITERATOR *li); 01058 01059 const AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_ConstList2Iterator_Next(AB_BANKINFO_PLUGIN_CONSTLIST2_ITERATOR *li); 01060 01061 const AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_ConstList2Iterator_Data(AB_BANKINFO_PLUGIN_CONSTLIST2_ITERATOR *li); 01062 01074 const AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_ConstList2_ForEach(AB_BANKINFO_PLUGIN_CONSTLIST2 *list, 01075 AB_BANKINFO_PLUGIN_CONSTLIST2_FOREACH func, void *user_data); 01076 01077 01078 #ifdef __cplusplus 01079 } 01080 #endif 01081 01082 01083 #endif /* AB_BANKINFO_PLUGIN_LIST_H */ 01084 01085 01086 01087 /*************************************************************************** 01088 $RCSfile$ 01089 ------------------- 01090 cvs : $Id$ 01091 begin : Sat Jun 28 2003 01092 copyright : (C) 2003 by Martin Preuss 01093 email : martin@libchipcard.de 01094 01095 *************************************************************************** 01096 * * 01097 * This library is free software; you can redistribute it and/or * 01098 * modify it under the terms of the GNU Lesser General Public * 01099 * License as published by the Free Software Foundation; either * 01100 * version 2.1 of the License, or (at your option) any later version. * 01101 * * 01102 * This library is distributed in the hope that it will be useful, * 01103 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 01104 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 01105 * Lesser General Public License for more details. * 01106 * * 01107 * You should have received a copy of the GNU Lesser General Public * 01108 * License along with this library; if not, write to the Free Software * 01109 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 01110 * MA 02111-1307 USA * 01111 * * 01112 ***************************************************************************/ 01113 01114 01115 #ifndef AB_COUNTRY_LIST2_H 01116 #define AB_COUNTRY_LIST2_H 01117 01118 01119 #ifdef __cplusplus 01120 extern "C" { 01121 #endif 01122 01129 typedef struct AB_COUNTRY_LIST2 AB_COUNTRY_LIST2; 01130 01134 typedef struct AB_COUNTRY_LIST2_ITERATOR AB_COUNTRY_LIST2_ITERATOR; 01135 01139 typedef AB_COUNTRY* (AB_COUNTRY_LIST2_FOREACH)(AB_COUNTRY *element, 01140 void *user_data); 01141 01145 AB_COUNTRY_LIST2 *AB_Country_List2_new(); 01146 01150 void AB_Country_List2_free(AB_COUNTRY_LIST2 *l); 01151 01155 void AB_Country_List2_Dump(AB_COUNTRY_LIST2 *l, FILE *f, unsigned int indent); 01156 01160 void AB_Country_List2_PushBack(AB_COUNTRY_LIST2 *l, AB_COUNTRY *p); 01161 01166 void AB_Country_List2_PushFront(AB_COUNTRY_LIST2 *l, AB_COUNTRY *p); 01167 01172 AB_COUNTRY *AB_Country_List2_GetFront(AB_COUNTRY_LIST2 *l); 01173 01178 AB_COUNTRY *AB_Country_List2_GetBack(AB_COUNTRY_LIST2 *l); 01179 01184 void AB_Country_List2_Erase(AB_COUNTRY_LIST2 *l, 01185 AB_COUNTRY_LIST2_ITERATOR *it); 01186 01192 unsigned int AB_Country_List2_GetSize(AB_COUNTRY_LIST2 *l); 01193 01198 void AB_Country_List2_PopBack(AB_COUNTRY_LIST2 *l); 01199 01204 void AB_Country_List2_PopFront(AB_COUNTRY_LIST2 *l); 01205 01209 void AB_Country_List2_Clear(AB_COUNTRY_LIST2 *l); 01210 01214 AB_COUNTRY_LIST2_ITERATOR *AB_Country_List2_First(AB_COUNTRY_LIST2 *l); 01215 01219 AB_COUNTRY_LIST2_ITERATOR *AB_Country_List2_Last(AB_COUNTRY_LIST2 *l); 01220 01224 AB_COUNTRY_LIST2_ITERATOR *AB_Country_List2Iterator_new(AB_COUNTRY_LIST2 *l); 01225 01229 void AB_Country_List2Iterator_free(AB_COUNTRY_LIST2_ITERATOR *li); 01230 01235 AB_COUNTRY *AB_Country_List2Iterator_Previous(AB_COUNTRY_LIST2_ITERATOR *li); 01236 01241 AB_COUNTRY *AB_Country_List2Iterator_Next(AB_COUNTRY_LIST2_ITERATOR *li); 01242 01247 AB_COUNTRY *AB_Country_List2Iterator_Data(AB_COUNTRY_LIST2_ITERATOR *li); 01248 01260 AB_COUNTRY *AB_Country_List2_ForEach(AB_COUNTRY_LIST2 *list, 01261 AB_COUNTRY_LIST2_FOREACH func, 01262 void *user_data); 01263 01264 01265 typedef struct AB_COUNTRY_CONSTLIST2 AB_COUNTRY_CONSTLIST2; 01266 typedef struct AB_COUNTRY_CONSTLIST2_ITERATOR AB_COUNTRY_CONSTLIST2_ITERATOR; 01267 typedef const AB_COUNTRY* 01268 (AB_COUNTRY_CONSTLIST2_FOREACH)(const AB_COUNTRY *element, 01269 void *user_data); 01270 01271 01272 AB_COUNTRY_CONSTLIST2 *AB_Country_ConstList2_new(); 01273 01274 void AB_Country_ConstList2_free(AB_COUNTRY_CONSTLIST2 *l); 01275 01276 void AB_Country_ConstList2_PushBack(AB_COUNTRY_CONSTLIST2 *l, const AB_COUNTRY *p); 01277 01278 void AB_Country_ConstList2_PushFront(AB_COUNTRY_CONSTLIST2 *l, const AB_COUNTRY *p); 01279 01280 const AB_COUNTRY *AB_Country_ConstList2_GetFront(AB_COUNTRY_CONSTLIST2 *l); 01281 01282 const AB_COUNTRY *AB_Country_ConstList2_GetBack(AB_COUNTRY_CONSTLIST2 *l); 01283 01284 unsigned int AB_Country_ConstList2_GetSize(AB_COUNTRY_CONSTLIST2 *l); 01285 01286 void AB_Country_ConstList2_PopBack(AB_COUNTRY_CONSTLIST2 *l); 01287 01288 void AB_Country_ConstList2_PopFront(AB_COUNTRY_CONSTLIST2 *l); 01289 01290 void AB_Country_ConstList2_Clear(AB_COUNTRY_CONSTLIST2 *l); 01291 01292 AB_COUNTRY_CONSTLIST2_ITERATOR *AB_Country_ConstList2_First(AB_COUNTRY_CONSTLIST2 *l); 01293 01294 AB_COUNTRY_CONSTLIST2_ITERATOR *AB_Country_ConstList2_Last(AB_COUNTRY_CONSTLIST2 *l); 01295 01296 AB_COUNTRY_CONSTLIST2_ITERATOR *AB_Country_ConstList2Iterator_new(AB_COUNTRY_CONSTLIST2 *l); 01297 01298 void AB_Country_ConstList2Iterator_free(AB_COUNTRY_CONSTLIST2_ITERATOR *li); 01299 01300 const AB_COUNTRY *AB_Country_ConstList2Iterator_Previous(AB_COUNTRY_CONSTLIST2_ITERATOR *li); 01301 01302 const AB_COUNTRY *AB_Country_ConstList2Iterator_Next(AB_COUNTRY_CONSTLIST2_ITERATOR *li); 01303 01304 const AB_COUNTRY *AB_Country_ConstList2Iterator_Data(AB_COUNTRY_CONSTLIST2_ITERATOR *li); 01305 01317 const AB_COUNTRY *AB_Country_ConstList2_ForEach(AB_COUNTRY_CONSTLIST2 *list, 01318 AB_COUNTRY_CONSTLIST2_FOREACH func, void *user_data); 01319 01320 01321 #ifdef __cplusplus 01322 } 01323 #endif 01324 01325 01326 #endif /* AB_COUNTRY_LIST_H */ 01327 01328 01329 01330 /*************************************************************************** 01331 $RCSfile$ 01332 ------------------- 01333 cvs : $Id$ 01334 begin : Sat Jun 28 2003 01335 copyright : (C) 2003 by Martin Preuss 01336 email : martin@libchipcard.de 01337 01338 *************************************************************************** 01339 * * 01340 * This library is free software; you can redistribute it and/or * 01341 * modify it under the terms of the GNU Lesser General Public * 01342 * License as published by the Free Software Foundation; either * 01343 * version 2.1 of the License, or (at your option) any later version. * 01344 * * 01345 * This library is distributed in the hope that it will be useful, * 01346 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 01347 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 01348 * Lesser General Public License for more details. * 01349 * * 01350 * You should have received a copy of the GNU Lesser General Public * 01351 * License along with this library; if not, write to the Free Software * 01352 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 01353 * MA 02111-1307 USA * 01354 * * 01355 ***************************************************************************/ 01356 01357 01358 #ifndef AB_JOB_LIST2_H 01359 #define AB_JOB_LIST2_H 01360 01361 01362 #ifdef __cplusplus 01363 extern "C" { 01364 #endif 01365 01372 typedef struct AB_JOB_LIST2 AB_JOB_LIST2; 01373 01377 typedef struct AB_JOB_LIST2_ITERATOR AB_JOB_LIST2_ITERATOR; 01378 01382 typedef AB_JOB* (AB_JOB_LIST2_FOREACH)(AB_JOB *element, 01383 void *user_data); 01384 01388 AB_JOB_LIST2 *AB_Job_List2_new(); 01389 01393 void AB_Job_List2_free(AB_JOB_LIST2 *l); 01394 01398 void AB_Job_List2_Dump(AB_JOB_LIST2 *l, FILE *f, unsigned int indent); 01399 01403 void AB_Job_List2_PushBack(AB_JOB_LIST2 *l, AB_JOB *p); 01404 01409 void AB_Job_List2_PushFront(AB_JOB_LIST2 *l, AB_JOB *p); 01410 01415 AB_JOB *AB_Job_List2_GetFront(AB_JOB_LIST2 *l); 01416 01421 AB_JOB *AB_Job_List2_GetBack(AB_JOB_LIST2 *l); 01422 01427 void AB_Job_List2_Erase(AB_JOB_LIST2 *l, 01428 AB_JOB_LIST2_ITERATOR *it); 01429 01435 unsigned int AB_Job_List2_GetSize(AB_JOB_LIST2 *l); 01436 01441 void AB_Job_List2_PopBack(AB_JOB_LIST2 *l); 01442 01447 void AB_Job_List2_PopFront(AB_JOB_LIST2 *l); 01448 01452 void AB_Job_List2_Clear(AB_JOB_LIST2 *l); 01453 01457 AB_JOB_LIST2_ITERATOR *AB_Job_List2_First(AB_JOB_LIST2 *l); 01458 01462 AB_JOB_LIST2_ITERATOR *AB_Job_List2_Last(AB_JOB_LIST2 *l); 01463 01467 AB_JOB_LIST2_ITERATOR *AB_Job_List2Iterator_new(AB_JOB_LIST2 *l); 01468 01472 void AB_Job_List2Iterator_free(AB_JOB_LIST2_ITERATOR *li); 01473 01478 AB_JOB *AB_Job_List2Iterator_Previous(AB_JOB_LIST2_ITERATOR *li); 01479 01484 AB_JOB *AB_Job_List2Iterator_Next(AB_JOB_LIST2_ITERATOR *li); 01485 01490 AB_JOB *AB_Job_List2Iterator_Data(AB_JOB_LIST2_ITERATOR *li); 01491 01503 AB_JOB *AB_Job_List2_ForEach(AB_JOB_LIST2 *list, 01504 AB_JOB_LIST2_FOREACH func, 01505 void *user_data); 01506 01507 01508 typedef struct AB_JOB_CONSTLIST2 AB_JOB_CONSTLIST2; 01509 typedef struct AB_JOB_CONSTLIST2_ITERATOR AB_JOB_CONSTLIST2_ITERATOR; 01510 typedef const AB_JOB* 01511 (AB_JOB_CONSTLIST2_FOREACH)(const AB_JOB *element, 01512 void *user_data); 01513 01514 01515 AB_JOB_CONSTLIST2 *AB_Job_ConstList2_new(); 01516 01517 void AB_Job_ConstList2_free(AB_JOB_CONSTLIST2 *l); 01518 01519 void AB_Job_ConstList2_PushBack(AB_JOB_CONSTLIST2 *l, const AB_JOB *p); 01520 01521 void AB_Job_ConstList2_PushFront(AB_JOB_CONSTLIST2 *l, const AB_JOB *p); 01522 01523 const AB_JOB *AB_Job_ConstList2_GetFront(AB_JOB_CONSTLIST2 *l); 01524 01525 const AB_JOB *AB_Job_ConstList2_GetBack(AB_JOB_CONSTLIST2 *l); 01526 01527 unsigned int AB_Job_ConstList2_GetSize(AB_JOB_CONSTLIST2 *l); 01528 01529 void AB_Job_ConstList2_PopBack(AB_JOB_CONSTLIST2 *l); 01530 01531 void AB_Job_ConstList2_PopFront(AB_JOB_CONSTLIST2 *l); 01532 01533 void AB_Job_ConstList2_Clear(AB_JOB_CONSTLIST2 *l); 01534 01535 AB_JOB_CONSTLIST2_ITERATOR *AB_Job_ConstList2_First(AB_JOB_CONSTLIST2 *l); 01536 01537 AB_JOB_CONSTLIST2_ITERATOR *AB_Job_ConstList2_Last(AB_JOB_CONSTLIST2 *l); 01538 01539 AB_JOB_CONSTLIST2_ITERATOR *AB_Job_ConstList2Iterator_new(AB_JOB_CONSTLIST2 *l); 01540 01541 void AB_Job_ConstList2Iterator_free(AB_JOB_CONSTLIST2_ITERATOR *li); 01542 01543 const AB_JOB *AB_Job_ConstList2Iterator_Previous(AB_JOB_CONSTLIST2_ITERATOR *li); 01544 01545 const AB_JOB *AB_Job_ConstList2Iterator_Next(AB_JOB_CONSTLIST2_ITERATOR *li); 01546 01547 const AB_JOB *AB_Job_ConstList2Iterator_Data(AB_JOB_CONSTLIST2_ITERATOR *li); 01548 01560 const AB_JOB *AB_Job_ConstList2_ForEach(AB_JOB_CONSTLIST2 *list, 01561 AB_JOB_CONSTLIST2_FOREACH func, void *user_data); 01562 01563 01564 #ifdef __cplusplus 01565 } 01566 #endif 01567 01568 01569 #endif /* AB_JOB_LIST_H */ 01570 01571 01572 01573 /*************************************************************************** 01574 $RCSfile$ 01575 ------------------- 01576 cvs : $Id$ 01577 begin : Sat Jun 28 2003 01578 copyright : (C) 2003 by Martin Preuss 01579 email : martin@libchipcard.de 01580 01581 *************************************************************************** 01582 * * 01583 * This library is free software; you can redistribute it and/or * 01584 * modify it under the terms of the GNU Lesser General Public * 01585 * License as published by the Free Software Foundation; either * 01586 * version 2.1 of the License, or (at your option) any later version. * 01587 * * 01588 * This library is distributed in the hope that it will be useful, * 01589 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 01590 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 01591 * Lesser General Public License for more details. * 01592 * * 01593 * You should have received a copy of the GNU Lesser General Public * 01594 * License along with this library; if not, write to the Free Software * 01595 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 01596 * MA 02111-1307 USA * 01597 * * 01598 ***************************************************************************/ 01599 01600 01601 #ifndef AB_PROVIDER_DESCRIPTION_LIST2_H 01602 #define AB_PROVIDER_DESCRIPTION_LIST2_H 01603 01604 01605 #ifdef __cplusplus 01606 extern "C" { 01607 #endif 01608 01615 typedef struct AB_PROVIDER_DESCRIPTION_LIST2 AB_PROVIDER_DESCRIPTION_LIST2; 01616 01620 typedef struct AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR; 01621 01625 typedef AB_PROVIDER_DESCRIPTION* (AB_PROVIDER_DESCRIPTION_LIST2_FOREACH)(AB_PROVIDER_DESCRIPTION *element, 01626 void *user_data); 01627 01631 AB_PROVIDER_DESCRIPTION_LIST2 *AB_ProviderDescription_List2_new(); 01632 01636 void AB_ProviderDescription_List2_free(AB_PROVIDER_DESCRIPTION_LIST2 *l); 01637 01641 void AB_ProviderDescription_List2_Dump(AB_PROVIDER_DESCRIPTION_LIST2 *l, FILE *f, unsigned int indent); 01642 01646 void AB_ProviderDescription_List2_PushBack(AB_PROVIDER_DESCRIPTION_LIST2 *l, AB_PROVIDER_DESCRIPTION *p); 01647 01652 void AB_ProviderDescription_List2_PushFront(AB_PROVIDER_DESCRIPTION_LIST2 *l, AB_PROVIDER_DESCRIPTION *p); 01653 01658 AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_List2_GetFront(AB_PROVIDER_DESCRIPTION_LIST2 *l); 01659 01664 AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_List2_GetBack(AB_PROVIDER_DESCRIPTION_LIST2 *l); 01665 01670 void AB_ProviderDescription_List2_Erase(AB_PROVIDER_DESCRIPTION_LIST2 *l, 01671 AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR *it); 01672 01678 unsigned int AB_ProviderDescription_List2_GetSize(AB_PROVIDER_DESCRIPTION_LIST2 *l); 01679 01684 void AB_ProviderDescription_List2_PopBack(AB_PROVIDER_DESCRIPTION_LIST2 *l); 01685 01690 void AB_ProviderDescription_List2_PopFront(AB_PROVIDER_DESCRIPTION_LIST2 *l); 01691 01695 void AB_ProviderDescription_List2_Clear(AB_PROVIDER_DESCRIPTION_LIST2 *l); 01696 01700 AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR *AB_ProviderDescription_List2_First(AB_PROVIDER_DESCRIPTION_LIST2 *l); 01701 01705 AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR *AB_ProviderDescription_List2_Last(AB_PROVIDER_DESCRIPTION_LIST2 *l); 01706 01710 AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR *AB_ProviderDescription_List2Iterator_new(AB_PROVIDER_DESCRIPTION_LIST2 *l); 01711 01715 void AB_ProviderDescription_List2Iterator_free(AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR *li); 01716 01721 AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_List2Iterator_Previous(AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR *li); 01722 01727 AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_List2Iterator_Next(AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR *li); 01728 01733 AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_List2Iterator_Data(AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR *li); 01734 01746 AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_List2_ForEach(AB_PROVIDER_DESCRIPTION_LIST2 *list, 01747 AB_PROVIDER_DESCRIPTION_LIST2_FOREACH func, 01748 void *user_data); 01749 01750 01751 typedef struct AB_PROVIDER_DESCRIPTION_CONSTLIST2 AB_PROVIDER_DESCRIPTION_CONSTLIST2; 01752 typedef struct AB_PROVIDER_DESCRIPTION_CONSTLIST2_ITERATOR AB_PROVIDER_DESCRIPTION_CONSTLIST2_ITERATOR; 01753 typedef const AB_PROVIDER_DESCRIPTION* 01754 (AB_PROVIDER_DESCRIPTION_CONSTLIST2_FOREACH)(const AB_PROVIDER_DESCRIPTION *element, 01755 void *user_data); 01756 01757 01758 AB_PROVIDER_DESCRIPTION_CONSTLIST2 *AB_ProviderDescription_ConstList2_new(); 01759 01760 void AB_ProviderDescription_ConstList2_free(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 01761 01762 void AB_ProviderDescription_ConstList2_PushBack(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l, const AB_PROVIDER_DESCRIPTION *p); 01763 01764 void AB_ProviderDescription_ConstList2_PushFront(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l, const AB_PROVIDER_DESCRIPTION *p); 01765 01766 const AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_ConstList2_GetFront(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 01767 01768 const AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_ConstList2_GetBack(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 01769 01770 unsigned int AB_ProviderDescription_ConstList2_GetSize(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 01771 01772 void AB_ProviderDescription_ConstList2_PopBack(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 01773 01774 void AB_ProviderDescription_ConstList2_PopFront(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 01775 01776 void AB_ProviderDescription_ConstList2_Clear(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 01777 01778 AB_PROVIDER_DESCRIPTION_CONSTLIST2_ITERATOR *AB_ProviderDescription_ConstList2_First(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 01779 01780 AB_PROVIDER_DESCRIPTION_CONSTLIST2_ITERATOR *AB_ProviderDescription_ConstList2_Last(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 01781 01782 AB_PROVIDER_DESCRIPTION_CONSTLIST2_ITERATOR *AB_ProviderDescription_ConstList2Iterator_new(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 01783 01784 void AB_ProviderDescription_ConstList2Iterator_free(AB_PROVIDER_DESCRIPTION_CONSTLIST2_ITERATOR *li); 01785 01786 const AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_ConstList2Iterator_Previous(AB_PROVIDER_DESCRIPTION_CONSTLIST2_ITERATOR *li); 01787 01788 const AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_ConstList2Iterator_Next(AB_PROVIDER_DESCRIPTION_CONSTLIST2_ITERATOR *li); 01789 01790 const AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_ConstList2Iterator_Data(AB_PROVIDER_DESCRIPTION_CONSTLIST2_ITERATOR *li); 01791 01803 const AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_ConstList2_ForEach(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *list, 01804 AB_PROVIDER_DESCRIPTION_CONSTLIST2_FOREACH func, void *user_data); 01805 01806 01807 #ifdef __cplusplus 01808 } 01809 #endif 01810 01811 01812 #endif /* AB_PROVIDER_DESCRIPTION_LIST_H */ 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_PROVIDER_DESCRIPTION_LIST1_H 01845 #define AB_PROVIDER_DESCRIPTION_LIST1_H 01846 01847 #ifdef __cplusplus 01848 extern "C" { 01849 #endif 01850 01852 typedef struct AB_PROVIDER_DESCRIPTION_LIST_ELEMENT { 01853 uint32_t id; 01854 AB_PROVIDER_DESCRIPTION *nextObject; 01855 } AB_PROVIDER_DESCRIPTION_LIST__ELEMENT; 01856 01863 typedef struct AB_PROVIDER_DESCRIPTION_LIST AB_PROVIDER_DESCRIPTION_LIST; 01864 01868 typedef int GWENHYWFAR_CB (*AB_PROVIDER_DESCRIPTION_LIST_SORT_FN)(const AB_PROVIDER_DESCRIPTION *a, const AB_PROVIDER_DESCRIPTION *b, int ascending); 01869 01870 01872 struct AB_PROVIDER_DESCRIPTION_LIST { 01873 AB_PROVIDER_DESCRIPTION *first; 01874 uint32_t count; 01875 uint32_t id; 01876 } AB_PROVIDER_DESCRIPTION_LIST; 01877 01882 void AB_ProviderDescription_List_AddList(AB_PROVIDER_DESCRIPTION_LIST *dst, AB_PROVIDER_DESCRIPTION_LIST *l); 01883 01887 void AB_ProviderDescription_List_Add(AB_PROVIDER_DESCRIPTION *element, AB_PROVIDER_DESCRIPTION_LIST *list); 01888 01893 void AB_ProviderDescription_List_Insert(AB_PROVIDER_DESCRIPTION *element, AB_PROVIDER_DESCRIPTION_LIST *list); 01894 01901 void AB_ProviderDescription_List_Del(AB_PROVIDER_DESCRIPTION *element); 01902 01906 AB_PROVIDER_DESCRIPTION* AB_ProviderDescription_List_First(const AB_PROVIDER_DESCRIPTION_LIST *l); 01907 01911 AB_PROVIDER_DESCRIPTION* AB_ProviderDescription_List_Last(const AB_PROVIDER_DESCRIPTION_LIST *l); 01912 01917 void AB_ProviderDescription_List_Clear(AB_PROVIDER_DESCRIPTION_LIST *l); 01918 01922 AB_PROVIDER_DESCRIPTION_LIST* AB_ProviderDescription_List_new(); 01923 01927 void AB_ProviderDescription_List_free(AB_PROVIDER_DESCRIPTION_LIST *l); 01928 01932 AB_PROVIDER_DESCRIPTION* AB_ProviderDescription_List_Next(const AB_PROVIDER_DESCRIPTION *element); 01933 01937 AB_PROVIDER_DESCRIPTION* AB_ProviderDescription_List_Previous(const AB_PROVIDER_DESCRIPTION *element); 01938 01942 uint32_t AB_ProviderDescription_List_GetCount(const AB_PROVIDER_DESCRIPTION_LIST *l); 01943 01947 AB_PROVIDER_DESCRIPTION_LIST_SORT_FN AB_ProviderDescription_List_SetSortFn(AB_PROVIDER_DESCRIPTION_LIST *l, AB_PROVIDER_DESCRIPTION_LIST_SORT_FN fn); 01948 01954 void AB_ProviderDescription_List_Sort(AB_PROVIDER_DESCRIPTION_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_BANKINFO_LIST2_H 02238 #define AB_BANKINFO_LIST2_H 02239 02240 02241 #ifdef __cplusplus 02242 extern "C" { 02243 #endif 02244 02251 typedef struct AB_BANKINFO_LIST2 AB_BANKINFO_LIST2; 02252 02256 typedef struct AB_BANKINFO_LIST2_ITERATOR AB_BANKINFO_LIST2_ITERATOR; 02257 02261 typedef AB_BANKINFO* (AB_BANKINFO_LIST2_FOREACH)(AB_BANKINFO *element, 02262 void *user_data); 02263 02267 AB_BANKINFO_LIST2 *AB_BankInfo_List2_new(); 02268 02272 void AB_BankInfo_List2_free(AB_BANKINFO_LIST2 *l); 02273 02277 void AB_BankInfo_List2_Dump(AB_BANKINFO_LIST2 *l, FILE *f, unsigned int indent); 02278 02282 void AB_BankInfo_List2_PushBack(AB_BANKINFO_LIST2 *l, AB_BANKINFO *p); 02283 02288 void AB_BankInfo_List2_PushFront(AB_BANKINFO_LIST2 *l, AB_BANKINFO *p); 02289 02294 AB_BANKINFO *AB_BankInfo_List2_GetFront(AB_BANKINFO_LIST2 *l); 02295 02300 AB_BANKINFO *AB_BankInfo_List2_GetBack(AB_BANKINFO_LIST2 *l); 02301 02306 void AB_BankInfo_List2_Erase(AB_BANKINFO_LIST2 *l, 02307 AB_BANKINFO_LIST2_ITERATOR *it); 02308 02314 unsigned int AB_BankInfo_List2_GetSize(AB_BANKINFO_LIST2 *l); 02315 02320 void AB_BankInfo_List2_PopBack(AB_BANKINFO_LIST2 *l); 02321 02326 void AB_BankInfo_List2_PopFront(AB_BANKINFO_LIST2 *l); 02327 02331 void AB_BankInfo_List2_Clear(AB_BANKINFO_LIST2 *l); 02332 02336 AB_BANKINFO_LIST2_ITERATOR *AB_BankInfo_List2_First(AB_BANKINFO_LIST2 *l); 02337 02341 AB_BANKINFO_LIST2_ITERATOR *AB_BankInfo_List2_Last(AB_BANKINFO_LIST2 *l); 02342 02346 AB_BANKINFO_LIST2_ITERATOR *AB_BankInfo_List2Iterator_new(AB_BANKINFO_LIST2 *l); 02347 02351 void AB_BankInfo_List2Iterator_free(AB_BANKINFO_LIST2_ITERATOR *li); 02352 02357 AB_BANKINFO *AB_BankInfo_List2Iterator_Previous(AB_BANKINFO_LIST2_ITERATOR *li); 02358 02363 AB_BANKINFO *AB_BankInfo_List2Iterator_Next(AB_BANKINFO_LIST2_ITERATOR *li); 02364 02369 AB_BANKINFO *AB_BankInfo_List2Iterator_Data(AB_BANKINFO_LIST2_ITERATOR *li); 02370 02382 AB_BANKINFO *AB_BankInfo_List2_ForEach(AB_BANKINFO_LIST2 *list, 02383 AB_BANKINFO_LIST2_FOREACH func, 02384 void *user_data); 02385 02386 02387 typedef struct AB_BANKINFO_CONSTLIST2 AB_BANKINFO_CONSTLIST2; 02388 typedef struct AB_BANKINFO_CONSTLIST2_ITERATOR AB_BANKINFO_CONSTLIST2_ITERATOR; 02389 typedef const AB_BANKINFO* 02390 (AB_BANKINFO_CONSTLIST2_FOREACH)(const AB_BANKINFO *element, 02391 void *user_data); 02392 02393 02394 AB_BANKINFO_CONSTLIST2 *AB_BankInfo_ConstList2_new(); 02395 02396 void AB_BankInfo_ConstList2_free(AB_BANKINFO_CONSTLIST2 *l); 02397 02398 void AB_BankInfo_ConstList2_PushBack(AB_BANKINFO_CONSTLIST2 *l, const AB_BANKINFO *p); 02399 02400 void AB_BankInfo_ConstList2_PushFront(AB_BANKINFO_CONSTLIST2 *l, const AB_BANKINFO *p); 02401 02402 const AB_BANKINFO *AB_BankInfo_ConstList2_GetFront(AB_BANKINFO_CONSTLIST2 *l); 02403 02404 const AB_BANKINFO *AB_BankInfo_ConstList2_GetBack(AB_BANKINFO_CONSTLIST2 *l); 02405 02406 unsigned int AB_BankInfo_ConstList2_GetSize(AB_BANKINFO_CONSTLIST2 *l); 02407 02408 void AB_BankInfo_ConstList2_PopBack(AB_BANKINFO_CONSTLIST2 *l); 02409 02410 void AB_BankInfo_ConstList2_PopFront(AB_BANKINFO_CONSTLIST2 *l); 02411 02412 void AB_BankInfo_ConstList2_Clear(AB_BANKINFO_CONSTLIST2 *l); 02413 02414 AB_BANKINFO_CONSTLIST2_ITERATOR *AB_BankInfo_ConstList2_First(AB_BANKINFO_CONSTLIST2 *l); 02415 02416 AB_BANKINFO_CONSTLIST2_ITERATOR *AB_BankInfo_ConstList2_Last(AB_BANKINFO_CONSTLIST2 *l); 02417 02418 AB_BANKINFO_CONSTLIST2_ITERATOR *AB_BankInfo_ConstList2Iterator_new(AB_BANKINFO_CONSTLIST2 *l); 02419 02420 void AB_BankInfo_ConstList2Iterator_free(AB_BANKINFO_CONSTLIST2_ITERATOR *li); 02421 02422 const AB_BANKINFO *AB_BankInfo_ConstList2Iterator_Previous(AB_BANKINFO_CONSTLIST2_ITERATOR *li); 02423 02424 const AB_BANKINFO *AB_BankInfo_ConstList2Iterator_Next(AB_BANKINFO_CONSTLIST2_ITERATOR *li); 02425 02426 const AB_BANKINFO *AB_BankInfo_ConstList2Iterator_Data(AB_BANKINFO_CONSTLIST2_ITERATOR *li); 02427 02439 const AB_BANKINFO *AB_BankInfo_ConstList2_ForEach(AB_BANKINFO_CONSTLIST2 *list, 02440 AB_BANKINFO_CONSTLIST2_FOREACH func, void *user_data); 02441 02442 02443 #ifdef __cplusplus 02444 } 02445 #endif 02446 02447 02448 #endif /* AB_BANKINFO_LIST_H */ 02449 02450 02451 02452 /*************************************************************************** 02453 $RCSfile$ 02454 ------------------- 02455 cvs : $Id$ 02456 begin : Sat Jun 28 2003 02457 copyright : (C) 2003 by Martin Preuss 02458 email : martin@libchipcard.de 02459 02460 *************************************************************************** 02461 * * 02462 * This library is free software; you can redistribute it and/or * 02463 * modify it under the terms of the GNU Lesser General Public * 02464 * License as published by the Free Software Foundation; either * 02465 * version 2.1 of the License, or (at your option) any later version. * 02466 * * 02467 * This library is distributed in the hope that it will be useful, * 02468 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 02469 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 02470 * Lesser General Public License for more details. * 02471 * * 02472 * You should have received a copy of the GNU Lesser General Public * 02473 * License along with this library; if not, write to the Free Software * 02474 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 02475 * MA 02111-1307 USA * 02476 * * 02477 ***************************************************************************/ 02478 02479 02480 #ifndef AB_BANKINFO_LIST1_H 02481 #define AB_BANKINFO_LIST1_H 02482 02483 #ifdef __cplusplus 02484 extern "C" { 02485 #endif 02486 02488 typedef struct AB_BANKINFO_LIST_ELEMENT { 02489 uint32_t id; 02490 AB_BANKINFO *nextObject; 02491 } AB_BANKINFO_LIST__ELEMENT; 02492 02499 typedef struct AB_BANKINFO_LIST AB_BANKINFO_LIST; 02500 02504 typedef int GWENHYWFAR_CB (*AB_BANKINFO_LIST_SORT_FN)(const AB_BANKINFO *a, const AB_BANKINFO *b, int ascending); 02505 02506 02508 struct AB_BANKINFO_LIST { 02509 AB_BANKINFO *first; 02510 uint32_t count; 02511 uint32_t id; 02512 } AB_BANKINFO_LIST; 02513 02518 void AB_BankInfo_List_AddList(AB_BANKINFO_LIST *dst, AB_BANKINFO_LIST *l); 02519 02523 void AB_BankInfo_List_Add(AB_BANKINFO *element, AB_BANKINFO_LIST *list); 02524 02529 void AB_BankInfo_List_Insert(AB_BANKINFO *element, AB_BANKINFO_LIST *list); 02530 02537 void AB_BankInfo_List_Del(AB_BANKINFO *element); 02538 02542 AB_BANKINFO* AB_BankInfo_List_First(const AB_BANKINFO_LIST *l); 02543 02547 AB_BANKINFO* AB_BankInfo_List_Last(const AB_BANKINFO_LIST *l); 02548 02553 void AB_BankInfo_List_Clear(AB_BANKINFO_LIST *l); 02554 02558 AB_BANKINFO_LIST* AB_BankInfo_List_new(); 02559 02563 void AB_BankInfo_List_free(AB_BANKINFO_LIST *l); 02564 02568 AB_BANKINFO* AB_BankInfo_List_Next(const AB_BANKINFO *element); 02569 02573 AB_BANKINFO* AB_BankInfo_List_Previous(const AB_BANKINFO *element); 02574 02578 uint32_t AB_BankInfo_List_GetCount(const AB_BANKINFO_LIST *l); 02579 02583 AB_BANKINFO_LIST_SORT_FN AB_BankInfo_List_SetSortFn(AB_BANKINFO_LIST *l, AB_BANKINFO_LIST_SORT_FN fn); 02584 02590 void AB_BankInfo_List_Sort(AB_BANKINFO_LIST *l, int ascending); 02591 02592 02593 #ifdef __cplusplus 02594 } 02595 #endif 02596 02597 02598 #endif 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_BANKINFO_SERVICE_LIST2_H 02631 #define AB_BANKINFO_SERVICE_LIST2_H 02632 02633 02634 #ifdef __cplusplus 02635 extern "C" { 02636 #endif 02637 02644 typedef struct AB_BANKINFO_SERVICE_LIST2 AB_BANKINFO_SERVICE_LIST2; 02645 02649 typedef struct AB_BANKINFO_SERVICE_LIST2_ITERATOR AB_BANKINFO_SERVICE_LIST2_ITERATOR; 02650 02654 typedef AB_BANKINFO_SERVICE* (AB_BANKINFO_SERVICE_LIST2_FOREACH)(AB_BANKINFO_SERVICE *element, 02655 void *user_data); 02656 02660 AB_BANKINFO_SERVICE_LIST2 *AB_BankInfoService_List2_new(); 02661 02665 void AB_BankInfoService_List2_free(AB_BANKINFO_SERVICE_LIST2 *l); 02666 02670 void AB_BankInfoService_List2_Dump(AB_BANKINFO_SERVICE_LIST2 *l, FILE *f, unsigned int indent); 02671 02675 void AB_BankInfoService_List2_PushBack(AB_BANKINFO_SERVICE_LIST2 *l, AB_BANKINFO_SERVICE *p); 02676 02681 void AB_BankInfoService_List2_PushFront(AB_BANKINFO_SERVICE_LIST2 *l, AB_BANKINFO_SERVICE *p); 02682 02687 AB_BANKINFO_SERVICE *AB_BankInfoService_List2_GetFront(AB_BANKINFO_SERVICE_LIST2 *l); 02688 02693 AB_BANKINFO_SERVICE *AB_BankInfoService_List2_GetBack(AB_BANKINFO_SERVICE_LIST2 *l); 02694 02699 void AB_BankInfoService_List2_Erase(AB_BANKINFO_SERVICE_LIST2 *l, 02700 AB_BANKINFO_SERVICE_LIST2_ITERATOR *it); 02701 02707 unsigned int AB_BankInfoService_List2_GetSize(AB_BANKINFO_SERVICE_LIST2 *l); 02708 02713 void AB_BankInfoService_List2_PopBack(AB_BANKINFO_SERVICE_LIST2 *l); 02714 02719 void AB_BankInfoService_List2_PopFront(AB_BANKINFO_SERVICE_LIST2 *l); 02720 02724 void AB_BankInfoService_List2_Clear(AB_BANKINFO_SERVICE_LIST2 *l); 02725 02729 AB_BANKINFO_SERVICE_LIST2_ITERATOR *AB_BankInfoService_List2_First(AB_BANKINFO_SERVICE_LIST2 *l); 02730 02734 AB_BANKINFO_SERVICE_LIST2_ITERATOR *AB_BankInfoService_List2_Last(AB_BANKINFO_SERVICE_LIST2 *l); 02735 02739 AB_BANKINFO_SERVICE_LIST2_ITERATOR *AB_BankInfoService_List2Iterator_new(AB_BANKINFO_SERVICE_LIST2 *l); 02740 02744 void AB_BankInfoService_List2Iterator_free(AB_BANKINFO_SERVICE_LIST2_ITERATOR *li); 02745 02750 AB_BANKINFO_SERVICE *AB_BankInfoService_List2Iterator_Previous(AB_BANKINFO_SERVICE_LIST2_ITERATOR *li); 02751 02756 AB_BANKINFO_SERVICE *AB_BankInfoService_List2Iterator_Next(AB_BANKINFO_SERVICE_LIST2_ITERATOR *li); 02757 02762 AB_BANKINFO_SERVICE *AB_BankInfoService_List2Iterator_Data(AB_BANKINFO_SERVICE_LIST2_ITERATOR *li); 02763 02775 AB_BANKINFO_SERVICE *AB_BankInfoService_List2_ForEach(AB_BANKINFO_SERVICE_LIST2 *list, 02776 AB_BANKINFO_SERVICE_LIST2_FOREACH func, 02777 void *user_data); 02778 02779 02780 typedef struct AB_BANKINFO_SERVICE_CONSTLIST2 AB_BANKINFO_SERVICE_CONSTLIST2; 02781 typedef struct AB_BANKINFO_SERVICE_CONSTLIST2_ITERATOR AB_BANKINFO_SERVICE_CONSTLIST2_ITERATOR; 02782 typedef const AB_BANKINFO_SERVICE* 02783 (AB_BANKINFO_SERVICE_CONSTLIST2_FOREACH)(const AB_BANKINFO_SERVICE *element, 02784 void *user_data); 02785 02786 02787 AB_BANKINFO_SERVICE_CONSTLIST2 *AB_BankInfoService_ConstList2_new(); 02788 02789 void AB_BankInfoService_ConstList2_free(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 02790 02791 void AB_BankInfoService_ConstList2_PushBack(AB_BANKINFO_SERVICE_CONSTLIST2 *l, const AB_BANKINFO_SERVICE *p); 02792 02793 void AB_BankInfoService_ConstList2_PushFront(AB_BANKINFO_SERVICE_CONSTLIST2 *l, const AB_BANKINFO_SERVICE *p); 02794 02795 const AB_BANKINFO_SERVICE *AB_BankInfoService_ConstList2_GetFront(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 02796 02797 const AB_BANKINFO_SERVICE *AB_BankInfoService_ConstList2_GetBack(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 02798 02799 unsigned int AB_BankInfoService_ConstList2_GetSize(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 02800 02801 void AB_BankInfoService_ConstList2_PopBack(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 02802 02803 void AB_BankInfoService_ConstList2_PopFront(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 02804 02805 void AB_BankInfoService_ConstList2_Clear(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 02806 02807 AB_BANKINFO_SERVICE_CONSTLIST2_ITERATOR *AB_BankInfoService_ConstList2_First(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 02808 02809 AB_BANKINFO_SERVICE_CONSTLIST2_ITERATOR *AB_BankInfoService_ConstList2_Last(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 02810 02811 AB_BANKINFO_SERVICE_CONSTLIST2_ITERATOR *AB_BankInfoService_ConstList2Iterator_new(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 02812 02813 void AB_BankInfoService_ConstList2Iterator_free(AB_BANKINFO_SERVICE_CONSTLIST2_ITERATOR *li); 02814 02815 const AB_BANKINFO_SERVICE *AB_BankInfoService_ConstList2Iterator_Previous(AB_BANKINFO_SERVICE_CONSTLIST2_ITERATOR *li); 02816 02817 const AB_BANKINFO_SERVICE *AB_BankInfoService_ConstList2Iterator_Next(AB_BANKINFO_SERVICE_CONSTLIST2_ITERATOR *li); 02818 02819 const AB_BANKINFO_SERVICE *AB_BankInfoService_ConstList2Iterator_Data(AB_BANKINFO_SERVICE_CONSTLIST2_ITERATOR *li); 02820 02832 const AB_BANKINFO_SERVICE *AB_BankInfoService_ConstList2_ForEach(AB_BANKINFO_SERVICE_CONSTLIST2 *list, 02833 AB_BANKINFO_SERVICE_CONSTLIST2_FOREACH func, void *user_data); 02834 02835 02836 #ifdef __cplusplus 02837 } 02838 #endif 02839 02840 02841 #endif /* AB_BANKINFO_SERVICE_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_BANKINFO_SERVICE_LIST1_H 02874 #define AB_BANKINFO_SERVICE_LIST1_H 02875 02876 #ifdef __cplusplus 02877 extern "C" { 02878 #endif 02879 02881 typedef struct AB_BANKINFO_SERVICE_LIST_ELEMENT { 02882 uint32_t id; 02883 AB_BANKINFO_SERVICE *nextObject; 02884 } AB_BANKINFO_SERVICE_LIST__ELEMENT; 02885 02892 typedef struct AB_BANKINFO_SERVICE_LIST AB_BANKINFO_SERVICE_LIST; 02893 02897 typedef int GWENHYWFAR_CB (*AB_BANKINFO_SERVICE_LIST_SORT_FN)(const AB_BANKINFO_SERVICE *a, const AB_BANKINFO_SERVICE *b, int ascending); 02898 02899 02901 struct AB_BANKINFO_SERVICE_LIST { 02902 AB_BANKINFO_SERVICE *first; 02903 uint32_t count; 02904 uint32_t id; 02905 } AB_BANKINFO_SERVICE_LIST; 02906 02911 void AB_BankInfoService_List_AddList(AB_BANKINFO_SERVICE_LIST *dst, AB_BANKINFO_SERVICE_LIST *l); 02912 02916 void AB_BankInfoService_List_Add(AB_BANKINFO_SERVICE *element, AB_BANKINFO_SERVICE_LIST *list); 02917 02922 void AB_BankInfoService_List_Insert(AB_BANKINFO_SERVICE *element, AB_BANKINFO_SERVICE_LIST *list); 02923 02930 void AB_BankInfoService_List_Del(AB_BANKINFO_SERVICE *element); 02931 02935 AB_BANKINFO_SERVICE* AB_BankInfoService_List_First(const AB_BANKINFO_SERVICE_LIST *l); 02936 02940 AB_BANKINFO_SERVICE* AB_BankInfoService_List_Last(const AB_BANKINFO_SERVICE_LIST *l); 02941 02946 void AB_BankInfoService_List_Clear(AB_BANKINFO_SERVICE_LIST *l); 02947 02951 AB_BANKINFO_SERVICE_LIST* AB_BankInfoService_List_new(); 02952 02956 void AB_BankInfoService_List_free(AB_BANKINFO_SERVICE_LIST *l); 02957 02961 AB_BANKINFO_SERVICE* AB_BankInfoService_List_Next(const AB_BANKINFO_SERVICE *element); 02962 02966 AB_BANKINFO_SERVICE* AB_BankInfoService_List_Previous(const AB_BANKINFO_SERVICE *element); 02967 02971 uint32_t AB_BankInfoService_List_GetCount(const AB_BANKINFO_SERVICE_LIST *l); 02972 02976 AB_BANKINFO_SERVICE_LIST_SORT_FN AB_BankInfoService_List_SetSortFn(AB_BANKINFO_SERVICE_LIST *l, AB_BANKINFO_SERVICE_LIST_SORT_FN fn); 02977 02983 void AB_BankInfoService_List_Sort(AB_BANKINFO_SERVICE_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_EUTRANSFER_INFO_LIST2_H 03417 #define AB_EUTRANSFER_INFO_LIST2_H 03418 03419 03420 #ifdef __cplusplus 03421 extern "C" { 03422 #endif 03423 03430 typedef struct AB_EUTRANSFER_INFO_LIST2 AB_EUTRANSFER_INFO_LIST2; 03431 03435 typedef struct AB_EUTRANSFER_INFO_LIST2_ITERATOR AB_EUTRANSFER_INFO_LIST2_ITERATOR; 03436 03440 typedef AB_EUTRANSFER_INFO* (AB_EUTRANSFER_INFO_LIST2_FOREACH)(AB_EUTRANSFER_INFO *element, 03441 void *user_data); 03442 03446 AB_EUTRANSFER_INFO_LIST2 *AB_EuTransferInfo_List2_new(); 03447 03451 void AB_EuTransferInfo_List2_free(AB_EUTRANSFER_INFO_LIST2 *l); 03452 03456 void AB_EuTransferInfo_List2_Dump(AB_EUTRANSFER_INFO_LIST2 *l, FILE *f, unsigned int indent); 03457 03461 void AB_EuTransferInfo_List2_PushBack(AB_EUTRANSFER_INFO_LIST2 *l, AB_EUTRANSFER_INFO *p); 03462 03467 void AB_EuTransferInfo_List2_PushFront(AB_EUTRANSFER_INFO_LIST2 *l, AB_EUTRANSFER_INFO *p); 03468 03473 AB_EUTRANSFER_INFO *AB_EuTransferInfo_List2_GetFront(AB_EUTRANSFER_INFO_LIST2 *l); 03474 03479 AB_EUTRANSFER_INFO *AB_EuTransferInfo_List2_GetBack(AB_EUTRANSFER_INFO_LIST2 *l); 03480 03485 void AB_EuTransferInfo_List2_Erase(AB_EUTRANSFER_INFO_LIST2 *l, 03486 AB_EUTRANSFER_INFO_LIST2_ITERATOR *it); 03487 03493 unsigned int AB_EuTransferInfo_List2_GetSize(AB_EUTRANSFER_INFO_LIST2 *l); 03494 03499 void AB_EuTransferInfo_List2_PopBack(AB_EUTRANSFER_INFO_LIST2 *l); 03500 03505 void AB_EuTransferInfo_List2_PopFront(AB_EUTRANSFER_INFO_LIST2 *l); 03506 03510 void AB_EuTransferInfo_List2_Clear(AB_EUTRANSFER_INFO_LIST2 *l); 03511 03515 AB_EUTRANSFER_INFO_LIST2_ITERATOR *AB_EuTransferInfo_List2_First(AB_EUTRANSFER_INFO_LIST2 *l); 03516 03520 AB_EUTRANSFER_INFO_LIST2_ITERATOR *AB_EuTransferInfo_List2_Last(AB_EUTRANSFER_INFO_LIST2 *l); 03521 03525 AB_EUTRANSFER_INFO_LIST2_ITERATOR *AB_EuTransferInfo_List2Iterator_new(AB_EUTRANSFER_INFO_LIST2 *l); 03526 03530 void AB_EuTransferInfo_List2Iterator_free(AB_EUTRANSFER_INFO_LIST2_ITERATOR *li); 03531 03536 AB_EUTRANSFER_INFO *AB_EuTransferInfo_List2Iterator_Previous(AB_EUTRANSFER_INFO_LIST2_ITERATOR *li); 03537 03542 AB_EUTRANSFER_INFO *AB_EuTransferInfo_List2Iterator_Next(AB_EUTRANSFER_INFO_LIST2_ITERATOR *li); 03543 03548 AB_EUTRANSFER_INFO *AB_EuTransferInfo_List2Iterator_Data(AB_EUTRANSFER_INFO_LIST2_ITERATOR *li); 03549 03561 AB_EUTRANSFER_INFO *AB_EuTransferInfo_List2_ForEach(AB_EUTRANSFER_INFO_LIST2 *list, 03562 AB_EUTRANSFER_INFO_LIST2_FOREACH func, 03563 void *user_data); 03564 03565 03566 typedef struct AB_EUTRANSFER_INFO_CONSTLIST2 AB_EUTRANSFER_INFO_CONSTLIST2; 03567 typedef struct AB_EUTRANSFER_INFO_CONSTLIST2_ITERATOR AB_EUTRANSFER_INFO_CONSTLIST2_ITERATOR; 03568 typedef const AB_EUTRANSFER_INFO* 03569 (AB_EUTRANSFER_INFO_CONSTLIST2_FOREACH)(const AB_EUTRANSFER_INFO *element, 03570 void *user_data); 03571 03572 03573 AB_EUTRANSFER_INFO_CONSTLIST2 *AB_EuTransferInfo_ConstList2_new(); 03574 03575 void AB_EuTransferInfo_ConstList2_free(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 03576 03577 void AB_EuTransferInfo_ConstList2_PushBack(AB_EUTRANSFER_INFO_CONSTLIST2 *l, const AB_EUTRANSFER_INFO *p); 03578 03579 void AB_EuTransferInfo_ConstList2_PushFront(AB_EUTRANSFER_INFO_CONSTLIST2 *l, const AB_EUTRANSFER_INFO *p); 03580 03581 const AB_EUTRANSFER_INFO *AB_EuTransferInfo_ConstList2_GetFront(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 03582 03583 const AB_EUTRANSFER_INFO *AB_EuTransferInfo_ConstList2_GetBack(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 03584 03585 unsigned int AB_EuTransferInfo_ConstList2_GetSize(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 03586 03587 void AB_EuTransferInfo_ConstList2_PopBack(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 03588 03589 void AB_EuTransferInfo_ConstList2_PopFront(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 03590 03591 void AB_EuTransferInfo_ConstList2_Clear(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 03592 03593 AB_EUTRANSFER_INFO_CONSTLIST2_ITERATOR *AB_EuTransferInfo_ConstList2_First(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 03594 03595 AB_EUTRANSFER_INFO_CONSTLIST2_ITERATOR *AB_EuTransferInfo_ConstList2_Last(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 03596 03597 AB_EUTRANSFER_INFO_CONSTLIST2_ITERATOR *AB_EuTransferInfo_ConstList2Iterator_new(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 03598 03599 void AB_EuTransferInfo_ConstList2Iterator_free(AB_EUTRANSFER_INFO_CONSTLIST2_ITERATOR *li); 03600 03601 const AB_EUTRANSFER_INFO *AB_EuTransferInfo_ConstList2Iterator_Previous(AB_EUTRANSFER_INFO_CONSTLIST2_ITERATOR *li); 03602 03603 const AB_EUTRANSFER_INFO *AB_EuTransferInfo_ConstList2Iterator_Next(AB_EUTRANSFER_INFO_CONSTLIST2_ITERATOR *li); 03604 03605 const AB_EUTRANSFER_INFO *AB_EuTransferInfo_ConstList2Iterator_Data(AB_EUTRANSFER_INFO_CONSTLIST2_ITERATOR *li); 03606 03618 const AB_EUTRANSFER_INFO *AB_EuTransferInfo_ConstList2_ForEach(AB_EUTRANSFER_INFO_CONSTLIST2 *list, 03619 AB_EUTRANSFER_INFO_CONSTLIST2_FOREACH func, void *user_data); 03620 03621 03622 #ifdef __cplusplus 03623 } 03624 #endif 03625 03626 03627 #endif /* AB_EUTRANSFER_INFO_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_EUTRANSFER_INFO_LIST1_H 03660 #define AB_EUTRANSFER_INFO_LIST1_H 03661 03662 #ifdef __cplusplus 03663 extern "C" { 03664 #endif 03665 03667 typedef struct AB_EUTRANSFER_INFO_LIST_ELEMENT { 03668 uint32_t id; 03669 AB_EUTRANSFER_INFO *nextObject; 03670 } AB_EUTRANSFER_INFO_LIST__ELEMENT; 03671 03678 typedef struct AB_EUTRANSFER_INFO_LIST AB_EUTRANSFER_INFO_LIST; 03679 03683 typedef int GWENHYWFAR_CB (*AB_EUTRANSFER_INFO_LIST_SORT_FN)(const AB_EUTRANSFER_INFO *a, const AB_EUTRANSFER_INFO *b, int ascending); 03684 03685 03687 struct AB_EUTRANSFER_INFO_LIST { 03688 AB_EUTRANSFER_INFO *first; 03689 uint32_t count; 03690 uint32_t id; 03691 } AB_EUTRANSFER_INFO_LIST; 03692 03697 void AB_EuTransferInfo_List_AddList(AB_EUTRANSFER_INFO_LIST *dst, AB_EUTRANSFER_INFO_LIST *l); 03698 03702 void AB_EuTransferInfo_List_Add(AB_EUTRANSFER_INFO *element, AB_EUTRANSFER_INFO_LIST *list); 03703 03708 void AB_EuTransferInfo_List_Insert(AB_EUTRANSFER_INFO *element, AB_EUTRANSFER_INFO_LIST *list); 03709 03716 void AB_EuTransferInfo_List_Del(AB_EUTRANSFER_INFO *element); 03717 03721 AB_EUTRANSFER_INFO* AB_EuTransferInfo_List_First(const AB_EUTRANSFER_INFO_LIST *l); 03722 03726 AB_EUTRANSFER_INFO* AB_EuTransferInfo_List_Last(const AB_EUTRANSFER_INFO_LIST *l); 03727 03732 void AB_EuTransferInfo_List_Clear(AB_EUTRANSFER_INFO_LIST *l); 03733 03737 AB_EUTRANSFER_INFO_LIST* AB_EuTransferInfo_List_new(); 03738 03742 void AB_EuTransferInfo_List_free(AB_EUTRANSFER_INFO_LIST *l); 03743 03747 AB_EUTRANSFER_INFO* AB_EuTransferInfo_List_Next(const AB_EUTRANSFER_INFO *element); 03748 03752 AB_EUTRANSFER_INFO* AB_EuTransferInfo_List_Previous(const AB_EUTRANSFER_INFO *element); 03753 03757 uint32_t AB_EuTransferInfo_List_GetCount(const AB_EUTRANSFER_INFO_LIST *l); 03758 03762 AB_EUTRANSFER_INFO_LIST_SORT_FN AB_EuTransferInfo_List_SetSortFn(AB_EUTRANSFER_INFO_LIST *l, AB_EUTRANSFER_INFO_LIST_SORT_FN fn); 03763 03769 void AB_EuTransferInfo_List_Sort(AB_EUTRANSFER_INFO_LIST *l, int ascending); 03770 03771 03772 #ifdef __cplusplus 03773 } 03774 #endif 03775 03776 03777 #endif 03778 03779 03780 03781 /*************************************************************************** 03782 $RCSfile$ 03783 ------------------- 03784 cvs : $Id$ 03785 begin : Sat Jun 28 2003 03786 copyright : (C) 2003 by Martin Preuss 03787 email : martin@libchipcard.de 03788 03789 *************************************************************************** 03790 * * 03791 * This library is free software; you can redistribute it and/or * 03792 * modify it under the terms of the GNU Lesser General Public * 03793 * License as published by the Free Software Foundation; either * 03794 * version 2.1 of the License, or (at your option) any later version. * 03795 * * 03796 * This library is distributed in the hope that it will be useful, * 03797 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 03798 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 03799 * Lesser General Public License for more details. * 03800 * * 03801 * You should have received a copy of the GNU Lesser General Public * 03802 * License along with this library; if not, write to the Free Software * 03803 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 03804 * MA 02111-1307 USA * 03805 * * 03806 ***************************************************************************/ 03807 03808 03809 #ifndef AB_MESSAGE_LIST2_H 03810 #define AB_MESSAGE_LIST2_H 03811 03812 03813 #ifdef __cplusplus 03814 extern "C" { 03815 #endif 03816 03823 typedef struct AB_MESSAGE_LIST2 AB_MESSAGE_LIST2; 03824 03828 typedef struct AB_MESSAGE_LIST2_ITERATOR AB_MESSAGE_LIST2_ITERATOR; 03829 03833 typedef AB_MESSAGE* (AB_MESSAGE_LIST2_FOREACH)(AB_MESSAGE *element, 03834 void *user_data); 03835 03839 AB_MESSAGE_LIST2 *AB_Message_List2_new(); 03840 03844 void AB_Message_List2_free(AB_MESSAGE_LIST2 *l); 03845 03849 void AB_Message_List2_Dump(AB_MESSAGE_LIST2 *l, FILE *f, unsigned int indent); 03850 03854 void AB_Message_List2_PushBack(AB_MESSAGE_LIST2 *l, AB_MESSAGE *p); 03855 03860 void AB_Message_List2_PushFront(AB_MESSAGE_LIST2 *l, AB_MESSAGE *p); 03861 03866 AB_MESSAGE *AB_Message_List2_GetFront(AB_MESSAGE_LIST2 *l); 03867 03872 AB_MESSAGE *AB_Message_List2_GetBack(AB_MESSAGE_LIST2 *l); 03873 03878 void AB_Message_List2_Erase(AB_MESSAGE_LIST2 *l, 03879 AB_MESSAGE_LIST2_ITERATOR *it); 03880 03886 unsigned int AB_Message_List2_GetSize(AB_MESSAGE_LIST2 *l); 03887 03892 void AB_Message_List2_PopBack(AB_MESSAGE_LIST2 *l); 03893 03898 void AB_Message_List2_PopFront(AB_MESSAGE_LIST2 *l); 03899 03903 void AB_Message_List2_Clear(AB_MESSAGE_LIST2 *l); 03904 03908 AB_MESSAGE_LIST2_ITERATOR *AB_Message_List2_First(AB_MESSAGE_LIST2 *l); 03909 03913 AB_MESSAGE_LIST2_ITERATOR *AB_Message_List2_Last(AB_MESSAGE_LIST2 *l); 03914 03918 AB_MESSAGE_LIST2_ITERATOR *AB_Message_List2Iterator_new(AB_MESSAGE_LIST2 *l); 03919 03923 void AB_Message_List2Iterator_free(AB_MESSAGE_LIST2_ITERATOR *li); 03924 03929 AB_MESSAGE *AB_Message_List2Iterator_Previous(AB_MESSAGE_LIST2_ITERATOR *li); 03930 03935 AB_MESSAGE *AB_Message_List2Iterator_Next(AB_MESSAGE_LIST2_ITERATOR *li); 03936 03941 AB_MESSAGE *AB_Message_List2Iterator_Data(AB_MESSAGE_LIST2_ITERATOR *li); 03942 03954 AB_MESSAGE *AB_Message_List2_ForEach(AB_MESSAGE_LIST2 *list, 03955 AB_MESSAGE_LIST2_FOREACH func, 03956 void *user_data); 03957 03958 03959 typedef struct AB_MESSAGE_CONSTLIST2 AB_MESSAGE_CONSTLIST2; 03960 typedef struct AB_MESSAGE_CONSTLIST2_ITERATOR AB_MESSAGE_CONSTLIST2_ITERATOR; 03961 typedef const AB_MESSAGE* 03962 (AB_MESSAGE_CONSTLIST2_FOREACH)(const AB_MESSAGE *element, 03963 void *user_data); 03964 03965 03966 AB_MESSAGE_CONSTLIST2 *AB_Message_ConstList2_new(); 03967 03968 void AB_Message_ConstList2_free(AB_MESSAGE_CONSTLIST2 *l); 03969 03970 void AB_Message_ConstList2_PushBack(AB_MESSAGE_CONSTLIST2 *l, const AB_MESSAGE *p); 03971 03972 void AB_Message_ConstList2_PushFront(AB_MESSAGE_CONSTLIST2 *l, const AB_MESSAGE *p); 03973 03974 const AB_MESSAGE *AB_Message_ConstList2_GetFront(AB_MESSAGE_CONSTLIST2 *l); 03975 03976 const AB_MESSAGE *AB_Message_ConstList2_GetBack(AB_MESSAGE_CONSTLIST2 *l); 03977 03978 unsigned int AB_Message_ConstList2_GetSize(AB_MESSAGE_CONSTLIST2 *l); 03979 03980 void AB_Message_ConstList2_PopBack(AB_MESSAGE_CONSTLIST2 *l); 03981 03982 void AB_Message_ConstList2_PopFront(AB_MESSAGE_CONSTLIST2 *l); 03983 03984 void AB_Message_ConstList2_Clear(AB_MESSAGE_CONSTLIST2 *l); 03985 03986 AB_MESSAGE_CONSTLIST2_ITERATOR *AB_Message_ConstList2_First(AB_MESSAGE_CONSTLIST2 *l); 03987 03988 AB_MESSAGE_CONSTLIST2_ITERATOR *AB_Message_ConstList2_Last(AB_MESSAGE_CONSTLIST2 *l); 03989 03990 AB_MESSAGE_CONSTLIST2_ITERATOR *AB_Message_ConstList2Iterator_new(AB_MESSAGE_CONSTLIST2 *l); 03991 03992 void AB_Message_ConstList2Iterator_free(AB_MESSAGE_CONSTLIST2_ITERATOR *li); 03993 03994 const AB_MESSAGE *AB_Message_ConstList2Iterator_Previous(AB_MESSAGE_CONSTLIST2_ITERATOR *li); 03995 03996 const AB_MESSAGE *AB_Message_ConstList2Iterator_Next(AB_MESSAGE_CONSTLIST2_ITERATOR *li); 03997 03998 const AB_MESSAGE *AB_Message_ConstList2Iterator_Data(AB_MESSAGE_CONSTLIST2_ITERATOR *li); 03999 04011 const AB_MESSAGE *AB_Message_ConstList2_ForEach(AB_MESSAGE_CONSTLIST2 *list, 04012 AB_MESSAGE_CONSTLIST2_FOREACH func, void *user_data); 04013 04014 04015 #ifdef __cplusplus 04016 } 04017 #endif 04018 04019 04020 #endif /* AB_MESSAGE_LIST_H */ 04021 04022 04023 04024 /*************************************************************************** 04025 $RCSfile$ 04026 ------------------- 04027 cvs : $Id$ 04028 begin : Sat Jun 28 2003 04029 copyright : (C) 2003 by Martin Preuss 04030 email : martin@libchipcard.de 04031 04032 *************************************************************************** 04033 * * 04034 * This library is free software; you can redistribute it and/or * 04035 * modify it under the terms of the GNU Lesser General Public * 04036 * License as published by the Free Software Foundation; either * 04037 * version 2.1 of the License, or (at your option) any later version. * 04038 * * 04039 * This library is distributed in the hope that it will be useful, * 04040 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 04041 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 04042 * Lesser General Public License for more details. * 04043 * * 04044 * You should have received a copy of the GNU Lesser General Public * 04045 * License along with this library; if not, write to the Free Software * 04046 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 04047 * MA 02111-1307 USA * 04048 * * 04049 ***************************************************************************/ 04050 04051 04052 #ifndef AB_MESSAGE_LIST1_H 04053 #define AB_MESSAGE_LIST1_H 04054 04055 #ifdef __cplusplus 04056 extern "C" { 04057 #endif 04058 04060 typedef struct AB_MESSAGE_LIST_ELEMENT { 04061 uint32_t id; 04062 AB_MESSAGE *nextObject; 04063 } AB_MESSAGE_LIST__ELEMENT; 04064 04071 typedef struct AB_MESSAGE_LIST AB_MESSAGE_LIST; 04072 04076 typedef int GWENHYWFAR_CB (*AB_MESSAGE_LIST_SORT_FN)(const AB_MESSAGE *a, const AB_MESSAGE *b, int ascending); 04077 04078 04080 struct AB_MESSAGE_LIST { 04081 AB_MESSAGE *first; 04082 uint32_t count; 04083 uint32_t id; 04084 } AB_MESSAGE_LIST; 04085 04090 void AB_Message_List_AddList(AB_MESSAGE_LIST *dst, AB_MESSAGE_LIST *l); 04091 04095 void AB_Message_List_Add(AB_MESSAGE *element, AB_MESSAGE_LIST *list); 04096 04101 void AB_Message_List_Insert(AB_MESSAGE *element, AB_MESSAGE_LIST *list); 04102 04109 void AB_Message_List_Del(AB_MESSAGE *element); 04110 04114 AB_MESSAGE* AB_Message_List_First(const AB_MESSAGE_LIST *l); 04115 04119 AB_MESSAGE* AB_Message_List_Last(const AB_MESSAGE_LIST *l); 04120 04125 void AB_Message_List_Clear(AB_MESSAGE_LIST *l); 04126 04130 AB_MESSAGE_LIST* AB_Message_List_new(); 04131 04135 void AB_Message_List_free(AB_MESSAGE_LIST *l); 04136 04140 AB_MESSAGE* AB_Message_List_Next(const AB_MESSAGE *element); 04141 04145 AB_MESSAGE* AB_Message_List_Previous(const AB_MESSAGE *element); 04146 04150 uint32_t AB_Message_List_GetCount(const AB_MESSAGE_LIST *l); 04151 04155 AB_MESSAGE_LIST_SORT_FN AB_Message_List_SetSortFn(AB_MESSAGE_LIST *l, AB_MESSAGE_LIST_SORT_FN fn); 04156 04162 void AB_Message_List_Sort(AB_MESSAGE_LIST *l, int ascending); 04163 04164 04165 #ifdef __cplusplus 04166 } 04167 #endif 04168 04169 04170 #endif 04171 04172 04173 04174 /*************************************************************************** 04175 $RCSfile$ 04176 ------------------- 04177 cvs : $Id$ 04178 begin : Sat Jun 28 2003 04179 copyright : (C) 2003 by Martin Preuss 04180 email : martin@libchipcard.de 04181 04182 *************************************************************************** 04183 * * 04184 * This library is free software; you can redistribute it and/or * 04185 * modify it under the terms of the GNU Lesser General Public * 04186 * License as published by the Free Software Foundation; either * 04187 * version 2.1 of the License, or (at your option) any later version. * 04188 * * 04189 * This library is distributed in the hope that it will be useful, * 04190 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 04191 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 04192 * Lesser General Public License for more details. * 04193 * * 04194 * You should have received a copy of the GNU Lesser General Public * 04195 * License along with this library; if not, write to the Free Software * 04196 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 04197 * MA 02111-1307 USA * 04198 * * 04199 ***************************************************************************/ 04200 04201 04202 #ifndef AB_SECURITY_LIST2_H 04203 #define AB_SECURITY_LIST2_H 04204 04205 04206 #ifdef __cplusplus 04207 extern "C" { 04208 #endif 04209 04216 typedef struct AB_SECURITY_LIST2 AB_SECURITY_LIST2; 04217 04221 typedef struct AB_SECURITY_LIST2_ITERATOR AB_SECURITY_LIST2_ITERATOR; 04222 04226 typedef AB_SECURITY* (AB_SECURITY_LIST2_FOREACH)(AB_SECURITY *element, 04227 void *user_data); 04228 04232 AB_SECURITY_LIST2 *AB_Security_List2_new(); 04233 04237 void AB_Security_List2_free(AB_SECURITY_LIST2 *l); 04238 04242 void AB_Security_List2_Dump(AB_SECURITY_LIST2 *l, FILE *f, unsigned int indent); 04243 04247 void AB_Security_List2_PushBack(AB_SECURITY_LIST2 *l, AB_SECURITY *p); 04248 04253 void AB_Security_List2_PushFront(AB_SECURITY_LIST2 *l, AB_SECURITY *p); 04254 04259 AB_SECURITY *AB_Security_List2_GetFront(AB_SECURITY_LIST2 *l); 04260 04265 AB_SECURITY *AB_Security_List2_GetBack(AB_SECURITY_LIST2 *l); 04266 04271 void AB_Security_List2_Erase(AB_SECURITY_LIST2 *l, 04272 AB_SECURITY_LIST2_ITERATOR *it); 04273 04279 unsigned int AB_Security_List2_GetSize(AB_SECURITY_LIST2 *l); 04280 04285 void AB_Security_List2_PopBack(AB_SECURITY_LIST2 *l); 04286 04291 void AB_Security_List2_PopFront(AB_SECURITY_LIST2 *l); 04292 04296 void AB_Security_List2_Clear(AB_SECURITY_LIST2 *l); 04297 04301 AB_SECURITY_LIST2_ITERATOR *AB_Security_List2_First(AB_SECURITY_LIST2 *l); 04302 04306 AB_SECURITY_LIST2_ITERATOR *AB_Security_List2_Last(AB_SECURITY_LIST2 *l); 04307 04311 AB_SECURITY_LIST2_ITERATOR *AB_Security_List2Iterator_new(AB_SECURITY_LIST2 *l); 04312 04316 void AB_Security_List2Iterator_free(AB_SECURITY_LIST2_ITERATOR *li); 04317 04322 AB_SECURITY *AB_Security_List2Iterator_Previous(AB_SECURITY_LIST2_ITERATOR *li); 04323 04328 AB_SECURITY *AB_Security_List2Iterator_Next(AB_SECURITY_LIST2_ITERATOR *li); 04329 04334 AB_SECURITY *AB_Security_List2Iterator_Data(AB_SECURITY_LIST2_ITERATOR *li); 04335 04347 AB_SECURITY *AB_Security_List2_ForEach(AB_SECURITY_LIST2 *list, 04348 AB_SECURITY_LIST2_FOREACH func, 04349 void *user_data); 04350 04351 04352 typedef struct AB_SECURITY_CONSTLIST2 AB_SECURITY_CONSTLIST2; 04353 typedef struct AB_SECURITY_CONSTLIST2_ITERATOR AB_SECURITY_CONSTLIST2_ITERATOR; 04354 typedef const AB_SECURITY* 04355 (AB_SECURITY_CONSTLIST2_FOREACH)(const AB_SECURITY *element, 04356 void *user_data); 04357 04358 04359 AB_SECURITY_CONSTLIST2 *AB_Security_ConstList2_new(); 04360 04361 void AB_Security_ConstList2_free(AB_SECURITY_CONSTLIST2 *l); 04362 04363 void AB_Security_ConstList2_PushBack(AB_SECURITY_CONSTLIST2 *l, const AB_SECURITY *p); 04364 04365 void AB_Security_ConstList2_PushFront(AB_SECURITY_CONSTLIST2 *l, const AB_SECURITY *p); 04366 04367 const AB_SECURITY *AB_Security_ConstList2_GetFront(AB_SECURITY_CONSTLIST2 *l); 04368 04369 const AB_SECURITY *AB_Security_ConstList2_GetBack(AB_SECURITY_CONSTLIST2 *l); 04370 04371 unsigned int AB_Security_ConstList2_GetSize(AB_SECURITY_CONSTLIST2 *l); 04372 04373 void AB_Security_ConstList2_PopBack(AB_SECURITY_CONSTLIST2 *l); 04374 04375 void AB_Security_ConstList2_PopFront(AB_SECURITY_CONSTLIST2 *l); 04376 04377 void AB_Security_ConstList2_Clear(AB_SECURITY_CONSTLIST2 *l); 04378 04379 AB_SECURITY_CONSTLIST2_ITERATOR *AB_Security_ConstList2_First(AB_SECURITY_CONSTLIST2 *l); 04380 04381 AB_SECURITY_CONSTLIST2_ITERATOR *AB_Security_ConstList2_Last(AB_SECURITY_CONSTLIST2 *l); 04382 04383 AB_SECURITY_CONSTLIST2_ITERATOR *AB_Security_ConstList2Iterator_new(AB_SECURITY_CONSTLIST2 *l); 04384 04385 void AB_Security_ConstList2Iterator_free(AB_SECURITY_CONSTLIST2_ITERATOR *li); 04386 04387 const AB_SECURITY *AB_Security_ConstList2Iterator_Previous(AB_SECURITY_CONSTLIST2_ITERATOR *li); 04388 04389 const AB_SECURITY *AB_Security_ConstList2Iterator_Next(AB_SECURITY_CONSTLIST2_ITERATOR *li); 04390 04391 const AB_SECURITY *AB_Security_ConstList2Iterator_Data(AB_SECURITY_CONSTLIST2_ITERATOR *li); 04392 04404 const AB_SECURITY *AB_Security_ConstList2_ForEach(AB_SECURITY_CONSTLIST2 *list, 04405 AB_SECURITY_CONSTLIST2_FOREACH func, void *user_data); 04406 04407 04408 #ifdef __cplusplus 04409 } 04410 #endif 04411 04412 04413 #endif /* AB_SECURITY_LIST_H */ 04414 04415 04416 04417 /*************************************************************************** 04418 $RCSfile$ 04419 ------------------- 04420 cvs : $Id$ 04421 begin : Sat Jun 28 2003 04422 copyright : (C) 2003 by Martin Preuss 04423 email : martin@libchipcard.de 04424 04425 *************************************************************************** 04426 * * 04427 * This library is free software; you can redistribute it and/or * 04428 * modify it under the terms of the GNU Lesser General Public * 04429 * License as published by the Free Software Foundation; either * 04430 * version 2.1 of the License, or (at your option) any later version. * 04431 * * 04432 * This library is distributed in the hope that it will be useful, * 04433 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 04434 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 04435 * Lesser General Public License for more details. * 04436 * * 04437 * You should have received a copy of the GNU Lesser General Public * 04438 * License along with this library; if not, write to the Free Software * 04439 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 04440 * MA 02111-1307 USA * 04441 * * 04442 ***************************************************************************/ 04443 04444 04445 #ifndef AB_SECURITY_LIST1_H 04446 #define AB_SECURITY_LIST1_H 04447 04448 #ifdef __cplusplus 04449 extern "C" { 04450 #endif 04451 04453 typedef struct AB_SECURITY_LIST_ELEMENT { 04454 uint32_t id; 04455 AB_SECURITY *nextObject; 04456 } AB_SECURITY_LIST__ELEMENT; 04457 04464 typedef struct AB_SECURITY_LIST AB_SECURITY_LIST; 04465 04469 typedef int GWENHYWFAR_CB (*AB_SECURITY_LIST_SORT_FN)(const AB_SECURITY *a, const AB_SECURITY *b, int ascending); 04470 04471 04473 struct AB_SECURITY_LIST { 04474 AB_SECURITY *first; 04475 uint32_t count; 04476 uint32_t id; 04477 } AB_SECURITY_LIST; 04478 04483 void AB_Security_List_AddList(AB_SECURITY_LIST *dst, AB_SECURITY_LIST *l); 04484 04488 void AB_Security_List_Add(AB_SECURITY *element, AB_SECURITY_LIST *list); 04489 04494 void AB_Security_List_Insert(AB_SECURITY *element, AB_SECURITY_LIST *list); 04495 04502 void AB_Security_List_Del(AB_SECURITY *element); 04503 04507 AB_SECURITY* AB_Security_List_First(const AB_SECURITY_LIST *l); 04508 04512 AB_SECURITY* AB_Security_List_Last(const AB_SECURITY_LIST *l); 04513 04518 void AB_Security_List_Clear(AB_SECURITY_LIST *l); 04519 04523 AB_SECURITY_LIST* AB_Security_List_new(); 04524 04528 void AB_Security_List_free(AB_SECURITY_LIST *l); 04529 04533 AB_SECURITY* AB_Security_List_Next(const AB_SECURITY *element); 04534 04538 AB_SECURITY* AB_Security_List_Previous(const AB_SECURITY *element); 04539 04543 uint32_t AB_Security_List_GetCount(const AB_SECURITY_LIST *l); 04544 04548 AB_SECURITY_LIST_SORT_FN AB_Security_List_SetSortFn(AB_SECURITY_LIST *l, AB_SECURITY_LIST_SORT_FN fn); 04549 04555 void AB_Security_List_Sort(AB_SECURITY_LIST *l, int ascending); 04556 04557 04558 #ifdef __cplusplus 04559 } 04560 #endif 04561 04562 04563 #endif 04564 04565 04566 04567 /*************************************************************************** 04568 $RCSfile$ 04569 ------------------- 04570 cvs : $Id$ 04571 begin : Sat Jun 28 2003 04572 copyright : (C) 2003 by Martin Preuss 04573 email : martin@libchipcard.de 04574 04575 *************************************************************************** 04576 * * 04577 * This library is free software; you can redistribute it and/or * 04578 * modify it under the terms of the GNU Lesser General Public * 04579 * License as published by the Free Software Foundation; either * 04580 * version 2.1 of the License, or (at your option) any later version. * 04581 * * 04582 * This library is distributed in the hope that it will be useful, * 04583 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 04584 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 04585 * Lesser General Public License for more details. * 04586 * * 04587 * You should have received a copy of the GNU Lesser General Public * 04588 * License along with this library; if not, write to the Free Software * 04589 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 04590 * MA 02111-1307 USA * 04591 * * 04592 ***************************************************************************/ 04593 04594 04595 #ifndef AB_TEXTKEY_DESCR_LIST2_H 04596 #define AB_TEXTKEY_DESCR_LIST2_H 04597 04598 04599 #ifdef __cplusplus 04600 extern "C" { 04601 #endif 04602 04609 typedef struct AB_TEXTKEY_DESCR_LIST2 AB_TEXTKEY_DESCR_LIST2; 04610 04614 typedef struct AB_TEXTKEY_DESCR_LIST2_ITERATOR AB_TEXTKEY_DESCR_LIST2_ITERATOR; 04615 04619 typedef AB_TEXTKEY_DESCR* (AB_TEXTKEY_DESCR_LIST2_FOREACH)(AB_TEXTKEY_DESCR *element, 04620 void *user_data); 04621 04625 AB_TEXTKEY_DESCR_LIST2 *AB_TextKeyDescr_List2_new(); 04626 04630 void AB_TextKeyDescr_List2_free(AB_TEXTKEY_DESCR_LIST2 *l); 04631 04635 void AB_TextKeyDescr_List2_Dump(AB_TEXTKEY_DESCR_LIST2 *l, FILE *f, unsigned int indent); 04636 04640 void AB_TextKeyDescr_List2_PushBack(AB_TEXTKEY_DESCR_LIST2 *l, AB_TEXTKEY_DESCR *p); 04641 04646 void AB_TextKeyDescr_List2_PushFront(AB_TEXTKEY_DESCR_LIST2 *l, AB_TEXTKEY_DESCR *p); 04647 04652 AB_TEXTKEY_DESCR *AB_TextKeyDescr_List2_GetFront(AB_TEXTKEY_DESCR_LIST2 *l); 04653 04658 AB_TEXTKEY_DESCR *AB_TextKeyDescr_List2_GetBack(AB_TEXTKEY_DESCR_LIST2 *l); 04659 04664 void AB_TextKeyDescr_List2_Erase(AB_TEXTKEY_DESCR_LIST2 *l, 04665 AB_TEXTKEY_DESCR_LIST2_ITERATOR *it); 04666 04672 unsigned int AB_TextKeyDescr_List2_GetSize(AB_TEXTKEY_DESCR_LIST2 *l); 04673 04678 void AB_TextKeyDescr_List2_PopBack(AB_TEXTKEY_DESCR_LIST2 *l); 04679 04684 void AB_TextKeyDescr_List2_PopFront(AB_TEXTKEY_DESCR_LIST2 *l); 04685 04689 void AB_TextKeyDescr_List2_Clear(AB_TEXTKEY_DESCR_LIST2 *l); 04690 04694 AB_TEXTKEY_DESCR_LIST2_ITERATOR *AB_TextKeyDescr_List2_First(AB_TEXTKEY_DESCR_LIST2 *l); 04695 04699 AB_TEXTKEY_DESCR_LIST2_ITERATOR *AB_TextKeyDescr_List2_Last(AB_TEXTKEY_DESCR_LIST2 *l); 04700 04704 AB_TEXTKEY_DESCR_LIST2_ITERATOR *AB_TextKeyDescr_List2Iterator_new(AB_TEXTKEY_DESCR_LIST2 *l); 04705 04709 void AB_TextKeyDescr_List2Iterator_free(AB_TEXTKEY_DESCR_LIST2_ITERATOR *li); 04710 04715 AB_TEXTKEY_DESCR *AB_TextKeyDescr_List2Iterator_Previous(AB_TEXTKEY_DESCR_LIST2_ITERATOR *li); 04716 04721 AB_TEXTKEY_DESCR *AB_TextKeyDescr_List2Iterator_Next(AB_TEXTKEY_DESCR_LIST2_ITERATOR *li); 04722 04727 AB_TEXTKEY_DESCR *AB_TextKeyDescr_List2Iterator_Data(AB_TEXTKEY_DESCR_LIST2_ITERATOR *li); 04728 04740 AB_TEXTKEY_DESCR *AB_TextKeyDescr_List2_ForEach(AB_TEXTKEY_DESCR_LIST2 *list, 04741 AB_TEXTKEY_DESCR_LIST2_FOREACH func, 04742 void *user_data); 04743 04744 04745 typedef struct AB_TEXTKEY_DESCR_CONSTLIST2 AB_TEXTKEY_DESCR_CONSTLIST2; 04746 typedef struct AB_TEXTKEY_DESCR_CONSTLIST2_ITERATOR AB_TEXTKEY_DESCR_CONSTLIST2_ITERATOR; 04747 typedef const AB_TEXTKEY_DESCR* 04748 (AB_TEXTKEY_DESCR_CONSTLIST2_FOREACH)(const AB_TEXTKEY_DESCR *element, 04749 void *user_data); 04750 04751 04752 AB_TEXTKEY_DESCR_CONSTLIST2 *AB_TextKeyDescr_ConstList2_new(); 04753 04754 void AB_TextKeyDescr_ConstList2_free(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 04755 04756 void AB_TextKeyDescr_ConstList2_PushBack(AB_TEXTKEY_DESCR_CONSTLIST2 *l, const AB_TEXTKEY_DESCR *p); 04757 04758 void AB_TextKeyDescr_ConstList2_PushFront(AB_TEXTKEY_DESCR_CONSTLIST2 *l, const AB_TEXTKEY_DESCR *p); 04759 04760 const AB_TEXTKEY_DESCR *AB_TextKeyDescr_ConstList2_GetFront(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 04761 04762 const AB_TEXTKEY_DESCR *AB_TextKeyDescr_ConstList2_GetBack(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 04763 04764 unsigned int AB_TextKeyDescr_ConstList2_GetSize(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 04765 04766 void AB_TextKeyDescr_ConstList2_PopBack(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 04767 04768 void AB_TextKeyDescr_ConstList2_PopFront(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 04769 04770 void AB_TextKeyDescr_ConstList2_Clear(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 04771 04772 AB_TEXTKEY_DESCR_CONSTLIST2_ITERATOR *AB_TextKeyDescr_ConstList2_First(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 04773 04774 AB_TEXTKEY_DESCR_CONSTLIST2_ITERATOR *AB_TextKeyDescr_ConstList2_Last(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 04775 04776 AB_TEXTKEY_DESCR_CONSTLIST2_ITERATOR *AB_TextKeyDescr_ConstList2Iterator_new(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 04777 04778 void AB_TextKeyDescr_ConstList2Iterator_free(AB_TEXTKEY_DESCR_CONSTLIST2_ITERATOR *li); 04779 04780 const AB_TEXTKEY_DESCR *AB_TextKeyDescr_ConstList2Iterator_Previous(AB_TEXTKEY_DESCR_CONSTLIST2_ITERATOR *li); 04781 04782 const AB_TEXTKEY_DESCR *AB_TextKeyDescr_ConstList2Iterator_Next(AB_TEXTKEY_DESCR_CONSTLIST2_ITERATOR *li); 04783 04784 const AB_TEXTKEY_DESCR *AB_TextKeyDescr_ConstList2Iterator_Data(AB_TEXTKEY_DESCR_CONSTLIST2_ITERATOR *li); 04785 04797 const AB_TEXTKEY_DESCR *AB_TextKeyDescr_ConstList2_ForEach(AB_TEXTKEY_DESCR_CONSTLIST2 *list, 04798 AB_TEXTKEY_DESCR_CONSTLIST2_FOREACH func, void *user_data); 04799 04800 04801 #ifdef __cplusplus 04802 } 04803 #endif 04804 04805 04806 #endif /* AB_TEXTKEY_DESCR_LIST_H */ 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_TEXTKEY_DESCR_LIST1_H 04839 #define AB_TEXTKEY_DESCR_LIST1_H 04840 04841 #ifdef __cplusplus 04842 extern "C" { 04843 #endif 04844 04846 typedef struct AB_TEXTKEY_DESCR_LIST_ELEMENT { 04847 uint32_t id; 04848 AB_TEXTKEY_DESCR *nextObject; 04849 } AB_TEXTKEY_DESCR_LIST__ELEMENT; 04850 04857 typedef struct AB_TEXTKEY_DESCR_LIST AB_TEXTKEY_DESCR_LIST; 04858 04862 typedef int GWENHYWFAR_CB (*AB_TEXTKEY_DESCR_LIST_SORT_FN)(const AB_TEXTKEY_DESCR *a, const AB_TEXTKEY_DESCR *b, int ascending); 04863 04864 04866 struct AB_TEXTKEY_DESCR_LIST { 04867 AB_TEXTKEY_DESCR *first; 04868 uint32_t count; 04869 uint32_t id; 04870 } AB_TEXTKEY_DESCR_LIST; 04871 04876 void AB_TextKeyDescr_List_AddList(AB_TEXTKEY_DESCR_LIST *dst, AB_TEXTKEY_DESCR_LIST *l); 04877 04881 void AB_TextKeyDescr_List_Add(AB_TEXTKEY_DESCR *element, AB_TEXTKEY_DESCR_LIST *list); 04882 04887 void AB_TextKeyDescr_List_Insert(AB_TEXTKEY_DESCR *element, AB_TEXTKEY_DESCR_LIST *list); 04888 04895 void AB_TextKeyDescr_List_Del(AB_TEXTKEY_DESCR *element); 04896 04900 AB_TEXTKEY_DESCR* AB_TextKeyDescr_List_First(const AB_TEXTKEY_DESCR_LIST *l); 04901 04905 AB_TEXTKEY_DESCR* AB_TextKeyDescr_List_Last(const AB_TEXTKEY_DESCR_LIST *l); 04906 04911 void AB_TextKeyDescr_List_Clear(AB_TEXTKEY_DESCR_LIST *l); 04912 04916 AB_TEXTKEY_DESCR_LIST* AB_TextKeyDescr_List_new(); 04917 04921 void AB_TextKeyDescr_List_free(AB_TEXTKEY_DESCR_LIST *l); 04922 04926 AB_TEXTKEY_DESCR* AB_TextKeyDescr_List_Next(const AB_TEXTKEY_DESCR *element); 04927 04931 AB_TEXTKEY_DESCR* AB_TextKeyDescr_List_Previous(const AB_TEXTKEY_DESCR *element); 04932 04936 uint32_t AB_TextKeyDescr_List_GetCount(const AB_TEXTKEY_DESCR_LIST *l); 04937 04941 AB_TEXTKEY_DESCR_LIST_SORT_FN AB_TextKeyDescr_List_SetSortFn(AB_TEXTKEY_DESCR_LIST *l, AB_TEXTKEY_DESCR_LIST_SORT_FN fn); 04942 04948 void AB_TextKeyDescr_List_Sort(AB_TEXTKEY_DESCR_LIST *l, int ascending); 04949 04950 04951 #ifdef __cplusplus 04952 } 04953 #endif 04954 04955 04956 #endif 04957 04958 04959 04960 /*************************************************************************** 04961 $RCSfile$ 04962 ------------------- 04963 cvs : $Id$ 04964 begin : Sat Jun 28 2003 04965 copyright : (C) 2003 by Martin Preuss 04966 email : martin@libchipcard.de 04967 04968 *************************************************************************** 04969 * * 04970 * This library is free software; you can redistribute it and/or * 04971 * modify it under the terms of the GNU Lesser General Public * 04972 * License as published by the Free Software Foundation; either * 04973 * version 2.1 of the License, or (at your option) any later version. * 04974 * * 04975 * This library is distributed in the hope that it will be useful, * 04976 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 04977 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 04978 * Lesser General Public License for more details. * 04979 * * 04980 * You should have received a copy of the GNU Lesser General Public * 04981 * License along with this library; if not, write to the Free Software * 04982 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 04983 * MA 02111-1307 USA * 04984 * * 04985 ***************************************************************************/ 04986 04987 04988 #ifndef AB_TRANSACTION_LIST2_H 04989 #define AB_TRANSACTION_LIST2_H 04990 04991 04992 #ifdef __cplusplus 04993 extern "C" { 04994 #endif 04995 05002 typedef struct AB_TRANSACTION_LIST2 AB_TRANSACTION_LIST2; 05003 05007 typedef struct AB_TRANSACTION_LIST2_ITERATOR AB_TRANSACTION_LIST2_ITERATOR; 05008 05012 typedef AB_TRANSACTION* (AB_TRANSACTION_LIST2_FOREACH)(AB_TRANSACTION *element, 05013 void *user_data); 05014 05018 AB_TRANSACTION_LIST2 *AB_Transaction_List2_new(); 05019 05023 void AB_Transaction_List2_free(AB_TRANSACTION_LIST2 *l); 05024 05028 void AB_Transaction_List2_Dump(AB_TRANSACTION_LIST2 *l, FILE *f, unsigned int indent); 05029 05033 void AB_Transaction_List2_PushBack(AB_TRANSACTION_LIST2 *l, AB_TRANSACTION *p); 05034 05039 void AB_Transaction_List2_PushFront(AB_TRANSACTION_LIST2 *l, AB_TRANSACTION *p); 05040 05045 AB_TRANSACTION *AB_Transaction_List2_GetFront(AB_TRANSACTION_LIST2 *l); 05046 05051 AB_TRANSACTION *AB_Transaction_List2_GetBack(AB_TRANSACTION_LIST2 *l); 05052 05057 void AB_Transaction_List2_Erase(AB_TRANSACTION_LIST2 *l, 05058 AB_TRANSACTION_LIST2_ITERATOR *it); 05059 05065 unsigned int AB_Transaction_List2_GetSize(AB_TRANSACTION_LIST2 *l); 05066 05071 void AB_Transaction_List2_PopBack(AB_TRANSACTION_LIST2 *l); 05072 05077 void AB_Transaction_List2_PopFront(AB_TRANSACTION_LIST2 *l); 05078 05082 void AB_Transaction_List2_Clear(AB_TRANSACTION_LIST2 *l); 05083 05087 AB_TRANSACTION_LIST2_ITERATOR *AB_Transaction_List2_First(AB_TRANSACTION_LIST2 *l); 05088 05092 AB_TRANSACTION_LIST2_ITERATOR *AB_Transaction_List2_Last(AB_TRANSACTION_LIST2 *l); 05093 05097 AB_TRANSACTION_LIST2_ITERATOR *AB_Transaction_List2Iterator_new(AB_TRANSACTION_LIST2 *l); 05098 05102 void AB_Transaction_List2Iterator_free(AB_TRANSACTION_LIST2_ITERATOR *li); 05103 05108 AB_TRANSACTION *AB_Transaction_List2Iterator_Previous(AB_TRANSACTION_LIST2_ITERATOR *li); 05109 05114 AB_TRANSACTION *AB_Transaction_List2Iterator_Next(AB_TRANSACTION_LIST2_ITERATOR *li); 05115 05120 AB_TRANSACTION *AB_Transaction_List2Iterator_Data(AB_TRANSACTION_LIST2_ITERATOR *li); 05121 05133 AB_TRANSACTION *AB_Transaction_List2_ForEach(AB_TRANSACTION_LIST2 *list, 05134 AB_TRANSACTION_LIST2_FOREACH func, 05135 void *user_data); 05136 05137 05138 typedef struct AB_TRANSACTION_CONSTLIST2 AB_TRANSACTION_CONSTLIST2; 05139 typedef struct AB_TRANSACTION_CONSTLIST2_ITERATOR AB_TRANSACTION_CONSTLIST2_ITERATOR; 05140 typedef const AB_TRANSACTION* 05141 (AB_TRANSACTION_CONSTLIST2_FOREACH)(const AB_TRANSACTION *element, 05142 void *user_data); 05143 05144 05145 AB_TRANSACTION_CONSTLIST2 *AB_Transaction_ConstList2_new(); 05146 05147 void AB_Transaction_ConstList2_free(AB_TRANSACTION_CONSTLIST2 *l); 05148 05149 void AB_Transaction_ConstList2_PushBack(AB_TRANSACTION_CONSTLIST2 *l, const AB_TRANSACTION *p); 05150 05151 void AB_Transaction_ConstList2_PushFront(AB_TRANSACTION_CONSTLIST2 *l, const AB_TRANSACTION *p); 05152 05153 const AB_TRANSACTION *AB_Transaction_ConstList2_GetFront(AB_TRANSACTION_CONSTLIST2 *l); 05154 05155 const AB_TRANSACTION *AB_Transaction_ConstList2_GetBack(AB_TRANSACTION_CONSTLIST2 *l); 05156 05157 unsigned int AB_Transaction_ConstList2_GetSize(AB_TRANSACTION_CONSTLIST2 *l); 05158 05159 void AB_Transaction_ConstList2_PopBack(AB_TRANSACTION_CONSTLIST2 *l); 05160 05161 void AB_Transaction_ConstList2_PopFront(AB_TRANSACTION_CONSTLIST2 *l); 05162 05163 void AB_Transaction_ConstList2_Clear(AB_TRANSACTION_CONSTLIST2 *l); 05164 05165 AB_TRANSACTION_CONSTLIST2_ITERATOR *AB_Transaction_ConstList2_First(AB_TRANSACTION_CONSTLIST2 *l); 05166 05167 AB_TRANSACTION_CONSTLIST2_ITERATOR *AB_Transaction_ConstList2_Last(AB_TRANSACTION_CONSTLIST2 *l); 05168 05169 AB_TRANSACTION_CONSTLIST2_ITERATOR *AB_Transaction_ConstList2Iterator_new(AB_TRANSACTION_CONSTLIST2 *l); 05170 05171 void AB_Transaction_ConstList2Iterator_free(AB_TRANSACTION_CONSTLIST2_ITERATOR *li); 05172 05173 const AB_TRANSACTION *AB_Transaction_ConstList2Iterator_Previous(AB_TRANSACTION_CONSTLIST2_ITERATOR *li); 05174 05175 const AB_TRANSACTION *AB_Transaction_ConstList2Iterator_Next(AB_TRANSACTION_CONSTLIST2_ITERATOR *li); 05176 05177 const AB_TRANSACTION *AB_Transaction_ConstList2Iterator_Data(AB_TRANSACTION_CONSTLIST2_ITERATOR *li); 05178 05190 const AB_TRANSACTION *AB_Transaction_ConstList2_ForEach(AB_TRANSACTION_CONSTLIST2 *list, 05191 AB_TRANSACTION_CONSTLIST2_FOREACH func, void *user_data); 05192 05193 05194 #ifdef __cplusplus 05195 } 05196 #endif 05197 05198 05199 #endif /* AB_TRANSACTION_LIST_H */ 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_TRANSACTION_LIMITS_LIST2_H 05232 #define AB_TRANSACTION_LIMITS_LIST2_H 05233 05234 05235 #ifdef __cplusplus 05236 extern "C" { 05237 #endif 05238 05245 typedef struct AB_TRANSACTION_LIMITS_LIST2 AB_TRANSACTION_LIMITS_LIST2; 05246 05250 typedef struct AB_TRANSACTION_LIMITS_LIST2_ITERATOR AB_TRANSACTION_LIMITS_LIST2_ITERATOR; 05251 05255 typedef AB_TRANSACTION_LIMITS* (AB_TRANSACTION_LIMITS_LIST2_FOREACH)(AB_TRANSACTION_LIMITS *element, 05256 void *user_data); 05257 05261 AB_TRANSACTION_LIMITS_LIST2 *AB_TransactionLimits_List2_new(); 05262 05266 void AB_TransactionLimits_List2_free(AB_TRANSACTION_LIMITS_LIST2 *l); 05267 05271 void AB_TransactionLimits_List2_Dump(AB_TRANSACTION_LIMITS_LIST2 *l, FILE *f, unsigned int indent); 05272 05276 void AB_TransactionLimits_List2_PushBack(AB_TRANSACTION_LIMITS_LIST2 *l, AB_TRANSACTION_LIMITS *p); 05277 05282 void AB_TransactionLimits_List2_PushFront(AB_TRANSACTION_LIMITS_LIST2 *l, AB_TRANSACTION_LIMITS *p); 05283 05288 AB_TRANSACTION_LIMITS *AB_TransactionLimits_List2_GetFront(AB_TRANSACTION_LIMITS_LIST2 *l); 05289 05294 AB_TRANSACTION_LIMITS *AB_TransactionLimits_List2_GetBack(AB_TRANSACTION_LIMITS_LIST2 *l); 05295 05300 void AB_TransactionLimits_List2_Erase(AB_TRANSACTION_LIMITS_LIST2 *l, 05301 AB_TRANSACTION_LIMITS_LIST2_ITERATOR *it); 05302 05308 unsigned int AB_TransactionLimits_List2_GetSize(AB_TRANSACTION_LIMITS_LIST2 *l); 05309 05314 void AB_TransactionLimits_List2_PopBack(AB_TRANSACTION_LIMITS_LIST2 *l); 05315 05320 void AB_TransactionLimits_List2_PopFront(AB_TRANSACTION_LIMITS_LIST2 *l); 05321 05325 void AB_TransactionLimits_List2_Clear(AB_TRANSACTION_LIMITS_LIST2 *l); 05326 05330 AB_TRANSACTION_LIMITS_LIST2_ITERATOR *AB_TransactionLimits_List2_First(AB_TRANSACTION_LIMITS_LIST2 *l); 05331 05335 AB_TRANSACTION_LIMITS_LIST2_ITERATOR *AB_TransactionLimits_List2_Last(AB_TRANSACTION_LIMITS_LIST2 *l); 05336 05340 AB_TRANSACTION_LIMITS_LIST2_ITERATOR *AB_TransactionLimits_List2Iterator_new(AB_TRANSACTION_LIMITS_LIST2 *l); 05341 05345 void AB_TransactionLimits_List2Iterator_free(AB_TRANSACTION_LIMITS_LIST2_ITERATOR *li); 05346 05351 AB_TRANSACTION_LIMITS *AB_TransactionLimits_List2Iterator_Previous(AB_TRANSACTION_LIMITS_LIST2_ITERATOR *li); 05352 05357 AB_TRANSACTION_LIMITS *AB_TransactionLimits_List2Iterator_Next(AB_TRANSACTION_LIMITS_LIST2_ITERATOR *li); 05358 05363 AB_TRANSACTION_LIMITS *AB_TransactionLimits_List2Iterator_Data(AB_TRANSACTION_LIMITS_LIST2_ITERATOR *li); 05364 05376 AB_TRANSACTION_LIMITS *AB_TransactionLimits_List2_ForEach(AB_TRANSACTION_LIMITS_LIST2 *list, 05377 AB_TRANSACTION_LIMITS_LIST2_FOREACH func, 05378 void *user_data); 05379 05380 05381 typedef struct AB_TRANSACTION_LIMITS_CONSTLIST2 AB_TRANSACTION_LIMITS_CONSTLIST2; 05382 typedef struct AB_TRANSACTION_LIMITS_CONSTLIST2_ITERATOR AB_TRANSACTION_LIMITS_CONSTLIST2_ITERATOR; 05383 typedef const AB_TRANSACTION_LIMITS* 05384 (AB_TRANSACTION_LIMITS_CONSTLIST2_FOREACH)(const AB_TRANSACTION_LIMITS *element, 05385 void *user_data); 05386 05387 05388 AB_TRANSACTION_LIMITS_CONSTLIST2 *AB_TransactionLimits_ConstList2_new(); 05389 05390 void AB_TransactionLimits_ConstList2_free(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 05391 05392 void AB_TransactionLimits_ConstList2_PushBack(AB_TRANSACTION_LIMITS_CONSTLIST2 *l, const AB_TRANSACTION_LIMITS *p); 05393 05394 void AB_TransactionLimits_ConstList2_PushFront(AB_TRANSACTION_LIMITS_CONSTLIST2 *l, const AB_TRANSACTION_LIMITS *p); 05395 05396 const AB_TRANSACTION_LIMITS *AB_TransactionLimits_ConstList2_GetFront(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 05397 05398 const AB_TRANSACTION_LIMITS *AB_TransactionLimits_ConstList2_GetBack(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 05399 05400 unsigned int AB_TransactionLimits_ConstList2_GetSize(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 05401 05402 void AB_TransactionLimits_ConstList2_PopBack(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 05403 05404 void AB_TransactionLimits_ConstList2_PopFront(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 05405 05406 void AB_TransactionLimits_ConstList2_Clear(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 05407 05408 AB_TRANSACTION_LIMITS_CONSTLIST2_ITERATOR *AB_TransactionLimits_ConstList2_First(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 05409 05410 AB_TRANSACTION_LIMITS_CONSTLIST2_ITERATOR *AB_TransactionLimits_ConstList2_Last(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 05411 05412 AB_TRANSACTION_LIMITS_CONSTLIST2_ITERATOR *AB_TransactionLimits_ConstList2Iterator_new(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 05413 05414 void AB_TransactionLimits_ConstList2Iterator_free(AB_TRANSACTION_LIMITS_CONSTLIST2_ITERATOR *li); 05415 05416 const AB_TRANSACTION_LIMITS *AB_TransactionLimits_ConstList2Iterator_Previous(AB_TRANSACTION_LIMITS_CONSTLIST2_ITERATOR *li); 05417 05418 const AB_TRANSACTION_LIMITS *AB_TransactionLimits_ConstList2Iterator_Next(AB_TRANSACTION_LIMITS_CONSTLIST2_ITERATOR *li); 05419 05420 const AB_TRANSACTION_LIMITS *AB_TransactionLimits_ConstList2Iterator_Data(AB_TRANSACTION_LIMITS_CONSTLIST2_ITERATOR *li); 05421 05433 const AB_TRANSACTION_LIMITS *AB_TransactionLimits_ConstList2_ForEach(AB_TRANSACTION_LIMITS_CONSTLIST2 *list, 05434 AB_TRANSACTION_LIMITS_CONSTLIST2_FOREACH func, void *user_data); 05435 05436 05437 #ifdef __cplusplus 05438 } 05439 #endif 05440 05441 05442 #endif /* AB_TRANSACTION_LIMITS_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_TRANSACTION_LIMITS_LIST1_H 05475 #define AB_TRANSACTION_LIMITS_LIST1_H 05476 05477 #ifdef __cplusplus 05478 extern "C" { 05479 #endif 05480 05482 typedef struct AB_TRANSACTION_LIMITS_LIST_ELEMENT { 05483 uint32_t id; 05484 AB_TRANSACTION_LIMITS *nextObject; 05485 } AB_TRANSACTION_LIMITS_LIST__ELEMENT; 05486 05493 typedef struct AB_TRANSACTION_LIMITS_LIST AB_TRANSACTION_LIMITS_LIST; 05494 05498 typedef int GWENHYWFAR_CB (*AB_TRANSACTION_LIMITS_LIST_SORT_FN)(const AB_TRANSACTION_LIMITS *a, const AB_TRANSACTION_LIMITS *b, int ascending); 05499 05500 05502 struct AB_TRANSACTION_LIMITS_LIST { 05503 AB_TRANSACTION_LIMITS *first; 05504 uint32_t count; 05505 uint32_t id; 05506 } AB_TRANSACTION_LIMITS_LIST; 05507 05512 void AB_TransactionLimits_List_AddList(AB_TRANSACTION_LIMITS_LIST *dst, AB_TRANSACTION_LIMITS_LIST *l); 05513 05517 void AB_TransactionLimits_List_Add(AB_TRANSACTION_LIMITS *element, AB_TRANSACTION_LIMITS_LIST *list); 05518 05523 void AB_TransactionLimits_List_Insert(AB_TRANSACTION_LIMITS *element, AB_TRANSACTION_LIMITS_LIST *list); 05524 05531 void AB_TransactionLimits_List_Del(AB_TRANSACTION_LIMITS *element); 05532 05536 AB_TRANSACTION_LIMITS* AB_TransactionLimits_List_First(const AB_TRANSACTION_LIMITS_LIST *l); 05537 05541 AB_TRANSACTION_LIMITS* AB_TransactionLimits_List_Last(const AB_TRANSACTION_LIMITS_LIST *l); 05542 05547 void AB_TransactionLimits_List_Clear(AB_TRANSACTION_LIMITS_LIST *l); 05548 05552 AB_TRANSACTION_LIMITS_LIST* AB_TransactionLimits_List_new(); 05553 05557 void AB_TransactionLimits_List_free(AB_TRANSACTION_LIMITS_LIST *l); 05558 05562 AB_TRANSACTION_LIMITS* AB_TransactionLimits_List_Next(const AB_TRANSACTION_LIMITS *element); 05563 05567 AB_TRANSACTION_LIMITS* AB_TransactionLimits_List_Previous(const AB_TRANSACTION_LIMITS *element); 05568 05572 uint32_t AB_TransactionLimits_List_GetCount(const AB_TRANSACTION_LIMITS_LIST *l); 05573 05577 AB_TRANSACTION_LIMITS_LIST_SORT_FN AB_TransactionLimits_List_SetSortFn(AB_TRANSACTION_LIMITS_LIST *l, AB_TRANSACTION_LIMITS_LIST_SORT_FN fn); 05578 05584 void AB_TransactionLimits_List_Sort(AB_TRANSACTION_LIMITS_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_USER_LIST2_H 05625 #define AB_USER_LIST2_H 05626 05627 05628 #ifdef __cplusplus 05629 extern "C" { 05630 #endif 05631 05638 typedef struct AB_USER_LIST2 AB_USER_LIST2; 05639 05643 typedef struct AB_USER_LIST2_ITERATOR AB_USER_LIST2_ITERATOR; 05644 05648 typedef AB_USER* (AB_USER_LIST2_FOREACH)(AB_USER *element, 05649 void *user_data); 05650 05654 AB_USER_LIST2 *AB_User_List2_new(); 05655 05659 void AB_User_List2_free(AB_USER_LIST2 *l); 05660 05664 void AB_User_List2_Dump(AB_USER_LIST2 *l, FILE *f, unsigned int indent); 05665 05669 void AB_User_List2_PushBack(AB_USER_LIST2 *l, AB_USER *p); 05670 05675 void AB_User_List2_PushFront(AB_USER_LIST2 *l, AB_USER *p); 05676 05681 AB_USER *AB_User_List2_GetFront(AB_USER_LIST2 *l); 05682 05687 AB_USER *AB_User_List2_GetBack(AB_USER_LIST2 *l); 05688 05693 void AB_User_List2_Erase(AB_USER_LIST2 *l, 05694 AB_USER_LIST2_ITERATOR *it); 05695 05701 unsigned int AB_User_List2_GetSize(AB_USER_LIST2 *l); 05702 05707 void AB_User_List2_PopBack(AB_USER_LIST2 *l); 05708 05713 void AB_User_List2_PopFront(AB_USER_LIST2 *l); 05714 05718 void AB_User_List2_Clear(AB_USER_LIST2 *l); 05719 05723 AB_USER_LIST2_ITERATOR *AB_User_List2_First(AB_USER_LIST2 *l); 05724 05728 AB_USER_LIST2_ITERATOR *AB_User_List2_Last(AB_USER_LIST2 *l); 05729 05733 AB_USER_LIST2_ITERATOR *AB_User_List2Iterator_new(AB_USER_LIST2 *l); 05734 05738 void AB_User_List2Iterator_free(AB_USER_LIST2_ITERATOR *li); 05739 05744 AB_USER *AB_User_List2Iterator_Previous(AB_USER_LIST2_ITERATOR *li); 05745 05750 AB_USER *AB_User_List2Iterator_Next(AB_USER_LIST2_ITERATOR *li); 05751 05756 AB_USER *AB_User_List2Iterator_Data(AB_USER_LIST2_ITERATOR *li); 05757 05769 AB_USER *AB_User_List2_ForEach(AB_USER_LIST2 *list, 05770 AB_USER_LIST2_FOREACH func, 05771 void *user_data); 05772 05773 05774 typedef struct AB_USER_CONSTLIST2 AB_USER_CONSTLIST2; 05775 typedef struct AB_USER_CONSTLIST2_ITERATOR AB_USER_CONSTLIST2_ITERATOR; 05776 typedef const AB_USER* 05777 (AB_USER_CONSTLIST2_FOREACH)(const AB_USER *element, 05778 void *user_data); 05779 05780 05781 AB_USER_CONSTLIST2 *AB_User_ConstList2_new(); 05782 05783 void AB_User_ConstList2_free(AB_USER_CONSTLIST2 *l); 05784 05785 void AB_User_ConstList2_PushBack(AB_USER_CONSTLIST2 *l, const AB_USER *p); 05786 05787 void AB_User_ConstList2_PushFront(AB_USER_CONSTLIST2 *l, const AB_USER *p); 05788 05789 const AB_USER *AB_User_ConstList2_GetFront(AB_USER_CONSTLIST2 *l); 05790 05791 const AB_USER *AB_User_ConstList2_GetBack(AB_USER_CONSTLIST2 *l); 05792 05793 unsigned int AB_User_ConstList2_GetSize(AB_USER_CONSTLIST2 *l); 05794 05795 void AB_User_ConstList2_PopBack(AB_USER_CONSTLIST2 *l); 05796 05797 void AB_User_ConstList2_PopFront(AB_USER_CONSTLIST2 *l); 05798 05799 void AB_User_ConstList2_Clear(AB_USER_CONSTLIST2 *l); 05800 05801 AB_USER_CONSTLIST2_ITERATOR *AB_User_ConstList2_First(AB_USER_CONSTLIST2 *l); 05802 05803 AB_USER_CONSTLIST2_ITERATOR *AB_User_ConstList2_Last(AB_USER_CONSTLIST2 *l); 05804 05805 AB_USER_CONSTLIST2_ITERATOR *AB_User_ConstList2Iterator_new(AB_USER_CONSTLIST2 *l); 05806 05807 void AB_User_ConstList2Iterator_free(AB_USER_CONSTLIST2_ITERATOR *li); 05808 05809 const AB_USER *AB_User_ConstList2Iterator_Previous(AB_USER_CONSTLIST2_ITERATOR *li); 05810 05811 const AB_USER *AB_User_ConstList2Iterator_Next(AB_USER_CONSTLIST2_ITERATOR *li); 05812 05813 const AB_USER *AB_User_ConstList2Iterator_Data(AB_USER_CONSTLIST2_ITERATOR *li); 05814 05826 const AB_USER *AB_User_ConstList2_ForEach(AB_USER_CONSTLIST2 *list, 05827 AB_USER_CONSTLIST2_FOREACH func, void *user_data); 05828 05829 05830 #ifdef __cplusplus 05831 } 05832 #endif 05833 05834 05835 #endif /* AB_USER_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_VALUE_LIST1_H 05868 #define AB_VALUE_LIST1_H 05869 05870 #ifdef __cplusplus 05871 extern "C" { 05872 #endif 05873 05875 typedef struct AB_VALUE_LIST_ELEMENT { 05876 uint32_t id; 05877 AB_VALUE *nextObject; 05878 } AB_VALUE_LIST__ELEMENT; 05879 05886 typedef struct AB_VALUE_LIST AB_VALUE_LIST; 05887 05891 typedef int GWENHYWFAR_CB (*AB_VALUE_LIST_SORT_FN)(const AB_VALUE *a, const AB_VALUE *b, int ascending); 05892 05893 05895 struct AB_VALUE_LIST { 05896 AB_VALUE *first; 05897 uint32_t count; 05898 uint32_t id; 05899 } AB_VALUE_LIST; 05900 05905 void AB_Value_List_AddList(AB_VALUE_LIST *dst, AB_VALUE_LIST *l); 05906 05910 void AB_Value_List_Add(AB_VALUE *element, AB_VALUE_LIST *list); 05911 05916 void AB_Value_List_Insert(AB_VALUE *element, AB_VALUE_LIST *list); 05917 05924 void AB_Value_List_Del(AB_VALUE *element); 05925 05929 AB_VALUE* AB_Value_List_First(const AB_VALUE_LIST *l); 05930 05934 AB_VALUE* AB_Value_List_Last(const AB_VALUE_LIST *l); 05935 05940 void AB_Value_List_Clear(AB_VALUE_LIST *l); 05941 05945 AB_VALUE_LIST* AB_Value_List_new(); 05946 05950 void AB_Value_List_free(AB_VALUE_LIST *l); 05951 05955 AB_VALUE* AB_Value_List_Next(const AB_VALUE *element); 05956 05960 AB_VALUE* AB_Value_List_Previous(const AB_VALUE *element); 05961 05965 uint32_t AB_Value_List_GetCount(const AB_VALUE_LIST *l); 05966 05970 AB_VALUE_LIST_SORT_FN AB_Value_List_SetSortFn(AB_VALUE_LIST *l, AB_VALUE_LIST_SORT_FN fn); 05971 05977 void AB_Value_List_Sort(AB_VALUE_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 AH_TAN_METHOD_LIST2_H 06018 #define AH_TAN_METHOD_LIST2_H 06019 06020 06021 #ifdef __cplusplus 06022 extern "C" { 06023 #endif 06024 06031 typedef struct AH_TAN_METHOD_LIST2 AH_TAN_METHOD_LIST2; 06032 06036 typedef struct AH_TAN_METHOD_LIST2_ITERATOR AH_TAN_METHOD_LIST2_ITERATOR; 06037 06041 typedef AH_TAN_METHOD* (AH_TAN_METHOD_LIST2_FOREACH)(AH_TAN_METHOD *element, 06042 void *user_data); 06043 06047 AH_TAN_METHOD_LIST2 *AH_TanMethod_List2_new(); 06048 06052 void AH_TanMethod_List2_free(AH_TAN_METHOD_LIST2 *l); 06053 06057 void AH_TanMethod_List2_Dump(AH_TAN_METHOD_LIST2 *l, FILE *f, unsigned int indent); 06058 06062 void AH_TanMethod_List2_PushBack(AH_TAN_METHOD_LIST2 *l, AH_TAN_METHOD *p); 06063 06068 void AH_TanMethod_List2_PushFront(AH_TAN_METHOD_LIST2 *l, AH_TAN_METHOD *p); 06069 06074 AH_TAN_METHOD *AH_TanMethod_List2_GetFront(AH_TAN_METHOD_LIST2 *l); 06075 06080 AH_TAN_METHOD *AH_TanMethod_List2_GetBack(AH_TAN_METHOD_LIST2 *l); 06081 06086 void AH_TanMethod_List2_Erase(AH_TAN_METHOD_LIST2 *l, 06087 AH_TAN_METHOD_LIST2_ITERATOR *it); 06088 06094 unsigned int AH_TanMethod_List2_GetSize(AH_TAN_METHOD_LIST2 *l); 06095 06100 void AH_TanMethod_List2_PopBack(AH_TAN_METHOD_LIST2 *l); 06101 06106 void AH_TanMethod_List2_PopFront(AH_TAN_METHOD_LIST2 *l); 06107 06111 void AH_TanMethod_List2_Clear(AH_TAN_METHOD_LIST2 *l); 06112 06116 AH_TAN_METHOD_LIST2_ITERATOR *AH_TanMethod_List2_First(AH_TAN_METHOD_LIST2 *l); 06117 06121 AH_TAN_METHOD_LIST2_ITERATOR *AH_TanMethod_List2_Last(AH_TAN_METHOD_LIST2 *l); 06122 06126 AH_TAN_METHOD_LIST2_ITERATOR *AH_TanMethod_List2Iterator_new(AH_TAN_METHOD_LIST2 *l); 06127 06131 void AH_TanMethod_List2Iterator_free(AH_TAN_METHOD_LIST2_ITERATOR *li); 06132 06137 AH_TAN_METHOD *AH_TanMethod_List2Iterator_Previous(AH_TAN_METHOD_LIST2_ITERATOR *li); 06138 06143 AH_TAN_METHOD *AH_TanMethod_List2Iterator_Next(AH_TAN_METHOD_LIST2_ITERATOR *li); 06144 06149 AH_TAN_METHOD *AH_TanMethod_List2Iterator_Data(AH_TAN_METHOD_LIST2_ITERATOR *li); 06150 06162 AH_TAN_METHOD *AH_TanMethod_List2_ForEach(AH_TAN_METHOD_LIST2 *list, 06163 AH_TAN_METHOD_LIST2_FOREACH func, 06164 void *user_data); 06165 06166 06167 typedef struct AH_TAN_METHOD_CONSTLIST2 AH_TAN_METHOD_CONSTLIST2; 06168 typedef struct AH_TAN_METHOD_CONSTLIST2_ITERATOR AH_TAN_METHOD_CONSTLIST2_ITERATOR; 06169 typedef const AH_TAN_METHOD* 06170 (AH_TAN_METHOD_CONSTLIST2_FOREACH)(const AH_TAN_METHOD *element, 06171 void *user_data); 06172 06173 06174 AH_TAN_METHOD_CONSTLIST2 *AH_TanMethod_ConstList2_new(); 06175 06176 void AH_TanMethod_ConstList2_free(AH_TAN_METHOD_CONSTLIST2 *l); 06177 06178 void AH_TanMethod_ConstList2_PushBack(AH_TAN_METHOD_CONSTLIST2 *l, const AH_TAN_METHOD *p); 06179 06180 void AH_TanMethod_ConstList2_PushFront(AH_TAN_METHOD_CONSTLIST2 *l, const AH_TAN_METHOD *p); 06181 06182 const AH_TAN_METHOD *AH_TanMethod_ConstList2_GetFront(AH_TAN_METHOD_CONSTLIST2 *l); 06183 06184 const AH_TAN_METHOD *AH_TanMethod_ConstList2_GetBack(AH_TAN_METHOD_CONSTLIST2 *l); 06185 06186 unsigned int AH_TanMethod_ConstList2_GetSize(AH_TAN_METHOD_CONSTLIST2 *l); 06187 06188 void AH_TanMethod_ConstList2_PopBack(AH_TAN_METHOD_CONSTLIST2 *l); 06189 06190 void AH_TanMethod_ConstList2_PopFront(AH_TAN_METHOD_CONSTLIST2 *l); 06191 06192 void AH_TanMethod_ConstList2_Clear(AH_TAN_METHOD_CONSTLIST2 *l); 06193 06194 AH_TAN_METHOD_CONSTLIST2_ITERATOR *AH_TanMethod_ConstList2_First(AH_TAN_METHOD_CONSTLIST2 *l); 06195 06196 AH_TAN_METHOD_CONSTLIST2_ITERATOR *AH_TanMethod_ConstList2_Last(AH_TAN_METHOD_CONSTLIST2 *l); 06197 06198 AH_TAN_METHOD_CONSTLIST2_ITERATOR *AH_TanMethod_ConstList2Iterator_new(AH_TAN_METHOD_CONSTLIST2 *l); 06199 06200 void AH_TanMethod_ConstList2Iterator_free(AH_TAN_METHOD_CONSTLIST2_ITERATOR *li); 06201 06202 const AH_TAN_METHOD *AH_TanMethod_ConstList2Iterator_Previous(AH_TAN_METHOD_CONSTLIST2_ITERATOR *li); 06203 06204 const AH_TAN_METHOD *AH_TanMethod_ConstList2Iterator_Next(AH_TAN_METHOD_CONSTLIST2_ITERATOR *li); 06205 06206 const AH_TAN_METHOD *AH_TanMethod_ConstList2Iterator_Data(AH_TAN_METHOD_CONSTLIST2_ITERATOR *li); 06207 06219 const AH_TAN_METHOD *AH_TanMethod_ConstList2_ForEach(AH_TAN_METHOD_CONSTLIST2 *list, 06220 AH_TAN_METHOD_CONSTLIST2_FOREACH func, void *user_data); 06221 06222 06223 #ifdef __cplusplus 06224 } 06225 #endif 06226 06227 06228 #endif /* AH_TAN_METHOD_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 AH_TAN_METHOD_LIST1_H 06261 #define AH_TAN_METHOD_LIST1_H 06262 06263 #ifdef __cplusplus 06264 extern "C" { 06265 #endif 06266 06268 typedef struct AH_TAN_METHOD_LIST_ELEMENT { 06269 uint32_t id; 06270 AH_TAN_METHOD *nextObject; 06271 } AH_TAN_METHOD_LIST__ELEMENT; 06272 06279 typedef struct AH_TAN_METHOD_LIST AH_TAN_METHOD_LIST; 06280 06284 typedef int GWENHYWFAR_CB (*AH_TAN_METHOD_LIST_SORT_FN)(const AH_TAN_METHOD *a, const AH_TAN_METHOD *b, int ascending); 06285 06286 06288 struct AH_TAN_METHOD_LIST { 06289 AH_TAN_METHOD *first; 06290 uint32_t count; 06291 uint32_t id; 06292 } AH_TAN_METHOD_LIST; 06293 06298 void AH_TanMethod_List_AddList(AH_TAN_METHOD_LIST *dst, AH_TAN_METHOD_LIST *l); 06299 06303 void AH_TanMethod_List_Add(AH_TAN_METHOD *element, AH_TAN_METHOD_LIST *list); 06304 06309 void AH_TanMethod_List_Insert(AH_TAN_METHOD *element, AH_TAN_METHOD_LIST *list); 06310 06317 void AH_TanMethod_List_Del(AH_TAN_METHOD *element); 06318 06322 AH_TAN_METHOD* AH_TanMethod_List_First(const AH_TAN_METHOD_LIST *l); 06323 06327 AH_TAN_METHOD* AH_TanMethod_List_Last(const AH_TAN_METHOD_LIST *l); 06328 06333 void AH_TanMethod_List_Clear(AH_TAN_METHOD_LIST *l); 06334 06338 AH_TAN_METHOD_LIST* AH_TanMethod_List_new(); 06339 06343 void AH_TanMethod_List_free(AH_TAN_METHOD_LIST *l); 06344 06348 AH_TAN_METHOD* AH_TanMethod_List_Next(const AH_TAN_METHOD *element); 06349 06353 AH_TAN_METHOD* AH_TanMethod_List_Previous(const AH_TAN_METHOD *element); 06354 06358 uint32_t AH_TanMethod_List_GetCount(const AH_TAN_METHOD_LIST *l); 06359 06363 AH_TAN_METHOD_LIST_SORT_FN AH_TanMethod_List_SetSortFn(AH_TAN_METHOD_LIST *l, AH_TAN_METHOD_LIST_SORT_FN fn); 06364 06370 void AH_TanMethod_List_Sort(AH_TAN_METHOD_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 OH_INSTITUTE_SPEC_LIST2_H 06804 #define OH_INSTITUTE_SPEC_LIST2_H 06805 06806 06807 #ifdef __cplusplus 06808 extern "C" { 06809 #endif 06810 06817 typedef struct OH_INSTITUTE_SPEC_LIST2 OH_INSTITUTE_SPEC_LIST2; 06818 06822 typedef struct OH_INSTITUTE_SPEC_LIST2_ITERATOR OH_INSTITUTE_SPEC_LIST2_ITERATOR; 06823 06827 typedef OH_INSTITUTE_SPEC* (OH_INSTITUTE_SPEC_LIST2_FOREACH)(OH_INSTITUTE_SPEC *element, 06828 void *user_data); 06829 06833 OH_INSTITUTE_SPEC_LIST2 *OH_InstituteSpec_List2_new(); 06834 06838 void OH_InstituteSpec_List2_free(OH_INSTITUTE_SPEC_LIST2 *l); 06839 06843 void OH_InstituteSpec_List2_Dump(OH_INSTITUTE_SPEC_LIST2 *l, FILE *f, unsigned int indent); 06844 06848 void OH_InstituteSpec_List2_PushBack(OH_INSTITUTE_SPEC_LIST2 *l, OH_INSTITUTE_SPEC *p); 06849 06854 void OH_InstituteSpec_List2_PushFront(OH_INSTITUTE_SPEC_LIST2 *l, OH_INSTITUTE_SPEC *p); 06855 06860 OH_INSTITUTE_SPEC *OH_InstituteSpec_List2_GetFront(OH_INSTITUTE_SPEC_LIST2 *l); 06861 06866 OH_INSTITUTE_SPEC *OH_InstituteSpec_List2_GetBack(OH_INSTITUTE_SPEC_LIST2 *l); 06867 06872 void OH_InstituteSpec_List2_Erase(OH_INSTITUTE_SPEC_LIST2 *l, 06873 OH_INSTITUTE_SPEC_LIST2_ITERATOR *it); 06874 06880 unsigned int OH_InstituteSpec_List2_GetSize(OH_INSTITUTE_SPEC_LIST2 *l); 06881 06886 void OH_InstituteSpec_List2_PopBack(OH_INSTITUTE_SPEC_LIST2 *l); 06887 06892 void OH_InstituteSpec_List2_PopFront(OH_INSTITUTE_SPEC_LIST2 *l); 06893 06897 void OH_InstituteSpec_List2_Clear(OH_INSTITUTE_SPEC_LIST2 *l); 06898 06902 OH_INSTITUTE_SPEC_LIST2_ITERATOR *OH_InstituteSpec_List2_First(OH_INSTITUTE_SPEC_LIST2 *l); 06903 06907 OH_INSTITUTE_SPEC_LIST2_ITERATOR *OH_InstituteSpec_List2_Last(OH_INSTITUTE_SPEC_LIST2 *l); 06908 06912 OH_INSTITUTE_SPEC_LIST2_ITERATOR *OH_InstituteSpec_List2Iterator_new(OH_INSTITUTE_SPEC_LIST2 *l); 06913 06917 void OH_InstituteSpec_List2Iterator_free(OH_INSTITUTE_SPEC_LIST2_ITERATOR *li); 06918 06923 OH_INSTITUTE_SPEC *OH_InstituteSpec_List2Iterator_Previous(OH_INSTITUTE_SPEC_LIST2_ITERATOR *li); 06924 06929 OH_INSTITUTE_SPEC *OH_InstituteSpec_List2Iterator_Next(OH_INSTITUTE_SPEC_LIST2_ITERATOR *li); 06930 06935 OH_INSTITUTE_SPEC *OH_InstituteSpec_List2Iterator_Data(OH_INSTITUTE_SPEC_LIST2_ITERATOR *li); 06936 06948 OH_INSTITUTE_SPEC *OH_InstituteSpec_List2_ForEach(OH_INSTITUTE_SPEC_LIST2 *list, 06949 OH_INSTITUTE_SPEC_LIST2_FOREACH func, 06950 void *user_data); 06951 06952 06953 typedef struct OH_INSTITUTE_SPEC_CONSTLIST2 OH_INSTITUTE_SPEC_CONSTLIST2; 06954 typedef struct OH_INSTITUTE_SPEC_CONSTLIST2_ITERATOR OH_INSTITUTE_SPEC_CONSTLIST2_ITERATOR; 06955 typedef const OH_INSTITUTE_SPEC* 06956 (OH_INSTITUTE_SPEC_CONSTLIST2_FOREACH)(const OH_INSTITUTE_SPEC *element, 06957 void *user_data); 06958 06959 06960 OH_INSTITUTE_SPEC_CONSTLIST2 *OH_InstituteSpec_ConstList2_new(); 06961 06962 void OH_InstituteSpec_ConstList2_free(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 06963 06964 void OH_InstituteSpec_ConstList2_PushBack(OH_INSTITUTE_SPEC_CONSTLIST2 *l, const OH_INSTITUTE_SPEC *p); 06965 06966 void OH_InstituteSpec_ConstList2_PushFront(OH_INSTITUTE_SPEC_CONSTLIST2 *l, const OH_INSTITUTE_SPEC *p); 06967 06968 const OH_INSTITUTE_SPEC *OH_InstituteSpec_ConstList2_GetFront(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 06969 06970 const OH_INSTITUTE_SPEC *OH_InstituteSpec_ConstList2_GetBack(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 06971 06972 unsigned int OH_InstituteSpec_ConstList2_GetSize(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 06973 06974 void OH_InstituteSpec_ConstList2_PopBack(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 06975 06976 void OH_InstituteSpec_ConstList2_PopFront(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 06977 06978 void OH_InstituteSpec_ConstList2_Clear(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 06979 06980 OH_INSTITUTE_SPEC_CONSTLIST2_ITERATOR *OH_InstituteSpec_ConstList2_First(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 06981 06982 OH_INSTITUTE_SPEC_CONSTLIST2_ITERATOR *OH_InstituteSpec_ConstList2_Last(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 06983 06984 OH_INSTITUTE_SPEC_CONSTLIST2_ITERATOR *OH_InstituteSpec_ConstList2Iterator_new(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 06985 06986 void OH_InstituteSpec_ConstList2Iterator_free(OH_INSTITUTE_SPEC_CONSTLIST2_ITERATOR *li); 06987 06988 const OH_INSTITUTE_SPEC *OH_InstituteSpec_ConstList2Iterator_Previous(OH_INSTITUTE_SPEC_CONSTLIST2_ITERATOR *li); 06989 06990 const OH_INSTITUTE_SPEC *OH_InstituteSpec_ConstList2Iterator_Next(OH_INSTITUTE_SPEC_CONSTLIST2_ITERATOR *li); 06991 06992 const OH_INSTITUTE_SPEC *OH_InstituteSpec_ConstList2Iterator_Data(OH_INSTITUTE_SPEC_CONSTLIST2_ITERATOR *li); 06993 07005 const OH_INSTITUTE_SPEC *OH_InstituteSpec_ConstList2_ForEach(OH_INSTITUTE_SPEC_CONSTLIST2 *list, 07006 OH_INSTITUTE_SPEC_CONSTLIST2_FOREACH func, void *user_data); 07007 07008 07009 #ifdef __cplusplus 07010 } 07011 #endif 07012 07013 07014 #endif /* OH_INSTITUTE_SPEC_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 OH_INSTITUTE_SPEC_LIST1_H 07047 #define OH_INSTITUTE_SPEC_LIST1_H 07048 07049 #ifdef __cplusplus 07050 extern "C" { 07051 #endif 07052 07054 typedef struct OH_INSTITUTE_SPEC_LIST_ELEMENT { 07055 uint32_t id; 07056 OH_INSTITUTE_SPEC *nextObject; 07057 } OH_INSTITUTE_SPEC_LIST__ELEMENT; 07058 07065 typedef struct OH_INSTITUTE_SPEC_LIST OH_INSTITUTE_SPEC_LIST; 07066 07070 typedef int GWENHYWFAR_CB (*OH_INSTITUTE_SPEC_LIST_SORT_FN)(const OH_INSTITUTE_SPEC *a, const OH_INSTITUTE_SPEC *b, int ascending); 07071 07072 07074 struct OH_INSTITUTE_SPEC_LIST { 07075 OH_INSTITUTE_SPEC *first; 07076 uint32_t count; 07077 uint32_t id; 07078 } OH_INSTITUTE_SPEC_LIST; 07079 07084 void OH_InstituteSpec_List_AddList(OH_INSTITUTE_SPEC_LIST *dst, OH_INSTITUTE_SPEC_LIST *l); 07085 07089 void OH_InstituteSpec_List_Add(OH_INSTITUTE_SPEC *element, OH_INSTITUTE_SPEC_LIST *list); 07090 07095 void OH_InstituteSpec_List_Insert(OH_INSTITUTE_SPEC *element, OH_INSTITUTE_SPEC_LIST *list); 07096 07103 void OH_InstituteSpec_List_Del(OH_INSTITUTE_SPEC *element); 07104 07108 OH_INSTITUTE_SPEC* OH_InstituteSpec_List_First(const OH_INSTITUTE_SPEC_LIST *l); 07109 07113 OH_INSTITUTE_SPEC* OH_InstituteSpec_List_Last(const OH_INSTITUTE_SPEC_LIST *l); 07114 07119 void OH_InstituteSpec_List_Clear(OH_INSTITUTE_SPEC_LIST *l); 07120 07124 OH_INSTITUTE_SPEC_LIST* OH_InstituteSpec_List_new(); 07125 07129 void OH_InstituteSpec_List_free(OH_INSTITUTE_SPEC_LIST *l); 07130 07134 OH_INSTITUTE_SPEC* OH_InstituteSpec_List_Next(const OH_INSTITUTE_SPEC *element); 07135 07139 OH_INSTITUTE_SPEC* OH_InstituteSpec_List_Previous(const OH_INSTITUTE_SPEC *element); 07140 07144 uint32_t OH_InstituteSpec_List_GetCount(const OH_INSTITUTE_SPEC_LIST *l); 07145 07149 OH_INSTITUTE_SPEC_LIST_SORT_FN OH_InstituteSpec_List_SetSortFn(OH_INSTITUTE_SPEC_LIST *l, OH_INSTITUTE_SPEC_LIST_SORT_FN fn); 07150 07156 void OH_InstituteSpec_List_Sort(OH_INSTITUTE_SPEC_LIST *l, int ascending); 07157 07158 07159 #ifdef __cplusplus 07160 } 07161 #endif 07162 07163 07164 #endif 07165 07166 07167