Mercurial > hg > dbutils / file revision

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2024 Olaf Wintermann. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the followign disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>

#include "field.h"

/* -------------------- Default Initializer Functions -------------------- */

static int field_def_init_int(DBUOffsetField *f, const CxAllocator *a, DBUObject obj) {
    *(int*)(obj+f->offset) = (int)f->def.def;
    return 0;
}

static int field_def_init_uint(DBUOffsetField *f, const CxAllocator *a, DBUObject obj) {
    *(unsigned int*)(obj+f->offset) = (unsigned int)f->def.udef;
    return 0;
}

static int field_def_init_int16(DBUOffsetField *f, const CxAllocator *a, DBUObject obj) {
    *(int16_t*)(obj+f->offset) = (int16_t)f->def.def;
    return 0;
}

static int field_def_init_uint16(DBUOffsetField *f, const CxAllocator *a, DBUObject obj) {
    *(uint16_t*)(obj+f->offset) = (uint16_t)f->def.udef;
    return 0;
}

static int field_def_init_int32(DBUOffsetField *f, const CxAllocator *a, DBUObject obj) {
    *(int32_t*)(obj+f->offset) = (int32_t)f->def.def;
    return 0;
}

static int field_def_init_uint32(DBUOffsetField *f, const CxAllocator *a, DBUObject obj) {
    *(uint32_t*)(obj+f->offset) = (int32_t)f->def.udef;
    return 0;
}

static int field_def_init_int64(DBUOffsetField *f, const CxAllocator *a, DBUObject obj) {
    *(int64_t*)(obj+f->offset) = f->def.def;
    return 0;
}

static int field_def_init_uint64(DBUOffsetField *f, const CxAllocator *a, DBUObject obj) {
    *(uint64_t*)(obj+f->offset) = (uint64_t)f->def.udef;
    return 0;
}

static int field_def_init_size(DBUOffsetField *f, const CxAllocator *a, DBUObject obj) {
    *(size_t*)(obj+f->offset) = (size_t)f->def.udef;
    return 0;
}

static int field_def_init_ssize(DBUOffsetField *f, const CxAllocator *a, DBUObject obj) {
    *(ssize_t*)(obj+f->offset) = (ssize_t)f->def.def;
    return 0;
}

static int field_def_init_float(DBUOffsetField *f, const CxAllocator *a, DBUObject obj) {
    *(float*)(obj+f->offset) = (float)f->def.fdef;
    return 0;
}

static int field_def_init_double(DBUOffsetField *f, const CxAllocator *a, DBUObject obj) {
    *(double*)(obj+f->offset) = (double)f->def.ddef;
    return 0;
}


/* --------------------     Initializer Functions     -------------------- */

static int str2int(const char *str, int64_t *i) {
    if(!str || *str == 0) {
        return 0;
    }
    
    char *endptr;
    long long v = strtoll(str, &endptr, 10);
    *i = v;
    return *endptr == 0;
}

static int str2uint(const char *str, uint64_t *u) {
    if(!str || *str == 0) {
        return 0;
    }
    
    char *endptr;
    unsigned long long v = strtoull(str, &endptr, 10);
    *u = v;
    return *endptr == 0;
}

static int field_init_int(
        DBUOffsetField *f,
        const CxAllocator *a,
        DBUObject obj,
        const char *value,
        size_t length)
{
    int64_t i;
    if(!str2int(value, &i)) {
        return 1;
    }
    if(i < INT_MIN || i > INT_MAX) {
        return 1;
    }
    *(int*)(obj+f->offset) = (int)i;
    return 0;
}

static int field_init_uint(
        DBUOffsetField *f,
        const CxAllocator *a,
        DBUObject obj,
        const char *value,
        size_t length)
{
    uint64_t i;
    if(!str2uint(value, &i)) {
        return 1;
    }
    if(i > UINT_MAX) {
        return 1;
    }
    *(unsigned int*)(obj+f->offset) = (unsigned int)i;
    return 0;
}

