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_CRYPTHEAD_LIST1_H
02754 #define GWEN_CRYPTHEAD_LIST1_H
02755
02756 #ifdef __cplusplus
02757 extern "C" {
02758 #endif
02759
02761 typedef struct GWEN_CRYPTHEAD_LIST_ELEMENT {
02762 uint32_t id;
02763 GWEN_CRYPTHEAD *nextObject;
02764 } GWEN_CRYPTHEAD_LIST__ELEMENT;
02765
02772 typedef struct GWEN_CRYPTHEAD_LIST GWEN_CRYPTHEAD_LIST;
02774 struct GWEN_CRYPTHEAD_LIST {
02775 GWEN_CRYPTHEAD *first;
02776 uint32_t count;
02777 uint32_t id;
02778 } GWEN_CRYPTHEAD_LIST;
02779
02784 void GWEN_CryptHead_List_AddList(GWEN_CRYPTHEAD_LIST *dst, GWEN_CRYPTHEAD_LIST *l);
02785
02789 void GWEN_CryptHead_List_Add(GWEN_CRYPTHEAD *element, GWEN_CRYPTHEAD_LIST *list);
02790
02795 void GWEN_CryptHead_List_Insert(GWEN_CRYPTHEAD *element, GWEN_CRYPTHEAD_LIST *list);
02796
02803 void GWEN_CryptHead_List_Del(GWEN_CRYPTHEAD *element);
02804
02808 GWEN_CRYPTHEAD* GWEN_CryptHead_List_First(const GWEN_CRYPTHEAD_LIST *l);
02809
02813 GWEN_CRYPTHEAD* GWEN_CryptHead_List_Last(const GWEN_CRYPTHEAD_LIST *l);
02814
02819 void GWEN_CryptHead_List_Clear(GWEN_CRYPTHEAD_LIST *l);
02820
02824 GWEN_CRYPTHEAD_LIST* GWEN_CryptHead_List_new();
02825
02829 void GWEN_CryptHead_List_free(GWEN_CRYPTHEAD_LIST *l);
02830
02834 GWEN_CRYPTHEAD* GWEN_CryptHead_List_Next(const GWEN_CRYPTHEAD *element);
02835
02839 GWEN_CRYPTHEAD* GWEN_CryptHead_List_Previous(const GWEN_CRYPTHEAD *element);
02840
02844 uint32_t GWEN_CryptHead_List_GetCount(const GWEN_CRYPTHEAD_LIST *l);
02845
02846 #ifdef __cplusplus
02847 }
02848 #endif
02849
02850
02851 #endif
02852
02853
02854
02855
02856
02857
02858
02859
02860
02861
02862
02863
02864
02865
02866
02867
02868
02869
02870
02871
02872
02873
02874
02875
02876
02877
02878
02879
02880
02881
02882
02883 #ifndef GWEN_SIGHEAD_LIST1_H
02884 #define GWEN_SIGHEAD_LIST1_H
02885
02886 #ifdef __cplusplus
02887 extern "C" {
02888 #endif
02889
02891 typedef struct GWEN_SIGHEAD_LIST_ELEMENT {
02892 uint32_t id;
02893 GWEN_SIGHEAD *nextObject;
02894 } GWEN_SIGHEAD_LIST__ELEMENT;
02895
02902 typedef struct GWEN_SIGHEAD_LIST GWEN_SIGHEAD_LIST;
02904 struct GWEN_SIGHEAD_LIST {
02905 GWEN_SIGHEAD *first;
02906 uint32_t count;
02907 uint32_t id;
02908 } GWEN_SIGHEAD_LIST;
02909
02914 void GWEN_SigHead_List_AddList(GWEN_SIGHEAD_LIST *dst, GWEN_SIGHEAD_LIST *l);
02915
02919 void GWEN_SigHead_List_Add(GWEN_SIGHEAD *element, GWEN_SIGHEAD_LIST *list);
02920
02925 void GWEN_SigHead_List_Insert(GWEN_SIGHEAD *element, GWEN_SIGHEAD_LIST *list);
02926
02933 void GWEN_SigHead_List_Del(GWEN_SIGHEAD *element);
02934
02938 GWEN_SIGHEAD* GWEN_SigHead_List_First(const GWEN_SIGHEAD_LIST *l);
02939
02943 GWEN_SIGHEAD* GWEN_SigHead_List_Last(const GWEN_SIGHEAD_LIST *l);
02944
02949 void GWEN_SigHead_List_Clear(GWEN_SIGHEAD_LIST *l);
02950
02954 GWEN_SIGHEAD_LIST* GWEN_SigHead_List_new();
02955
02959 void GWEN_SigHead_List_free(GWEN_SIGHEAD_LIST *l);
02960
02964 GWEN_SIGHEAD* GWEN_SigHead_List_Next(const GWEN_SIGHEAD *element);
02965
02969 GWEN_SIGHEAD* GWEN_SigHead_List_Previous(const GWEN_SIGHEAD *element);
02970
02974 uint32_t GWEN_SigHead_List_GetCount(const GWEN_SIGHEAD_LIST *l);
02975
02976 #ifdef __cplusplus
02977 }
02978 #endif
02979
02980
02981 #endif
02982
02983
02984
02985
02986
02987
02988
02989
02990
02991
02992
02993
02994
02995
02996
02997
02998
02999
03000
03001
03002
03003
03004
03005
03006
03007
03008
03009
03010
03011
03012
03013 #ifndef GWEN_SIGTAIL_LIST1_H
03014 #define GWEN_SIGTAIL_LIST1_H
03015
03016 #ifdef __cplusplus
03017 extern "C" {
03018 #endif
03019
03021 typedef struct GWEN_SIGTAIL_LIST_ELEMENT {
03022 uint32_t id;
03023 GWEN_SIGTAIL *nextObject;
03024 } GWEN_SIGTAIL_LIST__ELEMENT;
03025
03032 typedef struct GWEN_SIGTAIL_LIST GWEN_SIGTAIL_LIST;
03034 struct GWEN_SIGTAIL_LIST {
03035 GWEN_SIGTAIL *first;
03036 uint32_t count;
03037 uint32_t id;
03038 } GWEN_SIGTAIL_LIST;
03039
03044 void GWEN_SigTail_List_AddList(GWEN_SIGTAIL_LIST *dst, GWEN_SIGTAIL_LIST *l);
03045
03049 void GWEN_SigTail_List_Add(GWEN_SIGTAIL *element, GWEN_SIGTAIL_LIST *list);
03050
03055 void GWEN_SigTail_List_Insert(GWEN_SIGTAIL *element, GWEN_SIGTAIL_LIST *list);
03056
03063 void GWEN_SigTail_List_Del(GWEN_SIGTAIL *element);
03064
03068 GWEN_SIGTAIL* GWEN_SigTail_List_First(const GWEN_SIGTAIL_LIST *l);
03069
03073 GWEN_SIGTAIL* GWEN_SigTail_List_Last(const GWEN_SIGTAIL_LIST *l);
03074
03079 void GWEN_SigTail_List_Clear(GWEN_SIGTAIL_LIST *l);
03080
03084 GWEN_SIGTAIL_LIST* GWEN_SigTail_List_new();
03085
03089 void GWEN_SigTail_List_free(GWEN_SIGTAIL_LIST *l);
03090
03094 GWEN_SIGTAIL* GWEN_SigTail_List_Next(const GWEN_SIGTAIL *element);
03095
03099 GWEN_SIGTAIL* GWEN_SigTail_List_Previous(const GWEN_SIGTAIL *element);
03100
03104 uint32_t GWEN_SigTail_List_GetCount(const GWEN_SIGTAIL_LIST *l);
03105
03106 #ifdef __cplusplus
03107 }
03108 #endif
03109
03110
03111 #endif
03112
03113
03114
03115
03116
03117
03118
03119
03120
03121
03122
03123
03124
03125
03126
03127
03128
03129
03130
03131
03132
03133
03134
03135
03136
03137
03138
03139
03140
03141
03142
03143 #ifndef GWEN_CRYPT_TOKEN_LIST2_H
03144 #define GWEN_CRYPT_TOKEN_LIST2_H
03145
03146
03147 #ifdef __cplusplus
03148 extern "C" {
03149 #endif
03150
03157 typedef struct GWEN_CRYPT_TOKEN_LIST2 GWEN_CRYPT_TOKEN_LIST2;
03158
03162 typedef struct GWEN_CRYPT_TOKEN_LIST2_ITERATOR GWEN_CRYPT_TOKEN_LIST2_ITERATOR;
03163
03167 typedef GWEN_CRYPT_TOKEN* (GWEN_CRYPT_TOKEN_LIST2_FOREACH)(GWEN_CRYPT_TOKEN *element,
03168 void *user_data);
03169
03173 GWEN_CRYPT_TOKEN_LIST2 *GWEN_Crypt_Token_List2_new();
03174
03178 void GWEN_Crypt_Token_List2_free(GWEN_CRYPT_TOKEN_LIST2 *l);
03179
03183 void GWEN_Crypt_Token_List2_Dump(GWEN_CRYPT_TOKEN_LIST2 *l, FILE *f, unsigned int indent);
03184
03188 void GWEN_Crypt_Token_List2_PushBack(GWEN_CRYPT_TOKEN_LIST2 *l, GWEN_CRYPT_TOKEN *p);
03189
03194 void GWEN_Crypt_Token_List2_PushFront(GWEN_CRYPT_TOKEN_LIST2 *l, GWEN_CRYPT_TOKEN *p);
03195
03200 GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_List2_GetFront(GWEN_CRYPT_TOKEN_LIST2 *l);
03201
03206 GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_List2_GetBack(GWEN_CRYPT_TOKEN_LIST2 *l);
03207
03212 void GWEN_Crypt_Token_List2_Erase(GWEN_CRYPT_TOKEN_LIST2 *l,
03213 GWEN_CRYPT_TOKEN_LIST2_ITERATOR *it);
03214
03220 unsigned int GWEN_Crypt_Token_List2_GetSize(GWEN_CRYPT_TOKEN_LIST2 *l);
03221
03226 void GWEN_Crypt_Token_List2_PopBack(GWEN_CRYPT_TOKEN_LIST2 *l);
03227
03232 void GWEN_Crypt_Token_List2_PopFront(GWEN_CRYPT_TOKEN_LIST2 *l);
03233
03237 void GWEN_Crypt_Token_List2_Clear(GWEN_CRYPT_TOKEN_LIST2 *l);
03238
03242 GWEN_CRYPT_TOKEN_LIST2_ITERATOR *GWEN_Crypt_Token_List2_First(GWEN_CRYPT_TOKEN_LIST2 *l);
03243
03247 GWEN_CRYPT_TOKEN_LIST2_ITERATOR *GWEN_Crypt_Token_List2_Last(GWEN_CRYPT_TOKEN_LIST2 *l);
03248
03252 GWEN_CRYPT_TOKEN_LIST2_ITERATOR *GWEN_Crypt_Token_List2Iterator_new(GWEN_CRYPT_TOKEN_LIST2 *l);
03253
03257 void GWEN_Crypt_Token_List2Iterator_free(GWEN_CRYPT_TOKEN_LIST2_ITERATOR *li);
03258
03263 GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_List2Iterator_Previous(GWEN_CRYPT_TOKEN_LIST2_ITERATOR *li);
03264
03269 GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_List2Iterator_Next(GWEN_CRYPT_TOKEN_LIST2_ITERATOR *li);
03270
03275 GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_List2Iterator_Data(GWEN_CRYPT_TOKEN_LIST2_ITERATOR *li);
03276
03288 GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_List2_ForEach(GWEN_CRYPT_TOKEN_LIST2 *list,
03289 GWEN_CRYPT_TOKEN_LIST2_FOREACH func,
03290 void *user_data);
03291
03292
03293 typedef struct GWEN_CRYPT_TOKEN_CONSTLIST2 GWEN_CRYPT_TOKEN_CONSTLIST2;
03294 typedef struct GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR;
03295 typedef const GWEN_CRYPT_TOKEN*
03296 (GWEN_CRYPT_TOKEN_CONSTLIST2_FOREACH)(const GWEN_CRYPT_TOKEN *element,
03297 void *user_data);
03298
03299
03300 GWEN_CRYPT_TOKEN_CONSTLIST2 *GWEN_Crypt_Token_ConstList2_new();
03301
03302 void GWEN_Crypt_Token_ConstList2_free(GWEN_CRYPT_TOKEN_CONSTLIST2 *l);
03303
03304 void GWEN_Crypt_Token_ConstList2_PushBack(GWEN_CRYPT_TOKEN_CONSTLIST2 *l, const GWEN_CRYPT_TOKEN *p);
03305
03306 void GWEN_Crypt_Token_ConstList2_PushFront(GWEN_CRYPT_TOKEN_CONSTLIST2 *l, const GWEN_CRYPT_TOKEN *p);
03307
03308 const GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_ConstList2_GetFront(GWEN_CRYPT_TOKEN_CONSTLIST2 *l);
03309
03310 const GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_ConstList2_GetBack(GWEN_CRYPT_TOKEN_CONSTLIST2 *l);
03311
03312 unsigned int GWEN_Crypt_Token_ConstList2_GetSize(GWEN_CRYPT_TOKEN_CONSTLIST2 *l);
03313
03314 void GWEN_Crypt_Token_ConstList2_PopBack(GWEN_CRYPT_TOKEN_CONSTLIST2 *l);
03315
03316 void GWEN_Crypt_Token_ConstList2_PopFront(GWEN_CRYPT_TOKEN_CONSTLIST2 *l);
03317
03318 void GWEN_Crypt_Token_ConstList2_Clear(GWEN_CRYPT_TOKEN_CONSTLIST2 *l);
03319
03320 GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_ConstList2_First(GWEN_CRYPT_TOKEN_CONSTLIST2 *l);
03321
03322 GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_ConstList2_Last(GWEN_CRYPT_TOKEN_CONSTLIST2 *l);
03323
03324 GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_ConstList2Iterator_new(GWEN_CRYPT_TOKEN_CONSTLIST2 *l);
03325
03326 void GWEN_Crypt_Token_ConstList2Iterator_free(GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *li);
03327
03328 const GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_ConstList2Iterator_Previous(GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *li);
03329
03330 const GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_ConstList2Iterator_Next(GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *li);
03331
03332 const GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_ConstList2Iterator_Data(GWEN_CRYPT_TOKEN_CONSTLIST2_ITERATOR *li);
03333
03345 const GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_ConstList2_ForEach(GWEN_CRYPT_TOKEN_CONSTLIST2 *list,
03346 GWEN_CRYPT_TOKEN_CONSTLIST2_FOREACH func, void *user_data);
03347
03348
03349 #ifdef __cplusplus
03350 }
03351 #endif
03352
03353
03354 #endif
03355
03356
03357
03358
03359
03360
03361
03362
03363
03364
03365
03366
03367
03368
03369
03370
03371
03372
03373
03374
03375
03376
03377
03378
03379
03380
03381
03382
03383
03384
03385
03386 #ifndef GWEN_CRYPT_TOKEN_LIST1_H
03387 #define GWEN_CRYPT_TOKEN_LIST1_H
03388
03389 #ifdef __cplusplus
03390 extern "C" {
03391 #endif
03392
03394 typedef struct GWEN_CRYPT_TOKEN_LIST_ELEMENT {
03395 uint32_t id;
03396 GWEN_CRYPT_TOKEN *nextObject;
03397 } GWEN_CRYPT_TOKEN_LIST__ELEMENT;
03398
03405 typedef struct GWEN_CRYPT_TOKEN_LIST GWEN_CRYPT_TOKEN_LIST;
03407 struct GWEN_CRYPT_TOKEN_LIST {
03408 GWEN_CRYPT_TOKEN *first;
03409 uint32_t count;
03410 uint32_t id;
03411 } GWEN_CRYPT_TOKEN_LIST;
03412
03417 void GWEN_Crypt_Token_List_AddList(GWEN_CRYPT_TOKEN_LIST *dst, GWEN_CRYPT_TOKEN_LIST *l);
03418
03422 void GWEN_Crypt_Token_List_Add(GWEN_CRYPT_TOKEN *element, GWEN_CRYPT_TOKEN_LIST *list);
03423
03428 void GWEN_Crypt_Token_List_Insert(GWEN_CRYPT_TOKEN *element, GWEN_CRYPT_TOKEN_LIST *list);
03429
03436 void GWEN_Crypt_Token_List_Del(GWEN_CRYPT_TOKEN *element);
03437
03441 GWEN_CRYPT_TOKEN* GWEN_Crypt_Token_List_First(const GWEN_CRYPT_TOKEN_LIST *l);
03442
03446 GWEN_CRYPT_TOKEN* GWEN_Crypt_Token_List_Last(const GWEN_CRYPT_TOKEN_LIST *l);
03447
03452 void GWEN_Crypt_Token_List_Clear(GWEN_CRYPT_TOKEN_LIST *l);
03453
03457 GWEN_CRYPT_TOKEN_LIST* GWEN_Crypt_Token_List_new();
03458
03462 void GWEN_Crypt_Token_List_free(GWEN_CRYPT_TOKEN_LIST *l);
03463
03467 GWEN_CRYPT_TOKEN* GWEN_Crypt_Token_List_Next(const GWEN_CRYPT_TOKEN *element);
03468
03472 GWEN_CRYPT_TOKEN* GWEN_Crypt_Token_List_Previous(const GWEN_CRYPT_TOKEN *element);
03473
03477 uint32_t GWEN_Crypt_Token_List_GetCount(const GWEN_CRYPT_TOKEN_LIST *l);
03478
03479 #ifdef __cplusplus
03480 }
03481 #endif
03482
03483
03484 #endif
03485
03486
03487
03488
03489
03490
03491
03492
03493
03494
03495
03496
03497
03498
03499
03500
03501
03502
03503
03504
03505
03506
03507
03508
03509
03510
03511
03512
03513
03514
03515
03516 #ifndef GWEN_CRYPT_TOKEN_CONTEXT_LIST2_H
03517 #define GWEN_CRYPT_TOKEN_CONTEXT_LIST2_H
03518
03519
03520 #ifdef __cplusplus
03521 extern "C" {
03522 #endif
03523
03530 typedef struct GWEN_CRYPT_TOKEN_CONTEXT_LIST2 GWEN_CRYPT_TOKEN_CONTEXT_LIST2;
03531
03535 typedef struct GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR;
03536
03540 typedef GWEN_CRYPT_TOKEN_CONTEXT* (GWEN_CRYPT_TOKEN_CONTEXT_LIST2_FOREACH)(GWEN_CRYPT_TOKEN_CONTEXT *element,
03541 void *user_data);
03542
03546 GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *GWEN_Crypt_Token_Context_List2_new();
03547
03551 void GWEN_Crypt_Token_Context_List2_free(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l);
03552
03556 void GWEN_Crypt_Token_Context_List2_Dump(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l, FILE *f, unsigned int indent);
03557
03561 void GWEN_Crypt_Token_Context_List2_PushBack(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l, GWEN_CRYPT_TOKEN_CONTEXT *p);
03562
03567 void GWEN_Crypt_Token_Context_List2_PushFront(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l, GWEN_CRYPT_TOKEN_CONTEXT *p);
03568
03573 GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_List2_GetFront(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l);
03574
03579 GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_List2_GetBack(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l);
03580
03585 void GWEN_Crypt_Token_Context_List2_Erase(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l,
03586 GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *it);
03587
03593 unsigned int GWEN_Crypt_Token_Context_List2_GetSize(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l);
03594
03599 void GWEN_Crypt_Token_Context_List2_PopBack(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l);
03600
03605 void GWEN_Crypt_Token_Context_List2_PopFront(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l);
03606
03610 void GWEN_Crypt_Token_Context_List2_Clear(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l);
03611
03615 GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *GWEN_Crypt_Token_Context_List2_First(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l);
03616
03620 GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *GWEN_Crypt_Token_Context_List2_Last(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l);
03621
03625 GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *GWEN_Crypt_Token_Context_List2Iterator_new(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *l);
03626
03630 void GWEN_Crypt_Token_Context_List2Iterator_free(GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *li);
03631
03636 GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_List2Iterator_Previous(GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *li);
03637
03642 GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_List2Iterator_Next(GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *li);
03643
03648 GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_List2Iterator_Data(GWEN_CRYPT_TOKEN_CONTEXT_LIST2_ITERATOR *li);
03649
03661 GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_List2_ForEach(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *list,
03662 GWEN_CRYPT_TOKEN_CONTEXT_LIST2_FOREACH func,
03663 void *user_data);
03664
03665
03666 typedef struct GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2;
03667 typedef struct GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR;
03668 typedef const GWEN_CRYPT_TOKEN_CONTEXT*
03669 (GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_FOREACH)(const GWEN_CRYPT_TOKEN_CONTEXT *element,
03670 void *user_data);
03671
03672
03673 GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *GWEN_Crypt_Token_Context_ConstList2_new();
03674
03675 void GWEN_Crypt_Token_Context_ConstList2_free(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l);
03676
03677 void GWEN_Crypt_Token_Context_ConstList2_PushBack(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l, const GWEN_CRYPT_TOKEN_CONTEXT *p);
03678
03679 void GWEN_Crypt_Token_Context_ConstList2_PushFront(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l, const GWEN_CRYPT_TOKEN_CONTEXT *p);
03680
03681 const GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_ConstList2_GetFront(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l);
03682
03683 const GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_ConstList2_GetBack(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l);
03684
03685 unsigned int GWEN_Crypt_Token_Context_ConstList2_GetSize(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l);
03686
03687 void GWEN_Crypt_Token_Context_ConstList2_PopBack(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l);
03688
03689 void GWEN_Crypt_Token_Context_ConstList2_PopFront(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l);
03690
03691 void GWEN_Crypt_Token_Context_ConstList2_Clear(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l);
03692
03693 GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_Context_ConstList2_First(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l);
03694
03695 GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_Context_ConstList2_Last(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l);
03696
03697 GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_Context_ConstList2Iterator_new(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *l);
03698
03699 void GWEN_Crypt_Token_Context_ConstList2Iterator_free(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *li);
03700
03701 const GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_ConstList2Iterator_Previous(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *li);
03702
03703 const GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_ConstList2Iterator_Next(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *li);
03704
03705 const GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_ConstList2Iterator_Data(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_ITERATOR *li);
03706
03718 const GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_ConstList2_ForEach(GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2 *list,
03719 GWEN_CRYPT_TOKEN_CONTEXT_CONSTLIST2_FOREACH func, void *user_data);
03720
03721
03722 #ifdef __cplusplus
03723 }
03724 #endif
03725
03726
03727 #endif
03728
03729
03730
03731
03732
03733
03734
03735
03736
03737
03738
03739
03740
03741
03742
03743
03744
03745
03746
03747
03748
03749
03750
03751
03752
03753
03754
03755
03756
03757
03758
03759 #ifndef GWEN_CRYPT_TOKEN_CONTEXT_LIST1_H
03760 #define GWEN_CRYPT_TOKEN_CONTEXT_LIST1_H
03761
03762 #ifdef __cplusplus
03763 extern "C" {
03764 #endif
03765
03767 typedef struct GWEN_CRYPT_TOKEN_CONTEXT_LIST_ELEMENT {
03768 uint32_t id;
03769 GWEN_CRYPT_TOKEN_CONTEXT *nextObject;
03770 } GWEN_CRYPT_TOKEN_CONTEXT_LIST__ELEMENT;
03771
03778 typedef struct GWEN_CRYPT_TOKEN_CONTEXT_LIST GWEN_CRYPT_TOKEN_CONTEXT_LIST;
03780 struct GWEN_CRYPT_TOKEN_CONTEXT_LIST {
03781 GWEN_CRYPT_TOKEN_CONTEXT *first;
03782 uint32_t count;
03783 uint32_t id;
03784 } GWEN_CRYPT_TOKEN_CONTEXT_LIST;
03785
03790 void GWEN_Crypt_Token_Context_List_AddList(GWEN_CRYPT_TOKEN_CONTEXT_LIST *dst, GWEN_CRYPT_TOKEN_CONTEXT_LIST *l);
03791
03795 void GWEN_Crypt_Token_Context_List_Add(GWEN_CRYPT_TOKEN_CONTEXT *element, GWEN_CRYPT_TOKEN_CONTEXT_LIST *list);
03796
03801 void GWEN_Crypt_Token_Context_List_Insert(GWEN_CRYPT_TOKEN_CONTEXT *element, GWEN_CRYPT_TOKEN_CONTEXT_LIST *list);
03802
03809 void GWEN_Crypt_Token_Context_List_Del(GWEN_CRYPT_TOKEN_CONTEXT *element);
03810
03814 GWEN_CRYPT_TOKEN_CONTEXT* GWEN_Crypt_Token_Context_List_First(const GWEN_CRYPT_TOKEN_CONTEXT_LIST *l);
03815
03819 GWEN_CRYPT_TOKEN_CONTEXT* GWEN_Crypt_Token_Context_List_Last(const GWEN_CRYPT_TOKEN_CONTEXT_LIST *l);
03820
03825 void GWEN_Crypt_Token_Context_List_Clear(GWEN_CRYPT_TOKEN_CONTEXT_LIST *l);
03826
03830 GWEN_CRYPT_TOKEN_CONTEXT_LIST* GWEN_Crypt_Token_Context_List_new();
03831
03835 void GWEN_Crypt_Token_Context_List_free(GWEN_CRYPT_TOKEN_CONTEXT_LIST *l);
03836
03840 GWEN_CRYPT_TOKEN_CONTEXT* GWEN_Crypt_Token_Context_List_Next(const GWEN_CRYPT_TOKEN_CONTEXT *element);
03841
03845 GWEN_CRYPT_TOKEN_CONTEXT* GWEN_Crypt_Token_Context_List_Previous(const GWEN_CRYPT_TOKEN_CONTEXT *element);
03846
03850 uint32_t GWEN_Crypt_Token_Context_List_GetCount(const GWEN_CRYPT_TOKEN_CONTEXT_LIST *l);
03851
03852 #ifdef __cplusplus
03853 }
03854 #endif
03855
03856
03857 #endif
03858
03859
03860
03861
03862
03863
03864
03865
03866
03867
03868
03869
03870
03871
03872
03873
03874
03875
03876
03877
03878
03879
03880
03881
03882
03883
03884
03885
03886
03887
03888
03889 #ifndef GWEN_CRYPT_TOKEN_KEYINFO_LIST2_H
03890 #define GWEN_CRYPT_TOKEN_KEYINFO_LIST2_H
03891
03892
03893 #ifdef __cplusplus
03894 extern "C" {
03895 #endif
03896
03903 typedef struct GWEN_CRYPT_TOKEN_KEYINFO_LIST2 GWEN_CRYPT_TOKEN_KEYINFO_LIST2;
03904
03908 typedef struct GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR;
03909
03913 typedef GWEN_CRYPT_TOKEN_KEYINFO* (GWEN_CRYPT_TOKEN_KEYINFO_LIST2_FOREACH)(GWEN_CRYPT_TOKEN_KEYINFO *element,
03914 void *user_data);
03915
03919 GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *GWEN_Crypt_Token_KeyInfo_List2_new();
03920
03924 void GWEN_Crypt_Token_KeyInfo_List2_free(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l);
03925
03929 void GWEN_Crypt_Token_KeyInfo_List2_Dump(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l, FILE *f, unsigned int indent);
03930
03934 void GWEN_Crypt_Token_KeyInfo_List2_PushBack(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l, GWEN_CRYPT_TOKEN_KEYINFO *p);
03935
03940 void GWEN_Crypt_Token_KeyInfo_List2_PushFront(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l, GWEN_CRYPT_TOKEN_KEYINFO *p);
03941
03946 GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_List2_GetFront(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l);
03947
03952 GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_List2_GetBack(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l);
03953
03958 void GWEN_Crypt_Token_KeyInfo_List2_Erase(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l,
03959 GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *it);
03960
03966 unsigned int GWEN_Crypt_Token_KeyInfo_List2_GetSize(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l);
03967
03972 void GWEN_Crypt_Token_KeyInfo_List2_PopBack(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l);
03973
03978 void GWEN_Crypt_Token_KeyInfo_List2_PopFront(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l);
03979
03983 void GWEN_Crypt_Token_KeyInfo_List2_Clear(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l);
03984
03988 GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *GWEN_Crypt_Token_KeyInfo_List2_First(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l);
03989
03993 GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *GWEN_Crypt_Token_KeyInfo_List2_Last(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l);
03994
03998 GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *GWEN_Crypt_Token_KeyInfo_List2Iterator_new(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *l);
03999
04003 void GWEN_Crypt_Token_KeyInfo_List2Iterator_free(GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *li);
04004
04009 GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_List2Iterator_Previous(GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *li);
04010
04015 GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_List2Iterator_Next(GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *li);
04016
04021 GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_List2Iterator_Data(GWEN_CRYPT_TOKEN_KEYINFO_LIST2_ITERATOR *li);
04022
04034 GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_List2_ForEach(GWEN_CRYPT_TOKEN_KEYINFO_LIST2 *list,
04035 GWEN_CRYPT_TOKEN_KEYINFO_LIST2_FOREACH func,
04036 void *user_data);
04037
04038
04039 typedef struct GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2;
04040 typedef struct GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR;
04041 typedef const GWEN_CRYPT_TOKEN_KEYINFO*
04042 (GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_FOREACH)(const GWEN_CRYPT_TOKEN_KEYINFO *element,
04043 void *user_data);
04044
04045
04046 GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *GWEN_Crypt_Token_KeyInfo_ConstList2_new();
04047
04048 void GWEN_Crypt_Token_KeyInfo_ConstList2_free(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l);
04049
04050 void GWEN_Crypt_Token_KeyInfo_ConstList2_PushBack(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l, const GWEN_CRYPT_TOKEN_KEYINFO *p);
04051
04052 void GWEN_Crypt_Token_KeyInfo_ConstList2_PushFront(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l, const GWEN_CRYPT_TOKEN_KEYINFO *p);
04053
04054 const GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_ConstList2_GetFront(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l);
04055
04056 const GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_ConstList2_GetBack(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l);
04057
04058 unsigned int GWEN_Crypt_Token_KeyInfo_ConstList2_GetSize(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l);
04059
04060 void GWEN_Crypt_Token_KeyInfo_ConstList2_PopBack(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l);
04061
04062 void GWEN_Crypt_Token_KeyInfo_ConstList2_PopFront(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l);
04063
04064 void GWEN_Crypt_Token_KeyInfo_ConstList2_Clear(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l);
04065
04066 GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_KeyInfo_ConstList2_First(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l);
04067
04068 GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_KeyInfo_ConstList2_Last(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l);
04069
04070 GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *GWEN_Crypt_Token_KeyInfo_ConstList2Iterator_new(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *l);
04071
04072 void GWEN_Crypt_Token_KeyInfo_ConstList2Iterator_free(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *li);
04073
04074 const GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_ConstList2Iterator_Previous(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *li);
04075
04076 const GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_ConstList2Iterator_Next(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *li);
04077
04078 const GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_ConstList2Iterator_Data(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_ITERATOR *li);
04079
04091 const GWEN_CRYPT_TOKEN_KEYINFO *GWEN_Crypt_Token_KeyInfo_ConstList2_ForEach(GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2 *list,
04092 GWEN_CRYPT_TOKEN_KEYINFO_CONSTLIST2_FOREACH func, void *user_data);
04093
04094
04095 #ifdef __cplusplus
04096 }
04097 #endif
04098
04099
04100 #endif
04101
04102
04103
04104
04105
04106
04107
04108
04109
04110
04111
04112
04113
04114
04115
04116
04117
04118
04119
04120
04121
04122
04123
04124
04125
04126
04127
04128
04129
04130
04131
04132 #ifndef GWEN_CRYPT_TOKEN_KEYINFO_LIST1_H
04133 #define GWEN_CRYPT_TOKEN_KEYINFO_LIST1_H
04134
04135 #ifdef __cplusplus
04136 extern "C" {
04137 #endif
04138
04140 typedef struct GWEN_CRYPT_TOKEN_KEYINFO_LIST_ELEMENT {
04141 uint32_t id;
04142 GWEN_CRYPT_TOKEN_KEYINFO *nextObject;
04143 } GWEN_CRYPT_TOKEN_KEYINFO_LIST__ELEMENT;
04144
04151 typedef struct GWEN_CRYPT_TOKEN_KEYINFO_LIST GWEN_CRYPT_TOKEN_KEYINFO_LIST;
04153 struct GWEN_CRYPT_TOKEN_KEYINFO_LIST {
04154 GWEN_CRYPT_TOKEN_KEYINFO *first;
04155 uint32_t count;
04156 uint32_t id;
04157 } GWEN_CRYPT_TOKEN_KEYINFO_LIST;
04158
04163 void GWEN_Crypt_Token_KeyInfo_List_AddList(GWEN_CRYPT_TOKEN_KEYINFO_LIST *dst, GWEN_CRYPT_TOKEN_KEYINFO_LIST *l);
04164
04168 void GWEN_Crypt_Token_KeyInfo_List_Add(GWEN_CRYPT_TOKEN_KEYINFO *element, GWEN_CRYPT_TOKEN_KEYINFO_LIST *list);
04169
04174 void GWEN_Crypt_Token_KeyInfo_List_Insert(GWEN_CRYPT_TOKEN_KEYINFO *element, GWEN_CRYPT_TOKEN_KEYINFO_LIST *list);
04175
04182 void GWEN_Crypt_Token_KeyInfo_List_Del(GWEN_CRYPT_TOKEN_KEYINFO *element);
04183
04187 GWEN_CRYPT_TOKEN_KEYINFO* GWEN_Crypt_Token_KeyInfo_List_First(const GWEN_CRYPT_TOKEN_KEYINFO_LIST *l);
04188
04192 GWEN_CRYPT_TOKEN_KEYINFO* GWEN_Crypt_Token_KeyInfo_List_Last(const GWEN_CRYPT_TOKEN_KEYINFO_LIST *l);
04193
04198 void GWEN_Crypt_Token_KeyInfo_List_Clear(GWEN_CRYPT_TOKEN_KEYINFO_LIST *l);
04199
04203 GWEN_CRYPT_TOKEN_KEYINFO_LIST* GWEN_Crypt_Token_KeyInfo_List_new();
04204
04208 void GWEN_Crypt_Token_KeyInfo_List_free(GWEN_CRYPT_TOKEN_KEYINFO_LIST *l);
04209
04213 GWEN_CRYPT_TOKEN_KEYINFO* GWEN_Crypt_Token_KeyInfo_List_Next(const GWEN_CRYPT_TOKEN_KEYINFO *element);
04214
04218 GWEN_CRYPT_TOKEN_KEYINFO* GWEN_Crypt_Token_KeyInfo_List_Previous(const GWEN_CRYPT_TOKEN_KEYINFO *element);
04219
04223 uint32_t GWEN_Crypt_Token_KeyInfo_List_GetCount(const GWEN_CRYPT_TOKEN_KEYINFO_LIST *l);
04224
04225 #ifdef __cplusplus
04226 }
04227 #endif
04228
04229
04230 #endif
04231
04232
04233
04234
04235
04236
04237
04238
04239
04240
04241
04242
04243
04244
04245
04246
04247
04248
04249
04250
04251
04252
04253
04254
04255
04256
04257
04258
04259
04260
04261
04262 #ifndef GWEN_IO_LAYER_LIST2_H
04263 #define GWEN_IO_LAYER_LIST2_H
04264
04265
04266 #ifdef __cplusplus
04267 extern "C" {
04268 #endif
04269
04276 typedef struct GWEN_IO_LAYER_LIST2 GWEN_IO_LAYER_LIST2;
04277
04281 typedef struct GWEN_IO_LAYER_LIST2_ITERATOR GWEN_IO_LAYER_LIST2_ITERATOR;
04282
04286 typedef GWEN_IO_LAYER* (GWEN_IO_LAYER_LIST2_FOREACH)(GWEN_IO_LAYER *element,
04287 void *user_data);
04288
04292 GWEN_IO_LAYER_LIST2 *GWEN_Io_Layer_List2_new();
04293
04297 void GWEN_Io_Layer_List2_free(GWEN_IO_LAYER_LIST2 *l);
04298
04302 void GWEN_Io_Layer_List2_Dump(GWEN_IO_LAYER_LIST2 *l, FILE *f, unsigned int indent);
04303
04307 void GWEN_Io_Layer_List2_PushBack(GWEN_IO_LAYER_LIST2 *l, GWEN_IO_LAYER *p);
04308
04313 void GWEN_Io_Layer_List2_PushFront(GWEN_IO_LAYER_LIST2 *l, GWEN_IO_LAYER *p);
04314
04319 GWEN_IO_LAYER *GWEN_Io_Layer_List2_GetFront(GWEN_IO_LAYER_LIST2 *l);
04320
04325 GWEN_IO_LAYER *GWEN_Io_Layer_List2_GetBack(GWEN_IO_LAYER_LIST2 *l);
04326
04331 void GWEN_Io_Layer_List2_Erase(GWEN_IO_LAYER_LIST2 *l,
04332 GWEN_IO_LAYER_LIST2_ITERATOR *it);
04333
04339 unsigned int GWEN_Io_Layer_List2_GetSize(GWEN_IO_LAYER_LIST2 *l);
04340
04345 void GWEN_Io_Layer_List2_PopBack(GWEN_IO_LAYER_LIST2 *l);
04346
04351 void GWEN_Io_Layer_List2_PopFront(GWEN_IO_LAYER_LIST2 *l);
04352
04356 void GWEN_Io_Layer_List2_Clear(GWEN_IO_LAYER_LIST2 *l);
04357
04361 GWEN_IO_LAYER_LIST2_ITERATOR *GWEN_Io_Layer_List2_First(GWEN_IO_LAYER_LIST2 *l);
04362
04366 GWEN_IO_LAYER_LIST2_ITERATOR *GWEN_Io_Layer_List2_Last(GWEN_IO_LAYER_LIST2 *l);
04367
04371 GWEN_IO_LAYER_LIST2_ITERATOR *GWEN_Io_Layer_List2Iterator_new(GWEN_IO_LAYER_LIST2 *l);
04372
04376 void GWEN_Io_Layer_List2Iterator_free(GWEN_IO_LAYER_LIST2_ITERATOR *li);
04377
04382 GWEN_IO_LAYER *GWEN_Io_Layer_List2Iterator_Previous(GWEN_IO_LAYER_LIST2_ITERATOR *li);
04383
04388 GWEN_IO_LAYER *GWEN_Io_Layer_List2Iterator_Next(GWEN_IO_LAYER_LIST2_ITERATOR *li);
04389
04394 GWEN_IO_LAYER *GWEN_Io_Layer_List2Iterator_Data(GWEN_IO_LAYER_LIST2_ITERATOR *li);
04395
04407 GWEN_IO_LAYER *GWEN_Io_Layer_List2_ForEach(GWEN_IO_LAYER_LIST2 *list,
04408 GWEN_IO_LAYER_LIST2_FOREACH func,
04409 void *user_data);
04410
04411
04412 typedef struct GWEN_IO_LAYER_CONSTLIST2 GWEN_IO_LAYER_CONSTLIST2;
04413 typedef struct GWEN_IO_LAYER_CONSTLIST2_ITERATOR GWEN_IO_LAYER_CONSTLIST2_ITERATOR;
04414 typedef const GWEN_IO_LAYER*
04415 (GWEN_IO_LAYER_CONSTLIST2_FOREACH)(const GWEN_IO_LAYER *element,
04416 void *user_data);
04417
04418
04419 GWEN_IO_LAYER_CONSTLIST2 *GWEN_Io_Layer_ConstList2_new();
04420
04421 void GWEN_Io_Layer_ConstList2_free(GWEN_IO_LAYER_CONSTLIST2 *l);
04422
04423 void GWEN_Io_Layer_ConstList2_PushBack(GWEN_IO_LAYER_CONSTLIST2 *l, const GWEN_IO_LAYER *p);
04424
04425 void GWEN_Io_Layer_ConstList2_PushFront(GWEN_IO_LAYER_CONSTLIST2 *l, const GWEN_IO_LAYER *p);
04426
04427 const GWEN_IO_LAYER *GWEN_Io_Layer_ConstList2_GetFront(GWEN_IO_LAYER_CONSTLIST2 *l);
04428
04429 const GWEN_IO_LAYER *GWEN_Io_Layer_ConstList2_GetBack(GWEN_IO_LAYER_CONSTLIST2 *l);
04430
04431 unsigned int GWEN_Io_Layer_ConstList2_GetSize(GWEN_IO_LAYER_CONSTLIST2 *l);
04432
04433 void GWEN_Io_Layer_ConstList2_PopBack(GWEN_IO_LAYER_CONSTLIST2 *l);
04434
04435 void GWEN_Io_Layer_ConstList2_PopFront(GWEN_IO_LAYER_CONSTLIST2 *l);
04436
04437 void GWEN_Io_Layer_ConstList2_Clear(GWEN_IO_LAYER_CONSTLIST2 *l);
04438
04439 GWEN_IO_LAYER_CONSTLIST2_ITERATOR *GWEN_Io_Layer_ConstList2_First(GWEN_IO_LAYER_CONSTLIST2 *l);
04440
04441 GWEN_IO_LAYER_CONSTLIST2_ITERATOR *GWEN_Io_Layer_ConstList2_Last(GWEN_IO_LAYER_CONSTLIST2 *l);
04442
04443 GWEN_IO_LAYER_CONSTLIST2_ITERATOR *GWEN_Io_Layer_ConstList2Iterator_new(GWEN_IO_LAYER_CONSTLIST2 *l);
04444
04445 void GWEN_Io_Layer_ConstList2Iterator_free(GWEN_IO_LAYER_CONSTLIST2_ITERATOR *li);
04446
04447 const GWEN_IO_LAYER *GWEN_Io_Layer_ConstList2Iterator_Previous(GWEN_IO_LAYER_CONSTLIST2_ITERATOR *li);
04448
04449 const GWEN_IO_LAYER *GWEN_Io_Layer_ConstList2Iterator_Next(GWEN_IO_LAYER_CONSTLIST2_ITERATOR *li);
04450
04451 const GWEN_IO_LAYER *GWEN_Io_Layer_ConstList2Iterator_Data(GWEN_IO_LAYER_CONSTLIST2_ITERATOR *li);
04452
04464 const GWEN_IO_LAYER *GWEN_Io_Layer_ConstList2_ForEach(GWEN_IO_LAYER_CONSTLIST2 *list,
04465 GWEN_IO_LAYER_CONSTLIST2_FOREACH func, void *user_data);
04466
04467
04468 #ifdef __cplusplus
04469 }
04470 #endif
04471
04472
04473 #endif
04474
04475
04476
04477
04478
04479
04480
04481
04482
04483
04484
04485
04486
04487
04488
04489
04490
04491
04492
04493
04494
04495
04496
04497
04498
04499
04500
04501
04502
04503
04504
04505 #ifndef GWEN_IO_REQUEST_LIST2_H
04506 #define GWEN_IO_REQUEST_LIST2_H
04507
04508
04509 #ifdef __cplusplus
04510 extern "C" {
04511 #endif
04512
04519 typedef struct GWEN_IO_REQUEST_LIST2 GWEN_IO_REQUEST_LIST2;
04520
04524 typedef struct GWEN_IO_REQUEST_LIST2_ITERATOR GWEN_IO_REQUEST_LIST2_ITERATOR;
04525
04529 typedef GWEN_IO_REQUEST* (GWEN_IO_REQUEST_LIST2_FOREACH)(GWEN_IO_REQUEST *element,
04530 void *user_data);
04531
04535 GWEN_IO_REQUEST_LIST2 *GWEN_Io_Request_List2_new();
04536
04540 void GWEN_Io_Request_List2_free(GWEN_IO_REQUEST_LIST2 *l);
04541
04545 void GWEN_Io_Request_List2_Dump(GWEN_IO_REQUEST_LIST2 *l, FILE *f, unsigned int indent);
04546
04550 void GWEN_Io_Request_List2_PushBack(GWEN_IO_REQUEST_LIST2 *l, GWEN_IO_REQUEST *p);
04551
04556 void GWEN_Io_Request_List2_PushFront(GWEN_IO_REQUEST_LIST2 *l, GWEN_IO_REQUEST *p);
04557
04562 GWEN_IO_REQUEST *GWEN_Io_Request_List2_GetFront(GWEN_IO_REQUEST_LIST2 *l);
04563
04568 GWEN_IO_REQUEST *GWEN_Io_Request_List2_GetBack(GWEN_IO_REQUEST_LIST2 *l);
04569
04574 void GWEN_Io_Request_List2_Erase(GWEN_IO_REQUEST_LIST2 *l,
04575 GWEN_IO_REQUEST_LIST2_ITERATOR *it);
04576
04582 unsigned int GWEN_Io_Request_List2_GetSize(GWEN_IO_REQUEST_LIST2 *l);
04583
04588 void GWEN_Io_Request_List2_PopBack(GWEN_IO_REQUEST_LIST2 *l);
04589
04594 void GWEN_Io_Request_List2_PopFront(GWEN_IO_REQUEST_LIST2 *l);
04595
04599 void GWEN_Io_Request_List2_Clear(GWEN_IO_REQUEST_LIST2 *l);
04600
04604 GWEN_IO_REQUEST_LIST2_ITERATOR *GWEN_Io_Request_List2_First(GWEN_IO_REQUEST_LIST2 *l);
04605
04609 GWEN_IO_REQUEST_LIST2_ITERATOR *GWEN_Io_Request_List2_Last(GWEN_IO_REQUEST_LIST2 *l);
04610
04614 GWEN_IO_REQUEST_LIST2_ITERATOR *GWEN_Io_Request_List2Iterator_new(GWEN_IO_REQUEST_LIST2 *l);
04615
04619 void GWEN_Io_Request_List2Iterator_free(GWEN_IO_REQUEST_LIST2_ITERATOR *li);
04620
04625 GWEN_IO_REQUEST *GWEN_Io_Request_List2Iterator_Previous(GWEN_IO_REQUEST_LIST2_ITERATOR *li);
04626
04631 GWEN_IO_REQUEST *GWEN_Io_Request_List2Iterator_Next(GWEN_IO_REQUEST_LIST2_ITERATOR *li);
04632
04637 GWEN_IO_REQUEST *GWEN_Io_Request_List2Iterator_Data(GWEN_IO_REQUEST_LIST2_ITERATOR *li);
04638
04650 GWEN_IO_REQUEST *GWEN_Io_Request_List2_ForEach(GWEN_IO_REQUEST_LIST2 *list,
04651 GWEN_IO_REQUEST_LIST2_FOREACH func,
04652 void *user_data);
04653
04654
04655 typedef struct GWEN_IO_REQUEST_CONSTLIST2 GWEN_IO_REQUEST_CONSTLIST2;
04656 typedef struct GWEN_IO_REQUEST_CONSTLIST2_ITERATOR GWEN_IO_REQUEST_CONSTLIST2_ITERATOR;
04657 typedef const GWEN_IO_REQUEST*
04658 (GWEN_IO_REQUEST_CONSTLIST2_FOREACH)(const GWEN_IO_REQUEST *element,
04659 void *user_data);
04660
04661
04662 GWEN_IO_REQUEST_CONSTLIST2 *GWEN_Io_Request_ConstList2_new();
04663
04664 void GWEN_Io_Request_ConstList2_free(GWEN_IO_REQUEST_CONSTLIST2 *l);
04665
04666 void GWEN_Io_Request_ConstList2_PushBack(GWEN_IO_REQUEST_CONSTLIST2 *l, const GWEN_IO_REQUEST *p);
04667
04668 void GWEN_Io_Request_ConstList2_PushFront(GWEN_IO_REQUEST_CONSTLIST2 *l, const GWEN_IO_REQUEST *p);
04669
04670 const GWEN_IO_REQUEST *GWEN_Io_Request_ConstList2_GetFront(GWEN_IO_REQUEST_CONSTLIST2 *l);
04671
04672 const GWEN_IO_REQUEST *GWEN_Io_Request_ConstList2_GetBack(GWEN_IO_REQUEST_CONSTLIST2 *l);
04673
04674 unsigned int GWEN_Io_Request_ConstList2_GetSize(GWEN_IO_REQUEST_CONSTLIST2 *l);
04675
04676 void GWEN_Io_Request_ConstList2_PopBack(GWEN_IO_REQUEST_CONSTLIST2 *l);
04677
04678 void GWEN_Io_Request_ConstList2_PopFront(GWEN_IO_REQUEST_CONSTLIST2 *l);
04679
04680 void GWEN_Io_Request_ConstList2_Clear(GWEN_IO_REQUEST_CONSTLIST2 *l);
04681
04682 GWEN_IO_REQUEST_CONSTLIST2_ITERATOR *GWEN_Io_Request_ConstList2_First(GWEN_IO_REQUEST_CONSTLIST2 *l);
04683
04684 GWEN_IO_REQUEST_CONSTLIST2_ITERATOR *GWEN_Io_Request_ConstList2_Last(GWEN_IO_REQUEST_CONSTLIST2 *l);
04685
04686 GWEN_IO_REQUEST_CONSTLIST2_ITERATOR *GWEN_Io_Request_ConstList2Iterator_new(GWEN_IO_REQUEST_CONSTLIST2 *l);
04687
04688 void GWEN_Io_Request_ConstList2Iterator_free(GWEN_IO_REQUEST_CONSTLIST2_ITERATOR *li);
04689
04690 const GWEN_IO_REQUEST *GWEN_Io_Request_ConstList2Iterator_Previous(GWEN_IO_REQUEST_CONSTLIST2_ITERATOR *li);
04691
04692 const GWEN_IO_REQUEST *GWEN_Io_Request_ConstList2Iterator_Next(GWEN_IO_REQUEST_CONSTLIST2_ITERATOR *li);
04693
04694 const GWEN_IO_REQUEST *GWEN_Io_Request_ConstList2Iterator_Data(GWEN_IO_REQUEST_CONSTLIST2_ITERATOR *li);
04695
04707 const GWEN_IO_REQUEST *GWEN_Io_Request_ConstList2_ForEach(GWEN_IO_REQUEST_CONSTLIST2 *list,
04708 GWEN_IO_REQUEST_CONSTLIST2_FOREACH func, void *user_data);
04709
04710
04711 #ifdef __cplusplus
04712 }
04713 #endif
04714
04715
04716 #endif
04717
04718
04719
04720
04721
04722
04723
04724
04725
04726
04727
04728
04729
04730
04731
04732
04733
04734
04735
04736
04737
04738
04739
04740
04741
04742
04743
04744
04745
04746
04747
04748 #ifndef GWEN_IO_REQUEST_LIST1_H
04749 #define GWEN_IO_REQUEST_LIST1_H
04750
04751 #ifdef __cplusplus
04752 extern "C" {
04753 #endif
04754
04756 typedef struct GWEN_IO_REQUEST_LIST_ELEMENT {
04757 uint32_t id;
04758 GWEN_IO_REQUEST *nextObject;
04759 } GWEN_IO_REQUEST_LIST__ELEMENT;
04760
04767 typedef struct GWEN_IO_REQUEST_LIST GWEN_IO_REQUEST_LIST;
04769 struct GWEN_IO_REQUEST_LIST {
04770 GWEN_IO_REQUEST *first;
04771 uint32_t count;
04772 uint32_t id;
04773 } GWEN_IO_REQUEST_LIST;
04774
04779 void GWEN_Io_Request_List_AddList(GWEN_IO_REQUEST_LIST *dst, GWEN_IO_REQUEST_LIST *l);
04780
04784 void GWEN_Io_Request_List_Add(GWEN_IO_REQUEST *element, GWEN_IO_REQUEST_LIST *list);
04785
04790 void GWEN_Io_Request_List_Insert(GWEN_IO_REQUEST *element, GWEN_IO_REQUEST_LIST *list);
04791
04798 void GWEN_Io_Request_List_Del(GWEN_IO_REQUEST *element);
04799
04803 GWEN_IO_REQUEST* GWEN_Io_Request_List_First(const GWEN_IO_REQUEST_LIST *l);
04804
04808 GWEN_IO_REQUEST* GWEN_Io_Request_List_Last(const GWEN_IO_REQUEST_LIST *l);
04809
04814 void GWEN_Io_Request_List_Clear(GWEN_IO_REQUEST_LIST *l);
04815
04819 GWEN_IO_REQUEST_LIST* GWEN_Io_Request_List_new();
04820
04824 void GWEN_Io_Request_List_free(GWEN_IO_REQUEST_LIST *l);
04825
04829 GWEN_IO_REQUEST* GWEN_Io_Request_List_Next(const GWEN_IO_REQUEST *element);
04830
04834 GWEN_IO_REQUEST* GWEN_Io_Request_List_Previous(const GWEN_IO_REQUEST *element);
04835
04839 uint32_t GWEN_Io_Request_List_GetCount(const GWEN_IO_REQUEST_LIST *l);
04840
04841 #ifdef __cplusplus
04842 }
04843 #endif
04844
04845
04846 #endif
04847
04848
04849
04850
04851
04852
04853
04854
04855
04856
04857
04858
04859
04860
04861
04862
04863
04864
04865
04866
04867
04868
04869
04870
04871
04872
04873
04874
04875
04876
04877
04878 #ifndef GWEN_SSLCERTDESCR_LIST2_H
04879 #define GWEN_SSLCERTDESCR_LIST2_H
04880
04881
04882 #ifdef __cplusplus
04883 extern "C" {
04884 #endif
04885
04892 typedef struct GWEN_SSLCERTDESCR_LIST2 GWEN_SSLCERTDESCR_LIST2;
04893
04897 typedef struct GWEN_SSLCERTDESCR_LIST2_ITERATOR GWEN_SSLCERTDESCR_LIST2_ITERATOR;
04898
04902 typedef GWEN_SSLCERTDESCR* (GWEN_SSLCERTDESCR_LIST2_FOREACH)(GWEN_SSLCERTDESCR *element,
04903 void *user_data);
04904
04908 GWEN_SSLCERTDESCR_LIST2 *GWEN_SslCertDescr_List2_new();
04909
04913 void GWEN_SslCertDescr_List2_free(GWEN_SSLCERTDESCR_LIST2 *l);
04914
04918 void GWEN_SslCertDescr_List2_Dump(GWEN_SSLCERTDESCR_LIST2 *l, FILE *f, unsigned int indent);
04919
04923 void GWEN_SslCertDescr_List2_PushBack(GWEN_SSLCERTDESCR_LIST2 *l, GWEN_SSLCERTDESCR *p);
04924
04929 void GWEN_SslCertDescr_List2_PushFront(GWEN_SSLCERTDESCR_LIST2 *l, GWEN_SSLCERTDESCR *p);
04930
04935 GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2_GetFront(GWEN_SSLCERTDESCR_LIST2 *l);
04936
04941 GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2_GetBack(GWEN_SSLCERTDESCR_LIST2 *l);
04942
04947 void GWEN_SslCertDescr_List2_Erase(GWEN_SSLCERTDESCR_LIST2 *l,
04948 GWEN_SSLCERTDESCR_LIST2_ITERATOR *it);
04949
04955 unsigned int GWEN_SslCertDescr_List2_GetSize(GWEN_SSLCERTDESCR_LIST2 *l);
04956
04961 void GWEN_SslCertDescr_List2_PopBack(GWEN_SSLCERTDESCR_LIST2 *l);
04962
04967 void GWEN_SslCertDescr_List2_PopFront(GWEN_SSLCERTDESCR_LIST2 *l);
04968
04972 void GWEN_SslCertDescr_List2_Clear(GWEN_SSLCERTDESCR_LIST2 *l);
04973
04977 GWEN_SSLCERTDESCR_LIST2_ITERATOR *GWEN_SslCertDescr_List2_First(GWEN_SSLCERTDESCR_LIST2 *l);
04978
04982 GWEN_SSLCERTDESCR_LIST2_ITERATOR *GWEN_SslCertDescr_List2_Last(GWEN_SSLCERTDESCR_LIST2 *l);
04983
04987 GWEN_SSLCERTDESCR_LIST2_ITERATOR *GWEN_SslCertDescr_List2Iterator_new(GWEN_SSLCERTDESCR_LIST2 *l);
04988
04992 void GWEN_SslCertDescr_List2Iterator_free(GWEN_SSLCERTDESCR_LIST2_ITERATOR *li);
04993
04998 GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2Iterator_Previous(GWEN_SSLCERTDESCR_LIST2_ITERATOR *li);
04999
05004 GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2Iterator_Next(GWEN_SSLCERTDESCR_LIST2_ITERATOR *li);
05005
05010 GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2Iterator_Data(GWEN_SSLCERTDESCR_LIST2_ITERATOR *li);
05011
05023 GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2_ForEach(GWEN_SSLCERTDESCR_LIST2 *list,
05024 GWEN_SSLCERTDESCR_LIST2_FOREACH func,
05025 void *user_data);
05026
05027
05028 typedef struct GWEN_SSLCERTDESCR_CONSTLIST2 GWEN_SSLCERTDESCR_CONSTLIST2;
05029 typedef struct GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR;
05030 typedef const GWEN_SSLCERTDESCR*
05031 (GWEN_SSLCERTDESCR_CONSTLIST2_FOREACH)(const GWEN_SSLCERTDESCR *element,
05032 void *user_data);
05033
05034
05035 GWEN_SSLCERTDESCR_CONSTLIST2 *GWEN_SslCertDescr_ConstList2_new();
05036
05037 void GWEN_SslCertDescr_ConstList2_free(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
05038
05039 void GWEN_SslCertDescr_ConstList2_PushBack(GWEN_SSLCERTDESCR_CONSTLIST2 *l, const GWEN_SSLCERTDESCR *p);
05040
05041 void GWEN_SslCertDescr_ConstList2_PushFront(GWEN_SSLCERTDESCR_CONSTLIST2 *l, const GWEN_SSLCERTDESCR *p);
05042
05043 const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2_GetFront(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
05044
05045 const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2_GetBack(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
05046
05047 unsigned int GWEN_SslCertDescr_ConstList2_GetSize(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
05048
05049 void GWEN_SslCertDescr_ConstList2_PopBack(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
05050
05051 void GWEN_SslCertDescr_ConstList2_PopFront(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
05052
05053 void GWEN_SslCertDescr_ConstList2_Clear(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
05054
05055 GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *GWEN_SslCertDescr_ConstList2_First(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
05056
05057 GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *GWEN_SslCertDescr_ConstList2_Last(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
05058
05059 GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *GWEN_SslCertDescr_ConstList2Iterator_new(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
05060
05061 void GWEN_SslCertDescr_ConstList2Iterator_free(GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *li);
05062
05063 const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2Iterator_Previous(GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *li);
05064
05065 const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2Iterator_Next(GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *li);
05066
05067 const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2Iterator_Data(GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *li);
05068
05080 const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2_ForEach(GWEN_SSLCERTDESCR_CONSTLIST2 *list,
05081 GWEN_SSLCERTDESCR_CONSTLIST2_FOREACH func, void *user_data);
05082
05083
05084 #ifdef __cplusplus
05085 }
05086 #endif
05087
05088
05089 #endif
05090
05091
05092
05093
05094
05095
05096
05097
05098
05099
05100
05101
05102
05103
05104
05105
05106
05107
05108
05109
05110
05111
05112
05113
05114
05115
05116
05117
05118
05119
05120
05121 #ifndef GWEN_SSLCERTDESCR_LIST1_H
05122 #define GWEN_SSLCERTDESCR_LIST1_H
05123
05124 #ifdef __cplusplus
05125 extern "C" {
05126 #endif
05127
05129 typedef struct GWEN_SSLCERTDESCR_LIST_ELEMENT {
05130 uint32_t id;
05131 GWEN_SSLCERTDESCR *nextObject;
05132 } GWEN_SSLCERTDESCR_LIST__ELEMENT;
05133
05140 typedef struct GWEN_SSLCERTDESCR_LIST GWEN_SSLCERTDESCR_LIST;
05142 struct GWEN_SSLCERTDESCR_LIST {
05143 GWEN_SSLCERTDESCR *first;
05144 uint32_t count;
05145 uint32_t id;
05146 } GWEN_SSLCERTDESCR_LIST;
05147
05152 void GWEN_SslCertDescr_List_AddList(GWEN_SSLCERTDESCR_LIST *dst, GWEN_SSLCERTDESCR_LIST *l);
05153
05157 void GWEN_SslCertDescr_List_Add(GWEN_SSLCERTDESCR *element, GWEN_SSLCERTDESCR_LIST *list);
05158
05163 void GWEN_SslCertDescr_List_Insert(GWEN_SSLCERTDESCR *element, GWEN_SSLCERTDESCR_LIST *list);
05164
05171 void GWEN_SslCertDescr_List_Del(GWEN_SSLCERTDESCR *element);
05172
05176 GWEN_SSLCERTDESCR* GWEN_SslCertDescr_List_First(const GWEN_SSLCERTDESCR_LIST *l);
05177
05181 GWEN_SSLCERTDESCR* GWEN_SslCertDescr_List_Last(const GWEN_SSLCERTDESCR_LIST *l);
05182
05187 void GWEN_SslCertDescr_List_Clear(GWEN_SSLCERTDESCR_LIST *l);
05188
05192 GWEN_SSLCERTDESCR_LIST* GWEN_SslCertDescr_List_new();
05193
05197 void GWEN_SslCertDescr_List_free(GWEN_SSLCERTDESCR_LIST *l);
05198
05202 GWEN_SSLCERTDESCR* GWEN_SslCertDescr_List_Next(const GWEN_SSLCERTDESCR *element);
05203
05207 GWEN_SSLCERTDESCR* GWEN_SslCertDescr_List_Previous(const GWEN_SSLCERTDESCR *element);
05208
05212 uint32_t GWEN_SslCertDescr_List_GetCount(const GWEN_SSLCERTDESCR_LIST *l);
05213
05214 #ifdef __cplusplus
05215 }
05216 #endif
05217
05218
05219 #endif
05220
05221
05222
05223
05224
05225
05226
05227
05228
05229
05230
05231
05232
05233
05234
05235
05236
05237
05238
05239
05240
05241
05242
05243
05244
05245
05246
05247
05248
05249
05250
05251 #ifndef GWEN_IPC_REQUEST_LIST2_H
05252 #define GWEN_IPC_REQUEST_LIST2_H
05253
05254
05255 #ifdef __cplusplus
05256 extern "C" {
05257 #endif
05258
05265 typedef struct GWEN_IPC_REQUEST_LIST2 GWEN_IPC_REQUEST_LIST2;
05266
05270 typedef struct GWEN_IPC_REQUEST_LIST2_ITERATOR GWEN_IPC_REQUEST_LIST2_ITERATOR;
05271
05275 typedef GWEN_IPC_REQUEST* (GWEN_IPC_REQUEST_LIST2_FOREACH)(GWEN_IPC_REQUEST *element,
05276 void *user_data);
05277
05281 GWEN_IPC_REQUEST_LIST2 *GWEN_IpcRequest_List2_new();
05282
05286 void GWEN_IpcRequest_List2_free(GWEN_IPC_REQUEST_LIST2 *l);
05287
05291 void GWEN_IpcRequest_List2_Dump(GWEN_IPC_REQUEST_LIST2 *l, FILE *f, unsigned int indent);
05292
05296 void GWEN_IpcRequest_List2_PushBack(GWEN_IPC_REQUEST_LIST2 *l, GWEN_IPC_REQUEST *p);
05297
05302 void GWEN_IpcRequest_List2_PushFront(GWEN_IPC_REQUEST_LIST2 *l, GWEN_IPC_REQUEST *p);
05303
05308 GWEN_IPC_REQUEST *GWEN_IpcRequest_List2_GetFront(GWEN_IPC_REQUEST_LIST2 *l);
05309
05314 GWEN_IPC_REQUEST *GWEN_IpcRequest_List2_GetBack(GWEN_IPC_REQUEST_LIST2 *l);
05315
05320 void GWEN_IpcRequest_List2_Erase(GWEN_IPC_REQUEST_LIST2 *l,
05321 GWEN_IPC_REQUEST_LIST2_ITERATOR *it);
05322
05328 unsigned int GWEN_IpcRequest_List2_GetSize(GWEN_IPC_REQUEST_LIST2 *l);
05329
05334 void GWEN_IpcRequest_List2_PopBack(GWEN_IPC_REQUEST_LIST2 *l);
05335
05340 void GWEN_IpcRequest_List2_PopFront(GWEN_IPC_REQUEST_LIST2 *l);
05341
05345 void GWEN_IpcRequest_List2_Clear(GWEN_IPC_REQUEST_LIST2 *l);
05346
05350 GWEN_IPC_REQUEST_LIST2_ITERATOR *GWEN_IpcRequest_List2_First(GWEN_IPC_REQUEST_LIST2 *l);
05351
05355 GWEN_IPC_REQUEST_LIST2_ITERATOR *GWEN_IpcRequest_List2_Last(GWEN_IPC_REQUEST_LIST2 *l);
05356
05360 GWEN_IPC_REQUEST_LIST2_ITERATOR *GWEN_IpcRequest_List2Iterator_new(GWEN_IPC_REQUEST_LIST2 *l);
05361
05365 void GWEN_IpcRequest_List2Iterator_free(GWEN_IPC_REQUEST_LIST2_ITERATOR *li);
05366
05371 GWEN_IPC_REQUEST *GWEN_IpcRequest_List2Iterator_Previous(GWEN_IPC_REQUEST_LIST2_ITERATOR *li);
05372
05377 GWEN_IPC_REQUEST *GWEN_IpcRequest_List2Iterator_Next(GWEN_IPC_REQUEST_LIST2_ITERATOR *li);
05378
05383 GWEN_IPC_REQUEST *GWEN_IpcRequest_List2Iterator_Data(GWEN_IPC_REQUEST_LIST2_ITERATOR *li);
05384
05396 GWEN_IPC_REQUEST *GWEN_IpcRequest_List2_ForEach(GWEN_IPC_REQUEST_LIST2 *list,
05397 GWEN_IPC_REQUEST_LIST2_FOREACH func,
05398 void *user_data);
05399
05400
05401 typedef struct GWEN_IPC_REQUEST_CONSTLIST2 GWEN_IPC_REQUEST_CONSTLIST2;
05402 typedef struct GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR;
05403 typedef const GWEN_IPC_REQUEST*
05404 (GWEN_IPC_REQUEST_CONSTLIST2_FOREACH)(const GWEN_IPC_REQUEST *element,
05405 void *user_data);
05406
05407
05408 GWEN_IPC_REQUEST_CONSTLIST2 *GWEN_IpcRequest_ConstList2_new();
05409
05410 void GWEN_IpcRequest_ConstList2_free(GWEN_IPC_REQUEST_CONSTLIST2 *l);
05411
05412 void GWEN_IpcRequest_ConstList2_PushBack(GWEN_IPC_REQUEST_CONSTLIST2 *l, const GWEN_IPC_REQUEST *p);
05413
05414 void GWEN_IpcRequest_ConstList2_PushFront(GWEN_IPC_REQUEST_CONSTLIST2 *l, const GWEN_IPC_REQUEST *p);
05415
05416 const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2_GetFront(GWEN_IPC_REQUEST_CONSTLIST2 *l);
05417
05418 const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2_GetBack(GWEN_IPC_REQUEST_CONSTLIST2 *l);
05419
05420 unsigned int GWEN_IpcRequest_ConstList2_GetSize(GWEN_IPC_REQUEST_CONSTLIST2 *l);
05421
05422 void GWEN_IpcRequest_ConstList2_PopBack(GWEN_IPC_REQUEST_CONSTLIST2 *l);
05423
05424 void GWEN_IpcRequest_ConstList2_PopFront(GWEN_IPC_REQUEST_CONSTLIST2 *l);
05425
05426 void GWEN_IpcRequest_ConstList2_Clear(GWEN_IPC_REQUEST_CONSTLIST2 *l);
05427
05428 GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *GWEN_IpcRequest_ConstList2_First(GWEN_IPC_REQUEST_CONSTLIST2 *l);
05429
05430 GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *GWEN_IpcRequest_ConstList2_Last(GWEN_IPC_REQUEST_CONSTLIST2 *l);
05431
05432 GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *GWEN_IpcRequest_ConstList2Iterator_new(GWEN_IPC_REQUEST_CONSTLIST2 *l);
05433
05434 void GWEN_IpcRequest_ConstList2Iterator_free(GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *li);
05435
05436 const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2Iterator_Previous(GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *li);
05437
05438 const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2Iterator_Next(GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *li);
05439
05440 const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2Iterator_Data(GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *li);
05441
05453 const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2_ForEach(GWEN_IPC_REQUEST_CONSTLIST2 *list,
05454 GWEN_IPC_REQUEST_CONSTLIST2_FOREACH func, void *user_data);
05455
05456
05457 #ifdef __cplusplus
05458 }
05459 #endif
05460
05461
05462 #endif
05463
05464
05465
05466
05467
05468
05469
05470
05471
05472
05473
05474
05475
05476
05477
05478
05479
05480
05481
05482
05483
05484
05485
05486
05487
05488
05489
05490
05491
05492
05493
05494 #ifndef GWEN_IPC_REQUEST_LIST1_H
05495 #define GWEN_IPC_REQUEST_LIST1_H
05496
05497 #ifdef __cplusplus
05498 extern "C" {
05499 #endif
05500
05502 typedef struct GWEN_IPC_REQUEST_LIST_ELEMENT {
05503 uint32_t id;
05504 GWEN_IPC_REQUEST *nextObject;
05505 } GWEN_IPC_REQUEST_LIST__ELEMENT;
05506
05513 typedef struct GWEN_IPC_REQUEST_LIST GWEN_IPC_REQUEST_LIST;
05515 struct GWEN_IPC_REQUEST_LIST {
05516 GWEN_IPC_REQUEST *first;
05517 uint32_t count;
05518 uint32_t id;
05519 } GWEN_IPC_REQUEST_LIST;
05520
05525 void GWEN_IpcRequest_List_AddList(GWEN_IPC_REQUEST_LIST *dst, GWEN_IPC_REQUEST_LIST *l);
05526
05530 void GWEN_IpcRequest_List_Add(GWEN_IPC_REQUEST *element, GWEN_IPC_REQUEST_LIST *list);
05531
05536 void GWEN_IpcRequest_List_Insert(GWEN_IPC_REQUEST *element, GWEN_IPC_REQUEST_LIST *list);
05537
05544 void GWEN_IpcRequest_List_Del(GWEN_IPC_REQUEST *element);
05545
05549 GWEN_IPC_REQUEST* GWEN_IpcRequest_List_First(const GWEN_IPC_REQUEST_LIST *l);
05550
05554 GWEN_IPC_REQUEST* GWEN_IpcRequest_List_Last(const GWEN_IPC_REQUEST_LIST *l);
05555
05560 void GWEN_IpcRequest_List_Clear(GWEN_IPC_REQUEST_LIST *l);
05561
05565 GWEN_IPC_REQUEST_LIST* GWEN_IpcRequest_List_new();
05566
05570 void GWEN_IpcRequest_List_free(GWEN_IPC_REQUEST_LIST *l);
05571
05575 GWEN_IPC_REQUEST* GWEN_IpcRequest_List_Next(const GWEN_IPC_REQUEST *element);
05576
05580 GWEN_IPC_REQUEST* GWEN_IpcRequest_List_Previous(const GWEN_IPC_REQUEST *element);
05581
05585 uint32_t GWEN_IpcRequest_List_GetCount(const GWEN_IPC_REQUEST_LIST *l);
05586
05587 #ifdef __cplusplus
05588 }
05589 #endif
05590
05591
05592 #endif
05593
05594
05595
05596
05597
05598
05599
05600
05601
05602
05603
05604
05605
05606
05607
05608
05609
05610
05611
05612
05613
05614
05615
05616
05617
05618
05619
05620
05621
05622
05623
05624 #ifndef GWEN_FSLOCK_LIST2_H
05625 #define GWEN_FSLOCK_LIST2_H
05626
05627
05628 #ifdef __cplusplus
05629 extern "C" {
05630 #endif
05631
05638 typedef struct GWEN_FSLOCK_LIST2 GWEN_FSLOCK_LIST2;
05639
05643 typedef struct GWEN_FSLOCK_LIST2_ITERATOR GWEN_FSLOCK_LIST2_ITERATOR;
05644
05648 typedef GWEN_FSLOCK* (GWEN_FSLOCK_LIST2_FOREACH)(GWEN_FSLOCK *element,
05649 void *user_data);
05650
05654 GWEN_FSLOCK_LIST2 *GWEN_FSLock_List2_new();
05655
05659 void GWEN_FSLock_List2_free(GWEN_FSLOCK_LIST2 *l);
05660
05664 void GWEN_FSLock_List2_Dump(GWEN_FSLOCK_LIST2 *l, FILE *f, unsigned int indent);
05665
05669 void GWEN_FSLock_List2_PushBack(GWEN_FSLOCK_LIST2 *l, GWEN_FSLOCK *p);
05670
05675 void GWEN_FSLock_List2_PushFront(GWEN_FSLOCK_LIST2 *l, GWEN_FSLOCK *p);
05676
05681 GWEN_FSLOCK *GWEN_FSLock_List2_GetFront(GWEN_FSLOCK_LIST2 *l);
05682
05687 GWEN_FSLOCK *GWEN_FSLock_List2_GetBack(GWEN_FSLOCK_LIST2 *l);
05688
05693 void GWEN_FSLock_List2_Erase(GWEN_FSLOCK_LIST2 *l,
05694 GWEN_FSLOCK_LIST2_ITERATOR *it);
05695
05701 unsigned int GWEN_FSLock_List2_GetSize(GWEN_FSLOCK_LIST2 *l);
05702
05707 void GWEN_FSLock_List2_PopBack(GWEN_FSLOCK_LIST2 *l);
05708
05713 void GWEN_FSLock_List2_PopFront(GWEN_FSLOCK_LIST2 *l);
05714
05718 void GWEN_FSLock_List2_Clear(GWEN_FSLOCK_LIST2 *l);
05719
05723 GWEN_FSLOCK_LIST2_ITERATOR *GWEN_FSLock_List2_First(GWEN_FSLOCK_LIST2 *l);
05724
05728 GWEN_FSLOCK_LIST2_ITERATOR *GWEN_FSLock_List2_Last(GWEN_FSLOCK_LIST2 *l);
05729
05733 GWEN_FSLOCK_LIST2_ITERATOR *GWEN_FSLock_List2Iterator_new(GWEN_FSLOCK_LIST2 *l);
05734
05738 void GWEN_FSLock_List2Iterator_free(GWEN_FSLOCK_LIST2_ITERATOR *li);
05739
05744 GWEN_FSLOCK *GWEN_FSLock_List2Iterator_Previous(GWEN_FSLOCK_LIST2_ITERATOR *li);
05745
05750 GWEN_FSLOCK *GWEN_FSLock_List2Iterator_Next(GWEN_FSLOCK_LIST2_ITERATOR *li);
05751
05756 GWEN_FSLOCK *GWEN_FSLock_List2Iterator_Data(GWEN_FSLOCK_LIST2_ITERATOR *li);
05757
05769 GWEN_FSLOCK *GWEN_FSLock_List2_ForEach(GWEN_FSLOCK_LIST2 *list,
05770 GWEN_FSLOCK_LIST2_FOREACH func,
05771 void *user_data);
05772
05773
05774 typedef struct GWEN_FSLOCK_CONSTLIST2 GWEN_FSLOCK_CONSTLIST2;
05775 typedef struct GWEN_FSLOCK_CONSTLIST2_ITERATOR GWEN_FSLOCK_CONSTLIST2_ITERATOR;
05776 typedef const GWEN_FSLOCK*
05777 (GWEN_FSLOCK_CONSTLIST2_FOREACH)(const GWEN_FSLOCK *element,
05778 void *user_data);
05779
05780
05781 GWEN_FSLOCK_CONSTLIST2 *GWEN_FSLock_ConstList2_new();
05782
05783 void GWEN_FSLock_ConstList2_free(GWEN_FSLOCK_CONSTLIST2 *l);
05784
05785 void GWEN_FSLock_ConstList2_PushBack(GWEN_FSLOCK_CONSTLIST2 *l, const GWEN_FSLOCK *p);
05786
05787 void GWEN_FSLock_ConstList2_PushFront(GWEN_FSLOCK_CONSTLIST2 *l, const GWEN_FSLOCK *p);
05788
05789 const GWEN_FSLOCK *GWEN_FSLock_ConstList2_GetFront(GWEN_FSLOCK_CONSTLIST2 *l);
05790
05791 const GWEN_FSLOCK *GWEN_FSLock_ConstList2_GetBack(GWEN_FSLOCK_CONSTLIST2 *l);
05792
05793 unsigned int GWEN_FSLock_ConstList2_GetSize(GWEN_FSLOCK_CONSTLIST2 *l);
05794
05795 void GWEN_FSLock_ConstList2_PopBack(GWEN_FSLOCK_CONSTLIST2 *l);
05796
05797 void GWEN_FSLock_ConstList2_PopFront(GWEN_FSLOCK_CONSTLIST2 *l);
05798
05799 void GWEN_FSLock_ConstList2_Clear(GWEN_FSLOCK_CONSTLIST2 *l);
05800
05801 GWEN_FSLOCK_CONSTLIST2_ITERATOR *GWEN_FSLock_ConstList2_First(GWEN_FSLOCK_CONSTLIST2 *l);
05802
05803 GWEN_FSLOCK_CONSTLIST2_ITERATOR *GWEN_FSLock_ConstList2_Last(GWEN_FSLOCK_CONSTLIST2 *l);
05804
05805 GWEN_FSLOCK_CONSTLIST2_ITERATOR *GWEN_FSLock_ConstList2Iterator_new(GWEN_FSLOCK_CONSTLIST2 *l);
05806
05807 void GWEN_FSLock_ConstList2Iterator_free(GWEN_FSLOCK_CONSTLIST2_ITERATOR *li);
05808
05809 const GWEN_FSLOCK *GWEN_FSLock_ConstList2Iterator_Previous(GWEN_FSLOCK_CONSTLIST2_ITERATOR *li);
05810
05811 const GWEN_FSLOCK *GWEN_FSLock_ConstList2Iterator_Next(GWEN_FSLOCK_CONSTLIST2_ITERATOR *li);
05812
05813 const GWEN_FSLOCK *GWEN_FSLock_ConstList2Iterator_Data(GWEN_FSLOCK_CONSTLIST2_ITERATOR *li);
05814
05826 const GWEN_FSLOCK *GWEN_FSLock_ConstList2_ForEach(GWEN_FSLOCK_CONSTLIST2 *list,
05827 GWEN_FSLOCK_CONSTLIST2_FOREACH func, void *user_data);
05828
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_FSLOCK_LIST1_H
05868 #define GWEN_FSLOCK_LIST1_H
05869
05870 #ifdef __cplusplus
05871 extern "C" {
05872 #endif
05873
05875 typedef struct GWEN_FSLOCK_LIST_ELEMENT {
05876 uint32_t id;
05877 GWEN_FSLOCK *nextObject;
05878 } GWEN_FSLOCK_LIST__ELEMENT;
05879
05886 typedef struct GWEN_FSLOCK_LIST GWEN_FSLOCK_LIST;
05888 struct GWEN_FSLOCK_LIST {
05889 GWEN_FSLOCK *first;
05890 uint32_t count;
05891 uint32_t id;
05892 } GWEN_FSLOCK_LIST;
05893
05898 void GWEN_FSLock_List_AddList(GWEN_FSLOCK_LIST *dst, GWEN_FSLOCK_LIST *l);
05899
05903 void GWEN_FSLock_List_Add(GWEN_FSLOCK *element, GWEN_FSLOCK_LIST *list);
05904
05909 void GWEN_FSLock_List_Insert(GWEN_FSLOCK *element, GWEN_FSLOCK_LIST *list);
05910
05917 void GWEN_FSLock_List_Del(GWEN_FSLOCK *element);
05918
05922 GWEN_FSLOCK* GWEN_FSLock_List_First(const GWEN_FSLOCK_LIST *l);
05923
05927 GWEN_FSLOCK* GWEN_FSLock_List_Last(const GWEN_FSLOCK_LIST *l);
05928
05933 void GWEN_FSLock_List_Clear(GWEN_FSLOCK_LIST *l);
05934
05938 GWEN_FSLOCK_LIST* GWEN_FSLock_List_new();
05939
05943 void GWEN_FSLock_List_free(GWEN_FSLOCK_LIST *l);
05944
05948 GWEN_FSLOCK* GWEN_FSLock_List_Next(const GWEN_FSLOCK *element);
05949
05953 GWEN_FSLOCK* GWEN_FSLock_List_Previous(const GWEN_FSLOCK *element);
05954
05958 uint32_t GWEN_FSLock_List_GetCount(const GWEN_FSLOCK_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_SOCKET_LIST2_H
05998 #define GWEN_SOCKET_LIST2_H
05999
06000
06001 #ifdef __cplusplus
06002 extern "C" {
06003 #endif
06004
06011 typedef struct GWEN_SOCKET_LIST2 GWEN_SOCKET_LIST2;
06012
06016 typedef struct GWEN_SOCKET_LIST2_ITERATOR GWEN_SOCKET_LIST2_ITERATOR;
06017
06021 typedef GWEN_SOCKET* (GWEN_SOCKET_LIST2_FOREACH)(GWEN_SOCKET *element,
06022 void *user_data);
06023
06027 GWEN_SOCKET_LIST2 *GWEN_Socket_List2_new();
06028
06032 void GWEN_Socket_List2_free(GWEN_SOCKET_LIST2 *l);
06033
06037 void GWEN_Socket_List2_Dump(GWEN_SOCKET_LIST2 *l, FILE *f, unsigned int indent);
06038
06042 void GWEN_Socket_List2_PushBack(GWEN_SOCKET_LIST2 *l, GWEN_SOCKET *p);
06043
06048 void GWEN_Socket_List2_PushFront(GWEN_SOCKET_LIST2 *l, GWEN_SOCKET *p);
06049
06054 GWEN_SOCKET *GWEN_Socket_List2_GetFront(GWEN_SOCKET_LIST2 *l);
06055
06060 GWEN_SOCKET *GWEN_Socket_List2_GetBack(GWEN_SOCKET_LIST2 *l);
06061
06066 void GWEN_Socket_List2_Erase(GWEN_SOCKET_LIST2 *l,
06067 GWEN_SOCKET_LIST2_ITERATOR *it);
06068
06074 unsigned int GWEN_Socket_List2_GetSize(GWEN_SOCKET_LIST2 *l);
06075
06080 void GWEN_Socket_List2_PopBack(GWEN_SOCKET_LIST2 *l);
06081
06086 void GWEN_Socket_List2_PopFront(GWEN_SOCKET_LIST2 *l);
06087
06091 void GWEN_Socket_List2_Clear(GWEN_SOCKET_LIST2 *l);
06092
06096 GWEN_SOCKET_LIST2_ITERATOR *GWEN_Socket_List2_First(GWEN_SOCKET_LIST2 *l);
06097
06101 GWEN_SOCKET_LIST2_ITERATOR *GWEN_Socket_List2_Last(GWEN_SOCKET_LIST2 *l);
06102
06106 GWEN_SOCKET_LIST2_ITERATOR *GWEN_Socket_List2Iterator_new(GWEN_SOCKET_LIST2 *l);
06107
06111 void GWEN_Socket_List2Iterator_free(GWEN_SOCKET_LIST2_ITERATOR *li);
06112
06117 GWEN_SOCKET *GWEN_Socket_List2Iterator_Previous(GWEN_SOCKET_LIST2_ITERATOR *li);
06118
06123 GWEN_SOCKET *GWEN_Socket_List2Iterator_Next(GWEN_SOCKET_LIST2_ITERATOR *li);
06124
06129 GWEN_SOCKET *GWEN_Socket_List2Iterator_Data(GWEN_SOCKET_LIST2_ITERATOR *li);
06130
06142 GWEN_SOCKET *GWEN_Socket_List2_ForEach(GWEN_SOCKET_LIST2 *list,
06143 GWEN_SOCKET_LIST2_FOREACH func,
06144 void *user_data);
06145
06146
06147 typedef struct GWEN_SOCKET_CONSTLIST2 GWEN_SOCKET_CONSTLIST2;
06148 typedef struct GWEN_SOCKET_CONSTLIST2_ITERATOR GWEN_SOCKET_CONSTLIST2_ITERATOR;
06149 typedef const GWEN_SOCKET*
06150 (GWEN_SOCKET_CONSTLIST2_FOREACH)(const GWEN_SOCKET *element,
06151 void *user_data);
06152
06153
06154 GWEN_SOCKET_CONSTLIST2 *GWEN_Socket_ConstList2_new();
06155
06156 void GWEN_Socket_ConstList2_free(GWEN_SOCKET_CONSTLIST2 *l);
06157
06158 void GWEN_Socket_ConstList2_PushBack(GWEN_SOCKET_CONSTLIST2 *l, const GWEN_SOCKET *p);
06159
06160 void GWEN_Socket_ConstList2_PushFront(GWEN_SOCKET_CONSTLIST2 *l, const GWEN_SOCKET *p);
06161
06162 const GWEN_SOCKET *GWEN_Socket_ConstList2_GetFront(GWEN_SOCKET_CONSTLIST2 *l);
06163
06164 const GWEN_SOCKET *GWEN_Socket_ConstList2_GetBack(GWEN_SOCKET_CONSTLIST2 *l);
06165
06166 unsigned int GWEN_Socket_ConstList2_GetSize(GWEN_SOCKET_CONSTLIST2 *l);
06167
06168 void GWEN_Socket_ConstList2_PopBack(GWEN_SOCKET_CONSTLIST2 *l);
06169
06170 void GWEN_Socket_ConstList2_PopFront(GWEN_SOCKET_CONSTLIST2 *l);
06171
06172 void GWEN_Socket_ConstList2_Clear(GWEN_SOCKET_CONSTLIST2 *l);
06173
06174 GWEN_SOCKET_CONSTLIST2_ITERATOR *GWEN_Socket_ConstList2_First(GWEN_SOCKET_CONSTLIST2 *l);
06175
06176 GWEN_SOCKET_CONSTLIST2_ITERATOR *GWEN_Socket_ConstList2_Last(GWEN_SOCKET_CONSTLIST2 *l);
06177
06178 GWEN_SOCKET_CONSTLIST2_ITERATOR *GWEN_Socket_ConstList2Iterator_new(GWEN_SOCKET_CONSTLIST2 *l);
06179
06180 void GWEN_Socket_ConstList2Iterator_free(GWEN_SOCKET_CONSTLIST2_ITERATOR *li);
06181
06182 const GWEN_SOCKET *GWEN_Socket_ConstList2Iterator_Previous(GWEN_SOCKET_CONSTLIST2_ITERATOR *li);
06183
06184 const GWEN_SOCKET *GWEN_Socket_ConstList2Iterator_Next(GWEN_SOCKET_CONSTLIST2_ITERATOR *li);
06185
06186 const GWEN_SOCKET *GWEN_Socket_ConstList2Iterator_Data(GWEN_SOCKET_CONSTLIST2_ITERATOR *li);
06187
06199 const GWEN_SOCKET *GWEN_Socket_ConstList2_ForEach(GWEN_SOCKET_CONSTLIST2 *list,
06200 GWEN_SOCKET_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_SOCKET_LIST1_H
06241 #define GWEN_SOCKET_LIST1_H
06242
06243 #ifdef __cplusplus
06244 extern "C" {
06245 #endif
06246
06248 typedef struct GWEN_SOCKET_LIST_ELEMENT {
06249 uint32_t id;
06250 GWEN_SOCKET *nextObject;
06251 } GWEN_SOCKET_LIST__ELEMENT;
06252
06259 typedef struct GWEN_SOCKET_LIST GWEN_SOCKET_LIST;
06261 struct GWEN_SOCKET_LIST {
06262 GWEN_SOCKET *first;
06263 uint32_t count;
06264 uint32_t id;
06265 } GWEN_SOCKET_LIST;
06266
06271 void GWEN_Socket_List_AddList(GWEN_SOCKET_LIST *dst, GWEN_SOCKET_LIST *l);
06272
06276 void GWEN_Socket_List_Add(GWEN_SOCKET *element, GWEN_SOCKET_LIST *list);
06277
06282 void GWEN_Socket_List_Insert(GWEN_SOCKET *element, GWEN_SOCKET_LIST *list);
06283
06290 void GWEN_Socket_List_Del(GWEN_SOCKET *element);
06291
06295 GWEN_SOCKET* GWEN_Socket_List_First(const GWEN_SOCKET_LIST *l);
06296
06300 GWEN_SOCKET* GWEN_Socket_List_Last(const GWEN_SOCKET_LIST *l);
06301
06306 void GWEN_Socket_List_Clear(GWEN_SOCKET_LIST *l);
06307
06311 GWEN_SOCKET_LIST* GWEN_Socket_List_new();
06312
06316 void GWEN_Socket_List_free(GWEN_SOCKET_LIST *l);
06317
06321 GWEN_SOCKET* GWEN_Socket_List_Next(const GWEN_SOCKET *element);
06322
06326 GWEN_SOCKET* GWEN_Socket_List_Previous(const GWEN_SOCKET *element);
06327
06331 uint32_t GWEN_Socket_List_GetCount(const GWEN_SOCKET_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_DBIO_LIST1_H
06371 #define GWEN_DBIO_LIST1_H
06372
06373 #ifdef __cplusplus
06374 extern "C" {
06375 #endif
06376
06378 typedef struct GWEN_DBIO_LIST_ELEMENT {
06379 uint32_t id;
06380 GWEN_DBIO *nextObject;
06381 } GWEN_DBIO_LIST__ELEMENT;
06382
06389 typedef struct GWEN_DBIO_LIST GWEN_DBIO_LIST;
06391 struct GWEN_DBIO_LIST {
06392 GWEN_DBIO *first;
06393 uint32_t count;
06394 uint32_t id;
06395 } GWEN_DBIO_LIST;
06396
06401 void GWEN_DBIO_List_AddList(GWEN_DBIO_LIST *dst, GWEN_DBIO_LIST *l);
06402
06406 void GWEN_DBIO_List_Add(GWEN_DBIO *element, GWEN_DBIO_LIST *list);
06407
06412 void GWEN_DBIO_List_Insert(GWEN_DBIO *element, GWEN_DBIO_LIST *list);
06413
06420 void GWEN_DBIO_List_Del(GWEN_DBIO *element);
06421
06425 GWEN_DBIO* GWEN_DBIO_List_First(const GWEN_DBIO_LIST *l);
06426
06430 GWEN_DBIO* GWEN_DBIO_List_Last(const GWEN_DBIO_LIST *l);
06431
06436 void GWEN_DBIO_List_Clear(GWEN_DBIO_LIST *l);
06437
06441 GWEN_DBIO_LIST* GWEN_DBIO_List_new();
06442
06446 void GWEN_DBIO_List_free(GWEN_DBIO_LIST *l);
06447
06451 GWEN_DBIO* GWEN_DBIO_List_Next(const GWEN_DBIO *element);
06452
06456 GWEN_DBIO* GWEN_DBIO_List_Previous(const GWEN_DBIO *element);
06457
06461 uint32_t GWEN_DBIO_List_GetCount(const GWEN_DBIO_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_TAG16_LIST1_H
06501 #define GWEN_TAG16_LIST1_H
06502
06503 #ifdef __cplusplus
06504 extern "C" {
06505 #endif
06506
06508 typedef struct GWEN_TAG16_LIST_ELEMENT {
06509 uint32_t id;
06510 GWEN_TAG16 *nextObject;
06511 } GWEN_TAG16_LIST__ELEMENT;
06512
06519 typedef struct GWEN_TAG16_LIST GWEN_TAG16_LIST;
06521 struct GWEN_TAG16_LIST {
06522 GWEN_TAG16 *first;
06523 uint32_t count;
06524 uint32_t id;
06525 } GWEN_TAG16_LIST;
06526
06531 void GWEN_Tag16_List_AddList(GWEN_TAG16_LIST *dst, GWEN_TAG16_LIST *l);
06532
06536 void GWEN_Tag16_List_Add(GWEN_TAG16 *element, GWEN_TAG16_LIST *list);
06537
06542 void GWEN_Tag16_List_Insert(GWEN_TAG16 *element, GWEN_TAG16_LIST *list);
06543
06550 void GWEN_Tag16_List_Del(GWEN_TAG16 *element);
06551
06555 GWEN_TAG16* GWEN_Tag16_List_First(const GWEN_TAG16_LIST *l);
06556
06560 GWEN_TAG16* GWEN_Tag16_List_Last(const GWEN_TAG16_LIST *l);
06561
06566 void GWEN_Tag16_List_Clear(GWEN_TAG16_LIST *l);
06567
06571 GWEN_TAG16_LIST* GWEN_Tag16_List_new();
06572
06576 void GWEN_Tag16_List_free(GWEN_TAG16_LIST *l);
06577
06581 GWEN_TAG16* GWEN_Tag16_List_Next(const GWEN_TAG16 *element);
06582
06586 GWEN_TAG16* GWEN_Tag16_List_Previous(const GWEN_TAG16 *element);
06587
06591 uint32_t GWEN_Tag16_List_GetCount(const GWEN_TAG16_LIST *l);
06592
06593 #ifdef __cplusplus
06594 }
06595 #endif
06596
06597
06598 #endif
06599
06600
06601
06602
06603
06604
06605
06606
06607
06608
06609
06610
06611
06612
06613
06614
06615
06616
06617
06618
06619
06620
06621
06622
06623
06624
06625
06626
06627
06628
06629
06630 #ifndef GWEN_TLV_LIST1_H
06631 #define GWEN_TLV_LIST1_H
06632
06633 #ifdef __cplusplus
06634 extern "C" {
06635 #endif
06636
06638 typedef struct GWEN_TLV_LIST_ELEMENT {
06639 uint32_t id;
06640 GWEN_TLV *nextObject;
06641 } GWEN_TLV_LIST__ELEMENT;
06642
06649 typedef struct GWEN_TLV_LIST GWEN_TLV_LIST;
06651 struct GWEN_TLV_LIST {
06652 GWEN_TLV *first;
06653 uint32_t count;
06654 uint32_t id;
06655 } GWEN_TLV_LIST;
06656
06661 void GWEN_TLV_List_AddList(GWEN_TLV_LIST *dst, GWEN_TLV_LIST *l);
06662
06666 void GWEN_TLV_List_Add(GWEN_TLV *element, GWEN_TLV_LIST *list);
06667
06672 void GWEN_TLV_List_Insert(GWEN_TLV *element, GWEN_TLV_LIST *list);
06673
06680 void GWEN_TLV_List_Del(GWEN_TLV *element);
06681
06685 GWEN_TLV* GWEN_TLV_List_First(const GWEN_TLV_LIST *l);
06686
06690 GWEN_TLV* GWEN_TLV_List_Last(const GWEN_TLV_LIST *l);
06691
06696 void GWEN_TLV_List_Clear(GWEN_TLV_LIST *l);
06697
06701 GWEN_TLV_LIST* GWEN_TLV_List_new();
06702
06706 void GWEN_TLV_List_free(GWEN_TLV_LIST *l);
06707
06711 GWEN_TLV* GWEN_TLV_List_Next(const GWEN_TLV *element);
06712
06716 GWEN_TLV* GWEN_TLV_List_Previous(const GWEN_TLV *element);
06717
06721 uint32_t GWEN_TLV_List_GetCount(const GWEN_TLV_LIST *l);
06722
06723 #ifdef __cplusplus
06724 }
06725 #endif
06726
06727
06728 #endif
06729
06730
06731
06732
06733
06734
06735
06736
06737
06738
06739
06740
06741
06742
06743
06744
06745
06746
06747
06748
06749
06750
06751
06752
06753
06754
06755
06756
06757
06758
06759
06760 #ifndef GWEN_URL_LIST2_H
06761 #define GWEN_URL_LIST2_H
06762
06763
06764 #ifdef __cplusplus
06765 extern "C" {
06766 #endif
06767
06774 typedef struct GWEN_URL_LIST2 GWEN_URL_LIST2;
06775
06779 typedef struct GWEN_URL_LIST2_ITERATOR GWEN_URL_LIST2_ITERATOR;
06780
06784 typedef GWEN_URL* (GWEN_URL_LIST2_FOREACH)(GWEN_URL *element,
06785 void *user_data);
06786
06790 GWEN_URL_LIST2 *GWEN_Url_List2_new();
06791
06795 void GWEN_Url_List2_free(GWEN_URL_LIST2 *l);
06796
06800 void GWEN_Url_List2_Dump(GWEN_URL_LIST2 *l, FILE *f, unsigned int indent);
06801
06805 void GWEN_Url_List2_PushBack(GWEN_URL_LIST2 *l, GWEN_URL *p);
06806
06811 void GWEN_Url_List2_PushFront(GWEN_URL_LIST2 *l, GWEN_URL *p);
06812
06817 GWEN_URL *GWEN_Url_List2_GetFront(GWEN_URL_LIST2 *l);
06818
06823 GWEN_URL *GWEN_Url_List2_GetBack(GWEN_URL_LIST2 *l);
06824
06829 void GWEN_Url_List2_Erase(GWEN_URL_LIST2 *l,
06830 GWEN_URL_LIST2_ITERATOR *it);
06831
06837 unsigned int GWEN_Url_List2_GetSize(GWEN_URL_LIST2 *l);
06838
06843 void GWEN_Url_List2_PopBack(GWEN_URL_LIST2 *l);
06844
06849 void GWEN_Url_List2_PopFront(GWEN_URL_LIST2 *l);
06850
06854 void GWEN_Url_List2_Clear(GWEN_URL_LIST2 *l);
06855
06859 GWEN_URL_LIST2_ITERATOR *GWEN_Url_List2_First(GWEN_URL_LIST2 *l);
06860
06864 GWEN_URL_LIST2_ITERATOR *GWEN_Url_List2_Last(GWEN_URL_LIST2 *l);
06865
06869 GWEN_URL_LIST2_ITERATOR *GWEN_Url_List2Iterator_new(GWEN_URL_LIST2 *l);
06870
06874 void GWEN_Url_List2Iterator_free(GWEN_URL_LIST2_ITERATOR *li);
06875
06880 GWEN_URL *GWEN_Url_List2Iterator_Previous(GWEN_URL_LIST2_ITERATOR *li);
06881
06886 GWEN_URL *GWEN_Url_List2Iterator_Next(GWEN_URL_LIST2_ITERATOR *li);
06887
06892 GWEN_URL *GWEN_Url_List2Iterator_Data(GWEN_URL_LIST2_ITERATOR *li);
06893
06905 GWEN_URL *GWEN_Url_List2_ForEach(GWEN_URL_LIST2 *list,
06906 GWEN_URL_LIST2_FOREACH func,
06907 void *user_data);
06908
06909
06910 typedef struct GWEN_URL_CONSTLIST2 GWEN_URL_CONSTLIST2;
06911 typedef struct GWEN_URL_CONSTLIST2_ITERATOR GWEN_URL_CONSTLIST2_ITERATOR;
06912 typedef const GWEN_URL*
06913 (GWEN_URL_CONSTLIST2_FOREACH)(const GWEN_URL *element,
06914 void *user_data);
06915
06916
06917 GWEN_URL_CONSTLIST2 *GWEN_Url_ConstList2_new();
06918
06919 void GWEN_Url_ConstList2_free(GWEN_URL_CONSTLIST2 *l);
06920
06921 void GWEN_Url_ConstList2_PushBack(GWEN_URL_CONSTLIST2 *l, const GWEN_URL *p);
06922
06923 void GWEN_Url_ConstList2_PushFront(GWEN_URL_CONSTLIST2 *l, const GWEN_URL *p);
06924
06925 const GWEN_URL *GWEN_Url_ConstList2_GetFront(GWEN_URL_CONSTLIST2 *l);
06926
06927 const GWEN_URL *GWEN_Url_ConstList2_GetBack(GWEN_URL_CONSTLIST2 *l);
06928
06929 unsigned int GWEN_Url_ConstList2_GetSize(GWEN_URL_CONSTLIST2 *l);
06930
06931 void GWEN_Url_ConstList2_PopBack(GWEN_URL_CONSTLIST2 *l);
06932
06933 void GWEN_Url_ConstList2_PopFront(GWEN_URL_CONSTLIST2 *l);
06934
06935 void GWEN_Url_ConstList2_Clear(GWEN_URL_CONSTLIST2 *l);
06936
06937 GWEN_URL_CONSTLIST2_ITERATOR *GWEN_Url_ConstList2_First(GWEN_URL_CONSTLIST2 *l);
06938
06939 GWEN_URL_CONSTLIST2_ITERATOR *GWEN_Url_ConstList2_Last(GWEN_URL_CONSTLIST2 *l);
06940
06941 GWEN_URL_CONSTLIST2_ITERATOR *GWEN_Url_ConstList2Iterator_new(GWEN_URL_CONSTLIST2 *l);
06942
06943 void GWEN_Url_ConstList2Iterator_free(GWEN_URL_CONSTLIST2_ITERATOR *li);
06944
06945 const GWEN_URL *GWEN_Url_ConstList2Iterator_Previous(GWEN_URL_CONSTLIST2_ITERATOR *li);
06946
06947 const GWEN_URL *GWEN_Url_ConstList2Iterator_Next(GWEN_URL_CONSTLIST2_ITERATOR *li);
06948
06949 const GWEN_URL *GWEN_Url_ConstList2Iterator_Data(GWEN_URL_CONSTLIST2_ITERATOR *li);
06950
06962 const GWEN_URL *GWEN_Url_ConstList2_ForEach(GWEN_URL_CONSTLIST2 *list,
06963 GWEN_URL_CONSTLIST2_FOREACH func, void *user_data);
06964
06965
06966 #ifdef __cplusplus
06967 }
06968 #endif
06969
06970
06971 #endif
06972
06973
06974
06975
06976
06977
06978
06979
06980
06981
06982
06983
06984
06985
06986
06987
06988
06989
06990
06991
06992
06993
06994
06995
06996
06997
06998
06999
07000
07001
07002
07003 #ifndef GWEN_URL_LIST1_H
07004 #define GWEN_URL_LIST1_H
07005
07006 #ifdef __cplusplus
07007 extern "C" {
07008 #endif
07009
07011 typedef struct GWEN_URL_LIST_ELEMENT {
07012 uint32_t id;
07013 GWEN_URL *nextObject;
07014 } GWEN_URL_LIST__ELEMENT;
07015
07022 typedef struct GWEN_URL_LIST GWEN_URL_LIST;
07024 struct GWEN_URL_LIST {
07025 GWEN_URL *first;
07026 uint32_t count;
07027 uint32_t id;
07028 } GWEN_URL_LIST;
07029
07034 void GWEN_Url_List_AddList(GWEN_URL_LIST *dst, GWEN_URL_LIST *l);
07035
07039 void GWEN_Url_List_Add(GWEN_URL *element, GWEN_URL_LIST *list);
07040
07045 void GWEN_Url_List_Insert(GWEN_URL *element, GWEN_URL_LIST *list);
07046
07053 void GWEN_Url_List_Del(GWEN_URL *element);
07054
07058 GWEN_URL* GWEN_Url_List_First(const GWEN_URL_LIST *l);
07059
07063 GWEN_URL* GWEN_Url_List_Last(const GWEN_URL_LIST *l);
07064
07069 void GWEN_Url_List_Clear(GWEN_URL_LIST *l);
07070
07074 GWEN_URL_LIST* GWEN_Url_List_new();
07075
07079 void GWEN_Url_List_free(GWEN_URL_LIST *l);
07080
07084 GWEN_URL* GWEN_Url_List_Next(const GWEN_URL *element);
07085
07089 GWEN_URL* GWEN_Url_List_Previous(const GWEN_URL *element);
07090
07094 uint32_t GWEN_Url_List_GetCount(const GWEN_URL_LIST *l);
07095
07096 #ifdef __cplusplus
07097 }
07098 #endif
07099
07100
07101 #endif
07102
07103
07104
07105
07106
07107
07108
07109
07110
07111
07112
07113
07114
07115
07116
07117
07118
07119
07120
07121
07122
07123
07124
07125
07126
07127
07128
07129
07130
07131
07132
07133 #ifndef GWEN_XMLNODE_NAMESPACE_LIST1_H
07134 #define GWEN_XMLNODE_NAMESPACE_LIST1_H
07135
07136 #ifdef __cplusplus
07137 extern "C" {
07138 #endif
07139
07141 typedef struct GWEN_XMLNODE_NAMESPACE_LIST_ELEMENT {
07142 uint32_t id;
07143 GWEN_XMLNODE_NAMESPACE *nextObject;
07144 } GWEN_XMLNODE_NAMESPACE_LIST__ELEMENT;
07145
07152 typedef struct GWEN_XMLNODE_NAMESPACE_LIST GWEN_XMLNODE_NAMESPACE_LIST;
07154 struct GWEN_XMLNODE_NAMESPACE_LIST {
07155 GWEN_XMLNODE_NAMESPACE *first;
07156 uint32_t count;
07157 uint32_t id;
07158 } GWEN_XMLNODE_NAMESPACE_LIST;
07159
07164 void GWEN_XMLNode_NameSpace_List_AddList(GWEN_XMLNODE_NAMESPACE_LIST *dst, GWEN_XMLNODE_NAMESPACE_LIST *l);
07165
07169 void GWEN_XMLNode_NameSpace_List_Add(GWEN_XMLNODE_NAMESPACE *element, GWEN_XMLNODE_NAMESPACE_LIST *list);
07170
07175 void GWEN_XMLNode_NameSpace_List_Insert(GWEN_XMLNODE_NAMESPACE *element, GWEN_XMLNODE_NAMESPACE_LIST *list);
07176
07183 void GWEN_XMLNode_NameSpace_List_Del(GWEN_XMLNODE_NAMESPACE *element);
07184
07188 GWEN_XMLNODE_NAMESPACE* GWEN_XMLNode_NameSpace_List_First(const GWEN_XMLNODE_NAMESPACE_LIST *l);
07189
07193 GWEN_XMLNODE_NAMESPACE* GWEN_XMLNode_NameSpace_List_Last(const GWEN_XMLNODE_NAMESPACE_LIST *l);
07194
07199 void GWEN_XMLNode_NameSpace_List_Clear(GWEN_XMLNODE_NAMESPACE_LIST *l);
07200
07204 GWEN_XMLNODE_NAMESPACE_LIST* GWEN_XMLNode_NameSpace_List_new();
07205
07209 void GWEN_XMLNode_NameSpace_List_free(GWEN_XMLNODE_NAMESPACE_LIST *l);
07210
07214 GWEN_XMLNODE_NAMESPACE* GWEN_XMLNode_NameSpace_List_Next(const GWEN_XMLNODE_NAMESPACE *element);
07215
07219 GWEN_XMLNODE_NAMESPACE* GWEN_XMLNode_NameSpace_List_Previous(const GWEN_XMLNODE_NAMESPACE *element);
07220
07224 uint32_t GWEN_XMLNode_NameSpace_List_GetCount(const GWEN_XMLNODE_NAMESPACE_LIST *l);
07225
07226 #ifdef __cplusplus
07227 }
07228 #endif
07229
07230
07231 #endif
07232
07233
07234
07235
07236
07237
07238
07239
07240
07241
07242
07243
07244
07245
07246
07247
07248
07249
07250
07251
07252
07253
07254
07255
07256
07257
07258
07259
07260
07261
07262
07263 #ifndef GWEN_XMLNODE_LIST2_H
07264 #define GWEN_XMLNODE_LIST2_H
07265
07266
07267 #ifdef __cplusplus
07268 extern "C" {
07269 #endif
07270
07277 typedef struct GWEN_XMLNODE_LIST2 GWEN_XMLNODE_LIST2;
07278
07282 typedef struct GWEN_XMLNODE_LIST2_ITERATOR GWEN_XMLNODE_LIST2_ITERATOR;
07283
07287 typedef GWEN_XMLNODE* (GWEN_XMLNODE_LIST2_FOREACH)(GWEN_XMLNODE *element,
07288 void *user_data);
07289
07293 GWEN_XMLNODE_LIST2 *GWEN_XMLNode_List2_new();
07294
07298 void GWEN_XMLNode_List2_free(GWEN_XMLNODE_LIST2 *l);
07299
07303 void GWEN_XMLNode_List2_Dump(GWEN_XMLNODE_LIST2 *l, FILE *f, unsigned int indent);
07304
07308 void GWEN_XMLNode_List2_PushBack(GWEN_XMLNODE_LIST2 *l, GWEN_XMLNODE *p);
07309
07314 void GWEN_XMLNode_List2_PushFront(GWEN_XMLNODE_LIST2 *l, GWEN_XMLNODE *p);
07315
07320 GWEN_XMLNODE *GWEN_XMLNode_List2_GetFront(GWEN_XMLNODE_LIST2 *l);
07321
07326 GWEN_XMLNODE *GWEN_XMLNode_List2_GetBack(GWEN_XMLNODE_LIST2 *l);
07327
07332 void GWEN_XMLNode_List2_Erase(GWEN_XMLNODE_LIST2 *l,
07333 GWEN_XMLNODE_LIST2_ITERATOR *it);
07334
07340 unsigned int GWEN_XMLNode_List2_GetSize(GWEN_XMLNODE_LIST2 *l);
07341
07346 void GWEN_XMLNode_List2_PopBack(GWEN_XMLNODE_LIST2 *l);
07347
07352 void GWEN_XMLNode_List2_PopFront(GWEN_XMLNODE_LIST2 *l);
07353
07357 void GWEN_XMLNode_List2_Clear(GWEN_XMLNODE_LIST2 *l);
07358
07362 GWEN_XMLNODE_LIST2_ITERATOR *GWEN_XMLNode_List2_First(GWEN_XMLNODE_LIST2 *l);
07363
07367 GWEN_XMLNODE_LIST2_ITERATOR *GWEN_XMLNode_List2_Last(GWEN_XMLNODE_LIST2 *l);
07368
07372 GWEN_XMLNODE_LIST2_ITERATOR *GWEN_XMLNode_List2Iterator_new(GWEN_XMLNODE_LIST2 *l);
07373
07377 void GWEN_XMLNode_List2Iterator_free(GWEN_XMLNODE_LIST2_ITERATOR *li);
07378
07383 GWEN_XMLNODE *GWEN_XMLNode_List2Iterator_Previous(GWEN_XMLNODE_LIST2_ITERATOR *li);
07384
07389 GWEN_XMLNODE *GWEN_XMLNode_List2Iterator_Next(GWEN_XMLNODE_LIST2_ITERATOR *li);
07390
07395 GWEN_XMLNODE *GWEN_XMLNode_List2Iterator_Data(GWEN_XMLNODE_LIST2_ITERATOR *li);
07396
07408 GWEN_XMLNODE *GWEN_XMLNode_List2_ForEach(GWEN_XMLNODE_LIST2 *list,
07409 GWEN_XMLNODE_LIST2_FOREACH func,
07410 void *user_data);
07411
07412
07413 typedef struct GWEN_XMLNODE_CONSTLIST2 GWEN_XMLNODE_CONSTLIST2;
07414 typedef struct GWEN_XMLNODE_CONSTLIST2_ITERATOR GWEN_XMLNODE_CONSTLIST2_ITERATOR;
07415 typedef const GWEN_XMLNODE*
07416 (GWEN_XMLNODE_CONSTLIST2_FOREACH)(const GWEN_XMLNODE *element,
07417 void *user_data);
07418
07419
07420 GWEN_XMLNODE_CONSTLIST2 *GWEN_XMLNode_ConstList2_new();
07421
07422 void GWEN_XMLNode_ConstList2_free(GWEN_XMLNODE_CONSTLIST2 *l);
07423
07424 void GWEN_XMLNode_ConstList2_PushBack(GWEN_XMLNODE_CONSTLIST2 *l, const GWEN_XMLNODE *p);
07425
07426 void GWEN_XMLNode_ConstList2_PushFront(GWEN_XMLNODE_CONSTLIST2 *l, const GWEN_XMLNODE *p);
07427
07428 const GWEN_XMLNODE *GWEN_XMLNode_ConstList2_GetFront(GWEN_XMLNODE_CONSTLIST2 *l);
07429
07430 const GWEN_XMLNODE *GWEN_XMLNode_ConstList2_GetBack(GWEN_XMLNODE_CONSTLIST2 *l);
07431
07432 unsigned int GWEN_XMLNode_ConstList2_GetSize(GWEN_XMLNODE_CONSTLIST2 *l);
07433
07434 void GWEN_XMLNode_ConstList2_PopBack(GWEN_XMLNODE_CONSTLIST2 *l);
07435
07436 void GWEN_XMLNode_ConstList2_PopFront(GWEN_XMLNODE_CONSTLIST2 *l);
07437
07438 void GWEN_XMLNode_ConstList2_Clear(GWEN_XMLNODE_CONSTLIST2 *l);
07439
07440 GWEN_XMLNODE_CONSTLIST2_ITERATOR *GWEN_XMLNode_ConstList2_First(GWEN_XMLNODE_CONSTLIST2 *l);
07441
07442 GWEN_XMLNODE_CONSTLIST2_ITERATOR *GWEN_XMLNode_ConstList2_Last(GWEN_XMLNODE_CONSTLIST2 *l);
07443
07444 GWEN_XMLNODE_CONSTLIST2_ITERATOR *GWEN_XMLNode_ConstList2Iterator_new(GWEN_XMLNODE_CONSTLIST2 *l);
07445
07446 void GWEN_XMLNode_ConstList2Iterator_free(GWEN_XMLNODE_CONSTLIST2_ITERATOR *li);
07447
07448 const GWEN_XMLNODE *GWEN_XMLNode_ConstList2Iterator_Previous(GWEN_XMLNODE_CONSTLIST2_ITERATOR *li);
07449
07450 const GWEN_XMLNODE *GWEN_XMLNode_ConstList2Iterator_Next(GWEN_XMLNODE_CONSTLIST2_ITERATOR *li);
07451
07452 const GWEN_XMLNODE *GWEN_XMLNode_ConstList2Iterator_Data(GWEN_XMLNODE_CONSTLIST2_ITERATOR *li);
07453
07465 const GWEN_XMLNODE *GWEN_XMLNode_ConstList2_ForEach(GWEN_XMLNODE_CONSTLIST2 *list,
07466 GWEN_XMLNODE_CONSTLIST2_FOREACH func, void *user_data);
07467
07468
07469 #ifdef __cplusplus
07470 }
07471 #endif
07472
07473
07474 #endif
07475
07476
07477
07478
07479
07480
07481
07482
07483
07484
07485
07486
07487
07488
07489
07490
07491
07492
07493
07494
07495
07496
07497
07498
07499
07500
07501
07502
07503
07504
07505
07506 #ifndef GWEN_XMLNODE_LIST1_H
07507 #define GWEN_XMLNODE_LIST1_H
07508
07509 #ifdef __cplusplus
07510 extern "C" {
07511 #endif
07512
07514 typedef struct GWEN_XMLNODE_LIST_ELEMENT {
07515 uint32_t id;
07516 GWEN_XMLNODE *nextObject;
07517 } GWEN_XMLNODE_LIST__ELEMENT;
07518
07525 typedef struct GWEN_XMLNODE_LIST GWEN_XMLNODE_LIST;
07527 struct GWEN_XMLNODE_LIST {
07528 GWEN_XMLNODE *first;
07529 uint32_t count;
07530 uint32_t id;
07531 } GWEN_XMLNODE_LIST;
07532
07537 void GWEN_XMLNode_List_AddList(GWEN_XMLNODE_LIST *dst, GWEN_XMLNODE_LIST *l);
07538
07542 void GWEN_XMLNode_List_Add(GWEN_XMLNODE *element, GWEN_XMLNODE_LIST *list);
07543
07548 void GWEN_XMLNode_List_Insert(GWEN_XMLNODE *element, GWEN_XMLNODE_LIST *list);
07549
07556 void GWEN_XMLNode_List_Del(GWEN_XMLNODE *element);
07557
07561 GWEN_XMLNODE* GWEN_XMLNode_List_First(const GWEN_XMLNODE_LIST *l);
07562
07566 GWEN_XMLNODE* GWEN_XMLNode_List_Last(const GWEN_XMLNODE_LIST *l);
07567
07572 void GWEN_XMLNode_List_Clear(GWEN_XMLNODE_LIST *l);
07573
07577 GWEN_XMLNODE_LIST* GWEN_XMLNode_List_new();
07578
07582 void GWEN_XMLNode_List_free(GWEN_XMLNODE_LIST *l);
07583
07587 GWEN_XMLNODE* GWEN_XMLNode_List_Next(const GWEN_XMLNODE *element);
07588
07592 GWEN_XMLNODE* GWEN_XMLNode_List_Previous(const GWEN_XMLNODE *element);
07593
07597 uint32_t GWEN_XMLNode_List_GetCount(const GWEN_XMLNODE_LIST *l);
07598
07599 #ifdef __cplusplus
07600 }
07601 #endif
07602
07603
07604 #endif
07605
07606
07607
07608
07609
07610
07611
07612
07613
07614
07615
07616
07617
07618
07619
07620
07621
07622
07623
07624
07625
07626
07627
07628
07629
07630
07631
07632
07633
07634
07635
07636 #ifndef GWEN_XSD_NODE_LIST1_H
07637 #define GWEN_XSD_NODE_LIST1_H
07638
07639 #ifdef __cplusplus
07640 extern "C" {
07641 #endif
07642
07644 typedef struct GWEN_XSD_NODE_LIST_ELEMENT {
07645 uint32_t id;
07646 GWEN_XSD_NODE *nextObject;
07647 } GWEN_XSD_NODE_LIST__ELEMENT;
07648
07655 typedef struct GWEN_XSD_NODE_LIST GWEN_XSD_NODE_LIST;
07657 struct GWEN_XSD_NODE_LIST {
07658 GWEN_XSD_NODE *first;
07659 uint32_t count;
07660 uint32_t id;
07661 } GWEN_XSD_NODE_LIST;
07662
07667 void GWEN_XsdNode_List_AddList(GWEN_XSD_NODE_LIST *dst, GWEN_XSD_NODE_LIST *l);
07668
07672 void GWEN_XsdNode_List_Add(GWEN_XSD_NODE *element, GWEN_XSD_NODE_LIST *list);
07673
07678 void GWEN_XsdNode_List_Insert(GWEN_XSD_NODE *element, GWEN_XSD_NODE_LIST *list);
07679
07686 void GWEN_XsdNode_List_Del(GWEN_XSD_NODE *element);
07687
07691 GWEN_XSD_NODE* GWEN_XsdNode_List_First(const GWEN_XSD_NODE_LIST *l);
07692
07696 GWEN_XSD_NODE* GWEN_XsdNode_List_Last(const GWEN_XSD_NODE_LIST *l);
07697
07702 void GWEN_XsdNode_List_Clear(GWEN_XSD_NODE_LIST *l);
07703
07707 GWEN_XSD_NODE_LIST* GWEN_XsdNode_List_new();
07708
07712 void GWEN_XsdNode_List_free(GWEN_XSD_NODE_LIST *l);
07713
07717 GWEN_XSD_NODE* GWEN_XsdNode_List_Next(const GWEN_XSD_NODE *element);
07718
07722 GWEN_XSD_NODE* GWEN_XsdNode_List_Previous(const GWEN_XSD_NODE *element);
07723
07727 uint32_t GWEN_XsdNode_List_GetCount(const GWEN_XSD_NODE_LIST *l);
07728
07729 #ifdef __cplusplus
07730 }
07731 #endif
07732
07733
07734 #endif
07735
07736
07737