source: trunk/third/libsoup/libsoup/soup-message-queue.c @ 21108

/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/*
 * soup-message-queue.c: Message queue
 *
 * Copyright (C) 2003, Ximian, Inc.
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include "soup-message-queue.h"

struct SoupMessageQueue {
        GList *head, *tail;
        GList *iters;

        GMutex *mutex;
};

/**
 * soup_message_queue_new:
 *
 * Creates a new #SoupMessageQueue
 *
 * Return value: a new #SoupMessageQueue object
 **/
SoupMessageQueue *
soup_message_queue_new (void)
{
        SoupMessageQueue *queue;

        queue = g_new0 (SoupMessageQueue, 1);
        queue->mutex = g_mutex_new ();
        return queue;
}

/**
 * soup_message_queue_destroy:
 * @queue: a message queue
 *
 * Frees memory associated with @queue, which must be empty.
 **/
void
soup_message_queue_destroy (SoupMessageQueue *queue)
{
        g_return_if_fail (queue->head == NULL);

        g_list_free (queue->head);
        g_list_free (queue->iters);
        g_mutex_free (queue->mutex);
        g_free (queue);
}

/**
 * soup_message_queue_append:
 * @queue: a queue
 * @msg: a message
 *
 * Appends @msg to the end of @queue
 **/
void
soup_message_queue_append (SoupMessageQueue *queue, SoupMessage *msg)
{
        g_mutex_lock (queue->mutex);
        if (queue->head) {
                queue->tail = g_list_append (queue->tail, msg);
                queue->tail = queue->tail->next;
        } else
                queue->head = queue->tail = g_list_append (NULL, msg);

        g_object_add_weak_pointer (G_OBJECT (msg), &queue->tail->data);
        g_mutex_unlock (queue->mutex);
}

/**
 * soup_message_queue_first:
 * @queue: a queue
 * @iter: pointer to a #SoupMessageQueueIter
 *
 * Initializes @iter and returns the first element of @queue. If you
 * do not iterate all the way to the end of the list, you must call
 * soup_message_queue_free_iter() to dispose the iterator when you are
 * done.
 *
 * Return value: the first element of @queue, or %NULL if it is empty.
 **/
SoupMessage *
soup_message_queue_first (SoupMessageQueue *queue, SoupMessageQueueIter *iter)
{
        g_mutex_lock (queue->mutex);

        if (!queue->head) {
                g_mutex_unlock (queue->mutex);
                return NULL;
        }

        queue->iters = g_list_prepend (queue->iters, iter);

        iter->cur = NULL;
        iter->next = queue->head;
        g_mutex_unlock (queue->mutex);

        return soup_message_queue_next (queue, iter);
}

static SoupMessage *
queue_remove_internal (SoupMessageQueue *queue, SoupMessageQueueIter *iter)
{
        GList *i;
        SoupMessageQueueIter *iter2;
        SoupMessage *msg;

        if (!iter->cur) {
                /* We're at end of list or this item was already removed */
                return NULL;
        }

        /* Fix any other iters pointing to iter->cur */
        for (i = queue->iters; i; i = i->next) {
                iter2 = i->data;
                if (iter2 != iter) {
                        if (iter2->cur == iter->cur)
                                iter2->cur = NULL;
                        else if (iter2->next == iter->cur)
                                iter2->next = iter->cur->next;
                }
        }

        msg = iter->cur->data;
        if (msg)
                g_object_remove_weak_pointer (G_OBJECT (msg), &iter->cur->data);

        /* If deleting the last item, fix tail */
        if (queue->tail == iter->cur)
                queue->tail = queue->tail->prev;

        /* Remove the item */
        queue->head = g_list_delete_link (queue->head, iter->cur);
        iter->cur = NULL;

        return msg;
}

/**
 * soup_message_queue_next:
 * @queue: a queue
 * @iter: pointer to an initialized #SoupMessageQueueIter
 *
 * Returns the next element of @queue
 *
 * Return value: the next element, or %NULL if there are no more.
 **/
SoupMessage *
soup_message_queue_next (SoupMessageQueue *queue, SoupMessageQueueIter *iter)
{
        g_mutex_lock (queue->mutex);

        while (iter->next) {
                iter->cur = iter->next;
                iter->next = iter->cur->next;
                if (iter->cur->data) {
                        g_mutex_unlock (queue->mutex);
                        return iter->cur->data;
                }

                /* Message was finalized, remove dead queue element */
                queue_remove_internal (queue, iter);
        }

        /* Nothing left */
        iter->cur = NULL;
        queue->iters = g_list_remove (queue->iters, iter);

        g_mutex_unlock (queue->mutex);
        return NULL;
}

/**
 * soup_message_queue_remove:
 * @queue: a queue
 * @iter: pointer to an initialized #SoupMessageQueueIter
 *
 * Removes the queue element pointed to by @iter; that is, the last
 * message returned by soup_message_queue_first() or
 * soup_message_queue_next().
 *
 * Return value: the removed message, or %NULL if the element pointed
 * to by @iter was already removed.
 **/
SoupMessage *
soup_message_queue_remove (SoupMessageQueue *queue, SoupMessageQueueIter *iter)
{
        SoupMessage *msg;

        g_mutex_lock (queue->mutex);
        msg = queue_remove_internal (queue, iter);
        g_mutex_unlock (queue->mutex);

        return msg;
}

/**
 * soup_message_queue_remove_message:
 * @queue: a queue
 * @msg: a #SoupMessage
 *
 * Removes the indicated message from @queue.
 **/
void
soup_message_queue_remove_message (SoupMessageQueue *queue, SoupMessage *msg)
{
        SoupMessageQueueIter iter;
        SoupMessage *msg2;

        for (msg2 = soup_message_queue_first (queue, &iter); msg2; msg2 = soup_message_queue_next (queue, &iter)) {
                if (msg2 == msg) {
                        soup_message_queue_remove (queue, &iter);
                        soup_message_queue_free_iter (queue, &iter);
                        return;
                }
        }
}


/**
 * soup_message_queue_free_iter:
 * @queue: a queue
 * @iter: pointer to an initialized #SoupMessageQueueIter
 *
 * Removes @iter from the list of active iterators in @queue.
 **/
void
soup_message_queue_free_iter (SoupMessageQueue *queue,
                              SoupMessageQueueIter *iter)
{
        g_mutex_lock (queue->mutex);
        queue->iters = g_list_remove (queue->iters, iter);
        g_mutex_unlock (queue->mutex);
}