dav: comparison ucx/cx/linked

-:e77ccf1c4bb3
+:4d58cbcc9efa
 /**
 * Location of the payload (mandatory).
 */
 off_t loc_data;
 /**
+* Location of extra data (optional).
+* Negative when no extra data is requested.
+* @see cx_linked_list_extra_data()
+*/
+off_t loc_extra;
+/**
 * Additional bytes to allocate @em behind the payload (e.g. for metadata).
+* @see cx_linked_list_extra_data()
 */
 size_t extra_data_len;
 /**
 * Pointer to the first node.
 */
 /**
 * Allocates a linked list for storing elements with @p elem_size bytes each.
 *
 * If @p elem_size is #CX_STORE_POINTERS, the created list stores pointers instead of
 * copies of the added elements, and the compare function will be automatically set
-* to cx_cmp_ptr() if none is given.
+* to cx_cmp_ptr().
 *
 * @param allocator the allocator for allocating the list nodes
 * (if @c NULL, the cxDefaultAllocator will be used)
-* @param comparator the comparator for the elements
-* (if @c NULL, and the list is not storing pointers, sort and find
-* functions will not work)
 * @param elem_size the size of each element in bytes
 * @return the created list
 */
 cx_attr_nodiscard cx_attr_malloc cx_attr_dealloc(cxListFree, 1)
 CX_EXPORT CxList *cxLinkedListCreate(const CxAllocator *allocator,
-cx_compare_func comparator, size_t elem_size);
+size_t elem_size);
 /**
-* Allocates a linked list for storing elements with @p elem_size bytes each.
+* Instructs the linked list to reserve extra data in each node.
 *
-* The list will use cxDefaultAllocator and no comparator function. If you want
+* The extra data will be aligned and placed behind the element data.
-* to call functions that need a comparator, you must either set one immediately
+* The exact location in the node is stored in the @c loc_extra field
-* after list creation or use cxLinkedListCreate().
+* of the linked list.
 *
-* If @p elem_size is #CX_STORE_POINTERS, the created list stores pointers instead of
+* You should usually not use this function except when you are creating an
-* copies of the added elements, and the compare function will be automatically set
+* own linked-list implementation that is based on the UCX linked list and
-* to cx_cmp_ptr().
+* needs to store extra data in each node.
 *
-* @param elem_size (@c size_t) the size of each element in bytes
+* @param list the list (must be a linked list)
-* @return (@c CxList*) the created list
+* @param len the length of the extra data
 */
-#define cxLinkedListCreateSimple(elem_size) \
+cx_attr_nonnull
-cxLinkedListCreate(NULL, NULL, elem_size)
+CX_EXPORT void cx_linked_list_extra_data(cx_linked_list *list, size_t len);
 /**
 * Finds the node at a certain index.
 *
 * This function can be used to start at an arbitrary position within the list.
 * Finds the node containing an element within a linked list.
 *
 * @param start a pointer to the start node
 * @param loc_advance the location of the pointer to advance
 * @param loc_data the location of the @c data pointer within your node struct
-* @param cmp_func a compare function to compare @p elem against the node data
 * @param elem a pointer to the element to find
 * @param found_index an optional pointer where the index of the found node
 * (given that @p start has index 0) is stored
+* @param cmp_func a compare function to compare @p elem against the node data
 * @return a pointer to the found node or @c NULL if no matching node was found
 */
