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/self/undef.h>
#include <derive-c/core/includes/undef.h>

Go to the source code of this file.

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

Macros
#define	CAPACITY   32
	A statically allocated map that linearly looks up keys.
#define	KEY   map_key_t
#define	KEY_EQ   DC_MEM_EQ
#define	KEY_DELETE   DC_NO_DELETE
#define	KEY_CLONE   DC_COPY_CLONE
#define	KEY_DEBUG   DC_DEFAULT_DEBUG
#define	VALUE   value_t
#define	VALUE_DELETE   DC_NO_DELETE
#define	VALUE_CLONE   DC_COPY_CLONE
#define	VALUE_DEBUG   DC_DEFAULT_DEBUG
#define	ENTRY   NS(SELF, entry_t)
#define	INVARIANT_CHECK(self)
#define	ITER_CONST   NS(SELF, iter_const)
#define	KV_PAIR_CONST   NS(ITER_CONST, item)
#define	ITER   NS(SELF, iter)
#define	KV_PAIR   NS(ITER, item)

Typedefs
typedef int	KEY

Functions
	DC_STATIC_ASSERT (CAPACITY > 0, DC_EXPAND_STRING(SELF) " CAPACITY cannot be empty")
static DC_PUBLIC SELF	new ()
static DC_PUBLIC VALUE const *	try_read (SELF const *self, KEY key)
static DC_PUBLIC VALUE const *	read (SELF const *self, KEY key)
static DC_PUBLIC VALUE *	try_write (SELF *self, KEY key)
static DC_PUBLIC VALUE *	write (SELF *self, KEY key)
static DC_PUBLIC VALUE *	try_insert (SELF *self, KEY key, VALUE value)
static DC_PUBLIC VALUE *	insert (SELF *self, KEY key, VALUE value)
static DC_PUBLIC bool	try_remove (SELF *self, KEY key, VALUE *dest)
static DC_PUBLIC VALUE	remove (SELF *self, KEY key)
static DC_PUBLIC void	delete_entry (SELF *self, KEY key)
static DC_PUBLIC size_t	size (SELF const *self)
static DC_PUBLIC SELF	clone (SELF const *self)
static DC_PUBLIC void	delete (SELF *self)
static DC_PUBLIC void	debug (SELF const *self, dc_debug_fmt fmt, FILE *stream)
static DC_PUBLIC bool	empty_item (KV_PAIR_CONST const *item)
static DC_PUBLIC KV_PAIR_CONST	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 bool	empty_item (KV_PAIR const *item)
static DC_PUBLIC KV_PAIR	next (ITER *iter)
static DC_PUBLIC bool	empty (ITER const *iter)
static DC_PUBLIC ITER	get_iter (SELF *self)
	DC_TRAIT_MAP (SELF)

Variables
DC_STATIC_CONSTANT size_t	max_capacity = (size_t)CAPACITY

Macro Definition Documentation

CAPACITY

#define CAPACITY   32

A statically allocated map that linearly looks up keys.

Definition at line 14 of file template.h.

ENTRY

#define ENTRY   NS(SELF, entry_t)

Definition at line 68 of file template.h.

INVARIANT_CHECK

#define INVARIANT_CHECK

(

self

)

Value:

    DC_ASSUME(self);                                                                               \
    DC_ASSUME((self)->size <= CAPACITY);

Definition at line 84 of file template.h.

#define INVARIANT_CHECK(self)                                                                      \
    DC_ASSUME(self);                                                                               \
    DC_ASSUME((self)->size <= CAPACITY);

ITER

#define ITER   NS(SELF, iter)

Definition at line 280 of file template.h.

ITER_CONST

#define ITER_CONST   NS(SELF, iter_const)

Definition at line 227 of file template.h.

KEY

#define KEY   map_key_t

Definition at line 23 of file template.h.

KEY_CLONE

#define KEY_CLONE   DC_COPY_CLONE

Definition at line 36 of file template.h.

KEY_DEBUG

#define KEY_DEBUG   DC_DEFAULT_DEBUG

Definition at line 40 of file template.h.

KEY_DELETE

#define KEY_DELETE   DC_NO_DELETE

Definition at line 32 of file template.h.

KEY_EQ

#define KEY_EQ   DC_MEM_EQ

Definition at line 28 of file template.h.

KV_PAIR

#define KV_PAIR   NS(ITER, item)

Definition at line 281 of file template.h.

KV_PAIR_CONST

#define KV_PAIR_CONST   NS(ITER_CONST, item)

