00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029 #ifndef GWEN_DBIO_LIST1_H
00030 #define GWEN_DBIO_LIST1_H
00031
00032 #ifdef __cplusplus
00033 extern "C" {
00034 #endif
00035
00037 typedef struct GWEN_DBIO_LIST_ELEMENT {
00038 uint32_t id;
00039 GWEN_DBIO *nextObject;
00040 } GWEN_DBIO_LIST__ELEMENT;
00041
00048 typedef struct GWEN_DBIO_LIST GWEN_DBIO_LIST;
00050 struct GWEN_DBIO_LIST {
00051 GWEN_DBIO *first;
00052 uint32_t count;
00053 uint32_t id;
00054 } GWEN_DBIO_LIST;
00055
00060 void GWEN_DBIO_List_AddList(GWEN_DBIO_LIST *dst, GWEN_DBIO_LIST *l);
00061
00065 void GWEN_DBIO_List_Add(GWEN_DBIO *element, GWEN_DBIO_LIST *list);
00066
00071 void GWEN_DBIO_List_Insert(GWEN_DBIO *element, GWEN_DBIO_LIST *list);
00072
00079 void GWEN_DBIO_List_Del(GWEN_DBIO *element);
00080
00084 GWEN_DBIO* GWEN_DBIO_List_First(const GWEN_DBIO_LIST *l);
00085
00089 GWEN_DBIO* GWEN_DBIO_List_Last(const GWEN_DBIO_LIST *l);
00090
00095 void GWEN_DBIO_List_Clear(GWEN_DBIO_LIST *l);
00096
00100 GWEN_DBIO_LIST* GWEN_DBIO_List_new();
00101
00105 void GWEN_DBIO_List_free(GWEN_DBIO_LIST *l);
00106
00110 GWEN_DBIO* GWEN_DBIO_List_Next(const GWEN_DBIO *element);
00111
00115 GWEN_DBIO* GWEN_DBIO_List_Previous(const GWEN_DBIO *element);
00116
00120 uint32_t GWEN_DBIO_List_GetCount(const GWEN_DBIO_LIST *l);
00121
00122 #ifdef __cplusplus
00123 }
00124 #endif
00125
00126
00127 #endif
00128
00129
00130
00131
00132
00133
00134
00135
00136
00137
00138
00139
00140
00141
00142
00143
00144
00145
00146
00147
00148
00149
00150
00151
00152
00153
00154
00155
00156
00157
00158
00159 #ifndef GWEN_TLV_LIST1_H
00160 #define GWEN_TLV_LIST1_H
00161
00162 #ifdef __cplusplus
00163 extern "C" {
00164 #endif
00165
00167 typedef struct GWEN_TLV_LIST_ELEMENT {
00168 uint32_t id;
00169 GWEN_TLV *nextObject;
00170 } GWEN_TLV_LIST__ELEMENT;
00171
00178 typedef struct GWEN_TLV_LIST GWEN_TLV_LIST;
00180 struct GWEN_TLV_LIST {
00181 GWEN_TLV *first;
00182 uint32_t count;
00183 uint32_t id;
00184 } GWEN_TLV_LIST;
00185
00190 void GWEN_TLV_List_AddList(GWEN_TLV_LIST *dst, GWEN_TLV_LIST *l);
00191
00195 void GWEN_TLV_List_Add(GWEN_TLV *element, GWEN_TLV_LIST *list);
00196
00201 void GWEN_TLV_List_Insert(GWEN_TLV *element, GWEN_TLV_LIST *list);
00202
00209 void GWEN_TLV_List_Del(GWEN_TLV *element);
00210
00214 GWEN_TLV* GWEN_TLV_List_First(const GWEN_TLV_LIST *l);
00215
00219 GWEN_TLV* GWEN_TLV_List_Last(const GWEN_TLV_LIST *l);
00220
00225 void GWEN_TLV_List_Clear(GWEN_TLV_LIST *l);
00226
00230 GWEN_TLV_LIST* GWEN_TLV_List_new();
00231
00235 void GWEN_TLV_List_free(GWEN_TLV_LIST *l);
00236
00240 GWEN_TLV* GWEN_TLV_List_Next(const GWEN_TLV *element);
00241
00245 GWEN_TLV* GWEN_TLV_List_Previous(const GWEN_TLV *element);
00246
00250 uint32_t GWEN_TLV_List_GetCount(const GWEN_TLV_LIST *l);
00251
00252 #ifdef __cplusplus
00253 }
00254 #endif
00255
00256
00257 #endif
00258
00259
00260
00261
00262
00263
00264
00265
00266
00267
00268
00269
00270
00271
00272
00273
00274
00275
00276
00277
00278
00279
00280
00281
00282
00283
00284
00285
00286
00287
00288
00289 #ifndef GWEN_URL_LIST2_H
00290 #define GWEN_URL_LIST2_H
00291
00292
00293 #ifdef __cplusplus
00294 extern "C" {
00295 #endif
00296
00303 typedef struct GWEN_URL_LIST2 GWEN_URL_LIST2;
00304
00308 typedef struct GWEN_URL_LIST2_ITERATOR GWEN_URL_LIST2_ITERATOR;
00309
00313 typedef GWEN_URL* (GWEN_URL_LIST2_FOREACH)(GWEN_URL *element,
00314 void *user_data);
00315
00319 GWEN_URL_LIST2 *GWEN_Url_List2_new();
00320
00324 void GWEN_Url_List2_free(GWEN_URL_LIST2 *l);
00325
00329 void GWEN_Url_List2_Dump(GWEN_URL_LIST2 *l, FILE *f, unsigned int indent);
00330
00334 void GWEN_Url_List2_PushBack(GWEN_URL_LIST2 *l, GWEN_URL *p);
00335
00340 void GWEN_Url_List2_PushFront(GWEN_URL_LIST2 *l, GWEN_URL *p);
00341
00346 GWEN_URL *GWEN_Url_List2_GetFront(GWEN_URL_LIST2 *l);
00347
00352 GWEN_URL *GWEN_Url_List2_GetBack(GWEN_URL_LIST2 *l);
00353
00358 void GWEN_Url_List2_Erase(GWEN_URL_LIST2 *l,
00359 GWEN_URL_LIST2_ITERATOR *it);
00360
00366 unsigned int GWEN_Url_List2_GetSize(GWEN_URL_LIST2 *l);
00367
00372 void GWEN_Url_List2_PopBack(GWEN_URL_LIST2 *l);
00373
00378 void GWEN_Url_List2_PopFront(GWEN_URL_LIST2 *l);
00379
00383 void GWEN_Url_List2_Clear(GWEN_URL_LIST2 *l);
00384
00388 GWEN_URL_LIST2_ITERATOR *GWEN_Url_List2_First(GWEN_URL_LIST2 *l);
00389
00393 GWEN_URL_LIST2_ITERATOR *GWEN_Url_List2_Last(GWEN_URL_LIST2 *l);
00394
00398 GWEN_URL_LIST2_ITERATOR *GWEN_Url_List2Iterator_new(GWEN_URL_LIST2 *l);
00399
00403 void GWEN_Url_List2Iterator_free(GWEN_URL_LIST2_ITERATOR *li);
00404
00409 GWEN_URL *GWEN_Url_List2Iterator_Previous(GWEN_URL_LIST2_ITERATOR *li);
00410
00415 GWEN_URL *GWEN_Url_List2Iterator_Next(GWEN_URL_LIST2_ITERATOR *li);
00416
00421 GWEN_URL *GWEN_Url_List2Iterator_Data(GWEN_URL_LIST2_ITERATOR *li);
00422
00434 GWEN_URL *GWEN_Url_List2_ForEach(GWEN_URL_LIST2 *list,
00435 GWEN_URL_LIST2_FOREACH func,
00436 void *user_data);
00437
00438
00439 typedef struct GWEN_URL_CONSTLIST2 GWEN_URL_CONSTLIST2;
00440 typedef struct GWEN_URL_CONSTLIST2_ITERATOR GWEN_URL_CONSTLIST2_ITERATOR;
00441 typedef const GWEN_URL*
00442 (GWEN_URL_CONSTLIST2_FOREACH)(const GWEN_URL *element,
00443 void *user_data);
00444
00445
00446 GWEN_URL_CONSTLIST2 *GWEN_Url_ConstList2_new();
00447
00448 void GWEN_Url_ConstList2_free(GWEN_URL_CONSTLIST2 *l);
00449
00450 void GWEN_Url_ConstList2_PushBack(GWEN_URL_CONSTLIST2 *l, const GWEN_URL *p);
00451
00452 void GWEN_Url_ConstList2_PushFront(GWEN_URL_CONSTLIST2 *l, const GWEN_URL *p);
00453
00454 const GWEN_URL *GWEN_Url_ConstList2_GetFront(GWEN_URL_CONSTLIST2 *l);
00455
00456 const GWEN_URL *GWEN_Url_ConstList2_GetBack(GWEN_URL_CONSTLIST2 *l);
00457
00458 unsigned int GWEN_Url_ConstList2_GetSize(GWEN_URL_CONSTLIST2 *l);
00459
00460 void GWEN_Url_ConstList2_PopBack(GWEN_URL_CONSTLIST2 *l);
00461
00462 void GWEN_Url_ConstList2_PopFront(GWEN_URL_CONSTLIST2 *l);
00463
00464 void GWEN_Url_ConstList2_Clear(GWEN_URL_CONSTLIST2 *l);
00465
00466 GWEN_URL_CONSTLIST2_ITERATOR *GWEN_Url_ConstList2_First(GWEN_URL_CONSTLIST2 *l);
00467
00468 GWEN_URL_CONSTLIST2_ITERATOR *GWEN_Url_ConstList2_Last(GWEN_URL_CONSTLIST2 *l);
00469
00470 GWEN_URL_CONSTLIST2_ITERATOR *GWEN_Url_ConstList2Iterator_new(GWEN_URL_CONSTLIST2 *l);
00471
00472 void GWEN_Url_ConstList2Iterator_free(GWEN_URL_CONSTLIST2_ITERATOR *li);
00473
00474 const GWEN_URL *GWEN_Url_ConstList2Iterator_Previous(GWEN_URL_CONSTLIST2_ITERATOR *li);
00475
00476 const GWEN_URL *GWEN_Url_ConstList2Iterator_Next(GWEN_URL_CONSTLIST2_ITERATOR *li);
00477
00478 const GWEN_URL *GWEN_Url_ConstList2Iterator_Data(GWEN_URL_CONSTLIST2_ITERATOR *li);
00479
00491 const GWEN_URL *GWEN_Url_ConstList2_ForEach(GWEN_URL_CONSTLIST2 *list,
00492 GWEN_URL_CONSTLIST2_FOREACH func, void *user_data);
00493
00494
00495 #ifdef __cplusplus
00496 }
00497 #endif
00498
00499
00500 #endif
00501
00502
00503
00504
00505
00506
00507
00508
00509
00510
00511
00512
00513
00514
00515
00516
00517
00518
00519
00520
00521
00522
00523
00524
00525
00526
00527
00528
00529
00530
00531
00532 #ifndef GWEN_URL_LIST1_H
00533 #define GWEN_URL_LIST1_H
00534
00535 #ifdef __cplusplus
00536 extern "C" {
00537 #endif
00538
00540 typedef struct GWEN_URL_LIST_ELEMENT {
00541 uint32_t id;
00542 GWEN_URL *nextObject;
00543 } GWEN_URL_LIST__ELEMENT;
00544
00551 typedef struct GWEN_URL_LIST GWEN_URL_LIST;
00553 struct GWEN_URL_LIST {
00554 GWEN_URL *first;
00555 uint32_t count;
00556 uint32_t id;
00557 } GWEN_URL_LIST;
00558
00563 void GWEN_Url_List_AddList(GWEN_URL_LIST *dst, GWEN_URL_LIST *l);
00564
00568 void GWEN_Url_List_Add(GWEN_URL *element, GWEN_URL_LIST *list);
00569
00574 void GWEN_Url_List_Insert(GWEN_URL *element, GWEN_URL_LIST *list);
00575
00582 void GWEN_Url_List_Del(GWEN_URL *element);
00583
00587 GWEN_URL* GWEN_Url_List_First(const GWEN_URL_LIST *l);
00588
00592 GWEN_URL* GWEN_Url_List_Last(const GWEN_URL_LIST *l);
00593
00598 void GWEN_Url_List_Clear(GWEN_URL_LIST *l);
00599
00603 GWEN_URL_LIST* GWEN_Url_List_new();
00604
00608 void GWEN_Url_List_free(GWEN_URL_LIST *l);
00609
00613 GWEN_URL* GWEN_Url_List_Next(const GWEN_URL *element);
00614
00618 GWEN_URL* GWEN_Url_List_Previous(const GWEN_URL *element);
00619
00623 uint32_t GWEN_Url_List_GetCount(const GWEN_URL_LIST *l);
00624
00625 #ifdef __cplusplus
00626 }
00627 #endif
00628
00629
00630 #endif
00631
00632
00633
00634
00635
00636
00637
00638
00639
00640
00641
00642
00643
00644
00645
00646
00647
00648
00649
00650
00651
00652
00653
00654
00655
00656
00657
00658
00659
00660
00661
00662 #ifndef GWEN_CRYPT_KEY_LIST2_H
00663 #define GWEN_CRYPT_KEY_LIST2_H
00664
00665
00666 #ifdef __cplusplus
00667 extern "C" {
00668 #endif
00669
00676 typedef struct GWEN_CRYPT_KEY_LIST2 GWEN_CRYPT_KEY_LIST2;
00677
00681 typedef struct GWEN_CRYPT_KEY_LIST2_ITERATOR GWEN_CRYPT_KEY_LIST2_ITERATOR;
00682
00686 typedef GWEN_CRYPT_KEY* (GWEN_CRYPT_KEY_LIST2_FOREACH)(GWEN_CRYPT_KEY *element,
00687 void *user_data);
00688
00692 GWEN_CRYPT_KEY_LIST2 *GWEN_Crypt_Key_List2_new();
00693
00697 void GWEN_Crypt_Key_List2_free(GWEN_CRYPT_KEY_LIST2 *l);
00698
00702 void GWEN_Crypt_Key_List2_Dump(GWEN_CRYPT_KEY_LIST2 *l, FILE *f, unsigned int indent);
00703
00707 void GWEN_Crypt_Key_List2_PushBack(GWEN_CRYPT_KEY_LIST2 *l, GWEN_CRYPT_KEY *p);
00708
00713 void GWEN_Crypt_Key_List2_PushFront(GWEN_CRYPT_KEY_LIST2 *l, GWEN_CRYPT_KEY *p);
00714
00719 GWEN_CRYPT_KEY *GWEN_Crypt_Key_List2_GetFront(GWEN_CRYPT_KEY_LIST2 *l);
00720
00725 GWEN_CRYPT_KEY *GWEN_Crypt_Key_List2_GetBack(GWEN_CRYPT_KEY_LIST2 *l);
00726
00731 void GWEN_Crypt_Key_List2_Erase(GWEN_CRYPT_KEY_LIST2 *l,
00732 GWEN_CRYPT_KEY_LIST2_ITERATOR *it);
00733
00739 unsigned int GWEN_Crypt_Key_List2_GetSize(GWEN_CRYPT_KEY_LIST2 *l);
00740
00745 void GWEN_Crypt_Key_List2_PopBack(GWEN_CRYPT_KEY_LIST2 *l);
00746
00751 void GWEN_Crypt_Key_List2_PopFront(GWEN_CRYPT_KEY_LIST2 *l);
00752
00756 void GWEN_Crypt_Key_List2_Clear(GWEN_CRYPT_KEY_LIST2 *l);
00757
00761 GWEN_CRYPT_KEY_LIST2_ITERATOR *GWEN_Crypt_Key_List2_First(GWEN_CRYPT_KEY_LIST2 *l);
00762
00766 GWEN_CRYPT_KEY_LIST2_ITERATOR *GWEN_Crypt_Key_List2_Last(GWEN_CRYPT_KEY_LIST2 *l);
00767
00771 GWEN_CRYPT_KEY_LIST2_ITERATOR *GWEN_Crypt_Key_List2Iterator_new(GWEN_CRYPT_KEY_LIST2 *l);
00772
00776 void GWEN_Crypt_Key_List2Iterator_free(GWEN_CRYPT_KEY_LIST2_ITERATOR *li);
00777
00782 GWEN_CRYPT_KEY *GWEN_Crypt_Key_List2Iterator_Previous(GWEN_CRYPT_KEY_LIST2_ITERATOR *li);
00783
00788 GWEN_CRYPT_KEY *GWEN_Crypt_Key_List2Iterator_Next(GWEN_CRYPT_KEY_LIST2_ITERATOR *li);
00789
00794 GWEN_CRYPT_KEY *GWEN_Crypt_Key_List2Iterator_Data(GWEN_CRYPT_KEY_LIST2_ITERATOR *li);
00795
00807 GWEN_CRYPT_KEY *GWEN_Crypt_Key_List2_ForEach(GWEN_CRYPT_KEY_LIST2 *list,
00808 GWEN_CRYPT_KEY_LIST2_FOREACH func,
00809 void *user_data);
00810
00811
00812 typedef struct GWEN_CRYPT_KEY_CONSTLIST2 GWEN_CRYPT_KEY_CONSTLIST2;
00813 typedef struct GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR;
00814 typedef const GWEN_CRYPT_KEY*
00815 (GWEN_CRYPT_KEY_CONSTLIST2_FOREACH)(const GWEN_CRYPT_KEY *element,
00816 void *user_data);
00817
00818
00819 GWEN_CRYPT_KEY_CONSTLIST2 *GWEN_Crypt_Key_ConstList2_new();
00820
00821 void GWEN_Crypt_Key_ConstList2_free(GWEN_CRYPT_KEY_CONSTLIST2 *l);
00822
00823 void GWEN_Crypt_Key_ConstList2_PushBack(GWEN_CRYPT_KEY_CONSTLIST2 *l, const GWEN_CRYPT_KEY *p);
00824
00825 void GWEN_Crypt_Key_ConstList2_PushFront(GWEN_CRYPT_KEY_CONSTLIST2 *l, const GWEN_CRYPT_KEY *p);
00826
00827 const GWEN_CRYPT_KEY *GWEN_Crypt_Key_ConstList2_GetFront(GWEN_CRYPT_KEY_CONSTLIST2 *l);
00828
00829 const GWEN_CRYPT_KEY *GWEN_Crypt_Key_ConstList2_GetBack(GWEN_CRYPT_KEY_CONSTLIST2 *l);
00830
00831 unsigned int GWEN_Crypt_Key_ConstList2_GetSize(GWEN_CRYPT_KEY_CONSTLIST2 *l);
00832
00833 void GWEN_Crypt_Key_ConstList2_PopBack(GWEN_CRYPT_KEY_CONSTLIST2 *l);
00834
00835 void GWEN_Crypt_Key_ConstList2_PopFront(GWEN_CRYPT_KEY_CONSTLIST2 *l);
00836
00837 void GWEN_Crypt_Key_ConstList2_Clear(GWEN_CRYPT_KEY_CONSTLIST2 *l);
00838
00839 GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR *GWEN_Crypt_Key_ConstList2_First(GWEN_CRYPT_KEY_CONSTLIST2 *l);
00840
00841 GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR *GWEN_Crypt_Key_ConstList2_Last(GWEN_CRYPT_KEY_CONSTLIST2 *l);
00842
00843 GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR *GWEN_Crypt_Key_ConstList2Iterator_new(GWEN_CRYPT_KEY_CONSTLIST2 *l);
00844
00845 void GWEN_Crypt_Key_ConstList2Iterator_free(GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR *li);
00846
00847 const GWEN_CRYPT_KEY *GWEN_Crypt_Key_ConstList2Iterator_Previous(GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR *li);
00848
00849 const GWEN_CRYPT_KEY *GWEN_Crypt_Key_ConstList2Iterator_Next(GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR *li);
00850
00851 const GWEN_CRYPT_KEY *GWEN_Crypt_Key_ConstList2Iterator_Data(GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR *li);
00852
00864 const GWEN_CRYPT_KEY *GWEN_Crypt_Key_ConstList2_ForEach(GWEN_CRYPT_KEY_CONSTLIST2 *list,
00865 GWEN_CRYPT_KEY_CONSTLIST2_FOREACH func, void *user_data);
00866
00867
00868 #ifdef __cplusplus
00869 }
00870 #endif
00871
00872
00873 #endif
00874
00875
00876
00877
00878
00879
00880
00881
00882
00883
00884
00885
00886
00887
00888
00889
00890
00891
00892
00893
00894
00895
00896
00897
00898
00899
00900
00901
00902
00903
00904
00905 #ifndef GWEN_CRYPT_KEY_LIST1_H
00906 #define GWEN_CRYPT_KEY_LIST1_H
00907
00908 #ifdef __cplusplus
00909 extern "C" {
00910 #endif
00911
00913 typedef struct GWEN_CRYPT_KEY_LIST_ELEMENT {
00914 uint32_t id;
00915 GWEN_CRYPT_KEY *nextObject;
00916 } GWEN_CRYPT_KEY_LIST__ELEMENT;
00917
00924 typedef struct GWEN_CRYPT_KEY_LIST GWEN_CRYPT_KEY_LIST;
00926 struct GWEN_CRYPT_KEY_LIST {
00927 GWEN_CRYPT_KEY *first;
00928 uint32_t count;
00929 uint32_t id;
00930 } GWEN_CRYPT_KEY_LIST;
00931
00936 void GWEN_Crypt_Key_List_AddList(GWEN_CRYPT_KEY_LIST *dst, GWEN_CRYPT_KEY_LIST *l);
00937
00941 void GWEN_Crypt_Key_List_Add(GWEN_CRYPT_KEY *element, GWEN_CRYPT_KEY_LIST *list);
00942
00947 void GWEN_Crypt_Key_List_Insert(GWEN_CRYPT_KEY *element, GWEN_CRYPT_KEY_LIST *list);
00948
00955 void GWEN_Crypt_Key_List_Del(GWEN_CRYPT_KEY *element);
00956
00960 GWEN_CRYPT_KEY* GWEN_Crypt_Key_List_First(const GWEN_CRYPT_KEY_LIST *l);
00961
00965 GWEN_CRYPT_KEY* GWEN_Crypt_Key_List_Last(const GWEN_CRYPT_KEY_LIST *l);
00966
00971 void GWEN_Crypt_Key_List_Clear(GWEN_CRYPT_KEY_LIST *l);
00972
00976 GWEN_CRYPT_KEY_LIST* GWEN_Crypt_Key_List_new();
00977
00981 void GWEN_Crypt_Key_List_free(GWEN_CRYPT_KEY_LIST *l);
00982
00986 GWEN_CRYPT_KEY* GWEN_Crypt_Key_List_Next(const GWEN_CRYPT_KEY *element);
00987
00991 GWEN_CRYPT_KEY* GWEN_Crypt_Key_List_Previous(const GWEN_CRYPT_KEY *element);
00992
00996 uint32_t GWEN_Crypt_Key_List_GetCount(const GWEN_CRYPT_KEY_LIST *l);
00997
00998 #ifdef __cplusplus
00999 }
01000 #endif
01001
01002
01003 #endif
01004
01005
01006
01007
01008
01009
01010
01011
01012
01013
01014
01015
01016
01017
01018
01019
01020
01021
01022
01023
01024
01025
01026
01027
01028
01029
01030
01031
01032
01033
01034
01035 #ifndef GWEN_CRYPT_TOKEN_LIST2_H
01036 #define GWEN_CRYPT_TOKEN_LIST2_H
01037
01038
01039 #ifdef __cplusplus
01040 extern "C" {
01041 #endif
01042
01049 typedef struct GWEN_CRYPT_TOKEN_LIST2 GWEN_CRYPT_TOKEN_LIST2;
01050
01054 typedef struct GWEN_CRYPT_TOKEN_LIST2_ITERATOR GWEN_CRYPT_TOKEN_LIST2_ITERATOR;
01055
01059 typedef GWEN_CRYPT_TOKEN* (GWEN_CRYPT_TOKEN_LIST2_FOREACH)(GWEN_CRYPT_TOKEN *element,
01060 void *user_data);
01061
01065 GWEN_CRYPT_TOKEN_LIST2 *GWEN_Crypt_Token_List2_new();
01066
01070 void GWEN_Crypt_Token_List2_free(GWEN_CRYPT_TOKEN_LIST2 *l);
01071
01075 void GWEN_Crypt_Token_List2_Dump(GWEN_CRYPT_TOKEN_LIST2 *l, FILE *f, unsigned int indent);
01076
01080 void GWEN_Crypt_Token_List2_PushBack(GWEN_CRYPT_TOKEN_LIST2 *l, GWEN_CRYPT_TOKEN *p);
01081
01086 void GWEN_Crypt_Token_List2_PushFront(GWEN_CRYPT_TOKEN_LIST2 *l, GWEN_CRYPT_TOKEN *p);
01087
01092 GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_List2_GetFront(GWEN_CRYPT_TOKEN_LIST2 *l);
01093
01098 GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_List2_GetBack(GWEN_CRYPT_TOKEN_LIST2 *l);
01099
01104 void GWEN_Crypt_Token_List2_Erase(GWEN_CRYPT_TOKEN_LIST2 *l,
01105 GWEN_CRYPT_TOKEN_LIST2_ITERATOR *it);
01106
01112 unsigned int GWEN_Crypt_Token_List2_GetSize(GWEN_CRYPT_TOKEN_LIST2 *l);
01113
01118 void GWEN_Crypt_Token_List2_PopBack(GWEN_CRYPT_TOKEN_LIST2 *l);
01119
01124 void GWEN_Crypt_Token_List2_PopFront(GWEN_CRYPT_TOKEN_LIST2 *l);
01125
01129 void GWEN_Crypt_Token_List2_Clear(GWEN_CRYPT_TOKEN_LIST2 *l);
01130
01134 GWEN_CRYPT_TOKEN_LIST2_ITERATOR *GWEN_Crypt_Token_List2_First(GWEN_CRYPT_TOKEN_LIST2 *l);
01135
01139 GWEN_CRYPT_TOKEN_LIST2_ITERATOR *GWEN_Crypt_Token_List2_Last(GWEN_CRYPT_TOKEN_LIST2 *l);
01140
01144 GWEN_CRYPT_TOKEN_LIST2_ITERATOR *GWEN_Crypt_Token_List2Iterator_new(GWEN_CRYPT_TOKEN_LIST2 *l);
01145
01149 void GWEN_Crypt_Token_List2Iterator_free(GWEN_CRYPT_TOKEN_LIST2_ITERATOR *li);
01150
01155 GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_List2Iterator_Previous(GWEN_CRYPT_TOKEN_LIST2_ITERATOR *li);
01156
01161 GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_List2Iterator_Next(GWEN_CRYPT_TOKEN_LIST2_ITERATOR *li);
01162
01167 GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_List2Iterator_Data(GWEN_CRYPT_TOKEN_LIST2_ITERATOR *li);
01168
01180 GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_List2_ForEach(GWEN_CRYPT_TOKEN_LIST2 *list,
01181 GWEN_CRYPT_TOKEN_LIST2_FOREACH func,
01182 void *user_data);
01183
01184
01185 typedef struct GWEN_CRYPT_TOKEN_CONSTLIST2 GWEN_CRYPT_TOKEN_CONSTLIST2;
01186 typedef struct GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR;
01187 typedef const GWEN_CRYPT_TOKEN*
01188 (GWEN_CRYPT_TOKEN_CONSTLIST2_FOREACH)(const GWEN_CRYPT_TOKEN *element,
01189 void *user_data);
01190
01191
01192 GWEN_CRYPT_TOKEN_CONSTLIST2 *GWEN_Crypt_Token_ConstList2_new();
01193
01194 void GWEN_Crypt_Token_ConstList2_free(GWEN_CRYPT_TOKEN_CONSTLIST2 *l);
01195
01196 void GWEN_Crypt_Token_ConstList2_PushBack(GWEN_CRYPT_TOKEN_CONSTLIST2 *l, const GWEN_CRYPT_TOKEN *p);
01197
01198 void GWEN_Crypt_Token_ConstList2_PushFront(GWEN_CRYPT_TOKEN_CONSTLIST2 *l, const GWEN_CRYPT_TOKEN *p);
01199
01200 const GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_ConstList2_GetFront(GWEN_CRYPT_TOKEN_CONSTLIST2 *l);
01201
01202 const GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_ConstList2_GetBack(GWEN_CRYPT_TOKEN_CONSTLIST2 *l);
01203
01204 unsigned int GWEN_Crypt_Token_ConstList2_GetSize(GWEN_CRYPT_TOKEN_CONSTLIST2 *l);
01205
01206 void GWEN_Crypt_Token_ConstList2_PopBack(GWEN_CRYPT_TOKEN_CONSTLIST2 *l);
01207
01208 void GWEN_Crypt_Token_ConstList2_PopFront(GWEN_CRYPT_TOKEN_CONSTLIST2 *l);
01209
01210 void GWEN_Crypt_Token_ConstList2_Clear(GWEN_CRYPT_TOKEN_CONSTLIST2 *l);
01211
01212 GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_ConstList2_First(GWEN_CRYPT_TOKEN_CONSTLIST2 *l);
01213
01214 GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_ConstList2_Last(GWEN_CRYPT_TOKEN_CONSTLIST2 *l);
01215
01216 GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_ConstList2Iterator_new(GWEN_CRYPT_TOKEN_CONSTLIST2 *l);
01217
01218 void GWEN_Crypt_Token_ConstList2Iterator_free(GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *li);
01219
01220 const GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_ConstList2Iterator_Previous(GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *li);
01221
01222 const GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_ConstList2Iterator_Next(GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *li);
01223
01224 const GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_ConstList2Iterator_Data(GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *li);
01225
01237 const GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_ConstList2_ForEach(GWEN_CRYPT_TOKEN_CONSTLIST2 *list,
01238 GWEN_CRYPT_TOKEN_CONSTLIST2_FOREACH func, void *user_data);
01239
01240
01241 #ifdef __cplusplus
01242 }
01243 #endif
01244
01245
01246 #endif
01247
01248
01249
01250
01251
01252
01253
01254
01255
01256
01257
01258
01259
01260
01261
01262
01263
01264
01265
01266
01267
01268
01269
01270
01271
01272
01273
01274
01275
01276
01277
01278 #ifndef GWEN_CRYPT_TOKEN_LIST1_H
01279 #define GWEN_CRYPT_TOKEN_LIST1_H
01280
01281 #ifdef __cplusplus
01282 extern "C" {
01283 #endif
01284
01286 typedef struct GWEN_CRYPT_TOKEN_LIST_ELEMENT {
01287 uint32_t id;
01288 GWEN_CRYPT_TOKEN *nextObject;
01289 } GWEN_CRYPT_TOKEN_LIST__ELEMENT;
01290
01297 typedef struct GWEN_CRYPT_TOKEN_LIST GWEN_CRYPT_TOKEN_LIST;
01299 struct GWEN_CRYPT_TOKEN_LIST {
01300 GWEN_CRYPT_TOKEN *first;
01301 uint32_t count;
01302 uint32_t id;
01303 } GWEN_CRYPT_TOKEN_LIST;
01304
01309 void GWEN_Crypt_Token_List_AddList(GWEN_CRYPT_TOKEN_LIST *dst, GWEN_CRYPT_TOKEN_LIST *l);
01310
01314 void GWEN_Crypt_Token_List_Add(GWEN_CRYPT_TOKEN *element, GWEN_CRYPT_TOKEN_LIST *list);
01315
01320 void GWEN_Crypt_Token_List_Insert(GWEN_CRYPT_TOKEN *element, GWEN_CRYPT_TOKEN_LIST *list);
01321
01328 void GWEN_Crypt_Token_List_Del(GWEN_CRYPT_TOKEN *element);
01329
01333 GWEN_CRYPT_TOKEN* GWEN_Crypt_Token_List_First(const GWEN_CRYPT_TOKEN_LIST *l);
01334
01338 GWEN_CRYPT_TOKEN* GWEN_Crypt_Token_List_Last(const GWEN_CRYPT_TOKEN_LIST *l);
01339
01344 void GWEN_Crypt_Token_List_Clear(GWEN_CRYPT_TOKEN_LIST *l);
01345
01349 GWEN_CRYPT_TOKEN_LIST* GWEN_Crypt_Token_List_new();
01350
01354 void GWEN_Crypt_Token_List_free(GWEN_CRYPT_TOKEN_LIST *l);
01355
01359 GWEN_CRYPT_TOKEN* GWEN_Crypt_Token_List_Next(const GWEN_CRYPT_TOKEN *element);
01360
01364 GWEN_CRYPT_TOKEN* GWEN_Crypt_Token_List_Previous(const GWEN_CRYPT_TOKEN *element);
01365
01369 uint32_t GWEN_Crypt_Token_List_GetCount(const GWEN_CRYPT_TOKEN_LIST *l);
01370
01371 #ifdef __cplusplus
01372 }
01373 #endif
01374
01375
01376 #endif
01377
01378
01379
01380
01381
01382
01383
01384
01385
01386
01387
01388
01389
01390
01391
01392
01393
01394
01395
01396
01397
01398
01399
01400
01401
01402
01403
01404
01405
01406
01407
01408 #ifndef GWEN_XMLNODE_NAMESPACE_LIST1_H
01409 #define GWEN_XMLNODE_NAMESPACE_LIST1_H
01410
01411 #ifdef __cplusplus
01412 extern "C" {
01413 #endif
01414
01416 typedef struct GWEN_XMLNODE_NAMESPACE_LIST_ELEMENT {
01417 uint32_t id;
01418 GWEN_XMLNODE_NAMESPACE *nextObject;
01419 } GWEN_XMLNODE_NAMESPACE_LIST__ELEMENT;
01420
01427 typedef struct GWEN_XMLNODE_NAMESPACE_LIST GWEN_XMLNODE_NAMESPACE_LIST;
01429 struct GWEN_XMLNODE_NAMESPACE_LIST {
01430 GWEN_XMLNODE_NAMESPACE *first;
01431 uint32_t count;
01432 uint32_t id;
01433 } GWEN_XMLNODE_NAMESPACE_LIST;
01434
01439 void GWEN_XMLNode_NameSpace_List_AddList(GWEN_XMLNODE_NAMESPACE_LIST *dst, GWEN_XMLNODE_NAMESPACE_LIST *l);
01440
01444 void GWEN_XMLNode_NameSpace_List_Add(GWEN_XMLNODE_NAMESPACE *element, GWEN_XMLNODE_NAMESPACE_LIST *list);
01445
01450 void GWEN_XMLNode_NameSpace_List_Insert(GWEN_XMLNODE_NAMESPACE *element, GWEN_XMLNODE_NAMESPACE_LIST *list);
01451
01458 void GWEN_XMLNode_NameSpace_List_Del(GWEN_XMLNODE_NAMESPACE *element);
01459
01463 GWEN_XMLNODE_NAMESPACE* GWEN_XMLNode_NameSpace_List_First(const GWEN_XMLNODE_NAMESPACE_LIST *l);
01464
01468 GWEN_XMLNODE_NAMESPACE* GWEN_XMLNode_NameSpace_List_Last(const GWEN_XMLNODE_NAMESPACE_LIST *l);
01469
01474 void GWEN_XMLNode_NameSpace_List_Clear(GWEN_XMLNODE_NAMESPACE_LIST *l);
01475
01479 GWEN_XMLNODE_NAMESPACE_LIST* GWEN_XMLNode_NameSpace_List_new();
01480
01484 void GWEN_XMLNode_NameSpace_List_free(GWEN_XMLNODE_NAMESPACE_LIST *l);
01485
01489 GWEN_XMLNODE_NAMESPACE* GWEN_XMLNode_NameSpace_List_Next(const GWEN_XMLNODE_NAMESPACE *element);
01490
01494 GWEN_XMLNODE_NAMESPACE* GWEN_XMLNode_NameSpace_List_Previous(const GWEN_XMLNODE_NAMESPACE *element);
01495
01499 uint32_t GWEN_XMLNode_NameSpace_List_GetCount(const GWEN_XMLNODE_NAMESPACE_LIST *l);
01500
01501 #ifdef __cplusplus
01502 }
01503 #endif
01504
01505
01506 #endif
01507
01508
01509
01510
01511
01512
01513
01514
01515
01516
01517
01518
01519
01520
01521
01522
01523
01524
01525
01526
01527
01528
01529
01530
01531
01532
01533
01534
01535
01536
01537
01538 #ifndef GWEN_XMLNODE_LIST2_H
01539 #define GWEN_XMLNODE_LIST2_H
01540
01541
01542 #ifdef __cplusplus
01543 extern "C" {
01544 #endif
01545
01552 typedef struct GWEN_XMLNODE_LIST2 GWEN_XMLNODE_LIST2;
01553
01557 typedef struct GWEN_XMLNODE_LIST2_ITERATOR GWEN_XMLNODE_LIST2_ITERATOR;
01558
01562 typedef GWEN_XMLNODE* (GWEN_XMLNODE_LIST2_FOREACH)(GWEN_XMLNODE *element,
01563 void *user_data);
01564
01568 GWEN_XMLNODE_LIST2 *GWEN_XMLNode_List2_new();
01569
01573 void GWEN_XMLNode_List2_free(GWEN_XMLNODE_LIST2 *l);
01574
01578 void GWEN_XMLNode_List2_Dump(GWEN_XMLNODE_LIST2 *l, FILE *f, unsigned int indent);
01579
01583 void GWEN_XMLNode_List2_PushBack(GWEN_XMLNODE_LIST2 *l, GWEN_XMLNODE *p);
01584
01589 void GWEN_XMLNode_List2_PushFront(GWEN_XMLNODE_LIST2 *l, GWEN_XMLNODE *p);
01590
01595 GWEN_XMLNODE *GWEN_XMLNode_List2_GetFront(GWEN_XMLNODE_LIST2 *l);
01596
01601 GWEN_XMLNODE *GWEN_XMLNode_List2_GetBack(GWEN_XMLNODE_LIST2 *l);
01602
01607 void GWEN_XMLNode_List2_Erase(GWEN_XMLNODE_LIST2 *l,
01608 GWEN_XMLNODE_LIST2_ITERATOR *it);
01609
01615 unsigned int GWEN_XMLNode_List2_GetSize(GWEN_XMLNODE_LIST2 *l);
01616
01621 void GWEN_XMLNode_List2_PopBack(GWEN_XMLNODE_LIST2 *l);
01622
01627 void GWEN_XMLNode_List2_PopFront(GWEN_XMLNODE_LIST2 *l);
01628
01632 void GWEN_XMLNode_List2_Clear(GWEN_XMLNODE_LIST2 *l);
01633
01637 GWEN_XMLNODE_LIST2_ITERATOR *GWEN_XMLNode_List2_First(GWEN_XMLNODE_LIST2 *l);
01638
01642 GWEN_XMLNODE_LIST2_ITERATOR *GWEN_XMLNode_List2_Last(GWEN_XMLNODE_LIST2 *l);
01643
01647 GWEN_XMLNODE_LIST2_ITERATOR *GWEN_XMLNode_List2Iterator_new(GWEN_XMLNODE_LIST2 *l);
01648
01652 void GWEN_XMLNode_List2Iterator_free(GWEN_XMLNODE_LIST2_ITERATOR *li);
01653
01658 GWEN_XMLNODE *GWEN_XMLNode_List2Iterator_Previous(GWEN_XMLNODE_LIST2_ITERATOR *li);
01659
01664 GWEN_XMLNODE *GWEN_XMLNode_List2Iterator_Next(GWEN_XMLNODE_LIST2_ITERATOR *li);
01665
01670 GWEN_XMLNODE *GWEN_XMLNode_List2Iterator_Data(GWEN_XMLNODE_LIST2_ITERATOR *li);
01671
01683 GWEN_XMLNODE *GWEN_XMLNode_List2_ForEach(GWEN_XMLNODE_LIST2 *list,
01684 GWEN_XMLNODE_LIST2_FOREACH func,
01685 void *user_data);
01686
01687
01688 typedef struct GWEN_XMLNODE_CONSTLIST2 GWEN_XMLNODE_CONSTLIST2;
01689 typedef struct GWEN_XMLNODE_CONSTLIST2_ITERATOR GWEN_XMLNODE_CONSTLIST2_ITERATOR;
01690 typedef const GWEN_XMLNODE*
01691 (GWEN_XMLNODE_CONSTLIST2_FOREACH)(const GWEN_XMLNODE *element,
01692 void *user_data);
01693
01694
01695 GWEN_XMLNODE_CONSTLIST2 *GWEN_XMLNode_ConstList2_new();
01696
01697 void GWEN_XMLNode_ConstList2_free(GWEN_XMLNODE_CONSTLIST2 *l);
01698
01699 void GWEN_XMLNode_ConstList2_PushBack(GWEN_XMLNODE_CONSTLIST2 *l, const GWEN_XMLNODE *p);
01700
01701 void GWEN_XMLNode_ConstList2_PushFront(GWEN_XMLNODE_CONSTLIST2 *l, const GWEN_XMLNODE *p);
01702
01703 const GWEN_XMLNODE *GWEN_XMLNode_ConstList2_GetFront(GWEN_XMLNODE_CONSTLIST2 *l);
01704
01705 const GWEN_XMLNODE *GWEN_XMLNode_ConstList2_GetBack(GWEN_XMLNODE_CONSTLIST2 *l);
01706
01707 unsigned int GWEN_XMLNode_ConstList2_GetSize(GWEN_XMLNODE_CONSTLIST2 *l);
01708
01709 void GWEN_XMLNode_ConstList2_PopBack(GWEN_XMLNODE_CONSTLIST2 *l);
01710
01711 void GWEN_XMLNode_ConstList2_PopFront(GWEN_XMLNODE_CONSTLIST2 *l);
01712
01713 void GWEN_XMLNode_ConstList2_Clear(GWEN_XMLNODE_CONSTLIST2 *l);
01714
01715 GWEN_XMLNODE_CONSTLIST2_ITERATOR *GWEN_XMLNode_ConstList2_First(GWEN_XMLNODE_CONSTLIST2 *l);
01716
01717 GWEN_XMLNODE_CONSTLIST2_ITERATOR *GWEN_XMLNode_ConstList2_Last(GWEN_XMLNODE_CONSTLIST2 *l);
01718
01719 GWEN_XMLNODE_CONSTLIST2_ITERATOR *GWEN_XMLNode_ConstList2Iterator_new(GWEN_XMLNODE_CONSTLIST2 *l);
01720
01721 void GWEN_XMLNode_ConstList2Iterator_free(GWEN_XMLNODE_CONSTLIST2_ITERATOR *li);
01722
01723 const GWEN_XMLNODE *GWEN_XMLNode_ConstList2Iterator_Previous(GWEN_XMLNODE_CONSTLIST2_ITERATOR *li);
01724
01725 const GWEN_XMLNODE *GWEN_XMLNode_ConstList2Iterator_Next(GWEN_XMLNODE_CONSTLIST2_ITERATOR *li);
01726
01727 const GWEN_XMLNODE *GWEN_XMLNode_ConstList2Iterator_Data(GWEN_XMLNODE_CONSTLIST2_ITERATOR *li);
01728
01740 const GWEN_XMLNODE *GWEN_XMLNode_ConstList2_ForEach(GWEN_XMLNODE_CONSTLIST2 *list,
01741 GWEN_XMLNODE_CONSTLIST2_FOREACH func, void *user_data);
01742
01743
01744 #ifdef __cplusplus
01745 }
01746 #endif
01747
01748
01749 #endif
01750
01751
01752
01753
01754
01755
01756
01757
01758
01759
01760
01761
01762
01763
01764
01765
01766
01767
01768
01769
01770
01771
01772
01773
01774
01775
01776
01777
01778
01779
01780
01781 #ifndef GWEN_XMLNODE_LIST1_H
01782 #define GWEN_XMLNODE_LIST1_H
01783
01784 #ifdef __cplusplus
01785 extern "C" {
01786 #endif
01787
01789 typedef struct GWEN_XMLNODE_LIST_ELEMENT {
01790 uint32_t id;
01791 GWEN_XMLNODE *nextObject;
01792 } GWEN_XMLNODE_LIST__ELEMENT;
01793
01800 typedef struct GWEN_XMLNODE_LIST GWEN_XMLNODE_LIST;
01802 struct GWEN_XMLNODE_LIST {
01803 GWEN_XMLNODE *first;
01804 uint32_t count;
01805 uint32_t id;
01806 } GWEN_XMLNODE_LIST;
01807
01812 void GWEN_XMLNode_List_AddList(GWEN_XMLNODE_LIST *dst, GWEN_XMLNODE_LIST *l);
01813
01817 void GWEN_XMLNode_List_Add(GWEN_XMLNODE *element, GWEN_XMLNODE_LIST *list);
01818
01823 void GWEN_XMLNode_List_Insert(GWEN_XMLNODE *element, GWEN_XMLNODE_LIST *list);
01824
01831 void GWEN_XMLNode_List_Del(GWEN_XMLNODE *element);
01832
01836 GWEN_XMLNODE* GWEN_XMLNode_List_First(const GWEN_XMLNODE_LIST *l);
01837
01841 GWEN_XMLNODE* GWEN_XMLNode_List_Last(const GWEN_XMLNODE_LIST *l);
01842
01847 void GWEN_XMLNode_List_Clear(GWEN_XMLNODE_LIST *l);
01848
01852 GWEN_XMLNODE_LIST* GWEN_XMLNode_List_new();
01853
01857 void GWEN_XMLNode_List_free(GWEN_XMLNODE_LIST *l);
01858
01862 GWEN_XMLNODE* GWEN_XMLNode_List_Next(const GWEN_XMLNODE *element);
01863
01867 GWEN_XMLNODE* GWEN_XMLNode_List_Previous(const GWEN_XMLNODE *element);
01868
01872 uint32_t GWEN_XMLNode_List_GetCount(const GWEN_XMLNODE_LIST *l);
01873
01874 #ifdef __cplusplus
01875 }
01876 #endif
01877
01878
01879 #endif
01880
01881
01882
01883
01884
01885
01886
01887
01888
01889
01890
01891
01892
01893
01894
01895
01896
01897
01898
01899
01900
01901
01902
01903
01904
01905
01906
01907
01908
01909
01910
01911 #ifndef GWEN_CRYPTHEAD_LIST1_H
01912 #define GWEN_CRYPTHEAD_LIST1_H
01913
01914 #ifdef __cplusplus
01915 extern "C" {
01916 #endif
01917
01919 typedef struct GWEN_CRYPTHEAD_LIST_ELEMENT {
01920 uint32_t id;
01921 GWEN_CRYPTHEAD *nextObject;
01922 } GWEN_CRYPTHEAD_LIST__ELEMENT;
01923
01930 typedef struct GWEN_CRYPTHEAD_LIST GWEN_CRYPTHEAD_LIST;
01932 struct GWEN_CRYPTHEAD_LIST {
01933 GWEN_CRYPTHEAD *first;
01934 uint32_t count;
01935 uint32_t id;
01936 } GWEN_CRYPTHEAD_LIST;
01937
01942 void GWEN_CryptHead_List_AddList(GWEN_CRYPTHEAD_LIST *dst, GWEN_CRYPTHEAD_LIST *l);
01943
01947 void GWEN_CryptHead_List_Add(GWEN_CRYPTHEAD *element, GWEN_CRYPTHEAD_LIST *list);
01948
01953 void GWEN_CryptHead_List_Insert(GWEN_CRYPTHEAD *element, GWEN_CRYPTHEAD_LIST *list);
01954
01961 void GWEN_CryptHead_List_Del(GWEN_CRYPTHEAD *element);
01962
01966 GWEN_CRYPTHEAD* GWEN_CryptHead_List_First(const GWEN_CRYPTHEAD_LIST *l);
01967
01971 GWEN_CRYPTHEAD* GWEN_CryptHead_List_Last(const GWEN_CRYPTHEAD_LIST *l);
01972
01977 void GWEN_CryptHead_List_Clear(GWEN_CRYPTHEAD_LIST *l);
01978
01982 GWEN_CRYPTHEAD_LIST* GWEN_CryptHead_List_new();
01983
01987 void GWEN_CryptHead_List_free(GWEN_CRYPTHEAD_LIST *l);
01988
01992 GWEN_CRYPTHEAD* GWEN_CryptHead_List_Next(const GWEN_CRYPTHEAD *element);
01993
01997 GWEN_CRYPTHEAD* GWEN_CryptHead_List_Previous(const GWEN_CRYPTHEAD *element);
01998
02002 uint32_t GWEN_CryptHead_List_GetCount(const GWEN_CRYPTHEAD_LIST *l);
02003
02004 #ifdef __cplusplus
02005 }
02006 #endif
02007
02008
02009 #endif
02010
02011
02012
02013
02014
02015
02016
02017
02018
02019
02020
02021
02022
02023
02024
02025
02026
02027
02028
02029
02030
02031
02032
02033
02034
02035
02036
02037
02038
02039
02040
02041 #ifndef GWEN_CRYPT_PADDALGO_LIST2_H
02042 #define GWEN_CRYPT_PADDALGO_LIST2_H
02043
02044
02045 #ifdef __cplusplus
02046 extern "C" {
02047 #endif
02048
02055 typedef struct GWEN_CRYPT_PADDALGO_LIST2 GWEN_CRYPT_PADDALGO_LIST2;
02056
02060 typedef struct GWEN_CRYPT_PADDALGO_LIST2_ITERATOR GWEN_CRYPT_PADDALGO_LIST2_ITERATOR;
02061
02065 typedef GWEN_CRYPT_PADDALGO* (GWEN_CRYPT_PADDALGO_LIST2_FOREACH)(GWEN_CRYPT_PADDALGO *element,
02066 void *user_data);
02067
02071 GWEN_CRYPT_PADDALGO_LIST2 *GWEN_Crypt_PaddAlgo_List2_new();
02072
02076 void GWEN_Crypt_PaddAlgo_List2_free(GWEN_CRYPT_PADDALGO_LIST2 *l);
02077
02081 void GWEN_Crypt_PaddAlgo_List2_Dump(GWEN_CRYPT_PADDALGO_LIST2 *l, FILE *f, unsigned int indent);
02082
02086 void GWEN_Crypt_PaddAlgo_List2_PushBack(GWEN_CRYPT_PADDALGO_LIST2 *l, GWEN_CRYPT_PADDALGO *p);
02087
02092 void GWEN_Crypt_PaddAlgo_List2_PushFront(GWEN_CRYPT_PADDALGO_LIST2 *l, GWEN_CRYPT_PADDALGO *p);
02093
02098 GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_List2_GetFront(GWEN_CRYPT_PADDALGO_LIST2 *l);
02099
02104 GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_List2_GetBack(GWEN_CRYPT_PADDALGO_LIST2 *l);
02105
02110 void GWEN_Crypt_PaddAlgo_List2_Erase(GWEN_CRYPT_PADDALGO_LIST2 *l,
02111 GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *it);
02112
02118 unsigned int GWEN_Crypt_PaddAlgo_List2_GetSize(GWEN_CRYPT_PADDALGO_LIST2 *l);
02119
02124 void GWEN_Crypt_PaddAlgo_List2_PopBack(GWEN_CRYPT_PADDALGO_LIST2 *l);
02125
02130 void GWEN_Crypt_PaddAlgo_List2_PopFront(GWEN_CRYPT_PADDALGO_LIST2 *l);
02131
02135 void GWEN_Crypt_PaddAlgo_List2_Clear(GWEN_CRYPT_PADDALGO_LIST2 *l);
02136
02140 GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *GWEN_Crypt_PaddAlgo_List2_First(GWEN_CRYPT_PADDALGO_LIST2 *l);
02141
02145 GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *GWEN_Crypt_PaddAlgo_List2_Last(GWEN_CRYPT_PADDALGO_LIST2 *l);
02146
02150 GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *GWEN_Crypt_PaddAlgo_List2Iterator_new(GWEN_CRYPT_PADDALGO_LIST2 *l);
02151
02155 void GWEN_Crypt_PaddAlgo_List2Iterator_free(GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *li);
02156
02161 GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_List2Iterator_Previous(GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *li);
02162
02167 GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_List2Iterator_Next(GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *li);
02168
02173 GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_List2Iterator_Data(GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *li);
02174
02186 GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_List2_ForEach(GWEN_CRYPT_PADDALGO_LIST2 *list,
02187 GWEN_CRYPT_PADDALGO_LIST2_FOREACH func,
02188 void *user_data);
02189
02190
02191 typedef struct GWEN_CRYPT_PADDALGO_CONSTLIST2 GWEN_CRYPT_PADDALGO_CONSTLIST2;
02192 typedef struct GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR;
02193 typedef const GWEN_CRYPT_PADDALGO*
02194 (GWEN_CRYPT_PADDALGO_CONSTLIST2_FOREACH)(const GWEN_CRYPT_PADDALGO *element,
02195 void *user_data);
02196
02197
02198 GWEN_CRYPT_PADDALGO_CONSTLIST2 *GWEN_Crypt_PaddAlgo_ConstList2_new();
02199
02200 void GWEN_Crypt_PaddAlgo_ConstList2_free(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l);
02201
02202 void GWEN_Crypt_PaddAlgo_ConstList2_PushBack(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l, const GWEN_CRYPT_PADDALGO *p);
02203
02204 void GWEN_Crypt_PaddAlgo_ConstList2_PushFront(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l, const GWEN_CRYPT_PADDALGO *p);
02205
02206 const GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_ConstList2_GetFront(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l);
02207
02208 const GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_ConstList2_GetBack(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l);
02209
02210 unsigned int GWEN_Crypt_PaddAlgo_ConstList2_GetSize(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l);
02211
02212 void GWEN_Crypt_PaddAlgo_ConstList2_PopBack(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l);
02213
02214 void GWEN_Crypt_PaddAlgo_ConstList2_PopFront(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l);
02215
02216 void GWEN_Crypt_PaddAlgo_ConstList2_Clear(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l);
02217
02218 GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_PaddAlgo_ConstList2_First(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l);
02219
02220 GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_PaddAlgo_ConstList2_Last(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l);
02221
02222 GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_PaddAlgo_ConstList2Iterator_new(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l);
02223
02224 void GWEN_Crypt_PaddAlgo_ConstList2Iterator_free(GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR *li);
02225
02226 const GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_ConstList2Iterator_Previous(GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR *li);
02227
02228 const GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_ConstList2Iterator_Next(GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR *li);
02229
02230 const GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_ConstList2Iterator_Data(GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR *li);
02231
02243 const GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_ConstList2_ForEach(GWEN_CRYPT_PADDALGO_CONSTLIST2 *list,
02244 GWEN_CRYPT_PADDALGO_CONSTLIST2_FOREACH func, void *user_data);
02245
02246
02247 #ifdef __cplusplus
02248 }
02249 #endif
02250
02251
02252 #endif
02253
02254
02255
02256
02257
02258
02259
02260
02261
02262
02263
02264
02265
02266
02267
02268
02269
02270
02271
02272
02273
02274
02275
02276
02277
02278
02279
02280
02281
02282
02283
02284 #ifndef GWEN_CRYPT_CRYPTALGO_LIST2_H
02285 #define GWEN_CRYPT_CRYPTALGO_LIST2_H
02286
02287
02288 #ifdef __cplusplus
02289 extern "C" {
02290 #endif
02291
02298 typedef struct GWEN_CRYPT_CRYPTALGO_LIST2 GWEN_CRYPT_CRYPTALGO_LIST2;
02299
02303 typedef struct GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR;
02304
02308 typedef GWEN_CRYPT_CRYPTALGO* (GWEN_CRYPT_CRYPTALGO_LIST2_FOREACH)(GWEN_CRYPT_CRYPTALGO *element,
02309 void *user_data);
02310
02314 GWEN_CRYPT_CRYPTALGO_LIST2 *GWEN_Crypt_CryptAlgo_List2_new();
02315
02319 void GWEN_Crypt_CryptAlgo_List2_free(GWEN_CRYPT_CRYPTALGO_LIST2 *l);
02320
02324 void GWEN_Crypt_CryptAlgo_List2_Dump(GWEN_CRYPT_CRYPTALGO_LIST2 *l, FILE *f, unsigned int indent);
02325
02329 void GWEN_Crypt_CryptAlgo_List2_PushBack(GWEN_CRYPT_CRYPTALGO_LIST2 *l, GWEN_CRYPT_CRYPTALGO *p);
02330
02335 void GWEN_Crypt_CryptAlgo_List2_PushFront(GWEN_CRYPT_CRYPTALGO_LIST2 *l, GWEN_CRYPT_CRYPTALGO *p);
02336
02341 GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_List2_GetFront(GWEN_CRYPT_CRYPTALGO_LIST2 *l);
02342
02347 GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_List2_GetBack(GWEN_CRYPT_CRYPTALGO_LIST2 *l);
02348
02353 void GWEN_Crypt_CryptAlgo_List2_Erase(GWEN_CRYPT_CRYPTALGO_LIST2 *l,
02354 GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *it);
02355
02361 unsigned int GWEN_Crypt_CryptAlgo_List2_GetSize(GWEN_CRYPT_CRYPTALGO_LIST2 *l);
02362
02367 void GWEN_Crypt_CryptAlgo_List2_PopBack(GWEN_CRYPT_CRYPTALGO_LIST2 *l);
02368
02373 void GWEN_Crypt_CryptAlgo_List2_PopFront(GWEN_CRYPT_CRYPTALGO_LIST2 *l);
02374
02378 void GWEN_Crypt_CryptAlgo_List2_Clear(GWEN_CRYPT_CRYPTALGO_LIST2 *l);
02379
02383 GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *GWEN_Crypt_CryptAlgo_List2_First(GWEN_CRYPT_CRYPTALGO_LIST2 *l);
02384
02388 GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *GWEN_Crypt_CryptAlgo_List2_Last(GWEN_CRYPT_CRYPTALGO_LIST2 *l);
02389
02393 GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *GWEN_Crypt_CryptAlgo_List2Iterator_new(GWEN_CRYPT_CRYPTALGO_LIST2 *l);
02394
02398 void GWEN_Crypt_CryptAlgo_List2Iterator_free(GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *li);
02399
02404 GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_List2Iterator_Previous(GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *li);
02405
02410 GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_List2Iterator_Next(GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *li);
02411
02416 GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_List2Iterator_Data(GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *li);
02417
02429 GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_List2_ForEach(GWEN_CRYPT_CRYPTALGO_LIST2 *list,
02430 GWEN_CRYPT_CRYPTALGO_LIST2_FOREACH func,
02431 void *user_data);
02432
02433
02434 typedef struct GWEN_CRYPT_CRYPTALGO_CONSTLIST2 GWEN_CRYPT_CRYPTALGO_CONSTLIST2;
02435 typedef struct GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR;
02436 typedef const GWEN_CRYPT_CRYPTALGO*
02437 (GWEN_CRYPT_CRYPTALGO_CONSTLIST2_FOREACH)(const GWEN_CRYPT_CRYPTALGO *element,
02438 void *user_data);
02439
02440
02441 GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *GWEN_Crypt_CryptAlgo_ConstList2_new();
02442
02443 void GWEN_Crypt_CryptAlgo_ConstList2_free(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l);
02444
02445 void GWEN_Crypt_CryptAlgo_ConstList2_PushBack(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l, const GWEN_CRYPT_CRYPTALGO *p);
02446
02447 void GWEN_Crypt_CryptAlgo_ConstList2_PushFront(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l, const GWEN_CRYPT_CRYPTALGO *p);
02448
02449 const GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_ConstList2_GetFront(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l);
02450
02451 const GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_ConstList2_GetBack(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l);
02452
02453 unsigned int GWEN_Crypt_CryptAlgo_ConstList2_GetSize(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l);
02454
02455 void GWEN_Crypt_CryptAlgo_ConstList2_PopBack(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l);
02456
02457 void GWEN_Crypt_CryptAlgo_ConstList2_PopFront(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l);
02458
02459 void GWEN_Crypt_CryptAlgo_ConstList2_Clear(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l);
02460
02461 GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_CryptAlgo_ConstList2_First(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l);
02462
02463 GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_CryptAlgo_ConstList2_Last(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l);
02464
02465 GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_CryptAlgo_ConstList2Iterator_new(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l);
02466
02467 void GWEN_Crypt_CryptAlgo_ConstList2Iterator_free(GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR *li);
02468
02469 const GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_ConstList2Iterator_Previous(GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR *li);
02470
02471 const GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_ConstList2Iterator_Next(GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR *li);
02472
02473 const GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_ConstList2Iterator_Data(GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR *li);
02474
02486 const GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_ConstList2_ForEach(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *list,
02487 GWEN_CRYPT_CRYPTALGO_CONSTLIST2_FOREACH func, void *user_data);
02488
02489
02490 #ifdef __cplusplus
02491 }
02492 #endif
02493
02494
02495 #endif
02496
02497
02498
02499
02500
02501
02502
02503
02504
02505
02506
02507
02508
02509
02510
02511
02512
02513
02514
02515
02516
02517
02518
02519
02520
02521
02522
02523
02524
02525
02526
02527 #ifndef GWEN_INHERITDATA_LIST1_H
02528 #define GWEN_INHERITDATA_LIST1_H
02529
02530 #ifdef __cplusplus
02531 extern "C" {
02532 #endif
02533
02535 typedef struct GWEN_INHERITDATA_LIST_ELEMENT {
02536 uint32_t id;
02537 GWEN_INHERITDATA *nextObject;
02538 } GWEN_INHERITDATA_LIST__ELEMENT;
02539
02546 typedef struct GWEN_INHERITDATA_LIST GWEN_INHERITDATA_LIST;
02548 struct GWEN_INHERITDATA_LIST {
02549 GWEN_INHERITDATA *first;
02550 uint32_t count;
02551 uint32_t id;
02552 } GWEN_INHERITDATA_LIST;
02553
02558 void GWEN_InheritData_List_AddList(GWEN_INHERITDATA_LIST *dst, GWEN_INHERITDATA_LIST *l);
02559
02563 void GWEN_InheritData_List_Add(GWEN_INHERITDATA *element, GWEN_INHERITDATA_LIST *list);
02564
02569 void GWEN_InheritData_List_Insert(GWEN_INHERITDATA *element, GWEN_INHERITDATA_LIST *list);
02570
02577 void GWEN_InheritData_List_Del(GWEN_INHERITDATA *element);
02578
02582 GWEN_INHERITDATA* GWEN_InheritData_List_First(const GWEN_INHERITDATA_LIST *l);
02583
02587 GWEN_INHERITDATA* GWEN_InheritData_List_Last(const GWEN_INHERITDATA_LIST *l);
02588
02593 void GWEN_InheritData_List_Clear(GWEN_INHERITDATA_LIST *l);
02594
02598 GWEN_INHERITDATA_LIST* GWEN_InheritData_List_new();
02599
02603 void GWEN_InheritData_List_free(GWEN_INHERITDATA_LIST *l);
02604
02608 GWEN_INHERITDATA* GWEN_InheritData_List_Next(const GWEN_INHERITDATA *element);
02609
02613 GWEN_INHERITDATA* GWEN_InheritData_List_Previous(const GWEN_INHERITDATA *element);
02614
02618 uint32_t GWEN_InheritData_List_GetCount(const GWEN_INHERITDATA_LIST *l);
02619
02620 #ifdef __cplusplus
02621 }
02622 #endif
02623
02624
02625 #endif
02626
02627
02628
02629
02630
02631
02632
02633
02634
02635
02636
02637
02638
02639
02640
02641
02642
02643
02644
02645
02646
02647
02648
02649
02650
02651
02652
02653
02654
02655
02656
02657 #ifndef t_LIST1_H
02658 #define t_LIST1_H
02659
02660 #ifdef __cplusplus
02661 extern "C" {
02662 #endif
02663
02665 typedef struct t_LIST_ELEMENT {
02666 uint32_t id;
02667 t *nextObject;
02668 } t_LIST__ELEMENT;
02669
02676 typedef struct t_LIST t_LIST;
02678 struct t_LIST {
02679 t *first;
02680 uint32_t count;
02681 uint32_t id;
02682 } t_LIST;
02683
02688 void pr_List_AddList(t_LIST *dst, t_LIST *l);
02689
02693 void pr_List_Add(t *element, t_LIST *list);
02694
02699 void pr_List_Insert(t *element, t_LIST *list);
02700
02707 void pr_List_Del(t *element);
02708
02712 t* pr_List_First(const t_LIST *l);
02713
02717 t* pr_List_Last(const t_LIST *l);
02718
02723 void pr_List_Clear(t_LIST *l);
02724
02728 t_LIST* pr_List_new();
02729
02733 void pr_List_free(t_LIST *l);
02734
02738 t* pr_List_Next(const t *element);
02739
02743 t* pr_List_Previous(const t *element);
02744
02748 uint32_t pr_List_GetCount(const t_LIST *l);
02749
02750 #ifdef __cplusplus
02751 }
02752 #endif
02753
02754
02755 #endif
02756
02757
02758
02759
02760
02761
02762
02763
02764
02765
02766
02767
02768
02769
02770
02771
02772
02773
02774
02775
02776
02777
02778
02779
02780
02781
02782
02783
02784
02785
02786
02787 #ifndef MYSTRUCT_LIST1_H
02788 #define MYSTRUCT_LIST1_H
02789
02790 #ifdef __cplusplus
02791 extern "C" {
02792 #endif
02793
02795 typedef struct MYSTRUCT_LIST_ELEMENT {
02796 uint32_t id;
02797 MYSTRUCT *nextObject;
02798 } MYSTRUCT_LIST__ELEMENT;
02799
02806 typedef struct MYSTRUCT_LIST MYSTRUCT_LIST;
02808 struct MYSTRUCT_LIST {
02809 MYSTRUCT *first;
02810 uint32_t count;
02811 uint32_t id;
02812 } MYSTRUCT_LIST;
02813
02818 void MyStruct_List_AddList(MYSTRUCT_LIST *dst, MYSTRUCT_LIST *l);
02819
02823 void MyStruct_List_Add(MYSTRUCT *element, MYSTRUCT_LIST *list);
02824
02829 void MyStruct_List_Insert(MYSTRUCT *element, MYSTRUCT_LIST *list);
02830
02837 void MyStruct_List_Del(MYSTRUCT *element);
02838
02842 MYSTRUCT* MyStruct_List_First(const MYSTRUCT_LIST *l);
02843
02847 MYSTRUCT* MyStruct_List_Last(const MYSTRUCT_LIST *l);
02848
02853 void MyStruct_List_Clear(MYSTRUCT_LIST *l);
02854
02858 MYSTRUCT_LIST* MyStruct_List_new();
02859
02863 void MyStruct_List_free(MYSTRUCT_LIST *l);
02864
02868 MYSTRUCT* MyStruct_List_Next(const MYSTRUCT *element);
02869
02873 MYSTRUCT* MyStruct_List_Previous(const MYSTRUCT *element);
02874
02878 uint32_t MyStruct_List_GetCount(const MYSTRUCT_LIST *l);
02879
02880 #ifdef __cplusplus
02881 }
02882 #endif
02883
02884
02885 #endif
02886
02887
02888
02889
02890
02891
02892
02893
02894
02895
02896
02897
02898
02899
02900
02901
02902
02903
02904
02905
02906
02907
02908
02909
02910
02911
02912
02913
02914
02915
02916
02917 #ifndef GWEN_FSLOCK_LIST2_H
02918 #define GWEN_FSLOCK_LIST2_H
02919
02920
02921 #ifdef __cplusplus
02922 extern "C" {
02923 #endif
02924
02931 typedef struct GWEN_FSLOCK_LIST2 GWEN_FSLOCK_LIST2;
02932
02936 typedef struct GWEN_FSLOCK_LIST2_ITERATOR GWEN_FSLOCK_LIST2_ITERATOR;
02937
02941 typedef GWEN_FSLOCK* (GWEN_FSLOCK_LIST2_FOREACH)(GWEN_FSLOCK *element,
02942 void *user_data);
02943
02947 GWEN_FSLOCK_LIST2 *GWEN_FSLock_List2_new();
02948
02952 void GWEN_FSLock_List2_free(GWEN_FSLOCK_LIST2 *l);
02953
02957 void GWEN_FSLock_List2_Dump(GWEN_FSLOCK_LIST2 *l, FILE *f, unsigned int indent);
02958
02962 void GWEN_FSLock_List2_PushBack(GWEN_FSLOCK_LIST2 *l, GWEN_FSLOCK *p);
02963
02968 void GWEN_FSLock_List2_PushFront(GWEN_FSLOCK_LIST2 *l, GWEN_FSLOCK *p);
02969
02974 GWEN_FSLOCK *GWEN_FSLock_List2_GetFront(GWEN_FSLOCK_LIST2 *l);
02975
02980 GWEN_FSLOCK *GWEN_FSLock_List2_GetBack(GWEN_FSLOCK_LIST2 *l);
02981
02986 void GWEN_FSLock_List2_Erase(GWEN_FSLOCK_LIST2 *l,
02987 GWEN_FSLOCK_LIST2_ITERATOR *it);
02988
02994 unsigned int GWEN_FSLock_List2_GetSize(GWEN_FSLOCK_LIST2 *l);
02995
03000 void GWEN_FSLock_List2_PopBack(GWEN_FSLOCK_LIST2 *l);
03001
03006 void GWEN_FSLock_List2_PopFront(GWEN_FSLOCK_LIST2 *l);
03007
03011 void GWEN_FSLock_List2_Clear(GWEN_FSLOCK_LIST2 *l);
03012
03016 GWEN_FSLOCK_LIST2_ITERATOR *GWEN_FSLock_List2_First(GWEN_FSLOCK_LIST2 *l);
03017
03021 GWEN_FSLOCK_LIST2_ITERATOR *GWEN_FSLock_List2_Last(GWEN_FSLOCK_LIST2 *l);
03022
03026 GWEN_FSLOCK_LIST2_ITERATOR *GWEN_FSLock_List2Iterator_new(GWEN_FSLOCK_LIST2 *l);
03027
03031 void GWEN_FSLock_List2Iterator_free(GWEN_FSLOCK_LIST2_ITERATOR *li);
03032
03037 GWEN_FSLOCK *GWEN_FSLock_List2Iterator_Previous(GWEN_FSLOCK_LIST2_ITERATOR *li);
03038
03043 GWEN_FSLOCK *GWEN_FSLock_List2Iterator_Next(GWEN_FSLOCK_LIST2_ITERATOR *li);
03044
03049 GWEN_FSLOCK *GWEN_FSLock_List2Iterator_Data(GWEN_FSLOCK_LIST2_ITERATOR *li);
03050
03062 GWEN_FSLOCK *GWEN_FSLock_List2_ForEach(GWEN_FSLOCK_LIST2 *list,
03063 GWEN_FSLOCK_LIST2_FOREACH func,
03064 void *user_data);
03065
03066
03067 typedef struct GWEN_FSLOCK_CONSTLIST2 GWEN_FSLOCK_CONSTLIST2;
03068 typedef struct GWEN_FSLOCK_CONSTLIST2_ITERATOR GWEN_FSLOCK_CONSTLIST2_ITERATOR;
03069 typedef const GWEN_FSLOCK*
03070 (GWEN_FSLOCK_CONSTLIST2_FOREACH)(const GWEN_FSLOCK *element,
03071 void *user_data);
03072
03073
03074 GWEN_FSLOCK_CONSTLIST2 *GWEN_FSLock_ConstList2_new();
03075
03076 void GWEN_FSLock_ConstList2_free(GWEN_FSLOCK_CONSTLIST2 *l);
03077
03078 void GWEN_FSLock_ConstList2_PushBack(GWEN_FSLOCK_CONSTLIST2 *l, const GWEN_FSLOCK *p);
03079
03080 void GWEN_FSLock_ConstList2_PushFront(GWEN_FSLOCK_CONSTLIST2 *l, const GWEN_FSLOCK *p);
03081
03082 const GWEN_FSLOCK *GWEN_FSLock_ConstList2_GetFront(GWEN_FSLOCK_CONSTLIST2 *l);
03083
03084 const GWEN_FSLOCK *GWEN_FSLock_ConstList2_GetBack(GWEN_FSLOCK_CONSTLIST2 *l);
03085
03086 unsigned int GWEN_FSLock_ConstList2_GetSize(GWEN_FSLOCK_CONSTLIST2 *l);
03087
03088 void GWEN_FSLock_ConstList2_PopBack(GWEN_FSLOCK_CONSTLIST2 *l);
03089
03090 void GWEN_FSLock_ConstList2_PopFront(GWEN_FSLOCK_CONSTLIST2 *l);
03091
03092 void GWEN_FSLock_ConstList2_Clear(GWEN_FSLOCK_CONSTLIST2 *l);
03093
03094 GWEN_FSLOCK_CONSTLIST2_ITERATOR *GWEN_FSLock_ConstList2_First(GWEN_FSLOCK_CONSTLIST2 *l);
03095
03096 GWEN_FSLOCK_CONSTLIST2_ITERATOR *GWEN_FSLock_ConstList2_Last(GWEN_FSLOCK_CONSTLIST2 *l);
03097
03098 GWEN_FSLOCK_CONSTLIST2_ITERATOR *GWEN_FSLock_ConstList2Iterator_new(GWEN_FSLOCK_CONSTLIST2 *l);
03099
03100 void GWEN_FSLock_ConstList2Iterator_free(GWEN_FSLOCK_CONSTLIST2_ITERATOR *li);
03101
03102 const GWEN_FSLOCK *GWEN_FSLock_ConstList2Iterator_Previous(GWEN_FSLOCK_CONSTLIST2_ITERATOR *li);
03103
03104 const GWEN_FSLOCK *GWEN_FSLock_ConstList2Iterator_Next(GWEN_FSLOCK_CONSTLIST2_ITERATOR *li);
03105
03106 const GWEN_FSLOCK *GWEN_FSLock_ConstList2Iterator_Data(GWEN_FSLOCK_CONSTLIST2_ITERATOR *li);
03107
03119 const GWEN_FSLOCK *GWEN_FSLock_ConstList2_ForEach(GWEN_FSLOCK_CONSTLIST2 *list,
03120 GWEN_FSLOCK_CONSTLIST2_FOREACH func, void *user_data);
03121
03122
03123 #ifdef __cplusplus
03124 }
03125 #endif
03126
03127
03128 #endif
03129
03130
03131
03132
03133
03134
03135
03136
03137
03138
03139
03140
03141
03142
03143
03144
03145
03146
03147
03148
03149
03150
03151
03152
03153
03154
03155
03156
03157
03158
03159
03160 #ifndef GWEN_FSLOCK_LIST1_H
03161 #define GWEN_FSLOCK_LIST1_H
03162
03163 #ifdef __cplusplus
03164 extern "C" {
03165 #endif
03166
03168 typedef struct GWEN_FSLOCK_LIST_ELEMENT {
03169 uint32_t id;
03170 GWEN_FSLOCK *nextObject;
03171 } GWEN_FSLOCK_LIST__ELEMENT;
03172
03179 typedef struct GWEN_FSLOCK_LIST GWEN_FSLOCK_LIST;
03181 struct GWEN_FSLOCK_LIST {
03182 GWEN_FSLOCK *first;
03183 uint32_t count;
03184 uint32_t id;
03185 } GWEN_FSLOCK_LIST;
03186
03191 void GWEN_FSLock_List_AddList(GWEN_FSLOCK_LIST *dst, GWEN_FSLOCK_LIST *l);
03192
03196 void GWEN_FSLock_List_Add(GWEN_FSLOCK *element, GWEN_FSLOCK_LIST *list);
03197
03202 void GWEN_FSLock_List_Insert(GWEN_FSLOCK *element, GWEN_FSLOCK_LIST *list);
03203
03210 void GWEN_FSLock_List_Del(GWEN_FSLOCK *element);
03211
03215 GWEN_FSLOCK* GWEN_FSLock_List_First(const GWEN_FSLOCK_LIST *l);
03216
03220 GWEN_FSLOCK* GWEN_FSLock_List_Last(const GWEN_FSLOCK_LIST *l);
03221
03226 void GWEN_FSLock_List_Clear(GWEN_FSLOCK_LIST *l);
03227
03231 GWEN_FSLOCK_LIST* GWEN_FSLock_List_new();
03232
03236 void GWEN_FSLock_List_free(GWEN_FSLOCK_LIST *l);
03237
03241 GWEN_FSLOCK* GWEN_FSLock_List_Next(const GWEN_FSLOCK *element);
03242
03246 GWEN_FSLOCK* GWEN_FSLock_List_Previous(const GWEN_FSLOCK *element);
03247
03251 uint32_t GWEN_FSLock_List_GetCount(const GWEN_FSLOCK_LIST *l);
03252
03253 #ifdef __cplusplus
03254 }
03255 #endif
03256
03257
03258 #endif
03259
03260
03261
03262
03263
03264
03265
03266
03267
03268
03269
03270
03271
03272
03273
03274
03275
03276
03277
03278
03279
03280
03281
03282
03283
03284
03285
03286
03287
03288
03289
03290 #ifndef GWEN_SIGHEAD_LIST1_H
03291 #define GWEN_SIGHEAD_LIST1_H
03292
03293 #ifdef __cplusplus
03294 extern "C" {
03295 #endif
03296
03298 typedef struct GWEN_SIGHEAD_LIST_ELEMENT {
03299 uint32_t id;
03300 GWEN_SIGHEAD *nextObject;
03301 } GWEN_SIGHEAD_LIST__ELEMENT;
03302
03309 typedef struct GWEN_SIGHEAD_LIST GWEN_SIGHEAD_LIST;
03311 struct GWEN_SIGHEAD_LIST {
03312 GWEN_SIGHEAD *first;
03313 uint32_t count;
03314 uint32_t id;
03315 } GWEN_SIGHEAD_LIST;
03316
03321 void GWEN_SigHead_List_AddList(GWEN_SIGHEAD_LIST *dst, GWEN_SIGHEAD_LIST *l);
03322
03326 void GWEN_SigHead_List_Add(GWEN_SIGHEAD *element, GWEN_SIGHEAD_LIST *list);
03327
03332 void GWEN_SigHead_List_Insert(GWEN_SIGHEAD *element, GWEN_SIGHEAD_LIST *list);
03333
03340 void GWEN_SigHead_List_Del(GWEN_SIGHEAD *element);
03341
03345 GWEN_SIGHEAD* GWEN_SigHead_List_First(const GWEN_SIGHEAD_LIST *l);
03346
03350 GWEN_SIGHEAD* GWEN_SigHead_List_Last(const GWEN_SIGHEAD_LIST *l);
03351
03356 void GWEN_SigHead_List_Clear(GWEN_SIGHEAD_LIST *l);
03357
03361 GWEN_SIGHEAD_LIST* GWEN_SigHead_List_new();
03362
03366 void GWEN_SigHead_List_free(GWEN_SIGHEAD_LIST *l);
03367
03371 GWEN_SIGHEAD* GWEN_SigHead_List_Next(const GWEN_SIGHEAD *element);
03372
03376 GWEN_SIGHEAD* GWEN_SigHead_List_Previous(const GWEN_SIGHEAD *element);
03377
03381 uint32_t GWEN_SigHead_List_GetCount(const GWEN_SIGHEAD_LIST *l);
03382
03383 #ifdef __cplusplus
03384 }
03385 #endif
03386
03387
03388 #endif
03389
03390
03391
03392
03393
03394
03395
03396
03397
03398
03399
03400
03401
03402
03403
03404
03405
03406
03407
03408
03409
03410
03411
03412
03413
03414
03415
03416
03417
03418
03419
03420 #ifndef GWEN_SOCKET_LIST2_H
03421 #define GWEN_SOCKET_LIST2_H
03422
03423
03424 #ifdef __cplusplus
03425 extern "C" {
03426 #endif
03427
03434 typedef struct GWEN_SOCKET_LIST2 GWEN_SOCKET_LIST2;
03435
03439 typedef struct GWEN_SOCKET_LIST2_ITERATOR GWEN_SOCKET_LIST2_ITERATOR;
03440
03444 typedef GWEN_SOCKET* (GWEN_SOCKET_LIST2_FOREACH)(GWEN_SOCKET *element,
03445 void *user_data);
03446
03450 GWEN_SOCKET_LIST2 *GWEN_Socket_List2_new();
03451
03455 void GWEN_Socket_List2_free(GWEN_SOCKET_LIST2 *l);
03456
03460 void GWEN_Socket_List2_Dump(GWEN_SOCKET_LIST2 *l, FILE *f, unsigned int indent);
03461
03465 void GWEN_Socket_List2_PushBack(GWEN_SOCKET_LIST2 *l, GWEN_SOCKET *p);
03466
03471 void GWEN_Socket_List2_PushFront(GWEN_SOCKET_LIST2 *l, GWEN_SOCKET *p);
03472
03477 GWEN_SOCKET *GWEN_Socket_List2_GetFront(GWEN_SOCKET_LIST2 *l);
03478
03483 GWEN_SOCKET *GWEN_Socket_List2_GetBack(GWEN_SOCKET_LIST2 *l);
03484
03489 void GWEN_Socket_List2_Erase(GWEN_SOCKET_LIST2 *l,
03490 GWEN_SOCKET_LIST2_ITERATOR *it);
03491
03497 unsigned int GWEN_Socket_List2_GetSize(GWEN_SOCKET_LIST2 *l);
03498
03503 void GWEN_Socket_List2_PopBack(GWEN_SOCKET_LIST2 *l);
03504
03509 void GWEN_Socket_List2_PopFront(GWEN_SOCKET_LIST2 *l);
03510
03514 void GWEN_Socket_List2_Clear(GWEN_SOCKET_LIST2 *l);
03515
03519 GWEN_SOCKET_LIST2_ITERATOR *GWEN_Socket_List2_First(GWEN_SOCKET_LIST2 *l);
03520
03524 GWEN_SOCKET_LIST2_ITERATOR *GWEN_Socket_List2_Last(GWEN_SOCKET_LIST2 *l);
03525
03529 GWEN_SOCKET_LIST2_ITERATOR *GWEN_Socket_List2Iterator_new(GWEN_SOCKET_LIST2 *l);
03530
03534 void GWEN_Socket_List2Iterator_free(GWEN_SOCKET_LIST2_ITERATOR *li);
03535
03540 GWEN_SOCKET *GWEN_Socket_List2Iterator_Previous(GWEN_SOCKET_LIST2_ITERATOR *li);
03541
03546 GWEN_SOCKET *GWEN_Socket_List2Iterator_Next(GWEN_SOCKET_LIST2_ITERATOR *li);
03547
03552 GWEN_SOCKET *GWEN_Socket_List2Iterator_Data(GWEN_SOCKET_LIST2_ITERATOR *li);
03553
03565 GWEN_SOCKET *GWEN_Socket_List2_ForEach(GWEN_SOCKET_LIST2 *list,
03566 GWEN_SOCKET_LIST2_FOREACH func,
03567 void *user_data);
03568
03569
03570 typedef struct GWEN_SOCKET_CONSTLIST2 GWEN_SOCKET_CONSTLIST2;
03571 typedef struct GWEN_SOCKET_CONSTLIST2_ITERATOR GWEN_SOCKET_CONSTLIST2_ITERATOR;
03572 typedef const GWEN_SOCKET*
03573 (GWEN_SOCKET_CONSTLIST2_FOREACH)(const GWEN_SOCKET *element,
03574 void *user_data);
03575
03576
03577 GWEN_SOCKET_CONSTLIST2 *GWEN_Socket_ConstList2_new();
03578
03579 void GWEN_Socket_ConstList2_free(GWEN_SOCKET_CONSTLIST2 *l);
03580
03581 void GWEN_Socket_ConstList2_PushBack(GWEN_SOCKET_CONSTLIST2 *l, const GWEN_SOCKET *p);
03582
03583 void GWEN_Socket_ConstList2_PushFront(GWEN_SOCKET_CONSTLIST2 *l, const GWEN_SOCKET *p);
03584
03585 const GWEN_SOCKET *GWEN_Socket_ConstList2_GetFront(GWEN_SOCKET_CONSTLIST2 *l);
03586
03587 const GWEN_SOCKET *GWEN_Socket_ConstList2_GetBack(GWEN_SOCKET_CONSTLIST2 *l);
03588
03589 unsigned int GWEN_Socket_ConstList2_GetSize(GWEN_SOCKET_CONSTLIST2 *l);
03590
03591 void GWEN_Socket_ConstList2_PopBack(GWEN_SOCKET_CONSTLIST2 *l);
03592
03593 void GWEN_Socket_ConstList2_PopFront(GWEN_SOCKET_CONSTLIST2 *l);
03594
03595 void GWEN_Socket_ConstList2_Clear(GWEN_SOCKET_CONSTLIST2 *l);
03596
03597 GWEN_SOCKET_CONSTLIST2_ITERATOR *GWEN_Socket_ConstList2_First(GWEN_SOCKET_CONSTLIST2 *l);
03598
03599 GWEN_SOCKET_CONSTLIST2_ITERATOR *GWEN_Socket_ConstList2_Last(GWEN_SOCKET_CONSTLIST2 *l);
03600
03601 GWEN_SOCKET_CONSTLIST2_ITERATOR *GWEN_Socket_ConstList2Iterator_new(GWEN_SOCKET_CONSTLIST2 *l);
03602
03603 void GWEN_Socket_ConstList2Iterator_free(GWEN_SOCKET_CONSTLIST2_ITERATOR *li);
03604
03605 const GWEN_SOCKET *GWEN_Socket_ConstList2Iterator_Previous(GWEN_SOCKET_CONSTLIST2_ITERATOR *li);
03606
03607 const GWEN_SOCKET *GWEN_Socket_ConstList2Iterator_Next(GWEN_SOCKET_CONSTLIST2_ITERATOR *li);
03608
03609 const GWEN_SOCKET *GWEN_Socket_ConstList2Iterator_Data(GWEN_SOCKET_CONSTLIST2_ITERATOR *li);
03610
03622 const GWEN_SOCKET *GWEN_Socket_ConstList2_ForEach(GWEN_SOCKET_CONSTLIST2 *list,
03623 GWEN_SOCKET_CONSTLIST2_FOREACH func, void *user_data);
03624
03625
03626 #ifdef __cplusplus
03627 }
03628 #endif
03629
03630
03631 #endif
03632
03633
03634
03635
03636
03637
03638
03639
03640
03641
03642
03643
03644
03645
03646
03647
03648
03649
03650
03651
03652
03653
03654
03655
03656
03657
03658
03659
03660
03661
03662
03663 #ifndef GWEN_SOCKET_LIST1_H
03664 #define GWEN_SOCKET_LIST1_H
03665
03666 #ifdef __cplusplus
03667 extern "C" {
03668 #endif
03669
03671 typedef struct GWEN_SOCKET_LIST_ELEMENT {
03672 uint32_t id;
03673 GWEN_SOCKET *nextObject;
03674 } GWEN_SOCKET_LIST__ELEMENT;
03675
03682 typedef struct GWEN_SOCKET_LIST GWEN_SOCKET_LIST;
03684 struct GWEN_SOCKET_LIST {
03685 GWEN_SOCKET *first;
03686 uint32_t count;
03687 uint32_t id;
03688 } GWEN_SOCKET_LIST;
03689
03694 void GWEN_Socket_List_AddList(GWEN_SOCKET_LIST *dst, GWEN_SOCKET_LIST *l);
03695
03699 void GWEN_Socket_List_Add(GWEN_SOCKET *element, GWEN_SOCKET_LIST *list);
03700
03705 void GWEN_Socket_List_Insert(GWEN_SOCKET *element, GWEN_SOCKET_LIST *list);
03706
03713 void GWEN_Socket_List_Del(GWEN_SOCKET *element);
03714
03718 GWEN_SOCKET* GWEN_Socket_List_First(const GWEN_SOCKET_LIST *l);
03719
03723 GWEN_SOCKET* GWEN_Socket_List_Last(const GWEN_SOCKET_LIST *l);
03724
03729 void GWEN_Socket_List_Clear(GWEN_SOCKET_LIST *l);
03730
03734 GWEN_SOCKET_LIST* GWEN_Socket_List_new();
03735
03739 void GWEN_Socket_List_free(GWEN_SOCKET_LIST *l);
03740
03744 GWEN_SOCKET* GWEN_Socket_List_Next(const GWEN_SOCKET *element);
03745
03749 GWEN_SOCKET* GWEN_Socket_List_Previous(const GWEN_SOCKET *element);
03750
03754 uint32_t GWEN_Socket_List_GetCount(const GWEN_SOCKET_LIST *l);
03755
03756 #ifdef __cplusplus
03757 }
03758 #endif
03759
03760
03761 #endif
03762
03763
03764
03765
03766
03767
03768
03769
03770
03771
03772
03773
03774
03775
03776
03777
03778
03779
03780
03781
03782
03783
03784
03785
03786
03787
03788
03789
03790
03791
03792
03793 #ifndef GWEN_IO_LAYER_LIST2_H
03794 #define GWEN_IO_LAYER_LIST2_H
03795
03796
03797 #ifdef __cplusplus
03798 extern "C" {
03799 #endif
03800
03807 typedef struct GWEN_IO_LAYER_LIST2 GWEN_IO_LAYER_LIST2;
03808
03812 typedef struct GWEN_IO_LAYER_LIST2_ITERATOR GWEN_IO_LAYER_LIST2_ITERATOR;
03813
03817 typedef GWEN_IO_LAYER* (GWEN_IO_LAYER_LIST2_FOREACH)(GWEN_IO_LAYER *element,
03818 void *user_data);
03819
03823 GWEN_IO_LAYER_LIST2 *GWEN_Io_Layer_List2_new();
03824
03828 void GWEN_Io_Layer_List2_free(GWEN_IO_LAYER_LIST2 *l);
03829
03833 void GWEN_Io_Layer_List2_Dump(GWEN_IO_LAYER_LIST2 *l, FILE *f, unsigned int indent);
03834
03838 void GWEN_Io_Layer_List2_PushBack(GWEN_IO_LAYER_LIST2 *l, GWEN_IO_LAYER *p);
03839
03844 void GWEN_Io_Layer_List2_PushFront(GWEN_IO_LAYER_LIST2 *l, GWEN_IO_LAYER *p);
03845
03850 GWEN_IO_LAYER *GWEN_Io_Layer_List2_GetFront(GWEN_IO_LAYER_LIST2 *l);
03851
03856 GWEN_IO_LAYER *GWEN_Io_Layer_List2_GetBack(GWEN_IO_LAYER_LIST2 *l);
03857
03862 void GWEN_Io_Layer_List2_Erase(GWEN_IO_LAYER_LIST2 *l,
03863 GWEN_IO_LAYER_LIST2_ITERATOR *it);
03864
03870 unsigned int GWEN_Io_Layer_List2_GetSize(GWEN_IO_LAYER_LIST2 *l);
03871
03876 void GWEN_Io_Layer_List2_PopBack(GWEN_IO_LAYER_LIST2 *l);
03877
03882 void GWEN_Io_Layer_List2_PopFront(GWEN_IO_LAYER_LIST2 *l);
03883
03887 void GWEN_Io_Layer_List2_Clear(GWEN_IO_LAYER_LIST2 *l);
03888
03892 GWEN_IO_LAYER_LIST2_ITERATOR *GWEN_Io_Layer_List2_First(GWEN_IO_LAYER_LIST2 *l);
03893
03897 GWEN_IO_LAYER_LIST2_ITERATOR *GWEN_Io_Layer_List2_Last(GWEN_IO_LAYER_LIST2 *l);
03898
03902 GWEN_IO_LAYER_LIST2_ITERATOR *GWEN_Io_Layer_List2Iterator_new(GWEN_IO_LAYER_LIST2 *l);
03903
03907 void GWEN_Io_Layer_List2Iterator_free(GWEN_IO_LAYER_LIST2_ITERATOR *li);
03908
03913 GWEN_IO_LAYER *GWEN_Io_Layer_List2Iterator_Previous(GWEN_IO_LAYER_LIST2_ITERATOR *li);
03914
03919 GWEN_IO_LAYER *GWEN_Io_Layer_List2Iterator_Next(GWEN_IO_LAYER_LIST2_ITERATOR *li);
03920
03925 GWEN_IO_LAYER *GWEN_Io_Layer_List2Iterator_Data(GWEN_IO_LAYER_LIST2_ITERATOR *li);
03926
03938 GWEN_IO_LAYER *GWEN_Io_Layer_List2_ForEach(GWEN_IO_LAYER_LIST2 *list,
03939 GWEN_IO_LAYER_LIST2_FOREACH func,
03940 void *user_data);
03941
03942
03943 typedef struct GWEN_IO_LAYER_CONSTLIST2 GWEN_IO_LAYER_CONSTLIST2;
03944 typedef struct GWEN_IO_LAYER_CONSTLIST2_ITERATOR GWEN_IO_LAYER_CONSTLIST2_ITERATOR;
03945 typedef const GWEN_IO_LAYER*
03946 (GWEN_IO_LAYER_CONSTLIST2_FOREACH)(const GWEN_IO_LAYER *element,
03947 void *user_data);
03948
03949
03950 GWEN_IO_LAYER_CONSTLIST2 *GWEN_Io_Layer_ConstList2_new();
03951
03952 void GWEN_Io_Layer_ConstList2_free(GWEN_IO_LAYER_CONSTLIST2 *l);
03953
03954 void GWEN_Io_Layer_ConstList2_PushBack(GWEN_IO_LAYER_CONSTLIST2 *l, const GWEN_IO_LAYER *p);
03955
03956 void GWEN_Io_Layer_ConstList2_PushFront(GWEN_IO_LAYER_CONSTLIST2 *l, const GWEN_IO_LAYER *p);
03957
03958 const GWEN_IO_LAYER *GWEN_Io_Layer_ConstList2_GetFront(GWEN_IO_LAYER_CONSTLIST2 *l);
03959
03960 const GWEN_IO_LAYER *GWEN_Io_Layer_ConstList2_GetBack(GWEN_IO_LAYER_CONSTLIST2 *l);
03961
03962 unsigned int GWEN_Io_Layer_ConstList2_GetSize(GWEN_IO_LAYER_CONSTLIST2 *l);
03963
03964 void GWEN_Io_Layer_ConstList2_PopBack(GWEN_IO_LAYER_CONSTLIST2 *l);
03965
03966 void GWEN_Io_Layer_ConstList2_PopFront(GWEN_IO_LAYER_CONSTLIST2 *l);
03967
03968 void GWEN_Io_Layer_ConstList2_Clear(GWEN_IO_LAYER_CONSTLIST2 *l);
03969
03970 GWEN_IO_LAYER_CONSTLIST2_ITERATOR *GWEN_Io_Layer_ConstList2_First(GWEN_IO_LAYER_CONSTLIST2 *l);
03971
03972 GWEN_IO_LAYER_CONSTLIST2_ITERATOR *GWEN_Io_Layer_ConstList2_Last(GWEN_IO_LAYER_CONSTLIST2 *l);
03973
03974 GWEN_IO_LAYER_CONSTLIST2_ITERATOR *GWEN_Io_Layer_ConstList2Iterator_new(GWEN_IO_LAYER_CONSTLIST2 *l);
03975
03976 void GWEN_Io_Layer_ConstList2Iterator_free(GWEN_IO_LAYER_CONSTLIST2_ITERATOR *li);
03977
03978 const GWEN_IO_LAYER *GWEN_Io_Layer_ConstList2Iterator_Previous(GWEN_IO_LAYER_CONSTLIST2_ITERATOR *li);
03979
03980 const GWEN_IO_LAYER *GWEN_Io_Layer_ConstList2Iterator_Next(GWEN_IO_LAYER_CONSTLIST2_ITERATOR *li);
03981
03982 const GWEN_IO_LAYER *GWEN_Io_Layer_ConstList2Iterator_Data(GWEN_IO_LAYER_CONSTLIST2_ITERATOR *li);
03983
03995 const GWEN_IO_LAYER *GWEN_Io_Layer_ConstList2_ForEach(GWEN_IO_LAYER_CONSTLIST2 *list,
03996 GWEN_IO_LAYER_CONSTLIST2_FOREACH func, void *user_data);
03997
03998
03999 #ifdef __cplusplus
04000 }
04001 #endif
04002
04003
04004 #endif
04005
04006
04007
04008
04009
04010
04011
04012
04013
04014
04015
04016
04017
04018
04019
04020
04021
04022
04023
04024
04025
04026
04027
04028
04029
04030
04031
04032
04033
04034
04035
04036 #ifndef GWEN_SSLCERTDESCR_LIST2_H
04037 #define GWEN_SSLCERTDESCR_LIST2_H
04038
04039
04040 #ifdef __cplusplus
04041 extern "C" {
04042 #endif
04043
04050 typedef struct GWEN_SSLCERTDESCR_LIST2 GWEN_SSLCERTDESCR_LIST2;
04051
04055 typedef struct GWEN_SSLCERTDESCR_LIST2_ITERATOR GWEN_SSLCERTDESCR_LIST2_ITERATOR;
04056
04060 typedef GWEN_SSLCERTDESCR* (GWEN_SSLCERTDESCR_LIST2_FOREACH)(GWEN_SSLCERTDESCR *element,
04061 void *user_data);
04062
04066 GWEN_SSLCERTDESCR_LIST2 *GWEN_SslCertDescr_List2_new();
04067
04071 void GWEN_SslCertDescr_List2_free(GWEN_SSLCERTDESCR_LIST2 *l);
04072
04076 void GWEN_SslCertDescr_List2_Dump(GWEN_SSLCERTDESCR_LIST2 *l, FILE *f, unsigned int indent);
04077
04081 void GWEN_SslCertDescr_List2_PushBack(GWEN_SSLCERTDESCR_LIST2 *l, GWEN_SSLCERTDESCR *p);
04082
04087 void GWEN_SslCertDescr_List2_PushFront(GWEN_SSLCERTDESCR_LIST2 *l, GWEN_SSLCERTDESCR *p);
04088
04093 GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2_GetFront(GWEN_SSLCERTDESCR_LIST2 *l);
04094
04099 GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2_GetBack(GWEN_SSLCERTDESCR_LIST2 *l);
04100
04105 void GWEN_SslCertDescr_List2_Erase(GWEN_SSLCERTDESCR_LIST2 *l,
04106 GWEN_SSLCERTDESCR_LIST2_ITERATOR *it);
04107
04113 unsigned int GWEN_SslCertDescr_List2_GetSize(GWEN_SSLCERTDESCR_LIST2 *l);
04114
04119 void GWEN_SslCertDescr_List2_PopBack(GWEN_SSLCERTDESCR_LIST2 *l);
04120
04125 void GWEN_SslCertDescr_List2_PopFront(GWEN_SSLCERTDESCR_LIST2 *l);
04126
04130 void GWEN_SslCertDescr_List2_Clear(GWEN_SSLCERTDESCR_LIST2 *l);
04131
04135 GWEN_SSLCERTDESCR_LIST2_ITERATOR *GWEN_SslCertDescr_List2_First(GWEN_SSLCERTDESCR_LIST2 *l);
04136
04140 GWEN_SSLCERTDESCR_LIST2_ITERATOR *GWEN_SslCertDescr_List2_Last(GWEN_SSLCERTDESCR_LIST2 *l);
04141
04145 GWEN_SSLCERTDESCR_LIST2_ITERATOR *GWEN_SslCertDescr_List2Iterator_new(GWEN_SSLCERTDESCR_LIST2 *l);
04146
04150 void GWEN_SslCertDescr_List2Iterator_free(GWEN_SSLCERTDESCR_LIST2_ITERATOR *li);
04151
04156 GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2Iterator_Previous(GWEN_SSLCERTDESCR_LIST2_ITERATOR *li);
04157
04162 GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2Iterator_Next(GWEN_SSLCERTDESCR_LIST2_ITERATOR *li);
04163
04168 GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2Iterator_Data(GWEN_SSLCERTDESCR_LIST2_ITERATOR *li);
04169
04181 GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2_ForEach(GWEN_SSLCERTDESCR_LIST2 *list,
04182 GWEN_SSLCERTDESCR_LIST2_FOREACH func,
04183 void *user_data);
04184
04185
04186 typedef struct GWEN_SSLCERTDESCR_CONSTLIST2 GWEN_SSLCERTDESCR_CONSTLIST2;
04187 typedef struct GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR;
04188 typedef const GWEN_SSLCERTDESCR*
04189 (GWEN_SSLCERTDESCR_CONSTLIST2_FOREACH)(const GWEN_SSLCERTDESCR *element,
04190 void *user_data);
04191
04192
04193 GWEN_SSLCERTDESCR_CONSTLIST2 *GWEN_SslCertDescr_ConstList2_new();
04194
04195 void GWEN_SslCertDescr_ConstList2_free(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
04196
04197 void GWEN_SslCertDescr_ConstList2_PushBack(GWEN_SSLCERTDESCR_CONSTLIST2 *l, const GWEN_SSLCERTDESCR *p);
04198
04199 void GWEN_SslCertDescr_ConstList2_PushFront(GWEN_SSLCERTDESCR_CONSTLIST2 *l, const GWEN_SSLCERTDESCR *p);
04200
04201 const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2_GetFront(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
04202
04203 const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2_GetBack(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
04204
04205 unsigned int GWEN_SslCertDescr_ConstList2_GetSize(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
04206
04207 void GWEN_SslCertDescr_ConstList2_PopBack(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
04208
04209 void GWEN_SslCertDescr_ConstList2_PopFront(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
04210
04211 void GWEN_SslCertDescr_ConstList2_Clear(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
04212
04213 GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *GWEN_SslCertDescr_ConstList2_First(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
04214
04215 GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *GWEN_SslCertDescr_ConstList2_Last(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
04216
04217 GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *GWEN_SslCertDescr_ConstList2Iterator_new(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
04218
04219 void GWEN_SslCertDescr_ConstList2Iterator_free(GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *li);
04220
04221 const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2Iterator_Previous(GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *li);
04222
04223 const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2Iterator_Next(GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *li);
04224
04225 const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2Iterator_Data(GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *li);
04226
04238 const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2_ForEach(GWEN_SSLCERTDESCR_CONSTLIST2 *list,
04239 GWEN_SSLCERTDESCR_CONSTLIST2_FOREACH func, void *user_data);
04240
04241
04242 #ifdef __cplusplus
04243 }
04244 #endif
04245
04246
04247 #endif
04248
04249
04250
04251
04252
04253
04254
04255
04256
04257
04258
04259
04260
04261
04262
04263
04264
04265
04266
04267
04268
04269
04270
04271
04272
04273
04274
04275
04276
04277
04278
04279 #ifndef GWEN_SSLCERTDESCR_LIST1_H
04280 #define GWEN_SSLCERTDESCR_LIST1_H
04281
04282 #ifdef __cplusplus
04283 extern "C" {
04284 #endif
04285
04287 typedef struct GWEN_SSLCERTDESCR_LIST_ELEMENT {
04288 uint32_t id;
04289 GWEN_SSLCERTDESCR *nextObject;
04290 } GWEN_SSLCERTDESCR_LIST__ELEMENT;
04291
04298 typedef struct GWEN_SSLCERTDESCR_LIST GWEN_SSLCERTDESCR_LIST;
04300 struct GWEN_SSLCERTDESCR_LIST {
04301 GWEN_SSLCERTDESCR *first;
04302 uint32_t count;
04303 uint32_t id;
04304 } GWEN_SSLCERTDESCR_LIST;
04305
04310 void GWEN_SslCertDescr_List_AddList(GWEN_SSLCERTDESCR_LIST *dst, GWEN_SSLCERTDESCR_LIST *l);
04311
04315 void GWEN_SslCertDescr_List_Add(GWEN_SSLCERTDESCR *element, GWEN_SSLCERTDESCR_LIST *list);
04316
04321 void GWEN_SslCertDescr_List_Insert(GWEN_SSLCERTDESCR *element, GWEN_SSLCERTDESCR_LIST *list);
04322
04329 void GWEN_SslCertDescr_List_Del(GWEN_SSLCERTDESCR *element);
04330
04334 GWEN_SSLCERTDESCR* GWEN_SslCertDescr_List_First(const GWEN_SSLCERTDESCR_LIST *l);
04335
04339 GWEN_SSLCERTDESCR* GWEN_SslCertDescr_List_Last(const GWEN_SSLCERTDESCR_LIST *l);
04340
04345 void GWEN_SslCertDescr_List_Clear(GWEN_SSLCERTDESCR_LIST *l);
04346
04350 GWEN_SSLCERTDESCR_LIST* GWEN_SslCertDescr_List_new();
04351
04355 void GWEN_SslCertDescr_List_free(GWEN_SSLCERTDESCR_LIST *l);
04356
04360 GWEN_SSLCERTDESCR* GWEN_SslCertDescr_List_Next(const GWEN_SSLCERTDESCR *element);
04361
04365 GWEN_SSLCERTDESCR* GWEN_SslCertDescr_List_Previous(const GWEN_SSLCERTDESCR *element);
04366
04370 uint32_t GWEN_SslCertDescr_List_GetCount(const GWEN_SSLCERTDESCR_LIST *l);
04371
04372 #ifdef __cplusplus
04373 }
04374 #endif
04375
04376
04377 #endif
04378
04379
04380
04381
04382
04383
04384
04385
04386
04387
04388
04389
04390
04391
04392
04393
04394
04395
04396
04397
04398
04399
04400
04401
04402
04403
04404
04405
04406
04407
04408
04409 #ifndef GWEN_CRYPT_TOKEN_KEYINFO_LIST2_H
04410 #define GWEN_CRYPT_TOKEN_KEYINFO_LIST2_H
04411
04412
04413 #ifdef __cplusplus
04414 extern "C" {
04415 #endif
04416
04423 typedef struct GWEN_CRYPT_TOKEN_KEYINFO_LIST2 GWEN_CRYPT_TOKEN_KEYINFO_LIST2;
04424
04428 typedef struct GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR;
04429
04433 typedef GWEN_CRYPT_TOKEN_KEYINFO* (GWEN_CRYPT_TOKEN_KEYINFO_LIST2_FOREACH)(GWEN_CRYPT_TOKEN_KEYINFO *element,
04434 void *user_data);
04435
04439 GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *GWEN_Crypt_Token_KeyInfo_List2_new();
04440
04444 void GWEN_Crypt_Token_KeyInfo_List2_free(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l);
04445
04449 void GWEN_Crypt_Token_KeyInfo_List2_Dump(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l, FILE *f, unsigned int indent);
04450
04454 void GWEN_Crypt_Token_KeyInfo_List2_PushBack(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l, GWEN_CRYPT_TOKEN_KEYINFO *p);
04455
04460 void GWEN_Crypt_Token_KeyInfo_List2_PushFront(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l, GWEN_CRYPT_TOKEN_KEYINFO *p);
04461
04466 GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_List2_GetFront(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l);
04467
04472 GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_List2_GetBack(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l);
04473
04478 void GWEN_Crypt_Token_KeyInfo_List2_Erase(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l,
04479 GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *it);
04480
04486 unsigned int GWEN_Crypt_Token_KeyInfo_List2_GetSize(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l);
04487
04492 void GWEN_Crypt_Token_KeyInfo_List2_PopBack(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l);
04493
04498 void GWEN_Crypt_Token_KeyInfo_List2_PopFront(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l);
04499
04503 void GWEN_Crypt_Token_KeyInfo_List2_Clear(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l);
04504
04508 GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *GWEN_Crypt_Token_KeyInfo_List2_First(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l);
04509
04513 GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *GWEN_Crypt_Token_KeyInfo_List2_Last(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l);
04514
04518 GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *GWEN_Crypt_Token_KeyInfo_List2Iterator_new(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l);
04519
04523 void GWEN_Crypt_Token_KeyInfo_List2Iterator_free(GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *li);
04524
04529 GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_List2Iterator_Previous(GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *li);
04530
04535 GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_List2Iterator_Next(GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *li);
04536
04541 GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_List2Iterator_Data(GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *li);
04542
04554 GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_List2_ForEach(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *list,
04555 GWEN_CRYPT_TOKEN_KEYINFO_LIST2_FOREACH func,
04556 void *user_data);
04557
04558
04559 typedef struct GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2;
04560 typedef struct GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR;
04561 typedef const GWEN_CRYPT_TOKEN_KEYINFO*
04562 (GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_FOREACH)(const GWEN_CRYPT_TOKEN_KEYINFO *element,
04563 void *user_data);
04564
04565
04566 GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *GWEN_Crypt_Token_KeyInfo_ConstList2_new();
04567
04568 void GWEN_Crypt_Token_KeyInfo_ConstList2_free(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l);
04569
04570 void GWEN_Crypt_Token_KeyInfo_ConstList2_PushBack(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l, const GWEN_CRYPT_TOKEN_KEYINFO *p);
04571
04572 void GWEN_Crypt_Token_KeyInfo_ConstList2_PushFront(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l, const GWEN_CRYPT_TOKEN_KEYINFO *p);
04573
04574 const GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_ConstList2_GetFront(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l);
04575
04576 const GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_ConstList2_GetBack(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l);
04577
04578 unsigned int GWEN_Crypt_Token_KeyInfo_ConstList2_GetSize(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l);
04579
04580 void GWEN_Crypt_Token_KeyInfo_ConstList2_PopBack(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l);
04581
04582 void GWEN_Crypt_Token_KeyInfo_ConstList2_PopFront(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l);
04583
04584 void GWEN_Crypt_Token_KeyInfo_ConstList2_Clear(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l);
04585
04586 GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_KeyInfo_ConstList2_First(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l);
04587
04588 GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_KeyInfo_ConstList2_Last(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l);
04589
04590 GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_KeyInfo_ConstList2Iterator_new(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l);
04591
04592 void GWEN_Crypt_Token_KeyInfo_ConstList2Iterator_free(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *li);
04593
04594 const GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_ConstList2Iterator_Previous(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *li);
04595
04596 const GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_ConstList2Iterator_Next(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *li);
04597
04598 const GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_ConstList2Iterator_Data(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *li);
04599
04611 const GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_ConstList2_ForEach(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *list,
04612 GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_FOREACH func, void *user_data);
04613
04614
04615 #ifdef __cplusplus
04616 }
04617 #endif
04618
04619
04620 #endif
04621
04622
04623
04624
04625
04626
04627
04628
04629
04630
04631
04632
04633
04634
04635
04636
04637
04638
04639
04640
04641
04642
04643
04644
04645
04646
04647
04648
04649
04650
04651
04652 #ifndef GWEN_CRYPT_TOKEN_KEYINFO_LIST1_H
04653 #define GWEN_CRYPT_TOKEN_KEYINFO_LIST1_H
04654
04655 #ifdef __cplusplus
04656 extern "C" {
04657 #endif
04658
04660 typedef struct GWEN_CRYPT_TOKEN_KEYINFO_LIST_ELEMENT {
04661 uint32_t id;
04662 GWEN_CRYPT_TOKEN_KEYINFO *nextObject;
04663 } GWEN_CRYPT_TOKEN_KEYINFO_LIST__ELEMENT;
04664
04671 typedef struct GWEN_CRYPT_TOKEN_KEYINFO_LIST GWEN_CRYPT_TOKEN_KEYINFO_LIST;
04673 struct GWEN_CRYPT_TOKEN_KEYINFO_LIST {
04674 GWEN_CRYPT_TOKEN_KEYINFO *first;
04675 uint32_t count;
04676 uint32_t id;
04677 } GWEN_CRYPT_TOKEN_KEYINFO_LIST;
04678
04683 void GWEN_Crypt_Token_KeyInfo_List_AddList(GWEN_CRYPT_TOKEN_KEYINFO_LIST *dst, GWEN_CRYPT_TOKEN_KEYINFO_LIST *l);
04684
04688 void GWEN_Crypt_Token_KeyInfo_List_Add(GWEN_CRYPT_TOKEN_KEYINFO *element, GWEN_CRYPT_TOKEN_KEYINFO_LIST *list);
04689
04694 void GWEN_Crypt_Token_KeyInfo_List_Insert(GWEN_CRYPT_TOKEN_KEYINFO *element, GWEN_CRYPT_TOKEN_KEYINFO_LIST *list);
04695
04702 void GWEN_Crypt_Token_KeyInfo_List_Del(GWEN_CRYPT_TOKEN_KEYINFO *element);
04703
04707 GWEN_CRYPT_TOKEN_KEYINFO* GWEN_Crypt_Token_KeyInfo_List_First(const GWEN_CRYPT_TOKEN_KEYINFO_LIST *l);
04708
04712 GWEN_CRYPT_TOKEN_KEYINFO* GWEN_Crypt_Token_KeyInfo_List_Last(const GWEN_CRYPT_TOKEN_KEYINFO_LIST *l);
04713
04718 void GWEN_Crypt_Token_KeyInfo_List_Clear(GWEN_CRYPT_TOKEN_KEYINFO_LIST *l);
04719
04723 GWEN_CRYPT_TOKEN_KEYINFO_LIST* GWEN_Crypt_Token_KeyInfo_List_new();
04724
04728 void GWEN_Crypt_Token_KeyInfo_List_free(GWEN_CRYPT_TOKEN_KEYINFO_LIST *l);
04729
04733 GWEN_CRYPT_TOKEN_KEYINFO* GWEN_Crypt_Token_KeyInfo_List_Next(const GWEN_CRYPT_TOKEN_KEYINFO *element);
04734
04738 GWEN_CRYPT_TOKEN_KEYINFO* GWEN_Crypt_Token_KeyInfo_List_Previous(const GWEN_CRYPT_TOKEN_KEYINFO *element);
04739
04743 uint32_t GWEN_Crypt_Token_KeyInfo_List_GetCount(const GWEN_CRYPT_TOKEN_KEYINFO_LIST *l);
04744
04745 #ifdef __cplusplus
04746 }
04747 #endif
04748
04749
04750 #endif
04751
04752
04753
04754
04755
04756
04757
04758
04759
04760
04761
04762
04763
04764
04765
04766
04767
04768
04769
04770
04771
04772
04773
04774
04775
04776
04777
04778
04779
04780
04781
04782 #ifndef GWEN_XSD_NODE_LIST1_H
04783 #define GWEN_XSD_NODE_LIST1_H
04784
04785 #ifdef __cplusplus
04786 extern "C" {
04787 #endif
04788
04790 typedef struct GWEN_XSD_NODE_LIST_ELEMENT {
04791 uint32_t id;
04792 GWEN_XSD_NODE *nextObject;
04793 } GWEN_XSD_NODE_LIST__ELEMENT;
04794
04801 typedef struct GWEN_XSD_NODE_LIST GWEN_XSD_NODE_LIST;
04803 struct GWEN_XSD_NODE_LIST {
04804 GWEN_XSD_NODE *first;
04805 uint32_t count;
04806 uint32_t id;
04807 } GWEN_XSD_NODE_LIST;
04808
04813 void GWEN_XsdNode_List_AddList(GWEN_XSD_NODE_LIST *dst, GWEN_XSD_NODE_LIST *l);
04814
04818 void GWEN_XsdNode_List_Add(GWEN_XSD_NODE *element, GWEN_XSD_NODE_LIST *list);
04819
04824 void GWEN_XsdNode_List_Insert(GWEN_XSD_NODE *element, GWEN_XSD_NODE_LIST *list);
04825
04832 void GWEN_XsdNode_List_Del(GWEN_XSD_NODE *element);
04833
04837 GWEN_XSD_NODE* GWEN_XsdNode_List_First(const GWEN_XSD_NODE_LIST *l);
04838
04842 GWEN_XSD_NODE* GWEN_XsdNode_List_Last(const GWEN_XSD_NODE_LIST *l);
04843
04848 void GWEN_XsdNode_List_Clear(GWEN_XSD_NODE_LIST *l);
04849
04853 GWEN_XSD_NODE_LIST* GWEN_XsdNode_List_new();
04854
04858 void GWEN_XsdNode_List_free(GWEN_XSD_NODE_LIST *l);
04859
04863 GWEN_XSD_NODE* GWEN_XsdNode_List_Next(const GWEN_XSD_NODE *element);
04864
04868 GWEN_XSD_NODE* GWEN_XsdNode_List_Previous(const GWEN_XSD_NODE *element);
04869
04873 uint32_t GWEN_XsdNode_List_GetCount(const GWEN_XSD_NODE_LIST *l);
04874
04875 #ifdef __cplusplus
04876 }
04877 #endif
04878
04879
04880 #endif
04881
04882
04883
04884
04885
04886
04887
04888
04889
04890
04891
04892
04893
04894
04895
04896
04897
04898
04899
04900
04901
04902
04903
04904
04905
04906
04907
04908
04909
04910
04911
04912 #ifndef GWEN_IO_REQUEST_LIST2_H
04913 #define GWEN_IO_REQUEST_LIST2_H
04914
04915
04916 #ifdef __cplusplus
04917 extern "C" {
04918 #endif
04919
04926 typedef struct GWEN_IO_REQUEST_LIST2 GWEN_IO_REQUEST_LIST2;
04927
04931 typedef struct GWEN_IO_REQUEST_LIST2_ITERATOR GWEN_IO_REQUEST_LIST2_ITERATOR;
04932
04936 typedef GWEN_IO_REQUEST* (GWEN_IO_REQUEST_LIST2_FOREACH)(GWEN_IO_REQUEST *element,
04937 void *user_data);
04938
04942 GWEN_IO_REQUEST_LIST2 *GWEN_Io_Request_List2_new();
04943
04947 void GWEN_Io_Request_List2_free(GWEN_IO_REQUEST_LIST2 *l);
04948
04952 void GWEN_Io_Request_List2_Dump(GWEN_IO_REQUEST_LIST2 *l, FILE *f, unsigned int indent);
04953
04957 void GWEN_Io_Request_List2_PushBack(GWEN_IO_REQUEST_LIST2 *l, GWEN_IO_REQUEST *p);
04958
04963 void GWEN_Io_Request_List2_PushFront(GWEN_IO_REQUEST_LIST2 *l, GWEN_IO_REQUEST *p);
04964
04969 GWEN_IO_REQUEST *GWEN_Io_Request_List2_GetFront(GWEN_IO_REQUEST_LIST2 *l);
04970
04975 GWEN_IO_REQUEST *GWEN_Io_Request_List2_GetBack(GWEN_IO_REQUEST_LIST2 *l);
04976
04981 void GWEN_Io_Request_List2_Erase(GWEN_IO_REQUEST_LIST2 *l,
04982 GWEN_IO_REQUEST_LIST2_ITERATOR *it);
04983
04989 unsigned int GWEN_Io_Request_List2_GetSize(GWEN_IO_REQUEST_LIST2 *l);
04990
04995 void GWEN_Io_Request_List2_PopBack(GWEN_IO_REQUEST_LIST2 *l);
04996
05001 void GWEN_Io_Request_List2_PopFront(GWEN_IO_REQUEST_LIST2 *l);
05002
05006 void GWEN_Io_Request_List2_Clear(GWEN_IO_REQUEST_LIST2 *l);
05007
05011 GWEN_IO_REQUEST_LIST2_ITERATOR *GWEN_Io_Request_List2_First(GWEN_IO_REQUEST_LIST2 *l);
05012
05016 GWEN_IO_REQUEST_LIST2_ITERATOR *GWEN_Io_Request_List2_Last(GWEN_IO_REQUEST_LIST2 *l);
05017
05021 GWEN_IO_REQUEST_LIST2_ITERATOR *GWEN_Io_Request_List2Iterator_new(GWEN_IO_REQUEST_LIST2 *l);
05022
05026 void GWEN_Io_Request_List2Iterator_free(GWEN_IO_REQUEST_LIST2_ITERATOR *li);
05027
05032 GWEN_IO_REQUEST *GWEN_Io_Request_List2Iterator_Previous(GWEN_IO_REQUEST_LIST2_ITERATOR *li);
05033
05038 GWEN_IO_REQUEST *GWEN_Io_Request_List2Iterator_Next(GWEN_IO_REQUEST_LIST2_ITERATOR *li);
05039
05044 GWEN_IO_REQUEST *GWEN_Io_Request_List2Iterator_Data(GWEN_IO_REQUEST_LIST2_ITERATOR *li);
05045
05057 GWEN_IO_REQUEST *GWEN_Io_Request_List2_ForEach(GWEN_IO_REQUEST_LIST2 *list,
05058 GWEN_IO_REQUEST_LIST2_FOREACH func,
05059 void *user_data);
05060
05061
05062 typedef struct GWEN_IO_REQUEST_CONSTLIST2 GWEN_IO_REQUEST_CONSTLIST2;
05063 typedef struct GWEN_IO_REQUEST_CONSTLIST2_ITERATOR GWEN_IO_REQUEST_CONSTLIST2_ITERATOR;
05064 typedef const GWEN_IO_REQUEST*
05065 (GWEN_IO_REQUEST_CONSTLIST2_FOREACH)(const GWEN_IO_REQUEST *element,
05066 void *user_data);
05067
05068
05069 GWEN_IO_REQUEST_CONSTLIST2 *GWEN_Io_Request_ConstList2_new();
05070
05071 void GWEN_Io_Request_ConstList2_free(GWEN_IO_REQUEST_CONSTLIST2 *l);
05072
05073 void GWEN_Io_Request_ConstList2_PushBack(GWEN_IO_REQUEST_CONSTLIST2 *l, const GWEN_IO_REQUEST *p);
05074
05075 void GWEN_Io_Request_ConstList2_PushFront(GWEN_IO_REQUEST_CONSTLIST2 *l, const GWEN_IO_REQUEST *p);
05076
05077 const GWEN_IO_REQUEST *GWEN_Io_Request_ConstList2_GetFront(GWEN_IO_REQUEST_CONSTLIST2 *l);
05078
05079 const GWEN_IO_REQUEST *GWEN_Io_Request_ConstList2_GetBack(GWEN_IO_REQUEST_CONSTLIST2 *l);
05080
05081 unsigned int GWEN_Io_Request_ConstList2_GetSize(GWEN_IO_REQUEST_CONSTLIST2 *l);
05082
05083 void GWEN_Io_Request_ConstList2_PopBack(GWEN_IO_REQUEST_CONSTLIST2 *l);
05084
05085 void GWEN_Io_Request_ConstList2_PopFront(GWEN_IO_REQUEST_CONSTLIST2 *l);
05086
05087 void GWEN_Io_Request_ConstList2_Clear(GWEN_IO_REQUEST_CONSTLIST2 *l);
05088
05089 GWEN_IO_REQUEST_CONSTLIST2_ITERATOR *GWEN_Io_Request_ConstList2_First(GWEN_IO_REQUEST_CONSTLIST2 *l);
05090
05091 GWEN_IO_REQUEST_CONSTLIST2_ITERATOR *GWEN_Io_Request_ConstList2_Last(GWEN_IO_REQUEST_CONSTLIST2 *l);
05092
05093 GWEN_IO_REQUEST_CONSTLIST2_ITERATOR *GWEN_Io_Request_ConstList2Iterator_new(GWEN_IO_REQUEST_CONSTLIST2 *l);
05094
05095 void GWEN_Io_Request_ConstList2Iterator_free(GWEN_IO_REQUEST_CONSTLIST2_ITERATOR *li);
05096
05097 const GWEN_IO_REQUEST *GWEN_Io_Request_ConstList2Iterator_Previous(GWEN_IO_REQUEST_CONSTLIST2_ITERATOR *li);
05098
05099 const GWEN_IO_REQUEST *GWEN_Io_Request_ConstList2Iterator_Next(GWEN_IO_REQUEST_CONSTLIST2_ITERATOR *li);
05100
05101 const GWEN_IO_REQUEST *GWEN_Io_Request_ConstList2Iterator_Data(GWEN_IO_REQUEST_CONSTLIST2_ITERATOR *li);
05102
05114 const GWEN_IO_REQUEST *GWEN_Io_Request_ConstList2_ForEach(GWEN_IO_REQUEST_CONSTLIST2 *list,
05115 GWEN_IO_REQUEST_CONSTLIST2_FOREACH func, void *user_data);
05116
05117
05118 #ifdef __cplusplus
05119 }
05120 #endif
05121
05122
05123 #endif
05124
05125
05126
05127
05128
05129
05130
05131
05132
05133
05134
05135
05136
05137
05138
05139
05140
05141
05142
05143
05144
05145
05146
05147
05148
05149
05150
05151
05152
05153
05154
05155 #ifndef GWEN_PLUGIN_DESCRIPTION_LIST2_H
05156 #define GWEN_PLUGIN_DESCRIPTION_LIST2_H
05157
05158
05159 #ifdef __cplusplus
05160 extern "C" {
05161 #endif
05162
05169 typedef struct GWEN_PLUGIN_DESCRIPTION_LIST2 GWEN_PLUGIN_DESCRIPTION_LIST2;
05170
05174 typedef struct GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR;
05175
05179 typedef GWEN_PLUGIN_DESCRIPTION* (GWEN_PLUGIN_DESCRIPTION_LIST2_FOREACH)(GWEN_PLUGIN_DESCRIPTION *element,
05180 void *user_data);
05181
05185 GWEN_PLUGIN_DESCRIPTION_LIST2 *GWEN_PluginDescription_List2_new();
05186
05190 void GWEN_PluginDescription_List2_free(GWEN_PLUGIN_DESCRIPTION_LIST2 *l);
05191
05195 void GWEN_PluginDescription_List2_Dump(GWEN_PLUGIN_DESCRIPTION_LIST2 *l, FILE *f, unsigned int indent);
05196
05200 void GWEN_PluginDescription_List2_PushBack(GWEN_PLUGIN_DESCRIPTION_LIST2 *l, GWEN_PLUGIN_DESCRIPTION *p);
05201
05206 void GWEN_PluginDescription_List2_PushFront(GWEN_PLUGIN_DESCRIPTION_LIST2 *l, GWEN_PLUGIN_DESCRIPTION *p);
05207
05212 GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_List2_GetFront(GWEN_PLUGIN_DESCRIPTION_LIST2 *l);
05213
05218 GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_List2_GetBack(GWEN_PLUGIN_DESCRIPTION_LIST2 *l);
05219
05224 void GWEN_PluginDescription_List2_Erase(GWEN_PLUGIN_DESCRIPTION_LIST2 *l,
05225 GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *it);
05226
05232 unsigned int GWEN_PluginDescription_List2_GetSize(GWEN_PLUGIN_DESCRIPTION_LIST2 *l);
05233
05238 void GWEN_PluginDescription_List2_PopBack(GWEN_PLUGIN_DESCRIPTION_LIST2 *l);
05239
05244 void GWEN_PluginDescription_List2_PopFront(GWEN_PLUGIN_DESCRIPTION_LIST2 *l);
05245
05249 void GWEN_PluginDescription_List2_Clear(GWEN_PLUGIN_DESCRIPTION_LIST2 *l);
05250
05254 GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *GWEN_PluginDescription_List2_First(GWEN_PLUGIN_DESCRIPTION_LIST2 *l);
05255
05259 GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *GWEN_PluginDescription_List2_Last(GWEN_PLUGIN_DESCRIPTION_LIST2 *l);
05260
05264 GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *GWEN_PluginDescription_List2Iterator_new(GWEN_PLUGIN_DESCRIPTION_LIST2 *l);
05265
05269 void GWEN_PluginDescription_List2Iterator_free(GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *li);
05270
05275 GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_List2Iterator_Previous(GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *li);
05276
05281 GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_List2Iterator_Next(GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *li);
05282
05287 GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_List2Iterator_Data(GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *li);
05288
05300 GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_List2_ForEach(GWEN_PLUGIN_DESCRIPTION_LIST2 *list,
05301 GWEN_PLUGIN_DESCRIPTION_LIST2_FOREACH func,
05302 void *user_data);
05303
05304
05305 typedef struct GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 GWEN_PLUGIN_DESCRIPTION_CONSTLIST2;
05306 typedef struct GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR;
05307 typedef const GWEN_PLUGIN_DESCRIPTION*
05308 (GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_FOREACH)(const GWEN_PLUGIN_DESCRIPTION *element,
05309 void *user_data);
05310
05311
05312 GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *GWEN_PluginDescription_ConstList2_new();
05313
05314 void GWEN_PluginDescription_ConstList2_free(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l);
05315
05316 void GWEN_PluginDescription_ConstList2_PushBack(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l, const GWEN_PLUGIN_DESCRIPTION *p);
05317
05318 void GWEN_PluginDescription_ConstList2_PushFront(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l, const GWEN_PLUGIN_DESCRIPTION *p);
05319
05320 const GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_ConstList2_GetFront(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l);
05321
05322 const GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_ConstList2_GetBack(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l);
05323
05324 unsigned int GWEN_PluginDescription_ConstList2_GetSize(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l);
05325
05326 void GWEN_PluginDescription_ConstList2_PopBack(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l);
05327
05328 void GWEN_PluginDescription_ConstList2_PopFront(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l);
05329
05330 void GWEN_PluginDescription_ConstList2_Clear(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l);
05331
05332 GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *GWEN_PluginDescription_ConstList2_First(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l);
05333
05334 GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *GWEN_PluginDescription_ConstList2_Last(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l);
05335
05336 GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *GWEN_PluginDescription_ConstList2Iterator_new(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l);
05337
05338 void GWEN_PluginDescription_ConstList2Iterator_free(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *li);
05339
05340 const GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_ConstList2Iterator_Previous(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *li);
05341
05342 const GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_ConstList2Iterator_Next(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *li);
05343
05344 const GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_ConstList2Iterator_Data(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *li);
05345
05357 const GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_ConstList2_ForEach(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *list,
05358 GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_FOREACH func, void *user_data);
05359
05360
05361 #ifdef __cplusplus
05362 }
05363 #endif
05364
05365
05366 #endif
05367
05368
05369
05370
05371
05372
05373
05374
05375
05376
05377
05378
05379
05380
05381
05382
05383
05384
05385
05386
05387
05388
05389
05390
05391
05392
05393
05394
05395
05396
05397
05398 #ifndef GWEN_PLUGIN_DESCRIPTION_LIST1_H
05399 #define GWEN_PLUGIN_DESCRIPTION_LIST1_H
05400
05401 #ifdef __cplusplus
05402 extern "C" {
05403 #endif
05404
05406 typedef struct GWEN_PLUGIN_DESCRIPTION_LIST_ELEMENT {
05407 uint32_t id;
05408 GWEN_PLUGIN_DESCRIPTION *nextObject;
05409 } GWEN_PLUGIN_DESCRIPTION_LIST__ELEMENT;
05410
05417 typedef struct GWEN_PLUGIN_DESCRIPTION_LIST GWEN_PLUGIN_DESCRIPTION_LIST;
05419 struct GWEN_PLUGIN_DESCRIPTION_LIST {
05420 GWEN_PLUGIN_DESCRIPTION *first;
05421 uint32_t count;
05422 uint32_t id;
05423 } GWEN_PLUGIN_DESCRIPTION_LIST;
05424
05429 void GWEN_PluginDescription_List_AddList(GWEN_PLUGIN_DESCRIPTION_LIST *dst, GWEN_PLUGIN_DESCRIPTION_LIST *l);
05430
05434 void GWEN_PluginDescription_List_Add(GWEN_PLUGIN_DESCRIPTION *element, GWEN_PLUGIN_DESCRIPTION_LIST *list);
05435
05440 void GWEN_PluginDescription_List_Insert(GWEN_PLUGIN_DESCRIPTION *element, GWEN_PLUGIN_DESCRIPTION_LIST *list);
05441
05448 void GWEN_PluginDescription_List_Del(GWEN_PLUGIN_DESCRIPTION *element);
05449
05453 GWEN_PLUGIN_DESCRIPTION* GWEN_PluginDescription_List_First(const GWEN_PLUGIN_DESCRIPTION_LIST *l);
05454
05458 GWEN_PLUGIN_DESCRIPTION* GWEN_PluginDescription_List_Last(const GWEN_PLUGIN_DESCRIPTION_LIST *l);
05459
05464 void GWEN_PluginDescription_List_Clear(GWEN_PLUGIN_DESCRIPTION_LIST *l);
05465
05469 GWEN_PLUGIN_DESCRIPTION_LIST* GWEN_PluginDescription_List_new();
05470
05474 void GWEN_PluginDescription_List_free(GWEN_PLUGIN_DESCRIPTION_LIST *l);
05475
05479 GWEN_PLUGIN_DESCRIPTION* GWEN_PluginDescription_List_Next(const GWEN_PLUGIN_DESCRIPTION *element);
05480
05484 GWEN_PLUGIN_DESCRIPTION* GWEN_PluginDescription_List_Previous(const GWEN_PLUGIN_DESCRIPTION *element);
05485
05489 uint32_t GWEN_PluginDescription_List_GetCount(const GWEN_PLUGIN_DESCRIPTION_LIST *l);
05490
05491 #ifdef __cplusplus
05492 }
05493 #endif
05494
05495
05496 #endif
05497
05498
05499
05500
05501
05502
05503
05504
05505
05506
05507
05508
05509
05510
05511
05512
05513
05514
05515
05516
05517
05518
05519
05520
05521
05522
05523
05524
05525
05526
05527
05528 #ifndef GWEN_IO_REQUEST_LIST1_H
05529 #define GWEN_IO_REQUEST_LIST1_H
05530
05531 #ifdef __cplusplus
05532 extern "C" {
05533 #endif
05534
05536 typedef struct GWEN_IO_REQUEST_LIST_ELEMENT {
05537 uint32_t id;
05538 GWEN_IO_REQUEST *nextObject;
05539 } GWEN_IO_REQUEST_LIST__ELEMENT;
05540
05547 typedef struct GWEN_IO_REQUEST_LIST GWEN_IO_REQUEST_LIST;
05549 struct GWEN_IO_REQUEST_LIST {
05550 GWEN_IO_REQUEST *first;
05551 uint32_t count;
05552 uint32_t id;
05553 } GWEN_IO_REQUEST_LIST;
05554
05559 void GWEN_Io_Request_List_AddList(GWEN_IO_REQUEST_LIST *dst, GWEN_IO_REQUEST_LIST *l);
05560
05564 void GWEN_Io_Request_List_Add(GWEN_IO_REQUEST *element, GWEN_IO_REQUEST_LIST *list);
05565
05570 void GWEN_Io_Request_List_Insert(GWEN_IO_REQUEST *element, GWEN_IO_REQUEST_LIST *list);
05571
05578 void GWEN_Io_Request_List_Del(GWEN_IO_REQUEST *element);
05579
05583 GWEN_IO_REQUEST* GWEN_Io_Request_List_First(const GWEN_IO_REQUEST_LIST *l);
05584
05588 GWEN_IO_REQUEST* GWEN_Io_Request_List_Last(const GWEN_IO_REQUEST_LIST *l);
05589
05594 void GWEN_Io_Request_List_Clear(GWEN_IO_REQUEST_LIST *l);
05595
05599 GWEN_IO_REQUEST_LIST* GWEN_Io_Request_List_new();
05600
05604 void GWEN_Io_Request_List_free(GWEN_IO_REQUEST_LIST *l);
05605
05609 GWEN_IO_REQUEST* GWEN_Io_Request_List_Next(const GWEN_IO_REQUEST *element);
05610
05614 GWEN_IO_REQUEST* GWEN_Io_Request_List_Previous(const GWEN_IO_REQUEST *element);
05615
05619 uint32_t GWEN_Io_Request_List_GetCount(const GWEN_IO_REQUEST_LIST *l);
05620
05621 #ifdef __cplusplus
05622 }
05623 #endif
05624
05625
05626 #endif
05627
05628
05629
05630
05631
05632
05633
05634
05635
05636
05637
05638
05639
05640
05641
05642
05643
05644
05645
05646
05647
05648
05649
05650
05651
05652
05653
05654
05655
05656
05657
05658 #ifndef GWEN_CRYPT_HASHALGO_LIST2_H
05659 #define GWEN_CRYPT_HASHALGO_LIST2_H
05660
05661
05662 #ifdef __cplusplus
05663 extern "C" {
05664 #endif
05665
05672 typedef struct GWEN_CRYPT_HASHALGO_LIST2 GWEN_CRYPT_HASHALGO_LIST2;
05673
05677 typedef struct GWEN_CRYPT_HASHALGO_LIST2_ITERATOR GWEN_CRYPT_HASHALGO_LIST2_ITERATOR;
05678
05682 typedef GWEN_CRYPT_HASHALGO* (GWEN_CRYPT_HASHALGO_LIST2_FOREACH)(GWEN_CRYPT_HASHALGO *element,
05683 void *user_data);
05684
05688 GWEN_CRYPT_HASHALGO_LIST2 *GWEN_Crypt_HashAlgo_List2_new();
05689
05693 void GWEN_Crypt_HashAlgo_List2_free(GWEN_CRYPT_HASHALGO_LIST2 *l);
05694
05698 void GWEN_Crypt_HashAlgo_List2_Dump(GWEN_CRYPT_HASHALGO_LIST2 *l, FILE *f, unsigned int indent);
05699
05703 void GWEN_Crypt_HashAlgo_List2_PushBack(GWEN_CRYPT_HASHALGO_LIST2 *l, GWEN_CRYPT_HASHALGO *p);
05704
05709 void GWEN_Crypt_HashAlgo_List2_PushFront(GWEN_CRYPT_HASHALGO_LIST2 *l, GWEN_CRYPT_HASHALGO *p);
05710
05715 GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_List2_GetFront(GWEN_CRYPT_HASHALGO_LIST2 *l);
05716
05721 GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_List2_GetBack(GWEN_CRYPT_HASHALGO_LIST2 *l);
05722
05727 void GWEN_Crypt_HashAlgo_List2_Erase(GWEN_CRYPT_HASHALGO_LIST2 *l,
05728 GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *it);
05729
05735 unsigned int GWEN_Crypt_HashAlgo_List2_GetSize(GWEN_CRYPT_HASHALGO_LIST2 *l);
05736
05741 void GWEN_Crypt_HashAlgo_List2_PopBack(GWEN_CRYPT_HASHALGO_LIST2 *l);
05742
05747 void GWEN_Crypt_HashAlgo_List2_PopFront(GWEN_CRYPT_HASHALGO_LIST2 *l);
05748
05752 void GWEN_Crypt_HashAlgo_List2_Clear(GWEN_CRYPT_HASHALGO_LIST2 *l);
05753
05757 GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *GWEN_Crypt_HashAlgo_List2_First(GWEN_CRYPT_HASHALGO_LIST2 *l);
05758
05762 GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *GWEN_Crypt_HashAlgo_List2_Last(GWEN_CRYPT_HASHALGO_LIST2 *l);
05763
05767 GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *GWEN_Crypt_HashAlgo_List2Iterator_new(GWEN_CRYPT_HASHALGO_LIST2 *l);
05768
05772 void GWEN_Crypt_HashAlgo_List2Iterator_free(GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *li);
05773
05778 GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_List2Iterator_Previous(GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *li);
05779
05784 GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_List2Iterator_Next(GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *li);
05785
05790 GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_List2Iterator_Data(GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *li);
05791
05803 GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_List2_ForEach(GWEN_CRYPT_HASHALGO_LIST2 *list,
05804 GWEN_CRYPT_HASHALGO_LIST2_FOREACH func,
05805 void *user_data);
05806
05807
05808 typedef struct GWEN_CRYPT_HASHALGO_CONSTLIST2 GWEN_CRYPT_HASHALGO_CONSTLIST2;
05809 typedef struct GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR;
05810 typedef const GWEN_CRYPT_HASHALGO*
05811 (GWEN_CRYPT_HASHALGO_CONSTLIST2_FOREACH)(const GWEN_CRYPT_HASHALGO *element,
05812 void *user_data);
05813
05814
05815 GWEN_CRYPT_HASHALGO_CONSTLIST2 *GWEN_Crypt_HashAlgo_ConstList2_new();
05816
05817 void GWEN_Crypt_HashAlgo_ConstList2_free(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l);
05818
05819 void GWEN_Crypt_HashAlgo_ConstList2_PushBack(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l, const GWEN_CRYPT_HASHALGO *p);
05820
05821 void GWEN_Crypt_HashAlgo_ConstList2_PushFront(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l, const GWEN_CRYPT_HASHALGO *p);
05822
05823 const GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_ConstList2_GetFront(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l);
05824
05825 const GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_ConstList2_GetBack(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l);
05826
05827 unsigned int GWEN_Crypt_HashAlgo_ConstList2_GetSize(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l);
05828
05829 void GWEN_Crypt_HashAlgo_ConstList2_PopBack(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l);
05830
05831 void GWEN_Crypt_HashAlgo_ConstList2_PopFront(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l);
05832
05833 void GWEN_Crypt_HashAlgo_ConstList2_Clear(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l);
05834
05835 GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_HashAlgo_ConstList2_First(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l);
05836
05837 GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_HashAlgo_ConstList2_Last(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l);
05838
05839 GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_HashAlgo_ConstList2Iterator_new(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l);
05840
05841 void GWEN_Crypt_HashAlgo_ConstList2Iterator_free(GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR *li);
05842
05843 const GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_ConstList2Iterator_Previous(GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR *li);
05844
05845 const GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_ConstList2Iterator_Next(GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR *li);
05846
05847 const GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_ConstList2Iterator_Data(GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR *li);
05848
05860 const GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_ConstList2_ForEach(GWEN_CRYPT_HASHALGO_CONSTLIST2 *list,
05861 GWEN_CRYPT_HASHALGO_CONSTLIST2_FOREACH func, void *user_data);
05862
05863
05864 #ifdef __cplusplus
05865 }
05866 #endif
05867
05868
05869 #endif
05870
05871
05872
05873
05874
05875
05876
05877
05878
05879
05880
05881
05882
05883
05884
05885
05886
05887
05888
05889
05890
05891
05892
05893
05894
05895
05896
05897
05898
05899
05900
05901 #ifndef GWEN_TAG16_LIST1_H
05902 #define GWEN_TAG16_LIST1_H
05903
05904 #ifdef __cplusplus
05905 extern "C" {
05906 #endif
05907
05909 typedef struct GWEN_TAG16_LIST_ELEMENT {
05910 uint32_t id;
05911 GWEN_TAG16 *nextObject;
05912 } GWEN_TAG16_LIST__ELEMENT;
05913
05920 typedef struct GWEN_TAG16_LIST GWEN_TAG16_LIST;
05922 struct GWEN_TAG16_LIST {
05923 GWEN_TAG16 *first;
05924 uint32_t count;
05925 uint32_t id;
05926 } GWEN_TAG16_LIST;
05927
05932 void GWEN_Tag16_List_AddList(GWEN_TAG16_LIST *dst, GWEN_TAG16_LIST *l);
05933
05937 void GWEN_Tag16_List_Add(GWEN_TAG16 *element, GWEN_TAG16_LIST *list);
05938
05943 void GWEN_Tag16_List_Insert(GWEN_TAG16 *element, GWEN_TAG16_LIST *list);
05944
05951 void GWEN_Tag16_List_Del(GWEN_TAG16 *element);
05952
05956 GWEN_TAG16* GWEN_Tag16_List_First(const GWEN_TAG16_LIST *l);
05957
05961 GWEN_TAG16* GWEN_Tag16_List_Last(const GWEN_TAG16_LIST *l);
05962
05967 void GWEN_Tag16_List_Clear(GWEN_TAG16_LIST *l);
05968
05972 GWEN_TAG16_LIST* GWEN_Tag16_List_new();
05973
05977 void GWEN_Tag16_List_free(GWEN_TAG16_LIST *l);
05978
05982 GWEN_TAG16* GWEN_Tag16_List_Next(const GWEN_TAG16 *element);
05983
05987 GWEN_TAG16* GWEN_Tag16_List_Previous(const GWEN_TAG16 *element);
05988
05992 uint32_t GWEN_Tag16_List_GetCount(const GWEN_TAG16_LIST *l);
05993
05994 #ifdef __cplusplus
05995 }
05996 #endif
05997
05998
05999 #endif
06000
06001
06002
06003
06004
06005
06006
06007
06008
06009
06010
06011
06012
06013
06014
06015
06016
06017
06018
06019
06020
06021
06022
06023
06024
06025
06026
06027
06028
06029
06030
06031 #ifndef GWEN_SIGTAIL_LIST1_H
06032 #define GWEN_SIGTAIL_LIST1_H
06033
06034 #ifdef __cplusplus
06035 extern "C" {
06036 #endif
06037
06039 typedef struct GWEN_SIGTAIL_LIST_ELEMENT {
06040 uint32_t id;
06041 GWEN_SIGTAIL *nextObject;
06042 } GWEN_SIGTAIL_LIST__ELEMENT;
06043
06050 typedef struct GWEN_SIGTAIL_LIST GWEN_SIGTAIL_LIST;
06052 struct GWEN_SIGTAIL_LIST {
06053 GWEN_SIGTAIL *first;
06054 uint32_t count;
06055 uint32_t id;
06056 } GWEN_SIGTAIL_LIST;
06057
06062 void GWEN_SigTail_List_AddList(GWEN_SIGTAIL_LIST *dst, GWEN_SIGTAIL_LIST *l);
06063
06067 void GWEN_SigTail_List_Add(GWEN_SIGTAIL *element, GWEN_SIGTAIL_LIST *list);
06068
06073 void GWEN_SigTail_List_Insert(GWEN_SIGTAIL *element, GWEN_SIGTAIL_LIST *list);
06074
06081 void GWEN_SigTail_List_Del(GWEN_SIGTAIL *element);
06082
06086 GWEN_SIGTAIL* GWEN_SigTail_List_First(const GWEN_SIGTAIL_LIST *l);
06087
06091 GWEN_SIGTAIL* GWEN_SigTail_List_Last(const GWEN_SIGTAIL_LIST *l);
06092
06097 void GWEN_SigTail_List_Clear(GWEN_SIGTAIL_LIST *l);
06098
06102 GWEN_SIGTAIL_LIST* GWEN_SigTail_List_new();
06103
06107 void GWEN_SigTail_List_free(GWEN_SIGTAIL_LIST *l);
06108
06112 GWEN_SIGTAIL* GWEN_SigTail_List_Next(const GWEN_SIGTAIL *element);
06113
06117 GWEN_SIGTAIL* GWEN_SigTail_List_Previous(const GWEN_SIGTAIL *element);
06118
06122 uint32_t GWEN_SigTail_List_GetCount(const GWEN_SIGTAIL_LIST *l);
06123
06124 #ifdef __cplusplus
06125 }
06126 #endif
06127
06128
06129 #endif
06130
06131
06132
06133
06134
06135
06136
06137
06138
06139
06140
06141
06142
06143
06144
06145
06146
06147
06148
06149
06150
06151
06152
06153
06154
06155
06156
06157
06158
06159
06160
06161 #ifndef GWEN_CRYPT_TOKEN_CONTEXT_LIST2_H
06162 #define GWEN_CRYPT_TOKEN_CONTEXT_LIST2_H
06163
06164
06165 #ifdef __cplusplus
06166 extern "C" {
06167 #endif
06168
06175 typedef struct GWEN_CRYPT_TOKEN_CONTEXT_LIST2 GWEN_CRYPT_TOKEN_CONTEXT_LIST2;
06176
06180 typedef struct GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR;
06181
06185 typedef GWEN_CRYPT_TOKEN_CONTEXT* (GWEN_CRYPT_TOKEN_CONTEXT_LIST2_FOREACH)(GWEN_CRYPT_TOKEN_CONTEXT *element,
06186 void *user_data);
06187
06191 GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *GWEN_Crypt_Token_Context_List2_new();
06192
06196 void GWEN_Crypt_Token_Context_List2_free(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l);
06197
06201 void GWEN_Crypt_Token_Context_List2_Dump(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l, FILE *f, unsigned int indent);
06202
06206 void GWEN_Crypt_Token_Context_List2_PushBack(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l, GWEN_CRYPT_TOKEN_CONTEXT *p);
06207
06212 void GWEN_Crypt_Token_Context_List2_PushFront(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l, GWEN_CRYPT_TOKEN_CONTEXT *p);
06213
06218 GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_List2_GetFront(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l);
06219
06224 GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_List2_GetBack(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l);
06225
06230 void GWEN_Crypt_Token_Context_List2_Erase(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l,
06231 GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *it);
06232
06238 unsigned int GWEN_Crypt_Token_Context_List2_GetSize(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l);
06239
06244 void GWEN_Crypt_Token_Context_List2_PopBack(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l);
06245
06250 void GWEN_Crypt_Token_Context_List2_PopFront(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l);
06251
06255 void GWEN_Crypt_Token_Context_List2_Clear(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l);
06256
06260 GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *GWEN_Crypt_Token_Context_List2_First(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l);
06261
06265 GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *GWEN_Crypt_Token_Context_List2_Last(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l);
06266
06270 GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *GWEN_Crypt_Token_Context_List2Iterator_new(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l);
06271
06275 void GWEN_Crypt_Token_Context_List2Iterator_free(GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *li);
06276
06281 GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_List2Iterator_Previous(GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *li);
06282
06287 GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_List2Iterator_Next(GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *li);
06288
06293 GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_List2Iterator_Data(GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *li);
06294
06306 GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_List2_ForEach(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *list,
06307 GWEN_CRYPT_TOKEN_CONTEXT_LIST2_FOREACH func,
06308 void *user_data);
06309
06310
06311 typedef struct GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2;
06312 typedef struct GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR;
06313 typedef const GWEN_CRYPT_TOKEN_CONTEXT*
06314 (GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_FOREACH)(const GWEN_CRYPT_TOKEN_CONTEXT *element,
06315 void *user_data);
06316
06317
06318 GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *GWEN_Crypt_Token_Context_ConstList2_new();
06319
06320 void GWEN_Crypt_Token_Context_ConstList2_free(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l);
06321
06322 void GWEN_Crypt_Token_Context_ConstList2_PushBack(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l, const GWEN_CRYPT_TOKEN_CONTEXT *p);
06323
06324 void GWEN_Crypt_Token_Context_ConstList2_PushFront(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l, const GWEN_CRYPT_TOKEN_CONTEXT *p);
06325
06326 const GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_ConstList2_GetFront(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l);
06327
06328 const GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_ConstList2_GetBack(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l);
06329
06330 unsigned int GWEN_Crypt_Token_Context_ConstList2_GetSize(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l);
06331
06332 void GWEN_Crypt_Token_Context_ConstList2_PopBack(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l);
06333
06334 void GWEN_Crypt_Token_Context_ConstList2_PopFront(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l);
06335
06336 void GWEN_Crypt_Token_Context_ConstList2_Clear(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l);
06337
06338 GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_Context_ConstList2_First(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l);
06339
06340 GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_Context_ConstList2_Last(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l);
06341
06342 GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_Context_ConstList2Iterator_new(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l);
06343
06344 void GWEN_Crypt_Token_Context_ConstList2Iterator_free(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *li);
06345
06346 const GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_ConstList2Iterator_Previous(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *li);
06347
06348 const GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_ConstList2Iterator_Next(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *li);
06349
06350 const GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_ConstList2Iterator_Data(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *li);
06351
06363 const GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_ConstList2_ForEach(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *list,
06364 GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_FOREACH func, void *user_data);
06365
06366
06367 #ifdef __cplusplus
06368 }
06369 #endif
06370
06371
06372 #endif
06373
06374
06375
06376
06377
06378
06379
06380
06381
06382
06383
06384
06385
06386
06387
06388
06389
06390
06391
06392
06393
06394
06395
06396
06397
06398
06399
06400
06401
06402
06403
06404 #ifndef GWEN_CRYPT_TOKEN_CONTEXT_LIST1_H
06405 #define GWEN_CRYPT_TOKEN_CONTEXT_LIST1_H
06406
06407 #ifdef __cplusplus
06408 extern "C" {
06409 #endif
06410
06412 typedef struct GWEN_CRYPT_TOKEN_CONTEXT_LIST_ELEMENT {
06413 uint32_t id;
06414 GWEN_CRYPT_TOKEN_CONTEXT *nextObject;
06415 } GWEN_CRYPT_TOKEN_CONTEXT_LIST__ELEMENT;
06416
06423 typedef struct GWEN_CRYPT_TOKEN_CONTEXT_LIST GWEN_CRYPT_TOKEN_CONTEXT_LIST;
06425 struct GWEN_CRYPT_TOKEN_CONTEXT_LIST {
06426 GWEN_CRYPT_TOKEN_CONTEXT *first;
06427 uint32_t count;
06428 uint32_t id;
06429 } GWEN_CRYPT_TOKEN_CONTEXT_LIST;
06430
06435 void GWEN_Crypt_Token_Context_List_AddList(GWEN_CRYPT_TOKEN_CONTEXT_LIST *dst, GWEN_CRYPT_TOKEN_CONTEXT_LIST *l);
06436
06440 void GWEN_Crypt_Token_Context_List_Add(GWEN_CRYPT_TOKEN_CONTEXT *element, GWEN_CRYPT_TOKEN_CONTEXT_LIST *list);
06441
06446 void GWEN_Crypt_Token_Context_List_Insert(GWEN_CRYPT_TOKEN_CONTEXT *element, GWEN_CRYPT_TOKEN_CONTEXT_LIST *list);
06447
06454 void GWEN_Crypt_Token_Context_List_Del(GWEN_CRYPT_TOKEN_CONTEXT *element);
06455
06459 GWEN_CRYPT_TOKEN_CONTEXT* GWEN_Crypt_Token_Context_List_First(const GWEN_CRYPT_TOKEN_CONTEXT_LIST *l);
06460
06464 GWEN_CRYPT_TOKEN_CONTEXT* GWEN_Crypt_Token_Context_List_Last(const GWEN_CRYPT_TOKEN_CONTEXT_LIST *l);
06465
06470 void GWEN_Crypt_Token_Context_List_Clear(GWEN_CRYPT_TOKEN_CONTEXT_LIST *l);
06471
06475 GWEN_CRYPT_TOKEN_CONTEXT_LIST* GWEN_Crypt_Token_Context_List_new();
06476
06480 void GWEN_Crypt_Token_Context_List_free(GWEN_CRYPT_TOKEN_CONTEXT_LIST *l);
06481
06485 GWEN_CRYPT_TOKEN_CONTEXT* GWEN_Crypt_Token_Context_List_Next(const GWEN_CRYPT_TOKEN_CONTEXT *element);
06486
06490 GWEN_CRYPT_TOKEN_CONTEXT* GWEN_Crypt_Token_Context_List_Previous(const GWEN_CRYPT_TOKEN_CONTEXT *element);
06491
06495 uint32_t GWEN_Crypt_Token_Context_List_GetCount(const GWEN_CRYPT_TOKEN_CONTEXT_LIST *l);
06496
06497 #ifdef __cplusplus
06498 }
06499 #endif
06500
06501
06502 #endif
06503
06504
06505
06506
06507
06508
06509
06510
06511
06512
06513
06514
06515
06516
06517
06518
06519
06520
06521
06522
06523
06524
06525
06526
06527
06528
06529
06530
06531
06532
06533
06534 #ifndef GWEN_MDIGEST_LIST2_H
06535 #define GWEN_MDIGEST_LIST2_H
06536
06537
06538 #ifdef __cplusplus
06539 extern "C" {
06540 #endif
06541
06548 typedef struct GWEN_MDIGEST_LIST2 GWEN_MDIGEST_LIST2;
06549
06553 typedef struct GWEN_MDIGEST_LIST2_ITERATOR GWEN_MDIGEST_LIST2_ITERATOR;
06554
06558 typedef GWEN_MDIGEST* (GWEN_MDIGEST_LIST2_FOREACH)(GWEN_MDIGEST *element,
06559 void *user_data);
06560
06564 GWEN_MDIGEST_LIST2 *GWEN_MDigest_List2_new();
06565
06569 void GWEN_MDigest_List2_free(GWEN_MDIGEST_LIST2 *l);
06570
06574 void GWEN_MDigest_List2_Dump(GWEN_MDIGEST_LIST2 *l, FILE *f, unsigned int indent);
06575
06579 void GWEN_MDigest_List2_PushBack(GWEN_MDIGEST_LIST2 *l, GWEN_MDIGEST *p);
06580
06585 void GWEN_MDigest_List2_PushFront(GWEN_MDIGEST_LIST2 *l, GWEN_MDIGEST *p);
06586
06591 GWEN_MDIGEST *GWEN_MDigest_List2_GetFront(GWEN_MDIGEST_LIST2 *l);
06592
06597 GWEN_MDIGEST *GWEN_MDigest_List2_GetBack(GWEN_MDIGEST_LIST2 *l);
06598
06603 void GWEN_MDigest_List2_Erase(GWEN_MDIGEST_LIST2 *l,
06604 GWEN_MDIGEST_LIST2_ITERATOR *it);
06605
06611 unsigned int GWEN_MDigest_List2_GetSize(GWEN_MDIGEST_LIST2 *l);
06612
06617 void GWEN_MDigest_List2_PopBack(GWEN_MDIGEST_LIST2 *l);
06618
06623 void GWEN_MDigest_List2_PopFront(GWEN_MDIGEST_LIST2 *l);
06624
06628 void GWEN_MDigest_List2_Clear(GWEN_MDIGEST_LIST2 *l);
06629
06633 GWEN_MDIGEST_LIST2_ITERATOR *GWEN_MDigest_List2_First(GWEN_MDIGEST_LIST2 *l);
06634
06638 GWEN_MDIGEST_LIST2_ITERATOR *GWEN_MDigest_List2_Last(GWEN_MDIGEST_LIST2 *l);
06639
06643 GWEN_MDIGEST_LIST2_ITERATOR *GWEN_MDigest_List2Iterator_new(GWEN_MDIGEST_LIST2 *l);
06644
06648 void GWEN_MDigest_List2Iterator_free(GWEN_MDIGEST_LIST2_ITERATOR *li);
06649
06654 GWEN_MDIGEST *GWEN_MDigest_List2Iterator_Previous(GWEN_MDIGEST_LIST2_ITERATOR *li);
06655
06660 GWEN_MDIGEST *GWEN_MDigest_List2Iterator_Next(GWEN_MDIGEST_LIST2_ITERATOR *li);
06661
06666 GWEN_MDIGEST *GWEN_MDigest_List2Iterator_Data(GWEN_MDIGEST_LIST2_ITERATOR *li);
06667
06679 GWEN_MDIGEST *GWEN_MDigest_List2_ForEach(GWEN_MDIGEST_LIST2 *list,
06680 GWEN_MDIGEST_LIST2_FOREACH func,
06681 void *user_data);
06682
06683
06684 typedef struct GWEN_MDIGEST_CONSTLIST2 GWEN_MDIGEST_CONSTLIST2;
06685 typedef struct GWEN_MDIGEST_CONSTLIST2_ITERATOR GWEN_MDIGEST_CONSTLIST2_ITERATOR;
06686 typedef const GWEN_MDIGEST*
06687 (GWEN_MDIGEST_CONSTLIST2_FOREACH)(const GWEN_MDIGEST *element,
06688 void *user_data);
06689
06690
06691 GWEN_MDIGEST_CONSTLIST2 *GWEN_MDigest_ConstList2_new();
06692
06693 void GWEN_MDigest_ConstList2_free(GWEN_MDIGEST_CONSTLIST2 *l);
06694
06695 void GWEN_MDigest_ConstList2_PushBack(GWEN_MDIGEST_CONSTLIST2 *l, const GWEN_MDIGEST *p);
06696
06697 void GWEN_MDigest_ConstList2_PushFront(GWEN_MDIGEST_CONSTLIST2 *l, const GWEN_MDIGEST *p);
06698
06699 const GWEN_MDIGEST *GWEN_MDigest_ConstList2_GetFront(GWEN_MDIGEST_CONSTLIST2 *l);
06700
06701 const GWEN_MDIGEST *GWEN_MDigest_ConstList2_GetBack(GWEN_MDIGEST_CONSTLIST2 *l);
06702
06703 unsigned int GWEN_MDigest_ConstList2_GetSize(GWEN_MDIGEST_CONSTLIST2 *l);
06704
06705 void GWEN_MDigest_ConstList2_PopBack(GWEN_MDIGEST_CONSTLIST2 *l);
06706
06707 void GWEN_MDigest_ConstList2_PopFront(GWEN_MDIGEST_CONSTLIST2 *l);
06708
06709 void GWEN_MDigest_ConstList2_Clear(GWEN_MDIGEST_CONSTLIST2 *l);
06710
06711 GWEN_MDIGEST_CONSTLIST2_ITERATOR *GWEN_MDigest_ConstList2_First(GWEN_MDIGEST_CONSTLIST2 *l);
06712
06713 GWEN_MDIGEST_CONSTLIST2_ITERATOR *GWEN_MDigest_ConstList2_Last(GWEN_MDIGEST_CONSTLIST2 *l);
06714
06715 GWEN_MDIGEST_CONSTLIST2_ITERATOR *GWEN_MDigest_ConstList2Iterator_new(GWEN_MDIGEST_CONSTLIST2 *l);
06716
06717 void GWEN_MDigest_ConstList2Iterator_free(GWEN_MDIGEST_CONSTLIST2_ITERATOR *li);
06718
06719 const GWEN_MDIGEST *GWEN_MDigest_ConstList2Iterator_Previous(GWEN_MDIGEST_CONSTLIST2_ITERATOR *li);
06720
06721 const GWEN_MDIGEST *GWEN_MDigest_ConstList2Iterator_Next(GWEN_MDIGEST_CONSTLIST2_ITERATOR *li);
06722
06723 const GWEN_MDIGEST *GWEN_MDigest_ConstList2Iterator_Data(GWEN_MDIGEST_CONSTLIST2_ITERATOR *li);
06724
06736 const GWEN_MDIGEST *GWEN_MDigest_ConstList2_ForEach(GWEN_MDIGEST_CONSTLIST2 *list,
06737 GWEN_MDIGEST_CONSTLIST2_FOREACH func, void *user_data);
06738
06739
06740 #ifdef __cplusplus
06741 }
06742 #endif
06743
06744
06745 #endif
06746
06747
06748
06749
06750
06751
06752
06753
06754
06755
06756
06757
06758
06759
06760
06761
06762
06763
06764
06765
06766
06767
06768
06769
06770
06771
06772
06773
06774
06775
06776
06777 #ifndef GWEN_MDIGEST_LIST1_H
06778 #define GWEN_MDIGEST_LIST1_H
06779
06780 #ifdef __cplusplus
06781 extern "C" {
06782 #endif
06783
06785 typedef struct GWEN_MDIGEST_LIST_ELEMENT {
06786 uint32_t id;
06787 GWEN_MDIGEST *nextObject;
06788 } GWEN_MDIGEST_LIST__ELEMENT;
06789
06796 typedef struct GWEN_MDIGEST_LIST GWEN_MDIGEST_LIST;
06798 struct GWEN_MDIGEST_LIST {
06799 GWEN_MDIGEST *first;
06800 uint32_t count;
06801 uint32_t id;
06802 } GWEN_MDIGEST_LIST;
06803
06808 void GWEN_MDigest_List_AddList(GWEN_MDIGEST_LIST *dst, GWEN_MDIGEST_LIST *l);
06809
06813 void GWEN_MDigest_List_Add(GWEN_MDIGEST *element, GWEN_MDIGEST_LIST *list);
06814
06819 void GWEN_MDigest_List_Insert(GWEN_MDIGEST *element, GWEN_MDIGEST_LIST *list);
06820
06827 void GWEN_MDigest_List_Del(GWEN_MDIGEST *element);
06828
06832 GWEN_MDIGEST* GWEN_MDigest_List_First(const GWEN_MDIGEST_LIST *l);
06833
06837 GWEN_MDIGEST* GWEN_MDigest_List_Last(const GWEN_MDIGEST_LIST *l);
06838
06843 void GWEN_MDigest_List_Clear(GWEN_MDIGEST_LIST *l);
06844
06848 GWEN_MDIGEST_LIST* GWEN_MDigest_List_new();
06849
06853 void GWEN_MDigest_List_free(GWEN_MDIGEST_LIST *l);
06854
06858 GWEN_MDIGEST* GWEN_MDigest_List_Next(const GWEN_MDIGEST *element);
06859
06863 GWEN_MDIGEST* GWEN_MDigest_List_Previous(const GWEN_MDIGEST *element);
06864
06868 uint32_t GWEN_MDigest_List_GetCount(const GWEN_MDIGEST_LIST *l);
06869
06870 #ifdef __cplusplus
06871 }
06872 #endif
06873
06874
06875 #endif
06876
06877
06878
06879
06880
06881
06882
06883
06884
06885
06886
06887
06888
06889
06890
06891
06892
06893
06894
06895
06896
06897
06898
06899
06900
06901
06902
06903
06904
06905
06906
06907 #ifndef t_LIST2_H
06908 #define t_LIST2_H
06909
06910
06911 #ifdef __cplusplus
06912 extern "C" {
06913 #endif
06914
06921 typedef struct t_LIST2 t_LIST2;
06922
06926 typedef struct t_LIST2_ITERATOR t_LIST2_ITERATOR;
06927
06931 typedef t* (t_LIST2_FOREACH)(t *element,
06932 void *user_data);
06933
06937 t_LIST2 *pr_List2_new();
06938
06942 void pr_List2_free(t_LIST2 *l);
06943
06947 void pr_List2_Dump(t_LIST2 *l, FILE *f, unsigned int indent);
06948
06952 void pr_List2_PushBack(t_LIST2 *l, t *p);
06953
06958 void pr_List2_PushFront(t_LIST2 *l, t *p);
06959
06964 t *pr_List2_GetFront(t_LIST2 *l);
06965
06970 t *pr_List2_GetBack(t_LIST2 *l);
06971
06976 void pr_List2_Erase(t_LIST2 *l,
06977 t_LIST2_ITERATOR *it);
06978
06984 unsigned int pr_List2_GetSize(t_LIST2 *l);
06985
06990 void pr_List2_PopBack(t_LIST2 *l);
06991
06996 void pr_List2_PopFront(t_LIST2 *l);
06997
07001 void pr_List2_Clear(t_LIST2 *l);
07002
07006 t_LIST2_ITERATOR *pr_List2_First(t_LIST2 *l);
07007
07011 t_LIST2_ITERATOR *pr_List2_Last(t_LIST2 *l);
07012
07016 t_LIST2_ITERATOR *pr_List2Iterator_new(t_LIST2 *l);
07017
07021 void pr_List2Iterator_free(t_LIST2_ITERATOR *li);
07022
07027 t *pr_List2Iterator_Previous(t_LIST2_ITERATOR *li);
07028
07033 t *pr_List2Iterator_Next(t_LIST2_ITERATOR *li);
07034
07039 t *pr_List2Iterator_Data(t_LIST2_ITERATOR *li);
07040
07052 t *pr_List2_ForEach(t_LIST2 *list,
07053 t_LIST2_FOREACH func,
07054 void *user_data);
07055
07056
07057 typedef struct t_CONSTLIST2 t_CONSTLIST2;
07058 typedef struct t_CONSTLIST2_ITERATOR t_CONSTLIST2_ITERATOR;
07059 typedef const t*
07060 (t_CONSTLIST2_FOREACH)(const t *element,
07061 void *user_data);
07062
07063
07064 t_CONSTLIST2 *pr_ConstList2_new();
07065
07066 void pr_ConstList2_free(t_CONSTLIST2 *l);
07067
07068 void pr_ConstList2_PushBack(t_CONSTLIST2 *l, const t *p);
07069
07070 void pr_ConstList2_PushFront(t_CONSTLIST2 *l, const t *p);
07071
07072 const t *pr_ConstList2_GetFront(t_CONSTLIST2 *l);
07073
07074 const t *pr_ConstList2_GetBack(t_CONSTLIST2 *l);
07075
07076 unsigned int pr_ConstList2_GetSize(t_CONSTLIST2 *l);
07077
07078 void pr_ConstList2_PopBack(t_CONSTLIST2 *l);
07079
07080 void pr_ConstList2_PopFront(t_CONSTLIST2 *l);
07081
07082 void pr_ConstList2_Clear(t_CONSTLIST2 *l);
07083
07084 t_CONSTLIST2_ITERATOR *pr_ConstList2_First(t_CONSTLIST2 *l);
07085
07086 t_CONSTLIST2_ITERATOR *pr_ConstList2_Last(t_CONSTLIST2 *l);
07087
07088 t_CONSTLIST2_ITERATOR *pr_ConstList2Iterator_new(t_CONSTLIST2 *l);
07089
07090 void pr_ConstList2Iterator_free(t_CONSTLIST2_ITERATOR *li);
07091
07092 const t *pr_ConstList2Iterator_Previous(t_CONSTLIST2_ITERATOR *li);
07093
07094 const t *pr_ConstList2Iterator_Next(t_CONSTLIST2_ITERATOR *li);
07095
07096 const t *pr_ConstList2Iterator_Data(t_CONSTLIST2_ITERATOR *li);
07097
07109 const t *pr_ConstList2_ForEach(t_CONSTLIST2 *list,
07110 t_CONSTLIST2_FOREACH func, void *user_data);
07111
07112
07113 #ifdef __cplusplus
07114 }
07115 #endif
07116
07117
07118 #endif
07119
07120
07121
07122
07123
07124
07125
07126
07127
07128
07129
07130
07131
07132
07133
07134
07135
07136
07137
07138
07139
07140
07141
07142
07143
07144
07145
07146
07147
07148
07149
07150 #ifndef t_LIST2_H
07151 #define t_LIST2_H
07152
07153
07154 #ifdef __cplusplus
07155 extern "C" {
07156 #endif
07157
07164 typedef struct t_LIST2 t_LIST2;
07165
07169 typedef struct t_LIST2_ITERATOR t_LIST2_ITERATOR;
07170
07174 typedef t* (t_LIST2_FOREACH)(t *element,
07175 void *user_data);
07176
07180 t_LIST2 *pr_List2_new();
07181
07185 void pr_List2_free(t_LIST2 *l);
07186
07190 void pr_List2_Dump(t_LIST2 *l, FILE *f, unsigned int indent);
07191
07195 void pr_List2_PushBack(t_LIST2 *l, t *p);
07196
07201 void pr_List2_PushFront(t_LIST2 *l, t *p);
07202
07207 t *pr_List2_GetFront(t_LIST2 *l);
07208
07213 t *pr_List2_GetBack(t_LIST2 *l);
07214
07219 void pr_List2_Erase(t_LIST2 *l,
07220 t_LIST2_ITERATOR *it);
07221
07227 unsigned int pr_List2_GetSize(t_LIST2 *l);
07228
07233 void pr_List2_PopBack(t_LIST2 *l);
07234
07239 void pr_List2_PopFront(t_LIST2 *l);
07240
07244 void pr_List2_Clear(t_LIST2 *l);
07245
07249 t_LIST2_ITERATOR *pr_List2_First(t_LIST2 *l);
07250
07254 t_LIST2_ITERATOR *pr_List2_Last(t_LIST2 *l);
07255
07259 t_LIST2_ITERATOR *pr_List2Iterator_new(t_LIST2 *l);
07260
07264 void pr_List2Iterator_free(t_LIST2_ITERATOR *li);
07265
07270 t *pr_List2Iterator_Previous(t_LIST2_ITERATOR *li);
07271
07276 t *pr_List2Iterator_Next(t_LIST2_ITERATOR *li);
07277
07282 t *pr_List2Iterator_Data(t_LIST2_ITERATOR *li);
07283
07295 t *pr_List2_ForEach(t_LIST2 *list,
07296 t_LIST2_FOREACH func,
07297 void *user_data);
07298
07299
07300 typedef struct t_CONSTLIST2 t_CONSTLIST2;
07301 typedef struct t_CONSTLIST2_ITERATOR t_CONSTLIST2_ITERATOR;
07302 typedef const t*
07303 (t_CONSTLIST2_FOREACH)(const t *element,
07304 void *user_data);
07305
07306
07307 t_CONSTLIST2 *pr_ConstList2_new();
07308
07309 void pr_ConstList2_free(t_CONSTLIST2 *l);
07310
07311 void pr_ConstList2_PushBack(t_CONSTLIST2 *l, const t *p);
07312
07313 void pr_ConstList2_PushFront(t_CONSTLIST2 *l, const t *p);
07314
07315 const t *pr_ConstList2_GetFront(t_CONSTLIST2 *l);
07316
07317 const t *pr_ConstList2_GetBack(t_CONSTLIST2 *l);
07318
07319 unsigned int pr_ConstList2_GetSize(t_CONSTLIST2 *l);
07320
07321 void pr_ConstList2_PopBack(t_CONSTLIST2 *l);
07322
07323 void pr_ConstList2_PopFront(t_CONSTLIST2 *l);
07324
07325 void pr_ConstList2_Clear(t_CONSTLIST2 *l);
07326
07327 t_CONSTLIST2_ITERATOR *pr_ConstList2_First(t_CONSTLIST2 *l);
07328
07329 t_CONSTLIST2_ITERATOR *pr_ConstList2_Last(t_CONSTLIST2 *l);
07330
07331 t_CONSTLIST2_ITERATOR *pr_ConstList2Iterator_new(t_CONSTLIST2 *l);
07332
07333 void pr_ConstList2Iterator_free(t_CONSTLIST2_ITERATOR *li);
07334
07335 const t *pr_ConstList2Iterator_Previous(t_CONSTLIST2_ITERATOR *li);
07336
07337 const t *pr_ConstList2Iterator_Next(t_CONSTLIST2_ITERATOR *li);
07338
07339 const t *pr_ConstList2Iterator_Data(t_CONSTLIST2_ITERATOR *li);
07340
07352 const t *pr_ConstList2_ForEach(t_CONSTLIST2 *list,
07353 t_CONSTLIST2_FOREACH func, void *user_data);
07354
07355
07356 #ifdef __cplusplus
07357 }
07358 #endif
07359
07360
07361 #endif
07362
07363
07364
07365
07366
07367
07368
07369
07370
07371
07372
07373
07374
07375
07376
07377
07378
07379
07380
07381
07382
07383
07384
07385
07386
07387
07388
07389
07390
07391
07392
07393 #ifndef GWEN_IPC_REQUEST_LIST2_H
07394 #define GWEN_IPC_REQUEST_LIST2_H
07395
07396
07397 #ifdef __cplusplus
07398 extern "C" {
07399 #endif
07400
07407 typedef struct GWEN_IPC_REQUEST_LIST2 GWEN_IPC_REQUEST_LIST2;
07408
07412 typedef struct GWEN_IPC_REQUEST_LIST2_ITERATOR GWEN_IPC_REQUEST_LIST2_ITERATOR;
07413
07417 typedef GWEN_IPC_REQUEST* (GWEN_IPC_REQUEST_LIST2_FOREACH)(GWEN_IPC_REQUEST *element,
07418 void *user_data);
07419
07423 GWEN_IPC_REQUEST_LIST2 *GWEN_IpcRequest_List2_new();
07424
07428 void GWEN_IpcRequest_List2_free(GWEN_IPC_REQUEST_LIST2 *l);
07429
07433 void GWEN_IpcRequest_List2_Dump(GWEN_IPC_REQUEST_LIST2 *l, FILE *f, unsigned int indent);
07434
07438 void GWEN_IpcRequest_List2_PushBack(GWEN_IPC_REQUEST_LIST2 *l, GWEN_IPC_REQUEST *p);
07439
07444 void GWEN_IpcRequest_List2_PushFront(GWEN_IPC_REQUEST_LIST2 *l, GWEN_IPC_REQUEST *p);
07445
07450 GWEN_IPC_REQUEST *GWEN_IpcRequest_List2_GetFront(GWEN_IPC_REQUEST_LIST2 *l);
07451
07456 GWEN_IPC_REQUEST *GWEN_IpcRequest_List2_GetBack(GWEN_IPC_REQUEST_LIST2 *l);
07457
07462 void GWEN_IpcRequest_List2_Erase(GWEN_IPC_REQUEST_LIST2 *l,
07463 GWEN_IPC_REQUEST_LIST2_ITERATOR *it);
07464
07470 unsigned int GWEN_IpcRequest_List2_GetSize(GWEN_IPC_REQUEST_LIST2 *l);
07471
07476 void GWEN_IpcRequest_List2_PopBack(GWEN_IPC_REQUEST_LIST2 *l);
07477
07482 void GWEN_IpcRequest_List2_PopFront(GWEN_IPC_REQUEST_LIST2 *l);
07483
07487 void GWEN_IpcRequest_List2_Clear(GWEN_IPC_REQUEST_LIST2 *l);
07488
07492 GWEN_IPC_REQUEST_LIST2_ITERATOR *GWEN_IpcRequest_List2_First(GWEN_IPC_REQUEST_LIST2 *l);
07493
07497 GWEN_IPC_REQUEST_LIST2_ITERATOR *GWEN_IpcRequest_List2_Last(GWEN_IPC_REQUEST_LIST2 *l);
07498
07502 GWEN_IPC_REQUEST_LIST2_ITERATOR *GWEN_IpcRequest_List2Iterator_new(GWEN_IPC_REQUEST_LIST2 *l);
07503
07507 void GWEN_IpcRequest_List2Iterator_free(GWEN_IPC_REQUEST_LIST2_ITERATOR *li);
07508
07513 GWEN_IPC_REQUEST *GWEN_IpcRequest_List2Iterator_Previous(GWEN_IPC_REQUEST_LIST2_ITERATOR *li);
07514
07519 GWEN_IPC_REQUEST *GWEN_IpcRequest_List2Iterator_Next(GWEN_IPC_REQUEST_LIST2_ITERATOR *li);
07520
07525 GWEN_IPC_REQUEST *GWEN_IpcRequest_List2Iterator_Data(GWEN_IPC_REQUEST_LIST2_ITERATOR *li);
07526
07538 GWEN_IPC_REQUEST *GWEN_IpcRequest_List2_ForEach(GWEN_IPC_REQUEST_LIST2 *list,
07539 GWEN_IPC_REQUEST_LIST2_FOREACH func,
07540 void *user_data);
07541
07542
07543 typedef struct GWEN_IPC_REQUEST_CONSTLIST2 GWEN_IPC_REQUEST_CONSTLIST2;
07544 typedef struct GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR;
07545 typedef const GWEN_IPC_REQUEST*
07546 (GWEN_IPC_REQUEST_CONSTLIST2_FOREACH)(const GWEN_IPC_REQUEST *element,
07547 void *user_data);
07548
07549
07550 GWEN_IPC_REQUEST_CONSTLIST2 *GWEN_IpcRequest_ConstList2_new();
07551
07552 void GWEN_IpcRequest_ConstList2_free(GWEN_IPC_REQUEST_CONSTLIST2 *l);
07553
07554 void GWEN_IpcRequest_ConstList2_PushBack(GWEN_IPC_REQUEST_CONSTLIST2 *l, const GWEN_IPC_REQUEST *p);
07555
07556 void GWEN_IpcRequest_ConstList2_PushFront(GWEN_IPC_REQUEST_CONSTLIST2 *l, const GWEN_IPC_REQUEST *p);
07557
07558 const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2_GetFront(GWEN_IPC_REQUEST_CONSTLIST2 *l);
07559
07560 const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2_GetBack(GWEN_IPC_REQUEST_CONSTLIST2 *l);
07561
07562 unsigned int GWEN_IpcRequest_ConstList2_GetSize(GWEN_IPC_REQUEST_CONSTLIST2 *l);
07563
07564 void GWEN_IpcRequest_ConstList2_PopBack(GWEN_IPC_REQUEST_CONSTLIST2 *l);
07565
07566 void GWEN_IpcRequest_ConstList2_PopFront(GWEN_IPC_REQUEST_CONSTLIST2 *l);
07567
07568 void GWEN_IpcRequest_ConstList2_Clear(GWEN_IPC_REQUEST_CONSTLIST2 *l);
07569
07570 GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *GWEN_IpcRequest_ConstList2_First(GWEN_IPC_REQUEST_CONSTLIST2 *l);
07571
07572 GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *GWEN_IpcRequest_ConstList2_Last(GWEN_IPC_REQUEST_CONSTLIST2 *l);
07573
07574 GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *GWEN_IpcRequest_ConstList2Iterator_new(GWEN_IPC_REQUEST_CONSTLIST2 *l);
07575
07576 void GWEN_IpcRequest_ConstList2Iterator_free(GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *li);
07577
07578 const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2Iterator_Previous(GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *li);
07579
07580 const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2Iterator_Next(GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *li);
07581
07582 const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2Iterator_Data(GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *li);
07583
07595 const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2_ForEach(GWEN_IPC_REQUEST_CONSTLIST2 *list,
07596 GWEN_IPC_REQUEST_CONSTLIST2_FOREACH func, void *user_data);
07597
07598
07599 #ifdef __cplusplus
07600 }
07601 #endif
07602
07603
07604 #endif
07605
07606
07607
07608
07609
07610
07611
07612
07613
07614
07615
07616
07617
07618
07619
07620
07621
07622
07623
07624
07625
07626
07627
07628
07629
07630
07631
07632
07633
07634
07635
07636 #ifndef GWEN_IPC_REQUEST_LIST1_H
07637 #define GWEN_IPC_REQUEST_LIST1_H
07638
07639 #ifdef __cplusplus
07640 extern "C" {
07641 #endif
07642
07644 typedef struct GWEN_IPC_REQUEST_LIST_ELEMENT {
07645 uint32_t id;
07646 GWEN_IPC_REQUEST *nextObject;
07647 } GWEN_IPC_REQUEST_LIST__ELEMENT;
07648
07655 typedef struct GWEN_IPC_REQUEST_LIST GWEN_IPC_REQUEST_LIST;
07657 struct GWEN_IPC_REQUEST_LIST {
07658 GWEN_IPC_REQUEST *first;
07659 uint32_t count;
07660 uint32_t id;
07661 } GWEN_IPC_REQUEST_LIST;
07662
07667 void GWEN_IpcRequest_List_AddList(GWEN_IPC_REQUEST_LIST *dst, GWEN_IPC_REQUEST_LIST *l);
07668
07672 void GWEN_IpcRequest_List_Add(GWEN_IPC_REQUEST *element, GWEN_IPC_REQUEST_LIST *list);
07673
07678 void GWEN_IpcRequest_List_Insert(GWEN_IPC_REQUEST *element, GWEN_IPC_REQUEST_LIST *list);
07679
07686 void GWEN_IpcRequest_List_Del(GWEN_IPC_REQUEST *element);
07687
07691 GWEN_IPC_REQUEST* GWEN_IpcRequest_List_First(const GWEN_IPC_REQUEST_LIST *l);
07692
07696 GWEN_IPC_REQUEST* GWEN_IpcRequest_List_Last(const GWEN_IPC_REQUEST_LIST *l);
07697
07702 void GWEN_IpcRequest_List_Clear(GWEN_IPC_REQUEST_LIST *l);
07703
07707 GWEN_IPC_REQUEST_LIST* GWEN_IpcRequest_List_new();
07708
07712 void GWEN_IpcRequest_List_free(GWEN_IPC_REQUEST_LIST *l);
07713
07717 GWEN_IPC_REQUEST* GWEN_IpcRequest_List_Next(const GWEN_IPC_REQUEST *element);
07718
07722 GWEN_IPC_REQUEST* GWEN_IpcRequest_List_Previous(const GWEN_IPC_REQUEST *element);
07723
07727 uint32_t GWEN_IpcRequest_List_GetCount(const GWEN_IPC_REQUEST_LIST *l);
07728
07729 #ifdef __cplusplus
07730 }
07731 #endif
07732
07733
07734 #endif
07735
07736
07737