ucx: comparison src/list.c

-:f4ce7df9cff0
+:608b14deea18
 size_t cx_list_default_insert_sorted(
 struct cx_list_s *list,
 void const *sorted_data,
 size_t n
 ) {
+// corner case
+if (n == 0) return 0;
 size_t elem_size = list->collection.elem_size;
 cx_compare_func cmp = list->collection.cmpfunc;
 char const *src = sorted_data;
-size_t r = cx_list_default_insert_array(list, 0, src, n);
+// track indices and number of inserted items
-cx_list_default_sort(list);
+size_t di = 0, si = 0, inserted = 0;
-return r;
+// search the list for insertion points
+for (; di < list->collection.size; di++) {
+void const *list_elm = invoke_list_func(at, list, di);
+// compare current list element with first source element
+// if less or equal, skip
+if (cmp(list_elm, src) <= 0) {
+continue;
+}
+// determine number of consecutive elements that can be inserted
+size_t ins = 1;
+char const *next = src;
+while (++si < n) {
+next += elem_size;
+// once we become larger than the list elem, break
+if (cmp(list_elm, next) <= 0) {
+break;
+}
+// otherwise, we can insert one more
+ins++;
+}
+// insert the elements at location si
+if (ins == 1) {
+if (0 != invoke_list_func(insert_element,
+list, di, src))
+return inserted;
+} else {
+size_t r = invoke_list_func(insert_array, list, di, src, ins);
+if (r < ins) return inserted + r;
+}
+inserted += ins;
+di += ins;
+// everything inserted?
+if (inserted == n) return inserted;
+src = next;
+}
+// insert remaining items
+if (si < n) {
+inserted += invoke_list_func(insert_array, list, di, src, n - si);
+}
+return inserted;
 }
 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;

Mercurial > hg > ucx / file comparison

comparison: src/list.c

src/list.c