srcs/toolbox/list.c

/* 
 * Copyright (c) 2005-2012 by KoanLogic s.r.l. - All rights reserved.  
 */

#include <u/libu_conf.h>
#include <u/libu.h>
#include <toolbox/list.h>

typedef struct u_list_item_s
{
    TAILQ_ENTRY(u_list_item_s) np;
    void *ptr;
} u_list_item_t;

struct u_list_s
{
    TAILQ_HEAD(u_list_head_s, u_list_item_s) head;
    size_t count;
};

int u_list_create (u_list_t **plist)
{
    u_list_t *list = NULL;

    list = u_zalloc(sizeof(u_list_t));
    dbg_err_sif (list == NULL); 

    TAILQ_INIT(&list->head);

    *plist = list;

    return 0;
err:
    if(list)
        u_free(list);
    return ~0;
}

void u_list_free (u_list_t *list)
{
    dbg_return_if(list == NULL, );

    u_list_clear(list);

    u_free(list);

    return;
}

int u_list_add (u_list_t *list, void *ptr)
{
    return u_list_insert(list, ptr, list->count);
}

int u_list_del (u_list_t *list, void *ptr)
{
    u_list_item_t *item = NULL;

    TAILQ_FOREACH(item, &list->head, np)
    {
        if(item->ptr == ptr)
        {
            TAILQ_REMOVE(&list->head, item, np);
            list->count--;
            u_free(item);
            return 0; /* removed */
        }
    }

    return ~0; /* not found */
}

size_t u_list_count (u_list_t *list)
{
    /* a SIGBUS/SIGSEGV is better than returning 0 if list == NULL */
    /* NOTE: perhaps we could use ssize_t instead, and return -1 on error */
    return list->count;
}

void *u_list_get_n (u_list_t *list, size_t n)
{
    u_list_item_t *item = NULL;

    dbg_return_if (list == NULL, NULL);
    dbg_return_if (n > list->count, NULL);

    TAILQ_FOREACH(item, &list->head, np)
    {
        if(n-- == 0)
            return item->ptr;
    }

    return NULL;
}

int u_list_insert (u_list_t *list, void *ptr, size_t n)
{
    u_list_item_t *prev, *item = NULL;

    dbg_return_if (list == NULL, ~0);
    dbg_return_if (n > list->count, ~0);

    item = u_zalloc(sizeof(u_list_item_t));
    dbg_err_sif (item == NULL);

    item->ptr = ptr;
            
    if(n == 0)
    {
        TAILQ_INSERT_HEAD(&list->head, item, np);
    } else if (n == list->count) {
        TAILQ_INSERT_TAIL(&list->head, item, np);
    } else {
        /* find the current n-th elem */
        TAILQ_FOREACH(prev, &list->head, np)
        {
            if(n-- == 0)
                break;
        }

        TAILQ_INSERT_BEFORE(prev, item, np);
    }

    list->count++;

    return 0;
err:
    if(item)
        u_free(item);
    return ~0;
}

void *u_list_first (u_list_t *list, void **it)
{
    u_list_item_t *item;

    dbg_return_if (list == NULL, NULL);

    item = TAILQ_FIRST(&list->head);

    if(it && item)
        *it = TAILQ_NEXT(item, np);
    else if(it)
        *it = NULL;

    if(item)
        return item->ptr;

    return NULL;
}

void *u_list_next (u_list_t *list, void **it)
{
    u_list_item_t *item;

    dbg_return_if (list == NULL, NULL);
    dbg_return_if (it == NULL, NULL);
    nop_return_if (*it == NULL, NULL);

    item = *it;

    if(it && item)
        *it = TAILQ_NEXT(item, np);
    else if(it)
        *it = NULL;

    if(item)
        return item->ptr;

    return NULL;
}

int u_list_del_n (u_list_t *list, size_t n, void **pptr)
{
    u_list_item_t *item = NULL;

    dbg_return_if (list == NULL, ~0);
    dbg_return_if (n >= list->count, ~0);

    TAILQ_FOREACH(item, &list->head, np)
    {
        if(n-- == 0)
            break;
    }

    if(pptr)
        *pptr = item->ptr;

    TAILQ_REMOVE(&list->head, item, np);

    list->count--;

    u_free(item);

    return 0;
}

int u_list_clear (u_list_t *list)
{
    u_list_item_t *item;

    dbg_err_if(list == NULL);

    while((item = TAILQ_FIRST(&list->head)) != NULL)
    {
        TAILQ_REMOVE(&list->head, item, np);

        u_free(item);
    }

    return 0;
err:
    return ~0;
}