src/utils_llist.c

   1 /**
   2  * collectd - src/utils_llist.c
   3  * Copyright (C) 2006 Florian Forster <octo at verplant.org>
   4  *
   5  * This program is free software; you can redistribute it and/
   6  * or modify it under the terms of the GNU General Public Li-
   7  * cence as published by the Free Software Foundation; only
   8  * version 2 of the Licence is applicable.
   9  *
  10  * This program is distributed in the hope that it will be use-
  11  * ful, but WITHOUT ANY WARRANTY; without even the implied war-
  12  * ranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  13  * See the GNU General Public Licence for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  18  *
  19  * Authors:
  20  *   Florian Forster <octo at verplant.org>
  21  */
  22
  23 #include "config.h"
  24
  25 #include <stdlib.h>
  26 #include <string.h>
  27
  28 #include "utils_llist.h"
  29
  30 /*
  31  * Private data types
  32  */
  33 struct llist_s
  34 {
  35         llentry_t *head;
  36         llentry_t *tail;
  37         int size;
  38 };
  39
  40 /*
  41  * Public functions
  42  */
  43 llist_t *llist_create (void)
  44 {
  45         llist_t *ret;
  46
  47         ret = (llist_t *) malloc (sizeof (llist_t));
  48         if (ret == NULL)
  49                 return (NULL);
  50
  51         memset (ret, '\0', sizeof (llist_t));
  52
  53         return (ret);
  54 }
  55
  56 void llist_destroy (llist_t *l)
  57 {
  58         llentry_t *e_this;
  59         llentry_t *e_next;
  60
  61         if (l == NULL)
  62                 return;
  63
  64         for (e_this = l->head; e_this != NULL; e_this = e_next)
  65         {
  66                 e_next = e_this->next;
  67                 llentry_destroy (e_this);
  68         }
  69
  70         free (l);
  71 }
  72
  73 llentry_t *llentry_create (char *key, void *value)
  74 {
  75         llentry_t *e;
  76
  77         e = (llentry_t *) malloc (sizeof (llentry_t));
  78         if (e)
  79         {
  80                 e->key   = key;
  81                 e->value = value;
  82                 e->next  = NULL;
  83         }
  84
  85         return (e);
  86 }
  87
  88 void llentry_destroy (llentry_t *e)
  89 {
  90         free (e);
  91 }
  92
  93 void llist_append (llist_t *l, llentry_t *e)
  94 {
  95         e->next = NULL;
  96
  97         if (l->tail == NULL)
  98                 l->head = e;
  99         else
 100                 l->tail->next = e;
 101
 102         l->tail = e;
 103
 104         ++(l->size);
 105 }
 106
 107 void llist_prepend (llist_t *l, llentry_t *e)
 108 {
 109         e->next = l->head;
 110         l->head = e;
 111
 112         if (l->tail == NULL)
 113                 l->tail = e;
 114
 115         ++(l->size);
 116 }
 117
 118 void llist_remove (llist_t *l, llentry_t *e)
 119 {
 120         llentry_t *prev;
 121
 122         if ((l == NULL) || (e == NULL))
 123                 return;
 124
 125         prev = l->head;
 126         while ((prev != NULL) && (prev->next != e))
 127                 prev = prev->next;
 128
 129         if (prev != NULL)
 130                 prev->next = e->next;
 131         if (l->head == e)
 132                 l->head = e->next;
 133         if (l->tail == e)
 134                 l->tail = prev;
 135
 136         --(l->size);
 137 }
 138
 139 int llist_size (llist_t *l)
 140 {
 141         return (l ? l->size : 0);
 142 }
 143
 144 static int llist_strcmp (llentry_t *e, void *ud)
 145 {
 146         if ((e == NULL) || (ud == NULL))
 147                 return (-1);
 148         return (strcmp (e->key, (const char *)ud));
 149 }
 150
 151 llentry_t *llist_search (llist_t *l, const char *key)
 152 {
 153         return (llist_search_custom (l, llist_strcmp, (void *)key));
 154 }
 155
 156 llentry_t *llist_search_custom (llist_t *l,
 157                 int (*compare) (llentry_t *, void *), void *user_data)
 158 {
 159         llentry_t *e;
 160
 161         if (l == NULL)
 162                 return (NULL);
 163
 164         e = l->head;
 165         while (e != NULL) {
 166                 llentry_t *next = e->next;
 167
 168                 if (compare (e, user_data) == 0)
 169                         break;
 170
 171                 e = next;
 172         }
 173
 174         return (e);
 175 }
 176
 177 llentry_t *llist_head (llist_t *l)
 178 {
 179         if (l == NULL)
 180                 return (NULL);
 181         return (l->head);
 182 }
 183
 184 llentry_t *llist_tail (llist_t *l)
 185 {
 186         if (l == NULL)
 187                 return (NULL);
 188         return (l->tail);
 189 }