array.h

Go to the documentation of this file.

 
#pragma once
 
#include <mm/mm.h>
 
#include <stdint.h>
#include <string.h>
 
#define INIT_SIZE_ARRAY 8U
typedef uint_least32_t array_count_t;
 
#define dyn_array(type)                                                                                                \
    struct {                                                                                                       \
        type *items;                                                                                           \
        array_count_t count;                                                                                   \
        array_count_t capacity;                                                                                \
    }
 
#define array_items(self) ((self).items)
 
#define array_count(self) ((self).count)
 
#define array_capacity(self) ((self).capacity)
 
#define array_peek(self) (array_items(self)[array_count(self) - 1])
 
#define array_get_at(self, i) (array_items(self)[(i)])
 
#define array_is_empty(self) (array_count(self) == 0)
 
#define array_init(self)                                                                                               \
    __extension__({                                                                                                \
        array_capacity(self) = INIT_SIZE_ARRAY;                                                                \
        array_items(self) = mm_alloc(array_capacity(self) * sizeof(*array_items(self)));                       \
        array_count(self) = 0;                                                                                 \
    })
 
#define array_fini(self) __extension__({ mm_free(array_items(self)); })
 
#define array_push(self, elem)                                                                                         \
    __extension__({                                                                                                \
        array_expand(self);                                                                                    \
        array_items(self)[array_count(self)] = (elem);                                                         \
        array_count(self)++;                                                                                   \
    })
 
#define array_pop(self)                                                                                                \
    __extension__({                                                                                                \
        array_count(self)--;                                                                                   \
        array_items(self)[array_count(self)];                                                                  \
    })
 
#define array_add_at(self, i, elem)                                                                                    \
    __extension__({                                                                                                \
        array_expand(self);                                                                                    \
        memmove(&(array_items(self)[(i) + 1]), &(array_items(self)[(i)]),                                      \
            sizeof(*array_items(self)) * (array_count(self) - (i)));                                           \
        array_items(self)[(i)] = (elem);                                                                       \
        array_count(self)++;                                                                                   \
    })
 
#define array_remove_at(self, i)                                                                                       \
    __extension__({                                                                                                \
        __typeof__(*array_items(self)) __rmval;                                                                \
        array_count(self)--;                                                                                   \
        __rmval = array_items(self)[(i)];                                                                      \
        memmove(&(array_items(self)[(i)]), &(array_items(self)[(i) + 1]),                                      \
            sizeof(*array_items(self)) * (array_count(self) - (i)));                                           \
        array_shrink(self);                                                                                    \
        __rmval;                                                                                               \
    })
 
#define array_truncate_first(self, n)                                                                                  \
    __extension__({                                                                                                \
        array_count(self) -= (n);                                                                              \
        memmove(array_items(self), &(array_items(self)[n]), sizeof(*array_items(self)) * (array_count(self))); \
    })
 
#define array_shrink(self)                                                                                             \
    __extension__({                                                                                                \
        if(unlikely(array_count(self) > INIT_SIZE_ARRAY && array_count(self) * 3 <= array_capacity(self))) {   \
            array_capacity(self) /= 2;                                                                     \
            array_items(self) =                                                                            \
                mm_realloc(array_items(self), array_capacity(self) * sizeof(*array_items(self)));          \
        }                                                                                                      \
    })
 
#define array_reserve(self, n)                                                                                         \
    __extension__({                                                                                                \
        __typeof__(array_count(self)) tcnt = array_count(self) + (n);                                          \
        if(unlikely(tcnt >= array_capacity(self))) {                                                           \
            do {                                                                                           \
                array_capacity(self) *= 2;                                                             \
            } while(unlikely(tcnt >= array_capacity(self)));                                               \
            array_items(self) =                                                                            \
                mm_realloc(array_items(self), array_capacity(self) * sizeof(*array_items(self)));          \
        }                                                                                                      \
    })
 
#define array_expand(self)                                                                                             \
    __extension__({                                                                                                \
        if(unlikely(array_count(self) >= array_capacity(self))) {                                              \
            array_capacity(self) *= 2;                                                                     \
            array_items(self) =                                                                            \
                mm_realloc(array_items(self), array_capacity(self) * sizeof(*array_items(self)));          \
        }                                                                                                      \
    })
 
#define array_lazy_remove_at(self, i)                                                                                  \
    __extension__({ array_items(self)[(i)] = array_items(self)[--array_count(self)]; })