ccc/buffer_8h_source.html

#ifndef CCC_BUFFER_H

#define CCC_BUFFER_H


#include <stddef.h>

#include "impl/impl_buffer.h"

#include "types.h"


typedef struct ccc_buffer ccc_buffer;


#define ccc_buf_init(mem_ptr, any_type_name, alloc_fn, aux_data, capacity,     \

                     optional_size...)                                         \

    ccc_impl_buf_init(mem_ptr, any_type_name, alloc_fn, aux_data, capacity,    \

                      optional_size)


[[nodiscard]] ccc_result ccc_buf_reserve(ccc_buffer *buf, size_t to_add,

                                         ccc_any_alloc_fn *fn);


[[nodiscard]] ccc_result ccc_buf_copy(ccc_buffer *dst, ccc_buffer const *src,

                                      ccc_any_alloc_fn *fn);


[[nodiscard]] ccc_result ccc_buf_alloc(ccc_buffer *buf, size_t capacity,

                                       ccc_any_alloc_fn *fn);


[[nodiscard]] void *ccc_buf_alloc_back(ccc_buffer *buf);


[[nodiscard]] void *ccc_buf_push_back(ccc_buffer *buf, void const *data);


#define ccc_buf_emplace_back(buf_ptr, type_compound_literal...)                \

    ccc_impl_buf_emplace_back(buf_ptr, type_compound_literal)


[[nodiscard]] void *ccc_buf_insert(ccc_buffer *buf, size_t i, void const *data);


ccc_result ccc_buf_pop_back(ccc_buffer *buf);


ccc_result ccc_buf_pop_back_n(ccc_buffer *buf, size_t n);


ccc_result ccc_buf_erase(ccc_buffer *buf, size_t i);


[[nodiscard]] void *ccc_buf_at(ccc_buffer const *buf, size_t i);


#define ccc_buf_as(buf_ptr, type_name, index)                                  \

    ((type_name *)ccc_buf_at(buf_ptr, index))


[[nodiscard]] ccc_ucount ccc_buf_i(ccc_buffer const *buf, void const *slot);


[[nodiscard]] void *ccc_buf_back(ccc_buffer const *buf);


#define ccc_buf_back_as(buf_ptr, type_name) ((type_name *)ccc_buf_back(buf_ptr))


[[nodiscard]] void *ccc_buf_front(ccc_buffer const *buf);


#define ccc_buf_front_as(buf_ptr, type_name)                                   \

    ((type_name *)ccc_buf_front(buf_ptr))


void *ccc_buf_move(ccc_buffer *buf, size_t dst, size_t src);


ccc_result ccc_buf_write(ccc_buffer *buf, size_t i, void const *data);


#define ccc_buf_emplace(buf_ptr, index, type_compound_literal...)              \

    ccc_impl_buf_emplace(buf_ptr, index, type_compound_literal)


ccc_result ccc_buf_swap(ccc_buffer *buf, void *tmp, size_t i, size_t j);


[[nodiscard]] void *ccc_buf_begin(ccc_buffer const *buf);


[[nodiscard]] void *ccc_buf_next(ccc_buffer const *buf, void const *iter);


[[nodiscard]] void *ccc_buf_end(ccc_buffer const *buf);


[[nodiscard]] void *ccc_buf_capacity_end(ccc_buffer const *buf);


[[nodiscard]] void *ccc_buf_rbegin(ccc_buffer const *buf);


[[nodiscard]] void *ccc_buf_rnext(ccc_buffer const *buf, void const *iter);


[[nodiscard]] void *ccc_buf_rend(ccc_buffer const *buf);


ccc_result ccc_buf_size_plus(ccc_buffer *buf, size_t n);


ccc_result ccc_buf_size_minus(ccc_buffer *buf, size_t n);


ccc_result ccc_buf_size_set(ccc_buffer *buf, size_t n);


[[nodiscard]] ccc_ucount ccc_buf_count(ccc_buffer const *buf);


[[nodiscard]] ccc_ucount ccc_buf_capacity(ccc_buffer const *buf);


[[nodiscard]] ccc_ucount ccc_buf_sizeof_type(ccc_buffer const *buf);


[[nodiscard]] ccc_ucount ccc_buf_count_bytes(ccc_buffer const *buf);


[[nodiscard]] ccc_ucount ccc_buf_capacity_bytes(ccc_buffer const *buf);


[[nodiscard]] ccc_tribool ccc_buf_is_empty(ccc_buffer const *buf);


[[nodiscard]] ccc_tribool ccc_buf_is_full(ccc_buffer const *buf);


ccc_result

ccc_buf_clear_and_free_reserve(ccc_buffer *buf,

                               ccc_any_type_destructor_fn *destructor,

                               ccc_any_alloc_fn *alloc);


ccc_result ccc_buf_clear_and_free(ccc_buffer *buf,

                                  ccc_any_type_destructor_fn *destructor);


