--- a/src/list.c Thu Aug 29 20:48:15 2024 +0200
+++ b/src/list.c Thu Aug 29 21:30:52 2024 +0200
@@ -217,14 +217,6 @@
return -1;
}
-static int cx_emptyl_compare(
- __attribute__((__unused__)) struct cx_list_s const *list,
- struct cx_list_s const *other
-) {
- if (other->collection.size == 0) return 0;
- return -1;
-}
-
static bool cx_emptyl_iter_valid(__attribute__((__unused__)) void const *iter) {
return false;
}
@@ -252,7 +244,7 @@
cx_emptyl_at,
cx_emptyl_find_remove,
cx_emptyl_noop,
- cx_emptyl_compare,
+ NULL,
cx_emptyl_noop,
cx_emptyl_iterator,
};
@@ -276,6 +268,79 @@
// </editor-fold>
+#define invoke_list_func(name, list, ...) \
+ ((list)->climpl == NULL ? (list)->cl->name : (list)->climpl->name) \
+ (list, __VA_ARGS__)
+
+size_t cx_list_default_insert_array(
+ struct cx_list_s *list,
+ size_t index,
+ void const *data,
+ size_t n
+) {
+ size_t elem_size = list->collection.elem_size;
+ char const *src = data;
+ size_t i = 0;
+ for (; i < n; i++) {
+ if (0 != invoke_list_func(insert_element,
+ list, index + i, src + (i * elem_size))) {
+ return i;
+ }
+ }
+ return i;
+}
+
+void cx_list_default_sort(struct cx_list_s *list) {
+ size_t elem_size = list->collection.elem_size;
+ size_t list_size = list->collection.size;
+ void *tmp = malloc(elem_size * list_size);
+ if (tmp == NULL) abort();
+
+ // copy elements from source array
+ char *loc = tmp;
+ for (size_t i = 0; i < list_size; i++) {
+ void *src = invoke_list_func(at, list, i);
+ memcpy(loc, src, elem_size);
+ loc += elem_size;
+ }
+
+ // qsort
+ qsort(tmp, list_size, elem_size,
+ list->collection.cmpfunc);
+
+ // copy elements back
+ loc = tmp;
+ for (size_t i = 0; i < list_size; i++) {
+ void *dest = invoke_list_func(at, list, i);
+ memcpy(dest, loc, elem_size);
+ loc += elem_size;
+ }
+
+ free(tmp);
+}
+
+int cx_list_default_swap(struct cx_list_s *list, size_t i, size_t j) {
+ if (i == j) return 0;
+ if (i >= list->collection.size) return 1;
+ if (j >= list->collection.size) return 1;
+
+ size_t elem_size = list->collection.elem_size;
+
+ void *tmp = malloc(elem_size);
+ if (tmp == NULL) return 1;
+
+ void *ip = invoke_list_func(at, list, i);
+ void *jp = invoke_list_func(at, list, j);
+
+ memcpy(tmp, ip, elem_size);
+ memcpy(ip, jp, elem_size);
+ memcpy(jp, tmp, elem_size);
+
+ free(tmp);
+
+ return 0;
+}
+
void cxListDestroy(CxList *list) {
list->cl->destructor(list);
}
@@ -284,17 +349,25 @@
CxList const *list,
CxList const *other
) {
- if (
- // if one is storing pointers but the other is not
- (list->collection.store_pointer ^ other->collection.store_pointer) ||
+ bool cannot_optimize = false;
+
+ // if one is storing pointers but the other is not
+ cannot_optimize |= list->collection.store_pointer ^ other->collection.store_pointer;
+
+ // if one class is wrapped but the other is not
+ cannot_optimize |= (list->climpl == NULL) ^ (other->climpl == NULL);
- // if one class is wrapped but the other is not
- ((list->climpl == NULL) ^ (other->climpl == NULL)) ||
+ // if the compare functions do not match or both are NULL
+ if (!cannot_optimize) {
+ cx_compare_func list_cmp = (cx_compare_func) (list->climpl != NULL ?
+ list->climpl->compare : list->cl->compare);
+ cx_compare_func other_cmp = (cx_compare_func) (other->climpl != NULL ?
+ other->climpl->compare : other->cl->compare);
+ cannot_optimize |= list_cmp != other_cmp;
+ cannot_optimize |= list_cmp == NULL;
+ }
- // if the resolved compare functions are not the same
- ((list->climpl != NULL ? list->climpl->compare : list->cl->compare) !=
- (other->climpl != NULL ? other->climpl->compare : other->cl->compare))
- ) {
+ if (cannot_optimize) {
// lists are definitely different - cannot use internal compare function
if (list->collection.size == other->collection.size) {
CxIterator left = list->cl->iterator(list, 0, false);