template.h File Reference

#include <derive-c/core/includes/def.h>
#include "includes.h"
#include <derive-c/core/alloc/def.h>
#include <derive-c/core/self/def.h>
#include <derive-c/core/index/bits_to_type/def.h>
#include <derive-c/core/index/type_to_strong/def.h>
#include <derive-c/utils/slot/template.h>
#include <derive-c/core/index/type_to_strong/undef.h>
#include <derive-c/core/index/bits_to_type/undef.h>
#include <derive-c/core/self/undef.h>
#include <derive-c/core/alloc/undef.h>
#include <derive-c/core/includes/undef.h>

Go to the source code of this file.

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

Macros
#define	INDEX_BITS   8
#define	BLOCK_INDEX_BITS   7
#define	VALUE   value_t
#define	VALUE_DELETE   value_delete
#define	VALUE_CLONE   value_clone
#define	VALUE_DEBUG   value_debug
#define	SLOT   NS(NAME, slot)
#define	SLOT_INDEX_TYPE   INDEX_TYPE
#define	SLOT_VALUE   VALUE
#define	SLOT_VALUE_CLONE   VALUE_CLONE
#define	SLOT_VALUE_CLONE   VALUE_CLONE
#define	SLOT_VALUE_DELETE   VALUE_DELETE
#define	INTERNAL_NAME   SLOT
#define	INVARIANT_CHECK(self)
#define	ITER   NS(SELF, iter)
#define	IV_PAIR   NS(ITER, item)
#define	ITER_INVARIANT_CHECK(iter)
#define	ITER_CONST   NS(SELF, iter_const)
#define	IV_PAIR_CONST   NS(ITER_CONST, item)
#define	ITER_CONST_INVARIANT_CHECK(iter)

Typedefs
typedef VALUE	value_t
typedef ALLOC	alloc_t
typedef SLOT	PRIV(block)[DC_ARENA_CHUNKED_BLOCK_SIZE(BLOCK_INDEX_BITS)]

Functions
	DC_STATIC_ASSERT (BLOCK_INDEX_BITS > 0, "Cannot have zero block index bits")
	DC_STATIC_ASSERT (INDEX_BITS > 0, "Cannot have zero index bits")
	DC_STATIC_ASSERT (INDEX_BITS > BLOCK_INDEX_BITS, "The number of bits for offset within a block must be " "less than the number of bits used for an index")
static void	VALUE_DELETE (value_t *)
static value_t	VALUE_CLONE (value_t const *self)
static void	VALUE_DEBUG (VALUE const *, dc_debug_fmt, FILE *)
	DC_STATIC_ASSERT (sizeof(VALUE), "VALUE must be a non-zero sized type")
static DC_PUBLIC SELF	new (ref alloc_ref)
static DC_PUBLIC INDEX	insert (SELF *self, VALUE value)
static DC_PUBLIC VALUE const *	try_read (SELF const *self, INDEX index)
static DC_PUBLIC VALUE const *	read (SELF const *self, INDEX index)
static DC_PUBLIC VALUE *	try_write (SELF *self, INDEX index)
static DC_PUBLIC VALUE *	write (SELF *self, INDEX index)
static DC_PUBLIC SELF	clone (SELF const *self)
static DC_PUBLIC size_t	size (SELF const *self)
static DC_PUBLIC bool	full (SELF const *self)
static DC_PUBLIC bool	try_remove (SELF *self, INDEX index, VALUE *destination)
static DC_PUBLIC VALUE	remove (SELF *self, INDEX index)
static DC_PUBLIC INDEX_TYPE PRIV	next_index_value (SELF const *self, INDEX_TYPE from_index)
static DC_PUBLIC IV_PAIR	iv_empty ()
static DC_PUBLIC bool	empty_item (IV_PAIR const *item)
static DC_PUBLIC bool	empty (ITER const *iter)
static DC_PUBLIC IV_PAIR	next (ITER *iter)
static DC_PUBLIC ITER	get_iter (SELF *self)
static DC_PUBLIC void	delete (SELF *self)
static DC_PUBLIC IV_PAIR_CONST	iv_const_empty ()
static DC_PUBLIC bool	empty_item (IV_PAIR_CONST const *item)
static DC_PUBLIC bool	empty (ITER_CONST const *iter)
static DC_PUBLIC IV_PAIR_CONST	next (ITER_CONST *iter)
static DC_PUBLIC ITER_CONST	get_iter_const (SELF const *self)
static DC_PUBLIC void	debug (SELF const *self, dc_debug_fmt fmt, FILE *stream)
	DC_TRAIT_ARENA (SELF)

