REFACTOR: Translated to internal file for setup towards singular Vec

2026-09-25 18:22:09 -04:00
parent 924c45e223
commit 74873807dd
12 changed files with 879 additions and 1457 deletions
@@ -0,0 +1,725 @@
+#include "char.h"
+
+#include <limits.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "utils/utils.h"
+
+size_t
+_vec_char_is_valid(const _VecCharInternal* ptr)
+{
+	if (ptr == nullptr)
+	{
+		LOGERROR(ERR_VECTOR_NULL);
+		return ERR_VECTOR_NULL;
+	}
+	else if (ptr->_internal_arr == nullptr)
+	{
+		LOGERROR(ERR_BUF_NULL);
+		return ERR_BUF_NULL;
+	}
+	return SUCCESS;
+}
+
+_VecCharInternal
+_vec_char_create(const char* src, const size_t size)
+{
+	_VecCharInternal self = {
+		._internal_arr = NULL,
+		._internal_size = 0,
+		._internal_capacity = CAPACITY,
+		._internal_max_size = VEC_MAX,
+	};
+	if (size >= self._internal_max_size)
+	{
+		LOGERROR(ERR_MAX_PASSED);
+		LOG("If you need more memory to start, create a blank and "
+		    "selferve.");
+		return self;
+	}
+	if (self._internal_capacity < size && size < self._internal_max_size)
+	{
+		while (self._internal_capacity < size &&
+		       self._internal_capacity * 2 < self._internal_max_size)
+			self._internal_capacity *= 2;
+	}
+	if (self._internal_capacity * 2 > self._internal_max_size &&
+	    size < self._internal_max_size)
+	{
+		self._internal_capacity = size;
+	}
+	if (size > 0)
+	{
+		char* dst_buf = calloc(self._internal_capacity, sizeof(char));
+		if (!dst_buf)
+		{
+			LOGERROR(ERR_ALLOC_FAIL);
+			return self;
+		}
+		self._internal_arr = dst_buf;
+	}
+	if (src)
+	{
+		for (size_t i = 0; i < size; i++)
+		{
+			self._internal_arr[i] = src[i];
+			self._internal_size++;
+		}
+	}
+	return self;
+}
+
+_VecCharInternal
+_vec_char_push_back(_VecCharInternal* ptr, const char val)
+{
+	if (_vec_char_is_valid(ptr) == ERR_VECTOR_NULL)
+	{
+		return _vec_char_create(nullptr, 0);
+	}
+	_VecCharInternal self = { NULL, ptr->_internal_size,
+				  ptr->_internal_capacity,
+				  ptr->_internal_max_size };
+
+	if (_vec_char_is_valid(ptr) == ERR_BUF_NULL)
+	{
+		LOG("If you think this is wrong, reserve memory first");
+		return self;
+	}
+	if (ptr->_internal_size + 1 > ptr->_internal_max_size)
+	{
+		LOGERROR(ERR_MAX_PASSED);
+		self = *ptr;
+		return self;
+	}
+
+	char* dst_buf;
+	if (ptr->_internal_size + 1 > ptr->_internal_capacity)
+	{
+		if (ptr->_internal_capacity * 2 > ptr->_internal_max_size)
+		{
+			LOGERROR(ERR_MAX_PASSED);
+			self = *ptr;
+			return self;
+		}
+		self._internal_capacity = ptr->_internal_capacity * 2;
+		dst_buf = realloc(ptr->_internal_arr,
+				  self._internal_capacity * sizeof(char));
+		if (!dst_buf)
+		{
+			LOGERROR(ERR_ALLOC_FAIL);
+			self = *ptr;
+			return self;
+		}
+	}
+	else
+	{
+		dst_buf = ptr->_internal_arr;
+	}
+	self._internal_arr = dst_buf;
+	self._internal_arr[self._internal_size] = val;
+	self._internal_size++;
+	return self;
+}
+
+_VecCharInternal
+_vec_char_pop_back(_VecCharInternal* ptr)
+{
+	_VecCharInternal err = _vec_char_create(nullptr, 0);
+	if (_vec_char_is_valid(ptr) != SUCCESS)
+	{
+		return err;
+	}
+	if (ptr->_internal_size < 1)
+	{
+		LOGERROR(ERR_SIZE_ZERO);
+		return err;
+	}
+	_VecCharInternal self = { NULL, ptr->_internal_size - 1,
+				  ptr->_internal_capacity,
+				  ptr->_internal_max_size };
+	self._internal_arr = ptr->_internal_arr;
+	self._internal_arr[self._internal_size] = 0;
+	return self;
+}
+
+_VecCharInternal
+_vec_char_reserve(const _VecCharInternal* ptr, const size_t capacity)
+{
+	_VecCharInternal self = _vec_char_create(nullptr, 0);
+	if (capacity == 0)
+	{
+		LOGERROR(ERR_SIZE_ZERO);
+		return self;
+	}
+	if (_vec_char_is_valid(ptr) == ERR_VECTOR_NULL)
+	{
+		return self;
+	}
+	self._internal_arr = ptr->_internal_arr;
+	if (_vec_char_is_valid(&self) == ERR_BUF_NULL)
+	{
+		self._internal_arr = calloc(capacity, sizeof(char));
+		if (!self._internal_arr)
+		{
+			LOGERROR(ERR_ALLOC_FAIL);
+			self = *ptr;
+			return self;
+		}
+	}
+	else if (_vec_char_is_valid(ptr) == SUCCESS)
+	{
+		self._internal_arr =
+		    realloc(self._internal_arr, capacity * sizeof(char));
+		if (!self._internal_arr)
+		{
+			LOGERROR(ERR_ALLOC_FAIL);
+			self = *ptr;
+			return self;
+		}
+		self._internal_size = ptr->_internal_size;
+		if (self._internal_size > capacity)
+		{
+			for (size_t i = capacity; i < self._internal_size; i++)
+			{
+				self._internal_arr[i] = 0;
+			}
+			self._internal_size = capacity;
+		}
+	}
+	self._internal_capacity = capacity;
+	self._internal_max_size = capacity;
+	return self;
+}
+
+_VecCharInternal
+_vec_char_shrink_to_fit(_VecCharInternal* ptr)
+{
+	if (_vec_char_is_valid(ptr) != SUCCESS)
+		return _vec_char_create(nullptr, 0);
+	if (ptr->_internal_size == 0)
+	{
+		LOGERROR(ERR_SIZE_ZERO);
+		return _vec_char_create(nullptr, 0);
+	}
+	return _vec_char_reserve(ptr, ptr->_internal_size);
+}
+
+size_t
+_vec_char_swap(_VecCharInternal* ptr1, _VecCharInternal* ptr2)
+{
+	_VecCharInternal self = _vec_char_create(nullptr, 0);
+	if (_vec_char_is_valid(ptr1) == ERR_VECTOR_NULL ||
+	    _vec_char_is_valid(ptr2) == ERR_VECTOR_NULL)
+	{
+		return ERR_VECTOR_NULL;
+	}
+	if (_vec_char_is_valid(ptr1) == ERR_BUF_NULL ||
+	    _vec_char_is_valid(ptr2) == ERR_BUF_NULL)
+	{
+		return ERR_BUF_NULL;
+	}
+	self._internal_arr = ptr1->_internal_arr;
+	ptr1->_internal_arr = ptr2->_internal_arr;
+	ptr2->_internal_arr = self._internal_arr;
+
+	self._internal_capacity = ptr1->_internal_capacity;
+	self._internal_size = ptr1->_internal_size;
+	self._internal_max_size = ptr1->_internal_max_size;
+	ptr1->_internal_capacity = ptr2->_internal_capacity;
+	ptr1->_internal_size = ptr2->_internal_size;
+	ptr1->_internal_max_size = ptr2->_internal_max_size;
+
+	ptr2->_internal_capacity = self._internal_capacity;
+	ptr2->_internal_size = self._internal_size;
+	ptr2->_internal_max_size = self._internal_max_size;
+	return SUCCESS;
+}
+
+char*
+_vec_char_data(const _VecCharInternal* ptr)
+{
+	if (_vec_char_is_valid(ptr) == ERR_BUF_NULL ||
+	    _vec_char_is_valid(ptr) == ERR_VECTOR_NULL)
+		return nullptr;
+	return &ptr->_internal_arr[0];
+}
+
+size_t
+_vec_char_capacity(const _VecCharInternal* ptr)
+{
+	if (_vec_char_is_valid(ptr) == ERR_VECTOR_NULL)
+	{
+		return ERR_VECTOR_NULL;
+	}
+	if (_vec_char_is_valid(ptr) == ERR_BUF_NULL)
+	{
+		return ERR_BUF_NULL;
+	}
+	return ptr->_internal_capacity;
+}
+
+size_t
+_vec_char_max_size(const _VecCharInternal* ptr)
+{
+	if (_vec_char_is_valid(ptr) == ERR_VECTOR_NULL)
+	{
+		return ERR_VECTOR_NULL;
+	}
+	if (_vec_char_is_valid(ptr) == ERR_BUF_NULL)
+	{
+		return ERR_BUF_NULL;
+	}
+	return ptr->_internal_max_size;
+}
+
+void
+_vec_char_delete(const _VecCharInternal* ptr)
+{
+	if (_vec_char_is_valid(ptr) == SUCCESS)
+	{
+		free((void*)ptr->_internal_arr);
+	}
+}
+
+_VecCharInternal
+_vec_char_clear(const _VecCharInternal* ptr)
+{
+	_VecCharInternal self = _vec_char_create(nullptr, 0);
+	if (_vec_char_is_valid(ptr) == ERR_VECTOR_NULL ||
+	    _vec_char_is_valid(ptr) == ERR_BUF_NULL)
+	{
+		return self;
+	}
+	self = *ptr;
+	if (self._internal_size > 0)
+	{
+		for (size_t i = 0; i < self._internal_size; i++)
+		{
+			self._internal_arr[i] = 0;
+		}
+		self._internal_size = 0;
+	}
+	return self;
+}
+
+char
+_vec_char_at(const _VecCharInternal* ptr, const size_t idx)
+{
+	if (_vec_char_is_valid(ptr) == ERR_VECTOR_NULL)
+	{
+		return ERR_VECTOR_NULL;
+	}
+	if (_vec_char_is_valid(ptr) == ERR_BUF_NULL)
+	{
+		return ERR_BUF_NULL;
+	}
+	if (idx >= ptr->_internal_size)
+	{
+		fprintf(stderr,
+			"At Index: [%zu] is out of bounds for size: [%zu]", idx,
+			ptr->_internal_size);
+		return ERR_OUT_OF_BOUNDS;
+	}
+	return ptr->_internal_arr[idx];
+}
+
+void
+_vec_char_print_vec(const _VecCharInternal* ptr)
+{
+	if (_vec_char_is_valid(ptr) == ERR_VECTOR_NULL ||
+	    _vec_char_is_valid(ptr) == ERR_BUF_NULL)
+		return;
+	for (size_t i = 0; i < ptr->_internal_size; i++)
+		printf("%c ", ptr->_internal_arr[i]);
+	printf("\n");
+}
+
+size_t
+_vec_char_begin(const _VecCharInternal* ptr)
+{
+	if (_vec_char_is_valid(ptr) == SUCCESS) return 0;
+	return FAILURE;
+}
+
+size_t
+_vec_char_end(const _VecCharInternal* ptr)
+{
+	if (_vec_char_is_valid(ptr) == SUCCESS)
+	{
+		if (ptr->_internal_size != 0)
+			return (int)(ptr->_internal_size - 1);
+		else return FAILURE;
+	}
+	return FAILURE;
+}
+
+char
+_vec_char_front(const _VecCharInternal* ptr)
+{
+	if (_vec_char_is_valid(ptr) == ERR_VECTOR_NULL) return FAILURE;
+	if (ptr->_internal_size == 0) return FAILURE;
+	return _vec_char_at(ptr, 0);
+}
+
+char
+_vec_char_back(const _VecCharInternal* ptr)
+{
+	if (_vec_char_is_valid(ptr) == ERR_VECTOR_NULL) return FAILURE;
+	if (ptr->_internal_size == 0) return FAILURE;
+	return _vec_char_at(ptr, ptr->_internal_size - 1);
+}
+
+size_t
+_vec_char_empty(const _VecCharInternal* ptr)
+{
+	if (_vec_char_is_valid(ptr) == ERR_VECTOR_NULL ||
+	    _vec_char_is_valid(ptr) == ERR_BUF_NULL)
+		return FAILURE;
+	if (ptr->_internal_size == 0) return SUCCESS;
+	return FAILURE;
+}
+
+__attribute__((overloadable)) _VecCharInternal
+_vec_char_erase(const _VecCharInternal* ptr, const size_t iter)
+{
+	_VecCharInternal self = _vec_char_create(nullptr, 0);
+	if (_vec_char_is_valid(ptr) == ERR_VECTOR_NULL) return self;
+	if (_vec_char_is_valid(ptr) == ERR_BUF_NULL) return self;
+	if (iter >= ptr->_internal_size) return self;
+	self = *ptr;
+	memmove(&self._internal_arr[iter], &self._internal_arr[iter + 1],
+		(self._internal_size - iter - 1) * sizeof(char));
+	self._internal_arr[self._internal_size - 1] = 0;
+	self._internal_size--;
+	return self;
+}
+
+__attribute__((overloadable)) _VecCharInternal
+_vec_char_erase(const _VecCharInternal* ptr, const size_t iter_start,
+		const size_t iter_end)
+{
+	_VecCharInternal self = _vec_char_create(nullptr, 0);
+	if (_vec_char_is_valid(ptr) == ERR_VECTOR_NULL) return self;
+	if (_vec_char_is_valid(ptr) == ERR_BUF_NULL) return self;
+	if (iter_end > ptr->_internal_size) return self;
+	if (iter_start >= iter_end) return self;
+	self = *ptr;
+	size_t diff = iter_end - iter_start;
+	memmove(&self._internal_arr[iter_start], &self._internal_arr[iter_end],
+		(self._internal_size - iter_end) * sizeof(char));
+	for (size_t i = self._internal_size - diff; i < self._internal_size;
+	     i++)
+	{
+		self._internal_arr[i] = 0;
+	}
+	self._internal_size -= diff;
+	return self;
+}
+
+__attribute__((overloadable)) _VecCharInternal
+_vec_char_resize(const _VecCharInternal* ptr, const size_t size)
+{
+	_VecCharInternal self = _vec_char_create(nullptr, 0);
+	if (_vec_char_is_valid(ptr) == ERR_VECTOR_NULL ||
+	    _vec_char_is_valid(ptr) == ERR_BUF_NULL)
+		return self;
+	self = *ptr;
+	if (ptr->_internal_size == size)
+	{
+		LOG("ERR :- Ptr size and size are the same");
+		self = *ptr;
+		return self;
+	}
+
+	else if (size > ptr->_internal_max_size)
+	{
+		LOGERROR(ERR_MAX_PASSED);
+		self = *ptr;
+		return self;
+	}
+
+	else if (ptr->_internal_size == 0)
+	{
+		size_t max = self._internal_max_size;
+		self = _vec_char_reserve(&self, size);
+		if (self._internal_capacity != size)
+		{
+			LOGERROR(ERR_ALLOC_FAIL);
+			self = *ptr;
+			return self;
+		}
+		for (size_t i = 0; i < size; i++)
+		{
+			self._internal_arr[i] = '\0';
+		}
+		self._internal_max_size = max;
+		self._internal_size = size;
+		return self;
+	}
+	else if (size > ptr->_internal_capacity)
+	{
+		size_t tmpcp = ptr->_internal_capacity;
+		size_t tmpmx = ptr->_internal_max_size;
+		while (size > tmpcp)
+		{
+			tmpcp *= 2;
+		}
+		if (tmpcp > ptr->_internal_max_size)
+		{
+			tmpcp = size;
+		}
+		self = _vec_char_reserve(ptr, tmpcp);
+		if (self._internal_capacity != tmpcp)
+		{
+			LOGERROR(ERR_ALLOC_FAIL);
+			self = *ptr;
+			return self;
+		}
+		self._internal_max_size = tmpmx;
+	}
+	if (size < ptr->_internal_size)
+	{
+		for (size_t i = size; i < self._internal_size; i++)
+		{
+			self._internal_arr[i] = '\0';
+		}
+	}
+	if (self._internal_size < size && size <= self._internal_capacity)
+	{
+		for (size_t i = self._internal_size; i < size; i++)
+		{
+			self._internal_arr[i] = '\0';
+		}
+	}
+	self._internal_size = size;
+	return self;
+}
+
+__attribute__((overloadable)) _VecCharInternal
+_vec_char_resize(const _VecCharInternal* ptr, const size_t size, const char val)
+{
+	_VecCharInternal self = _vec_char_create(nullptr, 0);
+	if (_vec_char_is_valid(ptr) == ERR_VECTOR_NULL ||
+	    _vec_char_is_valid(ptr) == ERR_BUF_NULL)
+		return self;
+	self = *ptr;
+	if (ptr->_internal_size == size)
+	{
+		LOG("ERR :- Ptr size and size are the same");
+		self = *ptr;
+		return self;
+	}
+
+	else if (size > ptr->_internal_max_size)
+	{
+		LOGERROR(ERR_MAX_PASSED);
+		self = *ptr;
+		return self;
+	}
+
+	else if (ptr->_internal_size == 0)
+	{
+		size_t max = self._internal_max_size;
+		self = _vec_char_reserve(&self, size);
+		if (self._internal_capacity != size)
+		{
+			LOGERROR(ERR_ALLOC_FAIL);
+			self = *ptr;
+			return self;
+		}
+		for (size_t i = 0; i < size; i++)
+		{
+			self._internal_arr[i] = val;
+		}
+		self._internal_max_size = max;
+		self._internal_size = size;
+		return self;
+	}
+	else if (size > ptr->_internal_capacity)
+	{
+		size_t tmpcp = ptr->_internal_capacity;
+		size_t tmpmx = ptr->_internal_max_size;
+		while (size > tmpcp)
+		{
+			tmpcp *= 2;
+		}
+		if (tmpcp > ptr->_internal_max_size)
+		{
+			tmpcp = size;
+		}
+		self = _vec_char_reserve(ptr, tmpcp);
+		if (self._internal_capacity != tmpcp)
+		{
+			LOGERROR(ERR_ALLOC_FAIL);
+			self = *ptr;
+			return self;
+		}
+		self._internal_max_size = tmpmx;
+	}
+	if (size < ptr->_internal_size)
+	{
+		for (size_t i = size; i < self._internal_size; i++)
+		{
+			self._internal_arr[i] = val;
+		}
+	}
+	if (self._internal_size < size && size <= self._internal_capacity)
+	{
+		for (size_t i = self._internal_size; i < size; i++)
+		{
+			self._internal_arr[i] = val;
+		}
+	}
+	self._internal_size = size;
+	return self;
+}
+
+__attribute__((overloadable)) _VecCharInternal
+_vec_char_assign(const _VecCharInternal* ptr, const _VecCharInternal* iterator,
+		 const size_t iter_start, const size_t iter_end)
+{
+	_VecCharInternal self = _vec_char_create(nullptr, 0);
+	if (_vec_char_is_valid(ptr) == ERR_VECTOR_NULL ||
+	    _vec_char_is_valid(ptr) == ERR_BUF_NULL)
+		return self;
+	if (_vec_char_is_valid(iterator) == ERR_VECTOR_NULL ||
+	    _vec_char_is_valid(iterator) == ERR_BUF_NULL)
+		return self;
+
+	if (ptr->_internal_arr == iterator->_internal_arr)
+	{
+		LOGERROR(ERR_DOUBLE_BUF);
+		self = *ptr;
+		return self;
+	}
+	if (iterator->_internal_size < iter_end || iter_end <= iter_start)
+	{
+		LOGERROR(ERR_OUT_OF_BOUNDS);
+		return self;
+	}
+	self = *ptr;
+	self =
+	    _vec_char_erase(ptr, _vec_char_begin(ptr), _vec_char_end(ptr) + 1);
+	self = _vec_char_reserve(&self, (iter_end - iter_start));
+	for (size_t i = iter_start; i < iter_end; i++)
+	{
+		self = _vec_char_push_back(&self, _vec_char_at(iterator, i));
+	}
+	return self;
+}
+
+__attribute__((overloadable)) _VecCharInternal
+_vec_char_assign(const _VecCharInternal* ptr, const size_t amount,
+		 const char val)
+{
+	_VecCharInternal self = _vec_char_create(nullptr, 0);
+	if (_vec_char_is_valid(ptr) == ERR_VECTOR_NULL ||
+	    _vec_char_is_valid(ptr) == ERR_BUF_NULL)
+		return _vec_char_create(nullptr, 0);
+	self = *ptr;
+	if (amount == 0)
+	{
+		LOGERROR(ERR_SIZE_ZERO);
+		return self;
+	}
+	self = _vec_char_erase(&self, _vec_char_begin(&self),
+			       _vec_char_end(&self) + 1);
+	self = _vec_char_reserve(&self, amount);
+	for (size_t i = 0; i < amount; i++)
+	{
+		self = _vec_char_push_back(&self, val);
+	}
+	return self;
+}
+
+__attribute__((overloadable)) _VecCharInternal
+_vec_char_insert(const _VecCharInternal* ptr, const size_t iter, const char val)
+{
+	_VecCharInternal self = _vec_char_create(nullptr, 0);
+	if (_vec_char_is_valid(ptr) == ERR_VECTOR_NULL ||
+	    _vec_char_is_valid(ptr) == ERR_BUF_NULL)
+	{
+		return self;
+	}
+	if (ptr->_internal_max_size < ptr->_internal_size + 1)
+	{
+		LOGERROR(ERR_MAX_PASSED);
+		return self;
+	}
+	if (iter > ptr->_internal_size)
+	{
+		LOGERROR(ERR_OUT_OF_BOUNDS);
+		return self;
+	}
+	self = *ptr;
+	self = _vec_char_push_back(&self, 0);
+	for (size_t i = self._internal_size - 1; i > iter; i--)
+	{
+		self._internal_arr[i] = self._internal_arr[i - 1];
+	}
+	self._internal_arr[iter] = val;
+
+	return self;
+}
+
+__attribute__((overloadable)) _VecCharInternal
+_vec_char_insert(const _VecCharInternal* ptr, const size_t iter,
+		 const size_t amount, const char val)
+{
+	_VecCharInternal self = _vec_char_create(nullptr, 0);
+	if (_vec_char_is_valid(ptr) != SUCCESS)
+	{
+		LOGERROR(ERR_NULL);
+		return self;
+	}
+	if (iter > ptr->_internal_size)
+	{
+		LOGERROR(ERR_OUT_OF_BOUNDS);
+		return self;
+	}
+	if (amount <= 0)
+	{
+		LOGERROR(ERR_SIZE_ZERO);
+		return self;
+	}
+	self = *ptr;
+	for (size_t i = iter; i < iter + amount; i++)
+	{
+		self = _vec_char_insert(&self, i, val);
+	}
+	return self;
+}
+
+__attribute__((overloadable)) _VecCharInternal
+_vec_char_insert(const _VecCharInternal* ptr, const _VecCharInternal* iterator,
+		 const size_t iter, const size_t iter_start,
+		 const size_t iter_end)
+{
+	_VecCharInternal self = _vec_char_create(nullptr, 0);
+	if (_vec_char_is_valid(ptr) != SUCCESS ||
+	    _vec_char_is_valid(iterator) != SUCCESS)
+	{
+		LOGERROR(ERR_NULL);
+		return self;
+	}
+	if (iter_end > iterator->_internal_size || iter > ptr->_internal_size)
+	{
+		LOGERROR(ERR_OUT_OF_BOUNDS);
+		return self;
+	}
+	if (ptr->_internal_arr == iterator->_internal_arr)
+	{
+		LOGERROR(ERR_DOUBLE_BUF);
+		return self;
+	}
+	self = *ptr;
+	for (size_t i = iter_start; i < iter_end; i++)
+	{
+		self = _vec_char_insert(&self, iter + (i - iter_start),
+					iterator->_internal_arr[i]);
+	}
+	return self;
+}