ccc/flat__buffer_8h_source.html

#ifndef CCC_FLAT_BUFFER_H

#define CCC_FLAT_BUFFER_H


#include <stddef.h>

#include "private/private_flat_buffer.h"

#include "types.h"


typedef struct CCC_Flat_buffer CCC_Flat_buffer;


#define CCC_flat_buffer_default(type_name)                                     \

    CCC_private_flat_buffer_default(type_name)


#define CCC_flat_buffer_for(type_name, capacity, count, data_pointer...)       \

    CCC_private_flat_buffer_for(type_name, capacity, count, data_pointer)


#define CCC_flat_buffer_from(                                                  \

    allocator, optional_capacity, compound_literal_array...                    \

)                                                                              \

    CCC_private_flat_buffer_from(                                              \

        allocator, optional_capacity, compound_literal_array                   \

    )


#define CCC_flat_buffer_with_capacity(type_name, allocator, capacity)          \

    CCC_private_flat_buffer_with_capacity(type_name, allocator, capacity)


#define CCC_flat_buffer_with_storage(count, compound_literal_array...)         \

    CCC_private_flat_buffer_with_storage(count, compound_literal_array)


[[nodiscard]] CCC_Result CCC_flat_buffer_reserve(

    CCC_Flat_buffer *buffer, size_t to_add, CCC_Allocator const *allocator

);


[[nodiscard]] CCC_Result CCC_flat_buffer_copy(

    CCC_Flat_buffer *destination,

    CCC_Flat_buffer const *source,

    CCC_Allocator const *allocator

);


[[nodiscard]] CCC_Result CCC_flat_buffer_allocate(

    CCC_Flat_buffer *buffer, size_t capacity, CCC_Allocator const *allocator

);


[[nodiscard]] void *CCC_flat_buffer_allocate_back(

    CCC_Flat_buffer *buffer, CCC_Allocator const *allocator

);


[[nodiscard]] void *CCC_flat_buffer_push_back(

    CCC_Flat_buffer *buffer, void const *data, CCC_Allocator const *allocator

);


#define CCC_flat_buffer_emplace_back(                                          \

    flat_buffer_pointer, allocator_pointer, type_compound_literal...           \

)                                                                              \

    CCC_private_flat_buffer_emplace_back(                                      \

        flat_buffer_pointer, allocator_pointer, type_compound_literal          \

    )


[[nodiscard]] void *CCC_flat_buffer_insert(

    CCC_Flat_buffer *buffer,

    size_t index,

    void const *data,

    CCC_Allocator const *allocator

);


CCC_Result CCC_flat_buffer_pop_back(CCC_Flat_buffer *buffer);


CCC_Result CCC_flat_buffer_pop_back_n(CCC_Flat_buffer *buffer, size_t count);


CCC_Result CCC_flat_buffer_erase(CCC_Flat_buffer *buffer, size_t index);


[[nodiscard]] void *

CCC_flat_buffer_at(CCC_Flat_buffer const *buffer, size_t index);


#define CCC_flat_buffer_as(flat_buffer_pointer, type_name, index)              \

    ((type_name *)CCC_flat_buffer_at(flat_buffer_pointer, index))


[[nodiscard]] CCC_Count

CCC_flat_buffer_index(CCC_Flat_buffer const *buffer, void const *slot);


[[nodiscard]] void *CCC_flat_buffer_back(CCC_Flat_buffer const *buffer);


#define CCC_flat_buffer_back_as(flat_buffer_pointer, type_name)                \

    ((type_name *)CCC_flat_buffer_back(flat_buffer_pointer))


[[nodiscard]] void *CCC_flat_buffer_front(CCC_Flat_buffer const *buffer);


#define CCC_flat_buffer_front_as(flat_buffer_pointer, type_name)               \

    ((type_name *)CCC_flat_buffer_front(flat_buffer_pointer))


void *CCC_flat_buffer_move(

    CCC_Flat_buffer const *buffer, size_t destination, size_t source

);


CCC_Result CCC_flat_buffer_write(

    CCC_Flat_buffer const *buffer, size_t index, void const *data

);


