EnTT: src/entt/entity/runtime_view.hpp Source File

EnTT 3.15.0

Loading...
Searching...
No Matches
runtime_view.hpp
1#ifndef ENTT_ENTITY_RUNTIME_VIEW_HPP
2#define ENTT_ENTITY_RUNTIME_VIEW_HPP
3
4#include <algorithm>
5#include <cstddef>
6#include <iterator>
7#include <utility>
8#include <vector>
9#include "entity.hpp"
10#include "fwd.hpp"
11
12namespace entt {
13
15namespace internal {
16
17template<typename Set>
18class runtime_view_iterator final {
19 using iterator_type = typename Set::iterator;
20 using iterator_traits = std::iterator_traits<iterator_type>;
21
22 [[nodiscard]] bool valid() const {
23 return (!tombstone_check || *it != tombstone)
24 && std::all_of(++pools->begin(), pools->end(), [entt = *it](const auto *curr) { return curr->contains(entt); })
25 && std::none_of(filter->cbegin(), filter->cend(), [entt = *it](const auto *curr) { return curr && curr->contains(entt); });
26 }
27
28public:
29 using value_type = typename iterator_traits::value_type;
30 using pointer = typename iterator_traits::pointer;
31 using reference = typename iterator_traits::reference;
32 using difference_type = typename iterator_traits::difference_type;
33 using iterator_category = std::bidirectional_iterator_tag;
34
35 constexpr runtime_view_iterator() noexcept
36 : pools{},
37 filter{},
38 it{},
39 tombstone_check{} {}
40
41 // NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
42 runtime_view_iterator(const std::vector<Set *> &cpools, const std::vector<Set *> &ignore, iterator_type curr) noexcept
43 : pools{&cpools},
44 filter{&ignore},
45 it{curr},
46 tombstone_check{pools->size() == 1u && (*pools)[0u]->policy() == deletion_policy::in_place} {
47 if(it != (*pools)[0]->end() && !valid()) {
48 ++(*this);
49 }
50 }
51
52 runtime_view_iterator &operator++() {
53 ++it;
54 for(const auto last = (*pools)[0]->end(); it != last && !valid(); ++it) {}
55 return *this;
56 }
57
58 runtime_view_iterator operator++(int) {
59 const runtime_view_iterator orig = *this;
60 return ++(*this), orig;
61 }
62
63 runtime_view_iterator &operator--() {
64 --it;
65 for(const auto first = (*pools)[0]->begin(); it != first && !valid(); --it) {}
66 return *this;
67 }
68
69 runtime_view_iterator operator--(int) {
70 const runtime_view_iterator orig = *this;
71 return operator--(), orig;
72 }
73
74 [[nodiscard]] pointer operator->() const noexcept {
75 return it.operator->();
76 }
77
78 [[nodiscard]] reference operator*() const noexcept {
79 return *operator->();
80 }
81
82 [[nodiscard]] constexpr bool operator==(const runtime_view_iterator &other) const noexcept {
83 return it == other.it;
84 }
85
86 [[nodiscard]] constexpr bool operator!=(const runtime_view_iterator &other) const noexcept {
87 return !(*this == other);
88 }
89
90private:
91 const std::vector<Set *> *pools;
92 const std::vector<Set *> *filter;
93 iterator_type it;
94 bool tombstone_check;
95};
96
97} // namespace internal
99
123template<typename Type, typename Allocator>
124 class basic_runtime_view {
125 using alloc_traits = std::allocator_traits<Allocator>;
126 static_assert(std::is_same_v<typename alloc_traits::value_type, Type *>, "Invalid value type");
127 using container_type = std::vector<Type *, Allocator>;
128
129public:
131 using allocator_type = Allocator;
133 using entity_type = typename Type::entity_type;
135 using size_type = std::size_t;
137 using common_type = Type;
139 using iterator = internal::runtime_view_iterator<common_type>;
140
142 basic_runtime_view() noexcept
143 : basic_runtime_view{allocator_type{}} {}
144
149 explicit basic_runtime_view(const allocator_type &allocator)
150 : pools{allocator},
151 filter{allocator} {}
152
154 basic_runtime_view(const basic_runtime_view &) = default;
155
161 basic_runtime_view(const basic_runtime_view &other, const allocator_type &allocator)
162 : pools{other.pools, allocator},
163 filter{other.filter, allocator} {}
164
166 basic_runtime_view(basic_runtime_view &&) noexcept = default;
167
173 basic_runtime_view(basic_runtime_view &&other, const allocator_type &allocator)
174 : pools{std::move(other.pools), allocator},
175 filter{std::move(other.filter), allocator} {}
176
178 ~basic_runtime_view() = default;
179
184 basic_runtime_view &operator=(const basic_runtime_view &) = default;
185
190 basic_runtime_view &operator=(basic_runtime_view &&) noexcept = default;
191
196 void swap(basic_runtime_view &other) noexcept {
197 using std::swap;
198 swap(pools, other.pools);
199 swap(filter, other.filter);
200 }
201
206 [[nodiscard]] constexpr allocator_type get_allocator() const noexcept {
207 return pools.get_allocator();
208 }
209
211 void clear() {
212 pools.clear();
213 filter.clear();
214 }
215
221 basic_runtime_view &iterate(common_type &base) {
222 if(pools.empty() || !(base.size() < pools[0u]->size())) {
223 pools.push_back(&base);
224 } else {
225 pools.push_back(std::exchange(pools[0u], &base));
226 }
227
228 return *this;
229 }
230
236 basic_runtime_view &exclude(common_type &base) {
237 filter.push_back(&base);
238 return *this;
239 }
240
245 [[nodiscard]] size_type size_hint() const {
246 return pools.empty() ? size_type{} : pools.front()->size();
247 }
248
257 [[nodiscard]] iterator begin() const {
258 return pools.empty() ? iterator{} : iterator{pools, filter, pools[0]->begin()};
259 }
260
267 [[nodiscard]] iterator end() const {
268 return pools.empty() ? iterator{} : iterator{pools, filter, pools[0]->end()};
269 }
270
275 [[nodiscard]] explicit operator bool() const noexcept {
276 return !(pools.empty() && filter.empty());
277 }
278
284 [[nodiscard]] bool contains(const entity_type entt) const {
285 return !pools.empty()
286 && std::all_of(pools.cbegin(), pools.cend(), [entt](const auto *curr) { return curr->contains(entt); })
287 && std::none_of(filter.cbegin(), filter.cend(), [entt](const auto *curr) { return curr && curr->contains(entt); });
288 }
289
304 template<typename Func>
305 void each(Func func) const {
306 for(const auto entity: *this) {
307 func(entity);
308 }
309 }
310
311private:
312 container_type pools;
313 container_type filter;
314};
315
316} // namespace entt
317
318#endif
entt::basic_runtime_view::basic_runtime_view
basic_runtime_view(const basic_runtime_view &)=default
Default copy constructor.
entt::basic_runtime_view::begin
iterator begin() const
Returns an iterator to the first entity that has the given elements.
Definition runtime_view.hpp:257
entt::basic_runtime_view::basic_runtime_view
basic_runtime_view() noexcept
Default constructor to use to create empty, invalid views.
Definition runtime_view.hpp:142
entt::basic_runtime_view::basic_runtime_view
basic_runtime_view(const allocator_type &allocator)
Constructs an empty, invalid view with a given allocator.
Definition runtime_view.hpp:149
entt::basic_runtime_view< sparse_set >::iterator
internal::runtime_view_iterator< common_type > iterator
Definition runtime_view.hpp:139
entt::basic_runtime_view::operator=
basic_runtime_view & operator=(const basic_runtime_view &)=default
Default copy assignment operator.
entt::basic_runtime_view::get_allocator
constexpr allocator_type get_allocator() const noexcept
Returns the associated allocator.
Definition runtime_view.hpp:206
entt::basic_runtime_view::~basic_runtime_view
~basic_runtime_view()=default
Default destructor.
entt::basic_runtime_view::contains
bool contains(const entity_type entt) const
Checks if a view contains an entity.
Definition runtime_view.hpp:284
entt::basic_runtime_view::each
void each(Func func) const
Iterates entities and applies the given function object to them.
Definition runtime_view.hpp:305
entt::basic_runtime_view::exclude
basic_runtime_view & exclude(common_type &base)
Adds an opaque storage object as a filter of a runtime view.
Definition runtime_view.hpp:236
entt::basic_runtime_view< sparse_set >::allocator_type
Allocator allocator_type
Definition runtime_view.hpp:131
entt::basic_runtime_view::clear
void clear()
Clears the view.
Definition runtime_view.hpp:211
entt::basic_runtime_view< sparse_set >::entity_type
typename sparse_set::entity_type entity_type
Definition runtime_view.hpp:133
entt::basic_runtime_view::end
iterator end() const
Returns an iterator that is past the last entity that has the given elements.
Definition runtime_view.hpp:267
entt::basic_runtime_view::operator=
basic_runtime_view & operator=(basic_runtime_view &&) noexcept=default
Default move assignment operator.
entt::basic_runtime_view::size_hint
size_type size_hint() const
Estimates the number of entities iterated by the view.
Definition runtime_view.hpp:245
entt::basic_runtime_view< sparse_set >::common_type
sparse_set common_type
Definition runtime_view.hpp:137
entt::basic_runtime_view::basic_runtime_view
basic_runtime_view(const basic_runtime_view &other, const allocator_type &allocator)
Allocator-extended copy constructor.
Definition runtime_view.hpp:161
entt::basic_runtime_view< sparse_set >::swap
void swap(basic_runtime_view &other) noexcept
Definition runtime_view.hpp:196
entt::basic_runtime_view::iterate
basic_runtime_view & iterate(common_type &base)
Appends an opaque storage object to a runtime view.
Definition runtime_view.hpp:221
entt::basic_runtime_view< sparse_set >::size_type
std::size_t size_type
Definition runtime_view.hpp:135
entt::basic_runtime_view::basic_runtime_view
basic_runtime_view(basic_runtime_view &&) noexcept=default
Default move constructor.
entt::basic_sparse_set::size
size_type size() const noexcept
Returns the number of elements in a sparse set.
Definition sparse_set.hpp:614
entt
EnTT default namespace.
Definition dense_map.hpp:22
entt::entity
entity
Default entity identifier.
Definition fwd.hpp:14
entt::operator!=
constexpr bool operator!=(const basic_hashed_string< Char > &lhs, const basic_hashed_string< Char > &rhs) noexcept
Compares two hashed strings.
Definition hashed_string.hpp:232
entt::operator==
constexpr bool operator==(const basic_hashed_string< Char > &lhs, const basic_hashed_string< Char > &rhs) noexcept
Compares two hashed strings.
Definition hashed_string.hpp:220