Definition at line 228 of file template.h.

VALUE

#define VALUE   value_t

Definition at line 50 of file template.h.

VALUE_CLONE

#define VALUE_CLONE   DC_COPY_CLONE

Definition at line 58 of file template.h.

VALUE_DEBUG

#define VALUE_DEBUG   DC_DEFAULT_DEBUG

Definition at line 62 of file template.h.

VALUE_DELETE

#define VALUE_DELETE   DC_NO_DELETE

Definition at line 54 of file template.h.

Typedef Documentation

KEY

typedef int KEY

Definition at line 24 of file template.h.

Function Documentation

clone()

DC_PUBLIC SELF clone ( SELF const * self )

static

Definition at line 182 of file template.h.

                                                        {
    INVARIANT_CHECK(self);
 
    SELF new_self = (SELF){
        .size = self->size,
        .derive_c_map_staticlinear = dc_gdb_marker_new(),
        .iterator_invalidation_tracker = mutation_tracker_new(),
    };
    for (size_t index = 0; index < self->size; index++) {
        new_self.entries[index].key = KEY_CLONE(&self->entries[index].key);
        new_self.entries[index].value = VALUE_CLONE(&self->entries[index].value);
    }
    return new_self;
}

DC_STATIC_ASSERT()

DC_STATIC_ASSERT	(	CAPACITY	,
		0	,
		DC_EXPAND_STRING(SELF) " CAPACITY cannot be empty"	)

DC_TRAIT_MAP()

DC_TRAIT_MAP

(

SELF

)

debug()

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

static

