CircularQueue

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/**
 * https://gist.github.com/harshkn/909546
 * C Implementation of simple circular buffer, Functionality provided are add to queue, read latest
 *
 * Implementation: head, tail, and count. The major different between AndersKaloer/Harshkn is the way to detect full/empty.
 * The former trade with an empty slot, the latter use additional int->count. I review this because this is easier and Scott uses it too.
 */

typedef struct circular_buffer {
	void *buffer;     // data buffer
	void *buffer_end; // end of data buffer
	size_t capacity;  // maximum number of items in the buffer
	size_t count;     // number of items in the buffer
	size_t sz;        // size of each item in the buffer
	void *head;       // pointer to head
	void *tail;       // pointer to tail
} circular_buffer;

void cb_init(circular_buffer *cb, size_t capacity, size_t sz) {
	cb->buffer = malloc(capacity * sz);
	if (cb->buffer == NULL) {
		// handle error
	}
	cb->buffer_end = (char *) cb->buffer + capacity * sz;
	cb->capacity = capacity;
	cb->count = 0;
	cb->sz = sz;
	cb->head = cb->buffer;
	cb->tail = cb->buffer;
}

void cb_free(circular_buffer *cb) {
	free(cb->buffer);
	// clear out other fields too, just to be safe
}

void cb_push_back(circular_buffer *cb, const void *item) {
	if (cb->count == cb->capacity) {
		printf("%s, %d: cb push back error. \n", __FILE__, __LINE__);
//		return;
	}
	memcpy(cb->head, item, cb->sz);
	printf("push data = %d\n", *(char *) cb->head);
	cb->head = (char*) cb->head + cb->sz;
	if (cb->head == cb->buffer_end)
		cb->head = cb->buffer;
	cb->count = cb->count == cb->capacity ? cb->count : cb->count + 1;
}

void cb_pop_front(circular_buffer *cb, void *item) {
	if (cb->count == 0) {
		printf("%s, %d: cb_pop_front: empty cb.\n", __FILE__, __LINE__);
		return;
	}
	memcpy(item, cb->tail, cb->sz);
	printf("pop data = %d\n", *(char *) cb->tail);
	cb->tail = (char*) cb->tail + cb->sz;
	if (cb->tail == cb->buffer_end)
		cb->tail = cb->buffer;
	cb->count--;
}

int cb_empty(circular_buffer *cb) {
	if (cb->count == 0)
		return 1;
	return 0;
}

int cb_full(circular_buffer *cb) {
	return cb->count == cb->capacity;
}

void printbuf(circular_buffer *cb) {
	int i = 0;
	for (; i < cb->capacity; ++i)
		printf("%d ", *(char *) (cb->buffer + i));
}

/**
 * https://github.com/kqchen/workspace/blob/21ab1c18dbf6c674437b0c89bb313ddbfc2de85c/hello/circular.c
 */
void cb_print(circular_buffer *cb) {
	int cnt = cb->count;
	do {
		if (cb->count == 0) {
			printf("%s, %d: cb is empty now.\n", __FILE__, __LINE__);
			return;
		}
		printf("cb->tail=0x%x, cb->head=0x%x, cnt = %d\n", cb->tail, cb->head,
				cnt);
		cnt--;
	} while (cnt > 0);
}
/**
 * testing the ring buffer
 */
int main() {
	circular_buffer tony; // a holder
	cb_init(&tony, 4, 1);
	int i = 10;
	for (; i < 20; ++i) {
		cb_push_back(&tony, &i);
//		printf("%d with count: %d, data = %d\n", cb_full(&tony), tony.count, i);
	}

	printf("\nafter filling ---\n");
	cb_print(&tony);
//	printf("after filling ---\n");
//	printbuf(&tony);
	char result;
	int j = 0;
	for (; j < 6; ++j) {
		cb_pop_front(&tony, &result);
//		printf("%d with count: %d, result = %d\n", cb_empty(&tony), tony.count, result);
	}
	printf("\nafter pop ---\n");
	cb_print(&tony);
	return 0;
}