list.c

Go to the documentation of this file.

/*
============================================================
LINKED LIST
============================================================
*/

#include "list.h"
#include "mem.h"
#include <assert.h>
#include <string.h>

extern struct memPool_s *com_genericPool;

linkedList_t* LIST_Add (linkedList_t** listDest, const byte* data, size_t length)
{
    linkedList_t *newEntry;
    linkedList_t *list;

    assert(listDest);
    assert(data);

    /* create the list */
    if (!*listDest) {
        *listDest = (linkedList_t*)Mem_PoolAlloc(sizeof(**listDest), com_genericPool, 0);
        (*listDest)->data = (byte*)Mem_PoolAlloc(length, com_genericPool, 0);
        memcpy(((*listDest)->data), data, length);
        (*listDest)->next = NULL; /* not really needed - but for better readability */
        return *listDest;
    } else
        list = *listDest;

    while (list->next)
        list = list->next;

    newEntry = (linkedList_t*)Mem_PoolAlloc(sizeof(*newEntry), com_genericPool, 0);
    list->next = newEntry;
    newEntry->data = (byte*)Mem_PoolAlloc(length, com_genericPool, 0);
    memcpy(newEntry->data, data, length);
    newEntry->next = NULL; /* not really needed - but for better readability */

    return newEntry;
}

const linkedList_t* LIST_ContainsString (const linkedList_t* list, const char* string)
{
    assert(list);

    while ((string != NULL) && (list != NULL)) {
        if (!strcmp((const char*)list->data, string))
            return list;
        list = list->next;
    }

    return NULL;
}


linkedList_t* LIST_GetPointer (linkedList_t* list, const void* data)
{
    assert(list);

    while ((data != NULL) && (list != NULL)) {
        if (list->data == data)
            return list;
        list = list->next;
    }

    return NULL;
}

void LIST_AddString (linkedList_t** listDest, const char* data)
{
    linkedList_t *newEntry;
    linkedList_t *list;

    assert(listDest);
    assert(data);

    /* create the list */
    if (!*listDest) {
        *listDest = (linkedList_t*)Mem_PoolAlloc(sizeof(**listDest), com_genericPool, 0);
        (*listDest)->data = (byte*)Mem_StrDup(data);
        (*listDest)->next = NULL; /* not really needed - but for better readability */
        return;
    } else
        list = *listDest;

    while (list->next)
        list = list->next;

    newEntry = (linkedList_t*)Mem_PoolAlloc(sizeof(*newEntry), com_genericPool, 0);
    list->next = newEntry;
    newEntry->data = (byte*)Mem_StrDup(data);
    newEntry->next = NULL; /* not really needed - but for better readability */
}

void LIST_AddPointer (linkedList_t** listDest, void* data)
{
    linkedList_t *newEntry;
    linkedList_t *list;

    assert(listDest);
    assert(data);

    /* create the list */
    if (!*listDest) {
        *listDest = (linkedList_t*)Mem_PoolAlloc(sizeof(**listDest), com_genericPool, 0);
        (*listDest)->data = (byte *)data;
        (*listDest)->ptr = qtrue;
        (*listDest)->next = NULL; /* not really needed - but for better readability */
        return;
    } else
        list = *listDest;

    while (list->next)
        list = list->next;

    newEntry = (linkedList_t*)Mem_PoolAlloc(sizeof(*newEntry), com_genericPool, 0);
    list->next = newEntry;
    newEntry->data = (byte *)data;
    newEntry->ptr = qtrue;
    newEntry->next = NULL; /* not really needed - but for better readability */
}

void LIST_RemoveEntry (linkedList_t **list, linkedList_t *entry)
{
    linkedList_t* prev, *listPos;

    assert(list);
    assert(entry);

    prev = *list;
    listPos = *list;

    /* first entry */
    if (*list == entry) {
        if (!(*list)->ptr)
            Mem_Free((*list)->data);
        listPos = (*list)->next;
        Mem_Free(*list);
        *list = listPos;
    } else {
        while (listPos) {
            if (listPos == entry) {
                prev->next = listPos->next;
                if (!listPos->ptr)
                    Mem_Free(listPos->data);
                Mem_Free(listPos);
                break;
            }
            prev = listPos;
            listPos = listPos->next;
        }
    }
}

void LIST_Delete (linkedList_t **list)
{
    linkedList_t *next;
    linkedList_t *l = *list;

    while (l) {
        next = l->next;
        if (!l->ptr)
            Mem_Free(l->data);
        Mem_Free(l);
        l = next;
    }
    *list = NULL;
}

void *LIST_GetNext (linkedList_t *list, void *lastData)
{
    linkedList_t *entry;

    if (LIST_IsEmpty(list))
        return NULL;

    if (lastData == NULL)
        return list->data;

    entry = LIST_GetPointer(list, lastData);
    assert(entry);

    if (entry->next)
        return entry->next->data;

    return NULL;
}

qboolean LIST_Remove (linkedList_t **list, const void *data)
{
    linkedList_t *l = LIST_GetPointer(*list, data);
    if (l != NULL)
        LIST_RemoveEntry(list, l);
    return l != NULL;
}

qboolean LIST_IsEmpty (const linkedList_t *list)
{
    return list == NULL;
}

int LIST_Count (const linkedList_t *list)
{
    const linkedList_t *l = list;
    int count = 0;

    while (l) {
        count++;
        l = l->next;
    }
    return count;
}

void *LIST_GetLast (linkedList_t *list)
{
    while (list) {
        linkedList_t *next = list->next;
        if (next == NULL)
            return (void *)list->data;
        list = next;
    }

    return NULL;
}

void *LIST_GetByIdx (linkedList_t *list, int index)
{
    int i;
    const int count = LIST_Count(list);

    if (!count || !list)
        return NULL;

    if (index >= count || index < 0)
        return NULL;

    i = 0;
    while (list) {
        if (i == index)
            return (void *)list->data;
        i++;
        list = list->next;
    }

    return NULL;
}