basic.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <derive-c/utils/for.h>
#include <derive-c/alloc/std.h>
#include <derive-c/core/prelude.h>
#include <derive-c/container/arena/contiguous/template.h>

Go to the source code of this file.

Data Structures
struct	foo

Macros
#define	INDEX_BITS   32
#define	VALUE   uint32_t
#define	NAME   ints
#define	INDEX_BITS   8
#define	VALUE   struct foo
#define	VALUE_DELETE   my_foo_delete
#define	VALUE_DEBUG   foo_debug
#define	NAME   foo_arena

Functions
void	int_example ()
void	my_foo_delete (struct foo *self)
void	foo_debug (struct foo const *self, dc_debug_fmt fmt, FILE *stream)
int *	new_owned_int (int value)
void	foo_example ()
int	main ()

Macro Definition Documentation

INDEX_BITS [1/2]

#define INDEX_BITS   8

Definition at line 13 of file basic.c.

INDEX_BITS [2/2]

#define INDEX_BITS   32

Definition at line 13 of file basic.c.

NAME [1/2]

#define NAME   foo_arena

Definition at line 15 of file basic.c.

NAME [2/2]

#define NAME   ints

Definition at line 15 of file basic.c.

VALUE [1/2]

#define VALUE   struct foo

Definition at line 14 of file basic.c.

VALUE [2/2]

#define VALUE   uint32_t

Definition at line 14 of file basic.c.

VALUE_DEBUG

#define VALUE_DEBUG   foo_debug

Definition at line 68 of file basic.c.

VALUE_DELETE

#define VALUE_DELETE   my_foo_delete

Definition at line 67 of file basic.c.

Function Documentation

foo_debug()

void foo_debug	(	struct foo const *	self,
		dc_debug_fmt	fmt,
		FILE *	stream )

Examples

container/arena/basic.c.

Definition at line 53 of file basic.c.

                                                                       {
    (void)fmt;
    fprintf(stream, "foo@%p { x: %d, y: \"%s\", owned_data: @%p { %d }, }", self, self->x, self->y,
            self->owned_data, *self->owned_data);
}

foo_example()

void foo_example

(

)

Examples

container/arena/basic.c.

Definition at line 72 of file basic.c.

                   {
    foo_arena arena = foo_arena_new_with_capacity_for(12, stdalloc_get());
    foo_arena_index_t index_a =
        foo_arena_insert(&arena, (struct foo){.x = 42, .y = "A", .owned_data = new_owned_int(3)});
    foo_arena_index_t index_b =
        foo_arena_insert(&arena, (struct foo){.x = 41, .y = "B", .owned_data = new_owned_int(5)});
 
    DC_ASSERT(foo_arena_size(&arena) == 2);
    DC_ASSERT(foo_arena_full(&arena) == false);
    DC_ASSERT(foo_arena_read(&arena, index_a)->x == 42);
    DC_ASSERT(foo_arena_read(&arena, index_b)->x == 41);
 
    foo_arena_write(&arena, index_b)->x = 100;
    DC_ASSERT(foo_arena_read(&arena, index_b)->x == 100);
 
    foo_arena_debug(&arena, dc_debug_fmt_new(), stdout);
 
    // we remove the entry, importantly - we now own this data
    struct foo entry_a = foo_arena_remove(&arena, index_a);
 
    // entry_b was deleted
    foo_arena_delete(&arena);
 
    // entry a has not yet been deleted, so we can still access and then delete it
    DC_ASSERT(entry_a.x == 42);
 
    my_foo_delete(&entry_a);
}

int_example()

void int_example

(

)

Examples

container/arena/basic.c.

Definition at line 18 of file basic.c.

                   {
    ints arena = ints_new_with_capacity_for(12, stdalloc_get());
    ints_insert(&arena, 23);
    ints_insert(&arena, 42);
    ints_insert(&arena, 1000);
    ints_insert(&arena, 1001);
 
    DC_ASSERT(ints_size(&arena) == 4);
    {
        FOR(ints, &arena, iter, entry) {
            printf("entry for %d at %d\n", *entry.value, entry.index.index);
        }
    }
 
    {
        FOR(ints, &arena, iter, entry) {
            printf("incrementing for %d = %d + 1 at %d\n", *entry.value, *entry.value,
                   entry.index.index);
            *entry.value += 1;
        }
    }
 
    ints_debug(&arena, dc_debug_fmt_new(), stdout);
 
    ints_delete(&arena);
}

main()

int main

(

)

Definition at line 101 of file basic.c.

           {
    int_example();
    foo_example();
}

my_foo_delete()

void my_foo_delete

(

struct foo *

self

)

Examples

container/arena/basic.c.

Definition at line 51 of file basic.c.

{ free(self->owned_data); }

new_owned_int()

int * new_owned_int

(

int

value

)

Examples

container/arena/basic.c.

Definition at line 59 of file basic.c.

                              {
    int* v = (int*)malloc(sizeof(int));
    *v = value;
    return v;
}