4a2665004e
client code knows what objects is stored in the queue and its only 3 lines to do a simple free() on the items.
135 lines
2.6 KiB
C
135 lines
2.6 KiB
C
/* queue.c
|
|
*
|
|
* Copyright (C) 2010 Henrik Hautakoski <henrik@fiktivkod.org>
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <assert.h>
|
|
#include <stdint.h>
|
|
#include <malloc.h>
|
|
#include "queue.h"
|
|
|
|
#define BLOCK_SIZE (1<<7)
|
|
|
|
#define init(q) \
|
|
do { \
|
|
q->tail.n = q->head.n = NULL; \
|
|
q->tail.i = q->head.i = 0; \
|
|
} while(0)
|
|
|
|
/* linked list node holding a chunk of queue elements */
|
|
struct node {
|
|
void *block[BLOCK_SIZE];
|
|
struct node *next;
|
|
};
|
|
|
|
struct ref {
|
|
uint16_t i;
|
|
struct node *n;
|
|
};
|
|
|
|
struct __queue {
|
|
struct ref tail;
|
|
struct ref head;
|
|
};
|
|
|
|
static void alloc_node(struct ref *head) {
|
|
|
|
struct node *n = malloc(sizeof(struct node));
|
|
assert(n != NULL);
|
|
|
|
n->next = NULL;
|
|
head->n = head->n->next = n;
|
|
head->i = 0;
|
|
}
|
|
|
|
static void dealloc_node(struct ref *tail) {
|
|
|
|
struct node *next = tail->n->next;
|
|
assert(next != NULL);
|
|
|
|
free(tail->n);
|
|
|
|
tail->n = next;
|
|
tail->i = 0;
|
|
}
|
|
|
|
queue_t queue_init() {
|
|
|
|
queue_t q = malloc(sizeof(struct __queue));
|
|
|
|
if (q)
|
|
init(q);
|
|
return q;
|
|
}
|
|
|
|
void queue_destroy(queue_t q) {
|
|
|
|
if (q)
|
|
free(q);
|
|
}
|
|
|
|
void queue_enqueue(queue_t q, void *obj) {
|
|
|
|
if (q->head.n == NULL) {
|
|
q->tail.n = q->head.n = malloc(sizeof(struct node));
|
|
assert(q->tail.n != NULL);
|
|
} else if (q->head.i + 1 >= BLOCK_SIZE) {
|
|
alloc_node(&q->head);
|
|
} else {
|
|
q->head.i++;
|
|
}
|
|
|
|
q->head.n->block[q->head.i] = obj;
|
|
}
|
|
|
|
void* queue_dequeue(queue_t q) {
|
|
|
|
void *obj;
|
|
|
|
if (queue_isempty(q))
|
|
return NULL;
|
|
|
|
obj = q->tail.n->block[q->tail.i++];
|
|
|
|
if (q->tail.n == q->head.n && q->tail.i > q->head.i) {
|
|
free(q->head.n);
|
|
init(q);
|
|
} else if (q->tail.i >= BLOCK_SIZE) {
|
|
dealloc_node(&q->tail);
|
|
}
|
|
|
|
return obj;
|
|
}
|
|
|
|
int queue_isempty(queue_t q) {
|
|
|
|
if (q == NULL)
|
|
return -1;
|
|
|
|
return q->head.n == NULL && q->head.n == q->tail.n;
|
|
}
|
|
|
|
size_t queue_num_items(queue_t q) {
|
|
|
|
if (queue_isempty(q))
|
|
return 0;
|
|
if (q->head.n == q->tail.n)
|
|
return (q->head.i + 1) - q->tail.i;
|
|
|
|
size_t len = (BLOCK_SIZE - q->tail.i) + (q->head.i + 1);
|
|
struct node *n = q->tail.n->next;
|
|
|
|
for(; n != q->head.n; n = n->next)
|
|
len += BLOCK_SIZE;
|
|
|
|
return len;
|
|
}
|
|
|