private_flat_bitset.h

 
#ifndef CCC_PRIVATE_BITSET
#define CCC_PRIVATE_BITSET
 
#include <limits.h>
#include <stddef.h>
#include <stdint.h>
#include "../configuration.h"
#include "../types.h"
 
struct CCC_Flat_bitset {
    unsigned *blocks;
    size_t count;
    size_t capacity;
};
 
enum : size_t {
    CCC_PRIVATE_FLAT_BITSET_BLOCK_BITS
        = (sizeof(*(struct CCC_Flat_bitset){}.blocks) * CHAR_BIT),
};
 
/*=========================     Private Interface   =========================*/
 
CCC_Result CCC_private_flat_bitset_reserve(
    struct CCC_Flat_bitset *, size_t, CCC_Allocator const *
);
CCC_Tribool
CCC_private_flat_bitset_set(struct CCC_Flat_bitset *, size_t, CCC_Tribool);
 
/*================================     Macros     ===========================*/
 
#define CCC_private_flat_bitset_block_count(private_bit_capacity)              \
    (((private_bit_capacity) + (CCC_PRIVATE_FLAT_BITSET_BLOCK_BITS - 1))       \
     / CCC_PRIVATE_FLAT_BITSET_BLOCK_BITS)
 
#define CCC_private_flat_bitset_block_bytes(private_bit_capacity)              \
    (sizeof(*(struct CCC_Flat_bitset){}.blocks)                                \
     * CCC_private_flat_bitset_block_count(private_bit_capacity))
 
#define CCC_private_flat_bitset_default()                                      \
    (struct CCC_Flat_bitset) {                                                 \
    }
 
#define CCC_private_flat_bitset_non_CCC_private_flat_bitset_default_size(      \
    private_cap, ...                                                           \
)                                                                              \
    __VA_ARGS__
#define CCC_private_flat_bitset_default_size(private_cap, ...) private_cap
#define CCC_private_flat_bitset_optional_size(private_cap, ...)                \
    __VA_OPT__(CCC_private_flat_bitset_non_)                                   \
    ##CCC_private_flat_bitset_default_size(private_cap, __VA_ARGS__)
 
#define CCC_private_flat_bitset_for(                                           \
    private_cap, private_count, private_bitblock_pointer                       \
)                                                                              \
    (struct CCC_Flat_bitset) {                                                 \
        .blocks = memset(                                                      \
            (private_bitblock_pointer),                                        \
            0,                                                                 \
            CCC_private_flat_bitset_block_bytes(private_cap)                   \
        ),                                                                     \
        .count = (private_count), .capacity = (private_cap),                   \
    }
 
#define CCC_private_flat_bitset_from(                                          \
    private_allocator,                                                         \
    private_start_index,                                                       \
    private_count,                                                             \
    private_on_char,                                                           \
    private_string,                                                            \
    ...                                                                        \
)                                                                              \
    (struct { struct CCC_Flat_bitset private; }){(__extension__({              \
        struct CCC_Flat_bitset private_bitset                                  \
            = CCC_private_flat_bitset_default();                               \
        size_t const private_cap = CCC_private_flat_bitset_optional_size(      \
            (private_count), __VA_ARGS__                                       \
        );                                                                     \
        size_t private_index = (private_start_index);                          \
        if (CCC_private_flat_bitset_reserve(                                   \
                &private_bitset,                                               \
                private_cap < private_count ? private_count : private_cap,     \
                &private_allocator                                             \
            )                                                                  \
            == CCC_RESULT_OK) {                                                \
            private_bitset.count = private_count;                              \
            while (private_index < private_count                               \
                   && private_string[private_index]) {                         \
                (void)CCC_private_flat_bitset_set(                             \
                    &private_bitset,                                           \
                    private_index,                                             \
                    (CCC_Tribool)(private_string[private_index]                \
                                  == private_on_char)                          \
                );                                                             \
                ++private_index;                                               \
            }                                                                  \
            private_bitset.count = private_index;                              \
        }                                                                      \
        private_bitset;                                                        \
    }))}.private
 
