ReactOS  0.4.14-dev-608-gd495a4f
list.h File Reference
Include dependency graph for list.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Typedefs

typedef struct _xmlLink xmlLink
 
typedef xmlLinkxmlLinkPtr
 
typedef struct _xmlList xmlList
 
typedef xmlListxmlListPtr
 
typedef void(* xmlListDeallocator) (xmlLinkPtr lk)
 
typedef int(* xmlListDataCompare) (const void *data0, const void *data1)
 
typedef int(* xmlListWalker) (const void *data, void *user)
 

Functions

XMLPUBFUN xmlListPtr XMLCALL xmlListCreate (xmlListDeallocator deallocator, xmlListDataCompare compare)
 
XMLPUBFUN void XMLCALL xmlListDelete (xmlListPtr l)
 
XMLPUBFUN void *XMLCALL xmlListSearch (xmlListPtr l, void *data)
 
XMLPUBFUN void *XMLCALL xmlListReverseSearch (xmlListPtr l, void *data)
 
XMLPUBFUN int XMLCALL xmlListInsert (xmlListPtr l, void *data)
 
XMLPUBFUN int XMLCALL xmlListAppend (xmlListPtr l, void *data)
 
XMLPUBFUN int XMLCALL xmlListRemoveFirst (xmlListPtr l, void *data)
 
XMLPUBFUN int XMLCALL xmlListRemoveLast (xmlListPtr l, void *data)
 
XMLPUBFUN int XMLCALL xmlListRemoveAll (xmlListPtr l, void *data)
 
XMLPUBFUN void XMLCALL xmlListClear (xmlListPtr l)
 
XMLPUBFUN int XMLCALL xmlListEmpty (xmlListPtr l)
 
XMLPUBFUN xmlLinkPtr XMLCALL xmlListFront (xmlListPtr l)
 
XMLPUBFUN xmlLinkPtr XMLCALL xmlListEnd (xmlListPtr l)
 
XMLPUBFUN int XMLCALL xmlListSize (xmlListPtr l)
 
XMLPUBFUN void XMLCALL xmlListPopFront (xmlListPtr l)
 
XMLPUBFUN void XMLCALL xmlListPopBack (xmlListPtr l)
 
XMLPUBFUN int XMLCALL xmlListPushFront (xmlListPtr l, void *data)
 
XMLPUBFUN int XMLCALL xmlListPushBack (xmlListPtr l, void *data)
 
XMLPUBFUN void XMLCALL xmlListReverse (xmlListPtr l)
 
XMLPUBFUN void XMLCALL xmlListSort (xmlListPtr l)
 
XMLPUBFUN void XMLCALL xmlListWalk (xmlListPtr l, xmlListWalker walker, void *user)
 
XMLPUBFUN void XMLCALL xmlListReverseWalk (xmlListPtr l, xmlListWalker walker, void *user)
 
XMLPUBFUN void XMLCALL xmlListMerge (xmlListPtr l1, xmlListPtr l2)
 
XMLPUBFUN xmlListPtr XMLCALL xmlListDup (const xmlListPtr old)
 
XMLPUBFUN int XMLCALL xmlListCopy (xmlListPtr cur, const xmlListPtr old)
 
XMLPUBFUN void *XMLCALL xmlLinkGetData (xmlLinkPtr lk)
 

Typedef Documentation

◆ xmlLink

Definition at line 20 of file list.h.

◆ xmlLinkPtr

typedef xmlLink* xmlLinkPtr

Definition at line 21 of file list.h.

◆ xmlList

Definition at line 23 of file list.h.

◆ xmlListDataCompare

typedef int(* xmlListDataCompare) (const void *data0, const void *data1)

xmlListDataCompare: @data0: the first data @data1: the second data

Callback function used to compare 2 data.

Returns 0 is equality, -1 or 1 otherwise depending on the ordering.

Definition at line 42 of file list.h.

◆ xmlListDeallocator

typedef void(* xmlListDeallocator) (xmlLinkPtr lk)

xmlListDeallocator: @lk: the data to deallocate

Callback function used to free data from a list.

Definition at line 32 of file list.h.

◆ xmlListPtr

typedef xmlList* xmlListPtr

