template.h File Reference

#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <derive-c/core.h>
#include <derive-c/panic.h>
#include <derive-c/self.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	SELF

Macros
#define	T   derive_c_parameter_t
#define	T_DELETE   derive_c_parameter_t_delete

Functions
static SELF	new ()
static SELF	new_with_capacity (size_t capacity)
static SELF	new_with_defaults (size_t size, T default_value)
static SELF	shallow_clone (SELF const *self)
static T const *	try_read (SELF const *self, size_t index)
static T const *	read (SELF const *self, size_t index)
static T *	try_write (SELF *self, size_t index)
static T *	write (SELF *self, size_t index)
static T *	push (SELF *self, T value)
static bool	try_pop (SELF *self, T *destination)
static T	pop (SELF *self)
static size_t	size (SELF const *self)
static void	delete (SELF *self)
static T *	next (ITER *iter)
static size_t	position (ITER const *iter)
static bool	empty (ITER const *iter)
static ITER	get_iter (SELF *self)
static T const *	next (ITER_CONST *iter)
static size_t	position (ITER_CONST const *iter)
static bool	empty (ITER_CONST const *iter)
static ITER_CONST	get_iter_const (SELF const *self)

Macro Definition Documentation

T

#define T   derive_c_parameter_t

Definition at line 18 of file template.h.

T_DELETE

#define T_DELETE   derive_c_parameter_t_delete

Definition at line 20 of file template.h.

Function Documentation

delete()

static void delete ( SELF * self )

static

Definition at line 161 of file template.h.

                                           {
    DEBUG_ASSERT(self);
    for (size_t i = 0; i < self->size; i++) {
        T_DELETE(&self->data[i]);
    }
    free(self->data);
}

empty() [1/2]

static bool empty ( ITER const * iter )

static

Definition at line 192 of file template.h.

                                                {
    DEBUG_ASSERT(iter);
    return iter->pos >= iter->vec->size;
}

Here is the call graph for this function:

empty() [2/2]

static bool empty ( ITER_CONST const * iter )

static

Definition at line 229 of file template.h.

                                                            {
    DEBUG_ASSERT(iter);
    return iter->pos >= iter->vec->size;
}

Here is the call graph for this function:

get_iter()

static ITER get_iter ( SELF * self )

static

Definition at line 197 of file template.h.

                                             {
    DEBUG_ASSERT(self);
    return (ITER){
        .vec = self,
        .pos = 0,
    };
}

Here is the call graph for this function:

get_iter_const()

static ITER_CONST get_iter_const ( SELF const * self )

static

Definition at line 234 of file template.h.

                                                               {
    DEBUG_ASSERT(self);
    return (ITER_CONST){
        .vec = self,
        .pos = 0,
    };
}

Here is the call graph for this function:

new()

static SELF new ( )

static

Definition at line 34 of file template.h.

                              {
    SELF temp = (SELF){
        .size = 0,
        .capacity = 0,
        .data = NULL,
    };
    return temp;
}

new_with_capacity()

static SELF new_with_capacity ( size_t capacity )

static

Definition at line 43 of file template.h.

                                                           {
    DEBUG_ASSERT(capacity > 0);
    T* data = (T*)malloc(capacity * sizeof(T));
    ASSERT(LIKELY(data));
    return (SELF){
        .size = 0,
        .capacity = capacity,
        .data = data,
    };
}

Here is the call graph for this function:

Here is the caller graph for this function:

new_with_defaults()

static SELF new_with_defaults ( size_t size, T default_value )

static

Definition at line 54 of file template.h.

                                                                        {
    T* data = (T*)malloc(size * sizeof(T));
    for (size_t i = 0; i < size; i++) {
        data[i] = default_value;
    }
    ASSERT(LIKELY(data));
    return (SELF){
        .size = size,
        .capacity = size,
        .data = data,
    };
}

Here is the call graph for this function:

Here is the caller graph for this function:

next() [1/2]

static T * next ( ITER * iter )

static

