list-private.h

Go to the documentation of this file.

 
 
#pragma once
 
#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <util/api.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef struct {
  void *base; 
  size_t head; 
  size_t size; 
  size_t capacity; 
} list_t_;
 
static inline size_t gv_list_size_(const list_t_ list) { return list.size; }
 
UTIL_API bool gv_list_try_reserve_(list_t_ *list, size_t capacity,
                                   size_t item_size);
 
UTIL_API size_t gv_list_append_slot_(list_t_ *list, size_t item_size);
 
UTIL_API size_t gv_list_prepend_slot_(list_t_ *list, size_t item_size);
 
UTIL_API size_t gv_list_get_(const list_t_ list, size_t index);
 
#define LIST_DTOR_(list, slot)                                                 \
  do {                                                                         \
    if ((list)->dtor == LIST_DTOR_FREE) {                                      \
      /* we need to juggle the element into a pointer to avoid compilation */  \
      /* errors from this (untaken) branch when the element type is not a  */  \
      /* pointer */                                                            \
      void *ptr_;                                                              \
      sizeof((list)->base[0]) == sizeof(ptr_)                                  \
          ? (void)0                                                            \
          : (void)(fprintf(stderr, "list element type is not a pointer, but "  \
                                   "`free` used as destructor\n"),             \
                   abort());                                                   \
      memcpy(&ptr_, &(list)->base[slot], sizeof(ptr_));                        \
      free(ptr_);                                                              \
    } else if ((list)->dtor != NULL) {                                         \
      (list)->dtor((list)->base[slot]);                                        \
    }                                                                          \
  } while (0)
 
UTIL_API size_t gv_list_find_(const list_t_ list, const void *needle,
                              size_t item_size);
 
UTIL_API void gv_list_remove_(list_t_ *list, size_t index, size_t item_size);
 
UTIL_API void gv_list_clear_(list_t_ *list, size_t item_size);
 
UTIL_API void gv_list_reserve_(list_t_ *list, size_t capacity,
                               size_t item_size);
 
UTIL_API bool gv_list_contains_(const list_t_ list, const void *needle,
                                size_t item_size);
 
UTIL_API list_t_ gv_list_copy_(const list_t_ list, size_t item_size);
 
UTIL_API bool gv_list_is_contiguous_(const list_t_ list);
 
UTIL_API void gv_list_sync_(list_t_ *list, size_t item_size);
 
UTIL_API void gv_list_sort_(list_t_ *list,
                            int (*cmp)(const void *, const void *),
                            size_t item_size);
 
UTIL_API void gv_list_reverse_(list_t_ *list, size_t item_size);
 
UTIL_API void gv_list_shrink_to_fit_(list_t_ *list, size_t item_size);
 
UTIL_API void gv_list_free_(list_t_ *list);
 
UTIL_API void gv_list_pop_front_(list_t_ *list, void *into, size_t item_size);
 
UTIL_API void gv_list_pop_back_(list_t_ *list, void *into, size_t item_size);
 
#ifdef __cplusplus
}
#endif