static int field_init_int8(
        DBUOffsetField *f,
        const CxAllocator *a,
        DBUObject obj,
        const char *value,
        size_t length)
{
    int64_t i;
    if(!str2int(value, &i)) {
        return 1;
    }
    if(i < INT8_MIN || i > INT8_MAX) {
        return 1;
    }
    *(int8_t*)(obj+f->offset) = (int8_t)i;
    return 0;
}

static int field_init_uint8(
        DBUOffsetField *f,
        const CxAllocator *a,
        DBUObject obj,
        const char *value,
        size_t length)
{
    uint64_t i;
    if(!str2uint(value, &i)) {
        return 1;
    }
    if(i > UINT8_MAX) {
        return 1;
    }
    *(uint8_t*)(obj+f->offset) = (uint8_t)i;
    return 0;
}

static int field_init_int16(
        DBUOffsetField *f,
        const CxAllocator *a,
        DBUObject obj,
        const char *value,
        size_t length)
{
    int64_t i;
    if(!str2int(value, &i)) {
        return 1;
    }
    if(i < INT16_MIN || i > INT16_MAX) {
        return 1;
    }
    *(int16_t*)(obj+f->offset) = (int16_t)i;
    return 0;
}

static int field_init_uint16(
        DBUOffsetField *f,
        const CxAllocator *a,
        DBUObject obj,
        const char *value,
        size_t length)
{
    uint64_t i;
    if(!str2uint(value, &i)) {
        return 1;
    }
    if(i > UINT16_MAX) {
        return 1;
    }
    *(uint16_t*)(obj+f->offset) = (uint16_t)i;
    return 0;
}

static int field_init_int32(
        DBUOffsetField *f,
        const CxAllocator *a,
        DBUObject obj,
        const char *value,
        size_t length)
{
    int64_t i;
    if(!str2int(value, &i)) {
        return 1;
    }
    if(i < INT32_MIN || i > INT32_MAX) {
        return 1;
    }
    *(int32_t*)(obj+f->offset) = (int32_t)i;
    return 0;
}

static int field_init_uint32(
        DBUOffsetField *f,
        const CxAllocator *a,
        DBUObject obj,
        const char *value,
        size_t length)
{
    uint64_t i;
    if(!str2uint(value, &i)) {
        return 1;
    }
    if(i > UINT32_MAX) {
        return 1;
    }
    *(uint32_t*)(obj+f->offset) = (uint32_t)i;
    return 0;
}

static int field_init_int64(
        DBUOffsetField *f,
        const CxAllocator *a,
        DBUObject obj,
        const char *value,
        size_t length)
{
    int64_t i;
    if(!str2int(value, &i)) {
        return 1;
    }
    *(int64_t*)(obj+f->offset) = i;
    return 0;
}

static int field_init_uint64(
        DBUOffsetField *f,
        const CxAllocator *a,
        DBUObject obj,
        const char *value,
        size_t length)
{
    uint64_t i;
    if(!str2uint(value, &i)) {
        return 1;
    }
    *(uint64_t*)(obj+f->offset) = i;
    return 0;
}

static int field_init_size(
        DBUOffsetField *f,
        const CxAllocator *a,
        DBUObject obj,
        const char *value,
        size_t length)
{
    uint64_t i;
    if(!str2uint(value, &i)) {
        return 1;
    }
    *(uint64_t*)(obj+f->offset) = i;
    return 0;
}

static int field_init_ssize(
        DBUOffsetField *f,
        const CxAllocator *a,
        DBUObject obj,
        const char *value,
        size_t length)
{
    int64_t i;
    if(!str2int(value, &i)) {
        return 1;
    }
    *(ssize_t*)(obj+f->offset) = (ssize_t)i;
    return 0;
}

static int field_init_bool(
        DBUOffsetField *f,
        const CxAllocator *a,
        DBUObject obj,
        const char *value,
        size_t length)
{
    bool boolvalue = 0;
    if(value) {
        char c = value[0];
        if(c == 't' || c == 'T' || c == '1') {
            boolvalue = 1;
        }
    }
    *(bool*)(obj+f->offset) = boolvalue;
    return 0;
}