Variables
static DC_PUBLIC const size_t	max_entries = MAX_INDEX

Macro Definition Documentation

BLOCK_INDEX_BITS

#define BLOCK_INDEX_BITS   7

Definition at line 20 of file template.h.

INDEX_BITS

#define INDEX_BITS   8

Definition at line 13 of file template.h.

INTERNAL_NAME

#define INTERNAL_NAME   SLOT

Definition at line 72 of file template.h.

INVARIANT_CHECK

#define INVARIANT_CHECK

(

self

)

Value:

    DC_ASSUME(self);                                                                               \
    DC_ASSUME(((self))->count <= MAX_INDEX);                                                       \
    DC_ASSUME(((self)->block_current_exclusive_end) <=                                             \
              DC_ARENA_CHUNKED_BLOCK_SIZE(BLOCK_INDEX_BITS));                                      \
    DC_ASSUME(DC_WHEN((self)->free_list == INDEX_NONE,                                             \
                      (self)->count ==                                                             \
                          (DC_ARENA_CHUNKED_BLOCK_SIZE(BLOCK_INDEX_BITS) * (self)->block_current + \
                           (self)->block_current_exclusive_end)),                                  \
              "All slots are full if the free list is empty");

Definition at line 90 of file template.h.

#define INVARIANT_CHECK(self)                                                                      \
    DC_ASSUME(self);                                                                               \
    DC_ASSUME(((self))->count <= MAX_INDEX);                                                       \
    DC_ASSUME(((self)->block_current_exclusive_end) <=                                             \
              DC_ARENA_CHUNKED_BLOCK_SIZE(BLOCK_INDEX_BITS));                                      \
    DC_ASSUME(DC_WHEN((self)->free_list == INDEX_NONE,                                             \
                      (self)->count ==                                                             \
                          (DC_ARENA_CHUNKED_BLOCK_SIZE(BLOCK_INDEX_BITS) * (self)->block_current + \
                           (self)->block_current_exclusive_end)),                                  \
              "All slots are full if the free list is empty");

ITER

#define ITER   NS(SELF, iter)

Definition at line 322 of file template.h.

ITER_CONST

#define ITER_CONST   NS(SELF, iter_const)

Definition at line 411 of file template.h.

ITER_CONST_INVARIANT_CHECK

#define ITER_CONST_INVARIANT_CHECK

(

iter

)

Value:

    DC_ASSUME(iter);                                                                               \
    DC_DEBUG_ASSERT(                                                                               \
        DC_WHEN((iter)->next_index != INDEX_NONE,                                                  \
                NS(SELF, try_read)(iter->arena, (INDEX){.index = (iter)->next_index}) != NULL),    \
        "The next index is either valid, or the iterator is empty");

Definition at line 420 of file template.h.

#define ITER_CONST_INVARIANT_CHECK(iter)                                                           \
    DC_ASSUME(iter);                                                                               \
    DC_DEBUG_ASSERT(                                                                               \
        DC_WHEN((iter)->next_index != INDEX_NONE,                                                  \
                NS(SELF, try_read)(iter->arena, (INDEX){.index = (iter)->next_index}) != NULL),    \
        "The next index is either valid, or the iterator is empty");

ITER_INVARIANT_CHECK

#define ITER_INVARIANT_CHECK

(

iter

)

Value:

    DC_ASSUME(iter);                                                                               \
    DC_DEBUG_ASSERT(                                                                               \
        DC_WHEN((iter)->next_index != INDEX_NONE,                                                  \
                NS(SELF, try_read)(iter->arena, (INDEX){.index = (iter)->next_index}) != NULL),    \
        "The next index is either valid, or the iterator is empty");

Definition at line 331 of file template.h.

#define ITER_INVARIANT_CHECK(iter)                                                                 \
    DC_ASSUME(iter);                                                                               \
    DC_DEBUG_ASSERT(                                                                               \
        DC_WHEN((iter)->next_index != INDEX_NONE,                                                  \
                NS(SELF, try_read)(iter->arena, (INDEX){.index = (iter)->next_index}) != NULL),    \
        "The next index is either valid, or the iterator is empty");

