dbutils/field.c

/*
 * 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 <cx/linked_list.h>
#include <cx/array_list.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 int64_t field_get_int8(DBUOffsetField *f, DBUObject obj) {
    int8_t *i = (int8_t*)(obj + f->offset);
    return *i;
}

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 uint64_t field_get_uint8(DBUOffsetField *f, DBUObject obj) {
    uint8_t *i = (uint8_t*)(obj + f->offset);
    return *i;
}

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 int64_t field_get_int16(DBUOffsetField *f, DBUObject obj) {
    int16_t *i = (int16_t*)(obj + f->offset);
    return *i;
}

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 uint64_t field_get_uint16(DBUOffsetField *f, DBUObject obj) {
    uint16_t *i = (uint16_t*)(obj + f->offset);
    return *i;
}

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 int64_t field_get_int32(DBUOffsetField *f, DBUObject obj) {
    int32_t *i = (int32_t*)(obj + f->offset);
    return *i;
}

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 uint64_t field_get_uint32(DBUOffsetField *f, DBUObject obj) {
    uint32_t *i = (uint32_t*)(obj + f->offset);
    return *i;
}


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 int64_t field_get_int64(DBUOffsetField *f, DBUObject obj) {
    int64_t *i = (int64_t*)(obj + f->offset);
    return *i;
}

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 uint64_t field_get_uint64(DBUOffsetField *f, DBUObject obj) {
    uint64_t *i = (uint64_t*)(obj + f->offset);
    return *i;
}

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;
    }
    *(size_t*)(obj+f->offset) = i;
    return 0;
}

static uint64_t field_get_size(DBUOffsetField *f, DBUObject obj) {
    size_t *i = (size_t*)(obj + f->offset);
    return *i;
}

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 int64_t field_get_ssize(DBUOffsetField *f, DBUObject obj) {
    ssize_t *i = (ssize_t*)(obj + f->offset);
    return *i;
}

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 bool field_get_bool(DBUOffsetField *f, DBUObject obj) {
    bool *i = (bool*)(obj + f->offset);
    return *i;
}

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 double field_get_float(DBUOffsetField *f, DBUObject obj) {
    float *d = (float*)(obj + f->offset);
    return *d;
}

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 double field_get_double(DBUOffsetField *f, DBUObject obj) {
    double *d = (double*)(obj + f->offset);
    return *d;
}

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 cxmutstr field_get_str(DBUOffsetField *f, DBUObject obj, const CxAllocator *a) {
    char **s = (char**)(obj + f->offset);
    return cx_strdup_a(a, cx_str(*s));
}

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 cxmutstr field_get_cxstr(DBUOffsetField *f, DBUObject obj, const CxAllocator *a) {
    cxmutstr *s = (cxmutstr*)(obj + f->offset);
    return cx_strdup_a(a, *s);
}

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 cxmutstr field_get_str_len(DBUObjLenField *f, DBUObject obj, const CxAllocator *a) {
    char *ptr = *(char**)(obj+f->offset_obj);
    size_t len = *(size_t*)(obj+f->offset_len);
    return cx_strdup_a(a, cx_strn(ptr, len));
}

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 cxmutstr field_get_str_intlen(DBUObjLenField *f, DBUObject obj, const CxAllocator *a) {
    char *ptr = *(char**)(obj+f->offset_obj);
    int len = *(int*)(obj+f->offset_len);
    return cx_strdup_a(a, cx_strn(ptr, len));
}


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 DBUField* add_offset_def_field(
        DBUClass *cls, 
        const char *name, 
        off_t offset,
        DBUFieldDefInitFunc def_init,
        DBUFieldInitFunc init,
        bool nonnull, 
        union DBUDefValue def)
{
    DBUField *field = create_offset_def_field(offset, def_init, init, nonnull, def);
    dbuClassAddField(cls, name, field);
    return field;
}

static DBUField* add_offset_fk_field(
        DBUClass *cls, 
        const char *name, 
        off_t offset,
        DBUClass *fkcls,
        DBUFieldInitFunc init,
        bool nonnull)
{
    DBUField *field = create_offset_def_field(offset, NULL, init, nonnull, (union DBUDefValue){ 0 });
    dbuClassAddFKField(cls, name, field, fkcls);
    return field;
}

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;
    field->field.toInt64 = (DBUFieldToInt64Func)field_get_bool;
    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 DBUField* add_offset_str_field(
        DBUClass *cls, 
        const char *name,
        DBUFieldInitFunc init,
        off_t offset,
        bool nonnull)
{
    DBUField *f = create_offset_str_field(init, offset, nonnull);
    dbuClassAddField(cls, name, f);
    return f;
}

static DBUField* 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);
    return (DBUField*)field;
}


DBUField* dbuFieldCreateInt32(off_t offset) {
    DBUField *f = create_offset_def_field(offset, NULL, (DBUFieldInitFunc)field_init_int32, false, (union DBUDefValue){ 0 });
    f->toInt64 = (DBUFieldToInt64Func)field_get_int32;
    return f;
}

DBUField* dbuFieldCreateUInt32(off_t offset) {
    DBUField *f = create_offset_def_field(offset, NULL, (DBUFieldInitFunc)field_init_uint32, false, (union DBUDefValue){ 0 });
    f->toUInt64 = (DBUFieldToUInt64Func)field_get_uint32;
    return f;
}

DBUField* dbuFieldCreateInt64(off_t offset) {
    DBUField *f = create_offset_def_field(offset, NULL, (DBUFieldInitFunc)field_init_int64, false, (union DBUDefValue){ 0 });
    f->toInt64 = (DBUFieldToInt64Func)field_get_int64;
    return f;
}

DBUField* dbuFieldCreateUInt64(off_t offset) {
    DBUField *f = create_offset_def_field(offset, NULL, (DBUFieldInitFunc)field_init_uint64, false, (union DBUDefValue){ 0 });
    f->toUInt64 = (DBUFieldToUInt64Func)field_get_uint64;
    return f;
}

DBUField* dbuFieldCreateString(off_t offset) {
    DBUField *f = create_offset_str_field((DBUFieldInitFunc)field_init_str, offset, false);
    f->toString = (DBUFieldToStringFunc)field_get_str;
    return f;
}

DBUField* dbuFieldCreateCxMutStr(off_t offset) {
    DBUField *f = create_offset_str_field((DBUFieldInitFunc)field_init_cxmutstr, offset, false);
    f->toString = (DBUFieldToStringFunc)field_get_cxstr;
    return f;
}

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


void dbuClassAddInt(DBUClass *cls, const char *name, off_t offset, bool nonnull) {
    DBUField *f = add_offset_def_field(
            cls,
            name,
            offset,
            NULL,
            (DBUFieldInitFunc)field_init_int,
            nonnull,
            (union DBUDefValue){ 0 });
    f->toInt64 = (DBUFieldToInt64Func)field_get_int32;
}

void dbuClassAddUInt(DBUClass *cls, const char *name, off_t offset, bool nonnull) {
    DBUField *f = add_offset_def_field(
            cls,
            name,
            offset,
            NULL,
            (DBUFieldInitFunc)field_init_uint,
            nonnull,
            (union DBUDefValue){ 0 });
    f->toUInt64 = (DBUFieldToUInt64Func)field_get_uint32;
}

void dbuClassAddInt8(DBUClass *cls, const char *name, off_t offset, bool nonnull) {
    DBUField *f = add_offset_def_field(
            cls,
            name,
            offset,
            NULL,
            (DBUFieldInitFunc)field_init_int8,
            nonnull,
            (union DBUDefValue){ 0 });
    f->toInt64 = (DBUFieldToInt64Func)field_get_int8;
}

void dbuClassAddUInt8(DBUClass *cls, const char *name, off_t offset, bool nonnull) {
    DBUField *f = add_offset_def_field(
            cls,
            name,
            offset,
            NULL,
            (DBUFieldInitFunc)field_init_uint8,
            nonnull,
            (union DBUDefValue){ 0 });
    f->toUInt64 = (DBUFieldToUInt64Func)field_get_uint8;
}

void dbuClassAddInt16(DBUClass *cls, const char *name, off_t offset, bool nonnull) {
    DBUField *f = add_offset_def_field(
            cls,
            name,
            offset,
            NULL,
            (DBUFieldInitFunc)field_init_int16,
            nonnull,
            (union DBUDefValue){ 0 });
    f->toInt64 = (DBUFieldToInt64Func)field_get_int16;
}

void dbuClassAddUInt16(DBUClass *cls, const char *name, off_t offset, bool nonnull) {
    DBUField *f = add_offset_def_field(
            cls,
            name,
            offset,
            NULL,
            (DBUFieldInitFunc)field_init_uint16,
            nonnull,
            (union DBUDefValue){ 0 });
    f->toUInt64 = (DBUFieldToUInt64Func)field_get_uint16;
}

void dbuClassAddInt32(DBUClass *cls, const char *name, off_t offset, bool nonnull) {
    DBUField *f = add_offset_def_field(
            cls,
            name,
            offset,
            NULL,
            (DBUFieldInitFunc)field_init_int32,
            nonnull,
            (union DBUDefValue){ 0 });
    f->toInt64 = (DBUFieldToInt64Func)field_get_int32;
}

void dbuClassAddUInt32(DBUClass *cls, const char *name, off_t offset, bool nonnull) {
    DBUField *f = add_offset_def_field(
            cls,
            name,
            offset,
            NULL,
            (DBUFieldInitFunc)field_init_uint32,
            nonnull,
            (union DBUDefValue){ 0 });
    f->toUInt64 = (DBUFieldToUInt64Func)field_get_uint32;
}

void dbuClassAddInt64(DBUClass *cls, const char *name, off_t offset, bool nonnull) {
    DBUField *f = add_offset_def_field(
            cls,
            name,
            offset,
            NULL,
            (DBUFieldInitFunc)field_init_int64,
            nonnull,
            (union DBUDefValue){ 0 });
    f->toInt64 = (DBUFieldToInt64Func)field_get_int64;
}

void dbuClassAddUInt64(DBUClass *cls, const char *name, off_t offset, bool nonnull) {
    DBUField *f = add_offset_def_field(
            cls,
            name,
            offset,
            NULL,
            (DBUFieldInitFunc)field_init_uint64,
            nonnull,
            (union DBUDefValue){ 0 });
    f->toUInt64 = (DBUFieldToUInt64Func)field_get_uint64;
}

void dbuClassAddSize(DBUClass *cls, const char *name, off_t offset, bool nonnull) {
    DBUField *f = add_offset_def_field(
            cls,
            name,
            offset,
            NULL,
            (DBUFieldInitFunc)field_init_size,
            nonnull,
            (union DBUDefValue){ 0 });
    f->toUInt64 = (DBUFieldToUInt64Func)field_get_size;
}

void dbuClassAddSSize(DBUClass *cls, const char *name, off_t offset, bool nonnull) {
    DBUField *f = add_offset_def_field(
            cls,
            name,
            offset,
            NULL,
            (DBUFieldInitFunc)field_init_ssize,
            nonnull,
            (union DBUDefValue){ 0 });
    f->toInt64 = (DBUFieldToInt64Func)field_get_ssize;
}

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) {
    DBUField *f = add_offset_def_field(
            cls,
            name,
            offset,
            NULL,
            (DBUFieldInitFunc)field_init_float,
            nonnull,
            (union DBUDefValue){ 0 });
    f->toDouble = (DBUFieldToDoubleFunc)field_get_float;
}

void dbuClassAddDouble(DBUClass *cls, const char *name, off_t offset, bool nonnull) {
    DBUField *f = add_offset_def_field(
            cls,
            name,
            offset,
            NULL,
            (DBUFieldInitFunc)field_init_double,
            nonnull,
            (union DBUDefValue){ 0 });
    f->toDouble = (DBUFieldToDoubleFunc)field_get_double;
}

void dbuClassAddString(DBUClass *cls, const char *name, off_t offset, bool nonnull) {
    DBUField *f = add_offset_str_field(
            cls, 
            name,
            (DBUFieldInitFunc)field_init_str,
            offset,
            nonnull);
    f->toString = (DBUFieldToStringFunc)field_get_str;
}

void dbuClassAddCXMutStr(DBUClass *cls, const char *name, off_t offset, bool nonnull) {
    DBUField *f = add_offset_str_field(
            cls, 
            name,
            (DBUFieldInitFunc)field_init_cxmutstr,
            offset,
            nonnull);
    f->toString = (DBUFieldToStringFunc)field_get_cxstr;
}

void dbuClassAddStringSize(DBUClass *cls, const char *name, off_t offset, off_t size_offset, bool nonnull) {
    DBUField *f = add_objlen_field(
            cls, 
            name, 
            (DBUFieldInitFunc)field_init_str_size,
            offset,
            size_offset,
            nonnull);
    f->toString = (DBUFieldToStringFunc)field_get_str_len;
}

void dbuClassAddStringIntLen(DBUClass *cls, const char *name, off_t offset, off_t int_offset, bool nonnull) {
    DBUField *f = add_objlen_field(
            cls, 
            name, 
            (DBUFieldInitFunc)field_init_str_intlen,
            offset,
            int_offset,
            nonnull);
    f->toString = (DBUFieldToStringFunc)field_get_str_intlen;
}

void dbuClassAddBuf(DBUClass *cls, const char *name, off_t offset, off_t size_offset, bool nonnull) {
    DBUField *f = add_objlen_field(
            cls, 
            name, 
            (DBUFieldInitFunc)field_init_bytes_size,
            offset,
            size_offset,
            nonnull);
    f->toBinary = (DBUFieldToStringFunc)field_get_str_len;
}

void dbuClassAddBufIntLen(DBUClass *cls, const char *name, off_t offset, off_t int_offset, bool nonnull) {
    DBUField *f = add_objlen_field(
            cls, 
            name, 
            (DBUFieldInitFunc)field_init_bytes_intlen,
            offset,
            int_offset,
            nonnull);
    f->toBinary = (DBUFieldToStringFunc)field_get_str_intlen;
}


void dbuClassAddInt32FK(DBUClass *cls, const char *name, off_t offset, DBUClass *foreign_cls, bool nonnull) {
    DBUField *f = add_offset_fk_field(
            cls,
            name,
            offset,
            foreign_cls,
            (DBUFieldInitFunc)field_init_int32,
            nonnull);
    f->toInt64 = (DBUFieldToInt64Func)field_get_int32;
}

void dbuClassAddUInt32FK(DBUClass *cls, const char *name, off_t offset, DBUClass *foreign_cls, bool nonnull){
    DBUField *f = add_offset_fk_field(
            cls,
            name,
            offset,
            foreign_cls,
            (DBUFieldInitFunc)field_init_uint32,
            nonnull);
    f->toUInt64 = (DBUFieldToUInt64Func)field_get_uint32;
}

void dbuClassAddInt64FK(DBUClass *cls, const char *name, off_t offset, DBUClass *foreign_cls, bool nonnull){
    DBUField *f = add_offset_fk_field(
            cls,
            name,
            offset,
            foreign_cls,
            (DBUFieldInitFunc)field_init_int64,
            nonnull);
    f->toInt64 = (DBUFieldToInt64Func)field_get_int64;
}

void dbuClassAddUInt64FK(DBUClass *cls, const char *name, off_t offset, DBUClass *foreign_cls, bool nonnull){
    DBUField *f = add_offset_fk_field(
            cls,
            name,
            offset,
            foreign_cls,
            (DBUFieldInitFunc)field_init_uint64,
            nonnull);
    f->toUInt64 = (DBUFieldToUInt64Func)field_get_uint64;
}

void dbuClassAddStringFK(DBUClass *cls, const char *name, off_t offset, DBUClass *foreign_cls, bool nonnull){
    DBUField *f = add_offset_fk_field(
            cls, 
            name,
            offset,
            foreign_cls,
            (DBUFieldInitFunc)field_init_str,
            nonnull);
    f->toString = (DBUFieldToStringFunc)field_get_str;
}

void dbuClassAddCXMutStrFK(DBUClass *cls, const char *name, off_t offset, DBUClass *foreign_cls, bool nonnull){
    DBUField *f = add_offset_fk_field(
            cls, 
            name,
            offset,
            foreign_cls,
            (DBUFieldInitFunc)field_init_cxmutstr,
            nonnull);
    f->toString = (DBUFieldToStringFunc)field_get_cxstr;
}


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

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

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

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

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

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

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

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

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

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

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

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


// 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;
}

static DBUObject get_obj_ptr(DBUField *f, DBUObject obj) {
    DBUOffsetField *field = (DBUOffsetField*)f;
    return *(void**)(obj+field->offset);
}

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->field.toObject = get_obj_ptr;
    field->field.objType = foreign_cls;
    field->offset = offset;
    field->def.def = 0;
    dbuClassAddObjField(cls, name, (DBUField*)field, foreign_cls);
}

static int linked_list_add(DBUField *f, const CxAllocator *a, DBUObject obj, void *child) {
    DBUOffsetField *field = (DBUOffsetField*)f;
    CxList **list = (CxList**)(obj+field->offset);
    if(*list) {
        *list = cxLinkedListCreate(a, NULL, CX_STORE_POINTERS);
        if(!(*list)) {
            return 1;
        }
    }
    return cxListAdd(*list, child);;
}

static DBUObject linkedlist_create_obj(DBUObjectResult *result, DBUClass *type, const CxAllocator *a) {
    void *obj = cxMalloc(a, type->obj_size);
    if(obj) {
        memset(obj, 0, type->obj_size);
    }
    return obj;
}
static int linkedlist_add(DBUObjectResult *result, DBUObject parent, DBUClass *type, void *obj, CxList *fk, const CxAllocator *a) {
    DBUOffsetField *field  = result->userdata1;
    DBUClass *cls = result->userdata2;
    CxList **list = (CxList**)(parent+field->offset);
    if(!*list) {
        *list = cxLinkedListCreate(a, NULL, CX_STORE_POINTERS);
        if(!(*list)) {
            return 1;
        }
    }
    cxListAdd(*list, obj);;
    return 0;
}

static size_t dbu_cxlist_length(DBUAbstractList *list) {
    DBUListImpl *ls = (DBUListImpl*)list;
    return cxListSize(ls->list.list);
}

static void* dbu_cxlist_get(DBUAbstractList *list, size_t index) {
    DBUListImpl *ls = (DBUListImpl*)list;
    return cxListAt(ls->list.list, index);
}

static DBUField* listimpl_field(DBUAbstractList *list, void *elm) {
    DBUListImpl *ls = (DBUListImpl*)list;
    return &ls->field;
}

static CxIterator dbu_cxlist_iterator(DBUAbstractList *list) {
    DBUListImpl *ls = (DBUListImpl*)list;
    return cxListIterator(ls->list.list);
}

static DBUObject elmfield_toObject(DBUField *f, DBUObject obj) {
    return obj;
}

static DBUAbstractList* cxlist_tolist(DBUField *f, DBUObject obj) {
    DBUOffsetField *field = (DBUOffsetField*)f;
    DBUListImpl *list = malloc(sizeof(DBUListImpl));
    list->list.list = *(CxList**)(obj+field->offset);;
    list->list.length = dbu_cxlist_length;
    list->list.get = dbu_cxlist_get;
    list->list.iterator = dbu_cxlist_iterator;
    list->list.elementField = listimpl_field;
    list->list.free = (void(*)(DBUAbstractList*))free;
    memset(&list->field, 0, sizeof(DBUField));
    list->field.toObject = elmfield_toObject;
    list->field.objType = field->field.builder.userdata2;
    return (DBUAbstractList*)list;
}

void dbuClassAddCxLinkedList(DBUClass *cls, const char *name, off_t offset, DBUClass *foreign_cls) {
    DBUOffsetField *field = malloc(sizeof(DBUOffsetField));
    memset(field, 0, sizeof(DBUOffsetField));
    field->offset = offset;
    field->def.def = 0;
    field->field.builder.userdata1 = field;
    field->field.builder.userdata2 = foreign_cls;
    field->field.builder.create = linkedlist_create_obj;
    field->field.builder.add = linkedlist_add;
    field->field.toList = cxlist_tolist;
    // TODO: can we pass name to dbuClassAddObjField?
    dbuClassAddObjField(cls, NULL, (DBUField*)field, foreign_cls);
    field->field.name = name ? cx_strdup(cx_str(name)) : (cxmutstr){NULL,0};
    //dbuClassAddParentObjField(foreign_cls, name, cls, (DBUField*)field);
}

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) {
    
}