Blender  V3.3
BLI_map_test.cc
Go to the documentation of this file.
1 /* SPDX-License-Identifier: Apache-2.0 */
2 
4 #include "BLI_map.hh"
5 #include "BLI_rand.h"
6 #include "BLI_set.hh"
7 #include "BLI_strict_flags.h"
8 #include "BLI_timeit.hh"
9 #include "BLI_vector.hh"
10 #include "testing/testing.h"
11 #include <memory>
12 
13 namespace blender::tests {
14 
15 TEST(map, DefaultConstructor)
16 {
18  EXPECT_EQ(map.size(), 0);
19  EXPECT_TRUE(map.is_empty());
20 }
21 
22 TEST(map, AddIncreasesSize)
23 {
25  EXPECT_EQ(map.size(), 0);
26  EXPECT_TRUE(map.is_empty());
27  map.add(2, 5.0f);
28  EXPECT_EQ(map.size(), 1);
29  EXPECT_FALSE(map.is_empty());
30  map.add(6, 2.0f);
31  EXPECT_EQ(map.size(), 2);
32  EXPECT_FALSE(map.is_empty());
33 }
34 
35 TEST(map, Contains)
36 {
38  EXPECT_FALSE(map.contains(4));
39  map.add(5, 6.0f);
40  EXPECT_FALSE(map.contains(4));
41  map.add(4, 2.0f);
42  EXPECT_TRUE(map.contains(4));
43 }
44 
45 TEST(map, LookupExisting)
46 {
48  map.add(2, 6.0f);
49  map.add(4, 1.0f);
50  EXPECT_EQ(map.lookup(2), 6.0f);
51  EXPECT_EQ(map.lookup(4), 1.0f);
52 }
53 
54 TEST(map, LookupNotExisting)
55 {
57  map.add(2, 4.0f);
58  map.add(1, 1.0f);
59  EXPECT_EQ(map.lookup_ptr(0), nullptr);
60  EXPECT_EQ(map.lookup_ptr(5), nullptr);
61 }
62 
63 TEST(map, AddMany)
64 {
66  for (int i = 0; i < 100; i++) {
67  map.add(i * 30, i);
68  map.add(i * 31, i);
69  }
70 }
71 
72 TEST(map, PopItem)
73 {
75  map.add(2, 3.0f);
76  map.add(1, 9.0f);
77  EXPECT_TRUE(map.contains(2));
78  EXPECT_TRUE(map.contains(1));
79 
80  EXPECT_EQ(map.pop(1), 9.0f);
81  EXPECT_TRUE(map.contains(2));
82  EXPECT_FALSE(map.contains(1));
83 
84  EXPECT_EQ(map.pop(2), 3.0f);
85  EXPECT_FALSE(map.contains(2));
86  EXPECT_FALSE(map.contains(1));
87 }
88 
89 TEST(map, PopTry)
90 {
92  map.add(1, 5);
93  map.add(2, 7);
94  EXPECT_EQ(map.size(), 2);
95  std::optional<int> value = map.pop_try(4);
96  EXPECT_EQ(map.size(), 2);
97  EXPECT_FALSE(value.has_value());
98  value = map.pop_try(2);
99  EXPECT_EQ(map.size(), 1);
100  EXPECT_TRUE(value.has_value());
101  EXPECT_EQ(*value, 7);
102  EXPECT_EQ(*map.pop_try(1), 5);
103  EXPECT_EQ(map.size(), 0);
104 }
105 
106 TEST(map, PopDefault)
107 {
109  map.add(1, 4);
110  map.add(2, 7);
111  map.add(3, 8);
112  EXPECT_EQ(map.size(), 3);
113  EXPECT_EQ(map.pop_default(4, 10), 10);
114  EXPECT_EQ(map.size(), 3);
115  EXPECT_EQ(map.pop_default(1, 10), 4);
116  EXPECT_EQ(map.size(), 2);
117  EXPECT_EQ(map.pop_default(2, 20), 7);
118  EXPECT_EQ(map.size(), 1);
119  EXPECT_EQ(map.pop_default(2, 20), 20);
120  EXPECT_EQ(map.size(), 1);
121  EXPECT_EQ(map.pop_default(3, 0), 8);
122  EXPECT_EQ(map.size(), 0);
123 }
124 
125 TEST(map, PopItemMany)
126 {
128  for (int i = 0; i < 100; i++) {
129  map.add_new(i, i);
130  }
131  for (int i = 25; i < 80; i++) {
132  EXPECT_EQ(map.pop(i), i);
133  }
134  for (int i = 0; i < 100; i++) {
135  EXPECT_EQ(map.contains(i), i < 25 || i >= 80);
136  }
137 }
138 
139 TEST(map, ValueIterator)
140 {
142  map.add(3, 5.0f);
143  map.add(1, 2.0f);
144  map.add(7, -2.0f);
145 
146  blender::Set<float> values;
147 
148  int iterations = 0;
149  for (float value : map.values()) {
150  values.add(value);
151  iterations++;
152  }
153 
154  EXPECT_EQ(iterations, 3);
155  EXPECT_TRUE(values.contains(5.0f));
156  EXPECT_TRUE(values.contains(-2.0f));
157  EXPECT_TRUE(values.contains(2.0f));
158 }
159 
160 TEST(map, KeyIterator)
161 {
163  map.add(6, 3.0f);
164  map.add(2, 4.0f);
165  map.add(1, 3.0f);
166 
167  blender::Set<int> keys;
168 
169  int iterations = 0;
170  for (int key : map.keys()) {
171  keys.add(key);
172  iterations++;
173  }
174 
175  EXPECT_EQ(iterations, 3);
176  EXPECT_TRUE(keys.contains(1));
177  EXPECT_TRUE(keys.contains(2));
178  EXPECT_TRUE(keys.contains(6));
179 }
180 
181 TEST(map, ItemIterator)
182 {
184  map.add(5, 3.0f);
185  map.add(2, 9.0f);
186  map.add(1, 0.0f);
187 
188  blender::Set<int> keys;
189  blender::Set<float> values;
190 
191  int iterations = 0;
192  const Map<int, float> &const_map = map;
193  for (auto item : const_map.items()) {
194  keys.add(item.key);
195  values.add(item.value);
196  iterations++;
197  }
198 
199  EXPECT_EQ(iterations, 3);
200  EXPECT_TRUE(keys.contains(5));
201  EXPECT_TRUE(keys.contains(2));
202  EXPECT_TRUE(keys.contains(1));
203  EXPECT_TRUE(values.contains(3.0f));
204  EXPECT_TRUE(values.contains(9.0f));
205  EXPECT_TRUE(values.contains(0.0f));
206 }
207 
208 TEST(map, MutableValueIterator)
209 {
211  map.add(3, 6);
212  map.add(2, 1);
213 
214  for (int &value : map.values()) {
215  value += 10;
216  }
217 
218  EXPECT_EQ(map.lookup(3), 16);
219  EXPECT_EQ(map.lookup(2), 11);
220 }
221 
222 TEST(map, MutableItemIterator)
223 {
225  map.add(3, 6);
226  map.add(2, 1);
227 
228  for (auto item : map.items()) {
229  item.value += item.key;
230  }
231 
232  EXPECT_EQ(map.lookup(3), 9.0f);
233  EXPECT_EQ(map.lookup(2), 3.0f);
234 }
235 
236 TEST(map, MutableItemToItemConversion)
237 {
239  map.add(3, 6);
240  map.add(2, 1);
241 
242  Vector<int> keys, values;
243  for (Map<int, int>::Item item : map.items()) {
244  keys.append(item.key);
245  values.append(item.value);
246  }
247 
248  EXPECT_EQ(keys.size(), 2);
249  EXPECT_EQ(values.size(), 2);
250  EXPECT_TRUE(keys.contains(3));
251  EXPECT_TRUE(keys.contains(2));
252  EXPECT_TRUE(values.contains(6));
253  EXPECT_TRUE(values.contains(1));
254 }
255 
256 static float return_42()
257 {
258  return 42.0f;
259 }
260 
261 TEST(map, LookupOrAddCB_SeparateFunction)
262 {
264  EXPECT_EQ(map.lookup_or_add_cb(0, return_42), 42.0f);
265  EXPECT_EQ(map.lookup(0), 42);
266 
267  map.keys();
268 }
269 
270 TEST(map, LookupOrAddCB_Lambdas)
271 {
273  auto lambda1 = []() { return 11.0f; };
274  EXPECT_EQ(map.lookup_or_add_cb(0, lambda1), 11.0f);
275  auto lambda2 = []() { return 20.0f; };
276  EXPECT_EQ(map.lookup_or_add_cb(1, lambda2), 20.0f);
277 
278  EXPECT_EQ(map.lookup_or_add_cb(0, lambda2), 11.0f);
279  EXPECT_EQ(map.lookup_or_add_cb(1, lambda1), 20.0f);
280 }
281 
282 TEST(map, AddOrModify)
283 {
285  auto create_func = [](float *value) {
286  *value = 10.0f;
287  return true;
288  };
289  auto modify_func = [](float *value) {
290  *value += 5;
291  return false;
292  };
293  EXPECT_TRUE(map.add_or_modify(1, create_func, modify_func));
294  EXPECT_EQ(map.lookup(1), 10.0f);
295  EXPECT_FALSE(map.add_or_modify(1, create_func, modify_func));
296  EXPECT_EQ(map.lookup(1), 15.0f);
297 }
298 
299 TEST(map, AddOrModifyReference)
300 {
302  auto create_func = [](std::unique_ptr<int> *value) -> int & {
303  new (value) std::unique_ptr<int>(new int{10});
304  return **value;
305  };
306  auto modify_func = [](std::unique_ptr<int> *value) -> int & {
307  **value += 5;
308  return **value;
309  };
310  EXPECT_EQ(map.add_or_modify(1, create_func, modify_func), 10);
311  int &a = map.add_or_modify(1, create_func, modify_func);
312  EXPECT_EQ(a, 15);
313  a = 100;
314  EXPECT_EQ(*map.lookup(1), 100);
315 }
316 
317 TEST(map, AddOverwrite)
318 {
320  EXPECT_FALSE(map.contains(3));
321  EXPECT_TRUE(map.add_overwrite(3, 6.0f));
322  EXPECT_EQ(map.lookup(3), 6.0f);
323  EXPECT_FALSE(map.add_overwrite(3, 7.0f));
324  EXPECT_EQ(map.lookup(3), 7.0f);
325  EXPECT_FALSE(map.add(3, 8.0f));
326  EXPECT_EQ(map.lookup(3), 7.0f);
327 }
328 
329 TEST(map, LookupOrAddDefault)
330 {
332  map.lookup_or_add_default(3) = 6;
333  EXPECT_EQ(map.lookup(3), 6);
334  map.lookup_or_add_default(5) = 2;
335  EXPECT_EQ(map.lookup(5), 2);
336  map.lookup_or_add_default(3) += 4;
337  EXPECT_EQ(map.lookup(3), 10);
338 }
339 
340 TEST(map, LookupOrAdd)
341 {
343  EXPECT_EQ(map.lookup_or_add(6, 4), 4);
344  EXPECT_EQ(map.lookup_or_add(6, 5), 4);
345  map.lookup_or_add(6, 4) += 10;
346  EXPECT_EQ(map.lookup(6), 14);
347 }
348 
349 TEST(map, MoveConstructorSmall)
350 {
351  Map<int, float> map1;
352  map1.add(1, 2.0f);
353  map1.add(4, 1.0f);
354  Map<int, float> map2(std::move(map1));
355  EXPECT_EQ(map2.size(), 2);
356  EXPECT_EQ(map2.lookup(1), 2.0f);
357  EXPECT_EQ(map2.lookup(4), 1.0f);
358  EXPECT_EQ(map1.size(), 0); /* NOLINT: bugprone-use-after-move */
359  EXPECT_EQ(map1.lookup_ptr(4), nullptr);
360 }
361 
362 TEST(map, MoveConstructorLarge)
363 {
364  Map<int, int> map1;
365  for (int i = 0; i < 100; i++) {
366  map1.add_new(i, i);
367  }
368  Map<int, int> map2(std::move(map1));
369  EXPECT_EQ(map2.size(), 100);
370  EXPECT_EQ(map2.lookup(1), 1);
371  EXPECT_EQ(map2.lookup(4), 4);
372  EXPECT_EQ(map1.size(), 0); /* NOLINT: bugprone-use-after-move */
373  EXPECT_EQ(map1.lookup_ptr(4), nullptr);
374 }
375 
376 TEST(map, MoveAssignment)
377 {
378  Map<int, float> map1;
379  map1.add(1, 2.0f);
380  map1.add(4, 1.0f);
381  Map<int, float> map2;
382  map2 = std::move(map1);
383  EXPECT_EQ(map2.size(), 2);
384  EXPECT_EQ(map2.lookup(1), 2.0f);
385  EXPECT_EQ(map2.lookup(4), 1.0f);
386  EXPECT_EQ(map1.size(), 0); /* NOLINT: bugprone-use-after-move */
387  EXPECT_EQ(map1.lookup_ptr(4), nullptr);
388 }
389 
390 TEST(map, CopyAssignment)
391 {
392  Map<int, float> map1;
393  map1.add(1, 2.0f);
394  map1.add(4, 1.0f);
395  Map<int, float> map2;
396  map2 = map1;
397  EXPECT_EQ(map2.size(), 2);
398  EXPECT_EQ(map2.lookup(1), 2.0f);
399  EXPECT_EQ(map2.lookup(4), 1.0f);
400  EXPECT_EQ(map1.size(), 2);
401  EXPECT_EQ(*map1.lookup_ptr(4), 1.0f);
402 }
403 
404 TEST(map, Clear)
405 {
407  map.add(1, 1.0f);
408  map.add(2, 5.0f);
409 
410  EXPECT_EQ(map.size(), 2);
411  EXPECT_TRUE(map.contains(1));
412  EXPECT_TRUE(map.contains(2));
413 
414  map.clear();
415 
416  EXPECT_EQ(map.size(), 0);
417  EXPECT_FALSE(map.contains(1));
418  EXPECT_FALSE(map.contains(2));
419 }
420 
421 TEST(map, UniquePtrValue)
422 {
423  auto value1 = std::make_unique<int>();
424  auto value2 = std::make_unique<int>();
425  auto value3 = std::make_unique<int>();
426 
427  int *value1_ptr = value1.get();
428 
430  map.add_new(1, std::move(value1));
431  map.add(2, std::move(value2));
432  map.add_overwrite(3, std::move(value3));
433  map.lookup_or_add_cb(4, []() { return std::make_unique<int>(); });
434  map.add_new(5, std::make_unique<int>());
435  map.add(6, std::make_unique<int>());
436  map.add_overwrite(7, std::make_unique<int>());
437  map.lookup_or_add(8, std::make_unique<int>());
438  map.pop_default(9, std::make_unique<int>());
439 
440  EXPECT_EQ(map.lookup(1).get(), value1_ptr);
441  EXPECT_EQ(map.lookup_ptr(100), nullptr);
442 }
443 
444 TEST(map, Remove)
445 {
447  map.add(2, 4);
448  EXPECT_EQ(map.size(), 1);
449  EXPECT_FALSE(map.remove(3));
450  EXPECT_EQ(map.size(), 1);
451  EXPECT_TRUE(map.remove(2));
452  EXPECT_EQ(map.size(), 0);
453 }
454 
455 TEST(map, PointerKeys)
456 {
457  char a, b, c, d;
458 
460  EXPECT_TRUE(map.add(&a, 5));
461  EXPECT_FALSE(map.add(&a, 4));
462  map.add_new(&b, 1);
463  map.add_new(&c, 1);
464  EXPECT_EQ(map.size(), 3);
465  EXPECT_TRUE(map.remove(&b));
466  EXPECT_TRUE(map.add(&b, 8));
467  EXPECT_FALSE(map.remove(&d));
468  EXPECT_TRUE(map.remove(&a));
469  EXPECT_TRUE(map.remove(&b));
470  EXPECT_TRUE(map.remove(&c));
471  EXPECT_TRUE(map.is_empty());
472 }
473 
474 TEST(map, ConstKeysAndValues)
475 {
477  map.reserve(10);
478  map.add("45", "643");
479  EXPECT_TRUE(map.contains("45"));
480  EXPECT_FALSE(map.contains("54"));
481 }
482 
483 TEST(map, ForeachItem)
484 {
486  map.add(3, 4);
487  map.add(1, 8);
488 
489  Vector<int> keys;
490  Vector<int> values;
491  map.foreach_item([&](int key, int value) {
492  keys.append(key);
493  values.append(value);
494  });
495 
496  EXPECT_EQ(keys.size(), 2);
497  EXPECT_EQ(values.size(), 2);
498  EXPECT_EQ(keys.first_index_of(3), values.first_index_of(4));
499  EXPECT_EQ(keys.first_index_of(1), values.first_index_of(8));
500 }
501 
502 TEST(map, CopyConstructorExceptions)
503 {
505  MapType map;
506  map.add(2, 2);
507  map.add(4, 4);
508  map.lookup(2).throw_during_copy = true;
509  EXPECT_ANY_THROW({ MapType map_copy(map); });
510 }
511 
512 TEST(map, MoveConstructorExceptions)
513 {
515  MapType map;
516  map.add(1, 1);
517  map.add(2, 2);
518  map.lookup(1).throw_during_move = true;
519  EXPECT_ANY_THROW({ MapType map_moved(std::move(map)); });
520  map.add(5, 5); /* NOLINT: bugprone-use-after-move */
521 }
522 
523 TEST(map, AddNewExceptions)
524 {
526  ExceptionThrower key1 = 1;
527  key1.throw_during_copy = true;
528  ExceptionThrower value1;
529  EXPECT_ANY_THROW({ map.add_new(key1, value1); });
530  EXPECT_EQ(map.size(), 0);
531  ExceptionThrower key2 = 2;
532  ExceptionThrower value2;
533  value2.throw_during_copy = true;
534  EXPECT_ANY_THROW({ map.add_new(key2, value2); });
535 }
536 
537 TEST(map, ReserveExceptions)
538 {
540  map.add(3, 3);
541  map.add(5, 5);
542  map.add(2, 2);
543  map.lookup(2).throw_during_move = true;
544  EXPECT_ANY_THROW({ map.reserve(100); });
545  map.add(1, 1);
546  map.add(5, 5);
547 }
548 
549 TEST(map, PopExceptions)
550 {
552  map.add(3, 3);
553  map.lookup(3).throw_during_move = true;
554  EXPECT_ANY_THROW({ map.pop(3); }); /* NOLINT: bugprone-throw-keyword-missing */
555  EXPECT_EQ(map.size(), 1);
556  map.add(1, 1);
557  EXPECT_EQ(map.size(), 2);
558 }
559 
560 TEST(map, AddOrModifyExceptions)
561 {
563  auto create_fn = [](ExceptionThrower *UNUSED(v)) { throw std::runtime_error(""); };
564  auto modify_fn = [](ExceptionThrower *UNUSED(v)) {};
565  EXPECT_ANY_THROW({ map.add_or_modify(3, create_fn, modify_fn); });
566 }
567 
568 namespace {
569 enum class TestEnum {
570  A = 0,
571  B = 1,
572  C = 2,
573  D = 1,
574 };
575 }
576 
577 TEST(map, EnumKey)
578 {
580  map.add(TestEnum::A, 4);
581  map.add(TestEnum::B, 6);
582  EXPECT_EQ(map.lookup(TestEnum::A), 4);
583  EXPECT_EQ(map.lookup(TestEnum::B), 6);
584  EXPECT_EQ(map.lookup(TestEnum::D), 6);
585  EXPECT_FALSE(map.contains(TestEnum::C));
586  map.lookup(TestEnum::D) = 10;
587  EXPECT_EQ(map.lookup(TestEnum::B), 10);
588 }
589 
590 TEST(map, GenericAlgorithms)
591 {
593  map.add(5, 2);
594  map.add(1, 4);
595  map.add(2, 2);
596  map.add(7, 1);
597  map.add(8, 6);
598  EXPECT_TRUE(std::any_of(map.keys().begin(), map.keys().end(), [](int v) { return v == 1; }));
599  EXPECT_TRUE(std::any_of(map.values().begin(), map.values().end(), [](int v) { return v == 1; }));
600  EXPECT_TRUE(std::any_of(
601  map.items().begin(), map.items().end(), [](auto item) { return item.value == 1; }));
602  EXPECT_EQ(std::count(map.values().begin(), map.values().end(), 2), 2);
603  EXPECT_EQ(std::count(map.values().begin(), map.values().end(), 4), 1);
604  EXPECT_EQ(std::count(map.keys().begin(), map.keys().end(), 7), 1);
605 }
606 
607 TEST(map, AddAsVariadic)
608 {
610  map.add_as(3, "hello", 2);
611  map.add_as(2, "test", 1);
612  EXPECT_EQ(map.lookup(3), "he");
613  EXPECT_EQ(map.lookup(2), "t");
614 }
615 
616 TEST(map, RemoveDuringIteration)
617 {
619  map.add(2, 1);
620  map.add(5, 2);
621  map.add(1, 2);
622  map.add(6, 0);
623  map.add(3, 3);
624 
625  EXPECT_EQ(map.size(), 5);
626 
628  Iter begin = map.items().begin();
629  Iter end = map.items().end();
630  for (Iter iter = begin; iter != end; ++iter) {
631  Map<int, int>::MutableItem item = *iter;
632  if (item.value == 2) {
633  map.remove(iter);
634  }
635  }
636 
637  EXPECT_EQ(map.size(), 3);
638  EXPECT_EQ(map.lookup(2), 1);
639  EXPECT_EQ(map.lookup(6), 0);
640  EXPECT_EQ(map.lookup(3), 3);
641 }
642 
643 TEST(map, LookupKey)
644 {
646  map.add("a", 0);
647  map.add("b", 1);
648  map.add("c", 2);
649  EXPECT_EQ(map.lookup_key("a"), "a");
650  EXPECT_EQ(map.lookup_key_as("c"), "c");
651  EXPECT_EQ(map.lookup_key_ptr_as("d"), nullptr);
652  EXPECT_EQ(map.lookup_key_ptr_as("b")->size(), 1);
653  EXPECT_EQ(map.lookup_key_ptr("a"), map.lookup_key_ptr_as("a"));
654 }
655 
659 #if 0
660 template<typename MapT>
661 BLI_NOINLINE void benchmark_random_ints(StringRef name, int amount, int factor)
662 {
663  RNG *rng = BLI_rng_new(0);
664  Vector<int> values;
665  for (int i = 0; i < amount; i++) {
666  values.append(BLI_rng_get_int(rng) * factor);
667  }
668  BLI_rng_free(rng);
669 
670  MapT map;
671  {
672  SCOPED_TIMER(name + " Add");
673  for (int value : values) {
674  map.add(value, value);
675  }
676  }
677  int count = 0;
678  {
679  SCOPED_TIMER(name + " Contains");
680  for (int value : values) {
681  count += map.contains(value);
682  }
683  }
684  {
685  SCOPED_TIMER(name + " Remove");
686  for (int value : values) {
687  count += map.remove(value);
688  }
689  }
690 
691  /* Print the value for simple error checking and to avoid some compiler optimizations. */
692  std::cout << "Count: " << count << "\n";
693 }
694 
695 TEST(map, Benchmark)
696 {
697  for (int i = 0; i < 3; i++) {
698  benchmark_random_ints<blender::Map<int, int>>("blender::Map ", 1000000, 1);
699  benchmark_random_ints<blender::StdUnorderedMapWrapper<int, int>>("std::unordered_map", 1000000, 1);
700  }
701  std::cout << "\n";
702  for (int i = 0; i < 3; i++) {
703  uint32_t factor = (3 << 10);
704  benchmark_random_ints<blender::Map<int, int>>("blender::Map ", 1000000, factor);
705  benchmark_random_ints<blender::StdUnorderedMapWrapper<int, int>>(
706  "std::unordered_map", 1000000, factor);
707  }
708 }
709 
762 #endif /* Benchmark */
763 
764 } // namespace blender::tests
#define D
#define BLI_NOINLINE
EXPECT_EQ(BLI_expr_pylike_eval(expr, nullptr, 0, &result), EXPR_PYLIKE_INVALID)
Random number functions.
void int BLI_rng_get_int(struct RNG *rng) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition: rand.cc:78
void BLI_rng_free(struct RNG *rng) ATTR_NONNULL(1)
Definition: rand.cc:58
struct RNG * BLI_rng_new(unsigned int seed)
Definition: rand.cc:39
Strict compiler flags for areas of code we want to ensure don't do conversions without us knowing abo...
#define SCOPED_TIMER(name)
Definition: BLI_timeit.hh:68
#define UNUSED(x)
#define C
Definition: RandGen.cpp:25
ATTR_WARN_UNUSED_RESULT const BMVert * v
#define A
bool add(const Key &key, const Value &value)
Definition: BLI_map.hh:250
const Value & lookup(const Key &key) const
Definition: BLI_map.hh:485
void add_new(const Key &key, const Value &value)
Definition: BLI_map.hh:220
int64_t size() const
Definition: BLI_map.hh:901
ItemIterator items() const
Definition: BLI_map.hh:859
const Value * lookup_ptr(const Key &key) const
Definition: BLI_map.hh:463
bool contains(const Key &key) const
Definition: BLI_set.hh:296
bool add(const Key &key)
Definition: BLI_set.hh:253
int64_t size() const
Definition: BLI_vector.hh:694
bool contains(const T &value) const
Definition: BLI_vector.hh:837
void append(const T &value)
Definition: BLI_vector.hh:433
int64_t first_index_of(const T &value) const
Definition: BLI_vector.hh:826
int count
#define B
static unsigned c
Definition: RandGen.cpp:83
static unsigned a[3]
Definition: RandGen.cpp:78
static float return_42()
TEST(any, DefaultConstructor)
Definition: BLI_any_test.cc:10
static const pxr::TfToken b("b", pxr::TfToken::Immortal)
SocketIndexByIdentifierMap * map
static PyObject * create_func(PyObject *, PyObject *args)
Definition: python.cpp:156
unsigned int uint32_t
Definition: stdint.h:80
Definition: rand.cc:33
BLI_INLINE float D(const float *data, const int res[3], int x, int y, int z)
Definition: voxel.c:13