Updated file structure

src/lib/char/char.c

@@ -0,0 +1,288 @@
+#include "char.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+/*
+ * Andrew Haynes
+ * dmm.dev@icloud.com
+ * No LICENSE
+ * Vector Library For C
+ */
+
+/*
+ * All functions needed
+ * assign()	Fills a vector with multiple values stored
+ * insert()	Inserts a number of elements into a vector
+ * vector can have pop_back()	Removes the last element of a vector rbegin()
+ * Returns a reverse iterator pointing to the last element of a vector rend()
+ * Returns a reverse iterator pointing to a position right before the first
+ * element of a vector reserve()	Reserves memory for a vector resize()
+ * Changes the size of a vector, adding or removing elements if necessary
+ * */
+
+/**
+ * Creates a new vector with type char
+ * @param Takes in nullptr or another vector object. If an object is passed in
+ * the new vector will have its size incremented by 1
+ * @return Returns a new vector object
+ *
+ */
+
+__attribute__((overloadable)) Vec8_t
+create(const Vec8_t* input)
+{
+	Vec8_t vec = { .arr = nullptr, .size = 0, .capacity = CAPACITY };
+	if (input != nullptr && input->size > 0)
+	{
+		vec.size = input->size + 1;
+	}
+	vec.arr = calloc(vec.capacity, sizeof(char));
+	return vec;
+}
+
+/**
+ * Creates a new vector with type char
+ * @param Takes in a boolean of true or false to determine if a memory
+ * allocation occurs. True callocs a base memory, false does not
+ * @return Returns a new vector object
+ *
+ */
+
+__attribute__((overloadable)) Vec8_t
+create(const _Bool init)
+{
+	Vec8_t vec = { .arr = nullptr, .size = 0, .capacity = CAPACITY };
+	if (init)
+	{
+		vec.arr = calloc(vec.capacity, sizeof(char));
+	}
+	return vec;
+}
+
+Vec8_t
+reserve(Vec8_t* ptr, const size_t max_size)
+{
+	Vec8_t ret = create(nullptr);
+	char* res = reallocf(ptr->arr, max_size * sizeof(char));
+	ret.arr = res;
+	ret.capacity = max_size * sizeof(char);
+	ret.size = ptr->size;
+	if (ret.size > max_size) ret.size = max_size;
+	return ret;
+}
+
+Vec8_t
+shrink_to_fit(Vec8_t* ptr)
+{
+	return reserve(ptr, ptr->size);
+}
+
+int
+swap(Vec8_t* ptr, Vec8_t* ptr_other)
+{
+	Vec8_t empty = create(false);
+	if (ptr == nullptr || ptr_other == nullptr) return 0;
+	if (ptr->arr == nullptr || ptr_other->arr == nullptr) return 0;
+	empty.arr = ptr->arr;
+	ptr->arr = nullptr;
+	ptr->arr = ptr_other->arr;
+	ptr_other->arr = nullptr;
+	ptr_other->arr = empty.arr;
+	if (ptr != nullptr && ptr_other != nullptr)
+	{
+		empty.capacity = ptr->capacity;
+		ptr->capacity = ptr_other->capacity;
+		empty.size = ptr->size;
+		ptr->size = ptr_other->size;
+
+		ptr_other->capacity = empty.capacity;
+		ptr_other->size = empty.size;
+		return 1;
+	}
+	free(ptr);
+	free(ptr_other);
+	return 0;
+}
+
+char*
+data(const Vec8_t* ptr)
+{
+	if (ptr == nullptr || ptr->arr == nullptr) return nullptr;
+	return &ptr->arr[0];
+}
+
+size_t
+max_size(const Vec8_t* ptr)
+{
+	return ptr->capacity;
+}
+
+void
+delete(Vec8_t* vec)
+{
+	if (vec->arr != nullptr)
+	{
+		free(vec->arr);
+	}
+	vec->arr = nullptr;
+}
+
+Vec8_t
+clear(Vec8_t* vec)
+{
+	if (vec != nullptr && vec->size > 0)
+	{
+		for (int i = 0; i < vec->size; i++)
+		{
+			if (!vec->arr) continue;
+			vec->arr[i] = 0;
+		}
+		vec->size = 0;
+	}
+	return *vec;
+}
+
+char
+at(const Vec8_t* vec, const int idx)
+{
+	if (vec == nullptr)
+	{
+		return -2;
+	}
+	if (vec->arr == nullptr)
+	{
+		return -3;
+	}
+	if (vec->size <= idx)
+	{
+		fprintf(stderr,
+			"At Index: [%i] is out of bounds for size: [%zu]", idx,
+			vec->size);
+		exit(-4);
+		// return -4;
+	}
+	if (vec != nullptr && vec->arr != nullptr && vec->size > idx)
+	{
+		return vec->arr[idx];
+	}
+	return -1;
+}
+
+__attribute__((overloadable)) Vec8_t*
+erase(Vec8_t* vec, const size_t iter)
+{
+	if (vec == nullptr) return nullptr;
+	if (vec->arr == nullptr) return nullptr;
+	if (iter >= vec->size) return nullptr;
+	memmove(&vec->arr[iter], &vec->arr[iter + 1],
+		(vec->size - iter - 1) * sizeof(char));
+	vec->arr[vec->size - 1] = 0;
+	vec->size--;
+	return vec;
+}
+
+__attribute__((overloadable)) Vec8_t*
+erase(Vec8_t* vec, const size_t iter_start, const size_t iter_end)
+{
+	if (vec == nullptr) return nullptr;
+	if (vec->arr == nullptr) return nullptr;
+	if (iter_start < 0 || iter_end > vec->size) return nullptr;
+	if (iter_start >= iter_end) return nullptr;
+	size_t diff = iter_end - iter_start;
+	memmove(&vec->arr[iter_start], &vec->arr[iter_end],
+		(vec->size - iter_end) * sizeof(char));
+	for (size_t i = vec->size - diff; i < vec->size; i++)
+	{
+		vec->arr[i] = 0;
+	}
+	vec->size -= diff;
+	return vec;
+}
+
+void
+print_vec(const Vec8_t* vec)
+{
+	for (int i = 0; i < vec->size; i++)
+	{
+		if (vec->arr[i])
+		{
+			printf("%c ", at(vec, i));
+		}
+	}
+	printf("\n");
+}
+
+int
+begin(const Vec8_t* vec)
+{
+	if (vec != nullptr && vec->arr != nullptr && vec->size > 0)
+	{
+		return 0;
+	}
+	return -1;
+}
+
+int
+end(const Vec8_t* vec)
+{
+	if (vec != nullptr && vec->arr != nullptr && vec->size > 0)
+	{
+		return (int)(vec->size - 1);
+	}
+	return -1;
+}
+
+char
+front(const Vec8_t* vec)
+{
+	return at(vec, 0);
+}
+
+char
+back(const Vec8_t* vec)
+{
+	if (vec)
+	{
+		return at(vec, (int)vec->size - 1);
+	}
+	return -1;
+}
+
+int
+empty(const Vec8_t* vec)
+{
+	if (vec->size > 0)
+	{
+		return 1;
+	}
+	return 0;
+}
+
+Vec8_t
+add_back(Vec8_t* vec, const char val)
+{
+	if (vec->size >= vec->capacity)
+	{
+		vec->capacity *= 2;
+		char* nvec = reallocf(vec->arr, vec->capacity * sizeof(char));
+		if (nvec == NULL)
+		{
+			return *vec;
+		}
+		vec->arr = nvec;
+	}
+	vec->arr[vec->size] = val;
+	vec->size++;
+	return *vec;
+}
+
+Vec8_t
+pop_back(Vec8_t* vec)
+{
+	if (vec == nullptr || vec->arr == nullptr || vec->size <= 0)
+		return *vec;
+	vec->arr[vec->size - 1] = 0;
+	vec->size = vec->size - 1;
+	return *vec;
+}

