1.1 --- a/src/array_list.c Thu May 23 20:31:37 2024 +0200
1.2 +++ b/src/array_list.c Thu May 23 20:43:04 2024 +0200
1.3 @@ -191,21 +191,21 @@
1.4
1.5 char *ptr = arl->data;
1.6
1.7 - if (list->base.simple_destructor) {
1.8 - for (size_t i = 0; i < list->base.size; i++) {
1.9 + if (list->collection.simple_destructor) {
1.10 + for (size_t i = 0; i < list->collection.size; i++) {
1.11 cx_invoke_simple_destructor(list, ptr);
1.12 - ptr += list->base.elem_size;
1.13 + ptr += list->collection.elem_size;
1.14 }
1.15 }
1.16 - if (list->base.advanced_destructor) {
1.17 - for (size_t i = 0; i < list->base.size; i++) {
1.18 + if (list->collection.advanced_destructor) {
1.19 + for (size_t i = 0; i < list->collection.size; i++) {
1.20 cx_invoke_advanced_destructor(list, ptr);
1.21 - ptr += list->base.elem_size;
1.22 + ptr += list->collection.elem_size;
1.23 }
1.24 }
1.25
1.26 - cxFree(list->base.allocator, arl->data);
1.27 - cxFree(list->base.allocator, list);
1.28 + cxFree(list->collection.allocator, arl->data);
1.29 + cxFree(list->collection.allocator, list);
1.30 }
1.31
1.32 static size_t cx_arl_insert_array(
1.33 @@ -215,25 +215,25 @@
1.34 size_t n
1.35 ) {
1.36 // out of bounds and special case check
1.37 - if (index > list->base.size || n == 0) return 0;
1.38 + if (index > list->collection.size || n == 0) return 0;
1.39
1.40 // get a correctly typed pointer to the list
1.41 cx_array_list *arl = (cx_array_list *) list;
1.42
1.43 // do we need to move some elements?
1.44 - if (index < list->base.size) {
1.45 + if (index < list->collection.size) {
1.46 char const *first_to_move = (char const *) arl->data;
1.47 - first_to_move += index * list->base.elem_size;
1.48 - size_t elems_to_move = list->base.size - index;
1.49 + first_to_move += index * list->collection.elem_size;
1.50 + size_t elems_to_move = list->collection.size - index;
1.51 size_t start_of_moved = index + n;
1.52
1.53 if (CX_ARRAY_SUCCESS != cx_array_copy(
1.54 &arl->data,
1.55 - &list->base.size,
1.56 + &list->collection.size,
1.57 &arl->capacity,
1.58 start_of_moved,
1.59 first_to_move,
1.60 - list->base.elem_size,
1.61 + list->collection.elem_size,
1.62 elems_to_move,
1.63 &arl->reallocator
1.64 )) {
1.65 @@ -249,11 +249,11 @@
1.66 // place the new elements
1.67 if (CX_ARRAY_SUCCESS == cx_array_copy(
1.68 &arl->data,
1.69 - &list->base.size,
1.70 + &list->collection.size,
1.71 &arl->capacity,
1.72 index,
1.73 array,
1.74 - list->base.elem_size,
1.75 + list->collection.elem_size,
1.76 n,
1.77 &arl->reallocator
1.78 )) {
1.79 @@ -278,7 +278,7 @@
1.80 int prepend
1.81 ) {
1.82 struct cx_list_s *list = iter->src_handle.m;
1.83 - if (iter->index < list->base.size) {
1.84 + if (iter->index < list->collection.size) {
1.85 int result = cx_arl_insert_element(
1.86 list,
1.87 iter->index + 1 - prepend,
1.88 @@ -286,12 +286,12 @@
1.89 );
1.90 if (result == 0 && prepend != 0) {
1.91 iter->index++;
1.92 - iter->elem_handle = ((char *) iter->elem_handle) + list->base.elem_size;
1.93 + iter->elem_handle = ((char *) iter->elem_handle) + list->collection.elem_size;
1.94 }
1.95 return result;
1.96 } else {
1.97 - int result = cx_arl_insert_element(list, list->base.size, elem);
1.98 - iter->index = list->base.size;
1.99 + int result = cx_arl_insert_element(list, list->collection.size, elem);
1.100 + iter->index = list->collection.size;
1.101 return result;
1.102 }
1.103 }
1.104 @@ -303,28 +303,28 @@
1.105 cx_array_list *arl = (cx_array_list *) list;
1.106
1.107 // out-of-bounds check
1.108 - if (index >= list->base.size) {
1.109 + if (index >= list->collection.size) {
1.110 return 1;
1.111 }
1.112
1.113 // content destruction
1.114 - cx_invoke_destructor(list, ((char *) arl->data) + index * list->base.elem_size);
1.115 + cx_invoke_destructor(list, ((char *) arl->data) + index * list->collection.elem_size);
1.116
1.117 // short-circuit removal of last element
1.118 - if (index == list->base.size - 1) {
1.119 - list->base.size--;
1.120 + if (index == list->collection.size - 1) {
1.121 + list->collection.size--;
1.122 return 0;
1.123 }
1.124
1.125 // just move the elements starting at index to the left
1.126 int result = cx_array_copy(
1.127 &arl->data,
1.128 - &list->base.size,
1.129 + &list->collection.size,
1.130 &arl->capacity,
1.131 index,
1.132 - ((char *) arl->data) + (index + 1) * list->base.elem_size,
1.133 - list->base.elem_size,
1.134 - list->base.size - index - 1,
1.135 + ((char *) arl->data) + (index + 1) * list->collection.elem_size,
1.136 + list->collection.elem_size,
1.137 + list->collection.size - index - 1,
1.138 &arl->reallocator
1.139 );
1.140
1.141 @@ -332,32 +332,32 @@
1.142 assert(result == 0);
1.143
1.144 // decrease the size
1.145 - list->base.size--;
1.146 + list->collection.size--;
1.147
1.148 return 0;
1.149 }
1.150
1.151 static void cx_arl_clear(struct cx_list_s *list) {
1.152 - if (list->base.size == 0) return;
1.153 + if (list->collection.size == 0) return;
1.154
1.155 cx_array_list *arl = (cx_array_list *) list;
1.156 char *ptr = arl->data;
1.157
1.158 - if (list->base.simple_destructor) {
1.159 - for (size_t i = 0; i < list->base.size; i++) {
1.160 + if (list->collection.simple_destructor) {
1.161 + for (size_t i = 0; i < list->collection.size; i++) {
1.162 cx_invoke_simple_destructor(list, ptr);
1.163 - ptr += list->base.elem_size;
1.164 + ptr += list->collection.elem_size;
1.165 }
1.166 }
1.167 - if (list->base.advanced_destructor) {
1.168 - for (size_t i = 0; i < list->base.size; i++) {
1.169 + if (list->collection.advanced_destructor) {
1.170 + for (size_t i = 0; i < list->collection.size; i++) {
1.171 cx_invoke_advanced_destructor(list, ptr);
1.172 - ptr += list->base.elem_size;
1.173 + ptr += list->collection.elem_size;
1.174 }
1.175 }
1.176
1.177 - memset(arl->data, 0, list->base.size * list->base.elem_size);
1.178 - list->base.size = 0;
1.179 + memset(arl->data, 0, list->collection.size * list->collection.elem_size);
1.180 + list->collection.size = 0;
1.181 }
1.182
1.183 static int cx_arl_swap(
1.184 @@ -365,9 +365,9 @@
1.185 size_t i,
1.186 size_t j
1.187 ) {
1.188 - if (i >= list->base.size || j >= list->base.size) return 1;
1.189 + if (i >= list->collection.size || j >= list->collection.size) return 1;
1.190 cx_array_list *arl = (cx_array_list *) list;
1.191 - cx_array_swap(arl->data, list->base.elem_size, i, j);
1.192 + cx_array_swap(arl->data, list->collection.elem_size, i, j);
1.193 return 0;
1.194 }
1.195
1.196 @@ -375,10 +375,10 @@
1.197 struct cx_list_s const *list,
1.198 size_t index
1.199 ) {
1.200 - if (index < list->base.size) {
1.201 + if (index < list->collection.size) {
1.202 cx_array_list const *arl = (cx_array_list const *) list;
1.203 char *space = arl->data;
1.204 - return space + index * list->base.elem_size;
1.205 + return space + index * list->collection.elem_size;
1.206 } else {
1.207 return NULL;
1.208 }
1.209 @@ -389,12 +389,12 @@
1.210 void const *elem,
1.211 bool remove
1.212 ) {
1.213 - assert(list->base.cmpfunc != NULL);
1.214 - assert(list->base.size < SIZE_MAX / 2);
1.215 + assert(list->collection.cmpfunc != NULL);
1.216 + assert(list->collection.size < SIZE_MAX / 2);
1.217 char *cur = ((cx_array_list const *) list)->data;
1.218
1.219 - for (ssize_t i = 0; i < (ssize_t) list->base.size; i++) {
1.220 - if (0 == list->base.cmpfunc(elem, cur)) {
1.221 + for (ssize_t i = 0; i < (ssize_t) list->collection.size; i++) {
1.222 + if (0 == list->collection.cmpfunc(elem, cur)) {
1.223 if (remove) {
1.224 if (0 == cx_arl_remove(list, i)) {
1.225 return i;
1.226 @@ -405,18 +405,18 @@
1.227 return i;
1.228 }
1.229 }
1.230 - cur += list->base.elem_size;
1.231 + cur += list->collection.elem_size;
1.232 }
1.233
1.234 return -1;
1.235 }
1.236
1.237 static void cx_arl_sort(struct cx_list_s *list) {
1.238 - assert(list->base.cmpfunc != NULL);
1.239 + assert(list->collection.cmpfunc != NULL);
1.240 qsort(((cx_array_list *) list)->data,
1.241 - list->base.size,
1.242 - list->base.elem_size,
1.243 - list->base.cmpfunc
1.244 + list->collection.size,
1.245 + list->collection.elem_size,
1.246 + list->collection.cmpfunc
1.247 );
1.248 }
1.249
1.250 @@ -424,37 +424,37 @@
1.251 struct cx_list_s const *list,
1.252 struct cx_list_s const *other
1.253 ) {
1.254 - assert(list->base.cmpfunc != NULL);
1.255 - if (list->base.size == other->base.size) {
1.256 + assert(list->collection.cmpfunc != NULL);
1.257 + if (list->collection.size == other->collection.size) {
1.258 char const *left = ((cx_array_list const *) list)->data;
1.259 char const *right = ((cx_array_list const *) other)->data;
1.260 - for (size_t i = 0; i < list->base.size; i++) {
1.261 - int d = list->base.cmpfunc(left, right);
1.262 + for (size_t i = 0; i < list->collection.size; i++) {
1.263 + int d = list->collection.cmpfunc(left, right);
1.264 if (d != 0) {
1.265 return d;
1.266 }
1.267 - left += list->base.elem_size;
1.268 - right += other->base.elem_size;
1.269 + left += list->collection.elem_size;
1.270 + right += other->collection.elem_size;
1.271 }
1.272 return 0;
1.273 } else {
1.274 - return list->base.size < other->base.size ? -1 : 1;
1.275 + return list->collection.size < other->collection.size ? -1 : 1;
1.276 }
1.277 }
1.278
1.279 static void cx_arl_reverse(struct cx_list_s *list) {
1.280 - if (list->base.size < 2) return;
1.281 + if (list->collection.size < 2) return;
1.282 void *data = ((cx_array_list const *) list)->data;
1.283 - size_t half = list->base.size / 2;
1.284 + size_t half = list->collection.size / 2;
1.285 for (size_t i = 0; i < half; i++) {
1.286 - cx_array_swap(data, list->base.elem_size, i, list->base.size - 1 - i);
1.287 + cx_array_swap(data, list->collection.elem_size, i, list->collection.size - 1 - i);
1.288 }
1.289 }
1.290
1.291 static bool cx_arl_iter_valid(void const *it) {
1.292 struct cx_iterator_s const *iter = it;
1.293 struct cx_list_s const *list = iter->src_handle.c;
1.294 - return iter->index < list->base.size;
1.295 + return iter->index < list->collection.size;
1.296 }
1.297
1.298 static void *cx_arl_iter_current(void const *it) {
1.299 @@ -471,7 +471,7 @@
1.300 iter->index++;
1.301 iter->elem_handle =
1.302 ((char *) iter->elem_handle)
1.303 - + ((struct cx_list_s const *) iter->src_handle.c)->base.elem_size;
1.304 + + ((struct cx_list_s const *) iter->src_handle.c)->collection.elem_size;
1.305 }
1.306 }
1.307
1.308 @@ -483,9 +483,9 @@
1.309 cx_arl_remove(iter->src_handle.m, iter->index);
1.310 }
1.311 iter->index--;
1.312 - if (iter->index < list->base.base.size) {
1.313 + if (iter->index < list->base.collection.size) {
1.314 iter->elem_handle = ((char *) list->data)
1.315 - + iter->index * list->base.base.elem_size;
1.316 + + iter->index * list->base.collection.elem_size;
1.317 }
1.318 }
1.319
1.320 @@ -500,8 +500,8 @@
1.321 iter.index = index;
1.322 iter.src_handle.c = list;
1.323 iter.elem_handle = cx_arl_at(list, index);
1.324 - iter.elem_size = list->base.elem_size;
1.325 - iter.elem_count = list->base.size;
1.326 + iter.elem_size = list->collection.elem_size;
1.327 + iter.elem_count = list->collection.size;
1.328 iter.base.valid = cx_arl_iter_valid;
1.329 iter.base.current = cx_arl_iter_current;
1.330 iter.base.next = backwards ? cx_arl_iter_prev : cx_arl_iter_next;
1.331 @@ -541,15 +541,15 @@
1.332 if (list == NULL) return NULL;
1.333
1.334 list->base.cl = &cx_array_list_class;
1.335 - list->base.base.allocator = allocator;
1.336 + list->base.collection.allocator = allocator;
1.337 list->capacity = initial_capacity;
1.338
1.339 if (elem_size > 0) {
1.340 - list->base.base.elem_size = elem_size;
1.341 - list->base.base.cmpfunc = comparator;
1.342 + list->base.collection.elem_size = elem_size;
1.343 + list->base.collection.cmpfunc = comparator;
1.344 } else {
1.345 elem_size = sizeof(void *);
1.346 - list->base.base.cmpfunc = comparator == NULL ? cx_cmp_ptr : comparator;
1.347 + list->base.collection.cmpfunc = comparator == NULL ? cx_cmp_ptr : comparator;
1.348 cxListStorePointers((CxList *) list);
1.349 }
1.350
