private_bitset.h

 
#ifndef CCC_PRIVATE_BITSET
#define CCC_PRIVATE_BITSET
 
#include <limits.h>
#include <stddef.h>
#include "../types.h"
 
struct CCC_Bitset
{
    unsigned *blocks;
    size_t count;
    size_t capacity;
    CCC_Allocator *allocate;
    void *context;
};
 
enum : size_t
{
    CCC_PRIVATE_BITSET_BLOCK_BITS
        = (sizeof(*(struct CCC_Bitset){}.blocks) * CHAR_BIT),
};
 
/*=========================     Private Interface   =========================*/
 
CCC_Result CCC_private_bitset_reserve(struct CCC_Bitset *, size_t,
                                      CCC_Allocator *);
CCC_Tribool CCC_private_bitset_set(struct CCC_Bitset *, size_t, CCC_Tribool);
 
/*================================     Macros     ===========================*/
 
#define CCC_private_bitset_block_count(private_bit_cap)                        \
    (((private_bit_cap) + (CCC_PRIVATE_BITSET_BLOCK_BITS - 1))                 \
     / CCC_PRIVATE_BITSET_BLOCK_BITS)
 
#define CCC_private_bitset_block_bytes(private_bit_cap)                        \
    (sizeof(*(struct CCC_Bitset){}.blocks) * (private_bit_cap))
 
#define CCC_private_bitset_blocks(private_bit_cap, ...)                        \
    (__VA_OPT__(__VA_ARGS__) typeof (                                          \
        *(struct CCC_Bitset){}                                                 \
             .blocks)[CCC_private_bitset_block_count(private_bit_cap)])        \
    {}
 
#define CCC_private_bitset_non_CCC_private_bitset_default_size(private_cap,    \
                                                               ...)            \
    __VA_ARGS__
#define CCC_private_bitset_default_size(private_cap, ...) private_cap
#define CCC_private_bitset_optional_size(private_cap, ...)                     \
    __VA_OPT__(CCC_private_bitset_non_)                                        \
    ##CCC_private_bitset_default_size(private_cap, __VA_ARGS__)
 
#define CCC_private_bitset_initialize(private_bitblock_pointer,                \
                                      private_allocate, private_context,       \
                                      private_cap, ...)                        \
    {                                                                          \
        .blocks = (private_bitblock_pointer),                                  \
        .count = CCC_private_bitset_optional_size((private_cap), __VA_ARGS__), \
        .capacity = (private_cap),                                             \
        .allocate = (private_allocate),                                        \
        .context = (private_context),                                          \
    }
 
static inline struct CCC_Bitset
CCC_private_bitset_from_fn(CCC_Allocator *const fn, void *const context,
                           size_t i, size_t const count, size_t cap,
                           char const on_char, char const *string)
{
    struct CCC_Bitset b = CCC_private_bitset_initialize(NULL, fn, context, 0);
    if (CCC_private_bitset_reserve(&b, cap < count ? count : cap, fn)
        != CCC_RESULT_OK)
    {
        return b;
    }
    b.count = count;
    while (i < count && string[i])
    {
        (void)CCC_private_bitset_set(&b, i, string[i] == on_char);
        ++i;
    }
    b.count = i;
    return b;
}
 
static inline struct CCC_Bitset
CCC_private_bitset_with_capacity_fn(CCC_Allocator *const fn,
                                    void *const context, size_t const cap,
                                    size_t const count)
{
    struct CCC_Bitset b = CCC_private_bitset_initialize(NULL, fn, context, 0);
    if (CCC_private_bitset_reserve(&b, cap, fn) == CCC_RESULT_OK)
    {
        b.count = count;
    }
    return b;
}
 
#define CCC_private_bitset_from(private_allocate, private_context,             \
                                private_start_index, private_count,            \
                                private_on_char, private_string, ...)          \
    CCC_private_bitset_from_fn(                                                \
        private_allocate, private_context, private_start_index, private_count, \
        CCC_private_bitset_optional_size((private_count), __VA_ARGS__),        \
        private_on_char, private_string)
 
#define CCC_private_bitset_with_capacity(private_allocate, private_context,    \
                                         private_cap, ...)                     \
    CCC_private_bitset_with_capacity_fn(                                       \
        private_allocate, private_context, private_cap,                        \
        CCC_private_bitset_optional_size((private_cap), __VA_ARGS__))
 
#endif /* CCC_PRIVATE_BITSET */