ucx: comparison src/array

-:d0680a23d850
+:b09aae58bba4
 // HIGH LEVEL ARRAY LIST FUNCTIONS
 typedef struct {
 struct cx_list_s base;
 void *data;
+size_t capacity;
 struct cx_array_reallocator_s reallocator;
 } cx_array_list;
 static void *cx_arl_realloc(
 void *array,
 cx_array_list *arl = (cx_array_list *) list;
 // do we need to move some elements?
 if (index < list->size) {
 char const *first_to_move = (char const *) arl->data;
-first_to_move += index * list->itemsize;
+first_to_move += index * list->item_size;
 size_t elems_to_move = list->size - index;
 size_t start_of_moved = index + n;
 if (CX_ARRAY_COPY_SUCCESS != cx_array_copy(
 &arl->data,
 &list->size,
-&list->capacity,
+&arl->capacity,
 start_of_moved,
 first_to_move,
-list->itemsize,
+list->item_size,
 elems_to_move,
 &arl->reallocator
 )) {
 // if moving existing elems is unsuccessful, abort
 return 0;
 // place the new elements
 if (CX_ARRAY_COPY_SUCCESS == cx_array_copy(
 &arl->data,
 &list->size,
-&list->capacity,
+&arl->capacity,
 index,
 array,
-list->itemsize,
+list->item_size,
 n,
 &arl->reallocator
 )) {
 return n;
 } else {
 iter->index + 1 - prepend,
 elem
 );
 if (result == 0 && prepend != 0) {
 iter->index++;
-iter->elem_handle = ((char *) iter->elem_handle) + list->itemsize;
+iter->elem_handle = ((char *) iter->elem_handle) + list->item_size;
 }
 return result;
 } else {
 int result = cx_arl_insert_element(list, list->size, elem);
 iter->index = list->size;
 if (index >= list->size) {
 return 1;
 }
 // content destruction
-if (list->content_destructor_type != CX_DESTRUCTOR_NONE) {
+cx_invoke_destructor(list, ((char*)arl->data) + index * list->item_size);
-char *ptr = arl->data;
-ptr += index * list->itemsize;
-cx_list_invoke_destructor(list, ptr);
-}
 // short-circuit removal of last element
 if (index == list->size - 1) {
 list->size--;
 return 0;
 // just move the elements starting at index to the left
 int result = cx_array_copy(
 &arl->data,
 &list->size,
-&list->capacity,
+&arl->capacity,
 index,
-((char *) arl->data) + (index + 1) * list->itemsize,
+((char *) arl->data) + (index + 1) * list->item_size,
-list->itemsize,
+list->item_size,
 list->size - index - 1,
 &arl->reallocator
 );
 if (result == 0) {
 // decrease the size
 if (list->size == 0) return;
 cx_array_list *arl = (cx_array_list *) list;
 char *ptr = arl->data;
-switch (list->content_destructor_type) {
+if (list->simple_destructor) {
-case CX_DESTRUCTOR_SIMPLE: {
+for (size_t i = 0; i < list->size; i++) {
-for (size_t i = 0; i < list->size; i++) {
+cx_invoke_simple_destructor(list, ptr);
-cx_list_invoke_simple_destructor(list, ptr);
+ptr += list->item_size;
-ptr += list->itemsize;
+}
 }
-break;
+if (list->advanced_destructor) {
-}
+for (size_t i = 0; i < list->size; i++) {
-case CX_DESTRUCTOR_ADVANCED: {
+cx_invoke_advanced_destructor(list, ptr);
-for (size_t i = 0; i < list->size; i++) {
+ptr += list->item_size;
-cx_list_invoke_advanced_destructor(list, ptr);
+}
-ptr += list->itemsize;
+}
-}
-break;
+memset(arl->data, 0, list->size * list->item_size);
-}
-case CX_DESTRUCTOR_NONE:
-break; // nothing
-}
-memset(arl->data, 0, list->size * list->itemsize);
 list->size = 0;
 }
 static int cx_arl_swap(
 struct cx_list_s *list,
 size_t i,
 size_t j
 ) {
 if (i >= list->size || j >= list->size) return 1;
 cx_array_list *arl = (cx_array_list *) list;
-cx_array_swap(arl->data, list->itemsize, i, j);
+cx_array_swap(arl->data, list->item_size, i, j);
 return 0;
 }
 static void *cx_arl_at(
 struct cx_list_s const *list,
 size_t index
 ) {
 if (index < list->size) {
 cx_array_list const *arl = (cx_array_list const *) list;
 char *space = arl->data;
-return space + index * list->itemsize;
+return space + index * list->item_size;
 } else {
 return NULL;
 }
 }
 for (size_t i = 0; i < list->size; i++) {
 if (0 == list->cmpfunc(elem, cur)) {
 return i;
 }
-cur += list->itemsize;
+cur += list->item_size;
 }
 return list->size;
 }
 static void cx_arl_sort(struct cx_list_s *list) {
 assert(list->cmpfunc != NULL);
 qsort(((cx_array_list *) list)->data,
 list->size,
-list->itemsize,
+list->item_size,
 list->cmpfunc
 );
 }
 static int cx_arl_compare(
 for (size_t i = 0; i < list->size; i++) {
 int d = list->cmpfunc(left, right);
 if (d != 0) {
 return d;
 }
-left += list->itemsize;
+left += list->item_size;
-right += other->itemsize;
+right += other->item_size;
 }
 return 0;
 } else {
 return list->size < other->size ? -1 : 1;
 }
 static void cx_arl_reverse(struct cx_list_s *list) {
 if (list->size < 2) return;
 void *data = ((cx_array_list const *) list)->data;
 size_t half = list->size / 2;
 for (size_t i = 0; i < half; i++) {
-cx_array_swap(data, list->itemsize, i, list->size - 1 - i);
+cx_array_swap(data, list->item_size, i, list->size - 1 - i);
 }
 }
 static bool cx_arl_iter_valid(void const *it) {
 struct cx_iterator_s const *iter = it;
 } else {
 struct cx_iterator_s *iter = it;
 iter->index++;
 iter->elem_handle =
 ((char *) iter->elem_handle)
-+ ((struct cx_list_s const *) iter->src_handle)->itemsize;
++ ((struct cx_list_s const *) iter->src_handle)->item_size;
 }
 }
 static void cx_arl_iter_prev(void *it) {
 struct cx_iterator_base_s *itbase = it;
 cx_arl_remove(iter->src_handle, iter->index);
 }
 iter->index--;
 if (iter->index < list->base.size) {
 iter->elem_handle = ((char *) list->data)
-+ iter->index * list->base.itemsize;
++ iter->index * list->base.item_size;
 }
 }
 static bool cx_arl_iter_flag_rm(void *it) {
 struct cx_iterator_base_s *iter = it;
 cx_arl_iterator,
 };
 CxList *cxArrayListCreate(
 CxAllocator const *allocator,
-CxListComparator comparator,
+cx_compare_func comparator,
 size_t item_size,
 size_t initial_capacity
 ) {
 if (allocator == NULL) {
 allocator = cxDefaultAllocator;
 if (list == NULL) return NULL;
 list->base.cl = &cx_array_list_class;
 list->base.allocator = allocator;
 list->base.cmpfunc = comparator;
-list->base.capacity = initial_capacity;
+list->capacity = initial_capacity;
 if (item_size > 0) {
-list->base.itemsize = item_size;
+list->base.item_size = item_size;
 } else {
 item_size = sizeof(void*);
 cxListStorePointers((CxList *) list);
 }

comparison: src/array_list.c

src/array_list.c

Mercurial > hg > ucx / file comparison

comparison: src/array_list.c

src/array_list.c