-cx_attr_nonnull_arg(1, 4, 5)
+cx_attr_nonnull_arg(1, 4, 6)
 CX_EXPORT void *cx_linked_list_find(const void *start, ptrdiff_t loc_advance,
-ptrdiff_t loc_data, cx_compare_func cmp_func, const void *elem,
+ptrdiff_t loc_data, const void *elem, size_t *found_index,
-size_t *found_index);
+cx_compare_func cmp_func);
+/**
+* Finds the node containing an element within a linked list.
+*
+* @param start a pointer to the start node
+* @param loc_advance the location of the pointer to advance
+* @param loc_data the location of the @c data pointer within your node struct
+* @param elem a pointer to the element to find
+* @param found_index an optional pointer where the index of the found node
+* (given that @p start has index 0) is stored
+* @param cmp_func a compare function to compare @p elem against the node data
+* @param context additional context for the compare function
+* @return a pointer to the found node or @c NULL if no matching node was found
+*/
+cx_attr_nonnull_arg(1, 4, 6)
+CX_EXPORT void *cx_linked_list_find_c(const void *start, ptrdiff_t loc_advance,
+ptrdiff_t loc_data, const void *elem, size_t *found_index,
+cx_compare_func2 cmp_func, void *context);
 /**
 * Finds the first node in a linked list.
 *
 * The function starts with the pointer denoted by @p node and traverses the list
 cx_attr_nonnull_arg(1, 5, 6) cx_attr_nodiscard
 CX_EXPORT void *cx_linked_list_insert_unique_chain(void **begin, void **end,
 ptrdiff_t loc_prev, ptrdiff_t loc_next, void *insert_begin, cx_compare_func cmp_func);
 /**
+* Inserts a node into a sorted linked list.
+* The new node must not be part of any list yet.
+*
+* If the list starting with the node pointed to by @p begin is not sorted
+* already, the behavior is undefined.
+*
+* @param begin a pointer to the beginning node pointer (required)
+* @param end a pointer to the end node pointer (if your list has one)
+* @param loc_prev the location of a @c prev pointer within your node struct (negative if your struct does not have one)
+* @param loc_next the location of a @c next pointer within your node struct (required)
+* @param new_node a pointer to the node that shall be inserted
+* @param cmp_func a compare function that will receive the node pointers
+* @param context context for the compare function
+*/
+cx_attr_nonnull_arg(1, 5, 6)
+CX_EXPORT void cx_linked_list_insert_sorted_c(void **begin, void **end,
+ptrdiff_t loc_prev, ptrdiff_t loc_next, void *new_node, cx_compare_func2 cmp_func, void *context);
+/**
+* Inserts a chain of nodes into a sorted linked list.
+* The chain must not be part of any list yet.
+*
+* If either the list starting with the node pointed to by @p begin or the list
+* starting with @p insert_begin is not sorted, the behavior is undefined.
+*
+* @attention In contrast to cx_linked_list_insert_chain(), the source chain
+* will be broken and inserted into the target list so that the resulting list
+* will be sorted according to @p cmp_func. That means each node in the source
+* chain may be re-linked with nodes from the target list.
+*
+* @param begin a pointer to the beginning node pointer (required)
+* @param end a pointer to the end node pointer (if your list has one)
+* @param loc_prev the location of a @c prev pointer within your node struct (negative if your struct does not have one)
+* @param loc_next the location of a @c next pointer within your node struct (required)
+* @param insert_begin a pointer to the first node of the chain that shall be inserted
+* @param cmp_func a compare function that will receive the node pointers
+* @param context context for the compare function
+*/
+cx_attr_nonnull_arg(1, 5, 6)
+CX_EXPORT void cx_linked_list_insert_sorted_chain_c(void **begin, void **end,
+ptrdiff_t loc_prev, ptrdiff_t loc_next, void *insert_begin, cx_compare_func2 cmp_func, void *context);
+/**
+* Inserts a node into a sorted linked list if no other node with the same value already exists.
+* The new node must not be part of any list yet.
+*
+* If the list starting with the node pointed to by @p begin is not sorted
+* already, the behavior is undefined.
+*
+* @param begin a pointer to the beginning node pointer (required)
+* @param end a pointer to the end node pointer (if your list has one)
+* @param loc_prev the location of a @c prev pointer within your node struct (negative if your struct does not have one)
+* @param loc_next the location of a @c next pointer within your node struct (required)
+* @param new_node a pointer to the node that shall be inserted
+* @param cmp_func a compare function that will receive the node pointers
+* @retval zero when the node was inserted
+* @retval non-zero when a node with the same value already exists
+*/
+cx_attr_nonnull_arg(1, 5, 6)
+CX_EXPORT int cx_linked_list_insert_unique_c(void **begin, void **end,
+ptrdiff_t loc_prev, ptrdiff_t loc_next, void *new_node, cx_compare_func2 cmp_func, void *context);
+/**
+* Inserts a chain of nodes into a sorted linked list, avoiding duplicates.
+* The chain must not be part of any list yet.
+*
+* If either the list starting with the node pointed to by @p begin or the list
+* starting with @p insert_begin is not sorted, the behavior is undefined.
+*
+* @attention In contrast to cx_linked_list_insert_sorted(), not all nodes of the
+* chain might be added. This function returns a new chain consisting of all the duplicates.
+*
+* @param begin a pointer to the beginning node pointer (required)
+* @param end a pointer to the end node pointer (if your list has one)
+* @param loc_prev the location of a @c prev pointer within your node struct (negative if your struct does not have one)
+* @param loc_next the location of a @c next pointer within your node struct (required)
+* @param insert_begin a pointer to the first node of the chain that shall be inserted
+* @param cmp_func a compare function that will receive the node pointers
+* @param context context for the compare function
+* @return a pointer to a new chain with all duplicates that were not inserted (or @c NULL when there were no duplicates)
+*/
+cx_attr_nonnull_arg(1, 5, 6) cx_attr_nodiscard
+CX_EXPORT void *cx_linked_list_insert_unique_chain_c(void **begin, void **end,
+ptrdiff_t loc_prev, ptrdiff_t loc_next, void *insert_begin, cx_compare_func2 cmp_func, void *context);
+/**
 * Removes a chain of nodes from the linked list.
 *
 * If one of the nodes to remove is the beginning (resp. end) node of the list, and if @p begin (resp. @p end)
 * addresses are provided, the pointers are adjusted accordingly.
 *
 CX_EXPORT size_t cx_linked_list_size(const void *node, ptrdiff_t loc_next);
 /**
 * Sorts a linked list based on a comparison function.
 *
-* This function can work with linked lists of the following structure:
-* @code
-* typedef struct node node;
-* struct node {
-*   node* prev;
-*   node* next;
-*   my_payload data;
-* }
-* @endcode
-*
 * @note This is a recursive function with at most logarithmic recursion depth.
 *
 * @param begin a pointer to the beginning node pointer (required)
 * @param end a pointer to the end node pointer (optional)
 * @param loc_prev the location of a @c prev pointer within your node struct (negative if not present)
 * @param cmp_func the compare function defining the sort order
 */
 cx_attr_nonnull_arg(1, 6)
 CX_EXPORT void cx_linked_list_sort(void **begin, void **end,
 ptrdiff_t loc_prev, ptrdiff_t loc_next, ptrdiff_t loc_data, cx_compare_func cmp_func);
