private_buffer.h

 
#ifndef CCC_PRIVATE_BUFFER_H
#define CCC_PRIVATE_BUFFER_H
 
#include <assert.h>
#include <stddef.h>
#include <string.h>
#include "../types.h"
 
/* NOLINTBEGIN(readability-identifier-naming) */
 
struct CCC_Buffer
{
    void *data;
    size_t count;
    size_t capacity;
    size_t sizeof_type;
    CCC_Allocator *allocate;
    void *context;
};
 
#define CCC_private_buf_non_CCC_private_buf_default_size(...) __VA_ARGS__
#define CCC_private_buf_default_size(...) 0
#define CCC_private_buf_optional_size(...)                                     \
    __VA_OPT__(CCC_private_buf_non_)##CCC_private_buf_default_size(__VA_ARGS__)
 
#define CCC_private_buffer_initialize(private_data, private_type_name,         \
                                      private_allocate, private_context_data,  \
                                      private_capacity, ...)                   \
    {                                                                          \
        .data = (private_data),                                                \
        .sizeof_type = sizeof(private_type_name),                              \
        .count = CCC_private_buf_optional_size(__VA_ARGS__),                   \
        .capacity = (private_capacity),                                        \
        .allocate = (private_allocate),                                        \
        .context = (private_context_data),                                     \
    }
 
#define CCC_private_buffer_from(private_allocate, private_context_data,        \
                                private_optional_capacity,                     \
                                private_compound_literal_array...)             \
    (__extension__({                                                           \
        typeof(*private_compound_literal_array)                                \
            *private_buffer_initializer_list                                   \
            = private_compound_literal_array;                                  \
        struct CCC_Buffer private_buf = CCC_private_buffer_initialize(         \
            NULL, typeof(*private_buffer_initializer_list), private_allocate,  \
            private_context_data, 0);                                          \
        size_t const private_n = sizeof(private_compound_literal_array)        \
                               / sizeof(*private_buffer_initializer_list);     \
        size_t const private_cap = private_optional_capacity;                  \
        if (CCC_buffer_reserve(                                                \
                &private_buf,                                                  \
                (private_n > private_cap ? private_n : private_cap),           \
                private_allocate)                                              \
            == CCC_RESULT_OK)                                                  \
        {                                                                      \
            (void)memcpy(private_buf.data, private_buffer_initializer_list,    \
                         private_n                                             \
                             * sizeof(*private_buffer_initializer_list));      \
            private_buf.count = private_n;                                     \
        }                                                                      \
        private_buf;                                                           \
    }))
 
#define CCC_private_buffer_with_capacity(private_type_name, private_allocate,  \
                                         private_context_data,                 \
                                         private_capacity)                     \
    (__extension__({                                                           \
        struct CCC_Buffer private_buf = CCC_private_buffer_initialize(         \
            NULL, private_type_name, private_allocate, private_context_data,   \
            0);                                                                \
        (void)CCC_buffer_reserve(&private_buf, (private_capacity),             \
                                 private_allocate);                            \
        private_buf;                                                           \
    }))
 
#define CCC_private_buffer_with_compound_literal(                              \
    private_count, private_compound_literal_array...)                          \
                                                                               \
    {                                                                          \
        .data = (private_compound_literal_array),                              \
        .sizeof_type = sizeof(*private_compound_literal_array),                \
        .count = private_count,                                                \
        .capacity = sizeof(private_compound_literal_array)                     \
                  / sizeof(*private_compound_literal_array),                   \
        .allocate = NULL,                                                      \
        .context = NULL,                                                       \
    }
 
#define CCC_private_buffer_with_context_compound_literal(                      \
    private_context, private_count, private_compound_literal_array...)         \
                                                                               \
    {                                                                          \
        .data = (private_compound_literal_array),                              \
        .sizeof_type = sizeof(*private_compound_literal_array),                \
        .count = private_count,                                                \
        .capacity = sizeof(private_compound_literal_array)                     \
                  / sizeof(*private_compound_literal_array),                   \
        .allocate = NULL,                                                      \
        .context = (private_context),                                          \
    }
 
#define CCC_private_buffer_emplace(private_buffer_pointer, index,              \
                                   private_type_compound_literal...)           \
    (__extension__({                                                           \
        typeof(private_type_compound_literal) *private_buffer_res = NULL;      \
        __auto_type private_i = (index);                                       \
        __auto_type private_emplace_buff_pointer = (private_buffer_pointer);   \
        private_buffer_res                                                     \
            = CCC_buffer_at(private_emplace_buff_pointer, private_i);          \
        if (private_buffer_res)                                                \
        {                                                                      \
            *private_buffer_res = private_type_compound_literal;               \
        }                                                                      \
        private_buffer_res;                                                    \
    }))
 
#define CCC_private_buffer_emplace_back(private_buffer_pointer,                \
                                        private_type_compound_literal...)      \
    (__extension__({                                                           \
        typeof(private_type_compound_literal) *private_buffer_res = NULL;      \
        __auto_type private_emplace_back_private_buffer_pointer                \
            = (private_buffer_pointer);                                        \
        private_buffer_res = CCC_buffer_allocate_back(                         \
            (private_emplace_back_private_buffer_pointer));                    \
        if (private_buffer_res)                                                \
        {                                                                      \
            *private_buffer_res = private_type_compound_literal;               \
        }                                                                      \
        private_buffer_res;                                                    \
    }))
 
/* NOLINTEND(readability-identifier-naming) */
 
#endif /* CCC_PRIVATE_BUF_H */