darray.h

Go to the documentation of this file.

#ifndef H2OTILS_DARRAY_H
#define H2OTILS_DARRAY_H
 
#include <h2o/memory.h>
 
//
//
//
 
#include <htils/assert.h>
#include <htils/basictypes.h>
 
//
//
//
 
typedef struct h2o_da_header {
  u64 cap;
  u64 len;
} h2o_da_header_t;
 
//
//
//
 
#define H2O_DA_HEADER_SIZE                                                     \
  ((sizeof(h2o_da_header_t) + _Alignof(max_align_t) - 1) &                     \
   ~(_Alignof(max_align_t) - 1))
 
//
//
//
 
static inline h2o_da_header_t *h2o_da__hdr(void *h2o_da) {
  return (h2o_da_header_t *)((cstr *)h2o_da - H2O_DA_HEADER_SIZE);
}
 
#define h2o_da_len(darray) ((darray) ? h2o_da__hdr(darray)->len : 0)
 
#define h2o_da_cap(darray) ((darray) ? h2o_da__hdr(darray)->cap : 0)
 
#define h2o_da_new(pool, darray, intitial_capacity)                            \
  do {                                                                         \
    htils_assert(pool && "pool cannot be null.");                              \
    htils_assert(intitial_capacity > 0 &&                                      \
                 "Initial capacity must be greater than 0");                   \
                                                                               \
    u64 capacity = (intitial_capacity);                                        \
    u64 alloc_size = H2O_DA_HEADER_SIZE + capacity;                            \
                                                                               \
    h2o_da_header_t *header = h2o_mem_alloc_pool((pool), darray, alloc_size);  \
    header->cap = capacity;                                                    \
    header->len = 0;                                                           \
    (darray) = (void *)(header + 1);                                           \
  } while (0)
 
//
//
//
 
#define h2o_da_append(pool, darray, item)                                      \
  do {                                                                         \
    htils_assert(pool && "Pool cannot be null.");                              \
    htils_assert(darray && "Darray cannot be null.");                          \
    htils_assert(item && "Item cannot be null.");                              \
                                                                               \
    if (!(darray) || h2o_da_len(darray) >= h2o_da_cap(darray)) {               \
      u64 old_capacity = h2o_da_cap(darray);                                   \
      u64 new_capacity =                                                       \
          old_capacity ? old_capacity + old_capacity / 2 + (old_capacity % 2)  \
                       : 8;                                                    \
      u64 old_len = h2o_da_len(darray);                                        \
      u64 alloc_size = H2O_DA_HEADER_SIZE + new_capacity;                      \
                                                                               \
      h2o_da_header_t *header =                                                \
          h2o_mem_alloc_pool((pool), darray, alloc_size);                      \
                                                                               \
      header->cap = new_capacity;                                              \
      header->len = old_len;                                                   \
                                                                               \
      if (darray)                                                              \
        memcpy(header + 1, (darray), old_len * sizeof(*(darray)));             \
                                                                               \
      (darray) = (void *)(header + 1);                                         \
    }                                                                          \
                                                                               \
    (darray)[h2o_da__hdr(darray)->len++] = (item);                             \
  } while (0)
 
#define h2o_da_pop(darray)                                                     \
  do {                                                                         \
    if (darray && h2o_da__hdr(darray)->len > 0)                                \
      h2o_da__hdr(darray)->len--;                                              \
  } while (0)
 
#define h2o_da_last(darray)                                                    \
  (htils_assert(h2o_da__hdr(darray)->len > 0),                                 \
   (darray)[h2o_da__hdr(darray)->len - 1])
 
#define h2o_da_clear(darray)                                                   \
  do {                                                                         \
    if (darray)                                                                \
      h2o_da__hdr(darray)->len = 0;                                            \
  } while (0)
 
#endif // !H2OTILS_DARRAY_H