IV_PAIR

#define IV_PAIR   NS(ITER, item)

Definition at line 323 of file template.h.

IV_PAIR_CONST

#define IV_PAIR_CONST   NS(ITER_CONST, item)

Definition at line 412 of file template.h.

SLOT

#define SLOT   NS(NAME, slot)

Definition at line 65 of file template.h.

SLOT_INDEX_TYPE

#define SLOT_INDEX_TYPE   INDEX_TYPE

Definition at line 67 of file template.h.

SLOT_VALUE

#define SLOT_VALUE   VALUE

Definition at line 68 of file template.h.

SLOT_VALUE_CLONE [1/2]

#define SLOT_VALUE_CLONE   VALUE_CLONE

Definition at line 69 of file template.h.

SLOT_VALUE_CLONE [2/2]

#define SLOT_VALUE_CLONE   VALUE_CLONE

Definition at line 69 of file template.h.

SLOT_VALUE_DELETE

#define SLOT_VALUE_DELETE   VALUE_DELETE

Definition at line 71 of file template.h.

VALUE

#define VALUE   value_t

Definition at line 33 of file template.h.

VALUE_CLONE

#define VALUE_CLONE   value_clone

Definition at line 39 of file template.h.

VALUE_DEBUG

#define VALUE_DEBUG   value_debug

Definition at line 41 of file template.h.

VALUE_DELETE

#define VALUE_DELETE   value_delete

Definition at line 37 of file template.h.

Typedef Documentation

alloc_t

typedef ALLOC alloc_t

Definition at line 63 of file template.h.

PRIV

typedef SLOT PRIV(block)[DC_ARENA_CHUNKED_BLOCK_SIZE(BLOCK_INDEX_BITS)]

Definition at line 75 of file template.h.

value_t

typedef VALUE value_t

Definition at line 62 of file template.h.

Function Documentation

clone()

DC_PUBLIC SELF clone ( SELF const * self )

static

Definition at line 215 of file template.h.

                                                        {
    INVARIANT_CHECK(self);
 
    PRIV(NS(SELF, block))** blocks = (PRIV(NS(SELF, block))**)NS(ALLOC, allocate_uninit)(
        self->alloc_ref, sizeof(PRIV(NS(SELF, block))*) * (self->block_current + 1));
 
    for (INDEX_TYPE b = 0; b <= self->block_current; b++) {
        blocks[b] = (PRIV(NS(SELF, block))*)NS(ALLOC, allocate_uninit)(
            self->alloc_ref, sizeof(PRIV(NS(SELF, block))));
    }
 
    for (INDEX_TYPE b = 0; b < self->block_current; b++) {
        PRIV(NS(SELF, block))* to_block = blocks[b];
        PRIV(NS(SELF, block)) const* from_block = self->blocks[b];
        for (INDEX_TYPE i = 0; i < DC_ARENA_CHUNKED_BLOCK_SIZE(BLOCK_INDEX_BITS); i++) {
            NS(SLOT, clone_from)(&(*from_block)[i], &(*to_block)[i]);
        }
    }
 
    PRIV(NS(SELF, block))* to_current_block = blocks[self->block_current];
    PRIV(NS(SELF, block)) const* from_current_block = self->blocks[self->block_current];
    for (INDEX_TYPE i = 0; i < self->block_current_exclusive_end; i++) {
        NS(SLOT, clone_from)(&(*from_current_block)[i], &(*to_current_block)[i]);
    }
 
    return (SELF){
        .count = self->count,
        .free_list = self->free_list,
        .blocks = blocks,
        .block_current = self->block_current,
        .block_current_exclusive_end = self->block_current_exclusive_end,
        .alloc_ref = self->alloc_ref,
        .derive_c_arena_basic = dc_gdb_marker_new(),
        .iterator_invalidation_tracker = mutation_tracker_new(),
    };
}

DC_STATIC_ASSERT() [1/4]

DC_STATIC_ASSERT	(	BLOCK_INDEX_BITS	,
		0	,
		"Cannot have zero block index bits"	)

DC_STATIC_ASSERT() [2/4]

DC_STATIC_ASSERT	(	INDEX_BITS	,
		0	,
		"Cannot have zero index bits"	)

