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 #ifdef HAVE_CONFIG_H
00027 # include <config.h>
00028 #endif
00029
00030 #define DISABLE_DEBUGLOG
00031
00032
00033 #include "list_p.h"
00034 #include <gwenhywfar/misc.h>
00035 #include <gwenhywfar/debug.h>
00036
00037
00038 GWEN_INHERIT_FUNCTIONS(GWEN_LIST)
00039
00040
00041
00042 GWEN_LIST_ENTRY *GWEN_ListEntry_new(void){
00043 GWEN_LIST_ENTRY *le;
00044
00045 GWEN_NEW_OBJECT(GWEN_LIST_ENTRY, le);
00046 le->usage=1;
00047 return le;
00048 }
00049
00050
00051
00052 void GWEN_ListEntry_free(GWEN_LIST_ENTRY *le){
00053 if (le) {
00054 if (le->usage) {
00055 le->usage--;
00056 if (le->usage==0) {
00057
00058 le->previous=0;
00059 le->next=0;
00060 DBG_VERBOUS(GWEN_LOGDOMAIN, "Freeing entry");
00061 GWEN_RefPtr_free(le->dataPtr);
00062
00063 GWEN_FREE_OBJECT(le);
00064 }
00065 }
00066 }
00067 }
00068
00069
00070
00071 GWEN__LISTPTR *GWEN__ListPtr_new(void){
00072 GWEN__LISTPTR *lp;
00073
00074 GWEN_NEW_OBJECT(GWEN__LISTPTR, lp);
00075 lp->refCount=1;
00076 return lp;
00077 }
00078
00079
00080
00081 void GWEN__ListPtr_free(GWEN__LISTPTR *lp){
00082 if (lp) {
00083 assert(lp->refCount);
00084 if (--(lp->refCount)==0) {
00085 GWEN__ListPtr_Clear(lp);
00086 GWEN_FREE_OBJECT(lp);
00087 }
00088 }
00089 }
00090
00091
00092
00093 void GWEN__ListPtr_Attach(GWEN__LISTPTR *lp){
00094 assert(lp);
00095 assert(lp->refCount);
00096 lp->refCount++;
00097 }
00098
00099
00100
00101 void GWEN__ListPtr_Clear(GWEN__LISTPTR *lp){
00102 GWEN_LIST_ENTRY *le;
00103
00104 assert(lp);
00105 le=lp->first;
00106 while(le) {
00107 GWEN_LIST_ENTRY *nle;
00108
00109 nle=le->next;
00110 GWEN_ListEntry_free(le);
00111 le=nle;
00112 }
00113 lp->first=0;
00114 lp->last=0;
00115 lp->size=0;
00116 }
00117
00118
00119
00120 GWEN__LISTPTR *GWEN__ListPtr_dup(GWEN__LISTPTR *lp){
00121 GWEN__LISTPTR *nlp;
00122 GWEN_LIST_ENTRY *le;
00123
00124 nlp=GWEN__ListPtr_new();
00125 assert(lp);
00126 le=lp->first;
00127 while(le) {
00128 GWEN_LIST_ENTRY *nle;
00129
00130 nle=GWEN_ListEntry_new();
00131 if (le->dataPtr)
00132 nle->dataPtr=GWEN_RefPtr_dup(le->dataPtr);
00133
00134 nle->previous=nlp->last;
00135 if (nlp->last)
00136 nlp->last->next=nle;
00137 nlp->last=nle;
00138 if (!(nlp->first))
00139 nlp->first=nle;
00140 nlp->size++;
00141 nle->linkCount=le->linkCount;
00142
00143 le=le->next;
00144 }
00145
00146 return nlp;
00147 }
00148
00149
00150
00151
00152
00153
00154
00155
00156 GWEN_LIST *GWEN_List_new(void){
00157 GWEN_LIST *l;
00158
00159 GWEN_NEW_OBJECT(GWEN_LIST, l);
00160 GWEN_INHERIT_INIT(GWEN_LIST, l);
00161 l->listPtr=GWEN__ListPtr_new();
00162 return l;
00163 }
00164
00165
00166
00167 void GWEN_List_free(GWEN_LIST *l){
00168 if (l) {
00169 GWEN_INHERIT_FINI(GWEN_LIST, l);
00170 GWEN__ListPtr_free(l->listPtr);
00171 GWEN_RefPtrInfo_free(l->refPtrInfo);
00172 GWEN_FREE_OBJECT(l);
00173 }
00174 }
00175
00176
00177
00178 GWEN_LIST *GWEN_List_dup(const GWEN_LIST *l){
00179 GWEN_LIST *nl;
00180
00181 assert(l);
00182 assert(l->listPtr);
00183 GWEN_NEW_OBJECT(GWEN_LIST, nl);
00184 GWEN_INHERIT_INIT(GWEN_LIST, nl);
00185 nl->listPtr=l->listPtr;
00186 GWEN__ListPtr_Attach(nl->listPtr);
00187 return nl;
00188 }
00189
00190
00191
00192 GWEN_REFPTR_INFO *GWEN_List_GetRefPtrInfo(const GWEN_LIST *l){
00193 assert(l);
00194 return l->refPtrInfo;
00195 }
00196
00197
00198
00199 void GWEN_List_SetRefPtrInfo(GWEN_LIST *l, GWEN_REFPTR_INFO *rpi){
00200 assert(l);
00201 if (rpi)
00202 GWEN_RefPtrInfo_Attach(rpi);
00203 GWEN_RefPtrInfo_free(l->refPtrInfo);
00204 l->refPtrInfo=rpi;
00205 }
00206
00207
00208
00209 void GWEN_List_PushBackRefPtr(GWEN_LIST *l, GWEN_REFPTR *rp){
00210 GWEN_LIST_ENTRY *le;
00211 GWEN__LISTPTR *lp;
00212
00213 if (l->listPtr->refCount>1) {
00214 GWEN__LISTPTR *nlp;
00215
00216
00217 nlp=GWEN__ListPtr_dup(l->listPtr);
00218 GWEN__ListPtr_free(l->listPtr);
00219 l->listPtr=nlp;
00220 }
00221 lp=l->listPtr;
00222
00223 le=GWEN_ListEntry_new();
00224 le->dataPtr=rp;
00225 le->previous=lp->last;
00226 if (lp->last)
00227 lp->last->next=le;
00228 lp->last=le;
00229 if (!(lp->first))
00230 lp->first=le;
00231 lp->size++;
00232 le->linkCount=1;
00233 }
00234
00235
00236
00237 void GWEN_List_PushBack(GWEN_LIST *l, void *p){
00238 GWEN_List_PushBackRefPtr(l, GWEN_RefPtr_new(p, l->refPtrInfo));
00239 }
00240
00241
00242
00243 void GWEN_List_PushFrontRefPtr(GWEN_LIST *l, GWEN_REFPTR *rp){
00244 GWEN_LIST_ENTRY *le;
00245 GWEN__LISTPTR *lp;
00246
00247 if (l->listPtr->refCount>1) {
00248 GWEN__LISTPTR *nlp;
00249
00250
00251 nlp=GWEN__ListPtr_dup(l->listPtr);
00252 GWEN__ListPtr_free(l->listPtr);
00253 l->listPtr=nlp;
00254 }
00255 lp=l->listPtr;
00256
00257 le=GWEN_ListEntry_new();
00258 le->dataPtr=rp;
00259 le->next=lp->first;
00260 if (lp->first)
00261 lp->first->previous=le;
00262 lp->first=le;
00263 if (!(lp->last))
00264 lp->last=le;
00265 lp->size++;
00266 le->linkCount=1;
00267 }
00268
00269
00270
00271 void GWEN_List_PushFront(GWEN_LIST *l, void *p){
00272 GWEN_List_PushFrontRefPtr(l, GWEN_RefPtr_new(p, l->refPtrInfo));
00273 }
00274
00275
00276
00277 void *GWEN_List_GetFront(const GWEN_LIST *l){
00278 assert(l);
00279 assert(l->listPtr);
00280 if (l->listPtr->first)
00281 return GWEN_RefPtr_GetData(l->listPtr->first->dataPtr);
00282 return 0;
00283 }
00284
00285
00286
00287 GWEN_REFPTR *GWEN_List_GetFrontRefPtr(const GWEN_LIST *l){
00288 assert(l);
00289 assert(l->listPtr);
00290 if (l->listPtr->first)
00291 return l->listPtr->first->dataPtr;
00292 return 0;
00293 }
00294
00295
00296
00297 void *GWEN_List_GetBack(const GWEN_LIST *l){
00298 assert(l);
00299 assert(l->listPtr);
00300 if (l->listPtr->last)
00301 return GWEN_RefPtr_GetData(l->listPtr->last->dataPtr);
00302 return 0;
00303 }
00304
00305
00306
00307 GWEN_REFPTR *GWEN_List_GetBackRefPtr(const GWEN_LIST *l){
00308 assert(l);
00309 assert(l->listPtr);
00310 if (l->listPtr->last)
00311 return l->listPtr->last->dataPtr;
00312 return 0;
00313 }
00314
00315
00316
00317 unsigned int GWEN_List_GetSize(const GWEN_LIST *l){
00318 assert(l);
00319 assert(l->listPtr);
00320 return l->listPtr->size;
00321 }
00322
00323 int GWEN_List_IsEmpty(const GWEN_LIST *l) {
00324 return GWEN_List_GetSize(l) == 0;
00325 }
00326
00327
00328 void GWEN_List_PopBack(GWEN_LIST *l){
00329 GWEN_LIST_ENTRY *le;
00330 GWEN__LISTPTR *lp;
00331
00332 assert(l);
00333 assert(l->listPtr);
00334 if (l->listPtr->last==0)
00335 return;
00336 if (l->listPtr->refCount>1) {
00337 GWEN__LISTPTR *nlp;
00338
00339
00340 nlp=GWEN__ListPtr_dup(l->listPtr);
00341 GWEN__ListPtr_free(l->listPtr);
00342 l->listPtr=nlp;
00343 }
00344 lp=l->listPtr;
00345
00346 le=lp->last;
00347 if (le) {
00348 le->linkCount=0;
00349 lp->last=le->previous;
00350 if (le->previous) {
00351 le->previous->next=0;
00352 }
00353 else {
00354 lp->last=0;
00355 lp->first=0;
00356 }
00357 GWEN_ListEntry_free(le);
00358 lp->size--;
00359 }
00360 }
00361
00362
00363
00364 void GWEN_List_PopFront(GWEN_LIST *l){
00365 GWEN_LIST_ENTRY *le;
00366 GWEN__LISTPTR *lp;
00367
00368 assert(l);
00369 assert(l->listPtr);
00370 if (l->listPtr->first==0)
00371 return;
00372 if (l->listPtr->refCount>1) {
00373 GWEN__LISTPTR *nlp;
00374
00375
00376 nlp=GWEN__ListPtr_dup(l->listPtr);
00377 GWEN__ListPtr_free(l->listPtr);
00378 l->listPtr=nlp;
00379 }
00380 lp=l->listPtr;
00381
00382 le=lp->first;
00383 if (le) {
00384 le->linkCount=0;
00385 lp->first=le->next;
00386 if (le->next) {
00387 le->next->previous=0;
00388 }
00389 else {
00390 lp->first=0;
00391 lp->last=0;
00392 }
00393 GWEN_ListEntry_free(le);
00394 lp->size--;
00395 }
00396 }
00397
00398
00399
00400 void GWEN_List_Clear(GWEN_LIST *l){
00401
00402
00403 assert(l);
00404 if (l->listPtr->refCount>1) {
00405 GWEN__LISTPTR *nlp;
00406
00407
00408 nlp=GWEN__ListPtr_dup(l->listPtr);
00409 GWEN__ListPtr_free(l->listPtr);
00410 l->listPtr=nlp;
00411 }
00412 else
00413 GWEN__ListPtr_Clear(l->listPtr);
00414 }
00415
00416
00417
00418 void *GWEN_List_ForEach(GWEN_LIST *l,
00419 GWEN_LIST_FOREACH_CB fn, void *user_data){
00420 GWEN_LIST_ITERATOR *it;
00421 void *el;
00422 assert(l);
00423
00424 it=GWEN_List_First(l);
00425 if (!it)
00426 return 0;
00427 el=GWEN_ListIterator_Data(it);
00428 while(el) {
00429 el=fn(el, user_data);
00430 if (el) {
00431 GWEN_ListIterator_free(it);
00432 return el;
00433 }
00434 el=GWEN_ListIterator_Next(it);
00435 }
00436 GWEN_ListIterator_free(it);
00437 return 0;
00438 }
00439
00440
00441
00442 void GWEN_List_Unshare(GWEN_LIST *l) {
00443 if (l->listPtr->refCount>1) {
00444 GWEN__LISTPTR *nlp;
00445
00446
00447 nlp=GWEN__ListPtr_dup(l->listPtr);
00448 GWEN__ListPtr_free(l->listPtr);
00449 l->listPtr=nlp;
00450 }
00451 }
00452
00453
00454
00455 void GWEN_List_Erase(GWEN_LIST *l, GWEN_LIST_ITERATOR *it){
00456 GWEN_LIST_ENTRY *current;
00457 GWEN__LISTPTR *lp;
00458
00459 assert(l);
00460 assert(l->listPtr);
00461 if (l->listPtr->refCount>1) {
00462 GWEN_LIST_ENTRY *tle;
00463 GWEN__LISTPTR *nlp;
00464 int i;
00465
00466
00467 tle=it->current;
00468 assert(tle);
00469 i=0;
00470 while(tle->previous) {
00471 i++;
00472 tle=tle->previous;
00473 }
00474
00475
00476 nlp=GWEN__ListPtr_dup(l->listPtr);
00477 GWEN__ListPtr_free(l->listPtr);
00478 l->listPtr=nlp;
00479
00480
00481 tle=l->listPtr->first;
00482 assert(tle);
00483 while(tle && i--) {
00484 tle=tle->next;
00485 }
00486 assert(tle);
00487 it->current=tle;
00488 }
00489 lp=l->listPtr;
00490
00491 assert(it);
00492 if (it->current) {
00493 current=it->current;
00494 if (it->current->linkCount==1) {
00495
00496 if (lp->first==current)
00497 lp->first=current->next;
00498 if (lp->last==current)
00499 lp->last=current->previous;
00500
00501
00502 if (current->next) {
00503 it->current=current->next;
00504 current->next->usage++;
00505 current->next->previous=current->previous;
00506 }
00507 else
00508 it->current=0;
00509
00510 if (current->previous)
00511 current->previous->next=current->next;
00512
00513 current->usage--;
00514 GWEN_ListEntry_free(current);
00515 lp->size--;
00516 }
00517 else {
00518
00519
00520
00521
00522 if (current->next) {
00523 it->current=current->next;
00524 current->next->usage++;
00525 }
00526 else
00527 it->current=0;
00528 current->usage--;
00529 it->current->linkCount--;
00530 }
00531 }
00532 }
00533
00534
00535
00536 GWEN_LIST_ITERATOR *GWEN_List_FindIter(GWEN_LIST *l, const void *p) {
00537 GWEN_LIST_ITERATOR *li;
00538
00539 li=GWEN_List_First(l);
00540 if (li) {
00541 void *d;
00542
00543 d=GWEN_ListIterator_Data(li);
00544 while(d) {
00545 if (d==p) {
00546 return li;
00547 }
00548 d=GWEN_ListIterator_Next(li);
00549 }
00550 GWEN_ListIterator_free(li);
00551 }
00552 return 0;
00553 }
00554
00555
00556
00557 const void *GWEN_List_Contains(GWEN_LIST *l, const void *p) {
00558 GWEN_LIST_ITERATOR *li;
00559
00560 li = GWEN_List_FindIter(l, p);
00561 if (li) {
00562 GWEN_ListIterator_free(li);
00563 return p;
00564 }
00565 return 0;
00566 }
00567
00568
00569
00570 void GWEN_List_Remove(GWEN_LIST *l, const void *p) {
00571 GWEN_LIST_ITERATOR *li;
00572
00573 li = GWEN_List_FindIter(l, p);
00574 if (li) {
00575 GWEN_List_Erase(l, li);
00576 GWEN_ListIterator_free(li);
00577 }
00578 }
00579
00580
00581
00582 GWEN_LIST_ITERATOR *GWEN_List_First(const GWEN_LIST *l){
00583 GWEN_LIST_ITERATOR *li;
00584
00585 assert(l);
00586 assert(l->listPtr);
00587 if (l->listPtr->first==0)
00588 return 0;
00589 li=GWEN_ListIterator_new(l);
00590 li->current=l->listPtr->first;
00591 if (li->current) {
00592 li->current->usage++;
00593 }
00594 return li;
00595 }
00596
00597
00598
00599 GWEN_LIST_ITERATOR *GWEN_List_Last(const GWEN_LIST *l){
00600 GWEN_LIST_ITERATOR *li;
00601
00602 assert(l);
00603 assert(l->listPtr);
00604 if (l->listPtr->last==0)
00605 return 0;
00606 li=GWEN_ListIterator_new(l);
00607 li->current=l->listPtr->last;
00608 if (li->current)
00609 li->current->usage++;
00610 return li;
00611 }
00612
00613
00614
00615 void GWEN_List_Dump(const GWEN_LIST *l, FILE *f, unsigned int indent){
00616 GWEN_LIST_ENTRY *le;
00617 unsigned int i;
00618
00619 fprintf(f, "List contains %d entries\n", l->listPtr->size);
00620 le=l->listPtr->first;
00621 while(le) {
00622 for (i=0; i<indent; i++) fprintf(f, " ");
00623 fprintf(f, "List entry %p\n", (void*)le);
00624 for (i=0; i<indent; i++) fprintf(f, " ");
00625 fprintf(f, " Usage : %d\n", le->usage);
00626 for (i=0; i<indent; i++) fprintf(f, " ");
00627 fprintf(f, " Previous: %p\n", (void*)le->previous);
00628 for (i=0; i<indent; i++) fprintf(f, " ");
00629 fprintf(f, " Next : %p\n", (void*)le->next);
00630 for (i=0; i<indent; i++) fprintf(f, " ");
00631 fprintf(f, " Data : %p\n", (void*)GWEN_RefPtr_GetData(le->dataPtr));
00632 le=le->next;
00633 }
00634 }
00635
00636
00637
00638
00639 GWEN_LIST_ITERATOR *GWEN_ListIterator_new(const GWEN_LIST *l){
00640 GWEN_LIST_ITERATOR *li;
00641
00642 GWEN_NEW_OBJECT(GWEN_LIST_ITERATOR, li);
00643 li->list=l;
00644 return li;
00645 }
00646
00647
00648
00649 void GWEN_ListIterator_free(GWEN_LIST_ITERATOR *li){
00650 if (li) {
00651 if (li->current)
00652 GWEN_ListEntry_free(li->current);
00653 GWEN_FREE_OBJECT(li);
00654 }
00655 }
00656
00657
00658
00659 void *GWEN_ListIterator_Previous(GWEN_LIST_ITERATOR *li){
00660 GWEN_REFPTR *rp;
00661
00662 assert(li);
00663 rp=GWEN_ListIterator_PreviousRefPtr(li);
00664 if (!rp)
00665 return 0;
00666 return GWEN_RefPtr_GetData(rp);
00667 }
00668
00669
00670
00671 GWEN_REFPTR *GWEN_ListIterator_PreviousRefPtr(GWEN_LIST_ITERATOR *li){
00672 GWEN_LIST_ENTRY *le;
00673
00674 assert(li);
00675
00676 le=li->current;
00677 if (le)
00678 le=le->previous;
00679 if (li->current)
00680 GWEN_ListEntry_free(li->current);
00681 li->current=le;
00682 if (le) {
00683 le->usage++;
00684 return le->dataPtr;
00685 }
00686 return 0;
00687 }
00688
00689
00690
00691 void *GWEN_ListIterator_Next(GWEN_LIST_ITERATOR *li){
00692 GWEN_REFPTR *rp;
00693
00694 assert(li);
00695 rp=GWEN_ListIterator_NextRefPtr(li);
00696 if (!rp)
00697 return 0;
00698 return GWEN_RefPtr_GetData(rp);
00699 }
00700
00701
00702
00703 GWEN_REFPTR *GWEN_ListIterator_NextRefPtr(GWEN_LIST_ITERATOR *li){
00704 GWEN_LIST_ENTRY *le;
00705
00706 assert(li);
00707
00708 le=li->current;
00709 if (le)
00710 le=le->next;
00711 if (li->current)
00712 GWEN_ListEntry_free(li->current);
00713 li->current=le;
00714 if (le) {
00715 le->usage++;
00716 return le->dataPtr;
00717 }
00718 return 0;
00719 }
00720
00721
00722
00723 void *GWEN_ListIterator_Data(GWEN_LIST_ITERATOR *li){
00724 assert(li);
00725
00726 if (li->current)
00727 return GWEN_RefPtr_GetData(li->current->dataPtr);
00728 return 0;
00729 }
00730
00731
00732
00733 GWEN_REFPTR *GWEN_ListIterator_DataRefPtr(GWEN_LIST_ITERATOR *li){
00734 assert(li);
00735
00736 if (li->current)
00737 return li->current->dataPtr;
00738 return 0;
00739 }
00740
00741
00742
00743 void GWEN_ListIterator_IncLinkCount(GWEN_LIST_ITERATOR *li){
00744 assert(li);
00745
00746 if (li->current)
00747 li->current->linkCount++;
00748 }
00749
00750
00751
00752 unsigned int GWEN_ListIterator_GetLinkCount(const GWEN_LIST_ITERATOR *li){
00753 assert(li);
00754
00755 assert(li->current);
00756 return li->current->linkCount;
00757 }
00758
00759
00760
00761
00762
00763
00764
00765
00766
00767
00768
00769
00770
00771
00772
00773
00774 GWEN_CONSTLIST *GWEN_ConstList_new(void){
00775 return GWEN_List_new();
00776 }
00777
00778
00779
00780 void GWEN_ConstList_free(GWEN_CONSTLIST *l){
00781 GWEN_List_free(l);
00782 }
00783
00784
00785
00786 void GWEN_ConstList_PushBack(GWEN_CONSTLIST *l, const void *p){
00787 GWEN_List_PushBack(l, (void*)p);
00788 }
00789
00790
00791
00792 void GWEN_ConstList_PushFront(GWEN_CONSTLIST *l, const void *p){
00793 GWEN_List_PushFront(l, (void*)p);
00794 }
00795
00796
00797
00798 const void *GWEN_ConstList_GetFront(const GWEN_CONSTLIST *l){
00799 return GWEN_List_GetFront(l);
00800 }
00801
00802
00803
00804 const void *GWEN_ConstList_GetBack(const GWEN_CONSTLIST *l){
00805 return GWEN_List_GetBack(l);
00806 }
00807
00808
00809
00810 unsigned int GWEN_ConstList_GetSize(const GWEN_CONSTLIST *l){
00811 return GWEN_List_GetSize(l);
00812 }
00813
00814 int GWEN_ConstList_IsEmpty(const GWEN_LIST *l) {
00815 return GWEN_ConstList_GetSize(l) == 0;
00816 }
00817
00818
00819
00820 void GWEN_ConstList_PopBack(GWEN_CONSTLIST *l){
00821 GWEN_List_PopBack(l);
00822 }
00823
00824
00825
00826 void GWEN_ConstList_PopFront(GWEN_CONSTLIST *l){
00827 GWEN_List_PopFront(l);
00828 }
00829
00830
00831
00832 void GWEN_ConstList_Erase(GWEN_CONSTLIST *l, GWEN_CONSTLIST_ITERATOR *it){
00833 GWEN_List_Erase(l, it);
00834 }
00835
00836
00837
00838 void GWEN_ConstList_Clear(GWEN_CONSTLIST *l){
00839 GWEN_List_Clear(l);
00840 }
00841
00842
00843 const void *GWEN_ConstList_ForEach(GWEN_CONSTLIST *l,
00844 GWEN_CONSTLIST_FOREACH_CB fn,
00845 void *user_data){
00846 GWEN_LIST_ITERATOR *it;
00847 const void *el;
00848 assert(l);
00849
00850 it = GWEN_List_First(l);
00851 if (!it)
00852 return 0;
00853 el = GWEN_ListIterator_Data(it);
00854 while(el) {
00855 el = fn(el, user_data);
00856 if (el) {
00857 GWEN_ListIterator_free(it);
00858 return el;
00859 }
00860 el = GWEN_ListIterator_Next(it);
00861 }
00862 GWEN_ListIterator_free(it);
00863 return 0;
00864 }
00865
00866
00867
00868 GWEN_CONSTLIST_ITERATOR *GWEN_ConstList_FindIter(const GWEN_CONSTLIST *l, const void *p) {
00869 GWEN_CONSTLIST_ITERATOR *li;
00870
00871 li=GWEN_ConstList_First(l);
00872 if (li) {
00873 const void *d;
00874
00875 d=GWEN_ConstListIterator_Data(li);
00876 while(d) {
00877 if (d==p) {
00878 return li;
00879 }
00880 d=GWEN_ConstListIterator_Next(li);
00881 }
00882 GWEN_ConstListIterator_free(li);
00883 }
00884 return 0;
00885 }
00886
00887 const void *GWEN_ConstList_Contains(const GWEN_CONSTLIST *l, const void *p) {
00888 GWEN_CONSTLIST_ITERATOR *li;
00889
00890 li = GWEN_ConstList_FindIter(l, p);
00891 if (li) {
00892 GWEN_ConstListIterator_free(li);
00893 return p;
00894 }
00895 return 0;
00896 }
00897
00898 void GWEN_ConstList_Remove(GWEN_CONSTLIST *l, const void *p) {
00899 GWEN_CONSTLIST_ITERATOR *li;
00900
00901 li = GWEN_ConstList_FindIter(l, p);
00902 if (li) {
00903 GWEN_ConstList_Erase(l, li);
00904 }
00905 }
00906
00907 GWEN_CONSTLIST_ITERATOR *GWEN_ConstList_First(const GWEN_CONSTLIST *l){
00908 return GWEN_List_First(l);
00909 }
00910
00911
00912
00913 GWEN_CONSTLIST_ITERATOR *GWEN_ConstList_Last(const GWEN_CONSTLIST *l){
00914 return GWEN_List_Last(l);
00915 }
00916
00917
00918
00919 GWEN_CONSTLIST_ITERATOR *GWEN_ConstListIterator_new(const GWEN_CONSTLIST *l){
00920 return GWEN_ListIterator_new(l);
00921 }
00922
00923
00924
00925 void GWEN_ConstListIterator_free(GWEN_CONSTLIST_ITERATOR *li){
00926 GWEN_ListIterator_free(li);
00927 }
00928
00929
00930
00931 const void *GWEN_ConstListIterator_Previous(GWEN_CONSTLIST_ITERATOR *li){
00932 return GWEN_ListIterator_Previous(li);
00933 }
00934
00935
00936
00937 const void *GWEN_ConstListIterator_Next(GWEN_CONSTLIST_ITERATOR *li){
00938 return GWEN_ListIterator_Next(li);
00939 }
00940
00941
00942
00943 const void *GWEN_ConstListIterator_Data(GWEN_CONSTLIST_ITERATOR *li){
00944 return GWEN_ListIterator_Data(li);
00945 }
00946
00947
00948
00949
00950
00951