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_INHERITDATA_LIST1_H
00030 #define GWEN_INHERITDATA_LIST1_H
00031
00032 #ifdef __cplusplus
00033 extern "C" {
00034 #endif
00035
00037 typedef struct GWEN_INHERITDATA_LIST_ELEMENT {
00038 uint32_t id;
00039 GWEN_INHERITDATA *nextObject;
00040 } GWEN_INHERITDATA_LIST__ELEMENT;
00041
00048 typedef struct GWEN_INHERITDATA_LIST GWEN_INHERITDATA_LIST;
00050 struct GWEN_INHERITDATA_LIST {
00051 GWEN_INHERITDATA *first;
00052 uint32_t count;
00053 uint32_t id;
00054 } GWEN_INHERITDATA_LIST;
00055
00060 void GWEN_InheritData_List_AddList(GWEN_INHERITDATA_LIST *dst, GWEN_INHERITDATA_LIST *l);
00061
00065 void GWEN_InheritData_List_Add(GWEN_INHERITDATA *element, GWEN_INHERITDATA_LIST *list);
00066
00071 void GWEN_InheritData_List_Insert(GWEN_INHERITDATA *element, GWEN_INHERITDATA_LIST *list);
00072
00079 void GWEN_InheritData_List_Del(GWEN_INHERITDATA *element);
00080
00084 GWEN_INHERITDATA* GWEN_InheritData_List_First(const GWEN_INHERITDATA_LIST *l);
00085
00089 GWEN_INHERITDATA* GWEN_InheritData_List_Last(const GWEN_INHERITDATA_LIST *l);
00090
00095 void GWEN_InheritData_List_Clear(GWEN_INHERITDATA_LIST *l);
00096
00100 GWEN_INHERITDATA_LIST* GWEN_InheritData_List_new();
00101
00105 void GWEN_InheritData_List_free(GWEN_INHERITDATA_LIST *l);
00106
00110 GWEN_INHERITDATA* GWEN_InheritData_List_Next(const GWEN_INHERITDATA *element);
00111
00115 GWEN_INHERITDATA* GWEN_InheritData_List_Previous(const GWEN_INHERITDATA *element);
00116
00120 uint32_t GWEN_InheritData_List_GetCount(const GWEN_INHERITDATA_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 t_LIST1_H
00160 #define t_LIST1_H
00161
00162 #ifdef __cplusplus
00163 extern "C" {
00164 #endif
00165
00167 typedef struct t_LIST_ELEMENT {
00168 uint32_t id;
00169 t *nextObject;
00170 } t_LIST__ELEMENT;
00171
00178 typedef struct t_LIST t_LIST;
00180 struct t_LIST {
00181 t *first;
00182 uint32_t count;
00183 uint32_t id;
00184 } t_LIST;
00185
00190 void pr_List_AddList(t_LIST *dst, t_LIST *l);
00191
00195 void pr_List_Add(t *element, t_LIST *list);
00196
00201 void pr_List_Insert(t *element, t_LIST *list);
00202
00209 void pr_List_Del(t *element);
00210
00214 t* pr_List_First(const t_LIST *l);
00215
00219 t* pr_List_Last(const t_LIST *l);
00220
00225 void pr_List_Clear(t_LIST *l);
00226
00230 t_LIST* pr_List_new();
00231
00235 void pr_List_free(t_LIST *l);
00236
00240 t* pr_List_Next(const t *element);
00241
00245 t* pr_List_Previous(const t *element);
00246
00250 uint32_t pr_List_GetCount(const t_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 MYSTRUCT_LIST1_H
00290 #define MYSTRUCT_LIST1_H
00291
00292 #ifdef __cplusplus
00293 extern "C" {
00294 #endif
00295
00297 typedef struct MYSTRUCT_LIST_ELEMENT {
00298 uint32_t id;
00299 MYSTRUCT *nextObject;
00300 } MYSTRUCT_LIST__ELEMENT;
00301
00308 typedef struct MYSTRUCT_LIST MYSTRUCT_LIST;
00310 struct MYSTRUCT_LIST {
00311 MYSTRUCT *first;
00312 uint32_t count;
00313 uint32_t id;
00314 } MYSTRUCT_LIST;
00315
00320 void MyStruct_List_AddList(MYSTRUCT_LIST *dst, MYSTRUCT_LIST *l);
00321
00325 void MyStruct_List_Add(MYSTRUCT *element, MYSTRUCT_LIST *list);
00326
00331 void MyStruct_List_Insert(MYSTRUCT *element, MYSTRUCT_LIST *list);
00332
00339 void MyStruct_List_Del(MYSTRUCT *element);
00340
00344 MYSTRUCT* MyStruct_List_First(const MYSTRUCT_LIST *l);
00345
00349 MYSTRUCT* MyStruct_List_Last(const MYSTRUCT_LIST *l);
00350
00355 void MyStruct_List_Clear(MYSTRUCT_LIST *l);
00356
00360 MYSTRUCT_LIST* MyStruct_List_new();
00361
00365 void MyStruct_List_free(MYSTRUCT_LIST *l);
00366
00370 MYSTRUCT* MyStruct_List_Next(const MYSTRUCT *element);
00371
00375 MYSTRUCT* MyStruct_List_Previous(const MYSTRUCT *element);
00376
00380 uint32_t MyStruct_List_GetCount(const MYSTRUCT_LIST *l);
00381
00382 #ifdef __cplusplus
00383 }
00384 #endif
00385
00386
00387 #endif
00388
00389
00390
00391
00392
00393
00394
00395
00396
00397
00398
00399
00400
00401
00402
00403
00404
00405
00406
00407
00408
00409
00410
00411
00412
00413
00414
00415
00416
00417
00418
00419 #ifndef t_LIST2_H
00420 #define t_LIST2_H
00421
00422
00423 #ifdef __cplusplus
00424 extern "C" {
00425 #endif
00426
00433 typedef struct t_LIST2 t_LIST2;
00434
00438 typedef struct t_LIST2_ITERATOR t_LIST2_ITERATOR;
00439
00443 typedef t* (t_LIST2_FOREACH)(t *element,
00444 void *user_data);
00445
00449 t_LIST2 *pr_List2_new();
00450
00454 void pr_List2_free(t_LIST2 *l);
00455
00459 void pr_List2_Dump(t_LIST2 *l, FILE *f, unsigned int indent);
00460
00464 void pr_List2_PushBack(t_LIST2 *l, t *p);
00465
00470 void pr_List2_PushFront(t_LIST2 *l, t *p);
00471
00476 t *pr_List2_GetFront(t_LIST2 *l);
00477
00482 t *pr_List2_GetBack(t_LIST2 *l);
00483
00488 void pr_List2_Erase(t_LIST2 *l,
00489 t_LIST2_ITERATOR *it);
00490
00496 unsigned int pr_List2_GetSize(t_LIST2 *l);
00497
00502 void pr_List2_PopBack(t_LIST2 *l);
00503
00508 void pr_List2_PopFront(t_LIST2 *l);
00509
00513 void pr_List2_Clear(t_LIST2 *l);
00514
00518 t_LIST2_ITERATOR *pr_List2_First(t_LIST2 *l);
00519
00523 t_LIST2_ITERATOR *pr_List2_Last(t_LIST2 *l);
00524
00528 t_LIST2_ITERATOR *pr_List2Iterator_new(t_LIST2 *l);
00529
00533 void pr_List2Iterator_free(t_LIST2_ITERATOR *li);
00534
00539 t *pr_List2Iterator_Previous(t_LIST2_ITERATOR *li);
00540
00545 t *pr_List2Iterator_Next(t_LIST2_ITERATOR *li);
00546
00551 t *pr_List2Iterator_Data(t_LIST2_ITERATOR *li);
00552
00564 t *pr_List2_ForEach(t_LIST2 *list,
00565 t_LIST2_FOREACH func,
00566 void *user_data);
00567
00568
00569 typedef struct t_CONSTLIST2 t_CONSTLIST2;
00570 typedef struct t_CONSTLIST2_ITERATOR t_CONSTLIST2_ITERATOR;
00571 typedef const t*
00572 (t_CONSTLIST2_FOREACH)(const t *element,
00573 void *user_data);
00574
00575
00576 t_CONSTLIST2 *pr_ConstList2_new();
00577
00578 void pr_ConstList2_free(t_CONSTLIST2 *l);
00579
00580 void pr_ConstList2_PushBack(t_CONSTLIST2 *l, const t *p);
00581
00582 void pr_ConstList2_PushFront(t_CONSTLIST2 *l, const t *p);
00583
00584 const t *pr_ConstList2_GetFront(t_CONSTLIST2 *l);
00585
00586 const t *pr_ConstList2_GetBack(t_CONSTLIST2 *l);
00587
00588 unsigned int pr_ConstList2_GetSize(t_CONSTLIST2 *l);
00589
00590 void pr_ConstList2_PopBack(t_CONSTLIST2 *l);
00591
00592 void pr_ConstList2_PopFront(t_CONSTLIST2 *l);
00593
00594 void pr_ConstList2_Clear(t_CONSTLIST2 *l);
00595
00596 t_CONSTLIST2_ITERATOR *pr_ConstList2_First(t_CONSTLIST2 *l);
00597
00598 t_CONSTLIST2_ITERATOR *pr_ConstList2_Last(t_CONSTLIST2 *l);
00599
00600 t_CONSTLIST2_ITERATOR *pr_ConstList2Iterator_new(t_CONSTLIST2 *l);
00601
00602 void pr_ConstList2Iterator_free(t_CONSTLIST2_ITERATOR *li);
00603
00604 const t *pr_ConstList2Iterator_Previous(t_CONSTLIST2_ITERATOR *li);
00605
00606 const t *pr_ConstList2Iterator_Next(t_CONSTLIST2_ITERATOR *li);
00607
00608 const t *pr_ConstList2Iterator_Data(t_CONSTLIST2_ITERATOR *li);
00609
00621 const t *pr_ConstList2_ForEach(t_CONSTLIST2 *list,
00622 t_CONSTLIST2_FOREACH func, void *user_data);
00623
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 t_LIST2_H
00663 #define t_LIST2_H
00664
00665
00666 #ifdef __cplusplus
00667 extern "C" {
00668 #endif
00669
00676 typedef struct t_LIST2 t_LIST2;
00677
00681 typedef struct t_LIST2_ITERATOR t_LIST2_ITERATOR;
00682
00686 typedef t* (t_LIST2_FOREACH)(t *element,
00687 void *user_data);
00688
00692 t_LIST2 *pr_List2_new();
00693
00697 void pr_List2_free(t_LIST2 *l);
00698
00702 void pr_List2_Dump(t_LIST2 *l, FILE *f, unsigned int indent);
00703
00707 void pr_List2_PushBack(t_LIST2 *l, t *p);
00708
00713 void pr_List2_PushFront(t_LIST2 *l, t *p);
00714
00719 t *pr_List2_GetFront(t_LIST2 *l);
00720
00725 t *pr_List2_GetBack(t_LIST2 *l);
00726
00731 void pr_List2_Erase(t_LIST2 *l,
00732 t_LIST2_ITERATOR *it);
00733
00739 unsigned int pr_List2_GetSize(t_LIST2 *l);
00740
00745 void pr_List2_PopBack(t_LIST2 *l);
00746
00751 void pr_List2_PopFront(t_LIST2 *l);
00752
00756 void pr_List2_Clear(t_LIST2 *l);
00757
00761 t_LIST2_ITERATOR *pr_List2_First(t_LIST2 *l);
00762
00766 t_LIST2_ITERATOR *pr_List2_Last(t_LIST2 *l);
00767
00771 t_LIST2_ITERATOR *pr_List2Iterator_new(t_LIST2 *l);
00772
00776 void pr_List2Iterator_free(t_LIST2_ITERATOR *li);
00777
00782 t *pr_List2Iterator_Previous(t_LIST2_ITERATOR *li);
00783
00788 t *pr_List2Iterator_Next(t_LIST2_ITERATOR *li);
00789
00794 t *pr_List2Iterator_Data(t_LIST2_ITERATOR *li);
00795
00807 t *pr_List2_ForEach(t_LIST2 *list,
00808 t_LIST2_FOREACH func,
00809 void *user_data);
00810
00811
00812 typedef struct t_CONSTLIST2 t_CONSTLIST2;
00813 typedef struct t_CONSTLIST2_ITERATOR t_CONSTLIST2_ITERATOR;
00814 typedef const t*
00815 (t_CONSTLIST2_FOREACH)(const t *element,
00816 void *user_data);
00817
00818
00819 t_CONSTLIST2 *pr_ConstList2_new();
00820
00821 void pr_ConstList2_free(t_CONSTLIST2 *l);
00822
00823 void pr_ConstList2_PushBack(t_CONSTLIST2 *l, const t *p);
00824
00825 void pr_ConstList2_PushFront(t_CONSTLIST2 *l, const t *p);
00826
00827 const t *pr_ConstList2_GetFront(t_CONSTLIST2 *l);
00828
00829 const t *pr_ConstList2_GetBack(t_CONSTLIST2 *l);
00830
00831 unsigned int pr_ConstList2_GetSize(t_CONSTLIST2 *l);
00832
00833 void pr_ConstList2_PopBack(t_CONSTLIST2 *l);
00834
00835 void pr_ConstList2_PopFront(t_CONSTLIST2 *l);
00836
00837 void pr_ConstList2_Clear(t_CONSTLIST2 *l);
00838
00839 t_CONSTLIST2_ITERATOR *pr_ConstList2_First(t_CONSTLIST2 *l);
00840
00841 t_CONSTLIST2_ITERATOR *pr_ConstList2_Last(t_CONSTLIST2 *l);
00842
00843 t_CONSTLIST2_ITERATOR *pr_ConstList2Iterator_new(t_CONSTLIST2 *l);
00844
00845 void pr_ConstList2Iterator_free(t_CONSTLIST2_ITERATOR *li);
00846
00847 const t *pr_ConstList2Iterator_Previous(t_CONSTLIST2_ITERATOR *li);
00848
00849 const t *pr_ConstList2Iterator_Next(t_CONSTLIST2_ITERATOR *li);
00850
00851 const t *pr_ConstList2Iterator_Data(t_CONSTLIST2_ITERATOR *li);
00852
00864 const t *pr_ConstList2_ForEach(t_CONSTLIST2 *list,
00865 t_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_PLUGIN_DESCRIPTION_LIST2_H
00906 #define GWEN_PLUGIN_DESCRIPTION_LIST2_H
00907
00908
00909 #ifdef __cplusplus
00910 extern "C" {
00911 #endif
00912
00919 typedef struct GWEN_PLUGIN_DESCRIPTION_LIST2 GWEN_PLUGIN_DESCRIPTION_LIST2;
00920
00924 typedef struct GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR;
00925
00929 typedef GWEN_PLUGIN_DESCRIPTION* (GWEN_PLUGIN_DESCRIPTION_LIST2_FOREACH)(GWEN_PLUGIN_DESCRIPTION *element,
00930 void *user_data);
00931
00935 GWEN_PLUGIN_DESCRIPTION_LIST2 *GWEN_PluginDescription_List2_new();
00936
00940 void GWEN_PluginDescription_List2_free(GWEN_PLUGIN_DESCRIPTION_LIST2 *l);
00941
00945 void GWEN_PluginDescription_List2_Dump(GWEN_PLUGIN_DESCRIPTION_LIST2 *l, FILE *f, unsigned int indent);
00946
00950 void GWEN_PluginDescription_List2_PushBack(GWEN_PLUGIN_DESCRIPTION_LIST2 *l, GWEN_PLUGIN_DESCRIPTION *p);
00951
00956 void GWEN_PluginDescription_List2_PushFront(GWEN_PLUGIN_DESCRIPTION_LIST2 *l, GWEN_PLUGIN_DESCRIPTION *p);
00957
00962 GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_List2_GetFront(GWEN_PLUGIN_DESCRIPTION_LIST2 *l);
00963
00968 GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_List2_GetBack(GWEN_PLUGIN_DESCRIPTION_LIST2 *l);
00969
00974 void GWEN_PluginDescription_List2_Erase(GWEN_PLUGIN_DESCRIPTION_LIST2 *l,
00975 GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *it);
00976
00982 unsigned int GWEN_PluginDescription_List2_GetSize(GWEN_PLUGIN_DESCRIPTION_LIST2 *l);
00983
00988 void GWEN_PluginDescription_List2_PopBack(GWEN_PLUGIN_DESCRIPTION_LIST2 *l);
00989
00994 void GWEN_PluginDescription_List2_PopFront(GWEN_PLUGIN_DESCRIPTION_LIST2 *l);
00995
00999 void GWEN_PluginDescription_List2_Clear(GWEN_PLUGIN_DESCRIPTION_LIST2 *l);
01000
01004 GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *GWEN_PluginDescription_List2_First(GWEN_PLUGIN_DESCRIPTION_LIST2 *l);
01005
01009 GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *GWEN_PluginDescription_List2_Last(GWEN_PLUGIN_DESCRIPTION_LIST2 *l);
01010
01014 GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *GWEN_PluginDescription_List2Iterator_new(GWEN_PLUGIN_DESCRIPTION_LIST2 *l);
01015
01019 void GWEN_PluginDescription_List2Iterator_free(GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *li);
01020
01025 GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_List2Iterator_Previous(GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *li);
01026
01031 GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_List2Iterator_Next(GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *li);
01032
01037 GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_List2Iterator_Data(GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *li);
01038
01050 GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_List2_ForEach(GWEN_PLUGIN_DESCRIPTION_LIST2 *list,
01051 GWEN_PLUGIN_DESCRIPTION_LIST2_FOREACH func,
01052 void *user_data);
01053
01054
01055 typedef struct GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 GWEN_PLUGIN_DESCRIPTION_CONSTLIST2;
01056 typedef struct GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR;
01057 typedef const GWEN_PLUGIN_DESCRIPTION*
01058 (GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_FOREACH)(const GWEN_PLUGIN_DESCRIPTION *element,
01059 void *user_data);
01060
01061
01062 GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *GWEN_PluginDescription_ConstList2_new();
01063
01064 void GWEN_PluginDescription_ConstList2_free(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l);
01065
01066 void GWEN_PluginDescription_ConstList2_PushBack(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l, const GWEN_PLUGIN_DESCRIPTION *p);
01067
01068 void GWEN_PluginDescription_ConstList2_PushFront(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l, const GWEN_PLUGIN_DESCRIPTION *p);
01069
01070 const GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_ConstList2_GetFront(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l);
01071
01072 const GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_ConstList2_GetBack(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l);
01073
01074 unsigned int GWEN_PluginDescription_ConstList2_GetSize(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l);
01075
01076 void GWEN_PluginDescription_ConstList2_PopBack(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l);
01077
01078 void GWEN_PluginDescription_ConstList2_PopFront(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l);
01079
01080 void GWEN_PluginDescription_ConstList2_Clear(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l);
01081
01082 GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *GWEN_PluginDescription_ConstList2_First(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l);
01083
01084 GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *GWEN_PluginDescription_ConstList2_Last(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l);
01085
01086 GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *GWEN_PluginDescription_ConstList2Iterator_new(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l);
01087
01088 void GWEN_PluginDescription_ConstList2Iterator_free(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *li);
01089
01090 const GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_ConstList2Iterator_Previous(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *li);
01091
01092 const GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_ConstList2Iterator_Next(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *li);
01093
01094 const GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_ConstList2Iterator_Data(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *li);
01095
01107 const GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_ConstList2_ForEach(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *list,
01108 GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_FOREACH func, void *user_data);
01109
01110
01111 #ifdef __cplusplus
01112 }
01113 #endif
01114
01115
01116 #endif
01117
01118
01119
01120
01121
01122
01123
01124
01125
01126
01127
01128
01129
01130
01131
01132
01133
01134
01135
01136
01137
01138
01139
01140
01141
01142
01143
01144
01145
01146
01147
01148 #ifndef GWEN_PLUGIN_DESCRIPTION_LIST1_H
01149 #define GWEN_PLUGIN_DESCRIPTION_LIST1_H
01150
01151 #ifdef __cplusplus
01152 extern "C" {
01153 #endif
01154
01156 typedef struct GWEN_PLUGIN_DESCRIPTION_LIST_ELEMENT {
01157 uint32_t id;
01158 GWEN_PLUGIN_DESCRIPTION *nextObject;
01159 } GWEN_PLUGIN_DESCRIPTION_LIST__ELEMENT;
01160
01167 typedef struct GWEN_PLUGIN_DESCRIPTION_LIST GWEN_PLUGIN_DESCRIPTION_LIST;
01169 struct GWEN_PLUGIN_DESCRIPTION_LIST {
01170 GWEN_PLUGIN_DESCRIPTION *first;
01171 uint32_t count;
01172 uint32_t id;
01173 } GWEN_PLUGIN_DESCRIPTION_LIST;
01174
01179 void GWEN_PluginDescription_List_AddList(GWEN_PLUGIN_DESCRIPTION_LIST *dst, GWEN_PLUGIN_DESCRIPTION_LIST *l);
01180
01184 void GWEN_PluginDescription_List_Add(GWEN_PLUGIN_DESCRIPTION *element, GWEN_PLUGIN_DESCRIPTION_LIST *list);
01185
01190 void GWEN_PluginDescription_List_Insert(GWEN_PLUGIN_DESCRIPTION *element, GWEN_PLUGIN_DESCRIPTION_LIST *list);
01191
01198 void GWEN_PluginDescription_List_Del(GWEN_PLUGIN_DESCRIPTION *element);
01199
01203 GWEN_PLUGIN_DESCRIPTION* GWEN_PluginDescription_List_First(const GWEN_PLUGIN_DESCRIPTION_LIST *l);
01204
01208 GWEN_PLUGIN_DESCRIPTION* GWEN_PluginDescription_List_Last(const GWEN_PLUGIN_DESCRIPTION_LIST *l);
01209
01214 void GWEN_PluginDescription_List_Clear(GWEN_PLUGIN_DESCRIPTION_LIST *l);
01215
01219 GWEN_PLUGIN_DESCRIPTION_LIST* GWEN_PluginDescription_List_new();
01220
01224 void GWEN_PluginDescription_List_free(GWEN_PLUGIN_DESCRIPTION_LIST *l);
01225
01229 GWEN_PLUGIN_DESCRIPTION* GWEN_PluginDescription_List_Next(const GWEN_PLUGIN_DESCRIPTION *element);
01230
01234 GWEN_PLUGIN_DESCRIPTION* GWEN_PluginDescription_List_Previous(const GWEN_PLUGIN_DESCRIPTION *element);
01235
01239 uint32_t GWEN_PluginDescription_List_GetCount(const GWEN_PLUGIN_DESCRIPTION_LIST *l);
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_CRYPTALGO_LIST2_H
01279 #define GWEN_CRYPT_CRYPTALGO_LIST2_H
01280
01281
01282 #ifdef __cplusplus
01283 extern "C" {
01284 #endif
01285
01292 typedef struct GWEN_CRYPT_CRYPTALGO_LIST2 GWEN_CRYPT_CRYPTALGO_LIST2;
01293
01297 typedef struct GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR;
01298
01302 typedef GWEN_CRYPT_CRYPTALGO* (GWEN_CRYPT_CRYPTALGO_LIST2_FOREACH)(GWEN_CRYPT_CRYPTALGO *element,
01303 void *user_data);
01304
01308 GWEN_CRYPT_CRYPTALGO_LIST2 *GWEN_Crypt_CryptAlgo_List2_new();
01309
01313 void GWEN_Crypt_CryptAlgo_List2_free(GWEN_CRYPT_CRYPTALGO_LIST2 *l);
01314
01318 void GWEN_Crypt_CryptAlgo_List2_Dump(GWEN_CRYPT_CRYPTALGO_LIST2 *l, FILE *f, unsigned int indent);
01319
01323 void GWEN_Crypt_CryptAlgo_List2_PushBack(GWEN_CRYPT_CRYPTALGO_LIST2 *l, GWEN_CRYPT_CRYPTALGO *p);
01324
01329 void GWEN_Crypt_CryptAlgo_List2_PushFront(GWEN_CRYPT_CRYPTALGO_LIST2 *l, GWEN_CRYPT_CRYPTALGO *p);
01330
01335 GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_List2_GetFront(GWEN_CRYPT_CRYPTALGO_LIST2 *l);
01336
01341 GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_List2_GetBack(GWEN_CRYPT_CRYPTALGO_LIST2 *l);
01342
01347 void GWEN_Crypt_CryptAlgo_List2_Erase(GWEN_CRYPT_CRYPTALGO_LIST2 *l,
01348 GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *it);
01349
01355 unsigned int GWEN_Crypt_CryptAlgo_List2_GetSize(GWEN_CRYPT_CRYPTALGO_LIST2 *l);
01356
01361 void GWEN_Crypt_CryptAlgo_List2_PopBack(GWEN_CRYPT_CRYPTALGO_LIST2 *l);
01362
01367 void GWEN_Crypt_CryptAlgo_List2_PopFront(GWEN_CRYPT_CRYPTALGO_LIST2 *l);
01368
01372 void GWEN_Crypt_CryptAlgo_List2_Clear(GWEN_CRYPT_CRYPTALGO_LIST2 *l);
01373
01377 GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *GWEN_Crypt_CryptAlgo_List2_First(GWEN_CRYPT_CRYPTALGO_LIST2 *l);
01378
01382 GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *GWEN_Crypt_CryptAlgo_List2_Last(GWEN_CRYPT_CRYPTALGO_LIST2 *l);
01383
01387 GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *GWEN_Crypt_CryptAlgo_List2Iterator_new(GWEN_CRYPT_CRYPTALGO_LIST2 *l);
01388
01392 void GWEN_Crypt_CryptAlgo_List2Iterator_free(GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *li);
01393
01398 GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_List2Iterator_Previous(GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *li);
01399
01404 GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_List2Iterator_Next(GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *li);
01405
01410 GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_List2Iterator_Data(GWEN_CRYPT_CRYPTALGO_LIST2_ITERATOR *li);
01411
01423 GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_List2_ForEach(GWEN_CRYPT_CRYPTALGO_LIST2 *list,
01424 GWEN_CRYPT_CRYPTALGO_LIST2_FOREACH func,
01425 void *user_data);
01426
01427
01428 typedef struct GWEN_CRYPT_CRYPTALGO_CONSTLIST2 GWEN_CRYPT_CRYPTALGO_CONSTLIST2;
01429 typedef struct GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR;
01430 typedef const GWEN_CRYPT_CRYPTALGO*
01431 (GWEN_CRYPT_CRYPTALGO_CONSTLIST2_FOREACH)(const GWEN_CRYPT_CRYPTALGO *element,
01432 void *user_data);
01433
01434
01435 GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *GWEN_Crypt_CryptAlgo_ConstList2_new();
01436
01437 void GWEN_Crypt_CryptAlgo_ConstList2_free(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l);
01438
01439 void GWEN_Crypt_CryptAlgo_ConstList2_PushBack(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l, const GWEN_CRYPT_CRYPTALGO *p);
01440
01441 void GWEN_Crypt_CryptAlgo_ConstList2_PushFront(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l, const GWEN_CRYPT_CRYPTALGO *p);
01442
01443 const GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_ConstList2_GetFront(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l);
01444
01445 const GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_ConstList2_GetBack(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l);
01446
01447 unsigned int GWEN_Crypt_CryptAlgo_ConstList2_GetSize(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l);
01448
01449 void GWEN_Crypt_CryptAlgo_ConstList2_PopBack(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l);
01450
01451 void GWEN_Crypt_CryptAlgo_ConstList2_PopFront(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l);
01452
01453 void GWEN_Crypt_CryptAlgo_ConstList2_Clear(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l);
01454
01455 GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_CryptAlgo_ConstList2_First(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l);
01456
01457 GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_CryptAlgo_ConstList2_Last(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l);
01458
01459 GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_CryptAlgo_ConstList2Iterator_new(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *l);
01460
01461 void GWEN_Crypt_CryptAlgo_ConstList2Iterator_free(GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR *li);
01462
01463 const GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_ConstList2Iterator_Previous(GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR *li);
01464
01465 const GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_ConstList2Iterator_Next(GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR *li);
01466
01467 const GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_ConstList2Iterator_Data(GWEN_CRYPT_CRYPTALGO_CONSTLIST2_ITERATOR *li);
01468
01480 const GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_ConstList2_ForEach(GWEN_CRYPT_CRYPTALGO_CONSTLIST2 *list,
01481 GWEN_CRYPT_CRYPTALGO_CONSTLIST2_FOREACH func, void *user_data);
01482
01483
01484 #ifdef __cplusplus
01485 }
01486 #endif
01487
01488
01489 #endif
01490
01491
01492
01493
01494
01495
01496
01497
01498
01499
01500
01501
01502
01503
01504
01505
01506
01507
01508
01509
01510
01511
01512
01513
01514
01515
01516
01517
01518
01519
01520
01521 #ifndef GWEN_CRYPT_KEY_LIST2_H
01522 #define GWEN_CRYPT_KEY_LIST2_H
01523
01524
01525 #ifdef __cplusplus
01526 extern "C" {
01527 #endif
01528
01535 typedef struct GWEN_CRYPT_KEY_LIST2 GWEN_CRYPT_KEY_LIST2;
01536
01540 typedef struct GWEN_CRYPT_KEY_LIST2_ITERATOR GWEN_CRYPT_KEY_LIST2_ITERATOR;
01541
01545 typedef GWEN_CRYPT_KEY* (GWEN_CRYPT_KEY_LIST2_FOREACH)(GWEN_CRYPT_KEY *element,
01546 void *user_data);
01547
01551 GWEN_CRYPT_KEY_LIST2 *GWEN_Crypt_Key_List2_new();
01552
01556 void GWEN_Crypt_Key_List2_free(GWEN_CRYPT_KEY_LIST2 *l);
01557
01561 void GWEN_Crypt_Key_List2_Dump(GWEN_CRYPT_KEY_LIST2 *l, FILE *f, unsigned int indent);
01562
01566 void GWEN_Crypt_Key_List2_PushBack(GWEN_CRYPT_KEY_LIST2 *l, GWEN_CRYPT_KEY *p);
01567
01572 void GWEN_Crypt_Key_List2_PushFront(GWEN_CRYPT_KEY_LIST2 *l, GWEN_CRYPT_KEY *p);
01573
01578 GWEN_CRYPT_KEY *GWEN_Crypt_Key_List2_GetFront(GWEN_CRYPT_KEY_LIST2 *l);
01579
01584 GWEN_CRYPT_KEY *GWEN_Crypt_Key_List2_GetBack(GWEN_CRYPT_KEY_LIST2 *l);
01585
01590 void GWEN_Crypt_Key_List2_Erase(GWEN_CRYPT_KEY_LIST2 *l,
01591 GWEN_CRYPT_KEY_LIST2_ITERATOR *it);
01592
01598 unsigned int GWEN_Crypt_Key_List2_GetSize(GWEN_CRYPT_KEY_LIST2 *l);
01599
01604 void GWEN_Crypt_Key_List2_PopBack(GWEN_CRYPT_KEY_LIST2 *l);
01605
01610 void GWEN_Crypt_Key_List2_PopFront(GWEN_CRYPT_KEY_LIST2 *l);
01611
01615 void GWEN_Crypt_Key_List2_Clear(GWEN_CRYPT_KEY_LIST2 *l);
01616
01620 GWEN_CRYPT_KEY_LIST2_ITERATOR *GWEN_Crypt_Key_List2_First(GWEN_CRYPT_KEY_LIST2 *l);
01621
01625 GWEN_CRYPT_KEY_LIST2_ITERATOR *GWEN_Crypt_Key_List2_Last(GWEN_CRYPT_KEY_LIST2 *l);
01626
01630 GWEN_CRYPT_KEY_LIST2_ITERATOR *GWEN_Crypt_Key_List2Iterator_new(GWEN_CRYPT_KEY_LIST2 *l);
01631
01635 void GWEN_Crypt_Key_List2Iterator_free(GWEN_CRYPT_KEY_LIST2_ITERATOR *li);
01636
01641 GWEN_CRYPT_KEY *GWEN_Crypt_Key_List2Iterator_Previous(GWEN_CRYPT_KEY_LIST2_ITERATOR *li);
01642
01647 GWEN_CRYPT_KEY *GWEN_Crypt_Key_List2Iterator_Next(GWEN_CRYPT_KEY_LIST2_ITERATOR *li);
01648
01653 GWEN_CRYPT_KEY *GWEN_Crypt_Key_List2Iterator_Data(GWEN_CRYPT_KEY_LIST2_ITERATOR *li);
01654
01666 GWEN_CRYPT_KEY *GWEN_Crypt_Key_List2_ForEach(GWEN_CRYPT_KEY_LIST2 *list,
01667 GWEN_CRYPT_KEY_LIST2_FOREACH func,
01668 void *user_data);
01669
01670
01671 typedef struct GWEN_CRYPT_KEY_CONSTLIST2 GWEN_CRYPT_KEY_CONSTLIST2;
01672 typedef struct GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR;
01673 typedef const GWEN_CRYPT_KEY*
01674 (GWEN_CRYPT_KEY_CONSTLIST2_FOREACH)(const GWEN_CRYPT_KEY *element,
01675 void *user_data);
01676
01677
01678 GWEN_CRYPT_KEY_CONSTLIST2 *GWEN_Crypt_Key_ConstList2_new();
01679
01680 void GWEN_Crypt_Key_ConstList2_free(GWEN_CRYPT_KEY_CONSTLIST2 *l);
01681
01682 void GWEN_Crypt_Key_ConstList2_PushBack(GWEN_CRYPT_KEY_CONSTLIST2 *l, const GWEN_CRYPT_KEY *p);
01683
01684 void GWEN_Crypt_Key_ConstList2_PushFront(GWEN_CRYPT_KEY_CONSTLIST2 *l, const GWEN_CRYPT_KEY *p);
01685
01686 const GWEN_CRYPT_KEY *GWEN_Crypt_Key_ConstList2_GetFront(GWEN_CRYPT_KEY_CONSTLIST2 *l);
01687
01688 const GWEN_CRYPT_KEY *GWEN_Crypt_Key_ConstList2_GetBack(GWEN_CRYPT_KEY_CONSTLIST2 *l);
01689
01690 unsigned int GWEN_Crypt_Key_ConstList2_GetSize(GWEN_CRYPT_KEY_CONSTLIST2 *l);
01691
01692 void GWEN_Crypt_Key_ConstList2_PopBack(GWEN_CRYPT_KEY_CONSTLIST2 *l);
01693
01694 void GWEN_Crypt_Key_ConstList2_PopFront(GWEN_CRYPT_KEY_CONSTLIST2 *l);
01695
01696 void GWEN_Crypt_Key_ConstList2_Clear(GWEN_CRYPT_KEY_CONSTLIST2 *l);
01697
01698 GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR *GWEN_Crypt_Key_ConstList2_First(GWEN_CRYPT_KEY_CONSTLIST2 *l);
01699
01700 GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR *GWEN_Crypt_Key_ConstList2_Last(GWEN_CRYPT_KEY_CONSTLIST2 *l);
01701
01702 GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR *GWEN_Crypt_Key_ConstList2Iterator_new(GWEN_CRYPT_KEY_CONSTLIST2 *l);
01703
01704 void GWEN_Crypt_Key_ConstList2Iterator_free(GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR *li);
01705
01706 const GWEN_CRYPT_KEY *GWEN_Crypt_Key_ConstList2Iterator_Previous(GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR *li);
01707
01708 const GWEN_CRYPT_KEY *GWEN_Crypt_Key_ConstList2Iterator_Next(GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR *li);
01709
01710 const GWEN_CRYPT_KEY *GWEN_Crypt_Key_ConstList2Iterator_Data(GWEN_CRYPT_KEY_CONSTLIST2_ITERATOR *li);
01711
01723 const GWEN_CRYPT_KEY *GWEN_Crypt_Key_ConstList2_ForEach(GWEN_CRYPT_KEY_CONSTLIST2 *list,
01724 GWEN_CRYPT_KEY_CONSTLIST2_FOREACH func, void *user_data);
01725
01726
01727 #ifdef __cplusplus
01728 }
01729 #endif
01730
01731
01732 #endif
01733
01734
01735
01736
01737
01738
01739
01740
01741
01742
01743
01744
01745
01746
01747
01748
01749
01750
01751
01752
01753
01754
01755
01756
01757
01758
01759
01760
01761
01762
01763
01764 #ifndef GWEN_CRYPT_KEY_LIST1_H
01765 #define GWEN_CRYPT_KEY_LIST1_H
01766
01767 #ifdef __cplusplus
01768 extern "C" {
01769 #endif
01770
01772 typedef struct GWEN_CRYPT_KEY_LIST_ELEMENT {
01773 uint32_t id;
01774 GWEN_CRYPT_KEY *nextObject;
01775 } GWEN_CRYPT_KEY_LIST__ELEMENT;
01776
01783 typedef struct GWEN_CRYPT_KEY_LIST GWEN_CRYPT_KEY_LIST;
01785 struct GWEN_CRYPT_KEY_LIST {
01786 GWEN_CRYPT_KEY *first;
01787 uint32_t count;
01788 uint32_t id;
01789 } GWEN_CRYPT_KEY_LIST;
01790
01795 void GWEN_Crypt_Key_List_AddList(GWEN_CRYPT_KEY_LIST *dst, GWEN_CRYPT_KEY_LIST *l);
01796
01800 void GWEN_Crypt_Key_List_Add(GWEN_CRYPT_KEY *element, GWEN_CRYPT_KEY_LIST *list);
01801
01806 void GWEN_Crypt_Key_List_Insert(GWEN_CRYPT_KEY *element, GWEN_CRYPT_KEY_LIST *list);
01807
01814 void GWEN_Crypt_Key_List_Del(GWEN_CRYPT_KEY *element);
01815
01819 GWEN_CRYPT_KEY* GWEN_Crypt_Key_List_First(const GWEN_CRYPT_KEY_LIST *l);
01820
01824 GWEN_CRYPT_KEY* GWEN_Crypt_Key_List_Last(const GWEN_CRYPT_KEY_LIST *l);
01825
01830 void GWEN_Crypt_Key_List_Clear(GWEN_CRYPT_KEY_LIST *l);
01831
01835 GWEN_CRYPT_KEY_LIST* GWEN_Crypt_Key_List_new();
01836
01840 void GWEN_Crypt_Key_List_free(GWEN_CRYPT_KEY_LIST *l);
01841
01845 GWEN_CRYPT_KEY* GWEN_Crypt_Key_List_Next(const GWEN_CRYPT_KEY *element);
01846
01850 GWEN_CRYPT_KEY* GWEN_Crypt_Key_List_Previous(const GWEN_CRYPT_KEY *element);
01851
01855 uint32_t GWEN_Crypt_Key_List_GetCount(const GWEN_CRYPT_KEY_LIST *l);
01856
01857 #ifdef __cplusplus
01858 }
01859 #endif
01860
01861
01862 #endif
01863
01864
01865
01866
01867
01868
01869
01870
01871
01872
01873
01874
01875
01876
01877
01878
01879
01880
01881
01882
01883
01884
01885
01886
01887
01888
01889
01890
01891
01892
01893
01894 #ifndef GWEN_CRYPT_HASHALGO_LIST2_H
01895 #define GWEN_CRYPT_HASHALGO_LIST2_H
01896
01897
01898 #ifdef __cplusplus
01899 extern "C" {
01900 #endif
01901
01908 typedef struct GWEN_CRYPT_HASHALGO_LIST2 GWEN_CRYPT_HASHALGO_LIST2;
01909
01913 typedef struct GWEN_CRYPT_HASHALGO_LIST2_ITERATOR GWEN_CRYPT_HASHALGO_LIST2_ITERATOR;
01914
01918 typedef GWEN_CRYPT_HASHALGO* (GWEN_CRYPT_HASHALGO_LIST2_FOREACH)(GWEN_CRYPT_HASHALGO *element,
01919 void *user_data);
01920
01924 GWEN_CRYPT_HASHALGO_LIST2 *GWEN_Crypt_HashAlgo_List2_new();
01925
01929 void GWEN_Crypt_HashAlgo_List2_free(GWEN_CRYPT_HASHALGO_LIST2 *l);
01930
01934 void GWEN_Crypt_HashAlgo_List2_Dump(GWEN_CRYPT_HASHALGO_LIST2 *l, FILE *f, unsigned int indent);
01935
01939 void GWEN_Crypt_HashAlgo_List2_PushBack(GWEN_CRYPT_HASHALGO_LIST2 *l, GWEN_CRYPT_HASHALGO *p);
01940
01945 void GWEN_Crypt_HashAlgo_List2_PushFront(GWEN_CRYPT_HASHALGO_LIST2 *l, GWEN_CRYPT_HASHALGO *p);
01946
01951 GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_List2_GetFront(GWEN_CRYPT_HASHALGO_LIST2 *l);
01952
01957 GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_List2_GetBack(GWEN_CRYPT_HASHALGO_LIST2 *l);
01958
01963 void GWEN_Crypt_HashAlgo_List2_Erase(GWEN_CRYPT_HASHALGO_LIST2 *l,
01964 GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *it);
01965
01971 unsigned int GWEN_Crypt_HashAlgo_List2_GetSize(GWEN_CRYPT_HASHALGO_LIST2 *l);
01972
01977 void GWEN_Crypt_HashAlgo_List2_PopBack(GWEN_CRYPT_HASHALGO_LIST2 *l);
01978
01983 void GWEN_Crypt_HashAlgo_List2_PopFront(GWEN_CRYPT_HASHALGO_LIST2 *l);
01984
01988 void GWEN_Crypt_HashAlgo_List2_Clear(GWEN_CRYPT_HASHALGO_LIST2 *l);
01989
01993 GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *GWEN_Crypt_HashAlgo_List2_First(GWEN_CRYPT_HASHALGO_LIST2 *l);
01994
01998 GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *GWEN_Crypt_HashAlgo_List2_Last(GWEN_CRYPT_HASHALGO_LIST2 *l);
01999
02003 GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *GWEN_Crypt_HashAlgo_List2Iterator_new(GWEN_CRYPT_HASHALGO_LIST2 *l);
02004
02008 void GWEN_Crypt_HashAlgo_List2Iterator_free(GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *li);
02009
02014 GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_List2Iterator_Previous(GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *li);
02015
02020 GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_List2Iterator_Next(GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *li);
02021
02026 GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_List2Iterator_Data(GWEN_CRYPT_HASHALGO_LIST2_ITERATOR *li);
02027
02039 GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_List2_ForEach(GWEN_CRYPT_HASHALGO_LIST2 *list,
02040 GWEN_CRYPT_HASHALGO_LIST2_FOREACH func,
02041 void *user_data);
02042
02043
02044 typedef struct GWEN_CRYPT_HASHALGO_CONSTLIST2 GWEN_CRYPT_HASHALGO_CONSTLIST2;
02045 typedef struct GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR;
02046 typedef const GWEN_CRYPT_HASHALGO*
02047 (GWEN_CRYPT_HASHALGO_CONSTLIST2_FOREACH)(const GWEN_CRYPT_HASHALGO *element,
02048 void *user_data);
02049
02050
02051 GWEN_CRYPT_HASHALGO_CONSTLIST2 *GWEN_Crypt_HashAlgo_ConstList2_new();
02052
02053 void GWEN_Crypt_HashAlgo_ConstList2_free(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l);
02054
02055 void GWEN_Crypt_HashAlgo_ConstList2_PushBack(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l, const GWEN_CRYPT_HASHALGO *p);
02056
02057 void GWEN_Crypt_HashAlgo_ConstList2_PushFront(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l, const GWEN_CRYPT_HASHALGO *p);
02058
02059 const GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_ConstList2_GetFront(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l);
02060
02061 const GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_ConstList2_GetBack(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l);
02062
02063 unsigned int GWEN_Crypt_HashAlgo_ConstList2_GetSize(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l);
02064
02065 void GWEN_Crypt_HashAlgo_ConstList2_PopBack(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l);
02066
02067 void GWEN_Crypt_HashAlgo_ConstList2_PopFront(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l);
02068
02069 void GWEN_Crypt_HashAlgo_ConstList2_Clear(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l);
02070
02071 GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_HashAlgo_ConstList2_First(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l);
02072
02073 GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_HashAlgo_ConstList2_Last(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l);
02074
02075 GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_HashAlgo_ConstList2Iterator_new(GWEN_CRYPT_HASHALGO_CONSTLIST2 *l);
02076
02077 void GWEN_Crypt_HashAlgo_ConstList2Iterator_free(GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR *li);
02078
02079 const GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_ConstList2Iterator_Previous(GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR *li);
02080
02081 const GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_ConstList2Iterator_Next(GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR *li);
02082
02083 const GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_ConstList2Iterator_Data(GWEN_CRYPT_HASHALGO_CONSTLIST2_ITERATOR *li);
02084
02096 const GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_ConstList2_ForEach(GWEN_CRYPT_HASHALGO_CONSTLIST2 *list,
02097 GWEN_CRYPT_HASHALGO_CONSTLIST2_FOREACH func, void *user_data);
02098
02099
02100 #ifdef __cplusplus
02101 }
02102 #endif
02103
02104
02105 #endif
02106
02107
02108
02109
02110
02111
02112
02113
02114
02115
02116
02117
02118
02119
02120
02121
02122
02123
02124
02125
02126
02127
02128
02129
02130
02131
02132
02133
02134
02135
02136
02137 #ifndef GWEN_MDIGEST_LIST2_H
02138 #define GWEN_MDIGEST_LIST2_H
02139
02140
02141 #ifdef __cplusplus
02142 extern "C" {
02143 #endif
02144
02151 typedef struct GWEN_MDIGEST_LIST2 GWEN_MDIGEST_LIST2;
02152
02156 typedef struct GWEN_MDIGEST_LIST2_ITERATOR GWEN_MDIGEST_LIST2_ITERATOR;
02157
02161 typedef GWEN_MDIGEST* (GWEN_MDIGEST_LIST2_FOREACH)(GWEN_MDIGEST *element,
02162 void *user_data);
02163
02167 GWEN_MDIGEST_LIST2 *GWEN_MDigest_List2_new();
02168
02172 void GWEN_MDigest_List2_free(GWEN_MDIGEST_LIST2 *l);
02173
02177 void GWEN_MDigest_List2_Dump(GWEN_MDIGEST_LIST2 *l, FILE *f, unsigned int indent);
02178
02182 void GWEN_MDigest_List2_PushBack(GWEN_MDIGEST_LIST2 *l, GWEN_MDIGEST *p);
02183
02188 void GWEN_MDigest_List2_PushFront(GWEN_MDIGEST_LIST2 *l, GWEN_MDIGEST *p);
02189
02194 GWEN_MDIGEST *GWEN_MDigest_List2_GetFront(GWEN_MDIGEST_LIST2 *l);
02195
02200 GWEN_MDIGEST *GWEN_MDigest_List2_GetBack(GWEN_MDIGEST_LIST2 *l);
02201
02206 void GWEN_MDigest_List2_Erase(GWEN_MDIGEST_LIST2 *l,
02207 GWEN_MDIGEST_LIST2_ITERATOR *it);
02208
02214 unsigned int GWEN_MDigest_List2_GetSize(GWEN_MDIGEST_LIST2 *l);
02215
02220 void GWEN_MDigest_List2_PopBack(GWEN_MDIGEST_LIST2 *l);
02221
02226 void GWEN_MDigest_List2_PopFront(GWEN_MDIGEST_LIST2 *l);
02227
02231 void GWEN_MDigest_List2_Clear(GWEN_MDIGEST_LIST2 *l);
02232
02236 GWEN_MDIGEST_LIST2_ITERATOR *GWEN_MDigest_List2_First(GWEN_MDIGEST_LIST2 *l);
02237
02241 GWEN_MDIGEST_LIST2_ITERATOR *GWEN_MDigest_List2_Last(GWEN_MDIGEST_LIST2 *l);
02242
02246 GWEN_MDIGEST_LIST2_ITERATOR *GWEN_MDigest_List2Iterator_new(GWEN_MDIGEST_LIST2 *l);
02247
02251 void GWEN_MDigest_List2Iterator_free(GWEN_MDIGEST_LIST2_ITERATOR *li);
02252
02257 GWEN_MDIGEST *GWEN_MDigest_List2Iterator_Previous(GWEN_MDIGEST_LIST2_ITERATOR *li);
02258
02263 GWEN_MDIGEST *GWEN_MDigest_List2Iterator_Next(GWEN_MDIGEST_LIST2_ITERATOR *li);
02264
02269 GWEN_MDIGEST *GWEN_MDigest_List2Iterator_Data(GWEN_MDIGEST_LIST2_ITERATOR *li);
02270
02282 GWEN_MDIGEST *GWEN_MDigest_List2_ForEach(GWEN_MDIGEST_LIST2 *list,
02283 GWEN_MDIGEST_LIST2_FOREACH func,
02284 void *user_data);
02285
02286
02287 typedef struct GWEN_MDIGEST_CONSTLIST2 GWEN_MDIGEST_CONSTLIST2;
02288 typedef struct GWEN_MDIGEST_CONSTLIST2_ITERATOR GWEN_MDIGEST_CONSTLIST2_ITERATOR;
02289 typedef const GWEN_MDIGEST*
02290 (GWEN_MDIGEST_CONSTLIST2_FOREACH)(const GWEN_MDIGEST *element,
02291 void *user_data);
02292
02293
02294 GWEN_MDIGEST_CONSTLIST2 *GWEN_MDigest_ConstList2_new();
02295
02296 void GWEN_MDigest_ConstList2_free(GWEN_MDIGEST_CONSTLIST2 *l);
02297
02298 void GWEN_MDigest_ConstList2_PushBack(GWEN_MDIGEST_CONSTLIST2 *l, const GWEN_MDIGEST *p);
02299
02300 void GWEN_MDigest_ConstList2_PushFront(GWEN_MDIGEST_CONSTLIST2 *l, const GWEN_MDIGEST *p);
02301
02302 const GWEN_MDIGEST *GWEN_MDigest_ConstList2_GetFront(GWEN_MDIGEST_CONSTLIST2 *l);
02303
02304 const GWEN_MDIGEST *GWEN_MDigest_ConstList2_GetBack(GWEN_MDIGEST_CONSTLIST2 *l);
02305
02306 unsigned int GWEN_MDigest_ConstList2_GetSize(GWEN_MDIGEST_CONSTLIST2 *l);
02307
02308 void GWEN_MDigest_ConstList2_PopBack(GWEN_MDIGEST_CONSTLIST2 *l);
02309
02310 void GWEN_MDigest_ConstList2_PopFront(GWEN_MDIGEST_CONSTLIST2 *l);
02311
02312 void GWEN_MDigest_ConstList2_Clear(GWEN_MDIGEST_CONSTLIST2 *l);
02313
02314 GWEN_MDIGEST_CONSTLIST2_ITERATOR *GWEN_MDigest_ConstList2_First(GWEN_MDIGEST_CONSTLIST2 *l);
02315
02316 GWEN_MDIGEST_CONSTLIST2_ITERATOR *GWEN_MDigest_ConstList2_Last(GWEN_MDIGEST_CONSTLIST2 *l);
02317
02318 GWEN_MDIGEST_CONSTLIST2_ITERATOR *GWEN_MDigest_ConstList2Iterator_new(GWEN_MDIGEST_CONSTLIST2 *l);
02319
02320 void GWEN_MDigest_ConstList2Iterator_free(GWEN_MDIGEST_CONSTLIST2_ITERATOR *li);
02321
02322 const GWEN_MDIGEST *GWEN_MDigest_ConstList2Iterator_Previous(GWEN_MDIGEST_CONSTLIST2_ITERATOR *li);
02323
02324 const GWEN_MDIGEST *GWEN_MDigest_ConstList2Iterator_Next(GWEN_MDIGEST_CONSTLIST2_ITERATOR *li);
02325
02326 const GWEN_MDIGEST *GWEN_MDigest_ConstList2Iterator_Data(GWEN_MDIGEST_CONSTLIST2_ITERATOR *li);
02327
02339 const GWEN_MDIGEST *GWEN_MDigest_ConstList2_ForEach(GWEN_MDIGEST_CONSTLIST2 *list,
02340 GWEN_MDIGEST_CONSTLIST2_FOREACH func, void *user_data);
02341
02342
02343 #ifdef __cplusplus
02344 }
02345 #endif
02346
02347
02348 #endif
02349
02350
02351
02352
02353
02354
02355
02356
02357
02358
02359
02360
02361
02362
02363
02364
02365
02366
02367
02368
02369
02370
02371
02372
02373
02374
02375
02376
02377
02378
02379
02380 #ifndef GWEN_MDIGEST_LIST1_H
02381 #define GWEN_MDIGEST_LIST1_H
02382
02383 #ifdef __cplusplus
02384 extern "C" {
02385 #endif
02386
02388 typedef struct GWEN_MDIGEST_LIST_ELEMENT {
02389 uint32_t id;
02390 GWEN_MDIGEST *nextObject;
02391 } GWEN_MDIGEST_LIST__ELEMENT;
02392
02399 typedef struct GWEN_MDIGEST_LIST GWEN_MDIGEST_LIST;
02401 struct GWEN_MDIGEST_LIST {
02402 GWEN_MDIGEST *first;
02403 uint32_t count;
02404 uint32_t id;
02405 } GWEN_MDIGEST_LIST;
02406
02411 void GWEN_MDigest_List_AddList(GWEN_MDIGEST_LIST *dst, GWEN_MDIGEST_LIST *l);
02412
02416 void GWEN_MDigest_List_Add(GWEN_MDIGEST *element, GWEN_MDIGEST_LIST *list);
02417
02422 void GWEN_MDigest_List_Insert(GWEN_MDIGEST *element, GWEN_MDIGEST_LIST *list);
02423
02430 void GWEN_MDigest_List_Del(GWEN_MDIGEST *element);
02431
02435 GWEN_MDIGEST* GWEN_MDigest_List_First(const GWEN_MDIGEST_LIST *l);
02436
02440 GWEN_MDIGEST* GWEN_MDigest_List_Last(const GWEN_MDIGEST_LIST *l);
02441
02446 void GWEN_MDigest_List_Clear(GWEN_MDIGEST_LIST *l);
02447
02451 GWEN_MDIGEST_LIST* GWEN_MDigest_List_new();
02452
02456 void GWEN_MDigest_List_free(GWEN_MDIGEST_LIST *l);
02457
02461 GWEN_MDIGEST* GWEN_MDigest_List_Next(const GWEN_MDIGEST *element);
02462
02466 GWEN_MDIGEST* GWEN_MDigest_List_Previous(const GWEN_MDIGEST *element);
02467
02471 uint32_t GWEN_MDigest_List_GetCount(const GWEN_MDIGEST_LIST *l);
02472
02473 #ifdef __cplusplus
02474 }
02475 #endif
02476
02477
02478 #endif
02479
02480
02481
02482
02483
02484
02485
02486
02487
02488
02489
02490
02491
02492
02493
02494
02495
02496
02497
02498
02499
02500
02501
02502
02503
02504
02505
02506
02507
02508
02509
02510 #ifndef GWEN_CRYPT_PADDALGO_LIST2_H
02511 #define GWEN_CRYPT_PADDALGO_LIST2_H
02512
02513
02514 #ifdef __cplusplus
02515 extern "C" {
02516 #endif
02517
02524 typedef struct GWEN_CRYPT_PADDALGO_LIST2 GWEN_CRYPT_PADDALGO_LIST2;
02525
02529 typedef struct GWEN_CRYPT_PADDALGO_LIST2_ITERATOR GWEN_CRYPT_PADDALGO_LIST2_ITERATOR;
02530
02534 typedef GWEN_CRYPT_PADDALGO* (GWEN_CRYPT_PADDALGO_LIST2_FOREACH)(GWEN_CRYPT_PADDALGO *element,
02535 void *user_data);
02536
02540 GWEN_CRYPT_PADDALGO_LIST2 *GWEN_Crypt_PaddAlgo_List2_new();
02541
02545 void GWEN_Crypt_PaddAlgo_List2_free(GWEN_CRYPT_PADDALGO_LIST2 *l);
02546
02550 void GWEN_Crypt_PaddAlgo_List2_Dump(GWEN_CRYPT_PADDALGO_LIST2 *l, FILE *f, unsigned int indent);
02551
02555 void GWEN_Crypt_PaddAlgo_List2_PushBack(GWEN_CRYPT_PADDALGO_LIST2 *l, GWEN_CRYPT_PADDALGO *p);
02556
02561 void GWEN_Crypt_PaddAlgo_List2_PushFront(GWEN_CRYPT_PADDALGO_LIST2 *l, GWEN_CRYPT_PADDALGO *p);
02562
02567 GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_List2_GetFront(GWEN_CRYPT_PADDALGO_LIST2 *l);
02568
02573 GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_List2_GetBack(GWEN_CRYPT_PADDALGO_LIST2 *l);
02574
02579 void GWEN_Crypt_PaddAlgo_List2_Erase(GWEN_CRYPT_PADDALGO_LIST2 *l,
02580 GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *it);
02581
02587 unsigned int GWEN_Crypt_PaddAlgo_List2_GetSize(GWEN_CRYPT_PADDALGO_LIST2 *l);
02588
02593 void GWEN_Crypt_PaddAlgo_List2_PopBack(GWEN_CRYPT_PADDALGO_LIST2 *l);
02594
02599 void GWEN_Crypt_PaddAlgo_List2_PopFront(GWEN_CRYPT_PADDALGO_LIST2 *l);
02600
02604 void GWEN_Crypt_PaddAlgo_List2_Clear(GWEN_CRYPT_PADDALGO_LIST2 *l);
02605
02609 GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *GWEN_Crypt_PaddAlgo_List2_First(GWEN_CRYPT_PADDALGO_LIST2 *l);
02610
02614 GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *GWEN_Crypt_PaddAlgo_List2_Last(GWEN_CRYPT_PADDALGO_LIST2 *l);
02615
02619 GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *GWEN_Crypt_PaddAlgo_List2Iterator_new(GWEN_CRYPT_PADDALGO_LIST2 *l);
02620
02624 void GWEN_Crypt_PaddAlgo_List2Iterator_free(GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *li);
02625
02630 GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_List2Iterator_Previous(GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *li);
02631
02636 GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_List2Iterator_Next(GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *li);
02637
02642 GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_List2Iterator_Data(GWEN_CRYPT_PADDALGO_LIST2_ITERATOR *li);
02643
02655 GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_List2_ForEach(GWEN_CRYPT_PADDALGO_LIST2 *list,
02656 GWEN_CRYPT_PADDALGO_LIST2_FOREACH func,
02657 void *user_data);
02658
02659
02660 typedef struct GWEN_CRYPT_PADDALGO_CONSTLIST2 GWEN_CRYPT_PADDALGO_CONSTLIST2;
02661 typedef struct GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR;
02662 typedef const GWEN_CRYPT_PADDALGO*
02663 (GWEN_CRYPT_PADDALGO_CONSTLIST2_FOREACH)(const GWEN_CRYPT_PADDALGO *element,
02664 void *user_data);
02665
02666
02667 GWEN_CRYPT_PADDALGO_CONSTLIST2 *GWEN_Crypt_PaddAlgo_ConstList2_new();
02668
02669 void GWEN_Crypt_PaddAlgo_ConstList2_free(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l);
02670
02671 void GWEN_Crypt_PaddAlgo_ConstList2_PushBack(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l, const GWEN_CRYPT_PADDALGO *p);
02672
02673 void GWEN_Crypt_PaddAlgo_ConstList2_PushFront(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l, const GWEN_CRYPT_PADDALGO *p);
02674
02675 const GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_ConstList2_GetFront(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l);
02676
02677 const GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_ConstList2_GetBack(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l);
02678
02679 unsigned int GWEN_Crypt_PaddAlgo_ConstList2_GetSize(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l);
02680
02681 void GWEN_Crypt_PaddAlgo_ConstList2_PopBack(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l);
02682
02683 void GWEN_Crypt_PaddAlgo_ConstList2_PopFront(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l);
02684
02685 void GWEN_Crypt_PaddAlgo_ConstList2_Clear(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l);
02686
02687 GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_PaddAlgo_ConstList2_First(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l);
02688
02689 GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_PaddAlgo_ConstList2_Last(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l);
02690
02691 GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR *GWEN_Crypt_PaddAlgo_ConstList2Iterator_new(GWEN_CRYPT_PADDALGO_CONSTLIST2 *l);
02692
02693 void GWEN_Crypt_PaddAlgo_ConstList2Iterator_free(GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR *li);
02694
02695 const GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_ConstList2Iterator_Previous(GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR *li);
02696
02697 const GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_ConstList2Iterator_Next(GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR *li);
02698
02699 const GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_ConstList2Iterator_Data(GWEN_CRYPT_PADDALGO_CONSTLIST2_ITERATOR *li);
02700
02712 const GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_ConstList2_ForEach(GWEN_CRYPT_PADDALGO_CONSTLIST2 *list,
02713 GWEN_CRYPT_PADDALGO_CONSTLIST2_FOREACH func, void *user_data);
02714
02715
02716 #ifdef __cplusplus
02717 }
02718 #endif
02719
02720
02721 #endif
02722
02723
02724
02725
02726
02727
02728
02729
02730
02731
02732
02733
02734
02735
02736
02737
02738
02739
02740
02741
02742
02743
02744
02745
02746
02747
02748
02749
02750
02751
02752
02753 #ifndef GWEN_CRYPT_TOKEN_LIST2_H
02754 #define GWEN_CRYPT_TOKEN_LIST2_H
02755
02756
02757 #ifdef __cplusplus
02758 extern "C" {
02759 #endif
02760
02767 typedef struct GWEN_CRYPT_TOKEN_LIST2 GWEN_CRYPT_TOKEN_LIST2;
02768
02772 typedef struct GWEN_CRYPT_TOKEN_LIST2_ITERATOR GWEN_CRYPT_TOKEN_LIST2_ITERATOR;
02773
02777 typedef GWEN_CRYPT_TOKEN* (GWEN_CRYPT_TOKEN_LIST2_FOREACH)(GWEN_CRYPT_TOKEN *element,
02778 void *user_data);
02779
02783 GWEN_CRYPT_TOKEN_LIST2 *GWEN_Crypt_Token_List2_new();
02784
02788 void GWEN_Crypt_Token_List2_free(GWEN_CRYPT_TOKEN_LIST2 *l);
02789
02793 void GWEN_Crypt_Token_List2_Dump(GWEN_CRYPT_TOKEN_LIST2 *l, FILE *f, unsigned int indent);
02794
02798 void GWEN_Crypt_Token_List2_PushBack(GWEN_CRYPT_TOKEN_LIST2 *l, GWEN_CRYPT_TOKEN *p);
02799
02804 void GWEN_Crypt_Token_List2_PushFront(GWEN_CRYPT_TOKEN_LIST2 *l, GWEN_CRYPT_TOKEN *p);
02805
02810 GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_List2_GetFront(GWEN_CRYPT_TOKEN_LIST2 *l);
02811
02816 GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_List2_GetBack(GWEN_CRYPT_TOKEN_LIST2 *l);
02817
02822 void GWEN_Crypt_Token_List2_Erase(GWEN_CRYPT_TOKEN_LIST2 *l,
02823 GWEN_CRYPT_TOKEN_LIST2_ITERATOR *it);
02824
02830 unsigned int GWEN_Crypt_Token_List2_GetSize(GWEN_CRYPT_TOKEN_LIST2 *l);
02831
02836 void GWEN_Crypt_Token_List2_PopBack(GWEN_CRYPT_TOKEN_LIST2 *l);
02837
02842 void GWEN_Crypt_Token_List2_PopFront(GWEN_CRYPT_TOKEN_LIST2 *l);
02843
02847 void GWEN_Crypt_Token_List2_Clear(GWEN_CRYPT_TOKEN_LIST2 *l);
02848
02852 GWEN_CRYPT_TOKEN_LIST2_ITERATOR *GWEN_Crypt_Token_List2_First(GWEN_CRYPT_TOKEN_LIST2 *l);
02853
02857 GWEN_CRYPT_TOKEN_LIST2_ITERATOR *GWEN_Crypt_Token_List2_Last(GWEN_CRYPT_TOKEN_LIST2 *l);
02858
02862 GWEN_CRYPT_TOKEN_LIST2_ITERATOR *GWEN_Crypt_Token_List2Iterator_new(GWEN_CRYPT_TOKEN_LIST2 *l);
02863
02867 void GWEN_Crypt_Token_List2Iterator_free(GWEN_CRYPT_TOKEN_LIST2_ITERATOR *li);
02868
02873 GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_List2Iterator_Previous(GWEN_CRYPT_TOKEN_LIST2_ITERATOR *li);
02874
02879 GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_List2Iterator_Next(GWEN_CRYPT_TOKEN_LIST2_ITERATOR *li);
02880
02885 GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_List2Iterator_Data(GWEN_CRYPT_TOKEN_LIST2_ITERATOR *li);
02886
02898 GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_List2_ForEach(GWEN_CRYPT_TOKEN_LIST2 *list,
02899 GWEN_CRYPT_TOKEN_LIST2_FOREACH func,
02900 void *user_data);
02901
02902
02903 typedef struct GWEN_CRYPT_TOKEN_CONSTLIST2 GWEN_CRYPT_TOKEN_CONSTLIST2;
02904 typedef struct GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR;
02905 typedef const GWEN_CRYPT_TOKEN*
02906 (GWEN_CRYPT_TOKEN_CONSTLIST2_FOREACH)(const GWEN_CRYPT_TOKEN *element,
02907 void *user_data);
02908
02909
02910 GWEN_CRYPT_TOKEN_CONSTLIST2 *GWEN_Crypt_Token_ConstList2_new();
02911
02912 void GWEN_Crypt_Token_ConstList2_free(GWEN_CRYPT_TOKEN_CONSTLIST2 *l);
02913
02914 void GWEN_Crypt_Token_ConstList2_PushBack(GWEN_CRYPT_TOKEN_CONSTLIST2 *l, const GWEN_CRYPT_TOKEN *p);
02915
02916 void GWEN_Crypt_Token_ConstList2_PushFront(GWEN_CRYPT_TOKEN_CONSTLIST2 *l, const GWEN_CRYPT_TOKEN *p);
02917
02918 const GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_ConstList2_GetFront(GWEN_CRYPT_TOKEN_CONSTLIST2 *l);
02919
02920 const GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_ConstList2_GetBack(GWEN_CRYPT_TOKEN_CONSTLIST2 *l);
02921
02922 unsigned int GWEN_Crypt_Token_ConstList2_GetSize(GWEN_CRYPT_TOKEN_CONSTLIST2 *l);
02923
02924 void GWEN_Crypt_Token_ConstList2_PopBack(GWEN_CRYPT_TOKEN_CONSTLIST2 *l);
02925
02926 void GWEN_Crypt_Token_ConstList2_PopFront(GWEN_CRYPT_TOKEN_CONSTLIST2 *l);
02927
02928 void GWEN_Crypt_Token_ConstList2_Clear(GWEN_CRYPT_TOKEN_CONSTLIST2 *l);
02929
02930 GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_ConstList2_First(GWEN_CRYPT_TOKEN_CONSTLIST2 *l);
02931
02932 GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_ConstList2_Last(GWEN_CRYPT_TOKEN_CONSTLIST2 *l);
02933
02934 GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_ConstList2Iterator_new(GWEN_CRYPT_TOKEN_CONSTLIST2 *l);
02935
02936 void GWEN_Crypt_Token_ConstList2Iterator_free(GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *li);
02937
02938 const GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_ConstList2Iterator_Previous(GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *li);
02939
02940 const GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_ConstList2Iterator_Next(GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *li);
02941
02942 const GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_ConstList2Iterator_Data(GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *li);
02943
02955 const GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_ConstList2_ForEach(GWEN_CRYPT_TOKEN_CONSTLIST2 *list,
02956 GWEN_CRYPT_TOKEN_CONSTLIST2_FOREACH func, void *user_data);
02957
02958
02959 #ifdef __cplusplus
02960 }
02961 #endif
02962
02963
02964 #endif
02965
02966
02967
02968
02969
02970
02971
02972
02973
02974
02975
02976
02977
02978
02979
02980
02981
02982
02983
02984
02985
02986
02987
02988
02989
02990
02991
02992
02993
02994
02995
02996 #ifndef GWEN_CRYPT_TOKEN_LIST1_H
02997 #define GWEN_CRYPT_TOKEN_LIST1_H
02998
02999 #ifdef __cplusplus
03000 extern "C" {
03001 #endif
03002
03004 typedef struct GWEN_CRYPT_TOKEN_LIST_ELEMENT {
03005 uint32_t id;
03006 GWEN_CRYPT_TOKEN *nextObject;
03007 } GWEN_CRYPT_TOKEN_LIST__ELEMENT;
03008
03015 typedef struct GWEN_CRYPT_TOKEN_LIST GWEN_CRYPT_TOKEN_LIST;
03017 struct GWEN_CRYPT_TOKEN_LIST {
03018 GWEN_CRYPT_TOKEN *first;
03019 uint32_t count;
03020 uint32_t id;
03021 } GWEN_CRYPT_TOKEN_LIST;
03022
03027 void GWEN_Crypt_Token_List_AddList(GWEN_CRYPT_TOKEN_LIST *dst, GWEN_CRYPT_TOKEN_LIST *l);
03028
03032 void GWEN_Crypt_Token_List_Add(GWEN_CRYPT_TOKEN *element, GWEN_CRYPT_TOKEN_LIST *list);
03033
03038 void GWEN_Crypt_Token_List_Insert(GWEN_CRYPT_TOKEN *element, GWEN_CRYPT_TOKEN_LIST *list);
03039
03046 void GWEN_Crypt_Token_List_Del(GWEN_CRYPT_TOKEN *element);
03047
03051 GWEN_CRYPT_TOKEN* GWEN_Crypt_Token_List_First(const GWEN_CRYPT_TOKEN_LIST *l);
03052
03056 GWEN_CRYPT_TOKEN* GWEN_Crypt_Token_List_Last(const GWEN_CRYPT_TOKEN_LIST *l);
03057
03062 void GWEN_Crypt_Token_List_Clear(GWEN_CRYPT_TOKEN_LIST *l);
03063
03067 GWEN_CRYPT_TOKEN_LIST* GWEN_Crypt_Token_List_new();
03068
03072 void GWEN_Crypt_Token_List_free(GWEN_CRYPT_TOKEN_LIST *l);
03073
03077 GWEN_CRYPT_TOKEN* GWEN_Crypt_Token_List_Next(const GWEN_CRYPT_TOKEN *element);
03078
03082 GWEN_CRYPT_TOKEN* GWEN_Crypt_Token_List_Previous(const GWEN_CRYPT_TOKEN *element);
03083
03087 uint32_t GWEN_Crypt_Token_List_GetCount(const GWEN_CRYPT_TOKEN_LIST *l);
03088
03089 #ifdef __cplusplus
03090 }
03091 #endif
03092
03093
03094 #endif
03095
03096
03097
03098
03099
03100
03101
03102
03103
03104
03105
03106
03107
03108
03109
03110
03111
03112
03113
03114
03115
03116
03117
03118
03119
03120
03121
03122
03123
03124
03125
03126 #ifndef GWEN_CRYPT_TOKEN_CONTEXT_LIST2_H
03127 #define GWEN_CRYPT_TOKEN_CONTEXT_LIST2_H
03128
03129
03130 #ifdef __cplusplus
03131 extern "C" {
03132 #endif
03133
03140 typedef struct GWEN_CRYPT_TOKEN_CONTEXT_LIST2 GWEN_CRYPT_TOKEN_CONTEXT_LIST2;
03141
03145 typedef struct GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR;
03146
03150 typedef GWEN_CRYPT_TOKEN_CONTEXT* (GWEN_CRYPT_TOKEN_CONTEXT_LIST2_FOREACH)(GWEN_CRYPT_TOKEN_CONTEXT *element,
03151 void *user_data);
03152
03156 GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *GWEN_Crypt_Token_Context_List2_new();
03157
03161 void GWEN_Crypt_Token_Context_List2_free(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l);
03162
03166 void GWEN_Crypt_Token_Context_List2_Dump(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l, FILE *f, unsigned int indent);
03167
03171 void GWEN_Crypt_Token_Context_List2_PushBack(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l, GWEN_CRYPT_TOKEN_CONTEXT *p);
03172
03177 void GWEN_Crypt_Token_Context_List2_PushFront(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l, GWEN_CRYPT_TOKEN_CONTEXT *p);
03178
03183 GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_List2_GetFront(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l);
03184
03189 GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_List2_GetBack(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l);
03190
03195 void GWEN_Crypt_Token_Context_List2_Erase(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l,
03196 GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *it);
03197
03203 unsigned int GWEN_Crypt_Token_Context_List2_GetSize(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l);
03204
03209 void GWEN_Crypt_Token_Context_List2_PopBack(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l);
03210
03215 void GWEN_Crypt_Token_Context_List2_PopFront(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l);
03216
03220 void GWEN_Crypt_Token_Context_List2_Clear(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l);
03221
03225 GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *GWEN_Crypt_Token_Context_List2_First(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l);
03226
03230 GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *GWEN_Crypt_Token_Context_List2_Last(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l);
03231
03235 GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *GWEN_Crypt_Token_Context_List2Iterator_new(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l);
03236
03240 void GWEN_Crypt_Token_Context_List2Iterator_free(GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *li);
03241
03246 GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_List2Iterator_Previous(GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *li);
03247
03252 GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_List2Iterator_Next(GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *li);
03253
03258 GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_List2Iterator_Data(GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *li);
03259
03271 GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_List2_ForEach(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *list,
03272 GWEN_CRYPT_TOKEN_CONTEXT_LIST2_FOREACH func,
03273 void *user_data);
03274
03275
03276 typedef struct GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2;
03277 typedef struct GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR;
03278 typedef const GWEN_CRYPT_TOKEN_CONTEXT*
03279 (GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_FOREACH)(const GWEN_CRYPT_TOKEN_CONTEXT *element,
03280 void *user_data);
03281
03282
03283 GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *GWEN_Crypt_Token_Context_ConstList2_new();
03284
03285 void GWEN_Crypt_Token_Context_ConstList2_free(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l);
03286
03287 void GWEN_Crypt_Token_Context_ConstList2_PushBack(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l, const GWEN_CRYPT_TOKEN_CONTEXT *p);
03288
03289 void GWEN_Crypt_Token_Context_ConstList2_PushFront(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l, const GWEN_CRYPT_TOKEN_CONTEXT *p);
03290
03291 const GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_ConstList2_GetFront(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l);
03292
03293 const GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_ConstList2_GetBack(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l);
03294
03295 unsigned int GWEN_Crypt_Token_Context_ConstList2_GetSize(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l);
03296
03297 void GWEN_Crypt_Token_Context_ConstList2_PopBack(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l);
03298
03299 void GWEN_Crypt_Token_Context_ConstList2_PopFront(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l);
03300
03301 void GWEN_Crypt_Token_Context_ConstList2_Clear(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l);
03302
03303 GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_Context_ConstList2_First(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l);
03304
03305 GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_Context_ConstList2_Last(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l);
03306
03307 GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_Context_ConstList2Iterator_new(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l);
03308
03309 void GWEN_Crypt_Token_Context_ConstList2Iterator_free(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *li);
03310
03311 const GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_ConstList2Iterator_Previous(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *li);
03312
03313 const GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_ConstList2Iterator_Next(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *li);
03314
03315 const GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_ConstList2Iterator_Data(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *li);
03316
03328 const GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_ConstList2_ForEach(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *list,
03329 GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_FOREACH func, void *user_data);
03330
03331
03332 #ifdef __cplusplus
03333 }
03334 #endif
03335
03336
03337 #endif
03338
03339
03340
03341
03342
03343
03344
03345
03346
03347
03348
03349
03350
03351
03352
03353
03354
03355
03356
03357
03358
03359
03360
03361
03362
03363
03364
03365
03366
03367
03368
03369 #ifndef GWEN_CRYPT_TOKEN_CONTEXT_LIST1_H
03370 #define GWEN_CRYPT_TOKEN_CONTEXT_LIST1_H
03371
03372 #ifdef __cplusplus
03373 extern "C" {
03374 #endif
03375
03377 typedef struct GWEN_CRYPT_TOKEN_CONTEXT_LIST_ELEMENT {
03378 uint32_t id;
03379 GWEN_CRYPT_TOKEN_CONTEXT *nextObject;
03380 } GWEN_CRYPT_TOKEN_CONTEXT_LIST__ELEMENT;
03381
03388 typedef struct GWEN_CRYPT_TOKEN_CONTEXT_LIST GWEN_CRYPT_TOKEN_CONTEXT_LIST;
03390 struct GWEN_CRYPT_TOKEN_CONTEXT_LIST {
03391 GWEN_CRYPT_TOKEN_CONTEXT *first;
03392 uint32_t count;
03393 uint32_t id;
03394 } GWEN_CRYPT_TOKEN_CONTEXT_LIST;
03395
03400 void GWEN_Crypt_Token_Context_List_AddList(GWEN_CRYPT_TOKEN_CONTEXT_LIST *dst, GWEN_CRYPT_TOKEN_CONTEXT_LIST *l);
03401
03405 void GWEN_Crypt_Token_Context_List_Add(GWEN_CRYPT_TOKEN_CONTEXT *element, GWEN_CRYPT_TOKEN_CONTEXT_LIST *list);
03406
03411 void GWEN_Crypt_Token_Context_List_Insert(GWEN_CRYPT_TOKEN_CONTEXT *element, GWEN_CRYPT_TOKEN_CONTEXT_LIST *list);
03412
03419 void GWEN_Crypt_Token_Context_List_Del(GWEN_CRYPT_TOKEN_CONTEXT *element);
03420
03424 GWEN_CRYPT_TOKEN_CONTEXT* GWEN_Crypt_Token_Context_List_First(const GWEN_CRYPT_TOKEN_CONTEXT_LIST *l);
03425
03429 GWEN_CRYPT_TOKEN_CONTEXT* GWEN_Crypt_Token_Context_List_Last(const GWEN_CRYPT_TOKEN_CONTEXT_LIST *l);
03430
03435 void GWEN_Crypt_Token_Context_List_Clear(GWEN_CRYPT_TOKEN_CONTEXT_LIST *l);
03436
03440 GWEN_CRYPT_TOKEN_CONTEXT_LIST* GWEN_Crypt_Token_Context_List_new();
03441
03445 void GWEN_Crypt_Token_Context_List_free(GWEN_CRYPT_TOKEN_CONTEXT_LIST *l);
03446
03450 GWEN_CRYPT_TOKEN_CONTEXT* GWEN_Crypt_Token_Context_List_Next(const GWEN_CRYPT_TOKEN_CONTEXT *element);
03451
03455 GWEN_CRYPT_TOKEN_CONTEXT* GWEN_Crypt_Token_Context_List_Previous(const GWEN_CRYPT_TOKEN_CONTEXT *element);
03456
03460 uint32_t GWEN_Crypt_Token_Context_List_GetCount(const GWEN_CRYPT_TOKEN_CONTEXT_LIST *l);
03461
03462 #ifdef __cplusplus
03463 }
03464 #endif
03465
03466
03467 #endif
03468
03469
03470
03471
03472
03473
03474
03475
03476
03477
03478
03479
03480
03481
03482
03483
03484
03485
03486
03487
03488
03489
03490
03491
03492
03493
03494
03495
03496
03497
03498
03499 #ifndef GWEN_CRYPT_TOKEN_KEYINFO_LIST2_H
03500 #define GWEN_CRYPT_TOKEN_KEYINFO_LIST2_H
03501
03502
03503 #ifdef __cplusplus
03504 extern "C" {
03505 #endif
03506
03513 typedef struct GWEN_CRYPT_TOKEN_KEYINFO_LIST2 GWEN_CRYPT_TOKEN_KEYINFO_LIST2;
03514
03518 typedef struct GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR;
03519
03523 typedef GWEN_CRYPT_TOKEN_KEYINFO* (GWEN_CRYPT_TOKEN_KEYINFO_LIST2_FOREACH)(GWEN_CRYPT_TOKEN_KEYINFO *element,
03524 void *user_data);
03525
03529 GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *GWEN_Crypt_Token_KeyInfo_List2_new();
03530
03534 void GWEN_Crypt_Token_KeyInfo_List2_free(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l);
03535
03539 void GWEN_Crypt_Token_KeyInfo_List2_Dump(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l, FILE *f, unsigned int indent);
03540
03544 void GWEN_Crypt_Token_KeyInfo_List2_PushBack(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l, GWEN_CRYPT_TOKEN_KEYINFO *p);
03545
03550 void GWEN_Crypt_Token_KeyInfo_List2_PushFront(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l, GWEN_CRYPT_TOKEN_KEYINFO *p);
03551
03556 GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_List2_GetFront(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l);
03557
03562 GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_List2_GetBack(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l);
03563
03568 void GWEN_Crypt_Token_KeyInfo_List2_Erase(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l,
03569 GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *it);
03570
03576 unsigned int GWEN_Crypt_Token_KeyInfo_List2_GetSize(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l);
03577
03582 void GWEN_Crypt_Token_KeyInfo_List2_PopBack(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l);
03583
03588 void GWEN_Crypt_Token_KeyInfo_List2_PopFront(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l);
03589
03593 void GWEN_Crypt_Token_KeyInfo_List2_Clear(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l);
03594
03598 GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *GWEN_Crypt_Token_KeyInfo_List2_First(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l);
03599
03603 GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *GWEN_Crypt_Token_KeyInfo_List2_Last(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l);
03604
03608 GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *GWEN_Crypt_Token_KeyInfo_List2Iterator_new(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l);
03609
03613 void GWEN_Crypt_Token_KeyInfo_List2Iterator_free(GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *li);
03614
03619 GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_List2Iterator_Previous(GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *li);
03620
03625 GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_List2Iterator_Next(GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *li);
03626
03631 GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_List2Iterator_Data(GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *li);
03632
03644 GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_List2_ForEach(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *list,
03645 GWEN_CRYPT_TOKEN_KEYINFO_LIST2_FOREACH func,
03646 void *user_data);
03647
03648
03649 typedef struct GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2;
03650 typedef struct GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR;
03651 typedef const GWEN_CRYPT_TOKEN_KEYINFO*
03652 (GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_FOREACH)(const GWEN_CRYPT_TOKEN_KEYINFO *element,
03653 void *user_data);
03654
03655
03656 GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *GWEN_Crypt_Token_KeyInfo_ConstList2_new();
03657
03658 void GWEN_Crypt_Token_KeyInfo_ConstList2_free(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l);
03659
03660 void GWEN_Crypt_Token_KeyInfo_ConstList2_PushBack(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l, const GWEN_CRYPT_TOKEN_KEYINFO *p);
03661
03662 void GWEN_Crypt_Token_KeyInfo_ConstList2_PushFront(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l, const GWEN_CRYPT_TOKEN_KEYINFO *p);
03663
03664 const GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_ConstList2_GetFront(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l);
03665
03666 const GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_ConstList2_GetBack(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l);
03667
03668 unsigned int GWEN_Crypt_Token_KeyInfo_ConstList2_GetSize(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l);
03669
03670 void GWEN_Crypt_Token_KeyInfo_ConstList2_PopBack(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l);
03671
03672 void GWEN_Crypt_Token_KeyInfo_ConstList2_PopFront(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l);
03673
03674 void GWEN_Crypt_Token_KeyInfo_ConstList2_Clear(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l);
03675
03676 GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_KeyInfo_ConstList2_First(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l);
03677
03678 GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_KeyInfo_ConstList2_Last(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l);
03679
03680 GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_KeyInfo_ConstList2Iterator_new(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l);
03681
03682 void GWEN_Crypt_Token_KeyInfo_ConstList2Iterator_free(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *li);
03683
03684 const GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_ConstList2Iterator_Previous(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *li);
03685
03686 const GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_ConstList2Iterator_Next(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *li);
03687
03688 const GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_ConstList2Iterator_Data(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *li);
03689
03701 const GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_ConstList2_ForEach(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *list,
03702 GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_FOREACH func, void *user_data);
03703
03704
03705 #ifdef __cplusplus
03706 }
03707 #endif
03708
03709
03710 #endif
03711
03712
03713
03714
03715
03716
03717
03718
03719
03720
03721
03722
03723
03724
03725
03726
03727
03728
03729
03730
03731
03732
03733
03734
03735
03736
03737
03738
03739
03740
03741
03742 #ifndef GWEN_CRYPT_TOKEN_KEYINFO_LIST1_H
03743 #define GWEN_CRYPT_TOKEN_KEYINFO_LIST1_H
03744
03745 #ifdef __cplusplus
03746 extern "C" {
03747 #endif
03748
03750 typedef struct GWEN_CRYPT_TOKEN_KEYINFO_LIST_ELEMENT {
03751 uint32_t id;
03752 GWEN_CRYPT_TOKEN_KEYINFO *nextObject;
03753 } GWEN_CRYPT_TOKEN_KEYINFO_LIST__ELEMENT;
03754
03761 typedef struct GWEN_CRYPT_TOKEN_KEYINFO_LIST GWEN_CRYPT_TOKEN_KEYINFO_LIST;
03763 struct GWEN_CRYPT_TOKEN_KEYINFO_LIST {
03764 GWEN_CRYPT_TOKEN_KEYINFO *first;
03765 uint32_t count;
03766 uint32_t id;
03767 } GWEN_CRYPT_TOKEN_KEYINFO_LIST;
03768
03773 void GWEN_Crypt_Token_KeyInfo_List_AddList(GWEN_CRYPT_TOKEN_KEYINFO_LIST *dst, GWEN_CRYPT_TOKEN_KEYINFO_LIST *l);
03774
03778 void GWEN_Crypt_Token_KeyInfo_List_Add(GWEN_CRYPT_TOKEN_KEYINFO *element, GWEN_CRYPT_TOKEN_KEYINFO_LIST *list);
03779
03784 void GWEN_Crypt_Token_KeyInfo_List_Insert(GWEN_CRYPT_TOKEN_KEYINFO *element, GWEN_CRYPT_TOKEN_KEYINFO_LIST *list);
03785
03792 void GWEN_Crypt_Token_KeyInfo_List_Del(GWEN_CRYPT_TOKEN_KEYINFO *element);
03793
03797 GWEN_CRYPT_TOKEN_KEYINFO* GWEN_Crypt_Token_KeyInfo_List_First(const GWEN_CRYPT_TOKEN_KEYINFO_LIST *l);
03798
03802 GWEN_CRYPT_TOKEN_KEYINFO* GWEN_Crypt_Token_KeyInfo_List_Last(const GWEN_CRYPT_TOKEN_KEYINFO_LIST *l);
03803
03808 void GWEN_Crypt_Token_KeyInfo_List_Clear(GWEN_CRYPT_TOKEN_KEYINFO_LIST *l);
03809
03813 GWEN_CRYPT_TOKEN_KEYINFO_LIST* GWEN_Crypt_Token_KeyInfo_List_new();
03814
03818 void GWEN_Crypt_Token_KeyInfo_List_free(GWEN_CRYPT_TOKEN_KEYINFO_LIST *l);
03819
03823 GWEN_CRYPT_TOKEN_KEYINFO* GWEN_Crypt_Token_KeyInfo_List_Next(const GWEN_CRYPT_TOKEN_KEYINFO *element);
03824
03828 GWEN_CRYPT_TOKEN_KEYINFO* GWEN_Crypt_Token_KeyInfo_List_Previous(const GWEN_CRYPT_TOKEN_KEYINFO *element);
03829
03833 uint32_t GWEN_Crypt_Token_KeyInfo_List_GetCount(const GWEN_CRYPT_TOKEN_KEYINFO_LIST *l);
03834
03835 #ifdef __cplusplus
03836 }
03837 #endif
03838
03839
03840 #endif
03841
03842
03843
03844
03845
03846
03847
03848
03849
03850
03851
03852
03853
03854
03855
03856
03857
03858
03859
03860
03861
03862
03863
03864
03865
03866
03867
03868
03869
03870
03871
03872 #ifndef GWEN_IO_LAYER_LIST2_H
03873 #define GWEN_IO_LAYER_LIST2_H
03874
03875
03876 #ifdef __cplusplus
03877 extern "C" {
03878 #endif
03879
03886 typedef struct GWEN_IO_LAYER_LIST2 GWEN_IO_LAYER_LIST2;
03887
03891 typedef struct GWEN_IO_LAYER_LIST2_ITERATOR GWEN_IO_LAYER_LIST2_ITERATOR;
03892
03896 typedef GWEN_IO_LAYER* (GWEN_IO_LAYER_LIST2_FOREACH)(GWEN_IO_LAYER *element,
03897 void *user_data);
03898
03902 GWEN_IO_LAYER_LIST2 *GWEN_Io_Layer_List2_new();
03903
03907 void GWEN_Io_Layer_List2_free(GWEN_IO_LAYER_LIST2 *l);
03908
03912 void GWEN_Io_Layer_List2_Dump(GWEN_IO_LAYER_LIST2 *l, FILE *f, unsigned int indent);
03913
03917 void GWEN_Io_Layer_List2_PushBack(GWEN_IO_LAYER_LIST2 *l, GWEN_IO_LAYER *p);
03918
03923 void GWEN_Io_Layer_List2_PushFront(GWEN_IO_LAYER_LIST2 *l, GWEN_IO_LAYER *p);
03924
03929 GWEN_IO_LAYER *GWEN_Io_Layer_List2_GetFront(GWEN_IO_LAYER_LIST2 *l);
03930
03935 GWEN_IO_LAYER *GWEN_Io_Layer_List2_GetBack(GWEN_IO_LAYER_LIST2 *l);
03936
03941 void GWEN_Io_Layer_List2_Erase(GWEN_IO_LAYER_LIST2 *l,
03942 GWEN_IO_LAYER_LIST2_ITERATOR *it);
03943
03949 unsigned int GWEN_Io_Layer_List2_GetSize(GWEN_IO_LAYER_LIST2 *l);
03950
03955 void GWEN_Io_Layer_List2_PopBack(GWEN_IO_LAYER_LIST2 *l);
03956
03961 void GWEN_Io_Layer_List2_PopFront(GWEN_IO_LAYER_LIST2 *l);
03962
03966 void GWEN_Io_Layer_List2_Clear(GWEN_IO_LAYER_LIST2 *l);
03967
03971 GWEN_IO_LAYER_LIST2_ITERATOR *GWEN_Io_Layer_List2_First(GWEN_IO_LAYER_LIST2 *l);
03972
03976 GWEN_IO_LAYER_LIST2_ITERATOR *GWEN_Io_Layer_List2_Last(GWEN_IO_LAYER_LIST2 *l);
03977
03981 GWEN_IO_LAYER_LIST2_ITERATOR *GWEN_Io_Layer_List2Iterator_new(GWEN_IO_LAYER_LIST2 *l);
03982
03986 void GWEN_Io_Layer_List2Iterator_free(GWEN_IO_LAYER_LIST2_ITERATOR *li);
03987
03992 GWEN_IO_LAYER *GWEN_Io_Layer_List2Iterator_Previous(GWEN_IO_LAYER_LIST2_ITERATOR *li);
03993
03998 GWEN_IO_LAYER *GWEN_Io_Layer_List2Iterator_Next(GWEN_IO_LAYER_LIST2_ITERATOR *li);
03999
04004 GWEN_IO_LAYER *GWEN_Io_Layer_List2Iterator_Data(GWEN_IO_LAYER_LIST2_ITERATOR *li);
04005
04017 GWEN_IO_LAYER *GWEN_Io_Layer_List2_ForEach(GWEN_IO_LAYER_LIST2 *list,
04018 GWEN_IO_LAYER_LIST2_FOREACH func,
04019 void *user_data);
04020
04021
04022 typedef struct GWEN_IO_LAYER_CONSTLIST2 GWEN_IO_LAYER_CONSTLIST2;
04023 typedef struct GWEN_IO_LAYER_CONSTLIST2_ITERATOR GWEN_IO_LAYER_CONSTLIST2_ITERATOR;
04024 typedef const GWEN_IO_LAYER*
04025 (GWEN_IO_LAYER_CONSTLIST2_FOREACH)(const GWEN_IO_LAYER *element,
04026 void *user_data);
04027
04028
04029 GWEN_IO_LAYER_CONSTLIST2 *GWEN_Io_Layer_ConstList2_new();
04030
04031 void GWEN_Io_Layer_ConstList2_free(GWEN_IO_LAYER_CONSTLIST2 *l);
04032
04033 void GWEN_Io_Layer_ConstList2_PushBack(GWEN_IO_LAYER_CONSTLIST2 *l, const GWEN_IO_LAYER *p);
04034
04035 void GWEN_Io_Layer_ConstList2_PushFront(GWEN_IO_LAYER_CONSTLIST2 *l, const GWEN_IO_LAYER *p);
04036
04037 const GWEN_IO_LAYER *GWEN_Io_Layer_ConstList2_GetFront(GWEN_IO_LAYER_CONSTLIST2 *l);
04038
04039 const GWEN_IO_LAYER *GWEN_Io_Layer_ConstList2_GetBack(GWEN_IO_LAYER_CONSTLIST2 *l);
04040
04041 unsigned int GWEN_Io_Layer_ConstList2_GetSize(GWEN_IO_LAYER_CONSTLIST2 *l);
04042
04043 void GWEN_Io_Layer_ConstList2_PopBack(GWEN_IO_LAYER_CONSTLIST2 *l);
04044
04045 void GWEN_Io_Layer_ConstList2_PopFront(GWEN_IO_LAYER_CONSTLIST2 *l);
04046
04047 void GWEN_Io_Layer_ConstList2_Clear(GWEN_IO_LAYER_CONSTLIST2 *l);
04048
04049 GWEN_IO_LAYER_CONSTLIST2_ITERATOR *GWEN_Io_Layer_ConstList2_First(GWEN_IO_LAYER_CONSTLIST2 *l);
04050
04051 GWEN_IO_LAYER_CONSTLIST2_ITERATOR *GWEN_Io_Layer_ConstList2_Last(GWEN_IO_LAYER_CONSTLIST2 *l);
04052
04053 GWEN_IO_LAYER_CONSTLIST2_ITERATOR *GWEN_Io_Layer_ConstList2Iterator_new(GWEN_IO_LAYER_CONSTLIST2 *l);
04054
04055 void GWEN_Io_Layer_ConstList2Iterator_free(GWEN_IO_LAYER_CONSTLIST2_ITERATOR *li);
04056
04057 const GWEN_IO_LAYER *GWEN_Io_Layer_ConstList2Iterator_Previous(GWEN_IO_LAYER_CONSTLIST2_ITERATOR *li);
04058
04059 const GWEN_IO_LAYER *GWEN_Io_Layer_ConstList2Iterator_Next(GWEN_IO_LAYER_CONSTLIST2_ITERATOR *li);
04060
04061 const GWEN_IO_LAYER *GWEN_Io_Layer_ConstList2Iterator_Data(GWEN_IO_LAYER_CONSTLIST2_ITERATOR *li);
04062
04074 const GWEN_IO_LAYER *GWEN_Io_Layer_ConstList2_ForEach(GWEN_IO_LAYER_CONSTLIST2 *list,
04075 GWEN_IO_LAYER_CONSTLIST2_FOREACH func, void *user_data);
04076
04077
04078 #ifdef __cplusplus
04079 }
04080 #endif
04081
04082
04083 #endif
04084
04085
04086
04087
04088
04089
04090
04091
04092
04093
04094
04095
04096
04097
04098
04099
04100
04101
04102
04103
04104
04105
04106
04107
04108
04109
04110
04111
04112
04113
04114
04115 #ifndef GWEN_IO_REQUEST_LIST2_H
04116 #define GWEN_IO_REQUEST_LIST2_H
04117
04118
04119 #ifdef __cplusplus
04120 extern "C" {
04121 #endif
04122
04129 typedef struct GWEN_IO_REQUEST_LIST2 GWEN_IO_REQUEST_LIST2;
04130
04134 typedef struct GWEN_IO_REQUEST_LIST2_ITERATOR GWEN_IO_REQUEST_LIST2_ITERATOR;
04135
04139 typedef GWEN_IO_REQUEST* (GWEN_IO_REQUEST_LIST2_FOREACH)(GWEN_IO_REQUEST *element,
04140 void *user_data);
04141
04145 GWEN_IO_REQUEST_LIST2 *GWEN_Io_Request_List2_new();
04146
04150 void GWEN_Io_Request_List2_free(GWEN_IO_REQUEST_LIST2 *l);
04151
04155 void GWEN_Io_Request_List2_Dump(GWEN_IO_REQUEST_LIST2 *l, FILE *f, unsigned int indent);
04156
04160 void GWEN_Io_Request_List2_PushBack(GWEN_IO_REQUEST_LIST2 *l, GWEN_IO_REQUEST *p);
04161
04166 void GWEN_Io_Request_List2_PushFront(GWEN_IO_REQUEST_LIST2 *l, GWEN_IO_REQUEST *p);
04167
04172 GWEN_IO_REQUEST *GWEN_Io_Request_List2_GetFront(GWEN_IO_REQUEST_LIST2 *l);
04173
04178 GWEN_IO_REQUEST *GWEN_Io_Request_List2_GetBack(GWEN_IO_REQUEST_LIST2 *l);
04179
04184 void GWEN_Io_Request_List2_Erase(GWEN_IO_REQUEST_LIST2 *l,
04185 GWEN_IO_REQUEST_LIST2_ITERATOR *it);
04186
04192 unsigned int GWEN_Io_Request_List2_GetSize(GWEN_IO_REQUEST_LIST2 *l);
04193
04198 void GWEN_Io_Request_List2_PopBack(GWEN_IO_REQUEST_LIST2 *l);
04199
04204 void GWEN_Io_Request_List2_PopFront(GWEN_IO_REQUEST_LIST2 *l);
04205
04209 void GWEN_Io_Request_List2_Clear(GWEN_IO_REQUEST_LIST2 *l);
04210
04214 GWEN_IO_REQUEST_LIST2_ITERATOR *GWEN_Io_Request_List2_First(GWEN_IO_REQUEST_LIST2 *l);
04215
04219 GWEN_IO_REQUEST_LIST2_ITERATOR *GWEN_Io_Request_List2_Last(GWEN_IO_REQUEST_LIST2 *l);
04220
04224 GWEN_IO_REQUEST_LIST2_ITERATOR *GWEN_Io_Request_List2Iterator_new(GWEN_IO_REQUEST_LIST2 *l);
04225
04229 void GWEN_Io_Request_List2Iterator_free(GWEN_IO_REQUEST_LIST2_ITERATOR *li);
04230
04235 GWEN_IO_REQUEST *GWEN_Io_Request_List2Iterator_Previous(GWEN_IO_REQUEST_LIST2_ITERATOR *li);
04236
04241 GWEN_IO_REQUEST *GWEN_Io_Request_List2Iterator_Next(GWEN_IO_REQUEST_LIST2_ITERATOR *li);
04242
04247 GWEN_IO_REQUEST *GWEN_Io_Request_List2Iterator_Data(GWEN_IO_REQUEST_LIST2_ITERATOR *li);
04248
04260 GWEN_IO_REQUEST *GWEN_Io_Request_List2_ForEach(GWEN_IO_REQUEST_LIST2 *list,
04261 GWEN_IO_REQUEST_LIST2_FOREACH func,
04262 void *user_data);
04263
04264
04265 typedef struct GWEN_IO_REQUEST_CONSTLIST2 GWEN_IO_REQUEST_CONSTLIST2;
04266 typedef struct GWEN_IO_REQUEST_CONSTLIST2_ITERATOR GWEN_IO_REQUEST_CONSTLIST2_ITERATOR;
04267 typedef const GWEN_IO_REQUEST*
04268 (GWEN_IO_REQUEST_CONSTLIST2_FOREACH)(const GWEN_IO_REQUEST *element,
04269 void *user_data);
04270
04271
04272 GWEN_IO_REQUEST_CONSTLIST2 *GWEN_Io_Request_ConstList2_new();
04273
04274 void GWEN_Io_Request_ConstList2_free(GWEN_IO_REQUEST_CONSTLIST2 *l);
04275
04276 void GWEN_Io_Request_ConstList2_PushBack(GWEN_IO_REQUEST_CONSTLIST2 *l, const GWEN_IO_REQUEST *p);
04277
04278 void GWEN_Io_Request_ConstList2_PushFront(GWEN_IO_REQUEST_CONSTLIST2 *l, const GWEN_IO_REQUEST *p);
04279
04280 const GWEN_IO_REQUEST *GWEN_Io_Request_ConstList2_GetFront(GWEN_IO_REQUEST_CONSTLIST2 *l);
04281
04282 const GWEN_IO_REQUEST *GWEN_Io_Request_ConstList2_GetBack(GWEN_IO_REQUEST_CONSTLIST2 *l);
04283
04284 unsigned int GWEN_Io_Request_ConstList2_GetSize(GWEN_IO_REQUEST_CONSTLIST2 *l);
04285
04286 void GWEN_Io_Request_ConstList2_PopBack(GWEN_IO_REQUEST_CONSTLIST2 *l);
04287
04288 void GWEN_Io_Request_ConstList2_PopFront(GWEN_IO_REQUEST_CONSTLIST2 *l);
04289
04290 void GWEN_Io_Request_ConstList2_Clear(GWEN_IO_REQUEST_CONSTLIST2 *l);
04291
04292 GWEN_IO_REQUEST_CONSTLIST2_ITERATOR *GWEN_Io_Request_ConstList2_First(GWEN_IO_REQUEST_CONSTLIST2 *l);
04293
04294 GWEN_IO_REQUEST_CONSTLIST2_ITERATOR *GWEN_Io_Request_ConstList2_Last(GWEN_IO_REQUEST_CONSTLIST2 *l);
04295
04296 GWEN_IO_REQUEST_CONSTLIST2_ITERATOR *GWEN_Io_Request_ConstList2Iterator_new(GWEN_IO_REQUEST_CONSTLIST2 *l);
04297
04298 void GWEN_Io_Request_ConstList2Iterator_free(GWEN_IO_REQUEST_CONSTLIST2_ITERATOR *li);
04299
04300 const GWEN_IO_REQUEST *GWEN_Io_Request_ConstList2Iterator_Previous(GWEN_IO_REQUEST_CONSTLIST2_ITERATOR *li);
04301
04302 const GWEN_IO_REQUEST *GWEN_Io_Request_ConstList2Iterator_Next(GWEN_IO_REQUEST_CONSTLIST2_ITERATOR *li);
04303
04304 const GWEN_IO_REQUEST *GWEN_Io_Request_ConstList2Iterator_Data(GWEN_IO_REQUEST_CONSTLIST2_ITERATOR *li);
04305
04317 const GWEN_IO_REQUEST *GWEN_Io_Request_ConstList2_ForEach(GWEN_IO_REQUEST_CONSTLIST2 *list,
04318 GWEN_IO_REQUEST_CONSTLIST2_FOREACH func, void *user_data);
04319
04320
04321 #ifdef __cplusplus
04322 }
04323 #endif
04324
04325
04326 #endif
04327
04328
04329
04330
04331
04332
04333
04334
04335
04336
04337
04338
04339
04340
04341
04342
04343
04344
04345
04346
04347
04348
04349
04350
04351
04352
04353
04354
04355
04356
04357
04358 #ifndef GWEN_IO_REQUEST_LIST1_H
04359 #define GWEN_IO_REQUEST_LIST1_H
04360
04361 #ifdef __cplusplus
04362 extern "C" {
04363 #endif
04364
04366 typedef struct GWEN_IO_REQUEST_LIST_ELEMENT {
04367 uint32_t id;
04368 GWEN_IO_REQUEST *nextObject;
04369 } GWEN_IO_REQUEST_LIST__ELEMENT;
04370
04377 typedef struct GWEN_IO_REQUEST_LIST GWEN_IO_REQUEST_LIST;
04379 struct GWEN_IO_REQUEST_LIST {
04380 GWEN_IO_REQUEST *first;
04381 uint32_t count;
04382 uint32_t id;
04383 } GWEN_IO_REQUEST_LIST;
04384
04389 void GWEN_Io_Request_List_AddList(GWEN_IO_REQUEST_LIST *dst, GWEN_IO_REQUEST_LIST *l);
04390
04394 void GWEN_Io_Request_List_Add(GWEN_IO_REQUEST *element, GWEN_IO_REQUEST_LIST *list);
04395
04400 void GWEN_Io_Request_List_Insert(GWEN_IO_REQUEST *element, GWEN_IO_REQUEST_LIST *list);
04401
04408 void GWEN_Io_Request_List_Del(GWEN_IO_REQUEST *element);
04409
04413 GWEN_IO_REQUEST* GWEN_Io_Request_List_First(const GWEN_IO_REQUEST_LIST *l);
04414
04418 GWEN_IO_REQUEST* GWEN_Io_Request_List_Last(const GWEN_IO_REQUEST_LIST *l);
04419
04424 void GWEN_Io_Request_List_Clear(GWEN_IO_REQUEST_LIST *l);
04425
04429 GWEN_IO_REQUEST_LIST* GWEN_Io_Request_List_new();
04430
04434 void GWEN_Io_Request_List_free(GWEN_IO_REQUEST_LIST *l);
04435
04439 GWEN_IO_REQUEST* GWEN_Io_Request_List_Next(const GWEN_IO_REQUEST *element);
04440
04444 GWEN_IO_REQUEST* GWEN_Io_Request_List_Previous(const GWEN_IO_REQUEST *element);
04445
04449 uint32_t GWEN_Io_Request_List_GetCount(const GWEN_IO_REQUEST_LIST *l);
04450
04451 #ifdef __cplusplus
04452 }
04453 #endif
04454
04455
04456 #endif
04457
04458
04459
04460
04461
04462
04463
04464
04465
04466
04467
04468
04469
04470
04471
04472
04473
04474
04475
04476
04477
04478
04479
04480
04481
04482
04483
04484
04485
04486
04487
04488 #ifndef GWEN_SSLCERTDESCR_LIST2_H
04489 #define GWEN_SSLCERTDESCR_LIST2_H
04490
04491
04492 #ifdef __cplusplus
04493 extern "C" {
04494 #endif
04495
04502 typedef struct GWEN_SSLCERTDESCR_LIST2 GWEN_SSLCERTDESCR_LIST2;
04503
04507 typedef struct GWEN_SSLCERTDESCR_LIST2_ITERATOR GWEN_SSLCERTDESCR_LIST2_ITERATOR;
04508
04512 typedef GWEN_SSLCERTDESCR* (GWEN_SSLCERTDESCR_LIST2_FOREACH)(GWEN_SSLCERTDESCR *element,
04513 void *user_data);
04514
04518 GWEN_SSLCERTDESCR_LIST2 *GWEN_SslCertDescr_List2_new();
04519
04523 void GWEN_SslCertDescr_List2_free(GWEN_SSLCERTDESCR_LIST2 *l);
04524
04528 void GWEN_SslCertDescr_List2_Dump(GWEN_SSLCERTDESCR_LIST2 *l, FILE *f, unsigned int indent);
04529
04533 void GWEN_SslCertDescr_List2_PushBack(GWEN_SSLCERTDESCR_LIST2 *l, GWEN_SSLCERTDESCR *p);
04534
04539 void GWEN_SslCertDescr_List2_PushFront(GWEN_SSLCERTDESCR_LIST2 *l, GWEN_SSLCERTDESCR *p);
04540
04545 GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2_GetFront(GWEN_SSLCERTDESCR_LIST2 *l);
04546
04551 GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2_GetBack(GWEN_SSLCERTDESCR_LIST2 *l);
04552
04557 void GWEN_SslCertDescr_List2_Erase(GWEN_SSLCERTDESCR_LIST2 *l,
04558 GWEN_SSLCERTDESCR_LIST2_ITERATOR *it);
04559
04565 unsigned int GWEN_SslCertDescr_List2_GetSize(GWEN_SSLCERTDESCR_LIST2 *l);
04566
04571 void GWEN_SslCertDescr_List2_PopBack(GWEN_SSLCERTDESCR_LIST2 *l);
04572
04577 void GWEN_SslCertDescr_List2_PopFront(GWEN_SSLCERTDESCR_LIST2 *l);
04578
04582 void GWEN_SslCertDescr_List2_Clear(GWEN_SSLCERTDESCR_LIST2 *l);
04583
04587 GWEN_SSLCERTDESCR_LIST2_ITERATOR *GWEN_SslCertDescr_List2_First(GWEN_SSLCERTDESCR_LIST2 *l);
04588
04592 GWEN_SSLCERTDESCR_LIST2_ITERATOR *GWEN_SslCertDescr_List2_Last(GWEN_SSLCERTDESCR_LIST2 *l);
04593
04597 GWEN_SSLCERTDESCR_LIST2_ITERATOR *GWEN_SslCertDescr_List2Iterator_new(GWEN_SSLCERTDESCR_LIST2 *l);
04598
04602 void GWEN_SslCertDescr_List2Iterator_free(GWEN_SSLCERTDESCR_LIST2_ITERATOR *li);
04603
04608 GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2Iterator_Previous(GWEN_SSLCERTDESCR_LIST2_ITERATOR *li);
04609
04614 GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2Iterator_Next(GWEN_SSLCERTDESCR_LIST2_ITERATOR *li);
04615
04620 GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2Iterator_Data(GWEN_SSLCERTDESCR_LIST2_ITERATOR *li);
04621
04633 GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2_ForEach(GWEN_SSLCERTDESCR_LIST2 *list,
04634 GWEN_SSLCERTDESCR_LIST2_FOREACH func,
04635 void *user_data);
04636
04637
04638 typedef struct GWEN_SSLCERTDESCR_CONSTLIST2 GWEN_SSLCERTDESCR_CONSTLIST2;
04639 typedef struct GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR;
04640 typedef const GWEN_SSLCERTDESCR*
04641 (GWEN_SSLCERTDESCR_CONSTLIST2_FOREACH)(const GWEN_SSLCERTDESCR *element,
04642 void *user_data);
04643
04644
04645 GWEN_SSLCERTDESCR_CONSTLIST2 *GWEN_SslCertDescr_ConstList2_new();
04646
04647 void GWEN_SslCertDescr_ConstList2_free(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
04648
04649 void GWEN_SslCertDescr_ConstList2_PushBack(GWEN_SSLCERTDESCR_CONSTLIST2 *l, const GWEN_SSLCERTDESCR *p);
04650
04651 void GWEN_SslCertDescr_ConstList2_PushFront(GWEN_SSLCERTDESCR_CONSTLIST2 *l, const GWEN_SSLCERTDESCR *p);
04652
04653 const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2_GetFront(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
04654
04655 const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2_GetBack(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
04656
04657 unsigned int GWEN_SslCertDescr_ConstList2_GetSize(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
04658
04659 void GWEN_SslCertDescr_ConstList2_PopBack(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
04660
04661 void GWEN_SslCertDescr_ConstList2_PopFront(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
04662
04663 void GWEN_SslCertDescr_ConstList2_Clear(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
04664
04665 GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *GWEN_SslCertDescr_ConstList2_First(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
04666
04667 GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *GWEN_SslCertDescr_ConstList2_Last(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
04668
04669 GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *GWEN_SslCertDescr_ConstList2Iterator_new(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
04670
04671 void GWEN_SslCertDescr_ConstList2Iterator_free(GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *li);
04672
04673 const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2Iterator_Previous(GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *li);
04674
04675 const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2Iterator_Next(GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *li);
04676
04677 const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2Iterator_Data(GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *li);
04678
04690 const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2_ForEach(GWEN_SSLCERTDESCR_CONSTLIST2 *list,
04691 GWEN_SSLCERTDESCR_CONSTLIST2_FOREACH func, void *user_data);
04692
04693
04694 #ifdef __cplusplus
04695 }
04696 #endif
04697
04698
04699 #endif
04700
04701
04702
04703
04704
04705
04706
04707
04708
04709
04710
04711
04712
04713
04714
04715
04716
04717
04718
04719
04720
04721
04722
04723
04724
04725
04726
04727
04728
04729
04730
04731 #ifndef GWEN_SSLCERTDESCR_LIST1_H
04732 #define GWEN_SSLCERTDESCR_LIST1_H
04733
04734 #ifdef __cplusplus
04735 extern "C" {
04736 #endif
04737
04739 typedef struct GWEN_SSLCERTDESCR_LIST_ELEMENT {
04740 uint32_t id;
04741 GWEN_SSLCERTDESCR *nextObject;
04742 } GWEN_SSLCERTDESCR_LIST__ELEMENT;
04743
04750 typedef struct GWEN_SSLCERTDESCR_LIST GWEN_SSLCERTDESCR_LIST;
04752 struct GWEN_SSLCERTDESCR_LIST {
04753 GWEN_SSLCERTDESCR *first;
04754 uint32_t count;
04755 uint32_t id;
04756 } GWEN_SSLCERTDESCR_LIST;
04757
04762 void GWEN_SslCertDescr_List_AddList(GWEN_SSLCERTDESCR_LIST *dst, GWEN_SSLCERTDESCR_LIST *l);
04763
04767 void GWEN_SslCertDescr_List_Add(GWEN_SSLCERTDESCR *element, GWEN_SSLCERTDESCR_LIST *list);
04768
04773 void GWEN_SslCertDescr_List_Insert(GWEN_SSLCERTDESCR *element, GWEN_SSLCERTDESCR_LIST *list);
04774
04781 void GWEN_SslCertDescr_List_Del(GWEN_SSLCERTDESCR *element);
04782
04786 GWEN_SSLCERTDESCR* GWEN_SslCertDescr_List_First(const GWEN_SSLCERTDESCR_LIST *l);
04787
04791 GWEN_SSLCERTDESCR* GWEN_SslCertDescr_List_Last(const GWEN_SSLCERTDESCR_LIST *l);
04792
04797 void GWEN_SslCertDescr_List_Clear(GWEN_SSLCERTDESCR_LIST *l);
04798
04802 GWEN_SSLCERTDESCR_LIST* GWEN_SslCertDescr_List_new();
04803
04807 void GWEN_SslCertDescr_List_free(GWEN_SSLCERTDESCR_LIST *l);
04808
04812 GWEN_SSLCERTDESCR* GWEN_SslCertDescr_List_Next(const GWEN_SSLCERTDESCR *element);
04813
04817 GWEN_SSLCERTDESCR* GWEN_SslCertDescr_List_Previous(const GWEN_SSLCERTDESCR *element);
04818
04822 uint32_t GWEN_SslCertDescr_List_GetCount(const GWEN_SSLCERTDESCR_LIST *l);
04823
04824 #ifdef __cplusplus
04825 }
04826 #endif
04827
04828
04829 #endif
04830
04831
04832
04833
04834
04835
04836
04837
04838
04839
04840
04841
04842
04843
04844
04845
04846
04847
04848
04849
04850
04851
04852
04853
04854
04855
04856
04857
04858
04859
04860
04861 #ifndef GWEN_IPC_REQUEST_LIST2_H
04862 #define GWEN_IPC_REQUEST_LIST2_H
04863
04864
04865 #ifdef __cplusplus
04866 extern "C" {
04867 #endif
04868
04875 typedef struct GWEN_IPC_REQUEST_LIST2 GWEN_IPC_REQUEST_LIST2;
04876
04880 typedef struct GWEN_IPC_REQUEST_LIST2_ITERATOR GWEN_IPC_REQUEST_LIST2_ITERATOR;
04881
04885 typedef GWEN_IPC_REQUEST* (GWEN_IPC_REQUEST_LIST2_FOREACH)(GWEN_IPC_REQUEST *element,
04886 void *user_data);
04887
04891 GWEN_IPC_REQUEST_LIST2 *GWEN_IpcRequest_List2_new();
04892
04896 void GWEN_IpcRequest_List2_free(GWEN_IPC_REQUEST_LIST2 *l);
04897
04901 void GWEN_IpcRequest_List2_Dump(GWEN_IPC_REQUEST_LIST2 *l, FILE *f, unsigned int indent);
04902
04906 void GWEN_IpcRequest_List2_PushBack(GWEN_IPC_REQUEST_LIST2 *l, GWEN_IPC_REQUEST *p);
04907
04912 void GWEN_IpcRequest_List2_PushFront(GWEN_IPC_REQUEST_LIST2 *l, GWEN_IPC_REQUEST *p);
04913
04918 GWEN_IPC_REQUEST *GWEN_IpcRequest_List2_GetFront(GWEN_IPC_REQUEST_LIST2 *l);
04919
04924 GWEN_IPC_REQUEST *GWEN_IpcRequest_List2_GetBack(GWEN_IPC_REQUEST_LIST2 *l);
04925
04930 void GWEN_IpcRequest_List2_Erase(GWEN_IPC_REQUEST_LIST2 *l,
04931 GWEN_IPC_REQUEST_LIST2_ITERATOR *it);
04932
04938 unsigned int GWEN_IpcRequest_List2_GetSize(GWEN_IPC_REQUEST_LIST2 *l);
04939
04944 void GWEN_IpcRequest_List2_PopBack(GWEN_IPC_REQUEST_LIST2 *l);
04945
04950 void GWEN_IpcRequest_List2_PopFront(GWEN_IPC_REQUEST_LIST2 *l);
04951
04955 void GWEN_IpcRequest_List2_Clear(GWEN_IPC_REQUEST_LIST2 *l);
04956
04960 GWEN_IPC_REQUEST_LIST2_ITERATOR *GWEN_IpcRequest_List2_First(GWEN_IPC_REQUEST_LIST2 *l);
04961
04965 GWEN_IPC_REQUEST_LIST2_ITERATOR *GWEN_IpcRequest_List2_Last(GWEN_IPC_REQUEST_LIST2 *l);
04966
04970 GWEN_IPC_REQUEST_LIST2_ITERATOR *GWEN_IpcRequest_List2Iterator_new(GWEN_IPC_REQUEST_LIST2 *l);
04971
04975 void GWEN_IpcRequest_List2Iterator_free(GWEN_IPC_REQUEST_LIST2_ITERATOR *li);
04976
04981 GWEN_IPC_REQUEST *GWEN_IpcRequest_List2Iterator_Previous(GWEN_IPC_REQUEST_LIST2_ITERATOR *li);
04982
04987 GWEN_IPC_REQUEST *GWEN_IpcRequest_List2Iterator_Next(GWEN_IPC_REQUEST_LIST2_ITERATOR *li);
04988
04993 GWEN_IPC_REQUEST *GWEN_IpcRequest_List2Iterator_Data(GWEN_IPC_REQUEST_LIST2_ITERATOR *li);
04994
05006 GWEN_IPC_REQUEST *GWEN_IpcRequest_List2_ForEach(GWEN_IPC_REQUEST_LIST2 *list,
05007 GWEN_IPC_REQUEST_LIST2_FOREACH func,
05008 void *user_data);
05009
05010
05011 typedef struct GWEN_IPC_REQUEST_CONSTLIST2 GWEN_IPC_REQUEST_CONSTLIST2;
05012 typedef struct GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR;
05013 typedef const GWEN_IPC_REQUEST*
05014 (GWEN_IPC_REQUEST_CONSTLIST2_FOREACH)(const GWEN_IPC_REQUEST *element,
05015 void *user_data);
05016
05017
05018 GWEN_IPC_REQUEST_CONSTLIST2 *GWEN_IpcRequest_ConstList2_new();
05019
05020 void GWEN_IpcRequest_ConstList2_free(GWEN_IPC_REQUEST_CONSTLIST2 *l);
05021
05022 void GWEN_IpcRequest_ConstList2_PushBack(GWEN_IPC_REQUEST_CONSTLIST2 *l, const GWEN_IPC_REQUEST *p);
05023
05024 void GWEN_IpcRequest_ConstList2_PushFront(GWEN_IPC_REQUEST_CONSTLIST2 *l, const GWEN_IPC_REQUEST *p);
05025
05026 const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2_GetFront(GWEN_IPC_REQUEST_CONSTLIST2 *l);
05027
05028 const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2_GetBack(GWEN_IPC_REQUEST_CONSTLIST2 *l);
05029
05030 unsigned int GWEN_IpcRequest_ConstList2_GetSize(GWEN_IPC_REQUEST_CONSTLIST2 *l);
05031
05032 void GWEN_IpcRequest_ConstList2_PopBack(GWEN_IPC_REQUEST_CONSTLIST2 *l);
05033
05034 void GWEN_IpcRequest_ConstList2_PopFront(GWEN_IPC_REQUEST_CONSTLIST2 *l);
05035
05036 void GWEN_IpcRequest_ConstList2_Clear(GWEN_IPC_REQUEST_CONSTLIST2 *l);
05037
05038 GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *GWEN_IpcRequest_ConstList2_First(GWEN_IPC_REQUEST_CONSTLIST2 *l);
05039
05040 GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *GWEN_IpcRequest_ConstList2_Last(GWEN_IPC_REQUEST_CONSTLIST2 *l);
05041
05042 GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *GWEN_IpcRequest_ConstList2Iterator_new(GWEN_IPC_REQUEST_CONSTLIST2 *l);
05043
05044 void GWEN_IpcRequest_ConstList2Iterator_free(GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *li);
05045
05046 const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2Iterator_Previous(GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *li);
05047
05048 const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2Iterator_Next(GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *li);
05049
05050 const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2Iterator_Data(GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *li);
05051
05063 const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2_ForEach(GWEN_IPC_REQUEST_CONSTLIST2 *list,
05064 GWEN_IPC_REQUEST_CONSTLIST2_FOREACH func, void *user_data);
05065
05066
05067 #ifdef __cplusplus
05068 }
05069 #endif
05070
05071
05072 #endif
05073
05074
05075
05076
05077
05078
05079
05080
05081
05082
05083
05084
05085
05086
05087
05088
05089
05090
05091
05092
05093
05094
05095
05096
05097
05098
05099
05100
05101
05102
05103
05104 #ifndef GWEN_IPC_REQUEST_LIST1_H
05105 #define GWEN_IPC_REQUEST_LIST1_H
05106
05107 #ifdef __cplusplus
05108 extern "C" {
05109 #endif
05110
05112 typedef struct GWEN_IPC_REQUEST_LIST_ELEMENT {
05113 uint32_t id;
05114 GWEN_IPC_REQUEST *nextObject;
05115 } GWEN_IPC_REQUEST_LIST__ELEMENT;
05116
05123 typedef struct GWEN_IPC_REQUEST_LIST GWEN_IPC_REQUEST_LIST;
05125 struct GWEN_IPC_REQUEST_LIST {
05126 GWEN_IPC_REQUEST *first;
05127 uint32_t count;
05128 uint32_t id;
05129 } GWEN_IPC_REQUEST_LIST;
05130
05135 void GWEN_IpcRequest_List_AddList(GWEN_IPC_REQUEST_LIST *dst, GWEN_IPC_REQUEST_LIST *l);
05136
05140 void GWEN_IpcRequest_List_Add(GWEN_IPC_REQUEST *element, GWEN_IPC_REQUEST_LIST *list);
05141
05146 void GWEN_IpcRequest_List_Insert(GWEN_IPC_REQUEST *element, GWEN_IPC_REQUEST_LIST *list);
05147
05154 void GWEN_IpcRequest_List_Del(GWEN_IPC_REQUEST *element);
05155
05159 GWEN_IPC_REQUEST* GWEN_IpcRequest_List_First(const GWEN_IPC_REQUEST_LIST *l);
05160
05164 GWEN_IPC_REQUEST* GWEN_IpcRequest_List_Last(const GWEN_IPC_REQUEST_LIST *l);
05165
05170 void GWEN_IpcRequest_List_Clear(GWEN_IPC_REQUEST_LIST *l);
05171
05175 GWEN_IPC_REQUEST_LIST* GWEN_IpcRequest_List_new();
05176
05180 void GWEN_IpcRequest_List_free(GWEN_IPC_REQUEST_LIST *l);
05181
05185 GWEN_IPC_REQUEST* GWEN_IpcRequest_List_Next(const GWEN_IPC_REQUEST *element);
05186
05190 GWEN_IPC_REQUEST* GWEN_IpcRequest_List_Previous(const GWEN_IPC_REQUEST *element);
05191
05195 uint32_t GWEN_IpcRequest_List_GetCount(const GWEN_IPC_REQUEST_LIST *l);
05196
05197 #ifdef __cplusplus
05198 }
05199 #endif
05200
05201
05202 #endif
05203
05204
05205
05206
05207
05208
05209
05210
05211
05212
05213
05214
05215
05216
05217
05218
05219
05220
05221
05222
05223
05224
05225
05226
05227
05228
05229
05230
05231
05232
05233
05234 #ifndef GWEN_SOCKET_LIST2_H
05235 #define GWEN_SOCKET_LIST2_H
05236
05237
05238 #ifdef __cplusplus
05239 extern "C" {
05240 #endif
05241
05248 typedef struct GWEN_SOCKET_LIST2 GWEN_SOCKET_LIST2;
05249
05253 typedef struct GWEN_SOCKET_LIST2_ITERATOR GWEN_SOCKET_LIST2_ITERATOR;
05254
05258 typedef GWEN_SOCKET* (GWEN_SOCKET_LIST2_FOREACH)(GWEN_SOCKET *element,
05259 void *user_data);
05260
05264 GWEN_SOCKET_LIST2 *GWEN_Socket_List2_new();
05265
05269 void GWEN_Socket_List2_free(GWEN_SOCKET_LIST2 *l);
05270
05274 void GWEN_Socket_List2_Dump(GWEN_SOCKET_LIST2 *l, FILE *f, unsigned int indent);
05275
05279 void GWEN_Socket_List2_PushBack(GWEN_SOCKET_LIST2 *l, GWEN_SOCKET *p);
05280
05285 void GWEN_Socket_List2_PushFront(GWEN_SOCKET_LIST2 *l, GWEN_SOCKET *p);
05286
05291 GWEN_SOCKET *GWEN_Socket_List2_GetFront(GWEN_SOCKET_LIST2 *l);
05292
05297 GWEN_SOCKET *GWEN_Socket_List2_GetBack(GWEN_SOCKET_LIST2 *l);
05298
05303 void GWEN_Socket_List2_Erase(GWEN_SOCKET_LIST2 *l,
05304 GWEN_SOCKET_LIST2_ITERATOR *it);
05305
05311 unsigned int GWEN_Socket_List2_GetSize(GWEN_SOCKET_LIST2 *l);
05312
05317 void GWEN_Socket_List2_PopBack(GWEN_SOCKET_LIST2 *l);
05318
05323 void GWEN_Socket_List2_PopFront(GWEN_SOCKET_LIST2 *l);
05324
05328 void GWEN_Socket_List2_Clear(GWEN_SOCKET_LIST2 *l);
05329
05333 GWEN_SOCKET_LIST2_ITERATOR *GWEN_Socket_List2_First(GWEN_SOCKET_LIST2 *l);
05334
05338 GWEN_SOCKET_LIST2_ITERATOR *GWEN_Socket_List2_Last(GWEN_SOCKET_LIST2 *l);
05339
05343 GWEN_SOCKET_LIST2_ITERATOR *GWEN_Socket_List2Iterator_new(GWEN_SOCKET_LIST2 *l);
05344
05348 void GWEN_Socket_List2Iterator_free(GWEN_SOCKET_LIST2_ITERATOR *li);
05349
05354 GWEN_SOCKET *GWEN_Socket_List2Iterator_Previous(GWEN_SOCKET_LIST2_ITERATOR *li);
05355
05360 GWEN_SOCKET *GWEN_Socket_List2Iterator_Next(GWEN_SOCKET_LIST2_ITERATOR *li);
05361
05366 GWEN_SOCKET *GWEN_Socket_List2Iterator_Data(GWEN_SOCKET_LIST2_ITERATOR *li);
05367
05379 GWEN_SOCKET *GWEN_Socket_List2_ForEach(GWEN_SOCKET_LIST2 *list,
05380 GWEN_SOCKET_LIST2_FOREACH func,
05381 void *user_data);
05382
05383
05384 typedef struct GWEN_SOCKET_CONSTLIST2 GWEN_SOCKET_CONSTLIST2;
05385 typedef struct GWEN_SOCKET_CONSTLIST2_ITERATOR GWEN_SOCKET_CONSTLIST2_ITERATOR;
05386 typedef const GWEN_SOCKET*
05387 (GWEN_SOCKET_CONSTLIST2_FOREACH)(const GWEN_SOCKET *element,
05388 void *user_data);
05389
05390
05391 GWEN_SOCKET_CONSTLIST2 *GWEN_Socket_ConstList2_new();
05392
05393 void GWEN_Socket_ConstList2_free(GWEN_SOCKET_CONSTLIST2 *l);
05394
05395 void GWEN_Socket_ConstList2_PushBack(GWEN_SOCKET_CONSTLIST2 *l, const GWEN_SOCKET *p);
05396
05397 void GWEN_Socket_ConstList2_PushFront(GWEN_SOCKET_CONSTLIST2 *l, const GWEN_SOCKET *p);
05398
05399 const GWEN_SOCKET *GWEN_Socket_ConstList2_GetFront(GWEN_SOCKET_CONSTLIST2 *l);
05400
05401 const GWEN_SOCKET *GWEN_Socket_ConstList2_GetBack(GWEN_SOCKET_CONSTLIST2 *l);
05402
05403 unsigned int GWEN_Socket_ConstList2_GetSize(GWEN_SOCKET_CONSTLIST2 *l);
05404
05405 void GWEN_Socket_ConstList2_PopBack(GWEN_SOCKET_CONSTLIST2 *l);
05406
05407 void GWEN_Socket_ConstList2_PopFront(GWEN_SOCKET_CONSTLIST2 *l);
05408
05409 void GWEN_Socket_ConstList2_Clear(GWEN_SOCKET_CONSTLIST2 *l);
05410
05411 GWEN_SOCKET_CONSTLIST2_ITERATOR *GWEN_Socket_ConstList2_First(GWEN_SOCKET_CONSTLIST2 *l);
05412
05413 GWEN_SOCKET_CONSTLIST2_ITERATOR *GWEN_Socket_ConstList2_Last(GWEN_SOCKET_CONSTLIST2 *l);
05414
05415 GWEN_SOCKET_CONSTLIST2_ITERATOR *GWEN_Socket_ConstList2Iterator_new(GWEN_SOCKET_CONSTLIST2 *l);
05416
05417 void GWEN_Socket_ConstList2Iterator_free(GWEN_SOCKET_CONSTLIST2_ITERATOR *li);
05418
05419 const GWEN_SOCKET *GWEN_Socket_ConstList2Iterator_Previous(GWEN_SOCKET_CONSTLIST2_ITERATOR *li);
05420
05421 const GWEN_SOCKET *GWEN_Socket_ConstList2Iterator_Next(GWEN_SOCKET_CONSTLIST2_ITERATOR *li);
05422
05423 const GWEN_SOCKET *GWEN_Socket_ConstList2Iterator_Data(GWEN_SOCKET_CONSTLIST2_ITERATOR *li);
05424
05436 const GWEN_SOCKET *GWEN_Socket_ConstList2_ForEach(GWEN_SOCKET_CONSTLIST2 *list,
05437 GWEN_SOCKET_CONSTLIST2_FOREACH func, void *user_data);
05438
05439
05440 #ifdef __cplusplus
05441 }
05442 #endif
05443
05444
05445 #endif
05446
05447
05448
05449
05450
05451
05452
05453
05454
05455
05456
05457
05458
05459
05460
05461
05462
05463
05464
05465
05466
05467
05468
05469
05470
05471
05472
05473
05474
05475
05476
05477 #ifndef GWEN_SOCKET_LIST1_H
05478 #define GWEN_SOCKET_LIST1_H
05479
05480 #ifdef __cplusplus
05481 extern "C" {
05482 #endif
05483
05485 typedef struct GWEN_SOCKET_LIST_ELEMENT {
05486 uint32_t id;
05487 GWEN_SOCKET *nextObject;
05488 } GWEN_SOCKET_LIST__ELEMENT;
05489
05496 typedef struct GWEN_SOCKET_LIST GWEN_SOCKET_LIST;
05498 struct GWEN_SOCKET_LIST {
05499 GWEN_SOCKET *first;
05500 uint32_t count;
05501 uint32_t id;
05502 } GWEN_SOCKET_LIST;
05503
05508 void GWEN_Socket_List_AddList(GWEN_SOCKET_LIST *dst, GWEN_SOCKET_LIST *l);
05509
05513 void GWEN_Socket_List_Add(GWEN_SOCKET *element, GWEN_SOCKET_LIST *list);
05514
05519 void GWEN_Socket_List_Insert(GWEN_SOCKET *element, GWEN_SOCKET_LIST *list);
05520
05527 void GWEN_Socket_List_Del(GWEN_SOCKET *element);
05528
05532 GWEN_SOCKET* GWEN_Socket_List_First(const GWEN_SOCKET_LIST *l);
05533
05537 GWEN_SOCKET* GWEN_Socket_List_Last(const GWEN_SOCKET_LIST *l);
05538
05543 void GWEN_Socket_List_Clear(GWEN_SOCKET_LIST *l);
05544
05548 GWEN_SOCKET_LIST* GWEN_Socket_List_new();
05549
05553 void GWEN_Socket_List_free(GWEN_SOCKET_LIST *l);
05554
05558 GWEN_SOCKET* GWEN_Socket_List_Next(const GWEN_SOCKET *element);
05559
05563 GWEN_SOCKET* GWEN_Socket_List_Previous(const GWEN_SOCKET *element);
05564
05568 uint32_t GWEN_Socket_List_GetCount(const GWEN_SOCKET_LIST *l);
05569
05570 #ifdef __cplusplus
05571 }
05572 #endif
05573
05574
05575 #endif
05576
05577
05578
05579
05580
05581
05582
05583
05584
05585
05586
05587
05588
05589
05590
05591
05592
05593
05594
05595
05596
05597
05598
05599
05600
05601
05602
05603
05604
05605
05606
05607 #ifndef GWEN_DBIO_LIST1_H
05608 #define GWEN_DBIO_LIST1_H
05609
05610 #ifdef __cplusplus
05611 extern "C" {
05612 #endif
05613
05615 typedef struct GWEN_DBIO_LIST_ELEMENT {
05616 uint32_t id;
05617 GWEN_DBIO *nextObject;
05618 } GWEN_DBIO_LIST__ELEMENT;
05619
05626 typedef struct GWEN_DBIO_LIST GWEN_DBIO_LIST;
05628 struct GWEN_DBIO_LIST {
05629 GWEN_DBIO *first;
05630 uint32_t count;
05631 uint32_t id;
05632 } GWEN_DBIO_LIST;
05633
05638 void GWEN_DBIO_List_AddList(GWEN_DBIO_LIST *dst, GWEN_DBIO_LIST *l);
05639
05643 void GWEN_DBIO_List_Add(GWEN_DBIO *element, GWEN_DBIO_LIST *list);
05644
05649 void GWEN_DBIO_List_Insert(GWEN_DBIO *element, GWEN_DBIO_LIST *list);
05650
05657 void GWEN_DBIO_List_Del(GWEN_DBIO *element);
05658
05662 GWEN_DBIO* GWEN_DBIO_List_First(const GWEN_DBIO_LIST *l);
05663
05667 GWEN_DBIO* GWEN_DBIO_List_Last(const GWEN_DBIO_LIST *l);
05668
05673 void GWEN_DBIO_List_Clear(GWEN_DBIO_LIST *l);
05674
05678 GWEN_DBIO_LIST* GWEN_DBIO_List_new();
05679
05683 void GWEN_DBIO_List_free(GWEN_DBIO_LIST *l);
05684
05688 GWEN_DBIO* GWEN_DBIO_List_Next(const GWEN_DBIO *element);
05689
05693 GWEN_DBIO* GWEN_DBIO_List_Previous(const GWEN_DBIO *element);
05694
05698 uint32_t GWEN_DBIO_List_GetCount(const GWEN_DBIO_LIST *l);
05699
05700 #ifdef __cplusplus
05701 }
05702 #endif
05703
05704
05705 #endif
05706
05707
05708
05709
05710
05711
05712
05713
05714
05715
05716
05717
05718
05719
05720
05721
05722
05723
05724
05725
05726
05727
05728
05729
05730
05731
05732
05733
05734
05735
05736
05737 #ifndef GWEN_TAG16_LIST1_H
05738 #define GWEN_TAG16_LIST1_H
05739
05740 #ifdef __cplusplus
05741 extern "C" {
05742 #endif
05743
05745 typedef struct GWEN_TAG16_LIST_ELEMENT {
05746 uint32_t id;
05747 GWEN_TAG16 *nextObject;
05748 } GWEN_TAG16_LIST__ELEMENT;
05749
05756 typedef struct GWEN_TAG16_LIST GWEN_TAG16_LIST;
05758 struct GWEN_TAG16_LIST {
05759 GWEN_TAG16 *first;
05760 uint32_t count;
05761 uint32_t id;
05762 } GWEN_TAG16_LIST;
05763
05768 void GWEN_Tag16_List_AddList(GWEN_TAG16_LIST *dst, GWEN_TAG16_LIST *l);
05769
05773 void GWEN_Tag16_List_Add(GWEN_TAG16 *element, GWEN_TAG16_LIST *list);
05774
05779 void GWEN_Tag16_List_Insert(GWEN_TAG16 *element, GWEN_TAG16_LIST *list);
05780
05787 void GWEN_Tag16_List_Del(GWEN_TAG16 *element);
05788
05792 GWEN_TAG16* GWEN_Tag16_List_First(const GWEN_TAG16_LIST *l);
05793
05797 GWEN_TAG16* GWEN_Tag16_List_Last(const GWEN_TAG16_LIST *l);
05798
05803 void GWEN_Tag16_List_Clear(GWEN_TAG16_LIST *l);
05804
05808 GWEN_TAG16_LIST* GWEN_Tag16_List_new();
05809
05813 void GWEN_Tag16_List_free(GWEN_TAG16_LIST *l);
05814
05818 GWEN_TAG16* GWEN_Tag16_List_Next(const GWEN_TAG16 *element);
05819
05823 GWEN_TAG16* GWEN_Tag16_List_Previous(const GWEN_TAG16 *element);
05824
05828 uint32_t GWEN_Tag16_List_GetCount(const GWEN_TAG16_LIST *l);
05829
05830 #ifdef __cplusplus
05831 }
05832 #endif
05833
05834
05835 #endif
05836
05837
05838
05839
05840
05841
05842
05843
05844
05845
05846
05847
05848
05849
05850
05851
05852
05853
05854
05855
05856
05857
05858
05859
05860
05861
05862
05863
05864
05865
05866
05867 #ifndef GWEN_TLV_LIST1_H
05868 #define GWEN_TLV_LIST1_H
05869
05870 #ifdef __cplusplus
05871 extern "C" {
05872 #endif
05873
05875 typedef struct GWEN_TLV_LIST_ELEMENT {
05876 uint32_t id;
05877 GWEN_TLV *nextObject;
05878 } GWEN_TLV_LIST__ELEMENT;
05879
05886 typedef struct GWEN_TLV_LIST GWEN_TLV_LIST;
05888 struct GWEN_TLV_LIST {
05889 GWEN_TLV *first;
05890 uint32_t count;
05891 uint32_t id;
05892 } GWEN_TLV_LIST;
05893
05898 void GWEN_TLV_List_AddList(GWEN_TLV_LIST *dst, GWEN_TLV_LIST *l);
05899
05903 void GWEN_TLV_List_Add(GWEN_TLV *element, GWEN_TLV_LIST *list);
05904
05909 void GWEN_TLV_List_Insert(GWEN_TLV *element, GWEN_TLV_LIST *list);
05910
05917 void GWEN_TLV_List_Del(GWEN_TLV *element);
05918
05922 GWEN_TLV* GWEN_TLV_List_First(const GWEN_TLV_LIST *l);
05923
05927 GWEN_TLV* GWEN_TLV_List_Last(const GWEN_TLV_LIST *l);
05928
05933 void GWEN_TLV_List_Clear(GWEN_TLV_LIST *l);
05934
05938 GWEN_TLV_LIST* GWEN_TLV_List_new();
05939
05943 void GWEN_TLV_List_free(GWEN_TLV_LIST *l);
05944
05948 GWEN_TLV* GWEN_TLV_List_Next(const GWEN_TLV *element);
05949
05953 GWEN_TLV* GWEN_TLV_List_Previous(const GWEN_TLV *element);
05954
05958 uint32_t GWEN_TLV_List_GetCount(const GWEN_TLV_LIST *l);
05959
05960 #ifdef __cplusplus
05961 }
05962 #endif
05963
05964
05965 #endif
05966
05967
05968
05969
05970
05971
05972
05973
05974
05975
05976
05977
05978
05979
05980
05981
05982
05983
05984
05985
05986
05987
05988
05989
05990
05991
05992
05993
05994
05995
05996
05997 #ifndef GWEN_URL_LIST2_H
05998 #define GWEN_URL_LIST2_H
05999
06000
06001 #ifdef __cplusplus
06002 extern "C" {
06003 #endif
06004
06011 typedef struct GWEN_URL_LIST2 GWEN_URL_LIST2;
06012
06016 typedef struct GWEN_URL_LIST2_ITERATOR GWEN_URL_LIST2_ITERATOR;
06017
06021 typedef GWEN_URL* (GWEN_URL_LIST2_FOREACH)(GWEN_URL *element,
06022 void *user_data);
06023
06027 GWEN_URL_LIST2 *GWEN_Url_List2_new();
06028
06032 void GWEN_Url_List2_free(GWEN_URL_LIST2 *l);
06033
06037 void GWEN_Url_List2_Dump(GWEN_URL_LIST2 *l, FILE *f, unsigned int indent);
06038
06042 void GWEN_Url_List2_PushBack(GWEN_URL_LIST2 *l, GWEN_URL *p);
06043
06048 void GWEN_Url_List2_PushFront(GWEN_URL_LIST2 *l, GWEN_URL *p);
06049
06054 GWEN_URL *GWEN_Url_List2_GetFront(GWEN_URL_LIST2 *l);
06055
06060 GWEN_URL *GWEN_Url_List2_GetBack(GWEN_URL_LIST2 *l);
06061
06066 void GWEN_Url_List2_Erase(GWEN_URL_LIST2 *l,
06067 GWEN_URL_LIST2_ITERATOR *it);
06068
06074 unsigned int GWEN_Url_List2_GetSize(GWEN_URL_LIST2 *l);
06075
06080 void GWEN_Url_List2_PopBack(GWEN_URL_LIST2 *l);
06081
06086 void GWEN_Url_List2_PopFront(GWEN_URL_LIST2 *l);
06087
06091 void GWEN_Url_List2_Clear(GWEN_URL_LIST2 *l);
06092
06096 GWEN_URL_LIST2_ITERATOR *GWEN_Url_List2_First(GWEN_URL_LIST2 *l);
06097
06101 GWEN_URL_LIST2_ITERATOR *GWEN_Url_List2_Last(GWEN_URL_LIST2 *l);
06102
06106 GWEN_URL_LIST2_ITERATOR *GWEN_Url_List2Iterator_new(GWEN_URL_LIST2 *l);
06107
06111 void GWEN_Url_List2Iterator_free(GWEN_URL_LIST2_ITERATOR *li);
06112
06117 GWEN_URL *GWEN_Url_List2Iterator_Previous(GWEN_URL_LIST2_ITERATOR *li);
06118
06123 GWEN_URL *GWEN_Url_List2Iterator_Next(GWEN_URL_LIST2_ITERATOR *li);
06124
06129 GWEN_URL *GWEN_Url_List2Iterator_Data(GWEN_URL_LIST2_ITERATOR *li);
06130
06142 GWEN_URL *GWEN_Url_List2_ForEach(GWEN_URL_LIST2 *list,
06143 GWEN_URL_LIST2_FOREACH func,
06144 void *user_data);
06145
06146
06147 typedef struct GWEN_URL_CONSTLIST2 GWEN_URL_CONSTLIST2;
06148 typedef struct GWEN_URL_CONSTLIST2_ITERATOR GWEN_URL_CONSTLIST2_ITERATOR;
06149 typedef const GWEN_URL*
06150 (GWEN_URL_CONSTLIST2_FOREACH)(const GWEN_URL *element,
06151 void *user_data);
06152
06153
06154 GWEN_URL_CONSTLIST2 *GWEN_Url_ConstList2_new();
06155
06156 void GWEN_Url_ConstList2_free(GWEN_URL_CONSTLIST2 *l);
06157
06158 void GWEN_Url_ConstList2_PushBack(GWEN_URL_CONSTLIST2 *l, const GWEN_URL *p);
06159
06160 void GWEN_Url_ConstList2_PushFront(GWEN_URL_CONSTLIST2 *l, const GWEN_URL *p);
06161
06162 const GWEN_URL *GWEN_Url_ConstList2_GetFront(GWEN_URL_CONSTLIST2 *l);
06163
06164 const GWEN_URL *GWEN_Url_ConstList2_GetBack(GWEN_URL_CONSTLIST2 *l);
06165
06166 unsigned int GWEN_Url_ConstList2_GetSize(GWEN_URL_CONSTLIST2 *l);
06167
06168 void GWEN_Url_ConstList2_PopBack(GWEN_URL_CONSTLIST2 *l);
06169
06170 void GWEN_Url_ConstList2_PopFront(GWEN_URL_CONSTLIST2 *l);
06171
06172 void GWEN_Url_ConstList2_Clear(GWEN_URL_CONSTLIST2 *l);
06173
06174 GWEN_URL_CONSTLIST2_ITERATOR *GWEN_Url_ConstList2_First(GWEN_URL_CONSTLIST2 *l);
06175
06176 GWEN_URL_CONSTLIST2_ITERATOR *GWEN_Url_ConstList2_Last(GWEN_URL_CONSTLIST2 *l);
06177
06178 GWEN_URL_CONSTLIST2_ITERATOR *GWEN_Url_ConstList2Iterator_new(GWEN_URL_CONSTLIST2 *l);
06179
06180 void GWEN_Url_ConstList2Iterator_free(GWEN_URL_CONSTLIST2_ITERATOR *li);
06181
06182 const GWEN_URL *GWEN_Url_ConstList2Iterator_Previous(GWEN_URL_CONSTLIST2_ITERATOR *li);
06183
06184 const GWEN_URL *GWEN_Url_ConstList2Iterator_Next(GWEN_URL_CONSTLIST2_ITERATOR *li);
06185
06186 const GWEN_URL *GWEN_Url_ConstList2Iterator_Data(GWEN_URL_CONSTLIST2_ITERATOR *li);
06187
06199 const GWEN_URL *GWEN_Url_ConstList2_ForEach(GWEN_URL_CONSTLIST2 *list,
06200 GWEN_URL_CONSTLIST2_FOREACH func, void *user_data);
06201
06202
06203 #ifdef __cplusplus
06204 }
06205 #endif
06206
06207
06208 #endif
06209
06210
06211
06212
06213
06214
06215
06216
06217
06218
06219
06220
06221
06222
06223
06224
06225
06226
06227
06228
06229
06230
06231
06232
06233
06234
06235
06236
06237
06238
06239
06240 #ifndef GWEN_URL_LIST1_H
06241 #define GWEN_URL_LIST1_H
06242
06243 #ifdef __cplusplus
06244 extern "C" {
06245 #endif
06246
06248 typedef struct GWEN_URL_LIST_ELEMENT {
06249 uint32_t id;
06250 GWEN_URL *nextObject;
06251 } GWEN_URL_LIST__ELEMENT;
06252
06259 typedef struct GWEN_URL_LIST GWEN_URL_LIST;
06261 struct GWEN_URL_LIST {
06262 GWEN_URL *first;
06263 uint32_t count;
06264 uint32_t id;
06265 } GWEN_URL_LIST;
06266
06271 void GWEN_Url_List_AddList(GWEN_URL_LIST *dst, GWEN_URL_LIST *l);
06272
06276 void GWEN_Url_List_Add(GWEN_URL *element, GWEN_URL_LIST *list);
06277
06282 void GWEN_Url_List_Insert(GWEN_URL *element, GWEN_URL_LIST *list);
06283
06290 void GWEN_Url_List_Del(GWEN_URL *element);
06291
06295 GWEN_URL* GWEN_Url_List_First(const GWEN_URL_LIST *l);
06296
06300 GWEN_URL* GWEN_Url_List_Last(const GWEN_URL_LIST *l);
06301
06306 void GWEN_Url_List_Clear(GWEN_URL_LIST *l);
06307
06311 GWEN_URL_LIST* GWEN_Url_List_new();
06312
06316 void GWEN_Url_List_free(GWEN_URL_LIST *l);
06317
06321 GWEN_URL* GWEN_Url_List_Next(const GWEN_URL *element);
06322
06326 GWEN_URL* GWEN_Url_List_Previous(const GWEN_URL *element);
06327
06331 uint32_t GWEN_Url_List_GetCount(const GWEN_URL_LIST *l);
06332
06333 #ifdef __cplusplus
06334 }
06335 #endif
06336
06337
06338 #endif
06339
06340
06341
06342
06343
06344
06345
06346
06347
06348
06349
06350
06351
06352
06353
06354
06355
06356
06357
06358
06359
06360
06361
06362
06363
06364
06365
06366
06367
06368
06369
06370 #ifndef GWEN_XMLNODE_NAMESPACE_LIST1_H
06371 #define GWEN_XMLNODE_NAMESPACE_LIST1_H
06372
06373 #ifdef __cplusplus
06374 extern "C" {
06375 #endif
06376
06378 typedef struct GWEN_XMLNODE_NAMESPACE_LIST_ELEMENT {
06379 uint32_t id;
06380 GWEN_XMLNODE_NAMESPACE *nextObject;
06381 } GWEN_XMLNODE_NAMESPACE_LIST__ELEMENT;
06382
06389 typedef struct GWEN_XMLNODE_NAMESPACE_LIST GWEN_XMLNODE_NAMESPACE_LIST;
06391 struct GWEN_XMLNODE_NAMESPACE_LIST {
06392 GWEN_XMLNODE_NAMESPACE *first;
06393 uint32_t count;
06394 uint32_t id;
06395 } GWEN_XMLNODE_NAMESPACE_LIST;
06396
06401 void GWEN_XMLNode_NameSpace_List_AddList(GWEN_XMLNODE_NAMESPACE_LIST *dst, GWEN_XMLNODE_NAMESPACE_LIST *l);
06402
06406 void GWEN_XMLNode_NameSpace_List_Add(GWEN_XMLNODE_NAMESPACE *element, GWEN_XMLNODE_NAMESPACE_LIST *list);
06407
06412 void GWEN_XMLNode_NameSpace_List_Insert(GWEN_XMLNODE_NAMESPACE *element, GWEN_XMLNODE_NAMESPACE_LIST *list);
06413
06420 void GWEN_XMLNode_NameSpace_List_Del(GWEN_XMLNODE_NAMESPACE *element);
06421
06425 GWEN_XMLNODE_NAMESPACE* GWEN_XMLNode_NameSpace_List_First(const GWEN_XMLNODE_NAMESPACE_LIST *l);
06426
06430 GWEN_XMLNODE_NAMESPACE* GWEN_XMLNode_NameSpace_List_Last(const GWEN_XMLNODE_NAMESPACE_LIST *l);
06431
06436 void GWEN_XMLNode_NameSpace_List_Clear(GWEN_XMLNODE_NAMESPACE_LIST *l);
06437
06441 GWEN_XMLNODE_NAMESPACE_LIST* GWEN_XMLNode_NameSpace_List_new();
06442
06446 void GWEN_XMLNode_NameSpace_List_free(GWEN_XMLNODE_NAMESPACE_LIST *l);
06447
06451 GWEN_XMLNODE_NAMESPACE* GWEN_XMLNode_NameSpace_List_Next(const GWEN_XMLNODE_NAMESPACE *element);
06452
06456 GWEN_XMLNODE_NAMESPACE* GWEN_XMLNode_NameSpace_List_Previous(const GWEN_XMLNODE_NAMESPACE *element);
06457
06461 uint32_t GWEN_XMLNode_NameSpace_List_GetCount(const GWEN_XMLNODE_NAMESPACE_LIST *l);
06462
06463 #ifdef __cplusplus
06464 }
06465 #endif
06466
06467
06468 #endif
06469
06470
06471
06472
06473
06474
06475
06476
06477
06478
06479
06480
06481
06482
06483
06484
06485
06486
06487
06488
06489
06490
06491
06492
06493
06494
06495
06496
06497
06498
06499
06500 #ifndef GWEN_XMLNODE_LIST2_H
06501 #define GWEN_XMLNODE_LIST2_H
06502
06503
06504 #ifdef __cplusplus
06505 extern "C" {
06506 #endif
06507
06514 typedef struct GWEN_XMLNODE_LIST2 GWEN_XMLNODE_LIST2;
06515
06519 typedef struct GWEN_XMLNODE_LIST2_ITERATOR GWEN_XMLNODE_LIST2_ITERATOR;
06520
06524 typedef GWEN_XMLNODE* (GWEN_XMLNODE_LIST2_FOREACH)(GWEN_XMLNODE *element,
06525 void *user_data);
06526
06530 GWEN_XMLNODE_LIST2 *GWEN_XMLNode_List2_new();
06531
06535 void GWEN_XMLNode_List2_free(GWEN_XMLNODE_LIST2 *l);
06536
06540 void GWEN_XMLNode_List2_Dump(GWEN_XMLNODE_LIST2 *l, FILE *f, unsigned int indent);
06541
06545 void GWEN_XMLNode_List2_PushBack(GWEN_XMLNODE_LIST2 *l, GWEN_XMLNODE *p);
06546
06551 void GWEN_XMLNode_List2_PushFront(GWEN_XMLNODE_LIST2 *l, GWEN_XMLNODE *p);
06552
06557 GWEN_XMLNODE *GWEN_XMLNode_List2_GetFront(GWEN_XMLNODE_LIST2 *l);
06558
06563 GWEN_XMLNODE *GWEN_XMLNode_List2_GetBack(GWEN_XMLNODE_LIST2 *l);
06564
06569 void GWEN_XMLNode_List2_Erase(GWEN_XMLNODE_LIST2 *l,
06570 GWEN_XMLNODE_LIST2_ITERATOR *it);
06571
06577 unsigned int GWEN_XMLNode_List2_GetSize(GWEN_XMLNODE_LIST2 *l);
06578
06583 void GWEN_XMLNode_List2_PopBack(GWEN_XMLNODE_LIST2 *l);
06584
06589 void GWEN_XMLNode_List2_PopFront(GWEN_XMLNODE_LIST2 *l);
06590
06594 void GWEN_XMLNode_List2_Clear(GWEN_XMLNODE_LIST2 *l);
06595
06599 GWEN_XMLNODE_LIST2_ITERATOR *GWEN_XMLNode_List2_First(GWEN_XMLNODE_LIST2 *l);
06600
06604 GWEN_XMLNODE_LIST2_ITERATOR *GWEN_XMLNode_List2_Last(GWEN_XMLNODE_LIST2 *l);
06605
06609 GWEN_XMLNODE_LIST2_ITERATOR *GWEN_XMLNode_List2Iterator_new(GWEN_XMLNODE_LIST2 *l);
06610
06614 void GWEN_XMLNode_List2Iterator_free(GWEN_XMLNODE_LIST2_ITERATOR *li);
06615
06620 GWEN_XMLNODE *GWEN_XMLNode_List2Iterator_Previous(GWEN_XMLNODE_LIST2_ITERATOR *li);
06621
06626 GWEN_XMLNODE *GWEN_XMLNode_List2Iterator_Next(GWEN_XMLNODE_LIST2_ITERATOR *li);
06627
06632 GWEN_XMLNODE *GWEN_XMLNode_List2Iterator_Data(GWEN_XMLNODE_LIST2_ITERATOR *li);
06633
06645 GWEN_XMLNODE *GWEN_XMLNode_List2_ForEach(GWEN_XMLNODE_LIST2 *list,
06646 GWEN_XMLNODE_LIST2_FOREACH func,
06647 void *user_data);
06648
06649
06650 typedef struct GWEN_XMLNODE_CONSTLIST2 GWEN_XMLNODE_CONSTLIST2;
06651 typedef struct GWEN_XMLNODE_CONSTLIST2_ITERATOR GWEN_XMLNODE_CONSTLIST2_ITERATOR;
06652 typedef const GWEN_XMLNODE*
06653 (GWEN_XMLNODE_CONSTLIST2_FOREACH)(const GWEN_XMLNODE *element,
06654 void *user_data);
06655
06656
06657 GWEN_XMLNODE_CONSTLIST2 *GWEN_XMLNode_ConstList2_new();
06658
06659 void GWEN_XMLNode_ConstList2_free(GWEN_XMLNODE_CONSTLIST2 *l);
06660
06661 void GWEN_XMLNode_ConstList2_PushBack(GWEN_XMLNODE_CONSTLIST2 *l, const GWEN_XMLNODE *p);
06662
06663 void GWEN_XMLNode_ConstList2_PushFront(GWEN_XMLNODE_CONSTLIST2 *l, const GWEN_XMLNODE *p);
06664
06665 const GWEN_XMLNODE *GWEN_XMLNode_ConstList2_GetFront(GWEN_XMLNODE_CONSTLIST2 *l);
06666
06667 const GWEN_XMLNODE *GWEN_XMLNode_ConstList2_GetBack(GWEN_XMLNODE_CONSTLIST2 *l);
06668
06669 unsigned int GWEN_XMLNode_ConstList2_GetSize(GWEN_XMLNODE_CONSTLIST2 *l);
06670
06671 void GWEN_XMLNode_ConstList2_PopBack(GWEN_XMLNODE_CONSTLIST2 *l);
06672
06673 void GWEN_XMLNode_ConstList2_PopFront(GWEN_XMLNODE_CONSTLIST2 *l);
06674
06675 void GWEN_XMLNode_ConstList2_Clear(GWEN_XMLNODE_CONSTLIST2 *l);
06676
06677 GWEN_XMLNODE_CONSTLIST2_ITERATOR *GWEN_XMLNode_ConstList2_First(GWEN_XMLNODE_CONSTLIST2 *l);
06678
06679 GWEN_XMLNODE_CONSTLIST2_ITERATOR *GWEN_XMLNode_ConstList2_Last(GWEN_XMLNODE_CONSTLIST2 *l);
06680
06681 GWEN_XMLNODE_CONSTLIST2_ITERATOR *GWEN_XMLNode_ConstList2Iterator_new(GWEN_XMLNODE_CONSTLIST2 *l);
06682
06683 void GWEN_XMLNode_ConstList2Iterator_free(GWEN_XMLNODE_CONSTLIST2_ITERATOR *li);
06684
06685 const GWEN_XMLNODE *GWEN_XMLNode_ConstList2Iterator_Previous(GWEN_XMLNODE_CONSTLIST2_ITERATOR *li);
06686
06687 const GWEN_XMLNODE *GWEN_XMLNode_ConstList2Iterator_Next(GWEN_XMLNODE_CONSTLIST2_ITERATOR *li);
06688
06689 const GWEN_XMLNODE *GWEN_XMLNode_ConstList2Iterator_Data(GWEN_XMLNODE_CONSTLIST2_ITERATOR *li);
06690
06702 const GWEN_XMLNODE *GWEN_XMLNode_ConstList2_ForEach(GWEN_XMLNODE_CONSTLIST2 *list,
06703 GWEN_XMLNODE_CONSTLIST2_FOREACH func, void *user_data);
06704
06705
06706 #ifdef __cplusplus
06707 }
06708 #endif
06709
06710
06711 #endif
06712
06713
06714
06715
06716
06717
06718
06719
06720
06721
06722
06723
06724
06725
06726
06727
06728
06729
06730
06731
06732
06733
06734
06735
06736
06737
06738
06739
06740
06741
06742
06743 #ifndef GWEN_XMLNODE_LIST1_H
06744 #define GWEN_XMLNODE_LIST1_H
06745
06746 #ifdef __cplusplus
06747 extern "C" {
06748 #endif
06749
06751 typedef struct GWEN_XMLNODE_LIST_ELEMENT {
06752 uint32_t id;
06753 GWEN_XMLNODE *nextObject;
06754 } GWEN_XMLNODE_LIST__ELEMENT;
06755
06762 typedef struct GWEN_XMLNODE_LIST GWEN_XMLNODE_LIST;
06764 struct GWEN_XMLNODE_LIST {
06765 GWEN_XMLNODE *first;
06766 uint32_t count;
06767 uint32_t id;
06768 } GWEN_XMLNODE_LIST;
06769
06774 void GWEN_XMLNode_List_AddList(GWEN_XMLNODE_LIST *dst, GWEN_XMLNODE_LIST *l);
06775
06779 void GWEN_XMLNode_List_Add(GWEN_XMLNODE *element, GWEN_XMLNODE_LIST *list);
06780
06785 void GWEN_XMLNode_List_Insert(GWEN_XMLNODE *element, GWEN_XMLNODE_LIST *list);
06786
06793 void GWEN_XMLNode_List_Del(GWEN_XMLNODE *element);
06794
06798 GWEN_XMLNODE* GWEN_XMLNode_List_First(const GWEN_XMLNODE_LIST *l);
06799
06803 GWEN_XMLNODE* GWEN_XMLNode_List_Last(const GWEN_XMLNODE_LIST *l);
06804
06809 void GWEN_XMLNode_List_Clear(GWEN_XMLNODE_LIST *l);
06810
06814 GWEN_XMLNODE_LIST* GWEN_XMLNode_List_new();
06815
06819 void GWEN_XMLNode_List_free(GWEN_XMLNODE_LIST *l);
06820
06824 GWEN_XMLNODE* GWEN_XMLNode_List_Next(const GWEN_XMLNODE *element);
06825
06829 GWEN_XMLNODE* GWEN_XMLNode_List_Previous(const GWEN_XMLNODE *element);
06830
06834 uint32_t GWEN_XMLNode_List_GetCount(const GWEN_XMLNODE_LIST *l);
06835
06836 #ifdef __cplusplus
06837 }
06838 #endif
06839
06840
06841 #endif
06842
06843
06844
06845
06846
06847
06848
06849
06850
06851
06852
06853
06854
06855
06856
06857
06858
06859
06860
06861
06862
06863
06864
06865
06866
06867
06868
06869
06870
06871
06872
06873 #ifndef GWEN_XSD_NODE_LIST1_H
06874 #define GWEN_XSD_NODE_LIST1_H
06875
06876 #ifdef __cplusplus
06877 extern "C" {
06878 #endif
06879
06881 typedef struct GWEN_XSD_NODE_LIST_ELEMENT {
06882 uint32_t id;
06883 GWEN_XSD_NODE *nextObject;
06884 } GWEN_XSD_NODE_LIST__ELEMENT;
06885
06892 typedef struct GWEN_XSD_NODE_LIST GWEN_XSD_NODE_LIST;
06894 struct GWEN_XSD_NODE_LIST {
06895 GWEN_XSD_NODE *first;
06896 uint32_t count;
06897 uint32_t id;
06898 } GWEN_XSD_NODE_LIST;
06899
06904 void GWEN_XsdNode_List_AddList(GWEN_XSD_NODE_LIST *dst, GWEN_XSD_NODE_LIST *l);
06905
06909 void GWEN_XsdNode_List_Add(GWEN_XSD_NODE *element, GWEN_XSD_NODE_LIST *list);
06910
06915 void GWEN_XsdNode_List_Insert(GWEN_XSD_NODE *element, GWEN_XSD_NODE_LIST *list);
06916
06923 void GWEN_XsdNode_List_Del(GWEN_XSD_NODE *element);
06924
06928 GWEN_XSD_NODE* GWEN_XsdNode_List_First(const GWEN_XSD_NODE_LIST *l);
06929
06933 GWEN_XSD_NODE* GWEN_XsdNode_List_Last(const GWEN_XSD_NODE_LIST *l);
06934
06939 void GWEN_XsdNode_List_Clear(GWEN_XSD_NODE_LIST *l);
06940
06944 GWEN_XSD_NODE_LIST* GWEN_XsdNode_List_new();
06945
06949 void GWEN_XsdNode_List_free(GWEN_XSD_NODE_LIST *l);
06950
06954 GWEN_XSD_NODE* GWEN_XsdNode_List_Next(const GWEN_XSD_NODE *element);
06955
06959 GWEN_XSD_NODE* GWEN_XsdNode_List_Previous(const GWEN_XSD_NODE *element);
06960
06964 uint32_t GWEN_XsdNode_List_GetCount(const GWEN_XSD_NODE_LIST *l);
06965
06966 #ifdef __cplusplus
06967 }
06968 #endif
06969
06970
06971 #endif
06972
06973
06974