private_buffer.h

 
#ifndef CCC_PRIVATE_BUFFER_H
#define CCC_PRIVATE_BUFFER_H
 
#include <stddef.h>
#include <string.h>
#include "../types.h" /* IWYU pragma: keep */
 
/* NOLINTBEGIN(readability-identifier-naming) */
 
struct CCC_Buffer {
    void *data;
    size_t count;
    size_t capacity;
    size_t sizeof_type;
};
 
/* @internal */
#define CCC_private_buffer_default(private_type_name)                          \
    (struct CCC_Buffer) {                                                      \
        .sizeof_type = sizeof(private_type_name),                              \
    }
 
#define CCC_private_buffer_for(                                                \
    private_type_name, private_capacity, private_count, private_data...        \
)                                                                              \
    (struct CCC_Buffer) {                                                      \
        .data = (private_data), .sizeof_type = sizeof(private_type_name),      \
        .count = (private_count), .capacity = (private_capacity),              \
    }
 
#define CCC_private_buffer_from(                                               \
    private_allocator,                                                         \
    private_optional_capacity,                                                 \
    private_compound_literal_array...                                          \
)                                                                              \
    (struct { struct CCC_Buffer private; }){(__extension__({                   \
        typeof(*private_compound_literal_array)                                \
            *private_buffer_initializer_list = private_compound_literal_array; \
        struct CCC_Buffer private_buf = CCC_private_buffer_default(            \
            typeof(*private_buffer_initializer_list)                           \
        );                                                                     \
        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_allocator)                                           \
            )                                                                  \
            == 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;                                                           \
    }))}.private
 
#define CCC_private_buffer_with_capacity(                                      \
    private_type_name, private_allocator, private_capacity                     \
)                                                                              \
    (struct { struct CCC_Buffer private; }){(__extension__({                   \
        struct CCC_Buffer private_buf                                          \
            = CCC_private_buffer_default(private_type_name);                   \
        (void)CCC_buffer_reserve(                                              \
            &private_buf, (private_capacity), &(private_allocator)             \
        );                                                                     \
        private_buf;                                                           \
    }))}.private
 
#if defined(__clang__) || defined(__llvm__)
#    define CCC_private_buffer_with_storage(                                   \
        private_count, private_compound_literal_array...                       \
    )                                                                          \
        (struct {                                                              \
            static_assert(                                                     \
                sizeof(private_compound_literal_array),                        \
                "provide non-zero capacity compound literal array"             \
            );                                                                 \
            static_assert(                                                     \
                private_count                                                  \
                    <= (sizeof(private_compound_literal_array)                 \
                        / sizeof(*private_compound_literal_array)),            \
                "provide count less than or equal to capacity of "             \
                "compound literal array"                                       \
            );                                                                 \
            CCC_Buffer private;                                                \
        }){{                                                                   \
               .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),            \
           }}                                                                  \
            .private
#else
#    define CCC_private_buffer_with_storage(                                   \
        private_count, private_compound_literal_array...                       \
    )                                                                          \
        (struct CCC_Buffer) {                                                  \
            .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),               \
        }
#endif
 
#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);                                       \
        private_buffer_res                                                     \
            = CCC_buffer_at((private_buffer_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_allocator_pointer,                                                 \
    private_type_compound_literal...                                           \
)                                                                              \
    (__extension__({                                                           \
        typeof(private_type_compound_literal) *private_buffer_res = NULL;      \
        private_buffer_res = CCC_buffer_allocate_back(                         \
            (private_buffer_pointer), (private_allocator_pointer)              \
        );                                                                     \
        if (private_buffer_res) {                                              \
            *private_buffer_res = private_type_compound_literal;               \
        }                                                                      \
        private_buffer_res;                                                    \
    }))
 
/* NOLINTEND(readability-identifier-naming) */
 
#endif /* CCC_PRIVATE_BUFFER_H */