static int field_init_float(
        DBUOffsetField *f,
        const CxAllocator *a,
        DBUObject obj,
        const char *value,
        size_t length)
{
    char *endptr;
    float v = strtof(value, &endptr);
    if(!endptr || *endptr != 0) {
        return 1;
    }
    *(float*)(obj+f->offset) = v;
    return 0;
}

static int field_init_double(
        DBUOffsetField *f,
        const CxAllocator *a,
        DBUObject obj,
        const char *value,
        size_t length)
{
    char *endptr;
    double v = strtod(value, &endptr);
    if(!endptr || *endptr != 0) {
        return 1;
    }
    *(double*)(obj+f->offset) = v;
    return 0;
}


static int field_init_str(
        DBUOffsetField *f,
        const CxAllocator *a,
        DBUObject obj,
        const char *value,
        size_t length)
{
    cxmutstr m = cx_strdup_a(a, cx_strn(value, length));
    if(!m.ptr) {
        return 1;
    }
    *(char**)(obj+f->offset) = m.ptr;
    return 0;
}

static int field_init_cxmutstr(
        DBUOffsetField *f,
        const CxAllocator *a,
        DBUObject obj,
        const char *value,
        size_t length)
{
    cxmutstr m = cx_strdup_a(a, cx_strn(value, length));
    if(!m.ptr) {
        return 1;
    }
    *(cxmutstr*)(obj+f->offset) = m;
    return 0;
}

static int field_init_str_size(
        DBUObjLenField *f,
        const CxAllocator *a,
        DBUObject obj,
        const char *value,
        size_t length)
{
    cxmutstr m = cx_strdup_a(a, cx_strn(value, length));
    if(!m.ptr) {
        return 1;
    }
    *(char**)(obj+f->offset_obj) = m.ptr;
    *(size_t*)(obj+f->offset_len) = m.length;
    return 0;
}

static int field_init_str_intlen(
        DBUObjLenField *f,
        const CxAllocator *a,
        DBUObject obj,
        const char *value,
        size_t length)
{
    cxmutstr m = cx_strdup_a(a, cx_strn(value, length));
    if(!m.ptr) {
        return 1;
    }
    *(char**)(obj+f->offset_obj) = m.ptr;
    *(int*)(obj+f->offset_len) = (int)m.length;
    return 0;
}

static int field_init_bytes_size(
        DBUObjLenField *f,
        const CxAllocator *a,
        DBUObject obj,
        const char *value,
        size_t length)
{
    char *bytes = cxMalloc(a, length);
    if(!bytes) {
        return 1;
    }
    memcpy(bytes, value, length);
    *(char**)(obj+f->offset_obj) = bytes;
    *(size_t*)(obj+f->offset_len) = length;
    return 0;
}

static int field_init_bytes_intlen(
        DBUObjLenField *f,
        const CxAllocator *a,
        DBUObject obj,
        const char *value,
        size_t length)
{
    char *bytes = cxMalloc(a, length);
    if(!bytes) {
        return 1;
    }
    memcpy(bytes, value, length);
    *(char**)(obj+f->offset_obj) = bytes;
    *(int*)(obj+f->offset_len) = (int)length;
    return 0;
}


/* --------------------     FIELD CONSTRUCTOR      -------------------- */

static DBUField* create_offset_def_field(
        off_t offset,
        DBUFieldDefInitFunc def_init,
        DBUFieldInitFunc init,
        bool nonnull, 
        union DBUDefValue def)
{
    DBUOffsetField *field = calloc(1, sizeof(DBUOffsetField));
    field->field.initDefaultValue = def_init;
    field->field.initValue = init;
    field->field.nonnull = nonnull;
    field->field.query_length = false;
    field->offset = offset;
    field->def = def;
    return (DBUField*)field;
}

static void add_offset_def_field(
        DBUClass *cls, 
        const char *name, 
        off_t offset,
        DBUFieldDefInitFunc def_init,
        DBUFieldInitFunc init,
        bool nonnull, 
        union DBUDefValue def)
{
    dbuClassAddField(cls, name, create_offset_def_field(offset, def_init, init, nonnull, def));
}

