/* Standard queue */

/*
** Copyright 2001, Travis Geiselbrecht. All rights reserved.
** Distributed under the terms of the NewOS License.
*/

#include <kernel.h>
#include <queue.h>
#include <malloc.h>
#include <errno.h>

typedef struct queue_element {
        void *next;
} queue_element;

typedef struct queue_typed {
        queue_element *head;
        queue_element *tail;
        int count;
} queue_typed;


int
queue_init(queue *q)
{
        q->head = q->tail = NULL;
        q->count = 0;
        return 0;
}


int
queue_remove_item(queue *_q, void *e)
{
        queue_typed *q = (queue_typed *)_q;
        queue_element *elem = (queue_element *)e;
        queue_element *temp, *last = NULL;

        temp = (queue_element *)q->head;
        while (temp) {
                if (temp == elem) {
                        if (last)
                                last->next = temp->next;
                        else
                                q->head = (queue_element*)temp->next;

                        if (q->tail == temp)
                                q->tail = last;
                        q->count--;
                        return 0;
                }
                last = temp;
                temp = (queue_element*)temp->next;
        }

        return -1;
}


int
queue_enqueue(queue *_q, void *e)
{
        queue_typed *q = (queue_typed *)_q;
        queue_element *elem = (queue_element *)e;

        if (q->tail == NULL) {
                q->tail = elem;
                q->head = elem;
        } else {
                q->tail->next = elem;
                q->tail = elem;
        }
        elem->next = NULL;
        q->count++;
        return 0;
}


void *
queue_dequeue(queue *_q)
{
        queue_typed *q = (queue_typed *)_q;
        queue_element *elem;

        elem = q->head;
        if (q->head != NULL)
                q->head = (queue_element*)q->head->next;
        if (q->tail == elem)
                q->tail = NULL;

        if (elem != NULL)
                q->count--;

        return elem;
}


void *
queue_peek(queue *q)
{
        return q->head;
}


//      #pragma mark -
/* fixed queue stuff */


int
fixed_queue_init(fixed_queue *q, int size)
{
        if (size <= 0)
                return EINVAL;

        q->table = (void**)malloc(size * sizeof(void *));
        if (!q->table)
                return ENOMEM;
        q->head = 0;
        q->tail = 0;
        q->count = 0;
        q->size = size;

        return 0;
}


void
fixed_queue_destroy(fixed_queue *q)
{
        free(q->table);
}


int
fixed_queue_enqueue(fixed_queue *q, void *e)
{
        if (q->count == q->size)
                return ENOMEM;

        q->table[q->head++] = e;
        if (q->head >= q->size)
                q->head = 0;
        q->count++;

        return 0;
}


void *
fixed_queue_dequeue(fixed_queue *q)
{
        void *e;

        if (q->count <= 0)
                return NULL;

        e = q->table[q->tail++];
        if (q->tail >= q->size)
                q->tail = 0;
        q->count--;

        return e;
}


void *
fixed_queue_peek(fixed_queue *q)
{
        if (q->count <= 0)
                return NULL;

        return q->table[q->tail];
}