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_LIST2_H
00160 #define t_LIST2_H
00161
00162
00163 #ifdef __cplusplus
00164 extern "C" {
00165 #endif
00166
00173 typedef struct t_LIST2 t_LIST2;
00174
00178 typedef struct t_LIST2_ITERATOR t_LIST2_ITERATOR;
00179
00183 typedef t* (t_LIST2_FOREACH)(t *element,
00184 void *user_data);
00185
00189 t_LIST2 *pr_List2_new();
00190
00194 void pr_List2_free(t_LIST2 *l);
00195
00199 void pr_List2_Dump(t_LIST2 *l, FILE *f, unsigned int indent);
00200
00204 void pr_List2_PushBack(t_LIST2 *l, t *p);
00205
00210 void pr_List2_PushFront(t_LIST2 *l, t *p);
00211
00216 t *pr_List2_GetFront(t_LIST2 *l);
00217
00222 t *pr_List2_GetBack(t_LIST2 *l);
00223
00228 void pr_List2_Erase(t_LIST2 *l,
00229 t_LIST2_ITERATOR *it);
00230
00236 unsigned int pr_List2_GetSize(t_LIST2 *l);
00237
00242 void pr_List2_PopBack(t_LIST2 *l);
00243
00248 void pr_List2_PopFront(t_LIST2 *l);
00249
00253 void pr_List2_Clear(t_LIST2 *l);
00254
00258 t_LIST2_ITERATOR *pr_List2_First(t_LIST2 *l);
00259
00263 t_LIST2_ITERATOR *pr_List2_Last(t_LIST2 *l);
00264
00268 t_LIST2_ITERATOR *pr_List2Iterator_new(t_LIST2 *l);
00269
00273 void pr_List2Iterator_free(t_LIST2_ITERATOR *li);
00274
00279 t *pr_List2Iterator_Previous(t_LIST2_ITERATOR *li);
00280
00285 t *pr_List2Iterator_Next(t_LIST2_ITERATOR *li);
00286
00291 t *pr_List2Iterator_Data(t_LIST2_ITERATOR *li);
00292
00304 t *pr_List2_ForEach(t_LIST2 *list,
00305 t_LIST2_FOREACH func,
00306 void *user_data);
00307
00308
00309 typedef struct t_CONSTLIST2 t_CONSTLIST2;
00310 typedef struct t_CONSTLIST2_ITERATOR t_CONSTLIST2_ITERATOR;
00311 typedef const t*
00312 (t_CONSTLIST2_FOREACH)(const t *element,
00313 void *user_data);
00314
00315
00316 t_CONSTLIST2 *pr_ConstList2_new();
00317
00318 void pr_ConstList2_free(t_CONSTLIST2 *l);
00319
00320 void pr_ConstList2_PushBack(t_CONSTLIST2 *l, const t *p);
00321
00322 void pr_ConstList2_PushFront(t_CONSTLIST2 *l, const t *p);
00323
00324 const t *pr_ConstList2_GetFront(t_CONSTLIST2 *l);
00325
00326 const t *pr_ConstList2_GetBack(t_CONSTLIST2 *l);
00327
00328 unsigned int pr_ConstList2_GetSize(t_CONSTLIST2 *l);
00329
00330 void pr_ConstList2_PopBack(t_CONSTLIST2 *l);
00331
00332 void pr_ConstList2_PopFront(t_CONSTLIST2 *l);
00333
00334 void pr_ConstList2_Clear(t_CONSTLIST2 *l);
00335
00336 t_CONSTLIST2_ITERATOR *pr_ConstList2_First(t_CONSTLIST2 *l);
00337
00338 t_CONSTLIST2_ITERATOR *pr_ConstList2_Last(t_CONSTLIST2 *l);
00339
00340 t_CONSTLIST2_ITERATOR *pr_ConstList2Iterator_new(t_CONSTLIST2 *l);
00341
00342 void pr_ConstList2Iterator_free(t_CONSTLIST2_ITERATOR *li);
00343
00344 const t *pr_ConstList2Iterator_Previous(t_CONSTLIST2_ITERATOR *li);
00345
00346 const t *pr_ConstList2Iterator_Next(t_CONSTLIST2_ITERATOR *li);
00347
00348 const t *pr_ConstList2Iterator_Data(t_CONSTLIST2_ITERATOR *li);
00349
00361 const t *pr_ConstList2_ForEach(t_CONSTLIST2 *list,
00362 t_CONSTLIST2_FOREACH func, void *user_data);
00363
00364
00365 #ifdef __cplusplus
00366 }
00367 #endif
00368
00369
00370 #endif
00371
00372
00373
00374
00375
00376
00377
00378
00379
00380
00381
00382
00383
00384
00385
00386
00387
00388
00389
00390
00391
00392
00393
00394
00395
00396
00397
00398
00399
00400
00401
00402 #ifndef t_LIST1_H
00403 #define t_LIST1_H
00404
00405 #ifdef __cplusplus
00406 extern "C" {
00407 #endif
00408
00410 typedef struct t_LIST_ELEMENT {
00411 GWEN_TYPE_UINT32 id;
00412 t *nextObject;
00413 } t_LIST__ELEMENT;
00414
00421 typedef struct t_LIST t_LIST;
00423 struct t_LIST {
00424 t *first;
00425 GWEN_TYPE_UINT32 count;
00426 GWEN_TYPE_UINT32 id;
00427 } t_LIST;
00428
00433 void pr_List_AddList(t_LIST *dst, t_LIST *l);
00434
00438 void pr_List_Add(t *element, t_LIST *list);
00439
00444 void pr_List_Insert(t *element, t_LIST *list);
00445
00452 void pr_List_Del(t *element);
00453
00457 t* pr_List_First(const t_LIST *l);
00458
00462 t* pr_List_Last(const t_LIST *l);
00463
00468 void pr_List_Clear(t_LIST *l);
00469
00473 t_LIST* pr_List_new();
00474
00478 void pr_List_free(t_LIST *l);
00479
00483 t* pr_List_Next(const t *element);
00484
00488 t* pr_List_Previous(const t *element);
00489
00493 GWEN_TYPE_UINT32 pr_List_GetCount(const t_LIST *l);
00494
00495 #ifdef __cplusplus
00496 }
00497 #endif
00498
00499
00500 #endif
00501
00502
00503
00504
00505
00506
00507
00508
00509
00510
00511
00512
00513
00514
00515
00516
00517
00518
00519
00520
00521
00522
00523
00524
00525
00526
00527
00528
00529
00530
00531
00532 #ifndef MYSTRUCT_LIST1_H
00533 #define MYSTRUCT_LIST1_H
00534
00535 #ifdef __cplusplus
00536 extern "C" {
00537 #endif
00538
00540 typedef struct MYSTRUCT_LIST_ELEMENT {
00541 GWEN_TYPE_UINT32 id;
00542 MYSTRUCT *nextObject;
00543 } MYSTRUCT_LIST__ELEMENT;
00544
00551 typedef struct MYSTRUCT_LIST MYSTRUCT_LIST;
00553 struct MYSTRUCT_LIST {
00554 MYSTRUCT *first;
00555 GWEN_TYPE_UINT32 count;
00556 GWEN_TYPE_UINT32 id;
00557 } MYSTRUCT_LIST;
00558
00563 void MyStruct_List_AddList(MYSTRUCT_LIST *dst, MYSTRUCT_LIST *l);
00564
00568 void MyStruct_List_Add(MYSTRUCT *element, MYSTRUCT_LIST *list);
00569
00574 void MyStruct_List_Insert(MYSTRUCT *element, MYSTRUCT_LIST *list);
00575
00582 void MyStruct_List_Del(MYSTRUCT *element);
00583
00587 MYSTRUCT* MyStruct_List_First(const MYSTRUCT_LIST *l);
00588
00592 MYSTRUCT* MyStruct_List_Last(const MYSTRUCT_LIST *l);
00593
00598 void MyStruct_List_Clear(MYSTRUCT_LIST *l);
00599
00603 MYSTRUCT_LIST* MyStruct_List_new();
00604
00608 void MyStruct_List_free(MYSTRUCT_LIST *l);
00609
00613 MYSTRUCT* MyStruct_List_Next(const MYSTRUCT *element);
00614
00618 MYSTRUCT* MyStruct_List_Previous(const MYSTRUCT *element);
00619
00623 GWEN_TYPE_UINT32 MyStruct_List_GetCount(const MYSTRUCT_LIST *l);
00624
00625 #ifdef __cplusplus
00626 }
00627 #endif
00628
00629
00630 #endif
00631
00632
00633
00634
00635
00636
00637
00638
00639
00640
00641
00642
00643
00644
00645
00646
00647
00648
00649
00650
00651
00652
00653
00654
00655
00656
00657
00658
00659
00660
00661
00662 #ifndef GWEN_PLUGIN_DESCRIPTION_LIST2_H
00663 #define GWEN_PLUGIN_DESCRIPTION_LIST2_H
00664
00665
00666 #ifdef __cplusplus
00667 extern "C" {
00668 #endif
00669
00676 typedef struct GWEN_PLUGIN_DESCRIPTION_LIST2 GWEN_PLUGIN_DESCRIPTION_LIST2;
00677
00681 typedef struct GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR;
00682
00686 typedef GWEN_PLUGIN_DESCRIPTION* (GWEN_PLUGIN_DESCRIPTION_LIST2_FOREACH)(GWEN_PLUGIN_DESCRIPTION *element,
00687 void *user_data);
00688
00692 GWEN_PLUGIN_DESCRIPTION_LIST2 *GWEN_PluginDescription_List2_new();
00693
00697 void GWEN_PluginDescription_List2_free(GWEN_PLUGIN_DESCRIPTION_LIST2 *l);
00698
00702 void GWEN_PluginDescription_List2_Dump(GWEN_PLUGIN_DESCRIPTION_LIST2 *l, FILE *f, unsigned int indent);
00703
00707 void GWEN_PluginDescription_List2_PushBack(GWEN_PLUGIN_DESCRIPTION_LIST2 *l, GWEN_PLUGIN_DESCRIPTION *p);
00708
00713 void GWEN_PluginDescription_List2_PushFront(GWEN_PLUGIN_DESCRIPTION_LIST2 *l, GWEN_PLUGIN_DESCRIPTION *p);
00714
00719 GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_List2_GetFront(GWEN_PLUGIN_DESCRIPTION_LIST2 *l);
00720
00725 GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_List2_GetBack(GWEN_PLUGIN_DESCRIPTION_LIST2 *l);
00726
00731 void GWEN_PluginDescription_List2_Erase(GWEN_PLUGIN_DESCRIPTION_LIST2 *l,
00732 GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *it);
00733
00739 unsigned int GWEN_PluginDescription_List2_GetSize(GWEN_PLUGIN_DESCRIPTION_LIST2 *l);
00740
00745 void GWEN_PluginDescription_List2_PopBack(GWEN_PLUGIN_DESCRIPTION_LIST2 *l);
00746
00751 void GWEN_PluginDescription_List2_PopFront(GWEN_PLUGIN_DESCRIPTION_LIST2 *l);
00752
00756 void GWEN_PluginDescription_List2_Clear(GWEN_PLUGIN_DESCRIPTION_LIST2 *l);
00757
00761 GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *GWEN_PluginDescription_List2_First(GWEN_PLUGIN_DESCRIPTION_LIST2 *l);
00762
00766 GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *GWEN_PluginDescription_List2_Last(GWEN_PLUGIN_DESCRIPTION_LIST2 *l);
00767
00771 GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *GWEN_PluginDescription_List2Iterator_new(GWEN_PLUGIN_DESCRIPTION_LIST2 *l);
00772
00776 void GWEN_PluginDescription_List2Iterator_free(GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *li);
00777
00782 GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_List2Iterator_Previous(GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *li);
00783
00788 GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_List2Iterator_Next(GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *li);
00789
00794 GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_List2Iterator_Data(GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *li);
00795
00807 GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_List2_ForEach(GWEN_PLUGIN_DESCRIPTION_LIST2 *list,
00808 GWEN_PLUGIN_DESCRIPTION_LIST2_FOREACH func,
00809 void *user_data);
00810
00811
00812 typedef struct GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 GWEN_PLUGIN_DESCRIPTION_CONSTLIST2;
00813 typedef struct GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR;
00814 typedef const GWEN_PLUGIN_DESCRIPTION*
00815 (GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_FOREACH)(const GWEN_PLUGIN_DESCRIPTION *element,
00816 void *user_data);
00817
00818
00819 GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *GWEN_PluginDescription_ConstList2_new();
00820
00821 void GWEN_PluginDescription_ConstList2_free(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l);
00822
00823 void GWEN_PluginDescription_ConstList2_PushBack(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l, const GWEN_PLUGIN_DESCRIPTION *p);
00824
00825 void GWEN_PluginDescription_ConstList2_PushFront(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l, const GWEN_PLUGIN_DESCRIPTION *p);
00826
00827 const GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_ConstList2_GetFront(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l);
00828
00829 const GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_ConstList2_GetBack(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l);
00830
00831 unsigned int GWEN_PluginDescription_ConstList2_GetSize(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l);
00832
00833 void GWEN_PluginDescription_ConstList2_PopBack(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l);
00834
00835 void GWEN_PluginDescription_ConstList2_PopFront(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l);
00836
00837 void GWEN_PluginDescription_ConstList2_Clear(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l);
00838
00839 GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *GWEN_PluginDescription_ConstList2_First(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l);
00840
00841 GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *GWEN_PluginDescription_ConstList2_Last(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l);
00842
00843 GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *GWEN_PluginDescription_ConstList2Iterator_new(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *l);
00844
00845 void GWEN_PluginDescription_ConstList2Iterator_free(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *li);
00846
00847 const GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_ConstList2Iterator_Previous(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *li);
00848
00849 const GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_ConstList2Iterator_Next(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *li);
00850
00851 const GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_ConstList2Iterator_Data(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2_ITERATOR *li);
00852
00864 const GWEN_PLUGIN_DESCRIPTION *GWEN_PluginDescription_ConstList2_ForEach(GWEN_PLUGIN_DESCRIPTION_CONSTLIST2 *list,
00865 GWEN_PLUGIN_DESCRIPTION_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_LIST1_H
00906 #define GWEN_PLUGIN_DESCRIPTION_LIST1_H
00907
00908 #ifdef __cplusplus
00909 extern "C" {
00910 #endif
00911
00913 typedef struct GWEN_PLUGIN_DESCRIPTION_LIST_ELEMENT {
00914 GWEN_TYPE_UINT32 id;
00915 GWEN_PLUGIN_DESCRIPTION *nextObject;
00916 } GWEN_PLUGIN_DESCRIPTION_LIST__ELEMENT;
00917
00924 typedef struct GWEN_PLUGIN_DESCRIPTION_LIST GWEN_PLUGIN_DESCRIPTION_LIST;
00926 struct GWEN_PLUGIN_DESCRIPTION_LIST {
00927 GWEN_PLUGIN_DESCRIPTION *first;
00928 GWEN_TYPE_UINT32 count;
00929 GWEN_TYPE_UINT32 id;
00930 } GWEN_PLUGIN_DESCRIPTION_LIST;
00931
00936 void GWEN_PluginDescription_List_AddList(GWEN_PLUGIN_DESCRIPTION_LIST *dst, GWEN_PLUGIN_DESCRIPTION_LIST *l);
00937
00941 void GWEN_PluginDescription_List_Add(GWEN_PLUGIN_DESCRIPTION *element, GWEN_PLUGIN_DESCRIPTION_LIST *list);
00942
00947 void GWEN_PluginDescription_List_Insert(GWEN_PLUGIN_DESCRIPTION *element, GWEN_PLUGIN_DESCRIPTION_LIST *list);
00948
00955 void GWEN_PluginDescription_List_Del(GWEN_PLUGIN_DESCRIPTION *element);
00956
00960 GWEN_PLUGIN_DESCRIPTION* GWEN_PluginDescription_List_First(const GWEN_PLUGIN_DESCRIPTION_LIST *l);
00961
00965 GWEN_PLUGIN_DESCRIPTION* GWEN_PluginDescription_List_Last(const GWEN_PLUGIN_DESCRIPTION_LIST *l);
00966
00971 void GWEN_PluginDescription_List_Clear(GWEN_PLUGIN_DESCRIPTION_LIST *l);
00972
00976 GWEN_PLUGIN_DESCRIPTION_LIST* GWEN_PluginDescription_List_new();
00977
00981 void GWEN_PluginDescription_List_free(GWEN_PLUGIN_DESCRIPTION_LIST *l);
00982
00986 GWEN_PLUGIN_DESCRIPTION* GWEN_PluginDescription_List_Next(const GWEN_PLUGIN_DESCRIPTION *element);
00987
00991 GWEN_PLUGIN_DESCRIPTION* GWEN_PluginDescription_List_Previous(const GWEN_PLUGIN_DESCRIPTION *element);
00992
00996 GWEN_TYPE_UINT32 GWEN_PluginDescription_List_GetCount(const GWEN_PLUGIN_DESCRIPTION_LIST *l);
00997
00998 #ifdef __cplusplus
00999 }
01000 #endif
01001
01002
01003 #endif
01004
01005
01006
01007
01008
01009
01010
01011
01012
01013
01014
01015
01016
01017
01018
01019
01020
01021
01022
01023
01024
01025
01026
01027
01028
01029
01030
01031
01032
01033
01034
01035 #ifndef GWEN_WAITCALLBACK_LIST1_H
01036 #define GWEN_WAITCALLBACK_LIST1_H
01037
01038 #ifdef __cplusplus
01039 extern "C" {
01040 #endif
01041
01043 typedef struct GWEN_WAITCALLBACK_LIST_ELEMENT {
01044 GWEN_TYPE_UINT32 id;
01045 GWEN_WAITCALLBACK *nextObject;
01046 } GWEN_WAITCALLBACK_LIST__ELEMENT;
01047
01054 typedef struct GWEN_WAITCALLBACK_LIST GWEN_WAITCALLBACK_LIST;
01056 struct GWEN_WAITCALLBACK_LIST {
01057 GWEN_WAITCALLBACK *first;
01058 GWEN_TYPE_UINT32 count;
01059 GWEN_TYPE_UINT32 id;
01060 } GWEN_WAITCALLBACK_LIST;
01061
01066 void GWEN_WaitCallback_List_AddList(GWEN_WAITCALLBACK_LIST *dst, GWEN_WAITCALLBACK_LIST *l);
01067
01071 void GWEN_WaitCallback_List_Add(GWEN_WAITCALLBACK *element, GWEN_WAITCALLBACK_LIST *list);
01072
01077 void GWEN_WaitCallback_List_Insert(GWEN_WAITCALLBACK *element, GWEN_WAITCALLBACK_LIST *list);
01078
01085 void GWEN_WaitCallback_List_Del(GWEN_WAITCALLBACK *element);
01086
01090 GWEN_WAITCALLBACK* GWEN_WaitCallback_List_First(const GWEN_WAITCALLBACK_LIST *l);
01091
01095 GWEN_WAITCALLBACK* GWEN_WaitCallback_List_Last(const GWEN_WAITCALLBACK_LIST *l);
01096
01101 void GWEN_WaitCallback_List_Clear(GWEN_WAITCALLBACK_LIST *l);
01102
01106 GWEN_WAITCALLBACK_LIST* GWEN_WaitCallback_List_new();
01107
01111 void GWEN_WaitCallback_List_free(GWEN_WAITCALLBACK_LIST *l);
01112
01116 GWEN_WAITCALLBACK* GWEN_WaitCallback_List_Next(const GWEN_WAITCALLBACK *element);
01117
01121 GWEN_WAITCALLBACK* GWEN_WaitCallback_List_Previous(const GWEN_WAITCALLBACK *element);
01122
01126 GWEN_TYPE_UINT32 GWEN_WaitCallback_List_GetCount(const GWEN_WAITCALLBACK_LIST *l);
01127
01128 #ifdef __cplusplus
01129 }
01130 #endif
01131
01132
01133 #endif
01134
01135
01136
01137
01138
01139
01140
01141
01142
01143
01144
01145
01146
01147
01148
01149
01150
01151
01152
01153
01154
01155
01156
01157
01158
01159
01160
01161
01162
01163
01164
01165 #ifndef GWEN_NETCONNECTION_LIST2_H
01166 #define GWEN_NETCONNECTION_LIST2_H
01167
01168
01169 #ifdef __cplusplus
01170 extern "C" {
01171 #endif
01172
01179 typedef struct GWEN_NETCONNECTION_LIST2 GWEN_NETCONNECTION_LIST2;
01180
01184 typedef struct GWEN_NETCONNECTION_LIST2_ITERATOR GWEN_NETCONNECTION_LIST2_ITERATOR;
01185
01189 typedef GWEN_NETCONNECTION* (GWEN_NETCONNECTION_LIST2_FOREACH)(GWEN_NETCONNECTION *element,
01190 void *user_data);
01191
01195 GWEN_NETCONNECTION_LIST2 *GWEN_NetConnection_List2_new();
01196
01200 void GWEN_NetConnection_List2_free(GWEN_NETCONNECTION_LIST2 *l);
01201
01205 void GWEN_NetConnection_List2_Dump(GWEN_NETCONNECTION_LIST2 *l, FILE *f, unsigned int indent);
01206
01210 void GWEN_NetConnection_List2_PushBack(GWEN_NETCONNECTION_LIST2 *l, GWEN_NETCONNECTION *p);
01211
01216 void GWEN_NetConnection_List2_PushFront(GWEN_NETCONNECTION_LIST2 *l, GWEN_NETCONNECTION *p);
01217
01222 GWEN_NETCONNECTION *GWEN_NetConnection_List2_GetFront(GWEN_NETCONNECTION_LIST2 *l);
01223
01228 GWEN_NETCONNECTION *GWEN_NetConnection_List2_GetBack(GWEN_NETCONNECTION_LIST2 *l);
01229
01234 void GWEN_NetConnection_List2_Erase(GWEN_NETCONNECTION_LIST2 *l,
01235 GWEN_NETCONNECTION_LIST2_ITERATOR *it);
01236
01242 unsigned int GWEN_NetConnection_List2_GetSize(GWEN_NETCONNECTION_LIST2 *l);
01243
01248 void GWEN_NetConnection_List2_PopBack(GWEN_NETCONNECTION_LIST2 *l);
01249
01254 void GWEN_NetConnection_List2_PopFront(GWEN_NETCONNECTION_LIST2 *l);
01255
01259 void GWEN_NetConnection_List2_Clear(GWEN_NETCONNECTION_LIST2 *l);
01260
01264 GWEN_NETCONNECTION_LIST2_ITERATOR *GWEN_NetConnection_List2_First(GWEN_NETCONNECTION_LIST2 *l);
01265
01269 GWEN_NETCONNECTION_LIST2_ITERATOR *GWEN_NetConnection_List2_Last(GWEN_NETCONNECTION_LIST2 *l);
01270
01274 GWEN_NETCONNECTION_LIST2_ITERATOR *GWEN_NetConnection_List2Iterator_new(GWEN_NETCONNECTION_LIST2 *l);
01275
01279 void GWEN_NetConnection_List2Iterator_free(GWEN_NETCONNECTION_LIST2_ITERATOR *li);
01280
01285 GWEN_NETCONNECTION *GWEN_NetConnection_List2Iterator_Previous(GWEN_NETCONNECTION_LIST2_ITERATOR *li);
01286
01291 GWEN_NETCONNECTION *GWEN_NetConnection_List2Iterator_Next(GWEN_NETCONNECTION_LIST2_ITERATOR *li);
01292
01297 GWEN_NETCONNECTION *GWEN_NetConnection_List2Iterator_Data(GWEN_NETCONNECTION_LIST2_ITERATOR *li);
01298
01310 GWEN_NETCONNECTION *GWEN_NetConnection_List2_ForEach(GWEN_NETCONNECTION_LIST2 *list,
01311 GWEN_NETCONNECTION_LIST2_FOREACH func,
01312 void *user_data);
01313
01314
01315 typedef struct GWEN_NETCONNECTION_CONSTLIST2 GWEN_NETCONNECTION_CONSTLIST2;
01316 typedef struct GWEN_NETCONNECTION_CONSTLIST2_ITERATOR GWEN_NETCONNECTION_CONSTLIST2_ITERATOR;
01317 typedef const GWEN_NETCONNECTION*
01318 (GWEN_NETCONNECTION_CONSTLIST2_FOREACH)(const GWEN_NETCONNECTION *element,
01319 void *user_data);
01320
01321
01322 GWEN_NETCONNECTION_CONSTLIST2 *GWEN_NetConnection_ConstList2_new();
01323
01324 void GWEN_NetConnection_ConstList2_free(GWEN_NETCONNECTION_CONSTLIST2 *l);
01325
01326 void GWEN_NetConnection_ConstList2_PushBack(GWEN_NETCONNECTION_CONSTLIST2 *l, const GWEN_NETCONNECTION *p);
01327
01328 void GWEN_NetConnection_ConstList2_PushFront(GWEN_NETCONNECTION_CONSTLIST2 *l, const GWEN_NETCONNECTION *p);
01329
01330 const GWEN_NETCONNECTION *GWEN_NetConnection_ConstList2_GetFront(GWEN_NETCONNECTION_CONSTLIST2 *l);
01331
01332 const GWEN_NETCONNECTION *GWEN_NetConnection_ConstList2_GetBack(GWEN_NETCONNECTION_CONSTLIST2 *l);
01333
01334 unsigned int GWEN_NetConnection_ConstList2_GetSize(GWEN_NETCONNECTION_CONSTLIST2 *l);
01335
01336 void GWEN_NetConnection_ConstList2_PopBack(GWEN_NETCONNECTION_CONSTLIST2 *l);
01337
01338 void GWEN_NetConnection_ConstList2_PopFront(GWEN_NETCONNECTION_CONSTLIST2 *l);
01339
01340 void GWEN_NetConnection_ConstList2_Clear(GWEN_NETCONNECTION_CONSTLIST2 *l);
01341
01342 GWEN_NETCONNECTION_CONSTLIST2_ITERATOR *GWEN_NetConnection_ConstList2_First(GWEN_NETCONNECTION_CONSTLIST2 *l);
01343
01344 GWEN_NETCONNECTION_CONSTLIST2_ITERATOR *GWEN_NetConnection_ConstList2_Last(GWEN_NETCONNECTION_CONSTLIST2 *l);
01345
01346 GWEN_NETCONNECTION_CONSTLIST2_ITERATOR *GWEN_NetConnection_ConstList2Iterator_new(GWEN_NETCONNECTION_CONSTLIST2 *l);
01347
01348 void GWEN_NetConnection_ConstList2Iterator_free(GWEN_NETCONNECTION_CONSTLIST2_ITERATOR *li);
01349
01350 const GWEN_NETCONNECTION *GWEN_NetConnection_ConstList2Iterator_Previous(GWEN_NETCONNECTION_CONSTLIST2_ITERATOR *li);
01351
01352 const GWEN_NETCONNECTION *GWEN_NetConnection_ConstList2Iterator_Next(GWEN_NETCONNECTION_CONSTLIST2_ITERATOR *li);
01353
01354 const GWEN_NETCONNECTION *GWEN_NetConnection_ConstList2Iterator_Data(GWEN_NETCONNECTION_CONSTLIST2_ITERATOR *li);
01355
01367 const GWEN_NETCONNECTION *GWEN_NetConnection_ConstList2_ForEach(GWEN_NETCONNECTION_CONSTLIST2 *list,
01368 GWEN_NETCONNECTION_CONSTLIST2_FOREACH func, void *user_data);
01369
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_NETCONNECTION_LIST1_H
01409 #define GWEN_NETCONNECTION_LIST1_H
01410
01411 #ifdef __cplusplus
01412 extern "C" {
01413 #endif
01414
01416 typedef struct GWEN_NETCONNECTION_LIST_ELEMENT {
01417 GWEN_TYPE_UINT32 id;
01418 GWEN_NETCONNECTION *nextObject;
01419 } GWEN_NETCONNECTION_LIST__ELEMENT;
01420
01427 typedef struct GWEN_NETCONNECTION_LIST GWEN_NETCONNECTION_LIST;
01429 struct GWEN_NETCONNECTION_LIST {
01430 GWEN_NETCONNECTION *first;
01431 GWEN_TYPE_UINT32 count;
01432 GWEN_TYPE_UINT32 id;
01433 } GWEN_NETCONNECTION_LIST;
01434
01439 void GWEN_NetConnection_List_AddList(GWEN_NETCONNECTION_LIST *dst, GWEN_NETCONNECTION_LIST *l);
01440
01444 void GWEN_NetConnection_List_Add(GWEN_NETCONNECTION *element, GWEN_NETCONNECTION_LIST *list);
01445
01450 void GWEN_NetConnection_List_Insert(GWEN_NETCONNECTION *element, GWEN_NETCONNECTION_LIST *list);
01451
01458 void GWEN_NetConnection_List_Del(GWEN_NETCONNECTION *element);
01459
01463 GWEN_NETCONNECTION* GWEN_NetConnection_List_First(const GWEN_NETCONNECTION_LIST *l);
01464
01468 GWEN_NETCONNECTION* GWEN_NetConnection_List_Last(const GWEN_NETCONNECTION_LIST *l);
01469
01474 void GWEN_NetConnection_List_Clear(GWEN_NETCONNECTION_LIST *l);
01475
01479 GWEN_NETCONNECTION_LIST* GWEN_NetConnection_List_new();
01480
01484 void GWEN_NetConnection_List_free(GWEN_NETCONNECTION_LIST *l);
01485
01489 GWEN_NETCONNECTION* GWEN_NetConnection_List_Next(const GWEN_NETCONNECTION *element);
01490
01494 GWEN_NETCONNECTION* GWEN_NetConnection_List_Previous(const GWEN_NETCONNECTION *element);
01495
01499 GWEN_TYPE_UINT32 GWEN_NetConnection_List_GetCount(const GWEN_NETCONNECTION_LIST *l);
01500
01501 #ifdef __cplusplus
01502 }
01503 #endif
01504
01505
01506 #endif
01507
01508
01509
01510
01511
01512
01513
01514
01515
01516
01517
01518
01519
01520
01521
01522
01523
01524
01525
01526
01527
01528
01529
01530
01531
01532
01533
01534
01535
01536
01537
01538 #ifndef GWEN_NETMSG_LIST1_H
01539 #define GWEN_NETMSG_LIST1_H
01540
01541 #ifdef __cplusplus
01542 extern "C" {
01543 #endif
01544
01546 typedef struct GWEN_NETMSG_LIST_ELEMENT {
01547 GWEN_TYPE_UINT32 id;
01548 GWEN_NETMSG *nextObject;
01549 } GWEN_NETMSG_LIST__ELEMENT;
01550
01557 typedef struct GWEN_NETMSG_LIST GWEN_NETMSG_LIST;
01559 struct GWEN_NETMSG_LIST {
01560 GWEN_NETMSG *first;
01561 GWEN_TYPE_UINT32 count;
01562 GWEN_TYPE_UINT32 id;
01563 } GWEN_NETMSG_LIST;
01564
01569 void GWEN_NetMsg_List_AddList(GWEN_NETMSG_LIST *dst, GWEN_NETMSG_LIST *l);
01570
01574 void GWEN_NetMsg_List_Add(GWEN_NETMSG *element, GWEN_NETMSG_LIST *list);
01575
01580 void GWEN_NetMsg_List_Insert(GWEN_NETMSG *element, GWEN_NETMSG_LIST *list);
01581
01588 void GWEN_NetMsg_List_Del(GWEN_NETMSG *element);
01589
01593 GWEN_NETMSG* GWEN_NetMsg_List_First(const GWEN_NETMSG_LIST *l);
01594
01598 GWEN_NETMSG* GWEN_NetMsg_List_Last(const GWEN_NETMSG_LIST *l);
01599
01604 void GWEN_NetMsg_List_Clear(GWEN_NETMSG_LIST *l);
01605
01609 GWEN_NETMSG_LIST* GWEN_NetMsg_List_new();
01610
01614 void GWEN_NetMsg_List_free(GWEN_NETMSG_LIST *l);
01615
01619 GWEN_NETMSG* GWEN_NetMsg_List_Next(const GWEN_NETMSG *element);
01620
01624 GWEN_NETMSG* GWEN_NetMsg_List_Previous(const GWEN_NETMSG *element);
01625
01629 GWEN_TYPE_UINT32 GWEN_NetMsg_List_GetCount(const GWEN_NETMSG_LIST *l);
01630
01631 #ifdef __cplusplus
01632 }
01633 #endif
01634
01635
01636 #endif
01637
01638
01639
01640
01641
01642
01643
01644
01645
01646
01647
01648
01649
01650
01651
01652
01653
01654
01655
01656
01657
01658
01659
01660
01661
01662
01663
01664
01665
01666
01667
01668 #ifndef GWEN_NETTRANSPORT_LIST1_H
01669 #define GWEN_NETTRANSPORT_LIST1_H
01670
01671 #ifdef __cplusplus
01672 extern "C" {
01673 #endif
01674
01676 typedef struct GWEN_NETTRANSPORT_LIST_ELEMENT {
01677 GWEN_TYPE_UINT32 id;
01678 GWEN_NETTRANSPORT *nextObject;
01679 } GWEN_NETTRANSPORT_LIST__ELEMENT;
01680
01687 typedef struct GWEN_NETTRANSPORT_LIST GWEN_NETTRANSPORT_LIST;
01689 struct GWEN_NETTRANSPORT_LIST {
01690 GWEN_NETTRANSPORT *first;
01691 GWEN_TYPE_UINT32 count;
01692 GWEN_TYPE_UINT32 id;
01693 } GWEN_NETTRANSPORT_LIST;
01694
01699 void GWEN_NetTransport_List_AddList(GWEN_NETTRANSPORT_LIST *dst, GWEN_NETTRANSPORT_LIST *l);
01700
01704 void GWEN_NetTransport_List_Add(GWEN_NETTRANSPORT *element, GWEN_NETTRANSPORT_LIST *list);
01705
01710 void GWEN_NetTransport_List_Insert(GWEN_NETTRANSPORT *element, GWEN_NETTRANSPORT_LIST *list);
01711
01718 void GWEN_NetTransport_List_Del(GWEN_NETTRANSPORT *element);
01719
01723 GWEN_NETTRANSPORT* GWEN_NetTransport_List_First(const GWEN_NETTRANSPORT_LIST *l);
01724
01728 GWEN_NETTRANSPORT* GWEN_NetTransport_List_Last(const GWEN_NETTRANSPORT_LIST *l);
01729
01734 void GWEN_NetTransport_List_Clear(GWEN_NETTRANSPORT_LIST *l);
01735
01739 GWEN_NETTRANSPORT_LIST* GWEN_NetTransport_List_new();
01740
01744 void GWEN_NetTransport_List_free(GWEN_NETTRANSPORT_LIST *l);
01745
01749 GWEN_NETTRANSPORT* GWEN_NetTransport_List_Next(const GWEN_NETTRANSPORT *element);
01750
01754 GWEN_NETTRANSPORT* GWEN_NetTransport_List_Previous(const GWEN_NETTRANSPORT *element);
01755
01759 GWEN_TYPE_UINT32 GWEN_NetTransport_List_GetCount(const GWEN_NETTRANSPORT_LIST *l);
01760
01761 #ifdef __cplusplus
01762 }
01763 #endif
01764
01765
01766 #endif
01767
01768
01769
01770
01771
01772
01773
01774
01775
01776
01777
01778
01779
01780
01781
01782
01783
01784
01785
01786
01787
01788
01789
01790
01791
01792
01793
01794
01795
01796
01797
01798 #ifndef GWEN_CRYPTKEY_LIST2_H
01799 #define GWEN_CRYPTKEY_LIST2_H
01800
01801
01802 #ifdef __cplusplus
01803 extern "C" {
01804 #endif
01805
01812 typedef struct GWEN_CRYPTKEY_LIST2 GWEN_CRYPTKEY_LIST2;
01813
01817 typedef struct GWEN_CRYPTKEY_LIST2_ITERATOR GWEN_CRYPTKEY_LIST2_ITERATOR;
01818
01822 typedef GWEN_CRYPTKEY* (GWEN_CRYPTKEY_LIST2_FOREACH)(GWEN_CRYPTKEY *element,
01823 void *user_data);
01824
01828 GWEN_CRYPTKEY_LIST2 *GWEN_CryptKey_List2_new();
01829
01833 void GWEN_CryptKey_List2_free(GWEN_CRYPTKEY_LIST2 *l);
01834
01838 void GWEN_CryptKey_List2_Dump(GWEN_CRYPTKEY_LIST2 *l, FILE *f, unsigned int indent);
01839
01843 void GWEN_CryptKey_List2_PushBack(GWEN_CRYPTKEY_LIST2 *l, GWEN_CRYPTKEY *p);
01844
01849 void GWEN_CryptKey_List2_PushFront(GWEN_CRYPTKEY_LIST2 *l, GWEN_CRYPTKEY *p);
01850
01855 GWEN_CRYPTKEY *GWEN_CryptKey_List2_GetFront(GWEN_CRYPTKEY_LIST2 *l);
01856
01861 GWEN_CRYPTKEY *GWEN_CryptKey_List2_GetBack(GWEN_CRYPTKEY_LIST2 *l);
01862
01867 void GWEN_CryptKey_List2_Erase(GWEN_CRYPTKEY_LIST2 *l,
01868 GWEN_CRYPTKEY_LIST2_ITERATOR *it);
01869
01875 unsigned int GWEN_CryptKey_List2_GetSize(GWEN_CRYPTKEY_LIST2 *l);
01876
01881 void GWEN_CryptKey_List2_PopBack(GWEN_CRYPTKEY_LIST2 *l);
01882
01887 void GWEN_CryptKey_List2_PopFront(GWEN_CRYPTKEY_LIST2 *l);
01888
01892 void GWEN_CryptKey_List2_Clear(GWEN_CRYPTKEY_LIST2 *l);
01893
01897 GWEN_CRYPTKEY_LIST2_ITERATOR *GWEN_CryptKey_List2_First(GWEN_CRYPTKEY_LIST2 *l);
01898
01902 GWEN_CRYPTKEY_LIST2_ITERATOR *GWEN_CryptKey_List2_Last(GWEN_CRYPTKEY_LIST2 *l);
01903
01907 GWEN_CRYPTKEY_LIST2_ITERATOR *GWEN_CryptKey_List2Iterator_new(GWEN_CRYPTKEY_LIST2 *l);
01908
01912 void GWEN_CryptKey_List2Iterator_free(GWEN_CRYPTKEY_LIST2_ITERATOR *li);
01913
01918 GWEN_CRYPTKEY *GWEN_CryptKey_List2Iterator_Previous(GWEN_CRYPTKEY_LIST2_ITERATOR *li);
01919
01924 GWEN_CRYPTKEY *GWEN_CryptKey_List2Iterator_Next(GWEN_CRYPTKEY_LIST2_ITERATOR *li);
01925
01930 GWEN_CRYPTKEY *GWEN_CryptKey_List2Iterator_Data(GWEN_CRYPTKEY_LIST2_ITERATOR *li);
01931
01943 GWEN_CRYPTKEY *GWEN_CryptKey_List2_ForEach(GWEN_CRYPTKEY_LIST2 *list,
01944 GWEN_CRYPTKEY_LIST2_FOREACH func,
01945 void *user_data);
01946
01947
01948 typedef struct GWEN_CRYPTKEY_CONSTLIST2 GWEN_CRYPTKEY_CONSTLIST2;
01949 typedef struct GWEN_CRYPTKEY_CONSTLIST2_ITERATOR GWEN_CRYPTKEY_CONSTLIST2_ITERATOR;
01950 typedef const GWEN_CRYPTKEY*
01951 (GWEN_CRYPTKEY_CONSTLIST2_FOREACH)(const GWEN_CRYPTKEY *element,
01952 void *user_data);
01953
01954
01955 GWEN_CRYPTKEY_CONSTLIST2 *GWEN_CryptKey_ConstList2_new();
01956
01957 void GWEN_CryptKey_ConstList2_free(GWEN_CRYPTKEY_CONSTLIST2 *l);
01958
01959 void GWEN_CryptKey_ConstList2_PushBack(GWEN_CRYPTKEY_CONSTLIST2 *l, const GWEN_CRYPTKEY *p);
01960
01961 void GWEN_CryptKey_ConstList2_PushFront(GWEN_CRYPTKEY_CONSTLIST2 *l, const GWEN_CRYPTKEY *p);
01962
01963 const GWEN_CRYPTKEY *GWEN_CryptKey_ConstList2_GetFront(GWEN_CRYPTKEY_CONSTLIST2 *l);
01964
01965 const GWEN_CRYPTKEY *GWEN_CryptKey_ConstList2_GetBack(GWEN_CRYPTKEY_CONSTLIST2 *l);
01966
01967 unsigned int GWEN_CryptKey_ConstList2_GetSize(GWEN_CRYPTKEY_CONSTLIST2 *l);
01968
01969 void GWEN_CryptKey_ConstList2_PopBack(GWEN_CRYPTKEY_CONSTLIST2 *l);
01970
01971 void GWEN_CryptKey_ConstList2_PopFront(GWEN_CRYPTKEY_CONSTLIST2 *l);
01972
01973 void GWEN_CryptKey_ConstList2_Clear(GWEN_CRYPTKEY_CONSTLIST2 *l);
01974
01975 GWEN_CRYPTKEY_CONSTLIST2_ITERATOR *GWEN_CryptKey_ConstList2_First(GWEN_CRYPTKEY_CONSTLIST2 *l);
01976
01977 GWEN_CRYPTKEY_CONSTLIST2_ITERATOR *GWEN_CryptKey_ConstList2_Last(GWEN_CRYPTKEY_CONSTLIST2 *l);
01978
01979 GWEN_CRYPTKEY_CONSTLIST2_ITERATOR *GWEN_CryptKey_ConstList2Iterator_new(GWEN_CRYPTKEY_CONSTLIST2 *l);
01980
01981 void GWEN_CryptKey_ConstList2Iterator_free(GWEN_CRYPTKEY_CONSTLIST2_ITERATOR *li);
01982
01983 const GWEN_CRYPTKEY *GWEN_CryptKey_ConstList2Iterator_Previous(GWEN_CRYPTKEY_CONSTLIST2_ITERATOR *li);
01984
01985 const GWEN_CRYPTKEY *GWEN_CryptKey_ConstList2Iterator_Next(GWEN_CRYPTKEY_CONSTLIST2_ITERATOR *li);
01986
01987 const GWEN_CRYPTKEY *GWEN_CryptKey_ConstList2Iterator_Data(GWEN_CRYPTKEY_CONSTLIST2_ITERATOR *li);
01988
02000 const GWEN_CRYPTKEY *GWEN_CryptKey_ConstList2_ForEach(GWEN_CRYPTKEY_CONSTLIST2 *list,
02001 GWEN_CRYPTKEY_CONSTLIST2_FOREACH func, void *user_data);
02002
02003
02004 #ifdef __cplusplus
02005 }
02006 #endif
02007
02008
02009 #endif
02010
02011
02012
02013
02014
02015
02016
02017
02018
02019
02020
02021
02022
02023
02024
02025
02026
02027
02028
02029
02030
02031
02032
02033
02034
02035
02036
02037
02038
02039
02040
02041 #ifndef GWEN_CRYPTKEY_LIST1_H
02042 #define GWEN_CRYPTKEY_LIST1_H
02043
02044 #ifdef __cplusplus
02045 extern "C" {
02046 #endif
02047
02049 typedef struct GWEN_CRYPTKEY_LIST_ELEMENT {
02050 GWEN_TYPE_UINT32 id;
02051 GWEN_CRYPTKEY *nextObject;
02052 } GWEN_CRYPTKEY_LIST__ELEMENT;
02053
02060 typedef struct GWEN_CRYPTKEY_LIST GWEN_CRYPTKEY_LIST;
02062 struct GWEN_CRYPTKEY_LIST {
02063 GWEN_CRYPTKEY *first;
02064 GWEN_TYPE_UINT32 count;
02065 GWEN_TYPE_UINT32 id;
02066 } GWEN_CRYPTKEY_LIST;
02067
02072 void GWEN_CryptKey_List_AddList(GWEN_CRYPTKEY_LIST *dst, GWEN_CRYPTKEY_LIST *l);
02073
02077 void GWEN_CryptKey_List_Add(GWEN_CRYPTKEY *element, GWEN_CRYPTKEY_LIST *list);
02078
02083 void GWEN_CryptKey_List_Insert(GWEN_CRYPTKEY *element, GWEN_CRYPTKEY_LIST *list);
02084
02091 void GWEN_CryptKey_List_Del(GWEN_CRYPTKEY *element);
02092
02096 GWEN_CRYPTKEY* GWEN_CryptKey_List_First(const GWEN_CRYPTKEY_LIST *l);
02097
02101 GWEN_CRYPTKEY* GWEN_CryptKey_List_Last(const GWEN_CRYPTKEY_LIST *l);
02102
02107 void GWEN_CryptKey_List_Clear(GWEN_CRYPTKEY_LIST *l);
02108
02112 GWEN_CRYPTKEY_LIST* GWEN_CryptKey_List_new();
02113
02117 void GWEN_CryptKey_List_free(GWEN_CRYPTKEY_LIST *l);
02118
02122 GWEN_CRYPTKEY* GWEN_CryptKey_List_Next(const GWEN_CRYPTKEY *element);
02123
02127 GWEN_CRYPTKEY* GWEN_CryptKey_List_Previous(const GWEN_CRYPTKEY *element);
02128
02132 GWEN_TYPE_UINT32 GWEN_CryptKey_List_GetCount(const GWEN_CRYPTKEY_LIST *l);
02133
02134 #ifdef __cplusplus
02135 }
02136 #endif
02137
02138
02139 #endif
02140
02141
02142
02143
02144
02145
02146
02147
02148
02149
02150
02151
02152
02153
02154
02155
02156
02157
02158
02159
02160
02161
02162
02163
02164
02165
02166
02167
02168
02169
02170
02171 #ifndef GWEN_KEYSPEC_LIST2_H
02172 #define GWEN_KEYSPEC_LIST2_H
02173
02174
02175 #ifdef __cplusplus
02176 extern "C" {
02177 #endif
02178
02185 typedef struct GWEN_KEYSPEC_LIST2 GWEN_KEYSPEC_LIST2;
02186
02190 typedef struct GWEN_KEYSPEC_LIST2_ITERATOR GWEN_KEYSPEC_LIST2_ITERATOR;
02191
02195 typedef GWEN_KEYSPEC* (GWEN_KEYSPEC_LIST2_FOREACH)(GWEN_KEYSPEC *element,
02196 void *user_data);
02197
02201 GWEN_KEYSPEC_LIST2 *GWEN_KeySpec_List2_new();
02202
02206 void GWEN_KeySpec_List2_free(GWEN_KEYSPEC_LIST2 *l);
02207
02211 void GWEN_KeySpec_List2_Dump(GWEN_KEYSPEC_LIST2 *l, FILE *f, unsigned int indent);
02212
02216 void GWEN_KeySpec_List2_PushBack(GWEN_KEYSPEC_LIST2 *l, GWEN_KEYSPEC *p);
02217
02222 void GWEN_KeySpec_List2_PushFront(GWEN_KEYSPEC_LIST2 *l, GWEN_KEYSPEC *p);
02223
02228 GWEN_KEYSPEC *GWEN_KeySpec_List2_GetFront(GWEN_KEYSPEC_LIST2 *l);
02229
02234 GWEN_KEYSPEC *GWEN_KeySpec_List2_GetBack(GWEN_KEYSPEC_LIST2 *l);
02235
02240 void GWEN_KeySpec_List2_Erase(GWEN_KEYSPEC_LIST2 *l,
02241 GWEN_KEYSPEC_LIST2_ITERATOR *it);
02242
02248 unsigned int GWEN_KeySpec_List2_GetSize(GWEN_KEYSPEC_LIST2 *l);
02249
02254 void GWEN_KeySpec_List2_PopBack(GWEN_KEYSPEC_LIST2 *l);
02255
02260 void GWEN_KeySpec_List2_PopFront(GWEN_KEYSPEC_LIST2 *l);
02261
02265 void GWEN_KeySpec_List2_Clear(GWEN_KEYSPEC_LIST2 *l);
02266
02270 GWEN_KEYSPEC_LIST2_ITERATOR *GWEN_KeySpec_List2_First(GWEN_KEYSPEC_LIST2 *l);
02271
02275 GWEN_KEYSPEC_LIST2_ITERATOR *GWEN_KeySpec_List2_Last(GWEN_KEYSPEC_LIST2 *l);
02276
02280 GWEN_KEYSPEC_LIST2_ITERATOR *GWEN_KeySpec_List2Iterator_new(GWEN_KEYSPEC_LIST2 *l);
02281
02285 void GWEN_KeySpec_List2Iterator_free(GWEN_KEYSPEC_LIST2_ITERATOR *li);
02286
02291 GWEN_KEYSPEC *GWEN_KeySpec_List2Iterator_Previous(GWEN_KEYSPEC_LIST2_ITERATOR *li);
02292
02297 GWEN_KEYSPEC *GWEN_KeySpec_List2Iterator_Next(GWEN_KEYSPEC_LIST2_ITERATOR *li);
02298
02303 GWEN_KEYSPEC *GWEN_KeySpec_List2Iterator_Data(GWEN_KEYSPEC_LIST2_ITERATOR *li);
02304
02316 GWEN_KEYSPEC *GWEN_KeySpec_List2_ForEach(GWEN_KEYSPEC_LIST2 *list,
02317 GWEN_KEYSPEC_LIST2_FOREACH func,
02318 void *user_data);
02319
02320
02321 typedef struct GWEN_KEYSPEC_CONSTLIST2 GWEN_KEYSPEC_CONSTLIST2;
02322 typedef struct GWEN_KEYSPEC_CONSTLIST2_ITERATOR GWEN_KEYSPEC_CONSTLIST2_ITERATOR;
02323 typedef const GWEN_KEYSPEC*
02324 (GWEN_KEYSPEC_CONSTLIST2_FOREACH)(const GWEN_KEYSPEC *element,
02325 void *user_data);
02326
02327
02328 GWEN_KEYSPEC_CONSTLIST2 *GWEN_KeySpec_ConstList2_new();
02329
02330 void GWEN_KeySpec_ConstList2_free(GWEN_KEYSPEC_CONSTLIST2 *l);
02331
02332 void GWEN_KeySpec_ConstList2_PushBack(GWEN_KEYSPEC_CONSTLIST2 *l, const GWEN_KEYSPEC *p);
02333
02334 void GWEN_KeySpec_ConstList2_PushFront(GWEN_KEYSPEC_CONSTLIST2 *l, const GWEN_KEYSPEC *p);
02335
02336 const GWEN_KEYSPEC *GWEN_KeySpec_ConstList2_GetFront(GWEN_KEYSPEC_CONSTLIST2 *l);
02337
02338 const GWEN_KEYSPEC *GWEN_KeySpec_ConstList2_GetBack(GWEN_KEYSPEC_CONSTLIST2 *l);
02339
02340 unsigned int GWEN_KeySpec_ConstList2_GetSize(GWEN_KEYSPEC_CONSTLIST2 *l);
02341
02342 void GWEN_KeySpec_ConstList2_PopBack(GWEN_KEYSPEC_CONSTLIST2 *l);
02343
02344 void GWEN_KeySpec_ConstList2_PopFront(GWEN_KEYSPEC_CONSTLIST2 *l);
02345
02346 void GWEN_KeySpec_ConstList2_Clear(GWEN_KEYSPEC_CONSTLIST2 *l);
02347
02348 GWEN_KEYSPEC_CONSTLIST2_ITERATOR *GWEN_KeySpec_ConstList2_First(GWEN_KEYSPEC_CONSTLIST2 *l);
02349
02350 GWEN_KEYSPEC_CONSTLIST2_ITERATOR *GWEN_KeySpec_ConstList2_Last(GWEN_KEYSPEC_CONSTLIST2 *l);
02351
02352 GWEN_KEYSPEC_CONSTLIST2_ITERATOR *GWEN_KeySpec_ConstList2Iterator_new(GWEN_KEYSPEC_CONSTLIST2 *l);
02353
02354 void GWEN_KeySpec_ConstList2Iterator_free(GWEN_KEYSPEC_CONSTLIST2_ITERATOR *li);
02355
02356 const GWEN_KEYSPEC *GWEN_KeySpec_ConstList2Iterator_Previous(GWEN_KEYSPEC_CONSTLIST2_ITERATOR *li);
02357
02358 const GWEN_KEYSPEC *GWEN_KeySpec_ConstList2Iterator_Next(GWEN_KEYSPEC_CONSTLIST2_ITERATOR *li);
02359
02360 const GWEN_KEYSPEC *GWEN_KeySpec_ConstList2Iterator_Data(GWEN_KEYSPEC_CONSTLIST2_ITERATOR *li);
02361
02373 const GWEN_KEYSPEC *GWEN_KeySpec_ConstList2_ForEach(GWEN_KEYSPEC_CONSTLIST2 *list,
02374 GWEN_KEYSPEC_CONSTLIST2_FOREACH func, void *user_data);
02375
02376
02377 #ifdef __cplusplus
02378 }
02379 #endif
02380
02381
02382 #endif
02383
02384
02385
02386
02387
02388
02389
02390
02391
02392
02393
02394
02395
02396
02397
02398
02399
02400
02401
02402
02403
02404
02405
02406
02407
02408
02409
02410
02411
02412
02413
02414 #ifndef GWEN_CRYPTTOKEN_LIST1_H
02415 #define GWEN_CRYPTTOKEN_LIST1_H
02416
02417 #ifdef __cplusplus
02418 extern "C" {
02419 #endif
02420
02422 typedef struct GWEN_CRYPTTOKEN_LIST_ELEMENT {
02423 GWEN_TYPE_UINT32 id;
02424 GWEN_CRYPTTOKEN *nextObject;
02425 } GWEN_CRYPTTOKEN_LIST__ELEMENT;
02426
02433 typedef struct GWEN_CRYPTTOKEN_LIST GWEN_CRYPTTOKEN_LIST;
02435 struct GWEN_CRYPTTOKEN_LIST {
02436 GWEN_CRYPTTOKEN *first;
02437 GWEN_TYPE_UINT32 count;
02438 GWEN_TYPE_UINT32 id;
02439 } GWEN_CRYPTTOKEN_LIST;
02440
02445 void GWEN_CryptToken_List_AddList(GWEN_CRYPTTOKEN_LIST *dst, GWEN_CRYPTTOKEN_LIST *l);
02446
02450 void GWEN_CryptToken_List_Add(GWEN_CRYPTTOKEN *element, GWEN_CRYPTTOKEN_LIST *list);
02451
02456 void GWEN_CryptToken_List_Insert(GWEN_CRYPTTOKEN *element, GWEN_CRYPTTOKEN_LIST *list);
02457
02464 void GWEN_CryptToken_List_Del(GWEN_CRYPTTOKEN *element);
02465
02469 GWEN_CRYPTTOKEN* GWEN_CryptToken_List_First(const GWEN_CRYPTTOKEN_LIST *l);
02470
02474 GWEN_CRYPTTOKEN* GWEN_CryptToken_List_Last(const GWEN_CRYPTTOKEN_LIST *l);
02475
02480 void GWEN_CryptToken_List_Clear(GWEN_CRYPTTOKEN_LIST *l);
02481
02485 GWEN_CRYPTTOKEN_LIST* GWEN_CryptToken_List_new();
02486
02490 void GWEN_CryptToken_List_free(GWEN_CRYPTTOKEN_LIST *l);
02491
02495 GWEN_CRYPTTOKEN* GWEN_CryptToken_List_Next(const GWEN_CRYPTTOKEN *element);
02496
02500 GWEN_CRYPTTOKEN* GWEN_CryptToken_List_Previous(const GWEN_CRYPTTOKEN *element);
02501
02505 GWEN_TYPE_UINT32 GWEN_CryptToken_List_GetCount(const GWEN_CRYPTTOKEN_LIST *l);
02506
02507 #ifdef __cplusplus
02508 }
02509 #endif
02510
02511
02512 #endif
02513
02514
02515
02516
02517
02518
02519
02520
02521
02522
02523
02524
02525
02526
02527
02528
02529
02530
02531
02532
02533
02534
02535
02536
02537
02538
02539
02540
02541
02542
02543
02544 #ifndef GWEN_CRYPTTOKEN_CONTEXT_LIST1_H
02545 #define GWEN_CRYPTTOKEN_CONTEXT_LIST1_H
02546
02547 #ifdef __cplusplus
02548 extern "C" {
02549 #endif
02550
02552 typedef struct GWEN_CRYPTTOKEN_CONTEXT_LIST_ELEMENT {
02553 GWEN_TYPE_UINT32 id;
02554 GWEN_CRYPTTOKEN_CONTEXT *nextObject;
02555 } GWEN_CRYPTTOKEN_CONTEXT_LIST__ELEMENT;
02556
02563 typedef struct GWEN_CRYPTTOKEN_CONTEXT_LIST GWEN_CRYPTTOKEN_CONTEXT_LIST;
02565 struct GWEN_CRYPTTOKEN_CONTEXT_LIST {
02566 GWEN_CRYPTTOKEN_CONTEXT *first;
02567 GWEN_TYPE_UINT32 count;
02568 GWEN_TYPE_UINT32 id;
02569 } GWEN_CRYPTTOKEN_CONTEXT_LIST;
02570
02575 void GWEN_CryptToken_Context_List_AddList(GWEN_CRYPTTOKEN_CONTEXT_LIST *dst, GWEN_CRYPTTOKEN_CONTEXT_LIST *l);
02576
02580 void GWEN_CryptToken_Context_List_Add(GWEN_CRYPTTOKEN_CONTEXT *element, GWEN_CRYPTTOKEN_CONTEXT_LIST *list);
02581
02586 void GWEN_CryptToken_Context_List_Insert(GWEN_CRYPTTOKEN_CONTEXT *element, GWEN_CRYPTTOKEN_CONTEXT_LIST *list);
02587
02594 void GWEN_CryptToken_Context_List_Del(GWEN_CRYPTTOKEN_CONTEXT *element);
02595
02599 GWEN_CRYPTTOKEN_CONTEXT* GWEN_CryptToken_Context_List_First(const GWEN_CRYPTTOKEN_CONTEXT_LIST *l);
02600
02604 GWEN_CRYPTTOKEN_CONTEXT* GWEN_CryptToken_Context_List_Last(const GWEN_CRYPTTOKEN_CONTEXT_LIST *l);
02605
02610 void GWEN_CryptToken_Context_List_Clear(GWEN_CRYPTTOKEN_CONTEXT_LIST *l);
02611
02615 GWEN_CRYPTTOKEN_CONTEXT_LIST* GWEN_CryptToken_Context_List_new();
02616
02620 void GWEN_CryptToken_Context_List_free(GWEN_CRYPTTOKEN_CONTEXT_LIST *l);
02621
02625 GWEN_CRYPTTOKEN_CONTEXT* GWEN_CryptToken_Context_List_Next(const GWEN_CRYPTTOKEN_CONTEXT *element);
02626
02630 GWEN_CRYPTTOKEN_CONTEXT* GWEN_CryptToken_Context_List_Previous(const GWEN_CRYPTTOKEN_CONTEXT *element);
02631
02635 GWEN_TYPE_UINT32 GWEN_CryptToken_Context_List_GetCount(const GWEN_CRYPTTOKEN_CONTEXT_LIST *l);
02636
02637 #ifdef __cplusplus
02638 }
02639 #endif
02640
02641
02642 #endif
02643
02644
02645
02646
02647
02648
02649
02650
02651
02652
02653
02654
02655
02656
02657
02658
02659
02660
02661
02662
02663
02664
02665
02666
02667
02668
02669
02670
02671
02672
02673
02674 #ifndef GWEN_CRYPTTOKEN_CRYPTINFO_LIST1_H
02675 #define GWEN_CRYPTTOKEN_CRYPTINFO_LIST1_H
02676
02677 #ifdef __cplusplus
02678 extern "C" {
02679 #endif
02680
02682 typedef struct GWEN_CRYPTTOKEN_CRYPTINFO_LIST_ELEMENT {
02683 GWEN_TYPE_UINT32 id;
02684 GWEN_CRYPTTOKEN_CRYPTINFO *nextObject;
02685 } GWEN_CRYPTTOKEN_CRYPTINFO_LIST__ELEMENT;
02686
02693 typedef struct GWEN_CRYPTTOKEN_CRYPTINFO_LIST GWEN_CRYPTTOKEN_CRYPTINFO_LIST;
02695 struct GWEN_CRYPTTOKEN_CRYPTINFO_LIST {
02696 GWEN_CRYPTTOKEN_CRYPTINFO *first;
02697 GWEN_TYPE_UINT32 count;
02698 GWEN_TYPE_UINT32 id;
02699 } GWEN_CRYPTTOKEN_CRYPTINFO_LIST;
02700
02705 void GWEN_CryptToken_CryptInfo_List_AddList(GWEN_CRYPTTOKEN_CRYPTINFO_LIST *dst, GWEN_CRYPTTOKEN_CRYPTINFO_LIST *l);
02706
02710 void GWEN_CryptToken_CryptInfo_List_Add(GWEN_CRYPTTOKEN_CRYPTINFO *element, GWEN_CRYPTTOKEN_CRYPTINFO_LIST *list);
02711
02716 void GWEN_CryptToken_CryptInfo_List_Insert(GWEN_CRYPTTOKEN_CRYPTINFO *element, GWEN_CRYPTTOKEN_CRYPTINFO_LIST *list);
02717
02724 void GWEN_CryptToken_CryptInfo_List_Del(GWEN_CRYPTTOKEN_CRYPTINFO *element);
02725
02729 GWEN_CRYPTTOKEN_CRYPTINFO* GWEN_CryptToken_CryptInfo_List_First(const GWEN_CRYPTTOKEN_CRYPTINFO_LIST *l);
02730
02734 GWEN_CRYPTTOKEN_CRYPTINFO* GWEN_CryptToken_CryptInfo_List_Last(const GWEN_CRYPTTOKEN_CRYPTINFO_LIST *l);
02735
02740 void GWEN_CryptToken_CryptInfo_List_Clear(GWEN_CRYPTTOKEN_CRYPTINFO_LIST *l);
02741
02745 GWEN_CRYPTTOKEN_CRYPTINFO_LIST* GWEN_CryptToken_CryptInfo_List_new();
02746
02750 void GWEN_CryptToken_CryptInfo_List_free(GWEN_CRYPTTOKEN_CRYPTINFO_LIST *l);
02751
02755 GWEN_CRYPTTOKEN_CRYPTINFO* GWEN_CryptToken_CryptInfo_List_Next(const GWEN_CRYPTTOKEN_CRYPTINFO *element);
02756
02760 GWEN_CRYPTTOKEN_CRYPTINFO* GWEN_CryptToken_CryptInfo_List_Previous(const GWEN_CRYPTTOKEN_CRYPTINFO *element);
02761
02765 GWEN_TYPE_UINT32 GWEN_CryptToken_CryptInfo_List_GetCount(const GWEN_CRYPTTOKEN_CRYPTINFO_LIST *l);
02766
02767 #ifdef __cplusplus
02768 }
02769 #endif
02770
02771
02772 #endif
02773
02774
02775
02776
02777
02778
02779
02780
02781
02782
02783
02784
02785
02786
02787
02788
02789
02790
02791
02792
02793
02794
02795
02796
02797
02798
02799
02800
02801
02802
02803
02804 #ifndef GWEN_CRYPTTOKEN_KEYINFO_LIST1_H
02805 #define GWEN_CRYPTTOKEN_KEYINFO_LIST1_H
02806
02807 #ifdef __cplusplus
02808 extern "C" {
02809 #endif
02810
02812 typedef struct GWEN_CRYPTTOKEN_KEYINFO_LIST_ELEMENT {
02813 GWEN_TYPE_UINT32 id;
02814 GWEN_CRYPTTOKEN_KEYINFO *nextObject;
02815 } GWEN_CRYPTTOKEN_KEYINFO_LIST__ELEMENT;
02816
02823 typedef struct GWEN_CRYPTTOKEN_KEYINFO_LIST GWEN_CRYPTTOKEN_KEYINFO_LIST;
02825 struct GWEN_CRYPTTOKEN_KEYINFO_LIST {
02826 GWEN_CRYPTTOKEN_KEYINFO *first;
02827 GWEN_TYPE_UINT32 count;
02828 GWEN_TYPE_UINT32 id;
02829 } GWEN_CRYPTTOKEN_KEYINFO_LIST;
02830
02835 void GWEN_CryptToken_KeyInfo_List_AddList(GWEN_CRYPTTOKEN_KEYINFO_LIST *dst, GWEN_CRYPTTOKEN_KEYINFO_LIST *l);
02836
02840 void GWEN_CryptToken_KeyInfo_List_Add(GWEN_CRYPTTOKEN_KEYINFO *element, GWEN_CRYPTTOKEN_KEYINFO_LIST *list);
02841
02846 void GWEN_CryptToken_KeyInfo_List_Insert(GWEN_CRYPTTOKEN_KEYINFO *element, GWEN_CRYPTTOKEN_KEYINFO_LIST *list);
02847
02854 void GWEN_CryptToken_KeyInfo_List_Del(GWEN_CRYPTTOKEN_KEYINFO *element);
02855
02859 GWEN_CRYPTTOKEN_KEYINFO* GWEN_CryptToken_KeyInfo_List_First(const GWEN_CRYPTTOKEN_KEYINFO_LIST *l);
02860
02864 GWEN_CRYPTTOKEN_KEYINFO* GWEN_CryptToken_KeyInfo_List_Last(const GWEN_CRYPTTOKEN_KEYINFO_LIST *l);
02865
02870 void GWEN_CryptToken_KeyInfo_List_Clear(GWEN_CRYPTTOKEN_KEYINFO_LIST *l);
02871
02875 GWEN_CRYPTTOKEN_KEYINFO_LIST* GWEN_CryptToken_KeyInfo_List_new();
02876
02880 void GWEN_CryptToken_KeyInfo_List_free(GWEN_CRYPTTOKEN_KEYINFO_LIST *l);
02881
02885 GWEN_CRYPTTOKEN_KEYINFO* GWEN_CryptToken_KeyInfo_List_Next(const GWEN_CRYPTTOKEN_KEYINFO *element);
02886
02890 GWEN_CRYPTTOKEN_KEYINFO* GWEN_CryptToken_KeyInfo_List_Previous(const GWEN_CRYPTTOKEN_KEYINFO *element);
02891
02895 GWEN_TYPE_UINT32 GWEN_CryptToken_KeyInfo_List_GetCount(const GWEN_CRYPTTOKEN_KEYINFO_LIST *l);
02896
02897 #ifdef __cplusplus
02898 }
02899 #endif
02900
02901
02902 #endif
02903
02904
02905
02906
02907
02908
02909
02910
02911
02912
02913
02914
02915
02916
02917
02918
02919
02920
02921
02922
02923
02924
02925
02926
02927
02928
02929
02930
02931
02932
02933
02934 #ifndef GWEN_CRYPTTOKEN_SIGNINFO_LIST1_H
02935 #define GWEN_CRYPTTOKEN_SIGNINFO_LIST1_H
02936
02937 #ifdef __cplusplus
02938 extern "C" {
02939 #endif
02940
02942 typedef struct GWEN_CRYPTTOKEN_SIGNINFO_LIST_ELEMENT {
02943 GWEN_TYPE_UINT32 id;
02944 GWEN_CRYPTTOKEN_SIGNINFO *nextObject;
02945 } GWEN_CRYPTTOKEN_SIGNINFO_LIST__ELEMENT;
02946
02953 typedef struct GWEN_CRYPTTOKEN_SIGNINFO_LIST GWEN_CRYPTTOKEN_SIGNINFO_LIST;
02955 struct GWEN_CRYPTTOKEN_SIGNINFO_LIST {
02956 GWEN_CRYPTTOKEN_SIGNINFO *first;
02957 GWEN_TYPE_UINT32 count;
02958 GWEN_TYPE_UINT32 id;
02959 } GWEN_CRYPTTOKEN_SIGNINFO_LIST;
02960
02965 void GWEN_CryptToken_SignInfo_List_AddList(GWEN_CRYPTTOKEN_SIGNINFO_LIST *dst, GWEN_CRYPTTOKEN_SIGNINFO_LIST *l);
02966
02970 void GWEN_CryptToken_SignInfo_List_Add(GWEN_CRYPTTOKEN_SIGNINFO *element, GWEN_CRYPTTOKEN_SIGNINFO_LIST *list);
02971
02976 void GWEN_CryptToken_SignInfo_List_Insert(GWEN_CRYPTTOKEN_SIGNINFO *element, GWEN_CRYPTTOKEN_SIGNINFO_LIST *list);
02977
02984 void GWEN_CryptToken_SignInfo_List_Del(GWEN_CRYPTTOKEN_SIGNINFO *element);
02985
02989 GWEN_CRYPTTOKEN_SIGNINFO* GWEN_CryptToken_SignInfo_List_First(const GWEN_CRYPTTOKEN_SIGNINFO_LIST *l);
02990
02994 GWEN_CRYPTTOKEN_SIGNINFO* GWEN_CryptToken_SignInfo_List_Last(const GWEN_CRYPTTOKEN_SIGNINFO_LIST *l);
02995
03000 void GWEN_CryptToken_SignInfo_List_Clear(GWEN_CRYPTTOKEN_SIGNINFO_LIST *l);
03001
03005 GWEN_CRYPTTOKEN_SIGNINFO_LIST* GWEN_CryptToken_SignInfo_List_new();
03006
03010 void GWEN_CryptToken_SignInfo_List_free(GWEN_CRYPTTOKEN_SIGNINFO_LIST *l);
03011
03015 GWEN_CRYPTTOKEN_SIGNINFO* GWEN_CryptToken_SignInfo_List_Next(const GWEN_CRYPTTOKEN_SIGNINFO *element);
03016
03020 GWEN_CRYPTTOKEN_SIGNINFO* GWEN_CryptToken_SignInfo_List_Previous(const GWEN_CRYPTTOKEN_SIGNINFO *element);
03021
03025 GWEN_TYPE_UINT32 GWEN_CryptToken_SignInfo_List_GetCount(const GWEN_CRYPTTOKEN_SIGNINFO_LIST *l);
03026
03027 #ifdef __cplusplus
03028 }
03029 #endif
03030
03031
03032 #endif
03033
03034
03035
03036
03037
03038
03039
03040
03041
03042
03043
03044
03045
03046
03047
03048
03049
03050
03051
03052
03053
03054
03055
03056
03057
03058
03059
03060
03061
03062
03063
03064 #ifndef GWEN_CRYPTTOKEN_USER_LIST2_H
03065 #define GWEN_CRYPTTOKEN_USER_LIST2_H
03066
03067
03068 #ifdef __cplusplus
03069 extern "C" {
03070 #endif
03071
03078 typedef struct GWEN_CRYPTTOKEN_USER_LIST2 GWEN_CRYPTTOKEN_USER_LIST2;
03079
03083 typedef struct GWEN_CRYPTTOKEN_USER_LIST2_ITERATOR GWEN_CRYPTTOKEN_USER_LIST2_ITERATOR;
03084
03088 typedef GWEN_CRYPTTOKEN_USER* (GWEN_CRYPTTOKEN_USER_LIST2_FOREACH)(GWEN_CRYPTTOKEN_USER *element,
03089 void *user_data);
03090
03094 GWEN_CRYPTTOKEN_USER_LIST2 *GWEN_CryptToken_User_List2_new();
03095
03099 void GWEN_CryptToken_User_List2_free(GWEN_CRYPTTOKEN_USER_LIST2 *l);
03100
03104 void GWEN_CryptToken_User_List2_Dump(GWEN_CRYPTTOKEN_USER_LIST2 *l, FILE *f, unsigned int indent);
03105
03109 void GWEN_CryptToken_User_List2_PushBack(GWEN_CRYPTTOKEN_USER_LIST2 *l, GWEN_CRYPTTOKEN_USER *p);
03110
03115 void GWEN_CryptToken_User_List2_PushFront(GWEN_CRYPTTOKEN_USER_LIST2 *l, GWEN_CRYPTTOKEN_USER *p);
03116
03121 GWEN_CRYPTTOKEN_USER *GWEN_CryptToken_User_List2_GetFront(GWEN_CRYPTTOKEN_USER_LIST2 *l);
03122
03127 GWEN_CRYPTTOKEN_USER *GWEN_CryptToken_User_List2_GetBack(GWEN_CRYPTTOKEN_USER_LIST2 *l);
03128
03133 void GWEN_CryptToken_User_List2_Erase(GWEN_CRYPTTOKEN_USER_LIST2 *l,
03134 GWEN_CRYPTTOKEN_USER_LIST2_ITERATOR *it);
03135
03141 unsigned int GWEN_CryptToken_User_List2_GetSize(GWEN_CRYPTTOKEN_USER_LIST2 *l);
03142
03147 void GWEN_CryptToken_User_List2_PopBack(GWEN_CRYPTTOKEN_USER_LIST2 *l);
03148
03153 void GWEN_CryptToken_User_List2_PopFront(GWEN_CRYPTTOKEN_USER_LIST2 *l);
03154
03158 void GWEN_CryptToken_User_List2_Clear(GWEN_CRYPTTOKEN_USER_LIST2 *l);
03159
03163 GWEN_CRYPTTOKEN_USER_LIST2_ITERATOR *GWEN_CryptToken_User_List2_First(GWEN_CRYPTTOKEN_USER_LIST2 *l);
03164
03168 GWEN_CRYPTTOKEN_USER_LIST2_ITERATOR *GWEN_CryptToken_User_List2_Last(GWEN_CRYPTTOKEN_USER_LIST2 *l);
03169
03173 GWEN_CRYPTTOKEN_USER_LIST2_ITERATOR *GWEN_CryptToken_User_List2Iterator_new(GWEN_CRYPTTOKEN_USER_LIST2 *l);
03174
03178 void GWEN_CryptToken_User_List2Iterator_free(GWEN_CRYPTTOKEN_USER_LIST2_ITERATOR *li);
03179
03184 GWEN_CRYPTTOKEN_USER *GWEN_CryptToken_User_List2Iterator_Previous(GWEN_CRYPTTOKEN_USER_LIST2_ITERATOR *li);
03185
03190 GWEN_CRYPTTOKEN_USER *GWEN_CryptToken_User_List2Iterator_Next(GWEN_CRYPTTOKEN_USER_LIST2_ITERATOR *li);
03191
03196 GWEN_CRYPTTOKEN_USER *GWEN_CryptToken_User_List2Iterator_Data(GWEN_CRYPTTOKEN_USER_LIST2_ITERATOR *li);
03197
03209 GWEN_CRYPTTOKEN_USER *GWEN_CryptToken_User_List2_ForEach(GWEN_CRYPTTOKEN_USER_LIST2 *list,
03210 GWEN_CRYPTTOKEN_USER_LIST2_FOREACH func,
03211 void *user_data);
03212
03213
03214 typedef struct GWEN_CRYPTTOKEN_USER_CONSTLIST2 GWEN_CRYPTTOKEN_USER_CONSTLIST2;
03215 typedef struct GWEN_CRYPTTOKEN_USER_CONSTLIST2_ITERATOR GWEN_CRYPTTOKEN_USER_CONSTLIST2_ITERATOR;
03216 typedef const GWEN_CRYPTTOKEN_USER*
03217 (GWEN_CRYPTTOKEN_USER_CONSTLIST2_FOREACH)(const GWEN_CRYPTTOKEN_USER *element,
03218 void *user_data);
03219
03220
03221 GWEN_CRYPTTOKEN_USER_CONSTLIST2 *GWEN_CryptToken_User_ConstList2_new();
03222
03223 void GWEN_CryptToken_User_ConstList2_free(GWEN_CRYPTTOKEN_USER_CONSTLIST2 *l);
03224
03225 void GWEN_CryptToken_User_ConstList2_PushBack(GWEN_CRYPTTOKEN_USER_CONSTLIST2 *l, const GWEN_CRYPTTOKEN_USER *p);
03226
03227 void GWEN_CryptToken_User_ConstList2_PushFront(GWEN_CRYPTTOKEN_USER_CONSTLIST2 *l, const GWEN_CRYPTTOKEN_USER *p);
03228
03229 const GWEN_CRYPTTOKEN_USER *GWEN_CryptToken_User_ConstList2_GetFront(GWEN_CRYPTTOKEN_USER_CONSTLIST2 *l);
03230
03231 const GWEN_CRYPTTOKEN_USER *GWEN_CryptToken_User_ConstList2_GetBack(GWEN_CRYPTTOKEN_USER_CONSTLIST2 *l);
03232
03233 unsigned int GWEN_CryptToken_User_ConstList2_GetSize(GWEN_CRYPTTOKEN_USER_CONSTLIST2 *l);
03234
03235 void GWEN_CryptToken_User_ConstList2_PopBack(GWEN_CRYPTTOKEN_USER_CONSTLIST2 *l);
03236
03237 void GWEN_CryptToken_User_ConstList2_PopFront(GWEN_CRYPTTOKEN_USER_CONSTLIST2 *l);
03238
03239 void GWEN_CryptToken_User_ConstList2_Clear(GWEN_CRYPTTOKEN_USER_CONSTLIST2 *l);
03240
03241 GWEN_CRYPTTOKEN_USER_CONSTLIST2_ITERATOR *GWEN_CryptToken_User_ConstList2_First(GWEN_CRYPTTOKEN_USER_CONSTLIST2 *l);
03242
03243 GWEN_CRYPTTOKEN_USER_CONSTLIST2_ITERATOR *GWEN_CryptToken_User_ConstList2_Last(GWEN_CRYPTTOKEN_USER_CONSTLIST2 *l);
03244
03245 GWEN_CRYPTTOKEN_USER_CONSTLIST2_ITERATOR *GWEN_CryptToken_User_ConstList2Iterator_new(GWEN_CRYPTTOKEN_USER_CONSTLIST2 *l);
03246
03247 void GWEN_CryptToken_User_ConstList2Iterator_free(GWEN_CRYPTTOKEN_USER_CONSTLIST2_ITERATOR *li);
03248
03249 const GWEN_CRYPTTOKEN_USER *GWEN_CryptToken_User_ConstList2Iterator_Previous(GWEN_CRYPTTOKEN_USER_CONSTLIST2_ITERATOR *li);
03250
03251 const GWEN_CRYPTTOKEN_USER *GWEN_CryptToken_User_ConstList2Iterator_Next(GWEN_CRYPTTOKEN_USER_CONSTLIST2_ITERATOR *li);
03252
03253 const GWEN_CRYPTTOKEN_USER *GWEN_CryptToken_User_ConstList2Iterator_Data(GWEN_CRYPTTOKEN_USER_CONSTLIST2_ITERATOR *li);
03254
03266 const GWEN_CRYPTTOKEN_USER *GWEN_CryptToken_User_ConstList2_ForEach(GWEN_CRYPTTOKEN_USER_CONSTLIST2 *list,
03267 GWEN_CRYPTTOKEN_USER_CONSTLIST2_FOREACH func, void *user_data);
03268
03269
03270 #ifdef __cplusplus
03271 }
03272 #endif
03273
03274
03275 #endif
03276
03277
03278
03279
03280
03281
03282
03283
03284
03285
03286
03287
03288
03289
03290
03291
03292
03293
03294
03295
03296
03297
03298
03299
03300
03301
03302
03303
03304
03305
03306
03307 #ifndef GWEN_CRYPTTOKEN_USER_LIST1_H
03308 #define GWEN_CRYPTTOKEN_USER_LIST1_H
03309
03310 #ifdef __cplusplus
03311 extern "C" {
03312 #endif
03313
03315 typedef struct GWEN_CRYPTTOKEN_USER_LIST_ELEMENT {
03316 GWEN_TYPE_UINT32 id;
03317 GWEN_CRYPTTOKEN_USER *nextObject;
03318 } GWEN_CRYPTTOKEN_USER_LIST__ELEMENT;
03319
03326 typedef struct GWEN_CRYPTTOKEN_USER_LIST GWEN_CRYPTTOKEN_USER_LIST;
03328 struct GWEN_CRYPTTOKEN_USER_LIST {
03329 GWEN_CRYPTTOKEN_USER *first;
03330 GWEN_TYPE_UINT32 count;
03331 GWEN_TYPE_UINT32 id;
03332 } GWEN_CRYPTTOKEN_USER_LIST;
03333
03338 void GWEN_CryptToken_User_List_AddList(GWEN_CRYPTTOKEN_USER_LIST *dst, GWEN_CRYPTTOKEN_USER_LIST *l);
03339
03343 void GWEN_CryptToken_User_List_Add(GWEN_CRYPTTOKEN_USER *element, GWEN_CRYPTTOKEN_USER_LIST *list);
03344
03349 void GWEN_CryptToken_User_List_Insert(GWEN_CRYPTTOKEN_USER *element, GWEN_CRYPTTOKEN_USER_LIST *list);
03350
03357 void GWEN_CryptToken_User_List_Del(GWEN_CRYPTTOKEN_USER *element);
03358
03362 GWEN_CRYPTTOKEN_USER* GWEN_CryptToken_User_List_First(const GWEN_CRYPTTOKEN_USER_LIST *l);
03363
03367 GWEN_CRYPTTOKEN_USER* GWEN_CryptToken_User_List_Last(const GWEN_CRYPTTOKEN_USER_LIST *l);
03368
03373 void GWEN_CryptToken_User_List_Clear(GWEN_CRYPTTOKEN_USER_LIST *l);
03374
03378 GWEN_CRYPTTOKEN_USER_LIST* GWEN_CryptToken_User_List_new();
03379
03383 void GWEN_CryptToken_User_List_free(GWEN_CRYPTTOKEN_USER_LIST *l);
03384
03388 GWEN_CRYPTTOKEN_USER* GWEN_CryptToken_User_List_Next(const GWEN_CRYPTTOKEN_USER *element);
03389
03393 GWEN_CRYPTTOKEN_USER* GWEN_CryptToken_User_List_Previous(const GWEN_CRYPTTOKEN_USER *element);
03394
03398 GWEN_TYPE_UINT32 GWEN_CryptToken_User_List_GetCount(const GWEN_CRYPTTOKEN_USER_LIST *l);
03399
03400 #ifdef __cplusplus
03401 }
03402 #endif
03403
03404
03405 #endif
03406
03407
03408
03409
03410
03411
03412
03413
03414
03415
03416
03417
03418
03419
03420
03421
03422
03423
03424
03425
03426
03427
03428
03429
03430
03431
03432
03433
03434
03435
03436
03437 #ifndef GWEN_CT_FILE_CONTEXT_LIST2_H
03438 #define GWEN_CT_FILE_CONTEXT_LIST2_H
03439
03440
03441 #ifdef __cplusplus
03442 extern "C" {
03443 #endif
03444
03451 typedef struct GWEN_CT_FILE_CONTEXT_LIST2 GWEN_CT_FILE_CONTEXT_LIST2;
03452
03456 typedef struct GWEN_CT_FILE_CONTEXT_LIST2_ITERATOR GWEN_CT_FILE_CONTEXT_LIST2_ITERATOR;
03457
03461 typedef GWEN_CT_FILE_CONTEXT* (GWEN_CT_FILE_CONTEXT_LIST2_FOREACH)(GWEN_CT_FILE_CONTEXT *element,
03462 void *user_data);
03463
03467 GWEN_CT_FILE_CONTEXT_LIST2 *GWEN_CryptTokenFile_Context_List2_new();
03468
03472 void GWEN_CryptTokenFile_Context_List2_free(GWEN_CT_FILE_CONTEXT_LIST2 *l);
03473
03477 void GWEN_CryptTokenFile_Context_List2_Dump(GWEN_CT_FILE_CONTEXT_LIST2 *l, FILE *f, unsigned int indent);
03478
03482 void GWEN_CryptTokenFile_Context_List2_PushBack(GWEN_CT_FILE_CONTEXT_LIST2 *l, GWEN_CT_FILE_CONTEXT *p);
03483
03488 void GWEN_CryptTokenFile_Context_List2_PushFront(GWEN_CT_FILE_CONTEXT_LIST2 *l, GWEN_CT_FILE_CONTEXT *p);
03489
03494 GWEN_CT_FILE_CONTEXT *GWEN_CryptTokenFile_Context_List2_GetFront(GWEN_CT_FILE_CONTEXT_LIST2 *l);
03495
03500 GWEN_CT_FILE_CONTEXT *GWEN_CryptTokenFile_Context_List2_GetBack(GWEN_CT_FILE_CONTEXT_LIST2 *l);
03501
03506 void GWEN_CryptTokenFile_Context_List2_Erase(GWEN_CT_FILE_CONTEXT_LIST2 *l,
03507 GWEN_CT_FILE_CONTEXT_LIST2_ITERATOR *it);
03508
03514 unsigned int GWEN_CryptTokenFile_Context_List2_GetSize(GWEN_CT_FILE_CONTEXT_LIST2 *l);
03515
03520 void GWEN_CryptTokenFile_Context_List2_PopBack(GWEN_CT_FILE_CONTEXT_LIST2 *l);
03521
03526 void GWEN_CryptTokenFile_Context_List2_PopFront(GWEN_CT_FILE_CONTEXT_LIST2 *l);
03527
03531 void GWEN_CryptTokenFile_Context_List2_Clear(GWEN_CT_FILE_CONTEXT_LIST2 *l);
03532
03536 GWEN_CT_FILE_CONTEXT_LIST2_ITERATOR *GWEN_CryptTokenFile_Context_List2_First(GWEN_CT_FILE_CONTEXT_LIST2 *l);
03537
03541 GWEN_CT_FILE_CONTEXT_LIST2_ITERATOR *GWEN_CryptTokenFile_Context_List2_Last(GWEN_CT_FILE_CONTEXT_LIST2 *l);
03542
03546 GWEN_CT_FILE_CONTEXT_LIST2_ITERATOR *GWEN_CryptTokenFile_Context_List2Iterator_new(GWEN_CT_FILE_CONTEXT_LIST2 *l);
03547
03551 void GWEN_CryptTokenFile_Context_List2Iterator_free(GWEN_CT_FILE_CONTEXT_LIST2_ITERATOR *li);
03552
03557 GWEN_CT_FILE_CONTEXT *GWEN_CryptTokenFile_Context_List2Iterator_Previous(GWEN_CT_FILE_CONTEXT_LIST2_ITERATOR *li);
03558
03563 GWEN_CT_FILE_CONTEXT *GWEN_CryptTokenFile_Context_List2Iterator_Next(GWEN_CT_FILE_CONTEXT_LIST2_ITERATOR *li);
03564
03569 GWEN_CT_FILE_CONTEXT *GWEN_CryptTokenFile_Context_List2Iterator_Data(GWEN_CT_FILE_CONTEXT_LIST2_ITERATOR *li);
03570
03582 GWEN_CT_FILE_CONTEXT *GWEN_CryptTokenFile_Context_List2_ForEach(GWEN_CT_FILE_CONTEXT_LIST2 *list,
03583 GWEN_CT_FILE_CONTEXT_LIST2_FOREACH func,
03584 void *user_data);
03585
03586
03587 typedef struct GWEN_CT_FILE_CONTEXT_CONSTLIST2 GWEN_CT_FILE_CONTEXT_CONSTLIST2;
03588 typedef struct GWEN_CT_FILE_CONTEXT_CONSTLIST2_ITERATOR GWEN_CT_FILE_CONTEXT_CONSTLIST2_ITERATOR;
03589 typedef const GWEN_CT_FILE_CONTEXT*
03590 (GWEN_CT_FILE_CONTEXT_CONSTLIST2_FOREACH)(const GWEN_CT_FILE_CONTEXT *element,
03591 void *user_data);
03592
03593
03594 GWEN_CT_FILE_CONTEXT_CONSTLIST2 *GWEN_CryptTokenFile_Context_ConstList2_new();
03595
03596 void GWEN_CryptTokenFile_Context_ConstList2_free(GWEN_CT_FILE_CONTEXT_CONSTLIST2 *l);
03597
03598 void GWEN_CryptTokenFile_Context_ConstList2_PushBack(GWEN_CT_FILE_CONTEXT_CONSTLIST2 *l, const GWEN_CT_FILE_CONTEXT *p);
03599
03600 void GWEN_CryptTokenFile_Context_ConstList2_PushFront(GWEN_CT_FILE_CONTEXT_CONSTLIST2 *l, const GWEN_CT_FILE_CONTEXT *p);
03601
03602 const GWEN_CT_FILE_CONTEXT *GWEN_CryptTokenFile_Context_ConstList2_GetFront(GWEN_CT_FILE_CONTEXT_CONSTLIST2 *l);
03603
03604 const GWEN_CT_FILE_CONTEXT *GWEN_CryptTokenFile_Context_ConstList2_GetBack(GWEN_CT_FILE_CONTEXT_CONSTLIST2 *l);
03605
03606 unsigned int GWEN_CryptTokenFile_Context_ConstList2_GetSize(GWEN_CT_FILE_CONTEXT_CONSTLIST2 *l);
03607
03608 void GWEN_CryptTokenFile_Context_ConstList2_PopBack(GWEN_CT_FILE_CONTEXT_CONSTLIST2 *l);
03609
03610 void GWEN_CryptTokenFile_Context_ConstList2_PopFront(GWEN_CT_FILE_CONTEXT_CONSTLIST2 *l);
03611
03612 void GWEN_CryptTokenFile_Context_ConstList2_Clear(GWEN_CT_FILE_CONTEXT_CONSTLIST2 *l);
03613
03614 GWEN_CT_FILE_CONTEXT_CONSTLIST2_ITERATOR *GWEN_CryptTokenFile_Context_ConstList2_First(GWEN_CT_FILE_CONTEXT_CONSTLIST2 *l);
03615
03616 GWEN_CT_FILE_CONTEXT_CONSTLIST2_ITERATOR *GWEN_CryptTokenFile_Context_ConstList2_Last(GWEN_CT_FILE_CONTEXT_CONSTLIST2 *l);
03617
03618 GWEN_CT_FILE_CONTEXT_CONSTLIST2_ITERATOR *GWEN_CryptTokenFile_Context_ConstList2Iterator_new(GWEN_CT_FILE_CONTEXT_CONSTLIST2 *l);
03619
03620 void GWEN_CryptTokenFile_Context_ConstList2Iterator_free(GWEN_CT_FILE_CONTEXT_CONSTLIST2_ITERATOR *li);
03621
03622 const GWEN_CT_FILE_CONTEXT *GWEN_CryptTokenFile_Context_ConstList2Iterator_Previous(GWEN_CT_FILE_CONTEXT_CONSTLIST2_ITERATOR *li);
03623
03624 const GWEN_CT_FILE_CONTEXT *GWEN_CryptTokenFile_Context_ConstList2Iterator_Next(GWEN_CT_FILE_CONTEXT_CONSTLIST2_ITERATOR *li);
03625
03626 const GWEN_CT_FILE_CONTEXT *GWEN_CryptTokenFile_Context_ConstList2Iterator_Data(GWEN_CT_FILE_CONTEXT_CONSTLIST2_ITERATOR *li);
03627
03639 const GWEN_CT_FILE_CONTEXT *GWEN_CryptTokenFile_Context_ConstList2_ForEach(GWEN_CT_FILE_CONTEXT_CONSTLIST2 *list,
03640 GWEN_CT_FILE_CONTEXT_CONSTLIST2_FOREACH func, void *user_data);
03641
03642
03643 #ifdef __cplusplus
03644 }
03645 #endif
03646
03647
03648 #endif
03649
03650
03651
03652
03653
03654
03655
03656
03657
03658
03659
03660
03661
03662
03663
03664
03665
03666
03667
03668
03669
03670
03671
03672
03673
03674
03675
03676
03677
03678
03679
03680 #ifndef GWEN_CT_FILE_CONTEXT_LIST1_H
03681 #define GWEN_CT_FILE_CONTEXT_LIST1_H
03682
03683 #ifdef __cplusplus
03684 extern "C" {
03685 #endif
03686
03688 typedef struct GWEN_CT_FILE_CONTEXT_LIST_ELEMENT {
03689 GWEN_TYPE_UINT32 id;
03690 GWEN_CT_FILE_CONTEXT *nextObject;
03691 } GWEN_CT_FILE_CONTEXT_LIST__ELEMENT;
03692
03699 typedef struct GWEN_CT_FILE_CONTEXT_LIST GWEN_CT_FILE_CONTEXT_LIST;
03701 struct GWEN_CT_FILE_CONTEXT_LIST {
03702 GWEN_CT_FILE_CONTEXT *first;
03703 GWEN_TYPE_UINT32 count;
03704 GWEN_TYPE_UINT32 id;
03705 } GWEN_CT_FILE_CONTEXT_LIST;
03706
03711 void GWEN_CryptTokenFile_Context_List_AddList(GWEN_CT_FILE_CONTEXT_LIST *dst, GWEN_CT_FILE_CONTEXT_LIST *l);
03712
03716 void GWEN_CryptTokenFile_Context_List_Add(GWEN_CT_FILE_CONTEXT *element, GWEN_CT_FILE_CONTEXT_LIST *list);
03717
03722 void GWEN_CryptTokenFile_Context_List_Insert(GWEN_CT_FILE_CONTEXT *element, GWEN_CT_FILE_CONTEXT_LIST *list);
03723
03730 void GWEN_CryptTokenFile_Context_List_Del(GWEN_CT_FILE_CONTEXT *element);
03731
03735 GWEN_CT_FILE_CONTEXT* GWEN_CryptTokenFile_Context_List_First(const GWEN_CT_FILE_CONTEXT_LIST *l);
03736
03740 GWEN_CT_FILE_CONTEXT* GWEN_CryptTokenFile_Context_List_Last(const GWEN_CT_FILE_CONTEXT_LIST *l);
03741
03746 void GWEN_CryptTokenFile_Context_List_Clear(GWEN_CT_FILE_CONTEXT_LIST *l);
03747
03751 GWEN_CT_FILE_CONTEXT_LIST* GWEN_CryptTokenFile_Context_List_new();
03752
03756 void GWEN_CryptTokenFile_Context_List_free(GWEN_CT_FILE_CONTEXT_LIST *l);
03757
03761 GWEN_CT_FILE_CONTEXT* GWEN_CryptTokenFile_Context_List_Next(const GWEN_CT_FILE_CONTEXT *element);
03762
03766 GWEN_CT_FILE_CONTEXT* GWEN_CryptTokenFile_Context_List_Previous(const GWEN_CT_FILE_CONTEXT *element);
03767
03771 GWEN_TYPE_UINT32 GWEN_CryptTokenFile_Context_List_GetCount(const GWEN_CT_FILE_CONTEXT_LIST *l);
03772
03773 #ifdef __cplusplus
03774 }
03775 #endif
03776
03777
03778 #endif
03779
03780
03781
03782
03783
03784
03785
03786
03787
03788
03789
03790
03791
03792
03793
03794
03795
03796
03797
03798
03799
03800
03801
03802
03803
03804
03805
03806
03807
03808
03809
03810 #ifndef GWEN_HTTP_COOKIE_LIST2_H
03811 #define GWEN_HTTP_COOKIE_LIST2_H
03812
03813
03814 #ifdef __cplusplus
03815 extern "C" {
03816 #endif
03817
03824 typedef struct GWEN_HTTP_COOKIE_LIST2 GWEN_HTTP_COOKIE_LIST2;
03825
03829 typedef struct GWEN_HTTP_COOKIE_LIST2_ITERATOR GWEN_HTTP_COOKIE_LIST2_ITERATOR;
03830
03834 typedef GWEN_HTTP_COOKIE* (GWEN_HTTP_COOKIE_LIST2_FOREACH)(GWEN_HTTP_COOKIE *element,
03835 void *user_data);
03836
03840 GWEN_HTTP_COOKIE_LIST2 *GWEN_HttpCookie_List2_new();
03841
03845 void GWEN_HttpCookie_List2_free(GWEN_HTTP_COOKIE_LIST2 *l);
03846
03850 void GWEN_HttpCookie_List2_Dump(GWEN_HTTP_COOKIE_LIST2 *l, FILE *f, unsigned int indent);
03851
03855 void GWEN_HttpCookie_List2_PushBack(GWEN_HTTP_COOKIE_LIST2 *l, GWEN_HTTP_COOKIE *p);
03856
03861 void GWEN_HttpCookie_List2_PushFront(GWEN_HTTP_COOKIE_LIST2 *l, GWEN_HTTP_COOKIE *p);
03862
03867 GWEN_HTTP_COOKIE *GWEN_HttpCookie_List2_GetFront(GWEN_HTTP_COOKIE_LIST2 *l);
03868
03873 GWEN_HTTP_COOKIE *GWEN_HttpCookie_List2_GetBack(GWEN_HTTP_COOKIE_LIST2 *l);
03874
03879 void GWEN_HttpCookie_List2_Erase(GWEN_HTTP_COOKIE_LIST2 *l,
03880 GWEN_HTTP_COOKIE_LIST2_ITERATOR *it);
03881
03887 unsigned int GWEN_HttpCookie_List2_GetSize(GWEN_HTTP_COOKIE_LIST2 *l);
03888
03893 void GWEN_HttpCookie_List2_PopBack(GWEN_HTTP_COOKIE_LIST2 *l);
03894
03899 void GWEN_HttpCookie_List2_PopFront(GWEN_HTTP_COOKIE_LIST2 *l);
03900
03904 void GWEN_HttpCookie_List2_Clear(GWEN_HTTP_COOKIE_LIST2 *l);
03905
03909 GWEN_HTTP_COOKIE_LIST2_ITERATOR *GWEN_HttpCookie_List2_First(GWEN_HTTP_COOKIE_LIST2 *l);
03910
03914 GWEN_HTTP_COOKIE_LIST2_ITERATOR *GWEN_HttpCookie_List2_Last(GWEN_HTTP_COOKIE_LIST2 *l);
03915
03919 GWEN_HTTP_COOKIE_LIST2_ITERATOR *GWEN_HttpCookie_List2Iterator_new(GWEN_HTTP_COOKIE_LIST2 *l);
03920
03924 void GWEN_HttpCookie_List2Iterator_free(GWEN_HTTP_COOKIE_LIST2_ITERATOR *li);
03925
03930 GWEN_HTTP_COOKIE *GWEN_HttpCookie_List2Iterator_Previous(GWEN_HTTP_COOKIE_LIST2_ITERATOR *li);
03931
03936 GWEN_HTTP_COOKIE *GWEN_HttpCookie_List2Iterator_Next(GWEN_HTTP_COOKIE_LIST2_ITERATOR *li);
03937
03942 GWEN_HTTP_COOKIE *GWEN_HttpCookie_List2Iterator_Data(GWEN_HTTP_COOKIE_LIST2_ITERATOR *li);
03943
03955 GWEN_HTTP_COOKIE *GWEN_HttpCookie_List2_ForEach(GWEN_HTTP_COOKIE_LIST2 *list,
03956 GWEN_HTTP_COOKIE_LIST2_FOREACH func,
03957 void *user_data);
03958
03959
03960 typedef struct GWEN_HTTP_COOKIE_CONSTLIST2 GWEN_HTTP_COOKIE_CONSTLIST2;
03961 typedef struct GWEN_HTTP_COOKIE_CONSTLIST2_ITERATOR GWEN_HTTP_COOKIE_CONSTLIST2_ITERATOR;
03962 typedef const GWEN_HTTP_COOKIE*
03963 (GWEN_HTTP_COOKIE_CONSTLIST2_FOREACH)(const GWEN_HTTP_COOKIE *element,
03964 void *user_data);
03965
03966
03967 GWEN_HTTP_COOKIE_CONSTLIST2 *GWEN_HttpCookie_ConstList2_new();
03968
03969 void GWEN_HttpCookie_ConstList2_free(GWEN_HTTP_COOKIE_CONSTLIST2 *l);
03970
03971 void GWEN_HttpCookie_ConstList2_PushBack(GWEN_HTTP_COOKIE_CONSTLIST2 *l, const GWEN_HTTP_COOKIE *p);
03972
03973 void GWEN_HttpCookie_ConstList2_PushFront(GWEN_HTTP_COOKIE_CONSTLIST2 *l, const GWEN_HTTP_COOKIE *p);
03974
03975 const GWEN_HTTP_COOKIE *GWEN_HttpCookie_ConstList2_GetFront(GWEN_HTTP_COOKIE_CONSTLIST2 *l);
03976
03977 const GWEN_HTTP_COOKIE *GWEN_HttpCookie_ConstList2_GetBack(GWEN_HTTP_COOKIE_CONSTLIST2 *l);
03978
03979 unsigned int GWEN_HttpCookie_ConstList2_GetSize(GWEN_HTTP_COOKIE_CONSTLIST2 *l);
03980
03981 void GWEN_HttpCookie_ConstList2_PopBack(GWEN_HTTP_COOKIE_CONSTLIST2 *l);
03982
03983 void GWEN_HttpCookie_ConstList2_PopFront(GWEN_HTTP_COOKIE_CONSTLIST2 *l);
03984
03985 void GWEN_HttpCookie_ConstList2_Clear(GWEN_HTTP_COOKIE_CONSTLIST2 *l);
03986
03987 GWEN_HTTP_COOKIE_CONSTLIST2_ITERATOR *GWEN_HttpCookie_ConstList2_First(GWEN_HTTP_COOKIE_CONSTLIST2 *l);
03988
03989 GWEN_HTTP_COOKIE_CONSTLIST2_ITERATOR *GWEN_HttpCookie_ConstList2_Last(GWEN_HTTP_COOKIE_CONSTLIST2 *l);
03990
03991 GWEN_HTTP_COOKIE_CONSTLIST2_ITERATOR *GWEN_HttpCookie_ConstList2Iterator_new(GWEN_HTTP_COOKIE_CONSTLIST2 *l);
03992
03993 void GWEN_HttpCookie_ConstList2Iterator_free(GWEN_HTTP_COOKIE_CONSTLIST2_ITERATOR *li);
03994
03995 const GWEN_HTTP_COOKIE *GWEN_HttpCookie_ConstList2Iterator_Previous(GWEN_HTTP_COOKIE_CONSTLIST2_ITERATOR *li);
03996
03997 const GWEN_HTTP_COOKIE *GWEN_HttpCookie_ConstList2Iterator_Next(GWEN_HTTP_COOKIE_CONSTLIST2_ITERATOR *li);
03998
03999 const GWEN_HTTP_COOKIE *GWEN_HttpCookie_ConstList2Iterator_Data(GWEN_HTTP_COOKIE_CONSTLIST2_ITERATOR *li);
04000
04012 const GWEN_HTTP_COOKIE *GWEN_HttpCookie_ConstList2_ForEach(GWEN_HTTP_COOKIE_CONSTLIST2 *list,
04013 GWEN_HTTP_COOKIE_CONSTLIST2_FOREACH func, void *user_data);
04014
04015
04016 #ifdef __cplusplus
04017 }
04018 #endif
04019
04020
04021 #endif
04022
04023
04024
04025
04026
04027
04028
04029
04030
04031
04032
04033
04034
04035
04036
04037
04038
04039
04040
04041
04042
04043
04044
04045
04046
04047
04048
04049
04050
04051
04052
04053 #ifndef GWEN_HTTP_COOKIE_LIST1_H
04054 #define GWEN_HTTP_COOKIE_LIST1_H
04055
04056 #ifdef __cplusplus
04057 extern "C" {
04058 #endif
04059
04061 typedef struct GWEN_HTTP_COOKIE_LIST_ELEMENT {
04062 GWEN_TYPE_UINT32 id;
04063 GWEN_HTTP_COOKIE *nextObject;
04064 } GWEN_HTTP_COOKIE_LIST__ELEMENT;
04065
04072 typedef struct GWEN_HTTP_COOKIE_LIST GWEN_HTTP_COOKIE_LIST;
04074 struct GWEN_HTTP_COOKIE_LIST {
04075 GWEN_HTTP_COOKIE *first;
04076 GWEN_TYPE_UINT32 count;
04077 GWEN_TYPE_UINT32 id;
04078 } GWEN_HTTP_COOKIE_LIST;
04079
04084 void GWEN_HttpCookie_List_AddList(GWEN_HTTP_COOKIE_LIST *dst, GWEN_HTTP_COOKIE_LIST *l);
04085
04089 void GWEN_HttpCookie_List_Add(GWEN_HTTP_COOKIE *element, GWEN_HTTP_COOKIE_LIST *list);
04090
04095 void GWEN_HttpCookie_List_Insert(GWEN_HTTP_COOKIE *element, GWEN_HTTP_COOKIE_LIST *list);
04096
04103 void GWEN_HttpCookie_List_Del(GWEN_HTTP_COOKIE *element);
04104
04108 GWEN_HTTP_COOKIE* GWEN_HttpCookie_List_First(const GWEN_HTTP_COOKIE_LIST *l);
04109
04113 GWEN_HTTP_COOKIE* GWEN_HttpCookie_List_Last(const GWEN_HTTP_COOKIE_LIST *l);
04114
04119 void GWEN_HttpCookie_List_Clear(GWEN_HTTP_COOKIE_LIST *l);
04120
04124 GWEN_HTTP_COOKIE_LIST* GWEN_HttpCookie_List_new();
04125
04129 void GWEN_HttpCookie_List_free(GWEN_HTTP_COOKIE_LIST *l);
04130
04134 GWEN_HTTP_COOKIE* GWEN_HttpCookie_List_Next(const GWEN_HTTP_COOKIE *element);
04135
04139 GWEN_HTTP_COOKIE* GWEN_HttpCookie_List_Previous(const GWEN_HTTP_COOKIE *element);
04140
04144 GWEN_TYPE_UINT32 GWEN_HttpCookie_List_GetCount(const GWEN_HTTP_COOKIE_LIST *l);
04145
04146 #ifdef __cplusplus
04147 }
04148 #endif
04149
04150
04151 #endif
04152
04153
04154
04155
04156
04157
04158
04159
04160
04161
04162
04163
04164
04165
04166
04167
04168
04169
04170
04171
04172
04173
04174
04175
04176
04177
04178
04179
04180
04181
04182
04183 #ifndef GWEN_HTTP_SESSION_LIST1_H
04184 #define GWEN_HTTP_SESSION_LIST1_H
04185
04186 #ifdef __cplusplus
04187 extern "C" {
04188 #endif
04189
04191 typedef struct GWEN_HTTP_SESSION_LIST_ELEMENT {
04192 GWEN_TYPE_UINT32 id;
04193 GWEN_HTTP_SESSION *nextObject;
04194 } GWEN_HTTP_SESSION_LIST__ELEMENT;
04195
04202 typedef struct GWEN_HTTP_SESSION_LIST GWEN_HTTP_SESSION_LIST;
04204 struct GWEN_HTTP_SESSION_LIST {
04205 GWEN_HTTP_SESSION *first;
04206 GWEN_TYPE_UINT32 count;
04207 GWEN_TYPE_UINT32 id;
04208 } GWEN_HTTP_SESSION_LIST;
04209
04214 void GWEN_HttpSession_List_AddList(GWEN_HTTP_SESSION_LIST *dst, GWEN_HTTP_SESSION_LIST *l);
04215
04219 void GWEN_HttpSession_List_Add(GWEN_HTTP_SESSION *element, GWEN_HTTP_SESSION_LIST *list);
04220
04225 void GWEN_HttpSession_List_Insert(GWEN_HTTP_SESSION *element, GWEN_HTTP_SESSION_LIST *list);
04226
04233 void GWEN_HttpSession_List_Del(GWEN_HTTP_SESSION *element);
04234
04238 GWEN_HTTP_SESSION* GWEN_HttpSession_List_First(const GWEN_HTTP_SESSION_LIST *l);
04239
04243 GWEN_HTTP_SESSION* GWEN_HttpSession_List_Last(const GWEN_HTTP_SESSION_LIST *l);
04244
04249 void GWEN_HttpSession_List_Clear(GWEN_HTTP_SESSION_LIST *l);
04250
04254 GWEN_HTTP_SESSION_LIST* GWEN_HttpSession_List_new();
04255
04259 void GWEN_HttpSession_List_free(GWEN_HTTP_SESSION_LIST *l);
04260
04264 GWEN_HTTP_SESSION* GWEN_HttpSession_List_Next(const GWEN_HTTP_SESSION *element);
04265
04269 GWEN_HTTP_SESSION* GWEN_HttpSession_List_Previous(const GWEN_HTTP_SESSION *element);
04270
04274 GWEN_TYPE_UINT32 GWEN_HttpSession_List_GetCount(const GWEN_HTTP_SESSION_LIST *l);
04275
04276 #ifdef __cplusplus
04277 }
04278 #endif
04279
04280
04281 #endif
04282
04283
04284
04285
04286
04287
04288
04289
04290
04291
04292
04293
04294
04295
04296
04297
04298
04299
04300
04301
04302
04303
04304
04305
04306
04307
04308
04309
04310
04311
04312
04313 #ifndef GWEN_HTTP_URL_LIST2_H
04314 #define GWEN_HTTP_URL_LIST2_H
04315
04316
04317 #ifdef __cplusplus
04318 extern "C" {
04319 #endif
04320
04327 typedef struct GWEN_HTTP_URL_LIST2 GWEN_HTTP_URL_LIST2;
04328
04332 typedef struct GWEN_HTTP_URL_LIST2_ITERATOR GWEN_HTTP_URL_LIST2_ITERATOR;
04333
04337 typedef GWEN_HTTP_URL* (GWEN_HTTP_URL_LIST2_FOREACH)(GWEN_HTTP_URL *element,
04338 void *user_data);
04339
04343 GWEN_HTTP_URL_LIST2 *GWEN_HttpUrl_List2_new();
04344
04348 void GWEN_HttpUrl_List2_free(GWEN_HTTP_URL_LIST2 *l);
04349
04353 void GWEN_HttpUrl_List2_Dump(GWEN_HTTP_URL_LIST2 *l, FILE *f, unsigned int indent);
04354
04358 void GWEN_HttpUrl_List2_PushBack(GWEN_HTTP_URL_LIST2 *l, GWEN_HTTP_URL *p);
04359
04364 void GWEN_HttpUrl_List2_PushFront(GWEN_HTTP_URL_LIST2 *l, GWEN_HTTP_URL *p);
04365
04370 GWEN_HTTP_URL *GWEN_HttpUrl_List2_GetFront(GWEN_HTTP_URL_LIST2 *l);
04371
04376 GWEN_HTTP_URL *GWEN_HttpUrl_List2_GetBack(GWEN_HTTP_URL_LIST2 *l);
04377
04382 void GWEN_HttpUrl_List2_Erase(GWEN_HTTP_URL_LIST2 *l,
04383 GWEN_HTTP_URL_LIST2_ITERATOR *it);
04384
04390 unsigned int GWEN_HttpUrl_List2_GetSize(GWEN_HTTP_URL_LIST2 *l);
04391
04396 void GWEN_HttpUrl_List2_PopBack(GWEN_HTTP_URL_LIST2 *l);
04397
04402 void GWEN_HttpUrl_List2_PopFront(GWEN_HTTP_URL_LIST2 *l);
04403
04407 void GWEN_HttpUrl_List2_Clear(GWEN_HTTP_URL_LIST2 *l);
04408
04412 GWEN_HTTP_URL_LIST2_ITERATOR *GWEN_HttpUrl_List2_First(GWEN_HTTP_URL_LIST2 *l);
04413
04417 GWEN_HTTP_URL_LIST2_ITERATOR *GWEN_HttpUrl_List2_Last(GWEN_HTTP_URL_LIST2 *l);
04418
04422 GWEN_HTTP_URL_LIST2_ITERATOR *GWEN_HttpUrl_List2Iterator_new(GWEN_HTTP_URL_LIST2 *l);
04423
04427 void GWEN_HttpUrl_List2Iterator_free(GWEN_HTTP_URL_LIST2_ITERATOR *li);
04428
04433 GWEN_HTTP_URL *GWEN_HttpUrl_List2Iterator_Previous(GWEN_HTTP_URL_LIST2_ITERATOR *li);
04434
04439 GWEN_HTTP_URL *GWEN_HttpUrl_List2Iterator_Next(GWEN_HTTP_URL_LIST2_ITERATOR *li);
04440
04445 GWEN_HTTP_URL *GWEN_HttpUrl_List2Iterator_Data(GWEN_HTTP_URL_LIST2_ITERATOR *li);
04446
04458 GWEN_HTTP_URL *GWEN_HttpUrl_List2_ForEach(GWEN_HTTP_URL_LIST2 *list,
04459 GWEN_HTTP_URL_LIST2_FOREACH func,
04460 void *user_data);
04461
04462
04463 typedef struct GWEN_HTTP_URL_CONSTLIST2 GWEN_HTTP_URL_CONSTLIST2;
04464 typedef struct GWEN_HTTP_URL_CONSTLIST2_ITERATOR GWEN_HTTP_URL_CONSTLIST2_ITERATOR;
04465 typedef const GWEN_HTTP_URL*
04466 (GWEN_HTTP_URL_CONSTLIST2_FOREACH)(const GWEN_HTTP_URL *element,
04467 void *user_data);
04468
04469
04470 GWEN_HTTP_URL_CONSTLIST2 *GWEN_HttpUrl_ConstList2_new();
04471
04472 void GWEN_HttpUrl_ConstList2_free(GWEN_HTTP_URL_CONSTLIST2 *l);
04473
04474 void GWEN_HttpUrl_ConstList2_PushBack(GWEN_HTTP_URL_CONSTLIST2 *l, const GWEN_HTTP_URL *p);
04475
04476 void GWEN_HttpUrl_ConstList2_PushFront(GWEN_HTTP_URL_CONSTLIST2 *l, const GWEN_HTTP_URL *p);
04477
04478 const GWEN_HTTP_URL *GWEN_HttpUrl_ConstList2_GetFront(GWEN_HTTP_URL_CONSTLIST2 *l);
04479
04480 const GWEN_HTTP_URL *GWEN_HttpUrl_ConstList2_GetBack(GWEN_HTTP_URL_CONSTLIST2 *l);
04481
04482 unsigned int GWEN_HttpUrl_ConstList2_GetSize(GWEN_HTTP_URL_CONSTLIST2 *l);
04483
04484 void GWEN_HttpUrl_ConstList2_PopBack(GWEN_HTTP_URL_CONSTLIST2 *l);
04485
04486 void GWEN_HttpUrl_ConstList2_PopFront(GWEN_HTTP_URL_CONSTLIST2 *l);
04487
04488 void GWEN_HttpUrl_ConstList2_Clear(GWEN_HTTP_URL_CONSTLIST2 *l);
04489
04490 GWEN_HTTP_URL_CONSTLIST2_ITERATOR *GWEN_HttpUrl_ConstList2_First(GWEN_HTTP_URL_CONSTLIST2 *l);
04491
04492 GWEN_HTTP_URL_CONSTLIST2_ITERATOR *GWEN_HttpUrl_ConstList2_Last(GWEN_HTTP_URL_CONSTLIST2 *l);
04493
04494 GWEN_HTTP_URL_CONSTLIST2_ITERATOR *GWEN_HttpUrl_ConstList2Iterator_new(GWEN_HTTP_URL_CONSTLIST2 *l);
04495
04496 void GWEN_HttpUrl_ConstList2Iterator_free(GWEN_HTTP_URL_CONSTLIST2_ITERATOR *li);
04497
04498 const GWEN_HTTP_URL *GWEN_HttpUrl_ConstList2Iterator_Previous(GWEN_HTTP_URL_CONSTLIST2_ITERATOR *li);
04499
04500 const GWEN_HTTP_URL *GWEN_HttpUrl_ConstList2Iterator_Next(GWEN_HTTP_URL_CONSTLIST2_ITERATOR *li);
04501
04502 const GWEN_HTTP_URL *GWEN_HttpUrl_ConstList2Iterator_Data(GWEN_HTTP_URL_CONSTLIST2_ITERATOR *li);
04503
04515 const GWEN_HTTP_URL *GWEN_HttpUrl_ConstList2_ForEach(GWEN_HTTP_URL_CONSTLIST2 *list,
04516 GWEN_HTTP_URL_CONSTLIST2_FOREACH func, void *user_data);
04517
04518
04519 #ifdef __cplusplus
04520 }
04521 #endif
04522
04523
04524 #endif
04525
04526
04527
04528
04529
04530
04531
04532
04533
04534
04535
04536
04537
04538
04539
04540
04541
04542
04543
04544
04545
04546
04547
04548
04549
04550
04551
04552
04553
04554
04555
04556 #ifndef GWEN_HTTP_URL_LIST1_H
04557 #define GWEN_HTTP_URL_LIST1_H
04558
04559 #ifdef __cplusplus
04560 extern "C" {
04561 #endif
04562
04564 typedef struct GWEN_HTTP_URL_LIST_ELEMENT {
04565 GWEN_TYPE_UINT32 id;
04566 GWEN_HTTP_URL *nextObject;
04567 } GWEN_HTTP_URL_LIST__ELEMENT;
04568
04575 typedef struct GWEN_HTTP_URL_LIST GWEN_HTTP_URL_LIST;
04577 struct GWEN_HTTP_URL_LIST {
04578 GWEN_HTTP_URL *first;
04579 GWEN_TYPE_UINT32 count;
04580 GWEN_TYPE_UINT32 id;
04581 } GWEN_HTTP_URL_LIST;
04582
04587 void GWEN_HttpUrl_List_AddList(GWEN_HTTP_URL_LIST *dst, GWEN_HTTP_URL_LIST *l);
04588
04592 void GWEN_HttpUrl_List_Add(GWEN_HTTP_URL *element, GWEN_HTTP_URL_LIST *list);
04593
04598 void GWEN_HttpUrl_List_Insert(GWEN_HTTP_URL *element, GWEN_HTTP_URL_LIST *list);
04599
04606 void GWEN_HttpUrl_List_Del(GWEN_HTTP_URL *element);
04607
04611 GWEN_HTTP_URL* GWEN_HttpUrl_List_First(const GWEN_HTTP_URL_LIST *l);
04612
04616 GWEN_HTTP_URL* GWEN_HttpUrl_List_Last(const GWEN_HTTP_URL_LIST *l);
04617
04622 void GWEN_HttpUrl_List_Clear(GWEN_HTTP_URL_LIST *l);
04623
04627 GWEN_HTTP_URL_LIST* GWEN_HttpUrl_List_new();
04628
04632 void GWEN_HttpUrl_List_free(GWEN_HTTP_URL_LIST *l);
04633
04637 GWEN_HTTP_URL* GWEN_HttpUrl_List_Next(const GWEN_HTTP_URL *element);
04638
04642 GWEN_HTTP_URL* GWEN_HttpUrl_List_Previous(const GWEN_HTTP_URL *element);
04643
04647 GWEN_TYPE_UINT32 GWEN_HttpUrl_List_GetCount(const GWEN_HTTP_URL_LIST *l);
04648
04649 #ifdef __cplusplus
04650 }
04651 #endif
04652
04653
04654 #endif
04655
04656
04657
04658
04659
04660
04661
04662
04663
04664
04665
04666
04667
04668
04669
04670
04671
04672
04673
04674
04675
04676
04677
04678
04679
04680
04681
04682
04683
04684
04685
04686 #ifndef GWEN_IPC_REQUEST_LIST2_H
04687 #define GWEN_IPC_REQUEST_LIST2_H
04688
04689
04690 #ifdef __cplusplus
04691 extern "C" {
04692 #endif
04693
04700 typedef struct GWEN_IPC_REQUEST_LIST2 GWEN_IPC_REQUEST_LIST2;
04701
04705 typedef struct GWEN_IPC_REQUEST_LIST2_ITERATOR GWEN_IPC_REQUEST_LIST2_ITERATOR;
04706
04710 typedef GWEN_IPC_REQUEST* (GWEN_IPC_REQUEST_LIST2_FOREACH)(GWEN_IPC_REQUEST *element,
04711 void *user_data);
04712
04716 GWEN_IPC_REQUEST_LIST2 *GWEN_IpcRequest_List2_new();
04717
04721 void GWEN_IpcRequest_List2_free(GWEN_IPC_REQUEST_LIST2 *l);
04722
04726 void GWEN_IpcRequest_List2_Dump(GWEN_IPC_REQUEST_LIST2 *l, FILE *f, unsigned int indent);
04727
04731 void GWEN_IpcRequest_List2_PushBack(GWEN_IPC_REQUEST_LIST2 *l, GWEN_IPC_REQUEST *p);
04732
04737 void GWEN_IpcRequest_List2_PushFront(GWEN_IPC_REQUEST_LIST2 *l, GWEN_IPC_REQUEST *p);
04738
04743 GWEN_IPC_REQUEST *GWEN_IpcRequest_List2_GetFront(GWEN_IPC_REQUEST_LIST2 *l);
04744
04749 GWEN_IPC_REQUEST *GWEN_IpcRequest_List2_GetBack(GWEN_IPC_REQUEST_LIST2 *l);
04750
04755 void GWEN_IpcRequest_List2_Erase(GWEN_IPC_REQUEST_LIST2 *l,
04756 GWEN_IPC_REQUEST_LIST2_ITERATOR *it);
04757
04763 unsigned int GWEN_IpcRequest_List2_GetSize(GWEN_IPC_REQUEST_LIST2 *l);
04764
04769 void GWEN_IpcRequest_List2_PopBack(GWEN_IPC_REQUEST_LIST2 *l);
04770
04775 void GWEN_IpcRequest_List2_PopFront(GWEN_IPC_REQUEST_LIST2 *l);
04776
04780 void GWEN_IpcRequest_List2_Clear(GWEN_IPC_REQUEST_LIST2 *l);
04781
04785 GWEN_IPC_REQUEST_LIST2_ITERATOR *GWEN_IpcRequest_List2_First(GWEN_IPC_REQUEST_LIST2 *l);
04786
04790 GWEN_IPC_REQUEST_LIST2_ITERATOR *GWEN_IpcRequest_List2_Last(GWEN_IPC_REQUEST_LIST2 *l);
04791
04795 GWEN_IPC_REQUEST_LIST2_ITERATOR *GWEN_IpcRequest_List2Iterator_new(GWEN_IPC_REQUEST_LIST2 *l);
04796
04800 void GWEN_IpcRequest_List2Iterator_free(GWEN_IPC_REQUEST_LIST2_ITERATOR *li);
04801
04806 GWEN_IPC_REQUEST *GWEN_IpcRequest_List2Iterator_Previous(GWEN_IPC_REQUEST_LIST2_ITERATOR *li);
04807
04812 GWEN_IPC_REQUEST *GWEN_IpcRequest_List2Iterator_Next(GWEN_IPC_REQUEST_LIST2_ITERATOR *li);
04813
04818 GWEN_IPC_REQUEST *GWEN_IpcRequest_List2Iterator_Data(GWEN_IPC_REQUEST_LIST2_ITERATOR *li);
04819
04831 GWEN_IPC_REQUEST *GWEN_IpcRequest_List2_ForEach(GWEN_IPC_REQUEST_LIST2 *list,
04832 GWEN_IPC_REQUEST_LIST2_FOREACH func,
04833 void *user_data);
04834
04835
04836 typedef struct GWEN_IPC_REQUEST_CONSTLIST2 GWEN_IPC_REQUEST_CONSTLIST2;
04837 typedef struct GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR;
04838 typedef const GWEN_IPC_REQUEST*
04839 (GWEN_IPC_REQUEST_CONSTLIST2_FOREACH)(const GWEN_IPC_REQUEST *element,
04840 void *user_data);
04841
04842
04843 GWEN_IPC_REQUEST_CONSTLIST2 *GWEN_IpcRequest_ConstList2_new();
04844
04845 void GWEN_IpcRequest_ConstList2_free(GWEN_IPC_REQUEST_CONSTLIST2 *l);
04846
04847 void GWEN_IpcRequest_ConstList2_PushBack(GWEN_IPC_REQUEST_CONSTLIST2 *l, const GWEN_IPC_REQUEST *p);
04848
04849 void GWEN_IpcRequest_ConstList2_PushFront(GWEN_IPC_REQUEST_CONSTLIST2 *l, const GWEN_IPC_REQUEST *p);
04850
04851 const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2_GetFront(GWEN_IPC_REQUEST_CONSTLIST2 *l);
04852
04853 const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2_GetBack(GWEN_IPC_REQUEST_CONSTLIST2 *l);
04854
04855 unsigned int GWEN_IpcRequest_ConstList2_GetSize(GWEN_IPC_REQUEST_CONSTLIST2 *l);
04856
04857 void GWEN_IpcRequest_ConstList2_PopBack(GWEN_IPC_REQUEST_CONSTLIST2 *l);
04858
04859 void GWEN_IpcRequest_ConstList2_PopFront(GWEN_IPC_REQUEST_CONSTLIST2 *l);
04860
04861 void GWEN_IpcRequest_ConstList2_Clear(GWEN_IPC_REQUEST_CONSTLIST2 *l);
04862
04863 GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *GWEN_IpcRequest_ConstList2_First(GWEN_IPC_REQUEST_CONSTLIST2 *l);
04864
04865 GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *GWEN_IpcRequest_ConstList2_Last(GWEN_IPC_REQUEST_CONSTLIST2 *l);
04866
04867 GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *GWEN_IpcRequest_ConstList2Iterator_new(GWEN_IPC_REQUEST_CONSTLIST2 *l);
04868
04869 void GWEN_IpcRequest_ConstList2Iterator_free(GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *li);
04870
04871 const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2Iterator_Previous(GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *li);
04872
04873 const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2Iterator_Next(GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *li);
04874
04875 const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2Iterator_Data(GWEN_IPC_REQUEST_CONSTLIST2_ITERATOR *li);
04876
04888 const GWEN_IPC_REQUEST *GWEN_IpcRequest_ConstList2_ForEach(GWEN_IPC_REQUEST_CONSTLIST2 *list,
04889 GWEN_IPC_REQUEST_CONSTLIST2_FOREACH func, void *user_data);
04890
04891
04892 #ifdef __cplusplus
04893 }
04894 #endif
04895
04896
04897 #endif
04898
04899
04900
04901
04902
04903
04904
04905
04906
04907
04908
04909
04910
04911
04912
04913
04914
04915
04916
04917
04918
04919
04920
04921
04922
04923
04924
04925
04926
04927
04928
04929 #ifndef GWEN_IPC_REQUEST_LIST1_H
04930 #define GWEN_IPC_REQUEST_LIST1_H
04931
04932 #ifdef __cplusplus
04933 extern "C" {
04934 #endif
04935
04937 typedef struct GWEN_IPC_REQUEST_LIST_ELEMENT {
04938 GWEN_TYPE_UINT32 id;
04939 GWEN_IPC_REQUEST *nextObject;
04940 } GWEN_IPC_REQUEST_LIST__ELEMENT;
04941
04948 typedef struct GWEN_IPC_REQUEST_LIST GWEN_IPC_REQUEST_LIST;
04950 struct GWEN_IPC_REQUEST_LIST {
04951 GWEN_IPC_REQUEST *first;
04952 GWEN_TYPE_UINT32 count;
04953 GWEN_TYPE_UINT32 id;
04954 } GWEN_IPC_REQUEST_LIST;
04955
04960 void GWEN_IpcRequest_List_AddList(GWEN_IPC_REQUEST_LIST *dst, GWEN_IPC_REQUEST_LIST *l);
04961
04965 void GWEN_IpcRequest_List_Add(GWEN_IPC_REQUEST *element, GWEN_IPC_REQUEST_LIST *list);
04966
04971 void GWEN_IpcRequest_List_Insert(GWEN_IPC_REQUEST *element, GWEN_IPC_REQUEST_LIST *list);
04972
04979 void GWEN_IpcRequest_List_Del(GWEN_IPC_REQUEST *element);
04980
04984 GWEN_IPC_REQUEST* GWEN_IpcRequest_List_First(const GWEN_IPC_REQUEST_LIST *l);
04985
04989 GWEN_IPC_REQUEST* GWEN_IpcRequest_List_Last(const GWEN_IPC_REQUEST_LIST *l);
04990
04995 void GWEN_IpcRequest_List_Clear(GWEN_IPC_REQUEST_LIST *l);
04996
05000 GWEN_IPC_REQUEST_LIST* GWEN_IpcRequest_List_new();
05001
05005 void GWEN_IpcRequest_List_free(GWEN_IPC_REQUEST_LIST *l);
05006
05010 GWEN_IPC_REQUEST* GWEN_IpcRequest_List_Next(const GWEN_IPC_REQUEST *element);
05011
05015 GWEN_IPC_REQUEST* GWEN_IpcRequest_List_Previous(const GWEN_IPC_REQUEST *element);
05016
05020 GWEN_TYPE_UINT32 GWEN_IpcRequest_List_GetCount(const GWEN_IPC_REQUEST_LIST *l);
05021
05022 #ifdef __cplusplus
05023 }
05024 #endif
05025
05026
05027 #endif
05028
05029
05030
05031
05032
05033
05034
05035
05036
05037
05038
05039
05040
05041
05042
05043
05044
05045
05046
05047
05048
05049
05050
05051
05052
05053
05054
05055
05056
05057
05058
05059 #ifndef GWEN_DBIO_LIST1_H
05060 #define GWEN_DBIO_LIST1_H
05061
05062 #ifdef __cplusplus
05063 extern "C" {
05064 #endif
05065
05067 typedef struct GWEN_DBIO_LIST_ELEMENT {
05068 GWEN_TYPE_UINT32 id;
05069 GWEN_DBIO *nextObject;
05070 } GWEN_DBIO_LIST__ELEMENT;
05071
05078 typedef struct GWEN_DBIO_LIST GWEN_DBIO_LIST;
05080 struct GWEN_DBIO_LIST {
05081 GWEN_DBIO *first;
05082 GWEN_TYPE_UINT32 count;
05083 GWEN_TYPE_UINT32 id;
05084 } GWEN_DBIO_LIST;
05085
05090 void GWEN_DBIO_List_AddList(GWEN_DBIO_LIST *dst, GWEN_DBIO_LIST *l);
05091
05095 void GWEN_DBIO_List_Add(GWEN_DBIO *element, GWEN_DBIO_LIST *list);
05096
05101 void GWEN_DBIO_List_Insert(GWEN_DBIO *element, GWEN_DBIO_LIST *list);
05102
05109 void GWEN_DBIO_List_Del(GWEN_DBIO *element);
05110
05114 GWEN_DBIO* GWEN_DBIO_List_First(const GWEN_DBIO_LIST *l);
05115
05119 GWEN_DBIO* GWEN_DBIO_List_Last(const GWEN_DBIO_LIST *l);
05120
05125 void GWEN_DBIO_List_Clear(GWEN_DBIO_LIST *l);
05126
05130 GWEN_DBIO_LIST* GWEN_DBIO_List_new();
05131
05135 void GWEN_DBIO_List_free(GWEN_DBIO_LIST *l);
05136
05140 GWEN_DBIO* GWEN_DBIO_List_Next(const GWEN_DBIO *element);
05141
05145 GWEN_DBIO* GWEN_DBIO_List_Previous(const GWEN_DBIO *element);
05146
05150 GWEN_TYPE_UINT32 GWEN_DBIO_List_GetCount(const GWEN_DBIO_LIST *l);
05151
05152 #ifdef __cplusplus
05153 }
05154 #endif
05155
05156
05157 #endif
05158
05159
05160
05161
05162
05163
05164
05165
05166
05167
05168
05169
05170
05171
05172
05173
05174
05175
05176
05177
05178
05179
05180
05181
05182
05183
05184
05185
05186
05187
05188
05189 #ifndef GWEN_TLV_LIST1_H
05190 #define GWEN_TLV_LIST1_H
05191
05192 #ifdef __cplusplus
05193 extern "C" {
05194 #endif
05195
05197 typedef struct GWEN_TLV_LIST_ELEMENT {
05198 GWEN_TYPE_UINT32 id;
05199 GWEN_TLV *nextObject;
05200 } GWEN_TLV_LIST__ELEMENT;
05201
05208 typedef struct GWEN_TLV_LIST GWEN_TLV_LIST;
05210 struct GWEN_TLV_LIST {
05211 GWEN_TLV *first;
05212 GWEN_TYPE_UINT32 count;
05213 GWEN_TYPE_UINT32 id;
05214 } GWEN_TLV_LIST;
05215
05220 void GWEN_TLV_List_AddList(GWEN_TLV_LIST *dst, GWEN_TLV_LIST *l);
05221
05225 void GWEN_TLV_List_Add(GWEN_TLV *element, GWEN_TLV_LIST *list);
05226
05231 void GWEN_TLV_List_Insert(GWEN_TLV *element, GWEN_TLV_LIST *list);
05232
05239 void GWEN_TLV_List_Del(GWEN_TLV *element);
05240
05244 GWEN_TLV* GWEN_TLV_List_First(const GWEN_TLV_LIST *l);
05245
05249 GWEN_TLV* GWEN_TLV_List_Last(const GWEN_TLV_LIST *l);
05250
05255 void GWEN_TLV_List_Clear(GWEN_TLV_LIST *l);
05256
05260 GWEN_TLV_LIST* GWEN_TLV_List_new();
05261
05265 void GWEN_TLV_List_free(GWEN_TLV_LIST *l);
05266
05270 GWEN_TLV* GWEN_TLV_List_Next(const GWEN_TLV *element);
05271
05275 GWEN_TLV* GWEN_TLV_List_Previous(const GWEN_TLV *element);
05276
05280 GWEN_TYPE_UINT32 GWEN_TLV_List_GetCount(const GWEN_TLV_LIST *l);
05281
05282 #ifdef __cplusplus
05283 }
05284 #endif
05285
05286
05287 #endif
05288
05289
05290
05291
05292
05293
05294
05295
05296
05297
05298
05299
05300
05301
05302
05303
05304
05305
05306
05307
05308
05309
05310
05311
05312
05313
05314
05315
05316
05317
05318
05319 #ifndef GWEN_XMLNODE_LIST2_H
05320 #define GWEN_XMLNODE_LIST2_H
05321
05322
05323 #ifdef __cplusplus
05324 extern "C" {
05325 #endif
05326
05333 typedef struct GWEN_XMLNODE_LIST2 GWEN_XMLNODE_LIST2;
05334
05338 typedef struct GWEN_XMLNODE_LIST2_ITERATOR GWEN_XMLNODE_LIST2_ITERATOR;
05339
05343 typedef GWEN_XMLNODE* (GWEN_XMLNODE_LIST2_FOREACH)(GWEN_XMLNODE *element,
05344 void *user_data);
05345
05349 GWEN_XMLNODE_LIST2 *GWEN_XMLNode_List2_new();
05350
05354 void GWEN_XMLNode_List2_free(GWEN_XMLNODE_LIST2 *l);
05355
05359 void GWEN_XMLNode_List2_Dump(GWEN_XMLNODE_LIST2 *l, FILE *f, unsigned int indent);
05360
05364 void GWEN_XMLNode_List2_PushBack(GWEN_XMLNODE_LIST2 *l, GWEN_XMLNODE *p);
05365
05370 void GWEN_XMLNode_List2_PushFront(GWEN_XMLNODE_LIST2 *l, GWEN_XMLNODE *p);
05371
05376 GWEN_XMLNODE *GWEN_XMLNode_List2_GetFront(GWEN_XMLNODE_LIST2 *l);
05377
05382 GWEN_XMLNODE *GWEN_XMLNode_List2_GetBack(GWEN_XMLNODE_LIST2 *l);
05383
05388 void GWEN_XMLNode_List2_Erase(GWEN_XMLNODE_LIST2 *l,
05389 GWEN_XMLNODE_LIST2_ITERATOR *it);
05390
05396 unsigned int GWEN_XMLNode_List2_GetSize(GWEN_XMLNODE_LIST2 *l);
05397
05402 void GWEN_XMLNode_List2_PopBack(GWEN_XMLNODE_LIST2 *l);
05403
05408 void GWEN_XMLNode_List2_PopFront(GWEN_XMLNODE_LIST2 *l);
05409
05413 void GWEN_XMLNode_List2_Clear(GWEN_XMLNODE_LIST2 *l);
05414
05418 GWEN_XMLNODE_LIST2_ITERATOR *GWEN_XMLNode_List2_First(GWEN_XMLNODE_LIST2 *l);
05419
05423 GWEN_XMLNODE_LIST2_ITERATOR *GWEN_XMLNode_List2_Last(GWEN_XMLNODE_LIST2 *l);
05424
05428 GWEN_XMLNODE_LIST2_ITERATOR *GWEN_XMLNode_List2Iterator_new(GWEN_XMLNODE_LIST2 *l);
05429
05433 void GWEN_XMLNode_List2Iterator_free(GWEN_XMLNODE_LIST2_ITERATOR *li);
05434
05439 GWEN_XMLNODE *GWEN_XMLNode_List2Iterator_Previous(GWEN_XMLNODE_LIST2_ITERATOR *li);
05440
05445 GWEN_XMLNODE *GWEN_XMLNode_List2Iterator_Next(GWEN_XMLNODE_LIST2_ITERATOR *li);
05446
05451 GWEN_XMLNODE *GWEN_XMLNode_List2Iterator_Data(GWEN_XMLNODE_LIST2_ITERATOR *li);
05452
05464 GWEN_XMLNODE *GWEN_XMLNode_List2_ForEach(GWEN_XMLNODE_LIST2 *list,
05465 GWEN_XMLNODE_LIST2_FOREACH func,
05466 void *user_data);
05467
05468
05469 typedef struct GWEN_XMLNODE_CONSTLIST2 GWEN_XMLNODE_CONSTLIST2;
05470 typedef struct GWEN_XMLNODE_CONSTLIST2_ITERATOR GWEN_XMLNODE_CONSTLIST2_ITERATOR;
05471 typedef const GWEN_XMLNODE*
05472 (GWEN_XMLNODE_CONSTLIST2_FOREACH)(const GWEN_XMLNODE *element,
05473 void *user_data);
05474
05475
05476 GWEN_XMLNODE_CONSTLIST2 *GWEN_XMLNode_ConstList2_new();
05477
05478 void GWEN_XMLNode_ConstList2_free(GWEN_XMLNODE_CONSTLIST2 *l);
05479
05480 void GWEN_XMLNode_ConstList2_PushBack(GWEN_XMLNODE_CONSTLIST2 *l, const GWEN_XMLNODE *p);
05481
05482 void GWEN_XMLNode_ConstList2_PushFront(GWEN_XMLNODE_CONSTLIST2 *l, const GWEN_XMLNODE *p);
05483
05484 const GWEN_XMLNODE *GWEN_XMLNode_ConstList2_GetFront(GWEN_XMLNODE_CONSTLIST2 *l);
05485
05486 const GWEN_XMLNODE *GWEN_XMLNode_ConstList2_GetBack(GWEN_XMLNODE_CONSTLIST2 *l);
05487
05488 unsigned int GWEN_XMLNode_ConstList2_GetSize(GWEN_XMLNODE_CONSTLIST2 *l);
05489
05490 void GWEN_XMLNode_ConstList2_PopBack(GWEN_XMLNODE_CONSTLIST2 *l);
05491
05492 void GWEN_XMLNode_ConstList2_PopFront(GWEN_XMLNODE_CONSTLIST2 *l);
05493
05494 void GWEN_XMLNode_ConstList2_Clear(GWEN_XMLNODE_CONSTLIST2 *l);
05495
05496 GWEN_XMLNODE_CONSTLIST2_ITERATOR *GWEN_XMLNode_ConstList2_First(GWEN_XMLNODE_CONSTLIST2 *l);
05497
05498 GWEN_XMLNODE_CONSTLIST2_ITERATOR *GWEN_XMLNode_ConstList2_Last(GWEN_XMLNODE_CONSTLIST2 *l);
05499
05500 GWEN_XMLNODE_CONSTLIST2_ITERATOR *GWEN_XMLNode_ConstList2Iterator_new(GWEN_XMLNODE_CONSTLIST2 *l);
05501
05502 void GWEN_XMLNode_ConstList2Iterator_free(GWEN_XMLNODE_CONSTLIST2_ITERATOR *li);
05503
05504 const GWEN_XMLNODE *GWEN_XMLNode_ConstList2Iterator_Previous(GWEN_XMLNODE_CONSTLIST2_ITERATOR *li);
05505
05506 const GWEN_XMLNODE *GWEN_XMLNode_ConstList2Iterator_Next(GWEN_XMLNODE_CONSTLIST2_ITERATOR *li);
05507
05508 const GWEN_XMLNODE *GWEN_XMLNode_ConstList2Iterator_Data(GWEN_XMLNODE_CONSTLIST2_ITERATOR *li);
05509
05521 const GWEN_XMLNODE *GWEN_XMLNode_ConstList2_ForEach(GWEN_XMLNODE_CONSTLIST2 *list,
05522 GWEN_XMLNODE_CONSTLIST2_FOREACH func, void *user_data);
05523
05524
05525 #ifdef __cplusplus
05526 }
05527 #endif
05528
05529
05530 #endif
05531
05532
05533
05534
05535
05536
05537
05538
05539
05540
05541
05542
05543
05544
05545
05546
05547
05548
05549
05550
05551
05552
05553
05554
05555
05556
05557
05558
05559
05560
05561
05562 #ifndef GWEN_EVENT_LIST1_H
05563 #define GWEN_EVENT_LIST1_H
05564
05565 #ifdef __cplusplus
05566 extern "C" {
05567 #endif
05568
05570 typedef struct GWEN_EVENT_LIST_ELEMENT {
05571 GWEN_TYPE_UINT32 id;
05572 GWEN_EVENT *nextObject;
05573 } GWEN_EVENT_LIST__ELEMENT;
05574
05581 typedef struct GWEN_EVENT_LIST GWEN_EVENT_LIST;
05583 struct GWEN_EVENT_LIST {
05584 GWEN_EVENT *first;
05585 GWEN_TYPE_UINT32 count;
05586 GWEN_TYPE_UINT32 id;
05587 } GWEN_EVENT_LIST;
05588
05593 void GWEN_Event_List_AddList(GWEN_EVENT_LIST *dst, GWEN_EVENT_LIST *l);
05594
05598 void GWEN_Event_List_Add(GWEN_EVENT *element, GWEN_EVENT_LIST *list);
05599
05604 void GWEN_Event_List_Insert(GWEN_EVENT *element, GWEN_EVENT_LIST *list);
05605
05612 void GWEN_Event_List_Del(GWEN_EVENT *element);
05613
05617 GWEN_EVENT* GWEN_Event_List_First(const GWEN_EVENT_LIST *l);
05618
05622 GWEN_EVENT* GWEN_Event_List_Last(const GWEN_EVENT_LIST *l);
05623
05628 void GWEN_Event_List_Clear(GWEN_EVENT_LIST *l);
05629
05633 GWEN_EVENT_LIST* GWEN_Event_List_new();
05634
05638 void GWEN_Event_List_free(GWEN_EVENT_LIST *l);
05639
05643 GWEN_EVENT* GWEN_Event_List_Next(const GWEN_EVENT *element);
05644
05648 GWEN_EVENT* GWEN_Event_List_Previous(const GWEN_EVENT *element);
05649
05653 GWEN_TYPE_UINT32 GWEN_Event_List_GetCount(const GWEN_EVENT_LIST *l);
05654
05655 #ifdef __cplusplus
05656 }
05657 #endif
05658
05659
05660 #endif
05661
05662
05663
05664
05665
05666
05667
05668
05669
05670
05671
05672
05673
05674
05675
05676
05677
05678
05679
05680
05681
05682
05683
05684
05685
05686
05687
05688
05689
05690
05691
05692 #ifndef GWEN_TABLE_COLUMN_LIST1_H
05693 #define GWEN_TABLE_COLUMN_LIST1_H
05694
05695 #ifdef __cplusplus
05696 extern "C" {
05697 #endif
05698
05700 typedef struct GWEN_TABLE_COLUMN_LIST_ELEMENT {
05701 GWEN_TYPE_UINT32 id;
05702 GWEN_TABLE_COLUMN *nextObject;
05703 } GWEN_TABLE_COLUMN_LIST__ELEMENT;
05704
05711 typedef struct GWEN_TABLE_COLUMN_LIST GWEN_TABLE_COLUMN_LIST;
05713 struct GWEN_TABLE_COLUMN_LIST {
05714 GWEN_TABLE_COLUMN *first;
05715 GWEN_TYPE_UINT32 count;
05716 GWEN_TYPE_UINT32 id;
05717 } GWEN_TABLE_COLUMN_LIST;
05718
05723 void GWEN_TableColumn_List_AddList(GWEN_TABLE_COLUMN_LIST *dst, GWEN_TABLE_COLUMN_LIST *l);
05724
05728 void GWEN_TableColumn_List_Add(GWEN_TABLE_COLUMN *element, GWEN_TABLE_COLUMN_LIST *list);
05729
05734 void GWEN_TableColumn_List_Insert(GWEN_TABLE_COLUMN *element, GWEN_TABLE_COLUMN_LIST *list);
05735
05742 void GWEN_TableColumn_List_Del(GWEN_TABLE_COLUMN *element);
05743
05747 GWEN_TABLE_COLUMN* GWEN_TableColumn_List_First(const GWEN_TABLE_COLUMN_LIST *l);
05748
05752 GWEN_TABLE_COLUMN* GWEN_TableColumn_List_Last(const GWEN_TABLE_COLUMN_LIST *l);
05753
05758 void GWEN_TableColumn_List_Clear(GWEN_TABLE_COLUMN_LIST *l);
05759
05763 GWEN_TABLE_COLUMN_LIST* GWEN_TableColumn_List_new();
05764
05768 void GWEN_TableColumn_List_free(GWEN_TABLE_COLUMN_LIST *l);
05769
05773 GWEN_TABLE_COLUMN* GWEN_TableColumn_List_Next(const GWEN_TABLE_COLUMN *element);
05774
05778 GWEN_TABLE_COLUMN* GWEN_TableColumn_List_Previous(const GWEN_TABLE_COLUMN *element);
05779
05783 GWEN_TYPE_UINT32 GWEN_TableColumn_List_GetCount(const GWEN_TABLE_COLUMN_LIST *l);
05784
05785 #ifdef __cplusplus
05786 }
05787 #endif
05788
05789
05790 #endif
05791
05792
05793
05794
05795
05796
05797
05798
05799
05800
05801
05802
05803
05804
05805
05806
05807
05808
05809
05810
05811
05812
05813
05814
05815
05816
05817
05818
05819
05820
05821
05822 #ifndef GWEN_TABLE_FIELD_LIST1_H
05823 #define GWEN_TABLE_FIELD_LIST1_H
05824
05825 #ifdef __cplusplus
05826 extern "C" {
05827 #endif
05828
05830 typedef struct GWEN_TABLE_FIELD_LIST_ELEMENT {
05831 GWEN_TYPE_UINT32 id;
05832 GWEN_TABLE_FIELD *nextObject;
05833 } GWEN_TABLE_FIELD_LIST__ELEMENT;
05834
05841 typedef struct GWEN_TABLE_FIELD_LIST GWEN_TABLE_FIELD_LIST;
05843 struct GWEN_TABLE_FIELD_LIST {
05844 GWEN_TABLE_FIELD *first;
05845 GWEN_TYPE_UINT32 count;
05846 GWEN_TYPE_UINT32 id;
05847 } GWEN_TABLE_FIELD_LIST;
05848
05853 void GWEN_TableField_List_AddList(GWEN_TABLE_FIELD_LIST *dst, GWEN_TABLE_FIELD_LIST *l);
05854
05858 void GWEN_TableField_List_Add(GWEN_TABLE_FIELD *element, GWEN_TABLE_FIELD_LIST *list);
05859
05864 void GWEN_TableField_List_Insert(GWEN_TABLE_FIELD *element, GWEN_TABLE_FIELD_LIST *list);
05865
05872 void GWEN_TableField_List_Del(GWEN_TABLE_FIELD *element);
05873
05877 GWEN_TABLE_FIELD* GWEN_TableField_List_First(const GWEN_TABLE_FIELD_LIST *l);
05878
05882 GWEN_TABLE_FIELD* GWEN_TableField_List_Last(const GWEN_TABLE_FIELD_LIST *l);
05883
05888 void GWEN_TableField_List_Clear(GWEN_TABLE_FIELD_LIST *l);
05889
05893 GWEN_TABLE_FIELD_LIST* GWEN_TableField_List_new();
05894
05898 void GWEN_TableField_List_free(GWEN_TABLE_FIELD_LIST *l);
05899
05903 GWEN_TABLE_FIELD* GWEN_TableField_List_Next(const GWEN_TABLE_FIELD *element);
05904
05908 GWEN_TABLE_FIELD* GWEN_TableField_List_Previous(const GWEN_TABLE_FIELD *element);
05909
05913 GWEN_TYPE_UINT32 GWEN_TableField_List_GetCount(const GWEN_TABLE_FIELD_LIST *l);
05914
05915 #ifdef __cplusplus
05916 }
05917 #endif
05918
05919
05920 #endif
05921
05922
05923
05924
05925
05926
05927
05928
05929
05930
05931
05932
05933
05934
05935
05936
05937
05938
05939
05940
05941
05942
05943
05944
05945
05946
05947
05948
05949
05950
05951
05952 #ifndef GWEN_TW_LINE_LIST1_H
05953 #define GWEN_TW_LINE_LIST1_H
05954
05955 #ifdef __cplusplus
05956 extern "C" {
05957 #endif
05958
05960 typedef struct GWEN_TW_LINE_LIST_ELEMENT {
05961 GWEN_TYPE_UINT32 id;
05962 GWEN_TW_LINE *nextObject;
05963 } GWEN_TW_LINE_LIST__ELEMENT;
05964
05971 typedef struct GWEN_TW_LINE_LIST GWEN_TW_LINE_LIST;
05973 struct GWEN_TW_LINE_LIST {
05974 GWEN_TW_LINE *first;
05975 GWEN_TYPE_UINT32 count;
05976 GWEN_TYPE_UINT32 id;
05977 } GWEN_TW_LINE_LIST;
05978
05983 void GWEN_TWLine_List_AddList(GWEN_TW_LINE_LIST *dst, GWEN_TW_LINE_LIST *l);
05984
05988 void GWEN_TWLine_List_Add(GWEN_TW_LINE *element, GWEN_TW_LINE_LIST *list);
05989
05994 void GWEN_TWLine_List_Insert(GWEN_TW_LINE *element, GWEN_TW_LINE_LIST *list);
05995
06002 void GWEN_TWLine_List_Del(GWEN_TW_LINE *element);
06003
06007 GWEN_TW_LINE* GWEN_TWLine_List_First(const GWEN_TW_LINE_LIST *l);
06008
06012 GWEN_TW_LINE* GWEN_TWLine_List_Last(const GWEN_TW_LINE_LIST *l);
06013
06018 void GWEN_TWLine_List_Clear(GWEN_TW_LINE_LIST *l);
06019
06023 GWEN_TW_LINE_LIST* GWEN_TWLine_List_new();
06024
06028 void GWEN_TWLine_List_free(GWEN_TW_LINE_LIST *l);
06029
06033 GWEN_TW_LINE* GWEN_TWLine_List_Next(const GWEN_TW_LINE *element);
06034
06038 GWEN_TW_LINE* GWEN_TWLine_List_Previous(const GWEN_TW_LINE *element);
06039
06043 GWEN_TYPE_UINT32 GWEN_TWLine_List_GetCount(const GWEN_TW_LINE_LIST *l);
06044
06045 #ifdef __cplusplus
06046 }
06047 #endif
06048
06049
06050 #endif
06051
06052
06053
06054
06055
06056
06057
06058
06059
06060
06061
06062
06063
06064
06065
06066
06067
06068
06069
06070
06071
06072
06073
06074
06075
06076
06077
06078
06079
06080
06081
06082 #ifndef GWEN_WIDGET_LIST1_H
06083 #define GWEN_WIDGET_LIST1_H
06084
06085 #ifdef __cplusplus
06086 extern "C" {
06087 #endif
06088
06090 typedef struct GWEN_WIDGET_LIST_ELEMENT {
06091 GWEN_TYPE_UINT32 id;
06092 GWEN_WIDGET *nextObject;
06093 } GWEN_WIDGET_LIST__ELEMENT;
06094
06101 typedef struct GWEN_WIDGET_LIST GWEN_WIDGET_LIST;
06103 struct GWEN_WIDGET_LIST {
06104 GWEN_WIDGET *first;
06105 GWEN_TYPE_UINT32 count;
06106 GWEN_TYPE_UINT32 id;
06107 } GWEN_WIDGET_LIST;
06108
06113 void GWEN_Widget_List_AddList(GWEN_WIDGET_LIST *dst, GWEN_WIDGET_LIST *l);
06114
06118 void GWEN_Widget_List_Add(GWEN_WIDGET *element, GWEN_WIDGET_LIST *list);
06119
06124 void GWEN_Widget_List_Insert(GWEN_WIDGET *element, GWEN_WIDGET_LIST *list);
06125
06132 void GWEN_Widget_List_Del(GWEN_WIDGET *element);
06133
06137 GWEN_WIDGET* GWEN_Widget_List_First(const GWEN_WIDGET_LIST *l);
06138
06142 GWEN_WIDGET* GWEN_Widget_List_Last(const GWEN_WIDGET_LIST *l);
06143
06148 void GWEN_Widget_List_Clear(GWEN_WIDGET_LIST *l);
06149
06153 GWEN_WIDGET_LIST* GWEN_Widget_List_new();
06154
06158 void GWEN_Widget_List_free(GWEN_WIDGET_LIST *l);
06159
06163 GWEN_WIDGET* GWEN_Widget_List_Next(const GWEN_WIDGET *element);
06164
06168 GWEN_WIDGET* GWEN_Widget_List_Previous(const GWEN_WIDGET *element);
06169
06173 GWEN_TYPE_UINT32 GWEN_Widget_List_GetCount(const GWEN_WIDGET_LIST *l);
06174
06175 #ifdef __cplusplus
06176 }
06177 #endif
06178
06179
06180 #endif
06181
06182
06183