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_with_capacity_fn(CCC_Allocator *const private_allocate,
                                    void *const private_context,
                                    size_t const private_cap,
                                    size_t const private_count)
{
    struct CCC_Bitset b = CCC_private_bitset_initialize(NULL, private_allocate,
                                                        private_context, 0);
    if (CCC_private_bitset_reserve(&b, private_cap, private_allocate)
        == CCC_RESULT_OK)
    {
        b.count = private_count;
    }
    return b;
}
 
#define CCC_private_bitset_from(private_allocate, private_context,             \
                                private_start_index, private_count,            \
                                private_on_char, private_string, ...)          \
    (__extension__({                                                           \
        struct CCC_Bitset private_bitset = CCC_private_bitset_initialize(      \
            NULL, private_allocate, private_context, 0);                       \
        size_t const private_cap                                               \
            = CCC_private_bitset_optional_size((private_count), __VA_ARGS__);  \
        size_t private_index = (private_start_index);                          \
        if (CCC_private_bitset_reserve(                                        \
                &private_bitset,                                               \
                private_cap < private_count ? private_count : private_cap,     \
                private_allocate)                                              \
            == CCC_RESULT_OK)                                                  \
        {                                                                      \
            private_bitset.count = private_count;                              \
            while (private_index < private_count                               \
                   && private_string[private_index])                           \
            {                                                                  \
                (void)CCC_private_bitset_set(&private_bitset, private_index,   \
                                             private_string[private_index]     \
                                                 == private_on_char);          \
                ++private_index;                                               \
            }                                                                  \
            private_bitset.count = private_index;                              \
        }                                                                      \
        private_bitset;                                                        \
    }))
 
#define CCC_private_bitset_with_capacity(private_allocate, private_context,    \
                                         private_cap, ...)                     \
    (__extension__({                                                           \
        struct CCC_Bitset private_bitset = CCC_private_bitset_initialize(      \
            NULL, private_allocate, private_context, 0);                       \
        size_t const private_count                                             \
            = CCC_private_bitset_optional_size((private_cap), __VA_ARGS__);    \
        if (CCC_private_bitset_reserve(&private_bitset, private_cap,           \
                                       private_allocate)                       \
            == CCC_RESULT_OK)                                                  \
        {                                                                      \
            private_bitset.count = private_count;                              \
        }                                                                      \
        private_bitset;                                                        \
    }))
 
#define CCC_private_bitset_with_compound_literal(                              \
    private_count, private_compound_literal_array)                             \
    {                                                                          \
        .blocks = (private_compound_literal_array),                            \
        .count = (private_count),                                              \
        .capacity = sizeof(private_compound_literal_array) * CHAR_BIT,         \
        .allocate = NULL,                                                      \
        .context = NULL,                                                       \
    }
 
#define CCC_private_bitset_with_context_compound_literal(                      \
    private_context, private_count, private_compound_literal_array)            \
    {                                                                          \
        .blocks = (private_compound_literal_array),                            \
        .count = (private_count),                                              \
        .capacity = sizeof(private_compound_literal_array) * CHAR_BIT,         \
        .allocate = NULL,                                                      \
        .context = (private_context),                                          \
    }
 
#endif /* CCC_PRIVATE_BITSET */