dav: comparison ucx/list.c

-:1f40ca07ae1b
+:839fefbdedc7
 return cx_pl_cmpfunc_impl(left, right);
 }
 static void cx_pl_hack_cmpfunc(struct cx_list_s const *list) {
 // cast away const - this is the hacky thing
-struct cx_list_s *l = (struct cx_list_s *) list;
+struct cx_collection_s *l = (struct cx_collection_s*) &list->collection;
 cx_pl_cmpfunc_impl = l->cmpfunc;
 l->cmpfunc = cx_pl_cmpfunc;
 }
 static void cx_pl_unhack_cmpfunc(struct cx_list_s const *list) {
 // cast away const - this is the hacky thing
-struct cx_list_s *l = (struct cx_list_s *) list;
+struct cx_collection_s *l = (struct cx_collection_s*) &list->collection;
 l->cmpfunc = cx_pl_cmpfunc_impl;
 }
 static void cx_pl_destructor(struct cx_list_s *list) {
 list->climpl->destructor(list);
 ) {
 return list->climpl->insert_array(list, index, array, n);
 }
 static int cx_pl_insert_iter(
-struct cx_mut_iterator_s *iter,
+struct cx_iterator_s *iter,
 void const *elem,
 int prepend
 ) {
-struct cx_list_s *list = iter->src_handle;
+struct cx_list_s *list = iter->src_handle.m;
 return list->climpl->insert_iter(iter, &elem, prepend);
 }
 static int cx_pl_remove(
 struct cx_list_s *list,
 ) {
 void **ptr = list->climpl->at(list, index);
 return ptr == NULL ? NULL : *ptr;
 }
-static ssize_t cx_pl_find(
+static ssize_t cx_pl_find_remove(
-struct cx_list_s const *list,
+struct cx_list_s *list,
-void const *elem
+void const *elem,
+bool remove
 ) {
 cx_pl_hack_cmpfunc(list);
-ssize_t ret = list->climpl->find(list, &elem);
+ssize_t ret = list->climpl->find_remove(list, &elem, remove);
 cx_pl_unhack_cmpfunc(list);
 return ret;
 }
 static void cx_pl_sort(struct cx_list_s *list) {
 cx_pl_insert_iter,
 cx_pl_remove,
 cx_pl_clear,
 cx_pl_swap,
 cx_pl_at,
-cx_pl_find,
+cx_pl_find_remove,
 cx_pl_sort,
 cx_pl_compare,
 cx_pl_reverse,
 cx_pl_iterator,
 };
 void cxListStoreObjects(CxList *list) {
-list->store_pointer = false;
+list->collection.store_pointer = false;
 if (list->climpl != NULL) {
 list->cl = list->climpl;
 list->climpl = NULL;
 }
 }
 void cxListStorePointers(CxList *list) {
-list->item_size = sizeof(void *);
+list->collection.elem_size = sizeof(void *);
-list->store_pointer = true;
+list->collection.store_pointer = true;
 list->climpl = list->cl;
 list->cl = &cx_pointer_list_class;
 }
 // </editor-fold>
 __attribute__((__unused__)) size_t index
 ) {
 return NULL;
 }
-static ssize_t cx_emptyl_find(
+static ssize_t cx_emptyl_find_remove(
-__attribute__((__unused__)) struct cx_list_s const *list,
+__attribute__((__unused__)) struct cx_list_s *list,
-__attribute__((__unused__)) void const *elem
+__attribute__((__unused__)) void const *elem,
+__attribute__((__unused__)) bool remove
 ) {
 return -1;
 }
 static int cx_emptyl_compare(
 __attribute__((__unused__)) struct cx_list_s const *list,
 struct cx_list_s const *other
 ) {
-if (other->size == 0) return 0;
+if (other->collection.size == 0) return 0;
 return -1;
 }
 static bool cx_emptyl_iter_valid(__attribute__((__unused__)) void const *iter) {
 return false;
 struct cx_list_s const *list,
 size_t index,
 __attribute__((__unused__)) bool backwards
 ) {
 CxIterator iter = {0};
-iter.src_handle = list;
+iter.src_handle.c = list;
 iter.index = index;
 iter.base.valid = cx_emptyl_iter_valid;
 return iter;
 }
 NULL,
 NULL,
 cx_emptyl_noop,
 NULL,
 cx_emptyl_at,
-cx_emptyl_find,
+cx_emptyl_find_remove,
 cx_emptyl_noop,
 cx_emptyl_compare,
 cx_emptyl_noop,
 cx_emptyl_iterator,
 };
 CxList cx_empty_list = {
-NULL,
+{
 NULL,
-0,
+NULL,
 0,
-NULL,
+0,
 NULL,
 NULL,
-false,
+NULL,
+false
+},
 &cx_empty_list_class,
 NULL
 };
 CxList *const cxEmptyList = &cx_empty_list;
 CxList const *list,
 CxList const *other
 ) {
 if (
 // if one is storing pointers but the other is not
-(list->store_pointer ^ other->store_pointer) ||
+(list->collection.store_pointer ^ other->collection.store_pointer) ||
 // if one class is wrapped but the other is not
 ((list->climpl == NULL) ^ (other->climpl == 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))
 ) {
 // lists are definitely different - cannot use internal compare function
-if (list->size == other->size) {
+if (list->collection.size == other->collection.size) {
-CxIterator left = cxListIterator(list);
+CxIterator left = list->cl->iterator(list, 0, false);
-CxIterator right = cxListIterator(other);
+CxIterator right = other->cl->iterator(other, 0, false);
-for (size_t i = 0; i < list->size; i++) {
+for (size_t i = 0; i < list->collection.size; i++) {
 void *leftValue = cxIteratorCurrent(left);
 void *rightValue = cxIteratorCurrent(right);
-int d = list->cmpfunc(leftValue, rightValue);
+int d = list->collection.cmpfunc(leftValue, rightValue);
 if (d != 0) {
 return d;
 }
 cxIteratorNext(left);
 cxIteratorNext(right);
 }
 return 0;
 } else {
-return list->size < other->size ? -1 : 1;
+return list->collection.size < other->collection.size ? -1 : 1;
 }
 } else {
 // lists are compatible
 return list->cl->compare(list, other);
 }
 }
-CxMutIterator cxListMutIteratorAt(
+CxIterator cxListMutIteratorAt(
 CxList *list,
 size_t index
 ) {
 CxIterator it = list->cl->iterator(list, index, false);
 it.base.mutating = true;
+return it;
-// we know the iterators share the same memory layout
+}
-CxMutIterator iter;
-memcpy(&iter, &it, sizeof(CxMutIterator));
+CxIterator cxListMutBackwardsIteratorAt(
-return iter;
-}
-CxMutIterator cxListMutBackwardsIteratorAt(
 CxList *list,
 size_t index
 ) {
 CxIterator it = list->cl->iterator(list, index, true);
 it.base.mutating = true;
+return it;
-// we know the iterators share the same memory layout
+}
-CxMutIterator iter;
-memcpy(&iter, &it, sizeof(CxMutIterator));
-return iter;
-}

Mercurial > hg > dav / file comparison

comparison: ucx/list.c

ucx/list.c