list.h

Go to the documentation of this file.

 
 
#pragma once
 
#include <assert.h>
#include <stdint.h>
#include <string.h>
#include <util/list-private.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
static_assert(
    offsetof(list_t_, base) == 0,
    "LIST(<type>).base and LIST(<type>).impl.base will not alias each other");
 
#define LIST(type)                                                             \
  struct {                                                                     \
    union {                                                                    \
      type *base;                                                              \
      list_t_ impl;                                                            \
    };                                                  \
    void (*dtor)(type);                             \
    type scratch;            \
  }
 
#define LIST_DTOR_FREE ((void *)1)
 
#define LIST_SIZE(list) gv_list_size_((list)->impl)
 
#define LIST_IS_EMPTY(list) (LIST_SIZE(list) == 0)
 
#define LIST_TRY_APPEND(list, item)                                            \
  (((list)->impl.size < (list)->impl.capacity ||                               \
    gv_list_try_reserve_(                                                      \
        &(list)->impl,                                                         \
        (list)->impl.capacity == 0 ? 1 : ((list)->impl.capacity * 2),          \
        sizeof((list)->base[0])) ||                                            \
    gv_list_try_reserve_(&(list)->impl, (list)->impl.capacity + 1,             \
                         sizeof((list)->base[0]))) &&                          \
   (((list)->base[gv_list_append_slot_(&(list)->impl,                          \
                                       sizeof((list)->base[0]))] = (item)),    \
    1))
 
#define LIST_APPEND(list, item)                                                \
  do {                                                                         \
    const size_t slot_ =                                                       \
        gv_list_append_slot_(&(list)->impl, sizeof((list)->base[0]));          \
    (list)->base[slot_] = (item);                                              \
  } while (0)
 
#define LIST_PREPEND(list, item)                                               \
  do {                                                                         \
    const size_t slot_ =                                                       \
        gv_list_prepend_slot_(&(list)->impl, sizeof((list)->base[0]));         \
    (list)->base[slot_] = (item);                                              \
  } while (0)
 
#define LIST_GET(list, index)                                                  \
  ((list)->base[gv_list_get_((list)->impl, (index))])
 
#define LIST_AT(list, index)                                                   \
  (&(list)->base[gv_list_get_((list)->impl, (index))])
 
#define LIST_FRONT(list) LIST_AT((list), 0)
 
#define LIST_BACK(list) LIST_AT((list), LIST_SIZE(list) - 1)
 
#define LIST_SET(list, index, item)                                            \
  do {                                                                         \
    const size_t slot_ = gv_list_get_((list)->impl, (index));                  \
    LIST_DTOR_((list), slot_);                                                 \
    (list)->base[slot_] = (item);                                              \
  } while (0)
 
#define LIST_REMOVE(list, item)                                                \
  do {                                                                         \
    /* get something we can take the address of */                             \
    (list)->scratch = (item);                                                  \
                                                                               \
    const size_t found_ = gv_list_find_((list)->impl, &(list)->scratch,        \
                                        sizeof((list)->base[0]));              \
    if (found_ == SIZE_MAX) { /* not found */                                  \
      break;                                                                   \
    }                                                                          \
                                                                               \
    LIST_DTOR_((list), found_);                                                \
    gv_list_remove_(&(list)->impl, found_, sizeof((list)->base[0]));           \
  } while (0)
 
#define LIST_CLEAR(list)                                                       \
  do {                                                                         \
    for (size_t i_ = 0; i_ < LIST_SIZE(list); ++i_) {                          \
      const size_t slot_ = gv_list_get_((list)->impl, i_);                     \
      LIST_DTOR_((list), slot_);                                               \
    }                                                                          \
    gv_list_clear_(&(list)->impl, sizeof((list)->base[0]));                    \
  } while (0)
 
#define LIST_RESERVE(list, capacity)                                           \
  gv_list_reserve_(&(list)->impl, capacity, sizeof((list)->base[0]))
 
#define LIST_CONTAINS(list, needle)                                            \
  gv_list_contains_((list)->impl,                                              \
                    ((void)((list)->base == &(needle)), &(needle)),            \
                    sizeof((list)->base[0]))
 
#define LIST_COPY(dst, src)                                                    \
  do {                                                                         \
    (void)((dst)->base == (src)->base);                                        \
    memset((dst), 0, sizeof(*(dst)));                                          \
    (dst)->impl = gv_list_copy_((src)->impl, sizeof((src)->base[0]));          \
    (dst)->dtor = (src)->dtor;                                                 \
  } while (0)
 
#define LIST_IS_CONTIGUOUS(list) gv_list_is_contiguous_((list)->impl);
 
#define LIST_SYNC(list) gv_list_sync_(&(list)->impl, sizeof((list)->base[0]))
 
#define LIST_SORT(list, cmp)                                                   \
  gv_list_sort_(&(list)->impl, (cmp), sizeof((list)->base[0]))
 
#define LIST_REVERSE(list)                                                     \
  gv_list_reverse_(&(list)->impl, sizeof((list)->base[0]))
 
#define LIST_SHRINK_TO_FIT(list)                                               \
  gv_list_shrink_to_fit_(&(list)->impl, sizeof((list)->base[0]))
 
#define LIST_FREE(list)                                                        \
  do {                                                                         \
    LIST_CLEAR(list);                                                          \
    gv_list_free_(&(list)->impl);                                              \
  } while (0)
 
#define LIST_PUSH_BACK(list, item) LIST_APPEND((list), (item))
 
#define LIST_POP_FRONT(list)                                                   \
  (gv_list_pop_front_(&(list)->impl, &(list)->scratch,                         \
                      sizeof((list)->base[0])),                                \
   (list)->scratch)
 
#define LIST_POP_BACK(list)                                                    \
  (gv_list_pop_back_(&(list)->impl, &(list)->scratch,                          \
                     sizeof((list)->base[0])),                                 \
   (list)->scratch)
 
#define LIST_DETACH(list, datap, sizep)                                        \
  do {                                                                         \
    *(datap) = (list)->base;                                                   \
    *(sizep) = (list)->impl.size;                                              \
                                                                               \
    (list)->impl = (list_t_){0};                                               \
  } while (0)
 
#ifdef __cplusplus
}
#endif