Definition at line 24 of file list.h.

◆ xmlListWalker

typedef int(* xmlListWalker) (const void *data, void *user)

xmlListWalker: @data: the data found in the list @user: extra user provided data to the walker

Callback function used when walking a list with xmlListWalk().

Returns 0 to stop walking the list, 1 otherwise.

Definition at line 52 of file list.h.

Function Documentation

◆ xmlLinkGetData()

XMLPUBFUN void* XMLCALL xmlLinkGetData ( xmlLinkPtr  lk)

xmlLinkGetData: @lk: a link

See Returns.

Returns a pointer to the data referenced from this link

Definition at line 604 of file list.c.

605 {
606  if (lk == NULL)
607  return(NULL);
608  return lk->data;
609 }
smooth NULL
Definition: ftsmooth.c:416

Referenced by xmlFreeRef().

◆ xmlListAppend()

XMLPUBFUN int XMLCALL xmlListAppend ( xmlListPtr  l,
void data 
)

xmlListAppend: @l: a list @data: the data

Insert data in the ordered list at the end for this value

Returns 0 in case of success, 1 in case of failure

Definition at line 305 of file list.c.

306 {
307  xmlLinkPtr lkPlace, lkNew;
308 
309  if (l == NULL)
310  return(1);
311  lkPlace = xmlListHigherSearch(l, data);
312  /* Add the new link */
313  lkNew = (xmlLinkPtr) xmlMalloc(sizeof(xmlLink));
314  if (lkNew == NULL) {
316  "Cannot initialize memory for new link");
317  return (1);
318  }
319  lkNew->data = data;
320  lkNew->next = lkPlace->next;
321  (lkPlace->next)->prev = lkNew;
322  lkPlace->next = lkNew;
323  lkNew->prev = lkPlace;
324  return 0;
325 }
struct list_head * prev
Definition: list.h:16
XMLPUBVAR xmlGenericErrorFunc xmlGenericError
Definition: globals.h:346
smooth NULL
Definition: ftsmooth.c:416
r l[0]
Definition: byte_order.h:167
static xmlLinkPtr xmlListHigherSearch(xmlListPtr l, void *data)
Definition: list.c:118
xmlLink * xmlLinkPtr
Definition: list.h:21
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
XMLPUBVAR xmlMallocFunc xmlMalloc
Definition: globals.h:247
XMLPUBVAR void * xmlGenericErrorContext
Definition: globals.h:362

Referenced by xmlAddRef().

◆ xmlListClear()

XMLPUBFUN void XMLCALL xmlListClear ( xmlListPtr  l)

xmlListClear: @l: a list

Remove the all data in the list

Definition at line 422 of file list.c.

423 {
424  xmlLinkPtr lk;
425 
426  if (l == NULL)
427  return;
428  lk = l->sentinel->next;
429  while(lk != l->sentinel) {
430  xmlLinkPtr next = lk->next;
431 
432  xmlLinkDeallocator(l, lk);
433  lk = next;
434  }
435 }
static void xmlLinkDeallocator(xmlListPtr l, xmlLinkPtr lk)
Definition: list.c:59
smooth NULL
Definition: ftsmooth.c:416
r l[0]
Definition: byte_order.h:167
static unsigned __int64 next
Definition: rand_nt.c:6

Referenced by xmlListDelete(), xmlListMerge(), and xmlListSort().

◆ xmlListCopy()

XMLPUBFUN int XMLCALL xmlListCopy ( xmlListPtr  cur,
const xmlListPtr  old 
)

xmlListCopy: @cur: the new list @old: the old list

Move all the element from the old list in the new list

Returns 0 in case of success 1 in case of error

Definition at line 761 of file list.c.

762 {
763  /* Walk the old tree and insert the data into the new one */
764  xmlLinkPtr lk;
765 
766  if ((old == NULL) || (cur == NULL))
767  return(1);
768  for(lk = old->sentinel->next; lk != old->sentinel; lk = lk->next) {
769  if (0 !=xmlListInsert(cur, lk->data)) {
770  xmlListDelete(cur);
771  return (1);
772  }
773  }
774  return (0);
775 }
int xmlListInsert(xmlListPtr l, void *data)
Definition: list.c:273
smooth NULL
Definition: ftsmooth.c:416
xmlLinkPtr sentinel
Definition: list.c:40
void xmlListDelete(xmlListPtr l)
Definition: list.c:333