src/lib/char/char.h

@@ -0,0 +1,85 @@
+/*
+ * Andrew Haynes
+ * dmm.dev@icloud.com
+ * No LICENSE
+ * Vector Library For C
+ */
+
+#ifndef CHAR_H
+#define CHAR_H
+
+#define CAPACITY 1024
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct
+{
+	char* arr;
+	size_t size;
+	size_t capacity;
+} Vec8_t;
+
+__attribute__((overloadable)) Vec8_t
+create(const Vec8_t* input);
+
+__attribute__((overloadable)) Vec8_t
+create(const _Bool init);
+
+Vec8_t
+reserve(Vec8_t* ptr, size_t max_size);
+
+Vec8_t
+shrink_to_fit(Vec8_t* ptr);
+
+int
+swap(Vec8_t* ptr, Vec8_t* ptr_other);
+
+char*
+data(const Vec8_t* ptr);
+
+size_t
+max_size(const Vec8_t* ptr);
+
+void delete (Vec8_t* vec);
+
+Vec8_t
+clear(Vec8_t* vec);
+
+char
+at(const Vec8_t* vec, int idx);
+
+__attribute__((overloadable)) Vec8_t*
+erase(Vec8_t* vec, size_t iter);
+
+__attribute__((overloadable)) Vec8_t*
+erase(Vec8_t* vec, size_t iter_start, size_t iter_end);
+
+void
+print_vec(const Vec8_t* vec);
+
+int
+begin(const Vec8_t* vec);
+
+int
+end(const Vec8_t* vec);
+
+char
+front(const Vec8_t* vec);
+
+char
+back(const Vec8_t* vec);
+
+int
+empty(const Vec8_t* vec);
+
+Vec8_t
+add_back(Vec8_t* vec, char val);
+
+Vec8_t
+pop_back(Vec8_t* vec);
+
+#endif

