icl_list.c

Go to the documentation of this file.

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

#include "icl_list.h"


icl_list_t* icl_list_new()
{
    icl_list_t *node;

    node = (icl_list_t*)malloc(sizeof(icl_list_t));
    if (!node)
        return NULL;

    node->flink = NULL;
    node->blink = node;
    node->data = NULL;

    return(node);
}


icl_list_t* icl_list_insert(icl_list_t *head, icl_list_t *pos, void *data)
{
    icl_list_t *node;

    if(!head || !pos)
        return NULL;

    node = (icl_list_t*)malloc(sizeof(icl_list_t));
    if (!node)
        return NULL;

    node->blink = pos;
    node->flink = pos->flink;
    node->data = data;

    if (pos->flink)
        pos->flink->blink = node;
    else
        head->blink = node; // The node at end of the list.

    pos->flink = node;
    return node;
}


int icl_list_delete(
    icl_list_t *head, icl_list_t *pos, void (*free_function)(void *))
{
    if (!pos || !head)
        return -1;
    if (pos == head)
        return -1;

    if (free_function && pos->data)
        (*free_function)(pos->data);

    pos->blink->flink = pos->flink;

    if (pos->flink)
        pos->flink->blink = pos->blink;
    else
        head->blink = pos->blink; // Position at the end of the list.

    free(pos);
    return 0;
}


icl_list_t* icl_list_search(
    icl_list_t *head, void *data, int (*compare)(void*, void*))
{
    icl_list_t *node;

    if (!head)
        return NULL;

    for (node = head->flink; node != NULL; node = node->flink) {
        if (!node->data)
            continue;
        if ((compare && (*compare)(node->data, data) == 0))
            break;
        else if (node->data == data)
            break; // compare == NULL, then direct comparison of pointers.
    }
    return(node);
}


icl_list_t* icl_list_isort(
    icl_list_t *head, void *data, int (*compare)(void*, void*))
{
    if (!head || !compare)
        return NULL;

    if (head->flink == NULL)
        return (icl_list_insert(head, head, data));

    icl_list_t *node = head->flink;
    if (compare(data, node->data) <= 0)
        return (icl_list_insert(head, head, data));

    while (node->flink != NULL && compare(data, node->flink->data) > 0)
        node = node->flink;
    return (icl_list_insert(head, node, data));
}


int
icl_list_destroy(icl_list_t *head, void (*free_function)(void*))
{
    icl_list_t *node, *tmpnode;

    if (!head)
        return -1;

    for (node = head; node != NULL;) {
        tmpnode = node->flink;

        if (free_function != NULL && node->data != NULL)
            (*free_function)(node->data);

        free(node);
        node = tmpnode;
    }
    return 0;
}


int icl_list_size(icl_list_t *head)
{
    int size = 0;

    if (!head)
        return -1;

    while ((head=head->flink))
        size++;

    return size;
}


icl_list_t* icl_list_first(icl_list_t *head)
{
    if (head)
        return head->flink;

    return NULL;
}


icl_list_t* icl_list_last(icl_list_t *head)
{
    if (head)
        return head->blink;

    return NULL;
}


icl_list_t* icl_list_next(icl_list_t *head, icl_list_t *pos)
{
    if(pos)
        return pos->flink;

    return NULL;
}


icl_list_t* icl_list_prev(icl_list_t *head, icl_list_t *pos)
{
    if (pos && pos->blink != NULL && pos != head &&
        pos->blink != head && pos->blink != pos)
        return pos->blink;

    return NULL;
}


icl_list_t *icl_list_concat(icl_list_t *head1, icl_list_t *head2)
{
    if (!head1 || !head2 || !head1->blink || !head2->flink)
        return NULL;

    head1->blink->flink = head2->flink;
    head2->flink->blink = head1->blink;
    head1->blink = head2->blink;

    free(head2);
    return(head1);
}


icl_list_t *icl_list_prepend(icl_list_t *head, void *data)
{
    return (icl_list_insert(head, head, data));
}


icl_list_t* icl_list_append(icl_list_t *head, void *data)
{
    return (icl_list_insert(head, head->blink, data));
}