template.h File Reference

#include <derive-c/core/includes/def.h>
#include "includes.h"
#include <derive-c/core/self/def.h>
#include <derive-c/core/index/capacity_to_bits/def.h>
#include <derive-c/core/index/bits_to_type/def.h>
#include <derive-c/core/index/bits_to_type/undef.h>
#include <derive-c/core/index/capacity_to_bits/undef.h>
#include <derive-c/core/self/undef.h>
#include <derive-c/core/includes/undef.h>

Go to the source code of this file.

Data Structures
struct	SELF
	An allocator that prints to stdout when it allocates or frees memory. More...
struct	ITER_CONST
struct	ITER

Macros
#define	EXCLUSIVE_END_INDEX   32
	A simple bitset for indexes [0, EXCLUSIVE_END_INDEX), statically allocated.
#define	INDICES_CAPACITY   EXCLUSIVE_END_INDEX
#define	INVARIANT_CHECK(self)
#define	ITER_INDEX_TYPE   INDEX_LARGER_TYPE
#define	ITER_CONST   NS(SELF, iter_const)
#define	ITER   NS(SELF, iter)

Typedefs
typedef INDEX_TYPE	index_t
typedef ITER_INDEX_TYPE	item

Functions
	DC_STATIC_ASSERT (EXCLUSIVE_END_INDEX > 0, DC_EXPAND_STRING(SELF) " EXCLUSIVE_END_INDEX must be larger than 0 for nonempty bitset")
static DC_PUBLIC SELF	new ()
static DC_PUBLIC bool	try_set (SELF *self, INDEX_TYPE index, bool value)
static DC_PUBLIC void	set (SELF *self, INDEX_TYPE index, bool value)
static DC_PUBLIC bool	get (SELF const *self, INDEX_TYPE index)
static DC_PUBLIC void	debug (SELF const *self, dc_debug_fmt fmt, FILE *stream)
static DC_PUBLIC SELF	clone (SELF const *self)
static DC_PUBLIC size_t	size (SELF const *self)
static DC_PUBLIC void	delete (SELF *self)
static DC_PUBLIC bool	empty_item (ITER_INDEX_TYPE const *item)
static DC_PUBLIC ITER_INDEX_TYPE	next (ITER_CONST *iter)
static DC_PUBLIC bool	empty (ITER_CONST const *iter)
static DC_PUBLIC ITER_CONST	get_iter_const (SELF const *self)
static DC_PUBLIC ITER_INDEX_TYPE	next (ITER *iter)
static DC_PUBLIC bool	empty (ITER const *iter)
static DC_PUBLIC ITER	get_iter (SELF *self)
	DC_TRAIT_BITSET (SELF)

Variables
DC_STATIC_CONSTANT INDEX_TYPE	max_index = EXCLUSIVE_END_INDEX - 1
DC_STATIC_CONSTANT INDEX_TYPE	min_index = 0

Macro Definition Documentation

EXCLUSIVE_END_INDEX

#define EXCLUSIVE_END_INDEX   32

A simple bitset for indexes [0, EXCLUSIVE_END_INDEX), statically allocated.

Definition at line 14 of file template.h.

INDICES_CAPACITY

#define INDICES_CAPACITY   EXCLUSIVE_END_INDEX

Definition at line 21 of file template.h.

INVARIANT_CHECK

#define INVARIANT_CHECK

(

self

)

Value:

DC_ASSUME(self);

Definition at line 37 of file template.h.

ITER

#define ITER   NS(SELF, iter)

Definition at line 199 of file template.h.

ITER_CONST

#define ITER_CONST   NS(SELF, iter_const)

Definition at line 147 of file template.h.

ITER_INDEX_TYPE

#define ITER_INDEX_TYPE   INDEX_LARGER_TYPE

Definition at line 144 of file template.h.

Typedef Documentation

index_t

typedef INDEX_TYPE index_t

Definition at line 26 of file template.h.

item

typedef ITER_INDEX_TYPE item

Definition at line 153 of file template.h.

Function Documentation

clone()

DC_PUBLIC SELF clone ( SELF const * self )

static

Definition at line 115 of file template.h.

                                                        {
    INVARIANT_CHECK(self);
    SELF new_self = (SELF){
        .derive_c_bitset_static = dc_gdb_marker_new(),
        .iterator_invalidation_tracker = mutation_tracker_new(),
    };
    memcpy(&new_self.bits, &self->bits, sizeof(self->bits));
    return new_self;
}

