ucx: ucx/list.c@3192553c0df1

     1 #include "list.h"

     3 UcxList *ucx_list_clone(UcxList *l, copy_func fnc, void *data) {

     4     UcxList *ret = NULL;

     5     while (l != NULL) {

     6         if (fnc != NULL) {

     7             ret = ucx_list_append(ret, fnc(l->data, data));

     8         } else {

     9             ret = ucx_list_append(ret, l->data);

    10         }

    11         l = l->next;

    12     }

    13     return ret;

    14 }

    16 int ucx_list_equals(UcxList *l1, UcxList *l2, cmp_func fnc, void* data) {

    17     if (l1 == l2) return 1;

    19     while (l1 != NULL && l2 != NULL) {

    20         if (fnc == NULL) {

    21             if (l1->data != l2->data) return 0;

    22         } else {

    23             if (fnc(l1->data, l2->data, data) != 0) return 0;

    24         }

    25         l1 = l1->next;

    26         l2 = l2->next;

    27     }

    29     return (l1 == NULL && l2 == NULL);

    30 }

    32 void ucx_list_free(UcxList *l) {

    33     UcxList *e = l, *f;

    34     while (e != NULL) {

    35         f = e;

    36         e = e->next;

    37         free(f);

    38     }

    39 }

    41 UcxList *ucx_list_append(UcxList *l, void *data)  {

    42     UcxList *nl = (UcxList*) malloc(sizeof(UcxList));

    43     if (nl == NULL) return NULL;

    45     nl->data = data;

    46     nl->next = NULL;

    47     if (l == NULL) {

    48         return nl;

    49     } else {

    50         UcxList *t = ucx_list_last(l);

    51         t->next = nl;

    52         return l;

    53     }

    54 }

    56 UcxList *ucx_list_prepend(UcxList *l, void *data) {

    57     UcxList *nl = ucx_list_append(NULL, data);

    58     if (nl == NULL) return NULL;

    60     if (l != NULL) {

    61         nl->next = l;

    62     }

    63     return nl;

    64 }

    66 UcxList *ucx_list_concat(UcxList *l1, UcxList *l2) {

    67     if (l1 == NULL) {

    68         return l2;

    69     } else {

    70         UcxList *last = ucx_list_last(l1);

    71         last->next = l2;

    72         return l1;

    73     }

    74 }

    76 UcxList *ucx_list_last(UcxList *l) {

    77     if (l == NULL) return NULL;

    79     UcxList *e = l;

    80     while (e->next != NULL) {

    81         e = e->next;

    82     }

    83     return e;

    84 }

    86 UcxList *ucx_list_get(UcxList *l, int index) {

    87     if (l == NULL) return NULL;

    89     UcxList *e = l;

    90     while (e->next != NULL && index > 0) {

    91         e = e->next;

    92         index--;

    93     }

    95     return index == 0 ? e : NULL;

    96 }

    98 size_t ucx_list_size(UcxList *l) {

    99     if (l == NULL) return 0;

   101     UcxList *e = l;

   102     size_t s = 1;

   103     while (e->next != NULL) {

   104         e = e->next;

   105         s++;

   106     }

   108     return s;

   109 }

   111 void ucx_list_foreach(UcxList *l, ucx_callback fnc, void* data) {

   112     UcxList *e = l;

   113     UcxList *n;

   114     while (e != NULL) {

   115         n = e->next;

   116         fnc(e, data);

   117         e = n;

   118     }

   119 }

   121 /* list specific functions */

   122 UcxList *ucx_list_remove(UcxList *l, UcxList *e) {

   123     if (e == l) {

   124         l = e->next;

   125         free(e);

   126     } else {

   127         UcxList *f = l;

   128         while (f->next != NULL && f->next != e) {

   129             f = f->next;

   130         }

   131         /* perform remove iff this element is found in this list */

   132         if (f->next == e) {

   133             f->next = e->next;

   134             free(e);

   135         }

   136     }

   137     return l;

   138 }

Mercurial > hg > ucx / file revision