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 #include "str.h"
  29
  30 typedef struct list_t {
  31     char *data;
  32     struct list_t *next;
  33 } LIST;
  34
  35 #define mutt_new_list() p_new(LIST, 1)
  36 void mutt_free_list(LIST **);
  37
  38 LIST *mutt_copy_list(LIST *);
  39
  40 /* add an element to a list */
  41 LIST *mutt_add_list_n(LIST*, const void*, size_t len);
  42 static inline LIST *mutt_add_list(LIST *head, const char *data) {
  43     size_t len = m_strlen(data);
  44     return mutt_add_list_n(head, data, len ? len + 1 : 0);
  45 }
  46
  47 #define DO_SLIST(type, prefix)                                               \
  48     static inline type *prefix##_list_pop(type **list) {                     \
  49         if (*list) {                                                         \
  50             type *res = *list;                                               \
  51             *list = res->next;                                               \
  52             res->next = NULL;                                                \
  53             return res;                                                      \
  54         }                                                                    \
  55         return NULL;                                                         \
  56     }                                                                        \
  57     static inline void prefix##_list_push(type **list, type *item) {         \
  58         item->next = *list;                                                  \
  59         *list = item;                                                        \
  60     }                                                                        \
  61                                                                              \
  62     static inline type **prefix##_list_last(type **list) {                   \
  63         while (*list) {                                                      \
  64             list = &(*list)->next;                                           \
  65         }                                                                    \
  66         return list;                                                         \
  67     }                                                                        \
  68                                                                              \
  69     static inline type **prefix##_list_append(type **list, type *item) {     \
  70         list = prefix##_list_last(list);                                     \
  71         *list = item;                                                        \
  72         return list;                                                         \
  73     }                                                                        \
  74                                                                              \
  75     static inline type **prefix##_list_init(type **list) {                   \
  76         *list = NULL;                                                        \
  77         return list;                                                         \
  78     }                                                                        \
  79     static inline void prefix##_list_wipe(type **list, int del) {            \
  80         if (del) {                                                           \
  81             while (*list) {                                                  \
  82                 type *item = prefix##_list_pop(list);                        \
  83                 prefix##_delete(&item);                                      \
  84             }                                                                \
  85         } else {                                                             \
  86             *list = NULL;                                                    \
  87         }                                                                    \
  88     }                                                                        \
  89
  90
  91
  92
  93
  94 #endif /* MUTT_LIB_LIB_LIST_H */