rcpp_framework/libs/brynet/base/Stack.hpp

#pragma once

#include <brynet/base/Array.hpp>
#include <cstdlib>

namespace brynet {
namespace base {

struct stack_s {
	struct array_s *array;
	size_t element_size;

	size_t element_num;
	size_t front;
	size_t num;
};

static void stack_delete(struct stack_s *self) {
	if (self == nullptr) {
		return;
	}

	if (self->array != nullptr) {
		array_delete(self->array);
		self->array = nullptr;
	}

	self->element_num = 0;
	self->front = 0;
	self->num = 0;
	free(self);
	self = nullptr;
}

static struct stack_s *stack_new(size_t num, size_t element_size) {
	struct stack_s *ret = (struct stack_s *)malloc(sizeof(struct stack_s));
	if (ret == nullptr) {
		return nullptr;
	}

	ret->element_size = 0;
	ret->element_num = 0;
	ret->front = 0;
	ret->num = 0;
	ret->array = array_new(num, element_size);

	if (ret->array != nullptr) {
		ret->element_size = element_size;
		ret->element_num = num;
	} else {
		stack_delete(ret);
		ret = nullptr;
	}

	return ret;
}

static void stack_init(struct stack_s *self) {
	self->front = 0;
	self->num = 0;
}

static size_t stack_num(struct stack_s *self) {
	return self->num;
}

static bool stack_increase(struct stack_s *self, size_t increase_num) {
	struct array_s *tmp = array_new(self->element_num + increase_num,
			self->element_size);
	if (tmp == nullptr) {
		return false;
	}

	{
		size_t current_num = self->element_num;
		size_t current_stack_num = stack_num(self);
		for (size_t i = 0; i < current_stack_num; ++i) {
			array_set(tmp, i, array_at(self->array, (self->front + i) % current_num));
		}

		self->front = 0;
		array_delete(self->array);
		self->array = tmp;
		self->element_num = array_num(self->array);
	}

	return true;
}

static size_t stack_size(struct stack_s *self) {
	return self->element_num;
}

static bool stack_isfull(struct stack_s *self) {
	return (self->num == self->element_num);
}

static bool stack_push(struct stack_s *self, const void *data) {
	if (stack_isfull(self)) {
		stack_increase(self, stack_size(self));
	}

	if (stack_isfull(self)) {
		return false;
	}

	array_set(self->array, (self->front + self->num) % self->element_num, data);
	self->num++;
	return true;
}

static void *stack_front(struct stack_s *self) {
	void *ret = nullptr;

	if (stack_num(self) > 0) {
		ret = array_at(self->array, self->front);
	}

	return ret;
}

static void *stack_popfront(struct stack_s *self) {
	void *ret = stack_front(self);

	if (ret != nullptr) {
		self->num--;
		self->front++;
		self->front %= self->element_num;
	}

	return ret;
}

static void *stack_popback(struct stack_s *self) {
	void *ret = nullptr;

	if (stack_num(self) > 0) {
		self->num--;
		ret = array_at(self->array, (self->front + self->num) % self->element_num);
	}

	return ret;
}

} // namespace base
} // namespace brynet