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