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	item_t
	A queue comprised of an extendable circular buffer. More...
struct	SELF
	An allocator that prints to stdout when it allocates or frees memory. More...
struct	ITER
struct	ITER_CONST

Macros
#define	ITEM   item_t
#define	ITEM_DELETE   item_delete
#define	ITEM_CLONE   item_clone
#define	ITEM_DEBUG   item_debug
#define	CAPACITY   8
#define	INVARIANT_CHECK(self)
#define	ITER   NS(SELF, iter)
#define	ITER_CONST   NS(SELF, iter_const)

Typedefs
typedef ITEM *	item

Functions
static void	ITEM_DELETE (item_t *)
static item_t	ITEM_CLONE (item_t const *self)
static void	ITEM_DEBUG (ITEM const *, dc_debug_fmt, FILE *)
static SELF	new ()
static DC_PUBLIC SELF	clone (SELF const *self)
static DC_PUBLIC ITEM const *	try_read (SELF const *self, INDEX_TYPE index)
static DC_PUBLIC ITEM const *	read (SELF const *self, INDEX_TYPE index)
static DC_PUBLIC ITEM *	try_write (SELF *self, INDEX_TYPE index)
static DC_PUBLIC ITEM *	write (SELF *self, INDEX_TYPE index)
static DC_PUBLIC ITEM *	try_push (SELF *self, ITEM item)
static DC_PUBLIC ITEM *	try_insert_at (SELF *self, INDEX_TYPE at, ITEM const *items, INDEX_TYPE count)
static DC_PUBLIC void	remove_at (SELF *self, INDEX_TYPE at, INDEX_TYPE count)
static DC_PUBLIC ITEM *	push (SELF *self, ITEM item)
static DC_PUBLIC bool	try_pop (SELF *self, ITEM *destination)
static DC_PUBLIC ITEM	pop (SELF *self)
static DC_PUBLIC INDEX_TYPE	size (SELF const *self)
static DC_PUBLIC void	delete (SELF *self)
static DC_PUBLIC bool	empty_item (ITEM *const *item)
static DC_PUBLIC ITEM *	next (ITER *iter)
static DC_PUBLIC INDEX_TYPE	position (ITER const *iter)
static DC_PUBLIC bool	empty (ITER const *iter)
static DC_PUBLIC ITER	get_iter (SELF *self)
static DC_PUBLIC bool	empty_item (ITEM const *const *item)
static DC_PUBLIC ITEM const *	next (ITER_CONST *iter)
static DC_PUBLIC INDEX_TYPE	position (ITER_CONST 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 void	debug (SELF const *self, dc_debug_fmt fmt, FILE *stream)
	DC_TRAIT_VECTOR (SELF)

Variables
DC_STATIC_CONSTANT size_t	max_size = CAPACITY

Macro Definition Documentation

CAPACITY

#define CAPACITY   8

Definition at line 50 of file template.h.

INVARIANT_CHECK

#define INVARIANT_CHECK

(

self

)

Value:

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

Definition at line 73 of file template.h.

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

ITEM

#define ITEM   item_t

Definition at line 25 of file template.h.

ITEM_CLONE

#define ITEM_CLONE   item_clone

Definition at line 28 of file template.h.

ITEM_DEBUG

#define ITEM_DEBUG   item_debug

Definition at line 30 of file template.h.

ITEM_DELETE

#define ITEM_DELETE   item_delete

Definition at line 26 of file template.h.

ITER

#define ITER   NS(SELF, iter)

Definition at line 218 of file template.h.

ITER_CONST

#define ITER_CONST   NS(SELF, iter_const)

Definition at line 261 of file template.h.

Typedef Documentation

item

typedef ITEM const* item

Definition at line 219 of file template.h.

Function Documentation

clone()

DC_PUBLIC SELF clone ( SELF const * self )

static

Definition at line 88 of file template.h.

                                                        {
    SELF new_self = NS(SELF, new)();
    new_self.size = self->size;
 
    for (INDEX_TYPE i = 0; i < self->size; i++) {
        new_self.data[i] = ITEM_CLONE(&self->data[i]);
    }
 
    return new_self;
}

DC_TRAIT_VECTOR()

DC_TRAIT_VECTOR

(

SELF

)

debug()

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

static

Definition at line 304 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: %lu,\n", (size_t)CAPACITY);
    dc_debug_fmt_print(fmt, stream, "size: %lu,\n", (size_t)self->size);
 
    dc_debug_fmt_print(fmt, stream, "items: @%p [\n", (void*)self->data);
    fmt = dc_debug_fmt_scope_begin(fmt);
    ITER_CONST iter = NS(SELF, get_iter_const)(self);
    ITEM const* item;
    while ((item = NS(ITER_CONST, next)(&iter))) {
        dc_debug_fmt_print_indents(fmt, stream);
        ITEM_DEBUG(item, 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 211 of file template.h.

                                                   {
    INVARIANT_CHECK(self);
    for (INDEX_TYPE i = 0; i < self->size; i++) {
        ITEM_DELETE(&self->data[i]);
    }
}

empty() [1/2]

DC_PUBLIC bool empty ( ITER const * iter )

static

Definition at line 246 of file template.h.

                                                        {
    DC_ASSUME(iter);
    mutation_version_check(&iter->version);
    return iter->pos >= iter->vec->size;
}

empty() [2/2]

DC_PUBLIC bool empty ( ITER_CONST const * iter )

static

Definition at line 289 of file template.h.

                                                                    {
    DC_ASSUME(iter);
    mutation_version_check(&iter->version);
    return iter->pos >= iter->vec->size;
}

empty_item() [1/2]

DC_PUBLIC bool empty_item ( ITEM *const * item )

static

Definition at line 221 of file template.h.

{ return *item == NULL; }

empty_item() [2/2]

DC_PUBLIC bool empty_item ( ITEM const *const * item )

static

Definition at line 264 of file template.h.

{ return *item == NULL; }

get_iter()

DC_PUBLIC ITER get_iter ( SELF * self )

static

Definition at line 252 of file template.h.

                                                     {
    DC_ASSUME(self);
    return (ITER){.vec = self,
                  .pos = 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 295 of file template.h.

                                                                       {
    DC_ASSUME(self);
    return (ITER_CONST){
        .vec = self,
        .pos = 0,
        .version = mutation_tracker_get(&self->iterator_invalidation_tracker),
    };
}

ITEM_CLONE()

item_t ITEM_CLONE ( item_t const * self )

static

Definition at line 29 of file template.h.

{ return *self; }

ITEM_DEBUG()

void ITEM_DEBUG ( ITEM const * , dc_debug_fmt , FILE *  )

static

Definition at line 31 of file template.h.

{}

ITEM_DELETE()

void ITEM_DELETE ( item_t * )

static

Definition at line 27 of file template.h.

{}

new()

SELF new ( )

static

Definition at line 77 of file template.h.

                            {
    SELF self = {
        .size = 0,
        .derive_c_staticvec = dc_gdb_marker_new(),
        .iterator_invalidation_tracker = mutation_tracker_new(),
    };
    return self;
}

next() [1/2]

DC_PUBLIC ITEM * next ( ITER * iter )

static

Definition at line 229 of file template.h.

                                                  {
    DC_ASSUME(iter);
    mutation_version_check(&iter->version);
    if (iter->pos < iter->vec->size) {
        ITEM* item = &iter->vec->data[iter->pos];
        iter->pos++;
        return item;
    }
    return NULL;
}

next() [2/2]

DC_PUBLIC ITEM const * next ( ITER_CONST * iter )

static

Definition at line 272 of file template.h.

                                                                    {
    DC_ASSUME(iter);
    mutation_version_check(&iter->version);
    if (iter->pos < iter->vec->size) {
        ITEM const* item = &iter->vec->data[iter->pos];
        iter->pos++;
        return item;
    }
    return NULL;
}

pop()

DC_PUBLIC ITEM pop ( SELF * self )

static

Definition at line 199 of file template.h.

                                                {
    ITEM entry;
    DC_ASSERT(NS(SELF, try_pop)(self, &entry), "Cannot pop, already empty {size=%lu}",
              (size_t)self->size);
    return entry;
}

position() [1/2]

DC_PUBLIC INDEX_TYPE position ( ITER const * iter )

static

Definition at line 240 of file template.h.

                                                                 {
    DC_ASSUME(iter);
    mutation_version_check(&iter->version);
    return iter->pos;
}

position() [2/2]

DC_PUBLIC INDEX_TYPE position ( ITER_CONST const * iter )

static

Definition at line 283 of file template.h.

                                                                             {
    DC_ASSUME(iter);
    mutation_version_check(&iter->version);
    return iter->pos;
}

push()

DC_PUBLIC ITEM * push ( SELF * self, ITEM item )

static

Definition at line 181 of file template.h.

                                                             {
    ITEM* slot = NS(SELF, try_push)(self, item);
    DC_ASSERT(slot, "Cannot push, already at max capacity {capacity=%d, item=%s}", CAPACITY,
              DC_DEBUG(ITEM_DEBUG, &item));
    return slot;
}

read()

DC_PUBLIC ITEM const * read ( SELF const * self, INDEX_TYPE index )

static

Definition at line 107 of file template.h.

                                                                                {
    ITEM const* value = NS(SELF, try_read)(self, index);
    DC_ASSERT(value, "Cannot read, index out of bounds {index=%lu, size=%lu}", (size_t)index,
              (size_t)self->size);
    return value;
}

remove_at()

DC_PUBLIC void remove_at ( SELF * self, INDEX_TYPE at, INDEX_TYPE count )

static

Definition at line 163 of file template.h.

                                                                                       {
    INVARIANT_CHECK(self);
    DC_ASSERT(at + count <= self->size,
              "Cannot remove at, index out of bounds {at=%lu, count=%lu, size=%lu}", (size_t)at,
              (size_t)count, (size_t)self->size);
 
    if (count == 0) {
        return;
    }
 
    for (INDEX_TYPE i = at; i < at + count; i++) {
        ITEM_DELETE(&self->data[i]);
    }
 
    memmove(&self->data[at], &self->data[at + count], (self->size - (at + count)) * sizeof(ITEM));
    self->size -= count;
}

size()

DC_PUBLIC INDEX_TYPE size ( SELF const * self )

static

Definition at line 206 of file template.h.

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

try_insert_at()

DC_PUBLIC ITEM * try_insert_at ( SELF * self, INDEX_TYPE at, ITEM const * items, INDEX_TYPE count )

static

Definition at line 141 of file template.h.

                                                                 {
    INVARIANT_CHECK(self);
    DC_ASSUME(items);
    DC_ASSERT(at <= self->size, "Cannot insert at, index out of bounds {at=%lu, size=%lu}",
              (size_t)at, (size_t)self->size);
    mutation_tracker_mutate(&self->iterator_invalidation_tracker);
 
    if (self->size + count > CAPACITY) {
        return NULL;
    }
 
    if (count == 0) {
        return NULL;
    }
 
    memmove(&self->data[at + count], &self->data[at], (self->size - at) * sizeof(ITEM));
    memcpy(&self->data[at], items, count * sizeof(ITEM));
    self->size += count;
    return &self->data[at];
}

try_pop()

DC_PUBLIC bool try_pop ( SELF * self, ITEM * destination )

static

Definition at line 188 of file template.h.

                                                                       {
    INVARIANT_CHECK(self);
    mutation_tracker_mutate(&self->iterator_invalidation_tracker);
    if (DC_LIKELY(self->size > 0)) {
        self->size--;
        *destination = self->data[self->size];
        return true;
    }
    return false;
}

try_push()

DC_PUBLIC ITEM * try_push ( SELF * self, ITEM item )

static

Definition at line 129 of file template.h.

                                                                 {
    INVARIANT_CHECK(self);
    mutation_tracker_mutate(&self->iterator_invalidation_tracker);
    if (self->size < CAPACITY) {
        ITEM* slot = &self->data[self->size];
        *slot = item;
        self->size++;
        return slot;
    }
    return NULL;
}

try_read()

DC_PUBLIC ITEM const * try_read ( SELF const * self, INDEX_TYPE index )

static

Definition at line 99 of file template.h.

                                                                                    {
    INVARIANT_CHECK(self);
    if (DC_LIKELY(index < self->size)) {
        return &self->data[index];
    }
    return NULL;
}

try_write()

DC_PUBLIC ITEM * try_write ( SELF * self, INDEX_TYPE index )

static

Definition at line 114 of file template.h.

                                                                         {
    INVARIANT_CHECK(self);
    if (DC_LIKELY(index < self->size)) {
        return &self->data[index];
    }
    return NULL;
}

write()

DC_PUBLIC ITEM * write ( SELF * self, INDEX_TYPE index )

static

Definition at line 122 of file template.h.

                                                                     {
    ITEM* value = NS(SELF, try_write)(self, index);
    DC_ASSERT(value, "Cannot write, index out of bounds {index=%lu, size=%lu}", (size_t)index,
              (size_t)self->size);
    return value;
}

Variable Documentation

max_size

DC_STATIC_CONSTANT size_t max_size = CAPACITY

Definition at line 86 of file template.h.