ucx: comparison src/list.c

-:f549fd9fbd8f
+:54565fd74e74
 // <editor-fold desc="Store Pointers Functionality">
 static _Thread_local cx_compare_func cx_pl_cmpfunc_impl;
 static int cx_pl_cmpfunc(
-void const *l,
+const void *l,
-void const *r
+const void *r
 ) {
 void *const *lptr = l;
 void *const *rptr = r;
-void const *left = lptr == NULL ? NULL : *lptr;
+const void *left = lptr == NULL ? NULL : *lptr;
-void const *right = rptr == NULL ? NULL : *rptr;
+const void *right = rptr == NULL ? NULL : *rptr;
 return cx_pl_cmpfunc_impl(left, right);
 }
-static void cx_pl_hack_cmpfunc(struct cx_list_s const *list) {
+static void cx_pl_hack_cmpfunc(const struct cx_list_s *list) {
 // cast away const - this is the hacky thing
 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) {
+static void cx_pl_unhack_cmpfunc(const struct cx_list_s *list) {
 // cast away const - this is the hacky thing
 struct cx_collection_s *l = (struct cx_collection_s*) &list->collection;
 l->cmpfunc = cx_pl_cmpfunc_impl;
 }
 }
 static int cx_pl_insert_element(
 struct cx_list_s *list,
 size_t index,
-void const *element
+const void *element
 ) {
 return list->climpl->insert_element(list, index, &element);
 }
 static size_t cx_pl_insert_array(
 struct cx_list_s *list,
 size_t index,
-void const *array,
+const void *array,
 size_t n
 ) {
 return list->climpl->insert_array(list, index, array, n);
 }
 static size_t cx_pl_insert_sorted(
 struct cx_list_s *list,
-void const *array,
+const void *array,
 size_t n
 ) {
 cx_pl_hack_cmpfunc(list);
 size_t result = list->climpl->insert_sorted(list, array, n);
 cx_pl_unhack_cmpfunc(list);
 return result;
 }
 static int cx_pl_insert_iter(
 struct cx_iterator_s *iter,
-void const *elem,
+const void *elem,
 int prepend
 ) {
 struct cx_list_s *list = iter->src_handle.m;
 return list->climpl->insert_iter(iter, &elem, prepend);
 }
 ) {
 return list->climpl->swap(list, i, j);
 }
 static void *cx_pl_at(
-struct cx_list_s const *list,
+const struct cx_list_s *list,
 size_t index
 ) {
 void **ptr = list->climpl->at(list, index);
 return ptr == NULL ? NULL : *ptr;
 }
 static ssize_t cx_pl_find_remove(
 struct cx_list_s *list,
-void const *elem,
+const void *elem,
 bool remove
 ) {
 cx_pl_hack_cmpfunc(list);
 ssize_t ret = list->climpl->find_remove(list, &elem, remove);
 cx_pl_unhack_cmpfunc(list);
 list->climpl->sort(list);
 cx_pl_unhack_cmpfunc(list);
 }
 static int cx_pl_compare(
-struct cx_list_s const *list,
+const struct cx_list_s *list,
-struct cx_list_s const *other
+const struct cx_list_s *other
 ) {
 cx_pl_hack_cmpfunc(list);
 int ret = list->climpl->compare(list, other);
 cx_pl_unhack_cmpfunc(list);
 return ret;
 static void cx_pl_reverse(struct cx_list_s *list) {
 list->climpl->reverse(list);
 }
-static void *cx_pl_iter_current(void const *it) {
+static void *cx_pl_iter_current(const void *it) {
-struct cx_iterator_s const *iter = it;
+const struct cx_iterator_s *iter = it;
 void **ptr = iter->base.current_impl(it);
 return ptr == NULL ? NULL : *ptr;
 }
 static struct cx_iterator_s cx_pl_iterator(
-struct cx_list_s const *list,
+const struct cx_list_s *list,
 size_t index,
 bool backwards
 ) {
 struct cx_iterator_s iter = list->climpl->iterator(list, index, backwards);
 iter.base.current_impl = iter.base.current;
 static void cx_emptyl_noop(__attribute__((__unused__)) CxList *list) {
 // this is a noop, but MUST be implemented
 }
 static void *cx_emptyl_at(
-__attribute__((__unused__)) struct cx_list_s const *list,
+__attribute__((__unused__)) const struct cx_list_s *list,
 __attribute__((__unused__)) size_t index
 ) {
 return NULL;
 }
 static ssize_t cx_emptyl_find_remove(
 __attribute__((__unused__)) struct cx_list_s *list,
-__attribute__((__unused__)) void const *elem,
+__attribute__((__unused__)) const void *elem,
 __attribute__((__unused__)) bool remove
 ) {
 return -1;
 }
-static bool cx_emptyl_iter_valid(__attribute__((__unused__)) void const *iter) {
+static bool cx_emptyl_iter_valid(__attribute__((__unused__)) const void *iter) {
 return false;
 }
 static CxIterator cx_emptyl_iterator(
-struct cx_list_s const *list,
+const struct cx_list_s *list,
 size_t index,
 __attribute__((__unused__)) bool backwards
 ) {
 CxIterator iter = {0};
 iter.src_handle.c = list;
 (list, __VA_ARGS__)
 size_t cx_list_default_insert_array(
 struct cx_list_s *list,
 size_t index,
-void const *data,
+const void *data,
 size_t n
 ) {
 size_t elem_size = list->collection.elem_size;
-char const *src = data;
+const char *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;
 }
 size_t cx_list_default_insert_sorted(
 struct cx_list_s *list,
-void const *sorted_data,
+const void *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;
+const char *src = sorted_data;
 // track indices and number of inserted items
 size_t di = 0, si = 0, inserted = 0;
 // search the list for insertion points
 for (; di < list->collection.size; di++) {
-void const *list_elm = invoke_list_func(at, list, di);
+const void *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;
+const char *next = src;
 while (++si < n) {
 next += elem_size;
 // once we become larger than the list elem, break
 if (cmp(list_elm, next) <= 0) {
 break;
 void cxListDestroy(CxList *list) {
 list->cl->destructor(list);
 }
 int cxListCompare(
-CxList const *list,
+const CxList *list,
-CxList const *other
+const CxList *other
 ) {
 bool cannot_optimize = false;
 // if one is storing pointers but the other is not
 cannot_optimize |= list->collection.store_pointer ^ other->collection.store_pointer;

Mercurial > hg > ucx / file comparison

comparison: src/list.c

src/list.c