lib-lib/list.h

   1 /*
   2  *  This program is free software; you can redistribute it and/or modify
   3  *  it under the terms of the GNU General Public License as published by
   4  *  the Free Software Foundation; either version 2 of the License, or (at
   5  *  your option) any later version.
   6  *
   7  *  This program is distributed in the hope that it will be useful, but
   8  *  WITHOUT ANY WARRANTY; without even the implied warranty of
   9  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  10  *  General Public License for more details.
  11  *
  12  *  You should have received a copy of the GNU General Public License
  13  *  along with this program; if not, write to the Free Software
  14  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  15  *  MA 02110-1301, USA.
  16  *
  17  *  Copyright © 2006 Pierre Habouzit
  18  */
  19
  20 /*
  21  * Copyright notice from original mutt:
  22  * Copyright (C) 1996-2000 Michael R. Elkins <me@mutt.org>
  23  */
  24
  25 #ifndef MUTT_LIB_LIB_LIST_H
  26 #define MUTT_LIB_LIB_LIST_H
  27
  28 #define DO_SLIST(type, prefix, dtor)                                         \
  29     static inline type *prefix##_list_pop(type **list) {                     \
  30         if (*list) {                                                         \
  31             type *res = *list;                                               \
  32             *list = res->next;                                               \
  33             res->next = NULL;                                                \
  34             return res;                                                      \
  35         }                                                                    \
  36         return NULL;                                                         \
  37     }                                                                        \
  38     static inline void prefix##_list_push(type **list, type *item) {         \
  39         item->next = *list;                                                  \
  40         *list = item;                                                        \
  41     }                                                                        \
  42                                                                              \
  43     static inline type **prefix##_list_last(type **list) {                   \
  44         while (*list) {                                                      \
  45             list = &(*list)->next;                                           \
  46         }                                                                    \
  47         return list;                                                         \
  48     }                                                                        \
  49                                                                              \
  50     static inline type **prefix##_list_append(type **list, type *item) {     \
  51         list = prefix##_list_last(list);                                     \
  52         *list = item;                                                        \
  53         return list;                                                         \
  54     }                                                                        \
  55     static inline type *prefix##_list_rev(type *list) {                      \
  56         type *l = NULL;                                                      \
  57         while (list) {                                                       \
  58             prefix##_list_push(&l, prefix##_list_pop(&list));                \
  59         }                                                                    \
  60         return l;                                                            \
  61     }                                                                        \
  62                                                                              \
  63     static inline type **prefix##_list_init(type **list) {                   \
  64         *list = NULL;                                                        \
  65         return list;                                                         \
  66     }                                                                        \
  67     static inline void prefix##_list_wipe(type **list) {                     \
  68         while (*list) {                                                      \
  69             type *item = prefix##_list_pop(list);                            \
  70             dtor(&item);                                                     \
  71         }                                                                    \
  72     }                                                                        \
  73
  74
  75 typedef struct string_list_t {
  76     struct string_list_t *next;
  77     char *data;
  78 } string_list_t;
  79
  80 DO_INIT(string_list_t, string_item);
  81 static inline void string_item_wipe(string_list_t *it) {
  82     p_delete(&it->data);
  83 }
  84 DO_NEW(string_list_t, string_item);
  85 DO_DELETE(string_list_t, string_item);
  86 DO_SLIST(string_list_t, string, string_item_delete);
  87
  88 string_list_t *string_list_dup(const string_list_t *);
  89 int string_list_contains(const string_list_t *, const char *, const char *);
  90 void string_list_add(string_list_t **, const char *);
  91 void string_list_remove(string_list_t **l, const char *str);
  92
  93 /* FIXME: b0rken API's, replace that at any cost */
  94 /* add an element to a list */
  95 string_list_t *mutt_add_list_n(string_list_t*, const void*, size_t len);
  96 static inline string_list_t *mutt_add_list(string_list_t *head, const char *data) {
  97     size_t len = m_strlen(data);
  98     return mutt_add_list_n(head, data, len ? len + 1 : 0);
  99 }
 100
 101 #endif /* MUTT_LIB_LIB_LIST_H */