1 #include <algorithm>
2 #include <tuple>
3 #include <utility>
4 #include <type_traits>
5 #include <gtest/gtest.h>
6 #include <entt/entity/component.hpp>
7 #include <entt/entity/registry.hpp>
8 #include <entt/entity/view.hpp>
9
10 struct empty_type {};
11 struct stable_type { int value; };
12
13 template<>
14 struct entt::component_traits<stable_type>: basic_component_traits {
15 using in_place_delete = std::true_type;
16 };
17
TEST(SingleComponentView,Functionalities)18 TEST(SingleComponentView, Functionalities) {
19 entt::registry registry;
20 auto view = registry.view<char>();
21 auto cview = std::as_const(registry).view<const char>();
22
23 const auto e0 = registry.create();
24 const auto e1 = registry.create();
25
26 ASSERT_TRUE(view.empty());
27
28 registry.emplace<int>(e1);
29 registry.emplace<char>(e1);
30
31 ASSERT_NO_FATAL_FAILURE(view.begin()++);
32 ASSERT_NO_FATAL_FAILURE(++cview.begin());
33 ASSERT_NO_FATAL_FAILURE([](auto it) { return it++; }(view.rbegin()));
34 ASSERT_NO_FATAL_FAILURE([](auto it) { return ++it; }(cview.rbegin()));
35
36 ASSERT_NE(view.begin(), view.end());
37 ASSERT_NE(cview.begin(), cview.end());
38 ASSERT_NE(view.rbegin(), view.rend());
39 ASSERT_NE(cview.rbegin(), cview.rend());
40 ASSERT_EQ(view.size(), 1u);
41 ASSERT_FALSE(view.empty());
42
43 registry.emplace<char>(e0);
44
45 ASSERT_EQ(view.size(), 2u);
46
47 view.get<char>(e0) = '1';
48 std::get<0>(view.get(e1)) = '2';
49
50 for(auto entity: view) {
51 ASSERT_TRUE(cview.get<const char>(entity) == '1' || std::get<const char &>(cview.get(entity)) == '2');
52 }
53
54 ASSERT_EQ(view.data()[0u], e1);
55 ASSERT_EQ(view.data()[1u], e0);
56
57 ASSERT_EQ(view.raw()[0u][0u], '2');
58 ASSERT_EQ(cview.raw()[0u][1u], '1');
59
60 registry.erase<char>(e0);
61 registry.erase<char>(e1);
62
63 ASSERT_EQ(view.begin(), view.end());
64 ASSERT_EQ(view.rbegin(), view.rend());
65 ASSERT_TRUE(view.empty());
66
67 decltype(view) invalid{};
68
69 ASSERT_TRUE(view);
70 ASSERT_TRUE(cview);
71 ASSERT_FALSE(invalid);
72 }
73
TEST(SingleComponentView,RawData)74 TEST(SingleComponentView, RawData) {
75 entt::registry registry;
76 auto view = registry.view<int>();
77 auto cview = std::as_const(registry).view<const int>();
78
79 const auto entity = registry.create();
80
81 ASSERT_EQ(view.size(), 0u);
82 ASSERT_EQ(cview.size(), 0u);
83 ASSERT_EQ(view.raw(), cview.raw());
84 ASSERT_EQ(view.data(), cview.data());
85
86 registry.emplace<int>(entity, 42);
87
88 ASSERT_NE(view.size(), 0u);
89 ASSERT_NE(cview.size(), 0u);
90 ASSERT_EQ(view.raw()[0u][0u], 42);
91 ASSERT_EQ(cview.raw()[0u][0u], 42);
92 ASSERT_EQ(view.data()[0u], entity);
93 ASSERT_EQ(cview.data()[0u], entity);
94
95 registry.destroy(entity);
96
97 ASSERT_EQ(view.size(), 0u);
98 ASSERT_EQ(cview.size(), 0u);
99 }
100
TEST(SingleComponentView,LazyTypeFromConstRegistry)101 TEST(SingleComponentView, LazyTypeFromConstRegistry) {
102 entt::registry registry{};
103 auto eview = std::as_const(registry).view<const empty_type>();
104 auto cview = std::as_const(registry).view<const int>();
105
106 const auto entity = registry.create();
107 registry.emplace<empty_type>(entity);
108 registry.emplace<int>(entity);
109
110 ASSERT_TRUE(cview);
111 ASSERT_TRUE(eview);
112
113 ASSERT_NE(cview.raw(), nullptr);
114 ASSERT_NE(eview.data(), nullptr);
115
116 ASSERT_FALSE(cview.empty());
117 ASSERT_EQ(eview.size(), 1u);
118 ASSERT_TRUE(cview.contains(entity));
119
120 ASSERT_NE(cview.begin(), cview.end());
121 ASSERT_NE(eview.rbegin(), eview.rend());
122 ASSERT_NE(eview.find(entity), eview.end());
123 ASSERT_EQ(cview.front(), entity);
124 ASSERT_EQ(eview.back(), entity);
125 }
126
TEST(SingleComponentView,ElementAccess)127 TEST(SingleComponentView, ElementAccess) {
128 entt::registry registry;
129 auto view = registry.view<int>();
130 auto cview = std::as_const(registry).view<const int>();
131
132 const auto e0 = registry.create();
133 registry.emplace<int>(e0);
134
135 const auto e1 = registry.create();
136 registry.emplace<int>(e1);
137
138 for(auto i = 0u; i < view.size(); ++i) {
139 ASSERT_EQ(view[i], i ? e0 : e1);
140 ASSERT_EQ(cview[i], i ? e0 : e1);
141 }
142 }
143
TEST(SingleComponentView,Contains)144 TEST(SingleComponentView, Contains) {
145 entt::registry registry;
146
147 const auto e0 = registry.create();
148 registry.emplace<int>(e0);
149
150 const auto e1 = registry.create();
151 registry.emplace<int>(e1);
152
153 registry.destroy(e0);
154
155 auto view = registry.view<int>();
156
157 ASSERT_FALSE(view.contains(e0));
158 ASSERT_TRUE(view.contains(e1));
159 }
160
TEST(SingleComponentView,Empty)161 TEST(SingleComponentView, Empty) {
162 entt::registry registry;
163
164 const auto e0 = registry.create();
165 registry.emplace<char>(e0);
166 registry.emplace<double>(e0);
167
168 const auto e1 = registry.create();
169 registry.emplace<char>(e1);
170
171 auto view = registry.view<int>();
172
173 ASSERT_EQ(view.size(), 0u);
174 ASSERT_EQ(view.begin(), view.end());
175 ASSERT_EQ(view.rbegin(), view.rend());
176 }
177
TEST(SingleComponentView,Each)178 TEST(SingleComponentView, Each) {
179 entt::registry registry;
180
181 registry.emplace<int>(registry.create(), 0);
182 registry.emplace<int>(registry.create(), 1);
183
184 auto view = registry.view<int>();
185 auto iterable = view.each();
186
187 auto cview = std::as_const(registry).view<const int>();
188 auto citerable = cview.each();
189
190 std::size_t cnt = 0;
191
192 for(auto first = citerable.rbegin(), last = citerable.rend(); first != last; ++first) {
193 static_assert(std::is_same_v<decltype(*first), std::tuple<entt::entity, const int &>>);
194 ASSERT_EQ(std::get<1>(*first), cnt++);
195 }
196
197 view.each([&cnt](auto, int &) { ++cnt; });
198 view.each([&cnt](int &) { ++cnt; });
199
200 ASSERT_EQ(cnt, std::size_t{6});
201
202 cview.each([&cnt](const int &) { --cnt; });
203 cview.each([&cnt](auto, const int &) { --cnt; });
204
205 // do not use iterable, make sure an iterable view works when created from a temporary
206 for(auto [entt, iv]: registry.view<int>().each()) {
207 static_assert(std::is_same_v<decltype(entt), entt::entity>);
208 static_assert(std::is_same_v<decltype(iv), int &>);
209 ASSERT_EQ(iv, --cnt);
210 }
211
212 ASSERT_EQ(cnt, std::size_t{0});
213
214 auto it = iterable.begin();
215 auto rit = iterable.rbegin();
216
217 ASSERT_EQ((it++, ++it), iterable.end());
218 ASSERT_EQ((rit++, ++rit), iterable.rend());
219 }
220
TEST(SingleComponentView,ConstNonConstAndAllInBetween)221 TEST(SingleComponentView, ConstNonConstAndAllInBetween) {
222 entt::registry registry;
223 auto view = registry.view<int>();
224 auto cview = std::as_const(registry).view<const int>();
225
226 ASSERT_EQ(view.size(), 0u);
227 ASSERT_EQ(cview.size(), 0u);
228
229 registry.emplace<int>(registry.create(), 0);
230
231 ASSERT_EQ(view.size(), 1u);
232 ASSERT_EQ(cview.size(), 1u);
233
234 static_assert(std::is_same_v<decltype(view.raw()), int **>);
235 static_assert(std::is_same_v<decltype(cview.raw()), const int * const *>);
236
237 static_assert(std::is_same_v<decltype(view.get<int>({})), int &>);
238 static_assert(std::is_same_v<decltype(view.get({})), std::tuple<int &>>);
239 static_assert(std::is_same_v<decltype(view.raw()), int **>);
240 static_assert(std::is_same_v<decltype(cview.get<const int>({})), const int &>);
241 static_assert(std::is_same_v<decltype(cview.get({})), std::tuple<const int &>>);
242 static_assert(std::is_same_v<decltype(cview.raw()), const int * const *>);
243
244 static_assert(std::is_same_v<decltype(std::as_const(registry).view<int>()), decltype(cview)>);
245
246 view.each([](auto &&i) {
247 static_assert(std::is_same_v<decltype(i), int &>);
248 });
249
250 cview.each([](auto &&i) {
251 static_assert(std::is_same_v<decltype(i), const int &>);
252 });
253
254 for(auto [entt, iv]: view.each()) {
255 static_assert(std::is_same_v<decltype(entt), entt::entity>);
256 static_assert(std::is_same_v<decltype(iv), int &>);
257 }
258
259 for(auto [entt, iv]: cview.each()) {
260 static_assert(std::is_same_v<decltype(entt), entt::entity>);
261 static_assert(std::is_same_v<decltype(iv), const int &>);
262 }
263 }
264
TEST(SingleComponentView,ConstNonConstAndAllInBetweenWithEmptyType)265 TEST(SingleComponentView, ConstNonConstAndAllInBetweenWithEmptyType) {
266 entt::registry registry;
267 auto view = registry.view<empty_type>();
268 auto cview = std::as_const(registry).view<const empty_type>();
269
270 ASSERT_EQ(view.size(), 0u);
271 ASSERT_EQ(cview.size(), 0u);
272
273 registry.emplace<empty_type>(registry.create());
274
275 ASSERT_EQ(view.size(), 1u);
276 ASSERT_EQ(cview.size(), 1u);
277
278 static_assert(std::is_same_v<decltype(view.get({})), std::tuple<>>);
279 static_assert(std::is_same_v<decltype(cview.get({})), std::tuple<>>);
280
281 static_assert(std::is_same_v<decltype(std::as_const(registry).view<empty_type>()), decltype(cview)>);
282
283 for(auto [entt]: view.each()) {
284 static_assert(std::is_same_v<decltype(entt), entt::entity>);
285 }
286
287 for(auto [entt]: cview.each()) {
288 static_assert(std::is_same_v<decltype(entt), entt::entity>);
289 }
290 }
291
TEST(SingleComponentView,Find)292 TEST(SingleComponentView, Find) {
293 entt::registry registry;
294 auto view = registry.view<int>();
295
296 const auto e0 = registry.create();
297 registry.emplace<int>(e0);
298
299 const auto e1 = registry.create();
300 registry.emplace<int>(e1);
301
302 const auto e2 = registry.create();
303 registry.emplace<int>(e2);
304
305 const auto e3 = registry.create();
306 registry.emplace<int>(e3);
307
308 registry.erase<int>(e1);
309
310 ASSERT_NE(view.find(e0), view.end());
311 ASSERT_EQ(view.find(e1), view.end());
312 ASSERT_NE(view.find(e2), view.end());
313 ASSERT_NE(view.find(e3), view.end());
314
315 auto it = view.find(e2);
316
317 ASSERT_EQ(*it, e2);
318 ASSERT_EQ(*(++it), e3);
319 ASSERT_EQ(*(++it), e0);
320 ASSERT_EQ(++it, view.end());
321 ASSERT_EQ(++view.find(e0), view.end());
322
323 const auto e4 = registry.create();
324 registry.destroy(e4);
325 const auto e5 = registry.create();
326 registry.emplace<int>(e5);
327
328 ASSERT_NE(view.find(e5), view.end());
329 ASSERT_EQ(view.find(e4), view.end());
330 }
331
TEST(SingleComponentView,EmptyTypes)332 TEST(SingleComponentView, EmptyTypes) {
333 entt::registry registry;
334 auto create = [&](auto... component) {
335 const auto entt = registry.create();
336 (registry.emplace<decltype(component)>(entt, component), ...);
337 return entt;
338 };
339
340 const auto entity = create(0, empty_type{});
341 create('c');
342
343 registry.view<empty_type>().each([entity](const auto entt) {
344 ASSERT_EQ(entity, entt);
345 });
346
347 registry.view<empty_type>().each([check = true]() mutable {
348 ASSERT_TRUE(check);
349 check = false;
350 });
351
352 for(auto [entt]: registry.view<empty_type>().each()) {
353 static_assert(std::is_same_v<decltype(entt), entt::entity>);
354 ASSERT_EQ(entity, entt);
355 }
356
357 registry.view<int>().each([entity](const auto entt, int) {
358 ASSERT_EQ(entity, entt);
359 });
360
361 registry.view<int>().each([check = true](int) mutable {
362 ASSERT_TRUE(check);
363 check = false;
364 });
365
366 for(auto [entt, iv]: registry.view<int>().each()) {
367 static_assert(std::is_same_v<decltype(entt), entt::entity>);
368 static_assert(std::is_same_v<decltype(iv), int &>);
369 ASSERT_EQ(entity, entt);
370 }
371 }
372
TEST(SingleComponentView,FrontBack)373 TEST(SingleComponentView, FrontBack) {
374 entt::registry registry;
375 auto view = registry.view<const int>();
376
377 ASSERT_EQ(view.front(), static_cast<entt::entity>(entt::null));
378 ASSERT_EQ(view.back(), static_cast<entt::entity>(entt::null));
379
380 const auto e0 = registry.create();
381 registry.emplace<int>(e0);
382
383 const auto e1 = registry.create();
384 registry.emplace<int>(e1);
385
386 ASSERT_EQ(view.front(), e1);
387 ASSERT_EQ(view.back(), e0);
388 }
389
TEST(SingleComponentView,DeductionGuide)390 TEST(SingleComponentView, DeductionGuide) {
391 entt::registry registry;
392 typename entt::storage_traits<entt::entity, int>::storage_type istorage;
393 typename entt::storage_traits<entt::entity, stable_type>::storage_type sstorage;
394
395 static_assert(std::is_same_v<entt::basic_view<entt::entity, entt::exclude_t<>, int>, decltype(entt::basic_view{istorage})>);
396 static_assert(std::is_same_v<entt::basic_view<entt::entity, entt::exclude_t<>, const int>, decltype(entt::basic_view{std::as_const(istorage)})>);
397 static_assert(std::is_same_v<entt::basic_view<entt::entity, entt::exclude_t<>, stable_type>, decltype(entt::basic_view{sstorage})>);
398
399 static_assert(std::is_base_of_v<entt::basic_view_impl<entt::packed_storage_policy, entt::entity, entt::exclude_t<>, int>, decltype(entt::basic_view{istorage})>);
400 static_assert(std::is_base_of_v<entt::basic_view_impl<entt::packed_storage_policy, entt::entity, entt::exclude_t<>, const int>, decltype(entt::basic_view{std::as_const(istorage)})>);
401 static_assert(std::is_base_of_v<entt::basic_view_impl<entt::stable_storage_policy, entt::entity, entt::exclude_t<>, stable_type>, decltype(entt::basic_view{sstorage})>);
402 }
403
TEST(SingleComponentView,IterableViewAlgorithmCompatibility)404 TEST(SingleComponentView, IterableViewAlgorithmCompatibility) {
405 entt::registry registry;
406 const auto entity = registry.create();
407
408 registry.emplace<int>(entity);
409
410 const auto view = registry.view<int>();
411 const auto iterable = view.each();
412 const auto it = std::find_if(iterable.begin(), iterable.end(), [entity](auto args) { return std::get<0>(args) == entity; });
413
414 ASSERT_EQ(std::get<0>(*it), entity);
415 }
416
TEST(SingleComponentView,StableType)417 TEST(SingleComponentView, StableType) {
418 entt::registry registry;
419 auto view = registry.view<stable_type>();
420
421 const auto entity = registry.create();
422 const auto other = registry.create();
423
424 registry.emplace<stable_type>(entity);
425 registry.emplace<stable_type>(other);
426 registry.destroy(entity);
427
428 ASSERT_EQ(view.size_hint(), 2u);
429 ASSERT_FALSE(view.contains(entity));
430 ASSERT_TRUE(view.contains(other));
431
432 ASSERT_EQ(view.front(), other);
433 ASSERT_EQ(view.back(), other);
434
435 ASSERT_EQ(*view.begin(), other);
436 ASSERT_EQ(++view.begin(), view.end());
437
438 view.each([other](const auto entt, stable_type) {
439 ASSERT_EQ(other, entt);
440 });
441
442 view.each([check = true](stable_type) mutable {
443 ASSERT_TRUE(check);
444 check = false;
445 });
446
447 for(auto [entt, st]: view.each()) {
448 static_assert(std::is_same_v<decltype(entt), entt::entity>);
449 static_assert(std::is_same_v<decltype(st), stable_type &>);
450 ASSERT_EQ(other, entt);
451 }
452
453 registry.compact();
454
455 ASSERT_EQ(view.size_hint(), 1u);
456 }
457
TEST(MultiComponentView,Functionalities)458 TEST(MultiComponentView, Functionalities) {
459 entt::registry registry;
460 auto view = registry.view<int, char>();
461 auto cview = std::as_const(registry).view<const int, const char>();
462
463 const auto e0 = registry.create();
464 registry.emplace<char>(e0, '1');
465
466 const auto e1 = registry.create();
467 registry.emplace<int>(e1, 42);
468 registry.emplace<char>(e1, '2');
469
470 ASSERT_EQ(*view.begin(), e1);
471 ASSERT_EQ(*view.rbegin(), e1);
472 ASSERT_EQ(++view.begin(), (view.end()));
473 ASSERT_EQ(++view.rbegin(), (view.rend()));
474
475 ASSERT_NO_FATAL_FAILURE((view.begin()++));
476 ASSERT_NO_FATAL_FAILURE((++cview.begin()));
477 ASSERT_NO_FATAL_FAILURE(view.rbegin()++);
478 ASSERT_NO_FATAL_FAILURE(++cview.rbegin());
479
480 ASSERT_NE(view.begin(), view.end());
481 ASSERT_NE(cview.begin(), cview.end());
482 ASSERT_NE(view.rbegin(), view.rend());
483 ASSERT_NE(cview.rbegin(), cview.rend());
484 ASSERT_EQ(view.size_hint(), 1u);
485
486 for(auto entity: view) {
487 ASSERT_EQ(std::get<0>(cview.get<const int, const char>(entity)), 42);
488 ASSERT_EQ(std::get<1>(view.get<int, char>(entity)), '2');
489 ASSERT_EQ(cview.get<const char>(entity), '2');
490 }
491
492 decltype(view) invalid{};
493
494 ASSERT_TRUE(view);
495 ASSERT_TRUE(cview);
496 ASSERT_FALSE(invalid);
497 }
498
TEST(MultiComponentView,LazyTypesFromConstRegistry)499 TEST(MultiComponentView, LazyTypesFromConstRegistry) {
500 entt::registry registry{};
501 auto view = std::as_const(registry).view<const empty_type, const int>();
502
503 const auto entity = registry.create();
504 registry.emplace<empty_type>(entity);
505 registry.emplace<int>(entity);
506
507 ASSERT_TRUE(view);
508
509 ASSERT_EQ(view.size_hint(), 1u);
510 ASSERT_TRUE(view.contains(entity));
511
512 ASSERT_NE(view.begin(), view.end());
513 ASSERT_NE(view.find(entity), view.end());
514 ASSERT_EQ(view.front(), entity);
515 ASSERT_EQ(view.back(), entity);
516 }
517
TEST(MultiComponentView,LazyExcludedTypeFromConstRegistry)518 TEST(MultiComponentView, LazyExcludedTypeFromConstRegistry) {
519 entt::registry registry;
520
521 auto entity = registry.create();
522 registry.emplace<int>(entity);
523
524 auto view = std::as_const(registry).view<const int>(entt::exclude<char>);
525
526 ASSERT_TRUE(view);
527
528 ASSERT_EQ(view.size_hint(), 1u);
529 ASSERT_TRUE(view.contains(entity));
530
531 ASSERT_NE(view.begin(), view.end());
532 ASSERT_NE(view.find(entity), view.end());
533 ASSERT_EQ(view.front(), entity);
534 ASSERT_EQ(view.back(), entity);
535 }
536
TEST(MultiComponentView,Iterator)537 TEST(MultiComponentView, Iterator) {
538 entt::registry registry;
539 const auto entity = registry.create();
540 registry.emplace<int>(entity);
541 registry.emplace<char>(entity);
542
543 const auto view = registry.view<int, char>();
544 using iterator = typename decltype(view)::iterator;
545
546 iterator end{view.begin()};
547 iterator begin{};
548 begin = view.end();
549 std::swap(begin, end);
550
551 ASSERT_EQ(begin, view.begin());
552 ASSERT_EQ(end, view.end());
553 ASSERT_NE(begin, end);
554
555 ASSERT_EQ(begin++, view.begin());
556 ASSERT_EQ(begin--, view.end());
557
558 ASSERT_EQ(++begin, view.end());
559 ASSERT_EQ(--begin, view.begin());
560
561 ASSERT_EQ(*begin, entity);
562 ASSERT_EQ(*begin.operator->(), entity);
563
564 registry.emplace<int>(registry.create());
565 registry.emplace<char>(registry.create());
566
567 const auto other = registry.create();
568 registry.emplace<int>(other);
569 registry.emplace<char>(other);
570
571 begin = view.begin();
572
573 ASSERT_EQ(*(begin++), other);
574 ASSERT_EQ(*(begin++), entity);
575 ASSERT_EQ(begin--, end);
576 ASSERT_EQ(*(begin--), entity);
577 ASSERT_EQ(*begin, other);
578 }
579
TEST(MultiComponentView,ReverseIterator)580 TEST(MultiComponentView, ReverseIterator) {
581 entt::registry registry;
582 const auto entity = registry.create();
583 registry.emplace<int>(entity);
584 registry.emplace<char>(entity);
585
586 const auto view = registry.view<int, char>();
587 using iterator = typename decltype(view)::reverse_iterator;
588
589 iterator end{view.rbegin()};
590 iterator begin{};
591 begin = view.rend();
592 std::swap(begin, end);
593
594 ASSERT_EQ(begin, view.rbegin());
595 ASSERT_EQ(end, view.rend());
596 ASSERT_NE(begin, end);
597
598 ASSERT_EQ(begin++, view.rbegin());
599 ASSERT_EQ(begin--, view.rend());
600
601 ASSERT_EQ(++begin, view.rend());
602 ASSERT_EQ(--begin, view.rbegin());
603
604 ASSERT_EQ(*begin, entity);
605 ASSERT_EQ(*begin.operator->(), entity);
606 }
607
TEST(MultiComponentView,Contains)608 TEST(MultiComponentView, Contains) {
609 entt::registry registry;
610
611 const auto e0 = registry.create();
612 registry.emplace<int>(e0);
613 registry.emplace<char>(e0);
614
615 const auto e1 = registry.create();
616 registry.emplace<int>(e1);
617 registry.emplace<char>(e1);
618
619 registry.destroy(e0);
620
621 auto view = registry.view<int, char>();
622
623 ASSERT_FALSE(view.contains(e0));
624 ASSERT_TRUE(view.contains(e1));
625 }
626
TEST(MultiComponentView,SizeHint)627 TEST(MultiComponentView, SizeHint) {
628 entt::registry registry;
629
630 const auto e0 = registry.create();
631 registry.emplace<double>(e0);
632 registry.emplace<int>(e0);
633 registry.emplace<float>(e0);
634
635 const auto e1 = registry.create();
636 registry.emplace<char>(e1);
637 registry.emplace<float>(e1);
638
639 auto view = registry.view<char, int, float>();
640
641 ASSERT_EQ(view.size_hint(), 1u);
642 ASSERT_EQ(view.begin(), view.end());
643 ASSERT_EQ(view.rbegin(), view.rend());
644 }
645
TEST(MultiComponentView,Each)646 TEST(MultiComponentView, Each) {
647 entt::registry registry;
648
649 const auto e0 = registry.create();
650 registry.emplace<int>(e0, 0);
651 registry.emplace<char>(e0);
652
653 const auto e1 = registry.create();
654 registry.emplace<int>(e1, 1);
655 registry.emplace<char>(e1);
656
657 auto view = registry.view<int, char>();
658 auto iterable = view.each();
659
660 auto cview = std::as_const(registry).view<const int, const char>();
661 auto citerable = cview.each();
662
663 std::size_t cnt = 0;
664
665 for(auto first = citerable.rbegin(), last = citerable.rend(); first != last; ++first) {
666 static_assert(std::is_same_v<decltype(*first), std::tuple<entt::entity, const int &, const char &>>);
667 ASSERT_EQ(std::get<1>(*first), cnt++);
668 }
669
670 view.each([&cnt](auto, int &, char &) { ++cnt; });
671 view.each([&cnt](int &, char &) { ++cnt; });
672
673 ASSERT_EQ(cnt, std::size_t{6});
674
675 cview.each([&cnt](const int &, const char &) { --cnt; });
676 cview.each([&cnt](auto, const int &, const char &) { --cnt; });
677
678 // do not use iterable, make sure an iterable view works when created from a temporary
679 for(auto [entt, iv, cv]: registry.view<int, char>().each()) {
680 static_assert(std::is_same_v<decltype(entt), entt::entity>);
681 static_assert(std::is_same_v<decltype(iv), int &>);
682 static_assert(std::is_same_v<decltype(cv), char &>);
683 ASSERT_EQ(iv, --cnt);
684 }
685
686 ASSERT_EQ(cnt, std::size_t{0});
687
688 auto it = iterable.begin();
689 auto rit = iterable.rbegin();
690
691 ASSERT_EQ((it++, ++it), iterable.end());
692 ASSERT_EQ((rit++, ++rit), iterable.rend());
693 }
694
TEST(MultiComponentView,EachWithSuggestedType)695 TEST(MultiComponentView, EachWithSuggestedType) {
696 entt::registry registry;
697
698 for(auto i = 0; i < 3; ++i) {
699 const auto entity = registry.create();
700 registry.emplace<int>(entity, i);
701 registry.emplace<char>(entity);
702 }
703
704 // makes char a better candidate during iterations
705 const auto entity = registry.create();
706 registry.emplace<int>(entity, 99);
707
708 registry.view<int, char>().each<int>([value = 2](const auto curr, const auto) mutable {
709 ASSERT_EQ(curr, value--);
710 });
711
712 registry.sort<int>([](const auto lhs, const auto rhs) {
713 return lhs < rhs;
714 });
715
716 registry.view<int, char>().each<int>([value = 0](const auto curr, const auto) mutable {
717 ASSERT_EQ(curr, value++);
718 });
719
720 registry.sort<int>([](const auto lhs, const auto rhs) {
721 return lhs > rhs;
722 });
723
724 auto value = registry.view<int, char>().size_hint();
725
726 for(auto &&curr: registry.view<int, char>().each()) {
727 ASSERT_EQ(std::get<1>(curr), static_cast<int>(--value));
728 }
729
730 registry.sort<int>([](const auto lhs, const auto rhs) {
731 return lhs < rhs;
732 });
733
734 value = {};
735
736 for(auto &&curr: registry.view<int, char>().each<int>()) {
737 ASSERT_EQ(std::get<1>(curr), static_cast<int>(value++));
738 }
739 }
740
TEST(MultiComponentView,EachWithHoles)741 TEST(MultiComponentView, EachWithHoles) {
742 entt::registry registry;
743
744 const auto e0 = registry.create();
745 const auto e1 = registry.create();
746 const auto e2 = registry.create();
747
748 registry.emplace<char>(e0, '0');
749 registry.emplace<char>(e1, '1');
750
751 registry.emplace<int>(e0, 0);
752 registry.emplace<int>(e2, 2);
753
754 auto view = registry.view<char, int>();
755
756 view.each([e0](auto entity, const char &c, const int &i) {
757 ASSERT_EQ(entity, e0);
758 ASSERT_EQ(c, '0');
759 ASSERT_EQ(i, 0);
760 });
761
762 for(auto &&curr: view.each()) {
763 ASSERT_EQ(std::get<0>(curr), e0);
764 ASSERT_EQ(std::get<1>(curr), '0');
765 ASSERT_EQ(std::get<2>(curr), 0);
766 }
767 }
768
TEST(MultiComponentView,ConstNonConstAndAllInBetween)769 TEST(MultiComponentView, ConstNonConstAndAllInBetween) {
770 entt::registry registry;
771 auto view = registry.view<int, empty_type, const char>();
772
773 ASSERT_EQ(view.size_hint(), 0u);
774
775 const auto entity = registry.create();
776 registry.emplace<int>(entity, 0);
777 registry.emplace<empty_type>(entity);
778 registry.emplace<char>(entity, 'c');
779
780 ASSERT_EQ(view.size_hint(), 1u);
781
782 static_assert(std::is_same_v<decltype(view.get<int>({})), int &>);
783 static_assert(std::is_same_v<decltype(view.get<const char>({})), const char &>);
784 static_assert(std::is_same_v<decltype(view.get<int, const char>({})), std::tuple<int &, const char &>>);
785 static_assert(std::is_same_v<decltype(view.get({})), std::tuple<int &, const char &>>);
786
787 static_assert(std::is_same_v<decltype(std::as_const(registry).view<char, int>()), decltype(std::as_const(registry).view<const char, const int>())>);
788 static_assert(std::is_same_v<decltype(std::as_const(registry).view<char, const int>()), decltype(std::as_const(registry).view<const char, const int>())>);
789 static_assert(std::is_same_v<decltype(std::as_const(registry).view<const char, int>()), decltype(std::as_const(registry).view<const char, const int>())>);
790
791 view.each([](auto &&i, auto &&c) {
792 static_assert(std::is_same_v<decltype(i), int &>);
793 static_assert(std::is_same_v<decltype(c), const char &>);
794 });
795
796 for(auto [entt, iv, cv]: view.each()) {
797 static_assert(std::is_same_v<decltype(entt), entt::entity>);
798 static_assert(std::is_same_v<decltype(iv), int &>);
799 static_assert(std::is_same_v<decltype(cv), const char &>);
800 }
801 }
802
TEST(MultiComponentView,Find)803 TEST(MultiComponentView, Find) {
804 entt::registry registry;
805 auto view = registry.view<int, const char>();
806
807 const auto e0 = registry.create();
808 registry.emplace<int>(e0);
809 registry.emplace<char>(e0);
810
811 const auto e1 = registry.create();
812 registry.emplace<int>(e1);
813 registry.emplace<char>(e1);
814
815 const auto e2 = registry.create();
816 registry.emplace<int>(e2);
817 registry.emplace<char>(e2);
818
819 const auto e3 = registry.create();
820 registry.emplace<int>(e3);
821 registry.emplace<char>(e3);
822
823 registry.erase<int>(e1);
824
825 ASSERT_NE(view.find(e0), view.end());
826 ASSERT_EQ(view.find(e1), view.end());
827 ASSERT_NE(view.find(e2), view.end());
828 ASSERT_NE(view.find(e3), view.end());
829
830 auto it = view.find(e2);
831
832 ASSERT_EQ(*it, e2);
833 ASSERT_EQ(*(++it), e3);
834 ASSERT_EQ(*(++it), e0);
835 ASSERT_EQ(++it, view.end());
836 ASSERT_EQ(++view.find(e0), view.end());
837
838 const auto e4 = registry.create();
839 registry.destroy(e4);
840 const auto e5 = registry.create();
841 registry.emplace<int>(e5);
842 registry.emplace<char>(e5);
843
844 ASSERT_NE(view.find(e5), view.end());
845 ASSERT_EQ(view.find(e4), view.end());
846 }
847
TEST(MultiComponentView,ExcludedComponents)848 TEST(MultiComponentView, ExcludedComponents) {
849 entt::registry registry;
850
851 const auto e0 = registry.create();
852 registry.emplace<int>(e0, 0);
853
854 const auto e1 = registry.create();
855 registry.emplace<int>(e1, 1);
856 registry.emplace<char>(e1);
857
858 const auto e2 = registry.create();
859 registry.emplace<int>(e2, 2);
860
861 const auto e3 = registry.create();
862 registry.emplace<int>(e3, 3);
863 registry.emplace<char>(e3);
864
865 const auto view = std::as_const(registry).view<const int>(entt::exclude<char>);
866
867 for(const auto entity: view) {
868 ASSERT_TRUE(entity == e0 || entity == e2);
869
870 if(entity == e0) {
871 ASSERT_EQ(view.get<const int>(e0), 0);
872 } else if(entity == e2) {
873 ASSERT_EQ(std::get<0>(view.get(e2)), 2);
874 }
875 }
876
877 registry.emplace<char>(e0);
878 registry.emplace<char>(e2);
879 registry.erase<char>(e1);
880 registry.erase<char>(e3);
881
882 for(const auto entity: view) {
883 ASSERT_TRUE(entity == e1 || entity == e3);
884
885 if(entity == e1) {
886 ASSERT_EQ(std::get<0>(view.get(e1)), 1);
887 } else if(entity == e3) {
888 ASSERT_EQ(view.get<const int>(e3), 3);
889 }
890 }
891 }
892
TEST(MultiComponentView,EmptyTypes)893 TEST(MultiComponentView, EmptyTypes) {
894 entt::registry registry;
895
896 const auto entity = registry.create();
897 registry.emplace<int>(entity);
898 registry.emplace<char>(entity);
899 registry.emplace<empty_type>(entity);
900
901 const auto other = registry.create();
902 registry.emplace<int>(other);
903 registry.emplace<char>(other);
904 registry.emplace<double>(other);
905 registry.emplace<empty_type>(other);
906
907 const auto ignored = registry.create();
908 registry.emplace<int>(ignored);
909 registry.emplace<char>(ignored);
910
911 registry.view<int, char, empty_type>(entt::exclude<double>).each([entity](const auto entt, int, char) {
912 ASSERT_EQ(entity, entt);
913 });
914
915 for(auto [entt, iv, cv]: registry.view<int, char, empty_type>(entt::exclude<double>).each()) {
916 static_assert(std::is_same_v<decltype(entt), entt::entity>);
917 static_assert(std::is_same_v<decltype(iv), int &>);
918 static_assert(std::is_same_v<decltype(cv), char &>);
919 ASSERT_EQ(entity, entt);
920 }
921
922 registry.view<int, empty_type, char>(entt::exclude<double>).each([check = true](int, char) mutable {
923 ASSERT_TRUE(check);
924 check = false;
925 });
926
927 for(auto [entt, iv, cv]: registry.view<int, empty_type, char>(entt::exclude<double>).each()) {
928 static_assert(std::is_same_v<decltype(entt), entt::entity>);
929 static_assert(std::is_same_v<decltype(iv), int &>);
930 static_assert(std::is_same_v<decltype(cv), char &>);
931 ASSERT_EQ(entity, entt);
932 }
933
934 registry.view<empty_type, int, char>(entt::exclude<double>).each([entity](const auto entt, int, char) {
935 ASSERT_EQ(entity, entt);
936 });
937
938 for(auto [entt, iv, cv]: registry.view<empty_type, int, char>(entt::exclude<double>).each()) {
939 static_assert(std::is_same_v<decltype(entt), entt::entity>);
940 static_assert(std::is_same_v<decltype(iv), int &>);
941 static_assert(std::is_same_v<decltype(cv), char &>);
942 ASSERT_EQ(entity, entt);
943 }
944
945 registry.view<empty_type, int, char>(entt::exclude<double>).each<empty_type>([entity](const auto entt, int, char) {
946 ASSERT_EQ(entity, entt);
947 });
948
949 for(auto [entt, iv, cv]: registry.view<empty_type, int, char>(entt::exclude<double>).each<empty_type>()) {
950 static_assert(std::is_same_v<decltype(entt), entt::entity>);
951 static_assert(std::is_same_v<decltype(iv), int &>);
952 static_assert(std::is_same_v<decltype(cv), char &>);
953 ASSERT_EQ(entity, entt);
954 }
955
956 registry.view<int, empty_type, char>(entt::exclude<double>).each<empty_type>([check = true](int, char) mutable {
957 ASSERT_TRUE(check);
958 check = false;
959 });
960
961 for(auto [entt, iv, cv]: registry.view<int, empty_type, char>(entt::exclude<double>).each<empty_type>()) {
962 static_assert(std::is_same_v<decltype(entt), entt::entity>);
963 static_assert(std::is_same_v<decltype(iv), int &>);
964 static_assert(std::is_same_v<decltype(cv), char &>);
965 ASSERT_EQ(entity, entt);
966 }
967 }
968
TEST(MultiComponentView,FrontBack)969 TEST(MultiComponentView, FrontBack) {
970 entt::registry registry;
971 auto view = registry.view<const int, const char>();
972
973 ASSERT_EQ(view.front(), static_cast<entt::entity>(entt::null));
974 ASSERT_EQ(view.back(), static_cast<entt::entity>(entt::null));
975
976 const auto e0 = registry.create();
977 registry.emplace<int>(e0);
978 registry.emplace<char>(e0);
979
980 const auto e1 = registry.create();
981 registry.emplace<int>(e1);
982 registry.emplace<char>(e1);
983
984 const auto entity = registry.create();
985 registry.emplace<char>(entity);
986
987 ASSERT_EQ(view.front(), e1);
988 ASSERT_EQ(view.back(), e0);
989 }
990
TEST(MultiComponentView,ExtendedGet)991 TEST(MultiComponentView, ExtendedGet) {
992 using type = decltype(std::declval<entt::registry>().view<int, empty_type, char>().get({}));
993 static_assert(std::tuple_size_v<type> == 2u);
994 static_assert(std::is_same_v<std::tuple_element_t<0, type>, int &>);
995 static_assert(std::is_same_v<std::tuple_element_t<1, type>, char &>);
996 }
997
TEST(MultiComponentView,DeductionGuide)998 TEST(MultiComponentView, DeductionGuide) {
999 entt::registry registry;
1000 typename entt::storage_traits<entt::entity, int>::storage_type istorage;
1001 typename entt::storage_traits<entt::entity, double>::storage_type dstorage;
1002 typename entt::storage_traits<entt::entity, stable_type>::storage_type sstorage;
1003
1004 static_assert(std::is_same_v<entt::basic_view<entt::entity, entt::exclude_t<>, int, double>, decltype(entt::basic_view{istorage, dstorage})>);
1005 static_assert(std::is_same_v<entt::basic_view<entt::entity, entt::exclude_t<>, const int, double>, decltype(entt::basic_view{std::as_const(istorage), dstorage})>);
1006 static_assert(std::is_same_v<entt::basic_view<entt::entity, entt::exclude_t<>, int, const double>, decltype(entt::basic_view{istorage, std::as_const(dstorage)})>);
1007 static_assert(std::is_same_v<entt::basic_view<entt::entity, entt::exclude_t<>, const int, const double>, decltype(entt::basic_view{std::as_const(istorage), std::as_const(dstorage)})>);
1008 static_assert(std::is_same_v<entt::basic_view<entt::entity, entt::exclude_t<>, int, stable_type>, decltype(entt::basic_view{istorage, sstorage})>);
1009
1010 static_assert(std::is_base_of_v<entt::basic_view_impl<entt::packed_storage_policy, entt::entity, entt::exclude_t<>, int, double>, decltype(entt::basic_view{istorage, dstorage})>);
1011 static_assert(std::is_base_of_v<entt::basic_view_impl<entt::packed_storage_policy, entt::entity, entt::exclude_t<>, const int, double>, decltype(entt::basic_view{std::as_const(istorage), dstorage})>);
1012 static_assert(std::is_base_of_v<entt::basic_view_impl<entt::packed_storage_policy, entt::entity, entt::exclude_t<>, int, const double>, decltype(entt::basic_view{istorage, std::as_const(dstorage)})>);
1013 static_assert(std::is_base_of_v<entt::basic_view_impl<entt::packed_storage_policy, entt::entity, entt::exclude_t<>, const int, const double>, decltype(entt::basic_view{std::as_const(istorage), std::as_const(dstorage)})>);
1014 static_assert(std::is_base_of_v<entt::basic_view_impl<entt::stable_storage_policy, entt::entity, entt::exclude_t<>, int, stable_type>, decltype(entt::basic_view{istorage, sstorage})>);
1015 }
1016
TEST(MultiComponentView,IterableViewAlgorithmCompatibility)1017 TEST(MultiComponentView, IterableViewAlgorithmCompatibility) {
1018 entt::registry registry;
1019 const auto entity = registry.create();
1020
1021 registry.emplace<int>(entity);
1022 registry.emplace<char>(entity);
1023
1024 const auto view = registry.view<int, char>();
1025 const auto iterable = view.each();
1026 const auto it = std::find_if(iterable.begin(), iterable.end(), [entity](auto args) { return std::get<0>(args) == entity; });
1027
1028 ASSERT_EQ(std::get<0>(*it), entity);
1029 }
1030
TEST(MultiComponentView,StableType)1031 TEST(MultiComponentView, StableType) {
1032 entt::registry registry;
1033 auto view = registry.view<int, stable_type>();
1034
1035 const auto entity = registry.create();
1036 const auto other = registry.create();
1037
1038 registry.emplace<int>(entity);
1039 registry.emplace<int>(other);
1040 registry.emplace<stable_type>(entity);
1041 registry.emplace<stable_type>(other);
1042 registry.destroy(entity);
1043
1044 ASSERT_EQ(view.size_hint(), 1u);
1045
1046 view.use<stable_type>();
1047
1048 ASSERT_EQ(view.size_hint(), 2u);
1049 ASSERT_FALSE(view.contains(entity));
1050 ASSERT_TRUE(view.contains(other));
1051
1052 ASSERT_EQ(view.front(), other);
1053 ASSERT_EQ(view.back(), other);
1054
1055 ASSERT_EQ(*view.begin(), other);
1056 ASSERT_EQ(++view.begin(), view.end());
1057
1058 view.each([other](const auto entt, int, stable_type) {
1059 ASSERT_EQ(other, entt);
1060 });
1061
1062 view.each([check = true](int, stable_type) mutable {
1063 ASSERT_TRUE(check);
1064 check = false;
1065 });
1066
1067 for(auto [entt, iv, st]: view.each()) {
1068 static_assert(std::is_same_v<decltype(entt), entt::entity>);
1069 static_assert(std::is_same_v<decltype(iv), int &>);
1070 static_assert(std::is_same_v<decltype(st), stable_type &>);
1071 ASSERT_EQ(other, entt);
1072 }
1073
1074 registry.compact();
1075
1076 ASSERT_EQ(view.size_hint(), 1u);
1077 }
1078
TEST(View,Pipe)1079 TEST(View, Pipe) {
1080 entt::registry registry;
1081 const auto entity = registry.create();
1082 const auto other = registry.create();
1083
1084 registry.emplace<int>(entity);
1085 registry.emplace<char>(entity);
1086 registry.emplace<double>(entity);
1087 registry.emplace<empty_type>(entity);
1088
1089 registry.emplace<int>(other);
1090 registry.emplace<char>(other);
1091 registry.emplace<stable_type>(other);
1092
1093 const auto view1 = registry.view<int>(entt::exclude<double>);
1094 const auto view2 = registry.view<const char>(entt::exclude<float>);
1095 const auto view3 = registry.view<empty_type>();
1096 const auto view4 = registry.view<stable_type>();
1097
1098 static_assert(std::is_same_v<entt::basic_view<entt::entity, entt::exclude_t<double, float>, int, const char>, decltype(view1 | view2)>);
1099 static_assert(std::is_same_v<entt::basic_view<entt::entity, entt::exclude_t<float, double>, const char, int>, decltype(view2 | view1)>);
1100 static_assert(std::is_same_v<decltype((view1 | view2) | view3), decltype(view1 | (view2 | view3))>);
1101
1102 static_assert(std::is_base_of_v<entt::basic_view_impl<entt::packed_storage_policy, entt::entity, entt::exclude_t<double, float>, int, const char>, decltype(view1 | view2)>);
1103 static_assert(std::is_base_of_v<entt::basic_view_impl<entt::stable_storage_policy, entt::entity, entt::exclude_t<double, float>, int, stable_type, const char>, decltype(view1 | view4 | view2)>);
1104
1105 ASSERT_FALSE((view1 | view2).contains(entity));
1106 ASSERT_TRUE((view1 | view2).contains(other));
1107
1108 ASSERT_TRUE((view2 | view3).contains(entity));
1109 ASSERT_FALSE((view2 | view3).contains(other));
1110
1111 ASSERT_FALSE((view1 | view2 | view3).contains(entity));
1112 ASSERT_FALSE((view1 | view2 | view3).contains(other));
1113
1114 ASSERT_FALSE((view1 | view4 | view2).contains(entity));
1115 ASSERT_TRUE((view1 | view4 | view2).contains(other));
1116 }
1117