#define CCC_flat_buffer_emplace(                                               \

    flat_buffer_pointer, index, type_compound_literal...                       \

)                                                                              \

    CCC_private_flat_buffer_emplace(                                           \

        flat_buffer_pointer, index, type_compound_literal                      \

    )


CCC_Result CCC_flat_buffer_swap(

    CCC_Flat_buffer const *buffer, void *temp, size_t index, size_t swap_index

);


[[nodiscard]] void *CCC_flat_buffer_begin(CCC_Flat_buffer const *buffer);


[[nodiscard]] void *

CCC_flat_buffer_next(CCC_Flat_buffer const *buffer, void const *iterator);


[[nodiscard]] void *CCC_flat_buffer_end(CCC_Flat_buffer const *buffer);


[[nodiscard]] void *

CCC_flat_buffer_reverse_begin(CCC_Flat_buffer const *buffer);


[[nodiscard]] void *CCC_flat_buffer_reverse_next(

    CCC_Flat_buffer const *buffer, void const *iterator

);


[[nodiscard]] void *CCC_flat_buffer_reverse_end(CCC_Flat_buffer const *buffer);


CCC_Result CCC_flat_buffer_count_plus(CCC_Flat_buffer *buffer, size_t count);


CCC_Result CCC_flat_buffer_count_minus(CCC_Flat_buffer *buffer, size_t count);


CCC_Result CCC_flat_buffer_count_set(CCC_Flat_buffer *buffer, size_t count);


[[nodiscard]] CCC_Count CCC_flat_buffer_count(CCC_Flat_buffer const *buffer);


[[nodiscard]] CCC_Count CCC_flat_buffer_capacity(CCC_Flat_buffer const *buffer);


[[nodiscard]] CCC_Count

CCC_flat_buffer_sizeof_type(CCC_Flat_buffer const *buffer);


[[nodiscard]] CCC_Count

CCC_flat_buffer_count_bytes(CCC_Flat_buffer const *buffer);


[[nodiscard]] CCC_Count

CCC_flat_buffer_capacity_bytes(CCC_Flat_buffer const *buffer);


[[nodiscard]] CCC_Tribool

CCC_flat_buffer_is_empty(CCC_Flat_buffer const *buffer);


[[nodiscard]] CCC_Tribool

CCC_flat_buffer_is_full(CCC_Flat_buffer const *buffer);


[[nodiscard]] void *CCC_flat_buffer_data(CCC_Flat_buffer const *buffer);


CCC_Result CCC_flat_buffer_clear_and_free(

    CCC_Flat_buffer *buffer,

    CCC_Destructor const *destructor,

    CCC_Allocator const *allocator

);


CCC_Result CCC_flat_buffer_clear(

    CCC_Flat_buffer *buffer, CCC_Destructor const *destructor

);


#ifdef FLAT_BUFFER_USING_NAMESPACE_CCC

/* NOLINTBEGIN(readability-identifier-naming) */

typedef CCC_Flat_buffer Flat_buffer;

#    define flat_buffer_default(argument) CCC_flat_buffer_default(argument)

#    define flat_buffer_for(arguments...) CCC_flat_buffer_for(arguments)

#    define flat_buffer_with_storage(arguments...)                             \

        CCC_flat_buffer_with_storage(arguments)

#    define flat_buffer_with_allocator(arguments...)                           \

        CCC_flat_buffer_with_allocator(arguments)

#    define flat_buffer_with_capacity(arguments...)                            \

        CCC_flat_buffer_with_capacity(arguments)

#    define flat_buffer_from(arguments...) CCC_flat_buffer_from(arguments)

#    define flat_buffer_allocate(arguments...)                                 \

        CCC_flat_buffer_allocate(arguments)

#    define flat_buffer_reserve(arguments...) CCC_flat_buffer_reserve(arguments)

#    define flat_buffer_copy(arguments...) CCC_flat_buffer_copy(arguments)

#    define flat_buffer_clear(arguments...) CCC_flat_buffer_clear(arguments)

#    define flat_buffer_clear_and_free(arguments...)                           \

        CCC_flat_buffer_clear_and_free(arguments)

#    define flat_buffer_count(arguments...) CCC_flat_buffer_count(arguments)

#    define flat_buffer_count_bytes(arguments...)                              \

        CCC_flat_buffer_count_bytes(arguments)

#    define flat_buffer_count_plus(arguments...)                               \

        CCC_flat_buffer_count_plus(arguments)

#    define flat_buffer_count_minus(arguments...)                              \

        CCC_flat_buffer_count_minus(arguments)

#    define flat_buffer_count_set(arguments...)                                \

        CCC_flat_buffer_count_set(arguments)

#    define flat_buffer_capacity(arguments...)                                 \

        CCC_flat_buffer_capacity(arguments)

#    define flat_buffer_capacity_bytes(arguments...)                           \

        CCC_flat_buffer_capacity_bytes(arguments)

#    define flat_buffer_sizeof_type(arguments...)                              \

        CCC_flat_buffer_sizeof_type(arguments)

#    define flat_buffer_index(arguments...) CCC_flat_buffer_index(arguments)

#    define flat_buffer_is_full(arguments...) CCC_flat_buffer_is_full(arguments)

#    define flat_buffer_is_empty(arguments...)                                 \

        CCC_flat_buffer_is_empty(arguments)

#    define flat_buffer_at(arguments...) CCC_flat_buffer_at(arguments)

#    define flat_buffer_as(arguments...) CCC_flat_buffer_as(arguments)

#    define flat_buffer_back(arguments...) CCC_flat_buffer_back(arguments)

#    define flat_buffer_back_as(arguments...) CCC_flat_buffer_back_as(arguments)

#    define flat_buffer_front(arguments...) CCC_flat_buffer_front(arguments)

#    define flat_buffer_front_as(arguments...)                                 \

        CCC_flat_buffer_front_as(arguments)

#    define flat_buffer_allocate_back(arguments...)                            \

        CCC_flat_buffer_allocate_back(arguments)

#    define flat_buffer_emplace(arguments...) CCC_flat_buffer_emplace(arguments)

#    define flat_buffer_emplace_back(arguments...)                             \

        CCC_flat_buffer_emplace_back(arguments)

#    define flat_buffer_push_back(arguments...)                                \

        CCC_flat_buffer_push_back(arguments)

#    define flat_buffer_pop_back(arguments...)                                 \

        CCC_flat_buffer_pop_back(arguments)

#    define flat_buffer_pop_back_n(arguments...)                               \

        CCC_flat_buffer_pop_back_n(arguments)

#    define flat_buffer_move(arguments...) CCC_flat_buffer_move(arguments)

#    define flat_buffer_swap(arguments...) CCC_flat_buffer_swap(arguments)

#    define flat_buffer_write(arguments...) CCC_flat_buffer_write(arguments)

#    define flat_buffer_erase(arguments...) CCC_flat_buffer_erase(arguments)

#    define flat_buffer_insert(arguments...) CCC_flat_buffer_insert(arguments)

#    define flat_buffer_begin(arguments...) CCC_flat_buffer_begin(arguments)

#    define flat_buffer_next(arguments...) CCC_flat_buffer_next(arguments)

#    define flat_buffer_end(arguments...) CCC_flat_buffer_end(arguments)

#    define flat_buffer_reverse_begin(arguments...)                            \

        CCC_flat_buffer_reverse_begin(arguments)

#    define flat_buffer_reverse_next(arguments...)                             \

        CCC_flat_buffer_reverse_next(arguments)

#    define flat_buffer_reverse_end(arguments...)                              \

        CCC_flat_buffer_reverse_end(arguments)

#    define flat_buffer_data(arguments...) CCC_flat_buffer_data(arguments)

/* NOLINTEND(readability-identifier-naming) */

#endif /* FLAT_BUFFER_USING_NAMESPACE_CCC */


#endif /* CCC_FLAT_BUFFER_H */

CCC_flat_buffer_pop_back
CCC_Result CCC_flat_buffer_pop_back(CCC_Flat_buffer *buffer)
pop the back element from the Flat_buffer according to size.

CCC_flat_buffer_count_bytes
CCC_Count CCC_flat_buffer_count_bytes(CCC_Flat_buffer const *buffer)
Return the bytes in the Flat_buffer given the current count of active elements.

CCC_flat_buffer_clear
CCC_Result CCC_flat_buffer_clear(CCC_Flat_buffer *buffer, CCC_Destructor const *destructor)
Set size of buffer to 0 and call destroy on each element if needed. O(1) if no destroy is provided,...

CCC_flat_buffer_allocate
CCC_Result CCC_flat_buffer_allocate(CCC_Flat_buffer *buffer, size_t capacity, CCC_Allocator const *allocator)
allocates the Flat_buffer to the specified size according to the user defined allocation function.

CCC_flat_buffer_count_minus
CCC_Result CCC_flat_buffer_count_minus(CCC_Flat_buffer *buffer, size_t count)
Subtract count from the size of the buffer.

CCC_flat_buffer_index
CCC_Count CCC_flat_buffer_index(CCC_Flat_buffer const *buffer, void const *slot)
return the index of an element known to be in the buffer.

CCC_flat_buffer_reserve
CCC_Result CCC_flat_buffer_reserve(CCC_Flat_buffer *buffer, size_t to_add, CCC_Allocator const *allocator)
Reserves space for at least to_add more elements.

CCC_flat_buffer_is_full
CCC_Tribool CCC_flat_buffer_is_full(CCC_Flat_buffer const *buffer)
return true if the size of the Flat_buffer equals capacity.

CCC_flat_buffer_write
CCC_Result CCC_flat_buffer_write(CCC_Flat_buffer const *buffer, size_t index, void const *data)
write data to Flat_buffer at slot at index index according to capacity.

CCC_flat_buffer_push_back
void * CCC_flat_buffer_push_back(CCC_Flat_buffer *buffer, void const *data, CCC_Allocator const *allocator)
return the newly pushed data into the last slot of the buffer according to size.

CCC_flat_buffer_at
void * CCC_flat_buffer_at(CCC_Flat_buffer const *buffer, size_t index)
return the element at slot index in buf.

CCC_flat_buffer_is_empty
CCC_Tribool CCC_flat_buffer_is_empty(CCC_Flat_buffer const *buffer)
return true if the size of the Flat_buffer is 0.

CCC_flat_buffer_reverse_end
void * CCC_flat_buffer_reverse_end(CCC_Flat_buffer const *buffer)
return the reverse_end position of the buffer.

CCC_flat_buffer_insert
void * CCC_flat_buffer_insert(CCC_Flat_buffer *buffer, size_t index, void const *data, CCC_Allocator const *allocator)
insert data at slot index according to size of the Flat_buffer maintaining contiguous storage of elem...

CCC_flat_buffer_swap
CCC_Result CCC_flat_buffer_swap(CCC_Flat_buffer const *buffer, void *temp, size_t index, size_t swap_index)
swap elements at index and swap_index according to capacity of the bufer.

CCC_flat_buffer_copy
CCC_Result CCC_flat_buffer_copy(CCC_Flat_buffer *destination, CCC_Flat_buffer const *source, CCC_Allocator const *allocator)
Copy the buffer from source to newly initialized destination.

CCC_flat_buffer_clear_and_free
CCC_Result CCC_flat_buffer_clear_and_free(CCC_Flat_buffer *buffer, CCC_Destructor const *destructor, CCC_Allocator const *allocator)
Set size of buffer to 0 and call destroy on each element if needed. Free the underlying Flat_buffer s...

CCC_flat_buffer_front
void * CCC_flat_buffer_front(CCC_Flat_buffer const *buffer)
return the first element in the Flat_buffer at index 0.

CCC_flat_buffer_end
void * CCC_flat_buffer_end(CCC_Flat_buffer const *buffer)
return the end position of the Flat_buffer according to size.

