CHORE: cleaning up files and bug fixing
This commit is contained in:
+2
-2
@@ -681,7 +681,7 @@ vec_char_assign(vec_char* ptr, const vec_char* iterator,
|
||||
err->flags |= ERR_OUT_OF_BOUNDS;
|
||||
return;
|
||||
}
|
||||
vec_char_erase(ptr, _vec_char_begin(ptr, &status),
|
||||
vec_char_erase(ptr, vec_char_begin(ptr, &status),
|
||||
vec_char_end(ptr, &status) + 1, &status);
|
||||
if (status.flags != 0)
|
||||
{
|
||||
@@ -731,7 +731,7 @@ vec_char_assign(vec_char* ptr, const size_t amount, const char val, err_t* err)
|
||||
err->flags |= ERR_SIZE_ZERO;
|
||||
return;
|
||||
}
|
||||
vec_char_erase(ptr, _vec_char_begin(ptr, &status),
|
||||
vec_char_erase(ptr, vec_char_begin(ptr, &status),
|
||||
vec_char_end(ptr, &status) + 1, &status);
|
||||
if (status.flags != 0)
|
||||
{
|
||||
|
||||
@@ -6,9 +6,6 @@
|
||||
*/
|
||||
/*
|
||||
* Types Wanted:
|
||||
* Char 8 Bits
|
||||
* Float 32 Bits with suffix of 'f'
|
||||
* Int 32 bits
|
||||
* String 32 Bits with suffix of 's'
|
||||
*/
|
||||
|
||||
|
||||
+912
@@ -0,0 +1,912 @@
|
||||
#include "libstr/string.h"
|
||||
|
||||
#include <libvec/string.h>
|
||||
#include <libvec/utils.h>
|
||||
#include <stddef.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
__attribute__((overloadable)) size_t
|
||||
__null_check(const vec_string* ptr, err_t* status)
|
||||
{
|
||||
if (status == nullptr)
|
||||
{
|
||||
return ERR_ERR_T_NULL;
|
||||
}
|
||||
if (ptr == nullptr)
|
||||
{
|
||||
status->flags |= ERR_VEC_NULL;
|
||||
return ERR_VEC_NULL;
|
||||
}
|
||||
if (ptr->array == nullptr)
|
||||
{
|
||||
status->flags |= ERR_BUF_NULL;
|
||||
}
|
||||
|
||||
return status->flags;
|
||||
}
|
||||
|
||||
void
|
||||
vec_string_print_vec(const vec_string* ptr, err_t* err)
|
||||
{
|
||||
if (__null_check(ptr, err) != 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
for (size_t i = 0; i < ptr->size; i++)
|
||||
{
|
||||
printf("%s ", ptr->array[i].data);
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
vec_string
|
||||
vec_string_cpy(const char* src, const size_t src_size, err_t* err)
|
||||
{
|
||||
vec_string self = VEC_INIT;
|
||||
err_t status = ERR_T_INIT;
|
||||
|
||||
size_t null = __null_check(src, err);
|
||||
if (null != 0)
|
||||
{
|
||||
if (null & ERR_ERR_T_NULL)
|
||||
{
|
||||
return self;
|
||||
}
|
||||
__origin_override(err, "CPY");
|
||||
err->flags |= status.flags;
|
||||
return self;
|
||||
}
|
||||
if (src_size == 0)
|
||||
{
|
||||
__origin_override(err, "CPY");
|
||||
err->flags |= ERR_SIZE_ZERO;
|
||||
err->flags |= status.flags;
|
||||
return self;
|
||||
}
|
||||
if (src_size > self.max_size)
|
||||
{
|
||||
__origin_override(err, "CPY");
|
||||
err->flags |= ERR_SIZE_OVERFLOW;
|
||||
return self;
|
||||
}
|
||||
self.array = malloc(src_size * sizeof(String));
|
||||
if (self.array == nullptr)
|
||||
{
|
||||
__origin_override(err, "CPY");
|
||||
err->flags |= ERR_ALLOC_FAIL;
|
||||
return self;
|
||||
}
|
||||
memcpy(self.array, src, src_size * sizeof(String));
|
||||
self.size = src_size;
|
||||
self.capacity = src_size;
|
||||
return self;
|
||||
}
|
||||
|
||||
void
|
||||
vec_string_push_back(vec_string* ptr, const String val, err_t* err)
|
||||
{
|
||||
err_t status = ERR_T_INIT;
|
||||
String* res;
|
||||
__null_check(ptr, &status);
|
||||
if ((status.flags & ERR_VEC_NULL) != 0)
|
||||
{
|
||||
__origin_override(err, "PUSH_BACK");
|
||||
err->flags |= ERR_VEC_NULL;
|
||||
return;
|
||||
}
|
||||
|
||||
if (ptr->size + 1 > ptr->max_size)
|
||||
{
|
||||
__origin_override(err, "PUSH_BACK");
|
||||
err->flags |= ERR_SIZE_OVERFLOW;
|
||||
return;
|
||||
}
|
||||
|
||||
if ((status.flags & ERR_BUF_NULL) != 0)
|
||||
{
|
||||
res = malloc(1 * sizeof(String));
|
||||
if (res == nullptr)
|
||||
{
|
||||
__origin_override(err, "PUSH_BACK");
|
||||
err->flags |= ERR_ALLOC_FAIL;
|
||||
return;
|
||||
}
|
||||
ptr->array = res;
|
||||
ptr->capacity = 1;
|
||||
ptr->size = 0;
|
||||
}
|
||||
|
||||
else if (ptr->size + 1 > ptr->capacity)
|
||||
{
|
||||
size_t dst_cap = (ptr->capacity / 2) + ptr->capacity;
|
||||
if (dst_cap == ptr->capacity)
|
||||
{
|
||||
dst_cap++;
|
||||
}
|
||||
if (dst_cap > ptr->max_size)
|
||||
{
|
||||
dst_cap = ptr->max_size;
|
||||
DEBUG(
|
||||
"Capacity cannot be grown any further due "
|
||||
"to hitting max size");
|
||||
}
|
||||
res = realloc(ptr->array, dst_cap * sizeof(String));
|
||||
if (res == nullptr)
|
||||
{
|
||||
__origin_override(err, "PUSH_BACK");
|
||||
err->flags |= ERR_SIZE_OVERFLOW;
|
||||
return;
|
||||
}
|
||||
ptr->array = res;
|
||||
ptr->capacity = dst_cap;
|
||||
}
|
||||
ptr->array[ptr->size] = val;
|
||||
ptr->size++;
|
||||
return;
|
||||
}
|
||||
|
||||
void
|
||||
vec_string_pop_back(vec_string* ptr, err_t* err)
|
||||
{
|
||||
if (__null_check(ptr, err) != 0)
|
||||
{
|
||||
__origin_override(err, "POP_BACK");
|
||||
return;
|
||||
}
|
||||
|
||||
if (ptr->size == 0)
|
||||
{
|
||||
__origin_override(err, "POP_BACK");
|
||||
err->flags |= ERR_SIZE_ZERO;
|
||||
return;
|
||||
}
|
||||
|
||||
ptr->array[ptr->size - 1] = (String)STR_INIT;
|
||||
ptr->size--;
|
||||
}
|
||||
|
||||
void
|
||||
vec_string_reserve(vec_string* ptr, const size_t capacity, err_t* err)
|
||||
{
|
||||
err_t status = ERR_T_INIT;
|
||||
if (__null_check(ptr, &status) != 0)
|
||||
{
|
||||
if ((status.flags & ERR_VEC_NULL) != 0)
|
||||
{
|
||||
__origin_override(err, "RESERVE");
|
||||
err->flags |= ERR_VEC_NULL;
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (ptr->max_size < capacity)
|
||||
{
|
||||
__origin_override(err, "RESERVE");
|
||||
err->flags |= ERR_SIZE_OVERFLOW;
|
||||
return;
|
||||
}
|
||||
if (capacity == 0)
|
||||
{
|
||||
__origin_override(err, "RESERVE");
|
||||
err->flags |= ERR_SIZE_ZERO;
|
||||
return;
|
||||
}
|
||||
|
||||
String* res = realloc(ptr->array, capacity * sizeof(String));
|
||||
if (res == nullptr)
|
||||
{
|
||||
__origin_override(err, "RESERVE");
|
||||
err->flags |= ERR_ALLOC_FAIL;
|
||||
return;
|
||||
}
|
||||
ptr->array = res;
|
||||
ptr->capacity = capacity;
|
||||
if (ptr->size > capacity)
|
||||
{
|
||||
ptr->size = capacity;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
void
|
||||
vec_string_shrink_to_fit(vec_string* ptr, err_t* err)
|
||||
{
|
||||
err_t status = ERR_T_INIT;
|
||||
if (__null_check(ptr, &status) != 0)
|
||||
{
|
||||
__origin_override(err, "SHRINK_TO_FIT");
|
||||
err->flags |= status.flags;
|
||||
return;
|
||||
}
|
||||
if (ptr->size == 0)
|
||||
{
|
||||
__origin_override(err, "SHRINK_TO_FIT");
|
||||
err->flags |= ERR_SIZE_ZERO;
|
||||
return;
|
||||
}
|
||||
vec_string_reserve(ptr, ptr->size, err);
|
||||
}
|
||||
|
||||
void
|
||||
vec_string_swap(vec_string* ptr_a, vec_string* ptr_b, err_t* err)
|
||||
{
|
||||
err_t status_1 = ERR_T_INIT, status_2 = ERR_T_INIT;
|
||||
if ((__null_check(ptr_a, &status_1) & ERR_VEC_NULL) != 0 ||
|
||||
(__null_check(ptr_b, &status_2) & ERR_VEC_NULL) != 0)
|
||||
{
|
||||
__origin_override(err, "SWAP");
|
||||
err->flags |= ERR_VEC_NULL;
|
||||
return;
|
||||
}
|
||||
vec_string self = *ptr_a;
|
||||
*ptr_a = *ptr_b;
|
||||
*ptr_b = self;
|
||||
return;
|
||||
}
|
||||
|
||||
const String*
|
||||
vec_string_data(const vec_string* ptr, err_t* err)
|
||||
{
|
||||
err_t status = ERR_T_INIT;
|
||||
if (__null_check(ptr, &status) != 0)
|
||||
{
|
||||
__origin_override(err, "DATA");
|
||||
err->flags |= status.flags;
|
||||
return nullptr;
|
||||
}
|
||||
return &ptr->array[0];
|
||||
}
|
||||
|
||||
size_t
|
||||
vec_string_size(const vec_string* ptr, err_t* err)
|
||||
{
|
||||
err_t status = ERR_T_INIT;
|
||||
if (__null_check(ptr, &status) != 0)
|
||||
{
|
||||
__origin_override(err, "SIZE");
|
||||
err->flags |= status.flags;
|
||||
return 0;
|
||||
}
|
||||
return ptr->size;
|
||||
}
|
||||
|
||||
size_t
|
||||
vec_string_capacity(const vec_string* ptr, err_t* err)
|
||||
{
|
||||
err_t status = ERR_T_INIT;
|
||||
if (__null_check(ptr, &status) != 0)
|
||||
{
|
||||
__origin_override(err, "CAPACITY");
|
||||
err->flags |= status.flags;
|
||||
return 0;
|
||||
}
|
||||
return ptr->capacity;
|
||||
}
|
||||
|
||||
size_t
|
||||
vec_string_max_size(const vec_string* ptr, err_t* err)
|
||||
{
|
||||
err_t status = ERR_T_INIT;
|
||||
if (__null_check(ptr, &status) != 0)
|
||||
{
|
||||
__origin_override(err, "MAX_SIZE");
|
||||
err->flags |= status.flags;
|
||||
return 0;
|
||||
}
|
||||
return ptr->max_size;
|
||||
}
|
||||
|
||||
void
|
||||
vec_string_delete(vec_string* ptr, err_t* err)
|
||||
{
|
||||
err_t status = ERR_T_INIT;
|
||||
if (__null_check(ptr, &status) != 0)
|
||||
{
|
||||
__origin_override(err, "DELETE");
|
||||
err->flags |= status.flags;
|
||||
return;
|
||||
}
|
||||
if (ptr->array != nullptr)
|
||||
{
|
||||
free(ptr->array);
|
||||
ptr->array = nullptr;
|
||||
}
|
||||
ptr->size = 0;
|
||||
ptr->capacity = 0;
|
||||
}
|
||||
|
||||
void
|
||||
vec_string_clear(vec_string* ptr, err_t* err)
|
||||
{
|
||||
err_t status = ERR_T_INIT;
|
||||
if (__null_check(ptr, &status) != 0)
|
||||
{
|
||||
__origin_override(err, "CLEAR");
|
||||
err->flags |= status.flags;
|
||||
return;
|
||||
}
|
||||
if (ptr->size > 0)
|
||||
{
|
||||
memset(ptr->array, 0, ptr->size);
|
||||
ptr->size = 0;
|
||||
}
|
||||
}
|
||||
|
||||
String*
|
||||
vec_string_at(const vec_string* ptr, const size_t idx, err_t* err)
|
||||
{
|
||||
err_t status = ERR_T_INIT;
|
||||
if (__null_check(ptr, &status) != 0)
|
||||
{
|
||||
__origin_override(err, "AT");
|
||||
err->flags |= status.flags;
|
||||
return nullptr;
|
||||
}
|
||||
if (idx >= ptr->size)
|
||||
{
|
||||
__origin_override(err, "AT");
|
||||
err->flags |= ERR_OUT_OF_BOUNDS;
|
||||
return nullptr;
|
||||
}
|
||||
return &ptr->array[idx];
|
||||
}
|
||||
|
||||
size_t
|
||||
vec_string_begin(const vec_string* ptr, err_t* err)
|
||||
{
|
||||
err_t status = ERR_T_INIT;
|
||||
if (__null_check(ptr, &status) != 0)
|
||||
{
|
||||
__origin_override(err, "BEGIN");
|
||||
err->flags |= status.flags;
|
||||
return status.flags;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
size_t
|
||||
vec_string_end(const vec_string* ptr, err_t* err)
|
||||
{
|
||||
err_t status = ERR_T_INIT;
|
||||
if (__null_check(ptr, &status) != 0)
|
||||
{
|
||||
__origin_override(err, "END");
|
||||
err->flags |= status.flags;
|
||||
return status.flags;
|
||||
}
|
||||
if (ptr->size == 0)
|
||||
{
|
||||
__origin_override(err, "END");
|
||||
err->flags |= ERR_SIZE_ZERO;
|
||||
return status.flags;
|
||||
}
|
||||
return (size_t)(ptr->size - 1);
|
||||
}
|
||||
|
||||
String
|
||||
vec_string_front(const vec_string* ptr, err_t* err)
|
||||
{
|
||||
err_t status = ERR_T_INIT;
|
||||
String tmp = STR_INIT;
|
||||
if (__null_check(ptr, &status) != 0)
|
||||
{
|
||||
__origin_override(err, "FRONT");
|
||||
err->flags |= status.flags;
|
||||
return tmp;
|
||||
}
|
||||
if (vec_string_at(ptr, 0, err) == nullptr)
|
||||
{
|
||||
err->flags |= ERR_OUT_OF_BOUNDS;
|
||||
return tmp;
|
||||
}
|
||||
return *vec_string_at(ptr, 0, err);
|
||||
}
|
||||
|
||||
String
|
||||
vec_string_back(const vec_string* ptr, err_t* err)
|
||||
{
|
||||
err_t status = ERR_T_INIT;
|
||||
if (__null_check(ptr, &status) != 0)
|
||||
{
|
||||
__origin_override(err, "BACK");
|
||||
err->flags |= status.flags;
|
||||
return (String)STR_INIT;
|
||||
}
|
||||
if (vec_string_at(ptr, 0, err) == nullptr)
|
||||
{
|
||||
err->flags |= ERR_OUT_OF_BOUNDS;
|
||||
return (String)STR_INIT;
|
||||
}
|
||||
return *vec_string_at(ptr, ptr->size - 1, err);
|
||||
}
|
||||
|
||||
size_t
|
||||
vec_string_empty(const vec_string* ptr, err_t* err)
|
||||
{
|
||||
err_t status = ERR_T_INIT;
|
||||
if (__null_check(ptr, &status) != 0)
|
||||
{
|
||||
__origin_override(err, "EMPTY");
|
||||
err->flags |= status.flags;
|
||||
return status.flags;
|
||||
}
|
||||
if (ptr->size == 0)
|
||||
{
|
||||
return ptr->size;
|
||||
}
|
||||
return status.flags;
|
||||
}
|
||||
|
||||
__attribute__((overloadable)) void
|
||||
vec_string_erase(vec_string* ptr, const size_t iter, err_t* err)
|
||||
{
|
||||
err_t status = ERR_T_INIT;
|
||||
if (__null_check(ptr, &status) != 0)
|
||||
{
|
||||
__origin_override(err, "ERASE");
|
||||
err->flags |= status.flags;
|
||||
return;
|
||||
}
|
||||
if (iter >= ptr->size)
|
||||
{
|
||||
return;
|
||||
}
|
||||
memmove(&ptr->array[iter], &ptr->array[iter + 1],
|
||||
(ptr->size - iter - 1) * sizeof(String));
|
||||
ptr->array[ptr->size - 1] = (String)STR_INIT;
|
||||
ptr->size--;
|
||||
return;
|
||||
}
|
||||
|
||||
__attribute__((overloadable)) void
|
||||
vec_string_erase(vec_string* ptr, const size_t iter_start,
|
||||
const size_t iter_end, err_t* err)
|
||||
{
|
||||
err_t status = ERR_T_INIT;
|
||||
if (__null_check(ptr, &status) != 0)
|
||||
{
|
||||
__origin_override(err, "ERASE");
|
||||
err->flags |= status.flags;
|
||||
return;
|
||||
}
|
||||
|
||||
if (ptr->size < iter_end || iter_end <= iter_start)
|
||||
{
|
||||
__origin_override(err, "ERASE");
|
||||
err->flags |= ERR_OUT_OF_BOUNDS;
|
||||
return;
|
||||
}
|
||||
size_t diff = iter_end - iter_start;
|
||||
memmove(&ptr->array[iter_start], &ptr->array[iter_end],
|
||||
(ptr->size - iter_end) * sizeof(String));
|
||||
memset(&ptr->array[ptr->size - diff], 0, sizeof(String) * diff);
|
||||
ptr->size -= diff;
|
||||
return;
|
||||
}
|
||||
|
||||
__attribute__((overloadable)) void
|
||||
vec_string_resize(vec_string* ptr, const size_t size, err_t* err)
|
||||
{
|
||||
err_t status = ERR_T_INIT;
|
||||
__null_check(ptr, &status);
|
||||
if ((status.flags & ERR_VEC_NULL) != 0)
|
||||
{
|
||||
__origin_override(err, "RESIZE");
|
||||
err->flags |= ERR_VEC_NULL;
|
||||
return;
|
||||
}
|
||||
|
||||
if (ptr->size == size)
|
||||
{
|
||||
__origin_override(err, "RESIZE");
|
||||
err->flags |= ERR_OUT_OF_BOUNDS;
|
||||
return;
|
||||
}
|
||||
|
||||
else if (size > ptr->max_size)
|
||||
{
|
||||
__origin_override(err, "RESIZE");
|
||||
err->flags |= ERR_SIZE_OVERFLOW;
|
||||
return;
|
||||
}
|
||||
|
||||
else if ((status.flags & ERR_BUF_NULL) != 0 || ptr->size == 0)
|
||||
{
|
||||
size_t max = ptr->max_size;
|
||||
err_t verr = ERR_T_INIT;
|
||||
vec_string_reserve(ptr, size, &verr);
|
||||
if (verr.flags != 0)
|
||||
{
|
||||
__origin_override(err, "RESIZE");
|
||||
err->flags |= verr.flags;
|
||||
return;
|
||||
}
|
||||
if (ptr->capacity != size)
|
||||
{
|
||||
__origin_override(err, "RESIZE");
|
||||
err->flags |= ERR_ALLOC_FAIL;
|
||||
return;
|
||||
}
|
||||
for (size_t i = 0; i < size; i++)
|
||||
{
|
||||
ptr->array[i] = (String)STR_INIT;
|
||||
}
|
||||
ptr->max_size = max;
|
||||
ptr->size = size;
|
||||
return;
|
||||
}
|
||||
else if (size > ptr->capacity)
|
||||
{
|
||||
size_t tmpcp = ptr->capacity;
|
||||
size_t tmpmx = ptr->max_size;
|
||||
err_t verr = ERR_T_INIT;
|
||||
while (size > tmpcp)
|
||||
{
|
||||
tmpcp *= 2;
|
||||
}
|
||||
if (tmpcp > ptr->max_size)
|
||||
{
|
||||
tmpcp = size;
|
||||
}
|
||||
vec_string_reserve(ptr, tmpcp, &verr);
|
||||
if (verr.flags != 0)
|
||||
{
|
||||
__origin_override(err, "RESIZE");
|
||||
err->flags |= verr.flags;
|
||||
return;
|
||||
}
|
||||
if (ptr->capacity != tmpcp)
|
||||
{
|
||||
__origin_override(err, "RESIZE");
|
||||
err->flags |= ERR_ALLOC_FAIL;
|
||||
return;
|
||||
}
|
||||
ptr->max_size = tmpmx;
|
||||
}
|
||||
if (size < ptr->size)
|
||||
{
|
||||
for (size_t i = size; i < ptr->size; i++)
|
||||
{
|
||||
ptr->array[i] = (String)STR_INIT;
|
||||
}
|
||||
}
|
||||
if (ptr->size < size && size <= ptr->capacity)
|
||||
{
|
||||
for (size_t i = ptr->size; i < size; i++)
|
||||
{
|
||||
ptr->array[i] = (String)STR_INIT;
|
||||
}
|
||||
}
|
||||
ptr->size = size;
|
||||
return;
|
||||
}
|
||||
|
||||
__attribute__((overloadable)) void
|
||||
vec_string_resize(vec_string* ptr, const size_t size, const String val,
|
||||
err_t* err)
|
||||
{
|
||||
err_t status = ERR_T_INIT;
|
||||
__null_check(ptr, &status);
|
||||
if ((status.flags & ERR_VEC_NULL) != 0)
|
||||
{
|
||||
__origin_override(err, "RESIZE");
|
||||
err->flags |= ERR_VEC_NULL;
|
||||
return;
|
||||
}
|
||||
if (ptr->size == size)
|
||||
{
|
||||
__origin_override(err, "RESIZE");
|
||||
err->flags |= ERR_OUT_OF_BOUNDS;
|
||||
return;
|
||||
}
|
||||
|
||||
else if (size > ptr->max_size)
|
||||
{
|
||||
__origin_override(err, "RESIZE");
|
||||
err->flags |= ERR_SIZE_OVERFLOW;
|
||||
return;
|
||||
}
|
||||
|
||||
else if ((status.flags & ERR_BUF_NULL) != 0 || ptr->size == 0)
|
||||
{
|
||||
size_t max = ptr->max_size;
|
||||
err_t verr = ERR_T_INIT;
|
||||
vec_string_reserve(ptr, size, &verr);
|
||||
if (verr.flags != 0)
|
||||
{
|
||||
__origin_override(err, "RESIZE");
|
||||
err->flags |= verr.flags;
|
||||
return;
|
||||
}
|
||||
if (ptr->capacity != size)
|
||||
{
|
||||
__origin_override(err, "RESIZE");
|
||||
err->flags |= ERR_ALLOC_FAIL;
|
||||
return;
|
||||
}
|
||||
for (size_t i = 0; i < size; i++)
|
||||
{
|
||||
ptr->array[i] = val;
|
||||
}
|
||||
ptr->max_size = max;
|
||||
ptr->size = size;
|
||||
return;
|
||||
}
|
||||
else if (size > ptr->capacity)
|
||||
{
|
||||
size_t tmpcp = ptr->capacity;
|
||||
size_t tmpmx = ptr->max_size;
|
||||
err_t verr = ERR_T_INIT;
|
||||
while (size > tmpcp)
|
||||
{
|
||||
tmpcp *= 2;
|
||||
}
|
||||
if (tmpcp > ptr->max_size)
|
||||
{
|
||||
tmpcp = size;
|
||||
}
|
||||
vec_string_reserve(ptr, tmpcp, &verr);
|
||||
if (verr.flags != 0)
|
||||
{
|
||||
__origin_override(err, "RESIZE");
|
||||
err->flags |= verr.flags;
|
||||
return;
|
||||
}
|
||||
ptr->max_size = tmpmx;
|
||||
}
|
||||
if (size < ptr->size)
|
||||
{
|
||||
for (size_t i = size; i < ptr->size; i++)
|
||||
{
|
||||
ptr->array[i] = val;
|
||||
}
|
||||
}
|
||||
if (ptr->size < size && size <= ptr->capacity)
|
||||
{
|
||||
for (size_t i = ptr->size; i < size; i++)
|
||||
{
|
||||
ptr->array[i] = val;
|
||||
}
|
||||
}
|
||||
ptr->size = size;
|
||||
return;
|
||||
}
|
||||
|
||||
__attribute__((overloadable)) void
|
||||
vec_string_assign(vec_string* ptr, const vec_string* iterator,
|
||||
const size_t iter_start, const size_t iter_end, err_t* err)
|
||||
{
|
||||
err_t status = ERR_T_INIT;
|
||||
if (__null_check(ptr, &status) != 0 ||
|
||||
__null_check(iterator, &status) != 0)
|
||||
{
|
||||
__origin_override(err, "ASSIGN");
|
||||
err->flags |= status.flags;
|
||||
return;
|
||||
}
|
||||
if (ptr->array == iterator->array)
|
||||
{
|
||||
__origin_override(err, "ASSIGN");
|
||||
err->flags |= ERR_DOUBLE_BUF;
|
||||
return;
|
||||
}
|
||||
if (iterator->size < iter_end || iter_end <= iter_start)
|
||||
{
|
||||
__origin_override(err, "ASSIGN");
|
||||
err->flags |= ERR_OUT_OF_BOUNDS;
|
||||
return;
|
||||
}
|
||||
vec_string_erase(ptr, vec_string_begin(ptr, &status),
|
||||
vec_string_end(ptr, &status) + 1, &status);
|
||||
if (status.flags != 0)
|
||||
{
|
||||
__origin_override(err, "ASSIGN");
|
||||
err->flags |= status.flags;
|
||||
return;
|
||||
}
|
||||
vec_string_reserve(ptr, (iter_end - iter_start), &status);
|
||||
if (status.flags != 0)
|
||||
{
|
||||
__origin_override(err, "ASSIGN");
|
||||
err->flags |= status.flags;
|
||||
return;
|
||||
}
|
||||
for (size_t i = iter_start; i < iter_end; i++)
|
||||
{
|
||||
String* res = vec_string_at(iterator, i, &status);
|
||||
if (res == nullptr)
|
||||
{
|
||||
err->flags |= ERR_OUT_OF_BOUNDS;
|
||||
return;
|
||||
}
|
||||
vec_string_push_back(ptr, *res, &status);
|
||||
if (status.flags != 0)
|
||||
{
|
||||
__origin_override(err, "ASSIGN");
|
||||
err->flags |= status.flags;
|
||||
return;
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
__attribute__((overloadable)) void
|
||||
vec_string_assign(vec_string* ptr, const size_t amount, const String val,
|
||||
err_t* err)
|
||||
{
|
||||
err_t status = ERR_T_INIT;
|
||||
if (__null_check(ptr, &status) != 0)
|
||||
{
|
||||
__origin_override(err, "ASSIGN");
|
||||
err->flags |= status.flags;
|
||||
return;
|
||||
}
|
||||
if (amount == 0)
|
||||
{
|
||||
__origin_override(err, "ASSIGN");
|
||||
err->flags |= ERR_SIZE_ZERO;
|
||||
return;
|
||||
}
|
||||
vec_string_erase(ptr, vec_string_begin(ptr, &status),
|
||||
vec_string_end(ptr, &status) + 1, &status);
|
||||
if (status.flags != 0)
|
||||
{
|
||||
__origin_override(err, "ASSIGN");
|
||||
err->flags |= status.flags;
|
||||
return;
|
||||
}
|
||||
vec_string_reserve(ptr, amount, &status);
|
||||
if (status.flags != 0)
|
||||
{
|
||||
__origin_override(err, "ASSIGN");
|
||||
err->flags |= status.flags;
|
||||
return;
|
||||
}
|
||||
for (size_t i = 0; i < amount; i++)
|
||||
{
|
||||
vec_string_push_back(ptr, val, &status);
|
||||
if (status.flags != 0)
|
||||
{
|
||||
__origin_override(err, "ASSIGN");
|
||||
err->flags |= status.flags;
|
||||
return;
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
__attribute__((overloadable)) void
|
||||
vec_string_insert(vec_string* ptr, const size_t iter, const String val,
|
||||
err_t* err)
|
||||
{
|
||||
err_t status = ERR_T_INIT;
|
||||
__null_check(ptr, &status);
|
||||
if ((status.flags & ERR_VEC_NULL) != 0)
|
||||
{
|
||||
__origin_override(err, "INSERT");
|
||||
err->flags |= status.flags;
|
||||
return;
|
||||
}
|
||||
if ((status.flags & ERR_BUF_NULL) != 0)
|
||||
{
|
||||
String* res = malloc(1 * sizeof(String));
|
||||
if (res == nullptr)
|
||||
{
|
||||
__origin_override(err, "INSERT");
|
||||
err->flags |= ERR_BUF_NULL;
|
||||
return;
|
||||
}
|
||||
ptr->array = res;
|
||||
ptr->capacity = 1;
|
||||
ptr->array[0] = val;
|
||||
ptr->size = 1;
|
||||
return;
|
||||
}
|
||||
if (ptr->max_size < ptr->size + 1)
|
||||
{
|
||||
__origin_override(err, "INSERT");
|
||||
err->flags |= ERR_SIZE_OVERFLOW;
|
||||
return;
|
||||
}
|
||||
if (iter > ptr->size)
|
||||
{
|
||||
__origin_override(err, "INSERT");
|
||||
err->flags |= ERR_OUT_OF_BOUNDS;
|
||||
return;
|
||||
}
|
||||
|
||||
String empty = STR_INIT;
|
||||
vec_string_push_back(ptr, empty, &status);
|
||||
if (status.flags != 0)
|
||||
{
|
||||
__origin_override(err, "INSERT");
|
||||
err->flags |= status.flags;
|
||||
return;
|
||||
}
|
||||
for (size_t i = ptr->size - 1; i > iter; i--)
|
||||
{
|
||||
ptr->array[i] = ptr->array[i - 1];
|
||||
}
|
||||
ptr->array[iter] = val;
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
__attribute__((overloadable)) void
|
||||
vec_string_insert(vec_string* ptr, const size_t iter, const size_t amount,
|
||||
const String val, err_t* err)
|
||||
{
|
||||
err_t status = ERR_T_INIT;
|
||||
__null_check(ptr, &status);
|
||||
if ((status.flags & (ERR_VEC_NULL | ERR_BUF_NULL)) != 0)
|
||||
{
|
||||
__origin_override(err, "INSERT");
|
||||
err->flags |= status.flags;
|
||||
return;
|
||||
}
|
||||
if (iter > ptr->size)
|
||||
{
|
||||
__origin_override(err, "INSERT");
|
||||
err->flags |= ERR_OUT_OF_BOUNDS;
|
||||
return;
|
||||
}
|
||||
if (amount == 0)
|
||||
{
|
||||
__origin_override(err, "INSERT");
|
||||
err->flags |= ERR_SIZE_ZERO;
|
||||
return;
|
||||
}
|
||||
for (size_t i = iter; i < iter + amount; i++)
|
||||
{
|
||||
vec_string_insert(ptr, i, val, &status);
|
||||
if (status.flags != 0)
|
||||
{
|
||||
__origin_override(err, "INSERT");
|
||||
err->flags |= status.flags;
|
||||
return;
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
__attribute__((overloadable)) void
|
||||
vec_string_insert(vec_string* ptr, const vec_string* iterator,
|
||||
const size_t iter, const size_t iter_start,
|
||||
const size_t iter_end, err_t* err)
|
||||
{
|
||||
err_t status = ERR_T_INIT;
|
||||
__null_check(ptr, &status);
|
||||
__null_check(iterator, &status);
|
||||
if ((status.flags & (ERR_VEC_NULL | ERR_BUF_NULL)) != 0)
|
||||
{
|
||||
__origin_override(err, "INSERT");
|
||||
err->flags |= status.flags;
|
||||
return;
|
||||
}
|
||||
if (iter_end <= iter_start || iter_end > iterator->size ||
|
||||
iter > ptr->size)
|
||||
{
|
||||
__origin_override(err, "INSERT");
|
||||
err->flags |= ERR_OUT_OF_BOUNDS;
|
||||
return;
|
||||
}
|
||||
if (ptr->array == iterator->array)
|
||||
{
|
||||
__origin_override(err, "INSERT");
|
||||
err->flags |= ERR_DOUBLE_BUF;
|
||||
return;
|
||||
}
|
||||
for (size_t i = iter_start; i < iter_end; i++)
|
||||
{
|
||||
vec_string_insert(ptr, iter + (i - iter_start),
|
||||
iterator->array[i], &status);
|
||||
if (status.flags != 0)
|
||||
{
|
||||
__origin_override(err, "INSERT");
|
||||
err->flags |= status.flags;
|
||||
return;
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
+1
-1
@@ -36,7 +36,7 @@ vec_print_errs(const err_t err)
|
||||
}
|
||||
|
||||
void
|
||||
print_bits(unsigned int num)
|
||||
vec_print_bits(unsigned int num)
|
||||
{
|
||||
unsigned int total_bits = sizeof(num) * 8;
|
||||
|
||||
|
||||
Reference in New Issue
Block a user