comparison: ucx/list.c
ucx/list.c
- branch
- dav-2
- changeset 886
- da79af4baec8
- parent 854
- 1c8401ece69e
- child 889
- 42cdbf9bbd49
equal
deleted
inserted
replaced
| 885:591377a27fa3 | 886:da79af4baec8 |
|---|---|
| 60 | 60 |
| 61 static void cx_pl_destructor(struct cx_list_s *list) { | 61 static void cx_pl_destructor(struct cx_list_s *list) { |
| 62 list->climpl->deallocate(list); | 62 list->climpl->deallocate(list); |
| 63 } | 63 } |
| 64 | 64 |
| 65 static int cx_pl_insert_element( | 65 static void *cx_pl_insert_element( |
| 66 struct cx_list_s *list, | 66 struct cx_list_s *list, |
| 67 size_t index, | 67 size_t index, |
| 68 const void *element | 68 const void *element |
| 69 ) { | 69 ) { |
| 70 return list->climpl->insert_element(list, index, &element); | 70 return list->climpl->insert_element(list, index, &element); |
| 280 ) { | 280 ) { |
| 281 size_t elem_size = list->collection.elem_size; | 281 size_t elem_size = list->collection.elem_size; |
| 282 const char *src = data; | 282 const char *src = data; |
| 283 size_t i = 0; | 283 size_t i = 0; |
| 284 for (; i < n; i++) { | 284 for (; i < n; i++) { |
| 285 if (0 != invoke_list_func( | 285 if (NULL == invoke_list_func( |
| 286 insert_element, list, index + i, | 286 insert_element, list, index + i, |
| 287 src + (i * elem_size))) return i; | 287 src + (i * elem_size))) return i; |
| 288 } | 288 } |
| 289 return i; | 289 return i; |
| 290 } | 290 } |
| 327 ins++; | 327 ins++; |
| 328 } | 328 } |
| 329 | 329 |
| 330 // insert the elements at location si | 330 // insert the elements at location si |
| 331 if (ins == 1) { | 331 if (ins == 1) { |
| 332 if (0 != invoke_list_func( | 332 if (NULL == invoke_list_func( |
| 333 insert_element, list, di, src)) return inserted; | 333 insert_element, list, di, src)) return inserted; |
| 334 } else { | 334 } else { |
| 335 size_t r = invoke_list_func(insert_array, list, di, src, ins); | 335 size_t r = invoke_list_func(insert_array, list, di, src, ins); |
| 336 if (r < ins) return inserted + r; | 336 if (r < ins) return inserted + r; |
| 337 } | 337 } |
| 352 } | 352 } |
| 353 | 353 |
| 354 void cx_list_default_sort(struct cx_list_s *list) { | 354 void cx_list_default_sort(struct cx_list_s *list) { |
| 355 size_t elem_size = list->collection.elem_size; | 355 size_t elem_size = list->collection.elem_size; |
| 356 size_t list_size = list->collection.size; | 356 size_t list_size = list->collection.size; |
| 357 void *tmp = malloc(elem_size * list_size); | 357 void *tmp = cxMallocDefault(elem_size * list_size); |
| 358 if (tmp == NULL) abort(); | 358 if (tmp == NULL) abort(); |
| 359 | 359 |
| 360 // copy elements from source array | 360 // copy elements from source array |
| 361 char *loc = tmp; | 361 char *loc = tmp; |
| 362 for (size_t i = 0; i < list_size; i++) { | 362 for (size_t i = 0; i < list_size; i++) { |
| 375 void *dest = invoke_list_func(at, list, i); | 375 void *dest = invoke_list_func(at, list, i); |
| 376 memcpy(dest, loc, elem_size); | 376 memcpy(dest, loc, elem_size); |
| 377 loc += elem_size; | 377 loc += elem_size; |
| 378 } | 378 } |
| 379 | 379 |
| 380 free(tmp); | 380 cxFreeDefault(tmp); |
| 381 } | 381 } |
| 382 | 382 |
| 383 int cx_list_default_swap(struct cx_list_s *list, size_t i, size_t j) { | 383 int cx_list_default_swap(struct cx_list_s *list, size_t i, size_t j) { |
| 384 if (i == j) return 0; | 384 if (i == j) return 0; |
| 385 if (i >= list->collection.size) return 1; | 385 if (i >= list->collection.size) return 1; |
| 386 if (j >= list->collection.size) return 1; | 386 if (j >= list->collection.size) return 1; |
| 387 | 387 |
| 388 size_t elem_size = list->collection.elem_size; | 388 size_t elem_size = list->collection.elem_size; |
| 389 | 389 |
| 390 void *tmp = malloc(elem_size); | 390 void *tmp = cxMallocDefault(elem_size); |
| 391 if (tmp == NULL) return 1; | 391 if (tmp == NULL) return 1; |
| 392 | 392 |
| 393 void *ip = invoke_list_func(at, list, i); | 393 void *ip = invoke_list_func(at, list, i); |
| 394 void *jp = invoke_list_func(at, list, j); | 394 void *jp = invoke_list_func(at, list, j); |
| 395 | 395 |
| 396 memcpy(tmp, ip, elem_size); | 396 memcpy(tmp, ip, elem_size); |
| 397 memcpy(ip, jp, elem_size); | 397 memcpy(ip, jp, elem_size); |
| 398 memcpy(jp, tmp, elem_size); | 398 memcpy(jp, tmp, elem_size); |
| 399 | 399 |
| 400 free(tmp); | 400 cxFreeDefault(tmp); |
| 401 | 401 |
| 402 return 0; | 402 return 0; |
| 403 } | 403 } |
| 404 | 404 |
| 405 void cx_list_init( | 405 void cx_list_init( |
| 474 | 474 |
| 475 CxIterator cxListMutIteratorAt( | 475 CxIterator cxListMutIteratorAt( |
| 476 CxList *list, | 476 CxList *list, |
| 477 size_t index | 477 size_t index |
| 478 ) { | 478 ) { |
| 479 if (list == NULL) list = cxEmptyList; | |
| 479 CxIterator it = list->cl->iterator(list, index, false); | 480 CxIterator it = list->cl->iterator(list, index, false); |
| 480 it.base.mutating = true; | 481 it.base.mutating = true; |
| 481 return it; | 482 return it; |
| 482 } | 483 } |
| 483 | 484 |
| 484 CxIterator cxListMutBackwardsIteratorAt( | 485 CxIterator cxListMutBackwardsIteratorAt( |
| 485 CxList *list, | 486 CxList *list, |
| 486 size_t index | 487 size_t index |
| 487 ) { | 488 ) { |
| 489 if (list == NULL) list = cxEmptyList; | |
| 488 CxIterator it = list->cl->iterator(list, index, true); | 490 CxIterator it = list->cl->iterator(list, index, true); |
| 489 it.base.mutating = true; | 491 it.base.mutating = true; |
| 490 return it; | 492 return it; |
| 491 } | 493 } |
| 492 | 494 |
| 493 void cxListFree(CxList *list) { | 495 void cxListFree(CxList *list) { |
| 494 if (list == NULL) return; | 496 if (list == NULL) return; |
| 495 list->cl->deallocate(list); | 497 list->cl->deallocate(list); |
| 496 } | 498 } |
| 499 | |
| 500 int cxListSet( | |
| 501 CxList *list, | |
| 502 size_t index, | |
| 503 const void *elem | |
| 504 ) { | |
| 505 if (index >= list->collection.size) { | |
| 506 return 1; | |
| 507 } | |
| 508 | |
| 509 if (list->collection.store_pointer) { | |
| 510 // For pointer collections, always use climpl | |
| 511 void **target = list->climpl->at(list, index); | |
| 512 *target = (void *)elem; | |
| 513 } else { | |
| 514 void *target = list->cl->at(list, index); | |
| 515 memcpy(target, elem, list->collection.elem_size); | |
| 516 } | |
| 517 | |
| 518 return 0; | |
| 519 } |