+/**
+* Sorts a linked list based on a comparison function.
+*
+* @note This is a recursive function with at most logarithmic recursion depth.
+*
+* @param begin a pointer to the beginning node pointer (required)
+* @param end a pointer to the end node pointer (optional)
+* @param loc_prev the location of a @c prev pointer within your node struct (negative if not present)
+* @param loc_next the location of a @c next pointer within your node struct (required)
+* @param loc_data the location of the @c data pointer within your node struct
+* @param cmp_func the compare function defining the sort order
+* @param context additional context for the compare function
+*/
+cx_attr_nonnull_arg(1, 6)
+CX_EXPORT void cx_linked_list_sort_c(void **begin, void **end,
+ptrdiff_t loc_prev, ptrdiff_t loc_next, ptrdiff_t loc_data, cx_compare_func2 cmp_func, void *context);
 /**
 * Compares two lists element wise.
 *
 cx_attr_nonnull_arg(5)
 CX_EXPORT int cx_linked_list_compare(const void *begin_left, const void *begin_right,
 ptrdiff_t loc_advance, ptrdiff_t loc_data, cx_compare_func cmp_func);
 /**
+* Compares two lists element wise.
+*
+* @attention Both lists must have the same structure.
+*
+* @param begin_left the beginning of the left list (@c NULL denotes an empty list)
+* @param begin_right the beginning of the right list  (@c NULL denotes an empty list)
+* @param loc_advance the location of the pointer to advance
+* @param loc_data the location of the @c data pointer within your node struct
+* @param cmp_func the function to compare the elements
+* @return the first non-zero result of invoking @p cmp_func or: negative if the left list is smaller than the
+* right list, positive if the left list is larger than the right list, zero if both lists are equal.
+*/
+cx_attr_nonnull_arg(5)
+CX_EXPORT int cx_linked_list_compare_c(const void *begin_left, const void *begin_right,
+ptrdiff_t loc_advance, ptrdiff_t loc_data, cx_compare_func2 cmp_func, void *context);
+/**
 * Reverses the order of the nodes in a linked list.
 *
 * @param begin a pointer to the beginning node pointer (required)
 * @param end a pointer to the end node pointer (optional)
 * @param loc_prev the location of a @c prev pointer within your node struct (negative if your struct does not have one)

comparison: ucx/cx/linked_list.h

ucx/cx/linked_list.h

Mercurial > hg > dav / file comparison

comparison: ucx/cx/linked_list.h

ucx/cx/linked_list.h