ccc_result ccc_buf_clear(ccc_buffer *buf,

                         ccc_any_type_destructor_fn *destructor);


#ifdef BUFFER_USING_NAMESPACE_CCC

typedef ccc_buffer buffer;

#    define buf_init(args...) ccc_buf_init(args)

#    define buf_alloc(args...) ccc_buf_alloc(args)

#    define buf_reserve(args...) ccc_buf_reserve(args)

#    define buf_copy(args...) ccc_buf_copy(args)

#    define buf_clear(args...) ccc_buf_clear(args)

#    define buf_clear_and_free(args...) ccc_buf_clear_and_free(args)

#    define buf_clear_and_free_reserve(args...)                                \

        ccc_buf_clear_and_free_reserve(args)

#    define buf_count(args...) ccc_buf_count(args)

#    define buf_count_bytes(args...) ccc_buf_count_bytes(args)

#    define buf_size_plus(args...) ccc_buf_size_plus(args)

#    define buf_size_minus(args...) ccc_buf_size_minus(args)

#    define buf_size_set(args...) ccc_buf_size_set(args)

#    define buf_capacity(args...) ccc_buf_capacity(args)

#    define buf_capacity_bytes(args...) ccc_buf_capacity_bytes(args)

#    define buf_sizeof_type(args...) ccc_buf_sizeof_type(args)

#    define buf_i(args...) ccc_buf_i(args)

#    define buf_is_full(args...) ccc_buf_is_full(args)

#    define buf_is_empty(args...) ccc_buf_is_empty(args)

#    define buf_at(args...) ccc_buf_at(args)

#    define buf_as(args...) ccc_buf_as(args)

#    define buf_back(args...) ccc_buf_back(args)

#    define buf_back_as(args...) ccc_buf_back_as(args)

#    define buf_front(args...) ccc_buf_front(args)

#    define buf_front_as(args...) ccc_buf_front_as(args)

#    define buf_alloc_back(args...) ccc_buf_alloc_back(args)

#    define buf_emplace(args...) ccc_buf_emplace(args)

#    define buf_emplace_back(args...) ccc_buf_emplace_back(args)

#    define buf_push_back(args...) ccc_buf_push_back(args)

#    define buf_pop_back(args...) ccc_buf_pop_back(args)

#    define buf_pop_back_n(args...) ccc_buf_pop_back_n(args)

#    define buf_move(args...) ccc_buf_move(args)

#    define buf_swap(args...) ccc_buf_swap(args)

#    define buf_write(args...) ccc_buf_write(args)

#    define buf_erase(args...) ccc_buf_erase(args)

#    define buf_insert(args...) ccc_buf_insert(args)

#    define buf_begin(args...) ccc_buf_begin(args)

#    define buf_next(args...) ccc_buf_next(args)

#    define buf_end(args...) ccc_buf_end(args)

#    define buf_rbegin(args...) ccc_buf_rbegin(args)

#    define buf_rnext(args...) ccc_buf_rnext(args)

#    define buf_rend(args...) ccc_buf_rend(args)

#    define buf_capacity_end(args...) ccc_buf_capacity_end(args)

#endif /* BUFFER_USING_NAMESPACE_CCC */


#endif /* CCC_BUFFER_H */

ccc_buf_i
ccc_ucount ccc_buf_i(ccc_buffer const *buf, void const *slot)
return the index of an element known to be in the buffer.

ccc_buf_copy
ccc_result ccc_buf_copy(ccc_buffer *dst, ccc_buffer const *src, ccc_any_alloc_fn *fn)
Copy the buf from src to newly initialized dst.

ccc_buf_capacity_bytes
ccc_ucount ccc_buf_capacity_bytes(ccc_buffer const *buf)
Return the bytes in the buffer given the current capacity elements.

ccc_buf_pop_back
ccc_result ccc_buf_pop_back(ccc_buffer *buf)
pop the back element from the buffer according to size.

ccc_buf_size_minus
ccc_result ccc_buf_size_minus(ccc_buffer *buf, size_t n)
Subtract n from the size of the buffer.

ccc_buf_clear_and_free
ccc_result ccc_buf_clear_and_free(ccc_buffer *buf, ccc_any_type_destructor_fn *destructor)
Set size of buf to 0 and call destructor on each element if needed. Free the underlying buffer settin...

ccc_buf_alloc_back
void * ccc_buf_alloc_back(ccc_buffer *buf)
allocates a new slot from the buffer at the end of the contiguous array. A slot is equivalent to one ...

ccc_buf_is_empty
ccc_tribool ccc_buf_is_empty(ccc_buffer const *buf)
return true if the size of the buffer is 0.

ccc_buf_count
ccc_ucount ccc_buf_count(ccc_buffer const *buf)
obtain the count of buffer active slots.

ccc_buffer
struct ccc_buffer ccc_buffer
A contiguous block of storage for elements of the same type.
Definition: buffer.h:74

