aqbanking 5.0.2
|
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_BANKINFO_PLUGIN_LIST2_H 00030 #define AB_BANKINFO_PLUGIN_LIST2_H 00031 00032 00033 #ifdef __cplusplus 00034 extern "C" { 00035 #endif 00036 00043 typedef struct AB_BANKINFO_PLUGIN_LIST2 AB_BANKINFO_PLUGIN_LIST2; 00044 00048 typedef struct AB_BANKINFO_PLUGIN_LIST2_ITERATOR AB_BANKINFO_PLUGIN_LIST2_ITERATOR; 00049 00053 typedef AB_BANKINFO_PLUGIN* (AB_BANKINFO_PLUGIN_LIST2_FOREACH)(AB_BANKINFO_PLUGIN *element, 00054 void *user_data); 00055 00059 AB_BANKINFO_PLUGIN_LIST2 *AB_BankInfoPlugin_List2_new(); 00060 00064 void AB_BankInfoPlugin_List2_free(AB_BANKINFO_PLUGIN_LIST2 *l); 00065 00069 void AB_BankInfoPlugin_List2_Dump(AB_BANKINFO_PLUGIN_LIST2 *l, FILE *f, unsigned int indent); 00070 00074 void AB_BankInfoPlugin_List2_PushBack(AB_BANKINFO_PLUGIN_LIST2 *l, AB_BANKINFO_PLUGIN *p); 00075 00080 void AB_BankInfoPlugin_List2_PushFront(AB_BANKINFO_PLUGIN_LIST2 *l, AB_BANKINFO_PLUGIN *p); 00081 00086 AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_List2_GetFront(AB_BANKINFO_PLUGIN_LIST2 *l); 00087 00092 AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_List2_GetBack(AB_BANKINFO_PLUGIN_LIST2 *l); 00093 00098 void AB_BankInfoPlugin_List2_Erase(AB_BANKINFO_PLUGIN_LIST2 *l, 00099 AB_BANKINFO_PLUGIN_LIST2_ITERATOR *it); 00100 00106 unsigned int AB_BankInfoPlugin_List2_GetSize(AB_BANKINFO_PLUGIN_LIST2 *l); 00107 00112 void AB_BankInfoPlugin_List2_PopBack(AB_BANKINFO_PLUGIN_LIST2 *l); 00113 00118 void AB_BankInfoPlugin_List2_PopFront(AB_BANKINFO_PLUGIN_LIST2 *l); 00119 00123 void AB_BankInfoPlugin_List2_Clear(AB_BANKINFO_PLUGIN_LIST2 *l); 00124 00128 AB_BANKINFO_PLUGIN_LIST2_ITERATOR *AB_BankInfoPlugin_List2_First(AB_BANKINFO_PLUGIN_LIST2 *l); 00129 00133 AB_BANKINFO_PLUGIN_LIST2_ITERATOR *AB_BankInfoPlugin_List2_Last(AB_BANKINFO_PLUGIN_LIST2 *l); 00134 00138 AB_BANKINFO_PLUGIN_LIST2_ITERATOR *AB_BankInfoPlugin_List2Iterator_new(AB_BANKINFO_PLUGIN_LIST2 *l); 00139 00143 void AB_BankInfoPlugin_List2Iterator_free(AB_BANKINFO_PLUGIN_LIST2_ITERATOR *li); 00144 00149 AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_List2Iterator_Previous(AB_BANKINFO_PLUGIN_LIST2_ITERATOR *li); 00150 00155 AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_List2Iterator_Next(AB_BANKINFO_PLUGIN_LIST2_ITERATOR *li); 00156 00161 AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_List2Iterator_Data(AB_BANKINFO_PLUGIN_LIST2_ITERATOR *li); 00162 00174 AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_List2_ForEach(AB_BANKINFO_PLUGIN_LIST2 *list, 00175 AB_BANKINFO_PLUGIN_LIST2_FOREACH func, 00176 void *user_data); 00177 00178 00179 typedef struct AB_BANKINFO_PLUGIN_CONSTLIST2 AB_BANKINFO_PLUGIN_CONSTLIST2; 00180 typedef struct AB_BANKINFO_PLUGIN_CONSTLIST2_ITERATOR AB_BANKINFO_PLUGIN_CONSTLIST2_ITERATOR; 00181 typedef const AB_BANKINFO_PLUGIN* 00182 (AB_BANKINFO_PLUGIN_CONSTLIST2_FOREACH)(const AB_BANKINFO_PLUGIN *element, 00183 void *user_data); 00184 00185 00186 AB_BANKINFO_PLUGIN_CONSTLIST2 *AB_BankInfoPlugin_ConstList2_new(); 00187 00188 void AB_BankInfoPlugin_ConstList2_free(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 00189 00190 void AB_BankInfoPlugin_ConstList2_PushBack(AB_BANKINFO_PLUGIN_CONSTLIST2 *l, const AB_BANKINFO_PLUGIN *p); 00191 00192 void AB_BankInfoPlugin_ConstList2_PushFront(AB_BANKINFO_PLUGIN_CONSTLIST2 *l, const AB_BANKINFO_PLUGIN *p); 00193 00194 const AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_ConstList2_GetFront(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 00195 00196 const AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_ConstList2_GetBack(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 00197 00198 unsigned int AB_BankInfoPlugin_ConstList2_GetSize(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 00199 00200 void AB_BankInfoPlugin_ConstList2_PopBack(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 00201 00202 void AB_BankInfoPlugin_ConstList2_PopFront(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 00203 00204 void AB_BankInfoPlugin_ConstList2_Clear(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 00205 00206 AB_BANKINFO_PLUGIN_CONSTLIST2_ITERATOR *AB_BankInfoPlugin_ConstList2_First(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 00207 00208 AB_BANKINFO_PLUGIN_CONSTLIST2_ITERATOR *AB_BankInfoPlugin_ConstList2_Last(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 00209 00210 AB_BANKINFO_PLUGIN_CONSTLIST2_ITERATOR *AB_BankInfoPlugin_ConstList2Iterator_new(AB_BANKINFO_PLUGIN_CONSTLIST2 *l); 00211 00212 void AB_BankInfoPlugin_ConstList2Iterator_free(AB_BANKINFO_PLUGIN_CONSTLIST2_ITERATOR *li); 00213 00214 const AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_ConstList2Iterator_Previous(AB_BANKINFO_PLUGIN_CONSTLIST2_ITERATOR *li); 00215 00216 const AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_ConstList2Iterator_Next(AB_BANKINFO_PLUGIN_CONSTLIST2_ITERATOR *li); 00217 00218 const AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_ConstList2Iterator_Data(AB_BANKINFO_PLUGIN_CONSTLIST2_ITERATOR *li); 00219 00231 const AB_BANKINFO_PLUGIN *AB_BankInfoPlugin_ConstList2_ForEach(AB_BANKINFO_PLUGIN_CONSTLIST2 *list, 00232 AB_BANKINFO_PLUGIN_CONSTLIST2_FOREACH func, void *user_data); 00233 00234 00235 #ifdef __cplusplus 00236 } 00237 #endif 00238 00239 00240 #endif /* AB_BANKINFO_PLUGIN_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_JOBQUEUE_LIST1_H 00273 #define AB_JOBQUEUE_LIST1_H 00274 00275 #ifdef __cplusplus 00276 extern "C" { 00277 #endif 00278 00280 typedef struct AB_JOBQUEUE_LIST_ELEMENT { 00281 uint32_t id; 00282 AB_JOBQUEUE *nextObject; 00283 } AB_JOBQUEUE_LIST__ELEMENT; 00284 00291 typedef struct AB_JOBQUEUE_LIST AB_JOBQUEUE_LIST; 00293 struct AB_JOBQUEUE_LIST { 00294 AB_JOBQUEUE *first; 00295 uint32_t count; 00296 uint32_t id; 00297 } AB_JOBQUEUE_LIST; 00298 00303 void AB_JobQueue_List_AddList(AB_JOBQUEUE_LIST *dst, AB_JOBQUEUE_LIST *l); 00304 00308 void AB_JobQueue_List_Add(AB_JOBQUEUE *element, AB_JOBQUEUE_LIST *list); 00309 00314 void AB_JobQueue_List_Insert(AB_JOBQUEUE *element, AB_JOBQUEUE_LIST *list); 00315 00322 void AB_JobQueue_List_Del(AB_JOBQUEUE *element); 00323 00327 AB_JOBQUEUE* AB_JobQueue_List_First(const AB_JOBQUEUE_LIST *l); 00328 00332 AB_JOBQUEUE* AB_JobQueue_List_Last(const AB_JOBQUEUE_LIST *l); 00333 00338 void AB_JobQueue_List_Clear(AB_JOBQUEUE_LIST *l); 00339 00343 AB_JOBQUEUE_LIST* AB_JobQueue_List_new(); 00344 00348 void AB_JobQueue_List_free(AB_JOBQUEUE_LIST *l); 00349 00353 AB_JOBQUEUE* AB_JobQueue_List_Next(const AB_JOBQUEUE *element); 00354 00358 AB_JOBQUEUE* AB_JobQueue_List_Previous(const AB_JOBQUEUE *element); 00359 00363 uint32_t AB_JobQueue_List_GetCount(const AB_JOBQUEUE_LIST *l); 00364 00365 #ifdef __cplusplus 00366 } 00367 #endif 00368 00369 00370 #endif 00371 00372 00373 00374 /*************************************************************************** 00375 $RCSfile$ 00376 ------------------- 00377 cvs : $Id$ 00378 begin : Sat Jun 28 2003 00379 copyright : (C) 2003 by Martin Preuss 00380 email : martin@libchipcard.de 00381 00382 *************************************************************************** 00383 * * 00384 * This library is free software; you can redistribute it and/or * 00385 * modify it under the terms of the GNU Lesser General Public * 00386 * License as published by the Free Software Foundation; either * 00387 * version 2.1 of the License, or (at your option) any later version. * 00388 * * 00389 * This library is distributed in the hope that it will be useful, * 00390 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 00391 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 00392 * Lesser General Public License for more details. * 00393 * * 00394 * You should have received a copy of the GNU Lesser General Public * 00395 * License along with this library; if not, write to the Free Software * 00396 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 00397 * MA 02111-1307 USA * 00398 * * 00399 ***************************************************************************/ 00400 00401 00402 #ifndef AB_BANKINFO_LIST2_H 00403 #define AB_BANKINFO_LIST2_H 00404 00405 00406 #ifdef __cplusplus 00407 extern "C" { 00408 #endif 00409 00416 typedef struct AB_BANKINFO_LIST2 AB_BANKINFO_LIST2; 00417 00421 typedef struct AB_BANKINFO_LIST2_ITERATOR AB_BANKINFO_LIST2_ITERATOR; 00422 00426 typedef AB_BANKINFO* (AB_BANKINFO_LIST2_FOREACH)(AB_BANKINFO *element, 00427 void *user_data); 00428 00432 AB_BANKINFO_LIST2 *AB_BankInfo_List2_new(); 00433 00437 void AB_BankInfo_List2_free(AB_BANKINFO_LIST2 *l); 00438 00442 void AB_BankInfo_List2_Dump(AB_BANKINFO_LIST2 *l, FILE *f, unsigned int indent); 00443 00447 void AB_BankInfo_List2_PushBack(AB_BANKINFO_LIST2 *l, AB_BANKINFO *p); 00448 00453 void AB_BankInfo_List2_PushFront(AB_BANKINFO_LIST2 *l, AB_BANKINFO *p); 00454 00459 AB_BANKINFO *AB_BankInfo_List2_GetFront(AB_BANKINFO_LIST2 *l); 00460 00465 AB_BANKINFO *AB_BankInfo_List2_GetBack(AB_BANKINFO_LIST2 *l); 00466 00471 void AB_BankInfo_List2_Erase(AB_BANKINFO_LIST2 *l, 00472 AB_BANKINFO_LIST2_ITERATOR *it); 00473 00479 unsigned int AB_BankInfo_List2_GetSize(AB_BANKINFO_LIST2 *l); 00480 00485 void AB_BankInfo_List2_PopBack(AB_BANKINFO_LIST2 *l); 00486 00491 void AB_BankInfo_List2_PopFront(AB_BANKINFO_LIST2 *l); 00492 00496 void AB_BankInfo_List2_Clear(AB_BANKINFO_LIST2 *l); 00497 00501 AB_BANKINFO_LIST2_ITERATOR *AB_BankInfo_List2_First(AB_BANKINFO_LIST2 *l); 00502 00506 AB_BANKINFO_LIST2_ITERATOR *AB_BankInfo_List2_Last(AB_BANKINFO_LIST2 *l); 00507 00511 AB_BANKINFO_LIST2_ITERATOR *AB_BankInfo_List2Iterator_new(AB_BANKINFO_LIST2 *l); 00512 00516 void AB_BankInfo_List2Iterator_free(AB_BANKINFO_LIST2_ITERATOR *li); 00517 00522 AB_BANKINFO *AB_BankInfo_List2Iterator_Previous(AB_BANKINFO_LIST2_ITERATOR *li); 00523 00528 AB_BANKINFO *AB_BankInfo_List2Iterator_Next(AB_BANKINFO_LIST2_ITERATOR *li); 00529 00534 AB_BANKINFO *AB_BankInfo_List2Iterator_Data(AB_BANKINFO_LIST2_ITERATOR *li); 00535 00547 AB_BANKINFO *AB_BankInfo_List2_ForEach(AB_BANKINFO_LIST2 *list, 00548 AB_BANKINFO_LIST2_FOREACH func, 00549 void *user_data); 00550 00551 00552 typedef struct AB_BANKINFO_CONSTLIST2 AB_BANKINFO_CONSTLIST2; 00553 typedef struct AB_BANKINFO_CONSTLIST2_ITERATOR AB_BANKINFO_CONSTLIST2_ITERATOR; 00554 typedef const AB_BANKINFO* 00555 (AB_BANKINFO_CONSTLIST2_FOREACH)(const AB_BANKINFO *element, 00556 void *user_data); 00557 00558 00559 AB_BANKINFO_CONSTLIST2 *AB_BankInfo_ConstList2_new(); 00560 00561 void AB_BankInfo_ConstList2_free(AB_BANKINFO_CONSTLIST2 *l); 00562 00563 void AB_BankInfo_ConstList2_PushBack(AB_BANKINFO_CONSTLIST2 *l, const AB_BANKINFO *p); 00564 00565 void AB_BankInfo_ConstList2_PushFront(AB_BANKINFO_CONSTLIST2 *l, const AB_BANKINFO *p); 00566 00567 const AB_BANKINFO *AB_BankInfo_ConstList2_GetFront(AB_BANKINFO_CONSTLIST2 *l); 00568 00569 const AB_BANKINFO *AB_BankInfo_ConstList2_GetBack(AB_BANKINFO_CONSTLIST2 *l); 00570 00571 unsigned int AB_BankInfo_ConstList2_GetSize(AB_BANKINFO_CONSTLIST2 *l); 00572 00573 void AB_BankInfo_ConstList2_PopBack(AB_BANKINFO_CONSTLIST2 *l); 00574 00575 void AB_BankInfo_ConstList2_PopFront(AB_BANKINFO_CONSTLIST2 *l); 00576 00577 void AB_BankInfo_ConstList2_Clear(AB_BANKINFO_CONSTLIST2 *l); 00578 00579 AB_BANKINFO_CONSTLIST2_ITERATOR *AB_BankInfo_ConstList2_First(AB_BANKINFO_CONSTLIST2 *l); 00580 00581 AB_BANKINFO_CONSTLIST2_ITERATOR *AB_BankInfo_ConstList2_Last(AB_BANKINFO_CONSTLIST2 *l); 00582 00583 AB_BANKINFO_CONSTLIST2_ITERATOR *AB_BankInfo_ConstList2Iterator_new(AB_BANKINFO_CONSTLIST2 *l); 00584 00585 void AB_BankInfo_ConstList2Iterator_free(AB_BANKINFO_CONSTLIST2_ITERATOR *li); 00586 00587 const AB_BANKINFO *AB_BankInfo_ConstList2Iterator_Previous(AB_BANKINFO_CONSTLIST2_ITERATOR *li); 00588 00589 const AB_BANKINFO *AB_BankInfo_ConstList2Iterator_Next(AB_BANKINFO_CONSTLIST2_ITERATOR *li); 00590 00591 const AB_BANKINFO *AB_BankInfo_ConstList2Iterator_Data(AB_BANKINFO_CONSTLIST2_ITERATOR *li); 00592 00604 const AB_BANKINFO *AB_BankInfo_ConstList2_ForEach(AB_BANKINFO_CONSTLIST2 *list, 00605 AB_BANKINFO_CONSTLIST2_FOREACH func, void *user_data); 00606 00607 00608 #ifdef __cplusplus 00609 } 00610 #endif 00611 00612 00613 #endif /* AB_BANKINFO_LIST_H */ 00614 00615 00616 00617 /*************************************************************************** 00618 $RCSfile$ 00619 ------------------- 00620 cvs : $Id$ 00621 begin : Sat Jun 28 2003 00622 copyright : (C) 2003 by Martin Preuss 00623 email : martin@libchipcard.de 00624 00625 *************************************************************************** 00626 * * 00627 * This library is free software; you can redistribute it and/or * 00628 * modify it under the terms of the GNU Lesser General Public * 00629 * License as published by the Free Software Foundation; either * 00630 * version 2.1 of the License, or (at your option) any later version. * 00631 * * 00632 * This library is distributed in the hope that it will be useful, * 00633 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 00634 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 00635 * Lesser General Public License for more details. * 00636 * * 00637 * You should have received a copy of the GNU Lesser General Public * 00638 * License along with this library; if not, write to the Free Software * 00639 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 00640 * MA 02111-1307 USA * 00641 * * 00642 ***************************************************************************/ 00643 00644 00645 #ifndef AB_BANKINFO_LIST1_H 00646 #define AB_BANKINFO_LIST1_H 00647 00648 #ifdef __cplusplus 00649 extern "C" { 00650 #endif 00651 00653 typedef struct AB_BANKINFO_LIST_ELEMENT { 00654 uint32_t id; 00655 AB_BANKINFO *nextObject; 00656 } AB_BANKINFO_LIST__ELEMENT; 00657 00664 typedef struct AB_BANKINFO_LIST AB_BANKINFO_LIST; 00666 struct AB_BANKINFO_LIST { 00667 AB_BANKINFO *first; 00668 uint32_t count; 00669 uint32_t id; 00670 } AB_BANKINFO_LIST; 00671 00676 void AB_BankInfo_List_AddList(AB_BANKINFO_LIST *dst, AB_BANKINFO_LIST *l); 00677 00681 void AB_BankInfo_List_Add(AB_BANKINFO *element, AB_BANKINFO_LIST *list); 00682 00687 void AB_BankInfo_List_Insert(AB_BANKINFO *element, AB_BANKINFO_LIST *list); 00688 00695 void AB_BankInfo_List_Del(AB_BANKINFO *element); 00696 00700 AB_BANKINFO* AB_BankInfo_List_First(const AB_BANKINFO_LIST *l); 00701 00705 AB_BANKINFO* AB_BankInfo_List_Last(const AB_BANKINFO_LIST *l); 00706 00711 void AB_BankInfo_List_Clear(AB_BANKINFO_LIST *l); 00712 00716 AB_BANKINFO_LIST* AB_BankInfo_List_new(); 00717 00721 void AB_BankInfo_List_free(AB_BANKINFO_LIST *l); 00722 00726 AB_BANKINFO* AB_BankInfo_List_Next(const AB_BANKINFO *element); 00727 00731 AB_BANKINFO* AB_BankInfo_List_Previous(const AB_BANKINFO *element); 00732 00736 uint32_t AB_BankInfo_List_GetCount(const AB_BANKINFO_LIST *l); 00737 00738 #ifdef __cplusplus 00739 } 00740 #endif 00741 00742 00743 #endif 00744 00745 00746 00747 /*************************************************************************** 00748 $RCSfile$ 00749 ------------------- 00750 cvs : $Id$ 00751 begin : Sat Jun 28 2003 00752 copyright : (C) 2003 by Martin Preuss 00753 email : martin@libchipcard.de 00754 00755 *************************************************************************** 00756 * * 00757 * This library is free software; you can redistribute it and/or * 00758 * modify it under the terms of the GNU Lesser General Public * 00759 * License as published by the Free Software Foundation; either * 00760 * version 2.1 of the License, or (at your option) any later version. * 00761 * * 00762 * This library is distributed in the hope that it will be useful, * 00763 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 00764 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 00765 * Lesser General Public License for more details. * 00766 * * 00767 * You should have received a copy of the GNU Lesser General Public * 00768 * License along with this library; if not, write to the Free Software * 00769 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 00770 * MA 02111-1307 USA * 00771 * * 00772 ***************************************************************************/ 00773 00774 00775 #ifndef AB_ACCOUNT_LIST2_H 00776 #define AB_ACCOUNT_LIST2_H 00777 00778 00779 #ifdef __cplusplus 00780 extern "C" { 00781 #endif 00782 00789 typedef struct AB_ACCOUNT_LIST2 AB_ACCOUNT_LIST2; 00790 00794 typedef struct AB_ACCOUNT_LIST2_ITERATOR AB_ACCOUNT_LIST2_ITERATOR; 00795 00799 typedef AB_ACCOUNT* (AB_ACCOUNT_LIST2_FOREACH)(AB_ACCOUNT *element, 00800 void *user_data); 00801 00805 AB_ACCOUNT_LIST2 *AB_Account_List2_new(); 00806 00810 void AB_Account_List2_free(AB_ACCOUNT_LIST2 *l); 00811 00815 void AB_Account_List2_Dump(AB_ACCOUNT_LIST2 *l, FILE *f, unsigned int indent); 00816 00820 void AB_Account_List2_PushBack(AB_ACCOUNT_LIST2 *l, AB_ACCOUNT *p); 00821 00826 void AB_Account_List2_PushFront(AB_ACCOUNT_LIST2 *l, AB_ACCOUNT *p); 00827 00832 AB_ACCOUNT *AB_Account_List2_GetFront(AB_ACCOUNT_LIST2 *l); 00833 00838 AB_ACCOUNT *AB_Account_List2_GetBack(AB_ACCOUNT_LIST2 *l); 00839 00844 void AB_Account_List2_Erase(AB_ACCOUNT_LIST2 *l, 00845 AB_ACCOUNT_LIST2_ITERATOR *it); 00846 00852 unsigned int AB_Account_List2_GetSize(AB_ACCOUNT_LIST2 *l); 00853 00858 void AB_Account_List2_PopBack(AB_ACCOUNT_LIST2 *l); 00859 00864 void AB_Account_List2_PopFront(AB_ACCOUNT_LIST2 *l); 00865 00869 void AB_Account_List2_Clear(AB_ACCOUNT_LIST2 *l); 00870 00874 AB_ACCOUNT_LIST2_ITERATOR *AB_Account_List2_First(AB_ACCOUNT_LIST2 *l); 00875 00879 AB_ACCOUNT_LIST2_ITERATOR *AB_Account_List2_Last(AB_ACCOUNT_LIST2 *l); 00880 00884 AB_ACCOUNT_LIST2_ITERATOR *AB_Account_List2Iterator_new(AB_ACCOUNT_LIST2 *l); 00885 00889 void AB_Account_List2Iterator_free(AB_ACCOUNT_LIST2_ITERATOR *li); 00890 00895 AB_ACCOUNT *AB_Account_List2Iterator_Previous(AB_ACCOUNT_LIST2_ITERATOR *li); 00896 00901 AB_ACCOUNT *AB_Account_List2Iterator_Next(AB_ACCOUNT_LIST2_ITERATOR *li); 00902 00907 AB_ACCOUNT *AB_Account_List2Iterator_Data(AB_ACCOUNT_LIST2_ITERATOR *li); 00908 00920 AB_ACCOUNT *AB_Account_List2_ForEach(AB_ACCOUNT_LIST2 *list, 00921 AB_ACCOUNT_LIST2_FOREACH func, 00922 void *user_data); 00923 00924 00925 typedef struct AB_ACCOUNT_CONSTLIST2 AB_ACCOUNT_CONSTLIST2; 00926 typedef struct AB_ACCOUNT_CONSTLIST2_ITERATOR AB_ACCOUNT_CONSTLIST2_ITERATOR; 00927 typedef const AB_ACCOUNT* 00928 (AB_ACCOUNT_CONSTLIST2_FOREACH)(const AB_ACCOUNT *element, 00929 void *user_data); 00930 00931 00932 AB_ACCOUNT_CONSTLIST2 *AB_Account_ConstList2_new(); 00933 00934 void AB_Account_ConstList2_free(AB_ACCOUNT_CONSTLIST2 *l); 00935 00936 void AB_Account_ConstList2_PushBack(AB_ACCOUNT_CONSTLIST2 *l, const AB_ACCOUNT *p); 00937 00938 void AB_Account_ConstList2_PushFront(AB_ACCOUNT_CONSTLIST2 *l, const AB_ACCOUNT *p); 00939 00940 const AB_ACCOUNT *AB_Account_ConstList2_GetFront(AB_ACCOUNT_CONSTLIST2 *l); 00941 00942 const AB_ACCOUNT *AB_Account_ConstList2_GetBack(AB_ACCOUNT_CONSTLIST2 *l); 00943 00944 unsigned int AB_Account_ConstList2_GetSize(AB_ACCOUNT_CONSTLIST2 *l); 00945 00946 void AB_Account_ConstList2_PopBack(AB_ACCOUNT_CONSTLIST2 *l); 00947 00948 void AB_Account_ConstList2_PopFront(AB_ACCOUNT_CONSTLIST2 *l); 00949 00950 void AB_Account_ConstList2_Clear(AB_ACCOUNT_CONSTLIST2 *l); 00951 00952 AB_ACCOUNT_CONSTLIST2_ITERATOR *AB_Account_ConstList2_First(AB_ACCOUNT_CONSTLIST2 *l); 00953 00954 AB_ACCOUNT_CONSTLIST2_ITERATOR *AB_Account_ConstList2_Last(AB_ACCOUNT_CONSTLIST2 *l); 00955 00956 AB_ACCOUNT_CONSTLIST2_ITERATOR *AB_Account_ConstList2Iterator_new(AB_ACCOUNT_CONSTLIST2 *l); 00957 00958 void AB_Account_ConstList2Iterator_free(AB_ACCOUNT_CONSTLIST2_ITERATOR *li); 00959 00960 const AB_ACCOUNT *AB_Account_ConstList2Iterator_Previous(AB_ACCOUNT_CONSTLIST2_ITERATOR *li); 00961 00962 const AB_ACCOUNT *AB_Account_ConstList2Iterator_Next(AB_ACCOUNT_CONSTLIST2_ITERATOR *li); 00963 00964 const AB_ACCOUNT *AB_Account_ConstList2Iterator_Data(AB_ACCOUNT_CONSTLIST2_ITERATOR *li); 00965 00977 const AB_ACCOUNT *AB_Account_ConstList2_ForEach(AB_ACCOUNT_CONSTLIST2 *list, 00978 AB_ACCOUNT_CONSTLIST2_FOREACH func, void *user_data); 00979 00980 00981 #ifdef __cplusplus 00982 } 00983 #endif 00984 00985 00986 #endif /* AB_ACCOUNT_LIST_H */ 00987 00988 00989 00990 /*************************************************************************** 00991 $RCSfile$ 00992 ------------------- 00993 cvs : $Id$ 00994 begin : Sat Jun 28 2003 00995 copyright : (C) 2003 by Martin Preuss 00996 email : martin@libchipcard.de 00997 00998 *************************************************************************** 00999 * * 01000 * This library is free software; you can redistribute it and/or * 01001 * modify it under the terms of the GNU Lesser General Public * 01002 * License as published by the Free Software Foundation; either * 01003 * version 2.1 of the License, or (at your option) any later version. * 01004 * * 01005 * This library is distributed in the hope that it will be useful, * 01006 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 01007 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 01008 * Lesser General Public License for more details. * 01009 * * 01010 * You should have received a copy of the GNU Lesser General Public * 01011 * License along with this library; if not, write to the Free Software * 01012 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 01013 * MA 02111-1307 USA * 01014 * * 01015 ***************************************************************************/ 01016 01017 01018 #ifndef AB_TEXTKEY_DESCR_LIST2_H 01019 #define AB_TEXTKEY_DESCR_LIST2_H 01020 01021 01022 #ifdef __cplusplus 01023 extern "C" { 01024 #endif 01025 01032 typedef struct AB_TEXTKEY_DESCR_LIST2 AB_TEXTKEY_DESCR_LIST2; 01033 01037 typedef struct AB_TEXTKEY_DESCR_LIST2_ITERATOR AB_TEXTKEY_DESCR_LIST2_ITERATOR; 01038 01042 typedef AB_TEXTKEY_DESCR* (AB_TEXTKEY_DESCR_LIST2_FOREACH)(AB_TEXTKEY_DESCR *element, 01043 void *user_data); 01044 01048 AB_TEXTKEY_DESCR_LIST2 *AB_TextKeyDescr_List2_new(); 01049 01053 void AB_TextKeyDescr_List2_free(AB_TEXTKEY_DESCR_LIST2 *l); 01054 01058 void AB_TextKeyDescr_List2_Dump(AB_TEXTKEY_DESCR_LIST2 *l, FILE *f, unsigned int indent); 01059 01063 void AB_TextKeyDescr_List2_PushBack(AB_TEXTKEY_DESCR_LIST2 *l, AB_TEXTKEY_DESCR *p); 01064 01069 void AB_TextKeyDescr_List2_PushFront(AB_TEXTKEY_DESCR_LIST2 *l, AB_TEXTKEY_DESCR *p); 01070 01075 AB_TEXTKEY_DESCR *AB_TextKeyDescr_List2_GetFront(AB_TEXTKEY_DESCR_LIST2 *l); 01076 01081 AB_TEXTKEY_DESCR *AB_TextKeyDescr_List2_GetBack(AB_TEXTKEY_DESCR_LIST2 *l); 01082 01087 void AB_TextKeyDescr_List2_Erase(AB_TEXTKEY_DESCR_LIST2 *l, 01088 AB_TEXTKEY_DESCR_LIST2_ITERATOR *it); 01089 01095 unsigned int AB_TextKeyDescr_List2_GetSize(AB_TEXTKEY_DESCR_LIST2 *l); 01096 01101 void AB_TextKeyDescr_List2_PopBack(AB_TEXTKEY_DESCR_LIST2 *l); 01102 01107 void AB_TextKeyDescr_List2_PopFront(AB_TEXTKEY_DESCR_LIST2 *l); 01108 01112 void AB_TextKeyDescr_List2_Clear(AB_TEXTKEY_DESCR_LIST2 *l); 01113 01117 AB_TEXTKEY_DESCR_LIST2_ITERATOR *AB_TextKeyDescr_List2_First(AB_TEXTKEY_DESCR_LIST2 *l); 01118 01122 AB_TEXTKEY_DESCR_LIST2_ITERATOR *AB_TextKeyDescr_List2_Last(AB_TEXTKEY_DESCR_LIST2 *l); 01123 01127 AB_TEXTKEY_DESCR_LIST2_ITERATOR *AB_TextKeyDescr_List2Iterator_new(AB_TEXTKEY_DESCR_LIST2 *l); 01128 01132 void AB_TextKeyDescr_List2Iterator_free(AB_TEXTKEY_DESCR_LIST2_ITERATOR *li); 01133 01138 AB_TEXTKEY_DESCR *AB_TextKeyDescr_List2Iterator_Previous(AB_TEXTKEY_DESCR_LIST2_ITERATOR *li); 01139 01144 AB_TEXTKEY_DESCR *AB_TextKeyDescr_List2Iterator_Next(AB_TEXTKEY_DESCR_LIST2_ITERATOR *li); 01145 01150 AB_TEXTKEY_DESCR *AB_TextKeyDescr_List2Iterator_Data(AB_TEXTKEY_DESCR_LIST2_ITERATOR *li); 01151 01163 AB_TEXTKEY_DESCR *AB_TextKeyDescr_List2_ForEach(AB_TEXTKEY_DESCR_LIST2 *list, 01164 AB_TEXTKEY_DESCR_LIST2_FOREACH func, 01165 void *user_data); 01166 01167 01168 typedef struct AB_TEXTKEY_DESCR_CONSTLIST2 AB_TEXTKEY_DESCR_CONSTLIST2; 01169 typedef struct AB_TEXTKEY_DESCR_CONSTLIST2_ITERATOR AB_TEXTKEY_DESCR_CONSTLIST2_ITERATOR; 01170 typedef const AB_TEXTKEY_DESCR* 01171 (AB_TEXTKEY_DESCR_CONSTLIST2_FOREACH)(const AB_TEXTKEY_DESCR *element, 01172 void *user_data); 01173 01174 01175 AB_TEXTKEY_DESCR_CONSTLIST2 *AB_TextKeyDescr_ConstList2_new(); 01176 01177 void AB_TextKeyDescr_ConstList2_free(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 01178 01179 void AB_TextKeyDescr_ConstList2_PushBack(AB_TEXTKEY_DESCR_CONSTLIST2 *l, const AB_TEXTKEY_DESCR *p); 01180 01181 void AB_TextKeyDescr_ConstList2_PushFront(AB_TEXTKEY_DESCR_CONSTLIST2 *l, const AB_TEXTKEY_DESCR *p); 01182 01183 const AB_TEXTKEY_DESCR *AB_TextKeyDescr_ConstList2_GetFront(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 01184 01185 const AB_TEXTKEY_DESCR *AB_TextKeyDescr_ConstList2_GetBack(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 01186 01187 unsigned int AB_TextKeyDescr_ConstList2_GetSize(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 01188 01189 void AB_TextKeyDescr_ConstList2_PopBack(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 01190 01191 void AB_TextKeyDescr_ConstList2_PopFront(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 01192 01193 void AB_TextKeyDescr_ConstList2_Clear(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 01194 01195 AB_TEXTKEY_DESCR_CONSTLIST2_ITERATOR *AB_TextKeyDescr_ConstList2_First(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 01196 01197 AB_TEXTKEY_DESCR_CONSTLIST2_ITERATOR *AB_TextKeyDescr_ConstList2_Last(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 01198 01199 AB_TEXTKEY_DESCR_CONSTLIST2_ITERATOR *AB_TextKeyDescr_ConstList2Iterator_new(AB_TEXTKEY_DESCR_CONSTLIST2 *l); 01200 01201 void AB_TextKeyDescr_ConstList2Iterator_free(AB_TEXTKEY_DESCR_CONSTLIST2_ITERATOR *li); 01202 01203 const AB_TEXTKEY_DESCR *AB_TextKeyDescr_ConstList2Iterator_Previous(AB_TEXTKEY_DESCR_CONSTLIST2_ITERATOR *li); 01204 01205 const AB_TEXTKEY_DESCR *AB_TextKeyDescr_ConstList2Iterator_Next(AB_TEXTKEY_DESCR_CONSTLIST2_ITERATOR *li); 01206 01207 const AB_TEXTKEY_DESCR *AB_TextKeyDescr_ConstList2Iterator_Data(AB_TEXTKEY_DESCR_CONSTLIST2_ITERATOR *li); 01208 01220 const AB_TEXTKEY_DESCR *AB_TextKeyDescr_ConstList2_ForEach(AB_TEXTKEY_DESCR_CONSTLIST2 *list, 01221 AB_TEXTKEY_DESCR_CONSTLIST2_FOREACH func, void *user_data); 01222 01223 01224 #ifdef __cplusplus 01225 } 01226 #endif 01227 01228 01229 #endif /* AB_TEXTKEY_DESCR_LIST_H */ 01230 01231 01232 01233 /*************************************************************************** 01234 $RCSfile$ 01235 ------------------- 01236 cvs : $Id$ 01237 begin : Sat Jun 28 2003 01238 copyright : (C) 2003 by Martin Preuss 01239 email : martin@libchipcard.de 01240 01241 *************************************************************************** 01242 * * 01243 * This library is free software; you can redistribute it and/or * 01244 * modify it under the terms of the GNU Lesser General Public * 01245 * License as published by the Free Software Foundation; either * 01246 * version 2.1 of the License, or (at your option) any later version. * 01247 * * 01248 * This library is distributed in the hope that it will be useful, * 01249 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 01250 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 01251 * Lesser General Public License for more details. * 01252 * * 01253 * You should have received a copy of the GNU Lesser General Public * 01254 * License along with this library; if not, write to the Free Software * 01255 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 01256 * MA 02111-1307 USA * 01257 * * 01258 ***************************************************************************/ 01259 01260 01261 #ifndef AB_TEXTKEY_DESCR_LIST1_H 01262 #define AB_TEXTKEY_DESCR_LIST1_H 01263 01264 #ifdef __cplusplus 01265 extern "C" { 01266 #endif 01267 01269 typedef struct AB_TEXTKEY_DESCR_LIST_ELEMENT { 01270 uint32_t id; 01271 AB_TEXTKEY_DESCR *nextObject; 01272 } AB_TEXTKEY_DESCR_LIST__ELEMENT; 01273 01280 typedef struct AB_TEXTKEY_DESCR_LIST AB_TEXTKEY_DESCR_LIST; 01282 struct AB_TEXTKEY_DESCR_LIST { 01283 AB_TEXTKEY_DESCR *first; 01284 uint32_t count; 01285 uint32_t id; 01286 } AB_TEXTKEY_DESCR_LIST; 01287 01292 void AB_TextKeyDescr_List_AddList(AB_TEXTKEY_DESCR_LIST *dst, AB_TEXTKEY_DESCR_LIST *l); 01293 01297 void AB_TextKeyDescr_List_Add(AB_TEXTKEY_DESCR *element, AB_TEXTKEY_DESCR_LIST *list); 01298 01303 void AB_TextKeyDescr_List_Insert(AB_TEXTKEY_DESCR *element, AB_TEXTKEY_DESCR_LIST *list); 01304 01311 void AB_TextKeyDescr_List_Del(AB_TEXTKEY_DESCR *element); 01312 01316 AB_TEXTKEY_DESCR* AB_TextKeyDescr_List_First(const AB_TEXTKEY_DESCR_LIST *l); 01317 01321 AB_TEXTKEY_DESCR* AB_TextKeyDescr_List_Last(const AB_TEXTKEY_DESCR_LIST *l); 01322 01327 void AB_TextKeyDescr_List_Clear(AB_TEXTKEY_DESCR_LIST *l); 01328 01332 AB_TEXTKEY_DESCR_LIST* AB_TextKeyDescr_List_new(); 01333 01337 void AB_TextKeyDescr_List_free(AB_TEXTKEY_DESCR_LIST *l); 01338 01342 AB_TEXTKEY_DESCR* AB_TextKeyDescr_List_Next(const AB_TEXTKEY_DESCR *element); 01343 01347 AB_TEXTKEY_DESCR* AB_TextKeyDescr_List_Previous(const AB_TEXTKEY_DESCR *element); 01348 01352 uint32_t AB_TextKeyDescr_List_GetCount(const AB_TEXTKEY_DESCR_LIST *l); 01353 01354 #ifdef __cplusplus 01355 } 01356 #endif 01357 01358 01359 #endif 01360 01361 01362 01363 /*************************************************************************** 01364 $RCSfile$ 01365 ------------------- 01366 cvs : $Id$ 01367 begin : Sat Jun 28 2003 01368 copyright : (C) 2003 by Martin Preuss 01369 email : martin@libchipcard.de 01370 01371 *************************************************************************** 01372 * * 01373 * This library is free software; you can redistribute it and/or * 01374 * modify it under the terms of the GNU Lesser General Public * 01375 * License as published by the Free Software Foundation; either * 01376 * version 2.1 of the License, or (at your option) any later version. * 01377 * * 01378 * This library is distributed in the hope that it will be useful, * 01379 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 01380 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 01381 * Lesser General Public License for more details. * 01382 * * 01383 * You should have received a copy of the GNU Lesser General Public * 01384 * License along with this library; if not, write to the Free Software * 01385 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 01386 * MA 02111-1307 USA * 01387 * * 01388 ***************************************************************************/ 01389 01390 01391 #ifndef AB_TRANSACTION_LIMITS_LIST2_H 01392 #define AB_TRANSACTION_LIMITS_LIST2_H 01393 01394 01395 #ifdef __cplusplus 01396 extern "C" { 01397 #endif 01398 01405 typedef struct AB_TRANSACTION_LIMITS_LIST2 AB_TRANSACTION_LIMITS_LIST2; 01406 01410 typedef struct AB_TRANSACTION_LIMITS_LIST2_ITERATOR AB_TRANSACTION_LIMITS_LIST2_ITERATOR; 01411 01415 typedef AB_TRANSACTION_LIMITS* (AB_TRANSACTION_LIMITS_LIST2_FOREACH)(AB_TRANSACTION_LIMITS *element, 01416 void *user_data); 01417 01421 AB_TRANSACTION_LIMITS_LIST2 *AB_TransactionLimits_List2_new(); 01422 01426 void AB_TransactionLimits_List2_free(AB_TRANSACTION_LIMITS_LIST2 *l); 01427 01431 void AB_TransactionLimits_List2_Dump(AB_TRANSACTION_LIMITS_LIST2 *l, FILE *f, unsigned int indent); 01432 01436 void AB_TransactionLimits_List2_PushBack(AB_TRANSACTION_LIMITS_LIST2 *l, AB_TRANSACTION_LIMITS *p); 01437 01442 void AB_TransactionLimits_List2_PushFront(AB_TRANSACTION_LIMITS_LIST2 *l, AB_TRANSACTION_LIMITS *p); 01443 01448 AB_TRANSACTION_LIMITS *AB_TransactionLimits_List2_GetFront(AB_TRANSACTION_LIMITS_LIST2 *l); 01449 01454 AB_TRANSACTION_LIMITS *AB_TransactionLimits_List2_GetBack(AB_TRANSACTION_LIMITS_LIST2 *l); 01455 01460 void AB_TransactionLimits_List2_Erase(AB_TRANSACTION_LIMITS_LIST2 *l, 01461 AB_TRANSACTION_LIMITS_LIST2_ITERATOR *it); 01462 01468 unsigned int AB_TransactionLimits_List2_GetSize(AB_TRANSACTION_LIMITS_LIST2 *l); 01469 01474 void AB_TransactionLimits_List2_PopBack(AB_TRANSACTION_LIMITS_LIST2 *l); 01475 01480 void AB_TransactionLimits_List2_PopFront(AB_TRANSACTION_LIMITS_LIST2 *l); 01481 01485 void AB_TransactionLimits_List2_Clear(AB_TRANSACTION_LIMITS_LIST2 *l); 01486 01490 AB_TRANSACTION_LIMITS_LIST2_ITERATOR *AB_TransactionLimits_List2_First(AB_TRANSACTION_LIMITS_LIST2 *l); 01491 01495 AB_TRANSACTION_LIMITS_LIST2_ITERATOR *AB_TransactionLimits_List2_Last(AB_TRANSACTION_LIMITS_LIST2 *l); 01496 01500 AB_TRANSACTION_LIMITS_LIST2_ITERATOR *AB_TransactionLimits_List2Iterator_new(AB_TRANSACTION_LIMITS_LIST2 *l); 01501 01505 void AB_TransactionLimits_List2Iterator_free(AB_TRANSACTION_LIMITS_LIST2_ITERATOR *li); 01506 01511 AB_TRANSACTION_LIMITS *AB_TransactionLimits_List2Iterator_Previous(AB_TRANSACTION_LIMITS_LIST2_ITERATOR *li); 01512 01517 AB_TRANSACTION_LIMITS *AB_TransactionLimits_List2Iterator_Next(AB_TRANSACTION_LIMITS_LIST2_ITERATOR *li); 01518 01523 AB_TRANSACTION_LIMITS *AB_TransactionLimits_List2Iterator_Data(AB_TRANSACTION_LIMITS_LIST2_ITERATOR *li); 01524 01536 AB_TRANSACTION_LIMITS *AB_TransactionLimits_List2_ForEach(AB_TRANSACTION_LIMITS_LIST2 *list, 01537 AB_TRANSACTION_LIMITS_LIST2_FOREACH func, 01538 void *user_data); 01539 01540 01541 typedef struct AB_TRANSACTION_LIMITS_CONSTLIST2 AB_TRANSACTION_LIMITS_CONSTLIST2; 01542 typedef struct AB_TRANSACTION_LIMITS_CONSTLIST2_ITERATOR AB_TRANSACTION_LIMITS_CONSTLIST2_ITERATOR; 01543 typedef const AB_TRANSACTION_LIMITS* 01544 (AB_TRANSACTION_LIMITS_CONSTLIST2_FOREACH)(const AB_TRANSACTION_LIMITS *element, 01545 void *user_data); 01546 01547 01548 AB_TRANSACTION_LIMITS_CONSTLIST2 *AB_TransactionLimits_ConstList2_new(); 01549 01550 void AB_TransactionLimits_ConstList2_free(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 01551 01552 void AB_TransactionLimits_ConstList2_PushBack(AB_TRANSACTION_LIMITS_CONSTLIST2 *l, const AB_TRANSACTION_LIMITS *p); 01553 01554 void AB_TransactionLimits_ConstList2_PushFront(AB_TRANSACTION_LIMITS_CONSTLIST2 *l, const AB_TRANSACTION_LIMITS *p); 01555 01556 const AB_TRANSACTION_LIMITS *AB_TransactionLimits_ConstList2_GetFront(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 01557 01558 const AB_TRANSACTION_LIMITS *AB_TransactionLimits_ConstList2_GetBack(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 01559 01560 unsigned int AB_TransactionLimits_ConstList2_GetSize(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 01561 01562 void AB_TransactionLimits_ConstList2_PopBack(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 01563 01564 void AB_TransactionLimits_ConstList2_PopFront(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 01565 01566 void AB_TransactionLimits_ConstList2_Clear(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 01567 01568 AB_TRANSACTION_LIMITS_CONSTLIST2_ITERATOR *AB_TransactionLimits_ConstList2_First(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 01569 01570 AB_TRANSACTION_LIMITS_CONSTLIST2_ITERATOR *AB_TransactionLimits_ConstList2_Last(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 01571 01572 AB_TRANSACTION_LIMITS_CONSTLIST2_ITERATOR *AB_TransactionLimits_ConstList2Iterator_new(AB_TRANSACTION_LIMITS_CONSTLIST2 *l); 01573 01574 void AB_TransactionLimits_ConstList2Iterator_free(AB_TRANSACTION_LIMITS_CONSTLIST2_ITERATOR *li); 01575 01576 const AB_TRANSACTION_LIMITS *AB_TransactionLimits_ConstList2Iterator_Previous(AB_TRANSACTION_LIMITS_CONSTLIST2_ITERATOR *li); 01577 01578 const AB_TRANSACTION_LIMITS *AB_TransactionLimits_ConstList2Iterator_Next(AB_TRANSACTION_LIMITS_CONSTLIST2_ITERATOR *li); 01579 01580 const AB_TRANSACTION_LIMITS *AB_TransactionLimits_ConstList2Iterator_Data(AB_TRANSACTION_LIMITS_CONSTLIST2_ITERATOR *li); 01581 01593 const AB_TRANSACTION_LIMITS *AB_TransactionLimits_ConstList2_ForEach(AB_TRANSACTION_LIMITS_CONSTLIST2 *list, 01594 AB_TRANSACTION_LIMITS_CONSTLIST2_FOREACH func, void *user_data); 01595 01596 01597 #ifdef __cplusplus 01598 } 01599 #endif 01600 01601 01602 #endif /* AB_TRANSACTION_LIMITS_LIST_H */ 01603 01604 01605 01606 /*************************************************************************** 01607 $RCSfile$ 01608 ------------------- 01609 cvs : $Id$ 01610 begin : Sat Jun 28 2003 01611 copyright : (C) 2003 by Martin Preuss 01612 email : martin@libchipcard.de 01613 01614 *************************************************************************** 01615 * * 01616 * This library is free software; you can redistribute it and/or * 01617 * modify it under the terms of the GNU Lesser General Public * 01618 * License as published by the Free Software Foundation; either * 01619 * version 2.1 of the License, or (at your option) any later version. * 01620 * * 01621 * This library is distributed in the hope that it will be useful, * 01622 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 01623 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 01624 * Lesser General Public License for more details. * 01625 * * 01626 * You should have received a copy of the GNU Lesser General Public * 01627 * License along with this library; if not, write to the Free Software * 01628 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 01629 * MA 02111-1307 USA * 01630 * * 01631 ***************************************************************************/ 01632 01633 01634 #ifndef AB_TRANSACTION_LIMITS_LIST1_H 01635 #define AB_TRANSACTION_LIMITS_LIST1_H 01636 01637 #ifdef __cplusplus 01638 extern "C" { 01639 #endif 01640 01642 typedef struct AB_TRANSACTION_LIMITS_LIST_ELEMENT { 01643 uint32_t id; 01644 AB_TRANSACTION_LIMITS *nextObject; 01645 } AB_TRANSACTION_LIMITS_LIST__ELEMENT; 01646 01653 typedef struct AB_TRANSACTION_LIMITS_LIST AB_TRANSACTION_LIMITS_LIST; 01655 struct AB_TRANSACTION_LIMITS_LIST { 01656 AB_TRANSACTION_LIMITS *first; 01657 uint32_t count; 01658 uint32_t id; 01659 } AB_TRANSACTION_LIMITS_LIST; 01660 01665 void AB_TransactionLimits_List_AddList(AB_TRANSACTION_LIMITS_LIST *dst, AB_TRANSACTION_LIMITS_LIST *l); 01666 01670 void AB_TransactionLimits_List_Add(AB_TRANSACTION_LIMITS *element, AB_TRANSACTION_LIMITS_LIST *list); 01671 01676 void AB_TransactionLimits_List_Insert(AB_TRANSACTION_LIMITS *element, AB_TRANSACTION_LIMITS_LIST *list); 01677 01684 void AB_TransactionLimits_List_Del(AB_TRANSACTION_LIMITS *element); 01685 01689 AB_TRANSACTION_LIMITS* AB_TransactionLimits_List_First(const AB_TRANSACTION_LIMITS_LIST *l); 01690 01694 AB_TRANSACTION_LIMITS* AB_TransactionLimits_List_Last(const AB_TRANSACTION_LIMITS_LIST *l); 01695 01700 void AB_TransactionLimits_List_Clear(AB_TRANSACTION_LIMITS_LIST *l); 01701 01705 AB_TRANSACTION_LIMITS_LIST* AB_TransactionLimits_List_new(); 01706 01710 void AB_TransactionLimits_List_free(AB_TRANSACTION_LIMITS_LIST *l); 01711 01715 AB_TRANSACTION_LIMITS* AB_TransactionLimits_List_Next(const AB_TRANSACTION_LIMITS *element); 01716 01720 AB_TRANSACTION_LIMITS* AB_TransactionLimits_List_Previous(const AB_TRANSACTION_LIMITS *element); 01721 01725 uint32_t AB_TransactionLimits_List_GetCount(const AB_TRANSACTION_LIMITS_LIST *l); 01726 01727 #ifdef __cplusplus 01728 } 01729 #endif 01730 01731 01732 #endif 01733 01734 01735 01736 /*************************************************************************** 01737 $RCSfile$ 01738 ------------------- 01739 cvs : $Id$ 01740 begin : Sat Jun 28 2003 01741 copyright : (C) 2003 by Martin Preuss 01742 email : martin@libchipcard.de 01743 01744 *************************************************************************** 01745 * * 01746 * This library is free software; you can redistribute it and/or * 01747 * modify it under the terms of the GNU Lesser General Public * 01748 * License as published by the Free Software Foundation; either * 01749 * version 2.1 of the License, or (at your option) any later version. * 01750 * * 01751 * This library is distributed in the hope that it will be useful, * 01752 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 01753 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 01754 * Lesser General Public License for more details. * 01755 * * 01756 * You should have received a copy of the GNU Lesser General Public * 01757 * License along with this library; if not, write to the Free Software * 01758 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 01759 * MA 02111-1307 USA * 01760 * * 01761 ***************************************************************************/ 01762 01763 01764 #ifndef AB_ACCOUNTQUEUE_LIST1_H 01765 #define AB_ACCOUNTQUEUE_LIST1_H 01766 01767 #ifdef __cplusplus 01768 extern "C" { 01769 #endif 01770 01772 typedef struct AB_ACCOUNTQUEUE_LIST_ELEMENT { 01773 uint32_t id; 01774 AB_ACCOUNTQUEUE *nextObject; 01775 } AB_ACCOUNTQUEUE_LIST__ELEMENT; 01776 01783 typedef struct AB_ACCOUNTQUEUE_LIST AB_ACCOUNTQUEUE_LIST; 01785 struct AB_ACCOUNTQUEUE_LIST { 01786 AB_ACCOUNTQUEUE *first; 01787 uint32_t count; 01788 uint32_t id; 01789 } AB_ACCOUNTQUEUE_LIST; 01790 01795 void AB_AccountQueue_List_AddList(AB_ACCOUNTQUEUE_LIST *dst, AB_ACCOUNTQUEUE_LIST *l); 01796 01800 void AB_AccountQueue_List_Add(AB_ACCOUNTQUEUE *element, AB_ACCOUNTQUEUE_LIST *list); 01801 01806 void AB_AccountQueue_List_Insert(AB_ACCOUNTQUEUE *element, AB_ACCOUNTQUEUE_LIST *list); 01807 01814 void AB_AccountQueue_List_Del(AB_ACCOUNTQUEUE *element); 01815 01819 AB_ACCOUNTQUEUE* AB_AccountQueue_List_First(const AB_ACCOUNTQUEUE_LIST *l); 01820 01824 AB_ACCOUNTQUEUE* AB_AccountQueue_List_Last(const AB_ACCOUNTQUEUE_LIST *l); 01825 01830 void AB_AccountQueue_List_Clear(AB_ACCOUNTQUEUE_LIST *l); 01831 01835 AB_ACCOUNTQUEUE_LIST* AB_AccountQueue_List_new(); 01836 01840 void AB_AccountQueue_List_free(AB_ACCOUNTQUEUE_LIST *l); 01841 01845 AB_ACCOUNTQUEUE* AB_AccountQueue_List_Next(const AB_ACCOUNTQUEUE *element); 01846 01850 AB_ACCOUNTQUEUE* AB_AccountQueue_List_Previous(const AB_ACCOUNTQUEUE *element); 01851 01855 uint32_t AB_AccountQueue_List_GetCount(const AB_ACCOUNTQUEUE_LIST *l); 01856 01857 #ifdef __cplusplus 01858 } 01859 #endif 01860 01861 01862 #endif 01863 01864 01865 01866 /*************************************************************************** 01867 $RCSfile$ 01868 ------------------- 01869 cvs : $Id$ 01870 begin : Sat Jun 28 2003 01871 copyright : (C) 2003 by Martin Preuss 01872 email : martin@libchipcard.de 01873 01874 *************************************************************************** 01875 * * 01876 * This library is free software; you can redistribute it and/or * 01877 * modify it under the terms of the GNU Lesser General Public * 01878 * License as published by the Free Software Foundation; either * 01879 * version 2.1 of the License, or (at your option) any later version. * 01880 * * 01881 * This library is distributed in the hope that it will be useful, * 01882 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 01883 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 01884 * Lesser General Public License for more details. * 01885 * * 01886 * You should have received a copy of the GNU Lesser General Public * 01887 * License along with this library; if not, write to the Free Software * 01888 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 01889 * MA 02111-1307 USA * 01890 * * 01891 ***************************************************************************/ 01892 01893 01894 #ifndef AB_ACCOUNT_LIST1_H 01895 #define AB_ACCOUNT_LIST1_H 01896 01897 #ifdef __cplusplus 01898 extern "C" { 01899 #endif 01900 01902 typedef struct AB_ACCOUNT_LIST_ELEMENT { 01903 uint32_t id; 01904 AB_ACCOUNT *nextObject; 01905 } AB_ACCOUNT_LIST__ELEMENT; 01906 01913 typedef struct AB_ACCOUNT_LIST AB_ACCOUNT_LIST; 01915 struct AB_ACCOUNT_LIST { 01916 AB_ACCOUNT *first; 01917 uint32_t count; 01918 uint32_t id; 01919 } AB_ACCOUNT_LIST; 01920 01925 void AB_Account_List_AddList(AB_ACCOUNT_LIST *dst, AB_ACCOUNT_LIST *l); 01926 01930 void AB_Account_List_Add(AB_ACCOUNT *element, AB_ACCOUNT_LIST *list); 01931 01936 void AB_Account_List_Insert(AB_ACCOUNT *element, AB_ACCOUNT_LIST *list); 01937 01944 void AB_Account_List_Del(AB_ACCOUNT *element); 01945 01949 AB_ACCOUNT* AB_Account_List_First(const AB_ACCOUNT_LIST *l); 01950 01954 AB_ACCOUNT* AB_Account_List_Last(const AB_ACCOUNT_LIST *l); 01955 01960 void AB_Account_List_Clear(AB_ACCOUNT_LIST *l); 01961 01965 AB_ACCOUNT_LIST* AB_Account_List_new(); 01966 01970 void AB_Account_List_free(AB_ACCOUNT_LIST *l); 01971 01975 AB_ACCOUNT* AB_Account_List_Next(const AB_ACCOUNT *element); 01976 01980 AB_ACCOUNT* AB_Account_List_Previous(const AB_ACCOUNT *element); 01981 01985 uint32_t AB_Account_List_GetCount(const AB_ACCOUNT_LIST *l); 01986 01987 #ifdef __cplusplus 01988 } 01989 #endif 01990 01991 01992 #endif 01993 01994 01995 01996 /*************************************************************************** 01997 $RCSfile$ 01998 ------------------- 01999 cvs : $Id$ 02000 begin : Sat Jun 28 2003 02001 copyright : (C) 2003 by Martin Preuss 02002 email : martin@libchipcard.de 02003 02004 *************************************************************************** 02005 * * 02006 * This library is free software; you can redistribute it and/or * 02007 * modify it under the terms of the GNU Lesser General Public * 02008 * License as published by the Free Software Foundation; either * 02009 * version 2.1 of the License, or (at your option) any later version. * 02010 * * 02011 * This library is distributed in the hope that it will be useful, * 02012 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 02013 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 02014 * Lesser General Public License for more details. * 02015 * * 02016 * You should have received a copy of the GNU Lesser General Public * 02017 * License along with this library; if not, write to the Free Software * 02018 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 02019 * MA 02111-1307 USA * 02020 * * 02021 ***************************************************************************/ 02022 02023 02024 #ifndef AB_MESSAGE_LIST2_H 02025 #define AB_MESSAGE_LIST2_H 02026 02027 02028 #ifdef __cplusplus 02029 extern "C" { 02030 #endif 02031 02038 typedef struct AB_MESSAGE_LIST2 AB_MESSAGE_LIST2; 02039 02043 typedef struct AB_MESSAGE_LIST2_ITERATOR AB_MESSAGE_LIST2_ITERATOR; 02044 02048 typedef AB_MESSAGE* (AB_MESSAGE_LIST2_FOREACH)(AB_MESSAGE *element, 02049 void *user_data); 02050 02054 AB_MESSAGE_LIST2 *AB_Message_List2_new(); 02055 02059 void AB_Message_List2_free(AB_MESSAGE_LIST2 *l); 02060 02064 void AB_Message_List2_Dump(AB_MESSAGE_LIST2 *l, FILE *f, unsigned int indent); 02065 02069 void AB_Message_List2_PushBack(AB_MESSAGE_LIST2 *l, AB_MESSAGE *p); 02070 02075 void AB_Message_List2_PushFront(AB_MESSAGE_LIST2 *l, AB_MESSAGE *p); 02076 02081 AB_MESSAGE *AB_Message_List2_GetFront(AB_MESSAGE_LIST2 *l); 02082 02087 AB_MESSAGE *AB_Message_List2_GetBack(AB_MESSAGE_LIST2 *l); 02088 02093 void AB_Message_List2_Erase(AB_MESSAGE_LIST2 *l, 02094 AB_MESSAGE_LIST2_ITERATOR *it); 02095 02101 unsigned int AB_Message_List2_GetSize(AB_MESSAGE_LIST2 *l); 02102 02107 void AB_Message_List2_PopBack(AB_MESSAGE_LIST2 *l); 02108 02113 void AB_Message_List2_PopFront(AB_MESSAGE_LIST2 *l); 02114 02118 void AB_Message_List2_Clear(AB_MESSAGE_LIST2 *l); 02119 02123 AB_MESSAGE_LIST2_ITERATOR *AB_Message_List2_First(AB_MESSAGE_LIST2 *l); 02124 02128 AB_MESSAGE_LIST2_ITERATOR *AB_Message_List2_Last(AB_MESSAGE_LIST2 *l); 02129 02133 AB_MESSAGE_LIST2_ITERATOR *AB_Message_List2Iterator_new(AB_MESSAGE_LIST2 *l); 02134 02138 void AB_Message_List2Iterator_free(AB_MESSAGE_LIST2_ITERATOR *li); 02139 02144 AB_MESSAGE *AB_Message_List2Iterator_Previous(AB_MESSAGE_LIST2_ITERATOR *li); 02145 02150 AB_MESSAGE *AB_Message_List2Iterator_Next(AB_MESSAGE_LIST2_ITERATOR *li); 02151 02156 AB_MESSAGE *AB_Message_List2Iterator_Data(AB_MESSAGE_LIST2_ITERATOR *li); 02157 02169 AB_MESSAGE *AB_Message_List2_ForEach(AB_MESSAGE_LIST2 *list, 02170 AB_MESSAGE_LIST2_FOREACH func, 02171 void *user_data); 02172 02173 02174 typedef struct AB_MESSAGE_CONSTLIST2 AB_MESSAGE_CONSTLIST2; 02175 typedef struct AB_MESSAGE_CONSTLIST2_ITERATOR AB_MESSAGE_CONSTLIST2_ITERATOR; 02176 typedef const AB_MESSAGE* 02177 (AB_MESSAGE_CONSTLIST2_FOREACH)(const AB_MESSAGE *element, 02178 void *user_data); 02179 02180 02181 AB_MESSAGE_CONSTLIST2 *AB_Message_ConstList2_new(); 02182 02183 void AB_Message_ConstList2_free(AB_MESSAGE_CONSTLIST2 *l); 02184 02185 void AB_Message_ConstList2_PushBack(AB_MESSAGE_CONSTLIST2 *l, const AB_MESSAGE *p); 02186 02187 void AB_Message_ConstList2_PushFront(AB_MESSAGE_CONSTLIST2 *l, const AB_MESSAGE *p); 02188 02189 const AB_MESSAGE *AB_Message_ConstList2_GetFront(AB_MESSAGE_CONSTLIST2 *l); 02190 02191 const AB_MESSAGE *AB_Message_ConstList2_GetBack(AB_MESSAGE_CONSTLIST2 *l); 02192 02193 unsigned int AB_Message_ConstList2_GetSize(AB_MESSAGE_CONSTLIST2 *l); 02194 02195 void AB_Message_ConstList2_PopBack(AB_MESSAGE_CONSTLIST2 *l); 02196 02197 void AB_Message_ConstList2_PopFront(AB_MESSAGE_CONSTLIST2 *l); 02198 02199 void AB_Message_ConstList2_Clear(AB_MESSAGE_CONSTLIST2 *l); 02200 02201 AB_MESSAGE_CONSTLIST2_ITERATOR *AB_Message_ConstList2_First(AB_MESSAGE_CONSTLIST2 *l); 02202 02203 AB_MESSAGE_CONSTLIST2_ITERATOR *AB_Message_ConstList2_Last(AB_MESSAGE_CONSTLIST2 *l); 02204 02205 AB_MESSAGE_CONSTLIST2_ITERATOR *AB_Message_ConstList2Iterator_new(AB_MESSAGE_CONSTLIST2 *l); 02206 02207 void AB_Message_ConstList2Iterator_free(AB_MESSAGE_CONSTLIST2_ITERATOR *li); 02208 02209 const AB_MESSAGE *AB_Message_ConstList2Iterator_Previous(AB_MESSAGE_CONSTLIST2_ITERATOR *li); 02210 02211 const AB_MESSAGE *AB_Message_ConstList2Iterator_Next(AB_MESSAGE_CONSTLIST2_ITERATOR *li); 02212 02213 const AB_MESSAGE *AB_Message_ConstList2Iterator_Data(AB_MESSAGE_CONSTLIST2_ITERATOR *li); 02214 02226 const AB_MESSAGE *AB_Message_ConstList2_ForEach(AB_MESSAGE_CONSTLIST2 *list, 02227 AB_MESSAGE_CONSTLIST2_FOREACH func, void *user_data); 02228 02229 02230 #ifdef __cplusplus 02231 } 02232 #endif 02233 02234 02235 #endif /* AB_MESSAGE_LIST_H */ 02236 02237 02238 02239 /*************************************************************************** 02240 $RCSfile$ 02241 ------------------- 02242 cvs : $Id$ 02243 begin : Sat Jun 28 2003 02244 copyright : (C) 2003 by Martin Preuss 02245 email : martin@libchipcard.de 02246 02247 *************************************************************************** 02248 * * 02249 * This library is free software; you can redistribute it and/or * 02250 * modify it under the terms of the GNU Lesser General Public * 02251 * License as published by the Free Software Foundation; either * 02252 * version 2.1 of the License, or (at your option) any later version. * 02253 * * 02254 * This library is distributed in the hope that it will be useful, * 02255 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 02256 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 02257 * Lesser General Public License for more details. * 02258 * * 02259 * You should have received a copy of the GNU Lesser General Public * 02260 * License along with this library; if not, write to the Free Software * 02261 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 02262 * MA 02111-1307 USA * 02263 * * 02264 ***************************************************************************/ 02265 02266 02267 #ifndef AB_MESSAGE_LIST1_H 02268 #define AB_MESSAGE_LIST1_H 02269 02270 #ifdef __cplusplus 02271 extern "C" { 02272 #endif 02273 02275 typedef struct AB_MESSAGE_LIST_ELEMENT { 02276 uint32_t id; 02277 AB_MESSAGE *nextObject; 02278 } AB_MESSAGE_LIST__ELEMENT; 02279 02286 typedef struct AB_MESSAGE_LIST AB_MESSAGE_LIST; 02288 struct AB_MESSAGE_LIST { 02289 AB_MESSAGE *first; 02290 uint32_t count; 02291 uint32_t id; 02292 } AB_MESSAGE_LIST; 02293 02298 void AB_Message_List_AddList(AB_MESSAGE_LIST *dst, AB_MESSAGE_LIST *l); 02299 02303 void AB_Message_List_Add(AB_MESSAGE *element, AB_MESSAGE_LIST *list); 02304 02309 void AB_Message_List_Insert(AB_MESSAGE *element, AB_MESSAGE_LIST *list); 02310 02317 void AB_Message_List_Del(AB_MESSAGE *element); 02318 02322 AB_MESSAGE* AB_Message_List_First(const AB_MESSAGE_LIST *l); 02323 02327 AB_MESSAGE* AB_Message_List_Last(const AB_MESSAGE_LIST *l); 02328 02333 void AB_Message_List_Clear(AB_MESSAGE_LIST *l); 02334 02338 AB_MESSAGE_LIST* AB_Message_List_new(); 02339 02343 void AB_Message_List_free(AB_MESSAGE_LIST *l); 02344 02348 AB_MESSAGE* AB_Message_List_Next(const AB_MESSAGE *element); 02349 02353 AB_MESSAGE* AB_Message_List_Previous(const AB_MESSAGE *element); 02354 02358 uint32_t AB_Message_List_GetCount(const AB_MESSAGE_LIST *l); 02359 02360 #ifdef __cplusplus 02361 } 02362 #endif 02363 02364 02365 #endif 02366 02367 02368 02369 /*************************************************************************** 02370 $RCSfile$ 02371 ------------------- 02372 cvs : $Id$ 02373 begin : Sat Jun 28 2003 02374 copyright : (C) 2003 by Martin Preuss 02375 email : martin@libchipcard.de 02376 02377 *************************************************************************** 02378 * * 02379 * This library is free software; you can redistribute it and/or * 02380 * modify it under the terms of the GNU Lesser General Public * 02381 * License as published by the Free Software Foundation; either * 02382 * version 2.1 of the License, or (at your option) any later version. * 02383 * * 02384 * This library is distributed in the hope that it will be useful, * 02385 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 02386 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 02387 * Lesser General Public License for more details. * 02388 * * 02389 * You should have received a copy of the GNU Lesser General Public * 02390 * License along with this library; if not, write to the Free Software * 02391 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 02392 * MA 02111-1307 USA * 02393 * * 02394 ***************************************************************************/ 02395 02396 02397 #ifndef AB_COUNTRY_LIST2_H 02398 #define AB_COUNTRY_LIST2_H 02399 02400 02401 #ifdef __cplusplus 02402 extern "C" { 02403 #endif 02404 02411 typedef struct AB_COUNTRY_LIST2 AB_COUNTRY_LIST2; 02412 02416 typedef struct AB_COUNTRY_LIST2_ITERATOR AB_COUNTRY_LIST2_ITERATOR; 02417 02421 typedef AB_COUNTRY* (AB_COUNTRY_LIST2_FOREACH)(AB_COUNTRY *element, 02422 void *user_data); 02423 02427 AB_COUNTRY_LIST2 *AB_Country_List2_new(); 02428 02432 void AB_Country_List2_free(AB_COUNTRY_LIST2 *l); 02433 02437 void AB_Country_List2_Dump(AB_COUNTRY_LIST2 *l, FILE *f, unsigned int indent); 02438 02442 void AB_Country_List2_PushBack(AB_COUNTRY_LIST2 *l, AB_COUNTRY *p); 02443 02448 void AB_Country_List2_PushFront(AB_COUNTRY_LIST2 *l, AB_COUNTRY *p); 02449 02454 AB_COUNTRY *AB_Country_List2_GetFront(AB_COUNTRY_LIST2 *l); 02455 02460 AB_COUNTRY *AB_Country_List2_GetBack(AB_COUNTRY_LIST2 *l); 02461 02466 void AB_Country_List2_Erase(AB_COUNTRY_LIST2 *l, 02467 AB_COUNTRY_LIST2_ITERATOR *it); 02468 02474 unsigned int AB_Country_List2_GetSize(AB_COUNTRY_LIST2 *l); 02475 02480 void AB_Country_List2_PopBack(AB_COUNTRY_LIST2 *l); 02481 02486 void AB_Country_List2_PopFront(AB_COUNTRY_LIST2 *l); 02487 02491 void AB_Country_List2_Clear(AB_COUNTRY_LIST2 *l); 02492 02496 AB_COUNTRY_LIST2_ITERATOR *AB_Country_List2_First(AB_COUNTRY_LIST2 *l); 02497 02501 AB_COUNTRY_LIST2_ITERATOR *AB_Country_List2_Last(AB_COUNTRY_LIST2 *l); 02502 02506 AB_COUNTRY_LIST2_ITERATOR *AB_Country_List2Iterator_new(AB_COUNTRY_LIST2 *l); 02507 02511 void AB_Country_List2Iterator_free(AB_COUNTRY_LIST2_ITERATOR *li); 02512 02517 AB_COUNTRY *AB_Country_List2Iterator_Previous(AB_COUNTRY_LIST2_ITERATOR *li); 02518 02523 AB_COUNTRY *AB_Country_List2Iterator_Next(AB_COUNTRY_LIST2_ITERATOR *li); 02524 02529 AB_COUNTRY *AB_Country_List2Iterator_Data(AB_COUNTRY_LIST2_ITERATOR *li); 02530 02542 AB_COUNTRY *AB_Country_List2_ForEach(AB_COUNTRY_LIST2 *list, 02543 AB_COUNTRY_LIST2_FOREACH func, 02544 void *user_data); 02545 02546 02547 typedef struct AB_COUNTRY_CONSTLIST2 AB_COUNTRY_CONSTLIST2; 02548 typedef struct AB_COUNTRY_CONSTLIST2_ITERATOR AB_COUNTRY_CONSTLIST2_ITERATOR; 02549 typedef const AB_COUNTRY* 02550 (AB_COUNTRY_CONSTLIST2_FOREACH)(const AB_COUNTRY *element, 02551 void *user_data); 02552 02553 02554 AB_COUNTRY_CONSTLIST2 *AB_Country_ConstList2_new(); 02555 02556 void AB_Country_ConstList2_free(AB_COUNTRY_CONSTLIST2 *l); 02557 02558 void AB_Country_ConstList2_PushBack(AB_COUNTRY_CONSTLIST2 *l, const AB_COUNTRY *p); 02559 02560 void AB_Country_ConstList2_PushFront(AB_COUNTRY_CONSTLIST2 *l, const AB_COUNTRY *p); 02561 02562 const AB_COUNTRY *AB_Country_ConstList2_GetFront(AB_COUNTRY_CONSTLIST2 *l); 02563 02564 const AB_COUNTRY *AB_Country_ConstList2_GetBack(AB_COUNTRY_CONSTLIST2 *l); 02565 02566 unsigned int AB_Country_ConstList2_GetSize(AB_COUNTRY_CONSTLIST2 *l); 02567 02568 void AB_Country_ConstList2_PopBack(AB_COUNTRY_CONSTLIST2 *l); 02569 02570 void AB_Country_ConstList2_PopFront(AB_COUNTRY_CONSTLIST2 *l); 02571 02572 void AB_Country_ConstList2_Clear(AB_COUNTRY_CONSTLIST2 *l); 02573 02574 AB_COUNTRY_CONSTLIST2_ITERATOR *AB_Country_ConstList2_First(AB_COUNTRY_CONSTLIST2 *l); 02575 02576 AB_COUNTRY_CONSTLIST2_ITERATOR *AB_Country_ConstList2_Last(AB_COUNTRY_CONSTLIST2 *l); 02577 02578 AB_COUNTRY_CONSTLIST2_ITERATOR *AB_Country_ConstList2Iterator_new(AB_COUNTRY_CONSTLIST2 *l); 02579 02580 void AB_Country_ConstList2Iterator_free(AB_COUNTRY_CONSTLIST2_ITERATOR *li); 02581 02582 const AB_COUNTRY *AB_Country_ConstList2Iterator_Previous(AB_COUNTRY_CONSTLIST2_ITERATOR *li); 02583 02584 const AB_COUNTRY *AB_Country_ConstList2Iterator_Next(AB_COUNTRY_CONSTLIST2_ITERATOR *li); 02585 02586 const AB_COUNTRY *AB_Country_ConstList2Iterator_Data(AB_COUNTRY_CONSTLIST2_ITERATOR *li); 02587 02599 const AB_COUNTRY *AB_Country_ConstList2_ForEach(AB_COUNTRY_CONSTLIST2 *list, 02600 AB_COUNTRY_CONSTLIST2_FOREACH func, void *user_data); 02601 02602 02603 #ifdef __cplusplus 02604 } 02605 #endif 02606 02607 02608 #endif /* AB_COUNTRY_LIST_H */ 02609 02610 02611 02612 /*************************************************************************** 02613 $RCSfile$ 02614 ------------------- 02615 cvs : $Id$ 02616 begin : Sat Jun 28 2003 02617 copyright : (C) 2003 by Martin Preuss 02618 email : martin@libchipcard.de 02619 02620 *************************************************************************** 02621 * * 02622 * This library is free software; you can redistribute it and/or * 02623 * modify it under the terms of the GNU Lesser General Public * 02624 * License as published by the Free Software Foundation; either * 02625 * version 2.1 of the License, or (at your option) any later version. * 02626 * * 02627 * This library is distributed in the hope that it will be useful, * 02628 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 02629 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 02630 * Lesser General Public License for more details. * 02631 * * 02632 * You should have received a copy of the GNU Lesser General Public * 02633 * License along with this library; if not, write to the Free Software * 02634 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 02635 * MA 02111-1307 USA * 02636 * * 02637 ***************************************************************************/ 02638 02639 02640 #ifndef AB_CELLPHONE_PRODUCT_LIST2_H 02641 #define AB_CELLPHONE_PRODUCT_LIST2_H 02642 02643 02644 #ifdef __cplusplus 02645 extern "C" { 02646 #endif 02647 02654 typedef struct AB_CELLPHONE_PRODUCT_LIST2 AB_CELLPHONE_PRODUCT_LIST2; 02655 02659 typedef struct AB_CELLPHONE_PRODUCT_LIST2_ITERATOR AB_CELLPHONE_PRODUCT_LIST2_ITERATOR; 02660 02664 typedef AB_CELLPHONE_PRODUCT* (AB_CELLPHONE_PRODUCT_LIST2_FOREACH)(AB_CELLPHONE_PRODUCT *element, 02665 void *user_data); 02666 02670 AB_CELLPHONE_PRODUCT_LIST2 *AB_CellPhoneProduct_List2_new(); 02671 02675 void AB_CellPhoneProduct_List2_free(AB_CELLPHONE_PRODUCT_LIST2 *l); 02676 02680 void AB_CellPhoneProduct_List2_Dump(AB_CELLPHONE_PRODUCT_LIST2 *l, FILE *f, unsigned int indent); 02681 02685 void AB_CellPhoneProduct_List2_PushBack(AB_CELLPHONE_PRODUCT_LIST2 *l, AB_CELLPHONE_PRODUCT *p); 02686 02691 void AB_CellPhoneProduct_List2_PushFront(AB_CELLPHONE_PRODUCT_LIST2 *l, AB_CELLPHONE_PRODUCT *p); 02692 02697 AB_CELLPHONE_PRODUCT *AB_CellPhoneProduct_List2_GetFront(AB_CELLPHONE_PRODUCT_LIST2 *l); 02698 02703 AB_CELLPHONE_PRODUCT *AB_CellPhoneProduct_List2_GetBack(AB_CELLPHONE_PRODUCT_LIST2 *l); 02704 02709 void AB_CellPhoneProduct_List2_Erase(AB_CELLPHONE_PRODUCT_LIST2 *l, 02710 AB_CELLPHONE_PRODUCT_LIST2_ITERATOR *it); 02711 02717 unsigned int AB_CellPhoneProduct_List2_GetSize(AB_CELLPHONE_PRODUCT_LIST2 *l); 02718 02723 void AB_CellPhoneProduct_List2_PopBack(AB_CELLPHONE_PRODUCT_LIST2 *l); 02724 02729 void AB_CellPhoneProduct_List2_PopFront(AB_CELLPHONE_PRODUCT_LIST2 *l); 02730 02734 void AB_CellPhoneProduct_List2_Clear(AB_CELLPHONE_PRODUCT_LIST2 *l); 02735 02739 AB_CELLPHONE_PRODUCT_LIST2_ITERATOR *AB_CellPhoneProduct_List2_First(AB_CELLPHONE_PRODUCT_LIST2 *l); 02740 02744 AB_CELLPHONE_PRODUCT_LIST2_ITERATOR *AB_CellPhoneProduct_List2_Last(AB_CELLPHONE_PRODUCT_LIST2 *l); 02745 02749 AB_CELLPHONE_PRODUCT_LIST2_ITERATOR *AB_CellPhoneProduct_List2Iterator_new(AB_CELLPHONE_PRODUCT_LIST2 *l); 02750 02754 void AB_CellPhoneProduct_List2Iterator_free(AB_CELLPHONE_PRODUCT_LIST2_ITERATOR *li); 02755 02760 AB_CELLPHONE_PRODUCT *AB_CellPhoneProduct_List2Iterator_Previous(AB_CELLPHONE_PRODUCT_LIST2_ITERATOR *li); 02761 02766 AB_CELLPHONE_PRODUCT *AB_CellPhoneProduct_List2Iterator_Next(AB_CELLPHONE_PRODUCT_LIST2_ITERATOR *li); 02767 02772 AB_CELLPHONE_PRODUCT *AB_CellPhoneProduct_List2Iterator_Data(AB_CELLPHONE_PRODUCT_LIST2_ITERATOR *li); 02773 02785 AB_CELLPHONE_PRODUCT *AB_CellPhoneProduct_List2_ForEach(AB_CELLPHONE_PRODUCT_LIST2 *list, 02786 AB_CELLPHONE_PRODUCT_LIST2_FOREACH func, 02787 void *user_data); 02788 02789 02790 typedef struct AB_CELLPHONE_PRODUCT_CONSTLIST2 AB_CELLPHONE_PRODUCT_CONSTLIST2; 02791 typedef struct AB_CELLPHONE_PRODUCT_CONSTLIST2_ITERATOR AB_CELLPHONE_PRODUCT_CONSTLIST2_ITERATOR; 02792 typedef const AB_CELLPHONE_PRODUCT* 02793 (AB_CELLPHONE_PRODUCT_CONSTLIST2_FOREACH)(const AB_CELLPHONE_PRODUCT *element, 02794 void *user_data); 02795 02796 02797 AB_CELLPHONE_PRODUCT_CONSTLIST2 *AB_CellPhoneProduct_ConstList2_new(); 02798 02799 void AB_CellPhoneProduct_ConstList2_free(AB_CELLPHONE_PRODUCT_CONSTLIST2 *l); 02800 02801 void AB_CellPhoneProduct_ConstList2_PushBack(AB_CELLPHONE_PRODUCT_CONSTLIST2 *l, const AB_CELLPHONE_PRODUCT *p); 02802 02803 void AB_CellPhoneProduct_ConstList2_PushFront(AB_CELLPHONE_PRODUCT_CONSTLIST2 *l, const AB_CELLPHONE_PRODUCT *p); 02804 02805 const AB_CELLPHONE_PRODUCT *AB_CellPhoneProduct_ConstList2_GetFront(AB_CELLPHONE_PRODUCT_CONSTLIST2 *l); 02806 02807 const AB_CELLPHONE_PRODUCT *AB_CellPhoneProduct_ConstList2_GetBack(AB_CELLPHONE_PRODUCT_CONSTLIST2 *l); 02808 02809 unsigned int AB_CellPhoneProduct_ConstList2_GetSize(AB_CELLPHONE_PRODUCT_CONSTLIST2 *l); 02810 02811 void AB_CellPhoneProduct_ConstList2_PopBack(AB_CELLPHONE_PRODUCT_CONSTLIST2 *l); 02812 02813 void AB_CellPhoneProduct_ConstList2_PopFront(AB_CELLPHONE_PRODUCT_CONSTLIST2 *l); 02814 02815 void AB_CellPhoneProduct_ConstList2_Clear(AB_CELLPHONE_PRODUCT_CONSTLIST2 *l); 02816 02817 AB_CELLPHONE_PRODUCT_CONSTLIST2_ITERATOR *AB_CellPhoneProduct_ConstList2_First(AB_CELLPHONE_PRODUCT_CONSTLIST2 *l); 02818 02819 AB_CELLPHONE_PRODUCT_CONSTLIST2_ITERATOR *AB_CellPhoneProduct_ConstList2_Last(AB_CELLPHONE_PRODUCT_CONSTLIST2 *l); 02820 02821 AB_CELLPHONE_PRODUCT_CONSTLIST2_ITERATOR *AB_CellPhoneProduct_ConstList2Iterator_new(AB_CELLPHONE_PRODUCT_CONSTLIST2 *l); 02822 02823 void AB_CellPhoneProduct_ConstList2Iterator_free(AB_CELLPHONE_PRODUCT_CONSTLIST2_ITERATOR *li); 02824 02825 const AB_CELLPHONE_PRODUCT *AB_CellPhoneProduct_ConstList2Iterator_Previous(AB_CELLPHONE_PRODUCT_CONSTLIST2_ITERATOR *li); 02826 02827 const AB_CELLPHONE_PRODUCT *AB_CellPhoneProduct_ConstList2Iterator_Next(AB_CELLPHONE_PRODUCT_CONSTLIST2_ITERATOR *li); 02828 02829 const AB_CELLPHONE_PRODUCT *AB_CellPhoneProduct_ConstList2Iterator_Data(AB_CELLPHONE_PRODUCT_CONSTLIST2_ITERATOR *li); 02830 02842 const AB_CELLPHONE_PRODUCT *AB_CellPhoneProduct_ConstList2_ForEach(AB_CELLPHONE_PRODUCT_CONSTLIST2 *list, 02843 AB_CELLPHONE_PRODUCT_CONSTLIST2_FOREACH func, void *user_data); 02844 02845 02846 #ifdef __cplusplus 02847 } 02848 #endif 02849 02850 02851 #endif /* AB_CELLPHONE_PRODUCT_LIST_H */ 02852 02853 02854 02855 /*************************************************************************** 02856 $RCSfile$ 02857 ------------------- 02858 cvs : $Id$ 02859 begin : Sat Jun 28 2003 02860 copyright : (C) 2003 by Martin Preuss 02861 email : martin@libchipcard.de 02862 02863 *************************************************************************** 02864 * * 02865 * This library is free software; you can redistribute it and/or * 02866 * modify it under the terms of the GNU Lesser General Public * 02867 * License as published by the Free Software Foundation; either * 02868 * version 2.1 of the License, or (at your option) any later version. * 02869 * * 02870 * This library is distributed in the hope that it will be useful, * 02871 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 02872 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 02873 * Lesser General Public License for more details. * 02874 * * 02875 * You should have received a copy of the GNU Lesser General Public * 02876 * License along with this library; if not, write to the Free Software * 02877 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 02878 * MA 02111-1307 USA * 02879 * * 02880 ***************************************************************************/ 02881 02882 02883 #ifndef AB_CELLPHONE_PRODUCT_LIST1_H 02884 #define AB_CELLPHONE_PRODUCT_LIST1_H 02885 02886 #ifdef __cplusplus 02887 extern "C" { 02888 #endif 02889 02891 typedef struct AB_CELLPHONE_PRODUCT_LIST_ELEMENT { 02892 uint32_t id; 02893 AB_CELLPHONE_PRODUCT *nextObject; 02894 } AB_CELLPHONE_PRODUCT_LIST__ELEMENT; 02895 02902 typedef struct AB_CELLPHONE_PRODUCT_LIST AB_CELLPHONE_PRODUCT_LIST; 02904 struct AB_CELLPHONE_PRODUCT_LIST { 02905 AB_CELLPHONE_PRODUCT *first; 02906 uint32_t count; 02907 uint32_t id; 02908 } AB_CELLPHONE_PRODUCT_LIST; 02909 02914 void AB_CellPhoneProduct_List_AddList(AB_CELLPHONE_PRODUCT_LIST *dst, AB_CELLPHONE_PRODUCT_LIST *l); 02915 02919 void AB_CellPhoneProduct_List_Add(AB_CELLPHONE_PRODUCT *element, AB_CELLPHONE_PRODUCT_LIST *list); 02920 02925 void AB_CellPhoneProduct_List_Insert(AB_CELLPHONE_PRODUCT *element, AB_CELLPHONE_PRODUCT_LIST *list); 02926 02933 void AB_CellPhoneProduct_List_Del(AB_CELLPHONE_PRODUCT *element); 02934 02938 AB_CELLPHONE_PRODUCT* AB_CellPhoneProduct_List_First(const AB_CELLPHONE_PRODUCT_LIST *l); 02939 02943 AB_CELLPHONE_PRODUCT* AB_CellPhoneProduct_List_Last(const AB_CELLPHONE_PRODUCT_LIST *l); 02944 02949 void AB_CellPhoneProduct_List_Clear(AB_CELLPHONE_PRODUCT_LIST *l); 02950 02954 AB_CELLPHONE_PRODUCT_LIST* AB_CellPhoneProduct_List_new(); 02955 02959 void AB_CellPhoneProduct_List_free(AB_CELLPHONE_PRODUCT_LIST *l); 02960 02964 AB_CELLPHONE_PRODUCT* AB_CellPhoneProduct_List_Next(const AB_CELLPHONE_PRODUCT *element); 02965 02969 AB_CELLPHONE_PRODUCT* AB_CellPhoneProduct_List_Previous(const AB_CELLPHONE_PRODUCT *element); 02970 02974 uint32_t AB_CellPhoneProduct_List_GetCount(const AB_CELLPHONE_PRODUCT_LIST *l); 02975 02976 #ifdef __cplusplus 02977 } 02978 #endif 02979 02980 02981 #endif 02982 02983 02984 02985 /*************************************************************************** 02986 $RCSfile$ 02987 ------------------- 02988 cvs : $Id$ 02989 begin : Sat Jun 28 2003 02990 copyright : (C) 2003 by Martin Preuss 02991 email : martin@libchipcard.de 02992 02993 *************************************************************************** 02994 * * 02995 * This library is free software; you can redistribute it and/or * 02996 * modify it under the terms of the GNU Lesser General Public * 02997 * License as published by the Free Software Foundation; either * 02998 * version 2.1 of the License, or (at your option) any later version. * 02999 * * 03000 * This library is distributed in the hope that it will be useful, * 03001 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 03002 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 03003 * Lesser General Public License for more details. * 03004 * * 03005 * You should have received a copy of the GNU Lesser General Public * 03006 * License along with this library; if not, write to the Free Software * 03007 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 03008 * MA 02111-1307 USA * 03009 * * 03010 ***************************************************************************/ 03011 03012 03013 #ifndef AB_USERQUEUE_LIST1_H 03014 #define AB_USERQUEUE_LIST1_H 03015 03016 #ifdef __cplusplus 03017 extern "C" { 03018 #endif 03019 03021 typedef struct AB_USERQUEUE_LIST_ELEMENT { 03022 uint32_t id; 03023 AB_USERQUEUE *nextObject; 03024 } AB_USERQUEUE_LIST__ELEMENT; 03025 03032 typedef struct AB_USERQUEUE_LIST AB_USERQUEUE_LIST; 03034 struct AB_USERQUEUE_LIST { 03035 AB_USERQUEUE *first; 03036 uint32_t count; 03037 uint32_t id; 03038 } AB_USERQUEUE_LIST; 03039 03044 void AB_UserQueue_List_AddList(AB_USERQUEUE_LIST *dst, AB_USERQUEUE_LIST *l); 03045 03049 void AB_UserQueue_List_Add(AB_USERQUEUE *element, AB_USERQUEUE_LIST *list); 03050 03055 void AB_UserQueue_List_Insert(AB_USERQUEUE *element, AB_USERQUEUE_LIST *list); 03056 03063 void AB_UserQueue_List_Del(AB_USERQUEUE *element); 03064 03068 AB_USERQUEUE* AB_UserQueue_List_First(const AB_USERQUEUE_LIST *l); 03069 03073 AB_USERQUEUE* AB_UserQueue_List_Last(const AB_USERQUEUE_LIST *l); 03074 03079 void AB_UserQueue_List_Clear(AB_USERQUEUE_LIST *l); 03080 03084 AB_USERQUEUE_LIST* AB_UserQueue_List_new(); 03085 03089 void AB_UserQueue_List_free(AB_USERQUEUE_LIST *l); 03090 03094 AB_USERQUEUE* AB_UserQueue_List_Next(const AB_USERQUEUE *element); 03095 03099 AB_USERQUEUE* AB_UserQueue_List_Previous(const AB_USERQUEUE *element); 03100 03104 uint32_t AB_UserQueue_List_GetCount(const AB_USERQUEUE_LIST *l); 03105 03106 #ifdef __cplusplus 03107 } 03108 #endif 03109 03110 03111 #endif 03112 03113 03114 03115 /*************************************************************************** 03116 $RCSfile$ 03117 ------------------- 03118 cvs : $Id$ 03119 begin : Sat Jun 28 2003 03120 copyright : (C) 2003 by Martin Preuss 03121 email : martin@libchipcard.de 03122 03123 *************************************************************************** 03124 * * 03125 * This library is free software; you can redistribute it and/or * 03126 * modify it under the terms of the GNU Lesser General Public * 03127 * License as published by the Free Software Foundation; either * 03128 * version 2.1 of the License, or (at your option) any later version. * 03129 * * 03130 * This library is distributed in the hope that it will be useful, * 03131 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 03132 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 03133 * Lesser General Public License for more details. * 03134 * * 03135 * You should have received a copy of the GNU Lesser General Public * 03136 * License along with this library; if not, write to the Free Software * 03137 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 03138 * MA 02111-1307 USA * 03139 * * 03140 ***************************************************************************/ 03141 03142 03143 #ifndef AB_PROVIDER_DESCRIPTION_LIST2_H 03144 #define AB_PROVIDER_DESCRIPTION_LIST2_H 03145 03146 03147 #ifdef __cplusplus 03148 extern "C" { 03149 #endif 03150 03157 typedef struct AB_PROVIDER_DESCRIPTION_LIST2 AB_PROVIDER_DESCRIPTION_LIST2; 03158 03162 typedef struct AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR; 03163 03167 typedef AB_PROVIDER_DESCRIPTION* (AB_PROVIDER_DESCRIPTION_LIST2_FOREACH)(AB_PROVIDER_DESCRIPTION *element, 03168 void *user_data); 03169 03173 AB_PROVIDER_DESCRIPTION_LIST2 *AB_ProviderDescription_List2_new(); 03174 03178 void AB_ProviderDescription_List2_free(AB_PROVIDER_DESCRIPTION_LIST2 *l); 03179 03183 void AB_ProviderDescription_List2_Dump(AB_PROVIDER_DESCRIPTION_LIST2 *l, FILE *f, unsigned int indent); 03184 03188 void AB_ProviderDescription_List2_PushBack(AB_PROVIDER_DESCRIPTION_LIST2 *l, AB_PROVIDER_DESCRIPTION *p); 03189 03194 void AB_ProviderDescription_List2_PushFront(AB_PROVIDER_DESCRIPTION_LIST2 *l, AB_PROVIDER_DESCRIPTION *p); 03195 03200 AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_List2_GetFront(AB_PROVIDER_DESCRIPTION_LIST2 *l); 03201 03206 AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_List2_GetBack(AB_PROVIDER_DESCRIPTION_LIST2 *l); 03207 03212 void AB_ProviderDescription_List2_Erase(AB_PROVIDER_DESCRIPTION_LIST2 *l, 03213 AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR *it); 03214 03220 unsigned int AB_ProviderDescription_List2_GetSize(AB_PROVIDER_DESCRIPTION_LIST2 *l); 03221 03226 void AB_ProviderDescription_List2_PopBack(AB_PROVIDER_DESCRIPTION_LIST2 *l); 03227 03232 void AB_ProviderDescription_List2_PopFront(AB_PROVIDER_DESCRIPTION_LIST2 *l); 03233 03237 void AB_ProviderDescription_List2_Clear(AB_PROVIDER_DESCRIPTION_LIST2 *l); 03238 03242 AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR *AB_ProviderDescription_List2_First(AB_PROVIDER_DESCRIPTION_LIST2 *l); 03243 03247 AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR *AB_ProviderDescription_List2_Last(AB_PROVIDER_DESCRIPTION_LIST2 *l); 03248 03252 AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR *AB_ProviderDescription_List2Iterator_new(AB_PROVIDER_DESCRIPTION_LIST2 *l); 03253 03257 void AB_ProviderDescription_List2Iterator_free(AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR *li); 03258 03263 AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_List2Iterator_Previous(AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR *li); 03264 03269 AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_List2Iterator_Next(AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR *li); 03270 03275 AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_List2Iterator_Data(AB_PROVIDER_DESCRIPTION_LIST2_ITERATOR *li); 03276 03288 AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_List2_ForEach(AB_PROVIDER_DESCRIPTION_LIST2 *list, 03289 AB_PROVIDER_DESCRIPTION_LIST2_FOREACH func, 03290 void *user_data); 03291 03292 03293 typedef struct AB_PROVIDER_DESCRIPTION_CONSTLIST2 AB_PROVIDER_DESCRIPTION_CONSTLIST2; 03294 typedef struct AB_PROVIDER_DESCRIPTION_CONSTLIST2_ITERATOR AB_PROVIDER_DESCRIPTION_CONSTLIST2_ITERATOR; 03295 typedef const AB_PROVIDER_DESCRIPTION* 03296 (AB_PROVIDER_DESCRIPTION_CONSTLIST2_FOREACH)(const AB_PROVIDER_DESCRIPTION *element, 03297 void *user_data); 03298 03299 03300 AB_PROVIDER_DESCRIPTION_CONSTLIST2 *AB_ProviderDescription_ConstList2_new(); 03301 03302 void AB_ProviderDescription_ConstList2_free(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 03303 03304 void AB_ProviderDescription_ConstList2_PushBack(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l, const AB_PROVIDER_DESCRIPTION *p); 03305 03306 void AB_ProviderDescription_ConstList2_PushFront(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l, const AB_PROVIDER_DESCRIPTION *p); 03307 03308 const AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_ConstList2_GetFront(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 03309 03310 const AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_ConstList2_GetBack(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 03311 03312 unsigned int AB_ProviderDescription_ConstList2_GetSize(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 03313 03314 void AB_ProviderDescription_ConstList2_PopBack(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 03315 03316 void AB_ProviderDescription_ConstList2_PopFront(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 03317 03318 void AB_ProviderDescription_ConstList2_Clear(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 03319 03320 AB_PROVIDER_DESCRIPTION_CONSTLIST2_ITERATOR *AB_ProviderDescription_ConstList2_First(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 03321 03322 AB_PROVIDER_DESCRIPTION_CONSTLIST2_ITERATOR *AB_ProviderDescription_ConstList2_Last(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 03323 03324 AB_PROVIDER_DESCRIPTION_CONSTLIST2_ITERATOR *AB_ProviderDescription_ConstList2Iterator_new(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *l); 03325 03326 void AB_ProviderDescription_ConstList2Iterator_free(AB_PROVIDER_DESCRIPTION_CONSTLIST2_ITERATOR *li); 03327 03328 const AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_ConstList2Iterator_Previous(AB_PROVIDER_DESCRIPTION_CONSTLIST2_ITERATOR *li); 03329 03330 const AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_ConstList2Iterator_Next(AB_PROVIDER_DESCRIPTION_CONSTLIST2_ITERATOR *li); 03331 03332 const AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_ConstList2Iterator_Data(AB_PROVIDER_DESCRIPTION_CONSTLIST2_ITERATOR *li); 03333 03345 const AB_PROVIDER_DESCRIPTION *AB_ProviderDescription_ConstList2_ForEach(AB_PROVIDER_DESCRIPTION_CONSTLIST2 *list, 03346 AB_PROVIDER_DESCRIPTION_CONSTLIST2_FOREACH func, void *user_data); 03347 03348 03349 #ifdef __cplusplus 03350 } 03351 #endif 03352 03353 03354 #endif /* AB_PROVIDER_DESCRIPTION_LIST_H */ 03355 03356 03357 03358 /*************************************************************************** 03359 $RCSfile$ 03360 ------------------- 03361 cvs : $Id$ 03362 begin : Sat Jun 28 2003 03363 copyright : (C) 2003 by Martin Preuss 03364 email : martin@libchipcard.de 03365 03366 *************************************************************************** 03367 * * 03368 * This library is free software; you can redistribute it and/or * 03369 * modify it under the terms of the GNU Lesser General Public * 03370 * License as published by the Free Software Foundation; either * 03371 * version 2.1 of the License, or (at your option) any later version. * 03372 * * 03373 * This library is distributed in the hope that it will be useful, * 03374 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 03375 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 03376 * Lesser General Public License for more details. * 03377 * * 03378 * You should have received a copy of the GNU Lesser General Public * 03379 * License along with this library; if not, write to the Free Software * 03380 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 03381 * MA 02111-1307 USA * 03382 * * 03383 ***************************************************************************/ 03384 03385 03386 #ifndef AB_PROVIDER_DESCRIPTION_LIST1_H 03387 #define AB_PROVIDER_DESCRIPTION_LIST1_H 03388 03389 #ifdef __cplusplus 03390 extern "C" { 03391 #endif 03392 03394 typedef struct AB_PROVIDER_DESCRIPTION_LIST_ELEMENT { 03395 uint32_t id; 03396 AB_PROVIDER_DESCRIPTION *nextObject; 03397 } AB_PROVIDER_DESCRIPTION_LIST__ELEMENT; 03398 03405 typedef struct AB_PROVIDER_DESCRIPTION_LIST AB_PROVIDER_DESCRIPTION_LIST; 03407 struct AB_PROVIDER_DESCRIPTION_LIST { 03408 AB_PROVIDER_DESCRIPTION *first; 03409 uint32_t count; 03410 uint32_t id; 03411 } AB_PROVIDER_DESCRIPTION_LIST; 03412 03417 void AB_ProviderDescription_List_AddList(AB_PROVIDER_DESCRIPTION_LIST *dst, AB_PROVIDER_DESCRIPTION_LIST *l); 03418 03422 void AB_ProviderDescription_List_Add(AB_PROVIDER_DESCRIPTION *element, AB_PROVIDER_DESCRIPTION_LIST *list); 03423 03428 void AB_ProviderDescription_List_Insert(AB_PROVIDER_DESCRIPTION *element, AB_PROVIDER_DESCRIPTION_LIST *list); 03429 03436 void AB_ProviderDescription_List_Del(AB_PROVIDER_DESCRIPTION *element); 03437 03441 AB_PROVIDER_DESCRIPTION* AB_ProviderDescription_List_First(const AB_PROVIDER_DESCRIPTION_LIST *l); 03442 03446 AB_PROVIDER_DESCRIPTION* AB_ProviderDescription_List_Last(const AB_PROVIDER_DESCRIPTION_LIST *l); 03447 03452 void AB_ProviderDescription_List_Clear(AB_PROVIDER_DESCRIPTION_LIST *l); 03453 03457 AB_PROVIDER_DESCRIPTION_LIST* AB_ProviderDescription_List_new(); 03458 03462 void AB_ProviderDescription_List_free(AB_PROVIDER_DESCRIPTION_LIST *l); 03463 03467 AB_PROVIDER_DESCRIPTION* AB_ProviderDescription_List_Next(const AB_PROVIDER_DESCRIPTION *element); 03468 03472 AB_PROVIDER_DESCRIPTION* AB_ProviderDescription_List_Previous(const AB_PROVIDER_DESCRIPTION *element); 03473 03477 uint32_t AB_ProviderDescription_List_GetCount(const AB_PROVIDER_DESCRIPTION_LIST *l); 03478 03479 #ifdef __cplusplus 03480 } 03481 #endif 03482 03483 03484 #endif 03485 03486 03487 03488 /*************************************************************************** 03489 $RCSfile$ 03490 ------------------- 03491 cvs : $Id$ 03492 begin : Sat Jun 28 2003 03493 copyright : (C) 2003 by Martin Preuss 03494 email : martin@libchipcard.de 03495 03496 *************************************************************************** 03497 * * 03498 * This library is free software; you can redistribute it and/or * 03499 * modify it under the terms of the GNU Lesser General Public * 03500 * License as published by the Free Software Foundation; either * 03501 * version 2.1 of the License, or (at your option) any later version. * 03502 * * 03503 * This library is distributed in the hope that it will be useful, * 03504 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 03505 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 03506 * Lesser General Public License for more details. * 03507 * * 03508 * You should have received a copy of the GNU Lesser General Public * 03509 * License along with this library; if not, write to the Free Software * 03510 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 03511 * MA 02111-1307 USA * 03512 * * 03513 ***************************************************************************/ 03514 03515 03516 #ifndef AB_TRANSACTION_LIST2_H 03517 #define AB_TRANSACTION_LIST2_H 03518 03519 03520 #ifdef __cplusplus 03521 extern "C" { 03522 #endif 03523 03530 typedef struct AB_TRANSACTION_LIST2 AB_TRANSACTION_LIST2; 03531 03535 typedef struct AB_TRANSACTION_LIST2_ITERATOR AB_TRANSACTION_LIST2_ITERATOR; 03536 03540 typedef AB_TRANSACTION* (AB_TRANSACTION_LIST2_FOREACH)(AB_TRANSACTION *element, 03541 void *user_data); 03542 03546 AB_TRANSACTION_LIST2 *AB_Transaction_List2_new(); 03547 03551 void AB_Transaction_List2_free(AB_TRANSACTION_LIST2 *l); 03552 03556 void AB_Transaction_List2_Dump(AB_TRANSACTION_LIST2 *l, FILE *f, unsigned int indent); 03557 03561 void AB_Transaction_List2_PushBack(AB_TRANSACTION_LIST2 *l, AB_TRANSACTION *p); 03562 03567 void AB_Transaction_List2_PushFront(AB_TRANSACTION_LIST2 *l, AB_TRANSACTION *p); 03568 03573 AB_TRANSACTION *AB_Transaction_List2_GetFront(AB_TRANSACTION_LIST2 *l); 03574 03579 AB_TRANSACTION *AB_Transaction_List2_GetBack(AB_TRANSACTION_LIST2 *l); 03580 03585 void AB_Transaction_List2_Erase(AB_TRANSACTION_LIST2 *l, 03586 AB_TRANSACTION_LIST2_ITERATOR *it); 03587 03593 unsigned int AB_Transaction_List2_GetSize(AB_TRANSACTION_LIST2 *l); 03594 03599 void AB_Transaction_List2_PopBack(AB_TRANSACTION_LIST2 *l); 03600 03605 void AB_Transaction_List2_PopFront(AB_TRANSACTION_LIST2 *l); 03606 03610 void AB_Transaction_List2_Clear(AB_TRANSACTION_LIST2 *l); 03611 03615 AB_TRANSACTION_LIST2_ITERATOR *AB_Transaction_List2_First(AB_TRANSACTION_LIST2 *l); 03616 03620 AB_TRANSACTION_LIST2_ITERATOR *AB_Transaction_List2_Last(AB_TRANSACTION_LIST2 *l); 03621 03625 AB_TRANSACTION_LIST2_ITERATOR *AB_Transaction_List2Iterator_new(AB_TRANSACTION_LIST2 *l); 03626 03630 void AB_Transaction_List2Iterator_free(AB_TRANSACTION_LIST2_ITERATOR *li); 03631 03636 AB_TRANSACTION *AB_Transaction_List2Iterator_Previous(AB_TRANSACTION_LIST2_ITERATOR *li); 03637 03642 AB_TRANSACTION *AB_Transaction_List2Iterator_Next(AB_TRANSACTION_LIST2_ITERATOR *li); 03643 03648 AB_TRANSACTION *AB_Transaction_List2Iterator_Data(AB_TRANSACTION_LIST2_ITERATOR *li); 03649 03661 AB_TRANSACTION *AB_Transaction_List2_ForEach(AB_TRANSACTION_LIST2 *list, 03662 AB_TRANSACTION_LIST2_FOREACH func, 03663 void *user_data); 03664 03665 03666 typedef struct AB_TRANSACTION_CONSTLIST2 AB_TRANSACTION_CONSTLIST2; 03667 typedef struct AB_TRANSACTION_CONSTLIST2_ITERATOR AB_TRANSACTION_CONSTLIST2_ITERATOR; 03668 typedef const AB_TRANSACTION* 03669 (AB_TRANSACTION_CONSTLIST2_FOREACH)(const AB_TRANSACTION *element, 03670 void *user_data); 03671 03672 03673 AB_TRANSACTION_CONSTLIST2 *AB_Transaction_ConstList2_new(); 03674 03675 void AB_Transaction_ConstList2_free(AB_TRANSACTION_CONSTLIST2 *l); 03676 03677 void AB_Transaction_ConstList2_PushBack(AB_TRANSACTION_CONSTLIST2 *l, const AB_TRANSACTION *p); 03678 03679 void AB_Transaction_ConstList2_PushFront(AB_TRANSACTION_CONSTLIST2 *l, const AB_TRANSACTION *p); 03680 03681 const AB_TRANSACTION *AB_Transaction_ConstList2_GetFront(AB_TRANSACTION_CONSTLIST2 *l); 03682 03683 const AB_TRANSACTION *AB_Transaction_ConstList2_GetBack(AB_TRANSACTION_CONSTLIST2 *l); 03684 03685 unsigned int AB_Transaction_ConstList2_GetSize(AB_TRANSACTION_CONSTLIST2 *l); 03686 03687 void AB_Transaction_ConstList2_PopBack(AB_TRANSACTION_CONSTLIST2 *l); 03688 03689 void AB_Transaction_ConstList2_PopFront(AB_TRANSACTION_CONSTLIST2 *l); 03690 03691 void AB_Transaction_ConstList2_Clear(AB_TRANSACTION_CONSTLIST2 *l); 03692 03693 AB_TRANSACTION_CONSTLIST2_ITERATOR *AB_Transaction_ConstList2_First(AB_TRANSACTION_CONSTLIST2 *l); 03694 03695 AB_TRANSACTION_CONSTLIST2_ITERATOR *AB_Transaction_ConstList2_Last(AB_TRANSACTION_CONSTLIST2 *l); 03696 03697 AB_TRANSACTION_CONSTLIST2_ITERATOR *AB_Transaction_ConstList2Iterator_new(AB_TRANSACTION_CONSTLIST2 *l); 03698 03699 void AB_Transaction_ConstList2Iterator_free(AB_TRANSACTION_CONSTLIST2_ITERATOR *li); 03700 03701 const AB_TRANSACTION *AB_Transaction_ConstList2Iterator_Previous(AB_TRANSACTION_CONSTLIST2_ITERATOR *li); 03702 03703 const AB_TRANSACTION *AB_Transaction_ConstList2Iterator_Next(AB_TRANSACTION_CONSTLIST2_ITERATOR *li); 03704 03705 const AB_TRANSACTION *AB_Transaction_ConstList2Iterator_Data(AB_TRANSACTION_CONSTLIST2_ITERATOR *li); 03706 03718 const AB_TRANSACTION *AB_Transaction_ConstList2_ForEach(AB_TRANSACTION_CONSTLIST2 *list, 03719 AB_TRANSACTION_CONSTLIST2_FOREACH func, void *user_data); 03720 03721 03722 #ifdef __cplusplus 03723 } 03724 #endif 03725 03726 03727 #endif /* AB_TRANSACTION_LIST_H */ 03728 03729 03730 03731 /*************************************************************************** 03732 $RCSfile$ 03733 ------------------- 03734 cvs : $Id$ 03735 begin : Sat Jun 28 2003 03736 copyright : (C) 2003 by Martin Preuss 03737 email : martin@libchipcard.de 03738 03739 *************************************************************************** 03740 * * 03741 * This library is free software; you can redistribute it and/or * 03742 * modify it under the terms of the GNU Lesser General Public * 03743 * License as published by the Free Software Foundation; either * 03744 * version 2.1 of the License, or (at your option) any later version. * 03745 * * 03746 * This library is distributed in the hope that it will be useful, * 03747 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 03748 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 03749 * Lesser General Public License for more details. * 03750 * * 03751 * You should have received a copy of the GNU Lesser General Public * 03752 * License along with this library; if not, write to the Free Software * 03753 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 03754 * MA 02111-1307 USA * 03755 * * 03756 ***************************************************************************/ 03757 03758 03759 #ifndef AB_USER_LIST2_H 03760 #define AB_USER_LIST2_H 03761 03762 03763 #ifdef __cplusplus 03764 extern "C" { 03765 #endif 03766 03773 typedef struct AB_USER_LIST2 AB_USER_LIST2; 03774 03778 typedef struct AB_USER_LIST2_ITERATOR AB_USER_LIST2_ITERATOR; 03779 03783 typedef AB_USER* (AB_USER_LIST2_FOREACH)(AB_USER *element, 03784 void *user_data); 03785 03789 AB_USER_LIST2 *AB_User_List2_new(); 03790 03794 void AB_User_List2_free(AB_USER_LIST2 *l); 03795 03799 void AB_User_List2_Dump(AB_USER_LIST2 *l, FILE *f, unsigned int indent); 03800 03804 void AB_User_List2_PushBack(AB_USER_LIST2 *l, AB_USER *p); 03805 03810 void AB_User_List2_PushFront(AB_USER_LIST2 *l, AB_USER *p); 03811 03816 AB_USER *AB_User_List2_GetFront(AB_USER_LIST2 *l); 03817 03822 AB_USER *AB_User_List2_GetBack(AB_USER_LIST2 *l); 03823 03828 void AB_User_List2_Erase(AB_USER_LIST2 *l, 03829 AB_USER_LIST2_ITERATOR *it); 03830 03836 unsigned int AB_User_List2_GetSize(AB_USER_LIST2 *l); 03837 03842 void AB_User_List2_PopBack(AB_USER_LIST2 *l); 03843 03848 void AB_User_List2_PopFront(AB_USER_LIST2 *l); 03849 03853 void AB_User_List2_Clear(AB_USER_LIST2 *l); 03854 03858 AB_USER_LIST2_ITERATOR *AB_User_List2_First(AB_USER_LIST2 *l); 03859 03863 AB_USER_LIST2_ITERATOR *AB_User_List2_Last(AB_USER_LIST2 *l); 03864 03868 AB_USER_LIST2_ITERATOR *AB_User_List2Iterator_new(AB_USER_LIST2 *l); 03869 03873 void AB_User_List2Iterator_free(AB_USER_LIST2_ITERATOR *li); 03874 03879 AB_USER *AB_User_List2Iterator_Previous(AB_USER_LIST2_ITERATOR *li); 03880 03885 AB_USER *AB_User_List2Iterator_Next(AB_USER_LIST2_ITERATOR *li); 03886 03891 AB_USER *AB_User_List2Iterator_Data(AB_USER_LIST2_ITERATOR *li); 03892 03904 AB_USER *AB_User_List2_ForEach(AB_USER_LIST2 *list, 03905 AB_USER_LIST2_FOREACH func, 03906 void *user_data); 03907 03908 03909 typedef struct AB_USER_CONSTLIST2 AB_USER_CONSTLIST2; 03910 typedef struct AB_USER_CONSTLIST2_ITERATOR AB_USER_CONSTLIST2_ITERATOR; 03911 typedef const AB_USER* 03912 (AB_USER_CONSTLIST2_FOREACH)(const AB_USER *element, 03913 void *user_data); 03914 03915 03916 AB_USER_CONSTLIST2 *AB_User_ConstList2_new(); 03917 03918 void AB_User_ConstList2_free(AB_USER_CONSTLIST2 *l); 03919 03920 void AB_User_ConstList2_PushBack(AB_USER_CONSTLIST2 *l, const AB_USER *p); 03921 03922 void AB_User_ConstList2_PushFront(AB_USER_CONSTLIST2 *l, const AB_USER *p); 03923 03924 const AB_USER *AB_User_ConstList2_GetFront(AB_USER_CONSTLIST2 *l); 03925 03926 const AB_USER *AB_User_ConstList2_GetBack(AB_USER_CONSTLIST2 *l); 03927 03928 unsigned int AB_User_ConstList2_GetSize(AB_USER_CONSTLIST2 *l); 03929 03930 void AB_User_ConstList2_PopBack(AB_USER_CONSTLIST2 *l); 03931 03932 void AB_User_ConstList2_PopFront(AB_USER_CONSTLIST2 *l); 03933 03934 void AB_User_ConstList2_Clear(AB_USER_CONSTLIST2 *l); 03935 03936 AB_USER_CONSTLIST2_ITERATOR *AB_User_ConstList2_First(AB_USER_CONSTLIST2 *l); 03937 03938 AB_USER_CONSTLIST2_ITERATOR *AB_User_ConstList2_Last(AB_USER_CONSTLIST2 *l); 03939 03940 AB_USER_CONSTLIST2_ITERATOR *AB_User_ConstList2Iterator_new(AB_USER_CONSTLIST2 *l); 03941 03942 void AB_User_ConstList2Iterator_free(AB_USER_CONSTLIST2_ITERATOR *li); 03943 03944 const AB_USER *AB_User_ConstList2Iterator_Previous(AB_USER_CONSTLIST2_ITERATOR *li); 03945 03946 const AB_USER *AB_User_ConstList2Iterator_Next(AB_USER_CONSTLIST2_ITERATOR *li); 03947 03948 const AB_USER *AB_User_ConstList2Iterator_Data(AB_USER_CONSTLIST2_ITERATOR *li); 03949 03961 const AB_USER *AB_User_ConstList2_ForEach(AB_USER_CONSTLIST2 *list, 03962 AB_USER_CONSTLIST2_FOREACH func, void *user_data); 03963 03964 03965 #ifdef __cplusplus 03966 } 03967 #endif 03968 03969 03970 #endif /* AB_USER_LIST_H */ 03971 03972 03973 03974 /*************************************************************************** 03975 $RCSfile$ 03976 ------------------- 03977 cvs : $Id$ 03978 begin : Sat Jun 28 2003 03979 copyright : (C) 2003 by Martin Preuss 03980 email : martin@libchipcard.de 03981 03982 *************************************************************************** 03983 * * 03984 * This library is free software; you can redistribute it and/or * 03985 * modify it under the terms of the GNU Lesser General Public * 03986 * License as published by the Free Software Foundation; either * 03987 * version 2.1 of the License, or (at your option) any later version. * 03988 * * 03989 * This library is distributed in the hope that it will be useful, * 03990 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 03991 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 03992 * Lesser General Public License for more details. * 03993 * * 03994 * You should have received a copy of the GNU Lesser General Public * 03995 * License along with this library; if not, write to the Free Software * 03996 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 03997 * MA 02111-1307 USA * 03998 * * 03999 ***************************************************************************/ 04000 04001 04002 #ifndef AB_VALUE_LIST1_H 04003 #define AB_VALUE_LIST1_H 04004 04005 #ifdef __cplusplus 04006 extern "C" { 04007 #endif 04008 04010 typedef struct AB_VALUE_LIST_ELEMENT { 04011 uint32_t id; 04012 AB_VALUE *nextObject; 04013 } AB_VALUE_LIST__ELEMENT; 04014 04021 typedef struct AB_VALUE_LIST AB_VALUE_LIST; 04023 struct AB_VALUE_LIST { 04024 AB_VALUE *first; 04025 uint32_t count; 04026 uint32_t id; 04027 } AB_VALUE_LIST; 04028 04033 void AB_Value_List_AddList(AB_VALUE_LIST *dst, AB_VALUE_LIST *l); 04034 04038 void AB_Value_List_Add(AB_VALUE *element, AB_VALUE_LIST *list); 04039 04044 void AB_Value_List_Insert(AB_VALUE *element, AB_VALUE_LIST *list); 04045 04052 void AB_Value_List_Del(AB_VALUE *element); 04053 04057 AB_VALUE* AB_Value_List_First(const AB_VALUE_LIST *l); 04058 04062 AB_VALUE* AB_Value_List_Last(const AB_VALUE_LIST *l); 04063 04068 void AB_Value_List_Clear(AB_VALUE_LIST *l); 04069 04073 AB_VALUE_LIST* AB_Value_List_new(); 04074 04078 void AB_Value_List_free(AB_VALUE_LIST *l); 04079 04083 AB_VALUE* AB_Value_List_Next(const AB_VALUE *element); 04084 04088 AB_VALUE* AB_Value_List_Previous(const AB_VALUE *element); 04089 04093 uint32_t AB_Value_List_GetCount(const AB_VALUE_LIST *l); 04094 04095 #ifdef __cplusplus 04096 } 04097 #endif 04098 04099 04100 #endif 04101 04102 04103 04104 /*************************************************************************** 04105 $RCSfile$ 04106 ------------------- 04107 cvs : $Id$ 04108 begin : Sat Jun 28 2003 04109 copyright : (C) 2003 by Martin Preuss 04110 email : martin@libchipcard.de 04111 04112 *************************************************************************** 04113 * * 04114 * This library is free software; you can redistribute it and/or * 04115 * modify it under the terms of the GNU Lesser General Public * 04116 * License as published by the Free Software Foundation; either * 04117 * version 2.1 of the License, or (at your option) any later version. * 04118 * * 04119 * This library is distributed in the hope that it will be useful, * 04120 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 04121 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 04122 * Lesser General Public License for more details. * 04123 * * 04124 * You should have received a copy of the GNU Lesser General Public * 04125 * License along with this library; if not, write to the Free Software * 04126 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 04127 * MA 02111-1307 USA * 04128 * * 04129 ***************************************************************************/ 04130 04131 04132 #ifndef AB_EUTRANSFER_INFO_LIST2_H 04133 #define AB_EUTRANSFER_INFO_LIST2_H 04134 04135 04136 #ifdef __cplusplus 04137 extern "C" { 04138 #endif 04139 04146 typedef struct AB_EUTRANSFER_INFO_LIST2 AB_EUTRANSFER_INFO_LIST2; 04147 04151 typedef struct AB_EUTRANSFER_INFO_LIST2_ITERATOR AB_EUTRANSFER_INFO_LIST2_ITERATOR; 04152 04156 typedef AB_EUTRANSFER_INFO* (AB_EUTRANSFER_INFO_LIST2_FOREACH)(AB_EUTRANSFER_INFO *element, 04157 void *user_data); 04158 04162 AB_EUTRANSFER_INFO_LIST2 *AB_EuTransferInfo_List2_new(); 04163 04167 void AB_EuTransferInfo_List2_free(AB_EUTRANSFER_INFO_LIST2 *l); 04168 04172 void AB_EuTransferInfo_List2_Dump(AB_EUTRANSFER_INFO_LIST2 *l, FILE *f, unsigned int indent); 04173 04177 void AB_EuTransferInfo_List2_PushBack(AB_EUTRANSFER_INFO_LIST2 *l, AB_EUTRANSFER_INFO *p); 04178 04183 void AB_EuTransferInfo_List2_PushFront(AB_EUTRANSFER_INFO_LIST2 *l, AB_EUTRANSFER_INFO *p); 04184 04189 AB_EUTRANSFER_INFO *AB_EuTransferInfo_List2_GetFront(AB_EUTRANSFER_INFO_LIST2 *l); 04190 04195 AB_EUTRANSFER_INFO *AB_EuTransferInfo_List2_GetBack(AB_EUTRANSFER_INFO_LIST2 *l); 04196 04201 void AB_EuTransferInfo_List2_Erase(AB_EUTRANSFER_INFO_LIST2 *l, 04202 AB_EUTRANSFER_INFO_LIST2_ITERATOR *it); 04203 04209 unsigned int AB_EuTransferInfo_List2_GetSize(AB_EUTRANSFER_INFO_LIST2 *l); 04210 04215 void AB_EuTransferInfo_List2_PopBack(AB_EUTRANSFER_INFO_LIST2 *l); 04216 04221 void AB_EuTransferInfo_List2_PopFront(AB_EUTRANSFER_INFO_LIST2 *l); 04222 04226 void AB_EuTransferInfo_List2_Clear(AB_EUTRANSFER_INFO_LIST2 *l); 04227 04231 AB_EUTRANSFER_INFO_LIST2_ITERATOR *AB_EuTransferInfo_List2_First(AB_EUTRANSFER_INFO_LIST2 *l); 04232 04236 AB_EUTRANSFER_INFO_LIST2_ITERATOR *AB_EuTransferInfo_List2_Last(AB_EUTRANSFER_INFO_LIST2 *l); 04237 04241 AB_EUTRANSFER_INFO_LIST2_ITERATOR *AB_EuTransferInfo_List2Iterator_new(AB_EUTRANSFER_INFO_LIST2 *l); 04242 04246 void AB_EuTransferInfo_List2Iterator_free(AB_EUTRANSFER_INFO_LIST2_ITERATOR *li); 04247 04252 AB_EUTRANSFER_INFO *AB_EuTransferInfo_List2Iterator_Previous(AB_EUTRANSFER_INFO_LIST2_ITERATOR *li); 04253 04258 AB_EUTRANSFER_INFO *AB_EuTransferInfo_List2Iterator_Next(AB_EUTRANSFER_INFO_LIST2_ITERATOR *li); 04259 04264 AB_EUTRANSFER_INFO *AB_EuTransferInfo_List2Iterator_Data(AB_EUTRANSFER_INFO_LIST2_ITERATOR *li); 04265 04277 AB_EUTRANSFER_INFO *AB_EuTransferInfo_List2_ForEach(AB_EUTRANSFER_INFO_LIST2 *list, 04278 AB_EUTRANSFER_INFO_LIST2_FOREACH func, 04279 void *user_data); 04280 04281 04282 typedef struct AB_EUTRANSFER_INFO_CONSTLIST2 AB_EUTRANSFER_INFO_CONSTLIST2; 04283 typedef struct AB_EUTRANSFER_INFO_CONSTLIST2_ITERATOR AB_EUTRANSFER_INFO_CONSTLIST2_ITERATOR; 04284 typedef const AB_EUTRANSFER_INFO* 04285 (AB_EUTRANSFER_INFO_CONSTLIST2_FOREACH)(const AB_EUTRANSFER_INFO *element, 04286 void *user_data); 04287 04288 04289 AB_EUTRANSFER_INFO_CONSTLIST2 *AB_EuTransferInfo_ConstList2_new(); 04290 04291 void AB_EuTransferInfo_ConstList2_free(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 04292 04293 void AB_EuTransferInfo_ConstList2_PushBack(AB_EUTRANSFER_INFO_CONSTLIST2 *l, const AB_EUTRANSFER_INFO *p); 04294 04295 void AB_EuTransferInfo_ConstList2_PushFront(AB_EUTRANSFER_INFO_CONSTLIST2 *l, const AB_EUTRANSFER_INFO *p); 04296 04297 const AB_EUTRANSFER_INFO *AB_EuTransferInfo_ConstList2_GetFront(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 04298 04299 const AB_EUTRANSFER_INFO *AB_EuTransferInfo_ConstList2_GetBack(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 04300 04301 unsigned int AB_EuTransferInfo_ConstList2_GetSize(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 04302 04303 void AB_EuTransferInfo_ConstList2_PopBack(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 04304 04305 void AB_EuTransferInfo_ConstList2_PopFront(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 04306 04307 void AB_EuTransferInfo_ConstList2_Clear(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 04308 04309 AB_EUTRANSFER_INFO_CONSTLIST2_ITERATOR *AB_EuTransferInfo_ConstList2_First(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 04310 04311 AB_EUTRANSFER_INFO_CONSTLIST2_ITERATOR *AB_EuTransferInfo_ConstList2_Last(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 04312 04313 AB_EUTRANSFER_INFO_CONSTLIST2_ITERATOR *AB_EuTransferInfo_ConstList2Iterator_new(AB_EUTRANSFER_INFO_CONSTLIST2 *l); 04314 04315 void AB_EuTransferInfo_ConstList2Iterator_free(AB_EUTRANSFER_INFO_CONSTLIST2_ITERATOR *li); 04316 04317 const AB_EUTRANSFER_INFO *AB_EuTransferInfo_ConstList2Iterator_Previous(AB_EUTRANSFER_INFO_CONSTLIST2_ITERATOR *li); 04318 04319 const AB_EUTRANSFER_INFO *AB_EuTransferInfo_ConstList2Iterator_Next(AB_EUTRANSFER_INFO_CONSTLIST2_ITERATOR *li); 04320 04321 const AB_EUTRANSFER_INFO *AB_EuTransferInfo_ConstList2Iterator_Data(AB_EUTRANSFER_INFO_CONSTLIST2_ITERATOR *li); 04322 04334 const AB_EUTRANSFER_INFO *AB_EuTransferInfo_ConstList2_ForEach(AB_EUTRANSFER_INFO_CONSTLIST2 *list, 04335 AB_EUTRANSFER_INFO_CONSTLIST2_FOREACH func, void *user_data); 04336 04337 04338 #ifdef __cplusplus 04339 } 04340 #endif 04341 04342 04343 #endif /* AB_EUTRANSFER_INFO_LIST_H */ 04344 04345 04346 04347 /*************************************************************************** 04348 $RCSfile$ 04349 ------------------- 04350 cvs : $Id$ 04351 begin : Sat Jun 28 2003 04352 copyright : (C) 2003 by Martin Preuss 04353 email : martin@libchipcard.de 04354 04355 *************************************************************************** 04356 * * 04357 * This library is free software; you can redistribute it and/or * 04358 * modify it under the terms of the GNU Lesser General Public * 04359 * License as published by the Free Software Foundation; either * 04360 * version 2.1 of the License, or (at your option) any later version. * 04361 * * 04362 * This library is distributed in the hope that it will be useful, * 04363 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 04364 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 04365 * Lesser General Public License for more details. * 04366 * * 04367 * You should have received a copy of the GNU Lesser General Public * 04368 * License along with this library; if not, write to the Free Software * 04369 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 04370 * MA 02111-1307 USA * 04371 * * 04372 ***************************************************************************/ 04373 04374 04375 #ifndef AB_EUTRANSFER_INFO_LIST1_H 04376 #define AB_EUTRANSFER_INFO_LIST1_H 04377 04378 #ifdef __cplusplus 04379 extern "C" { 04380 #endif 04381 04383 typedef struct AB_EUTRANSFER_INFO_LIST_ELEMENT { 04384 uint32_t id; 04385 AB_EUTRANSFER_INFO *nextObject; 04386 } AB_EUTRANSFER_INFO_LIST__ELEMENT; 04387 04394 typedef struct AB_EUTRANSFER_INFO_LIST AB_EUTRANSFER_INFO_LIST; 04396 struct AB_EUTRANSFER_INFO_LIST { 04397 AB_EUTRANSFER_INFO *first; 04398 uint32_t count; 04399 uint32_t id; 04400 } AB_EUTRANSFER_INFO_LIST; 04401 04406 void AB_EuTransferInfo_List_AddList(AB_EUTRANSFER_INFO_LIST *dst, AB_EUTRANSFER_INFO_LIST *l); 04407 04411 void AB_EuTransferInfo_List_Add(AB_EUTRANSFER_INFO *element, AB_EUTRANSFER_INFO_LIST *list); 04412 04417 void AB_EuTransferInfo_List_Insert(AB_EUTRANSFER_INFO *element, AB_EUTRANSFER_INFO_LIST *list); 04418 04425 void AB_EuTransferInfo_List_Del(AB_EUTRANSFER_INFO *element); 04426 04430 AB_EUTRANSFER_INFO* AB_EuTransferInfo_List_First(const AB_EUTRANSFER_INFO_LIST *l); 04431 04435 AB_EUTRANSFER_INFO* AB_EuTransferInfo_List_Last(const AB_EUTRANSFER_INFO_LIST *l); 04436 04441 void AB_EuTransferInfo_List_Clear(AB_EUTRANSFER_INFO_LIST *l); 04442 04446 AB_EUTRANSFER_INFO_LIST* AB_EuTransferInfo_List_new(); 04447 04451 void AB_EuTransferInfo_List_free(AB_EUTRANSFER_INFO_LIST *l); 04452 04456 AB_EUTRANSFER_INFO* AB_EuTransferInfo_List_Next(const AB_EUTRANSFER_INFO *element); 04457 04461 AB_EUTRANSFER_INFO* AB_EuTransferInfo_List_Previous(const AB_EUTRANSFER_INFO *element); 04462 04466 uint32_t AB_EuTransferInfo_List_GetCount(const AB_EUTRANSFER_INFO_LIST *l); 04467 04468 #ifdef __cplusplus 04469 } 04470 #endif 04471 04472 04473 #endif 04474 04475 04476 04477 /*************************************************************************** 04478 $RCSfile$ 04479 ------------------- 04480 cvs : $Id$ 04481 begin : Sat Jun 28 2003 04482 copyright : (C) 2003 by Martin Preuss 04483 email : martin@libchipcard.de 04484 04485 *************************************************************************** 04486 * * 04487 * This library is free software; you can redistribute it and/or * 04488 * modify it under the terms of the GNU Lesser General Public * 04489 * License as published by the Free Software Foundation; either * 04490 * version 2.1 of the License, or (at your option) any later version. * 04491 * * 04492 * This library is distributed in the hope that it will be useful, * 04493 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 04494 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 04495 * Lesser General Public License for more details. * 04496 * * 04497 * You should have received a copy of the GNU Lesser General Public * 04498 * License along with this library; if not, write to the Free Software * 04499 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 04500 * MA 02111-1307 USA * 04501 * * 04502 ***************************************************************************/ 04503 04504 04505 #ifndef AB_SECURITY_LIST2_H 04506 #define AB_SECURITY_LIST2_H 04507 04508 04509 #ifdef __cplusplus 04510 extern "C" { 04511 #endif 04512 04519 typedef struct AB_SECURITY_LIST2 AB_SECURITY_LIST2; 04520 04524 typedef struct AB_SECURITY_LIST2_ITERATOR AB_SECURITY_LIST2_ITERATOR; 04525 04529 typedef AB_SECURITY* (AB_SECURITY_LIST2_FOREACH)(AB_SECURITY *element, 04530 void *user_data); 04531 04535 AB_SECURITY_LIST2 *AB_Security_List2_new(); 04536 04540 void AB_Security_List2_free(AB_SECURITY_LIST2 *l); 04541 04545 void AB_Security_List2_Dump(AB_SECURITY_LIST2 *l, FILE *f, unsigned int indent); 04546 04550 void AB_Security_List2_PushBack(AB_SECURITY_LIST2 *l, AB_SECURITY *p); 04551 04556 void AB_Security_List2_PushFront(AB_SECURITY_LIST2 *l, AB_SECURITY *p); 04557 04562 AB_SECURITY *AB_Security_List2_GetFront(AB_SECURITY_LIST2 *l); 04563 04568 AB_SECURITY *AB_Security_List2_GetBack(AB_SECURITY_LIST2 *l); 04569 04574 void AB_Security_List2_Erase(AB_SECURITY_LIST2 *l, 04575 AB_SECURITY_LIST2_ITERATOR *it); 04576 04582 unsigned int AB_Security_List2_GetSize(AB_SECURITY_LIST2 *l); 04583 04588 void AB_Security_List2_PopBack(AB_SECURITY_LIST2 *l); 04589 04594 void AB_Security_List2_PopFront(AB_SECURITY_LIST2 *l); 04595 04599 void AB_Security_List2_Clear(AB_SECURITY_LIST2 *l); 04600 04604 AB_SECURITY_LIST2_ITERATOR *AB_Security_List2_First(AB_SECURITY_LIST2 *l); 04605 04609 AB_SECURITY_LIST2_ITERATOR *AB_Security_List2_Last(AB_SECURITY_LIST2 *l); 04610 04614 AB_SECURITY_LIST2_ITERATOR *AB_Security_List2Iterator_new(AB_SECURITY_LIST2 *l); 04615 04619 void AB_Security_List2Iterator_free(AB_SECURITY_LIST2_ITERATOR *li); 04620 04625 AB_SECURITY *AB_Security_List2Iterator_Previous(AB_SECURITY_LIST2_ITERATOR *li); 04626 04631 AB_SECURITY *AB_Security_List2Iterator_Next(AB_SECURITY_LIST2_ITERATOR *li); 04632 04637 AB_SECURITY *AB_Security_List2Iterator_Data(AB_SECURITY_LIST2_ITERATOR *li); 04638 04650 AB_SECURITY *AB_Security_List2_ForEach(AB_SECURITY_LIST2 *list, 04651 AB_SECURITY_LIST2_FOREACH func, 04652 void *user_data); 04653 04654 04655 typedef struct AB_SECURITY_CONSTLIST2 AB_SECURITY_CONSTLIST2; 04656 typedef struct AB_SECURITY_CONSTLIST2_ITERATOR AB_SECURITY_CONSTLIST2_ITERATOR; 04657 typedef const AB_SECURITY* 04658 (AB_SECURITY_CONSTLIST2_FOREACH)(const AB_SECURITY *element, 04659 void *user_data); 04660 04661 04662 AB_SECURITY_CONSTLIST2 *AB_Security_ConstList2_new(); 04663 04664 void AB_Security_ConstList2_free(AB_SECURITY_CONSTLIST2 *l); 04665 04666 void AB_Security_ConstList2_PushBack(AB_SECURITY_CONSTLIST2 *l, const AB_SECURITY *p); 04667 04668 void AB_Security_ConstList2_PushFront(AB_SECURITY_CONSTLIST2 *l, const AB_SECURITY *p); 04669 04670 const AB_SECURITY *AB_Security_ConstList2_GetFront(AB_SECURITY_CONSTLIST2 *l); 04671 04672 const AB_SECURITY *AB_Security_ConstList2_GetBack(AB_SECURITY_CONSTLIST2 *l); 04673 04674 unsigned int AB_Security_ConstList2_GetSize(AB_SECURITY_CONSTLIST2 *l); 04675 04676 void AB_Security_ConstList2_PopBack(AB_SECURITY_CONSTLIST2 *l); 04677 04678 void AB_Security_ConstList2_PopFront(AB_SECURITY_CONSTLIST2 *l); 04679 04680 void AB_Security_ConstList2_Clear(AB_SECURITY_CONSTLIST2 *l); 04681 04682 AB_SECURITY_CONSTLIST2_ITERATOR *AB_Security_ConstList2_First(AB_SECURITY_CONSTLIST2 *l); 04683 04684 AB_SECURITY_CONSTLIST2_ITERATOR *AB_Security_ConstList2_Last(AB_SECURITY_CONSTLIST2 *l); 04685 04686 AB_SECURITY_CONSTLIST2_ITERATOR *AB_Security_ConstList2Iterator_new(AB_SECURITY_CONSTLIST2 *l); 04687 04688 void AB_Security_ConstList2Iterator_free(AB_SECURITY_CONSTLIST2_ITERATOR *li); 04689 04690 const AB_SECURITY *AB_Security_ConstList2Iterator_Previous(AB_SECURITY_CONSTLIST2_ITERATOR *li); 04691 04692 const AB_SECURITY *AB_Security_ConstList2Iterator_Next(AB_SECURITY_CONSTLIST2_ITERATOR *li); 04693 04694 const AB_SECURITY *AB_Security_ConstList2Iterator_Data(AB_SECURITY_CONSTLIST2_ITERATOR *li); 04695 04707 const AB_SECURITY *AB_Security_ConstList2_ForEach(AB_SECURITY_CONSTLIST2 *list, 04708 AB_SECURITY_CONSTLIST2_FOREACH func, void *user_data); 04709 04710 04711 #ifdef __cplusplus 04712 } 04713 #endif 04714 04715 04716 #endif /* AB_SECURITY_LIST_H */ 04717 04718 04719 04720 /*************************************************************************** 04721 $RCSfile$ 04722 ------------------- 04723 cvs : $Id$ 04724 begin : Sat Jun 28 2003 04725 copyright : (C) 2003 by Martin Preuss 04726 email : martin@libchipcard.de 04727 04728 *************************************************************************** 04729 * * 04730 * This library is free software; you can redistribute it and/or * 04731 * modify it under the terms of the GNU Lesser General Public * 04732 * License as published by the Free Software Foundation; either * 04733 * version 2.1 of the License, or (at your option) any later version. * 04734 * * 04735 * This library is distributed in the hope that it will be useful, * 04736 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 04737 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 04738 * Lesser General Public License for more details. * 04739 * * 04740 * You should have received a copy of the GNU Lesser General Public * 04741 * License along with this library; if not, write to the Free Software * 04742 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 04743 * MA 02111-1307 USA * 04744 * * 04745 ***************************************************************************/ 04746 04747 04748 #ifndef AB_SECURITY_LIST1_H 04749 #define AB_SECURITY_LIST1_H 04750 04751 #ifdef __cplusplus 04752 extern "C" { 04753 #endif 04754 04756 typedef struct AB_SECURITY_LIST_ELEMENT { 04757 uint32_t id; 04758 AB_SECURITY *nextObject; 04759 } AB_SECURITY_LIST__ELEMENT; 04760 04767 typedef struct AB_SECURITY_LIST AB_SECURITY_LIST; 04769 struct AB_SECURITY_LIST { 04770 AB_SECURITY *first; 04771 uint32_t count; 04772 uint32_t id; 04773 } AB_SECURITY_LIST; 04774 04779 void AB_Security_List_AddList(AB_SECURITY_LIST *dst, AB_SECURITY_LIST *l); 04780 04784 void AB_Security_List_Add(AB_SECURITY *element, AB_SECURITY_LIST *list); 04785 04790 void AB_Security_List_Insert(AB_SECURITY *element, AB_SECURITY_LIST *list); 04791 04798 void AB_Security_List_Del(AB_SECURITY *element); 04799 04803 AB_SECURITY* AB_Security_List_First(const AB_SECURITY_LIST *l); 04804 04808 AB_SECURITY* AB_Security_List_Last(const AB_SECURITY_LIST *l); 04809 04814 void AB_Security_List_Clear(AB_SECURITY_LIST *l); 04815 04819 AB_SECURITY_LIST* AB_Security_List_new(); 04820 04824 void AB_Security_List_free(AB_SECURITY_LIST *l); 04825 04829 AB_SECURITY* AB_Security_List_Next(const AB_SECURITY *element); 04830 04834 AB_SECURITY* AB_Security_List_Previous(const AB_SECURITY *element); 04835 04839 uint32_t AB_Security_List_GetCount(const AB_SECURITY_LIST *l); 04840 04841 #ifdef __cplusplus 04842 } 04843 #endif 04844 04845 04846 #endif 04847 04848 04849 04850 /*************************************************************************** 04851 $RCSfile$ 04852 ------------------- 04853 cvs : $Id$ 04854 begin : Sat Jun 28 2003 04855 copyright : (C) 2003 by Martin Preuss 04856 email : martin@libchipcard.de 04857 04858 *************************************************************************** 04859 * * 04860 * This library is free software; you can redistribute it and/or * 04861 * modify it under the terms of the GNU Lesser General Public * 04862 * License as published by the Free Software Foundation; either * 04863 * version 2.1 of the License, or (at your option) any later version. * 04864 * * 04865 * This library is distributed in the hope that it will be useful, * 04866 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 04867 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 04868 * Lesser General Public License for more details. * 04869 * * 04870 * You should have received a copy of the GNU Lesser General Public * 04871 * License along with this library; if not, write to the Free Software * 04872 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 04873 * MA 02111-1307 USA * 04874 * * 04875 ***************************************************************************/ 04876 04877 04878 #ifndef AB_ACCOUNT_STATUS_LIST2_H 04879 #define AB_ACCOUNT_STATUS_LIST2_H 04880 04881 04882 #ifdef __cplusplus 04883 extern "C" { 04884 #endif 04885 04892 typedef struct AB_ACCOUNT_STATUS_LIST2 AB_ACCOUNT_STATUS_LIST2; 04893 04897 typedef struct AB_ACCOUNT_STATUS_LIST2_ITERATOR AB_ACCOUNT_STATUS_LIST2_ITERATOR; 04898 04902 typedef AB_ACCOUNT_STATUS* (AB_ACCOUNT_STATUS_LIST2_FOREACH)(AB_ACCOUNT_STATUS *element, 04903 void *user_data); 04904 04908 AB_ACCOUNT_STATUS_LIST2 *AB_AccountStatus_List2_new(); 04909 04913 void AB_AccountStatus_List2_free(AB_ACCOUNT_STATUS_LIST2 *l); 04914 04918 void AB_AccountStatus_List2_Dump(AB_ACCOUNT_STATUS_LIST2 *l, FILE *f, unsigned int indent); 04919 04923 void AB_AccountStatus_List2_PushBack(AB_ACCOUNT_STATUS_LIST2 *l, AB_ACCOUNT_STATUS *p); 04924 04929 void AB_AccountStatus_List2_PushFront(AB_ACCOUNT_STATUS_LIST2 *l, AB_ACCOUNT_STATUS *p); 04930 04935 AB_ACCOUNT_STATUS *AB_AccountStatus_List2_GetFront(AB_ACCOUNT_STATUS_LIST2 *l); 04936 04941 AB_ACCOUNT_STATUS *AB_AccountStatus_List2_GetBack(AB_ACCOUNT_STATUS_LIST2 *l); 04942 04947 void AB_AccountStatus_List2_Erase(AB_ACCOUNT_STATUS_LIST2 *l, 04948 AB_ACCOUNT_STATUS_LIST2_ITERATOR *it); 04949 04955 unsigned int AB_AccountStatus_List2_GetSize(AB_ACCOUNT_STATUS_LIST2 *l); 04956 04961 void AB_AccountStatus_List2_PopBack(AB_ACCOUNT_STATUS_LIST2 *l); 04962 04967 void AB_AccountStatus_List2_PopFront(AB_ACCOUNT_STATUS_LIST2 *l); 04968 04972 void AB_AccountStatus_List2_Clear(AB_ACCOUNT_STATUS_LIST2 *l); 04973 04977 AB_ACCOUNT_STATUS_LIST2_ITERATOR *AB_AccountStatus_List2_First(AB_ACCOUNT_STATUS_LIST2 *l); 04978 04982 AB_ACCOUNT_STATUS_LIST2_ITERATOR *AB_AccountStatus_List2_Last(AB_ACCOUNT_STATUS_LIST2 *l); 04983 04987 AB_ACCOUNT_STATUS_LIST2_ITERATOR *AB_AccountStatus_List2Iterator_new(AB_ACCOUNT_STATUS_LIST2 *l); 04988 04992 void AB_AccountStatus_List2Iterator_free(AB_ACCOUNT_STATUS_LIST2_ITERATOR *li); 04993 04998 AB_ACCOUNT_STATUS *AB_AccountStatus_List2Iterator_Previous(AB_ACCOUNT_STATUS_LIST2_ITERATOR *li); 04999 05004 AB_ACCOUNT_STATUS *AB_AccountStatus_List2Iterator_Next(AB_ACCOUNT_STATUS_LIST2_ITERATOR *li); 05005 05010 AB_ACCOUNT_STATUS *AB_AccountStatus_List2Iterator_Data(AB_ACCOUNT_STATUS_LIST2_ITERATOR *li); 05011 05023 AB_ACCOUNT_STATUS *AB_AccountStatus_List2_ForEach(AB_ACCOUNT_STATUS_LIST2 *list, 05024 AB_ACCOUNT_STATUS_LIST2_FOREACH func, 05025 void *user_data); 05026 05027 05028 typedef struct AB_ACCOUNT_STATUS_CONSTLIST2 AB_ACCOUNT_STATUS_CONSTLIST2; 05029 typedef struct AB_ACCOUNT_STATUS_CONSTLIST2_ITERATOR AB_ACCOUNT_STATUS_CONSTLIST2_ITERATOR; 05030 typedef const AB_ACCOUNT_STATUS* 05031 (AB_ACCOUNT_STATUS_CONSTLIST2_FOREACH)(const AB_ACCOUNT_STATUS *element, 05032 void *user_data); 05033 05034 05035 AB_ACCOUNT_STATUS_CONSTLIST2 *AB_AccountStatus_ConstList2_new(); 05036 05037 void AB_AccountStatus_ConstList2_free(AB_ACCOUNT_STATUS_CONSTLIST2 *l); 05038 05039 void AB_AccountStatus_ConstList2_PushBack(AB_ACCOUNT_STATUS_CONSTLIST2 *l, const AB_ACCOUNT_STATUS *p); 05040 05041 void AB_AccountStatus_ConstList2_PushFront(AB_ACCOUNT_STATUS_CONSTLIST2 *l, const AB_ACCOUNT_STATUS *p); 05042 05043 const AB_ACCOUNT_STATUS *AB_AccountStatus_ConstList2_GetFront(AB_ACCOUNT_STATUS_CONSTLIST2 *l); 05044 05045 const AB_ACCOUNT_STATUS *AB_AccountStatus_ConstList2_GetBack(AB_ACCOUNT_STATUS_CONSTLIST2 *l); 05046 05047 unsigned int AB_AccountStatus_ConstList2_GetSize(AB_ACCOUNT_STATUS_CONSTLIST2 *l); 05048 05049 void AB_AccountStatus_ConstList2_PopBack(AB_ACCOUNT_STATUS_CONSTLIST2 *l); 05050 05051 void AB_AccountStatus_ConstList2_PopFront(AB_ACCOUNT_STATUS_CONSTLIST2 *l); 05052 05053 void AB_AccountStatus_ConstList2_Clear(AB_ACCOUNT_STATUS_CONSTLIST2 *l); 05054 05055 AB_ACCOUNT_STATUS_CONSTLIST2_ITERATOR *AB_AccountStatus_ConstList2_First(AB_ACCOUNT_STATUS_CONSTLIST2 *l); 05056 05057 AB_ACCOUNT_STATUS_CONSTLIST2_ITERATOR *AB_AccountStatus_ConstList2_Last(AB_ACCOUNT_STATUS_CONSTLIST2 *l); 05058 05059 AB_ACCOUNT_STATUS_CONSTLIST2_ITERATOR *AB_AccountStatus_ConstList2Iterator_new(AB_ACCOUNT_STATUS_CONSTLIST2 *l); 05060 05061 void AB_AccountStatus_ConstList2Iterator_free(AB_ACCOUNT_STATUS_CONSTLIST2_ITERATOR *li); 05062 05063 const AB_ACCOUNT_STATUS *AB_AccountStatus_ConstList2Iterator_Previous(AB_ACCOUNT_STATUS_CONSTLIST2_ITERATOR *li); 05064 05065 const AB_ACCOUNT_STATUS *AB_AccountStatus_ConstList2Iterator_Next(AB_ACCOUNT_STATUS_CONSTLIST2_ITERATOR *li); 05066 05067 const AB_ACCOUNT_STATUS *AB_AccountStatus_ConstList2Iterator_Data(AB_ACCOUNT_STATUS_CONSTLIST2_ITERATOR *li); 05068 05080 const AB_ACCOUNT_STATUS *AB_AccountStatus_ConstList2_ForEach(AB_ACCOUNT_STATUS_CONSTLIST2 *list, 05081 AB_ACCOUNT_STATUS_CONSTLIST2_FOREACH func, void *user_data); 05082 05083 05084 #ifdef __cplusplus 05085 } 05086 #endif 05087 05088 05089 #endif /* AB_ACCOUNT_STATUS_LIST_H */ 05090 05091 05092 05093 /*************************************************************************** 05094 $RCSfile$ 05095 ------------------- 05096 cvs : $Id$ 05097 begin : Sat Jun 28 2003 05098 copyright : (C) 2003 by Martin Preuss 05099 email : martin@libchipcard.de 05100 05101 *************************************************************************** 05102 * * 05103 * This library is free software; you can redistribute it and/or * 05104 * modify it under the terms of the GNU Lesser General Public * 05105 * License as published by the Free Software Foundation; either * 05106 * version 2.1 of the License, or (at your option) any later version. * 05107 * * 05108 * This library is distributed in the hope that it will be useful, * 05109 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 05110 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 05111 * Lesser General Public License for more details. * 05112 * * 05113 * You should have received a copy of the GNU Lesser General Public * 05114 * License along with this library; if not, write to the Free Software * 05115 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 05116 * MA 02111-1307 USA * 05117 * * 05118 ***************************************************************************/ 05119 05120 05121 #ifndef AB_BANKINFO_SERVICE_LIST2_H 05122 #define AB_BANKINFO_SERVICE_LIST2_H 05123 05124 05125 #ifdef __cplusplus 05126 extern "C" { 05127 #endif 05128 05135 typedef struct AB_BANKINFO_SERVICE_LIST2 AB_BANKINFO_SERVICE_LIST2; 05136 05140 typedef struct AB_BANKINFO_SERVICE_LIST2_ITERATOR AB_BANKINFO_SERVICE_LIST2_ITERATOR; 05141 05145 typedef AB_BANKINFO_SERVICE* (AB_BANKINFO_SERVICE_LIST2_FOREACH)(AB_BANKINFO_SERVICE *element, 05146 void *user_data); 05147 05151 AB_BANKINFO_SERVICE_LIST2 *AB_BankInfoService_List2_new(); 05152 05156 void AB_BankInfoService_List2_free(AB_BANKINFO_SERVICE_LIST2 *l); 05157 05161 void AB_BankInfoService_List2_Dump(AB_BANKINFO_SERVICE_LIST2 *l, FILE *f, unsigned int indent); 05162 05166 void AB_BankInfoService_List2_PushBack(AB_BANKINFO_SERVICE_LIST2 *l, AB_BANKINFO_SERVICE *p); 05167 05172 void AB_BankInfoService_List2_PushFront(AB_BANKINFO_SERVICE_LIST2 *l, AB_BANKINFO_SERVICE *p); 05173 05178 AB_BANKINFO_SERVICE *AB_BankInfoService_List2_GetFront(AB_BANKINFO_SERVICE_LIST2 *l); 05179 05184 AB_BANKINFO_SERVICE *AB_BankInfoService_List2_GetBack(AB_BANKINFO_SERVICE_LIST2 *l); 05185 05190 void AB_BankInfoService_List2_Erase(AB_BANKINFO_SERVICE_LIST2 *l, 05191 AB_BANKINFO_SERVICE_LIST2_ITERATOR *it); 05192 05198 unsigned int AB_BankInfoService_List2_GetSize(AB_BANKINFO_SERVICE_LIST2 *l); 05199 05204 void AB_BankInfoService_List2_PopBack(AB_BANKINFO_SERVICE_LIST2 *l); 05205 05210 void AB_BankInfoService_List2_PopFront(AB_BANKINFO_SERVICE_LIST2 *l); 05211 05215 void AB_BankInfoService_List2_Clear(AB_BANKINFO_SERVICE_LIST2 *l); 05216 05220 AB_BANKINFO_SERVICE_LIST2_ITERATOR *AB_BankInfoService_List2_First(AB_BANKINFO_SERVICE_LIST2 *l); 05221 05225 AB_BANKINFO_SERVICE_LIST2_ITERATOR *AB_BankInfoService_List2_Last(AB_BANKINFO_SERVICE_LIST2 *l); 05226 05230 AB_BANKINFO_SERVICE_LIST2_ITERATOR *AB_BankInfoService_List2Iterator_new(AB_BANKINFO_SERVICE_LIST2 *l); 05231 05235 void AB_BankInfoService_List2Iterator_free(AB_BANKINFO_SERVICE_LIST2_ITERATOR *li); 05236 05241 AB_BANKINFO_SERVICE *AB_BankInfoService_List2Iterator_Previous(AB_BANKINFO_SERVICE_LIST2_ITERATOR *li); 05242 05247 AB_BANKINFO_SERVICE *AB_BankInfoService_List2Iterator_Next(AB_BANKINFO_SERVICE_LIST2_ITERATOR *li); 05248 05253 AB_BANKINFO_SERVICE *AB_BankInfoService_List2Iterator_Data(AB_BANKINFO_SERVICE_LIST2_ITERATOR *li); 05254 05266 AB_BANKINFO_SERVICE *AB_BankInfoService_List2_ForEach(AB_BANKINFO_SERVICE_LIST2 *list, 05267 AB_BANKINFO_SERVICE_LIST2_FOREACH func, 05268 void *user_data); 05269 05270 05271 typedef struct AB_BANKINFO_SERVICE_CONSTLIST2 AB_BANKINFO_SERVICE_CONSTLIST2; 05272 typedef struct AB_BANKINFO_SERVICE_CONSTLIST2_ITERATOR AB_BANKINFO_SERVICE_CONSTLIST2_ITERATOR; 05273 typedef const AB_BANKINFO_SERVICE* 05274 (AB_BANKINFO_SERVICE_CONSTLIST2_FOREACH)(const AB_BANKINFO_SERVICE *element, 05275 void *user_data); 05276 05277 05278 AB_BANKINFO_SERVICE_CONSTLIST2 *AB_BankInfoService_ConstList2_new(); 05279 05280 void AB_BankInfoService_ConstList2_free(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 05281 05282 void AB_BankInfoService_ConstList2_PushBack(AB_BANKINFO_SERVICE_CONSTLIST2 *l, const AB_BANKINFO_SERVICE *p); 05283 05284 void AB_BankInfoService_ConstList2_PushFront(AB_BANKINFO_SERVICE_CONSTLIST2 *l, const AB_BANKINFO_SERVICE *p); 05285 05286 const AB_BANKINFO_SERVICE *AB_BankInfoService_ConstList2_GetFront(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 05287 05288 const AB_BANKINFO_SERVICE *AB_BankInfoService_ConstList2_GetBack(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 05289 05290 unsigned int AB_BankInfoService_ConstList2_GetSize(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 05291 05292 void AB_BankInfoService_ConstList2_PopBack(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 05293 05294 void AB_BankInfoService_ConstList2_PopFront(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 05295 05296 void AB_BankInfoService_ConstList2_Clear(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 05297 05298 AB_BANKINFO_SERVICE_CONSTLIST2_ITERATOR *AB_BankInfoService_ConstList2_First(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 05299 05300 AB_BANKINFO_SERVICE_CONSTLIST2_ITERATOR *AB_BankInfoService_ConstList2_Last(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 05301 05302 AB_BANKINFO_SERVICE_CONSTLIST2_ITERATOR *AB_BankInfoService_ConstList2Iterator_new(AB_BANKINFO_SERVICE_CONSTLIST2 *l); 05303 05304 void AB_BankInfoService_ConstList2Iterator_free(AB_BANKINFO_SERVICE_CONSTLIST2_ITERATOR *li); 05305 05306 const AB_BANKINFO_SERVICE *AB_BankInfoService_ConstList2Iterator_Previous(AB_BANKINFO_SERVICE_CONSTLIST2_ITERATOR *li); 05307 05308 const AB_BANKINFO_SERVICE *AB_BankInfoService_ConstList2Iterator_Next(AB_BANKINFO_SERVICE_CONSTLIST2_ITERATOR *li); 05309 05310 const AB_BANKINFO_SERVICE *AB_BankInfoService_ConstList2Iterator_Data(AB_BANKINFO_SERVICE_CONSTLIST2_ITERATOR *li); 05311 05323 const AB_BANKINFO_SERVICE *AB_BankInfoService_ConstList2_ForEach(AB_BANKINFO_SERVICE_CONSTLIST2 *list, 05324 AB_BANKINFO_SERVICE_CONSTLIST2_FOREACH func, void *user_data); 05325 05326 05327 #ifdef __cplusplus 05328 } 05329 #endif 05330 05331 05332 #endif /* AB_BANKINFO_SERVICE_LIST_H */ 05333 05334 05335 05336 /*************************************************************************** 05337 $RCSfile$ 05338 ------------------- 05339 cvs : $Id$ 05340 begin : Sat Jun 28 2003 05341 copyright : (C) 2003 by Martin Preuss 05342 email : martin@libchipcard.de 05343 05344 *************************************************************************** 05345 * * 05346 * This library is free software; you can redistribute it and/or * 05347 * modify it under the terms of the GNU Lesser General Public * 05348 * License as published by the Free Software Foundation; either * 05349 * version 2.1 of the License, or (at your option) any later version. * 05350 * * 05351 * This library is distributed in the hope that it will be useful, * 05352 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 05353 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 05354 * Lesser General Public License for more details. * 05355 * * 05356 * You should have received a copy of the GNU Lesser General Public * 05357 * License along with this library; if not, write to the Free Software * 05358 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 05359 * MA 02111-1307 USA * 05360 * * 05361 ***************************************************************************/ 05362 05363 05364 #ifndef AB_BANKINFO_SERVICE_LIST1_H 05365 #define AB_BANKINFO_SERVICE_LIST1_H 05366 05367 #ifdef __cplusplus 05368 extern "C" { 05369 #endif 05370 05372 typedef struct AB_BANKINFO_SERVICE_LIST_ELEMENT { 05373 uint32_t id; 05374 AB_BANKINFO_SERVICE *nextObject; 05375 } AB_BANKINFO_SERVICE_LIST__ELEMENT; 05376 05383 typedef struct AB_BANKINFO_SERVICE_LIST AB_BANKINFO_SERVICE_LIST; 05385 struct AB_BANKINFO_SERVICE_LIST { 05386 AB_BANKINFO_SERVICE *first; 05387 uint32_t count; 05388 uint32_t id; 05389 } AB_BANKINFO_SERVICE_LIST; 05390 05395 void AB_BankInfoService_List_AddList(AB_BANKINFO_SERVICE_LIST *dst, AB_BANKINFO_SERVICE_LIST *l); 05396 05400 void AB_BankInfoService_List_Add(AB_BANKINFO_SERVICE *element, AB_BANKINFO_SERVICE_LIST *list); 05401 05406 void AB_BankInfoService_List_Insert(AB_BANKINFO_SERVICE *element, AB_BANKINFO_SERVICE_LIST *list); 05407 05414 void AB_BankInfoService_List_Del(AB_BANKINFO_SERVICE *element); 05415 05419 AB_BANKINFO_SERVICE* AB_BankInfoService_List_First(const AB_BANKINFO_SERVICE_LIST *l); 05420 05424 AB_BANKINFO_SERVICE* AB_BankInfoService_List_Last(const AB_BANKINFO_SERVICE_LIST *l); 05425 05430 void AB_BankInfoService_List_Clear(AB_BANKINFO_SERVICE_LIST *l); 05431 05435 AB_BANKINFO_SERVICE_LIST* AB_BankInfoService_List_new(); 05436 05440 void AB_BankInfoService_List_free(AB_BANKINFO_SERVICE_LIST *l); 05441 05445 AB_BANKINFO_SERVICE* AB_BankInfoService_List_Next(const AB_BANKINFO_SERVICE *element); 05446 05450 AB_BANKINFO_SERVICE* AB_BankInfoService_List_Previous(const AB_BANKINFO_SERVICE *element); 05451 05455 uint32_t AB_BankInfoService_List_GetCount(const AB_BANKINFO_SERVICE_LIST *l); 05456 05457 #ifdef __cplusplus 05458 } 05459 #endif 05460 05461 05462 #endif 05463 05464 05465 05466 /*************************************************************************** 05467 $RCSfile$ 05468 ------------------- 05469 cvs : $Id$ 05470 begin : Sat Jun 28 2003 05471 copyright : (C) 2003 by Martin Preuss 05472 email : martin@libchipcard.de 05473 05474 *************************************************************************** 05475 * * 05476 * This library is free software; you can redistribute it and/or * 05477 * modify it under the terms of the GNU Lesser General Public * 05478 * License as published by the Free Software Foundation; either * 05479 * version 2.1 of the License, or (at your option) any later version. * 05480 * * 05481 * This library is distributed in the hope that it will be useful, * 05482 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 05483 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 05484 * Lesser General Public License for more details. * 05485 * * 05486 * You should have received a copy of the GNU Lesser General Public * 05487 * License along with this library; if not, write to the Free Software * 05488 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 05489 * MA 02111-1307 USA * 05490 * * 05491 ***************************************************************************/ 05492 05493 05494 #ifndef AB_JOB_LIST2_H 05495 #define AB_JOB_LIST2_H 05496 05497 05498 #ifdef __cplusplus 05499 extern "C" { 05500 #endif 05501 05508 typedef struct AB_JOB_LIST2 AB_JOB_LIST2; 05509 05513 typedef struct AB_JOB_LIST2_ITERATOR AB_JOB_LIST2_ITERATOR; 05514 05518 typedef AB_JOB* (AB_JOB_LIST2_FOREACH)(AB_JOB *element, 05519 void *user_data); 05520 05524 AB_JOB_LIST2 *AB_Job_List2_new(); 05525 05529 void AB_Job_List2_free(AB_JOB_LIST2 *l); 05530 05534 void AB_Job_List2_Dump(AB_JOB_LIST2 *l, FILE *f, unsigned int indent); 05535 05539 void AB_Job_List2_PushBack(AB_JOB_LIST2 *l, AB_JOB *p); 05540 05545 void AB_Job_List2_PushFront(AB_JOB_LIST2 *l, AB_JOB *p); 05546 05551 AB_JOB *AB_Job_List2_GetFront(AB_JOB_LIST2 *l); 05552 05557 AB_JOB *AB_Job_List2_GetBack(AB_JOB_LIST2 *l); 05558 05563 void AB_Job_List2_Erase(AB_JOB_LIST2 *l, 05564 AB_JOB_LIST2_ITERATOR *it); 05565 05571 unsigned int AB_Job_List2_GetSize(AB_JOB_LIST2 *l); 05572 05577 void AB_Job_List2_PopBack(AB_JOB_LIST2 *l); 05578 05583 void AB_Job_List2_PopFront(AB_JOB_LIST2 *l); 05584 05588 void AB_Job_List2_Clear(AB_JOB_LIST2 *l); 05589 05593 AB_JOB_LIST2_ITERATOR *AB_Job_List2_First(AB_JOB_LIST2 *l); 05594 05598 AB_JOB_LIST2_ITERATOR *AB_Job_List2_Last(AB_JOB_LIST2 *l); 05599 05603 AB_JOB_LIST2_ITERATOR *AB_Job_List2Iterator_new(AB_JOB_LIST2 *l); 05604 05608 void AB_Job_List2Iterator_free(AB_JOB_LIST2_ITERATOR *li); 05609 05614 AB_JOB *AB_Job_List2Iterator_Previous(AB_JOB_LIST2_ITERATOR *li); 05615 05620 AB_JOB *AB_Job_List2Iterator_Next(AB_JOB_LIST2_ITERATOR *li); 05621 05626 AB_JOB *AB_Job_List2Iterator_Data(AB_JOB_LIST2_ITERATOR *li); 05627 05639 AB_JOB *AB_Job_List2_ForEach(AB_JOB_LIST2 *list, 05640 AB_JOB_LIST2_FOREACH func, 05641 void *user_data); 05642 05643 05644 typedef struct AB_JOB_CONSTLIST2 AB_JOB_CONSTLIST2; 05645 typedef struct AB_JOB_CONSTLIST2_ITERATOR AB_JOB_CONSTLIST2_ITERATOR; 05646 typedef const AB_JOB* 05647 (AB_JOB_CONSTLIST2_FOREACH)(const AB_JOB *element, 05648 void *user_data); 05649 05650 05651 AB_JOB_CONSTLIST2 *AB_Job_ConstList2_new(); 05652 05653 void AB_Job_ConstList2_free(AB_JOB_CONSTLIST2 *l); 05654 05655 void AB_Job_ConstList2_PushBack(AB_JOB_CONSTLIST2 *l, const AB_JOB *p); 05656 05657 void AB_Job_ConstList2_PushFront(AB_JOB_CONSTLIST2 *l, const AB_JOB *p); 05658 05659 const AB_JOB *AB_Job_ConstList2_GetFront(AB_JOB_CONSTLIST2 *l); 05660 05661 const AB_JOB *AB_Job_ConstList2_GetBack(AB_JOB_CONSTLIST2 *l); 05662 05663 unsigned int AB_Job_ConstList2_GetSize(AB_JOB_CONSTLIST2 *l); 05664 05665 void AB_Job_ConstList2_PopBack(AB_JOB_CONSTLIST2 *l); 05666 05667 void AB_Job_ConstList2_PopFront(AB_JOB_CONSTLIST2 *l); 05668 05669 void AB_Job_ConstList2_Clear(AB_JOB_CONSTLIST2 *l); 05670 05671 AB_JOB_CONSTLIST2_ITERATOR *AB_Job_ConstList2_First(AB_JOB_CONSTLIST2 *l); 05672 05673 AB_JOB_CONSTLIST2_ITERATOR *AB_Job_ConstList2_Last(AB_JOB_CONSTLIST2 *l); 05674 05675 AB_JOB_CONSTLIST2_ITERATOR *AB_Job_ConstList2Iterator_new(AB_JOB_CONSTLIST2 *l); 05676 05677 void AB_Job_ConstList2Iterator_free(AB_JOB_CONSTLIST2_ITERATOR *li); 05678 05679 const AB_JOB *AB_Job_ConstList2Iterator_Previous(AB_JOB_CONSTLIST2_ITERATOR *li); 05680 05681 const AB_JOB *AB_Job_ConstList2Iterator_Next(AB_JOB_CONSTLIST2_ITERATOR *li); 05682 05683 const AB_JOB *AB_Job_ConstList2Iterator_Data(AB_JOB_CONSTLIST2_ITERATOR *li); 05684 05696 const AB_JOB *AB_Job_ConstList2_ForEach(AB_JOB_CONSTLIST2 *list, 05697 AB_JOB_CONSTLIST2_FOREACH func, void *user_data); 05698 05699 05700 #ifdef __cplusplus 05701 } 05702 #endif 05703 05704 05705 #endif /* AB_JOB_LIST_H */ 05706 05707 05708 05709 /*************************************************************************** 05710 $RCSfile$ 05711 ------------------- 05712 cvs : $Id$ 05713 begin : Sat Jun 28 2003 05714 copyright : (C) 2003 by Martin Preuss 05715 email : martin@libchipcard.de 05716 05717 *************************************************************************** 05718 * * 05719 * This library is free software; you can redistribute it and/or * 05720 * modify it under the terms of the GNU Lesser General Public * 05721 * License as published by the Free Software Foundation; either * 05722 * version 2.1 of the License, or (at your option) any later version. * 05723 * * 05724 * This library is distributed in the hope that it will be useful, * 05725 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 05726 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 05727 * Lesser General Public License for more details. * 05728 * * 05729 * You should have received a copy of the GNU Lesser General Public * 05730 * License along with this library; if not, write to the Free Software * 05731 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 05732 * MA 02111-1307 USA * 05733 * * 05734 ***************************************************************************/ 05735 05736 05737 #ifndef OH_INSTITUTE_DATA_LIST2_H 05738 #define OH_INSTITUTE_DATA_LIST2_H 05739 05740 05741 #ifdef __cplusplus 05742 extern "C" { 05743 #endif 05744 05751 typedef struct OH_INSTITUTE_DATA_LIST2 OH_INSTITUTE_DATA_LIST2; 05752 05756 typedef struct OH_INSTITUTE_DATA_LIST2_ITERATOR OH_INSTITUTE_DATA_LIST2_ITERATOR; 05757 05761 typedef OH_INSTITUTE_DATA* (OH_INSTITUTE_DATA_LIST2_FOREACH)(OH_INSTITUTE_DATA *element, 05762 void *user_data); 05763 05767 OH_INSTITUTE_DATA_LIST2 *OH_InstituteData_List2_new(); 05768 05772 void OH_InstituteData_List2_free(OH_INSTITUTE_DATA_LIST2 *l); 05773 05777 void OH_InstituteData_List2_Dump(OH_INSTITUTE_DATA_LIST2 *l, FILE *f, unsigned int indent); 05778 05782 void OH_InstituteData_List2_PushBack(OH_INSTITUTE_DATA_LIST2 *l, OH_INSTITUTE_DATA *p); 05783 05788 void OH_InstituteData_List2_PushFront(OH_INSTITUTE_DATA_LIST2 *l, OH_INSTITUTE_DATA *p); 05789 05794 OH_INSTITUTE_DATA *OH_InstituteData_List2_GetFront(OH_INSTITUTE_DATA_LIST2 *l); 05795 05800 OH_INSTITUTE_DATA *OH_InstituteData_List2_GetBack(OH_INSTITUTE_DATA_LIST2 *l); 05801 05806 void OH_InstituteData_List2_Erase(OH_INSTITUTE_DATA_LIST2 *l, 05807 OH_INSTITUTE_DATA_LIST2_ITERATOR *it); 05808 05814 unsigned int OH_InstituteData_List2_GetSize(OH_INSTITUTE_DATA_LIST2 *l); 05815 05820 void OH_InstituteData_List2_PopBack(OH_INSTITUTE_DATA_LIST2 *l); 05821 05826 void OH_InstituteData_List2_PopFront(OH_INSTITUTE_DATA_LIST2 *l); 05827 05831 void OH_InstituteData_List2_Clear(OH_INSTITUTE_DATA_LIST2 *l); 05832 05836 OH_INSTITUTE_DATA_LIST2_ITERATOR *OH_InstituteData_List2_First(OH_INSTITUTE_DATA_LIST2 *l); 05837 05841 OH_INSTITUTE_DATA_LIST2_ITERATOR *OH_InstituteData_List2_Last(OH_INSTITUTE_DATA_LIST2 *l); 05842 05846 OH_INSTITUTE_DATA_LIST2_ITERATOR *OH_InstituteData_List2Iterator_new(OH_INSTITUTE_DATA_LIST2 *l); 05847 05851 void OH_InstituteData_List2Iterator_free(OH_INSTITUTE_DATA_LIST2_ITERATOR *li); 05852 05857 OH_INSTITUTE_DATA *OH_InstituteData_List2Iterator_Previous(OH_INSTITUTE_DATA_LIST2_ITERATOR *li); 05858 05863 OH_INSTITUTE_DATA *OH_InstituteData_List2Iterator_Next(OH_INSTITUTE_DATA_LIST2_ITERATOR *li); 05864 05869 OH_INSTITUTE_DATA *OH_InstituteData_List2Iterator_Data(OH_INSTITUTE_DATA_LIST2_ITERATOR *li); 05870 05882 OH_INSTITUTE_DATA *OH_InstituteData_List2_ForEach(OH_INSTITUTE_DATA_LIST2 *list, 05883 OH_INSTITUTE_DATA_LIST2_FOREACH func, 05884 void *user_data); 05885 05886 05887 typedef struct OH_INSTITUTE_DATA_CONSTLIST2 OH_INSTITUTE_DATA_CONSTLIST2; 05888 typedef struct OH_INSTITUTE_DATA_CONSTLIST2_ITERATOR OH_INSTITUTE_DATA_CONSTLIST2_ITERATOR; 05889 typedef const OH_INSTITUTE_DATA* 05890 (OH_INSTITUTE_DATA_CONSTLIST2_FOREACH)(const OH_INSTITUTE_DATA *element, 05891 void *user_data); 05892 05893 05894 OH_INSTITUTE_DATA_CONSTLIST2 *OH_InstituteData_ConstList2_new(); 05895 05896 void OH_InstituteData_ConstList2_free(OH_INSTITUTE_DATA_CONSTLIST2 *l); 05897 05898 void OH_InstituteData_ConstList2_PushBack(OH_INSTITUTE_DATA_CONSTLIST2 *l, const OH_INSTITUTE_DATA *p); 05899 05900 void OH_InstituteData_ConstList2_PushFront(OH_INSTITUTE_DATA_CONSTLIST2 *l, const OH_INSTITUTE_DATA *p); 05901 05902 const OH_INSTITUTE_DATA *OH_InstituteData_ConstList2_GetFront(OH_INSTITUTE_DATA_CONSTLIST2 *l); 05903 05904 const OH_INSTITUTE_DATA *OH_InstituteData_ConstList2_GetBack(OH_INSTITUTE_DATA_CONSTLIST2 *l); 05905 05906 unsigned int OH_InstituteData_ConstList2_GetSize(OH_INSTITUTE_DATA_CONSTLIST2 *l); 05907 05908 void OH_InstituteData_ConstList2_PopBack(OH_INSTITUTE_DATA_CONSTLIST2 *l); 05909 05910 void OH_InstituteData_ConstList2_PopFront(OH_INSTITUTE_DATA_CONSTLIST2 *l); 05911 05912 void OH_InstituteData_ConstList2_Clear(OH_INSTITUTE_DATA_CONSTLIST2 *l); 05913 05914 OH_INSTITUTE_DATA_CONSTLIST2_ITERATOR *OH_InstituteData_ConstList2_First(OH_INSTITUTE_DATA_CONSTLIST2 *l); 05915 05916 OH_INSTITUTE_DATA_CONSTLIST2_ITERATOR *OH_InstituteData_ConstList2_Last(OH_INSTITUTE_DATA_CONSTLIST2 *l); 05917 05918 OH_INSTITUTE_DATA_CONSTLIST2_ITERATOR *OH_InstituteData_ConstList2Iterator_new(OH_INSTITUTE_DATA_CONSTLIST2 *l); 05919 05920 void OH_InstituteData_ConstList2Iterator_free(OH_INSTITUTE_DATA_CONSTLIST2_ITERATOR *li); 05921 05922 const OH_INSTITUTE_DATA *OH_InstituteData_ConstList2Iterator_Previous(OH_INSTITUTE_DATA_CONSTLIST2_ITERATOR *li); 05923 05924 const OH_INSTITUTE_DATA *OH_InstituteData_ConstList2Iterator_Next(OH_INSTITUTE_DATA_CONSTLIST2_ITERATOR *li); 05925 05926 const OH_INSTITUTE_DATA *OH_InstituteData_ConstList2Iterator_Data(OH_INSTITUTE_DATA_CONSTLIST2_ITERATOR *li); 05927 05939 const OH_INSTITUTE_DATA *OH_InstituteData_ConstList2_ForEach(OH_INSTITUTE_DATA_CONSTLIST2 *list, 05940 OH_INSTITUTE_DATA_CONSTLIST2_FOREACH func, void *user_data); 05941 05942 05943 #ifdef __cplusplus 05944 } 05945 #endif 05946 05947 05948 #endif /* OH_INSTITUTE_DATA_LIST_H */ 05949 05950 05951 05952 /*************************************************************************** 05953 $RCSfile$ 05954 ------------------- 05955 cvs : $Id$ 05956 begin : Sat Jun 28 2003 05957 copyright : (C) 2003 by Martin Preuss 05958 email : martin@libchipcard.de 05959 05960 *************************************************************************** 05961 * * 05962 * This library is free software; you can redistribute it and/or * 05963 * modify it under the terms of the GNU Lesser General Public * 05964 * License as published by the Free Software Foundation; either * 05965 * version 2.1 of the License, or (at your option) any later version. * 05966 * * 05967 * This library is distributed in the hope that it will be useful, * 05968 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 05969 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 05970 * Lesser General Public License for more details. * 05971 * * 05972 * You should have received a copy of the GNU Lesser General Public * 05973 * License along with this library; if not, write to the Free Software * 05974 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 05975 * MA 02111-1307 USA * 05976 * * 05977 ***************************************************************************/ 05978 05979 05980 #ifndef OH_INSTITUTE_DATA_LIST1_H 05981 #define OH_INSTITUTE_DATA_LIST1_H 05982 05983 #ifdef __cplusplus 05984 extern "C" { 05985 #endif 05986 05988 typedef struct OH_INSTITUTE_DATA_LIST_ELEMENT { 05989 uint32_t id; 05990 OH_INSTITUTE_DATA *nextObject; 05991 } OH_INSTITUTE_DATA_LIST__ELEMENT; 05992 05999 typedef struct OH_INSTITUTE_DATA_LIST OH_INSTITUTE_DATA_LIST; 06001 struct OH_INSTITUTE_DATA_LIST { 06002 OH_INSTITUTE_DATA *first; 06003 uint32_t count; 06004 uint32_t id; 06005 } OH_INSTITUTE_DATA_LIST; 06006 06011 void OH_InstituteData_List_AddList(OH_INSTITUTE_DATA_LIST *dst, OH_INSTITUTE_DATA_LIST *l); 06012 06016 void OH_InstituteData_List_Add(OH_INSTITUTE_DATA *element, OH_INSTITUTE_DATA_LIST *list); 06017 06022 void OH_InstituteData_List_Insert(OH_INSTITUTE_DATA *element, OH_INSTITUTE_DATA_LIST *list); 06023 06030 void OH_InstituteData_List_Del(OH_INSTITUTE_DATA *element); 06031 06035 OH_INSTITUTE_DATA* OH_InstituteData_List_First(const OH_INSTITUTE_DATA_LIST *l); 06036 06040 OH_INSTITUTE_DATA* OH_InstituteData_List_Last(const OH_INSTITUTE_DATA_LIST *l); 06041 06046 void OH_InstituteData_List_Clear(OH_INSTITUTE_DATA_LIST *l); 06047 06051 OH_INSTITUTE_DATA_LIST* OH_InstituteData_List_new(); 06052 06056 void OH_InstituteData_List_free(OH_INSTITUTE_DATA_LIST *l); 06057 06061 OH_INSTITUTE_DATA* OH_InstituteData_List_Next(const OH_INSTITUTE_DATA *element); 06062 06066 OH_INSTITUTE_DATA* OH_InstituteData_List_Previous(const OH_INSTITUTE_DATA *element); 06067 06071 uint32_t OH_InstituteData_List_GetCount(const OH_INSTITUTE_DATA_LIST *l); 06072 06073 #ifdef __cplusplus 06074 } 06075 #endif 06076 06077 06078 #endif 06079 06080 06081 06082 /*************************************************************************** 06083 $RCSfile$ 06084 ------------------- 06085 cvs : $Id$ 06086 begin : Sat Jun 28 2003 06087 copyright : (C) 2003 by Martin Preuss 06088 email : martin@libchipcard.de 06089 06090 *************************************************************************** 06091 * * 06092 * This library is free software; you can redistribute it and/or * 06093 * modify it under the terms of the GNU Lesser General Public * 06094 * License as published by the Free Software Foundation; either * 06095 * version 2.1 of the License, or (at your option) any later version. * 06096 * * 06097 * This library is distributed in the hope that it will be useful, * 06098 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 06099 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 06100 * Lesser General Public License for more details. * 06101 * * 06102 * You should have received a copy of the GNU Lesser General Public * 06103 * License along with this library; if not, write to the Free Software * 06104 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 06105 * MA 02111-1307 USA * 06106 * * 06107 ***************************************************************************/ 06108 06109 06110 #ifndef OH_INSTITUTE_SPEC_LIST2_H 06111 #define OH_INSTITUTE_SPEC_LIST2_H 06112 06113 06114 #ifdef __cplusplus 06115 extern "C" { 06116 #endif 06117 06124 typedef struct OH_INSTITUTE_SPEC_LIST2 OH_INSTITUTE_SPEC_LIST2; 06125 06129 typedef struct OH_INSTITUTE_SPEC_LIST2_ITERATOR OH_INSTITUTE_SPEC_LIST2_ITERATOR; 06130 06134 typedef OH_INSTITUTE_SPEC* (OH_INSTITUTE_SPEC_LIST2_FOREACH)(OH_INSTITUTE_SPEC *element, 06135 void *user_data); 06136 06140 OH_INSTITUTE_SPEC_LIST2 *OH_InstituteSpec_List2_new(); 06141 06145 void OH_InstituteSpec_List2_free(OH_INSTITUTE_SPEC_LIST2 *l); 06146 06150 void OH_InstituteSpec_List2_Dump(OH_INSTITUTE_SPEC_LIST2 *l, FILE *f, unsigned int indent); 06151 06155 void OH_InstituteSpec_List2_PushBack(OH_INSTITUTE_SPEC_LIST2 *l, OH_INSTITUTE_SPEC *p); 06156 06161 void OH_InstituteSpec_List2_PushFront(OH_INSTITUTE_SPEC_LIST2 *l, OH_INSTITUTE_SPEC *p); 06162 06167 OH_INSTITUTE_SPEC *OH_InstituteSpec_List2_GetFront(OH_INSTITUTE_SPEC_LIST2 *l); 06168 06173 OH_INSTITUTE_SPEC *OH_InstituteSpec_List2_GetBack(OH_INSTITUTE_SPEC_LIST2 *l); 06174 06179 void OH_InstituteSpec_List2_Erase(OH_INSTITUTE_SPEC_LIST2 *l, 06180 OH_INSTITUTE_SPEC_LIST2_ITERATOR *it); 06181 06187 unsigned int OH_InstituteSpec_List2_GetSize(OH_INSTITUTE_SPEC_LIST2 *l); 06188 06193 void OH_InstituteSpec_List2_PopBack(OH_INSTITUTE_SPEC_LIST2 *l); 06194 06199 void OH_InstituteSpec_List2_PopFront(OH_INSTITUTE_SPEC_LIST2 *l); 06200 06204 void OH_InstituteSpec_List2_Clear(OH_INSTITUTE_SPEC_LIST2 *l); 06205 06209 OH_INSTITUTE_SPEC_LIST2_ITERATOR *OH_InstituteSpec_List2_First(OH_INSTITUTE_SPEC_LIST2 *l); 06210 06214 OH_INSTITUTE_SPEC_LIST2_ITERATOR *OH_InstituteSpec_List2_Last(OH_INSTITUTE_SPEC_LIST2 *l); 06215 06219 OH_INSTITUTE_SPEC_LIST2_ITERATOR *OH_InstituteSpec_List2Iterator_new(OH_INSTITUTE_SPEC_LIST2 *l); 06220 06224 void OH_InstituteSpec_List2Iterator_free(OH_INSTITUTE_SPEC_LIST2_ITERATOR *li); 06225 06230 OH_INSTITUTE_SPEC *OH_InstituteSpec_List2Iterator_Previous(OH_INSTITUTE_SPEC_LIST2_ITERATOR *li); 06231 06236 OH_INSTITUTE_SPEC *OH_InstituteSpec_List2Iterator_Next(OH_INSTITUTE_SPEC_LIST2_ITERATOR *li); 06237 06242 OH_INSTITUTE_SPEC *OH_InstituteSpec_List2Iterator_Data(OH_INSTITUTE_SPEC_LIST2_ITERATOR *li); 06243 06255 OH_INSTITUTE_SPEC *OH_InstituteSpec_List2_ForEach(OH_INSTITUTE_SPEC_LIST2 *list, 06256 OH_INSTITUTE_SPEC_LIST2_FOREACH func, 06257 void *user_data); 06258 06259 06260 typedef struct OH_INSTITUTE_SPEC_CONSTLIST2 OH_INSTITUTE_SPEC_CONSTLIST2; 06261 typedef struct OH_INSTITUTE_SPEC_CONSTLIST2_ITERATOR OH_INSTITUTE_SPEC_CONSTLIST2_ITERATOR; 06262 typedef const OH_INSTITUTE_SPEC* 06263 (OH_INSTITUTE_SPEC_CONSTLIST2_FOREACH)(const OH_INSTITUTE_SPEC *element, 06264 void *user_data); 06265 06266 06267 OH_INSTITUTE_SPEC_CONSTLIST2 *OH_InstituteSpec_ConstList2_new(); 06268 06269 void OH_InstituteSpec_ConstList2_free(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 06270 06271 void OH_InstituteSpec_ConstList2_PushBack(OH_INSTITUTE_SPEC_CONSTLIST2 *l, const OH_INSTITUTE_SPEC *p); 06272 06273 void OH_InstituteSpec_ConstList2_PushFront(OH_INSTITUTE_SPEC_CONSTLIST2 *l, const OH_INSTITUTE_SPEC *p); 06274 06275 const OH_INSTITUTE_SPEC *OH_InstituteSpec_ConstList2_GetFront(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 06276 06277 const OH_INSTITUTE_SPEC *OH_InstituteSpec_ConstList2_GetBack(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 06278 06279 unsigned int OH_InstituteSpec_ConstList2_GetSize(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 06280 06281 void OH_InstituteSpec_ConstList2_PopBack(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 06282 06283 void OH_InstituteSpec_ConstList2_PopFront(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 06284 06285 void OH_InstituteSpec_ConstList2_Clear(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 06286 06287 OH_INSTITUTE_SPEC_CONSTLIST2_ITERATOR *OH_InstituteSpec_ConstList2_First(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 06288 06289 OH_INSTITUTE_SPEC_CONSTLIST2_ITERATOR *OH_InstituteSpec_ConstList2_Last(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 06290 06291 OH_INSTITUTE_SPEC_CONSTLIST2_ITERATOR *OH_InstituteSpec_ConstList2Iterator_new(OH_INSTITUTE_SPEC_CONSTLIST2 *l); 06292 06293 void OH_InstituteSpec_ConstList2Iterator_free(OH_INSTITUTE_SPEC_CONSTLIST2_ITERATOR *li); 06294 06295 const OH_INSTITUTE_SPEC *OH_InstituteSpec_ConstList2Iterator_Previous(OH_INSTITUTE_SPEC_CONSTLIST2_ITERATOR *li); 06296 06297 const OH_INSTITUTE_SPEC *OH_InstituteSpec_ConstList2Iterator_Next(OH_INSTITUTE_SPEC_CONSTLIST2_ITERATOR *li); 06298 06299 const OH_INSTITUTE_SPEC *OH_InstituteSpec_ConstList2Iterator_Data(OH_INSTITUTE_SPEC_CONSTLIST2_ITERATOR *li); 06300 06312 const OH_INSTITUTE_SPEC *OH_InstituteSpec_ConstList2_ForEach(OH_INSTITUTE_SPEC_CONSTLIST2 *list, 06313 OH_INSTITUTE_SPEC_CONSTLIST2_FOREACH func, void *user_data); 06314 06315 06316 #ifdef __cplusplus 06317 } 06318 #endif 06319 06320 06321 #endif /* OH_INSTITUTE_SPEC_LIST_H */ 06322 06323 06324 06325 /*************************************************************************** 06326 $RCSfile$ 06327 ------------------- 06328 cvs : $Id$ 06329 begin : Sat Jun 28 2003 06330 copyright : (C) 2003 by Martin Preuss 06331 email : martin@libchipcard.de 06332 06333 *************************************************************************** 06334 * * 06335 * This library is free software; you can redistribute it and/or * 06336 * modify it under the terms of the GNU Lesser General Public * 06337 * License as published by the Free Software Foundation; either * 06338 * version 2.1 of the License, or (at your option) any later version. * 06339 * * 06340 * This library is distributed in the hope that it will be useful, * 06341 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 06342 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 06343 * Lesser General Public License for more details. * 06344 * * 06345 * You should have received a copy of the GNU Lesser General Public * 06346 * License along with this library; if not, write to the Free Software * 06347 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 06348 * MA 02111-1307 USA * 06349 * * 06350 ***************************************************************************/ 06351 06352 06353 #ifndef OH_INSTITUTE_SPEC_LIST1_H 06354 #define OH_INSTITUTE_SPEC_LIST1_H 06355 06356 #ifdef __cplusplus 06357 extern "C" { 06358 #endif 06359 06361 typedef struct OH_INSTITUTE_SPEC_LIST_ELEMENT { 06362 uint32_t id; 06363 OH_INSTITUTE_SPEC *nextObject; 06364 } OH_INSTITUTE_SPEC_LIST__ELEMENT; 06365 06372 typedef struct OH_INSTITUTE_SPEC_LIST OH_INSTITUTE_SPEC_LIST; 06374 struct OH_INSTITUTE_SPEC_LIST { 06375 OH_INSTITUTE_SPEC *first; 06376 uint32_t count; 06377 uint32_t id; 06378 } OH_INSTITUTE_SPEC_LIST; 06379 06384 void OH_InstituteSpec_List_AddList(OH_INSTITUTE_SPEC_LIST *dst, OH_INSTITUTE_SPEC_LIST *l); 06385 06389 void OH_InstituteSpec_List_Add(OH_INSTITUTE_SPEC *element, OH_INSTITUTE_SPEC_LIST *list); 06390 06395 void OH_InstituteSpec_List_Insert(OH_INSTITUTE_SPEC *element, OH_INSTITUTE_SPEC_LIST *list); 06396 06403 void OH_InstituteSpec_List_Del(OH_INSTITUTE_SPEC *element); 06404 06408 OH_INSTITUTE_SPEC* OH_InstituteSpec_List_First(const OH_INSTITUTE_SPEC_LIST *l); 06409 06413 OH_INSTITUTE_SPEC* OH_InstituteSpec_List_Last(const OH_INSTITUTE_SPEC_LIST *l); 06414 06419 void OH_InstituteSpec_List_Clear(OH_INSTITUTE_SPEC_LIST *l); 06420 06424 OH_INSTITUTE_SPEC_LIST* OH_InstituteSpec_List_new(); 06425 06429 void OH_InstituteSpec_List_free(OH_INSTITUTE_SPEC_LIST *l); 06430 06434 OH_INSTITUTE_SPEC* OH_InstituteSpec_List_Next(const OH_INSTITUTE_SPEC *element); 06435 06439 OH_INSTITUTE_SPEC* OH_InstituteSpec_List_Previous(const OH_INSTITUTE_SPEC *element); 06440 06444 uint32_t OH_InstituteSpec_List_GetCount(const OH_INSTITUTE_SPEC_LIST *l); 06445 06446 #ifdef __cplusplus 06447 } 06448 #endif 06449 06450 06451 #endif 06452 06453 06454 06455 /*************************************************************************** 06456 $RCSfile$ 06457 ------------------- 06458 cvs : $Id$ 06459 begin : Sat Jun 28 2003 06460 copyright : (C) 2003 by Martin Preuss 06461 email : martin@libchipcard.de 06462 06463 *************************************************************************** 06464 * * 06465 * This library is free software; you can redistribute it and/or * 06466 * modify it under the terms of the GNU Lesser General Public * 06467 * License as published by the Free Software Foundation; either * 06468 * version 2.1 of the License, or (at your option) any later version. * 06469 * * 06470 * This library is distributed in the hope that it will be useful, * 06471 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 06472 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 06473 * Lesser General Public License for more details. * 06474 * * 06475 * You should have received a copy of the GNU Lesser General Public * 06476 * License along with this library; if not, write to the Free Software * 06477 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 06478 * MA 02111-1307 USA * 06479 * * 06480 ***************************************************************************/ 06481 06482 06483 #ifndef AH_TAN_METHOD_LIST2_H 06484 #define AH_TAN_METHOD_LIST2_H 06485 06486 06487 #ifdef __cplusplus 06488 extern "C" { 06489 #endif 06490 06497 typedef struct AH_TAN_METHOD_LIST2 AH_TAN_METHOD_LIST2; 06498 06502 typedef struct AH_TAN_METHOD_LIST2_ITERATOR AH_TAN_METHOD_LIST2_ITERATOR; 06503 06507 typedef AH_TAN_METHOD* (AH_TAN_METHOD_LIST2_FOREACH)(AH_TAN_METHOD *element, 06508 void *user_data); 06509 06513 AH_TAN_METHOD_LIST2 *AH_TanMethod_List2_new(); 06514 06518 void AH_TanMethod_List2_free(AH_TAN_METHOD_LIST2 *l); 06519 06523 void AH_TanMethod_List2_Dump(AH_TAN_METHOD_LIST2 *l, FILE *f, unsigned int indent); 06524 06528 void AH_TanMethod_List2_PushBack(AH_TAN_METHOD_LIST2 *l, AH_TAN_METHOD *p); 06529 06534 void AH_TanMethod_List2_PushFront(AH_TAN_METHOD_LIST2 *l, AH_TAN_METHOD *p); 06535 06540 AH_TAN_METHOD *AH_TanMethod_List2_GetFront(AH_TAN_METHOD_LIST2 *l); 06541 06546 AH_TAN_METHOD *AH_TanMethod_List2_GetBack(AH_TAN_METHOD_LIST2 *l); 06547 06552 void AH_TanMethod_List2_Erase(AH_TAN_METHOD_LIST2 *l, 06553 AH_TAN_METHOD_LIST2_ITERATOR *it); 06554 06560 unsigned int AH_TanMethod_List2_GetSize(AH_TAN_METHOD_LIST2 *l); 06561 06566 void AH_TanMethod_List2_PopBack(AH_TAN_METHOD_LIST2 *l); 06567 06572 void AH_TanMethod_List2_PopFront(AH_TAN_METHOD_LIST2 *l); 06573 06577 void AH_TanMethod_List2_Clear(AH_TAN_METHOD_LIST2 *l); 06578 06582 AH_TAN_METHOD_LIST2_ITERATOR *AH_TanMethod_List2_First(AH_TAN_METHOD_LIST2 *l); 06583 06587 AH_TAN_METHOD_LIST2_ITERATOR *AH_TanMethod_List2_Last(AH_TAN_METHOD_LIST2 *l); 06588 06592 AH_TAN_METHOD_LIST2_ITERATOR *AH_TanMethod_List2Iterator_new(AH_TAN_METHOD_LIST2 *l); 06593 06597 void AH_TanMethod_List2Iterator_free(AH_TAN_METHOD_LIST2_ITERATOR *li); 06598 06603 AH_TAN_METHOD *AH_TanMethod_List2Iterator_Previous(AH_TAN_METHOD_LIST2_ITERATOR *li); 06604 06609 AH_TAN_METHOD *AH_TanMethod_List2Iterator_Next(AH_TAN_METHOD_LIST2_ITERATOR *li); 06610 06615 AH_TAN_METHOD *AH_TanMethod_List2Iterator_Data(AH_TAN_METHOD_LIST2_ITERATOR *li); 06616 06628 AH_TAN_METHOD *AH_TanMethod_List2_ForEach(AH_TAN_METHOD_LIST2 *list, 06629 AH_TAN_METHOD_LIST2_FOREACH func, 06630 void *user_data); 06631 06632 06633 typedef struct AH_TAN_METHOD_CONSTLIST2 AH_TAN_METHOD_CONSTLIST2; 06634 typedef struct AH_TAN_METHOD_CONSTLIST2_ITERATOR AH_TAN_METHOD_CONSTLIST2_ITERATOR; 06635 typedef const AH_TAN_METHOD* 06636 (AH_TAN_METHOD_CONSTLIST2_FOREACH)(const AH_TAN_METHOD *element, 06637 void *user_data); 06638 06639 06640 AH_TAN_METHOD_CONSTLIST2 *AH_TanMethod_ConstList2_new(); 06641 06642 void AH_TanMethod_ConstList2_free(AH_TAN_METHOD_CONSTLIST2 *l); 06643 06644 void AH_TanMethod_ConstList2_PushBack(AH_TAN_METHOD_CONSTLIST2 *l, const AH_TAN_METHOD *p); 06645 06646 void AH_TanMethod_ConstList2_PushFront(AH_TAN_METHOD_CONSTLIST2 *l, const AH_TAN_METHOD *p); 06647 06648 const AH_TAN_METHOD *AH_TanMethod_ConstList2_GetFront(AH_TAN_METHOD_CONSTLIST2 *l); 06649 06650 const AH_TAN_METHOD *AH_TanMethod_ConstList2_GetBack(AH_TAN_METHOD_CONSTLIST2 *l); 06651 06652 unsigned int AH_TanMethod_ConstList2_GetSize(AH_TAN_METHOD_CONSTLIST2 *l); 06653 06654 void AH_TanMethod_ConstList2_PopBack(AH_TAN_METHOD_CONSTLIST2 *l); 06655 06656 void AH_TanMethod_ConstList2_PopFront(AH_TAN_METHOD_CONSTLIST2 *l); 06657 06658 void AH_TanMethod_ConstList2_Clear(AH_TAN_METHOD_CONSTLIST2 *l); 06659 06660 AH_TAN_METHOD_CONSTLIST2_ITERATOR *AH_TanMethod_ConstList2_First(AH_TAN_METHOD_CONSTLIST2 *l); 06661 06662 AH_TAN_METHOD_CONSTLIST2_ITERATOR *AH_TanMethod_ConstList2_Last(AH_TAN_METHOD_CONSTLIST2 *l); 06663 06664 AH_TAN_METHOD_CONSTLIST2_ITERATOR *AH_TanMethod_ConstList2Iterator_new(AH_TAN_METHOD_CONSTLIST2 *l); 06665 06666 void AH_TanMethod_ConstList2Iterator_free(AH_TAN_METHOD_CONSTLIST2_ITERATOR *li); 06667 06668 const AH_TAN_METHOD *AH_TanMethod_ConstList2Iterator_Previous(AH_TAN_METHOD_CONSTLIST2_ITERATOR *li); 06669 06670 const AH_TAN_METHOD *AH_TanMethod_ConstList2Iterator_Next(AH_TAN_METHOD_CONSTLIST2_ITERATOR *li); 06671 06672 const AH_TAN_METHOD *AH_TanMethod_ConstList2Iterator_Data(AH_TAN_METHOD_CONSTLIST2_ITERATOR *li); 06673 06685 const AH_TAN_METHOD *AH_TanMethod_ConstList2_ForEach(AH_TAN_METHOD_CONSTLIST2 *list, 06686 AH_TAN_METHOD_CONSTLIST2_FOREACH func, void *user_data); 06687 06688 06689 #ifdef __cplusplus 06690 } 06691 #endif 06692 06693 06694 #endif /* AH_TAN_METHOD_LIST_H */ 06695 06696 06697 06698 /*************************************************************************** 06699 $RCSfile$ 06700 ------------------- 06701 cvs : $Id$ 06702 begin : Sat Jun 28 2003 06703 copyright : (C) 2003 by Martin Preuss 06704 email : martin@libchipcard.de 06705 06706 *************************************************************************** 06707 * * 06708 * This library is free software; you can redistribute it and/or * 06709 * modify it under the terms of the GNU Lesser General Public * 06710 * License as published by the Free Software Foundation; either * 06711 * version 2.1 of the License, or (at your option) any later version. * 06712 * * 06713 * This library is distributed in the hope that it will be useful, * 06714 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 06715 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 06716 * Lesser General Public License for more details. * 06717 * * 06718 * You should have received a copy of the GNU Lesser General Public * 06719 * License along with this library; if not, write to the Free Software * 06720 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * 06721 * MA 02111-1307 USA * 06722 * * 06723 ***************************************************************************/ 06724 06725 06726 #ifndef AH_TAN_METHOD_LIST1_H 06727 #define AH_TAN_METHOD_LIST1_H 06728 06729 #ifdef __cplusplus 06730 extern "C" { 06731 #endif 06732 06734 typedef struct AH_TAN_METHOD_LIST_ELEMENT { 06735 uint32_t id; 06736 AH_TAN_METHOD *nextObject; 06737 } AH_TAN_METHOD_LIST__ELEMENT; 06738 06745 typedef struct AH_TAN_METHOD_LIST AH_TAN_METHOD_LIST; 06747 struct AH_TAN_METHOD_LIST { 06748 AH_TAN_METHOD *first; 06749 uint32_t count; 06750 uint32_t id; 06751 } AH_TAN_METHOD_LIST; 06752 06757 void AH_TanMethod_List_AddList(AH_TAN_METHOD_LIST *dst, AH_TAN_METHOD_LIST *l); 06758 06762 void AH_TanMethod_List_Add(AH_TAN_METHOD *element, AH_TAN_METHOD_LIST *list); 06763 06768 void AH_TanMethod_List_Insert(AH_TAN_METHOD *element, AH_TAN_METHOD_LIST *list); 06769 06776 void AH_TanMethod_List_Del(AH_TAN_METHOD *element); 06777 06781 AH_TAN_METHOD* AH_TanMethod_List_First(const AH_TAN_METHOD_LIST *l); 06782 06786 AH_TAN_METHOD* AH_TanMethod_List_Last(const AH_TAN_METHOD_LIST *l); 06787 06792 void AH_TanMethod_List_Clear(AH_TAN_METHOD_LIST *l); 06793 06797 AH_TAN_METHOD_LIST* AH_TanMethod_List_new(); 06798 06802 void AH_TanMethod_List_free(AH_TAN_METHOD_LIST *l); 06803 06807 AH_TAN_METHOD* AH_TanMethod_List_Next(const AH_TAN_METHOD *element); 06808 06812 AH_TAN_METHOD* AH_TanMethod_List_Previous(const AH_TAN_METHOD *element); 06813 06817 uint32_t AH_TanMethod_List_GetCount(const AH_TAN_METHOD_LIST *l); 06818 06819 #ifdef __cplusplus 06820 } 06821 #endif 06822 06823 06824 #endif 06825 06826 06827