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/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	SELF
	An allocator that prints to stdout when it allocates or frees memory. More...

Macros
#define	INVARIANT_CHECK(self)

Functions
static ssize_t PRIV	read (void *capture, char *buf, size_t size)
static ssize_t PRIV	write (void *capture, const char *data, size_t size)
static int PRIV	seek (void *capture, off_t *offset, int whence)
static int PRIV	close (void *capture)
static SELF	new (ALLOC *alloc)
static FILE *	stream (SELF *self)
	Opens a file for.
static void	reset (SELF *self)
	Resets the string, but keps the same stream pointer alive.
static char const *	string (SELF const *self)
	Gets access to the null terminated string.
static char *	release_string (SELF *self)
	Disowns the current string, free/management with chosen allocator determined by user.
static size_t	string_size (SELF *self)
static void	delete (SELF *self)

Variables
static size_t const	additional_alloc_size = 32

Macro Definition Documentation

INVARIANT_CHECK

#define INVARIANT_CHECK

(

self

)

Value:

    DC_ASSUME(self);                                                                               \
    DC_ASSUME((self)->alloc);                                                                      \
    DC_ASSUME(DC_WHEN((self)->buf, (self)->stream && (self)->capacity > 0));                       \
    DC_ASSUME(DC_WHEN((self)->capacity == 0, !(self)->buf));                                       \
    DC_ASSUME(DC_WHEN((self)->buf, (self)->size_without_null + 1 <= (self)->capacity));

Definition at line 26 of file template.h.

#define INVARIANT_CHECK(self)                                                                      \
    DC_ASSUME(self);                                                                               \
    DC_ASSUME((self)->alloc);                                                                      \
    DC_ASSUME(DC_WHEN((self)->buf, (self)->stream && (self)->capacity > 0));                       \
    DC_ASSUME(DC_WHEN((self)->capacity == 0, !(self)->buf));                                       \
    DC_ASSUME(DC_WHEN((self)->buf, (self)->size_without_null + 1 <= (self)->capacity));

Function Documentation

close()

int PRIV close ( void * capture )

static

Definition at line 90 of file template.h.

                                                {
    SELF* self = (SELF*)capture;
    INVARIANT_CHECK(self);
    return 0;
}

delete()

void delete ( SELF * self )

static

Definition at line 162 of file template.h.

                                         {
    INVARIANT_CHECK(self);
    if (self->stream) {
        fclose(self->stream);
    }
    if (self->buf) {
        NS(ALLOC, free)(self->alloc, self->buf);
    }
}

new()

SELF new ( ALLOC * alloc )

static

Definition at line 96 of file template.h.

                                        {
    return (SELF){
        .stream = NULL,
        .buf = NULL,
        .size_without_null = 0,
        .capacity = 0,
        .alloc = alloc,
    };
}

read()

ssize_t PRIV read ( void * capture, char * buf, size_t size )

static

Definition at line 33 of file template.h.

                                                 {
    SELF* self = (SELF*)capture;
    INVARIANT_CHECK(self);
 
    (void)buf;
    (void)size;
 
    DC_PANIC("cookie set in write-only mode, but read was called.");
}

release_string()

char * release_string ( SELF * self )

static

Disowns the current string, free/management with chosen allocator determined by user.

Definition at line 147 of file template.h.

                                                  {
    INVARIANT_CHECK(self);
    char* buf = self->buf;
    self->size_without_null = 0;
    self->buf = NULL;
    self->capacity = 0;
 
    return buf;
}

reset()

void reset ( SELF * self )

static

Resets the string, but keps the same stream pointer alive.

Definition at line 132 of file template.h.

                                        {
    INVARIANT_CHECK(self);
    self->size_without_null = 0;
}

seek()

int PRIV seek ( void * capture, off_t * offset, int whence )

static

Definition at line 78 of file template.h.

                                            {
    SELF* self = (SELF*)capture;
    INVARIANT_CHECK(self);
    (void)offset;
    (void)whence;
 
    errno = EPERM; // NOLINT(misc-include-cleaner)
    return -1;
}

stream()

FILE * stream ( SELF * self )

static

Opens a file for.

Examples

complex/employees.c, container/arena/basic.c, container/map/decomposed.c, container/vector/dynamic.c, and utils/option.c.

Definition at line 107 of file template.h.

                                          {
    INVARIANT_CHECK(self);
 
    if (self->stream == NULL) {
        cookie_io_functions_t /* NOLINT(misc-include-cleaner) */ const io = {
            .read = PRIV(NS(SELF, read)),
            .write = PRIV(NS(SELF, write)),
            .seek = PRIV(NS(SELF, seek)),
            .close = PRIV(NS(SELF, close)),
        };
        self->stream = fopencookie(self, "w", io);
        DC_ASSERT(self->stream != NULL, "Failed to open stream for string builder, with error: %s",
                  strerror(errno));
 
        // JUSTIFY: No buffering
        // - No performance advantage to buffering writes - this already writes to an in memory
        //   buffer
        // - No need to fflush
        setvbuf(self->stream, NULL, _IONBF, 0);
    }
 
    return self->stream;
}

string()

char const * string ( SELF const * self )

static

Gets access to the null terminated string.

Definition at line 138 of file template.h.

                                                      {
    INVARIANT_CHECK(self);
    if (self->size_without_null == 0) {
        return "";
    }
    return self->buf;
}

string_size()

size_t string_size ( SELF * self )

static

Definition at line 157 of file template.h.

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

write()

ssize_t PRIV write ( void * capture, const char * data, size_t size )

static

Definition at line 45 of file template.h.

                                                                                   {
    SELF* self = (SELF*)capture;
    INVARIANT_CHECK(self);
 
    if (self->size_without_null + size + 1 > self->capacity) {
        size_t new_capacity;
        char* new_buf;
        if (self->buf != NULL) {
            size_t const growth_factor = 2;
            new_capacity =
                (self->capacity * growth_factor) + size + NS(SELF, additional_alloc_size);
            new_buf = (char*)NS(ALLOC, realloc)(self->alloc, self->buf, new_capacity);
        } else {
            DC_ASSUME(self->capacity == 0);
            new_capacity = size + 1 + NS(SELF, additional_alloc_size);
            new_buf = (char*)NS(ALLOC, malloc)(self->alloc, new_capacity);
        }
 
        if (!new_buf) {
            errno = ENOMEM; // NOLINT(misc-include-cleaner)
            return -1;
        }
 
        self->capacity = new_capacity;
        self->buf = new_buf;
    }
 
    memcpy(self->buf + self->size_without_null, data, size);
    self->size_without_null += size;
    self->buf[self->size_without_null] = '\0';
    return (ssize_t)size;
}

Variable Documentation

additional_alloc_size

size_t const additional_alloc_size = 32

static

Definition at line 24 of file template.h.