CCC_flat_buffer_next
void * CCC_flat_buffer_next(CCC_Flat_buffer const *buffer, void const *iterator)
advance the iterator to the next slot in the Flat_buffer according to size.

CCC_flat_buffer_allocate_back
void * CCC_flat_buffer_allocate_back(CCC_Flat_buffer *buffer, CCC_Allocator const *allocator)
allocates a new slot from the Flat_buffer at the end of the contiguous array. A slot is equivalent to...

CCC_flat_buffer_data
void * CCC_flat_buffer_data(CCC_Flat_buffer const *buffer)
return a reference to the underlying data of the buffer.

CCC_flat_buffer_back
void * CCC_flat_buffer_back(CCC_Flat_buffer const *buffer)
return the final element in the Flat_buffer according the current size.

CCC_flat_buffer_capacity
CCC_Count CCC_flat_buffer_capacity(CCC_Flat_buffer const *buffer)
Return the current capacity of total possible slots.

CCC_flat_buffer_erase
CCC_Result CCC_flat_buffer_erase(CCC_Flat_buffer *buffer, size_t index)
erase element at slot index according to size of the Flat_buffer maintaining contiguous storage of el...

CCC_flat_buffer_reverse_begin
void * CCC_flat_buffer_reverse_begin(CCC_Flat_buffer const *buffer)
obtain the address of the last element in the Flat_buffer in preparation for iteration according to s...

CCC_flat_buffer_capacity_bytes
CCC_Count CCC_flat_buffer_capacity_bytes(CCC_Flat_buffer const *buffer)
Return the bytes in the Flat_buffer given the current capacity elements.

CCC_flat_buffer_move
void * CCC_flat_buffer_move(CCC_Flat_buffer const *buffer, size_t destination, size_t source)
Move data at index source to destination according to capacity.

CCC_flat_buffer_sizeof_type
CCC_Count CCC_flat_buffer_sizeof_type(CCC_Flat_buffer const *buffer)
The size of the type being stored contiguously in the buffer.

CCC_flat_buffer_pop_back_n
CCC_Result CCC_flat_buffer_pop_back_n(CCC_Flat_buffer *buffer, size_t count)
pop count elements from the back of the Flat_buffer according to size.

CCC_flat_buffer_begin
void * CCC_flat_buffer_begin(CCC_Flat_buffer const *buffer)
obtain the base address of the Flat_buffer in preparation for iteration.

CCC_flat_buffer_count_plus
CCC_Result CCC_flat_buffer_count_plus(CCC_Flat_buffer *buffer, size_t count)
add count to the size of the buffer.

CCC_flat_buffer_count_set
CCC_Result CCC_flat_buffer_count_set(CCC_Flat_buffer *buffer, size_t count)
Set the Flat_buffer size to n.

CCC_flat_buffer_reverse_next
void * CCC_flat_buffer_reverse_next(CCC_Flat_buffer const *buffer, void const *iterator)
advance the iterator to the next slot in the Flat_buffer according to size and in reverse order.

CCC_flat_buffer_count
CCC_Count CCC_flat_buffer_count(CCC_Flat_buffer const *buffer)
obtain the count of Flat_buffer active slots.

CCC_Allocator
The type passed by reference to any container function that may need to allocate memory....
Definition: types.h:369

CCC_Count
A type for returning an unsigned integer from a container for counting. Intended to count sizes,...
Definition: types.h:243

CCC_Destructor
The type passed by reference to any container function that may need to destroy elements....
Definition: types.h:457

CCC_Flat_buffer
Definition: private_flat_buffer.h:32

CCC_Flat_buffer::data
void * data
Definition: private_flat_buffer.h:34

CCC_Flat_buffer::capacity
size_t capacity
Definition: private_flat_buffer.h:38

CCC_Flat_buffer::count
size_t count
Definition: private_flat_buffer.h:36

types.h
The C Container Collection Fundamental Types.

CCC_Tribool
CCC_Tribool
A three state boolean to allow for an error state. Error is -1, False is 0, and True is 1.
Definition: types.h:178

CCC_Result
CCC_Result
A result of actions on containers.
Definition: types.h:192