dynamic_list.c

Go to the documentation of this file.

#include "dynamic.h"

#define LST_CONT(X)   X->data.list->container
#define LST_SPACE(X)  X->data.list->space


trilean dyn_set_list_len (dyn_c* dyn, dyn_ushort len)
{
    dyn_free(dyn);

    dyn_list *list = (dyn_list*) malloc(sizeof(dyn_list));

    if (list) {

        list->container = (dyn_c*) malloc(len * sizeof(dyn_c));

        if (list->container) {
            list->space = len;
            list->length = 0;

            // Initialize all elements in list with NONE
            while (len--)
                DYN_INIT(&list->container[len]);

            dyn->type = LIST;
            dyn->data.list = list;
            return DYN_TRUE;
        }
        free(list);
    }
    return DYN_FALSE;
}

void dyn_list_free (dyn_c* dyn)
{
    dyn_ushort len = DYN_LIST_LEN(dyn);

    // free all elements within the allocated container element
    dyn_c *ptr = dyn->data.list->container;
    while (len--) {
        dyn_free(ptr++);
    }

    free(dyn->data.list->container);
    free(dyn->data.list);
}

trilean dyn_list_resize (dyn_c* list, dyn_ushort size)
{
    dyn_list *ptr = list->data.list;

    dyn_c* new_list = (dyn_c*) realloc(ptr->container, size * sizeof(dyn_c));

    if (new_list) {
        ptr->container = new_list;

        if (ptr->space < size) {
            dyn_ushort i = ptr->length;
            for(; i<size; ++i)
                DYN_INIT(&ptr->container[i]);
        }

        ptr->space = size;
        return DYN_TRUE;
    }

    return DYN_FALSE;
}

dyn_c* dyn_list_push (dyn_c* list, const dyn_c* element)
{
    dyn_list *ptr = list->data.list;

    if (ptr->length == ptr->space)
        if (!dyn_list_resize(list, ptr->space + LIST_DEFAULT))
            return NULL;

    dyn_copy(element, &ptr->container[ ptr->length++ ]);

    return &ptr->container[ ptr->length-1 ];
}

dyn_c* dyn_list_push_none (dyn_c* list)
{
    dyn_list *ptr = list->data.list;
    if (ptr->length == ptr->space)
        if (!dyn_list_resize(list, ptr->space + LIST_DEFAULT))
            return NULL;

    return &ptr->container[ ptr->length++ ];
}

trilean dyn_list_remove (dyn_c* list, dyn_ushort i)
{
    dyn_list *ptr = list->data.list;
    if (ptr->length > i) {
        for(; i<ptr->length-1; ++i) {
            dyn_move(&ptr->container[i+1], &ptr->container[i]);
        }
        dyn_list_popi(list, 1);
    }
    return DYN_TRUE;
}

trilean dyn_list_insert (dyn_c* list, dyn_c* element, const dyn_ushort i)
{
    dyn_ushort n = DYN_LIST_LEN(list);
    if (n >= i) {
        dyn_list_push_none(list);

        dyn_c *ptr = list->data.list->container;

        ++n;
        while(--n > i)
            dyn_move(&ptr[n-1], &ptr[n]);

        dyn_move(element, &ptr[i]);
    }
    return DYN_TRUE;
}

trilean dyn_list_pop(dyn_c* list, dyn_c* element)
{
    dyn_list *ptr = list->data.list;

    dyn_move(&ptr->container[--ptr->length], element);

    if (ptr->space - ptr->length > LIST_DEFAULT)
        if (!dyn_list_resize(list, ptr->space - LIST_DEFAULT))
            return DYN_FALSE;

    return DYN_TRUE;
}

trilean dyn_list_popi (dyn_c* list, dyn_short i)
{
    while(i--)
        dyn_free(&list->data.list->container[ --list->data.list->length ]);

    return DYN_TRUE;
}

trilean dyn_list_get (const dyn_c* list, dyn_c* element, const dyn_short i)
{
    dyn_free(element);

    dyn_c* ptr = dyn_list_get_ref(list, i);

    if (ptr) {
        return dyn_copy(ptr, element);
    }

    return DYN_FALSE;
}

dyn_c* dyn_list_get_ref (const dyn_c* list, const dyn_short i)
{
    dyn_list *ptr = list->data.list;
    if (i >= 0 && i<= ptr->length)
        return &ptr->container[i];
    else if (i < 0 && -i <= ptr->length)
        return &ptr->container[ ptr->length+i ];
    return NULL;
}

trilean dyn_list_copy (const dyn_c* list, dyn_c* copy)
{
    dyn_ushort len = DYN_LIST_LEN(list);

    if (dyn_set_list_len(copy, len)) {
        list = list->data.list->container;
        while (len--) {
            if (!dyn_list_push(copy, list++)) {
                dyn_free(copy);
                return DYN_FALSE;
            }
        }
        return DYN_TRUE;
    }
    return DYN_FALSE;
}

dyn_ushort dyn_list_string_len (const dyn_c* list)
{
    dyn_ushort size = DYN_LIST_LEN(list)+1;
    dyn_ushort len = 2 + size;

    while (--size)
        len += dyn_string_len(DYN_LIST_GET_REF(list, size-1));

    return len;
}

void dyn_list_string_add (const dyn_c* list, dyn_str str)
{
    dyn_strcat(str, "[");
    dyn_ushort len = DYN_LIST_LEN(list);

    if (len == 0) {
        dyn_strcat(str, "]");
        return;
    }

    dyn_ushort i;
    for (i=0; i<len; i++) {
        dyn_string_add(DYN_LIST_GET_REF(list, i), str);
        dyn_strcat(str, ",");
    }
    str[dyn_strlen(str)-1] = ']';
}