src/daemon/utils_llist.c

   1 /**
   2  * collectd - src/utils_llist.c
   3  * Copyright (C) 2006       Florian Forster <octo at collectd.org>
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in
  13  * all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21  * DEALINGS IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  *   Florian Forster <octo at collectd.org>
  25  */
  26
  27 #include <stdlib.h>
  28 #include <string.h>
  29
  30 #include "utils_llist.h"
  31
  32 /*
  33  * Private data types
  34  */
  35 struct llist_s
  36 {
  37         llentry_t *head;
  38         llentry_t *tail;
  39         int size;
  40 };
  41
  42 /*
  43  * Public functions
  44  */
  45 llist_t *llist_create (void)
  46 {
  47         llist_t *ret;
  48
  49         ret = calloc (1, sizeof (*ret));
  50         if (ret == NULL)
  51                 return (NULL);
  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 = malloc (sizeof (*e));
  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 }