From f51a03c47643501cc0c8cd27d30da99c1af28dc2 Mon Sep 17 00:00:00 2001 From: Andrew Haynes Date: Fri, 18 Sep 2026 11:42:40 -0400 Subject: [PATCH] FEAT: Implemented a more streamlined error handler. REFACTOR: Completely rewrote insert and cleaned up names and redundant code. --- include/char.h | 37 ++-- include/utils.h | 5 +- src/char.c | 508 +++++++++++++++++++++++------------------------- src/main.c | 27 ++- src/utils.c | 4 +- 5 files changed, 285 insertions(+), 296 deletions(-) diff --git a/include/char.h b/include/char.h index 4cf74bb..4959d05 100644 --- a/include/char.h +++ b/include/char.h @@ -23,6 +23,9 @@ typedef struct size_t max_size; } Vec8_t; +int +is_valid(const Vec8_t* vec); + Vec8_t create(const char* buf, const int len); @@ -30,10 +33,10 @@ Vec8_t push_back(Vec8_t* vec, const char val); Vec8_t -pop_back(Vec8_t* vec); +pop_back(Vec8_t* ptr); Vec8_t -reserve(Vec8_t* ptr, const size_t max_size); +reserve(const Vec8_t* ptr, const size_t max_size); Vec8_t shrink_to_fit(Vec8_t* ptr); @@ -58,12 +61,6 @@ clear(const 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); @@ -83,25 +80,33 @@ int empty(const Vec8_t* vec); __attribute__((overloadable)) Vec8_t -resize(Vec8_t* vec, size_t size); +erase(const Vec8_t* vec, const size_t iter); __attribute__((overloadable)) Vec8_t -resize(Vec8_t* vec, size_t size, char val); +erase(const Vec8_t* vec, const size_t iter_start, const size_t iter_end); __attribute__((overloadable)) Vec8_t -assign(Vec8_t* vec, const Vec8_t* iterator, size_t iter_start, size_t iter_end); +resize(const Vec8_t* vec, const size_t size); __attribute__((overloadable)) Vec8_t -assign(Vec8_t* vec, const size_t amount, char val); +resize(Vec8_t* vec, const size_t size, const char val); __attribute__((overloadable)) Vec8_t -insert(Vec8_t* vec, size_t iter, char val); +assign(const Vec8_t* vec, const Vec8_t* iterator, const size_t iter_start, + const size_t iter_end); __attribute__((overloadable)) Vec8_t -insert(Vec8_t* vec, size_t iter, size_t amount, char val); +assign(const Vec8_t* vec, const size_t amount, const char val); __attribute__((overloadable)) Vec8_t -insert(Vec8_t* dst_vec, size_t iter, Vec8_t* src_vec, size_t iter_start, - size_t iter_end); +insert(const Vec8_t* vec, const size_t iter, const char val); + +__attribute__((overloadable)) Vec8_t +insert(const Vec8_t* vec, const size_t iter, const size_t amount, + const char val); + +__attribute__((overloadable)) Vec8_t +insert(const Vec8_t* dst_vec, const Vec8_t* src_vec, const size_t iter, + const size_t iter_start, const size_t iter_end); #endif diff --git a/include/utils.h b/include/utils.h index 48d81d3..a568356 100644 --- a/include/utils.h +++ b/include/utils.h @@ -3,6 +3,7 @@ #include #include + #define CAPACITY 1024 #define SUCCESS 0 @@ -10,9 +11,10 @@ #define ERR_ALLOC_FAIL 20 #define ERR_BUF_NULL 21 #define ERR_BAD_TYPE 22 -#define ERR_INVALID_SIZE 23 +#define ERR_SIZE_ZERO 23 #define ERR_VECTOR_NULL 24 #define ERR_MAX_PASSED 25 +#define ERR_OUT_OF_BOUNDS 26 extern const char* error_messages[]; @@ -22,6 +24,7 @@ extern const char* error_messages[]; error_messages[error_code]) /**< Print log error message*/ #define find_len(arr) sizeof(arr) / sizeof(arr[0]) + static const size_t VEC_MAX = SIZE_MAX / sizeof(int); #endif diff --git a/src/char.c b/src/char.c index 6a1255f..54ba389 100644 --- a/src/char.c +++ b/src/char.c @@ -8,20 +8,35 @@ #include "utils.h" +int +is_valid(const Vec8_t* vec) +{ + if (vec == nullptr) + { + LOGERROR(ERR_VECTOR_NULL); + return ERR_VECTOR_NULL; + } + else if (vec->arr == nullptr) + { + LOGERROR(ERR_BUF_NULL); + return ERR_BUF_NULL; + } + return SUCCESS; +} + // If -1 for len, returns a blank Vector with no allocated memory Vec8_t create(const char* buf, const int len) { Vec8_t dst = { NULL, 0, CAPACITY, VEC_MAX }; - if (len > -1) + if (len > 0) { char* dst_buf = calloc(CAPACITY, sizeof(char)); dst.arr = dst_buf; } - if (!dst.arr) + if (len == -1) { - LOG("Warning! Buffer not allocated, be careful if this was " - "intentional"); + // LOG("Warning! Buffer was forcibly not allocated."); return dst; } if (buf) @@ -36,39 +51,37 @@ create(const char* buf, const int len) } Vec8_t -push_back(Vec8_t* vec, const char val) +push_back(Vec8_t* ptr, const char val) { - if (!vec) + if (is_valid(ptr) == ERR_VECTOR_NULL) { - LOGERROR(ERR_VECTOR_NULL); return create(nullptr, -1); } - Vec8_t dst = { NULL, vec->size, CAPACITY, vec->max_size }; + Vec8_t dst = { NULL, ptr->size, CAPACITY, ptr->max_size }; - if (!vec->arr) + if (is_valid(ptr) == ERR_BUF_NULL) { - LOGERROR(ERR_BUF_NULL); LOG("If you think this is wrong, reserve memory first"); return dst; } - if (vec->size + 1 > vec->max_size) + if (ptr->size + 1 > ptr->max_size) { LOGERROR(ERR_MAX_PASSED); - dst = *vec; + dst = *ptr; return dst; } char* dst_buf; - if (vec->size + 1 > vec->capacity) + if (ptr->size + 1 > ptr->capacity) { - if (vec->capacity * 2 > vec->max_size) + if (ptr->capacity * 2 > ptr->max_size) { LOGERROR(ERR_MAX_PASSED); - dst = *vec; + dst = *ptr; return dst; } - dst.capacity = vec->capacity * 2; - dst_buf = reallocf(vec->arr, dst.capacity * sizeof(char)); + dst.capacity = ptr->capacity * 2; + dst_buf = reallocf(ptr->arr, dst.capacity * sizeof(char)); if (!dst_buf) { LOGERROR(ERR_ALLOC_FAIL); @@ -77,7 +90,7 @@ push_back(Vec8_t* vec, const char val) } else { - dst_buf = vec->arr; + dst_buf = ptr->arr; } dst.arr = dst_buf; dst.arr[dst.size] = val; @@ -86,46 +99,40 @@ push_back(Vec8_t* vec, const char val) } Vec8_t -pop_back(Vec8_t* vec) +pop_back(Vec8_t* ptr) { Vec8_t err = create(nullptr, -1); - if (!vec) + if (is_valid(ptr) != SUCCESS) { - LOGERROR(ERR_VECTOR_NULL); return err; } - if (!vec->arr) + if (ptr->size < 1) { - LOGERROR(ERR_BUF_NULL); + LOGERROR(ERR_SIZE_ZERO); return err; } - if (vec->size < 1) - { - LOGERROR(ERR_INVALID_SIZE); - return err; - } - Vec8_t dst = { NULL, vec->size - 1, vec->capacity, vec->max_size }; - dst.arr = vec->arr; + Vec8_t dst = { NULL, ptr->size - 1, ptr->capacity, ptr->max_size }; + dst.arr = ptr->arr; dst.arr[dst.size] = 0; return dst; } Vec8_t -reserve(Vec8_t* ptr, const size_t max_size) +reserve(const Vec8_t* ptr, const size_t max_size) { Vec8_t ret = create(nullptr, -1); - if (!ptr) + ret.arr = ptr->arr; + if (is_valid(ptr) == ERR_VECTOR_NULL) { - LOGERROR(ERR_VECTOR_NULL); return ret; } - if (!ptr->arr) + if (is_valid(ptr) == ERR_BUF_NULL) { ret.arr = calloc(max_size, sizeof(char)); } - if (ptr->arr) + if (is_valid(ptr) == SUCCESS) { - ret.arr = reallocf(ptr->arr, max_size * sizeof(char)); + ret.arr = reallocf(ret.arr, max_size * sizeof(char)); ret.size = ptr->size; if (ret.size > max_size) { @@ -148,35 +155,37 @@ shrink_to_fit(Vec8_t* ptr) } int -swap(Vec8_t* ptr, Vec8_t* ptr_other) +swap(Vec8_t* ptr1, Vec8_t* ptr2) { Vec8_t empty = create(nullptr, -1); - if (ptr == nullptr || ptr_other == nullptr || ptr->arr == nullptr || - ptr_other->arr == nullptr) - return 0; - empty.arr = ptr->arr; - ptr->arr = ptr_other->arr; - ptr_other->arr = empty.arr; - if (ptr != nullptr && ptr_other != nullptr) + if (is_valid(ptr1) == ERR_VECTOR_NULL || + is_valid(ptr2) == ERR_VECTOR_NULL) { - 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; + return ERR_VECTOR_NULL; } - free(ptr); - free(ptr_other); + if (is_valid(ptr1) == ERR_BUF_NULL || is_valid(ptr2) == ERR_BUF_NULL) + { + return ERR_BUF_NULL; + } + empty.arr = ptr1->arr; + ptr1->arr = ptr2->arr; + ptr2->arr = empty.arr; + + empty.capacity = ptr1->capacity; + empty.size = ptr1->size; + ptr1->capacity = ptr2->capacity; + ptr1->size = ptr2->size; + + ptr2->capacity = empty.capacity; + ptr2->size = empty.size; return 0; } char* data(const Vec8_t* ptr) { - if (ptr == nullptr || ptr->arr == nullptr) return nullptr; + if (is_valid(ptr) == ERR_BUF_NULL || is_valid(ptr) == ERR_VECTOR_NULL) + return nullptr; return &ptr->arr[0]; } @@ -193,26 +202,26 @@ max_size(const Vec8_t* ptr) } void -delete(const Vec8_t* vec) +delete(const Vec8_t* ptr) { - if (vec->arr != nullptr) + if (is_valid(ptr) == SUCCESS) { - free((void*)vec->arr); + free((void*)ptr->arr); } } Vec8_t -clear(const Vec8_t* vec) +clear(const Vec8_t* ptr) { Vec8_t dst = create(nullptr, -1); - if (!vec && !vec->arr) + if (is_valid(ptr) == ERR_VECTOR_NULL || is_valid(ptr) == ERR_BUF_NULL) { return dst; } - dst.arr = vec->arr; - if (vec->size > 0) + dst.arr = ptr->arr; + if (ptr->size > 0) { - for (int i = 0; i < vec->size; i++) + for (int i = 0; i < ptr->size; i++) { dst.arr[i] = 0; } @@ -222,299 +231,262 @@ clear(const Vec8_t* vec) } char -at(const Vec8_t* vec, const int idx) +at(const Vec8_t* ptr, const int idx) { - if (vec == nullptr) + if (is_valid(ptr) == ERR_VECTOR_NULL) { - LOGERROR(ERR_VECTOR_NULL); return ERR_VECTOR_NULL; } - if (vec->arr == nullptr) + if (is_valid(ptr) == ERR_BUF_NULL) { - LOGERROR(ERR_BUF_NULL); return ERR_BUF_NULL; } - if (vec->size <= idx) + if (ptr->size <= idx) { fprintf(stderr, "At Index: [%i] is out of bounds for size: [%zu]", idx, - vec->size); + ptr->size); exit(-4); - // return -4; + return ERR_OUT_OF_BOUNDS; } - return vec->arr[idx]; -} - -__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; + return ptr->arr[idx]; } void -print_vec(const Vec8_t* vec) +print_vec(const Vec8_t* ptr) { - if (!vec) - { - LOGERROR(ERR_VECTOR_NULL); + if (is_valid(ptr) == ERR_VECTOR_NULL || is_valid(ptr) == ERR_BUF_NULL) return; - } - for (int i = 0; i < vec->size; i++) - { - if (vec->arr[i]) - { - printf("%c ", at(vec, i)); - } - else - { - LOGERROR(ERR_INVALID_SIZE); - } - } + for (int i = 0; i < ptr->size; i++) printf("%c ", at(ptr, i)); printf("\n"); } int -begin(const Vec8_t* vec) +begin(const Vec8_t* ptr) { - if (vec != nullptr && vec->arr != nullptr && vec->size > 0) - { - return 0; - } - return -1; + if (is_valid(ptr) == SUCCESS) return 0; + return FAILURE; } int -end(const Vec8_t* vec) +end(const Vec8_t* ptr) { - if (vec != nullptr && vec->arr != nullptr && vec->size > 0) - { - return (int)(vec->size - 1); - } - return -1; + if (is_valid(ptr) == SUCCESS) return (int)(ptr->size - 1); + return FAILURE; } char -front(const Vec8_t* vec) +front(const Vec8_t* ptr) { - return at(vec, 0); + return at(ptr, 0); } char -back(const Vec8_t* vec) +back(const Vec8_t* ptr) { - if (vec) - { - return at(vec, (int)vec->size - 1); - } - return -1; + if (is_valid(ptr) == ERR_VECTOR_NULL) + return at(ptr, (int)ptr->size - 1); + return FAILURE; } int -empty(const Vec8_t* vec) +empty(const Vec8_t* ptr) { - if (vec->size > 0) - { - return 1; - } - return 0; + if (is_valid(ptr) == ERR_VECTOR_NULL || is_valid(ptr) == ERR_BUF_NULL) + return FAILURE; + if (ptr->size <= 0) return SUCCESS; + return FAILURE; } __attribute__((overloadable)) Vec8_t -resize(Vec8_t* vec, size_t size) +erase(const Vec8_t* ptr, const size_t iter) { - Vec8_t nvec = create(nullptr, 0); - if (vec == nullptr || vec->arr == nullptr) return nvec; - if (size <= 0 || vec->size <= 0) - { - fprintf(stderr, - "Size or Vector Size is at or below 0 and is invalid"); - return nvec; - } - for (size_t i = size; i < vec->size; i++) - { - vec->arr[i] = '\0'; - } - return *vec; + Vec8_t dst = create(nullptr, -1); + if (is_valid(ptr) == ERR_VECTOR_NULL) return dst; + if (is_valid(ptr) == ERR_BUF_NULL) return dst; + if (iter >= ptr->size) return dst; + dst = *ptr; + memmove(&dst.arr[iter], &dst.arr[iter + 1], + (dst.size - iter - 1) * sizeof(char)); + dst.arr[dst.size - 1] = 0; + dst.size--; + return dst; } __attribute__((overloadable)) Vec8_t -resize(Vec8_t* vec, size_t size, char val) +erase(const Vec8_t* ptr, const size_t iter_start, const size_t iter_end) { - Vec8_t nvec = create(nullptr, 0); - if (vec == nullptr || vec->arr == nullptr) return nvec; - if (size <= 0 || vec->size <= 0) + Vec8_t dst = create(nullptr, -1); + if (is_valid(ptr) == ERR_VECTOR_NULL) return dst; + if (is_valid(ptr) == ERR_BUF_NULL) return dst; + if (iter_start < 0 || iter_end > ptr->size) return dst; + if (iter_start >= iter_end) return dst; + dst = *ptr; + size_t diff = iter_end - iter_start; + memmove(&dst.arr[iter_start], &dst.arr[iter_end], + (dst.size - iter_end) * sizeof(char)); + for (size_t i = dst.size - diff; i < dst.size; i++) { - fprintf(stderr, - "Size or Vector Size is at or below 0 and is invalid"); - return nvec; + dst.arr[i] = 0; } - if (size == vec->size) - { - fprintf(stderr, - "Size and Vector Size are equal to each other and is " - "invalid"); - return nvec; - } - if (size < vec->size) - { - fprintf(stderr, "Size is below Vector Size is invalid"); - return nvec; - } - if (size >= vec->capacity) - { - nvec = reserve(vec, size); - } - size_t ret = vec->size; - vec->size = vec->size + (size - vec->size); + dst.size -= diff; + return dst; +} - for (size_t i = ret; i < vec->size; i++) +// TODO: Redo resize entirely +__attribute__((overloadable)) Vec8_t +resize(const Vec8_t* ptr, const size_t size) +{ + Vec8_t dst = create(nullptr, -1); + if (is_valid(ptr) == ERR_VECTOR_NULL || is_valid(ptr) == ERR_BUF_NULL) + return dst; + dst = *ptr; + if ((0 < size && size != ptr->size && size < ptr->size) || + is_valid(ptr) == ERR_SIZE_ZERO) { - if (at(vec, (int)i) >= 0) + LOGERROR(ERR_SIZE_ZERO); + return dst; + } + for (size_t i = size - 1; i < ptr->size; i++) + { + dst.arr[i] = '\0'; + } + dst.size = size; + return dst; +} + +__attribute__((overloadable)) Vec8_t +resize(Vec8_t* ptr, const size_t size, const char val) +{ + Vec8_t dst = create(nullptr, -1); + dst = *ptr; + if (is_valid(ptr) == ERR_VECTOR_NULL || is_valid(ptr) == ERR_BUF_NULL) + return dst; + + if ((0 < size && size != dst.size && size < dst.size) || + is_valid(ptr) == ERR_SIZE_ZERO) + { + LOGERROR(ERR_SIZE_ZERO); + return dst; + } + if ((0 < size && size < dst.size) || is_valid(ptr) == ERR_SIZE_ZERO) + { + LOGERROR(ERR_SIZE_ZERO); + return dst; + } + if (size >= dst.capacity) + { + dst = reserve(&dst, size); + } + dst.size = ptr->size + (size - ptr->size); + + for (size_t i = ptr->size; i < dst.size; i++) + { + if (at(&dst, (int)i) >= 0) { - vec->arr[i] = val; + dst.arr[i] = val; } } - return *vec; + dst.size = size; + return dst; } __attribute__((overloadable)) Vec8_t -assign(Vec8_t* vec, const Vec8_t* iterator, size_t iter_start, size_t iter_end) +assign(const Vec8_t* ptr, const Vec8_t* iterator, const size_t iter_start, + const size_t iter_end) { - Vec8_t ret = create(nullptr, 0); - if (vec == nullptr || vec->arr == nullptr) return ret; - if (iterator == nullptr || iterator->arr == nullptr) return ret; - if (iter_end <= iter_start) return ret; - vec = erase(vec, begin(vec), end(vec) + 1); - size_t res = iter_end - iter_start; - *vec = reserve(vec, res); + Vec8_t dst = create(nullptr, -1); + if (is_valid(ptr) == ERR_VECTOR_NULL || is_valid(ptr) == ERR_BUF_NULL) + return dst; + if (is_valid(iterator) == ERR_VECTOR_NULL || + is_valid(iterator) == ERR_BUF_NULL) + return dst; + if (iter_end <= iter_start) return dst; + dst = erase(ptr, begin(ptr), end(ptr) + 1); + dst = reserve(&dst, (iter_end - iter_start)); for (size_t i = iter_start; i < iter_end; i++) { - *vec = push_back(vec, at(iterator, (int)i)); + dst = push_back(&dst, at(iterator, (int)i)); } - return *vec; + return dst; } __attribute__((overloadable)) Vec8_t -assign(Vec8_t* vec, const size_t amount, char val) +assign(const Vec8_t* ptr, const size_t amount, const char val) { - if (vec == nullptr || vec->arr == nullptr) return create(nullptr, 0); - vec = erase(vec, begin(vec), end(vec) + 1); - *vec = reserve(vec, amount); + Vec8_t dst = create(nullptr, -1); + if (is_valid(ptr) == ERR_VECTOR_NULL || is_valid(ptr) == ERR_BUF_NULL) + return create(nullptr, -1); + dst = erase(&dst, begin(&dst), end(&dst) + 1); + dst = reserve(&dst, amount); for (int i = 0; i < amount; i++) { - *vec = push_back(vec, val); + dst = push_back(&dst, val); } - return *vec; + return dst; } -// TODO: Add error checking and null checking -// Follows array style __attribute__((overloadable)) Vec8_t -insert(Vec8_t* vec, size_t iter, char val) +insert(const Vec8_t* ptr, const size_t iter, const char val) { - size_t last = vec->size; - *vec = push_back(vec, 0); - for (size_t i = vec->size - 1; i > iter; i--) + Vec8_t dst = create(nullptr, -1); + if (is_valid(ptr) == ERR_VECTOR_NULL || is_valid(ptr) == ERR_BUF_NULL) { - vec->arr[i] = vec->arr[i - 1]; + return dst; } - vec->arr[iter] = val; + if (iter < 0) + { + LOGERROR(ERR_SIZE_ZERO); + return dst; + } + dst = *ptr; + dst = push_back(&dst, 0); + for (size_t i = dst.size - 1; i > iter; i--) + { + dst.arr[i] = dst.arr[i - 1]; + } + dst.arr[iter] = val; - return *vec; + return dst; } -// TODO: Add error checking and null checking -// Follows array style __attribute__((overloadable)) Vec8_t -insert(Vec8_t* vec, size_t iter, size_t amount, char val) +insert(const Vec8_t* ptr, const size_t iter, const size_t amount, + const char val) { - size_t last = vec->size; - char cpy[vec->size - (iter)]; - size_t cpy_size = (vec->size - (iter)); - int k = 0; - for (size_t i = iter; i < vec->size; i++) + Vec8_t dst = create(nullptr, -1); + if (is_valid(ptr) == ERR_VECTOR_NULL || is_valid(ptr) == ERR_BUF_NULL) { - cpy[k] = vec->arr[i]; - k++; + return dst; } - for (int i = 0; i < amount; i++) + if (iter < 0 || amount <= 0) { - *vec = push_back(vec, 0); + LOGERROR(ERR_SIZE_ZERO); + return dst; } - - if ((iter - 1) + amount <= last) + dst = *ptr; + for (size_t i = iter; i < iter + amount; i++) { - for (int i = iter; i < vec->size; i++) - { - vec->arr[i] = 0; - } - size_t j = iter - 1 + amount; - for (int i = 0; i < cpy_size; i++) - { - vec->arr[j + i] = cpy[i]; - } - for (int i = iter; i < iter + amount - 1; i++) - { - vec->arr[i] = val; - } + dst = insert(&dst, i, val); } - else - { - return *vec; - } - - return *vec; + return dst; } -// TODO: Add error checking and null checking -// NOTE: It might be a good idea to move the iter ahead of the src_vec __attribute__((overloadable)) Vec8_t -insert(Vec8_t* dst_vec, size_t iter, Vec8_t* src_vec, size_t iter_start, - size_t iter_end) +insert(const Vec8_t* dst_vec, const Vec8_t* src_vec, const size_t iter, + const size_t iter_start, const size_t iter_end) { - size_t cpy_size = iter_end - iter_start; - char cpy[cpy_size]; - int j = 0; - for (int i = iter_start; i < iter_end; i++) + Vec8_t dst = create(nullptr, -1); + if (is_valid(dst_vec) == ERR_VECTOR_NULL || + is_valid(dst_vec) == ERR_BUF_NULL) + return dst; + if (is_valid(src_vec) == ERR_VECTOR_NULL || + is_valid(src_vec) == ERR_BUF_NULL) + return dst; + dst = *dst_vec; + for (size_t i = iter_start; i < iter_end; i++) { - cpy[j] = src_vec->arr[i]; - j++; + dst = insert(&dst, iter + (i - iter_start), src_vec->arr[i]); } - for (int i = 0; i < cpy_size; i++) - { - printf("%c ", cpy[i]); - } - printf("\n"); - for (int i = 0; i < iter_end - iter_start; i++) - { - insert(dst_vec, (iter_start - 1) + i, cpy[i]); - } - return *dst_vec; - - // Inserts over an iteration, [0, 5] + return dst; } diff --git a/src/main.c b/src/main.c index 6514ae4..25d9888 100644 --- a/src/main.c +++ b/src/main.c @@ -22,18 +22,25 @@ int main() { - char arr[] = { '1', '2', '3', '4' }; - Vec8_t v1 = create(arr, find_len(arr)); - Vec8_t v2 = create((char[]) { 'a', 'b', 'c', 'd' }, 4); - + char ar1[] = { '1', '2', '3', '4' }; + char ar2[] = { 'a', 'b', 'c', 'd' }; + Vec8_t v1 = create(ar1, find_len(ar1)); + Vec8_t v2 = create(ar2, find_len(ar2)); + // print_vec(&v1); + // printf("Hello\n"); + // v1 = assign(&v1, &v2, 0, 1); + v1 = insert(&v1, 1, 5, 'a'); + // printf("RESERVED SIZE: %zu", v1.max_size); print_vec(&v1); - print_vec(&v2); + // v2 = resize(&v2, 3); - if (swap(&v1, &v2)) - { - print_vec(&v1); - print_vec(&v2); - } + // print_vec(&v2); + + // if (swap(&v1, &v2)) + // { + // print_vec(&v1); + // print_vec(&v2); + // } // Vec8_t v1 = create(nullptr, 0); // v1 = reserve(&v1, 10); // v1 = pop_back(&v1); diff --git a/src/utils.c b/src/utils.c index 27b6524..a97d7ab 100644 --- a/src/utils.c +++ b/src/utils.c @@ -4,9 +4,11 @@ const char* error_messages[] = { [ERR_ALLOC_FAIL] = "Calloc :- Failed to allocate", [ERR_BUF_NULL] = "Buffer :- NULL", [ERR_BAD_TYPE] = "Type :- Does not match vector type", - [ERR_INVALID_SIZE] = "Size :- Size is 0 or invalid", + [ERR_SIZE_ZERO] = "Size :- Size is or is less than 0 or invalid", [ERR_VECTOR_NULL] = "Vector :- Given vector is null", [ERR_MAX_PASSED] = "Max :- Vector Max value is overloaded", + [ERR_OUT_OF_BOUNDS] = "Bounds:- Value is out of bounds", + // [ERR_CREATION_FAIL] = "Buffer creation failed", // [ERR_MALLOC_NULL] = "Malloc Failed to allocate", };