Definition at line 206 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, "capacity: %zu,\n", (size_t)CAPACITY);
    dc_debug_fmt_print(fmt, stream, "size: %zu,\n", self->size);
    dc_debug_fmt_print(fmt, stream, "entries: [\n");
    fmt = dc_debug_fmt_scope_begin(fmt);
    for (size_t index = 0; index < self->size; index++) {
        dc_debug_fmt_print(fmt, stream, "{index: %lu, key: ", index);
        KEY_DEBUG(&self->entries[index].key, fmt, stream);
        fprintf(stream, ", value: ");
        VALUE_DEBUG(&self->entries[index].value, fmt, stream);
        fprintf(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 197 of file template.h.

                                                   {
    INVARIANT_CHECK(self);
 
    for (size_t index = 0; index < self->size; index++) {
        KEY_DELETE(&self->entries[index].key);
        VALUE_DELETE(&self->entries[index].value);
    }
}

delete_entry()

DC_PUBLIC void delete_entry ( SELF * self, KEY key )

static

Definition at line 175 of file template.h.

                                                                  {
    VALUE val = NS(SELF, remove)(self, key);
    VALUE_DELETE(&val);
}

empty() [1/2]

DC_PUBLIC bool empty ( ITER const * iter )

static

Definition at line 314 of file template.h.

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

empty() [2/2]

DC_PUBLIC bool empty ( ITER_CONST const * iter )

static

Definition at line 261 of file template.h.

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

empty_item() [1/2]

DC_PUBLIC bool empty_item ( KV_PAIR const * item )

static

Definition at line 294 of file template.h.

                                                                {
    return item->key == NULL && item->value == NULL;
}

empty_item() [2/2]

DC_PUBLIC bool empty_item ( KV_PAIR_CONST const * item )

static

Definition at line 241 of file template.h.

                                                                            {
    return item->key == NULL && item->value == NULL;
}

get_iter()

DC_PUBLIC ITER get_iter ( SELF * self )

static

Definition at line 320 of file template.h.

                                                     {
    INVARIANT_CHECK(self);
 
    return (ITER){
        .map = self,
        .next_index = 0,
        .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 267 of file template.h.

                                                                       {
    INVARIANT_CHECK(self);
 
    return (ITER_CONST){
        .map = self,
        .next_index = 0,
        .version = mutation_tracker_get(&self->iterator_invalidation_tracker),
    };
}

insert()

DC_PUBLIC VALUE * insert ( SELF * self, KEY key, VALUE value )

static

Definition at line 142 of file template.h.

                                                                           {
    VALUE* placed = NS(SELF, try_insert)(self, key, value);
    DC_ASSERT(placed, "Failed to insert item {key=%s, value=%s}", DC_DEBUG(KEY_DEBUG, &key),
              DC_DEBUG(VALUE_DEBUG, &value));
    return placed;
}

new()

DC_PUBLIC SELF new ( )

static

Definition at line 88 of file template.h.

                                      {
    return (SELF){
        .size = 0,
        .entries = {},
        .derive_c_map_staticlinear = dc_gdb_marker_new(),
        .iterator_invalidation_tracker = mutation_tracker_new(),
    };
}

next() [1/2]

DC_PUBLIC KV_PAIR next ( ITER * iter )

static

Definition at line 298 of file template.h.

                                                    {
    mutation_version_check(&iter->version);
    size_t const next_index = iter->next_index;
 
    if (next_index >= iter->map->size) {
        return (KV_PAIR){.key = NULL, .value = NULL};
    }
 
    iter->next_index++;
 
    return (KV_PAIR){
        .key = &iter->map->entries[next_index].key,
        .value = &iter->map->entries[next_index].value,
    };
}

next() [2/2]

DC_PUBLIC KV_PAIR_CONST next ( ITER_CONST * iter )

static

Definition at line 245 of file template.h.

                                                                      {
    mutation_version_check(&iter->version);
    size_t const next_index = iter->next_index;
 
    if (next_index >= iter->map->size) {
        return (KV_PAIR_CONST){.key = NULL, .value = NULL};
    }
 
    iter->next_index++;
 
    return (KV_PAIR_CONST){
        .key = &iter->map->entries[next_index].key,
        .value = &iter->map->entries[next_index].value,
    };
}

read()

DC_PUBLIC VALUE const * read ( SELF const * self, KEY key )

static

Definition at line 107 of file template.h.

                                                                        {
    VALUE const* value = NS(SELF, try_read)(self, key);
    DC_ASSERT(value, "Cannot read item {key=%s}", DC_DEBUG(KEY_DEBUG, &key));
    return value;
}

remove()

DC_PUBLIC VALUE remove ( SELF * self, KEY key )

static

Definition at line 168 of file template.h.

                                                             {
    VALUE dest;
    DC_ASSERT(NS(SELF, try_remove)(self, key, &dest), "Failed to remove item {key=%s}",
              DC_DEBUG(KEY_DEBUG, &key));
    return dest;
}

size()

DC_PUBLIC size_t size ( SELF const * self )

static

Definition at line 180 of file template.h.

{ return self->size; }

try_insert()

DC_PUBLIC VALUE * try_insert ( SELF * self, KEY key, VALUE value )

static

Definition at line 123 of file template.h.

                                                                               {
    INVARIANT_CHECK(self);
    mutation_tracker_mutate(&self->iterator_invalidation_tracker);
 
    if (self->size >= CAPACITY) {
        return NULL;
    }
 
    VALUE const* existing_value = NS(SELF, try_read)(self, key);
    if (existing_value) {
        return NULL;
    }
 
    self->entries[self->size].key = key;
    self->entries[self->size].value = value;
    self->size++;
    return &self->entries[self->size - 1].value;
}

try_read()

DC_PUBLIC VALUE const * try_read ( SELF const * self, KEY key )

static

Definition at line 97 of file template.h.

                                                                            {
    INVARIANT_CHECK(self);
    for (size_t index = 0; index < self->size; index++) {
        if (KEY_EQ(&self->entries[index].key, &key)) {
            return &self->entries[index].value;
        }
    }
    return NULL;
}

try_remove()

DC_PUBLIC bool try_remove ( SELF * self, KEY key, VALUE * dest )

static

Definition at line 149 of file template.h.

                                                                             {
    INVARIANT_CHECK(self);
    mutation_tracker_mutate(&self->iterator_invalidation_tracker);
 
    for (size_t index = 0; index < self->size; index++) {
        if (KEY_EQ(&self->entries[index].key, &key)) {
            KEY_DELETE(&self->entries[index].key);
            *dest = self->entries[index].value;
            // Shift remaining entries down
            for (size_t i = index; i < self->size - 1; i++) {
                self->entries[i] = self->entries[i + 1];
            }
            self->size--;
            return true;
        }
    }
    return false;
}

try_write()

DC_PUBLIC VALUE * try_write ( SELF * self, KEY key )

static

Definition at line 113 of file template.h.

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

write()

DC_PUBLIC VALUE * write ( SELF * self, KEY key )

static

Definition at line 117 of file template.h.

                                                             {
    VALUE* value = NS(SELF, try_write)(self, key);
    DC_ASSERT(value, "Cannot write item {key=%s}", DC_DEBUG(KEY_DEBUG, &key));
    return value;
}

Variable Documentation

max_capacity

DC_STATIC_CONSTANT size_t max_capacity = (size_t)CAPACITY

Definition at line 82 of file template.h.