dbutils/class.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 following 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 "class.h"
#include "field.h"

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

#include <cx/hash_map.h>

static void field_destructor(DBUField *f) {
    if(f->destructor) {
        f->destructor(f);
    }
    free(f);
}

DBUClass* dbuClassCreate(const char *name) {
    DBUClass *cls = malloc(sizeof(DBUClass));
    memset(cls, 0, sizeof(DBUClass));
    
    cls->name = cx_strdup(cx_str(name));
    cls->fields = cxHashMapCreateSimple(CX_STORE_POINTERS);
    cls->fields->collection.simple_destructor = (cx_destructor_func)field_destructor;
    cls->obj_fields = cxHashMapCreateSimple(CX_STORE_POINTERS);
    cls->obj_fields->collection.simple_destructor = (cx_destructor_func)field_destructor;
    cls->foreign_keys = cxHashMapCreateSimple(sizeof(DBUForeignKeyField));
    
    return cls;
}

void dbuClassFree(DBUClass *cls) {
    cxMapFree(cls->fields);
    free(cls->name.ptr);
    free(cls->primary_key_column.ptr);
    free(cls);
}

void dbuClassAddField(DBUClass *cls, const char *name, DBUField *field) {
    free(field->name.ptr);
    field->name = cx_strdup(cx_str(name));
    cxMapPut(cls->fields, name, field);
}

void dbuClassAddFKField(DBUClass *cls, const char *name, DBUField *field, DBUClass *fkcls) {
    DBUForeignKeyField val;
    val.field = field;
    val.cls = fkcls;
    field->foreignKeyClass = fkcls;
    cxMapPut(cls->foreign_keys, name, &val);
    dbuClassAddField(cls, name, field);
}

void dbuClassAddObjField(DBUClass *cls, const char *name, DBUField *field, DBUClass *foreign_cls) {
    free(field->name.ptr);
    field->name = name ? cx_strdup(cx_str(name)) : (cxmutstr){NULL,0};
    cxMapPut(cls->obj_fields, foreign_cls->name, field);
}


void dbuClassSetPrimaryKeyInt32(DBUClass *cls, const char *column_name, off_t offset) {
    cls->primary_key_column = cx_strdup(cx_str(column_name));
    cls->primary_key = dbuFieldCreateInt32(offset);
    dbuClassAddField(cls, column_name, cls->primary_key);
}

void dbuClassSetPrimaryKeyUInt32(DBUClass *cls, const char *column_name, off_t offset) {
    cls->primary_key_column = cx_strdup(cx_str(column_name));
    cls->primary_key = dbuFieldCreateUInt32(offset);
    dbuClassAddField(cls, column_name, cls->primary_key);
}

void dbuClassSetPrimaryKeyInt64(DBUClass *cls, const char *column_name, off_t offset) {
    cls->primary_key_column = cx_strdup(cx_str(column_name));
    cls->primary_key = dbuFieldCreateInt64(offset);
    dbuClassAddField(cls, column_name, cls->primary_key);
}

void dbuClassSetPrimaryKeyUInt64(DBUClass *cls, const char *column_name, off_t offset) {
    cls->primary_key_column = cx_strdup(cx_str(column_name));
    cls->primary_key = dbuFieldCreateInt64(offset);
    dbuClassAddField(cls, column_name, cls->primary_key);
}

void dbuClassSetPrimaryKeyString(DBUClass *cls, const char *column_name, off_t offset) {
    cls->primary_key_column = cx_strdup(cx_str(column_name));
    cls->primary_key = dbuFieldCreateString(offset);
    dbuClassAddField(cls, column_name, cls->primary_key);
}

void dbuClassSetPrimaryKeyCxMutStr(DBUClass *cls, const char *column_name, off_t offset) {
    cls->primary_key_column = cx_strdup(cx_str(column_name));
    cls->primary_key = dbuFieldCreateCxMutStr(offset);
    dbuClassAddField(cls, column_name, cls->primary_key);
}