helmetc/libxtools/vmapper.c

/*
 * Copyright 2023 Oleg Borodin  <borodin@unix7.org>
 */

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

#include <vmapper.h>

static char* copystr(char* src) {
        size_t srcsize = strlen(src) + 1;
        char* dest = malloc(srcsize);

        memset(dest, '\0', srcsize);
        strcpy(dest, src);
        return dest;
}



static mlink_t* new_mlink_string(char* name, char** val) {
        mlink_t* mlink = malloc(sizeof(mlink_t));

        mlink->name = name;
        mlink->vptr = (void *)val;
        mlink->type = MAPPER_STR;
        return mlink;
}

static mlink_t* new_mlink_integer(char* name, int* val) {
        mlink_t* mlink = malloc(sizeof(mlink_t));

        mlink->name = name;
        mlink->vptr = (void *)val;
        mlink->type = MAPPER_INT;
        return mlink;
}

static mlink_t* new_mlink_bool(char* name, bool* val) {
        mlink_t* mlink = malloc(sizeof(mlink_t));

        mlink->name = name;
        mlink->vptr = (void *)val;
        mlink->type = MAPPER_BOOL;
        return mlink;
}


#define MAPPER_INITCAPA 64


vmapper_t* new_vmapper(void) {
        vmapper_t* vmapper = malloc(sizeof(vmapper_t));

        if (vmapper == NULL)
                return NULL;
        vmapper->mlinks = malloc(sizeof(mlink_t) * MAPPER_INITCAPA);
        vmapper->capa = MAPPER_INITCAPA;
        vmapper->size = 0;
        vmapper->err = false;
        vmapper->errstr = NULL;
        return vmapper;
}


void vmapper_init(vmapper_t * vmapper) {
        vmapper->mlinks = malloc(sizeof(mlink_t) * MAPPER_INITCAPA);
        vmapper->capa = MAPPER_INITCAPA;
        vmapper->size = 0;
        vmapper->err = false;
        vmapper->errstr = NULL;
        return;
}

#define RES_BIND_OK   ((int)0)
#define RES_BIND_ERR  ((int)-1)

int vmapper_check_capa(vmapper_t * vmapper) {
        if (vmapper->size == vmapper->capa) {
                size_t newcapa = vmapper->capa * 2;
                mlink_t** newmlinks = realloc(vmapper->mlinks, newcapa);

                if (newmlinks == NULL)
                        return RES_BIND_ERR;
                vmapper->mlinks = newmlinks;
                vmapper->capa = newcapa;
        }
        return RES_BIND_OK;
}

int vmapper_bind_string(vmapper_t * vmapper, char* name, char** val) {
        int res = 0;

        if ((res = vmapper_check_capa(vmapper)) != RES_BIND_OK) {
                return res;
        }
        mlink_t* mlink = new_mlink_string(name, val);

        vmapper->mlinks[vmapper->size] = mlink;
        vmapper->size++;
        return RES_BIND_OK;
}

int vmapper_bind_int(vmapper_t * vmapper, char* name, int* val) {
        int res = 0;

        if ((res = vmapper_check_capa(vmapper)) != RES_BIND_OK) {
                return res;
        }
        mlink_t* mlink = new_mlink_integer(name, val);

        vmapper->mlinks[vmapper->size] = mlink;
        vmapper->size++;
        return RES_BIND_OK;
}


int vmapper_bind_bool(vmapper_t * vmapper, char* name, bool* val) {
        int res = 0;

        if ((res = vmapper_check_capa(vmapper)) != RES_BIND_OK) {
                return res;
        }
        mlink_t* mlink = new_mlink_bool(name, val);

        vmapper->mlinks[vmapper->size] = mlink;
        vmapper->size++;
        return RES_BIND_OK;
}

int vmapper_set_int(vmapper_t * vmapper, char* key, char* val) {
        for (size_t i = 0; i < vmapper->size; i++) {
                mlink_t* mlink = vmapper->mlinks[i];

                if (mlink->type == MAPPER_INT && strcmp(mlink->name, key) == 0) {
                        char* eptr = NULL;

                        *(int *)(mlink->vptr) = (int)strtol(val, &eptr, 10);
                }
        }
        return 0;
}

int vmapper_set_string(vmapper_t * vmapper, char* key, char* val) {
        for (size_t i = 0; i < vmapper->size; i++) {
                mlink_t* mlink = vmapper->mlinks[i];

                if (mlink->type == MAPPER_STR && strcmp(mlink->name, key) == 0) {
                        *(char **)(mlink->vptr) = copystr(val);
                }
        }
        return 0;
}

int vmapper_set_bool(vmapper_t * vmapper, char* key, char* val) {
        for (size_t i = 0; i < vmapper->size; i++) {
                mlink_t* mlink = vmapper->mlinks[i];

                if (mlink->type == MAPPER_BOOL && strcmp(mlink->name, key) == 0) {
                        if (strcmp(val, "true") == 0) {
                                *(bool *)(mlink->vptr) = true;
                        }
                        if (strcmp(val, "false") == 0) {
                                *(bool *)(mlink->vptr) = false;
                        }
                }
        }
        return 0;
}

int vmapper_bind(vmapper_t * vmapper, int type, char* name, void* val) {
        switch (type) {
        case MAPPER_STR:{
                    return vmapper_bind_string(vmapper, name, (char **)val);
            }
        case MAPPER_INT:{
                    return vmapper_bind_int(vmapper, name, (int *)val);
            }
        case MAPPER_BOOL:{
                    return vmapper_bind_bool(vmapper, name, (bool *)val);
            }
        }
        return 0;
}



int vmapper_set(vmapper_t * vmapper, char* key, char* val) {
        vmapper_set_int(vmapper, key, val);
        vmapper_set_string(vmapper, key, val);
        vmapper_set_bool(vmapper, key, val);
        return 0;
}

void vmapper_destroy(vmapper_t * vmapper) {
        if (vmapper != NULL) {
                for (size_t i = 0; i < vmapper->size; i++) {
                        free(vmapper->mlinks[i]);
                }
                free(vmapper->mlinks);
        }
        return;
}

void vmapper_free(vmapper_t * vmapper) {
        if (vmapper != NULL) {
                for (size_t i = 0; i < vmapper->size; i++) {
                        free(vmapper->mlinks[i]);
                }
                free(vmapper->mlinks);
        }
        free(vmapper);
}