Referenced by xmlListDup(), and xmlListMerge().

◆ xmlListCreate()

XMLPUBFUN xmlListPtr XMLCALL xmlListCreate ( xmlListDeallocator  deallocator,
xmlListDataCompare  compare 
)

xmlListCreate: @deallocator: an optional deallocator function @compare: an optional comparison function

Create a new list

Returns the new list or NULL in case of error

Definition at line 188 of file list.c.

189 {
190  xmlListPtr l;
191  if (NULL == (l = (xmlListPtr )xmlMalloc( sizeof(xmlList)))) {
193  "Cannot initialize memory for list");
194  return (NULL);
195  }
196  /* Initialize the list to NULL */
197  memset(l, 0, sizeof(xmlList));
198 
199  /* Add the sentinel */
200  if (NULL ==(l->sentinel = (xmlLinkPtr )xmlMalloc(sizeof(xmlLink)))) {
202  "Cannot initialize memory for sentinel");
203  xmlFree(l);
204  return (NULL);
205  }
206  l->sentinel->next = l->sentinel;
207  l->sentinel->prev = l->sentinel;
208  l->sentinel->data = NULL;
209 
210  /* If there is a link deallocator, use it */
211  if (deallocator != NULL)
212  l->linkDeallocator = deallocator;
213  /* If there is a link comparator, use it */
214  if (compare != NULL)
215  l->linkCompare = compare;
216  else /* Use our own */
217  l->linkCompare = xmlLinkCompare;
218  return l;
219 }
Definition: bug.cpp:7
XMLPUBVAR xmlGenericErrorFunc xmlGenericError
Definition: globals.h:346
smooth NULL
Definition: ftsmooth.c:416
r l[0]
Definition: byte_order.h:167
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:250
Definition: list.c:38
XMLPUBVAR xmlMallocFunc xmlMalloc
Definition: globals.h:247
static int xmlLinkCompare(const void *data0, const void *data1)
Definition: list.c:79
#define compare
#define memset(x, y, z)
Definition: compat.h:39
XMLPUBVAR void * xmlGenericErrorContext
Definition: globals.h:362

Referenced by xmlAddRef(), and xmlListDup().

◆ xmlListDelete()

XMLPUBFUN void XMLCALL xmlListDelete ( xmlListPtr  l)

xmlListDelete: @l: a list

Deletes the list and its associated data

Definition at line 333 of file list.c.

334 {
335  if (l == NULL)
336  return;
337 
338  xmlListClear(l);
339  xmlFree(l->sentinel);
340  xmlFree(l);
341 }
void xmlListClear(xmlListPtr l)
Definition: list.c:422
smooth NULL
Definition: ftsmooth.c:416
r l[0]
Definition: byte_order.h:167
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:250

Referenced by xmlAddRef(), xmlFreeRefTableEntry(), xmlListCopy(), and xmlListSort().

◆ xmlListDup()

xmlListDup: @old: the list

Duplicate the list

Returns a new copy of the list or NULL in case of error

Definition at line 732 of file list.c.

733 {
734  xmlListPtr cur;
735 
736  if (old == NULL)
737  return(NULL);
738  /* Hmmm, how to best deal with allocation issues when copying
739  * lists. If there is a de-allocator, should responsibility lie with
740  * the new list or the old list. Surely not both. I'll arbitrarily
741  * set it to be the old list for the time being whilst I work out
742  * the answer
743  */
744  if (NULL ==(cur = xmlListCreate(NULL, old->linkCompare)))
745  return (NULL);
746  if (0 != xmlListCopy(cur, old))
747  return NULL;
748  return cur;
749 }
xmlListPtr xmlListCreate(xmlListDeallocator deallocator, xmlListDataCompare compare)
Definition: list.c:188
int xmlListCopy(xmlListPtr cur, const xmlListPtr old)
Definition: list.c:761
smooth NULL
Definition: ftsmooth.c:416
int(* linkCompare)(const void *, const void *)
Definition: list.c:42
Definition: list.c:38

