API: Properly moved and configured char to new headers for cleaner api calls for later. Now I can add and cleanup easier

CMakeLists.txt

@@ -7,6 +7,7 @@ project(libvec LANGUAGES C)
 
 set(SOURCES
 	src/main.c
+        src/char.c
 )
 
 add_executable(libvec ${SOURCES})

include/char.h

@@ -0,0 +1,76 @@
+/*
+ * 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;
+
+Vec8_t
+create(const Vec8_t* input);
+
+char*
+reserve(Vec8_t* ptr, size_t max_size);
+
+Vec8_t*
+shrink_to_fit(const Vec8_t* ptr);
+
+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);
+
+#endif

src/char.c

@@ -0,0 +1,222 @@
+#include "char.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
+ * shrink_to_fit()	Reduces the reseved memory of a vector if necessary to
+ * exactly fit the number of elements swap()	Swaps the contents of one vector
+ * with another
+ * */
+
+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;
+}
+
+char*
+reserve(Vec8_t* ptr, const size_t max_size)
+{
+	char* res = reallocf(ptr, max_size * sizeof(char));
+	ptr->arr = res;
+	ptr->capacity = max_size * sizeof(char);
+	if (ptr->size > max_size) ptr->size = max_size;
+	return ptr->arr;
+}
+
+Vec8_t*
+shrink_to_fit(const Vec8_t* ptr)
+{
+	/* Create a new empty heap
+	 * copy current ptr values
+	 * realloc heap to current size
+	 *
+	 * */
+}
+
+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)
+	{
+		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;
+}

src/main.c

@@ -4,21 +4,6 @@
  * 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
- * shrink_to_fit()	Reduces the reseved memory of a vector if necessary to
- * exactly fit the number of elements swap()	Swaps the contents of one vector
- * with another
- * */
-
 /*
  * Types Wanted:
  *      Char
@@ -27,208 +12,7 @@
  *      String
  */
 
-#include <stddef.h>
+#include "char.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;
-
-#define CAPACITY 1024
-
-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;
-}
-
-char* reserve(Vec8_t* ptr, const size_t max_size) {
-        char* res = reallocf(ptr, max_size * sizeof(char));
-        ptr->arr = res;
-        ptr->capacity = max_size * sizeof(char);
-        if(ptr->size > max_size) ptr->size = max_size;
-        return ptr->arr;
-}
-
-Vec8_t*
-shrink_to_fit(const Vec8_t* ptr) {
-        /* Create a new empty heap
-         * copy current ptr values
-         * realloc heap to current size
-         *
-         * */
-}
-
-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)
-	{
-		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;
-}
 
 int
 main()