Blender  V3.3
listbase.c
Go to the documentation of this file.
1 /* SPDX-License-Identifier: GPL-2.0-or-later
2  * Copyright 2001-2002 NaN Holding BV. All rights reserved. */
3 
12 #include <stdlib.h>
13 #include <string.h>
14 
15 #include "MEM_guardedalloc.h"
16 
17 #include "DNA_listBase.h"
18 
19 #include "BLI_listbase.h"
20 
21 #include "BLI_strict_flags.h"
22 
24 {
25  if (src->first == NULL) {
26  return;
27  }
28 
29  if (dst->first == NULL) {
30  dst->first = src->first;
31  dst->last = src->last;
32  }
33  else {
34  ((Link *)dst->last)->next = src->first;
35  ((Link *)src->first)->prev = dst->last;
36  dst->last = src->last;
37  }
38  src->first = src->last = NULL;
39 }
40 
42 {
43  if (src->first == NULL) {
44  return;
45  }
46 
47  if (dst->first == NULL) {
48  dst->first = src->first;
49  dst->last = src->last;
50  }
51  else {
52  ((Link *)src->last)->next = dst->first;
53  ((Link *)dst->first)->prev = src->last;
54  dst->first = src->first;
55  }
56 
57  src->first = src->last = NULL;
58 }
59 
60 void BLI_addhead(ListBase *listbase, void *vlink)
61 {
62  Link *link = vlink;
63 
64  if (link == NULL) {
65  return;
66  }
67 
68  link->next = listbase->first;
69  link->prev = NULL;
70 
71  if (listbase->first) {
72  ((Link *)listbase->first)->prev = link;
73  }
74  if (listbase->last == NULL) {
75  listbase->last = link;
76  }
77  listbase->first = link;
78 }
79 
80 void BLI_addtail(ListBase *listbase, void *vlink)
81 {
82  Link *link = vlink;
83 
84  if (link == NULL) {
85  return;
86  }
87 
88  link->next = NULL;
89  link->prev = listbase->last;
90 
91  if (listbase->last) {
92  ((Link *)listbase->last)->next = link;
93  }
94  if (listbase->first == NULL) {
95  listbase->first = link;
96  }
97  listbase->last = link;
98 }
99 
100 void BLI_remlink(ListBase *listbase, void *vlink)
101 {
102  Link *link = vlink;
103 
104  if (link == NULL) {
105  return;
106  }
107 
108  if (link->next) {
109  link->next->prev = link->prev;
110  }
111  if (link->prev) {
112  link->prev->next = link->next;
113  }
114 
115  if (listbase->last == link) {
116  listbase->last = link->prev;
117  }
118  if (listbase->first == link) {
119  listbase->first = link->next;
120  }
121 }
122 
123 bool BLI_remlink_safe(ListBase *listbase, void *vlink)
124 {
125  if (BLI_findindex(listbase, vlink) != -1) {
126  BLI_remlink(listbase, vlink);
127  return true;
128  }
129 
130  return false;
131 }
132 
133 void BLI_listbase_swaplinks(ListBase *listbase, void *vlinka, void *vlinkb)
134 {
135  Link *linka = vlinka;
136  Link *linkb = vlinkb;
137 
138  if (!linka || !linkb) {
139  return;
140  }
141 
142  if (linkb->next == linka) {
143  SWAP(Link *, linka, linkb);
144  }
145 
146  if (linka->next == linkb) {
147  linka->next = linkb->next;
148  linkb->prev = linka->prev;
149  linka->prev = linkb;
150  linkb->next = linka;
151  }
152  else { /* Non-contiguous items, we can safely swap. */
153  SWAP(Link *, linka->prev, linkb->prev);
154  SWAP(Link *, linka->next, linkb->next);
155  }
156 
157  /* Update neighbors of linka and linkb. */
158  if (linka->prev) {
159  linka->prev->next = linka;
160  }
161  if (linka->next) {
162  linka->next->prev = linka;
163  }
164  if (linkb->prev) {
165  linkb->prev->next = linkb;
166  }
167  if (linkb->next) {
168  linkb->next->prev = linkb;
169  }
170 
171  if (listbase->last == linka) {
172  listbase->last = linkb;
173  }
174  else if (listbase->last == linkb) {
175  listbase->last = linka;
176  }
177 
178  if (listbase->first == linka) {
179  listbase->first = linkb;
180  }
181  else if (listbase->first == linkb) {
182  listbase->first = linka;
183  }
184 }
185 
186 void BLI_listbases_swaplinks(ListBase *listbasea, ListBase *listbaseb, void *vlinka, void *vlinkb)
187 {
188  Link *linka = vlinka;
189  Link *linkb = vlinkb;
190  Link linkc = {NULL};
191 
192  if (!linka || !linkb) {
193  return;
194  }
195 
196  /* The reference to `linkc` assigns NULL, not a dangling pointer so it can be ignored. */
197 #if defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) >= 1201 /* gcc12.1+ only */
198 # pragma GCC diagnostic push
199 # pragma GCC diagnostic ignored "-Wdangling-pointer"
200 #endif
201 
202  /* Temporary link to use as placeholder of the links positions */
203  BLI_insertlinkafter(listbasea, linka, &linkc);
204 
205 #if defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) >= 1201 /* gcc12.1+ only */
206 # pragma GCC diagnostic pop
207 #endif
208 
209  /* Bring linka into linkb position */
210  BLI_remlink(listbasea, linka);
211  BLI_insertlinkafter(listbaseb, linkb, linka);
212 
213  /* Bring linkb into linka position */
214  BLI_remlink(listbaseb, linkb);
215  BLI_insertlinkafter(listbasea, &linkc, linkb);
216 
217  /* Remove temporary link */
218  BLI_remlink(listbasea, &linkc);
219 }
220 
221 void *BLI_pophead(ListBase *listbase)
222 {
223  Link *link;
224  if ((link = listbase->first)) {
225  BLI_remlink(listbase, link);
226  }
227  return link;
228 }
229 
230 void *BLI_poptail(ListBase *listbase)
231 {
232  Link *link;
233  if ((link = listbase->last)) {
234  BLI_remlink(listbase, link);
235  }
236  return link;
237 }
238 
239 void BLI_freelinkN(ListBase *listbase, void *vlink)
240 {
241  Link *link = vlink;
242 
243  if (link == NULL) {
244  return;
245  }
246 
247  BLI_remlink(listbase, link);
248  MEM_freeN(link);
249 }
250 
254 static void listbase_double_from_single(Link *iter, ListBase *listbase)
255 {
256  Link *prev = NULL;
257  listbase->first = iter;
258  do {
259  iter->prev = prev;
260  prev = iter;
261  } while ((iter = iter->next));
262  listbase->last = prev;
263 }
264 
265 #define SORT_IMPL_LINKTYPE Link
266 
267 /* regular call */
268 #define SORT_IMPL_FUNC listbase_sort_fn
269 #include "list_sort_impl.h"
270 #undef SORT_IMPL_FUNC
271 
272 /* re-entrant call */
273 #define SORT_IMPL_USE_THUNK
274 #define SORT_IMPL_FUNC listbase_sort_fn_r
275 #include "list_sort_impl.h"
276 #undef SORT_IMPL_FUNC
277 #undef SORT_IMPL_USE_THUNK
278 
279 #undef SORT_IMPL_LINKTYPE
280 
281 void BLI_listbase_sort(ListBase *listbase, int (*cmp)(const void *, const void *))
282 {
283  if (listbase->first != listbase->last) {
284  Link *head = listbase->first;
285  head = listbase_sort_fn(head, cmp);
286  listbase_double_from_single(head, listbase);
287  }
288 }
289 
291  int (*cmp)(void *, const void *, const void *),
292  void *thunk)
293 {
294  if (listbase->first != listbase->last) {
295  Link *head = listbase->first;
296  head = listbase_sort_fn_r(head, cmp, thunk);
297  listbase_double_from_single(head, listbase);
298  }
299 }
300 
301 void BLI_insertlinkafter(ListBase *listbase, void *vprevlink, void *vnewlink)
302 {
303  Link *prevlink = vprevlink;
304  Link *newlink = vnewlink;
305 
306  /* newlink before nextlink */
307  if (newlink == NULL) {
308  return;
309  }
310 
311  /* empty list */
312  if (listbase->first == NULL) {
313  listbase->first = newlink;
314  listbase->last = newlink;
315  return;
316  }
317 
318  /* insert at head of list */
319  if (prevlink == NULL) {
320  newlink->prev = NULL;
321  newlink->next = listbase->first;
322  newlink->next->prev = newlink;
323  listbase->first = newlink;
324  return;
325  }
326 
327  /* at end of list */
328  if (listbase->last == prevlink) {
329  listbase->last = newlink;
330  }
331 
332  newlink->next = prevlink->next;
333  newlink->prev = prevlink;
334  prevlink->next = newlink;
335  if (newlink->next) {
336  newlink->next->prev = newlink;
337  }
338 }
339 
340 void BLI_insertlinkbefore(ListBase *listbase, void *vnextlink, void *vnewlink)
341 {
342  Link *nextlink = vnextlink;
343  Link *newlink = vnewlink;
344 
345  /* newlink before nextlink */
346  if (newlink == NULL) {
347  return;
348  }
349 
350  /* empty list */
351  if (listbase->first == NULL) {
352  listbase->first = newlink;
353  listbase->last = newlink;
354  return;
355  }
356 
357  /* insert at end of list */
358  if (nextlink == NULL) {
359  newlink->prev = listbase->last;
360  newlink->next = NULL;
361  ((Link *)listbase->last)->next = newlink;
362  listbase->last = newlink;
363  return;
364  }
365 
366  /* at beginning of list */
367  if (listbase->first == nextlink) {
368  listbase->first = newlink;
369  }
370 
371  newlink->next = nextlink;
372  newlink->prev = nextlink->prev;
373  nextlink->prev = newlink;
374  if (newlink->prev) {
375  newlink->prev->next = newlink;
376  }
377 }
378 
379 void BLI_insertlinkreplace(ListBase *listbase, void *vreplacelink, void *vnewlink)
380 {
381  Link *l_old = vreplacelink;
382  Link *l_new = vnewlink;
383 
384  /* update adjacent links */
385  if (l_old->next != NULL) {
386  l_old->next->prev = l_new;
387  }
388  if (l_old->prev != NULL) {
389  l_old->prev->next = l_new;
390  }
391 
392  /* set direct links */
393  l_new->next = l_old->next;
394  l_new->prev = l_old->prev;
395 
396  /* update list */
397  if (listbase->first == l_old) {
398  listbase->first = l_new;
399  }
400  if (listbase->last == l_old) {
401  listbase->last = l_new;
402  }
403 }
404 
405 bool BLI_listbase_link_move(ListBase *listbase, void *vlink, int step)
406 {
407  Link *link = vlink;
408  Link *hook = link;
409  const bool is_up = step < 0;
410 
411  if (step == 0) {
412  return false;
413  }
414  BLI_assert(BLI_findindex(listbase, link) != -1);
415 
416  /* find link to insert before/after */
417  const int abs_step = abs(step);
418  for (int i = 0; i < abs_step; i++) {
419  hook = is_up ? hook->prev : hook->next;
420  if (!hook) {
421  return false;
422  }
423  }
424 
425  /* reinsert link */
426  BLI_remlink(listbase, vlink);
427  if (is_up) {
428  BLI_insertlinkbefore(listbase, hook, vlink);
429  }
430  else {
431  BLI_insertlinkafter(listbase, hook, vlink);
432  }
433  return true;
434 }
435 
436 bool BLI_listbase_move_index(ListBase *listbase, int from, int to)
437 {
438  if (from == to) {
439  return false;
440  }
441 
442  /* Find the link to move. */
443  void *link = BLI_findlink(listbase, from);
444 
445  if (!link) {
446  return false;
447  }
448 
449  return BLI_listbase_link_move(listbase, link, to - from);
450 }
451 
452 void BLI_freelist(ListBase *listbase)
453 {
454  Link *link, *next;
455 
456  link = listbase->first;
457  while (link) {
458  next = link->next;
459  free(link);
460  link = next;
461  }
462 
463  BLI_listbase_clear(listbase);
464 }
465 
466 void BLI_freelistN(ListBase *listbase)
467 {
468  Link *link, *next;
469 
470  link = listbase->first;
471  while (link) {
472  next = link->next;
473  MEM_freeN(link);
474  link = next;
475  }
476 
477  BLI_listbase_clear(listbase);
478 }
479 
480 int BLI_listbase_count_at_most(const ListBase *listbase, const int count_max)
481 {
482  Link *link;
483  int count = 0;
484 
485  for (link = listbase->first; link && count != count_max; link = link->next) {
486  count++;
487  }
488 
489  return count;
490 }
491 
492 int BLI_listbase_count(const ListBase *listbase)
493 {
494  Link *link;
495  int count = 0;
496 
497  for (link = listbase->first; link; link = link->next) {
498  count++;
499  }
500 
501  return count;
502 }
503 
504 void *BLI_findlink(const ListBase *listbase, int number)
505 {
506  Link *link = NULL;
507 
508  if (number >= 0) {
509  link = listbase->first;
510  while (link != NULL && number != 0) {
511  number--;
512  link = link->next;
513  }
514  }
515 
516  return link;
517 }
518 
519 void *BLI_rfindlink(const ListBase *listbase, int number)
520 {
521  Link *link = NULL;
522 
523  if (number >= 0) {
524  link = listbase->last;
525  while (link != NULL && number != 0) {
526  number--;
527  link = link->prev;
528  }
529  }
530 
531  return link;
532 }
533 
534 void *BLI_findlinkfrom(Link *start, int number)
535 {
536  Link *link = NULL;
537 
538  if (number >= 0) {
539  link = start;
540  while (link != NULL && number != 0) {
541  number--;
542  link = link->next;
543  }
544  }
545 
546  return link;
547 }
548 
549 int BLI_findindex(const ListBase *listbase, const void *vlink)
550 {
551  Link *link = NULL;
552  int number = 0;
553 
554  if (vlink == NULL) {
555  return -1;
556  }
557 
558  link = listbase->first;
559  while (link) {
560  if (link == vlink) {
561  return number;
562  }
563 
564  number++;
565  link = link->next;
566  }
567 
568  return -1;
569 }
570 
571 void *BLI_findstring(const ListBase *listbase, const char *id, const int offset)
572 {
573  Link *link = NULL;
574  const char *id_iter;
575 
576  if (id == NULL) {
577  return NULL;
578  }
579 
580  for (link = listbase->first; link; link = link->next) {
581  id_iter = ((const char *)link) + offset;
582 
583  if (id[0] == id_iter[0] && STREQ(id, id_iter)) {
584  return link;
585  }
586  }
587 
588  return NULL;
589 }
590 void *BLI_rfindstring(const ListBase *listbase, const char *id, const int offset)
591 {
592  /* Same as #BLI_findstring but find reverse. */
593 
594  Link *link = NULL;
595  const char *id_iter;
596 
597  for (link = listbase->last; link; link = link->prev) {
598  id_iter = ((const char *)link) + offset;
599 
600  if (id[0] == id_iter[0] && STREQ(id, id_iter)) {
601  return link;
602  }
603  }
604 
605  return NULL;
606 }
607 
608 void *BLI_findstring_ptr(const ListBase *listbase, const char *id, const int offset)
609 {
610  Link *link = NULL;
611  const char *id_iter;
612 
613  for (link = listbase->first; link; link = link->next) {
614  /* exact copy of BLI_findstring(), except for this line */
615  id_iter = *((const char **)(((const char *)link) + offset));
616 
617  if (id[0] == id_iter[0] && STREQ(id, id_iter)) {
618  return link;
619  }
620  }
621 
622  return NULL;
623 }
624 void *BLI_rfindstring_ptr(const ListBase *listbase, const char *id, const int offset)
625 {
626  /* Same as #BLI_findstring_ptr but find reverse. */
627 
628  Link *link = NULL;
629  const char *id_iter;
630 
631  for (link = listbase->last; link; link = link->prev) {
632  /* exact copy of BLI_rfindstring(), except for this line */
633  id_iter = *((const char **)(((const char *)link) + offset));
634 
635  if (id[0] == id_iter[0] && STREQ(id, id_iter)) {
636  return link;
637  }
638  }
639 
640  return NULL;
641 }
642 
643 void *BLI_findptr(const ListBase *listbase, const void *ptr, const int offset)
644 {
645  Link *link = NULL;
646  const void *ptr_iter;
647 
648  for (link = listbase->first; link; link = link->next) {
649  /* exact copy of BLI_findstring(), except for this line */
650  ptr_iter = *((const void **)(((const char *)link) + offset));
651 
652  if (ptr == ptr_iter) {
653  return link;
654  }
655  }
656 
657  return NULL;
658 }
659 void *BLI_rfindptr(const ListBase *listbase, const void *ptr, const int offset)
660 {
661  /* Same as #BLI_findptr but find reverse. */
662 
663  Link *link = NULL;
664  const void *ptr_iter;
665 
666  for (link = listbase->last; link; link = link->prev) {
667  /* exact copy of BLI_rfindstring(), except for this line */
668  ptr_iter = *((const void **)(((const char *)link) + offset));
669 
670  if (ptr == ptr_iter) {
671  return link;
672  }
673  }
674 
675  return NULL;
676 }
677 
678 void *BLI_listbase_bytes_find(const ListBase *listbase,
679  const void *bytes,
680  const size_t bytes_size,
681  const int offset)
682 {
683  Link *link = NULL;
684  const void *ptr_iter;
685 
686  for (link = listbase->first; link; link = link->next) {
687  ptr_iter = (const void *)(((const char *)link) + offset);
688 
689  if (memcmp(bytes, ptr_iter, bytes_size) == 0) {
690  return link;
691  }
692  }
693 
694  return NULL;
695 }
696 void *BLI_listbase_bytes_rfind(const ListBase *listbase,
697  const void *bytes,
698  const size_t bytes_size,
699  const int offset)
700 {
701  /* Same as #BLI_listbase_bytes_find but find reverse. */
702 
703  Link *link = NULL;
704  const void *ptr_iter;
705 
706  for (link = listbase->last; link; link = link->prev) {
707  ptr_iter = (const void *)(((const char *)link) + offset);
708 
709  if (memcmp(bytes, ptr_iter, bytes_size) == 0) {
710  return link;
711  }
712  }
713 
714  return NULL;
715 }
716 
718  const char *string,
719  const size_t string_offset,
720  const int index)
721 {
722  Link *link = NULL;
723  Link *link_at_index = NULL;
724 
725  int index_iter;
726  for (link = listbase->first, index_iter = 0; link; link = link->next, index_iter++) {
727  if (string != NULL && string[0] != '\0') {
728  const char *string_iter = ((const char *)link) + string_offset;
729 
730  if (string[0] == string_iter[0] && STREQ(string, string_iter)) {
731  return link;
732  }
733  }
734  if (index_iter == index) {
735  link_at_index = link;
736  }
737  }
738  return link_at_index;
739 }
740 
741 int BLI_findstringindex(const ListBase *listbase, const char *id, const int offset)
742 {
743  Link *link = NULL;
744  const char *id_iter;
745  int i = 0;
746 
747  link = listbase->first;
748  while (link) {
749  id_iter = ((const char *)link) + offset;
750 
751  if (id[0] == id_iter[0] && STREQ(id, id_iter)) {
752  return i;
753  }
754  i++;
755  link = link->next;
756  }
757 
758  return -1;
759 }
760 
762 {
763  ListBase list = {some_link, some_link};
764  if (some_link == NULL) {
765  return list;
766  }
767 
768  /* Find the first element. */
769  while (((Link *)list.first)->prev != NULL) {
770  list.first = ((Link *)list.first)->prev;
771  }
772 
773  /* Find the last element. */
774  while (((Link *)list.last)->next != NULL) {
775  list.last = ((Link *)list.last)->next;
776  }
777 
778  return list;
779 }
780 
782 {
783  struct Link *dst_link, *src_link;
784 
785  /* in this order, to ensure it works if dst == src */
786  src_link = src->first;
787  dst->first = dst->last = NULL;
788 
789  while (src_link) {
790  dst_link = MEM_dupallocN(src_link);
791  BLI_addtail(dst, dst_link);
792 
793  src_link = src_link->next;
794  }
795 }
796 
798 {
799  struct Link *curr = lb->first;
800  struct Link *prev = NULL;
801  struct Link *next = NULL;
802  while (curr) {
803  next = curr->next;
804  curr->next = prev;
805  curr->prev = next;
806  prev = curr;
807  curr = next;
808  }
809 
810  /* swap first/last */
811  curr = lb->first;
812  lb->first = lb->last;
813  lb->last = curr;
814 }
815 
816 void BLI_listbase_rotate_first(ListBase *lb, void *vlink)
817 {
818  /* make circular */
819  ((Link *)lb->first)->prev = lb->last;
820  ((Link *)lb->last)->next = lb->first;
821 
822  lb->first = vlink;
823  lb->last = ((Link *)vlink)->prev;
824 
825  ((Link *)lb->first)->prev = NULL;
826  ((Link *)lb->last)->next = NULL;
827 }
828 
829 void BLI_listbase_rotate_last(ListBase *lb, void *vlink)
830 {
831  /* make circular */
832  ((Link *)lb->first)->prev = lb->last;
833  ((Link *)lb->last)->next = lb->first;
834 
835  lb->first = ((Link *)vlink)->next;
836  lb->last = vlink;
837 
838  ((Link *)lb->first)->prev = NULL;
839  ((Link *)lb->last)->next = NULL;
840 }
841 
843 {
844  LinkData *ld;
845 
846  if (data == NULL) {
847  return NULL;
848  }
849 
850  /* create new link, and make it hold the given data */
851  ld = MEM_callocN(sizeof(LinkData), __func__);
852  ld->data = data;
853 
854  return ld;
855 }
#define BLI_assert(a)
Definition: BLI_assert.h:46
void BLI_kdtree_nd_() free(KDTree *tree)
Definition: kdtree_impl.h:102
BLI_INLINE void BLI_listbase_clear(struct ListBase *lb)
Definition: BLI_listbase.h:273
Strict compiler flags for areas of code we want to ensure don't do conversions without us knowing abo...
#define SWAP(type, a, b)
#define STREQ(a, b)
These structs are the foundation for all linked lists in the library system.
Read Guarded memory(de)allocation.
StackEntry * from
SyclQueue void void * src
int count
ccl_gpu_kernel_postfix ccl_global float int int int int float bool int offset
void BLI_insertlinkafter(ListBase *listbase, void *vprevlink, void *vnewlink)
Definition: listbase.c:301
void BLI_remlink(ListBase *listbase, void *vlink)
Definition: listbase.c:100
void * BLI_listbase_string_or_index_find(const ListBase *listbase, const char *string, const size_t string_offset, const int index)
Definition: listbase.c:717
void BLI_listbase_rotate_last(ListBase *lb, void *vlink)
Definition: listbase.c:829
bool BLI_listbase_link_move(ListBase *listbase, void *vlink, int step)
Definition: listbase.c:405
void BLI_listbase_reverse(ListBase *lb)
Definition: listbase.c:797
void BLI_movelisttolist_reverse(ListBase *dst, ListBase *src)
Definition: listbase.c:41
void BLI_freelist(ListBase *listbase)
Definition: listbase.c:452
void * BLI_findstring(const ListBase *listbase, const char *id, const int offset)
Definition: listbase.c:571
void BLI_listbase_sort_r(ListBase *listbase, int(*cmp)(void *, const void *, const void *), void *thunk)
Definition: listbase.c:290
void * BLI_rfindptr(const ListBase *listbase, const void *ptr, const int offset)
Definition: listbase.c:659
bool BLI_listbase_move_index(ListBase *listbase, int from, int to)
Definition: listbase.c:436
void BLI_insertlinkreplace(ListBase *listbase, void *vreplacelink, void *vnewlink)
Definition: listbase.c:379
void BLI_addhead(ListBase *listbase, void *vlink)
Definition: listbase.c:60
void BLI_movelisttolist(ListBase *dst, ListBase *src)
Definition: listbase.c:23
void BLI_insertlinkbefore(ListBase *listbase, void *vnextlink, void *vnewlink)
Definition: listbase.c:340
int BLI_findindex(const ListBase *listbase, const void *vlink)
Definition: listbase.c:549
void BLI_listbase_sort(ListBase *listbase, int(*cmp)(const void *, const void *))
Definition: listbase.c:281
void * BLI_rfindlink(const ListBase *listbase, int number)
Definition: listbase.c:519
void * BLI_pophead(ListBase *listbase)
Definition: listbase.c:221
void * BLI_rfindstring_ptr(const ListBase *listbase, const char *id, const int offset)
Definition: listbase.c:624
void BLI_duplicatelist(ListBase *dst, const ListBase *src)
Definition: listbase.c:781
void BLI_listbase_swaplinks(ListBase *listbase, void *vlinka, void *vlinkb)
Definition: listbase.c:133
int BLI_listbase_count(const ListBase *listbase)
Definition: listbase.c:492
void * BLI_poptail(ListBase *listbase)
Definition: listbase.c:230
void BLI_listbases_swaplinks(ListBase *listbasea, ListBase *listbaseb, void *vlinka, void *vlinkb)
Definition: listbase.c:186
void BLI_freelinkN(ListBase *listbase, void *vlink)
Definition: listbase.c:239
int BLI_findstringindex(const ListBase *listbase, const char *id, const int offset)
Definition: listbase.c:741
void * BLI_findlinkfrom(Link *start, int number)
Definition: listbase.c:534
void * BLI_listbase_bytes_find(const ListBase *listbase, const void *bytes, const size_t bytes_size, const int offset)
Definition: listbase.c:678
void BLI_freelistN(ListBase *listbase)
Definition: listbase.c:466
LinkData * BLI_genericNodeN(void *data)
Definition: listbase.c:842
void * BLI_findptr(const ListBase *listbase, const void *ptr, const int offset)
Definition: listbase.c:643
ListBase BLI_listbase_from_link(Link *some_link)
Definition: listbase.c:761
void BLI_addtail(ListBase *listbase, void *vlink)
Definition: listbase.c:80
void * BLI_listbase_bytes_rfind(const ListBase *listbase, const void *bytes, const size_t bytes_size, const int offset)
Definition: listbase.c:696
void * BLI_findlink(const ListBase *listbase, int number)
Definition: listbase.c:504
static void listbase_double_from_single(Link *iter, ListBase *listbase)
Definition: listbase.c:254
void * BLI_findstring_ptr(const ListBase *listbase, const char *id, const int offset)
Definition: listbase.c:608
void BLI_listbase_rotate_first(ListBase *lb, void *vlink)
Definition: listbase.c:816
bool BLI_remlink_safe(ListBase *listbase, void *vlink)
Definition: listbase.c:123
void * BLI_rfindstring(const ListBase *listbase, const char *id, const int offset)
Definition: listbase.c:590
int BLI_listbase_count_at_most(const ListBase *listbase, const int count_max)
Definition: listbase.c:480
void(* MEM_freeN)(void *vmemh)
Definition: mallocn.c:27
void *(* MEM_dupallocN)(const void *vmemh)
Definition: mallocn.c:28
void *(* MEM_callocN)(size_t len, const char *str)
Definition: mallocn.c:31
static ulong * next
T abs(const T &a)
SymEdge< T > * prev(const SymEdge< T > *se)
Definition: delaunay_2d.cc:105
void * data
Definition: DNA_listBase.h:26
void * last
Definition: DNA_listBase.h:31
void * first
Definition: DNA_listBase.h:31
PointerRNA * ptr
Definition: wm_files.c:3480