Referenced by xmlListSort().

◆ xmlListEmpty()

XMLPUBFUN int XMLCALL xmlListEmpty ( xmlListPtr  l)

xmlListEmpty: @l: a list

Is the list empty ?

Returns 1 if the list is empty, 0 if not empty and -1 in case of error

Definition at line 446 of file list.c.

447 {
448  if (l == NULL)
449  return(-1);
450  return (l->sentinel->next == l->sentinel);
451 }
smooth NULL
Definition: ftsmooth.c:416
r l[0]
Definition: byte_order.h:167

Referenced by xmlListPopBack(), xmlListPopFront(), xmlListSort(), and xmlRemoveRef().

◆ xmlListEnd()

xmlListEnd: @l: a list

Get the last element in the list

Returns the last element in the list, or NULL

Definition at line 478 of file list.c.

479 {
480  if (l == NULL)
481  return(NULL);
482  return (l->sentinel->prev);
483 }
smooth NULL
Definition: ftsmooth.c:416
r l[0]
Definition: byte_order.h:167

◆ xmlListFront()

XMLPUBFUN xmlLinkPtr XMLCALL xmlListFront ( xmlListPtr  l)

xmlListFront: @l: a list

Get the first element in the list

Returns the first element in the list, or NULL

Definition at line 462 of file list.c.

463 {
464  if (l == NULL)
465  return(NULL);
466  return (l->sentinel->next);
467 }
smooth NULL
Definition: ftsmooth.c:416
r l[0]
Definition: byte_order.h:167

◆ xmlListInsert()

XMLPUBFUN int XMLCALL xmlListInsert ( xmlListPtr  l,
void data 
)

xmlListInsert: @l: a list @data: the data

Insert data in the ordered list at the beginning for this value

Returns 0 in case of success, 1 in case of failure

Definition at line 273 of file list.c.

274 {
275  xmlLinkPtr lkPlace, lkNew;
276 
277  if (l == NULL)
278  return(1);
279  lkPlace = xmlListLowerSearch(l, data);
280  /* Add the new link */
281  lkNew = (xmlLinkPtr) xmlMalloc(sizeof(xmlLink));
282  if (lkNew == NULL) {
284  "Cannot initialize memory for new link");
285  return (1);
286  }
287  lkNew->data = data;
288  lkPlace = lkPlace->prev;
289  lkNew->next = lkPlace->next;
290  (lkPlace->next)->prev = lkNew;
291  lkPlace->next = lkNew;
292  lkNew->prev = lkPlace;
293  return 0;
294 }
static xmlLinkPtr xmlListLowerSearch(xmlListPtr l, void *data)
Definition: list.c:98
struct list_head * prev
Definition: list.h:16
XMLPUBVAR xmlGenericErrorFunc xmlGenericError
Definition: globals.h:346
smooth NULL
Definition: ftsmooth.c:416
r l[0]
Definition: byte_order.h:167
xmlLink * xmlLinkPtr
Definition: list.h:21
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
XMLPUBVAR xmlMallocFunc xmlMalloc
Definition: globals.h:247
XMLPUBVAR void * xmlGenericErrorContext
Definition: globals.h:362

Referenced by xmlListCopy().

◆ xmlListMerge()

XMLPUBFUN void XMLCALL xmlListMerge ( xmlListPtr  l1,
xmlListPtr  l2 
)

xmlListMerge: @l1: the original list @l2: the new list

include all the elements of the second list in the first one and clear the second list

Definition at line 717 of file list.c.

718 {
719  xmlListCopy(l1, l2);
720  xmlListClear(l2);
721 }
void xmlListClear(xmlListPtr l)
Definition: list.c:422
int xmlListCopy(xmlListPtr cur, const xmlListPtr old)
Definition: list.c:761

Referenced by xmlListSort().

◆ xmlListPopBack()

XMLPUBFUN void XMLCALL xmlListPopBack ( xmlListPtr  l)

xmlListPopBack: @l: a list

Removes the last element in the list

Definition at line 526 of file list.c.

527 {
528  if(!xmlListEmpty(l))
529  xmlLinkDeallocator(l, l->sentinel->prev);
530 }
static void xmlLinkDeallocator(xmlListPtr l, xmlLinkPtr lk)
Definition: list.c:59
int xmlListEmpty(xmlListPtr l)
Definition: list.c:446
r l[0]
Definition: byte_order.h:167