static void add_bool(
        DBUClass *cls, 
        const char *name, 
        off_t offset,
        bool nonnull)
{
    DBUOffsetField *field = calloc(1, sizeof(DBUOffsetField));
    field->field.initDefaultValue = NULL;
    field->field.initValue = (DBUFieldInitFunc)field_init_bool;
    field->field.nonnull = nonnull;
    field->field.query_length = false;
    field->offset = offset;
    field->def.def = 0;
    dbuClassAddField(cls, name, (DBUField*)field);
}

static DBUField* create_offset_str_field(
        DBUFieldInitFunc init,
        off_t offset,
        bool nonnull)
{
    DBUOffsetField *field = calloc(1, sizeof(DBUOffsetField));
    field->field.initDefaultValue = NULL;
    field->field.initValue = (DBUFieldInitFunc)init;
    field->field.nonnull = nonnull;
    field->field.query_length = true;
    field->offset = offset;
    field->def.def = 0;
    return (DBUField*)field;
}

static void add_offset_str_field(
        DBUClass *cls, 
        const char *name,
        DBUFieldInitFunc init,
        off_t offset,
        bool nonnull)
{
    DBUOffsetField *field = calloc(1, sizeof(DBUOffsetField));
    field->field.initDefaultValue = NULL;
    field->field.initValue = (DBUFieldInitFunc)init;
    field->field.nonnull = nonnull;
    field->field.query_length = true;
    field->offset = offset;
    field->def.def = 0;
    dbuClassAddField(cls, name, create_offset_str_field(init, offset, nonnull));
}

static void add_objlen_field(
        DBUClass *cls, 
        const char *name, 
        DBUFieldInitFunc init,
        off_t offset,
        off_t size_offset,
        bool nonnull)
{
    DBUObjLenField *field = malloc(sizeof(DBUObjLenField));
    memset(field, 0, sizeof(DBUObjLenField));
    field->field.initDefaultValue = NULL;
    field->field.initValue = (DBUFieldInitFunc)init;
    field->field.nonnull = nonnull;
    field->field.query_length = true;
    field->offset_obj = offset;
    field->offset_len = size_offset;
    dbuClassAddField(cls, name, (DBUField*)field);
}




DBUField* dbuFieldCreateInt32(off_t offset) {
    return create_offset_def_field(offset, NULL, (DBUFieldInitFunc)field_init_int32, false, (union DBUDefValue){ 0 });
}

DBUField* dbuFieldCreateUInt32(off_t offset) {
    return create_offset_def_field(offset, NULL, (DBUFieldInitFunc)field_init_uint32, false, (union DBUDefValue){ 0 });
}

DBUField* dbuFieldCreateInt64(off_t offset) {
    return create_offset_def_field(offset, NULL, (DBUFieldInitFunc)field_init_int64, false, (union DBUDefValue){ 0 });
}

DBUField* dbuFieldCreateUInt64(off_t offset) {
    return create_offset_def_field(offset, NULL, (DBUFieldInitFunc)field_init_uint64, false, (union DBUDefValue){ 0 });
}

DBUField* dbuFieldCreateString(off_t offset) {
    return create_offset_str_field((DBUFieldInitFunc)field_init_str, offset, false);
}

DBUField* dbuFieldCreateCxMutStr(off_t offset) {
    return create_offset_str_field((DBUFieldInitFunc)field_init_cxmutstr, offset, false);
}

/* --------------------            PUBLIC            -------------------- */


void dbuClassAddInt(DBUClass *cls, const char *name, off_t offset, bool nonnull) {
    add_offset_def_field(
            cls,
            name,
            offset,
            NULL,
            (DBUFieldInitFunc)field_init_int,
            nonnull,
            (union DBUDefValue){ 0 });
}

void dbuClassAddUInt(DBUClass *cls, const char *name, off_t offset, bool nonnull) {
    add_offset_def_field(
            cls,
            name,
            offset,
            NULL,
            (DBUFieldInitFunc)field_init_uint,
            nonnull,
            (union DBUDefValue){ 0 });
}

