# HG changeset patch # User Mike Becker # Date 1706216472 -3600 # Node ID 2be8fe3d5a2d439d0726285af5edc3ab638783ea # Parent 949908c97474e29e8939071c433dade3e4ef0b7e add cx_array_add() + fix type of cx_array_default_reallocator diff -r 949908c97474 -r 2be8fe3d5a2d CHANGELOG --- a/CHANGELOG Wed Jan 24 22:19:05 2024 +0100 +++ b/CHANGELOG Thu Jan 25 22:01:12 2024 +0100 @@ -2,6 +2,7 @@ ------------------------ * adds tree.h * adds cx_array_default_reallocator + * adds cx_array_add() * adds cx_linked_list_find_node() * adds cxListFindRemove() * adds cxBufferReset() diff -r 949908c97474 -r 2be8fe3d5a2d src/array_list.c --- a/src/array_list.c Wed Jan 24 22:19:05 2024 +0100 +++ b/src/array_list.c Thu Jan 25 22:01:12 2024 +0100 @@ -42,10 +42,12 @@ return realloc(array, capacity * elem_size); } -struct cx_array_reallocator_s cx_array_default_reallocator = { +struct cx_array_reallocator_s cx_array_default_reallocator_impl = { cx_array_default_realloc, NULL, NULL, 0, 0 }; +struct cx_array_reallocator_s *cx_array_default_reallocator = &cx_array_default_reallocator_impl; + // LOW LEVEL ARRAY LIST FUNCTIONS enum cx_array_copy_result cx_array_copy( diff -r 949908c97474 -r 2be8fe3d5a2d src/cx/array_list.h --- a/src/cx/array_list.h Wed Jan 24 22:19:05 2024 +0100 +++ b/src/cx/array_list.h Thu Jan 25 22:01:12 2024 +0100 @@ -96,7 +96,7 @@ /** * A default stdlib-based array reallocator. */ -extern struct cx_array_reallocator_s cx_array_default_reallocator; +extern struct cx_array_reallocator_s *cx_array_default_reallocator; /** * Return codes for cx_array_copy(). @@ -117,7 +117,7 @@ * capacity is used. * * If the capacity is insufficient to hold the new data, a reallocation - * attempt is made, unless the allocator is set to \c NULL, in which case + * attempt is made, unless the \p reallocator is set to \c NULL, in which case * this function ultimately returns a failure. * * @param target the target array @@ -143,6 +143,28 @@ struct cx_array_reallocator_s *reallocator ) __attribute__((__nonnull__(1, 2, 5))); +/** + * Adds an element to an array with the possibility of allocating more space. + * + * The element \p elem is added to the end of the \p target array which containing + * \p size elements, already. The \p capacity must not be \c NULL and point a + * variable holding the current maximum number of elements the array can hold. + * + * If the capacity is insufficient to hold the new element, and the optional + * \p reallocator is not \c NULL, an attempt increase the \p capacity is made + * and the new capacity is written back. + * + * @param target the target array + * @param size a pointer to the size of the target array + * @param capacity a pointer to the target array's capacity - must not be \c NULL + * @param elem_size the size of one element + * @param elem the element to add + * @param reallocator the array re-allocator to use, or \c NULL + * if re-allocation shall not happen + * @return zero on success, non-zero error code on failure + */ +#define cx_array_add(target, size, capacity, elem_size, elem, reallocator) \ + cx_array_copy((void**)(target), size, capacity, *(size), elem, elem_size, 1, reallocator) /** * Swaps two array elements. diff -r 949908c97474 -r 2be8fe3d5a2d tests/test_list.c --- a/tests/test_list.c Wed Jan 24 22:19:05 2024 +0100 +++ b/tests/test_list.c Thu Jan 25 22:01:12 2024 +0100 @@ -36,6 +36,68 @@ #include +CX_TEST(test_array_add) { + int stackspace[5] = {1,1,2,3,5}; + int *stackarray = stackspace; + size_t stackarray_size = 3; + size_t stackarray_capacity = 5; + int *heaparray = calloc(5, sizeof(int)); + heaparray[0] = 2; + heaparray[1] = 3; + heaparray[2] = 5; + heaparray[3] = 7; + heaparray[4] = 11; + size_t heaparray_size = 3; + size_t heaparray_capacity = 5; + int elem = 8, elem2 = 47; + enum cx_array_copy_result result; + CX_TEST_DO { + result = cx_array_add(&stackarray, &stackarray_size, &stackarray_capacity, sizeof(int), &elem, NULL); + CX_TEST_ASSERT(result == CX_ARRAY_COPY_SUCCESS); + CX_TEST_ASSERT(stackarray[0] == 1); + CX_TEST_ASSERT(stackarray[1] == 1); + CX_TEST_ASSERT(stackarray[2] == 2); + CX_TEST_ASSERT(stackarray[3] == 8); + CX_TEST_ASSERT(stackarray[4] == 5); + CX_TEST_ASSERT(stackarray_size == 4); + CX_TEST_ASSERT(stackarray_capacity == 5); + + stackarray_size = 5; + result = cx_array_add(&stackarray, &stackarray_size, &stackarray_capacity, sizeof(int), &elem2, NULL); + CX_TEST_ASSERT(result == CX_ARRAY_COPY_REALLOC_NOT_SUPPORTED); + CX_TEST_ASSERT(stackarray[0] == 1); + CX_TEST_ASSERT(stackarray[1] == 1); + CX_TEST_ASSERT(stackarray[2] == 2); + CX_TEST_ASSERT(stackarray[3] == 8); + CX_TEST_ASSERT(stackarray[4] == 5); + CX_TEST_ASSERT(stackarray_size == 5); + CX_TEST_ASSERT(stackarray_capacity == 5); + + result = cx_array_add(&heaparray, &heaparray_size, &heaparray_capacity, sizeof(int), &elem, cx_array_default_reallocator); + CX_TEST_ASSERT(result == CX_ARRAY_COPY_SUCCESS); + CX_TEST_ASSERT(heaparray[0] == 2); + CX_TEST_ASSERT(heaparray[1] == 3); + CX_TEST_ASSERT(heaparray[2] == 5); + CX_TEST_ASSERT(heaparray[3] == 8); + CX_TEST_ASSERT(heaparray[4] == 11); + CX_TEST_ASSERT(heaparray_size == 4); + CX_TEST_ASSERT(heaparray_capacity == 5); + + heaparray_size = 5; + result = cx_array_add(&heaparray, &heaparray_size, &heaparray_capacity, sizeof(int), &elem2, cx_array_default_reallocator); + CX_TEST_ASSERT(result == CX_ARRAY_COPY_SUCCESS); + CX_TEST_ASSERT(heaparray[0] == 2); + CX_TEST_ASSERT(heaparray[1] == 3); + CX_TEST_ASSERT(heaparray[2] == 5); + CX_TEST_ASSERT(heaparray[3] == 8); + CX_TEST_ASSERT(heaparray[4] == 11); + CX_TEST_ASSERT(heaparray[5] == 47); + CX_TEST_ASSERT(heaparray_size == 6); + CX_TEST_ASSERT(heaparray_capacity >= 6); + } + free(heaparray); +} + typedef struct node { struct node *next; struct node *prev; @@ -1344,6 +1406,8 @@ CxTestSuite *cx_test_suite_array_list(void) { CxTestSuite *suite = cx_test_suite_new("array_list"); + cx_test_register(suite, test_array_add); + cx_test_register(suite, test_list_arl_create); cx_test_register(suite, test_list_arl_create_simple); cx_test_register(suite, test_list_arl_create_simple_for_pointers);