array.h

Go to the documentation of this file.

 
#ifndef MUTT_MUTT_ARRAY_H
#define MUTT_MUTT_ARRAY_H
 
#include <stdbool.h>
#include <string.h>
#include "memory.h"
 
#define ARRAY_HEADROOM 25
 
#define ARRAY_HEAD(name, type)                                                 \
  struct name                                                                  \
  {                                                                            \
    int size;                              \
    int capacity;                  \
    type *entries;                               \
  }
 
#define ARRAY_HEAD_INITIALIZER                                                 \
  { 0, 0, NULL }
 
#define ARRAY_INIT(head)                                                       \
  memset((head), 0, sizeof(*(head)))
 
#define ARRAY_EMPTY(head)                                                      \
  ((head)->size == 0)
 
#define ARRAY_SIZE(head)                                                       \
  ((head)->size)
 
#define ARRAY_CAPACITY(head)                                                   \
  ((head)->capacity)
 
#define ARRAY_GET(head, idx)                                                   \
  ((idx >= 0) && ((head)->size > (idx)) ? &(head)->entries[(idx)] : NULL)
 
#define ARRAY_SET(head, idx, elem)                                             \
  (((head)->capacity > (idx)                                                   \
    ? true                                                                     \
    : ARRAY_RESERVE((head), (idx) + 1)),                                       \
   ARRAY_SET_NORESERVE((head), (idx), (elem)))
 
#define ARRAY_FIRST(head)                                                      \
   ARRAY_GET((head), 0)
 
#define ARRAY_LAST(head)                                                       \
  (ARRAY_EMPTY((head))                                                         \
   ? NULL                                                                      \
   : ARRAY_GET((head), ARRAY_SIZE((head)) - 1))
 
#define ARRAY_ADD(head, elem)                                                  \
  (((head)->capacity > (head)->size                                            \
    ? true                                                                     \
    : ARRAY_RESERVE((head), (head)->size + 1)),                                \
   ARRAY_ADD_NORESERVE((head), (elem)))
 
#define ARRAY_SHRINK(head, num)                                                \
  ((head)->size -= MIN((num), (head)->size))
 
#define ARRAY_ELEM_SIZE(head)                                                  \
  (sizeof(*(head)->entries))
 
#define ARRAY_RESERVE(head, num)                                               \
  (((head)->capacity > (num)) ?                                                \
       (head)->capacity :                                                      \
       ((mutt_mem_reallocarray(                                                \
         &(head)->entries, (num) + ARRAY_HEADROOM, ARRAY_ELEM_SIZE(head))),    \
        (memset((head)->entries + (head)->capacity, 0,                         \
                ((num) + ARRAY_HEADROOM - (head)->capacity) *                  \
                ARRAY_ELEM_SIZE(head))),                                       \
        ((head)->capacity = (num) + ARRAY_HEADROOM)))
 
#define ARRAY_FREE(head)                                                       \
  (FREE(&(head)->entries), (head)->size = (head)->capacity = 0)
 
#define ARRAY_FOREACH(elem, head)                                              \
  ARRAY_FOREACH_FROM_TO(elem, (head), 0, (head)->size)
 
#define ARRAY_FOREACH_FROM(elem, head, from)                                   \
  ARRAY_FOREACH_FROM_TO(elem, (head), (from), (head)->size)
 
#define ARRAY_FOREACH_TO(elem, head, to)                                       \
  ARRAY_FOREACH_FROM_TO(elem, (head), 0, (to))
 
#define ARRAY_FOREACH_FROM_TO(elem, head, from, to)                            \
  for (int ARRAY_FOREACH_IDX_##elem = (from);                                  \
       (ARRAY_FOREACH_IDX_##elem < (to)) &&                                    \
       (elem = ARRAY_GET((head), ARRAY_FOREACH_IDX_##elem));                   \
       ARRAY_FOREACH_IDX_##elem++)
 
#define ARRAY_FOREACH_REVERSE(elem, head)                                      \
  ARRAY_FOREACH_REVERSE_FROM_TO(elem, (head), (head)->size, 0)
 
#define ARRAY_FOREACH_REVERSE_FROM(elem, head, from)                           \
  ARRAY_FOREACH_REVERSE_FROM_TO(elem, (head), (from), 0)
 
#define ARRAY_FOREACH_REVERSE_TO(elem, head, to)                               \
  ARRAY_FOREACH_REVERSE_FROM_TO(elem, (head), (head)->size, (to))
 
#define ARRAY_FOREACH_REVERSE_FROM_TO(elem, head, from, to)                    \
  for (int ARRAY_FOREACH_IDX_##elem = (from) - 1;                              \
       (ARRAY_FOREACH_IDX_##elem >= (to)) &&                                   \
       (elem = ARRAY_GET((head), ARRAY_FOREACH_IDX_##elem));                   \
       ARRAY_FOREACH_IDX_##elem--)
 
#define ARRAY_IDX(head, elem)                                                  \
  (elem - (head)->entries)
 
#define ARRAY_REMOVE(head, elem)                                               \
  (memmove((elem), (elem) + 1,                                                 \
           ARRAY_ELEM_SIZE((head)) *                                           \
           MAX(0, (ARRAY_SIZE((head)) - ARRAY_IDX((head), (elem)) - 1))),      \
   ARRAY_SHRINK((head), 1))
 
#define ARRAY_SORT(head, fn, sdata)                                            \
  ((head)->entries &&                                                          \
   (mutt_qsort_r((head)->entries, ARRAY_SIZE(head), ARRAY_ELEM_SIZE(head), (fn), (sdata)), true))
 
/******************************************************************************
 * Internal APIs
 *****************************************************************************/
#define ARRAY_SET_NORESERVE(head, idx, elem)                                   \
  ((head)->capacity > (idx)                                                    \
   ? (((head)->size = MAX((head)->size, ((idx) + 1))),                         \
      ((head)->entries[(idx)] = (elem)),                                       \
      true)                                                                    \
   : false)
 
#ifndef __COVERITY__
#define __coverity_escape__(x) 0
#endif
#define ARRAY_ADD_NORESERVE(head, elem)                                        \
  ((head)->capacity > (head)->size                                             \
   ? (((head)->entries[(head)->size++] = (elem)),                              \
     ((void)__coverity_escape__(elem), true))                                  \
   : ((void)__coverity_escape__(elem), false))
 
#endif /* MUTT_MUTT_ARRAY_H */