void dbuClassAddInt8(DBUClass *cls, const char *name, off_t offset, bool nonnull) {
    add_offset_def_field(
            cls,
            name,
            offset,
            NULL,
            (DBUFieldInitFunc)field_init_int8,
            nonnull,
            (union DBUDefValue){ 0 });
}

void dbuClassAddUInt8(DBUClass *cls, const char *name, off_t offset, bool nonnull) {
    add_offset_def_field(
            cls,
            name,
            offset,
            NULL,
            (DBUFieldInitFunc)field_init_uint8,
            nonnull,
            (union DBUDefValue){ 0 });
}

void dbuClassAddInt16(DBUClass *cls, const char *name, off_t offset, bool nonnull) {
    add_offset_def_field(
            cls,
            name,
            offset,
            NULL,
            (DBUFieldInitFunc)field_init_int16,
            nonnull,
            (union DBUDefValue){ 0 });
}

void dbuClassAddUInt16(DBUClass *cls, const char *name, off_t offset, bool nonnull) {
    add_offset_def_field(
            cls,
            name,
            offset,
            NULL,
            (DBUFieldInitFunc)field_init_uint16,
            nonnull,
            (union DBUDefValue){ 0 });
}

void dbuClassAddInt32(DBUClass *cls, const char *name, off_t offset, bool nonnull) {
    add_offset_def_field(
            cls,
            name,
            offset,
            NULL,
            (DBUFieldInitFunc)field_init_int32,
            nonnull,
            (union DBUDefValue){ 0 });
}

void dbuClassAddUInt32(DBUClass *cls, const char *name, off_t offset, bool nonnull) {
    add_offset_def_field(
            cls,
            name,
            offset,
            NULL,
            (DBUFieldInitFunc)field_init_uint32,
            nonnull,
            (union DBUDefValue){ 0 });
}

void dbuClassAddInt64(DBUClass *cls, const char *name, off_t offset, bool nonnull) {
    add_offset_def_field(
            cls,
            name,
            offset,
            NULL,
            (DBUFieldInitFunc)field_init_int64,
            nonnull,
            (union DBUDefValue){ 0 });
}

void dbuClassAddUInt64(DBUClass *cls, const char *name, off_t offset, bool nonnull) {
    add_offset_def_field(
            cls,
            name,
            offset,
            NULL,
            (DBUFieldInitFunc)field_init_uint64,
            nonnull,
            (union DBUDefValue){ 0 });
}

void dbuClassAddSize(DBUClass *cls, const char *name, off_t offset, bool nonnull) {
    add_offset_def_field(
            cls,
            name,
            offset,
            NULL,
            (DBUFieldInitFunc)field_init_size,
            nonnull,
            (union DBUDefValue){ 0 });
}

void dbuClassAddSSize(DBUClass *cls, const char *name, off_t offset, bool nonnull) {
    add_offset_def_field(
            cls,
            name,
            offset,
            NULL,
            (DBUFieldInitFunc)field_init_ssize,
            nonnull,
            (union DBUDefValue){ 0 });
}

void dbuClassAddBool(DBUClass *cls, const char *name, off_t offset, bool nonnull) {
    add_bool(
            cls, 
            name, 
            offset,
            nonnull);
}

void dbuClassAddFloat(DBUClass *cls, const char *name, off_t offset, bool nonnull) {
    add_offset_def_field(
            cls,
            name,
            offset,
            NULL,
            (DBUFieldInitFunc)field_init_float,
            nonnull,
            (union DBUDefValue){ 0 });
}

void dbuClassAddDouble(DBUClass *cls, const char *name, off_t offset, bool nonnull) {
    add_offset_def_field(
            cls,
            name,
            offset,
            NULL,
            (DBUFieldInitFunc)field_init_double,
            nonnull,
            (union DBUDefValue){ 0 });
}

void dbuClassAddString(DBUClass *cls, const char *name, off_t offset, bool nonnull) {
    add_offset_str_field(
            cls, 
            name,
            (DBUFieldInitFunc)field_init_str,
            offset,
            nonnull);
}