ccc_buf_is_full
ccc_tribool ccc_buf_is_full(ccc_buffer const *buf)
return true if the size of the buffer equals capacity.

ccc_buf_size_set
ccc_result ccc_buf_size_set(ccc_buffer *buf, size_t n)
Set the buffer size to n.

ccc_buf_clear
ccc_result ccc_buf_clear(ccc_buffer *buf, ccc_any_type_destructor_fn *destructor)
Set size of buf to 0 and call destructor on each element if needed. O(1) if no destructor is provided...

ccc_buf_rend
void * ccc_buf_rend(ccc_buffer const *buf)
return the rend position of the buffer.

ccc_buf_capacity_end
void * ccc_buf_capacity_end(ccc_buffer const *buf)
return the end position of the buffer according to capacity.

ccc_buf_sizeof_type
ccc_ucount ccc_buf_sizeof_type(ccc_buffer const *buf)
The size of the type being stored contiguously in the buffer.

ccc_buf_at
void * ccc_buf_at(ccc_buffer const *buf, size_t i)
return the element at slot i in buf.

ccc_buf_rnext
void * ccc_buf_rnext(ccc_buffer const *buf, void const *iter)
advance the iter to the next slot in the buffer according to size and in reverse order.

ccc_buf_back
void * ccc_buf_back(ccc_buffer const *buf)
return the final element in the buffer according the current size.

ccc_buf_next
void * ccc_buf_next(ccc_buffer const *buf, void const *iter)
advance the iter to the next slot in the buffer according to size.

ccc_buf_write
ccc_result ccc_buf_write(ccc_buffer *buf, size_t i, void const *data)
write data to buffer at slot at index i according to capacity.

ccc_buf_size_plus
ccc_result ccc_buf_size_plus(ccc_buffer *buf, size_t n)
add n to the size of the buffer.

ccc_buf_rbegin
void * ccc_buf_rbegin(ccc_buffer const *buf)
obtain the address of the last element in the buffer in preparation for iteration according to size.

ccc_buf_move
void * ccc_buf_move(ccc_buffer *buf, size_t dst, size_t src)
Move data at index src to dst according to capacity.

ccc_buf_reserve
ccc_result ccc_buf_reserve(ccc_buffer *buf, size_t to_add, ccc_any_alloc_fn *fn)
Reserves space for at least to_add more elements.

ccc_buf_end
void * ccc_buf_end(ccc_buffer const *buf)
return the end position of the buffer according to size.

ccc_buf_capacity
ccc_ucount ccc_buf_capacity(ccc_buffer const *buf)
Return the current capacity of total possible slots.

ccc_buf_front
void * ccc_buf_front(ccc_buffer const *buf)
return the first element in the buffer at index 0.

ccc_buf_begin
void * ccc_buf_begin(ccc_buffer const *buf)
obtain the base address of the buffer in preparation for iteration.

ccc_buf_count_bytes
ccc_ucount ccc_buf_count_bytes(ccc_buffer const *buf)
Return the bytes in the buffer given the current count of active elements.

ccc_buf_erase
ccc_result ccc_buf_erase(ccc_buffer *buf, size_t i)
erase element at slot i according to size of the buffer maintaining contiguous storage of elements be...

ccc_buf_clear_and_free_reserve
ccc_result ccc_buf_clear_and_free_reserve(ccc_buffer *buf, ccc_any_type_destructor_fn *destructor, ccc_any_alloc_fn *alloc)
Frees all slots in the buf and frees the underlying buffer that was previously dynamically reserved w...

ccc_buf_insert
void * ccc_buf_insert(ccc_buffer *buf, size_t i, void const *data)
insert data at slot i according to size of the buffer maintaining contiguous storage of elements betw...

ccc_buf_pop_back_n
ccc_result ccc_buf_pop_back_n(ccc_buffer *buf, size_t n)
pop n elements from the back of the buffer according to size.

ccc_buf_alloc
ccc_result ccc_buf_alloc(ccc_buffer *buf, size_t capacity, ccc_any_alloc_fn *fn)
allocates the buffer to the specified size according to the user defined allocation function.

ccc_buf_push_back
void * ccc_buf_push_back(ccc_buffer *buf, void const *data)
return the newly pushed data into the last slot of the buffer according to size.

ccc_buf_swap
ccc_result ccc_buf_swap(ccc_buffer *buf, void *tmp, size_t i, size_t j)
swap elements at i and j according to capacity of the bufer.

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

types.h
The C Container Collection Fundamental Types.

ccc_any_alloc_fn
void * ccc_any_alloc_fn(void *ptr, size_t size, void *aux)
An allocation function at the core of all containers.
Definition: types.h:312

ccc_result
ccc_result
A result of actions on containers.
Definition: types.h:132

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:117

ccc_any_type_destructor_fn
void ccc_any_type_destructor_fn(ccc_any_type)
A callback function for destroying an element in the container.
Definition: types.h:347