FEAT: Added assign and resize functions
API: Fixed CMAKELISTS.txt to work without the encapsulation as it will not work or be viable right now
This commit is contained in:
Andrew Haynes
+380
@@ -0,0 +1,380 @@
|
||||
#include "char.h"
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
/*
|
||||
* Andrew Haynes
|
||||
* dmm.dev@icloud.com
|
||||
* No LICENSE
|
||||
* Vector Library For C
|
||||
*/
|
||||
|
||||
/**
|
||||
* 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;
|
||||
}
|
||||
|
||||
__attribute__((overloadable)) Vec8_t
|
||||
resize(Vec8_t* vec, size_t size)
|
||||
{
|
||||
Vec8_t nvec = create(nullptr);
|
||||
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;
|
||||
}
|
||||
|
||||
__attribute__((overloadable)) Vec8_t
|
||||
resize(Vec8_t* vec, size_t size, char val)
|
||||
{
|
||||
Vec8_t nvec = create(nullptr);
|
||||
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;
|
||||
}
|
||||
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);
|
||||
|
||||
for (size_t i = ret; i < vec->size; i++)
|
||||
{
|
||||
if (at(vec, (int)i) >= 0)
|
||||
{
|
||||
vec->arr[i] = val;
|
||||
}
|
||||
}
|
||||
return *vec;
|
||||
}
|
||||
|
||||
__attribute__((overloadable)) Vec8_t
|
||||
assign(Vec8_t* vec, const Vec8_t* iterator, size_t iter_start, size_t iter_end)
|
||||
{
|
||||
Vec8_t ret = create(nullptr);
|
||||
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);
|
||||
for (size_t i = iter_start; i < iter_end; i++)
|
||||
{
|
||||
*vec = add_back(vec, at(iterator, (int)i));
|
||||
}
|
||||
return *vec;
|
||||
}
|
||||
|
||||
__attribute__((overloadable)) Vec8_t
|
||||
assign(Vec8_t* vec, const size_t amount, char val)
|
||||
{
|
||||
Vec8_t ret = create(nullptr);
|
||||
if (vec == nullptr || vec->arr == nullptr) return ret;
|
||||
vec = erase(vec, begin(vec), end(vec) + 1);
|
||||
*vec = reserve(vec, amount);
|
||||
for (int i = 0; i < amount; i++)
|
||||
{
|
||||
*vec = add_back(vec, val);
|
||||
}
|
||||
return *vec;
|
||||
}
|
||||
|
||||
/*
|
||||
* assign() Fills a vector with multiple values stored
|
||||
vector.assign(iterator start, iterator end);
|
||||
vector.assign(size_t amount, <type> value);
|
||||
|
||||
|
||||
* insert() Inserts a number of elements into a vector vector can have
|
||||
vector.insert(iterator position, <type> value);
|
||||
vector.insert(iterator position, size_t amount, <type> value);
|
||||
vector.insert(iterator position (vector to add to), iterator to add with
|
||||
(other vector) iterator start, iterator end);
|
||||
* */
|
||||
Reference in New Issue
Block a user