void dbuClassAddCXMutStr(DBUClass *cls, const char *name, off_t offset, bool nonnull) {
    add_offset_str_field(
            cls, 
            name,
            (DBUFieldInitFunc)field_init_cxmutstr,
            offset,
            nonnull);
}

void dbuClassAddStringSize(DBUClass *cls, const char *name, off_t offset, off_t size_offset, bool nonnull) {
    add_objlen_field(
            cls, 
            name, 
            (DBUFieldInitFunc)field_init_str_size,
            offset,
            size_offset,
            nonnull);
}

void dbuClassAddStringIntLen(DBUClass *cls, const char *name, off_t offset, off_t int_offset, bool nonnull) {
    add_objlen_field(
            cls, 
            name, 
            (DBUFieldInitFunc)field_init_str_intlen,
            offset,
            int_offset,
            nonnull);
}

void dbuClassAddBuf(DBUClass *cls, const char *name, off_t offset, off_t size_offset, bool nonnull) {
    add_objlen_field(
            cls, 
            name, 
            (DBUFieldInitFunc)field_init_bytes_size,
            offset,
            size_offset,
            nonnull);
}

void dbuClassAddBufIntLen(DBUClass *cls, const char *name, off_t offset, off_t int_offset, bool nonnull) {
    add_objlen_field(
            cls, 
            name, 
            (DBUFieldInitFunc)field_init_bytes_intlen,
            offset,
            int_offset,
            nonnull);
}


void dbuClassAddIntDef(DBUClass *cls, const char *name, off_t offset, int def) {
    union DBUDefValue defvalue;
    defvalue.def = def;
    add_offset_def_field(
            cls,
            name,
            offset,
            (DBUFieldDefInitFunc)field_def_init_int,
            (DBUFieldInitFunc)field_init_int,
            false,
            (union DBUDefValue){ 0 });
}

void dbuClassAddUIntDef(DBUClass *cls, const char *name, off_t offset, unsigned int def) {
    union DBUDefValue defvalue;
    defvalue.udef = def;
    add_offset_def_field(
            cls,
            name,
            offset,
            (DBUFieldDefInitFunc)field_def_init_uint,
            (DBUFieldInitFunc)field_init_uint,
            false,
            (union DBUDefValue){ 0 });
}

void dbuClassAddInt16Def(DBUClass *cls, const char *name, off_t offset, int16_t def) {
    union DBUDefValue defvalue;
    defvalue.def = def;
    add_offset_def_field(
            cls,
            name,
            offset,
            (DBUFieldDefInitFunc)field_def_init_int16,
            (DBUFieldInitFunc)field_init_int16,
            false,
            (union DBUDefValue){ 0 });
}

void dbuClassAddUInt16Def(DBUClass *cls, const char *name, off_t offset, uint16_t def) {
    union DBUDefValue defvalue;
    defvalue.udef = def;
    add_offset_def_field(
            cls,
            name,
            offset,
            (DBUFieldDefInitFunc)field_def_init_uint16,
            (DBUFieldInitFunc)field_init_uint16,
            false,
            (union DBUDefValue){ 0 });
}

void dbuClassAddInt32Def(DBUClass *cls, const char *name, off_t offset, int32_t def) {
    union DBUDefValue defvalue;
    defvalue.def = def;
    add_offset_def_field(
            cls,
            name,
            offset,
            (DBUFieldDefInitFunc)field_def_init_int32,
            (DBUFieldInitFunc)field_init_int32,
            false,
            (union DBUDefValue){ 0 });
}

void dbuClassAddUInt32Def(DBUClass *cls, const char *name, off_t offset, uint32_t def) {
    union DBUDefValue defvalue;
    defvalue.udef = def;
    add_offset_def_field(
            cls,
            name,
            offset,
            (DBUFieldDefInitFunc)field_def_init_uint32,
            (DBUFieldInitFunc)field_init_uint32,
            false,
            (union DBUDefValue){ 0 });
}

