libcdsb/src/array/extra.c

/* This software is licensed by the MIT License, see LICENSE file */
/*                                Copyright © 2022 Gregory Lirent */

#include "include.h"
#include "../__internal/assert.h"
#include "../__internal/vnode.h"

ssize_t libcdsb_array_find(const arr_t* x, const void* v, vtype vt) {
    int c;
    ssize_t index;

    if (is_integer(x->type)) {
        tvalue_assert(vt);
    } else if (is_float(x->type)) {
        tvalue_assert(vt);
    } else type_assert(x->type, vt);

    index = -1;

    if (!x->size)
        return index;

    void* p = x->mem;
    void* e = array_end(x);

    assert(!is_null(x->mem));

    do {
        ++index;
        c = vtype_compare(p, x->type, v, vt);

        if (c == 0)
            return index;

        p += vtype_size(x->type);
    } while (p < e);

    return -1;
}


ssize_t libcdsb_array_push(arr_t* x, const void* v, vtype vt) {
    ssize_t i = x->size;
    vnode_t n = vnode_tcreate(x->type, v, vt);

    x->mem = realloc(x->mem, ++x->size * vtype_size(x->type));
    memcpy(array_internal_at(x, i), vnode_peek(&n, x->type), vtype_size(x->type));

    if (vtype_size(x->type) > sizeof(void*) && x->type < VTYPE_STRING)
        vnode_free(&n, x->type);

    return i;
}


int libcdsb_array_get(vtype_array* x, ssize_t i, void* _, array_access_callback callback, vtype_bool cut) {

    int r = 0;

    if (i < 0 && (i += x->size) < 0) i = 0;

    if (i < x->size) {
        if (callback) r = callback(array_internal_at(x, i), i, x->type, _);
        if (cut)      array_cut(x, i, 1);
    } else return -1;

    return r;
}


int libcdsb_array_foreach(vtype_array* x, void* data, array_access_callback callback, _Bool flush) {

    void*  p;
    void*  e;
    size_t n;
    int    r;

    p = x->mem;
    e = x->mem + x->size*vtype_size(x->type);
    n = 0;
    r = 0;

    while (p < e) {
        if ((r = callback(p, n, x->type, data)))
            break;

        p += vtype_size(x->type);
        ++n;
    }

    if (flush) {
        free(x->mem);
        memset(x, 0, sizeof(*x));
    }
    return r;
}