◆ xmlListPopFront()

XMLPUBFUN void XMLCALL xmlListPopFront ( xmlListPtr  l)

xmlListPopFront: @l: a list

Removes the first element in the list

Definition at line 513 of file list.c.

514 {
515  if(!xmlListEmpty(l))
516  xmlLinkDeallocator(l, l->sentinel->next);
517 }
static void xmlLinkDeallocator(xmlListPtr l, xmlLinkPtr lk)
Definition: list.c:59
int xmlListEmpty(xmlListPtr l)
Definition: list.c:446
r l[0]
Definition: byte_order.h:167

◆ xmlListPushBack()

XMLPUBFUN int XMLCALL xmlListPushBack ( xmlListPtr  l,
void data 
)

xmlListPushBack: @l: a list @data: new data

add the new data at the end of the list

Returns 1 if successful, 0 otherwise

Definition at line 574 of file list.c.

575 {
576  xmlLinkPtr lkPlace, lkNew;
577 
578  if (l == NULL)
579  return(0);
580  lkPlace = l->sentinel->prev;
581  /* Add the new link */
582  if (NULL ==(lkNew = (xmlLinkPtr )xmlMalloc(sizeof(xmlLink)))) {
584  "Cannot initialize memory for new link");
585  return (0);
586  }
587  lkNew->data = data;
588  lkNew->next = lkPlace->next;
589  (lkPlace->next)->prev = lkNew;
590  lkPlace->next = lkNew;
591  lkNew->prev = lkPlace;
592  return 1;
593 }
struct list_head * prev
Definition: list.h:16
XMLPUBVAR xmlGenericErrorFunc xmlGenericError
Definition: globals.h:346
smooth NULL
Definition: ftsmooth.c:416
r l[0]
Definition: byte_order.h:167
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
XMLPUBVAR xmlMallocFunc xmlMalloc
Definition: globals.h:247
XMLPUBVAR void * xmlGenericErrorContext
Definition: globals.h:362

◆ xmlListPushFront()

XMLPUBFUN int XMLCALL xmlListPushFront ( xmlListPtr  l,
void data 
)

xmlListPushFront: @l: a list @data: new data

add the new data at the beginning of the list

Returns 1 if successful, 0 otherwise

Definition at line 542 of file list.c.

543 {
544  xmlLinkPtr lkPlace, lkNew;
545 
546  if (l == NULL)
547  return(0);
548  lkPlace = l->sentinel;
549  /* Add the new link */
550  lkNew = (xmlLinkPtr) xmlMalloc(sizeof(xmlLink));
551  if (lkNew == NULL) {
553  "Cannot initialize memory for new link");
554  return (0);
555  }
556  lkNew->data = data;
557  lkNew->next = lkPlace->next;
558  (lkPlace->next)->prev = lkNew;
559  lkPlace->next = lkNew;
560  lkNew->prev = lkPlace;
561  return 1;
562 }
struct list_head * prev
Definition: list.h:16
XMLPUBVAR xmlGenericErrorFunc xmlGenericError
Definition: globals.h:346
smooth NULL
Definition: ftsmooth.c:416
r l[0]
Definition: byte_order.h:167
xmlLink * xmlLinkPtr
Definition: list.h:21
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
XMLPUBVAR xmlMallocFunc xmlMalloc
Definition: globals.h:247
XMLPUBVAR void * xmlGenericErrorContext
Definition: globals.h:362

◆ xmlListRemoveAll()

XMLPUBFUN int XMLCALL xmlListRemoveAll ( xmlListPtr  l,
void data 
)

xmlListRemoveAll: @l: a list @data: list data

Remove the all instance associated to data in the list

Returns the number of deallocation, or 0 if not found

Definition at line 403 of file list.c.

404 {
405  int count=0;
406 
407  if (l == NULL)
408  return(0);
409 
410  while(xmlListRemoveFirst(l, data))
411  count++;
412  return count;
413 }
GLuint GLuint GLsizei count
Definition: gl.h:1545
smooth NULL
Definition: ftsmooth.c:416
r l[0]
Definition: byte_order.h:167
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
int xmlListRemoveFirst(xmlListPtr l, void *data)
Definition: list.c:353

