# HG changeset patch # User Mike Becker # Date 1650295581 -7200 # Node ID 4fbfac557df87d724e77d3a8d39a112f51c89a69 # Parent 08539b8273fab8e917ec48328b62b3f0694c467b #179 improve API for list content destruction diff -r 08539b8273fa -r 4fbfac557df8 src/cx/allocator.h --- a/src/cx/allocator.h Mon Apr 18 16:56:29 2022 +0200 +++ b/src/cx/allocator.h Mon Apr 18 17:26:21 2022 +0200 @@ -117,6 +117,57 @@ typedef void (*cx_destructor_func)(void *memory) __attribute__((__nonnull__)); /** + * Function pointer type for destructor functions. + * + * A destructor function deallocates possible contents and MAY free the memory + * pointed to by \p memory. Read the documentation of the respective function + * pointer to learn if a destructor SHALL, MAY, or MUST NOT free the memory in that + * particular implementation. + * + * @param data an optional pointer to custom data + * @param memory a pointer to the object to destruct + */ +typedef void (*cx_destructor_func2)( + void *data, + void *memory +) __attribute__((__nonnull__(2))); + +/** + * Structure holding an advanced destructor function and the desired payload. + * Invocations of func should use data as first argument. + */ +typedef struct { + /** + * A pointer to the data that SHALL be used to invoke func. + */ + void *data; + /** + * A pointer to the function to invoke. + */ + cx_destructor_func2 func; +} cx_advanced_destructor; + +/** + * Specifies the type of destructor to use. + */ +enum cx_destructor_type { + /** + * Do not use a destructor function. + */ + CX_DESTRUCTOR_NONE, + /** + * Use a simple destructor. + * @see cx_destructor_func + */ + CX_DESTRUCTOR_SIMPLE, + /** + * Use an advanced destructor. + * @see cx_advanced_destructor + */ + CX_DESTRUCTOR_ADVANCED +}; + +/** * Allocate \p n bytes of memory. * * @param allocator the allocator diff -r 08539b8273fa -r 4fbfac557df8 src/cx/linked_list.h --- a/src/cx/linked_list.h Mon Apr 18 16:56:29 2022 +0200 +++ b/src/cx/linked_list.h Mon Apr 18 17:26:21 2022 +0200 @@ -48,7 +48,7 @@ /** * Allocates a linked list for storing elements with \p item_size bytes each. * - * @remark Elements added to the list are copied, therefore a possible cx_list_s.content_destructor + * @remark Elements added to the list are copied, therefore a possible destructor * MUST NOT free the memory pointed to by its argument. * * @param allocator the allocator for allocating the list nodes @@ -67,7 +67,7 @@ * * If you want to store the elements directly in this list, use cxLinkedListCreate(). * - * @remark Since only pointers are stored in this list, a possible cx_list_s.content_destructor + * @remark Since only pointers are stored in this list, a possible destructor * MAY free the memory pointed to by its argument in order to prevent memory leaks. * * @param allocator the allocator for allocating the list nodes @@ -82,7 +82,7 @@ /** * Creates a linked list using the data from an array. * - * @remark Elements added to the list are copied, therefore a possible cx_list_s.content_destructor + * @remark Elements added to the list are copied, therefore a possible destructor * MUST NOT free the memory pointed to by its argument. * * @param allocator the allocator for allocating the list nodes diff -r 08539b8273fa -r 4fbfac557df8 src/cx/list.h --- a/src/cx/list.h Mon Apr 18 16:56:29 2022 +0200 +++ b/src/cx/list.h Mon Apr 18 17:26:21 2022 +0200 @@ -71,13 +71,6 @@ */ CxAllocator const *allocator; /** - * An optional destructor for the list contents. - * - * @attention Read the documentation of the particular list implementation - * whether this destructor shall only destroy the contents or also free the memory. - */ - cx_destructor_func content_destructor; - /** * The comparator function for the elements. */ CxListComparator cmpfunc; @@ -93,6 +86,30 @@ * The capacity of the list (maximum number of elements). */ size_t capacity; + union { + /** + * An optional simple destructor for the list contents that admits the free() interface. + * + * @remark Set content_destructor_type to #CX_DESTRUCTOR_SIMPLE. + * + * @attention Read the documentation of the particular list implementation + * whether this destructor shall only destroy the contents or also free the memory. + */ + cx_destructor_func simple_destructor; + /** + * An optional advanced destructor for the list contents providing additional data. + * + * @remark Set content_destructor_type to #CX_DESTRUCTOR_ADVANCED. + * + * @attention Read the documentation of the particular list implementation + * whether this destructor shall only destroy the contents or also free the memory. + */ + cx_advanced_destructor advanced_destructor; + }; + /** + * The type of destructor to use. + */ + enum cx_destructor_type content_destructor_type; }; /** @@ -389,19 +406,17 @@ } /** - * Calls the list's destructor function for every element. - * If CxList.autofree_content is \c true, the elements are automatically free'd - * unless the content destructor function did not already do that. - * Similarly, if CxList.autofree is \c true, the list structure is free'd, unless - * the list destructor function did not already do that. + * Deallocates the memory of the specified list structure. + * + * Also calls content a destructor function, depending on the configuration + * in CxList.content_destructor_type. * * This function itself is a destructor function for the CxList. * - * @param list the list which contents shall be destroyed - * @return \p list if the list structure has not been free'd during the process + * @param list the list which shall be destroyed */ __attribute__((__nonnull__)) -CxList *cxListDestroy(CxList *list); +void cxListDestroy(CxList *list); #ifdef __cplusplus } /* extern "C" */ diff -r 08539b8273fa -r 4fbfac557df8 src/linked_list.c --- a/src/linked_list.c Mon Apr 18 16:56:29 2022 +0200 +++ b/src/linked_list.c Mon Apr 18 17:26:21 2022 +0200 @@ -779,8 +779,7 @@ size_t item_size ) { cx_linked_list *list = cxCalloc(allocator, 1, sizeof(cx_linked_list)); - if (list == NULL) - return NULL; + if (list == NULL) return NULL; list->base.cl = &cx_linked_list_class; list->base.allocator = allocator; @@ -796,8 +795,7 @@ CxListComparator comparator ) { cx_linked_list *list = cxCalloc(allocator, 1, sizeof(cx_linked_list)); - if (list == NULL) - return NULL; + if (list == NULL) return NULL; list->base.cl = &cx_pointer_linked_list_class; list->base.allocator = allocator; diff -r 08539b8273fa -r 4fbfac557df8 src/list.c --- a/src/list.c Mon Apr 18 16:56:29 2022 +0200 +++ b/src/list.c Mon Apr 18 17:26:21 2022 +0200 @@ -28,14 +28,26 @@ #include "cx/list.h" -CxList *cxListDestroy(CxList *list) { - if (list->content_destructor != NULL) { - CxIterator iter = cxListBegin(list); - cx_foreach(void*, elem, iter) { - list->content_destructor(elem); +void cxListDestroy(CxList *list) { + switch (list->content_destructor_type) { + case CX_DESTRUCTOR_SIMPLE: { + CxIterator iter = cxListBegin(list); + cx_foreach(void*, elem, iter) { + list->simple_destructor(elem); + } + break; } + case CX_DESTRUCTOR_ADVANCED: { + CxIterator iter = cxListBegin(list); + cx_foreach(void*, elem, iter) { + list->advanced_destructor.func(list->advanced_destructor.data, elem); + } + break; + } + case CX_DESTRUCTOR_NONE: + break; // nothing } + list->cl->destructor(list); cxFree(list->allocator, list); - return NULL; } diff -r 08539b8273fa -r 4fbfac557df8 test/test_list.cpp --- a/test/test_list.cpp Mon Apr 18 16:56:29 2022 +0200 +++ b/test/test_list.cpp Mon Apr 18 17:26:21 2022 +0200 @@ -92,7 +92,10 @@ } template -static node_test_data create_nodes_test_data(InputIter begin, InputIter end) { +static node_test_data create_nodes_test_data( + InputIter begin, + InputIter end +) { if (begin == end) return node_test_data{nullptr}; node *first = new node; first->data = *begin; @@ -592,13 +595,17 @@ } void verifyCreate(CxList *list) const { + EXPECT_EQ(list->content_destructor_type, CX_DESTRUCTOR_NONE); EXPECT_EQ(list->size, 0); EXPECT_EQ(list->capacity, (size_t) -1); EXPECT_EQ(list->allocator, &testingAllocator); EXPECT_EQ(list->cmpfunc, cmp_int); } - void verifyAdd(CxList *list, bool write_through) { + void verifyAdd( + CxList *list, + bool write_through + ) { auto len = testdata_len; cx_for_n (i, len) EXPECT_EQ(cxListAdd(list, &testdata.data[i]), 0); EXPECT_EQ(list->size, len); @@ -741,7 +748,10 @@ } } - static void verifyCompare(CxList *left, CxList *right) { + static void verifyCompare( + CxList *left, + CxList *right + ) { EXPECT_EQ(cxListCompare(left, right), 0); int x = 42; cxListAdd(left, &x); @@ -757,7 +767,7 @@ ASSERT_EQ(left->size, right->size); EXPECT_LT(cxListCompare(left, right), 0); EXPECT_GT(cxListCompare(right, left), 0); - *(int*)cxListAt(left, 15) = 10; + *(int *) cxListAt(left, 15) = 10; EXPECT_EQ(cxListCompare(left, right), 0); } }; @@ -879,3 +889,35 @@ verifyCompare(left, right); } +TEST_F(PointerLinkedList, NoDestructor) { + void *item = cxMalloc(&testingAllocator, sizeof(int)); + auto list = cxPointerLinkedListCreate(cxDefaultAllocator, cmp_int); + cxListAdd(list, item); + ASSERT_FALSE(testingAllocator.verify()); + cxListDestroy(list); + EXPECT_FALSE(testingAllocator.verify()); + cxFree(&testingAllocator, item); + EXPECT_TRUE(testingAllocator.verify()); +} + +TEST_F(PointerLinkedList, SimpleDestructor) { + int item = 0; + auto list = cxPointerLinkedListCreate(cxDefaultAllocator, cmp_int); + list->content_destructor_type = CX_DESTRUCTOR_SIMPLE; + list->simple_destructor = [](void *elem) { *(int *) elem = 42; }; + cxListAdd(list, &item); + cxListDestroy(list); + EXPECT_EQ(item, 42); +} + +TEST_F(PointerLinkedList, AdvancedDestructor) { + void *item = cxMalloc(&testingAllocator, sizeof(int)); + auto list = cxPointerLinkedListCreate(cxDefaultAllocator, cmp_int); + list->content_destructor_type = CX_DESTRUCTOR_ADVANCED; + list->advanced_destructor.data = &testingAllocator; + list->advanced_destructor.func = (cx_destructor_func2) cxFree; + cxListAdd(list, item); + ASSERT_FALSE(testingAllocator.verify()); + cxListDestroy(list); + EXPECT_TRUE(testingAllocator.verify()); +}