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
  16  * Licence along with this program; if not, write to the Free
  17  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
  18  * USA.
  19  *
  20  * Authors:
  21  *   Florian Forster <octo at verplant.org>
  22  */
  23
  24 #include "config.h"
  25
  26 #include <stdlib.h>
  27 #include <string.h>
  28
  29 #include "utils_llist.h"
  30
  31 /*
  32  * Private data types
  33  */
  34 struct llist_s
  35 {
  36         llentry_t *head;
  37         llentry_t *tail;
  38         int size;
  39 };
  40
  41 /*
  42  * Public functions
  43  */
  44 llist_t *llist_create (void)
  45 {
  46         llist_t *ret;
  47
  48         ret = (llist_t *) malloc (sizeof (llist_t));
  49         if (ret == NULL)
  50                 return (NULL);
  51
  52         memset (ret, '\0', sizeof (llist_t));
  53
  54         return (ret);
  55 }
  56
  57 void llist_destroy (llist_t *l)
  58 {
  59         llentry_t *e_this;
  60         llentry_t *e_next;
  61
  62         for (e_this = l->head; e_this != NULL; e_this = e_next)
  63         {
  64                 e_next = e_this->next;
  65                 llentry_destroy (e_this);
  66         }
  67
  68         free (l);
  69 }
  70
  71 llentry_t *llentry_create (char *key, void *value)
  72 {
  73         llentry_t *e;
  74
  75         e = (llentry_t *) malloc (sizeof (llentry_t));
  76         if (e)
  77         {
  78                 e->key   = key;
  79                 e->value = value;
  80                 e->next  = NULL;
  81         }
  82
  83         return (e);
  84 }
  85
  86 void llentry_destroy (llentry_t *e)
  87 {
  88         free (e);
  89 }
  90
  91 void llist_append (llist_t *l, llentry_t *e)
  92 {
  93         e->next = NULL;
  94
  95         if (l->tail == NULL)
  96                 l->head = e;
  97         else
  98                 l->tail->next = e;
  99
 100         l->tail = e;
 101
 102         ++(l->size);
 103 }
 104
 105 void llist_prepend (llist_t *l, llentry_t *e)
 106 {
 107         e->next = l->head;
 108         l->head = e;
 109
 110         if (l->tail == NULL)
 111                 l->tail = e;
 112
 113         ++(l->size);
 114 }
 115
 116 void llist_remove (llist_t *l, llentry_t *e)
 117 {
 118         llentry_t *prev;
 119
 120         prev = l->head;
 121         while ((prev != NULL) && (prev->next != e))
 122                 prev = prev->next;
 123
 124         if (prev != NULL)
 125                 prev->next = e->next;
 126         if (l->head == e)
 127                 l->head = e->next;
 128         if (l->tail == e)
 129                 l->tail = prev;
 130
 131         --(l->size);
 132 }
 133
 134 int llist_size (llist_t *l)
 135 {
 136         return (l ? l->size : 0);
 137 }
 138
 139 llentry_t *llist_search (llist_t *l, const char *key)
 140 {
 141         llentry_t *e;
 142
 143         for (e = l->head; e != NULL; e = e->next)
 144                 if (strcmp (key, e->key) == 0)
 145                         break;
 146
 147         return (e);
 148 }
 149
 150 llentry_t *llist_head (llist_t *l)
 151 {
 152         return (l->head);
 153 }
 154
 155 llentry_t *llist_tail (llist_t *l)
 156 {
 157         return (l->tail);
 158 }