DC_STATIC_ASSERT()

DC_STATIC_ASSERT	(	EXCLUSIVE_END_INDEX	,
		0	,
		DC_EXPAND_STRING(SELF) " EXCLUSIVE_END_INDEX must be larger than 0 for nonempty bitset"	)

DC_TRAIT_BITSET()

DC_TRAIT_BITSET

(

SELF

)

debug()

DC_PUBLIC void debug ( SELF const * self, dc_debug_fmt fmt, FILE * stream )

static

Definition at line 95 of file template.h.

                                                                                        {
    fprintf(stream, DC_EXPAND_STRING(SELF) "@%p {\n", (void*)self);
    fmt = dc_debug_fmt_scope_begin(fmt);
 
    dc_debug_fmt_print(fmt, stream, "blocks: [\n");
    fmt = dc_debug_fmt_scope_begin(fmt);
    for (size_t index = 0; index < EXCLUSIVE_END_INDEX; index++) {
        if (NS(SELF, get)(self, (INDEX_TYPE)index)) {
            dc_debug_fmt_print(fmt, stream, "{ byte: %lu, offset: %lu, index: %lu},\n",
                               DC_BITSET_STATIC_INDEX_TO_BYTES(index),
                               DC_BITSET_STATIC_INDEX_TO_OFFSET(index), index);
        }
    }
    fmt = dc_debug_fmt_scope_end(fmt);
    dc_debug_fmt_print(fmt, stream, "],\n");
 
    fmt = dc_debug_fmt_scope_end(fmt);
    dc_debug_fmt_print(fmt, stream, "}");
}

delete()

DC_PUBLIC void delete ( SELF * self )

static

Definition at line 136 of file template.h.

{ INVARIANT_CHECK(self); }

empty() [1/2]

DC_PUBLIC bool empty ( ITER const * iter )

static

Definition at line 228 of file template.h.

                                                        {
    DC_ASSUME(iter);
    mutation_version_check(&iter->version);
    return iter->next_index >= EXCLUSIVE_END_INDEX;
}

empty() [2/2]

DC_PUBLIC bool empty ( ITER_CONST const * iter )

static

Definition at line 176 of file template.h.

                                                                    {
    DC_ASSUME(iter);
    mutation_version_check(&iter->version);
    return iter->next_index >= EXCLUSIVE_END_INDEX;
}

empty_item()

DC_PUBLIC bool empty_item ( ITER_INDEX_TYPE const * item )

static

Definition at line 155 of file template.h.

                                                                              {
    return *item == EXCLUSIVE_END_INDEX;
}

get()

DC_PUBLIC bool get ( SELF const * self, INDEX_TYPE index )

static

Definition at line 80 of file template.h.

                                                                        {
    INVARIANT_CHECK(self);
 
#if EXCLUSIVE_END_INDEX <= MAX_INDEX
    DC_ASSERT(index < EXCLUSIVE_END_INDEX,
              "Index out of bounds {index=%lu, exclusive_end_index=%d}", (size_t)index,
              EXCLUSIVE_END_INDEX);
#endif
 
    INDEX_TYPE byte = DC_BITSET_STATIC_INDEX_TO_BYTES(index);
    INDEX_TYPE offset = DC_BITSET_STATIC_INDEX_TO_OFFSET(index);
    uint8_t mask = DC_BITSET_STATIC_OFFSET_TO_MASK(offset);
    return (self->bits[byte] & mask) != 0;
}

get_iter()

DC_PUBLIC ITER get_iter ( SELF * self )

static

Definition at line 234 of file template.h.

                                                     {
    INVARIANT_CHECK(self);
 
    ITER_INDEX_TYPE next_index = 0;
    while (next_index < EXCLUSIVE_END_INDEX && !NS(SELF, get)(self, (INDEX_TYPE)next_index)) {
        next_index++;
    }
 
    return (ITER){
        .bitset = self,
        .next_index = next_index,
        .version = mutation_tracker_get(&self->iterator_invalidation_tracker),
    };
}

get_iter_const()

DC_PUBLIC ITER_CONST get_iter_const ( SELF const * self )

static

Definition at line 182 of file template.h.

                                                                       {
    INVARIANT_CHECK(self);
 
    ITER_INDEX_TYPE next_index = 0;
    while (next_index < EXCLUSIVE_END_INDEX && !NS(SELF, get)(self, (INDEX_TYPE)next_index)) {
        next_index++;
    }
 
    return (ITER_CONST){
        .bitset = self,
        .next_index = next_index,
        .version = mutation_tracker_get(&self->iterator_invalidation_tracker),
    };
}

