template.h

Go to the documentation of this file.

 
#include <derive-c/core/includes/def.h>
#if !defined(SKIP_INCLUDES)
    #include "includes.h"
#endif
 
#include <derive-c/test/mock_in_struct/def.h>
#include <derive-c/core/alloc/def.h>
#include <derive-c/core/self/def.h>
 
typedef struct {
    NS(ALLOC, ref) alloc_ref;
} SELF;
 
DC_PUBLIC static SELF NS(SELF, new)(NS(ALLOC, ref) alloc_ref) {
    return (SELF){.alloc_ref = alloc_ref};
}
 
DC_MOCKABLE(void*, NS(SELF, allocate_uninit), (SELF * self, size_t size)) {
    return NS(ALLOC, allocate_uninit)(self->alloc_ref, size);
}
 
DC_MOCKABLE(void*, NS(SELF, allocate_zeroed), (SELF * self, size_t size)) {
    return NS(ALLOC, allocate_zeroed)(self->alloc_ref, size);
}
 
DC_MOCKABLE(void*, NS(SELF, reallocate),
            (SELF * self, void* ptr, size_t old_size, size_t new_size)) {
    return NS(ALLOC, reallocate)(self->alloc_ref, ptr, old_size, new_size);
}
 
DC_MOCKABLE(void, NS(SELF, deallocate), (SELF * self, void* ptr, size_t size)) {
    NS(ALLOC, deallocate)(self->alloc_ref, ptr, size);
}
 
DC_PUBLIC static void NS(SELF, debug)(SELF const* self, dc_debug_fmt fmt, FILE* stream) {
    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, "}");
}
 
DC_PUBLIC static void NS(SELF, delete)(SELF* self) { DC_ASSUME(self); }
 
DC_TRAIT_REFERENCABLE_BY_PTR(SELF);
 
DC_TRAIT_ALLOC(SELF);
 
#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>