src/main.c

@@ -12,26 +12,69 @@
  *      String
  */
 
-#include "char.h"
+#include <stddef.h>
+#include <stdio.h>
+
+#include "lib/char/char.h"
 
 int
 main()
 {
 	Vec8_t vec = create(nullptr);
-	vec = add_back(&vec, '3');
+	Vec8_t other = create(nullptr);
-	vec = add_back(&vec, '4');
-	vec = add_back(&vec, '5');
-	vec = add_back(&vec, '6');
-	vec = add_back(&vec, '8');
-	vec = add_back(&vec, '6');
 
-	size_t size = vec.size;
+	for (int i = 0; i < 10; i++)
+	{
+		vec = add_back(&vec, 'a');
+	}
+	for (int i = 0; i < 5; i++)
+	{
+		other = add_back(&other, 'b');
+	}
+	printf("Vec: ");
 	print_vec(&vec);
-	// vec = *erase(&vec, begin(&vec) + 2);
+	printf("\n");
-	vec = *erase(&vec, begin(&vec) + 2, begin(&vec) + 4);
+	pop_back(&vec);
+	printf("Vec: ");
 	print_vec(&vec);
-	printf("%p", data(&vec));
+	printf("\n");
+
+	// int error = swap(&vec, &other);
+	// if (error)
+	// {
+	// 	printf("Vec: ");
+	// 	print_vec(&vec);
+	// 	printf("\n");
+	// 	printf("Other: ");
+	// 	print_vec(&other);
+	// }
+
+	// Vec8_t vec = create(false);
+
+	// vec = add_back(&vec, '3');
+	// vec = add_back(&vec, '4');
+	// vec = add_back(&vec, '5');
+	// vec = add_back(&vec, '6');
+	// vec = add_back(&vec, '8');
+	// vec = add_back(&vec, '6');
+
+	// for (int i = 0; i < vec.capacity; i++)
+	// {
+	// 	printf("%i\n", vec.arr[i]);
+	// }
+	// printf("\n");
+	// printf("\n");
+	//
+	// vec = shrink_to_fit(&vec);
+	// for (int i = 0; i < vec.capacity; i++)
+	// {
+	// 	printf("%i\n", vec.arr[i]);
+	// }
+	// vec = *erase(&vec, begin(&vec) + 2, begin(&vec) + 4);
+	// print_vec(&vec);
+	// printf("%p", data(&vec));
 
 	delete(&vec);
+	delete(&other);
 	return 0;
 }