DC_STATIC_ASSERT() [3/4]

DC_STATIC_ASSERT	(	INDEX_BITS	,
		BLOCK_INDEX_BITS	,
		"The number of bits for offset within a block must be " "less than the number of bits used for an index"	)

DC_STATIC_ASSERT() [4/4]

DC_STATIC_ASSERT	(	sizeof(VALUE)	,
		"VALUE must be a non-zero sized type"	)

DC_TRAIT_ARENA()

DC_TRAIT_ARENA

(

SELF

)

debug()

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

static

Definition at line 482 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, "count: %lu,\n", self->count);
    dc_debug_fmt_print(fmt, stream, "free_list: %lu,\n", (size_t)self->free_list);
 
    dc_debug_fmt_print(fmt, stream, "alloc: ");
    NS(ALLOC, debug)(NS(NS(ALLOC, ref), deref)(self->alloc_ref), fmt, stream);
    fprintf(stream, ",\n");
 
    dc_debug_fmt_print(fmt, stream, "current_block: %lu\n", (size_t)self->block_current);
    dc_debug_fmt_print(fmt, stream, "block_current_exclusive_end: %lu\n",
                       (size_t)self->block_current_exclusive_end);
    dc_debug_fmt_print(fmt, stream, "blocks: [\n");
    fmt = dc_debug_fmt_scope_begin(fmt);
 
    for (INDEX_TYPE b = 0; b <= self->block_current; b++) {
 
        dc_debug_fmt_print(fmt, stream, "block[%lu]: @%p [\n", (size_t)b, (void*)self->blocks[b]);
        fmt = dc_debug_fmt_scope_begin(fmt);
 
        INDEX_TYPE block_entry_exclusive_end = b == self->block_current
                                                   ? self->block_current_exclusive_end
                                                   : DC_ARENA_CHUNKED_BLOCK_SIZE(BLOCK_INDEX_BITS);
 
        for (INDEX_TYPE i = 0; i < block_entry_exclusive_end; i++) {
            /* Previously used self->blocks[b][i] which computes wrong address.
               Use the dereference-then-index form to get the SLOT. */
            SLOT* entry = &(*self->blocks[b])[i];
 
            if (entry->present) {
                dc_debug_fmt_print(
                    fmt, stream, "[index=%lu] ",
                    (size_t)DC_ARENA_CHUNKED_BLOCK_OFFSET_TO_INDEX(b, i, BLOCK_INDEX_BITS));
                VALUE_DEBUG(&entry->value, fmt, stream);
                fprintf(stream, ",\n");
            } else {
                dc_debug_fmt_print(
                    fmt, stream, "[index=%lu]{ next_free=%lu }\n",
                    (size_t)DC_ARENA_CHUNKED_BLOCK_OFFSET_TO_INDEX(b, i, BLOCK_INDEX_BITS),
                    (size_t)entry->next_free);
            }
        }
 
        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, "],\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 391 of file template.h.

                                                   {
    INVARIANT_CHECK(self);
    ITER iter = NS(SELF, get_iter)(self);
 
    for (IV_PAIR entry = NS(ITER, next)(&iter); !NS(ITER, empty_item)(&entry);
         entry = NS(ITER, next)(&iter)) {
        VALUE_DELETE(entry.value);
    }
 
    for (INDEX_TYPE b = 0; b <= self->block_current; b++) {
        NS(ALLOC, deallocate)(self->alloc_ref, self->blocks[b], sizeof(PRIV(NS(SELF, block))));
    }
    NS(ALLOC, deallocate)(self->alloc_ref, (void*)self->blocks,
                          self->block_current * sizeof(PRIV(NS(SELF, block))*));
}

empty() [1/2]

DC_PUBLIC bool empty ( ITER const * iter )

static

Definition at line 349 of file template.h.

                                                        {
    ITER_INVARIANT_CHECK(iter);
    mutation_version_check(&iter->version);
    return iter->next_index == INDEX_NONE;
}

empty() [2/2]

DC_PUBLIC bool empty ( ITER_CONST const * iter )

static

Definition at line 440 of file template.h.

                                                                    {
    ITER_CONST_INVARIANT_CHECK(iter);
    mutation_version_check(&iter->version);
    return iter->next_index == INDEX_NONE;
}

empty_item() [1/2]

DC_PUBLIC bool empty_item ( IV_PAIR const * item )

static

Definition at line 347 of file template.h.

{ return item->value == NULL; }

empty_item() [2/2]

DC_PUBLIC bool empty_item ( IV_PAIR_CONST const * item )

static

Definition at line 436 of file template.h.

                                                                            {
    return item->value == NULL;
}

full()

DC_PUBLIC bool full ( SELF const * self )

static

Definition at line 257 of file template.h.

                                                       {
    INVARIANT_CHECK(self);
    return self->count < MAX_INDEX;
}

get_iter()

DC_PUBLIC ITER get_iter ( SELF * self )

static

Definition at line 373 of file template.h.

                                                     {
    INVARIANT_CHECK(self);
 
    // Check if index 0 is present, otherwise find the next valid index
    INDEX_TYPE first_index;
    if (self->block_current_exclusive_end > 0 && (*self->blocks[0])[0].present) {
        first_index = 0;
    } else {
        first_index = PRIV(NS(SELF, next_index_value))(self, 0);
    }
 
    return (ITER){
        .arena = self,
        .next_index = first_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 464 of file template.h.

                                                                       {
    INVARIANT_CHECK(self);
 
    // Check if index 0 is present, otherwise find the next valid index
    INDEX_TYPE first_index;
    if (self->block_current_exclusive_end > 0 && (*self->blocks[0])[0].present) {
        first_index = 0;
    } else {
        first_index = PRIV(NS(SELF, next_index_value))(self, 0);
    }
 
    return (ITER_CONST){
        .arena = self,
        .next_index = first_index,
        .version = mutation_tracker_get(&self->iterator_invalidation_tracker),
    };
}

insert()

DC_PUBLIC INDEX insert ( SELF * self, VALUE value )

static

Definition at line 126 of file template.h.

                                                                 {
    INVARIANT_CHECK(self);
    mutation_tracker_mutate(&self->iterator_invalidation_tracker);
    DC_ASSERT(self->count < MAX_INDEX,
              "Arena is full, cannot insert {count=%lu, max_index=%lu, value=%s}",
              (size_t)self->count, (size_t)MAX_INDEX, DC_DEBUG(VALUE_DEBUG, &value));
 
    if (self->free_list != INDEX_NONE) {
        INDEX_TYPE free_index = self->free_list;
        INDEX_TYPE block = DC_ARENA_CHUNKED_INDEX_TO_BLOCK(free_index, BLOCK_INDEX_BITS);
        INDEX_TYPE offset = DC_ARENA_CHUNKED_INDEX_TO_OFFSET(free_index, BLOCK_INDEX_BITS);
 
        SLOT* slot = &(*self->blocks[block])[offset];
 
        DC_ASSUME(!slot->present);
        self->free_list = slot->next_free;
 
        NS(SLOT, fill)(slot, value);
 
        self->count++;
        return (INDEX){.index = free_index};
    }
 
    if (self->block_current_exclusive_end == DC_ARENA_CHUNKED_BLOCK_SIZE(BLOCK_INDEX_BITS)) {
        self->block_current++;
        self->block_current_exclusive_end = 0;
 
        size_t blocks_current_size = self->block_current * sizeof(PRIV(NS(SELF, block))*);
        size_t blocks_new_size = blocks_current_size + sizeof(PRIV(NS(SELF, block))*);
 
        self->blocks = (PRIV(NS(SELF, block))**)NS(ALLOC, reallocate)(
            self->alloc_ref, (void*)self->blocks, blocks_current_size, blocks_new_size);
 
        PRIV(NS(SELF, block))* new_block = (PRIV(NS(SELF, block))*)NS(ALLOC, allocate_uninit)(
            self->alloc_ref, sizeof(PRIV(NS(SELF, block))));
 
        self->blocks[self->block_current] = new_block;
 
        for (size_t offset = 0; offset < DC_ARENA_CHUNKED_BLOCK_SIZE(BLOCK_INDEX_BITS); offset++) {
            NS(SLOT, memory_tracker_empty)(&(*new_block)[offset]);
        }
    }
 
    SLOT* slot = &(*self->blocks[self->block_current])[self->block_current_exclusive_end];
    NS(SLOT, fill)(slot, value);
 
    INDEX_TYPE index = (INDEX_TYPE)DC_ARENA_CHUNKED_BLOCK_OFFSET_TO_INDEX(
        self->block_current, self->block_current_exclusive_end, BLOCK_INDEX_BITS);
    self->count++;
    self->block_current_exclusive_end++;
 
    return (INDEX){.index = index};
}

iv_const_empty()

DC_PUBLIC IV_PAIR_CONST iv_const_empty ( )

static

Definition at line 432 of file template.h.

                                                          {
    return (IV_PAIR_CONST){.index = (INDEX){.index = INDEX_NONE}, .value = NULL};
}

iv_empty()

DC_PUBLIC IV_PAIR iv_empty ( )

static

Definition at line 343 of file template.h.

                                              {
    return (IV_PAIR){.index = (INDEX){.index = INDEX_NONE}, .value = NULL};
}

new()

DC_PUBLIC SELF new ( ref alloc_ref )

static

Definition at line 101 of file template.h.

                                                              {
    PRIV(NS(SELF, block))* first_block = (PRIV(NS(SELF, block))*)NS(ALLOC, allocate_uninit)(
        alloc_ref, sizeof(PRIV(NS(SELF, block))));
    PRIV(NS(SELF, block))** blocks = (PRIV(NS(SELF, block))**)NS(ALLOC, allocate_uninit)(
        alloc_ref, sizeof(PRIV(NS(SELF, block))*));
 
    blocks[0] = first_block;
 
    for (INDEX_TYPE offset = 0; offset < DC_ARENA_CHUNKED_BLOCK_SIZE(BLOCK_INDEX_BITS); offset++) {
        /* Properly index the slots within the allocated block */
        NS(SLOT, memory_tracker_empty)(&(*first_block)[offset]);
    }
 
    return (SELF){
        .count = 0,
        .free_list = INDEX_NONE,
        .blocks = blocks,
        .block_current = 0,
        .block_current_exclusive_end = 0,
        .alloc_ref = alloc_ref,
        .derive_c_arena_basic = dc_gdb_marker_new(),
        .iterator_invalidation_tracker = mutation_tracker_new(),
    };
}

next() [1/2]

DC_PUBLIC IV_PAIR next ( ITER * iter )

static

Definition at line 355 of file template.h.

                                                    {
    ITER_INVARIANT_CHECK(iter);
    mutation_version_check(&iter->version);
 
    if (iter->next_index == INDEX_NONE) {
        return NS(SELF, iv_empty)();
    }
 
    INDEX index = {.index = iter->next_index};
    IV_PAIR result = (IV_PAIR){
        .index = index,
        .value = NS(SELF, write)(iter->arena, index),
    };
 
    iter->next_index = PRIV(NS(SELF, next_index_value))(iter->arena, iter->next_index);
    return result;
}

next() [2/2]

DC_PUBLIC IV_PAIR_CONST next ( ITER_CONST * iter )

static

Definition at line 446 of file template.h.

                                                                      {
    ITER_CONST_INVARIANT_CHECK(iter);
    mutation_version_check(&iter->version);
 
    if (iter->next_index == INDEX_NONE) {
        return NS(SELF, iv_const_empty)();
    }
 
    INDEX index = {.index = iter->next_index};
    IV_PAIR_CONST result = (IV_PAIR_CONST){
        .index = index,
        .value = NS(SELF, read)(iter->arena, index),
    };
 
    iter->next_index = PRIV(NS(SELF, next_index_value))(iter->arena, iter->next_index);
    return result;
}

next_index_value()

DC_PUBLIC INDEX_TYPE PRIV next_index_value ( SELF const * self, INDEX_TYPE from_index )

static

Definition at line 302 of file template.h.

                                                                                    {
    for (INDEX_TYPE next_index = from_index + 1;; next_index++) {
        INDEX_TYPE block = DC_ARENA_CHUNKED_INDEX_TO_BLOCK(next_index, BLOCK_INDEX_BITS);
        INDEX_TYPE offset = DC_ARENA_CHUNKED_INDEX_TO_OFFSET(next_index, BLOCK_INDEX_BITS);
 
        if (block > self->block_current ||
            (block == self->block_current && offset >= self->block_current_exclusive_end)) {
            return INDEX_NONE;
        }
 
        /* Fix wrong indexing: use &(*self->blocks[block])[offset] rather than
           self->blocks[block][offset] which indexes by block-sized strides. */
        SLOT* slot = &(*self->blocks[block])[offset];
        if (slot->present) {
            return next_index;
        }
    }
}

read()

DC_PUBLIC VALUE const * read ( SELF const * self, INDEX index )

static

Definition at line 199 of file template.h.

                                                                            {
    VALUE const* value = NS(SELF, try_read)(self, index);
    DC_ASSERT(value, "Cannot read item {index=%lu}", (size_t)index.index);
    return value;
}

remove()

DC_PUBLIC VALUE remove ( SELF * self, INDEX index )

static

Definition at line 292 of file template.h.

                                                                 {
    INVARIANT_CHECK(self);
    mutation_tracker_mutate(&self->iterator_invalidation_tracker);
 
    VALUE value;
    DC_ASSERT(NS(SELF, try_remove)(self, index, &value),
              "Failed to remove item, index not found {index=%lu}", (size_t)index.index);
    return value;
}

size()

DC_PUBLIC size_t size ( SELF const * self )

static

Examples

complex/prime_sieve.c.

Definition at line 252 of file template.h.

                                                         {
    INVARIANT_CHECK(self);
    return self->count;
}

try_read()

DC_PUBLIC VALUE const * try_read ( SELF const * self, INDEX index )

static

Definition at line 180 of file template.h.

                                                                                {
    INVARIANT_CHECK(self);
 
    INDEX_TYPE block = DC_ARENA_CHUNKED_INDEX_TO_BLOCK(index.index, BLOCK_INDEX_BITS);
    INDEX_TYPE offset = DC_ARENA_CHUNKED_INDEX_TO_OFFSET(index.index, BLOCK_INDEX_BITS);
 
    if (block > self->block_current ||
        (block == self->block_current && offset >= self->block_current_exclusive_end)) {
        return NULL;
    }
 
    SLOT* slot = &(*self->blocks[block])[offset];
 
    if (!slot->present) {
        return NULL;
    }
    return &slot->value;
}

try_remove()

DC_PUBLIC bool try_remove ( SELF * self, INDEX index, VALUE * destination )

static

Definition at line 264 of file template.h.

                                                                                        {
    INVARIANT_CHECK(self);
    mutation_tracker_mutate(&self->iterator_invalidation_tracker);
 
    INDEX_TYPE block = DC_ARENA_CHUNKED_INDEX_TO_BLOCK(index.index, BLOCK_INDEX_BITS);
    INDEX_TYPE offset = DC_ARENA_CHUNKED_INDEX_TO_OFFSET(index.index, BLOCK_INDEX_BITS);
 
    /* Only treat offset vs block_current_exclusive_end for the last block */
    if (block > self->block_current ||
        (block == self->block_current && offset >= self->block_current_exclusive_end)) {
        return false;
    }
 
    PRIV(NS(SELF, block))* current_block = self->blocks[block];
    SLOT* entry = &(*current_block)[offset];
 
    if (entry->present) {
        *destination = entry->value;
 
        NS(SLOT, set_empty)(entry, self->free_list);
 
        self->free_list = index.index;
        self->count--;
        return true;
    }
    return false;
}

try_write()

DC_PUBLIC VALUE * try_write ( SELF * self, INDEX index )

static

Definition at line 205 of file template.h.

                                                                     {
    return (VALUE*)NS(SELF, try_read)(self, index);
}

VALUE_CLONE()

value_t VALUE_CLONE ( value_t const * self )

static

Definition at line 40 of file template.h.

{ return *self; }

VALUE_DEBUG()

void VALUE_DEBUG ( VALUE const * , dc_debug_fmt , FILE *  )

static

Definition at line 42 of file template.h.

{}

VALUE_DELETE()

void VALUE_DELETE ( value_t * )

static

Definition at line 38 of file template.h.

{}

write()

DC_PUBLIC VALUE * write ( SELF * self, INDEX index )

static

Definition at line 209 of file template.h.

                                                                 {
    VALUE* value = NS(SELF, try_write)(self, index);
    DC_ASSERT(value, "Cannot write item {index=%lu}", (size_t)index.index);
    return value;
}

Variable Documentation

max_entries

DC_PUBLIC const size_t max_entries = MAX_INDEX

static

Definition at line 262 of file template.h.