ucx: comparison src/array

-:f549fd9fbd8f
+:54565fd74e74
 enum cx_array_result cx_array_copy(
 void **target,
 size_t *size,
 size_t *capacity,
 size_t index,
-void const *src,
+const void *src,
 size_t elem_size,
 size_t elem_count,
 struct cx_array_reallocator_s *reallocator
 ) {
 // assert pointers
 enum cx_array_result cx_array_insert_sorted(
 void **target,
 size_t *size,
 size_t *capacity,
 cx_compare_func cmp_func,
-void const *sorted_data,
+const void *sorted_data,
 size_t elem_size,
 size_t elem_count,
 struct cx_array_reallocator_s *reallocator
 ) {
 // assert pointers
 size_t new_size = old_size + elem_count;
 *size = new_size;
 // declare the source and destination indices/pointers
 size_t si = 0, di = 0;
-char const *src = sorted_data;
+const char *src = sorted_data;
 char *dest = *target;
 // find the first insertion point
 di = cx_array_binary_search_sup(dest, old_size, elem_size, src, cmp_func);
 dest += di * elem_size;
 return CX_ARRAY_SUCCESS;
 }
 size_t cx_array_binary_search_inf(
-void const *arr,
+const void *arr,
 size_t size,
 size_t elem_size,
-void const *elem,
+const void *elem,
 cx_compare_func cmp_func
 ) {
 // special case: empty array
 if (size == 0) return 0;
 // declare a variable that will contain the compare results
 int result;
 // cast the array pointer to something we can use offsets with
-char const *array = arr;
+const char *array = arr;
 // check the first array element
 result = cmp_func(elem, array);
 if (result < 0) {
 return size;
 size_t right_index = size - 1;
 size_t pivot_index;
 while (left_index <= right_index) {
 pivot_index = left_index + (right_index - left_index) / 2;
-char const *arr_elem = array + pivot_index * elem_size;
+const char *arr_elem = array + pivot_index * elem_size;
 result = cmp_func(elem, arr_elem);
 if (result == 0) {
 // found it!
 return pivot_index;
 } else if (result < 0) {
 size_t capacity,
 size_t elem_size,
 struct cx_array_reallocator_s *alloc
 ) {
 // retrieve the pointer to the list allocator
-CxAllocator const *al = alloc->ptr1;
+const CxAllocator *al = alloc->ptr1;
 // use the list allocator to reallocate the memory
 return cxRealloc(al, array, capacity * elem_size);
 }
 }
 static size_t cx_arl_insert_array(
 struct cx_list_s *list,
 size_t index,
-void const *array,
+const void *array,
 size_t n
 ) {
 // out of bounds and special case check
 if (index > list->collection.size || n == 0) return 0;
 // get a correctly typed pointer to the list
 cx_array_list *arl = (cx_array_list *) list;
 // do we need to move some elements?
 if (index < list->collection.size) {
-char const *first_to_move = (char const *) arl->data;
+const char *first_to_move = (const char *) arl->data;
 first_to_move += index * list->collection.elem_size;
 size_t elems_to_move = list->collection.size - index;
 size_t start_of_moved = index + n;
 if (CX_ARRAY_SUCCESS != cx_array_copy(
 }
 }
 static size_t cx_arl_insert_sorted(
 struct cx_list_s *list,
-void const *sorted_data,
+const void *sorted_data,
 size_t n
 ) {
 // get a correctly typed pointer to the list
 cx_array_list *arl = (cx_array_list *) list;
 }
 static int cx_arl_insert_element(
 struct cx_list_s *list,
 size_t index,
-void const *element
+const void *element
 ) {
 return 1 != cx_arl_insert_array(list, index, element, 1);
 }
 static int cx_arl_insert_iter(
 struct cx_iterator_s *iter,
-void const *elem,
+const void *elem,
 int prepend
 ) {
 struct cx_list_s *list = iter->src_handle.m;
 if (iter->index < list->collection.size) {
 int result = cx_arl_insert_element(
 cx_array_swap(arl->data, list->collection.elem_size, i, j);
 return 0;
 }
 static void *cx_arl_at(
-struct cx_list_s const *list,
+const struct cx_list_s *list,
 size_t index
 ) {
 if (index < list->collection.size) {
-cx_array_list const *arl = (cx_array_list const *) list;
+const cx_array_list *arl = (const cx_array_list *) list;
 char *space = arl->data;
 return space + index * list->collection.elem_size;
 } else {
 return NULL;
 }
 }
 static ssize_t cx_arl_find_remove(
 struct cx_list_s *list,
-void const *elem,
+const void *elem,
 bool remove
 ) {
 assert(list->collection.cmpfunc != NULL);
 assert(list->collection.size < SIZE_MAX / 2);
-char *cur = ((cx_array_list const *) list)->data;
+char *cur = ((const cx_array_list *) list)->data;
 for (ssize_t i = 0; i < (ssize_t) list->collection.size; i++) {
 if (0 == list->collection.cmpfunc(elem, cur)) {
 if (remove) {
 if (0 == cx_arl_remove(list, i)) {
 list->collection.cmpfunc
 );
 }
 static int cx_arl_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
 ) {
 assert(list->collection.cmpfunc != NULL);
 if (list->collection.size == other->collection.size) {
-char const *left = ((cx_array_list const *) list)->data;
+const char *left = ((const cx_array_list *) list)->data;
-char const *right = ((cx_array_list const *) other)->data;
+const char *right = ((const cx_array_list *) other)->data;
 for (size_t i = 0; i < list->collection.size; i++) {
 int d = list->collection.cmpfunc(left, right);
 if (d != 0) {
 return d;
 }
 }
 }
 static void cx_arl_reverse(struct cx_list_s *list) {
 if (list->collection.size < 2) return;
-void *data = ((cx_array_list const *) list)->data;
+void *data = ((const cx_array_list *) list)->data;
 size_t half = list->collection.size / 2;
 for (size_t i = 0; i < half; i++) {
 cx_array_swap(data, list->collection.elem_size, i, list->collection.size - 1 - i);
 }
 }
-static bool cx_arl_iter_valid(void const *it) {
+static bool cx_arl_iter_valid(const void *it) {
-struct cx_iterator_s const *iter = it;
+const struct cx_iterator_s *iter = it;
-struct cx_list_s const *list = iter->src_handle.c;
+const struct cx_list_s *list = iter->src_handle.c;
 return iter->index < list->collection.size;
 }
-static void *cx_arl_iter_current(void const *it) {
+static void *cx_arl_iter_current(const void *it) {
-struct cx_iterator_s const *iter = it;
+const struct cx_iterator_s *iter = it;
 return iter->elem_handle;
 }
 static void cx_arl_iter_next(void *it) {
 struct cx_iterator_s *iter = it;
 cx_arl_remove(iter->src_handle.m, iter->index);
 } else {
 iter->index++;
 iter->elem_handle =
 ((char *) iter->elem_handle)
-+ ((struct cx_list_s const *) iter->src_handle.c)->collection.elem_size;
++ ((const struct cx_list_s *) iter->src_handle.c)->collection.elem_size;
 }
 }
 static void cx_arl_iter_prev(void *it) {
 struct cx_iterator_s *iter = it;
-cx_array_list const* list = iter->src_handle.c;
+const cx_array_list *list = iter->src_handle.c;
 if (iter->base.remove) {
 iter->base.remove = false;
 cx_arl_remove(iter->src_handle.m, iter->index);
 }
 iter->index--;
 }
 }
 static struct cx_iterator_s cx_arl_iterator(
-struct cx_list_s const *list,
+const struct cx_list_s *list,
 size_t index,
 bool backwards
 ) {
 struct cx_iterator_s iter;
 cx_arl_reverse,
 cx_arl_iterator,
 };
 CxList *cxArrayListCreate(
-CxAllocator const *allocator,
+const CxAllocator *allocator,
 cx_compare_func comparator,
 size_t elem_size,
 size_t initial_capacity
 ) {
 if (allocator == NULL) {

comparison: src/array_list.c

src/array_list.c

Mercurial > hg > ucx / file comparison

comparison: src/array_list.c

src/array_list.c