template.h File Reference

#include <derive-c/core/includes/def.h>
#include "includes.h"
#include <derive-c/test/mock_in_struct/def.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/test/mock_in_struct/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	DEBUG_MOCK_TOGGLE(name)

Functions
static DC_PUBLIC SELF	new (ref alloc_ref)
	DC_MOCKABLE (void *, allocate_uninit,(SELF *self, size_t size))
	DC_MOCKABLE (void *, allocate_zeroed,(SELF *self, size_t size))
	DC_MOCKABLE (void *, reallocate,(SELF *self, void *ptr, size_t old_size, size_t new_size))
	DC_MOCKABLE (void, deallocate,(SELF *self, void *ptr, size_t size))
static DC_PUBLIC void	debug (SELF const *self, dc_debug_fmt fmt, FILE *stream)
static DC_PUBLIC void	delete (SELF *self)
	DC_TRAIT_REFERENCABLE_BY_PTR (SELF)
	DC_TRAIT_ALLOC (SELF)

Macro Definition Documentation

DEBUG_MOCK_TOGGLE

#define DEBUG_MOCK_TOGGLE

(

name

)

Value:

    dc_debug_fmt_print(fmt, stream, DC_EXPAND_STRING(NS(SELF, name)) ": %s,\n",                    \
                       DC_MOCKABLE_ENABLED(NS(SELF, name)) ? "enabled" : "disabled")

Function Documentation

DC_MOCKABLE() [1/4]

DC_MOCKABLE	(	void *	,
		allocate_uninit	,
		(SELF *self, size_t size)	)

Definition at line 27 of file template.h.

                                                                          {
    return NS(ALLOC, allocate_uninit)(self->alloc_ref, size);
}

DC_MOCKABLE() [2/4]

DC_MOCKABLE	(	void *	,
		allocate_zeroed	,
		(SELF *self, size_t size)	)

Definition at line 31 of file template.h.

                                                                          {
    return NS(ALLOC, allocate_zeroed)(self->alloc_ref, size);
}

DC_MOCKABLE() [3/4]

DC_MOCKABLE	(	void *	,
		reallocate	,
		(SELF *self, void *ptr, size_t old_size, size_t new_size)	)

Definition at line 35 of file template.h.

                                                                        {
    return NS(ALLOC, reallocate)(self->alloc_ref, ptr, old_size, new_size);
}

DC_MOCKABLE() [4/4]

DC_MOCKABLE	(	void	,
		deallocate	,
		(SELF *self, void *ptr, size_t size)	)

Definition at line 40 of file template.h.

                                                                               {
    NS(ALLOC, deallocate)(self->alloc_ref, ptr, size);
}

DC_TRAIT_ALLOC()

DC_TRAIT_ALLOC

(

SELF

)

DC_TRAIT_REFERENCABLE_BY_PTR()

DC_TRAIT_REFERENCABLE_BY_PTR

(

SELF

)

debug()

DC_PUBLIC void debug ( SELF const * self, dc_debug_fmt fmt, FILE * stream )

static

Definition at line 44 of file template.h.

                                                                                        {
    fprintf(stream, DC_EXPAND_STRING(SELF) "@%p {\n", (void*)self);
    fmt = dc_debug_fmt_scope_begin(fmt);
    dc_debug_fmt_print(fmt, stream, "alloc: ");
    NS(ALLOC, debug)(NS(NS(ALLOC, ref), deref)(self->alloc_ref), fmt, stream);
    fprintf(stream, ",\n");
 
    dc_debug_fmt_print(fmt, stream, "mocking: {\n");
    fmt = dc_debug_fmt_scope_begin(fmt);
 
#define DEBUG_MOCK_TOGGLE(name)                                                                    \
    dc_debug_fmt_print(fmt, stream, DC_EXPAND_STRING(NS(SELF, name)) ": %s,\n",                    \
                       DC_MOCKABLE_ENABLED(NS(SELF, name)) ? "enabled" : "disabled")
 
    DEBUG_MOCK_TOGGLE(allocate_uninit);
    DEBUG_MOCK_TOGGLE(allocate_zeroed);
    DEBUG_MOCK_TOGGLE(reallocate);
    DEBUG_MOCK_TOGGLE(deallocate);
 
#undef DEBUG_MOCK_TOGGLE
 
    fmt = dc_debug_fmt_scope_end(fmt);
    dc_debug_fmt_print(fmt, stream, "}\n");
 
    fmt = dc_debug_fmt_scope_end(fmt);
    dc_debug_fmt_print(fmt, stream, "}");
}

delete()

DC_PUBLIC void delete ( SELF * self )

static

Definition at line 72 of file template.h.

{ DC_ASSUME(self); }

new()

DC_PUBLIC SELF new ( ref alloc_ref )

static

Definition at line 23 of file template.h.

                                                              {
    return (SELF){.alloc_ref = alloc_ref};
}