#define CCC_private_flat_bitset_with_capacity(                                 \
    private_allocate, private_cap, ...                                         \
)                                                                              \
    (struct { struct CCC_Flat_bitset private; }){(__extension__({              \
        struct CCC_Flat_bitset private_bitset                                  \
            = CCC_private_flat_bitset_default();                               \
        size_t const private_count = CCC_private_flat_bitset_optional_size(    \
            (private_cap), __VA_ARGS__                                         \
        );                                                                     \
        if (CCC_private_flat_bitset_reserve(                                   \
                &private_bitset, private_cap, &private_allocate                \
            )                                                                  \
            == CCC_RESULT_OK) {                                                \
            private_bitset.count = private_count;                              \
        }                                                                      \
        private_bitset;                                                        \
    }))}.private
 
#if defined(__clang__) || defined(__llvm__)
#    define CCC_private_flat_bitset_count_check_storage_for(                   \
        private_count,                                                         \
        private_bit_compound_literal,                                          \
        private_optional_storage_specifier...                                  \
    )                                                                          \
        (private_optional_storage_specifier struct {                           \
            static_assert(                                                     \
                sizeof(private_bit_compound_literal),                          \
                "Specify non-zero capacity of bits."                           \
            );                                                                 \
            static_assert(                                                     \
                sizeof(*(private_bit_compound_literal)) == sizeof(CCC_Bit),    \
                "CCC_flat_bitset_storage_for and "                             \
                "CCC_flat_bitset_with_storage only "                           \
                "accept "                                                      \
                "a (CCC_Bit[N]){} compound literal array as an argument. Do "  \
                "not "                                                         \
                "use CCC_flat_bitset_storage_for as an argument to "           \
                "CCC_flat_bitset_with_storage."                                \
            );                                                                 \
            static_assert(                                                     \
                (private_count) <= sizeof(private_bit_compound_literal),       \
                "Bit count is less than or equal to capacity."                 \
            );                                                                 \
            typeof(*(struct CCC_Flat_bitset){}.blocks) private                 \
                [CCC_private_flat_bitset_block_count(                          \
                    sizeof(private_bit_compound_literal)                       \
                )];                                                            \
        }){}                                                                   \
            .private
 
#    define CCC_private_flat_bitset_storage_for(                               \
        private_bit_compound_literal, private_optional_storage_specifier...    \
    )                                                                          \
        CCC_private_flat_bitset_count_check_storage_for(                       \
            0,                                                                 \
            private_bit_compound_literal,                                      \
            private_optional_storage_specifier                                 \
        )
 
#else
#    define CCC_private_flat_bitset_count_check_storage_for(                   \
        private_count,                                                         \
        private_bit_compound_literal,                                          \
        private_optional_storage_specifier...                                  \
    )                                                                          \
        (typeof (                                                              \
            *(struct CCC_Flat_bitset){}.blocks                                 \
        )[CCC_private_flat_bitset_block_count(                                 \
            sizeof(private_bit_compound_literal)                               \
        )]) {                                                                  \
        }
 
#    define CCC_private_flat_bitset_storage_for(                               \
        private_bit_compound_literal, private_optional_storage_specifier...    \
    )                                                                          \
        CCC_private_flat_bitset_count_check_storage_for(                       \
            0,                                                                 \
            private_bit_compound_literal,                                      \
            private_optional_storage_specifier                                 \
        )
#endif
 
#define CCC_private_flat_bitset_with_storage(                                  \
    private_count,                                                             \
    private_compound_literal_array,                                            \
    private_optional_storage_specifier...                                      \
)                                                                              \
    (struct CCC_Flat_bitset) {                                                 \
        .blocks = CCC_private_flat_bitset_count_check_storage_for(             \
            private_count,                                                     \
            private_compound_literal_array,                                    \
            private_optional_storage_specifier                                 \
        ),                                                                     \
        .count = (private_count),                                              \
        .capacity = CCC_private_flat_bitset_block_count(                       \
                        sizeof(private_compound_literal_array)                 \
                    )                                                          \
                  * sizeof(*(struct CCC_Flat_bitset){}.blocks) * CHAR_BIT,     \
    }
 
#endif /* CCC_PRIVATE_BITSET */