dbutils: comparison ucx/cx/list.h

-:d33eaaec15da
+:287484519844
 CX_COLLECTION_BASE;
 /**
 * The list class definition.
 */
 const cx_list_class *cl;
-/**
-* The actual implementation in case the list class is delegating.
-*/
-const cx_list_class *climpl;
 };
 /**
 * The class definition for arbitrary lists.
 */
 *
 * Only use this function if you are creating your own list implementation.
 * The purpose of this function is to be called in the initialization code
 * of your list to set certain members correctly.
 *
-* This is particularly important when you want your list to support
+* This is particularly useful when you want your list to support
-* #CX_STORE_POINTERS as @p elem_size. This function will wrap the list
+* #CX_STORE_POINTERS as @p elem_size.
-* class accordingly and make sure that you can implement your list as if
-* it was only storing objects, and the wrapper will automatically enable
-* the feature of storing pointers.
 *
 * @par Example
 *
 * @code
 * CxList *myCustomListCreate(
 *         const CxAllocator *allocator,
-*         cx_compare_func comparator,
 *         size_t elem_size
 * ) {
 *     if (allocator == NULL) {
 *         allocator = cxDefaultAllocator;
 *     }
 *
-*     MyCustomList *list = cxCalloc(allocator, 1, sizeof(MyCustomList));
+*     MyCustomList *list = cxZalloc(allocator, sizeof(MyCustomList));
 *     if (list == NULL) return NULL;
 *
 *     // initialize
 *     cx_list_init((CxList*)list, &my_custom_list_class,
-*             allocator, comparator, elem_size);
+*             allocator, elem_size);
 *
 *     // ... some more custom stuff ...
 *
 *     return (CxList *) list;
 * }
 * @endcode
 *
 * @param list the list to initialize
 * @param cl the list class
 * @param allocator the allocator for the elements
-* @param comparator a compare function for the elements
 * @param elem_size the size of one element
 */
 cx_attr_nonnull_arg(1, 2, 3)
 CX_EXPORT void cx_list_init(struct cx_list_s *list,
 struct cx_list_class_s *cl, const struct cx_allocator_s *allocator,
-cx_compare_func comparator, size_t elem_size);
+size_t elem_size);
+/**
+* A @c cx_compare_func2 compatible wrapper for the compare functions of a list.
+*
+* @param left first element
+* @param right second element
+* @param list the list which is comparing the elements
+* @return the comparison result
+*/
+cx_attr_nonnull
+CX_EXPORT int cx_list_compare_wrapper(
+const void *left, const void *right, void *list);
 /**
 * Returns the number of elements currently stored in the list.
 *
 * @param list the list
 * @param clone_func the clone function for the elements
 * @param clone_allocator the allocator that is passed to the clone function
 * @param data optional additional data that is passed to the clone function
 * @retval zero when all elements were successfully cloned
 * @retval non-zero when an allocation error occurred
-* @see cxListCloneSimple()
+* @see cxListCloneShallow()
 */
 cx_attr_nonnull_arg(1, 2, 3)
 CX_EXPORT int cxListClone(CxList *dst, const CxList *src,
 cx_clone_func clone_func, const CxAllocator *clone_allocator, void *data);
 * @param clone_func the clone function for the elements
 * @param clone_allocator the allocator that is passed to the clone function
 * @param data optional additional data that is passed to the clone function
 * @retval zero when the elements were successfully cloned
 * @retval non-zero when an allocation error occurred
-* @see cxListDifferenceSimple()
+* @see cxListDifferenceShallow()
 */
 cx_attr_nonnull_arg(1, 2, 3, 4)
 CX_EXPORT int cxListDifference(CxList *dst,
 const CxList *minuend, const CxList *subtrahend,
 cx_clone_func clone_func, const CxAllocator *clone_allocator, void *data);
 * @param clone_func the clone function for the elements
 * @param clone_allocator the allocator that is passed to the clone function
 * @param data optional additional data that is passed to the clone function
 * @retval zero when the elements were successfully cloned
 * @retval non-zero when an allocation error occurred
-* @see cxListIntersectionSimple()
+* @see cxListIntersectionShallow()
 */
 cx_attr_nonnull_arg(1, 2, 3, 4)
 CX_EXPORT int cxListIntersection(CxList *dst, const CxList *src, const CxList *other,
 cx_clone_func clone_func, const CxAllocator *clone_allocator, void *data);
 * @param clone_func the clone function for the elements
 * @param clone_allocator the allocator that is passed to the clone function
 * @param data optional additional data that is passed to the clone function
 * @retval zero when the elements were successfully cloned
 * @retval non-zero when an allocation error occurred
-* @see cxListUnionSimple()
+* @see cxListUnionShallow()
 */
 cx_attr_nonnull_arg(1, 2, 3, 4)
 CX_EXPORT int cxListUnion(CxList *dst, const CxList *src, const CxList *other,
 cx_clone_func clone_func, const CxAllocator *clone_allocator, void *data);
 * @retval zero when all elements were successfully cloned
 * @retval non-zero when an allocation error occurred
 * @see cxListClone()
 */
 cx_attr_nonnull
-CX_EXPORT int cxListCloneSimple(CxList *dst, const CxList *src);
+CX_EXPORT int cxListCloneShallow(CxList *dst, const CxList *src);
 /**
 * Clones elements from a list only if they are not present in another list.
 *
 * This function uses the default allocator, if needed, and performs
 * @retval zero when the elements were successfully cloned
 * @retval non-zero when an allocation error occurred
 * @see cxListDifference()
 */
 cx_attr_nonnull
-CX_EXPORT int cxListDifferenceSimple(CxList *dst,
+CX_EXPORT int cxListDifferenceShallow(CxList *dst,
 const CxList *minuend, const CxList *subtrahend);
 /**
 * Clones elements from a list only if they are also present in another list.
 *
 * @retval zero when the elements were successfully cloned
 * @retval non-zero when an allocation error occurred
 * @see cxListIntersection()
 */
 cx_attr_nonnull
-CX_EXPORT int cxListIntersectionSimple(CxList *dst, const CxList *src, const CxList *other);
+CX_EXPORT int cxListIntersectionShallow(CxList *dst, const CxList *src, const CxList *other);
 /**
 * Performs a deep clone of one list into another, skipping duplicates.
 *
 * This function uses the default allocator, if needed, and performs
 * @retval zero when the elements were successfully cloned
 * @retval non-zero when an allocation error occurred
 * @see cxListUnion()
 */
 cx_attr_nonnull
-CX_EXPORT int cxListUnionSimple(CxList *dst, const CxList *src, const CxList *other);
+CX_EXPORT int cxListUnionShallow(CxList *dst, const CxList *src, const CxList *other);
 /**
 * Asks the list to reserve enough memory for a given total number of elements.
 *
 * List implementations are free to choose if reserving memory upfront makes

Mercurial > hg > dbutils / file comparison

comparison: ucx/cx/list.h

ucx/cx/list.h