◆ xmlListRemoveFirst()

XMLPUBFUN int XMLCALL xmlListRemoveFirst ( xmlListPtr  l,
void data 
)

xmlListRemoveFirst: @l: a list @data: list data

Remove the first instance associated to data in the list

Returns 1 if a deallocation occurred, or 0 if not found

Definition at line 353 of file list.c.

354 {
355  xmlLinkPtr lk;
356 
357  if (l == NULL)
358  return(0);
359  /*Find the first instance of this data */
360  lk = xmlListLinkSearch(l, data);
361  if (lk != NULL) {
362  xmlLinkDeallocator(l, lk);
363  return 1;
364  }
365  return 0;
366 }
static void xmlLinkDeallocator(xmlListPtr l, xmlLinkPtr lk)
Definition: list.c:59
smooth NULL
Definition: ftsmooth.c:416
r l[0]
Definition: byte_order.h:167
static xmlLinkPtr xmlListLinkSearch(xmlListPtr l, void *data)
Definition: list.c:138
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950

Referenced by xmlListRemoveAll(), and xmlWalkRemoveRef().

◆ xmlListRemoveLast()

XMLPUBFUN int XMLCALL xmlListRemoveLast ( xmlListPtr  l,
void data 
)

xmlListRemoveLast: @l: a list @data: list data

Remove the last instance associated to data in the list

Returns 1 if a deallocation occurred, or 0 if not found

Definition at line 378 of file list.c.

379 {
380  xmlLinkPtr lk;
381 
382  if (l == NULL)
383  return(0);
384  /*Find the last instance of this data */
386  if (lk != NULL) {
387  xmlLinkDeallocator(l, lk);
388  return 1;
389  }
390  return 0;
391 }
static void xmlLinkDeallocator(xmlListPtr l, xmlLinkPtr lk)
Definition: list.c:59
static xmlLinkPtr xmlListLinkReverseSearch(xmlListPtr l, void *data)
Definition: list.c:163
smooth NULL
Definition: ftsmooth.c:416
r l[0]
Definition: byte_order.h:167
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950

◆ xmlListReverse()

XMLPUBFUN void XMLCALL xmlListReverse ( xmlListPtr  l)

xmlListReverse: @l: a list

Reverse the order of the elements in the list

Definition at line 618 of file list.c.

619 {
620  xmlLinkPtr lk;
621  xmlLinkPtr lkPrev;
622 
623  if (l == NULL)
624  return;
625  lkPrev = l->sentinel;
626  for (lk = l->sentinel->next; lk != l->sentinel; lk = lk->next) {
627  lkPrev->next = lkPrev->prev;
628  lkPrev->prev = lk;
629  lkPrev = lk;
630  }
631  /* Fix up the last node */
632  lkPrev->next = lkPrev->prev;
633  lkPrev->prev = lk;
634 }
smooth NULL
Definition: ftsmooth.c:416
r l[0]
Definition: byte_order.h:167

◆ xmlListReverseSearch()

XMLPUBFUN void* XMLCALL xmlListReverseSearch ( xmlListPtr  l,
void data 
)

xmlListReverseSearch: @l: a list @data: a search value

Search the list in reverse order for an existing value of @data

Returns the value associated to @data or NULL in case of error

Definition at line 252 of file list.c.

253 {
254  xmlLinkPtr lk;
255  if (l == NULL)
256  return(NULL);
258  if (lk)
259  return (lk->data);
260  return NULL;
261 }
static xmlLinkPtr xmlListLinkReverseSearch(xmlListPtr l, void *data)
Definition: list.c:163
smooth NULL
Definition: ftsmooth.c:416
r l[0]
Definition: byte_order.h:167
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950

◆ xmlListReverseWalk()

XMLPUBFUN void XMLCALL xmlListReverseWalk ( xmlListPtr  l,
xmlListWalker  walker,
void user 
)

xmlListReverseWalk: @l: a list @walker: a processing function @user: a user parameter passed to the walker function

Walk all the element of the list in reverse order and apply the walker function to it

