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 + 1)
#define	INVARIANT_CHECK(self)
#define	ITER_CONST   NS(SELF, iter_const)
#define	ITER   NS(SELF, iter)

Typedefs
typedef INDEX_TYPE	index_t
typedef INDEX_TYPE	item

Functions
static INDEX_TYPE	max_index ()
static INDEX_TYPE	min_index ()
static SELF	new ()
static bool	try_set (SELF *self, INDEX_TYPE index, bool value)
static void	set (SELF *self, INDEX_TYPE index, bool value)
static bool	get (SELF const *self, INDEX_TYPE index)
static void	debug (SELF const *self, dc_debug_fmt fmt, FILE *stream)
static SELF	clone (SELF const *self)
static INDEX_TYPE	size (SELF const *self)
static void	delete (SELF *self)
static bool	empty_item (INDEX_TYPE const *item)
static INDEX_TYPE	next (ITER_CONST *iter)
static ITER_CONST	get_iter_const (SELF const *self)
static INDEX_TYPE	next (ITER *iter)
static ITER	get_iter (SELF *self)
	DC_TRAIT_BITSET (SELF)

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 + 1)

Definition at line 27 of file template.h.

INVARIANT_CHECK

#define INVARIANT_CHECK

(

self

)

Value:

DC_ASSUME(self);

Definition at line 44 of file template.h.

ITER

#define ITER   NS(SELF, iter)

Definition at line 179 of file template.h.

ITER_CONST

#define ITER_CONST   NS(SELF, iter_const)

Definition at line 133 of file template.h.

Typedef Documentation

index_t

typedef INDEX_TYPE index_t

Definition at line 32 of file template.h.

item

typedef INDEX_TYPE item

Definition at line 139 of file template.h.

Function Documentation

clone()

SELF clone ( SELF const * self )

static

Definition at line 110 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_TRAIT_BITSET()

DC_TRAIT_BITSET

(

SELF

)

debug()

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

static

Definition at line 90 of file template.h.

                                                                              {
    fprintf(stream, EXPAND_STRING(SELF) "@%p {\n", self);
    fmt = dc_debug_fmt_scope_begin(fmt);
 
    dc_debug_fmt_print(fmt, stream, "blocks: [");
    fmt = dc_debug_fmt_scope_begin(fmt);
    for (INDEX_TYPE index = 0; index < EXCLUSIVE_END_INDEX; index++) {
        if (NS(SELF, get)(self, index)) {
            dc_debug_fmt_print(fmt, stream, "(byte: %lu, offset: %lu, index: %lu)",
                               (size_t)DC_BITSET_STATIC_INDEX_TO_BYTES(index),
                               (size_t)DC_BITSET_STATIC_INDEX_TO_OFFSET(index), (size_t)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()

void delete ( SELF * self )

static

Definition at line 131 of file template.h.

{ INVARIANT_CHECK(self); }

empty_item()

bool empty_item ( INDEX_TYPE const * item )

static

Definition at line 141 of file template.h.

                                                               {
    return *item == EXCLUSIVE_END_INDEX;
}

get()

bool get ( SELF const * self, INDEX_TYPE index )

static

Definition at line 79 of file template.h.

                                                              {
    INVARIANT_CHECK(self);
 
    DC_ASSERT(index < EXCLUSIVE_END_INDEX);
 
    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()

ITER get_iter ( SELF * self )

static

Definition at line 206 of file template.h.

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

get_iter_const()

ITER_CONST get_iter_const ( SELF const * self )

static

Definition at line 162 of file template.h.

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

max_index()

INDEX_TYPE max_index ( )

static

Definition at line 34 of file template.h.

{ return EXCLUSIVE_END_INDEX - 1; }

min_index()

INDEX_TYPE min_index ( )

static

Definition at line 36 of file template.h.

{ return 0; }

new()

SELF new ( )

static

Definition at line 46 of file template.h.

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

next() [1/2]

INDEX_TYPE next ( ITER * iter )

static

Definition at line 189 of file template.h.

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

next() [2/2]

INDEX_TYPE next ( ITER_CONST * iter )

static

Definition at line 145 of file template.h.

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

set()

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

static

Definition at line 74 of file template.h.

                                                                    {
    INVARIANT_CHECK(self);
    DC_ASSERT(NS(SELF, try_set)(self, index, value));
}

size()

INDEX_TYPE size ( SELF const * self )

static

Definition at line 120 of file template.h.

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

try_set()

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

static

Definition at line 54 of file template.h.

                                                                        {
    INVARIANT_CHECK(self);
    mutation_tracker_mutate(&self->iterator_invalidation_tracker);
 
    if (index >= EXCLUSIVE_END_INDEX) {
        return false;
    }
 
    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;
}