---

xlv_list.h

/*
 * xlv_list.h
 *
 * XLV_List is a thread-safe implementation of list for XLV with list pool
 * capability to preserve list allocation speed.
 *
 * Copyright (C) 2001 Guilhem Lavaux
 *
 * This file is part of XLV, a free middleware audio-video stream coder/decoder.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * XLV is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
#ifndef _XLV_LIST_H
#define _XLV_LIST_H

#include <glib.h>
#include <pthread.h>

/* -------
 * Aliases
 * -------
 */

typedef struct _XLV_List XLV_List;
typedef struct _XLV_ListIterator XLV_ListIterator;
typedef XLV_List XLV_ListPool;

/* ------------------
 * Struct definitions
 * ------------------
 */
struct _XLV_List {
    XLV_ListIterator *m_first_element;
    XLV_ListIterator *m_last_element;
    XLV_ListPool *m_pool;
    guint32 m_n_elements;
    pthread_mutex_t m_mutex;
};

struct _XLV_ListIterator {
    gpointer data;
    XLV_ListIterator *m_next;
    XLV_ListIterator *m_prev;
};


/* -----------------------
 * XLV List implementation
 * -----------------------
 */

static inline XLV_ListIterator *xlv_list_pool_get_node (XLV_ListPool * pool);
static inline void xlv_list_pool_release_node (XLV_ListPool * pool,
                                               XLV_ListIterator * node);

static inline XLV_ListIterator *
xlv_list_next (XLV_ListIterator * list)
{
    return list->m_next;
}

static inline XLV_ListIterator *
xlv_list_prev (XLV_ListIterator * list)
{
    return list->m_prev;
}

static inline XLV_ListIterator *
xlv_list_first (XLV_List * list)
{
    return list->m_first_element;
}

static inline XLV_ListIterator *
xlv_list_last (XLV_List * list)
{
    return list->m_last_element;
}

static inline guint32
xlv_list_length (XLV_List * list)
{
    return list->m_n_elements;
}

static inline XLV_List *
xlv_list_new (XLV_ListPool * pool)
{
    XLV_List *list;

    list = g_new (XLV_List, 1);
    list->m_first_element = NULL;
    list->m_last_element = NULL;
    list->m_n_elements = 0;
    list->m_pool = pool;
    pthread_mutex_init (&list->m_mutex, NULL);

    return list;
}

static inline void
xlv_list_free (XLV_List * list)
{
    XLV_ListIterator *iter;

    g_assert (list != NULL);

    iter = xlv_list_first (list);
    while (iter != NULL) {
        XLV_ListIterator *next;

        next = xlv_list_next (iter);
        xlv_list_pool_release_node (list->m_pool, iter);
        iter = next;
    }

    pthread_mutex_destroy (&list->m_mutex);
    g_free (list);
}

static inline void
xlv_list_append (XLV_List * list, gpointer data)
{
    XLV_ListIterator *iter;

    g_assert (list != NULL);

    pthread_mutex_lock (&list->m_mutex);
    iter = xlv_list_pool_get_node (list->m_pool);
    iter->data = data;
    iter->m_next = NULL;
    iter->m_prev = list->m_last_element;

    if (list->m_last_element != NULL)
        list->m_last_element->m_next = iter;

    list->m_last_element = iter;

    if (list->m_first_element == NULL)
        list->m_first_element = iter;

    list->m_n_elements++;
    pthread_mutex_unlock (&list->m_mutex);
}

static inline XLV_ListIterator *
xlv_list_find (XLV_List * list, gpointer data)
{
    XLV_ListIterator *iter;

    g_assert (list != NULL);

    iter = xlv_list_first (list);
    while (iter != NULL) {
        if (iter->data == data)
            return iter;
        iter = xlv_list_next (iter);
    }

    return NULL;
}

static inline void
xlv_list_remove_link (XLV_List * list, XLV_ListIterator * link)
{
    g_assert (list != NULL);
    g_assert (link != NULL);

    pthread_mutex_lock (&list->m_mutex);

    list->m_n_elements--;

    if (link->m_prev)
        link->m_prev->m_next = link->m_next;
    if (link->m_next)
        link->m_next->m_prev = link->m_prev;

    if (link == list->m_first_element)
        list->m_first_element = link->m_next;
    if (link == list->m_last_element)
        list->m_last_element = link->m_prev;

    xlv_list_pool_release_node (list->m_pool, link);
    pthread_mutex_unlock (&list->m_mutex);
}

static inline void
xlv_list_remove_all_links (XLV_List * list)
{
    XLV_ListIterator *iter, *node;

    iter = xlv_list_first (list);
    while (iter != NULL) {
        node = iter->m_next;
        xlv_list_pool_release_node (list->m_pool, iter);
        iter = node;
    }

    list->m_first_element = NULL;
    list->m_last_element = NULL;
    list->m_n_elements = 0;
}


/* ---------
 * List pool
 * ---------
 */
static inline XLV_ListPool *
xlv_list_pool_new (guint32 elems)
{
    XLV_ListPool *pool;

    pool = xlv_list_new (NULL);
    for (; elems != 0; elems--)
        xlv_list_append (pool, NULL);

    return pool;
}

static inline void
xlv_list_pool_free (XLV_ListPool * pool)
{
    xlv_list_free (pool);
}

static inline XLV_ListIterator *
xlv_list_pool_get_node (XLV_ListPool * pool)
{
    XLV_ListIterator *node;

    if (pool && pool->m_first_element) {
        pthread_mutex_lock (&pool->m_mutex);
        pool->m_n_elements--;

        node = pool->m_first_element;
        pool->m_first_element = node->m_next;
        if (pool->m_first_element)
            pool->m_first_element->m_prev = NULL;
        if (pool->m_last_element == node)
            pool->m_last_element = NULL;
        pthread_mutex_unlock (&pool->m_mutex);

        return node;
    }
    node = g_new (XLV_ListIterator, 1);

    return node;
}

static inline void
xlv_list_pool_release_node (XLV_ListPool * pool, XLV_ListIterator * node)
{
    if (!pool) {
        g_free (node);
        return;
    }

    pthread_mutex_lock (&pool->m_mutex);
    if (pool->m_first_element)
        pool->m_first_element->m_prev = node;

    node->m_next = pool->m_first_element;
    node->m_prev = NULL;
    pool->m_first_element = node;

    pool->m_n_elements++;
    pthread_mutex_unlock (&pool->m_mutex);
}

#endif

---