Definition at line 697 of file list.c.

697  {
698  xmlLinkPtr lk;
699 
700  if ((l == NULL) || (walker == NULL))
701  return;
702  for(lk = l->sentinel->prev; lk != l->sentinel; lk = lk->prev) {
703  if((walker(lk->data, user)) == 0)
704  break;
705  }
706 }
smooth NULL
Definition: ftsmooth.c:416
r l[0]
Definition: byte_order.h:167
void user(int argc, const char *argv[])
Definition: cmds.c:1350

◆ xmlListSearch()

XMLPUBFUN void* XMLCALL xmlListSearch ( xmlListPtr  l,
void data 
)

xmlListSearch: @l: a list @data: a search value

Search the list for an existing value of @data

Returns the value associated to @data or NULL in case of error

Definition at line 231 of file list.c.

232 {
233  xmlLinkPtr lk;
234  if (l == NULL)
235  return(NULL);
236  lk = xmlListLinkSearch(l, data);
237  if (lk)
238  return (lk->data);
239  return NULL;
240 }
smooth NULL
Definition: ftsmooth.c:416
r l[0]
Definition: byte_order.h:167
static xmlLinkPtr xmlListLinkSearch(xmlListPtr l, void *data)
Definition: list.c:138
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950

◆ xmlListSize()

XMLPUBFUN int XMLCALL xmlListSize ( xmlListPtr  l)

xmlListSize: @l: a list

Get the number of elements in the list

Returns the number of elements in the list or -1 in case of error

Definition at line 494 of file list.c.

495 {
496  xmlLinkPtr lk;
497  int count=0;
498 
499  if (l == NULL)
500  return(-1);
501  /* TODO: keep a counter in xmlList instead */
502  for(lk = l->sentinel->next; lk != l->sentinel; lk = lk->next, count++);
503  return count;
504 }
GLuint GLuint GLsizei count
Definition: gl.h:1545
smooth NULL
Definition: ftsmooth.c:416
r l[0]
Definition: byte_order.h:167

◆ xmlListSort()

XMLPUBFUN void XMLCALL xmlListSort ( xmlListPtr  l)

xmlListSort: @l: a list

Sort all the elements in the list

Definition at line 643 of file list.c.

644 {
645  xmlListPtr lTemp;
646 
647  if (l == NULL)
648  return;
649  if(xmlListEmpty(l))
650  return;
651 
652  /* I think that the real answer is to implement quicksort, the
653  * alternative is to implement some list copying procedure which
654  * would be based on a list copy followed by a clear followed by
655  * an insert. This is slow...
656  */
657 
658  if (NULL ==(lTemp = xmlListDup(l)))
659  return;
660  xmlListClear(l);
661  xmlListMerge(l, lTemp);
662  xmlListDelete(lTemp);
663  return;
664 }
void xmlListClear(xmlListPtr l)
Definition: list.c:422
int xmlListEmpty(xmlListPtr l)
Definition: list.c:446
smooth NULL
Definition: ftsmooth.c:416
r l[0]
Definition: byte_order.h:167
void xmlListMerge(xmlListPtr l1, xmlListPtr l2)
Definition: list.c:717
void xmlListDelete(xmlListPtr l)
Definition: list.c:333
Definition: list.c:38
xmlListPtr xmlListDup(const xmlListPtr old)
Definition: list.c:732

◆ xmlListWalk()

XMLPUBFUN void XMLCALL xmlListWalk ( xmlListPtr  l,
xmlListWalker  walker,
void user 
)

xmlListWalk: @l: a list @walker: a processing function @user: a user parameter passed to the walker function

Walk all the element of the first from first to last and apply the walker function to it

Definition at line 676 of file list.c.

676  {
677  xmlLinkPtr lk;
678 
679  if ((l == NULL) || (walker == NULL))
680  return;
681  for(lk = l->sentinel->next; lk != l->sentinel; lk = lk->next) {
682  if((walker(lk->data, user)) == 0)
683  break;
684  }
685 }
smooth NULL
Definition: ftsmooth.c:416
r l[0]
Definition: byte_order.h:167
void user(int argc, const char *argv[])
Definition: cmds.c:1350

Referenced by xmlRemoveRef().