arena.c File Reference

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <derive-c/allocs/std.h>
#include <derive-c/structures/arena/template.h>

Include dependency graph for arena.c:

Go to the source code of this file.

Classes
struct	foo

Macros
#define	INDEX_BITS   32
#define	V   uint32_t
#define	SELF   ints
#define	INDEX_BITS   8
#define	V   struct foo
#define	V_DELETE   my_foo_delete
#define	SELF   foo_arena

Functions
void	int_example ()
void	my_foo_delete (struct foo *self)
void	foo_example ()
int	main ()

Macro Definition Documentation

INDEX_BITS [1/2]

#define INDEX_BITS   32

Definition at line 11 of file arena.c.

INDEX_BITS [2/2]

#define INDEX_BITS   8

Definition at line 11 of file arena.c.

SELF [1/2]

#define SELF   ints

Definition at line 13 of file arena.c.

SELF [2/2]

#define SELF   foo_arena

Definition at line 13 of file arena.c.

V [1/2]

#define V   uint32_t

Definition at line 12 of file arena.c.

V [2/2]

#define V   struct foo

Definition at line 12 of file arena.c.

V_DELETE

#define V_DELETE   my_foo_delete

Definition at line 55 of file arena.c.

Function Documentation

foo_example()

void foo_example

(

)

Examples

structures/arena.c.

Definition at line 59 of file arena.c.

                   {
    foo_arena arena = foo_arena_new_with_capacity_for(12, stdalloc_get());
    foo_arena_index index_a = foo_arena_insert(
        &arena, (struct foo){.x = 42, .y = "A", .owned_data = (int*)malloc(sizeof(int))});
    foo_arena_index index_b = foo_arena_insert(
        &arena, (struct foo){.x = 41, .y = "B", .owned_data = (int*)malloc(sizeof(int))});
 
    assert(foo_arena_size(&arena) == 2);
    assert(foo_arena_full(&arena) == false);
    assert(foo_arena_read(&arena, index_a)->x == 42);
    assert(foo_arena_read(&arena, index_b)->x == 41);
 
    foo_arena_write(&arena, index_b)->x = 100;
    assert(foo_arena_read(&arena, index_b)->x == 100);
 
    // we remove the entry, improtantly - 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
    assert(entry_a.x == 42);
 
    my_foo_delete(&entry_a);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int_example()

void int_example

(

)

Examples

structures/arena.c.

Definition at line 16 of file arena.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);
 
    assert(ints_size(&arena) == 4);
    {
        ints_iter_const print_ints = ints_get_iter_const(&arena);
        ints_iv_const const* entry = NULL;
        while ((entry = ints_iter_const_next(&print_ints))) {
            printf("entry for %d at %d\n", *entry->value, entry->index.index);
        }
    }
 
    {
        ints_iter inc_ints = ints_get_iter(&arena);
        ints_iv const* entry = NULL;
        while ((entry = ints_iter_next(&inc_ints))) {
            printf("incrementing for %d = %d + 1 at %d\n", *entry->value, *entry->value,
                   entry->index.index);
            *entry->value += 1;
        }
    }
 
    ints_delete(&arena);
}

Here is the caller graph for this function:

main()

int main

(

)

Definition at line 86 of file arena.c.

           {
    int_example();
    foo_example();
}

Here is the call graph for this function:

my_foo_delete()

void my_foo_delete

(

struct foo *

self

)

Examples

structures/arena.c.

Definition at line 51 of file arena.c.

{ free(self->owned_data); }

Here is the call graph for this function:

Here is the caller graph for this function: