diff --git a/Include/Fledasty/Core/DynamicArray.h b/Include/Fledasty/Core/DynamicArray.h new file mode 100644 index 0000000..b6f087e --- /dev/null +++ b/Include/Fledasty/Core/DynamicArray.h @@ -0,0 +1,56 @@ +/* + * 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 + + #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); + +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); + +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); +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 91f5dc7..0e955ef 100644 --- a/Include/Fledasty/Utils/Error.h +++ b/Include/Fledasty/Utils/Error.h @@ -27,6 +27,8 @@ typedef enum { FLEDASTY_ERROR_NONE = 0, 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 new file mode 100644 index 0000000..79dc033 --- /dev/null +++ b/Src/Core/DynamicArray.c @@ -0,0 +1,235 @@ +/* + * 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; +} + +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; +} + +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); + + 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); + 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; +} + +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; +} + +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; + } + + 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; + } + + 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; + } + + 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/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..c9bb3fe 100644 --- a/Tests/Main.c +++ b/Tests/Main.c @@ -22,6 +22,7 @@ #include #include #include +#include int main() { FledastyQueue test_queue; @@ -32,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)) { @@ -53,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)) { @@ -66,6 +67,40 @@ 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)); + for (int i = 0; i < 10; i += 1) { + fledasty_dynamic_array_append(&test_dynamic_array, &i); + } + + int insert_value = 18; + fledasty_dynamic_array_insert_at_index(&test_dynamic_array, 1, &insert_value); + + insert_value = 35; + 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); + + 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); + 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"); + } + + fledasty_dynamic_array_destroy(&test_dynamic_array); printf("Done\n"); return 0; } \ No newline at end of file