From 6e8385521643818a6a885ea86383df455c6b90db Mon Sep 17 00:00:00 2001 From: Mineplay Date: Thu, 24 Apr 2025 10:34:57 -0500 Subject: [PATCH 01/10] feat(dynamic array): added dynamic array datastructure with init and destroy function --- Include/Fledasty/Core/DynamicArray.h | 41 ++++++++++++++++ Src/Core/DynamicArray.c | 71 ++++++++++++++++++++++++++++ Src/Core/Queue.c | 2 +- Src/Core/Stack.c | 2 +- Tests/Main.c | 5 ++ 5 files changed, 119 insertions(+), 2 deletions(-) create mode 100644 Include/Fledasty/Core/DynamicArray.h create mode 100644 Src/Core/DynamicArray.c diff --git a/Include/Fledasty/Core/DynamicArray.h b/Include/Fledasty/Core/DynamicArray.h new file mode 100644 index 0000000..15549b5 --- /dev/null +++ b/Include/Fledasty/Core/DynamicArray.h @@ -0,0 +1,41 @@ +/* + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * ----------------------------------------------------------------------------- + * File: DynamicArray.h + * Description: + * This file contains the Dynamic Array structure and the functions for modifying it. + * It includes functions to append, Insert before, Insert after, Insert at index, + * Get, Remove element, Remove at index, Check if has element and Check if is empty. + * + * Author: Mineplay + * ----------------------------------------------------------------------------- + */ + #ifndef FLEDASTY_DYNAMIC_ARRAY + #define FLEDASTY_DYNAMIC_ARRAY + + #include + + #include "../Utils/Error.h" + +typedef struct { + size_t size, capacity; + + size_t element_byte_size; + unsigned char *buffer; +} FledastyDynamicArray; + +FledastyError fledasty_dynamic_array_initialize(FledastyDynamicArray *new_dynamic_array, void *values, const size_t values_size, const size_t element_byte_size); +FledastyError fledasty_dynamic_array_destroy(FledastyDynamicArray *current_dynamic_array); + + #endif \ No newline at end of file diff --git a/Src/Core/DynamicArray.c b/Src/Core/DynamicArray.c new file mode 100644 index 0000000..7d902f1 --- /dev/null +++ b/Src/Core/DynamicArray.c @@ -0,0 +1,71 @@ +/* + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * ----------------------------------------------------------------------------- + * File: DynamicArray.c + * Description: + * This file contains the functions for modifying the Dynamic Array. It includes + * functions to append, Insert before, Insert after, Insert at index, + * Get, Remove element, Remove at index, Check if has element and Check if is empty. + * + * Author: Mineplay + * ----------------------------------------------------------------------------- + */ +#include "../../Include/Fledasty/Core/DynamicArray.h" + +#include +#include +#include + +FledastyError fledasty_dynamic_array_initialize(FledastyDynamicArray *new_dynamic_array, void *values, const size_t values_size, const size_t element_byte_size) { + if (new_dynamic_array == NULL) { + return FLEDASTY_ERROR_INVALID_POINTER; + } + + new_dynamic_array->element_byte_size = element_byte_size; + if (values == NULL || values_size == 0) { + new_dynamic_array->size = 0; + new_dynamic_array->capacity = 10; + + new_dynamic_array->buffer = (unsigned char*)hallocy_malloc(new_dynamic_array->capacity * element_byte_size); + if (new_dynamic_array->buffer == NULL) { + return FLEDASTY_ERROR_FAILED_ALLOCATION; + } + } else { + new_dynamic_array->size = values_size; + new_dynamic_array->capacity = new_dynamic_array->size + new_dynamic_array->size; + + new_dynamic_array->buffer = (unsigned char*)hallocy_malloc(new_dynamic_array->capacity * element_byte_size); + if (new_dynamic_array->buffer == NULL) { + return FLEDASTY_ERROR_FAILED_ALLOCATION; + } + + hallocy_copy_memory(new_dynamic_array->buffer, values, values_size * element_byte_size); + } + + return FLEDASTY_ERROR_NONE; +} + +FledastyError fledasty_dynamic_array_destroy(FledastyDynamicArray *current_dynamic_array) { + if (current_dynamic_array == NULL) { + return FLEDASTY_ERROR_INVALID_POINTER; + } + + HallocyError result = hallocy_free(current_dynamic_array->buffer); + if (result != HALLOCY_ERROR_NONE) { + return FLEDASTY_ERROR_FAILED_ALLOCATION; + } + + current_dynamic_array->buffer = NULL; + return FLEDASTY_ERROR_NONE; +} \ No newline at end of file diff --git a/Src/Core/Queue.c b/Src/Core/Queue.c index f06898e..9b1be7c 100644 --- a/Src/Core/Queue.c +++ b/Src/Core/Queue.c @@ -43,7 +43,7 @@ FledastyError fledasty_queue_initialize(FledastyQueue *new_queue, void *values, } } else { new_queue->size = values_size; - new_queue->capacity = values_size + (values_size / 2); + new_queue->capacity = new_queue->size + new_queue->size; new_queue->buffer = (unsigned char*)hallocy_malloc(new_queue->capacity * element_byte_size); if (new_queue->buffer == NULL) { diff --git a/Src/Core/Stack.c b/Src/Core/Stack.c index b35b517..8988e58 100644 --- a/Src/Core/Stack.c +++ b/Src/Core/Stack.c @@ -42,7 +42,7 @@ FledastyError fledasty_stack_initialize(FledastyStack *new_stack, void *values, } } else { new_stack->size = values_size; - new_stack->capacity = values_size + (values_size / 2); + new_stack->capacity = new_stack->size + new_stack->size; new_stack->buffer = (unsigned char*)hallocy_malloc(new_stack->capacity * element_byte_size); if (new_stack->buffer == NULL) { diff --git a/Tests/Main.c b/Tests/Main.c index 383bf48..3a9a95c 100644 --- a/Tests/Main.c +++ b/Tests/Main.c @@ -22,6 +22,7 @@ #include #include #include +#include int main() { FledastyQueue test_queue; @@ -66,6 +67,10 @@ int main() { fledasty_stack_destroy(&test_stack); + FledastyDynamicArray test_dynamic_array; + fledasty_dynamic_array_initialize(&test_dynamic_array, (int[]){11, 12, 13, 14, 15}, 5, sizeof(int)); + + fledasty_dynamic_array_destroy(&test_dynamic_array); printf("Done\n"); return 0; } \ No newline at end of file -- 2.39.5 From a0ac7fb33236fb3d2a2fc78fc57769625134d5ee Mon Sep 17 00:00:00 2001 From: Mineplay Date: Thu, 24 Apr 2025 12:40:21 -0500 Subject: [PATCH 02/10] feat(dynamic array): implemented append function for dynamic array --- Include/Fledasty/Core/DynamicArray.h | 4 +++- Src/Core/DynamicArray.c | 16 ++++++++++++++++ Tests/Main.c | 3 +++ 3 files changed, 22 insertions(+), 1 deletion(-) diff --git a/Include/Fledasty/Core/DynamicArray.h b/Include/Fledasty/Core/DynamicArray.h index 15549b5..f4e4ec7 100644 --- a/Include/Fledasty/Core/DynamicArray.h +++ b/Include/Fledasty/Core/DynamicArray.h @@ -38,4 +38,6 @@ typedef struct { FledastyError fledasty_dynamic_array_initialize(FledastyDynamicArray *new_dynamic_array, void *values, const size_t values_size, const size_t element_byte_size); FledastyError fledasty_dynamic_array_destroy(FledastyDynamicArray *current_dynamic_array); - #endif \ No newline at end of file +FledastyError fledasty_dynamic_array_append(FledastyDynamicArray *current_dynamic_array, void *value); + +#endif \ No newline at end of file diff --git a/Src/Core/DynamicArray.c b/Src/Core/DynamicArray.c index 7d902f1..30361be 100644 --- a/Src/Core/DynamicArray.c +++ b/Src/Core/DynamicArray.c @@ -67,5 +67,21 @@ FledastyError fledasty_dynamic_array_destroy(FledastyDynamicArray *current_dynam } current_dynamic_array->buffer = NULL; + return FLEDASTY_ERROR_NONE; +} + +FledastyError fledasty_dynamic_array_append(FledastyDynamicArray *current_dynamic_array, void *value) { + if (current_dynamic_array == NULL || value == NULL) { + return FLEDASTY_ERROR_INVALID_POINTER; + } + + if (current_dynamic_array->size == current_dynamic_array->capacity) { + current_dynamic_array->capacity += current_dynamic_array->capacity; + current_dynamic_array->buffer = (unsigned char*)hallocy_realloc(current_dynamic_array->buffer, current_dynamic_array->capacity * current_dynamic_array->element_byte_size); + } + + hallocy_copy_memory(current_dynamic_array->buffer + (current_dynamic_array->size * current_dynamic_array->element_byte_size), value, current_dynamic_array->element_byte_size); + current_dynamic_array->size += 1; + return FLEDASTY_ERROR_NONE; } \ No newline at end of file diff --git a/Tests/Main.c b/Tests/Main.c index 3a9a95c..aa54c30 100644 --- a/Tests/Main.c +++ b/Tests/Main.c @@ -69,6 +69,9 @@ int main() { FledastyDynamicArray test_dynamic_array; fledasty_dynamic_array_initialize(&test_dynamic_array, (int[]){11, 12, 13, 14, 15}, 5, sizeof(int)); + for (int i = 0; i < 10; i += 1) { + fledasty_dynamic_array_append(&test_dynamic_array, &i); + } fledasty_dynamic_array_destroy(&test_dynamic_array); printf("Done\n"); -- 2.39.5 From 42f537ebd14d46a19bce8c037f512612e7f7f540 Mon Sep 17 00:00:00 2001 From: Mineplay Date: Thu, 24 Apr 2025 17:36:38 -0500 Subject: [PATCH 03/10] feat(dynamic array): implemented insert at index for dynamic array --- Include/Fledasty/Core/DynamicArray.h | 1 + Include/Fledasty/Utils/Error.h | 1 + Src/Core/DynamicArray.c | 21 +++++++++++++++++++++ Tests/Main.c | 3 +++ 4 files changed, 26 insertions(+) diff --git a/Include/Fledasty/Core/DynamicArray.h b/Include/Fledasty/Core/DynamicArray.h index f4e4ec7..668f5d5 100644 --- a/Include/Fledasty/Core/DynamicArray.h +++ b/Include/Fledasty/Core/DynamicArray.h @@ -39,5 +39,6 @@ FledastyError fledasty_dynamic_array_initialize(FledastyDynamicArray *new_dynami FledastyError fledasty_dynamic_array_destroy(FledastyDynamicArray *current_dynamic_array); FledastyError fledasty_dynamic_array_append(FledastyDynamicArray *current_dynamic_array, void *value); +FledastyError fledasty_dynamic_array_insert_at_index(FledastyDynamicArray *current_dynamic_array, const size_t index, void *value); #endif \ No newline at end of file diff --git a/Include/Fledasty/Utils/Error.h b/Include/Fledasty/Utils/Error.h index 91f5dc7..b1b545c 100644 --- a/Include/Fledasty/Utils/Error.h +++ b/Include/Fledasty/Utils/Error.h @@ -27,6 +27,7 @@ typedef enum { FLEDASTY_ERROR_NONE = 0, FLEDASTY_ERROR_FAILED_ALLOCATION = 1, FLEDASTY_ERROR_INVALID_POINTER = 2, + FLEDASTY_ERROR_INDEX_OUT_OF_RANGE = 3, } FledastyError; #endif \ No newline at end of file diff --git a/Src/Core/DynamicArray.c b/Src/Core/DynamicArray.c index 30361be..7b9e2cb 100644 --- a/Src/Core/DynamicArray.c +++ b/Src/Core/DynamicArray.c @@ -83,5 +83,26 @@ FledastyError fledasty_dynamic_array_append(FledastyDynamicArray *current_dynami hallocy_copy_memory(current_dynamic_array->buffer + (current_dynamic_array->size * current_dynamic_array->element_byte_size), value, current_dynamic_array->element_byte_size); current_dynamic_array->size += 1; + return FLEDASTY_ERROR_NONE; +} + +FledastyError fledasty_dynamic_array_insert_at_index(FledastyDynamicArray *current_dynamic_array, const size_t index, void *value) { + if (current_dynamic_array == NULL || value == NULL) { + return FLEDASTY_ERROR_FAILED_ALLOCATION; + } + + if (index >= current_dynamic_array->size) { + return FLEDASTY_ERROR_INDEX_OUT_OF_RANGE; + } + + if (current_dynamic_array->size == current_dynamic_array->capacity) { + current_dynamic_array->capacity += current_dynamic_array->capacity; + current_dynamic_array->buffer = (unsigned char*)hallocy_realloc(current_dynamic_array->buffer, current_dynamic_array->capacity * current_dynamic_array->element_byte_size); + } + + unsigned char *insert_pointer = current_dynamic_array->buffer + (index * current_dynamic_array->element_byte_size); + hallocy_move_memory(insert_pointer, insert_pointer + current_dynamic_array->element_byte_size, (current_dynamic_array->size - index) * current_dynamic_array->element_byte_size); + hallocy_copy_memory(insert_pointer, value, current_dynamic_array->element_byte_size); + return FLEDASTY_ERROR_NONE; } \ No newline at end of file diff --git a/Tests/Main.c b/Tests/Main.c index aa54c30..b3f1792 100644 --- a/Tests/Main.c +++ b/Tests/Main.c @@ -73,6 +73,9 @@ int main() { fledasty_dynamic_array_append(&test_dynamic_array, &i); } + int insert_value = 18; + fledasty_dynamic_array_insert_at_index(&test_dynamic_array, 1, &insert_value); + fledasty_dynamic_array_destroy(&test_dynamic_array); printf("Done\n"); return 0; -- 2.39.5 From 438875637193740786f279cfe08f8adedfedc2de Mon Sep 17 00:00:00 2001 From: Mineplay Date: Thu, 24 Apr 2025 17:51:53 -0500 Subject: [PATCH 04/10] feat(dynamic array): implemented get function for dynamic array --- Include/Fledasty/Core/DynamicArray.h | 2 ++ Src/Core/DynamicArray.c | 11 ++++++++++- Tests/Main.c | 13 +++++++++---- 3 files changed, 21 insertions(+), 5 deletions(-) diff --git a/Include/Fledasty/Core/DynamicArray.h b/Include/Fledasty/Core/DynamicArray.h index 668f5d5..ccac3cd 100644 --- a/Include/Fledasty/Core/DynamicArray.h +++ b/Include/Fledasty/Core/DynamicArray.h @@ -41,4 +41,6 @@ FledastyError fledasty_dynamic_array_destroy(FledastyDynamicArray *current_dynam FledastyError fledasty_dynamic_array_append(FledastyDynamicArray *current_dynamic_array, void *value); FledastyError fledasty_dynamic_array_insert_at_index(FledastyDynamicArray *current_dynamic_array, const size_t index, void *value); +void *fledasty_dynamic_array_get(FledastyDynamicArray *current_dynamic_array, const size_t index); + #endif \ No newline at end of file diff --git a/Src/Core/DynamicArray.c b/Src/Core/DynamicArray.c index 7b9e2cb..6c1ab8e 100644 --- a/Src/Core/DynamicArray.c +++ b/Src/Core/DynamicArray.c @@ -101,8 +101,17 @@ FledastyError fledasty_dynamic_array_insert_at_index(FledastyDynamicArray *curre } unsigned char *insert_pointer = current_dynamic_array->buffer + (index * current_dynamic_array->element_byte_size); - hallocy_move_memory(insert_pointer, insert_pointer + current_dynamic_array->element_byte_size, (current_dynamic_array->size - index) * current_dynamic_array->element_byte_size); + hallocy_move_memory(insert_pointer + current_dynamic_array->element_byte_size, insert_pointer, (current_dynamic_array->size - index) * current_dynamic_array->element_byte_size); hallocy_copy_memory(insert_pointer, value, current_dynamic_array->element_byte_size); + current_dynamic_array->size += 1; return FLEDASTY_ERROR_NONE; +} + +void *fledasty_dynamic_array_get(FledastyDynamicArray *current_dynamic_array, const size_t index) { + if (current_dynamic_array == NULL || index >= current_dynamic_array->size) { + return NULL; + } + + return current_dynamic_array->buffer + (index * current_dynamic_array->element_byte_size); } \ No newline at end of file diff --git a/Tests/Main.c b/Tests/Main.c index b3f1792..042beed 100644 --- a/Tests/Main.c +++ b/Tests/Main.c @@ -33,11 +33,11 @@ int main() { } int *peeked_queue_data = (int*)fledasty_queue_peek(&test_queue); - printf("Peeked: %d\n", *peeked_queue_data); + printf("Queue peeked: %d\n", *peeked_queue_data); for (int i = test_queue.size; i > 0; i -= 1) { int *popped_data = (int*)fledasty_queue_pop(&test_queue); - printf("Popped: %d\n", *popped_data); + printf("Queue popped: %d\n", *popped_data); } if (fledasty_queue_is_empty(&test_queue)) { @@ -54,11 +54,11 @@ int main() { } int *peeked_stack_data = (int*)fledasty_stack_peek(&test_stack); - printf("Peeked: %d\n", *peeked_stack_data); + printf("Stack peeked: %d\n", *peeked_stack_data); for (int i = test_stack.size; i > 0; i -= 1) { int *popped_data = (int*)fledasty_stack_pop(&test_stack); - printf("Popped: %d\n", *popped_data); + printf("Stack popped: %d\n", *popped_data); } if (fledasty_stack_is_empty(&test_stack)) { @@ -76,6 +76,11 @@ int main() { int insert_value = 18; fledasty_dynamic_array_insert_at_index(&test_dynamic_array, 1, &insert_value); + for (int i = 0; i < test_dynamic_array.size; i += 1) { + int *dynamic_array_data = (int*)fledasty_dynamic_array_get(&test_dynamic_array, i); + printf("Dynamic array get: %d\n", *dynamic_array_data); + } + fledasty_dynamic_array_destroy(&test_dynamic_array); printf("Done\n"); return 0; -- 2.39.5 From c51fd33b504655f82625a27f5d5b6d0d668bd860 Mon Sep 17 00:00:00 2001 From: Mineplay Date: Thu, 24 Apr 2025 18:26:33 -0500 Subject: [PATCH 05/10] feat(dynamic array): implemented insert before value function for dynamic array --- Include/Fledasty/Core/DynamicArray.h | 6 ++++- Include/Fledasty/Core/Queue.h | 3 ++- Include/Fledasty/Core/Stack.h | 3 ++- Include/Fledasty/Utils/Error.h | 1 + Src/Core/DynamicArray.c | 37 +++++++++++++++++++++++++++- Tests/Main.c | 8 ++++++ 6 files changed, 54 insertions(+), 4 deletions(-) diff --git a/Include/Fledasty/Core/DynamicArray.h b/Include/Fledasty/Core/DynamicArray.h index ccac3cd..e8e7ebc 100644 --- a/Include/Fledasty/Core/DynamicArray.h +++ b/Include/Fledasty/Core/DynamicArray.h @@ -25,6 +25,7 @@ #define FLEDASTY_DYNAMIC_ARRAY #include +#include #include "../Utils/Error.h" @@ -40,7 +41,10 @@ FledastyError fledasty_dynamic_array_destroy(FledastyDynamicArray *current_dynam FledastyError fledasty_dynamic_array_append(FledastyDynamicArray *current_dynamic_array, void *value); FledastyError fledasty_dynamic_array_insert_at_index(FledastyDynamicArray *current_dynamic_array, const size_t index, void *value); +FledastyError fledasty_dynamic_array_insert_before_value(FledastyDynamicArray *current_dynamic_array, void *before_value, void *value); -void *fledasty_dynamic_array_get(FledastyDynamicArray *current_dynamic_array, const size_t index); +void *fledasty_dynamic_array_get(const FledastyDynamicArray *current_dynamic_array, const size_t index); + +inline static bool fledasty_dynamic_array_is_empty(const FledastyDynamicArray *current_dynamic_array) { return current_dynamic_array->size == 0; } #endif \ No newline at end of file diff --git a/Include/Fledasty/Core/Queue.h b/Include/Fledasty/Core/Queue.h index 2775230..d4919a6 100644 --- a/Include/Fledasty/Core/Queue.h +++ b/Include/Fledasty/Core/Queue.h @@ -24,6 +24,7 @@ #define FLEDASTY_QUEUE #include +#include #include "../Utils/Error.h" @@ -42,6 +43,6 @@ FledastyError fledasty_queue_push(FledastyQueue *current_queue, void *value); void *fledasty_queue_peek(const FledastyQueue *current_queue); void *fledasty_queue_pop(FledastyQueue *current_queue); -static inline size_t fledasty_queue_is_empty(const FledastyQueue *current_queue) { return current_queue->size == 0; } +static inline bool fledasty_queue_is_empty(const FledastyQueue *current_queue) { return current_queue->size == 0; } #endif \ No newline at end of file diff --git a/Include/Fledasty/Core/Stack.h b/Include/Fledasty/Core/Stack.h index fc0d237..da54a65 100644 --- a/Include/Fledasty/Core/Stack.h +++ b/Include/Fledasty/Core/Stack.h @@ -24,6 +24,7 @@ #define FLEDASTY_STACK #include +#include #include "../Utils/Error.h" @@ -41,6 +42,6 @@ FledastyError fledasty_stack_push(FledastyStack *current_stack, void *value); void *fledasty_stack_peek(const FledastyStack *current_stack); void *fledasty_stack_pop(FledastyStack *current_stack); -static inline size_t fledasty_stack_is_empty(const FledastyStack *current_stack) { return current_stack->size == 0; } +static inline bool fledasty_stack_is_empty(const FledastyStack *current_stack) { return current_stack->size == 0; } #endif \ No newline at end of file diff --git a/Include/Fledasty/Utils/Error.h b/Include/Fledasty/Utils/Error.h index b1b545c..0e955ef 100644 --- a/Include/Fledasty/Utils/Error.h +++ b/Include/Fledasty/Utils/Error.h @@ -28,6 +28,7 @@ typedef enum { FLEDASTY_ERROR_FAILED_ALLOCATION = 1, FLEDASTY_ERROR_INVALID_POINTER = 2, FLEDASTY_ERROR_INDEX_OUT_OF_RANGE = 3, + FLEDASTY_ERROR_VALUE_NOT_FOUND = 4, } FledastyError; #endif \ No newline at end of file diff --git a/Src/Core/DynamicArray.c b/Src/Core/DynamicArray.c index 6c1ab8e..5fc324a 100644 --- a/Src/Core/DynamicArray.c +++ b/Src/Core/DynamicArray.c @@ -98,6 +98,10 @@ FledastyError fledasty_dynamic_array_insert_at_index(FledastyDynamicArray *curre if (current_dynamic_array->size == current_dynamic_array->capacity) { current_dynamic_array->capacity += current_dynamic_array->capacity; current_dynamic_array->buffer = (unsigned char*)hallocy_realloc(current_dynamic_array->buffer, current_dynamic_array->capacity * current_dynamic_array->element_byte_size); + + if (current_dynamic_array->buffer == NULL) { + return FLEDASTY_ERROR_FAILED_ALLOCATION; + } } unsigned char *insert_pointer = current_dynamic_array->buffer + (index * current_dynamic_array->element_byte_size); @@ -108,7 +112,38 @@ FledastyError fledasty_dynamic_array_insert_at_index(FledastyDynamicArray *curre return FLEDASTY_ERROR_NONE; } -void *fledasty_dynamic_array_get(FledastyDynamicArray *current_dynamic_array, const size_t index) { +FledastyError fledasty_dynamic_array_insert_before_value(FledastyDynamicArray *current_dynamic_array, void *before_value, void *value) { + if (current_dynamic_array == NULL || before_value == NULL || value == NULL) { + return FLEDASTY_ERROR_INVALID_POINTER; + } + + size_t byte_index = 0; + size_t byte_size = current_dynamic_array->size * current_dynamic_array->element_byte_size; + while (byte_index < byte_size && !hallocy_compare_memory(current_dynamic_array->buffer + byte_index, before_value, current_dynamic_array->element_byte_size)) { + byte_index += current_dynamic_array->element_byte_size; + } + + if (byte_index == byte_size) { + return FLEDASTY_ERROR_VALUE_NOT_FOUND; + } + + if (current_dynamic_array->size == current_dynamic_array->capacity) { + current_dynamic_array->capacity += current_dynamic_array->capacity; + current_dynamic_array->buffer = (unsigned char*)hallocy_realloc(current_dynamic_array->buffer, current_dynamic_array->capacity * current_dynamic_array->element_byte_size); + + if (current_dynamic_array->buffer == NULL) { + return FLEDASTY_ERROR_FAILED_ALLOCATION; + } + } + + hallocy_move_memory(current_dynamic_array->buffer + (byte_index + current_dynamic_array->element_byte_size), current_dynamic_array->buffer + byte_index, byte_size - byte_index); + hallocy_copy_memory(current_dynamic_array->buffer + byte_index, value, current_dynamic_array->element_byte_size); + current_dynamic_array->size += 1; + + return FLEDASTY_ERROR_NONE; +} + +void *fledasty_dynamic_array_get(const FledastyDynamicArray *current_dynamic_array, const size_t index) { if (current_dynamic_array == NULL || index >= current_dynamic_array->size) { return NULL; } diff --git a/Tests/Main.c b/Tests/Main.c index 042beed..d7e7da7 100644 --- a/Tests/Main.c +++ b/Tests/Main.c @@ -76,11 +76,19 @@ int main() { int insert_value = 18; fledasty_dynamic_array_insert_at_index(&test_dynamic_array, 1, &insert_value); + insert_value = 35; + int before_value = 11; + fledasty_dynamic_array_insert_before_value(&test_dynamic_array, &before_value, &insert_value); + for (int i = 0; i < test_dynamic_array.size; i += 1) { int *dynamic_array_data = (int*)fledasty_dynamic_array_get(&test_dynamic_array, i); printf("Dynamic array get: %d\n", *dynamic_array_data); } + if (fledasty_dynamic_array_is_empty(&test_dynamic_array)) { + printf("Dynamic array is empty\n"); + } + fledasty_dynamic_array_destroy(&test_dynamic_array); printf("Done\n"); return 0; -- 2.39.5 From d5ba0a07bccf9429004afbde5e26d7a60dabf824 Mon Sep 17 00:00:00 2001 From: Mineplay Date: Fri, 25 Apr 2025 04:34:01 -0500 Subject: [PATCH 06/10] feat(dynamic array): implemented insert after value function for dynamic array --- Include/Fledasty/Core/DynamicArray.h | 2 ++ Src/Core/DynamicArray.c | 32 ++++++++++++++++++++++++++++ Tests/Main.c | 7 ++++-- 3 files changed, 39 insertions(+), 2 deletions(-) diff --git a/Include/Fledasty/Core/DynamicArray.h b/Include/Fledasty/Core/DynamicArray.h index e8e7ebc..8f5028b 100644 --- a/Include/Fledasty/Core/DynamicArray.h +++ b/Include/Fledasty/Core/DynamicArray.h @@ -40,8 +40,10 @@ FledastyError fledasty_dynamic_array_initialize(FledastyDynamicArray *new_dynami FledastyError fledasty_dynamic_array_destroy(FledastyDynamicArray *current_dynamic_array); FledastyError fledasty_dynamic_array_append(FledastyDynamicArray *current_dynamic_array, void *value); + FledastyError fledasty_dynamic_array_insert_at_index(FledastyDynamicArray *current_dynamic_array, const size_t index, void *value); FledastyError fledasty_dynamic_array_insert_before_value(FledastyDynamicArray *current_dynamic_array, void *before_value, void *value); +FledastyError fledasty_dynamic_array_insert_after_value(FledastyDynamicArray *current_dynamic_array, void *after_value, void *value); void *fledasty_dynamic_array_get(const FledastyDynamicArray *current_dynamic_array, const size_t index); diff --git a/Src/Core/DynamicArray.c b/Src/Core/DynamicArray.c index 5fc324a..308d86c 100644 --- a/Src/Core/DynamicArray.c +++ b/Src/Core/DynamicArray.c @@ -143,6 +143,38 @@ FledastyError fledasty_dynamic_array_insert_before_value(FledastyDynamicArray *c return FLEDASTY_ERROR_NONE; } +FledastyError fledasty_dynamic_array_insert_after_value(FledastyDynamicArray *current_dynamic_array, void *after_value, void *value) { + if (current_dynamic_array == NULL || after_value == NULL || value == NULL) { + return FLEDASTY_ERROR_INVALID_POINTER; + } + + size_t byte_index = 0; + size_t byte_size = current_dynamic_array->size * current_dynamic_array->element_byte_size; + while (byte_index < byte_size && !hallocy_compare_memory(current_dynamic_array->buffer + byte_index, after_value, current_dynamic_array->element_byte_size)) { + byte_index += current_dynamic_array->element_byte_size; + } + + if (byte_index == byte_size) { + return FLEDASTY_ERROR_VALUE_NOT_FOUND; + } + + if (current_dynamic_array->size == current_dynamic_array->capacity) { + current_dynamic_array->capacity += current_dynamic_array->capacity; + current_dynamic_array->buffer = (unsigned char*)hallocy_realloc(current_dynamic_array->buffer, current_dynamic_array->capacity * current_dynamic_array->element_byte_size); + + if (current_dynamic_array->buffer == NULL) { + return FLEDASTY_ERROR_FAILED_ALLOCATION; + } + } + + byte_index += current_dynamic_array->element_byte_size; + hallocy_move_memory(current_dynamic_array->buffer + (byte_index + current_dynamic_array->element_byte_size), current_dynamic_array->buffer + byte_index, byte_size - byte_index); + hallocy_copy_memory(current_dynamic_array->buffer + byte_index, value, current_dynamic_array->element_byte_size); + current_dynamic_array->size += 1; + + return FLEDASTY_ERROR_NONE; +} + void *fledasty_dynamic_array_get(const FledastyDynamicArray *current_dynamic_array, const size_t index) { if (current_dynamic_array == NULL || index >= current_dynamic_array->size) { return NULL; diff --git a/Tests/Main.c b/Tests/Main.c index d7e7da7..b30b229 100644 --- a/Tests/Main.c +++ b/Tests/Main.c @@ -77,8 +77,11 @@ int main() { fledasty_dynamic_array_insert_at_index(&test_dynamic_array, 1, &insert_value); insert_value = 35; - int before_value = 11; - fledasty_dynamic_array_insert_before_value(&test_dynamic_array, &before_value, &insert_value); + int insert_at_value = 11; + fledasty_dynamic_array_insert_before_value(&test_dynamic_array, &insert_at_value, &insert_value); + insert_value = 90; + insert_at_value = 35; + fledasty_dynamic_array_insert_after_value(&test_dynamic_array, &insert_at_value, &insert_value); for (int i = 0; i < test_dynamic_array.size; i += 1) { int *dynamic_array_data = (int*)fledasty_dynamic_array_get(&test_dynamic_array, i); -- 2.39.5 From 57e61c403651d58e742d03e14e74f46b27ed26fd Mon Sep 17 00:00:00 2001 From: Mineplay Date: Fri, 25 Apr 2025 04:42:15 -0500 Subject: [PATCH 07/10] feat(dynamic array): implemented has value function for dynamic array --- Include/Fledasty/Core/DynamicArray.h | 1 + Src/Core/DynamicArray.c | 15 +++++++++++++++ Tests/Main.c | 4 ++++ 3 files changed, 20 insertions(+) diff --git a/Include/Fledasty/Core/DynamicArray.h b/Include/Fledasty/Core/DynamicArray.h index 8f5028b..ab1d35d 100644 --- a/Include/Fledasty/Core/DynamicArray.h +++ b/Include/Fledasty/Core/DynamicArray.h @@ -47,6 +47,7 @@ FledastyError fledasty_dynamic_array_insert_after_value(FledastyDynamicArray *cu void *fledasty_dynamic_array_get(const FledastyDynamicArray *current_dynamic_array, const size_t index); +bool fledasty_dynamic_array_has_value(const FledastyDynamicArray *current_dynamic_array, void *value); inline static bool fledasty_dynamic_array_is_empty(const FledastyDynamicArray *current_dynamic_array) { return current_dynamic_array->size == 0; } #endif \ No newline at end of file diff --git a/Src/Core/DynamicArray.c b/Src/Core/DynamicArray.c index 308d86c..028e8fa 100644 --- a/Src/Core/DynamicArray.c +++ b/Src/Core/DynamicArray.c @@ -26,6 +26,7 @@ #include #include #include +#include FledastyError fledasty_dynamic_array_initialize(FledastyDynamicArray *new_dynamic_array, void *values, const size_t values_size, const size_t element_byte_size) { if (new_dynamic_array == NULL) { @@ -181,4 +182,18 @@ void *fledasty_dynamic_array_get(const FledastyDynamicArray *current_dynamic_arr } return current_dynamic_array->buffer + (index * current_dynamic_array->element_byte_size); +} + +bool fledasty_dynamic_array_has_value(const FledastyDynamicArray *current_dynamic_array, void *value) { + if (current_dynamic_array == NULL) { + return false; + } + + for (size_t byte_index = 0; byte_index < current_dynamic_array->size * current_dynamic_array->element_byte_size; byte_index += current_dynamic_array->element_byte_size) { + if (hallocy_compare_memory(current_dynamic_array->buffer + byte_index, value, current_dynamic_array->element_byte_size)) { + return true; + } + } + + return false; } \ No newline at end of file diff --git a/Tests/Main.c b/Tests/Main.c index b30b229..b38895a 100644 --- a/Tests/Main.c +++ b/Tests/Main.c @@ -88,6 +88,10 @@ int main() { printf("Dynamic array get: %d\n", *dynamic_array_data); } + if (fledasty_dynamic_array_has_value(&test_dynamic_array, &insert_value)) { + printf("Dynamic array contains %d\n", insert_value); + } + if (fledasty_dynamic_array_is_empty(&test_dynamic_array)) { printf("Dynamic array is empty\n"); } -- 2.39.5 From 2c41786406e08fd51d549028f82a9b58a889d696 Mon Sep 17 00:00:00 2001 From: Mineplay Date: Fri, 25 Apr 2025 05:09:16 -0500 Subject: [PATCH 08/10] feat(dynamic array): implemented remove value --- Include/Fledasty/Core/DynamicArray.h | 2 ++ Src/Core/DynamicArray.c | 21 +++++++++++++++++++++ Tests/Main.c | 3 +++ 3 files changed, 26 insertions(+) diff --git a/Include/Fledasty/Core/DynamicArray.h b/Include/Fledasty/Core/DynamicArray.h index ab1d35d..5097f84 100644 --- a/Include/Fledasty/Core/DynamicArray.h +++ b/Include/Fledasty/Core/DynamicArray.h @@ -47,6 +47,8 @@ FledastyError fledasty_dynamic_array_insert_after_value(FledastyDynamicArray *cu void *fledasty_dynamic_array_get(const FledastyDynamicArray *current_dynamic_array, const size_t index); +FledastyError fledasty_dynamic_array_remove_value(FledastyDynamicArray *current_dynamic_array, void *value); + bool fledasty_dynamic_array_has_value(const FledastyDynamicArray *current_dynamic_array, void *value); inline static bool fledasty_dynamic_array_is_empty(const FledastyDynamicArray *current_dynamic_array) { return current_dynamic_array->size == 0; } diff --git a/Src/Core/DynamicArray.c b/Src/Core/DynamicArray.c index 028e8fa..17e188c 100644 --- a/Src/Core/DynamicArray.c +++ b/Src/Core/DynamicArray.c @@ -184,6 +184,27 @@ void *fledasty_dynamic_array_get(const FledastyDynamicArray *current_dynamic_arr return current_dynamic_array->buffer + (index * current_dynamic_array->element_byte_size); } +FledastyError fledasty_dynamic_array_remove_value(FledastyDynamicArray *current_dynamic_array, void *value) { + if (current_dynamic_array == NULL || value == NULL) { + return FLEDASTY_ERROR_INVALID_POINTER; + } + + size_t byte_index = 0; + size_t byte_size = current_dynamic_array->size * current_dynamic_array->element_byte_size; + while (byte_index < byte_size && !hallocy_compare_memory(current_dynamic_array->buffer + byte_index, value, current_dynamic_array->element_byte_size)) { + byte_index += current_dynamic_array->element_byte_size; + } + + if (byte_index == byte_size) { + return FLEDASTY_ERROR_VALUE_NOT_FOUND; + } + + hallocy_copy_memory(current_dynamic_array->buffer + byte_index, current_dynamic_array->buffer + (byte_index + current_dynamic_array->element_byte_size), byte_size - (byte_index + current_dynamic_array->element_byte_size)); + current_dynamic_array->size -= 1; + + return FLEDASTY_ERROR_NONE; +} + bool fledasty_dynamic_array_has_value(const FledastyDynamicArray *current_dynamic_array, void *value) { if (current_dynamic_array == NULL) { return false; diff --git a/Tests/Main.c b/Tests/Main.c index b38895a..5029906 100644 --- a/Tests/Main.c +++ b/Tests/Main.c @@ -83,6 +83,9 @@ int main() { insert_at_value = 35; fledasty_dynamic_array_insert_after_value(&test_dynamic_array, &insert_at_value, &insert_value); + int remove_value = 15; + fledasty_dynamic_array_remove_value(&test_dynamic_array, &remove_value); + for (int i = 0; i < test_dynamic_array.size; i += 1) { int *dynamic_array_data = (int*)fledasty_dynamic_array_get(&test_dynamic_array, i); printf("Dynamic array get: %d\n", *dynamic_array_data); -- 2.39.5 From 3ef5bddf9a0b05f195efd9884eb1072197cf47ce Mon Sep 17 00:00:00 2001 From: Mineplay Date: Fri, 25 Apr 2025 05:56:32 -0500 Subject: [PATCH 09/10] feat(dynamic array): implemented remove at index --- Include/Fledasty/Core/DynamicArray.h | 1 + Src/Core/DynamicArray.c | 16 ++++++++++++++++ Tests/Main.c | 1 + 3 files changed, 18 insertions(+) diff --git a/Include/Fledasty/Core/DynamicArray.h b/Include/Fledasty/Core/DynamicArray.h index 5097f84..b6f087e 100644 --- a/Include/Fledasty/Core/DynamicArray.h +++ b/Include/Fledasty/Core/DynamicArray.h @@ -47,6 +47,7 @@ FledastyError fledasty_dynamic_array_insert_after_value(FledastyDynamicArray *cu void *fledasty_dynamic_array_get(const FledastyDynamicArray *current_dynamic_array, const size_t index); +FledastyError fledasty_dynamic_array_remove_at_index(FledastyDynamicArray *current_dynamic_array, const size_t index); FledastyError fledasty_dynamic_array_remove_value(FledastyDynamicArray *current_dynamic_array, void *value); bool fledasty_dynamic_array_has_value(const FledastyDynamicArray *current_dynamic_array, void *value); diff --git a/Src/Core/DynamicArray.c b/Src/Core/DynamicArray.c index 17e188c..629ae31 100644 --- a/Src/Core/DynamicArray.c +++ b/Src/Core/DynamicArray.c @@ -184,6 +184,22 @@ void *fledasty_dynamic_array_get(const FledastyDynamicArray *current_dynamic_arr return current_dynamic_array->buffer + (index * current_dynamic_array->element_byte_size); } +FledastyError fledasty_dynamic_array_remove_at_index(FledastyDynamicArray *current_dynamic_array, const size_t index) { + if (current_dynamic_array == NULL) { + return FLEDASTY_ERROR_INVALID_POINTER; + } + + if (index >= current_dynamic_array->size) { + return FLEDASTY_ERROR_INDEX_OUT_OF_RANGE; + } + + void *index_pointer = current_dynamic_array->buffer + (index * current_dynamic_array->element_byte_size); + hallocy_copy_memory(index_pointer, index_pointer + current_dynamic_array->element_byte_size, (current_dynamic_array->size + index) * current_dynamic_array->element_byte_size); + current_dynamic_array->size -= 1; + + return FLEDASTY_ERROR_NONE; +} + FledastyError fledasty_dynamic_array_remove_value(FledastyDynamicArray *current_dynamic_array, void *value) { if (current_dynamic_array == NULL || value == NULL) { return FLEDASTY_ERROR_INVALID_POINTER; diff --git a/Tests/Main.c b/Tests/Main.c index 5029906..c9bb3fe 100644 --- a/Tests/Main.c +++ b/Tests/Main.c @@ -85,6 +85,7 @@ int main() { int remove_value = 15; fledasty_dynamic_array_remove_value(&test_dynamic_array, &remove_value); + fledasty_dynamic_array_remove_at_index(&test_dynamic_array, test_dynamic_array.size - 2); for (int i = 0; i < test_dynamic_array.size; i += 1) { int *dynamic_array_data = (int*)fledasty_dynamic_array_get(&test_dynamic_array, i); -- 2.39.5 From 54ddcc5442c96586d0a5e6c7c319ce4ad03f245c Mon Sep 17 00:00:00 2001 From: Mineplay Date: Fri, 25 Apr 2025 10:21:18 -0500 Subject: [PATCH 10/10] refactor(dynamic dashboard): removed uneeded include --- Src/Core/DynamicArray.c | 1 - 1 file changed, 1 deletion(-) diff --git a/Src/Core/DynamicArray.c b/Src/Core/DynamicArray.c index 629ae31..79dc033 100644 --- a/Src/Core/DynamicArray.c +++ b/Src/Core/DynamicArray.c @@ -26,7 +26,6 @@ #include #include #include -#include FledastyError fledasty_dynamic_array_initialize(FledastyDynamicArray *new_dynamic_array, void *values, const size_t values_size, const size_t element_byte_size) { if (new_dynamic_array == NULL) { -- 2.39.5