void dbuClassAddInt64Def(DBUClass *cls, const char *name, off_t offset, int64_t def) {
    union DBUDefValue defvalue;
    defvalue.def = def;
    add_offset_def_field(
            cls,
            name,
            offset,
            (DBUFieldDefInitFunc)field_def_init_int64,
            (DBUFieldInitFunc)field_init_int64,
            false,
            (union DBUDefValue){ 0 });
}

void dbuClassAddUInt64Def(DBUClass *cls, const char *name, off_t offset, uint64_t def) {
    union DBUDefValue defvalue;
    defvalue.def = def;
    add_offset_def_field(
            cls,
            name,
            offset,
            (DBUFieldDefInitFunc)field_def_init_uint64,
            (DBUFieldInitFunc)field_init_uint64,
            false,
            (union DBUDefValue){ 0 });
}

void dbuClassAddSizeDef(DBUClass *cls, const char *name, off_t offset, size_t def) {
    union DBUDefValue defvalue;
    defvalue.udef = def;
    add_offset_def_field(
            cls,
            name,
            offset,
            (DBUFieldDefInitFunc)field_def_init_size,
            (DBUFieldInitFunc)field_init_size,
            false,
            (union DBUDefValue){ 0 });
}

void dbuClassAddSSizeDef(DBUClass *cls, const char *name, off_t offset, ssize_t def) {
    union DBUDefValue defvalue;
    defvalue.def = def;
    add_offset_def_field(
            cls,
            name,
            offset,
            (DBUFieldDefInitFunc)field_def_init_ssize,
            (DBUFieldInitFunc)field_init_ssize,
            false,
            (union DBUDefValue){ 0 });
}

void dbuClassAddFloatDef(DBUClass *cls, const char *name, off_t offset, float def) {
    union DBUDefValue defvalue;
    defvalue.fdef = def;
    add_offset_def_field(
            cls,
            name,
            offset,
            (DBUFieldDefInitFunc)field_def_init_float,
            (DBUFieldInitFunc)field_init_float,
            false,
            (union DBUDefValue){ 0 });
}

void dbuClassAddDoubleDef(DBUClass *cls, const char *name, off_t offset, double def) {
    union DBUDefValue defvalue;
    defvalue.ddef = def;
    add_offset_def_field(
            cls,
            name,
            offset,
            (DBUFieldDefInitFunc)field_def_init_double,
            (DBUFieldInitFunc)field_init_double,
            false,
            (union DBUDefValue){ 0 });
}


// add complex members

static int set_obj_ptr(DBUField *f, const CxAllocator *a, DBUObject obj, void *child) {
    DBUOffsetField *field = (DBUOffsetField*)f;
    *(void**)(obj+field->offset) = child;
    return 0;
}

void dbuClassAddObj(DBUClass *cls, const char *name, off_t offset, DBUClass *foreign_cls) {
    DBUOffsetField *field = malloc(sizeof(DBUOffsetField));
    memset(field, 0, sizeof(DBUOffsetField));
    field->field.initObjValue = set_obj_ptr;
    field->offset = offset;
    field->def.def = 0;
    dbuClassAddObjField(cls, name, (DBUField*)field, foreign_cls);
}

void dbuClassAddLinkedList(DBUClass *cls, const char *name, off_t offset, DBUClass *foreign_cls) {
    
}

void dbuClassAddValueLinkedList(DBUClass *cls, const char *name, off_t offset, DBUClass *foreign_cls) {
    
}

void dbuClassAddCxArrayList(DBUClass *cls, const char *name, off_t offset, DBUClass *foreign_cls) {
    
}

void dbuClassAddValueArrayList(DBUClass *cls, const char *name, off_t offset, DBUClass *foreign_cls) {
    
}

void dbuClassAddArray(DBUClass *cls, const char *name, off_t array_offset, off_t size_offset, DBUClass *foreign_cls) {
    
}

void dbuClassAddValueArray(DBUClass *cls, const char *name, off_t array_offset, off_t size_offset, DBUClass *foreign_cls) {
    
}