template.h File Reference

#include <stddef.h>
#include <stdint.h>
#include <string.h>
#include <derive-c/container/vector/trait.h>
#include <derive-c/core/debug/gdb_marker.h>
#include <derive-c/core/debug/memory_tracker.h>
#include <derive-c/core/debug/mutation_tracker.h>
#include <derive-c/core/prelude.h>
#include <derive-c/core/self/def.h>
#include <derive-c/core/self/undef.h>

Include dependency graph for template.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
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...

Macros
#define	ITEM   item_t
#define	ITEM_DELETE   item_delete
#define	ITEM_CLONE   item_clone
#define	INPLACE_CAPACITY   8
#define	INDEX_TYPE   uint8_t
#define	INVARIANT_CHECK(self)

Typedefs
typedef INDEX_TYPE	index_t
typedef ITEM *	item

Functions
static void	item_delete (item_t *self)
static item_t	item_clone (item_t const *self)
static SELF	new ()
static SELF	clone (SELF const *self)
static ITEM const *	try_read (SELF const *self, INDEX_TYPE index)
static ITEM const *	read (SELF const *self, INDEX_TYPE index)
static ITEM *	try_write (SELF *self, INDEX_TYPE index)
static ITEM *	write (SELF *self, INDEX_TYPE index)
static ITEM *	try_push (SELF *self, ITEM item)
static bool	try_insert_at (SELF *self, INDEX_TYPE at, ITEM const *items, INDEX_TYPE count)
static void	remove_at (SELF *self, INDEX_TYPE at, INDEX_TYPE count)
static ITEM *	push (SELF *self, ITEM item)
static bool	try_pop (SELF *self, ITEM *destination)
static ITEM	pop (SELF *self)
static INDEX_TYPE	size (SELF const *self)
static void	delete (SELF *self)
static bool	empty_item (ITEM *const *item)
static ITEM *	next (ITER *iter)
static INDEX_TYPE	position (ITER const *iter)
static bool	empty (ITER const *iter)
static ITER	get_iter (SELF *self)
static bool	empty_item (ITEM const *const *item)
static ITEM const *	next (ITER_CONST *iter)
static INDEX_TYPE	position (ITER_CONST const *iter)
static bool	empty (ITER_CONST const *iter)
static ITER_CONST	get_iter_const (SELF const *self)
	TRAIT_VECTOR (SELF)

Variables
static const INDEX_TYPE	max_size = INPLACE_CAPACITY

Macro Definition Documentation

INDEX_TYPE

#define INDEX_TYPE   uint8_t

Definition at line 46 of file template.h.

INPLACE_CAPACITY

#define INPLACE_CAPACITY   8

Definition at line 42 of file template.h.

INVARIANT_CHECK

#define INVARIANT_CHECK

(

self

)

Value:

    ASSUME(self);                                                                                  \
    ASSUME((self->size) <= INPLACE_CAPACITY);

Definition at line 64 of file template.h.

#define INVARIANT_CHECK(self)                                                                      \
    ASSUME(self);                                                                                  \
    ASSUME((self->size) <= INPLACE_CAPACITY);

ITEM

#define ITEM   item_t

Definition at line 23 of file template.h.

ITEM_CLONE

#define ITEM_CLONE   item_clone

Definition at line 27 of file template.h.

ITEM_DELETE

#define ITEM_DELETE   item_delete

Definition at line 25 of file template.h.

Typedef Documentation

index_t

typedef INDEX_TYPE index_t

Definition at line 54 of file template.h.

item

typedef ITEM const* item

Definition at line 213 of file template.h.

Function Documentation

clone()

SELF clone ( SELF const * self )

static

Definition at line 81 of file template.h.

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

Here is the call graph for this function:

delete()

void delete ( SELF * self )

static

Definition at line 203 of file template.h.

                                         {
    INVARIANT_CHECK(self);
    for (INDEX_TYPE i = 0; i < self->size; i++) {
        ITEM_DELETE(&self->data[i]);
    }
    memory_tracker_set(MEMORY_TRACKER_LVL_CONTAINER, MEMORY_TRACKER_CAP_NONE, &self->data,
                       self->size * sizeof(ITEM));
}

Here is the call graph for this function:

empty() [1/2]

bool empty ( ITER const * iter )

static

Definition at line 240 of file template.h.

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

Here is the call graph for this function:

empty() [2/2]

bool empty ( ITER_CONST const * iter )

static

Definition at line 283 of file template.h.

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

Here is the call graph for this function:

empty_item() [1/2]

bool empty_item ( ITEM *const * item )

static

Definition at line 215 of file template.h.

{ return *item == NULL; }

Here is the call graph for this function:

empty_item() [2/2]

bool empty_item ( ITEM const *const * item )

static

Definition at line 258 of file template.h.

{ return *item == NULL; }

Here is the call graph for this function:

get_iter()

ITER get_iter ( SELF * self )

static

Definition at line 246 of file template.h.

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

Here is the call graph for this function:

get_iter_const()

ITER_CONST get_iter_const ( SELF const * self )

static

Definition at line 289 of file template.h.

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

Here is the call graph for this function:

item_clone()