new()

DC_PUBLIC SELF new ( )

static

Definition at line 39 of file template.h.

                                      {
    return (SELF){
        .bits = {},
        .derive_c_bitset_static = dc_gdb_marker_new(),
        .iterator_invalidation_tracker = mutation_tracker_new(),
    };
}

next() [1/2]

DC_PUBLIC ITER_INDEX_TYPE next ( ITER * iter )

static

Definition at line 211 of file template.h.

                                                            {
    DC_ASSUME(iter);
    mutation_version_check(&iter->version);
 
    if (iter->next_index == EXCLUSIVE_END_INDEX) {
        return EXCLUSIVE_END_INDEX;
    }
 
    ITER_INDEX_TYPE next_index = iter->next_index;
    iter->next_index++;
    while (iter->next_index < EXCLUSIVE_END_INDEX &&
           !NS(SELF, get)(iter->bitset, (INDEX_TYPE)iter->next_index)) {
        iter->next_index++;
    }
    return next_index;
}

next() [2/2]

DC_PUBLIC ITER_INDEX_TYPE next ( ITER_CONST * iter )

static

Definition at line 159 of file template.h.

                                                                        {
    DC_ASSUME(iter);
    mutation_version_check(&iter->version);
 
    if (iter->next_index == EXCLUSIVE_END_INDEX) {
        return EXCLUSIVE_END_INDEX;
    }
 
    ITER_INDEX_TYPE next_index = iter->next_index;
    iter->next_index++;
    while (iter->next_index < EXCLUSIVE_END_INDEX &&
           !NS(SELF, get)(iter->bitset, (INDEX_TYPE)iter->next_index)) {
        iter->next_index++;
    }
    return next_index;
}

set()

DC_PUBLIC void set ( SELF * self, INDEX_TYPE index, bool value )

static

Examples

container/set.c.

Definition at line 73 of file template.h.

                                                                              {
    INVARIANT_CHECK(self);
    DC_ASSERT(NS(SELF, try_set)(self, index, value),
              "Failed to set index {index=%lu, value=%d, exclusive_end_index=%d}", (size_t)index,
              value, EXCLUSIVE_END_INDEX);
}

size()

DC_PUBLIC size_t size ( SELF const * self )

static

Definition at line 125 of file template.h.

                                                         {
    size_t size = 0;
 
    for (INDEX_TYPE byte = 0;
         byte < (INDEX_TYPE)DC_BITSET_STATIC_CAPACITY_TO_BYTES(EXCLUSIVE_END_INDEX); byte++) {
        size += (uint32_t)__builtin_popcount((unsigned int)self->bits[byte]);
    }
 
    return size;
}

try_set()

DC_PUBLIC bool try_set ( SELF * self, INDEX_TYPE index, bool value )

static

Definition at line 47 of file template.h.

                                                                                  {
    INVARIANT_CHECK(self);
    mutation_tracker_mutate(&self->iterator_invalidation_tracker);
 
    // JUSTIFY: Only checking if the end index could be smaller than max
    //  - If exclusive end is 1 larger than the max index, this check does not work.
    //    e.g. exclusive end is 256. So index is uint8_t, which means we can never represent an
    //         incorrect index, so no check.
#if EXCLUSIVE_END_INDEX <= MAX_INDEX
    if (index >= EXCLUSIVE_END_INDEX) {
        return false;
    }
#endif
 
    INDEX_TYPE byte = DC_BITSET_STATIC_INDEX_TO_BYTES(index);
    INDEX_TYPE offset = DC_BITSET_STATIC_INDEX_TO_OFFSET(index);
    uint8_t mask = DC_BITSET_STATIC_OFFSET_TO_MASK(offset);
 
    if (value) {
        self->bits[byte] = self->bits[byte] | mask;
    } else {
        self->bits[byte] = self->bits[byte] & (~mask);
    }
    return true;
}

Variable Documentation

max_index

DC_STATIC_CONSTANT INDEX_TYPE max_index = EXCLUSIVE_END_INDEX - 1

Definition at line 28 of file template.h.

min_index

DC_STATIC_CONSTANT INDEX_TYPE min_index = 0

Definition at line 29 of file template.h.