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, T)                                                    \
  struct name                                                                  \
  {                                                                            \
    int size;                              \
    int capacity;                  \
    T *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)                                             \
  ({                                                                           \
    if ((head)->capacity <= (idx))                                             \
      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)                                                  \
  ({                                                                           \
    if ((head)->capacity <= (head)->size)                                      \
      ARRAY_RESERVE(head, (head)->size + 1);                                   \
    ARRAY_ADD_NORESERVE(head, elem);                                           \
  })

#define ARRAY_SHRINK(head, n)                                                  \
  ((head)->size -= MIN(n, (head)->size))

#define ARRAY_ELEM_SIZE(head)                                                  \
  (sizeof(*(head)->entries))

#define ARRAY_RESERVE(head, n)                                                 \
  ({                                                                           \
    if ((head)->capacity < (n))                                                \
    {                                                                          \
      mutt_mem_reallocarray(&(head)->entries,                                  \
                            (n) + ARRAY_HEADROOM,                              \
                            ARRAY_ELEM_SIZE(head));                            \
      memset((head)->entries + (head)->capacity, 0,                            \
             ((n) + ARRAY_HEADROOM - (head)->capacity) * ARRAY_ELEM_SIZE(head)); \
      (head)->capacity = (n) + ARRAY_HEADROOM;                                 \
    }                                                                          \
    (head)->capacity;                                                          \
  })

#define ARRAY_FREE(head)                                                       \
  do                                                                           \
  {                                                                            \
    FREE(&(head)->entries);                                                    \
    (head)->size = (head)->capacity = 0;                                       \
  } while (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_INSERT(head, idx, elem)                                          \
  (((head)->capacity > (head)->size                                            \
    ? true                                                                     \
    : ARRAY_RESERVE((head), (head)->size + 1)),                                \
   ((idx) <= (head)->size                                                      \
    ? (memmove(&(head)->entries[(idx) + 1], &(head)->entries[(idx)],           \
               ARRAY_ELEM_SIZE((head)) * ((head)->size - (idx))),              \
       (head)->entries[(idx)] = (elem),                                        \
       (head)->size++,                                                         \
       true)                                                                   \
    : false))

#define ARRAY_REMOVE(head, elem)                                               \
  do                                                                           \
  {                                                                            \
    if (ARRAY_SIZE(head) > ARRAY_IDX(head, elem) + 1)                          \
    {                                                                          \
      memmove(elem, (elem) + 1,                                                \
              ARRAY_ELEM_SIZE(head) *                                          \
              (ARRAY_SIZE(head) - ARRAY_IDX(head, elem) - 1));                 \
    }                                                                          \
    ARRAY_SHRINK(head, 1);                                                     \
  } while (0)

#define ARRAY_SORT(head, fn, sdata)                                            \
  ({                                                                           \
    if ((head)->entries != NULL)                                               \
      mutt_qsort_r((head)->entries, ARRAY_SIZE(head), ARRAY_ELEM_SIZE(head), fn, sdata);\
    !!(head)->entries;                                                         \
  })
 
/******************************************************************************
 * Internal APIs
 *****************************************************************************/
#define ARRAY_SET_NORESERVE(head, idx, elem)                                   \
  ({                                                                           \
    if ((head)->capacity > (idx))                                              \
    {                                                                          \
      (head)->size = MAX((head)->size, (idx) + 1);                             \
      (head)->entries[(idx)] = (elem);                                         \
    }                                                                          \
    (head)->capacity > (idx);                                                  \
  })
 
#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 */