item_t item_clone ( item_t const * self )

static

Definition at line 26 of file template.h.

{ return *self; }

item_delete()

void item_delete ( item_t * self )

static

Definition at line 24 of file template.h.

{ (void)self; }

new()

SELF new ( )

static

Definition at line 68 of file template.h.

                            {
    SELF self = {
        .size = 0,
        .derive_c_staticvec = gdb_marker_new(),
        .iterator_invalidation_tracker = mutation_tracker_new(),
    };
    memory_tracker_set(MEMORY_TRACKER_LVL_CONTAINER, MEMORY_TRACKER_CAP_NONE, &self.data,
                       sizeof(ITEM) * INPLACE_CAPACITY);
    return self;
}

Here is the call graph for this function:

next() [1/2]

ITEM * next ( ITER * iter )

static

Definition at line 223 of file template.h.

                                        {
    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;
}

Here is the call graph for this function:

next() [2/2]

ITEM const * next ( ITER_CONST * iter )

static

Definition at line 266 of file template.h.

                                                          {
    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;
}

Here is the call graph for this function:

pop()

ITEM pop ( SELF * self )

static

Definition at line 192 of file template.h.

                                      {
    ITEM entry;
    ASSERT(NS(SELF, try_pop)(self, &entry));
    return entry;
}

Here is the call graph for this function:

position() [1/2]

INDEX_TYPE position ( ITER const * iter )

static

Definition at line 234 of file template.h.

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

Here is the call graph for this function:

position() [2/2]

INDEX_TYPE position ( ITER_CONST const * iter )

static

Definition at line 277 of file template.h.

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

Here is the call graph for this function:

push()

ITEM * push ( SELF * self, ITEM item )

static

Definition at line 173 of file template.h.

                                                   {
    ITEM* slot = NS(SELF, try_push)(self, item);
    ASSERT(slot);
    return slot;
}

Here is the call graph for this function:

read()

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

static

Definition at line 102 of file template.h.

                                                                      {
    ITEM const* value = NS(SELF, try_read)(self, index);
    ASSERT(value);
    return value;
}

Here is the call graph for this function:

remove_at()

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

static

Definition at line 155 of file template.h.

                                                                             {
    INVARIANT_CHECK(self);
    ASSERT(at + count <= 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;
    memory_tracker_set(MEMORY_TRACKER_LVL_CONTAINER, MEMORY_TRACKER_CAP_NONE,
                       &self->data[self->size], count * sizeof(ITEM));
}

Here is the call graph for this function:

size()

INDEX_TYPE size ( SELF const * self )

static

Definition at line 198 of file template.h.

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

Here is the call graph for this function:

TRAIT_VECTOR()

TRAIT_VECTOR

(

SELF

)

try_insert_at()

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

static

Definition at line 136 of file template.h.

                                                      {
    INVARIANT_CHECK(self);
    ASSUME(items);
    ASSERT(at <= self->size);
    mutation_tracker_mutate(&self->iterator_invalidation_tracker);
 
    if (self->size + count > INPLACE_CAPACITY) {
        return false;
    }
 
    memory_tracker_set(MEMORY_TRACKER_LVL_CONTAINER, MEMORY_TRACKER_CAP_WRITE,
                       &self->data[self->size], count * sizeof(ITEM));
    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 true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

try_pop()

bool try_pop ( SELF * self, ITEM * destination )

static

Definition at line 179 of file template.h.

                                                             {
    INVARIANT_CHECK(self);
    mutation_tracker_mutate(&self->iterator_invalidation_tracker);
    if (LIKELY(self->size > 0)) {
        self->size--;
        *destination = self->data[self->size];
        memory_tracker_set(MEMORY_TRACKER_LVL_CONTAINER, MEMORY_TRACKER_CAP_NONE,
                           &self->data[self->size + 1], sizeof(ITEM));
        return true;
    }
    return false;
}

Here is the call graph for this function:

try_push()

ITEM * try_push ( SELF * self, ITEM item )

static

Definition at line 122 of file template.h.

                                                       {
    INVARIANT_CHECK(self);
    mutation_tracker_mutate(&self->iterator_invalidation_tracker);
    if (self->size < INPLACE_CAPACITY) {
        ITEM* slot = &self->data[self->size];
        memory_tracker_set(MEMORY_TRACKER_LVL_CONTAINER, MEMORY_TRACKER_CAP_WRITE, slot,
                           sizeof(ITEM));
        *slot = item;
        self->size++;
        return slot;
    }
    return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

try_read()

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

static

Definition at line 94 of file template.h.

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

Here is the call graph for this function:

try_write()

ITEM * try_write ( SELF * self, INDEX_TYPE index )

static

Definition at line 108 of file template.h.

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

Here is the call graph for this function:

write()

ITEM * write ( SELF * self, INDEX_TYPE index )

static

Definition at line 116 of file template.h.

                                                           {
    ITEM* value = NS(SELF, try_write)(self, index);
    ASSERT(value);
    return value;
}

Here is the call graph for this function:

Variable Documentation

max_size

const INDEX_TYPE max_size = INPLACE_CAPACITY

static

Definition at line 79 of file template.h.