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 GWEN_TYPE_UINT32 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 GWEN_TYPE_UINT32 count;
00053 GWEN_TYPE_UINT32 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 GWEN_TYPE_UINT32 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 GWEN_TYPE_UINT32 id;
00169 t *nextObject;
00170 } t_LIST__ELEMENT;
00171
00178 typedef struct t_LIST t_LIST;
00180 struct t_LIST {
00181 t *first;
00182 GWEN_TYPE_UINT32 count;
00183 GWEN_TYPE_UINT32 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 GWEN_TYPE_UINT32 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 GWEN_TYPE_UINT32 id;
00299 MYSTRUCT *nextObject;
00300 } MYSTRUCT_LIST__ELEMENT;
00301
00308 typedef struct MYSTRUCT_LIST MYSTRUCT_LIST;
00310 struct MYSTRUCT_LIST {
00311 MYSTRUCT *first;
00312 GWEN_TYPE_UINT32 count;
00313 GWEN_TYPE_UINT32 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 GWEN_TYPE_UINT32 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 GWEN_TYPE_UINT32 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 GWEN_TYPE_UINT32 count;
01172 GWEN_TYPE_UINT32 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 GWEN_TYPE_UINT32 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_WAITCALLBACK_LIST1_H
01279 #define GWEN_WAITCALLBACK_LIST1_H
01280
01281 #ifdef __cplusplus
01282 extern "C" {
01283 #endif
01284
01286 typedef struct GWEN_WAITCALLBACK_LIST_ELEMENT {
01287 GWEN_TYPE_UINT32 id;
01288 GWEN_WAITCALLBACK *nextObject;
01289 } GWEN_WAITCALLBACK_LIST__ELEMENT;
01290
01297 typedef struct GWEN_WAITCALLBACK_LIST GWEN_WAITCALLBACK_LIST;
01299 struct GWEN_WAITCALLBACK_LIST {
01300 GWEN_WAITCALLBACK *first;
01301 GWEN_TYPE_UINT32 count;
01302 GWEN_TYPE_UINT32 id;
01303 } GWEN_WAITCALLBACK_LIST;
01304
01309 void GWEN_WaitCallback_List_AddList(GWEN_WAITCALLBACK_LIST *dst, GWEN_WAITCALLBACK_LIST *l);
01310
01314 void GWEN_WaitCallback_List_Add(GWEN_WAITCALLBACK *element, GWEN_WAITCALLBACK_LIST *list);
01315
01320 void GWEN_WaitCallback_List_Insert(GWEN_WAITCALLBACK *element, GWEN_WAITCALLBACK_LIST *list);
01321
01328 void GWEN_WaitCallback_List_Del(GWEN_WAITCALLBACK *element);
01329
01333 GWEN_WAITCALLBACK* GWEN_WaitCallback_List_First(const GWEN_WAITCALLBACK_LIST *l);
01334
01338 GWEN_WAITCALLBACK* GWEN_WaitCallback_List_Last(const GWEN_WAITCALLBACK_LIST *l);
01339
01344 void GWEN_WaitCallback_List_Clear(GWEN_WAITCALLBACK_LIST *l);
01345
01349 GWEN_WAITCALLBACK_LIST* GWEN_WaitCallback_List_new();
01350
01354 void GWEN_WaitCallback_List_free(GWEN_WAITCALLBACK_LIST *l);
01355
01359 GWEN_WAITCALLBACK* GWEN_WaitCallback_List_Next(const GWEN_WAITCALLBACK *element);
01360
01364 GWEN_WAITCALLBACK* GWEN_WaitCallback_List_Previous(const GWEN_WAITCALLBACK *element);
01365
01369 GWEN_TYPE_UINT32 GWEN_WaitCallback_List_GetCount(const GWEN_WAITCALLBACK_LIST *l);
01370
01371 #ifdef __cplusplus
01372 }
01373 #endif
01374
01375
01376 #endif
01377
01378
01379
01380
01381
01382
01383
01384
01385
01386
01387
01388
01389
01390
01391
01392
01393
01394
01395
01396
01397
01398
01399
01400
01401
01402
01403
01404
01405
01406
01407
01408 #ifndef GWEN_NETLAYER_LIST2_H
01409 #define GWEN_NETLAYER_LIST2_H
01410
01411
01412 #ifdef __cplusplus
01413 extern "C" {
01414 #endif
01415
01422 typedef struct GWEN_NETLAYER_LIST2 GWEN_NETLAYER_LIST2;
01423
01427 typedef struct GWEN_NETLAYER_LIST2_ITERATOR GWEN_NETLAYER_LIST2_ITERATOR;
01428
01432 typedef GWEN_NETLAYER* (GWEN_NETLAYER_LIST2_FOREACH)(GWEN_NETLAYER *element,
01433 void *user_data);
01434
01438 GWEN_NETLAYER_LIST2 *GWEN_NetLayer_List2_new();
01439
01443 void GWEN_NetLayer_List2_free(GWEN_NETLAYER_LIST2 *l);
01444
01448 void GWEN_NetLayer_List2_Dump(GWEN_NETLAYER_LIST2 *l, FILE *f, unsigned int indent);
01449
01453 void GWEN_NetLayer_List2_PushBack(GWEN_NETLAYER_LIST2 *l, GWEN_NETLAYER *p);
01454
01459 void GWEN_NetLayer_List2_PushFront(GWEN_NETLAYER_LIST2 *l, GWEN_NETLAYER *p);
01460
01465 GWEN_NETLAYER *GWEN_NetLayer_List2_GetFront(GWEN_NETLAYER_LIST2 *l);
01466
01471 GWEN_NETLAYER *GWEN_NetLayer_List2_GetBack(GWEN_NETLAYER_LIST2 *l);
01472
01477 void GWEN_NetLayer_List2_Erase(GWEN_NETLAYER_LIST2 *l,
01478 GWEN_NETLAYER_LIST2_ITERATOR *it);
01479
01485 unsigned int GWEN_NetLayer_List2_GetSize(GWEN_NETLAYER_LIST2 *l);
01486
01491 void GWEN_NetLayer_List2_PopBack(GWEN_NETLAYER_LIST2 *l);
01492
01497 void GWEN_NetLayer_List2_PopFront(GWEN_NETLAYER_LIST2 *l);
01498
01502 void GWEN_NetLayer_List2_Clear(GWEN_NETLAYER_LIST2 *l);
01503
01507 GWEN_NETLAYER_LIST2_ITERATOR *GWEN_NetLayer_List2_First(GWEN_NETLAYER_LIST2 *l);
01508
01512 GWEN_NETLAYER_LIST2_ITERATOR *GWEN_NetLayer_List2_Last(GWEN_NETLAYER_LIST2 *l);
01513
01517 GWEN_NETLAYER_LIST2_ITERATOR *GWEN_NetLayer_List2Iterator_new(GWEN_NETLAYER_LIST2 *l);
01518
01522 void GWEN_NetLayer_List2Iterator_free(GWEN_NETLAYER_LIST2_ITERATOR *li);
01523
01528 GWEN_NETLAYER *GWEN_NetLayer_List2Iterator_Previous(GWEN_NETLAYER_LIST2_ITERATOR *li);
01529
01534 GWEN_NETLAYER *GWEN_NetLayer_List2Iterator_Next(GWEN_NETLAYER_LIST2_ITERATOR *li);
01535
01540 GWEN_NETLAYER *GWEN_NetLayer_List2Iterator_Data(GWEN_NETLAYER_LIST2_ITERATOR *li);
01541
01553 GWEN_NETLAYER *GWEN_NetLayer_List2_ForEach(GWEN_NETLAYER_LIST2 *list,
01554 GWEN_NETLAYER_LIST2_FOREACH func,
01555 void *user_data);
01556
01557
01558 typedef struct GWEN_NETLAYER_CONSTLIST2 GWEN_NETLAYER_CONSTLIST2;
01559 typedef struct GWEN_NETLAYER_CONSTLIST2_ITERATOR GWEN_NETLAYER_CONSTLIST2_ITERATOR;
01560 typedef const GWEN_NETLAYER*
01561 (GWEN_NETLAYER_CONSTLIST2_FOREACH)(const GWEN_NETLAYER *element,
01562 void *user_data);
01563
01564
01565 GWEN_NETLAYER_CONSTLIST2 *GWEN_NetLayer_ConstList2_new();
01566
01567 void GWEN_NetLayer_ConstList2_free(GWEN_NETLAYER_CONSTLIST2 *l);
01568
01569 void GWEN_NetLayer_ConstList2_PushBack(GWEN_NETLAYER_CONSTLIST2 *l, const GWEN_NETLAYER *p);
01570
01571 void GWEN_NetLayer_ConstList2_PushFront(GWEN_NETLAYER_CONSTLIST2 *l, const GWEN_NETLAYER *p);
01572
01573 const GWEN_NETLAYER *GWEN_NetLayer_ConstList2_GetFront(GWEN_NETLAYER_CONSTLIST2 *l);
01574
01575 const GWEN_NETLAYER *GWEN_NetLayer_ConstList2_GetBack(GWEN_NETLAYER_CONSTLIST2 *l);
01576
01577 unsigned int GWEN_NetLayer_ConstList2_GetSize(GWEN_NETLAYER_CONSTLIST2 *l);
01578
01579 void GWEN_NetLayer_ConstList2_PopBack(GWEN_NETLAYER_CONSTLIST2 *l);
01580
01581 void GWEN_NetLayer_ConstList2_PopFront(GWEN_NETLAYER_CONSTLIST2 *l);
01582
01583 void GWEN_NetLayer_ConstList2_Clear(GWEN_NETLAYER_CONSTLIST2 *l);
01584
01585 GWEN_NETLAYER_CONSTLIST2_ITERATOR *GWEN_NetLayer_ConstList2_First(GWEN_NETLAYER_CONSTLIST2 *l);
01586
01587 GWEN_NETLAYER_CONSTLIST2_ITERATOR *GWEN_NetLayer_ConstList2_Last(GWEN_NETLAYER_CONSTLIST2 *l);
01588
01589 GWEN_NETLAYER_CONSTLIST2_ITERATOR *GWEN_NetLayer_ConstList2Iterator_new(GWEN_NETLAYER_CONSTLIST2 *l);
01590
01591 void GWEN_NetLayer_ConstList2Iterator_free(GWEN_NETLAYER_CONSTLIST2_ITERATOR *li);
01592
01593 const GWEN_NETLAYER *GWEN_NetLayer_ConstList2Iterator_Previous(GWEN_NETLAYER_CONSTLIST2_ITERATOR *li);
01594
01595 const GWEN_NETLAYER *GWEN_NetLayer_ConstList2Iterator_Next(GWEN_NETLAYER_CONSTLIST2_ITERATOR *li);
01596
01597 const GWEN_NETLAYER *GWEN_NetLayer_ConstList2Iterator_Data(GWEN_NETLAYER_CONSTLIST2_ITERATOR *li);
01598
01610 const GWEN_NETLAYER *GWEN_NetLayer_ConstList2_ForEach(GWEN_NETLAYER_CONSTLIST2 *list,
01611 GWEN_NETLAYER_CONSTLIST2_FOREACH func, void *user_data);
01612
01613
01614 #ifdef __cplusplus
01615 }
01616 #endif
01617
01618
01619 #endif
01620
01621
01622
01623
01624
01625
01626
01627
01628
01629
01630
01631
01632
01633
01634
01635
01636
01637
01638
01639
01640
01641
01642
01643
01644
01645
01646
01647
01648
01649
01650
01651 #ifndef GWEN_URL_LIST2_H
01652 #define GWEN_URL_LIST2_H
01653
01654
01655 #ifdef __cplusplus
01656 extern "C" {
01657 #endif
01658
01665 typedef struct GWEN_URL_LIST2 GWEN_URL_LIST2;
01666
01670 typedef struct GWEN_URL_LIST2_ITERATOR GWEN_URL_LIST2_ITERATOR;
01671
01675 typedef GWEN_URL* (GWEN_URL_LIST2_FOREACH)(GWEN_URL *element,
01676 void *user_data);
01677
01681 GWEN_URL_LIST2 *GWEN_Url_List2_new();
01682
01686 void GWEN_Url_List2_free(GWEN_URL_LIST2 *l);
01687
01691 void GWEN_Url_List2_Dump(GWEN_URL_LIST2 *l, FILE *f, unsigned int indent);
01692
01696 void GWEN_Url_List2_PushBack(GWEN_URL_LIST2 *l, GWEN_URL *p);
01697
01702 void GWEN_Url_List2_PushFront(GWEN_URL_LIST2 *l, GWEN_URL *p);
01703
01708 GWEN_URL *GWEN_Url_List2_GetFront(GWEN_URL_LIST2 *l);
01709
01714 GWEN_URL *GWEN_Url_List2_GetBack(GWEN_URL_LIST2 *l);
01715
01720 void GWEN_Url_List2_Erase(GWEN_URL_LIST2 *l,
01721 GWEN_URL_LIST2_ITERATOR *it);
01722
01728 unsigned int GWEN_Url_List2_GetSize(GWEN_URL_LIST2 *l);
01729
01734 void GWEN_Url_List2_PopBack(GWEN_URL_LIST2 *l);
01735
01740 void GWEN_Url_List2_PopFront(GWEN_URL_LIST2 *l);
01741
01745 void GWEN_Url_List2_Clear(GWEN_URL_LIST2 *l);
01746
01750 GWEN_URL_LIST2_ITERATOR *GWEN_Url_List2_First(GWEN_URL_LIST2 *l);
01751
01755 GWEN_URL_LIST2_ITERATOR *GWEN_Url_List2_Last(GWEN_URL_LIST2 *l);
01756
01760 GWEN_URL_LIST2_ITERATOR *GWEN_Url_List2Iterator_new(GWEN_URL_LIST2 *l);
01761
01765 void GWEN_Url_List2Iterator_free(GWEN_URL_LIST2_ITERATOR *li);
01766
01771 GWEN_URL *GWEN_Url_List2Iterator_Previous(GWEN_URL_LIST2_ITERATOR *li);
01772
01777 GWEN_URL *GWEN_Url_List2Iterator_Next(GWEN_URL_LIST2_ITERATOR *li);
01778
01783 GWEN_URL *GWEN_Url_List2Iterator_Data(GWEN_URL_LIST2_ITERATOR *li);
01784
01796 GWEN_URL *GWEN_Url_List2_ForEach(GWEN_URL_LIST2 *list,
01797 GWEN_URL_LIST2_FOREACH func,
01798 void *user_data);
01799
01800
01801 typedef struct GWEN_URL_CONSTLIST2 GWEN_URL_CONSTLIST2;
01802 typedef struct GWEN_URL_CONSTLIST2_ITERATOR GWEN_URL_CONSTLIST2_ITERATOR;
01803 typedef const GWEN_URL*
01804 (GWEN_URL_CONSTLIST2_FOREACH)(const GWEN_URL *element,
01805 void *user_data);
01806
01807
01808 GWEN_URL_CONSTLIST2 *GWEN_Url_ConstList2_new();
01809
01810 void GWEN_Url_ConstList2_free(GWEN_URL_CONSTLIST2 *l);
01811
01812 void GWEN_Url_ConstList2_PushBack(GWEN_URL_CONSTLIST2 *l, const GWEN_URL *p);
01813
01814 void GWEN_Url_ConstList2_PushFront(GWEN_URL_CONSTLIST2 *l, const GWEN_URL *p);
01815
01816 const GWEN_URL *GWEN_Url_ConstList2_GetFront(GWEN_URL_CONSTLIST2 *l);
01817
01818 const GWEN_URL *GWEN_Url_ConstList2_GetBack(GWEN_URL_CONSTLIST2 *l);
01819
01820 unsigned int GWEN_Url_ConstList2_GetSize(GWEN_URL_CONSTLIST2 *l);
01821
01822 void GWEN_Url_ConstList2_PopBack(GWEN_URL_CONSTLIST2 *l);
01823
01824 void GWEN_Url_ConstList2_PopFront(GWEN_URL_CONSTLIST2 *l);
01825
01826 void GWEN_Url_ConstList2_Clear(GWEN_URL_CONSTLIST2 *l);
01827
01828 GWEN_URL_CONSTLIST2_ITERATOR *GWEN_Url_ConstList2_First(GWEN_URL_CONSTLIST2 *l);
01829
01830 GWEN_URL_CONSTLIST2_ITERATOR *GWEN_Url_ConstList2_Last(GWEN_URL_CONSTLIST2 *l);
01831
01832 GWEN_URL_CONSTLIST2_ITERATOR *GWEN_Url_ConstList2Iterator_new(GWEN_URL_CONSTLIST2 *l);
01833
01834 void GWEN_Url_ConstList2Iterator_free(GWEN_URL_CONSTLIST2_ITERATOR *li);
01835
01836 const GWEN_URL *GWEN_Url_ConstList2Iterator_Previous(GWEN_URL_CONSTLIST2_ITERATOR *li);
01837
01838 const GWEN_URL *GWEN_Url_ConstList2Iterator_Next(GWEN_URL_CONSTLIST2_ITERATOR *li);
01839
01840 const GWEN_URL *GWEN_Url_ConstList2Iterator_Data(GWEN_URL_CONSTLIST2_ITERATOR *li);
01841
01853 const GWEN_URL *GWEN_Url_ConstList2_ForEach(GWEN_URL_CONSTLIST2 *list,
01854 GWEN_URL_CONSTLIST2_FOREACH func, void *user_data);
01855
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_URL_LIST1_H
01895 #define GWEN_URL_LIST1_H
01896
01897 #ifdef __cplusplus
01898 extern "C" {
01899 #endif
01900
01902 typedef struct GWEN_URL_LIST_ELEMENT {
01903 GWEN_TYPE_UINT32 id;
01904 GWEN_URL *nextObject;
01905 } GWEN_URL_LIST__ELEMENT;
01906
01913 typedef struct GWEN_URL_LIST GWEN_URL_LIST;
01915 struct GWEN_URL_LIST {
01916 GWEN_URL *first;
01917 GWEN_TYPE_UINT32 count;
01918 GWEN_TYPE_UINT32 id;
01919 } GWEN_URL_LIST;
01920
01925 void GWEN_Url_List_AddList(GWEN_URL_LIST *dst, GWEN_URL_LIST *l);
01926
01930 void GWEN_Url_List_Add(GWEN_URL *element, GWEN_URL_LIST *list);
01931
01936 void GWEN_Url_List_Insert(GWEN_URL *element, GWEN_URL_LIST *list);
01937
01944 void GWEN_Url_List_Del(GWEN_URL *element);
01945
01949 GWEN_URL* GWEN_Url_List_First(const GWEN_URL_LIST *l);
01950
01954 GWEN_URL* GWEN_Url_List_Last(const GWEN_URL_LIST *l);
01955
01960 void GWEN_Url_List_Clear(GWEN_URL_LIST *l);
01961
01965 GWEN_URL_LIST* GWEN_Url_List_new();
01966
01970 void GWEN_Url_List_free(GWEN_URL_LIST *l);
01971
01975 GWEN_URL* GWEN_Url_List_Next(const GWEN_URL *element);
01976
01980 GWEN_URL* GWEN_Url_List_Previous(const GWEN_URL *element);
01981
01985 GWEN_TYPE_UINT32 GWEN_Url_List_GetCount(const GWEN_URL_LIST *l);
01986
01987 #ifdef __cplusplus
01988 }
01989 #endif
01990
01991
01992 #endif
01993
01994
01995
01996
01997
01998
01999
02000
02001
02002
02003
02004
02005
02006
02007
02008
02009
02010
02011
02012
02013
02014
02015
02016
02017
02018
02019
02020
02021
02022
02023
02024 #ifndef GWEN_CRYPTKEY_LIST2_H
02025 #define GWEN_CRYPTKEY_LIST2_H
02026
02027
02028 #ifdef __cplusplus
02029 extern "C" {
02030 #endif
02031
02038 typedef struct GWEN_CRYPTKEY_LIST2 GWEN_CRYPTKEY_LIST2;
02039
02043 typedef struct GWEN_CRYPTKEY_LIST2_ITERATOR GWEN_CRYPTKEY_LIST2_ITERATOR;
02044
02048 typedef GWEN_CRYPTKEY* (GWEN_CRYPTKEY_LIST2_FOREACH)(GWEN_CRYPTKEY *element,
02049 void *user_data);
02050
02054 GWEN_CRYPTKEY_LIST2 *GWEN_CryptKey_List2_new();
02055
02059 void GWEN_CryptKey_List2_free(GWEN_CRYPTKEY_LIST2 *l);
02060
02064 void GWEN_CryptKey_List2_Dump(GWEN_CRYPTKEY_LIST2 *l, FILE *f, unsigned int indent);
02065
02069 void GWEN_CryptKey_List2_PushBack(GWEN_CRYPTKEY_LIST2 *l, GWEN_CRYPTKEY *p);
02070
02075 void GWEN_CryptKey_List2_PushFront(GWEN_CRYPTKEY_LIST2 *l, GWEN_CRYPTKEY *p);
02076
02081 GWEN_CRYPTKEY *GWEN_CryptKey_List2_GetFront(GWEN_CRYPTKEY_LIST2 *l);
02082
02087 GWEN_CRYPTKEY *GWEN_CryptKey_List2_GetBack(GWEN_CRYPTKEY_LIST2 *l);
02088
02093 void GWEN_CryptKey_List2_Erase(GWEN_CRYPTKEY_LIST2 *l,
02094 GWEN_CRYPTKEY_LIST2_ITERATOR *it);
02095
02101 unsigned int GWEN_CryptKey_List2_GetSize(GWEN_CRYPTKEY_LIST2 *l);
02102
02107 void GWEN_CryptKey_List2_PopBack(GWEN_CRYPTKEY_LIST2 *l);
02108
02113 void GWEN_CryptKey_List2_PopFront(GWEN_CRYPTKEY_LIST2 *l);
02114
02118 void GWEN_CryptKey_List2_Clear(GWEN_CRYPTKEY_LIST2 *l);
02119
02123 GWEN_CRYPTKEY_LIST2_ITERATOR *GWEN_CryptKey_List2_First(GWEN_CRYPTKEY_LIST2 *l);
02124
02128 GWEN_CRYPTKEY_LIST2_ITERATOR *GWEN_CryptKey_List2_Last(GWEN_CRYPTKEY_LIST2 *l);
02129
02133 GWEN_CRYPTKEY_LIST2_ITERATOR *GWEN_CryptKey_List2Iterator_new(GWEN_CRYPTKEY_LIST2 *l);
02134
02138 void GWEN_CryptKey_List2Iterator_free(GWEN_CRYPTKEY_LIST2_ITERATOR *li);
02139
02144 GWEN_CRYPTKEY *GWEN_CryptKey_List2Iterator_Previous(GWEN_CRYPTKEY_LIST2_ITERATOR *li);
02145
02150 GWEN_CRYPTKEY *GWEN_CryptKey_List2Iterator_Next(GWEN_CRYPTKEY_LIST2_ITERATOR *li);
02151
02156 GWEN_CRYPTKEY *GWEN_CryptKey_List2Iterator_Data(GWEN_CRYPTKEY_LIST2_ITERATOR *li);
02157
02169 GWEN_CRYPTKEY *GWEN_CryptKey_List2_ForEach(GWEN_CRYPTKEY_LIST2 *list,
02170 GWEN_CRYPTKEY_LIST2_FOREACH func,
02171 void *user_data);
02172
02173
02174 typedef struct GWEN_CRYPTKEY_CONSTLIST2 GWEN_CRYPTKEY_CONSTLIST2;
02175 typedef struct GWEN_CRYPTKEY_CONSTLIST2_ITERATOR GWEN_CRYPTKEY_CONSTLIST2_ITERATOR;
02176 typedef const GWEN_CRYPTKEY*
02177 (GWEN_CRYPTKEY_CONSTLIST2_FOREACH)(const GWEN_CRYPTKEY *element,
02178 void *user_data);
02179
02180
02181 GWEN_CRYPTKEY_CONSTLIST2 *GWEN_CryptKey_ConstList2_new();
02182
02183 void GWEN_CryptKey_ConstList2_free(GWEN_CRYPTKEY_CONSTLIST2 *l);
02184
02185 void GWEN_CryptKey_ConstList2_PushBack(GWEN_CRYPTKEY_CONSTLIST2 *l, const GWEN_CRYPTKEY *p);
02186
02187 void GWEN_CryptKey_ConstList2_PushFront(GWEN_CRYPTKEY_CONSTLIST2 *l, const GWEN_CRYPTKEY *p);
02188
02189 const GWEN_CRYPTKEY *GWEN_CryptKey_ConstList2_GetFront(GWEN_CRYPTKEY_CONSTLIST2 *l);
02190
02191 const GWEN_CRYPTKEY *GWEN_CryptKey_ConstList2_GetBack(GWEN_CRYPTKEY_CONSTLIST2 *l);
02192
02193 unsigned int GWEN_CryptKey_ConstList2_GetSize(GWEN_CRYPTKEY_CONSTLIST2 *l);
02194
02195 void GWEN_CryptKey_ConstList2_PopBack(GWEN_CRYPTKEY_CONSTLIST2 *l);
02196
02197 void GWEN_CryptKey_ConstList2_PopFront(GWEN_CRYPTKEY_CONSTLIST2 *l);
02198
02199 void GWEN_CryptKey_ConstList2_Clear(GWEN_CRYPTKEY_CONSTLIST2 *l);
02200
02201 GWEN_CRYPTKEY_CONSTLIST2_ITERATOR *GWEN_CryptKey_ConstList2_First(GWEN_CRYPTKEY_CONSTLIST2 *l);
02202
02203 GWEN_CRYPTKEY_CONSTLIST2_ITERATOR *GWEN_CryptKey_ConstList2_Last(GWEN_CRYPTKEY_CONSTLIST2 *l);
02204
02205 GWEN_CRYPTKEY_CONSTLIST2_ITERATOR *GWEN_CryptKey_ConstList2Iterator_new(GWEN_CRYPTKEY_CONSTLIST2 *l);
02206
02207 void GWEN_CryptKey_ConstList2Iterator_free(GWEN_CRYPTKEY_CONSTLIST2_ITERATOR *li);
02208
02209 const GWEN_CRYPTKEY *GWEN_CryptKey_ConstList2Iterator_Previous(GWEN_CRYPTKEY_CONSTLIST2_ITERATOR *li);
02210
02211 const GWEN_CRYPTKEY *GWEN_CryptKey_ConstList2Iterator_Next(GWEN_CRYPTKEY_CONSTLIST2_ITERATOR *li);
02212
02213 const GWEN_CRYPTKEY *GWEN_CryptKey_ConstList2Iterator_Data(GWEN_CRYPTKEY_CONSTLIST2_ITERATOR *li);
02214
02226 const GWEN_CRYPTKEY *GWEN_CryptKey_ConstList2_ForEach(GWEN_CRYPTKEY_CONSTLIST2 *list,
02227 GWEN_CRYPTKEY_CONSTLIST2_FOREACH func, void *user_data);
02228
02229
02230 #ifdef __cplusplus
02231 }
02232 #endif
02233
02234
02235 #endif
02236
02237
02238
02239
02240
02241
02242
02243
02244
02245
02246
02247
02248
02249
02250
02251
02252
02253
02254
02255
02256
02257
02258
02259
02260
02261
02262
02263
02264
02265
02266
02267 #ifndef GWEN_CRYPTKEY_LIST1_H
02268 #define GWEN_CRYPTKEY_LIST1_H
02269
02270 #ifdef __cplusplus
02271 extern "C" {
02272 #endif
02273
02275 typedef struct GWEN_CRYPTKEY_LIST_ELEMENT {
02276 GWEN_TYPE_UINT32 id;
02277 GWEN_CRYPTKEY *nextObject;
02278 } GWEN_CRYPTKEY_LIST__ELEMENT;
02279
02286 typedef struct GWEN_CRYPTKEY_LIST GWEN_CRYPTKEY_LIST;
02288 struct GWEN_CRYPTKEY_LIST {
02289 GWEN_CRYPTKEY *first;
02290 GWEN_TYPE_UINT32 count;
02291 GWEN_TYPE_UINT32 id;
02292 } GWEN_CRYPTKEY_LIST;
02293
02298 void GWEN_CryptKey_List_AddList(GWEN_CRYPTKEY_LIST *dst, GWEN_CRYPTKEY_LIST *l);
02299
02303 void GWEN_CryptKey_List_Add(GWEN_CRYPTKEY *element, GWEN_CRYPTKEY_LIST *list);
02304
02309 void GWEN_CryptKey_List_Insert(GWEN_CRYPTKEY *element, GWEN_CRYPTKEY_LIST *list);
02310
02317 void GWEN_CryptKey_List_Del(GWEN_CRYPTKEY *element);
02318
02322 GWEN_CRYPTKEY* GWEN_CryptKey_List_First(const GWEN_CRYPTKEY_LIST *l);
02323
02327 GWEN_CRYPTKEY* GWEN_CryptKey_List_Last(const GWEN_CRYPTKEY_LIST *l);
02328
02333 void GWEN_CryptKey_List_Clear(GWEN_CRYPTKEY_LIST *l);
02334
02338 GWEN_CRYPTKEY_LIST* GWEN_CryptKey_List_new();
02339
02343 void GWEN_CryptKey_List_free(GWEN_CRYPTKEY_LIST *l);
02344
02348 GWEN_CRYPTKEY* GWEN_CryptKey_List_Next(const GWEN_CRYPTKEY *element);
02349
02353 GWEN_CRYPTKEY* GWEN_CryptKey_List_Previous(const GWEN_CRYPTKEY *element);
02354
02358 GWEN_TYPE_UINT32 GWEN_CryptKey_List_GetCount(const GWEN_CRYPTKEY_LIST *l);
02359
02360 #ifdef __cplusplus
02361 }
02362 #endif
02363
02364
02365 #endif
02366
02367
02368
02369
02370
02371
02372
02373
02374
02375
02376
02377
02378
02379
02380
02381
02382
02383
02384
02385
02386
02387
02388
02389
02390
02391
02392
02393
02394
02395
02396
02397 #ifndef GWEN_KEYSPEC_LIST2_H
02398 #define GWEN_KEYSPEC_LIST2_H
02399
02400
02401 #ifdef __cplusplus
02402 extern "C" {
02403 #endif
02404
02411 typedef struct GWEN_KEYSPEC_LIST2 GWEN_KEYSPEC_LIST2;
02412
02416 typedef struct GWEN_KEYSPEC_LIST2_ITERATOR GWEN_KEYSPEC_LIST2_ITERATOR;
02417
02421 typedef GWEN_KEYSPEC* (GWEN_KEYSPEC_LIST2_FOREACH)(GWEN_KEYSPEC *element,
02422 void *user_data);
02423
02427 GWEN_KEYSPEC_LIST2 *GWEN_KeySpec_List2_new();
02428
02432 void GWEN_KeySpec_List2_free(GWEN_KEYSPEC_LIST2 *l);
02433
02437 void GWEN_KeySpec_List2_Dump(GWEN_KEYSPEC_LIST2 *l, FILE *f, unsigned int indent);
02438
02442 void GWEN_KeySpec_List2_PushBack(GWEN_KEYSPEC_LIST2 *l, GWEN_KEYSPEC *p);
02443
02448 void GWEN_KeySpec_List2_PushFront(GWEN_KEYSPEC_LIST2 *l, GWEN_KEYSPEC *p);
02449
02454 GWEN_KEYSPEC *GWEN_KeySpec_List2_GetFront(GWEN_KEYSPEC_LIST2 *l);
02455
02460 GWEN_KEYSPEC *GWEN_KeySpec_List2_GetBack(GWEN_KEYSPEC_LIST2 *l);
02461
02466 void GWEN_KeySpec_List2_Erase(GWEN_KEYSPEC_LIST2 *l,
02467 GWEN_KEYSPEC_LIST2_ITERATOR *it);
02468
02474 unsigned int GWEN_KeySpec_List2_GetSize(GWEN_KEYSPEC_LIST2 *l);
02475
02480 void GWEN_KeySpec_List2_PopBack(GWEN_KEYSPEC_LIST2 *l);
02481
02486 void GWEN_KeySpec_List2_PopFront(GWEN_KEYSPEC_LIST2 *l);
02487
02491 void GWEN_KeySpec_List2_Clear(GWEN_KEYSPEC_LIST2 *l);
02492
02496 GWEN_KEYSPEC_LIST2_ITERATOR *GWEN_KeySpec_List2_First(GWEN_KEYSPEC_LIST2 *l);
02497
02501 GWEN_KEYSPEC_LIST2_ITERATOR *GWEN_KeySpec_List2_Last(GWEN_KEYSPEC_LIST2 *l);
02502
02506 GWEN_KEYSPEC_LIST2_ITERATOR *GWEN_KeySpec_List2Iterator_new(GWEN_KEYSPEC_LIST2 *l);
02507
02511 void GWEN_KeySpec_List2Iterator_free(GWEN_KEYSPEC_LIST2_ITERATOR *li);
02512
02517 GWEN_KEYSPEC *GWEN_KeySpec_List2Iterator_Previous(GWEN_KEYSPEC_LIST2_ITERATOR *li);
02518
02523 GWEN_KEYSPEC *GWEN_KeySpec_List2Iterator_Next(GWEN_KEYSPEC_LIST2_ITERATOR *li);
02524
02529 GWEN_KEYSPEC *GWEN_KeySpec_List2Iterator_Data(GWEN_KEYSPEC_LIST2_ITERATOR *li);
02530
02542 GWEN_KEYSPEC *GWEN_KeySpec_List2_ForEach(GWEN_KEYSPEC_LIST2 *list,
02543 GWEN_KEYSPEC_LIST2_FOREACH func,
02544 void *user_data);
02545
02546
02547 typedef struct GWEN_KEYSPEC_CONSTLIST2 GWEN_KEYSPEC_CONSTLIST2;
02548 typedef struct GWEN_KEYSPEC_CONSTLIST2_ITERATOR GWEN_KEYSPEC_CONSTLIST2_ITERATOR;
02549 typedef const GWEN_KEYSPEC*
02550 (GWEN_KEYSPEC_CONSTLIST2_FOREACH)(const GWEN_KEYSPEC *element,
02551 void *user_data);
02552
02553
02554 GWEN_KEYSPEC_CONSTLIST2 *GWEN_KeySpec_ConstList2_new();
02555
02556 void GWEN_KeySpec_ConstList2_free(GWEN_KEYSPEC_CONSTLIST2 *l);
02557
02558 void GWEN_KeySpec_ConstList2_PushBack(GWEN_KEYSPEC_CONSTLIST2 *l, const GWEN_KEYSPEC *p);
02559
02560 void GWEN_KeySpec_ConstList2_PushFront(GWEN_KEYSPEC_CONSTLIST2 *l, const GWEN_KEYSPEC *p);
02561
02562 const GWEN_KEYSPEC *GWEN_KeySpec_ConstList2_GetFront(GWEN_KEYSPEC_CONSTLIST2 *l);
02563
02564 const GWEN_KEYSPEC *GWEN_KeySpec_ConstList2_GetBack(GWEN_KEYSPEC_CONSTLIST2 *l);
02565
02566 unsigned int GWEN_KeySpec_ConstList2_GetSize(GWEN_KEYSPEC_CONSTLIST2 *l);
02567
02568 void GWEN_KeySpec_ConstList2_PopBack(GWEN_KEYSPEC_CONSTLIST2 *l);
02569
02570 void GWEN_KeySpec_ConstList2_PopFront(GWEN_KEYSPEC_CONSTLIST2 *l);
02571
02572 void GWEN_KeySpec_ConstList2_Clear(GWEN_KEYSPEC_CONSTLIST2 *l);
02573
02574 GWEN_KEYSPEC_CONSTLIST2_ITERATOR *GWEN_KeySpec_ConstList2_First(GWEN_KEYSPEC_CONSTLIST2 *l);
02575
02576 GWEN_KEYSPEC_CONSTLIST2_ITERATOR *GWEN_KeySpec_ConstList2_Last(GWEN_KEYSPEC_CONSTLIST2 *l);
02577
02578 GWEN_KEYSPEC_CONSTLIST2_ITERATOR *GWEN_KeySpec_ConstList2Iterator_new(GWEN_KEYSPEC_CONSTLIST2 *l);
02579
02580 void GWEN_KeySpec_ConstList2Iterator_free(GWEN_KEYSPEC_CONSTLIST2_ITERATOR *li);
02581
02582 const GWEN_KEYSPEC *GWEN_KeySpec_ConstList2Iterator_Previous(GWEN_KEYSPEC_CONSTLIST2_ITERATOR *li);
02583
02584 const GWEN_KEYSPEC *GWEN_KeySpec_ConstList2Iterator_Next(GWEN_KEYSPEC_CONSTLIST2_ITERATOR *li);
02585
02586 const GWEN_KEYSPEC *GWEN_KeySpec_ConstList2Iterator_Data(GWEN_KEYSPEC_CONSTLIST2_ITERATOR *li);
02587
02599 const GWEN_KEYSPEC *GWEN_KeySpec_ConstList2_ForEach(GWEN_KEYSPEC_CONSTLIST2 *list,
02600 GWEN_KEYSPEC_CONSTLIST2_FOREACH func, void *user_data);
02601
02602
02603 #ifdef __cplusplus
02604 }
02605 #endif
02606
02607
02608 #endif
02609
02610
02611
02612
02613
02614
02615
02616
02617
02618
02619
02620
02621
02622
02623
02624
02625
02626
02627
02628
02629
02630
02631
02632
02633
02634
02635
02636
02637
02638
02639
02640 #ifndef GWEN_KEYSPEC_LIST1_H
02641 #define GWEN_KEYSPEC_LIST1_H
02642
02643 #ifdef __cplusplus
02644 extern "C" {
02645 #endif
02646
02648 typedef struct GWEN_KEYSPEC_LIST_ELEMENT {
02649 GWEN_TYPE_UINT32 id;
02650 GWEN_KEYSPEC *nextObject;
02651 } GWEN_KEYSPEC_LIST__ELEMENT;
02652
02659 typedef struct GWEN_KEYSPEC_LIST GWEN_KEYSPEC_LIST;
02661 struct GWEN_KEYSPEC_LIST {
02662 GWEN_KEYSPEC *first;
02663 GWEN_TYPE_UINT32 count;
02664 GWEN_TYPE_UINT32 id;
02665 } GWEN_KEYSPEC_LIST;
02666
02671 void GWEN_KeySpec_List_AddList(GWEN_KEYSPEC_LIST *dst, GWEN_KEYSPEC_LIST *l);
02672
02676 void GWEN_KeySpec_List_Add(GWEN_KEYSPEC *element, GWEN_KEYSPEC_LIST *list);
02677
02682 void GWEN_KeySpec_List_Insert(GWEN_KEYSPEC *element, GWEN_KEYSPEC_LIST *list);
02683
02690 void GWEN_KeySpec_List_Del(GWEN_KEYSPEC *element);
02691
02695 GWEN_KEYSPEC* GWEN_KeySpec_List_First(const GWEN_KEYSPEC_LIST *l);
02696
02700 GWEN_KEYSPEC* GWEN_KeySpec_List_Last(const GWEN_KEYSPEC_LIST *l);
02701
02706 void GWEN_KeySpec_List_Clear(GWEN_KEYSPEC_LIST *l);
02707
02711 GWEN_KEYSPEC_LIST* GWEN_KeySpec_List_new();
02712
02716 void GWEN_KeySpec_List_free(GWEN_KEYSPEC_LIST *l);
02717
02721 GWEN_KEYSPEC* GWEN_KeySpec_List_Next(const GWEN_KEYSPEC *element);
02722
02726 GWEN_KEYSPEC* GWEN_KeySpec_List_Previous(const GWEN_KEYSPEC *element);
02727
02731 GWEN_TYPE_UINT32 GWEN_KeySpec_List_GetCount(const GWEN_KEYSPEC_LIST *l);
02732
02733 #ifdef __cplusplus
02734 }
02735 #endif
02736
02737
02738 #endif
02739
02740
02741
02742
02743
02744
02745
02746
02747
02748
02749
02750
02751
02752
02753
02754
02755
02756
02757
02758
02759
02760
02761
02762
02763
02764
02765
02766
02767
02768
02769
02770 #ifndef GWEN_SSLCERTDESCR_LIST2_H
02771 #define GWEN_SSLCERTDESCR_LIST2_H
02772
02773
02774 #ifdef __cplusplus
02775 extern "C" {
02776 #endif
02777
02784 typedef struct GWEN_SSLCERTDESCR_LIST2 GWEN_SSLCERTDESCR_LIST2;
02785
02789 typedef struct GWEN_SSLCERTDESCR_LIST2_ITERATOR GWEN_SSLCERTDESCR_LIST2_ITERATOR;
02790
02794 typedef GWEN_SSLCERTDESCR* (GWEN_SSLCERTDESCR_LIST2_FOREACH)(GWEN_SSLCERTDESCR *element,
02795 void *user_data);
02796
02800 GWEN_SSLCERTDESCR_LIST2 *GWEN_SslCertDescr_List2_new();
02801
02805 void GWEN_SslCertDescr_List2_free(GWEN_SSLCERTDESCR_LIST2 *l);
02806
02810 void GWEN_SslCertDescr_List2_Dump(GWEN_SSLCERTDESCR_LIST2 *l, FILE *f, unsigned int indent);
02811
02815 void GWEN_SslCertDescr_List2_PushBack(GWEN_SSLCERTDESCR_LIST2 *l, GWEN_SSLCERTDESCR *p);
02816
02821 void GWEN_SslCertDescr_List2_PushFront(GWEN_SSLCERTDESCR_LIST2 *l, GWEN_SSLCERTDESCR *p);
02822
02827 GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2_GetFront(GWEN_SSLCERTDESCR_LIST2 *l);
02828
02833 GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2_GetBack(GWEN_SSLCERTDESCR_LIST2 *l);
02834
02839 void GWEN_SslCertDescr_List2_Erase(GWEN_SSLCERTDESCR_LIST2 *l,
02840 GWEN_SSLCERTDESCR_LIST2_ITERATOR *it);
02841
02847 unsigned int GWEN_SslCertDescr_List2_GetSize(GWEN_SSLCERTDESCR_LIST2 *l);
02848
02853 void GWEN_SslCertDescr_List2_PopBack(GWEN_SSLCERTDESCR_LIST2 *l);
02854
02859 void GWEN_SslCertDescr_List2_PopFront(GWEN_SSLCERTDESCR_LIST2 *l);
02860
02864 void GWEN_SslCertDescr_List2_Clear(GWEN_SSLCERTDESCR_LIST2 *l);
02865
02869 GWEN_SSLCERTDESCR_LIST2_ITERATOR *GWEN_SslCertDescr_List2_First(GWEN_SSLCERTDESCR_LIST2 *l);
02870
02874 GWEN_SSLCERTDESCR_LIST2_ITERATOR *GWEN_SslCertDescr_List2_Last(GWEN_SSLCERTDESCR_LIST2 *l);
02875
02879 GWEN_SSLCERTDESCR_LIST2_ITERATOR *GWEN_SslCertDescr_List2Iterator_new(GWEN_SSLCERTDESCR_LIST2 *l);
02880
02884 void GWEN_SslCertDescr_List2Iterator_free(GWEN_SSLCERTDESCR_LIST2_ITERATOR *li);
02885
02890 GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2Iterator_Previous(GWEN_SSLCERTDESCR_LIST2_ITERATOR *li);
02891
02896 GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2Iterator_Next(GWEN_SSLCERTDESCR_LIST2_ITERATOR *li);
02897
02902 GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2Iterator_Data(GWEN_SSLCERTDESCR_LIST2_ITERATOR *li);
02903
02915 GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2_ForEach(GWEN_SSLCERTDESCR_LIST2 *list,
02916 GWEN_SSLCERTDESCR_LIST2_FOREACH func,
02917 void *user_data);
02918
02919
02920 typedef struct GWEN_SSLCERTDESCR_CONSTLIST2 GWEN_SSLCERTDESCR_CONSTLIST2;
02921 typedef struct GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR;
02922 typedef const GWEN_SSLCERTDESCR*
02923 (GWEN_SSLCERTDESCR_CONSTLIST2_FOREACH)(const GWEN_SSLCERTDESCR *element,
02924 void *user_data);
02925
02926
02927 GWEN_SSLCERTDESCR_CONSTLIST2 *GWEN_SslCertDescr_ConstList2_new();
02928
02929 void GWEN_SslCertDescr_ConstList2_free(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
02930
02931 void GWEN_SslCertDescr_ConstList2_PushBack(GWEN_SSLCERTDESCR_CONSTLIST2 *l, const GWEN_SSLCERTDESCR *p);
02932
02933 void GWEN_SslCertDescr_ConstList2_PushFront(GWEN_SSLCERTDESCR_CONSTLIST2 *l, const GWEN_SSLCERTDESCR *p);
02934
02935 const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2_GetFront(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
02936
02937 const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2_GetBack(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
02938
02939 unsigned int GWEN_SslCertDescr_ConstList2_GetSize(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
02940
02941 void GWEN_SslCertDescr_ConstList2_PopBack(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
02942
02943 void GWEN_SslCertDescr_ConstList2_PopFront(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
02944
02945 void GWEN_SslCertDescr_ConstList2_Clear(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
02946
02947 GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *GWEN_SslCertDescr_ConstList2_First(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
02948
02949 GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *GWEN_SslCertDescr_ConstList2_Last(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
02950
02951 GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *GWEN_SslCertDescr_ConstList2Iterator_new(GWEN_SSLCERTDESCR_CONSTLIST2 *l);
02952
02953 void GWEN_SslCertDescr_ConstList2Iterator_free(GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *li);
02954
02955 const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2Iterator_Previous(GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *li);
02956
02957 const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2Iterator_Next(GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *li);
02958
02959 const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2Iterator_Data(GWEN_SSLCERTDESCR_CONSTLIST2_ITERATOR *li);
02960
02972 const GWEN_SSLCERTDESCR *GWEN_SslCertDescr_ConstList2_ForEach(GWEN_SSLCERTDESCR_CONSTLIST2 *list,
02973 GWEN_SSLCERTDESCR_CONSTLIST2_FOREACH func, void *user_data);
02974
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_SSLCERTDESCR_LIST1_H
03014 #define GWEN_SSLCERTDESCR_LIST1_H
03015
03016 #ifdef __cplusplus
03017 extern "C" {
03018 #endif
03019
03021 typedef struct GWEN_SSLCERTDESCR_LIST_ELEMENT {
03022 GWEN_TYPE_UINT32 id;
03023 GWEN_SSLCERTDESCR *nextObject;
03024 } GWEN_SSLCERTDESCR_LIST__ELEMENT;
03025
03032 typedef struct GWEN_SSLCERTDESCR_LIST GWEN_SSLCERTDESCR_LIST;
03034 struct GWEN_SSLCERTDESCR_LIST {
03035 GWEN_SSLCERTDESCR *first;
03036 GWEN_TYPE_UINT32 count;
03037 GWEN_TYPE_UINT32 id;
03038 } GWEN_SSLCERTDESCR_LIST;
03039
03044 void GWEN_SslCertDescr_List_AddList(GWEN_SSLCERTDESCR_LIST *dst, GWEN_SSLCERTDESCR_LIST *l);
03045
03049 void GWEN_SslCertDescr_List_Add(GWEN_SSLCERTDESCR *element, GWEN_SSLCERTDESCR_LIST *list);
03050
03055 void GWEN_SslCertDescr_List_Insert(GWEN_SSLCERTDESCR *element, GWEN_SSLCERTDESCR_LIST *list);
03056
03063 void GWEN_SslCertDescr_List_Del(GWEN_SSLCERTDESCR *element);
03064
03068 GWEN_SSLCERTDESCR* GWEN_SslCertDescr_List_First(const GWEN_SSLCERTDESCR_LIST *l);
03069
03073 GWEN_SSLCERTDESCR* GWEN_SslCertDescr_List_Last(const GWEN_SSLCERTDESCR_LIST *l);
03074
03079 void GWEN_SslCertDescr_List_Clear(GWEN_SSLCERTDESCR_LIST *l);
03080
03084 GWEN_SSLCERTDESCR_LIST* GWEN_SslCertDescr_List_new();
03085
03089 void GWEN_SslCertDescr_List_free(GWEN_SSLCERTDESCR_LIST *l);
03090
03094 GWEN_SSLCERTDESCR* GWEN_SslCertDescr_List_Next(const GWEN_SSLCERTDESCR *element);
03095
03099 GWEN_SSLCERTDESCR* GWEN_SslCertDescr_List_Previous(const GWEN_SSLCERTDESCR *element);
03100
03104 GWEN_TYPE_UINT32 GWEN_SslCertDescr_List_GetCount(const GWEN_SSLCERTDESCR_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_SSLCIPHER_LIST2_H
03144 #define GWEN_SSLCIPHER_LIST2_H
03145
03146
03147 #ifdef __cplusplus
03148 extern "C" {
03149 #endif
03150
03157 typedef struct GWEN_SSLCIPHER_LIST2 GWEN_SSLCIPHER_LIST2;
03158
03162 typedef struct GWEN_SSLCIPHER_LIST2_ITERATOR GWEN_SSLCIPHER_LIST2_ITERATOR;
03163
03167 typedef GWEN_SSLCIPHER* (GWEN_SSLCIPHER_LIST2_FOREACH)(GWEN_SSLCIPHER *element,
03168 void *user_data);
03169
03173 GWEN_SSLCIPHER_LIST2 *GWEN_SslCipher_List2_new();
03174
03178 void GWEN_SslCipher_List2_free(GWEN_SSLCIPHER_LIST2 *l);
03179
03183 void GWEN_SslCipher_List2_Dump(GWEN_SSLCIPHER_LIST2 *l, FILE *f, unsigned int indent);
03184
03188 void GWEN_SslCipher_List2_PushBack(GWEN_SSLCIPHER_LIST2 *l, GWEN_SSLCIPHER *p);
03189
03194 void GWEN_SslCipher_List2_PushFront(GWEN_SSLCIPHER_LIST2 *l, GWEN_SSLCIPHER *p);
03195
03200 GWEN_SSLCIPHER *GWEN_SslCipher_List2_GetFront(GWEN_SSLCIPHER_LIST2 *l);
03201
03206 GWEN_SSLCIPHER *GWEN_SslCipher_List2_GetBack(GWEN_SSLCIPHER_LIST2 *l);
03207
03212 void GWEN_SslCipher_List2_Erase(GWEN_SSLCIPHER_LIST2 *l,
03213 GWEN_SSLCIPHER_LIST2_ITERATOR *it);
03214
03220 unsigned int GWEN_SslCipher_List2_GetSize(GWEN_SSLCIPHER_LIST2 *l);
03221
03226 void GWEN_SslCipher_List2_PopBack(GWEN_SSLCIPHER_LIST2 *l);
03227
03232 void GWEN_SslCipher_List2_PopFront(GWEN_SSLCIPHER_LIST2 *l);
03233
03237 void GWEN_SslCipher_List2_Clear(GWEN_SSLCIPHER_LIST2 *l);
03238
03242 GWEN_SSLCIPHER_LIST2_ITERATOR *GWEN_SslCipher_List2_First(GWEN_SSLCIPHER_LIST2 *l);
03243
03247 GWEN_SSLCIPHER_LIST2_ITERATOR *GWEN_SslCipher_List2_Last(GWEN_SSLCIPHER_LIST2 *l);
03248
03252 GWEN_SSLCIPHER_LIST2_ITERATOR *GWEN_SslCipher_List2Iterator_new(GWEN_SSLCIPHER_LIST2 *l);
03253
03257 void GWEN_SslCipher_List2Iterator_free(GWEN_SSLCIPHER_LIST2_ITERATOR *li);
03258
03263 GWEN_SSLCIPHER *GWEN_SslCipher_List2Iterator_Previous(GWEN_SSLCIPHER_LIST2_ITERATOR *li);
03264
03269 GWEN_SSLCIPHER *GWEN_SslCipher_List2Iterator_Next(GWEN_SSLCIPHER_LIST2_ITERATOR *li);
03270
03275 GWEN_SSLCIPHER *GWEN_SslCipher_List2Iterator_Data(GWEN_SSLCIPHER_LIST2_ITERATOR *li);
03276
03288 GWEN_SSLCIPHER *GWEN_SslCipher_List2_ForEach(GWEN_SSLCIPHER_LIST2 *list,
03289 GWEN_SSLCIPHER_LIST2_FOREACH func,
03290 void *user_data);
03291
03292
03293 typedef struct GWEN_SSLCIPHER_CONSTLIST2 GWEN_SSLCIPHER_CONSTLIST2;
03294 typedef struct GWEN_SSLCIPHER_CONSTLIST2_ITERATOR GWEN_SSLCIPHER_CONSTLIST2_ITERATOR;
03295 typedef const GWEN_SSLCIPHER*
03296 (GWEN_SSLCIPHER_CONSTLIST2_FOREACH)(const GWEN_SSLCIPHER *element,
03297 void *user_data);
03298
03299
03300 GWEN_SSLCIPHER_CONSTLIST2 *GWEN_SslCipher_ConstList2_new();
03301
03302 void GWEN_SslCipher_ConstList2_free(GWEN_SSLCIPHER_CONSTLIST2 *l);
03303
03304 void GWEN_SslCipher_ConstList2_PushBack(GWEN_SSLCIPHER_CONSTLIST2 *l, const GWEN_SSLCIPHER *p);
03305
03306 void GWEN_SslCipher_ConstList2_PushFront(GWEN_SSLCIPHER_CONSTLIST2 *l, const GWEN_SSLCIPHER *p);
03307
03308 const GWEN_SSLCIPHER *GWEN_SslCipher_ConstList2_GetFront(GWEN_SSLCIPHER_CONSTLIST2 *l);
03309
03310 const GWEN_SSLCIPHER *GWEN_SslCipher_ConstList2_GetBack(GWEN_SSLCIPHER_CONSTLIST2 *l);
03311
03312 unsigned int GWEN_SslCipher_ConstList2_GetSize(GWEN_SSLCIPHER_CONSTLIST2 *l);
03313
03314 void GWEN_SslCipher_ConstList2_PopBack(GWEN_SSLCIPHER_CONSTLIST2 *l);
03315
03316 void GWEN_SslCipher_ConstList2_PopFront(GWEN_SSLCIPHER_CONSTLIST2 *l);
03317
03318 void GWEN_SslCipher_ConstList2_Clear(GWEN_SSLCIPHER_CONSTLIST2 *l);
03319
03320 GWEN_SSLCIPHER_CONSTLIST2_ITERATOR *GWEN_SslCipher_ConstList2_First(GWEN_SSLCIPHER_CONSTLIST2 *l);
03321
03322 GWEN_SSLCIPHER_CONSTLIST2_ITERATOR *GWEN_SslCipher_ConstList2_Last(GWEN_SSLCIPHER_CONSTLIST2 *l);
03323
03324 GWEN_SSLCIPHER_CONSTLIST2_ITERATOR *GWEN_SslCipher_ConstList2Iterator_new(GWEN_SSLCIPHER_CONSTLIST2 *l);
03325
03326 void GWEN_SslCipher_ConstList2Iterator_free(GWEN_SSLCIPHER_CONSTLIST2_ITERATOR *li);
03327
03328 const GWEN_SSLCIPHER *GWEN_SslCipher_ConstList2Iterator_Previous(GWEN_SSLCIPHER_CONSTLIST2_ITERATOR *li);
03329
03330 const GWEN_SSLCIPHER *GWEN_SslCipher_ConstList2Iterator_Next(GWEN_SSLCIPHER_CONSTLIST2_ITERATOR *li);
03331
03332 const GWEN_SSLCIPHER *GWEN_SslCipher_ConstList2Iterator_Data(GWEN_SSLCIPHER_CONSTLIST2_ITERATOR *li);
03333
03345 const GWEN_SSLCIPHER *GWEN_SslCipher_ConstList2_ForEach(GWEN_SSLCIPHER_CONSTLIST2 *list,
03346 GWEN_SSLCIPHER_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_SSLCIPHER_LIST1_H
03387 #define GWEN_SSLCIPHER_LIST1_H
03388
03389 #ifdef __cplusplus
03390 extern "C" {
03391 #endif
03392
03394 typedef struct GWEN_SSLCIPHER_LIST_ELEMENT {
03395 GWEN_TYPE_UINT32 id;
03396 GWEN_SSLCIPHER *nextObject;
03397 } GWEN_SSLCIPHER_LIST__ELEMENT;
03398
03405 typedef struct GWEN_SSLCIPHER_LIST GWEN_SSLCIPHER_LIST;
03407 struct GWEN_SSLCIPHER_LIST {
03408 GWEN_SSLCIPHER *first;
03409 GWEN_TYPE_UINT32 count;
03410 GWEN_TYPE_UINT32 id;
03411 } GWEN_SSLCIPHER_LIST;
03412
03417 void GWEN_SslCipher_List_AddList(GWEN_SSLCIPHER_LIST *dst, GWEN_SSLCIPHER_LIST *l);
03418
03422 void GWEN_SslCipher_List_Add(GWEN_SSLCIPHER *element, GWEN_SSLCIPHER_LIST *list);
03423
03428 void GWEN_SslCipher_List_Insert(GWEN_SSLCIPHER *element, GWEN_SSLCIPHER_LIST *list);
03429
03436 void GWEN_SslCipher_List_Del(GWEN_SSLCIPHER *element);
03437
03441 GWEN_SSLCIPHER* GWEN_SslCipher_List_First(const GWEN_SSLCIPHER_LIST *l);
03442
03446 GWEN_SSLCIPHER* GWEN_SslCipher_List_Last(const GWEN_SSLCIPHER_LIST *l);
03447
03452 void GWEN_SslCipher_List_Clear(GWEN_SSLCIPHER_LIST *l);
03453
03457 GWEN_SSLCIPHER_LIST* GWEN_SslCipher_List_new();
03458
03462 void GWEN_SslCipher_List_free(GWEN_SSLCIPHER_LIST *l);
03463
03467 GWEN_SSLCIPHER* GWEN_SslCipher_List_Next(const GWEN_SSLCIPHER *element);
03468
03472 GWEN_SSLCIPHER* GWEN_SslCipher_List_Previous(const GWEN_SSLCIPHER *element);
03473
03477 GWEN_TYPE_UINT32 GWEN_SslCipher_List_GetCount(const GWEN_SSLCIPHER_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_CRYPTTOKEN_LIST1_H
03517 #define GWEN_CRYPTTOKEN_LIST1_H
03518
03519 #ifdef __cplusplus
03520 extern "C" {
03521 #endif
03522
03524 typedef struct GWEN_CRYPTTOKEN_LIST_ELEMENT {
03525 GWEN_TYPE_UINT32 id;
03526 GWEN_CRYPTTOKEN *nextObject;
03527 } GWEN_CRYPTTOKEN_LIST__ELEMENT;
03528
03535 typedef struct GWEN_CRYPTTOKEN_LIST GWEN_CRYPTTOKEN_LIST;
03537 struct GWEN_CRYPTTOKEN_LIST {
03538 GWEN_CRYPTTOKEN *first;
03539 GWEN_TYPE_UINT32 count;
03540 GWEN_TYPE_UINT32 id;
03541 } GWEN_CRYPTTOKEN_LIST;
03542
03547 void GWEN_CryptToken_List_AddList(GWEN_CRYPTTOKEN_LIST *dst, GWEN_CRYPTTOKEN_LIST *l);
03548
03552 void GWEN_CryptToken_List_Add(GWEN_CRYPTTOKEN *element, GWEN_CRYPTTOKEN_LIST *list);
03553
03558 void GWEN_CryptToken_List_Insert(GWEN_CRYPTTOKEN *element, GWEN_CRYPTTOKEN_LIST *list);
03559
03566 void GWEN_CryptToken_List_Del(GWEN_CRYPTTOKEN *element);
03567
03571 GWEN_CRYPTTOKEN* GWEN_CryptToken_List_First(const GWEN_CRYPTTOKEN_LIST *l);
03572
03576 GWEN_CRYPTTOKEN* GWEN_CryptToken_List_Last(const GWEN_CRYPTTOKEN_LIST *l);
03577
03582 void GWEN_CryptToken_List_Clear(GWEN_CRYPTTOKEN_LIST *l);
03583
03587 GWEN_CRYPTTOKEN_LIST* GWEN_CryptToken_List_new();
03588
03592 void GWEN_CryptToken_List_free(GWEN_CRYPTTOKEN_LIST *l);
03593
03597 GWEN_CRYPTTOKEN* GWEN_CryptToken_List_Next(const GWEN_CRYPTTOKEN *element);
03598
03602 GWEN_CRYPTTOKEN* GWEN_CryptToken_List_Previous(const GWEN_CRYPTTOKEN *element);
03603
03607 GWEN_TYPE_UINT32 GWEN_CryptToken_List_GetCount(const GWEN_CRYPTTOKEN_LIST *l);
03608
03609 #ifdef __cplusplus
03610 }
03611 #endif
03612
03613
03614 #endif
03615
03616
03617
03618
03619
03620
03621
03622
03623
03624
03625
03626
03627
03628
03629
03630
03631
03632
03633
03634
03635
03636
03637
03638
03639
03640
03641
03642
03643
03644
03645
03646 #ifndef GWEN_CRYPTTOKEN_CONTEXT_LIST1_H
03647 #define GWEN_CRYPTTOKEN_CONTEXT_LIST1_H
03648
03649 #ifdef __cplusplus
03650 extern "C" {
03651 #endif
03652
03654 typedef struct GWEN_CRYPTTOKEN_CONTEXT_LIST_ELEMENT {
03655 GWEN_TYPE_UINT32 id;
03656 GWEN_CRYPTTOKEN_CONTEXT *nextObject;
03657 } GWEN_CRYPTTOKEN_CONTEXT_LIST__ELEMENT;
03658
03665 typedef struct GWEN_CRYPTTOKEN_CONTEXT_LIST GWEN_CRYPTTOKEN_CONTEXT_LIST;
03667 struct GWEN_CRYPTTOKEN_CONTEXT_LIST {
03668 GWEN_CRYPTTOKEN_CONTEXT *first;
03669 GWEN_TYPE_UINT32 count;
03670 GWEN_TYPE_UINT32 id;
03671 } GWEN_CRYPTTOKEN_CONTEXT_LIST;
03672
03677 void GWEN_CryptToken_Context_List_AddList(GWEN_CRYPTTOKEN_CONTEXT_LIST *dst, GWEN_CRYPTTOKEN_CONTEXT_LIST *l);
03678
03682 void GWEN_CryptToken_Context_List_Add(GWEN_CRYPTTOKEN_CONTEXT *element, GWEN_CRYPTTOKEN_CONTEXT_LIST *list);
03683
03688 void GWEN_CryptToken_Context_List_Insert(GWEN_CRYPTTOKEN_CONTEXT *element, GWEN_CRYPTTOKEN_CONTEXT_LIST *list);
03689
03696 void GWEN_CryptToken_Context_List_Del(GWEN_CRYPTTOKEN_CONTEXT *element);
03697
03701 GWEN_CRYPTTOKEN_CONTEXT* GWEN_CryptToken_Context_List_First(const GWEN_CRYPTTOKEN_CONTEXT_LIST *l);
03702
03706 GWEN_CRYPTTOKEN_CONTEXT* GWEN_CryptToken_Context_List_Last(const GWEN_CRYPTTOKEN_CONTEXT_LIST *l);
03707
03712 void GWEN_CryptToken_Context_List_Clear(GWEN_CRYPTTOKEN_CONTEXT_LIST *l);
03713
03717 GWEN_CRYPTTOKEN_CONTEXT_LIST* GWEN_CryptToken_Context_List_new();
03718
03722 void GWEN_CryptToken_Context_List_free(GWEN_CRYPTTOKEN_CONTEXT_LIST *l);
03723
03727 GWEN_CRYPTTOKEN_CONTEXT* GWEN_CryptToken_Context_List_Next(const GWEN_CRYPTTOKEN_CONTEXT *element);
03728
03732 GWEN_CRYPTTOKEN_CONTEXT* GWEN_CryptToken_Context_List_Previous(const GWEN_CRYPTTOKEN_CONTEXT *element);
03733
03737 GWEN_TYPE_UINT32 GWEN_CryptToken_Context_List_GetCount(const GWEN_CRYPTTOKEN_CONTEXT_LIST *l);
03738
03739 #ifdef __cplusplus
03740 }
03741 #endif
03742
03743
03744 #endif
03745
03746
03747
03748
03749
03750
03751
03752
03753
03754
03755
03756
03757
03758
03759
03760
03761
03762
03763
03764
03765
03766
03767
03768
03769
03770
03771
03772
03773
03774
03775
03776 #ifndef GWEN_CRYPTTOKEN_CRYPTINFO_LIST1_H
03777 #define GWEN_CRYPTTOKEN_CRYPTINFO_LIST1_H
03778
03779 #ifdef __cplusplus
03780 extern "C" {
03781 #endif
03782
03784 typedef struct GWEN_CRYPTTOKEN_CRYPTINFO_LIST_ELEMENT {
03785 GWEN_TYPE_UINT32 id;
03786 GWEN_CRYPTTOKEN_CRYPTINFO *nextObject;
03787 } GWEN_CRYPTTOKEN_CRYPTINFO_LIST__ELEMENT;
03788
03795 typedef struct GWEN_CRYPTTOKEN_CRYPTINFO_LIST GWEN_CRYPTTOKEN_CRYPTINFO_LIST;
03797 struct GWEN_CRYPTTOKEN_CRYPTINFO_LIST {
03798 GWEN_CRYPTTOKEN_CRYPTINFO *first;
03799 GWEN_TYPE_UINT32 count;
03800 GWEN_TYPE_UINT32 id;
03801 } GWEN_CRYPTTOKEN_CRYPTINFO_LIST;
03802
03807 void GWEN_CryptToken_CryptInfo_List_AddList(GWEN_CRYPTTOKEN_CRYPTINFO_LIST *dst, GWEN_CRYPTTOKEN_CRYPTINFO_LIST *l);
03808
03812 void GWEN_CryptToken_CryptInfo_List_Add(GWEN_CRYPTTOKEN_CRYPTINFO *element, GWEN_CRYPTTOKEN_CRYPTINFO_LIST *list);
03813
03818 void GWEN_CryptToken_CryptInfo_List_Insert(GWEN_CRYPTTOKEN_CRYPTINFO *element, GWEN_CRYPTTOKEN_CRYPTINFO_LIST *list);
03819
03826 void GWEN_CryptToken_CryptInfo_List_Del(GWEN_CRYPTTOKEN_CRYPTINFO *element);
03827
03831 GWEN_CRYPTTOKEN_CRYPTINFO* GWEN_CryptToken_CryptInfo_List_First(const GWEN_CRYPTTOKEN_CRYPTINFO_LIST *l);
03832
03836 GWEN_CRYPTTOKEN_CRYPTINFO* GWEN_CryptToken_CryptInfo_List_Last(const GWEN_CRYPTTOKEN_CRYPTINFO_LIST *l);
03837
03842 void GWEN_CryptToken_CryptInfo_List_Clear(GWEN_CRYPTTOKEN_CRYPTINFO_LIST *l);
03843
03847 GWEN_CRYPTTOKEN_CRYPTINFO_LIST* GWEN_CryptToken_CryptInfo_List_new();
03848
03852 void GWEN_CryptToken_CryptInfo_List_free(GWEN_CRYPTTOKEN_CRYPTINFO_LIST *l);
03853
03857 GWEN_CRYPTTOKEN_CRYPTINFO* GWEN_CryptToken_CryptInfo_List_Next(const GWEN_CRYPTTOKEN_CRYPTINFO *element);
03858
03862 GWEN_CRYPTTOKEN_CRYPTINFO* GWEN_CryptToken_CryptInfo_List_Previous(const GWEN_CRYPTTOKEN_CRYPTINFO *element);
03863
03867 GWEN_TYPE_UINT32 GWEN_CryptToken_CryptInfo_List_GetCount(const GWEN_CRYPTTOKEN_CRYPTINFO_LIST *l);
03868
03869 #ifdef __cplusplus
03870 }
03871 #endif
03872
03873
03874 #endif
03875
03876
03877
03878
03879
03880
03881
03882
03883
03884
03885
03886
03887
03888
03889
03890
03891
03892
03893
03894
03895
03896
03897
03898
03899
03900
03901
03902
03903
03904
03905
03906 #ifndef GWEN_CRYPTTOKEN_KEYINFO_LIST1_H
03907 #define GWEN_CRYPTTOKEN_KEYINFO_LIST1_H
03908
03909 #ifdef __cplusplus
03910 extern "C" {
03911 #endif
03912
03914 typedef struct GWEN_CRYPTTOKEN_KEYINFO_LIST_ELEMENT {
03915 GWEN_TYPE_UINT32 id;
03916 GWEN_CRYPTTOKEN_KEYINFO *nextObject;
03917 } GWEN_CRYPTTOKEN_KEYINFO_LIST__ELEMENT;
03918
03925 typedef struct GWEN_CRYPTTOKEN_KEYINFO_LIST GWEN_CRYPTTOKEN_KEYINFO_LIST;
03927 struct GWEN_CRYPTTOKEN_KEYINFO_LIST {
03928 GWEN_CRYPTTOKEN_KEYINFO *first;
03929 GWEN_TYPE_UINT32 count;
03930 GWEN_TYPE_UINT32 id;
03931 } GWEN_CRYPTTOKEN_KEYINFO_LIST;
03932
03937 void GWEN_CryptToken_KeyInfo_List_AddList(GWEN_CRYPTTOKEN_KEYINFO_LIST *dst, GWEN_CRYPTTOKEN_KEYINFO_LIST *l);
03938
03942 void GWEN_CryptToken_KeyInfo_List_Add(GWEN_CRYPTTOKEN_KEYINFO *element, GWEN_CRYPTTOKEN_KEYINFO_LIST *list);
03943
03948 void GWEN_CryptToken_KeyInfo_List_Insert(GWEN_CRYPTTOKEN_KEYINFO *element, GWEN_CRYPTTOKEN_KEYINFO_LIST *list);
03949
03956 void GWEN_CryptToken_KeyInfo_List_Del(GWEN_CRYPTTOKEN_KEYINFO *element);
03957
03961 GWEN_CRYPTTOKEN_KEYINFO* GWEN_CryptToken_KeyInfo_List_First(const GWEN_CRYPTTOKEN_KEYINFO_LIST *l);
03962
03966 GWEN_CRYPTTOKEN_KEYINFO* GWEN_CryptToken_KeyInfo_List_Last(const GWEN_CRYPTTOKEN_KEYINFO_LIST *l);
03967
03972 void GWEN_CryptToken_KeyInfo_List_Clear(GWEN_CRYPTTOKEN_KEYINFO_LIST *l);
03973
03977 GWEN_CRYPTTOKEN_KEYINFO_LIST* GWEN_CryptToken_KeyInfo_List_new();
03978
03982 void GWEN_CryptToken_KeyInfo_List_free(GWEN_CRYPTTOKEN_KEYINFO_LIST *l);
03983
03987 GWEN_CRYPTTOKEN_KEYINFO* GWEN_CryptToken_KeyInfo_List_Next(const GWEN_CRYPTTOKEN_KEYINFO *element);
03988
03992 GWEN_CRYPTTOKEN_KEYINFO* GWEN_CryptToken_KeyInfo_List_Previous(const GWEN_CRYPTTOKEN_KEYINFO *element);
03993
03997 GWEN_TYPE_UINT32 GWEN_CryptToken_KeyInfo_List_GetCount(const GWEN_CRYPTTOKEN_KEYINFO_LIST *l);
03998
03999 #ifdef __cplusplus
04000 }
04001 #endif
04002
04003
04004 #endif
04005
04006
04007
04008
04009
04010
04011
04012
04013
04014
04015
04016
04017
04018
04019
04020
04021
04022
04023
04024
04025
04026
04027
04028
04029
04030
04031
04032
04033
04034
04035
04036 #ifndef GWEN_CRYPTTOKEN_SIGNINFO_LIST1_H
04037 #define GWEN_CRYPTTOKEN_SIGNINFO_LIST1_H
04038
04039 #ifdef __cplusplus
04040 extern "C" {
04041 #endif
04042
04044 typedef struct GWEN_CRYPTTOKEN_SIGNINFO_LIST_ELEMENT {
04045 GWEN_TYPE_UINT32 id;
04046 GWEN_CRYPTTOKEN_SIGNINFO *nextObject;
04047 } GWEN_CRYPTTOKEN_SIGNINFO_LIST__ELEMENT;
04048
04055 typedef struct GWEN_CRYPTTOKEN_SIGNINFO_LIST GWEN_CRYPTTOKEN_SIGNINFO_LIST;
04057 struct GWEN_CRYPTTOKEN_SIGNINFO_LIST {
04058 GWEN_CRYPTTOKEN_SIGNINFO *first;
04059 GWEN_TYPE_UINT32 count;
04060 GWEN_TYPE_UINT32 id;
04061 } GWEN_CRYPTTOKEN_SIGNINFO_LIST;
04062
04067 void GWEN_CryptToken_SignInfo_List_AddList(GWEN_CRYPTTOKEN_SIGNINFO_LIST *dst, GWEN_CRYPTTOKEN_SIGNINFO_LIST *l);
04068
04072 void GWEN_CryptToken_SignInfo_List_Add(GWEN_CRYPTTOKEN_SIGNINFO *element, GWEN_CRYPTTOKEN_SIGNINFO_LIST *list);
04073
04078 void GWEN_CryptToken_SignInfo_List_Insert(GWEN_CRYPTTOKEN_SIGNINFO *element, GWEN_CRYPTTOKEN_SIGNINFO_LIST *list);
04079
04086 void GWEN_CryptToken_SignInfo_List_Del(GWEN_CRYPTTOKEN_SIGNINFO *element);
04087
04091 GWEN_CRYPTTOKEN_SIGNINFO* GWEN_CryptToken_SignInfo_List_First(const GWEN_CRYPTTOKEN_SIGNINFO_LIST *l);
04092
04096 GWEN_CRYPTTOKEN_SIGNINFO* GWEN_CryptToken_SignInfo_List_Last(const GWEN_CRYPTTOKEN_SIGNINFO_LIST *l);
04097
04102 void GWEN_CryptToken_SignInfo_List_Clear(GWEN_CRYPTTOKEN_SIGNINFO_LIST *l);
04103
04107 GWEN_CRYPTTOKEN_SIGNINFO_LIST* GWEN_CryptToken_SignInfo_List_new();
04108
04112 void GWEN_CryptToken_SignInfo_List_free(GWEN_CRYPTTOKEN_SIGNINFO_LIST *l);
04113
04117 GWEN_CRYPTTOKEN_SIGNINFO* GWEN_CryptToken_SignInfo_List_Next(const GWEN_CRYPTTOKEN_SIGNINFO *element);
04118
04122 GWEN_CRYPTTOKEN_SIGNINFO* GWEN_CryptToken_SignInfo_List_Previous(const GWEN_CRYPTTOKEN_SIGNINFO *element);
04123
04127 GWEN_TYPE_UINT32 GWEN_CryptToken_SignInfo_List_GetCount(const GWEN_CRYPTTOKEN_SIGNINFO_LIST *l);
04128
04129 #ifdef __cplusplus
04130 }
04131 #endif
04132
04133
04134 #endif
04135
04136
04137
04138
04139
04140
04141
04142
04143
04144
04145
04146
04147
04148
04149
04150
04151
04152
04153
04154
04155
04156
04157
04158
04159
04160
04161
04162
04163
04164
04165
04166 #ifndef GWEN_CRYPTTOKEN_USER_LIST2_H
04167 #define GWEN_CRYPTTOKEN_USER_LIST2_H
04168
04169
04170 #ifdef __cplusplus
04171 extern "C" {
04172 #endif
04173
04180 typedef struct GWEN_CRYPTTOKEN_USER_LIST2 GWEN_CRYPTTOKEN_USER_LIST2;
04181
04185 typedef struct GWEN_CRYPTTOKEN_USER_LIST2_ITERATOR GWEN_CRYPTTOKEN_USER_LIST2_ITERATOR;
04186
04190 typedef GWEN_CRYPTTOKEN_USER* (GWEN_CRYPTTOKEN_USER_LIST2_FOREACH)(GWEN_CRYPTTOKEN_USER *element,
04191 void *user_data);
04192
04196 GWEN_CRYPTTOKEN_USER_LIST2 *GWEN_CryptToken_User_List2_new();
04197
04201 void GWEN_CryptToken_User_List2_free(GWEN_CRYPTTOKEN_USER_LIST2 *l);
04202
04206 void GWEN_CryptToken_User_List2_Dump(GWEN_CRYPTTOKEN_USER_LIST2 *l, FILE *f, unsigned int indent);
04207
04211 void GWEN_CryptToken_User_List2_PushBack(GWEN_CRYPTTOKEN_USER_LIST2 *l, GWEN_CRYPTTOKEN_USER *p);
04212
04217 void GWEN_CryptToken_User_List2_PushFront(GWEN_CRYPTTOKEN_USER_LIST2 *l, GWEN_CRYPTTOKEN_USER *p);
04218
04223 GWEN_CRYPTTOKEN_USER *GWEN_CryptToken_User_List2_GetFront(GWEN_CRYPTTOKEN_USER_LIST2 *l);
04224
04229 GWEN_CRYPTTOKEN_USER *GWEN_CryptToken_User_List2_GetBack(GWEN_CRYPTTOKEN_USER_LIST2 *l);
04230
04235 void GWEN_CryptToken_User_List2_Erase(GWEN_CRYPTTOKEN_USER_LIST2 *l,
04236 GWEN_CRYPTTOKEN_USER_LIST2_ITERATOR *it);
04237
04243 unsigned int GWEN_CryptToken_User_List2_GetSize(GWEN_CRYPTTOKEN_USER_LIST2 *l);
04244
04249 void GWEN_CryptToken_User_List2_PopBack(GWEN_CRYPTTOKEN_USER_LIST2 *l);
04250
04255 void GWEN_CryptToken_User_List2_PopFront(GWEN_CRYPTTOKEN_USER_LIST2 *l);
04256
04260 void GWEN_CryptToken_User_List2_Clear(GWEN_CRYPTTOKEN_USER_LIST2 *l);
04261
04265 GWEN_CRYPTTOKEN_USER_LIST2_ITERATOR *GWEN_CryptToken_User_List2_First(GWEN_CRYPTTOKEN_USER_LIST2 *l);
04266
04270 GWEN_CRYPTTOKEN_USER_LIST2_ITERATOR *GWEN_CryptToken_User_List2_Last(GWEN_CRYPTTOKEN_USER_LIST2 *l);
04271
04275 GWEN_CRYPTTOKEN_USER_LIST2_ITERATOR *GWEN_CryptToken_User_List2Iterator_new(GWEN_CRYPTTOKEN_USER_LIST2 *l);
04276
04280 void GWEN_CryptToken_User_List2Iterator_free(GWEN_CRYPTTOKEN_USER_LIST2_ITERATOR *li);
04281
04286 GWEN_CRYPTTOKEN_USER *GWEN_CryptToken_User_List2Iterator_Previous(GWEN_CRYPTTOKEN_USER_LIST2_ITERATOR *li);
04287
04292 GWEN_CRYPTTOKEN_USER *GWEN_CryptToken_User_List2Iterator_Next(GWEN_CRYPTTOKEN_USER_LIST2_ITERATOR *li);
04293
04298 GWEN_CRYPTTOKEN_USER *GWEN_CryptToken_User_List2Iterator_Data(GWEN_CRYPTTOKEN_USER_LIST2_ITERATOR *li);
04299
04311 GWEN_CRYPTTOKEN_USER *GWEN_CryptToken_User_List2_ForEach(GWEN_CRYPTTOKEN_USER_LIST2 *list,
04312 GWEN_CRYPTTOKEN_USER_LIST2_FOREACH func,
04313 void *user_data);
04314
04315
04316 typedef struct GWEN_CRYPTTOKEN_USER_CONSTLIST2 GWEN_CRYPTTOKEN_USER_CONSTLIST2;
04317 typedef struct GWEN_CRYPTTOKEN_USER_CONSTLIST2_ITERATOR GWEN_CRYPTTOKEN_USER_CONSTLIST2_ITERATOR;
04318 typedef const GWEN_CRYPTTOKEN_USER*
04319 (GWEN_CRYPTTOKEN_USER_CONSTLIST2_FOREACH)(const GWEN_CRYPTTOKEN_USER *element,
04320 void *user_data);
04321
04322
04323 GWEN_CRYPTTOKEN_USER_CONSTLIST2 *GWEN_CryptToken_User_ConstList2_new();
04324
04325 void GWEN_CryptToken_User_ConstList2_free(GWEN_CRYPTTOKEN_USER_CONSTLIST2 *l);
04326
04327 void GWEN_CryptToken_User_ConstList2_PushBack(GWEN_CRYPTTOKEN_USER_CONSTLIST2 *l, const GWEN_CRYPTTOKEN_USER *p);
04328
04329 void GWEN_CryptToken_User_ConstList2_PushFront(GWEN_CRYPTTOKEN_USER_CONSTLIST2 *l, const GWEN_CRYPTTOKEN_USER *p);
04330
04331 const GWEN_CRYPTTOKEN_USER *GWEN_CryptToken_User_ConstList2_GetFront(GWEN_CRYPTTOKEN_USER_CONSTLIST2 *l);
04332
04333 const GWEN_CRYPTTOKEN_USER *GWEN_CryptToken_User_ConstList2_GetBack(GWEN_CRYPTTOKEN_USER_CONSTLIST2 *l);
04334
04335 unsigned int GWEN_CryptToken_User_ConstList2_GetSize(GWEN_CRYPTTOKEN_USER_CONSTLIST2 *l);
04336
04337 void GWEN_CryptToken_User_ConstList2_PopBack(GWEN_CRYPTTOKEN_USER_CONSTLIST2 *l);
04338
04339 void GWEN_CryptToken_User_ConstList2_PopFront(GWEN_CRYPTTOKEN_USER_CONSTLIST2 *l);
04340
04341 void GWEN_CryptToken_User_ConstList2_Clear(GWEN_CRYPTTOKEN_USER_CONSTLIST2 *l);
04342
04343 GWEN_CRYPTTOKEN_USER_CONSTLIST2_ITERATOR *GWEN_CryptToken_User_ConstList2_First(GWEN_CRYPTTOKEN_USER_CONSTLIST2 *l);
04344
04345 GWEN_CRYPTTOKEN_USER_CONSTLIST2_ITERATOR *GWEN_CryptToken_User_ConstList2_Last(GWEN_CRYPTTOKEN_USER_CONSTLIST2 *l);
04346
04347 GWEN_CRYPTTOKEN_USER_CONSTLIST2_ITERATOR *GWEN_CryptToken_User_ConstList2Iterator_new(GWEN_CRYPTTOKEN_USER_CONSTLIST2 *l);
04348
04349 void GWEN_CryptToken_User_ConstList2Iterator_free(GWEN_CRYPTTOKEN_USER_CONSTLIST2_ITERATOR *li);
04350
04351 const GWEN_CRYPTTOKEN_USER *GWEN_CryptToken_User_ConstList2Iterator_Previous(GWEN_CRYPTTOKEN_USER_CONSTLIST2_ITERATOR *li);
04352
04353 const GWEN_CRYPTTOKEN_USER *GWEN_CryptToken_User_ConstList2Iterator_Next(GWEN_CRYPTTOKEN_USER_CONSTLIST2_ITERATOR *li);
04354
04355 const GWEN_CRYPTTOKEN_USER *GWEN_CryptToken_User_ConstList2Iterator_Data(GWEN_CRYPTTOKEN_USER_CONSTLIST2_ITERATOR *li);
04356
04368 const GWEN_CRYPTTOKEN_USER *GWEN_CryptToken_User_ConstList2_ForEach(GWEN_CRYPTTOKEN_USER_CONSTLIST2 *list,
04369 GWEN_CRYPTTOKEN_USER_CONSTLIST2_FOREACH func, void *user_data);
04370
04371
04372 #ifdef __cplusplus
04373 }
04374 #endif
04375
04376
04377 #endif
04378
04379
04380
04381
04382
04383
04384
04385
04386
04387
04388
04389
04390
04391
04392
04393
04394
04395
04396
04397
04398
04399
04400
04401
04402
04403
04404
04405
04406
04407
04408
04409 #ifndef GWEN_CRYPTTOKEN_USER_LIST1_H
04410 #define GWEN_CRYPTTOKEN_USER_LIST1_H
04411
04412 #ifdef __cplusplus
04413 extern "C" {
04414 #endif
04415
04417 typedef struct GWEN_CRYPTTOKEN_USER_LIST_ELEMENT {
04418 GWEN_TYPE_UINT32 id;
04419 GWEN_CRYPTTOKEN_USER *nextObject;
04420 } GWEN_CRYPTTOKEN_USER_LIST__ELEMENT;
04421
04428 typedef struct GWEN_CRYPTTOKEN_USER_LIST GWEN_CRYPTTOKEN_USER_LIST;
04430 struct GWEN_CRYPTTOKEN_USER_LIST {
04431 GWEN_CRYPTTOKEN_USER *first;
04432 GWEN_TYPE_UINT32 count;
04433 GWEN_TYPE_UINT32 id;
04434 } GWEN_CRYPTTOKEN_USER_LIST;
04435
04440 void GWEN_CryptToken_User_List_AddList(GWEN_CRYPTTOKEN_USER_LIST *dst, GWEN_CRYPTTOKEN_USER_LIST *l);
04441
04445 void GWEN_CryptToken_User_List_Add(GWEN_CRYPTTOKEN_USER *element, GWEN_CRYPTTOKEN_USER_LIST *list);
04446
04451 void GWEN_CryptToken_User_List_Insert(GWEN_CRYPTTOKEN_USER *element, GWEN_CRYPTTOKEN_USER_LIST *list);
04452
04459 void GWEN_CryptToken_User_List_Del(GWEN_CRYPTTOKEN_USER *element);
04460
04464 GWEN_CRYPTTOKEN_USER* GWEN_CryptToken_User_List_First(const GWEN_CRYPTTOKEN_USER_LIST *l);
04465
04469 GWEN_CRYPTTOKEN_USER* GWEN_CryptToken_User_List_Last(const GWEN_CRYPTTOKEN_USER_LIST *l);
04470
04475 void GWEN_CryptToken_User_List_Clear(GWEN_CRYPTTOKEN_USER_LIST *l);
04476
04480 GWEN_CRYPTTOKEN_USER_LIST* GWEN_CryptToken_User_List_new();
04481
04485 void GWEN_CryptToken_User_List_free(GWEN_CRYPTTOKEN_USER_LIST *l);
04486
04490 GWEN_CRYPTTOKEN_USER* GWEN_CryptToken_User_List_Next(const GWEN_CRYPTTOKEN_USER *element);
04491
04495 GWEN_CRYPTTOKEN_USER* GWEN_CryptToken_User_List_Previous(const GWEN_CRYPTTOKEN_USER *element);
04496
04500 GWEN_TYPE_UINT32 GWEN_CryptToken_User_List_GetCount(const GWEN_CRYPTTOKEN_USER_LIST *l);
04501
04502 #ifdef __cplusplus
04503 }
04504 #endif
04505
04506
04507 #endif
04508
04509
04510
04511
04512
04513
04514
04515
04516
04517
04518
04519
04520
04521
04522
04523
04524
04525
04526
04527
04528
04529
04530
04531
04532
04533
04534
04535
04536
04537
04538
04539 #ifndef GWEN_CT_FILE_CONTEXT_LIST2_H
04540 #define GWEN_CT_FILE_CONTEXT_LIST2_H
04541
04542
04543 #ifdef __cplusplus
04544 extern "C" {
04545 #endif
04546
04553 typedef struct GWEN_CT_FILE_CONTEXT_LIST2 GWEN_CT_FILE_CONTEXT_LIST2;
04554
04558 typedef struct GWEN_CT_FILE_CONTEXT_LIST2_ITERATOR GWEN_CT_FILE_CONTEXT_LIST2_ITERATOR;
04559
04563 typedef GWEN_CT_FILE_CONTEXT* (GWEN_CT_FILE_CONTEXT_LIST2_FOREACH)(GWEN_CT_FILE_CONTEXT *element,
04564 void *user_data);
04565
04569 GWEN_CT_FILE_CONTEXT_LIST2 *GWEN_CryptTokenFile_Context_List2_new();
04570
04574 void GWEN_CryptTokenFile_Context_List2_free(GWEN_CT_FILE_CONTEXT_LIST2 *l);
04575
04579 void GWEN_CryptTokenFile_Context_List2_Dump(GWEN_CT_FILE_CONTEXT_LIST2 *l, FILE *f, unsigned int indent);
04580
04584 void GWEN_CryptTokenFile_Context_List2_PushBack(GWEN_CT_FILE_CONTEXT_LIST2 *l, GWEN_CT_FILE_CONTEXT *p);
04585
04590 void GWEN_CryptTokenFile_Context_List2_PushFront(GWEN_CT_FILE_CONTEXT_LIST2 *l, GWEN_CT_FILE_CONTEXT *p);
04591
04596 GWEN_CT_FILE_CONTEXT *GWEN_CryptTokenFile_Context_List2_GetFront(GWEN_CT_FILE_CONTEXT_LIST2 *l);
04597
04602 GWEN_CT_FILE_CONTEXT *GWEN_CryptTokenFile_Context_List2_GetBack(GWEN_CT_FILE_CONTEXT_LIST2 *l);
04603
04608 void GWEN_CryptTokenFile_Context_List2_Erase(GWEN_CT_FILE_CONTEXT_LIST2 *l,
04609 GWEN_CT_FILE_CONTEXT_LIST2_ITERATOR *it);
04610
04616 unsigned int GWEN_CryptTokenFile_Context_List2_GetSize(GWEN_CT_FILE_CONTEXT_LIST2 *l);
04617
04622 void GWEN_CryptTokenFile_Context_List2_PopBack(GWEN_CT_FILE_CONTEXT_LIST2 *l);
04623
04628 void GWEN_CryptTokenFile_Context_List2_PopFront(GWEN_CT_FILE_CONTEXT_LIST2 *l);
04629
04633 void GWEN_CryptTokenFile_Context_List2_Clear(GWEN_CT_FILE_CONTEXT_LIST2 *l);
04634
04638 GWEN_CT_FILE_CONTEXT_LIST2_ITERATOR *GWEN_CryptTokenFile_Context_List2_First(GWEN_CT_FILE_CONTEXT_LIST2 *l);
04639
04643 GWEN_CT_FILE_CONTEXT_LIST2_ITERATOR *GWEN_CryptTokenFile_Context_List2_Last(GWEN_CT_FILE_CONTEXT_LIST2 *l);
04644
04648 GWEN_CT_FILE_CONTEXT_LIST2_ITERATOR *GWEN_CryptTokenFile_Context_List2Iterator_new(GWEN_CT_FILE_CONTEXT_LIST2 *l);
04649
04653 void GWEN_CryptTokenFile_Context_List2Iterator_free(GWEN_CT_FILE_CONTEXT_LIST2_ITERATOR *li);
04654
04659 GWEN_CT_FILE_CONTEXT *GWEN_CryptTokenFile_Context_List2Iterator_Previous(GWEN_CT_FILE_CONTEXT_LIST2_ITERATOR *li);
04660
04665 GWEN_CT_FILE_CONTEXT *GWEN_CryptTokenFile_Context_List2Iterator_Next(GWEN_CT_FILE_CONTEXT_LIST2_ITERATOR *li);
04666
04671 GWEN_CT_FILE_CONTEXT *GWEN_CryptTokenFile_Context_List2Iterator_Data(GWEN_CT_FILE_CONTEXT_LIST2_ITERATOR *li);
04672
04684 GWEN_CT_FILE_CONTEXT *GWEN_CryptTokenFile_Context_List2_ForEach(GWEN_CT_FILE_CONTEXT_LIST2 *list,
04685 GWEN_CT_FILE_CONTEXT_LIST2_FOREACH func,
04686 void *user_data);
04687
04688
04689 typedef struct GWEN_CT_FILE_CONTEXT_CONSTLIST2 GWEN_CT_FILE_CONTEXT_CONSTLIST2;
04690 typedef struct GWEN_CT_FILE_CONTEXT_CONSTLIST2_ITERATOR GWEN_CT_FILE_CONTEXT_CONSTLIST2_ITERATOR;
04691 typedef const GWEN_CT_FILE_CONTEXT*
04692 (GWEN_CT_FILE_CONTEXT_CONSTLIST2_FOREACH)(const GWEN_CT_FILE_CONTEXT *element,
04693 void *user_data);
04694
04695
04696 GWEN_CT_FILE_CONTEXT_CONSTLIST2 *GWEN_CryptTokenFile_Context_ConstList2_new();
04697
04698 void GWEN_CryptTokenFile_Context_ConstList2_free(GWEN_CT_FILE_CONTEXT_CONSTLIST2 *l);
04699
04700 void GWEN_CryptTokenFile_Context_ConstList2_PushBack(GWEN_CT_FILE_CONTEXT_CONSTLIST2 *l, const GWEN_CT_FILE_CONTEXT *p);
04701
04702 void GWEN_CryptTokenFile_Context_ConstList2_PushFront(GWEN_CT_FILE_CONTEXT_CONSTLIST2 *l, const GWEN_CT_FILE_CONTEXT *p);
04703
04704 const GWEN_CT_FILE_CONTEXT *GWEN_CryptTokenFile_Context_ConstList2_GetFront(GWEN_CT_FILE_CONTEXT_CONSTLIST2 *l);
04705
04706 const GWEN_CT_FILE_CONTEXT *GWEN_CryptTokenFile_Context_ConstList2_GetBack(GWEN_CT_FILE_CONTEXT_CONSTLIST2 *l);
04707
04708 unsigned int GWEN_CryptTokenFile_Context_ConstList2_GetSize(GWEN_CT_FILE_CONTEXT_CONSTLIST2 *l);
04709
04710 void GWEN_CryptTokenFile_Context_ConstList2_PopBack(GWEN_CT_FILE_CONTEXT_CONSTLIST2 *l);
04711
04712 void GWEN_CryptTokenFile_Context_ConstList2_PopFront(GWEN_CT_FILE_CONTEXT_CONSTLIST2 *l);
04713
04714 void GWEN_CryptTokenFile_Context_ConstList2_Clear(GWEN_CT_FILE_CONTEXT_CONSTLIST2 *l);
04715
04716 GWEN_CT_FILE_CONTEXT_CONSTLIST2_ITERATOR *GWEN_CryptTokenFile_Context_ConstList2_First(GWEN_CT_FILE_CONTEXT_CONSTLIST2 *l);
04717
04718 GWEN_CT_FILE_CONTEXT_CONSTLIST2_ITERATOR *GWEN_CryptTokenFile_Context_ConstList2_Last(GWEN_CT_FILE_CONTEXT_CONSTLIST2 *l);
04719
04720 GWEN_CT_FILE_CONTEXT_CONSTLIST2_ITERATOR *GWEN_CryptTokenFile_Context_ConstList2Iterator_new(GWEN_CT_FILE_CONTEXT_CONSTLIST2 *l);
04721
04722 void GWEN_CryptTokenFile_Context_ConstList2Iterator_free(GWEN_CT_FILE_CONTEXT_CONSTLIST2_ITERATOR *li);
04723
04724 const GWEN_CT_FILE_CONTEXT *GWEN_CryptTokenFile_Context_ConstList2Iterator_Previous(GWEN_CT_FILE_CONTEXT_CONSTLIST2_ITERATOR *li);
04725
04726 const GWEN_CT_FILE_CONTEXT *GWEN_CryptTokenFile_Context_ConstList2Iterator_Next(GWEN_CT_FILE_CONTEXT_CONSTLIST2_ITERATOR *li);
04727
04728 const GWEN_CT_FILE_CONTEXT *GWEN_CryptTokenFile_Context_ConstList2Iterator_Data(GWEN_CT_FILE_CONTEXT_CONSTLIST2_ITERATOR *li);
04729
04741 const GWEN_CT_FILE_CONTEXT *GWEN_CryptTokenFile_Context_ConstList2_ForEach(GWEN_CT_FILE_CONTEXT_CONSTLIST2 *list,
04742 GWEN_CT_FILE_CONTEXT_CONSTLIST2_FOREACH func, void *user_data);
04743
04744
04745 #ifdef __cplusplus
04746 }
04747 #endif
04748
04749
04750 #endif
04751
04752
04753
04754
04755
04756
04757
04758
04759
04760
04761
04762
04763
04764
04765
04766
04767
04768
04769
04770
04771
04772
04773
04774
04775
04776
04777
04778
04779
04780
04781
04782 #ifndef GWEN_CT_FILE_CONTEXT_LIST1_H
04783 #define GWEN_CT_FILE_CONTEXT_LIST1_H
04784
04785 #ifdef __cplusplus
04786 extern "C" {
04787 #endif
04788
04790 typedef struct GWEN_CT_FILE_CONTEXT_LIST_ELEMENT {
04791 GWEN_TYPE_UINT32 id;
04792 GWEN_CT_FILE_CONTEXT *nextObject;
04793 } GWEN_CT_FILE_CONTEXT_LIST__ELEMENT;
04794
04801 typedef struct GWEN_CT_FILE_CONTEXT_LIST GWEN_CT_FILE_CONTEXT_LIST;
04803 struct GWEN_CT_FILE_CONTEXT_LIST {
04804 GWEN_CT_FILE_CONTEXT *first;
04805 GWEN_TYPE_UINT32 count;
04806 GWEN_TYPE_UINT32 id;
04807 } GWEN_CT_FILE_CONTEXT_LIST;
04808
04813 void GWEN_CryptTokenFile_Context_List_AddList(GWEN_CT_FILE_CONTEXT_LIST *dst, GWEN_CT_FILE_CONTEXT_LIST *l);
04814
04818 void GWEN_CryptTokenFile_Context_List_Add(GWEN_CT_FILE_CONTEXT *element, GWEN_CT_FILE_CONTEXT_LIST *list);
04819
04824 void GWEN_CryptTokenFile_Context_List_Insert(GWEN_CT_FILE_CONTEXT *element, GWEN_CT_FILE_CONTEXT_LIST *list);
04825
04832 void GWEN_CryptTokenFile_Context_List_Del(GWEN_CT_FILE_CONTEXT *element);
04833
04837 GWEN_CT_FILE_CONTEXT* GWEN_CryptTokenFile_Context_List_First(const GWEN_CT_FILE_CONTEXT_LIST *l);
04838
04842 GWEN_CT_FILE_CONTEXT* GWEN_CryptTokenFile_Context_List_Last(const GWEN_CT_FILE_CONTEXT_LIST *l);
04843
04848 void GWEN_CryptTokenFile_Context_List_Clear(GWEN_CT_FILE_CONTEXT_LIST *l);
04849
04853 GWEN_CT_FILE_CONTEXT_LIST* GWEN_CryptTokenFile_Context_List_new();
04854
04858 void GWEN_CryptTokenFile_Context_List_free(GWEN_CT_FILE_CONTEXT_LIST *l);
04859
04863 GWEN_CT_FILE_CONTEXT* GWEN_CryptTokenFile_Context_List_Next(const GWEN_CT_FILE_CONTEXT *element);
04864
04868 GWEN_CT_FILE_CONTEXT* GWEN_CryptTokenFile_Context_List_Previous(const GWEN_CT_FILE_CONTEXT *element);
04869
04873 GWEN_TYPE_UINT32 GWEN_CryptTokenFile_Context_List_GetCount(const GWEN_CT_FILE_CONTEXT_LIST *l);
04874
04875 #ifdef __cplusplus
04876 }
04877 #endif
04878
04879
04880 #endif
04881
04882
04883
04884
04885
04886
04887
04888
04889
04890
04891
04892
04893
04894
04895
04896
04897
04898
04899
04900
04901
04902
04903
04904
04905
04906
04907
04908
04909
04910
04911
04912 #ifndef GWEN_IPC_REQUEST_LIST2_H
04913 #define GWEN_IPC_REQUEST_LIST2_H
04914
04915
04916 #ifdef __cplusplus
04917 extern "C" {
04918 #endif
04919
04926 typedef struct GWEN_IPC_REQUEST_LIST2 GWEN_IPC_REQUEST_LIST2;
04927
04931 typedef struct GWEN_IPC_REQUEST_LIST2_ITERATOR GWEN_IPC_REQUEST_LIST2_ITERATOR;
04932
04936 typedef GWEN_IPC_REQUEST* (GWEN_IPC_REQUEST_LIST2_FOREACH)(GWEN_IPC_REQUEST *element,
04937 void *user_data);
04938
04942 GWEN_IPC_REQUEST_LIST2 *GWEN_IpcRequest_List2_new();
04943
04947 void GWEN_IpcRequest_List2_free(GWEN_IPC_REQUEST_LIST2 *l);
04948
04952 void GWEN_IpcRequest_List2_Dump(GWEN_IPC_REQUEST_LIST2 *l, FILE *f, unsigned int indent);
04953
04957 void GWEN_IpcRequest_List2_PushBack(GWEN_IPC_REQUEST_LIST2 *l, GWEN_IPC_REQUEST *p);
04958
04963 void GWEN_IpcRequest_List2_PushFront(GWEN_IPC_REQUEST_LIST2 *l, GWEN_IPC_REQUEST *p);
04964
04969 GWEN_IPC_REQUEST *GWEN_IpcRequest_List2_GetFront(GWEN_IPC_REQUEST_LIST2 *l);
04970
04975 GWEN_IPC_REQUEST *GWEN_IpcRequest_List2_GetBack(GWEN_IPC_REQUEST_LIST2 *l);
04976
04981 void GWEN_IpcRequest_List2_Erase(GWEN_IPC_REQUEST_LIST2 *l,
04982 GWEN_IPC_REQUEST_LIST2_ITERATOR *it);
04983
04989 unsigned int GWEN_IpcRequest_List2_GetSize(GWEN_IPC_REQUEST_LIST2 *l);
04990
04995 void GWEN_IpcRequest_List2_PopBack(GWEN_IPC_REQUEST_LIST2 *l);
04996
05001 void GWEN_IpcRequest_List2_PopFront(GWEN_IPC_REQUEST_LIST2 *l);
05002
05006 void GWEN_IpcRequest_List2_Clear(GWEN_IPC_REQUEST_LIST2 *l);
05007
05011 GWEN_IPC_REQUEST_LIST2_ITERATOR *GWEN_IpcRequest_List2_First(GWEN_IPC_REQUEST_LIST2 *l);
05012
05016 GWEN_IPC_REQUEST_LIST2_ITERATOR *GWEN_IpcRequest_List2_Last(GWEN_IPC_REQUEST_LIST2 *l);
05017
05021 GWEN_IPC_REQUEST_LIST2_ITERATOR *GWEN_IpcRequest_List2Iterator_new(GWEN_IPC_REQUEST_LIST2 *l);
05022
05026 void GWEN_IpcRequest_List2Iterator_free(GWEN_IPC_REQUEST_LIST2_ITERATOR *li);
05027
05032 GWEN_IPC_REQUEST *GWEN_IpcRequest_List2Iterator_Previous(GWEN_IPC_REQUEST_LIST2_ITERATOR *li);
05033
05038 GWEN_IPC_REQUEST *GWEN_IpcRequest_List2Iterator_Next(GWEN_IPC_REQUEST_LIST2_ITERATOR *li);
05039
05044 GWEN_IPC_REQUEST *GWEN_IpcRequest_List2Iterator_Data(GWEN_IPC_REQUEST_LIST2_ITERATOR *li);
05045
05057 GWEN_IPC_REQUEST *GWEN_IpcRequest_List2_ForEach(GWEN_IPC_REQUEST_LIST2 *list,
05058 GWEN_IPC_REQUEST_LIST2_FOREACH func,
05059 void *user_data);
05060
05061
05062 typedef struct GWEN_IPC_REQUEST_CONSTLIST2 GWEN_IPC_REQUEST_CONSTLIST2;
05063 typedef struct GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR;
05064 typedef const GWEN_IPC_REQUEST*
05065 (GWEN_IPC_REQUEST_CONSTLIST2_FOREACH)(const GWEN_IPC_REQUEST *element,
05066 void *user_data);
05067
05068
05069 GWEN_IPC_REQUEST_CONSTLIST2 *GWEN_IpcRequest_ConstList2_new();
05070
05071 void GWEN_IpcRequest_ConstList2_free(GWEN_IPC_REQUEST_CONSTLIST2 *l);
05072
05073 void GWEN_IpcRequest_ConstList2_PushBack(GWEN_IPC_REQUEST_CONSTLIST2 *l, const GWEN_IPC_REQUEST *p);
05074
05075 void GWEN_IpcRequest_ConstList2_PushFront(GWEN_IPC_REQUEST_CONSTLIST2 *l, const GWEN_IPC_REQUEST *p);
05076
05077 const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2_GetFront(GWEN_IPC_REQUEST_CONSTLIST2 *l);
05078
05079 const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2_GetBack(GWEN_IPC_REQUEST_CONSTLIST2 *l);
05080
05081 unsigned int GWEN_IpcRequest_ConstList2_GetSize(GWEN_IPC_REQUEST_CONSTLIST2 *l);
05082
05083 void GWEN_IpcRequest_ConstList2_PopBack(GWEN_IPC_REQUEST_CONSTLIST2 *l);
05084
05085 void GWEN_IpcRequest_ConstList2_PopFront(GWEN_IPC_REQUEST_CONSTLIST2 *l);
05086
05087 void GWEN_IpcRequest_ConstList2_Clear(GWEN_IPC_REQUEST_CONSTLIST2 *l);
05088
05089 GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *GWEN_IpcRequest_ConstList2_First(GWEN_IPC_REQUEST_CONSTLIST2 *l);
05090
05091 GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *GWEN_IpcRequest_ConstList2_Last(GWEN_IPC_REQUEST_CONSTLIST2 *l);
05092
05093 GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *GWEN_IpcRequest_ConstList2Iterator_new(GWEN_IPC_REQUEST_CONSTLIST2 *l);
05094
05095 void GWEN_IpcRequest_ConstList2Iterator_free(GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *li);
05096
05097 const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2Iterator_Previous(GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *li);
05098
05099 const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2Iterator_Next(GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *li);
05100
05101 const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2Iterator_Data(GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *li);
05102
05114 const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2_ForEach(GWEN_IPC_REQUEST_CONSTLIST2 *list,
05115 GWEN_IPC_REQUEST_CONSTLIST2_FOREACH func, void *user_data);
05116
05117
05118 #ifdef __cplusplus
05119 }
05120 #endif
05121
05122
05123 #endif
05124
05125
05126
05127
05128
05129
05130
05131
05132
05133
05134
05135
05136
05137
05138
05139
05140
05141
05142
05143
05144
05145
05146
05147
05148
05149
05150
05151
05152
05153
05154
05155 #ifndef GWEN_IPC_REQUEST_LIST1_H
05156 #define GWEN_IPC_REQUEST_LIST1_H
05157
05158 #ifdef __cplusplus
05159 extern "C" {
05160 #endif
05161
05163 typedef struct GWEN_IPC_REQUEST_LIST_ELEMENT {
05164 GWEN_TYPE_UINT32 id;
05165 GWEN_IPC_REQUEST *nextObject;
05166 } GWEN_IPC_REQUEST_LIST__ELEMENT;
05167
05174 typedef struct GWEN_IPC_REQUEST_LIST GWEN_IPC_REQUEST_LIST;
05176 struct GWEN_IPC_REQUEST_LIST {
05177 GWEN_IPC_REQUEST *first;
05178 GWEN_TYPE_UINT32 count;
05179 GWEN_TYPE_UINT32 id;
05180 } GWEN_IPC_REQUEST_LIST;
05181
05186 void GWEN_IpcRequest_List_AddList(GWEN_IPC_REQUEST_LIST *dst, GWEN_IPC_REQUEST_LIST *l);
05187
05191 void GWEN_IpcRequest_List_Add(GWEN_IPC_REQUEST *element, GWEN_IPC_REQUEST_LIST *list);
05192
05197 void GWEN_IpcRequest_List_Insert(GWEN_IPC_REQUEST *element, GWEN_IPC_REQUEST_LIST *list);
05198
05205 void GWEN_IpcRequest_List_Del(GWEN_IPC_REQUEST *element);
05206
05210 GWEN_IPC_REQUEST* GWEN_IpcRequest_List_First(const GWEN_IPC_REQUEST_LIST *l);
05211
05215 GWEN_IPC_REQUEST* GWEN_IpcRequest_List_Last(const GWEN_IPC_REQUEST_LIST *l);
05216
05221 void GWEN_IpcRequest_List_Clear(GWEN_IPC_REQUEST_LIST *l);
05222
05226 GWEN_IPC_REQUEST_LIST* GWEN_IpcRequest_List_new();
05227
05231 void GWEN_IpcRequest_List_free(GWEN_IPC_REQUEST_LIST *l);
05232
05236 GWEN_IPC_REQUEST* GWEN_IpcRequest_List_Next(const GWEN_IPC_REQUEST *element);
05237
05241 GWEN_IPC_REQUEST* GWEN_IpcRequest_List_Previous(const GWEN_IPC_REQUEST *element);
05242
05246 GWEN_TYPE_UINT32 GWEN_IpcRequest_List_GetCount(const GWEN_IPC_REQUEST_LIST *l);
05247
05248 #ifdef __cplusplus
05249 }
05250 #endif
05251
05252
05253 #endif
05254
05255
05256
05257
05258
05259
05260
05261
05262
05263
05264
05265
05266
05267
05268
05269
05270
05271
05272
05273
05274
05275
05276
05277
05278
05279
05280
05281
05282
05283
05284
05285 #ifndef GWEN_STO_CLIENT_LIST2_H
05286 #define GWEN_STO_CLIENT_LIST2_H
05287
05288
05289 #ifdef __cplusplus
05290 extern "C" {
05291 #endif
05292
05299 typedef struct GWEN_STO_CLIENT_LIST2 GWEN_STO_CLIENT_LIST2;
05300
05304 typedef struct GWEN_STO_CLIENT_LIST2_ITERATOR GWEN_STO_CLIENT_LIST2_ITERATOR;
05305
05309 typedef GWEN_STO_CLIENT* (GWEN_STO_CLIENT_LIST2_FOREACH)(GWEN_STO_CLIENT *element,
05310 void *user_data);
05311
05315 GWEN_STO_CLIENT_LIST2 *GWEN_StoClient_List2_new();
05316
05320 void GWEN_StoClient_List2_free(GWEN_STO_CLIENT_LIST2 *l);
05321
05325 void GWEN_StoClient_List2_Dump(GWEN_STO_CLIENT_LIST2 *l, FILE *f, unsigned int indent);
05326
05330 void GWEN_StoClient_List2_PushBack(GWEN_STO_CLIENT_LIST2 *l, GWEN_STO_CLIENT *p);
05331
05336 void GWEN_StoClient_List2_PushFront(GWEN_STO_CLIENT_LIST2 *l, GWEN_STO_CLIENT *p);
05337
05342 GWEN_STO_CLIENT *GWEN_StoClient_List2_GetFront(GWEN_STO_CLIENT_LIST2 *l);
05343
05348 GWEN_STO_CLIENT *GWEN_StoClient_List2_GetBack(GWEN_STO_CLIENT_LIST2 *l);
05349
05354 void GWEN_StoClient_List2_Erase(GWEN_STO_CLIENT_LIST2 *l,
05355 GWEN_STO_CLIENT_LIST2_ITERATOR *it);
05356
05362 unsigned int GWEN_StoClient_List2_GetSize(GWEN_STO_CLIENT_LIST2 *l);
05363
05368 void GWEN_StoClient_List2_PopBack(GWEN_STO_CLIENT_LIST2 *l);
05369
05374 void GWEN_StoClient_List2_PopFront(GWEN_STO_CLIENT_LIST2 *l);
05375
05379 void GWEN_StoClient_List2_Clear(GWEN_STO_CLIENT_LIST2 *l);
05380
05384 GWEN_STO_CLIENT_LIST2_ITERATOR *GWEN_StoClient_List2_First(GWEN_STO_CLIENT_LIST2 *l);
05385
05389 GWEN_STO_CLIENT_LIST2_ITERATOR *GWEN_StoClient_List2_Last(GWEN_STO_CLIENT_LIST2 *l);
05390
05394 GWEN_STO_CLIENT_LIST2_ITERATOR *GWEN_StoClient_List2Iterator_new(GWEN_STO_CLIENT_LIST2 *l);
05395
05399 void GWEN_StoClient_List2Iterator_free(GWEN_STO_CLIENT_LIST2_ITERATOR *li);
05400
05405 GWEN_STO_CLIENT *GWEN_StoClient_List2Iterator_Previous(GWEN_STO_CLIENT_LIST2_ITERATOR *li);
05406
05411 GWEN_STO_CLIENT *GWEN_StoClient_List2Iterator_Next(GWEN_STO_CLIENT_LIST2_ITERATOR *li);
05412
05417 GWEN_STO_CLIENT *GWEN_StoClient_List2Iterator_Data(GWEN_STO_CLIENT_LIST2_ITERATOR *li);
05418
05430 GWEN_STO_CLIENT *GWEN_StoClient_List2_ForEach(GWEN_STO_CLIENT_LIST2 *list,
05431 GWEN_STO_CLIENT_LIST2_FOREACH func,
05432 void *user_data);
05433
05434
05435 typedef struct GWEN_STO_CLIENT_CONSTLIST2 GWEN_STO_CLIENT_CONSTLIST2;
05436 typedef struct GWEN_STO_CLIENT_CONSTLIST2_ITERATOR GWEN_STO_CLIENT_CONSTLIST2_ITERATOR;
05437 typedef const GWEN_STO_CLIENT*
05438 (GWEN_STO_CLIENT_CONSTLIST2_FOREACH)(const GWEN_STO_CLIENT *element,
05439 void *user_data);
05440
05441
05442 GWEN_STO_CLIENT_CONSTLIST2 *GWEN_StoClient_ConstList2_new();
05443
05444 void GWEN_StoClient_ConstList2_free(GWEN_STO_CLIENT_CONSTLIST2 *l);
05445
05446 void GWEN_StoClient_ConstList2_PushBack(GWEN_STO_CLIENT_CONSTLIST2 *l, const GWEN_STO_CLIENT *p);
05447
05448 void GWEN_StoClient_ConstList2_PushFront(GWEN_STO_CLIENT_CONSTLIST2 *l, const GWEN_STO_CLIENT *p);
05449
05450 const GWEN_STO_CLIENT *GWEN_StoClient_ConstList2_GetFront(GWEN_STO_CLIENT_CONSTLIST2 *l);
05451
05452 const GWEN_STO_CLIENT *GWEN_StoClient_ConstList2_GetBack(GWEN_STO_CLIENT_CONSTLIST2 *l);
05453
05454 unsigned int GWEN_StoClient_ConstList2_GetSize(GWEN_STO_CLIENT_CONSTLIST2 *l);
05455
05456 void GWEN_StoClient_ConstList2_PopBack(GWEN_STO_CLIENT_CONSTLIST2 *l);
05457
05458 void GWEN_StoClient_ConstList2_PopFront(GWEN_STO_CLIENT_CONSTLIST2 *l);
05459
05460 void GWEN_StoClient_ConstList2_Clear(GWEN_STO_CLIENT_CONSTLIST2 *l);
05461
05462 GWEN_STO_CLIENT_CONSTLIST2_ITERATOR *GWEN_StoClient_ConstList2_First(GWEN_STO_CLIENT_CONSTLIST2 *l);
05463
05464 GWEN_STO_CLIENT_CONSTLIST2_ITERATOR *GWEN_StoClient_ConstList2_Last(GWEN_STO_CLIENT_CONSTLIST2 *l);
05465
05466 GWEN_STO_CLIENT_CONSTLIST2_ITERATOR *GWEN_StoClient_ConstList2Iterator_new(GWEN_STO_CLIENT_CONSTLIST2 *l);
05467
05468 void GWEN_StoClient_ConstList2Iterator_free(GWEN_STO_CLIENT_CONSTLIST2_ITERATOR *li);
05469
05470 const GWEN_STO_CLIENT *GWEN_StoClient_ConstList2Iterator_Previous(GWEN_STO_CLIENT_CONSTLIST2_ITERATOR *li);
05471
05472 const GWEN_STO_CLIENT *GWEN_StoClient_ConstList2Iterator_Next(GWEN_STO_CLIENT_CONSTLIST2_ITERATOR *li);
05473
05474 const GWEN_STO_CLIENT *GWEN_StoClient_ConstList2Iterator_Data(GWEN_STO_CLIENT_CONSTLIST2_ITERATOR *li);
05475
05487 const GWEN_STO_CLIENT *GWEN_StoClient_ConstList2_ForEach(GWEN_STO_CLIENT_CONSTLIST2 *list,
05488 GWEN_STO_CLIENT_CONSTLIST2_FOREACH func, void *user_data);
05489
05490
05491 #ifdef __cplusplus
05492 }
05493 #endif
05494
05495
05496 #endif
05497
05498
05499
05500
05501
05502
05503
05504
05505
05506
05507
05508
05509
05510
05511
05512
05513
05514
05515
05516
05517
05518
05519
05520
05521
05522
05523
05524
05525
05526
05527
05528 #ifndef GWEN_STO_CLIENT_LIST1_H
05529 #define GWEN_STO_CLIENT_LIST1_H
05530
05531 #ifdef __cplusplus
05532 extern "C" {
05533 #endif
05534
05536 typedef struct GWEN_STO_CLIENT_LIST_ELEMENT {
05537 GWEN_TYPE_UINT32 id;
05538 GWEN_STO_CLIENT *nextObject;
05539 } GWEN_STO_CLIENT_LIST__ELEMENT;
05540
05547 typedef struct GWEN_STO_CLIENT_LIST GWEN_STO_CLIENT_LIST;
05549 struct GWEN_STO_CLIENT_LIST {
05550 GWEN_STO_CLIENT *first;
05551 GWEN_TYPE_UINT32 count;
05552 GWEN_TYPE_UINT32 id;
05553 } GWEN_STO_CLIENT_LIST;
05554
05559 void GWEN_StoClient_List_AddList(GWEN_STO_CLIENT_LIST *dst, GWEN_STO_CLIENT_LIST *l);
05560
05564 void GWEN_StoClient_List_Add(GWEN_STO_CLIENT *element, GWEN_STO_CLIENT_LIST *list);
05565
05570 void GWEN_StoClient_List_Insert(GWEN_STO_CLIENT *element, GWEN_STO_CLIENT_LIST *list);
05571
05578 void GWEN_StoClient_List_Del(GWEN_STO_CLIENT *element);
05579
05583 GWEN_STO_CLIENT* GWEN_StoClient_List_First(const GWEN_STO_CLIENT_LIST *l);
05584
05588 GWEN_STO_CLIENT* GWEN_StoClient_List_Last(const GWEN_STO_CLIENT_LIST *l);
05589
05594 void GWEN_StoClient_List_Clear(GWEN_STO_CLIENT_LIST *l);
05595
05599 GWEN_STO_CLIENT_LIST* GWEN_StoClient_List_new();
05600
05604 void GWEN_StoClient_List_free(GWEN_STO_CLIENT_LIST *l);
05605
05609 GWEN_STO_CLIENT* GWEN_StoClient_List_Next(const GWEN_STO_CLIENT *element);
05610
05614 GWEN_STO_CLIENT* GWEN_StoClient_List_Previous(const GWEN_STO_CLIENT *element);
05615
05619 GWEN_TYPE_UINT32 GWEN_StoClient_List_GetCount(const GWEN_STO_CLIENT_LIST *l);
05620
05621 #ifdef __cplusplus
05622 }
05623 #endif
05624
05625
05626 #endif
05627
05628
05629
05630
05631
05632
05633
05634
05635
05636
05637
05638
05639
05640
05641
05642
05643
05644
05645
05646
05647
05648
05649
05650
05651
05652
05653
05654
05655
05656
05657
05658 #ifndef GWEN_STO_FIND_LIST1_H
05659 #define GWEN_STO_FIND_LIST1_H
05660
05661 #ifdef __cplusplus
05662 extern "C" {
05663 #endif
05664
05666 typedef struct GWEN_STO_FIND_LIST_ELEMENT {
05667 GWEN_TYPE_UINT32 id;
05668 GWEN_STO_FIND *nextObject;
05669 } GWEN_STO_FIND_LIST__ELEMENT;
05670
05677 typedef struct GWEN_STO_FIND_LIST GWEN_STO_FIND_LIST;
05679 struct GWEN_STO_FIND_LIST {
05680 GWEN_STO_FIND *first;
05681 GWEN_TYPE_UINT32 count;
05682 GWEN_TYPE_UINT32 id;
05683 } GWEN_STO_FIND_LIST;
05684
05689 void GWEN_StoFind_List_AddList(GWEN_STO_FIND_LIST *dst, GWEN_STO_FIND_LIST *l);
05690
05694 void GWEN_StoFind_List_Add(GWEN_STO_FIND *element, GWEN_STO_FIND_LIST *list);
05695
05700 void GWEN_StoFind_List_Insert(GWEN_STO_FIND *element, GWEN_STO_FIND_LIST *list);
05701
05708 void GWEN_StoFind_List_Del(GWEN_STO_FIND *element);
05709
05713 GWEN_STO_FIND* GWEN_StoFind_List_First(const GWEN_STO_FIND_LIST *l);
05714
05718 GWEN_STO_FIND* GWEN_StoFind_List_Last(const GWEN_STO_FIND_LIST *l);
05719
05724 void GWEN_StoFind_List_Clear(GWEN_STO_FIND_LIST *l);
05725
05729 GWEN_STO_FIND_LIST* GWEN_StoFind_List_new();
05730
05734 void GWEN_StoFind_List_free(GWEN_STO_FIND_LIST *l);
05735
05739 GWEN_STO_FIND* GWEN_StoFind_List_Next(const GWEN_STO_FIND *element);
05740
05744 GWEN_STO_FIND* GWEN_StoFind_List_Previous(const GWEN_STO_FIND *element);
05745
05749 GWEN_TYPE_UINT32 GWEN_StoFind_List_GetCount(const GWEN_STO_FIND_LIST *l);
05750
05751 #ifdef __cplusplus
05752 }
05753 #endif
05754
05755
05756 #endif
05757
05758
05759
05760
05761
05762
05763
05764
05765
05766
05767
05768
05769
05770
05771
05772
05773
05774
05775
05776
05777
05778
05779
05780
05781
05782
05783
05784
05785
05786
05787
05788 #ifndef GWEN_STO_LOG_LIST1_H
05789 #define GWEN_STO_LOG_LIST1_H
05790
05791 #ifdef __cplusplus
05792 extern "C" {
05793 #endif
05794
05796 typedef struct GWEN_STO_LOG_LIST_ELEMENT {
05797 GWEN_TYPE_UINT32 id;
05798 GWEN_STO_LOG *nextObject;
05799 } GWEN_STO_LOG_LIST__ELEMENT;
05800
05807 typedef struct GWEN_STO_LOG_LIST GWEN_STO_LOG_LIST;
05809 struct GWEN_STO_LOG_LIST {
05810 GWEN_STO_LOG *first;
05811 GWEN_TYPE_UINT32 count;
05812 GWEN_TYPE_UINT32 id;
05813 } GWEN_STO_LOG_LIST;
05814
05819 void GWEN_StoLog_List_AddList(GWEN_STO_LOG_LIST *dst, GWEN_STO_LOG_LIST *l);
05820
05824 void GWEN_StoLog_List_Add(GWEN_STO_LOG *element, GWEN_STO_LOG_LIST *list);
05825
05830 void GWEN_StoLog_List_Insert(GWEN_STO_LOG *element, GWEN_STO_LOG_LIST *list);
05831
05838 void GWEN_StoLog_List_Del(GWEN_STO_LOG *element);
05839
05843 GWEN_STO_LOG* GWEN_StoLog_List_First(const GWEN_STO_LOG_LIST *l);
05844
05848 GWEN_STO_LOG* GWEN_StoLog_List_Last(const GWEN_STO_LOG_LIST *l);
05849
05854 void GWEN_StoLog_List_Clear(GWEN_STO_LOG_LIST *l);
05855
05859 GWEN_STO_LOG_LIST* GWEN_StoLog_List_new();
05860
05864 void GWEN_StoLog_List_free(GWEN_STO_LOG_LIST *l);
05865
05869 GWEN_STO_LOG* GWEN_StoLog_List_Next(const GWEN_STO_LOG *element);
05870
05874 GWEN_STO_LOG* GWEN_StoLog_List_Previous(const GWEN_STO_LOG *element);
05875
05879 GWEN_TYPE_UINT32 GWEN_StoLog_List_GetCount(const GWEN_STO_LOG_LIST *l);
05880
05881 #ifdef __cplusplus
05882 }
05883 #endif
05884
05885
05886 #endif
05887
05888
05889
05890
05891
05892
05893
05894
05895
05896
05897
05898
05899
05900
05901
05902
05903
05904
05905
05906
05907
05908
05909
05910
05911
05912
05913
05914
05915
05916
05917
05918 #ifndef GWEN_STO_OBJECT_LIST2_H
05919 #define GWEN_STO_OBJECT_LIST2_H
05920
05921
05922 #ifdef __cplusplus
05923 extern "C" {
05924 #endif
05925
05932 typedef struct GWEN_STO_OBJECT_LIST2 GWEN_STO_OBJECT_LIST2;
05933
05937 typedef struct GWEN_STO_OBJECT_LIST2_ITERATOR GWEN_STO_OBJECT_LIST2_ITERATOR;
05938
05942 typedef GWEN_STO_OBJECT* (GWEN_STO_OBJECT_LIST2_FOREACH)(GWEN_STO_OBJECT *element,
05943 void *user_data);
05944
05948 GWEN_STO_OBJECT_LIST2 *GWEN_StoObject_List2_new();
05949
05953 void GWEN_StoObject_List2_free(GWEN_STO_OBJECT_LIST2 *l);
05954
05958 void GWEN_StoObject_List2_Dump(GWEN_STO_OBJECT_LIST2 *l, FILE *f, unsigned int indent);
05959
05963 void GWEN_StoObject_List2_PushBack(GWEN_STO_OBJECT_LIST2 *l, GWEN_STO_OBJECT *p);
05964
05969 void GWEN_StoObject_List2_PushFront(GWEN_STO_OBJECT_LIST2 *l, GWEN_STO_OBJECT *p);
05970
05975 GWEN_STO_OBJECT *GWEN_StoObject_List2_GetFront(GWEN_STO_OBJECT_LIST2 *l);
05976
05981 GWEN_STO_OBJECT *GWEN_StoObject_List2_GetBack(GWEN_STO_OBJECT_LIST2 *l);
05982
05987 void GWEN_StoObject_List2_Erase(GWEN_STO_OBJECT_LIST2 *l,
05988 GWEN_STO_OBJECT_LIST2_ITERATOR *it);
05989
05995 unsigned int GWEN_StoObject_List2_GetSize(GWEN_STO_OBJECT_LIST2 *l);
05996
06001 void GWEN_StoObject_List2_PopBack(GWEN_STO_OBJECT_LIST2 *l);
06002
06007 void GWEN_StoObject_List2_PopFront(GWEN_STO_OBJECT_LIST2 *l);
06008
06012 void GWEN_StoObject_List2_Clear(GWEN_STO_OBJECT_LIST2 *l);
06013
06017 GWEN_STO_OBJECT_LIST2_ITERATOR *GWEN_StoObject_List2_First(GWEN_STO_OBJECT_LIST2 *l);
06018
06022 GWEN_STO_OBJECT_LIST2_ITERATOR *GWEN_StoObject_List2_Last(GWEN_STO_OBJECT_LIST2 *l);
06023
06027 GWEN_STO_OBJECT_LIST2_ITERATOR *GWEN_StoObject_List2Iterator_new(GWEN_STO_OBJECT_LIST2 *l);
06028
06032 void GWEN_StoObject_List2Iterator_free(GWEN_STO_OBJECT_LIST2_ITERATOR *li);
06033
06038 GWEN_STO_OBJECT *GWEN_StoObject_List2Iterator_Previous(GWEN_STO_OBJECT_LIST2_ITERATOR *li);
06039
06044 GWEN_STO_OBJECT *GWEN_StoObject_List2Iterator_Next(GWEN_STO_OBJECT_LIST2_ITERATOR *li);
06045
06050 GWEN_STO_OBJECT *GWEN_StoObject_List2Iterator_Data(GWEN_STO_OBJECT_LIST2_ITERATOR *li);
06051
06063 GWEN_STO_OBJECT *GWEN_StoObject_List2_ForEach(GWEN_STO_OBJECT_LIST2 *list,
06064 GWEN_STO_OBJECT_LIST2_FOREACH func,
06065 void *user_data);
06066
06067
06068 typedef struct GWEN_STO_OBJECT_CONSTLIST2 GWEN_STO_OBJECT_CONSTLIST2;
06069 typedef struct GWEN_STO_OBJECT_CONSTLIST2_ITERATOR GWEN_STO_OBJECT_CONSTLIST2_ITERATOR;
06070 typedef const GWEN_STO_OBJECT*
06071 (GWEN_STO_OBJECT_CONSTLIST2_FOREACH)(const GWEN_STO_OBJECT *element,
06072 void *user_data);
06073
06074
06075 GWEN_STO_OBJECT_CONSTLIST2 *GWEN_StoObject_ConstList2_new();
06076
06077 void GWEN_StoObject_ConstList2_free(GWEN_STO_OBJECT_CONSTLIST2 *l);
06078
06079 void GWEN_StoObject_ConstList2_PushBack(GWEN_STO_OBJECT_CONSTLIST2 *l, const GWEN_STO_OBJECT *p);
06080
06081 void GWEN_StoObject_ConstList2_PushFront(GWEN_STO_OBJECT_CONSTLIST2 *l, const GWEN_STO_OBJECT *p);
06082
06083 const GWEN_STO_OBJECT *GWEN_StoObject_ConstList2_GetFront(GWEN_STO_OBJECT_CONSTLIST2 *l);
06084
06085 const GWEN_STO_OBJECT *GWEN_StoObject_ConstList2_GetBack(GWEN_STO_OBJECT_CONSTLIST2 *l);
06086
06087 unsigned int GWEN_StoObject_ConstList2_GetSize(GWEN_STO_OBJECT_CONSTLIST2 *l);
06088
06089 void GWEN_StoObject_ConstList2_PopBack(GWEN_STO_OBJECT_CONSTLIST2 *l);
06090
06091 void GWEN_StoObject_ConstList2_PopFront(GWEN_STO_OBJECT_CONSTLIST2 *l);
06092
06093 void GWEN_StoObject_ConstList2_Clear(GWEN_STO_OBJECT_CONSTLIST2 *l);
06094
06095 GWEN_STO_OBJECT_CONSTLIST2_ITERATOR *GWEN_StoObject_ConstList2_First(GWEN_STO_OBJECT_CONSTLIST2 *l);
06096
06097 GWEN_STO_OBJECT_CONSTLIST2_ITERATOR *GWEN_StoObject_ConstList2_Last(GWEN_STO_OBJECT_CONSTLIST2 *l);
06098
06099 GWEN_STO_OBJECT_CONSTLIST2_ITERATOR *GWEN_StoObject_ConstList2Iterator_new(GWEN_STO_OBJECT_CONSTLIST2 *l);
06100
06101 void GWEN_StoObject_ConstList2Iterator_free(GWEN_STO_OBJECT_CONSTLIST2_ITERATOR *li);
06102
06103 const GWEN_STO_OBJECT *GWEN_StoObject_ConstList2Iterator_Previous(GWEN_STO_OBJECT_CONSTLIST2_ITERATOR *li);
06104
06105 const GWEN_STO_OBJECT *GWEN_StoObject_ConstList2Iterator_Next(GWEN_STO_OBJECT_CONSTLIST2_ITERATOR *li);
06106
06107 const GWEN_STO_OBJECT *GWEN_StoObject_ConstList2Iterator_Data(GWEN_STO_OBJECT_CONSTLIST2_ITERATOR *li);
06108
06120 const GWEN_STO_OBJECT *GWEN_StoObject_ConstList2_ForEach(GWEN_STO_OBJECT_CONSTLIST2 *list,
06121 GWEN_STO_OBJECT_CONSTLIST2_FOREACH func, void *user_data);
06122
06123
06124 #ifdef __cplusplus
06125 }
06126 #endif
06127
06128
06129 #endif
06130
06131
06132
06133
06134
06135
06136
06137
06138
06139
06140
06141
06142
06143
06144
06145
06146
06147
06148
06149
06150
06151
06152
06153
06154
06155
06156
06157
06158
06159
06160
06161 #ifndef GWEN_STO_OBJECT_LIST1_H
06162 #define GWEN_STO_OBJECT_LIST1_H
06163
06164 #ifdef __cplusplus
06165 extern "C" {
06166 #endif
06167
06169 typedef struct GWEN_STO_OBJECT_LIST_ELEMENT {
06170 GWEN_TYPE_UINT32 id;
06171 GWEN_STO_OBJECT *nextObject;
06172 } GWEN_STO_OBJECT_LIST__ELEMENT;
06173
06180 typedef struct GWEN_STO_OBJECT_LIST GWEN_STO_OBJECT_LIST;
06182 struct GWEN_STO_OBJECT_LIST {
06183 GWEN_STO_OBJECT *first;
06184 GWEN_TYPE_UINT32 count;
06185 GWEN_TYPE_UINT32 id;
06186 } GWEN_STO_OBJECT_LIST;
06187
06192 void GWEN_StoObject_List_AddList(GWEN_STO_OBJECT_LIST *dst, GWEN_STO_OBJECT_LIST *l);
06193
06197 void GWEN_StoObject_List_Add(GWEN_STO_OBJECT *element, GWEN_STO_OBJECT_LIST *list);
06198
06203 void GWEN_StoObject_List_Insert(GWEN_STO_OBJECT *element, GWEN_STO_OBJECT_LIST *list);
06204
06211 void GWEN_StoObject_List_Del(GWEN_STO_OBJECT *element);
06212
06216 GWEN_STO_OBJECT* GWEN_StoObject_List_First(const GWEN_STO_OBJECT_LIST *l);
06217
06221 GWEN_STO_OBJECT* GWEN_StoObject_List_Last(const GWEN_STO_OBJECT_LIST *l);
06222
06227 void GWEN_StoObject_List_Clear(GWEN_STO_OBJECT_LIST *l);
06228
06232 GWEN_STO_OBJECT_LIST* GWEN_StoObject_List_new();
06233
06237 void GWEN_StoObject_List_free(GWEN_STO_OBJECT_LIST *l);
06238
06242 GWEN_STO_OBJECT* GWEN_StoObject_List_Next(const GWEN_STO_OBJECT *element);
06243
06247 GWEN_STO_OBJECT* GWEN_StoObject_List_Previous(const GWEN_STO_OBJECT *element);
06248
06252 GWEN_TYPE_UINT32 GWEN_StoObject_List_GetCount(const GWEN_STO_OBJECT_LIST *l);
06253
06254 #ifdef __cplusplus
06255 }
06256 #endif
06257
06258
06259 #endif
06260
06261
06262
06263
06264
06265
06266
06267
06268
06269
06270
06271
06272
06273
06274
06275
06276
06277
06278
06279
06280
06281
06282
06283
06284
06285
06286
06287
06288
06289
06290
06291 #ifndef GWEN_STO_STORAGE_LIST1_H
06292 #define GWEN_STO_STORAGE_LIST1_H
06293
06294 #ifdef __cplusplus
06295 extern "C" {
06296 #endif
06297
06299 typedef struct GWEN_STO_STORAGE_LIST_ELEMENT {
06300 GWEN_TYPE_UINT32 id;
06301 GWEN_STO_STORAGE *nextObject;
06302 } GWEN_STO_STORAGE_LIST__ELEMENT;
06303
06310 typedef struct GWEN_STO_STORAGE_LIST GWEN_STO_STORAGE_LIST;
06312 struct GWEN_STO_STORAGE_LIST {
06313 GWEN_STO_STORAGE *first;
06314 GWEN_TYPE_UINT32 count;
06315 GWEN_TYPE_UINT32 id;
06316 } GWEN_STO_STORAGE_LIST;
06317
06322 void GWEN_StoStorage_List_AddList(GWEN_STO_STORAGE_LIST *dst, GWEN_STO_STORAGE_LIST *l);
06323
06327 void GWEN_StoStorage_List_Add(GWEN_STO_STORAGE *element, GWEN_STO_STORAGE_LIST *list);
06328
06333 void GWEN_StoStorage_List_Insert(GWEN_STO_STORAGE *element, GWEN_STO_STORAGE_LIST *list);
06334
06341 void GWEN_StoStorage_List_Del(GWEN_STO_STORAGE *element);
06342
06346 GWEN_STO_STORAGE* GWEN_StoStorage_List_First(const GWEN_STO_STORAGE_LIST *l);
06347
06351 GWEN_STO_STORAGE* GWEN_StoStorage_List_Last(const GWEN_STO_STORAGE_LIST *l);
06352
06357 void GWEN_StoStorage_List_Clear(GWEN_STO_STORAGE_LIST *l);
06358
06362 GWEN_STO_STORAGE_LIST* GWEN_StoStorage_List_new();
06363
06367 void GWEN_StoStorage_List_free(GWEN_STO_STORAGE_LIST *l);
06368
06372 GWEN_STO_STORAGE* GWEN_StoStorage_List_Next(const GWEN_STO_STORAGE *element);
06373
06377 GWEN_STO_STORAGE* GWEN_StoStorage_List_Previous(const GWEN_STO_STORAGE *element);
06378
06382 GWEN_TYPE_UINT32 GWEN_StoStorage_List_GetCount(const GWEN_STO_STORAGE_LIST *l);
06383
06384 #ifdef __cplusplus
06385 }
06386 #endif
06387
06388
06389 #endif
06390
06391
06392
06393
06394
06395
06396
06397
06398
06399
06400
06401
06402
06403
06404
06405
06406
06407
06408
06409
06410
06411
06412
06413
06414
06415
06416
06417
06418
06419
06420
06421 #ifndef GWEN_STO_TYPE_LIST2_H
06422 #define GWEN_STO_TYPE_LIST2_H
06423
06424
06425 #ifdef __cplusplus
06426 extern "C" {
06427 #endif
06428
06435 typedef struct GWEN_STO_TYPE_LIST2 GWEN_STO_TYPE_LIST2;
06436
06440 typedef struct GWEN_STO_TYPE_LIST2_ITERATOR GWEN_STO_TYPE_LIST2_ITERATOR;
06441
06445 typedef GWEN_STO_TYPE* (GWEN_STO_TYPE_LIST2_FOREACH)(GWEN_STO_TYPE *element,
06446 void *user_data);
06447
06451 GWEN_STO_TYPE_LIST2 *GWEN_StoType_List2_new();
06452
06456 void GWEN_StoType_List2_free(GWEN_STO_TYPE_LIST2 *l);
06457
06461 void GWEN_StoType_List2_Dump(GWEN_STO_TYPE_LIST2 *l, FILE *f, unsigned int indent);
06462
06466 void GWEN_StoType_List2_PushBack(GWEN_STO_TYPE_LIST2 *l, GWEN_STO_TYPE *p);
06467
06472 void GWEN_StoType_List2_PushFront(GWEN_STO_TYPE_LIST2 *l, GWEN_STO_TYPE *p);
06473
06478 GWEN_STO_TYPE *GWEN_StoType_List2_GetFront(GWEN_STO_TYPE_LIST2 *l);
06479
06484 GWEN_STO_TYPE *GWEN_StoType_List2_GetBack(GWEN_STO_TYPE_LIST2 *l);
06485
06490 void GWEN_StoType_List2_Erase(GWEN_STO_TYPE_LIST2 *l,
06491 GWEN_STO_TYPE_LIST2_ITERATOR *it);
06492
06498 unsigned int GWEN_StoType_List2_GetSize(GWEN_STO_TYPE_LIST2 *l);
06499
06504 void GWEN_StoType_List2_PopBack(GWEN_STO_TYPE_LIST2 *l);
06505
06510 void GWEN_StoType_List2_PopFront(GWEN_STO_TYPE_LIST2 *l);
06511
06515 void GWEN_StoType_List2_Clear(GWEN_STO_TYPE_LIST2 *l);
06516
06520 GWEN_STO_TYPE_LIST2_ITERATOR *GWEN_StoType_List2_First(GWEN_STO_TYPE_LIST2 *l);
06521
06525 GWEN_STO_TYPE_LIST2_ITERATOR *GWEN_StoType_List2_Last(GWEN_STO_TYPE_LIST2 *l);
06526
06530 GWEN_STO_TYPE_LIST2_ITERATOR *GWEN_StoType_List2Iterator_new(GWEN_STO_TYPE_LIST2 *l);
06531
06535 void GWEN_StoType_List2Iterator_free(GWEN_STO_TYPE_LIST2_ITERATOR *li);
06536
06541 GWEN_STO_TYPE *GWEN_StoType_List2Iterator_Previous(GWEN_STO_TYPE_LIST2_ITERATOR *li);
06542
06547 GWEN_STO_TYPE *GWEN_StoType_List2Iterator_Next(GWEN_STO_TYPE_LIST2_ITERATOR *li);
06548
06553 GWEN_STO_TYPE *GWEN_StoType_List2Iterator_Data(GWEN_STO_TYPE_LIST2_ITERATOR *li);
06554
06566 GWEN_STO_TYPE *GWEN_StoType_List2_ForEach(GWEN_STO_TYPE_LIST2 *list,
06567 GWEN_STO_TYPE_LIST2_FOREACH func,
06568 void *user_data);
06569
06570
06571 typedef struct GWEN_STO_TYPE_CONSTLIST2 GWEN_STO_TYPE_CONSTLIST2;
06572 typedef struct GWEN_STO_TYPE_CONSTLIST2_ITERATOR GWEN_STO_TYPE_CONSTLIST2_ITERATOR;
06573 typedef const GWEN_STO_TYPE*
06574 (GWEN_STO_TYPE_CONSTLIST2_FOREACH)(const GWEN_STO_TYPE *element,
06575 void *user_data);
06576
06577
06578 GWEN_STO_TYPE_CONSTLIST2 *GWEN_StoType_ConstList2_new();
06579
06580 void GWEN_StoType_ConstList2_free(GWEN_STO_TYPE_CONSTLIST2 *l);
06581
06582 void GWEN_StoType_ConstList2_PushBack(GWEN_STO_TYPE_CONSTLIST2 *l, const GWEN_STO_TYPE *p);
06583
06584 void GWEN_StoType_ConstList2_PushFront(GWEN_STO_TYPE_CONSTLIST2 *l, const GWEN_STO_TYPE *p);
06585
06586 const GWEN_STO_TYPE *GWEN_StoType_ConstList2_GetFront(GWEN_STO_TYPE_CONSTLIST2 *l);
06587
06588 const GWEN_STO_TYPE *GWEN_StoType_ConstList2_GetBack(GWEN_STO_TYPE_CONSTLIST2 *l);
06589
06590 unsigned int GWEN_StoType_ConstList2_GetSize(GWEN_STO_TYPE_CONSTLIST2 *l);
06591
06592 void GWEN_StoType_ConstList2_PopBack(GWEN_STO_TYPE_CONSTLIST2 *l);
06593
06594 void GWEN_StoType_ConstList2_PopFront(GWEN_STO_TYPE_CONSTLIST2 *l);
06595
06596 void GWEN_StoType_ConstList2_Clear(GWEN_STO_TYPE_CONSTLIST2 *l);
06597
06598 GWEN_STO_TYPE_CONSTLIST2_ITERATOR *GWEN_StoType_ConstList2_First(GWEN_STO_TYPE_CONSTLIST2 *l);
06599
06600 GWEN_STO_TYPE_CONSTLIST2_ITERATOR *GWEN_StoType_ConstList2_Last(GWEN_STO_TYPE_CONSTLIST2 *l);
06601
06602 GWEN_STO_TYPE_CONSTLIST2_ITERATOR *GWEN_StoType_ConstList2Iterator_new(GWEN_STO_TYPE_CONSTLIST2 *l);
06603
06604 void GWEN_StoType_ConstList2Iterator_free(GWEN_STO_TYPE_CONSTLIST2_ITERATOR *li);
06605
06606 const GWEN_STO_TYPE *GWEN_StoType_ConstList2Iterator_Previous(GWEN_STO_TYPE_CONSTLIST2_ITERATOR *li);
06607
06608 const GWEN_STO_TYPE *GWEN_StoType_ConstList2Iterator_Next(GWEN_STO_TYPE_CONSTLIST2_ITERATOR *li);
06609
06610 const GWEN_STO_TYPE *GWEN_StoType_ConstList2Iterator_Data(GWEN_STO_TYPE_CONSTLIST2_ITERATOR *li);
06611
06623 const GWEN_STO_TYPE *GWEN_StoType_ConstList2_ForEach(GWEN_STO_TYPE_CONSTLIST2 *list,
06624 GWEN_STO_TYPE_CONSTLIST2_FOREACH func, void *user_data);
06625
06626
06627 #ifdef __cplusplus
06628 }
06629 #endif
06630
06631
06632 #endif
06633
06634
06635
06636
06637
06638
06639
06640
06641
06642
06643
06644
06645
06646
06647
06648
06649
06650
06651
06652
06653
06654
06655
06656
06657
06658
06659
06660
06661
06662
06663
06664 #ifndef GWEN_STO_TYPE_LIST1_H
06665 #define GWEN_STO_TYPE_LIST1_H
06666
06667 #ifdef __cplusplus
06668 extern "C" {
06669 #endif
06670
06672 typedef struct GWEN_STO_TYPE_LIST_ELEMENT {
06673 GWEN_TYPE_UINT32 id;
06674 GWEN_STO_TYPE *nextObject;
06675 } GWEN_STO_TYPE_LIST__ELEMENT;
06676
06683 typedef struct GWEN_STO_TYPE_LIST GWEN_STO_TYPE_LIST;
06685 struct GWEN_STO_TYPE_LIST {
06686 GWEN_STO_TYPE *first;
06687 GWEN_TYPE_UINT32 count;
06688 GWEN_TYPE_UINT32 id;
06689 } GWEN_STO_TYPE_LIST;
06690
06695 void GWEN_StoType_List_AddList(GWEN_STO_TYPE_LIST *dst, GWEN_STO_TYPE_LIST *l);
06696
06700 void GWEN_StoType_List_Add(GWEN_STO_TYPE *element, GWEN_STO_TYPE_LIST *list);
06701
06706 void GWEN_StoType_List_Insert(GWEN_STO_TYPE *element, GWEN_STO_TYPE_LIST *list);
06707
06714 void GWEN_StoType_List_Del(GWEN_STO_TYPE *element);
06715
06719 GWEN_STO_TYPE* GWEN_StoType_List_First(const GWEN_STO_TYPE_LIST *l);
06720
06724 GWEN_STO_TYPE* GWEN_StoType_List_Last(const GWEN_STO_TYPE_LIST *l);
06725
06730 void GWEN_StoType_List_Clear(GWEN_STO_TYPE_LIST *l);
06731
06735 GWEN_STO_TYPE_LIST* GWEN_StoType_List_new();
06736
06740 void GWEN_StoType_List_free(GWEN_STO_TYPE_LIST *l);
06741
06745 GWEN_STO_TYPE* GWEN_StoType_List_Next(const GWEN_STO_TYPE *element);
06746
06750 GWEN_STO_TYPE* GWEN_StoType_List_Previous(const GWEN_STO_TYPE *element);
06751
06755 GWEN_TYPE_UINT32 GWEN_StoType_List_GetCount(const GWEN_STO_TYPE_LIST *l);
06756
06757 #ifdef __cplusplus
06758 }
06759 #endif
06760
06761
06762 #endif
06763
06764
06765
06766
06767
06768
06769
06770
06771
06772
06773
06774
06775
06776
06777
06778
06779
06780
06781
06782
06783
06784
06785
06786
06787
06788
06789
06790
06791
06792
06793
06794 #ifndef GWEN_STO_VARDEF_LIST1_H
06795 #define GWEN_STO_VARDEF_LIST1_H
06796
06797 #ifdef __cplusplus
06798 extern "C" {
06799 #endif
06800
06802 typedef struct GWEN_STO_VARDEF_LIST_ELEMENT {
06803 GWEN_TYPE_UINT32 id;
06804 GWEN_STO_VARDEF *nextObject;
06805 } GWEN_STO_VARDEF_LIST__ELEMENT;
06806
06813 typedef struct GWEN_STO_VARDEF_LIST GWEN_STO_VARDEF_LIST;
06815 struct GWEN_STO_VARDEF_LIST {
06816 GWEN_STO_VARDEF *first;
06817 GWEN_TYPE_UINT32 count;
06818 GWEN_TYPE_UINT32 id;
06819 } GWEN_STO_VARDEF_LIST;
06820
06825 void GWEN_StoVarDef_List_AddList(GWEN_STO_VARDEF_LIST *dst, GWEN_STO_VARDEF_LIST *l);
06826
06830 void GWEN_StoVarDef_List_Add(GWEN_STO_VARDEF *element, GWEN_STO_VARDEF_LIST *list);
06831
06836 void GWEN_StoVarDef_List_Insert(GWEN_STO_VARDEF *element, GWEN_STO_VARDEF_LIST *list);
06837
06844 void GWEN_StoVarDef_List_Del(GWEN_STO_VARDEF *element);
06845
06849 GWEN_STO_VARDEF* GWEN_StoVarDef_List_First(const GWEN_STO_VARDEF_LIST *l);
06850
06854 GWEN_STO_VARDEF* GWEN_StoVarDef_List_Last(const GWEN_STO_VARDEF_LIST *l);
06855
06860 void GWEN_StoVarDef_List_Clear(GWEN_STO_VARDEF_LIST *l);
06861
06865 GWEN_STO_VARDEF_LIST* GWEN_StoVarDef_List_new();
06866
06870 void GWEN_StoVarDef_List_free(GWEN_STO_VARDEF_LIST *l);
06871
06875 GWEN_STO_VARDEF* GWEN_StoVarDef_List_Next(const GWEN_STO_VARDEF *element);
06876
06880 GWEN_STO_VARDEF* GWEN_StoVarDef_List_Previous(const GWEN_STO_VARDEF *element);
06881
06885 GWEN_TYPE_UINT32 GWEN_StoVarDef_List_GetCount(const GWEN_STO_VARDEF_LIST *l);
06886
06887 #ifdef __cplusplus
06888 }
06889 #endif
06890
06891
06892 #endif
06893
06894
06895
06896
06897
06898
06899
06900
06901
06902
06903
06904
06905
06906
06907
06908
06909
06910
06911
06912
06913
06914
06915
06916
06917
06918
06919
06920
06921
06922
06923
06924 #ifndef GWEN_DBIO_LIST1_H
06925 #define GWEN_DBIO_LIST1_H
06926
06927 #ifdef __cplusplus
06928 extern "C" {
06929 #endif
06930
06932 typedef struct GWEN_DBIO_LIST_ELEMENT {
06933 GWEN_TYPE_UINT32 id;
06934 GWEN_DBIO *nextObject;
06935 } GWEN_DBIO_LIST__ELEMENT;
06936
06943 typedef struct GWEN_DBIO_LIST GWEN_DBIO_LIST;
06945 struct GWEN_DBIO_LIST {
06946 GWEN_DBIO *first;
06947 GWEN_TYPE_UINT32 count;
06948 GWEN_TYPE_UINT32 id;
06949 } GWEN_DBIO_LIST;
06950
06955 void GWEN_DBIO_List_AddList(GWEN_DBIO_LIST *dst, GWEN_DBIO_LIST *l);
06956
06960 void GWEN_DBIO_List_Add(GWEN_DBIO *element, GWEN_DBIO_LIST *list);
06961
06966 void GWEN_DBIO_List_Insert(GWEN_DBIO *element, GWEN_DBIO_LIST *list);
06967
06974 void GWEN_DBIO_List_Del(GWEN_DBIO *element);
06975
06979 GWEN_DBIO* GWEN_DBIO_List_First(const GWEN_DBIO_LIST *l);
06980
06984 GWEN_DBIO* GWEN_DBIO_List_Last(const GWEN_DBIO_LIST *l);
06985
06990 void GWEN_DBIO_List_Clear(GWEN_DBIO_LIST *l);
06991
06995 GWEN_DBIO_LIST* GWEN_DBIO_List_new();
06996
07000 void GWEN_DBIO_List_free(GWEN_DBIO_LIST *l);
07001
07005 GWEN_DBIO* GWEN_DBIO_List_Next(const GWEN_DBIO *element);
07006
07010 GWEN_DBIO* GWEN_DBIO_List_Previous(const GWEN_DBIO *element);
07011
07015 GWEN_TYPE_UINT32 GWEN_DBIO_List_GetCount(const GWEN_DBIO_LIST *l);
07016
07017 #ifdef __cplusplus
07018 }
07019 #endif
07020
07021
07022 #endif
07023
07024
07025
07026
07027
07028
07029
07030
07031
07032
07033
07034
07035
07036
07037
07038
07039
07040
07041
07042
07043
07044
07045
07046
07047
07048
07049
07050
07051
07052
07053
07054 #ifndef GWEN_TLV_LIST1_H
07055 #define GWEN_TLV_LIST1_H
07056
07057 #ifdef __cplusplus
07058 extern "C" {
07059 #endif
07060
07062 typedef struct GWEN_TLV_LIST_ELEMENT {
07063 GWEN_TYPE_UINT32 id;
07064 GWEN_TLV *nextObject;
07065 } GWEN_TLV_LIST__ELEMENT;
07066
07073 typedef struct GWEN_TLV_LIST GWEN_TLV_LIST;
07075 struct GWEN_TLV_LIST {
07076 GWEN_TLV *first;
07077 GWEN_TYPE_UINT32 count;
07078 GWEN_TYPE_UINT32 id;
07079 } GWEN_TLV_LIST;
07080
07085 void GWEN_TLV_List_AddList(GWEN_TLV_LIST *dst, GWEN_TLV_LIST *l);
07086
07090 void GWEN_TLV_List_Add(GWEN_TLV *element, GWEN_TLV_LIST *list);
07091
07096 void GWEN_TLV_List_Insert(GWEN_TLV *element, GWEN_TLV_LIST *list);
07097
07104 void GWEN_TLV_List_Del(GWEN_TLV *element);
07105
07109 GWEN_TLV* GWEN_TLV_List_First(const GWEN_TLV_LIST *l);
07110
07114 GWEN_TLV* GWEN_TLV_List_Last(const GWEN_TLV_LIST *l);
07115
07120 void GWEN_TLV_List_Clear(GWEN_TLV_LIST *l);
07121
07125 GWEN_TLV_LIST* GWEN_TLV_List_new();
07126
07130 void GWEN_TLV_List_free(GWEN_TLV_LIST *l);
07131
07135 GWEN_TLV* GWEN_TLV_List_Next(const GWEN_TLV *element);
07136
07140 GWEN_TLV* GWEN_TLV_List_Previous(const GWEN_TLV *element);
07141
07145 GWEN_TYPE_UINT32 GWEN_TLV_List_GetCount(const GWEN_TLV_LIST *l);
07146
07147 #ifdef __cplusplus
07148 }
07149 #endif
07150
07151
07152 #endif
07153
07154
07155
07156
07157
07158
07159
07160
07161
07162
07163
07164
07165
07166
07167
07168
07169
07170
07171
07172
07173
07174
07175
07176
07177
07178
07179
07180
07181
07182
07183
07184 #ifndef GWEN_XMLNODE_LIST2_H
07185 #define GWEN_XMLNODE_LIST2_H
07186
07187
07188 #ifdef __cplusplus
07189 extern "C" {
07190 #endif
07191
07198 typedef struct GWEN_XMLNODE_LIST2 GWEN_XMLNODE_LIST2;
07199
07203 typedef struct GWEN_XMLNODE_LIST2_ITERATOR GWEN_XMLNODE_LIST2_ITERATOR;
07204
07208 typedef GWEN_XMLNODE* (GWEN_XMLNODE_LIST2_FOREACH)(GWEN_XMLNODE *element,
07209 void *user_data);
07210
07214 GWEN_XMLNODE_LIST2 *GWEN_XMLNode_List2_new();
07215
07219 void GWEN_XMLNode_List2_free(GWEN_XMLNODE_LIST2 *l);
07220
07224 void GWEN_XMLNode_List2_Dump(GWEN_XMLNODE_LIST2 *l, FILE *f, unsigned int indent);
07225
07229 void GWEN_XMLNode_List2_PushBack(GWEN_XMLNODE_LIST2 *l, GWEN_XMLNODE *p);
07230
07235 void GWEN_XMLNode_List2_PushFront(GWEN_XMLNODE_LIST2 *l, GWEN_XMLNODE *p);
07236
07241 GWEN_XMLNODE *GWEN_XMLNode_List2_GetFront(GWEN_XMLNODE_LIST2 *l);
07242
07247 GWEN_XMLNODE *GWEN_XMLNode_List2_GetBack(GWEN_XMLNODE_LIST2 *l);
07248
07253 void GWEN_XMLNode_List2_Erase(GWEN_XMLNODE_LIST2 *l,
07254 GWEN_XMLNODE_LIST2_ITERATOR *it);
07255
07261 unsigned int GWEN_XMLNode_List2_GetSize(GWEN_XMLNODE_LIST2 *l);
07262
07267 void GWEN_XMLNode_List2_PopBack(GWEN_XMLNODE_LIST2 *l);
07268
07273 void GWEN_XMLNode_List2_PopFront(GWEN_XMLNODE_LIST2 *l);
07274
07278 void GWEN_XMLNode_List2_Clear(GWEN_XMLNODE_LIST2 *l);
07279
07283 GWEN_XMLNODE_LIST2_ITERATOR *GWEN_XMLNode_List2_First(GWEN_XMLNODE_LIST2 *l);
07284
07288 GWEN_XMLNODE_LIST2_ITERATOR *GWEN_XMLNode_List2_Last(GWEN_XMLNODE_LIST2 *l);
07289
07293 GWEN_XMLNODE_LIST2_ITERATOR *GWEN_XMLNode_List2Iterator_new(GWEN_XMLNODE_LIST2 *l);
07294
07298 void GWEN_XMLNode_List2Iterator_free(GWEN_XMLNODE_LIST2_ITERATOR *li);
07299
07304 GWEN_XMLNODE *GWEN_XMLNode_List2Iterator_Previous(GWEN_XMLNODE_LIST2_ITERATOR *li);
07305
07310 GWEN_XMLNODE *GWEN_XMLNode_List2Iterator_Next(GWEN_XMLNODE_LIST2_ITERATOR *li);
07311
07316 GWEN_XMLNODE *GWEN_XMLNode_List2Iterator_Data(GWEN_XMLNODE_LIST2_ITERATOR *li);
07317
07329 GWEN_XMLNODE *GWEN_XMLNode_List2_ForEach(GWEN_XMLNODE_LIST2 *list,
07330 GWEN_XMLNODE_LIST2_FOREACH func,
07331 void *user_data);
07332
07333
07334 typedef struct GWEN_XMLNODE_CONSTLIST2 GWEN_XMLNODE_CONSTLIST2;
07335 typedef struct GWEN_XMLNODE_CONSTLIST2_ITERATOR GWEN_XMLNODE_CONSTLIST2_ITERATOR;
07336 typedef const GWEN_XMLNODE*
07337 (GWEN_XMLNODE_CONSTLIST2_FOREACH)(const GWEN_XMLNODE *element,
07338 void *user_data);
07339
07340
07341 GWEN_XMLNODE_CONSTLIST2 *GWEN_XMLNode_ConstList2_new();
07342
07343 void GWEN_XMLNode_ConstList2_free(GWEN_XMLNODE_CONSTLIST2 *l);
07344
07345 void GWEN_XMLNode_ConstList2_PushBack(GWEN_XMLNODE_CONSTLIST2 *l, const GWEN_XMLNODE *p);
07346
07347 void GWEN_XMLNode_ConstList2_PushFront(GWEN_XMLNODE_CONSTLIST2 *l, const GWEN_XMLNODE *p);
07348
07349 const GWEN_XMLNODE *GWEN_XMLNode_ConstList2_GetFront(GWEN_XMLNODE_CONSTLIST2 *l);
07350
07351 const GWEN_XMLNODE *GWEN_XMLNode_ConstList2_GetBack(GWEN_XMLNODE_CONSTLIST2 *l);
07352
07353 unsigned int GWEN_XMLNode_ConstList2_GetSize(GWEN_XMLNODE_CONSTLIST2 *l);
07354
07355 void GWEN_XMLNode_ConstList2_PopBack(GWEN_XMLNODE_CONSTLIST2 *l);
07356
07357 void GWEN_XMLNode_ConstList2_PopFront(GWEN_XMLNODE_CONSTLIST2 *l);
07358
07359 void GWEN_XMLNode_ConstList2_Clear(GWEN_XMLNODE_CONSTLIST2 *l);
07360
07361 GWEN_XMLNODE_CONSTLIST2_ITERATOR *GWEN_XMLNode_ConstList2_First(GWEN_XMLNODE_CONSTLIST2 *l);
07362
07363 GWEN_XMLNODE_CONSTLIST2_ITERATOR *GWEN_XMLNode_ConstList2_Last(GWEN_XMLNODE_CONSTLIST2 *l);
07364
07365 GWEN_XMLNODE_CONSTLIST2_ITERATOR *GWEN_XMLNode_ConstList2Iterator_new(GWEN_XMLNODE_CONSTLIST2 *l);
07366
07367 void GWEN_XMLNode_ConstList2Iterator_free(GWEN_XMLNODE_CONSTLIST2_ITERATOR *li);
07368
07369 const GWEN_XMLNODE *GWEN_XMLNode_ConstList2Iterator_Previous(GWEN_XMLNODE_CONSTLIST2_ITERATOR *li);
07370
07371 const GWEN_XMLNODE *GWEN_XMLNode_ConstList2Iterator_Next(GWEN_XMLNODE_CONSTLIST2_ITERATOR *li);
07372
07373 const GWEN_XMLNODE *GWEN_XMLNode_ConstList2Iterator_Data(GWEN_XMLNODE_CONSTLIST2_ITERATOR *li);
07374
07386 const GWEN_XMLNODE *GWEN_XMLNode_ConstList2_ForEach(GWEN_XMLNODE_CONSTLIST2 *list,
07387 GWEN_XMLNODE_CONSTLIST2_FOREACH func, void *user_data);
07388
07389
07390 #ifdef __cplusplus
07391 }
07392 #endif
07393
07394
07395 #endif
07396
07397
07398
07399
07400
07401
07402
07403
07404
07405
07406
07407
07408
07409
07410
07411
07412
07413
07414
07415
07416
07417
07418
07419
07420
07421
07422
07423
07424
07425
07426
07427 #ifndef GWEN_XMLNODE_LIST1_H
07428 #define GWEN_XMLNODE_LIST1_H
07429
07430 #ifdef __cplusplus
07431 extern "C" {
07432 #endif
07433
07435 typedef struct GWEN_XMLNODE_LIST_ELEMENT {
07436 GWEN_TYPE_UINT32 id;
07437 GWEN_XMLNODE *nextObject;
07438 } GWEN_XMLNODE_LIST__ELEMENT;
07439
07446 typedef struct GWEN_XMLNODE_LIST GWEN_XMLNODE_LIST;
07448 struct GWEN_XMLNODE_LIST {
07449 GWEN_XMLNODE *first;
07450 GWEN_TYPE_UINT32 count;
07451 GWEN_TYPE_UINT32 id;
07452 } GWEN_XMLNODE_LIST;
07453
07458 void GWEN_XMLNode_List_AddList(GWEN_XMLNODE_LIST *dst, GWEN_XMLNODE_LIST *l);
07459
07463 void GWEN_XMLNode_List_Add(GWEN_XMLNODE *element, GWEN_XMLNODE_LIST *list);
07464
07469 void GWEN_XMLNode_List_Insert(GWEN_XMLNODE *element, GWEN_XMLNODE_LIST *list);
07470
07477 void GWEN_XMLNode_List_Del(GWEN_XMLNODE *element);
07478
07482 GWEN_XMLNODE* GWEN_XMLNode_List_First(const GWEN_XMLNODE_LIST *l);
07483
07487 GWEN_XMLNODE* GWEN_XMLNode_List_Last(const GWEN_XMLNODE_LIST *l);
07488
07493 void GWEN_XMLNode_List_Clear(GWEN_XMLNODE_LIST *l);
07494
07498 GWEN_XMLNODE_LIST* GWEN_XMLNode_List_new();
07499
07503 void GWEN_XMLNode_List_free(GWEN_XMLNODE_LIST *l);
07504
07508 GWEN_XMLNODE* GWEN_XMLNode_List_Next(const GWEN_XMLNODE *element);
07509
07513 GWEN_XMLNODE* GWEN_XMLNode_List_Previous(const GWEN_XMLNODE *element);
07514
07518 GWEN_TYPE_UINT32 GWEN_XMLNode_List_GetCount(const GWEN_XMLNODE_LIST *l);
07519
07520 #ifdef __cplusplus
07521 }
07522 #endif
07523
07524
07525 #endif
07526
07527
07528