Definition at line 176 of file template.h.

                                       {
    DEBUG_ASSERT(iter);
    if (iter->pos < iter->vec->size) {
        T* item = &iter->vec->data[iter->pos];
        iter->pos++;
        return item;
    } else {
        return NULL;
    }
}

Here is the call graph for this function:

next() [2/2]

static T const * next ( ITER_CONST * iter )

static

Definition at line 213 of file template.h.

                                                         {
    DEBUG_ASSERT(iter);
    if (iter->pos < iter->vec->size) {
        T const* item = &iter->vec->data[iter->pos];
        iter->pos++;
        return item;
    } else {
        return NULL;
    }
}

Here is the call graph for this function:

pop()

static T pop ( SELF * self )

static

Definition at line 150 of file template.h.

                                     {
    T entry;
    ASSERT(NAME(SELF, try_pop)(self, &entry));
    return entry;
}

Here is the call graph for this function:

position() [1/2]

static size_t position ( ITER const * iter )

static

Definition at line 187 of file template.h.

                                                     {
    DEBUG_ASSERT(iter);
    return iter->pos;
}

Here is the call graph for this function:

position() [2/2]

static size_t position ( ITER_CONST const * iter )

static

Definition at line 224 of file template.h.

                                                                 {
    DEBUG_ASSERT(iter);
    return iter->pos;
}

Here is the call graph for this function:

push()

static T * push ( SELF * self, T value )

static

Definition at line 109 of file template.h.

                                                {
    DEBUG_ASSERT(self);
    if (self->size == self->capacity) {
        T* new_data;
        size_t new_capacity;
        if (self->data == NULL) {
            DEBUG_ASSERT(self->capacity == 0);
            // JUSTIFY: Allocating capacity of 4
            //           - Avoid repeat reallocations on growing a vector from
            //             size sero (from new)
            //           Otherwise an arbitrary choice (given we do not know the size of T)
            new_capacity = 8;
            new_data = (T*)malloc(new_capacity * sizeof(T));
        } else {
            // JUSTIFY: Growth factor of 2
            //           - Simple arithmetic (for debugging)
            //           - Same as used by GCC's std::vector implementation
            new_capacity = self->capacity * 2;
            new_data = (T*)realloc(self->data, new_capacity * sizeof(T));
        }
        ASSERT(new_data);
        self->capacity = new_capacity;
        self->data = new_data;
    }
    T* entry = &self->data[self->size];
    *entry = value;
    self->size++;
    return entry;
}

Here is the call graph for this function:

read()

static T const * read ( SELF const * self, size_t index )

static

Definition at line 88 of file template.h.

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

Here is the call graph for this function:

shallow_clone()

static SELF shallow_clone ( SELF const * self )

static

Definition at line 67 of file template.h.

                                                        {
    DEBUG_ASSERT(self);
    T* data = (T*)malloc(self->capacity * sizeof(T));
    ASSERT(data);
    memcpy(data, self->data, self->size * sizeof(T));
    return (SELF){
        .size = self->size,
        .capacity = self->capacity,
        .data = data,
    };
}

Here is the call graph for this function:

size()

static size_t size ( SELF const * self )

static

Definition at line 156 of file template.h.

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

Here is the call graph for this function:

try_pop()

static bool try_pop ( SELF * self, T * destination )

static

Definition at line 139 of file template.h.

                                                            {
    DEBUG_ASSERT(self);
    if (LIKELY(self->size > 0)) {
        self->size--;
        *destination = self->data[self->size];
        return true;
    } else {
        return false;
    }
}

Here is the call graph for this function:

try_read()

static T const * try_read ( SELF const * self, size_t index )

static

Definition at line 79 of file template.h.

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

Here is the call graph for this function:

try_write()

static T * try_write ( SELF * self, size_t index )

static

Definition at line 94 of file template.h.

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

Here is the call graph for this function:

write()

static T * write ( SELF * self, size_t index )

static

Definition at line 103 of file template.h.

                                                      {
    T* value = NAME(SELF, try_write)(self, index);
    ASSERT(value);
    return value;
}

Here is the call graph for this function: