private_flat_buffer.h

 
#ifndef CCC_PRIVATE_FLAT_BUFFER_H
#define CCC_PRIVATE_FLAT_BUFFER_H
 
#include <stddef.h>
#include <string.h>
#include "../types.h" /* IWYU pragma: keep */
 
/* NOLINTBEGIN(readability-identifier-naming) */
 
struct CCC_Flat_buffer {
    void *data;
    size_t count;
    size_t capacity;
    size_t sizeof_type;
};
 
/* @internal */
#define CCC_private_flat_buffer_default(private_type_name)                     \
    (struct CCC_Flat_buffer) {                                                 \
        .sizeof_type = sizeof(private_type_name),                              \
    }
 
#define CCC_private_flat_buffer_for(                                           \
    private_type_name, private_capacity, private_count, private_data...        \
)                                                                              \
    (struct CCC_Flat_buffer) {                                                 \
        .data = (private_data), .sizeof_type = sizeof(private_type_name),      \
        .count = (private_count), .capacity = (private_capacity),              \
    }
 
#define CCC_private_flat_buffer_from(                                          \
    private_allocator,                                                         \
    private_optional_capacity,                                                 \
    private_compound_literal_array...                                          \
)                                                                              \
    (struct { struct CCC_Flat_buffer private; }){(__extension__({              \
        typeof(*private_compound_literal_array)                                \
            *private_flat_buffer_initializer_list                              \
            = private_compound_literal_array;                                  \
        struct CCC_Flat_buffer private_buf = CCC_private_flat_buffer_default(  \
            typeof(*private_flat_buffer_initializer_list)                      \
        );                                                                     \
        size_t const private_n                                                 \
            = sizeof(private_compound_literal_array)                           \
            / sizeof(*private_flat_buffer_initializer_list);                   \
        size_t const private_cap = private_optional_capacity;                  \
        if (CCC_flat_buffer_reserve(                                           \
                &private_buf,                                                  \
                (private_n > private_cap ? private_n : private_cap),           \
                &(private_allocator)                                           \
            )                                                                  \
            == CCC_RESULT_OK) {                                                \
            (void)memcpy(                                                      \
                private_buf.data,                                              \
                private_flat_buffer_initializer_list,                          \
                private_n * sizeof(*private_flat_buffer_initializer_list)      \
            );                                                                 \
            private_buf.count = private_n;                                     \
        }                                                                      \
        private_buf;                                                           \
    }))}.private
 
#define CCC_private_flat_buffer_with_capacity(                                 \
    private_type_name, private_allocator, private_capacity                     \
)                                                                              \
    (struct { struct CCC_Flat_buffer private; }){(__extension__({              \
        struct CCC_Flat_buffer private_buf                                     \
            = CCC_private_flat_buffer_default(private_type_name);              \
        (void)CCC_flat_buffer_reserve(                                         \
            &private_buf, (private_capacity), &(private_allocator)             \
        );                                                                     \
        private_buf;                                                           \
    }))}.private
 
#if defined(__clang__) || defined(__llvm__)
#    define CCC_private_flat_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_Flat_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_flat_buffer_with_storage(                              \
        private_count, private_compound_literal_array...                       \
    )                                                                          \
        (struct CCC_Flat_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_flat_buffer_emplace(                                       \
    private_flat_buffer_pointer, index, private_type_compound_literal...       \
)                                                                              \
    (__extension__({                                                           \
        __auto_type private_i = (index);                                       \
        typeof(private_type_compound_literal) *private_flat_buffer_res         \
            = CCC_flat_buffer_at((private_flat_buffer_pointer), private_i);    \
        if (private_flat_buffer_res) {                                         \
            *private_flat_buffer_res = private_type_compound_literal;          \
        }                                                                      \
        private_flat_buffer_res;                                               \
    }))
 
#define CCC_private_flat_buffer_emplace_back(                                  \
    private_flat_buffer_pointer,                                               \
    private_allocator_pointer,                                                 \
    private_type_compound_literal...                                           \
)                                                                              \
    (__extension__({                                                           \
        typeof(private_type_compound_literal) *private_flat_buffer_res         \
            = CCC_flat_buffer_allocate_back(                                   \
                (private_flat_buffer_pointer), (private_allocator_pointer)     \
            );                                                                 \
        if (private_flat_buffer_res) {                                         \
            *private_flat_buffer_res = private_type_compound_literal;          \
        }                                                                      \
        private_flat_buffer_res;                                               \
    }))
 
/* NOLINTEND(readability-identifier-naming) */
 
#endif /* CCC_PRIVATE_FLAT_BUFFER_H */