libopkg/void_list.c

   1 /* void_list.c - the opkg package management system
   2
   3    Carl D. Worth
   4
   5    Copyright (C) 2001 University of Southern California
   6
   7    This program is free software; you can redistribute it and/or
   8    modify it under the terms of the GNU General Public License as
   9    published by the Free Software Foundation; either version 2, or (at
  10    your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful, but
  13    WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15    General Public License for more details.
  16 */
  17
  18 #include "includes.h"
  19 #include <errno.h>
  20
  21 #include "void_list.h"
  22
  23 int void_list_elt_init(void_list_elt_t *elt, void *data)
  24 {
  25     INIT_LIST_HEAD(&elt->node);
  26     elt->data = data;
  27
  28     return 0;
  29 }
  30
  31 void_list_elt_t * void_list_elt_new (void *data) {
  32     void_list_elt_t *elt;
  33     /* freed in void_list_deinit */
  34     elt = calloc(1, sizeof(void_list_elt_t));
  35     if (elt == NULL) {
  36         fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
  37         return NULL;
  38     }
  39     void_list_elt_init(elt, data);
  40     return elt;
  41 }
  42
  43 void void_list_elt_deinit(void_list_elt_t *elt)
  44 {
  45     list_del_init(&elt->node);
  46     void_list_elt_init(elt, NULL);
  47 }
  48
  49 int void_list_init(void_list_t *list)
  50 {
  51     INIT_LIST_HEAD(&list->head);
  52     return 0;
  53 }
  54
  55 void void_list_deinit(void_list_t *list)
  56 {
  57     void_list_elt_t *elt;
  58
  59     while (!void_list_empty(list)) {
  60         elt = void_list_pop(list);
  61         void_list_elt_deinit(elt);
  62         /* malloced in void_list_append */
  63         free(elt);
  64     }
  65     INIT_LIST_HEAD(&list->head);
  66 }
  67
  68 int void_list_append(void_list_t *list, void *data)
  69 {
  70     void_list_elt_t *elt = void_list_elt_new(data);
  71
  72     list_add_tail(&elt->node, &list->head);
  73
  74     return 0;
  75 }
  76
  77 int void_list_push(void_list_t *list, void *data)
  78 {
  79     void_list_elt_t *elt = void_list_elt_new(data);
  80
  81     list_add(&elt->node, &list->head);
  82
  83     return 0;
  84 }
  85
  86 void_list_elt_t *void_list_pop(void_list_t *list)
  87 {
  88     struct list_head *node;
  89
  90     if (void_list_empty(list))
  91         return NULL;
  92     node = list->head.next;
  93     list_del_init(node);
  94     return list_entry(node, void_list_elt_t, node);
  95 }
  96
  97 void *void_list_remove(void_list_t *list, void_list_elt_t **iter)
  98 {
  99     void_list_elt_t *pos, *n;
 100     void_list_elt_t *old_elt;
 101     void *old_data = NULL;
 102
 103     old_elt = *iter;
 104     if (!old_elt)
 105         return old_data;
 106     old_data = old_elt->data;
 107
 108     list_for_each_entry_safe(pos, n, &list->head, node) {
 109         if (pos == old_elt)
 110             break;
 111     }
 112     if ( pos != old_elt) {
 113         fprintf(stderr, "%s: ERROR: element not found in list\n", __FUNCTION__);
 114         return NULL;
 115     }
 116
 117     *iter = list_entry(pos->node.prev, void_list_elt_t, node);
 118     void_list_elt_deinit(pos);
 119     free(pos);
 120
 121     return old_data;
 122 }
 123
 124 /* remove element containing elt data, using cmp(elt->data, target_data) == 0. */
 125 void *void_list_remove_elt(void_list_t *list, const void *target_data, void_list_cmp_t cmp)
 126 {
 127     void_list_elt_t *pos, *n;
 128     void *old_data = NULL;
 129     list_for_each_entry_safe(pos, n, &list->head, node) {
 130         if ( pos->data && cmp(pos->data, target_data)==0 ){
 131             old_data = pos->data;
 132             void_list_elt_deinit(pos);
 133             break;
 134         }
 135     }
 136     return old_data;
 137 }
 138
 139 void_list_elt_t *void_list_first(void_list_t *list) {
 140     struct list_head *elt;
 141     if (!list)
 142         return NULL;
 143     elt = list->head.next;
 144     if (elt == &list->head ) {
 145         return NULL;
 146     }
 147     return list_entry(elt, void_list_elt_t, node);
 148 }
 149
 150 void_list_elt_t *void_list_prev(void_list_t *list, void_list_elt_t *node) {
 151     struct list_head *elt;
 152     if (!list || !node)
 153         return NULL;
 154     elt = node->node.prev;
 155     if (elt == &list->head ) {
 156         return NULL;
 157     }
 158     return list_entry(elt, void_list_elt_t, node);
 159 }
 160
 161 void_list_elt_t *void_list_next(void_list_t *list, void_list_elt_t *node) {
 162     struct list_head *elt;
 163     if (!list || !node)
 164         return NULL;
 165     elt = node->node.next;
 166     if (elt == &list->head ) {
 167         return NULL;
 168     }
 169     return list_entry(elt, void_list_elt_t, node);
 170 }
 171
 172 void_list_elt_t *void_list_last(void_list_t *list) {
 173     struct list_head *elt;
 174     if (!list)
 175         return NULL;
 176     elt = list->head.prev;
 177     if (elt == &list->head ) {
 178         return NULL;
 179     }
 180     return list_entry(elt, void_list_elt_t, node);
 181 }
 182