diff --git a/CONTRIBUTING_8md_source.html b/CONTRIBUTING_8md_source.html index 65bcbca97..ab2a40f4b 100644 --- a/CONTRIBUTING_8md_source.html +++ b/CONTRIBUTING_8md_source.html @@ -5,7 +5,7 @@ -EnTT: docs/CONTRIBUTING.md Source File +EnTT: docs/md/CONTRIBUTING.md Source File @@ -22,7 +22,7 @@
EnTT -  2.7.3 +  3.0.0
@@ -60,10 +60,10 @@ $(function() {
-
docs/CONTRIBUTING.md
+
docs/md/CONTRIBUTING.md
-
1 # Contributing
2 
3 First of all, thank you very much for taking the time to contribute to the
4 `EnTT` framework.<br/>
5 How to do it mostly depends on the type of contribution:
6 
7 * If you have a question, **please** ensure there isn't already an answer for
8  you by searching on GitHub under
9  [issues](https://github.com/skypjack/entt/issues). Do not forget to search
10  also through the closed ones. If you are unable to find a proper answer, feel
11  free to [open a new issue](https://github.com/skypjack/entt/issues/new).
12  Usually, questions are marked as such and closed in a few days.
13 
14 * If you want to fix a typo in the inline documentation or in the README file,
15  if you want to add some new sections or if you want to help me with the
16  language by reviewing what I wrote so far (I'm not a native speaker after
17  all), **please** open a new
18  [pull request](https://github.com/skypjack/entt/pulls) with your changes.
19 
20 * If you found a bug, **please** ensure there isn't already an answer for you by
21  searching on GitHub under [issues](https://github.com/skypjack/entt/issues).
22  If you are unable to find an open issue addressing the problem, feel free to
23  [open a new one](https://github.com/skypjack/entt/issues/new). **Please**, do
24  not forget to carefully describe how to reproduce the problem, then add all
25  the informaion about the system on which you are experiencing it and point out
26  the version of `EnTT` you are using (tag or commit).
27 
28 * If you found a bug and you wrote a patch to fix it, open a new
29  [pull request](https://github.com/skypjack/entt/pulls) with your code.
30  **Please**, add some tests to avoid regressions in future if possible, it
31  would be really appreciated. Note that the `EnTT` framework has a
32  [coverage at 100%](https://coveralls.io/github/skypjack/entt?branch=master)
33  (at least it was at 100% at the time I wrote this file) and this is the reason
34  for which you can be confident with using it in a production environment.
35 
36 * If you want to propose a new feature and you know how to code it, **please**
37  do not issue directly a pull request. Before to do it,
38  [create a new issue](https://github.com/skypjack/entt/issues/new) to discuss
39  your proposal. Other users could be interested in your idea and the discussion
40  that will follow can refine it and therefore give us a better solution.
41 
42 * If you want to request a new feature, I'm available for hiring. Take a look at
43  [my profile](https://github.com/skypjack) and feel free to write me.
+
1 # Contributing
2 
3 First of all, thank you very much for taking the time to contribute to the
4 `EnTT` framework.<br/>
5 How to do it mostly depends on the type of contribution:
6 
7 * If you have a question, **please** ensure there isn't already an answer for
8  you by searching on GitHub under
9  [issues](https://github.com/skypjack/entt/issues). Do not forget to search
10  also through the closed ones. If you are unable to find a proper answer, feel
11  free to [open a new issue](https://github.com/skypjack/entt/issues/new).
12  Usually, questions are marked as such and closed in a few days.
13 
14 * If you want to fix a typo in the inline documentation or in the README file,
15  if you want to add some new sections or if you want to help me with the
16  language by reviewing what I wrote so far (I'm not a native speaker after
17  all), **please** open a new
18  [pull request](https://github.com/skypjack/entt/pulls) with your changes.
19 
20 * If you found a bug, **please** ensure there isn't already an answer for you by
21  searching on GitHub under [issues](https://github.com/skypjack/entt/issues).
22  If you are unable to find an open issue addressing the problem, feel free to
23  [open a new one](https://github.com/skypjack/entt/issues/new). **Please**, do
24  not forget to carefully describe how to reproduce the problem, then add all
25  the information about the system on which you are experiencing it and point
26  out the version of `EnTT` you are using (tag or commit).
27 
28 * If you found a bug and you wrote a patch to fix it, open a new
29  [pull request](https://github.com/skypjack/entt/pulls) with your code.
30  **Please**, add some tests to avoid regressions in future if possible, it
31  would be really appreciated. Note that the `EnTT` framework has a
32  [coverage at 100%](https://coveralls.io/github/skypjack/entt?branch=master)
33  (at least it was at 100% at the time I wrote this file) and this is the reason
34  for which you can be confident with using it in a production environment.
35 
36 * If you want to propose a new feature and you know how to code it, **please**
37  do not issue directly a pull request. Before to do it,
38  [create a new issue](https://github.com/skypjack/entt/issues/new) to discuss
39  your proposal. Other users could be interested in your idea and the discussion
40  that will follow can refine it and therefore give us a better solution.
41 
42 * If you want to request a new feature, I'm available for hiring. Take a look at
43  [my profile](https://github.com/skypjack) and feel free to write me.
Generated by   diff --git a/README_8md_source.html b/README_8md_source.html index 66bc75cf9..afaccb89f 100644 --- a/README_8md_source.html +++ b/README_8md_source.html @@ -22,7 +22,7 @@
EnTT -  2.7.3 +  3.0.0
@@ -63,7 +63,7 @@ $(function() {
README.md
-
1 ![EnTT: Gaming meets modern C++](https://user-images.githubusercontent.com/1812216/42513718-ee6e98d0-8457-11e8-9baf-8d83f61a3097.png)
2 
3 <!--
4 @cond TURN_OFF_DOXYGEN
5 -->
6 [![Build Status](https://travis-ci.org/skypjack/entt.svg?branch=master)](https://travis-ci.org/skypjack/entt)
7 [![Build status](https://ci.appveyor.com/api/projects/status/rvhaabjmghg715ck?svg=true)](https://ci.appveyor.com/project/skypjack/entt)
8 [![Coverage Status](https://coveralls.io/repos/github/skypjack/entt/badge.svg?branch=master)](https://coveralls.io/github/skypjack/entt?branch=master)
9 [![Gitter chat](https://badges.gitter.im/skypjack/entt.png)](https://gitter.im/skypjack/entt)
10 [![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=W2HF9FESD5LJY&lc=IT&item_name=Michele%20Caini&currency_code=EUR&bn=PP%2dDonationsBF%3abtn_donateCC_LG%2egif%3aNonHosted)
11 
12 # Table of Contents
13 
14 * [Introduction](#introduction)
15  * [Code Example](#code-example)
16  * [Motivation](#motivation)
17  * [Performance](#performance)
18 * [Build Instructions](#build-instructions)
19  * [Requirements](#requirements)
20  * [Library](#library)
21  * [Documentation](#documentation)
22  * [Tests](#tests)
23 * [Packaging Tools](#packaging-tools)
24 * [EnTT in Action](#entt-in-action)
25 * [Contributors](#contributors)
26 * [License](#license)
27 * [Support](#support)
28  * [Donation](#donation)
29  * [Hire me](#hire-me)
30 <!--
31 @endcond TURN_OFF_DOXYGEN
32 -->
33 
34 # Introduction
35 
36 `EnTT` is a header-only, tiny and easy to use entity-component system (and much
37 more) written in modern C++ and even
38 [used by Mojang in Minecraft](https://minecraft.net/en-us/attribution/).<br/>
39 The entity-component-system (also known as _ECS_) is an architectural pattern
40 used mostly in game development. For further details:
41 
42 * [Entity Systems Wiki](http://entity-systems.wikidot.com/)
43 * [Evolve Your Hierarchy](http://cowboyprogramming.com/2007/01/05/evolve-your-heirachy/)
44 * [ECS on Wikipedia](https://en.wikipedia.org/wiki/Entity%E2%80%93component%E2%80%93system)
45 
46 A long time ago, the sole entity-component system was part of the project. After
47 a while the codebase has grown and more and more classes have become part of the
48 repository.<br/>
49 Here is a brief, yet incomplete list of what it offers today:
50 
51 * Statically generated integer identifiers for types (assigned either at
52  compile-time or at runtime).
53 * A constexpr utility for human readable resource identifiers.
54 * A minimal configuration system built on top of the monostate pattern.
55 * An incredibly fast entity-component system based on sparse sets, with its own
56  views and a _pay for what you use_ policy to adjust performance and memory
57  usage according to users' requirements.
58 * A lot of facilities built on top of the entity-component system to help
59  developers and avoid reinventing the wheel (ie dependencies, snapshot, actor
60  class for those who aren't confident with the architecture and so on).
61 * The smallest and most basic implementation of a service locator ever seen.
62 * A cooperative scheduler for processes of any type.
63 * All what is needed for resource management (cache, loaders, handles).
64 * Delegates, signal handlers (with built-in support for collectors) and a tiny
65  event dispatcher.
66 * A general purpose event emitter, that is a CRTP idiom based class template.
67 * An event dispatcher for immediate and delayed events to integrate in loops.
68 * ...
69 * Any other business.
70 
71 Consider it a work in progress. The whole API is also fully documented in-code
72 for those who are brave enough to read it.
73 
74 Currently, `EnTT` is tested on Linux, Microsoft Windows and OS X. It has proven
75 to work also on both Android and iOS.<br/>
76 Most likely it will not be problematic on other systems as well, but has not
77 been sufficiently tested so far.
78 
79 ## Code Example
80 
81 ```cpp
82 #include <entt/entt.hpp>
83 #include <cstdint>
84 
85 struct Position {
86  float x;
87  float y;
88 };
89 
90 struct Velocity {
91  float dx;
92  float dy;
93 };
94 
95 void update(entt::DefaultRegistry &registry) {
96  auto view = registry.view<Position, Velocity>();
97 
98  for(auto entity: view) {
99  // gets only the components that are going to be used ...
100 
101  auto &velocity = view.get<Velocity>(entity);
102 
103  velocity.dx = 0.;
104  velocity.dy = 0.;
105 
106  // ...
107  }
108 }
109 
110 void update(std::uint64_t dt, entt::DefaultRegistry &registry) {
111  registry.view<Position, Velocity>().each([dt](auto entity, auto &position, auto &velocity) {
112  // gets all the components of the view at once ...
113 
114  position.x += velocity.dx * dt;
115  position.y += velocity.dy * dt;
116 
117  // ...
118  });
119 }
120 
121 int main() {
122  entt::DefaultRegistry registry;
123  std::uint64_t dt = 16;
124 
125  for(auto i = 0; i < 10; ++i) {
126  auto entity = registry.create();
127  registry.assign<Position>(entity, i * 1.f, i * 1.f);
128  if(i % 2 == 0) { registry.assign<Velocity>(entity, i * .1f, i * .1f); }
129  }
130 
131  update(dt, registry);
132  update(registry);
133 
134  // ...
135 }
136 ```
137 
138 ## Motivation
139 
140 I started working on `EnTT` because of the wrong reason: my goal was to design
141 an entity-component system that beated another well known open source solution
142 in terms of performance and used (possibly) less memory in the average
143 case.<br/>
144 In the end, I did it, but it wasn't much satisfying. Actually it wasn't
145 satisfying at all. The fastest and nothing more, fairly little indeed. When I
146 realized it, I tried hard to keep intact the great performance of `EnTT` and to
147 add all the features I wanted to see in *my own library* at the same time.
148 
149 Nowadays, `EnTT` is finally what I was looking for: still faster than its
150 _competitors_, lower memory usage in the average case, a really good API and an
151 amazing set of features. And even more, of course.
152 
153 ## Performance
154 
155 As it stands right now, `EnTT` is just fast enough for my requirements if
156 compared to my first choice (it was already amazingly fast actually).<br/>
157 Below is a comparison between the two (both of them compiled with GCC 7.3.0 on a
158 Dell XPS 13 out of the mid 2014):
159 
160 | Benchmark | EntityX (compile-time) | EnTT |
161 |-----------|-------------|-------------|
162 | Create 1M entities | 0.0147s | **0.0046s** |
163 | Destroy 1M entities | 0.0053s | **0.0045s** |
164 | 1M entities, one component | 0.0012s | **1.9e-07s** |
165 | 1M entities, two components | 0.0012s | **3.8e-07s** |
166 | 1M entities, two components<br/>Half of the entities have all the components | 0.0009s | **3.8e-07s** |
167 | 1M entities, two components<br/>One of the entities has all the components | 0.0008s | **1.0e-06s** |
168 | 1M entities, five components | 0.0010s | **7.0e-07s** |
169 | 1M entities, ten components | 0.0011s | **1.2e-06s** |
170 | 1M entities, ten components<br/>Half of the entities have all the components | 0.0010s | **1.2e-06s** |
171 | 1M entities, ten components<br/>One of the entities has all the components | 0.0008s | **1.2e-06s** |
172 | Sort 150k entities, one component<br/>Arrays are in reverse order | - | **0.0036s** |
173 | Sort 150k entities, enforce permutation<br/>Arrays are in reverse order | - | **0.0005s** |
174 | Sort 150k entities, one component<br/>Arrays are almost sorted, std::sort | - | **0.0035s** |
175 | Sort 150k entities, one component<br/>Arrays are almost sorted, insertion sort | - | **0.0007s** |
176 
177 Note: The default version of `EntityX` (`master` branch) wasn't added to the
178 comparison because it's already much slower than its compile-time counterpart.
179 
180 Pretty interesting, aren't them? In fact, these benchmarks are the same used by
181 `EntityX` to show _how fast it is_. To be honest, they aren't so good and these
182 results shouldn't be taken much seriously (they are completely unrealistic
183 indeed).<br/>
184 The proposed entity-component system is incredibly fast to iterate entities,
185 this is a fact. The compiler can make a lot of optimizations because of how
186 `EnTT` works, even more when components aren't used at all. This is exactly the
187 case for these benchmarks. On the other hand and if we consider real world
188 cases, `EnTT` is in the middle between a bit and much faster than the other
189 solutions around when users also access the components and not just the
190 entities, although it is not as fast as reported by these benchmarks.<br/>
191 This is why they are completely wrong and cannot be used to evaluate any of the
192 entity-component systems.
193 
194 If you decide to use `EnTT`, choose it because of its API, features and
195 performance, not because there is a benchmark somewhere that makes it seem the
196 fastest.
197 
198 Probably I'll try to get out of `EnTT` more features and even better performance
199 in the future, mainly for fun.<br/>
200 If you want to contribute and/or have any suggestion, feel free to make a PR or
201 open an issue to discuss your idea.
202 
203 # Build Instructions
204 
205 ## Requirements
206 
207 To be able to use `EnTT`, users must provide a full-featured compiler that
208 supports at least C++14.<br/>
209 The requirements below are mandatory to compile the tests and to extract the
210 documentation:
211 
212 * CMake version 3.2 or later.
213 * Doxygen version 1.8 or later.
214 
215 ## Library
216 
217 `EnTT` is a header-only library. This means that including the `entt.hpp` header
218 is enough to include the library as a whole and use it. For those who are
219 interested only in the entity-component system, consider to include the sole
220 `entity/registry.hpp` header instead.<br/>
221 It's a matter of adding the following line to the top of a file:
222 
223 ```cpp
224 #include <entt/entt.hpp>
225 ```
226 
227 Use the line below to include only the entity-component system instead:
228 
229 ```cpp
230 #include <entt/entity/registry.hpp>
231 ```
232 
233 Then pass the proper `-I` argument to the compiler to add the `src` directory to
234 the include paths.
235 
236 ## Documentation
237 
238 The documentation is based on [doxygen](http://www.stack.nl/~dimitri/doxygen/).
239 To build it:
240 
241  $ cd build
242  $ cmake .. -DBUILD_DOCS=ON
243  $ make
244 
245 The API reference will be created in HTML format within the directory
246 `build/docs/html`. To navigate it with your favorite browser:
247 
248  $ cd build
249  $ your_favorite_browser docs/html/index.html
250 
251 <!--
252 @cond TURN_OFF_DOXYGEN
253 -->
254 The API reference is also available [online](https://skypjack.github.io/entt/)
255 for the latest version.<br/>
256 There exists also a [wiki](https://github.com/skypjack/entt/wiki) dedicated to
257 the project where users can find all related documentation pages.
258 <!--
259 @endcond TURN_OFF_DOXYGEN
260 -->
261 
262 ## Tests
263 
264 To compile and run the tests, `EnTT` requires *googletest*.<br/>
265 `cmake` will download and compile the library before compiling anything else.
266 In order to build without tests set CMake option `BUILD_TESTING=OFF`.
267 
268 To build the most basic set of tests:
269 
270 * `$ cd build`
271 * `$ cmake ..`
272 * `$ make`
273 * `$ make test`
274 
275 Note that benchmarks are not part of this set.
276 
277 # Packaging Tools
278 
279 `EnTT` is available for some of the most known packaging tools. In particular:
280 
281 * [`vcpkg`](https://github.com/Microsoft/vcpkg/tree/master/ports/entt),
282  Microsoft VC++ Packaging Tool.
283 * [`Homebrew`](https://github.com/skypjack/homebrew-entt), the missing package
284  manager for macOS.<br/>
285  Available as a homebrew formula. Just type the following to install it:
286  ```
287  brew install skypjack/entt/entt
288  ```
289 
290 Consider this list a work in progress and help me to make it longer.
291 
292 # EnTT in Action
293 
294 `EnTT` is widely used in private and commercial applications. I cannot even
295 mention most of them because of some signatures I put on some documents time
296 ago.<br/>
297 Fortunately, there are also people who took the time to implement open source
298 projects based on EnTT and did not hold back when it came to documenting them.
299 
300 Below an incomplete list of projects and articles:
301 
302 * [Minecraft](https://minecraft.net/en-us/attribution/): of course, **that**
303  Minecraft, by Mojang (see the open source attributions page).
304 * [Face Smash](https://play.google.com/store/apps/details?id=com.gamee.facesmash):
305  the emojis dominate the world, destroy them all with your facial expressions.
306 * [shiva](https://github.com/Milerius/shiva): modern C++ Engine with modularity.
307 * [Classic Tower Defence](https://github.com/kerndog73/Classic-Tower-Defence):
308  a tiny little tower defence game featuring a homemade font.
309  [Check it out](https://indi-kernick.itch.io/classic-tower-defence).
310 * [The Machine](https://github.com/Kerndog73/The-Machine): a box pushing puzzler
311  with logic gates and other cool stuff.
312  [Check it out](https://indi-kernick.itch.io/the-machine-web-version).
313 * [EnttPong](https://github.com/reworks/EnttPong): example game with `EnTT`.
314 * [Space Battle: Huge edition](http://victor.madtriangles.com/code%20experiment/2018/06/11/post-ecs-battle-huge.html):
315  huge space battle built entirely from scratch.
316 * [Space Battle](https://github.com/vblanco20-1/ECS_SpaceBattle): huge space
317  battle built on `UE4`.
318 * [Experimenting with ECS in UE4](http://victor.madtriangles.com/code%20experiment/2018/03/25/post-ue4-ecs-battle.html):
319  interesting article about `UE4` and `EnTT`.
320 * [Implementing ECS architecture in UE4](https://forums.unrealengine.com/development-discussion/c-gameplay-programming/1449913-implementing-ecs-architecture-in-ue4-giant-space-battle):
321  giant space battle.
322 * [MatchOneEntt](https://github.com/mhaemmerle/MatchOneEntt): port of
323  [Match One](https://github.com/sschmid/Match-One) for `Entitas-CSharp`.
324 * [Randballs](https://github.com/gale93/randballs): simple `SFML` and `EnTT`
325  playground.
326 * ...
327 
328 If you know of other resources out there that are about `EnTT`, feel free to
329 open an issue or a PR and I'll be glad to add them to the list.
330 
331 <!--
332 @cond TURN_OFF_DOXYGEN
333 -->
334 # Contributors
335 
336 `EnTT` was written initially as a faster alternative to other well known and
337 open source entity-component systems. Nowadays this library is moving its first
338 steps. Much more will come in the future and hopefully I'm going to work on it
339 for a long time.<br/>
340 Requests for features, PR, suggestions ad feedback are highly appreciated.
341 
342 If you find you can help me and want to contribute to the project with your
343 experience or you do want to get part of the project for some other reasons,
344 feel free to contact me directly (you can find the mail in the
345 [profile](https://github.com/skypjack)).<br/>
346 I can't promise that each and every contribution will be accepted, but I can
347 assure that I'll do my best to take them all seriously.
348 
349 If you decide to participate, please see the guidelines for
350 [contributing](docs/CONTRIBUTING.md) before to create issues or pull requests.<br/>
351 Take also a look at the
352 [contributors list](https://github.com/skypjack/entt/blob/master/AUTHORS) to
353 know who has participated so far.
354 <!--
355 @endcond TURN_OFF_DOXYGEN
356 -->
357 
358 # License
359 
360 Code and documentation Copyright (c) 2017-2018 Michele Caini.<br/>
361 Logo Copyright (c) 2018 Richard Caseres.
362 
363 Code released under
364 [the MIT license](https://github.com/skypjack/entt/blob/master/LICENSE).
365 Documentation released under
366 [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/).<br/>
367 Logo released under
368 [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/).
369 
370 <!--
371 @cond TURN_OFF_DOXYGEN
372 -->
373 # Support
374 
375 ## Donation
376 
377 Developing and maintaining `EnTT` takes some time and lots of coffee. I'd like
378 to add more and more functionalities in future and turn it in a full-featured
379 solution.<br/>
380 If you want to support this project, you can offer me an espresso. I'm from
381 Italy, we're used to turning the best coffee ever in code. If you find that
382 it's not enough, feel free to support me the way you prefer.<br/>
383 Take a look at the donation button at the top of the page for more details or
384 just click [here](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=W2HF9FESD5LJY&lc=IT&item_name=Michele%20Caini&currency_code=EUR&bn=PP%2dDonationsBF%3abtn_donateCC_LG%2egif%3aNonHosted).
385 
386 ## Hire me
387 
388 If you start using `EnTT` and need help, if you want a new feature and want me
389 to give it the highest priority, if you have any other reason to contact me:
390 do not hesitate. I'm available for hiring.<br/>
391 Feel free to take a look at my [profile](https://github.com/skypjack) and
392 contact me by mail.
393 <!--
394 @endcond TURN_OFF_DOXYGEN
395 -->
+
1 ![EnTT: Gaming meets modern C++](https://user-images.githubusercontent.com/1812216/42513718-ee6e98d0-8457-11e8-9baf-8d83f61a3097.png)
2 
3 <!--
4 @cond TURN_OFF_DOXYGEN
5 -->
6 [![GitHub version](https://badge.fury.io/gh/skypjack%2Fentt.svg)](http://badge.fury.io/gh/skypjack%2Fentt)
7 [![LoC](https://tokei.rs/b1/github/skypjack/entt)](https://github.com/skypjack/entt)
8 [![Build Status](https://travis-ci.org/skypjack/entt.svg?branch=master)](https://travis-ci.org/skypjack/entt)
9 [![Build status](https://ci.appveyor.com/api/projects/status/rvhaabjmghg715ck?svg=true)](https://ci.appveyor.com/project/skypjack/entt)
10 [![Coverage Status](https://coveralls.io/repos/github/skypjack/entt/badge.svg?branch=master)](https://coveralls.io/github/skypjack/entt?branch=master)
11 [![Gitter chat](https://badges.gitter.im/skypjack/entt.png)](https://gitter.im/skypjack/entt)
12 [![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.me/skypjack)
13 
14 `EnTT` is a header-only, tiny and easy to use library for game programming and
15 much more written in **modern C++**, mainly known for its innovative
16 **entity-component-system (ECS)** model.<br/>
17 [Among others](https://github.com/skypjack/entt/wiki/EnTT-in-Action), it's used
18 in [**Minecraft**](https://minecraft.net/en-us/attribution/) by Mojang, the
19 [**ArcGIS Runtime SDKs**](https://developers.arcgis.com/arcgis-runtime/) by Esri
20 and [**The Forge**](https://github.com/ConfettiFX/The-Forge) by Confetti. Read
21 on to find out what it can offer you.
22 
23 ---
24 
25 Do you want to **keep up with changes** or do you have a **question** that
26 doesn't require you to open an issue?<br/>
27 Join the [gitter channel](https://gitter.im/skypjack/entt) and meet other users
28 like you. The more we are, the better for everyone.
29 
30 If you use `EnTT` and you want to say thanks or support the project, please
31 **consider becoming a patron**:
32 
33 [![Patreon](https://c5.patreon.com/external/logo/become_a_patron_button.png)](https://www.patreon.com/bePatron?c=1772573)
34 
35 # Table of Contents
36 
37 * [Introduction](#introduction)
38  * [Code Example](#code-example)
39  * [Motivation](#motivation)
40  * [Performance](#performance)
41 * [Build Instructions](#build-instructions)
42  * [Requirements](#requirements)
43  * [Library](#library)
44  * [Documentation](#documentation)
45  * [Tests](#tests)
46 * [Packaging Tools](#packaging-tools)
47 * [EnTT in Action](#entt-in-action)
48 * [Contributors](#contributors)
49 * [License](#license)
50 * [Support](#support)
51  * [Patreon](#patreon)
52  * [Donation](#donation)
53  * [Hire me](#hire-me)
54 <!--
55 @endcond TURN_OFF_DOXYGEN
56 -->
57 
58 # Introduction
59 
60 The entity-component-system (also known as _ECS_) is an architectural pattern
61 used mostly in game development. For further details:
62 
63 * [Entity Systems Wiki](http://entity-systems.wikidot.com/)
64 * [Evolve Your Hierarchy](http://cowboyprogramming.com/2007/01/05/evolve-your-heirachy/)
65 * [ECS on Wikipedia](https://en.wikipedia.org/wiki/Entity%E2%80%93component%E2%80%93system)
66 
67 This project started off as a pure entity-component system. Over time the
68 codebase has grown as more and more classes and functionalities were added.<br/>
69 Here is a brief, yet incomplete list of what it offers today:
70 
71 * Statically generated integer **identifiers for types** (assigned either at
72  compile-time or at runtime).
73 * A `constexpr` utility for **human readable resource identifiers**.
74 * A minimal **configuration system** built using the monostate pattern.
75 * An incredibly fast **entity-component system** based on sparse sets, with its
76  own _pay for what you use_ policy to adjust performance and memory usage
77  according to the users' requirements.
78 * Views and groups to iterate entities and components and allow different access
79  patterns, from **perfect SoA** to fully random.
80 * A lot of **facilities** built on top of the entity-component system to support
81  the users and avoid reinventing the wheel (dependencies, snapshot, actor class
82  for those who aren't confident with the architecture and so on).
83 * The smallest and most basic implementation of a **service locator** ever seen.
84 * A built-in, non-intrusive and macro-free **runtime reflection system**.
85 * A **cooperative scheduler** for processes of any type.
86 * All that is needed for **resource management** (cache, loaders, handles).
87 * **Delegates**, **signal handlers** (with built-in support for collectors) and
88  a tiny **event dispatcher** for immediate and delayed events to integrate in
89  loops.
90 * A general purpose **event emitter** as a CRTP idiom based class template.
91 * And **much more**! Check out the
92  [**wiki**](https://github.com/skypjack/entt/wiki).
93 
94 Consider this list a work in progress as well as the project. The whole API is
95 fully documented in-code for those who are brave enough to read it.
96 
97 Currently, `EnTT` is tested on Linux, Microsoft Windows and OSX. It has proven
98 to work also on both Android and iOS.<br/>
99 Most likely it won't be problematic on other systems as well, but it hasn't been
100 sufficiently tested so far.
101 
102 ## Code Example
103 
104 ```cpp
105 #include <entt/entt.hpp>
106 #include <cstdint>
107 
108 struct position {
109  float x;
110  float y;
111 };
112 
113 struct velocity {
114  float dx;
115  float dy;
116 };
117 
118 void update(entt::registry &registry) {
119  auto view = registry.view<position, velocity>();
120 
121  for(auto entity: view) {
122  // gets only the components that are going to be used ...
123 
124  auto &vel = view.get<velocity>(entity);
125 
126  vel.dx = 0.;
127  vel.dy = 0.;
128 
129  // ...
130  }
131 }
132 
133 void update(std::uint64_t dt, entt::registry &registry) {
134  registry.view<position, velocity>().each([dt](auto &pos, auto &vel) {
135  // gets all the components of the view at once ...
136 
137  pos.x += vel.dx * dt;
138  pos.y += vel.dy * dt;
139 
140  // ...
141  });
142 }
143 
144 int main() {
145  entt::registry registry;
146  std::uint64_t dt = 16;
147 
148  for(auto i = 0; i < 10; ++i) {
149  auto entity = registry.create();
150  registry.assign<position>(entity, i * 1.f, i * 1.f);
151  if(i % 2 == 0) { registry.assign<velocity>(entity, i * .1f, i * .1f); }
152  }
153 
154  update(dt, registry);
155  update(registry);
156 
157  // ...
158 }
159 ```
160 
161 ## Motivation
162 
163 I started developing `EnTT` for the _wrong_ reason: my goal was to design an
164 entity-component system to beat another well known open source solution both in
165 terms of performance and possibly memory usage.<br/>
166 In the end, I did it, but it wasn't very satisfying. Actually it wasn't
167 satisfying at all. The fastest and nothing more, fairly little indeed. When I
168 realized it, I tried hard to keep intact the great performance of `EnTT` and to
169 add all the features I wanted to see in *my own library* at the same time.
170 
171 Nowadays, `EnTT` is finally what I was looking for: still faster than its
172 _competitors_, lower memory usage in the average case, a really good API and an
173 amazing set of features. And even more, of course.
174 
175 ## Performance
176 
177 As it stands right now, `EnTT` is just fast enough for my requirements when
178 compared to my first choice (it was already amazingly fast actually).<br/>
179 Below is a comparison between the two (both of them compiled with GCC 7.3.0 on a
180 Dell XPS 13 from mid 2014):
181 
182 | Benchmark | EntityX (compile-time) | EnTT |
183 |-----------|-------------|-------------|
184 | Create 1M entities | 0.0147s | **0.0046s** |
185 | Destroy 1M entities | 0.0053s | **0.0045s** |
186 | 1M entities, one component | 0.0012s | **1.9e-07s** |
187 | 1M entities, two components | 0.0012s | **3.8e-07s** |
188 | 1M entities, two components<br/>Half of the entities have all the components | 0.0009s | **3.8e-07s** |
189 | 1M entities, two components<br/>One of the entities has all the components | 0.0008s | **1.0e-06s** |
190 | 1M entities, five components | 0.0010s | **7.0e-07s** |
191 | 1M entities, ten components | 0.0011s | **1.2e-06s** |
192 | 1M entities, ten components<br/>Half of the entities have all the components | 0.0010s | **1.2e-06s** |
193 | 1M entities, ten components<br/>One of the entities has all the components | 0.0008s | **1.2e-06s** |
194 | Sort 150k entities, one component<br/>Arrays are in reverse order | - | **0.0036s** |
195 | Sort 150k entities, enforce permutation<br/>Arrays are in reverse order | - | **0.0005s** |
196 | Sort 150k entities, one component<br/>Arrays are almost sorted, std::sort | - | **0.0035s** |
197 | Sort 150k entities, one component<br/>Arrays are almost sorted, insertion sort | - | **0.0007s** |
198 
199 Note: The default version of `EntityX` (`master` branch) wasn't added to the
200 comparison because it's already much slower than its compile-time counterpart.
201 
202 Pretty interesting results, aren't them? In fact, these benchmarks are the ones
203 used by `EntityX` to show _how fast it is_. To be honest, they aren't so good
204 and these results shouldn't be taken too seriously (indeed they are completely
205 unrealistic).<br/>
206 The proposed entity-component system is incredibly fast to iterate entities,
207 this is a fact. The compiler can make a lot of optimizations because of how
208 `EnTT` works, even more when components aren't used at all. This is exactly the
209 case for these benchmarks. On the other hand, if we consider real world cases,
210 `EnTT` is somewhere between a bit and much faster than the other solutions
211 around when users also access the components and not just the entities, although
212 it isn't as fast as reported by these benchmarks.<br/>
213 This is why they are completely wrong and cannot be used to evaluate any of the
214 entity-component-system libraries out there.
215 
216 The choice to use `EnTT` should be based on its carefully designed API, its
217 set of features and the general performance, not because some single benchmark
218 shows it to be the fastest tool available.
219 
220 In the future I'll likely try to get even better performance while still adding
221 new features, mainly for fun.<br/>
222 If you want to contribute and/or have suggestions, feel free to make a PR or
223 open an issue to discuss your idea.
224 
225 # Build Instructions
226 
227 ## Requirements
228 
229 To be able to use `EnTT`, users must provide a full-featured compiler that
230 supports at least C++17.<br/>
231 The requirements below are mandatory to compile the tests and to extract the
232 documentation:
233 
234 * CMake version 3.2 or later.
235 * Doxygen version 1.8 or later.
236 
237 If you are looking for a C++14 version of `EnTT`, check out the git tag `cpp14`.
238 
239 ## Library
240 
241 `EnTT` is a header-only library. This means that including the `entt.hpp` header
242 is enough to include the library as a whole and use it. For those who are
243 interested only in the entity-component system, consider to include the sole
244 `entity/registry.hpp` header instead.<br/>
245 It's a matter of adding the following line to the top of a file:
246 
247 ```cpp
248 #include <entt/entt.hpp>
249 ```
250 
251 Use the line below to include only the entity-component system instead:
252 
253 ```cpp
254 #include <entt/entity/registry.hpp>
255 ```
256 
257 Then pass the proper `-I` argument to the compiler to add the `src` directory to
258 the include paths.
259 
260 ## Documentation
261 
262 The documentation is based on [doxygen](http://www.doxygen.nl/).
263 To build it:
264 
265  $ cd build
266  $ cmake .. -DBUILD_DOCS=ON
267  $ make
268 
269 The API reference will be created in HTML format within the directory
270 `build/docs/html`. To navigate it with your favorite browser:
271 
272  $ cd build
273  $ your_favorite_browser docs/html/index.html
274 
275 <!--
276 @cond TURN_OFF_DOXYGEN
277 -->
278 It's also available [online](https://skypjack.github.io/entt/) for the latest
279 version.<br/>
280 Finally, there exists a [wiki](https://github.com/skypjack/entt/wiki) dedicated
281 to the project where users can find all related documentation pages.
282 <!--
283 @endcond TURN_OFF_DOXYGEN
284 -->
285 
286 ## Tests
287 
288 To compile and run the tests, `EnTT` requires *googletest*.<br/>
289 `cmake` will download and compile the library before compiling anything else.
290 In order to build the tests, set the CMake option `BUILD_TESTING` to `ON`.
291 
292 To build the most basic set of tests:
293 
294 * `$ cd build`
295 * `$ cmake -DBUILD_TESTING=ON ..`
296 * `$ make`
297 * `$ make test`
298 
299 Note that benchmarks are not part of this set.
300 
301 # Packaging Tools
302 
303 `EnTT` is available for some of the most known packaging tools. In particular:
304 
305 * [`Conan`](https://bintray.com/skypjack/conan/entt%3Askypjack/_latestVersion),
306  the C/C++ Package Manager for Developers.
307 * [`Homebrew`](https://github.com/skypjack/homebrew-entt), the missing package
308  manager for macOS.<br/>
309  Available as a homebrew formula. Just type the following to install it:
310  ```
311  brew install skypjack/entt/entt
312  ```
313 * [`vcpkg`](https://github.com/Microsoft/vcpkg/tree/master/ports/entt),
314  Microsoft VC++ Packaging Tool.
315 
316 Consider this list a work in progress and help me to make it longer.
317 
318 <!--
319 @cond TURN_OFF_DOXYGEN
320 -->
321 # EnTT in Action
322 
323 `EnTT` is widely used in private and commercial applications. I cannot even
324 mention most of them because of some signatures I put on some documents time
325 ago. Fortunately, there are also people who took the time to implement open
326 source projects based on `EnTT` and did not hold back when it came to
327 documenting them.
328 
329 [Here](https://github.com/skypjack/entt/wiki/EnTT-in-Action) you can find an
330 incomplete list of games, applications and articles that can be used as a
331 reference.
332 
333 If you know of other resources out there that are about `EnTT`, feel free to
334 open an issue or a PR and I'll be glad to add them to the list.
335 
336 # Contributors
337 
338 `EnTT` was written initially as a faster alternative to other well known and
339 open source entity-component systems. Nowadays this library is moving its first
340 steps. Much more will come in the future and hopefully I'm going to work on it
341 for a long time.<br/>
342 Requests for features, PR, suggestions ad feedback are highly appreciated.
343 
344 If you find you can help me and want to contribute to the project with your
345 experience or you do want to get part of the project for some other reasons,
346 feel free to contact me directly (you can find the mail in the
347 [profile](https://github.com/skypjack)).<br/>
348 I can't promise that each and every contribution will be accepted, but I can
349 assure that I'll do my best to take them all seriously.
350 
351 If you decide to participate, please see the guidelines for
352 [contributing](docs/md/CONTRIBUTING.md) before to create issues or pull
353 requests.<br/>
354 Take also a look at the
355 [contributors list](https://github.com/skypjack/entt/blob/master/AUTHORS) to
356 know who has participated so far.
357 <!--
358 @endcond TURN_OFF_DOXYGEN
359 -->
360 
361 # License
362 
363 Code and documentation Copyright (c) 2017-2019 Michele Caini.<br/>
364 Logo Copyright (c) 2018-2019 Richard Caseres.
365 
366 Code released under
367 [the MIT license](https://github.com/skypjack/entt/blob/master/LICENSE).
368 Documentation released under
369 [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/).<br/>
370 Logo released under
371 [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/).
372 
373 <!--
374 @cond TURN_OFF_DOXYGEN
375 -->
376 # Support
377 
378 ## Patreon
379 
380 Become a [patron](https://www.patreon.com/bePatron?c=1772573) and get access to
381 extra content, help me spend more time on the projects you love and create new
382 ones for you. Your support will help me to continue the work done so far and
383 make it more professional and feature-rich every day.<br/>
384 It takes very little to
385 [become a patron](https://www.patreon.com/bePatron?c=1772573) and thus help the
386 software you use every day. Don't miss the chance.
387 
388 ## Donation
389 
390 Developing and maintaining `EnTT` takes some time and lots of coffee. I'd like
391 to add more and more functionalities in future and turn it in a full-featured
392 solution.<br/>
393 If you want to support this project, you can offer me an espresso. I'm from
394 Italy, we're used to turning the best coffee ever in code. If you find that
395 it's not enough, feel free to support me the way you prefer.<br/>
396 Take a look at the donation button at the top of the page for more details or
397 just click [here](https://www.paypal.me/skypjack).
398 
399 ## Hire me
400 
401 If you start using `EnTT` and need help, if you want a new feature and want me
402 to give it the highest priority, if you have any other reason to contact me:
403 do not hesitate. I'm available for hiring.<br/>
404 Feel free to take a look at my [profile](https://github.com/skypjack) and
405 contact me by mail.
406 <!--
407 @endcond TURN_OFF_DOXYGEN
408 -->
Generated by   diff --git a/actor_8hpp_source.html b/actor_8hpp_source.html index 73ed28e1f..bcb40de13 100644 --- a/actor_8hpp_source.html +++ b/actor_8hpp_source.html @@ -22,7 +22,7 @@
EnTT -  2.7.3 +  3.0.0
@@ -67,26 +67,24 @@ $(function() {
actor.hpp
-
1 #ifndef ENTT_ENTITY_ACTOR_HPP
2 #define ENTT_ENTITY_ACTOR_HPP
3 
4 
5 #include <cassert>
6 #include <utility>
7 #include "../config/config.h"
8 #include "registry.hpp"
9 #include "entity.hpp"
10 
11 
12 namespace entt {
13 
14 
23 template<typename Entity>
24 struct Actor {
26  using registry_type = Registry<Entity>;
28  using entity_type = Entity;
29 
34  Actor(Registry<Entity> &reg)
35  : reg{&reg}, entt{reg.create()}
36  {}
37 
39  virtual ~Actor() {
40  reg->destroy(entt);
41  }
42 
44  Actor(const Actor &) = delete;
45 
55  Actor(Actor &&other)
56  : reg{other.reg}, entt{other.entt}
57  {
58  other.entt = entt::null;
59  }
60 
62  Actor & operator=(const Actor &) = delete;
63 
74  Actor & operator=(Actor &&other) {
75  if(this != &other) {
76  auto tmp{std::move(other)};
77  std::swap(reg, tmp.reg);
78  std::swap(entt, tmp.entt);
79  }
80 
81  return *this;
82  }
83 
97  template<typename Tag, typename... Args>
98  Tag & assign(tag_t, Args &&... args) {
99  return (reg->template remove<Tag>(), reg->template assign<Tag>(tag_t{}, entt, std::forward<Args>(args)...));
100  }
101 
116  template<typename Component, typename... Args>
117  Component & assign(Args &&... args) {
118  return reg->template accommodate<Component>(entt, std::forward<Args>(args)...);
119  }
120 
125  template<typename Tag>
126  void remove(tag_t) {
127  assert(has<Tag>(tag_t{}));
128  reg->template remove<Tag>();
129  }
130 
135  template<typename Component>
136  void remove() {
137  reg->template remove<Component>(entt);
138  }
139 
145  template<typename Tag>
146  bool has(tag_t) const ENTT_NOEXCEPT {
147  return (reg->template has<Tag>() && (reg->template attachee<Tag>() == entt));
148  }
149 
155  template<typename Component>
156  bool has() const ENTT_NOEXCEPT {
157  return reg->template has<Component>(entt);
158  }
159 
165  template<typename Tag>
166  const Tag & get(tag_t) const ENTT_NOEXCEPT {
167  assert(has<Tag>(tag_t{}));
168  return reg->template get<Tag>();
169  }
170 
176  template<typename Tag>
177  inline Tag & get(tag_t) ENTT_NOEXCEPT {
178  return const_cast<Tag &>(const_cast<const Actor *>(this)->get<Tag>(tag_t{}));
179  }
180 
186  template<typename Component>
187  const Component & get() const ENTT_NOEXCEPT {
188  return reg->template get<Component>(entt);
189  }
190 
196  template<typename Component>
197  inline Component & get() ENTT_NOEXCEPT {
198  return const_cast<Component &>(const_cast<const Actor *>(this)->get<Component>());
199  }
200 
205  inline const registry_type & registry() const ENTT_NOEXCEPT {
206  return *reg;
207  }
208 
213  inline registry_type & registry() ENTT_NOEXCEPT {
214  return const_cast<registry_type &>(const_cast<const Actor *>(this)->registry());
215  }
216 
221  inline entity_type entity() const ENTT_NOEXCEPT {
222  return entt;
223  }
224 
225 private:
226  registry_type * reg;
227  Entity entt;
228 };
229 
230 
237 using DefaultActor = Actor<DefaultRegistry::entity_type>;
238 
239 
240 }
241 
242 
243 #endif // ENTT_ENTITY_ACTOR_HPP
entt::Actor::registry
registry_type & registry() ENTT_NOEXCEPT
Returns a reference to the underlying registry.
Definition: actor.hpp:213
-
entt::Actor::entity_type
Entity entity_type
Underlying entity identifier.
Definition: actor.hpp:28
-
entt::Actor::registry
const registry_type & registry() const ENTT_NOEXCEPT
Returns a reference to the underlying registry.
Definition: actor.hpp:205
-
entt::Registry
Fast and reliable entity-component system.
Definition: registry.hpp:42
-
entt::Actor::has
bool has() const ENTT_NOEXCEPT
Checks if an actor has the given component.
Definition: actor.hpp:156
-
entt::Actor::operator=
Actor & operator=(Actor &&other)
Move assignment operator.
Definition: actor.hpp:74
-
entt::Actor::Actor
Actor(Registry< Entity > &reg)
Constructs an actor by using the given registry.
Definition: actor.hpp:34
+
1 #ifndef ENTT_ENTITY_ACTOR_HPP
2 #define ENTT_ENTITY_ACTOR_HPP
3 
4 
5 #include <cassert>
6 #include <utility>
7 #include <type_traits>
8 #include "../config/config.h"
9 #include "registry.hpp"
10 #include "entity.hpp"
11 #include "fwd.hpp"
12 
13 
14 namespace entt {
15 
16 
25 template<typename Entity>
26 struct basic_actor {
28  using registry_type = basic_registry<Entity>;
30  using entity_type = Entity;
31 
36  basic_actor(registry_type &ref)
37  : reg{&ref}, entt{ref.create()}
38  {}
39 
41  virtual ~basic_actor() {
42  reg->destroy(entt);
43  }
44 
54  basic_actor(basic_actor &&other)
55  : reg{other.reg}, entt{other.entt}
56  {
57  other.entt = null;
58  }
59 
70  basic_actor & operator=(basic_actor &&other) {
71  if(this != &other) {
72  auto tmp{std::move(other)};
73  std::swap(reg, tmp.reg);
74  std::swap(entt, tmp.entt);
75  }
76 
77  return *this;
78  }
79 
94  template<typename Component, typename... Args>
95  decltype(auto) assign(Args &&... args) {
96  return reg->template assign_or_replace<Component>(entt, std::forward<Args>(args)...);
97  }
98 
103  template<typename Component>
104  void remove() {
105  reg->template remove<Component>(entt);
106  }
107 
113  template<typename Component>
114  bool has() const ENTT_NOEXCEPT {
115  return reg->template has<Component>(entt);
116  }
117 
123  template<typename... Component>
124  decltype(auto) get() const ENTT_NOEXCEPT {
125  return std::as_const(*reg).template get<Component...>(entt);
126  }
127 
129  template<typename... Component>
130  decltype(auto) get() ENTT_NOEXCEPT {
131  return reg->template get<Component...>(entt);
132  }
133 
139  template<typename... Component>
140  auto try_get() const ENTT_NOEXCEPT {
141  return std::as_const(*reg).template try_get<Component...>(entt);
142  }
143 
145  template<typename... Component>
146  auto try_get() ENTT_NOEXCEPT {
147  return reg->template try_get<Component...>(entt);
148  }
149 
154  inline const registry_type & backend() const ENTT_NOEXCEPT {
155  return *reg;
156  }
157 
159  inline registry_type & backend() ENTT_NOEXCEPT {
160  return const_cast<registry_type &>(std::as_const(*this).backend());
161  }
162 
167  inline entity_type entity() const ENTT_NOEXCEPT {
168  return entt;
169  }
170 
171 private:
172  registry_type *reg;
173  Entity entt;
174 };
175 
176 
177 }
178 
179 
180 #endif // ENTT_ENTITY_ACTOR_HPP
entt::basic_actor::assign
decltype(auto) assign(Args &&... args)
Assigns the given component to an actor.
Definition: actor.hpp:95
+
entt::basic_actor::~basic_actor
virtual ~basic_actor()
Default destructor.
Definition: actor.hpp:41
+
entt::basic_actor::has
bool has() const ENTT_NOEXCEPT
Checks if an actor has the given component.
Definition: actor.hpp:114
+
entt::basic_actor::backend
registry_type & backend() ENTT_NOEXCEPT
Returns a reference to the underlying registry.
Definition: actor.hpp:159
+
entt::basic_registry::destroy
void destroy(const entity_type entity)
Destroys an entity and lets the registry recycle the identifier.
Definition: registry.hpp:659
entt
EnTT default namespace.
Definition: algorithm.hpp:10
-
entt::Actor::entity
entity_type entity() const ENTT_NOEXCEPT
Returns the entity associated with an actor.
Definition: actor.hpp:221
-
entt::Registry::destroy
void destroy(tag_t)
Destroys the entity that owns the given tag, if any.
Definition: registry.hpp:556
-
entt::Actor::assign
Tag & assign(tag_t, Args &&... args)
Assigns the given tag to an actor.
Definition: actor.hpp:98
-
entt::null
constexpr auto null
Null entity.
Definition: entity.hpp:78
-
entt::Actor::assign
Component & assign(Args &&... args)
Assigns the given component to an actor.
Definition: actor.hpp:117
-
entt::Actor::has
bool has(tag_t) const ENTT_NOEXCEPT
Checks if an actor owns the given tag.
Definition: actor.hpp:146
-
entt::Registry::create
entity_type create()
Creates a new entity and returns it.
Definition: registry.hpp:521
-
entt::Actor
Dedicated to those who aren&#39;t confident with entity-component systems.
Definition: actor.hpp:24
-
entt::Actor::operator=
Actor & operator=(const Actor &)=delete
Default copy assignment operator.
-
entt::tag_t
Tag class type used to disambiguate overloads.
Definition: utility.hpp:9
-
entt::Actor::Actor
Actor(Actor &&other)
Move constructor.
Definition: actor.hpp:55
-
entt::Actor::~Actor
virtual ~Actor()
Default destructor.
Definition: actor.hpp:39
+
entt::basic_actor::entity_type
Entity entity_type
Underlying entity identifier.
Definition: actor.hpp:30
+
entt::basic_actor::backend
const registry_type & backend() const ENTT_NOEXCEPT
Returns a reference to the underlying registry.
Definition: actor.hpp:154
+
entt::basic_actor::try_get
auto try_get() const ENTT_NOEXCEPT
Returns pointers to the given components for an actor.
Definition: actor.hpp:140
+
entt::null
constexpr auto null
Null entity.
Definition: entity.hpp:163
+
entt::basic_registry
Fast and reliable entity-component system.
Definition: fwd.hpp:13
+
entt::basic_actor::basic_actor
basic_actor(registry_type &ref)
Constructs an actor by using the given registry.
Definition: actor.hpp:36
+
entt::basic_actor::try_get
auto try_get() ENTT_NOEXCEPT
Returns pointers to the given components for an actor.
Definition: actor.hpp:146
+
entt::basic_actor::operator=
basic_actor & operator=(basic_actor &&other)
Move assignment operator.
Definition: actor.hpp:70
+
entt::basic_actor::basic_actor
basic_actor(basic_actor &&other)
Move constructor.
Definition: actor.hpp:54
+
entt::basic_actor::get
decltype(auto) get() const ENTT_NOEXCEPT
Returns references to the given components for an actor.
Definition: actor.hpp:124
+
entt::basic_actor
Dedicated to those who aren&#39;t confident with entity-component systems.
Definition: actor.hpp:26
+
entt::basic_actor::entity
entity_type entity() const ENTT_NOEXCEPT
Returns the entity associated with an actor.
Definition: actor.hpp:167
diff --git a/algorithm_8hpp_source.html b/algorithm_8hpp_source.html index 7f7d52b53..a567db96a 100644 --- a/algorithm_8hpp_source.html +++ b/algorithm_8hpp_source.html @@ -22,7 +22,7 @@
EnTT -  2.7.3 +  3.0.0
@@ -67,13 +67,11 @@ $(function() {
algorithm.hpp
-
1 #ifndef ENTT_CORE_ALGORITHM_HPP
2 #define ENTT_CORE_ALGORITHM_HPP
3 
4 
5 #include <functional>
6 #include <algorithm>
7 #include <utility>
8 
9 
10 namespace entt {
11 
12 
21 struct StdSort final {
35  template<typename It, typename Compare = std::less<>, typename... Args>
36  void operator()(It first, It last, Compare compare = Compare{}, Args &&... args) const {
37  std::sort(std::forward<Args>(args)..., std::move(first), std::move(last), std::move(compare));
38  }
39 };
40 
41 
43 struct InsertionSort final {
55  template<typename It, typename Compare = std::less<>>
56  void operator()(It first, It last, Compare compare = Compare{}) const {
57  auto it = first + 1;
58 
59  while(it != last) {
60  auto value = *it;
61  auto pre = it;
62 
63  while(pre != first && compare(value, *(pre-1))) {
64  *pre = *(pre-1);
65  --pre;
66  }
67 
68  *pre = value;
69  ++it;
70  }
71  }
72 };
73 
74 
76 struct OneShotBubbleSort final {
90  template<typename It, typename Compare = std::less<>>
91  void operator()(It first, It last, Compare compare = Compare{}) const {
92  if(first != last) {
93  auto it = first++;
94 
95  while(first != last) {
96  if(compare(*first, *it)) {
97  using std::swap;
98  std::swap(*first, *it);
99  }
100 
101  it = first++;
102  }
103  }
104  }
105 };
106 
107 
108 }
109 
110 
111 #endif // ENTT_CORE_ALGORITHM_HPP
entt::OneShotBubbleSort
Function object for performing bubble sort (single iteration).
Definition: algorithm.hpp:76
-
entt
EnTT default namespace.
Definition: algorithm.hpp:10
-
entt::OneShotBubbleSort::operator()
void operator()(It first, It last, Compare compare=Compare{}) const
Tries to sort the elements in a range.
Definition: algorithm.hpp:91
-
entt::InsertionSort
Function object for performing insertion sort.
Definition: algorithm.hpp:43
-
entt::StdSort
Function object to wrap std::sort in a class type.
Definition: algorithm.hpp:21
-
entt::InsertionSort::operator()
void operator()(It first, It last, Compare compare=Compare{}) const
Sorts the elements in a range.
Definition: algorithm.hpp:56
-
entt::StdSort::operator()
void operator()(It first, It last, Compare compare=Compare{}, Args &&... args) const
Sorts the elements in a range.
Definition: algorithm.hpp:36
+
1 #ifndef ENTT_CORE_ALGORITHM_HPP
2 #define ENTT_CORE_ALGORITHM_HPP
3 
4 
5 #include <functional>
6 #include <algorithm>
7 #include <utility>
8 
9 
10 namespace entt {
11 
12 
21 struct std_sort {
35  template<typename It, typename Compare = std::less<>, typename... Args>
36  void operator()(It first, It last, Compare compare = Compare{}, Args &&... args) const {
37  std::sort(std::forward<Args>(args)..., std::move(first), std::move(last), std::move(compare));
38  }
39 };
40 
41 
43 struct insertion_sort {
55  template<typename It, typename Compare = std::less<>>
56  void operator()(It first, It last, Compare compare = Compare{}) const {
57  if(first != last) {
58  auto it = first + 1;
59 
60  while(it != last) {
61  auto pre = it++;
62  auto value = *pre;
63 
64  while(pre-- != first && compare(value, *pre)) {
65  *(pre+1) = *pre;
66  }
67 
68  *(pre+1) = value;
69  }
70  }
71  }
72 };
73 
74 
75 }
76 
77 
78 #endif // ENTT_CORE_ALGORITHM_HPP
entt
EnTT default namespace.
Definition: algorithm.hpp:10
+
entt::std_sort::operator()
void operator()(It first, It last, Compare compare=Compare{}, Args &&... args) const
Sorts the elements in a range.
Definition: algorithm.hpp:36
+
entt::insertion_sort::operator()
void operator()(It first, It last, Compare compare=Compare{}) const
Sorts the elements in a range.
Definition: algorithm.hpp:56
+
entt::std_sort
Function object to wrap std::sort in a class type.
Definition: algorithm.hpp:21
+
entt::insertion_sort
Function object for performing insertion sort.
Definition: algorithm.hpp:43
diff --git a/annotated.html b/annotated.html index 2a5af1662..b3fc94346 100644 --- a/annotated.html +++ b/annotated.html @@ -22,7 +22,7 @@
EnTT -  2.7.3 +  3.0.0
@@ -66,53 +66,75 @@ $(function() {
Here are the classes, structs, unions and interfaces with brief descriptions:
[detail level 123]
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
 ▼NenttEnTT default namespace
 CActorDedicated to those who aren't confident with entity-component systems
 CAttacheeAttachee
 CAttachee< Entity >Basic attachee implementation
 CAttachee< Entity, Type >Extended attachee implementation
 CContinuousLoaderUtility class for continuous loading
 CDelegateBasic delegate implementation
 CDelegate< Ret(Args...)>Utility class to send around functions and member functions
 CDispatcherBasic dispatcher implementation
 ▼CEmitterGeneral purpose event emitter
 CConnectionGeneric connection type for events
 Centt_traitsEntity traits
 Centt_traits< std::uint16_t >Entity traits for a 16 bits entity identifier
 Centt_traits< std::uint32_t >Entity traits for a 32 bits entity identifier
 Centt_traits< std::uint64_t >Entity traits for a 64 bits entity identifier
 CFamilyDynamic identifier generator
 CHashedStringZero overhead resource identifier
 CIdentifierTypes identifiers
 CInsertionSortFunction object for performing insertion sort
 CMonostateMinimal implementation of the monostate pattern
 COneShotBubbleSortFunction object for performing bubble sort (single iteration)
 Cpersistent_tPersistent view type used to disambiguate overloads
 CPersistentViewPersistent view
 CProcessBase class for processes
 CProcessAdaptorAdaptor for lambdas and functors to turn them into processes
 CPrototypePrototype container for concepts
 Craw_tRaw view type used to disambiguate overloads
 CRawViewRaw view
 CRegistryFast and reliable entity-component system
 CResourceCacheSimple cache for resources of a given type
 CResourceHandleShared resource handle
 CResourceLoaderBase class for resource loaders
 CRuntimeViewRuntime view
 CSchedulerCooperative scheduler for processes
 CServiceLocatorService locator, nothing more
 CSigHUnmanaged signal handler declaration
 CSigH< Ret(Args...), Collector >Unmanaged signal handler definition
 CSinkSink implementation
 CSink< Ret(Args...)>Sink implementation
 CSnapshotUtility class to create snapshots from a registry
 CSnapshotLoaderUtility class to restore a snapshot as a whole
 CSparseSetSparse set
 CSparseSet< Entity >Basic sparse set implementation
 CSparseSet< Entity, Type >Extended sparse set implementation
 CStdSortFunction object to wrap std::sort in a class type
 Ctag_tTag class type used to disambiguate overloads
 CViewMulti component view
 CView< Entity, Component >Single component view specialization
 Cas_groupConverts a registry to a group
 Cas_viewConverts a registry to a view
 Cbasic_actorDedicated to those who aren't confident with entity-component systems
 Cbasic_continuous_loaderUtility class for continuous loading
 Cbasic_groupGroup
 Cbasic_group< Entity, get_t< Get... > >Non-owning group
 Cbasic_group< Entity, get_t< Get... >, Owned... >Owning group
 Cbasic_prototypePrototype container for concepts
 Cbasic_registryFast and reliable entity-component system
 Cbasic_runtime_viewRuntime view
 Cbasic_snapshotUtility class to create snapshots from a registry
 Cbasic_snapshot_loaderUtility class to restore a snapshot as a whole
 Cbasic_storageBasic storage implementation
 Cbasic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >Basic storage implementation.
 Cbasic_viewMulti component view
 Cbasic_view< Entity, Component >Single component view specialization
 Cconnect_arg_tUsed to wrap a function or a member of a specified type
 CdelegateBasic delegate implementation
 Cdelegate< Ret(Args...)>Utility class to use to send around functions and members
 CdispatcherBasic dispatcher implementation
 ▼CemitterGeneral purpose event emitter
 CconnectionGeneric connection type for events
 Centt_traitsEntity traits
 Centt_traits< std::uint16_t >Entity traits for a 16 bits entity identifier
 Centt_traits< std::uint32_t >Entity traits for a 32 bits entity identifier
 Centt_traits< std::uint64_t >Entity traits for a 64 bits entity identifier
 Cexclude_tAlias for exclusion lists
 CfamilyDynamic identifier generator
 Cget_tAlias for lists of observed components
 Chashed_stringZero overhead unique identifier
 CidentifierTypes identifiers
 Cinsertion_sortFunction object for performing insertion sort
 Cis_named_typeProvides the member constant value to true if a given type has a name. In all other cases, value is false
 Cis_named_type< Type, std::void_t< named_type_traits_t< std::decay_t< Type > > > >Provides the member constant value to true if a given type has a name. In all other cases, value is false
 Cmeta_anyMeta any object
 Cmeta_baseMeta base object
 Cmeta_convMeta conversion function object
 Cmeta_ctorMeta constructor object
 Cmeta_dataMeta data object
 Cmeta_dtorMeta destructor object
 Cmeta_factoryA meta factory to be used for reflection purposes
 Cmeta_funcMeta function object
 Cmeta_handleMeta handle object
 Cmeta_propMeta property object
 Cmeta_typeMeta type object
 CmonostateMinimal implementation of the monostate pattern
 Cnamed_type_traitsTraits class used mainly to push things across boundaries
 Cnamed_type_traits< const Type >Specialization used to get rid of constness
 CprocessBase class for processes
 Cprocess_adaptorAdaptor for lambdas and functors to turn them into processes
 Cresource_cacheSimple cache for resources of a given type
 Cresource_handleShared resource handle
 Cresource_loaderBase class for resource loaders
 CschedulerCooperative scheduler for processes
 Cservice_locatorService locator, nothing more
 CsighUnmanaged signal handler declaration
 Csigh< Ret(Args...), Collector >Unmanaged signal handler definition
 CsinkSink implementation
 Csink< Ret(Args...)>Sink implementation
 Csparse_setBasic sparse set implementation
 Cstd_sortFunction object to wrap std::sort in a class type
 CstorageBasic storage implementation.
 Ctype_listA class to use to push around lists of types, nothing more
 Ctype_list_catPrimary template isn't defined on purpose
 Ctype_list_cat< type_list< Type... > >Concatenates multiple type lists
 Ctype_list_cat< type_list< Type... >, type_list< Other... >, List... >Concatenates multiple type lists
 Ctype_list_uniquePrimary template isn't defined on purpose
 Ctype_list_unique< type_list< Type, Other... > >Removes duplicates types from a type list
 Ctype_list_unique< type_list<> >Removes duplicates types from a type list
diff --git a/attachee_8hpp_source.html b/attachee_8hpp_source.html deleted file mode 100644 index 30ad1c3a0..000000000 --- a/attachee_8hpp_source.html +++ /dev/null @@ -1,91 +0,0 @@ - - - - - - - -EnTT: src/entt/entity/attachee.hpp Source File - - - - - - - - - -
-
- - - - - - -
-
EnTT -  2.7.3 -
-
-
- - - - - - - - -
-
- - -
- -
- - -
-
-
-
attachee.hpp
-
-
-
1 #ifndef ENTT_ENTITY_ATTACHEE_HPP
2 #define ENTT_ENTITY_ATTACHEE_HPP
3 
4 
5 #include <cassert>
6 #include <utility>
7 #include <type_traits>
8 #include "../config/config.h"
9 #include "entity.hpp"
10 
11 
12 namespace entt {
13 
14 
21 template<typename...>
22 class Attachee;
23 
24 
32 template<typename Entity>
33 class Attachee<Entity> {
34 public:
36  using entity_type = Entity;
37 
39  Attachee() ENTT_NOEXCEPT
40  : owner{null}
41  {}
42 
44  Attachee(const Attachee &) = default;
46  Attachee(Attachee &&) = default;
47 
49  Attachee & operator=(const Attachee &) = default;
51  Attachee & operator=(Attachee &&) = default;
52 
54  virtual ~Attachee() ENTT_NOEXCEPT = default;
55 
61  inline entity_type get() const ENTT_NOEXCEPT {
62  return owner;
63  }
64 
76  inline void construct(const entity_type entity) ENTT_NOEXCEPT {
77  assert(owner == null);
78  owner = entity;
79  }
80 
89  virtual void destroy() ENTT_NOEXCEPT {
90  assert(owner != null);
91  owner = null;
92  }
93 
94 private:
95  entity_type owner;
96 };
97 
98 
111 template<typename Entity, typename Type>
112 class Attachee<Entity, Type>: public Attachee<Entity> {
113  using underlying_type = Attachee<Entity>;
114 
115 public:
117  using object_type = Type;
119  using entity_type = typename underlying_type::entity_type;
120 
122  Attachee() ENTT_NOEXCEPT = default;
123 
125  Attachee(const Attachee &) = delete;
127  Attachee(Attachee &&) = delete;
128 
130  Attachee & operator=(const Attachee &) = delete;
132  Attachee & operator=(Attachee &&) = delete;
133 
135  ~Attachee() {
136  if(underlying_type::get() != null) {
137  reinterpret_cast<Type *>(&storage)->~Type();
138  }
139  }
140 
151  const Type & get() const ENTT_NOEXCEPT {
152  assert(underlying_type::get() != null);
153  return *reinterpret_cast<const Type *>(&storage);
154  }
155 
166  Type & get() ENTT_NOEXCEPT {
167  return const_cast<Type &>(const_cast<const Attachee *>(this)->get());
168  }
169 
184  template<typename... Args>
185  Type & construct(entity_type entity, Args &&... args) ENTT_NOEXCEPT {
186  underlying_type::construct(entity);
187  new (&storage) Type{std::forward<Args>(args)...};
188  return *reinterpret_cast<Type *>(&storage);
189  }
190 
199  void destroy() ENTT_NOEXCEPT override {
200  reinterpret_cast<Type *>(&storage)->~Type();
201  underlying_type::destroy();
202  }
203 
217  void move(const entity_type entity) ENTT_NOEXCEPT {
218  underlying_type::destroy();
219  underlying_type::construct(entity);
220  }
221 
222 private:
223  std::aligned_storage_t<sizeof(Type), alignof(Type)> storage;
224 };
225 
226 
227 }
228 
229 
230 #endif // ENTT_ENTITY_ATTACHEE_HPP
entt::Attachee< Entity >::construct
void construct(const entity_type entity) ENTT_NOEXCEPT
Assigns an entity to an attachee.
Definition: attachee.hpp:76
-
entt::Attachee< Entity, Type >::move
void move(const entity_type entity) ENTT_NOEXCEPT
Changes the owner of an attachee.
Definition: attachee.hpp:217
-
entt
EnTT default namespace.
Definition: algorithm.hpp:10
-
entt::Attachee< Entity, Type >::destroy
void destroy() ENTT_NOEXCEPT override
Removes an entity from an attachee and destroies its object.
Definition: attachee.hpp:199
-
entt::null
constexpr auto null
Null entity.
Definition: entity.hpp:78
-
entt::Attachee< Entity, Type >
Extended attachee implementation.
Definition: attachee.hpp:112
-
entt::Attachee< Entity, Type >::object_type
Type object_type
Type of the object associated to the attachee.
Definition: attachee.hpp:117
-
entt::Attachee< Entity >::destroy
virtual void destroy() ENTT_NOEXCEPT
Removes an entity from an attachee.
Definition: attachee.hpp:89
-
entt::Attachee< Entity >
Basic attachee implementation.
Definition: attachee.hpp:33
-
entt::Attachee
Attachee.
Definition: attachee.hpp:22
-
entt::Attachee< Entity >::Attachee
Attachee() ENTT_NOEXCEPT
Default constructor.
Definition: attachee.hpp:39
-
entt::Attachee< Entity >::entity_type
Entity entity_type
Underlying entity identifier.
Definition: attachee.hpp:36
-
entt::Attachee< Entity, Type >::construct
Type & construct(entity_type entity, Args &&... args) ENTT_NOEXCEPT
Assigns an entity to an attachee and constructs its object.
Definition: attachee.hpp:185
-
- -
-Generated by   -doxygen - 1.8.13 -
- - diff --git a/autotoc_md0.html b/autotoc_md0.html index a88903a50..167441aca 100644 --- a/autotoc_md0.html +++ b/autotoc_md0.html @@ -22,7 +22,7 @@
EnTT -  2.7.3 +  3.0.0
@@ -68,7 +68,7 @@ $(function() {
  • If you have a question, please ensure there isn't already an answer for you by searching on GitHub under issues. Do not forget to search also through the closed ones. If you are unable to find a proper answer, feel free to open a new issue. Usually, questions are marked as such and closed in a few days.
  • If you want to fix a typo in the inline documentation or in the README file, if you want to add some new sections or if you want to help me with the language by reviewing what I wrote so far (I'm not a native speaker after all), please open a new pull request with your changes.
    • -
  • If you found a bug, please ensure there isn't already an answer for you by searching on GitHub under issues. If you are unable to find an open issue addressing the problem, feel free to open a new one. Please, do not forget to carefully describe how to reproduce the problem, then add all the informaion about the system on which you are experiencing it and point out the version of EnTT you are using (tag or commit).
    • +
  • If you found a bug, please ensure there isn't already an answer for you by searching on GitHub under issues. If you are unable to find an open issue addressing the problem, feel free to open a new one. Please, do not forget to carefully describe how to reproduce the problem, then add all the information about the system on which you are experiencing it and point out the version of EnTT you are using (tag or commit).
  • If you found a bug and you wrote a patch to fix it, open a new pull request with your code. Please, add some tests to avoid regressions in future if possible, it would be really appreciated. Note that the EnTT framework has a coverage at 100% (at least it was at 100% at the time I wrote this file) and this is the reason for which you can be confident with using it in a production environment.
  • If you want to propose a new feature and you know how to code it, please do not issue directly a pull request. Before to do it, create a new issue to discuss your proposal. Other users could be interested in your idea and the discussion that will follow can refine it and therefore give us a better solution.
  • If you want to request a new feature, I'm available for hiring. Take a look at my profile and feel free to write me.
    • diff --git a/autotoc_md1.html b/autotoc_md1.html index a773bf74f..94de750a1 100644 --- a/autotoc_md1.html +++ b/autotoc_md1.html @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    @@ -71,35 +71,35 @@ Introduction Compile-time identifiers

    Sometimes it's useful to be able to give unique identifiers to types at compile-time.
    There are plenty of different solutions out there and I could have used one of them. However, I decided to spend my time to define a compact and versatile tool that fully embraces what the modern C++ has to offer.

    -

    The result of my efforts is the Identifier class template:

    -
    #include <ident.hpp>
    // defines the identifiers for the given types
    using ID = entt::Identifier<AType, AnotherType>;
    // ...
    switch(aTypeIdentifier) {
    case ID::get<AType>():
    // ...
    break;
    case ID::get<AnotherType>():
    // ...
    break;
    default:
    // ...
    }

    This is all what the class template has to offer: a static get member function that returns a numerical identifier for the given type. It can be used in any context where constant expressions are required.

    +

    The result of my efforts is the identifier class template:

    +
    #include <ident.hpp>
    // defines the identifiers for the given types
    using id = entt::identifier<a_type, another_type>;
    // ...
    switch(a_type_identifier) {
    case id::type<a_type>:
    // ...
    break;
    case id::type<another_type>:
    // ...
    break;
    default:
    // ...
    }

    This is all what the class template has to offer: a type inline variable that contains a numerical identifier for the given type. It can be used in any context where constant expressions are required.

    As long as the list remains unchanged, identifiers are also guaranteed to be the same for every run. In case they have been used in a production environment and a type has to be removed, one can just use a placeholder to left the other identifiers unchanged:

    -
    template<typename> struct IgnoreType {};
    using ID = entt::Identifier<
    ATypeStillValid,
    IgnoreType<ATypeNoLongerValid>,
    AnotherTypeStillValid
    >;

    A bit ugly to see, but it works at least.

    +
    template<typename> struct ignore_type {};
    using id = entt::identifier<
    a_type_still_valid,
    ignore_type<a_type_no_longer_valid>,
    another_type_still_valid
    >;

    A bit ugly to see, but it works at least.

    Runtime identifiers

    Sometimes it's useful to be able to give unique identifiers to types at runtime.
    There are plenty of different solutions out there and I could have used one of them. In fact, I adapted the most common one to my requirements and used it extensively within the entire library.

    -

    It's the Family class. Here is an example of use directly from the entity-component system:

    -
    using component_family = entt::Family<struct InternalRegistryComponentFamily>;
    // ...
    template<typename Component>
    component_type component() const noexcept {
    return component_family::type<Component>();
    }

    This is all what a family has to offer: a type member function that returns a numerical identifier for the given type.

    +

    It's the family class. Here is an example of use directly from the entity-component system:

    +
    using component_family = entt::family<struct internal_registry_component_family>;
    // ...
    template<typename Component>
    component_type component() const noexcept {
    return component_family::type<Component>;
    }

    This is all what a family has to offer: a type inline variable that contains a numerical identifier for the given type.

    Please, note that identifiers aren't guaranteed to be the same for every run. Indeed it mostly depends on the flow of execution.

    Hashed strings

    -

    A hashed string is a zero overhead resource identifier. Users can use human-readable identifiers in the codebase while using their numeric counterparts at runtime, thus without affecting performance.
    +

    A hashed string is a zero overhead unique identifier. Users can use human-readable identifiers in the codebase while using their numeric counterparts at runtime, thus without affecting performance.
    The class has an implicit constexpr constructor that chews a bunch of characters. Once created, all what one can do with it is getting back the original string or converting it into a number.
    The good part is that a hashed string can be used wherever a constant expression is required and no string-to-number conversion will take place at runtime if used carefully.

    Example of use:

    -
    auto load(entt::HashedString::hash_type resource) {
    // uses the numeric representation of the resource to load and return it
    }
    auto resource = load(entt::HashedString{"gui/background"});

    There is also a user defined literal dedicated to hashed strings to make them more user-friendly:

    +
    auto load(entt::hashed_string::hash_type resource) {
    // uses the numeric representation of the resource to load and return it
    }
    auto resource = load(entt::hashed_string{"gui/background"});

    There is also a user defined literal dedicated to hashed strings to make them more user-friendly:

    constexpr auto str = "text"_hs;

    Conflicts

    The hashed string class uses internally FNV-1a to compute the numeric counterpart of a string. Because of the pigeonhole principle, conflicts are possible. This is a fact.
    There is no silver bullet to solve the problem of conflicts when dealing with hashing functions. In this case, the best solution seemed to be to give up. That's all.
    - After all, human-readable resource identifiers aren't something strictly defined and over which users have not the control. Choosing a slightly different identifier is probably the best solution to make the conflict disappear in this case.

    + After all, human-readable unique identifiers aren't something strictly defined and over which users have not the control. Choosing a slightly different identifier is probably the best solution to make the conflict disappear in this case.

    Monostate

    The monostate pattern is often presented as an alternative to a singleton based configuration system. This is exactly its purpose in EnTT. Moreover, this implementation is thread safe by design (hopefully).
    Keys are represented by hashed strings, values are basic types like ints or bools. Values of different types can be associated to each key, even more than one at a time. Because of this, users must pay attention to use the same type both during an assignment and when they try to read back their data. Otherwise, they will probably incur in unexpected results.

    Example of use:

    -
    entt::Monostate<entt::HashedString{"mykey"}>{} = true;
    entt::Monostate<"mykey"_hs>{} = 42;
    // ...
    const bool b = entt::Monostate<"mykey"_hs>{};
    const int i = entt::Monostate<entt::HashedString{"mykey"}>{};
    +
    entt::monostate<entt::hashed_string{"mykey"}>{} = true;
    entt::monostate<"mykey"_hs>{} = 42;
    // ...
    const bool b = entt::monostate<"mykey"_hs>{};
    const int i = entt::monostate<entt::hashed_string{"mykey"}>{};
    Generated by   diff --git a/structentt_1_1internal_1_1Holder-members.html b/autotoc_md46.html similarity index 50% rename from structentt_1_1internal_1_1Holder-members.html rename to autotoc_md46.html index ce09b6137..0b9446397 100644 --- a/structentt_1_1internal_1_1Holder-members.html +++ b/autotoc_md46.html @@ -5,7 +5,7 @@ -EnTT: Member List +EnTT: Frequently Asked Questions @@ -22,7 +22,7 @@
    EnTT -  2.7.2 +  3.0.0
    @@ -57,25 +57,30 @@ $(function() { -
    -
    entt::internal::Holder Member List
    +
    Frequently Asked Questions
    - -

    This is the complete list of members for entt::internal::Holder, including all inherited members.

    - - - - - - -
    data() const ENTT_NOEXCEPT=0 (defined in entt::internal::Holder)entt::internal::Holderpure virtual
    data() ENTT_NOEXCEPT (defined in entt::internal::Holder)entt::internal::Holderinline
    node() const ENTT_NOEXCEPT=0 (defined in entt::internal::Holder)entt::internal::Holderpure virtual
    operator==(const Holder &) const ENTT_NOEXCEPT=0 (defined in entt::internal::Holder)entt::internal::Holderpure virtual
    ~Holder()=default (defined in entt::internal::Holder)entt::internal::Holdervirtual
    +

    +Introduction

    +

    This is a constantly updated section where I'll try to put the answers to the most frequently asked questions.
    + If you don't find your answer here, there are two cases: nobody has done it yet or this section needs updating. In both cases, try to open a new issue or enter the gitter channel and ask your question. Probably someone already has an answer for you and we can then integrate this part of the documentation.

    +

    +FAQ

    +

    +Why is my debug build on Windows so slow?

    +

    EnTT is an experimental project that I also use to keep me up-to-date with the latest revision of the language and the standard library. For this reason, it's likely that some classes you're working with are using standard containers under the hood.
    + Unfortunately, it's known that the standard containers aren't particularly performing in debugging (the reasons for this go beyond this document) and are even less so on Windows apparently. Fortunately this can also be mitigated a lot, achieving good results in many cases.

    +

    First of all, there are two things to do in a Windows project:

    +
      +
    • Disable the /JMC option (Just My Code debugging), available starting in Visual Studio 2017 version 15.8.
      • +
    • Set the _ITERATOR_DEBUG_LEVEL macro to 0. This will disable checked iterators and iterator debugging.
      • +
    +

    Moreover, the macro ENTT_DISABLE_ASSERT should be defined to disable internal checks made by EnTT in debug. These are asserts introduced to help the users, but require to access to the underlying containers and therefore risk ruining the performance in some cases.

    +

    With these changes, debug performance should increase enough for most cases. If you want something more, you can can also switch to an optimization level O0 or preferably O1.

    +
    Generated by   diff --git a/autotoc_md50.html b/autotoc_md50.html new file mode 100644 index 000000000..44cb7fcb8 --- /dev/null +++ b/autotoc_md50.html @@ -0,0 +1,116 @@ + + + + + + + +EnTT: Push EnTT across boundaries + + + + + + + + + +
    +
    + + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + +
    +
    +
    +
    Push EnTT across boundaries
    +
    +
    +

    +Introduction

    +

    EnTT has historically had a limit when used across boundaries on Windows in general and on GNU/Linux when default visibility was set to hidden. The limitation is due mainly to a custom utility used to assign unique, sequential identifiers to different types. Unfortunately, this tool is used by several core classes (the registry among the others) that are thus almost unusable across boundaries.
    + The reasons for that are beyond the purposes of this document. However, the good news is that EnTT also offers now a way to overcome this limit and to push things across boundaries without problems when needed.

    +

    +Named types and traits class

    +

    To allow a type to work properly across boundaries when used by a class that requires to assign unique identifiers to types, users must specialize a class template to literally give a compile-time name to the type itself.
    + The name of the class template is name_type_traits and the specialization must be such that it exposes a static constexpr data member named value having type either ENTT_ID_TYPE or entt::hashed_string::hash_type. Its value is the user defined unique identifier assigned to the specific type.
    + Identifiers are not to be sequentially generated in this case.

    +

    As an example:

    +
    struct my_type { /* ... */ };
    template<>
    struct entt::named_type_traits<my_type> {
    static constexpr auto value = "my_type"_hs;
    };

    Because of the rules of the language, the specialization must reside in the global namespace or in the entt namespace. There is no way to change this rule unfortunately, because it doesn't depend on the library itself.

    +

    The good aspect of this approach is that it's not intrusive at all. The other way around was in fact forcing users to inherit all their classes from a common base. Something to avoid, at least from my point of view.
    + However, despite the fact that it's not intrusive, it would be great if it was also easier to use and a bit less error-prone. This is why a bunch of macros exist to ease defining named types.

    +

    +Do not mix types

    +

    Someone might think that this trick is valid only for the types to push across boundaries. This isn't how things work. In fact, the problem is more complex than that.
    + As a rule of thumb, users should never mix named and non-named types. Whenever a type is given a name, all the types must be given a name. As an example, consider the registry class template: in case it is pushed across boundaries, all the types of components should be assigned a name to avoid subtle bugs.

    +

    Indeed, this constraint can be relaxed in many cases. However, it is difficult to define a general rule to follow that is not the most stringent, unless users know exactly what they are doing. Therefore, I won't elaborate on giving further details on the topic.

    +

    +Macros, macros everywhere

    +

    The library comes with a set of predefined macros to use to declare named types or export already existing ones. In particular:

    +
      +
    • ENTT_NAMED_TYPE can be used to assign a name to already existing types. This macro must be used in the global namespace even when the types to be named are not.
      • +
    +
    ENTT_NAMED_TYPE(my_type)
    ENTT_NAMED_TYPE(ns::another_type)
      +
    • ENTT_NAMED_STRUCT can be used to define and export a struct at the same time. It accepts also an optional namespace in which to define the given type. This macro must be used in the global namespace.
      • +
    +
    ENTT_NAMED_STRUCT(my_type, { /* struct definition */})
    ENTT_NAMED_STRUCT(ns, another_type, { /* struct definition */})
      +
    • ENTT_NAMED_CLASS can be used to define and export a class at the same time. It accepts also an optional namespace in which to define the given type. This macro must be used in the global namespace.
      • +
    +
    ENTT_NAMED_CLASS(my_type, { /* class definition */})
    ENTT_NAMED_CLASS(ns, another_type, { /* class definition */})

    Nested namespaces are supported out of the box as well in all cases. As an example:

    +
    ENTT_NAMED_STRUCT(nested::ns, my_type, { /* struct definition */})

    These macros can be used to avoid specializing the named_type_traits class template. In all cases, the name of the class is used also as a seed to generate the compile-time unique identifier.

    +

    +Conflicts

    +

    When using macros, unique identifiers are 32/64 bit integers generated by hashing strings during compilation. Therefore, conflicts are rare but still possible. In case of conflicts, everything simply will get broken at runtime and the strangest things will probably take place.
    + Unfortunately, there is no safe way to prevent it. If this happens, it will be enough to give a different value to one of the conflicting types to solve the problem. To do this, users can either assign a different name to the class or directly define a specialization for the named_type_traits class template.

    +

    +Allocations: the dark side of the force

    +

    As long as EnTT won't support custom allocators, another problem with allocations will remain alive instead. This is in fact easily solved, or at least it is if one knows it.

    +

    To allow users to add types dynamically, the library makes extensive use of type erasure techniques and dynamic allocations for pools (whether they are for components, events or anything else). The problem occurs when, for example, a registry is created on one side of a boundary and a pool is dynamically created on the other side. In the best case, everything will crash at the exit, while at worst it will do so at runtime.
    + To avoid problems, the pools must be generated from the same side of the boundary where the object that owns them is also created. As an example, when the registry is created in the main executable and used across boundaries for a given type of component, the pool for that type must be created before passing around the registry itself. To do this is fortunately quite easy, since it is sufficient to invoke any of the methods that involve the given type (continuing the example with the registry, a call to reserve or size is more than enough).

    +

    Maybe one day some dedicated methods will be added that do nothing but create a pool for a given type. Until now it has been preferred to keep the API cleaner as they are not strictly necessary.

    +
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/autotoc_md52.html b/autotoc_md52.html deleted file mode 100644 index f6fb54a2e..000000000 --- a/autotoc_md52.html +++ /dev/null @@ -1,84 +0,0 @@ - - - - - - - -EnTT: EnTT and shared libraries - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - -
    -
    -
    -
    EnTT and shared libraries
    -
    -
    -

    To make sure that an application and a shared library that use both EnTT can interact correctly when symbols are hidden by default, there are some tricks to follow.
    - In particular and in order to avoid undefined behaviors, all the instantiation of the Family class template shall be made explicit along with the system-wide specifier to use to export them.

    -

    At the time I'm writing this document, the classes that use internally the above mentioned class template are Dispatcher, Emitter and Registry. Therefore and as an example, if you use the Registry class template in your shared library and want to set symbols visibility to hidden by default, the following lines are required to allow it to function properly with a client that also uses the Registry somehow:

    -
      -
    • On GNU/Linux:
      • -
    -
    namespace entt {
    template class __attribute__((visibility("default"))) Family<struct InternalRegistryTagFamily>;
    template class __attribute__((visibility("default"))) Family<struct InternalRegistryComponentFamily>;
    template class __attribute__((visibility("default"))) Family<struct InternalRegistryHandlerFamily>;
    }
      -
    • On Windows:
      • -
    -
    namespace entt {
    template class __declspec(dllexport) Family<struct InternalRegistryTagFamily>;
    template class __declspec(dllexport) Family<struct InternalRegistryComponentFamily>;
    template class __declspec(dllexport) Family<struct InternalRegistryHandlerFamily>;
    }

    Otherwise, the risk is that type identifiers are different between the shared library and the application and this will prevent the whole thing from functioning correctly for obvious reasons.

    -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/autotoc_md53.html b/autotoc_md53.html deleted file mode 100644 index 66fc871f2..000000000 --- a/autotoc_md53.html +++ /dev/null @@ -1,147 +0,0 @@ - - - - - - - -EnTT: Crash Course: events, signals and everything in between - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - -
    -
    -
    -
    Crash Course: events, signals and everything in between
    -
    -
    -

    -Introduction

    -

    Signals are usually a core part of games and software architectures in general.
    - Roughly speaking, they help to decouple the various parts of a system while allowing them to communicate with each other somehow.

    -

    The so called _modern C++_ comes with a tool that can be useful in these terms, the std::function. As an example, it can be used to create delegates.
    - However, there is no guarantee that an std::function does not perform allocations under the hood and this could be problematic sometimes. Furthermore, it solves a problem but may not adapt well to other requirements that may arise from time to time.

    -

    In case that the flexibility and potential of an std::function are not required or where you are looking for something different, EnTT offers a full set of classes to solve completely different problems.

    -

    -Signals

    -

    Signal handlers work with naked pointers, function pointers and pointers to member functions. Listeners can be any kind of objects and users are in charge of connecting and disconnecting them from a signal to avoid crashes due to different lifetimes. On the other side, performance shouldn't be affected that much by the presence of such a signal handler.
    - A signal handler can be used as a private data member without exposing any publish functionality to the clients of a class. The basic idea is to impose a clear separation between the signal itself and its sink class, that is a tool to be used to connect and disconnect listeners on the fly.

    -

    The API of a signal handler is straightforward. The most important thing is that it comes in two forms: with and without a collector. In case a signal is associated with a collector, all the values returned by the listeners can be literally collected and used later by the caller. Otherwise it works just like a plain signal that emits events from time to time.
    -

    -

    Note: collectors are allowed only in case of function types whose the return type isn't void for obvious reasons.

    -

    To create instances of signal handlers there exist mainly two ways:

    -
    // no collector type
    entt::SigH<void(int, char)> signal;
    // explicit collector type
    entt::SigH<void(int, char), MyCollector<bool>> collector;

    As expected, they offer all the basic functionalities required to know how many listeners they contain (size) or if they contain at least a listener (empty) and even to swap two signal handlers (swap).

    -

    Besides them, there are member functions to use both to connect and disconnect listeners in all their forms by means of a sink:

    -
    void foo(int, char) { /* ... */ }
    struct S {
    void bar(int, char) { /* ... */ }
    };
    // ...
    S instance;
    signal.sink().connect<&foo>();
    signal.sink().connect<S, &S::bar>(&instance);
    // ...
    // disconnects a free function
    signal.sink().disconnect<&foo>();
    // disconnect a specific member function of an instance ...
    signal.sink().disconnect<S, &S::bar>(&instance);
    // ... or an instance as a whole
    signal.sink().disconnect(&instance);
    // discards all the listeners at once
    signal.sink().disconnect();

    Once listeners are attached (or even if there are no listeners at all), events and data in general can be published through a signal by means of the publish member function:

    -
    signal.publish(42, 'c');

    To collect data, the collect member function should be used instead. Below is a minimal example to show how to use it:

    -
    struct MyCollector {
    std::vector<int> vec{};
    bool operator()(int v) noexcept {
    vec.push_back(v);
    return true;
    }
    };
    int f() { return 0; }
    int g() { return 1; }
    // ...
    entt::SigH<int(), MyCollector<int>> signal;
    signal.sink().connect<&f>();
    signal.sink().connect<&g>();
    MyCollector collector = signal.collect();
    assert(collector.vec[0] == 0);
    assert(collector.vec[1] == 1);

    As shown above, a collector must expose a function operator that accepts as an argument a type to which the return type of the listeners can be converted. Moreover, it has to return a boolean value that is false to stop collecting data, true otherwise. This way one can avoid calling all the listeners in case it isn't necessary.

    -

    -Delegate

    -

    A delegate can be used as general purpose invoker with no memory overhead for free functions and member functions provided along with an instance on which to invoke them.
    - It does not claim to be a drop-in replacement for an std::function, so do not expect to use it whenever an std::function fits well. However, it can be used to send opaque delegates around to be used to invoke functions as needed.

    -

    The interface is trivial. It offers a default constructor to create empty delegates:

    -
    entt::Delegate<int(int)> delegate{};

    All what is needed to create an instance is to specify the type of the function the delegate will contain, that is the signature of the free function or the member function one wants to assign to it.

    -

    Attempting to use an empty delegate by invoking its function call operator results in undefined behavior, most likely a crash actually. Before to use a delegate, it must be initialized.
    - There exist two functions to do that, both named connect:

    -
    int f(int i) { return i; }
    struct MyStruct {
    int f(int i) { return i }
    };
    // bind a free function to the delegate
    delegate.connect<&f>();
    // bind a member function to the delegate
    MyStruct instance;
    delegate.connect<MyStruct, &MyStruct::f>(&instance);

    It hasn't a disconnect counterpart. Instead, there exists a reset member function to clear it.
    - The empty member function can be used to know if a delegate is empty:

    -
    const auto empty = delegate.empty();

    Finally, to invoke a delegate, the function call operator is the way to go as usual:

    -
    auto ret = delegate(42);

    Probably too much small and pretty poor of functionalities, but the delegate class can help in a lot of cases and it has shown that it is worth keeping it within the library.

    -

    -Event dispatcher

    -

    The event dispatcher class is designed so as to be used in a loop. It allows users both to trigger immediate events or to queue events to be published all together once per tick.
    - This class shares part of its API with the one of the signal handler, but it doesn't require that all the types of events are specified when declared:

    -
    // define a general purpose dispatcher that works with naked pointers
    entt::Dispatcher dispatcher{};

    In order to register an instance of a class to a dispatcher, its type must expose one or more member functions of which the return types are void and the argument lists are const E &, for each type of event E.
    - To ease the development, member functions that are named receive are automatically detected and have not to be explicitly specified when registered. In all the other cases, the name of the member function aimed to receive the event must be provided to the connect member function of the sink bound to the specific event:

    -
    struct AnEvent { int value; };
    struct AnotherEvent {};
    struct Listener
    {
    void receive(const AnEvent &) { /* ... */ }
    void method(const AnotherEvent &) { /* ... */ }
    };
    // ...
    Listener listener;
    dispatcher.sink<AnEvent>().connect(&listener);
    dispatcher.sink<AnotherEvent>().connect<Listener, &Listener::method>(&listener);

    The disconnect member function follows the same pattern and can be used to selectively remove listeners:

    -
    dispatcher.sink<AnEvent>().disconnect(&listener);
    dispatcher.sink<AnotherEvent>().disconnect<Listener, &Listener::method>(&listener);

    The trigger member function serves the purpose of sending an immediate event to all the listeners registered so far. It offers a convenient approach that relieves users from having to create the event itself. Instead, it's enough to specify the type of event and provide all the parameters required to construct it.
    - As an example:

    -
    dispatcher.trigger<AnEvent>(42);
    dispatcher.trigger<AnotherEvent>();

    Listeners are invoked immediately, order of execution isn't guaranteed. This method can be used to push around urgent messages like an is terminating notification on a mobile app.

    -

    On the other hand, the enqueue member function queues messages together and allows to maintain control over the moment they are sent to listeners. The signature of this method is more or less the same of trigger:

    -
    dispatcher.enqueue<AnEvent>(42);
    dispatcher.enqueue<AnotherEvent>();

    Events are stored aside until the update member function is invoked, then all the messages that are still pending are sent to the listeners at once:

    -
    // emits all the events of the given type at once
    dispatcher.update<MyEvent>();
    // emits all the events queued so far at once
    dispatcher.update();

    This way users can embed the dispatcher in a loop and literally dispatch events once per tick to their systems.

    -

    -Event emitter

    -

    A general purpose event emitter thought mainly for those cases where it comes to working with asynchronous stuff.
    - Originally designed to fit the requirements of uvw (a wrapper for libuv written in modern C++), it was adapted later to be included in this library.

    -

    To create a custom emitter type, derived classes must inherit directly from the base class as:

    -
    struct MyEmitter: Emitter<MyEmitter> {
    // ...
    }

    The full list of accepted types of events isn't required. Handlers are created internally on the fly and thus each type of event is accepted by default.

    -

    Whenever an event is published, an emitter provides the listeners with a reference to itself along with a const reference to the event. Therefore listeners have an handy way to work with it without incurring in the need of capturing a reference to the emitter itself.
    - In addition, an opaque object is returned each time a connection is established between an emitter and a listener, allowing the caller to disconnect them at a later time.
    - The opaque object used to handle connections is both movable and copyable. On the other side, an event emitter is movable but not copyable by default.

    -

    To create new instances of an emitter, no arguments are required:

    -
    MyEmitter emitter{};

    Listeners must be movable and callable objects (free functions, lambdas, functors, std::functions, whatever) whose function type is:

    -
    void(const Event &, MyEmitter &)

    Where Event is the type of event they want to listen.
    - There are two ways to attach a listener to an event emitter that differ slightly from each other:

    -
      -
    • To register a long-lived listener, use the on member function. It is meant to register a listener designed to be invoked more than once for the given event type.
      - As an example:
      • -
    -
    auto conn = emitter.on<MyEvent>([](const MyEvent &event, MyEmitter &emitter) {
    // ...
    });

    The connection object can be freely discarded. Otherwise, it can be used later to disconnect the listener if required.

    -
      -
    • To register a short-lived listener, use the once member function. It is meant to register a listener designed to be invoked only once for the given event type. The listener is automatically disconnected after the first invocation.
      - As an example:
      • -
    -
    auto conn = emitter.once<MyEvent>([](const MyEvent &event, MyEmitter &emitter) {
    // ...
    });

    The connection object can be freely discarded. Otherwise, it can be used later to disconnect the listener if required.

    -

    In both cases, the connection object can be used with the erase member function:

    -
    emitter.erase(conn);

    There are also two member functions to use either to disconnect all the listeners for a given type of event or to clear the emitter:

    -
    // removes all the listener for the specific event
    emitter.clear<MyEvent>();
    // removes all the listeners registered so far
    emitter.clear();

    To send an event to all the listeners that are interested in it, the publish member function offers a convenient approach that relieves users from having to create the event:

    -
    struct MyEvent { int i; };
    // ...
    emitter.publish<MyEvent>(42);

    Finally, the empty member function tests if there exists at least either a listener registered with the event emitter or to a given type of event:

    -
    bool empty;
    // checks if there is any listener registered for the specific event
    empty = emitter.empty<MyEvent>();
    // checks it there are listeners registered with the event emitter
    empty = emitter.empty();

    In general, the event emitter is a handy tool when the derived classes wrap asynchronous operations, because it introduces a nice-to-have model based on events and listeners that kindly hides the complexity behind the scenes. However it is not limited to such uses.

    -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/autotoc_md57.html b/autotoc_md57.html new file mode 100644 index 000000000..6e402c603 --- /dev/null +++ b/autotoc_md57.html @@ -0,0 +1,120 @@ + + + + + + + +EnTT: EnTT in Action + + + + + + + + + +
    +
    + + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + +
    +
    +
    +
    EnTT in Action
    +
    +
    +

    EnTT is widely used in private and commercial applications. I cannot even mention most of them because of some signatures I put on some documents time ago. Fortunately, there are also people who took the time to implement open source projects based on EnTT and did not hold back when it came to documenting them.

    +

    Below an incomplete list of games, applications and articles that can be used as a reference. Where I put the word apparently means that the use of EnTT is documented but the authors didn't make explicit announcements or contacted me directly.

    +

    I hope this list can grow much more in the future:

    + +

    If you know of other resources out there that are about EnTT, feel free to open an issue or a PR and I'll be glad to add them to this page.

    +
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/autotoc_md41.html b/autotoc_md58.html similarity index 56% rename from autotoc_md41.html rename to autotoc_md58.html index 9cf9e38a1..7f31e4b1e 100644 --- a/autotoc_md41.html +++ b/autotoc_md58.html @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    @@ -63,17 +63,17 @@ $(function() {
    Crash Course: service locator
    -

    +

    Introduction

    Usually service locators are tightly bound to the services they expose and it's hard to define a general purpose solution. This template based implementation tries to fill the gap and to get rid of the burden of defining a different specific locator for each application.
    This class is tiny, partially unsafe and thus risky to use. Moreover it doesn't fit probably most of the scenarios in which a service locator is required. Look at it as a small tool that can sometimes be useful if users know how to handle it.

    -

    +

    Service locator

    The API is straightforward. The basic idea is that services are implemented by means of interfaces and rely on polymorphism.
    The locator is instantiated with the base type of the service if any and a concrete implementation is provided along with all the parameters required to initialize it. As an example:

    -
    // the service has no base type, a locator is used to treat it as a kind of singleton
    entt::ServiceLocator<MyService>::set(params...);
    // sets up an opaque service
    entt::ServiceLocator<AudioInterface>::set<AudioImplementation>(params...);
    // resets (destroys) the service
    entt::ServiceLocator<AudioInterface>::reset();

    The locator can also be queried to know if an active service is currently set and to retrieve it if necessary (either as a pointer or as a reference):

    -
    // no service currently set
    auto empty = entt::ServiceLocator<AudioInterface>::empty();
    // gets a (possibly empty) shared pointer to the service ...
    std::shared_ptr<AudioInterface> ptr = entt::ServiceLocator<AudioInterface>::get();
    // ... or a reference, but it's undefined behaviour if the service isn't set yet
    AudioInterface &ref = entt::ServiceLocator<AudioInterface>::ref();

    A common use is to wrap the different locators in a container class, creating aliases for the various services:

    -
    struct Locator {
    using Camera = entt::ServiceLocator<CameraInterface>;
    using Audio = entt::ServiceLocator<AudioInterface>;
    // ...
    };
    // ...
    void init() {
    Locator::Camera::set<CameraNull>();
    Locator::Audio::set<AudioImplementation>(params...);
    // ...
    }

    +
    // the service has no base type, a locator is used to treat it as a kind of singleton
    entt::service_locator<my_service>::set(params...);
    // sets up an opaque service
    entt::service_locator<audio_interface>::set<audio_implementation>(params...);
    // resets (destroys) the service
    entt::service_locator<audio_interface>::reset();

    The locator can also be queried to know if an active service is currently set and to retrieve it if necessary (either as a pointer or as a reference):

    +
    // no service currently set
    auto empty = entt::service_locator<audio_interface>::empty();
    // gets a (possibly empty) shared pointer to the service ...
    std::shared_ptr<audio_interface> ptr = entt::service_locator<audio_interface>::get();
    // ... or a reference, but it's undefined behaviour if the service isn't set yet
    audio_interface &ref = entt::service_locator<audio_interface>::ref();

    A common use is to wrap the different locators in a container class, creating aliases for the various services:

    +
    struct locator {
    using camera = entt::service_locator<camera_interface>;
    using audio = entt::service_locator<audio_interface>;
    // ...
    };
    // ...
    void init() {
    locator::camera::set<camera_null>();
    locator::audio::set<audio_implementation>(params...);
    // ...
    }
    Generated by   diff --git a/autotoc_md61.html b/autotoc_md61.html new file mode 100644 index 000000000..b04a4569a --- /dev/null +++ b/autotoc_md61.html @@ -0,0 +1,193 @@ + + + + + + + +EnTT: Crash Course: reflection system + + + + + + + + + +
    +
    + + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + +
    +
    +
    +
    Crash Course: reflection system
    +
    +
    +

    +Introduction

    +

    Reflection (or rather, its lack) is a trending topic in the C++ world and, in the specific case of EnTT, a tool that can unlock a lot of other features. I looked for a third-party library that met my needs on the subject, but I always came across some details that I didn't like: macros, being intrusive, too many allocations. In one word: unsatisfactory.
    + I finally decided to write a built-in, non-intrusive and macro-free runtime reflection system for EnTT. Maybe I didn't do better than others or maybe yes, time will tell me, but at least I can model this tool around the library to which it belongs and not vice versa.

    +

    +Reflection in a nutshell

    +

    Reflection always starts from real types (users cannot reflect imaginary types and it would not make much sense, we wouldn't be talking about reflection anymore).
    + To reflect a type, the library provides the reflect function:

    +
    auto factory = entt::reflect<my_type>("reflected_type");

    It accepts the type to reflect as a template parameter and an optional name as an argument. Names are important because users can retrieve meta types at runtime by searching for them by name. However, there are cases in which users can be interested in adding features to a reflected type so that the reflection system can use it correctly under the hood, but they don't want to allow searching the type by name.
    + In both cases, the returned value is a factory object to use to continue building the meta type.

    +

    A factory is such that all its member functions returns the factory itself. It can be used to extend the reflected type and add the following:

    +
      +
    • Constructors. Actual constructors can be assigned to a reflected type by specifying their list of arguments. Free functions (namely, factories) can be used as well, as long as the return type is the expected one. From a client's point of view, nothing changes if a constructor is a free function or an actual constructor.
      + Use the ctor member function for this purpose:
      • +
    +
    entt::reflect<my_type>("reflected").ctor<int, char>().ctor<&factory>();
      +
    • Destructors. Free functions can be set as destructors of reflected types. The purpose is to give users the ability to free up resources that require special treatment before an object is actually destroyed.
      + Use the dtor member function for this purpose:
      • +
    +
    entt::reflect<my_type>("reflected").dtor<&destroy>();
      +
    • Data members. Both real data members of the underlying type and static and global variables, as well as constants of any kind, can be attached to a meta type. From a client's point of view, all the variables associated with the reflected type will appear as if they were part of the type itself.
      + Use the data member function for this purpose:
      • +
    +
    entt::reflect<my_type>("reflected")
    .data<&my_type::static_variable>("static")
    .data<&my_type::data_member>("member")
    .data<&global_variable>("global");

    This function requires as an argument the name to give to the meta data once created. Users can then access meta data at runtime by searching for them by name.
    + Data members can be set also by means of a couple of functions, namely a setter and a getter. Setters and getters can be either free functions, member functions or mixed ones, as long as they respect the required signatures.
    + Refer to the inline documentation for all the details.

    +
      +
    • Member functions. Both real member functions of the underlying type and free functions can be attached to a meta type. From a client's point of view, all the functions associated with the reflected type will appear as if they were part of the type itself.
      + Use the func member function for this purpose:
      • +
    +
    entt::reflect<my_type>("reflected")
    .func<&my_type::static_function>("static")
    .func<&my_type::member_function>("member")
    .func<&free_function>("free");

    This function requires as an argument the name to give to the meta function once created. Users can then access meta functions at runtime by searching for them by name.

    +
      +
    • Base classes. A base class is such that the underlying type is actually derived from it. In this case, the reflection system tracks the relationship and allows for implicit casts at runtime when required.
      + Use the base member function for this purpose:
      • +
    +
    entt::reflect<derived_type>("derived").base<base_type>();

    From now on, wherever a base_type is required, an instance of derived_type will also be accepted.

    +
      +
    • Conversion functions. Actual types can be converted, this is a fact. Just think of the relationship between a double and an int to see it. Similar to bases, conversion functions allow users to define conversions that will be implicitly performed by the reflection system when required.
      + Use the conv member function for this purpose:
      • +
    +
    entt::reflect<double>().conv<int>();

    That's all, everything users need to create meta types and enjoy the reflection system. At first glance it may not seem that much, but users usually learn to appreciate it over time.
    + Also, do not forget what these few lines hide under the hood: a built-in, non-intrusive and macro-free system for reflection in C++. Features that are definitely worth the price, at least for me.

    +

    +Any as in any type

    +

    The reflection system comes with its own meta any type. It may seem redundant since C++17 introduced std::any, but it is not.
    + In fact, the type returned by an std::any is a const reference to an std::type_info, an implementation defined class that's not something everyone wants to see in a software. Furthermore, the class std::type_info suffers from some design flaws and there is even no way to convert an std::type_info into a meta type, thus linking the two worlds.

    +

    A meta any object provides an API similar to that of its most famous counterpart and serves the same purpose of being an opaque container for any type of value.
    + It minimizes the allocations required, which are almost absent thanks to SBO techniques. In fact, unless users deal with fat types and create instances of them though the reflection system, allocations are at zero.

    +

    A meta any object can be created by any other object or as an empty container to initialize later:

    +
    // a meta any object that contains an int
    entt::meta_any any{0};
    // an empty meta any object
    entt::meta_any empty{};

    It can be constructed or assigned by copy and move and it takes the burden of destroying the contained object when required.
    + A meta any object has a type member function that returns the meta type of the contained value, if any. The member functions can_cast and can_convert are used to know if the underlying object has a given type as a base or if it can be converted implicitly to it. Similarly, cast and convert do what they promise and return the expected value.

    +

    +Enjoy the runtime

    +

    Once the web of reflected types has been constructed, it's a matter of using it at runtime where required.
    + All this has the great merit that, unlike the vast majority of the things present in this library and closely linked to the compile-time, the reflection system stands in fact as a non-intrusive tool for the runtime.

    +

    To search for a reflected type there are two options: by type or by name. In both cases, the search can be done by means of the resolve function:

    +
    // search for a reflected type by type
    auto by_type = entt::resolve<my_type>();
    // search for a reflected type by name
    auto by_name = entt::resolve("reflected_type");

    There exits also a third overload of the resolve function to use to iterate all the reflected types at once:

    +
    resolve([](auto type) {
    // ...
    });

    In all cases, the returned value is an instance of meta_type. This type of objects offer an API to know the runtime name of the type, to iterate all the meta objects associated with them and even to build or destroy instances of the underlying type.
    + Refer to the inline documentation for all the details.

    +

    The meta objects that compose a meta type are accessed in the following ways:

    +
      +
    • Meta constructors. They are accessed by types of arguments:
      • +
    +
    auto ctor = entt::resolve<my_type>().ctor<int, char>();

    The returned type is meta_ctor and may be invalid if there is no constructor that accepts the supplied arguments or at least some types from which they are derived or to which they can be converted.
    + A meta constructor offers an API to know the number of arguments, the expected meta types and to invoke it, therefore to construct a new instance of the underlying type.

    +
      +
    • Meta destructor. It's returned by a dedicated function:
      • +
    +
    auto dtor = entt::resolve<my_type>().dtor();

    The returned type is meta_dtor and may be invalid if there is no custom destructor set for the given meta type.
    + All what a meta destructor has to offer is a way to invoke it on a given instance. Be aware that the result may not be what is expected.

    +
      +
    • Meta data. They are accessed by name:
      • +
    +
    auto data = entt::resolve<my_type>().data("member");

    The returned type is meta_data and may be invalid if there is no meta data object associated with the given name.
    + A meta data object offers an API to query the underlying type (ie to know if it's a const or a static one), to get the meta type of the variable and to set or get the contained value.

    +
      +
    • Meta functions. They are accessed by name:
      • +
    +
    auto func = entt::resolve<my_type>().func("member");

    The returned type is meta_func and may be invalid if there is no meta function object associated with the given name.
    + A meta function object offers an API to query the underlying type (ie to know if it's a const or a static function), to know the number of arguments, the meta return type and the meta types of the parameters. In addition, a meta function object can be used to invoke the underlying function and then get the return value in the form of meta any object.

    +
      +
    • Meta bases. They are accessed through the name of the base types:
      • +
    +
    auto base = entt::resolve<derived_type>().base("base");

    The returned type is meta_base and may be invalid if there is no meta base object associated with the given name.
    + Meta bases aren't meant to be used directly, even though they are freely accessible. They expose only a few methods to use to know the meta type of the base class and to convert a raw pointer between types.

    +
      +
    • Meta conversion functions. They are accessed by type:
      • +
    +
    auto conv = entt::resolve<double>().conv<int>();

    The returned type is meta_conv and may be invalid if there is no meta conversion function associated with the given type.
    + The meta conversion functions are as thin as the meta bases and with a very similar interface. The sole difference is that they return a newly created instance wrapped in a meta any object when they convert between different types.

    +

    All the objects thus obtained as well as the meta types can be explicitly converted to a boolean value to check if they are valid:

    +
    auto func = entt::resolve<my_type>().func("member");
    if(func) {
    // ...
    }

    Furthermore, all meta objects with the exception of meta destructors can be iterated through an overload that accepts a callback through which to return them. As an example:

    +
    entt::resolve<my_type>().data([](auto data) {
    // ...
    });

    A meta type can also be used to construct or destroy actual instances of the underlying type.
    + In particular, the construct member function accepts a variable number of arguments and searches for a match. It returns a meta_any object that may or may not be initialized, depending on whether a suitable constructor has been found or not. On the other side, the destroy member function accepts instances of meta_any as well as actual objects by reference and invokes the registered destructor if any or a default one.
    + Be aware that the result of a call to destroy may not be what is expected.

    +

    Meta types and meta objects in general contain much more than what is said: a plethora of functions in addition to those listed whose purposes and uses go unfortunately beyond the scope of this document.
    + I invite anyone interested in the subject to look at the code, experiment and read the official documentation to get the best out of this powerful tool.

    +

    +Named constants and enums

    +

    A special mention should be made for constant values and enums. It wouldn't be necessary, but it will help distracted readers.

    +

    As mentioned, the data member function can be used to reflect constants of any type among the other things.
    + This allows users to create meta types for enums that will work exactly like any other meta type built from a class. Similarly, arithmetic types can be enriched with constants of special meaning where required.
    + Personally, I find it very useful not to export what is the difference between enums and classes in C++ directly in the space of the reflected types.

    +

    All the values thus exported will appear to users as if they were constant data members of the reflected types.

    +

    Exporting constant values or elements from an enum is as simple as ever:

    +
    entt::reflect<my_enum>()
    .data<my_enum::a_value>("a_value")
    .data<my_enum::another_value>("another_value");
    entt::reflect<int>().data<2048>("max_int");

    It goes without saying that accessing them is trivial as well. It's a matter of doing the following, as with any other data member of a meta type:

    +
    auto value = entt::resolve<my_enum>().data("a_value").get({}).cast<my_enum>();
    auto max = entt::resolve<int>().data("max_int").get({}).cast<int>();

    As a side note, remember that all this happens behind the scenes without any allocation because of the small object optimization performed by the meta any class.

    +

    +Properties and meta objects

    +

    Sometimes (ie when it comes to creating an editor) it might be useful to be able to attach properties to the meta objects created. Fortunately, this is possible for most of them.
    + To attach a property to a meta object, no matter what as long as it supports properties, it is sufficient to provide an object at the time of construction such that std::get<0> and std::get<1> are valid for it. In other terms, the properties are nothing more than key/value pairs users can put in an std::pair. As an example:

    +
    entt::reflect<my_type>("reflected", std::make_pair("tooltip"_hs, "message"));

    The meta objects that support properties offer then a couple of member functions named prop to iterate them at once and to search a specific property by key:

    +
    // iterate all the properties of a meta type
    entt::resolve<my_type>().prop([](auto prop) {
    // ...
    });
    // search for a given property by name
    auto prop = entt::resolve<my_type>().prop("tooltip"_hs);

    Meta properties are objects having a fairly poor interface, all in all. They only provide the key and the value member functions to be used to retrieve the key and the value contained in the form of meta any objects, respectively.

    +

    +Unregister types

    +

    A type registered with the reflection system can also be unregistered. This means unregistering all its data members, member functions, conversion functions and so on. However, the base classes won't be unregistered, since they don't necessarily depend on it. Similarly, implicitly generated types (as an example, the meta types implicitly generated for function parameters when needed) won't be unregistered.

    +

    To unregister a type, users can use the unregister function from the global namespace:

    +
    entt::unregister<my_type>();

    This function returns a boolean value that is true if the type is actually registered with the reflection system, false otherwise.
    + The type can be re-registered later with a completely different name and form.

    +
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/autotoc_md44.html b/autotoc_md69.html similarity index 61% rename from autotoc_md44.html rename to autotoc_md69.html index b7c8c9452..c6e36b5a8 100644 --- a/autotoc_md44.html +++ b/autotoc_md69.html @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    @@ -63,20 +63,20 @@ $(function() {
    Crash Course: cooperative scheduler
    -

    +

    Introduction

    Sometimes processes are a useful tool to work around the strict definition of a system and introduce logic in a different way, usually without resorting to the introduction of other components.

    EnTT offers a minimal support to this paradigm by introducing a few classes that users can use to define and execute cooperative processes.

    -

    +

    The process

    -

    A typical process must inherit from the Process class template that stays true to the CRTP idiom. Moreover, derived classes must specify what's the intended type for elapsed times.

    +

    A typical process must inherit from the process class template that stays true to the CRTP idiom. Moreover, derived classes must specify what's the intended type for elapsed times.

    A process should expose publicly the following member functions whether required (note that it isn't required to define a function unless the derived class wants to override the default behavior):

    • void update(Delta, void *);

      It's invoked once per tick until a process is explicitly aborted or it terminates either with or without errors. Even though it's not mandatory to declare this member function, as a rule of thumb each process should at least define it to work properly. The void * parameter is an opaque pointer to user data (if any) forwarded directly to the process during an update.

      • -

    • void init(void *);

      -

      It's invoked at the first tick, immediately before an update. The void * parameter is an opaque pointer to user data (if any) forwarded directly to the process during an update.

      +

    • void init();

      +

      It's invoked when the process joins the running queue of a scheduler. This happens as soon as it's attached to the scheduler if the process is a top level one, otherwise when it replaces its parent if the process is a continuation.

    • void succeeded();

      It's invoked in case of success, immediately after an update and during the same tick.

      @@ -90,7 +90,7 @@ The process

Derived classes can also change the internal state of a process by invoking succeed and fail, as well as pause and unpause the process itself. All these are protected member functions made available to be able to manage the life cycle of a process from a derived class.

Here is a minimal example for the sake of curiosity:

-
struct MyProcess: entt::Process<MyProcess, std::uint32_t> {
using delta_type = std::uint32_t;
void update(delta_type delta, void *) {
remaining = delta > remaining ? delta_type{] : (remaining - delta);
// ...
if(!remaining) {
succeed();
}
}
void init(void *data) {
remaining = *static_cast<delta_type *>(data);
}
private:
delta_type remaining;
};

+
struct my_process: entt::process<my_process, std::uint32_t> {
using delta_type = std::uint32_t;
void update(delta_type delta, void *) {
remaining -= std::min(remaining, delta);
// ...
if(!remaining) {
succeed();
}
}
private:
delta_type remaining{1000u};
};

Adaptor

Lambdas and functors can't be used directly with a scheduler for they are not properly defined processes with managed life cycles.
This class helps in filling the gap and turning lambdas and functors into full featured processes usable by a scheduler.

@@ -104,23 +104,23 @@ Adaptor

Both succeed and fail accept no parameters at all.

Note that usually users shouldn't worry about creating adaptors at all. A scheduler creates them internally each and every time a lambda or a functor is used as a process.

-

+

The scheduler

A cooperative scheduler runs different processes and helps managing their life cycles.

-

Each process is invoked once per tick. If it terminates, it's removed automatically from the scheduler and it's never invoked again. Otherwise it's a good candidate to run once more the next tick.
- A process can also have a child. In this case, the process is replaced with its child when it terminates if it returns with success. In case of errors, both the process and its child are discarded. This way, it's easy to create chain of processes to run sequentially.

+

Each process is invoked once per tick. If it terminates, it's removed automatically from the scheduler and it's never invoked again. Otherwise it's a good candidate to run one more time the next tick.
+ A process can also have a child. In this case, the parent process is replaced with its child when it terminates and only if it returns with success. In case of errors, both the parent process and its child are discarded. This way, it's easy to create chain of processes to run sequentially.

Using a scheduler is straightforward. To create it, users must provide only the type for the elapsed times and no arguments at all:

-
Scheduler<std::uint32_t> scheduler;

It has member functions to query its internal data structures, like empty or size, as well as a clear utility to reset it to a clean state:

-
// checks if there are processes still running
const auto empty = scheduler.empty();
// gets the number of processes still running
Scheduler<std::uint32_t>::size_type size = scheduler.size();
// resets the scheduler to its initial state and discards all the processes
scheduler.clear();

To attach a process to a scheduler there are mainly two ways:

+
entt::scheduler<std::uint32_t> scheduler;

It has member functions to query its internal data structures, like empty or size, as well as a clear utility to reset it to a clean state:

+
// checks if there are processes still running
const auto empty = scheduler.empty();
// gets the number of processes still running
entt::scheduler<std::uint32_t>::size_type size = scheduler.size();
// resets the scheduler to its initial state and discards all the processes
scheduler.clear();

To attach a process to a scheduler there are mainly two ways:

    -
  • If the process inherits from the Process class template, it's enough to indicate its type and submit all the parameters required to construct it to the attach member function:
    • +
  • If the process inherits from the process class template, it's enough to indicate its type and submit all the parameters required to construct it to the attach member function:
-
scheduler.attach<MyProcess>("foobar");
    +
    scheduler.attach<my_process>("foobar");
    • Otherwise, in case of a lambda or a functor, it's enough to provide an instance of the class to the attach member function:
    -
    scheduler.attach([](auto...){ /* ... */ });

    In both cases, the return value is an opaque object that offers a then member function to use to create chains of processes to run sequentially.
    +

    scheduler.attach([](auto...){ /* ... */ });

    In both cases, the return value is an opaque object that offers a then member function to use to create chains of processes to run sequentially.
    As a minimal example of use:

    -
    // schedules a task in the form of a lambda function
    scheduler.attach([](auto delta, void *, auto succeed, auto fail) {
    // ...
    })
    // appends a child in the form of another lambda function
    .then([](auto delta, void *, auto succeed, auto fail) {
    // ...
    })
    // appends a child in the form of a process class
    .then<MyProcess>();

    To update a scheduler and thus all its processes, the update member function is the way to go:

    +
    // schedules a task in the form of a lambda function
    scheduler.attach([](auto delta, void *, auto succeed, auto fail) {
    // ...
    })
    // appends a child in the form of another lambda function
    .then([](auto delta, void *, auto succeed, auto fail) {
    // ...
    })
    // appends a child in the form of a process class
    .then<my_process>();

    To update a scheduler and therefore all its processes, the update member function is the way to go:

    // updates all the processes, no user data are provided
    scheduler.update(delta);
    // updates all the processes and provides them with custom data
    scheduler.update(delta, &data);

    In addition to these functions, the scheduler offers an abort member function that can be used to discard all the running processes at once:

    // aborts all the processes abruptly ...
    scheduler.abort(true);
    // ... or gracefully during the next tick
    scheduler.abort();
    diff --git a/autotoc_md49.html b/autotoc_md74.html similarity index 54% rename from autotoc_md49.html rename to autotoc_md74.html index dc39051cc..538044a1b 100644 --- a/autotoc_md49.html +++ b/autotoc_md74.html @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    @@ -63,42 +63,41 @@ $(function() {
    Crash Course: resource management
    -

    +

    Introduction

    Resource management is usually one of the most critical part of a software like a game. Solutions are often tuned to the particular application. There exist several approaches and all of them are perfectly fine as long as they fit the requirements of the piece of software in which they are used.
    Examples are loading everything on start, loading on request, predictive loading, and so on.

    EnTT doesn't pretend to offer a one-fits-all solution for the different cases. Instead, it offers a minimal and perhaps trivial cache that can be useful most of the time during prototyping and sometimes even in a production environment.
    For those interested in the subject, the plan is to improve it considerably over time in terms of performance, memory usage and functionalities. Hoping to make it, of course, one step at a time.

    -

    +

    The resource, the loader and the cache

    There are three main actors in the model: the resource, the loader and the cache.

    The resource is whatever users want it to be. An image, a video, an audio, whatever. There are no limits.
    As a minimal example:

    -
    struct MyResource { const int value; };

    A loader is a class the aim of which is to load a specific resource. It has to inherit directly from the dedicated base class as in the following example:

    -
    struct MyLoader final: entt::ResourceLoader<MyLoader, MyResource> {
    // ...
    };

    Where MyResource is the type of resources it creates.
    +

    struct my_resource { const int value; };

    A loader is a class the aim of which is to load a specific resource. It has to inherit directly from the dedicated base class as in the following example:

    +
    struct my_loader final: entt::resource_loader<my_loader, my_resource> {
    // ...
    };

    Where my_resource is the type of resources it creates.
    A resource loader must also expose a public const member function named load that accepts a variable number of arguments and returns a shared pointer to a resource.
    As an example:

    -
    struct MyLoader: entt::ResourceLoader<MyLoader, MyResource> {
    std::shared_ptr<MyResource> load(int value) const {
    // ...
    return std::shared_ptr<MyResource>(new MyResource{ value });
    }
    };

    In general, resource loaders should not have a state or retain data of any type. They should let the cache manage their resources instead.
    +

    struct my_loader: entt::resource_loader<my_loader, my_resource> {
    std::shared_ptr<my_resource> load(int value) const {
    // ...
    return std::shared_ptr<my_resource>(new my_resource{ value });
    }
    };

    In general, resource loaders should not have a state or retain data of any type. They should let the cache manage their resources instead.
    As a side note, base class and CRTP idiom aren't strictly required with the current implementation. One could argue that a cache can easily work with loaders of any type. However, future changes won't be breaking ones by forcing the use of a base class today and that's why the model is already in its place.

    Finally, a cache is a specialization of a class template tailored to a specific resource:

    -
    using MyResourceCache = entt::ResourceCache<MyResource>;
    // ...
    MyResourceCache cache{};

    The idea is to create different caches for different types of resources and to manage each one independently and in the most appropriate way.
    +

    using my_resource_cache = entt::resource_cache<my_resource>;
    // ...
    my_resource_cache cache{};

    The idea is to create different caches for different types of resources and to manage each one independently in the most appropriate way.
    As a (very) trivial example, audio tracks can survive in most of the scenes of an application while meshes can be associated with a single scene and then discarded when users leave it.

    A cache offers a set of basic functionalities to query its internal state and to organize it:

    -
    // gets the number of resources managed by a cache
    const auto size = cache.size();
    // checks if a cache contains at least a valid resource
    const auto empty = cache.empty();
    // clears a cache and discards its content
    cache.clear();

    Besides these member functions, it contains what is needed to load, use and discard resources of the given type.
    +

    // gets the number of resources managed by a cache
    const auto size = cache.size();
    // checks if a cache contains at least a valid resource
    const auto empty = cache.empty();
    // clears a cache and discards its content
    cache.clear();

    Besides these member functions, a cache contains what is needed to load, use and discard resources of the given type.
    Before to explore this part of the interface, it makes sense to mention how resources are identified. The type of the identifiers to use is defined as:

    -
    entt::ResourceCache<Resource>::resource_type

    Where resource_type is an alias for entt::HashedString. Therefore, resource identifiers are created explicitly as in the following example:

    -
    constexpr auto identifier = entt::ResourceCache<Resource>::resource_type{"my/resource/identifier"};
    // this is equivalent to the following
    constexpr auto hs = entt::HashedString{"my/resource/identifier"};

    The class HashedString is described in a dedicated section, so I won't do in details here.

    +
    entt::resource_cache<resource>::resource_type

    Where resource_type is an alias for entt::hashed_string::hash_type. Therefore, resource identifiers are created explicitly as in the following example:

    +
    constexpr auto identifier = entt::resource_cache<resource>::resource_type{"my/resource/identifier"_hs};
    // this is equivalent to the following
    constexpr auto hs = entt::hashed_string{"my/resource/identifier"};

    The class hashed_string is described in a dedicated section, so I won't go in details here.

    Resources are loaded and thus stored in a cache through the load member function. It accepts the loader to use as a template parameter, the resource identifier and the parameters used to construct the resource as arguments:

    -
    // uses the identifier declared above
    cache.load<MyLoader>(identifier, 0);
    // uses a const char * directly as an identifier
    cache.load<MyLoader>("another/identifier", 42);

    The return value can be used to know if the resource has been loaded correctly. In case the loader returns an invalid pointer or the resource already exists in the cache, a false value is returned:

    -
    if(!cache.load<MyLoader>("another/identifier", 42)) {
    // ...
    }

    Unfortunately, in this case there is no way to know what was the problem exactly. However, before trying to load a resource or after an error, one can use the contains member function to know if a cache already contains a specific resource:

    -
    auto exists = cache.contains("my/identifier");

    There exists also a member function to use to force a reload of an already existing resource if needed:

    -
    auto result = cache.reload<MyLoader>("another/identifier", 42);

    As above, the function returns true in case of success, false otherwise. The sole difference in this case is that an error necessarily means that the loader has failed for some reasons to load the resource.
    - Note that the reload member function is a kind of alias of the following snippet:

    -
    cache.discard(identifier);
    cache.load<MyLoader>(identifier, 42);

    Where the discard member function is used to get rid of a resource if loaded. In case the cache doesn't contain a resource for the given identifier, the function does nothing and returns immediately.

    +
    // uses the identifier declared above
    cache.load<my_loader>(identifier, 0);
    // uses a const char * directly as an identifier
    cache.load<my_loader>("another/identifier"_hs, 42);

    The function returns a handle to the resource, whether it already exists or is loaded. In case the loader returns an invalid pointer, the handle is invalid as well and therefore it can be easily used with an if statement:

    +
    if(auto handle = cache.load<my_loader>("another/identifier"_hs, 42); handle) {
    // ...
    }

    Before trying to load a resource, the contains member function can be used to know if a cache already contains a specific resource:

    +
    auto exists = cache.contains("my/identifier"_hs);

    There exists also a member function to use to force a reload of an already existing resource if needed:

    +
    auto handle = cache.reload<my_loader>("another/identifier"_hs, 42);

    As above, the function returns a handle to the resource that is invalid in case of errors. The reload member function is a kind of alias of the following snippet:

    +
    cache.discard(identifier);
    cache.load<my_loader>(identifier, 42);

    Where the discard member function is used to get rid of a resource if loaded. In case the cache doesn't contain a resource for the given identifier, discard does nothing and returns immediately.

    So far, so good. Resources are finally loaded and stored within the cache.
    - They are returned to users in the form of handles. To get one of them:

    -
    auto handle = cache.handle("my/identifier");

    The idea behind a handle is the same of the flyweight pattern. In other terms, resources aren't copied around. Instead, instances are shared between handles. Users of a resource owns a handle and it guarantees that a resource isn't destroyed until all the handles are destroyed, even if the resource itself is removed from the cache.
    - Handles are tiny objects both movable and copyable. They returns the contained resource as a const reference on request:

    + They are returned to users in the form of handles. To get one of them later on:

    +
    auto handle = cache.handle("my/identifier"_hs);

    The idea behind a handle is the same of the flyweight pattern. In other terms, resources aren't copied around. Instead, instances are shared between handles. Users of a resource own a handle that guarantees that a resource isn't destroyed until all the handles are destroyed, even if the resource itself is removed from the cache.
    + Handles are tiny objects both movable and copyable. They return the contained resource as a const reference on request:

    • By means of the get member function:
    @@ -111,8 +110,8 @@ The resource, the loader and the cache

    const auto &resource = *handle;

    The resource can also be accessed directly using the arrow operator if required:

    auto value = handle->value;

    To test if a handle is still valid, the cast operator to bool allows users to use it in a guard:

    if(handle) {
    // ...
    }

    Finally, in case there is the need to load a resource and thus to get a handle without storing the resource itself in the cache, users can rely on the temp member function template.
    - The declaration is similar to the one of load but for the fact that it doesn't return a boolean value. Instead, it returns a (possibly invalid) handle for the resource:

    -
    auto handle = cache.temp<MyLoader>("another/identifier", 42);

    Do not forget to test the handle for validity. Otherwise, getting the reference to the resource it points may result in undefined behavior.

    + The declaration is similar to that of load, a (possibly invalid) handle for the resource is returned also in this case:

    +
    if(auto handle = cache.temp<my_loader>(42); handle) {
    // ...
    }

    Do not forget to test the handle for validity. Otherwise, getting a reference to the resource it points may result in undefined behavior.

    diff --git a/autotoc_md77.html b/autotoc_md77.html new file mode 100644 index 000000000..262e53acf --- /dev/null +++ b/autotoc_md77.html @@ -0,0 +1,153 @@ + + + + + + + +EnTT: Crash Course: events, signals and everything in between + + + + + + + + + +
    +
    + + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + +
    +
    +
    +
    Crash Course: events, signals and everything in between
    +
    +
    +

    +Introduction

    +

    Signals are usually a core part of games and software architectures in general.
    + Roughly speaking, they help to decouple the various parts of a system while allowing them to communicate with each other somehow.

    +

    The so called _modern C++_ comes with a tool that can be useful in these terms, the std::function. As an example, it can be used to create delegates.
    + However, there is no guarantee that an std::function does not perform allocations under the hood and this could be problematic sometimes. Furthermore, it solves a problem but may not adapt well to other requirements that may arise from time to time.

    +

    In case that the flexibility and potential of an std::function are not required or where you are looking for something different, EnTT offers a full set of classes to solve completely different problems.

    +

    +Delegate

    +

    A delegate can be used as a general purpose invoker with no memory overhead for free functions and members provided along with an instance on which to invoke them.
    + It does not claim to be a drop-in replacement for an std::function, so do not expect to use it whenever an std::function fits well. However, it can be used to send opaque delegates around to be used to invoke functions as needed.

    +

    The interface is trivial. It offers a default constructor to create empty delegates:

    +
    entt::delegate<int(int)> delegate{};

    All what is needed to create an instance is to specify the type of the function the delegate will contain, that is the signature of the free function or the member function one wants to assign to it.

    +

    Attempting to use an empty delegate by invoking its function call operator results in undefined behavior or most likely a crash. Before to use a delegate, it must be initialized.
    + There exists a bunch of overloads of the connect member function to do that. As an example of use:

    +
    int f(int i) { return i; }
    struct my_struct {
    int f(const int &i) { return i }
    };
    // bind a free function to the delegate
    delegate.connect<&f>();
    // bind a member function to the delegate
    my_struct instance;
    delegate.connect<&my_struct::f>(&instance);

    The delegate class accepts also data members, if needed. In this case, the function type of the delegate is such that the parameter list is empty and the value of the data member is at least convertible to the return type.
    + Functions having type equivalent to void(T *, args...) are accepted as well. In this case, T * is considered a payload and the function will receive it back every time it's invoked. In other terms, this works just fine with the above definition:

    +
    void g(const char *c, int i) { /* ... */ }
    const char c = 'c';
    delegate.connect<&g>(&c);
    delegate(42);

    The function g will be invoked with a pointer to c and 42. However, the function type of the delegate is still void(int), mainly because this is also the signature of its function call operator.

    +

    To create and initialize a delegate at once, there are also some specialized constructors. Because of the rules of the language, the listener is provided by means of the entt::connect_arg variable template:

    +
    entt::delegate<int(int)> func{entt::connect_arg<&f>};

    Aside connect, a disconnect counterpart isn't provided. Instead, there exists a reset member function to use to clear a delegate.
    + To know if a delegate is empty, it can be used explicitly in every conditional statement:

    +
    if(delegate) {
    // ...
    }

    Finally, to invoke a delegate, the function call operator is the way to go as usual:

    +
    auto ret = delegate(42);

    As shown above, listeners do not have to strictly follow the signature of the delegate. As long as a listener can be invoked with the given arguments to yield a result that is convertible to the given result type, everything works just fine.

    +

    Probably too much small and pretty poor of functionalities, but the delegate class can help in a lot of cases and it has shown that it is worth keeping it within the library.

    +

    +Signals

    +

    Signal handlers work with naked pointers, function pointers and pointers to member functions. Listeners can be any kind of objects and users are in charge of connecting and disconnecting them from a signal to avoid crashes due to different lifetimes. On the other side, performance shouldn't be affected that much by the presence of such a signal handler.
    + A signal handler can be used as a private data member without exposing any publish functionality to the clients of a class. The basic idea is to impose a clear separation between the signal itself and its sink class, that is a tool to be used to connect and disconnect listeners on the fly.

    +

    The API of a signal handler is straightforward. The most important thing is that it comes in two forms: with and without a collector. In case a signal is associated with a collector, all the values returned by the listeners can be literally collected and used later by the caller. Otherwise it works just like a plain signal that emits events from time to time.
    +

    +

    Note: collectors are allowed only in case of function types whose the return type isn't void for obvious reasons.

    +

    To create instances of signal handlers there exist mainly two ways:

    +
    // no collector type
    entt::sigh<void(int, char)> signal;
    // explicit collector type
    entt::sigh<void(int, char), my_collector<bool>> collector;

    As expected, they offer all the basic functionalities required to know how many listeners they contain (size) or if they contain at least a listener (empty) and even to swap two signal handlers (swap).

    +

    Besides them, there are member functions to use both to connect and disconnect listeners in all their forms by means of a sink:

    +
    void foo(int, char) { /* ... */ }
    struct listener {
    void bar(const int &, char) { /* ... */ }
    };
    // ...
    listener instance;
    signal.sink().connect<&foo>();
    signal.sink().connect<&listener::bar>(&instance);
    // ...
    // disconnects a free function
    signal.sink().disconnect<&foo>();
    // disconnect a member function of an instance
    signal.sink().disconnect<&listener::bar>(&instance);
    // discards all the listeners at once
    signal.sink().disconnect();

    As shown above, listeners do not have to strictly follow the signature of the signal. As long as a listener can be invoked with the given arguments to yield a result that is convertible to the given result type, everything works just fine.

    +

    Once listeners are attached (or even if there are no listeners at all), events and data in general can be published through a signal by means of the publish member function:

    +
    signal.publish(42, 'c');

    To collect data, the collect member function should be used instead. Below is a minimal example to show how to use it:

    +
    struct my_collector {
    std::vector<int> vec{};
    bool operator()(int v) noexcept {
    vec.push_back(v);
    return true;
    }
    };
    int f() { return 0; }
    int g() { return 1; }
    // ...
    entt::sigh<int(), my_collector<int>> signal;
    signal.sink().connect<&f>();
    signal.sink().connect<&g>();
    my_collector collector = signal.collect();
    assert(collector.vec[0] == 0);
    assert(collector.vec[1] == 1);

    A collector must expose a function operator that accepts as an argument a type to which the return type of the listeners can be converted. Moreover, it has to return a boolean value that is false to stop collecting data, true otherwise. This way one can avoid calling all the listeners in case it isn't necessary.

    +

    +Event dispatcher

    +

    The event dispatcher class is designed so as to be used in a loop. It allows users both to trigger immediate events or to queue events to be published all together once per tick.
    + This class shares part of its API with the one of the signal handler, but it doesn't require that all the types of events are specified when declared:

    +
    // define a general purpose dispatcher that works with naked pointers
    entt::dispatcher dispatcher{};

    In order to register an instance of a class to a dispatcher, its type must expose one or more member functions the arguments of which are such that const E & can be converted to them for each type of event E, no matter what the return value is.
    + The name of the member function aimed to receive the event must be provided to the connect member function of the sink in charge for the specific event:

    +
    struct an_event { int value; };
    struct another_event {};
    struct listener
    {
    void receive(const an_event &) { /* ... */ }
    void method(const another_event &) { /* ... */ }
    };
    // ...
    listener listener;
    dispatcher.sink<an_event>().connect<&listener::receive>(&listener);
    dispatcher.sink<another_event>().connect<&listener::method>(&listener);

    The disconnect member function follows the same pattern and can be used to selectively remove listeners:

    +
    dispatcher.sink<an_event>().disconnect<&listener::receive>(&listener);
    dispatcher.sink<another_event>().disconnect<&listener::method>(&listener);

    The trigger member function serves the purpose of sending an immediate event to all the listeners registered so far. It offers a convenient approach that relieves users from having to create the event itself. Instead, it's enough to specify the type of event and provide all the parameters required to construct it.
    + As an example:

    +
    dispatcher.trigger<an_event>(42);
    dispatcher.trigger<another_event>();

    Listeners are invoked immediately, order of execution isn't guaranteed. This method can be used to push around urgent messages like an is terminating notification on a mobile app.

    +

    On the other hand, the enqueue member function queues messages together and allows to maintain control over the moment they are sent to listeners. The signature of this method is more or less the same of trigger:

    +
    dispatcher.enqueue<an_event>(42);
    dispatcher.enqueue<another_event>();

    Events are stored aside until the update member function is invoked, then all the messages that are still pending are sent to the listeners at once:

    +
    // emits all the events of the given type at once
    dispatcher.update<my_event>();
    // emits all the events queued so far at once
    dispatcher.update();

    This way users can embed the dispatcher in a loop and literally dispatch events once per tick to their systems.

    +

    +Event emitter

    +

    A general purpose event emitter thought mainly for those cases where it comes to working with asynchronous stuff.
    + Originally designed to fit the requirements of uvw (a wrapper for libuv written in modern C++), it was adapted later to be included in this library.

    +

    To create a custom emitter type, derived classes must inherit directly from the base class as:

    +
    struct my_emitter: emitter<my_emitter> {
    // ...
    }

    The full list of accepted types of events isn't required. Handlers are created internally on the fly and thus each type of event is accepted by default.

    +

    Whenever an event is published, an emitter provides the listeners with a reference to itself along with a const reference to the event. Therefore listeners have an handy way to work with it without incurring in the need of capturing a reference to the emitter itself.
    + In addition, an opaque object is returned each time a connection is established between an emitter and a listener, allowing the caller to disconnect them at a later time.
    + The opaque object used to handle connections is both movable and copyable. On the other side, an event emitter is movable but not copyable by default.

    +

    To create new instances of an emitter, no arguments are required:

    +
    my_emitter emitter{};

    Listeners must be movable and callable objects (free functions, lambdas, functors, std::functions, whatever) whose function type is:

    +
    void(const Event &, my_emitter &)

    Where Event is the type of event they want to listen.
    + There are two ways to attach a listener to an event emitter that differ slightly from each other:

    +
      +
    • To register a long-lived listener, use the on member function. It is meant to register a listener designed to be invoked more than once for the given event type.
      + As an example:
      • +
    +
    auto conn = emitter.on<my_event>([](const my_event &event, my_emitter &emitter) {
    // ...
    });

    The connection object can be freely discarded. Otherwise, it can be used later to disconnect the listener if required.

    +
      +
    • To register a short-lived listener, use the once member function. It is meant to register a listener designed to be invoked only once for the given event type. The listener is automatically disconnected after the first invocation.
      + As an example:
      • +
    +
    auto conn = emitter.once<my_event>([](const my_event &event, my_emitter &emitter) {
    // ...
    });

    The connection object can be freely discarded. Otherwise, it can be used later to disconnect the listener if required.

    +

    In both cases, the connection object can be used with the erase member function:

    +
    emitter.erase(conn);

    There are also two member functions to use either to disconnect all the listeners for a given type of event or to clear the emitter:

    +
    // removes all the listener for the specific event
    emitter.clear<my_event>();
    // removes all the listeners registered so far
    emitter.clear();

    To send an event to all the listeners that are interested in it, the publish member function offers a convenient approach that relieves users from having to create the event:

    +
    struct my_event { int i; };
    // ...
    emitter.publish<my_event>(42);

    Finally, the empty member function tests if there exists at least either a listener registered with the event emitter or to a given type of event:

    +
    bool empty;
    // checks if there is any listener registered for the specific event
    empty = emitter.empty<my_event>();
    // checks it there are listeners registered with the event emitter
    empty = emitter.empty();

    In general, the event emitter is a handy tool when the derived classes wrap asynchronous operations, because it introduces a nice-to-have model based on events and listeners that kindly hides the complexity behind the scenes. However it is not limited to such uses.

    +
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/autotoc_md8.html b/autotoc_md8.html index 699d95ad5..2aca89993 100644 --- a/autotoc_md8.html +++ b/autotoc_md8.html @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    @@ -68,99 +68,96 @@ Introduction

    EnTT is a header-only, tiny and easy to use entity-component system (and much more) written in modern C++.
    The entity-component-system (also known as ECS) is an architectural pattern used mostly in game development.

    -Design choices

    +Design decisions

    A bitset-free entity-component system

    EnTT is a bitset-free entity-component system that doesn't require users to specify the component set at compile-time.
    This is why users can instantiate the core class simply like:

    -
    entt::DefaultRegistry registry;

    In place of its more annoying and error-prone counterpart:

    -
    entt::DefaultRegistry<Comp0, Comp1, ..., CompN> registry;

    +
    entt::registry registry;

    In place of its more annoying and error-prone counterpart:

    +
    entt::registry<comp_0, comp_1, ..., comp_n> registry;

    Pay per use

    EnTT is entirely designed around the principle that users have to pay only for what they want.

    -

    When it comes to using an entity-component system, the tradeoff is usually between performance and memory usage. The faster it is, the more memory it uses. However, slightly worse performance along non-critical paths are the right price to pay to reduce memory usage and I've always wondered why this kind of tools do not leave me the choice.
    - EnTT follows a completely different approach. It squeezes the best from the basic data structures and gives users the possibility to pay more for higher performance where needed.
    +

    When it comes to using an entity-component system, the tradeoff is usually between performance and memory usage. The faster it is, the more memory it uses. Even worse, some approaches tend to heavily affect other functionalities like the construction and destruction of components to favor iterations, even when it isn't strictly required. In fact, slightly worse performance along non-critical paths are the right price to pay to reduce memory usage and have overall better perfomance sometimes and I've always wondered why this kind of tools do not leave me the choice.
    + EnTT follows a completely different approach. It gets the best out from the basic data structures and gives users the possibility to pay more for higher performance where needed.
    The disadvantage of this approach is that users need to know the systems they are working on and the tools they are using. Otherwise, the risk to ruin the performance along critical paths is high.

    So far, this choice has proven to be a good one and I really hope it can be for many others besides me.

    -

    +

    +All or nothing

    +

    EnTT is such that at every moment a pair (T *, size) is available to directly access all the instances of a given component type T.
    + This was a guideline and a design decision that influenced many choices, for better and for worse. I cannot say whether it will be useful or not to the reader, but it's worth to mention it, because it's one of the corner stones of this library.

    +

    Many of the tools described below, from the registry to the views and up to the groups give the possibility to get this information and have been designed around this need, which was and remains one of my main requirements during the development.
    + The rest is experimentation and the desire to invent something new, hoping to have succeeded.

    +

    +Stateless systems

    +

    EnTT is designed so that it can work with stateless systems. In other words, all systems can be free functions and there is no need to define them as classes (although nothing prevents users from doing so).
    + This is possible because the main class with which the users will work provides all what is needed to act as the sole source of truth of an application.

    +

    To be honest, this point became part of the design principles at a later date, but has also become one of the cornerstones of the library to date, as stateless systems are widely used and appreciated in general.

    +

    Vademecum

    -

    The Registry to store, the views to iterate. That's all.

    -

    An entity (the E of an ECS) is an opaque identifier that users should just use as-is and store around if needed. Do not try to inspect an entity identifier, its format can change in future and a registry offers all the functionalities to query them out-of-the-box. The underlying type of an entity (either std::uint16_t, std::uint32_t or std::uint64_t) can be specified when defining a registry (actually the DefaultRegistry is nothing more than a Registry where the type of the entities is std::uint32_t).
    +

    The registry to store, the views and the groups to iterate. That's all.

    +

    An entity (the E of an ECS) is an opaque identifier that users should just use as-is and store around if needed. Do not try to inspect an entity identifier, its format can change in future and a registry offers all the functionalities to query them out-of-the-box. The underlying type of an entity (either std::uint16_t, std::uint32_t or std::uint64_t) can be specified when defining a registry (actually entt::registry is nothing more than an alias for entt::basic_registry<entt::entity> and entt::entity is an alias for std::uint32_t).
    Components (the C of an ECS) should be plain old data structures or more complex and movable data structures with a proper constructor. Actually, the sole requirement of a component type is that it must be both move constructible and move assignable. They are list initialized by using the parameters provided to construct the component itself. No need to register components or their types neither with the registry nor with the entity-component system at all.
    - Systems (the S of an ECS) are just plain functions, functors, lambdas or whatever users want. They can accept a Registry or a view of any type and use them the way they prefer. No need to register systems or their types neither with the registry nor with the entity-component system at all.

    + Systems (the S of an ECS) are just plain functions, functors, lambdas or whatever users want. They can accept a registry, a view or a group of any type and use them the way they prefer. No need to register systems or their types neither with the registry nor with the entity-component system at all.

    The following sections will explain in short how to use the entity-component system, the core part of the whole library.
    In fact, the project is composed of many other classes in addition to those describe below. For more details, please refer to the inline documentation.

    -

    +

    The Registry, the Entity and the Component

    -

    A registry can store and manage entities, as well as create views to iterate the underlying data structures.
    - Registry is a class template that lets users decide what's the preferred type to represent an entity. Because std::uint32_t is large enough for almost all the cases, there exists also an alias named DefaultRegistry for Registry<std::uint32_t>.

    +

    A registry can store and manage entities, as well as create views and groups to iterate the underlying data structures.
    + The class template basic_registry lets users decide what's the preferred type to represent an entity. Because std::uint32_t is large enough for almost all the cases, there exists also the alias entt::entity for it, as well as the alias entt::registry for entt::basic_registry<entt::entity>.

    Entities are represented by entity identifiers. An entity identifier is an opaque type that users should not inspect or modify in any way. It carries information about the entity itself and its version.

    -

    A registry can be used both to construct and destroy entities:

    -
    // constructs a naked entity with no components and returns its identifier
    auto entity = registry.create();
    // destroys an entity and all its components
    registry.destroy(entity);

    Entities can also be destroyed by type, that is by specifying the types of the tags or components that identify them:

    -
    // destroys the entity that owns the given tag, if any
    registry.destroy<MyTag>(entt::tag_t{});
    // destroys the entities that own the given components, if any
    registry.destroy<AComponent, AnotherComponent>();

    When an entity is destroyed, the registry can freely reuse it internally with a slightly different identifier. In particular, the version of an entity is increased each and every time it's discarded.
    - In case entity identifiers are stored around, the registry offers all the functionalities required to test them and get out of the them all the information they carry:

    +

    A registry can be used both to construct and to destroy entities:

    +
    // constructs a naked entity with no components and returns its identifier
    auto entity = registry.create();
    // destroys an entity and all its components
    registry.destroy(entity);

    There exists also an overload of the create and destroy member functions that accepts two iterators, that is a range to assign or to destroy. It can be used to create or destroy multiple entities at once:

    +
    // destroys all the entities in a range
    auto view = registry.view<a_component, another_component>();
    registry.destroy(view.begin(), view.end());

    In both cases, the create member function accepts also a list of default constructible types of components to assign to the entities before to return. It's a faster alternative to the creation and subsequent assignment of components in separate steps.

    +

    When an entity is destroyed, the registry can freely reuse it internally with a slightly different identifier. In particular, the version of an entity is increased each and every time it's discarded.
    + In case entity identifiers are stored around, the registry offers all the functionalities required to test them and to get out of them the information they carry:

    // returns true if the entity is still valid, false otherwise
    bool b = registry.valid(entity);
    // gets the version contained in the entity identifier
    auto version = registry.version(entity);
    // gets the actual version for the given entity
    auto curr = registry.current(entity);

    Components can be assigned to or removed from entities at any time with a few calls to member functions of the registry. As for the entities, the registry offers also a set of functionalities users can use to work with the components.

    The assign member function template creates, initializes and assigns to an entity the given component. It accepts a variable number of arguments to construct the component itself if present:

    -
    registry.assign<Position>(entity, 0., 0.);
    // ...
    Velocity &velocity = registry.assign<Velocity>(entity);
    velocity.dx = 0.;
    velocity.dy = 0.;

    If an entity already has the given component, the replace member function template can be used to replace it:

    -
    registry.replace<Position>(entity, 0., 0.);
    // ...
    Velocity &velocity = registry.replace<Velocity>(entity);
    velocity.dx = 0.;
    velocity.dy = 0.;

    In case users want to assign a component to an entity, but it's unknown whether the entity already has it or not, accommodate does the work in a single call (there is a performance penalty to pay for this mainly due to the fact that it has to check if the entity already has the given component or not):

    -
    registry.accommodate<Position>(entity, 0., 0.);
    // ...
    Velocity &velocity = registry.accommodate<Velocity>(entity);
    velocity.dx = 0.;
    velocity.dy = 0.;

    Note that accommodate is a slightly faster alternative for the following if/else statement and nothing more:

    -
    if(registry.has<Comp>(entity)) {
    registry.replace<Comp>(entity, arg1, argN);
    } else {
    registry.assign<Comp>(entity, arg1, argN);
    }

    As already shown, if in doubt about whether or not an entity has one or more components, the has member function template may be useful:

    -
    bool b = registry.has<Position, Velocity>(entity);

    On the other side, if the goal is to delete a single component, the remove member function template is the way to go when it's certain that the entity owns a copy of the component:

    -
    registry.remove<Position>(entity);

    Otherwise consider to use the reset member function. It behaves similarly to remove but with a strictly defined behavior (and a performance penalty is the price to pay for this). In particular it removes the component if and only if it exists, otherwise it returns safely to the caller:

    -
    registry.reset<Position>(entity);

    There exist also two other versions of the reset member function:

    +
    registry.assign<position>(entity, 0., 0.);
    // ...
    auto &velocity = registry.assign<velocity>(entity);
    vel.dx = 0.;
    vel.dy = 0.;

    If an entity already has the given component, the replace member function template can be used to replace it:

    +
    registry.replace<position>(entity, 0., 0.);
    // ...
    auto &velocity = registry.replace<velocity>(entity);
    vel.dx = 0.;
    vel.dy = 0.;

    In case users want to assign a component to an entity, but it's unknown whether the entity already has it or not, assign_or_replace does the work in a single call (there is a performance penalty to pay for this mainly due to the fact that it has to check if the entity already has the given component or not):

    +
    registry.assign_or_replace<position>(entity, 0., 0.);
    // ...
    auto &velocity = registry.assign_or_replace<velocity>(entity);
    vel.dx = 0.;
    vel.dy = 0.;

    Note that assign_or_replace is a slightly faster alternative for the following if/else statement and nothing more:

    +
    if(registry.has<comp>(entity)) {
    registry.replace<comp>(entity, arg1, argN);
    } else {
    registry.assign<comp>(entity, arg1, argN);
    }

    As already shown, if in doubt about whether or not an entity has one or more components, the has member function template may be useful:

    +
    bool b = registry.has<position, velocity>(entity);

    On the other side, if the goal is to delete a single component, the remove member function template is the way to go when it's certain that the entity owns a copy of the component:

    +
    registry.remove<position>(entity);

    Otherwise consider to use the reset member function. It behaves similarly to remove but with a strictly defined behavior (and a performance penalty is the price to pay for this). In particular it removes the component if and only if it exists, otherwise it returns safely to the caller:

    +
    registry.reset<position>(entity);

    There exist also two other versions of the reset member function:

    • If no entity is passed to it, reset will remove the given component from each entity that has it:
    -
    registry.reset<Position>();
      +
      registry.reset<position>();
      • If neither the entity nor the component are specified, all the entities still in use and their components are destroyed:
      registry.reset();

      Finally, references to components can be retrieved simply by doing this:

      -
      const auto &cregistry = registry;
      // const and non-const reference
      const Position &position = cregistry.get<Position>(entity);
      Position &position = registry.get<Position>(entity);
      // const and non-const references
      std::tuple<const Position &, const Velocity &> tup = cregistry.get<Position, Velocity>(entity);
      std::tuple<Position &, Velocity &> tup = registry.get<Position, Velocity>(entity);

      The get member function template gives direct access to the component of an entity stored in the underlying data structures of the registry.

      -

      -Single instance components

      -

      In those cases where all what is needed is a single instance component, tags are the right tool to achieve the purpose.
      - Tags undergo the same requirements of components. They can be either plain old data structures or more complex and movable data structures with a proper constructor.
      - Actually, the same type can be used both as a tag and as a component and the registry will not complain about it. It is up to users to properly manage their own types. In some cases, the tag tag_t must also be used in order to disambiguate overloads of member functions.

      -

      Attaching tags to entities and removing them is trivial:

      -
      auto player = registry.create();
      auto camera = registry.create();
      // attaches a default-initialized tag to an entity
      registry.assign<PlayingCharacter>(entt::tag_t{}, player);
      // attaches a tag to an entity and initializes it
      registry.assign<Camera>(entt::tag_t{}, camera, player);
      // removes tags from their owners
      registry.remove<PlayingCharacter>();
      registry.remove<Camera>();

      In case a tag already has an owner, its content can be updated by means of the replace member function template and the ownership of the tag can be transferred to another entity using the move member function template:

      -
      // replaces the content of the given tag
      Point &point = registry.replace<Point>(entt::tag_t{}, 1.f, 1.f);
      // transfers the ownership of the tag to another entity
      entity_type prev = registry.move<Point>(next);

      If in doubt about whether or not a tag already has an owner, the has member function template may be useful:

      -
      bool b = registry.has<PlayingCharacter>();

      References to tags can be retrieved simply by doing this:

      -
      const auto &cregistry = registry;
      // either a non-const reference ...
      PlayingCharacter &player = registry.get<PlayingCharacter>();
      // ... or a const one
      const Camera &camera = cregistry.get<Camera>();

      The get member function template gives direct access to the tag as stored in the underlying data structures of the registry.

      -

      As shown above, in almost all the cases the entity identifier isn't required. Since a single instance component can have only one associated entity, it doesn't make much sense to mention it explicitly.
      - To find out who the owner is, just do the following:

      -
      auto player = registry.attachee<PlayingCharacter>();

      Note that iterating tags isn't possible for obvious reasons. Tags give direct access to single entities and nothing more.

      -

      +
      const auto &cregistry = registry;
      // const and non-const reference
      const auto &crenderable = cregistry.get<renderable>(entity);
      auto &renderable = registry.get<renderable>(entity);
      // const and non-const references
      const auto &[cpos, cvel] = cregistry.get<position, velocity>(entity);
      auto &[pos, vel] = registry.get<position, velocity>(entity);

      The get member function template gives direct access to the component of an entity stored in the underlying data structures of the registry. There exists also an alternative member function named try_get that returns a pointer to the component owned by an entity if any, a null pointer otherwise.

      +

      Observe changes

      -

      Because of how the registry works internally, it stores a couple of signal handlers for each pool in order to notify some of its data structures on the construction and destruction of components.
      - These signal handlers are also exposed and made available to users. This is the basic brick to build fancy things like dependencies and reactive systems.

      -

      To get a sink to be used to connect and disconnect listeners so as to be notified on the creation of a component, use the construction member function:

      -
      // connects a free function
      registry.construction<Position>().connect<&MyFreeFunction>();
      // connects a member function
      registry.construction<Position>().connect<MyClass, &MyClass::member>(&instance);
      // disconnects a free function
      registry.construction<Position>().disconnect<&MyFreeFunction>();
      // disconnects a member function
      registry.construction<Position>().disconnect<MyClass, &MyClass::member>(&instance);

      To be notified when components are destroyed, use the destruction member function instead.

      -

      The function type of a listener is the same in both cases:

      -
      void(Registry<Entity> &, Entity);

      In other terms, a listener is provided with the registry that triggered the notification and the entity affected by the change. Note also that:

      +

      Because of how the registry works internally, it stores a bunch of signal handlers for each pool in order to notify some of its data structures on the construction and destruction of components or when an instance of a component is explicitly replaced by the user.
      + These signal handlers are also exposed and made available to users. These are the basic bricks to build fancy things like dependencies and reactive systems.

      +

      To get a sink to be used to connect and disconnect listeners so as to be notified on the creation of a component, use the on_construct member function:

      +
      // connects a free function
      registry.on_construct<position>().connect<&my_free_function>();
      // connects a member function
      registry.on_construct<position>().connect<&my_class::member>(&instance);
      // disconnects a free function
      registry.on_construct<position>().disconnect<&my_free_function>();
      // disconnects a member function
      registry.on_construct<position>().disconnect<&my_class::member>(&instance);

      To be notified when components are destroyed, use the on_destroy member function instead. Finally, the on_replace member function will return a sink to which to connect listeners to observe changes on components.

      +

      The function type of a listener for the construction signal should be equivalent to the following:

      +
      void(entt::registry &, entt::entity, Component &);

      Where Component is intuitively the type of component of interest. In other words, a listener is provided with the registry that triggered the notification and the entity affected by the change, in addition to the newly created instance.
      + The sink returned by the on_replace member function accepts listeners the signature of which is the same of that of the construction signal. The one of the destruction signal is also similar, except for the Component parameter:

      +
      void(entt::registry &, entt::entity);

      This is mainly due to performance reasons. While the component is made available after the construction, it is not when destroyed. Because of that, there are no reasons to get it from the underlying storage unless the user requires so. In this case, the registry is made available for the purpose.

      +

      Note also that:

        -
      • Listeners are invoked after components have been assigned to entities.
        • -
      • Listeners are invoked before components have been removed from entities.
        • +
      • Listeners for the construction signal are invoked after components have been assigned to entities.
        • +
      • Listeners designed to observe changes are invoked before components have been replaced and therefore before newly created instances have been assigned to entities.
        • +
      • Listeners for the destruction signal are invoked before components have been removed from entities.
      • The order of invocation of the listeners isn't guaranteed in any case.

      There are also some limitations on what a listener can and cannot do. In particular:

      • Connecting and disconnecting other functions from within the body of a listener should be avoided. It can lead to undefined behavior in some cases.
        • -
      • Assigning and removing components and tags from within the body of a listener that observes the destruction of instances of a given type should be avoided. It can lead to undefined behavior in some cases. This type of listeners is intended to provide users with an easy way to perform cleanup and nothing more.
        • +
      • Assigning and removing components from within the body of a listener that observes the destruction of instances of a given type should be avoided. It can lead to undefined behavior in some cases. This type of listeners is intended to provide users with an easy way to perform cleanup and nothing more.
      -

      To a certain extent, these limitations do not apply. However, it is risky to try to force them and users should respect the limitations unless they know exactly what they are doing. Subtle bugs are the price to pay in case of errors otherwise.

      +

      To a certain extent, these limitations don't apply. However, it's risky to try to force them and users should respect the limitations unless they know exactly what they are doing. Subtle bugs are the price to pay in case of errors otherwise.

      In general, events and therefore listeners must not be used as replacements for systems. They should not contain much logic and interactions with a registry should be kept to a minimum, if possible. Note also that the greater the number of listeners, the greater the performance hit when components are created or destroyed.

      -

      -Who let the tags out?

      -

      As an extension, signals are also provided with tags. Although they are not strictly required internally, it makes sense that a user expects signal support even when it comes to tags actually.
      - Signals for tags undergo exactly the same requirements of those introduced for components. Also the function type for a listener is the same and it's invoked with the same guarantees discussed above.

      -

      To get the sinks for a tag just use tag tag_t to disambiguate overloads of member functions as in the following example:

      -
      registry.construction<MyTag>(entt::tag_t{}).connect<&MyFreeFunction>();
      registry.destruction<MyTag>(entt::tag_t{}).connect<MyClass, &MyClass::member>(&instance);

      Listeners for tags and components are managed separately and do not influence each other in any case. Therefore, note that the greater the number of listeners for a type, the greater the performance hit when a tag of the given type is created or destroyed.

      Runtime components

      Defining components at runtime is useful to support plugin systems and mods in general. However, it seems impossible with a tool designed around a bunch of templates. Indeed it's not that difficult.
      Of course, some features cannot be easily exported into a runtime environment. As an example, sorting a group of components defined at runtime isn't for free if compared to most of the other operations. However, the basic functionalities of an entity-component system such as EnTT fit the problem perfectly and can also be used to manage runtime components if required.
      All that is necessary to do it is to know the identifiers of the components. An identifier is nothing more than a number or similar that can be used at runtime to work with the type system.

      In EnTT, identifiers are easily accessible:

      -
      entt::DefaultRegistry registry;
      // standard component identifier
      auto ctype = registry.type<Position>();
      // single instance component identifier
      auto ttype = registry.type<PlayingCharacter>(entt::tag_t{});

      Once the identifiers are made available, almost everything becomes pretty simple.

      +
      entt::registry registry;
      // component identifier
      auto type = registry.type<position>();

      Once the identifiers are made available, almost everything becomes pretty simple.

      A journey through a plugin

      EnTT comes with an example (actually a test) that shows how to integrate compile-time and runtime components in a stack based JavaScript environment. It uses Duktape under the hood, mainly because I wanted to learn how it works at the time I was writing the code.

      @@ -175,23 +172,24 @@ Sorting: is it possible?

      It goes without saying that sorting entities and components is possible with EnTT.
      In fact, there are two functions that respond to slightly different needs:

        -
      • Components can be sorted directly:
        • +
      • Components can be sorted either directly:
      -
      registry.sort<Renderable>([](const auto &lhs, const auto &rhs) {
      return lhs.z < rhs.z;
      });

      There exists also the possibility to use a custom sort function object, as long as it adheres to the requirements described in the inline documentation.
      - This is possible mainly because users can get much more with a custom sort function object if the pattern of usage is known. As an example, in case of an almost sorted pool, quick sort could be much, much slower than insertion sort.

      +
      registry.sort<renderable>([](const auto &lhs, const auto &rhs) {
      return lhs.z < rhs.z;
      });

      Or by accessing their entities:

      +
      registry.sort<renderable>([](const entt::entity lhs, const entt::entity rhs) {
      return entt::registry::entity(lhs) < entt::registry::entity(rhs);
      });

      There exists also the possibility to use a custom sort function object, as long as it adheres to the requirements described in the inline documentation.
      + This is possible mainly because users can get much more with a custom sort function object if the usage pattern is known. As an example, in case of an almost sorted pool, quick sort could be much, much slower than insertion sort.

      • Components can be sorted according to the order imposed by another component:
      -
      registry.sort<Movement, Physics>();

      In this case, instances of Movement are arranged in memory so that cache misses are minimized when the two components are iterated together.

      +
      registry.sort<movement, physics>();

      In this case, instances of movement are arranged in memory so that cache misses are minimized when the two components are iterated together.

      Snapshot: complete vs continuous

      -

      The Registry class offers basic support to serialization.
      - It doesn't convert components and tags to bytes directly, there wasn't the need of another tool for serialization out there. Instead, it accepts an opaque object with a suitable interface (namely an archive) to serialize its internal data structures and restore them later. The way types and instances are converted to a bunch of bytes is completely in charge to the archive and thus to final users.

      -

      The goal of the serialization part is to allow users to make both a dump of the entire registry or a narrower snapshot, that is to select only the components and the tags in which they are interested.
      +

      The registry class offers basic support to serialization.
      + It doesn't convert components to bytes directly, there wasn't the need of another tool for serialization out there. Instead, it accepts an opaque object with a suitable interface (namely an archive) to serialize its internal data structures and restore them later. The way types and instances are converted to a bunch of bytes is completely in charge to the archive and thus to final users.

      +

      The goal of the serialization part is to allow users to make both a dump of the entire registry or a narrower snapshot, that is to select only the components in which they are interested.
      Intuitively, the use cases are different. As an example, the first approach is suitable for local save/restore functionalities while the latter is suitable for creating client-server applications and for transferring somehow parts of the representation side to side.

      To take a snapshot of the registry, use the snapshot member function. It returns a temporary object properly initialized to save the whole registry or parts of it.

      Example of use:

      -
      OutputArchive output;
      registry.snapshot()
      .entities(output)
      .destroyed(output)
      .component<AComponent, AnotherComponent>(output)
      .tag<MyTag>(output);

      It isn't necessary to invoke all these functions each and every time. What functions to use in which case mostly depends on the goal and there is not a golden rule to do that.

      +
      output_archive output;
      registry.snapshot()
      .entities(output)
      .destroyed(output)
      .component<a_component, another_component>(output);

      It isn't necessary to invoke all these functions each and every time. What functions to use in which case mostly depends on the goal and there is not a golden rule to do that.

      The entities member function asks the registry to serialize all the entities that are still in use along with their versions. On the other side, the destroyed member function tells to the registry to serialize the entities that have been destroyed and are no longer in use.
      These two functions can be used to save and restore the whole set of entities with the versions they had during serialization.

      The component member function is a function template the aim of which is to store aside components. The presence of a template parameter list is a consequence of a couple of design choices from the past and in the present:

      @@ -201,30 +199,29 @@ Snapshot: complete vs continuous

    There exists also another version of the component member function that accepts a range of entities to serialize. This version is a bit slower than the other one, mainly because it iterates the range of entities more than once for internal purposes. However, it can be used to filter out those entities that shouldn't be serialized for some reasons.
    As an example:

    -
    const auto view = registry.view<Serialize>();
    OutputArchive output;
    registry.snapshot()
    .component<AComponent, AnotherComponent>(output, view.cbegin(), view.cend());

    The tag member function is similar to the previous one, apart from the fact that it works with tags and not with components.
    - Note also that both component and tag store items along with entities. It means that they work properly without a call to the entities member function.

    +
    const auto view = registry.view<serialize>();
    output_archive output;
    registry.snapshot().component<a_component, another_component>(output, view.cbegin(), view.cend());

    Note that component stores items along with entities. It means that it works properly without a call to the entities member function.

    Once a snapshot is created, there exist mainly two ways to load it: as a whole and in a kind of continuous mode.
    The following sections describe both loaders and archives in details.

    Snapshot loader

    A snapshot loader requires that the destination registry be empty and loads all the data at once while keeping intact the identifiers that the entities originally had.
    - To do that, the registry offers a member function named restore that returns a temporary object properly initialized to restore a snapshot.

    + To do that, the registry offers a member function named loader that returns a temporary object properly initialized to restore a snapshot.

    Example of use:

    -
    InputArchive input;
    registry.restore()
    .entities(input)
    .destroyed(input)
    .component<AComponent, AnotherComponent>(input)
    .tag<MyTag>(input)
    .orphans();

    It isn't necessary to invoke all these functions each and every time. What functions to use in which case mostly depends on the goal and there is not a golden rule to do that. For obvious reasons, what is important is that the data are restored in exactly the same order in which they were serialized.

    +
    input_archive input;
    registry.loader()
    .entities(input)
    .destroyed(input)
    .component<a_component, another_component>(input)
    .orphans();

    It isn't necessary to invoke all these functions each and every time. What functions to use in which case mostly depends on the goal and there is not a golden rule to do that. For obvious reasons, what is important is that the data are restored in exactly the same order in which they were serialized.

    The entities and destroyed member functions restore the sets of entities and the versions that the entities originally had at the source.

    -

    The component member function restores all and only the components specified and assigns them to the right entities. Note that the template parameter list must be exactly the same used during the serialization. The same applies to the tag member function.

    -

    The orphans member function literally destroys those entities that have neither components nor tags. It's usually useless if the snapshot is a full dump of the source. However, in case all the entities are serialized but only few components and tags are saved, it could happen that some of the entities have neither components nor tags once restored. The best users can do to deal with them is to destroy those entities and thus update their versions.

    +

    The component member function restores all and only the components specified and assigns them to the right entities. Note that the template parameter list must be exactly the same used during the serialization.

    +

    The orphans member function literally destroys those entities that have no components attached. It's usually useless if the snapshot is a full dump of the source. However, in case all the entities are serialized but only few components are saved, it could happen that some of the entities have no components once restored. The best users can do to deal with them is to destroy those entities and thus update their versions.

    Continuous loader

    A continuous loader is designed to load data from a source registry to a (possibly) non-empty destination. The loader can accommodate in a registry more than one snapshot in a sort of continuous loading that updates the destination one step at a time.
    - Identifiers that entities originally had are not transferred to the target. Instead, the loader maps remote identifiers to local ones while restoring a snapshot. Because of that, this kind of loader offers a way to update automatically identifiers that are part of components or tags (as an example, as data members or gathered in a container).
    + Identifiers that entities originally had are not transferred to the target. Instead, the loader maps remote identifiers to local ones while restoring a snapshot. Because of that, this kind of loader offers a way to update automatically identifiers that are part of components (as an example, as data members or gathered in a container).
    Another difference with the snapshot loader is that the continuous loader does not need to work with the private data structures of a registry. Furthermore, it has an internal state that must persist over time. Therefore, there is no reason to create it by means of a registry, or to limit its lifetime to that of a temporary object.

    Example of use:

    -
    entt::ContinuousLoader<entity_type> loader{registry};
    InputArchive input;
    loader.entities(input)
    .destroyed(input)
    .component<AComponent, AnotherComponent, DirtyComponent>(input, &DirtyComponent::parent, &DirtyComponent::child)
    .tag<MyTag, DirtyTag>(input, &DirtyTag::container)
    .orphans()
    .shrink();

    It isn't necessary to invoke all these functions each and every time. What functions to use in which case mostly depends on the goal and there is not a golden rule to do that. For obvious reasons, what is important is that the data are restored in exactly the same order in which they were serialized.

    +
    entt::continuous_loader<entt::entity> loader{registry};
    input_archive input;
    loader.entities(input)
    .destroyed(input)
    .component<a_component, another_component, dirty_component>(input, &dirty_component::parent, &dirty_component::child)
    .orphans()
    .shrink();

    It isn't necessary to invoke all these functions each and every time. What functions to use in which case mostly depends on the goal and there is not a golden rule to do that. For obvious reasons, what is important is that the data are restored in exactly the same order in which they were serialized.

    The entities and destroyed member functions restore groups of entities and map each entity to a local counterpart when required. In other terms, for each remote entity identifier not yet registered by the loader, the latter creates a local identifier so that it can keep the local entity in sync with the remote one.

    -

    The component and tag member functions restore all and only the components and the tags specified and assign them to the right entities.
    - In case the component or the tag contains entities itself (either as data members of type entity_type or as containers of entities), the loader can update them automatically. To do that, it's enough to specify the data members to update as shown in the example.

    -

    The orphans member function literally destroys those entities that have neither components nor tags after a restore. It has exactly the same purpose described in the previous section and works the same way.

    +

    The component member function restores all and only the components specified and assigns them to the right entities.
    + In case the component contains entities itself (either as data members of type entt::entity or as containers of entities), the loader can update them automatically. To do that, it's enough to specify the data members to update as shown in the example.

    +

    The orphans member function literally destroys those entities that have no components after a restore. It has exactly the same purpose described in the previous section and works the same way.

    Finally, shrink helps to purge local entities that no longer have a remote conterpart. Users should invoke this member function after restoring each snapshot, unless they know exactly what they are doing.

    Archives

    @@ -233,15 +230,15 @@ Archives
    • An output archive, the one used when creating a snapshot, must expose a function call operator with the following signature to store entities:
    -
    void operator()(Entity);

    Where Entity is the type of the entities used by the registry. Note that all the member functions of the snapshot class make also an initial call to this endpoint to save the size of the set they are going to store.
    - In addition, an archive must accept a pair of entity and either component or tag for each type to be serialized. Therefore, given a type T, the archive must contain a function call operator with the following signature:

    -
    void operator()(Entity, const T &);

    The output archive can freely decide how to serialize the data. The register is not affected at all by the decision.

    +
    void operator()(entt::entity);

    Where entt::entity is the type of the entities used by the registry. Note that all the member functions of the snapshot class make also an initial call to this endpoint to save the size of the set they are going to store.
    + In addition, an archive must accept a pair of entity and component for each type to be serialized. Therefore, given a type T, the archive must contain a function call operator with the following signature:

    +
    void operator()(entt::entity, const T &);

    The output archive can freely decide how to serialize the data. The register is not affected at all by the decision.

    • An input archive, the one used when restoring a snapshot, must expose a function call operator with the following signature to load entities:
    -
    void operator()(Entity &);

    Where Entity is the type of the entities used by the registry. Each time the function is invoked, the archive must read the next element from the underlying storage and copy it in the given variable. Note that all the member functions of a loader class make also an initial call to this endpoint to read the size of the set they are going to load.
    - In addition, the archive must accept a pair of entity and either component or tag for each type to be restored. Therefore, given a type T, the archive must contain a function call operator with the following signature:

    -
    void operator()(Entity &, T &);

    Every time such an operator is invoked, the archive must read the next elements from the underlying storage and copy them in the given variables.

    +
    void operator()(entt::entity &);

    Where entt::entity is the type of the entities used by the registry. Each time the function is invoked, the archive must read the next element from the underlying storage and copy it in the given variable. Note that all the member functions of a loader class make also an initial call to this endpoint to read the size of the set they are going to load.
    + In addition, the archive must accept a pair of entity and component for each type to be restored. Therefore, given a type T, the archive must contain a function call operator with the following signature:

    +
    void operator()(entt::entity &, T &);

    Every time such an operator is invoked, the archive must read the next elements from the underlying storage and copy them in the given variables.

    One example to rule them all

    EnTT comes with some examples (actually some tests) that show how to integrate a well known library for serialization as an archive. It uses Cereal C++ under the hood, mainly because I wanted to learn how it works at the time I was writing the code.

    @@ -252,12 +249,12 @@ Prototype

    A prototype defines a type of an application in terms of its parts. They can be used to assign components to entities of a registry at once.
    Roughly speaking, in most cases prototypes can be considered just as templates to use to initialize entities according to concepts. In fact, users can create how many prototypes they want, each one initialized differently from the others.

    The following is an example of use of a prototype:

    -
    entt::DefaultRegistry registry;
    entt::DefaultPrototype prototype{registry};
    prototype.set<Position>(100.f, 100.f);
    prototype.set<Velocity>(0.f, 0.f);
    // ...
    const auto entity = prototype();

    To assign and remove components from a prototype, it offers two dedicated member functions named set and unset. The has member function can be used to know if a given prototype contains one or more components and the get member function can be used to retrieve the components.

    +
    entt::registry registry;
    entt::prototype prototype{registry};
    prototype.set<position>(100.f, 100.f);
    prototype.set<velocity>(0.f, 0.f);
    // ...
    const auto entity = prototype();

    To assign and remove components from a prototype, it offers two dedicated member functions named set and unset. The has member function can be used to know if a given prototype contains one or more components and the get member function can be used to retrieve the components.

    Creating an entity from a prototype is straightforward:

      -
    • To create a new entity from scratch and assign it a prototype, this is the way to go:
      const auto entity = prototype();
      It is equivalent to the following invokation:
      const auto entity = prototype.create();
      • -
    • In case we want to initialize an already existing entity, we can provide the operator() directly with the entity identifier:
      prototype(entity);
      It is equivalent to the following invokation:
      prototype.assign(entity);
      Note that existing components aren't overwritten in this case. Only those components that the entity doesn't own yet are copied over. All the other components remain unchanged.
      • -
    • Finally, to assign or replace all the components for an entity, thus overwriting existing ones:
      prototype.accommodate(entity);
      • +
    • To create a new entity from scratch and assign it a prototype, this is the way to go:
      const auto entity = prototype();
      It is equivalent to the following invokation:
      const auto entity = prototype.create();
      • +
    • In case we want to initialize an already existing entity, we can provide the operator() directly with the entity identifier:
      prototype(entity);
      It is equivalent to the following invokation:
      prototype.assign(entity);
      Note that existing components aren't overwritten in this case. Only those components that the entity doesn't own yet are copied over. All the other components remain unchanged.
      • +
    • Finally, to assign or replace all the components for an entity, thus overwriting existing ones:
      prototype.assign_or_replace(entity);

    In the examples above, the prototype uses its underlying registry to create entities and components both for its purposes and when it's cloned. To use a different repository to clone a prototype, all the member functions accept also a reference to a valid registry as a first argument.

    Prototypes are a very useful tool that can save a lot of typing sometimes. Furthermore, the codebase may be easier to maintain, since updating a prototype is much less error prone than jumping around in the codebase to update all the snippets copied and pasted around to initialize entities and components.

    @@ -268,188 +265,183 @@ Helpers

    Dependency function

    A dependency function is a predefined listener, actually a function template to use to automatically assign components to an entity when a type has a dependency on some other types.
    - The following adds components AType and AnotherType whenever MyType is assigned to an entity:

    -
    entt::connnect<AType, AnotherType>(registry.construction<MyType>());

    A component is assigned to an entity and thus default initialized only in case the entity itself hasn't it yet. It means that already existent components won't be overriden.
    + The following adds components a_type and another_type whenever my_type is assigned to an entity:

    +
    entt::connnect<a_type, another_type>(registry.on_construct<my_type>());

    A component is assigned to an entity and thus default initialized only in case the entity itself hasn't it yet. It means that already existent components won't be overriden.
    A dependency can easily be broken by means of the following function template:

    -
    entt::disconnect<AType, AnotherType>(registry.construction<MyType>());

    -Labels

    -

    There's nothing magical about the way labels can be assigned to entities while avoiding a performance hit at runtime. Nonetheless, the syntax can be annoying and that's why a more user-friendly shortcut is provided to do it.
    - This shortcut is the alias template entt::label.

    -

    If used in combination with hashed strings, it helps to use labels where types would be required otherwise. As an example:

    -
    registry.assign<entt::label<"enemy"_hs>>(entity);

    +
    entt::disconnect<a_type, another_type>(registry.on_construct<my_type>());

    +Tags

    +

    There's nothing magical about the way tags can be assigned to entities while avoiding a performance hit at runtime. Nonetheless, the syntax can be annoying and that's why a more user-friendly shortcut is provided to do it.
    + This shortcut is the alias template entt::tag.

    +

    If used in combination with hashed strings, it helps to use tags where types would be required otherwise. As an example:

    +
    registry.assign<entt::tag<"enemy"_hs>>(entity);

    Null entity

    In EnTT, there exists a sort of null entity made available to users that is accessible via the entt::null variable.
    The library guarantees that the following expression always returns false:

    -
    registry.valid(entt::null);

    In other terms, a registry will reject the null entity in all cases because it isn't considered valid. It means that the null entity cannot own components or tags for obvious reasons.
    +

    registry.valid(entt::null);

    In other terms, a registry will reject the null entity in all cases because it isn't considered valid. It means that the null entity cannot own components for obvious reasons.
    The type of the null entity is internal and should not be used for any purpose other than defining the null entity itself. However, there exist implicit conversions from the null entity to identifiers of any allowed type:

    -
    typename entt::DefaultRegistry::entity_type null = entt::null;

    Similarly, the null entity can be compared to any other identifier:

    -
    const auto entity = registry.create();
    const bool null = (entity == entt::null);

    -View: to persist or not to persist?

    -

    First of all, it is worth answering an obvious question: why views?
    - Roughly speaking, they are a good tool to enforce single responsibility. A system that has access to a registry can create and destroy entities, as well as assign and remove components. On the other side, a system that has access to a view can only iterate entities and their components, then read or update the data members of the latter.
    +

    entt::entity null = entt::null;

    Similarly, the null entity can be compared to any other identifier:

    +
    const auto entity = registry.create();
    const bool null = (entity == entt::null);

    +Context variables

    +

    It is often convenient to assign context variables to a registry, so as to make it the only source of truth of an application.
    + This is possible by means of a member function named set to use to create a context variable from a given type. Later on, either ctx or try_ctx can be used to retrieve the newly created instance and unset is there to literally reset it if needed.

    +

    Example of use:

    +
    // creates a new context variable initialized with the given values
    registry.set<my_type>(42, 'c');
    // gets the context variable
    const auto &var = registry.ctx<my_type>();
    // if in doubts, probe the registry to avoid assertions in case of errors
    if(auto *ptr = registry.try_ctx<my_type>(); ptr) {
    // uses the context variable associated with the registry, if any
    }
    // unsets the context variable
    registry.unset<my_type>();

    The type of a context variable must be such that it's default constructible and can be moved. The set member function either creates a new instance of the context variable or overwrites an already existing one if any. The try_ctx member function returns a pointer to the context variable if it exists, otherwise it returns a null pointer. This fits well with the if statement with initializer.

    +

    +Views and Groups

    +

    First of all, it is worth answering an obvious question: why views and groups?
    + Briefly, they are a good tool to enforce single responsibility. A system that has access to a registry can create and destroy entities, as well as assign and remove components. On the other side, a system that has access to a view or a group can only iterate entities and their components, then read or update the data members of the latter.
    It is a subtle difference that can help designing a better software sometimes.

    -

    There are mainly four kinds of views: standard (also known as View), persistent (also known as PersistentView), raw (also known as RawView) and runtime (also known as RuntimeView).
    - All of them have pros and cons to take in consideration. In particular:

    -
      -

    • Standard views:

      -

      Pros:

        -
      • They work out-of-the-box and don't require any dedicated data structure.
        • -
      • Creating and destroying them isn't expensive at all because they don't have any type of initialization.
        • -
      • They are the best tool for iterating entities for a single component.
        • -
      • They are the best tool for iterating entities for multiple components when one of the components is assigned to a significantly low number of entities.
        • -
      • They don't affect any other operations of the registry.
        • -
      -

      Cons:

        -
      • Their performance tend to degenerate when the number of components to iterate grows up and the most of the entities have all of them.
        • -
      -
      • -

    • Persistent views:

      -

      Pros:

        -
      • Once prepared, creating and destroying them isn't expensive at all because they don't have any type of initialization.
        • -
      • They are the best tool for iterating entities for multiple components when most entities have them all.
        • -
      -

      Cons:

        -
      • They have dedicated data structures and thus affect the memory usage to a minimal extent.
        • -
      • If not previously prepared, the first time they are used they go through an initialization step that could take a while.
        • -
      • They affect to a minimum the creation and destruction of entities and components. In other terms: the more persistent views there will be, the less performing will be creating and destroying entities and components.
        • -
      -
      • -

    • Raw views:

      -

      Pros:

        -
      • They work out-of-the-box and don't require any dedicated data structure.
        • -
      • Creating and destroying them isn't expensive at all because they don't have any type of initialization.
        • -
      • They are the best tool for iterating components when it is not necessary to know which entities they belong to.
        • -
      • They don't affect any other operations of the registry.
        • -
      -

      Cons:

        -
      • They can be used to iterate only one type of component at a time.
        • -
      • They don't return the entity to which a component belongs to the caller.
        • -
      -
      • -

    • Runtime views:

      -

      Pros:

        -
      • Their lists of components are defined at runtime and not at compile-time.
        • -
      • Creating and destroying them isn't expensive at all because they don't have any type of initialization.
        • -
      • They are the best tool for things like plugin systems and mods in general.
        • -
      • They don't affect any other operations of the registry.
        • -
      -

      Cons:

        -
      • Their performances are definitely lower than those of all the other views, although they are still usable and sufficient for most of the purposes.
        • -
      -
      • -
    -

    To sum up and as a rule of thumb:

    -
      -
    • Use a raw view to iterate components only (no entities) for a given type.
      • -
    • Use a standard view to iterate entities and components for a single type.
      • -
    • Use a standard view to iterate entities and components for multiple types when the number of types is low. Standard views are really optimized and persistent views won't add much in this case.
      • -
    • Use a standard view to iterate entities and components for multiple types when a significantly low number of entities have one of the components.
      • -
    • Use a standard view in all those cases where a persistent view would give a boost to performance but the iteration isn't performed frequently.
      • -
    • Prepare and use a persistent view when you want to iterate only entities for multiple components.
      • -
    • Prepare and use a persistent view when you want to iterate entities for multiple components and each component is assigned to a great number of entities but the intersection between the sets of entities is small.
      • -
    • Prepare and use a persistent view in all the cases where a standard view wouldn't fit well otherwise.
      • -
    • Finally, in case you don't know at compile-time what are the components to use, choose a runtime view and set them during execution.
      • -
    -

    To easily iterate entities and components, all the views offer the common begin and end member functions that allow users to use a view in a typical range-for loop. Almost all the views offer also a more functional each member function that accepts a callback for convenience.
    - Continue reading for more details or refer to the inline documentation.

    -

    -Standard View

    -

    A standard view behaves differently if it's constructed for a single component or if it has been requested to iterate multiple components. Even the API is different in the two cases.
    - All that they share is the way they are created by means of a registry:

    -
    // single component standard view
    auto single = registry.view<Position>();
    // multi component standard view
    auto multi = registry.view<Position, Velocity>();

    For all that remains, it's worth discussing them separately.
    -

    -

    -Single component standard view

    -

    Single component standard views are specialized in order to give a boost in terms of performance in all the situation. This kind of views can access the underlying data structures directly and avoid superfluous checks.
    - They offer a bunch of functionalities to get the number of entities they are going to return and a raw access to the entity list as well as to the component list. It's also possible to ask a view if it contains a given entity.
    +

    More in details, views are a non-intrusive tool to access entities and components without affecting other functionalities or increasing the memory consumption. On the other side, groups are an intrusive tool that allows to reach higher performance along critical paths but has also a price to pay for that.

    +

    There are mainly two kinds of views: compile-time (also known as view) and runtime (also known as runtime_view).
    + The former require that users indicate at compile-time what are the components involved and can make several optimizations because of that. The latter can be constructed at runtime instead and are a bit slower to iterate entities and components.
    + In both cases, creating and destroying a view isn't expensive at all because views don't have any type of initialization. Moreover, views don't affect any other functionality of the registry and keep memory usage at a minimum.

    +

    Groups come in three different flavors: full-owning groups, partial-owning groups and non-owning groups. The main difference between them is in terms of performance.
    + Groups can literally own one or more types of components. It means that they will be allowed to rearrange pools so as to speed up iterations. Roughly speaking: the more components a group owns, the faster it is to iterate them. On the other side, a given component can belong only to one group, so users have to define groups carefully to get the best out of them.

    +

    Continue reading for more details or refer to the inline documentation.

    +

    +Views

    +

    A view behaves differently if it's constructed for a single component or if it has been created to iterate multiple components. Even the API is slightly different in the two cases.

    +

    Single component views are specialized in order to give a boost in terms of performance in all the situations. This kind of views can access the underlying data structures directly and avoid superfluous checks. There is nothing as fast as a single component view. In fact, they walk through a packed array of components and return them one at a time.
    + Single component views offer a bunch of functionalities to get the number of entities they are going to return and a raw access to the entity list as well as to the component list. It's also possible to ask a view if it contains a given entity.
    Refer to the inline documentation for all the details.

    -

    There is no need to store views around for they are extremely cheap to construct, even though they can be copied without problems and reused freely. In fact, they return newly created and correctly initialized iterators whenever begin or end are invoked.
    - To iterate a single component standard view, either use it in a range-for loop:

    -
    auto view = registry.view<Renderable>();
    for(auto entity: view) {
    Renderable &renderable = view.get(entity);
    // ...
    }

    Or rely on the each member function to iterate entities and get all their components at once:

    -
    registry.view<Renderable>().each([](auto entity, auto &renderable) {
    // ...
    });

    The each member function is highly optimized. Unless users want to iterate only entities, using each should be the preferred approach.

    -

    Note: prefer the get member function of a view instead of the get member function template of a registry during iterations, if possible. However, keep in mind that it works only with the components of the view itself.

    -

    -Multi component standard view

    -

    Multi component standard views iterate entities that have at least all the given components in their bags. During construction, these views look at the number of entities available for each component and pick up a reference to the smallest set of candidates in order to speed up iterations.
    - They offer fewer functionalities than their companion views for single component. In particular, a multi component standard view exposes utility functions to get the estimated number of entities it is going to return and to know whether it's empty or not. It's also possible to ask a view if it contains a given entity.
    +

    Multi component views iterate entities that have at least all the given components in their bags. During construction, these views look at the number of entities available for each component and pick up a reference to the smallest set of candidates in order to speed up iterations.
    + They offer fewer functionalities than their companion views for single component. In particular, a multi component view exposes utility functions to get the estimated number of entities it is going to return and to know whether it's empty or not. It's also possible to ask a view if it contains a given entity.
    Refer to the inline documentation for all the details.

    -

    There is no need to store views around for they are extremely cheap to construct, even though they can be copied without problems and reused freely. In fact, they return newly created and correctly initialized iterators whenever begin or end are invoked.
    - To iterate a multi component standard view, either use it in a range-for loop:

    -
    auto view = registry.view<Position, Velocity>();
    for(auto entity: view) {
    // a component at a time ...
    Position &position = view.get<Position>(entity);
    Velocity &velocity = view.get<Velocity>(entity);
    // ... or multiple components at once
    std::tuple<Position &, Velocity &> tup = view.get<Position, Velocity>(entity);
    // ...
    }

    Or rely on the each member function to iterate entities and get all their components at once:

    -
    registry.view<Position, Velocity>().each([](auto entity, auto &position, auto &velocity) {
    // ...
    });

    The each member function is highly optimized. Unless users want to iterate only entities or get only some of the components, using each should be the preferred approach.

    -

    Note: prefer the get member function of a view instead of the get member function template of a registry during iterations, if possible. However, keep in mind that it works only with the components of the view itself.

    -

    -Persistent View

    -

    A persistent view returns all the entities and only the entities that have at least the given components. Moreover, it's guaranteed that the entity list is tightly packed in memory for fast iterations.
    - In general, persistent views don't stay true to the order of any set of components unless users explicitly sort them.

    -

    Persistent views can be used only to iterate multiple components. To create this kind of views, the tag persistent_t must also be used in order to disambiguate overloads of the view member function:

    -
    auto view = registry.view<Position, Velocity>(entt::persistent_t{});

    There is no need to store views around for they are extremely cheap to construct, even though they can be copied without problems and reused freely. In fact, they return newly created and correctly initialized iterators whenever begin or end are invoked.
    - That being said, persistent views perform an initialization step the very first time they are constructed and this could be quite costly. To avoid it, consider asking to the registry to prepare them when no entities have been created yet:

    -
    registry.prepare<Position, Velocity>();

    If the registry is empty, preparation is extremely fast. Moreover the prepare member function template is idempotent. Feel free to invoke it even more than once: if the view has been already prepared before, the function returns immediately and does nothing.

    -

    A persistent view offers a bunch of functionalities to get the number of entities it's going to return, a raw access to the entity list and the possibility to sort the underlying data structures according to the order of one of the components for which it has been constructed. It's also possible to ask a view if it contains a given entity.
    - Refer to the inline documentation for all the details.

    -

    To iterate a persistent view, either use it in a range-for loop:

    -
    auto view = registry.view<Position, Velocity>(entt::persistent_t{});
    for(auto entity: view) {
    // a component at a time ...
    Position &position = view.get<Position>(entity);
    Velocity &velocity = view.get<Velocity>(entity);
    // ... or multiple components at once
    std::tuple<Position &, Velocity &> tup = view.get<Position, Velocity>(entity);
    // ...
    }

    Or rely on the each member function to iterate entities and get all their components at once:

    -
    registry.view<Position, Velocity>(entt::persistent_t{}).each([](auto entity, auto &position, auto &velocity) {
    // ...
    });

    Performance are more or less the same. The best approach depends mainly on whether all the components have to be accessed or not.

    -

    Note: prefer the get member function of a view instead of the get member function template of a registry during iterations, if possible. However, keep in mind that it works only with the components of the view itself.

    -

    -Raw View

    -

    Raw views return all the components of a given type. This kind of views can access components directly and avoid extra indirections like when components are accessed via an entity identifier.
    - They offer a bunch of functionalities to get the number of instances they are going to return and a raw access to the entity list as well as to the component list.
    - Refer to the inline documentation for all the details.

    -

    Raw views can be used only to iterate components for a single type. To create this kind of views, the tag raw_t must also be used in order to disambiguate overloads of the view member function:

    -
    auto view = registry.view<Renderable>(entt::raw_t{});

    There is no need to store views around for they are extremely cheap to construct, even though they can be copied without problems and reused freely. In fact, they return newly created and correctly initialized iterators whenever begin or end are invoked.
    - To iterate a raw view, use it in a range-for loop:

    -
    auto view = registry.view<Renderable>(entt::raw_t{});
    for(auto &&component: raw) {
    // ...
    }

    Or rely on the each member function:

    -
    registry.view<Renderable>(entt::raw_t{}).each([](auto &renderable) {
    // ...
    });

    Performance are exactly the same in both cases.

    -

    Note: raw views don't have a get member function for obvious reasons.

    -

    -Runtime View

    +

    There is no need to store views around for they are extremely cheap to construct, even though they can be copied without problems and reused freely. Views also return newly created and correctly initialized iterators whenever begin or end are invoked.

    +

    Views share the way they are created by means of a registry:

    +
    // single component view
    auto single = registry.view<position>();
    // multi component view
    auto multi = registry.view<position, velocity>();

    To iterate a view, either use it in a range-for loop:

    +
    auto view = registry.view<position, velocity>();
    for(auto entity: view) {
    // a component at a time ...
    auto &position = view.get<position>(entity);
    auto &velocity = view.get<velocity>(entity);
    // ... or multiple components at once
    auto &[pos, vel] = view.get<position, velocity>(entity);
    // ...
    }

    Or rely on the each member function to iterate entities and get all their components at once:

    +
    registry.view<position, velocity>().each([](auto entity, auto &pos, auto &vel) {
    // ...
    });

    The each member function is highly optimized. Unless users want to iterate only entities or get only some of the components, this should be the preferred approach. Note that the entity can also be excluded from the parameter list if not required, but this won't improve performance for multi component views.

    +

    As a side note, when using a single component view, the most common error is to invoke get with the type of the component as a template parameter. This is probably due to the fact that it's required for multi component views:

    +
    auto view = registry.view<position, const velocity>();
    for(auto entity: view) {
    const auto &vel = view.get<const velocity>(entity);
    // ...
    }

    However, in case of a single component view, get doesn't accept a template parameter, since it's implicitly defined by the view itself:

    +
    auto view = registry.view<const renderable>();
    for(auto entity: view) {
    const auto &renderable = view.get(entity);
    // ...
    }

    Note: prefer the get member function of a view instead of the get member function template of a registry during iterations, if possible. However, keep in mind that it works only with the components of the view itself.

    +

    +Runtime views

    Runtime views iterate entities that have at least all the given components in their bags. During construction, these views look at the number of entities available for each component and pick up a reference to the smallest set of candidates in order to speed up iterations.
    - They offer more or less the same functionalities of a multi component standard view. However, they don't expose a get member function and users should refer to the registry that generated the view to access components. In particular, a runtime view exposes utility functions to get the estimated number of entities it is going to return and to know whether it's empty or not. It's also possible to ask a view if it contains a given entity.
    + They offer more or less the same functionalities of a multi component view. However, they don't expose a get member function and users should refer to the registry that generated the view to access components. In particular, a runtime view exposes utility functions to get the estimated number of entities it is going to return and to know whether it's empty or not. It's also possible to ask a runtime view if it contains a given entity.
    Refer to the inline documentation for all the details.

    Runtime view are extremely cheap to construct and should not be stored around in any case. They should be used immediately after creation and then they should be thrown away. The reasons for this go far beyond the scope of this document.
    To iterate a runtime view, either use it in a range-for loop:

    -
    using component_type = typename decltype(registry)::component_type;
    component_type types[] = { registry.type<Position>(), registry.type<Velocity>() };
    auto view = registry.view(std::cbegin(types), std::cend(types));
    for(auto entity: view) {
    // a component at a time ...
    Position &position = registry.get<Position>(entity);
    Velocity &velocity = registry.get<Velocity>(entity);
    // ... or multiple components at once
    std::tuple<Position &, Velocity &> tup = view.get<Position, Velocity>(entity);
    // ...
    }

    Or rely on the each member function to iterate entities:

    -
    using component_type = typename decltype(registry)::component_type;
    component_type types[] = { registry.type<Position>(), registry.type<Velocity>() };
    auto view = registry.view(std::cbegin(types), std::cend(types)).each([](auto entity) {
    // ...
    });

    Performance are exactly the same in both cases.

    +
    using component_type = typename decltype(registry)::component_type;
    component_type types[] = { registry.type<position>(), registry.type<velocity>() };
    auto view = registry.runtime_view(std::cbegin(types), std::cend(types));
    for(auto entity: view) {
    // a component at a time ...
    auto &position = registry.get<position>(entity);
    auto &velocity = registry.get<velocity>(entity);
    // ... or multiple components at once
    auto &[pos, vel] = registry.get<position, velocity>(entity);
    // ...
    }

    Or rely on the each member function to iterate entities:

    +
    using component_type = typename decltype(registry)::component_type;
    component_type types[] = { registry.type<position>(), registry.type<velocity>() };
    auto view = registry.runtime_view(std::cbegin(types), std::cend(types)).each([](auto entity) {
    // ...
    });

    Performance are exactly the same in both cases.

    Note: runtime views are meant for all those cases where users don't know at compile-time what components to use to iterate entities. This is particularly well suited to plugin systems and mods in general. Where possible, don't use runtime views, as their performance are slightly inferior to those of the other views.

    -

    +

    +Groups

    +

    Groups are meant to iterate multiple components at once and offer a faster alternative to views. Roughly speaking, they just play in another league when compared to views.
    + Groups overcome the performance of the other tools available but require to get the ownership of components and this sets some constraints on pools. On the other side, groups aren't an automatism that increases memory consumption, affects functionalities and tries to optimize iterations for all the possible combinations of components. Users can decide when to pay for groups and to what extent.
    + The most interesting aspect of groups is that they fit usage patterns. Other solutions around usually try to optimize everything, because it is known that somewhere within the everything there are also our usage patterns. However this has a cost that isn't negligible, both in terms of performance and memory usage. Ironically, users pay the price also for things they don't want and this isn't something I like much. Even worse, one cannot easily disable such a behavior. Groups work differently instead and are designed to optimize only the real use cases when users find they need to.
    + Another nice-to-have feature of groups is that they have no impact on memory consumption, put aside full non-owning groups that are pretty rare and should be avoided as long as possible.

    +

    All groups affect to an extent the creation and destruction of their components. This is due to the fact that they must observe changes in the pools of interest and arrange data correctly when needed for the types they own.
    + That being said, the way groups operate is beyond the scope of this document. However, it's unlikely that users will be able to appreciate the impact of groups on other functionalities of the registry.

    +

    Groups offer a bunch of functionalities to get the number of entities they are going to return and a raw access to the entity list as well as to the component list for owned components. It's also possible to ask a group if it contains a given entity.
    + Refer to the inline documentation for all the details.

    +

    There is no need to store groups around for they are extremely cheap to construct, even though they can be copied without problems and reused freely. A group performs an initialization step the very first time it's requested and this could be quite costly. To avoid it, consider creating the group when no components have been assigned yet. If the registry is empty, preparation is extremely fast. Groups also return newly created and correctly initialized iterators whenever begin or end are invoked.

    +

    To iterate groups, either use them in a range-for loop:

    +
    auto group = registry.group<position>(entt::get<velocity>);
    for(auto entity: group) {
    // a component at a time ...
    auto &position = group.get<position>(entity);
    auto &velocity = group.get<velocity>(entity);
    // ... or multiple components at once
    auto &[pos, vel] = group.get<position, velocity>(entity);
    // ...
    }

    Or rely on the each member function to iterate entities and get all their components at once:

    +
    registry.group<position>(entt::get<velocity>).each([](auto entity, auto &pos, auto &vel) {
    // ...
    });

    The each member function is highly optimized. Unless users want to iterate only entities, this should be the preferred approach. Note that the entity can also be excluded from the parameter list if not required and it can improve even further the performance during iterations.

    +

    Note: prefer the get member function of a group instead of the get member function template of a registry during iterations, if possible. However, keep in mind that it works only with the components of the group itself.

    +

    Let's go a bit deeper into the different types of groups made available by this library to know how they are constructed and what are the differences between them.

    +

    +Full-owning groups

    +

    A full-owning group is the fastest tool an user can expect to use to iterate multiple components at once. It iterates all the components directly, no indirection required. This type of groups performs more or less as if users are accessing sequentially a bunch of packed arrays of components all sorted identically.

    +

    A full-owning group is created as:

    +
    auto group = registry.group<position, velocity>();

    Filtering entities by components is also supported:

    +
    auto group = registry.group<position, velocity>(entt::exclude<renderable>);

    Once created, the group gets the ownership of all the components specified in the template parameter list and arranges their pools so as to iterate all of them as fast as possible.

    +

    Sorting owned components is no longer allowed once the group has been created. However, full-owning groups can be sorted by means of their sort member functions, if required. Sorting a full-owning group affects all the instance of the same group (it means that users don't have to call sort on each instance to sort all of them because they share the underlying data structure).

    +

    +Partial-owning groups

    +

    A partial-owning group works similarly to a full-owning group for the components it owns, but relies on indirection to get components owned by other groups. This isn't as fast as a full-owning group, but it's already much faster than views when there are only one or two free components to retrieve (the most common cases likely). In the worst case, it's not slower than views anyway.

    +

    A partial-owning group is created as:

    +
    auto group = registry.group<position>(entt::get<velocity>);

    Filtering entities by components is also supported:

    +
    auto group = registry.group<position>(entt::get<velocity>, entt::exclude<renderable>);

    Once created, the group gets the ownership of all the components specified in the template parameter list and arranges their pools so as to iterate all of them as fast as possible. The ownership of the types provided via entt::get doesn't pass to the group instead.

    +

    Sorting owned components is no longer allowed once the group has been created. However, partial-owning groups can be sorted by means of their sort member functions, if required. Sorting a partial-owning group affects all the instance of the same group (it means that users don't have to call sort on each instance to sort all of them because they share the underlying data structure).

    +

    +Non-owning groups

    +

    Non-owning groups are usually fast enough, for sure faster than views and well suited for most of the cases. However, they require custom data structures to work properly and they increase memory consumption. As a rule of thumb, users should avoid using non-owning groups, if possible.

    +

    A non-owning group is created as:

    +
    auto group = registry.group<>(entt::get<position, velocity>);

    Filtering entities by components is also supported:

    +
    auto group = registry.group<>(entt::get<position, velocity>, entt::exclude<renderable>);

    The group doesn't receive the ownership of any type of component in this case. This type of groups is therefore the least performing in general, but also the only one that can be used in any situation to improve a performance where necessary.

    +

    Non-owning groups can be sorted by means of their sort member functions, if required. Sorting a non-owning group affects all the instance of the same group (it means that users don't have to call sort on each instance to sort all of them because they share the set of entities).

    +

    +Types: const, non-const and all in between

    +

    The registry class offers two overloads when it comes to constructing views and groups: a const version and a non-const one. The former accepts both const and non-const types as template parameters, the latter accepts only const types instead.
    + It means that views and groups can be constructed also from a const registry and they propagate the constness of the registry to the types involved. As an example:

    +
    entt::view<const position, const velocity> view = std::as_const(registry).view<const position, const velocity>();

    Consider the following definition for a non-const view instead:

    +
    entt::view<position, const velocity> view = registry.view<position, const velocity>();

    In the example above, view can be used to access either read-only or writable position components while velocity components are read-only in all cases.
    + In other terms, these statements are all valid:

    +
    position &pos = view.get<position>(entity);
    const position &cpos = view.get<const position>(entity);
    const velocity &cpos = view.get<const velocity>(entity);
    std::tuple<position &, const velocity &> tup = view.get<position, const velocity>(entity);
    std::tuple<const position &, const velocity &> ctup = view.get<const position, const velocity>(entity);

    It's not possible to get non-const references to velocity components from the same view instead and these will result in compilation errors:

    +
    velocity &cpos = view.get<velocity>(entity);
    std::tuple<position &, velocity &> tup = view.get<position, velocity>(entity);
    std::tuple<const position &, velocity &> ctup = view.get<const position, velocity>(entity);

    Similarly, the each member functions will propagate constness to the type of the components returned during iterations:

    +
    view.each([](auto entity, position &pos, const velocity &vel) {
    // ...
    });

    Obviously, a caller can still refer to the position components through a const reference because of the rules of the language that fortunately already allow it.

    +

    The same concepts apply to groups as well.

    +

    Give me everything

    -

    Views are narrow windows on the entire list of entities. They work by filtering entities according to their components.
    +

    Views and groups are narrow windows on the entire list of entities. They work by filtering entities according to their components.
    In some cases there may be the need to iterate all the entities still in use regardless of their components. The registry offers a specific member function to do that:

    -
    registry.each([](auto entity) {
    // ...
    });

    It returns to the caller all the entities that are still in use by means of the given function.
    - As a rule of thumb, consider using a view if the goal is to iterate entities that have a determinate set of components. A view is usually much faster than combining this function with a bunch of custom tests.
    +

    registry.each([](auto entity) {
    // ...
    });

    It returns to the caller all the entities that are still in use by means of the given function.
    + As a rule of thumb, consider using a view or a group if the goal is to iterate entities that have a determinate set of components. These tools are usually much faster than combining this function with a bunch of custom tests.
    In all the other cases, this is the way to go.

    -

    There exists also another member function to use to retrieve orphans. An orphan is an entity that is still in use and has neither assigned components nor tags.
    +

    There exists also another member function to use to retrieve orphans. An orphan is an entity that is still in use and has no assigned components.
    The signature of the function is the same of each:

    -
    registry.orphans([](auto entity) {
    // ...
    });

    To test the orphanity of a single entity, use the member function orphan instead. It accepts a valid entity identifer as an argument and returns true in case the entity is an orphan, false otherwise.

    +
    registry.orphans([](auto entity) {
    // ...
    });

    To test the orphanity of a single entity, use the member function orphan instead. It accepts a valid entity identifer as an argument and returns true in case the entity is an orphan, false otherwise.

    In general, all these functions can result in poor performance.
    each is fairly slow because of some checks it performs on each and every entity. For similar reasons, orphans can be even slower. Both functions should not be used frequently to avoid the risk of a performance hit.

    -

    -Iterations: what is allowed and what is not

    -

    Most of the ECS available out there have some annoying limitations (at least from my point of view): entities and components cannot be created nor destroyed during iterations.
    +

    +What is allowed and what is not

    +

    Most of the ECS available out there don't allow to create and destroy entities and components during iterations.
    EnTT partially solves the problem with a few limitations:

      -
    • Creating entities and components is allowed during iterations.
      • -
    • Deleting an entity or removing its components is allowed during iterations if it's the one currently returned by the view. For all the other entities, destroying them or removing their components isn't allowed and it can result in undefined behavior.
      • +
    • Creating entities and components is allowed during iterations in almost all cases.
      • +
    • Deleting the current entity or removing its components is allowed during iterations. For all the other entities, destroying them or removing their components isn't allowed and can result in undefined behavior.
    -

    Iterators are invalidated and the behavior is undefined if an entity is modified or destroyed and it's not the one currently returned by the view nor a newly created one.
    +

    In these cases, iterators aren't invalidated. To be clear, it doesn't mean that also references will continue to be valid.
    + Consider the following example:

    +
    registry.view<position>([&](const auto entity, auto &pos) {
    registry.assign<position>(registry.create(), 0., 0.);
    pos.x = 0.; // warning: dangling pointer
    });

    The each member function won't break (because iterators aren't invalidated) but there are no guarantees on references. Use a common range-for loop and get components directly from the view or move the creation of components at the end of the function to avoid dangling pointers.

    +

    Iterators are invalidated instead and the behavior is undefined if an entity is modified or destroyed and it's not the one currently returned by the iterator nor a newly created one.
    To work around it, possible approaches are:

    • Store aside the entities and the components to be removed and perform the operations at the end of the iteration.
    • Mark entities and components with a proper tag component that indicates they must be purged, then perform a second iteration to clean them up one by one.

    A notable side effect of this feature is that the number of required allocations is further reduced in most of the cases.

    -

    +

    +More performance, more constraints

    +

    Groups are a (much) faster alternative to views. However, the higher the performance, the greater the constraints on what is allowed and what is not.
    + In particular, groups add in some rare cases a limitation on the creation of components during iterations. It happens in quite particular cases. Given the nature and the scope of the groups, it isn't something in which it will happen to come across probably, but it's good to know it anyway.

    +

    First of all, it must be said that creating components while iterating a group isn't a problem at all and can be done freely as it happens with the views. The same applies to the destruction of components and entities, for which the rules mentioned above apply.

    +

    The additional limitation pops out instead when a given component that is owned by a group is iterated outside of it. In this case, adding components that are part of the group itself may invalidate the iterators. There are no further limitations to the destruction of components and entities.
    + Fortunately, this isn't always true. In fact, it almost never is and this happens only under certain conditions. In particular:

    +
      +
    • Iterating a type of component that is part of a group with a single component view and adding to an entity all the components required to get it into the group may invalidate the iterators.
      • +
    • Iterating a type of component that is part of a group with a multi component view and adding to an entity all the components required to get it into the group can invalidate the iterators, unless users specify another type of component to use to induce the order of iteration of the view (in this case, the former is treated as a free type and isn't affected by the limitation).
      • +
    +

    In other words, the limitation doesn't exist as long as a type is treated as a free type (as an example with multi component views and partial- or non-owning groups) or iterated with its own group, but it can occur if the type is used as a main type to rule on an iteration.
    + This happens because groups own the pools of their components and organize the data internally to maximize performance. Because of that, full consistency for owned components is guaranteed only when they are iterated as part of their groups or as free types with multi component views and groups in general.

    +

    +Empty type optimization

    +

    An empty type T is such that std::is_empty_v<T> returns true. They are also the same types for which empty base optimization (EBO) is possibile.
    + EnTT handles these types in a special way, optimizing both in terms of performance and memory usage. However, this also has consequences that are worth mentioning.

    +

    When an empty type is detected, it's not instantiated in any case. Therefore, only the entities to which it's assigned are made available. All the iterators as well as the get member functions of the registry, the views and the groups will return temporary objects. Similarly, some functions such as try_get or the raw access to the list of components aren't available for this kind of types.
    + On the other hand, iterations are faster because only the entities to which the type is assigned are considered. Moreover, less memory is used, since there doesn't exist any instance of the component, no matter how many entities it is assigned to.

    +

    For similar reasons, wherever a function type of a listener accepts a component, it cannot be caught by a non-const reference. Capture it by copy or by const reference instead.

    +

    More in general, none of the features offered by the library is affected, but for the ones that require to return actual instances.

    +

    Multithreading

    In general, the entire registry isn't thread safe as it is. Thread safety isn't something that users should want out of the box for several reasons. Just to mention one of them: performance.
    - Views and consequently the approach adopted by EnTT are the great exception to the rule. It's true that views and thus their iterators aren't thread safe by themselves. Because of this users shouldn't try to iterate a set of components and modify the same set concurrently. However:

    + Views, groups and consequently the approach adopted by EnTT are the great exception to the rule. It's true that views, groups and iterators in general aren't thread safe by themselves. Because of this users shouldn't try to iterate a set of components and modify the same set concurrently. However:

    • As long as a thread iterates the entities that have the component X or assign and removes that component from a set of entities, another thread can safely do the same with components Y and Z and everything will work like a charm. As a trivial example, users can freely execute the rendering system and iterate the renderable entities while updating a physic component concurrently on a separate thread.
    • Similarly, a single set of components can be iterated by multiple threads as long as the components are neither assigned nor removed in the meantime. In other words, a hypothetical movement system can start multiple threads, each of which will access the components that carry information about velocity and position for its entities.

    This kind of entity-component systems can be used in single threaded applications as well as along with async stuff or multiple threads. Moreover, typical thread based models for ECS don't require a fully thread safe registry to work. Actually, users can reach the goal with the registry as it is while working with most of the common models.

    -

    Because of the few reasons mentioned above and many others not mentioned, users are completely responsible for synchronization whether required. On the other hand, they could get away with it without having to resort to particular expedients.

    +

    Because of the few reasons mentioned above and many others not mentioned, users are completely responsible for synchronization whether required. On the other hand, they could get away with it without having to resort to particular expedients.

    +

    +Iterators

    +

    A special mention is needed for the iterators returned by the views and the groups. Most of the time they meet the requirements of random access iterators, in all cases they meet at least the requirements of forward iterators.
    + In other terms, they are suitable for use with the parallel algorithms of the standard library. If it's not clear, this is a great thing.

    +

    As an example, this kind of iterators can be used in combination with std::for_each and std::execution::par to parallelize the visit and therefore the update of the components returned by a view or a group, as long as the constraints previously discussed are respected:

    +
    auto view = registry.view<position, const velocity>();
    std::for_each(std::execution::par_unseq, view.begin(), view.end(), [&view](auto entity) {
    // ...
    });

    This can increase the throughput considerably, even without resorting to who knows what artifacts that are difficult to maintain over time.

    +

    Unfortunately, because of the limitations of the current revision of the standard, the parallel std::for_each accepts only forward iterators. This means that the iterators provided by the library cannot return proxy objects as references and must return actual reference types instead.
    + This may change in the future and the iterators will almost certainly return both the entities and a list of references to their components sooner or later. Multi-pass guarantee won't break in any case and the performance should even benefit from it further.

    diff --git a/cache_8hpp_source.html b/cache_8hpp_source.html index d81aec370..558726bac 100644 --- a/cache_8hpp_source.html +++ b/cache_8hpp_source.html @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    @@ -67,22 +67,24 @@ $(function() {
    cache.hpp
    -
    1 #ifndef ENTT_RESOURCE_CACHE_HPP
    2 #define ENTT_RESOURCE_CACHE_HPP
    3 
    4 
    5 #include <memory>
    6 #include <utility>
    7 #include <type_traits>
    8 #include <unordered_map>
    9 #include "../config/config.h"
    10 #include "../core/hashed_string.hpp"
    11 #include "handle.hpp"
    12 #include "loader.hpp"
    13 
    14 
    15 namespace entt {
    16 
    17 
    28 template<typename Resource>
    29 class ResourceCache {
    30  using container_type = std::unordered_map<HashedString::hash_type, std::shared_ptr<Resource>>;
    31 
    32 public:
    34  using size_type = typename container_type::size_type;
    36  using resource_type = HashedString;
    37 
    39  ResourceCache() = default;
    40 
    42  ResourceCache(const ResourceCache &) ENTT_NOEXCEPT = delete;
    44  ResourceCache(ResourceCache &&) ENTT_NOEXCEPT = default;
    45 
    47  ResourceCache & operator=(const ResourceCache &) ENTT_NOEXCEPT = delete;
    49  ResourceCache & operator=(ResourceCache &&) ENTT_NOEXCEPT = default;
    50 
    55  size_type size() const ENTT_NOEXCEPT {
    56  return resources.size();
    57  }
    58 
    63  bool empty() const ENTT_NOEXCEPT {
    64  return resources.empty();
    65  }
    66 
    73  void clear() ENTT_NOEXCEPT {
    74  resources.clear();
    75  }
    76 
    95  template<typename Loader, typename... Args>
    96  bool load(const resource_type id, Args &&... args) {
    97  static_assert(std::is_base_of<ResourceLoader<Loader, Resource>, Loader>::value, "!");
    98 
    99  bool loaded = true;
    100 
    101  if(resources.find(id) == resources.cend()) {
    102  std::shared_ptr<Resource> resource = Loader{}.get(std::forward<Args>(args)...);
    103  loaded = (static_cast<bool>(resource) ? (resources[id] = std::move(resource), loaded) : false);
    104  }
    105 
    106  return loaded;
    107  }
    108 
    128  template<typename Loader, typename... Args>
    129  bool reload(const resource_type id, Args &&... args) {
    130  return (discard(id), load<Loader>(id, std::forward<Args>(args)...));
    131  }
    132 
    145  template<typename Loader, typename... Args>
    146  ResourceHandle<Resource> temp(Args &&... args) const {
    147  return { Loader{}.get(std::forward<Args>(args)...) };
    148  }
    149 
    163  ResourceHandle<Resource> handle(const resource_type id) const {
    164  auto it = resources.find(id);
    165  return { it == resources.end() ? nullptr : it->second };
    166  }
    167 
    173  bool contains(const resource_type id) const ENTT_NOEXCEPT {
    174  return (resources.find(id) != resources.cend());
    175  }
    176 
    185  void discard(const resource_type id) ENTT_NOEXCEPT {
    186  auto it = resources.find(id);
    187 
    188  if(it != resources.end()) {
    189  resources.erase(it);
    190  }
    191  }
    192 
    193 private:
    194  container_type resources;
    195 };
    196 
    197 
    198 }
    199 
    200 
    201 #endif // ENTT_RESOURCE_CACHE_HPP
    entt::ResourceCache::size_type
    typename container_type::size_type size_type
    Unsigned integer type.
    Definition: cache.hpp:34
    -
    entt::ResourceCache::discard
    void discard(const resource_type id) ENTT_NOEXCEPT
    Discards the resource that corresponds to a given identifier.
    Definition: cache.hpp:185
    -
    entt::ResourceCache::contains
    bool contains(const resource_type id) const ENTT_NOEXCEPT
    Checks if a cache contains a given identifier.
    Definition: cache.hpp:173
    -
    entt::ResourceCache::reload
    bool reload(const resource_type id, Args &&... args)
    Reloads a resource or loads it for the first time if not present.
    Definition: cache.hpp:129
    +
    1 #ifndef ENTT_RESOURCE_CACHE_HPP
    2 #define ENTT_RESOURCE_CACHE_HPP
    3 
    4 
    5 #include <memory>
    6 #include <utility>
    7 #include <type_traits>
    8 #include <unordered_map>
    9 #include "../config/config.h"
    10 #include "../core/hashed_string.hpp"
    11 #include "handle.hpp"
    12 #include "loader.hpp"
    13 #include "fwd.hpp"
    14 
    15 
    16 namespace entt {
    17 
    18 
    29 template<typename Resource>
    30 class resource_cache {
    31  using container_type = std::unordered_map<hashed_string::hash_type, std::shared_ptr<Resource>>;
    32 
    33 public:
    35  using size_type = typename container_type::size_type;
    37  using resource_type = typename hashed_string::hash_type;
    38 
    40  resource_cache() = default;
    41 
    43  resource_cache(resource_cache &&) = default;
    44 
    46  resource_cache & operator=(resource_cache &&) = default;
    47 
    52  size_type size() const ENTT_NOEXCEPT {
    53  return resources.size();
    54  }
    55 
    60  bool empty() const ENTT_NOEXCEPT {
    61  return resources.empty();
    62  }
    63 
    70  void clear() ENTT_NOEXCEPT {
    71  resources.clear();
    72  }
    73 
    96  template<typename Loader, typename... Args>
    97  resource_handle<Resource> load(const resource_type id, Args &&... args) {
    98  static_assert(std::is_base_of_v<resource_loader<Loader, Resource>, Loader>);
    99  resource_handle<Resource> handle{};
    100 
    101  if(auto it = resources.find(id); it == resources.cend()) {
    102  if(auto resource = Loader{}.get(std::forward<Args>(args)...); resource) {
    103  resources[id] = resource;
    104  handle = std::move(resource);
    105  }
    106  } else {
    107  handle = it->second;
    108  }
    109 
    110  return handle;
    111  }
    112 
    136  template<typename Loader, typename... Args>
    137  resource_handle<Resource> reload(const resource_type id, Args &&... args) {
    138  return (discard(id), load<Loader>(id, std::forward<Args>(args)...));
    139  }
    140 
    153  template<typename Loader, typename... Args>
    154  resource_handle<Resource> temp(Args &&... args) const {
    155  return { Loader{}.get(std::forward<Args>(args)...) };
    156  }
    157 
    171  resource_handle<Resource> handle(const resource_type id) const {
    172  auto it = resources.find(id);
    173  return { it == resources.end() ? nullptr : it->second };
    174  }
    175 
    181  bool contains(const resource_type id) const ENTT_NOEXCEPT {
    182  return (resources.find(id) != resources.cend());
    183  }
    184 
    193  void discard(const resource_type id) ENTT_NOEXCEPT {
    194  if(auto it = resources.find(id); it != resources.end()) {
    195  resources.erase(it);
    196  }
    197  }
    198 
    199 private:
    200  container_type resources;
    201 };
    202 
    203 
    204 }
    205 
    206 
    207 #endif // ENTT_RESOURCE_CACHE_HPP
    entt::resource_cache::size
    size_type size() const ENTT_NOEXCEPT
    Number of resources managed by a cache.
    Definition: cache.hpp:52
    +
    entt::resource_cache::resource_type
    typename hashed_string::hash_type resource_type
    Type of resources managed by a cache.
    Definition: cache.hpp:37
    +
    entt::resource_cache
    Simple cache for resources of a given type.
    Definition: cache.hpp:30
    +
    entt::resource_cache::reload
    resource_handle< Resource > reload(const resource_type id, Args &&... args)
    Reloads a resource or loads it for the first time if not present.
    Definition: cache.hpp:137
    +
    entt::resource_cache::temp
    resource_handle< Resource > temp(Args &&... args) const
    Creates a temporary handle for a resource.
    Definition: cache.hpp:154
    +
    entt::resource_loader
    Base class for resource loaders.
    Definition: fwd.hpp:21
    entt
    EnTT default namespace.
    Definition: algorithm.hpp:10
    -
    entt::ResourceCache::temp
    ResourceHandle< Resource > temp(Args &&... args) const
    Creates a temporary handle for a resource.
    Definition: cache.hpp:146
    -
    entt::ResourceCache::ResourceCache
    ResourceCache()=default
    Default constructor.
    -
    entt::HashedString
    Zero overhead resource identifier.
    Definition: hashed_string.hpp:22
    -
    entt::ResourceCache::size
    size_type size() const ENTT_NOEXCEPT
    Number of resources managed by a cache.
    Definition: cache.hpp:55
    -
    entt::ResourceCache::empty
    bool empty() const ENTT_NOEXCEPT
    Returns true if a cache contains no resources, false otherwise.
    Definition: cache.hpp:63
    -
    entt::ResourceLoader
    Base class for resource loaders.
    Definition: loader.hpp:48
    -
    entt::ResourceHandle
    Shared resource handle.
    Definition: handle.hpp:31
    -
    entt::ResourceCache::load
    bool load(const resource_type id, Args &&... args)
    Loads the resource that corresponds to a given identifier.
    Definition: cache.hpp:96
    -
    entt::ResourceCache::handle
    ResourceHandle< Resource > handle(const resource_type id) const
    Creates a handle for a given resource identifier.
    Definition: cache.hpp:163
    -
    entt::ResourceCache
    Simple cache for resources of a given type.
    Definition: cache.hpp:29
    -
    entt::ResourceCache::clear
    void clear() ENTT_NOEXCEPT
    Clears a cache and discards all its resources.
    Definition: cache.hpp:73
    +
    entt::resource_cache::size_type
    typename container_type::size_type size_type
    Unsigned integer type.
    Definition: cache.hpp:35
    +
    entt::resource_cache::operator=
    resource_cache & operator=(resource_cache &&)=default
    Default move assignment operator.
    +
    entt::resource_cache::discard
    void discard(const resource_type id) ENTT_NOEXCEPT
    Discards the resource that corresponds to a given identifier.
    Definition: cache.hpp:193
    +
    entt::resource_cache::empty
    bool empty() const ENTT_NOEXCEPT
    Returns true if a cache contains no resources, false otherwise.
    Definition: cache.hpp:60
    +
    entt::resource_cache::contains
    bool contains(const resource_type id) const ENTT_NOEXCEPT
    Checks if a cache contains a given identifier.
    Definition: cache.hpp:181
    +
    entt::resource_handle
    Shared resource handle.
    Definition: fwd.hpp:17
    +
    entt::resource_cache::handle
    resource_handle< Resource > handle(const resource_type id) const
    Creates a handle for a given resource identifier.
    Definition: cache.hpp:171
    +
    entt::resource_cache::clear
    void clear() ENTT_NOEXCEPT
    Clears a cache and discards all its resources.
    Definition: cache.hpp:70
    +
    entt::resource_cache::load
    resource_handle< Resource > load(const resource_type id, Args &&... args)
    Loads the resource that corresponds to a given identifier.
    Definition: cache.hpp:97
    +
    entt::hashed_string::hash_type
    ENTT_ID_TYPE hash_type
    Unsigned integer type.
    Definition: hashed_string.hpp:73
    +
    entt::resource_cache::resource_cache
    resource_cache()=default
    Default constructor.
    diff --git a/classentt_1_1Attachee_3_01Entity_00_01Type_01_4-members.html b/classentt_1_1Attachee_3_01Entity_00_01Type_01_4-members.html deleted file mode 100644 index 535a49068..000000000 --- a/classentt_1_1Attachee_3_01Entity_00_01Type_01_4-members.html +++ /dev/null @@ -1,95 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::Attachee< Entity, Type > Member List
    -
    -
    - -

    This is the complete list of members for entt::Attachee< Entity, Type >, including all inherited members.

    - - - - - - - - - - - - - - - -
    Attachee() ENTT_NOEXCEPT=defaultentt::Attachee< Entity, Type >
    Attachee(const Attachee &)=deleteentt::Attachee< Entity, Type >
    Attachee(Attachee &&)=deleteentt::Attachee< Entity, Type >
    construct(entity_type entity, Args &&... args) ENTT_NOEXCEPTentt::Attachee< Entity, Type >inline
    entt::Attachee< Entity >::construct(const entity_type entity) ENTT_NOEXCEPTentt::Attachee< Entity >inline
    destroy() ENTT_NOEXCEPT overrideentt::Attachee< Entity, Type >inlinevirtual
    entity_type typedefentt::Attachee< Entity, Type >
    get() const ENTT_NOEXCEPTentt::Attachee< Entity, Type >inline
    get() ENTT_NOEXCEPTentt::Attachee< Entity, Type >inline
    move(const entity_type entity) ENTT_NOEXCEPTentt::Attachee< Entity, Type >inline
    object_type typedefentt::Attachee< Entity, Type >
    operator=(const Attachee &)=deleteentt::Attachee< Entity, Type >
    operator=(Attachee &&)=deleteentt::Attachee< Entity, Type >
    ~Attachee()entt::Attachee< Entity, Type >inlinevirtual
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1Attachee_3_01Entity_00_01Type_01_4.html b/classentt_1_1Attachee_3_01Entity_00_01Type_01_4.html deleted file mode 100644 index f865cf463..000000000 --- a/classentt_1_1Attachee_3_01Entity_00_01Type_01_4.html +++ /dev/null @@ -1,472 +0,0 @@ - - - - - - - -EnTT: entt::Attachee< Entity, Type > Class Template Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Public Types | -Public Member Functions | -List of all members
    -
    -
    entt::Attachee< Entity, Type > Class Template Reference
    -
    -
    - -

    Extended attachee implementation. - More...

    - -

    #include <attachee.hpp>

    -
    -Inheritance diagram for entt::Attachee< Entity, Type >:
    -
    -
    Inheritance graph
    - - - -
    [legend]
    -
    -Collaboration diagram for entt::Attachee< Entity, Type >:
    -
    -
    Collaboration graph
    - - - -
    [legend]
    - - - - - - - - - - - - -

    -Public Types

    -using object_type = Type
     Type of the object associated to the attachee.
     
    -using entity_type = typename underlying_type::entity_type
     Underlying entity identifier.
     
    - Public Types inherited from entt::Attachee< Entity >
    -using entity_type = Entity
     Underlying entity identifier.
     
    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

    -Public Member Functions

    - Attachee () ENTT_NOEXCEPT=default
     Default constructor.
     
    - Attachee (const Attachee &)=delete
     Copying an attachee isn't allowed.
     
    - Attachee (Attachee &&)=delete
     Moving an attachee isn't allowed.
     
    Attachee & operator= (const Attachee &)=delete
     Copying an attachee isn't allowed. More...
     
    Attachee & operator= (Attachee &&)=delete
     Moving an attachee isn't allowed. More...
     
    - ~Attachee ()
     Default destructor.
     
    const Type & get () const ENTT_NOEXCEPT
     Returns the object associated to an attachee. More...
     
    Type & get () ENTT_NOEXCEPT
     Returns the object associated to an attachee. More...
     
    template<typename... Args>
    Type & construct (entity_type entity, Args &&... args) ENTT_NOEXCEPT
     Assigns an entity to an attachee and constructs its object. More...
     
    void destroy () ENTT_NOEXCEPT override
     Removes an entity from an attachee and destroies its object. More...
     
    void move (const entity_type entity) ENTT_NOEXCEPT
     Changes the owner of an attachee. More...
     
    - Public Member Functions inherited from entt::Attachee< Entity >
    - Attachee () ENTT_NOEXCEPT
     Default constructor.
     
    - Attachee (const Attachee &)=default
     Default copy constructor.
     
    - Attachee (Attachee &&)=default
     Default move constructor.
     
    Attachee & operator= (const Attachee &)=default
     Default copy assignment operator. More...
     
    Attachee & operator= (Attachee &&)=default
     Default move assignment operator. More...
     
    entity_type get () const ENTT_NOEXCEPT
     Returns the owner of an attachee. More...
     
    void construct (const entity_type entity) ENTT_NOEXCEPT
     Assigns an entity to an attachee. More...
     
    -

    Detailed Description

    -

    template<typename Entity, typename Type>
    -class entt::Attachee< Entity, Type >

    - -

    Extended attachee implementation.

    -

    This specialization of an attachee associates an object to an entity. The main purpose of this class is to use attachees to store tags in a Registry. It guarantees fast access both to the element and to the entity.

    -
    See also
    Attachee<Entity>
    -
    Template Parameters
    - - - -
    EntityA valid entity type (see entt_traits for more details).
    TypeType of object assigned to the entity.
    -
    -
    - -

    Definition at line 112 of file attachee.hpp.

    -

    Member Function Documentation

    - -

    ◆ construct()

    - -
    -
    -
    -template<typename Entity , typename Type >
    -
    -template<typename... Args>
    - - - - - -
    - - - - - - - - - - - - - - - - - - -
    Type& entt::Attachee< Entity, Type >::construct (entity_type entity,
    Args &&... args 
    )
    -     		-inline
    -
    - -

    Assigns an entity to an attachee and constructs its object.

    -
    Warning
    Attempting to assigns an entity to an attachee that already has an owner results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode in case the attachee already has an owner.
    -
    Template Parameters
    - - -
    ArgsTypes of arguments to use to construct the object.
    -
    -
    -
    Parameters
    - - - -
    entityA valid entity identifier.
    argsParameters to use to construct an object for the entity.
    -
    -
    -
    Returns
    The object associated to the attachee.
    - -

    Definition at line 185 of file attachee.hpp.

    - -
    -
    - -

    ◆ destroy()

    - -
    -
    -
    -template<typename Entity , typename Type >
    - - - - - -
    - - - - - - - -
    void entt::Attachee< Entity, Type >::destroy ()
    -     		-inlineoverridevirtual
    -
    - -

    Removes an entity from an attachee and destroies its object.

    -
    Warning
    Attempting to free an empty attachee results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode if the attachee is already empty.
    - -

    Reimplemented from entt::Attachee< Entity >.

    - -

    Definition at line 199 of file attachee.hpp.

    - -
    -
    - -

    ◆ get() [1/2]

    - -
    -
    -
    -template<typename Entity , typename Type >
    - - - - - -
    - - - - - - - -
    const Type& entt::Attachee< Entity, Type >::get () const
    -     		-inline
    -
    - -

    Returns the object associated to an attachee.

    -
    Warning
    Attempting to query an empty attachee results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode if the attachee is empty.
    -
    Returns
    The object associated to the attachee.
    - -

    Definition at line 151 of file attachee.hpp.

    - -
    -
    - -

    ◆ get() [2/2]

    - -
    -
    -
    -template<typename Entity , typename Type >
    - - - - - -
    - - - - - - - -
    Type& entt::Attachee< Entity, Type >::get ()
    -     		-inline
    -
    - -

    Returns the object associated to an attachee.

    -
    Warning
    Attempting to query an empty attachee results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode if the attachee is empty.
    -
    Returns
    The object associated to the attachee.
    - -

    Definition at line 166 of file attachee.hpp.

    - -
    -
    - -

    ◆ move()

    - -
    -
    -
    -template<typename Entity , typename Type >
    - - - - - -
    - - - - - - - - -
    void entt::Attachee< Entity, Type >::move (const entity_type entity)
    -     		-inline
    -
    - -

    Changes the owner of an attachee.

    -

    The ownership of the attachee is transferred from one entity to another.

    -
    Warning
    Attempting to transfer the ownership of an attachee that hasn't an owner results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode in case the attachee hasn't an owner yet.
    -
    Parameters
    - - -
    entityA valid entity identifier.
    -
    -
    - -

    Definition at line 217 of file attachee.hpp.

    - -
    -
    - -

    ◆ operator=() [1/2]

    - -
    -
    -
    -template<typename Entity , typename Type >
    - - - - - -
    - - - - - - - - -
    Attachee& entt::Attachee< Entity, Type >::operator= (const Attachee< Entity, Type > & )
    -     		-delete
    -
    - -

    Copying an attachee isn't allowed.

    -
    Returns
    This attachee.
    - -
    -
    - -

    ◆ operator=() [2/2]

    - -
    -
    -
    -template<typename Entity , typename Type >
    - - - - - -
    - - - - - - - - -
    Attachee& entt::Attachee< Entity, Type >::operator= (Attachee< Entity, Type > && )
    -     		-delete
    -
    - -

    Moving an attachee isn't allowed.

    -
    Returns
    This attachee.
    - -
    -
    -
    The documentation for this class was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1Attachee_3_01Entity_00_01Type_01_4__coll__graph.map b/classentt_1_1Attachee_3_01Entity_00_01Type_01_4__coll__graph.map deleted file mode 100644 index d082ee3e2..000000000 --- a/classentt_1_1Attachee_3_01Entity_00_01Type_01_4__coll__graph.map +++ /dev/null @@ -1,3 +0,0 @@ - - - diff --git a/classentt_1_1Attachee_3_01Entity_00_01Type_01_4__coll__graph.md5 b/classentt_1_1Attachee_3_01Entity_00_01Type_01_4__coll__graph.md5 deleted file mode 100644 index 8ad7cbd0c..000000000 --- a/classentt_1_1Attachee_3_01Entity_00_01Type_01_4__coll__graph.md5 +++ /dev/null @@ -1 +0,0 @@ -2fd30cf67acfb8c69efa7822cb51703e \ No newline at end of file diff --git a/classentt_1_1Attachee_3_01Entity_00_01Type_01_4__coll__graph.png b/classentt_1_1Attachee_3_01Entity_00_01Type_01_4__coll__graph.png deleted file mode 100644 index c94746720..000000000 Binary files a/classentt_1_1Attachee_3_01Entity_00_01Type_01_4__coll__graph.png and /dev/null differ diff --git a/classentt_1_1Attachee_3_01Entity_00_01Type_01_4__inherit__graph.map b/classentt_1_1Attachee_3_01Entity_00_01Type_01_4__inherit__graph.map deleted file mode 100644 index d082ee3e2..000000000 --- a/classentt_1_1Attachee_3_01Entity_00_01Type_01_4__inherit__graph.map +++ /dev/null @@ -1,3 +0,0 @@ - - - diff --git a/classentt_1_1Attachee_3_01Entity_00_01Type_01_4__inherit__graph.md5 b/classentt_1_1Attachee_3_01Entity_00_01Type_01_4__inherit__graph.md5 deleted file mode 100644 index 42196e769..000000000 --- a/classentt_1_1Attachee_3_01Entity_00_01Type_01_4__inherit__graph.md5 +++ /dev/null @@ -1 +0,0 @@ -cd0c4f7a89b236495fb5929f2aa13015 \ No newline at end of file diff --git a/classentt_1_1Attachee_3_01Entity_00_01Type_01_4__inherit__graph.png b/classentt_1_1Attachee_3_01Entity_00_01Type_01_4__inherit__graph.png deleted file mode 100644 index c94746720..000000000 Binary files a/classentt_1_1Attachee_3_01Entity_00_01Type_01_4__inherit__graph.png and /dev/null differ diff --git a/classentt_1_1Attachee_3_01Entity_01_4-members.html b/classentt_1_1Attachee_3_01Entity_01_4-members.html deleted file mode 100644 index 519157fd7..000000000 --- a/classentt_1_1Attachee_3_01Entity_01_4-members.html +++ /dev/null @@ -1,91 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::Attachee< Entity > Member List
    -
    -
    - -

    This is the complete list of members for entt::Attachee< Entity >, including all inherited members.

    - - - - - - - - - - - -
    Attachee() ENTT_NOEXCEPTentt::Attachee< Entity >inline
    Attachee(const Attachee &)=defaultentt::Attachee< Entity >
    Attachee(Attachee &&)=defaultentt::Attachee< Entity >
    construct(const entity_type entity) ENTT_NOEXCEPTentt::Attachee< Entity >inline
    destroy() ENTT_NOEXCEPTentt::Attachee< Entity >inlinevirtual
    entity_type typedefentt::Attachee< Entity >
    get() const ENTT_NOEXCEPTentt::Attachee< Entity >inline
    operator=(const Attachee &)=defaultentt::Attachee< Entity >
    operator=(Attachee &&)=defaultentt::Attachee< Entity >
    ~Attachee() ENTT_NOEXCEPT=defaultentt::Attachee< Entity >virtual
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1Attachee_3_01Entity_01_4.html b/classentt_1_1Attachee_3_01Entity_01_4.html deleted file mode 100644 index 741967c57..000000000 --- a/classentt_1_1Attachee_3_01Entity_01_4.html +++ /dev/null @@ -1,324 +0,0 @@ - - - - - - - -EnTT: entt::Attachee< Entity > Class Template Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Public Types | -Public Member Functions | -List of all members
    -
    -
    entt::Attachee< Entity > Class Template Reference
    -
    -
    - -

    Basic attachee implementation. - More...

    - -

    #include <attachee.hpp>

    -
    -Inheritance diagram for entt::Attachee< Entity >:
    -
    -
    Inheritance graph
    - - - -
    [legend]
    - - - - - -

    -Public Types

    -using entity_type = Entity
     Underlying entity identifier.
     
    - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

    -Public Member Functions

    - Attachee () ENTT_NOEXCEPT
     Default constructor.
     
    - Attachee (const Attachee &)=default
     Default copy constructor.
     
    - Attachee (Attachee &&)=default
     Default move constructor.
     
    Attachee & operator= (const Attachee &)=default
     Default copy assignment operator. More...
     
    Attachee & operator= (Attachee &&)=default
     Default move assignment operator. More...
     
    -virtual ~Attachee () ENTT_NOEXCEPT=default
     Default destructor.
     
    entity_type get () const ENTT_NOEXCEPT
     Returns the owner of an attachee. More...
     
    void construct (const entity_type entity) ENTT_NOEXCEPT
     Assigns an entity to an attachee. More...
     
    virtual void destroy () ENTT_NOEXCEPT
     Removes an entity from an attachee. More...
     
    -

    Detailed Description

    -

    template<typename Entity>
    -class entt::Attachee< Entity >

    - -

    Basic attachee implementation.

    -

    Convenience data structure used to store single instance components.

    -
    Template Parameters
    - - -
    EntityA valid entity type (see entt_traits for more details).
    -
    -
    - -

    Definition at line 33 of file attachee.hpp.

    -

    Member Function Documentation

    - -

    ◆ construct()

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - - -
    void entt::Attachee< Entity >::construct (const entity_type entity)
    -     		-inline
    -
    - -

    Assigns an entity to an attachee.

    -
    Warning
    Attempting to assigns an entity to an attachee that already has an owner results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode in case the attachee already has an owner.
    -
    Parameters
    - - -
    entityA valid entity identifier.
    -
    -
    - -

    Definition at line 76 of file attachee.hpp.

    - -
    -
    - -

    ◆ destroy()

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - -
    virtual void entt::Attachee< Entity >::destroy ()
    -     		-inlinevirtual
    -
    - -

    Removes an entity from an attachee.

    -
    Warning
    Attempting to free an empty attachee results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode if the attachee is already empty.
    - -

    Reimplemented in entt::Attachee< Entity, Type >.

    - -

    Definition at line 89 of file attachee.hpp.

    - -
    -
    - -

    ◆ get()

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - -
    entity_type entt::Attachee< Entity >::get () const
    -     		-inline
    -
    - -

    Returns the owner of an attachee.

    -
    Returns
    A valid entity identifier if an owner exists, the null entity identifier otherwise.
    - -

    Definition at line 61 of file attachee.hpp.

    - -
    -
    - -

    ◆ operator=() [1/2]

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - - -
    Attachee& entt::Attachee< Entity >::operator= (const Attachee< Entity > & )
    -     		-default
    -
    - -

    Default copy assignment operator.

    -
    Returns
    This attachee.
    - -
    -
    - -

    ◆ operator=() [2/2]

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - - -
    Attachee& entt::Attachee< Entity >::operator= (Attachee< Entity > && )
    -     		-default
    -
    - -

    Default move assignment operator.

    -
    Returns
    This attachee.
    - -
    -
    -
    The documentation for this class was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1Attachee_3_01Entity_01_4__inherit__graph.map b/classentt_1_1Attachee_3_01Entity_01_4__inherit__graph.map deleted file mode 100644 index ef4fa59fd..000000000 --- a/classentt_1_1Attachee_3_01Entity_01_4__inherit__graph.map +++ /dev/null @@ -1,3 +0,0 @@ - - - diff --git a/classentt_1_1Attachee_3_01Entity_01_4__inherit__graph.md5 b/classentt_1_1Attachee_3_01Entity_01_4__inherit__graph.md5 deleted file mode 100644 index a89cd2b56..000000000 --- a/classentt_1_1Attachee_3_01Entity_01_4__inherit__graph.md5 +++ /dev/null @@ -1 +0,0 @@ -8c21d26f3e6d0119d1531c2ad74b3eaf \ No newline at end of file diff --git a/classentt_1_1Attachee_3_01Entity_01_4__inherit__graph.png b/classentt_1_1Attachee_3_01Entity_01_4__inherit__graph.png deleted file mode 100644 index 67ca68fa0..000000000 Binary files a/classentt_1_1Attachee_3_01Entity_01_4__inherit__graph.png and /dev/null differ diff --git a/classentt_1_1ContinuousLoader-members.html b/classentt_1_1ContinuousLoader-members.html deleted file mode 100644 index 53c15591f..000000000 --- a/classentt_1_1ContinuousLoader-members.html +++ /dev/null @@ -1,95 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::ContinuousLoader< Entity > Member List
    -
    -
    - -

    This is the complete list of members for entt::ContinuousLoader< Entity >, including all inherited members.

    - - - - - - - - - - - - - - - -
    component(Archive &archive, Member Type::*... member)entt::ContinuousLoader< Entity >inline
    ContinuousLoader(Registry< entity_type > &registry) ENTT_NOEXCEPTentt::ContinuousLoader< Entity >inline
    ContinuousLoader(const ContinuousLoader &)=deleteentt::ContinuousLoader< Entity >
    ContinuousLoader(ContinuousLoader &&)=defaultentt::ContinuousLoader< Entity >
    destroyed(Archive &archive)entt::ContinuousLoader< Entity >inline
    entities(Archive &archive)entt::ContinuousLoader< Entity >inline
    entity_type typedefentt::ContinuousLoader< Entity >
    has(entity_type entity) const ENTT_NOEXCEPTentt::ContinuousLoader< Entity >inline
    map(entity_type entity) const ENTT_NOEXCEPTentt::ContinuousLoader< Entity >inline
    operator=(const ContinuousLoader &)=deleteentt::ContinuousLoader< Entity >
    operator=(ContinuousLoader &&)=defaultentt::ContinuousLoader< Entity >
    orphans()entt::ContinuousLoader< Entity >inline
    shrink()entt::ContinuousLoader< Entity >inline
    tag(Archive &archive, Member Type::*... member)entt::ContinuousLoader< Entity >inline
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1ContinuousLoader.html b/classentt_1_1ContinuousLoader.html deleted file mode 100644 index da9dc4cbc..000000000 --- a/classentt_1_1ContinuousLoader.html +++ /dev/null @@ -1,633 +0,0 @@ - - - - - - - -EnTT: entt::ContinuousLoader< Entity > Class Template Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Public Types | -Public Member Functions | -List of all members
    -
    -
    entt::ContinuousLoader< Entity > Class Template Referencefinal
    -
    -
    - -

    Utility class for continuous loading. - More...

    - -

    #include <snapshot.hpp>

    - - - - - -

    -Public Types

    -using entity_type = Entity
     Underlying entity identifier.
     
    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

    -Public Member Functions

     ContinuousLoader (Registry< entity_type > &registry) ENTT_NOEXCEPT
     Constructs a loader that is bound to a given registry. More...
     
    - ContinuousLoader (const ContinuousLoader &)=delete
     Copying a snapshot loader isn't allowed.
     
    - ContinuousLoader (ContinuousLoader &&)=default
     Default move constructor.
     
    ContinuousLoader & operator= (const ContinuousLoader &)=delete
     Copying a snapshot loader isn't allowed. More...
     
    ContinuousLoader & operator= (ContinuousLoader &&)=default
     Default move assignment operator. More...
     
    template<typename Archive >
    ContinuousLoader & entities (Archive &archive)
     Restores entities that were in use during serialization. More...
     
    template<typename Archive >
    ContinuousLoader & destroyed (Archive &archive)
     Restores entities that were destroyed during serialization. More...
     
    template<typename... Component, typename Archive , typename... Type, typename... Member>
    ContinuousLoader & component (Archive &archive, Member Type::*... member)
     Restores components and assigns them to the right entities. More...
     
    template<typename... Tag, typename Archive , typename... Type, typename... Member>
    ContinuousLoader & tag (Archive &archive, Member Type::*... member)
     Restores tags and assigns them to the right entities. More...
     
    ContinuousLoader & shrink ()
     Helps to purge entities that no longer have a conterpart. More...
     
    ContinuousLoader & orphans ()
     Destroys those entities that have neither components nor tags. More...
     
    bool has (entity_type entity) const ENTT_NOEXCEPT
     Tests if a loader knows about a given entity. More...
     
    entity_type map (entity_type entity) const ENTT_NOEXCEPT
     Returns the identifier to which an entity refers. More...
     
    -

    Detailed Description

    -

    template<typename Entity>
    -class entt::ContinuousLoader< Entity >

    - -

    Utility class for continuous loading.

    -

    A continuous loader is designed to load data from a source registry to a (possibly) non-empty destination. The loader can accomodate in a registry more than one snapshot in a sort of continuous loading that updates the destination one step at a time.
    - Identifiers that entities originally had are not transferred to the target. Instead, the loader maps remote identifiers to local ones while restoring a snapshot.
    - An example of use is the implementation of a client-server applications with the requirement of transferring somehow parts of the representation side to side.

    -
    Template Parameters
    - - -
    EntityA valid entity type (see entt_traits for more details).
    -
    -
    - -

    Definition at line 434 of file snapshot.hpp.

    -

    Constructor & Destructor Documentation

    - -

    ◆ ContinuousLoader()

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - - -
    entt::ContinuousLoader< Entity >::ContinuousLoader (Registry< entity_type > & registry)
    -     		-inline
    -
    - -

    Constructs a loader that is bound to a given registry.

    -
    Parameters
    - - -
    registryA valid reference to a registry.
    -
    -
    - -

    Definition at line 533 of file snapshot.hpp.

    - -
    -
    -

    Member Function Documentation

    - -

    ◆ component()

    - -
    -
    -
    -template<typename Entity >
    -
    -template<typename... Component, typename Archive , typename... Type, typename... Member>
    - - - - - -
    - - - - - - - - - - - - - - - - - - -
    ContinuousLoader& entt::ContinuousLoader< Entity >::component (Archive & archive,
    Member Type::*... member 
    )
    -     		-inline
    -
    - -

    Restores components and assigns them to the right entities.

    -

    The template parameter list must be exactly the same used during serialization. In the event that the entity to which the component is assigned doesn't exist yet, the loader will take care to create a local counterpart for it.
    - Members can be either data members of type entity_type or containers of entities. In both cases, the loader will visit them and update the entities by replacing each one with its local counterpart.

    -
    Template Parameters
    - - - - - -
    ComponentType of component to restore.
    ArchiveType of input archive.
    TypeTypes of components to update with local counterparts.
    MemberTypes of members to update with their local counterparts.
    -
    -
    -
    Parameters
    - - - -
    archiveA valid reference to an input archive.
    memberMembers to update with their local counterparts.
    -
    -
    -
    Returns
    A non-const reference to this loader.
    - -

    Definition at line 599 of file snapshot.hpp.

    - -
    -
    - -

    ◆ destroyed()

    - -
    -
    -
    -template<typename Entity >
    -
    -template<typename Archive >
    - - - - - -
    - - - - - - - - -
    ContinuousLoader& entt::ContinuousLoader< Entity >::destroyed (Archive & archive)
    -     		-inline
    -
    - -

    Restores entities that were destroyed during serialization.

    -

    This function restores the entities that were destroyed during serialization and creates local counterparts for them if required.

    -
    Template Parameters
    - - -
    ArchiveType of input archive.
    -
    -
    -
    Parameters
    - - -
    archiveA valid reference to an input archive.
    -
    -
    -
    Returns
    A non-const reference to this loader.
    - -

    Definition at line 574 of file snapshot.hpp.

    - -
    -
    - -

    ◆ entities()

    - -
    -
    -
    -template<typename Entity >
    -
    -template<typename Archive >
    - - - - - -
    - - - - - - - - -
    ContinuousLoader& entt::ContinuousLoader< Entity >::entities (Archive & archive)
    -     		-inline
    -
    - -

    Restores entities that were in use during serialization.

    -

    This function restores the entities that were in use during serialization and creates local counterparts for them if required.

    -
    Template Parameters
    - - -
    ArchiveType of input archive.
    -
    -
    -
    Parameters
    - - -
    archiveA valid reference to an input archive.
    -
    -
    -
    Returns
    A non-const reference to this loader.
    - -

    Definition at line 558 of file snapshot.hpp.

    - -
    -
    - -

    ◆ has()

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - - -
    bool entt::ContinuousLoader< Entity >::has (entity_type entity) const
    -     		-inline
    -
    - -

    Tests if a loader knows about a given entity.

    -
    Parameters
    - - -
    entityAn entity identifier.
    -
    -
    -
    Returns
    True if entity is managed by the loader, false otherwise.
    - -

    Definition at line 694 of file snapshot.hpp.

    - -
    -
    - -

    ◆ map()

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - - -
    entity_type entt::ContinuousLoader< Entity >::map (entity_type entity) const
    -     		-inline
    -
    - -

    Returns the identifier to which an entity refers.

    -
    Warning
    Attempting to use an entity that isn't managed by the loader results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode if the loader doesn't knows about the entity.
    -
    Parameters
    - - -
    entityAn entity identifier.
    -
    -
    -
    Returns
    The identifier to which entity refers in the target registry.
    - -

    Definition at line 710 of file snapshot.hpp.

    - -
    -
    - -

    ◆ operator=() [1/2]

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - - -
    ContinuousLoader& entt::ContinuousLoader< Entity >::operator= (const ContinuousLoader< Entity > & )
    -     		-delete
    -
    - -

    Copying a snapshot loader isn't allowed.

    -
    Returns
    This loader.
    - -
    -
    - -

    ◆ operator=() [2/2]

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - - -
    ContinuousLoader& entt::ContinuousLoader< Entity >::operator= (ContinuousLoader< Entity > && )
    -     		-default
    -
    - -

    Default move assignment operator.

    -
    Returns
    This loader.
    - -
    -
    - -

    ◆ orphans()

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - -
    ContinuousLoader& entt::ContinuousLoader< Entity >::orphans ()
    -     		-inline
    -
    - -

    Destroys those entities that have neither components nor tags.

    -

    In case all the entities were serialized but only part of the components and tags was saved, it could happen that some of the entities have neither components nor tags once restored.
    - This functions helps to identify and destroy those entities.

    -
    Returns
    A non-const reference to this loader.
    - -

    Definition at line 681 of file snapshot.hpp.

    - -
    -
    - -

    ◆ shrink()

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - -
    ContinuousLoader& entt::ContinuousLoader< Entity >::shrink ()
    -     		-inline
    -
    - -

    Helps to purge entities that no longer have a conterpart.

    -

    Users should invoke this member function after restoring each snapshot, unless they know exactly what they are doing.

    -
    Returns
    A non-const reference to this loader.
    - -

    Definition at line 649 of file snapshot.hpp.

    - -
    -
    - -

    ◆ tag()

    - -
    -
    -
    -template<typename Entity >
    -
    -template<typename... Tag, typename Archive , typename... Type, typename... Member>
    - - - - - -
    - - - - - - - - - - - - - - - - - - -
    ContinuousLoader& entt::ContinuousLoader< Entity >::tag (Archive & archive,
    Member Type::*... member 
    )
    -     		-inline
    -
    - -

    Restores tags and assigns them to the right entities.

    -

    The template parameter list must be exactly the same used during serialization. In the event that the entity to which the tag is assigned doesn't exist yet, the loader will take care to create a local counterpart for it.
    - Members can be either data members of type entity_type or containers of entities. In both cases, the loader will visit them and update the entities by replacing each one with its local counterpart.

    -
    Template Parameters
    - - - - - -
    TagType of tag to restore.
    ArchiveType of input archive.
    TypeTypes of components to update with local counterparts.
    MemberTypes of members to update with their local counterparts.
    -
    -
    -
    Parameters
    - - - -
    archiveA valid reference to an input archive.
    memberMembers to update with their local counterparts.
    -
    -
    -
    Returns
    A non-const reference to this loader.
    - -

    Definition at line 630 of file snapshot.hpp.

    - -
    -
    -
    The documentation for this class was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4-members.html b/classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4-members.html deleted file mode 100644 index 82ab9e5d2..000000000 --- a/classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4-members.html +++ /dev/null @@ -1,89 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::Delegate< Ret(Args...)> Member List
    -
    -
    - -

    This is the complete list of members for entt::Delegate< Ret(Args...)>, including all inherited members.

    - - - - - - - - - -
    connect() ENTT_NOEXCEPTentt::Delegate< Ret(Args...)>inline
    connect(Class *instance) ENTT_NOEXCEPTentt::Delegate< Ret(Args...)>inline
    connect(Class *instance) ENTT_NOEXCEPTentt::Delegate< Ret(Args...)>inline
    Delegate() ENTT_NOEXCEPTentt::Delegate< Ret(Args...)>inline
    empty() const ENTT_NOEXCEPTentt::Delegate< Ret(Args...)>inline
    operator()(Args... args) constentt::Delegate< Ret(Args...)>inline
    operator==(const Delegate< Ret(Args...)> &other) const ENTT_NOEXCEPTentt::Delegate< Ret(Args...)>inline
    reset() ENTT_NOEXCEPTentt::Delegate< Ret(Args...)>inline
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html b/classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html deleted file mode 100644 index 6329d37c6..000000000 --- a/classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html +++ /dev/null @@ -1,416 +0,0 @@ - - - - - - - -EnTT: entt::Delegate< Ret(Args...)> Class Template Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Public Member Functions | -List of all members
    -
    -
    entt::Delegate< Ret(Args...)> Class Template Referencefinal
    -
    -
    - -

    Utility class to send around functions and member functions. - More...

    - -

    #include <delegate.hpp>

    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

    -Public Member Functions

    - Delegate () ENTT_NOEXCEPT
     Default constructor.
     
    bool empty () const ENTT_NOEXCEPT
     Checks whether a delegate actually stores a listener. More...
     
    template<Ret(*)(Args...) Function>
    void connect () ENTT_NOEXCEPT
     Binds a free function to a delegate. More...
     
    template<typename Class , Ret(Class::*)(Args...) const Member>
    void connect (Class *instance) ENTT_NOEXCEPT
     Connects a member function for a given instance to a delegate. More...
     
    template<typename Class , Ret(Class::*)(Args...) Member>
    void connect (Class *instance) ENTT_NOEXCEPT
     Connects a member function for a given instance to a delegate. More...
     
    void reset () ENTT_NOEXCEPT
     Resets a delegate. More...
     
    Ret operator() (Args... args) const
     Triggers a delegate. More...
     
    bool operator== (const Delegate< Ret(Args...)> &other) const ENTT_NOEXCEPT
     Checks if the contents of the two delegates are different. More...
     
    -

    Detailed Description

    -

    template<typename Ret, typename... Args>
    -class entt::Delegate< Ret(Args...)>

    - -

    Utility class to send around functions and member functions.

    -

    Unmanaged delegate for function pointers and member functions. Users of this class are in charge of disconnecting instances before deleting them.

    -

    A delegate can be used as general purpose invoker with no memory overhead for free functions and member functions provided along with an instance on which to invoke them.

    -
    Template Parameters
    - - - -
    RetReturn type of a function type.
    ArgsTypes of arguments of a function type.
    -
    -
    - -

    Definition at line 36 of file delegate.hpp.

    -

    Member Function Documentation

    - -

    ◆ connect() [1/3]

    - -
    -
    -
    -template<typename Ret , typename... Args>
    -
    -template<Ret(*)(Args...) Function>
    - - - - - -
    - - - - - - - -
    void entt::Delegate< Ret(Args...)>::connect ()
    -     		-inline
    -
    - -

    Binds a free function to a delegate.

    -
    Template Parameters
    - - -
    FunctionA valid free function pointer.
    -
    -
    - -

    Definition at line 75 of file delegate.hpp.

    - -
    -
    - -

    ◆ connect() [2/3]

    - -
    -
    -
    -template<typename Ret , typename... Args>
    -
    -template<typename Class , Ret(Class::*)(Args...) const Member>
    - - - - - -
    - - - - - - - - -
    void entt::Delegate< Ret(Args...)>::connect (Class * instance)
    -     		-inline
    -
    - -

    Connects a member function for a given instance to a delegate.

    -

    The delegate isn't responsible for the connected object. Users must guarantee that the lifetime of the instance overcomes the one of the delegate.

    -
    Template Parameters
    - - - -
    ClassType of class to which the member function belongs.
    MemberMember function to connect to the delegate.
    -
    -
    -
    Parameters
    - - -
    instanceA valid instance of type pointer to Class.
    -
    -
    - -

    Definition at line 91 of file delegate.hpp.

    - -
    -
    - -

    ◆ connect() [3/3]

    - -
    -
    -
    -template<typename Ret , typename... Args>
    -
    -template<typename Class , Ret(Class::*)(Args...) Member>
    - - - - - -
    - - - - - - - - -
    void entt::Delegate< Ret(Args...)>::connect (Class * instance)
    -     		-inline
    -
    - -

    Connects a member function for a given instance to a delegate.

    -

    The delegate isn't responsible for the connected object. Users must guarantee that the lifetime of the instance overcomes the one of the delegate.

    -
    Template Parameters
    - - - -
    ClassType of class to which the member function belongs.
    MemberMember function to connect to the delegate.
    -
    -
    -
    Parameters
    - - -
    instanceA valid instance of type pointer to Class.
    -
    -
    - -

    Definition at line 107 of file delegate.hpp.

    - -
    -
    - -

    ◆ empty()

    - -
    -
    -
    -template<typename Ret , typename... Args>
    - - - - - -
    - - - - - - - -
    bool entt::Delegate< Ret(Args...)>::empty () const
    -     		-inline
    -
    - -

    Checks whether a delegate actually stores a listener.

    -
    Returns
    True if the delegate is empty, false otherwise.
    - -

    Definition at line 65 of file delegate.hpp.

    - -
    -
    - -

    ◆ operator()()

    - -
    -
    -
    -template<typename Ret , typename... Args>
    - - - - - -
    - - - - - - - - -
    Ret entt::Delegate< Ret(Args...)>::operator() (Args... args) const
    -     		-inline
    -
    - -

    Triggers a delegate.

    -
    Parameters
    - - -
    argsArguments to use to invoke the underlying function.
    -
    -
    -
    Returns
    The value returned by the underlying function.
    - -

    Definition at line 125 of file delegate.hpp.

    - -
    -
    - -

    ◆ operator==()

    - -
    -
    -
    -template<typename Ret , typename... Args>
    - - - - - -
    - - - - - - - - -
    bool entt::Delegate< Ret(Args...)>::operator== (const Delegate< Ret(Args...)> & other) const
    -     		-inline
    -
    - -

    Checks if the contents of the two delegates are different.

    -

    Two delegates are identical if they contain the same listener.

    -
    Parameters
    - - -
    otherDelegate with which to compare.
    -
    -
    -
    Returns
    True if the two delegates are identical, false otherwise.
    - -

    Definition at line 137 of file delegate.hpp.

    - -
    -
    - -

    ◆ reset()

    - -
    -
    -
    -template<typename Ret , typename... Args>
    - - - - - -
    - - - - - - - -
    void entt::Delegate< Ret(Args...)>::reset ()
    -     		-inline
    -
    - -

    Resets a delegate.

    -

    After a reset, a delegate can be safely invoked with no effect.

    - -

    Definition at line 116 of file delegate.hpp.

    - -
    -
    -
    The documentation for this class was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1HashedString.html b/classentt_1_1HashedString.html deleted file mode 100644 index 38e9c2940..000000000 --- a/classentt_1_1HashedString.html +++ /dev/null @@ -1,304 +0,0 @@ - - - - - - - -EnTT: entt::HashedString Class Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Classes | -Public Types | -Public Member Functions | -List of all members
    -
    -
    entt::HashedString Class Referencefinal
    -
    -
    - -

    Zero overhead resource identifier. - More...

    - -

    #include <hashed_string.hpp>

    - - - - - -

    -Public Types

    -using hash_type = std::uint64_t
     Unsigned integer type.
     
    - - - - - - - - - - - - - - - - - -

    -Public Member Functions

    template<std::size_t N>
    constexpr HashedString (const char(&str)[N]) ENTT_NOEXCEPT
     Constructs a hashed string from an array of const chars. More...
     
    constexpr HashedString (ConstCharWrapper wrapper) ENTT_NOEXCEPT
     Explicit constructor on purpose to avoid constructing a hashed string directly from a const char *. More...
     
    constexpr operator const char * () const ENTT_NOEXCEPT
     Returns the human-readable representation of a hashed string. More...
     
    constexpr operator hash_type () const ENTT_NOEXCEPT
     Returns the numeric representation of a hashed string. More...
     
    constexpr bool operator== (const HashedString &other) const ENTT_NOEXCEPT
     Compares two hashed strings. More...
     
    -

    Detailed Description

    -

    Zero overhead resource identifier.

    -

    A hashed string is a compile-time tool that allows users to use human-readable identifers in the codebase while using their numeric counterparts at runtime.
    - Because of that, a hashed string can also be used in constant expressions if required.

    - -

    Definition at line 22 of file hashed_string.hpp.

    -

    Constructor & Destructor Documentation

    - -

    ◆ HashedString() [1/2]

    - -
    -
    -
    -template<std::size_t N>
    - - - - - -
    - - - - - - - - -
    constexpr entt::HashedString::HashedString (const char(&) str[N])
    -     		-inline
    -
    - -

    Constructs a hashed string from an array of const chars.

    -

    Forcing template resolution avoids implicit conversions. An human-readable identifier can be anything but a plain, old bunch of characters.
    - Example of use:

    HashedString sh{"my.png"};
    Template Parameters
    - - -
    NNumber of characters of the identifier.
    -
    -
    -
    Parameters
    - - -
    strHuman-readable identifer.
    -
    -
    - -

    Definition at line 56 of file hashed_string.hpp.

    - -
    -
    - -

    ◆ HashedString() [2/2]

    - -
    -
    - - - - - -
    - - - - - - - - -
    constexpr entt::HashedString::HashedString (ConstCharWrapper wrapper)
    -     		-inlineexplicit
    -
    - -

    Explicit constructor on purpose to avoid constructing a hashed string directly from a const char *.

    -
    Parameters
    - - -
    wrapperHelps achieving the purpose by relying on overloading.
    -
    -
    - -

    Definition at line 66 of file hashed_string.hpp.

    - -
    -
    -

    Member Function Documentation

    - -

    ◆ operator const char *()

    - -
    -
    - - - - - -
    - - - - - - - -
    constexpr entt::HashedString::operator const char * () const
    -     		-inline
    -
    - -

    Returns the human-readable representation of a hashed string.

    -
    Returns
    The string used to initialize the instance.
    - -

    Definition at line 74 of file hashed_string.hpp.

    - -
    -
    - -

    ◆ operator hash_type()

    - -
    -
    - - - - - -
    - - - - - - - -
    constexpr entt::HashedString::operator hash_type () const
    -     		-inline
    -
    - -

    Returns the numeric representation of a hashed string.

    -
    Returns
    The numeric representation of the instance.
    - -

    Definition at line 80 of file hashed_string.hpp.

    - -
    -
    - -

    ◆ operator==()

    - -
    -
    - - - - - -
    - - - - - - - - -
    constexpr bool entt::HashedString::operator== (const HashedString & other) const
    -     		-inline
    -
    - -

    Compares two hashed strings.

    -
    Parameters
    - - -
    otherHashed string with which to compare.
    -
    -
    -
    Returns
    True if the two hashed strings are identical, false otherwise.
    - -

    Definition at line 87 of file hashed_string.hpp.

    - -
    -
    -
    The documentation for this class was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1Identifier.html b/classentt_1_1Identifier.html deleted file mode 100644 index 735dce5e1..000000000 --- a/classentt_1_1Identifier.html +++ /dev/null @@ -1,161 +0,0 @@ - - - - - - - -EnTT: entt::Identifier< Types > Class Template Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Public Types | -Static Public Member Functions | -List of all members
    -
    -
    entt::Identifier< Types > Class Template Referencefinal
    -
    -
    - -

    Types identifiers. - More...

    - -

    #include <ident.hpp>

    - - - - - -

    -Public Types

    -using identifier_type = std::size_t
     Unsigned integer type.
     
    - - - - - -

    -Static Public Member Functions

    template<typename Type >
    static constexpr identifier_type get () ENTT_NOEXCEPT
     Returns the identifier associated with a given type. More...
     
    -

    Detailed Description

    -

    template<typename... Types>
    -class entt::Identifier< Types >

    - -

    Types identifiers.

    -

    TURN_OFF_DOXYGEN Variable template used to generate identifiers at compile-time for the given types. Use the get member function to know what's the identifier associated to the specific type.

    -
    Note
    Identifiers are constant expression and can be used in any context where such an expression is required. As an example:
    using ID = entt::Identifier<AType, AnotherType>;
    switch(aTypeIdentifier) {
    case ID::get<AType>():
    // ...
    break;
    case ID::get<AnotherType>():
    // ...
    break;
    default:
    // ...
    }
    -
    Template Parameters
    - - -
    TypesList of types for which to generate identifiers.
    -
    -
    - -

    Definition at line 71 of file ident.hpp.

    -

    Member Function Documentation

    - -

    ◆ get()

    - -
    -
    -
    -template<typename... Types>
    -
    -template<typename Type >
    - - - - - -
    - - - - - - - -
    static constexpr identifier_type entt::Identifier< Types >::get ()
    -     		-inlinestatic
    -
    - -

    Returns the identifier associated with a given type.

    -
    Template Parameters
    - - -
    Typeof which to return the identifier.
    -
    -
    -
    Returns
    The identifier associated with the given type.
    - -

    Definition at line 95 of file ident.hpp.

    - -
    -
    -
    The documentation for this class was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1Meta-members.html b/classentt_1_1Meta-members.html deleted file mode 100644 index 5e7d10a38..000000000 --- a/classentt_1_1Meta-members.html +++ /dev/null @@ -1,85 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::Meta Member List
    -
    -
    - -

    This is the complete list of members for entt::Meta, including all inherited members.

    - - - - - -
    factory_type typedef (defined in entt::Meta)entt::Meta
    reflect(const char *str, Property &&... property) ENTT_NOEXCEPT (defined in entt::Meta)entt::Metainlinestatic
    resolve() ENTT_NOEXCEPT (defined in entt::Meta)entt::Metainlinestatic
    resolve(const char *str) ENTT_NOEXCEPT (defined in entt::Meta)entt::Metainlinestatic
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1Meta.html b/classentt_1_1Meta.html deleted file mode 100644 index 144303d8e..000000000 --- a/classentt_1_1Meta.html +++ /dev/null @@ -1,111 +0,0 @@ - - - - - - - -EnTT: entt::Meta Class Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Classes | -Public Types | -Static Public Member Functions | -List of all members
    -
    -
    entt::Meta Class Referencefinal
    -
    -
    - - - - - -

    -Public Types

    -template<typename Type >
    using factory_type = MetaFactory< Type >
     
    - - - - - - - - - -

    -Static Public Member Functions

    -template<typename Type , typename... Property>
    static factory_type< std::decay_t< Type > > reflect (const char *str, Property &&... property) ENTT_NOEXCEPT
     
    -template<typename Type >
    static MetaType * resolve () ENTT_NOEXCEPT
     
    -static MetaType * resolve (const char *str) ENTT_NOEXCEPT
     
    -

    Detailed Description

    -
    -

    Definition at line 24 of file factory.hpp.

    -
    The documentation for this class was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1MetaCtor-members.html b/classentt_1_1MetaCtor-members.html deleted file mode 100644 index dd2e4c2d0..000000000 --- a/classentt_1_1MetaCtor-members.html +++ /dev/null @@ -1,89 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::MetaCtor Member List
    -
    -
    - -

    This is the complete list of members for entt::MetaCtor, including all inherited members.

    - - - - - - - - - -
    accept() const ENTT_NOEXCEPT (defined in entt::MetaCtor)entt::MetaCtorinline
    arg(size_type index) const ENTT_NOEXCEPT (defined in entt::MetaCtor)entt::MetaCtorinline
    invoke(Args &&... args) (defined in entt::MetaCtor)entt::MetaCtorinline
    Meta (defined in entt::MetaCtor)entt::MetaCtorfriend
    properties(Op op) const ENTT_NOEXCEPT (defined in entt::MetaCtor)entt::MetaCtorinline
    property(Key &&key) const ENTT_NOEXCEPT (defined in entt::MetaCtor)entt::MetaCtorinline
    size() const ENTT_NOEXCEPT (defined in entt::MetaCtor)entt::MetaCtorinline
    size_type typedef (defined in entt::MetaCtor)entt::MetaCtor
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1MetaCtor.html b/classentt_1_1MetaCtor.html deleted file mode 100644 index edeee1d0a..000000000 --- a/classentt_1_1MetaCtor.html +++ /dev/null @@ -1,127 +0,0 @@ - - - - - - - -EnTT: entt::MetaCtor Class Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Public Types | -Public Member Functions | -Friends | -List of all members
    -
    -
    entt::MetaCtor Class Reference
    -
    -
    - - - - -

    -Public Types

    -using size_type = typename internal::MetaCtorNode::size_type
     
    - - - - - - - - - - - - - - - - - -

    -Public Member Functions

    -size_type size () const ENTT_NOEXCEPT
     
    -MetaType * arg (size_type index) const ENTT_NOEXCEPT
     
    -template<typename... Args>
    bool accept () const ENTT_NOEXCEPT
     
    -template<typename... Args>
    MetaAny invoke (Args &&... args)
     
    -template<typename Op >
    void properties (Op op) const ENTT_NOEXCEPT
     
    -template<typename Key >
    MetaProp * property (Key &&key) const ENTT_NOEXCEPT
     
    - - - -

    -Friends

    -class Meta
     
    -

    Detailed Description

    -
    -

    Definition at line 361 of file meta.hpp.

    -
    The documentation for this class was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1MetaData-members.html b/classentt_1_1MetaData-members.html deleted file mode 100644 index ee3d7824b..000000000 --- a/classentt_1_1MetaData-members.html +++ /dev/null @@ -1,91 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::MetaData Member List
    -
    -
    - -

    This is the complete list of members for entt::MetaData, including all inherited members.

    - - - - - - - - - - - -
    accept() const ENTT_NOEXCEPT (defined in entt::MetaData)entt::MetaDatainline
    get(const void *instance) const ENTT_NOEXCEPT (defined in entt::MetaData)entt::MetaDatainline
    Meta (defined in entt::MetaData)entt::MetaDatafriend
    name() const ENTT_NOEXCEPT (defined in entt::MetaData)entt::MetaDatainline
    properties(Op op) const ENTT_NOEXCEPT (defined in entt::MetaData)entt::MetaDatainline
    property(Key &&key) const ENTT_NOEXCEPT (defined in entt::MetaData)entt::MetaDatainline
    readonly() const ENTT_NOEXCEPT (defined in entt::MetaData)entt::MetaDatainline
    set(void *instance, Type &&value) (defined in entt::MetaData)entt::MetaDatainline
    shared() const ENTT_NOEXCEPT (defined in entt::MetaData)entt::MetaDatainline
    type() const ENTT_NOEXCEPT (defined in entt::MetaData)entt::MetaDatainline
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1MetaData.html b/classentt_1_1MetaData.html deleted file mode 100644 index a20183584..000000000 --- a/classentt_1_1MetaData.html +++ /dev/null @@ -1,129 +0,0 @@ - - - - - - - -EnTT: entt::MetaData Class Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Public Member Functions | -Friends | -List of all members
    -
    -
    entt::MetaData Class Reference
    -
    -
    - - - - - - - - - - - - - - - - - - - - - - - - -

    -Public Member Functions

    -const char * name () const ENTT_NOEXCEPT
     
    -bool readonly () const ENTT_NOEXCEPT
     
    -bool shared () const ENTT_NOEXCEPT
     
    -MetaType * type () const ENTT_NOEXCEPT
     
    -template<typename Type >
    bool accept () const ENTT_NOEXCEPT
     
    -template<typename Type >
    void set (void *instance, Type &&value)
     
    -MetaAny get (const void *instance) const ENTT_NOEXCEPT
     
    -template<typename Op >
    void properties (Op op) const ENTT_NOEXCEPT
     
    -template<typename Key >
    MetaProp * property (Key &&key) const ENTT_NOEXCEPT
     
    - - - -

    -Friends

    -class Meta
     
    -

    Detailed Description

    -
    -

    Definition at line 433 of file meta.hpp.

    -
    The documentation for this class was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1MetaDtor-members.html b/classentt_1_1MetaDtor-members.html deleted file mode 100644 index 9cb2313bc..000000000 --- a/classentt_1_1MetaDtor-members.html +++ /dev/null @@ -1,85 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::MetaDtor Member List
    -
    -
    - -

    This is the complete list of members for entt::MetaDtor, including all inherited members.

    - - - - - -
    invoke(void *instance) (defined in entt::MetaDtor)entt::MetaDtorinline
    Meta (defined in entt::MetaDtor)entt::MetaDtorfriend
    properties(Op op) const ENTT_NOEXCEPT (defined in entt::MetaDtor)entt::MetaDtorinline
    property(Key &&key) const ENTT_NOEXCEPT (defined in entt::MetaDtor)entt::MetaDtorinline
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1MetaDtor.html b/classentt_1_1MetaDtor.html deleted file mode 100644 index fae2dba57..000000000 --- a/classentt_1_1MetaDtor.html +++ /dev/null @@ -1,109 +0,0 @@ - - - - - - - -EnTT: entt::MetaDtor Class Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Public Member Functions | -Friends | -List of all members
    -
    -
    entt::MetaDtor Class Reference
    -
    -
    - - - - - - - - - - -

    -Public Member Functions

    -void invoke (void *instance)
     
    -template<typename Op >
    void properties (Op op) const ENTT_NOEXCEPT
     
    -template<typename Key >
    MetaProp * property (Key &&key) const ENTT_NOEXCEPT
     
    - - - -

    -Friends

    -class Meta
     
    -

    Detailed Description

    -
    -

    Definition at line 406 of file meta.hpp.

    -
    The documentation for this class was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1MetaFunc-members.html b/classentt_1_1MetaFunc-members.html deleted file mode 100644 index bf8de980d..000000000 --- a/classentt_1_1MetaFunc-members.html +++ /dev/null @@ -1,94 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::MetaFunc Member List
    -
    -
    - -

    This is the complete list of members for entt::MetaFunc, including all inherited members.

    - - - - - - - - - - - - - - -
    accept() const ENTT_NOEXCEPT (defined in entt::MetaFunc)entt::MetaFuncinline
    arg(size_type index) const ENTT_NOEXCEPT (defined in entt::MetaFunc)entt::MetaFuncinline
    constant() const ENTT_NOEXCEPT (defined in entt::MetaFunc)entt::MetaFuncinline
    invoke(const void *instance, Args &&... args) const (defined in entt::MetaFunc)entt::MetaFuncinline
    invoke(void *instance, Args &&... args) (defined in entt::MetaFunc)entt::MetaFuncinline
    Meta (defined in entt::MetaFunc)entt::MetaFuncfriend
    name() const ENTT_NOEXCEPT (defined in entt::MetaFunc)entt::MetaFuncinline
    properties(Op op) const ENTT_NOEXCEPT (defined in entt::MetaFunc)entt::MetaFuncinline
    property(Key &&key) const ENTT_NOEXCEPT (defined in entt::MetaFunc)entt::MetaFuncinline
    ret() const ENTT_NOEXCEPT (defined in entt::MetaFunc)entt::MetaFuncinline
    shared() const ENTT_NOEXCEPT (defined in entt::MetaFunc)entt::MetaFuncinline
    size() const ENTT_NOEXCEPT (defined in entt::MetaFunc)entt::MetaFuncinline
    size_type typedef (defined in entt::MetaFunc)entt::MetaFunc
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1MetaFunc.html b/classentt_1_1MetaFunc.html deleted file mode 100644 index a3faa535e..000000000 --- a/classentt_1_1MetaFunc.html +++ /dev/null @@ -1,143 +0,0 @@ - - - - - - - -EnTT: entt::MetaFunc Class Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Public Types | -Public Member Functions | -Friends | -List of all members
    -
    -
    entt::MetaFunc Class Reference
    -
    -
    - - - - -

    -Public Types

    -using size_type = typename internal::MetaCtorNode::size_type
     
    - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

    -Public Member Functions

    -const char * name () const ENTT_NOEXCEPT
     
    -size_type size () const ENTT_NOEXCEPT
     
    -bool constant () const ENTT_NOEXCEPT
     
    -bool shared () const ENTT_NOEXCEPT
     
    -MetaType * ret () const ENTT_NOEXCEPT
     
    -MetaType * arg (size_type index) const ENTT_NOEXCEPT
     
    -template<typename... Args>
    bool accept () const ENTT_NOEXCEPT
     
    -template<typename... Args>
    MetaAny invoke (const void *instance, Args &&... args) const
     
    -template<typename... Args>
    MetaAny invoke (void *instance, Args &&... args)
     
    -template<typename Op >
    void properties (Op op) const ENTT_NOEXCEPT
     
    -template<typename Key >
    MetaProp * property (Key &&key) const ENTT_NOEXCEPT
     
    - - - -

    -Friends

    -class Meta
     
    -

    Detailed Description

    -
    -

    Definition at line 486 of file meta.hpp.

    -
    The documentation for this class was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1MetaProp-members.html b/classentt_1_1MetaProp-members.html deleted file mode 100644 index bf963cb74..000000000 --- a/classentt_1_1MetaProp-members.html +++ /dev/null @@ -1,84 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::MetaProp Member List
    -
    -
    - -

    This is the complete list of members for entt::MetaProp, including all inherited members.

    - - - - -
    key() const ENTT_NOEXCEPT (defined in entt::MetaProp)entt::MetaPropinline
    Meta (defined in entt::MetaProp)entt::MetaPropfriend
    value() const ENTT_NOEXCEPT (defined in entt::MetaProp)entt::MetaPropinline
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1MetaProp.html b/classentt_1_1MetaProp.html deleted file mode 100644 index d455c4b79..000000000 --- a/classentt_1_1MetaProp.html +++ /dev/null @@ -1,104 +0,0 @@ - - - - - - - -EnTT: entt::MetaProp Class Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Public Member Functions | -Friends | -List of all members
    -
    -
    entt::MetaProp Class Reference
    -
    -
    - - - - - - -

    -Public Member Functions

    -const MetaAny & key () const ENTT_NOEXCEPT
     
    -const MetaAny & value () const ENTT_NOEXCEPT
     
    - - - -

    -Friends

    -class Meta
     
    -

    Detailed Description

    -
    -

    Definition at line 340 of file meta.hpp.

    -
    The documentation for this class was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1MetaType-members.html b/classentt_1_1MetaType-members.html deleted file mode 100644 index a0186c27a..000000000 --- a/classentt_1_1MetaType-members.html +++ /dev/null @@ -1,95 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::MetaType Member List
    -
    -
    - -

    This is the complete list of members for entt::MetaType, including all inherited members.

    - - - - - - - - - - - - - - - -
    construct(Args &&... args) const (defined in entt::MetaType)entt::MetaTypeinline
    ctor(Op op) const ENTT_NOEXCEPT (defined in entt::MetaType)entt::MetaTypeinline
    ctor() const ENTT_NOEXCEPT (defined in entt::MetaType)entt::MetaTypeinline
    data(Op op) const ENTT_NOEXCEPT (defined in entt::MetaType)entt::MetaTypeinline
    data(const char *str) const ENTT_NOEXCEPT (defined in entt::MetaType)entt::MetaTypeinline
    destroy(void *instance) (defined in entt::MetaType)entt::MetaTypeinline
    dtor(Op op) const ENTT_NOEXCEPT (defined in entt::MetaType)entt::MetaTypeinline
    dtor() const ENTT_NOEXCEPT (defined in entt::MetaType)entt::MetaTypeinline
    func(Op op) const ENTT_NOEXCEPT (defined in entt::MetaType)entt::MetaTypeinline
    func(const char *str) const ENTT_NOEXCEPT (defined in entt::MetaType)entt::MetaTypeinline
    Meta (defined in entt::MetaType)entt::MetaTypefriend
    name() const ENTT_NOEXCEPT (defined in entt::MetaType)entt::MetaTypeinline
    properties(Op op) const ENTT_NOEXCEPT (defined in entt::MetaType)entt::MetaTypeinline
    property(Key &&key) const ENTT_NOEXCEPT (defined in entt::MetaType)entt::MetaTypeinline
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1MetaType.html b/classentt_1_1MetaType.html deleted file mode 100644 index 89b318798..000000000 --- a/classentt_1_1MetaType.html +++ /dev/null @@ -1,145 +0,0 @@ - - - - - - - -EnTT: entt::MetaType Class Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Public Member Functions | -Friends | -List of all members
    -
    -
    entt::MetaType Class Reference
    -
    -
    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

    -Public Member Functions

    -const char * name () const ENTT_NOEXCEPT
     
    -template<typename Op >
    void ctor (Op op) const ENTT_NOEXCEPT
     
    -template<typename... Args>
    MetaCtor * ctor () const ENTT_NOEXCEPT
     
    -template<typename Op >
    void dtor (Op op) const ENTT_NOEXCEPT
     
    -MetaDtor * dtor () const ENTT_NOEXCEPT
     
    -template<typename Op >
    void data (Op op) const ENTT_NOEXCEPT
     
    -MetaData * data (const char *str) const ENTT_NOEXCEPT
     
    -template<typename Op >
    void func (Op op) const ENTT_NOEXCEPT
     
    -MetaFunc * func (const char *str) const ENTT_NOEXCEPT
     
    -template<typename... Args>
    MetaAny construct (Args &&... args) const
     
    -void destroy (void *instance)
     
    -template<typename Op >
    void properties (Op op) const ENTT_NOEXCEPT
     
    -template<typename Key >
    MetaProp * property (Key &&key) const ENTT_NOEXCEPT
     
    - - - -

    -Friends

    -class Meta
     
    -

    Detailed Description

    -
    -

    Definition at line 553 of file meta.hpp.

    -
    The documentation for this class was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1PersistentView-members.html b/classentt_1_1PersistentView-members.html deleted file mode 100644 index 66bdfafd0..000000000 --- a/classentt_1_1PersistentView-members.html +++ /dev/null @@ -1,104 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::PersistentView< Entity, Component > Member List
    -
    -
    - -

    This is the complete list of members for entt::PersistentView< Entity, Component >, including all inherited members.

    - - - - - - - - - - - - - - - - - - - - - - - - -
    begin() const ENTT_NOEXCEPTentt::PersistentView< Entity, Component >inline
    begin() ENTT_NOEXCEPTentt::PersistentView< Entity, Component >inline
    cbegin() const ENTT_NOEXCEPTentt::PersistentView< Entity, Component >inline
    cend() const ENTT_NOEXCEPTentt::PersistentView< Entity, Component >inline
    const_iterator_type typedefentt::PersistentView< Entity, Component >
    contains(const entity_type entity) const ENTT_NOEXCEPTentt::PersistentView< Entity, Component >inline
    data() const ENTT_NOEXCEPTentt::PersistentView< Entity, Component >inline
    each(Func func) constentt::PersistentView< Entity, Component >inline
    each(Func func)entt::PersistentView< Entity, Component >inline
    empty() const ENTT_NOEXCEPTentt::PersistentView< Entity, Component >inline
    end() const ENTT_NOEXCEPTentt::PersistentView< Entity, Component >inline
    end() ENTT_NOEXCEPTentt::PersistentView< Entity, Component >inline
    entity_type typedefentt::PersistentView< Entity, Component >
    get(const entity_type entity) const ENTT_NOEXCEPTentt::PersistentView< Entity, Component >inline
    get(const entity_type entity) ENTT_NOEXCEPTentt::PersistentView< Entity, Component >inline
    get(const entity_type entity) const ENTT_NOEXCEPTentt::PersistentView< Entity, Component >inline
    get(const entity_type entity) ENTT_NOEXCEPTentt::PersistentView< Entity, Component >inline
    iterator_type typedefentt::PersistentView< Entity, Component >
    operator[](const size_type pos) const ENTT_NOEXCEPTentt::PersistentView< Entity, Component >inline
    Registry< Entity > classentt::PersistentView< Entity, Component >friend
    size() const ENTT_NOEXCEPTentt::PersistentView< Entity, Component >inline
    size_type typedefentt::PersistentView< Entity, Component >
    sort()entt::PersistentView< Entity, Component >inline
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1PersistentView.html b/classentt_1_1PersistentView.html deleted file mode 100644 index 18a198e73..000000000 --- a/classentt_1_1PersistentView.html +++ /dev/null @@ -1,933 +0,0 @@ - - - - - - - -EnTT: entt::PersistentView< Entity, Component > Class Template Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Public Types | -Public Member Functions | -Friends | -List of all members
    -
    -
    entt::PersistentView< Entity, Component > Class Template Referencefinal
    -
    -
    - -

    Persistent view. - More...

    - -

    #include <view.hpp>

    - - - - - - - - - - - - - - -

    -Public Types

    -using entity_type = typename view_type::entity_type
     Underlying entity identifier.
     
    -using size_type = typename view_type::size_type
     Unsigned integer type.
     
    -using iterator_type = typename view_type::iterator_type
     Input iterator type.
     
    -using const_iterator_type = typename view_type::const_iterator_type
     Constant input iterator type.
     
    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

    -Public Member Functions

    size_type size () const ENTT_NOEXCEPT
     Returns the number of entities that have the given components. More...
     
    bool empty () const ENTT_NOEXCEPT
     Checks whether the view is empty. More...
     
    const entity_type * data () const ENTT_NOEXCEPT
     Direct access to the list of entities. More...
     
    const_iterator_type cbegin () const ENTT_NOEXCEPT
     Returns an iterator to the first entity that has the given components. More...
     
    const_iterator_type begin () const ENTT_NOEXCEPT
     Returns an iterator to the first entity that has the given components. More...
     
    iterator_type begin () ENTT_NOEXCEPT
     Returns an iterator to the first entity that has the given components. More...
     
    const_iterator_type cend () const ENTT_NOEXCEPT
     Returns an iterator that is past the last entity that has the given components. More...
     
    const_iterator_type end () const ENTT_NOEXCEPT
     Returns an iterator that is past the last entity that has the given components. More...
     
    iterator_type end () ENTT_NOEXCEPT
     Returns an iterator that is past the last entity that has the given components. More...
     
    const entity_type & operator[] (const size_type pos) const ENTT_NOEXCEPT
     Returns a reference to the element at the given position. More...
     
    bool contains (const entity_type entity) const ENTT_NOEXCEPT
     Checks if a view contains an entity. More...
     
    template<typename Comp >
    const Comp & get (const entity_type entity) const ENTT_NOEXCEPT
     Returns the component assigned to the given entity. More...
     
    template<typename Comp >
    Comp & get (const entity_type entity) ENTT_NOEXCEPT
     Returns the component assigned to the given entity. More...
     
    template<typename... Comp>
    std::enable_if_t<(sizeof...(Comp) > 1), std::tuple< const Comp &... > > get (const entity_type entity) const ENTT_NOEXCEPT
     Returns the components assigned to the given entity. More...
     
    template<typename... Comp>
    std::enable_if_t<(sizeof...(Comp) > 1), std::tuple< Comp &... > > get (const entity_type entity) ENTT_NOEXCEPT
     Returns the components assigned to the given entity. More...
     
    template<typename Func >
    void each (Func func) const
     Iterates entities and components and applies the given function object to them. More...
     
    template<typename Func >
    void each (Func func)
     Iterates entities and components and applies the given function object to them. More...
     
    template<typename Comp >
    void sort ()
     Sort the shared pool of entities according to the given component. More...
     
    - - - - -

    -Friends

    -class Registry< Entity >
     A registry is allowed to create views.
     
    -

    Detailed Description

    -

    template<typename Entity, typename... Component>
    -class entt::PersistentView< Entity, Component >

    - -

    Persistent view.

    -

    A persistent view returns all the entities and only the entities that have at least the given components. Moreover, it's guaranteed that the entity list is tightly packed in memory for fast iterations.
    - In general, persistent views don't stay true to the order of any set of components unless users explicitly sort them.

    -

    Important

    -

    Iterators aren't invalidated if:

    -
      -
    • New instances of the given components are created and assigned to entities.
      • -
    • The entity currently pointed is modified (as an example, if one of the given components is removed from the entity to which the iterator points).
      • -
    -

    In all the other cases, modifying the pools of the given components in any way invalidates all the iterators and using them results in undefined behavior.

    -
    Note
    Views share references to the underlying data structures with the Registry that generated them. Therefore any change to the entities and to the components made by means of the registry are immediately reflected by views.
    - Moreover, sorting a persistent view affects all the other views of the same type (it means that users don't have to call sort on each view to sort all of them because they share the set of entities).
    -
    Warning
    Lifetime of a view must overcome the one of the registry that generated it. In any other case, attempting to use a view results in undefined behavior.
    -
    See also
    View
    -
    -View<Entity, Component>
    -
    -RawView
    -
    -RuntimeView
    -
    Template Parameters
    - - - -
    EntityA valid entity type (see entt_traits for more details).
    ComponentTypes of components iterated by the view.
    -
    -
    - -

    Definition at line 71 of file view.hpp.

    -

    Member Function Documentation

    - -

    ◆ begin() [1/2]

    - -
    -
    -
    -template<typename Entity , typename... Component>
    - - - - - -
    - - - - - - - -
    const_iterator_type entt::PersistentView< Entity, Component >::begin () const
    -     		-inline
    -
    - -

    Returns an iterator to the first entity that has the given components.

    -

    The returned iterator points to the first entity that has the given components. If the view is empty, the returned iterator will be equal to end().

    -
    Note
    Input iterators stay true to the order imposed to the underlying data structures.
    -
    Returns
    An iterator to the first entity that has the given components.
    - -

    Definition at line 161 of file view.hpp.

    - -
    -
    - -

    ◆ begin() [2/2]

    - -
    -
    -
    -template<typename Entity , typename... Component>
    - - - - - -
    - - - - - - - -
    iterator_type entt::PersistentView< Entity, Component >::begin ()
    -     		-inline
    -
    - -

    Returns an iterator to the first entity that has the given components.

    -

    The returned iterator points to the first entity that has the given components. If the view is empty, the returned iterator will be equal to end().

    -
    Note
    Input iterators stay true to the order imposed to the underlying data structures.
    -
    Returns
    An iterator to the first entity that has the given components.
    - -

    Definition at line 179 of file view.hpp.

    - -
    -
    - -

    ◆ cbegin()

    - -
    -
    -
    -template<typename Entity , typename... Component>
    - - - - - -
    - - - - - - - -
    const_iterator_type entt::PersistentView< Entity, Component >::cbegin () const
    -     		-inline
    -
    - -

    Returns an iterator to the first entity that has the given components.

    -

    The returned iterator points to the first entity that has the given components. If the view is empty, the returned iterator will be equal to end().

    -
    Note
    Input iterators stay true to the order imposed to the underlying data structures.
    -
    Returns
    An iterator to the first entity that has the given components.
    - -

    Definition at line 143 of file view.hpp.

    - -
    -
    - -

    ◆ cend()

    - -
    -
    -
    -template<typename Entity , typename... Component>
    - - - - - -
    - - - - - - - -
    const_iterator_type entt::PersistentView< Entity, Component >::cend () const
    -     		-inline
    -
    - -

    Returns an iterator that is past the last entity that has the given components.

    -

    The returned iterator points to the entity following the last entity that has the given components. Attempting to dereference the returned iterator results in undefined behavior.

    -
    Note
    Input iterators stay true to the order imposed to the underlying data structures.
    -
    Returns
    An iterator to the entity following the last entity that has the given components.
    - -

    Definition at line 198 of file view.hpp.

    - -
    -
    - -

    ◆ contains()

    - -
    -
    -
    -template<typename Entity , typename... Component>
    - - - - - -
    - - - - - - - - -
    bool entt::PersistentView< Entity, Component >::contains (const entity_type entity) const
    -     		-inline
    -
    - -

    Checks if a view contains an entity.

    -
    Parameters
    - - -
    entityA valid entity identifier.
    -
    -
    -
    Returns
    True if the view contains the given entity, false otherwise.
    - -

    Definition at line 254 of file view.hpp.

    - -
    -
    - -

    ◆ data()

    - -
    -
    -
    -template<typename Entity , typename... Component>
    - - - - - -
    - - - - - - - -
    const entity_type* entt::PersistentView< Entity, Component >::data () const
    -     		-inline
    -
    - -

    Direct access to the list of entities.

    -

    The returned pointer is such that range [data(), data() + size()] is always a valid range, even if the container is empty.

    -
    Note
    There are no guarantees on the order of the entities. Use begin and end if you want to iterate the view in the expected order.
    -
    Returns
    A pointer to the array of entities.
    - -

    Definition at line 125 of file view.hpp.

    - -
    -
    - -

    ◆ each() [1/2]

    - -
    -
    -
    -template<typename Entity , typename... Component>
    -
    -template<typename Func >
    - - - - - -
    - - - - - - - - -
    void entt::PersistentView< Entity, Component >::each (Func func) const
    -     		-inline
    -
    - -

    Iterates entities and components and applies the given function object to them.

    -

    The function object is invoked for each entity. It is provided with the entity itself and a set of const references to all the components of the view.
    - The signature of the function should be equivalent to the following:

    -
    void(const entity_type, const Component &...);
    Template Parameters
    - - -
    FuncType of the function object to invoke.
    -
    -
    -
    Parameters
    - - -
    funcA valid function object.
    -
    -
    - -

    Definition at line 368 of file view.hpp.

    - -
    -
    - -

    ◆ each() [2/2]

    - -
    -
    -
    -template<typename Entity , typename... Component>
    -
    -template<typename Func >
    - - - - - -
    - - - - - - - - -
    void entt::PersistentView< Entity, Component >::each (Func func)
    -     		-inline
    -
    - -

    Iterates entities and components and applies the given function object to them.

    -

    The function object is invoked for each entity. It is provided with the entity itself and a set of references to all the components of the view.
    - The signature of the function should be equivalent to the following:

    -
    void(const entity_type, Component &...);
    Template Parameters
    - - -
    FuncType of the function object to invoke.
    -
    -
    -
    Parameters
    - - -
    funcA valid function object.
    -
    -
    - -

    Definition at line 391 of file view.hpp.

    - -
    -
    - -

    ◆ empty()

    - -
    -
    -
    -template<typename Entity , typename... Component>
    - - - - - -
    - - - - - - - -
    bool entt::PersistentView< Entity, Component >::empty () const
    -     		-inline
    -
    - -

    Checks whether the view is empty.

    -
    Returns
    True if the view is empty, false otherwise.
    - -

    Definition at line 109 of file view.hpp.

    - -
    -
    - -

    ◆ end() [1/2]

    - -
    -
    -
    -template<typename Entity , typename... Component>
    - - - - - -
    - - - - - - - -
    const_iterator_type entt::PersistentView< Entity, Component >::end () const
    -     		-inline
    -
    - -

    Returns an iterator that is past the last entity that has the given components.

    -

    The returned iterator points to the entity following the last entity that has the given components. Attempting to dereference the returned iterator results in undefined behavior.

    -
    Note
    Input iterators stay true to the order imposed to the underlying data structures.
    -
    Returns
    An iterator to the entity following the last entity that has the given components.
    - -

    Definition at line 217 of file view.hpp.

    - -
    -
    - -

    ◆ end() [2/2]

    - -
    -
    -
    -template<typename Entity , typename... Component>
    - - - - - -
    - - - - - - - -
    iterator_type entt::PersistentView< Entity, Component >::end ()
    -     		-inline
    -
    - -

    Returns an iterator that is past the last entity that has the given components.

    -

    The returned iterator points to the entity following the last entity that has the given components. Attempting to dereference the returned iterator results in undefined behavior.

    -
    Note
    Input iterators stay true to the order imposed to the underlying data structures.
    -
    Returns
    An iterator to the entity following the last entity that has the given components.
    - -

    Definition at line 236 of file view.hpp.

    - -
    -
    - -

    ◆ get() [1/4]

    - -
    -
    -
    -template<typename Entity , typename... Component>
    -
    -template<typename Comp >
    - - - - - -
    - - - - - - - - -
    const Comp& entt::PersistentView< Entity, Component >::get (const entity_type entity) const
    -     		-inline
    -
    - -

    Returns the component assigned to the given entity.

    -

    Prefer this function instead of Registry::get during iterations. It has far better performance than its companion function.

    -
    Warning
    Attempting to use an invalid component type results in a compilation error. Attempting to use an entity that doesn't belong to the view results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode if the view doesn't contain the given entity.
    -
    Template Parameters
    - - -
    CompType of component to get.
    -
    -
    -
    Parameters
    - - -
    entityA valid entity identifier.
    -
    -
    -
    Returns
    The component assigned to the entity.
    - -

    Definition at line 276 of file view.hpp.

    - -
    -
    - -

    ◆ get() [2/4]

    - -
    -
    -
    -template<typename Entity , typename... Component>
    -
    -template<typename Comp >
    - - - - - -
    - - - - - - - - -
    Comp& entt::PersistentView< Entity, Component >::get (const entity_type entity)
    -     		-inline
    -
    - -

    Returns the component assigned to the given entity.

    -

    Prefer this function instead of Registry::get during iterations. It has far better performance than its companion function.

    -
    Warning
    Attempting to use an invalid component type results in a compilation error. Attempting to use an entity that doesn't belong to the view results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode if the view doesn't contain the given entity.
    -
    Template Parameters
    - - -
    CompType of component to get.
    -
    -
    -
    Parameters
    - - -
    entityA valid entity identifier.
    -
    -
    -
    Returns
    The component assigned to the entity.
    - -

    Definition at line 299 of file view.hpp.

    - -
    -
    - -

    ◆ get() [3/4]

    - -
    -
    -
    -template<typename Entity , typename... Component>
    -
    -template<typename... Comp>
    - - - - - -
    - - - - - - - - -
    std::enable_if_t<(sizeof...(Comp) > 1), std::tuple<const Comp &...> > entt::PersistentView< Entity, Component >::get (const entity_type entity) const
    -     		-inline
    -
    - -

    Returns the components assigned to the given entity.

    -

    Prefer this function instead of Registry::get during iterations. It has far better performance than its companion function.

    -
    Warning
    Attempting to use invalid component types results in a compilation error. Attempting to use an entity that doesn't belong to the view results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode if the view doesn't contain the given entity.
    -
    Template Parameters
    - - -
    CompTypes of the components to get.
    -
    -
    -
    Parameters
    - - -
    entityA valid entity identifier.
    -
    -
    -
    Returns
    The components assigned to the entity.
    - -

    Definition at line 322 of file view.hpp.

    - -
    -
    - -

    ◆ get() [4/4]

    - -
    -
    -
    -template<typename Entity , typename... Component>
    -
    -template<typename... Comp>
    - - - - - -
    - - - - - - - - -
    std::enable_if_t<(sizeof...(Comp) > 1), std::tuple<Comp &...> > entt::PersistentView< Entity, Component >::get (const entity_type entity)
    -     		-inline
    -
    - -

    Returns the components assigned to the given entity.

    -

    Prefer this function instead of Registry::get during iterations. It has far better performance than its companion function.

    -
    Warning
    Attempting to use invalid component types results in a compilation error. Attempting to use an entity that doesn't belong to the view results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode if the view doesn't contain the given entity.
    -
    Template Parameters
    - - -
    CompTypes of the components to get.
    -
    -
    -
    Parameters
    - - -
    entityA valid entity identifier.
    -
    -
    -
    Returns
    The components assigned to the entity.
    - -

    Definition at line 346 of file view.hpp.

    - -
    -
    - -

    ◆ operator[]()

    - -
    -
    -
    -template<typename Entity , typename... Component>
    - - - - - -
    - - - - - - - - -
    const entity_type& entt::PersistentView< Entity, Component >::operator[] (const size_type pos) const
    -     		-inline
    -
    - -

    Returns a reference to the element at the given position.

    -
    Parameters
    - - -
    posPosition of the element to return.
    -
    -
    -
    Returns
    A reference to the requested element.
    - -

    Definition at line 245 of file view.hpp.

    - -
    -
    - -

    ◆ size()

    - -
    -
    -
    -template<typename Entity , typename... Component>
    - - - - - -
    - - - - - - - -
    size_type entt::PersistentView< Entity, Component >::size () const
    -     		-inline
    -
    - -

    Returns the number of entities that have the given components.

    -
    Returns
    Number of entities that have the given components.
    - -

    Definition at line 101 of file view.hpp.

    - -
    -
    - -

    ◆ sort()

    - -
    -
    -
    -template<typename Entity , typename... Component>
    -
    -template<typename Comp >
    - - - - - -
    - - - - - - - -
    void entt::PersistentView< Entity, Component >::sort ()
    -     		-inline
    -
    - -

    Sort the shared pool of entities according to the given component.

    -

    Persistent views of the same type share with the Registry a pool of entities with its own order that doesn't depend on the order of any pool of components. Users can order the underlying data structure so that it respects the order of the pool of the given component.

    -
    Note
    The shared pool of entities and thus its order is affected by the changes to each and every pool that it tracks. Therefore changes to those pools can quickly ruin the order imposed to the pool of entities shared between the persistent views.
    -
    Template Parameters
    - - -
    CompType of component to use to impose the order.
    -
    -
    - -

    Definition at line 414 of file view.hpp.

    - -
    -
    -
    The documentation for this class was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1Prototype-members.html b/classentt_1_1Prototype-members.html deleted file mode 100644 index 59faada7d..000000000 --- a/classentt_1_1Prototype-members.html +++ /dev/null @@ -1,107 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::Prototype< Entity > Member List
    -
    -
    - -

    This is the complete list of members for entt::Prototype< Entity >, including all inherited members.

    - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    accommodate(registry_type &other, const entity_type dst) constentt::Prototype< Entity >inline
    accommodate(const entity_type dst) constentt::Prototype< Entity >inline
    assign(registry_type &other, const entity_type dst) constentt::Prototype< Entity >inline
    assign(const entity_type dst) constentt::Prototype< Entity >inline
    create(registry_type &other) constentt::Prototype< Entity >inline
    create() constentt::Prototype< Entity >inline
    entity_type typedefentt::Prototype< Entity >
    get() const ENTT_NOEXCEPTentt::Prototype< Entity >inline
    get() ENTT_NOEXCEPTentt::Prototype< Entity >inline
    get() const ENTT_NOEXCEPTentt::Prototype< Entity >inline
    get() ENTT_NOEXCEPTentt::Prototype< Entity >inline
    has() const ENTT_NOEXCEPTentt::Prototype< Entity >inline
    operator()(registry_type &other, const entity_type dst) const ENTT_NOEXCEPTentt::Prototype< Entity >inline
    operator()(const entity_type dst) const ENTT_NOEXCEPTentt::Prototype< Entity >inline
    operator()(registry_type &other) const ENTT_NOEXCEPTentt::Prototype< Entity >inline
    operator()() const ENTT_NOEXCEPTentt::Prototype< Entity >inline
    operator=(const Prototype &)=deleteentt::Prototype< Entity >
    operator=(Prototype &&other)entt::Prototype< Entity >inline
    Prototype(Registry< Entity > &registry)entt::Prototype< Entity >inline
    Prototype(const Prototype &)=deleteentt::Prototype< Entity >
    Prototype(Prototype &&other)entt::Prototype< Entity >inline
    registry_type typedefentt::Prototype< Entity >
    set(Args &&... args)entt::Prototype< Entity >inline
    size_type typedefentt::Prototype< Entity >
    unset() ENTT_NOEXCEPTentt::Prototype< Entity >inline
    ~Prototype()entt::Prototype< Entity >inline
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1RawView-members.html b/classentt_1_1RawView-members.html deleted file mode 100644 index 9890b00ab..000000000 --- a/classentt_1_1RawView-members.html +++ /dev/null @@ -1,102 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::RawView< Entity, Component > Member List
    -
    -
    - -

    This is the complete list of members for entt::RawView< Entity, Component >, including all inherited members.

    - - - - - - - - - - - - - - - - - - - - - - -
    begin() const ENTT_NOEXCEPTentt::RawView< Entity, Component >inline
    begin() ENTT_NOEXCEPTentt::RawView< Entity, Component >inline
    cbegin() const ENTT_NOEXCEPTentt::RawView< Entity, Component >inline
    cend() const ENTT_NOEXCEPTentt::RawView< Entity, Component >inline
    const_iterator_type typedefentt::RawView< Entity, Component >
    data() const ENTT_NOEXCEPTentt::RawView< Entity, Component >inline
    each(Func func) constentt::RawView< Entity, Component >inline
    each(Func func)entt::RawView< Entity, Component >inline
    empty() const ENTT_NOEXCEPTentt::RawView< Entity, Component >inline
    end() const ENTT_NOEXCEPTentt::RawView< Entity, Component >inline
    end() ENTT_NOEXCEPTentt::RawView< Entity, Component >inline
    entity_type typedefentt::RawView< Entity, Component >
    iterator_type typedefentt::RawView< Entity, Component >
    operator[](const size_type pos) const ENTT_NOEXCEPTentt::RawView< Entity, Component >inline
    operator[](const size_type pos) ENTT_NOEXCEPTentt::RawView< Entity, Component >inline
    raw() const ENTT_NOEXCEPTentt::RawView< Entity, Component >inline
    raw() ENTT_NOEXCEPTentt::RawView< Entity, Component >inline
    raw_type typedefentt::RawView< Entity, Component >
    Registry< Entity > classentt::RawView< Entity, Component >friend
    size() const ENTT_NOEXCEPTentt::RawView< Entity, Component >inline
    size_type typedefentt::RawView< Entity, Component >
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1RawView.html b/classentt_1_1RawView.html deleted file mode 100644 index 5d65faf4a..000000000 --- a/classentt_1_1RawView.html +++ /dev/null @@ -1,749 +0,0 @@ - - - - - - - -EnTT: entt::RawView< Entity, Component > Class Template Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Public Types | -Public Member Functions | -Friends | -List of all members
    -
    -
    entt::RawView< Entity, Component > Class Template Referencefinal
    -
    -
    - -

    Raw view. - More...

    - -

    #include <view.hpp>

    - - - - - - - - - - - - - - - - - -

    -Public Types

    -using raw_type = typename pool_type::object_type
     Type of component iterated by the view.
     
    -using entity_type = typename pool_type::entity_type
     Underlying entity identifier.
     
    -using size_type = typename pool_type::size_type
     Unsigned integer type.
     
    -using iterator_type = typename pool_type::iterator_type
     Input iterator type.
     
    -using const_iterator_type = typename pool_type::const_iterator_type
     Constant input iterator type.
     
    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

    -Public Member Functions

    size_type size () const ENTT_NOEXCEPT
     Returns the number of instances of the given type. More...
     
    bool empty () const ENTT_NOEXCEPT
     Checks whether the view is empty. More...
     
    const raw_type * raw () const ENTT_NOEXCEPT
     Direct access to the list of components. More...
     
    raw_type * raw () ENTT_NOEXCEPT
     Direct access to the list of components. More...
     
    const entity_type * data () const ENTT_NOEXCEPT
     Direct access to the list of entities. More...
     
    const_iterator_type cbegin () const ENTT_NOEXCEPT
     Returns an iterator to the first instance of the given type. More...
     
    const_iterator_type begin () const ENTT_NOEXCEPT
     Returns an iterator to the first instance of the given type. More...
     
    iterator_type begin () ENTT_NOEXCEPT
     Returns an iterator to the first instance of the given type. More...
     
    const_iterator_type cend () const ENTT_NOEXCEPT
     Returns an iterator that is past the last instance of the given type. More...
     
    const_iterator_type end () const ENTT_NOEXCEPT
     Returns an iterator that is past the last instance of the given type. More...
     
    iterator_type end () ENTT_NOEXCEPT
     Returns an iterator that is past the last instance of the given type. More...
     
    const raw_type & operator[] (const size_type pos) const ENTT_NOEXCEPT
     Returns a reference to the element at the given position. More...
     
    raw_type & operator[] (const size_type pos) ENTT_NOEXCEPT
     Returns a reference to the element at the given position. More...
     
    template<typename Func >
    void each (Func func) const
     Iterates components and applies the given function object to them. More...
     
    template<typename Func >
    void each (Func func)
     Iterates components and applies the given function object to them. More...
     
    - - - - -

    -Friends

    -class Registry< Entity >
     A registry is allowed to create views.
     
    -

    Detailed Description

    -

    template<typename Entity, typename Component>
    -class entt::RawView< Entity, Component >

    - -

    Raw view.

    -

    Raw views are meant to easily iterate components without having to resort to using any other member function, so as to further increase the performance. Whenever knowing the entity to which a component belongs isn't required, this should be the preferred tool.
    - Order of elements during iterations are highly dependent on the order of the underlying data structure. See SparseSet and its specializations for more details.

    -

    Important

    -

    Iterators aren't invalidated if:

    -
      -
    • New instances of the given component are created and assigned to entities.
      • -
    • The entity to which the component belongs is modified (as an example, the given component is destroyed).
      • -
    -

    In all the other cases, modifying the pool of the given component in any way invalidates all the iterators and using them results in undefined behavior.

    -
    Note
    Views share a reference to the underlying data structure with the Registry that generated them. Therefore any change to the entities and to the components made by means of the registry are immediately reflected by views.
    -
    Warning
    Lifetime of a view must overcome the one of the registry that generated it. In any other case, attempting to use a view results in undefined behavior.
    -
    See also
    View
    -
    -View<Entity, Component>
    -
    -PersistentView
    -
    -RuntimeView
    -
    Template Parameters
    - - - -
    EntityA valid entity type (see entt_traits for more details).
    ComponentType of component iterated by the view.
    -
    -
    - -

    Definition at line 1295 of file view.hpp.

    -

    Member Function Documentation

    - -

    ◆ begin() [1/2]

    - -
    -
    -
    -template<typename Entity , typename Component >
    - - - - - -
    - - - - - - - -
    const_iterator_type entt::RawView< Entity, Component >::begin () const
    -     		-inline
    -
    - -

    Returns an iterator to the first instance of the given type.

    -

    The returned iterator points to the first instance of the given type. If the view is empty, the returned iterator will be equal to end().

    -
    Note
    Input iterators stay true to the order imposed to the underlying data structures.
    -
    Returns
    An iterator to the first instance of the given type.
    - -

    Definition at line 1409 of file view.hpp.

    - -
    -
    - -

    ◆ begin() [2/2]

    - -
    -
    -
    -template<typename Entity , typename Component >
    - - - - - -
    - - - - - - - -
    iterator_type entt::RawView< Entity, Component >::begin ()
    -     		-inline
    -
    - -

    Returns an iterator to the first instance of the given type.

    -

    The returned iterator points to the first instance of the given type. If the view is empty, the returned iterator will be equal to end().

    -
    Note
    Input iterators stay true to the order imposed to the underlying data structures.
    -
    Returns
    An iterator to the first instance of the given type.
    - -

    Definition at line 1425 of file view.hpp.

    - -
    -
    - -

    ◆ cbegin()

    - -
    -
    -
    -template<typename Entity , typename Component >
    - - - - - -
    - - - - - - - -
    const_iterator_type entt::RawView< Entity, Component >::cbegin () const
    -     		-inline
    -
    - -

    Returns an iterator to the first instance of the given type.

    -

    The returned iterator points to the first instance of the given type. If the view is empty, the returned iterator will be equal to end().

    -
    Note
    Input iterators stay true to the order imposed to the underlying data structures.
    -
    Returns
    An iterator to the first instance of the given type.
    - -

    Definition at line 1393 of file view.hpp.

    - -
    -
    - -

    ◆ cend()

    - -
    -
    -
    -template<typename Entity , typename Component >
    - - - - - -
    - - - - - - - -
    const_iterator_type entt::RawView< Entity, Component >::cend () const
    -     		-inline
    -
    - -

    Returns an iterator that is past the last instance of the given type.

    -

    The returned iterator points to the element following the last instance of the given type. Attempting to dereference the returned iterator results in undefined behavior.

    -
    Note
    Input iterators stay true to the order imposed to the underlying data structures.
    -
    Returns
    An iterator to the element following the last instance of the given type.
    - -

    Definition at line 1444 of file view.hpp.

    - -
    -
    - -

    ◆ data()

    - -
    -
    -
    -template<typename Entity , typename Component >
    - - - - - -
    - - - - - - - -
    const entity_type* entt::RawView< Entity, Component >::data () const
    -     		-inline
    -
    - -

    Direct access to the list of entities.

    -

    The returned pointer is such that range [data(), data() + size()] is always a valid range, even if the container is empty.

    -
    Note
    There are no guarantees on the order of the entities. Use begin and end if you want to iterate the view in the expected order.
    -
    Returns
    A pointer to the array of entities.
    - -

    Definition at line 1377 of file view.hpp.

    - -
    -
    - -

    ◆ each() [1/2]

    - -
    -
    -
    -template<typename Entity , typename Component >
    -
    -template<typename Func >
    - - - - - -
    - - - - - - - - -
    void entt::RawView< Entity, Component >::each (Func func) const
    -     		-inline
    -
    - -

    Iterates components and applies the given function object to them.

    -

    The function object is provided with a const reference to each component of the view.
    - The signature of the function should be equivalent to the following:

    -
    void(const Component &);
    Template Parameters
    - - -
    FuncType of the function object to invoke.
    -
    -
    -
    Parameters
    - - -
    funcA valid function object.
    -
    -
    - -

    Definition at line 1519 of file view.hpp.

    - -
    -
    - -

    ◆ each() [2/2]

    - -
    -
    -
    -template<typename Entity , typename Component >
    -
    -template<typename Func >
    - - - - - -
    - - - - - - - - -
    void entt::RawView< Entity, Component >::each (Func func)
    -     		-inline
    -
    - -

    Iterates components and applies the given function object to them.

    -

    The function object is provided with a reference to each component of the view.
    - The signature of the function should be equivalent to the following:

    -
    void(Component &);
    Template Parameters
    - - -
    FuncType of the function object to invoke.
    -
    -
    -
    Parameters
    - - -
    funcA valid function object.
    -
    -
    - -

    Definition at line 1538 of file view.hpp.

    - -
    -
    - -

    ◆ empty()

    - -
    -
    -
    -template<typename Entity , typename Component >
    - - - - - -
    - - - - - - - -
    bool entt::RawView< Entity, Component >::empty () const
    -     		-inline
    -
    - -

    Checks whether the view is empty.

    -
    Returns
    True if the view is empty, false otherwise.
    - -

    Definition at line 1329 of file view.hpp.

    - -
    -
    - -

    ◆ end() [1/2]

    - -
    -
    -
    -template<typename Entity , typename Component >
    - - - - - -
    - - - - - - - -
    const_iterator_type entt::RawView< Entity, Component >::end () const
    -     		-inline
    -
    - -

    Returns an iterator that is past the last instance of the given type.

    -

    The returned iterator points to the element following the last instance of the given type. Attempting to dereference the returned iterator results in undefined behavior.

    -
    Note
    Input iterators stay true to the order imposed to the underlying data structures.
    -
    Returns
    An iterator to the element following the last instance of the given type.
    - -

    Definition at line 1463 of file view.hpp.

    - -
    -
    - -

    ◆ end() [2/2]

    - -
    -
    -
    -template<typename Entity , typename Component >
    - - - - - -
    - - - - - - - -
    iterator_type entt::RawView< Entity, Component >::end ()
    -     		-inline
    -
    - -

    Returns an iterator that is past the last instance of the given type.

    -

    The returned iterator points to the element following the last instance of the given type. Attempting to dereference the returned iterator results in undefined behavior.

    -
    Note
    Input iterators stay true to the order imposed to the underlying data structures.
    -
    Returns
    An iterator to the element following the last instance of the given type.
    - -

    Definition at line 1482 of file view.hpp.

    - -
    -
    - -

    ◆ operator[]() [1/2]

    - -
    -
    -
    -template<typename Entity , typename Component >
    - - - - - -
    - - - - - - - - -
    const raw_type& entt::RawView< Entity, Component >::operator[] (const size_type pos) const
    -     		-inline
    -
    - -

    Returns a reference to the element at the given position.

    -
    Parameters
    - - -
    posPosition of the element to return.
    -
    -
    -
    Returns
    A reference to the requested element.
    - -

    Definition at line 1491 of file view.hpp.

    - -
    -
    - -

    ◆ operator[]() [2/2]

    - -
    -
    -
    -template<typename Entity , typename Component >
    - - - - - -
    - - - - - - - - -
    raw_type& entt::RawView< Entity, Component >::operator[] (const size_type pos)
    -     		-inline
    -
    - -

    Returns a reference to the element at the given position.

    -
    Parameters
    - - -
    posPosition of the element to return.
    -
    -
    -
    Returns
    A reference to the requested element.
    - -

    Definition at line 1500 of file view.hpp.

    - -
    -
    - -

    ◆ raw() [1/2]

    - -
    -
    -
    -template<typename Entity , typename Component >
    - - - - - -
    - - - - - - - -
    const raw_type* entt::RawView< Entity, Component >::raw () const
    -     		-inline
    -
    - -

    Direct access to the list of components.

    -

    The returned pointer is such that range [raw(), raw() + size()] is always a valid range, even if the container is empty.

    -
    Note
    There are no guarantees on the order of the components. Use begin and end if you want to iterate the view in the expected order.
    -
    Returns
    A pointer to the array of components.
    - -

    Definition at line 1345 of file view.hpp.

    - -
    -
    - -

    ◆ raw() [2/2]

    - -
    -
    -
    -template<typename Entity , typename Component >
    - - - - - -
    - - - - - - - -
    raw_type* entt::RawView< Entity, Component >::raw ()
    -     		-inline
    -
    - -

    Direct access to the list of components.

    -

    The returned pointer is such that range [raw(), raw() + size()] is always a valid range, even if the container is empty.

    -
    Note
    There are no guarantees on the order of the components. Use begin and end if you want to iterate the view in the expected order.
    -
    Returns
    A pointer to the array of components.
    - -

    Definition at line 1361 of file view.hpp.

    - -
    -
    - -

    ◆ size()

    - -
    -
    -
    -template<typename Entity , typename Component >
    - - - - - -
    - - - - - - - -
    size_type entt::RawView< Entity, Component >::size () const
    -     		-inline
    -
    - -

    Returns the number of instances of the given type.

    -
    Returns
    Number of instances of the given component.
    - -

    Definition at line 1321 of file view.hpp.

    - -
    -
    -
    The documentation for this class was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1Registry-members.html b/classentt_1_1Registry-members.html deleted file mode 100644 index c2f74e06c..000000000 --- a/classentt_1_1Registry-members.html +++ /dev/null @@ -1,154 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::Registry< Entity > Member List
    -
    -
    - -

    This is the complete list of members for entt::Registry< Entity >, including all inherited members.

    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    accommodate(const entity_type entity, Args &&... args)entt::Registry< Entity >inline
    alive() const ENTT_NOEXCEPTentt::Registry< Entity >inline
    assign(tag_t, const entity_type entity, Args &&... args)entt::Registry< Entity >inline
    assign(const entity_type entity, Args &&... args)entt::Registry< Entity >inline
    attachee() const ENTT_NOEXCEPTentt::Registry< Entity >inline
    capacity() const ENTT_NOEXCEPTentt::Registry< Entity >inline
    capacity() const ENTT_NOEXCEPTentt::Registry< Entity >inline
    component_type typedefentt::Registry< Entity >
    construction(tag_t) ENTT_NOEXCEPTentt::Registry< Entity >inline
    construction() ENTT_NOEXCEPTentt::Registry< Entity >inline
    contains() const ENTT_NOEXCEPTentt::Registry< Entity >inline
    create()entt::Registry< Entity >inline
    current(const entity_type entity) const ENTT_NOEXCEPTentt::Registry< Entity >inline
    data() const ENTT_NOEXCEPTentt::Registry< Entity >inline
    destroy(tag_t)entt::Registry< Entity >inline
    destroy(const entity_type entity)entt::Registry< Entity >inline
    destroy(Type...)entt::Registry< Entity >inline
    destruction(tag_t) ENTT_NOEXCEPTentt::Registry< Entity >inline
    destruction() ENTT_NOEXCEPTentt::Registry< Entity >inline
    discard()entt::Registry< Entity >inline
    each(Func func) constentt::Registry< Entity >inline
    empty() const ENTT_NOEXCEPTentt::Registry< Entity >inline
    empty() const ENTT_NOEXCEPTentt::Registry< Entity >inline
    entity(const entity_type entity) const ENTT_NOEXCEPTentt::Registry< Entity >inline
    entity_type typedefentt::Registry< Entity >
    fast(const entity_type entity) const ENTT_NOEXCEPTentt::Registry< Entity >inline
    get() const ENTT_NOEXCEPTentt::Registry< Entity >inline
    get() ENTT_NOEXCEPTentt::Registry< Entity >inline
    get(const entity_type entity) const ENTT_NOEXCEPTentt::Registry< Entity >inline
    get(const entity_type entity) ENTT_NOEXCEPTentt::Registry< Entity >inline
    get(const entity_type entity) const ENTT_NOEXCEPTentt::Registry< Entity >inline
    get(const entity_type entity) ENTT_NOEXCEPTentt::Registry< Entity >inline
    has() const ENTT_NOEXCEPTentt::Registry< Entity >inline
    has(tag_t, const entity_type entity) const ENTT_NOEXCEPTentt::Registry< Entity >inline
    has(const entity_type entity) const ENTT_NOEXCEPTentt::Registry< Entity >inline
    move(const entity_type entity) ENTT_NOEXCEPTentt::Registry< Entity >inline
    operator=(const Registry &)=deleteentt::Registry< Entity >
    operator=(Registry &&)=defaultentt::Registry< Entity >
    orphan(const entity_type entity) constentt::Registry< Entity >inline
    orphans(Func func) constentt::Registry< Entity >inline
    prepare()entt::Registry< Entity >inline
    raw() const ENTT_NOEXCEPTentt::Registry< Entity >inline
    raw() ENTT_NOEXCEPTentt::Registry< Entity >inline
    Registry()=defaultentt::Registry< Entity >
    Registry(const Registry &)=deleteentt::Registry< Entity >
    Registry(Registry &&)=defaultentt::Registry< Entity >
    remove()entt::Registry< Entity >inline
    remove(const entity_type entity)entt::Registry< Entity >inline
    replace(tag_t, Args &&... args)entt::Registry< Entity >inline
    replace(const entity_type entity, Args &&... args)entt::Registry< Entity >inline
    reserve(const size_type cap)entt::Registry< Entity >inline
    reserve(const size_type cap)entt::Registry< Entity >inline
    reset(const entity_type entity)entt::Registry< Entity >inline
    reset()entt::Registry< Entity >inline
    reset()entt::Registry< Entity >inline
    restore() ENTT_NOEXCEPTentt::Registry< Entity >inline
    sink_type typedefentt::Registry< Entity >
    size() const ENTT_NOEXCEPTentt::Registry< Entity >inline
    size() const ENTT_NOEXCEPTentt::Registry< Entity >inline
    size_type typedefentt::Registry< Entity >
    snapshot() const ENTT_NOEXCEPTentt::Registry< Entity >inline
    sort(Compare compare, Sort sort=Sort{}, Args &&... args)entt::Registry< Entity >inline
    sort()entt::Registry< Entity >inline
    tag_type typedefentt::Registry< Entity >
    type(tag_t) ENTT_NOEXCEPTentt::Registry< Entity >inlinestatic
    type() ENTT_NOEXCEPTentt::Registry< Entity >inlinestatic
    valid(const entity_type entity) const ENTT_NOEXCEPTentt::Registry< Entity >inline
    version(const entity_type entity) const ENTT_NOEXCEPTentt::Registry< Entity >inline
    version_type typedefentt::Registry< Entity >
    view()entt::Registry< Entity >inline
    view(persistent_t)entt::Registry< Entity >inline
    view(raw_t)entt::Registry< Entity >inline
    view(It first, It last)entt::Registry< Entity >inline
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1Registry.html b/classentt_1_1Registry.html deleted file mode 100644 index 44d6f06df..000000000 --- a/classentt_1_1Registry.html +++ /dev/null @@ -1,3299 +0,0 @@ - - - - - - - -EnTT: entt::Registry< Entity > Class Template Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Classes | -Public Types | -Public Member Functions | -Static Public Member Functions | -List of all members
    -
    -
    entt::Registry< Entity > Class Template Reference
    -
    -
    - -

    Fast and reliable entity-component system. - More...

    - -

    #include <registry.hpp>

    - - - - - - - - - - - - - - - - - - - - -

    -Public Types

    -using entity_type = typename traits_type::entity_type
     Underlying entity identifier.
     
    -using version_type = typename traits_type::version_type
     Underlying version type.
     
    -using size_type = std::size_t
     Unsigned integer type.
     
    -using tag_type = typename tag_family::family_type
     Unsigned integer type.
     
    -using component_type = typename component_family::family_type
     Unsigned integer type.
     
    -using sink_type = typename signal_type::sink_type
     Type of sink for the given component.
     
    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

    -Public Member Functions

    - Registry ()=default
     Default constructor.
     
    - Registry (const Registry &)=delete
     Copying a registry isn't allowed.
     
    - Registry (Registry &&)=default
     Default move constructor.
     
    Registry & operator= (const Registry &)=delete
     Copying a registry isn't allowed. More...
     
    Registry & operator= (Registry &&)=default
     Default move assignment operator. More...
     
    template<typename Component >
    size_type size () const ENTT_NOEXCEPT
     Returns the number of existing components of the given type. More...
     
    size_type size () const ENTT_NOEXCEPT
     Returns the number of entities created so far. More...
     
    size_type alive () const ENTT_NOEXCEPT
     Returns the number of entities still in use. More...
     
    template<typename Component >
    void reserve (const size_type cap)
     Increases the capacity of the pool for the given component. More...
     
    void reserve (const size_type cap)
     Increases the capacity of a registry in terms of entities. More...
     
    template<typename Component >
    size_type capacity () const ENTT_NOEXCEPT
     Returns the capacity of the pool for the given component. More...
     
    size_type capacity () const ENTT_NOEXCEPT
     Returns the number of entities that a registry has currently allocated space for. More...
     
    template<typename Component >
    bool empty () const ENTT_NOEXCEPT
     Checks whether the pool of the given component is empty. More...
     
    bool empty () const ENTT_NOEXCEPT
     Checks if there exists at least an entity still in use. More...
     
    template<typename Component >
    const Component * raw () const ENTT_NOEXCEPT
     Direct access to the list of components of a given pool. More...
     
    template<typename Component >
    Component * raw () ENTT_NOEXCEPT
     Direct access to the list of components of a given pool. More...
     
    template<typename Component >
    const entity_type * data () const ENTT_NOEXCEPT
     Direct access to the list of entities of a given pool. More...
     
    bool valid (const entity_type entity) const ENTT_NOEXCEPT
     Checks if an entity identifier refers to a valid entity. More...
     
    bool fast (const entity_type entity) const ENTT_NOEXCEPT
     Checks if an entity identifier refers to a valid entity. More...
     
    entity_type entity (const entity_type entity) const ENTT_NOEXCEPT
     Returns the entity identifier without the version. More...
     
    version_type version (const entity_type entity) const ENTT_NOEXCEPT
     Returns the version stored along with an entity identifier. More...
     
    version_type current (const entity_type entity) const ENTT_NOEXCEPT
     Returns the actual version for an entity identifier. More...
     
    entity_type create ()
     Creates a new entity and returns it. More...
     
    template<typename Tag >
    void destroy (tag_t)
     Destroys the entity that owns the given tag, if any. More...
     
    void destroy (const entity_type entity)
     Destroys an entity and lets the registry recycle the identifier. More...
     
    template<typename... Component, typename... Type>
    void destroy (Type...)
     Destroys the entities that own the given components, if any. More...
     
    template<typename Tag , typename... Args>
    Tag & assign (tag_t, const entity_type entity, Args &&... args)
     Attaches the given tag to an entity. More...
     
    template<typename Component , typename... Args>
    Component & assign (const entity_type entity, Args &&... args)
     Assigns the given component to an entity. More...
     
    template<typename Tag >
    void remove ()
     Removes the given tag from its owner, if any. More...
     
    template<typename Component >
    void remove (const entity_type entity)
     Removes the given component from an entity. More...
     
    template<typename Tag >
    bool has () const ENTT_NOEXCEPT
     Checks if the given tag has an owner. More...
     
    template<typename Tag >
    bool has (tag_t, const entity_type entity) const ENTT_NOEXCEPT
     Checks if an entity owns the given tag. More...
     
    template<typename... Component>
    bool has (const entity_type entity) const ENTT_NOEXCEPT
     Checks if an entity has all the given components. More...
     
    template<typename Tag >
    const Tag & get () const ENTT_NOEXCEPT
     Returns a reference to the given tag. More...
     
    template<typename Tag >
    Tag & get () ENTT_NOEXCEPT
     Returns a reference to the given tag. More...
     
    template<typename Component >
    const Component & get (const entity_type entity) const ENTT_NOEXCEPT
     Returns a reference to the given component for an entity. More...
     
    template<typename Component >
    Component & get (const entity_type entity) ENTT_NOEXCEPT
     Returns a reference to the given component for an entity. More...
     
    template<typename... Component>
    std::enable_if_t<(sizeof...(Component) > 1), std::tuple< const Component &... > > get (const entity_type entity) const ENTT_NOEXCEPT
     Returns a reference to the given components for an entity. More...
     
    template<typename... Component>
    std::enable_if_t<(sizeof...(Component) > 1), std::tuple< Component &... > > get (const entity_type entity) ENTT_NOEXCEPT
     Returns a reference to the given components for an entity. More...
     
    template<typename Tag , typename... Args>
    Tag & replace (tag_t, Args &&... args)
     Replaces the given tag. More...
     
    template<typename Component , typename... Args>
    Component & replace (const entity_type entity, Args &&... args)
     Replaces the given component for an entity. More...
     
    template<typename Tag >
    entity_type move (const entity_type entity) ENTT_NOEXCEPT
     Changes the owner of the given tag. More...
     
    template<typename Tag >
    entity_type attachee () const ENTT_NOEXCEPT
     Gets the owner of the given tag, if any. More...
     
    template<typename Component , typename... Args>
    Component & accommodate (const entity_type entity, Args &&... args)
     Assigns or replaces the given component for an entity. More...
     
    template<typename Tag >
    sink_type construction (tag_t) ENTT_NOEXCEPT
     Returns a sink object for the given tag. More...
     
    template<typename Component >
    sink_type construction () ENTT_NOEXCEPT
     Returns a sink object for the given component. More...
     
    template<typename Tag >
    sink_type destruction (tag_t) ENTT_NOEXCEPT
     Returns a sink object for the given tag. More...
     
    template<typename Component >
    sink_type destruction () ENTT_NOEXCEPT
     Returns a sink object for the given component. More...
     
    template<typename Component , typename Compare , typename Sort = StdSort, typename... Args>
    void sort (Compare compare, Sort sort=Sort{}, Args &&... args)
     Sorts the pool of entities for the given component. More...
     
    template<typename To , typename From >
    void sort ()
     Sorts two pools of components in the same way. More...
     
    template<typename Component >
    void reset (const entity_type entity)
     Resets the given component for an entity. More...
     
    template<typename Component >
    void reset ()
     Resets the pool of the given component. More...
     
    void reset ()
     Resets a whole registry. More...
     
    template<typename Func >
    void each (Func func) const
     Iterates all the entities that are still in use. More...
     
    bool orphan (const entity_type entity) const
     Checks if an entity is an orphan. More...
     
    template<typename Func >
    void orphans (Func func) const
     Iterates orphans and applies them the given function object. More...
     
    template<typename... Component>
    View< Entity, Component... > view ()
     Returns a standard view for the given components. More...
     
    template<typename... Component>
    void prepare ()
     Prepares the internal data structures used by persistent views. More...
     
    template<typename... Component>
    void discard ()
     Discards all the data structures used for a given persitent view. More...
     
    template<typename... Component>
    bool contains () const ENTT_NOEXCEPT
     Checks if a persistent view has already been prepared. More...
     
    template<typename... Component>
    PersistentView< Entity, Component... > view (persistent_t)
     Returns a persistent view for the given components. More...
     
    template<typename Component >
    RawView< Entity, Component > view (raw_t)
     Returns a raw view for the given component. More...
     
    template<typename It >
    RuntimeView< Entity > view (It first, It last)
     Returns a runtime view for the given components. More...
     
    Snapshot< Entity > snapshot () const ENTT_NOEXCEPT
     Returns a temporary object to use to create snapshots. More...
     
    SnapshotLoader< Entity > restore () ENTT_NOEXCEPT
     Returns a temporary object to use to load snapshots. More...
     
    - - - - - - - - - -

    -Static Public Member Functions

    template<typename Tag >
    static tag_type type (tag_t) ENTT_NOEXCEPT
     Returns the numeric identifier of a type of tag at runtime. More...
     
    template<typename Component >
    static component_type type () ENTT_NOEXCEPT
     Returns the numeric identifier of a type of component at runtime. More...
     
    -

    Detailed Description

    -

    template<typename Entity>
    -class entt::Registry< Entity >

    - -

    Fast and reliable entity-component system.

    -

    Forward declaration of the registry class.

    -

    The registry is the core class of the entity-component framework.
    - It stores entities and arranges pools of components on a per request basis. By means of a registry, users can manage entities and components and thus create views to iterate them.

    -
    Template Parameters
    - - -
    EntityA valid entity type (see entt_traits for more details).
    -
    -
    - -

    Definition at line 42 of file registry.hpp.

    -

    Member Function Documentation

    - -

    ◆ accommodate()

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename Component , typename... Args>
    - - - - - -
    - - - - - - - - - - - - - - - - - - -
    Component& entt::Registry< Entity >::accommodate (const entity_type entity,
    Args &&... args 
    )
    -     		-inline
    -
    - -

    Assigns or replaces the given component for an entity.

    -

    Equivalent to the following snippet (pseudocode):

    -
    if(registry.has<Component>(entity)) {
    registry.replace<Component>(entity, args...);
    } else {
    registry.assign<Component>(entity, args...);
    }

    Prefer this function anyway because it has slightly better performance.

    -
    Warning
    Attempting to use an invalid entity results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode in case of invalid entity.
    -
    Template Parameters
    - - - -
    ComponentType of component to assign or replace.
    ArgsTypes of arguments to use to construct the component.
    -
    -
    -
    Parameters
    - - - -
    entityA valid entity identifier.
    argsParameters to use to initialize the component.
    -
    -
    -
    Returns
    A reference to the newly created component.
    - -

    Definition at line 994 of file registry.hpp.

    - -
    -
    - -

    ◆ alive()

    - -
    -
    -
    -template<typename Entity>
    - - - - - -
    - - - - - - - -
    size_type entt::Registry< Entity >::alive () const
    -     		-inline
    -
    - -

    Returns the number of entities still in use.

    -
    Returns
    Number of entities still in use.
    - -

    Definition at line 304 of file registry.hpp.

    - -
    -
    - -

    ◆ assign() [1/2]

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename Tag , typename... Args>
    - - - - - -
    - - - - - - - - - - - - - - - - - - - - - - - - -
    Tag& entt::Registry< Entity >::assign (tag_t ,
    const entity_type entity,
    Args &&... args 
    )
    -     		-inline
    -
    - -

    Attaches the given tag to an entity.

    -

    Usually, pools of components allocate enough memory to store a bunch of elements even if only one of them is used. On the other hand, there are cases where all what is needed is a single instance component to attach to an entity.
    - Tags are the right tool to achieve the purpose.

    -
    Warning
    Attempting to use an invalid entity or to attach to an entity a tag that already has an owner results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode in case of invalid entity or if the tag has been already attached to another entity.
    -
    Template Parameters
    - - - -
    TagType of tag to create.
    ArgsTypes of arguments to use to construct the tag.
    -
    -
    -
    Parameters
    - - - -
    entityA valid entity identifier.
    argsParameters to use to initialize the tag.
    -
    -
    -
    Returns
    A reference to the newly created tag.
    - -

    Definition at line 657 of file registry.hpp.

    - -
    -
    - -

    ◆ assign() [2/2]

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename Component , typename... Args>
    - - - - - -
    - - - - - - - - - - - - - - - - - - -
    Component& entt::Registry< Entity >::assign (const entity_type entity,
    Args &&... args 
    )
    -     		-inline
    -
    - -

    Assigns the given component to an entity.

    -

    A new instance of the given component is created and initialized with the arguments provided (the component must have a proper constructor or be of aggregate type). Then the component is assigned to the given entity.

    -
    Warning
    Attempting to use an invalid entity or to assign a component to an entity that already owns it results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode in case of invalid entity or if the entity already owns an instance of the given component.
    -
    Template Parameters
    - - - -
    ComponentType of component to create.
    ArgsTypes of arguments to use to construct the component.
    -
    -
    -
    Parameters
    - - - -
    entityA valid entity identifier.
    argsParameters to use to initialize the component.
    -
    -
    -
    Returns
    A reference to the newly created component.
    - -

    Definition at line 685 of file registry.hpp.

    - -
    -
    - -

    ◆ attachee()

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename Tag >
    - - - - - -
    - - - - - - - -
    entity_type entt::Registry< Entity >::attachee () const
    -     		-inline
    -
    - -

    Gets the owner of the given tag, if any.

    -
    Template Parameters
    - - -
    TagType of tag of which to get the owner.
    -
    -
    -
    Returns
    A valid entity identifier if an owner exists, the null entity identifier otherwise.
    - -

    Definition at line 963 of file registry.hpp.

    - -
    -
    - -

    ◆ capacity() [1/2]

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename Component >
    - - - - - -
    - - - - - - - -
    size_type entt::Registry< Entity >::capacity () const
    -     		-inline
    -
    - -

    Returns the capacity of the pool for the given component.

    -
    Template Parameters
    - - -
    ComponentType of component in which one is interested.
    -
    -
    -
    Returns
    Capacity of the pool of the given component.
    - -

    Definition at line 341 of file registry.hpp.

    - -
    -
    - -

    ◆ capacity() [2/2]

    - -
    -
    -
    -template<typename Entity>
    - - - - - -
    - - - - - - - -
    size_type entt::Registry< Entity >::capacity () const
    -     		-inline
    -
    - -

    Returns the number of entities that a registry has currently allocated space for.

    -
    Returns
    Capacity of the registry.
    - -

    Definition at line 350 of file registry.hpp.

    - -
    -
    - -

    ◆ construction() [1/2]

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename Tag >
    - - - - - -
    - - - - - - - - -
    sink_type entt::Registry< Entity >::construction (tag_t )
    -     		-inline
    -
    - -

    Returns a sink object for the given tag.

    -

    A sink is an opaque object used to connect listeners to tags.
    - The sink returned by this function can be used to receive notifications whenever a new instance of the given tag is created and assigned to an entity.

    -

    The function type for a listener is:

    void(Registry<Entity> &, Entity);

    Listeners are invoked after the tag has been assigned to the entity. The order of invocation of the listeners isn't guaranteed.
    - Note also that the greater the number of listeners, the greater the performance hit when a new tag is created.

    -
    See also
    SigH::Sink
    -
    Template Parameters
    - - -
    TagType of tag of which to get the sink.
    -
    -
    -
    Returns
    A temporary sink object.
    - -

    Definition at line 1027 of file registry.hpp.

    - -
    -
    - -

    ◆ construction() [2/2]

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename Component >
    - - - - - -
    - - - - - - - -
    sink_type entt::Registry< Entity >::construction ()
    -     		-inline
    -
    - -

    Returns a sink object for the given component.

    -

    A sink is an opaque object used to connect listeners to components.
    - The sink returned by this function can be used to receive notifications whenever a new instance of the given component is created and assigned to an entity.

    -

    The function type for a listener is:

    void(Registry<Entity> &, Entity);

    Listeners are invoked after the component has been assigned to the entity. The order of invocation of the listeners isn't guaranteed.
    - Note also that the greater the number of listeners, the greater the performance hit when a new component is created.

    -
    See also
    SigH::Sink
    -
    Template Parameters
    - - -
    ComponentType of component of which to get the sink.
    -
    -
    -
    Returns
    A temporary sink object.
    - -

    Definition at line 1056 of file registry.hpp.

    - -
    -
    - -

    ◆ contains()

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename... Component>
    - - - - - -
    - - - - - - - -
    bool entt::Registry< Entity >::contains () const
    -     		-inline
    -
    - -

    Checks if a persistent view has already been prepared.

    -
    Template Parameters
    - - -
    ComponentTypes of components of the persistent view.
    -
    -
    -
    Returns
    True if the view has already been prepared, false otherwise.
    - -

    Definition at line 1455 of file registry.hpp.

    - -
    -
    - -

    ◆ create()

    - -
    -
    -
    -template<typename Entity>
    - - - - - -
    - - - - - - - -
    entity_type entt::Registry< Entity >::create ()
    -     		-inline
    -
    - -

    Creates a new entity and returns it.

    -

    There are two kinds of entity identifiers:

    -
      -
    • Newly created ones in case no entities have been previously destroyed.
      • -
    • Recycled ones with updated versions.
      • -
    -

    Users should not care about the type of the returned entity identifier. In case entity identifers are stored around, the valid member function can be used to know if they are still valid or the entity has been destroyed and potentially recycled.

    -

    The returned entity has no components nor tags assigned.

    -
    Returns
    A valid entity identifier.
    - -

    Definition at line 521 of file registry.hpp.

    - -
    -
    - -

    ◆ current()

    - -
    -
    -
    -template<typename Entity>
    - - - - - -
    - - - - - - - - -
    version_type entt::Registry< Entity >::current (const entity_type entity) const
    -     		-inline
    -
    - -

    Returns the actual version for an entity identifier.

    -

    In case entity identifers are stored around, this function can be used to know if they are still valid or the entity has been destroyed and potentially recycled.

    -
    Warning
    Attempting to use an entity that doesn't belong to the registry results in undefined behavior. An entity belongs to the registry even if it has been previously destroyed and/or recycled.
    - An assertion will abort the execution at runtime in debug mode if the registry doesn't own the given entity.
    -
    Parameters
    - - -
    entityA valid entity identifier.
    -
    -
    -
    Returns
    Actual version for the given entity identifier.
    - -

    Definition at line 498 of file registry.hpp.

    - -
    -
    - -

    ◆ data()

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename Component >
    - - - - - -
    - - - - - - - -
    const entity_type* entt::Registry< Entity >::data () const
    -     		-inline
    -
    - -

    Direct access to the list of entities of a given pool.

    -

    The returned pointer is such that range [data<Component>(), data<Component>() + size<Component>()] is always a valid range, even if the container is empty.

    -
    Note
    There are no guarantees on the order of the entities. Use a view if you want to iterate entities and components in the expected order.
    -
    Template Parameters
    - - -
    ComponentType of component in which one is interested.
    -
    -
    -
    Returns
    A pointer to the array of entities.
    - -

    Definition at line 426 of file registry.hpp.

    - -
    -
    - -

    ◆ destroy() [1/3]

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename Tag >
    - - - - - -
    - - - - - - - - -
    void entt::Registry< Entity >::destroy (tag_t )
    -     		-inline
    -
    - -

    Destroys the entity that owns the given tag, if any.

    -

    Convenient shortcut to destroy an entity by means of a tag type.
    - Syntactic sugar for the following snippet:

    -
    if(registry.has<Tag>()) {
    registry.destroy(registry.attachee<Tag>());
    }
    Template Parameters
    - - -
    TagType of tag to use to search for the entity.
    -
    -
    - -

    Definition at line 556 of file registry.hpp.

    - -
    -
    - -

    ◆ destroy() [2/3]

    - -
    -
    -
    -template<typename Entity>
    - - - - - -
    - - - - - - - - -
    void entt::Registry< Entity >::destroy (const entity_type entity)
    -     		-inline
    -
    - -

    Destroys an entity and lets the registry recycle the identifier.

    -

    When an entity is destroyed, its version is updated and the identifier can be recycled at any time. In case entity identifers are stored around, the valid member function can be used to know if they are still valid or the entity has been destroyed and potentially recycled.

    -
    Warning
    In case there are listeners that observe the destruction of components and assign other components to the entity in their bodies, the result of invoking this function may not be as expected. In the worst case, it could lead to undefined behavior. An assertion will abort the execution at runtime in debug mode if a violation is detected.
    -
    -Attempting to use an invalid entity results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode in case of invalid entity.
    -
    Parameters
    - - -
    entityA valid entity identifier.
    -
    -
    - -

    Definition at line 582 of file registry.hpp.

    - -
    -
    - -

    ◆ destroy() [3/3]

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename... Component, typename... Type>
    - - - - - -
    - - - - - - - - -
    void entt::Registry< Entity >::destroy (Type... )
    -     		-inline
    -
    - -

    Destroys the entities that own the given components, if any.

    -

    Convenient shortcut to destroy a set of entities at once.
    - Syntactic sugar for the following snippet:

    -
    for(const auto entity: registry.view<Component...>(Type{}...)) {
    registry.destroy(entity);
    }
    Template Parameters
    - - - -
    ComponentTypes of components to use to search for the entities.
    TypeType of view to use or empty to use a standard view.
    -
    -
    - -

    Definition at line 629 of file registry.hpp.

    - -
    -
    - -

    ◆ destruction() [1/2]

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename Tag >
    - - - - - -
    - - - - - - - - -
    sink_type entt::Registry< Entity >::destruction (tag_t )
    -     		-inline
    -
    - -

    Returns a sink object for the given tag.

    -

    A sink is an opaque object used to connect listeners to tag.
    - The sink returned by this function can be used to receive notifications whenever an instance of the given tag is removed from an entity and thus destroyed.

    -

    The function type for a listener is:

    void(Registry<Entity> &, Entity);

    Listeners are invoked before the tag has been removed from the entity. The order of invocation of the listeners isn't guaranteed.
    - Note also that the greater the number of listeners, the greater the performance hit when a tag is destroyed.

    -
    See also
    SigH::Sink
    -
    Template Parameters
    - - -
    TagType of tag of which to get the sink.
    -
    -
    -
    Returns
    A temporary sink object.
    - -

    Definition at line 1085 of file registry.hpp.

    - -
    -
    - -

    ◆ destruction() [2/2]

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename Component >
    - - - - - -
    - - - - - - - -
    sink_type entt::Registry< Entity >::destruction ()
    -     		-inline
    -
    - -

    Returns a sink object for the given component.

    -

    A sink is an opaque object used to connect listeners to components.
    - The sink returned by this function can be used to receive notifications whenever an instance of the given component is removed from an entity and thus destroyed.

    -

    The function type for a listener is:

    void(Registry<Entity> &, Entity);

    Listeners are invoked before the component has been removed from the entity. The order of invocation of the listeners isn't guaranteed.
    - Note also that the greater the number of listeners, the greater the performance hit when a component is destroyed.

    -
    See also
    SigH::Sink
    -
    Template Parameters
    - - -
    ComponentType of component of which to get the sink.
    -
    -
    -
    Returns
    A temporary sink object.
    - -

    Definition at line 1114 of file registry.hpp.

    - -
    -
    - -

    ◆ discard()

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename... Component>
    - - - - - -
    - - - - - - - -
    void entt::Registry< Entity >::discard ()
    -     		-inline
    -
    - -

    Discards all the data structures used for a given persitent view.

    -

    Persistent views occupy memory, no matter if they are in use or not.
    - This function can be used to discard all the internal data structures dedicated to a specific persistent view, with the goal of reducing the memory pressure.

    -
    Warning
    Attempting to use a persistent view created before calling this function results in undefined behavior. No assertion available in this case, neither in debug mode nor in release mode.
    -
    Template Parameters
    - - -
    ComponentTypes of components of the persistent view.
    -
    -
    - -

    Definition at line 1442 of file registry.hpp.

    - -
    -
    - -

    ◆ each()

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename Func >
    - - - - - -
    - - - - - - - - -
    void entt::Registry< Entity >::each (Func func) const
    -     		-inline
    -
    - -

    Iterates all the entities that are still in use.

    -

    The function object is invoked for each entity that is still in use.
    - The signature of the function should be equivalent to the following:

    -
    void(const entity_type);

    This function is fairly slow and should not be used frequently.
    - Consider using a view if the goal is to iterate entities that have a determinate set of components. A view is usually faster than combining this function with a bunch of custom tests.
    - On the other side, this function can be used to iterate all the entities that are in use, regardless of their components.

    -
    Template Parameters
    - - -
    FuncType of the function object to invoke.
    -
    -
    -
    Parameters
    - - -
    funcA valid function object.
    -
    -
    - -

    Definition at line 1282 of file registry.hpp.

    - -
    -
    - -

    ◆ empty() [1/2]

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename Component >
    - - - - - -
    - - - - - - - -
    bool entt::Registry< Entity >::empty () const
    -     		-inline
    -
    - -

    Checks whether the pool of the given component is empty.

    -
    Template Parameters
    - - -
    ComponentType of component in which one is interested.
    -
    -
    -
    Returns
    True if the pool of the given component is empty, false otherwise.
    - -

    Definition at line 361 of file registry.hpp.

    - -
    -
    - -

    ◆ empty() [2/2]

    - -
    -
    -
    -template<typename Entity>
    - - - - - -
    - - - - - - - -
    bool entt::Registry< Entity >::empty () const
    -     		-inline
    -
    - -

    Checks if there exists at least an entity still in use.

    -
    Returns
    True if at least an entity is still in use, false otherwise.
    - -

    Definition at line 369 of file registry.hpp.

    - -
    -
    - -

    ◆ entity()

    - -
    -
    -
    -template<typename Entity>
    - - - - - -
    - - - - - - - - -
    entity_type entt::Registry< Entity >::entity (const entity_type entity) const
    -     		-inline
    -
    - -

    Returns the entity identifier without the version.

    -
    Parameters
    - - -
    entityAn entity identifier, either valid or not.
    -
    -
    -
    Returns
    The entity identifier without the version.
    - -

    Definition at line 468 of file registry.hpp.

    - -
    -
    - -

    ◆ fast()

    - -
    -
    -
    -template<typename Entity>
    - - - - - -
    - - - - - - - - -
    bool entt::Registry< Entity >::fast (const entity_type entity) const
    -     		-inline
    -
    - -

    Checks if an entity identifier refers to a valid entity.

    -

    Alternative version of valid. It accesses the internal data structures without bounds checking and thus it's both unsafe and risky to use.
    - You should not invoke directly this function unless you know exactly what you are doing. Prefer the valid member function instead.

    -
    Warning
    Attempting to use an entity that doesn't belong to the registry can result in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode in case of bounds violation.
    -
    Parameters
    - - -
    entityA valid entity identifier.
    -
    -
    -
    Returns
    True if the identifier is valid, false otherwise.
    - -

    Definition at line 457 of file registry.hpp.

    - -
    -
    - -

    ◆ get() [1/6]

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename Tag >
    - - - - - -
    - - - - - - - -
    const Tag& entt::Registry< Entity >::get () const
    -     		-inline
    -
    - -

    Returns a reference to the given tag.

    -
    Warning
    Attempting to get a tag that hasn't an owner results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode if the tag hasn't been previously attached to an entity.
    -
    Template Parameters
    - - -
    TagType of tag to get.
    -
    -
    -
    Returns
    A reference to the tag.
    - -

    Definition at line 783 of file registry.hpp.

    - -
    -
    - -

    ◆ get() [2/6]

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename Tag >
    - - - - - -
    - - - - - - - -
    Tag& entt::Registry< Entity >::get ()
    -     		-inline
    -
    - -

    Returns a reference to the given tag.

    -
    Warning
    Attempting to get a tag that hasn't an owner results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode if the tag hasn't been previously attached to an entity.
    -
    Template Parameters
    - - -
    TagType of tag to get.
    -
    -
    -
    Returns
    A reference to the tag.
    - -

    Definition at line 801 of file registry.hpp.

    - -
    -
    - -

    ◆ get() [3/6]

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename Component >
    - - - - - -
    - - - - - - - - -
    const Component& entt::Registry< Entity >::get (const entity_type entity) const
    -     		-inline
    -
    - -

    Returns a reference to the given component for an entity.

    -
    Warning
    Attempting to use an invalid entity or to get a component from an entity that doesn't own it results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode in case of invalid entity or if the entity doesn't own an instance of the given component.
    -
    Template Parameters
    - - -
    ComponentType of component to get.
    -
    -
    -
    Parameters
    - - -
    entityA valid entity identifier.
    -
    -
    -
    Returns
    A reference to the component owned by the entity.
    - -

    Definition at line 820 of file registry.hpp.

    - -
    -
    - -

    ◆ get() [4/6]

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename Component >
    - - - - - -
    - - - - - - - - -
    Component& entt::Registry< Entity >::get (const entity_type entity)
    -     		-inline
    -
    - -

    Returns a reference to the given component for an entity.

    -
    Warning
    Attempting to use an invalid entity or to get a component from an entity that doesn't own it results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode in case of invalid entity or if the entity doesn't own an instance of the given component.
    -
    Template Parameters
    - - -
    ComponentType of component to get.
    -
    -
    -
    Parameters
    - - -
    entityA valid entity identifier.
    -
    -
    -
    Returns
    A reference to the component owned by the entity.
    - -

    Definition at line 841 of file registry.hpp.

    - -
    -
    - -

    ◆ get() [5/6]

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename... Component>
    - - - - - -
    - - - - - - - - -
    std::enable_if_t<(sizeof...(Component) > 1), std::tuple<const Component &...> > entt::Registry< Entity >::get (const entity_type entity) const
    -     		-inline
    -
    - -

    Returns a reference to the given components for an entity.

    -
    Warning
    Attempting to use an invalid entity or to get components from an entity that doesn't own them results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode in case of invalid entity or if the entity doesn't own instances of the given components.
    -
    Template Parameters
    - - -
    ComponentType of components to get.
    -
    -
    -
    Parameters
    - - -
    entityA valid entity identifier.
    -
    -
    -
    Returns
    References to the components owned by the entity.
    - -

    Definition at line 861 of file registry.hpp.

    - -
    -
    - -

    ◆ get() [6/6]

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename... Component>
    - - - - - -
    - - - - - - - - -
    std::enable_if_t<(sizeof...(Component) > 1), std::tuple<Component &...> > entt::Registry< Entity >::get (const entity_type entity)
    -     		-inline
    -
    - -

    Returns a reference to the given components for an entity.

    -
    Warning
    Attempting to use an invalid entity or to get components from an entity that doesn't own them results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode in case of invalid entity or if the entity doesn't own instances of the given components.
    -
    Template Parameters
    - - -
    ComponentType of components to get.
    -
    -
    -
    Parameters
    - - -
    entityA valid entity identifier.
    -
    -
    -
    Returns
    References to the components owned by the entity.
    - -

    Definition at line 881 of file registry.hpp.

    - -
    -
    - -

    ◆ has() [1/3]

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename Tag >
    - - - - - -
    - - - - - - - -
    bool entt::Registry< Entity >::has () const
    -     		-inline
    -
    - -

    Checks if the given tag has an owner.

    -
    Template Parameters
    - - -
    TagType of tag for which to perform the check.
    -
    -
    -
    Returns
    True if the tag already has an owner, false otherwise.
    - -

    Definition at line 726 of file registry.hpp.

    - -
    -
    - -

    ◆ has() [2/3]

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename Tag >
    - - - - - -
    - - - - - - - - - - - - - - - - - - -
    bool entt::Registry< Entity >::has (tag_t ,
    const entity_type entity 
    ) const
    -     		-inline
    -
    - -

    Checks if an entity owns the given tag.

    -

    Syntactic sugar for the following snippet:

    -
    registry.has<Tag>() && registry.attachee<Tag>() == entity
    Template Parameters
    - - -
    TagType of tag for which to perform the check.
    -
    -
    -
    Parameters
    - - -
    entityA valid entity identifier.
    -
    -
    -
    Returns
    True if the entity owns the tag, false otherwise.
    - -

    Definition at line 744 of file registry.hpp.

    - -
    -
    - -

    ◆ has() [3/3]

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename... Component>
    - - - - - -
    - - - - - - - - -
    bool entt::Registry< Entity >::has (const entity_type entity) const
    -     		-inline
    -
    - -

    Checks if an entity has all the given components.

    -
    Warning
    Attempting to use an invalid entity results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode in case of invalid entity.
    -
    Template Parameters
    - - -
    ComponentComponents for which to perform the check.
    -
    -
    -
    Parameters
    - - -
    entityA valid entity identifier.
    -
    -
    -
    Returns
    True if the entity has all the components, false otherwise.
    - -

    Definition at line 761 of file registry.hpp.

    - -
    -
    - -

    ◆ move()

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename Tag >
    - - - - - -
    - - - - - - - - -
    entity_type entt::Registry< Entity >::move (const entity_type entity)
    -     		-inline
    -
    - -

    Changes the owner of the given tag.

    -

    The ownership of the tag is transferred from one entity to another.

    -
    Warning
    Attempting to use an invalid entity or to transfer the ownership of a tag that hasn't an owner results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode in case of invalid entity or if the tag hasn't been previously attached to an entity.
    -
    Template Parameters
    - - -
    TagType of tag of which to transfer the ownership.
    -
    -
    -
    Parameters
    - - -
    entityA valid entity identifier.
    -
    -
    -
    Returns
    A valid entity identifier.
    - -

    Definition at line 950 of file registry.hpp.

    - -
    -
    - -

    ◆ operator=() [1/2]

    - -
    -
    -
    -template<typename Entity>
    - - - - - -
    - - - - - - - - -
    Registry& entt::Registry< Entity >::operator= (const Registry< Entity > & )
    -     		-delete
    -
    - -

    Copying a registry isn't allowed.

    -
    Returns
    This registry.
    - -
    -
    - -

    ◆ operator=() [2/2]

    - -
    -
    -
    -template<typename Entity>
    - - - - - -
    - - - - - - - - -
    Registry& entt::Registry< Entity >::operator= (Registry< Entity > && )
    -     		-default
    -
    - -

    Default move assignment operator.

    -
    Returns
    This registry.
    - -
    -
    - -

    ◆ orphan()

    - -
    -
    -
    -template<typename Entity>
    - - - - - -
    - - - - - - - - -
    bool entt::Registry< Entity >::orphan (const entity_type entity) const
    -     		-inline
    -
    - -

    Checks if an entity is an orphan.

    -

    An orphan is an entity that has neither assigned components nor tags.

    -
    Parameters
    - - -
    entityA valid entity identifier.
    -
    -
    -
    Returns
    True if the entity is an orphan, false otherwise.
    - -

    Definition at line 1309 of file registry.hpp.

    - -
    -
    - -

    ◆ orphans()

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename Func >
    - - - - - -
    - - - - - - - - -
    void entt::Registry< Entity >::orphans (Func func) const
    -     		-inline
    -
    - -

    Iterates orphans and applies them the given function object.

    -

    The function object is invoked for each entity that is still in use and has neither assigned components nor tags.
    - The signature of the function should be equivalent to the following:

    -
    void(const entity_type);

    This function can be very slow and should not be used frequently.

    -
    Template Parameters
    - - -
    FuncType of the function object to invoke.
    -
    -
    -
    Parameters
    - - -
    funcA valid function object.
    -
    -
    - -

    Definition at line 1343 of file registry.hpp.

    - -
    -
    - -

    ◆ prepare()

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename... Component>
    - - - - - -
    - - - - - - - -
    void entt::Registry< Entity >::prepare ()
    -     		-inline
    -
    - -

    Prepares the internal data structures used by persistent views.

    -

    Persistent views are an incredibly fast tool used to iterate a packed array of entities all of which have specific components.
    - The initialization of a persistent view is also a pretty cheap operation, but for the first time they are created. That's mainly because of the internal data structures of the registry that are dedicated to this kind of views and that don't exist yet the very first time they are requested.
    - To avoid costly operations, internal data structures for persistent views can be prepared with this function. Just use the same set of components that would have been used otherwise to construct the view.

    -
    Template Parameters
    - - -
    ComponentTypes of components used to prepare the view.
    -
    -
    - -

    Definition at line 1407 of file registry.hpp.

    - -
    -
    - -

    ◆ raw() [1/2]

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename Component >
    - - - - - -
    - - - - - - - -
    const Component* entt::Registry< Entity >::raw () const
    -     		-inline
    -
    - -

    Direct access to the list of components of a given pool.

    -

    The returned pointer is such that range [raw<Component>(), raw<Component>() + size<Component>()] is always a valid range, even if the container is empty.

    -
    Note
    There are no guarantees on the order of the components. Use a view if you want to iterate entities and components in the expected order.
    -
    Template Parameters
    - - -
    ComponentType of component in which one is interested.
    -
    -
    -
    Returns
    A pointer to the array of components of the given type.
    - -

    Definition at line 388 of file registry.hpp.

    - -
    -
    - -

    ◆ raw() [2/2]

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename Component >
    - - - - - -
    - - - - - - - -
    Component* entt::Registry< Entity >::raw ()
    -     		-inline
    -
    - -

    Direct access to the list of components of a given pool.

    -

    The returned pointer is such that range [raw<Component>(), raw<Component>() + size<Component>()] is always a valid range, even if the container is empty.

    -
    Note
    There are no guarantees on the order of the components. Use a view if you want to iterate entities and components in the expected order.
    -
    Template Parameters
    - - -
    ComponentType of component in which one is interested.
    -
    -
    -
    Returns
    A pointer to the array of components of the given type.
    - -

    Definition at line 407 of file registry.hpp.

    - -
    -
    - -

    ◆ remove() [1/2]

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename Tag >
    - - - - - -
    - - - - - - - -
    void entt::Registry< Entity >::remove ()
    -     		-inline
    -
    - -

    Removes the given tag from its owner, if any.

    -
    Template Parameters
    - - -
    TagType of tag to remove.
    -
    -
    - -

    Definition at line 696 of file registry.hpp.

    - -
    -
    - -

    ◆ remove() [2/2]

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename Component >
    - - - - - -
    - - - - - - - - -
    void entt::Registry< Entity >::remove (const entity_type entity)
    -     		-inline
    -
    - -

    Removes the given component from an entity.

    -
    Warning
    Attempting to use an invalid entity or to remove a component from an entity that doesn't own it results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode in case of invalid entity or if the entity doesn't own an instance of the given component.
    -
    Template Parameters
    - - -
    ComponentType of component to remove.
    -
    -
    -
    Parameters
    - - -
    entityA valid entity identifier.
    -
    -
    - -

    Definition at line 714 of file registry.hpp.

    - -
    -
    - -

    ◆ replace() [1/2]

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename Tag , typename... Args>
    - - - - - -
    - - - - - - - - - - - - - - - - - - -
    Tag& entt::Registry< Entity >::replace (tag_t ,
    Args &&... args 
    )
    -     		-inline
    -
    - -

    Replaces the given tag.

    -

    A new instance of the given tag is created and initialized with the arguments provided (the tag must have a proper constructor or be of aggregate type).

    -
    Warning
    Attempting to replace a tag that hasn't an owner results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode if the tag hasn't been previously attached to an entity.
    -
    Template Parameters
    - - - -
    TagType of tag to replace.
    ArgsTypes of arguments to use to construct the tag.
    -
    -
    -
    Parameters
    - - -
    argsParameters to use to initialize the tag.
    -
    -
    -
    Returns
    A reference to the tag.
    - -

    Definition at line 904 of file registry.hpp.

    - -
    -
    - -

    ◆ replace() [2/2]

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename Component , typename... Args>
    - - - - - -
    - - - - - - - - - - - - - - - - - - -
    Component& entt::Registry< Entity >::replace (const entity_type entity,
    Args &&... args 
    )
    -     		-inline
    -
    - -

    Replaces the given component for an entity.

    -

    A new instance of the given component is created and initialized with the arguments provided (the component must have a proper constructor or be of aggregate type). Then the component is assigned to the given entity.

    -
    Warning
    Attempting to use an invalid entity or to replace a component of an entity that doesn't own it results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode in case of invalid entity or if the entity doesn't own an instance of the given component.
    -
    Template Parameters
    - - - -
    ComponentType of component to replace.
    ArgsTypes of arguments to use to construct the component.
    -
    -
    -
    Parameters
    - - - -
    entityA valid entity identifier.
    argsParameters to use to initialize the component.
    -
    -
    -
    Returns
    A reference to the newly created component.
    - -

    Definition at line 929 of file registry.hpp.

    - -
    -
    - -

    ◆ reserve() [1/2]

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename Component >
    - - - - - -
    - - - - - - - - -
    void entt::Registry< Entity >::reserve (const size_type cap)
    -     		-inline
    -
    - -

    Increases the capacity of the pool for the given component.

    -

    If the new capacity is greater than the current capacity, new storage is allocated, otherwise the method does nothing.

    -
    Template Parameters
    - - -
    ComponentType of component for which to reserve storage.
    -
    -
    -
    Parameters
    - - -
    capDesired capacity.
    -
    -
    - -

    Definition at line 318 of file registry.hpp.

    - -
    -
    - -

    ◆ reserve() [2/2]

    - -
    -
    -
    -template<typename Entity>
    - - - - - -
    - - - - - - - - -
    void entt::Registry< Entity >::reserve (const size_type cap)
    -     		-inline
    -
    - -

    Increases the capacity of a registry in terms of entities.

    -

    If the new capacity is greater than the current capacity, new storage is allocated, otherwise the method does nothing.

    -
    Parameters
    - - -
    capDesired capacity.
    -
    -
    - -

    Definition at line 331 of file registry.hpp.

    - -
    -
    - -

    ◆ reset() [1/3]

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename Component >
    - - - - - -
    - - - - - - - - -
    void entt::Registry< Entity >::reset (const entity_type entity)
    -     		-inline
    -
    - -

    Resets the given component for an entity.

    -

    If the entity has an instance of the component, this function removes the component from the entity. Otherwise it does nothing.

    -
    Warning
    Attempting to use an invalid entity results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode in case of invalid entity.
    -
    Template Parameters
    - - -
    ComponentType of component to reset.
    -
    -
    -
    Parameters
    - - -
    entityA valid entity identifier.
    -
    -
    - -

    Definition at line 1218 of file registry.hpp.

    - -
    -
    - -

    ◆ reset() [2/3]

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename Component >
    - - - - - -
    - - - - - - - -
    void entt::Registry< Entity >::reset ()
    -     		-inline
    -
    - -

    Resets the pool of the given component.

    -

    For each entity that has an instance of the given component, the component itself is removed and thus destroyed.

    -
    Template Parameters
    - - -
    ComponentType of component whose pool must be reset.
    -
    -
    - -

    Definition at line 1237 of file registry.hpp.

    - -
    -
    - -

    ◆ reset() [3/3]

    - -
    -
    -
    -template<typename Entity>
    - - - - - -
    - - - - - - - -
    void entt::Registry< Entity >::reset ()
    -     		-inline
    -
    - -

    Resets a whole registry.

    -

    Destroys all the entities. After a call to reset, all the entities still in use are recycled with a new version number. In case entity identifers are stored around, the valid member function can be used to know if they are still valid.

    - -

    Definition at line 1254 of file registry.hpp.

    - -
    -
    - -

    ◆ restore()

    - -
    -
    -
    -template<typename Entity>
    - - - - - -
    - - - - - - - -
    SnapshotLoader<Entity> entt::Registry< Entity >::restore ()
    -     		-inline
    -
    - -

    Returns a temporary object to use to load snapshots.

    -

    A snapshot is either a full or a partial dump of a registry.
    - It can be used to save and restore its internal state or to keep two or more instances of this class in sync, as an example in a client-server architecture.

    -
    Warning
    The loader returned by this function requires that the registry be empty. In case it isn't, all the data will be automatically deleted before to return.
    -
    Returns
    A temporary object to use to load snasphosts.
    - -

    Definition at line 1613 of file registry.hpp.

    - -
    -
    - -

    ◆ size() [1/2]

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename Component >
    - - - - - -
    - - - - - - - -
    size_type entt::Registry< Entity >::size () const
    -     		-inline
    -
    - -

    Returns the number of existing components of the given type.

    -
    Template Parameters
    - - -
    ComponentType of component of which to return the size.
    -
    -
    -
    Returns
    Number of existing components of the given type.
    - -

    Definition at line 288 of file registry.hpp.

    - -
    -
    - -

    ◆ size() [2/2]

    - -
    -
    -
    -template<typename Entity>
    - - - - - -
    - - - - - - - -
    size_type entt::Registry< Entity >::size () const
    -     		-inline
    -
    - -

    Returns the number of entities created so far.

    -
    Returns
    Number of entities created so far.
    - -

    Definition at line 296 of file registry.hpp.

    - -
    -
    - -

    ◆ snapshot()

    - -
    -
    -
    -template<typename Entity>
    - - - - - -
    - - - - - - - -
    Snapshot<Entity> entt::Registry< Entity >::snapshot () const
    -     		-inline
    -
    - -

    Returns a temporary object to use to create snapshots.

    -

    A snapshot is either a full or a partial dump of a registry.
    - It can be used to save and restore its internal state or to keep two or more instances of this class in sync, as an example in a client-server architecture.

    -
    Returns
    A temporary object to use to take snasphosts.
    - -

    Definition at line 1584 of file registry.hpp.

    - -
    -
    - -

    ◆ sort() [1/2]

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename Component , typename Compare , typename Sort = StdSort, typename... Args>
    - - - - - -
    - - - - - - - - - - - - - - - - - - - - - - - - -
    void entt::Registry< Entity >::sort (Compare compare,
    Sort sort = Sort{},
    Args &&... args 
    )
    -     		-inline
    -
    - -

    Sorts the pool of entities for the given component.

    -

    The order of the elements in a pool is highly affected by assignments of components to entities and deletions. Components are arranged to maximize the performance during iterations and users should not make any assumption on the order.
    - This function can be used to impose an order to the elements in the pool of the given component. The order is kept valid until a component of the given type is assigned or removed from an entity.

    -

    The comparison function object must return true if the first element is less than the second one, false otherwise. The signature of the comparison function should be equivalent to the following:

    -
    bool(const Component &, const Component &)

    Moreover, the comparison function object shall induce a strict weak ordering on the values.

    -

    The sort function oject must offer a member function template operator() that accepts three arguments:

    -
      -
    • An iterator to the first element of the range to sort.
      • -
    • An iterator past the last element of the range to sort.
      • -
    • A comparison function to use to compare the elements.
      • -
    -

    The comparison funtion object received by the sort function object hasn't necessarily the type of the one passed along with the other parameters to this member function.

    -
    Template Parameters
    - - - - - -
    ComponentType of components to sort.
    CompareType of comparison function object.
    SortType of sort function object.
    ArgsTypes of arguments to forward to the sort function object.
    -
    -
    -
    Parameters
    - - - - -
    compareA valid comparison function object.
    sortA valid sort function object.
    argsArguments to forward to the sort function object, if any.
    -
    -
    - -

    Definition at line 1161 of file registry.hpp.

    - -
    -
    - -

    ◆ sort() [2/2]

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename To , typename From >
    - - - - - -
    - - - - - - - -
    void entt::Registry< Entity >::sort ()
    -     		-inline
    -
    - -

    Sorts two pools of components in the same way.

    -

    The order of the elements in a pool is highly affected by assignments of components to entities and deletions. Components are arranged to maximize the performance during iterations and users should not make any assumption on the order.

    -

    It happens that different pools of components must be sorted the same way because of runtime and/or performance constraints. This function can be used to order a pool of components according to the order between the entities in another pool of components.

    -

    How it works

    -

    Being A and B the two sets where B is the master (the one the order of which rules) and A is the slave (the one to sort), after a call to this function an iterator for A will return the entities according to the following rules:

    -
      -
    • All the entities in A that are also in B are returned first according to the order they have in B.
      • -
    • All the entities in A that are not in B are returned in no particular order after all the other entities.
      • -
    -

    Any subsequent change to B won't affect the order in A.

    -
    Template Parameters
    - - - -
    ToType of components to sort.
    FromType of components to use to sort.
    -
    -
    - -

    Definition at line 1197 of file registry.hpp.

    - -
    -
    - -

    ◆ type() [1/2]

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename Tag >
    - - - - - -
    - - - - - - - - -
    static tag_type entt::Registry< Entity >::type (tag_t )
    -     		-inlinestatic
    -
    - -

    Returns the numeric identifier of a type of tag at runtime.

    -

    The given tag doesn't need to be necessarily in use. However, the registry could decide to prepare internal data structures for it for later uses.
    - Do not use this functionality to provide numeric identifiers to types at runtime.

    -
    Template Parameters
    - - -
    TagType of tag to query.
    -
    -
    -
    Returns
    Runtime numeric identifier of the given type of tag.
    - -

    Definition at line 261 of file registry.hpp.

    - -
    -
    - -

    ◆ type() [2/2]

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename Component >
    - - - - - -
    - - - - - - - -
    static component_type entt::Registry< Entity >::type ()
    -     		-inlinestatic
    -
    - -

    Returns the numeric identifier of a type of component at runtime.

    -

    The given component doesn't need to be necessarily in use. However, the registry could decide to prepare internal data structures for it for later uses.
    - Do not use this functionality to provide numeric identifiers to types at runtime.

    -
    Template Parameters
    - - -
    ComponentType of component to query.
    -
    -
    -
    Returns
    Runtime numeric identifier of the given type of component.
    - -

    Definition at line 278 of file registry.hpp.

    - -
    -
    - -

    ◆ valid()

    - -
    -
    -
    -template<typename Entity>
    - - - - - -
    - - - - - - - - -
    bool entt::Registry< Entity >::valid (const entity_type entity) const
    -     		-inline
    -
    - -

    Checks if an entity identifier refers to a valid entity.

    -
    Parameters
    - - -
    entityAn entity identifier, either valid or not.
    -
    -
    -
    Returns
    True if the identifier is valid, false otherwise.
    - -

    Definition at line 435 of file registry.hpp.

    - -
    -
    - -

    ◆ version()

    - -
    -
    -
    -template<typename Entity>
    - - - - - -
    - - - - - - - - -
    version_type entt::Registry< Entity >::version (const entity_type entity) const
    -     		-inline
    -
    - -

    Returns the version stored along with an entity identifier.

    -
    Parameters
    - - -
    entityAn entity identifier, either valid or not.
    -
    -
    -
    Returns
    The version stored along with the given entity identifier.
    - -

    Definition at line 477 of file registry.hpp.

    - -
    -
    - -

    ◆ view() [1/4]

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename... Component>
    - - - - - -
    - - - - - - - -
    View<Entity, Component...> entt::Registry< Entity >::view ()
    -     		-inline
    -
    - -

    Returns a standard view for the given components.

    -

    This kind of views are created on the fly and share with the registry its internal data structures.
    - Feel free to discard a view after the use. Creating and destroying a view is an incredibly cheap operation because they do not require any type of initialization.
    - As a rule of thumb, storing a view should never be an option.

    -

    Standard views do their best to iterate the smallest set of candidate entities. In particular:

    -
      -
    • Single component views are incredibly fast and iterate a packed array of entities, all of which has the given component.
      • -
    • Multi component views look at the number of entities available for each component and pick up a reference to the smallest set of candidates to test for the given components.
      • -
    -
    Note
    Multi component views are pretty fast. However their performance tend to degenerate when the number of components to iterate grows up and the most of the entities have all the given components.
    - To get a performance boost, consider using a PersistentView instead.
    -
    See also
    View
    -
    -View<Entity, Component>
    -
    -PersistentView
    -
    -RawView
    -
    -RuntimeView
    -
    Template Parameters
    - - -
    ComponentType of components used to construct the view.
    -
    -
    -
    Returns
    A newly created standard view.
    - -

    Definition at line 1386 of file registry.hpp.

    - -
    -
    - -

    ◆ view() [2/4]

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename... Component>
    - - - - - -
    - - - - - - - - -
    PersistentView<Entity, Component...> entt::Registry< Entity >::view (persistent_t )
    -     		-inline
    -
    - -

    Returns a persistent view for the given components.

    -

    This kind of views are created on the fly and share with the registry its internal data structures.
    - Feel free to discard a view after the use. Creating and destroying a view is an incredibly cheap operation because they do not require any type of initialization.
    - As a rule of thumb, storing a view should never be an option.

    -

    Persistent views are the right choice to iterate entities when the number of components grows up and the most of the entities have all the given components.
    - However they have also drawbacks:

    -
      -
    • Each kind of persistent view requires a dedicated data structure that is allocated within the registry and it increases memory pressure.
      • -
    • Internal data structures used to construct persistent views must be kept updated and it affects slightly construction and destruction of entities and components.
      • -
    -

    That being said, persistent views are an incredibly powerful tool if used with care and offer a boost of performance undoubtedly.

    -
    Note
    Consider to use the prepare member function to initialize the internal data structures used by persistent views when the registry is still empty. Initialization could be a costly operation otherwise and it will be performed the very first time each view is created.
    -
    See also
    View
    -
    -View<Entity, Component>
    -
    -PersistentView
    -
    -RawView
    -
    -RuntimeView
    -
    Template Parameters
    - - -
    ComponentTypes of components used to construct the view.
    -
    -
    -
    Returns
    A newly created persistent view.
    - -

    Definition at line 1501 of file registry.hpp.

    - -
    -
    - -

    ◆ view() [3/4]

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename Component >
    - - - - - -
    - - - - - - - - -
    RawView<Entity, Component> entt::Registry< Entity >::view (raw_t )
    -     		-inline
    -
    - -

    Returns a raw view for the given component.

    -

    This kind of views are created on the fly and share with the registry its internal data structures.
    - Feel free to discard a view after the use. Creating and destroying a view is an incredibly cheap operation because they do not require any type of initialization.
    - As a rule of thumb, storing a view should never be an option.

    -

    Raw views are incredibly fast and must be considered the best tool to iterate components whenever knowing the entities to which they belong isn't required.

    -
    See also
    View
    -
    -View<Entity, Component>
    -
    -PersistentView
    -
    -RawView
    -
    -RuntimeView
    -
    Template Parameters
    - - -
    ComponentType of component used to construct the view.
    -
    -
    -
    Returns
    A newly created raw view.
    - -

    Definition at line 1531 of file registry.hpp.

    - -
    -
    - -

    ◆ view() [4/4]

    - -
    -
    -
    -template<typename Entity>
    -
    -template<typename It >
    - - - - - -
    - - - - - - - - - - - - - - - - - - -
    RuntimeView<Entity> entt::Registry< Entity >::view (It first,
    It last 
    )
    -     		-inline
    -
    - -

    Returns a runtime view for the given components.

    -

    This kind of views are created on the fly and share with the registry its internal data structures.
    - Users should throw away the view after use. Fortunately, creating and destroying a view is an incredibly cheap operation because they do not require any type of initialization.
    - As a rule of thumb, storing a view should never be an option.

    -

    Runtime views are well suited when users want to construct a view from some external inputs and don't know at compile-time what are the required components.
    - This is particularly well suited to plugin systems and mods in general.

    -
    See also
    View
    -
    -View<Entity, Component>
    -
    -PersistentView
    -
    -RawView
    -
    -RuntimeView
    -
    Template Parameters
    - - -
    ItType of forward iterator.
    -
    -
    -
    Parameters
    - - - -
    firstAn iterator to the first element of the range of components.
    lastAn iterator past the last element of the range of components.
    -
    -
    -
    Returns
    A newly created runtime view.
    - -

    Definition at line 1563 of file registry.hpp.

    - -
    -
    -
    The documentation for this class was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1ResourceCache-members.html b/classentt_1_1ResourceCache-members.html deleted file mode 100644 index 5926cbd25..000000000 --- a/classentt_1_1ResourceCache-members.html +++ /dev/null @@ -1,97 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::ResourceCache< Resource > Member List
    -
    -
    - -

    This is the complete list of members for entt::ResourceCache< Resource >, including all inherited members.

    - - - - - - - - - - - - - - - - - -
    clear() ENTT_NOEXCEPTentt::ResourceCache< Resource >inline
    contains(const resource_type id) const ENTT_NOEXCEPTentt::ResourceCache< Resource >inline
    discard(const resource_type id) ENTT_NOEXCEPTentt::ResourceCache< Resource >inline
    empty() const ENTT_NOEXCEPTentt::ResourceCache< Resource >inline
    handle(const resource_type id) constentt::ResourceCache< Resource >inline
    load(const resource_type id, Args &&... args)entt::ResourceCache< Resource >inline
    operator=(const ResourceCache &) ENTT_NOEXCEPT=deleteentt::ResourceCache< Resource >
    operator=(ResourceCache &&) ENTT_NOEXCEPT=defaultentt::ResourceCache< Resource >
    reload(const resource_type id, Args &&... args)entt::ResourceCache< Resource >inline
    resource_type typedefentt::ResourceCache< Resource >
    ResourceCache()=defaultentt::ResourceCache< Resource >
    ResourceCache(const ResourceCache &) ENTT_NOEXCEPT=deleteentt::ResourceCache< Resource >
    ResourceCache(ResourceCache &&) ENTT_NOEXCEPT=defaultentt::ResourceCache< Resource >
    size() const ENTT_NOEXCEPTentt::ResourceCache< Resource >inline
    size_type typedefentt::ResourceCache< Resource >
    temp(Args &&... args) constentt::ResourceCache< Resource >inline
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1ResourceHandle-members.html b/classentt_1_1ResourceHandle-members.html deleted file mode 100644 index ddd8a7b34..000000000 --- a/classentt_1_1ResourceHandle-members.html +++ /dev/null @@ -1,91 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::ResourceHandle< Resource > Member List
    -
    -
    - -

    This is the complete list of members for entt::ResourceHandle< Resource >, including all inherited members.

    - - - - - - - - - - - -
    get() const ENTT_NOEXCEPTentt::ResourceHandle< Resource >inline
    operator bool() constentt::ResourceHandle< Resource >inlineexplicit
    operator const Resource &() const ENTT_NOEXCEPTentt::ResourceHandle< Resource >inline
    operator*() const ENTT_NOEXCEPTentt::ResourceHandle< Resource >inline
    operator->() const ENTT_NOEXCEPTentt::ResourceHandle< Resource >inline
    operator=(const ResourceHandle &) ENTT_NOEXCEPT=defaultentt::ResourceHandle< Resource >
    operator=(ResourceHandle &&) ENTT_NOEXCEPT=defaultentt::ResourceHandle< Resource >
    ResourceCache< Resource > classentt::ResourceHandle< Resource >friend
    ResourceHandle(const ResourceHandle &) ENTT_NOEXCEPT=defaultentt::ResourceHandle< Resource >
    ResourceHandle(ResourceHandle &&) ENTT_NOEXCEPT=defaultentt::ResourceHandle< Resource >
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1RuntimeView-members.html b/classentt_1_1RuntimeView-members.html deleted file mode 100644 index 54314c300..000000000 --- a/classentt_1_1RuntimeView-members.html +++ /dev/null @@ -1,96 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::RuntimeView< Entity > Member List
    -
    -
    - -

    This is the complete list of members for entt::RuntimeView< Entity >, including all inherited members.

    - - - - - - - - - - - - - - - - -
    begin() const ENTT_NOEXCEPTentt::RuntimeView< Entity >inline
    begin() ENTT_NOEXCEPTentt::RuntimeView< Entity >inline
    cbegin() const ENTT_NOEXCEPTentt::RuntimeView< Entity >inline
    cend() const ENTT_NOEXCEPTentt::RuntimeView< Entity >inline
    const_iterator_type typedefentt::RuntimeView< Entity >
    contains(const entity_type entity) const ENTT_NOEXCEPTentt::RuntimeView< Entity >inline
    each(Func func) constentt::RuntimeView< Entity >inline
    empty() const ENTT_NOEXCEPTentt::RuntimeView< Entity >inline
    end() const ENTT_NOEXCEPTentt::RuntimeView< Entity >inline
    end() ENTT_NOEXCEPTentt::RuntimeView< Entity >inline
    entity_type typedefentt::RuntimeView< Entity >
    iterator_type typedefentt::RuntimeView< Entity >
    Registry< Entity > classentt::RuntimeView< Entity >friend
    size() const ENTT_NOEXCEPTentt::RuntimeView< Entity >inline
    size_type typedefentt::RuntimeView< Entity >
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1RuntimeView.html b/classentt_1_1RuntimeView.html deleted file mode 100644 index 2e93ddb34..000000000 --- a/classentt_1_1RuntimeView.html +++ /dev/null @@ -1,540 +0,0 @@ - - - - - - - -EnTT: entt::RuntimeView< Entity > Class Template Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Classes | -Public Types | -Public Member Functions | -Friends | -List of all members
    -
    -
    entt::RuntimeView< Entity > Class Template Reference
    -
    -
    - -

    Runtime view. - More...

    - -

    #include <view.hpp>

    - - - - - - - - - - - - - - -

    -Public Types

    -using entity_type = typename view_type::entity_type
     Underlying entity identifier.
     
    -using size_type = typename view_type::size_type
     Unsigned integer type.
     
    -using iterator_type = Iterator
     Input iterator type.
     
    -using const_iterator_type = Iterator
     Constant input iterator type.
     
    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

    -Public Member Functions

    size_type size () const ENTT_NOEXCEPT
     Estimates the number of entities that have the given components. More...
     
    bool empty () const ENTT_NOEXCEPT
     Checks if the view is definitely empty. More...
     
    const_iterator_type cbegin () const ENTT_NOEXCEPT
     Returns an iterator to the first entity that has the given components. More...
     
    const_iterator_type begin () const ENTT_NOEXCEPT
     Returns an iterator to the first entity that has the given components. More...
     
    iterator_type begin () ENTT_NOEXCEPT
     Returns an iterator to the first entity that has the given components. More...
     
    const_iterator_type cend () const ENTT_NOEXCEPT
     Returns an iterator that is past the last entity that has the given components. More...
     
    const_iterator_type end () const ENTT_NOEXCEPT
     Returns an iterator that is past the last entity that has the given components. More...
     
    iterator_type end () ENTT_NOEXCEPT
     Returns an iterator that is past the last entity that has the given components. More...
     
    bool contains (const entity_type entity) const ENTT_NOEXCEPT
     Checks if a view contains an entity. More...
     
    template<typename Func >
    void each (Func func) const
     Iterates entities and applies the given function object to them. More...
     
    - - - - -

    -Friends

    -class Registry< Entity >
     A registry is allowed to create views.
     
    -

    Detailed Description

    -

    template<typename Entity>
    -class entt::RuntimeView< Entity >

    - -

    Runtime view.

    -

    Runtime views iterate over those entities that have at least all the given components in their bags. During initialization, a runtime view looks at the number of entities available for each component and picks up a reference to the smallest set of candidate entities in order to get a performance boost when iterate.
    - Order of elements during iterations are highly dependent on the order of the underlying data structures. See SparseSet and its specializations for more details.

    -

    Important

    -

    Iterators aren't invalidated if:

    -
      -
    • New instances of the given components are created and assigned to entities.
      • -
    • The entity currently pointed is modified (as an example, if one of the given components is removed from the entity to which the iterator points).
      • -
    -

    In all the other cases, modifying the pools of the given components in any way invalidates all the iterators and using them results in undefined behavior.

    -
    Note
    Views share references to the underlying data structures with the Registry that generated them. Therefore any change to the entities and to the components made by means of the registry are immediately reflected by views, unless a pool wasn't missing when the view was built (in this case, the view won't have a valid reference and won't be updated accordingly).
    -
    Warning
    Lifetime of a view must overcome the one of the registry that generated it. In any other case, attempting to use a view results in undefined behavior.
    -
    See also
    View
    -
    -View<Entity, Component>
    -
    -PersistentView
    -
    -RawView
    -
    Template Parameters
    - - -
    EntityA valid entity type (see entt_traits for more details).
    -
    -
    - -

    Definition at line 1590 of file view.hpp.

    -

    Member Function Documentation

    - -

    ◆ begin() [1/2]

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - -
    const_iterator_type entt::RuntimeView< Entity >::begin () const
    -     		-inline
    -
    - -

    Returns an iterator to the first entity that has the given components.

    -

    The returned iterator points to the first entity that has the given components. If the view is empty, the returned iterator will be equal to end().

    -
    Note
    Input iterators stay true to the order imposed to the underlying data structures.
    -
    Returns
    An iterator to the first entity that has the given components.
    - -

    Definition at line 1764 of file view.hpp.

    - -
    -
    - -

    ◆ begin() [2/2]

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - -
    iterator_type entt::RuntimeView< Entity >::begin ()
    -     		-inline
    -
    - -

    Returns an iterator to the first entity that has the given components.

    -

    The returned iterator points to the first entity that has the given components. If the view is empty, the returned iterator will be equal to end().

    -
    Note
    Input iterators stay true to the order imposed to the underlying data structures.
    -
    Returns
    An iterator to the first entity that has the given components.
    - -

    Definition at line 1782 of file view.hpp.

    - -
    -
    - -

    ◆ cbegin()

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - -
    const_iterator_type entt::RuntimeView< Entity >::cbegin () const
    -     		-inline
    -
    - -

    Returns an iterator to the first entity that has the given components.

    -

    The returned iterator points to the first entity that has the given components. If the view is empty, the returned iterator will be equal to end().

    -
    Note
    Input iterators stay true to the order imposed to the underlying data structures.
    -
    Returns
    An iterator to the first entity that has the given components.
    - -

    Definition at line 1738 of file view.hpp.

    - -
    -
    - -

    ◆ cend()

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - -
    const_iterator_type entt::RuntimeView< Entity >::cend () const
    -     		-inline
    -
    - -

    Returns an iterator that is past the last entity that has the given components.

    -

    The returned iterator points to the entity following the last entity that has the given components. Attempting to dereference the returned iterator results in undefined behavior.

    -
    Note
    Input iterators stay true to the order imposed to the underlying data structures.
    -
    Returns
    An iterator to the entity following the last entity that has the given components.
    - -

    Definition at line 1801 of file view.hpp.

    - -
    -
    - -

    ◆ contains()

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - - -
    bool entt::RuntimeView< Entity >::contains (const entity_type entity) const
    -     		-inline
    -
    - -

    Checks if a view contains an entity.

    -
    Parameters
    - - -
    entityA valid entity identifier.
    -
    -
    -
    Returns
    True if the view contains the given entity, false otherwise.
    - -

    Definition at line 1855 of file view.hpp.

    - -
    -
    - -

    ◆ each()

    - -
    -
    -
    -template<typename Entity >
    -
    -template<typename Func >
    - - - - - -
    - - - - - - - - -
    void entt::RuntimeView< Entity >::each (Func func) const
    -     		-inline
    -
    - -

    Iterates entities and applies the given function object to them.

    -

    The function object is invoked for each entity. It is provided only with the entity itself. To get the components, users can use the registry with which the view was built.
    - The signature of the function should be equivalent to the following:

    -
    void(const entity_type);
    Template Parameters
    - - -
    FuncType of the function object to invoke.
    -
    -
    -
    Parameters
    - - -
    funcA valid function object.
    -
    -
    - -

    Definition at line 1877 of file view.hpp.

    - -
    -
    - -

    ◆ empty()

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - -
    bool entt::RuntimeView< Entity >::empty () const
    -     		-inline
    -
    - -

    Checks if the view is definitely empty.

    -
    Returns
    True if the view is definitely empty, false otherwise.
    - -

    Definition at line 1720 of file view.hpp.

    - -
    -
    - -

    ◆ end() [1/2]

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - -
    const_iterator_type entt::RuntimeView< Entity >::end () const
    -     		-inline
    -
    - -

    Returns an iterator that is past the last entity that has the given components.

    -

    The returned iterator points to the entity following the last entity that has the given components. Attempting to dereference the returned iterator results in undefined behavior.

    -
    Note
    Input iterators stay true to the order imposed to the underlying data structures.
    -
    Returns
    An iterator to the entity following the last entity that has the given components.
    - -

    Definition at line 1827 of file view.hpp.

    - -
    -
    - -

    ◆ end() [2/2]

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - -
    iterator_type entt::RuntimeView< Entity >::end ()
    -     		-inline
    -
    - -

    Returns an iterator that is past the last entity that has the given components.

    -

    The returned iterator points to the entity following the last entity that has the given components. Attempting to dereference the returned iterator results in undefined behavior.

    -
    Note
    Input iterators stay true to the order imposed to the underlying data structures.
    -
    Returns
    An iterator to the entity following the last entity that has the given components.
    - -

    Definition at line 1846 of file view.hpp.

    - -
    -
    - -

    ◆ size()

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - -
    size_type entt::RuntimeView< Entity >::size () const
    -     		-inline
    -
    - -

    Estimates the number of entities that have the given components.

    -
    Returns
    Estimated number of entities that have the given components.
    - -

    Definition at line 1712 of file view.hpp.

    - -
    -
    -
    The documentation for this class was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4-members.html b/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4-members.html deleted file mode 100644 index 9a669e7a7..000000000 --- a/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4-members.html +++ /dev/null @@ -1,92 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::SigH< Ret(Args...), Collector > Member List
    -
    -
    - -

    This is the complete list of members for entt::SigH< Ret(Args...), Collector >, including all inherited members.

    - - - - - - - - - - - - -
    collect(Args... args) constentt::SigH< Ret(Args...), Collector >inline
    collector_type typedefentt::SigH< Ret(Args...), Collector >
    empty() const ENTT_NOEXCEPTentt::SigH< Ret(Args...), Collector >inline
    instance_type typedefentt::SigH< Ret(Args...), Collector >
    operator==(const SigH &other) const ENTT_NOEXCEPTentt::SigH< Ret(Args...), Collector >inline
    publish(Args... args) constentt::SigH< Ret(Args...), Collector >inline
    sink() ENTT_NOEXCEPTentt::SigH< Ret(Args...), Collector >inline
    sink_type typedefentt::SigH< Ret(Args...), Collector >
    size() const ENTT_NOEXCEPTentt::SigH< Ret(Args...), Collector >inline
    size_type typedefentt::SigH< Ret(Args...), Collector >
    swap(SigH &lhs, SigH &rhs)entt::SigH< Ret(Args...), Collector >friend
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__coll__graph.map b/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__coll__graph.map deleted file mode 100644 index 8c2e222a4..000000000 --- a/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__coll__graph.map +++ /dev/null @@ -1,2 +0,0 @@ - - diff --git a/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__coll__graph.md5 b/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__coll__graph.md5 deleted file mode 100644 index 6984d2f8c..000000000 --- a/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__coll__graph.md5 +++ /dev/null @@ -1 +0,0 @@ -5912f9063856265db81c2fd46ab86e10 \ No newline at end of file diff --git a/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__coll__graph.png b/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__coll__graph.png deleted file mode 100644 index b450694bb..000000000 Binary files a/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__coll__graph.png and /dev/null differ diff --git a/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__inherit__graph.map b/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__inherit__graph.map deleted file mode 100644 index 8c2e222a4..000000000 --- a/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__inherit__graph.map +++ /dev/null @@ -1,2 +0,0 @@ - - diff --git a/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__inherit__graph.md5 b/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__inherit__graph.md5 deleted file mode 100644 index 875b972b2..000000000 --- a/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__inherit__graph.md5 +++ /dev/null @@ -1 +0,0 @@ -10a9db26013b49724b6014469940db4c \ No newline at end of file diff --git a/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__inherit__graph.png b/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__inherit__graph.png deleted file mode 100644 index b450694bb..000000000 Binary files a/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__inherit__graph.png and /dev/null differ diff --git a/classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html b/classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html deleted file mode 100644 index 5148ae011..000000000 --- a/classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html +++ /dev/null @@ -1,467 +0,0 @@ - - - - - - - -EnTT: entt::Sink< Ret(Args...)> Class Template Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Public Member Functions | -Friends | -List of all members
    -
    -
    entt::Sink< Ret(Args...)> Class Template Referencefinal
    -
    -
    - -

    Sink implementation. - More...

    - -

    #include <sigh.hpp>

    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

    -Public Member Functions

    template<Ret(*)(Args...) Function>
    void connect ()
     Connects a free function to a signal. More...
     
    template<typename Class , Ret(Class::*)(Args...) const Member = &Class::receive>
    void connect (Class *instance)
     Connects a member function for a given instance to a signal. More...
     
    template<typename Class , Ret(Class::*)(Args...) Member = &Class::receive>
    void connect (Class *instance)
     Connects a member function for a given instance to a signal. More...
     
    template<Ret(*)(Args...) Function>
    void disconnect ()
     Disconnects a free function from a signal. More...
     
    template<typename Class , Ret(Class::*)(Args...) const Member>
    void disconnect (Class *instance)
     Disconnects the given member function from a signal. More...
     
    template<typename Class , Ret(Class::*)(Args...) Member>
    void disconnect (Class *instance)
     Disconnects the given member function from a signal. More...
     
    template<typename Class >
    void disconnect (Class *instance)
     Removes all existing connections for the given instance. More...
     
    -void disconnect ()
     Disconnects all the listeners from a signal.
     
    - - - - - -

    -Friends

    -template<typename , typename >
    class SigH
     A signal is allowed to create sinks.
     
    -

    Detailed Description

    -

    template<typename Ret, typename... Args>
    -class entt::Sink< Ret(Args...)>

    - -

    Sink implementation.

    -

    A sink is an opaque object used to connect listeners to signals.
    - The function type for a listener is the one of the signal to which it belongs.

    -

    The clear separation between a signal and a sink permits to store the former as private data member without exposing the publish functionality to the users of a class.

    -
    Template Parameters
    - - - -
    RetReturn type of a function type.
    ArgsTypes of arguments of a function type.
    -
    -
    - -

    Definition at line 139 of file sigh.hpp.

    -

    Member Function Documentation

    - -

    ◆ connect() [1/3]

    - -
    -
    -
    -template<typename Ret , typename... Args>
    -
    -template<Ret(*)(Args...) Function>
    - - - - - -
    - - - - - - - -
    void entt::Sink< Ret(Args...)>::connect ()
    -     		-inline
    -
    - -

    Connects a free function to a signal.

    -

    The signal handler performs checks to avoid multiple connections for free functions.

    -
    Template Parameters
    - - -
    FunctionA valid free function pointer.
    -
    -
    - -

    Definition at line 175 of file sigh.hpp.

    - -
    -
    - -

    ◆ connect() [2/3]

    - -
    -
    -
    -template<typename Ret , typename... Args>
    -
    -template<typename Class , Ret(Class::*)(Args...) const Member = &Class::receive>
    - - - - - -
    - - - - - - - - -
    void entt::Sink< Ret(Args...)>::connect (Class * instance)
    -     		-inline
    -
    - -

    Connects a member function for a given instance to a signal.

    -

    The signal isn't responsible for the connected object. Users must guarantee that the lifetime of the instance overcomes the one of the signal. On the other side, the signal handler performs checks to avoid multiple connections for the same member function of a given instance.

    -
    Template Parameters
    - - - -
    ClassType of class to which the member function belongs.
    MemberMember function to connect to the signal.
    -
    -
    -
    Parameters
    - - -
    instanceA valid instance of type pointer to Class.
    -
    -
    - -

    Definition at line 194 of file sigh.hpp.

    - -
    -
    - -

    ◆ connect() [3/3]

    - -
    -
    -
    -template<typename Ret , typename... Args>
    -
    -template<typename Class , Ret(Class::*)(Args...) Member = &Class::receive>
    - - - - - -
    - - - - - - - - -
    void entt::Sink< Ret(Args...)>::connect (Class * instance)
    -     		-inline
    -
    - -

    Connects a member function for a given instance to a signal.

    -

    The signal isn't responsible for the connected object. Users must guarantee that the lifetime of the instance overcomes the one of the signal. On the other side, the signal handler performs checks to avoid multiple connections for the same member function of a given instance.

    -
    Template Parameters
    - - - -
    ClassType of class to which the member function belongs.
    MemberMember function to connect to the signal.
    -
    -
    -
    Parameters
    - - -
    instanceA valid instance of type pointer to Class.
    -
    -
    - -

    Definition at line 213 of file sigh.hpp.

    - -
    -
    - -

    ◆ disconnect() [1/4]

    - -
    -
    -
    -template<typename Ret , typename... Args>
    -
    -template<Ret(*)(Args...) Function>
    - - - - - -
    - - - - - - - -
    void entt::Sink< Ret(Args...)>::disconnect ()
    -     		-inline
    -
    - -

    Disconnects a free function from a signal.

    -
    Template Parameters
    - - -
    FunctionA valid free function pointer.
    -
    -
    - -

    Definition at line 223 of file sigh.hpp.

    - -
    -
    - -

    ◆ disconnect() [2/4]

    - -
    -
    -
    -template<typename Ret , typename... Args>
    -
    -template<typename Class , Ret(Class::*)(Args...) const Member>
    - - - - - -
    - - - - - - - - -
    void entt::Sink< Ret(Args...)>::disconnect (Class * instance)
    -     		-inline
    -
    - -

    Disconnects the given member function from a signal.

    -
    Template Parameters
    - - - -
    ClassType of class to which the member function belongs.
    MemberMember function to connect to the signal.
    -
    -
    -
    Parameters
    - - -
    instanceA valid instance of type pointer to Class.
    -
    -
    - -

    Definition at line 235 of file sigh.hpp.

    - -
    -
    - -

    ◆ disconnect() [3/4]

    - -
    -
    -
    -template<typename Ret , typename... Args>
    -
    -template<typename Class , Ret(Class::*)(Args...) Member>
    - - - - - -
    - - - - - - - - -
    void entt::Sink< Ret(Args...)>::disconnect (Class * instance)
    -     		-inline
    -
    - -

    Disconnects the given member function from a signal.

    -
    Template Parameters
    - - - -
    ClassType of class to which the member function belongs.
    MemberMember function to connect to the signal.
    -
    -
    -
    Parameters
    - - -
    instanceA valid instance of type pointer to Class.
    -
    -
    - -

    Definition at line 247 of file sigh.hpp.

    - -
    -
    - -

    ◆ disconnect() [4/4]

    - -
    -
    -
    -template<typename Ret , typename... Args>
    -
    -template<typename Class >
    - - - - - -
    - - - - - - - - -
    void entt::Sink< Ret(Args...)>::disconnect (Class * instance)
    -     		-inline
    -
    - -

    Removes all existing connections for the given instance.

    -
    Template Parameters
    - - -
    ClassType of class to which the member function belongs.
    -
    -
    -
    Parameters
    - - -
    instanceA valid instance of type pointer to Class.
    -
    -
    - -

    Definition at line 258 of file sigh.hpp.

    - -
    -
    -
    The documentation for this class was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1Snapshot-members.html b/classentt_1_1Snapshot-members.html deleted file mode 100644 index 67783580c..000000000 --- a/classentt_1_1Snapshot-members.html +++ /dev/null @@ -1,93 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::Snapshot< Entity > Member List
    -
    -
    - -

    This is the complete list of members for entt::Snapshot< Entity >, including all inherited members.

    - - - - - - - - - - - - - -
    component(Archive &archive) constentt::Snapshot< Entity >inline
    component(Archive &archive) constentt::Snapshot< Entity >inline
    component(Archive &archive, It first, It last) constentt::Snapshot< Entity >inline
    destroyed(Archive &archive) constentt::Snapshot< Entity >inline
    entities(Archive &archive) constentt::Snapshot< Entity >inline
    operator=(const Snapshot &)=deleteentt::Snapshot< Entity >
    operator=(Snapshot &&)=defaultentt::Snapshot< Entity >
    Registry< Entity > classentt::Snapshot< Entity >friend
    Snapshot(const Snapshot &)=deleteentt::Snapshot< Entity >
    Snapshot(Snapshot &&)=defaultentt::Snapshot< Entity >
    tag(Archive &archive) constentt::Snapshot< Entity >inline
    tag(Archive &archive) constentt::Snapshot< Entity >inline
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1Snapshot.html b/classentt_1_1Snapshot.html deleted file mode 100644 index 7d41bf86a..000000000 --- a/classentt_1_1Snapshot.html +++ /dev/null @@ -1,581 +0,0 @@ - - - - - - - -EnTT: entt::Snapshot< Entity > Class Template Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Public Member Functions | -Friends | -List of all members
    -
    -
    entt::Snapshot< Entity > Class Template Referencefinal
    -
    -
    - -

    Utility class to create snapshots from a registry. - More...

    - -

    #include <snapshot.hpp>

    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

    -Public Member Functions

    - Snapshot (const Snapshot &)=delete
     Copying a snapshot isn't allowed.
     
    - Snapshot (Snapshot &&)=default
     Default move constructor.
     
    Snapshot & operator= (const Snapshot &)=delete
     Copying a snapshot isn't allowed. More...
     
    Snapshot & operator= (Snapshot &&)=default
     Default move assignment operator. More...
     
    template<typename Archive >
    const Snapshot & entities (Archive &archive) const
     Puts aside all the entities that are still in use. More...
     
    template<typename Archive >
    const Snapshot & destroyed (Archive &archive) const
     Puts aside destroyed entities. More...
     
    template<typename Component , typename Archive >
    const Snapshot & component (Archive &archive) const
     Puts aside the given component. More...
     
    template<typename... Component, typename Archive >
    std::enable_if_t<(sizeof...(Component) > 1), const Snapshot & > component (Archive &archive) const
     Puts aside the given components. More...
     
    template<typename... Component, typename Archive , typename It >
    const Snapshot & component (Archive &archive, It first, It last) const
     Puts aside the given components for the entities in a range. More...
     
    template<typename Tag , typename Archive >
    const Snapshot & tag (Archive &archive) const
     Puts aside the given tag. More...
     
    template<typename... Tag, typename Archive >
    std::enable_if_t<(sizeof...(Tag) > 1), const Snapshot & > tag (Archive &archive) const
     Puts aside the given tags. More...
     
    - - - - -

    -Friends

    -class Registry< Entity >
     A registry is allowed to create snapshots.
     
    -

    Detailed Description

    -

    template<typename Entity>
    -class entt::Snapshot< Entity >

    - -

    Utility class to create snapshots from a registry.

    -

    A snapshot can be either a dump of the entire registry or a narrower selection of components and tags of interest.
    - This type can be used in both cases if provided with a correctly configured output archive.

    -
    Template Parameters
    - - -
    EntityA valid entity type (see entt_traits for more details).
    -
    -
    - -

    Definition at line 38 of file snapshot.hpp.

    -

    Member Function Documentation

    - -

    ◆ component() [1/3]

    - -
    -
    -
    -template<typename Entity >
    -
    -template<typename Component , typename Archive >
    - - - - - -
    - - - - - - - - -
    const Snapshot& entt::Snapshot< Entity >::component (Archive & archive) const
    -     		-inline
    -
    - -

    Puts aside the given component.

    -

    Each instance is serialized together with the entity to which it belongs. Entities are serialized along with their versions.

    -
    Template Parameters
    - - - -
    ComponentType of component to serialize.
    ArchiveType of output archive.
    -
    -
    -
    Parameters
    - - -
    archiveA valid reference to an output archive.
    -
    -
    -
    Returns
    An object of this type to continue creating the snapshot.
    - -

    Definition at line 148 of file snapshot.hpp.

    - -
    -
    - -

    ◆ component() [2/3]

    - -
    -
    -
    -template<typename Entity >
    -
    -template<typename... Component, typename Archive >
    - - - - - -
    - - - - - - - - -
    std::enable_if_t<(sizeof...(Component) > 1), const Snapshot &> entt::Snapshot< Entity >::component (Archive & archive) const
    -     		-inline
    -
    - -

    Puts aside the given components.

    -

    Each instance is serialized together with the entity to which it belongs. Entities are serialized along with their versions.

    -
    Template Parameters
    - - - -
    ComponentTypes of components to serialize.
    ArchiveType of output archive.
    -
    -
    -
    Parameters
    - - -
    archiveA valid reference to an output archive.
    -
    -
    -
    Returns
    An object of this type to continue creating the snapshot.
    - -

    Definition at line 175 of file snapshot.hpp.

    - -
    -
    - -

    ◆ component() [3/3]

    - -
    -
    -
    -template<typename Entity >
    -
    -template<typename... Component, typename Archive , typename It >
    - - - - - -
    - - - - - - - - - - - - - - - - - - - - - - - - -
    const Snapshot& entt::Snapshot< Entity >::component (Archive & archive,
    It first,
    It last 
    ) const
    -     		-inline
    -
    - -

    Puts aside the given components for the entities in a range.

    -

    Each instance is serialized together with the entity to which it belongs. Entities are serialized along with their versions.

    -
    Template Parameters
    - - - - -
    ComponentTypes of components to serialize.
    ArchiveType of output archive.
    ItType of input iterator.
    -
    -
    -
    Parameters
    - - - - -
    archiveA valid reference to an output archive.
    firstAn iterator to the first element of the range to serialize.
    lastAn iterator past the last element of the range to serialize.
    -
    -
    -
    Returns
    An object of this type to continue creating the snapshot.
    - -

    Definition at line 197 of file snapshot.hpp.

    - -
    -
    - -

    ◆ destroyed()

    - -
    -
    -
    -template<typename Entity >
    -
    -template<typename Archive >
    - - - - - -
    - - - - - - - - -
    const Snapshot& entt::Snapshot< Entity >::destroyed (Archive & archive) const
    -     		-inline
    -
    - -

    Puts aside destroyed entities.

    -

    Entities are serialized along with their versions. Entities that are still in use are not taken in consideration by this function.

    -
    Template Parameters
    - - -
    ArchiveType of output archive.
    -
    -
    -
    Parameters
    - - -
    archiveA valid reference to an output archive.
    -
    -
    -
    Returns
    An object of this type to continue creating the snapshot.
    - -

    Definition at line 119 of file snapshot.hpp.

    - -
    -
    - -

    ◆ entities()

    - -
    -
    -
    -template<typename Entity >
    -
    -template<typename Archive >
    - - - - - -
    - - - - - - - - -
    const Snapshot& entt::Snapshot< Entity >::entities (Archive & archive) const
    -     		-inline
    -
    - -

    Puts aside all the entities that are still in use.

    -

    Entities are serialized along with their versions. Destroyed entities are not taken in consideration by this function.

    -
    Template Parameters
    - - -
    ArchiveType of output archive.
    -
    -
    -
    Parameters
    - - -
    archiveA valid reference to an output archive.
    -
    -
    -
    Returns
    An object of this type to continue creating the snapshot.
    - -

    Definition at line 102 of file snapshot.hpp.

    - -
    -
    - -

    ◆ operator=() [1/2]

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - - -
    Snapshot& entt::Snapshot< Entity >::operator= (const Snapshot< Entity > & )
    -     		-delete
    -
    - -

    Copying a snapshot isn't allowed.

    -
    Returns
    This snapshot.
    - -
    -
    - -

    ◆ operator=() [2/2]

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - - -
    Snapshot& entt::Snapshot< Entity >::operator= (Snapshot< Entity > && )
    -     		-default
    -
    - -

    Default move assignment operator.

    -
    Returns
    This snapshot.
    - -
    -
    - -

    ◆ tag() [1/2]

    - -
    -
    -
    -template<typename Entity >
    -
    -template<typename Tag , typename Archive >
    - - - - - -
    - - - - - - - - -
    const Snapshot& entt::Snapshot< Entity >::tag (Archive & archive) const
    -     		-inline
    -
    - -

    Puts aside the given tag.

    -

    Each instance is serialized together with the entity to which it belongs. Entities are serialized along with their versions.

    -
    Template Parameters
    - - - -
    TagType of tag to serialize.
    ArchiveType of output archive.
    -
    -
    -
    Parameters
    - - -
    archiveA valid reference to an output archive.
    -
    -
    -
    Returns
    An object of this type to continue creating the snapshot.
    - -

    Definition at line 214 of file snapshot.hpp.

    - -
    -
    - -

    ◆ tag() [2/2]

    - -
    -
    -
    -template<typename Entity >
    -
    -template<typename... Tag, typename Archive >
    - - - - - -
    - - - - - - - - -
    std::enable_if_t<(sizeof...(Tag) > 1), const Snapshot &> entt::Snapshot< Entity >::tag (Archive & archive) const
    -     		-inline
    -
    - -

    Puts aside the given tags.

    -

    Each instance is serialized together with the entity to which it belongs. Entities are serialized along with their versions.

    -
    Template Parameters
    - - - -
    TagTypes of tags to serialize.
    ArchiveType of output archive.
    -
    -
    -
    Parameters
    - - -
    archiveA valid reference to an output archive.
    -
    -
    -
    Returns
    An object of this type to continue creating the snapshot.
    - -

    Definition at line 240 of file snapshot.hpp.

    - -
    -
    -
    The documentation for this class was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1SnapshotLoader-members.html b/classentt_1_1SnapshotLoader-members.html deleted file mode 100644 index 7b01374e6..000000000 --- a/classentt_1_1SnapshotLoader-members.html +++ /dev/null @@ -1,91 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::SnapshotLoader< Entity > Member List
    -
    -
    - -

    This is the complete list of members for entt::SnapshotLoader< Entity >, including all inherited members.

    - - - - - - - - - - - -
    component(Archive &archive) constentt::SnapshotLoader< Entity >inline
    destroyed(Archive &archive) constentt::SnapshotLoader< Entity >inline
    entities(Archive &archive) constentt::SnapshotLoader< Entity >inline
    operator=(const SnapshotLoader &)=deleteentt::SnapshotLoader< Entity >
    operator=(SnapshotLoader &&)=defaultentt::SnapshotLoader< Entity >
    orphans() constentt::SnapshotLoader< Entity >inline
    Registry< Entity > classentt::SnapshotLoader< Entity >friend
    SnapshotLoader(const SnapshotLoader &)=deleteentt::SnapshotLoader< Entity >
    SnapshotLoader(SnapshotLoader &&)=defaultentt::SnapshotLoader< Entity >
    tag(Archive &archive) constentt::SnapshotLoader< Entity >inline
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1SnapshotLoader.html b/classentt_1_1SnapshotLoader.html deleted file mode 100644 index b715f0237..000000000 --- a/classentt_1_1SnapshotLoader.html +++ /dev/null @@ -1,440 +0,0 @@ - - - - - - - -EnTT: entt::SnapshotLoader< Entity > Class Template Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Public Member Functions | -Friends | -List of all members
    -
    -
    entt::SnapshotLoader< Entity > Class Template Referencefinal
    -
    -
    - -

    Utility class to restore a snapshot as a whole. - More...

    - -

    #include <snapshot.hpp>

    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

    -Public Member Functions

    - SnapshotLoader (const SnapshotLoader &)=delete
     Copying a snapshot loader isn't allowed.
     
    - SnapshotLoader (SnapshotLoader &&)=default
     Default move constructor.
     
    SnapshotLoader & operator= (const SnapshotLoader &)=delete
     Copying a snapshot loader isn't allowed. More...
     
    SnapshotLoader & operator= (SnapshotLoader &&)=default
     Default move assignment operator. More...
     
    template<typename Archive >
    const SnapshotLoader & entities (Archive &archive) const
     Restores entities that were in use during serialization. More...
     
    template<typename Archive >
    const SnapshotLoader & destroyed (Archive &archive) const
     Restores entities that were destroyed during serialization. More...
     
    template<typename... Component, typename Archive >
    const SnapshotLoader & component (Archive &archive) const
     Restores components and assigns them to the right entities. More...
     
    template<typename... Tag, typename Archive >
    const SnapshotLoader & tag (Archive &archive) const
     Restores tags and assigns them to the right entities. More...
     
    const SnapshotLoader & orphans () const
     Destroys those entities that have neither components nor tags. More...
     
    - - - - -

    -Friends

    -class Registry< Entity >
     A registry is allowed to create snapshot loaders.
     
    -

    Detailed Description

    -

    template<typename Entity>
    -class entt::SnapshotLoader< Entity >

    - -

    Utility class to restore a snapshot as a whole.

    -

    A snapshot loader requires that the destination registry be empty and loads all the data at once while keeping intact the identifiers that the entities originally had.
    - An example of use is the implementation of a save/restore utility.

    -
    Template Parameters
    - - -
    EntityA valid entity type (see entt_traits for more details).
    -
    -
    - -

    Definition at line 265 of file snapshot.hpp.

    -

    Member Function Documentation

    - -

    ◆ component()

    - -
    -
    -
    -template<typename Entity >
    -
    -template<typename... Component, typename Archive >
    - - - - - -
    - - - - - - - - -
    const SnapshotLoader& entt::SnapshotLoader< Entity >::component (Archive & archive) const
    -     		-inline
    -
    - -

    Restores components and assigns them to the right entities.

    -

    The template parameter list must be exactly the same used during serialization. In the event that the entity to which the component is assigned doesn't exist yet, the loader will take care to create it with the version it originally had.

    -
    Template Parameters
    - - - -
    ComponentTypes of components to restore.
    ArchiveType of input archive.
    -
    -
    -
    Parameters
    - - -
    archiveA valid reference to an input archive.
    -
    -
    -
    Returns
    A valid loader to continue restoring data.
    - -

    Definition at line 365 of file snapshot.hpp.

    - -
    -
    - -

    ◆ destroyed()

    - -
    -
    -
    -template<typename Entity >
    -
    -template<typename Archive >
    - - - - - -
    - - - - - - - - -
    const SnapshotLoader& entt::SnapshotLoader< Entity >::destroyed (Archive & archive) const
    -     		-inline
    -
    - -

    Restores entities that were destroyed during serialization.

    -

    This function restores the entities that were destroyed during serialization and gives them the versions they originally had.

    -
    Template Parameters
    - - -
    ArchiveType of input archive.
    -
    -
    -
    Parameters
    - - -
    archiveA valid reference to an input archive.
    -
    -
    -
    Returns
    A valid loader to continue restoring data.
    - -

    Definition at line 345 of file snapshot.hpp.

    - -
    -
    - -

    ◆ entities()

    - -
    -
    -
    -template<typename Entity >
    -
    -template<typename Archive >
    - - - - - -
    - - - - - - - - -
    const SnapshotLoader& entt::SnapshotLoader< Entity >::entities (Archive & archive) const
    -     		-inline
    -
    - -

    Restores entities that were in use during serialization.

    -

    This function restores the entities that were in use during serialization and gives them the versions they originally had.

    -
    Template Parameters
    - - -
    ArchiveType of input archive.
    -
    -
    -
    Parameters
    - - -
    archiveA valid reference to an input archive.
    -
    -
    -
    Returns
    A valid loader to continue restoring data.
    - -

    Definition at line 328 of file snapshot.hpp.

    - -
    -
    - -

    ◆ operator=() [1/2]

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - - -
    SnapshotLoader& entt::SnapshotLoader< Entity >::operator= (const SnapshotLoader< Entity > & )
    -     		-delete
    -
    - -

    Copying a snapshot loader isn't allowed.

    -
    Returns
    This loader.
    - -
    -
    - -

    ◆ operator=() [2/2]

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - - -
    SnapshotLoader& entt::SnapshotLoader< Entity >::operator= (SnapshotLoader< Entity > && )
    -     		-default
    -
    - -

    Default move assignment operator.

    -
    Returns
    This loader.
    - -
    -
    - -

    ◆ orphans()

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - -
    const SnapshotLoader& entt::SnapshotLoader< Entity >::orphans () const
    -     		-inline
    -
    - -

    Destroys those entities that have neither components nor tags.

    -

    In case all the entities were serialized but only part of the components and tags was saved, it could happen that some of the entities have neither components nor tags once restored.
    - This functions helps to identify and destroy those entities.

    -
    Returns
    A valid loader to continue restoring data.
    - -

    Definition at line 403 of file snapshot.hpp.

    - -
    -
    - -

    ◆ tag()

    - -
    -
    -
    -template<typename Entity >
    -
    -template<typename... Tag, typename Archive >
    - - - - - -
    - - - - - - - - -
    const SnapshotLoader& entt::SnapshotLoader< Entity >::tag (Archive & archive) const
    -     		-inline
    -
    - -

    Restores tags and assigns them to the right entities.

    -

    The template parameter list must be exactly the same used during serialization. In the event that the entity to which the tag is assigned doesn't exist yet, the loader will take care to create it with the version it originally had.

    -
    Template Parameters
    - - - -
    TagTypes of tags to restore.
    ArchiveType of input archive.
    -
    -
    -
    Parameters
    - - -
    archiveA valid reference to an input archive.
    -
    -
    -
    Returns
    A valid loader to continue restoring data.
    - -

    Definition at line 386 of file snapshot.hpp.

    - -
    -
    -
    The documentation for this class was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4-members.html b/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4-members.html deleted file mode 100644 index 2f8c4538c..000000000 --- a/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4-members.html +++ /dev/null @@ -1,120 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::SparseSet< Entity, Type > Member List
    -
    -
    - -

    This is the complete list of members for entt::SparseSet< Entity, Type >, including all inherited members.

    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    begin() const ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
    begin() ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
    capacity() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    cbegin() const ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
    cend() const ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
    const_iterator_type typedefentt::SparseSet< Entity, Type >
    construct(const entity_type entity, Args &&... args)entt::SparseSet< Entity, Type >inline
    construct(const entity_type entity, Args &&... args)entt::SparseSet< Entity, Type >inline
    entt::SparseSet< Entity >::construct(const entity_type entity)entt::SparseSet< Entity >inline
    data() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    destroy(const entity_type entity) overrideentt::SparseSet< Entity, Type >inlinevirtual
    empty() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    end() const ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
    end() ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
    entity_type typedefentt::SparseSet< Entity, Type >
    extent() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    fast(const entity_type entity) const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    get(const entity_type entity) const ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
    get(const entity_type entity) ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
    has(const entity_type entity) const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    iterator_type typedefentt::SparseSet< Entity, Type >
    object_type typedefentt::SparseSet< Entity, Type >
    operator=(const SparseSet &)=deleteentt::SparseSet< Entity, Type >
    operator=(SparseSet &&)=defaultentt::SparseSet< Entity, Type >
    operator[](const size_type pos) const ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
    operator[](const size_type pos) ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
    raw() const ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
    raw() ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
    reserve(const size_type cap)entt::SparseSet< Entity, Type >inline
    reset() overrideentt::SparseSet< Entity, Type >inlinevirtual
    respect(const SparseSet< Entity > &other) ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
    size() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    size_type typedefentt::SparseSet< Entity, Type >
    sort(Compare compare, Sort sort=Sort{}, Args &&... args)entt::SparseSet< Entity, Type >inline
    SparseSet() ENTT_NOEXCEPT=defaultentt::SparseSet< Entity, Type >
    SparseSet(const SparseSet &)=deleteentt::SparseSet< Entity, Type >
    SparseSet(SparseSet &&)=defaultentt::SparseSet< Entity, Type >
    swap(const size_type lhs, const size_type rhs) ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    ~SparseSet() ENTT_NOEXCEPT=defaultentt::SparseSet< Entity >virtual
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html b/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html deleted file mode 100644 index 796493cd9..000000000 --- a/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html +++ /dev/null @@ -1,1148 +0,0 @@ - - - - - - - -EnTT: entt::SparseSet< Entity, Type > Class Template Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Classes | -Public Types | -Public Member Functions | -List of all members
    -
    -
    entt::SparseSet< Entity, Type > Class Template Reference
    -
    -
    - -

    Extended sparse set implementation. - More...

    - -

    #include <sparse_set.hpp>

    -
    -Inheritance diagram for entt::SparseSet< Entity, Type >:
    -
    -
    Inheritance graph
    - - - -
    [legend]
    -
    -Collaboration diagram for entt::SparseSet< Entity, Type >:
    -
    -
    Collaboration graph
    - - - -
    [legend]
    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

    -Public Types

    -using object_type = Type
     Type of the objects associated to the entities.
     
    -using entity_type = typename underlying_type::entity_type
     Underlying entity identifier.
     
    -using size_type = typename underlying_type::size_type
     Unsigned integer type.
     
    -using iterator_type = Iterator< false >
     Input iterator type.
     
    -using const_iterator_type = Iterator< true >
     Constant input iterator type.
     
    - Public Types inherited from entt::SparseSet< Entity >
    -using entity_type = Entity
     Underlying entity identifier.
     
    -using size_type = std::size_t
     Unsigned integer type.
     
    -using iterator_type = Iterator
     Input iterator type.
     
    -using const_iterator_type = Iterator
     Constant input iterator type.
     
    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

    -Public Member Functions

    - SparseSet () ENTT_NOEXCEPT=default
     Default constructor.
     
    - SparseSet (const SparseSet &)=delete
     Copying a sparse set isn't allowed.
     
    - SparseSet (SparseSet &&)=default
     Default move constructor.
     
    SparseSet & operator= (const SparseSet &)=delete
     Copying a sparse set isn't allowed. More...
     
    SparseSet & operator= (SparseSet &&)=default
     Default move assignment operator. More...
     
    void reserve (const size_type cap)
     Increases the capacity of a sparse set. More...
     
    const object_type * raw () const ENTT_NOEXCEPT
     Direct access to the array of objects. More...
     
    object_type * raw () ENTT_NOEXCEPT
     Direct access to the array of objects. More...
     
    const_iterator_type cbegin () const ENTT_NOEXCEPT
     Returns an iterator to the beginning. More...
     
    const_iterator_type begin () const ENTT_NOEXCEPT
     Returns an iterator to the beginning. More...
     
    iterator_type begin () ENTT_NOEXCEPT
     Returns an iterator to the beginning. More...
     
    const_iterator_type cend () const ENTT_NOEXCEPT
     Returns an iterator to the end. More...
     
    const_iterator_type end () const ENTT_NOEXCEPT
     Returns an iterator to the end. More...
     
    iterator_type end () ENTT_NOEXCEPT
     Returns an iterator to the end. More...
     
    const object_type & operator[] (const size_type pos) const ENTT_NOEXCEPT
     Returns a reference to the element at the given position. More...
     
    object_type & operator[] (const size_type pos) ENTT_NOEXCEPT
     Returns a reference to the element at the given position. More...
     
    const object_type & get (const entity_type entity) const ENTT_NOEXCEPT
     Returns the object associated to an entity. More...
     
    object_type & get (const entity_type entity) ENTT_NOEXCEPT
     Returns the object associated to an entity. More...
     
    template<typename... Args>
    std::enable_if_t< std::is_constructible< Type, Args... >::value, object_type & > construct (const entity_type entity, Args &&... args)
     Assigns an entity to a sparse set and constructs its object. More...
     
    template<typename... Args>
    std::enable_if_t<!std::is_constructible< Type, Args... >::value, object_type & > construct (const entity_type entity, Args &&... args)
     Assigns an entity to a sparse set and constructs its object. More...
     
    void destroy (const entity_type entity) override
     Removes an entity from a sparse set and destroies its object. More...
     
    template<typename Compare , typename Sort = StdSort, typename... Args>
    void sort (Compare compare, Sort sort=Sort{}, Args &&... args)
     Sort components according to the given comparison function. More...
     
    void respect (const SparseSet< Entity > &other) ENTT_NOEXCEPT
     Sort components according to the order of the entities in another sparse set. More...
     
    -void reset () override
     Resets a sparse set.
     
    - Public Member Functions inherited from entt::SparseSet< Entity >
    - SparseSet () ENTT_NOEXCEPT=default
     Default constructor.
     
    -virtual ~SparseSet () ENTT_NOEXCEPT=default
     Default destructor.
     
    - SparseSet (const SparseSet &)=delete
     Copying a sparse set isn't allowed.
     
    - SparseSet (SparseSet &&)=default
     Default move constructor.
     
    SparseSet & operator= (const SparseSet &)=delete
     Copying a sparse set isn't allowed. More...
     
    SparseSet & operator= (SparseSet &&)=default
     Default move assignment operator. More...
     
    void reserve (const size_type cap)
     Increases the capacity of a sparse set. More...
     
    size_type capacity () const ENTT_NOEXCEPT
     Returns the number of elements that a sparse set has currently allocated space for. More...
     
    size_type extent () const ENTT_NOEXCEPT
     Returns the extent of a sparse set. More...
     
    size_type size () const ENTT_NOEXCEPT
     Returns the number of elements in a sparse set. More...
     
    bool empty () const ENTT_NOEXCEPT
     Checks whether a sparse set is empty. More...
     
    const entity_type * data () const ENTT_NOEXCEPT
     Direct access to the internal packed array. More...
     
    const_iterator_type cbegin () const ENTT_NOEXCEPT
     Returns an iterator to the beginning. More...
     
    const_iterator_type begin () const ENTT_NOEXCEPT
     Returns an iterator to the beginning. More...
     
    iterator_type begin () ENTT_NOEXCEPT
     Returns an iterator to the beginning. More...
     
    const_iterator_type cend () const ENTT_NOEXCEPT
     Returns an iterator to the end. More...
     
    const_iterator_type end () const ENTT_NOEXCEPT
     Returns an iterator to the end. More...
     
    iterator_type end () ENTT_NOEXCEPT
     Returns an iterator to the end. More...
     
    const entity_type & operator[] (const size_type pos) const ENTT_NOEXCEPT
     Returns a reference to the element at the given position. More...
     
    bool has (const entity_type entity) const ENTT_NOEXCEPT
     Checks if a sparse set contains an entity. More...
     
    bool fast (const entity_type entity) const ENTT_NOEXCEPT
     Checks if a sparse set contains an entity (unsafe). More...
     
    size_type get (const entity_type entity) const ENTT_NOEXCEPT
     Returns the position of an entity in a sparse set. More...
     
    void construct (const entity_type entity)
     Assigns an entity to a sparse set. More...
     
    void swap (const size_type lhs, const size_type rhs) ENTT_NOEXCEPT
     Swaps the position of two entities in the internal packed array. More...
     
    void respect (const SparseSet< Entity > &other) ENTT_NOEXCEPT
     Sort entities according to their order in another sparse set. More...
     
    -

    Detailed Description

    -

    template<typename Entity, typename Type>
    -class entt::SparseSet< Entity, Type >

    - -

    Extended sparse set implementation.

    -

    This specialization of a sparse set associates an object to an entity. The main purpose of this class is to use sparse sets to store components in a Registry. It guarantees fast access both to the elements and to the entities.

    -
    Note
    Entities and objects have the same order. It's guaranteed both in case of raw access (either to entities or objects) and when using input iterators.
    -
    -Internal data structures arrange elements to maximize performance. Because of that, there are no guarantees that elements have the expected order when iterate directly the internal packed array (see raw and size member functions for that). Use begin and end instead.
    -
    See also
    SparseSet<Entity>
    -
    Template Parameters
    - - - -
    EntityA valid entity type (see entt_traits for more details).
    TypeType of objects assigned to the entities.
    -
    -
    - -

    Definition at line 576 of file sparse_set.hpp.

    -

    Member Function Documentation

    - -

    ◆ begin() [1/2]

    - -
    -
    -
    -template<typename Entity , typename Type >
    - - - - - -
    - - - - - - - -
    const_iterator_type entt::SparseSet< Entity, Type >::begin () const
    -     		-inline
    -
    - -

    Returns an iterator to the beginning.

    -

    The returned iterator points to the first instance of the given type. If the sparse set is empty, the returned iterator will be equal to end().

    -
    Note
    Input iterators stay true to the order imposed by a call to either sort or respect.
    -
    Returns
    An iterator to the first instance of the given type.
    - -

    Definition at line 790 of file sparse_set.hpp.

    - -
    -
    - -

    ◆ begin() [2/2]

    - -
    -
    -
    -template<typename Entity , typename Type >
    - - - - - -
    - - - - - - - -
    iterator_type entt::SparseSet< Entity, Type >::begin ()
    -     		-inline
    -
    - -

    Returns an iterator to the beginning.

    -

    The returned iterator points to the first instance of the given type. If the sparse set is empty, the returned iterator will be equal to end().

    -
    Note
    Input iterators stay true to the order imposed by a call to either sort or respect.
    -
    Returns
    An iterator to the first instance of the given type.
    - -

    Definition at line 806 of file sparse_set.hpp.

    - -
    -
    - -

    ◆ cbegin()

    - -
    -
    -
    -template<typename Entity , typename Type >
    - - - - - -
    - - - - - - - -
    const_iterator_type entt::SparseSet< Entity, Type >::cbegin () const
    -     		-inline
    -
    - -

    Returns an iterator to the beginning.

    -

    The returned iterator points to the first instance of the given type. If the sparse set is empty, the returned iterator will be equal to end().

    -
    Note
    Input iterators stay true to the order imposed by a call to either sort or respect.
    -
    Returns
    An iterator to the first instance of the given type.
    - -

    Definition at line 773 of file sparse_set.hpp.

    - -
    -
    - -

    ◆ cend()

    - -
    -
    -
    -template<typename Entity , typename Type >
    - - - - - -
    - - - - - - - -
    const_iterator_type entt::SparseSet< Entity, Type >::cend () const
    -     		-inline
    -
    - -

    Returns an iterator to the end.

    -

    The returned iterator points to the element following the last instance of the given type. Attempting to dereference the returned iterator results in undefined behavior.

    -
    Note
    Input iterators stay true to the order imposed by a call to either sort or respect.
    -
    Returns
    An iterator to the element following the last instance of the given type.
    - -

    Definition at line 825 of file sparse_set.hpp.

    - -
    -
    - -

    ◆ construct() [1/2]

    - -
    -
    -
    -template<typename Entity , typename Type >
    -
    -template<typename... Args>
    - - - - - -
    - - - - - - - - - - - - - - - - - - -
    std::enable_if_t<std::is_constructible<Type, Args...>::value, object_type &> entt::SparseSet< Entity, Type >::construct (const entity_type entity,
    Args &&... args 
    )
    -     		-inline
    -
    - -

    Assigns an entity to a sparse set and constructs its object.

    -
    Note
    Sfinae'd function.
    - This version is used for types that can be constructed in place directly. It doesn't work well with aggregates because of the placement new usually performed under the hood during an emplace back.
    -
    Warning
    Attempting to use an entity that already belongs to the sparse set results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode if the sparse set already contains the given entity.
    -
    Template Parameters
    - - -
    ArgsTypes of arguments to use to construct the object.
    -
    -
    -
    Parameters
    - - - -
    entityA valid entity identifier.
    argsParameters to use to construct an object for the entity.
    -
    -
    -
    Returns
    The object associated to the entity.
    - -

    Definition at line 937 of file sparse_set.hpp.

    - -
    -
    - -

    ◆ construct() [2/2]

    - -
    -
    -
    -template<typename Entity , typename Type >
    -
    -template<typename... Args>
    - - - - - -
    - - - - - - - - - - - - - - - - - - -
    std::enable_if_t<!std::is_constructible<Type, Args...>::value, object_type &> entt::SparseSet< Entity, Type >::construct (const entity_type entity,
    Args &&... args 
    )
    -     		-inline
    -
    - -

    Assigns an entity to a sparse set and constructs its object.

    -
    Note
    Sfinae'd function.
    - Fallback for aggregates and types in general that do not work well with a placement new as performed usually under the hood during an emplace back.
    -
    Warning
    Attempting to use an entity that already belongs to the sparse set results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode if the sparse set already contains the given entity.
    -
    Template Parameters
    - - -
    ArgsTypes of arguments to use to construct the object.
    -
    -
    -
    Parameters
    - - - -
    entityA valid entity identifier.
    argsParameters to use to construct an object for the entity.
    -
    -
    -
    Returns
    The object associated to the entity.
    - -

    Definition at line 965 of file sparse_set.hpp.

    - -
    -
    - -

    ◆ destroy()

    - -
    -
    -
    -template<typename Entity , typename Type >
    - - - - - -
    - - - - - - - - -
    void entt::SparseSet< Entity, Type >::destroy (const entity_type entity)
    -     		-inlineoverridevirtual
    -
    - -

    Removes an entity from a sparse set and destroies its object.

    -
    Warning
    Attempting to use an entity that doesn't belong to the sparse set results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode if the sparse set doesn't contain the given entity.
    -
    Parameters
    - - -
    entityA valid entity identifier.
    -
    -
    - -

    Reimplemented from entt::SparseSet< Entity >.

    - -

    Definition at line 982 of file sparse_set.hpp.

    - -
    -
    - -

    ◆ end() [1/2]

    - -
    -
    -
    -template<typename Entity , typename Type >
    - - - - - -
    - - - - - - - -
    const_iterator_type entt::SparseSet< Entity, Type >::end () const
    -     		-inline
    -
    - -

    Returns an iterator to the end.

    -

    The returned iterator points to the element following the last instance of the given type. Attempting to dereference the returned iterator results in undefined behavior.

    -
    Note
    Input iterators stay true to the order imposed by a call to either sort or respect.
    -
    Returns
    An iterator to the element following the last instance of the given type.
    - -

    Definition at line 843 of file sparse_set.hpp.

    - -
    -
    - -

    ◆ end() [2/2]

    - -
    -
    -
    -template<typename Entity , typename Type >
    - - - - - -
    - - - - - - - -
    iterator_type entt::SparseSet< Entity, Type >::end ()
    -     		-inline
    -
    - -

    Returns an iterator to the end.

    -

    The returned iterator points to the element following the last instance of the given type. Attempting to dereference the returned iterator results in undefined behavior.

    -
    Note
    Input iterators stay true to the order imposed by a call to either sort or respect.
    -
    Returns
    An iterator to the element following the last instance of the given type.
    - -

    Definition at line 861 of file sparse_set.hpp.

    - -
    -
    - -

    ◆ get() [1/2]

    - -
    -
    -
    -template<typename Entity , typename Type >
    - - - - - -
    - - - - - - - - -
    const object_type& entt::SparseSet< Entity, Type >::get (const entity_type entity) const
    -     		-inline
    -
    - -

    Returns the object associated to an entity.

    -
    Warning
    Attempting to use an entity that doesn't belong to the sparse set results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode if the sparse set doesn't contain the given entity.
    -
    Parameters
    - - -
    entityA valid entity identifier.
    -
    -
    -
    Returns
    The object associated to the entity.
    - -

    Definition at line 895 of file sparse_set.hpp.

    - -
    -
    - -

    ◆ get() [2/2]

    - -
    -
    -
    -template<typename Entity , typename Type >
    - - - - - -
    - - - - - - - - -
    object_type& entt::SparseSet< Entity, Type >::get (const entity_type entity)
    -     		-inline
    -
    - -

    Returns the object associated to an entity.

    -
    Warning
    Attempting to use an entity that doesn't belong to the sparse set results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode if the sparse set doesn't contain the given entity.
    -
    Parameters
    - - -
    entityA valid entity identifier.
    -
    -
    -
    Returns
    The object associated to the entity.
    - -

    Definition at line 911 of file sparse_set.hpp.

    - -
    -
    - -

    ◆ operator=() [1/2]

    - -
    -
    -
    -template<typename Entity , typename Type >
    - - - - - -
    - - - - - - - - -
    SparseSet& entt::SparseSet< Entity, Type >::operator= (const SparseSet< Entity, Type > & )
    -     		-delete
    -
    - -

    Copying a sparse set isn't allowed.

    -
    Returns
    This sparse set.
    - -
    -
    - -

    ◆ operator=() [2/2]

    - -
    -
    -
    -template<typename Entity , typename Type >
    - - - - - -
    - - - - - - - - -
    SparseSet& entt::SparseSet< Entity, Type >::operator= (SparseSet< Entity, Type > && )
    -     		-default
    -
    - -

    Default move assignment operator.

    -
    Returns
    This sparse set.
    - -
    -
    - -

    ◆ operator[]() [1/2]

    - -
    -
    -
    -template<typename Entity , typename Type >
    - - - - - -
    - - - - - - - - -
    const object_type& entt::SparseSet< Entity, Type >::operator[] (const size_type pos) const
    -     		-inline
    -
    - -

    Returns a reference to the element at the given position.

    -
    Parameters
    - - -
    posPosition of the element to return.
    -
    -
    -
    Returns
    A reference to the requested element.
    - -

    Definition at line 870 of file sparse_set.hpp.

    - -
    -
    - -

    ◆ operator[]() [2/2]

    - -
    -
    -
    -template<typename Entity , typename Type >
    - - - - - -
    - - - - - - - - -
    object_type& entt::SparseSet< Entity, Type >::operator[] (const size_type pos)
    -     		-inline
    -
    - -

    Returns a reference to the element at the given position.

    -
    Parameters
    - - -
    posPosition of the element to return.
    -
    -
    -
    Returns
    A reference to the requested element.
    - -

    Definition at line 879 of file sparse_set.hpp.

    - -
    -
    - -

    ◆ raw() [1/2]

    - -
    -
    -
    -template<typename Entity , typename Type >
    - - - - - -
    - - - - - - - -
    const object_type* entt::SparseSet< Entity, Type >::raw () const
    -     		-inline
    -
    - -

    Direct access to the array of objects.

    -

    The returned pointer is such that range [raw(), raw() + size()] is always a valid range, even if the container is empty.

    -
    Note
    There are no guarantees on the order, even though either sort or respect has been previously invoked. Internal data structures arrange elements to maximize performance. Accessing them directly gives a performance boost but less guarantees. Use begin and end if you want to iterate the sparse set in the expected order.
    -
    Returns
    A pointer to the array of objects.
    - -

    Definition at line 738 of file sparse_set.hpp.

    - -
    -
    - -

    ◆ raw() [2/2]

    - -
    -
    -
    -template<typename Entity , typename Type >
    - - - - - -
    - - - - - - - -
    object_type* entt::SparseSet< Entity, Type >::raw ()
    -     		-inline
    -
    - -

    Direct access to the array of objects.

    -

    The returned pointer is such that range [raw(), raw() + size()] is always a valid range, even if the container is empty.

    -
    Note
    There are no guarantees on the order, even though either sort or respect has been previously invoked. Internal data structures arrange elements to maximize performance. Accessing them directly gives a performance boost but less guarantees. Use begin and end if you want to iterate the sparse set in the expected order.
    -
    Returns
    A pointer to the array of objects.
    - -

    Definition at line 757 of file sparse_set.hpp.

    - -
    -
    - -

    ◆ reserve()

    - -
    -
    -
    -template<typename Entity , typename Type >
    - - - - - -
    - - - - - - - - -
    void entt::SparseSet< Entity, Type >::reserve (const size_type cap)
    -     		-inline
    -
    - -

    Increases the capacity of a sparse set.

    -

    If the new capacity is greater than the current capacity, new storage is allocated, otherwise the method does nothing.

    -
    Parameters
    - - -
    capDesired capacity.
    -
    -
    - -

    Definition at line 718 of file sparse_set.hpp.

    - -
    -
    - -

    ◆ respect()

    - -
    -
    -
    -template<typename Entity , typename Type >
    - - - - - -
    - - - - - - - - -
    void entt::SparseSet< Entity, Type >::respect (const SparseSet< Entity > & other)
    -     		-inline
    -
    - -

    Sort components according to the order of the entities in another sparse set.

    -

    Entities that are part of both the sparse sets are ordered internally according to the order they have in other. All the other entities goes to the end of the list and there are no guarantess on their order. Components are sorted according to the entities to which they belong.
    - In other terms, this function can be used to impose the same order on two sets by using one of them as a master and the other one as a slave.

    -

    Iterating the sparse set with a couple of iterators returns elements in the expected order after a call to respect. See begin and end for more details.

    -
    Note
    Attempting to iterate elements using a raw pointer returned by a call to either data or raw gives no guarantees on the order, even though respect has been invoked.
    -
    Parameters
    - - -
    otherThe sparse sets that imposes the order of the entities.
    -
    -
    - -

    Definition at line 1080 of file sparse_set.hpp.

    - -
    -
    - -

    ◆ sort()

    - -
    -
    -
    -template<typename Entity , typename Type >
    -
    -template<typename Compare , typename Sort = StdSort, typename... Args>
    - - - - - -
    - - - - - - - - - - - - - - - - - - - - - - - - -
    void entt::SparseSet< Entity, Type >::sort (Compare compare,
    Sort sort = Sort{},
    Args &&... args 
    )
    -     		-inline
    -
    - -

    Sort components according to the given comparison function.

    -

    Sort the elements so that iterating the sparse set with a couple of iterators returns them in the expected order. See begin and end for more details.

    -

    The comparison function object must return true if the first element is less than the second one, false otherwise. The signature of the comparison function should be equivalent to the following:

    -
    bool(const Type &, const Type &)

    Moreover, the comparison function object shall induce a strict weak ordering on the values.

    -

    The sort function oject must offer a member function template operator() that accepts three arguments:

    -
      -
    • An iterator to the first element of the range to sort.
      • -
    • An iterator past the last element of the range to sort.
      • -
    • A comparison function to use to compare the elements.
      • -
    -

    The comparison funtion object received by the sort function object hasn't necessarily the type of the one passed along with the other parameters to this member function.

    -
    Note
    Attempting to iterate elements using a raw pointer returned by a call to either data or raw gives no guarantees on the order, even though sort has been invoked.
    -
    Template Parameters
    - - - - -
    CompareType of comparison function object.
    SortType of sort function object.
    ArgsTypes of arguments to forward to the sort function object.
    -
    -
    -
    Parameters
    - - - - -
    compareA valid comparison function object.
    sortA valid sort function object.
    argsArguments to forward to the sort function object, if any.
    -
    -
    - -

    Definition at line 1033 of file sparse_set.hpp.

    - -
    -
    -
    The documentation for this class was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4__coll__graph.map b/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4__coll__graph.map deleted file mode 100644 index afb611447..000000000 --- a/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4__coll__graph.map +++ /dev/null @@ -1,3 +0,0 @@ - - - diff --git a/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4__coll__graph.md5 b/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4__coll__graph.md5 deleted file mode 100644 index 0397c6a51..000000000 --- a/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4__coll__graph.md5 +++ /dev/null @@ -1 +0,0 @@ -9dd00cc071bb6f77cee0a01806ec26e8 \ No newline at end of file diff --git a/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4__coll__graph.png b/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4__coll__graph.png deleted file mode 100644 index 60efc29ea..000000000 Binary files a/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4__coll__graph.png and /dev/null differ diff --git a/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4__inherit__graph.map b/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4__inherit__graph.map deleted file mode 100644 index afb611447..000000000 --- a/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4__inherit__graph.map +++ /dev/null @@ -1,3 +0,0 @@ - - - diff --git a/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4__inherit__graph.md5 b/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4__inherit__graph.md5 deleted file mode 100644 index 90dfdf9e9..000000000 --- a/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4__inherit__graph.md5 +++ /dev/null @@ -1 +0,0 @@ -5d66a969af4ef8af36b07c3ce805bc3f \ No newline at end of file diff --git a/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4__inherit__graph.png b/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4__inherit__graph.png deleted file mode 100644 index 60efc29ea..000000000 Binary files a/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4__inherit__graph.png and /dev/null differ diff --git a/classentt_1_1SparseSet_3_01Entity_01_4-members.html b/classentt_1_1SparseSet_3_01Entity_01_4-members.html deleted file mode 100644 index a0346757b..000000000 --- a/classentt_1_1SparseSet_3_01Entity_01_4-members.html +++ /dev/null @@ -1,112 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::SparseSet< Entity > Member List
    -
    -
    - -

    This is the complete list of members for entt::SparseSet< Entity >, including all inherited members.

    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    begin() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    begin() ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    capacity() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    cbegin() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    cend() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    const_iterator_type typedefentt::SparseSet< Entity >
    construct(const entity_type entity)entt::SparseSet< Entity >inline
    data() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    destroy(const entity_type entity)entt::SparseSet< Entity >inlinevirtual
    empty() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    end() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    end() ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    entity_type typedefentt::SparseSet< Entity >
    extent() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    fast(const entity_type entity) const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    get(const entity_type entity) const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    has(const entity_type entity) const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    iterator_type typedefentt::SparseSet< Entity >
    operator=(const SparseSet &)=deleteentt::SparseSet< Entity >
    operator=(SparseSet &&)=defaultentt::SparseSet< Entity >
    operator[](const size_type pos) const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    reserve(const size_type cap)entt::SparseSet< Entity >inline
    reset()entt::SparseSet< Entity >inlinevirtual
    respect(const SparseSet< Entity > &other) ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    size() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    size_type typedefentt::SparseSet< Entity >
    SparseSet() ENTT_NOEXCEPT=defaultentt::SparseSet< Entity >
    SparseSet(const SparseSet &)=deleteentt::SparseSet< Entity >
    SparseSet(SparseSet &&)=defaultentt::SparseSet< Entity >
    swap(const size_type lhs, const size_type rhs) ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    ~SparseSet() ENTT_NOEXCEPT=defaultentt::SparseSet< Entity >virtual
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1SparseSet_3_01Entity_01_4.html b/classentt_1_1SparseSet_3_01Entity_01_4.html deleted file mode 100644 index 675c39976..000000000 --- a/classentt_1_1SparseSet_3_01Entity_01_4.html +++ /dev/null @@ -1,1036 +0,0 @@ - - - - - - - -EnTT: entt::SparseSet< Entity > Class Template Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Classes | -Public Types | -Public Member Functions | -List of all members
    -
    -
    entt::SparseSet< Entity > Class Template Reference
    -
    -
    - -

    Basic sparse set implementation. - More...

    - -

    #include <sparse_set.hpp>

    -
    -Inheritance diagram for entt::SparseSet< Entity >:
    -
    -
    Inheritance graph
    - - - -
    [legend]
    - - - - - - - - - - - - - - -

    -Public Types

    -using entity_type = Entity
     Underlying entity identifier.
     
    -using size_type = std::size_t
     Unsigned integer type.
     
    -using iterator_type = Iterator
     Input iterator type.
     
    -using const_iterator_type = Iterator
     Constant input iterator type.
     
    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

    -Public Member Functions

    - SparseSet () ENTT_NOEXCEPT=default
     Default constructor.
     
    -virtual ~SparseSet () ENTT_NOEXCEPT=default
     Default destructor.
     
    - SparseSet (const SparseSet &)=delete
     Copying a sparse set isn't allowed.
     
    - SparseSet (SparseSet &&)=default
     Default move constructor.
     
    SparseSet & operator= (const SparseSet &)=delete
     Copying a sparse set isn't allowed. More...
     
    SparseSet & operator= (SparseSet &&)=default
     Default move assignment operator. More...
     
    void reserve (const size_type cap)
     Increases the capacity of a sparse set. More...
     
    size_type capacity () const ENTT_NOEXCEPT
     Returns the number of elements that a sparse set has currently allocated space for. More...
     
    size_type extent () const ENTT_NOEXCEPT
     Returns the extent of a sparse set. More...
     
    size_type size () const ENTT_NOEXCEPT
     Returns the number of elements in a sparse set. More...
     
    bool empty () const ENTT_NOEXCEPT
     Checks whether a sparse set is empty. More...
     
    const entity_type * data () const ENTT_NOEXCEPT
     Direct access to the internal packed array. More...
     
    const_iterator_type cbegin () const ENTT_NOEXCEPT
     Returns an iterator to the beginning. More...
     
    const_iterator_type begin () const ENTT_NOEXCEPT
     Returns an iterator to the beginning. More...
     
    iterator_type begin () ENTT_NOEXCEPT
     Returns an iterator to the beginning. More...
     
    const_iterator_type cend () const ENTT_NOEXCEPT
     Returns an iterator to the end. More...
     
    const_iterator_type end () const ENTT_NOEXCEPT
     Returns an iterator to the end. More...
     
    iterator_type end () ENTT_NOEXCEPT
     Returns an iterator to the end. More...
     
    const entity_type & operator[] (const size_type pos) const ENTT_NOEXCEPT
     Returns a reference to the element at the given position. More...
     
    bool has (const entity_type entity) const ENTT_NOEXCEPT
     Checks if a sparse set contains an entity. More...
     
    bool fast (const entity_type entity) const ENTT_NOEXCEPT
     Checks if a sparse set contains an entity (unsafe). More...
     
    size_type get (const entity_type entity) const ENTT_NOEXCEPT
     Returns the position of an entity in a sparse set. More...
     
    void construct (const entity_type entity)
     Assigns an entity to a sparse set. More...
     
    virtual void destroy (const entity_type entity)
     Removes an entity from a sparse set. More...
     
    void swap (const size_type lhs, const size_type rhs) ENTT_NOEXCEPT
     Swaps the position of two entities in the internal packed array. More...
     
    void respect (const SparseSet< Entity > &other) ENTT_NOEXCEPT
     Sort entities according to their order in another sparse set. More...
     
    -virtual void reset ()
     Resets a sparse set.
     
    -

    Detailed Description

    -

    template<typename Entity>
    -class entt::SparseSet< Entity >

    - -

    Basic sparse set implementation.

    -

    Sparse set or packed array or whatever is the name users give it.
    - Two arrays: an external one and an internal one; a sparse one and a packed one; one used for direct access through contiguous memory, the other one used to get the data through an extra level of indirection.
    - This is largely used by the Registry to offer users the fastest access ever to the components. View and PersistentView are entirely designed around sparse sets.

    -

    This type of data structure is widely documented in the literature and on the web. This is nothing more than a customized implementation suitable for the purpose of the framework.

    -
    Note
    There are no guarantees that entities are returned in the insertion order when iterate a sparse set. Do not make assumption on the order in any case.
    -
    -Internal data structures arrange elements to maximize performance. Because of that, there are no guarantees that elements have the expected order when iterate directly the internal packed array (see data and size member functions for that). Use begin and end instead.
    -
    Template Parameters
    - - -
    EntityA valid entity type (see entt_traits for more details).
    -
    -
    - -

    Definition at line 60 of file sparse_set.hpp.

    -

    Member Function Documentation

    - -

    ◆ begin() [1/2]

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - -
    const_iterator_type entt::SparseSet< Entity >::begin () const
    -     		-inline
    -
    - -

    Returns an iterator to the beginning.

    -

    The returned iterator points to the first entity of the internal packed array. If the sparse set is empty, the returned iterator will be equal to end().

    -
    Note
    Input iterators stay true to the order imposed by a call to respect.
    -
    Returns
    An iterator to the first entity of the internal packed array.
    - -

    Definition at line 298 of file sparse_set.hpp.

    - -
    -
    - -

    ◆ begin() [2/2]

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - -
    iterator_type entt::SparseSet< Entity >::begin ()
    -     		-inline
    -
    - -

    Returns an iterator to the beginning.

    -

    The returned iterator points to the first entity of the internal packed array. If the sparse set is empty, the returned iterator will be equal to end().

    -
    Note
    Input iterators stay true to the order imposed by a call to respect.
    -
    Returns
    An iterator to the first entity of the internal packed array.
    - -

    Definition at line 314 of file sparse_set.hpp.

    - -
    -
    - -

    ◆ capacity()

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - -
    size_type entt::SparseSet< Entity >::capacity () const
    -     		-inline
    -
    - -

    Returns the number of elements that a sparse set has currently allocated space for.

    -
    Returns
    Capacity of the sparse set.
    - -

    Definition at line 210 of file sparse_set.hpp.

    - -
    -
    - -

    ◆ cbegin()

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - -
    const_iterator_type entt::SparseSet< Entity >::cbegin () const
    -     		-inline
    -
    - -

    Returns an iterator to the beginning.

    -

    The returned iterator points to the first entity of the internal packed array. If the sparse set is empty, the returned iterator will be equal to end().

    -
    Note
    Input iterators stay true to the order imposed by a call to respect.
    -
    Returns
    An iterator to the first entity of the internal packed array.
    - -

    Definition at line 281 of file sparse_set.hpp.

    - -
    -
    - -

    ◆ cend()

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - -
    const_iterator_type entt::SparseSet< Entity >::cend () const
    -     		-inline
    -
    - -

    Returns an iterator to the end.

    -

    The returned iterator points to the element following the last entity in the internal packed array. Attempting to dereference the returned iterator results in undefined behavior.

    -
    Note
    Input iterators stay true to the order imposed by a call to respect.
    -
    Returns
    An iterator to the element following the last entity of the internal packed array.
    - -

    Definition at line 331 of file sparse_set.hpp.

    - -
    -
    - -

    ◆ construct()

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - - -
    void entt::SparseSet< Entity >::construct (const entity_type entity)
    -     		-inline
    -
    - -

    Assigns an entity to a sparse set.

    -
    Warning
    Attempting to assign an entity that already belongs to the sparse set results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode if the sparse set already contains the given entity.
    -
    Parameters
    - - -
    entityA valid entity identifier.
    -
    -
    - -

    Definition at line 442 of file sparse_set.hpp.

    - -
    -
    - -

    ◆ data()

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - -
    const entity_type* entt::SparseSet< Entity >::data () const
    -     		-inline
    -
    - -

    Direct access to the internal packed array.

    -

    The returned pointer is such that range [data(), data() + size()] is always a valid range, even if the container is empty.

    -
    Note
    There are no guarantees on the order, even though respect has been previously invoked. Internal data structures arrange elements to maximize performance. Accessing them directly gives a performance boost but less guarantees. Use begin and end if you want to iterate the sparse set in the expected order.
    -
    Returns
    A pointer to the internal packed array.
    - -

    Definition at line 265 of file sparse_set.hpp.

    - -
    -
    - -

    ◆ destroy()

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - - -
    virtual void entt::SparseSet< Entity >::destroy (const entity_type entity)
    -     		-inlinevirtual
    -
    - -

    Removes an entity from a sparse set.

    -
    Warning
    Attempting to remove an entity that doesn't belong to the sparse set results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode if the sparse set doesn't contain the given entity.
    -
    Parameters
    - - -
    entityA valid entity identifier.
    -
    -
    - -

    Reimplemented in entt::SparseSet< Entity, Type >.

    - -

    Definition at line 466 of file sparse_set.hpp.

    - -
    -
    - -

    ◆ empty()

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - -
    bool entt::SparseSet< Entity >::empty () const
    -     		-inline
    -
    - -

    Checks whether a sparse set is empty.

    -
    Returns
    True if the sparse set is empty, false otherwise.
    - -

    Definition at line 246 of file sparse_set.hpp.

    - -
    -
    - -

    ◆ end() [1/2]

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - -
    const_iterator_type entt::SparseSet< Entity >::end () const
    -     		-inline
    -
    - -

    Returns an iterator to the end.

    -

    The returned iterator points to the element following the last entity in the internal packed array. Attempting to dereference the returned iterator results in undefined behavior.

    -
    Note
    Input iterators stay true to the order imposed by a call to respect.
    -
    Returns
    An iterator to the element following the last entity of the internal packed array.
    - -

    Definition at line 348 of file sparse_set.hpp.

    - -
    -
    - -

    ◆ end() [2/2]

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - -
    iterator_type entt::SparseSet< Entity >::end ()
    -     		-inline
    -
    - -

    Returns an iterator to the end.

    -

    The returned iterator points to the element following the last entity in the internal packed array. Attempting to dereference the returned iterator results in undefined behavior.

    -
    Note
    Input iterators stay true to the order imposed by a call to respect.
    -
    Returns
    An iterator to the element following the last entity of the internal packed array.
    - -

    Definition at line 365 of file sparse_set.hpp.

    - -
    -
    - -

    ◆ extent()

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - -
    size_type entt::SparseSet< Entity >::extent () const
    -     		-inline
    -
    - -

    Returns the extent of a sparse set.

    -

    The extent of a sparse set is also the size of the internal sparse array. There is no guarantee that the internal packed array has the same size. Usually the size of the internal sparse array is equal or greater than the one of the internal packed array.

    -
    Returns
    Extent of the sparse set.
    - -

    Definition at line 224 of file sparse_set.hpp.

    - -
    -
    - -

    ◆ fast()

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - - -
    bool entt::SparseSet< Entity >::fast (const entity_type entity) const
    -     		-inline
    -
    - -

    Checks if a sparse set contains an entity (unsafe).

    -

    Alternative version of has. It accesses the underlying data structures without bounds checking and thus it's both unsafe and risky to use.
    - You should not invoke directly this function unless you know exactly what you are doing. Prefer the has member function instead.

    -
    Warning
    Attempting to use an entity that doesn't belong to the sparse set can result in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode in case of bounds violation.
    -
    Parameters
    - - -
    entityA valid entity identifier.
    -
    -
    -
    Returns
    True if the sparse set contains the entity, false otherwise.
    - -

    Definition at line 406 of file sparse_set.hpp.

    - -
    -
    - -

    ◆ get()

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - - -
    size_type entt::SparseSet< Entity >::get (const entity_type entity) const
    -     		-inline
    -
    - -

    Returns the position of an entity in a sparse set.

    -
    Warning
    Attempting to get the position of an entity that doesn't belong to the sparse set results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode if the sparse set doesn't contain the given entity.
    -
    Parameters
    - - -
    entityA valid entity identifier.
    -
    -
    -
    Returns
    The position of the entity in the sparse set.
    - -

    Definition at line 425 of file sparse_set.hpp.

    - -
    -
    - -

    ◆ has()

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - - -
    bool entt::SparseSet< Entity >::has (const entity_type entity) const
    -     		-inline
    -
    - -

    Checks if a sparse set contains an entity.

    -
    Parameters
    - - -
    entityA valid entity identifier.
    -
    -
    -
    Returns
    True if the sparse set contains the entity, false otherwise.
    - -

    Definition at line 383 of file sparse_set.hpp.

    - -
    -
    - -

    ◆ operator=() [1/2]

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - - -
    SparseSet& entt::SparseSet< Entity >::operator= (const SparseSet< Entity > & )
    -     		-delete
    -
    - -

    Copying a sparse set isn't allowed.

    -
    Returns
    This sparse set.
    - -
    -
    - -

    ◆ operator=() [2/2]

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - - -
    SparseSet& entt::SparseSet< Entity >::operator= (SparseSet< Entity > && )
    -     		-default
    -
    - -

    Default move assignment operator.

    -
    Returns
    This sparse set.
    - -
    -
    - -

    ◆ operator[]()

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - - -
    const entity_type& entt::SparseSet< Entity >::operator[] (const size_type pos) const
    -     		-inline
    -
    - -

    Returns a reference to the element at the given position.

    -
    Parameters
    - - -
    posPosition of the element to return.
    -
    -
    -
    Returns
    A reference to the requested element.
    - -

    Definition at line 374 of file sparse_set.hpp.

    - -
    -
    - -

    ◆ reserve()

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - - -
    void entt::SparseSet< Entity >::reserve (const size_type cap)
    -     		-inline
    -
    - -

    Increases the capacity of a sparse set.

    -

    If the new capacity is greater than the current capacity, new storage is allocated, otherwise the method does nothing.

    -
    Parameters
    - - -
    capDesired capacity.
    -
    -
    - -

    Definition at line 201 of file sparse_set.hpp.

    - -
    -
    - -

    ◆ respect()

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - - -
    void entt::SparseSet< Entity >::respect (const SparseSet< Entity > & other)
    -     		-inline
    -
    - -

    Sort entities according to their order in another sparse set.

    -

    Entities that are part of both the sparse sets are ordered internally according to the order they have in other. All the other entities goes to the end of the list and there are no guarantess on their order.
    - In other terms, this function can be used to impose the same order on two sets by using one of them as a master and the other one as a slave.

    -

    Iterating the sparse set with a couple of iterators returns elements in the expected order after a call to respect. See begin and end for more details.

    -
    Note
    Attempting to iterate elements using the raw pointer returned by data gives no guarantees on the order, even though respect has been invoked.
    -
    Parameters
    - - -
    otherThe sparse sets that imposes the order of the entities.
    -
    -
    - -

    Definition at line 520 of file sparse_set.hpp.

    - -
    -
    - -

    ◆ size()

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - -
    size_type entt::SparseSet< Entity >::size () const
    -     		-inline
    -
    - -

    Returns the number of elements in a sparse set.

    -

    The number of elements is also the size of the internal packed array. There is no guarantee that the internal sparse array has the same size. Usually the size of the internal sparse array is equal or greater than the one of the internal packed array.

    -
    Returns
    Number of elements.
    - -

    Definition at line 238 of file sparse_set.hpp.

    - -
    -
    - -

    ◆ swap()

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - - - - - - - - - - - - -
    void entt::SparseSet< Entity >::swap (const size_type lhs,
    const size_type rhs 
    )
    -     		-inline
    -
    - -

    Swaps the position of two entities in the internal packed array.

    -

    For what it's worth, this function affects both the internal sparse array and the internal packed array. Users should not care of that anyway.

    -
    Warning
    Attempting to swap entities that don't belong to the sparse set results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode if the sparse set doesn't contain the given entities.
    -
    Parameters
    - - - -
    lhsA valid position within the sparse set.
    rhsA valid position within the sparse set.
    -
    -
    - -

    Definition at line 492 of file sparse_set.hpp.

    - -
    -
    -
    The documentation for this class was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1SparseSet_3_01Entity_01_4__inherit__graph.map b/classentt_1_1SparseSet_3_01Entity_01_4__inherit__graph.map deleted file mode 100644 index d25f98594..000000000 --- a/classentt_1_1SparseSet_3_01Entity_01_4__inherit__graph.map +++ /dev/null @@ -1,3 +0,0 @@ - - - diff --git a/classentt_1_1SparseSet_3_01Entity_01_4__inherit__graph.md5 b/classentt_1_1SparseSet_3_01Entity_01_4__inherit__graph.md5 deleted file mode 100644 index 877ab7b26..000000000 --- a/classentt_1_1SparseSet_3_01Entity_01_4__inherit__graph.md5 +++ /dev/null @@ -1 +0,0 @@ -6d71b221f475a29f7b7544220a193386 \ No newline at end of file diff --git a/classentt_1_1SparseSet_3_01Entity_01_4__inherit__graph.png b/classentt_1_1SparseSet_3_01Entity_01_4__inherit__graph.png deleted file mode 100644 index 53642da80..000000000 Binary files a/classentt_1_1SparseSet_3_01Entity_01_4__inherit__graph.png and /dev/null differ diff --git a/classentt_1_1View-members.html b/classentt_1_1View-members.html deleted file mode 100644 index 12e829c09..000000000 --- a/classentt_1_1View-members.html +++ /dev/null @@ -1,101 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::View< Entity, Component > Member List
    -
    -
    - -

    This is the complete list of members for entt::View< Entity, Component >, including all inherited members.

    - - - - - - - - - - - - - - - - - - - - - -
    begin() const ENTT_NOEXCEPTentt::View< Entity, Component >inline
    begin() ENTT_NOEXCEPTentt::View< Entity, Component >inline
    cbegin() const ENTT_NOEXCEPTentt::View< Entity, Component >inline
    cend() const ENTT_NOEXCEPTentt::View< Entity, Component >inline
    const_iterator_type typedefentt::View< Entity, Component >
    contains(const entity_type entity) const ENTT_NOEXCEPTentt::View< Entity, Component >inline
    each(Func func) constentt::View< Entity, Component >inline
    each(Func func)entt::View< Entity, Component >inline
    empty() const ENTT_NOEXCEPTentt::View< Entity, Component >inline
    end() const ENTT_NOEXCEPTentt::View< Entity, Component >inline
    end() ENTT_NOEXCEPTentt::View< Entity, Component >inline
    entity_type typedefentt::View< Entity, Component >
    get(const entity_type entity) const ENTT_NOEXCEPTentt::View< Entity, Component >inline
    get(const entity_type entity) ENTT_NOEXCEPTentt::View< Entity, Component >inline
    get(const entity_type entity) const ENTT_NOEXCEPTentt::View< Entity, Component >inline
    get(const entity_type entity) ENTT_NOEXCEPTentt::View< Entity, Component >inline
    iterator_type typedefentt::View< Entity, Component >
    Registry< Entity > classentt::View< Entity, Component >friend
    size() const ENTT_NOEXCEPTentt::View< Entity, Component >inline
    size_type typedefentt::View< Entity, Component >
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1View.html b/classentt_1_1View.html deleted file mode 100644 index 94e867c44..000000000 --- a/classentt_1_1View.html +++ /dev/null @@ -1,809 +0,0 @@ - - - - - - - -EnTT: entt::View< Entity, Component > Class Template Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Classes | -Public Types | -Public Member Functions | -Friends | -List of all members
    -
    -
    entt::View< Entity, Component > Class Template Referencefinal
    -
    -
    - -

    Multi component view. - More...

    - -

    #include <view.hpp>

    - - - - - - - - - - - - - - -

    -Public Types

    -using entity_type = typename view_type::entity_type
     Underlying entity identifier.
     
    -using size_type = typename view_type::size_type
     Unsigned integer type.
     
    -using iterator_type = Iterator
     Input iterator type.
     
    -using const_iterator_type = Iterator
     Constant input iterator type.
     
    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

    -Public Member Functions

    size_type size () const ENTT_NOEXCEPT
     Estimates the number of entities that have the given components. More...
     
    bool empty () const ENTT_NOEXCEPT
     Checks if the view is definitely empty. More...
     
    const_iterator_type cbegin () const ENTT_NOEXCEPT
     Returns an iterator to the first entity that has the given components. More...
     
    const_iterator_type begin () const ENTT_NOEXCEPT
     Returns an iterator to the first entity that has the given components. More...
     
    iterator_type begin () ENTT_NOEXCEPT
     Returns an iterator to the first entity that has the given components. More...
     
    const_iterator_type cend () const ENTT_NOEXCEPT
     Returns an iterator that is past the last entity that has the given components. More...
     
    const_iterator_type end () const ENTT_NOEXCEPT
     Returns an iterator that is past the last entity that has the given components. More...
     
    iterator_type end () ENTT_NOEXCEPT
     Returns an iterator that is past the last entity that has the given components. More...
     
    bool contains (const entity_type entity) const ENTT_NOEXCEPT
     Checks if a view contains an entity. More...
     
    template<typename Comp >
    const Comp & get (const entity_type entity) const ENTT_NOEXCEPT
     Returns the component assigned to the given entity. More...
     
    template<typename Comp >
    Comp & get (const entity_type entity) ENTT_NOEXCEPT
     Returns the component assigned to the given entity. More...
     
    template<typename... Comp>
    std::enable_if_t<(sizeof...(Comp) > 1), std::tuple< const Comp &... > > get (const entity_type entity) const ENTT_NOEXCEPT
     Returns the components assigned to the given entity. More...
     
    template<typename... Comp>
    std::enable_if_t<(sizeof...(Comp) > 1), std::tuple< Comp &... > > get (const entity_type entity) ENTT_NOEXCEPT
     Returns the components assigned to the given entity. More...
     
    template<typename Func >
    void each (Func func) const
     Iterates entities and components and applies the given function object to them. More...
     
    template<typename Func >
    void each (Func func)
     Iterates entities and components and applies the given function object to them. More...
     
    - - - - -

    -Friends

    -class Registry< Entity >
     A registry is allowed to create views.
     
    -

    Detailed Description

    -

    template<typename Entity, typename... Component>
    -class entt::View< Entity, Component >

    - -

    Multi component view.

    -

    Multi component views iterate over those entities that have at least all the given components in their bags. During initialization, a multi component view looks at the number of entities available for each component and picks up a reference to the smallest set of candidate entities in order to get a performance boost when iterate.
    - Order of elements during iterations are highly dependent on the order of the underlying data structures. See SparseSet and its specializations for more details.

    -

    Important

    -

    Iterators aren't invalidated if:

    -
      -
    • New instances of the given components are created and assigned to entities.
      • -
    • The entity currently pointed is modified (as an example, if one of the given components is removed from the entity to which the iterator points).
      • -
    -

    In all the other cases, modifying the pools of the given components in any way invalidates all the iterators and using them results in undefined behavior.

    -
    Note
    Views share references to the underlying data structures with the Registry that generated them. Therefore any change to the entities and to the components made by means of the registry are immediately reflected by views.
    -
    Warning
    Lifetime of a view must overcome the one of the registry that generated it. In any other case, attempting to use a view results in undefined behavior.
    -
    See also
    View<Entity, Component>
    -
    -PersistentView
    -
    -RawView
    -
    -RuntimeView
    -
    Template Parameters
    - - - -
    EntityA valid entity type (see entt_traits for more details).
    ComponentTypes of components iterated by the view.
    -
    -
    - -

    Definition at line 466 of file view.hpp.

    -

    Member Function Documentation

    - -

    ◆ begin() [1/2]

    - -
    -
    -
    -template<typename Entity , typename... Component>
    - - - - - -
    - - - - - - - -
    const_iterator_type entt::View< Entity, Component >::begin () const
    -     		-inline
    -
    - -

    Returns an iterator to the first entity that has the given components.

    -

    The returned iterator points to the first entity that has the given components. If the view is empty, the returned iterator will be equal to end().

    -
    Note
    Input iterators stay true to the order imposed to the underlying data structures.
    -
    Returns
    An iterator to the first entity that has the given components.
    - -

    Definition at line 676 of file view.hpp.

    - -
    -
    - -

    ◆ begin() [2/2]

    - -
    -
    -
    -template<typename Entity , typename... Component>
    - - - - - -
    - - - - - - - -
    iterator_type entt::View< Entity, Component >::begin ()
    -     		-inline
    -
    - -

    Returns an iterator to the first entity that has the given components.

    -

    The returned iterator points to the first entity that has the given components. If the view is empty, the returned iterator will be equal to end().

    -
    Note
    Input iterators stay true to the order imposed to the underlying data structures.
    -
    Returns
    An iterator to the first entity that has the given components.
    - -

    Definition at line 694 of file view.hpp.

    - -
    -
    - -

    ◆ cbegin()

    - -
    -
    -
    -template<typename Entity , typename... Component>
    - - - - - -
    - - - - - - - -
    const_iterator_type entt::View< Entity, Component >::cbegin () const
    -     		-inline
    -
    - -

    Returns an iterator to the first entity that has the given components.

    -

    The returned iterator points to the first entity that has the given components. If the view is empty, the returned iterator will be equal to end().

    -
    Note
    Input iterators stay true to the order imposed to the underlying data structures.
    -
    Returns
    An iterator to the first entity that has the given components.
    - -

    Definition at line 657 of file view.hpp.

    - -
    -
    - -

    ◆ cend()

    - -
    -
    -
    -template<typename Entity , typename... Component>
    - - - - - -
    - - - - - - - -
    const_iterator_type entt::View< Entity, Component >::cend () const
    -     		-inline
    -
    - -

    Returns an iterator that is past the last entity that has the given components.

    -

    The returned iterator points to the entity following the last entity that has the given components. Attempting to dereference the returned iterator results in undefined behavior.

    -
    Note
    Input iterators stay true to the order imposed to the underlying data structures.
    -
    Returns
    An iterator to the entity following the last entity that has the given components.
    - -

    Definition at line 713 of file view.hpp.

    - -
    -
    - -

    ◆ contains()

    - -
    -
    -
    -template<typename Entity , typename... Component>
    - - - - - -
    - - - - - - - - -
    bool entt::View< Entity, Component >::contains (const entity_type entity) const
    -     		-inline
    -
    - -

    Checks if a view contains an entity.

    -
    Parameters
    - - -
    entityA valid entity identifier.
    -
    -
    -
    Returns
    True if the view contains the given entity, false otherwise.
    - -

    Definition at line 761 of file view.hpp.

    - -
    -
    - -

    ◆ each() [1/2]

    - -
    -
    -
    -template<typename Entity , typename... Component>
    -
    -template<typename Func >
    - - - - - -
    - - - - - - - - -
    void entt::View< Entity, Component >::each (Func func) const
    -     		-inline
    -
    - -

    Iterates entities and components and applies the given function object to them.

    -

    The function object is invoked for each entity. It is provided with the entity itself and a set of const references to all the components of the view.
    - The signature of the function should be equivalent to the following:

    -
    void(const entity_type, const Component &...);
    Template Parameters
    - - -
    FuncType of the function object to invoke.
    -
    -
    -
    Parameters
    - - -
    funcA valid function object.
    -
    -
    - -

    Definition at line 877 of file view.hpp.

    - -
    -
    - -

    ◆ each() [2/2]

    - -
    -
    -
    -template<typename Entity , typename... Component>
    -
    -template<typename Func >
    - - - - - -
    - - - - - - - - -
    void entt::View< Entity, Component >::each (Func func)
    -     		-inline
    -
    - -

    Iterates entities and components and applies the given function object to them.

    -

    The function object is invoked for each entity. It is provided with the entity itself and a set of references to all the components of the view.
    - The signature of the function should be equivalent to the following:

    -
    void(const entity_type, Component &...);
    Template Parameters
    - - -
    FuncType of the function object to invoke.
    -
    -
    -
    Parameters
    - - -
    funcA valid function object.
    -
    -
    - -

    Definition at line 901 of file view.hpp.

    - -
    -
    - -

    ◆ empty()

    - -
    -
    -
    -template<typename Entity , typename... Component>
    - - - - - -
    - - - - - - - -
    bool entt::View< Entity, Component >::empty () const
    -     		-inline
    -
    - -

    Checks if the view is definitely empty.

    -
    Returns
    True if the view is definitely empty, false otherwise.
    - -

    Definition at line 639 of file view.hpp.

    - -
    -
    - -

    ◆ end() [1/2]

    - -
    -
    -
    -template<typename Entity , typename... Component>
    - - - - - -
    - - - - - - - -
    const_iterator_type entt::View< Entity, Component >::end () const
    -     		-inline
    -
    - -

    Returns an iterator that is past the last entity that has the given components.

    -

    The returned iterator points to the entity following the last entity that has the given components. Attempting to dereference the returned iterator results in undefined behavior.

    -
    Note
    Input iterators stay true to the order imposed to the underlying data structures.
    -
    Returns
    An iterator to the entity following the last entity that has the given components.
    - -

    Definition at line 733 of file view.hpp.

    - -
    -
    - -

    ◆ end() [2/2]

    - -
    -
    -
    -template<typename Entity , typename... Component>
    - - - - - -
    - - - - - - - -
    iterator_type entt::View< Entity, Component >::end ()
    -     		-inline
    -
    - -

    Returns an iterator that is past the last entity that has the given components.

    -

    The returned iterator points to the entity following the last entity that has the given components. Attempting to dereference the returned iterator results in undefined behavior.

    -
    Note
    Input iterators stay true to the order imposed to the underlying data structures.
    -
    Returns
    An iterator to the entity following the last entity that has the given components.
    - -

    Definition at line 752 of file view.hpp.

    - -
    -
    - -

    ◆ get() [1/4]

    - -
    -
    -
    -template<typename Entity , typename... Component>
    -
    -template<typename Comp >
    - - - - - -
    - - - - - - - - -
    const Comp& entt::View< Entity, Component >::get (const entity_type entity) const
    -     		-inline
    -
    - -

    Returns the component assigned to the given entity.

    -

    Prefer this function instead of Registry::get during iterations. It has far better performance than its companion function.

    -
    Warning
    Attempting to use an invalid component type results in a compilation error. Attempting to use an entity that doesn't belong to the view results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode if the view doesn't contain the given entity.
    -
    Template Parameters
    - - -
    CompType of component to get.
    -
    -
    -
    Parameters
    - - -
    entityA valid entity identifier.
    -
    -
    -
    Returns
    The component assigned to the entity.
    - -

    Definition at line 785 of file view.hpp.

    - -
    -
    - -

    ◆ get() [2/4]

    - -
    -
    -
    -template<typename Entity , typename... Component>
    -
    -template<typename Comp >
    - - - - - -
    - - - - - - - - -
    Comp& entt::View< Entity, Component >::get (const entity_type entity)
    -     		-inline
    -
    - -

    Returns the component assigned to the given entity.

    -

    Prefer this function instead of Registry::get during iterations. It has far better performance than its companion function.

    -
    Warning
    Attempting to use an invalid component type results in a compilation error. Attempting to use an entity that doesn't belong to the view results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode if the view doesn't contain the given entity.
    -
    Template Parameters
    - - -
    CompType of component to get.
    -
    -
    -
    Parameters
    - - -
    entityA valid entity identifier.
    -
    -
    -
    Returns
    The component assigned to the entity.
    - -

    Definition at line 808 of file view.hpp.

    - -
    -
    - -

    ◆ get() [3/4]

    - -
    -
    -
    -template<typename Entity , typename... Component>
    -
    -template<typename... Comp>
    - - - - - -
    - - - - - - - - -
    std::enable_if_t<(sizeof...(Comp) > 1), std::tuple<const Comp &...> > entt::View< Entity, Component >::get (const entity_type entity) const
    -     		-inline
    -
    - -

    Returns the components assigned to the given entity.

    -

    Prefer this function instead of Registry::get during iterations. It has far better performance than its companion function.

    -
    Warning
    Attempting to use invalid component types results in a compilation error. Attempting to use an entity that doesn't belong to the view results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode if the view doesn't contain the given entity.
    -
    Template Parameters
    - - -
    CompTypes of the components to get.
    -
    -
    -
    Parameters
    - - -
    entityA valid entity identifier.
    -
    -
    -
    Returns
    The components assigned to the entity.
    - -

    Definition at line 831 of file view.hpp.

    - -
    -
    - -

    ◆ get() [4/4]

    - -
    -
    -
    -template<typename Entity , typename... Component>
    -
    -template<typename... Comp>
    - - - - - -
    - - - - - - - - -
    std::enable_if_t<(sizeof...(Comp) > 1), std::tuple<Comp &...> > entt::View< Entity, Component >::get (const entity_type entity)
    -     		-inline
    -
    - -

    Returns the components assigned to the given entity.

    -

    Prefer this function instead of Registry::get during iterations. It has far better performance than its companion function.

    -
    Warning
    Attempting to use invalid component types results in a compilation error. Attempting to use an entity that doesn't belong to the view results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode if the view doesn't contain the given entity.
    -
    Template Parameters
    - - -
    CompTypes of the components to get.
    -
    -
    -
    Parameters
    - - -
    entityA valid entity identifier.
    -
    -
    -
    Returns
    The components assigned to the entity.
    - -

    Definition at line 855 of file view.hpp.

    - -
    -
    - -

    ◆ size()

    - -
    -
    -
    -template<typename Entity , typename... Component>
    - - - - - -
    - - - - - - - -
    size_type entt::View< Entity, Component >::size () const
    -     		-inline
    -
    - -

    Estimates the number of entities that have the given components.

    -
    Returns
    Estimated number of entities that have the given components.
    - -

    Definition at line 631 of file view.hpp.

    - -
    -
    -
    The documentation for this class was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1View_3_01Entity_00_01Component_01_4-members.html b/classentt_1_1View_3_01Entity_00_01Component_01_4-members.html deleted file mode 100644 index 53b7f9abc..000000000 --- a/classentt_1_1View_3_01Entity_00_01Component_01_4-members.html +++ /dev/null @@ -1,104 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::View< Entity, Component > Member List
    -
    -
    - -

    This is the complete list of members for entt::View< Entity, Component >, including all inherited members.

    - - - - - - - - - - - - - - - - - - - - - - - - -
    begin() const ENTT_NOEXCEPTentt::View< Entity, Component >inline
    begin() ENTT_NOEXCEPTentt::View< Entity, Component >inline
    cbegin() const ENTT_NOEXCEPTentt::View< Entity, Component >inline
    cend() const ENTT_NOEXCEPTentt::View< Entity, Component >inline
    const_iterator_type typedefentt::View< Entity, Component >
    contains(const entity_type entity) const ENTT_NOEXCEPTentt::View< Entity, Component >inline
    data() const ENTT_NOEXCEPTentt::View< Entity, Component >inline
    each(Func func) constentt::View< Entity, Component >inline
    each(Func func)entt::View< Entity, Component >inline
    empty() const ENTT_NOEXCEPTentt::View< Entity, Component >inline
    end() const ENTT_NOEXCEPTentt::View< Entity, Component >inline
    end() ENTT_NOEXCEPTentt::View< Entity, Component >inline
    entity_type typedefentt::View< Entity, Component >
    get(const entity_type entity) const ENTT_NOEXCEPTentt::View< Entity, Component >inline
    get(const entity_type entity) ENTT_NOEXCEPTentt::View< Entity, Component >inline
    iterator_type typedefentt::View< Entity, Component >
    operator[](const size_type pos) const ENTT_NOEXCEPTentt::View< Entity, Component >inline
    raw() const ENTT_NOEXCEPTentt::View< Entity, Component >inline
    raw() ENTT_NOEXCEPTentt::View< Entity, Component >inline
    raw_type typedefentt::View< Entity, Component >
    Registry< Entity > classentt::View< Entity, Component >friend
    size() const ENTT_NOEXCEPTentt::View< Entity, Component >inline
    size_type typedefentt::View< Entity, Component >
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1View_3_01Entity_00_01Component_01_4.html b/classentt_1_1View_3_01Entity_00_01Component_01_4.html deleted file mode 100644 index 5d6811049..000000000 --- a/classentt_1_1View_3_01Entity_00_01Component_01_4.html +++ /dev/null @@ -1,839 +0,0 @@ - - - - - - - -EnTT: entt::View< Entity, Component > Class Template Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Public Types | -Public Member Functions | -Friends | -List of all members
    -
    -
    entt::View< Entity, Component > Class Template Referencefinal
    -
    -
    - -

    Single component view specialization. - More...

    - -

    #include <view.hpp>

    - - - - - - - - - - - - - - - - - -

    -Public Types

    -using raw_type = typename pool_type::object_type
     Type of component iterated by the view.
     
    -using entity_type = typename pool_type::entity_type
     Underlying entity identifier.
     
    -using size_type = typename pool_type::size_type
     Unsigned integer type.
     
    -using iterator_type = typename view_type::iterator_type
     Input iterator type.
     
    -using const_iterator_type = typename view_type::const_iterator_type
     Constant input iterator type.
     
    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

    -Public Member Functions

    size_type size () const ENTT_NOEXCEPT
     Returns the number of entities that have the given component. More...
     
    bool empty () const ENTT_NOEXCEPT
     Checks whether the view is empty. More...
     
    const raw_type * raw () const ENTT_NOEXCEPT
     Direct access to the list of components. More...
     
    raw_type * raw () ENTT_NOEXCEPT
     Direct access to the list of components. More...
     
    const entity_type * data () const ENTT_NOEXCEPT
     Direct access to the list of entities. More...
     
    const_iterator_type cbegin () const ENTT_NOEXCEPT
     Returns an iterator to the first entity that has the given component. More...
     
    const_iterator_type begin () const ENTT_NOEXCEPT
     Returns an iterator to the first entity that has the given component. More...
     
    iterator_type begin () ENTT_NOEXCEPT
     Returns an iterator to the first entity that has the given component. More...
     
    const_iterator_type cend () const ENTT_NOEXCEPT
     Returns an iterator that is past the last entity that has the given component. More...
     
    const_iterator_type end () const ENTT_NOEXCEPT
     Returns an iterator that is past the last entity that has the given component. More...
     
    iterator_type end () ENTT_NOEXCEPT
     Returns an iterator that is past the last entity that has the given component. More...
     
    const entity_type & operator[] (const size_type pos) const ENTT_NOEXCEPT
     Returns a reference to the element at the given position. More...
     
    bool contains (const entity_type entity) const ENTT_NOEXCEPT
     Checks if a view contains an entity. More...
     
    const Component & get (const entity_type entity) const ENTT_NOEXCEPT
     Returns the component assigned to the given entity. More...
     
    Component & get (const entity_type entity) ENTT_NOEXCEPT
     Returns the component assigned to the given entity. More...
     
    template<typename Func >
    void each (Func func) const
     Iterates entities and components and applies the given function object to them. More...
     
    template<typename Func >
    void each (Func func)
     Iterates entities and components and applies the given function object to them. More...
     
    - - - - -

    -Friends

    -class Registry< Entity >
     A registry is allowed to create views.
     
    -

    Detailed Description

    -

    template<typename Entity, typename Component>
    -class entt::View< Entity, Component >

    - -

    Single component view specialization.

    -

    Single component views are specialized in order to get a boost in terms of performance. This kind of views can access the underlying data structure directly and avoid superfluous checks.
    - Order of elements during iterations are highly dependent on the order of the underlying data structure. See SparseSet and its specializations for more details.

    -

    Important

    -

    Iterators aren't invalidated if:

    -
      -
    • New instances of the given component are created and assigned to entities.
      • -
    • The entity currently pointed is modified (as an example, the given component is removed from the entity to which the iterator points).
      • -
    -

    In all the other cases, modifying the pool of the given component in any way invalidates all the iterators and using them results in undefined behavior.

    -
    Note
    Views share a reference to the underlying data structure with the Registry that generated them. Therefore any change to the entities and to the components made by means of the registry are immediately reflected by views.
    -
    Warning
    Lifetime of a view must overcome the one of the registry that generated it. In any other case, attempting to use a view results in undefined behavior.
    -
    See also
    View
    -
    -PersistentView
    -
    -RawView
    -
    -RuntimeView
    -
    Template Parameters
    - - - -
    EntityA valid entity type (see entt_traits for more details).
    ComponentType of component iterated by the view.
    -
    -
    - -

    Definition at line 951 of file view.hpp.

    -

    Member Function Documentation

    - -

    ◆ begin() [1/2]

    - -
    -
    -
    -template<typename Entity , typename Component >
    - - - - - -
    - - - - - - - -
    const_iterator_type entt::View< Entity, Component >::begin () const
    -     		-inline
    -
    - -

    Returns an iterator to the first entity that has the given component.

    -

    The returned iterator points to the first entity that has the given component. If the view is empty, the returned iterator will be equal to end().

    -
    Note
    Input iterators stay true to the order imposed to the underlying data structures.
    -
    Returns
    An iterator to the first entity that has the given component.
    - -

    Definition at line 1070 of file view.hpp.

    - -
    -
    - -

    ◆ begin() [2/2]

    - -
    -
    -
    -template<typename Entity , typename Component >
    - - - - - -
    - - - - - - - -
    iterator_type entt::View< Entity, Component >::begin ()
    -     		-inline
    -
    - -

    Returns an iterator to the first entity that has the given component.

    -

    The returned iterator points to the first entity that has the given component. If the view is empty, the returned iterator will be equal to end().

    -
    Note
    Input iterators stay true to the order imposed to the underlying data structures.
    -
    Returns
    An iterator to the first entity that has the given component.
    - -

    Definition at line 1088 of file view.hpp.

    - -
    -
    - -

    ◆ cbegin()

    - -
    -
    -
    -template<typename Entity , typename Component >
    - - - - - -
    - - - - - - - -
    const_iterator_type entt::View< Entity, Component >::cbegin () const
    -     		-inline
    -
    - -

    Returns an iterator to the first entity that has the given component.

    -

    The returned iterator points to the first entity that has the given component. If the view is empty, the returned iterator will be equal to end().

    -
    Note
    Input iterators stay true to the order imposed to the underlying data structures.
    -
    Returns
    An iterator to the first entity that has the given component.
    - -

    Definition at line 1052 of file view.hpp.

    - -
    -
    - -

    ◆ cend()

    - -
    -
    -
    -template<typename Entity , typename Component >
    - - - - - -
    - - - - - - - -
    const_iterator_type entt::View< Entity, Component >::cend () const
    -     		-inline
    -
    - -

    Returns an iterator that is past the last entity that has the given component.

    -

    The returned iterator points to the entity following the last entity that has the given component. Attempting to dereference the returned iterator results in undefined behavior.

    -
    Note
    Input iterators stay true to the order imposed to the underlying data structures.
    -
    Returns
    An iterator to the entity following the last entity that has the given component.
    - -

    Definition at line 1107 of file view.hpp.

    - -
    -
    - -

    ◆ contains()

    - -
    -
    -
    -template<typename Entity , typename Component >
    - - - - - -
    - - - - - - - - -
    bool entt::View< Entity, Component >::contains (const entity_type entity) const
    -     		-inline
    -
    - -

    Checks if a view contains an entity.

    -
    Parameters
    - - -
    entityA valid entity identifier.
    -
    -
    -
    Returns
    True if the view contains the given entity, false otherwise.
    - -

    Definition at line 1163 of file view.hpp.

    - -
    -
    - -

    ◆ data()

    - -
    -
    -
    -template<typename Entity , typename Component >
    - - - - - -
    - - - - - - - -
    const entity_type* entt::View< Entity, Component >::data () const
    -     		-inline
    -
    - -

    Direct access to the list of entities.

    -

    The returned pointer is such that range [data(), data() + size()] is always a valid range, even if the container is empty.

    -
    Note
    There are no guarantees on the order of the entities. Use begin and end if you want to iterate the view in the expected order.
    -
    Returns
    A pointer to the array of entities.
    - -

    Definition at line 1034 of file view.hpp.

    - -
    -
    - -

    ◆ each() [1/2]

    - -
    -
    -
    -template<typename Entity , typename Component >
    -
    -template<typename Func >
    - - - - - -
    - - - - - - - - -
    void entt::View< Entity, Component >::each (Func func) const
    -     		-inline
    -
    - -

    Iterates entities and components and applies the given function object to them.

    -

    The function object is invoked for each entity. It is provided with the entity itself and a const reference to the component of the view.
    - The signature of the function should be equivalent to the following:

    -
    void(const entity_type, const Component &);
    Template Parameters
    - - -
    FuncType of the function object to invoke.
    -
    -
    -
    Parameters
    - - -
    funcA valid function object.
    -
    -
    - -

    Definition at line 1222 of file view.hpp.

    - -
    -
    - -

    ◆ each() [2/2]

    - -
    -
    -
    -template<typename Entity , typename Component >
    -
    -template<typename Func >
    - - - - - -
    - - - - - - - - -
    void entt::View< Entity, Component >::each (Func func)
    -     		-inline
    -
    - -

    Iterates entities and components and applies the given function object to them.

    -

    The function object is invoked for each entity. It is provided with the entity itself and a reference to the component of the view.
    - The signature of the function should be equivalent to the following:

    -
    void(const entity_type, Component &);
    Template Parameters
    - - -
    FuncType of the function object to invoke.
    -
    -
    -
    Parameters
    - - -
    funcA valid function object.
    -
    -
    - -

    Definition at line 1244 of file view.hpp.

    - -
    -
    - -

    ◆ empty()

    - -
    -
    -
    -template<typename Entity , typename Component >
    - - - - - -
    - - - - - - - -
    bool entt::View< Entity, Component >::empty () const
    -     		-inline
    -
    - -

    Checks whether the view is empty.

    -
    Returns
    True if the view is empty, false otherwise.
    - -

    Definition at line 986 of file view.hpp.

    - -
    -
    - -

    ◆ end() [1/2]

    - -
    -
    -
    -template<typename Entity , typename Component >
    - - - - - -
    - - - - - - - -
    const_iterator_type entt::View< Entity, Component >::end () const
    -     		-inline
    -
    - -

    Returns an iterator that is past the last entity that has the given component.

    -

    The returned iterator points to the entity following the last entity that has the given component. Attempting to dereference the returned iterator results in undefined behavior.

    -
    Note
    Input iterators stay true to the order imposed to the underlying data structures.
    -
    Returns
    An iterator to the entity following the last entity that has the given component.
    - -

    Definition at line 1126 of file view.hpp.

    - -
    -
    - -

    ◆ end() [2/2]

    - -
    -
    -
    -template<typename Entity , typename Component >
    - - - - - -
    - - - - - - - -
    iterator_type entt::View< Entity, Component >::end ()
    -     		-inline
    -
    - -

    Returns an iterator that is past the last entity that has the given component.

    -

    The returned iterator points to the entity following the last entity that has the given component. Attempting to dereference the returned iterator results in undefined behavior.

    -
    Note
    Input iterators stay true to the order imposed to the underlying data structures.
    -
    Returns
    An iterator to the entity following the last entity that has the given component.
    - -

    Definition at line 1145 of file view.hpp.

    - -
    -
    - -

    ◆ get() [1/2]

    - -
    -
    -
    -template<typename Entity , typename Component >
    - - - - - -
    - - - - - - - - -
    const Component& entt::View< Entity, Component >::get (const entity_type entity) const
    -     		-inline
    -
    - -

    Returns the component assigned to the given entity.

    -

    Prefer this function instead of Registry::get during iterations. It has far better performance than its companion function.

    -
    Warning
    Attempting to use an entity that doesn't belong to the view results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode if the view doesn't contain the given entity.
    -
    Parameters
    - - -
    entityA valid entity identifier.
    -
    -
    -
    Returns
    The component assigned to the entity.
    - -

    Definition at line 1182 of file view.hpp.

    - -
    -
    - -

    ◆ get() [2/2]

    - -
    -
    -
    -template<typename Entity , typename Component >
    - - - - - -
    - - - - - - - - -
    Component& entt::View< Entity, Component >::get (const entity_type entity)
    -     		-inline
    -
    - -

    Returns the component assigned to the given entity.

    -

    Prefer this function instead of Registry::get during iterations. It has far better performance than its companion function.

    -
    Warning
    Attempting to use an entity that doesn't belong to the view results in undefined behavior.
    - An assertion will abort the execution at runtime in debug mode if the view doesn't contain the given entity.
    -
    Parameters
    - - -
    entityA valid entity identifier.
    -
    -
    -
    Returns
    The component assigned to the entity.
    - -

    Definition at line 1202 of file view.hpp.

    - -
    -
    - -

    ◆ operator[]()

    - -
    -
    -
    -template<typename Entity , typename Component >
    - - - - - -
    - - - - - - - - -
    const entity_type& entt::View< Entity, Component >::operator[] (const size_type pos) const
    -     		-inline
    -
    - -

    Returns a reference to the element at the given position.

    -
    Parameters
    - - -
    posPosition of the element to return.
    -
    -
    -
    Returns
    A reference to the requested element.
    - -

    Definition at line 1154 of file view.hpp.

    - -
    -
    - -

    ◆ raw() [1/2]

    - -
    -
    -
    -template<typename Entity , typename Component >
    - - - - - -
    - - - - - - - -
    const raw_type* entt::View< Entity, Component >::raw () const
    -     		-inline
    -
    - -

    Direct access to the list of components.

    -

    The returned pointer is such that range [raw(), raw() + size()] is always a valid range, even if the container is empty.

    -
    Note
    There are no guarantees on the order of the components. Use begin and end if you want to iterate the view in the expected order.
    -
    Returns
    A pointer to the array of components.
    - -

    Definition at line 1002 of file view.hpp.

    - -
    -
    - -

    ◆ raw() [2/2]

    - -
    -
    -
    -template<typename Entity , typename Component >
    - - - - - -
    - - - - - - - -
    raw_type* entt::View< Entity, Component >::raw ()
    -     		-inline
    -
    - -

    Direct access to the list of components.

    -

    The returned pointer is such that range [raw(), raw() + size()] is always a valid range, even if the container is empty.

    -
    Note
    There are no guarantees on the order of the components. Use begin and end if you want to iterate the view in the expected order.
    -
    Returns
    A pointer to the array of components.
    - -

    Definition at line 1018 of file view.hpp.

    - -
    -
    - -

    ◆ size()

    - -
    -
    -
    -template<typename Entity , typename Component >
    - - - - - -
    - - - - - - - -
    size_type entt::View< Entity, Component >::size () const
    -     		-inline
    -
    - -

    Returns the number of entities that have the given component.

    -
    Returns
    Number of entities that have the given component.
    - -

    Definition at line 978 of file view.hpp.

    - -
    -
    -
    The documentation for this class was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/classentt_1_1basic__continuous__loader-members.html b/classentt_1_1basic__continuous__loader-members.html new file mode 100644 index 000000000..9fb83034b --- /dev/null +++ b/classentt_1_1basic__continuous__loader-members.html @@ -0,0 +1,92 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
    +
    + + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +
    entt::basic_continuous_loader< Entity > Member List
    +
    +
    + +

    This is the complete list of members for entt::basic_continuous_loader< Entity >, including all inherited members.

    + + + + + + + + + + + + +
    basic_continuous_loader(basic_registry< entity_type > &source) ENTT_NOEXCEPTentt::basic_continuous_loader< Entity >inline
    basic_continuous_loader(basic_continuous_loader &&)=defaultentt::basic_continuous_loader< Entity >
    component(Archive &archive, Member Type::*... member)entt::basic_continuous_loader< Entity >inline
    destroyed(Archive &archive)entt::basic_continuous_loader< Entity >inline
    entities(Archive &archive)entt::basic_continuous_loader< Entity >inline
    entity_type typedefentt::basic_continuous_loader< Entity >
    has(entity_type entt) const ENTT_NOEXCEPTentt::basic_continuous_loader< Entity >inline
    map(entity_type entt) const ENTT_NOEXCEPTentt::basic_continuous_loader< Entity >inline
    operator=(basic_continuous_loader &&)=defaultentt::basic_continuous_loader< Entity >
    orphans()entt::basic_continuous_loader< Entity >inline
    shrink()entt::basic_continuous_loader< Entity >inline
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/classentt_1_1basic__continuous__loader.html b/classentt_1_1basic__continuous__loader.html new file mode 100644 index 000000000..57c8608d6 --- /dev/null +++ b/classentt_1_1basic__continuous__loader.html @@ -0,0 +1,527 @@ + + + + + + + +EnTT: entt::basic_continuous_loader< Entity > Class Template Reference + + + + + + + + + +
    +
    + + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +Public Types | +Public Member Functions | +List of all members
    +
    +
    entt::basic_continuous_loader< Entity > Class Template Reference
    +
    +
    + +

    Utility class for continuous loading. + More...

    + +

    #include <snapshot.hpp>

    + + + + + +

    +Public Types

    +using entity_type = Entity
     Underlying entity identifier.
     
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    +Public Member Functions

     basic_continuous_loader (basic_registry< entity_type > &source) ENTT_NOEXCEPT
     Constructs a loader that is bound to a given registry. More...
     
    + basic_continuous_loader (basic_continuous_loader &&)=default
     Default move constructor.
     
    basic_continuous_loader & operator= (basic_continuous_loader &&)=default
     Default move assignment operator. More...
     
    template<typename Archive >
    basic_continuous_loader & entities (Archive &archive)
     Restores entities that were in use during serialization. More...
     
    template<typename Archive >
    basic_continuous_loader & destroyed (Archive &archive)
     Restores entities that were destroyed during serialization. More...
     
    template<typename... Component, typename Archive , typename... Type, typename... Member>
    basic_continuous_loader & component (Archive &archive, Member Type::*... member)
     Restores components and assigns them to the right entities. More...
     
    basic_continuous_loader & shrink ()
     Helps to purge entities that no longer have a conterpart. More...
     
    basic_continuous_loader & orphans ()
     Destroys those entities that have no components. More...
     
    bool has (entity_type entt) const ENTT_NOEXCEPT
     Tests if a loader knows about a given entity. More...
     
    entity_type map (entity_type entt) const ENTT_NOEXCEPT
     Returns the identifier to which an entity refers. More...
     
    +

    Detailed Description

    +

    template<typename Entity>
    +class entt::basic_continuous_loader< Entity >

    + +

    Utility class for continuous loading.

    +

    A continuous loader is designed to load data from a source registry to a (possibly) non-empty destination. The loader can accomodate in a registry more than one snapshot in a sort of continuous loading that updates the destination one step at a time.
    + Identifiers that entities originally had are not transferred to the target. Instead, the loader maps remote identifiers to local ones while restoring a snapshot.
    + An example of use is the implementation of a client-server applications with the requirement of transferring somehow parts of the representation side to side.

    +
    Template Parameters
    + + +
    EntityA valid entity type (see entt_traits for more details).
    +
    +
    + +

    Definition at line 45 of file fwd.hpp.

    +

    Constructor & Destructor Documentation

    + +

    ◆ basic_continuous_loader()

    + +
    +
    +
    +template<typename Entity >
    + + + + + +
    + + + + + + + + +
    entt::basic_continuous_loader< Entity >::basic_continuous_loader (basic_registry< entity_type > & source)
    +     		+inline
    +
    + +

    Constructs a loader that is bound to a given registry.

    +
    Parameters
    + + +
    sourceA valid reference to a registry.
    +
    +
    + +

    Definition at line 439 of file snapshot.hpp.

    + +
    +
    +

    Member Function Documentation

    + +

    ◆ component()

    + +
    +
    +
    +template<typename Entity >
    +
    +template<typename... Component, typename Archive , typename... Type, typename... Member>
    + + + + + +
    + + + + + + + + + + + + + + + + + + +
    basic_continuous_loader& entt::basic_continuous_loader< Entity >::component (Archive & archive,
    Member Type::*... member 
    )
    +     		+inline
    +
    + +

    Restores components and assigns them to the right entities.

    +

    The template parameter list must be exactly the same used during serialization. In the event that the entity to which the component is assigned doesn't exist yet, the loader will take care to create a local counterpart for it.
    + Members can be either data members of type entity_type or containers of entities. In both cases, the loader will visit them and update the entities by replacing each one with its local counterpart.

    +
    Template Parameters
    + + + + + +
    ComponentType of component to restore.
    ArchiveType of input archive.
    TypeTypes of components to update with local counterparts.
    MemberTypes of members to update with their local counterparts.
    +
    +
    +
    Parameters
    + + + +
    archiveA valid reference to an input archive.
    memberMembers to update with their local counterparts.
    +
    +
    +
    Returns
    A non-const reference to this loader.
    + +

    Definition at line 501 of file snapshot.hpp.

    + +
    +
    + +

    ◆ destroyed()

    + +
    +
    +
    +template<typename Entity >
    +
    +template<typename Archive >
    + + + + + +
    + + + + + + + + +
    basic_continuous_loader& entt::basic_continuous_loader< Entity >::destroyed (Archive & archive)
    +     		+inline
    +
    + +

    Restores entities that were destroyed during serialization.

    +

    This function restores the entities that were destroyed during serialization and creates local counterparts for them if required.

    +
    Template Parameters
    + + +
    ArchiveType of input archive.
    +
    +
    +
    Parameters
    + + +
    archiveA valid reference to an input archive.
    +
    +
    +
    Returns
    A non-const reference to this loader.
    + +

    Definition at line 476 of file snapshot.hpp.

    + +
    +
    + +

    ◆ entities()

    + +
    +
    +
    +template<typename Entity >
    +
    +template<typename Archive >
    + + + + + +
    + + + + + + + + +
    basic_continuous_loader& entt::basic_continuous_loader< Entity >::entities (Archive & archive)
    +     		+inline
    +
    + +

    Restores entities that were in use during serialization.

    +

    This function restores the entities that were in use during serialization and creates local counterparts for them if required.

    +
    Template Parameters
    + + +
    ArchiveType of input archive.
    +
    +
    +
    Parameters
    + + +
    archiveA valid reference to an input archive.
    +
    +
    +
    Returns
    A non-const reference to this loader.
    + +

    Definition at line 460 of file snapshot.hpp.

    + +
    +
    + +

    ◆ has()

    + +
    +
    +
    +template<typename Entity >
    + + + + + +
    + + + + + + + + +
    bool entt::basic_continuous_loader< Entity >::has (entity_type entt) const
    +     		+inline
    +
    + +

    Tests if a loader knows about a given entity.

    +
    Parameters
    + + +
    enttAn entity identifier.
    +
    +
    +
    Returns
    True if entity is managed by the loader, false otherwise.
    + +

    Definition at line 560 of file snapshot.hpp.

    + +
    +
    + +

    ◆ map()

    + +
    +
    +
    +template<typename Entity >
    + + + + + +
    + + + + + + + + +
    entity_type entt::basic_continuous_loader< Entity >::map (entity_type entt) const
    +     		+inline
    +
    + +

    Returns the identifier to which an entity refers.

    +
    Parameters
    + + +
    enttAn entity identifier.
    +
    +
    +
    Returns
    The local identifier if any, the null entity otherwise.
    + +

    Definition at line 569 of file snapshot.hpp.

    + +
    +
    + +

    ◆ operator=()

    + +
    +
    +
    +template<typename Entity >
    + + + + + +
    + + + + + + + + +
    basic_continuous_loader& entt::basic_continuous_loader< Entity >::operator= (basic_continuous_loader< Entity > && )
    +     		+default
    +
    + +

    Default move assignment operator.

    +
    Returns
    This loader.
    + +
    +
    + +

    ◆ orphans()

    + +
    +
    +
    +template<typename Entity >
    + + + + + +
    + + + + + + + +
    basic_continuous_loader& entt::basic_continuous_loader< Entity >::orphans ()
    +     		+inline
    +
    + +

    Destroys those entities that have no components.

    +

    In case all the entities were serialized but only part of the components was saved, it could happen that some of the entities have no components once restored.
    + This functions helps to identify and destroy those entities.

    +
    Returns
    A non-const reference to this loader.
    + +

    Definition at line 547 of file snapshot.hpp.

    + +
    +
    + +

    ◆ shrink()

    + +
    +
    +
    +template<typename Entity >
    + + + + + +
    + + + + + + + +
    basic_continuous_loader& entt::basic_continuous_loader< Entity >::shrink ()
    +     		+inline
    +
    + +

    Helps to purge entities that no longer have a conterpart.

    +

    Users should invoke this member function after restoring each snapshot, unless they know exactly what they are doing.

    +
    Returns
    A non-const reference to this loader.
    + +

    Definition at line 515 of file snapshot.hpp.

    + +
    +
    +
    The documentation for this class was generated from the following files: +
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/classentt_1_1SparseSet.html b/classentt_1_1basic__group.html similarity index 78% rename from classentt_1_1SparseSet.html rename to classentt_1_1basic__group.html index 840056a13..02da03b1c 100644 --- a/classentt_1_1SparseSet.html +++ b/classentt_1_1basic__group.html @@ -5,7 +5,7 @@ -EnTT: entt::SparseSet<... > Class Template Reference +EnTT: entt::basic_group<... > Class Template Reference @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    @@ -59,29 +59,29 @@ $(function() {
-
entt::SparseSet<... > Class Template Reference
+
entt::basic_group<... > Class Template Reference
-

Sparse set. - More...

+

Group. + More...

-

#include <sparse_set.hpp>

+

#include <group.hpp>

Detailed Description

template<typename...>
-class entt::SparseSet<... >

+class entt::basic_group<... > -

Sparse set.

+

Group.

Primary template isn't defined on purpose. All the specializations give a compile-time error, but for a few reasonable cases.

-

Definition at line 29 of file sparse_set.hpp.

+

Definition at line 25 of file fwd.hpp.

The documentation for this class was generated from the following file:
diff --git a/classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4-members.html b/classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4-members.html new file mode 100644 index 000000000..a00626b07 --- /dev/null +++ b/classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4-members.html @@ -0,0 +1,100 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
entt::basic_group< Entity, get_t< Get... >, Owned... > Member List
+
+
+ +

This is the complete list of members for entt::basic_group< Entity, get_t< Get... >, Owned... >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + +
basic_registry< Entity > classentt::basic_group< Entity, get_t< Get... >, Owned... >friend
begin() const ENTT_NOEXCEPTentt::basic_group< Entity, get_t< Get... >, Owned... >inline
contains(const entity_type entt) const ENTT_NOEXCEPTentt::basic_group< Entity, get_t< Get... >, Owned... >inline
data() const ENTT_NOEXCEPTentt::basic_group< Entity, get_t< Get... >, Owned... >inline
data() const ENTT_NOEXCEPTentt::basic_group< Entity, get_t< Get... >, Owned... >inline
each(Func func) constentt::basic_group< Entity, get_t< Get... >, Owned... >inline
empty() const ENTT_NOEXCEPTentt::basic_group< Entity, get_t< Get... >, Owned... >inline
empty() const ENTT_NOEXCEPTentt::basic_group< Entity, get_t< Get... >, Owned... >inline
end() const ENTT_NOEXCEPTentt::basic_group< Entity, get_t< Get... >, Owned... >inline
entity_type typedefentt::basic_group< Entity, get_t< Get... >, Owned... >
find(const entity_type entt) const ENTT_NOEXCEPTentt::basic_group< Entity, get_t< Get... >, Owned... >inline
get([[maybe_unused]] const entity_type entt) const ENTT_NOEXCEPTentt::basic_group< Entity, get_t< Get... >, Owned... >inline
iterator_type typedefentt::basic_group< Entity, get_t< Get... >, Owned... >
operator[](const size_type pos) const ENTT_NOEXCEPTentt::basic_group< Entity, get_t< Get... >, Owned... >inline
raw() const ENTT_NOEXCEPTentt::basic_group< Entity, get_t< Get... >, Owned... >inline
size() const ENTT_NOEXCEPTentt::basic_group< Entity, get_t< Get... >, Owned... >inline
size() const ENTT_NOEXCEPTentt::basic_group< Entity, get_t< Get... >, Owned... >inline
size_type typedefentt::basic_group< Entity, get_t< Get... >, Owned... >
sort(Compare compare, Sort algo=Sort{}, Args &&... args)entt::basic_group< Entity, get_t< Get... >, Owned... >inline
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html b/classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html new file mode 100644 index 000000000..4036aa21f --- /dev/null +++ b/classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html @@ -0,0 +1,828 @@ + + + + + + + +EnTT: entt::basic_group< Entity, get_t< Get... >, Owned... > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+Public Types | +Public Member Functions | +Friends | +List of all members
+
+
entt::basic_group< Entity, get_t< Get... >, Owned... > Class Template Reference
+
+
+ +

Owning group. + More...

+ +

#include <group.hpp>

+ + + + + + + + + + + +

+Public Types

+using entity_type = typename sparse_set< Entity >::entity_type
 Underlying entity identifier.
 
+using size_type = typename sparse_set< Entity >::size_type
 Unsigned integer type.
 
+using iterator_type = typename sparse_set< Entity >::iterator_type
 Input iterator type.
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

template<typename Component >
size_type size () const ENTT_NOEXCEPT
 Returns the number of existing components of the given type. More...
 
size_type size () const ENTT_NOEXCEPT
 Returns the number of entities that have the given components. More...
 
template<typename Component >
bool empty () const ENTT_NOEXCEPT
 Checks whether the pool of a given component is empty. More...
 
bool empty () const ENTT_NOEXCEPT
 Checks whether the group is empty. More...
 
template<typename Component >
Component * raw () const ENTT_NOEXCEPT
 Direct access to the list of components of a given pool. More...
 
template<typename Component >
const entity_type * data () const ENTT_NOEXCEPT
 Direct access to the list of entities of a given pool. More...
 
const entity_type * data () const ENTT_NOEXCEPT
 Direct access to the list of entities. More...
 
iterator_type begin () const ENTT_NOEXCEPT
 Returns an iterator to the first entity that has the given components. More...
 
iterator_type end () const ENTT_NOEXCEPT
 Returns an iterator that is past the last entity that has the given components. More...
 
iterator_type find (const entity_type entt) const ENTT_NOEXCEPT
 Finds an entity. More...
 
entity_type operator[] (const size_type pos) const ENTT_NOEXCEPT
 Returns the identifier that occupies the given position. More...
 
bool contains (const entity_type entt) const ENTT_NOEXCEPT
 Checks if a group contains an entity. More...
 
template<typename... Component>
decltype(auto) get ([[maybe_unused]] const entity_type entt) const ENTT_NOEXCEPT
 Returns the components assigned to the given entity. More...
 
template<typename Func >
void each (Func func) const
 Iterates entities and components and applies the given function object to them. More...
 
template<typename... Component, typename Compare , typename Sort = std_sort, typename... Args>
void sort (Compare compare, Sort algo=Sort{}, Args &&... args)
 Sort a group according to the given comparison function. More...
 
+ + + + +

+Friends

+class basic_registry< Entity >
 A registry is allowed to create groups.
 
+

Detailed Description

+

template<typename Entity, typename... Get, typename... Owned>
+class entt::basic_group< Entity, get_t< Get... >, Owned... >

+ +

Owning group.

+

Owning groups return all the entities and only the entities that have at least the given components. Moreover:

+
    +
  • It's guaranteed that the entity list is tightly packed in memory for fast iterations.
    • +
  • It's guaranteed that the lists of owned components are tightly packed in memory for even faster iterations and to allow direct access.
    • +
  • They stay true to the order of the owned components and all the owned components have the same order in memory.
    • +
+

The more types of components are owned by a group, the faster it is to iterate them.

+

Important

+

Iterators aren't invalidated if:

+
    +
  • New instances of the given components are created and assigned to entities.
    • +
  • The entity currently pointed is modified (as an example, if one of the given components is removed from the entity to which the iterator points).
    • +
+

In all the other cases, modifying the pools of the given components in any way invalidates all the iterators and using them results in undefined behavior.

+
Note
Groups share references to the underlying data structures of the registry that generated them. Therefore any change to the entities and to the components made by means of the registry are immediately reflected by all the groups. Moreover, sorting an owning group affects all the instance of the same group (it means that users don't have to call sort on each instance to sort all of them because they share the underlying data structure).
+
Warning
Lifetime of a group must overcome the one of the registry that generated it. In any other case, attempting to use a group results in undefined behavior.
+
Template Parameters
+ + + + +
EntityA valid entity type (see entt_traits for more details).
GetTypes of components observed by the group.
OwnedTypes of components owned by the group.
+
+
+ +

Definition at line 411 of file group.hpp.

+

Member Function Documentation

+ +

◆ begin()

+ +
+
+
+template<typename Entity , typename... Get, typename... Owned>
+ + + + + +
+ + + + + + + +
iterator_type entt::basic_group< Entity, get_t< Get... >, Owned... >::begin () const
+ 		+inline
+
+ +

Returns an iterator to the first entity that has the given components.

+

The returned iterator points to the first entity that has the given components. If the group is empty, the returned iterator will be equal to end().

+
Note
Input iterators stay true to the order imposed to the underlying data structures.
+
Returns
An iterator to the first entity that has the given components.
+ +

Definition at line 571 of file group.hpp.

+ +
+
+ +

◆ contains()

+ +
+
+
+template<typename Entity , typename... Get, typename... Owned>
+ + + + + +
+ + + + + + + + +
bool entt::basic_group< Entity, get_t< Get... >, Owned... >::contains (const entity_type entt) const
+ 		+inline
+
+ +

Checks if a group contains an entity.

+
Parameters
+ + +
enttA valid entity identifier.
+
+
+
Returns
True if the group contains the given entity, false otherwise.
+ +

Definition at line 619 of file group.hpp.

+ +
+
+ +

◆ data() [1/2]

+ +
+
+
+template<typename Entity , typename... Get, typename... Owned>
+
+template<typename Component >
+ + + + + +
+ + + + + + + +
const entity_type* entt::basic_group< Entity, get_t< Get... >, Owned... >::data () const
+ 		+inline
+
+ +

Direct access to the list of entities of a given pool.

+

The returned pointer is such that range [data<Component>(), data<Component>() + size<Component>()] is always a valid range, even if the container is empty.
+ Moreover, in case the group owns the given component, the range [data<Component>(), data<Component>() + size()] is such that it contains the entities that are part of the group itself.

+
Note
There are no guarantees on the order of the entities. Use begin and end if you want to iterate the group in the expected order.
+
Template Parameters
+ + +
ComponentType of component in which one is interested.
+
+
+
Returns
A pointer to the array of entities.
+ +

Definition at line 537 of file group.hpp.

+ +
+
+ +

◆ data() [2/2]

+ +
+
+
+template<typename Entity , typename... Get, typename... Owned>
+ + + + + +
+ + + + + + + +
const entity_type* entt::basic_group< Entity, get_t< Get... >, Owned... >::data () const
+ 		+inline
+
+ +

Direct access to the list of entities.

+

The returned pointer is such that range [data(), data() + size()] is always a valid range, even if the container is empty.

+
Note
There are no guarantees on the order of the entities. Use begin and end if you want to iterate the group in the expected order.
+
Returns
A pointer to the array of entities.
+ +

Definition at line 553 of file group.hpp.

+ +
+
+ +

◆ each()

+ +
+
+
+template<typename Entity , typename... Get, typename... Owned>
+
+template<typename Func >
+ + + + + +
+ + + + + + + + +
void entt::basic_group< Entity, get_t< Get... >, Owned... >::each (Func func) const
+ 		+inline
+
+ +

Iterates entities and components and applies the given function object to them.

+

The function object is invoked for each entity. It is provided with the entity itself and a set of references to all its components. The constness of the components is as requested.
+ The signature of the function must be equivalent to one of the following forms:

+
void(const entity_type, Owned &..., Get &...);
void(Owned &..., Get &...);
Note
Empty types aren't explicitly instantiated. Therefore, temporary objects are returned during iterations. They can be caught only by copy or with const references.
+
Template Parameters
+ + +
FuncType of the function object to invoke.
+
+
+
Parameters
+ + +
funcA valid function object.
+
+
+ +

Definition at line 675 of file group.hpp.

+ +
+
+ +

◆ empty() [1/2]

+ +
+
+
+template<typename Entity , typename... Get, typename... Owned>
+
+template<typename Component >
+ + + + + +
+ + + + + + + +
bool entt::basic_group< Entity, get_t< Get... >, Owned... >::empty () const
+ 		+inline
+
+ +

Checks whether the pool of a given component is empty.

+
Template Parameters
+ + +
ComponentType of component in which one is interested.
+
+
+
Returns
True if the pool of the given component is empty, false otherwise.
+ +

Definition at line 485 of file group.hpp.

+ +
+
+ +

◆ empty() [2/2]

+ +
+
+
+template<typename Entity , typename... Get, typename... Owned>
+ + + + + +
+ + + + + + + +
bool entt::basic_group< Entity, get_t< Get... >, Owned... >::empty () const
+ 		+inline
+
+ +

Checks whether the group is empty.

+
Returns
True if the group is empty, false otherwise.
+ +

Definition at line 493 of file group.hpp.

+ +
+
+ +

◆ end()

+ +
+
+
+template<typename Entity , typename... Get, typename... Owned>
+ + + + + +
+ + + + + + + +
iterator_type entt::basic_group< Entity, get_t< Get... >, Owned... >::end () const
+ 		+inline
+
+ +

Returns an iterator that is past the last entity that has the given components.

+

The returned iterator points to the entity following the last entity that has the given components. Attempting to dereference the returned iterator results in undefined behavior.

+
Note
Input iterators stay true to the order imposed to the underlying data structures.
+
Returns
An iterator to the entity following the last entity that has the given components.
+ +

Definition at line 590 of file group.hpp.

+ +
+
+ +

◆ find()

+ +
+
+
+template<typename Entity , typename... Get, typename... Owned>
+ + + + + +
+ + + + + + + + +
iterator_type entt::basic_group< Entity, get_t< Get... >, Owned... >::find (const entity_type entt) const
+ 		+inline
+
+ +

Finds an entity.

+
Parameters
+ + +
enttA valid entity identifier.
+
+
+
Returns
An iterator to the given entity if it's found, past the end iterator otherwise.
+ +

Definition at line 600 of file group.hpp.

+ +
+
+ +

◆ get()

+ +
+
+
+template<typename Entity , typename... Get, typename... Owned>
+
+template<typename... Component>
+ + + + + +
+ + + + + + + + +
decltype(auto) entt::basic_group< Entity, get_t< Get... >, Owned... >::get ([[maybe_unused] ] const entity_type entt) const
+ 		+inline
+
+ +

Returns the components assigned to the given entity.

+

Prefer this function instead of registry::get during iterations. It has far better performance than its companion function.

+
Warning
Attempting to use an invalid component type results in a compilation error. Attempting to use an entity that doesn't belong to the group results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode if the group doesn't contain the given entity.
+
Template Parameters
+ + +
ComponentTypes of components to get.
+
+
+
Parameters
+ + +
enttA valid entity identifier.
+
+
+
Returns
The components assigned to the entity.
+ +

Definition at line 641 of file group.hpp.

+ +
+
+ +

◆ operator[]()

+ +
+
+
+template<typename Entity , typename... Get, typename... Owned>
+ + + + + +
+ + + + + + + + +
entity_type entt::basic_group< Entity, get_t< Get... >, Owned... >::operator[] (const size_type pos) const
+ 		+inline
+
+ +

Returns the identifier that occupies the given position.

+
Parameters
+ + +
posPosition of the element to return.
+
+
+
Returns
The identifier that occupies the given position.
+ +

Definition at line 610 of file group.hpp.

+ +
+
+ +

◆ raw()

+ +
+
+
+template<typename Entity , typename... Get, typename... Owned>
+
+template<typename Component >
+ + + + + +
+ + + + + + + +
Component* entt::basic_group< Entity, get_t< Get... >, Owned... >::raw () const
+ 		+inline
+
+ +

Direct access to the list of components of a given pool.

+

The returned pointer is such that range [raw<Component>(), raw<Component>() + size<Component>()] is always a valid range, even if the container is empty.
+ Moreover, in case the group owns the given component, the range [raw<Component>(), raw<Component>() + size()] is such that it contains the instances that are part of the group itself.

+
Note
There are no guarantees on the order of the components. Use begin and end if you want to iterate the group in the expected order.
+
Template Parameters
+ + +
ComponentType of component in which one is interested.
+
+
+
Returns
A pointer to the array of components.
+ +

Definition at line 515 of file group.hpp.

+ +
+
+ +

◆ size() [1/2]

+ +
+
+
+template<typename Entity , typename... Get, typename... Owned>
+
+template<typename Component >
+ + + + + +
+ + + + + + + +
size_type entt::basic_group< Entity, get_t< Get... >, Owned... >::size () const
+ 		+inline
+
+ +

Returns the number of existing components of the given type.

+
Template Parameters
+ + +
ComponentType of component of which to return the size.
+
+
+
Returns
Number of existing components of the given type.
+ +

Definition at line 466 of file group.hpp.

+ +
+
+ +

◆ size() [2/2]

+ +
+
+
+template<typename Entity , typename... Get, typename... Owned>
+ + + + + +
+ + + + + + + +
size_type entt::basic_group< Entity, get_t< Get... >, Owned... >::size () const
+ 		+inline
+
+ +

Returns the number of entities that have the given components.

+
Returns
Number of entities that have the given components.
+ +

Definition at line 474 of file group.hpp.

+ +
+
+ +

◆ sort()

+ +
+
+
+template<typename Entity , typename... Get, typename... Owned>
+
+template<typename... Component, typename Compare , typename Sort = std_sort, typename... Args>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
void entt::basic_group< Entity, get_t< Get... >, Owned... >::sort (Compare compare,
Sort algo = Sort{},
Args &&... args 
)
+ 		+inline
+
+ +

Sort a group according to the given comparison function.

+

Sort the group so that iterating it with a couple of iterators returns entities and components in the expected order. See begin and end for more details.

+

The comparison function object must return true if the first element is less than the second one, false otherwise. The signature of the comparison function should be equivalent to one of the following:

+
bool(const Component &..., const Component &...);
bool(const Entity, const Entity);

Where Component are either owned types or not but still such that they are iterated by the group.
+ Moreover, the comparison function object shall induce a strict weak ordering on the values.

+

The sort function oject must offer a member function template operator() that accepts three arguments:

+
    +
  • An iterator to the first element of the range to sort.
    • +
  • An iterator past the last element of the range to sort.
    • +
  • A comparison function to use to compare the elements.
    • +
+

The comparison function object received by the sort function object hasn't necessarily the type of the one passed along with the other parameters to this member function.

+
Note
Attempting to iterate elements using a raw pointer returned by a call to either data or raw gives no guarantees on the order, even though sort has been invoked.
+
Template Parameters
+ + + + + +
ComponentOptional types of components to compare.
CompareType of comparison function object.
SortType of sort function object.
ArgsTypes of arguments to forward to the sort function object.
+
+
+
Parameters
+ + + + +
compareA valid comparison function object.
algoA valid sort function object.
argsArguments to forward to the sort function object, if any.
+
+
+ +

Definition at line 740 of file group.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4-members.html b/classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4-members.html new file mode 100644 index 000000000..255cc2b8b --- /dev/null +++ b/classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4-members.html @@ -0,0 +1,102 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
entt::basic_group< Entity, get_t< Get... > > Member List
+
+
+ +

This is the complete list of members for entt::basic_group< Entity, get_t< Get... > >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + +
basic_registry< Entity > classentt::basic_group< Entity, get_t< Get... > >friend
begin() const ENTT_NOEXCEPTentt::basic_group< Entity, get_t< Get... > >inline
capacity() const ENTT_NOEXCEPTentt::basic_group< Entity, get_t< Get... > >inline
contains(const entity_type entt) const ENTT_NOEXCEPTentt::basic_group< Entity, get_t< Get... > >inline
data() const ENTT_NOEXCEPTentt::basic_group< Entity, get_t< Get... > >inline
data() const ENTT_NOEXCEPTentt::basic_group< Entity, get_t< Get... > >inline
each(Func func) constentt::basic_group< Entity, get_t< Get... > >inline
empty() const ENTT_NOEXCEPTentt::basic_group< Entity, get_t< Get... > >inline
empty() const ENTT_NOEXCEPTentt::basic_group< Entity, get_t< Get... > >inline
end() const ENTT_NOEXCEPTentt::basic_group< Entity, get_t< Get... > >inline
entity_type typedefentt::basic_group< Entity, get_t< Get... > >
find(const entity_type entt) const ENTT_NOEXCEPTentt::basic_group< Entity, get_t< Get... > >inline
get([[maybe_unused]] const entity_type entt) const ENTT_NOEXCEPTentt::basic_group< Entity, get_t< Get... > >inline
iterator_type typedefentt::basic_group< Entity, get_t< Get... > >
operator[](const size_type pos) const ENTT_NOEXCEPTentt::basic_group< Entity, get_t< Get... > >inline
raw() const ENTT_NOEXCEPTentt::basic_group< Entity, get_t< Get... > >inline
shrink_to_fit()entt::basic_group< Entity, get_t< Get... > >inline
size() const ENTT_NOEXCEPTentt::basic_group< Entity, get_t< Get... > >inline
size() const ENTT_NOEXCEPTentt::basic_group< Entity, get_t< Get... > >inline
size_type typedefentt::basic_group< Entity, get_t< Get... > >
sort() constentt::basic_group< Entity, get_t< Get... > >inline
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html b/classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html new file mode 100644 index 000000000..11857d098 --- /dev/null +++ b/classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html @@ -0,0 +1,822 @@ + + + + + + + +EnTT: entt::basic_group< Entity, get_t< Get... > > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+Public Types | +Public Member Functions | +Friends | +List of all members
+
+
entt::basic_group< Entity, get_t< Get... > > Class Template Reference
+
+
+ +

Non-owning group. + More...

+ +

#include <group.hpp>

+ + + + + + + + + + + +

+Public Types

+using entity_type = typename sparse_set< Entity >::entity_type
 Underlying entity identifier.
 
+using size_type = typename sparse_set< Entity >::size_type
 Unsigned integer type.
 
+using iterator_type = typename sparse_set< Entity >::iterator_type
 Input iterator type.
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

template<typename Component >
size_type size () const ENTT_NOEXCEPT
 Returns the number of existing components of the given type. More...
 
size_type size () const ENTT_NOEXCEPT
 Returns the number of entities that have the given components. More...
 
size_type capacity () const ENTT_NOEXCEPT
 Returns the number of elements that a group has currently allocated space for. More...
 
+void shrink_to_fit ()
 Requests the removal of unused capacity.
 
template<typename Component >
bool empty () const ENTT_NOEXCEPT
 Checks whether the pool of a given component is empty. More...
 
bool empty () const ENTT_NOEXCEPT
 Checks whether the group is empty. More...
 
template<typename Component >
Component * raw () const ENTT_NOEXCEPT
 Direct access to the list of components of a given pool. More...
 
template<typename Component >
const entity_type * data () const ENTT_NOEXCEPT
 Direct access to the list of entities of a given pool. More...
 
const entity_type * data () const ENTT_NOEXCEPT
 Direct access to the list of entities. More...
 
iterator_type begin () const ENTT_NOEXCEPT
 Returns an iterator to the first entity that has the given components. More...
 
iterator_type end () const ENTT_NOEXCEPT
 Returns an iterator that is past the last entity that has the given components. More...
 
iterator_type find (const entity_type entt) const ENTT_NOEXCEPT
 Finds an entity. More...
 
entity_type operator[] (const size_type pos) const ENTT_NOEXCEPT
 Returns the identifier that occupies the given position. More...
 
bool contains (const entity_type entt) const ENTT_NOEXCEPT
 Checks if a group contains an entity. More...
 
template<typename... Component>
decltype(auto) get ([[maybe_unused]] const entity_type entt) const ENTT_NOEXCEPT
 Returns the components assigned to the given entity. More...
 
template<typename Func >
void each (Func func) const
 Iterates entities and components and applies the given function object to them. More...
 
template<typename Component >
void sort () const
 Sort the shared pool of entities according to the given component. More...
 
+ + + + +

+Friends

+class basic_registry< Entity >
 A registry is allowed to create groups.
 
+

Detailed Description

+

template<typename Entity, typename... Get>
+class entt::basic_group< Entity, get_t< Get... > >

+ +

Non-owning group.

+

A non-owning group returns all the entities and only the entities that have at least the given components. Moreover, it's guaranteed that the entity list is tightly packed in memory for fast iterations.
+ In general, non-owning groups don't stay true to the order of any set of components unless users explicitly sort them.

+

Important

+

Iterators aren't invalidated if:

+
    +
  • New instances of the given components are created and assigned to entities.
    • +
  • The entity currently pointed is modified (as an example, if one of the given components is removed from the entity to which the iterator points).
    • +
+

In all the other cases, modifying the pools of the given components in any way invalidates all the iterators and using them results in undefined behavior.

+
Note
Groups share references to the underlying data structures of the registry that generated them. Therefore any change to the entities and to the components made by means of the registry are immediately reflected by all the groups.
+ Moreover, sorting a non-owning group affects all the instance of the same group (it means that users don't have to call sort on each instance to sort all of them because they share the set of entities).
+
Warning
Lifetime of a group must overcome the one of the registry that generated it. In any other case, attempting to use a group results in undefined behavior.
+
Template Parameters
+ + + +
EntityA valid entity type (see entt_traits for more details).
GetTypes of components observed by the group.
+
+
+ +

Definition at line 82 of file group.hpp.

+

Member Function Documentation

+ +

◆ begin()

+ +
+
+
+template<typename Entity , typename... Get>
+ + + + + +
+ + + + + + + +
iterator_type entt::basic_group< Entity, get_t< Get... > >::begin () const
+ 		+inline
+
+ +

Returns an iterator to the first entity that has the given components.

+

The returned iterator points to the first entity that has the given components. If the group is empty, the returned iterator will be equal to end().

+
Note
Input iterators stay true to the order imposed to the underlying data structures.
+
Returns
An iterator to the first entity that has the given components.
+ +

Definition at line 224 of file group.hpp.

+ +
+
+ +

◆ capacity()

+ +
+
+
+template<typename Entity , typename... Get>
+ + + + + +
+ + + + + + + +
size_type entt::basic_group< Entity, get_t< Get... > >::capacity () const
+ 		+inline
+
+ +

Returns the number of elements that a group has currently allocated space for.

+
Returns
Capacity of the group.
+ +

Definition at line 128 of file group.hpp.

+ +
+
+ +

◆ contains()

+ +
+
+
+template<typename Entity , typename... Get>
+ + + + + +
+ + + + + + + + +
bool entt::basic_group< Entity, get_t< Get... > >::contains (const entity_type entt) const
+ 		+inline
+
+ +

Checks if a group contains an entity.

+
Parameters
+ + +
enttA valid entity identifier.
+
+
+
Returns
True if the group contains the given entity, false otherwise.
+ +

Definition at line 272 of file group.hpp.

+ +
+
+ +

◆ data() [1/2]

+ +
+
+
+template<typename Entity , typename... Get>
+
+template<typename Component >
+ + + + + +
+ + + + + + + +
const entity_type* entt::basic_group< Entity, get_t< Get... > >::data () const
+ 		+inline
+
+ +

Direct access to the list of entities of a given pool.

+

The returned pointer is such that range [data<Component>(), data<Component>() + size<Component>()] is always a valid range, even if the container is empty.

+
Note
There are no guarantees on the order of the entities. Use begin and end if you want to iterate the group in the expected order.
+
Template Parameters
+ + +
ComponentType of component in which one is interested.
+
+
+
Returns
A pointer to the array of entities.
+ +

Definition at line 190 of file group.hpp.

+ +
+
+ +

◆ data() [2/2]

+ +
+
+
+template<typename Entity , typename... Get>
+ + + + + +
+ + + + + + + +
const entity_type* entt::basic_group< Entity, get_t< Get... > >::data () const
+ 		+inline
+
+ +

Direct access to the list of entities.

+

The returned pointer is such that range [data(), data() + size()] is always a valid range, even if the container is empty.

+
Note
There are no guarantees on the order of the entities. Use begin and end if you want to iterate the group in the expected order.
+
Returns
A pointer to the array of entities.
+ +

Definition at line 206 of file group.hpp.

+ +
+
+ +

◆ each()

+ +
+
+
+template<typename Entity , typename... Get>
+
+template<typename Func >
+ + + + + +
+ + + + + + + + +
void entt::basic_group< Entity, get_t< Get... > >::each (Func func) const
+ 		+inline
+
+ +

Iterates entities and components and applies the given function object to them.

+

The function object is invoked for each entity. It is provided with the entity itself and a set of references to all its components. The constness of the components is as requested.
+ The signature of the function must be equivalent to one of the following forms:

+
void(const entity_type, Get &...);
void(Get &...);
Note
Empty types aren't explicitly instantiated. Therefore, temporary objects are returned during iterations. They can be caught only by copy or with const references.
+
Template Parameters
+ + +
FuncType of the function object to invoke.
+
+
+
Parameters
+ + +
funcA valid function object.
+
+
+ +

Definition at line 328 of file group.hpp.

+ +
+
+ +

◆ empty() [1/2]

+ +
+
+
+template<typename Entity , typename... Get>
+
+template<typename Component >
+ + + + + +
+ + + + + + + +
bool entt::basic_group< Entity, get_t< Get... > >::empty () const
+ 		+inline
+
+ +

Checks whether the pool of a given component is empty.

+
Template Parameters
+ + +
ComponentType of component in which one is interested.
+
+
+
Returns
True if the pool of the given component is empty, false otherwise.
+ +

Definition at line 144 of file group.hpp.

+ +
+
+ +

◆ empty() [2/2]

+ +
+
+
+template<typename Entity , typename... Get>
+ + + + + +
+ + + + + + + +
bool entt::basic_group< Entity, get_t< Get... > >::empty () const
+ 		+inline
+
+ +

Checks whether the group is empty.

+
Returns
True if the group is empty, false otherwise.
+ +

Definition at line 152 of file group.hpp.

+ +
+
+ +

◆ end()

+ +
+
+
+template<typename Entity , typename... Get>
+ + + + + +
+ + + + + + + +
iterator_type entt::basic_group< Entity, get_t< Get... > >::end () const
+ 		+inline
+
+ +

Returns an iterator that is past the last entity that has the given components.

+

The returned iterator points to the entity following the last entity that has the given components. Attempting to dereference the returned iterator results in undefined behavior.

+
Note
Input iterators stay true to the order imposed to the underlying data structures.
+
Returns
An iterator to the entity following the last entity that has the given components.
+ +

Definition at line 243 of file group.hpp.

+ +
+
+ +

◆ find()

+ +
+
+
+template<typename Entity , typename... Get>
+ + + + + +
+ + + + + + + + +
iterator_type entt::basic_group< Entity, get_t< Get... > >::find (const entity_type entt) const
+ 		+inline
+
+ +

Finds an entity.

+
Parameters
+ + +
enttA valid entity identifier.
+
+
+
Returns
An iterator to the given entity if it's found, past the end iterator otherwise.
+ +

Definition at line 253 of file group.hpp.

+ +
+
+ +

◆ get()

+ +
+
+
+template<typename Entity , typename... Get>
+
+template<typename... Component>
+ + + + + +
+ + + + + + + + +
decltype(auto) entt::basic_group< Entity, get_t< Get... > >::get ([[maybe_unused] ] const entity_type entt) const
+ 		+inline
+
+ +

Returns the components assigned to the given entity.

+

Prefer this function instead of registry::get during iterations. It has far better performance than its companion function.

+
Warning
Attempting to use an invalid component type results in a compilation error. Attempting to use an entity that doesn't belong to the group results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode if the group doesn't contain the given entity.
+
Template Parameters
+ + +
ComponentTypes of components to get.
+
+
+
Parameters
+ + +
enttA valid entity identifier.
+
+
+
Returns
The components assigned to the entity.
+ +

Definition at line 294 of file group.hpp.

+ +
+
+ +

◆ operator[]()

+ +
+
+
+template<typename Entity , typename... Get>
+ + + + + +
+ + + + + + + + +
entity_type entt::basic_group< Entity, get_t< Get... > >::operator[] (const size_type pos) const
+ 		+inline
+
+ +

Returns the identifier that occupies the given position.

+
Parameters
+ + +
posPosition of the element to return.
+
+
+
Returns
The identifier that occupies the given position.
+ +

Definition at line 263 of file group.hpp.

+ +
+
+ +

◆ raw()

+ +
+
+
+template<typename Entity , typename... Get>
+
+template<typename Component >
+ + + + + +
+ + + + + + + +
Component* entt::basic_group< Entity, get_t< Get... > >::raw () const
+ 		+inline
+
+ +

Direct access to the list of components of a given pool.

+

The returned pointer is such that range [raw<Component>(), raw<Component>() + size<Component>()] is always a valid range, even if the container is empty.

+
Note
There are no guarantees on the order of the components. Use begin and end if you want to iterate the group in the expected order.
+
Template Parameters
+ + +
ComponentType of component in which one is interested.
+
+
+
Returns
A pointer to the array of components.
+ +

Definition at line 171 of file group.hpp.

+ +
+
+ +

◆ size() [1/2]

+ +
+
+
+template<typename Entity , typename... Get>
+
+template<typename Component >
+ + + + + +
+ + + + + + + +
size_type entt::basic_group< Entity, get_t< Get... > >::size () const
+ 		+inline
+
+ +

Returns the number of existing components of the given type.

+
Template Parameters
+ + +
ComponentType of component of which to return the size.
+
+
+
Returns
Number of existing components of the given type.
+ +

Definition at line 111 of file group.hpp.

+ +
+
+ +

◆ size() [2/2]

+ +
+
+
+template<typename Entity , typename... Get>
+ + + + + +
+ + + + + + + +
size_type entt::basic_group< Entity, get_t< Get... > >::size () const
+ 		+inline
+
+ +

Returns the number of entities that have the given components.

+
Returns
Number of entities that have the given components.
+ +

Definition at line 119 of file group.hpp.

+ +
+
+ +

◆ sort()

+ +
+
+
+template<typename Entity , typename... Get>
+
+template<typename Component >
+ + + + + +
+ + + + + + + +
void entt::basic_group< Entity, get_t< Get... > >::sort () const
+ 		+inline
+
+ +

Sort the shared pool of entities according to the given component.

+

Non-owning groups of the same type share with the registry a pool of entities with its own order that doesn't depend on the order of any pool of components. Users can order the underlying data structure so that it respects the order of the pool of the given component.

+
Note
The shared pool of entities and thus its order is affected by the changes to each and every pool that it tracks. Therefore changes to those pools can quickly ruin the order imposed to the pool of entities shared between the non-owning groups.
+
Template Parameters
+ + +
ComponentType of component to use to impose the order.
+
+
+ +

Definition at line 355 of file group.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1basic__prototype-members.html b/classentt_1_1basic__prototype-members.html new file mode 100644 index 000000000..2879e4d41 --- /dev/null +++ b/classentt_1_1basic__prototype-members.html @@ -0,0 +1,107 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
entt::basic_prototype< Entity > Member List
+
+
+ +

This is the complete list of members for entt::basic_prototype< Entity >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + +
assign(registry_type &other, const entity_type dst) constentt::basic_prototype< Entity >inline
assign(const entity_type dst) constentt::basic_prototype< Entity >inline
assign_or_replace(registry_type &other, const entity_type dst) constentt::basic_prototype< Entity >inline
assign_or_replace(const entity_type dst) constentt::basic_prototype< Entity >inline
backend() const ENTT_NOEXCEPTentt::basic_prototype< Entity >inline
backend() ENTT_NOEXCEPTentt::basic_prototype< Entity >inline
basic_prototype(registry_type &ref)entt::basic_prototype< Entity >inline
basic_prototype(basic_prototype &&other)entt::basic_prototype< Entity >inline
create(registry_type &other) constentt::basic_prototype< Entity >inline
create() constentt::basic_prototype< Entity >inline
entity_type typedefentt::basic_prototype< Entity >
get() const ENTT_NOEXCEPTentt::basic_prototype< Entity >inline
get() ENTT_NOEXCEPTentt::basic_prototype< Entity >inline
has() const ENTT_NOEXCEPTentt::basic_prototype< Entity >inline
operator()(registry_type &other, const entity_type dst) const ENTT_NOEXCEPTentt::basic_prototype< Entity >inline
operator()(const entity_type dst) const ENTT_NOEXCEPTentt::basic_prototype< Entity >inline
operator()(registry_type &other) const ENTT_NOEXCEPTentt::basic_prototype< Entity >inline
operator()() const ENTT_NOEXCEPTentt::basic_prototype< Entity >inline
operator=(basic_prototype &&other)entt::basic_prototype< Entity >inline
registry_type typedefentt::basic_prototype< Entity >
set(Args &&... args)entt::basic_prototype< Entity >inline
size_type typedefentt::basic_prototype< Entity >
try_get() const ENTT_NOEXCEPTentt::basic_prototype< Entity >inline
try_get() ENTT_NOEXCEPTentt::basic_prototype< Entity >inline
unset() ENTT_NOEXCEPTentt::basic_prototype< Entity >inline
~basic_prototype()entt::basic_prototype< Entity >inline
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1Prototype.html b/classentt_1_1basic__prototype.html similarity index 55% rename from classentt_1_1Prototype.html rename to classentt_1_1basic__prototype.html index b6a9af9b0..6cbb633c1 100644 --- a/classentt_1_1Prototype.html +++ b/classentt_1_1basic__prototype.html @@ -5,7 +5,7 @@ -EnTT: entt::Prototype< Entity > Class Template Reference +EnTT: entt::basic_prototype< Entity > Class Template Reference @@ -22,7 +22,7 @@
EnTT -  2.7.3 +  3.0.0
@@ -59,7 +59,7 @@ $(function() {
@@ -67,118 +67,117 @@ $(function() { Classes | Public Types | Public Member Functions | -List of all members
+List of all members
-
entt::Prototype< Entity > Class Template Referencefinal
+
entt::basic_prototype< Entity > Class Template Reference
-

Prototype container for concepts. - More...

+

Prototype container for concepts. + More...

#include <prototype.hpp>

- - - - - - - - - + + + + + + + + +

Public Types

-using registry_type = Registry< Entity >
 Registry type.
 
-using entity_type = Entity
 Underlying entity identifier.
 
-using size_type = std::size_t
 Unsigned integer type.
 
+using registry_type = basic_registry< Entity >
 Registry type.
 
+using entity_type = Entity
 Underlying entity identifier.
 
+using size_type = std::size_t
 Unsigned integer type.
 
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Public Member Functions

 Prototype (Registry< Entity > &registry)
 Constructs a prototype that is bound to a given registry. More...
 
- ~Prototype ()
 Releases all its resources.
 
- Prototype (const Prototype &)=delete
 Copying a prototype isn't allowed.
 
 Prototype (Prototype &&other)
 Move constructor. More...
 
Prototype & operator= (const Prototype &)=delete
 Copying a prototype isn't allowed. More...
 
Prototype & operator= (Prototype &&other)
 Move assignment operator. More...
 
template<typename Component , typename... Args>
Component & set (Args &&... args)
 Assigns to or replaces the given component of a prototype. More...
 
template<typename Component >
void unset () ENTT_NOEXCEPT
 Removes the given component from a prototype. More...
 
template<typename... Component>
bool has () const ENTT_NOEXCEPT
 Checks if a prototype owns all the given components. More...
 
template<typename Component >
const Component & get () const ENTT_NOEXCEPT
 Returns a reference to the given component. More...
 
template<typename Component >
Component & get () ENTT_NOEXCEPT
 Returns a reference to the given component. More...
 
template<typename... Component>
std::enable_if_t<(sizeof...(Component) > 1), std::tuple< const Component &... > > get () const ENTT_NOEXCEPT
 Returns a reference to the given components. More...
 
template<typename... Component>
std::enable_if_t<(sizeof...(Component) > 1), std::tuple< Component &... > > get () ENTT_NOEXCEPT
 Returns a reference to the given components. More...
 
entity_type create (registry_type &other) const
 Creates a new entity using a given prototype. More...
 
entity_type create () const
 Creates a new entity using a given prototype. More...
 
void assign (registry_type &other, const entity_type dst) const
 Assigns the components of a prototype to a given entity. More...
 
void assign (const entity_type dst) const
 Assigns the components of a prototype to a given entity. More...
 
void accommodate (registry_type &other, const entity_type dst) const
 Assigns or replaces the components of a prototype for an entity. More...
 
void accommodate (const entity_type dst) const
 Assigns or replaces the components of a prototype for an entity. More...
 
void operator() (registry_type &other, const entity_type dst) const ENTT_NOEXCEPT
 Assigns the components of a prototype to an entity. More...
 
void operator() (const entity_type dst) const ENTT_NOEXCEPT
 Assigns the components of a prototype to an entity. More...
 
entity_type operator() (registry_type &other) const ENTT_NOEXCEPT
 Creates a new entity using a given prototype. More...
 
entity_type operator() () const ENTT_NOEXCEPT
 Creates a new entity using a given prototype. More...
 
 basic_prototype (registry_type &ref)
 Constructs a prototype that is bound to a given registry. More...
 
+ ~basic_prototype ()
 Releases all its resources.
 
 basic_prototype (basic_prototype &&other)
 Move constructor. More...
 
basic_prototype & operator= (basic_prototype &&other)
 Move assignment operator. More...
 
template<typename Component , typename... Args>
Component & set (Args &&... args)
 Assigns to or replaces the given component of a prototype. More...
 
template<typename Component >
void unset () ENTT_NOEXCEPT
 Removes the given component from a prototype. More...
 
template<typename... Component>
bool has () const ENTT_NOEXCEPT
 Checks if a prototype owns all the given components. More...
 
template<typename... Component>
decltype(auto) get () const ENTT_NOEXCEPT
 Returns references to the given components. More...
 
template<typename... Component>
decltype(auto) get () ENTT_NOEXCEPT
 Returns references to the given components. More...
 
template<typename... Component>
auto try_get () const ENTT_NOEXCEPT
 Returns pointers to the given components. More...
 
template<typename... Component>
auto try_get () ENTT_NOEXCEPT
 Returns pointers to the given components. More...
 
entity_type create (registry_type &other) const
 Creates a new entity using a given prototype. More...
 
entity_type create () const
 Creates a new entity using a given prototype. More...
 
void assign (registry_type &other, const entity_type dst) const
 Assigns the components of a prototype to a given entity. More...
 
void assign (const entity_type dst) const
 Assigns the components of a prototype to a given entity. More...
 
void assign_or_replace (registry_type &other, const entity_type dst) const
 Assigns or replaces the components of a prototype for an entity. More...
 
void assign_or_replace (const entity_type dst) const
 Assigns or replaces the components of a prototype for an entity. More...
 
void operator() (registry_type &other, const entity_type dst) const ENTT_NOEXCEPT
 Assigns the components of a prototype to an entity. More...
 
void operator() (const entity_type dst) const ENTT_NOEXCEPT
 Assigns the components of a prototype to an entity. More...
 
entity_type operator() (registry_type &other) const ENTT_NOEXCEPT
 Creates a new entity using a given prototype. More...
 
entity_type operator() () const ENTT_NOEXCEPT
 Creates a new entity using a given prototype. More...
 
const registry_type & backend () const ENTT_NOEXCEPT
 Returns a reference to the underlying registry. More...
 
registry_type & backend () ENTT_NOEXCEPT
 Returns a reference to the underlying registry. More...
 

Detailed Description

template<typename Entity>
-class entt::Prototype< Entity >

+class entt::basic_prototype< Entity > -

Prototype container for concepts.

+

Prototype container for concepts.

A prototype is used to define a concept in terms of components.
Prototypes act as templates for those specific types of an application which users would otherwise define through a series of component assignments to entities. In other words, prototypes can be used to assign components to entities of a registry at once.

Note
Components used along with prototypes must be copy constructible. Prototypes wrap component types with custom types, so they do not interfere with other users of the registry they were built with.
@@ -190,10 +189,10 @@ class entt::Prototype< Entity > -

Definition at line 40 of file prototype.hpp.

+

Definition at line 33 of file fwd.hpp.

Constructor & Destructor Documentation

- -

◆ Prototype() [1/2]

+ +

◆ basic_prototype() [1/2]

@@ -204,10 +203,10 @@ template<typename Entity >
- + - - + +
entt::Prototype< Entity >::Prototype entt::basic_prototype< Entity >::basic_prototype (Registry< Entity > & registry)registry_type & ref)
@@ -221,17 +220,17 @@ template<typename Entity >

Constructs a prototype that is bound to a given registry.

Parameters
- +
registryA valid reference to a registry.
refA valid reference to a registry.
-

Definition at line 70 of file prototype.hpp.

+

Definition at line 71 of file prototype.hpp.

- -

◆ Prototype() [2/2]

+ +

◆ basic_prototype() [2/2]

@@ -242,9 +241,9 @@ template<typename Entity >
- + - + @@ -265,13 +264,13 @@ template<typename Entity > -

Definition at line 94 of file prototype.hpp.

+

Definition at line 92 of file prototype.hpp.

Member Function Documentation

- -

◆ accommodate() [1/2]

+ +

◆ assign() [1/2]

@@ -282,110 +281,15 @@ template<typename Entity >
- - -
entt::Prototype< Entity >::Prototype entt::basic_prototype< Entity >::basic_prototype (Prototype< Entity > && basic_prototype< Entity > &&  other)
- + - + - - - - - - - - -
void entt::Prototype< Entity >::accommodate void entt::basic_prototype< Entity >::assign (registry_type & registry_type &  other,
const entity_type dst 
) const
- 		-inline
-
- -

Assigns or replaces the components of a prototype for an entity.

-

Existing components are overwritten, if any. All the other components will be copied over to the target entity.

-
Note
The registry may or may not be different from the one already used by the prototype. There is also an overload that directly uses the underlying registry.
-
Warning
Attempting to use an invalid entity results in undefined behavior.
- An assertion will abort the execution at runtime in debug mode in case of invalid entity.
-
Parameters
- - - -
otherA valid reference to a registry.
dstA valid entity identifier.
-
-
- -

Definition at line 357 of file prototype.hpp.

- -
- - -

◆ accommodate() [2/2]

- -
-
-
-template<typename Entity >
- - - - - -
- - - - - - - - -
void entt::Prototype< Entity >::accommodate (const entity_type dst) const
- 		-inline
-
- -

Assigns or replaces the components of a prototype for an entity.

-

Existing components are overwritten, if any. All the other components will be copied over to the target entity.

-
Note
This overload directly uses the underlying registry as a working space. Therefore, the components of the prototype and of the entity will share the same registry.
-
Warning
Attempting to use an invalid entity results in undefined behavior.
- An assertion will abort the execution at runtime in debug mode in case of invalid entity.
-
Parameters
- - -
dstA valid entity identifier.
-
-
- -

Definition at line 381 of file prototype.hpp.

- -
-
- -

◆ assign() [1/2]

- -
-
-
-template<typename Entity >
- - -
- - - - - - - - - - - + @@ -415,12 +319,12 @@ template<typename Entity > -

Definition at line 308 of file prototype.hpp.

+

Definition at line 291 of file prototype.hpp.

- -

◆ assign() [2/2]

+ +

◆ assign() [2/2]

@@ -431,9 +335,9 @@ template<typename Entity >
void entt::Prototype< Entity >::assign (registry_type & other,
const entity_type const entity_type  dst 
- + - + @@ -458,12 +362,12 @@ template<typename Entity > -

Definition at line 334 of file prototype.hpp.

+

Definition at line 317 of file prototype.hpp.

- -

◆ create() [1/2]

+ +

◆ assign_or_replace() [1/2]

@@ -474,9 +378,168 @@ template<typename Entity >
+ + +
void entt::Prototype< Entity >::assign void entt::basic_prototype< Entity >::assign (const entity_type const entity_type  dst) const
- + - + + + + + + + + + + + + + + +
entity_type entt::Prototype< Entity >::create void entt::basic_prototype< Entity >::assign_or_replace (registry_type & registry_type & other,
const entity_type dst 
) const
+ 		+inline
+
+ +

Assigns or replaces the components of a prototype for an entity.

+

Existing components are overwritten, if any. All the other components will be copied over to the target entity.

+
Note
The registry may or may not be different from the one already used by the prototype. There is also an overload that directly uses the underlying registry.
+
Warning
Attempting to use an invalid entity results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode in case of invalid entity.
+
Parameters
+ + + +
otherA valid reference to a registry.
dstA valid entity identifier.
+
+
+ +

Definition at line 340 of file prototype.hpp.

+ +
+ + +

◆ assign_or_replace() [2/2]

+ +
+
+
+template<typename Entity >
+ + + + + +
+ + + + + + + + +
void entt::basic_prototype< Entity >::assign_or_replace (const entity_type dst) const
+ 		+inline
+
+ +

Assigns or replaces the components of a prototype for an entity.

+

Existing components are overwritten, if any. All the other components will be copied over to the target entity.

+
Note
This overload directly uses the underlying registry as a working space. Therefore, the components of the prototype and of the entity will share the same registry.
+
Warning
Attempting to use an invalid entity results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode in case of invalid entity.
+
Parameters
+ + +
dstA valid entity identifier.
+
+
+ +

Definition at line 364 of file prototype.hpp.

+ +
+
+ +

◆ backend() [1/2]

+ +
+
+
+template<typename Entity >
+ + + + + +
+ + + + + + + +
const registry_type& entt::basic_prototype< Entity >::backend () const
+ 		+inline
+
+ +

Returns a reference to the underlying registry.

+
Returns
A reference to the underlying registry.
+ +

Definition at line 464 of file prototype.hpp.

+ +
+
+ +

◆ backend() [2/2]

+ +
+
+
+template<typename Entity >
+ + + + + +
+ + + + + + + +
registry_type& entt::basic_prototype< Entity >::backend ()
+ 		+inline
+
+ +

Returns a reference to the underlying registry.

+
Returns
A reference to the underlying registry.
+ +

Definition at line 469 of file prototype.hpp.

+ +
+
+ +

◆ create() [1/2]

+ +
+
+
+template<typename Entity >
+ + +
+ + + + + @@ -490,7 +553,7 @@ template<typename Entity >

Creates a new entity using a given prototype.

Utility shortcut, equivalent to the following snippet:

-
const auto entity = registry.create();
prototype(registry, entity);
Note
The registry may or may not be different from the one already used by the prototype. There is also an overload that directly uses the underlying registry.
+
const auto entity = registry.create();
prototype(registry, entity);
Note
The registry may or may not be different from the one already used by the prototype. There is also an overload that directly uses the underlying registry.
Parameters
entity_type entt::basic_prototype< Entity >::create (registry_type &  other) const
@@ -499,12 +562,12 @@ template<typename Entity >
Returns
A valid entity identifier.
-

Definition at line 260 of file prototype.hpp.

+

Definition at line 243 of file prototype.hpp.

- -

◆ create() [2/2]

+ +

◆ create() [2/2]

@@ -515,7 +578,7 @@ template<typename Entity >
otherA valid reference to a registry.
- + @@ -530,28 +593,28 @@ template<typename Entity >

Creates a new entity using a given prototype.

Utility shortcut, equivalent to the following snippet:

-
const auto entity = registry.create();
prototype(entity);
Note
This overload directly uses the underlying registry as a working space. Therefore, the components of the prototype and of the entity will share the same registry.
+
const auto entity = registry.create();
prototype(entity);
Note
This overload directly uses the underlying registry as a working space. Therefore, the components of the prototype and of the entity will share the same registry.
Returns
A valid entity identifier.
-

Definition at line 283 of file prototype.hpp.

+

Definition at line 266 of file prototype.hpp.

- -

◆ get() [1/4]

+ +

◆ get() [1/2]

template<typename Entity >
-template<typename Component >
+template<typename... Component>
entity_type entt::Prototype< Entity >::create entity_type entt::basic_prototype< Entity >::create ( ) const
- + @@ -564,36 +627,36 @@ template<typename Component >
const Component& entt::Prototype< Entity >::get decltype(auto) entt::basic_prototype< Entity >::get ( ) const
-

Returns a reference to the given component.

+

Returns references to the given components.

Warning
Attempting to get a component from a prototype that doesn't own it results in undefined behavior.
An assertion will abort the execution at runtime in debug mode if the prototype doesn't own an instance of the given component.
Template Parameters
- +
ComponentType of component to get.
ComponentTypes of components to get.
-
Returns
A reference to the component owned by the prototype.
+
Returns
References to the components owned by the prototype.
-

Definition at line 185 of file prototype.hpp.

+

Definition at line 182 of file prototype.hpp.

- -

◆ get() [2/4]

+ +

◆ get() [2/2]

template<typename Entity >
-template<typename Component >
+template<typename... Component>
- - -
- + @@ -606,65 +669,23 @@ template<typename Component >
Component& entt::Prototype< Entity >::get decltype(auto) entt::basic_prototype< Entity >::get ( )
-

Returns a reference to the given component.

+

Returns references to the given components.

Warning
Attempting to get a component from a prototype that doesn't own it results in undefined behavior.
An assertion will abort the execution at runtime in debug mode if the prototype doesn't own an instance of the given component.
Template Parameters
- -
ComponentType of component to get.
-
-
-
Returns
A reference to the component owned by the prototype.
- -

Definition at line 202 of file prototype.hpp.

- -
- - -

◆ get() [3/4]

- -
-
-
-template<typename Entity >
-
-template<typename... Component>
- - - - - -
- - - - - - - -
std::enable_if_t<(sizeof...(Component) > 1), std::tuple<const Component &...> > entt::Prototype< Entity >::get () const
- 		-inline
-
- -

Returns a reference to the given components.

-
Warning
Attempting to get components from a prototype that doesn't own them results in undefined behavior.
- An assertion will abort the execution at runtime in debug mode if the prototype doesn't own instances of the given components.
-
Template Parameters
- - +
ComponentType of components to get.
ComponentTypes of components to get.
Returns
References to the components owned by the prototype.
-

Definition at line 220 of file prototype.hpp.

+

Definition at line 192 of file prototype.hpp.

- -

◆ get() [4/4]

+ +

◆ has()

@@ -677,49 +698,7 @@ template<typename... Component>
- - - - - -
std::enable_if_t<(sizeof...(Component) > 1), std::tuple<Component &...> > entt::Prototype< Entity >::get ()
- 		-inline
-
- -

Returns a reference to the given components.

-
Warning
Attempting to get components from a prototype that doesn't own them results in undefined behavior.
- An assertion will abort the execution at runtime in debug mode if the prototype doesn't own instances of the given components.
-
Template Parameters
- - -
ComponentType of components to get.
-
-
-
Returns
References to the components owned by the prototype.
- -

Definition at line 238 of file prototype.hpp.

- -
- - -

◆ has()

- -
-
-
-template<typename Entity >
-
-template<typename... Component>
- - -
- - - + @@ -741,12 +720,12 @@ template<typename... Component>
Returns
True if the prototype owns all the components, false otherwise.
-

Definition at line 168 of file prototype.hpp.

+

Definition at line 165 of file prototype.hpp.

- -

◆ operator()() [1/4]

+ +

◆ operator()() [1/4]

@@ -757,15 +736,15 @@ template<typename Entity >
bool entt::Prototype< Entity >::has bool entt::basic_prototype< Entity >::has ( ) const - + - + - + @@ -795,12 +774,12 @@ template<typename Entity > -

Definition at line 406 of file prototype.hpp.

+

Definition at line 389 of file prototype.hpp.

- -

◆ operator()() [2/4]

+ +

◆ operator()() [2/4]

@@ -811,9 +790,9 @@ template<typename Entity >
void entt::Prototype< Entity >::operator() void entt::basic_prototype< Entity >::operator() (registry_type & registry_type &  other,
const entity_type const entity_type  dst 
- + - + @@ -838,12 +817,12 @@ template<typename Entity > -

Definition at line 430 of file prototype.hpp.

+

Definition at line 413 of file prototype.hpp.

- -

◆ operator()() [3/4]

+ +

◆ operator()() [3/4]

@@ -854,9 +833,9 @@ template<typename Entity >
+ + +
void entt::Prototype< Entity >::operator() void entt::basic_prototype< Entity >::operator() (const entity_type const entity_type  dst) const
- + - + @@ -870,7 +849,7 @@ template<typename Entity >

Creates a new entity using a given prototype.

Utility shortcut, equivalent to the following snippet:

-
const auto entity = registry.create();
prototype(registry, entity);
Note
The registry may or may not be different from the one already used by the prototype. There is also an overload that directly uses the underlying registry.
+
const auto entity = registry.create();
prototype(registry, entity);
Note
The registry may or may not be different from the one already used by the prototype. There is also an overload that directly uses the underlying registry.
Parameters
entity_type entt::Prototype< Entity >::operator() entity_type entt::basic_prototype< Entity >::operator() (registry_type & registry_type &  other) const
@@ -879,12 +858,12 @@ template<typename Entity >
Returns
A valid entity identifier.
-

Definition at line 452 of file prototype.hpp.

+

Definition at line 435 of file prototype.hpp.

- -

◆ operator()() [4/4]

+ +

◆ operator()() [4/4]

@@ -895,7 +874,7 @@ template<typename Entity >
@@ -59,7 +59,7 @@ $(function() {
@@ -67,56 +67,65 @@ $(function() { Classes | Public Types | Public Member Functions | -List of all members
+List of all members
-
entt::Dispatcher Class Referencefinal
+
entt::dispatcher Class Reference

Basic dispatcher implementation. - More...

+ More...

#include <dispatcher.hpp>

otherA valid reference to a registry.
- + @@ -910,15 +889,15 @@ template<typename Entity >

Creates a new entity using a given prototype.

Utility shortcut, equivalent to the following snippet:

-
const auto entity = registry.create();
prototype(entity);
Note
This overload directly uses the underlying registry as a working space. Therefore, the components of the prototype and of the entity will share the same registry.
+
const auto entity = registry.create();
prototype(entity);
Note
This overload directly uses the underlying registry as a working space. Therefore, the components of the prototype and of the entity will share the same registry.
Returns
A valid entity identifier.
-

Definition at line 473 of file prototype.hpp.

+

Definition at line 456 of file prototype.hpp.

- -

◆ operator=() [1/2]

+ +

◆ operator=()

@@ -929,40 +908,9 @@ template<typename Entity >
- - -
entity_type entt::Prototype< Entity >::operator() entity_type entt::basic_prototype< Entity >::operator() ( ) const - + - - - - -
Prototype& entt::Prototype< Entity >::operator= basic_prototype& entt::basic_prototype< Entity >::operator= (const Prototype< Entity > & )
- 		-delete
-
- -

Copying a prototype isn't allowed.

-
Returns
This Prototype.
- -
- - -

◆ operator=() [2/2]

- -
-
-
-template<typename Entity >
- - - @@ -59,27 +59,27 @@ $(function() {
-
entt::Delegate< typename > Class Template Reference
+
entt::delegate< typename > Class Template Reference

Basic delegate implementation. - More...

+ More...

#include <delegate.hpp>

Detailed Description

template<typename>
-class entt::Delegate< typename >

+class entt::delegate< typename >

Basic delegate implementation.

Primary template isn't defined on purpose. All the specializations give a compile-time error unless the template parameter is a function type.

-

Definition at line 19 of file delegate.hpp.

+

Definition at line 66 of file delegate.hpp.

The documentation for this class was generated from the following file: diff --git a/classentt_1_1delegate_3_01Ret_07Args_8_8_8_08_4-members.html b/classentt_1_1delegate_3_01Ret_07Args_8_8_8_08_4-members.html new file mode 100644 index 000000000..e61f294fa --- /dev/null +++ b/classentt_1_1delegate_3_01Ret_07Args_8_8_8_08_4-members.html @@ -0,0 +1,92 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
+
+
- - - - - + @@ -982,14 +930,14 @@ template<typename Entity >
Prototype& entt::Prototype< Entity >::operator= (Prototype< Entity > && basic_prototype< Entity > &&  other)
-
Returns
This Prototype.
+
Returns
This prototype.
-

Definition at line 115 of file prototype.hpp.

+

Definition at line 110 of file prototype.hpp.

- -

◆ set()

+ +

◆ set()

@@ -1002,7 +950,7 @@ template<typename Component , typename... Args>
- + @@ -1032,12 +980,92 @@ template<typename Component , typename... Args>
Returns
A reference to the newly created component.
-

Definition at line 134 of file prototype.hpp.

+

Definition at line 129 of file prototype.hpp.

- -

◆ unset()

+ +

◆ try_get() [1/2]

+ +
+
+
+template<typename Entity >
+
+template<typename... Component>
+
Component& entt::Prototype< Entity >::set Component& entt::basic_prototype< Entity >::set ( Args &&...  args)
+ + + + +
+ + + + + + + +
auto entt::basic_prototype< Entity >::try_get () const
+ 		+inline
+
+ +

Returns pointers to the given components.

+
Template Parameters
+ + +
ComponentTypes of components to get.
+
+
+
Returns
Pointers to the components owned by the prototype.
+ +

Definition at line 206 of file prototype.hpp.

+ +
+ + +

◆ try_get() [2/2]

+ +
+
+
+template<typename Entity >
+
+template<typename... Component>
+ + + + + +
+ + + + + + + +
auto entt::basic_prototype< Entity >::try_get ()
+ 		+inline
+
+ +

Returns pointers to the given components.

+
Template Parameters
+ + +
ComponentTypes of components to get.
+
+
+
Returns
Pointers to the components owned by the prototype.
+ +

Definition at line 217 of file prototype.hpp.

+ +
+
+ +

◆ unset()

@@ -1050,7 +1078,7 @@ template<typename Component >
- + @@ -1071,11 +1099,12 @@ template<typename Component > -

Definition at line 157 of file prototype.hpp.

+

Definition at line 154 of file prototype.hpp.

-
The documentation for this class was generated from the following file:
    +
    The documentation for this class was generated from the following files: diff --git a/classentt_1_1basic__registry-members.html b/classentt_1_1basic__registry-members.html new file mode 100644 index 000000000..ee9524ddb --- /dev/null +++ b/classentt_1_1basic__registry-members.html @@ -0,0 +1,148 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
    +
    +
void entt::Prototype< Entity >::unset void entt::basic_prototype< Entity >::unset ( )
+ + + + + +
+
EnTT +  3.0.0 +
+
+ + + + + + + + + +
+
+ + +
+ +
+ + + +
+
+
entt::basic_registry< Entity > Member List
+
+
+ +

This is the complete list of members for entt::basic_registry< Entity >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
alive() const ENTT_NOEXCEPTentt::basic_registry< Entity >inline
assign(const entity_type entity, [[maybe_unused]] Args &&... args)entt::basic_registry< Entity >inline
assign_or_replace(const entity_type entity, Args &&... args)entt::basic_registry< Entity >inline
basic_registry() ENTT_NOEXCEPT=defaultentt::basic_registry< Entity >
basic_registry(basic_registry &&)=defaultentt::basic_registry< Entity >
capacity() const ENTT_NOEXCEPTentt::basic_registry< Entity >inline
capacity() const ENTT_NOEXCEPTentt::basic_registry< Entity >inline
clone() constentt::basic_registry< Entity >inline
component_type typedefentt::basic_registry< Entity >
create()entt::basic_registry< Entity >inline
create(It first, It last)entt::basic_registry< Entity >inline
ctx() const ENTT_NOEXCEPTentt::basic_registry< Entity >inline
ctx() ENTT_NOEXCEPTentt::basic_registry< Entity >inline
current(const entity_type entity) const ENTT_NOEXCEPTentt::basic_registry< Entity >inline
data() const ENTT_NOEXCEPTentt::basic_registry< Entity >inline
destroy(const entity_type entity)entt::basic_registry< Entity >inline
destroy(It first, It last)entt::basic_registry< Entity >inline
each(Func func) constentt::basic_registry< Entity >inline
empty() const ENTT_NOEXCEPTentt::basic_registry< Entity >inline
empty() const ENTT_NOEXCEPTentt::basic_registry< Entity >inline
entity(const entity_type entity) ENTT_NOEXCEPTentt::basic_registry< Entity >inlinestatic
entity_type typedefentt::basic_registry< Entity >
get([[maybe_unused]] const entity_type entity) const ENTT_NOEXCEPTentt::basic_registry< Entity >inline
get([[maybe_unused]] const entity_type entity) ENTT_NOEXCEPTentt::basic_registry< Entity >inline
get_or_assign(const entity_type entity, Args &&... args) ENTT_NOEXCEPTentt::basic_registry< Entity >inline
group(get_t< Get... >, exclude_t< Exclude... >={})entt::basic_registry< Entity >inline
group(get_t< Get... >, exclude_t< Exclude... >={}) constentt::basic_registry< Entity >inline
group(exclude_t< Exclude... >={})entt::basic_registry< Entity >inline
group(exclude_t< Exclude... >={}) constentt::basic_registry< Entity >inline
has(const entity_type entity) const ENTT_NOEXCEPTentt::basic_registry< Entity >inline
loader() ENTT_NOEXCEPTentt::basic_registry< Entity >inline
on_construct() ENTT_NOEXCEPTentt::basic_registry< Entity >inline
on_destroy() ENTT_NOEXCEPTentt::basic_registry< Entity >inline
on_replace() ENTT_NOEXCEPTentt::basic_registry< Entity >inline
operator=(basic_registry &&)=defaultentt::basic_registry< Entity >
orphan(const entity_type entity) constentt::basic_registry< Entity >inline
orphans(Func func) constentt::basic_registry< Entity >inline
owned() const ENTT_NOEXCEPTentt::basic_registry< Entity >inline
raw() const ENTT_NOEXCEPTentt::basic_registry< Entity >inline
raw() ENTT_NOEXCEPTentt::basic_registry< Entity >inline
remove(const entity_type entity)entt::basic_registry< Entity >inline
replace(const entity_type entity, Args &&... args)entt::basic_registry< Entity >inline
reserve(const size_type cap)entt::basic_registry< Entity >inline
reserve(const size_type cap)entt::basic_registry< Entity >inline
reset(const entity_type entity)entt::basic_registry< Entity >inline
reset()entt::basic_registry< Entity >inline
reset()entt::basic_registry< Entity >inline
runtime_view(It first, It last) constentt::basic_registry< Entity >inline
set(Args &&... args)entt::basic_registry< Entity >inline
shrink_to_fit()entt::basic_registry< Entity >inline
size() const ENTT_NOEXCEPTentt::basic_registry< Entity >inline
size() const ENTT_NOEXCEPTentt::basic_registry< Entity >inline
size_type typedefentt::basic_registry< Entity >
snapshot() const ENTT_NOEXCEPTentt::basic_registry< Entity >inline
sort(Compare compare, Sort algo=Sort{}, Args &&... args)entt::basic_registry< Entity >inline
sort()entt::basic_registry< Entity >inline
try_ctx() const ENTT_NOEXCEPTentt::basic_registry< Entity >inline
try_ctx() ENTT_NOEXCEPTentt::basic_registry< Entity >inline
try_get([[maybe_unused]] const entity_type entity) const ENTT_NOEXCEPTentt::basic_registry< Entity >inline
try_get([[maybe_unused]] const entity_type entity) ENTT_NOEXCEPTentt::basic_registry< Entity >inline
type() ENTT_NOEXCEPTentt::basic_registry< Entity >inlinestatic
unset()entt::basic_registry< Entity >inline
valid(const entity_type entity) const ENTT_NOEXCEPTentt::basic_registry< Entity >inline
version(const entity_type entity) ENTT_NOEXCEPTentt::basic_registry< Entity >inlinestatic
version_type typedefentt::basic_registry< Entity >
view()entt::basic_registry< Entity >inline
view() constentt::basic_registry< Entity >inline
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1basic__registry.html b/classentt_1_1basic__registry.html new file mode 100644 index 000000000..0c4e0d971 --- /dev/null +++ b/classentt_1_1basic__registry.html @@ -0,0 +1,3171 @@ + + + + + + + +EnTT: entt::basic_registry< Entity > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+Classes | +Public Types | +Public Member Functions | +Static Public Member Functions | +List of all members
+
+
entt::basic_registry< Entity > Class Template Reference
+
+
+ +

Fast and reliable entity-component system. + More...

+ +

#include <registry.hpp>

+ + + + + + + + + + + + + + +

+Public Types

+using entity_type = typename traits_type::entity_type
 Underlying entity identifier.
 
+using version_type = typename traits_type::version_type
 Underlying version type.
 
+using size_type = typename sparse_set< Entity >::size_type
 Unsigned integer type.
 
+using component_type = ENTT_ID_TYPE
 Unsigned integer type.
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+ basic_registry () ENTT_NOEXCEPT=default
 Default constructor.
 
+ basic_registry (basic_registry &&)=default
 Default move constructor.
 
basic_registry & operator= (basic_registry &&)=default
 Default move assignment operator. More...
 
template<typename Component >
size_type size () const ENTT_NOEXCEPT
 Returns the number of existing components of the given type. More...
 
size_type size () const ENTT_NOEXCEPT
 Returns the number of entities created so far. More...
 
size_type alive () const ENTT_NOEXCEPT
 Returns the number of entities still in use. More...
 
template<typename Component >
void reserve (const size_type cap)
 Increases the capacity of the pool for the given component. More...
 
void reserve (const size_type cap)
 Increases the capacity of a registry in terms of entities. More...
 
template<typename Component >
size_type capacity () const ENTT_NOEXCEPT
 Returns the capacity of the pool for the given component. More...
 
size_type capacity () const ENTT_NOEXCEPT
 Returns the number of entities that a registry has currently allocated space for. More...
 
template<typename Component >
void shrink_to_fit ()
 Requests the removal of unused capacity for a given component. More...
 
template<typename Component >
bool empty () const ENTT_NOEXCEPT
 Checks whether the pool of a given component is empty. More...
 
bool empty () const ENTT_NOEXCEPT
 Checks if there exists at least an entity still in use. More...
 
template<typename Component >
const Component * raw () const ENTT_NOEXCEPT
 Direct access to the list of components of a given pool. More...
 
template<typename Component >
Component * raw () ENTT_NOEXCEPT
 Direct access to the list of components of a given pool. More...
 
template<typename Component >
const entity_type * data () const ENTT_NOEXCEPT
 Direct access to the list of entities of a given pool. More...
 
bool valid (const entity_type entity) const ENTT_NOEXCEPT
 Checks if an entity identifier refers to a valid entity. More...
 
version_type current (const entity_type entity) const ENTT_NOEXCEPT
 Returns the actual version for an entity identifier. More...
 
template<typename... Component>
decltype(auto) create ()
 Creates a new entity and returns it. More...
 
template<typename... Component, typename It >
auto create (It first, It last)
 Assigns each element in a range an entity. More...
 
void destroy (const entity_type entity)
 Destroys an entity and lets the registry recycle the identifier. More...
 
template<typename It >
void destroy (It first, It last)
 Destroys all the entities in a range. More...
 
template<typename Component , typename... Args>
decltype(auto) assign (const entity_type entity, [[maybe_unused]] Args &&... args)
 Assigns the given component to an entity. More...
 
template<typename Component >
void remove (const entity_type entity)
 Removes the given component from an entity. More...
 
template<typename... Component>
bool has (const entity_type entity) const ENTT_NOEXCEPT
 Checks if an entity has all the given components. More...
 
template<typename... Component>
decltype(auto) get ([[maybe_unused]] const entity_type entity) const ENTT_NOEXCEPT
 Returns references to the given components for an entity. More...
 
template<typename... Component>
decltype(auto) get ([[maybe_unused]] const entity_type entity) ENTT_NOEXCEPT
 Returns references to the given components for an entity. More...
 
template<typename Component , typename... Args>
decltype(auto) get_or_assign (const entity_type entity, Args &&... args) ENTT_NOEXCEPT
 Returns a reference to the given component for an entity. More...
 
template<typename... Component>
auto try_get ([[maybe_unused]] const entity_type entity) const ENTT_NOEXCEPT
 Returns pointers to the given components for an entity. More...
 
template<typename... Component>
auto try_get ([[maybe_unused]] const entity_type entity) ENTT_NOEXCEPT
 Returns pointers to the given components for an entity. More...
 
template<typename Component , typename... Args>
decltype(auto) replace (const entity_type entity, Args &&... args)
 Replaces the given component for an entity. More...
 
template<typename Component , typename... Args>
decltype(auto) assign_or_replace (const entity_type entity, Args &&... args)
 Assigns or replaces the given component for an entity. More...
 
template<typename Component >
auto on_construct () ENTT_NOEXCEPT
 Returns a sink object for the given component. More...
 
template<typename Component >
auto on_replace () ENTT_NOEXCEPT
 Returns a sink object for the given component. More...
 
template<typename Component >
auto on_destroy () ENTT_NOEXCEPT
 Returns a sink object for the given component. More...
 
template<typename Component , typename Compare , typename Sort = std_sort, typename... Args>
void sort (Compare compare, Sort algo=Sort{}, Args &&... args)
 Sorts the pool of entities for the given component. More...
 
template<typename To , typename From >
void sort ()
 Sorts two pools of components in the same way. More...
 
template<typename Component >
void reset (const entity_type entity)
 Resets the given component for an entity. More...
 
template<typename Component >
void reset ()
 Resets the pool of the given component. More...
 
void reset ()
 Resets a whole registry. More...
 
template<typename Func >
void each (Func func) const
 Iterates all the entities that are still in use. More...
 
bool orphan (const entity_type entity) const
 Checks if an entity has components assigned. More...
 
template<typename Func >
void orphans (Func func) const
 Iterates orphans and applies them the given function object. More...
 
template<typename... Component>
entt::basic_view< Entity, Component... > view ()
 Returns a view for the given components. More...
 
template<typename... Component>
entt::basic_view< Entity, Component... > view () const
 Returns a view for the given components. More...
 
template<typename Component >
bool owned () const ENTT_NOEXCEPT
 Checks whether a given component belongs to a group. More...
 
template<typename... Owned, typename... Get, typename... Exclude>
entt::basic_group< Entity, get_t< Get... >, Owned... > group (get_t< Get... >, exclude_t< Exclude... >={})
 Returns a group for the given components. More...
 
template<typename... Owned, typename... Get, typename... Exclude>
entt::basic_group< Entity, get_t< Get... >, Owned... > group (get_t< Get... >, exclude_t< Exclude... >={}) const
 Returns a group for the given components. More...
 
template<typename... Owned, typename... Exclude>
entt::basic_group< Entity, get_t<>, Owned... > group (exclude_t< Exclude... >={})
 Returns a group for the given components. More...
 
template<typename... Owned, typename... Exclude>
entt::basic_group< Entity, get_t<>, Owned... > group (exclude_t< Exclude... >={}) const
 Returns a group for the given components. More...
 
template<typename It >
entt::basic_runtime_view< Entity > runtime_view (It first, It last) const
 Returns a runtime view for the given components. More...
 
template<typename... Component>
basic_registry clone () const
 Clones the given components and all the entity identifiers. More...
 
entt::basic_snapshot< Entity > snapshot () const ENTT_NOEXCEPT
 Returns a temporary object to use to create snapshots. More...
 
basic_snapshot_loader< Entity > loader () ENTT_NOEXCEPT
 Returns a temporary object to use to load snapshots. More...
 
template<typename Type , typename... Args>
Type & set (Args &&... args)
 Binds an object to the context of the registry. More...
 
template<typename Type >
void unset ()
 Unsets a context variable if it exists. More...
 
template<typename Type >
const Type * try_ctx () const ENTT_NOEXCEPT
 Returns a pointer to an object in the context of the registry. More...
 
template<typename Type >
Type * try_ctx () ENTT_NOEXCEPT
 Returns a pointer to an object in the context of the registry. More...
 
template<typename Type >
const Type & ctx () const ENTT_NOEXCEPT
 Returns a reference to an object in the context of the registry. More...
 
template<typename Type >
Type & ctx () ENTT_NOEXCEPT
 Returns a reference to an object in the context of the registry. More...
 
+ + + + + + + + + + + +

+Static Public Member Functions

template<typename Component >
static component_type type () ENTT_NOEXCEPT
 Returns the numeric identifier of a component. More...
 
static entity_type entity (const entity_type entity) ENTT_NOEXCEPT
 Returns the entity identifier without the version. More...
 
static version_type version (const entity_type entity) ENTT_NOEXCEPT
 Returns the version stored along with an entity identifier. More...
 
+

Detailed Description

+

template<typename Entity>
+class entt::basic_registry< Entity >

+ +

Fast and reliable entity-component system.

+

The registry is the core class of the entity-component framework.
+ It stores entities and arranges pools of components on a per request basis. By means of a registry, users can manage entities and components and thus create views or groups to iterate them.

+
Template Parameters
+ + +
EntityA valid entity type (see entt_traits for more details).
+
+
+ +

Definition at line 13 of file fwd.hpp.

+

Member Function Documentation

+ +

◆ alive()

+ +
+
+
+template<typename Entity>
+ + + + + +
+ + + + + + + +
size_type entt::basic_registry< Entity >::alive () const
+ 		+inline
+
+ +

Returns the number of entities still in use.

+
Returns
Number of entities still in use.
+ +

Definition at line 371 of file registry.hpp.

+ +
+
+ +

◆ assign()

+ +
+
+
+template<typename Entity>
+
+template<typename Component , typename... Args>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
decltype(auto) entt::basic_registry< Entity >::assign (const entity_type entity,
[[maybe_unused] ] Args &&... args 
)
+ 		+inline
+
+ +

Assigns the given component to an entity.

+

A new instance of the given component is created and initialized with the arguments provided (the component must have a proper constructor or be of aggregate type). Then the component is assigned to the given entity.

+
Warning
Attempting to use an invalid entity or to assign a component to an entity that already owns it results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode in case of invalid entity or if the entity already owns an instance of the given component.
+
Template Parameters
+ + + +
ComponentType of component to create.
ArgsTypes of arguments to use to construct the component.
+
+
+
Parameters
+ + + +
entityA valid entity identifier.
argsParameters to use to initialize the component.
+
+
+
Returns
A reference to the newly created component.
+ +

Definition at line 722 of file registry.hpp.

+ +
+
+ +

◆ assign_or_replace()

+ +
+
+
+template<typename Entity>
+
+template<typename Component , typename... Args>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
decltype(auto) entt::basic_registry< Entity >::assign_or_replace (const entity_type entity,
Args &&... args 
)
+ 		+inline
+
+ +

Assigns or replaces the given component for an entity.

+

Equivalent to the following snippet (pseudocode):

+
auto &component = registry.has<Component>(entity) ? registry.replace<Component>(entity, args...) : registry.assign<Component>(entity, args...);

Prefer this function anyway because it has slightly better performance.

+
Warning
Attempting to use an invalid entity results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode in case of invalid entity.
+
Template Parameters
+ + + +
ComponentType of component to assign or replace.
ArgsTypes of arguments to use to construct the component.
+
+
+
Parameters
+ + + +
entityA valid entity identifier.
argsParameters to use to initialize the component.
+
+
+
Returns
A reference to the newly created component.
+ +

Definition at line 916 of file registry.hpp.

+ +
+
+ +

◆ capacity() [1/2]

+ +
+
+
+template<typename Entity>
+
+template<typename Component >
+ + + + + +
+ + + + + + + +
size_type entt::basic_registry< Entity >::capacity () const
+ 		+inline
+
+ +

Returns the capacity of the pool for the given component.

+
Template Parameters
+ + +
ComponentType of component in which one is interested.
+
+
+
Returns
Capacity of the pool of the given component.
+ +

Definition at line 407 of file registry.hpp.

+ +
+
+ +

◆ capacity() [2/2]

+ +
+
+
+template<typename Entity>
+ + + + + +
+ + + + + + + +
size_type entt::basic_registry< Entity >::capacity () const
+ 		+inline
+
+ +

Returns the number of entities that a registry has currently allocated space for.

+
Returns
Capacity of the registry.
+ +

Definition at line 417 of file registry.hpp.

+ +
+
+ +

◆ clone()

+ +
+
+
+template<typename Entity>
+
+template<typename... Component>
+ + + + + +
+ + + + + + + +
basic_registry entt::basic_registry< Entity >::clone () const
+ 		+inline
+
+ +

Clones the given components and all the entity identifiers.

+

The components must be copiable for obvious reasons. The entities maintain their versions once copied.
+ If no components are provided, the registry will try to clone all the existing pools.

+
Note
There isn't an efficient way to know if all the entities are assigned at least one component once copied. Therefore, there may be orphans. It is up to the caller to clean up the registry if necessary.
+
+Listeners and groups aren't copied. It is up to the caller to connect the listeners of interest to the new registry and to set up groups.
+
Warning
Attempting to clone components that aren't copyable results in unexpected behaviors.
+ A static assertion will abort the compilation when the components provided aren't copy constructible. Otherwise, an assertion will abort the execution at runtime in debug mode in case one or more pools cannot be cloned.
+
Template Parameters
+ + +
ComponentTypes of components to clone.
+
+
+
Returns
A fresh copy of the registry.
+ +

Definition at line 1493 of file registry.hpp.

+ +
+
+ +

◆ create() [1/2]

+ +
+
+
+template<typename Entity>
+
+template<typename... Component>
+ + + + + +
+ + + + + + + +
decltype(auto) entt::basic_registry< Entity >::create ()
+ 		+inline
+
+ +

Creates a new entity and returns it.

+

There are two kinds of entity identifiers:

+
    +
  • Newly created ones in case no entities have been previously destroyed.
    • +
  • Recycled ones with updated versions.
    • +
+

Users should not care about the type of the returned entity identifier. In case entity identifers are stored around, the valid member function can be used to know if they are still valid or the entity has been destroyed and potentially recycled.

+

The returned entity has assigned the given components, if any. The components must be at least default constructible. A compilation error will occur otherwhise.

+
Template Parameters
+ + +
ComponentTypes of components to assign to the entity.
+
+
+
Returns
A valid entity identifier if the component list is empty, a tuple containing the entity identifier and the references to the components just created otherwise.
+ +

Definition at line 569 of file registry.hpp.

+ +
+
+ +

◆ create() [2/2]

+ +
+
+
+template<typename Entity>
+
+template<typename... Component, typename It >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
auto entt::basic_registry< Entity >::create (It first,
It last 
)
+ 		+inline
+
+ +

Assigns each element in a range an entity.

+
See also
create
+
Template Parameters
+ + + +
ComponentTypes of components to assign to the entity.
ItType of forward iterator.
+
+
+
Parameters
+ + + +
firstAn iterator to the first element of the range to generate.
lastAn iterator past the last element of the range to generate.
+
+
+
Returns
No return value if the component list is empty, a tuple containing the pointers to the arrays of components just created and sorted the same of the entities otherwise.
+ +

Definition at line 606 of file registry.hpp.

+ +
+
+ +

◆ ctx() [1/2]

+ +
+
+
+template<typename Entity>
+
+template<typename Type >
+ + + + + +
+ + + + + + + +
const Type& entt::basic_registry< Entity >::ctx () const
+ 		+inline
+
+ +

Returns a reference to an object in the context of the registry.

+
Warning
Attempting to get a context variable that doesn't exist results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode in case of invalid requests.
+
Template Parameters
+ + +
TypeType of object to get.
+
+
+
Returns
A valid reference to the object in the context of the registry.
+ +

Definition at line 1668 of file registry.hpp.

+ +
+
+ +

◆ ctx() [2/2]

+ +
+
+
+template<typename Entity>
+
+template<typename Type >
+ + + + + +
+ + + + + + + +
Type& entt::basic_registry< Entity >::ctx ()
+ 		+inline
+
+ +

Returns a reference to an object in the context of the registry.

+
Warning
Attempting to get a context variable that doesn't exist results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode in case of invalid requests.
+
Template Parameters
+ + +
TypeType of object to get.
+
+
+
Returns
A valid reference to the object in the context of the registry.
+ +

Definition at line 1676 of file registry.hpp.

+ +
+
+ +

◆ current()

+ +
+
+
+template<typename Entity>
+ + + + + +
+ + + + + + + + +
version_type entt::basic_registry< Entity >::current (const entity_type entity) const
+ 		+inline
+
+ +

Returns the actual version for an entity identifier.

+
Warning
Attempting to use an entity that doesn't belong to the registry results in undefined behavior. An entity belongs to the registry even if it has been previously destroyed and/or recycled.
+ An assertion will abort the execution at runtime in debug mode if the registry doesn't own the given entity.
+
Parameters
+ + +
entityA valid entity identifier.
+
+
+
Returns
Actual version for the given entity identifier.
+ +

Definition at line 540 of file registry.hpp.

+ +
+
+ +

◆ data()

+ +
+
+
+template<typename Entity>
+
+template<typename Component >
+ + + + + +
+ + + + + + + +
const entity_type* entt::basic_registry< Entity >::data () const
+ 		+inline
+
+ +

Direct access to the list of entities of a given pool.

+

The returned pointer is such that range [data<Component>(), data<Component>() + size<Component>()] is always a valid range, even if the container is empty.

+

There are no guarantees on the order of the entities. Use a view if you want to iterate entities and components in the expected order.

+
Template Parameters
+ + +
ComponentType of component in which one is interested.
+
+
+
Returns
A pointer to the array of entities.
+ +

Definition at line 494 of file registry.hpp.

+ +
+
+ +

◆ destroy() [1/2]

+ +
+
+
+template<typename Entity>
+ + + + + +
+ + + + + + + + +
void entt::basic_registry< Entity >::destroy (const entity_type entity)
+ 		+inline
+
+ +

Destroys an entity and lets the registry recycle the identifier.

+

When an entity is destroyed, its version is updated and the identifier can be recycled at any time. In case entity identifers are stored around, the valid member function can be used to know if they are still valid or the entity has been destroyed and potentially recycled.

+
Warning
In case there are listeners that observe the destruction of components and assign other components to the entity in their bodies, the result of invoking this function may not be as expected. In the worst case, it could lead to undefined behavior. An assertion will abort the execution at runtime in debug mode if a violation is detected.
+
+Attempting to use an invalid entity results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode in case of invalid entity.
+
Parameters
+ + +
entityA valid entity identifier.
+
+
+ +

Definition at line 659 of file registry.hpp.

+ +
+
+ +

◆ destroy() [2/2]

+ +
+
+
+template<typename Entity>
+
+template<typename It >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void entt::basic_registry< Entity >::destroy (It first,
It last 
)
+ 		+inline
+
+ +

Destroys all the entities in a range.

+
Template Parameters
+ + +
ItType of forward iterator.
+
+
+
Parameters
+ + + +
firstAn iterator to the first element of the range to generate.
lastAn iterator past the last element of the range to generate.
+
+
+ +

Definition at line 680 of file registry.hpp.

+ +
+
+ +

◆ each()

+ +
+
+
+template<typename Entity>
+
+template<typename Func >
+ + + + + +
+ + + + + + + + +
void entt::basic_registry< Entity >::each (Func func) const
+ 		+inline
+
+ +

Iterates all the entities that are still in use.

+

The function object is invoked for each entity that is still in use.
+ The signature of the function should be equivalent to the following:

+
void(const Entity);

This function is fairly slow and should not be used frequently. However, it's useful for iterating all the entities still in use, regardless of their components.

+
Template Parameters
+ + +
FuncType of the function object to invoke.
+
+
+
Parameters
+ + +
funcA valid function object.
+
+
+ +

Definition at line 1187 of file registry.hpp.

+ +
+
+ +

◆ empty() [1/2]

+ +
+
+
+template<typename Entity>
+
+template<typename Component >
+ + + + + +
+ + + + + + + +
bool entt::basic_registry< Entity >::empty () const
+ 		+inline
+
+ +

Checks whether the pool of a given component is empty.

+
Template Parameters
+ + +
ComponentType of component in which one is interested.
+
+
+
Returns
True if the pool of the given component is empty, false otherwise.
+ +

Definition at line 437 of file registry.hpp.

+ +
+
+ +

◆ empty() [2/2]

+ +
+
+
+template<typename Entity>
+ + + + + +
+ + + + + + + +
bool entt::basic_registry< Entity >::empty () const
+ 		+inline
+
+ +

Checks if there exists at least an entity still in use.

+
Returns
True if at least an entity is still in use, false otherwise.
+ +

Definition at line 446 of file registry.hpp.

+ +
+
+ +

◆ entity()

+ +
+
+
+template<typename Entity>
+ + + + + +
+ + + + + + + + +
static entity_type entt::basic_registry< Entity >::entity (const entity_type entity)
+ 		+inlinestatic
+
+ +

Returns the entity identifier without the version.

+
Parameters
+ + +
entityAn entity identifier, either valid or not.
+
+
+
Returns
The entity identifier without the version.
+ +

Definition at line 514 of file registry.hpp.

+ +
+
+ +

◆ get() [1/2]

+ +
+
+
+template<typename Entity>
+
+template<typename... Component>
+ + + + + +
+ + + + + + + + +
decltype(auto) entt::basic_registry< Entity >::get ([[maybe_unused] ] const entity_type entity) const
+ 		+inline
+
+ +

Returns references to the given components for an entity.

+
Warning
Attempting to use an invalid entity or to get a component from an entity that doesn't own it results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode in case of invalid entity or if the entity doesn't own an instance of the given component.
+
Template Parameters
+ + +
ComponentTypes of components to get.
+
+
+
Parameters
+ + +
entityA valid entity identifier.
+
+
+
Returns
References to the components owned by the entity.
+ +

Definition at line 780 of file registry.hpp.

+ +
+
+ +

◆ get() [2/2]

+ +
+
+
+template<typename Entity>
+
+template<typename... Component>
+ + + + + +
+ + + + + + + + +
decltype(auto) entt::basic_registry< Entity >::get ([[maybe_unused] ] const entity_type entity)
+ 		+inline
+
+ +

Returns references to the given components for an entity.

+
Warning
Attempting to use an invalid entity or to get a component from an entity that doesn't own it results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode in case of invalid entity or if the entity doesn't own an instance of the given component.
+
Template Parameters
+ + +
ComponentTypes of components to get.
+
+
+
Parameters
+ + +
entityA valid entity identifier.
+
+
+
Returns
References to the components owned by the entity.
+ +

Definition at line 792 of file registry.hpp.

+ +
+
+ +

◆ get_or_assign()

+ +
+
+
+template<typename Entity>
+
+template<typename Component , typename... Args>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
decltype(auto) entt::basic_registry< Entity >::get_or_assign (const entity_type entity,
Args &&... args 
)
+ 		+inline
+
+ +

Returns a reference to the given component for an entity.

+

In case the entity doesn't own the component, the parameters provided are used to construct it.
+ Equivalent to the following snippet (pseudocode):

+
auto &component = registry.has<Component>(entity) ? registry.get<Component>(entity) : registry.assign<Component>(entity, args...);

Prefer this function anyway because it has slightly better performance.

+
Warning
Attempting to use an invalid entity results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode in case of invalid entity.
+
Template Parameters
+ + + +
ComponentType of component to get.
ArgsTypes of arguments to use to construct the component.
+
+
+
Parameters
+ + + +
entityA valid entity identifier.
argsParameters to use to initialize the component.
+
+
+
Returns
Reference to the component owned by the entity.
+ +

Definition at line 827 of file registry.hpp.

+ +
+
+ +

◆ group() [1/4]

+ +
+
+
+template<typename Entity>
+
+template<typename... Owned, typename... Get, typename... Exclude>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
entt::basic_group<Entity, get_t<Get...>, Owned...> entt::basic_registry< Entity >::group (get_t< Get... > ,
exclude_t< Exclude... >  = {} 
)
+ 		+inline
+
+ +

Returns a group for the given components.

+

This kind of objects are created on the fly and share with the registry its internal data structures.
+ Feel free to discard a group after the use. Creating and destroying a group is an incredibly cheap operation because they do not require any type of initialization, but for the first time they are requested.
+ As a rule of thumb, storing a group should never be an option.

+

Groups support exclusion lists and can own types of components. The more types are owned by a group, the faster it is to iterate entities and components.
+ However, groups also affect some features of the registry such as the creation and destruction of components, which will consequently be slightly slower (nothing that can be noticed in most cases).

+
Note
Pools of components that are owned by a group cannot be sorted anymore. The group takes the ownership of the pools and arrange components so as to iterate them as fast as possible.
+
Template Parameters
+ + + + +
OwnedTypes of components owned by the group.
GetTypes of components observed by the group.
ExcludeTypes of components used to filter the group.
+
+
+
Returns
A newly created group.
+ +

Definition at line 1333 of file registry.hpp.

+ +
+
+ +

◆ group() [2/4]

+ +
+
+
+template<typename Entity>
+
+template<typename... Owned, typename... Get, typename... Exclude>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
entt::basic_group<Entity, get_t<Get...>, Owned...> entt::basic_registry< Entity >::group (get_t< Get... > ,
exclude_t< Exclude... >  = {} 
) const
+ 		+inline
+
+ +

Returns a group for the given components.

+

This kind of objects are created on the fly and share with the registry its internal data structures.
+ Feel free to discard a group after the use. Creating and destroying a group is an incredibly cheap operation because they do not require any type of initialization, but for the first time they are requested.
+ As a rule of thumb, storing a group should never be an option.

+

Groups support exclusion lists and can own types of components. The more types are owned by a group, the faster it is to iterate entities and components.
+ However, groups also affect some features of the registry such as the creation and destruction of components, which will consequently be slightly slower (nothing that can be noticed in most cases).

+
Note
Pools of components that are owned by a group cannot be sorted anymore. The group takes the ownership of the pools and arrange components so as to iterate them as fast as possible.
+
Template Parameters
+ + + + +
OwnedTypes of components owned by the group.
GetTypes of components observed by the group.
ExcludeTypes of components used to filter the group.
+
+
+
Returns
A newly created group.
+ +

Definition at line 1410 of file registry.hpp.

+ +
+
+ +

◆ group() [3/4]

+ +
+
+
+template<typename Entity>
+
+template<typename... Owned, typename... Exclude>
+ + + + + +
+ + + + + + + + +
entt::basic_group<Entity, get_t<>, Owned...> entt::basic_registry< Entity >::group (exclude_t< Exclude... >  = {})
+ 		+inline
+
+ +

Returns a group for the given components.

+

This kind of objects are created on the fly and share with the registry its internal data structures.
+ Feel free to discard a group after the use. Creating and destroying a group is an incredibly cheap operation because they do not require any type of initialization, but for the first time they are requested.
+ As a rule of thumb, storing a group should never be an option.

+

Groups support exclusion lists and can own types of components. The more types are owned by a group, the faster it is to iterate entities and components.
+ However, groups also affect some features of the registry such as the creation and destruction of components, which will consequently be slightly slower (nothing that can be noticed in most cases).

+
Note
Pools of components that are owned by a group cannot be sorted anymore. The group takes the ownership of the pools and arrange components so as to iterate them as fast as possible.
+
Template Parameters
+ + + + +
OwnedTypes of components owned by the group.
GetTypes of components observed by the group.
ExcludeTypes of components used to filter the group.
+
+
+
Returns
A newly created group.
+ +

Definition at line 1417 of file registry.hpp.

+ +
+
+ +

◆ group() [4/4]

+ +
+
+
+template<typename Entity>
+
+template<typename... Owned, typename... Exclude>
+ + + + + +
+ + + + + + + + +
entt::basic_group<Entity, get_t<>, Owned...> entt::basic_registry< Entity >::group (exclude_t< Exclude... >  = {}) const
+ 		+inline
+
+ +

Returns a group for the given components.

+

This kind of objects are created on the fly and share with the registry its internal data structures.
+ Feel free to discard a group after the use. Creating and destroying a group is an incredibly cheap operation because they do not require any type of initialization, but for the first time they are requested.
+ As a rule of thumb, storing a group should never be an option.

+

Groups support exclusion lists and can own types of components. The more types are owned by a group, the faster it is to iterate entities and components.
+ However, groups also affect some features of the registry such as the creation and destruction of components, which will consequently be slightly slower (nothing that can be noticed in most cases).

+
Note
Pools of components that are owned by a group cannot be sorted anymore. The group takes the ownership of the pools and arrange components so as to iterate them as fast as possible.
+
Template Parameters
+ + + + +
OwnedTypes of components owned by the group.
GetTypes of components observed by the group.
ExcludeTypes of components used to filter the group.
+
+
+
Returns
A newly created group.
+ +

Definition at line 1423 of file registry.hpp.

+ +
+
+ +

◆ has()

+ +
+
+
+template<typename Entity>
+
+template<typename... Component>
+ + + + + +
+ + + + + + + + +
bool entt::basic_registry< Entity >::has (const entity_type entity) const
+ 		+inline
+
+ +

Checks if an entity has all the given components.

+
Warning
Attempting to use an invalid entity results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode in case of invalid entity.
+
Template Parameters
+ + +
ComponentComponents for which to perform the check.
+
+
+
Parameters
+ + +
entityA valid entity identifier.
+
+
+
Returns
True if the entity has all the components, false otherwise.
+ +

Definition at line 759 of file registry.hpp.

+ +
+
+ +

◆ loader()

+ +
+
+
+template<typename Entity>
+ + + + + +
+ + + + + + + +
basic_snapshot_loader<Entity> entt::basic_registry< Entity >::loader ()
+ 		+inline
+
+ +

Returns a temporary object to use to load snapshots.

+

A snapshot is either a full or a partial dump of a registry.
+ It can be used to save and restore its internal state or to keep two or more instances of this class in sync, as an example in a client-server architecture.

+
Note
The loader returned by this function requires that the registry be empty. In case it isn't, all the data will be automatically deleted before to return.
+
Returns
A temporary object to use to load snasphosts.
+ +

Definition at line 1560 of file registry.hpp.

+ +
+
+ +

◆ on_construct()

+ +
+
+
+template<typename Entity>
+
+template<typename Component >
+ + + + + +
+ + + + + + + +
auto entt::basic_registry< Entity >::on_construct ()
+ 		+inline
+
+ +

Returns a sink object for the given component.

+

A sink is an opaque object used to connect listeners to components.
+ The sink returned by this function can be used to receive notifications whenever a new instance of the given component is created and assigned to an entity.

+

The function type for a listener is equivalent to:

+
void(registry<Entity> &, Entity, Component &);

Listeners are invoked after the component has been assigned to the entity. The order of invocation of the listeners isn't guaranteed.

+
Note
Empty types aren't explicitly instantiated. Therefore, temporary objects are returned through signals. They can be caught only by copy or with const references.
+
See also
sink
+
Template Parameters
+ + +
ComponentType of component of which to get the sink.
+
+
+
Returns
A temporary sink object.
+ +

Definition at line 950 of file registry.hpp.

+ +
+
+ +

◆ on_destroy()

+ +
+
+
+template<typename Entity>
+
+template<typename Component >
+ + + + + +
+ + + + + + + +
auto entt::basic_registry< Entity >::on_destroy ()
+ 		+inline
+
+ +

Returns a sink object for the given component.

+

A sink is an opaque object used to connect listeners to components.
+ The sink returned by this function can be used to receive notifications whenever an instance of the given component is removed from an entity and thus destroyed.

+

The function type for a listener is equivalent to:

+
void(registry<Entity> &, Entity);

Listeners are invoked before the component has been removed from the entity. The order of invocation of the listeners isn't guaranteed.

+
Note
Empty types aren't explicitly instantiated. Therefore, temporary objects are returned through signals. They can be caught only by copy or with const references.
+
See also
sink
+
Template Parameters
+ + +
ComponentType of component of which to get the sink.
+
+
+
Returns
A temporary sink object.
+ +

Definition at line 1013 of file registry.hpp.

+ +
+
+ +

◆ on_replace()

+ +
+
+
+template<typename Entity>
+
+template<typename Component >
+ + + + + +
+ + + + + + + +
auto entt::basic_registry< Entity >::on_replace ()
+ 		+inline
+
+ +

Returns a sink object for the given component.

+

A sink is an opaque object used to connect listeners to components.
+ The sink returned by this function can be used to receive notifications whenever an instance of the given component is explicitly replaced.

+

The function type for a listener is equivalent to:

+
void(registry<Entity> &, Entity, Component &);

Listeners are invoked before the component has been replaced. The order of invocation of the listeners isn't guaranteed.

+
Note
Empty types aren't explicitly instantiated. Therefore, temporary objects are returned through signals. They can be caught only by copy or with const references.
+
See also
sink
+
Template Parameters
+ + +
ComponentType of component of which to get the sink.
+
+
+
Returns
A temporary sink object.
+ +

Definition at line 981 of file registry.hpp.

+ +
+
+ +

◆ operator=()

+ +
+
+
+template<typename Entity>
+ + + + + +
+ + + + + + + + +
basic_registry& entt::basic_registry< Entity >::operator= (basic_registry< Entity > && )
+ 		+default
+
+ +

Default move assignment operator.

+
Returns
This registry.
+ +
+
+ +

◆ orphan()

+ +
+
+
+template<typename Entity>
+ + + + + +
+ + + + + + + + +
bool entt::basic_registry< Entity >::orphan (const entity_type entity) const
+ 		+inline
+
+ +

Checks if an entity has components assigned.

+
Parameters
+ + +
entityA valid entity identifier.
+
+
+
Returns
True if the entity has no components assigned, false otherwise.
+ +

Definition at line 1212 of file registry.hpp.

+ +
+
+ +

◆ orphans()

+ +
+
+
+template<typename Entity>
+
+template<typename Func >
+ + + + + +
+ + + + + + + + +
void entt::basic_registry< Entity >::orphans (Func func) const
+ 		+inline
+
+ +

Iterates orphans and applies them the given function object.

+

The function object is invoked for each entity that is still in use and has no components assigned.
+ The signature of the function should be equivalent to the following:

+
void(const Entity);

This function can be very slow and should not be used frequently.

+
Template Parameters
+ + +
FuncType of the function object to invoke.
+
+
+
Parameters
+ + +
funcA valid function object.
+
+
+ +

Definition at line 1241 of file registry.hpp.

+ +
+
+ +

◆ owned()

+ +
+
+
+template<typename Entity>
+
+template<typename Component >
+ + + + + +
+ + + + + + + +
bool entt::basic_registry< Entity >::owned () const
+ 		+inline
+
+ +

Checks whether a given component belongs to a group.

+
Template Parameters
+ + +
ComponentType of component in which one is interested.
+
+
+
Returns
True if the component belongs to a group, false otherwise.
+ +

Definition at line 1300 of file registry.hpp.

+ +
+
+ +

◆ raw() [1/2]

+ +
+
+
+template<typename Entity>
+
+template<typename Component >
+ + + + + +
+ + + + + + + +
const Component* entt::basic_registry< Entity >::raw () const
+ 		+inline
+
+ +

Direct access to the list of components of a given pool.

+

The returned pointer is such that range [raw<Component>(), raw<Component>() + size<Component>()] is always a valid range, even if the container is empty.

+

There are no guarantees on the order of the components. Use a view if you want to iterate entities and components in the expected order.

+
Note
Empty components aren't explicitly instantiated. Only one instance of the given type is created. Therefore, this function always returns a pointer to that instance.
+
Template Parameters
+ + +
ComponentType of component in which one is interested.
+
+
+
Returns
A pointer to the array of components of the given type.
+ +

Definition at line 469 of file registry.hpp.

+ +
+
+ +

◆ raw() [2/2]

+ +
+
+
+template<typename Entity>
+
+template<typename Component >
+ + + + + +
+ + + + + + + +
Component* entt::basic_registry< Entity >::raw ()
+ 		+inline
+
+ +

Direct access to the list of components of a given pool.

+

The returned pointer is such that range [raw<Component>(), raw<Component>() + size<Component>()] is always a valid range, even if the container is empty.

+

There are no guarantees on the order of the components. Use a view if you want to iterate entities and components in the expected order.

+
Note
Empty components aren't explicitly instantiated. Only one instance of the given type is created. Therefore, this function always returns a pointer to that instance.
+
Template Parameters
+ + +
ComponentType of component in which one is interested.
+
+
+
Returns
A pointer to the array of components of the given type.
+ +

Definition at line 476 of file registry.hpp.

+ +
+
+ +

◆ remove()

+ +
+
+
+template<typename Entity>
+
+template<typename Component >
+ + + + + +
+ + + + + + + + +
void entt::basic_registry< Entity >::remove (const entity_type entity)
+ 		+inline
+
+ +

Removes the given component from an entity.

+
Warning
Attempting to use an invalid entity or to remove a component from an entity that doesn't own it results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode in case of invalid entity or if the entity doesn't own an instance of the given component.
+
Template Parameters
+ + +
ComponentType of component to remove.
+
+
+
Parameters
+ + +
entityA valid entity identifier.
+
+
+ +

Definition at line 741 of file registry.hpp.

+ +
+
+ +

◆ replace()

+ +
+
+
+template<typename Entity>
+
+template<typename Component , typename... Args>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
decltype(auto) entt::basic_registry< Entity >::replace (const entity_type entity,
Args &&... args 
)
+ 		+inline
+
+ +

Replaces the given component for an entity.

+

A new instance of the given component is created and initialized with the arguments provided (the component must have a proper constructor or be of aggregate type). Then the component is assigned to the given entity.

+
Warning
Attempting to use an invalid entity or to replace a component of an entity that doesn't own it results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode in case of invalid entity or if the entity doesn't own an instance of the given component.
+
Template Parameters
+ + + +
ComponentType of component to replace.
ArgsTypes of arguments to use to construct the component.
+
+
+
Parameters
+ + + +
entityA valid entity identifier.
argsParameters to use to initialize the component.
+
+
+
Returns
A reference to the newly created component.
+ +

Definition at line 888 of file registry.hpp.

+ +
+
+ +

◆ reserve() [1/2]

+ +
+
+
+template<typename Entity>
+
+template<typename Component >
+ + + + + +
+ + + + + + + + +
void entt::basic_registry< Entity >::reserve (const size_type cap)
+ 		+inline
+
+ +

Increases the capacity of the pool for the given component.

+

If the new capacity is greater than the current capacity, new storage is allocated, otherwise the method does nothing.

+
Template Parameters
+ + +
ComponentType of component for which to reserve storage.
+
+
+
Parameters
+ + +
capDesired capacity.
+
+
+ +

Definition at line 385 of file registry.hpp.

+ +
+
+ +

◆ reserve() [2/2]

+ +
+
+
+template<typename Entity>
+ + + + + +
+ + + + + + + + +
void entt::basic_registry< Entity >::reserve (const size_type cap)
+ 		+inline
+
+ +

Increases the capacity of a registry in terms of entities.

+

If the new capacity is greater than the current capacity, new storage is allocated, otherwise the method does nothing.

+
Parameters
+ + +
capDesired capacity.
+
+
+ +

Definition at line 397 of file registry.hpp.

+ +
+
+ +

◆ reset() [1/3]

+ +
+
+
+template<typename Entity>
+
+template<typename Component >
+ + + + + +
+ + + + + + + + +
void entt::basic_registry< Entity >::reset (const entity_type entity)
+ 		+inline
+
+ +

Resets the given component for an entity.

+

If the entity has an instance of the component, this function removes the component from the entity. Otherwise it does nothing.

+
Warning
Attempting to use an invalid entity results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode in case of invalid entity.
+
Template Parameters
+ + +
ComponentType of component to reset.
+
+
+
Parameters
+ + +
entityA valid entity identifier.
+
+
+ +

Definition at line 1126 of file registry.hpp.

+ +
+
+ +

◆ reset() [2/3]

+ +
+
+
+template<typename Entity>
+
+template<typename Component >
+ + + + + +
+ + + + + + + +
void entt::basic_registry< Entity >::reset ()
+ 		+inline
+
+ +

Resets the pool of the given component.

+

For each entity that has an instance of the given component, the component itself is removed and thus destroyed.

+
Template Parameters
+ + +
ComponentType of component whose pool must be reset.
+
+
+ +

Definition at line 1143 of file registry.hpp.

+ +
+
+ +

◆ reset() [3/3]

+ +
+
+
+template<typename Entity>
+ + + + + +
+ + + + + + + +
void entt::basic_registry< Entity >::reset ()
+ 		+inline
+
+ +

Resets a whole registry.

+

Destroys all the entities. After a call to reset, all the entities still in use are recycled with a new version number. In case entity identifers are stored around, the valid member function can be used to know if they are still valid.

+ +

Definition at line 1162 of file registry.hpp.

+ +
+
+ +

◆ runtime_view()

+ +
+
+
+template<typename Entity>
+
+template<typename It >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
entt::basic_runtime_view<Entity> entt::basic_registry< Entity >::runtime_view (It first,
It last 
) const
+ 		+inline
+
+ +

Returns a runtime view for the given components.

+

This kind of objects are created on the fly and share with the registry its internal data structures.
+ Users should throw away the view after use. Fortunately, creating and destroying a runtime view is an incredibly cheap operation because they do not require any type of initialization.
+ As a rule of thumb, storing a view should never be an option.

+

Runtime views are to be used when users want to construct a view from some external inputs and don't know at compile-time what are the required components.
+ This is particularly well suited to plugin systems and mods in general.

+
Template Parameters
+ + +
ItType of forward iterator.
+
+
+
Parameters
+ + + +
firstAn iterator to the first element of the range of components.
lastAn iterator past the last element of the range of components.
+
+
+
Returns
A newly created runtime view.
+ +

Definition at line 1449 of file registry.hpp.

+ +
+
+ +

◆ set()

+ +
+
+
+template<typename Entity>
+
+template<typename Type , typename... Args>
+ + + + + +
+ + + + + + + + +
Type& entt::basic_registry< Entity >::set (Args &&... args)
+ 		+inline
+
+ +

Binds an object to the context of the registry.

+

If the value already exists it is overwritten, otherwise a new instance of the given type is created and initialized with the arguments provided.

+
Template Parameters
+ + + +
TypeType of object to set.
ArgsTypes of arguments to use to construct the object.
+
+
+
Parameters
+ + +
argsParameters to use to initialize the value.
+
+
+
Returns
A reference to the newly created object.
+ +

Definition at line 1603 of file registry.hpp.

+ +
+
+ +

◆ shrink_to_fit()

+ +
+
+
+template<typename Entity>
+
+template<typename Component >
+ + + + + +
+ + + + + + + +
void entt::basic_registry< Entity >::shrink_to_fit ()
+ 		+inline
+
+ +

Requests the removal of unused capacity for a given component.

+
Template Parameters
+ + +
ComponentType of component for which to reclaim unused capacity.
+
+
+ +

Definition at line 426 of file registry.hpp.

+ +
+
+ +

◆ size() [1/2]

+ +
+
+
+template<typename Entity>
+
+template<typename Component >
+ + + + + +
+ + + + + + + +
size_type entt::basic_registry< Entity >::size () const
+ 		+inline
+
+ +

Returns the number of existing components of the given type.

+
Template Parameters
+ + +
ComponentType of component of which to return the size.
+
+
+
Returns
Number of existing components of the given type.
+ +

Definition at line 354 of file registry.hpp.

+ +
+
+ +

◆ size() [2/2]

+ +
+
+
+template<typename Entity>
+ + + + + +
+ + + + + + + +
size_type entt::basic_registry< Entity >::size () const
+ 		+inline
+
+ +

Returns the number of entities created so far.

+
Returns
Number of entities created so far.
+ +

Definition at line 363 of file registry.hpp.

+ +
+
+ +

◆ snapshot()

+ +
+
+
+template<typename Entity>
+ + + + + +
+ + + + + + + +
entt::basic_snapshot<Entity> entt::basic_registry< Entity >::snapshot () const
+ 		+inline
+
+ +

Returns a temporary object to use to create snapshots.

+

A snapshot is either a full or a partial dump of a registry.
+ It can be used to save and restore its internal state or to keep two or more instances of this class in sync, as an example in a client-server architecture.

+
Returns
A temporary object to use to take snasphosts.
+ +

Definition at line 1531 of file registry.hpp.

+ +
+
+ +

◆ sort() [1/2]

+ +
+
+
+template<typename Entity>
+
+template<typename Component , typename Compare , typename Sort = std_sort, typename... Args>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
void entt::basic_registry< Entity >::sort (Compare compare,
Sort algo = Sort{},
Args &&... args 
)
+ 		+inline
+
+ +

Sorts the pool of entities for the given component.

+

The order of the elements in a pool is highly affected by assignments of components to entities and deletions. Components are arranged to maximize the performance during iterations and users should not make any assumption on the order.
+ This function can be used to impose an order to the elements in the pool of the given component. The order is kept valid until a component of the given type is assigned or removed from an entity.

+

The comparison function object must return true if the first element is less than the second one, false otherwise. The signature of the comparison function should be equivalent to one of the following:

+
bool(const Entity, const Entity);
bool(const Component &, const Component &);

Moreover, the comparison function object shall induce a strict weak ordering on the values.

+

The sort function oject must offer a member function template operator() that accepts three arguments:

+
    +
  • An iterator to the first element of the range to sort.
    • +
  • An iterator past the last element of the range to sort.
    • +
  • A comparison function to use to compare the elements.
    • +
+

The comparison funtion object received by the sort function object hasn't necessarily the type of the one passed along with the other parameters to this member function.

+
Warning
Pools of components that are owned by a group cannot be sorted.
+ An assertion will abort the execution at runtime in debug mode in case the pool is owned by a group.
+
Template Parameters
+ + + + + +
ComponentType of components to sort.
CompareType of comparison function object.
SortType of sort function object.
ArgsTypes of arguments to forward to the sort function object.
+
+
+
Parameters
+ + + + +
compareA valid comparison function object.
algoA valid sort function object.
argsArguments to forward to the sort function object, if any.
+
+
+ +

Definition at line 1065 of file registry.hpp.

+ +
+
+ +

◆ sort() [2/2]

+ +
+
+
+template<typename Entity>
+
+template<typename To , typename From >
+ + + + + +
+ + + + + + + +
void entt::basic_registry< Entity >::sort ()
+ 		+inline
+
+ +

Sorts two pools of components in the same way.

+

The order of the elements in a pool is highly affected by assignments of components to entities and deletions. Components are arranged to maximize the performance during iterations and users should not make any assumption on the order.

+

It happens that different pools of components must be sorted the same way because of runtime and/or performance constraints. This function can be used to order a pool of components according to the order between the entities in another pool of components.

+

How it works

+

Being A and B the two sets where B is the master (the one the order of which rules) and A is the slave (the one to sort), after a call to this function an iterator for A will return the entities according to the following rules:

+
    +
  • All the entities in A that are also in B are returned first according to the order they have in B.
    • +
  • All the entities in A that are not in B are returned in no particular order after all the other entities.
    • +
+

Any subsequent change to B won't affect the order in A.

+
Warning
Pools of components that are owned by a group cannot be sorted.
+ An assertion will abort the execution at runtime in debug mode in case the pool is owned by a group.
+
Template Parameters
+ + + +
ToType of components to sort.
FromType of components to use to sort.
+
+
+ +

Definition at line 1106 of file registry.hpp.

+ +
+
+ +

◆ try_ctx() [1/2]

+ +
+
+
+template<typename Entity>
+
+template<typename Type >
+ + + + + +
+ + + + + + + +
const Type* entt::basic_registry< Entity >::try_ctx () const
+ 		+inline
+
+ +

Returns a pointer to an object in the context of the registry.

+
Template Parameters
+ + +
TypeType of object to get.
+
+
+
Returns
A pointer to the object if it exists in the context of the registry, a null pointer otherwise.
+ +

Definition at line 1641 of file registry.hpp.

+ +
+
+ +

◆ try_ctx() [2/2]

+ +
+
+
+template<typename Entity>
+
+template<typename Type >
+ + + + + +
+ + + + + + + +
Type* entt::basic_registry< Entity >::try_ctx ()
+ 		+inline
+
+ +

Returns a pointer to an object in the context of the registry.

+
Template Parameters
+ + +
TypeType of object to get.
+
+
+
Returns
A pointer to the object if it exists in the context of the registry, a null pointer otherwise.
+ +

Definition at line 1651 of file registry.hpp.

+ +
+
+ +

◆ try_get() [1/2]

+ +
+
+
+template<typename Entity>
+
+template<typename... Component>
+ + + + + +
+ + + + + + + + +
auto entt::basic_registry< Entity >::try_get ([[maybe_unused] ] const entity_type entity) const
+ 		+inline
+
+ +

Returns pointers to the given components for an entity.

+
Warning
Attempting to use an invalid entity results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode in case of invalid entity.
+
Template Parameters
+ + +
ComponentTypes of components to get.
+
+
+
Parameters
+ + +
entityA valid entity identifier.
+
+
+
Returns
Pointers to the components owned by the entity.
+ +

Definition at line 846 of file registry.hpp.

+ +
+
+ +

◆ try_get() [2/2]

+ +
+
+
+template<typename Entity>
+
+template<typename... Component>
+ + + + + +
+ + + + + + + + +
auto entt::basic_registry< Entity >::try_get ([[maybe_unused] ] const entity_type entity)
+ 		+inline
+
+ +

Returns pointers to the given components for an entity.

+
Warning
Attempting to use an invalid entity results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode in case of invalid entity.
+
Template Parameters
+ + +
ComponentTypes of components to get.
+
+
+
Parameters
+ + +
entityA valid entity identifier.
+
+
+
Returns
Pointers to the components owned by the entity.
+ +

Definition at line 859 of file registry.hpp.

+ +
+
+ +

◆ type()

+ +
+
+
+template<typename Entity>
+
+template<typename Component >
+ + + + + +
+ + + + + + + +
static component_type entt::basic_registry< Entity >::type ()
+ 		+inlinestatic
+
+ +

Returns the numeric identifier of a component.

+

The given component doesn't need to be necessarily in use.
+ Do not use this functionality to generate numeric identifiers for types at runtime. They aren't guaranteed to be stable between different runs.

+
Template Parameters
+ + +
ComponentType of component to query.
+
+
+
Returns
Runtime numeric identifier of the given type of component.
+ +

Definition at line 344 of file registry.hpp.

+ +
+
+ +

◆ unset()

+ +
+
+
+template<typename Entity>
+
+template<typename Type >
+ + + + + +
+ + + + + + + +
void entt::basic_registry< Entity >::unset ()
+ 		+inline
+
+ +

Unsets a context variable if it exists.

+
Template Parameters
+ + +
TypeType of object to set.
+
+
+ +

Definition at line 1628 of file registry.hpp.

+ +
+
+ +

◆ valid()

+ +
+
+
+template<typename Entity>
+ + + + + +
+ + + + + + + + +
bool entt::basic_registry< Entity >::valid (const entity_type entity) const
+ 		+inline
+
+ +

Checks if an entity identifier refers to a valid entity.

+
Parameters
+ + +
entityAn entity identifier, either valid or not.
+
+
+
Returns
True if the identifier is valid, false otherwise.
+ +

Definition at line 504 of file registry.hpp.

+ +
+
+ +

◆ version()

+ +
+
+
+template<typename Entity>
+ + + + + +
+ + + + + + + + +
static version_type entt::basic_registry< Entity >::version (const entity_type entity)
+ 		+inlinestatic
+
+ +

Returns the version stored along with an entity identifier.

+
Parameters
+ + +
entityAn entity identifier, either valid or not.
+
+
+
Returns
The version stored along with the given entity identifier.
+ +

Definition at line 523 of file registry.hpp.

+ +
+
+ +

◆ view() [1/2]

+ +
+
+
+template<typename Entity>
+
+template<typename... Component>
+ + + + + +
+ + + + + + + +
entt::basic_view<Entity, Component...> entt::basic_registry< Entity >::view ()
+ 		+inline
+
+ +

Returns a view for the given components.

+

This kind of objects are created on the fly and share with the registry its internal data structures.
+ Feel free to discard a view after the use. Creating and destroying a view is an incredibly cheap operation because they do not require any type of initialization.
+ As a rule of thumb, storing a view should never be an option.

+

Views do their best to iterate the smallest set of candidate entities. In particular:

+
    +
  • Single component views are incredibly fast and iterate a packed array of entities, all of which has the given component.
    • +
  • Multi component views look at the number of entities available for each component and pick up a reference to the smallest set of candidates to test for the given components.
    • +
+

Views in no way affect the functionalities of the registry nor those of the underlying pools.

+
Note
Multi component views are pretty fast. However their performance tend to degenerate when the number of components to iterate grows up and the most of the entities have all the given components.
+ To get a performance boost, consider using a group instead.
+
Template Parameters
+ + +
ComponentType of components used to construct the view.
+
+
+
Returns
A newly created view.
+ +

Definition at line 1283 of file registry.hpp.

+ +
+
+ +

◆ view() [2/2]

+ +
+
+
+template<typename Entity>
+
+template<typename... Component>
+ + + + + +
+ + + + + + + +
entt::basic_view<Entity, Component...> entt::basic_registry< Entity >::view () const
+ 		+inline
+
+ +

Returns a view for the given components.

+

This kind of objects are created on the fly and share with the registry its internal data structures.
+ Feel free to discard a view after the use. Creating and destroying a view is an incredibly cheap operation because they do not require any type of initialization.
+ As a rule of thumb, storing a view should never be an option.

+

Views do their best to iterate the smallest set of candidate entities. In particular:

+
    +
  • Single component views are incredibly fast and iterate a packed array of entities, all of which has the given component.
    • +
  • Multi component views look at the number of entities available for each component and pick up a reference to the smallest set of candidates to test for the given components.
    • +
+

Views in no way affect the functionalities of the registry nor those of the underlying pools.

+
Note
Multi component views are pretty fast. However their performance tend to degenerate when the number of components to iterate grows up and the most of the entities have all the given components.
+ To get a performance boost, consider using a group instead.
+
Template Parameters
+ + +
ComponentType of components used to construct the view.
+
+
+
Returns
A newly created view.
+ +

Definition at line 1289 of file registry.hpp.

+ +
+
+
The documentation for this class was generated from the following files: +
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1basic__runtime__view-members.html b/classentt_1_1basic__runtime__view-members.html new file mode 100644 index 000000000..ef1a0ca61 --- /dev/null +++ b/classentt_1_1basic__runtime__view-members.html @@ -0,0 +1,91 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
entt::basic_runtime_view< Entity > Member List
+
+
+ +

This is the complete list of members for entt::basic_runtime_view< Entity >, including all inherited members.

+ + + + + + + + + + + +
basic_registry< Entity > classentt::basic_runtime_view< Entity >friend
begin() const ENTT_NOEXCEPTentt::basic_runtime_view< Entity >inline
contains(const entity_type entt) const ENTT_NOEXCEPTentt::basic_runtime_view< Entity >inline
each(Func func) constentt::basic_runtime_view< Entity >inline
empty() const ENTT_NOEXCEPTentt::basic_runtime_view< Entity >inline
end() const ENTT_NOEXCEPTentt::basic_runtime_view< Entity >inline
entity_type typedefentt::basic_runtime_view< Entity >
iterator_type typedefentt::basic_runtime_view< Entity >
size() const ENTT_NOEXCEPTentt::basic_runtime_view< Entity >inline
size_type typedefentt::basic_runtime_view< Entity >
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1basic__runtime__view.html b/classentt_1_1basic__runtime__view.html new file mode 100644 index 000000000..41d750357 --- /dev/null +++ b/classentt_1_1basic__runtime__view.html @@ -0,0 +1,382 @@ + + + + + + + +EnTT: entt::basic_runtime_view< Entity > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+Classes | +Public Types | +Public Member Functions | +Friends | +List of all members
+
+
entt::basic_runtime_view< Entity > Class Template Reference
+
+
+ +

Runtime view. + More...

+ +

#include <runtime_view.hpp>

+ + + + + + + + + + + +

+Public Types

+using entity_type = typename sparse_set< Entity >::entity_type
 Underlying entity identifier.
 
+using size_type = typename sparse_set< Entity >::size_type
 Unsigned integer type.
 
+using iterator_type = iterator
 Input iterator type.
 
+ + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

size_type size () const ENTT_NOEXCEPT
 Estimates the number of entities that have the given components. More...
 
bool empty () const ENTT_NOEXCEPT
 Checks if the view is definitely empty. More...
 
iterator_type begin () const ENTT_NOEXCEPT
 Returns an iterator to the first entity that has the given components. More...
 
iterator_type end () const ENTT_NOEXCEPT
 Returns an iterator that is past the last entity that has the given components. More...
 
bool contains (const entity_type entt) const ENTT_NOEXCEPT
 Checks if a view contains an entity. More...
 
template<typename Func >
void each (Func func) const
 Iterates entities and applies the given function object to them. More...
 
+ + + + +

+Friends

+class basic_registry< Entity >
 A registry is allowed to create views.
 
+

Detailed Description

+

template<typename Entity>
+class entt::basic_runtime_view< Entity >

+ +

Runtime view.

+

Runtime views iterate over those entities that have at least all the given components in their bags. During initialization, a runtime view looks at the number of entities available for each component and picks up a reference to the smallest set of candidate entities in order to get a performance boost when iterate.
+ Order of elements during iterations are highly dependent on the order of the underlying data structures. See sparse_set and its specializations for more details.

+

Important

+

Iterators aren't invalidated if:

+
    +
  • New instances of the given components are created and assigned to entities.
    • +
  • The entity currently pointed is modified (as an example, if one of the given components is removed from the entity to which the iterator points).
    • +
+

In all the other cases, modifying the pools of the given components in any way invalidates all the iterators and using them results in undefined behavior.

+
Note
Views share references to the underlying data structures of the registry that generated them. Therefore any change to the entities and to the components made by means of the registry are immediately reflected by the views, unless a pool was missing when the view was built (in this case, the view won't have a valid reference and won't be updated accordingly).
+
Warning
Lifetime of a view must overcome the one of the registry that generated it. In any other case, attempting to use a view results in undefined behavior.
+
Template Parameters
+ + +
EntityA valid entity type (see entt_traits for more details).
+
+
+ +

Definition at line 21 of file fwd.hpp.

+

Member Function Documentation

+ +

◆ begin()

+ +
+
+
+template<typename Entity >
+ + + + + +
+ + + + + + + +
iterator_type entt::basic_runtime_view< Entity >::begin () const
+ 		+inline
+
+ +

Returns an iterator to the first entity that has the given components.

+

The returned iterator points to the first entity that has the given components. If the view is empty, the returned iterator will be equal to end().

+
Note
Input iterators stay true to the order imposed to the underlying data structures.
+
Returns
An iterator to the first entity that has the given components.
+ +

Definition at line 198 of file runtime_view.hpp.

+ +
+
+ +

◆ contains()

+ +
+
+
+template<typename Entity >
+ + + + + +
+ + + + + + + + +
bool entt::basic_runtime_view< Entity >::contains (const entity_type entt) const
+ 		+inline
+
+ +

Checks if a view contains an entity.

+
Parameters
+ + +
enttA valid entity identifier.
+
+
+
Returns
True if the view contains the given entity, false otherwise.
+ +

Definition at line 241 of file runtime_view.hpp.

+ +
+
+ +

◆ each()

+ +
+
+
+template<typename Entity >
+
+template<typename Func >
+ + + + + +
+ + + + + + + + +
void entt::basic_runtime_view< Entity >::each (Func func) const
+ 		+inline
+
+ +

Iterates entities and applies the given function object to them.

+

The function object is invoked for each entity. It is provided only with the entity itself. To get the components, users can use the registry with which the view was built.
+ The signature of the function should be equivalent to the following:

+
void(const entity_type);
Template Parameters
+ + +
FuncType of the function object to invoke.
+
+
+
Parameters
+ + +
funcA valid function object.
+
+
+ +

Definition at line 263 of file runtime_view.hpp.

+ +
+
+ +

◆ empty()

+ +
+
+
+template<typename Entity >
+ + + + + +
+ + + + + + + +
bool entt::basic_runtime_view< Entity >::empty () const
+ 		+inline
+
+ +

Checks if the view is definitely empty.

+
Returns
True if the view is definitely empty, false otherwise.
+ +

Definition at line 180 of file runtime_view.hpp.

+ +
+
+ +

◆ end()

+ +
+
+
+template<typename Entity >
+ + + + + +
+ + + + + + + +
iterator_type entt::basic_runtime_view< Entity >::end () const
+ 		+inline
+
+ +

Returns an iterator that is past the last entity that has the given components.

+

The returned iterator points to the entity following the last entity that has the given components. Attempting to dereference the returned iterator results in undefined behavior.

+
Note
Input iterators stay true to the order imposed to the underlying data structures.
+
Returns
An iterator to the entity following the last entity that has the given components.
+ +

Definition at line 225 of file runtime_view.hpp.

+ +
+
+ +

◆ size()

+ +
+
+
+template<typename Entity >
+ + + + + +
+ + + + + + + +
size_type entt::basic_runtime_view< Entity >::size () const
+ 		+inline
+
+ +

Estimates the number of entities that have the given components.

+
Returns
Estimated number of entities that have the given components.
+ +

Definition at line 172 of file runtime_view.hpp.

+ +
+
+
The documentation for this class was generated from the following files: +
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1basic__snapshot-members.html b/classentt_1_1basic__snapshot-members.html new file mode 100644 index 000000000..8fa828a02 --- /dev/null +++ b/classentt_1_1basic__snapshot-members.html @@ -0,0 +1,88 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
entt::basic_snapshot< Entity > Member List
+
+
+ +

This is the complete list of members for entt::basic_snapshot< Entity >, including all inherited members.

+ + + + + + + + +
basic_registry< Entity > classentt::basic_snapshot< Entity >friend
basic_snapshot(basic_snapshot &&)=defaultentt::basic_snapshot< Entity >
component(Archive &archive) constentt::basic_snapshot< Entity >inline
component(Archive &archive, It first, It last) constentt::basic_snapshot< Entity >inline
destroyed(Archive &archive) constentt::basic_snapshot< Entity >inline
entities(Archive &archive) constentt::basic_snapshot< Entity >inline
operator=(basic_snapshot &&)=defaultentt::basic_snapshot< Entity >
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1basic__snapshot.html b/classentt_1_1basic__snapshot.html new file mode 100644 index 000000000..632bbf3c8 --- /dev/null +++ b/classentt_1_1basic__snapshot.html @@ -0,0 +1,385 @@ + + + + + + + +EnTT: entt::basic_snapshot< Entity > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+Public Member Functions | +Friends | +List of all members
+
+
entt::basic_snapshot< Entity > Class Template Reference
+
+
+ +

Utility class to create snapshots from a registry. + More...

+ +

#include <snapshot.hpp>

+ + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+ basic_snapshot (basic_snapshot &&)=default
 Default move constructor.
 
basic_snapshot & operator= (basic_snapshot &&)=default
 Default move assignment operator. More...
 
template<typename Archive >
const basic_snapshot & entities (Archive &archive) const
 Puts aside all the entities that are still in use. More...
 
template<typename Archive >
const basic_snapshot & destroyed (Archive &archive) const
 Puts aside destroyed entities. More...
 
template<typename... Component, typename Archive >
const basic_snapshot & component (Archive &archive) const
 Puts aside the given components. More...
 
template<typename... Component, typename Archive , typename It >
const basic_snapshot & component (Archive &archive, It first, It last) const
 Puts aside the given components for the entities in a range. More...
 
+ + + + +

+Friends

+class basic_registry< Entity >
 A registry is allowed to create snapshots.
 
+

Detailed Description

+

template<typename Entity>
+class entt::basic_snapshot< Entity >

+ +

Utility class to create snapshots from a registry.

+

A snapshot can be either a dump of the entire registry or a narrower selection of components of interest.
+ This type can be used in both cases if provided with a correctly configured output archive.

+
Template Parameters
+ + +
EntityA valid entity type (see entt_traits for more details).
+
+
+ +

Definition at line 37 of file fwd.hpp.

+

Member Function Documentation

+ +

◆ component() [1/2]

+ +
+
+
+template<typename Entity >
+
+template<typename... Component, typename Archive >
+ + + + + +
+ + + + + + + + +
const basic_snapshot& entt::basic_snapshot< Entity >::component (Archive & archive) const
+ 		+inline
+
+ +

Puts aside the given components.

+

Each instance is serialized together with the entity to which it belongs. Entities are serialized along with their versions.

+
Template Parameters
+ + + +
ComponentTypes of components to serialize.
ArchiveType of output archive.
+
+
+
Parameters
+ + +
archiveA valid reference to an output archive.
+
+
+
Returns
An object of this type to continue creating the snapshot.
+ +

Definition at line 136 of file snapshot.hpp.

+ +
+
+ +

◆ component() [2/2]

+ +
+
+
+template<typename Entity >
+
+template<typename... Component, typename Archive , typename It >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
const basic_snapshot& entt::basic_snapshot< Entity >::component (Archive & archive,
It first,
It last 
) const
+ 		+inline
+
+ +

Puts aside the given components for the entities in a range.

+

Each instance is serialized together with the entity to which it belongs. Entities are serialized along with their versions.

+
Template Parameters
+ + + + +
ComponentTypes of components to serialize.
ArchiveType of output archive.
ItType of input iterator.
+
+
+
Parameters
+ + + + +
archiveA valid reference to an output archive.
firstAn iterator to the first element of the range to serialize.
lastAn iterator past the last element of the range to serialize.
+
+
+
Returns
An object of this type to continue creating the snapshot.
+ +

Definition at line 174 of file snapshot.hpp.

+ +
+
+ +

◆ destroyed()

+ +
+
+
+template<typename Entity >
+
+template<typename Archive >
+ + + + + +
+ + + + + + + + +
const basic_snapshot& entt::basic_snapshot< Entity >::destroyed (Archive & archive) const
+ 		+inline
+
+ +

Puts aside destroyed entities.

+

Entities are serialized along with their versions. Entities that are still in use are not taken in consideration by this function.

+
Template Parameters
+ + +
ArchiveType of output archive.
+
+
+
Parameters
+ + +
archiveA valid reference to an output archive.
+
+
+
Returns
An object of this type to continue creating the snapshot.
+ +

Definition at line 107 of file snapshot.hpp.

+ +
+
+ +

◆ entities()

+ +
+
+
+template<typename Entity >
+
+template<typename Archive >
+ + + + + +
+ + + + + + + + +
const basic_snapshot& entt::basic_snapshot< Entity >::entities (Archive & archive) const
+ 		+inline
+
+ +

Puts aside all the entities that are still in use.

+

Entities are serialized along with their versions. Destroyed entities are not taken in consideration by this function.

+
Template Parameters
+ + +
ArchiveType of output archive.
+
+
+
Parameters
+ + +
archiveA valid reference to an output archive.
+
+
+
Returns
An object of this type to continue creating the snapshot.
+ +

Definition at line 90 of file snapshot.hpp.

+ +
+
+ +

◆ operator=()

+ +
+
+
+template<typename Entity >
+ + + + + +
+ + + + + + + + +
basic_snapshot& entt::basic_snapshot< Entity >::operator= (basic_snapshot< Entity > && )
+ 		+default
+
+ +

Default move assignment operator.

+
Returns
This snapshot.
+ +
+
+
The documentation for this class was generated from the following files: +
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1basic__snapshot__loader-members.html b/classentt_1_1basic__snapshot__loader-members.html new file mode 100644 index 000000000..87f44aaba --- /dev/null +++ b/classentt_1_1basic__snapshot__loader-members.html @@ -0,0 +1,88 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
entt::basic_snapshot_loader< Entity > Member List
+
+
+ +

This is the complete list of members for entt::basic_snapshot_loader< Entity >, including all inherited members.

+ + + + + + + + +
basic_registry< Entity > classentt::basic_snapshot_loader< Entity >friend
basic_snapshot_loader(basic_snapshot_loader &&)=defaultentt::basic_snapshot_loader< Entity >
component(Archive &archive) constentt::basic_snapshot_loader< Entity >inline
destroyed(Archive &archive) constentt::basic_snapshot_loader< Entity >inline
entities(Archive &archive) constentt::basic_snapshot_loader< Entity >inline
operator=(basic_snapshot_loader &&)=defaultentt::basic_snapshot_loader< Entity >
orphans() constentt::basic_snapshot_loader< Entity >inline
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1basic__snapshot__loader.html b/classentt_1_1basic__snapshot__loader.html new file mode 100644 index 000000000..8497df55c --- /dev/null +++ b/classentt_1_1basic__snapshot__loader.html @@ -0,0 +1,350 @@ + + + + + + + +EnTT: entt::basic_snapshot_loader< Entity > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+Public Member Functions | +Friends | +List of all members
+
+
entt::basic_snapshot_loader< Entity > Class Template Reference
+
+
+ +

Utility class to restore a snapshot as a whole. + More...

+ +

#include <snapshot.hpp>

+ + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+ basic_snapshot_loader (basic_snapshot_loader &&)=default
 Default move constructor.
 
basic_snapshot_loader & operator= (basic_snapshot_loader &&)=default
 Default move assignment operator. More...
 
template<typename Archive >
const basic_snapshot_loader & entities (Archive &archive) const
 Restores entities that were in use during serialization. More...
 
template<typename Archive >
const basic_snapshot_loader & destroyed (Archive &archive) const
 Restores entities that were destroyed during serialization. More...
 
template<typename... Component, typename Archive >
const basic_snapshot_loader & component (Archive &archive) const
 Restores components and assigns them to the right entities. More...
 
const basic_snapshot_loader & orphans () const
 Destroys those entities that have no components. More...
 
+ + + + +

+Friends

+class basic_registry< Entity >
 A registry is allowed to create snapshot loaders.
 
+

Detailed Description

+

template<typename Entity>
+class entt::basic_snapshot_loader< Entity >

+ +

Utility class to restore a snapshot as a whole.

+

A snapshot loader requires that the destination registry be empty and loads all the data at once while keeping intact the identifiers that the entities originally had.
+ An example of use is the implementation of a save/restore utility.

+
Template Parameters
+ + +
EntityA valid entity type (see entt_traits for more details).
+
+
+ +

Definition at line 41 of file fwd.hpp.

+

Member Function Documentation

+ +

◆ component()

+ +
+
+
+template<typename Entity >
+
+template<typename... Component, typename Archive >
+ + + + + +
+ + + + + + + + +
const basic_snapshot_loader& entt::basic_snapshot_loader< Entity >::component (Archive & archive) const
+ 		+inline
+
+ +

Restores components and assigns them to the right entities.

+

The template parameter list must be exactly the same used during serialization. In the event that the entity to which the component is assigned doesn't exist yet, the loader will take care to create it with the version it originally had.

+
Template Parameters
+ + + +
ComponentTypes of components to restore.
ArchiveType of input archive.
+
+
+
Parameters
+ + +
archiveA valid reference to an input archive.
+
+
+
Returns
A valid loader to continue restoring data.
+ +

Definition at line 300 of file snapshot.hpp.

+ +
+
+ +

◆ destroyed()

+ +
+
+
+template<typename Entity >
+
+template<typename Archive >
+ + + + + +
+ + + + + + + + +
const basic_snapshot_loader& entt::basic_snapshot_loader< Entity >::destroyed (Archive & archive) const
+ 		+inline
+
+ +

Restores entities that were destroyed during serialization.

+

This function restores the entities that were destroyed during serialization and gives them the versions they originally had.

+
Template Parameters
+ + +
ArchiveType of input archive.
+
+
+
Parameters
+ + +
archiveA valid reference to an input archive.
+
+
+
Returns
A valid loader to continue restoring data.
+ +

Definition at line 280 of file snapshot.hpp.

+ +
+
+ +

◆ entities()

+ +
+
+
+template<typename Entity >
+
+template<typename Archive >
+ + + + + +
+ + + + + + + + +
const basic_snapshot_loader& entt::basic_snapshot_loader< Entity >::entities (Archive & archive) const
+ 		+inline
+
+ +

Restores entities that were in use during serialization.

+

This function restores the entities that were in use during serialization and gives them the versions they originally had.

+
Template Parameters
+ + +
ArchiveType of input archive.
+
+
+
Parameters
+ + +
archiveA valid reference to an input archive.
+
+
+
Returns
A valid loader to continue restoring data.
+ +

Definition at line 263 of file snapshot.hpp.

+ +
+
+ +

◆ operator=()

+ +
+
+
+template<typename Entity >
+ + + + + +
+ + + + + + + + +
basic_snapshot_loader& entt::basic_snapshot_loader< Entity >::operator= (basic_snapshot_loader< Entity > && )
+ 		+default
+
+ +

Default move assignment operator.

+
Returns
This loader.
+ +
+
+ +

◆ orphans()

+ +
+
+
+template<typename Entity >
+ + + + + +
+ + + + + + + +
const basic_snapshot_loader& entt::basic_snapshot_loader< Entity >::orphans () const
+ 		+inline
+
+ +

Destroys those entities that have no components.

+

In case all the entities were serialized but only part of the components was saved, it could happen that some of the entities have no components once restored.
+ This functions helps to identify and destroy those entities.

+
Returns
A valid loader to continue restoring data.
+ +

Definition at line 315 of file snapshot.hpp.

+ +
+
+
The documentation for this class was generated from the following files: +
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1basic__storage-members.html b/classentt_1_1basic__storage-members.html new file mode 100644 index 000000000..61d4f2d4e --- /dev/null +++ b/classentt_1_1basic__storage-members.html @@ -0,0 +1,121 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
entt::basic_storage< Entity, Type, typename > Member List
+
+
+ +

This is the complete list of members for entt::basic_storage< Entity, Type, typename >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
batch(It first, It last)entt::basic_storage< Entity, Type, typename >inline
begin() const ENTT_NOEXCEPTentt::basic_storage< Entity, Type, typename >inline
begin() ENTT_NOEXCEPTentt::basic_storage< Entity, Type, typename >inline
capacity() const ENTT_NOEXCEPTentt::sparse_set< Entity >inline
cbegin() const ENTT_NOEXCEPTentt::basic_storage< Entity, Type, typename >inline
cend() const ENTT_NOEXCEPTentt::basic_storage< Entity, Type, typename >inline
const_iterator_type typedefentt::basic_storage< Entity, Type, typename >
construct(const entity_type entt, Args &&... args)entt::basic_storage< Entity, Type, typename >inline
entt::sparse_set::construct(const entity_type entt)entt::sparse_set< Entity >inline
data() const ENTT_NOEXCEPTentt::sparse_set< Entity >inline
destroy(const entity_type entt) overrideentt::basic_storage< Entity, Type, typename >inlinevirtual
empty() const ENTT_NOEXCEPTentt::sparse_set< Entity >inline
end() const ENTT_NOEXCEPTentt::basic_storage< Entity, Type, typename >inline
end() ENTT_NOEXCEPTentt::basic_storage< Entity, Type, typename >inline
entity_type typedefentt::basic_storage< Entity, Type, typename >
extent() const ENTT_NOEXCEPTentt::sparse_set< Entity >inline
find(const entity_type entt) const ENTT_NOEXCEPTentt::sparse_set< Entity >inline
get(const entity_type entt) const ENTT_NOEXCEPTentt::basic_storage< Entity, Type, typename >inline
get(const entity_type entt) ENTT_NOEXCEPTentt::basic_storage< Entity, Type, typename >inline
has(const entity_type entt) const ENTT_NOEXCEPTentt::sparse_set< Entity >inline
iterator_type typedefentt::basic_storage< Entity, Type, typename >
object_type typedefentt::basic_storage< Entity, Type, typename >
operator=(const sparse_set &other)entt::sparse_set< Entity >inline
operator=(sparse_set &&)=defaultentt::sparse_set< Entity >
raw() const ENTT_NOEXCEPTentt::basic_storage< Entity, Type, typename >inline
raw() ENTT_NOEXCEPTentt::basic_storage< Entity, Type, typename >inline
reserve(const size_type cap) overrideentt::basic_storage< Entity, Type, typename >inlinevirtual
reset() overrideentt::basic_storage< Entity, Type, typename >inlinevirtual
respect(const sparse_set< Entity > &other) ENTT_NOEXCEPT overrideentt::basic_storage< Entity, Type, typename >inlinevirtual
shrink_to_fit() overrideentt::basic_storage< Entity, Type, typename >inlinevirtual
size() const ENTT_NOEXCEPTentt::sparse_set< Entity >inline
size_type typedefentt::basic_storage< Entity, Type, typename >
sort(Compare compare, Sort algo=Sort{}, Args &&... args)entt::basic_storage< Entity, Type, typename >inline
sparse_set()=defaultentt::sparse_set< Entity >
sparse_set(const sparse_set &other)entt::sparse_set< Entity >inline
sparse_set(sparse_set &&)=defaultentt::sparse_set< Entity >
swap(const size_type lhs, const size_type rhs) ENTT_NOEXCEPTentt::sparse_set< Entity >inline
try_get(const entity_type entt) const ENTT_NOEXCEPTentt::basic_storage< Entity, Type, typename >inline
try_get(const entity_type entt) ENTT_NOEXCEPTentt::basic_storage< Entity, Type, typename >inline
~sparse_set() ENTT_NOEXCEPT=defaultentt::sparse_set< Entity >virtual
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1basic__storage.html b/classentt_1_1basic__storage.html new file mode 100644 index 000000000..5845a6f00 --- /dev/null +++ b/classentt_1_1basic__storage.html @@ -0,0 +1,1054 @@ + + + + + + + +EnTT: entt::basic_storage< Entity, Type, typename > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+Classes | +Public Types | +Public Member Functions | +List of all members
+
+
entt::basic_storage< Entity, Type, typename > Class Template Reference
+
+
+ +

Basic storage implementation. + More...

+ +

#include <storage.hpp>

+
+Inheritance diagram for entt::basic_storage< Entity, Type, typename >:
+
+
Inheritance graph
+ + + + +
[legend]
+
+Collaboration diagram for entt::basic_storage< Entity, Type, typename >:
+
+
Collaboration graph
+ + + +
[legend]
+ + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

+using object_type = Type
 Type of the objects associated with the entities.
 
+using entity_type = typename underlying_type::entity_type
 Underlying entity identifier.
 
+using size_type = typename underlying_type::size_type
 Unsigned integer type.
 
+using iterator_type = iterator< false >
 Random access iterator type.
 
+using const_iterator_type = iterator< true >
 Constant random access iterator type.
 
- Public Types inherited from entt::sparse_set< Entity >
+using entity_type = Entity
 Underlying entity identifier.
 
+using size_type = std::size_t
 Unsigned integer type.
 
+using iterator_type = iterator
 Random access iterator type.
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

void reserve (const size_type cap) override
 Increases the capacity of a storage. More...
 
+void shrink_to_fit () override
 Requests the removal of unused capacity.
 
const object_type * raw () const ENTT_NOEXCEPT
 Direct access to the array of objects. More...
 
object_type * raw () ENTT_NOEXCEPT
 Direct access to the array of objects. More...
 
const_iterator_type cbegin () const ENTT_NOEXCEPT
 Returns an iterator to the beginning. More...
 
const_iterator_type begin () const ENTT_NOEXCEPT
 Returns an iterator to the beginning. More...
 
iterator_type begin () ENTT_NOEXCEPT
 Returns an iterator to the beginning. More...
 
const_iterator_type cend () const ENTT_NOEXCEPT
 Returns an iterator to the end. More...
 
const_iterator_type end () const ENTT_NOEXCEPT
 Returns an iterator to the end. More...
 
iterator_type end () ENTT_NOEXCEPT
 Returns an iterator to the end. More...
 
const object_type & get (const entity_type entt) const ENTT_NOEXCEPT
 Returns the object associated with an entity. More...
 
object_type & get (const entity_type entt) ENTT_NOEXCEPT
 Returns the object associated with an entity. More...
 
const object_type * try_get (const entity_type entt) const ENTT_NOEXCEPT
 Returns a pointer to the object associated with an entity, if any. More...
 
object_type * try_get (const entity_type entt) ENTT_NOEXCEPT
 Returns a pointer to the object associated with an entity, if any. More...
 
template<typename... Args>
object_type & construct (const entity_type entt, Args &&... args)
 Assigns an entity to a storage and constructs its object. More...
 
template<typename It >
object_type * batch (It first, It last)
 Assigns one or more entities to a storage and constructs their objects. More...
 
void destroy (const entity_type entt) override
 Removes an entity from a storage and destroys its object. More...
 
template<typename Compare , typename Sort = std_sort, typename... Args>
void sort (Compare compare, Sort algo=Sort{}, Args &&... args)
 Sort instances according to the given comparison function. More...
 
void respect (const sparse_set< Entity > &other) ENTT_NOEXCEPT override
 Sort instances according to the order of the entities in another sparse set. More...
 
+void reset () override
 Resets a storage.
 
- Public Member Functions inherited from entt::sparse_set< Entity >
+ sparse_set ()=default
 Default constructor.
 
 sparse_set (const sparse_set &other)
 Copy constructor. More...
 
+ sparse_set (sparse_set &&)=default
 Default move constructor.
 
+virtual ~sparse_set () ENTT_NOEXCEPT=default
 Default destructor.
 
sparse_set & operator= (const sparse_set &other)
 Copy assignment operator. More...
 
sparse_set & operator= (sparse_set &&)=default
 Default move assignment operator. More...
 
size_type capacity () const ENTT_NOEXCEPT
 Returns the number of elements that a sparse set has currently allocated space for. More...
 
size_type extent () const ENTT_NOEXCEPT
 Returns the extent of a sparse set. More...
 
size_type size () const ENTT_NOEXCEPT
 Returns the number of elements in a sparse set. More...
 
bool empty () const ENTT_NOEXCEPT
 Checks whether a sparse set is empty. More...
 
const entity_type * data () const ENTT_NOEXCEPT
 Direct access to the internal packed array. More...
 
iterator_type begin () const ENTT_NOEXCEPT
 Returns an iterator to the beginning. More...
 
iterator_type end () const ENTT_NOEXCEPT
 Returns an iterator to the end. More...
 
iterator_type find (const entity_type entt) const ENTT_NOEXCEPT
 Finds an entity. More...
 
bool has (const entity_type entt) const ENTT_NOEXCEPT
 Checks if a sparse set contains an entity. More...
 
size_type get (const entity_type entt) const ENTT_NOEXCEPT
 Returns the position of an entity in a sparse set. More...
 
void construct (const entity_type entt)
 Assigns an entity to a sparse set. More...
 
template<typename It >
void batch (It first, It last)
 Assigns one or more entities to a sparse set. More...
 
void swap (const size_type lhs, const size_type rhs) ENTT_NOEXCEPT
 Swaps the position of two entities in the internal packed array. More...
 
+

Detailed Description

+

template<typename Entity, typename Type, typename = std::void_t<>>
+class entt::basic_storage< Entity, Type, typename >

+ +

Basic storage implementation.

+

This class is a refinement of a sparse set that associates an object to an entity. The main purpose of this class is to extend sparse sets to store components in a registry. It guarantees fast access both to the elements and to the entities.

+
Note
Entities and objects have the same order. It's guaranteed both in case of raw access (either to entities or objects) and when using input iterators.
+
+Internal data structures arrange elements to maximize performance. Because of that, there are no guarantees that elements have the expected order when iterate directly the internal packed array (see raw and size member functions for that). Use begin and end instead.
+
Warning
Empty types aren't explicitly instantiated. Temporary objects are returned in place of the instances of the components and raw access isn't available for them.
+
See also
sparse_set<Entity>
+
Template Parameters
+ + + +
EntityA valid entity type (see entt_traits for more details).
TypeType of objects assigned to the entities.
+
+
+ +

Definition at line 50 of file storage.hpp.

+

Member Function Documentation

+ +

◆ batch()

+ +
+
+
+template<typename Entity, typename Type, typename = std::void_t<>>
+
+template<typename It >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
object_type* entt::basic_storage< Entity, Type, typename >::batch (It first,
It last 
)
+ 		+inline
+
+ +

Assigns one or more entities to a storage and constructs their objects.

+

The object type must be at least default constructible.

+
Warning
Attempting to assign an entity that already belongs to the storage results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode if the storage already contains the given entity.
+
Template Parameters
+ + +
ItType of forward iterator.
+
+
+
Parameters
+ + + +
firstAn iterator to the first element of the range of entities.
lastAn iterator past the last element of the range of entities.
+
+
+
Returns
A pointer to the array of instances just created and sorted the same of the entities.
+ +

Definition at line 352 of file storage.hpp.

+ +
+
+ +

◆ begin() [1/2]

+ +
+
+
+template<typename Entity, typename Type, typename = std::void_t<>>
+ + + + + +
+ + + + + + + +
const_iterator_type entt::basic_storage< Entity, Type, typename >::begin () const
+ 		+inline
+
+ +

Returns an iterator to the beginning.

+

The returned iterator points to the first instance of the given type. If the storage is empty, the returned iterator will be equal to end().

+
Note
Input iterators stay true to the order imposed by a call to either sort or respect.
+
Returns
An iterator to the first instance of the given type.
+ +

Definition at line 229 of file storage.hpp.

+ +
+
+ +

◆ begin() [2/2]

+ +
+
+
+template<typename Entity, typename Type, typename = std::void_t<>>
+ + + + + +
+ + + + + + + +
iterator_type entt::basic_storage< Entity, Type, typename >::begin ()
+ 		+inline
+
+ +

Returns an iterator to the beginning.

+

The returned iterator points to the first instance of the given type. If the storage is empty, the returned iterator will be equal to end().

+
Note
Input iterators stay true to the order imposed by a call to either sort or respect.
+
Returns
An iterator to the first instance of the given type.
+ +

Definition at line 234 of file storage.hpp.

+ +
+
+ +

◆ cbegin()

+ +
+
+
+template<typename Entity, typename Type, typename = std::void_t<>>
+ + + + + +
+ + + + + + + +
const_iterator_type entt::basic_storage< Entity, Type, typename >::cbegin () const
+ 		+inline
+
+ +

Returns an iterator to the beginning.

+

The returned iterator points to the first instance of the given type. If the storage is empty, the returned iterator will be equal to end().

+
Note
Input iterators stay true to the order imposed by a call to either sort or respect.
+
Returns
An iterator to the first instance of the given type.
+ +

Definition at line 223 of file storage.hpp.

+ +
+
+ +

◆ cend()

+ +
+
+
+template<typename Entity, typename Type, typename = std::void_t<>>
+ + + + + +
+ + + + + + + +
const_iterator_type entt::basic_storage< Entity, Type, typename >::cend () const
+ 		+inline
+
+ +

Returns an iterator to the end.

+

The returned iterator points to the element following the last instance of the given type. Attempting to dereference the returned iterator results in undefined behavior.

+
Note
Input iterators stay true to the order imposed by a call to either sort or respect.
+
Returns
An iterator to the element following the last instance of the given type.
+ +

Definition at line 253 of file storage.hpp.

+ +
+
+ +

◆ construct()

+ +
+
+
+template<typename Entity, typename Type, typename = std::void_t<>>
+
+template<typename... Args>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
object_type& entt::basic_storage< Entity, Type, typename >::construct (const entity_type entt,
Args &&... args 
)
+ 		+inline
+
+ +

Assigns an entity to a storage and constructs its object.

+

This version accept both types that can be constructed in place directly and types like aggregates that do not work well with a placement new as performed usually under the hood during an emplace back.

+
Warning
Attempting to use an entity that already belongs to the storage results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode if the storage already contains the given entity.
+
Template Parameters
+ + +
ArgsTypes of arguments to use to construct the object.
+
+
+
Parameters
+ + + +
enttA valid entity identifier.
argsParameters to use to construct an object for the entity.
+
+
+
Returns
The object associated with the entity.
+ +

Definition at line 321 of file storage.hpp.

+ +
+
+ +

◆ destroy()

+ +
+
+
+template<typename Entity, typename Type, typename = std::void_t<>>
+ + + + + +
+ + + + + + + + +
void entt::basic_storage< Entity, Type, typename >::destroy (const entity_type entt)
+ 		+inlineoverridevirtual
+
+ +

Removes an entity from a storage and destroys its object.

+
Warning
Attempting to use an entity that doesn't belong to the storage results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode if the storage doesn't contain the given entity.
+
Parameters
+ + +
enttA valid entity identifier.
+
+
+ +

Reimplemented from entt::sparse_set< Entity >.

+ +

Definition at line 372 of file storage.hpp.

+ +
+
+ +

◆ end() [1/2]

+ +
+
+
+template<typename Entity, typename Type, typename = std::void_t<>>
+ + + + + +
+ + + + + + + +
const_iterator_type entt::basic_storage< Entity, Type, typename >::end () const
+ 		+inline
+
+ +

Returns an iterator to the end.

+

The returned iterator points to the element following the last instance of the given type. Attempting to dereference the returned iterator results in undefined behavior.

+
Note
Input iterators stay true to the order imposed by a call to either sort or respect.
+
Returns
An iterator to the element following the last instance of the given type.
+ +

Definition at line 258 of file storage.hpp.

+ +
+
+ +

◆ end() [2/2]

+ +
+
+
+template<typename Entity, typename Type, typename = std::void_t<>>
+ + + + + +
+ + + + + + + +
iterator_type entt::basic_storage< Entity, Type, typename >::end ()
+ 		+inline
+
+ +

Returns an iterator to the end.

+

The returned iterator points to the element following the last instance of the given type. Attempting to dereference the returned iterator results in undefined behavior.

+
Note
Input iterators stay true to the order imposed by a call to either sort or respect.
+
Returns
An iterator to the element following the last instance of the given type.
+ +

Definition at line 263 of file storage.hpp.

+ +
+
+ +

◆ get() [1/2]

+ +
+
+
+template<typename Entity, typename Type, typename = std::void_t<>>
+ + + + + +
+ + + + + + + + +
const object_type& entt::basic_storage< Entity, Type, typename >::get (const entity_type entt) const
+ 		+inline
+
+ +

Returns the object associated with an entity.

+
Warning
Attempting to use an entity that doesn't belong to the storage results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode if the storage doesn't contain the given entity.
+
Parameters
+ + +
enttA valid entity identifier.
+
+
+
Returns
The object associated with the entity.
+ +

Definition at line 279 of file storage.hpp.

+ +
+
+ +

◆ get() [2/2]

+ +
+
+
+template<typename Entity, typename Type, typename = std::void_t<>>
+ + + + + +
+ + + + + + + + +
object_type& entt::basic_storage< Entity, Type, typename >::get (const entity_type entt)
+ 		+inline
+
+ +

Returns the object associated with an entity.

+
Warning
Attempting to use an entity that doesn't belong to the storage results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode if the storage doesn't contain the given entity.
+
Parameters
+ + +
enttA valid entity identifier.
+
+
+
Returns
The object associated with the entity.
+ +

Definition at line 284 of file storage.hpp.

+ +
+
+ +

◆ raw() [1/2]

+ +
+
+
+template<typename Entity, typename Type, typename = std::void_t<>>
+ + + + + +
+ + + + + + + +
const object_type* entt::basic_storage< Entity, Type, typename >::raw () const
+ 		+inline
+
+ +

Direct access to the array of objects.

+

The returned pointer is such that range [raw(), raw() + size()] is always a valid range, even if the container is empty.

+
Note
There are no guarantees on the order, even though either sort or respect has been previously invoked. Internal data structures arrange elements to maximize performance. Accessing them directly gives a performance boost but less guarantees. Use begin and end if you want to iterate the storage in the expected order.
+
Returns
A pointer to the array of objects.
+ +

Definition at line 202 of file storage.hpp.

+ +
+
+ +

◆ raw() [2/2]

+ +
+
+
+template<typename Entity, typename Type, typename = std::void_t<>>
+ + + + + +
+ + + + + + + +
object_type* entt::basic_storage< Entity, Type, typename >::raw ()
+ 		+inline
+
+ +

Direct access to the array of objects.

+

The returned pointer is such that range [raw(), raw() + size()] is always a valid range, even if the container is empty.

+
Note
There are no guarantees on the order, even though either sort or respect has been previously invoked. Internal data structures arrange elements to maximize performance. Accessing them directly gives a performance boost but less guarantees. Use begin and end if you want to iterate the storage in the expected order.
+
Returns
A pointer to the array of objects.
+ +

Definition at line 207 of file storage.hpp.

+ +
+
+ +

◆ reserve()

+ +
+
+
+template<typename Entity, typename Type, typename = std::void_t<>>
+ + + + + +
+ + + + + + + + +
void entt::basic_storage< Entity, Type, typename >::reserve (const size_type cap)
+ 		+inlineoverridevirtual
+
+ +

Increases the capacity of a storage.

+

If the new capacity is greater than the current capacity, new storage is allocated, otherwise the method does nothing.

+
Parameters
+ + +
capDesired capacity.
+
+
+ +

Reimplemented from entt::sparse_set< Entity >.

+ +

Definition at line 176 of file storage.hpp.

+ +
+
+ +

◆ respect()

+ +
+
+
+template<typename Entity, typename Type, typename = std::void_t<>>
+ + + + + +
+ + + + + + + + +
void entt::basic_storage< Entity, Type, typename >::respect (const sparse_set< Entity > & other)
+ 		+inlineoverridevirtual
+
+ +

Sort instances according to the order of the entities in another sparse set.

+

Entities that are part of both the storage are ordered internally according to the order they have in other. All the other entities goes to the end of the list and there are no guarantess on their order. Instances are sorted according to the entities to which they belong.
+ In other terms, this function can be used to impose the same order on two sets by using one of them as a master and the other one as a slave.

+

Iterating the storage with a couple of iterators returns elements in the expected order after a call to respect. See begin and end for more details.

+
Note
Attempting to iterate elements using a raw pointer returned by a call to either data or raw gives no guarantees on the order, even though respect has been invoked.
+
Parameters
+ + +
otherThe sparse sets that imposes the order of the entities.
+
+
+ +

Reimplemented from entt::sparse_set< Entity >.

+ +

Definition at line 475 of file storage.hpp.

+ +
+
+ +

◆ sort()

+ +
+
+
+template<typename Entity, typename Type, typename = std::void_t<>>
+
+template<typename Compare , typename Sort = std_sort, typename... Args>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
void entt::basic_storage< Entity, Type, typename >::sort (Compare compare,
Sort algo = Sort{},
Args &&... args 
)
+ 		+inline
+
+ +

Sort instances according to the given comparison function.

+

Sort the elements so that iterating the storage with a couple of iterators returns them in the expected order. See begin and end for more details.

+

The comparison function object must return true if the first element is less than the second one, false otherwise. The signature of the comparison function should be equivalent to one of the following:

+
bool(const Entity, const Entity);
bool(const Type &, const Type &);

Moreover, the comparison function object shall induce a strict weak ordering on the values.

+

The sort function oject must offer a member function template operator() that accepts three arguments:

+
    +
  • An iterator to the first element of the range to sort.
    • +
  • An iterator past the last element of the range to sort.
    • +
  • A comparison function to use to compare the elements.
    • +
+

The comparison function object received by the sort function object hasn't necessarily the type of the one passed along with the other parameters to this member function.

+
Note
Attempting to iterate elements using a raw pointer returned by a call to either data or raw gives no guarantees on the order, even though sort has been invoked.
+
Template Parameters
+ + + + +
CompareType of comparison function object.
SortType of sort function object.
ArgsTypes of arguments to forward to the sort function object.
+
+
+
Parameters
+ + + + +
compareA valid comparison function object.
algoA valid sort function object.
argsArguments to forward to the sort function object, if any.
+
+
+ +

Definition at line 421 of file storage.hpp.

+ +
+
+ +

◆ try_get() [1/2]

+ +
+
+
+template<typename Entity, typename Type, typename = std::void_t<>>
+ + + + + +
+ + + + + + + + +
const object_type* entt::basic_storage< Entity, Type, typename >::try_get (const entity_type entt) const
+ 		+inline
+
+ +

Returns a pointer to the object associated with an entity, if any.

+
Parameters
+ + +
enttA valid entity identifier.
+
+
+
Returns
The object associated with the entity, if any.
+ +

Definition at line 293 of file storage.hpp.

+ +
+
+ +

◆ try_get() [2/2]

+ +
+
+
+template<typename Entity, typename Type, typename = std::void_t<>>
+ + + + + +
+ + + + + + + + +
object_type* entt::basic_storage< Entity, Type, typename >::try_get (const entity_type entt)
+ 		+inline
+
+ +

Returns a pointer to the object associated with an entity, if any.

+
Parameters
+ + +
enttA valid entity identifier.
+
+
+
Returns
The object associated with the entity, if any.
+ +

Definition at line 298 of file storage.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty_03c43bf21b9ff29af7916eca6f32bd45.map b/classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty_03c43bf21b9ff29af7916eca6f32bd45.map new file mode 100644 index 000000000..7e52dd078 --- /dev/null +++ b/classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty_03c43bf21b9ff29af7916eca6f32bd45.map @@ -0,0 +1,3 @@ + + + diff --git a/classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty_03c43bf21b9ff29af7916eca6f32bd45.md5 b/classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty_03c43bf21b9ff29af7916eca6f32bd45.md5 new file mode 100644 index 000000000..c4e0e8ef9 --- /dev/null +++ b/classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty_03c43bf21b9ff29af7916eca6f32bd45.md5 @@ -0,0 +1 @@ +6cc3c20d351d56269782af04b309a742 \ No newline at end of file diff --git a/classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty_03c43bf21b9ff29af7916eca6f32bd45.png b/classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty_03c43bf21b9ff29af7916eca6f32bd45.png new file mode 100644 index 000000000..273438184 Binary files /dev/null and b/classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty_03c43bf21b9ff29af7916eca6f32bd45.png differ diff --git a/classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty_55389e5d919856c74679502c484f479d.html b/classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty_55389e5d919856c74679502c484f479d.html new file mode 100644 index 000000000..47dcf65a6 --- /dev/null +++ b/classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty_55389e5d919856c74679502c484f479d.html @@ -0,0 +1,112 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
entt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > > Member List
+
+
+ +

This is the complete list of members for entt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
batch(It first, It last)entt::sparse_set< Entity >inline
begin() const ENTT_NOEXCEPTentt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >inline
capacity() const ENTT_NOEXCEPTentt::sparse_set< Entity >inline
cbegin() const ENTT_NOEXCEPTentt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >inline
cend() const ENTT_NOEXCEPTentt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >inline
construct(const entity_type entt)entt::sparse_set< Entity >inline
data() const ENTT_NOEXCEPTentt::sparse_set< Entity >inline
destroy(const entity_type entt)entt::sparse_set< Entity >inlinevirtual
empty() const ENTT_NOEXCEPTentt::sparse_set< Entity >inline
end() const ENTT_NOEXCEPTentt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >inline
entity_type typedefentt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >
extent() const ENTT_NOEXCEPTentt::sparse_set< Entity >inline
find(const entity_type entt) const ENTT_NOEXCEPTentt::sparse_set< Entity >inline
get([[maybe_unused]] const entity_type entt) const ENTT_NOEXCEPTentt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >inline
entt::sparse_set::get(const entity_type entt) const ENTT_NOEXCEPTentt::sparse_set< Entity >inline
has(const entity_type entt) const ENTT_NOEXCEPTentt::sparse_set< Entity >inline
iterator_type typedefentt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >
object_type typedefentt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >
operator=(const sparse_set &other)entt::sparse_set< Entity >inline
operator=(sparse_set &&)=defaultentt::sparse_set< Entity >
reserve(const size_type cap)entt::sparse_set< Entity >inlinevirtual
reset()entt::sparse_set< Entity >inlinevirtual
respect(const sparse_set &other) ENTT_NOEXCEPTentt::sparse_set< Entity >inlinevirtual
shrink_to_fit()entt::sparse_set< Entity >inlinevirtual
size() const ENTT_NOEXCEPTentt::sparse_set< Entity >inline
size_type typedefentt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >
sparse_set()=defaultentt::sparse_set< Entity >
sparse_set(const sparse_set &other)entt::sparse_set< Entity >inline
sparse_set(sparse_set &&)=defaultentt::sparse_set< Entity >
swap(const size_type lhs, const size_type rhs) ENTT_NOEXCEPTentt::sparse_set< Entity >inline
~sparse_set() ENTT_NOEXCEPT=defaultentt::sparse_set< Entity >virtual
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty__v_3_01Type_01_4_01_4_01_4.html b/classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty__v_3_01Type_01_4_01_4_01_4.html new file mode 100644 index 000000000..83fd961a2 --- /dev/null +++ b/classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty__v_3_01Type_01_4_01_4_01_4.html @@ -0,0 +1,436 @@ + + + + + + + +EnTT: entt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+Classes | +Public Types | +Public Member Functions | +List of all members
+
+
entt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > > Class Template Reference
+
+
+ +

Basic storage implementation. + More...

+ +

#include <storage.hpp>

+
+Inheritance diagram for entt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >:
+
+
Inheritance graph
+ + + +
[legend]
+
+Collaboration diagram for entt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >:
+
+
Collaboration graph
+ + + +
[legend]
+ + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

+using object_type = Type
 Type of the objects associated with the entities.
 
+using entity_type = typename underlying_type::entity_type
 Underlying entity identifier.
 
+using size_type = typename underlying_type::size_type
 Unsigned integer type.
 
+using iterator_type = iterator
 Random access iterator type.
 
- Public Types inherited from entt::sparse_set< Entity >
+using entity_type = Entity
 Underlying entity identifier.
 
+using size_type = std::size_t
 Unsigned integer type.
 
+using iterator_type = iterator
 Random access iterator type.
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

iterator_type cbegin () const ENTT_NOEXCEPT
 Returns an iterator to the beginning. More...
 
iterator_type begin () const ENTT_NOEXCEPT
 Returns an iterator to the beginning. More...
 
iterator_type cend () const ENTT_NOEXCEPT
 Returns an iterator to the end. More...
 
iterator_type end () const ENTT_NOEXCEPT
 Returns an iterator to the end. More...
 
object_type get ([[maybe_unused]] const entity_type entt) const ENTT_NOEXCEPT
 Returns the object associated with an entity. More...
 
- Public Member Functions inherited from entt::sparse_set< Entity >
+ sparse_set ()=default
 Default constructor.
 
 sparse_set (const sparse_set &other)
 Copy constructor. More...
 
+ sparse_set (sparse_set &&)=default
 Default move constructor.
 
+virtual ~sparse_set () ENTT_NOEXCEPT=default
 Default destructor.
 
sparse_set & operator= (const sparse_set &other)
 Copy assignment operator. More...
 
sparse_set & operator= (sparse_set &&)=default
 Default move assignment operator. More...
 
virtual void reserve (const size_type cap)
 Increases the capacity of a sparse set. More...
 
size_type capacity () const ENTT_NOEXCEPT
 Returns the number of elements that a sparse set has currently allocated space for. More...
 
+virtual void shrink_to_fit ()
 Requests the removal of unused capacity.
 
size_type extent () const ENTT_NOEXCEPT
 Returns the extent of a sparse set. More...
 
size_type size () const ENTT_NOEXCEPT
 Returns the number of elements in a sparse set. More...
 
bool empty () const ENTT_NOEXCEPT
 Checks whether a sparse set is empty. More...
 
const entity_type * data () const ENTT_NOEXCEPT
 Direct access to the internal packed array. More...
 
iterator_type begin () const ENTT_NOEXCEPT
 Returns an iterator to the beginning. More...
 
iterator_type end () const ENTT_NOEXCEPT
 Returns an iterator to the end. More...
 
iterator_type find (const entity_type entt) const ENTT_NOEXCEPT
 Finds an entity. More...
 
bool has (const entity_type entt) const ENTT_NOEXCEPT
 Checks if a sparse set contains an entity. More...
 
size_type get (const entity_type entt) const ENTT_NOEXCEPT
 Returns the position of an entity in a sparse set. More...
 
void construct (const entity_type entt)
 Assigns an entity to a sparse set. More...
 
template<typename It >
void batch (It first, It last)
 Assigns one or more entities to a sparse set. More...
 
virtual void destroy (const entity_type entt)
 Removes an entity from a sparse set. More...
 
void swap (const size_type lhs, const size_type rhs) ENTT_NOEXCEPT
 Swaps the position of two entities in the internal packed array. More...
 
virtual void respect (const sparse_set &other) ENTT_NOEXCEPT
 Sort entities according to their order in another sparse set. More...
 
+virtual void reset ()
 Resets a sparse set.
 
+

Detailed Description

+

template<typename Entity, typename Type>
+class entt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >

+ +

Basic storage implementation.

+

This class is a refinement of a sparse set that associates an object to an entity. The main purpose of this class is to extend sparse sets to store components in a registry. It guarantees fast access both to the elements and to the entities.

+
Note
Entities and objects have the same order. It's guaranteed both in case of raw access (either to entities or objects) and when using input iterators.
+
+Internal data structures arrange elements to maximize performance. Because of that, there are no guarantees that elements have the expected order when iterate directly the internal packed array (see raw and size member functions for that). Use begin and end instead.
+
Warning
Empty types aren't explicitly instantiated. Temporary objects are returned in place of the instances of the components and raw access isn't available for them.
+
See also
sparse_set<Entity>
+
Template Parameters
+ + + +
EntityA valid entity type (see entt_traits for more details).
TypeType of objects assigned to the entities.
+
+
+ +

Definition at line 512 of file storage.hpp.

+

Member Function Documentation

+ +

◆ begin()

+ +
+
+
+template<typename Entity , typename Type >
+ + + + + +
+ + + + + + + +
iterator_type entt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >::begin () const
+ 		+inline
+
+ +

Returns an iterator to the beginning.

+

The returned iterator points to the first instance of the given type. If the storage is empty, the returned iterator will be equal to end().

+
Note
Input iterators stay true to the order imposed by a call to either sort or respect.
+
Returns
An iterator to the first instance of the given type.
+ +

Definition at line 641 of file storage.hpp.

+ +
+
+ +

◆ cbegin()

+ +
+
+
+template<typename Entity , typename Type >
+ + + + + +
+ + + + + + + +
iterator_type entt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >::cbegin () const
+ 		+inline
+
+ +

Returns an iterator to the beginning.

+

The returned iterator points to the first instance of the given type. If the storage is empty, the returned iterator will be equal to end().

+
Note
Input iterators stay true to the order imposed by a call to either sort or respect.
+
Returns
An iterator to the first instance of the given type.
+ +

Definition at line 635 of file storage.hpp.

+ +
+
+ +

◆ cend()

+ +
+
+
+template<typename Entity , typename Type >
+ + + + + +
+ + + + + + + +
iterator_type entt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >::cend () const
+ 		+inline
+
+ +

Returns an iterator to the end.

+

The returned iterator points to the element following the last instance of the given type. Attempting to dereference the returned iterator results in undefined behavior.

+
Note
Input iterators stay true to the order imposed by a call to either sort or respect.
+
Returns
An iterator to the element following the last instance of the given type.
+ +

Definition at line 659 of file storage.hpp.

+ +
+
+ +

◆ end()

+ +
+
+
+template<typename Entity , typename Type >
+ + + + + +
+ + + + + + + +
iterator_type entt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >::end () const
+ 		+inline
+
+ +

Returns an iterator to the end.

+

The returned iterator points to the element following the last instance of the given type. Attempting to dereference the returned iterator results in undefined behavior.

+
Note
Input iterators stay true to the order imposed by a call to either sort or respect.
+
Returns
An iterator to the element following the last instance of the given type.
+ +

Definition at line 664 of file storage.hpp.

+ +
+
+ +

◆ get()

+ +
+
+
+template<typename Entity , typename Type >
+ + + + + +
+ + + + + + + + +
object_type entt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >::get ([[maybe_unused] ] const entity_type entt) const
+ 		+inline
+
+ +

Returns the object associated with an entity.

+
Note
Empty types aren't explicitly instantiated. Therefore, this function always returns a temporary object.
+
Warning
Attempting to use an entity that doesn't belong to the storage results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode if the storage doesn't contain the given entity.
+
Parameters
+ + +
enttA valid entity identifier.
+
+
+
Returns
The object associated with the entity.
+ +

Definition at line 684 of file storage.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty_ac9255c8c588438ee2413ba78575c478.map b/classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty_ac9255c8c588438ee2413ba78575c478.map new file mode 100644 index 000000000..7e52dd078 --- /dev/null +++ b/classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty_ac9255c8c588438ee2413ba78575c478.map @@ -0,0 +1,3 @@ + + + diff --git a/classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty_ac9255c8c588438ee2413ba78575c478.md5 b/classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty_ac9255c8c588438ee2413ba78575c478.md5 new file mode 100644 index 000000000..a8a923958 --- /dev/null +++ b/classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty_ac9255c8c588438ee2413ba78575c478.md5 @@ -0,0 +1 @@ +980b49e0e616ac60324f16d20965aaea \ No newline at end of file diff --git a/classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty_ac9255c8c588438ee2413ba78575c478.png b/classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty_ac9255c8c588438ee2413ba78575c478.png new file mode 100644 index 000000000..273438184 Binary files /dev/null and b/classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty_ac9255c8c588438ee2413ba78575c478.png differ diff --git a/classentt_1_1basic__storage__coll__graph.map b/classentt_1_1basic__storage__coll__graph.map new file mode 100644 index 000000000..a4c414c02 --- /dev/null +++ b/classentt_1_1basic__storage__coll__graph.map @@ -0,0 +1,3 @@ + + + diff --git a/classentt_1_1basic__storage__coll__graph.md5 b/classentt_1_1basic__storage__coll__graph.md5 new file mode 100644 index 000000000..f0f0b7d72 --- /dev/null +++ b/classentt_1_1basic__storage__coll__graph.md5 @@ -0,0 +1 @@ +12e4fc4ffbf66bc838f249e35b053554 \ No newline at end of file diff --git a/classentt_1_1basic__storage__coll__graph.png b/classentt_1_1basic__storage__coll__graph.png new file mode 100644 index 000000000..5e9b62afa Binary files /dev/null and b/classentt_1_1basic__storage__coll__graph.png differ diff --git a/classentt_1_1basic__storage__inherit__graph.map b/classentt_1_1basic__storage__inherit__graph.map new file mode 100644 index 000000000..fc1a4d796 --- /dev/null +++ b/classentt_1_1basic__storage__inherit__graph.map @@ -0,0 +1,4 @@ + + + + diff --git a/classentt_1_1basic__storage__inherit__graph.md5 b/classentt_1_1basic__storage__inherit__graph.md5 new file mode 100644 index 000000000..1fc462d2e --- /dev/null +++ b/classentt_1_1basic__storage__inherit__graph.md5 @@ -0,0 +1 @@ +addce201ba3ef52c820b52aa9be1efff \ No newline at end of file diff --git a/classentt_1_1basic__storage__inherit__graph.png b/classentt_1_1basic__storage__inherit__graph.png new file mode 100644 index 000000000..2bdc92f78 Binary files /dev/null and b/classentt_1_1basic__storage__inherit__graph.png differ diff --git a/classentt_1_1basic__view-members.html b/classentt_1_1basic__view-members.html new file mode 100644 index 000000000..0bdaa793a --- /dev/null +++ b/classentt_1_1basic__view-members.html @@ -0,0 +1,98 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
entt::basic_view< Entity, Component > Member List
+
+
+ +

This is the complete list of members for entt::basic_view< Entity, Component >, including all inherited members.

+ + + + + + + + + + + + + + + + + + +
basic_registry< Entity > classentt::basic_view< Entity, Component >friend
begin() const ENTT_NOEXCEPTentt::basic_view< Entity, Component >inline
contains(const entity_type entt) const ENTT_NOEXCEPTentt::basic_view< Entity, Component >inline
data() const ENTT_NOEXCEPTentt::basic_view< Entity, Component >inline
each(Func func) constentt::basic_view< Entity, Component >inline
each(Func func) constentt::basic_view< Entity, Component >inline
empty() const ENTT_NOEXCEPTentt::basic_view< Entity, Component >inline
empty() const ENTT_NOEXCEPTentt::basic_view< Entity, Component >inline
end() const ENTT_NOEXCEPTentt::basic_view< Entity, Component >inline
entity_type typedefentt::basic_view< Entity, Component >
find(const entity_type entt) const ENTT_NOEXCEPTentt::basic_view< Entity, Component >inline
get([[maybe_unused]] const entity_type entt) const ENTT_NOEXCEPTentt::basic_view< Entity, Component >inline
iterator_type typedefentt::basic_view< Entity, Component >
raw() const ENTT_NOEXCEPTentt::basic_view< Entity, Component >inline
size() const ENTT_NOEXCEPTentt::basic_view< Entity, Component >inline
size() const ENTT_NOEXCEPTentt::basic_view< Entity, Component >inline
size_type typedefentt::basic_view< Entity, Component >
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1basic__view.html b/classentt_1_1basic__view.html new file mode 100644 index 000000000..54d2ddc43 --- /dev/null +++ b/classentt_1_1basic__view.html @@ -0,0 +1,716 @@ + + + + + + + +EnTT: entt::basic_view< Entity, Component > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+Classes | +Public Types | +Public Member Functions | +Friends | +List of all members
+
+
entt::basic_view< Entity, Component > Class Template Reference
+
+
+ +

Multi component view. + More...

+ +

#include <view.hpp>

+ + + + + + + + + + + +

+Public Types

+using entity_type = typename sparse_set< Entity >::entity_type
 Underlying entity identifier.
 
+using size_type = typename sparse_set< Entity >::size_type
 Unsigned integer type.
 
+using iterator_type = iterator
 Input iterator type.
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

template<typename Comp >
size_type size () const ENTT_NOEXCEPT
 Returns the number of existing components of the given type. More...
 
size_type size () const ENTT_NOEXCEPT
 Estimates the number of entities that have the given components. More...
 
template<typename Comp >
bool empty () const ENTT_NOEXCEPT
 Checks whether the pool of a given component is empty. More...
 
bool empty () const ENTT_NOEXCEPT
 Checks if the view is definitely empty. More...
 
template<typename Comp >
Comp * raw () const ENTT_NOEXCEPT
 Direct access to the list of components of a given pool. More...
 
template<typename Comp >
const entity_type * data () const ENTT_NOEXCEPT
 Direct access to the list of entities of a given pool. More...
 
iterator_type begin () const ENTT_NOEXCEPT
 Returns an iterator to the first entity that has the given components. More...
 
iterator_type end () const ENTT_NOEXCEPT
 Returns an iterator that is past the last entity that has the given components. More...
 
iterator_type find (const entity_type entt) const ENTT_NOEXCEPT
 Finds an entity. More...
 
bool contains (const entity_type entt) const ENTT_NOEXCEPT
 Checks if a view contains an entity. More...
 
template<typename... Comp>
decltype(auto) get ([[maybe_unused]] const entity_type entt) const ENTT_NOEXCEPT
 Returns the components assigned to the given entity. More...
 
template<typename Func >
void each (Func func) const
 Iterates entities and components and applies the given function object to them. More...
 
template<typename Comp , typename Func >
void each (Func func) const
 Iterates entities and components and applies the given function object to them. More...
 
+ + + + +

+Friends

+class basic_registry< Entity >
 A registry is allowed to create views.
 
+

Detailed Description

+

template<typename Entity, typename... Component>
+class entt::basic_view< Entity, Component >

+ +

Multi component view.

+

Multi component views iterate over those entities that have at least all the given components in their bags. During initialization, a multi component view looks at the number of entities available for each component and picks up a reference to the smallest set of candidate entities in order to get a performance boost when iterate.
+ Order of elements during iterations are highly dependent on the order of the underlying data structures. See sparse_set and its specializations for more details.

+

Important

+

Iterators aren't invalidated if:

+
    +
  • New instances of the given components are created and assigned to entities.
    • +
  • The entity currently pointed is modified (as an example, if one of the given components is removed from the entity to which the iterator points).
    • +
+

In all the other cases, modifying the pools of the given components in any way invalidates all the iterators and using them results in undefined behavior.

+
Note
Views share references to the underlying data structures of the registry that generated them. Therefore any change to the entities and to the components made by means of the registry are immediately reflected by views.
+
Warning
Lifetime of a view must overcome the one of the registry that generated it. In any other case, attempting to use a view results in undefined behavior.
+
Template Parameters
+ + + +
EntityA valid entity type (see entt_traits for more details).
ComponentTypes of components iterated by the view.
+
+
+ +

Definition at line 17 of file fwd.hpp.

+

Member Function Documentation

+ +

◆ begin()

+ +
+
+
+template<typename Entity, typename... Component>
+ + + + + +
+ + + + + + + +
iterator_type entt::basic_view< Entity, Component >::begin () const
+ 		+inline
+
+ +

Returns an iterator to the first entity that has the given components.

+

The returned iterator points to the first entity that has the given components. If the view is empty, the returned iterator will be equal to end().

+
Note
Input iterators stay true to the order imposed to the underlying data structures.
+
Returns
An iterator to the first entity that has the given components.
+ +

Definition at line 288 of file view.hpp.

+ +
+
+ +

◆ contains()

+ +
+
+
+template<typename Entity, typename... Component>
+ + + + + +
+ + + + + + + + +
bool entt::basic_view< Entity, Component >::contains (const entity_type entt) const
+ 		+inline
+
+ +

Checks if a view contains an entity.

+
Parameters
+ + +
enttA valid entity identifier.
+
+
+
Returns
True if the view contains the given entity, false otherwise.
+ +

Definition at line 330 of file view.hpp.

+ +
+
+ +

◆ data()

+ +
+
+
+template<typename Entity, typename... Component>
+
+template<typename Comp >
+ + + + + +
+ + + + + + + +
const entity_type* entt::basic_view< Entity, Component >::data () const
+ 		+inline
+
+ +

Direct access to the list of entities of a given pool.

+

The returned pointer is such that range [data<Comp>(), data<Comp>() + size<Comp>()] is always a valid range, even if the container is empty.

+
Note
There are no guarantees on the order of the entities. Use begin and end if you want to iterate the view in the expected order.
+
Template Parameters
+ + +
CompType of component in which one is interested.
+
+
+
Returns
A pointer to the array of entities.
+ +

Definition at line 270 of file view.hpp.

+ +
+
+ +

◆ each() [1/2]

+ +
+
+
+template<typename Entity, typename... Component>
+
+template<typename Func >
+ + + + + +
+ + + + + + + + +
void entt::basic_view< Entity, Component >::each (Func func) const
+ 		+inline
+
+ +

Iterates entities and components and applies the given function object to them.

+

The function object is invoked for each entity. It is provided with the entity itself and a set of references to all its components. The constness of the components is as requested.
+ The signature of the function must be equivalent to one of the following forms:

+
void(const entity_type, Component &...);
void(Component &...);
Note
Empty types aren't explicitly instantiated. Therefore, temporary objects are returned during iterations. They can be caught only by copy or with const references.
+
Template Parameters
+ + +
FuncType of the function object to invoke.
+
+
+
Parameters
+ + +
funcA valid function object.
+
+
+ +

Definition at line 386 of file view.hpp.

+ +
+
+ +

◆ each() [2/2]

+ +
+
+
+template<typename Entity, typename... Component>
+
+template<typename Comp , typename Func >
+ + + + + +
+ + + + + + + + +
void entt::basic_view< Entity, Component >::each (Func func) const
+ 		+inline
+
+ +

Iterates entities and components and applies the given function object to them.

+

The function object is invoked for each entity. It is provided with the entity itself and a set of references to all its components. The constness of the components is as requested.
+ The signature of the function must be equivalent to one of the following forms:

+
void(const entity_type, Component &...);
void(Component &...);

The pool of the suggested component is used to lead the iterations. The returned entities will therefore respect the order of the pool associated with that type.
+ It is no longer guaranteed that the performance is the best possible, but there will be greater control over the order of iteration.

+
Note
Empty types aren't explicitly instantiated. Therefore, temporary objects are returned during iterations. They can be caught only by copy or with const references.
+
Template Parameters
+ + + +
CompType of component to use to enforce the iteration order.
FuncType of the function object to invoke.
+
+
+
Parameters
+ + +
funcA valid function object.
+
+
+ +

Definition at line 422 of file view.hpp.

+ +
+
+ +

◆ empty() [1/2]

+ +
+
+
+template<typename Entity, typename... Component>
+
+template<typename Comp >
+ + + + + +
+ + + + + + + +
bool entt::basic_view< Entity, Component >::empty () const
+ 		+inline
+
+ +

Checks whether the pool of a given component is empty.

+
Template Parameters
+ + +
CompType of component in which one is interested.
+
+
+
Returns
True if the pool of the given component is empty, false otherwise.
+ +

Definition at line 224 of file view.hpp.

+ +
+
+ +

◆ empty() [2/2]

+ +
+
+
+template<typename Entity, typename... Component>
+ + + + + +
+ + + + + + + +
bool entt::basic_view< Entity, Component >::empty () const
+ 		+inline
+
+ +

Checks if the view is definitely empty.

+
Returns
True if the view is definitely empty, false otherwise.
+ +

Definition at line 232 of file view.hpp.

+ +
+
+ +

◆ end()

+ +
+
+
+template<typename Entity, typename... Component>
+ + + + + +
+ + + + + + + +
iterator_type entt::basic_view< Entity, Component >::end () const
+ 		+inline
+
+ +

Returns an iterator that is past the last entity that has the given components.

+

The returned iterator points to the entity following the last entity that has the given components. Attempting to dereference the returned iterator results in undefined behavior.

+
Note
Input iterators stay true to the order imposed to the underlying data structures.
+
Returns
An iterator to the entity following the last entity that has the given components.
+ +

Definition at line 308 of file view.hpp.

+ +
+
+ +

◆ find()

+ +
+
+
+template<typename Entity, typename... Component>
+ + + + + +
+ + + + + + + + +
iterator_type entt::basic_view< Entity, Component >::find (const entity_type entt) const
+ 		+inline
+
+ +

Finds an entity.

+
Parameters
+ + +
enttA valid entity identifier.
+
+
+
Returns
An iterator to the given entity if it's found, past the end iterator otherwise.
+ +

Definition at line 319 of file view.hpp.

+ +
+
+ +

◆ get()

+ +
+
+
+template<typename Entity, typename... Component>
+
+template<typename... Comp>
+ + + + + +
+ + + + + + + + +
decltype(auto) entt::basic_view< Entity, Component >::get ([[maybe_unused] ] const entity_type entt) const
+ 		+inline
+
+ +

Returns the components assigned to the given entity.

+

Prefer this function instead of registry::get during iterations. It has far better performance than its companion function.

+
Warning
Attempting to use an invalid component type results in a compilation error. Attempting to use an entity that doesn't belong to the view results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode if the view doesn't contain the given entity.
+
Template Parameters
+ + +
CompTypes of components to get.
+
+
+
Parameters
+ + +
enttA valid entity identifier.
+
+
+
Returns
The components assigned to the entity.
+ +

Definition at line 352 of file view.hpp.

+ +
+
+ +

◆ raw()

+ +
+
+
+template<typename Entity, typename... Component>
+
+template<typename Comp >
+ + + + + +
+ + + + + + + +
Comp* entt::basic_view< Entity, Component >::raw () const
+ 		+inline
+
+ +

Direct access to the list of components of a given pool.

+

The returned pointer is such that range [raw<Comp>(), raw<Comp>() + size<Comp>()] is always a valid range, even if the container is empty.

+
Note
There are no guarantees on the order of the components. Use begin and end if you want to iterate the view in the expected order.
+
Template Parameters
+ + +
CompType of component in which one is interested.
+
+
+
Returns
A pointer to the array of components.
+ +

Definition at line 251 of file view.hpp.

+ +
+
+ +

◆ size() [1/2]

+ +
+
+
+template<typename Entity, typename... Component>
+
+template<typename Comp >
+ + + + + +
+ + + + + + + +
size_type entt::basic_view< Entity, Component >::size () const
+ 		+inline
+
+ +

Returns the number of existing components of the given type.

+
Template Parameters
+ + +
CompType of component of which to return the size.
+
+
+
Returns
Number of existing components of the given type.
+ +

Definition at line 205 of file view.hpp.

+ +
+
+ +

◆ size() [2/2]

+ +
+
+
+template<typename Entity, typename... Component>
+ + + + + +
+ + + + + + + +
size_type entt::basic_view< Entity, Component >::size () const
+ 		+inline
+
+ +

Estimates the number of entities that have the given components.

+
Returns
Estimated number of entities that have the given components.
+ +

Definition at line 213 of file view.hpp.

+ +
+
+
The documentation for this class was generated from the following files: +
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1basic__view_3_01Entity_00_01Component_01_4-members.html b/classentt_1_1basic__view_3_01Entity_00_01Component_01_4-members.html new file mode 100644 index 000000000..6b282b209 --- /dev/null +++ b/classentt_1_1basic__view_3_01Entity_00_01Component_01_4-members.html @@ -0,0 +1,97 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
entt::basic_view< Entity, Component > Member List
+
+
+ +

This is the complete list of members for entt::basic_view< Entity, Component >, including all inherited members.

+ + + + + + + + + + + + + + + + + +
basic_registry< Entity > classentt::basic_view< Entity, Component >friend
begin() const ENTT_NOEXCEPTentt::basic_view< Entity, Component >inline
contains(const entity_type entt) const ENTT_NOEXCEPTentt::basic_view< Entity, Component >inline
data() const ENTT_NOEXCEPTentt::basic_view< Entity, Component >inline
each(Func func) constentt::basic_view< Entity, Component >inline
empty() const ENTT_NOEXCEPTentt::basic_view< Entity, Component >inline
end() const ENTT_NOEXCEPTentt::basic_view< Entity, Component >inline
entity_type typedefentt::basic_view< Entity, Component >
find(const entity_type entt) const ENTT_NOEXCEPTentt::basic_view< Entity, Component >inline
get(const entity_type entt) const ENTT_NOEXCEPTentt::basic_view< Entity, Component >inline
iterator_type typedefentt::basic_view< Entity, Component >
operator[](const size_type pos) const ENTT_NOEXCEPTentt::basic_view< Entity, Component >inline
raw() const ENTT_NOEXCEPTentt::basic_view< Entity, Component >inline
raw_type typedefentt::basic_view< Entity, Component >
size() const ENTT_NOEXCEPTentt::basic_view< Entity, Component >inline
size_type typedefentt::basic_view< Entity, Component >
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1basic__view_3_01Entity_00_01Component_01_4.html b/classentt_1_1basic__view_3_01Entity_00_01Component_01_4.html new file mode 100644 index 000000000..c96949623 --- /dev/null +++ b/classentt_1_1basic__view_3_01Entity_00_01Component_01_4.html @@ -0,0 +1,589 @@ + + + + + + + +EnTT: entt::basic_view< Entity, Component > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+Public Types | +Public Member Functions | +Friends | +List of all members
+
+
entt::basic_view< Entity, Component > Class Template Reference
+
+
+ +

Single component view specialization. + More...

+ +

#include <view.hpp>

+ + + + + + + + + + + + + + +

+Public Types

+using raw_type = Component
 Type of component iterated by the view.
 
+using entity_type = typename pool_type::entity_type
 Underlying entity identifier.
 
+using size_type = typename pool_type::size_type
 Unsigned integer type.
 
+using iterator_type = typename sparse_set< Entity >::iterator_type
 Input iterator type.
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

size_type size () const ENTT_NOEXCEPT
 Returns the number of entities that have the given component. More...
 
bool empty () const ENTT_NOEXCEPT
 Checks whether the view is empty. More...
 
raw_type * raw () const ENTT_NOEXCEPT
 Direct access to the list of components. More...
 
const entity_type * data () const ENTT_NOEXCEPT
 Direct access to the list of entities. More...
 
iterator_type begin () const ENTT_NOEXCEPT
 Returns an iterator to the first entity that has the given component. More...
 
iterator_type end () const ENTT_NOEXCEPT
 Returns an iterator that is past the last entity that has the given component. More...
 
iterator_type find (const entity_type entt) const ENTT_NOEXCEPT
 Finds an entity. More...
 
entity_type operator[] (const size_type pos) const ENTT_NOEXCEPT
 Returns the identifier that occupies the given position. More...
 
bool contains (const entity_type entt) const ENTT_NOEXCEPT
 Checks if a view contains an entity. More...
 
decltype(auto) get (const entity_type entt) const ENTT_NOEXCEPT
 Returns the component assigned to the given entity. More...
 
template<typename Func >
void each (Func func) const
 Iterates entities and components and applies the given function object to them. More...
 
+ + + + +

+Friends

+class basic_registry< Entity >
 A registry is allowed to create views.
 
+

Detailed Description

+

template<typename Entity, typename Component>
+class entt::basic_view< Entity, Component >

+ +

Single component view specialization.

+

Single component views are specialized in order to get a boost in terms of performance. This kind of views can access the underlying data structure directly and avoid superfluous checks.
+ Order of elements during iterations are highly dependent on the order of the underlying data structure. See sparse_set and its specializations for more details.

+

Important

+

Iterators aren't invalidated if:

+
    +
  • New instances of the given component are created and assigned to entities.
    • +
  • The entity currently pointed is modified (as an example, the given component is removed from the entity to which the iterator points).
    • +
+

In all the other cases, modifying the pool of the given component in any way invalidates all the iterators and using them results in undefined behavior.

+
Note
Views share a reference to the underlying data structure of the registry that generated them. Therefore any change to the entities and to the components made by means of the registry are immediately reflected by views.
+
Warning
Lifetime of a view must overcome the one of the registry that generated it. In any other case, attempting to use a view results in undefined behavior.
+
Template Parameters
+ + + +
EntityA valid entity type (see entt_traits for more details).
ComponentType of component iterated by the view.
+
+
+ +

Definition at line 466 of file view.hpp.

+

Member Function Documentation

+ +

◆ begin()

+ +
+
+
+template<typename Entity , typename Component >
+ + + + + +
+ + + + + + + +
iterator_type entt::basic_view< Entity, Component >::begin () const
+ 		+inline
+
+ +

Returns an iterator to the first entity that has the given component.

+

The returned iterator points to the first entity that has the given component. If the view is empty, the returned iterator will be equal to end().

+
Note
Input iterators stay true to the order imposed to the underlying data structures.
+
Returns
An iterator to the first entity that has the given component.
+ +

Definition at line 548 of file view.hpp.

+ +
+
+ +

◆ contains()

+ +
+
+
+template<typename Entity , typename Component >
+ + + + + +
+ + + + + + + + +
bool entt::basic_view< Entity, Component >::contains (const entity_type entt) const
+ 		+inline
+
+ +

Checks if a view contains an entity.

+
Parameters
+ + +
enttA valid entity identifier.
+
+
+
Returns
True if the view contains the given entity, false otherwise.
+ +

Definition at line 596 of file view.hpp.

+ +
+
+ +

◆ data()

+ +
+
+
+template<typename Entity , typename Component >
+ + + + + +
+ + + + + + + +
const entity_type* entt::basic_view< Entity, Component >::data () const
+ 		+inline
+
+ +

Direct access to the list of entities.

+

The returned pointer is such that range [data(), data() + size()] is always a valid range, even if the container is empty.

+
Note
There are no guarantees on the order of the entities. Use begin and end if you want to iterate the view in the expected order.
+
Returns
A pointer to the array of entities.
+ +

Definition at line 530 of file view.hpp.

+ +
+
+ +

◆ each()

+ +
+
+
+template<typename Entity , typename Component >
+
+template<typename Func >
+ + + + + +
+ + + + + + + + +
void entt::basic_view< Entity, Component >::each (Func func) const
+ 		+inline
+
+ +

Iterates entities and components and applies the given function object to them.

+

The function object is invoked for each entity. It is provided with the entity itself and a reference to its component. The constness of the component is as requested.
+ The signature of the function must be equivalent to one of the following forms:

+
void(const entity_type, Component &);
void(Component &);
Note
Empty types aren't explicitly instantiated. Therefore, temporary objects are returned during iterations. They can be caught only by copy or with const references.
+
Template Parameters
+ + +
FuncType of the function object to invoke.
+
+
+
Parameters
+ + +
funcA valid function object.
+
+
+ +

Definition at line 644 of file view.hpp.

+ +
+
+ +

◆ empty()

+ +
+
+
+template<typename Entity , typename Component >
+ + + + + +
+ + + + + + + +
bool entt::basic_view< Entity, Component >::empty () const
+ 		+inline
+
+ +

Checks whether the view is empty.

+
Returns
True if the view is empty, false otherwise.
+ +

Definition at line 498 of file view.hpp.

+ +
+
+ +

◆ end()

+ +
+
+
+template<typename Entity , typename Component >
+ + + + + +
+ + + + + + + +
iterator_type entt::basic_view< Entity, Component >::end () const
+ 		+inline
+
+ +

Returns an iterator that is past the last entity that has the given component.

+

The returned iterator points to the entity following the last entity that has the given component. Attempting to dereference the returned iterator results in undefined behavior.

+
Note
Input iterators stay true to the order imposed to the underlying data structures.
+
Returns
An iterator to the entity following the last entity that has the given component.
+ +

Definition at line 567 of file view.hpp.

+ +
+
+ +

◆ find()

+ +
+
+
+template<typename Entity , typename Component >
+ + + + + +
+ + + + + + + + +
iterator_type entt::basic_view< Entity, Component >::find (const entity_type entt) const
+ 		+inline
+
+ +

Finds an entity.

+
Parameters
+ + +
enttA valid entity identifier.
+
+
+
Returns
An iterator to the given entity if it's found, past the end iterator otherwise.
+ +

Definition at line 577 of file view.hpp.

+ +
+
+ +

◆ get()

+ +
+
+
+template<typename Entity , typename Component >
+ + + + + +
+ + + + + + + + +
decltype(auto) entt::basic_view< Entity, Component >::get (const entity_type entt) const
+ 		+inline
+
+ +

Returns the component assigned to the given entity.

+

Prefer this function instead of registry::get during iterations. It has far better performance than its companion function.

+
Warning
Attempting to use an entity that doesn't belong to the view results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode if the view doesn't contain the given entity.
+
Parameters
+ + +
enttA valid entity identifier.
+
+
+
Returns
The component assigned to the entity.
+ +

Definition at line 615 of file view.hpp.

+ +
+
+ +

◆ operator[]()

+ +
+
+
+template<typename Entity , typename Component >
+ + + + + +
+ + + + + + + + +
entity_type entt::basic_view< Entity, Component >::operator[] (const size_type pos) const
+ 		+inline
+
+ +

Returns the identifier that occupies the given position.

+
Parameters
+ + +
posPosition of the element to return.
+
+
+
Returns
The identifier that occupies the given position.
+ +

Definition at line 587 of file view.hpp.

+ +
+
+ +

◆ raw()

+ +
+
+
+template<typename Entity , typename Component >
+ + + + + +
+ + + + + + + +
raw_type* entt::basic_view< Entity, Component >::raw () const
+ 		+inline
+
+ +

Direct access to the list of components.

+

The returned pointer is such that range [raw(), raw() + size()] is always a valid range, even if the container is empty.

+
Note
There are no guarantees on the order of the components. Use begin and end if you want to iterate the view in the expected order.
+
Returns
A pointer to the array of components.
+ +

Definition at line 514 of file view.hpp.

+ +
+
+ +

◆ size()

+ +
+
+
+template<typename Entity , typename Component >
+ + + + + +
+ + + + + + + +
size_type entt::basic_view< Entity, Component >::size () const
+ 		+inline
+
+ +

Returns the number of entities that have the given component.

+
Returns
Number of entities that have the given component.
+ +

Definition at line 490 of file view.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1Delegate.html b/classentt_1_1delegate.html similarity index 88% rename from classentt_1_1Delegate.html rename to classentt_1_1delegate.html index 5386e438f..c00abeafb 100644 --- a/classentt_1_1Delegate.html +++ b/classentt_1_1delegate.html @@ -5,7 +5,7 @@ -EnTT: entt::Delegate< typename > Class Template Reference +EnTT: entt::delegate< typename > Class Template Reference @@ -22,7 +22,7 @@
EnTT -  2.7.3 +  3.0.0
+ + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
entt::delegate< Ret(Args...)> Member List
+
+
+ +

This is the complete list of members for entt::delegate< Ret(Args...)>, including all inherited members.

+ + + + + + + + + + + + +
connect() ENTT_NOEXCEPTentt::delegate< Ret(Args...)>inline
connect(Type *value_or_instance) ENTT_NOEXCEPTentt::delegate< Ret(Args...)>inline
delegate() ENTT_NOEXCEPTentt::delegate< Ret(Args...)>inline
delegate(connect_arg_t< Function >) ENTT_NOEXCEPTentt::delegate< Ret(Args...)>inline
delegate(connect_arg_t< Candidate >, Type *value_or_instance) ENTT_NOEXCEPTentt::delegate< Ret(Args...)>inline
function_type typedefentt::delegate< Ret(Args...)>
instance() const ENTT_NOEXCEPTentt::delegate< Ret(Args...)>inline
operator bool() const ENTT_NOEXCEPTentt::delegate< Ret(Args...)>inlineexplicit
operator()(Args... args) constentt::delegate< Ret(Args...)>inline
operator==(const delegate< Ret(Args...)> &other) const ENTT_NOEXCEPTentt::delegate< Ret(Args...)>inline
reset() ENTT_NOEXCEPTentt::delegate< Ret(Args...)>inline
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1delegate_3_01Ret_07Args_8_8_8_08_4.html b/classentt_1_1delegate_3_01Ret_07Args_8_8_8_08_4.html new file mode 100644 index 000000000..a30e6ea19 --- /dev/null +++ b/classentt_1_1delegate_3_01Ret_07Args_8_8_8_08_4.html @@ -0,0 +1,517 @@ + + + + + + + +EnTT: entt::delegate< Ret(Args...)> Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+Public Types | +Public Member Functions | +List of all members
+
+
entt::delegate< Ret(Args...)> Class Template Reference
+
+
+ +

Utility class to use to send around functions and members. + More...

+ +

#include <delegate.hpp>

+ + + + + +

+Public Types

+using function_type = Ret(Args...)
 Function type of the delegate.
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+ delegate () ENTT_NOEXCEPT
 Default constructor.
 
template<auto Function>
 delegate (connect_arg_t< Function >) ENTT_NOEXCEPT
 Constructs a delegate and connects a free function to it. More...
 
template<auto Candidate, typename Type >
 delegate (connect_arg_t< Candidate >, Type *value_or_instance) ENTT_NOEXCEPT
 Constructs a delegate and connects a member for a given instance or a free function with payload. More...
 
template<auto Function>
void connect () ENTT_NOEXCEPT
 Connects a free function to a delegate. More...
 
template<auto Candidate, typename Type >
void connect (Type *value_or_instance) ENTT_NOEXCEPT
 Connects a member function for a given instance or a free function with payload to a delegate. More...
 
void reset () ENTT_NOEXCEPT
 Resets a delegate. More...
 
const void * instance () const ENTT_NOEXCEPT
 Returns the instance linked to a delegate, if any. More...
 
Ret operator() (Args... args) const
 Triggers a delegate. More...
 
 operator bool () const ENTT_NOEXCEPT
 Checks whether a delegate actually stores a listener. More...
 
bool operator== (const delegate< Ret(Args...)> &other) const ENTT_NOEXCEPT
 Checks if the connected functions differ. More...
 
+

Detailed Description

+

template<typename Ret, typename... Args>
+class entt::delegate< Ret(Args...)>

+ +

Utility class to use to send around functions and members.

+

Unmanaged delegate for function pointers and members. Users of this class are in charge of disconnecting instances before deleting them.

+

A delegate can be used as general purpose invoker with no memory overhead for free functions (with or without payload) and members provided along with an instance on which to invoke them.

+
Template Parameters
+ + + +
RetReturn type of a function type.
ArgsTypes of arguments of a function type.
+
+
+ +

Definition at line 83 of file delegate.hpp.

+

Constructor & Destructor Documentation

+ +

◆ delegate() [1/2]

+ +
+
+
+template<typename Ret , typename... Args>
+
+template<auto Function>
+ + + + + +
+ + + + + + + + +
entt::delegate< Ret(Args...)>::delegate (connect_arg_t< Function > )
+ 		+inline
+
+ +

Constructs a delegate and connects a free function to it.

+
Template Parameters
+ + +
FunctionA valid free function pointer.
+
+
+ +

Definition at line 100 of file delegate.hpp.

+ +
+
+ +

◆ delegate() [2/2]

+ +
+
+
+template<typename Ret , typename... Args>
+
+template<auto Candidate, typename Type >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
entt::delegate< Ret(Args...)>::delegate (connect_arg_t< Candidate > ,
Type * value_or_instance 
)
+ 		+inline
+
+ +

Constructs a delegate and connects a member for a given instance or a free function with payload.

+
Template Parameters
+ + + +
CandidateMember or free function to connect to the delegate.
TypeType of class or type of payload.
+
+
+
Parameters
+ + +
value_or_instanceA valid pointer that fits the purpose.
+
+
+ +

Definition at line 114 of file delegate.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ connect() [1/2]

+ +
+
+
+template<typename Ret , typename... Args>
+
+template<auto Function>
+ + + + + +
+ + + + + + + +
void entt::delegate< Ret(Args...)>::connect ()
+ 		+inline
+
+ +

Connects a free function to a delegate.

+
Template Parameters
+ + +
FunctionA valid free function pointer.
+
+
+ +

Definition at line 125 of file delegate.hpp.

+ +
+
+ +

◆ connect() [2/2]

+ +
+
+
+template<typename Ret , typename... Args>
+
+template<auto Candidate, typename Type >
+ + + + + +
+ + + + + + + + +
void entt::delegate< Ret(Args...)>::connect (Type * value_or_instance)
+ 		+inline
+
+ +

Connects a member function for a given instance or a free function with payload to a delegate.

+

The delegate isn't responsible for the connected object or the payload. Users must always guarantee that the lifetime of the instance overcomes the one of the delegate.
+ When used to connect a free function with payload, its signature must be such that the instance is the first argument before the ones used to define the delegate itself.

+
Template Parameters
+ + + +
CandidateMember or free function to connect to the delegate.
TypeType of class or type of payload.
+
+
+
Parameters
+ + +
value_or_instanceA valid pointer that fits the purpose.
+
+
+ +

Definition at line 151 of file delegate.hpp.

+ +
+
+ +

◆ instance()

+ +
+
+
+template<typename Ret , typename... Args>
+ + + + + +
+ + + + + + + +
const void* entt::delegate< Ret(Args...)>::instance () const
+ 		+inline
+
+ +

Returns the instance linked to a delegate, if any.

+
Returns
An opaque pointer to the instance linked to the delegate, if any.
+ +

Definition at line 183 of file delegate.hpp.

+ +
+
+ +

◆ operator bool()

+ +
+
+
+template<typename Ret , typename... Args>
+ + + + + +
+ + + + + + + +
entt::delegate< Ret(Args...)>::operator bool () const
+ 		+inlineexplicit
+
+ +

Checks whether a delegate actually stores a listener.

+
Returns
False if the delegate is empty, true otherwise.
+ +

Definition at line 210 of file delegate.hpp.

+ +
+
+ +

◆ operator()()

+ +
+
+
+template<typename Ret , typename... Args>
+ + + + + +
+ + + + + + + + +
Ret entt::delegate< Ret(Args...)>::operator() (Args... args) const
+ 		+inline
+
+ +

Triggers a delegate.

+

The delegate invokes the underlying function and returns the result.

+
Warning
Attempting to trigger an invalid delegate results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode if the delegate has not yet been set.
+
Parameters
+ + +
argsArguments to use to invoke the underlying function.
+
+
+
Returns
The value returned by the underlying function.
+ +

Definition at line 201 of file delegate.hpp.

+ +
+
+ +

◆ operator==()

+ +
+
+
+template<typename Ret , typename... Args>
+ + + + + +
+ + + + + + + + +
bool entt::delegate< Ret(Args...)>::operator== (const delegate< Ret(Args...)> & other) const
+ 		+inline
+
+ +

Checks if the connected functions differ.

+

Instances connected to delegates are ignored by this operator. Use the instance member function instead.

+
Parameters
+ + +
otherDelegate with which to compare.
+
+
+
Returns
False if the connected functions differ, true otherwise.
+ +

Definition at line 224 of file delegate.hpp.

+ +
+
+ +

◆ reset()

+ +
+
+
+template<typename Ret , typename... Args>
+ + + + + +
+ + + + + + + +
void entt::delegate< Ret(Args...)>::reset ()
+ 		+inline
+
+ +

Resets a delegate.

+

After a reset, a delegate cannot be invoked anymore.

+ +

Definition at line 174 of file delegate.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1dispatcher-members.html b/classentt_1_1dispatcher-members.html new file mode 100644 index 000000000..b1f2c87fe --- /dev/null +++ b/classentt_1_1dispatcher-members.html @@ -0,0 +1,89 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
entt::dispatcher Member List
+
+
+ +

This is the complete list of members for entt::dispatcher, including all inherited members.

+ + + + + + + + + +
enqueue(Args &&... args)entt::dispatcherinline
enqueue(Event &&event)entt::dispatcherinline
sink() ENTT_NOEXCEPTentt::dispatcherinline
sink_type typedefentt::dispatcher
trigger(Args &&... args)entt::dispatcherinline
trigger(Event &&event)entt::dispatcherinline
update()entt::dispatcherinline
update() constentt::dispatcherinline
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1Dispatcher.html b/classentt_1_1dispatcher.html similarity index 53% rename from classentt_1_1Dispatcher.html rename to classentt_1_1dispatcher.html index 18f218e76..14ba50676 100644 --- a/classentt_1_1Dispatcher.html +++ b/classentt_1_1dispatcher.html @@ -5,7 +5,7 @@ -EnTT: entt::Dispatcher Class Reference +EnTT: entt::dispatcher Class Reference @@ -22,7 +22,7 @@
EnTT -  2.7.3 +  3.0.0
- - - - + + +

Public Types

+
template<typename Event >
using sink_type = typename SignalWrapper< Event >::sink_type
 Type of sink for the given event.
 
using sink_type = typename signal_wrapper< Event >::sink_type
 Type of sink for the given event.
 
- - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + +

Public Member Functions

template<typename Event >
sink_type< Event > sink () ENTT_NOEXCEPT
 Returns a sink object for the given event. More...
 
template<typename Event , typename... Args>
void trigger (Args &&... args)
 Triggers an immediate event of the given type. More...
 
template<typename Event , typename... Args>
void enqueue (Args &&... args)
 Enqueues an event of the given type. More...
 
template<typename Event >
void update ()
 Delivers all the pending events of the given type. More...
 
void update () const
 Delivers all the pending events. More...
 
template<typename Event >
sink_type< Event > sink () ENTT_NOEXCEPT
 Returns a sink object for the given event. More...
 
template<typename Event , typename... Args>
void trigger (Args &&... args)
 Triggers an immediate event of the given type. More...
 
template<typename Event >
void trigger (Event &&event)
 Triggers an immediate event of the given type. More...
 
template<typename Event , typename... Args>
void enqueue (Args &&... args)
 Enqueues an event of the given type. More...
 
template<typename Event >
void enqueue (Event &&event)
 Enqueues an event of the given type. More...
 
template<typename Event >
void update ()
 Delivers all the pending events of the given type. More...
 
void update () const
 Delivers all the pending events. More...
 

Detailed Description

Basic dispatcher implementation.

A dispatcher can be used either to trigger an immediate event or to enqueue events to be published all together once per tick.
- Listeners are provided in the form of member functions. For each event of type Event, listeners must have the following function type:

void(const Event &)

Member functions named receive are automatically detected and registered or unregistered by the dispatcher. The type of the instances is Class * (a naked pointer). It means that users must guarantee that the lifetimes of the instances overcome the one of the dispatcher itself to avoid crashes.

+ Listeners are provided in the form of member functions. For each event of type Event, listeners are such that they can be invoked with an argument of type const Event &, no matter what the return type is.

+

The type of the instances is Class * (a naked pointer). It means that users must guarantee that the lifetimes of the instances overcome the one of the dispatcher itself to avoid crashes.

-

Definition at line 35 of file dispatcher.hpp.

+

Definition at line 31 of file dispatcher.hpp.

Member Function Documentation

- -

◆ enqueue()

+ +

◆ enqueue() [1/2]

@@ -127,7 +136,7 @@ template<typename Event , typename... Args>
- + @@ -145,7 +154,7 @@ template<typename Event , typename... Args>

An event of the given type is queued. No listener is invoked. Use the update member function to notify listeners when ready.

Template Parameters
void entt::Dispatcher::enqueue void entt::dispatcher::enqueue ( Args &&...  args)
- +
EventType of event to trigger.
EventType of event to enqueue.
ArgsTypes of arguments to use to construct the event.
@@ -157,12 +166,12 @@ template<typename Event , typename... Args> -

Definition at line 145 of file dispatcher.hpp.

+

Definition at line 190 of file dispatcher.hpp.

- -

◆ sink()

+ +

◆ enqueue() [2/2]

@@ -173,7 +182,52 @@ template<typename Event >
- + + + + + + +
sink_type<Event> entt::Dispatcher::sink void entt::dispatcher::enqueue (Event && event)
+ 		+inline
+
+ +

Enqueues an event of the given type.

+

An event of the given type is queued. No listener is invoked. Use the update member function to notify listeners when ready.

+
Template Parameters
+ + +
EventType of event to enqueue.
+
+
+
Parameters
+ + +
eventAn instance of the given type of event.
+
+
+ +

Definition at line 204 of file dispatcher.hpp.

+ +
+ + +

◆ sink()

+ +
+
+
+template<typename Event >
+ + +
+ + + @@ -188,8 +242,8 @@ template<typename Event >

Returns a sink object for the given event.

A sink is an opaque object used to connect listeners to events.

-

The function type for a listener is:

void(const Event &)

The order of invocation of the listeners isn't guaranteed.

-
See also
SigH::Sink
+

The function type for a listener is:

void(const Event &);

The order of invocation of the listeners isn't guaranteed.

+
See also
sink
Template Parameters
sink_type<Event> entt::dispatcher::sink ( )
@@ -198,12 +252,12 @@ template<typename Event >
Returns
A temporary sink object.
-

Definition at line 115 of file dispatcher.hpp.

+

Definition at line 146 of file dispatcher.hpp.

- -

◆ trigger()

+ +

◆ trigger() [1/2]

@@ -214,7 +268,7 @@ template<typename Event , typename... Args>
@@ -59,51 +59,51 @@ $(function() {
Public Member Functions | -List of all members
+List of all members
-
entt::Monostate< hash_type > Struct Template Reference
+
entt::monostate< hash_type > Struct Template Reference

Minimal implementation of the monostate pattern. - More...

+ More...

#include <monostate.hpp>

EventType of event of which to get the sink.
- + @@ -244,12 +298,12 @@ template<typename Event , typename... Args> -

Definition at line 130 of file dispatcher.hpp.

+

Definition at line 161 of file dispatcher.hpp.

- -

◆ update() [1/2]

+ +

◆ trigger() [2/2]

@@ -260,7 +314,52 @@ template<typename Event >
+ + +
void entt::Dispatcher::trigger void entt::dispatcher::trigger ( Args &&...  args) - + + + + + + +
void entt::Dispatcher::update void entt::dispatcher::trigger (Event && event)
+ 		+inline
+
+ +

Triggers an immediate event of the given type.

+

All the listeners registered for the given type are immediately notified. The event is discarded after the execution.

+
Template Parameters
+ + +
EventType of event to trigger.
+
+
+
Parameters
+ + +
eventAn instance of the given type of event.
+
+
+ +

Definition at line 175 of file dispatcher.hpp.

+ +
+ + +

◆ update() [1/2]

+ +
+
+
+template<typename Event >
+ + + @@ -59,19 +59,19 @@ $(function() {
-
entt::Monostate< hash_type > Member List
+
entt::monostate< hash_type > Member List
-

This is the complete list of members for entt::Monostate< hash_type >, including all inherited members.

+

This is the complete list of members for entt::monostate< hash_type >, including all inherited members.

+ + + @@ -282,12 +381,12 @@ template<typename Event > -

Definition at line 159 of file dispatcher.hpp.

+

Definition at line 218 of file dispatcher.hpp.

- -

◆ update() [2/2]

+ +

◆ update() [2/2]

@@ -296,7 +395,7 @@ template<typename Event >
@@ -59,7 +59,7 @@ $(function() {
@@ -67,93 +67,86 @@ $(function() { Classes | Public Types | Public Member Functions | -List of all members
+List of all members
-
entt::Emitter< Derived > Class Template Reference
+
entt::emitter< Derived > Class Template Reference

General purpose event emitter. - More...

+ More...

#include <emitter.hpp>

void entt::dispatcher::update ( ) - + @@ -312,7 +411,7 @@ template<typename Event >

Delivers all the pending events.

This method is blocking and it doesn't return until all the events are delivered to the registered listeners. It's responsibility of the users to reduce at a minimum the time spent in the bodies of the listeners.

-

Definition at line 170 of file dispatcher.hpp.

+

Definition at line 229 of file dispatcher.hpp.

diff --git a/classentt_1_1Emitter-members.html b/classentt_1_1emitter-members.html similarity index 53% rename from classentt_1_1Emitter-members.html rename to classentt_1_1emitter-members.html index dfcc1e0a8..2c6d838e6 100644 --- a/classentt_1_1Emitter-members.html +++ b/classentt_1_1emitter-members.html @@ -22,7 +22,7 @@ @@ -59,32 +59,30 @@ $(function() {
-
entt::Emitter< Derived > Member List
+
entt::emitter< Derived > Member List
-

This is the complete list of members for entt::Emitter< Derived >, including all inherited members.

+

This is the complete list of members for entt::emitter< Derived >, including all inherited members.

void entt::Dispatcher::update void entt::dispatcher::update ( ) const
EnTT -  2.7.3 +  3.0.0
- - - - - - - - - - - - - - - + + + + + + + + + + + + +
clear() ENTT_NOEXCEPTentt::Emitter< Derived >inline
clear() ENTT_NOEXCEPTentt::Emitter< Derived >inline
Emitter() ENTT_NOEXCEPT=defaultentt::Emitter< Derived >
Emitter(const Emitter &)=deleteentt::Emitter< Derived >
Emitter(Emitter &&)=defaultentt::Emitter< Derived >
empty() const ENTT_NOEXCEPTentt::Emitter< Derived >inline
empty() const ENTT_NOEXCEPTentt::Emitter< Derived >inline
erase(Connection< Event > conn) ENTT_NOEXCEPTentt::Emitter< Derived >inline
Listener typedefentt::Emitter< Derived >
on(Listener< Event > listener)entt::Emitter< Derived >inline
once(Listener< Event > listener)entt::Emitter< Derived >inline
operator=(const Emitter &)=deleteentt::Emitter< Derived >
operator=(Emitter &&)=defaultentt::Emitter< Derived >
publish(Args &&... args)entt::Emitter< Derived >inline
~Emitter() ENTT_NOEXCEPTentt::Emitter< Derived >inlinevirtual
clear() ENTT_NOEXCEPTentt::emitter< Derived >inline
clear() ENTT_NOEXCEPTentt::emitter< Derived >inline
emitter() ENTT_NOEXCEPT=defaultentt::emitter< Derived >
emitter(emitter &&)=defaultentt::emitter< Derived >
empty() const ENTT_NOEXCEPTentt::emitter< Derived >inline
empty() const ENTT_NOEXCEPTentt::emitter< Derived >inline
erase(connection< Event > conn) ENTT_NOEXCEPTentt::emitter< Derived >inline
listener typedefentt::emitter< Derived >
on(listener< Event > instance)entt::emitter< Derived >inline
once(listener< Event > instance)entt::emitter< Derived >inline
operator=(emitter &&)=defaultentt::emitter< Derived >
publish(Args &&... args)entt::emitter< Derived >inline
~emitter() ENTT_NOEXCEPTentt::emitter< Derived >inlinevirtual
diff --git a/classentt_1_1Emitter.html b/classentt_1_1emitter.html similarity index 59% rename from classentt_1_1Emitter.html rename to classentt_1_1emitter.html index 08b01544a..f78feacc7 100644 --- a/classentt_1_1Emitter.html +++ b/classentt_1_1emitter.html @@ -5,7 +5,7 @@ -EnTT: entt::Emitter< Derived > Class Template Reference +EnTT: entt::emitter< Derived > Class Template Reference @@ -22,7 +22,7 @@
EnTT -  2.7.3 +  3.0.0
- - + +

Classes

struct  Connection
 Generic connection type for events. More...
struct  connection
 Generic connection type for events. More...
 
- - - - + + +

Public Types

+
template<typename Event >
using Listener = typename Handler< Event >::listener_type
 Type of listeners accepted for the given event.
 
using listener = typename event_handler< Event >::listener_type
 Type of listeners accepted for the given event.
 
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Public Member Functions

- Emitter () ENTT_NOEXCEPT=default
 Default constructor.
 
-virtual ~Emitter () ENTT_NOEXCEPT
 Default destructor.
 
- Emitter (const Emitter &)=delete
 Copying an emitter isn't allowed.
 
- Emitter (Emitter &&)=default
 Default move constructor.
 
Emitter & operator= (const Emitter &)=delete
 Copying an emitter isn't allowed. More...
 
Emitter & operator= (Emitter &&)=default
 Default move assignment operator. More...
 
template<typename Event , typename... Args>
void publish (Args &&... args)
 Emits the given event. More...
 
template<typename Event >
Connection< Event > on (Listener< Event > listener)
 Registers a long-lived listener with the event emitter. More...
 
template<typename Event >
Connection< Event > once (Listener< Event > listener)
 Registers a short-lived listener with the event emitter. More...
 
template<typename Event >
void erase (Connection< Event > conn) ENTT_NOEXCEPT
 Disconnects a listener from the event emitter. More...
 
template<typename Event >
void clear () ENTT_NOEXCEPT
 Disconnects all the listeners for the given event type. More...
 
void clear () ENTT_NOEXCEPT
 Disconnects all the listeners. More...
 
template<typename Event >
bool empty () const ENTT_NOEXCEPT
 Checks if there are listeners registered for the specific event. More...
 
bool empty () const ENTT_NOEXCEPT
 Checks if there are listeners registered with the event emitter. More...
 
+ emitter () ENTT_NOEXCEPT=default
 Default constructor.
 
+virtual ~emitter () ENTT_NOEXCEPT
 Default destructor.
 
+ emitter (emitter &&)=default
 Default move constructor.
 
emitter & operator= (emitter &&)=default
 Default move assignment operator. More...
 
template<typename Event , typename... Args>
void publish (Args &&... args)
 Emits the given event. More...
 
template<typename Event >
connection< Event > on (listener< Event > instance)
 Registers a long-lived listener with the event emitter. More...
 
template<typename Event >
connection< Event > once (listener< Event > instance)
 Registers a short-lived listener with the event emitter. More...
 
template<typename Event >
void erase (connection< Event > conn) ENTT_NOEXCEPT
 Disconnects a listener from the event emitter. More...
 
template<typename Event >
void clear () ENTT_NOEXCEPT
 Disconnects all the listeners for the given event type. More...
 
void clear () ENTT_NOEXCEPT
 Disconnects all the listeners. More...
 
template<typename Event >
bool empty () const ENTT_NOEXCEPT
 Checks if there are listeners registered for the specific event. More...
 
bool empty () const ENTT_NOEXCEPT
 Checks if there are listeners registered with the event emitter. More...
 

Detailed Description

template<typename Derived>
-class entt::Emitter< Derived >

+class entt::emitter< Derived >

General purpose event emitter.

The emitter class template follows the CRTP idiom. To create a custom emitter type, derived classes must inherit directly from the base class as:

-
struct MyEmitter: Emitter<MyEmitter> {
// ...
}

Handlers for the type of events are created internally on the fly. It's not required to specify in advance the full list of accepted types.
+

struct my_emitter: emitter<my_emitter> {
// ...
}

Handlers for the type of events are created internally on the fly. It's not required to specify in advance the full list of accepted types.
Moreover, whenever an event is published, an emitter provides the listeners with a reference to itself along with a const reference to the event. Therefore listeners have an handy way to work with it without incurring in the need of capturing a reference to the emitter.

Template Parameters
@@ -164,8 +157,8 @@ class entt::Emitter< Derived >

Definition at line 42 of file emitter.hpp.

Member Function Documentation

- -

◆ clear() [1/2]

+ +

◆ clear() [1/2]

@@ -178,7 +171,7 @@ template<typename Event >
@@ -59,37 +59,37 @@ $(function() {
Public Member Functions | -List of all members
+List of all members
-
entt::InsertionSort Struct Referencefinal
+
entt::insertion_sort Struct Reference

Function object for performing insertion sort. - More...

+ More...

#include <algorithm.hpp>

- + @@ -200,12 +193,12 @@ template<typename Event > -

Definition at line 288 of file emitter.hpp.

+

Definition at line 299 of file emitter.hpp.

- -

◆ clear() [2/2]

+ +

◆ clear() [2/2]

@@ -216,7 +209,7 @@ template<typename Derived >
@@ -59,7 +59,7 @@ $(function() {
@@ -67,67 +67,67 @@ $(function() { Public Types | Public Member Functions | Protected Member Functions | -List of all members
+List of all members
-
entt::Process< Derived, Delta > Class Template Reference
+
entt::process< Derived, Delta > Class Template Reference

Base class for processes. - More...

+ More...

#include <process.hpp>

void entt::Emitter< Derived >::clear void entt::emitter< Derived >::clear ( ) - + @@ -232,12 +225,12 @@ template<typename Derived >

Disconnects all the listeners.

All the connections previously returned are invalidated. Using them results in undefined behavior.

-

Definition at line 298 of file emitter.hpp.

+

Definition at line 309 of file emitter.hpp.

- -

◆ empty() [1/2]

+ +

◆ empty() [1/2]

@@ -250,7 +243,7 @@ template<typename Event >
@@ -59,29 +59,29 @@ $(function() {
-
entt::Process< Derived, Delta > Member List
+
entt::process< Derived, Delta > Member List
-

This is the complete list of members for entt::Process< Derived, Delta >, including all inherited members.

+

This is the complete list of members for entt::process< Derived, Delta >, including all inherited members.

void entt::Emitter< Derived >::clear void entt::emitter< Derived >::clear ( ) - + @@ -272,12 +265,12 @@ template<typename Event >
Returns
True if there are no listeners registered, false otherwise.
-

Definition at line 310 of file emitter.hpp.

+

Definition at line 321 of file emitter.hpp.

- -

◆ empty() [2/2]

+ +

◆ empty() [2/2]

@@ -288,7 +281,7 @@ template<typename Derived >
@@ -59,23 +59,23 @@ $(function() {
-
entt::Dispatcher Member List
+
entt::meta_prop Member List
-

This is the complete list of members for entt::Dispatcher, including all inherited members.

+

This is the complete list of members for entt::meta_prop, including all inherited members.

bool entt::Emitter< Derived >::empty bool entt::emitter< Derived >::empty ( ) const - + @@ -304,12 +297,12 @@ template<typename Derived >

Checks if there are listeners registered with the event emitter.

Returns
True if there are no listeners registered, false otherwise.
-

Definition at line 322 of file emitter.hpp.

+

Definition at line 329 of file emitter.hpp.

- -

◆ erase()

+ +

◆ erase()

@@ -322,9 +315,9 @@ template<typename Event >
@@ -59,23 +59,23 @@ $(function() {
-
entt::HashedString Member List
+
entt::meta_dtor Member List
-

This is the complete list of members for entt::HashedString, including all inherited members.

+

This is the complete list of members for entt::meta_dtor, including all inherited members.

bool entt::Emitter< Derived >::empty bool entt::emitter< Derived >::empty ( ) const - + - + @@ -351,12 +344,12 @@ template<typename Event > -

Definition at line 275 of file emitter.hpp.

+

Definition at line 286 of file emitter.hpp.

- -

◆ on()

+ +

◆ on()

@@ -369,10 +362,10 @@ template<typename Event >
- - -
void entt::Emitter< Derived >::erase void entt::emitter< Derived >::erase (Connection< Event > connection< Event >  conn)
- + - - + +
Connection<Event> entt::Emitter< Derived >::on connection<Event> entt::emitter< Derived >::on (Listener< Event > listener)listener< Event > instance)
@@ -396,18 +389,18 @@ template<typename Event >
Parameters
- +
listenerThe listener to register.
instanceThe listener to register.
-
Returns
Connection object that can be used to disconnect the listener.
+
Returns
Connection object that can be used to disconnect the listener.
-

Definition at line 236 of file emitter.hpp.

+

Definition at line 247 of file emitter.hpp.

- -

◆ once()

+ +

◆ once()

@@ -420,10 +413,10 @@ template<typename Event >
- + - - + +
Connection<Event> entt::Emitter< Derived >::once connection<Event> entt::emitter< Derived >::once (Listener< Event > listener)listener< Event > instance)
@@ -447,18 +440,18 @@ template<typename Event >
Parameters
- +
listenerThe listener to register.
instanceThe listener to register.
-
Returns
Connection object that can be used to disconnect the listener.
+
Returns
Connection object that can be used to disconnect the listener.
-

Definition at line 261 of file emitter.hpp.

+

Definition at line 272 of file emitter.hpp.

- -

◆ operator=() [1/2]

+ +

◆ operator=()

@@ -469,40 +462,9 @@ template<typename Derived >
- + - - - - -
Emitter& entt::Emitter< Derived >::operator= emitter& entt::emitter< Derived >::operator= (const Emitter< Derived > & )
- 		-delete
-
- -

Copying an emitter isn't allowed.

-
Returns
This emitter.
- -
- - -

◆ operator=() [2/2]

- -
-
-
-template<typename Derived >
- - - @@ -59,19 +59,19 @@ $(function() {
-
entt::Identifier< Types > Member List
+
entt::identifier< Types > Member List
-

This is the complete list of members for entt::Identifier< Types >, including all inherited members.

+

This is the complete list of members for entt::identifier< Types >, including all inherited members.

- - - - - + @@ -519,8 +481,8 @@ template<typename Derived > - -

◆ publish()

+ +

◆ publish()

@@ -533,7 +495,7 @@ template<typename Event , typename... Args>
@@ -59,82 +59,48 @@ $(function() {
Public Types | -Static Public Member Functions | -List of all members
+Static Public Attributes | +List of all members
-
entt::Family<... > Class Template Reference
+
entt::family<... > Class Template Reference

Dynamic identifier generator. - More...

+ More...

#include <family.hpp>

Emitter& entt::Emitter< Derived >::operator= (Emitter< Derived > && emitter< Derived > &&  )
- + @@ -563,7 +525,7 @@ template<typename Event , typename... Args> -

Definition at line 211 of file emitter.hpp.

+

Definition at line 222 of file emitter.hpp.

diff --git a/classentt_1_1Family-members.html b/classentt_1_1family-members.html similarity index 80% rename from classentt_1_1Family-members.html rename to classentt_1_1family-members.html index 894203000..ef1166013 100644 --- a/classentt_1_1Family-members.html +++ b/classentt_1_1family-members.html @@ -22,7 +22,7 @@ @@ -59,19 +59,19 @@ $(function() {
-
entt::Family<... > Member List
+
entt::family<... > Member List
-

This is the complete list of members for entt::Family<... >, including all inherited members.

+

This is the complete list of members for entt::family<... >, including all inherited members.

void entt::Emitter< Derived >::publish void entt::emitter< Derived >::publish ( Args &&...  args)
EnTT -  2.7.3 +  3.0.0
- - + +
family_type typedefentt::Family<... >
type() ENTT_NOEXCEPTentt::Family<... >inlinestatic
family_type typedefentt::family<... >
typeentt::family<... >inlinestatic
diff --git a/classentt_1_1Family.html b/classentt_1_1family.html similarity index 53% rename from classentt_1_1Family.html rename to classentt_1_1family.html index ecfadb1a0..3a3b1b52b 100644 --- a/classentt_1_1Family.html +++ b/classentt_1_1family.html @@ -5,7 +5,7 @@ -EnTT: entt::Family<... > Class Template Reference +EnTT: entt::family<... > Class Template Reference @@ -22,7 +22,7 @@
EnTT -  2.7.3 +  3.0.0
- - - + + +

Public Types

-using family_type = std::size_t
 Unsigned integer type.
 
+using family_type = ENTT_ID_TYPE
 Unsigned integer type.
 
- - - - - + + + + +

-Static Public Member Functions

template<typename... Type>
static family_type type () ENTT_NOEXCEPT
 Returns an unique identifier for the given type. More...
 

+Static Public Attributes

+template<typename... Type>
static const family_type type = inner<std::decay_t<Type>...>
 Statically generated unique identifier for the given type.
 

Detailed Description

template<typename...>
-class entt::Family<... >

+class entt::family<... >

Dynamic identifier generator.

Utility class template that can be used to assign unique identifiers to types at runtime. Use different specializations to create separate sets of identifiers.

-

Definition at line 22 of file family.hpp.

-

Member Function Documentation

- -

◆ type()

- -
-
-
-template<typename... >
-
-template<typename... Type>
- - - - - -
- - - - - - - -
static family_type entt::Family<... >::type ()
- 		-inlinestatic
-
- -

Returns an unique identifier for the given type.

-
Returns
Statically generated unique identifier for the given type.
- -

Definition at line 40 of file family.hpp.

- -
-
-
The documentation for this class was generated from the following file:
    +

    Definition at line 20 of file family.hpp.

    +
    The documentation for this class was generated from the following file: diff --git a/classentt_1_1hashed__string-members.html b/classentt_1_1hashed__string-members.html new file mode 100644 index 000000000..ced14d1c9 --- /dev/null +++ b/classentt_1_1hashed__string-members.html @@ -0,0 +1,93 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
    +
    + + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +
    entt::hashed_string Member List
    +
    +
    + +

    This is the complete list of members for entt::hashed_string, including all inherited members.

    + + + + + + + + + + + + + +
    data() const ENTT_NOEXCEPTentt::hashed_stringinline
    hash_type typedefentt::hashed_string
    hashed_string() ENTT_NOEXCEPTentt::hashed_stringinline
    hashed_string(const char(&curr)[N]) ENTT_NOEXCEPTentt::hashed_stringinline
    hashed_string(const_wrapper wrapper) ENTT_NOEXCEPTentt::hashed_stringinlineexplicit
    operator const char *() const ENTT_NOEXCEPTentt::hashed_stringinline
    operator hash_type() const ENTT_NOEXCEPTentt::hashed_stringinline
    operator==(const hashed_string &other) const ENTT_NOEXCEPTentt::hashed_stringinline
    to_value(const char(&str)[N]) ENTT_NOEXCEPTentt::hashed_stringinlinestatic
    to_value(const_wrapper wrapper) ENTT_NOEXCEPTentt::hashed_stringinlinestatic
    to_value(const char *str, std::size_t size) ENTT_NOEXCEPTentt::hashed_stringinlinestatic
    value() const ENTT_NOEXCEPTentt::hashed_stringinline
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/classentt_1_1hashed__string.html b/classentt_1_1hashed__string.html new file mode 100644 index 000000000..388891665 --- /dev/null +++ b/classentt_1_1hashed__string.html @@ -0,0 +1,519 @@ + + + + + + + +EnTT: entt::hashed_string Class Reference + + + + + + + + + +
    +
    + + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +Classes | +Public Types | +Public Member Functions | +Static Public Member Functions | +List of all members
    +
    +
    entt::hashed_string Class Reference
    +
    +
    + +

    Zero overhead unique identifier. + More...

    + +

    #include <hashed_string.hpp>

    + + + + + +

    +Public Types

    +using hash_type = ENTT_ID_TYPE
     Unsigned integer type.
     
    + + + + + + + + + + + + + + + + + + + + + + + + + + +

    +Public Member Functions

    +constexpr hashed_string () ENTT_NOEXCEPT
     Constructs an empty hashed string.
     
    template<std::size_t N>
    constexpr hashed_string (const char(&curr)[N]) ENTT_NOEXCEPT
     Constructs a hashed string from an array of const chars. More...
     
    constexpr hashed_string (const_wrapper wrapper) ENTT_NOEXCEPT
     Explicit constructor on purpose to avoid constructing a hashed string directly from a const char *. More...
     
    constexpr const char * data () const ENTT_NOEXCEPT
     Returns the human-readable representation of a hashed string. More...
     
    constexpr hash_type value () const ENTT_NOEXCEPT
     Returns the numeric representation of a hashed string. More...
     
    constexpr operator const char * () const ENTT_NOEXCEPT
     Returns the human-readable representation of a hashed string. More...
     
    constexpr operator hash_type () const ENTT_NOEXCEPT
     Returns the numeric representation of a hashed string. More...
     
    constexpr bool operator== (const hashed_string &other) const ENTT_NOEXCEPT
     Compares two hashed strings. More...
     
    + + + + + + + + + + + +

    +Static Public Member Functions

    template<std::size_t N>
    static constexpr hash_type to_value (const char(&str)[N]) ENTT_NOEXCEPT
     Returns directly the numeric representation of a string. More...
     
    static hash_type to_value (const_wrapper wrapper) ENTT_NOEXCEPT
     Returns directly the numeric representation of a string. More...
     
    static hash_type to_value (const char *str, std::size_t size) ENTT_NOEXCEPT
     Returns directly the numeric representation of a string view. More...
     
    +

    Detailed Description

    +

    Zero overhead unique identifier.

    +

    TURN_OFF_DOXYGEN A hashed string is a compile-time tool that allows users to use human-readable identifers in the codebase while using their numeric counterparts at runtime.
    + Because of that, a hashed string can also be used in constant expressions if required.

    + +

    Definition at line 57 of file hashed_string.hpp.

    +

    Constructor & Destructor Documentation

    + +

    ◆ hashed_string() [1/2]

    + +
    +
    +
    +template<std::size_t N>
    + + + + + +
    + + + + + + + + +
    constexpr entt::hashed_string::hashed_string (const char(&) curr[N])
    +     		+inline
    +
    + +

    Constructs a hashed string from an array of const chars.

    +

    Forcing template resolution avoids implicit conversions. An human-readable identifier can be anything but a plain, old bunch of characters.
    + Example of use:

    hashed_string hs{"my.png"};
    Template Parameters
    + + +
    NNumber of characters of the identifier.
    +
    +
    +
    Parameters
    + + +
    currHuman-readable identifer.
    +
    +
    + +

    Definition at line 136 of file hashed_string.hpp.

    + +
    +
    + +

    ◆ hashed_string() [2/2]

    + +
    +
    + + + + + +
    + + + + + + + + +
    constexpr entt::hashed_string::hashed_string (const_wrapper wrapper)
    +     		+inlineexplicit
    +
    + +

    Explicit constructor on purpose to avoid constructing a hashed string directly from a const char *.

    +
    Parameters
    + + +
    wrapperHelps achieving the purpose by relying on overloading.
    +
    +
    + +

    Definition at line 145 of file hashed_string.hpp.

    + +
    +
    +

    Member Function Documentation

    + +

    ◆ data()

    + +
    +
    + + + + + +
    + + + + + + + +
    constexpr const char* entt::hashed_string::data () const
    +     		+inline
    +
    + +

    Returns the human-readable representation of a hashed string.

    +
    Returns
    The string used to initialize the instance.
    + +

    Definition at line 153 of file hashed_string.hpp.

    + +
    +
    + +

    ◆ operator const char *()

    + +
    +
    + + + + + +
    + + + + + + + +
    constexpr entt::hashed_string::operator const char * () const
    +     		+inline
    +
    + +

    Returns the human-readable representation of a hashed string.

    +
    Returns
    The string used to initialize the instance.
    + +

    Definition at line 169 of file hashed_string.hpp.

    + +
    +
    + +

    ◆ operator hash_type()

    + +
    +
    + + + + + +
    + + + + + + + +
    constexpr entt::hashed_string::operator hash_type () const
    +     		+inline
    +
    + +

    Returns the numeric representation of a hashed string.

    +
    Returns
    The numeric representation of the instance.
    + +

    Definition at line 172 of file hashed_string.hpp.

    + +
    +
    + +

    ◆ operator==()

    + +
    +
    + + + + + +
    + + + + + + + + +
    constexpr bool entt::hashed_string::operator== (const hashed_string & other) const
    +     		+inline
    +
    + +

    Compares two hashed strings.

    +
    Parameters
    + + +
    otherHashed string with which to compare.
    +
    +
    +
    Returns
    True if the two hashed strings are identical, false otherwise.
    + +

    Definition at line 179 of file hashed_string.hpp.

    + +
    +
    + +

    ◆ to_value() [1/3]

    + +
    +
    +
    +template<std::size_t N>
    + + + + + +
    + + + + + + + + +
    static constexpr hash_type entt::hashed_string::to_value (const char(&) str[N])
    +     		+inlinestatic
    +
    + +

    Returns directly the numeric representation of a string.

    +

    Forcing template resolution avoids implicit conversions. An human-readable identifier can be anything but a plain, old bunch of characters.
    + Example of use:

    const auto value = hashed_string::to_value("my.png");
    Template Parameters
    + + +
    NNumber of characters of the identifier.
    +
    +
    +
    Parameters
    + + +
    strHuman-readable identifer.
    +
    +
    +
    Returns
    The numeric representation of the string.
    + +

    Definition at line 91 of file hashed_string.hpp.

    + +
    +
    + +

    ◆ to_value() [2/3]

    + +
    +
    + + + + + +
    + + + + + + + + +
    static hash_type entt::hashed_string::to_value (const_wrapper wrapper)
    +     		+inlinestatic
    +
    + +

    Returns directly the numeric representation of a string.

    +
    Parameters
    + + +
    wrapperHelps achieving the purpose by relying on overloading.
    +
    +
    +
    Returns
    The numeric representation of the string.
    + +

    Definition at line 100 of file hashed_string.hpp.

    + +
    +
    + +

    ◆ to_value() [3/3]

    + +
    +
    + + + + + +
    + + + + + + + + + + + + + + + + + + +
    static hash_type entt::hashed_string::to_value (const char * str,
    std::size_t size 
    )
    +     		+inlinestatic
    +
    + +

    Returns directly the numeric representation of a string view.

    +
    Parameters
    + + + +
    strHuman-readable identifer.
    sizeLength of the string to hash.
    +
    +
    +
    Returns
    The numeric representation of the string.
    + +

    Definition at line 110 of file hashed_string.hpp.

    + +
    +
    + +

    ◆ value()

    + +
    +
    + + + + + +
    + + + + + + + +
    constexpr hash_type entt::hashed_string::value () const
    +     		+inline
    +
    + +

    Returns the numeric representation of a hashed string.

    +
    Returns
    The numeric representation of the instance.
    + +

    Definition at line 161 of file hashed_string.hpp.

    + +
    +
    +
    The documentation for this class was generated from the following file: +
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/classentt_1_1Identifier-members.html b/classentt_1_1identifier-members.html similarity index 77% rename from classentt_1_1Identifier-members.html rename to classentt_1_1identifier-members.html index 05eda48b4..33fd38663 100644 --- a/classentt_1_1Identifier-members.html +++ b/classentt_1_1identifier-members.html @@ -22,7 +22,7 @@
EnTT -  2.7.3 +  3.0.0
- - + +
get() ENTT_NOEXCEPTentt::Identifier< Types >inlinestatic
identifier_type typedefentt::Identifier< Types >
identifier_type typedefentt::identifier< Types >
typeentt::identifier< Types >static
diff --git a/classentt_1_1identifier.html b/classentt_1_1identifier.html new file mode 100644 index 000000000..c876453b2 --- /dev/null +++ b/classentt_1_1identifier.html @@ -0,0 +1,121 @@ + + + + + + + +EnTT: entt::identifier< Types > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+Public Types | +Static Public Attributes | +List of all members
+
+
entt::identifier< Types > Class Template Reference
+
+
+ +

Types identifiers. + More...

+ +

#include <ident.hpp>

+ + + + + +

+Public Types

+using identifier_type = ENTT_ID_TYPE
 Unsigned integer type.
 
+ + + + + +

+Static Public Attributes

+template<typename Type >
static constexpr identifier_type type = get<std::decay_t<Type>>(std::make_index_sequence<sizeof...(Types)>{})
 Statically generated unique identifier for the given type.
 
+

Detailed Description

+

template<typename... Types>
+class entt::identifier< Types >

+ +

Types identifiers.

+

Variable template used to generate identifiers at compile-time for the given types. Use the get member function to know what's the identifier associated to the specific type.

+
Note
Identifiers are constant expression and can be used in any context where such an expression is required. As an example:
using id = entt::identifier<a_type, another_type>;
switch(a_type_identifier) {
case id::type<a_type>:
// ...
break;
case id::type<another_type>:
// ...
break;
default:
// ...
}
+
Template Parameters
+ + +
TypesList of types for which to generate identifiers.
+
+
+ +

Definition at line 42 of file ident.hpp.

+
The documentation for this class was generated from the following file: +
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1meta__any-members.html b/classentt_1_1meta__any-members.html new file mode 100644 index 000000000..9188d5861 --- /dev/null +++ b/classentt_1_1meta__any-members.html @@ -0,0 +1,100 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
entt::meta_any Member List
+
+
+ +

This is the complete list of members for entt::meta_any, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + +
can_cast() const ENTT_NOEXCEPTentt::meta_anyinline
can_convert() const ENTT_NOEXCEPTentt::meta_anyinline
cast() const ENTT_NOEXCEPTentt::meta_anyinline
cast() ENTT_NOEXCEPTentt::meta_anyinline
convert() const ENTT_NOEXCEPTentt::meta_anyinline
convert() ENTT_NOEXCEPTentt::meta_anyinline
data() const ENTT_NOEXCEPTentt::meta_anyinline
data() ENTT_NOEXCEPTentt::meta_anyinline
meta_any() ENTT_NOEXCEPTentt::meta_anyinline
meta_any(Type &&type)entt::meta_anyinline
meta_any(const meta_any &other)entt::meta_anyinline
meta_any(meta_any &&other) ENTT_NOEXCEPTentt::meta_anyinline
meta_handle classentt::meta_anyfriend
operator bool() const ENTT_NOEXCEPTentt::meta_anyinlineexplicit
operator=(meta_any other)entt::meta_anyinline
operator==(const meta_any &other) const ENTT_NOEXCEPTentt::meta_anyinline
swap(meta_any &lhs, meta_any &rhs)entt::meta_anyfriend
type() const ENTT_NOEXCEPTentt::meta_anyinline
~meta_any()entt::meta_anyinline
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1meta__any.html b/classentt_1_1meta__any.html new file mode 100644 index 000000000..410624d72 --- /dev/null +++ b/classentt_1_1meta__any.html @@ -0,0 +1,768 @@ + + + + + + + +EnTT: entt::meta_any Class Reference + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+Public Member Functions | +Friends | +List of all members
+
+
entt::meta_any Class Reference
+
+
+ +

Meta any object. + More...

+ +

#include <meta.hpp>

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+ meta_any () ENTT_NOEXCEPT
 Default constructor.
 
template<typename Type , typename = std::enable_if_t<!std::is_same_v<std::remove_cv_t<std::remove_reference_t<Type>>, meta_any>>>
 meta_any (Type &&type)
 Constructs a meta any from a given value. More...
 
 meta_any (const meta_any &other)
 Copy constructor. More...
 
 meta_any (meta_any &&other) ENTT_NOEXCEPT
 Move constructor. More...
 
+ ~meta_any ()
 Frees the internal storage, whatever it means.
 
meta_any & operator= (meta_any other)
 Assignment operator. More...
 
meta_type type () const ENTT_NOEXCEPT
 Returns the meta type of the underlying object. More...
 
const void * data () const ENTT_NOEXCEPT
 Returns an opaque pointer to the contained instance. More...
 
void * data () ENTT_NOEXCEPT
 Returns an opaque pointer to the contained instance. More...
 
template<typename Type >
bool can_cast () const ENTT_NOEXCEPT
 Checks if it's possible to cast an instance to a given type. More...
 
template<typename Type >
const Type & cast () const ENTT_NOEXCEPT
 Tries to cast an instance to a given type. More...
 
template<typename Type >
Type & cast () ENTT_NOEXCEPT
 Tries to cast an instance to a given type. More...
 
template<typename Type >
bool can_convert () const ENTT_NOEXCEPT
 Checks if it's possible to convert an instance to a given type. More...
 
template<typename Type >
meta_any convert () const ENTT_NOEXCEPT
 Tries to convert an instance to a given type and returns it. More...
 
template<typename Type >
bool convert () ENTT_NOEXCEPT
 Tries to convert an instance to a given type. More...
 
 operator bool () const ENTT_NOEXCEPT
 Returns false if a container is empty, true otherwise. More...
 
bool operator== (const meta_any &other) const ENTT_NOEXCEPT
 Checks if two containers differ in their content. More...
 
+ + + + + + + +

+Friends

+class meta_handle
 A meta handle is allowed to inherit from a meta any.
 
void swap (meta_any &lhs, meta_any &rhs)
 Swaps two meta any objects. More...
 
+

Detailed Description

+

Meta any object.

+

TURN_OFF_DOXYGEN A meta any is an opaque container for single values of any type.

+

This class uses a technique called small buffer optimization (SBO) to completely eliminate the need to allocate memory, where possible.
+ From the user's point of view, nothing will change, but the elimination of allocations will reduce the jumps in memory and therefore will avoid chasing of pointers. This will greatly improve the use of the cache, thus increasing the overall performance.

+ +

Definition at line 302 of file meta.hpp.

+

Constructor & Destructor Documentation

+ +

◆ meta_any() [1/3]

+ +
+
+
+template<typename Type , typename = std::enable_if_t<!std::is_same_v<std::remove_cv_t<std::remove_reference_t<Type>>, meta_any>>>
+ + + + + +
+ + + + + + + + +
entt::meta_any::meta_any (Type && type)
+ 		+inline
+
+ +

Constructs a meta any from a given value.

+

This class uses a technique called small buffer optimization (SBO) to completely eliminate the need to allocate memory, where possible.
+ From the user's point of view, nothing will change, but the elimination of allocations will reduce the jumps in memory and therefore will avoid chasing of pointers. This will greatly improve the use of the cache, thus increasing the overall performance.

+
Template Parameters
+ + +
TypeType of object to use to initialize the container.
+
+
+
Parameters
+ + +
typeAn instance of an object to use to initialize the container.
+
+
+ +

Definition at line 382 of file meta.hpp.

+ +
+
+ +

◆ meta_any() [2/3]

+ +
+
+ + + + + +
+ + + + + + + + +
entt::meta_any::meta_any (const meta_any & other)
+ 		+inline
+
+ +

Copy constructor.

+
Parameters
+ + +
otherThe instance to copy from.
+
+
+ +

Definition at line 408 of file meta.hpp.

+ +
+
+ +

◆ meta_any() [3/3]

+ +
+
+ + + + + +
+ + + + + + + + +
entt::meta_any::meta_any (meta_any && other)
+ 		+inline
+
+ +

Move constructor.

+

After meta any move construction, instances that have been moved from are placed in a valid but unspecified state. It's highly discouraged to continue using them.

+
Parameters
+ + +
otherThe instance to move from.
+
+
+ +

Definition at line 429 of file meta.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ can_cast()

+ +
+
+
+template<typename Type >
+ + + + + +
+ + + + + + + +
bool entt::meta_any::can_cast () const
+ 		+inline
+
+ +

Checks if it's possible to cast an instance to a given type.

+
Template Parameters
+ + +
TypeType to which to cast the instance.
+
+
+
Returns
True if the cast is viable, false otherwise.
+ +

Definition at line 477 of file meta.hpp.

+ +
+
+ +

◆ can_convert()

+ +
+
+
+template<typename Type >
+ + + + + +
+ + + + + + + +
bool entt::meta_any::can_convert () const
+ 		+inline
+
+ +

Checks if it's possible to convert an instance to a given type.

+
Template Parameters
+ + +
TypeType to which to convert the instance.
+
+
+
Returns
True if the conversion is viable, false otherwise.
+ +

Definition at line 514 of file meta.hpp.

+ +
+
+ +

◆ cast() [1/2]

+ +
+
+
+template<typename Type >
+ + + + + +
+ + + + + + + +
const Type& entt::meta_any::cast () const
+ 		+inline
+
+ +

Tries to cast an instance to a given type.

+

The type of the instance must be such that the cast is possible.

+
Warning
Attempting to perform a cast that isn't viable results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode in case the cast is not feasible.
+
Template Parameters
+ + +
TypeType to which to cast the instance.
+
+
+
Returns
A reference to the contained instance.
+ +

Definition at line 497 of file meta.hpp.

+ +
+
+ +

◆ cast() [2/2]

+ +
+
+
+template<typename Type >
+ + + + + +
+ + + + + + + +
Type& entt::meta_any::cast ()
+ 		+inline
+
+ +

Tries to cast an instance to a given type.

+

The type of the instance must be such that the cast is possible.

+
Warning
Attempting to perform a cast that isn't viable results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode in case the cast is not feasible.
+
Template Parameters
+ + +
TypeType to which to cast the instance.
+
+
+
Returns
A reference to the contained instance.
+ +

Definition at line 504 of file meta.hpp.

+ +
+
+ +

◆ convert() [1/2]

+ +
+
+
+template<typename Type >
+ + + + + +
+ + + + + + + +
meta_any entt::meta_any::convert () const
+ 		+inline
+
+ +

Tries to convert an instance to a given type and returns it.

+
Template Parameters
+ + +
TypeType to which to convert the instance.
+
+
+
Returns
A valid meta any object if the conversion is possible, an invalid one otherwise.
+ +

Definition at line 526 of file meta.hpp.

+ +
+
+ +

◆ convert() [2/2]

+ +
+
+
+template<typename Type >
+ + + + + +
+ + + + + + + +
bool entt::meta_any::convert ()
+ 		+inline
+
+ +

Tries to convert an instance to a given type.

+
Template Parameters
+ + +
TypeType to which to convert the instance.
+
+
+
Returns
True if the conversion is possible, false otherwise.
+ +

Definition at line 551 of file meta.hpp.

+ +
+
+ +

◆ data() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
const void* entt::meta_any::data () const
+ 		+inline
+
+ +

Returns an opaque pointer to the contained instance.

+
Returns
An opaque pointer the contained instance, if any.
+ +

Definition at line 462 of file meta.hpp.

+ +
+
+ +

◆ data() [2/2]

+ +
+
+ + + + + +
+ + + + + + + +
void* entt::meta_any::data ()
+ 		+inline
+
+ +

Returns an opaque pointer to the contained instance.

+
Returns
An opaque pointer the contained instance, if any.
+ +

Definition at line 467 of file meta.hpp.

+ +
+
+ +

◆ operator bool()

+ +
+
+ + + + + +
+ + + + + + + +
entt::meta_any::operator bool () const
+ 		+inlineexplicit
+
+ +

Returns false if a container is empty, true otherwise.

+
Returns
False if the container is empty, true otherwise.
+ +

Definition at line 570 of file meta.hpp.

+ +
+
+ +

◆ operator=()

+ +
+
+ + + + + +
+ + + + + + + + +
meta_any& entt::meta_any::operator= (meta_any other)
+ 		+inline
+
+ +

Assignment operator.

+
Parameters
+ + +
otherThe instance to assign.
+
+
+
Returns
This meta any object.
+ +

Definition at line 447 of file meta.hpp.

+ +
+
+ +

◆ operator==()

+ +
+
+ + + + + +
+ + + + + + + + +
bool entt::meta_any::operator== (const meta_any & other) const
+ 		+inline
+
+ +

Checks if two containers differ in their content.

+
Parameters
+ + +
otherContainer with which to compare.
+
+
+
Returns
False if the two containers differ in their content, true otherwise.
+ +

Definition at line 580 of file meta.hpp.

+ +
+
+ +

◆ type()

+ +
+
+ + + + + +
+ + + + + + + +
meta_type entt::meta_any::type () const
+ 		+inline
+
+ +

Returns the meta type of the underlying object.

+
Returns
The meta type of the underlying object, if any.
+ +

Definition at line 1942 of file meta.hpp.

+ +
+
+

Friends And Related Function Documentation

+ +

◆ swap

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void swap (meta_any & lhs,
meta_any & rhs 
)
+ 		+friend
+
+ +

Swaps two meta any objects.

+
Parameters
+ + + +
lhsA valid meta any object.
rhsA valid meta any object.
+
+
+ +

Definition at line 589 of file meta.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1meta__base-members.html b/classentt_1_1meta__base-members.html new file mode 100644 index 000000000..784e7360a --- /dev/null +++ b/classentt_1_1meta__base-members.html @@ -0,0 +1,88 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
entt::meta_base Member List
+
+
+ +

This is the complete list of members for entt::meta_base, including all inherited members.

+ + + + + + + + +
cast(void *instance) const ENTT_NOEXCEPTentt::meta_baseinline
meta_base() ENTT_NOEXCEPTentt::meta_baseinline
meta_factory classentt::meta_basefriend
operator bool() const ENTT_NOEXCEPTentt::meta_baseinlineexplicit
operator==(const meta_base &other) const ENTT_NOEXCEPTentt::meta_baseinline
parent() const ENTT_NOEXCEPTentt::meta_baseinline
type() const ENTT_NOEXCEPTentt::meta_baseinline
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1meta__base.html b/classentt_1_1meta__base.html new file mode 100644 index 000000000..3fedee149 --- /dev/null +++ b/classentt_1_1meta__base.html @@ -0,0 +1,291 @@ + + + + + + + +EnTT: entt::meta_base Class Reference + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+Public Member Functions | +Friends | +List of all members
+
+
entt::meta_base Class Reference
+
+
+ +

Meta base object. + More...

+ +

#include <meta.hpp>

+ + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+ meta_base () ENTT_NOEXCEPT
 Default constructor.
 
meta_type parent () const ENTT_NOEXCEPT
 Returns the meta type to which a meta base belongs. More...
 
meta_type type () const ENTT_NOEXCEPT
 Returns the meta type of a given meta base. More...
 
void * cast (void *instance) const ENTT_NOEXCEPT
 Casts an instance from a parent type to a base type. More...
 
 operator bool () const ENTT_NOEXCEPT
 Returns true if a meta object is valid, false otherwise. More...
 
bool operator== (const meta_base &other) const ENTT_NOEXCEPT
 Checks if two meta objects refer to the same node. More...
 
+ + + + + +

+Friends

+template<typename >
class meta_factory
 A meta factory is allowed to create meta objects.
 
+

Detailed Description

+

Meta base object.

+

A meta base is an opaque container for a base class to be used to walk through hierarchies.

+ +

Definition at line 810 of file meta.hpp.

+

Member Function Documentation

+ +

◆ cast()

+ +
+
+ + + + + +
+ + + + + + + + +
void* entt::meta_base::cast (void * instance) const
+ 		+inline
+
+ +

Casts an instance from a parent type to a base type.

+
Parameters
+ + +
instanceThe instance to cast.
+
+
+
Returns
An opaque pointer to the base type.
+ +

Definition at line 841 of file meta.hpp.

+ +
+
+ +

◆ operator bool()

+ +
+
+ + + + + +
+ + + + + + + +
entt::meta_base::operator bool () const
+ 		+inlineexplicit
+
+ +

Returns true if a meta object is valid, false otherwise.

+
Returns
True if the meta object is valid, false otherwise.
+ +

Definition at line 849 of file meta.hpp.

+ +
+
+ +

◆ operator==()

+ +
+
+ + + + + +
+ + + + + + + + +
bool entt::meta_base::operator== (const meta_base & other) const
+ 		+inline
+
+ +

Checks if two meta objects refer to the same node.

+
Parameters
+ + +
otherThe meta object with which to compare.
+
+
+
Returns
True if the two meta objects refer to the same node, false otherwise.
+ +

Definition at line 859 of file meta.hpp.

+ +
+
+ +

◆ parent()

+ +
+
+ + + + + +
+ + + + + + + +
meta_type entt::meta_base::parent () const
+ 		+inline
+
+ +

Returns the meta type to which a meta base belongs.

+
Returns
The meta type to which the meta base belongs.
+ +

Definition at line 1952 of file meta.hpp.

+ +
+
+ +

◆ type()

+ +
+
+ + + + + +
+ + + + + + + +
meta_type entt::meta_base::type () const
+ 		+inline
+
+ +

Returns the meta type of a given meta base.

+
Returns
The meta type of the meta base.
+ +

Definition at line 1957 of file meta.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1meta__conv-members.html b/classentt_1_1meta__conv-members.html new file mode 100644 index 000000000..f3582158f --- /dev/null +++ b/classentt_1_1meta__conv-members.html @@ -0,0 +1,88 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
entt::meta_conv Member List
+
+
+ +

This is the complete list of members for entt::meta_conv, including all inherited members.

+ + + + + + + + +
convert(void *instance) const ENTT_NOEXCEPTentt::meta_convinline
meta_conv() ENTT_NOEXCEPTentt::meta_convinline
meta_factory classentt::meta_convfriend
operator bool() const ENTT_NOEXCEPTentt::meta_convinlineexplicit
operator==(const meta_conv &other) const ENTT_NOEXCEPTentt::meta_convinline
parent() const ENTT_NOEXCEPTentt::meta_convinline
type() const ENTT_NOEXCEPTentt::meta_convinline
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1meta__conv.html b/classentt_1_1meta__conv.html new file mode 100644 index 000000000..5c6cced41 --- /dev/null +++ b/classentt_1_1meta__conv.html @@ -0,0 +1,291 @@ + + + + + + + +EnTT: entt::meta_conv Class Reference + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+Public Member Functions | +Friends | +List of all members
+
+
entt::meta_conv Class Reference
+
+
+ +

Meta conversion function object. + More...

+ +

#include <meta.hpp>

+ + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+ meta_conv () ENTT_NOEXCEPT
 Default constructor.
 
meta_type parent () const ENTT_NOEXCEPT
 Returns the meta type to which a meta conversion function belongs. More...
 
meta_type type () const ENTT_NOEXCEPT
 Returns the meta type of a given meta conversion function. More...
 
meta_any convert (void *instance) const ENTT_NOEXCEPT
 Converts an instance to a given type. More...
 
 operator bool () const ENTT_NOEXCEPT
 Returns true if a meta object is valid, false otherwise. More...
 
bool operator== (const meta_conv &other) const ENTT_NOEXCEPT
 Checks if two meta objects refer to the same node. More...
 
+ + + + + +

+Friends

+template<typename >
class meta_factory
 A meta factory is allowed to create meta objects.
 
+

Detailed Description

+

Meta conversion function object.

+

A meta conversion function is an opaque container for a conversion function to be used to convert a given instance to another type.

+ +

Definition at line 885 of file meta.hpp.

+

Member Function Documentation

+ +

◆ convert()

+ +
+
+ + + + + +
+ + + + + + + + +
meta_any entt::meta_conv::convert (void * instance) const
+ 		+inline
+
+ +

Converts an instance to a given type.

+
Parameters
+ + +
instanceThe instance to convert.
+
+
+
Returns
An opaque pointer to the instance to convert.
+ +

Definition at line 916 of file meta.hpp.

+ +
+
+ +

◆ operator bool()

+ +
+
+ + + + + +
+ + + + + + + +
entt::meta_conv::operator bool () const
+ 		+inlineexplicit
+
+ +

Returns true if a meta object is valid, false otherwise.

+
Returns
True if the meta object is valid, false otherwise.
+ +

Definition at line 924 of file meta.hpp.

+ +
+
+ +

◆ operator==()

+ +
+
+ + + + + +
+ + + + + + + + +
bool entt::meta_conv::operator== (const meta_conv & other) const
+ 		+inline
+
+ +

Checks if two meta objects refer to the same node.

+
Parameters
+ + +
otherThe meta object with which to compare.
+
+
+
Returns
True if the two meta objects refer to the same node, false otherwise.
+ +

Definition at line 934 of file meta.hpp.

+ +
+
+ +

◆ parent()

+ +
+
+ + + + + +
+ + + + + + + +
meta_type entt::meta_conv::parent () const
+ 		+inline
+
+ +

Returns the meta type to which a meta conversion function belongs.

+
Returns
The meta type to which the meta conversion function belongs.
+ +

Definition at line 1962 of file meta.hpp.

+ +
+
+ +

◆ type()

+ +
+
+ + + + + +
+ + + + + + + +
meta_type entt::meta_conv::type () const
+ 		+inline
+
+ +

Returns the meta type of a given meta conversion function.

+
Returns
The meta type of the meta conversion function.
+ +

Definition at line 1967 of file meta.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1meta__ctor-members.html b/classentt_1_1meta__ctor-members.html new file mode 100644 index 000000000..8d02f6661 --- /dev/null +++ b/classentt_1_1meta__ctor-members.html @@ -0,0 +1,92 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
entt::meta_ctor Member List
+
+
+ +

This is the complete list of members for entt::meta_ctor, including all inherited members.

+ + + + + + + + + + + + +
arg(size_type index) const ENTT_NOEXCEPTentt::meta_ctorinline
invoke(Args &&... args) constentt::meta_ctorinline
meta_ctor() ENTT_NOEXCEPTentt::meta_ctorinline
meta_factory classentt::meta_ctorfriend
operator bool() const ENTT_NOEXCEPTentt::meta_ctorinlineexplicit
operator==(const meta_ctor &other) const ENTT_NOEXCEPTentt::meta_ctorinline
parent() const ENTT_NOEXCEPTentt::meta_ctorinline
prop(Op op) const ENTT_NOEXCEPTentt::meta_ctorinline
prop(Key &&key) const ENTT_NOEXCEPTentt::meta_ctorinline
size() const ENTT_NOEXCEPTentt::meta_ctorinline
size_type typedefentt::meta_ctor
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1meta__ctor.html b/classentt_1_1meta__ctor.html new file mode 100644 index 000000000..b1bdc9f68 --- /dev/null +++ b/classentt_1_1meta__ctor.html @@ -0,0 +1,446 @@ + + + + + + + +EnTT: entt::meta_ctor Class Reference + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+Public Types | +Public Member Functions | +Friends | +List of all members
+
+
entt::meta_ctor Class Reference
+
+
+ +

Meta constructor object. + More...

+ +

#include <meta.hpp>

+ + + + + +

+Public Types

+using size_type = typename internal::meta_ctor_node::size_type
 Unsigned integer type.
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+ meta_ctor () ENTT_NOEXCEPT
 Default constructor.
 
meta_type parent () const ENTT_NOEXCEPT
 Returns the meta type to which a meta constructor belongs. More...
 
size_type size () const ENTT_NOEXCEPT
 Returns the number of arguments accepted by a meta constructor. More...
 
meta_type arg (size_type index) const ENTT_NOEXCEPT
 Returns the meta type of the i-th argument of a meta constructor. More...
 
template<typename... Args>
meta_any invoke (Args &&... args) const
 Creates an instance of the underlying type, if possible. More...
 
template<typename Op >
std::enable_if_t< std::is_invocable_v< Op, meta_prop >, void > prop (Op op) const ENTT_NOEXCEPT
 Iterates all the properties assigned to a meta constructor. More...
 
template<typename Key >
std::enable_if_t<!std::is_invocable_v< Key, meta_prop >, meta_prop > prop (Key &&key) const ENTT_NOEXCEPT
 Returns the property associated with a given key. More...
 
 operator bool () const ENTT_NOEXCEPT
 Returns true if a meta object is valid, false otherwise. More...
 
bool operator== (const meta_ctor &other) const ENTT_NOEXCEPT
 Checks if two meta objects refer to the same node. More...
 
+ + + + + +

+Friends

+template<typename >
class meta_factory
 A meta factory is allowed to create meta objects.
 
+

Detailed Description

+

Meta constructor object.

+

A meta constructor is an opaque container for a function to be used to construct instances of a given type.

+ +

Definition at line 960 of file meta.hpp.

+

Member Function Documentation

+ +

◆ arg()

+ +
+
+ + + + + +
+ + + + + + + + +
meta_type entt::meta_ctor::arg (size_type index) const
+ 		+inline
+
+ +

Returns the meta type of the i-th argument of a meta constructor.

+
Parameters
+ + +
indexThe index of the argument of which to return the meta type.
+
+
+
Returns
The meta type of the i-th argument of a meta constructor, if any.
+ +

Definition at line 1977 of file meta.hpp.

+ +
+
+ +

◆ invoke()

+ +
+
+
+template<typename... Args>
+ + + + + +
+ + + + + + + + +
meta_any entt::meta_ctor::invoke (Args &&... args) const
+ 		+inline
+
+ +

Creates an instance of the underlying type, if possible.

+

To create a valid instance, the types of the parameters must coincide exactly with those required by the underlying meta constructor. Otherwise, an empty and then invalid container is returned.

+
Template Parameters
+ + +
ArgsTypes of arguments to use to construct the instance.
+
+
+
Parameters
+ + +
argsParameters to use to construct the instance.
+
+
+
Returns
A meta any containing the new instance, if any.
+ +

Definition at line 1010 of file meta.hpp.

+ +
+
+ +

◆ operator bool()

+ +
+
+ + + + + +
+ + + + + + + +
entt::meta_ctor::operator bool () const
+ 		+inlineexplicit
+
+ +

Returns true if a meta object is valid, false otherwise.

+
Returns
True if the meta object is valid, false otherwise.
+ +

Definition at line 1054 of file meta.hpp.

+ +
+
+ +

◆ operator==()

+ +
+
+ + + + + +
+ + + + + + + + +
bool entt::meta_ctor::operator== (const meta_ctor & other) const
+ 		+inline
+
+ +

Checks if two meta objects refer to the same node.

+
Parameters
+ + +
otherThe meta object with which to compare.
+
+
+
Returns
True if the two meta objects refer to the same node, false otherwise.
+ +

Definition at line 1064 of file meta.hpp.

+ +
+
+ +

◆ parent()

+ +
+
+ + + + + +
+ + + + + + + +
meta_type entt::meta_ctor::parent () const
+ 		+inline
+
+ +

Returns the meta type to which a meta constructor belongs.

+
Returns
The meta type to which the meta constructor belongs.
+ +

Definition at line 1972 of file meta.hpp.

+ +
+
+ +

◆ prop() [1/2]

+ +
+
+
+template<typename Op >
+ + + + + +
+ + + + + + + + +
std::enable_if_t<std::is_invocable_v<Op, meta_prop>, void> entt::meta_ctor::prop (Op op) const
+ 		+inline
+
+ +

Iterates all the properties assigned to a meta constructor.

+
Template Parameters
+ + +
OpType of the function object to invoke.
+
+
+
Parameters
+ + +
opA valid function object.
+
+
+ +

Definition at line 1028 of file meta.hpp.

+ +
+
+ +

◆ prop() [2/2]

+ +
+
+
+template<typename Key >
+ + + + + +
+ + + + + + + + +
std::enable_if_t<!std::is_invocable_v<Key, meta_prop>, meta_prop> entt::meta_ctor::prop (Key && key) const
+ 		+inline
+
+ +

Returns the property associated with a given key.

+
Template Parameters
+ + +
KeyType of key to use to search for a property.
+
+
+
Parameters
+ + +
keyThe key to use to search for a property.
+
+
+
Returns
The property associated with the given key, if any.
+ +

Definition at line 1042 of file meta.hpp.

+ +
+
+ +

◆ size()

+ +
+
+ + + + + +
+ + + + + + + +
size_type entt::meta_ctor::size () const
+ 		+inline
+
+ +

Returns the number of arguments accepted by a meta constructor.

+
Returns
The number of arguments accepted by the meta constructor.
+ +

Definition at line 987 of file meta.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1meta__data-members.html b/classentt_1_1meta__data-members.html new file mode 100644 index 000000000..9eafa9b20 --- /dev/null +++ b/classentt_1_1meta__data-members.html @@ -0,0 +1,96 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
entt::meta_data Member List
+
+
+ +

This is the complete list of members for entt::meta_data, including all inherited members.

+ + + + + + + + + + + + + + + + +
get(meta_handle handle) const ENTT_NOEXCEPTentt::meta_datainline
get(meta_handle handle, std::size_t index) const ENTT_NOEXCEPTentt::meta_datainline
is_const() const ENTT_NOEXCEPTentt::meta_datainline
is_static() const ENTT_NOEXCEPTentt::meta_datainline
meta_data() ENTT_NOEXCEPTentt::meta_datainline
meta_factory classentt::meta_datafriend
name() const ENTT_NOEXCEPTentt::meta_datainline
operator bool() const ENTT_NOEXCEPTentt::meta_datainlineexplicit
operator==(const meta_data &other) const ENTT_NOEXCEPTentt::meta_datainline
parent() const ENTT_NOEXCEPTentt::meta_datainline
prop(Op op) const ENTT_NOEXCEPTentt::meta_datainline
prop(Key &&key) const ENTT_NOEXCEPTentt::meta_datainline
set(meta_handle handle, Type &&value) constentt::meta_datainline
set(meta_handle handle, std::size_t index, Type &&value) constentt::meta_datainline
type() const ENTT_NOEXCEPTentt::meta_datainline
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1meta__data.html b/classentt_1_1meta__data.html new file mode 100644 index 000000000..d22575a9c --- /dev/null +++ b/classentt_1_1meta__data.html @@ -0,0 +1,672 @@ + + + + + + + +EnTT: entt::meta_data Class Reference + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+Public Member Functions | +Friends | +List of all members
+
+
entt::meta_data Class Reference
+
+
+ +

Meta data object. + More...

+ +

#include <meta.hpp>

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+ meta_data () ENTT_NOEXCEPT
 Default constructor.
 
const char * name () const ENTT_NOEXCEPT
 Returns the name assigned to a given meta data. More...
 
meta_type parent () const ENTT_NOEXCEPT
 Returns the meta type to which a meta data belongs. More...
 
bool is_const () const ENTT_NOEXCEPT
 Indicates whether a given meta data is constant or not. More...
 
bool is_static () const ENTT_NOEXCEPT
 Indicates whether a given meta data is static or not. More...
 
meta_type type () const ENTT_NOEXCEPT
 Returns the meta type of a given meta data. More...
 
template<typename Type >
bool set (meta_handle handle, Type &&value) const
 Sets the value of the variable enclosed by a given meta type. More...
 
template<typename Type >
bool set (meta_handle handle, std::size_t index, Type &&value) const
 Sets the i-th element of an array enclosed by a given meta type. More...
 
meta_any get (meta_handle handle) const ENTT_NOEXCEPT
 Gets the value of the variable enclosed by a given meta type. More...
 
meta_any get (meta_handle handle, std::size_t index) const ENTT_NOEXCEPT
 Gets the i-th element of an array enclosed by a given meta type. More...
 
template<typename Op >
std::enable_if_t< std::is_invocable_v< Op, meta_prop >, void > prop (Op op) const ENTT_NOEXCEPT
 Iterates all the properties assigned to a meta data. More...
 
template<typename Key >
std::enable_if_t<!std::is_invocable_v< Key, meta_prop >, meta_prop > prop (Key &&key) const ENTT_NOEXCEPT
 Returns the property associated with a given key. More...
 
 operator bool () const ENTT_NOEXCEPT
 Returns true if a meta object is valid, false otherwise. More...
 
bool operator== (const meta_data &other) const ENTT_NOEXCEPT
 Checks if two meta objects refer to the same node. More...
 
+ + + + + +

+Friends

+template<typename >
class meta_factory
 A meta factory is allowed to create meta objects.
 
+

Detailed Description

+

Meta data object.

+

A meta data is an opaque container for a data member associated with a given type.

+ +

Definition at line 1164 of file meta.hpp.

+

Member Function Documentation

+ +

◆ get() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
meta_any entt::meta_data::get (meta_handle handle) const
+ 		+inline
+
+ +

Gets the value of the variable enclosed by a given meta type.

+

It must be possible to cast the instance to the parent type of the meta data. Otherwise, invoking the getter results in an undefined behavior.

+
Parameters
+ + +
handleAn opaque pointer to an instance of the underlying type.
+
+
+
Returns
A meta any containing the value of the underlying variable.
+ +

Definition at line 1267 of file meta.hpp.

+ +
+
+ +

◆ get() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
meta_any entt::meta_data::get (meta_handle handle,
std::size_t index 
) const
+ 		+inline
+
+ +

Gets the i-th element of an array enclosed by a given meta type.

+

It must be possible to cast the instance to the parent type of the meta data. Otherwise, invoking the getter results in an undefined behavior.

+
Parameters
+ + + +
handleAn opaque pointer to an instance of the underlying type.
indexPosition of the underlying element to get.
+
+
+
Returns
A meta any containing the value of the underlying element.
+ +

Definition at line 1281 of file meta.hpp.

+ +
+
+ +

◆ is_const()

+ +
+
+ + + + + +
+ + + + + + + +
bool entt::meta_data::is_const () const
+ 		+inline
+
+ +

Indicates whether a given meta data is constant or not.

+
Returns
True if the meta data is constant, false otherwise.
+ +

Definition at line 1196 of file meta.hpp.

+ +
+
+ +

◆ is_static()

+ +
+
+ + + + + +
+ + + + + + + +
bool entt::meta_data::is_static () const
+ 		+inline
+
+ +

Indicates whether a given meta data is static or not.

+

A static meta data is such that it can be accessed using a null pointer as an instance.

+
Returns
True if the meta data is static, false otherwise.
+ +

Definition at line 1208 of file meta.hpp.

+ +
+
+ +

◆ name()

+ +
+
+ + + + + +
+ + + + + + + +
const char* entt::meta_data::name () const
+ 		+inline
+
+ +

Returns the name assigned to a given meta data.

+
Returns
The name assigned to the meta data.
+ +

Definition at line 1182 of file meta.hpp.

+ +
+
+ +

◆ operator bool()

+ +
+
+ + + + + +
+ + + + + + + +
entt::meta_data::operator bool () const
+ 		+inlineexplicit
+
+ +

Returns true if a meta object is valid, false otherwise.

+
Returns
True if the meta object is valid, false otherwise.
+ +

Definition at line 1319 of file meta.hpp.

+ +
+
+ +

◆ operator==()

+ +
+
+ + + + + +
+ + + + + + + + +
bool entt::meta_data::operator== (const meta_data & other) const
+ 		+inline
+
+ +

Checks if two meta objects refer to the same node.

+
Parameters
+ + +
otherThe meta object with which to compare.
+
+
+
Returns
True if the two meta objects refer to the same node, false otherwise.
+ +

Definition at line 1329 of file meta.hpp.

+ +
+
+ +

◆ parent()

+ +
+
+ + + + + +
+ + + + + + + +
meta_type entt::meta_data::parent () const
+ 		+inline
+
+ +

Returns the meta type to which a meta data belongs.

+
Returns
The meta type to which the meta data belongs.
+ +

Definition at line 1987 of file meta.hpp.

+ +
+
+ +

◆ prop() [1/2]

+ +
+
+
+template<typename Op >
+ + + + + +
+ + + + + + + + +
std::enable_if_t<std::is_invocable_v<Op, meta_prop>, void> entt::meta_data::prop (Op op) const
+ 		+inline
+
+ +

Iterates all the properties assigned to a meta data.

+
Template Parameters
+ + +
OpType of the function object to invoke.
+
+
+
Parameters
+ + +
opA valid function object.
+
+
+ +

Definition at line 1293 of file meta.hpp.

+ +
+
+ +

◆ prop() [2/2]

+ +
+
+
+template<typename Key >
+ + + + + +
+ + + + + + + + +
std::enable_if_t<!std::is_invocable_v<Key, meta_prop>, meta_prop> entt::meta_data::prop (Key && key) const
+ 		+inline
+
+ +

Returns the property associated with a given key.

+
Template Parameters
+ + +
KeyType of key to use to search for a property.
+
+
+
Parameters
+ + +
keyThe key to use to search for a property.
+
+
+
Returns
The property associated with the given key, if any.
+ +

Definition at line 1307 of file meta.hpp.

+ +
+
+ +

◆ set() [1/2]

+ +
+
+
+template<typename Type >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool entt::meta_data::set (meta_handle handle,
Type && value 
) const
+ 		+inline
+
+ +

Sets the value of the variable enclosed by a given meta type.

+

It must be possible to cast the instance to the parent type of the meta data. Otherwise, invoking the setter results in an undefined behavior.
+ The type of the value must coincide exactly with that of the variable enclosed by the meta data. Otherwise, invoking the setter does nothing.

+
Template Parameters
+ + +
TypeType of value to assign.
+
+
+
Parameters
+ + + +
handleAn opaque pointer to an instance of the underlying type.
valueParameter to use to set the underlying variable.
+
+
+
Returns
True in case of success, false otherwise.
+ +

Definition at line 1233 of file meta.hpp.

+ +
+
+ +

◆ set() [2/2]

+ +
+
+
+template<typename Type >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
bool entt::meta_data::set (meta_handle handle,
std::size_t index,
Type && value 
) const
+ 		+inline
+
+ +

Sets the i-th element of an array enclosed by a given meta type.

+

It must be possible to cast the instance to the parent type of the meta data. Otherwise, invoking the setter results in an undefined behavior.
+ The type of the value must coincide exactly with that of the array type enclosed by the meta data. Otherwise, invoking the setter does nothing.

+
Template Parameters
+ + +
TypeType of value to assign.
+
+
+
Parameters
+ + + + +
handleAn opaque pointer to an instance of the underlying type.
indexPosition of the underlying element to set.
valueParameter to use to set the underlying element.
+
+
+
Returns
True in case of success, false otherwise.
+ +

Definition at line 1253 of file meta.hpp.

+ +
+
+ +

◆ type()

+ +
+
+ + + + + +
+ + + + + + + +
meta_type entt::meta_data::type () const
+ 		+inline
+
+ +

Returns the meta type of a given meta data.

+
Returns
The meta type of the meta data.
+ +

Definition at line 1992 of file meta.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1HashedString-members.html b/classentt_1_1meta__dtor-members.html similarity index 59% rename from classentt_1_1HashedString-members.html rename to classentt_1_1meta__dtor-members.html index e8369cff5..878708f9f 100644 --- a/classentt_1_1HashedString-members.html +++ b/classentt_1_1meta__dtor-members.html @@ -22,7 +22,7 @@
EnTT -  2.7.3 +  3.0.0
- - - - - - + + + + + +
hash_type typedefentt::HashedString
HashedString(const char(&str)[N]) ENTT_NOEXCEPTentt::HashedStringinline
HashedString(ConstCharWrapper wrapper) ENTT_NOEXCEPTentt::HashedStringinlineexplicit
operator const char *() const ENTT_NOEXCEPTentt::HashedStringinline
operator hash_type() const ENTT_NOEXCEPTentt::HashedStringinline
operator==(const HashedString &other) const ENTT_NOEXCEPTentt::HashedStringinline
invoke(meta_handle handle) constentt::meta_dtorinline
meta_dtor() ENTT_NOEXCEPTentt::meta_dtorinline
meta_factory classentt::meta_dtorfriend
operator bool() const ENTT_NOEXCEPTentt::meta_dtorinlineexplicit
operator==(const meta_dtor &other) const ENTT_NOEXCEPTentt::meta_dtorinline
parent() const ENTT_NOEXCEPTentt::meta_dtorinline
diff --git a/classentt_1_1meta__dtor.html b/classentt_1_1meta__dtor.html new file mode 100644 index 000000000..b87c5d23e --- /dev/null +++ b/classentt_1_1meta__dtor.html @@ -0,0 +1,259 @@ + + + + + + + +EnTT: entt::meta_dtor Class Reference + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+Public Member Functions | +Friends | +List of all members
+
+
entt::meta_dtor Class Reference
+
+
+ +

Meta destructor object. + More...

+ +

#include <meta.hpp>

+ + + + + + + + + + + + + + + + + +

+Public Member Functions

+ meta_dtor () ENTT_NOEXCEPT
 Default constructor.
 
meta_type parent () const ENTT_NOEXCEPT
 Returns the meta type to which a meta destructor belongs. More...
 
bool invoke (meta_handle handle) const
 Destroys an instance of the underlying type. More...
 
 operator bool () const ENTT_NOEXCEPT
 Returns true if a meta object is valid, false otherwise. More...
 
bool operator== (const meta_dtor &other) const ENTT_NOEXCEPT
 Checks if two meta objects refer to the same node. More...
 
+ + + + + +

+Friends

+template<typename >
class meta_factory
 A meta factory is allowed to create meta objects.
 
+

Detailed Description

+

Meta destructor object.

+

A meta destructor is an opaque container for a function to be used to destroy instances of a given type.

+ +

Definition at line 1090 of file meta.hpp.

+

Member Function Documentation

+ +

◆ invoke()

+ +
+
+ + + + + +
+ + + + + + + + +
bool entt::meta_dtor::invoke (meta_handle handle) const
+ 		+inline
+
+ +

Destroys an instance of the underlying type.

+

It must be possible to cast the instance to the parent type of the meta destructor. Otherwise, invoking the meta destructor results in an undefined behavior.

+
Parameters
+ + +
handleAn opaque pointer to an instance of the underlying type.
+
+
+
Returns
True in case of success, false otherwise.
+ +

Definition at line 1120 of file meta.hpp.

+ +
+
+ +

◆ operator bool()

+ +
+
+ + + + + +
+ + + + + + + +
entt::meta_dtor::operator bool () const
+ 		+inlineexplicit
+
+ +

Returns true if a meta object is valid, false otherwise.

+
Returns
True if the meta object is valid, false otherwise.
+ +

Definition at line 1128 of file meta.hpp.

+ +
+
+ +

◆ operator==()

+ +
+
+ + + + + +
+ + + + + + + + +
bool entt::meta_dtor::operator== (const meta_dtor & other) const
+ 		+inline
+
+ +

Checks if two meta objects refer to the same node.

+
Parameters
+ + +
otherThe meta object with which to compare.
+
+
+
Returns
True if the two meta objects refer to the same node, false otherwise.
+ +

Definition at line 1138 of file meta.hpp.

+ +
+
+ +

◆ parent()

+ +
+
+ + + + + +
+ + + + + + + +
meta_type entt::meta_dtor::parent () const
+ 		+inline
+
+ +

Returns the meta type to which a meta destructor belongs.

+
Returns
The meta type to which the meta destructor belongs.
+ +

Definition at line 1982 of file meta.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1meta__factory-members.html b/classentt_1_1meta__factory-members.html new file mode 100644 index 000000000..5d303f436 --- /dev/null +++ b/classentt_1_1meta__factory-members.html @@ -0,0 +1,91 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
entt::meta_factory< Type > Member List
+
+
+ +

This is the complete list of members for entt::meta_factory< Type >, including all inherited members.

+ + + + + + + + + + + +
base() ENTT_NOEXCEPTentt::meta_factory< Type >inline
conv() ENTT_NOEXCEPTentt::meta_factory< Type >inline
ctor(Property &&... property) ENTT_NOEXCEPTentt::meta_factory< Type >inline
ctor(Property &&... property) ENTT_NOEXCEPTentt::meta_factory< Type >inline
data(const char *str, Property &&... property) ENTT_NOEXCEPTentt::meta_factory< Type >inline
data(const char *str, Property &&... property) ENTT_NOEXCEPTentt::meta_factory< Type >inline
dtor() ENTT_NOEXCEPTentt::meta_factory< Type >inline
func(const char *str, Property &&... property) ENTT_NOEXCEPTentt::meta_factory< Type >inline
reflect(const char *str, Property &&... property) ENTT_NOEXCEPTentt::meta_factory< Type >friend
unregister() ENTT_NOEXCEPTentt::meta_factory< Type >friend
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1meta__factory.html b/classentt_1_1meta__factory.html new file mode 100644 index 000000000..73b3ab7cc --- /dev/null +++ b/classentt_1_1meta__factory.html @@ -0,0 +1,664 @@ + + + + + + + +EnTT: entt::meta_factory< Type > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+Public Member Functions | +Friends | +List of all members
+
+
entt::meta_factory< Type > Class Template Reference
+
+
+ +

A meta factory to be used for reflection purposes. + More...

+ +

#include <factory.hpp>

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

template<typename Base >
meta_factory base () ENTT_NOEXCEPT
 Assigns a meta base to a meta type. More...
 
template<typename To >
meta_factory conv () ENTT_NOEXCEPT
 Assigns a meta conversion function to a meta type. More...
 
template<auto Func, typename... Property>
meta_factory ctor (Property &&... property) ENTT_NOEXCEPT
 Assigns a meta constructor to a meta type. More...
 
template<typename... Args, typename... Property>
meta_factory ctor (Property &&... property) ENTT_NOEXCEPT
 Assigns a meta constructor to a meta type. More...
 
template<auto * Func>
meta_factory dtor () ENTT_NOEXCEPT
 Assigns a meta destructor to a meta type. More...
 
template<auto Data, typename... Property>
meta_factory data (const char *str, Property &&... property) ENTT_NOEXCEPT
 Assigns a meta data to a meta type. More...
 
template<auto Setter, auto Getter, typename... Property>
meta_factory data (const char *str, Property &&... property) ENTT_NOEXCEPT
 Assigns a meta data to a meta type by means of its setter and getter. More...
 
template<auto Func, typename... Property>
meta_factory func (const char *str, Property &&... property) ENTT_NOEXCEPT
 Assigns a meta funcion to a meta type. More...
 
+ + + + + + + + + +

+Friends

template<typename Other , typename... Property>
meta_factory< Other > reflect (const char *str, Property &&... property) ENTT_NOEXCEPT
 Basic function to use for reflection. More...
 
template<typename Other >
bool unregister () ENTT_NOEXCEPT
 Basic function to unregister a type. More...
 
+

Detailed Description

+

template<typename Type>
+class entt::meta_factory< Type >

+ +

A meta factory to be used for reflection purposes.

+

A meta factory is an utility class used to reflect types, data and functions of all sorts. This class ensures that the underlying web of types is built correctly and performs some checks in debug mode to ensure that there are no subtle errors at runtime.

+
Template Parameters
+ + +
TypeReflected type for which the factory was created.
+
+
+ +

Definition at line 17 of file factory.hpp.

+

Member Function Documentation

+ +

◆ base()

+ +
+
+
+template<typename Type >
+
+template<typename Base >
+ + + + + +
+ + + + + + + +
meta_factory entt::meta_factory< Type >::base ()
+ 		+inline
+
+ +

Assigns a meta base to a meta type.

+

A reflected base class must be a real base class of the reflected type.

+
Template Parameters
+ + +
BaseType of the base class to assign to the meta type.
+
+
+
Returns
A meta factory for the parent type.
+ +

Definition at line 204 of file factory.hpp.

+ +
+
+ +

◆ conv()

+ +
+
+
+template<typename Type >
+
+template<typename To >
+ + + + + +
+ + + + + + + +
meta_factory entt::meta_factory< Type >::conv ()
+ 		+inline
+
+ +

Assigns a meta conversion function to a meta type.

+

The given type must be such that an instance of the reflected type can be converted to it.

+
Template Parameters
+ + +
ToType of the conversion function to assign to the meta type.
+
+
+
Returns
A meta factory for the parent type.
+ +

Definition at line 239 of file factory.hpp.

+ +
+
+ +

◆ ctor() [1/2]

+ +
+
+
+template<typename Type >
+
+template<auto Func, typename... Property>
+ + + + + +
+ + + + + + + + +
meta_factory entt::meta_factory< Type >::ctor (Property &&... property)
+ 		+inline
+
+ +

Assigns a meta constructor to a meta type.

+

Free functions can be assigned to meta types in the role of constructors. All that is required is that they return an instance of the underlying type.
+ From a client's point of view, nothing changes if a constructor of a meta type is a built-in one or a free function.

+
Template Parameters
+ + + +
FuncThe actual function to use as a constructor.
PropertyTypes of properties to assign to the meta data.
+
+
+
Parameters
+ + +
propertyProperties to assign to the meta data.
+
+
+
Returns
A meta factory for the parent type.
+ +

Definition at line 279 of file factory.hpp.

+ +
+
+ +

◆ ctor() [2/2]

+ +
+
+
+template<typename Type >
+
+template<typename... Args, typename... Property>
+ + + + + +
+ + + + + + + + +
meta_factory entt::meta_factory< Type >::ctor (Property &&... property)
+ 		+inline
+
+ +

Assigns a meta constructor to a meta type.

+

A meta constructor is uniquely identified by the types of its arguments and is such that there exists an actual constructor of the underlying type that can be invoked with parameters whose types are those given.

+
Template Parameters
+ + + +
ArgsTypes of arguments to use to construct an instance.
PropertyTypes of properties to assign to the meta data.
+
+
+
Parameters
+ + +
propertyProperties to assign to the meta data.
+
+
+
Returns
A meta factory for the parent type.
+ +

Definition at line 321 of file factory.hpp.

+ +
+
+ +

◆ data() [1/2]

+ +
+
+
+template<typename Type >
+
+template<auto Data, typename... Property>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
meta_factory entt::meta_factory< Type >::data (const char * str,
Property &&... property 
)
+ 		+inline
+
+ +

Assigns a meta data to a meta type.

+

Both data members and static and global variables, as well as constants of any kind, can be assigned to a meta type.
+ From a client's point of view, all the variables associated with the reflected object will appear as if they were part of the type itself.

+
Template Parameters
+ + + +
DataThe actual variable to attach to the meta type.
PropertyTypes of properties to assign to the meta data.
+
+
+
Parameters
+ + + +
strThe name to assign to the meta data.
propertyProperties to assign to the meta data.
+
+
+
Returns
A meta factory for the parent type.
+ +

Definition at line 406 of file factory.hpp.

+ +
+
+ +

◆ data() [2/2]

+ +
+
+
+template<typename Type >
+
+template<auto Setter, auto Getter, typename... Property>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
meta_factory entt::meta_factory< Type >::data (const char * str,
Property &&... property 
)
+ 		+inline
+
+ +

Assigns a meta data to a meta type by means of its setter and getter.

+

Setters and getters can be either free functions, member functions or a mix of them.
+ In case of free functions, setters and getters must accept a pointer to an instance of the parent type as their first argument. A setter has then an extra argument of a type convertible to that of the parameter to set.
+ In case of member functions, getters have no arguments at all, while setters has an argument of a type convertible to that of the parameter to set.

+
Template Parameters
+ + + + +
SetterThe actual function to use as a setter.
GetterThe actual function to use as a getter.
PropertyTypes of properties to assign to the meta data.
+
+
+
Parameters
+ + + +
strThe name to assign to the meta data.
propertyProperties to assign to the meta data.
+
+
+
Returns
A meta factory for the parent type.
+ +

Definition at line 506 of file factory.hpp.

+ +
+
+ +

◆ dtor()

+ +
+
+
+template<typename Type >
+
+template<auto * Func>
+ + + + + +
+ + + + + + + +
meta_factory entt::meta_factory< Type >::dtor ()
+ 		+inline
+
+ +

Assigns a meta destructor to a meta type.

+

Free functions can be assigned to meta types in the role of destructors. The signature of the function should identical to the following:

+
void(Type *);

From a client's point of view, nothing changes if the destructor of a meta type is the default one or a custom one.

+
Template Parameters
+ + +
FuncThe actual function to use as a destructor.
+
+
+
Returns
A meta factory for the parent type.
+ +

Definition at line 366 of file factory.hpp.

+ +
+
+ +

◆ func()

+ +
+
+
+template<typename Type >
+
+template<auto Func, typename... Property>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
meta_factory entt::meta_factory< Type >::func (const char * str,
Property &&... property 
)
+ 		+inline
+
+ +

Assigns a meta funcion to a meta type.

+

Both member functions and free functions can be assigned to a meta type.
+ From a client's point of view, all the functions associated with the reflected object will appear as if they were part of the type itself.

+
Template Parameters
+ + + +
FuncThe actual function to attach to the meta type.
PropertyTypes of properties to assign to the meta function.
+
+
+
Parameters
+ + + +
strThe name to assign to the meta function.
propertyProperties to assign to the meta function.
+
+
+
Returns
A meta factory for the parent type.
+ +

Definition at line 554 of file factory.hpp.

+ +
+
+

Friends And Related Function Documentation

+ +

◆ reflect

+ +
+
+
+template<typename Type >
+
+template<typename Other , typename... Property>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
meta_factory<Other> reflect (const char * str,
Property &&... property 
)
+ 		+friend
+
+ +

Basic function to use for reflection.

+

This is the point from which everything starts.
+ By invoking this function with a type that is not yet reflected, a meta type is created to which it will be possible to attach data and functions through a dedicated factory.

+
Template Parameters
+ + + +
TypeType to reflect.
PropertyTypes of properties to assign to the reflected type.
+
+
+
Parameters
+ + + +
strThe name to assign to the reflected type.
propertyProperties to assign to the reflected type.
+
+
+
Returns
A meta factory for the given type.
+ +

Definition at line 606 of file factory.hpp.

+ +
+
+ +

◆ unregister

+ +
+
+
+template<typename Type >
+
+template<typename Other >
+ + + + + +
+ + + + + + + +
bool unregister ()
+ 		+friend
+
+ +

Basic function to unregister a type.

+

This function unregisters a type and all its data members, member functions and properties, as well as its constructors, destructors and conversion functions if any.
+ Base classes aren't unregistered but the link between the two types is removed.

+
Template Parameters
+ + +
TypeType to unregister.
+
+
+
Returns
True if the type to unregister exists, false otherwise.
+ +

Definition at line 641 of file factory.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1meta__func-members.html b/classentt_1_1meta__func-members.html new file mode 100644 index 000000000..fea9835ed --- /dev/null +++ b/classentt_1_1meta__func-members.html @@ -0,0 +1,96 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
entt::meta_func Member List
+
+
+ +

This is the complete list of members for entt::meta_func, including all inherited members.

+ + + + + + + + + + + + + + + + +
arg(size_type index) const ENTT_NOEXCEPTentt::meta_funcinline
invoke(meta_handle handle, Args &&... args) constentt::meta_funcinline
is_const() const ENTT_NOEXCEPTentt::meta_funcinline
is_static() const ENTT_NOEXCEPTentt::meta_funcinline
meta_factory classentt::meta_funcfriend
meta_func() ENTT_NOEXCEPTentt::meta_funcinline
name() const ENTT_NOEXCEPTentt::meta_funcinline
operator bool() const ENTT_NOEXCEPTentt::meta_funcinlineexplicit
operator==(const meta_func &other) const ENTT_NOEXCEPTentt::meta_funcinline
parent() const ENTT_NOEXCEPTentt::meta_funcinline
prop(Op op) const ENTT_NOEXCEPTentt::meta_funcinline
prop(Key &&key) const ENTT_NOEXCEPTentt::meta_funcinline
ret() const ENTT_NOEXCEPTentt::meta_funcinline
size() const ENTT_NOEXCEPTentt::meta_funcinline
size_type typedefentt::meta_func
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1meta__func.html b/classentt_1_1meta__func.html new file mode 100644 index 000000000..735aff6aa --- /dev/null +++ b/classentt_1_1meta__func.html @@ -0,0 +1,591 @@ + + + + + + + +EnTT: entt::meta_func Class Reference + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+Public Types | +Public Member Functions | +Friends | +List of all members
+
+
entt::meta_func Class Reference
+
+
+ +

Meta function object. + More...

+ +

#include <meta.hpp>

+ + + + + +

+Public Types

+using size_type = typename internal::meta_func_node::size_type
 Unsigned integer type.
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+ meta_func () ENTT_NOEXCEPT
 Default constructor.
 
const char * name () const ENTT_NOEXCEPT
 Returns the name assigned to a given meta function. More...
 
meta_type parent () const ENTT_NOEXCEPT
 Returns the meta type to which a meta function belongs. More...
 
size_type size () const ENTT_NOEXCEPT
 Returns the number of arguments accepted by a meta function. More...
 
bool is_const () const ENTT_NOEXCEPT
 Indicates whether a given meta function is constant or not. More...
 
bool is_static () const ENTT_NOEXCEPT
 Indicates whether a given meta function is static or not. More...
 
meta_type ret () const ENTT_NOEXCEPT
 Returns the meta type of the return type of a meta function. More...
 
meta_type arg (size_type index) const ENTT_NOEXCEPT
 Returns the meta type of the i-th argument of a meta function. More...
 
template<typename... Args>
meta_any invoke (meta_handle handle, Args &&... args) const
 Invokes the underlying function, if possible. More...
 
template<typename Op >
std::enable_if_t< std::is_invocable_v< Op, meta_prop >, void > prop (Op op) const ENTT_NOEXCEPT
 Iterates all the properties assigned to a meta function. More...
 
template<typename Key >
std::enable_if_t<!std::is_invocable_v< Key, meta_prop >, meta_prop > prop (Key &&key) const ENTT_NOEXCEPT
 Returns the property associated with a given key. More...
 
 operator bool () const ENTT_NOEXCEPT
 Returns true if a meta object is valid, false otherwise. More...
 
bool operator== (const meta_func &other) const ENTT_NOEXCEPT
 Checks if two meta objects refer to the same node. More...
 
+ + + + + +

+Friends

+template<typename >
class meta_factory
 A meta factory is allowed to create meta objects.
 
+

Detailed Description

+

Meta function object.

+

A meta function is an opaque container for a member function associated with a given type.

+ +

Definition at line 1355 of file meta.hpp.

+

Member Function Documentation

+ +

◆ arg()

+ +
+
+ + + + + +
+ + + + + + + + +
meta_type entt::meta_func::arg (size_type index) const
+ 		+inline
+
+ +

Returns the meta type of the i-th argument of a meta function.

+
Parameters
+ + +
indexThe index of the argument of which to return the meta type.
+
+
+
Returns
The meta type of the i-th argument of a meta function, if any.
+ +

Definition at line 2007 of file meta.hpp.

+ +
+
+ +

◆ invoke()

+ +
+
+
+template<typename... Args>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
meta_any entt::meta_func::invoke (meta_handle handle,
Args &&... args 
) const
+ 		+inline
+
+ +

Invokes the underlying function, if possible.

+

To invoke a meta function, the types of the parameters must coincide exactly with those required by the underlying function. Otherwise, an empty and then invalid container is returned.
+ It must be possible to cast the instance to the parent type of the meta function. Otherwise, invoking the underlying function results in an undefined behavior.

+
Template Parameters
+ + +
ArgsTypes of arguments to use to invoke the function.
+
+
+
Parameters
+ + + +
handleAn opaque pointer to an instance of the underlying type.
argsParameters to use to invoke the function.
+
+
+
Returns
A meta any containing the returned value, if any.
+ +

Definition at line 1443 of file meta.hpp.

+ +
+
+ +

◆ is_const()

+ +
+
+ + + + + +
+ + + + + + + +
bool entt::meta_func::is_const () const
+ 		+inline
+
+ +

Indicates whether a given meta function is constant or not.

+
Returns
True if the meta function is constant, false otherwise.
+ +

Definition at line 1398 of file meta.hpp.

+ +
+
+ +

◆ is_static()

+ +
+
+ + + + + +
+ + + + + + + +
bool entt::meta_func::is_static () const
+ 		+inline
+
+ +

Indicates whether a given meta function is static or not.

+

A static meta function is such that it can be invoked using a null pointer as an instance.

+
Returns
True if the meta function is static, false otherwise.
+ +

Definition at line 1410 of file meta.hpp.

+ +
+
+ +

◆ name()

+ +
+
+ + + + + +
+ + + + + + + +
const char* entt::meta_func::name () const
+ 		+inline
+
+ +

Returns the name assigned to a given meta function.

+
Returns
The name assigned to the meta function.
+ +

Definition at line 1376 of file meta.hpp.

+ +
+
+ +

◆ operator bool()

+ +
+
+ + + + + +
+ + + + + + + +
entt::meta_func::operator bool () const
+ 		+inlineexplicit
+
+ +

Returns true if a meta object is valid, false otherwise.

+
Returns
True if the meta object is valid, false otherwise.
+ +

Definition at line 1487 of file meta.hpp.

+ +
+
+ +

◆ operator==()

+ +
+
+ + + + + +
+ + + + + + + + +
bool entt::meta_func::operator== (const meta_func & other) const
+ 		+inline
+
+ +

Checks if two meta objects refer to the same node.

+
Parameters
+ + +
otherThe meta object with which to compare.
+
+
+
Returns
True if the two meta objects refer to the same node, false otherwise.
+ +

Definition at line 1497 of file meta.hpp.

+ +
+
+ +

◆ parent()

+ +
+
+ + + + + +
+ + + + + + + +
meta_type entt::meta_func::parent () const
+ 		+inline
+
+ +

Returns the meta type to which a meta function belongs.

+
Returns
The meta type to which the meta function belongs.
+ +

Definition at line 1997 of file meta.hpp.

+ +
+
+ +

◆ prop() [1/2]

+ +
+
+
+template<typename Op >
+ + + + + +
+ + + + + + + + +
std::enable_if_t<std::is_invocable_v<Op, meta_prop>, void> entt::meta_func::prop (Op op) const
+ 		+inline
+
+ +

Iterates all the properties assigned to a meta function.

+
Template Parameters
+ + +
OpType of the function object to invoke.
+
+
+
Parameters
+ + +
opA valid function object.
+
+
+ +

Definition at line 1461 of file meta.hpp.

+ +
+
+ +

◆ prop() [2/2]

+ +
+
+
+template<typename Key >
+ + + + + +
+ + + + + + + + +
std::enable_if_t<!std::is_invocable_v<Key, meta_prop>, meta_prop> entt::meta_func::prop (Key && key) const
+ 		+inline
+
+ +

Returns the property associated with a given key.

+
Template Parameters
+ + +
KeyType of key to use to search for a property.
+
+
+
Parameters
+ + +
keyThe key to use to search for a property.
+
+
+
Returns
The property associated with the given key, if any.
+ +

Definition at line 1475 of file meta.hpp.

+ +
+
+ +

◆ ret()

+ +
+
+ + + + + +
+ + + + + + + +
meta_type entt::meta_func::ret () const
+ 		+inline
+
+ +

Returns the meta type of the return type of a meta function.

+
Returns
The meta type of the return type of the meta function.
+ +

Definition at line 2002 of file meta.hpp.

+ +
+
+ +

◆ size()

+ +
+
+ + + + + +
+ + + + + + + +
size_type entt::meta_func::size () const
+ 		+inline
+
+ +

Returns the number of arguments accepted by a meta function.

+
Returns
The number of arguments accepted by the meta function.
+ +

Definition at line 1390 of file meta.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1meta__handle-members.html b/classentt_1_1meta__handle-members.html new file mode 100644 index 000000000..b743ae4b1 --- /dev/null +++ b/classentt_1_1meta__handle-members.html @@ -0,0 +1,89 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
entt::meta_handle Member List
+
+
+ +

This is the complete list of members for entt::meta_handle, including all inherited members.

+ + + + + + + + + +
data() const ENTT_NOEXCEPTentt::meta_handleinline
data() ENTT_NOEXCEPTentt::meta_handleinline
meta_handle() ENTT_NOEXCEPTentt::meta_handleinline
meta_handle(Type &&obj) ENTT_NOEXCEPTentt::meta_handleinline
operator bool() const ENTT_NOEXCEPTentt::meta_handleinlineexplicit
try_cast() const ENTT_NOEXCEPTentt::meta_handleinline
try_cast() ENTT_NOEXCEPTentt::meta_handleinline
type() const ENTT_NOEXCEPTentt::meta_handleinline
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1meta__handle.html b/classentt_1_1meta__handle.html new file mode 100644 index 000000000..b1b40cf3c --- /dev/null +++ b/classentt_1_1meta__handle.html @@ -0,0 +1,375 @@ + + + + + + + +EnTT: entt::meta_handle Class Reference + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+Public Member Functions | +List of all members
+
+
entt::meta_handle Class Reference
+
+
+ +

Meta handle object. + More...

+ +

#include <meta.hpp>

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+ meta_handle () ENTT_NOEXCEPT
 Default constructor.
 
template<typename Type , typename = std::enable_if_t<!std::is_same_v<std::remove_cv_t<std::remove_reference_t<Type>>, meta_handle>>>
 meta_handle (Type &&obj) ENTT_NOEXCEPT
 Constructs a meta handle from a given instance. More...
 
meta_type type () const ENTT_NOEXCEPT
 Returns the meta type of the underlying object. More...
 
template<typename Type >
const Type * try_cast () const ENTT_NOEXCEPT
 Tries to cast an instance to a given type. More...
 
template<typename Type >
Type * try_cast () ENTT_NOEXCEPT
 Tries to cast an instance to a given type. More...
 
const void * data () const ENTT_NOEXCEPT
 Returns an opaque pointer to the contained instance. More...
 
void * data () ENTT_NOEXCEPT
 Returns an opaque pointer to the contained instance. More...
 
 operator bool () const ENTT_NOEXCEPT
 Returns false if a handle is empty, true otherwise. More...
 
+

Detailed Description

+

Meta handle object.

+

A meta handle is an opaque pointer to an instance of any type.

+

A handle doesn't perform copies and isn't responsible for the contained object. It doesn't prolong the lifetime of the pointed instance. Users are responsible for ensuring that the target object remains alive for the entire interval of use of the handle.

+ +

Definition at line 636 of file meta.hpp.

+

Constructor & Destructor Documentation

+ +

◆ meta_handle()

+ +
+
+
+template<typename Type , typename = std::enable_if_t<!std::is_same_v<std::remove_cv_t<std::remove_reference_t<Type>>, meta_handle>>>
+ + + + + +
+ + + + + + + + +
entt::meta_handle::meta_handle (Type && obj)
+ 		+inline
+
+ +

Constructs a meta handle from a given instance.

+
Template Parameters
+ + +
TypeType of object to use to initialize the handle.
+
+
+
Parameters
+ + +
objA reference to an object to use to initialize the handle.
+
+
+ +

Definition at line 661 of file meta.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ data() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
const void* entt::meta_handle::data () const
+ 		+inline
+
+ +

Returns an opaque pointer to the contained instance.

+
Returns
An opaque pointer the contained instance, if any.
+ +

Definition at line 700 of file meta.hpp.

+ +
+
+ +

◆ data() [2/2]

+ +
+
+ + + + + +
+ + + + + + + +
void* entt::meta_handle::data ()
+ 		+inline
+
+ +

Returns an opaque pointer to the contained instance.

+
Returns
An opaque pointer the contained instance, if any.
+ +

Definition at line 705 of file meta.hpp.

+ +
+
+ +

◆ operator bool()

+ +
+
+ + + + + +
+ + + + + + + +
entt::meta_handle::operator bool () const
+ 		+inlineexplicit
+
+ +

Returns false if a handle is empty, true otherwise.

+
Returns
False if the handle is empty, true otherwise.
+ +

Definition at line 713 of file meta.hpp.

+ +
+
+ +

◆ try_cast() [1/2]

+ +
+
+
+template<typename Type >
+ + + + + +
+ + + + + + + +
const Type* entt::meta_handle::try_cast () const
+ 		+inline
+
+ +

Tries to cast an instance to a given type.

+

The type of the instance must be such that the conversion is possible.

+
Warning
Attempting to perform a conversion that isn't viable results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode in case the conversion is not feasible.
+
Template Parameters
+ + +
TypeType to which to cast the instance.
+
+
+
Returns
A pointer to the contained instance.
+ +

Definition at line 686 of file meta.hpp.

+ +
+
+ +

◆ try_cast() [2/2]

+ +
+
+
+template<typename Type >
+ + + + + +
+ + + + + + + +
Type* entt::meta_handle::try_cast ()
+ 		+inline
+
+ +

Tries to cast an instance to a given type.

+

The type of the instance must be such that the conversion is possible.

+
Warning
Attempting to perform a conversion that isn't viable results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode in case the conversion is not feasible.
+
Template Parameters
+ + +
TypeType to which to cast the instance.
+
+
+
Returns
A pointer to the contained instance.
+ +

Definition at line 692 of file meta.hpp.

+ +
+
+ +

◆ type()

+ +
+
+ + + + + +
+ + + + + + + +
meta_type entt::meta_handle::type () const
+ 		+inline
+
+ +

Returns the meta type of the underlying object.

+
Returns
The meta type of the underlying object, if any.
+ +

Definition at line 1947 of file meta.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1Dispatcher-members.html b/classentt_1_1meta__prop-members.html similarity index 59% rename from classentt_1_1Dispatcher-members.html rename to classentt_1_1meta__prop-members.html index 2313612b8..0cf21d644 100644 --- a/classentt_1_1Dispatcher-members.html +++ b/classentt_1_1meta__prop-members.html @@ -22,7 +22,7 @@
EnTT -  2.7.3 +  3.0.0
- - - - - - + + + + + +
enqueue(Args &&... args)entt::Dispatcherinline
sink() ENTT_NOEXCEPTentt::Dispatcherinline
sink_type typedefentt::Dispatcher
trigger(Args &&... args)entt::Dispatcherinline
update()entt::Dispatcherinline
update() constentt::Dispatcherinline
key() const ENTT_NOEXCEPTentt::meta_propinline
meta_factory classentt::meta_propfriend
meta_prop() ENTT_NOEXCEPTentt::meta_propinline
operator bool() const ENTT_NOEXCEPTentt::meta_propinlineexplicit
operator==(const meta_prop &other) const ENTT_NOEXCEPTentt::meta_propinline
value() const ENTT_NOEXCEPTentt::meta_propinline
diff --git a/classentt_1_1meta__prop.html b/classentt_1_1meta__prop.html new file mode 100644 index 000000000..1cdf338d8 --- /dev/null +++ b/classentt_1_1meta__prop.html @@ -0,0 +1,252 @@ + + + + + + + +EnTT: entt::meta_prop Class Reference + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+Public Member Functions | +Friends | +List of all members
+
+
entt::meta_prop Class Reference
+
+
+ +

Meta property object. + More...

+ +

#include <meta.hpp>

+ + + + + + + + + + + + + + + + + +

+Public Member Functions

+ meta_prop () ENTT_NOEXCEPT
 Default constructor.
 
meta_any key () const ENTT_NOEXCEPT
 Returns the stored key. More...
 
meta_any value () const ENTT_NOEXCEPT
 Returns the stored value. More...
 
 operator bool () const ENTT_NOEXCEPT
 Returns true if a meta object is valid, false otherwise. More...
 
bool operator== (const meta_prop &other) const ENTT_NOEXCEPT
 Checks if two meta objects refer to the same node. More...
 
+ + + + + +

+Friends

+template<typename >
class meta_factory
 A meta factory is allowed to create meta objects.
 
+

Detailed Description

+

Meta property object.

+

A meta property is an opaque container for a key/value pair.
+ Properties are associated with any other meta object to enrich it.

+ +

Definition at line 740 of file meta.hpp.

+

Member Function Documentation

+ +

◆ key()

+ +
+
+ + + + + +
+ + + + + + + +
meta_any entt::meta_prop::key () const
+ 		+inline
+
+ +

Returns the stored key.

+
Returns
A meta any containing the key stored with the given property.
+ +

Definition at line 758 of file meta.hpp.

+ +
+
+ +

◆ operator bool()

+ +
+
+ + + + + +
+ + + + + + + +
entt::meta_prop::operator bool () const
+ 		+inlineexplicit
+
+ +

Returns true if a meta object is valid, false otherwise.

+
Returns
True if the meta object is valid, false otherwise.
+ +

Definition at line 774 of file meta.hpp.

+ +
+
+ +

◆ operator==()

+ +
+
+ + + + + +
+ + + + + + + + +
bool entt::meta_prop::operator== (const meta_prop & other) const
+ 		+inline
+
+ +

Checks if two meta objects refer to the same node.

+
Parameters
+ + +
otherThe meta object with which to compare.
+
+
+
Returns
True if the two meta objects refer to the same node, false otherwise.
+ +

Definition at line 784 of file meta.hpp.

+ +
+
+ +

◆ value()

+ +
+
+ + + + + +
+ + + + + + + +
meta_any entt::meta_prop::value () const
+ 		+inline
+
+ +

Returns the stored value.

+
Returns
A meta any containing the value stored with the given property.
+ +

Definition at line 766 of file meta.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1meta__type-members.html b/classentt_1_1meta__type-members.html new file mode 100644 index 000000000..251fd2f68 --- /dev/null +++ b/classentt_1_1meta__type-members.html @@ -0,0 +1,116 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
entt::meta_type Member List
+
+
+ +

This is the complete list of members for entt::meta_type, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
base(Op op) const ENTT_NOEXCEPTentt::meta_typeinline
base(const char *str) const ENTT_NOEXCEPTentt::meta_typeinline
construct(Args &&... args) constentt::meta_typeinline
conv(Op op) const ENTT_NOEXCEPTentt::meta_typeinline
conv() const ENTT_NOEXCEPTentt::meta_typeinline
ctor(Op op) const ENTT_NOEXCEPTentt::meta_typeinline
ctor() const ENTT_NOEXCEPTentt::meta_typeinline
data(Op op) const ENTT_NOEXCEPTentt::meta_typeinline
data(const char *str) const ENTT_NOEXCEPTentt::meta_typeinline
destroy(meta_handle handle) constentt::meta_typeinline
dtor() const ENTT_NOEXCEPTentt::meta_typeinline
extent() const ENTT_NOEXCEPTentt::meta_typeinline
func(Op op) const ENTT_NOEXCEPTentt::meta_typeinline
func(const char *str) const ENTT_NOEXCEPTentt::meta_typeinline
internal::meta_nodeentt::meta_typefriend
is_array() const ENTT_NOEXCEPTentt::meta_typeinline
is_class() const ENTT_NOEXCEPTentt::meta_typeinline
is_enum() const ENTT_NOEXCEPTentt::meta_typeinline
is_floating_point() const ENTT_NOEXCEPTentt::meta_typeinline
is_function() const ENTT_NOEXCEPTentt::meta_typeinline
is_integral() const ENTT_NOEXCEPTentt::meta_typeinline
is_member_function_pointer() const ENTT_NOEXCEPTentt::meta_typeinline
is_member_object_pointer() const ENTT_NOEXCEPTentt::meta_typeinline
is_pointer() const ENTT_NOEXCEPTentt::meta_typeinline
is_union() const ENTT_NOEXCEPTentt::meta_typeinline
is_void() const ENTT_NOEXCEPTentt::meta_typeinline
meta_factory classentt::meta_typefriend
meta_type() ENTT_NOEXCEPTentt::meta_typeinline
name() const ENTT_NOEXCEPTentt::meta_typeinline
operator bool() const ENTT_NOEXCEPTentt::meta_typeinlineexplicit
operator==(const meta_type &other) const ENTT_NOEXCEPTentt::meta_typeinline
prop(Op op) const ENTT_NOEXCEPTentt::meta_typeinline
prop(Key &&key) const ENTT_NOEXCEPTentt::meta_typeinline
remove_pointer() const ENTT_NOEXCEPTentt::meta_typeinline
size_type typedefentt::meta_type
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1meta__type.html b/classentt_1_1meta__type.html new file mode 100644 index 000000000..65ffcd591 --- /dev/null +++ b/classentt_1_1meta__type.html @@ -0,0 +1,1329 @@ + + + + + + + +EnTT: entt::meta_type Class Reference + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  3.0.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+Public Types | +Public Member Functions | +Friends | +List of all members
+
+
entt::meta_type Class Reference
+
+
+ +

Meta type object. + More...

+ +

#include <meta.hpp>

+ + + + + +

+Public Types

+using size_type = typename internal::meta_type_node::size_type
 Unsigned integer type.
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+ meta_type () ENTT_NOEXCEPT
 Default constructor.
 
const char * name () const ENTT_NOEXCEPT
 Returns the name assigned to a given meta type. More...
 
bool is_void () const ENTT_NOEXCEPT
 Indicates whether a given meta type refers to void or not. More...
 
bool is_integral () const ENTT_NOEXCEPT
 Indicates whether a given meta type refers to an integral type or not. More...
 
bool is_floating_point () const ENTT_NOEXCEPT
 Indicates whether a given meta type refers to a floating-point type or not. More...
 
bool is_array () const ENTT_NOEXCEPT
 Indicates whether a given meta type refers to an array type or not. More...
 
bool is_enum () const ENTT_NOEXCEPT
 Indicates whether a given meta type refers to an enum or not. More...
 
bool is_union () const ENTT_NOEXCEPT
 Indicates whether a given meta type refers to an union or not. More...
 
bool is_class () const ENTT_NOEXCEPT
 Indicates whether a given meta type refers to a class or not. More...
 
bool is_pointer () const ENTT_NOEXCEPT
 Indicates whether a given meta type refers to a pointer or not. More...
 
bool is_function () const ENTT_NOEXCEPT
 Indicates whether a given meta type refers to a function type or not. More...
 
bool is_member_object_pointer () const ENTT_NOEXCEPT
 Indicates whether a given meta type refers to a pointer to data member or not. More...
 
bool is_member_function_pointer () const ENTT_NOEXCEPT
 Indicates whether a given meta type refers to a pointer to member function or not. More...
 
size_type extent () const ENTT_NOEXCEPT
 If a given meta type refers to an array type, provides the number of elements of the array. More...
 
meta_type remove_pointer () const ENTT_NOEXCEPT
 Provides the meta type for which the pointer is defined. More...
 
template<typename Op >
void base (Op op) const ENTT_NOEXCEPT
 Iterates all the meta base of a meta type. More...
 
meta_base base (const char *str) const ENTT_NOEXCEPT
 Returns the meta base associated with a given name. More...
 
template<typename Op >
void conv (Op op) const ENTT_NOEXCEPT
 Iterates all the meta conversion functions of a meta type. More...
 
template<typename Type >
meta_conv conv () const ENTT_NOEXCEPT
 Returns the meta conversion function associated with a given type. More...
 
template<typename Op >
void ctor (Op op) const ENTT_NOEXCEPT
 Iterates all the meta constructors of a meta type. More...
 
template<typename... Args>
meta_ctor ctor () const ENTT_NOEXCEPT
 Returns the meta constructor that accepts a given list of types of arguments. More...
 
meta_dtor dtor () const ENTT_NOEXCEPT
 Returns the meta destructor associated with a given type. More...
 
template<typename Op >
void data (Op op) const ENTT_NOEXCEPT
 Iterates all the meta data of a meta type. More...
 
meta_data data (const char *str) const ENTT_NOEXCEPT
 Returns the meta data associated with a given name. More...
 
template<typename Op >
void func (Op op) const ENTT_NOEXCEPT
 Iterates all the meta functions of a meta type. More...
 
meta_func func (const char *str) const ENTT_NOEXCEPT
 Returns the meta function associated with a given name. More...
 
template<typename... Args>
meta_any construct (Args &&... args) const
 Creates an instance of the underlying type, if possible. More...
 
bool destroy (meta_handle handle) const
 Destroys an instance of the underlying type. More...
 
template<typename Op >
std::enable_if_t< std::is_invocable_v< Op, meta_prop >, void > prop (Op op) const ENTT_NOEXCEPT
 Iterates all the properties assigned to a meta type. More...
 
template<typename Key >
std::enable_if_t<!std::is_invocable_v< Key, meta_prop >, meta_prop > prop (Key &&key) const ENTT_NOEXCEPT
 Returns the property associated with a given key. More...
 
 operator bool () const ENTT_NOEXCEPT
 Returns true if a meta object is valid, false otherwise. More...
 
bool operator== (const meta_type &other) const ENTT_NOEXCEPT
 Checks if two meta objects refer to the same node. More...
 
+ + + + + + + + + +

+Friends

+template<typename >
class meta_factory
 A meta factory is allowed to create meta objects.
 
+template<typename... >
struct internal::meta_node
 A meta node is allowed to create meta objects.
 
+

Detailed Description

+

Meta type object.

+

A meta type is the starting point for accessing a reflected type, thus being able to work through it on real objects.

+ +

Definition at line 1523 of file meta.hpp.

+

Member Function Documentation

+ +

◆ base() [1/2]

+ +
+
+
+template<typename Op >
+ + + + + +
+ + + + + + + + +
void entt::meta_type::base (Op op) const
+ 		+inline
+
+ +

Iterates all the meta base of a meta type.

+

Iteratively returns all the base classes of the given type.

+
Template Parameters
+ + +
OpType of the function object to invoke.
+
+
+
Parameters
+ + +
opA valid function object.
+
+
+ +

Definition at line 1676 of file meta.hpp.

+ +
+
+ +

◆ base() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + +
meta_base entt::meta_type::base (const char * str) const
+ 		+inline
+
+ +

Returns the meta base associated with a given name.

+

Searches recursively among all the base classes of the given type.

+
Parameters
+ + +
strThe name to use to search for a meta base.
+
+
+
Returns
The meta base associated with the given name, if any.
+ +

Definition at line 1690 of file meta.hpp.

+ +
+
+ +

◆ construct()

+ +
+
+
+template<typename... Args>
+ + + + + +
+ + + + + + + + +
meta_any entt::meta_type::construct (Args &&... args) const
+ 		+inline
+
+ +

Creates an instance of the underlying type, if possible.

+

To create a valid instance, the types of the parameters must coincide exactly with those required by the underlying meta constructor. Otherwise, an empty and then invalid container is returned.

+
Template Parameters
+ + +
ArgsTypes of arguments to use to construct the instance.
+
+
+
Parameters
+ + +
argsParameters to use to construct the instance.
+
+
+
Returns
A meta any containing the new instance, if any.
+ +

Definition at line 1845 of file meta.hpp.

+ +
+
+ +

◆ conv() [1/2]

+ +
+
+
+template<typename Op >
+ + + + + +
+ + + + + + + + +
void entt::meta_type::conv (Op op) const
+ 		+inline
+
+ +

Iterates all the meta conversion functions of a meta type.

+

Iteratively returns all the meta conversion functions of the given type.

+
Template Parameters
+ + +
OpType of the function object to invoke.
+
+
+
Parameters
+ + +
opA valid function object.
+
+
+ +

Definition at line 1708 of file meta.hpp.

+ +
+
+ +

◆ conv() [2/2]

+ +
+
+
+template<typename Type >
+ + + + + +
+ + + + + + + +
meta_conv entt::meta_type::conv () const
+ 		+inline
+
+ +

Returns the meta conversion function associated with a given type.

+

Searches recursively among all the conversion functions of the given type.

+
Template Parameters
+ + +
TypeThe type to use to search for a meta conversion function.
+
+
+
Returns
The meta conversion function associated with the given type, if any.
+ +

Definition at line 1725 of file meta.hpp.

+ +
+
+ +

◆ ctor() [1/2]

+ +
+
+
+template<typename Op >
+ + + + + +
+ + + + + + + + +
void entt::meta_type::ctor (Op op) const
+ 		+inline
+
+ +

Iterates all the meta constructors of a meta type.

+
Template Parameters
+ + +
OpType of the function object to invoke.
+
+
+
Parameters
+ + +
opA valid function object.
+
+
+ +

Definition at line 1739 of file meta.hpp.

+ +
+
+ +

◆ ctor() [2/2]

+ +
+
+
+template<typename... Args>
+ + + + + +
+ + + + + + + +
meta_ctor entt::meta_type::ctor () const
+ 		+inline
+
+ +

Returns the meta constructor that accepts a given list of types of arguments.

+
Returns
The requested meta constructor, if any.
+ +

Definition at line 1751 of file meta.hpp.

+ +
+
+ +

◆ data() [1/2]

+ +
+
+
+template<typename Op >
+ + + + + +
+ + + + + + + + +
void entt::meta_type::data (Op op) const
+ 		+inline
+
+ +

Iterates all the meta data of a meta type.

+

Iteratively returns all the meta data of the given type. This means that the meta data of the base classes will also be returned, if any.

+
Template Parameters
+ + +
OpType of the function object to invoke.
+
+
+
Parameters
+ + +
opA valid function object.
+
+
+ +

Definition at line 1774 of file meta.hpp.

+ +
+
+ +

◆ data() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + +
meta_data entt::meta_type::data (const char * str) const
+ 		+inline
+
+ +

Returns the meta data associated with a given name.

+

Searches recursively among all the meta data of the given type. This means that the meta data of the base classes will also be inspected, if any.

+
Parameters
+ + +
strThe name to use to search for a meta data.
+
+
+
Returns
The meta data associated with the given name, if any.
+ +

Definition at line 1790 of file meta.hpp.

+ +
+
+ +

◆ destroy()

+ +
+
+ + + + + +
+ + + + + + + + +
bool entt::meta_type::destroy (meta_handle handle) const
+ 		+inline
+
+ +

Destroys an instance of the underlying type.

+

It must be possible to cast the instance to the underlying type. Otherwise, invoking the meta destructor results in an undefined behavior.

+
Parameters
+ + +
handleAn opaque pointer to an instance of the underlying type.
+
+
+
Returns
True in case of success, false otherwise.
+ +

Definition at line 1866 of file meta.hpp.

+ +
+
+ +

◆ dtor()

+ +
+
+ + + + + +
+ + + + + + + +
meta_dtor entt::meta_type::dtor () const
+ 		+inline
+
+ +

Returns the meta destructor associated with a given type.

+
Returns
The meta destructor associated with the given type, if any.
+ +

Definition at line 1760 of file meta.hpp.

+ +
+
+ +

◆ extent()

+ +
+
+ + + + + +
+ + + + + + + +
size_type entt::meta_type::extent () const
+ 		+inline
+
+ +

If a given meta type refers to an array type, provides the number of elements of the array.

+
Returns
The number of elements of the array if the underlying type is an array type, 0 otherwise.
+ +

Definition at line 1654 of file meta.hpp.

+ +
+
+ +

◆ func() [1/2]

+ +
+
+
+template<typename Op >
+ + + + + +
+ + + + + + + + +
void entt::meta_type::func (Op op) const
+ 		+inline
+
+ +

Iterates all the meta functions of a meta type.

+

Iteratively returns all the meta functions of the given type. This means that the meta functions of the base classes will also be returned, if any.

+
Template Parameters
+ + +
OpType of the function object to invoke.
+
+
+
Parameters
+ + +
opA valid function object.
+
+
+ +

Definition at line 1809 of file meta.hpp.

+ +
+
+ +

◆ func() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + +
meta_func entt::meta_type::func (const char * str) const
+ 		+inline
+
+ +

Returns the meta function associated with a given name.

+

Searches recursively among all the meta functions of the given type. This means that the meta functions of the base classes will also be inspected, if any.

+
Parameters
+ + +
strThe name to use to search for a meta function.
+
+
+
Returns
The meta function associated with the given name, if any.
+ +

Definition at line 1825 of file meta.hpp.

+ +
+
+ +

◆ is_array()

+ +
+
+ + + + + +
+ + + + + + + +
bool entt::meta_type::is_array () const
+ 		+inline
+
+ +

Indicates whether a given meta type refers to an array type or not.

+
Returns
True if the underlying type is an array type, false otherwise.
+ +

Definition at line 1583 of file meta.hpp.

+ +
+
+ +

◆ is_class()

+ +
+
+ + + + + +
+ + + + + + + +
bool entt::meta_type::is_class () const
+ 		+inline
+
+ +

Indicates whether a given meta type refers to a class or not.

+
Returns
True if the underlying type is a class, false otherwise.
+ +

Definition at line 1607 of file meta.hpp.

+ +
+
+ +

◆ is_enum()

+ +
+
+ + + + + +
+ + + + + + + +
bool entt::meta_type::is_enum () const
+ 		+inline
+
+ +

Indicates whether a given meta type refers to an enum or not.

+
Returns
True if the underlying type is an enum, false otherwise.
+ +

Definition at line 1591 of file meta.hpp.

+ +
+
+ +

◆ is_floating_point()

+ +
+
+ + + + + +
+ + + + + + + +
bool entt::meta_type::is_floating_point () const
+ 		+inline
+
+ +

Indicates whether a given meta type refers to a floating-point type or not.

+
Returns
True if the underlying type is a floating-point type, false otherwise.
+ +

Definition at line 1574 of file meta.hpp.

+ +
+
+ +

◆ is_function()

+ +
+
+ + + + + +
+ + + + + + + +
bool entt::meta_type::is_function () const
+ 		+inline
+
+ +

Indicates whether a given meta type refers to a function type or not.

+
Returns
True if the underlying type is a function, false otherwise.
+ +

Definition at line 1624 of file meta.hpp.

+ +
+
+ +

◆ is_integral()

+ +
+
+ + + + + +
+ + + + + + + +
bool entt::meta_type::is_integral () const
+ 		+inline
+
+ +

Indicates whether a given meta type refers to an integral type or not.

+
Returns
True if the underlying type is an integral type, false otherwise.
+ +

Definition at line 1564 of file meta.hpp.

+ +
+
+ +

◆ is_member_function_pointer()

+ +
+
+ + + + + +
+ + + + + + + +
bool entt::meta_type::is_member_function_pointer () const
+ 		+inline
+
+ +

Indicates whether a given meta type refers to a pointer to member function or not.

+
Returns
True if the underlying type is a pointer to member function, false otherwise.
+ +

Definition at line 1644 of file meta.hpp.

+ +
+
+ +

◆ is_member_object_pointer()

+ +
+
+ + + + + +
+ + + + + + + +
bool entt::meta_type::is_member_object_pointer () const
+ 		+inline
+
+ +

Indicates whether a given meta type refers to a pointer to data member or not.

+
Returns
True if the underlying type is a pointer to data member, false otherwise.
+ +

Definition at line 1634 of file meta.hpp.

+ +
+
+ +

◆ is_pointer()

+ +
+
+ + + + + +
+ + + + + + + +
bool entt::meta_type::is_pointer () const
+ 		+inline
+
+ +

Indicates whether a given meta type refers to a pointer or not.

+
Returns
True if the underlying type is a pointer, false otherwise.
+ +

Definition at line 1615 of file meta.hpp.

+ +
+
+ +

◆ is_union()

+ +
+
+ + + + + +
+ + + + + + + +
bool entt::meta_type::is_union () const
+ 		+inline
+
+ +

Indicates whether a given meta type refers to an union or not.

+
Returns
True if the underlying type is an union, false otherwise.
+ +

Definition at line 1599 of file meta.hpp.

+ +
+
+ +

◆ is_void()

+ +
+
+ + + + + +
+ + + + + + + +
bool entt::meta_type::is_void () const
+ 		+inline
+
+ +

Indicates whether a given meta type refers to void or not.

+
Returns
True if the underlying type is void, false otherwise.
+ +

Definition at line 1555 of file meta.hpp.

+ +
+
+ +

◆ name()

+ +
+
+ + + + + +
+ + + + + + + +
const char* entt::meta_type::name () const
+ 		+inline
+
+ +

Returns the name assigned to a given meta type.

+
Returns
The name assigned to the meta type.
+ +

Definition at line 1547 of file meta.hpp.

+ +
+
+ +

◆ operator bool()

+ +
+
+ + + + + +
+ + + + + + + +
entt::meta_type::operator bool () const
+ 		+inlineexplicit
+
+ +

Returns true if a meta object is valid, false otherwise.

+
Returns
True if the meta object is valid, false otherwise.
+ +

Definition at line 1912 of file meta.hpp.

+ +
+
+ +

◆ operator==()

+ +
+
+ + + + + +
+ + + + + + + + +
bool entt::meta_type::operator== (const meta_type & other) const
+ 		+inline
+
+ +

Checks if two meta objects refer to the same node.

+
Parameters
+ + +
otherThe meta object with which to compare.
+
+
+
Returns
True if the two meta objects refer to the same node, false otherwise.
+ +

Definition at line 1922 of file meta.hpp.

+ +
+
+ +

◆ prop() [1/2]

+ +
+
+
+template<typename Op >
+ + + + + +
+ + + + + + + + +
std::enable_if_t<std::is_invocable_v<Op, meta_prop>, void> entt::meta_type::prop (Op op) const
+ 		+inline
+
+ +

Iterates all the properties assigned to a meta type.

+

Iteratively returns all the properties of the given type. This means that the properties of the base classes will also be returned, if any.

+
Template Parameters
+ + +
OpType of the function object to invoke.
+
+
+
Parameters
+ + +
opA valid function object.
+
+
+ +

Definition at line 1881 of file meta.hpp.

+ +
+
+ +

◆ prop() [2/2]

+ +
+
+
+template<typename Key >
+ + + + + +
+ + + + + + + + +
std::enable_if_t<!std::is_invocable_v<Key, meta_prop>, meta_prop> entt::meta_type::prop (Key && key) const
+ 		+inline
+
+ +

Returns the property associated with a given key.

+

Searches recursively among all the properties of the given type. This means that the properties of the base classes will also be inspected, if any.

+
Template Parameters
+ + +
KeyType of key to use to search for a property.
+
+
+
Parameters
+ + +
keyThe key to use to search for a property.
+
+
+
Returns
The property associated with the given key, if any.
+ +

Definition at line 1900 of file meta.hpp.

+ +
+
+ +

◆ remove_pointer()

+ +
+
+ + + + + +
+ + + + + + + +
meta_type entt::meta_type::remove_pointer () const
+ 		+inline
+
+ +

Provides the meta type for which the pointer is defined.

+
Returns
The meta type for which the pointer is defined or this meta type if it doesn't refer to a pointer type.
+ +

Definition at line 1663 of file meta.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1Process-members.html b/classentt_1_1process-members.html similarity index 66% rename from classentt_1_1Process-members.html rename to classentt_1_1process-members.html index 97b80349b..6411c7d5d 100644 --- a/classentt_1_1Process-members.html +++ b/classentt_1_1process-members.html @@ -22,7 +22,7 @@
EnTT -  2.7.3 +  3.0.0
- - - - - - - - - - - - + + + + + + + + + + + +
abort(const bool immediately=false) ENTT_NOEXCEPTentt::Process< Derived, Delta >inline
alive() const ENTT_NOEXCEPTentt::Process< Derived, Delta >inline
dead() const ENTT_NOEXCEPTentt::Process< Derived, Delta >inline
delta_type typedefentt::Process< Derived, Delta >
fail() ENTT_NOEXCEPTentt::Process< Derived, Delta >inlineprotected
pause() ENTT_NOEXCEPTentt::Process< Derived, Delta >inlineprotected
paused() const ENTT_NOEXCEPTentt::Process< Derived, Delta >inline
rejected() const ENTT_NOEXCEPTentt::Process< Derived, Delta >inline
succeed() ENTT_NOEXCEPTentt::Process< Derived, Delta >inlineprotected
tick(const Delta delta, void *data=nullptr)entt::Process< Derived, Delta >inline
unpause() ENTT_NOEXCEPTentt::Process< Derived, Delta >inlineprotected
~Process() ENTT_NOEXCEPTentt::Process< Derived, Delta >inlinevirtual
abort(const bool immediately=false) ENTT_NOEXCEPTentt::process< Derived, Delta >inline
alive() const ENTT_NOEXCEPTentt::process< Derived, Delta >inline
dead() const ENTT_NOEXCEPTentt::process< Derived, Delta >inline
delta_type typedefentt::process< Derived, Delta >
fail() ENTT_NOEXCEPTentt::process< Derived, Delta >inlineprotected
pause() ENTT_NOEXCEPTentt::process< Derived, Delta >inlineprotected
paused() const ENTT_NOEXCEPTentt::process< Derived, Delta >inline
rejected() const ENTT_NOEXCEPTentt::process< Derived, Delta >inline
succeed() ENTT_NOEXCEPTentt::process< Derived, Delta >inlineprotected
tick(const Delta delta, void *data=nullptr)entt::process< Derived, Delta >inline
unpause() ENTT_NOEXCEPTentt::process< Derived, Delta >inlineprotected
~process() ENTT_NOEXCEPTentt::process< Derived, Delta >inlinevirtual
diff --git a/classentt_1_1Process.html b/classentt_1_1process.html similarity index 72% rename from classentt_1_1Process.html rename to classentt_1_1process.html index 5dc79b4f5..12320a8b3 100644 --- a/classentt_1_1Process.html +++ b/classentt_1_1process.html @@ -5,7 +5,7 @@ -EnTT: entt::Process< Derived, Delta > Class Template Reference +EnTT: entt::process< Derived, Delta > Class Template Reference @@ -22,7 +22,7 @@
EnTT -  2.7.3 +  3.0.0
- - - + + +

Public Types

-using delta_type = Delta
 Type used to provide elapsed time.
 
+using delta_type = Delta
 Type used to provide elapsed time.
 
- - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + +

Public Member Functions

-virtual ~Process () ENTT_NOEXCEPT
 Default destructor.
 
void abort (const bool immediately=false) ENTT_NOEXCEPT
 Aborts a process if it's still alive. More...
 
bool alive () const ENTT_NOEXCEPT
 Returns true if a process is either running or paused. More...
 
bool dead () const ENTT_NOEXCEPT
 Returns true if a process is already terminated. More...
 
bool paused () const ENTT_NOEXCEPT
 Returns true if a process is currently paused. More...
 
bool rejected () const ENTT_NOEXCEPT
 Returns true if a process terminated with errors. More...
 
void tick (const Delta delta, void *data=nullptr)
 Updates a process and its internal state if required. More...
 
+virtual ~process () ENTT_NOEXCEPT
 Default destructor.
 
void abort (const bool immediately=false) ENTT_NOEXCEPT
 Aborts a process if it's still alive. More...
 
bool alive () const ENTT_NOEXCEPT
 Returns true if a process is either running or paused. More...
 
bool dead () const ENTT_NOEXCEPT
 Returns true if a process is already terminated. More...
 
bool paused () const ENTT_NOEXCEPT
 Returns true if a process is currently paused. More...
 
bool rejected () const ENTT_NOEXCEPT
 Returns true if a process terminated with errors. More...
 
void tick (const Delta delta, void *data=nullptr)
 Updates a process and its internal state if required. More...
 
- - - - - - - - - - - - + + + + + + + + + + + +

Protected Member Functions

void succeed () ENTT_NOEXCEPT
 Terminates a process with success if it's still alive. More...
 
void fail () ENTT_NOEXCEPT
 Terminates a process with errors if it's still alive. More...
 
void pause () ENTT_NOEXCEPT
 Stops a process if it's in a running state. More...
 
void unpause () ENTT_NOEXCEPT
 Restarts a process if it's paused. More...
 
void succeed () ENTT_NOEXCEPT
 Terminates a process with success if it's still alive. More...
 
void fail () ENTT_NOEXCEPT
 Terminates a process with errors if it's still alive. More...
 
void pause () ENTT_NOEXCEPT
 Stops a process if it's in a running state. More...
 
void unpause () ENTT_NOEXCEPT
 Restarts a process if it's paused. More...
 

Detailed Description

template<typename Derived, typename Delta>
-class entt::Process< Derived, Delta >

+class entt::process< Derived, Delta >

Base class for processes.

This class stays true to the CRTP idiom. Derived classes must specify what's the intended type for elapsed times.
@@ -135,7 +135,7 @@ class entt::Process< Derived, Delta >

  • void update(Delta, void *);

    It's invoked once per tick until a process is explicitly aborted or it terminates either with or without errors. Even though it's not mandatory to declare this member function, as a rule of thumb each process should at least define it to work properly. The void * parameter is an opaque pointer to user data (if any) forwarded directly to the process during an update.

    • -
  • void init(void *);

    It's invoked at the first tick, immediately before an update. The void * parameter is an opaque pointer to user data (if any) forwarded directly to the process during an update.

    +
  • void init();

    It's invoked when the process joins the running queue of a scheduler. This happens as soon as it's attached to the scheduler if the process is a top level one, otherwise when it replaces its parent if the process is a continuation.

  • void succeeded();

    It's invoked in case of success, immediately after an update and during the same tick.

    • @@ -145,7 +145,7 @@ class entt::Process< Derived, Delta >

Derived classes can change the internal state of a process by invoking the succeed and fail protected member functions and even pause or unpause the process itself.

-
See also
Scheduler
+
See also
scheduler
Template Parameters
@@ -156,8 +156,8 @@ class entt::Process< Derived, Delta >

Definition at line 73 of file process.hpp.

Member Function Documentation

- -

◆ abort()

+ +

◆ abort()

@@ -168,7 +168,7 @@ template<typename Derived, typename Delta>
@@ -59,18 +59,18 @@ $(function() {
-
entt::InsertionSort Member List
+
entt::get_t< Type > Member List
-

This is the complete list of members for entt::InsertionSort, including all inherited members.

+

This is the complete list of members for entt::get_t< Type >, including all inherited members.

DerivedActual type of process that extends the class template.
- + @@ -195,8 +195,8 @@ template<typename Derived, typename Delta> - -

◆ alive()

+ +

◆ alive()

@@ -207,7 +207,7 @@ template<typename Derived, typename Delta>
@@ -71,7 +71,7 @@ $(function() {

Entity traits. More...

-

#include <entt_traits.hpp>

+

#include <entity.hpp>

Detailed Description

template<typename>
struct entt::entt_traits< typename >

@@ -79,9 +79,9 @@ struct entt::entt_traits< typename >

Entity traits.

Primary template isn't defined on purpose. All the specializations give a compile-time error unless the template parameter is an accepted entity type.

-

Definition at line 18 of file entt_traits.hpp.

+

Definition at line 18 of file entity.hpp.

The documentation for this struct was generated from the following file: diff --git a/structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4-members.html b/structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4-members.html index 8b392c62b..2e0d0651b 100644 --- a/structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4-members.html +++ b/structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4-members.html @@ -22,7 +22,7 @@ diff --git a/structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html b/structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html index f7a248837..bc4e8c5f5 100644 --- a/structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html +++ b/structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html @@ -22,7 +22,7 @@ @@ -75,7 +75,7 @@ $(function() {

Entity traits for a 16 bits entity identifier. More...

-

#include <entt_traits.hpp>

+

#include <entity.hpp>

void entt::Process< Derived, Delta >::abort void entt::process< Derived, Delta >::abort ( const bool  immediately = false) - + @@ -227,8 +227,8 @@ template<typename Derived, typename Delta> - -

◆ dead()

+ +

◆ dead()

@@ -239,7 +239,7 @@ template<typename Derived, typename Delta>
@@ -59,25 +59,29 @@ $(function() {
-
entt::persistent_t Struct Referencefinal
+
entt::connect_arg_t< auto > Struct Template Reference
-

Persistent view type used to disambiguate overloads. - More...

+

Used to wrap a function or a member of a specified type. + More...

-

#include <utility.hpp>

+

#include <delegate.hpp>

Detailed Description

-

Persistent view type used to disambiguate overloads.

+

template<auto>
+struct entt::connect_arg_t< auto >

-

Definition at line 13 of file utility.hpp.

+

Used to wrap a function or a member of a specified type.

+

TURN_OFF_DOXYGEN

+ +

Definition at line 51 of file delegate.hpp.

The documentation for this struct was generated from the following file:
diff --git a/structentt_1_1emitter_1_1connection-members.html b/structentt_1_1emitter_1_1connection-members.html new file mode 100644 index 000000000..9a60ceef7 --- /dev/null +++ b/structentt_1_1emitter_1_1connection-members.html @@ -0,0 +1,84 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
+
+
bool entt::Process< Derived, Delta >::alive bool entt::process< Derived, Delta >::alive ( ) const - + @@ -259,8 +259,8 @@ template<typename Derived, typename Delta> - -

◆ fail()

+ +

◆ fail()

@@ -271,7 +271,7 @@ template<typename Derived, typename Delta>
@@ -60,10 +60,10 @@ $(function() {
-
docs/signal.md
+
docs/md/signal.md
-
1 # Crash Course: events, signals and everything in between
2 
3 <!--
4 @cond TURN_OFF_DOXYGEN
5 -->
6 # Table of Contents
7 
8 * [Introduction](#introduction)
9 * [Signals](#signals)
10 * [Delegate](#delegate)
11 * [Event dispatcher](#event-dispatcher)
12 * [Event emitter](#event-emitter)
13 <!--
14 @endcond TURN_OFF_DOXYGEN
15 -->
16 
17 # Introduction
18 
19 Signals are usually a core part of games and software architectures in
20 general.<br/>
21 Roughly speaking, they help to decouple the various parts of a system while
22 allowing them to communicate with each other somehow.
23 
24 The so called _modern C++_ comes with a tool that can be useful in these terms,
25 the `std::function`. As an example, it can be used to create delegates.<br/>
26 However, there is no guarantee that an `std::function` does not perform
27 allocations under the hood and this could be problematic sometimes. Furthermore,
28 it solves a problem but may not adapt well to other requirements that may arise
29 from time to time.
30 
31 In case that the flexibility and potential of an `std::function` are not
32 required or where you are looking for something different, `EnTT` offers a full
33 set of classes to solve completely different problems.
34 
35 # Signals
36 
37 Signal handlers work with naked pointers, function pointers and pointers to
38 member functions. Listeners can be any kind of objects and users are in charge
39 of connecting and disconnecting them from a signal to avoid crashes due to
40 different lifetimes. On the other side, performance shouldn't be affected that
41 much by the presence of such a signal handler.<br/>
42 A signal handler can be used as a private data member without exposing any
43 _publish_ functionality to the clients of a class. The basic idea is to impose a
44 clear separation between the signal itself and its _sink_ class, that is a tool
45 to be used to connect and disconnect listeners on the fly.
46 
47 The API of a signal handler is straightforward. The most important thing is that
48 it comes in two forms: with and without a collector. In case a signal is
49 associated with a collector, all the values returned by the listeners can be
50 literally _collected_ and used later by the caller. Otherwise it works just like
51 a plain signal that emits events from time to time.<br/>
52 
53 **Note**: collectors are allowed only in case of function types whose the return
54 type isn't `void` for obvious reasons.
55 
56 To create instances of signal handlers there exist mainly two ways:
57 
58 ```cpp
59 // no collector type
60 entt::SigH<void(int, char)> signal;
61 
62 // explicit collector type
63 entt::SigH<void(int, char), MyCollector<bool>> collector;
64 ```
65 
66 As expected, they offer all the basic functionalities required to know how many
67 listeners they contain (`size`) or if they contain at least a listener (`empty`)
68 and even to swap two signal handlers (`swap`).
69 
70 Besides them, there are member functions to use both to connect and disconnect
71 listeners in all their forms by means of a sink:
72 
73 ```cpp
74 void foo(int, char) { /* ... */ }
75 
76 struct S {
77  void bar(int, char) { /* ... */ }
78 };
79 
80 // ...
81 
82 S instance;
83 
84 signal.sink().connect<&foo>();
85 signal.sink().connect<S, &S::bar>(&instance);
86 
87 // ...
88 
89 // disconnects a free function
90 signal.sink().disconnect<&foo>();
91 
92 // disconnect a specific member function of an instance ...
93 signal.sink().disconnect<S, &S::bar>(&instance);
94 
95 // ... or an instance as a whole
96 signal.sink().disconnect(&instance);
97 
98 // discards all the listeners at once
99 signal.sink().disconnect();
100 ```
101 
102 Once listeners are attached (or even if there are no listeners at all), events
103 and data in general can be published through a signal by means of the `publish`
104 member function:
105 
106 ```cpp
107 signal.publish(42, 'c');
108 ```
109 
110 To collect data, the `collect` member function should be used instead. Below is
111 a minimal example to show how to use it:
112 
113 ```cpp
114 struct MyCollector {
115  std::vector<int> vec{};
116 
117  bool operator()(int v) noexcept {
118  vec.push_back(v);
119  return true;
120  }
121 };
122 
123 int f() { return 0; }
124 int g() { return 1; }
125 
126 // ...
127 
128 entt::SigH<int(), MyCollector<int>> signal;
129 
130 signal.sink().connect<&f>();
131 signal.sink().connect<&g>();
132 
133 MyCollector collector = signal.collect();
134 
135 assert(collector.vec[0] == 0);
136 assert(collector.vec[1] == 1);
137 ```
138 
139 As shown above, a collector must expose a function operator that accepts as an
140 argument a type to which the return type of the listeners can be converted.
141 Moreover, it has to return a boolean value that is false to stop collecting
142 data, true otherwise. This way one can avoid calling all the listeners in case
143 it isn't necessary.
144 
145 # Delegate
146 
147 A delegate can be used as general purpose invoker with no memory overhead for
148 free functions and member functions provided along with an instance on which
149 to invoke them.<br/>
150 It does not claim to be a drop-in replacement for an `std::function`, so do not
151 expect to use it whenever an `std::function` fits well. However, it can be used
152 to send opaque delegates around to be used to invoke functions as needed.
153 
154 The interface is trivial. It offers a default constructor to create empty
155 delegates:
156 
157 ```cpp
158 entt::Delegate<int(int)> delegate{};
159 ```
160 
161 All what is needed to create an instance is to specify the type of the function
162 the delegate will _contain_, that is the signature of the free function or the
163 member function one wants to assign to it.
164 
165 Attempting to use an empty delegate by invoking its function call operator
166 results in undefined behavior, most likely a crash actually. Before to use a
167 delegate, it must be initialized.<br/>
168 There exist two functions to do that, both named `connect`:
169 
170 ```cpp
171 int f(int i) { return i; }
172 
173 struct MyStruct {
174  int f(int i) { return i }
175 };
176 
177 // bind a free function to the delegate
178 delegate.connect<&f>();
179 
180 // bind a member function to the delegate
181 MyStruct instance;
182 delegate.connect<MyStruct, &MyStruct::f>(&instance);
183 ```
184 
185 It hasn't a `disconnect` counterpart. Instead, there exists a `reset` member
186 function to clear it.<br/>
187 The `empty` member function can be used to know if a delegate is empty:
188 
189 ```cpp
190 const auto empty = delegate.empty();
191 ```
192 
193 Finally, to invoke a delegate, the function call operator is the way to go as
194 usual:
195 
196 ```cpp
197 auto ret = delegate(42);
198 ```
199 
200 Probably too much small and pretty poor of functionalities, but the delegate
201 class can help in a lot of cases and it has shown that it is worth keeping it
202 within the library.
203 
204 # Event dispatcher
205 
206 The event dispatcher class is designed so as to be used in a loop. It allows
207 users both to trigger immediate events or to queue events to be published all
208 together once per tick.<br/>
209 This class shares part of its API with the one of the signal handler, but it
210 doesn't require that all the types of events are specified when declared:
211 
212 ```cpp
213 // define a general purpose dispatcher that works with naked pointers
214 entt::Dispatcher dispatcher{};
215 ```
216 
217 In order to register an instance of a class to a dispatcher, its type must
218 expose one or more member functions of which the return types are `void` and the
219 argument lists are `const E &`, for each type of event `E`.<br/>
220 To ease the development, member functions that are named `receive` are
221 automatically detected and have not to be explicitly specified when registered.
222 In all the other cases, the name of the member function aimed to receive the
223 event must be provided to the `connect` member function of the sink bound to the
224 specific event:
225 
226 ```cpp
227 struct AnEvent { int value; };
228 struct AnotherEvent {};
229 
230 struct Listener
231 {
232  void receive(const AnEvent &) { /* ... */ }
233  void method(const AnotherEvent &) { /* ... */ }
234 };
235 
236 // ...
237 
238 Listener listener;
239 dispatcher.sink<AnEvent>().connect(&listener);
240 dispatcher.sink<AnotherEvent>().connect<Listener, &Listener::method>(&listener);
241 ```
242 
243 The `disconnect` member function follows the same pattern and can be used to
244 selectively remove listeners:
245 
246 ```cpp
247 dispatcher.sink<AnEvent>().disconnect(&listener);
248 dispatcher.sink<AnotherEvent>().disconnect<Listener, &Listener::method>(&listener);
249 ```
250 
251 The `trigger` member function serves the purpose of sending an immediate event
252 to all the listeners registered so far. It offers a convenient approach that
253 relieves users from having to create the event itself. Instead, it's enough to
254 specify the type of event and provide all the parameters required to construct
255 it.<br/>
256 As an example:
257 
258 ```cpp
259 dispatcher.trigger<AnEvent>(42);
260 dispatcher.trigger<AnotherEvent>();
261 ```
262 
263 Listeners are invoked immediately, order of execution isn't guaranteed. This
264 method can be used to push around urgent messages like an _is terminating_
265 notification on a mobile app.
266 
267 On the other hand, the `enqueue` member function queues messages together and
268 allows to maintain control over the moment they are sent to listeners. The
269 signature of this method is more or less the same of `trigger`:
270 
271 ```cpp
272 dispatcher.enqueue<AnEvent>(42);
273 dispatcher.enqueue<AnotherEvent>();
274 ```
275 
276 Events are stored aside until the `update` member function is invoked, then all
277 the messages that are still pending are sent to the listeners at once:
278 
279 ```cpp
280 // emits all the events of the given type at once
281 dispatcher.update<MyEvent>();
282 
283 // emits all the events queued so far at once
284 dispatcher.update();
285 ```
286 
287 This way users can embed the dispatcher in a loop and literally dispatch events
288 once per tick to their systems.
289 
290 # Event emitter
291 
292 A general purpose event emitter thought mainly for those cases where it comes to
293 working with asynchronous stuff.<br/>
294 Originally designed to fit the requirements of
295 [`uvw`](https://github.com/skypjack/uvw) (a wrapper for `libuv` written in
296 modern C++), it was adapted later to be included in this library.
297 
298 To create a custom emitter type, derived classes must inherit directly from the
299 base class as:
300 
301 ```cpp
302 struct MyEmitter: Emitter<MyEmitter> {
303  // ...
304 }
305 ```
306 
307 The full list of accepted types of events isn't required. Handlers are created
308 internally on the fly and thus each type of event is accepted by default.
309 
310 Whenever an event is published, an emitter provides the listeners with a
311 reference to itself along with a const reference to the event. Therefore
312 listeners have an handy way to work with it without incurring in the need of
313 capturing a reference to the emitter itself.<br/>
314 In addition, an opaque object is returned each time a connection is established
315 between an emitter and a listener, allowing the caller to disconnect them at a
316 later time.<br/>
317 The opaque object used to handle connections is both movable and copyable. On
318 the other side, an event emitter is movable but not copyable by default.
319 
320 To create new instances of an emitter, no arguments are required:
321 
322 ```cpp
323 MyEmitter emitter{};
324 ```
325 
326 Listeners must be movable and callable objects (free functions, lambdas,
327 functors, `std::function`s, whatever) whose function type is:
328 
329 ```cpp
330 void(const Event &, MyEmitter &)
331 ```
332 
333 Where `Event` is the type of event they want to listen.<br/>
334 There are two ways to attach a listener to an event emitter that differ
335 slightly from each other:
336 
337 * To register a long-lived listener, use the `on` member function. It is meant
338  to register a listener designed to be invoked more than once for the given
339  event type.<br/>
340  As an example:
341 
342  ```cpp
343  auto conn = emitter.on<MyEvent>([](const MyEvent &event, MyEmitter &emitter) {
344  // ...
345  });
346  ```
347 
348  The connection object can be freely discarded. Otherwise, it can be used later
349  to disconnect the listener if required.
350 
351 * To register a short-lived listener, use the `once` member function. It is
352  meant to register a listener designed to be invoked only once for the given
353  event type. The listener is automatically disconnected after the first
354  invocation.<br/>
355  As an example:
356 
357  ```cpp
358  auto conn = emitter.once<MyEvent>([](const MyEvent &event, MyEmitter &emitter) {
359  // ...
360  });
361  ```
362 
363  The connection object can be freely discarded. Otherwise, it can be used later
364  to disconnect the listener if required.
365 
366 In both cases, the connection object can be used with the `erase` member
367 function:
368 
369 ```cpp
370 emitter.erase(conn);
371 ```
372 
373 There are also two member functions to use either to disconnect all the
374 listeners for a given type of event or to clear the emitter:
375 
376 ```cpp
377 // removes all the listener for the specific event
378 emitter.clear<MyEvent>();
379 
380 // removes all the listeners registered so far
381 emitter.clear();
382 ```
383 
384 To send an event to all the listeners that are interested in it, the `publish`
385 member function offers a convenient approach that relieves users from having to
386 create the event:
387 
388 ```cpp
389 struct MyEvent { int i; };
390 
391 // ...
392 
393 emitter.publish<MyEvent>(42);
394 ```
395 
396 Finally, the `empty` member function tests if there exists at least either a
397 listener registered with the event emitter or to a given type of event:
398 
399 ```cpp
400 bool empty;
401 
402 // checks if there is any listener registered for the specific event
403 empty = emitter.empty<MyEvent>();
404 
405 // checks it there are listeners registered with the event emitter
406 empty = emitter.empty();
407 ```
408 
409 In general, the event emitter is a handy tool when the derived classes _wrap_
410 asynchronous operations, because it introduces a _nice-to-have_ model based on
411 events and listeners that kindly hides the complexity behind the scenes. However
412 it is not limited to such uses.
+
1 # Crash Course: events, signals and everything in between
2 
3 <!--
4 @cond TURN_OFF_DOXYGEN
5 -->
6 # Table of Contents
7 
8 * [Introduction](#introduction)
9 * [Delegate](#delegate)
10 * [Signals](#signals)
11 * [Event dispatcher](#event-dispatcher)
12 * [Event emitter](#event-emitter)
13 <!--
14 @endcond TURN_OFF_DOXYGEN
15 -->
16 
17 # Introduction
18 
19 Signals are usually a core part of games and software architectures in
20 general.<br/>
21 Roughly speaking, they help to decouple the various parts of a system while
22 allowing them to communicate with each other somehow.
23 
24 The so called _modern C++_ comes with a tool that can be useful in these terms,
25 the `std::function`. As an example, it can be used to create delegates.<br/>
26 However, there is no guarantee that an `std::function` does not perform
27 allocations under the hood and this could be problematic sometimes. Furthermore,
28 it solves a problem but may not adapt well to other requirements that may arise
29 from time to time.
30 
31 In case that the flexibility and potential of an `std::function` are not
32 required or where you are looking for something different, `EnTT` offers a full
33 set of classes to solve completely different problems.
34 
35 # Delegate
36 
37 A delegate can be used as a general purpose invoker with no memory overhead for
38 free functions and members provided along with an instance on which to invoke
39 them.<br/>
40 It does not claim to be a drop-in replacement for an `std::function`, so do not
41 expect to use it whenever an `std::function` fits well. However, it can be used
42 to send opaque delegates around to be used to invoke functions as needed.
43 
44 The interface is trivial. It offers a default constructor to create empty
45 delegates:
46 
47 ```cpp
48 entt::delegate<int(int)> delegate{};
49 ```
50 
51 All what is needed to create an instance is to specify the type of the function
52 the delegate will _contain_, that is the signature of the free function or the
53 member function one wants to assign to it.
54 
55 Attempting to use an empty delegate by invoking its function call operator
56 results in undefined behavior or most likely a crash. Before to use a delegate,
57 it must be initialized.<br/>
58 There exists a bunch of overloads of the `connect` member function to do that.
59 As an example of use:
60 
61 ```cpp
62 int f(int i) { return i; }
63 
64 struct my_struct {
65  int f(const int &i) { return i }
66 };
67 
68 // bind a free function to the delegate
69 delegate.connect<&f>();
70 
71 // bind a member function to the delegate
72 my_struct instance;
73 delegate.connect<&my_struct::f>(&instance);
74 ```
75 
76 The delegate class accepts also data members, if needed. In this case, the
77 function type of the delegate is such that the parameter list is empty and the
78 value of the data member is at least convertible to the return type.<br/>
79 Functions having type equivalent to `void(T *, args...)` are accepted as well.
80 In this case, `T *` is considered a payload and the function will receive it
81 back every time it's invoked. In other terms, this works just fine with the
82 above definition:
83 
84 ```cpp
85 void g(const char *c, int i) { /* ... */ }
86 const char c = 'c';
87 
88 delegate.connect<&g>(&c);
89 delegate(42);
90 ```
91 
92 The function `g` will be invoked with a pointer to `c` and `42`. However, the
93 function type of the delegate is still `void(int)`, mainly because this is also
94 the signature of its function call operator.
95 
96 To create and initialize a delegate at once, there are also some specialized
97 constructors. Because of the rules of the language, the listener is provided by
98 means of the `entt::connect_arg` variable template:
99 
100 ```cpp
101 entt::delegate<int(int)> func{entt::connect_arg<&f>};
102 ```
103 
104 Aside `connect`, a `disconnect` counterpart isn't provided. Instead, there
105 exists a `reset` member function to use to clear a delegate.<br/>
106 To know if a delegate is empty, it can be used explicitly in every conditional
107 statement:
108 
109 ```cpp
110 if(delegate) {
111  // ...
112 }
113 ```
114 
115 Finally, to invoke a delegate, the function call operator is the way to go as
116 usual:
117 
118 ```cpp
119 auto ret = delegate(42);
120 ```
121 
122 As shown above, listeners do not have to strictly follow the signature of the
123 delegate. As long as a listener can be invoked with the given arguments to yield
124 a result that is convertible to the given result type, everything works just
125 fine.
126 
127 Probably too much small and pretty poor of functionalities, but the delegate
128 class can help in a lot of cases and it has shown that it is worth keeping it
129 within the library.
130 
131 # Signals
132 
133 Signal handlers work with naked pointers, function pointers and pointers to
134 member functions. Listeners can be any kind of objects and users are in charge
135 of connecting and disconnecting them from a signal to avoid crashes due to
136 different lifetimes. On the other side, performance shouldn't be affected that
137 much by the presence of such a signal handler.<br/>
138 A signal handler can be used as a private data member without exposing any
139 _publish_ functionality to the clients of a class. The basic idea is to impose a
140 clear separation between the signal itself and its _sink_ class, that is a tool
141 to be used to connect and disconnect listeners on the fly.
142 
143 The API of a signal handler is straightforward. The most important thing is that
144 it comes in two forms: with and without a collector. In case a signal is
145 associated with a collector, all the values returned by the listeners can be
146 literally _collected_ and used later by the caller. Otherwise it works just like
147 a plain signal that emits events from time to time.<br/>
148 
149 **Note**: collectors are allowed only in case of function types whose the return
150 type isn't `void` for obvious reasons.
151 
152 To create instances of signal handlers there exist mainly two ways:
153 
154 ```cpp
155 // no collector type
156 entt::sigh<void(int, char)> signal;
157 
158 // explicit collector type
159 entt::sigh<void(int, char), my_collector<bool>> collector;
160 ```
161 
162 As expected, they offer all the basic functionalities required to know how many
163 listeners they contain (`size`) or if they contain at least a listener (`empty`)
164 and even to swap two signal handlers (`swap`).
165 
166 Besides them, there are member functions to use both to connect and disconnect
167 listeners in all their forms by means of a sink:
168 
169 ```cpp
170 void foo(int, char) { /* ... */ }
171 
172 struct listener {
173  void bar(const int &, char) { /* ... */ }
174 };
175 
176 // ...
177 
178 listener instance;
179 
180 signal.sink().connect<&foo>();
181 signal.sink().connect<&listener::bar>(&instance);
182 
183 // ...
184 
185 // disconnects a free function
186 signal.sink().disconnect<&foo>();
187 
188 // disconnect a member function of an instance
189 signal.sink().disconnect<&listener::bar>(&instance);
190 
191 // discards all the listeners at once
192 signal.sink().disconnect();
193 ```
194 
195 As shown above, listeners do not have to strictly follow the signature of the
196 signal. As long as a listener can be invoked with the given arguments to yield a
197 result that is convertible to the given result type, everything works just fine.
198 
199 Once listeners are attached (or even if there are no listeners at all), events
200 and data in general can be published through a signal by means of the `publish`
201 member function:
202 
203 ```cpp
204 signal.publish(42, 'c');
205 ```
206 
207 To collect data, the `collect` member function should be used instead. Below is
208 a minimal example to show how to use it:
209 
210 ```cpp
211 struct my_collector {
212  std::vector<int> vec{};
213 
214  bool operator()(int v) noexcept {
215  vec.push_back(v);
216  return true;
217  }
218 };
219 
220 int f() { return 0; }
221 int g() { return 1; }
222 
223 // ...
224 
225 entt::sigh<int(), my_collector<int>> signal;
226 
227 signal.sink().connect<&f>();
228 signal.sink().connect<&g>();
229 
230 my_collector collector = signal.collect();
231 
232 assert(collector.vec[0] == 0);
233 assert(collector.vec[1] == 1);
234 ```
235 
236 A collector must expose a function operator that accepts as an argument a type
237 to which the return type of the listeners can be converted. Moreover, it has to
238 return a boolean value that is false to stop collecting data, true otherwise.
239 This way one can avoid calling all the listeners in case it isn't necessary.
240 
241 # Event dispatcher
242 
243 The event dispatcher class is designed so as to be used in a loop. It allows
244 users both to trigger immediate events or to queue events to be published all
245 together once per tick.<br/>
246 This class shares part of its API with the one of the signal handler, but it
247 doesn't require that all the types of events are specified when declared:
248 
249 ```cpp
250 // define a general purpose dispatcher that works with naked pointers
251 entt::dispatcher dispatcher{};
252 ```
253 
254 In order to register an instance of a class to a dispatcher, its type must
255 expose one or more member functions the arguments of which are such that
256 `const E &` can be converted to them for each type of event `E`, no matter what
257 the return value is.<br/>
258 The name of the member function aimed to receive the event must be provided to
259 the `connect` member function of the sink in charge for the specific event:
260 
261 ```cpp
262 struct an_event { int value; };
263 struct another_event {};
264 
265 struct listener
266 {
267  void receive(const an_event &) { /* ... */ }
268  void method(const another_event &) { /* ... */ }
269 };
270 
271 // ...
272 
273 listener listener;
274 dispatcher.sink<an_event>().connect<&listener::receive>(&listener);
275 dispatcher.sink<another_event>().connect<&listener::method>(&listener);
276 ```
277 
278 The `disconnect` member function follows the same pattern and can be used to
279 selectively remove listeners:
280 
281 ```cpp
282 dispatcher.sink<an_event>().disconnect<&listener::receive>(&listener);
283 dispatcher.sink<another_event>().disconnect<&listener::method>(&listener);
284 ```
285 
286 The `trigger` member function serves the purpose of sending an immediate event
287 to all the listeners registered so far. It offers a convenient approach that
288 relieves users from having to create the event itself. Instead, it's enough to
289 specify the type of event and provide all the parameters required to construct
290 it.<br/>
291 As an example:
292 
293 ```cpp
294 dispatcher.trigger<an_event>(42);
295 dispatcher.trigger<another_event>();
296 ```
297 
298 Listeners are invoked immediately, order of execution isn't guaranteed. This
299 method can be used to push around urgent messages like an _is terminating_
300 notification on a mobile app.
301 
302 On the other hand, the `enqueue` member function queues messages together and
303 allows to maintain control over the moment they are sent to listeners. The
304 signature of this method is more or less the same of `trigger`:
305 
306 ```cpp
307 dispatcher.enqueue<an_event>(42);
308 dispatcher.enqueue<another_event>();
309 ```
310 
311 Events are stored aside until the `update` member function is invoked, then all
312 the messages that are still pending are sent to the listeners at once:
313 
314 ```cpp
315 // emits all the events of the given type at once
316 dispatcher.update<my_event>();
317 
318 // emits all the events queued so far at once
319 dispatcher.update();
320 ```
321 
322 This way users can embed the dispatcher in a loop and literally dispatch events
323 once per tick to their systems.
324 
325 # Event emitter
326 
327 A general purpose event emitter thought mainly for those cases where it comes to
328 working with asynchronous stuff.<br/>
329 Originally designed to fit the requirements of
330 [`uvw`](https://github.com/skypjack/uvw) (a wrapper for `libuv` written in
331 modern C++), it was adapted later to be included in this library.
332 
333 To create a custom emitter type, derived classes must inherit directly from the
334 base class as:
335 
336 ```cpp
337 struct my_emitter: emitter<my_emitter> {
338  // ...
339 }
340 ```
341 
342 The full list of accepted types of events isn't required. Handlers are created
343 internally on the fly and thus each type of event is accepted by default.
344 
345 Whenever an event is published, an emitter provides the listeners with a
346 reference to itself along with a const reference to the event. Therefore
347 listeners have an handy way to work with it without incurring in the need of
348 capturing a reference to the emitter itself.<br/>
349 In addition, an opaque object is returned each time a connection is established
350 between an emitter and a listener, allowing the caller to disconnect them at a
351 later time.<br/>
352 The opaque object used to handle connections is both movable and copyable. On
353 the other side, an event emitter is movable but not copyable by default.
354 
355 To create new instances of an emitter, no arguments are required:
356 
357 ```cpp
358 my_emitter emitter{};
359 ```
360 
361 Listeners must be movable and callable objects (free functions, lambdas,
362 functors, `std::function`s, whatever) whose function type is:
363 
364 ```cpp
365 void(const Event &, my_emitter &)
366 ```
367 
368 Where `Event` is the type of event they want to listen.<br/>
369 There are two ways to attach a listener to an event emitter that differ
370 slightly from each other:
371 
372 * To register a long-lived listener, use the `on` member function. It is meant
373  to register a listener designed to be invoked more than once for the given
374  event type.<br/>
375  As an example:
376 
377  ```cpp
378  auto conn = emitter.on<my_event>([](const my_event &event, my_emitter &emitter) {
379  // ...
380  });
381  ```
382 
383  The connection object can be freely discarded. Otherwise, it can be used later
384  to disconnect the listener if required.
385 
386 * To register a short-lived listener, use the `once` member function. It is
387  meant to register a listener designed to be invoked only once for the given
388  event type. The listener is automatically disconnected after the first
389  invocation.<br/>
390  As an example:
391 
392  ```cpp
393  auto conn = emitter.once<my_event>([](const my_event &event, my_emitter &emitter) {
394  // ...
395  });
396  ```
397 
398  The connection object can be freely discarded. Otherwise, it can be used later
399  to disconnect the listener if required.
400 
401 In both cases, the connection object can be used with the `erase` member
402 function:
403 
404 ```cpp
405 emitter.erase(conn);
406 ```
407 
408 There are also two member functions to use either to disconnect all the
409 listeners for a given type of event or to clear the emitter:
410 
411 ```cpp
412 // removes all the listener for the specific event
413 emitter.clear<my_event>();
414 
415 // removes all the listeners registered so far
416 emitter.clear();
417 ```
418 
419 To send an event to all the listeners that are interested in it, the `publish`
420 member function offers a convenient approach that relieves users from having to
421 create the event:
422 
423 ```cpp
424 struct my_event { int i; };
425 
426 // ...
427 
428 emitter.publish<my_event>(42);
429 ```
430 
431 Finally, the `empty` member function tests if there exists at least either a
432 listener registered with the event emitter or to a given type of event:
433 
434 ```cpp
435 bool empty;
436 
437 // checks if there is any listener registered for the specific event
438 empty = emitter.empty<my_event>();
439 
440 // checks it there are listeners registered with the event emitter
441 empty = emitter.empty();
442 ```
443 
444 In general, the event emitter is a handy tool when the derived classes _wrap_
445 asynchronous operations, because it introduces a _nice-to-have_ model based on
446 events and listeners that kindly hides the complexity behind the scenes. However
447 it is not limited to such uses.
Generated by   diff --git a/snapshot_8hpp_source.html b/snapshot_8hpp_source.html index 70434a9b7..9870212db 100644 --- a/snapshot_8hpp_source.html +++ b/snapshot_8hpp_source.html @@ -22,7 +22,7 @@
@@ -67,36 +67,31 @@ $(function() {
snapshot.hpp
-
1 #ifndef ENTT_ENTITY_SNAPSHOT_HPP
2 #define ENTT_ENTITY_SNAPSHOT_HPP
3 
4 
5 #include <array>
6 #include <cstddef>
7 #include <utility>
8 #include <cassert>
9 #include <iterator>
10 #include <type_traits>
11 #include <unordered_map>
12 #include "../config/config.h"
13 #include "entt_traits.hpp"
14 #include "utility.hpp"
15 
16 
17 namespace entt {
18 
19 
23 template<typename>
24 class Registry;
25 
26 
37 template<typename Entity>
38 class Snapshot final {
40  friend class Registry<Entity>;
41 
42  using follow_fn_type = Entity(const Registry<Entity> &, const Entity);
43 
44  Snapshot(const Registry<Entity> &registry, Entity seed, follow_fn_type *follow) ENTT_NOEXCEPT
45  : registry{registry},
46  seed{seed},
47  follow{follow}
48  {}
49 
50  template<typename Component, typename Archive, typename It>
51  void get(Archive &archive, std::size_t sz, It first, It last) const {
52  archive(static_cast<Entity>(sz));
53 
54  while(first != last) {
55  const auto entity = *(first++);
56 
57  if(registry.template has<Component>(entity)) {
58  archive(entity, registry.template get<Component>(entity));
59  }
60  }
61  }
62 
63  template<typename... Component, typename Archive, typename It, std::size_t... Indexes>
64  void component(Archive &archive, It first, It last, std::index_sequence<Indexes...>) const {
65  std::array<std::size_t, sizeof...(Indexes)> size{};
66  auto begin = first;
67 
68  while(begin != last) {
69  const auto entity = *(begin++);
70  using accumulator_type = std::size_t[];
71  accumulator_type accumulator = { (registry.template has<Component>(entity) ? ++size[Indexes] : size[Indexes])... };
72  (void)accumulator;
73  }
74 
75  using accumulator_type = int[];
76  accumulator_type accumulator = { (get<Component>(archive, size[Indexes], first, last), 0)... };
77  (void)accumulator;
78  }
79 
80 public:
82  Snapshot(const Snapshot &) = delete;
84  Snapshot(Snapshot &&) = default;
85 
87  Snapshot & operator=(const Snapshot &) = delete;
89  Snapshot & operator=(Snapshot &&) = default;
90 
101  template<typename Archive>
102  const Snapshot & entities(Archive &archive) const {
103  archive(static_cast<Entity>(registry.alive()));
104  registry.each([&archive](const auto entity) { archive(entity); });
105  return *this;
106  }
107 
118  template<typename Archive>
119  const Snapshot & destroyed(Archive &archive) const {
120  auto size = registry.size() - registry.alive();
121  archive(static_cast<Entity>(size));
122 
123  if(size) {
124  auto curr = seed;
125  archive(curr);
126 
127  for(--size; size; --size) {
128  curr = follow(registry, curr);
129  archive(curr);
130  }
131  }
132 
133  return *this;
134  }
135 
147  template<typename Component, typename Archive>
148  const Snapshot & component(Archive &archive) const {
149  const auto sz = registry.template size<Component>();
150  const auto *entities = registry.template data<Component>();
151 
152  archive(static_cast<Entity>(sz));
153 
154  for(std::remove_const_t<decltype(sz)> i{}; i < sz; ++i) {
155  const auto entity = entities[i];
156  archive(entity, registry.template get<Component>(entity));
157  };
158 
159  return *this;
160  }
161 
173  template<typename... Component, typename Archive>
174  std::enable_if_t<(sizeof...(Component) > 1), const Snapshot &>
175  component(Archive &archive) const {
176  using accumulator_type = int[];
177  accumulator_type accumulator = { 0, (component<Component>(archive), 0)... };
178  (void)accumulator;
179  return *this;
180  }
181 
196  template<typename... Component, typename Archive, typename It>
197  const Snapshot & component(Archive &archive, It first, It last) const {
198  component<Component...>(archive, first, last, std::make_index_sequence<sizeof...(Component)>{});
199  return *this;
200  }
201 
213  template<typename Tag, typename Archive>
214  const Snapshot & tag(Archive &archive) const {
215  const bool has = registry.template has<Tag>();
216 
217  // numerical length is forced for tags to facilitate loading
218  archive(has ? Entity(1): Entity{});
219 
220  if(has) {
221  archive(registry.template attachee<Tag>(), registry.template get<Tag>());
222  }
223 
224  return *this;
225  }
226 
238  template<typename... Tag, typename Archive>
239  std::enable_if_t<(sizeof...(Tag) > 1), const Snapshot &>
240  tag(Archive &archive) const {
241  using accumulator_type = int[];
242  accumulator_type accumulator = { 0, (tag<Tag>(archive), 0)... };
243  (void)accumulator;
244  return *this;
245  }
246 
247 private:
248  const Registry<Entity> &registry;
249  const Entity seed;
250  follow_fn_type *follow;
251 };
252 
253 
264 template<typename Entity>
265 class SnapshotLoader final {
267  friend class Registry<Entity>;
268 
269  using assure_fn_type = void(Registry<Entity> &, const Entity, const bool);
270 
271  SnapshotLoader(Registry<Entity> &registry, assure_fn_type *assure_fn) ENTT_NOEXCEPT
272  : registry{registry},
273  assure_fn{assure_fn}
274  {
275  // restore a snapshot as a whole requires a clean registry
276  assert(!registry.capacity());
277  }
278 
279  template<typename Archive>
280  void assure(Archive &archive, bool destroyed) const {
281  Entity length{};
282  archive(length);
283 
284  while(length--) {
285  Entity entity{};
286  archive(entity);
287  assure_fn(registry, entity, destroyed);
288  }
289  }
290 
291  template<typename Type, typename Archive, typename... Args>
292  void assign(Archive &archive, Args... args) const {
293  Entity length{};
294  archive(length);
295 
296  while(length--) {
297  Entity entity{};
298  Type instance{};
299  archive(entity, instance);
300  static constexpr auto destroyed = false;
301  assure_fn(registry, entity, destroyed);
302  registry.template assign<Type>(args..., entity, static_cast<const Type &>(instance));
303  }
304  }
305 
306 public:
308  SnapshotLoader(const SnapshotLoader &) = delete;
310  SnapshotLoader(SnapshotLoader &&) = default;
311 
313  SnapshotLoader & operator=(const SnapshotLoader &) = delete;
315  SnapshotLoader & operator=(SnapshotLoader &&) = default;
316 
327  template<typename Archive>
328  const SnapshotLoader & entities(Archive &archive) const {
329  static constexpr auto destroyed = false;
330  assure(archive, destroyed);
331  return *this;
332  }
333 
344  template<typename Archive>
345  const SnapshotLoader & destroyed(Archive &archive) const {
346  static constexpr auto destroyed = true;
347  assure(archive, destroyed);
348  return *this;
349  }
350 
364  template<typename... Component, typename Archive>
365  const SnapshotLoader & component(Archive &archive) const {
366  using accumulator_type = int[];
367  accumulator_type accumulator = { 0, (assign<Component>(archive), 0)... };
368  (void)accumulator;
369  return *this;
370  }
371 
385  template<typename... Tag, typename Archive>
386  const SnapshotLoader & tag(Archive &archive) const {
387  using accumulator_type = int[];
388  accumulator_type accumulator = { 0, (assign<Tag>(archive, tag_t{}), 0)... };
389  (void)accumulator;
390  return *this;
391  }
392 
403  const SnapshotLoader & orphans() const {
404  registry.orphans([this](const auto entity) {
405  registry.destroy(entity);
406  });
407 
408  return *this;
409  }
410 
411 private:
412  Registry<Entity> &registry;
413  assure_fn_type *assure_fn;
414 };
415 
416 
433 template<typename Entity>
434 class ContinuousLoader final {
435  using traits_type = entt_traits<Entity>;
436 
437  void destroy(Entity entity) {
438  const auto it = remloc.find(entity);
439 
440  if(it == remloc.cend()) {
441  const auto local = registry.create();
442  remloc.emplace(entity, std::make_pair(local, true));
443  registry.destroy(local);
444  }
445  }
446 
447  void restore(Entity entity) {
448  const auto it = remloc.find(entity);
449 
450  if(it == remloc.cend()) {
451  const auto local = registry.create();
452  remloc.emplace(entity, std::make_pair(local, true));
453  } else {
454  remloc[entity].first =
455  registry.valid(remloc[entity].first)
456  ? remloc[entity].first
457  : registry.create();
458 
459  // set the dirty flag
460  remloc[entity].second = true;
461  }
462  }
463 
464  template<typename Type, typename Member>
465  std::enable_if_t<std::is_same<Member, Entity>::value>
466  update(Type &instance, Member Type:: *member) {
467  instance.*member = map(instance.*member);
468  }
469 
470  template<typename Type, typename Member>
471  std::enable_if_t<std::is_same<typename std::iterator_traits<typename Member::iterator>::value_type, Entity>::value>
472  update(Type &instance, Member Type:: *member) {
473  for(auto &entity: instance.*member) {
474  entity = map(entity);
475  }
476  }
477 
478  template<typename Other, typename Type, typename Member>
479  std::enable_if_t<!std::is_same<Other, Type>::value>
480  update(Other &, Member Type:: *) {}
481 
482  template<typename Archive>
483  void assure(Archive &archive, void(ContinuousLoader:: *member)(Entity)) {
484  Entity length{};
485  archive(length);
486 
487  while(length--) {
488  Entity entity{};
489  archive(entity);
490  (this->*member)(entity);
491  }
492  }
493 
494  template<typename Component>
495  void reset() {
496  for(auto &&ref: remloc) {
497  const auto local = ref.second.first;
498 
499  if(registry.valid(local)) {
500  registry.template reset<Component>(local);
501  }
502  }
503  }
504 
505  template<typename Other, typename Archive, typename Func, typename... Type, typename... Member>
506  void assign(Archive &archive, Func func, Member Type:: *... member) {
507  Entity length{};
508  archive(length);
509 
510  while(length--) {
511  Entity entity{};
512  Other instance{};
513 
514  archive(entity, instance);
515  restore(entity);
516 
517  using accumulator_type = int[];
518  accumulator_type accumulator = { 0, (update(instance, member), 0)... };
519  (void)accumulator;
520 
521  func(map(entity), instance);
522  }
523  }
524 
525 public:
527  using entity_type = Entity;
528 
533  ContinuousLoader(Registry<entity_type> &registry) ENTT_NOEXCEPT
534  : registry{registry}
535  {}
536 
538  ContinuousLoader(const ContinuousLoader &) = delete;
540  ContinuousLoader(ContinuousLoader &&) = default;
541 
543  ContinuousLoader & operator=(const ContinuousLoader &) = delete;
545  ContinuousLoader & operator=(ContinuousLoader &&) = default;
546 
557  template<typename Archive>
558  ContinuousLoader & entities(Archive &archive) {
559  assure(archive, &ContinuousLoader::restore);
560  return *this;
561  }
562 
573  template<typename Archive>
574  ContinuousLoader & destroyed(Archive &archive) {
575  assure(archive, &ContinuousLoader::destroy);
576  return *this;
577  }
578 
598  template<typename... Component, typename Archive, typename... Type, typename... Member>
599  ContinuousLoader & component(Archive &archive, Member Type:: *... member) {
600  auto apply = [this](const auto entity, const auto &component) {
601  registry.template accommodate<std::decay_t<decltype(component)>>(entity, component);
602  };
603 
604  using accumulator_type = int[];
605  accumulator_type accumulator = { 0, (reset<Component>(), assign<Component>(archive, apply, member...), 0)... };
606  (void)accumulator;
607  return *this;
608  }
609 
629  template<typename... Tag, typename Archive, typename... Type, typename... Member>
630  ContinuousLoader & tag(Archive &archive, Member Type:: *... member) {
631  auto apply = [this](const auto entity, const auto &tag) {
632  registry.template assign<std::decay_t<decltype(tag)>>(tag_t{}, entity, tag);
633  };
634 
635  using accumulator_type = int[];
636  accumulator_type accumulator = { 0, (registry.template remove<Tag>(), assign<Tag>(archive, apply, member...), 0)... };
637  (void)accumulator;
638  return *this;
639  }
640 
649  ContinuousLoader & shrink() {
650  auto it = remloc.begin();
651 
652  while(it != remloc.cend()) {
653  const auto local = it->second.first;
654  bool &dirty = it->second.second;
655 
656  if(dirty) {
657  dirty = false;
658  ++it;
659  } else {
660  if(registry.valid(local)) {
661  registry.destroy(local);
662  }
663 
664  it = remloc.erase(it);
665  }
666  }
667 
668  return *this;
669  }
670 
681  ContinuousLoader & orphans() {
682  registry.orphans([this](const auto entity) {
683  registry.destroy(entity);
684  });
685 
686  return *this;
687  }
688 
694  bool has(entity_type entity) const ENTT_NOEXCEPT {
695  return (remloc.find(entity) != remloc.cend());
696  }
697 
710  entity_type map(entity_type entity) const ENTT_NOEXCEPT {
711  assert(has(entity));
712  return remloc.find(entity)->second.first;
713  }
714 
715 private:
716  std::unordered_map<Entity, std::pair<Entity, bool>> remloc;
717  Registry<Entity> &registry;
718 };
719 
720 
721 }
722 
723 
724 #endif // ENTT_ENTITY_SNAPSHOT_HPP
entt::ContinuousLoader::tag
ContinuousLoader & tag(Archive &archive, Member Type::*... member)
Restores tags and assigns them to the right entities.
Definition: snapshot.hpp:630
-
entt::ContinuousLoader::map
entity_type map(entity_type entity) const ENTT_NOEXCEPT
Returns the identifier to which an entity refers.
Definition: snapshot.hpp:710
-
entt::Registry
Fast and reliable entity-component system.
Definition: registry.hpp:42
-
entt::SnapshotLoader
Utility class to restore a snapshot as a whole.
Definition: snapshot.hpp:265
-
entt::SnapshotLoader::tag
const SnapshotLoader & tag(Archive &archive) const
Restores tags and assigns them to the right entities.
Definition: snapshot.hpp:386
-
entt::SnapshotLoader::component
const SnapshotLoader & component(Archive &archive) const
Restores components and assigns them to the right entities.
Definition: snapshot.hpp:365
+
1 #ifndef ENTT_ENTITY_SNAPSHOT_HPP
2 #define ENTT_ENTITY_SNAPSHOT_HPP
3 
4 
5 #include <array>
6 #include <cstddef>
7 #include <utility>
8 #include <iterator>
9 #include <type_traits>
10 #include <unordered_map>
11 #include "../config/config.h"
12 #include "entity.hpp"
13 #include "fwd.hpp"
14 
15 
16 namespace entt {
17 
18 
29 template<typename Entity>
30 class basic_snapshot {
32  friend class basic_registry<Entity>;
33 
34  using follow_fn_type = Entity(const basic_registry<Entity> &, const Entity);
35 
36  basic_snapshot(const basic_registry<Entity> *source, Entity init, follow_fn_type *fn) ENTT_NOEXCEPT
37  : reg{source},
38  seed{init},
39  follow{fn}
40  {}
41 
42  template<typename Component, typename Archive, typename It>
43  void get(Archive &archive, std::size_t sz, It first, It last) const {
44  archive(static_cast<Entity>(sz));
45 
46  while(first != last) {
47  const auto entt = *(first++);
48 
49  if(reg->template has<Component>(entt)) {
50  if constexpr(std::is_empty_v<Component>) {
51  archive(entt);
52  } else {
53  archive(entt, reg->template get<Component>(entt));
54  }
55  }
56  }
57  }
58 
59  template<typename... Component, typename Archive, typename It, std::size_t... Indexes>
60  void component(Archive &archive, It first, It last, std::index_sequence<Indexes...>) const {
61  std::array<std::size_t, sizeof...(Indexes)> size{};
62  auto begin = first;
63 
64  while(begin != last) {
65  const auto entt = *(begin++);
66  ((reg->template has<Component>(entt) ? ++size[Indexes] : size[Indexes]), ...);
67  }
68 
69  (get<Component>(archive, size[Indexes], first, last), ...);
70  }
71 
72 public:
74  basic_snapshot(basic_snapshot &&) = default;
75 
77  basic_snapshot & operator=(basic_snapshot &&) = default;
78 
89  template<typename Archive>
90  const basic_snapshot & entities(Archive &archive) const {
91  archive(static_cast<Entity>(reg->alive()));
92  reg->each([&archive](const auto entt) { archive(entt); });
93  return *this;
94  }
95 
106  template<typename Archive>
107  const basic_snapshot & destroyed(Archive &archive) const {
108  auto size = reg->size() - reg->alive();
109  archive(static_cast<Entity>(size));
110 
111  if(size) {
112  auto curr = seed;
113  archive(curr);
114 
115  for(--size; size; --size) {
116  curr = follow(*reg, curr);
117  archive(curr);
118  }
119  }
120 
121  return *this;
122  }
123 
135  template<typename... Component, typename Archive>
136  const basic_snapshot & component(Archive &archive) const {
137  if constexpr(sizeof...(Component) == 1) {
138  const auto sz = reg->template size<Component...>();
139  const auto *entities = reg->template data<Component...>();
140 
141  archive(static_cast<Entity>(sz));
142 
143  for(std::remove_const_t<decltype(sz)> i{}; i < sz; ++i) {
144  const auto entt = entities[i];
145 
146  if constexpr(std::is_empty_v<Component...>) {
147  archive(entt);
148  } else {
149  archive(entt, reg->template get<Component...>(entt));
150  }
151  };
152  } else {
153  (component<Component>(archive), ...);
154  }
155 
156  return *this;
157  }
158 
173  template<typename... Component, typename Archive, typename It>
174  const basic_snapshot & component(Archive &archive, It first, It last) const {
175  component<Component...>(archive, first, last, std::make_index_sequence<sizeof...(Component)>{});
176  return *this;
177  }
178 
179 private:
180  const basic_registry<Entity> *reg;
181  const Entity seed;
182  follow_fn_type *follow;
183 };
184 
185 
196 template<typename Entity>
197 class basic_snapshot_loader {
199  friend class basic_registry<Entity>;
200 
201  using force_fn_type = void(basic_registry<Entity> &, const Entity, const bool);
202 
203  basic_snapshot_loader(basic_registry<Entity> *source, force_fn_type *fn) ENTT_NOEXCEPT
204  : reg{source},
205  force{fn}
206  {
207  // to restore a snapshot as a whole requires a clean registry
208  ENTT_ASSERT(reg->empty());
209  }
210 
211  template<typename Archive>
212  void assure(Archive &archive, bool destroyed) const {
213  Entity length{};
214  archive(length);
215 
216  while(length--) {
217  Entity entt{};
218  archive(entt);
219  force(*reg, entt, destroyed);
220  }
221  }
222 
223  template<typename Type, typename Archive, typename... Args>
224  void assign(Archive &archive, Args... args) const {
225  Entity length{};
226  archive(length);
227 
228  while(length--) {
229  static constexpr auto destroyed = false;
230  Entity entt{};
231 
232  if constexpr(std::is_empty_v<Type>) {
233  archive(entt);
234  force(*reg, entt, destroyed);
235  reg->template assign<Type>(args..., entt);
236  } else {
237  Type instance{};
238  archive(entt, instance);
239  force(*reg, entt, destroyed);
240  reg->template assign<Type>(args..., entt, std::as_const(instance));
241  }
242  }
243  }
244 
245 public:
247  basic_snapshot_loader(basic_snapshot_loader &&) = default;
248 
250  basic_snapshot_loader & operator=(basic_snapshot_loader &&) = default;
251 
262  template<typename Archive>
263  const basic_snapshot_loader & entities(Archive &archive) const {
264  static constexpr auto destroyed = false;
265  assure(archive, destroyed);
266  return *this;
267  }
268 
279  template<typename Archive>
280  const basic_snapshot_loader & destroyed(Archive &archive) const {
281  static constexpr auto destroyed = true;
282  assure(archive, destroyed);
283  return *this;
284  }
285 
299  template<typename... Component, typename Archive>
300  const basic_snapshot_loader & component(Archive &archive) const {
301  (assign<Component>(archive), ...);
302  return *this;
303  }
304 
315  const basic_snapshot_loader & orphans() const {
316  reg->orphans([this](const auto entt) {
317  reg->destroy(entt);
318  });
319 
320  return *this;
321  }
322 
323 private:
324  basic_registry<Entity> *reg;
325  force_fn_type *force;
326 };
327 
328 
345 template<typename Entity>
346 class basic_continuous_loader {
347  using traits_type = entt_traits<Entity>;
348 
349  void destroy(Entity entt) {
350  const auto it = remloc.find(entt);
351 
352  if(it == remloc.cend()) {
353  const auto local = reg->create();
354  remloc.emplace(entt, std::make_pair(local, true));
355  reg->destroy(local);
356  }
357  }
358 
359  void restore(Entity entt) {
360  const auto it = remloc.find(entt);
361 
362  if(it == remloc.cend()) {
363  const auto local = reg->create();
364  remloc.emplace(entt, std::make_pair(local, true));
365  } else {
366  remloc[entt].first = reg->valid(remloc[entt].first) ? remloc[entt].first : reg->create();
367  // set the dirty flag
368  remloc[entt].second = true;
369  }
370  }
371 
372  template<typename Other, typename Type, typename Member>
373  void update(Other &instance, Member Type:: *member) {
374  if constexpr(!std::is_same_v<Other, Type>) {
375  return;
376  } else if constexpr(std::is_same_v<Member, Entity>) {
377  instance.*member = map(instance.*member);
378  } else {
379  // maybe a container? let's try...
380  for(auto &entt: instance.*member) {
381  entt = map(entt);
382  }
383  }
384  }
385 
386  template<typename Archive>
387  void assure(Archive &archive, void(basic_continuous_loader:: *member)(Entity)) {
388  Entity length{};
389  archive(length);
390 
391  while(length--) {
392  Entity entt{};
393  archive(entt);
394  (this->*member)(entt);
395  }
396  }
397 
398  template<typename Component>
399  void reset() {
400  for(auto &&ref: remloc) {
401  const auto local = ref.second.first;
402 
403  if(reg->valid(local)) {
404  reg->template reset<Component>(local);
405  }
406  }
407  }
408 
409  template<typename Other, typename Archive, typename... Type, typename... Member>
410  void assign(Archive &archive, [[maybe_unused]] Member Type:: *... member) {
411  Entity length{};
412  archive(length);
413 
414  while(length--) {
415  Entity entt{};
416 
417  if constexpr(std::is_empty_v<Other>) {
418  archive(entt);
419  restore(entt);
420  reg->template assign_or_replace<Other>(map(entt));
421  } else {
422  Other instance{};
423  archive(entt, instance);
424  (update(instance, member), ...);
425  restore(entt);
426  reg->template assign_or_replace<Other>(map(entt), std::as_const(instance));
427  }
428  }
429  }
430 
431 public:
433  using entity_type = Entity;
434 
439  basic_continuous_loader(basic_registry<entity_type> &source) ENTT_NOEXCEPT
440  : reg{&source}
441  {}
442 
444  basic_continuous_loader(basic_continuous_loader &&) = default;
445 
447  basic_continuous_loader & operator=(basic_continuous_loader &&) = default;
448 
459  template<typename Archive>
460  basic_continuous_loader & entities(Archive &archive) {
461  assure(archive, &basic_continuous_loader::restore);
462  return *this;
463  }
464 
475  template<typename Archive>
476  basic_continuous_loader & destroyed(Archive &archive) {
477  assure(archive, &basic_continuous_loader::destroy);
478  return *this;
479  }
480 
500  template<typename... Component, typename Archive, typename... Type, typename... Member>
501  basic_continuous_loader & component(Archive &archive, Member Type:: *... member) {
502  (reset<Component>(), ...);
503  (assign<Component>(archive, member...), ...);
504  return *this;
505  }
506 
515  basic_continuous_loader & shrink() {
516  auto it = remloc.begin();
517 
518  while(it != remloc.cend()) {
519  const auto local = it->second.first;
520  bool &dirty = it->second.second;
521 
522  if(dirty) {
523  dirty = false;
524  ++it;
525  } else {
526  if(reg->valid(local)) {
527  reg->destroy(local);
528  }
529 
530  it = remloc.erase(it);
531  }
532  }
533 
534  return *this;
535  }
536 
547  basic_continuous_loader & orphans() {
548  reg->orphans([this](const auto entt) {
549  reg->destroy(entt);
550  });
551 
552  return *this;
553  }
554 
560  bool has(entity_type entt) const ENTT_NOEXCEPT {
561  return (remloc.find(entt) != remloc.cend());
562  }
563 
569  entity_type map(entity_type entt) const ENTT_NOEXCEPT {
570  const auto it = remloc.find(entt);
571  entity_type other = null;
572 
573  if(it != remloc.cend()) {
574  other = it->second.first;
575  }
576 
577  return other;
578  }
579 
580 private:
581  std::unordered_map<Entity, std::pair<Entity, bool>> remloc;
582  basic_registry<Entity> *reg;
583 };
584 
585 
586 }
587 
588 
589 #endif // ENTT_ENTITY_SNAPSHOT_HPP
entt::basic_snapshot_loader::orphans
const basic_snapshot_loader & orphans() const
Destroys those entities that have no components.
Definition: snapshot.hpp:315
+
entt::basic_snapshot_loader::component
const basic_snapshot_loader & component(Archive &archive) const
Restores components and assigns them to the right entities.
Definition: snapshot.hpp:300
+
entt::basic_continuous_loader::shrink
basic_continuous_loader & shrink()
Helps to purge entities that no longer have a conterpart.
Definition: snapshot.hpp:515
+
entt::basic_continuous_loader::basic_continuous_loader
basic_continuous_loader(basic_registry< entity_type > &source) ENTT_NOEXCEPT
Constructs a loader that is bound to a given registry.
Definition: snapshot.hpp:439
+
entt::basic_snapshot::destroyed
const basic_snapshot & destroyed(Archive &archive) const
Puts aside destroyed entities.
Definition: snapshot.hpp:107
entt
EnTT default namespace.
Definition: algorithm.hpp:10
-
entt::Snapshot
Utility class to create snapshots from a registry.
Definition: snapshot.hpp:38
-
entt::ContinuousLoader::component
ContinuousLoader & component(Archive &archive, Member Type::*... member)
Restores components and assigns them to the right entities.
Definition: snapshot.hpp:599
-
entt::ContinuousLoader::entity_type
Entity entity_type
Underlying entity identifier.
Definition: snapshot.hpp:527
-
entt::Snapshot::entities
const Snapshot & entities(Archive &archive) const
Puts aside all the entities that are still in use.
Definition: snapshot.hpp:102
-
entt::ContinuousLoader::has
bool has(entity_type entity) const ENTT_NOEXCEPT
Tests if a loader knows about a given entity.
Definition: snapshot.hpp:694
-
entt::Snapshot::destroyed
const Snapshot & destroyed(Archive &archive) const
Puts aside destroyed entities.
Definition: snapshot.hpp:119
-
entt::ContinuousLoader::destroyed
ContinuousLoader & destroyed(Archive &archive)
Restores entities that were destroyed during serialization.
Definition: snapshot.hpp:574
-
entt::Snapshot::component
std::enable_if_t<(sizeof...(Component) > 1), const Snapshot & > component(Archive &archive) const
Puts aside the given components.
Definition: snapshot.hpp:175
-
entt::SnapshotLoader::destroyed
const SnapshotLoader & destroyed(Archive &archive) const
Restores entities that were destroyed during serialization.
Definition: snapshot.hpp:345
-
entt::ContinuousLoader::ContinuousLoader
ContinuousLoader(Registry< entity_type > &registry) ENTT_NOEXCEPT
Constructs a loader that is bound to a given registry.
Definition: snapshot.hpp:533
-
entt::SnapshotLoader::orphans
const SnapshotLoader & orphans() const
Destroys those entities that have neither components nor tags.
Definition: snapshot.hpp:403
-
entt::Snapshot::tag
std::enable_if_t<(sizeof...(Tag) > 1), const Snapshot & > tag(Archive &archive) const
Puts aside the given tags.
Definition: snapshot.hpp:240
-
entt::Snapshot::component
const Snapshot & component(Archive &archive) const
Puts aside the given component.
Definition: snapshot.hpp:148
-
entt::ContinuousLoader
Utility class for continuous loading.
Definition: snapshot.hpp:434
-
entt::SnapshotLoader::entities
const SnapshotLoader & entities(Archive &archive) const
Restores entities that were in use during serialization.
Definition: snapshot.hpp:328
-
entt::Snapshot::component
const Snapshot & component(Archive &archive, It first, It last) const
Puts aside the given components for the entities in a range.
Definition: snapshot.hpp:197
-
entt::ContinuousLoader::shrink
ContinuousLoader & shrink()
Helps to purge entities that no longer have a conterpart.
Definition: snapshot.hpp:649
-
entt::tag_t
Tag class type used to disambiguate overloads.
Definition: utility.hpp:9
-
entt::Snapshot::tag
const Snapshot & tag(Archive &archive) const
Puts aside the given tag.
Definition: snapshot.hpp:214
-
entt::Snapshot::operator=
Snapshot & operator=(const Snapshot &)=delete
Copying a snapshot isn&#39;t allowed.
-
entt::entt_traits
Entity traits.
Definition: entt_traits.hpp:18
-
entt::ContinuousLoader::entities
ContinuousLoader & entities(Archive &archive)
Restores entities that were in use during serialization.
Definition: snapshot.hpp:558
-
entt::ContinuousLoader::orphans
ContinuousLoader & orphans()
Destroys those entities that have neither components nor tags.
Definition: snapshot.hpp:681
+
entt::basic_continuous_loader::entity_type
Entity entity_type
Underlying entity identifier.
Definition: snapshot.hpp:433
+
entt::basic_snapshot_loader::destroyed
const basic_snapshot_loader & destroyed(Archive &archive) const
Restores entities that were destroyed during serialization.
Definition: snapshot.hpp:280
+
entt::basic_continuous_loader::component
basic_continuous_loader & component(Archive &archive, Member Type::*... member)
Restores components and assigns them to the right entities.
Definition: snapshot.hpp:501
+
entt::basic_snapshot::component
const basic_snapshot & component(Archive &archive, It first, It last) const
Puts aside the given components for the entities in a range.
Definition: snapshot.hpp:174
+
entt::basic_continuous_loader
Utility class for continuous loading.
Definition: fwd.hpp:45
+
entt::null
constexpr auto null
Null entity.
Definition: entity.hpp:163
+
entt::basic_snapshot_loader
Utility class to restore a snapshot as a whole.
Definition: fwd.hpp:41
+
entt::basic_snapshot::operator=
basic_snapshot & operator=(basic_snapshot &&)=default
Default move assignment operator.
+
entt::basic_registry
Fast and reliable entity-component system.
Definition: fwd.hpp:13
+
entt::basic_continuous_loader::orphans
basic_continuous_loader & orphans()
Destroys those entities that have no components.
Definition: snapshot.hpp:547
+
entt::basic_snapshot_loader::entities
const basic_snapshot_loader & entities(Archive &archive) const
Restores entities that were in use during serialization.
Definition: snapshot.hpp:263
+
entt::basic_snapshot::component
const basic_snapshot & component(Archive &archive) const
Puts aside the given components.
Definition: snapshot.hpp:136
+
entt::basic_continuous_loader::destroyed
basic_continuous_loader & destroyed(Archive &archive)
Restores entities that were destroyed during serialization.
Definition: snapshot.hpp:476
+
entt::basic_continuous_loader::map
entity_type map(entity_type entt) const ENTT_NOEXCEPT
Returns the identifier to which an entity refers.
Definition: snapshot.hpp:569
+
entt::basic_continuous_loader::entities
basic_continuous_loader & entities(Archive &archive)
Restores entities that were in use during serialization.
Definition: snapshot.hpp:460
+
entt::basic_snapshot
Utility class to create snapshots from a registry.
Definition: fwd.hpp:37
+
entt::basic_snapshot::entities
const basic_snapshot & entities(Archive &archive) const
Puts aside all the entities that are still in use.
Definition: snapshot.hpp:90
+
entt::basic_continuous_loader::has
bool has(entity_type entt) const ENTT_NOEXCEPT
Tests if a loader knows about a given entity.
Definition: snapshot.hpp:560
+
entt::entt_traits
Entity traits.
Definition: entity.hpp:18
diff --git a/sparse__set_8hpp_source.html b/sparse__set_8hpp_source.html index 2c3ee3ecc..5a0e5e35f 100644 --- a/sparse__set_8hpp_source.html +++ b/sparse__set_8hpp_source.html @@ -22,7 +22,7 @@
@@ -67,53 +67,36 @@ $(function() {
sparse_set.hpp
-
1 #ifndef ENTT_ENTITY_SPARSE_SET_HPP
2 #define ENTT_ENTITY_SPARSE_SET_HPP
3 
4 
5 #include <algorithm>
6 #include <iterator>
7 #include <numeric>
8 #include <utility>
9 #include <vector>
10 #include <cstddef>
11 #include <cassert>
12 #include <type_traits>
13 #include "../config/config.h"
14 #include "../core/algorithm.hpp"
15 #include "entt_traits.hpp"
16 #include "entity.hpp"
17 
18 
19 namespace entt {
20 
21 
28 template<typename...>
29 class SparseSet;
30 
31 
59 template<typename Entity>
60 class SparseSet<Entity> {
61  using traits_type = entt_traits<Entity>;
62 
63  class Iterator final {
64  friend class SparseSet<Entity>;
65 
66  using direct_type = const std::vector<Entity>;
67  using index_type = typename traits_type::difference_type;
68 
69  Iterator(direct_type *direct, index_type index) ENTT_NOEXCEPT
70  : direct{direct}, index{index}
71  {}
72 
73  public:
74  using difference_type = index_type;
75  using value_type = const Entity;
76  using pointer = value_type *;
77  using reference = value_type &;
78  using iterator_category = std::random_access_iterator_tag;
79 
80  Iterator() ENTT_NOEXCEPT = default;
81 
82  Iterator(const Iterator &) ENTT_NOEXCEPT = default;
83  Iterator & operator=(const Iterator &) ENTT_NOEXCEPT = default;
84 
85  Iterator & operator++() ENTT_NOEXCEPT {
86  return --index, *this;
87  }
88 
89  Iterator operator++(int) ENTT_NOEXCEPT {
90  Iterator orig = *this;
91  return ++(*this), orig;
92  }
93 
94  Iterator & operator--() ENTT_NOEXCEPT {
95  return ++index, *this;
96  }
97 
98  Iterator operator--(int) ENTT_NOEXCEPT {
99  Iterator orig = *this;
100  return --(*this), orig;
101  }
102 
103  Iterator & operator+=(const difference_type value) ENTT_NOEXCEPT {
104  index -= value;
105  return *this;
106  }
107 
108  Iterator operator+(const difference_type value) const ENTT_NOEXCEPT {
109  return Iterator{direct, index-value};
110  }
111 
112  inline Iterator & operator-=(const difference_type value) ENTT_NOEXCEPT {
113  return (*this += -value);
114  }
115 
116  inline Iterator operator-(const difference_type value) const ENTT_NOEXCEPT {
117  return (*this + -value);
118  }
119 
120  difference_type operator-(const Iterator &other) const ENTT_NOEXCEPT {
121  return other.index - index;
122  }
123 
124  reference operator[](const difference_type value) const ENTT_NOEXCEPT {
125  const auto pos = size_type(index-value-1);
126  return (*direct)[pos];
127  }
128 
129  bool operator==(const Iterator &other) const ENTT_NOEXCEPT {
130  return other.index == index;
131  }
132 
133  inline bool operator!=(const Iterator &other) const ENTT_NOEXCEPT {
134  return !(*this == other);
135  }
136 
137  bool operator<(const Iterator &other) const ENTT_NOEXCEPT {
138  return index > other.index;
139  }
140 
141  bool operator>(const Iterator &other) const ENTT_NOEXCEPT {
142  return index < other.index;
143  }
144 
145  inline bool operator<=(const Iterator &other) const ENTT_NOEXCEPT {
146  return !(*this > other);
147  }
148 
149  inline bool operator>=(const Iterator &other) const ENTT_NOEXCEPT {
150  return !(*this < other);
151  }
152 
153  pointer operator->() const ENTT_NOEXCEPT {
154  const auto pos = size_type(index-1);
155  return &(*direct)[pos];
156  }
157 
158  inline reference operator*() const ENTT_NOEXCEPT {
159  return *operator->();
160  }
161 
162  private:
163  direct_type *direct;
164  index_type index;
165  };
166 
167 public:
169  using entity_type = Entity;
171  using size_type = std::size_t;
173  using iterator_type = Iterator;
175  using const_iterator_type = Iterator;
176 
178  SparseSet() ENTT_NOEXCEPT = default;
179 
181  virtual ~SparseSet() ENTT_NOEXCEPT = default;
182 
184  SparseSet(const SparseSet &) = delete;
186  SparseSet(SparseSet &&) = default;
187 
189  SparseSet & operator=(const SparseSet &) = delete;
191  SparseSet & operator=(SparseSet &&) = default;
192 
201  void reserve(const size_type cap) {
202  direct.reserve(cap);
203  }
204 
210  size_type capacity() const ENTT_NOEXCEPT {
211  return direct.capacity();
212  }
213 
224  size_type extent() const ENTT_NOEXCEPT {
225  return reverse.size();
226  }
227 
238  size_type size() const ENTT_NOEXCEPT {
239  return direct.size();
240  }
241 
246  bool empty() const ENTT_NOEXCEPT {
247  return direct.empty();
248  }
249 
265  const entity_type * data() const ENTT_NOEXCEPT {
266  return direct.data();
267  }
268 
281  const_iterator_type cbegin() const ENTT_NOEXCEPT {
282  const typename traits_type::difference_type pos = direct.size();
283  return const_iterator_type{&direct, pos};
284  }
285 
298  inline const_iterator_type begin() const ENTT_NOEXCEPT {
299  return cbegin();
300  }
301 
314  inline iterator_type begin() ENTT_NOEXCEPT {
315  return cbegin();
316  }
317 
331  const_iterator_type cend() const ENTT_NOEXCEPT {
332  return const_iterator_type{&direct, {}};
333  }
334 
348  inline const_iterator_type end() const ENTT_NOEXCEPT {
349  return cend();
350  }
351 
365  inline iterator_type end() ENTT_NOEXCEPT {
366  return cend();
367  }
368 
374  inline const entity_type & operator[](const size_type pos) const ENTT_NOEXCEPT {
375  return cbegin()[pos];
376  }
377 
383  bool has(const entity_type entity) const ENTT_NOEXCEPT {
384  const auto pos = size_type(entity & traits_type::entity_mask);
385  // testing against null permits to avoid accessing the direct vector
386  return (pos < reverse.size()) && (reverse[pos] != null);
387  }
388 
406  bool fast(const entity_type entity) const ENTT_NOEXCEPT {
407  const auto pos = size_type(entity & traits_type::entity_mask);
408  assert(pos < reverse.size());
409  // testing against null permits to avoid accessing the direct vector
410  return (reverse[pos] != null);
411  }
412 
425  size_type get(const entity_type entity) const ENTT_NOEXCEPT {
426  assert(has(entity));
427  const auto pos = size_type(entity & traits_type::entity_mask);
428  return size_type(reverse[pos]);
429  }
430 
442  void construct(const entity_type entity) {
443  assert(!has(entity));
444  const auto pos = size_type(entity & traits_type::entity_mask);
445 
446  if(!(pos < reverse.size())) {
447  // null is safe in all cases for our purposes
448  reverse.resize(pos+1, null);
449  }
450 
451  reverse[pos] = entity_type(direct.size());
452  direct.push_back(entity);
453  }
454 
466  virtual void destroy(const entity_type entity) {
467  assert(has(entity));
468  const auto back = direct.back();
469  auto &candidate = reverse[size_type(entity & traits_type::entity_mask)];
470  // swapping isn't required here, we are getting rid of the last element
471  reverse[back & traits_type::entity_mask] = candidate;
472  direct[size_type(candidate)] = back;
473  candidate = null;
474  direct.pop_back();
475  }
476 
492  void swap(const size_type lhs, const size_type rhs) ENTT_NOEXCEPT {
493  assert(lhs < direct.size());
494  assert(rhs < direct.size());
495  auto &src = direct[lhs];
496  auto &dst = direct[rhs];
497  std::swap(reverse[src & traits_type::entity_mask], reverse[dst & traits_type::entity_mask]);
498  std::swap(src, dst);
499  }
500 
520  void respect(const SparseSet<Entity> &other) ENTT_NOEXCEPT {
521  auto from = other.cbegin();
522  auto to = other.cend();
523 
524  size_type pos = direct.size() - 1;
525 
526  while(pos && from != to) {
527  if(has(*from)) {
528  if(*from != direct[pos]) {
529  swap(pos, get(*from));
530  }
531 
532  --pos;
533  }
534 
535  ++from;
536  }
537  }
538 
542  virtual void reset() {
543  reverse.clear();
544  direct.clear();
545  }
546 
547 private:
548  std::vector<entity_type> reverse;
549  std::vector<entity_type> direct;
550 };
551 
552 
575 template<typename Entity, typename Type>
576 class SparseSet<Entity, Type>: public SparseSet<Entity> {
577  using underlying_type = SparseSet<Entity>;
578  using traits_type = entt_traits<Entity>;
579 
580  template<bool Const>
581  class Iterator final {
582  friend class SparseSet<Entity, Type>;
583 
584  using instance_type = std::conditional_t<Const, const std::vector<Type>, std::vector<Type>>;
585  using index_type = typename traits_type::difference_type;
586 
587  Iterator(instance_type *instances, index_type index) ENTT_NOEXCEPT
588  : instances{instances}, index{index}
589  {}
590 
591  public:
592  using difference_type = index_type;
593  using value_type = std::conditional_t<Const, const Type, Type>;
594  using pointer = value_type *;
595  using reference = value_type &;
596  using iterator_category = std::random_access_iterator_tag;
597 
598  Iterator() ENTT_NOEXCEPT = default;
599 
600  Iterator(const Iterator &) ENTT_NOEXCEPT = default;
601  Iterator & operator=(const Iterator &) ENTT_NOEXCEPT = default;
602 
603  Iterator & operator++() ENTT_NOEXCEPT {
604  return --index, *this;
605  }
606 
607  Iterator operator++(int) ENTT_NOEXCEPT {
608  Iterator orig = *this;
609  return ++(*this), orig;
610  }
611 
612  Iterator & operator--() ENTT_NOEXCEPT {
613  return ++index, *this;
614  }
615 
616  Iterator operator--(int) ENTT_NOEXCEPT {
617  Iterator orig = *this;
618  return --(*this), orig;
619  }
620 
621  Iterator & operator+=(const difference_type value) ENTT_NOEXCEPT {
622  index -= value;
623  return *this;
624  }
625 
626  Iterator operator+(const difference_type value) const ENTT_NOEXCEPT {
627  return Iterator{instances, index-value};
628  }
629 
630  inline Iterator & operator-=(const difference_type value) ENTT_NOEXCEPT {
631  return (*this += -value);
632  }
633 
634  inline Iterator operator-(const difference_type value) const ENTT_NOEXCEPT {
635  return (*this + -value);
636  }
637 
638  difference_type operator-(const Iterator &other) const ENTT_NOEXCEPT {
639  return other.index - index;
640  }
641 
642  reference operator[](const difference_type value) const ENTT_NOEXCEPT {
643  const auto pos = size_type(index-value-1);
644  return (*instances)[pos];
645  }
646 
647  bool operator==(const Iterator &other) const ENTT_NOEXCEPT {
648  return other.index == index;
649  }
650 
651  inline bool operator!=(const Iterator &other) const ENTT_NOEXCEPT {
652  return !(*this == other);
653  }
654 
655  bool operator<(const Iterator &other) const ENTT_NOEXCEPT {
656  return index > other.index;
657  }
658 
659  bool operator>(const Iterator &other) const ENTT_NOEXCEPT {
660  return index < other.index;
661  }
662 
663  inline bool operator<=(const Iterator &other) const ENTT_NOEXCEPT {
664  return !(*this > other);
665  }
666 
667  inline bool operator>=(const Iterator &other) const ENTT_NOEXCEPT {
668  return !(*this < other);
669  }
670 
671  pointer operator->() const ENTT_NOEXCEPT {
672  const auto pos = size_type(index-1);
673  return &(*instances)[pos];
674  }
675 
676  inline reference operator*() const ENTT_NOEXCEPT {
677  return *operator->();
678  }
679 
680  private:
681  instance_type *instances;
682  index_type index;
683  };
684 
685 public:
687  using object_type = Type;
689  using entity_type = typename underlying_type::entity_type;
691  using size_type = typename underlying_type::size_type;
693  using iterator_type = Iterator<false>;
695  using const_iterator_type = Iterator<true>;
696 
698  SparseSet() ENTT_NOEXCEPT = default;
699 
701  SparseSet(const SparseSet &) = delete;
703  SparseSet(SparseSet &&) = default;
704 
706  SparseSet & operator=(const SparseSet &) = delete;
708  SparseSet & operator=(SparseSet &&) = default;
709 
718  void reserve(const size_type cap) {
719  underlying_type::reserve(cap);
720  instances.reserve(cap);
721  }
722 
738  const object_type * raw() const ENTT_NOEXCEPT {
739  return instances.data();
740  }
741 
757  object_type * raw() ENTT_NOEXCEPT {
758  return instances.data();
759  }
760 
773  const_iterator_type cbegin() const ENTT_NOEXCEPT {
774  const typename traits_type::difference_type pos = instances.size();
775  return const_iterator_type{&instances, pos};
776  }
777 
790  inline const_iterator_type begin() const ENTT_NOEXCEPT {
791  return cbegin();
792  }
793 
806  iterator_type begin() ENTT_NOEXCEPT {
807  const typename traits_type::difference_type pos = instances.size();
808  return iterator_type{&instances, pos};
809  }
810 
825  const_iterator_type cend() const ENTT_NOEXCEPT {
826  return const_iterator_type{&instances, {}};
827  }
828 
843  inline const_iterator_type end() const ENTT_NOEXCEPT {
844  return cend();
845  }
846 
861  iterator_type end() ENTT_NOEXCEPT {
862  return iterator_type{&instances, {}};
863  }
864 
870  inline const object_type & operator[](const size_type pos) const ENTT_NOEXCEPT {
871  return cbegin()[pos];
872  }
873 
879  inline object_type & operator[](const size_type pos) ENTT_NOEXCEPT {
880  return const_cast<object_type &>(const_cast<const SparseSet *>(this)->operator[](pos));
881  }
882 
895  const object_type & get(const entity_type entity) const ENTT_NOEXCEPT {
896  return instances[underlying_type::get(entity)];
897  }
898 
911  inline object_type & get(const entity_type entity) ENTT_NOEXCEPT {
912  return const_cast<object_type &>(const_cast<const SparseSet *>(this)->get(entity));
913  }
914 
935  template<typename... Args>
936  std::enable_if_t<std::is_constructible<Type, Args...>::value, object_type &>
937  construct(const entity_type entity, Args &&... args) {
938  underlying_type::construct(entity);
939  instances.emplace_back(std::forward<Args>(args)...);
940  return instances.back();
941  }
942 
963  template<typename... Args>
964  std::enable_if_t<!std::is_constructible<Type, Args...>::value, object_type &>
965  construct(const entity_type entity, Args &&... args) {
966  underlying_type::construct(entity);
967  instances.emplace_back(Type{std::forward<Args>(args)...});
968  return instances.back();
969  }
970 
982  void destroy(const entity_type entity) override {
983  // swapping isn't required here, we are getting rid of the last element
984  // however, we must protect ourselves from self assignments (see #37)
985  auto tmp = std::move(instances.back());
986  instances[underlying_type::get(entity)] = std::move(tmp);
987  instances.pop_back();
988  underlying_type::destroy(entity);
989  }
990 
1032  template<typename Compare, typename Sort = StdSort, typename... Args>
1033  void sort(Compare compare, Sort sort = Sort{}, Args &&... args) {
1034  std::vector<size_type> copy(instances.size());
1035  std::iota(copy.begin(), copy.end(), 0);
1036 
1037  sort(copy.begin(), copy.end(), [this, compare = std::move(compare)](const auto lhs, const auto rhs) {
1038  return compare(const_cast<const object_type &>(instances[rhs]), const_cast<const object_type &>(instances[lhs]));
1039  }, std::forward<Args>(args)...);
1040 
1041  for(size_type pos = 0, last = copy.size(); pos < last; ++pos) {
1042  auto curr = pos;
1043  auto next = copy[curr];
1044 
1045  while(curr != next) {
1046  const auto lhs = copy[curr];
1047  const auto rhs = copy[next];
1048  std::swap(instances[lhs], instances[rhs]);
1049  underlying_type::swap(lhs, rhs);
1050  copy[curr] = curr;
1051  curr = next;
1052  next = copy[curr];
1053  }
1054  }
1055  }
1056 
1080  void respect(const SparseSet<Entity> &other) ENTT_NOEXCEPT {
1081  auto from = other.cbegin();
1082  auto to = other.cend();
1083 
1084  size_type pos = underlying_type::size() - 1;
1085  const auto *local = underlying_type::data();
1086 
1087  while(pos && from != to) {
1088  const auto curr = *from;
1089 
1090  if(underlying_type::has(curr)) {
1091  if(curr != *(local + pos)) {
1092  auto candidate = underlying_type::get(curr);
1093  std::swap(instances[pos], instances[candidate]);
1094  underlying_type::swap(pos, candidate);
1095  }
1096 
1097  --pos;
1098  }
1099 
1100  ++from;
1101  }
1102  }
1103 
1107  void reset() override {
1108  underlying_type::reset();
1109  instances.clear();
1110  }
1111 
1112 private:
1113  std::vector<object_type> instances;
1114 };
1115 
1116 
1117 }
1118 
1119 
1120 #endif // ENTT_ENTITY_SPARSE_SET_HPP
entt::SparseSet< Entity >::swap
void swap(const size_type lhs, const size_type rhs) ENTT_NOEXCEPT
Swaps the position of two entities in the internal packed array.
Definition: sparse_set.hpp:492
-
entt::operator!=
constexpr bool operator!=(const HashedString &lhs, const HashedString &rhs) ENTT_NOEXCEPT
Compares two hashed strings.
Definition: hashed_string.hpp:103
-
entt::SparseSet< Entity, Type >::cbegin
const_iterator_type cbegin() const ENTT_NOEXCEPT
Returns an iterator to the beginning.
Definition: sparse_set.hpp:773
-
entt::SparseSet< Entity >::capacity
size_type capacity() const ENTT_NOEXCEPT
Returns the number of elements that a sparse set has currently allocated space for.
Definition: sparse_set.hpp:210
-
entt::SparseSet< Entity, Type >::operator[]
object_type & operator[](const size_type pos) ENTT_NOEXCEPT
Returns a reference to the element at the given position.
Definition: sparse_set.hpp:879
-
entt::SparseSet< Entity >::empty
bool empty() const ENTT_NOEXCEPT
Checks whether a sparse set is empty.
Definition: sparse_set.hpp:246
-
entt::SparseSet< Entity, Type >::construct
std::enable_if_t<!std::is_constructible< Type, Args... >::value, object_type & > construct(const entity_type entity, Args &&... args)
Assigns an entity to a sparse set and constructs its object.
Definition: sparse_set.hpp:965
-
entt::SparseSet< Entity >::fast
bool fast(const entity_type entity) const ENTT_NOEXCEPT
Checks if a sparse set contains an entity (unsafe).
Definition: sparse_set.hpp:406
-
entt::SparseSet< Entity >::reset
virtual void reset()
Resets a sparse set.
Definition: sparse_set.hpp:542
+
1 #ifndef ENTT_ENTITY_SPARSE_SET_HPP
2 #define ENTT_ENTITY_SPARSE_SET_HPP
3 
4 
5 #include <algorithm>
6 #include <iterator>
7 #include <utility>
8 #include <vector>
9 #include <memory>
10 #include <cstddef>
11 #include "../config/config.h"
12 #include "entity.hpp"
13 
14 
15 namespace entt {
16 
17 
45 template<typename Entity>
46 class sparse_set {
47  using traits_type = entt_traits<Entity>;
48 
49  static_assert(ENTT_PAGE_SIZE && ((ENTT_PAGE_SIZE & (ENTT_PAGE_SIZE - 1)) == 0));
50  static constexpr auto entt_per_page = ENTT_PAGE_SIZE / sizeof(typename entt_traits<Entity>::entity_type);
51 
52  class iterator {
53  friend class sparse_set<Entity>;
54 
55  using direct_type = const std::vector<Entity>;
56  using index_type = typename traits_type::difference_type;
57 
58  iterator(direct_type *ref, const index_type idx) ENTT_NOEXCEPT
59  : direct{ref}, index{idx}
60  {}
61 
62  public:
63  using difference_type = index_type;
64  using value_type = Entity;
65  using pointer = const value_type *;
66  using reference = const value_type &;
67  using iterator_category = std::random_access_iterator_tag;
68 
69  iterator() ENTT_NOEXCEPT = default;
70 
71  iterator & operator++() ENTT_NOEXCEPT {
72  return --index, *this;
73  }
74 
75  iterator operator++(int) ENTT_NOEXCEPT {
76  iterator orig = *this;
77  return ++(*this), orig;
78  }
79 
80  iterator & operator--() ENTT_NOEXCEPT {
81  return ++index, *this;
82  }
83 
84  iterator operator--(int) ENTT_NOEXCEPT {
85  iterator orig = *this;
86  return --(*this), orig;
87  }
88 
89  iterator & operator+=(const difference_type value) ENTT_NOEXCEPT {
90  index -= value;
91  return *this;
92  }
93 
94  iterator operator+(const difference_type value) const ENTT_NOEXCEPT {
95  return iterator{direct, index-value};
96  }
97 
98  inline iterator & operator-=(const difference_type value) ENTT_NOEXCEPT {
99  return (*this += -value);
100  }
101 
102  inline iterator operator-(const difference_type value) const ENTT_NOEXCEPT {
103  return (*this + -value);
104  }
105 
106  difference_type operator-(const iterator &other) const ENTT_NOEXCEPT {
107  return other.index - index;
108  }
109 
110  reference operator[](const difference_type value) const ENTT_NOEXCEPT {
111  const auto pos = size_type(index-value-1);
112  return (*direct)[pos];
113  }
114 
115  bool operator==(const iterator &other) const ENTT_NOEXCEPT {
116  return other.index == index;
117  }
118 
119  inline bool operator!=(const iterator &other) const ENTT_NOEXCEPT {
120  return !(*this == other);
121  }
122 
123  bool operator<(const iterator &other) const ENTT_NOEXCEPT {
124  return index > other.index;
125  }
126 
127  bool operator>(const iterator &other) const ENTT_NOEXCEPT {
128  return index < other.index;
129  }
130 
131  inline bool operator<=(const iterator &other) const ENTT_NOEXCEPT {
132  return !(*this > other);
133  }
134 
135  inline bool operator>=(const iterator &other) const ENTT_NOEXCEPT {
136  return !(*this < other);
137  }
138 
139  pointer operator->() const ENTT_NOEXCEPT {
140  const auto pos = size_type(index-1);
141  return &(*direct)[pos];
142  }
143 
144  inline reference operator*() const ENTT_NOEXCEPT {
145  return *operator->();
146  }
147 
148  private:
149  direct_type *direct;
150  index_type index;
151  };
152 
153  void assure(const std::size_t page) {
154  if(!(page < reverse.size())) {
155  reverse.resize(page+1);
156  }
157 
158  if(!reverse[page].first) {
159  reverse[page].first = std::make_unique<entity_type[]>(entt_per_page);
160  // null is safe in all cases for our purposes
161  std::fill_n(reverse[page].first.get(), entt_per_page, null);
162  }
163  }
164 
165  auto index(const Entity entt) const ENTT_NOEXCEPT {
166  const auto identifier = entt & traits_type::entity_mask;
167  const auto page = size_type(identifier / entt_per_page);
168  const auto offset = size_type(identifier & (entt_per_page - 1));
169  return std::make_pair(page, offset);
170  }
171 
172 public:
174  using entity_type = Entity;
176  using size_type = std::size_t;
178  using iterator_type = iterator;
179 
181  sparse_set() = default;
182 
187  sparse_set(const sparse_set &other)
188  : reverse{},
189  direct{other.direct}
190  {
191  for(size_type i = {}, last = other.reverse.size(); i < last; ++i) {
192  if(other.reverse[i].first) {
193  assure(i);
194  std::copy_n(other.reverse[i].first.get(), entt_per_page, reverse[i].first.get());
195  reverse[i].second = other.reverse[i].second;
196  }
197  }
198  }
199 
201  sparse_set(sparse_set &&) = default;
202 
204  virtual ~sparse_set() ENTT_NOEXCEPT = default;
205 
211  sparse_set & operator=(const sparse_set &other) {
212  if(&other != this) {
213  auto tmp{other};
214  *this = std::move(tmp);
215  }
216 
217  return *this;
218  }
219 
221  sparse_set & operator=(sparse_set &&) = default;
222 
231  virtual void reserve(const size_type cap) {
232  direct.reserve(cap);
233  }
234 
240  size_type capacity() const ENTT_NOEXCEPT {
241  return direct.capacity();
242  }
243 
245  virtual void shrink_to_fit() {
246  while(!reverse.empty() && !reverse.back().second) {
247  reverse.pop_back();
248  }
249 
250  for(auto &&data: reverse) {
251  if(!data.second) {
252  data.first.reset();
253  }
254  }
255 
256  reverse.shrink_to_fit();
257  direct.shrink_to_fit();
258  }
259 
270  size_type extent() const ENTT_NOEXCEPT {
271  return reverse.size() * entt_per_page;
272  }
273 
284  size_type size() const ENTT_NOEXCEPT {
285  return direct.size();
286  }
287 
292  bool empty() const ENTT_NOEXCEPT {
293  return direct.empty();
294  }
295 
311  const entity_type * data() const ENTT_NOEXCEPT {
312  return direct.data();
313  }
314 
327  iterator_type begin() const ENTT_NOEXCEPT {
328  const typename traits_type::difference_type pos = direct.size();
329  return iterator_type{&direct, pos};
330  }
331 
345  iterator_type end() const ENTT_NOEXCEPT {
346  return iterator_type{&direct, {}};
347  }
348 
355  iterator_type find(const entity_type entt) const ENTT_NOEXCEPT {
356  return has(entt) ? --(end() - get(entt)) : end();
357  }
358 
364  bool has(const entity_type entt) const ENTT_NOEXCEPT {
365  auto [page, offset] = index(entt);
366  // testing against null permits to avoid accessing the direct vector
367  return (page < reverse.size() && reverse[page].second && reverse[page].first[offset] != null);
368  }
369 
382  size_type get(const entity_type entt) const ENTT_NOEXCEPT {
383  ENTT_ASSERT(has(entt));
384  auto [page, offset] = index(entt);
385  return size_type(reverse[page].first[offset]);
386  }
387 
399  void construct(const entity_type entt) {
400  ENTT_ASSERT(!has(entt));
401  auto [page, offset] = index(entt);
402  assure(page);
403  reverse[page].first[offset] = entity_type(direct.size());
404  reverse[page].second++;
405  direct.push_back(entt);
406  }
407 
421  template<typename It>
422  void batch(It first, It last) {
423  std::for_each(first, last, [next = entity_type(direct.size()), this](const auto entt) mutable {
424  ENTT_ASSERT(!has(entt));
425  auto [page, offset] = index(entt);
426  assure(page);
427  reverse[page].first[offset] = next++;
428  reverse[page].second++;
429  });
430 
431  direct.insert(direct.end(), first, last);
432  }
433 
445  virtual void destroy(const entity_type entt) {
446  ENTT_ASSERT(has(entt));
447  auto [from_page, from_offset] = index(entt);
448  auto [to_page, to_offset] = index(direct.back());
449  direct[size_type(reverse[from_page].first[from_offset])] = direct.back();
450  reverse[to_page].first[to_offset] = reverse[from_page].first[from_offset];
451  reverse[from_page].first[from_offset] = null;
452  reverse[from_page].second--;
453  direct.pop_back();
454  }
455 
471  void swap(const size_type lhs, const size_type rhs) ENTT_NOEXCEPT {
472  ENTT_ASSERT(lhs < direct.size());
473  ENTT_ASSERT(rhs < direct.size());
474  auto [src_page, src_offset] = index(direct[lhs]);
475  auto [dst_page, dst_offset] = index(direct[rhs]);
476  std::swap(reverse[src_page].first[src_offset], reverse[dst_page].first[dst_offset]);
477  std::swap(direct[lhs], direct[rhs]);
478  }
479 
499  virtual void respect(const sparse_set &other) ENTT_NOEXCEPT {
500  const auto to = other.end();
501  auto from = other.begin();
502 
503  size_type pos = direct.size() - 1;
504 
505  while(pos && from != to) {
506  if(has(*from)) {
507  if(*from != direct[pos]) {
508  swap(pos, get(*from));
509  }
510 
511  --pos;
512  }
513 
514  ++from;
515  }
516  }
517 
521  virtual void reset() {
522  reverse.clear();
523  direct.clear();
524  }
525 
526 private:
527  std::vector<std::pair<std::unique_ptr<entity_type[]>, size_type>> reverse;
528  std::vector<entity_type> direct;
529 };
530 
531 
532 }
533 
534 
535 #endif // ENTT_ENTITY_SPARSE_SET_HPP
entt::sparse_set::swap
void swap(const size_type lhs, const size_type rhs) ENTT_NOEXCEPT
Swaps the position of two entities in the internal packed array.
Definition: sparse_set.hpp:471
+
entt::sparse_set
Basic sparse set implementation.
Definition: sparse_set.hpp:46
+
entt::sparse_set::operator=
sparse_set & operator=(const sparse_set &other)
Copy assignment operator.
Definition: sparse_set.hpp:211
+
entt::sparse_set::sparse_set
sparse_set(const sparse_set &other)
Copy constructor.
Definition: sparse_set.hpp:187
+
entt::sparse_set::size
size_type size() const ENTT_NOEXCEPT
Returns the number of elements in a sparse set.
Definition: sparse_set.hpp:284
+
entt::sparse_set::batch
void batch(It first, It last)
Assigns one or more entities to a sparse set.
Definition: sparse_set.hpp:422
+
entt::sparse_set::data
const entity_type * data() const ENTT_NOEXCEPT
Direct access to the internal packed array.
Definition: sparse_set.hpp:311
entt
EnTT default namespace.
Definition: algorithm.hpp:10
-
entt::SparseSet< Entity, Type >::raw
const object_type * raw() const ENTT_NOEXCEPT
Direct access to the array of objects.
Definition: sparse_set.hpp:738
-
entt::SparseSet< Entity, Type >::reset
void reset() override
Resets a sparse set.
Definition: sparse_set.hpp:1107
-
entt::SparseSet< Entity, Type >::cend
const_iterator_type cend() const ENTT_NOEXCEPT
Returns an iterator to the end.
Definition: sparse_set.hpp:825
-
entt::SparseSet< Entity >::has
bool has(const entity_type entity) const ENTT_NOEXCEPT
Checks if a sparse set contains an entity.
Definition: sparse_set.hpp:383
-
entt::SparseSet< Entity >::begin
const_iterator_type begin() const ENTT_NOEXCEPT
Returns an iterator to the beginning.
Definition: sparse_set.hpp:298
-
entt::SparseSet< Entity, Type >::destroy
void destroy(const entity_type entity) override
Removes an entity from a sparse set and destroies its object.
Definition: sparse_set.hpp:982
-
entt::SparseSet< Entity, Type >::begin
const_iterator_type begin() const ENTT_NOEXCEPT
Returns an iterator to the beginning.
Definition: sparse_set.hpp:790
-
entt::SparseSet
Sparse set.
Definition: sparse_set.hpp:29
-
entt::SparseSet< Entity, Type >::construct
std::enable_if_t< std::is_constructible< Type, Args... >::value, object_type & > construct(const entity_type entity, Args &&... args)
Assigns an entity to a sparse set and constructs its object.
Definition: sparse_set.hpp:937
-
entt::null
constexpr auto null
Null entity.
Definition: entity.hpp:78
-
entt::SparseSet< Entity >::size_type
std::size_t size_type
Unsigned integer type.
Definition: sparse_set.hpp:171
-
entt::SparseSet< Entity >::extent
size_type extent() const ENTT_NOEXCEPT
Returns the extent of a sparse set.
Definition: sparse_set.hpp:224
-
entt::SparseSet< Entity, Type >::begin
iterator_type begin() ENTT_NOEXCEPT
Returns an iterator to the beginning.
Definition: sparse_set.hpp:806
-
entt::SparseSet< Entity, Type >::sort
void sort(Compare compare, Sort sort=Sort{}, Args &&... args)
Sort components according to the given comparison function.
Definition: sparse_set.hpp:1033
-
entt::SparseSet< Entity >::end
iterator_type end() ENTT_NOEXCEPT
Returns an iterator to the end.
Definition: sparse_set.hpp:365
-
entt::SparseSet< Entity, Type >::end
iterator_type end() ENTT_NOEXCEPT
Returns an iterator to the end.
Definition: sparse_set.hpp:861
-
entt::SparseSet< Entity >::entity_type
Entity entity_type
Underlying entity identifier.
Definition: sparse_set.hpp:169
-
entt::SparseSet< Entity >::iterator_type
Iterator iterator_type
Input iterator type.
Definition: sparse_set.hpp:173
-
entt::SparseSet< Entity >
Basic sparse set implementation.
Definition: sparse_set.hpp:60
-
entt::SparseSet< Entity, Type >::respect
void respect(const SparseSet< Entity > &other) ENTT_NOEXCEPT
Sort components according to the order of the entities in another sparse set.
Definition: sparse_set.hpp:1080
-
entt::SparseSet< Entity >::const_iterator_type
Iterator const_iterator_type
Constant input iterator type.
Definition: sparse_set.hpp:175
-
entt::SparseSet< Entity, Type >::object_type
Type object_type
Type of the objects associated to the entities.
Definition: sparse_set.hpp:687
-
entt::SparseSet< Entity >::size
size_type size() const ENTT_NOEXCEPT
Returns the number of elements in a sparse set.
Definition: sparse_set.hpp:238
-
entt::SparseSet< Entity >::cend
const_iterator_type cend() const ENTT_NOEXCEPT
Returns an iterator to the end.
Definition: sparse_set.hpp:331
-
entt::SparseSet< Entity, Type >::end
const_iterator_type end() const ENTT_NOEXCEPT
Returns an iterator to the end.
Definition: sparse_set.hpp:843
-
entt::StdSort
Function object to wrap std::sort in a class type.
Definition: algorithm.hpp:21
-
entt::SparseSet< Entity >::destroy
virtual void destroy(const entity_type entity)
Removes an entity from a sparse set.
Definition: sparse_set.hpp:466
-
entt::SparseSet< Entity, Type >::raw
object_type * raw() ENTT_NOEXCEPT
Direct access to the array of objects.
Definition: sparse_set.hpp:757
-
entt::SparseSet< Entity >::respect
void respect(const SparseSet< Entity > &other) ENTT_NOEXCEPT
Sort entities according to their order in another sparse set.
Definition: sparse_set.hpp:520
-
entt::SparseSet< Entity >::begin
iterator_type begin() ENTT_NOEXCEPT
Returns an iterator to the beginning.
Definition: sparse_set.hpp:314
-
entt::SparseSet< Entity >::data
const entity_type * data() const ENTT_NOEXCEPT
Direct access to the internal packed array.
Definition: sparse_set.hpp:265
-
entt::SparseSet< Entity >::cbegin
const_iterator_type cbegin() const ENTT_NOEXCEPT
Returns an iterator to the beginning.
Definition: sparse_set.hpp:281
-
entt::SparseSet< Entity >::end
const_iterator_type end() const ENTT_NOEXCEPT
Returns an iterator to the end.
Definition: sparse_set.hpp:348
-
entt::SparseSet< Entity >::construct
void construct(const entity_type entity)
Assigns an entity to a sparse set.
Definition: sparse_set.hpp:442
-
entt::SparseSet< Entity >::operator[]
const entity_type & operator[](const size_type pos) const ENTT_NOEXCEPT
Returns a reference to the element at the given position.
Definition: sparse_set.hpp:374
-
entt::SparseSet< Entity, Type >::operator[]
const object_type & operator[](const size_type pos) const ENTT_NOEXCEPT
Returns a reference to the element at the given position.
Definition: sparse_set.hpp:870
-
entt::entt_traits
Entity traits.
Definition: entt_traits.hpp:18
+
entt::sparse_set::has
bool has(const entity_type entt) const ENTT_NOEXCEPT
Checks if a sparse set contains an entity.
Definition: sparse_set.hpp:364
+
entt::sparse_set::size_type
std::size_t size_type
Unsigned integer type.
Definition: sparse_set.hpp:176
+
entt::sparse_set::reserve
virtual void reserve(const size_type cap)
Increases the capacity of a sparse set.
Definition: sparse_set.hpp:231
+
entt::sparse_set::reset
virtual void reset()
Resets a sparse set.
Definition: sparse_set.hpp:521
+
entt::sparse_set::respect
virtual void respect(const sparse_set &other) ENTT_NOEXCEPT
Sort entities according to their order in another sparse set.
Definition: sparse_set.hpp:499
+
entt::sparse_set::begin
iterator_type begin() const ENTT_NOEXCEPT
Returns an iterator to the beginning.
Definition: sparse_set.hpp:327
+
entt::null
constexpr auto null
Null entity.
Definition: entity.hpp:163
+
entt::sparse_set::~sparse_set
virtual ~sparse_set() ENTT_NOEXCEPT=default
Default destructor.
+
entt::sparse_set::extent
size_type extent() const ENTT_NOEXCEPT
Returns the extent of a sparse set.
Definition: sparse_set.hpp:270
+
entt::sparse_set::shrink_to_fit
virtual void shrink_to_fit()
Requests the removal of unused capacity.
Definition: sparse_set.hpp:245
+
entt::sparse_set::capacity
size_type capacity() const ENTT_NOEXCEPT
Returns the number of elements that a sparse set has currently allocated space for.
Definition: sparse_set.hpp:240
+
entt::sparse_set< entity_type >::entity_type
entity_type entity_type
Underlying entity identifier.
Definition: sparse_set.hpp:174
+
entt::identifier
Types identifiers.
Definition: ident.hpp:42
+
entt::sparse_set::destroy
virtual void destroy(const entity_type entt)
Removes an entity from a sparse set.
Definition: sparse_set.hpp:445
+
entt::sparse_set::empty
bool empty() const ENTT_NOEXCEPT
Checks whether a sparse set is empty.
Definition: sparse_set.hpp:292
+
entt::sparse_set::sparse_set
sparse_set()=default
Default constructor.
+
entt::sparse_set::end
iterator_type end() const ENTT_NOEXCEPT
Returns an iterator to the end.
Definition: sparse_set.hpp:345
+
entt::sparse_set::find
iterator_type find(const entity_type entt) const ENTT_NOEXCEPT
Finds an entity.
Definition: sparse_set.hpp:355
+
entt::entt_traits
Entity traits.
Definition: entity.hpp:18
+
entt::operator!=
constexpr bool operator!=(const hashed_string &lhs, const hashed_string &rhs) ENTT_NOEXCEPT
Compares two hashed strings.
Definition: hashed_string.hpp:195
+
entt::sparse_set< entity_type >::iterator_type
iterator iterator_type
Random access iterator type.
Definition: sparse_set.hpp:178
+
entt::sparse_set::construct
void construct(const entity_type entt)
Assigns an entity to a sparse set.
Definition: sparse_set.hpp:399
diff --git a/storage_8hpp_source.html b/storage_8hpp_source.html new file mode 100644 index 000000000..de7cc9cbb --- /dev/null +++ b/storage_8hpp_source.html @@ -0,0 +1,125 @@ + + + + + + + +EnTT: src/entt/entity/storage.hpp Source File + + + + + + + + + +
+
+
bool entt::Process< Derived, Delta >::dead bool entt::process< Derived, Delta >::dead ( ) const - + @@ -291,8 +291,8 @@ template<typename Derived, typename Delta> - -

◆ pause()

+ +

◆ pause()

@@ -303,7 +303,7 @@ template<typename Derived, typename Delta>
@@ -67,27 +67,27 @@ $(function() {
sigh.hpp
-
1 #ifndef ENTT_SIGNAL_SIGH_HPP
2 #define ENTT_SIGNAL_SIGH_HPP
3 
4 
5 #include <algorithm>
6 #include <utility>
7 #include <vector>
8 #include "../config/config.h"
9 
10 
11 namespace entt {
12 
13 
20 namespace internal {
21 
22 
23 template<typename>
24 struct sigh_traits;
25 
26 
27 template<typename Ret, typename... Args>
28 struct sigh_traits<Ret(Args...)> {
29  using proto_fn_type = Ret(void *, Args...);
30  using call_type = std::pair<void *, proto_fn_type *>;
31 };
32 
33 
34 template<typename, typename>
35 struct Invoker;
36 
37 
38 template<typename Ret, typename... Args, typename Collector>
39 struct Invoker<Ret(Args...), Collector> {
40  using proto_fn_type = typename sigh_traits<Ret(Args...)>::proto_fn_type;
41 
42  virtual ~Invoker() = default;
43 
44  bool invoke(Collector &collector, proto_fn_type *proto, void *instance, Args... args) const {
45  return collector(proto(instance, args...));
46  }
47 };
48 
49 
50 template<typename... Args, typename Collector>
51 struct Invoker<void(Args...), Collector> {
52  using proto_fn_type = typename sigh_traits<void(Args...)>::proto_fn_type;
53 
54  virtual ~Invoker() = default;
55 
56  bool invoke(Collector &, proto_fn_type *proto, void *instance, Args... args) const {
57  return (proto(instance, args...), true);
58  }
59 };
60 
61 
62 template<typename Ret>
63 struct NullCollector final {
64  using result_type = Ret;
65  bool operator()(result_type) const ENTT_NOEXCEPT { return true; }
66 };
67 
68 
69 template<>
70 struct NullCollector<void> final {
71  using result_type = void;
72  bool operator()() const ENTT_NOEXCEPT { return true; }
73 };
74 
75 
76 template<typename>
77 struct DefaultCollector;
78 
79 
80 template<typename Ret, typename... Args>
81 struct DefaultCollector<Ret(Args...)> final {
82  using collector_type = NullCollector<Ret>;
83 };
84 
85 
86 template<typename Function>
87 using DefaultCollectorType = typename DefaultCollector<Function>::collector_type;
88 
89 
90 }
91 
92 
107 template<typename Function>
108 class Sink;
109 
110 
120 template<typename Function, typename Collector = internal::DefaultCollectorType<Function>>
121 class SigH;
122 
123 
138 template<typename Ret, typename... Args>
139 class Sink<Ret(Args...)> final {
141  template<typename, typename>
142  friend class SigH;
143 
144  using call_type = typename internal::sigh_traits<Ret(Args...)>::call_type;
145 
146  template<Ret(*Function)(Args...)>
147  static Ret proto(void *, Args... args) {
148  return (Function)(args...);
149  }
150 
151  template<typename Class, Ret(Class:: *Member)(Args... args) const>
152  static Ret proto(void *instance, Args... args) {
153  return (static_cast<const Class *>(instance)->*Member)(args...);
154  }
155 
156  template<typename Class, Ret(Class:: *Member)(Args... args)>
157  static Ret proto(void *instance, Args... args) {
158  return (static_cast<Class *>(instance)->*Member)(args...);
159  }
160 
161  Sink(std::vector<call_type> *calls) ENTT_NOEXCEPT
162  : calls{calls}
163  {}
164 
165 public:
174  template<Ret(*Function)(Args...)>
175  void connect() {
176  disconnect<Function>();
177  calls->emplace_back(nullptr, &proto<Function>);
178  }
179 
193  template<typename Class, Ret(Class:: *Member)(Args...) const = &Class::receive>
194  void connect(Class *instance) {
195  disconnect<Class, Member>(instance);
196  calls->emplace_back(instance, &proto<Class, Member>);
197  }
198 
212  template<typename Class, Ret(Class:: *Member)(Args...) = &Class::receive>
213  void connect(Class *instance) {
214  disconnect<Class, Member>(instance);
215  calls->emplace_back(instance, &proto<Class, Member>);
216  }
217 
222  template<Ret(*Function)(Args...)>
223  void disconnect() {
224  call_type target{nullptr, &proto<Function>};
225  calls->erase(std::remove(calls->begin(), calls->end(), std::move(target)), calls->end());
226  }
227 
234  template<typename Class, Ret(Class:: *Member)(Args...) const>
235  void disconnect(Class *instance) {
236  call_type target{instance, &proto<Class, Member>};
237  calls->erase(std::remove(calls->begin(), calls->end(), std::move(target)), calls->end());
238  }
239 
246  template<typename Class, Ret(Class:: *Member)(Args...)>
247  void disconnect(Class *instance) {
248  call_type target{instance, &proto<Class, Member>};
249  calls->erase(std::remove(calls->begin(), calls->end(), std::move(target)), calls->end());
250  }
251 
257  template<typename Class>
258  void disconnect(Class *instance) {
259  auto func = [instance](const call_type &call) { return call.first == instance; };
260  calls->erase(std::remove_if(calls->begin(), calls->end(), std::move(func)), calls->end());
261  }
262 
266  void disconnect() {
267  calls->clear();
268  }
269 
270 private:
271  std::vector<call_type> *calls;
272 };
273 
274 
298 template<typename Ret, typename... Args, typename Collector>
299 class SigH<Ret(Args...), Collector> final: private internal::Invoker<Ret(Args...), Collector> {
300  using call_type = typename internal::sigh_traits<Ret(Args...)>::call_type;
301 
302 public:
304  using size_type = typename std::vector<call_type>::size_type;
306  using collector_type = Collector;
308  using sink_type = Sink<Ret(Args...)>;
309 
314  template<typename Class>
315  using instance_type = Class *;
316 
321  size_type size() const ENTT_NOEXCEPT {
322  return calls.size();
323  }
324 
329  bool empty() const ENTT_NOEXCEPT {
330  return calls.empty();
331  }
332 
342  sink_type sink() ENTT_NOEXCEPT {
343  return { &calls };
344  }
345 
353  void publish(Args... args) const {
354  for(auto pos = calls.size(); pos; --pos) {
355  auto &call = calls[pos-1];
356  call.second(call.first, args...);
357  }
358  }
359 
365  collector_type collect(Args... args) const {
366  collector_type collector;
367 
368  for(auto &&call: calls) {
369  if(!this->invoke(collector, call.second, call.first, args...)) {
370  break;
371  }
372  }
373 
374  return collector;
375  }
376 
382  friend void swap(SigH &lhs, SigH &rhs) {
383  using std::swap;
384  swap(lhs.calls, rhs.calls);
385  }
386 
396  bool operator==(const SigH &other) const ENTT_NOEXCEPT {
397  return std::equal(calls.cbegin(), calls.cend(), other.calls.cbegin(), other.calls.cend());
398  }
399 
400 private:
401  std::vector<call_type> calls;
402 };
403 
404 
417 template<typename Ret, typename... Args>
418 bool operator!=(const SigH<Ret(Args...)> &lhs, const SigH<Ret(Args...)> &rhs) ENTT_NOEXCEPT {
419  return !(lhs == rhs);
420 }
421 
422 
423 }
424 
425 
426 #endif // ENTT_SIGNAL_SIGH_HPP
entt::operator!=
constexpr bool operator!=(const HashedString &lhs, const HashedString &rhs) ENTT_NOEXCEPT
Compares two hashed strings.
Definition: hashed_string.hpp:103
-
entt::Sink
Sink implementation.
Definition: sigh.hpp:108
-
entt::SigH< Ret(Args...), Collector >::instance_type
Class * instance_type
Instance type when it comes to connecting member functions.
Definition: sigh.hpp:315
-
entt::SigH< Ret(Args...), Collector >::collector_type
Collector collector_type
Collector type.
Definition: sigh.hpp:306
+
1 #ifndef ENTT_SIGNAL_SIGH_HPP
2 #define ENTT_SIGNAL_SIGH_HPP
3 
4 
5 #include <algorithm>
6 #include <utility>
7 #include <vector>
8 #include <functional>
9 #include <type_traits>
10 #include "../config/config.h"
11 #include "delegate.hpp"
12 #include "fwd.hpp"
13 
14 
15 namespace entt {
16 
17 
24 namespace internal {
25 
26 
27 template<typename, typename>
28 struct invoker;
29 
30 
31 template<typename Ret, typename... Args, typename Collector>
32 struct invoker<Ret(Args...), Collector> {
33  virtual ~invoker() = default;
34 
35  bool invoke(Collector &collector, const delegate<Ret(Args...)> &delegate, Args... args) const {
36  return collector(delegate(args...));
37  }
38 };
39 
40 
41 template<typename... Args, typename Collector>
42 struct invoker<void(Args...), Collector> {
43  virtual ~invoker() = default;
44 
45  bool invoke(Collector &, const delegate<void(Args...)> &delegate, Args... args) const {
46  return (delegate(args...), true);
47  }
48 };
49 
50 
51 template<typename Ret>
52 struct null_collector {
53  using result_type = Ret;
54  bool operator()(result_type) const ENTT_NOEXCEPT { return true; }
55 };
56 
57 
58 template<>
59 struct null_collector<void> {
60  using result_type = void;
61  bool operator()() const ENTT_NOEXCEPT { return true; }
62 };
63 
64 
65 template<typename>
66 struct default_collector;
67 
68 
69 template<typename Ret, typename... Args>
70 struct default_collector<Ret(Args...)> {
71  using collector_type = null_collector<Ret>;
72 };
73 
74 
75 template<typename Function>
76 using default_collector_type = typename default_collector<Function>::collector_type;
77 
78 
79 }
80 
81 
96 template<typename Function>
97 class sink;
98 
99 
109 template<typename Function, typename Collector = internal::default_collector_type<Function>>
110 struct sigh;
111 
112 
127 template<typename Ret, typename... Args>
128 class sink<Ret(Args...)> {
130  template<typename, typename>
131  friend struct sigh;
132 
133  template<typename Type>
134  Type * payload_type(Ret(*)(Type *, Args...));
135 
136  sink(std::vector<delegate<Ret(Args...)>> *ref) ENTT_NOEXCEPT
137  : calls{ref}
138  {}
139 
140 public:
145  bool empty() const ENTT_NOEXCEPT {
146  return calls->empty();
147  }
148 
157  template<auto Function>
158  void connect() {
159  disconnect<Function>();
160  delegate<Ret(Args...)> delegate{};
161  delegate.template connect<Function>();
162  calls->emplace_back(std::move(delegate));
163  }
164 
181  template<auto Candidate, typename Type>
182  void connect(Type *value_or_instance) {
183  if constexpr(std::is_member_function_pointer_v<decltype(Candidate)>) {
184  disconnect<Candidate>(value_or_instance);
185  } else {
186  disconnect<Candidate>();
187  }
188 
189  delegate<Ret(Args...)> delegate{};
190  delegate.template connect<Candidate>(value_or_instance);
191  calls->emplace_back(std::move(delegate));
192  }
193 
198  template<auto Function>
199  void disconnect() {
200  delegate<Ret(Args...)> delegate{};
201 
202  if constexpr(std::is_invocable_r_v<Ret, decltype(Function), Args...>) {
203  delegate.template connect<Function>();
204  } else {
205  decltype(payload_type(Function)) payload = nullptr;
206  delegate.template connect<Function>(payload);
207  }
208 
209  calls->erase(std::remove(calls->begin(), calls->end(), std::move(delegate)), calls->end());
210  }
211 
218  template<auto Member, typename Class>
219  void disconnect(Class *instance) {
220  static_assert(std::is_member_function_pointer_v<decltype(Member)>);
221  delegate<Ret(Args...)> delegate{};
222  delegate.template connect<Member>(instance);
223  calls->erase(std::remove_if(calls->begin(), calls->end(), [&delegate](const auto &other) {
224  return other == delegate && other.instance() == delegate.instance();
225  }), calls->end());
226  }
227 
231  void disconnect() {
232  calls->clear();
233  }
234 
235 private:
236  std::vector<delegate<Ret(Args...)>> *calls;
237 };
238 
239 
263 template<typename Ret, typename... Args, typename Collector>
264 struct sigh<Ret(Args...), Collector>: private internal::invoker<Ret(Args...), Collector> {
266  using size_type = typename std::vector<delegate<Ret(Args...)>>::size_type;
268  using collector_type = Collector;
270  using sink_type = entt::sink<Ret(Args...)>;
271 
276  template<typename Class>
277  using instance_type = Class *;
278 
283  size_type size() const ENTT_NOEXCEPT {
284  return calls.size();
285  }
286 
291  bool empty() const ENTT_NOEXCEPT {
292  return calls.empty();
293  }
294 
304  sink_type sink() ENTT_NOEXCEPT {
305  return { &calls };
306  }
307 
315  void publish(Args... args) const {
316  for(auto pos = calls.size(); pos; --pos) {
317  auto &call = calls[pos-1];
318  call(args...);
319  }
320  }
321 
327  collector_type collect(Args... args) const {
328  collector_type collector;
329 
330  for(auto &&call: calls) {
331  if(!this->invoke(collector, call, args...)) {
332  break;
333  }
334  }
335 
336  return collector;
337  }
338 
344  friend void swap(sigh &lhs, sigh &rhs) {
345  using std::swap;
346  swap(lhs.calls, rhs.calls);
347  }
348 
349 private:
350  std::vector<delegate<Ret(Args...)>> calls;
351 };
352 
353 
354 }
355 
356 
357 #endif // ENTT_SIGNAL_SIGH_HPP
entt::sigh< Ret(Args...), Collector >::empty
bool empty() const ENTT_NOEXCEPT
Returns false if at least a listener is connected to the signal.
Definition: sigh.hpp:291
+
entt::sigh< Ret(Args...), Collector >::publish
void publish(Args... args) const
Triggers a signal.
Definition: sigh.hpp:315
entt
EnTT default namespace.
Definition: algorithm.hpp:10
-
entt::Sink< Ret(Args...)>::disconnect
void disconnect(Class *instance)
Removes all existing connections for the given instance.
Definition: sigh.hpp:258
-
entt::SigH< Ret(Args...), Collector >::operator==
bool operator==(const SigH &other) const ENTT_NOEXCEPT
Checks if the contents of the two signals are identical.
Definition: sigh.hpp:396
-
entt::Sink< Ret(Args...)>::connect
void connect(Class *instance)
Connects a member function for a given instance to a signal.
Definition: sigh.hpp:194
-
entt::SigH< Ret(Args...), Collector >::collect
collector_type collect(Args... args) const
Collects return values from the listeners.
Definition: sigh.hpp:365
-
entt::SigH< Ret(Args...), Collector >::swap
friend void swap(SigH &lhs, SigH &rhs)
Swaps listeners between the two signals.
Definition: sigh.hpp:382
-
entt::SigH< Ret(Args...), Collector >::sink
sink_type sink() ENTT_NOEXCEPT
Returns a sink object for the given signal.
Definition: sigh.hpp:342
-
entt::SigH< Ret(Args...), Collector >::empty
bool empty() const ENTT_NOEXCEPT
Returns false if at least a listener is connected to the signal.
Definition: sigh.hpp:329
-
entt::SigH< Ret(Args...), Collector >::size_type
typename std::vector< call_type >::size_type size_type
Unsigned integer type.
Definition: sigh.hpp:304
-
entt::Sink< Ret(Args...)>::disconnect
void disconnect()
Disconnects all the listeners from a signal.
Definition: sigh.hpp:266
-
entt::Sink< Ret(Args...)>::disconnect
void disconnect()
Disconnects a free function from a signal.
Definition: sigh.hpp:223
-
entt::Sink< Ret(Args...)>::connect
void connect()
Connects a free function to a signal.
Definition: sigh.hpp:175
-
entt::SigH
Unmanaged signal handler declaration.
Definition: sigh.hpp:121
-
entt::Sink< Ret(Args...)>::disconnect
void disconnect(Class *instance)
Disconnects the given member function from a signal.
Definition: sigh.hpp:235
-
entt::SigH< Ret(Args...), Collector >::size
size_type size() const ENTT_NOEXCEPT
Number of listeners connected to the signal.
Definition: sigh.hpp:321
-
entt::Sink< Ret(Args...)>
Sink implementation.
Definition: sigh.hpp:139
-
entt::SigH< Ret(Args...), Collector >::publish
void publish(Args... args) const
Triggers a signal.
Definition: sigh.hpp:353
+
entt::sigh< Ret(Args...), Collector >::collect
collector_type collect(Args... args) const
Collects return values from the listeners.
Definition: sigh.hpp:327
+
entt::delegate
Basic delegate implementation.
Definition: delegate.hpp:66
+
entt::sink< Ret(Args...)>::disconnect
void disconnect()
Disconnects all the listeners from a signal.
Definition: sigh.hpp:231
+
entt::sink< Ret(Args...)>::connect
void connect()
Connects a free function to a signal.
Definition: sigh.hpp:158
+
entt::sink< Ret(Args...)>::disconnect
void disconnect(Class *instance)
Disconnects a given member function from a signal.
Definition: sigh.hpp:219
+
entt::sigh< Ret(Args...), Collector >::size_type
typename std::vector< delegate< Ret(Args...)> >::size_type size_type
Unsigned integer type.
Definition: sigh.hpp:266
+
entt::sigh< Ret(Args...), Collector >::size
size_type size() const ENTT_NOEXCEPT
Number of listeners connected to the signal.
Definition: sigh.hpp:283
+
entt::sink< Ret(Args...)>::connect
void connect(Type *value_or_instance)
Connects a member function or a free function with payload to a signal.
Definition: sigh.hpp:182
+
entt::sigh< Ret(Args...), Collector >::collector_type
Collector collector_type
Collector type.
Definition: sigh.hpp:268
+
entt::sigh< Ret(Args...), Collector >::swap
friend void swap(sigh &lhs, sigh &rhs)
Swaps listeners between the two signals.
Definition: sigh.hpp:344
+
entt::delegate
delegate(connect_arg_t< Function >) ENTT_NOEXCEPT -> delegate< std::remove_pointer_t< decltype(internal::to_function_pointer(Function))>>
Deduction guide.
+
entt::sigh
Unmanaged signal handler declaration.
Definition: fwd.hpp:21
+
entt::sink< Ret(Args...)>::empty
bool empty() const ENTT_NOEXCEPT
Returns false if at least a listener is connected to the sink.
Definition: sigh.hpp:145
+
entt::sigh< Ret(Args...), Collector >::sink
sink_type sink() ENTT_NOEXCEPT
Returns a sink object for the given signal.
Definition: sigh.hpp:304
+
entt::sink< Ret(Args...)>
Sink implementation.
Definition: sigh.hpp:128
+
entt::sink< Ret(Args...)>::disconnect
void disconnect()
Disconnects a free function from a signal.
Definition: sigh.hpp:199
+
entt::sink
Sink implementation.
Definition: fwd.hpp:17
+
entt::sigh< Ret(Args...), Collector >::instance_type
Class * instance_type
Instance type when it comes to connecting member functions.
Definition: sigh.hpp:277
diff --git a/signal_2fwd_8hpp_source.html b/signal_2fwd_8hpp_source.html new file mode 100644 index 000000000..bb85157d1 --- /dev/null +++ b/signal_2fwd_8hpp_source.html @@ -0,0 +1,82 @@ + + + + + + + +EnTT: src/entt/signal/fwd.hpp Source File + + + + + + + + + +
+
+
void entt::Process< Derived, Delta >::fail void entt::process< Derived, Delta >::fail ( ) - + @@ -323,8 +323,8 @@ template<typename Derived, typename Delta> - -

◆ paused()

+ +

◆ paused()

@@ -335,7 +335,7 @@ template<typename Derived, typename Delta>
@@ -67,19 +67,21 @@ $(function() {
scheduler.hpp
-
1 #ifndef ENTT_PROCESS_SCHEDULER_HPP
2 #define ENTT_PROCESS_SCHEDULER_HPP
3 
4 
5 #include <vector>
6 #include <memory>
7 #include <utility>
8 #include <algorithm>
9 #include <type_traits>
10 #include "../config/config.h"
11 #include "process.hpp"
12 
13 
14 namespace entt {
15 
16 
43 template<typename Delta>
44 class Scheduler final {
45  struct ProcessHandler final {
46  using instance_type = std::unique_ptr<void, void(*)(void *)>;
47  using update_fn_type = bool(ProcessHandler &, Delta, void *);
48  using abort_fn_type = void(ProcessHandler &, bool);
49  using next_type = std::unique_ptr<ProcessHandler>;
50 
51  instance_type instance;
52  update_fn_type *update;
53  abort_fn_type *abort;
54  next_type next;
55  };
56 
57  struct Then final {
58  Then(ProcessHandler *handler)
59  : handler{handler}
60  {}
61 
62  template<typename Proc, typename... Args>
63  decltype(auto) then(Args &&... args) && {
64  static_assert(std::is_base_of<Process<Proc, Delta>, Proc>::value, "!");
65  handler = Scheduler::then<Proc>(handler, std::forward<Args>(args)...);
66  return std::move(*this);
67  }
68 
69  template<typename Func>
70  decltype(auto) then(Func &&func) && {
71  using Proc = ProcessAdaptor<std::decay_t<Func>, Delta>;
72  return std::move(*this).template then<Proc>(std::forward<Func>(func));
73  }
74 
75  private:
76  ProcessHandler *handler;
77  };
78 
79  template<typename Proc>
80  static bool update(ProcessHandler &handler, const Delta delta, void *data) {
81  auto *process = static_cast<Proc *>(handler.instance.get());
82  process->tick(delta, data);
83 
84  auto dead = process->dead();
85 
86  if(dead) {
87  if(handler.next && !process->rejected()) {
88  handler = std::move(*handler.next);
89  dead = handler.update(handler, delta, data);
90  } else {
91  handler.instance.reset();
92  }
93  }
94 
95  return dead;
96  }
97 
98  template<typename Proc>
99  static void abort(ProcessHandler &handler, const bool immediately) {
100  static_cast<Proc *>(handler.instance.get())->abort(immediately);
101  }
102 
103  template<typename Proc>
104  static void deleter(void *proc) {
105  delete static_cast<Proc *>(proc);
106  }
107 
108  template<typename Proc, typename... Args>
109  static auto then(ProcessHandler *handler, Args &&... args) {
110  if(handler) {
111  auto proc = typename ProcessHandler::instance_type{new Proc{std::forward<Args>(args)...}, &Scheduler::deleter<Proc>};
112  handler->next.reset(new ProcessHandler{std::move(proc), &Scheduler::update<Proc>, &Scheduler::abort<Proc>, nullptr});
113  handler = handler->next.get();
114  }
115 
116  return handler;
117  }
118 
119 public:
121  using size_type = typename std::vector<ProcessHandler>::size_type;
122 
124  Scheduler() ENTT_NOEXCEPT = default;
125 
127  Scheduler(const Scheduler &) = delete;
129  Scheduler(Scheduler &&) = default;
130 
132  Scheduler & operator=(const Scheduler &) = delete;
134  Scheduler & operator=(Scheduler &&) = default;
135 
140  size_type size() const ENTT_NOEXCEPT {
141  return handlers.size();
142  }
143 
148  bool empty() const ENTT_NOEXCEPT {
149  return handlers.empty();
150  }
151 
158  void clear() {
159  handlers.clear();
160  }
161 
187  template<typename Proc, typename... Args>
188  auto attach(Args &&... args) {
189  static_assert(std::is_base_of<Process<Proc, Delta>, Proc>::value, "!");
190 
191  auto proc = typename ProcessHandler::instance_type{new Proc{std::forward<Args>(args)...}, &Scheduler::deleter<Proc>};
192  ProcessHandler handler{std::move(proc), &Scheduler::update<Proc>, &Scheduler::abort<Proc>, nullptr};
193  handlers.push_back(std::move(handler));
194 
195  return Then{&handlers.back()};
196  }
197 
248  template<typename Func>
249  auto attach(Func &&func) {
250  using Proc = ProcessAdaptor<std::decay_t<Func>, Delta>;
251  return attach<Proc>(std::forward<Func>(func));
252  }
253 
265  void update(const Delta delta, void *data = nullptr) {
266  bool clean = false;
267 
268  for(auto pos = handlers.size(); pos; --pos) {
269  auto &handler = handlers[pos-1];
270  const bool dead = handler.update(handler, delta, data);
271  clean = clean || dead;
272  }
273 
274  if(clean) {
275  handlers.erase(std::remove_if(handlers.begin(), handlers.end(), [](auto &handler) {
276  return !handler.instance;
277  }), handlers.end());
278  }
279  }
280 
291  void abort(const bool immediately = false) {
292  decltype(handlers) exec;
293  exec.swap(handlers);
294 
295  std::for_each(exec.begin(), exec.end(), [immediately](auto &handler) {
296  handler.abort(handler, immediately);
297  });
298 
299  std::move(handlers.begin(), handlers.end(), std::back_inserter(exec));
300  handlers.swap(exec);
301  }
302 
303 private:
304  std::vector<ProcessHandler> handlers{};
305 };
306 
307 
308 }
309 
310 
311 #endif // ENTT_PROCESS_SCHEDULER_HPP
entt::Scheduler::size
size_type size() const ENTT_NOEXCEPT
Number of processes currently scheduled.
Definition: scheduler.hpp:140
-
entt::Process
Base class for processes.
Definition: process.hpp:73
-
entt::Scheduler::clear
void clear()
Discards all scheduled processes.
Definition: scheduler.hpp:158
-
entt::Scheduler::empty
bool empty() const ENTT_NOEXCEPT
Returns true if at least a process is currently scheduled.
Definition: scheduler.hpp:148
-
entt::Scheduler::update
void update(const Delta delta, void *data=nullptr)
Updates all scheduled processes.
Definition: scheduler.hpp:265
+
1 #ifndef ENTT_PROCESS_SCHEDULER_HPP
2 #define ENTT_PROCESS_SCHEDULER_HPP
3 
4 
5 #include <vector>
6 #include <memory>
7 #include <utility>
8 #include <algorithm>
9 #include <type_traits>
10 #include "../config/config.h"
11 #include "process.hpp"
12 
13 
14 namespace entt {
15 
16 
43 template<typename Delta>
44 class scheduler {
45  struct process_handler {
46  using instance_type = std::unique_ptr<void, void(*)(void *)>;
47  using update_fn_type = bool(process_handler &, Delta, void *);
48  using abort_fn_type = void(process_handler &, bool);
49  using next_type = std::unique_ptr<process_handler>;
50 
51  instance_type instance;
52  update_fn_type *update;
53  abort_fn_type *abort;
54  next_type next;
55  };
56 
57  struct continuation {
58  continuation(process_handler *ref)
59  : handler{ref}
60  {
61  ENTT_ASSERT(handler);
62  }
63 
64  template<typename Proc, typename... Args>
65  continuation then(Args &&... args) {
66  static_assert(std::is_base_of_v<process<Proc, Delta>, Proc>);
67  auto proc = typename process_handler::instance_type{new Proc{std::forward<Args>(args)...}, &scheduler::deleter<Proc>};
68  handler->next.reset(new process_handler{std::move(proc), &scheduler::update<Proc>, &scheduler::abort<Proc>, nullptr});
69  handler = handler->next.get();
70  return *this;
71  }
72 
73  template<typename Func>
74  continuation then(Func &&func) {
75  return then<process_adaptor<std::decay_t<Func>, Delta>>(std::forward<Func>(func));
76  }
77 
78  private:
79  process_handler *handler;
80  };
81 
82  template<typename Proc>
83  static bool update(process_handler &handler, const Delta delta, void *data) {
84  auto *process = static_cast<Proc *>(handler.instance.get());
85  process->tick(delta, data);
86 
87  auto dead = process->dead();
88 
89  if(dead) {
90  if(handler.next && !process->rejected()) {
91  handler = std::move(*handler.next);
92  // forces the process to exit the uninitialized state
93  dead = handler.update(handler, {}, nullptr);
94  } else {
95  handler.instance.reset();
96  }
97  }
98 
99  return dead;
100  }
101 
102  template<typename Proc>
103  static void abort(process_handler &handler, const bool immediately) {
104  static_cast<Proc *>(handler.instance.get())->abort(immediately);
105  }
106 
107  template<typename Proc>
108  static void deleter(void *proc) {
109  delete static_cast<Proc *>(proc);
110  }
111 
112 public:
114  using size_type = typename std::vector<process_handler>::size_type;
115 
117  scheduler() ENTT_NOEXCEPT = default;
118 
120  scheduler(scheduler &&) = default;
121 
123  scheduler & operator=(scheduler &&) = default;
124 
129  size_type size() const ENTT_NOEXCEPT {
130  return handlers.size();
131  }
132 
137  bool empty() const ENTT_NOEXCEPT {
138  return handlers.empty();
139  }
140 
147  void clear() {
148  handlers.clear();
149  }
150 
176  template<typename Proc, typename... Args>
177  auto attach(Args &&... args) {
178  static_assert(std::is_base_of_v<process<Proc, Delta>, Proc>);
179  auto proc = typename process_handler::instance_type{new Proc{std::forward<Args>(args)...}, &scheduler::deleter<Proc>};
180  process_handler handler{std::move(proc), &scheduler::update<Proc>, &scheduler::abort<Proc>, nullptr};
181  // forces the process to exit the uninitialized state
182  handler.update(handler, {}, nullptr);
183  return continuation{&handlers.emplace_back(std::move(handler))};
184  }
185 
237  template<typename Func>
238  auto attach(Func &&func) {
239  using Proc = process_adaptor<std::decay_t<Func>, Delta>;
240  return attach<Proc>(std::forward<Func>(func));
241  }
242 
254  void update(const Delta delta, void *data = nullptr) {
255  bool clean = false;
256 
257  for(auto pos = handlers.size(); pos; --pos) {
258  auto &handler = handlers[pos-1];
259  const bool dead = handler.update(handler, delta, data);
260  clean = clean || dead;
261  }
262 
263  if(clean) {
264  handlers.erase(std::remove_if(handlers.begin(), handlers.end(), [](auto &handler) {
265  return !handler.instance;
266  }), handlers.end());
267  }
268  }
269 
280  void abort(const bool immediately = false) {
281  decltype(handlers) exec;
282  exec.swap(handlers);
283 
284  std::for_each(exec.begin(), exec.end(), [immediately](auto &handler) {
285  handler.abort(handler, immediately);
286  });
287 
288  std::move(handlers.begin(), handlers.end(), std::back_inserter(exec));
289  handlers.swap(exec);
290  }
291 
292 private:
293  std::vector<process_handler> handlers{};
294 };
295 
296 
297 }
298 
299 
300 #endif // ENTT_PROCESS_SCHEDULER_HPP
entt::scheduler::size_type
typename std::vector< process_handler >::size_type size_type
Unsigned integer type.
Definition: scheduler.hpp:114
+
entt::process::rejected
bool rejected() const ENTT_NOEXCEPT
Returns true if a process terminated with errors.
Definition: process.hpp:224
+
entt::scheduler::update
void update(const Delta delta, void *data=nullptr)
Updates all scheduled processes.
Definition: scheduler.hpp:254
+
entt::process::dead
bool dead() const ENTT_NOEXCEPT
Returns true if a process is already terminated.
Definition: process.hpp:208
entt
EnTT default namespace.
Definition: algorithm.hpp:10
-
entt::Scheduler::Scheduler
Scheduler() ENTT_NOEXCEPT=default
Default constructor.
-
entt::ProcessAdaptor
Adaptor for lambdas and functors to turn them into processes.
Definition: process.hpp:314
-
entt::Scheduler::size_type
typename std::vector< ProcessHandler >::size_type size_type
Unsigned integer type.
Definition: scheduler.hpp:121
-
entt::Scheduler::abort
void abort(const bool immediately=false)
Aborts all scheduled processes.
Definition: scheduler.hpp:291
-
entt::Scheduler::attach
auto attach(Args &&... args)
Schedules a process for the next tick.
Definition: scheduler.hpp:188
-
entt::Scheduler::attach
auto attach(Func &&func)
Schedules a process for the next tick.
Definition: scheduler.hpp:249
-
entt::Scheduler
Cooperative scheduler for processes.
Definition: scheduler.hpp:44
+
entt::scheduler::scheduler
scheduler() ENTT_NOEXCEPT=default
Default constructor.
+
entt::scheduler::size
size_type size() const ENTT_NOEXCEPT
Number of processes currently scheduled.
Definition: scheduler.hpp:129
+
entt::scheduler::attach
auto attach(Func &&func)
Schedules a process for the next tick.
Definition: scheduler.hpp:238
+
entt::scheduler::empty
bool empty() const ENTT_NOEXCEPT
Returns true if at least a process is currently scheduled.
Definition: scheduler.hpp:137
+
entt::process
Base class for processes.
Definition: process.hpp:73
+
entt::process_adaptor
Adaptor for lambdas and functors to turn them into processes.
Definition: process.hpp:315
+
entt::scheduler::clear
void clear()
Discards all scheduled processes.
Definition: scheduler.hpp:147
+
entt::scheduler::abort
void abort(const bool immediately=false)
Aborts all scheduled processes.
Definition: scheduler.hpp:280
+
entt::scheduler
Cooperative scheduler for processes.
Definition: scheduler.hpp:44
+
entt::scheduler::attach
auto attach(Args &&... args)
Schedules a process for the next tick.
Definition: scheduler.hpp:177
diff --git a/search/all_0.js b/search/all_0.js index caa1d67b8..27e783cc7 100644 --- a/search/all_0.js +++ b/search/all_0.js @@ -1,13 +1,12 @@ var searchData= [ - ['abort',['abort',['../classentt_1_1Process.html#ae7a9c2acd493969267ce4a6d2e2884b8',1,'entt::Process::abort()'],['../classentt_1_1Scheduler.html#af2494e025703d03a87117d6e897c87db',1,'entt::Scheduler::abort()']]], - ['accommodate',['accommodate',['../classentt_1_1Prototype.html#adaec9cc16436af85ef938fc9686cd02d',1,'entt::Prototype::accommodate(registry_type &other, const entity_type dst) const'],['../classentt_1_1Prototype.html#a37299298c61bb06a75b697296e328477',1,'entt::Prototype::accommodate(const entity_type dst) const'],['../classentt_1_1Registry.html#a6333a56f3a5a58882963a11bbbcf2ac2',1,'entt::Registry::accommodate()']]], - ['actor',['Actor',['../structentt_1_1Actor.html',1,'entt::Actor< Entity >'],['../structentt_1_1Actor.html#a000a099327600af5eaf86990fe886260',1,'entt::Actor::Actor(Registry< Entity > &reg)'],['../structentt_1_1Actor.html#a68a0a3b98e601615fca06a35bb68f47f',1,'entt::Actor::Actor(const Actor &)=delete'],['../structentt_1_1Actor.html#a74b71918643b7d02c8788db1b9b5cae6',1,'entt::Actor::Actor(Actor &&other)']]], - ['alive',['alive',['../classentt_1_1Registry.html#a4288576a8d41018b63838d4afdd01717',1,'entt::Registry::alive()'],['../classentt_1_1Process.html#ad18ce3558d2325d622fb2b8ab51c49d5',1,'entt::Process::alive()']]], - ['assign',['assign',['../structentt_1_1Actor.html#a0a161248d739e780833e534f7d1cf638',1,'entt::Actor::assign(tag_t, Args &&... args)'],['../structentt_1_1Actor.html#a7631fdb2de787c10b016a71905906147',1,'entt::Actor::assign(Args &&... args)'],['../classentt_1_1Prototype.html#a0a52cda550a678ee14272cff7b2fcf35',1,'entt::Prototype::assign(registry_type &other, const entity_type dst) const'],['../classentt_1_1Prototype.html#ab7bf733f40f1071d73d4f3245526c038',1,'entt::Prototype::assign(const entity_type dst) const'],['../classentt_1_1Registry.html#a93b5717af287a2b97e0ef9695c51ed58',1,'entt::Registry::assign(tag_t, const entity_type entity, Args &&... args)'],['../classentt_1_1Registry.html#a01f87450271067dda6c87f0c7c9b80dd',1,'entt::Registry::assign(const entity_type entity, Args &&... args)']]], - ['attach',['attach',['../classentt_1_1Scheduler.html#a1a836000f65e8e275119c0f77ec46674',1,'entt::Scheduler::attach(Args &&... args)'],['../classentt_1_1Scheduler.html#a5915b9783b278a6006d4857feefc0e3b',1,'entt::Scheduler::attach(Func &&func)']]], - ['attachee',['Attachee',['../classentt_1_1Attachee.html',1,'entt::Attachee<... >'],['../classentt_1_1Attachee_3_01Entity_01_4.html#a8774e0674c802952e298261b42dfdea2',1,'entt::Attachee< Entity >::Attachee() ENTT_NOEXCEPT'],['../classentt_1_1Attachee_3_01Entity_01_4.html#a3dc6b5bc229adf6e7decef65d3931575',1,'entt::Attachee< Entity >::Attachee(const Attachee &)=default'],['../classentt_1_1Attachee_3_01Entity_01_4.html#a436f1d599b6a4917185bc57dae3b5647',1,'entt::Attachee< Entity >::Attachee(Attachee &&)=default'],['../classentt_1_1Attachee_3_01Entity_00_01Type_01_4.html#a43dba4f726b1aced4c954e79d259a360',1,'entt::Attachee< Entity, Type >::Attachee() ENTT_NOEXCEPT=default'],['../classentt_1_1Attachee_3_01Entity_00_01Type_01_4.html#a806774cdf9c04019f8142c76738774b2',1,'entt::Attachee< Entity, Type >::Attachee(const Attachee &)=delete'],['../classentt_1_1Attachee_3_01Entity_00_01Type_01_4.html#ae1af322496b316594ce46022e49bf0ed',1,'entt::Attachee< Entity, Type >::Attachee(Attachee &&)=delete'],['../classentt_1_1Registry.html#af157dcabe4fe027e2f9cd45f4958f3b9',1,'entt::Registry::attachee()']]], - ['attachee_3c_20entity_20_3e',['Attachee< Entity >',['../classentt_1_1Attachee_3_01Entity_01_4.html',1,'entt']]], - ['attachee_3c_20entity_2c_20tag_20_3e',['Attachee< Entity, Tag >',['../classentt_1_1Attachee.html',1,'entt']]], - ['attachee_3c_20entity_2c_20type_20_3e',['Attachee< Entity, Type >',['../classentt_1_1Attachee_3_01Entity_00_01Type_01_4.html',1,'entt']]] + ['abort',['abort',['../classentt_1_1process.html#a0a45fb64300d51aa0f826609d11a3f78',1,'entt::process::abort()'],['../classentt_1_1scheduler.html#aabc25388bff1b3b0770f913f54b915f2',1,'entt::scheduler::abort()']]], + ['actor',['actor',['../namespaceentt.html#a3effdbc1557d9b1ffaed77f843c5c2cd',1,'entt']]], + ['alive',['alive',['../classentt_1_1basic__registry.html#a65a49772b3d59dd39c76b24a62e0fdf4',1,'entt::basic_registry::alive()'],['../classentt_1_1process.html#a8bc92bd0304659eb2a034fae65f1eeb9',1,'entt::process::alive()']]], + ['arg',['arg',['../classentt_1_1meta__ctor.html#a3faab3b8c49ee1b803f337435c8d54ce',1,'entt::meta_ctor::arg()'],['../classentt_1_1meta__func.html#a34709d9f0a7498382ced3a4e2daa64ba',1,'entt::meta_func::arg()']]], + ['as_5fgroup',['as_group',['../structentt_1_1as__group.html',1,'entt::as_group< Const, Entity >'],['../structentt_1_1as__group.html#a7ebe095efa7c1e00e2f156ad7930d9a9',1,'entt::as_group::as_group()'],['../namespaceentt.html#a6609f31d6ab3f544ebf7d0413d007ead',1,'entt::as_group(basic_registry< Entity > &) ENTT_NOEXCEPT -> as_group< false, Entity >'],['../namespaceentt.html#a8fce796266ac507c9b0c193a70f51745',1,'entt::as_group(const basic_registry< Entity > &) ENTT_NOEXCEPT -> as_group< true, Entity >']]], + ['as_5fview',['as_view',['../structentt_1_1as__view.html',1,'entt::as_view< Const, Entity >'],['../structentt_1_1as__view.html#a820ab4da509a0fb60c4edf8ea24b748a',1,'entt::as_view::as_view()'],['../namespaceentt.html#a3fee75741468f7807d3d48dd807ee024',1,'entt::as_view(basic_registry< Entity > &) ENTT_NOEXCEPT -> as_view< false, Entity >'],['../namespaceentt.html#aac314d83c9af1077857f01975f086bed',1,'entt::as_view(const basic_registry< Entity > &) ENTT_NOEXCEPT -> as_view< true, Entity >']]], + ['assign',['assign',['../structentt_1_1basic__actor.html#abf572e19a5d9625fbf80cc4f00cba032',1,'entt::basic_actor::assign()'],['../classentt_1_1basic__prototype.html#a0a5c5313d46f5f52977e7fc3fe93d865',1,'entt::basic_prototype::assign(registry_type &other, const entity_type dst) const'],['../classentt_1_1basic__prototype.html#a6062b4ed6fcf6053ea748b235db47807',1,'entt::basic_prototype::assign(const entity_type dst) const'],['../classentt_1_1basic__registry.html#a3deb5b8f14eb1414c92e6ccb2065ce0e',1,'entt::basic_registry::assign()']]], + ['assign_5for_5freplace',['assign_or_replace',['../classentt_1_1basic__prototype.html#ad8cc32084b579a727669e8f0e7b600a9',1,'entt::basic_prototype::assign_or_replace(registry_type &other, const entity_type dst) const'],['../classentt_1_1basic__prototype.html#a2884b160480a2e26acefd0d47316c26d',1,'entt::basic_prototype::assign_or_replace(const entity_type dst) const'],['../classentt_1_1basic__registry.html#aa013d9c67f8fda068f616aa9bb66b564',1,'entt::basic_registry::assign_or_replace()']]], + ['attach',['attach',['../classentt_1_1scheduler.html#a729c83e1983123c642a08cda67e486e3',1,'entt::scheduler::attach(Args &&... args)'],['../classentt_1_1scheduler.html#a871812d08af8483316d1ce5d1e9d686f',1,'entt::scheduler::attach(Func &&func)']]] ]; diff --git a/search/all_1.js b/search/all_1.js index 59542535f..a07dfee16 100644 --- a/search/all_1.js +++ b/search/all_1.js @@ -1,4 +1,24 @@ var searchData= [ - ['begin',['begin',['../classentt_1_1SparseSet_3_01Entity_01_4.html#aebd9c479dc54907cf42a4423f34edeb2',1,'entt::SparseSet< Entity >::begin() const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a6b33b62684d62255ca53a371cfbe1d28',1,'entt::SparseSet< Entity >::begin() ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a6f177729ba483b37119881db872b7736',1,'entt::SparseSet< Entity, Type >::begin() const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#aef10db6199e31f72c14c4be9347b0822',1,'entt::SparseSet< Entity, Type >::begin() ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#af1469f9dd45ebc68729e88e741c465a4',1,'entt::PersistentView::begin() const ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#a6bb6ca7b9dbbbf6da3f2cf7250a61075',1,'entt::PersistentView::begin() ENTT_NOEXCEPT'],['../classentt_1_1View.html#a7c59406241bd142289a0d618a33f98d3',1,'entt::View::begin() const ENTT_NOEXCEPT'],['../classentt_1_1View.html#a5d4b1ac137a2dd3ac7f8f91a40b6eb0e',1,'entt::View::begin() ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a7c59406241bd142289a0d618a33f98d3',1,'entt::View< Entity, Component >::begin() const ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a5d4b1ac137a2dd3ac7f8f91a40b6eb0e',1,'entt::View< Entity, Component >::begin() ENTT_NOEXCEPT'],['../classentt_1_1RawView.html#a564cc60d60b8d80aefca967eea79031f',1,'entt::RawView::begin() const ENTT_NOEXCEPT'],['../classentt_1_1RawView.html#a195eb860ca3f49f72fc08e4505431286',1,'entt::RawView::begin() ENTT_NOEXCEPT'],['../classentt_1_1RuntimeView.html#af1fb74dd84e6ffd0f8626b8f0f55af91',1,'entt::RuntimeView::begin() const ENTT_NOEXCEPT'],['../classentt_1_1RuntimeView.html#a8b424a07dd1fdca3a11103dbc6ad76ac',1,'entt::RuntimeView::begin() ENTT_NOEXCEPT']]] + ['backend',['backend',['../structentt_1_1basic__actor.html#a079bddd72566b14843729a154a8f684e',1,'entt::basic_actor::backend() const ENTT_NOEXCEPT'],['../structentt_1_1basic__actor.html#a827ed2e23e39e8b706f7acc511a46024',1,'entt::basic_actor::backend() ENTT_NOEXCEPT'],['../classentt_1_1basic__prototype.html#a3eca09d9203b3ad97d6663e0bf5bb2f8',1,'entt::basic_prototype::backend() const ENTT_NOEXCEPT'],['../classentt_1_1basic__prototype.html#ac6cdd27694a8e9e2bdb576ffca098e1b',1,'entt::basic_prototype::backend() ENTT_NOEXCEPT']]], + ['base',['base',['../classentt_1_1meta__factory.html#a08184dab6a4da744ad630ede2ac0856b',1,'entt::meta_factory::base()'],['../classentt_1_1meta__type.html#a03961322c038576a874fd927a407d14e',1,'entt::meta_type::base(Op op) const ENTT_NOEXCEPT'],['../classentt_1_1meta__type.html#a987d41f4887a6b9c1a710969d1e7e825',1,'entt::meta_type::base(const char *str) const ENTT_NOEXCEPT']]], + ['basic_5factor',['basic_actor',['../structentt_1_1basic__actor.html',1,'entt::basic_actor< Entity >'],['../structentt_1_1basic__actor.html#a32635ae3046ebca665adef6b3ef87ef3',1,'entt::basic_actor::basic_actor(registry_type &ref)'],['../structentt_1_1basic__actor.html#a8c86ac43873d5b42c1774ea6646513e0',1,'entt::basic_actor::basic_actor(basic_actor &&other)']]], + ['basic_5fcontinuous_5floader',['basic_continuous_loader',['../classentt_1_1basic__continuous__loader.html',1,'entt::basic_continuous_loader< Entity >'],['../classentt_1_1basic__continuous__loader.html#a18d87fd5fc80f062ae27b90ef3232bd8',1,'entt::basic_continuous_loader::basic_continuous_loader(basic_registry< entity_type > &source) ENTT_NOEXCEPT'],['../classentt_1_1basic__continuous__loader.html#a619f3aa278b405481fd1e26c46a96a5c',1,'entt::basic_continuous_loader::basic_continuous_loader(basic_continuous_loader &&)=default']]], + ['basic_5fgroup',['basic_group',['../classentt_1_1basic__group.html',1,'entt']]], + ['basic_5fgroup_3c_20entity_2c_20get_5ft_3c_20get_2e_2e_2e_20_3e_20_3e',['basic_group< Entity, get_t< Get... > >',['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html',1,'entt']]], + ['basic_5fgroup_3c_20entity_2c_20get_5ft_3c_20get_2e_2e_2e_20_3e_2c_20owned_2e_2e_2e_20_3e',['basic_group< Entity, get_t< Get... >, Owned... >',['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html',1,'entt']]], + ['basic_5fprototype',['basic_prototype',['../classentt_1_1basic__prototype.html',1,'entt::basic_prototype< Entity >'],['../classentt_1_1basic__prototype.html#acffae325962a54170176025d67d38a80',1,'entt::basic_prototype::basic_prototype(registry_type &ref)'],['../classentt_1_1basic__prototype.html#a1592ff421e77a624830cb965c6f52110',1,'entt::basic_prototype::basic_prototype(basic_prototype &&other)']]], + ['basic_5fregistry',['basic_registry',['../classentt_1_1basic__registry.html',1,'entt::basic_registry< Entity >'],['../classentt_1_1basic__registry.html#af976c68848de4fa6db6dea2b4cf76e77',1,'entt::basic_registry::basic_registry() ENTT_NOEXCEPT=default'],['../classentt_1_1basic__registry.html#a3fc181b150fee3e42b8cad4103953b9f',1,'entt::basic_registry::basic_registry(basic_registry &&)=default']]], + ['basic_5fregistry_3c_20entity_20_3e',['basic_registry< Entity >',['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#a60c928831c22b7dd2216dbc469f68f24',1,'entt::basic_group< Entity, get_t< Get... > >::basic_registry< Entity >()'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html#a60c928831c22b7dd2216dbc469f68f24',1,'entt::basic_group< Entity, get_t< Get... >, Owned... >::basic_registry< Entity >()'],['../classentt_1_1basic__runtime__view.html#a60c928831c22b7dd2216dbc469f68f24',1,'entt::basic_runtime_view::basic_registry< Entity >()'],['../classentt_1_1basic__snapshot.html#a60c928831c22b7dd2216dbc469f68f24',1,'entt::basic_snapshot::basic_registry< Entity >()'],['../classentt_1_1basic__snapshot__loader.html#a60c928831c22b7dd2216dbc469f68f24',1,'entt::basic_snapshot_loader::basic_registry< Entity >()'],['../classentt_1_1basic__view.html#a60c928831c22b7dd2216dbc469f68f24',1,'entt::basic_view::basic_registry< Entity >()'],['../classentt_1_1basic__view_3_01Entity_00_01Component_01_4.html#a60c928831c22b7dd2216dbc469f68f24',1,'entt::basic_view< Entity, Component >::basic_registry< Entity >()']]], + ['basic_5fruntime_5fview',['basic_runtime_view',['../classentt_1_1basic__runtime__view.html',1,'entt']]], + ['basic_5fsnapshot',['basic_snapshot',['../classentt_1_1basic__snapshot.html',1,'entt::basic_snapshot< Entity >'],['../classentt_1_1basic__snapshot.html#a10f658d8e4feb7df9da8b48119551334',1,'entt::basic_snapshot::basic_snapshot()']]], + ['basic_5fsnapshot_5floader',['basic_snapshot_loader',['../classentt_1_1basic__snapshot__loader.html',1,'entt::basic_snapshot_loader< Entity >'],['../classentt_1_1basic__snapshot__loader.html#acc078b2e9068ae41a2910168b40322d4',1,'entt::basic_snapshot_loader::basic_snapshot_loader()']]], + ['basic_5fstorage',['basic_storage',['../classentt_1_1basic__storage.html',1,'entt']]], + ['basic_5fstorage_3c_20entity_2c_20component_20_3e',['basic_storage< Entity, Component >',['../classentt_1_1basic__storage.html',1,'entt']]], + ['basic_5fstorage_3c_20entity_2c_20type_20_3e',['basic_storage< Entity, Type >',['../classentt_1_1basic__storage.html',1,'entt']]], + ['basic_5fstorage_3c_20entity_2c_20type_2c_20std_3a_3aenable_5fif_5ft_3c_20std_3a_3ais_5fempty_5fv_3c_20type_20_3e_20_3e_20_3e',['basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >',['../classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty__v_3_01Type_01_4_01_4_01_4.html',1,'entt']]], + ['basic_5fview',['basic_view',['../classentt_1_1basic__view.html',1,'entt']]], + ['basic_5fview_3c_20entity_2c_20component_20_3e',['basic_view< Entity, Component >',['../classentt_1_1basic__view_3_01Entity_00_01Component_01_4.html',1,'entt']]], + ['batch',['batch',['../classentt_1_1sparse__set.html#a642460f7f0ca8e42220c43c785467063',1,'entt::sparse_set::batch()'],['../classentt_1_1basic__storage.html#ab6d4fdce9c54a7468eed85423d82e520',1,'entt::basic_storage::batch()']]], + ['begin',['begin',['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#aa68f0d2a68100cb41d5413063b22eb27',1,'entt::basic_group< Entity, get_t< Get... > >::begin()'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html#a8076bfc4e22d1b1e8b42fbd9cc1c0c68',1,'entt::basic_group< Entity, get_t< Get... >, Owned... >::begin()'],['../classentt_1_1basic__runtime__view.html#af47b1aff2d44990f17c9740cf24a2670',1,'entt::basic_runtime_view::begin()'],['../classentt_1_1sparse__set.html#a06743336f265989b48e106a3d3bd1562',1,'entt::sparse_set::begin()'],['../classentt_1_1basic__storage.html#aecc4b13b67a7664c5c36596f2b927bed',1,'entt::basic_storage::begin() const ENTT_NOEXCEPT'],['../classentt_1_1basic__storage.html#ab963b76ebe297a1ad4a2c433aa55f2b5',1,'entt::basic_storage::begin() ENTT_NOEXCEPT'],['../classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty__v_3_01Type_01_4_01_4_01_4.html#aa4a66c77a01df615cbdf02c07e184bd1',1,'entt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >::begin()'],['../classentt_1_1basic__view.html#a00d2bb01727273bf40acdf1a57588fc7',1,'entt::basic_view::begin()'],['../classentt_1_1basic__view_3_01Entity_00_01Component_01_4.html#a00d2bb01727273bf40acdf1a57588fc7',1,'entt::basic_view< Entity, Component >::begin()']]] ]; diff --git a/search/all_10.js b/search/all_10.js index 1af19899d..23d16e3bf 100644 --- a/search/all_10.js +++ b/search/all_10.js @@ -1,10 +1,29 @@ var searchData= [ - ['tag',['tag',['../classentt_1_1Snapshot.html#ac13d5fe79511e27f7b935e84c112e051',1,'entt::Snapshot::tag(Archive &archive) const'],['../classentt_1_1Snapshot.html#a960471c2f13bc1c693a9c58396e63b93',1,'entt::Snapshot::tag(Archive &archive) const'],['../classentt_1_1SnapshotLoader.html#afc4964c76a8fc7a8a1c6a435babc796f',1,'entt::SnapshotLoader::tag()'],['../classentt_1_1ContinuousLoader.html#a8d50d3f90d95b370305561da67da6c3b',1,'entt::ContinuousLoader::tag()']]], - ['tag_5ft',['tag_t',['../structentt_1_1tag__t.html',1,'entt']]], - ['tag_5ftype',['tag_type',['../classentt_1_1Registry.html#a357cfdc1b3c5abc7a36e8eddbd6ce5c7',1,'entt::Registry']]], - ['temp',['temp',['../classentt_1_1ResourceCache.html#a00ad6d9478d2f6721f0a846b49adec07',1,'entt::ResourceCache']]], - ['tick',['tick',['../classentt_1_1Process.html#a9298c55069b27d4ffa005f4345be4d59',1,'entt::Process']]], - ['trigger',['trigger',['../classentt_1_1Dispatcher.html#a89d44e6fa992fba9ba927f4b1492f66f',1,'entt::Dispatcher']]], - ['type',['type',['../classentt_1_1Family.html#aa5ce983dfef17bf0df6a608308193f6d',1,'entt::Family::type()'],['../classentt_1_1Registry.html#a682552d500d7768b5d9d4e5f547cdfaf',1,'entt::Registry::type(tag_t) ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a484018ca7d1898708ea17a651eddc7e4',1,'entt::Registry::type() ENTT_NOEXCEPT']]] + ['scheduler',['scheduler',['../classentt_1_1scheduler.html',1,'entt::scheduler< Delta >'],['../classentt_1_1scheduler.html#a7b06b3a881b89c9d3b9829ccf111fae4',1,'entt::scheduler::scheduler() ENTT_NOEXCEPT=default'],['../classentt_1_1scheduler.html#af582ffea72368a83ea4dd7d9e563f715',1,'entt::scheduler::scheduler(scheduler &&)=default']]], + ['service_5flocator',['service_locator',['../structentt_1_1service__locator.html',1,'entt::service_locator< Service >'],['../structentt_1_1service__locator.html#a120cdb3eb1d820e5649f3d8bac8098d0',1,'entt::service_locator::service_locator()']]], + ['service_5ftype',['service_type',['../structentt_1_1service__locator.html#af34a883e56f32a98d7b8a5db87bdf504',1,'entt::service_locator']]], + ['set',['set',['../classentt_1_1basic__prototype.html#afb3ed35c2b2edcca53a618116208ca94',1,'entt::basic_prototype::set()'],['../classentt_1_1basic__registry.html#a7d771eee6e8e573bf1b8e4e8501ea7f1',1,'entt::basic_registry::set()'],['../structentt_1_1service__locator.html#a116dc62f5d2a1c65db9d7528c957e91f',1,'entt::service_locator::set(Args &&... args)'],['../structentt_1_1service__locator.html#a86770e79d01ab5fb0dddffba0bf9a697',1,'entt::service_locator::set(std::shared_ptr< Service > ptr)'],['../classentt_1_1meta__data.html#a776f1d239c00cc96c683bbbd348119da',1,'entt::meta_data::set(meta_handle handle, Type &&value) const'],['../classentt_1_1meta__data.html#ae0a9924efdaedd5bec4ed37efa5e0671',1,'entt::meta_data::set(meta_handle handle, std::size_t index, Type &&value) const']]], + ['shrink',['shrink',['../classentt_1_1basic__continuous__loader.html#a01b949f4a5829bd5bf3738a7e0f776d2',1,'entt::basic_continuous_loader']]], + ['shrink_5fto_5ffit',['shrink_to_fit',['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#a40a638de8c83e543dea5d89fbe46d7a7',1,'entt::basic_group< Entity, get_t< Get... > >::shrink_to_fit()'],['../classentt_1_1basic__registry.html#a63aa387e557553d61483a58807cd785e',1,'entt::basic_registry::shrink_to_fit()'],['../classentt_1_1sparse__set.html#ad410641d1403e3b0c38c119511c6a54c',1,'entt::sparse_set::shrink_to_fit()'],['../classentt_1_1basic__storage.html#ab794e48f20864cd5db6c56aa85af315e',1,'entt::basic_storage::shrink_to_fit()']]], + ['sigh',['sigh',['../structentt_1_1sigh.html',1,'entt::sigh< typename, typename >'],['../classentt_1_1sink_3_01Ret_07Args_8_8_8_08_4.html#a312dc0d91e6a3d5eec9f202a263c7e47',1,'entt::sink< Ret(Args...)>::sigh()']]], + ['sigh_3c_20ret_28args_2e_2e_2e_29_2c_20collector_20_3e',['sigh< Ret(Args...), Collector >',['../structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html',1,'entt']]], + ['sigh_3c_20void_28const_20event_20_26_29_3e',['sigh< void(const Event &)>',['../structentt_1_1sigh.html',1,'entt']]], + ['sigh_3c_20void_28entt_3a_3abasic_5fregistry_20_26_2c_20const_20entity_29_3e',['sigh< void(entt::basic_registry &, const Entity)>',['../structentt_1_1sigh.html',1,'entt']]], + ['sigh_3c_20void_28entt_3a_3abasic_5fregistry_20_26_2c_20const_20entity_2c_20std_3a_3aconditional_5ft_3c_20std_3a_3ais_5fempty_5fv_3c_20component_20_3e_2c_20const_20component_20_26_2c_20component_20_26_3e_29_3e',['sigh< void(entt::basic_registry &, const Entity, std::conditional_t< std::is_empty_v< Component >, const Component &, Component &>)>',['../structentt_1_1sigh.html',1,'entt']]], + ['sink',['sink',['../classentt_1_1sink.html',1,'entt::sink< typename >'],['../classentt_1_1dispatcher.html#afedd59083875621a11510b00c84c8878',1,'entt::dispatcher::sink()'],['../structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#a5e436274ab7f40394bf3272561db8d3a',1,'entt::sigh< Ret(Args...), Collector >::sink()']]], + ['sink_3c_20ret_28args_2e_2e_2e_29_3e',['sink< Ret(Args...)>',['../classentt_1_1sink_3_01Ret_07Args_8_8_8_08_4.html',1,'entt']]], + ['sink_5ftype',['sink_type',['../classentt_1_1dispatcher.html#a9ab3b084146a292b2dd2411cea452273',1,'entt::dispatcher::sink_type()'],['../structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#adcfc3a58cb6421c41637461e9ac97812',1,'entt::sigh< Ret(Args...), Collector >::sink_type()']]], + ['size',['size',['../structentt_1_1type__list.html#a430c0675bdbcbb40be9b8f13f7259484',1,'entt::type_list::size()'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#a99b144072f6eda675eb3d272bfb5aec3',1,'entt::basic_group< Entity, get_t< Get... > >::size() const ENTT_NOEXCEPT'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#ab414ffe7acdf36c249c42d71812ec1e9',1,'entt::basic_group< Entity, get_t< Get... > >::size() const ENTT_NOEXCEPT'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html#ad62ba67afadc3b4c45298c65f672404a',1,'entt::basic_group< Entity, get_t< Get... >, Owned... >::size() const ENTT_NOEXCEPT'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html#abcf4e26f33e523318b7d640ce605b6d8',1,'entt::basic_group< Entity, get_t< Get... >, Owned... >::size() const ENTT_NOEXCEPT'],['../classentt_1_1basic__registry.html#abb5713726f7b5c4b67a0271a64bedd2f',1,'entt::basic_registry::size() const ENTT_NOEXCEPT'],['../classentt_1_1basic__registry.html#afdfc12e1ffa6bac72c2de9af7e91f44e',1,'entt::basic_registry::size() const ENTT_NOEXCEPT'],['../classentt_1_1basic__runtime__view.html#a8a14205c30a77fae500ff244a8f9041e',1,'entt::basic_runtime_view::size()'],['../classentt_1_1sparse__set.html#a340dff7484f1e58feff58a5f0627e190',1,'entt::sparse_set::size()'],['../classentt_1_1basic__view.html#a05e540230bfb537a7574da0f8d4eaaa5',1,'entt::basic_view::size() const ENTT_NOEXCEPT'],['../classentt_1_1basic__view.html#acb9ee6ba89ed94297808c4ee04d21f1e',1,'entt::basic_view::size() const ENTT_NOEXCEPT'],['../classentt_1_1basic__view_3_01Entity_00_01Component_01_4.html#acb9ee6ba89ed94297808c4ee04d21f1e',1,'entt::basic_view< Entity, Component >::size()'],['../classentt_1_1meta__ctor.html#ad0ac4a64b630462768a3f12f6389b6e7',1,'entt::meta_ctor::size()'],['../classentt_1_1meta__func.html#ae4bc5f5e90003362872d8cd056b2f689',1,'entt::meta_func::size()'],['../classentt_1_1scheduler.html#ab0c473e6d4733bdb78f3dc26147de4ad',1,'entt::scheduler::size()'],['../classentt_1_1resource__cache.html#a115fe363ea30ae2e6fe2d2c7420c672c',1,'entt::resource_cache::size()'],['../structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#a1c1a46bd4335d6c45e8a3e2b7223a0c7',1,'entt::sigh< Ret(Args...), Collector >::size()']]], + ['size_5ftype',['size_type',['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#aeeca37a280faff7a53129a9b712ee523',1,'entt::basic_group< Entity, get_t< Get... > >::size_type()'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html#a515301bf580587caac4bdfdf8d178623',1,'entt::basic_group< Entity, get_t< Get... >, Owned... >::size_type()'],['../classentt_1_1basic__prototype.html#a01d3afe0260e80974f24c1d36b5fbccc',1,'entt::basic_prototype::size_type()'],['../classentt_1_1basic__registry.html#a19addadd1c414778261e7c1ed67eee76',1,'entt::basic_registry::size_type()'],['../classentt_1_1basic__runtime__view.html#af8fef2e30d39eaa7ce736539a55c2a1a',1,'entt::basic_runtime_view::size_type()'],['../classentt_1_1sparse__set.html#a3d2138b0eb8c7ac968e9e38a9e981ec1',1,'entt::sparse_set::size_type()'],['../classentt_1_1basic__storage.html#ab820e508dfbc4442bc9a114cf49efde7',1,'entt::basic_storage::size_type()'],['../classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty__v_3_01Type_01_4_01_4_01_4.html#a9c0a52b283bc9b0ac2b7bf72cc76f996',1,'entt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >::size_type()'],['../classentt_1_1basic__view.html#a8f3ec253d7fc6da42e9eb0e5c8f6a655',1,'entt::basic_view::size_type()'],['../classentt_1_1basic__view_3_01Entity_00_01Component_01_4.html#aecab46810f8e3a65a3aa46e14028b40a',1,'entt::basic_view< Entity, Component >::size_type()'],['../classentt_1_1meta__ctor.html#a7a267e333222dab22e7a965137538f18',1,'entt::meta_ctor::size_type()'],['../classentt_1_1meta__func.html#a422ec572c7c56d3cb46d09704be64f65',1,'entt::meta_func::size_type()'],['../classentt_1_1meta__type.html#a7362687fc89444507cded22f57be3ff0',1,'entt::meta_type::size_type()'],['../classentt_1_1scheduler.html#a7b08d5871918b39049c29e4daa62271f',1,'entt::scheduler::size_type()'],['../classentt_1_1resource__cache.html#abfb6bd59f656ca6139602bbc7bb4c24a',1,'entt::resource_cache::size_type()'],['../structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#accb002f3088f2a3b5b5ff1fdd24fd353',1,'entt::sigh< Ret(Args...), Collector >::size_type()']]], + ['snapshot',['snapshot',['../classentt_1_1basic__registry.html#ad6ab9182dd41bc02ddfc0c3c8195a215',1,'entt::basic_registry::snapshot()'],['../namespaceentt.html#a80012f9fa628920a3507ae947704d447',1,'entt::snapshot()']]], + ['snapshot_5floader',['snapshot_loader',['../namespaceentt.html#ae7e50fc296c4ea68183db332950b99f5',1,'entt']]], + ['sort',['sort',['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#a23d2a9946ff93ffe57b528db9a760e2e',1,'entt::basic_group< Entity, get_t< Get... > >::sort()'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html#a0464e3b686015ec92dbf0efecc8bcbd6',1,'entt::basic_group< Entity, get_t< Get... >, Owned... >::sort()'],['../classentt_1_1basic__registry.html#a38ac2a883e3d881c6ae5a05a0252b7ae',1,'entt::basic_registry::sort(Compare compare, Sort algo=Sort{}, Args &&... args)'],['../classentt_1_1basic__registry.html#a2907f89b80fb692b16727e5e67a91c5d',1,'entt::basic_registry::sort()'],['../classentt_1_1basic__storage.html#ac1ed30f50fdc3eb2f994e3b4440dcf32',1,'entt::basic_storage::sort()']]], + ['sparse_5fset',['sparse_set',['../classentt_1_1sparse__set.html',1,'entt::sparse_set< Entity >'],['../classentt_1_1sparse__set.html#a8ef544aaed30126797f6f0b9a9f8b9e8',1,'entt::sparse_set::sparse_set()=default'],['../classentt_1_1sparse__set.html#af684a44e129f3aafd311814b5972378f',1,'entt::sparse_set::sparse_set(const sparse_set &other)'],['../classentt_1_1sparse__set.html#af8f4f137b5ac0984599067d5408db5bf',1,'entt::sparse_set::sparse_set(sparse_set &&)=default']]], + ['sparse_5fset_3c_20entity_5ftype_20_3e',['sparse_set< entity_type >',['../classentt_1_1sparse__set.html',1,'entt']]], + ['std_5fsort',['std_sort',['../structentt_1_1std__sort.html',1,'entt']]], + ['storage',['storage',['../structentt_1_1storage.html',1,'entt']]], + ['storage_3c_20entity_2c_20component_20_3e',['storage< Entity, Component >',['../structentt_1_1storage.html',1,'entt']]], + ['succeed',['succeed',['../classentt_1_1process.html#a43d63ba9304654f0209fc32d2c74f4ce',1,'entt::process']]], + ['swap',['swap',['../classentt_1_1sparse__set.html#a3777f32f6c173b65a922caa8058efc93',1,'entt::sparse_set::swap()'],['../classentt_1_1meta__any.html#a939cebbfd07b49ed6365c302f838dc03',1,'entt::meta_any::swap()'],['../structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#a85fb0c034b7e550330ff267bb1bcdfce',1,'entt::sigh< Ret(Args...), Collector >::swap()']]] ]; diff --git a/search/all_11.js b/search/all_11.js index 585dca5cd..723caf08c 100644 --- a/search/all_11.js +++ b/search/all_11.js @@ -1,6 +1,22 @@ var searchData= [ - ['unpause',['unpause',['../classentt_1_1Process.html#aeb2057ef29594395ef68b965e6b27c7e',1,'entt::Process']]], - ['unset',['unset',['../classentt_1_1Prototype.html#ac75f485a3afa9dada4574269be50166d',1,'entt::Prototype']]], - ['update',['update',['../structentt_1_1ProcessAdaptor.html#a46e837972764bdd457f7512212367eb5',1,'entt::ProcessAdaptor::update()'],['../classentt_1_1Scheduler.html#aff001b4bf5aaa53fe1fda94991e73935',1,'entt::Scheduler::update()'],['../classentt_1_1Dispatcher.html#a2c3ffb218856dd962c7e50a5de14b918',1,'entt::Dispatcher::update()'],['../classentt_1_1Dispatcher.html#a88431e5c4e050d8c2e5ee880b920f5a5',1,'entt::Dispatcher::update() const']]] + ['tag',['tag',['../namespaceentt.html#af3e97711799c25b85af58006541601e2',1,'entt']]], + ['temp',['temp',['../classentt_1_1resource__cache.html#a74d899246a6acf2414d6b149e12533c2',1,'entt::resource_cache']]], + ['tick',['tick',['../classentt_1_1process.html#aacc7fe0ef3265113079c70ff8cd9478d',1,'entt::process']]], + ['to_5fvalue',['to_value',['../classentt_1_1hashed__string.html#a1641786d9583eee4a5cd373a7df9449e',1,'entt::hashed_string::to_value(const char(&str)[N]) ENTT_NOEXCEPT'],['../classentt_1_1hashed__string.html#ac0e253c370cc1fb200211b7b3d485d97',1,'entt::hashed_string::to_value(const_wrapper wrapper) ENTT_NOEXCEPT'],['../classentt_1_1hashed__string.html#ade8d090abfa489e3f11554e0e362c540',1,'entt::hashed_string::to_value(const char *str, std::size_t size) ENTT_NOEXCEPT']]], + ['trigger',['trigger',['../classentt_1_1dispatcher.html#ac3d3eae7004c63f0232b09f2770c4ebd',1,'entt::dispatcher::trigger(Args &&... args)'],['../classentt_1_1dispatcher.html#a1d14234071d22c9fe09c453ebd818d2e',1,'entt::dispatcher::trigger(Event &&event)']]], + ['try_5fcast',['try_cast',['../classentt_1_1meta__handle.html#acb0127bdd270a55523492e6314cede51',1,'entt::meta_handle::try_cast() const ENTT_NOEXCEPT'],['../classentt_1_1meta__handle.html#a95f9e578c26fffc8880f985bfc8f8e04',1,'entt::meta_handle::try_cast() ENTT_NOEXCEPT']]], + ['try_5fctx',['try_ctx',['../classentt_1_1basic__registry.html#a33650f5792414c71ef00c3bcaca3f1d5',1,'entt::basic_registry::try_ctx() const ENTT_NOEXCEPT'],['../classentt_1_1basic__registry.html#a4182d11d18ec7873562c2842a332ac89',1,'entt::basic_registry::try_ctx() ENTT_NOEXCEPT']]], + ['try_5fget',['try_get',['../structentt_1_1basic__actor.html#ac37259d66c0a8f42b7e744567382c6c2',1,'entt::basic_actor::try_get() const ENTT_NOEXCEPT'],['../structentt_1_1basic__actor.html#a0320585b864c700d980212f37654a8a1',1,'entt::basic_actor::try_get() ENTT_NOEXCEPT'],['../classentt_1_1basic__prototype.html#a26c239c2d51cda5c0f5ff398d6a67f8c',1,'entt::basic_prototype::try_get() const ENTT_NOEXCEPT'],['../classentt_1_1basic__prototype.html#a59e50d3b0aabb00952322a72bdaa5c69',1,'entt::basic_prototype::try_get() ENTT_NOEXCEPT'],['../classentt_1_1basic__registry.html#a25c4412448ddcbfe1290f72498ae7809',1,'entt::basic_registry::try_get([[maybe_unused]] const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1basic__registry.html#a2c3ba909a2f845601a5b873c6bdd8371',1,'entt::basic_registry::try_get([[maybe_unused]] const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1basic__storage.html#aab7da23b603d6cc78e67b3509ad979fa',1,'entt::basic_storage::try_get(const entity_type entt) const ENTT_NOEXCEPT'],['../classentt_1_1basic__storage.html#a8ff9d6ef48840c8ad88f8c0b8b5dcd35',1,'entt::basic_storage::try_get(const entity_type entt) ENTT_NOEXCEPT']]], + ['type',['type',['../structentt_1_1type__list__cat_3_01type__list_3_01Type_8_8_8_01_4_00_01type__list_3_01Other_8_8_8_01_4_00_01List_8_8_8_01_4.html#ae17db475954ad06eba24fd1eedba5f8b',1,'entt::type_list_cat< type_list< Type... >, type_list< Other... >, List... >::type()'],['../structentt_1_1type__list__cat_3_01type__list_3_01Type_8_8_8_01_4_01_4.html#a0c40287fad9d80f0532d80bf48f219ed',1,'entt::type_list_cat< type_list< Type... > >::type()'],['../structentt_1_1type__list__unique_3_01type__list_3_01Type_00_01Other_8_8_8_01_4_01_4.html#a378823486aa4e4f288b1d73b2703c485',1,'entt::type_list_unique< type_list< Type, Other... > >::type()'],['../structentt_1_1type__list__unique_3_01type__list_3_4_01_4.html#a48245981f9818ca2601b9815cbfa5b79',1,'entt::type_list_unique< type_list<> >::type()'],['../classentt_1_1family.html#ad2c16ecd854f12f1aa70ceaba094e43a',1,'entt::family::type()'],['../classentt_1_1identifier.html#adb3aad553b8d57ef94581af39fc53178',1,'entt::identifier::type()'],['../classentt_1_1basic__registry.html#a47bb003d6c82097e1c0d5a7d462f033e',1,'entt::basic_registry::type()'],['../classentt_1_1meta__any.html#a406ea303f140056a30103d90afab2737',1,'entt::meta_any::type()'],['../classentt_1_1meta__handle.html#aa8f78e22bdf61554c38f27575fd8cf33',1,'entt::meta_handle::type()'],['../classentt_1_1meta__base.html#a5e9f69b43cdc90add110654acde5e8b6',1,'entt::meta_base::type()'],['../classentt_1_1meta__conv.html#accdedbb8b1636f59967dc30ba5d7e753',1,'entt::meta_conv::type()'],['../classentt_1_1meta__data.html#a4d99cf1fb67d2bea840fa608dc95e64f',1,'entt::meta_data::type()']]], + ['type_5flist',['type_list',['../structentt_1_1type__list.html',1,'entt']]], + ['type_5flist_3c_20type_2e_2e_2e_20_3e',['type_list< Type... >',['../structentt_1_1type__list.html',1,'entt']]], + ['type_5flist_5fcat',['type_list_cat',['../structentt_1_1type__list__cat.html',1,'entt']]], + ['type_5flist_5fcat_3c_20type_5flist_3c_20type_2e_2e_2e_20_3e_20_3e',['type_list_cat< type_list< Type... > >',['../structentt_1_1type__list__cat_3_01type__list_3_01Type_8_8_8_01_4_01_4.html',1,'entt']]], + ['type_5flist_5fcat_3c_20type_5flist_3c_20type_2e_2e_2e_20_3e_2c_20type_5flist_3c_20other_2e_2e_2e_20_3e_2c_20list_2e_2e_2e_20_3e',['type_list_cat< type_list< Type... >, type_list< Other... >, List... >',['../structentt_1_1type__list__cat_3_01type__list_3_01Type_8_8_8_01_4_00_01type__list_3_01Other_8_8_8_01_4_00_01List_8_8_8_01_4.html',1,'entt']]], + ['type_5flist_5fcat_5ft',['type_list_cat_t',['../namespaceentt.html#a546467a3662e9a915d5d519ad565e801',1,'entt']]], + ['type_5flist_5funique',['type_list_unique',['../structentt_1_1type__list__unique.html',1,'entt']]], + ['type_5flist_5funique_3c_20type_5flist_3c_20type_2c_20other_2e_2e_2e_20_3e_20_3e',['type_list_unique< type_list< Type, Other... > >',['../structentt_1_1type__list__unique_3_01type__list_3_01Type_00_01Other_8_8_8_01_4_01_4.html',1,'entt']]], + ['type_5flist_5funique_3c_20type_5flist_3c_3e_20_3e',['type_list_unique< type_list<> >',['../structentt_1_1type__list__unique_3_01type__list_3_4_01_4.html',1,'entt']]], + ['type_5flist_5funique_5ft',['type_list_unique_t',['../namespaceentt.html#a75a277a6037279d65cd3874b46ec7166',1,'entt']]] ]; diff --git a/search/all_12.js b/search/all_12.js index 2ad76a9b8..03bee7994 100644 --- a/search/all_12.js +++ b/search/all_12.js @@ -1,9 +1,7 @@ var searchData= [ - ['valid',['valid',['../classentt_1_1Registry.html#aaba72db4ebf99a911b58327063ec8ad9',1,'entt::Registry']]], - ['version',['version',['../classentt_1_1Registry.html#ad7467ac1c8a7657062b1b4386dded54e',1,'entt::Registry']]], - ['version_5fmask',['version_mask',['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#a83bda73c5a360f5ba8f653d0f888993b',1,'entt::entt_traits< std::uint16_t >::version_mask()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#a6ada978f907780643740d9ca2a8e8762',1,'entt::entt_traits< std::uint32_t >::version_mask()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#a3f9f70e677d638708d0ce72ce1a28c92',1,'entt::entt_traits< std::uint64_t >::version_mask()']]], - ['version_5ftype',['version_type',['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#ab37d10c3be3d59159a63c0bd1e9e2924',1,'entt::entt_traits< std::uint16_t >::version_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#aee59dc7455ea0be015e699c3e46a22d1',1,'entt::entt_traits< std::uint32_t >::version_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#aeac4d9172940a9dec0682860ac176725',1,'entt::entt_traits< std::uint64_t >::version_type()'],['../classentt_1_1Registry.html#a82c8996277034df5e72b5f30a70ebb2d',1,'entt::Registry::version_type()']]], - ['view',['View',['../classentt_1_1View.html',1,'entt::View< Entity, Component >'],['../classentt_1_1Registry.html#aed83d4c8f80ae647ee73f2a8440fa09d',1,'entt::Registry::view()'],['../classentt_1_1Registry.html#abb1eb5f1a2ec31d14b5b98271ff78f1e',1,'entt::Registry::view(persistent_t)'],['../classentt_1_1Registry.html#aedc2a2344c5d13a0483608d48189a92a',1,'entt::Registry::view(raw_t)'],['../classentt_1_1Registry.html#a4a157973e57670b5df3eedc8d137de7e',1,'entt::Registry::view(It first, It last)']]], - ['view_3c_20entity_2c_20component_20_3e',['View< Entity, Component >',['../classentt_1_1View_3_01Entity_00_01Component_01_4.html',1,'entt']]] + ['unpause',['unpause',['../classentt_1_1process.html#a91fd8adb2ea48c88c6f9fb5818890f67',1,'entt::process']]], + ['unregister',['unregister',['../classentt_1_1meta__factory.html#aa43299816c83740fdf20e6d7687f9055',1,'entt::meta_factory::unregister()'],['../namespaceentt.html#a04658621584dae59cabe9863a38e0e7a',1,'entt::unregister()']]], + ['unset',['unset',['../classentt_1_1basic__prototype.html#a05230038ddbafaca4d5da09dfb247186',1,'entt::basic_prototype::unset()'],['../classentt_1_1basic__registry.html#aaa23b74e76b1749bb510a86e9d31b9cd',1,'entt::basic_registry::unset()']]], + ['update',['update',['../structentt_1_1process__adaptor.html#a7514fabbbda491742872bc0e52dde5c2',1,'entt::process_adaptor::update()'],['../classentt_1_1scheduler.html#a827eae426378df9ed9190752156a4154',1,'entt::scheduler::update()'],['../classentt_1_1dispatcher.html#aabed6fd7fa4027dcfa3afc7bc20f2784',1,'entt::dispatcher::update()'],['../classentt_1_1dispatcher.html#ae15c11634047d7718db5e2e30675c80c',1,'entt::dispatcher::update() const']]] ]; diff --git a/search/all_13.js b/search/all_13.js index 35728c7ea..91e011929 100644 --- a/search/all_13.js +++ b/search/all_13.js @@ -1,10 +1,9 @@ var searchData= [ - ['_7eactor',['~Actor',['../structentt_1_1Actor.html#a3ab5d325569b88346684a1cffd6bd633',1,'entt::Actor']]], - ['_7eattachee',['~Attachee',['../classentt_1_1Attachee_3_01Entity_01_4.html#a134cedd024e7adcd4332b2514f856111',1,'entt::Attachee< Entity >::~Attachee()'],['../classentt_1_1Attachee_3_01Entity_00_01Type_01_4.html#aa75f3b1253e049f669e92fef3ac237bc',1,'entt::Attachee< Entity, Type >::~Attachee()']]], - ['_7eemitter',['~Emitter',['../classentt_1_1Emitter.html#ac713dddc6b8f7b056e3c1a8979a4e271',1,'entt::Emitter']]], - ['_7eprocess',['~Process',['../classentt_1_1Process.html#abcfd11c007770ec8bd997333b00f5f8b',1,'entt::Process']]], - ['_7eprototype',['~Prototype',['../classentt_1_1Prototype.html#acb70104c3d32fcf22fbe37afa7602ed5',1,'entt::Prototype']]], - ['_7eservicelocator',['~ServiceLocator',['../structentt_1_1ServiceLocator.html#af0dc69f829f93c86b6537cf0c133ef75',1,'entt::ServiceLocator']]], - ['_7esparseset',['~SparseSet',['../classentt_1_1SparseSet_3_01Entity_01_4.html#a7a0a9d11f6b89102468b45ed83651bc8',1,'entt::SparseSet< Entity >']]] + ['valid',['valid',['../classentt_1_1basic__registry.html#ac7d145b7adb8ca486c49cfd44aebea73',1,'entt::basic_registry']]], + ['value',['value',['../classentt_1_1hashed__string.html#af5cb18d66625ba096e2e95069ac710cd',1,'entt::hashed_string::value()'],['../classentt_1_1meta__prop.html#a38a979e40971692929b46f80c3f22f9e',1,'entt::meta_prop::value()']]], + ['version',['version',['../classentt_1_1basic__registry.html#a75f09d82b0cd6305ea7422d60162704e',1,'entt::basic_registry']]], + ['version_5fmask',['version_mask',['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#a83bda73c5a360f5ba8f653d0f888993b',1,'entt::entt_traits< std::uint16_t >::version_mask()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#a6ada978f907780643740d9ca2a8e8762',1,'entt::entt_traits< std::uint32_t >::version_mask()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#a3f9f70e677d638708d0ce72ce1a28c92',1,'entt::entt_traits< std::uint64_t >::version_mask()']]], + ['version_5ftype',['version_type',['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#ab37d10c3be3d59159a63c0bd1e9e2924',1,'entt::entt_traits< std::uint16_t >::version_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#aee59dc7455ea0be015e699c3e46a22d1',1,'entt::entt_traits< std::uint32_t >::version_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#aeac4d9172940a9dec0682860ac176725',1,'entt::entt_traits< std::uint64_t >::version_type()'],['../classentt_1_1basic__registry.html#aae2197c81e29459bbe3fa7984656a2b6',1,'entt::basic_registry::version_type()']]], + ['view',['view',['../classentt_1_1basic__registry.html#ab2ea1df9f827924f2ecba67921bf4845',1,'entt::basic_registry::view()'],['../classentt_1_1basic__registry.html#a1a2ffab3b15bb205ceef86b8d8b3fdcb',1,'entt::basic_registry::view() const'],['../namespaceentt.html#af2118c00dea16193aee017d1408beb53',1,'entt::view()']]] ]; diff --git a/search/all_14.html b/search/all_14.html new file mode 100644 index 000000000..fb4d0ecc7 --- /dev/null +++ b/search/all_14.html @@ -0,0 +1,26 @@ + + + + + + + + + +
+
Loading...
+
+ +
Searching...
+
No Matches
+ +
+ + diff --git a/search/all_14.js b/search/all_14.js new file mode 100644 index 000000000..71a260f3a --- /dev/null +++ b/search/all_14.js @@ -0,0 +1,10 @@ +var searchData= +[ + ['_7ebasic_5factor',['~basic_actor',['../structentt_1_1basic__actor.html#a46dc913885c448e059e9ca7cf3a21221',1,'entt::basic_actor']]], + ['_7ebasic_5fprototype',['~basic_prototype',['../classentt_1_1basic__prototype.html#a1181e970dc90a33b823210d33af819d5',1,'entt::basic_prototype']]], + ['_7eemitter',['~emitter',['../classentt_1_1emitter.html#a77d175ad8e8060c3628b3fb544cba15f',1,'entt::emitter']]], + ['_7emeta_5fany',['~meta_any',['../classentt_1_1meta__any.html#a816dae3d4ed3e41fcb376ec5ec9c38c1',1,'entt::meta_any']]], + ['_7eprocess',['~process',['../classentt_1_1process.html#a9280903240c53d1f2c7474ae8ccaa48d',1,'entt::process']]], + ['_7eservice_5flocator',['~service_locator',['../structentt_1_1service__locator.html#a2cbb6cfc1614067ae92f1c60580236a8',1,'entt::service_locator']]], + ['_7esparse_5fset',['~sparse_set',['../classentt_1_1sparse__set.html#a74c49e0d205b6240bf14ac3003cfcbd1',1,'entt::sparse_set']]] +]; diff --git a/search/all_2.js b/search/all_2.js index 814ab5882..e6233b599 100644 --- a/search/all_2.js +++ b/search/all_2.js @@ -2,26 +2,36 @@ var searchData= [ ['contributing',['Contributing',['../autotoc_md0.html',1,'']]], ['crash_20course_3a_20core_20functionalities',['Crash Course: core functionalities',['../autotoc_md1.html',1,'']]], - ['crash_20course_3a_20service_20locator',['Crash Course: service locator',['../autotoc_md41.html',1,'']]], - ['crash_20course_3a_20cooperative_20scheduler',['Crash Course: cooperative scheduler',['../autotoc_md44.html',1,'']]], - ['crash_20course_3a_20resource_20management',['Crash Course: resource management',['../autotoc_md49.html',1,'']]], - ['crash_20course_3a_20events_2c_20signals_20and_20everything_20in_20between',['Crash Course: events, signals and everything in between',['../autotoc_md53.html',1,'']]], + ['crash_20course_3a_20service_20locator',['Crash Course: service locator',['../autotoc_md58.html',1,'']]], + ['crash_20course_3a_20reflection_20system',['Crash Course: reflection system',['../autotoc_md61.html',1,'']]], + ['crash_20course_3a_20cooperative_20scheduler',['Crash Course: cooperative scheduler',['../autotoc_md69.html',1,'']]], + ['crash_20course_3a_20resource_20management',['Crash Course: resource management',['../autotoc_md74.html',1,'']]], + ['crash_20course_3a_20events_2c_20signals_20and_20everything_20in_20between',['Crash Course: events, signals and everything in between',['../autotoc_md77.html',1,'']]], ['crash_20course_3a_20entity_2dcomponent_20system',['Crash Course: entity-component system',['../autotoc_md8.html',1,'']]], - ['capacity',['capacity',['../classentt_1_1Registry.html#a38e5391f9c1b4a8ea814f0abcf7a3323',1,'entt::Registry::capacity() const ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#aefe4ec26db45257de26da19147a9e3f3',1,'entt::Registry::capacity() const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#affd4ddc4bc12517d84772a40b0d992d5',1,'entt::SparseSet< Entity >::capacity()']]], - ['cbegin',['cbegin',['../classentt_1_1SparseSet_3_01Entity_01_4.html#a1ba1127cc520b39c2d147da99000866f',1,'entt::SparseSet< Entity >::cbegin()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#af38e9a34f90809eae7b2d51882cc2302',1,'entt::SparseSet< Entity, Type >::cbegin()'],['../classentt_1_1PersistentView.html#a5a6d810548ae9959047cc1a6249c5aff',1,'entt::PersistentView::cbegin()'],['../classentt_1_1View.html#a2cefabdbdd85098f9ac789a47fcc930a',1,'entt::View::cbegin()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a2cefabdbdd85098f9ac789a47fcc930a',1,'entt::View< Entity, Component >::cbegin()'],['../classentt_1_1RawView.html#a2550b7ceee635d59bac8eddce6523cf3',1,'entt::RawView::cbegin()'],['../classentt_1_1RuntimeView.html#a838fbbbceba139250db0dd186de86506',1,'entt::RuntimeView::cbegin()']]], - ['cend',['cend',['../classentt_1_1SparseSet_3_01Entity_01_4.html#aaec7e4e14421c38084ef57b13d40a15d',1,'entt::SparseSet< Entity >::cend()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#ae5994b196eca429c708722ba4b720208',1,'entt::SparseSet< Entity, Type >::cend()'],['../classentt_1_1PersistentView.html#a8ae9798901deacb27827f23b9ab51fe2',1,'entt::PersistentView::cend()'],['../classentt_1_1View.html#ab57c0ac7a0bb1487f525757a07a6bd71',1,'entt::View::cend()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#ab57c0ac7a0bb1487f525757a07a6bd71',1,'entt::View< Entity, Component >::cend()'],['../classentt_1_1RawView.html#aedfe14bbc1b65afecc549cc65354575f',1,'entt::RawView::cend()'],['../classentt_1_1RuntimeView.html#a111c068457853eb5c55845e68fd7b8a6',1,'entt::RuntimeView::cend()']]], - ['clear',['clear',['../classentt_1_1Scheduler.html#a2fd48cfd2ce32308f5e7bb8bafd5cda2',1,'entt::Scheduler::clear()'],['../classentt_1_1ResourceCache.html#a9ab70500ad42f8bd565ce1c379f472b4',1,'entt::ResourceCache::clear()'],['../classentt_1_1Emitter.html#a4e722d57776f3185e39386e6f252c56b',1,'entt::Emitter::clear() ENTT_NOEXCEPT'],['../classentt_1_1Emitter.html#a12ce32d79978c671a4d72532cd8e33f7',1,'entt::Emitter::clear() ENTT_NOEXCEPT']]], - ['collect',['collect',['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#af50a728e8b61c75af4286132e1312c77',1,'entt::SigH< Ret(Args...), Collector >']]], - ['collector_5ftype',['collector_type',['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#ad0e4e34e41daec83437b1c607855079a',1,'entt::SigH< Ret(Args...), Collector >']]], - ['component',['component',['../classentt_1_1Snapshot.html#a336288f5faaeb5f49831e3a0b4445bb0',1,'entt::Snapshot::component(Archive &archive) const'],['../classentt_1_1Snapshot.html#a4aa8df6d1e59c4f441e472f63f5ee580',1,'entt::Snapshot::component(Archive &archive) const'],['../classentt_1_1Snapshot.html#a98433fc64a9935e744a4c1b1f5d6e630',1,'entt::Snapshot::component(Archive &archive, It first, It last) const'],['../classentt_1_1SnapshotLoader.html#a03f291aa5216eab207780f785a75bbba',1,'entt::SnapshotLoader::component()'],['../classentt_1_1ContinuousLoader.html#a9c185ecae861f074afb1d2a14cf4f0f2',1,'entt::ContinuousLoader::component()']]], - ['component_5ftype',['component_type',['../classentt_1_1Registry.html#aefd07a0cdff88ebf1e35e531d58c3077',1,'entt::Registry']]], - ['connect',['connect',['../classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html#a51d3c462c56349e09a1c7fe0d58859b7',1,'entt::Delegate< Ret(Args...)>::connect() ENTT_NOEXCEPT'],['../classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html#a453219af4b49ccaf258e564006ed1f07',1,'entt::Delegate< Ret(Args...)>::connect(Class *instance) ENTT_NOEXCEPT'],['../classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html#a453219af4b49ccaf258e564006ed1f07',1,'entt::Delegate< Ret(Args...)>::connect(Class *instance) ENTT_NOEXCEPT'],['../classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html#a1b37a003e4d4edc19f95b1924ef18323',1,'entt::Sink< Ret(Args...)>::connect()'],['../classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html#a53d91eccac3db8a7b64534f2b52d31bb',1,'entt::Sink< Ret(Args...)>::connect(Class *instance)'],['../classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html#a53d91eccac3db8a7b64534f2b52d31bb',1,'entt::Sink< Ret(Args...)>::connect(Class *instance)'],['../namespaceentt.html#a70059e6999fc2c4fa892b3a8afc4d8bc',1,'entt::connect()']]], - ['connection',['Connection',['../structentt_1_1Emitter_1_1Connection.html',1,'entt::Emitter< Derived >::Connection< Event >'],['../structentt_1_1Emitter_1_1Connection.html#a1091537202d401609a73f0ee3fcc9ea6',1,'entt::Emitter::Connection::Connection() ENTT_NOEXCEPT=default'],['../structentt_1_1Emitter_1_1Connection.html#af059ef0d0aa727ea11e6873144fcbc1b',1,'entt::Emitter::Connection::Connection(typename Handler< Event >::connection_type conn)'],['../structentt_1_1Emitter_1_1Connection.html#a1ccd273683a9fb65a7a4d0c9bf7d0543',1,'entt::Emitter::Connection::Connection(const Connection &)=default'],['../structentt_1_1Emitter_1_1Connection.html#a0c5020d2127d9d0e45abd7e9c08c65c3',1,'entt::Emitter::Connection::Connection(Connection &&)=default']]], - ['const_5fiterator_5ftype',['const_iterator_type',['../classentt_1_1SparseSet_3_01Entity_01_4.html#aba42055f0c8a43cae63d443a17f6a5e2',1,'entt::SparseSet< Entity >::const_iterator_type()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a947d3fd0440167f469331a31b1d8d782',1,'entt::SparseSet< Entity, Type >::const_iterator_type()'],['../classentt_1_1PersistentView.html#a260bd2740fb90caf984ce62c26bb887b',1,'entt::PersistentView::const_iterator_type()'],['../classentt_1_1View.html#a81b76e0389ffeb60195a3391c4c5ce3a',1,'entt::View::const_iterator_type()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a79316bcf7c15b52712689653fff419c3',1,'entt::View< Entity, Component >::const_iterator_type()'],['../classentt_1_1RawView.html#a5fa9cd28fb18ccfe01fd0eb3ea6e3dc7',1,'entt::RawView::const_iterator_type()'],['../classentt_1_1RuntimeView.html#acf976983924a5e0194a19a9b98fdc249',1,'entt::RuntimeView::const_iterator_type()']]], - ['construct',['construct',['../classentt_1_1Attachee_3_01Entity_01_4.html#a264393f844d8058b7b1e1ce3b83626bd',1,'entt::Attachee< Entity >::construct()'],['../classentt_1_1Attachee_3_01Entity_00_01Type_01_4.html#af89f69ab26880a5bdf390ebbae2a445e',1,'entt::Attachee< Entity, Type >::construct()'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a47dad39fa63ac4be07dcd9234c8a57c7',1,'entt::SparseSet< Entity >::construct()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#acf06fa56b6b0880d546dd3bc0ddc087f',1,'entt::SparseSet< Entity, Type >::construct(const entity_type entity, Args &&... args)'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#aded5c64ff04ee1a78e7e238208923d58',1,'entt::SparseSet< Entity, Type >::construct(const entity_type entity, Args &&... args)']]], - ['construction',['construction',['../classentt_1_1Registry.html#a6f6b29268ba11a8526fa3f9d3bdb58e5',1,'entt::Registry::construction(tag_t) ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#af43b25946f4cbdec633df25317edc020',1,'entt::Registry::construction() ENTT_NOEXCEPT']]], - ['contains',['contains',['../classentt_1_1Registry.html#a67a9d1a75fa1f8e29091f1127c0f3a70',1,'entt::Registry::contains()'],['../classentt_1_1PersistentView.html#af98a61a6ac04e08b6b46e4163ad3d415',1,'entt::PersistentView::contains()'],['../classentt_1_1View.html#abbc407e2fecdbcf97c129ade5db185e8',1,'entt::View::contains()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#abbc407e2fecdbcf97c129ade5db185e8',1,'entt::View< Entity, Component >::contains()'],['../classentt_1_1RuntimeView.html#a903cb93104fba0816f71f8851c6ff162',1,'entt::RuntimeView::contains()'],['../classentt_1_1ResourceCache.html#aa133ec347db1ee8fab5d757b8b24a185',1,'entt::ResourceCache::contains()']]], - ['continuousloader',['ContinuousLoader',['../classentt_1_1ContinuousLoader.html',1,'entt::ContinuousLoader< Entity >'],['../classentt_1_1ContinuousLoader.html#a26ccd96f9ee4219ad7e3d1b8138ade37',1,'entt::ContinuousLoader::ContinuousLoader(Registry< entity_type > &registry) ENTT_NOEXCEPT'],['../classentt_1_1ContinuousLoader.html#a4d7cdac6b296eedb3dffd7ad0f182e3a',1,'entt::ContinuousLoader::ContinuousLoader(const ContinuousLoader &)=delete'],['../classentt_1_1ContinuousLoader.html#a4ba9abb1659a78f2ba4e12f86da68402',1,'entt::ContinuousLoader::ContinuousLoader(ContinuousLoader &&)=default']]], - ['create',['create',['../classentt_1_1Prototype.html#a434b43ae5f761093a0c9e74da0802523',1,'entt::Prototype::create(registry_type &other) const'],['../classentt_1_1Prototype.html#a5a659d7582d8fb52c5be59b0a319e2ec',1,'entt::Prototype::create() const'],['../classentt_1_1Registry.html#a433ac3fc8ea49347f691dd4ad1ccb58b',1,'entt::Registry::create()']]], - ['current',['current',['../classentt_1_1Registry.html#a9e79305f5a066bdc2b272181a08b17ac',1,'entt::Registry']]] + ['can_5fcast',['can_cast',['../classentt_1_1meta__any.html#a0df3dc5a414cbbade8f3738f68ca55e1',1,'entt::meta_any']]], + ['can_5fconvert',['can_convert',['../classentt_1_1meta__any.html#acfa712a0735f3f9596a2c9f9b96aa5b9',1,'entt::meta_any']]], + ['capacity',['capacity',['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#a9b52184cda174edc3555e05288ff9ebf',1,'entt::basic_group< Entity, get_t< Get... > >::capacity()'],['../classentt_1_1basic__registry.html#a90147848037f6661c2b7d28fb98dbd61',1,'entt::basic_registry::capacity() const ENTT_NOEXCEPT'],['../classentt_1_1basic__registry.html#abde8cee1ff1060eaebae6bef1e6c5e0e',1,'entt::basic_registry::capacity() const ENTT_NOEXCEPT'],['../classentt_1_1sparse__set.html#a30267005e552fce0d2a9b4e4d70d6656',1,'entt::sparse_set::capacity()']]], + ['cast',['cast',['../classentt_1_1meta__any.html#a160947a443eca2b61c5bf53f4cb8c6b4',1,'entt::meta_any::cast() const ENTT_NOEXCEPT'],['../classentt_1_1meta__any.html#a65793af4f215d84dd42e2d8da82a6057',1,'entt::meta_any::cast() ENTT_NOEXCEPT'],['../classentt_1_1meta__base.html#aa83c9d560b8b684d93f8df90830d6c56',1,'entt::meta_base::cast()']]], + ['cbegin',['cbegin',['../classentt_1_1basic__storage.html#aa5499c18eea80f3c903afef5031abf1b',1,'entt::basic_storage::cbegin()'],['../classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty__v_3_01Type_01_4_01_4_01_4.html#af1ea909d6d6a710a98b0e9c0673e5ca2',1,'entt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >::cbegin()']]], + ['cend',['cend',['../classentt_1_1basic__storage.html#a5fb9f5fd4996f424ab94b70f79b15205',1,'entt::basic_storage::cend()'],['../classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty__v_3_01Type_01_4_01_4_01_4.html#a99eb437d4d9d2a2c316787e6073da32f',1,'entt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >::cend()']]], + ['clear',['clear',['../classentt_1_1scheduler.html#a5a0f92dbe54b58751237a567e86805e0',1,'entt::scheduler::clear()'],['../classentt_1_1resource__cache.html#a2873906f1ee00b11980eadb6008da7ff',1,'entt::resource_cache::clear()'],['../classentt_1_1emitter.html#a09386e63b0871a304e295921c574318a',1,'entt::emitter::clear() ENTT_NOEXCEPT'],['../classentt_1_1emitter.html#acedafaefe2c9c91282c84e79aef26a35',1,'entt::emitter::clear() ENTT_NOEXCEPT']]], + ['clone',['clone',['../classentt_1_1basic__registry.html#aa5812babb6af95b8b524e59a5033c365',1,'entt::basic_registry']]], + ['collect',['collect',['../structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#a3341a4928e438e82eb070d3f9002b870',1,'entt::sigh< Ret(Args...), Collector >']]], + ['collector_5ftype',['collector_type',['../structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#aa1ed972f1fffb437a3b3c115fabe0532',1,'entt::sigh< Ret(Args...), Collector >']]], + ['component',['component',['../classentt_1_1basic__snapshot.html#a59cf70d5b7730d388f3a63845e8faede',1,'entt::basic_snapshot::component(Archive &archive) const'],['../classentt_1_1basic__snapshot.html#a05fff12a4af42f0ad77dc4893856772c',1,'entt::basic_snapshot::component(Archive &archive, It first, It last) const'],['../classentt_1_1basic__snapshot__loader.html#af7352e091c3421432cc2ef77010a0a2d',1,'entt::basic_snapshot_loader::component()'],['../classentt_1_1basic__continuous__loader.html#a315b55f7576992d9261ee812f202d5ad',1,'entt::basic_continuous_loader::component()']]], + ['component_5ftype',['component_type',['../classentt_1_1basic__registry.html#ace85f74fac787b967100f4186860f226',1,'entt::basic_registry']]], + ['connect',['connect',['../classentt_1_1delegate_3_01Ret_07Args_8_8_8_08_4.html#a6e732abcbc4aa9b8899c92d8f21e55a6',1,'entt::delegate< Ret(Args...)>::connect() ENTT_NOEXCEPT'],['../classentt_1_1delegate_3_01Ret_07Args_8_8_8_08_4.html#afcdce5ab5ae55520cce86f3f79b38e9c',1,'entt::delegate< Ret(Args...)>::connect(Type *value_or_instance) ENTT_NOEXCEPT'],['../classentt_1_1sink_3_01Ret_07Args_8_8_8_08_4.html#aa8bab262e4c9cfefe7610492cdfbdd2b',1,'entt::sink< Ret(Args...)>::connect()'],['../classentt_1_1sink_3_01Ret_07Args_8_8_8_08_4.html#af7a9d71f8798711264a9803e3e9864ac',1,'entt::sink< Ret(Args...)>::connect(Type *value_or_instance)'],['../namespaceentt.html#a3b009bb4a03a46a209dee068dc133b6b',1,'entt::connect()']]], + ['connect_5farg',['connect_arg',['../namespaceentt.html#af1e73acd6f3d892955819677dc2664b7',1,'entt']]], + ['connect_5farg_5ft',['connect_arg_t',['../structentt_1_1connect__arg__t.html',1,'entt']]], + ['connection',['connection',['../structentt_1_1emitter_1_1connection.html',1,'entt::emitter< Derived >::connection< Event >'],['../structentt_1_1emitter_1_1connection.html#a846b5190231aee4dd2340ab910adea40',1,'entt::emitter::connection::connection() ENTT_NOEXCEPT=default'],['../structentt_1_1emitter_1_1connection.html#a6497a7521b75836697bf4fb97de246d7',1,'entt::emitter::connection::connection(typename event_handler< Event >::connection_type conn)']]], + ['const_5fiterator_5ftype',['const_iterator_type',['../classentt_1_1basic__storage.html#aaa02d4db8defee92683bbc47b3eaa869',1,'entt::basic_storage']]], + ['construct',['construct',['../classentt_1_1sparse__set.html#a4f6d293b9bc7227de22c86722881083f',1,'entt::sparse_set::construct()'],['../classentt_1_1basic__storage.html#a4cf7d707b57b6dd63c4d7852a23b6f5e',1,'entt::basic_storage::construct()'],['../classentt_1_1meta__type.html#ad9c9a821b8047a5b48efadd2a045da2a',1,'entt::meta_type::construct()']]], + ['contains',['contains',['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#a16fc46d56939e5c5bab2685b870ff31d',1,'entt::basic_group< Entity, get_t< Get... > >::contains()'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html#a9b5fe414b78000832d52a7810c6aba82',1,'entt::basic_group< Entity, get_t< Get... >, Owned... >::contains()'],['../classentt_1_1basic__runtime__view.html#a3754c1d13392fc18daaf2003867a64fd',1,'entt::basic_runtime_view::contains()'],['../classentt_1_1basic__view.html#a8dc82a3867a4ae26e8e80b5abc2e2118',1,'entt::basic_view::contains()'],['../classentt_1_1basic__view_3_01Entity_00_01Component_01_4.html#a8dc82a3867a4ae26e8e80b5abc2e2118',1,'entt::basic_view< Entity, Component >::contains()'],['../classentt_1_1resource__cache.html#a21e2634bfd4412ed83ee9a024969f309',1,'entt::resource_cache::contains()']]], + ['continuous_5floader',['continuous_loader',['../namespaceentt.html#a37b5b489846f6f2a5d143db2b4aea5d0',1,'entt']]], + ['conv',['conv',['../classentt_1_1meta__factory.html#a84633b1bc2d531e2322997fd9a8f44dd',1,'entt::meta_factory::conv()'],['../classentt_1_1meta__type.html#a148df7974d347bc1b4c9cad9f30c51ef',1,'entt::meta_type::conv(Op op) const ENTT_NOEXCEPT'],['../classentt_1_1meta__type.html#ae6ea2662ab2d241577d0c1f51b7b97d0',1,'entt::meta_type::conv() const ENTT_NOEXCEPT']]], + ['convert',['convert',['../classentt_1_1meta__any.html#a3ad2f3a20951675fdeb5dccbed67e39c',1,'entt::meta_any::convert() const ENTT_NOEXCEPT'],['../classentt_1_1meta__any.html#a23180882087f7aab5835c7276e5f5a28',1,'entt::meta_any::convert() ENTT_NOEXCEPT'],['../classentt_1_1meta__conv.html#aa8acf7e218f317e9bb643d0a8d81b390',1,'entt::meta_conv::convert()']]], + ['create',['create',['../classentt_1_1basic__prototype.html#a6f96bf09702ed9b2d911c1d08ff5b0b1',1,'entt::basic_prototype::create(registry_type &other) const'],['../classentt_1_1basic__prototype.html#adb90842d165a76693de962f2cb7444e4',1,'entt::basic_prototype::create() const'],['../classentt_1_1basic__registry.html#a1bb5d5d0c5af3bd98de3d902406ff372',1,'entt::basic_registry::create()'],['../classentt_1_1basic__registry.html#a3dc6b7ace48533c41cf0fb28a4b0a36c',1,'entt::basic_registry::create(It first, It last)']]], + ['ctor',['ctor',['../classentt_1_1meta__factory.html#a452a2b2df406361785ec40c2e2f9a426',1,'entt::meta_factory::ctor(Property &&... property) ENTT_NOEXCEPT'],['../classentt_1_1meta__factory.html#a452a2b2df406361785ec40c2e2f9a426',1,'entt::meta_factory::ctor(Property &&... property) ENTT_NOEXCEPT'],['../classentt_1_1meta__type.html#a527e242b24025efb218a7936bb82955e',1,'entt::meta_type::ctor(Op op) const ENTT_NOEXCEPT'],['../classentt_1_1meta__type.html#a19e66bc8271fac7f72413c09922fbc32',1,'entt::meta_type::ctor() const ENTT_NOEXCEPT']]], + ['ctx',['ctx',['../classentt_1_1basic__registry.html#ac53dddfa495bb678debd98ecc2720e6d',1,'entt::basic_registry::ctx() const ENTT_NOEXCEPT'],['../classentt_1_1basic__registry.html#af887e7939d4b09c4634bcb24e817170b',1,'entt::basic_registry::ctx() ENTT_NOEXCEPT']]], + ['current',['current',['../classentt_1_1basic__registry.html#ad3e60af648b0b602527dbb6ea17e95c4',1,'entt::basic_registry']]] ]; diff --git a/search/all_3.js b/search/all_3.js index fe713b257..b855a0f35 100644 --- a/search/all_3.js +++ b/search/all_3.js @@ -1,19 +1,16 @@ var searchData= [ - ['data',['data',['../classentt_1_1Registry.html#a2bb7899d022c90b2385cad18a31e48dd',1,'entt::Registry::data()'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a3da83139d2ef41982399948a94383c0b',1,'entt::SparseSet< Entity >::data()'],['../classentt_1_1PersistentView.html#ae3e2d20cb89f810542c0ec4fe4537176',1,'entt::PersistentView::data()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a7b1ac1bc68c41fb4007ad5c47ed754a0',1,'entt::View< Entity, Component >::data()'],['../classentt_1_1RawView.html#a27edc55b8d2d18f75118b3b1e68ff270',1,'entt::RawView::data()']]], - ['dead',['dead',['../classentt_1_1Process.html#a08265296592bcc0e5a6632b7067329b9',1,'entt::Process']]], - ['defaultactor',['DefaultActor',['../namespaceentt.html#a0790fdd772249d8b22f1cf2d5e2403d4',1,'entt']]], - ['defaultprototype',['DefaultPrototype',['../namespaceentt.html#a94d8a4552b7bd5a3543c2ffc6eaf878c',1,'entt']]], - ['defaultregistry',['DefaultRegistry',['../namespaceentt.html#aa56ef01a9c62f21d68dd60f005296b23',1,'entt']]], - ['delegate',['Delegate',['../classentt_1_1Delegate.html',1,'entt::Delegate< typename >'],['../classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html#a57a011f4b42c3358ee5219f63997e00b',1,'entt::Delegate< Ret(Args...)>::Delegate()']]], - ['delegate_3c_20ret_28args_2e_2e_2e_29_3e',['Delegate< Ret(Args...)>',['../classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html',1,'entt']]], - ['delta_5ftype',['delta_type',['../classentt_1_1Process.html#aaa304f69a0344fffd3a53daa922284ad',1,'entt::Process']]], - ['dependency',['dependency',['../namespaceentt.html#ab9d53b0eb1c6fb4d7636d4ab451b615d',1,'entt']]], - ['destroy',['destroy',['../classentt_1_1Attachee_3_01Entity_01_4.html#ab3e8fbcf3f0d55bf4c907fb3178bad51',1,'entt::Attachee< Entity >::destroy()'],['../classentt_1_1Attachee_3_01Entity_00_01Type_01_4.html#a5c45bacb7159e042c065300ccf4660a7',1,'entt::Attachee< Entity, Type >::destroy()'],['../classentt_1_1Registry.html#a140dfdb699d360b7c0e066ae298aab5e',1,'entt::Registry::destroy(tag_t)'],['../classentt_1_1Registry.html#a197afcc6da68df6eb87575284232a3ff',1,'entt::Registry::destroy(const entity_type entity)'],['../classentt_1_1Registry.html#a8169422afda942f5915ee68b46636c3b',1,'entt::Registry::destroy(Type...)'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a7bd15b00eb2ce0e52d3d957673b4dd97',1,'entt::SparseSet< Entity >::destroy()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#ae763b848ccde63e554f5b3f04b9dcdea',1,'entt::SparseSet< Entity, Type >::destroy()']]], - ['destroyed',['destroyed',['../classentt_1_1Snapshot.html#ac7d571f0901df2476451e2fd26d9dab9',1,'entt::Snapshot::destroyed()'],['../classentt_1_1SnapshotLoader.html#a094ec796643b2c7422533c24e80963f3',1,'entt::SnapshotLoader::destroyed()'],['../classentt_1_1ContinuousLoader.html#a8aa96c02f3fa734078b4e77198665c91',1,'entt::ContinuousLoader::destroyed()']]], - ['destruction',['destruction',['../classentt_1_1Registry.html#a89df80b61b83bc3c4c3ed6d9324aa8b4',1,'entt::Registry::destruction(tag_t) ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#aaa38dca5bb6875370d50a923cf52fcfb',1,'entt::Registry::destruction() ENTT_NOEXCEPT']]], + ['data',['data',['../classentt_1_1hashed__string.html#af8136c35e3f7ec352f9d09f0762ea8cb',1,'entt::hashed_string::data()'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#a333424a68d4267a0302df6dcb5e39e81',1,'entt::basic_group< Entity, get_t< Get... > >::data() const ENTT_NOEXCEPT'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#a320e6da3f841cf798d981d6b1fcad117',1,'entt::basic_group< Entity, get_t< Get... > >::data() const ENTT_NOEXCEPT'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html#aa62e833b539039982a99b7326f9b3139',1,'entt::basic_group< Entity, get_t< Get... >, Owned... >::data() const ENTT_NOEXCEPT'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html#a2df6e5b81f1aa1d839c645dec19fc7ad',1,'entt::basic_group< Entity, get_t< Get... >, Owned... >::data() const ENTT_NOEXCEPT'],['../classentt_1_1basic__registry.html#a79d6af03e34feae7123b924b50a91ca9',1,'entt::basic_registry::data()'],['../classentt_1_1sparse__set.html#a2eafe4975271769b08fe7f7d4924992f',1,'entt::sparse_set::data()'],['../classentt_1_1basic__view.html#ac2122c6c128744f4617fab34dca651c3',1,'entt::basic_view::data()'],['../classentt_1_1basic__view_3_01Entity_00_01Component_01_4.html#a3a612381efadb0c6d68b43965e6d1149',1,'entt::basic_view< Entity, Component >::data()'],['../classentt_1_1meta__factory.html#a02634a64ff7fe7c644691d495e9ccc18',1,'entt::meta_factory::data(const char *str, Property &&... property) ENTT_NOEXCEPT'],['../classentt_1_1meta__factory.html#a1226d202290aaff53c14db38bd505a2b',1,'entt::meta_factory::data(const char *str, Property &&... property) ENTT_NOEXCEPT'],['../classentt_1_1meta__any.html#a427ee14f12077f8634919fa5c501f93a',1,'entt::meta_any::data() const ENTT_NOEXCEPT'],['../classentt_1_1meta__any.html#a2726c037b90fef702cc90eb54e741b49',1,'entt::meta_any::data() ENTT_NOEXCEPT'],['../classentt_1_1meta__handle.html#a07e72402cf9163c50472b201f9c130d5',1,'entt::meta_handle::data() const ENTT_NOEXCEPT'],['../classentt_1_1meta__handle.html#a3f9f079820d1bcd1d987e6c2c91a733f',1,'entt::meta_handle::data() ENTT_NOEXCEPT'],['../classentt_1_1meta__type.html#af0f837a5bf6e4edbe9f4c15b19114506',1,'entt::meta_type::data(Op op) const ENTT_NOEXCEPT'],['../classentt_1_1meta__type.html#aa1d24de2069a1578de40237774c03d97',1,'entt::meta_type::data(const char *str) const ENTT_NOEXCEPT']]], + ['dead',['dead',['../classentt_1_1process.html#ad83f2550ca63e03af126a07e4ae5d9dd',1,'entt::process']]], + ['delegate',['delegate',['../classentt_1_1delegate.html',1,'entt::delegate< typename >'],['../classentt_1_1delegate_3_01Ret_07Args_8_8_8_08_4.html#a5c4828a5df5ed1e8fd18465ff63eb73c',1,'entt::delegate< Ret(Args...)>::delegate() ENTT_NOEXCEPT'],['../classentt_1_1delegate_3_01Ret_07Args_8_8_8_08_4.html#ad07c76f552619d55edc17a3722958215',1,'entt::delegate< Ret(Args...)>::delegate(connect_arg_t< Function >) ENTT_NOEXCEPT'],['../classentt_1_1delegate_3_01Ret_07Args_8_8_8_08_4.html#a3c3391085b16cba9024b4bbb372f7326',1,'entt::delegate< Ret(Args...)>::delegate(connect_arg_t< Candidate >, Type *value_or_instance) ENTT_NOEXCEPT'],['../namespaceentt.html#aeda304d14f286ffcb1d872a6ef526745',1,'entt::delegate(connect_arg_t< Function >) ENTT_NOEXCEPT -> delegate< std::remove_pointer_t< decltype(internal::to_function_pointer(Function))>>'],['../namespaceentt.html#a7e9e79b197bfa9e04868fdff9939931e',1,'entt::delegate(connect_arg_t< Candidate >, Type *) ENTT_NOEXCEPT -> delegate< std::remove_pointer_t< decltype(internal::to_function_pointer(Candidate, std::declval< Type *>()))>>']]], + ['delegate_3c_20ret_28args_2e_2e_2e_29_3e',['delegate< Ret(Args...)>',['../classentt_1_1delegate_3_01Ret_07Args_8_8_8_08_4.html',1,'entt']]], + ['delta_5ftype',['delta_type',['../classentt_1_1process.html#a625b574ea6d83e3a4933acc3d0279295',1,'entt::process']]], + ['dependency',['dependency',['../namespaceentt.html#aab5117f888340d500280c50f424d228c',1,'entt']]], + ['destroy',['destroy',['../classentt_1_1basic__registry.html#af58f3add442cfb3f1fa470402db072bd',1,'entt::basic_registry::destroy(const entity_type entity)'],['../classentt_1_1basic__registry.html#a6c163dcc335da90e727e2f40e67973b7',1,'entt::basic_registry::destroy(It first, It last)'],['../classentt_1_1sparse__set.html#aedf563d410f1288b175b2d67522b5bb5',1,'entt::sparse_set::destroy()'],['../classentt_1_1basic__storage.html#a66169e7a351a3dadb00bfb53141ade5b',1,'entt::basic_storage::destroy()'],['../classentt_1_1meta__type.html#ad91cc02c03b339a9917d5d65305c29b2',1,'entt::meta_type::destroy()']]], + ['destroyed',['destroyed',['../classentt_1_1basic__snapshot.html#a7a26ec6a9bc937a7d71b1a4723bdf4c7',1,'entt::basic_snapshot::destroyed()'],['../classentt_1_1basic__snapshot__loader.html#a49128534d0d232dd4c380513dca345c0',1,'entt::basic_snapshot_loader::destroyed()'],['../classentt_1_1basic__continuous__loader.html#a368a3a5f63c99637ee456668dab1ef36',1,'entt::basic_continuous_loader::destroyed()']]], ['difference_5ftype',['difference_type',['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#ac16a602de26d43d316b497cb11b7c6b2',1,'entt::entt_traits< std::uint16_t >::difference_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#a9809b457e16f4a071a91530b23c930d6',1,'entt::entt_traits< std::uint32_t >::difference_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#afba2f77f80b0bf89a208f6876ab67271',1,'entt::entt_traits< std::uint64_t >::difference_type()']]], - ['discard',['discard',['../classentt_1_1Registry.html#a9289a7c5d8bed1ba59948311f8fcd3f4',1,'entt::Registry::discard()'],['../classentt_1_1ResourceCache.html#a771ee2c8c203eb018731e7914afbe5fa',1,'entt::ResourceCache::discard()']]], - ['disconnect',['disconnect',['../classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html#a3ecbd44accc33e5eb2d9e1920c347f5a',1,'entt::Sink< Ret(Args...)>::disconnect()'],['../classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html#a4c3eb2a296d7e99fd09b9e81ddab9777',1,'entt::Sink< Ret(Args...)>::disconnect(Class *instance)'],['../classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html#a4c3eb2a296d7e99fd09b9e81ddab9777',1,'entt::Sink< Ret(Args...)>::disconnect(Class *instance)'],['../classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html#aa7ba0d3b192499927ac7714bc04d10f8',1,'entt::Sink< Ret(Args...)>::disconnect(Class *instance)'],['../classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html#af537cc1833d4c5dbc5216f7c70440539',1,'entt::Sink< Ret(Args...)>::disconnect()'],['../namespaceentt.html#a8232dd7b7bfb15a663db6dc55e502eb2',1,'entt::disconnect()']]], - ['dispatcher',['Dispatcher',['../classentt_1_1Dispatcher.html',1,'entt']]] + ['discard',['discard',['../classentt_1_1resource__cache.html#a59355414c1a727ff347763734e569068',1,'entt::resource_cache']]], + ['disconnect',['disconnect',['../classentt_1_1sink_3_01Ret_07Args_8_8_8_08_4.html#ab0186e5614c746b3355119a8f1abc9d1',1,'entt::sink< Ret(Args...)>::disconnect()'],['../classentt_1_1sink_3_01Ret_07Args_8_8_8_08_4.html#a3ea78f6a9f675a922995f4897b74d9ef',1,'entt::sink< Ret(Args...)>::disconnect(Class *instance)'],['../classentt_1_1sink_3_01Ret_07Args_8_8_8_08_4.html#a1f9b66d606a004485f535997c96c231a',1,'entt::sink< Ret(Args...)>::disconnect()'],['../namespaceentt.html#a71889edeeb1f03ecc2b47d183465384c',1,'entt::disconnect()']]], + ['dispatcher',['dispatcher',['../classentt_1_1dispatcher.html',1,'entt']]], + ['dtor',['dtor',['../classentt_1_1meta__factory.html#ac0166de72ef9397be042ab7ad9087b0f',1,'entt::meta_factory::dtor()'],['../classentt_1_1meta__type.html#a0f36a3011bce598684c673a2e7734163',1,'entt::meta_type::dtor()']]] ]; diff --git a/search/all_4.js b/search/all_4.js index f3ecead80..db883f6ca 100644 --- a/search/all_4.js +++ b/search/all_4.js @@ -1,21 +1,23 @@ var searchData= [ - ['entt_20and_20shared_20libraries',['EnTT and shared libraries',['../autotoc_md52.html',1,'']]], - ['each',['each',['../classentt_1_1Registry.html#a1d7547f6d8503265480d235fe48dfb1d',1,'entt::Registry::each()'],['../classentt_1_1PersistentView.html#abaf27560862f9b514695e61fa6a8c6e6',1,'entt::PersistentView::each(Func func) const'],['../classentt_1_1PersistentView.html#aa71f689a8ac192907617a4316492f03c',1,'entt::PersistentView::each(Func func)'],['../classentt_1_1View.html#a85eea1ef9655368de8da355019fbeaa0',1,'entt::View::each(Func func) const'],['../classentt_1_1View.html#a6c540ac6937e6e9cf931cccaabcec745',1,'entt::View::each(Func func)'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a85eea1ef9655368de8da355019fbeaa0',1,'entt::View< Entity, Component >::each(Func func) const'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a6c540ac6937e6e9cf931cccaabcec745',1,'entt::View< Entity, Component >::each(Func func)'],['../classentt_1_1RawView.html#a2f88d86e1ad74bb558df47e7507612b1',1,'entt::RawView::each(Func func) const'],['../classentt_1_1RawView.html#ad54a334bfbd407df75b93e428117d598',1,'entt::RawView::each(Func func)'],['../classentt_1_1RuntimeView.html#aa67ccd106835ddc0cc8c10bbdbcdd4e4',1,'entt::RuntimeView::each()']]], - ['emitter',['Emitter',['../classentt_1_1Emitter.html',1,'entt::Emitter< Derived >'],['../structentt_1_1Emitter_1_1Connection.html#a1cad71ec309b8c8b0beee324b9b65e5a',1,'entt::Emitter::Connection::Emitter()'],['../classentt_1_1Emitter.html#a69aedf4db58a11af9eb6c36859e951c8',1,'entt::Emitter::Emitter() ENTT_NOEXCEPT=default'],['../classentt_1_1Emitter.html#ab4ee1e31a476217c9c8c5a9b9dfe856b',1,'entt::Emitter::Emitter(const Emitter &)=delete'],['../classentt_1_1Emitter.html#aef84a369260e86a006c151ab4a9041a8',1,'entt::Emitter::Emitter(Emitter &&)=default']]], - ['empty',['empty',['../classentt_1_1Registry.html#a57193f01b75256867ba34342cd46ec13',1,'entt::Registry::empty() const ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a8735df0baab2fea088e6946e2811e29b',1,'entt::Registry::empty() const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a62f5ebeb316c3d52877c6eca45c652ce',1,'entt::SparseSet< Entity >::empty()'],['../classentt_1_1PersistentView.html#a25cf198e023b229190aa6d62852f4d10',1,'entt::PersistentView::empty()'],['../classentt_1_1View.html#aee65a80863abccbe3117e60b22695dc4',1,'entt::View::empty()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#aee65a80863abccbe3117e60b22695dc4',1,'entt::View< Entity, Component >::empty()'],['../classentt_1_1RawView.html#abf0001549a9555166c532405bd3b647d',1,'entt::RawView::empty()'],['../classentt_1_1RuntimeView.html#ab08f06a99381e857657b2875e23c90a4',1,'entt::RuntimeView::empty()'],['../structentt_1_1ServiceLocator.html#afb0038914d828b6b3483484cc906ec44',1,'entt::ServiceLocator::empty()'],['../classentt_1_1Scheduler.html#aba0da7c946d76561a8694ecf7c5b29e3',1,'entt::Scheduler::empty()'],['../classentt_1_1ResourceCache.html#a03f2f3c02e84ec7f5825fe415c3f1cdb',1,'entt::ResourceCache::empty()'],['../classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html#ab776848ee5ece9b92740d8a2ad0b84a8',1,'entt::Delegate< Ret(Args...)>::empty()'],['../classentt_1_1Emitter.html#a4c54c5f15827be561e2912f7e91d1a6f',1,'entt::Emitter::empty() const ENTT_NOEXCEPT'],['../classentt_1_1Emitter.html#a733f11dc3c15aa910e3f2e6f167b62fd',1,'entt::Emitter::empty() const ENTT_NOEXCEPT'],['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#a6b35b22faefe41acd8c1426a1bdcd149',1,'entt::SigH< Ret(Args...), Collector >::empty()']]], - ['end',['end',['../classentt_1_1SparseSet_3_01Entity_01_4.html#a956957bcafba7391d1008110596d5714',1,'entt::SparseSet< Entity >::end() const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a14720d48f6d553a06813379ee6d7092f',1,'entt::SparseSet< Entity >::end() ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#aa04fe0d91fc40c8982cdfada8664e9b1',1,'entt::SparseSet< Entity, Type >::end() const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a43b4c3d129ab2b6559154f8db037bfd5',1,'entt::SparseSet< Entity, Type >::end() ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#a0e614f77f05085e951e761d8ca967a84',1,'entt::PersistentView::end() const ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#a470ef6edb944f127e26f7e3398cbded1',1,'entt::PersistentView::end() ENTT_NOEXCEPT'],['../classentt_1_1View.html#af0cbc67f83e47cb4cbb3a1a26d7cd263',1,'entt::View::end() const ENTT_NOEXCEPT'],['../classentt_1_1View.html#a34bca7c2c996fe26e150c0a7a2dbb69d',1,'entt::View::end() ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#af0cbc67f83e47cb4cbb3a1a26d7cd263',1,'entt::View< Entity, Component >::end() const ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a34bca7c2c996fe26e150c0a7a2dbb69d',1,'entt::View< Entity, Component >::end() ENTT_NOEXCEPT'],['../classentt_1_1RawView.html#ad7ad0559b9b4a440813e1752b0814bb4',1,'entt::RawView::end() const ENTT_NOEXCEPT'],['../classentt_1_1RawView.html#a8ebfe24e5a5e428b429f470755d0a1f7',1,'entt::RawView::end() ENTT_NOEXCEPT'],['../classentt_1_1RuntimeView.html#af8040215c3db60033388328ddff9a5d8',1,'entt::RuntimeView::end() const ENTT_NOEXCEPT'],['../classentt_1_1RuntimeView.html#afc2af975c32c247e0c333d4e49c0208c',1,'entt::RuntimeView::end() ENTT_NOEXCEPT']]], - ['enqueue',['enqueue',['../classentt_1_1Dispatcher.html#a431743aa289ce022f7ee87cd7fb3eedf',1,'entt::Dispatcher']]], - ['entities',['entities',['../classentt_1_1Snapshot.html#aa77d63e06c40969adca662fca3a2ca08',1,'entt::Snapshot::entities()'],['../classentt_1_1SnapshotLoader.html#a7bff030b50995a78f79217eecfb90535',1,'entt::SnapshotLoader::entities()'],['../classentt_1_1ContinuousLoader.html#a26eadd32f719c24de2305347a5066197',1,'entt::ContinuousLoader::entities()']]], - ['entity',['entity',['../structentt_1_1Actor.html#afb70b6f30071680efab23715a7e61a29',1,'entt::Actor::entity()'],['../classentt_1_1Registry.html#a43374c03910bf8b7337992d1bcc88e30',1,'entt::Registry::entity()']]], + ['entt_20in_20action',['EnTT in Action',['../autotoc_md57.html',1,'']]], + ['each',['each',['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#a3c29b484e3e0841ef87f52f5bc5e8141',1,'entt::basic_group< Entity, get_t< Get... > >::each()'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html#ab8c9dbf314b88997966995dda17178ca',1,'entt::basic_group< Entity, get_t< Get... >, Owned... >::each()'],['../classentt_1_1basic__registry.html#a86d2b035f54225d82548e8f03de28754',1,'entt::basic_registry::each()'],['../classentt_1_1basic__runtime__view.html#a79fe059a28f768f4dc82edf48438cce0',1,'entt::basic_runtime_view::each()'],['../classentt_1_1basic__view.html#a1019208022f9a4a35ade26f3f35c097f',1,'entt::basic_view::each(Func func) const'],['../classentt_1_1basic__view.html#aa8d3d77cb491ea84ebac40017780c96f',1,'entt::basic_view::each(Func func) const'],['../classentt_1_1basic__view_3_01Entity_00_01Component_01_4.html#a1019208022f9a4a35ade26f3f35c097f',1,'entt::basic_view< Entity, Component >::each()']]], + ['emitter',['emitter',['../classentt_1_1emitter.html',1,'entt::emitter< Derived >'],['../structentt_1_1emitter_1_1connection.html#a0f3bb10ad57dc0e06298fc9ba38a7bd9',1,'entt::emitter::connection::emitter()'],['../classentt_1_1emitter.html#a9c2e7d7eb8accd1d71e8aacce404e4d9',1,'entt::emitter::emitter() ENTT_NOEXCEPT=default'],['../classentt_1_1emitter.html#a842fef69b914a160b0bcc211bb77b27b',1,'entt::emitter::emitter(emitter &&)=default']]], + ['empty',['empty',['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#a7d52210fbf901c8f2087a51e583b6699',1,'entt::basic_group< Entity, get_t< Get... > >::empty() const ENTT_NOEXCEPT'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#a1e9bf2f22c9b2b8f60fd55afc1f65af0',1,'entt::basic_group< Entity, get_t< Get... > >::empty() const ENTT_NOEXCEPT'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html#a35a1a8d1a7ae00497bdc3367078408b5',1,'entt::basic_group< Entity, get_t< Get... >, Owned... >::empty() const ENTT_NOEXCEPT'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html#a9d999f38f6de0804c8e06d3637d56d5a',1,'entt::basic_group< Entity, get_t< Get... >, Owned... >::empty() const ENTT_NOEXCEPT'],['../classentt_1_1basic__registry.html#af78aafdf9439c8535a2652b258a3720b',1,'entt::basic_registry::empty() const ENTT_NOEXCEPT'],['../classentt_1_1basic__registry.html#a980aa529b3be187c4403730efc6479c0',1,'entt::basic_registry::empty() const ENTT_NOEXCEPT'],['../classentt_1_1basic__runtime__view.html#a2483047bb494ac1bea3b1823bec87985',1,'entt::basic_runtime_view::empty()'],['../classentt_1_1sparse__set.html#ae1a16cb354a9ed5ded92b6edcddce15e',1,'entt::sparse_set::empty()'],['../classentt_1_1basic__view.html#a9d19f70eda47e20c8c6d97b7f2c05f11',1,'entt::basic_view::empty() const ENTT_NOEXCEPT'],['../classentt_1_1basic__view.html#af7916ac310c1ec40c3cb5426d74d641d',1,'entt::basic_view::empty() const ENTT_NOEXCEPT'],['../classentt_1_1basic__view_3_01Entity_00_01Component_01_4.html#af7916ac310c1ec40c3cb5426d74d641d',1,'entt::basic_view< Entity, Component >::empty()'],['../structentt_1_1service__locator.html#a9265b7273a758003283a79f7a4de6250',1,'entt::service_locator::empty()'],['../classentt_1_1scheduler.html#a817d93653aec6a479b920143bd21edbb',1,'entt::scheduler::empty()'],['../classentt_1_1resource__cache.html#a3a192adacbb198fe09b2c2a473d433d8',1,'entt::resource_cache::empty()'],['../classentt_1_1emitter.html#a841edafebf32b85da11657578e887961',1,'entt::emitter::empty() const ENTT_NOEXCEPT'],['../classentt_1_1emitter.html#afbac9d6fb49c28f06cb382715ed92ab9',1,'entt::emitter::empty() const ENTT_NOEXCEPT'],['../classentt_1_1sink_3_01Ret_07Args_8_8_8_08_4.html#a07679954660265dfbcffa34a25a6033f',1,'entt::sink< Ret(Args...)>::empty()'],['../structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#a52a4f9b5e9a6ba18cdbd8c05ce9d0005',1,'entt::sigh< Ret(Args...), Collector >::empty()']]], + ['end',['end',['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#a74f539ec1945cb261a172bf014019d5b',1,'entt::basic_group< Entity, get_t< Get... > >::end()'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html#ae9ba261769c3ffaef0b173fae8f46143',1,'entt::basic_group< Entity, get_t< Get... >, Owned... >::end()'],['../classentt_1_1basic__runtime__view.html#a777a70d6c1905a32b8a68b0b87cc9b85',1,'entt::basic_runtime_view::end()'],['../classentt_1_1sparse__set.html#a69d6c1288f673c6f92d2b1b028d6aa75',1,'entt::sparse_set::end()'],['../classentt_1_1basic__storage.html#a43640288a074495b549779ad271d7010',1,'entt::basic_storage::end() const ENTT_NOEXCEPT'],['../classentt_1_1basic__storage.html#a9922f88c0ed8f587ff4ae09745f67ae9',1,'entt::basic_storage::end() ENTT_NOEXCEPT'],['../classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty__v_3_01Type_01_4_01_4_01_4.html#aa56ba13f8c81dd153417fd0054e23a0b',1,'entt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >::end()'],['../classentt_1_1basic__view.html#a1c17f8511d0e12087fbdd3b9b5cc9e4a',1,'entt::basic_view::end()'],['../classentt_1_1basic__view_3_01Entity_00_01Component_01_4.html#a1c17f8511d0e12087fbdd3b9b5cc9e4a',1,'entt::basic_view< Entity, Component >::end()']]], + ['enqueue',['enqueue',['../classentt_1_1dispatcher.html#ab41d56a73b6bdc64f0862abd333ea701',1,'entt::dispatcher::enqueue(Args &&... args)'],['../classentt_1_1dispatcher.html#a1e0a488354698cbf3cba82396ac4b76e',1,'entt::dispatcher::enqueue(Event &&event)']]], + ['entities',['entities',['../classentt_1_1basic__snapshot.html#a79fe1641f3b448b37b8aecfcabf52a5e',1,'entt::basic_snapshot::entities()'],['../classentt_1_1basic__snapshot__loader.html#a0ee608c24b47e2f54a1224177a0dc741',1,'entt::basic_snapshot_loader::entities()'],['../classentt_1_1basic__continuous__loader.html#ae6655c1c6868b11f2781cec2aee77abb',1,'entt::basic_continuous_loader::entities()']]], + ['entity',['entity',['../structentt_1_1basic__actor.html#af92d62c39e122692addbfd6b75ea6922',1,'entt::basic_actor::entity()'],['../classentt_1_1basic__registry.html#a5d07b2e0105da47d25ceef530d91bb8b',1,'entt::basic_registry::entity()'],['../namespaceentt.html#ad777a7dd756427c5ee570d7c0543d339',1,'entt::entity()']]], ['entity_5fmask',['entity_mask',['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#a3b85bff62534fc16597a391161fdc884',1,'entt::entt_traits< std::uint16_t >::entity_mask()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#a10edcf27d0e80e58102f41372d4b8df8',1,'entt::entt_traits< std::uint32_t >::entity_mask()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#a1127933a9ef4bfa4f64ded191b4342dd',1,'entt::entt_traits< std::uint64_t >::entity_mask()']]], ['entity_5fshift',['entity_shift',['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#aedc1e30160a37f69a5e6cc903a5113cc',1,'entt::entt_traits< std::uint16_t >::entity_shift()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#ad2fb05bba66c9426a4c239222a191650',1,'entt::entt_traits< std::uint32_t >::entity_shift()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#abbf9ff9ddaf2cb92eec8bd08dcc7d5a7',1,'entt::entt_traits< std::uint64_t >::entity_shift()']]], - ['entity_5ftype',['entity_type',['../structentt_1_1Actor.html#a809cbe96d54fe86b470246a34e873a4e',1,'entt::Actor::entity_type()'],['../classentt_1_1Attachee_3_01Entity_01_4.html#ab29a9628056147ed6eec373a1d0e6b32',1,'entt::Attachee< Entity >::entity_type()'],['../classentt_1_1Attachee_3_01Entity_00_01Type_01_4.html#ae2bc6eb2a7828941bab842f3dd4d4247',1,'entt::Attachee< Entity, Type >::entity_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#a86e202c8932f341626b29c194bd47489',1,'entt::entt_traits< std::uint16_t >::entity_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#aecde3ac9bfc28e7f0f880a74ee2c5d8f',1,'entt::entt_traits< std::uint32_t >::entity_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#a304eb4dc4a1487cf2966d902214f7185',1,'entt::entt_traits< std::uint64_t >::entity_type()'],['../classentt_1_1Prototype.html#ab4542df6834170b6f0d96828d094269d',1,'entt::Prototype::entity_type()'],['../classentt_1_1Registry.html#ad434a1920dd2c6a9a31ab482e2f29038',1,'entt::Registry::entity_type()'],['../classentt_1_1ContinuousLoader.html#ae2ddecfaeb16ddbf340b6ca643036c6f',1,'entt::ContinuousLoader::entity_type()'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a7d36e852257a965a9a0ed3fb636433e2',1,'entt::SparseSet< Entity >::entity_type()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#afe382e2d5c8769fb3d924e1a357cf9b0',1,'entt::SparseSet< Entity, Type >::entity_type()'],['../classentt_1_1PersistentView.html#a5195c9d1dede0fe6c40bea576398022b',1,'entt::PersistentView::entity_type()'],['../classentt_1_1View.html#a61be0e712de89d1eb275e14bbc59174e',1,'entt::View::entity_type()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a75fc64bf381a3003d8acf03ed66728f2',1,'entt::View< Entity, Component >::entity_type()'],['../classentt_1_1RawView.html#a544ee87b4a856cfa5c49ea4581c85a35',1,'entt::RawView::entity_type()'],['../classentt_1_1RuntimeView.html#ad5b5d664d388179dc164814e6268a774',1,'entt::RuntimeView::entity_type()']]], + ['entity_5ftype',['entity_type',['../structentt_1_1basic__actor.html#a2c2e10f12014f5269be0b9ab055acfca',1,'entt::basic_actor::entity_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#a86e202c8932f341626b29c194bd47489',1,'entt::entt_traits< std::uint16_t >::entity_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#aecde3ac9bfc28e7f0f880a74ee2c5d8f',1,'entt::entt_traits< std::uint32_t >::entity_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#a304eb4dc4a1487cf2966d902214f7185',1,'entt::entt_traits< std::uint64_t >::entity_type()'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#a6e655df47eca24e9f0885f1114eac566',1,'entt::basic_group< Entity, get_t< Get... > >::entity_type()'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html#a364afe2787baf1f17fe4a8af294356b2',1,'entt::basic_group< Entity, get_t< Get... >, Owned... >::entity_type()'],['../classentt_1_1basic__prototype.html#a0a8606dc36496d42f6188acdad4906f3',1,'entt::basic_prototype::entity_type()'],['../classentt_1_1basic__registry.html#a86f7d4defe404257da3be0e94cc3b6fd',1,'entt::basic_registry::entity_type()'],['../classentt_1_1basic__runtime__view.html#a8347b5b209e9dd8962c7b98c3314bae6',1,'entt::basic_runtime_view::entity_type()'],['../classentt_1_1basic__continuous__loader.html#a90a0d33147978cb3c142408487428277',1,'entt::basic_continuous_loader::entity_type()'],['../classentt_1_1sparse__set.html#a9a1dbe5ab2dbb098beae0bff56bbf780',1,'entt::sparse_set::entity_type()'],['../classentt_1_1basic__storage.html#ab2520abd2591d114866414f275cbdaa7',1,'entt::basic_storage::entity_type()'],['../classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty__v_3_01Type_01_4_01_4_01_4.html#adcf45b53722e877c6c8b92e87ecc7824',1,'entt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >::entity_type()'],['../classentt_1_1basic__view.html#a4d733f92580b2623300174292e47c7cf',1,'entt::basic_view::entity_type()'],['../classentt_1_1basic__view_3_01Entity_00_01Component_01_4.html#aecda0b0101603b9342248086dcb71ec5',1,'entt::basic_view< Entity, Component >::entity_type()']]], ['entt',['entt',['../namespaceentt.html',1,'']]], ['entt_5ftraits',['entt_traits',['../structentt_1_1entt__traits.html',1,'entt']]], ['entt_5ftraits_3c_20std_3a_3auint16_5ft_20_3e',['entt_traits< std::uint16_t >',['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html',1,'entt']]], ['entt_5ftraits_3c_20std_3a_3auint32_5ft_20_3e',['entt_traits< std::uint32_t >',['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html',1,'entt']]], ['entt_5ftraits_3c_20std_3a_3auint64_5ft_20_3e',['entt_traits< std::uint64_t >',['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html',1,'entt']]], - ['erase',['erase',['../classentt_1_1Emitter.html#ab15f07d10744ce8aa74964fa5623375c',1,'entt::Emitter']]], - ['extent',['extent',['../classentt_1_1SparseSet_3_01Entity_01_4.html#ab314d3642b6a5b90bbcb170ba83b7978',1,'entt::SparseSet< Entity >']]] + ['erase',['erase',['../classentt_1_1emitter.html#a14409e5061892c1342924b25f4ec2a0c',1,'entt::emitter']]], + ['exclude',['exclude',['../namespaceentt.html#a5b73210cef43c4db35ef8ce477cc38a6',1,'entt']]], + ['exclude_5ft',['exclude_t',['../structentt_1_1exclude__t.html',1,'entt']]], + ['extent',['extent',['../classentt_1_1sparse__set.html#af79345df59154e5ea9e58b7efa7ff8f0',1,'entt::sparse_set::extent()'],['../classentt_1_1meta__type.html#a4eadf479b9b7f11879a24e0e76d5cd51',1,'entt::meta_type::extent()']]] ]; diff --git a/search/all_5.js b/search/all_5.js index a2a448ce0..e2edd0fac 100644 --- a/search/all_5.js +++ b/search/all_5.js @@ -1,7 +1,10 @@ var searchData= [ - ['fail',['fail',['../classentt_1_1Process.html#aa46a0784a199e1044c50e8aa34eea1bb',1,'entt::Process']]], - ['family',['Family',['../classentt_1_1Family.html',1,'entt']]], - ['family_5ftype',['family_type',['../classentt_1_1Family.html#a263330fe09b437d3d91b8769f6a9fc77',1,'entt::Family']]], - ['fast',['fast',['../classentt_1_1Registry.html#a76bf9ca50a3651d3c0c32df0627d8270',1,'entt::Registry::fast()'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#aa76df55ad01a2c5d4e407fc3a72ccd90',1,'entt::SparseSet< Entity >::fast()']]] + ['frequently_20asked_20questions',['Frequently Asked Questions',['../autotoc_md46.html',1,'']]], + ['fail',['fail',['../classentt_1_1process.html#a81816bdd06dce4058bfe3cfa5d42a64c',1,'entt::process']]], + ['family',['family',['../classentt_1_1family.html',1,'entt']]], + ['family_5ftype',['family_type',['../classentt_1_1family.html#a86a662c9342935bcf145b70bf36191cb',1,'entt::family']]], + ['find',['find',['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#a7376a0f7f7badf83d6a58b38e41e69c2',1,'entt::basic_group< Entity, get_t< Get... > >::find()'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html#a09d84415b93dd88e5a9e15faa9229c83',1,'entt::basic_group< Entity, get_t< Get... >, Owned... >::find()'],['../classentt_1_1sparse__set.html#a0ed57521bb3279b5ed3cd397b65abf01',1,'entt::sparse_set::find()'],['../classentt_1_1basic__view.html#aa8098ec2a26d9386d68c0b664d21d93e',1,'entt::basic_view::find()'],['../classentt_1_1basic__view_3_01Entity_00_01Component_01_4.html#aa8098ec2a26d9386d68c0b664d21d93e',1,'entt::basic_view< Entity, Component >::find()']]], + ['func',['func',['../classentt_1_1meta__factory.html#ad4948c2fc844fe17a5a69dc71c845561',1,'entt::meta_factory::func()'],['../classentt_1_1meta__type.html#abf0f410fb838c6b6a430931f2d142e64',1,'entt::meta_type::func(Op op) const ENTT_NOEXCEPT'],['../classentt_1_1meta__type.html#a93ec0cd3e91b92243cc4638140ddacc4',1,'entt::meta_type::func(const char *str) const ENTT_NOEXCEPT']]], + ['function_5ftype',['function_type',['../classentt_1_1delegate_3_01Ret_07Args_8_8_8_08_4.html#a235927a00f56e4b56dbfdc4e6cf5ddb4',1,'entt::delegate< Ret(Args...)>']]] ]; diff --git a/search/all_6.js b/search/all_6.js index e42d45482..3e93a592f 100644 --- a/search/all_6.js +++ b/search/all_6.js @@ -1,4 +1,7 @@ var searchData= [ - ['get',['get',['../classentt_1_1Identifier.html#aed05b85b75f2b0646e007f156e43ca6a',1,'entt::Identifier::get()'],['../structentt_1_1Actor.html#ae6a07d30d0aca366d5b1eb3e839e36bc',1,'entt::Actor::get(tag_t) const ENTT_NOEXCEPT'],['../structentt_1_1Actor.html#ae3ef92c5829b365871bb9fffb013d825',1,'entt::Actor::get(tag_t) ENTT_NOEXCEPT'],['../structentt_1_1Actor.html#acd9d53518e387076d89df97767fee4f1',1,'entt::Actor::get() const ENTT_NOEXCEPT'],['../structentt_1_1Actor.html#a636b3ba19d4762b9b616a5e47e959b08',1,'entt::Actor::get() ENTT_NOEXCEPT'],['../classentt_1_1Attachee_3_01Entity_01_4.html#ae11b358a9638ea78e642118d8ad8eaad',1,'entt::Attachee< Entity >::get()'],['../classentt_1_1Attachee_3_01Entity_00_01Type_01_4.html#a8a0a579bc14bd6265891cd7484c9c356',1,'entt::Attachee< Entity, Type >::get() const ENTT_NOEXCEPT'],['../classentt_1_1Attachee_3_01Entity_00_01Type_01_4.html#ae7a2e05bf005d6db60e7ea01bc24ea50',1,'entt::Attachee< Entity, Type >::get() ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#a0d23c82dcf122123ee29ffd3254b4b84',1,'entt::Prototype::get() const ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#a4069701eaf29716ed9bbb404da5f1b59',1,'entt::Prototype::get() ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#ae52596223d2a61e52c41979b1e76d68f',1,'entt::Prototype::get() const ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#a35fcf29a4c01caa611cffa9f73cbe535',1,'entt::Prototype::get() ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a2079fb67093feb86b75e9dede6bb6c4d',1,'entt::Registry::get() const ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a3c71607135bee449a486c8a5241dc70d',1,'entt::Registry::get() ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#aa40aa6a87415b2e88c67b8b9f895bfe8',1,'entt::Registry::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#aefa861cd4cd2750ddb43f587fc756531',1,'entt::Registry::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a19e0832f4aceb58f1be1e7540313cec0',1,'entt::Registry::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a73f3a68af4e73a74a273cca9ceab68a2',1,'entt::Registry::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#aa7893474e3b47da7c2568a0dc4ab4bcf',1,'entt::SparseSet< Entity >::get()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a00ef6f3c6da43a1ef864a5252bc9b0a6',1,'entt::SparseSet< Entity, Type >::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#ab0a6f42129ec08ab607545712e67ce92',1,'entt::SparseSet< Entity, Type >::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#a51452939486c5e98036b60838f69a32d',1,'entt::PersistentView::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#a0a088e6e40be777f9834c1c3fc6d1b15',1,'entt::PersistentView::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#af6931b058d6009776cc19082eb9a512f',1,'entt::PersistentView::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#ad2e8b8cf33831f8ea2caf1bd9a0474b6',1,'entt::PersistentView::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1View.html#a8f2e5fc95bb71c698b8ce61b9b4a8a5e',1,'entt::View::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1View.html#ade86403331b51e25fae9238dd8997de0',1,'entt::View::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1View.html#a9fb10d57d05afa48c0f25ea0b475c81f',1,'entt::View::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1View.html#ac5b199f031c48da2393eb56fea35b83e',1,'entt::View::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a51d497700a0322a130022eea97643d0f',1,'entt::View< Entity, Component >::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a269fac4009da89c9743202b16dcd6d87',1,'entt::View< Entity, Component >::get(const entity_type entity) ENTT_NOEXCEPT'],['../structentt_1_1ServiceLocator.html#a87a0d27f2ce4ac8a94229e32853503ca',1,'entt::ServiceLocator::get()'],['../classentt_1_1ResourceHandle.html#a32e791c4556d040273643ca5f42755a9',1,'entt::ResourceHandle::get()']]] + ['get',['get',['../structentt_1_1basic__actor.html#a64d3d7ff9801b9efbb3cf08d93baca88',1,'entt::basic_actor::get() const ENTT_NOEXCEPT'],['../structentt_1_1basic__actor.html#a194f434fa3ed013a5266ebcbaa4761d8',1,'entt::basic_actor::get() ENTT_NOEXCEPT'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#ac9e3a791565a6ce40e63a579204320fc',1,'entt::basic_group< Entity, get_t< Get... > >::get()'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html#abcf557e056d884bcd6bd6a250448d6af',1,'entt::basic_group< Entity, get_t< Get... >, Owned... >::get()'],['../classentt_1_1basic__prototype.html#ac030e38aaa91c32530493a97a64fe1af',1,'entt::basic_prototype::get() const ENTT_NOEXCEPT'],['../classentt_1_1basic__prototype.html#a803649bd8fde6e3adad5c99dd118186a',1,'entt::basic_prototype::get() ENTT_NOEXCEPT'],['../classentt_1_1basic__registry.html#ab3c413736c37cd59e013dacae68512bc',1,'entt::basic_registry::get([[maybe_unused]] const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1basic__registry.html#aed5e3029a1134f1bb87617d0e99f89ac',1,'entt::basic_registry::get([[maybe_unused]] const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1sparse__set.html#ae5fdeb500ab138905118a4ebb018895a',1,'entt::sparse_set::get()'],['../classentt_1_1basic__storage.html#ab9f40b67e8a21a0aa2071ea127a1e4b9',1,'entt::basic_storage::get(const entity_type entt) const ENTT_NOEXCEPT'],['../classentt_1_1basic__storage.html#a629a39bfc6a29036671dea9d9b42f70d',1,'entt::basic_storage::get(const entity_type entt) ENTT_NOEXCEPT'],['../classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty__v_3_01Type_01_4_01_4_01_4.html#acd4baaae6a45b994ff2890034e423954',1,'entt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >::get()'],['../classentt_1_1basic__view.html#aaa4f1d01440c37739502d3d73a28c4ca',1,'entt::basic_view::get()'],['../classentt_1_1basic__view_3_01Entity_00_01Component_01_4.html#a55c708083311799867acab1954e530a9',1,'entt::basic_view< Entity, Component >::get()'],['../structentt_1_1service__locator.html#ab72c1dab3eec4554690a82457894b385',1,'entt::service_locator::get()'],['../classentt_1_1meta__data.html#a3d63885952dd5a7613bab37fc63c8ecd',1,'entt::meta_data::get(meta_handle handle) const ENTT_NOEXCEPT'],['../classentt_1_1meta__data.html#a98d5a4bd199049ba9ea553ec21fac583',1,'entt::meta_data::get(meta_handle handle, std::size_t index) const ENTT_NOEXCEPT'],['../classentt_1_1resource__handle.html#a694112d96f6c6f4e1c803aa2824996c7',1,'entt::resource_handle::get()'],['../namespaceentt.html#a8c24ecc5ab0055f9f2a4725c95afb29e',1,'entt::get()']]], + ['get_5for_5fassign',['get_or_assign',['../classentt_1_1basic__registry.html#a20a14f97c1684c5aaeeba13ba40a3ad7',1,'entt::basic_registry']]], + ['get_5ft',['get_t',['../structentt_1_1get__t.html',1,'entt']]], + ['group',['group',['../classentt_1_1basic__registry.html#a5a1700b02f6149444e190e57198e6a56',1,'entt::basic_registry::group(get_t< Get... >, exclude_t< Exclude... >={})'],['../classentt_1_1basic__registry.html#a0cd8cce88fd986480f641cd54ab74a68',1,'entt::basic_registry::group(get_t< Get... >, exclude_t< Exclude... >={}) const'],['../classentt_1_1basic__registry.html#a2c58ef6dde05dee6060b67009c4f2830',1,'entt::basic_registry::group(exclude_t< Exclude... >={})'],['../classentt_1_1basic__registry.html#a0009b9e643337268ec3e3015b684904f',1,'entt::basic_registry::group(exclude_t< Exclude... >={}) const'],['../namespaceentt.html#a010d1bbf234dbca47e6755fc278e36b5',1,'entt::group()']]] ]; diff --git a/search/all_7.js b/search/all_7.js index f35aecaa0..a1f0c0566 100644 --- a/search/all_7.js +++ b/search/all_7.js @@ -1,7 +1,7 @@ var searchData= [ - ['handle',['handle',['../classentt_1_1ResourceCache.html#a8d7348dc398645962d9993905ea8709f',1,'entt::ResourceCache']]], - ['has',['has',['../structentt_1_1Actor.html#a17e417a142fb430413f08bc56b7f95e1',1,'entt::Actor::has(tag_t) const ENTT_NOEXCEPT'],['../structentt_1_1Actor.html#ac606b0a0418351c925d29809f7107662',1,'entt::Actor::has() const ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#a3f156472cc6a07016eadf51082b8f2f8',1,'entt::Prototype::has()'],['../classentt_1_1Registry.html#ae2be7a8e1e6216b8a48fa941e9d3fbd6',1,'entt::Registry::has() const ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#afc108dadf41e5080274bcc4e877024e4',1,'entt::Registry::has(tag_t, const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a1ca7a3b46d14db8d917547643b1ab614',1,'entt::Registry::has(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1ContinuousLoader.html#a65c5550a1a68135345e30e2af20b6096',1,'entt::ContinuousLoader::has()'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a824d6f4789f0c03a7f18802d9dc46582',1,'entt::SparseSet< Entity >::has()']]], - ['hash_5ftype',['hash_type',['../classentt_1_1HashedString.html#af511100177b5e0213bf5b0efb3f4f528',1,'entt::HashedString']]], - ['hashedstring',['HashedString',['../classentt_1_1HashedString.html',1,'entt::HashedString'],['../classentt_1_1HashedString.html#af9ae25ce87c6183a71026d2c64501f98',1,'entt::HashedString::HashedString(const char(&str)[N]) ENTT_NOEXCEPT'],['../classentt_1_1HashedString.html#a56c7a79123eb7f0b63f0b0e218a111b9',1,'entt::HashedString::HashedString(ConstCharWrapper wrapper) ENTT_NOEXCEPT']]] + ['handle',['handle',['../classentt_1_1resource__cache.html#af4253936d31e8755bc0ff099d844600b',1,'entt::resource_cache']]], + ['has',['has',['../structentt_1_1basic__actor.html#a8e7a76ea53bc8a0cce33462def30b9ac',1,'entt::basic_actor::has()'],['../classentt_1_1basic__prototype.html#a6d4f9ce06a07f9b40ec714b13428326c',1,'entt::basic_prototype::has()'],['../classentt_1_1basic__registry.html#a22f516140a0fb811552f82910d95fead',1,'entt::basic_registry::has()'],['../classentt_1_1basic__continuous__loader.html#a7c2650e8116d6d32eb859435d9a31023',1,'entt::basic_continuous_loader::has()'],['../classentt_1_1sparse__set.html#af4eb4faf1aa28d20717716bea7981f5b',1,'entt::sparse_set::has()']]], + ['hash_5ftype',['hash_type',['../classentt_1_1hashed__string.html#a71cb1793c1193bd6c89c42a00179793f',1,'entt::hashed_string']]], + ['hashed_5fstring',['hashed_string',['../classentt_1_1hashed__string.html',1,'entt::hashed_string'],['../classentt_1_1hashed__string.html#ada991606527a67c3cb4eed4fba4bebce',1,'entt::hashed_string::hashed_string() ENTT_NOEXCEPT'],['../classentt_1_1hashed__string.html#a10130abb35bcca89b366815b2398bb55',1,'entt::hashed_string::hashed_string(const char(&curr)[N]) ENTT_NOEXCEPT'],['../classentt_1_1hashed__string.html#ae1b9c068c45549c59e795ad74f22ef5c',1,'entt::hashed_string::hashed_string(const_wrapper wrapper) ENTT_NOEXCEPT']]] ]; diff --git a/search/all_8.js b/search/all_8.js index 0fa2e71e9..d8935af4f 100644 --- a/search/all_8.js +++ b/search/all_8.js @@ -1,8 +1,27 @@ var searchData= [ - ['identifier',['Identifier',['../classentt_1_1Identifier.html',1,'entt']]], - ['identifier_5ftype',['identifier_type',['../classentt_1_1Identifier.html#a80c4fd9773928949e788790fac671169',1,'entt::Identifier']]], - ['insertionsort',['InsertionSort',['../structentt_1_1InsertionSort.html',1,'entt']]], - ['instance_5ftype',['instance_type',['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#aad306ac41adf5562740f5528bed80014',1,'entt::SigH< Ret(Args...), Collector >']]], - ['iterator_5ftype',['iterator_type',['../classentt_1_1SparseSet_3_01Entity_01_4.html#a1ad77aed1e49af60b61044c996969b9a',1,'entt::SparseSet< Entity >::iterator_type()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a7ff4726f5e0ae6698cb8e3f039289b52',1,'entt::SparseSet< Entity, Type >::iterator_type()'],['../classentt_1_1PersistentView.html#ae563ed31a62fd9f33f93767f0ecdfff5',1,'entt::PersistentView::iterator_type()'],['../classentt_1_1View.html#a738fb04a466b1f858a1eb5d7bc8fd668',1,'entt::View::iterator_type()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a791a1288db896fda8e77acad396aa513',1,'entt::View< Entity, Component >::iterator_type()'],['../classentt_1_1RawView.html#ab34740dea79327742888e84ba5c14328',1,'entt::RawView::iterator_type()'],['../classentt_1_1RuntimeView.html#a59c6645fb86e079986d04887aa7c74e1',1,'entt::RuntimeView::iterator_type()']]] + ['identifier',['identifier',['../classentt_1_1identifier.html',1,'entt']]], + ['identifier_5ftype',['identifier_type',['../classentt_1_1identifier.html#ae35c46f5811183291dd25294e7d82f92',1,'entt::identifier']]], + ['insertion_5fsort',['insertion_sort',['../structentt_1_1insertion__sort.html',1,'entt']]], + ['instance',['instance',['../classentt_1_1delegate_3_01Ret_07Args_8_8_8_08_4.html#a3e0495b7612d458cbc59dc4b657d586f',1,'entt::delegate< Ret(Args...)>']]], + ['instance_5ftype',['instance_type',['../structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#adfd38e6a8d026f9418d60c207edcd295',1,'entt::sigh< Ret(Args...), Collector >']]], + ['invoke',['invoke',['../classentt_1_1meta__ctor.html#a2402980d8233e20480e0732df86f4d11',1,'entt::meta_ctor::invoke()'],['../classentt_1_1meta__dtor.html#a0b61f83fcfee615d8a27d9ff31c3deed',1,'entt::meta_dtor::invoke()'],['../classentt_1_1meta__func.html#a6145a3e14b99154a5caec4ad66a85c88',1,'entt::meta_func::invoke()']]], + ['is_5farray',['is_array',['../classentt_1_1meta__type.html#a708c42df22be9647eca05a8c9701a7b2',1,'entt::meta_type']]], + ['is_5fclass',['is_class',['../classentt_1_1meta__type.html#a9d1e5e6cd4c097143a3055b8e56a8641',1,'entt::meta_type']]], + ['is_5fconst',['is_const',['../classentt_1_1meta__data.html#a04acd97d1fe059a1dd3daaf508e10558',1,'entt::meta_data::is_const()'],['../classentt_1_1meta__func.html#a93c1f9ba3252788f9ac470f6ad6e3fb9',1,'entt::meta_func::is_const()']]], + ['is_5fenum',['is_enum',['../classentt_1_1meta__type.html#ab2d4f56d08063128d0b4bc5cb4b1b0c9',1,'entt::meta_type']]], + ['is_5ffloating_5fpoint',['is_floating_point',['../classentt_1_1meta__type.html#acb95ab1d8952b3595b0d820cee1aa79d',1,'entt::meta_type']]], + ['is_5ffunction',['is_function',['../classentt_1_1meta__type.html#a34f470bbee1fbc3a640d156c0e37c553',1,'entt::meta_type']]], + ['is_5fintegral',['is_integral',['../classentt_1_1meta__type.html#a222c4b6ae628f9ed6f90cd3573f788c8',1,'entt::meta_type']]], + ['is_5fmember_5ffunction_5fpointer',['is_member_function_pointer',['../classentt_1_1meta__type.html#a184083298b97b476f02509fd5379bdbb',1,'entt::meta_type']]], + ['is_5fmember_5fobject_5fpointer',['is_member_object_pointer',['../classentt_1_1meta__type.html#a486ce6d737b37675403f3e719a2a51a2',1,'entt::meta_type']]], + ['is_5fnamed_5ftype',['is_named_type',['../structentt_1_1is__named__type.html',1,'entt']]], + ['is_5fnamed_5ftype_3c_20type_2c_20std_3a_3avoid_5ft_3c_20named_5ftype_5ftraits_5ft_3c_20std_3a_3adecay_5ft_3c_20type_20_3e_20_3e_20_3e_20_3e',['is_named_type< Type, std::void_t< named_type_traits_t< std::decay_t< Type > > > >',['../structentt_1_1is__named__type_3_01Type_00_01std_1_1void__t_3_01named__type__traits__t_3_01std_1_268fa5a871b2de95e24d77c0786df19e.html',1,'entt']]], + ['is_5fnamed_5ftype_5fv',['is_named_type_v',['../namespaceentt.html#ab127297f5449d5c90bcef166a12c4358',1,'entt']]], + ['is_5fpointer',['is_pointer',['../classentt_1_1meta__type.html#a8eec2742984f892febcbc48a6192bdfd',1,'entt::meta_type']]], + ['is_5fstatic',['is_static',['../classentt_1_1meta__data.html#a94ae645e41c37e0da30a0353d391b9ad',1,'entt::meta_data::is_static()'],['../classentt_1_1meta__func.html#a8faf171039dc72ea51d94acc2c2ea249',1,'entt::meta_func::is_static()']]], + ['is_5funion',['is_union',['../classentt_1_1meta__type.html#ad3503617450b2814e53362206bb6fecd',1,'entt::meta_type']]], + ['is_5fvoid',['is_void',['../classentt_1_1meta__type.html#a4a8aea6060bd82daf287bb6c63c1955a',1,'entt::meta_type']]], + ['iterator_5ftype',['iterator_type',['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#aad8c6789036e02b7c4f2823255e7f16e',1,'entt::basic_group< Entity, get_t< Get... > >::iterator_type()'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html#aafbded588937b50f5ce4ee6d79a559e6',1,'entt::basic_group< Entity, get_t< Get... >, Owned... >::iterator_type()'],['../classentt_1_1basic__runtime__view.html#afbaa87a1aa3eacd54ec3a5462faa10da',1,'entt::basic_runtime_view::iterator_type()'],['../classentt_1_1sparse__set.html#a580b210d5a24c49ca8c255646f3bb469',1,'entt::sparse_set::iterator_type()'],['../classentt_1_1basic__storage.html#a9a1c32a0adebc8c3dc279064742c858f',1,'entt::basic_storage::iterator_type()'],['../classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty__v_3_01Type_01_4_01_4_01_4.html#a2136db82a122b336298bd909c07c629b',1,'entt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >::iterator_type()'],['../classentt_1_1basic__view.html#adad369b0a841ef254549668348fed0c5',1,'entt::basic_view::iterator_type()'],['../classentt_1_1basic__view_3_01Entity_00_01Component_01_4.html#a11420baf6cdbf1a97f3861784bd5fac2',1,'entt::basic_view< Entity, Component >::iterator_type()']]], + ['meta_5fnode',['meta_node',['../classentt_1_1meta__type.html#a98457ea639e19ea648d32776ac80cd44',1,'entt::meta_type']]] ]; diff --git a/search/all_9.js b/search/all_9.js index ec9117c10..dc852501d 100644 --- a/search/all_9.js +++ b/search/all_9.js @@ -1,6 +1,4 @@ var searchData= [ - ['label',['label',['../namespaceentt.html#a8512c4b75207424bd97724a17cd1eeb0',1,'entt']]], - ['listener',['Listener',['../classentt_1_1Emitter.html#a1a5bb5d6a7626aec285cc73bfc1e80ef',1,'entt::Emitter']]], - ['load',['load',['../classentt_1_1ResourceCache.html#a12155caf98459157ed5dbf3b3c4d545f',1,'entt::ResourceCache']]] + ['key',['key',['../classentt_1_1meta__prop.html#a3f46ec94ffc028eb41c8db9915e7b6f3',1,'entt::meta_prop']]] ]; diff --git a/search/all_a.js b/search/all_a.js index 82c209144..eb05bc873 100644 --- a/search/all_a.js +++ b/search/all_a.js @@ -1,6 +1,6 @@ var searchData= [ - ['map',['map',['../classentt_1_1ContinuousLoader.html#a63d6f733d8651a19b7ea882f3615455c',1,'entt::ContinuousLoader']]], - ['monostate',['Monostate',['../structentt_1_1Monostate.html',1,'entt']]], - ['move',['move',['../classentt_1_1Attachee_3_01Entity_00_01Type_01_4.html#af23f10b818925731c47beb0eb2e6164d',1,'entt::Attachee< Entity, Type >::move()'],['../classentt_1_1Registry.html#a459073e0dfdb4f21519792717f688173',1,'entt::Registry::move()']]] + ['listener',['listener',['../classentt_1_1emitter.html#a460311b6b4adfabe69b9d964c8d0b579',1,'entt::emitter']]], + ['load',['load',['../classentt_1_1resource__cache.html#a4c5aa78d4c9c8d8148fab59a738cf20d',1,'entt::resource_cache']]], + ['loader',['loader',['../classentt_1_1basic__registry.html#a3d1400403d03bc6e3e5fd9dfe60c5dd3',1,'entt::basic_registry']]] ]; diff --git a/search/all_b.js b/search/all_b.js index ae2385a1f..35a71553e 100644 --- a/search/all_b.js +++ b/search/all_b.js @@ -1,4 +1,17 @@ var searchData= [ - ['null',['null',['../namespaceentt.html#a588326af8f6f902a6c0b57d3f9fc6c17',1,'entt']]] + ['map',['map',['../classentt_1_1basic__continuous__loader.html#ab077b1e21a817130db7401524ffc41a0',1,'entt::basic_continuous_loader']]], + ['meta_5fany',['meta_any',['../classentt_1_1meta__any.html',1,'entt::meta_any'],['../classentt_1_1meta__any.html#a7d9eaa43621da68af96080b7f345f2b6',1,'entt::meta_any::meta_any() ENTT_NOEXCEPT'],['../classentt_1_1meta__any.html#adb57245c636a920913ec11088473c064',1,'entt::meta_any::meta_any(Type &&type)'],['../classentt_1_1meta__any.html#a8070ecc97c91d3c294d07339073e0a6a',1,'entt::meta_any::meta_any(const meta_any &other)'],['../classentt_1_1meta__any.html#a16de68c4d78064eb025627588936edfb',1,'entt::meta_any::meta_any(meta_any &&other) ENTT_NOEXCEPT']]], + ['meta_5fbase',['meta_base',['../classentt_1_1meta__base.html',1,'entt::meta_base'],['../classentt_1_1meta__base.html#a626084cbdbd95551966a74268a4c032c',1,'entt::meta_base::meta_base()']]], + ['meta_5fconv',['meta_conv',['../classentt_1_1meta__conv.html',1,'entt::meta_conv'],['../classentt_1_1meta__conv.html#a4397a13a77cbce66d1f8588f99974066',1,'entt::meta_conv::meta_conv()']]], + ['meta_5fctor',['meta_ctor',['../classentt_1_1meta__ctor.html',1,'entt::meta_ctor'],['../classentt_1_1meta__ctor.html#ad9afbf8f0d39ecb2bb6cc5fdc694724c',1,'entt::meta_ctor::meta_ctor()']]], + ['meta_5fdata',['meta_data',['../classentt_1_1meta__data.html',1,'entt::meta_data'],['../classentt_1_1meta__data.html#a0cf4625a3d9427c4c589052a6b72709f',1,'entt::meta_data::meta_data()']]], + ['meta_5fdtor',['meta_dtor',['../classentt_1_1meta__dtor.html',1,'entt::meta_dtor'],['../classentt_1_1meta__dtor.html#adfa744faec2c49be6c2864cec39a23ce',1,'entt::meta_dtor::meta_dtor()']]], + ['meta_5ffactory',['meta_factory',['../classentt_1_1meta__factory.html',1,'entt::meta_factory< Type >'],['../classentt_1_1meta__prop.html#aedfbba32fc3c4d0017b417d21473cddf',1,'entt::meta_prop::meta_factory()'],['../classentt_1_1meta__base.html#aedfbba32fc3c4d0017b417d21473cddf',1,'entt::meta_base::meta_factory()'],['../classentt_1_1meta__conv.html#aedfbba32fc3c4d0017b417d21473cddf',1,'entt::meta_conv::meta_factory()'],['../classentt_1_1meta__ctor.html#aedfbba32fc3c4d0017b417d21473cddf',1,'entt::meta_ctor::meta_factory()'],['../classentt_1_1meta__dtor.html#aedfbba32fc3c4d0017b417d21473cddf',1,'entt::meta_dtor::meta_factory()'],['../classentt_1_1meta__data.html#aedfbba32fc3c4d0017b417d21473cddf',1,'entt::meta_data::meta_factory()'],['../classentt_1_1meta__func.html#aedfbba32fc3c4d0017b417d21473cddf',1,'entt::meta_func::meta_factory()'],['../classentt_1_1meta__type.html#aedfbba32fc3c4d0017b417d21473cddf',1,'entt::meta_type::meta_factory()']]], + ['meta_5ffunc',['meta_func',['../classentt_1_1meta__func.html',1,'entt::meta_func'],['../classentt_1_1meta__func.html#accb09abe59e6e219f098d5a629a4ab60',1,'entt::meta_func::meta_func()']]], + ['meta_5fhandle',['meta_handle',['../classentt_1_1meta__handle.html',1,'entt::meta_handle'],['../classentt_1_1meta__any.html#a8b9314fab6c8ba30425b75c7b2e2977e',1,'entt::meta_any::meta_handle()'],['../classentt_1_1meta__handle.html#a45c9c3f6a23bcf62a0fc306296236236',1,'entt::meta_handle::meta_handle() ENTT_NOEXCEPT'],['../classentt_1_1meta__handle.html#a11ff4c2d10554f9649396cd2cb564b2e',1,'entt::meta_handle::meta_handle(Type &&obj) ENTT_NOEXCEPT']]], + ['meta_5fprop',['meta_prop',['../classentt_1_1meta__prop.html',1,'entt::meta_prop'],['../classentt_1_1meta__prop.html#abd7eebc5c56f072f44c42542218a732c',1,'entt::meta_prop::meta_prop()']]], + ['meta_5ftype',['meta_type',['../classentt_1_1meta__type.html',1,'entt::meta_type'],['../classentt_1_1meta__type.html#adc6239b718064cbcde0bbcebfcddbfda',1,'entt::meta_type::meta_type()']]], + ['monostate',['monostate',['../structentt_1_1monostate.html',1,'entt']]], + ['monostate_5fv',['monostate_v',['../namespaceentt.html#ab43a13f7ee60bcb0d04a001f92b86fa2',1,'entt']]] ]; diff --git a/search/all_c.js b/search/all_c.js index 1e1eec18d..fce556f5e 100644 --- a/search/all_c.js +++ b/search/all_c.js @@ -1,21 +1,9 @@ var searchData= [ - ['object_5ftype',['object_type',['../classentt_1_1Attachee_3_01Entity_00_01Type_01_4.html#a081468359310ab5cf3807d044ba4a8d6',1,'entt::Attachee< Entity, Type >::object_type()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#af7db79dfb4e031a63fa526d4f7d54915',1,'entt::SparseSet< Entity, Type >::object_type()']]], - ['on',['on',['../classentt_1_1Emitter.html#a1df9a54b806806add57c3168cbb2bdf1',1,'entt::Emitter']]], - ['once',['once',['../classentt_1_1Emitter.html#a1145cc27235acf0e24e1956ba0b15393',1,'entt::Emitter']]], - ['oneshotbubblesort',['OneShotBubbleSort',['../structentt_1_1OneShotBubbleSort.html',1,'entt']]], - ['operator_20bool',['operator bool',['../classentt_1_1ResourceHandle.html#a4da18e304419e8d070fbc095236b4403',1,'entt::ResourceHandle']]], - ['operator_20const_20char_20_2a',['operator const char *',['../classentt_1_1HashedString.html#ac93c062eb14c80be82bd75bb6e853be0',1,'entt::HashedString']]], - ['operator_20const_20resource_20_26',['operator const Resource &',['../classentt_1_1ResourceHandle.html#aa728424029a170454b7e61056af0926a',1,'entt::ResourceHandle']]], - ['operator_20hash_5ftype',['operator hash_type',['../classentt_1_1HashedString.html#a47843deb0d550b5a6e1129a9b913d85f',1,'entt::HashedString']]], - ['operator_20type',['operator Type',['../structentt_1_1Monostate.html#ae16dec68153e1cf761d8c2379c4e3e8c',1,'entt::Monostate']]], - ['operator_21_3d',['operator!=',['../namespaceentt.html#a8a638f5585d404bbdcfd8efdfeb39203',1,'entt::operator!=(const HashedString &lhs, const HashedString &rhs) ENTT_NOEXCEPT'],['../namespaceentt.html#aef8743ab32f59bd2905b9fa2938318b6',1,'entt::operator!=(const Delegate< Ret(Args...)> &lhs, const Delegate< Ret(Args...)> &rhs) ENTT_NOEXCEPT'],['../namespaceentt.html#a13ce28be581233dd1e9179a126dd979d',1,'entt::operator!=(const SigH< Ret(Args...)> &lhs, const SigH< Ret(Args...)> &rhs) ENTT_NOEXCEPT']]], - ['operator_28_29',['operator()',['../structentt_1_1StdSort.html#a3363910b5a138b20f96d8a967a7bbd8b',1,'entt::StdSort::operator()()'],['../structentt_1_1InsertionSort.html#a53f94456eb885d9a02344b33b39f8815',1,'entt::InsertionSort::operator()()'],['../structentt_1_1OneShotBubbleSort.html#a9c8c582c4a83a9faaf1e328296daf971',1,'entt::OneShotBubbleSort::operator()()'],['../classentt_1_1Prototype.html#ac7cb69aad2015e94f3a0a9ad42b82f1b',1,'entt::Prototype::operator()(registry_type &other, const entity_type dst) const ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#a6b0560c31432fb6591a772ce9a322728',1,'entt::Prototype::operator()(const entity_type dst) const ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#a7c401ecc89b0c88ab15ed2dd7686b54e',1,'entt::Prototype::operator()(registry_type &other) const ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#ad39dd5c5449cc647a1402543ebe411fe',1,'entt::Prototype::operator()() const ENTT_NOEXCEPT'],['../classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html#a3259f295bc4ea1da8307d1be65c83d6a',1,'entt::Delegate< Ret(Args...)>::operator()()']]], - ['operator_2a',['operator*',['../classentt_1_1ResourceHandle.html#a737a5c2e623d30f372ba4876fe3d0fd3',1,'entt::ResourceHandle']]], - ['operator_2d_3e',['operator->',['../classentt_1_1ResourceHandle.html#a55727b34cb2bcbff11a680bae2fd793e',1,'entt::ResourceHandle']]], - ['operator_3d',['operator=',['../structentt_1_1Monostate.html#a9e94509f038e4a634ce776cdc23548cf',1,'entt::Monostate::operator=()'],['../structentt_1_1Actor.html#a4c76bce639cb1b1f9cd3393dc6a9722c',1,'entt::Actor::operator=(const Actor &)=delete'],['../structentt_1_1Actor.html#a6c62cd16b0c52210930b0ac46854e716',1,'entt::Actor::operator=(Actor &&other)'],['../classentt_1_1Attachee_3_01Entity_01_4.html#a5577985fadaf54cd8b7a68379121f70b',1,'entt::Attachee< Entity >::operator=(const Attachee &)=default'],['../classentt_1_1Attachee_3_01Entity_01_4.html#a0fae3370d9f43831f912fc62c720fdd2',1,'entt::Attachee< Entity >::operator=(Attachee &&)=default'],['../classentt_1_1Attachee_3_01Entity_00_01Type_01_4.html#a7fc23ce495ad53e201ccd065975a0863',1,'entt::Attachee< Entity, Type >::operator=(const Attachee &)=delete'],['../classentt_1_1Attachee_3_01Entity_00_01Type_01_4.html#ad84135f7dd401013703924ee2f4971e3',1,'entt::Attachee< Entity, Type >::operator=(Attachee &&)=delete'],['../classentt_1_1Prototype.html#a65529171240b1b7c348445c7ba4f319e',1,'entt::Prototype::operator=(const Prototype &)=delete'],['../classentt_1_1Prototype.html#a9faf0b8878925090431a9e6acaed06c5',1,'entt::Prototype::operator=(Prototype &&other)'],['../classentt_1_1Registry.html#a6ff250745f1774984a9524d63855f26d',1,'entt::Registry::operator=(const Registry &)=delete'],['../classentt_1_1Registry.html#ade7432a219317a6912553feb2971188b',1,'entt::Registry::operator=(Registry &&)=default'],['../classentt_1_1Snapshot.html#a3375f7d701d086fc21e04e6077c954fc',1,'entt::Snapshot::operator=(const Snapshot &)=delete'],['../classentt_1_1Snapshot.html#a627c0ea635facdd8b8246d1b97de11e3',1,'entt::Snapshot::operator=(Snapshot &&)=default'],['../classentt_1_1SnapshotLoader.html#ad1f8a300b9c5ccf0598cd90ab0e0062f',1,'entt::SnapshotLoader::operator=(const SnapshotLoader &)=delete'],['../classentt_1_1SnapshotLoader.html#a69ed990a8a614e5a1cb90960c216784b',1,'entt::SnapshotLoader::operator=(SnapshotLoader &&)=default'],['../classentt_1_1ContinuousLoader.html#add60e853e8b948f8f3c9f5c73207cb2a',1,'entt::ContinuousLoader::operator=(const ContinuousLoader &)=delete'],['../classentt_1_1ContinuousLoader.html#a3e0c1b78fbd9ba85857c066b5c89adb5',1,'entt::ContinuousLoader::operator=(ContinuousLoader &&)=default'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a34ffc79377cef381ef5af2e75d61cf4d',1,'entt::SparseSet< Entity >::operator=(const SparseSet &)=delete'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a24ddfc9e45d7b70639124fe7c2800384',1,'entt::SparseSet< Entity >::operator=(SparseSet &&)=default'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#aa700bb907a18470dce144f84822c67ae',1,'entt::SparseSet< Entity, Type >::operator=(const SparseSet &)=delete'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a52a81e838ae87413116ab9165ab9ba86',1,'entt::SparseSet< Entity, Type >::operator=(SparseSet &&)=default'],['../classentt_1_1Scheduler.html#a66fa731504da02dfaa607e1c3f153120',1,'entt::Scheduler::operator=(const Scheduler &)=delete'],['../classentt_1_1Scheduler.html#a929ec57792af25f0552f25ad445c7731',1,'entt::Scheduler::operator=(Scheduler &&)=default'],['../classentt_1_1ResourceCache.html#abe56c919c4a2606f87d7d8351261a0e8',1,'entt::ResourceCache::operator=(const ResourceCache &) ENTT_NOEXCEPT=delete'],['../classentt_1_1ResourceCache.html#a18ddc0a0bae71d8124d775d9ddebc550',1,'entt::ResourceCache::operator=(ResourceCache &&) ENTT_NOEXCEPT=default'],['../classentt_1_1ResourceHandle.html#a017670d5037cf65ea0b81b5c094004ac',1,'entt::ResourceHandle::operator=(const ResourceHandle &) ENTT_NOEXCEPT=default'],['../classentt_1_1ResourceHandle.html#a5c6a854be6eca84bd76d8e05f05f657b',1,'entt::ResourceHandle::operator=(ResourceHandle &&) ENTT_NOEXCEPT=default'],['../structentt_1_1Emitter_1_1Connection.html#aa1dba0de2aaa8426f4b42e6c52aa80ea',1,'entt::Emitter::Connection::operator=(const Connection &)=default'],['../structentt_1_1Emitter_1_1Connection.html#a26bc490e1d62f8e7863052f28cc5672c',1,'entt::Emitter::Connection::operator=(Connection &&)=default'],['../classentt_1_1Emitter.html#ace3403fe310953f720dbddff016fe715',1,'entt::Emitter::operator=(const Emitter &)=delete'],['../classentt_1_1Emitter.html#a8d06e737c14bf6be779135529424ca64',1,'entt::Emitter::operator=(Emitter &&)=default']]], - ['operator_3d_3d',['operator==',['../classentt_1_1HashedString.html#aa5ca9b72d2fa65f2a4796a4ffae00c11',1,'entt::HashedString::operator==()'],['../classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html#a7fd87003864d2a56baa7d2c8a9317509',1,'entt::Delegate< Ret(Args...)>::operator==()'],['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#acd0e64abe3b6d879a27ced38fe50aa4b',1,'entt::SigH< Ret(Args...), Collector >::operator==()']]], - ['operator_5b_5d',['operator[]',['../classentt_1_1SparseSet_3_01Entity_01_4.html#a2de3b3dc887e30616c37dd1dbc3de46b',1,'entt::SparseSet< Entity >::operator[]()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a073eb76e982c1031ef0b69118764faab',1,'entt::SparseSet< Entity, Type >::operator[](const size_type pos) const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a6cd7bd35b86f34191bbfe73ff922b91e',1,'entt::SparseSet< Entity, Type >::operator[](const size_type pos) ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#a7edc6f5cbd49d978469d9384b9aca6b3',1,'entt::PersistentView::operator[]()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a6094dd00422b07f0a9523699b9bf77aa',1,'entt::View< Entity, Component >::operator[]()'],['../classentt_1_1RawView.html#a6a8855ebc61f5ea5f4c676173e92cfcc',1,'entt::RawView::operator[](const size_type pos) const ENTT_NOEXCEPT'],['../classentt_1_1RawView.html#ac85aa3a824640eeeb45f9d1eaaaeea8d',1,'entt::RawView::operator[](const size_type pos) ENTT_NOEXCEPT']]], - ['orphan',['orphan',['../classentt_1_1Registry.html#a3b4a5341ac0ef79fd2477753e857a9cb',1,'entt::Registry']]], - ['orphans',['orphans',['../classentt_1_1Registry.html#ada2900e50f66573c14821baac03bbd68',1,'entt::Registry::orphans()'],['../classentt_1_1SnapshotLoader.html#a70e3af34bfacf921a2579b1d0055ceca',1,'entt::SnapshotLoader::orphans()'],['../classentt_1_1ContinuousLoader.html#ad1f0c307283afc23e11460c9ca2037c0',1,'entt::ContinuousLoader::orphans()']]] + ['name',['name',['../classentt_1_1meta__data.html#a0a8b6735b7e7d017986aba75ce3c0515',1,'entt::meta_data::name()'],['../classentt_1_1meta__func.html#a418fd52ebc418d8afcfd645aa348416f',1,'entt::meta_func::name()'],['../classentt_1_1meta__type.html#ae07252fea20d74382a4e3876128cde40',1,'entt::meta_type::name()']]], + ['named_5ftype_5ftraits',['named_type_traits',['../structentt_1_1named__type__traits.html',1,'entt']]], + ['named_5ftype_5ftraits_3c_20const_20type_20_3e',['named_type_traits< const Type >',['../structentt_1_1named__type__traits_3_01const_01Type_01_4.html',1,'entt']]], + ['named_5ftype_5ftraits_3c_20type_20_3e',['named_type_traits< Type >',['../structentt_1_1named__type__traits.html',1,'entt']]], + ['named_5ftype_5ftraits_5ft',['named_type_traits_t',['../namespaceentt.html#a63a1328e9f26407f68f4f814ab86ad6f',1,'entt']]], + ['null',['null',['../namespaceentt.html#a588326af8f6f902a6c0b57d3f9fc6c17',1,'entt']]] ]; diff --git a/search/all_d.js b/search/all_d.js index 4630825ab..b8f989f80 100644 --- a/search/all_d.js +++ b/search/all_d.js @@ -1,13 +1,27 @@ var searchData= [ - ['pause',['pause',['../classentt_1_1Process.html#a1f2f865b2c4f0c7cf2d82786ecb50f5f',1,'entt::Process']]], - ['paused',['paused',['../classentt_1_1Process.html#a3e320da0927d9ac83dc829d0aee8a310',1,'entt::Process']]], - ['persistent_5ft',['persistent_t',['../structentt_1_1persistent__t.html',1,'entt']]], - ['persistentview',['PersistentView',['../classentt_1_1PersistentView.html',1,'entt']]], - ['prepare',['prepare',['../classentt_1_1Registry.html#ac05c9ccc5fe57df386d8104578fc9675',1,'entt::Registry']]], - ['process',['Process',['../classentt_1_1Process.html',1,'entt']]], - ['process_3c_20processadaptor_3c_20func_2c_20delta_20_3e_2c_20delta_20_3e',['Process< ProcessAdaptor< Func, Delta >, Delta >',['../classentt_1_1Process.html',1,'entt']]], - ['processadaptor',['ProcessAdaptor',['../structentt_1_1ProcessAdaptor.html',1,'entt::ProcessAdaptor< Func, Delta >'],['../structentt_1_1ProcessAdaptor.html#a16a0964a81c537fe16b937696e47358b',1,'entt::ProcessAdaptor::ProcessAdaptor()']]], - ['prototype',['Prototype',['../classentt_1_1Prototype.html',1,'entt::Prototype< Entity >'],['../classentt_1_1Prototype.html#aa6033be234aad4d287d740c40db17fec',1,'entt::Prototype::Prototype(Registry< Entity > &registry)'],['../classentt_1_1Prototype.html#a6f3d7431f85160da0e255b279c4b5291',1,'entt::Prototype::Prototype(const Prototype &)=delete'],['../classentt_1_1Prototype.html#ad4900c4a27f506b5d2b9db54aba9d224',1,'entt::Prototype::Prototype(Prototype &&other)']]], - ['publish',['publish',['../classentt_1_1Emitter.html#ab5141fd9793f53ef83af47c8c8a74b0e',1,'entt::Emitter::publish()'],['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#a5d3aaec10dba146d75672e3dc81a4274',1,'entt::SigH< Ret(Args...), Collector >::publish()']]] + ['basic_5fgroup_3c_20entity_2c_20get_5ft_2c_20owned_2e_2e_2e_20_3e',['basic_group< Entity, get_t, Owned... >',['../structentt_1_1as__group.html#af21610b3a3c165daaeb8f7724ab2b12d',1,'entt::as_group']]], + ['basic_5fview_3c_20entity_2c_20component_2e_2e_2e_20_3e',['basic_view< Entity, Component... >',['../structentt_1_1as__view.html#a6ca2fdd962761c71661b5178f3ec510b',1,'entt::as_view']]], + ['object_5ftype',['object_type',['../classentt_1_1basic__storage.html#aa4e4358d25212b71d9629e470b845c53',1,'entt::basic_storage::object_type()'],['../classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty__v_3_01Type_01_4_01_4_01_4.html#af67063212a566afa51deede112b70d2a',1,'entt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >::object_type()']]], + ['on',['on',['../classentt_1_1emitter.html#a0b580005200bb810a4a3e94320efcd8a',1,'entt::emitter']]], + ['on_5fconstruct',['on_construct',['../classentt_1_1basic__registry.html#a3784cae09a1a72a861c4ccd1e76db86a',1,'entt::basic_registry']]], + ['on_5fdestroy',['on_destroy',['../classentt_1_1basic__registry.html#a2a4af2fe256e5609282686b427f0ebcf',1,'entt::basic_registry']]], + ['on_5freplace',['on_replace',['../classentt_1_1basic__registry.html#a23857b92dfe141d7fd60c450fd14507a',1,'entt::basic_registry']]], + ['once',['once',['../classentt_1_1emitter.html#a79834d452b0600ebe0e70c54f4a21fd6',1,'entt::emitter']]], + ['operator_20bool',['operator bool',['../classentt_1_1meta__any.html#ad1cbe0447f1b0df45706712566f1b2a0',1,'entt::meta_any::operator bool()'],['../classentt_1_1meta__handle.html#a759d3375fd8e5811ca898cb8d6740eda',1,'entt::meta_handle::operator bool()'],['../classentt_1_1meta__prop.html#adb6af4bef4db742083886a0b97646407',1,'entt::meta_prop::operator bool()'],['../classentt_1_1meta__base.html#ad19d5a997c91281da3674a6b17d011bd',1,'entt::meta_base::operator bool()'],['../classentt_1_1meta__conv.html#aa7b17a68e2b9f7a1b614a5aa1e4a7c1a',1,'entt::meta_conv::operator bool()'],['../classentt_1_1meta__ctor.html#ac34d2ccb2c3ff0549775ed5c4c617ba2',1,'entt::meta_ctor::operator bool()'],['../classentt_1_1meta__dtor.html#ad4b53dd0805dd47276c196b093258deb',1,'entt::meta_dtor::operator bool()'],['../classentt_1_1meta__data.html#aebff3cb9edf609deb8577ed29225c508',1,'entt::meta_data::operator bool()'],['../classentt_1_1meta__func.html#a436c57daae914c9222de41c7b7678584',1,'entt::meta_func::operator bool()'],['../classentt_1_1meta__type.html#ae8101e23b4b79a4452f063736f86b3ad',1,'entt::meta_type::operator bool()'],['../classentt_1_1resource__handle.html#a78608879425212e25817c16e3393ee07',1,'entt::resource_handle::operator bool()'],['../classentt_1_1delegate_3_01Ret_07Args_8_8_8_08_4.html#a73e1029cbb6359d803a6cc06b82f80d7',1,'entt::delegate< Ret(Args...)>::operator bool()']]], + ['operator_20const_20char_20_2a',['operator const char *',['../classentt_1_1hashed__string.html#ad2b28732fadfb525cab25b19310617d1',1,'entt::hashed_string']]], + ['operator_20const_20resource_20_26',['operator const Resource &',['../classentt_1_1resource__handle.html#ab22a293cb18602690309a561b97d28cb',1,'entt::resource_handle']]], + ['operator_20hash_5ftype',['operator hash_type',['../classentt_1_1hashed__string.html#abc56b22d4cddd7b05fb41e32adfea8e2',1,'entt::hashed_string']]], + ['operator_20type',['operator Type',['../structentt_1_1monostate.html#ae48c2fc3cb5ca85e12b57a10fee54dfe',1,'entt::monostate']]], + ['operator_21_3d',['operator!=',['../namespaceentt.html#a9bb4a7e4959c087484745324d79efbd9',1,'entt::operator!=(const hashed_string &lhs, const hashed_string &rhs) ENTT_NOEXCEPT'],['../namespaceentt.html#a3e7582fde7d0323ad068543d660116f4',1,'entt::operator!=(const meta_any &lhs, const meta_any &rhs) ENTT_NOEXCEPT'],['../namespaceentt.html#abe07bfd01b0fac902d6d89a76b8b58fe',1,'entt::operator!=(const meta_prop &lhs, const meta_prop &rhs) ENTT_NOEXCEPT'],['../namespaceentt.html#a633d6546a24a66cfba27ad3f8bdbbd30',1,'entt::operator!=(const meta_base &lhs, const meta_base &rhs) ENTT_NOEXCEPT'],['../namespaceentt.html#ae0028b0d2edc4d7fd110069323d80f4b',1,'entt::operator!=(const meta_conv &lhs, const meta_conv &rhs) ENTT_NOEXCEPT'],['../namespaceentt.html#a42e03a0e2b4f0ed2bf7dd7635e4d22e8',1,'entt::operator!=(const meta_ctor &lhs, const meta_ctor &rhs) ENTT_NOEXCEPT'],['../namespaceentt.html#ab4ba1bf1f3ad09a47b477ad9a320393f',1,'entt::operator!=(const meta_dtor &lhs, const meta_dtor &rhs) ENTT_NOEXCEPT'],['../namespaceentt.html#afffe04587aa936ef68791af1d99d380d',1,'entt::operator!=(const meta_data &lhs, const meta_data &rhs) ENTT_NOEXCEPT'],['../namespaceentt.html#a0bccfeb5e95c4ce5ea82cac0b4738f49',1,'entt::operator!=(const meta_func &lhs, const meta_func &rhs) ENTT_NOEXCEPT'],['../namespaceentt.html#a2feb1b10f84534d2ed32aed30c36cb61',1,'entt::operator!=(const meta_type &lhs, const meta_type &rhs) ENTT_NOEXCEPT'],['../namespaceentt.html#a656b2ec80abf493ce1924b314d13fd18',1,'entt::operator!=(const delegate< Ret(Args...)> &lhs, const delegate< Ret(Args...)> &rhs) ENTT_NOEXCEPT']]], + ['operator_28_29',['operator()',['../structentt_1_1std__sort.html#af25b38ddb03e206a71a1f47521eaea46',1,'entt::std_sort::operator()()'],['../structentt_1_1insertion__sort.html#a73a5644fe5b683f9b9376c89ac47f2b8',1,'entt::insertion_sort::operator()()'],['../classentt_1_1basic__prototype.html#a463e0d4a93ce396a069bd181c59ba6e2',1,'entt::basic_prototype::operator()(registry_type &other, const entity_type dst) const ENTT_NOEXCEPT'],['../classentt_1_1basic__prototype.html#a081d19f1dbb870c85f2bb215422700c1',1,'entt::basic_prototype::operator()(const entity_type dst) const ENTT_NOEXCEPT'],['../classentt_1_1basic__prototype.html#a8e47d98dbba3929f3edfe682975db846',1,'entt::basic_prototype::operator()(registry_type &other) const ENTT_NOEXCEPT'],['../classentt_1_1basic__prototype.html#afa55befc754adbf67d25ebae7aed6a75',1,'entt::basic_prototype::operator()() const ENTT_NOEXCEPT'],['../classentt_1_1delegate_3_01Ret_07Args_8_8_8_08_4.html#a0e53caedb53810bc96aa71bce199c990',1,'entt::delegate< Ret(Args...)>::operator()()']]], + ['operator_2a',['operator*',['../classentt_1_1resource__handle.html#a2b014e1f6f871f25329c6bed1048f0ef',1,'entt::resource_handle']]], + ['operator_2d_3e',['operator->',['../classentt_1_1resource__handle.html#ab2b2301a2f2f81f14979a9278c565e78',1,'entt::resource_handle']]], + ['operator_3d',['operator=',['../structentt_1_1monostate.html#a60244e7ef8dfc7c0eea55123b3ed294e',1,'entt::monostate::operator=()'],['../structentt_1_1basic__actor.html#a729116e0ae65677a6ed9ed9d21c111c6',1,'entt::basic_actor::operator=()'],['../classentt_1_1basic__prototype.html#a24a5c455ba9368897c959f722496fa54',1,'entt::basic_prototype::operator=()'],['../classentt_1_1basic__registry.html#a70f7acd3a0e9a8dc4ef7e85172f93a59',1,'entt::basic_registry::operator=()'],['../classentt_1_1basic__snapshot.html#a1484b609195cfd057bbdd8808d4392bc',1,'entt::basic_snapshot::operator=()'],['../classentt_1_1basic__snapshot__loader.html#aa55eeaad2ab4dd117524afff9d6e184b',1,'entt::basic_snapshot_loader::operator=()'],['../classentt_1_1basic__continuous__loader.html#afd396d84cb27e070a6a812bd28140c75',1,'entt::basic_continuous_loader::operator=()'],['../classentt_1_1sparse__set.html#a32a00ca96cc7e78089fb7120d144de34',1,'entt::sparse_set::operator=(const sparse_set &other)'],['../classentt_1_1sparse__set.html#a7cb1c0bffe341b847537956075b398fa',1,'entt::sparse_set::operator=(sparse_set &&)=default'],['../classentt_1_1meta__any.html#a80b825c89dc1509a9099d807b528b3aa',1,'entt::meta_any::operator=()'],['../classentt_1_1scheduler.html#aea6ab78dbf00ba17c6e828ee0505afd9',1,'entt::scheduler::operator=()'],['../classentt_1_1resource__cache.html#a1aecfbf6c4faaadb05ce5005c202223c',1,'entt::resource_cache::operator=()'],['../classentt_1_1emitter.html#ab270d2c6d986621a781467e29e64629c',1,'entt::emitter::operator=()']]], + ['operator_3d_3d',['operator==',['../classentt_1_1hashed__string.html#a6f7720e526da38370d52636a8ecb1b50',1,'entt::hashed_string::operator==()'],['../classentt_1_1meta__any.html#a2673fdc066e710ce94cbb2f5c3994d42',1,'entt::meta_any::operator==()'],['../classentt_1_1meta__prop.html#adbcf1179374bab74c2be1f395078b89e',1,'entt::meta_prop::operator==()'],['../classentt_1_1meta__base.html#a6469955ac7550d5396cf185795c07a15',1,'entt::meta_base::operator==()'],['../classentt_1_1meta__conv.html#a176af5a8c4b2fae4dc1d862509705152',1,'entt::meta_conv::operator==()'],['../classentt_1_1meta__ctor.html#a49299869b3adc7a3a97dc9c9cf9617a8',1,'entt::meta_ctor::operator==()'],['../classentt_1_1meta__dtor.html#a55905a8daf9dafcdc33e38e1247b1e9d',1,'entt::meta_dtor::operator==()'],['../classentt_1_1meta__data.html#ac44372da54f317b93fec85570bb50cfc',1,'entt::meta_data::operator==()'],['../classentt_1_1meta__func.html#a4d29a2982e937d0dff5dac93434099a1',1,'entt::meta_func::operator==()'],['../classentt_1_1meta__type.html#a838362aa3598bfa4cc18041d3445bace',1,'entt::meta_type::operator==()'],['../classentt_1_1delegate_3_01Ret_07Args_8_8_8_08_4.html#a54ca30c9a3f7a9662363c48db4e86aae',1,'entt::delegate< Ret(Args...)>::operator==()']]], + ['operator_5b_5d',['operator[]',['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#a9d0986a0b72def2ddbc12ffada355745',1,'entt::basic_group< Entity, get_t< Get... > >::operator[]()'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html#abd790e8ea6c44818592481c8312fc718',1,'entt::basic_group< Entity, get_t< Get... >, Owned... >::operator[]()'],['../classentt_1_1basic__view_3_01Entity_00_01Component_01_4.html#a08e5f6d88283b8e90ce252fcae447932',1,'entt::basic_view< Entity, Component >::operator[]()']]], + ['orphan',['orphan',['../classentt_1_1basic__registry.html#a10f5e61d4cabab9e9c1e87edc30de551',1,'entt::basic_registry']]], + ['orphans',['orphans',['../classentt_1_1basic__registry.html#ae337ceb77e75c10c73ffa671e09bfff8',1,'entt::basic_registry::orphans()'],['../classentt_1_1basic__snapshot__loader.html#acd881016761f5eb598763fbf3595a625',1,'entt::basic_snapshot_loader::orphans()'],['../classentt_1_1basic__continuous__loader.html#ac8b328bb8c6c4acde51ab5b943f0ea86',1,'entt::basic_continuous_loader::orphans()']]], + ['overload',['overload',['../namespaceentt.html#a386a739051d9d37a5578785b77fc426b',1,'entt::overload(Type Class::*member)'],['../namespaceentt.html#a00d50f88cc654b9326f7844b8cb03370',1,'entt::overload(Type *func)']]], + ['owned',['owned',['../classentt_1_1basic__registry.html#a6685b760dd15f8a1976c2d30f852789d',1,'entt::basic_registry']]] ]; diff --git a/search/all_e.js b/search/all_e.js index eb8344b6a..b3d444db8 100644 --- a/search/all_e.js +++ b/search/all_e.js @@ -1,25 +1,13 @@ var searchData= [ - ['raw',['raw',['../classentt_1_1Registry.html#aaa4a9703f583da393101aa91604267e6',1,'entt::Registry::raw() const ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a1728046f5645bf2ff3f167c40ca29d0e',1,'entt::Registry::raw() ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#acbad98597d305c221c90eabd67b169bc',1,'entt::SparseSet< Entity, Type >::raw() const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a8bc3ff7eb8a371ad64cf16f85116946b',1,'entt::SparseSet< Entity, Type >::raw() ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a67bdaf39828b8055069d51825192541d',1,'entt::View< Entity, Component >::raw() const ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a07d8b7d15b93f9988f6b4fbf514a356a',1,'entt::View< Entity, Component >::raw() ENTT_NOEXCEPT'],['../classentt_1_1RawView.html#ae9909bbe3f734989b765324b8cd75332',1,'entt::RawView::raw() const ENTT_NOEXCEPT'],['../classentt_1_1RawView.html#a1cdb189f5b2bf17021cf5c53d10ec222',1,'entt::RawView::raw() ENTT_NOEXCEPT']]], - ['raw_5ft',['raw_t',['../structentt_1_1raw__t.html',1,'entt']]], - ['raw_5ftype',['raw_type',['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a8bdfb1fbdd4340131be9c70bf02671b5',1,'entt::View< Entity, Component >::raw_type()'],['../classentt_1_1RawView.html#a6a6e2cd0387a63e153a18bd60a1283a3',1,'entt::RawView::raw_type()']]], - ['rawview',['RawView',['../classentt_1_1RawView.html',1,'entt']]], - ['ref',['ref',['../structentt_1_1ServiceLocator.html#a746c27214142cdd98c650c9cc66bf165',1,'entt::ServiceLocator']]], - ['registry',['Registry',['../classentt_1_1Registry.html',1,'entt::Registry< Entity >'],['../structentt_1_1Actor.html#ab31a5da2d556ff3c01e0cea59f090956',1,'entt::Actor::registry() const ENTT_NOEXCEPT'],['../structentt_1_1Actor.html#ae914b8f7817cdfaf596983743df126fe',1,'entt::Actor::registry() ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#ab5022bf3ac71d209cb9b85e686324f28',1,'entt::Registry::Registry()=default'],['../classentt_1_1Registry.html#a441dfbc29b39106fbacec0f0c7b07359',1,'entt::Registry::Registry(const Registry &)=delete'],['../classentt_1_1Registry.html#a5340b49833d3e23e28200a4069fe04b0',1,'entt::Registry::Registry(Registry &&)=default']]], - ['registry_3c_20entity_20_3e',['Registry< Entity >',['../classentt_1_1Snapshot.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::Snapshot::Registry< Entity >()'],['../classentt_1_1SnapshotLoader.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::SnapshotLoader::Registry< Entity >()'],['../classentt_1_1PersistentView.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::PersistentView::Registry< Entity >()'],['../classentt_1_1View.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::View::Registry< Entity >()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::View< Entity, Component >::Registry< Entity >()'],['../classentt_1_1RawView.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::RawView::Registry< Entity >()'],['../classentt_1_1RuntimeView.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::RuntimeView::Registry< Entity >()']]], - ['registry_5ftype',['registry_type',['../structentt_1_1Actor.html#a59ce601affb52396d2cacdc3ffd14928',1,'entt::Actor::registry_type()'],['../classentt_1_1Prototype.html#a8e4a91009c1cbb0bfaadf4e95178eaec',1,'entt::Prototype::registry_type()']]], - ['rejected',['rejected',['../classentt_1_1Process.html#aa4e618f12f5cf18d978557ea793b697d',1,'entt::Process']]], - ['reload',['reload',['../classentt_1_1ResourceCache.html#afaa3e5a964e1f04ea0c2c86adb7b4fbd',1,'entt::ResourceCache']]], - ['remove',['remove',['../structentt_1_1Actor.html#a4c805918eeb0f01c86529a3c9b4e9b13',1,'entt::Actor::remove(tag_t)'],['../structentt_1_1Actor.html#a2a647927841d9c2440cfb664f371bf09',1,'entt::Actor::remove()'],['../classentt_1_1Registry.html#a957bcbdbf082f9767e5474a73be6ece4',1,'entt::Registry::remove()'],['../classentt_1_1Registry.html#a113ff63724bdb90344984d5dd16995f2',1,'entt::Registry::remove(const entity_type entity)']]], - ['replace',['replace',['../classentt_1_1Registry.html#a39b071aa110b8ea38fb71ca471d371b5',1,'entt::Registry::replace(tag_t, Args &&... args)'],['../classentt_1_1Registry.html#a2482e363a9b4ff9b6a4a0e1385c7b6e1',1,'entt::Registry::replace(const entity_type entity, Args &&... args)']]], - ['reserve',['reserve',['../classentt_1_1Registry.html#a6d57a57e13ca236a215e332b94852147',1,'entt::Registry::reserve(const size_type cap)'],['../classentt_1_1Registry.html#aa927ac552b42e2a0fcc8de08f56510c7',1,'entt::Registry::reserve(const size_type cap)'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a19fd8be1b2cad2a4ca01c88225b0a379',1,'entt::SparseSet< Entity >::reserve()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a9b7168661765b86a7c24500a03115197',1,'entt::SparseSet< Entity, Type >::reserve()']]], - ['reset',['reset',['../classentt_1_1Registry.html#af406e83980abc792905ff4a0626b3d02',1,'entt::Registry::reset(const entity_type entity)'],['../classentt_1_1Registry.html#a613333e0a4acb227d08938ccc594e064',1,'entt::Registry::reset()'],['../classentt_1_1Registry.html#a1b6ec743e9a62389cf2bba9a25ee09d7',1,'entt::Registry::reset()'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#ad1c62c65aeb0112e688f05d8f641cdab',1,'entt::SparseSet< Entity >::reset()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a3b138c121f11592a3f9e9f2fc2bb67fe',1,'entt::SparseSet< Entity, Type >::reset()'],['../structentt_1_1ServiceLocator.html#ac52892a5692c15c8b230a5020adb0847',1,'entt::ServiceLocator::reset()'],['../classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html#a77c5b9a98a0636391955de940dad0b4f',1,'entt::Delegate< Ret(Args...)>::reset()']]], - ['resource_5ftype',['resource_type',['../classentt_1_1ResourceCache.html#a4936da93a62827d8c5fc04ac444e5456',1,'entt::ResourceCache']]], - ['resourcecache',['ResourceCache',['../classentt_1_1ResourceCache.html',1,'entt::ResourceCache< Resource >'],['../classentt_1_1ResourceCache.html#aaeb4613b842a5d0861585e024af0a41d',1,'entt::ResourceCache::ResourceCache()=default'],['../classentt_1_1ResourceCache.html#a4dbd37c3c1a703b684b6122a59a0b3a7',1,'entt::ResourceCache::ResourceCache(const ResourceCache &) ENTT_NOEXCEPT=delete'],['../classentt_1_1ResourceCache.html#a86dde6d7190adbb13d8472424f6e8bca',1,'entt::ResourceCache::ResourceCache(ResourceCache &&) ENTT_NOEXCEPT=default']]], - ['resourcecache_3c_20resource_20_3e',['ResourceCache< Resource >',['../classentt_1_1ResourceHandle.html#a302c9d1bd54cf8e7e958d5e505773b23',1,'entt::ResourceHandle::ResourceCache< Resource >()'],['../classentt_1_1ResourceLoader.html#a302c9d1bd54cf8e7e958d5e505773b23',1,'entt::ResourceLoader::ResourceCache< Resource >()']]], - ['resourcehandle',['ResourceHandle',['../classentt_1_1ResourceHandle.html',1,'entt::ResourceHandle< Resource >'],['../classentt_1_1ResourceHandle.html#a7b267f802e92b57dcc750f824fd5e3df',1,'entt::ResourceHandle::ResourceHandle(const ResourceHandle &) ENTT_NOEXCEPT=default'],['../classentt_1_1ResourceHandle.html#a4d5c929ea7f0bd8860d7188aa6fb76a8',1,'entt::ResourceHandle::ResourceHandle(ResourceHandle &&) ENTT_NOEXCEPT=default']]], - ['resourceloader',['ResourceLoader',['../classentt_1_1ResourceLoader.html',1,'entt']]], - ['respect',['respect',['../classentt_1_1SparseSet_3_01Entity_01_4.html#a17422401f952b58be5113ff88e302c0e',1,'entt::SparseSet< Entity >::respect()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a605545f8f99a7bb1f92d1dfc3ed438f3',1,'entt::SparseSet< Entity, Type >::respect()']]], - ['restore',['restore',['../classentt_1_1Registry.html#a37b755b43c7067658d2b4129baa403cf',1,'entt::Registry']]], - ['runtimeview',['RuntimeView',['../classentt_1_1RuntimeView.html',1,'entt']]] + ['push_20entt_20across_20boundaries',['Push EnTT across boundaries',['../autotoc_md50.html',1,'']]], + ['parent',['parent',['../classentt_1_1meta__base.html#ad05e984d2cc36f64c0a64fe951e9cdce',1,'entt::meta_base::parent()'],['../classentt_1_1meta__conv.html#a6ca68ad1f28b7e410133f2fa902e2fd5',1,'entt::meta_conv::parent()'],['../classentt_1_1meta__ctor.html#a776c2812dd8724523fc881defb1116f2',1,'entt::meta_ctor::parent()'],['../classentt_1_1meta__dtor.html#ad5cf3129b534f5cb6f736a713f71e37e',1,'entt::meta_dtor::parent()'],['../classentt_1_1meta__data.html#af951f9f860512984d19c706ca3013fed',1,'entt::meta_data::parent()'],['../classentt_1_1meta__func.html#a63056a4d3f0a16c988d90162240fe74d',1,'entt::meta_func::parent()']]], + ['pause',['pause',['../classentt_1_1process.html#a9bf45a6c430f5e32fc7ab33a7a197abc',1,'entt::process']]], + ['paused',['paused',['../classentt_1_1process.html#a2c1c1f5ea78d3b2fc87cfcdbf7a1b40f',1,'entt::process']]], + ['process',['process',['../classentt_1_1process.html',1,'entt']]], + ['process_3c_20process_5fadaptor_3c_20func_2c_20delta_20_3e_2c_20delta_20_3e',['process< process_adaptor< Func, Delta >, Delta >',['../classentt_1_1process.html',1,'entt']]], + ['process_5fadaptor',['process_adaptor',['../structentt_1_1process__adaptor.html',1,'entt::process_adaptor< Func, Delta >'],['../structentt_1_1process__adaptor.html#ad1e2c8f3c44bf42abb05ef913b8267ce',1,'entt::process_adaptor::process_adaptor()']]], + ['prop',['prop',['../classentt_1_1meta__ctor.html#ae63dd6567cc8ec0eb871ce253f49f6a7',1,'entt::meta_ctor::prop(Op op) const ENTT_NOEXCEPT'],['../classentt_1_1meta__ctor.html#a20f04e7acdd1988d7f3981a449fdd437',1,'entt::meta_ctor::prop(Key &&key) const ENTT_NOEXCEPT'],['../classentt_1_1meta__data.html#abffe3a3870ba6d7f05c953b7cea50a68',1,'entt::meta_data::prop(Op op) const ENTT_NOEXCEPT'],['../classentt_1_1meta__data.html#a60c8d19929ecd943c286fad22cc210f4',1,'entt::meta_data::prop(Key &&key) const ENTT_NOEXCEPT'],['../classentt_1_1meta__func.html#a28d919188b186ad646b56e0fd1485fc6',1,'entt::meta_func::prop(Op op) const ENTT_NOEXCEPT'],['../classentt_1_1meta__func.html#a9798c7e2216e7d395d57f25ff53a5042',1,'entt::meta_func::prop(Key &&key) const ENTT_NOEXCEPT'],['../classentt_1_1meta__type.html#a9da6947b4a4df64e23f81b3488fa7dff',1,'entt::meta_type::prop(Op op) const ENTT_NOEXCEPT'],['../classentt_1_1meta__type.html#a59d911f5ba7b0a69606b93289bcc21fa',1,'entt::meta_type::prop(Key &&key) const ENTT_NOEXCEPT']]], + ['prototype',['prototype',['../namespaceentt.html#a5db962f82244acf52040d0a1eca2c13a',1,'entt']]], + ['publish',['publish',['../classentt_1_1emitter.html#a4ece275ff8736bcdcfb4103087801ea2',1,'entt::emitter::publish()'],['../structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#a33009a1bb0c46ae6500dc8475251babe',1,'entt::sigh< Ret(Args...), Collector >::publish()']]] ]; diff --git a/search/all_f.js b/search/all_f.js index 59ccd2f50..dedbff233 100644 --- a/search/all_f.js +++ b/search/all_f.js @@ -1,27 +1,25 @@ var searchData= [ - ['scheduler',['Scheduler',['../classentt_1_1Scheduler.html',1,'entt::Scheduler< Delta >'],['../classentt_1_1Scheduler.html#a9c8baf08ea6f2869432cb13d870481c3',1,'entt::Scheduler::Scheduler() ENTT_NOEXCEPT=default'],['../classentt_1_1Scheduler.html#a4527dc6d1aedb50126e522ae7c8de5a1',1,'entt::Scheduler::Scheduler(const Scheduler &)=delete'],['../classentt_1_1Scheduler.html#ab3a3ca9fa457fd48873c6d0d700a6f6c',1,'entt::Scheduler::Scheduler(Scheduler &&)=default']]], - ['service_5ftype',['service_type',['../structentt_1_1ServiceLocator.html#a0631b136adf579365fb444bc5e8f1416',1,'entt::ServiceLocator']]], - ['servicelocator',['ServiceLocator',['../structentt_1_1ServiceLocator.html',1,'entt::ServiceLocator< Service >'],['../structentt_1_1ServiceLocator.html#a9806fa1d96f6edfb5b946b11acabc0da',1,'entt::ServiceLocator::ServiceLocator()']]], - ['set',['set',['../classentt_1_1Prototype.html#abf665ce59c8f43c4eff3ce77a21c5cfb',1,'entt::Prototype::set()'],['../structentt_1_1ServiceLocator.html#abf8d8b8d70ed082d54516def7500ec5c',1,'entt::ServiceLocator::set(Args &&... args)'],['../structentt_1_1ServiceLocator.html#ad913de8d4a2dcf39b925773e42cbfff5',1,'entt::ServiceLocator::set(std::shared_ptr< Service > ptr)']]], - ['shrink',['shrink',['../classentt_1_1ContinuousLoader.html#a959dc40d6285e8175e95c3679c6698d6',1,'entt::ContinuousLoader']]], - ['sigh',['SigH',['../classentt_1_1SigH.html',1,'entt::SigH< Function, Collector >'],['../classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html#a06123dbbb14806c157626a76c2a2da01',1,'entt::Sink< Ret(Args...)>::SigH()']]], - ['sigh_3c_20ret_28args_2e_2e_2e_29_2c_20collector_20_3e',['SigH< Ret(Args...), Collector >',['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html',1,'entt']]], - ['sigh_3c_20void_28const_20event_20_26_29_3e',['SigH< void(const Event &)>',['../classentt_1_1SigH.html',1,'entt']]], - ['sigh_3c_20void_28registry_20_26_2c_20const_20entity_29_3e',['SigH< void(Registry &, const Entity)>',['../classentt_1_1SigH.html',1,'entt']]], - ['sink',['Sink',['../classentt_1_1Sink.html',1,'entt::Sink< Function >'],['../classentt_1_1Dispatcher.html#a091aa6ab261f34eee355c2b7180f709b',1,'entt::Dispatcher::sink()'],['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#a20b7fde8e36650f0e4cd31bd54ac1fc7',1,'entt::SigH< Ret(Args...), Collector >::sink()']]], - ['sink_3c_20ret_28args_2e_2e_2e_29_3e',['Sink< Ret(Args...)>',['../classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html',1,'entt']]], - ['sink_5ftype',['sink_type',['../classentt_1_1Registry.html#ada8da3c42b6f37209255eef008581b0b',1,'entt::Registry::sink_type()'],['../classentt_1_1Dispatcher.html#a3b34b8591cdd82022dba3c542054fe68',1,'entt::Dispatcher::sink_type()'],['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#afe3b68f9dc0a2bfe92081c256d0108b7',1,'entt::SigH< Ret(Args...), Collector >::sink_type()']]], - ['size',['size',['../classentt_1_1Registry.html#a88d7621801898d0a551cfd98b29a7cd0',1,'entt::Registry::size() const ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a1be83159fed73573014e6e2919ecabf3',1,'entt::Registry::size() const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a6dc502e9af33ac00af110e5eb8414bc1',1,'entt::SparseSet< Entity >::size()'],['../classentt_1_1PersistentView.html#ad6b816b2acc684733d79ac680005f8da',1,'entt::PersistentView::size()'],['../classentt_1_1View.html#a2244b847c1e148f901ea3b83ec2d6703',1,'entt::View::size()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a2244b847c1e148f901ea3b83ec2d6703',1,'entt::View< Entity, Component >::size()'],['../classentt_1_1RawView.html#a56cd44cbd4cf15fcaacdcfd9e2b0f710',1,'entt::RawView::size()'],['../classentt_1_1RuntimeView.html#a1532f09ceaac574965c9190554c74f55',1,'entt::RuntimeView::size()'],['../classentt_1_1Scheduler.html#a59aea2fac213df785278870474a3abb5',1,'entt::Scheduler::size()'],['../classentt_1_1ResourceCache.html#a1fb9767a303a85f09497751a7d70623f',1,'entt::ResourceCache::size()'],['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#a5f0c4724d805b4ecdd30045a13ed93ec',1,'entt::SigH< Ret(Args...), Collector >::size()']]], - ['size_5ftype',['size_type',['../classentt_1_1Prototype.html#a2a593566474356ad2a03fea9b122de93',1,'entt::Prototype::size_type()'],['../classentt_1_1Registry.html#a741ffda6e06838c5593ba97adc7658e2',1,'entt::Registry::size_type()'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#ab81c48dcee7a1104ee82794613ee7ed2',1,'entt::SparseSet< Entity >::size_type()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a27a88e2bb0822de41131741d9ffcded5',1,'entt::SparseSet< Entity, Type >::size_type()'],['../classentt_1_1PersistentView.html#ac2e81caacece38b84f46c4430cd8cf4e',1,'entt::PersistentView::size_type()'],['../classentt_1_1View.html#ab3f86ec55935bbbb00077bbe07f15c4b',1,'entt::View::size_type()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#afa754b0f10b28dbdb2149b5b8d0fdf73',1,'entt::View< Entity, Component >::size_type()'],['../classentt_1_1RawView.html#afc530c9c64688b522ac643fdb5a0bb6e',1,'entt::RawView::size_type()'],['../classentt_1_1RuntimeView.html#a64ed96d1933ffff0e76f96a0cb38428e',1,'entt::RuntimeView::size_type()'],['../classentt_1_1Scheduler.html#a2d76dbf324cf960ac8f2fc6d87d40eba',1,'entt::Scheduler::size_type()'],['../classentt_1_1ResourceCache.html#a439daf6009e24ae40b1d7689c60ead48',1,'entt::ResourceCache::size_type()'],['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#a7635c4c773fee73faf6eddda2d4abb87',1,'entt::SigH< Ret(Args...), Collector >::size_type()']]], - ['snapshot',['Snapshot',['../classentt_1_1Snapshot.html',1,'entt::Snapshot< Entity >'],['../classentt_1_1Snapshot.html#a80f9a56ce8667a5d9947cdaac686fd8d',1,'entt::Snapshot::Snapshot(const Snapshot &)=delete'],['../classentt_1_1Snapshot.html#a3682df1db11f032bfa9ead93c0cec479',1,'entt::Snapshot::Snapshot(Snapshot &&)=default'],['../classentt_1_1Registry.html#a00a0b4949a4cc0cb87e88cc6d1171a9d',1,'entt::Registry::snapshot()']]], - ['snapshotloader',['SnapshotLoader',['../classentt_1_1SnapshotLoader.html',1,'entt::SnapshotLoader< Entity >'],['../classentt_1_1SnapshotLoader.html#a7cc32b25447bf6d13ac36a814e446f4c',1,'entt::SnapshotLoader::SnapshotLoader(const SnapshotLoader &)=delete'],['../classentt_1_1SnapshotLoader.html#ad20cadc8bb3699629cb3ae54bf07b39a',1,'entt::SnapshotLoader::SnapshotLoader(SnapshotLoader &&)=default']]], - ['sort',['sort',['../classentt_1_1Registry.html#acb72e05f3128b6604b438707eabdfa4a',1,'entt::Registry::sort(Compare compare, Sort sort=Sort{}, Args &&... args)'],['../classentt_1_1Registry.html#aa3abb830a7ba342266b62ff1a2965754',1,'entt::Registry::sort()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a8d2f225354c91f10b427e02dc211d24f',1,'entt::SparseSet< Entity, Type >::sort()'],['../classentt_1_1PersistentView.html#accde3d4b4a904e79c832f6b05f324b05',1,'entt::PersistentView::sort()']]], - ['sparseset',['SparseSet',['../classentt_1_1SparseSet.html',1,'entt::SparseSet<... >'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#ac21f0c7137814008016648e166061426',1,'entt::SparseSet< Entity >::SparseSet() ENTT_NOEXCEPT=default'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#aa4ad5318f2be78e8e4336bdf4b012905',1,'entt::SparseSet< Entity >::SparseSet(const SparseSet &)=delete'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#acdfceb557303dee515fe906a13ac759e',1,'entt::SparseSet< Entity >::SparseSet(SparseSet &&)=default'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a80cd93fb003c8edd8583fb679464a36e',1,'entt::SparseSet< Entity, Type >::SparseSet() ENTT_NOEXCEPT=default'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a52d68a9763bed211729df965cb7ab859',1,'entt::SparseSet< Entity, Type >::SparseSet(const SparseSet &)=delete'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a11cbb29701b5a1b1a6e4b77d19d29cec',1,'entt::SparseSet< Entity, Type >::SparseSet(SparseSet &&)=default']]], - ['sparseset_3c_20entity_20_3e',['SparseSet< Entity >',['../classentt_1_1SparseSet_3_01Entity_01_4.html',1,'entt']]], - ['sparseset_3c_20entity_2c_20component_20_3e',['SparseSet< Entity, Component >',['../classentt_1_1SparseSet.html',1,'entt']]], - ['sparseset_3c_20entity_2c_20type_20_3e',['SparseSet< Entity, Type >',['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html',1,'entt']]], - ['stdsort',['StdSort',['../structentt_1_1StdSort.html',1,'entt']]], - ['succeed',['succeed',['../classentt_1_1Process.html#ae90a29bf2afabf6a14aec0e1d3809a0f',1,'entt::Process']]], - ['swap',['swap',['../classentt_1_1SparseSet_3_01Entity_01_4.html#ace9db01fbfd9f1b8afa4a6f43d42390e',1,'entt::SparseSet< Entity >::swap()'],['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#a77dd7bf9e63e5457c080416f31bb232b',1,'entt::SigH< Ret(Args...), Collector >::swap()']]] + ['raw',['raw',['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#a5563e4a99012122c42831db0587466b8',1,'entt::basic_group< Entity, get_t< Get... > >::raw()'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html#a64c80eda73138d8510bc519b21209501',1,'entt::basic_group< Entity, get_t< Get... >, Owned... >::raw()'],['../classentt_1_1basic__registry.html#aa0aa5dd120230aecd3b41474acbaecd2',1,'entt::basic_registry::raw() const ENTT_NOEXCEPT'],['../classentt_1_1basic__registry.html#a79751d793fe0f28e8f0e163e46638cb9',1,'entt::basic_registry::raw() ENTT_NOEXCEPT'],['../classentt_1_1basic__storage.html#a8e38d136d24bb38ef96c02135549c5d8',1,'entt::basic_storage::raw() const ENTT_NOEXCEPT'],['../classentt_1_1basic__storage.html#ae7757471c65eca305d2b83b570571065',1,'entt::basic_storage::raw() ENTT_NOEXCEPT'],['../classentt_1_1basic__view.html#acb3b8c843b1ded37a8bac4e9d434d048',1,'entt::basic_view::raw()'],['../classentt_1_1basic__view_3_01Entity_00_01Component_01_4.html#a28da2cdc89a3600cd01ca820e13352f6',1,'entt::basic_view< Entity, Component >::raw()']]], + ['raw_5ftype',['raw_type',['../classentt_1_1basic__view_3_01Entity_00_01Component_01_4.html#a07488b51f1575b2e5740f3d5f21e0524',1,'entt::basic_view< Entity, Component >']]], + ['ref',['ref',['../structentt_1_1service__locator.html#ae24d16726620af40371fadeddf5b5e2e',1,'entt::service_locator']]], + ['reflect',['reflect',['../classentt_1_1meta__factory.html#aa42fdb45a8b89dcb693ea717ec3106f2',1,'entt::meta_factory::reflect()'],['../namespaceentt.html#a9739002a4b8c8e752e612b48d941d85a',1,'entt::reflect(const char *str, Property &&... property) ENTT_NOEXCEPT'],['../namespaceentt.html#a3fdbbdb46e1c539b0141ff86b3201393',1,'entt::reflect() ENTT_NOEXCEPT']]], + ['registry',['registry',['../namespaceentt.html#a292643317d1dbb13e45824f757bd1086',1,'entt']]], + ['registry_5ftype',['registry_type',['../structentt_1_1basic__actor.html#a4577b087e2fe3e76dbd4516ae9064c6a',1,'entt::basic_actor::registry_type()'],['../structentt_1_1as__view.html#a458942b049c7ef96d45600337d57a70b',1,'entt::as_view::registry_type()'],['../structentt_1_1as__group.html#a7ede36514bf64187bc93d3d295fe0123',1,'entt::as_group::registry_type()'],['../classentt_1_1basic__prototype.html#aa7b03fff67dee5898849c971bc341962',1,'entt::basic_prototype::registry_type()']]], + ['rejected',['rejected',['../classentt_1_1process.html#a6ac63863bf823806d813b046769b4419',1,'entt::process']]], + ['reload',['reload',['../classentt_1_1resource__cache.html#aae5a27a1ecf361409846a5d64cc58088',1,'entt::resource_cache']]], + ['remove',['remove',['../structentt_1_1basic__actor.html#ab740844d18ada7ad15988f808617a1a1',1,'entt::basic_actor::remove()'],['../classentt_1_1basic__registry.html#a44f5eac6fa4d1999a121f55e67a36c24',1,'entt::basic_registry::remove()']]], + ['remove_5fpointer',['remove_pointer',['../classentt_1_1meta__type.html#a89df1ddbee0b5aef2651f1fc712ada20',1,'entt::meta_type']]], + ['replace',['replace',['../classentt_1_1basic__registry.html#a0411735fcddcc942613463c5401dd661',1,'entt::basic_registry']]], + ['reserve',['reserve',['../classentt_1_1basic__registry.html#a632adf32f7b23f1dae8bf4f8800a0bbe',1,'entt::basic_registry::reserve(const size_type cap)'],['../classentt_1_1basic__registry.html#a97677776c466a310547be1fdfdf84ff9',1,'entt::basic_registry::reserve(const size_type cap)'],['../classentt_1_1sparse__set.html#aabfddf33cb086063a471ee06d1778690',1,'entt::sparse_set::reserve()'],['../classentt_1_1basic__storage.html#a54d09089dd33cf9c0e5ac10a1be3fb29',1,'entt::basic_storage::reserve()']]], + ['reset',['reset',['../classentt_1_1basic__registry.html#a95dd0483f9839dfbce8af5ed120b94c2',1,'entt::basic_registry::reset(const entity_type entity)'],['../classentt_1_1basic__registry.html#ac5b546f2508b2a10a6f1d8c77db12837',1,'entt::basic_registry::reset()'],['../classentt_1_1basic__registry.html#a38a7c3696f749d0e873374086c3c0f88',1,'entt::basic_registry::reset()'],['../classentt_1_1sparse__set.html#a46d1553f6837b467f1ddf8ae3dece3d2',1,'entt::sparse_set::reset()'],['../classentt_1_1basic__storage.html#af899b0dbc254608941bcac7b08a6a7ce',1,'entt::basic_storage::reset()'],['../structentt_1_1service__locator.html#a4d655acab54d87058ad41a266830d0e8',1,'entt::service_locator::reset()'],['../classentt_1_1delegate_3_01Ret_07Args_8_8_8_08_4.html#a0d81bb1bde6abd78914cd0a07084bcd7',1,'entt::delegate< Ret(Args...)>::reset()']]], + ['resolve',['resolve',['../namespaceentt.html#a2129cb8668f5dcbc11854be6a4a0b6e5',1,'entt::resolve() ENTT_NOEXCEPT'],['../namespaceentt.html#a1397da6968def57fbee4afc9b1d09df1',1,'entt::resolve(const char *str) ENTT_NOEXCEPT'],['../namespaceentt.html#aa883472f0bd195810aaf482c55f18dcd',1,'entt::resolve(Op op) ENTT_NOEXCEPT']]], + ['resource_5fcache',['resource_cache',['../classentt_1_1resource__cache.html',1,'entt::resource_cache< Resource >'],['../classentt_1_1resource__cache.html#a919d10578aeda6ad9dd04e1b969b8a9c',1,'entt::resource_cache::resource_cache()=default'],['../classentt_1_1resource__cache.html#ac785934919090b5755a87ab34804b163',1,'entt::resource_cache::resource_cache(resource_cache &&)=default']]], + ['resource_5fcache_3c_20resource_20_3e',['resource_cache< Resource >',['../classentt_1_1resource__handle.html#aa58438d97a0e80057bbb837e2a4477d6',1,'entt::resource_handle::resource_cache< Resource >()'],['../classentt_1_1resource__loader.html#aa58438d97a0e80057bbb837e2a4477d6',1,'entt::resource_loader::resource_cache< Resource >()']]], + ['resource_5fhandle',['resource_handle',['../classentt_1_1resource__handle.html',1,'entt::resource_handle< Resource >'],['../classentt_1_1resource__handle.html#ac0346238aa57dbf5df3ce775ceba856f',1,'entt::resource_handle::resource_handle()']]], + ['resource_5floader',['resource_loader',['../classentt_1_1resource__loader.html',1,'entt']]], + ['resource_5ftype',['resource_type',['../classentt_1_1resource__cache.html#a178e741d1df5b41b0d27f814b6d061a7',1,'entt::resource_cache']]], + ['respect',['respect',['../classentt_1_1sparse__set.html#a600c39f7f77c58a71eb75eef32916e9d',1,'entt::sparse_set::respect()'],['../classentt_1_1basic__storage.html#aac84c253cdf3bf0357d6d729a7430635',1,'entt::basic_storage::respect()']]], + ['ret',['ret',['../classentt_1_1meta__func.html#a6a1bfe7f9b2e8c833dbfb5dff75bf1e9',1,'entt::meta_func']]], + ['runtime_5fview',['runtime_view',['../classentt_1_1basic__registry.html#af1f17548d9527797e366f610e9de36f6',1,'entt::basic_registry::runtime_view()'],['../namespaceentt.html#a85d470a55d982d87388e899c322e9ddc',1,'entt::runtime_view()']]] ]; diff --git a/search/classes_0.js b/search/classes_0.js index 20bbe603f..e677ff425 100644 --- a/search/classes_0.js +++ b/search/classes_0.js @@ -1,8 +1,5 @@ var searchData= [ - ['actor',['Actor',['../structentt_1_1Actor.html',1,'entt']]], - ['attachee',['Attachee',['../classentt_1_1Attachee.html',1,'entt']]], - ['attachee_3c_20entity_20_3e',['Attachee< Entity >',['../classentt_1_1Attachee_3_01Entity_01_4.html',1,'entt']]], - ['attachee_3c_20entity_2c_20tag_20_3e',['Attachee< Entity, Tag >',['../classentt_1_1Attachee.html',1,'entt']]], - ['attachee_3c_20entity_2c_20type_20_3e',['Attachee< Entity, Type >',['../classentt_1_1Attachee_3_01Entity_00_01Type_01_4.html',1,'entt']]] + ['as_5fgroup',['as_group',['../structentt_1_1as__group.html',1,'entt']]], + ['as_5fview',['as_view',['../structentt_1_1as__view.html',1,'entt']]] ]; diff --git a/search/classes_1.js b/search/classes_1.js index 04e65fe42..87de2ff88 100644 --- a/search/classes_1.js +++ b/search/classes_1.js @@ -1,5 +1,19 @@ var searchData= [ - ['connection',['Connection',['../structentt_1_1Emitter_1_1Connection.html',1,'entt::Emitter']]], - ['continuousloader',['ContinuousLoader',['../classentt_1_1ContinuousLoader.html',1,'entt']]] + ['basic_5factor',['basic_actor',['../structentt_1_1basic__actor.html',1,'entt']]], + ['basic_5fcontinuous_5floader',['basic_continuous_loader',['../classentt_1_1basic__continuous__loader.html',1,'entt']]], + ['basic_5fgroup',['basic_group',['../classentt_1_1basic__group.html',1,'entt']]], + ['basic_5fgroup_3c_20entity_2c_20get_5ft_3c_20get_2e_2e_2e_20_3e_20_3e',['basic_group< Entity, get_t< Get... > >',['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html',1,'entt']]], + ['basic_5fgroup_3c_20entity_2c_20get_5ft_3c_20get_2e_2e_2e_20_3e_2c_20owned_2e_2e_2e_20_3e',['basic_group< Entity, get_t< Get... >, Owned... >',['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html',1,'entt']]], + ['basic_5fprototype',['basic_prototype',['../classentt_1_1basic__prototype.html',1,'entt']]], + ['basic_5fregistry',['basic_registry',['../classentt_1_1basic__registry.html',1,'entt']]], + ['basic_5fruntime_5fview',['basic_runtime_view',['../classentt_1_1basic__runtime__view.html',1,'entt']]], + ['basic_5fsnapshot',['basic_snapshot',['../classentt_1_1basic__snapshot.html',1,'entt']]], + ['basic_5fsnapshot_5floader',['basic_snapshot_loader',['../classentt_1_1basic__snapshot__loader.html',1,'entt']]], + ['basic_5fstorage',['basic_storage',['../classentt_1_1basic__storage.html',1,'entt']]], + ['basic_5fstorage_3c_20entity_2c_20component_20_3e',['basic_storage< Entity, Component >',['../classentt_1_1basic__storage.html',1,'entt']]], + ['basic_5fstorage_3c_20entity_2c_20type_20_3e',['basic_storage< Entity, Type >',['../classentt_1_1basic__storage.html',1,'entt']]], + ['basic_5fstorage_3c_20entity_2c_20type_2c_20std_3a_3aenable_5fif_5ft_3c_20std_3a_3ais_5fempty_5fv_3c_20type_20_3e_20_3e_20_3e',['basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >',['../classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty__v_3_01Type_01_4_01_4_01_4.html',1,'entt']]], + ['basic_5fview',['basic_view',['../classentt_1_1basic__view.html',1,'entt']]], + ['basic_5fview_3c_20entity_2c_20component_20_3e',['basic_view< Entity, Component >',['../classentt_1_1basic__view_3_01Entity_00_01Component_01_4.html',1,'entt']]] ]; diff --git a/search/classes_2.js b/search/classes_2.js index 6d041ec87..cfe2060b8 100644 --- a/search/classes_2.js +++ b/search/classes_2.js @@ -1,6 +1,5 @@ var searchData= [ - ['delegate',['Delegate',['../classentt_1_1Delegate.html',1,'entt']]], - ['delegate_3c_20ret_28args_2e_2e_2e_29_3e',['Delegate< Ret(Args...)>',['../classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html',1,'entt']]], - ['dispatcher',['Dispatcher',['../classentt_1_1Dispatcher.html',1,'entt']]] + ['connect_5farg_5ft',['connect_arg_t',['../structentt_1_1connect__arg__t.html',1,'entt']]], + ['connection',['connection',['../structentt_1_1emitter_1_1connection.html',1,'entt::emitter']]] ]; diff --git a/search/classes_3.js b/search/classes_3.js index f279024a9..df1b72943 100644 --- a/search/classes_3.js +++ b/search/classes_3.js @@ -1,8 +1,6 @@ var searchData= [ - ['emitter',['Emitter',['../classentt_1_1Emitter.html',1,'entt']]], - ['entt_5ftraits',['entt_traits',['../structentt_1_1entt__traits.html',1,'entt']]], - ['entt_5ftraits_3c_20std_3a_3auint16_5ft_20_3e',['entt_traits< std::uint16_t >',['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html',1,'entt']]], - ['entt_5ftraits_3c_20std_3a_3auint32_5ft_20_3e',['entt_traits< std::uint32_t >',['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html',1,'entt']]], - ['entt_5ftraits_3c_20std_3a_3auint64_5ft_20_3e',['entt_traits< std::uint64_t >',['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html',1,'entt']]] + ['delegate',['delegate',['../classentt_1_1delegate.html',1,'entt']]], + ['delegate_3c_20ret_28args_2e_2e_2e_29_3e',['delegate< Ret(Args...)>',['../classentt_1_1delegate_3_01Ret_07Args_8_8_8_08_4.html',1,'entt']]], + ['dispatcher',['dispatcher',['../classentt_1_1dispatcher.html',1,'entt']]] ]; diff --git a/search/classes_4.js b/search/classes_4.js index 7a95d181c..cde80dac8 100644 --- a/search/classes_4.js +++ b/search/classes_4.js @@ -1,4 +1,9 @@ var searchData= [ - ['family',['Family',['../classentt_1_1Family.html',1,'entt']]] + ['emitter',['emitter',['../classentt_1_1emitter.html',1,'entt']]], + ['entt_5ftraits',['entt_traits',['../structentt_1_1entt__traits.html',1,'entt']]], + ['entt_5ftraits_3c_20std_3a_3auint16_5ft_20_3e',['entt_traits< std::uint16_t >',['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html',1,'entt']]], + ['entt_5ftraits_3c_20std_3a_3auint32_5ft_20_3e',['entt_traits< std::uint32_t >',['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html',1,'entt']]], + ['entt_5ftraits_3c_20std_3a_3auint64_5ft_20_3e',['entt_traits< std::uint64_t >',['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html',1,'entt']]], + ['exclude_5ft',['exclude_t',['../structentt_1_1exclude__t.html',1,'entt']]] ]; diff --git a/search/classes_5.js b/search/classes_5.js index 3adab7ae7..c9c7a62ef 100644 --- a/search/classes_5.js +++ b/search/classes_5.js @@ -1,4 +1,4 @@ var searchData= [ - ['hashedstring',['HashedString',['../classentt_1_1HashedString.html',1,'entt']]] + ['family',['family',['../classentt_1_1family.html',1,'entt']]] ]; diff --git a/search/classes_6.js b/search/classes_6.js index b153b39ae..d7631695f 100644 --- a/search/classes_6.js +++ b/search/classes_6.js @@ -1,5 +1,4 @@ var searchData= [ - ['identifier',['Identifier',['../classentt_1_1Identifier.html',1,'entt']]], - ['insertionsort',['InsertionSort',['../structentt_1_1InsertionSort.html',1,'entt']]] + ['get_5ft',['get_t',['../structentt_1_1get__t.html',1,'entt']]] ]; diff --git a/search/classes_7.js b/search/classes_7.js index 15cc5ce97..c73e48e1b 100644 --- a/search/classes_7.js +++ b/search/classes_7.js @@ -1,4 +1,4 @@ var searchData= [ - ['monostate',['Monostate',['../structentt_1_1Monostate.html',1,'entt']]] + ['hashed_5fstring',['hashed_string',['../classentt_1_1hashed__string.html',1,'entt']]] ]; diff --git a/search/classes_8.js b/search/classes_8.js index 48cb2fab0..5bdfb7b15 100644 --- a/search/classes_8.js +++ b/search/classes_8.js @@ -1,4 +1,7 @@ var searchData= [ - ['oneshotbubblesort',['OneShotBubbleSort',['../structentt_1_1OneShotBubbleSort.html',1,'entt']]] + ['identifier',['identifier',['../classentt_1_1identifier.html',1,'entt']]], + ['insertion_5fsort',['insertion_sort',['../structentt_1_1insertion__sort.html',1,'entt']]], + ['is_5fnamed_5ftype',['is_named_type',['../structentt_1_1is__named__type.html',1,'entt']]], + ['is_5fnamed_5ftype_3c_20type_2c_20std_3a_3avoid_5ft_3c_20named_5ftype_5ftraits_5ft_3c_20std_3a_3adecay_5ft_3c_20type_20_3e_20_3e_20_3e_20_3e',['is_named_type< Type, std::void_t< named_type_traits_t< std::decay_t< Type > > > >',['../structentt_1_1is__named__type_3_01Type_00_01std_1_1void__t_3_01named__type__traits__t_3_01std_1_268fa5a871b2de95e24d77c0786df19e.html',1,'entt']]] ]; diff --git a/search/classes_9.js b/search/classes_9.js index 3820dea84..974e5a53d 100644 --- a/search/classes_9.js +++ b/search/classes_9.js @@ -1,9 +1,15 @@ var searchData= [ - ['persistent_5ft',['persistent_t',['../structentt_1_1persistent__t.html',1,'entt']]], - ['persistentview',['PersistentView',['../classentt_1_1PersistentView.html',1,'entt']]], - ['process',['Process',['../classentt_1_1Process.html',1,'entt']]], - ['process_3c_20processadaptor_3c_20func_2c_20delta_20_3e_2c_20delta_20_3e',['Process< ProcessAdaptor< Func, Delta >, Delta >',['../classentt_1_1Process.html',1,'entt']]], - ['processadaptor',['ProcessAdaptor',['../structentt_1_1ProcessAdaptor.html',1,'entt']]], - ['prototype',['Prototype',['../classentt_1_1Prototype.html',1,'entt']]] + ['meta_5fany',['meta_any',['../classentt_1_1meta__any.html',1,'entt']]], + ['meta_5fbase',['meta_base',['../classentt_1_1meta__base.html',1,'entt']]], + ['meta_5fconv',['meta_conv',['../classentt_1_1meta__conv.html',1,'entt']]], + ['meta_5fctor',['meta_ctor',['../classentt_1_1meta__ctor.html',1,'entt']]], + ['meta_5fdata',['meta_data',['../classentt_1_1meta__data.html',1,'entt']]], + ['meta_5fdtor',['meta_dtor',['../classentt_1_1meta__dtor.html',1,'entt']]], + ['meta_5ffactory',['meta_factory',['../classentt_1_1meta__factory.html',1,'entt']]], + ['meta_5ffunc',['meta_func',['../classentt_1_1meta__func.html',1,'entt']]], + ['meta_5fhandle',['meta_handle',['../classentt_1_1meta__handle.html',1,'entt']]], + ['meta_5fprop',['meta_prop',['../classentt_1_1meta__prop.html',1,'entt']]], + ['meta_5ftype',['meta_type',['../classentt_1_1meta__type.html',1,'entt']]], + ['monostate',['monostate',['../structentt_1_1monostate.html',1,'entt']]] ]; diff --git a/search/classes_a.js b/search/classes_a.js index 6154b5021..e443e785a 100644 --- a/search/classes_a.js +++ b/search/classes_a.js @@ -1,10 +1,6 @@ var searchData= [ - ['raw_5ft',['raw_t',['../structentt_1_1raw__t.html',1,'entt']]], - ['rawview',['RawView',['../classentt_1_1RawView.html',1,'entt']]], - ['registry',['Registry',['../classentt_1_1Registry.html',1,'entt']]], - ['resourcecache',['ResourceCache',['../classentt_1_1ResourceCache.html',1,'entt']]], - ['resourcehandle',['ResourceHandle',['../classentt_1_1ResourceHandle.html',1,'entt']]], - ['resourceloader',['ResourceLoader',['../classentt_1_1ResourceLoader.html',1,'entt']]], - ['runtimeview',['RuntimeView',['../classentt_1_1RuntimeView.html',1,'entt']]] + ['named_5ftype_5ftraits',['named_type_traits',['../structentt_1_1named__type__traits.html',1,'entt']]], + ['named_5ftype_5ftraits_3c_20const_20type_20_3e',['named_type_traits< const Type >',['../structentt_1_1named__type__traits_3_01const_01Type_01_4.html',1,'entt']]], + ['named_5ftype_5ftraits_3c_20type_20_3e',['named_type_traits< Type >',['../structentt_1_1named__type__traits.html',1,'entt']]] ]; diff --git a/search/classes_b.js b/search/classes_b.js index 9be2b977c..9dd36312b 100644 --- a/search/classes_b.js +++ b/search/classes_b.js @@ -1,18 +1,6 @@ var searchData= [ - ['scheduler',['Scheduler',['../classentt_1_1Scheduler.html',1,'entt']]], - ['servicelocator',['ServiceLocator',['../structentt_1_1ServiceLocator.html',1,'entt']]], - ['sigh',['SigH',['../classentt_1_1SigH.html',1,'entt']]], - ['sigh_3c_20ret_28args_2e_2e_2e_29_2c_20collector_20_3e',['SigH< Ret(Args...), Collector >',['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html',1,'entt']]], - ['sigh_3c_20void_28const_20event_20_26_29_3e',['SigH< void(const Event &)>',['../classentt_1_1SigH.html',1,'entt']]], - ['sigh_3c_20void_28registry_20_26_2c_20const_20entity_29_3e',['SigH< void(Registry &, const Entity)>',['../classentt_1_1SigH.html',1,'entt']]], - ['sink',['Sink',['../classentt_1_1Sink.html',1,'entt']]], - ['sink_3c_20ret_28args_2e_2e_2e_29_3e',['Sink< Ret(Args...)>',['../classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html',1,'entt']]], - ['snapshot',['Snapshot',['../classentt_1_1Snapshot.html',1,'entt']]], - ['snapshotloader',['SnapshotLoader',['../classentt_1_1SnapshotLoader.html',1,'entt']]], - ['sparseset',['SparseSet',['../classentt_1_1SparseSet.html',1,'entt']]], - ['sparseset_3c_20entity_20_3e',['SparseSet< Entity >',['../classentt_1_1SparseSet_3_01Entity_01_4.html',1,'entt']]], - ['sparseset_3c_20entity_2c_20component_20_3e',['SparseSet< Entity, Component >',['../classentt_1_1SparseSet.html',1,'entt']]], - ['sparseset_3c_20entity_2c_20type_20_3e',['SparseSet< Entity, Type >',['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html',1,'entt']]], - ['stdsort',['StdSort',['../structentt_1_1StdSort.html',1,'entt']]] + ['process',['process',['../classentt_1_1process.html',1,'entt']]], + ['process_3c_20process_5fadaptor_3c_20func_2c_20delta_20_3e_2c_20delta_20_3e',['process< process_adaptor< Func, Delta >, Delta >',['../classentt_1_1process.html',1,'entt']]], + ['process_5fadaptor',['process_adaptor',['../structentt_1_1process__adaptor.html',1,'entt']]] ]; diff --git a/search/classes_c.js b/search/classes_c.js index 467e6c4c1..acf55d25e 100644 --- a/search/classes_c.js +++ b/search/classes_c.js @@ -1,4 +1,6 @@ var searchData= [ - ['tag_5ft',['tag_t',['../structentt_1_1tag__t.html',1,'entt']]] + ['resource_5fcache',['resource_cache',['../classentt_1_1resource__cache.html',1,'entt']]], + ['resource_5fhandle',['resource_handle',['../classentt_1_1resource__handle.html',1,'entt']]], + ['resource_5floader',['resource_loader',['../classentt_1_1resource__loader.html',1,'entt']]] ]; diff --git a/search/classes_d.js b/search/classes_d.js index adad9ed1c..9d1da7389 100644 --- a/search/classes_d.js +++ b/search/classes_d.js @@ -1,5 +1,17 @@ var searchData= [ - ['view',['View',['../classentt_1_1View.html',1,'entt']]], - ['view_3c_20entity_2c_20component_20_3e',['View< Entity, Component >',['../classentt_1_1View_3_01Entity_00_01Component_01_4.html',1,'entt']]] + ['scheduler',['scheduler',['../classentt_1_1scheduler.html',1,'entt']]], + ['service_5flocator',['service_locator',['../structentt_1_1service__locator.html',1,'entt']]], + ['sigh',['sigh',['../structentt_1_1sigh.html',1,'entt']]], + ['sigh_3c_20ret_28args_2e_2e_2e_29_2c_20collector_20_3e',['sigh< Ret(Args...), Collector >',['../structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html',1,'entt']]], + ['sigh_3c_20void_28const_20event_20_26_29_3e',['sigh< void(const Event &)>',['../structentt_1_1sigh.html',1,'entt']]], + ['sigh_3c_20void_28entt_3a_3abasic_5fregistry_20_26_2c_20const_20entity_29_3e',['sigh< void(entt::basic_registry &, const Entity)>',['../structentt_1_1sigh.html',1,'entt']]], + ['sigh_3c_20void_28entt_3a_3abasic_5fregistry_20_26_2c_20const_20entity_2c_20std_3a_3aconditional_5ft_3c_20std_3a_3ais_5fempty_5fv_3c_20component_20_3e_2c_20const_20component_20_26_2c_20component_20_26_3e_29_3e',['sigh< void(entt::basic_registry &, const Entity, std::conditional_t< std::is_empty_v< Component >, const Component &, Component &>)>',['../structentt_1_1sigh.html',1,'entt']]], + ['sink',['sink',['../classentt_1_1sink.html',1,'entt']]], + ['sink_3c_20ret_28args_2e_2e_2e_29_3e',['sink< Ret(Args...)>',['../classentt_1_1sink_3_01Ret_07Args_8_8_8_08_4.html',1,'entt']]], + ['sparse_5fset',['sparse_set',['../classentt_1_1sparse__set.html',1,'entt']]], + ['sparse_5fset_3c_20entity_5ftype_20_3e',['sparse_set< entity_type >',['../classentt_1_1sparse__set.html',1,'entt']]], + ['std_5fsort',['std_sort',['../structentt_1_1std__sort.html',1,'entt']]], + ['storage',['storage',['../structentt_1_1storage.html',1,'entt']]], + ['storage_3c_20entity_2c_20component_20_3e',['storage< Entity, Component >',['../structentt_1_1storage.html',1,'entt']]] ]; diff --git a/search/classes_e.js b/search/classes_e.js index adad9ed1c..225a05050 100644 --- a/search/classes_e.js +++ b/search/classes_e.js @@ -1,5 +1,11 @@ var searchData= [ - ['view',['View',['../classentt_1_1View.html',1,'entt']]], - ['view_3c_20entity_2c_20component_20_3e',['View< Entity, Component >',['../classentt_1_1View_3_01Entity_00_01Component_01_4.html',1,'entt']]] + ['type_5flist',['type_list',['../structentt_1_1type__list.html',1,'entt']]], + ['type_5flist_3c_20type_2e_2e_2e_20_3e',['type_list< Type... >',['../structentt_1_1type__list.html',1,'entt']]], + ['type_5flist_5fcat',['type_list_cat',['../structentt_1_1type__list__cat.html',1,'entt']]], + ['type_5flist_5fcat_3c_20type_5flist_3c_20type_2e_2e_2e_20_3e_20_3e',['type_list_cat< type_list< Type... > >',['../structentt_1_1type__list__cat_3_01type__list_3_01Type_8_8_8_01_4_01_4.html',1,'entt']]], + ['type_5flist_5fcat_3c_20type_5flist_3c_20type_2e_2e_2e_20_3e_2c_20type_5flist_3c_20other_2e_2e_2e_20_3e_2c_20list_2e_2e_2e_20_3e',['type_list_cat< type_list< Type... >, type_list< Other... >, List... >',['../structentt_1_1type__list__cat_3_01type__list_3_01Type_8_8_8_01_4_00_01type__list_3_01Other_8_8_8_01_4_00_01List_8_8_8_01_4.html',1,'entt']]], + ['type_5flist_5funique',['type_list_unique',['../structentt_1_1type__list__unique.html',1,'entt']]], + ['type_5flist_5funique_3c_20type_5flist_3c_20type_2c_20other_2e_2e_2e_20_3e_20_3e',['type_list_unique< type_list< Type, Other... > >',['../structentt_1_1type__list__unique_3_01type__list_3_01Type_00_01Other_8_8_8_01_4_01_4.html',1,'entt']]], + ['type_5flist_5funique_3c_20type_5flist_3c_3e_20_3e',['type_list_unique< type_list<> >',['../structentt_1_1type__list__unique_3_01type__list_3_4_01_4.html',1,'entt']]] ]; diff --git a/search/functions_0.js b/search/functions_0.js index 1ce570ecc..24f087c80 100644 --- a/search/functions_0.js +++ b/search/functions_0.js @@ -1,10 +1,11 @@ var searchData= [ - ['abort',['abort',['../classentt_1_1Process.html#ae7a9c2acd493969267ce4a6d2e2884b8',1,'entt::Process::abort()'],['../classentt_1_1Scheduler.html#af2494e025703d03a87117d6e897c87db',1,'entt::Scheduler::abort()']]], - ['accommodate',['accommodate',['../classentt_1_1Prototype.html#adaec9cc16436af85ef938fc9686cd02d',1,'entt::Prototype::accommodate(registry_type &other, const entity_type dst) const'],['../classentt_1_1Prototype.html#a37299298c61bb06a75b697296e328477',1,'entt::Prototype::accommodate(const entity_type dst) const'],['../classentt_1_1Registry.html#a6333a56f3a5a58882963a11bbbcf2ac2',1,'entt::Registry::accommodate()']]], - ['actor',['Actor',['../structentt_1_1Actor.html#a000a099327600af5eaf86990fe886260',1,'entt::Actor::Actor(Registry< Entity > &reg)'],['../structentt_1_1Actor.html#a68a0a3b98e601615fca06a35bb68f47f',1,'entt::Actor::Actor(const Actor &)=delete'],['../structentt_1_1Actor.html#a74b71918643b7d02c8788db1b9b5cae6',1,'entt::Actor::Actor(Actor &&other)']]], - ['alive',['alive',['../classentt_1_1Registry.html#a4288576a8d41018b63838d4afdd01717',1,'entt::Registry::alive()'],['../classentt_1_1Process.html#ad18ce3558d2325d622fb2b8ab51c49d5',1,'entt::Process::alive()']]], - ['assign',['assign',['../structentt_1_1Actor.html#a0a161248d739e780833e534f7d1cf638',1,'entt::Actor::assign(tag_t, Args &&... args)'],['../structentt_1_1Actor.html#a7631fdb2de787c10b016a71905906147',1,'entt::Actor::assign(Args &&... args)'],['../classentt_1_1Prototype.html#a0a52cda550a678ee14272cff7b2fcf35',1,'entt::Prototype::assign(registry_type &other, const entity_type dst) const'],['../classentt_1_1Prototype.html#ab7bf733f40f1071d73d4f3245526c038',1,'entt::Prototype::assign(const entity_type dst) const'],['../classentt_1_1Registry.html#a93b5717af287a2b97e0ef9695c51ed58',1,'entt::Registry::assign(tag_t, const entity_type entity, Args &&... args)'],['../classentt_1_1Registry.html#a01f87450271067dda6c87f0c7c9b80dd',1,'entt::Registry::assign(const entity_type entity, Args &&... args)']]], - ['attach',['attach',['../classentt_1_1Scheduler.html#a1a836000f65e8e275119c0f77ec46674',1,'entt::Scheduler::attach(Args &&... args)'],['../classentt_1_1Scheduler.html#a5915b9783b278a6006d4857feefc0e3b',1,'entt::Scheduler::attach(Func &&func)']]], - ['attachee',['Attachee',['../classentt_1_1Attachee_3_01Entity_01_4.html#a8774e0674c802952e298261b42dfdea2',1,'entt::Attachee< Entity >::Attachee() ENTT_NOEXCEPT'],['../classentt_1_1Attachee_3_01Entity_01_4.html#a3dc6b5bc229adf6e7decef65d3931575',1,'entt::Attachee< Entity >::Attachee(const Attachee &)=default'],['../classentt_1_1Attachee_3_01Entity_01_4.html#a436f1d599b6a4917185bc57dae3b5647',1,'entt::Attachee< Entity >::Attachee(Attachee &&)=default'],['../classentt_1_1Attachee_3_01Entity_00_01Type_01_4.html#a43dba4f726b1aced4c954e79d259a360',1,'entt::Attachee< Entity, Type >::Attachee() ENTT_NOEXCEPT=default'],['../classentt_1_1Attachee_3_01Entity_00_01Type_01_4.html#a806774cdf9c04019f8142c76738774b2',1,'entt::Attachee< Entity, Type >::Attachee(const Attachee &)=delete'],['../classentt_1_1Attachee_3_01Entity_00_01Type_01_4.html#ae1af322496b316594ce46022e49bf0ed',1,'entt::Attachee< Entity, Type >::Attachee(Attachee &&)=delete'],['../classentt_1_1Registry.html#af157dcabe4fe027e2f9cd45f4958f3b9',1,'entt::Registry::attachee()']]] + ['abort',['abort',['../classentt_1_1process.html#a0a45fb64300d51aa0f826609d11a3f78',1,'entt::process::abort()'],['../classentt_1_1scheduler.html#aabc25388bff1b3b0770f913f54b915f2',1,'entt::scheduler::abort()']]], + ['alive',['alive',['../classentt_1_1basic__registry.html#a65a49772b3d59dd39c76b24a62e0fdf4',1,'entt::basic_registry::alive()'],['../classentt_1_1process.html#a8bc92bd0304659eb2a034fae65f1eeb9',1,'entt::process::alive()']]], + ['arg',['arg',['../classentt_1_1meta__ctor.html#a3faab3b8c49ee1b803f337435c8d54ce',1,'entt::meta_ctor::arg()'],['../classentt_1_1meta__func.html#a34709d9f0a7498382ced3a4e2daa64ba',1,'entt::meta_func::arg()']]], + ['as_5fgroup',['as_group',['../structentt_1_1as__group.html#a7ebe095efa7c1e00e2f156ad7930d9a9',1,'entt::as_group::as_group()'],['../namespaceentt.html#a6609f31d6ab3f544ebf7d0413d007ead',1,'entt::as_group(basic_registry< Entity > &) ENTT_NOEXCEPT -> as_group< false, Entity >'],['../namespaceentt.html#a8fce796266ac507c9b0c193a70f51745',1,'entt::as_group(const basic_registry< Entity > &) ENTT_NOEXCEPT -> as_group< true, Entity >']]], + ['as_5fview',['as_view',['../structentt_1_1as__view.html#a820ab4da509a0fb60c4edf8ea24b748a',1,'entt::as_view::as_view()'],['../namespaceentt.html#a3fee75741468f7807d3d48dd807ee024',1,'entt::as_view(basic_registry< Entity > &) ENTT_NOEXCEPT -> as_view< false, Entity >'],['../namespaceentt.html#aac314d83c9af1077857f01975f086bed',1,'entt::as_view(const basic_registry< Entity > &) ENTT_NOEXCEPT -> as_view< true, Entity >']]], + ['assign',['assign',['../structentt_1_1basic__actor.html#abf572e19a5d9625fbf80cc4f00cba032',1,'entt::basic_actor::assign()'],['../classentt_1_1basic__prototype.html#a0a5c5313d46f5f52977e7fc3fe93d865',1,'entt::basic_prototype::assign(registry_type &other, const entity_type dst) const'],['../classentt_1_1basic__prototype.html#a6062b4ed6fcf6053ea748b235db47807',1,'entt::basic_prototype::assign(const entity_type dst) const'],['../classentt_1_1basic__registry.html#a3deb5b8f14eb1414c92e6ccb2065ce0e',1,'entt::basic_registry::assign()']]], + ['assign_5for_5freplace',['assign_or_replace',['../classentt_1_1basic__prototype.html#ad8cc32084b579a727669e8f0e7b600a9',1,'entt::basic_prototype::assign_or_replace(registry_type &other, const entity_type dst) const'],['../classentt_1_1basic__prototype.html#a2884b160480a2e26acefd0d47316c26d',1,'entt::basic_prototype::assign_or_replace(const entity_type dst) const'],['../classentt_1_1basic__registry.html#aa013d9c67f8fda068f616aa9bb66b564',1,'entt::basic_registry::assign_or_replace()']]], + ['attach',['attach',['../classentt_1_1scheduler.html#a729c83e1983123c642a08cda67e486e3',1,'entt::scheduler::attach(Args &&... args)'],['../classentt_1_1scheduler.html#a871812d08af8483316d1ce5d1e9d686f',1,'entt::scheduler::attach(Func &&func)']]] ]; diff --git a/search/functions_1.js b/search/functions_1.js index 59542535f..9b23f50e3 100644 --- a/search/functions_1.js +++ b/search/functions_1.js @@ -1,4 +1,13 @@ var searchData= [ - ['begin',['begin',['../classentt_1_1SparseSet_3_01Entity_01_4.html#aebd9c479dc54907cf42a4423f34edeb2',1,'entt::SparseSet< Entity >::begin() const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a6b33b62684d62255ca53a371cfbe1d28',1,'entt::SparseSet< Entity >::begin() ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a6f177729ba483b37119881db872b7736',1,'entt::SparseSet< Entity, Type >::begin() const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#aef10db6199e31f72c14c4be9347b0822',1,'entt::SparseSet< Entity, Type >::begin() ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#af1469f9dd45ebc68729e88e741c465a4',1,'entt::PersistentView::begin() const ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#a6bb6ca7b9dbbbf6da3f2cf7250a61075',1,'entt::PersistentView::begin() ENTT_NOEXCEPT'],['../classentt_1_1View.html#a7c59406241bd142289a0d618a33f98d3',1,'entt::View::begin() const ENTT_NOEXCEPT'],['../classentt_1_1View.html#a5d4b1ac137a2dd3ac7f8f91a40b6eb0e',1,'entt::View::begin() ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a7c59406241bd142289a0d618a33f98d3',1,'entt::View< Entity, Component >::begin() const ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a5d4b1ac137a2dd3ac7f8f91a40b6eb0e',1,'entt::View< Entity, Component >::begin() ENTT_NOEXCEPT'],['../classentt_1_1RawView.html#a564cc60d60b8d80aefca967eea79031f',1,'entt::RawView::begin() const ENTT_NOEXCEPT'],['../classentt_1_1RawView.html#a195eb860ca3f49f72fc08e4505431286',1,'entt::RawView::begin() ENTT_NOEXCEPT'],['../classentt_1_1RuntimeView.html#af1fb74dd84e6ffd0f8626b8f0f55af91',1,'entt::RuntimeView::begin() const ENTT_NOEXCEPT'],['../classentt_1_1RuntimeView.html#a8b424a07dd1fdca3a11103dbc6ad76ac',1,'entt::RuntimeView::begin() ENTT_NOEXCEPT']]] + ['backend',['backend',['../structentt_1_1basic__actor.html#a079bddd72566b14843729a154a8f684e',1,'entt::basic_actor::backend() const ENTT_NOEXCEPT'],['../structentt_1_1basic__actor.html#a827ed2e23e39e8b706f7acc511a46024',1,'entt::basic_actor::backend() ENTT_NOEXCEPT'],['../classentt_1_1basic__prototype.html#a3eca09d9203b3ad97d6663e0bf5bb2f8',1,'entt::basic_prototype::backend() const ENTT_NOEXCEPT'],['../classentt_1_1basic__prototype.html#ac6cdd27694a8e9e2bdb576ffca098e1b',1,'entt::basic_prototype::backend() ENTT_NOEXCEPT']]], + ['base',['base',['../classentt_1_1meta__factory.html#a08184dab6a4da744ad630ede2ac0856b',1,'entt::meta_factory::base()'],['../classentt_1_1meta__type.html#a03961322c038576a874fd927a407d14e',1,'entt::meta_type::base(Op op) const ENTT_NOEXCEPT'],['../classentt_1_1meta__type.html#a987d41f4887a6b9c1a710969d1e7e825',1,'entt::meta_type::base(const char *str) const ENTT_NOEXCEPT']]], + ['basic_5factor',['basic_actor',['../structentt_1_1basic__actor.html#a32635ae3046ebca665adef6b3ef87ef3',1,'entt::basic_actor::basic_actor(registry_type &ref)'],['../structentt_1_1basic__actor.html#a8c86ac43873d5b42c1774ea6646513e0',1,'entt::basic_actor::basic_actor(basic_actor &&other)']]], + ['basic_5fcontinuous_5floader',['basic_continuous_loader',['../classentt_1_1basic__continuous__loader.html#a18d87fd5fc80f062ae27b90ef3232bd8',1,'entt::basic_continuous_loader::basic_continuous_loader(basic_registry< entity_type > &source) ENTT_NOEXCEPT'],['../classentt_1_1basic__continuous__loader.html#a619f3aa278b405481fd1e26c46a96a5c',1,'entt::basic_continuous_loader::basic_continuous_loader(basic_continuous_loader &&)=default']]], + ['basic_5fprototype',['basic_prototype',['../classentt_1_1basic__prototype.html#acffae325962a54170176025d67d38a80',1,'entt::basic_prototype::basic_prototype(registry_type &ref)'],['../classentt_1_1basic__prototype.html#a1592ff421e77a624830cb965c6f52110',1,'entt::basic_prototype::basic_prototype(basic_prototype &&other)']]], + ['basic_5fregistry',['basic_registry',['../classentt_1_1basic__registry.html#af976c68848de4fa6db6dea2b4cf76e77',1,'entt::basic_registry::basic_registry() ENTT_NOEXCEPT=default'],['../classentt_1_1basic__registry.html#a3fc181b150fee3e42b8cad4103953b9f',1,'entt::basic_registry::basic_registry(basic_registry &&)=default']]], + ['basic_5fsnapshot',['basic_snapshot',['../classentt_1_1basic__snapshot.html#a10f658d8e4feb7df9da8b48119551334',1,'entt::basic_snapshot']]], + ['basic_5fsnapshot_5floader',['basic_snapshot_loader',['../classentt_1_1basic__snapshot__loader.html#acc078b2e9068ae41a2910168b40322d4',1,'entt::basic_snapshot_loader']]], + ['batch',['batch',['../classentt_1_1sparse__set.html#a642460f7f0ca8e42220c43c785467063',1,'entt::sparse_set::batch()'],['../classentt_1_1basic__storage.html#ab6d4fdce9c54a7468eed85423d82e520',1,'entt::basic_storage::batch()']]], + ['begin',['begin',['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#aa68f0d2a68100cb41d5413063b22eb27',1,'entt::basic_group< Entity, get_t< Get... > >::begin()'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html#a8076bfc4e22d1b1e8b42fbd9cc1c0c68',1,'entt::basic_group< Entity, get_t< Get... >, Owned... >::begin()'],['../classentt_1_1basic__runtime__view.html#af47b1aff2d44990f17c9740cf24a2670',1,'entt::basic_runtime_view::begin()'],['../classentt_1_1sparse__set.html#a06743336f265989b48e106a3d3bd1562',1,'entt::sparse_set::begin()'],['../classentt_1_1basic__storage.html#aecc4b13b67a7664c5c36596f2b927bed',1,'entt::basic_storage::begin() const ENTT_NOEXCEPT'],['../classentt_1_1basic__storage.html#ab963b76ebe297a1ad4a2c433aa55f2b5',1,'entt::basic_storage::begin() ENTT_NOEXCEPT'],['../classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty__v_3_01Type_01_4_01_4_01_4.html#aa4a66c77a01df615cbdf02c07e184bd1',1,'entt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >::begin()'],['../classentt_1_1basic__view.html#a00d2bb01727273bf40acdf1a57588fc7',1,'entt::basic_view::begin()'],['../classentt_1_1basic__view_3_01Entity_00_01Component_01_4.html#a00d2bb01727273bf40acdf1a57588fc7',1,'entt::basic_view< Entity, Component >::begin()']]] ]; diff --git a/search/functions_10.js b/search/functions_10.js index adef06239..acea0b5f9 100644 --- a/search/functions_10.js +++ b/search/functions_10.js @@ -1,6 +1,15 @@ var searchData= [ - ['valid',['valid',['../classentt_1_1Registry.html#aaba72db4ebf99a911b58327063ec8ad9',1,'entt::Registry']]], - ['version',['version',['../classentt_1_1Registry.html#ad7467ac1c8a7657062b1b4386dded54e',1,'entt::Registry']]], - ['view',['view',['../classentt_1_1Registry.html#aed83d4c8f80ae647ee73f2a8440fa09d',1,'entt::Registry::view()'],['../classentt_1_1Registry.html#abb1eb5f1a2ec31d14b5b98271ff78f1e',1,'entt::Registry::view(persistent_t)'],['../classentt_1_1Registry.html#aedc2a2344c5d13a0483608d48189a92a',1,'entt::Registry::view(raw_t)'],['../classentt_1_1Registry.html#a4a157973e57670b5df3eedc8d137de7e',1,'entt::Registry::view(It first, It last)']]] + ['scheduler',['scheduler',['../classentt_1_1scheduler.html#a7b06b3a881b89c9d3b9829ccf111fae4',1,'entt::scheduler::scheduler() ENTT_NOEXCEPT=default'],['../classentt_1_1scheduler.html#af582ffea72368a83ea4dd7d9e563f715',1,'entt::scheduler::scheduler(scheduler &&)=default']]], + ['service_5flocator',['service_locator',['../structentt_1_1service__locator.html#a120cdb3eb1d820e5649f3d8bac8098d0',1,'entt::service_locator']]], + ['set',['set',['../classentt_1_1basic__prototype.html#afb3ed35c2b2edcca53a618116208ca94',1,'entt::basic_prototype::set()'],['../classentt_1_1basic__registry.html#a7d771eee6e8e573bf1b8e4e8501ea7f1',1,'entt::basic_registry::set()'],['../structentt_1_1service__locator.html#a116dc62f5d2a1c65db9d7528c957e91f',1,'entt::service_locator::set(Args &&... args)'],['../structentt_1_1service__locator.html#a86770e79d01ab5fb0dddffba0bf9a697',1,'entt::service_locator::set(std::shared_ptr< Service > ptr)'],['../classentt_1_1meta__data.html#a776f1d239c00cc96c683bbbd348119da',1,'entt::meta_data::set(meta_handle handle, Type &&value) const'],['../classentt_1_1meta__data.html#ae0a9924efdaedd5bec4ed37efa5e0671',1,'entt::meta_data::set(meta_handle handle, std::size_t index, Type &&value) const']]], + ['shrink',['shrink',['../classentt_1_1basic__continuous__loader.html#a01b949f4a5829bd5bf3738a7e0f776d2',1,'entt::basic_continuous_loader']]], + ['shrink_5fto_5ffit',['shrink_to_fit',['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#a40a638de8c83e543dea5d89fbe46d7a7',1,'entt::basic_group< Entity, get_t< Get... > >::shrink_to_fit()'],['../classentt_1_1basic__registry.html#a63aa387e557553d61483a58807cd785e',1,'entt::basic_registry::shrink_to_fit()'],['../classentt_1_1sparse__set.html#ad410641d1403e3b0c38c119511c6a54c',1,'entt::sparse_set::shrink_to_fit()'],['../classentt_1_1basic__storage.html#ab794e48f20864cd5db6c56aa85af315e',1,'entt::basic_storage::shrink_to_fit()']]], + ['sink',['sink',['../classentt_1_1dispatcher.html#afedd59083875621a11510b00c84c8878',1,'entt::dispatcher::sink()'],['../structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#a5e436274ab7f40394bf3272561db8d3a',1,'entt::sigh< Ret(Args...), Collector >::sink()']]], + ['size',['size',['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#a99b144072f6eda675eb3d272bfb5aec3',1,'entt::basic_group< Entity, get_t< Get... > >::size() const ENTT_NOEXCEPT'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#ab414ffe7acdf36c249c42d71812ec1e9',1,'entt::basic_group< Entity, get_t< Get... > >::size() const ENTT_NOEXCEPT'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html#ad62ba67afadc3b4c45298c65f672404a',1,'entt::basic_group< Entity, get_t< Get... >, Owned... >::size() const ENTT_NOEXCEPT'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html#abcf4e26f33e523318b7d640ce605b6d8',1,'entt::basic_group< Entity, get_t< Get... >, Owned... >::size() const ENTT_NOEXCEPT'],['../classentt_1_1basic__registry.html#abb5713726f7b5c4b67a0271a64bedd2f',1,'entt::basic_registry::size() const ENTT_NOEXCEPT'],['../classentt_1_1basic__registry.html#afdfc12e1ffa6bac72c2de9af7e91f44e',1,'entt::basic_registry::size() const ENTT_NOEXCEPT'],['../classentt_1_1basic__runtime__view.html#a8a14205c30a77fae500ff244a8f9041e',1,'entt::basic_runtime_view::size()'],['../classentt_1_1sparse__set.html#a340dff7484f1e58feff58a5f0627e190',1,'entt::sparse_set::size()'],['../classentt_1_1basic__view.html#a05e540230bfb537a7574da0f8d4eaaa5',1,'entt::basic_view::size() const ENTT_NOEXCEPT'],['../classentt_1_1basic__view.html#acb9ee6ba89ed94297808c4ee04d21f1e',1,'entt::basic_view::size() const ENTT_NOEXCEPT'],['../classentt_1_1basic__view_3_01Entity_00_01Component_01_4.html#acb9ee6ba89ed94297808c4ee04d21f1e',1,'entt::basic_view< Entity, Component >::size()'],['../classentt_1_1meta__ctor.html#ad0ac4a64b630462768a3f12f6389b6e7',1,'entt::meta_ctor::size()'],['../classentt_1_1meta__func.html#ae4bc5f5e90003362872d8cd056b2f689',1,'entt::meta_func::size()'],['../classentt_1_1scheduler.html#ab0c473e6d4733bdb78f3dc26147de4ad',1,'entt::scheduler::size()'],['../classentt_1_1resource__cache.html#a115fe363ea30ae2e6fe2d2c7420c672c',1,'entt::resource_cache::size()'],['../structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#a1c1a46bd4335d6c45e8a3e2b7223a0c7',1,'entt::sigh< Ret(Args...), Collector >::size()']]], + ['snapshot',['snapshot',['../classentt_1_1basic__registry.html#ad6ab9182dd41bc02ddfc0c3c8195a215',1,'entt::basic_registry']]], + ['sort',['sort',['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#a23d2a9946ff93ffe57b528db9a760e2e',1,'entt::basic_group< Entity, get_t< Get... > >::sort()'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html#a0464e3b686015ec92dbf0efecc8bcbd6',1,'entt::basic_group< Entity, get_t< Get... >, Owned... >::sort()'],['../classentt_1_1basic__registry.html#a38ac2a883e3d881c6ae5a05a0252b7ae',1,'entt::basic_registry::sort(Compare compare, Sort algo=Sort{}, Args &&... args)'],['../classentt_1_1basic__registry.html#a2907f89b80fb692b16727e5e67a91c5d',1,'entt::basic_registry::sort()'],['../classentt_1_1basic__storage.html#ac1ed30f50fdc3eb2f994e3b4440dcf32',1,'entt::basic_storage::sort()']]], + ['sparse_5fset',['sparse_set',['../classentt_1_1sparse__set.html#a8ef544aaed30126797f6f0b9a9f8b9e8',1,'entt::sparse_set::sparse_set()=default'],['../classentt_1_1sparse__set.html#af684a44e129f3aafd311814b5972378f',1,'entt::sparse_set::sparse_set(const sparse_set &other)'],['../classentt_1_1sparse__set.html#af8f4f137b5ac0984599067d5408db5bf',1,'entt::sparse_set::sparse_set(sparse_set &&)=default']]], + ['succeed',['succeed',['../classentt_1_1process.html#a43d63ba9304654f0209fc32d2c74f4ce',1,'entt::process']]], + ['swap',['swap',['../classentt_1_1sparse__set.html#a3777f32f6c173b65a922caa8058efc93',1,'entt::sparse_set']]] ]; diff --git a/search/functions_11.js b/search/functions_11.js index 35728c7ea..dfeecdc74 100644 --- a/search/functions_11.js +++ b/search/functions_11.js @@ -1,10 +1,11 @@ var searchData= [ - ['_7eactor',['~Actor',['../structentt_1_1Actor.html#a3ab5d325569b88346684a1cffd6bd633',1,'entt::Actor']]], - ['_7eattachee',['~Attachee',['../classentt_1_1Attachee_3_01Entity_01_4.html#a134cedd024e7adcd4332b2514f856111',1,'entt::Attachee< Entity >::~Attachee()'],['../classentt_1_1Attachee_3_01Entity_00_01Type_01_4.html#aa75f3b1253e049f669e92fef3ac237bc',1,'entt::Attachee< Entity, Type >::~Attachee()']]], - ['_7eemitter',['~Emitter',['../classentt_1_1Emitter.html#ac713dddc6b8f7b056e3c1a8979a4e271',1,'entt::Emitter']]], - ['_7eprocess',['~Process',['../classentt_1_1Process.html#abcfd11c007770ec8bd997333b00f5f8b',1,'entt::Process']]], - ['_7eprototype',['~Prototype',['../classentt_1_1Prototype.html#acb70104c3d32fcf22fbe37afa7602ed5',1,'entt::Prototype']]], - ['_7eservicelocator',['~ServiceLocator',['../structentt_1_1ServiceLocator.html#af0dc69f829f93c86b6537cf0c133ef75',1,'entt::ServiceLocator']]], - ['_7esparseset',['~SparseSet',['../classentt_1_1SparseSet_3_01Entity_01_4.html#a7a0a9d11f6b89102468b45ed83651bc8',1,'entt::SparseSet< Entity >']]] + ['temp',['temp',['../classentt_1_1resource__cache.html#a74d899246a6acf2414d6b149e12533c2',1,'entt::resource_cache']]], + ['tick',['tick',['../classentt_1_1process.html#aacc7fe0ef3265113079c70ff8cd9478d',1,'entt::process']]], + ['to_5fvalue',['to_value',['../classentt_1_1hashed__string.html#a1641786d9583eee4a5cd373a7df9449e',1,'entt::hashed_string::to_value(const char(&str)[N]) ENTT_NOEXCEPT'],['../classentt_1_1hashed__string.html#ac0e253c370cc1fb200211b7b3d485d97',1,'entt::hashed_string::to_value(const_wrapper wrapper) ENTT_NOEXCEPT'],['../classentt_1_1hashed__string.html#ade8d090abfa489e3f11554e0e362c540',1,'entt::hashed_string::to_value(const char *str, std::size_t size) ENTT_NOEXCEPT']]], + ['trigger',['trigger',['../classentt_1_1dispatcher.html#ac3d3eae7004c63f0232b09f2770c4ebd',1,'entt::dispatcher::trigger(Args &&... args)'],['../classentt_1_1dispatcher.html#a1d14234071d22c9fe09c453ebd818d2e',1,'entt::dispatcher::trigger(Event &&event)']]], + ['try_5fcast',['try_cast',['../classentt_1_1meta__handle.html#acb0127bdd270a55523492e6314cede51',1,'entt::meta_handle::try_cast() const ENTT_NOEXCEPT'],['../classentt_1_1meta__handle.html#a95f9e578c26fffc8880f985bfc8f8e04',1,'entt::meta_handle::try_cast() ENTT_NOEXCEPT']]], + ['try_5fctx',['try_ctx',['../classentt_1_1basic__registry.html#a33650f5792414c71ef00c3bcaca3f1d5',1,'entt::basic_registry::try_ctx() const ENTT_NOEXCEPT'],['../classentt_1_1basic__registry.html#a4182d11d18ec7873562c2842a332ac89',1,'entt::basic_registry::try_ctx() ENTT_NOEXCEPT']]], + ['try_5fget',['try_get',['../structentt_1_1basic__actor.html#ac37259d66c0a8f42b7e744567382c6c2',1,'entt::basic_actor::try_get() const ENTT_NOEXCEPT'],['../structentt_1_1basic__actor.html#a0320585b864c700d980212f37654a8a1',1,'entt::basic_actor::try_get() ENTT_NOEXCEPT'],['../classentt_1_1basic__prototype.html#a26c239c2d51cda5c0f5ff398d6a67f8c',1,'entt::basic_prototype::try_get() const ENTT_NOEXCEPT'],['../classentt_1_1basic__prototype.html#a59e50d3b0aabb00952322a72bdaa5c69',1,'entt::basic_prototype::try_get() ENTT_NOEXCEPT'],['../classentt_1_1basic__registry.html#a25c4412448ddcbfe1290f72498ae7809',1,'entt::basic_registry::try_get([[maybe_unused]] const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1basic__registry.html#a2c3ba909a2f845601a5b873c6bdd8371',1,'entt::basic_registry::try_get([[maybe_unused]] const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1basic__storage.html#aab7da23b603d6cc78e67b3509ad979fa',1,'entt::basic_storage::try_get(const entity_type entt) const ENTT_NOEXCEPT'],['../classentt_1_1basic__storage.html#a8ff9d6ef48840c8ad88f8c0b8b5dcd35',1,'entt::basic_storage::try_get(const entity_type entt) ENTT_NOEXCEPT']]], + ['type',['type',['../classentt_1_1basic__registry.html#a47bb003d6c82097e1c0d5a7d462f033e',1,'entt::basic_registry::type()'],['../classentt_1_1meta__any.html#a406ea303f140056a30103d90afab2737',1,'entt::meta_any::type()'],['../classentt_1_1meta__handle.html#aa8f78e22bdf61554c38f27575fd8cf33',1,'entt::meta_handle::type()'],['../classentt_1_1meta__base.html#a5e9f69b43cdc90add110654acde5e8b6',1,'entt::meta_base::type()'],['../classentt_1_1meta__conv.html#accdedbb8b1636f59967dc30ba5d7e753',1,'entt::meta_conv::type()'],['../classentt_1_1meta__data.html#a4d99cf1fb67d2bea840fa608dc95e64f',1,'entt::meta_data::type()']]] ]; diff --git a/search/functions_12.html b/search/functions_12.html new file mode 100644 index 000000000..3df848924 --- /dev/null +++ b/search/functions_12.html @@ -0,0 +1,26 @@ + + + + + + + + + +
+
Loading...
+
+ +
Searching...
+
No Matches
+ +
+ + diff --git a/search/functions_12.js b/search/functions_12.js new file mode 100644 index 000000000..f48342a63 --- /dev/null +++ b/search/functions_12.js @@ -0,0 +1,7 @@ +var searchData= +[ + ['unpause',['unpause',['../classentt_1_1process.html#a91fd8adb2ea48c88c6f9fb5818890f67',1,'entt::process']]], + ['unregister',['unregister',['../namespaceentt.html#a04658621584dae59cabe9863a38e0e7a',1,'entt']]], + ['unset',['unset',['../classentt_1_1basic__prototype.html#a05230038ddbafaca4d5da09dfb247186',1,'entt::basic_prototype::unset()'],['../classentt_1_1basic__registry.html#aaa23b74e76b1749bb510a86e9d31b9cd',1,'entt::basic_registry::unset()']]], + ['update',['update',['../structentt_1_1process__adaptor.html#a7514fabbbda491742872bc0e52dde5c2',1,'entt::process_adaptor::update()'],['../classentt_1_1scheduler.html#a827eae426378df9ed9190752156a4154',1,'entt::scheduler::update()'],['../classentt_1_1dispatcher.html#aabed6fd7fa4027dcfa3afc7bc20f2784',1,'entt::dispatcher::update()'],['../classentt_1_1dispatcher.html#ae15c11634047d7718db5e2e30675c80c',1,'entt::dispatcher::update() const']]] +]; diff --git a/search/functions_13.html b/search/functions_13.html new file mode 100644 index 000000000..febf8e03d --- /dev/null +++ b/search/functions_13.html @@ -0,0 +1,26 @@ + + + + + + + + + +
+
Loading...
+
+ +
Searching...
+
No Matches
+ +
+ + diff --git a/search/functions_13.js b/search/functions_13.js new file mode 100644 index 000000000..195048db0 --- /dev/null +++ b/search/functions_13.js @@ -0,0 +1,7 @@ +var searchData= +[ + ['valid',['valid',['../classentt_1_1basic__registry.html#ac7d145b7adb8ca486c49cfd44aebea73',1,'entt::basic_registry']]], + ['value',['value',['../classentt_1_1hashed__string.html#af5cb18d66625ba096e2e95069ac710cd',1,'entt::hashed_string::value()'],['../classentt_1_1meta__prop.html#a38a979e40971692929b46f80c3f22f9e',1,'entt::meta_prop::value()']]], + ['version',['version',['../classentt_1_1basic__registry.html#a75f09d82b0cd6305ea7422d60162704e',1,'entt::basic_registry']]], + ['view',['view',['../classentt_1_1basic__registry.html#ab2ea1df9f827924f2ecba67921bf4845',1,'entt::basic_registry::view()'],['../classentt_1_1basic__registry.html#a1a2ffab3b15bb205ceef86b8d8b3fdcb',1,'entt::basic_registry::view() const']]] +]; diff --git a/search/functions_14.html b/search/functions_14.html new file mode 100644 index 000000000..4c814f5ab --- /dev/null +++ b/search/functions_14.html @@ -0,0 +1,26 @@ + + + + + + + + + +
+
Loading...
+
+ +
Searching...
+
No Matches
+ +
+ + diff --git a/search/functions_14.js b/search/functions_14.js new file mode 100644 index 000000000..71a260f3a --- /dev/null +++ b/search/functions_14.js @@ -0,0 +1,10 @@ +var searchData= +[ + ['_7ebasic_5factor',['~basic_actor',['../structentt_1_1basic__actor.html#a46dc913885c448e059e9ca7cf3a21221',1,'entt::basic_actor']]], + ['_7ebasic_5fprototype',['~basic_prototype',['../classentt_1_1basic__prototype.html#a1181e970dc90a33b823210d33af819d5',1,'entt::basic_prototype']]], + ['_7eemitter',['~emitter',['../classentt_1_1emitter.html#a77d175ad8e8060c3628b3fb544cba15f',1,'entt::emitter']]], + ['_7emeta_5fany',['~meta_any',['../classentt_1_1meta__any.html#a816dae3d4ed3e41fcb376ec5ec9c38c1',1,'entt::meta_any']]], + ['_7eprocess',['~process',['../classentt_1_1process.html#a9280903240c53d1f2c7474ae8ccaa48d',1,'entt::process']]], + ['_7eservice_5flocator',['~service_locator',['../structentt_1_1service__locator.html#a2cbb6cfc1614067ae92f1c60580236a8',1,'entt::service_locator']]], + ['_7esparse_5fset',['~sparse_set',['../classentt_1_1sparse__set.html#a74c49e0d205b6240bf14ac3003cfcbd1',1,'entt::sparse_set']]] +]; diff --git a/search/functions_2.js b/search/functions_2.js index 16c74ec34..92820621b 100644 --- a/search/functions_2.js +++ b/search/functions_2.js @@ -1,17 +1,23 @@ var searchData= [ - ['capacity',['capacity',['../classentt_1_1Registry.html#a38e5391f9c1b4a8ea814f0abcf7a3323',1,'entt::Registry::capacity() const ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#aefe4ec26db45257de26da19147a9e3f3',1,'entt::Registry::capacity() const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#affd4ddc4bc12517d84772a40b0d992d5',1,'entt::SparseSet< Entity >::capacity()']]], - ['cbegin',['cbegin',['../classentt_1_1SparseSet_3_01Entity_01_4.html#a1ba1127cc520b39c2d147da99000866f',1,'entt::SparseSet< Entity >::cbegin()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#af38e9a34f90809eae7b2d51882cc2302',1,'entt::SparseSet< Entity, Type >::cbegin()'],['../classentt_1_1PersistentView.html#a5a6d810548ae9959047cc1a6249c5aff',1,'entt::PersistentView::cbegin()'],['../classentt_1_1View.html#a2cefabdbdd85098f9ac789a47fcc930a',1,'entt::View::cbegin()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a2cefabdbdd85098f9ac789a47fcc930a',1,'entt::View< Entity, Component >::cbegin()'],['../classentt_1_1RawView.html#a2550b7ceee635d59bac8eddce6523cf3',1,'entt::RawView::cbegin()'],['../classentt_1_1RuntimeView.html#a838fbbbceba139250db0dd186de86506',1,'entt::RuntimeView::cbegin()']]], - ['cend',['cend',['../classentt_1_1SparseSet_3_01Entity_01_4.html#aaec7e4e14421c38084ef57b13d40a15d',1,'entt::SparseSet< Entity >::cend()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#ae5994b196eca429c708722ba4b720208',1,'entt::SparseSet< Entity, Type >::cend()'],['../classentt_1_1PersistentView.html#a8ae9798901deacb27827f23b9ab51fe2',1,'entt::PersistentView::cend()'],['../classentt_1_1View.html#ab57c0ac7a0bb1487f525757a07a6bd71',1,'entt::View::cend()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#ab57c0ac7a0bb1487f525757a07a6bd71',1,'entt::View< Entity, Component >::cend()'],['../classentt_1_1RawView.html#aedfe14bbc1b65afecc549cc65354575f',1,'entt::RawView::cend()'],['../classentt_1_1RuntimeView.html#a111c068457853eb5c55845e68fd7b8a6',1,'entt::RuntimeView::cend()']]], - ['clear',['clear',['../classentt_1_1Scheduler.html#a2fd48cfd2ce32308f5e7bb8bafd5cda2',1,'entt::Scheduler::clear()'],['../classentt_1_1ResourceCache.html#a9ab70500ad42f8bd565ce1c379f472b4',1,'entt::ResourceCache::clear()'],['../classentt_1_1Emitter.html#a4e722d57776f3185e39386e6f252c56b',1,'entt::Emitter::clear() ENTT_NOEXCEPT'],['../classentt_1_1Emitter.html#a12ce32d79978c671a4d72532cd8e33f7',1,'entt::Emitter::clear() ENTT_NOEXCEPT']]], - ['collect',['collect',['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#af50a728e8b61c75af4286132e1312c77',1,'entt::SigH< Ret(Args...), Collector >']]], - ['component',['component',['../classentt_1_1Snapshot.html#a336288f5faaeb5f49831e3a0b4445bb0',1,'entt::Snapshot::component(Archive &archive) const'],['../classentt_1_1Snapshot.html#a4aa8df6d1e59c4f441e472f63f5ee580',1,'entt::Snapshot::component(Archive &archive) const'],['../classentt_1_1Snapshot.html#a98433fc64a9935e744a4c1b1f5d6e630',1,'entt::Snapshot::component(Archive &archive, It first, It last) const'],['../classentt_1_1SnapshotLoader.html#a03f291aa5216eab207780f785a75bbba',1,'entt::SnapshotLoader::component()'],['../classentt_1_1ContinuousLoader.html#a9c185ecae861f074afb1d2a14cf4f0f2',1,'entt::ContinuousLoader::component()']]], - ['connect',['connect',['../classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html#a51d3c462c56349e09a1c7fe0d58859b7',1,'entt::Delegate< Ret(Args...)>::connect() ENTT_NOEXCEPT'],['../classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html#a453219af4b49ccaf258e564006ed1f07',1,'entt::Delegate< Ret(Args...)>::connect(Class *instance) ENTT_NOEXCEPT'],['../classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html#a453219af4b49ccaf258e564006ed1f07',1,'entt::Delegate< Ret(Args...)>::connect(Class *instance) ENTT_NOEXCEPT'],['../classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html#a1b37a003e4d4edc19f95b1924ef18323',1,'entt::Sink< Ret(Args...)>::connect()'],['../classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html#a53d91eccac3db8a7b64534f2b52d31bb',1,'entt::Sink< Ret(Args...)>::connect(Class *instance)'],['../classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html#a53d91eccac3db8a7b64534f2b52d31bb',1,'entt::Sink< Ret(Args...)>::connect(Class *instance)'],['../namespaceentt.html#a70059e6999fc2c4fa892b3a8afc4d8bc',1,'entt::connect()']]], - ['connection',['Connection',['../structentt_1_1Emitter_1_1Connection.html#a1091537202d401609a73f0ee3fcc9ea6',1,'entt::Emitter::Connection::Connection() ENTT_NOEXCEPT=default'],['../structentt_1_1Emitter_1_1Connection.html#af059ef0d0aa727ea11e6873144fcbc1b',1,'entt::Emitter::Connection::Connection(typename Handler< Event >::connection_type conn)'],['../structentt_1_1Emitter_1_1Connection.html#a1ccd273683a9fb65a7a4d0c9bf7d0543',1,'entt::Emitter::Connection::Connection(const Connection &)=default'],['../structentt_1_1Emitter_1_1Connection.html#a0c5020d2127d9d0e45abd7e9c08c65c3',1,'entt::Emitter::Connection::Connection(Connection &&)=default']]], - ['construct',['construct',['../classentt_1_1Attachee_3_01Entity_01_4.html#a264393f844d8058b7b1e1ce3b83626bd',1,'entt::Attachee< Entity >::construct()'],['../classentt_1_1Attachee_3_01Entity_00_01Type_01_4.html#af89f69ab26880a5bdf390ebbae2a445e',1,'entt::Attachee< Entity, Type >::construct()'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a47dad39fa63ac4be07dcd9234c8a57c7',1,'entt::SparseSet< Entity >::construct()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#acf06fa56b6b0880d546dd3bc0ddc087f',1,'entt::SparseSet< Entity, Type >::construct(const entity_type entity, Args &&... args)'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#aded5c64ff04ee1a78e7e238208923d58',1,'entt::SparseSet< Entity, Type >::construct(const entity_type entity, Args &&... args)']]], - ['construction',['construction',['../classentt_1_1Registry.html#a6f6b29268ba11a8526fa3f9d3bdb58e5',1,'entt::Registry::construction(tag_t) ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#af43b25946f4cbdec633df25317edc020',1,'entt::Registry::construction() ENTT_NOEXCEPT']]], - ['contains',['contains',['../classentt_1_1Registry.html#a67a9d1a75fa1f8e29091f1127c0f3a70',1,'entt::Registry::contains()'],['../classentt_1_1PersistentView.html#af98a61a6ac04e08b6b46e4163ad3d415',1,'entt::PersistentView::contains()'],['../classentt_1_1View.html#abbc407e2fecdbcf97c129ade5db185e8',1,'entt::View::contains()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#abbc407e2fecdbcf97c129ade5db185e8',1,'entt::View< Entity, Component >::contains()'],['../classentt_1_1RuntimeView.html#a903cb93104fba0816f71f8851c6ff162',1,'entt::RuntimeView::contains()'],['../classentt_1_1ResourceCache.html#aa133ec347db1ee8fab5d757b8b24a185',1,'entt::ResourceCache::contains()']]], - ['continuousloader',['ContinuousLoader',['../classentt_1_1ContinuousLoader.html#a26ccd96f9ee4219ad7e3d1b8138ade37',1,'entt::ContinuousLoader::ContinuousLoader(Registry< entity_type > &registry) ENTT_NOEXCEPT'],['../classentt_1_1ContinuousLoader.html#a4d7cdac6b296eedb3dffd7ad0f182e3a',1,'entt::ContinuousLoader::ContinuousLoader(const ContinuousLoader &)=delete'],['../classentt_1_1ContinuousLoader.html#a4ba9abb1659a78f2ba4e12f86da68402',1,'entt::ContinuousLoader::ContinuousLoader(ContinuousLoader &&)=default']]], - ['create',['create',['../classentt_1_1Prototype.html#a434b43ae5f761093a0c9e74da0802523',1,'entt::Prototype::create(registry_type &other) const'],['../classentt_1_1Prototype.html#a5a659d7582d8fb52c5be59b0a319e2ec',1,'entt::Prototype::create() const'],['../classentt_1_1Registry.html#a433ac3fc8ea49347f691dd4ad1ccb58b',1,'entt::Registry::create()']]], - ['current',['current',['../classentt_1_1Registry.html#a9e79305f5a066bdc2b272181a08b17ac',1,'entt::Registry']]] + ['can_5fcast',['can_cast',['../classentt_1_1meta__any.html#a0df3dc5a414cbbade8f3738f68ca55e1',1,'entt::meta_any']]], + ['can_5fconvert',['can_convert',['../classentt_1_1meta__any.html#acfa712a0735f3f9596a2c9f9b96aa5b9',1,'entt::meta_any']]], + ['capacity',['capacity',['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#a9b52184cda174edc3555e05288ff9ebf',1,'entt::basic_group< Entity, get_t< Get... > >::capacity()'],['../classentt_1_1basic__registry.html#a90147848037f6661c2b7d28fb98dbd61',1,'entt::basic_registry::capacity() const ENTT_NOEXCEPT'],['../classentt_1_1basic__registry.html#abde8cee1ff1060eaebae6bef1e6c5e0e',1,'entt::basic_registry::capacity() const ENTT_NOEXCEPT'],['../classentt_1_1sparse__set.html#a30267005e552fce0d2a9b4e4d70d6656',1,'entt::sparse_set::capacity()']]], + ['cast',['cast',['../classentt_1_1meta__any.html#a160947a443eca2b61c5bf53f4cb8c6b4',1,'entt::meta_any::cast() const ENTT_NOEXCEPT'],['../classentt_1_1meta__any.html#a65793af4f215d84dd42e2d8da82a6057',1,'entt::meta_any::cast() ENTT_NOEXCEPT'],['../classentt_1_1meta__base.html#aa83c9d560b8b684d93f8df90830d6c56',1,'entt::meta_base::cast()']]], + ['cbegin',['cbegin',['../classentt_1_1basic__storage.html#aa5499c18eea80f3c903afef5031abf1b',1,'entt::basic_storage::cbegin()'],['../classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty__v_3_01Type_01_4_01_4_01_4.html#af1ea909d6d6a710a98b0e9c0673e5ca2',1,'entt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >::cbegin()']]], + ['cend',['cend',['../classentt_1_1basic__storage.html#a5fb9f5fd4996f424ab94b70f79b15205',1,'entt::basic_storage::cend()'],['../classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty__v_3_01Type_01_4_01_4_01_4.html#a99eb437d4d9d2a2c316787e6073da32f',1,'entt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >::cend()']]], + ['clear',['clear',['../classentt_1_1scheduler.html#a5a0f92dbe54b58751237a567e86805e0',1,'entt::scheduler::clear()'],['../classentt_1_1resource__cache.html#a2873906f1ee00b11980eadb6008da7ff',1,'entt::resource_cache::clear()'],['../classentt_1_1emitter.html#a09386e63b0871a304e295921c574318a',1,'entt::emitter::clear() ENTT_NOEXCEPT'],['../classentt_1_1emitter.html#acedafaefe2c9c91282c84e79aef26a35',1,'entt::emitter::clear() ENTT_NOEXCEPT']]], + ['clone',['clone',['../classentt_1_1basic__registry.html#aa5812babb6af95b8b524e59a5033c365',1,'entt::basic_registry']]], + ['collect',['collect',['../structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#a3341a4928e438e82eb070d3f9002b870',1,'entt::sigh< Ret(Args...), Collector >']]], + ['component',['component',['../classentt_1_1basic__snapshot.html#a59cf70d5b7730d388f3a63845e8faede',1,'entt::basic_snapshot::component(Archive &archive) const'],['../classentt_1_1basic__snapshot.html#a05fff12a4af42f0ad77dc4893856772c',1,'entt::basic_snapshot::component(Archive &archive, It first, It last) const'],['../classentt_1_1basic__snapshot__loader.html#af7352e091c3421432cc2ef77010a0a2d',1,'entt::basic_snapshot_loader::component()'],['../classentt_1_1basic__continuous__loader.html#a315b55f7576992d9261ee812f202d5ad',1,'entt::basic_continuous_loader::component()']]], + ['connect',['connect',['../classentt_1_1delegate_3_01Ret_07Args_8_8_8_08_4.html#a6e732abcbc4aa9b8899c92d8f21e55a6',1,'entt::delegate< Ret(Args...)>::connect() ENTT_NOEXCEPT'],['../classentt_1_1delegate_3_01Ret_07Args_8_8_8_08_4.html#afcdce5ab5ae55520cce86f3f79b38e9c',1,'entt::delegate< Ret(Args...)>::connect(Type *value_or_instance) ENTT_NOEXCEPT'],['../classentt_1_1sink_3_01Ret_07Args_8_8_8_08_4.html#aa8bab262e4c9cfefe7610492cdfbdd2b',1,'entt::sink< Ret(Args...)>::connect()'],['../classentt_1_1sink_3_01Ret_07Args_8_8_8_08_4.html#af7a9d71f8798711264a9803e3e9864ac',1,'entt::sink< Ret(Args...)>::connect(Type *value_or_instance)'],['../namespaceentt.html#a3b009bb4a03a46a209dee068dc133b6b',1,'entt::connect()']]], + ['connection',['connection',['../structentt_1_1emitter_1_1connection.html#a846b5190231aee4dd2340ab910adea40',1,'entt::emitter::connection::connection() ENTT_NOEXCEPT=default'],['../structentt_1_1emitter_1_1connection.html#a6497a7521b75836697bf4fb97de246d7',1,'entt::emitter::connection::connection(typename event_handler< Event >::connection_type conn)']]], + ['construct',['construct',['../classentt_1_1sparse__set.html#a4f6d293b9bc7227de22c86722881083f',1,'entt::sparse_set::construct()'],['../classentt_1_1basic__storage.html#a4cf7d707b57b6dd63c4d7852a23b6f5e',1,'entt::basic_storage::construct()'],['../classentt_1_1meta__type.html#ad9c9a821b8047a5b48efadd2a045da2a',1,'entt::meta_type::construct()']]], + ['contains',['contains',['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#a16fc46d56939e5c5bab2685b870ff31d',1,'entt::basic_group< Entity, get_t< Get... > >::contains()'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html#a9b5fe414b78000832d52a7810c6aba82',1,'entt::basic_group< Entity, get_t< Get... >, Owned... >::contains()'],['../classentt_1_1basic__runtime__view.html#a3754c1d13392fc18daaf2003867a64fd',1,'entt::basic_runtime_view::contains()'],['../classentt_1_1basic__view.html#a8dc82a3867a4ae26e8e80b5abc2e2118',1,'entt::basic_view::contains()'],['../classentt_1_1basic__view_3_01Entity_00_01Component_01_4.html#a8dc82a3867a4ae26e8e80b5abc2e2118',1,'entt::basic_view< Entity, Component >::contains()'],['../classentt_1_1resource__cache.html#a21e2634bfd4412ed83ee9a024969f309',1,'entt::resource_cache::contains()']]], + ['conv',['conv',['../classentt_1_1meta__factory.html#a84633b1bc2d531e2322997fd9a8f44dd',1,'entt::meta_factory::conv()'],['../classentt_1_1meta__type.html#a148df7974d347bc1b4c9cad9f30c51ef',1,'entt::meta_type::conv(Op op) const ENTT_NOEXCEPT'],['../classentt_1_1meta__type.html#ae6ea2662ab2d241577d0c1f51b7b97d0',1,'entt::meta_type::conv() const ENTT_NOEXCEPT']]], + ['convert',['convert',['../classentt_1_1meta__any.html#a3ad2f3a20951675fdeb5dccbed67e39c',1,'entt::meta_any::convert() const ENTT_NOEXCEPT'],['../classentt_1_1meta__any.html#a23180882087f7aab5835c7276e5f5a28',1,'entt::meta_any::convert() ENTT_NOEXCEPT'],['../classentt_1_1meta__conv.html#aa8acf7e218f317e9bb643d0a8d81b390',1,'entt::meta_conv::convert()']]], + ['create',['create',['../classentt_1_1basic__prototype.html#a6f96bf09702ed9b2d911c1d08ff5b0b1',1,'entt::basic_prototype::create(registry_type &other) const'],['../classentt_1_1basic__prototype.html#adb90842d165a76693de962f2cb7444e4',1,'entt::basic_prototype::create() const'],['../classentt_1_1basic__registry.html#a1bb5d5d0c5af3bd98de3d902406ff372',1,'entt::basic_registry::create()'],['../classentt_1_1basic__registry.html#a3dc6b7ace48533c41cf0fb28a4b0a36c',1,'entt::basic_registry::create(It first, It last)']]], + ['ctor',['ctor',['../classentt_1_1meta__factory.html#a452a2b2df406361785ec40c2e2f9a426',1,'entt::meta_factory::ctor(Property &&... property) ENTT_NOEXCEPT'],['../classentt_1_1meta__factory.html#a452a2b2df406361785ec40c2e2f9a426',1,'entt::meta_factory::ctor(Property &&... property) ENTT_NOEXCEPT'],['../classentt_1_1meta__type.html#a527e242b24025efb218a7936bb82955e',1,'entt::meta_type::ctor(Op op) const ENTT_NOEXCEPT'],['../classentt_1_1meta__type.html#a19e66bc8271fac7f72413c09922fbc32',1,'entt::meta_type::ctor() const ENTT_NOEXCEPT']]], + ['ctx',['ctx',['../classentt_1_1basic__registry.html#ac53dddfa495bb678debd98ecc2720e6d',1,'entt::basic_registry::ctx() const ENTT_NOEXCEPT'],['../classentt_1_1basic__registry.html#af887e7939d4b09c4634bcb24e817170b',1,'entt::basic_registry::ctx() ENTT_NOEXCEPT']]], + ['current',['current',['../classentt_1_1basic__registry.html#ad3e60af648b0b602527dbb6ea17e95c4',1,'entt::basic_registry']]] ]; diff --git a/search/functions_3.js b/search/functions_3.js index 9fb3dcbb2..d1265a217 100644 --- a/search/functions_3.js +++ b/search/functions_3.js @@ -1,12 +1,12 @@ var searchData= [ - ['data',['data',['../classentt_1_1Registry.html#a2bb7899d022c90b2385cad18a31e48dd',1,'entt::Registry::data()'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a3da83139d2ef41982399948a94383c0b',1,'entt::SparseSet< Entity >::data()'],['../classentt_1_1PersistentView.html#ae3e2d20cb89f810542c0ec4fe4537176',1,'entt::PersistentView::data()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a7b1ac1bc68c41fb4007ad5c47ed754a0',1,'entt::View< Entity, Component >::data()'],['../classentt_1_1RawView.html#a27edc55b8d2d18f75118b3b1e68ff270',1,'entt::RawView::data()']]], - ['dead',['dead',['../classentt_1_1Process.html#a08265296592bcc0e5a6632b7067329b9',1,'entt::Process']]], - ['delegate',['Delegate',['../classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html#a57a011f4b42c3358ee5219f63997e00b',1,'entt::Delegate< Ret(Args...)>']]], - ['dependency',['dependency',['../namespaceentt.html#ab9d53b0eb1c6fb4d7636d4ab451b615d',1,'entt']]], - ['destroy',['destroy',['../classentt_1_1Attachee_3_01Entity_01_4.html#ab3e8fbcf3f0d55bf4c907fb3178bad51',1,'entt::Attachee< Entity >::destroy()'],['../classentt_1_1Attachee_3_01Entity_00_01Type_01_4.html#a5c45bacb7159e042c065300ccf4660a7',1,'entt::Attachee< Entity, Type >::destroy()'],['../classentt_1_1Registry.html#a140dfdb699d360b7c0e066ae298aab5e',1,'entt::Registry::destroy(tag_t)'],['../classentt_1_1Registry.html#a197afcc6da68df6eb87575284232a3ff',1,'entt::Registry::destroy(const entity_type entity)'],['../classentt_1_1Registry.html#a8169422afda942f5915ee68b46636c3b',1,'entt::Registry::destroy(Type...)'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a7bd15b00eb2ce0e52d3d957673b4dd97',1,'entt::SparseSet< Entity >::destroy()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#ae763b848ccde63e554f5b3f04b9dcdea',1,'entt::SparseSet< Entity, Type >::destroy()']]], - ['destroyed',['destroyed',['../classentt_1_1Snapshot.html#ac7d571f0901df2476451e2fd26d9dab9',1,'entt::Snapshot::destroyed()'],['../classentt_1_1SnapshotLoader.html#a094ec796643b2c7422533c24e80963f3',1,'entt::SnapshotLoader::destroyed()'],['../classentt_1_1ContinuousLoader.html#a8aa96c02f3fa734078b4e77198665c91',1,'entt::ContinuousLoader::destroyed()']]], - ['destruction',['destruction',['../classentt_1_1Registry.html#a89df80b61b83bc3c4c3ed6d9324aa8b4',1,'entt::Registry::destruction(tag_t) ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#aaa38dca5bb6875370d50a923cf52fcfb',1,'entt::Registry::destruction() ENTT_NOEXCEPT']]], - ['discard',['discard',['../classentt_1_1Registry.html#a9289a7c5d8bed1ba59948311f8fcd3f4',1,'entt::Registry::discard()'],['../classentt_1_1ResourceCache.html#a771ee2c8c203eb018731e7914afbe5fa',1,'entt::ResourceCache::discard()']]], - ['disconnect',['disconnect',['../classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html#a3ecbd44accc33e5eb2d9e1920c347f5a',1,'entt::Sink< Ret(Args...)>::disconnect()'],['../classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html#a4c3eb2a296d7e99fd09b9e81ddab9777',1,'entt::Sink< Ret(Args...)>::disconnect(Class *instance)'],['../classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html#a4c3eb2a296d7e99fd09b9e81ddab9777',1,'entt::Sink< Ret(Args...)>::disconnect(Class *instance)'],['../classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html#aa7ba0d3b192499927ac7714bc04d10f8',1,'entt::Sink< Ret(Args...)>::disconnect(Class *instance)'],['../classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html#af537cc1833d4c5dbc5216f7c70440539',1,'entt::Sink< Ret(Args...)>::disconnect()'],['../namespaceentt.html#a8232dd7b7bfb15a663db6dc55e502eb2',1,'entt::disconnect()']]] + ['data',['data',['../classentt_1_1hashed__string.html#af8136c35e3f7ec352f9d09f0762ea8cb',1,'entt::hashed_string::data()'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#a333424a68d4267a0302df6dcb5e39e81',1,'entt::basic_group< Entity, get_t< Get... > >::data() const ENTT_NOEXCEPT'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#a320e6da3f841cf798d981d6b1fcad117',1,'entt::basic_group< Entity, get_t< Get... > >::data() const ENTT_NOEXCEPT'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html#aa62e833b539039982a99b7326f9b3139',1,'entt::basic_group< Entity, get_t< Get... >, Owned... >::data() const ENTT_NOEXCEPT'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html#a2df6e5b81f1aa1d839c645dec19fc7ad',1,'entt::basic_group< Entity, get_t< Get... >, Owned... >::data() const ENTT_NOEXCEPT'],['../classentt_1_1basic__registry.html#a79d6af03e34feae7123b924b50a91ca9',1,'entt::basic_registry::data()'],['../classentt_1_1sparse__set.html#a2eafe4975271769b08fe7f7d4924992f',1,'entt::sparse_set::data()'],['../classentt_1_1basic__view.html#ac2122c6c128744f4617fab34dca651c3',1,'entt::basic_view::data()'],['../classentt_1_1basic__view_3_01Entity_00_01Component_01_4.html#a3a612381efadb0c6d68b43965e6d1149',1,'entt::basic_view< Entity, Component >::data()'],['../classentt_1_1meta__factory.html#a02634a64ff7fe7c644691d495e9ccc18',1,'entt::meta_factory::data(const char *str, Property &&... property) ENTT_NOEXCEPT'],['../classentt_1_1meta__factory.html#a1226d202290aaff53c14db38bd505a2b',1,'entt::meta_factory::data(const char *str, Property &&... property) ENTT_NOEXCEPT'],['../classentt_1_1meta__any.html#a427ee14f12077f8634919fa5c501f93a',1,'entt::meta_any::data() const ENTT_NOEXCEPT'],['../classentt_1_1meta__any.html#a2726c037b90fef702cc90eb54e741b49',1,'entt::meta_any::data() ENTT_NOEXCEPT'],['../classentt_1_1meta__handle.html#a07e72402cf9163c50472b201f9c130d5',1,'entt::meta_handle::data() const ENTT_NOEXCEPT'],['../classentt_1_1meta__handle.html#a3f9f079820d1bcd1d987e6c2c91a733f',1,'entt::meta_handle::data() ENTT_NOEXCEPT'],['../classentt_1_1meta__type.html#af0f837a5bf6e4edbe9f4c15b19114506',1,'entt::meta_type::data(Op op) const ENTT_NOEXCEPT'],['../classentt_1_1meta__type.html#aa1d24de2069a1578de40237774c03d97',1,'entt::meta_type::data(const char *str) const ENTT_NOEXCEPT']]], + ['dead',['dead',['../classentt_1_1process.html#ad83f2550ca63e03af126a07e4ae5d9dd',1,'entt::process']]], + ['delegate',['delegate',['../classentt_1_1delegate_3_01Ret_07Args_8_8_8_08_4.html#a5c4828a5df5ed1e8fd18465ff63eb73c',1,'entt::delegate< Ret(Args...)>::delegate() ENTT_NOEXCEPT'],['../classentt_1_1delegate_3_01Ret_07Args_8_8_8_08_4.html#ad07c76f552619d55edc17a3722958215',1,'entt::delegate< Ret(Args...)>::delegate(connect_arg_t< Function >) ENTT_NOEXCEPT'],['../classentt_1_1delegate_3_01Ret_07Args_8_8_8_08_4.html#a3c3391085b16cba9024b4bbb372f7326',1,'entt::delegate< Ret(Args...)>::delegate(connect_arg_t< Candidate >, Type *value_or_instance) ENTT_NOEXCEPT'],['../namespaceentt.html#aeda304d14f286ffcb1d872a6ef526745',1,'entt::delegate(connect_arg_t< Function >) ENTT_NOEXCEPT -> delegate< std::remove_pointer_t< decltype(internal::to_function_pointer(Function))>>'],['../namespaceentt.html#a7e9e79b197bfa9e04868fdff9939931e',1,'entt::delegate(connect_arg_t< Candidate >, Type *) ENTT_NOEXCEPT -> delegate< std::remove_pointer_t< decltype(internal::to_function_pointer(Candidate, std::declval< Type *>()))>>']]], + ['dependency',['dependency',['../namespaceentt.html#aab5117f888340d500280c50f424d228c',1,'entt']]], + ['destroy',['destroy',['../classentt_1_1basic__registry.html#af58f3add442cfb3f1fa470402db072bd',1,'entt::basic_registry::destroy(const entity_type entity)'],['../classentt_1_1basic__registry.html#a6c163dcc335da90e727e2f40e67973b7',1,'entt::basic_registry::destroy(It first, It last)'],['../classentt_1_1sparse__set.html#aedf563d410f1288b175b2d67522b5bb5',1,'entt::sparse_set::destroy()'],['../classentt_1_1basic__storage.html#a66169e7a351a3dadb00bfb53141ade5b',1,'entt::basic_storage::destroy()'],['../classentt_1_1meta__type.html#ad91cc02c03b339a9917d5d65305c29b2',1,'entt::meta_type::destroy()']]], + ['destroyed',['destroyed',['../classentt_1_1basic__snapshot.html#a7a26ec6a9bc937a7d71b1a4723bdf4c7',1,'entt::basic_snapshot::destroyed()'],['../classentt_1_1basic__snapshot__loader.html#a49128534d0d232dd4c380513dca345c0',1,'entt::basic_snapshot_loader::destroyed()'],['../classentt_1_1basic__continuous__loader.html#a368a3a5f63c99637ee456668dab1ef36',1,'entt::basic_continuous_loader::destroyed()']]], + ['discard',['discard',['../classentt_1_1resource__cache.html#a59355414c1a727ff347763734e569068',1,'entt::resource_cache']]], + ['disconnect',['disconnect',['../classentt_1_1sink_3_01Ret_07Args_8_8_8_08_4.html#ab0186e5614c746b3355119a8f1abc9d1',1,'entt::sink< Ret(Args...)>::disconnect()'],['../classentt_1_1sink_3_01Ret_07Args_8_8_8_08_4.html#a3ea78f6a9f675a922995f4897b74d9ef',1,'entt::sink< Ret(Args...)>::disconnect(Class *instance)'],['../classentt_1_1sink_3_01Ret_07Args_8_8_8_08_4.html#a1f9b66d606a004485f535997c96c231a',1,'entt::sink< Ret(Args...)>::disconnect()'],['../namespaceentt.html#a71889edeeb1f03ecc2b47d183465384c',1,'entt::disconnect()']]], + ['dtor',['dtor',['../classentt_1_1meta__factory.html#ac0166de72ef9397be042ab7ad9087b0f',1,'entt::meta_factory::dtor()'],['../classentt_1_1meta__type.html#a0f36a3011bce598684c673a2e7734163',1,'entt::meta_type::dtor()']]] ]; diff --git a/search/functions_4.js b/search/functions_4.js index 75649df41..81ee39e32 100644 --- a/search/functions_4.js +++ b/search/functions_4.js @@ -1,12 +1,12 @@ var searchData= [ - ['each',['each',['../classentt_1_1Registry.html#a1d7547f6d8503265480d235fe48dfb1d',1,'entt::Registry::each()'],['../classentt_1_1PersistentView.html#abaf27560862f9b514695e61fa6a8c6e6',1,'entt::PersistentView::each(Func func) const'],['../classentt_1_1PersistentView.html#aa71f689a8ac192907617a4316492f03c',1,'entt::PersistentView::each(Func func)'],['../classentt_1_1View.html#a85eea1ef9655368de8da355019fbeaa0',1,'entt::View::each(Func func) const'],['../classentt_1_1View.html#a6c540ac6937e6e9cf931cccaabcec745',1,'entt::View::each(Func func)'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a85eea1ef9655368de8da355019fbeaa0',1,'entt::View< Entity, Component >::each(Func func) const'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a6c540ac6937e6e9cf931cccaabcec745',1,'entt::View< Entity, Component >::each(Func func)'],['../classentt_1_1RawView.html#a2f88d86e1ad74bb558df47e7507612b1',1,'entt::RawView::each(Func func) const'],['../classentt_1_1RawView.html#ad54a334bfbd407df75b93e428117d598',1,'entt::RawView::each(Func func)'],['../classentt_1_1RuntimeView.html#aa67ccd106835ddc0cc8c10bbdbcdd4e4',1,'entt::RuntimeView::each()']]], - ['emitter',['Emitter',['../classentt_1_1Emitter.html#a69aedf4db58a11af9eb6c36859e951c8',1,'entt::Emitter::Emitter() ENTT_NOEXCEPT=default'],['../classentt_1_1Emitter.html#ab4ee1e31a476217c9c8c5a9b9dfe856b',1,'entt::Emitter::Emitter(const Emitter &)=delete'],['../classentt_1_1Emitter.html#aef84a369260e86a006c151ab4a9041a8',1,'entt::Emitter::Emitter(Emitter &&)=default']]], - ['empty',['empty',['../classentt_1_1Registry.html#a57193f01b75256867ba34342cd46ec13',1,'entt::Registry::empty() const ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a8735df0baab2fea088e6946e2811e29b',1,'entt::Registry::empty() const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a62f5ebeb316c3d52877c6eca45c652ce',1,'entt::SparseSet< Entity >::empty()'],['../classentt_1_1PersistentView.html#a25cf198e023b229190aa6d62852f4d10',1,'entt::PersistentView::empty()'],['../classentt_1_1View.html#aee65a80863abccbe3117e60b22695dc4',1,'entt::View::empty()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#aee65a80863abccbe3117e60b22695dc4',1,'entt::View< Entity, Component >::empty()'],['../classentt_1_1RawView.html#abf0001549a9555166c532405bd3b647d',1,'entt::RawView::empty()'],['../classentt_1_1RuntimeView.html#ab08f06a99381e857657b2875e23c90a4',1,'entt::RuntimeView::empty()'],['../structentt_1_1ServiceLocator.html#afb0038914d828b6b3483484cc906ec44',1,'entt::ServiceLocator::empty()'],['../classentt_1_1Scheduler.html#aba0da7c946d76561a8694ecf7c5b29e3',1,'entt::Scheduler::empty()'],['../classentt_1_1ResourceCache.html#a03f2f3c02e84ec7f5825fe415c3f1cdb',1,'entt::ResourceCache::empty()'],['../classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html#ab776848ee5ece9b92740d8a2ad0b84a8',1,'entt::Delegate< Ret(Args...)>::empty()'],['../classentt_1_1Emitter.html#a4c54c5f15827be561e2912f7e91d1a6f',1,'entt::Emitter::empty() const ENTT_NOEXCEPT'],['../classentt_1_1Emitter.html#a733f11dc3c15aa910e3f2e6f167b62fd',1,'entt::Emitter::empty() const ENTT_NOEXCEPT'],['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#a6b35b22faefe41acd8c1426a1bdcd149',1,'entt::SigH< Ret(Args...), Collector >::empty()']]], - ['end',['end',['../classentt_1_1SparseSet_3_01Entity_01_4.html#a956957bcafba7391d1008110596d5714',1,'entt::SparseSet< Entity >::end() const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a14720d48f6d553a06813379ee6d7092f',1,'entt::SparseSet< Entity >::end() ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#aa04fe0d91fc40c8982cdfada8664e9b1',1,'entt::SparseSet< Entity, Type >::end() const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a43b4c3d129ab2b6559154f8db037bfd5',1,'entt::SparseSet< Entity, Type >::end() ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#a0e614f77f05085e951e761d8ca967a84',1,'entt::PersistentView::end() const ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#a470ef6edb944f127e26f7e3398cbded1',1,'entt::PersistentView::end() ENTT_NOEXCEPT'],['../classentt_1_1View.html#af0cbc67f83e47cb4cbb3a1a26d7cd263',1,'entt::View::end() const ENTT_NOEXCEPT'],['../classentt_1_1View.html#a34bca7c2c996fe26e150c0a7a2dbb69d',1,'entt::View::end() ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#af0cbc67f83e47cb4cbb3a1a26d7cd263',1,'entt::View< Entity, Component >::end() const ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a34bca7c2c996fe26e150c0a7a2dbb69d',1,'entt::View< Entity, Component >::end() ENTT_NOEXCEPT'],['../classentt_1_1RawView.html#ad7ad0559b9b4a440813e1752b0814bb4',1,'entt::RawView::end() const ENTT_NOEXCEPT'],['../classentt_1_1RawView.html#a8ebfe24e5a5e428b429f470755d0a1f7',1,'entt::RawView::end() ENTT_NOEXCEPT'],['../classentt_1_1RuntimeView.html#af8040215c3db60033388328ddff9a5d8',1,'entt::RuntimeView::end() const ENTT_NOEXCEPT'],['../classentt_1_1RuntimeView.html#afc2af975c32c247e0c333d4e49c0208c',1,'entt::RuntimeView::end() ENTT_NOEXCEPT']]], - ['enqueue',['enqueue',['../classentt_1_1Dispatcher.html#a431743aa289ce022f7ee87cd7fb3eedf',1,'entt::Dispatcher']]], - ['entities',['entities',['../classentt_1_1Snapshot.html#aa77d63e06c40969adca662fca3a2ca08',1,'entt::Snapshot::entities()'],['../classentt_1_1SnapshotLoader.html#a7bff030b50995a78f79217eecfb90535',1,'entt::SnapshotLoader::entities()'],['../classentt_1_1ContinuousLoader.html#a26eadd32f719c24de2305347a5066197',1,'entt::ContinuousLoader::entities()']]], - ['entity',['entity',['../structentt_1_1Actor.html#afb70b6f30071680efab23715a7e61a29',1,'entt::Actor::entity()'],['../classentt_1_1Registry.html#a43374c03910bf8b7337992d1bcc88e30',1,'entt::Registry::entity()']]], - ['erase',['erase',['../classentt_1_1Emitter.html#ab15f07d10744ce8aa74964fa5623375c',1,'entt::Emitter']]], - ['extent',['extent',['../classentt_1_1SparseSet_3_01Entity_01_4.html#ab314d3642b6a5b90bbcb170ba83b7978',1,'entt::SparseSet< Entity >']]] + ['each',['each',['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#a3c29b484e3e0841ef87f52f5bc5e8141',1,'entt::basic_group< Entity, get_t< Get... > >::each()'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html#ab8c9dbf314b88997966995dda17178ca',1,'entt::basic_group< Entity, get_t< Get... >, Owned... >::each()'],['../classentt_1_1basic__registry.html#a86d2b035f54225d82548e8f03de28754',1,'entt::basic_registry::each()'],['../classentt_1_1basic__runtime__view.html#a79fe059a28f768f4dc82edf48438cce0',1,'entt::basic_runtime_view::each()'],['../classentt_1_1basic__view.html#a1019208022f9a4a35ade26f3f35c097f',1,'entt::basic_view::each(Func func) const'],['../classentt_1_1basic__view.html#aa8d3d77cb491ea84ebac40017780c96f',1,'entt::basic_view::each(Func func) const'],['../classentt_1_1basic__view_3_01Entity_00_01Component_01_4.html#a1019208022f9a4a35ade26f3f35c097f',1,'entt::basic_view< Entity, Component >::each()']]], + ['emitter',['emitter',['../classentt_1_1emitter.html#a9c2e7d7eb8accd1d71e8aacce404e4d9',1,'entt::emitter::emitter() ENTT_NOEXCEPT=default'],['../classentt_1_1emitter.html#a842fef69b914a160b0bcc211bb77b27b',1,'entt::emitter::emitter(emitter &&)=default']]], + ['empty',['empty',['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#a7d52210fbf901c8f2087a51e583b6699',1,'entt::basic_group< Entity, get_t< Get... > >::empty() const ENTT_NOEXCEPT'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#a1e9bf2f22c9b2b8f60fd55afc1f65af0',1,'entt::basic_group< Entity, get_t< Get... > >::empty() const ENTT_NOEXCEPT'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html#a35a1a8d1a7ae00497bdc3367078408b5',1,'entt::basic_group< Entity, get_t< Get... >, Owned... >::empty() const ENTT_NOEXCEPT'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html#a9d999f38f6de0804c8e06d3637d56d5a',1,'entt::basic_group< Entity, get_t< Get... >, Owned... >::empty() const ENTT_NOEXCEPT'],['../classentt_1_1basic__registry.html#af78aafdf9439c8535a2652b258a3720b',1,'entt::basic_registry::empty() const ENTT_NOEXCEPT'],['../classentt_1_1basic__registry.html#a980aa529b3be187c4403730efc6479c0',1,'entt::basic_registry::empty() const ENTT_NOEXCEPT'],['../classentt_1_1basic__runtime__view.html#a2483047bb494ac1bea3b1823bec87985',1,'entt::basic_runtime_view::empty()'],['../classentt_1_1sparse__set.html#ae1a16cb354a9ed5ded92b6edcddce15e',1,'entt::sparse_set::empty()'],['../classentt_1_1basic__view.html#a9d19f70eda47e20c8c6d97b7f2c05f11',1,'entt::basic_view::empty() const ENTT_NOEXCEPT'],['../classentt_1_1basic__view.html#af7916ac310c1ec40c3cb5426d74d641d',1,'entt::basic_view::empty() const ENTT_NOEXCEPT'],['../classentt_1_1basic__view_3_01Entity_00_01Component_01_4.html#af7916ac310c1ec40c3cb5426d74d641d',1,'entt::basic_view< Entity, Component >::empty()'],['../structentt_1_1service__locator.html#a9265b7273a758003283a79f7a4de6250',1,'entt::service_locator::empty()'],['../classentt_1_1scheduler.html#a817d93653aec6a479b920143bd21edbb',1,'entt::scheduler::empty()'],['../classentt_1_1resource__cache.html#a3a192adacbb198fe09b2c2a473d433d8',1,'entt::resource_cache::empty()'],['../classentt_1_1emitter.html#a841edafebf32b85da11657578e887961',1,'entt::emitter::empty() const ENTT_NOEXCEPT'],['../classentt_1_1emitter.html#afbac9d6fb49c28f06cb382715ed92ab9',1,'entt::emitter::empty() const ENTT_NOEXCEPT'],['../classentt_1_1sink_3_01Ret_07Args_8_8_8_08_4.html#a07679954660265dfbcffa34a25a6033f',1,'entt::sink< Ret(Args...)>::empty()'],['../structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#a52a4f9b5e9a6ba18cdbd8c05ce9d0005',1,'entt::sigh< Ret(Args...), Collector >::empty()']]], + ['end',['end',['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#a74f539ec1945cb261a172bf014019d5b',1,'entt::basic_group< Entity, get_t< Get... > >::end()'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html#ae9ba261769c3ffaef0b173fae8f46143',1,'entt::basic_group< Entity, get_t< Get... >, Owned... >::end()'],['../classentt_1_1basic__runtime__view.html#a777a70d6c1905a32b8a68b0b87cc9b85',1,'entt::basic_runtime_view::end()'],['../classentt_1_1sparse__set.html#a69d6c1288f673c6f92d2b1b028d6aa75',1,'entt::sparse_set::end()'],['../classentt_1_1basic__storage.html#a43640288a074495b549779ad271d7010',1,'entt::basic_storage::end() const ENTT_NOEXCEPT'],['../classentt_1_1basic__storage.html#a9922f88c0ed8f587ff4ae09745f67ae9',1,'entt::basic_storage::end() ENTT_NOEXCEPT'],['../classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty__v_3_01Type_01_4_01_4_01_4.html#aa56ba13f8c81dd153417fd0054e23a0b',1,'entt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >::end()'],['../classentt_1_1basic__view.html#a1c17f8511d0e12087fbdd3b9b5cc9e4a',1,'entt::basic_view::end()'],['../classentt_1_1basic__view_3_01Entity_00_01Component_01_4.html#a1c17f8511d0e12087fbdd3b9b5cc9e4a',1,'entt::basic_view< Entity, Component >::end()']]], + ['enqueue',['enqueue',['../classentt_1_1dispatcher.html#ab41d56a73b6bdc64f0862abd333ea701',1,'entt::dispatcher::enqueue(Args &&... args)'],['../classentt_1_1dispatcher.html#a1e0a488354698cbf3cba82396ac4b76e',1,'entt::dispatcher::enqueue(Event &&event)']]], + ['entities',['entities',['../classentt_1_1basic__snapshot.html#a79fe1641f3b448b37b8aecfcabf52a5e',1,'entt::basic_snapshot::entities()'],['../classentt_1_1basic__snapshot__loader.html#a0ee608c24b47e2f54a1224177a0dc741',1,'entt::basic_snapshot_loader::entities()'],['../classentt_1_1basic__continuous__loader.html#ae6655c1c6868b11f2781cec2aee77abb',1,'entt::basic_continuous_loader::entities()']]], + ['entity',['entity',['../structentt_1_1basic__actor.html#af92d62c39e122692addbfd6b75ea6922',1,'entt::basic_actor::entity()'],['../classentt_1_1basic__registry.html#a5d07b2e0105da47d25ceef530d91bb8b',1,'entt::basic_registry::entity()']]], + ['erase',['erase',['../classentt_1_1emitter.html#a14409e5061892c1342924b25f4ec2a0c',1,'entt::emitter']]], + ['extent',['extent',['../classentt_1_1sparse__set.html#af79345df59154e5ea9e58b7efa7ff8f0',1,'entt::sparse_set::extent()'],['../classentt_1_1meta__type.html#a4eadf479b9b7f11879a24e0e76d5cd51',1,'entt::meta_type::extent()']]] ]; diff --git a/search/functions_5.js b/search/functions_5.js index 649e35603..f5139dde4 100644 --- a/search/functions_5.js +++ b/search/functions_5.js @@ -1,5 +1,6 @@ var searchData= [ - ['fail',['fail',['../classentt_1_1Process.html#aa46a0784a199e1044c50e8aa34eea1bb',1,'entt::Process']]], - ['fast',['fast',['../classentt_1_1Registry.html#a76bf9ca50a3651d3c0c32df0627d8270',1,'entt::Registry::fast()'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#aa76df55ad01a2c5d4e407fc3a72ccd90',1,'entt::SparseSet< Entity >::fast()']]] + ['fail',['fail',['../classentt_1_1process.html#a81816bdd06dce4058bfe3cfa5d42a64c',1,'entt::process']]], + ['find',['find',['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#a7376a0f7f7badf83d6a58b38e41e69c2',1,'entt::basic_group< Entity, get_t< Get... > >::find()'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html#a09d84415b93dd88e5a9e15faa9229c83',1,'entt::basic_group< Entity, get_t< Get... >, Owned... >::find()'],['../classentt_1_1sparse__set.html#a0ed57521bb3279b5ed3cd397b65abf01',1,'entt::sparse_set::find()'],['../classentt_1_1basic__view.html#aa8098ec2a26d9386d68c0b664d21d93e',1,'entt::basic_view::find()'],['../classentt_1_1basic__view_3_01Entity_00_01Component_01_4.html#aa8098ec2a26d9386d68c0b664d21d93e',1,'entt::basic_view< Entity, Component >::find()']]], + ['func',['func',['../classentt_1_1meta__factory.html#ad4948c2fc844fe17a5a69dc71c845561',1,'entt::meta_factory::func()'],['../classentt_1_1meta__type.html#abf0f410fb838c6b6a430931f2d142e64',1,'entt::meta_type::func(Op op) const ENTT_NOEXCEPT'],['../classentt_1_1meta__type.html#a93ec0cd3e91b92243cc4638140ddacc4',1,'entt::meta_type::func(const char *str) const ENTT_NOEXCEPT']]] ]; diff --git a/search/functions_6.js b/search/functions_6.js index e42d45482..0a191cce3 100644 --- a/search/functions_6.js +++ b/search/functions_6.js @@ -1,4 +1,6 @@ var searchData= [ - ['get',['get',['../classentt_1_1Identifier.html#aed05b85b75f2b0646e007f156e43ca6a',1,'entt::Identifier::get()'],['../structentt_1_1Actor.html#ae6a07d30d0aca366d5b1eb3e839e36bc',1,'entt::Actor::get(tag_t) const ENTT_NOEXCEPT'],['../structentt_1_1Actor.html#ae3ef92c5829b365871bb9fffb013d825',1,'entt::Actor::get(tag_t) ENTT_NOEXCEPT'],['../structentt_1_1Actor.html#acd9d53518e387076d89df97767fee4f1',1,'entt::Actor::get() const ENTT_NOEXCEPT'],['../structentt_1_1Actor.html#a636b3ba19d4762b9b616a5e47e959b08',1,'entt::Actor::get() ENTT_NOEXCEPT'],['../classentt_1_1Attachee_3_01Entity_01_4.html#ae11b358a9638ea78e642118d8ad8eaad',1,'entt::Attachee< Entity >::get()'],['../classentt_1_1Attachee_3_01Entity_00_01Type_01_4.html#a8a0a579bc14bd6265891cd7484c9c356',1,'entt::Attachee< Entity, Type >::get() const ENTT_NOEXCEPT'],['../classentt_1_1Attachee_3_01Entity_00_01Type_01_4.html#ae7a2e05bf005d6db60e7ea01bc24ea50',1,'entt::Attachee< Entity, Type >::get() ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#a0d23c82dcf122123ee29ffd3254b4b84',1,'entt::Prototype::get() const ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#a4069701eaf29716ed9bbb404da5f1b59',1,'entt::Prototype::get() ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#ae52596223d2a61e52c41979b1e76d68f',1,'entt::Prototype::get() const ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#a35fcf29a4c01caa611cffa9f73cbe535',1,'entt::Prototype::get() ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a2079fb67093feb86b75e9dede6bb6c4d',1,'entt::Registry::get() const ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a3c71607135bee449a486c8a5241dc70d',1,'entt::Registry::get() ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#aa40aa6a87415b2e88c67b8b9f895bfe8',1,'entt::Registry::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#aefa861cd4cd2750ddb43f587fc756531',1,'entt::Registry::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a19e0832f4aceb58f1be1e7540313cec0',1,'entt::Registry::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a73f3a68af4e73a74a273cca9ceab68a2',1,'entt::Registry::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#aa7893474e3b47da7c2568a0dc4ab4bcf',1,'entt::SparseSet< Entity >::get()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a00ef6f3c6da43a1ef864a5252bc9b0a6',1,'entt::SparseSet< Entity, Type >::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#ab0a6f42129ec08ab607545712e67ce92',1,'entt::SparseSet< Entity, Type >::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#a51452939486c5e98036b60838f69a32d',1,'entt::PersistentView::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#a0a088e6e40be777f9834c1c3fc6d1b15',1,'entt::PersistentView::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#af6931b058d6009776cc19082eb9a512f',1,'entt::PersistentView::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#ad2e8b8cf33831f8ea2caf1bd9a0474b6',1,'entt::PersistentView::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1View.html#a8f2e5fc95bb71c698b8ce61b9b4a8a5e',1,'entt::View::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1View.html#ade86403331b51e25fae9238dd8997de0',1,'entt::View::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1View.html#a9fb10d57d05afa48c0f25ea0b475c81f',1,'entt::View::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1View.html#ac5b199f031c48da2393eb56fea35b83e',1,'entt::View::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a51d497700a0322a130022eea97643d0f',1,'entt::View< Entity, Component >::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a269fac4009da89c9743202b16dcd6d87',1,'entt::View< Entity, Component >::get(const entity_type entity) ENTT_NOEXCEPT'],['../structentt_1_1ServiceLocator.html#a87a0d27f2ce4ac8a94229e32853503ca',1,'entt::ServiceLocator::get()'],['../classentt_1_1ResourceHandle.html#a32e791c4556d040273643ca5f42755a9',1,'entt::ResourceHandle::get()']]] + ['get',['get',['../structentt_1_1basic__actor.html#a64d3d7ff9801b9efbb3cf08d93baca88',1,'entt::basic_actor::get() const ENTT_NOEXCEPT'],['../structentt_1_1basic__actor.html#a194f434fa3ed013a5266ebcbaa4761d8',1,'entt::basic_actor::get() ENTT_NOEXCEPT'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#ac9e3a791565a6ce40e63a579204320fc',1,'entt::basic_group< Entity, get_t< Get... > >::get()'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html#abcf557e056d884bcd6bd6a250448d6af',1,'entt::basic_group< Entity, get_t< Get... >, Owned... >::get()'],['../classentt_1_1basic__prototype.html#ac030e38aaa91c32530493a97a64fe1af',1,'entt::basic_prototype::get() const ENTT_NOEXCEPT'],['../classentt_1_1basic__prototype.html#a803649bd8fde6e3adad5c99dd118186a',1,'entt::basic_prototype::get() ENTT_NOEXCEPT'],['../classentt_1_1basic__registry.html#ab3c413736c37cd59e013dacae68512bc',1,'entt::basic_registry::get([[maybe_unused]] const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1basic__registry.html#aed5e3029a1134f1bb87617d0e99f89ac',1,'entt::basic_registry::get([[maybe_unused]] const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1sparse__set.html#ae5fdeb500ab138905118a4ebb018895a',1,'entt::sparse_set::get()'],['../classentt_1_1basic__storage.html#ab9f40b67e8a21a0aa2071ea127a1e4b9',1,'entt::basic_storage::get(const entity_type entt) const ENTT_NOEXCEPT'],['../classentt_1_1basic__storage.html#a629a39bfc6a29036671dea9d9b42f70d',1,'entt::basic_storage::get(const entity_type entt) ENTT_NOEXCEPT'],['../classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty__v_3_01Type_01_4_01_4_01_4.html#acd4baaae6a45b994ff2890034e423954',1,'entt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >::get()'],['../classentt_1_1basic__view.html#aaa4f1d01440c37739502d3d73a28c4ca',1,'entt::basic_view::get()'],['../classentt_1_1basic__view_3_01Entity_00_01Component_01_4.html#a55c708083311799867acab1954e530a9',1,'entt::basic_view< Entity, Component >::get()'],['../structentt_1_1service__locator.html#ab72c1dab3eec4554690a82457894b385',1,'entt::service_locator::get()'],['../classentt_1_1meta__data.html#a3d63885952dd5a7613bab37fc63c8ecd',1,'entt::meta_data::get(meta_handle handle) const ENTT_NOEXCEPT'],['../classentt_1_1meta__data.html#a98d5a4bd199049ba9ea553ec21fac583',1,'entt::meta_data::get(meta_handle handle, std::size_t index) const ENTT_NOEXCEPT'],['../classentt_1_1resource__handle.html#a694112d96f6c6f4e1c803aa2824996c7',1,'entt::resource_handle::get()']]], + ['get_5for_5fassign',['get_or_assign',['../classentt_1_1basic__registry.html#a20a14f97c1684c5aaeeba13ba40a3ad7',1,'entt::basic_registry']]], + ['group',['group',['../classentt_1_1basic__registry.html#a5a1700b02f6149444e190e57198e6a56',1,'entt::basic_registry::group(get_t< Get... >, exclude_t< Exclude... >={})'],['../classentt_1_1basic__registry.html#a0cd8cce88fd986480f641cd54ab74a68',1,'entt::basic_registry::group(get_t< Get... >, exclude_t< Exclude... >={}) const'],['../classentt_1_1basic__registry.html#a2c58ef6dde05dee6060b67009c4f2830',1,'entt::basic_registry::group(exclude_t< Exclude... >={})'],['../classentt_1_1basic__registry.html#a0009b9e643337268ec3e3015b684904f',1,'entt::basic_registry::group(exclude_t< Exclude... >={}) const']]] ]; diff --git a/search/functions_7.js b/search/functions_7.js index d746dbf72..ef3eb52a5 100644 --- a/search/functions_7.js +++ b/search/functions_7.js @@ -1,6 +1,6 @@ var searchData= [ - ['handle',['handle',['../classentt_1_1ResourceCache.html#a8d7348dc398645962d9993905ea8709f',1,'entt::ResourceCache']]], - ['has',['has',['../structentt_1_1Actor.html#a17e417a142fb430413f08bc56b7f95e1',1,'entt::Actor::has(tag_t) const ENTT_NOEXCEPT'],['../structentt_1_1Actor.html#ac606b0a0418351c925d29809f7107662',1,'entt::Actor::has() const ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#a3f156472cc6a07016eadf51082b8f2f8',1,'entt::Prototype::has()'],['../classentt_1_1Registry.html#ae2be7a8e1e6216b8a48fa941e9d3fbd6',1,'entt::Registry::has() const ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#afc108dadf41e5080274bcc4e877024e4',1,'entt::Registry::has(tag_t, const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a1ca7a3b46d14db8d917547643b1ab614',1,'entt::Registry::has(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1ContinuousLoader.html#a65c5550a1a68135345e30e2af20b6096',1,'entt::ContinuousLoader::has()'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a824d6f4789f0c03a7f18802d9dc46582',1,'entt::SparseSet< Entity >::has()']]], - ['hashedstring',['HashedString',['../classentt_1_1HashedString.html#af9ae25ce87c6183a71026d2c64501f98',1,'entt::HashedString::HashedString(const char(&str)[N]) ENTT_NOEXCEPT'],['../classentt_1_1HashedString.html#a56c7a79123eb7f0b63f0b0e218a111b9',1,'entt::HashedString::HashedString(ConstCharWrapper wrapper) ENTT_NOEXCEPT']]] + ['handle',['handle',['../classentt_1_1resource__cache.html#af4253936d31e8755bc0ff099d844600b',1,'entt::resource_cache']]], + ['has',['has',['../structentt_1_1basic__actor.html#a8e7a76ea53bc8a0cce33462def30b9ac',1,'entt::basic_actor::has()'],['../classentt_1_1basic__prototype.html#a6d4f9ce06a07f9b40ec714b13428326c',1,'entt::basic_prototype::has()'],['../classentt_1_1basic__registry.html#a22f516140a0fb811552f82910d95fead',1,'entt::basic_registry::has()'],['../classentt_1_1basic__continuous__loader.html#a7c2650e8116d6d32eb859435d9a31023',1,'entt::basic_continuous_loader::has()'],['../classentt_1_1sparse__set.html#af4eb4faf1aa28d20717716bea7981f5b',1,'entt::sparse_set::has()']]], + ['hashed_5fstring',['hashed_string',['../classentt_1_1hashed__string.html#ada991606527a67c3cb4eed4fba4bebce',1,'entt::hashed_string::hashed_string() ENTT_NOEXCEPT'],['../classentt_1_1hashed__string.html#a10130abb35bcca89b366815b2398bb55',1,'entt::hashed_string::hashed_string(const char(&curr)[N]) ENTT_NOEXCEPT'],['../classentt_1_1hashed__string.html#ae1b9c068c45549c59e795ad74f22ef5c',1,'entt::hashed_string::hashed_string(const_wrapper wrapper) ENTT_NOEXCEPT']]] ]; diff --git a/search/functions_8.js b/search/functions_8.js index 6591ab407..6fb5709ad 100644 --- a/search/functions_8.js +++ b/search/functions_8.js @@ -1,4 +1,18 @@ var searchData= [ - ['load',['load',['../classentt_1_1ResourceCache.html#a12155caf98459157ed5dbf3b3c4d545f',1,'entt::ResourceCache']]] + ['instance',['instance',['../classentt_1_1delegate_3_01Ret_07Args_8_8_8_08_4.html#a3e0495b7612d458cbc59dc4b657d586f',1,'entt::delegate< Ret(Args...)>']]], + ['invoke',['invoke',['../classentt_1_1meta__ctor.html#a2402980d8233e20480e0732df86f4d11',1,'entt::meta_ctor::invoke()'],['../classentt_1_1meta__dtor.html#a0b61f83fcfee615d8a27d9ff31c3deed',1,'entt::meta_dtor::invoke()'],['../classentt_1_1meta__func.html#a6145a3e14b99154a5caec4ad66a85c88',1,'entt::meta_func::invoke()']]], + ['is_5farray',['is_array',['../classentt_1_1meta__type.html#a708c42df22be9647eca05a8c9701a7b2',1,'entt::meta_type']]], + ['is_5fclass',['is_class',['../classentt_1_1meta__type.html#a9d1e5e6cd4c097143a3055b8e56a8641',1,'entt::meta_type']]], + ['is_5fconst',['is_const',['../classentt_1_1meta__data.html#a04acd97d1fe059a1dd3daaf508e10558',1,'entt::meta_data::is_const()'],['../classentt_1_1meta__func.html#a93c1f9ba3252788f9ac470f6ad6e3fb9',1,'entt::meta_func::is_const()']]], + ['is_5fenum',['is_enum',['../classentt_1_1meta__type.html#ab2d4f56d08063128d0b4bc5cb4b1b0c9',1,'entt::meta_type']]], + ['is_5ffloating_5fpoint',['is_floating_point',['../classentt_1_1meta__type.html#acb95ab1d8952b3595b0d820cee1aa79d',1,'entt::meta_type']]], + ['is_5ffunction',['is_function',['../classentt_1_1meta__type.html#a34f470bbee1fbc3a640d156c0e37c553',1,'entt::meta_type']]], + ['is_5fintegral',['is_integral',['../classentt_1_1meta__type.html#a222c4b6ae628f9ed6f90cd3573f788c8',1,'entt::meta_type']]], + ['is_5fmember_5ffunction_5fpointer',['is_member_function_pointer',['../classentt_1_1meta__type.html#a184083298b97b476f02509fd5379bdbb',1,'entt::meta_type']]], + ['is_5fmember_5fobject_5fpointer',['is_member_object_pointer',['../classentt_1_1meta__type.html#a486ce6d737b37675403f3e719a2a51a2',1,'entt::meta_type']]], + ['is_5fpointer',['is_pointer',['../classentt_1_1meta__type.html#a8eec2742984f892febcbc48a6192bdfd',1,'entt::meta_type']]], + ['is_5fstatic',['is_static',['../classentt_1_1meta__data.html#a94ae645e41c37e0da30a0353d391b9ad',1,'entt::meta_data::is_static()'],['../classentt_1_1meta__func.html#a8faf171039dc72ea51d94acc2c2ea249',1,'entt::meta_func::is_static()']]], + ['is_5funion',['is_union',['../classentt_1_1meta__type.html#ad3503617450b2814e53362206bb6fecd',1,'entt::meta_type']]], + ['is_5fvoid',['is_void',['../classentt_1_1meta__type.html#a4a8aea6060bd82daf287bb6c63c1955a',1,'entt::meta_type']]] ]; diff --git a/search/functions_9.js b/search/functions_9.js index 8e202d4f6..dc852501d 100644 --- a/search/functions_9.js +++ b/search/functions_9.js @@ -1,5 +1,4 @@ var searchData= [ - ['map',['map',['../classentt_1_1ContinuousLoader.html#a63d6f733d8651a19b7ea882f3615455c',1,'entt::ContinuousLoader']]], - ['move',['move',['../classentt_1_1Attachee_3_01Entity_00_01Type_01_4.html#af23f10b818925731c47beb0eb2e6164d',1,'entt::Attachee< Entity, Type >::move()'],['../classentt_1_1Registry.html#a459073e0dfdb4f21519792717f688173',1,'entt::Registry::move()']]] + ['key',['key',['../classentt_1_1meta__prop.html#a3f46ec94ffc028eb41c8db9915e7b6f3',1,'entt::meta_prop']]] ]; diff --git a/search/functions_a.js b/search/functions_a.js index 0299afa2e..5df976d6a 100644 --- a/search/functions_a.js +++ b/search/functions_a.js @@ -1,19 +1,5 @@ var searchData= [ - ['on',['on',['../classentt_1_1Emitter.html#a1df9a54b806806add57c3168cbb2bdf1',1,'entt::Emitter']]], - ['once',['once',['../classentt_1_1Emitter.html#a1145cc27235acf0e24e1956ba0b15393',1,'entt::Emitter']]], - ['operator_20bool',['operator bool',['../classentt_1_1ResourceHandle.html#a4da18e304419e8d070fbc095236b4403',1,'entt::ResourceHandle']]], - ['operator_20const_20char_20_2a',['operator const char *',['../classentt_1_1HashedString.html#ac93c062eb14c80be82bd75bb6e853be0',1,'entt::HashedString']]], - ['operator_20const_20resource_20_26',['operator const Resource &',['../classentt_1_1ResourceHandle.html#aa728424029a170454b7e61056af0926a',1,'entt::ResourceHandle']]], - ['operator_20hash_5ftype',['operator hash_type',['../classentt_1_1HashedString.html#a47843deb0d550b5a6e1129a9b913d85f',1,'entt::HashedString']]], - ['operator_20type',['operator Type',['../structentt_1_1Monostate.html#ae16dec68153e1cf761d8c2379c4e3e8c',1,'entt::Monostate']]], - ['operator_21_3d',['operator!=',['../namespaceentt.html#a8a638f5585d404bbdcfd8efdfeb39203',1,'entt::operator!=(const HashedString &lhs, const HashedString &rhs) ENTT_NOEXCEPT'],['../namespaceentt.html#aef8743ab32f59bd2905b9fa2938318b6',1,'entt::operator!=(const Delegate< Ret(Args...)> &lhs, const Delegate< Ret(Args...)> &rhs) ENTT_NOEXCEPT'],['../namespaceentt.html#a13ce28be581233dd1e9179a126dd979d',1,'entt::operator!=(const SigH< Ret(Args...)> &lhs, const SigH< Ret(Args...)> &rhs) ENTT_NOEXCEPT']]], - ['operator_28_29',['operator()',['../structentt_1_1StdSort.html#a3363910b5a138b20f96d8a967a7bbd8b',1,'entt::StdSort::operator()()'],['../structentt_1_1InsertionSort.html#a53f94456eb885d9a02344b33b39f8815',1,'entt::InsertionSort::operator()()'],['../structentt_1_1OneShotBubbleSort.html#a9c8c582c4a83a9faaf1e328296daf971',1,'entt::OneShotBubbleSort::operator()()'],['../classentt_1_1Prototype.html#ac7cb69aad2015e94f3a0a9ad42b82f1b',1,'entt::Prototype::operator()(registry_type &other, const entity_type dst) const ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#a6b0560c31432fb6591a772ce9a322728',1,'entt::Prototype::operator()(const entity_type dst) const ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#a7c401ecc89b0c88ab15ed2dd7686b54e',1,'entt::Prototype::operator()(registry_type &other) const ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#ad39dd5c5449cc647a1402543ebe411fe',1,'entt::Prototype::operator()() const ENTT_NOEXCEPT'],['../classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html#a3259f295bc4ea1da8307d1be65c83d6a',1,'entt::Delegate< Ret(Args...)>::operator()()']]], - ['operator_2a',['operator*',['../classentt_1_1ResourceHandle.html#a737a5c2e623d30f372ba4876fe3d0fd3',1,'entt::ResourceHandle']]], - ['operator_2d_3e',['operator->',['../classentt_1_1ResourceHandle.html#a55727b34cb2bcbff11a680bae2fd793e',1,'entt::ResourceHandle']]], - ['operator_3d',['operator=',['../structentt_1_1Monostate.html#a9e94509f038e4a634ce776cdc23548cf',1,'entt::Monostate::operator=()'],['../structentt_1_1Actor.html#a4c76bce639cb1b1f9cd3393dc6a9722c',1,'entt::Actor::operator=(const Actor &)=delete'],['../structentt_1_1Actor.html#a6c62cd16b0c52210930b0ac46854e716',1,'entt::Actor::operator=(Actor &&other)'],['../classentt_1_1Attachee_3_01Entity_01_4.html#a5577985fadaf54cd8b7a68379121f70b',1,'entt::Attachee< Entity >::operator=(const Attachee &)=default'],['../classentt_1_1Attachee_3_01Entity_01_4.html#a0fae3370d9f43831f912fc62c720fdd2',1,'entt::Attachee< Entity >::operator=(Attachee &&)=default'],['../classentt_1_1Attachee_3_01Entity_00_01Type_01_4.html#a7fc23ce495ad53e201ccd065975a0863',1,'entt::Attachee< Entity, Type >::operator=(const Attachee &)=delete'],['../classentt_1_1Attachee_3_01Entity_00_01Type_01_4.html#ad84135f7dd401013703924ee2f4971e3',1,'entt::Attachee< Entity, Type >::operator=(Attachee &&)=delete'],['../classentt_1_1Prototype.html#a65529171240b1b7c348445c7ba4f319e',1,'entt::Prototype::operator=(const Prototype &)=delete'],['../classentt_1_1Prototype.html#a9faf0b8878925090431a9e6acaed06c5',1,'entt::Prototype::operator=(Prototype &&other)'],['../classentt_1_1Registry.html#a6ff250745f1774984a9524d63855f26d',1,'entt::Registry::operator=(const Registry &)=delete'],['../classentt_1_1Registry.html#ade7432a219317a6912553feb2971188b',1,'entt::Registry::operator=(Registry &&)=default'],['../classentt_1_1Snapshot.html#a3375f7d701d086fc21e04e6077c954fc',1,'entt::Snapshot::operator=(const Snapshot &)=delete'],['../classentt_1_1Snapshot.html#a627c0ea635facdd8b8246d1b97de11e3',1,'entt::Snapshot::operator=(Snapshot &&)=default'],['../classentt_1_1SnapshotLoader.html#ad1f8a300b9c5ccf0598cd90ab0e0062f',1,'entt::SnapshotLoader::operator=(const SnapshotLoader &)=delete'],['../classentt_1_1SnapshotLoader.html#a69ed990a8a614e5a1cb90960c216784b',1,'entt::SnapshotLoader::operator=(SnapshotLoader &&)=default'],['../classentt_1_1ContinuousLoader.html#add60e853e8b948f8f3c9f5c73207cb2a',1,'entt::ContinuousLoader::operator=(const ContinuousLoader &)=delete'],['../classentt_1_1ContinuousLoader.html#a3e0c1b78fbd9ba85857c066b5c89adb5',1,'entt::ContinuousLoader::operator=(ContinuousLoader &&)=default'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a34ffc79377cef381ef5af2e75d61cf4d',1,'entt::SparseSet< Entity >::operator=(const SparseSet &)=delete'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a24ddfc9e45d7b70639124fe7c2800384',1,'entt::SparseSet< Entity >::operator=(SparseSet &&)=default'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#aa700bb907a18470dce144f84822c67ae',1,'entt::SparseSet< Entity, Type >::operator=(const SparseSet &)=delete'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a52a81e838ae87413116ab9165ab9ba86',1,'entt::SparseSet< Entity, Type >::operator=(SparseSet &&)=default'],['../classentt_1_1Scheduler.html#a66fa731504da02dfaa607e1c3f153120',1,'entt::Scheduler::operator=(const Scheduler &)=delete'],['../classentt_1_1Scheduler.html#a929ec57792af25f0552f25ad445c7731',1,'entt::Scheduler::operator=(Scheduler &&)=default'],['../classentt_1_1ResourceCache.html#abe56c919c4a2606f87d7d8351261a0e8',1,'entt::ResourceCache::operator=(const ResourceCache &) ENTT_NOEXCEPT=delete'],['../classentt_1_1ResourceCache.html#a18ddc0a0bae71d8124d775d9ddebc550',1,'entt::ResourceCache::operator=(ResourceCache &&) ENTT_NOEXCEPT=default'],['../classentt_1_1ResourceHandle.html#a017670d5037cf65ea0b81b5c094004ac',1,'entt::ResourceHandle::operator=(const ResourceHandle &) ENTT_NOEXCEPT=default'],['../classentt_1_1ResourceHandle.html#a5c6a854be6eca84bd76d8e05f05f657b',1,'entt::ResourceHandle::operator=(ResourceHandle &&) ENTT_NOEXCEPT=default'],['../structentt_1_1Emitter_1_1Connection.html#aa1dba0de2aaa8426f4b42e6c52aa80ea',1,'entt::Emitter::Connection::operator=(const Connection &)=default'],['../structentt_1_1Emitter_1_1Connection.html#a26bc490e1d62f8e7863052f28cc5672c',1,'entt::Emitter::Connection::operator=(Connection &&)=default'],['../classentt_1_1Emitter.html#ace3403fe310953f720dbddff016fe715',1,'entt::Emitter::operator=(const Emitter &)=delete'],['../classentt_1_1Emitter.html#a8d06e737c14bf6be779135529424ca64',1,'entt::Emitter::operator=(Emitter &&)=default']]], - ['operator_3d_3d',['operator==',['../classentt_1_1HashedString.html#aa5ca9b72d2fa65f2a4796a4ffae00c11',1,'entt::HashedString::operator==()'],['../classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html#a7fd87003864d2a56baa7d2c8a9317509',1,'entt::Delegate< Ret(Args...)>::operator==()'],['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#acd0e64abe3b6d879a27ced38fe50aa4b',1,'entt::SigH< Ret(Args...), Collector >::operator==()']]], - ['operator_5b_5d',['operator[]',['../classentt_1_1SparseSet_3_01Entity_01_4.html#a2de3b3dc887e30616c37dd1dbc3de46b',1,'entt::SparseSet< Entity >::operator[]()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a073eb76e982c1031ef0b69118764faab',1,'entt::SparseSet< Entity, Type >::operator[](const size_type pos) const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a6cd7bd35b86f34191bbfe73ff922b91e',1,'entt::SparseSet< Entity, Type >::operator[](const size_type pos) ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#a7edc6f5cbd49d978469d9384b9aca6b3',1,'entt::PersistentView::operator[]()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a6094dd00422b07f0a9523699b9bf77aa',1,'entt::View< Entity, Component >::operator[]()'],['../classentt_1_1RawView.html#a6a8855ebc61f5ea5f4c676173e92cfcc',1,'entt::RawView::operator[](const size_type pos) const ENTT_NOEXCEPT'],['../classentt_1_1RawView.html#ac85aa3a824640eeeb45f9d1eaaaeea8d',1,'entt::RawView::operator[](const size_type pos) ENTT_NOEXCEPT']]], - ['orphan',['orphan',['../classentt_1_1Registry.html#a3b4a5341ac0ef79fd2477753e857a9cb',1,'entt::Registry']]], - ['orphans',['orphans',['../classentt_1_1Registry.html#ada2900e50f66573c14821baac03bbd68',1,'entt::Registry::orphans()'],['../classentt_1_1SnapshotLoader.html#a70e3af34bfacf921a2579b1d0055ceca',1,'entt::SnapshotLoader::orphans()'],['../classentt_1_1ContinuousLoader.html#ad1f0c307283afc23e11460c9ca2037c0',1,'entt::ContinuousLoader::orphans()']]] + ['load',['load',['../classentt_1_1resource__cache.html#a4c5aa78d4c9c8d8148fab59a738cf20d',1,'entt::resource_cache']]], + ['loader',['loader',['../classentt_1_1basic__registry.html#a3d1400403d03bc6e3e5fd9dfe60c5dd3',1,'entt::basic_registry']]] ]; diff --git a/search/functions_b.js b/search/functions_b.js index 9a2306819..f8fb539ad 100644 --- a/search/functions_b.js +++ b/search/functions_b.js @@ -1,9 +1,14 @@ var searchData= [ - ['pause',['pause',['../classentt_1_1Process.html#a1f2f865b2c4f0c7cf2d82786ecb50f5f',1,'entt::Process']]], - ['paused',['paused',['../classentt_1_1Process.html#a3e320da0927d9ac83dc829d0aee8a310',1,'entt::Process']]], - ['prepare',['prepare',['../classentt_1_1Registry.html#ac05c9ccc5fe57df386d8104578fc9675',1,'entt::Registry']]], - ['processadaptor',['ProcessAdaptor',['../structentt_1_1ProcessAdaptor.html#a16a0964a81c537fe16b937696e47358b',1,'entt::ProcessAdaptor']]], - ['prototype',['Prototype',['../classentt_1_1Prototype.html#aa6033be234aad4d287d740c40db17fec',1,'entt::Prototype::Prototype(Registry< Entity > &registry)'],['../classentt_1_1Prototype.html#a6f3d7431f85160da0e255b279c4b5291',1,'entt::Prototype::Prototype(const Prototype &)=delete'],['../classentt_1_1Prototype.html#ad4900c4a27f506b5d2b9db54aba9d224',1,'entt::Prototype::Prototype(Prototype &&other)']]], - ['publish',['publish',['../classentt_1_1Emitter.html#ab5141fd9793f53ef83af47c8c8a74b0e',1,'entt::Emitter::publish()'],['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#a5d3aaec10dba146d75672e3dc81a4274',1,'entt::SigH< Ret(Args...), Collector >::publish()']]] + ['map',['map',['../classentt_1_1basic__continuous__loader.html#ab077b1e21a817130db7401524ffc41a0',1,'entt::basic_continuous_loader']]], + ['meta_5fany',['meta_any',['../classentt_1_1meta__any.html#a7d9eaa43621da68af96080b7f345f2b6',1,'entt::meta_any::meta_any() ENTT_NOEXCEPT'],['../classentt_1_1meta__any.html#adb57245c636a920913ec11088473c064',1,'entt::meta_any::meta_any(Type &&type)'],['../classentt_1_1meta__any.html#a8070ecc97c91d3c294d07339073e0a6a',1,'entt::meta_any::meta_any(const meta_any &other)'],['../classentt_1_1meta__any.html#a16de68c4d78064eb025627588936edfb',1,'entt::meta_any::meta_any(meta_any &&other) ENTT_NOEXCEPT']]], + ['meta_5fbase',['meta_base',['../classentt_1_1meta__base.html#a626084cbdbd95551966a74268a4c032c',1,'entt::meta_base']]], + ['meta_5fconv',['meta_conv',['../classentt_1_1meta__conv.html#a4397a13a77cbce66d1f8588f99974066',1,'entt::meta_conv']]], + ['meta_5fctor',['meta_ctor',['../classentt_1_1meta__ctor.html#ad9afbf8f0d39ecb2bb6cc5fdc694724c',1,'entt::meta_ctor']]], + ['meta_5fdata',['meta_data',['../classentt_1_1meta__data.html#a0cf4625a3d9427c4c589052a6b72709f',1,'entt::meta_data']]], + ['meta_5fdtor',['meta_dtor',['../classentt_1_1meta__dtor.html#adfa744faec2c49be6c2864cec39a23ce',1,'entt::meta_dtor']]], + ['meta_5ffunc',['meta_func',['../classentt_1_1meta__func.html#accb09abe59e6e219f098d5a629a4ab60',1,'entt::meta_func']]], + ['meta_5fhandle',['meta_handle',['../classentt_1_1meta__handle.html#a45c9c3f6a23bcf62a0fc306296236236',1,'entt::meta_handle::meta_handle() ENTT_NOEXCEPT'],['../classentt_1_1meta__handle.html#a11ff4c2d10554f9649396cd2cb564b2e',1,'entt::meta_handle::meta_handle(Type &&obj) ENTT_NOEXCEPT']]], + ['meta_5fprop',['meta_prop',['../classentt_1_1meta__prop.html#abd7eebc5c56f072f44c42542218a732c',1,'entt::meta_prop']]], + ['meta_5ftype',['meta_type',['../classentt_1_1meta__type.html#adc6239b718064cbcde0bbcebfcddbfda',1,'entt::meta_type']]] ]; diff --git a/search/functions_c.js b/search/functions_c.js index 3076e9f45..2bf557a27 100644 --- a/search/functions_c.js +++ b/search/functions_c.js @@ -1,16 +1,4 @@ var searchData= [ - ['raw',['raw',['../classentt_1_1Registry.html#aaa4a9703f583da393101aa91604267e6',1,'entt::Registry::raw() const ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a1728046f5645bf2ff3f167c40ca29d0e',1,'entt::Registry::raw() ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#acbad98597d305c221c90eabd67b169bc',1,'entt::SparseSet< Entity, Type >::raw() const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a8bc3ff7eb8a371ad64cf16f85116946b',1,'entt::SparseSet< Entity, Type >::raw() ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a67bdaf39828b8055069d51825192541d',1,'entt::View< Entity, Component >::raw() const ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a07d8b7d15b93f9988f6b4fbf514a356a',1,'entt::View< Entity, Component >::raw() ENTT_NOEXCEPT'],['../classentt_1_1RawView.html#ae9909bbe3f734989b765324b8cd75332',1,'entt::RawView::raw() const ENTT_NOEXCEPT'],['../classentt_1_1RawView.html#a1cdb189f5b2bf17021cf5c53d10ec222',1,'entt::RawView::raw() ENTT_NOEXCEPT']]], - ['ref',['ref',['../structentt_1_1ServiceLocator.html#a746c27214142cdd98c650c9cc66bf165',1,'entt::ServiceLocator']]], - ['registry',['registry',['../structentt_1_1Actor.html#ab31a5da2d556ff3c01e0cea59f090956',1,'entt::Actor::registry() const ENTT_NOEXCEPT'],['../structentt_1_1Actor.html#ae914b8f7817cdfaf596983743df126fe',1,'entt::Actor::registry() ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#ab5022bf3ac71d209cb9b85e686324f28',1,'entt::Registry::Registry()=default'],['../classentt_1_1Registry.html#a441dfbc29b39106fbacec0f0c7b07359',1,'entt::Registry::Registry(const Registry &)=delete'],['../classentt_1_1Registry.html#a5340b49833d3e23e28200a4069fe04b0',1,'entt::Registry::Registry(Registry &&)=default']]], - ['rejected',['rejected',['../classentt_1_1Process.html#aa4e618f12f5cf18d978557ea793b697d',1,'entt::Process']]], - ['reload',['reload',['../classentt_1_1ResourceCache.html#afaa3e5a964e1f04ea0c2c86adb7b4fbd',1,'entt::ResourceCache']]], - ['remove',['remove',['../structentt_1_1Actor.html#a4c805918eeb0f01c86529a3c9b4e9b13',1,'entt::Actor::remove(tag_t)'],['../structentt_1_1Actor.html#a2a647927841d9c2440cfb664f371bf09',1,'entt::Actor::remove()'],['../classentt_1_1Registry.html#a957bcbdbf082f9767e5474a73be6ece4',1,'entt::Registry::remove()'],['../classentt_1_1Registry.html#a113ff63724bdb90344984d5dd16995f2',1,'entt::Registry::remove(const entity_type entity)']]], - ['replace',['replace',['../classentt_1_1Registry.html#a39b071aa110b8ea38fb71ca471d371b5',1,'entt::Registry::replace(tag_t, Args &&... args)'],['../classentt_1_1Registry.html#a2482e363a9b4ff9b6a4a0e1385c7b6e1',1,'entt::Registry::replace(const entity_type entity, Args &&... args)']]], - ['reserve',['reserve',['../classentt_1_1Registry.html#a6d57a57e13ca236a215e332b94852147',1,'entt::Registry::reserve(const size_type cap)'],['../classentt_1_1Registry.html#aa927ac552b42e2a0fcc8de08f56510c7',1,'entt::Registry::reserve(const size_type cap)'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a19fd8be1b2cad2a4ca01c88225b0a379',1,'entt::SparseSet< Entity >::reserve()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a9b7168661765b86a7c24500a03115197',1,'entt::SparseSet< Entity, Type >::reserve()']]], - ['reset',['reset',['../classentt_1_1Registry.html#af406e83980abc792905ff4a0626b3d02',1,'entt::Registry::reset(const entity_type entity)'],['../classentt_1_1Registry.html#a613333e0a4acb227d08938ccc594e064',1,'entt::Registry::reset()'],['../classentt_1_1Registry.html#a1b6ec743e9a62389cf2bba9a25ee09d7',1,'entt::Registry::reset()'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#ad1c62c65aeb0112e688f05d8f641cdab',1,'entt::SparseSet< Entity >::reset()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a3b138c121f11592a3f9e9f2fc2bb67fe',1,'entt::SparseSet< Entity, Type >::reset()'],['../structentt_1_1ServiceLocator.html#ac52892a5692c15c8b230a5020adb0847',1,'entt::ServiceLocator::reset()'],['../classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html#a77c5b9a98a0636391955de940dad0b4f',1,'entt::Delegate< Ret(Args...)>::reset()']]], - ['resourcecache',['ResourceCache',['../classentt_1_1ResourceCache.html#aaeb4613b842a5d0861585e024af0a41d',1,'entt::ResourceCache::ResourceCache()=default'],['../classentt_1_1ResourceCache.html#a4dbd37c3c1a703b684b6122a59a0b3a7',1,'entt::ResourceCache::ResourceCache(const ResourceCache &) ENTT_NOEXCEPT=delete'],['../classentt_1_1ResourceCache.html#a86dde6d7190adbb13d8472424f6e8bca',1,'entt::ResourceCache::ResourceCache(ResourceCache &&) ENTT_NOEXCEPT=default']]], - ['resourcehandle',['ResourceHandle',['../classentt_1_1ResourceHandle.html#a7b267f802e92b57dcc750f824fd5e3df',1,'entt::ResourceHandle::ResourceHandle(const ResourceHandle &) ENTT_NOEXCEPT=default'],['../classentt_1_1ResourceHandle.html#a4d5c929ea7f0bd8860d7188aa6fb76a8',1,'entt::ResourceHandle::ResourceHandle(ResourceHandle &&) ENTT_NOEXCEPT=default']]], - ['respect',['respect',['../classentt_1_1SparseSet_3_01Entity_01_4.html#a17422401f952b58be5113ff88e302c0e',1,'entt::SparseSet< Entity >::respect()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a605545f8f99a7bb1f92d1dfc3ed438f3',1,'entt::SparseSet< Entity, Type >::respect()']]], - ['restore',['restore',['../classentt_1_1Registry.html#a37b755b43c7067658d2b4129baa403cf',1,'entt::Registry']]] + ['name',['name',['../classentt_1_1meta__data.html#a0a8b6735b7e7d017986aba75ce3c0515',1,'entt::meta_data::name()'],['../classentt_1_1meta__func.html#a418fd52ebc418d8afcfd645aa348416f',1,'entt::meta_func::name()'],['../classentt_1_1meta__type.html#ae07252fea20d74382a4e3876128cde40',1,'entt::meta_type::name()']]] ]; diff --git a/search/functions_d.js b/search/functions_d.js index c607cc275..391e6ac7e 100644 --- a/search/functions_d.js +++ b/search/functions_d.js @@ -1,15 +1,26 @@ var searchData= [ - ['scheduler',['Scheduler',['../classentt_1_1Scheduler.html#a9c8baf08ea6f2869432cb13d870481c3',1,'entt::Scheduler::Scheduler() ENTT_NOEXCEPT=default'],['../classentt_1_1Scheduler.html#a4527dc6d1aedb50126e522ae7c8de5a1',1,'entt::Scheduler::Scheduler(const Scheduler &)=delete'],['../classentt_1_1Scheduler.html#ab3a3ca9fa457fd48873c6d0d700a6f6c',1,'entt::Scheduler::Scheduler(Scheduler &&)=default']]], - ['servicelocator',['ServiceLocator',['../structentt_1_1ServiceLocator.html#a9806fa1d96f6edfb5b946b11acabc0da',1,'entt::ServiceLocator']]], - ['set',['set',['../classentt_1_1Prototype.html#abf665ce59c8f43c4eff3ce77a21c5cfb',1,'entt::Prototype::set()'],['../structentt_1_1ServiceLocator.html#abf8d8b8d70ed082d54516def7500ec5c',1,'entt::ServiceLocator::set(Args &&... args)'],['../structentt_1_1ServiceLocator.html#ad913de8d4a2dcf39b925773e42cbfff5',1,'entt::ServiceLocator::set(std::shared_ptr< Service > ptr)']]], - ['shrink',['shrink',['../classentt_1_1ContinuousLoader.html#a959dc40d6285e8175e95c3679c6698d6',1,'entt::ContinuousLoader']]], - ['sink',['sink',['../classentt_1_1Dispatcher.html#a091aa6ab261f34eee355c2b7180f709b',1,'entt::Dispatcher::sink()'],['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#a20b7fde8e36650f0e4cd31bd54ac1fc7',1,'entt::SigH< Ret(Args...), Collector >::sink()']]], - ['size',['size',['../classentt_1_1Registry.html#a88d7621801898d0a551cfd98b29a7cd0',1,'entt::Registry::size() const ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a1be83159fed73573014e6e2919ecabf3',1,'entt::Registry::size() const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a6dc502e9af33ac00af110e5eb8414bc1',1,'entt::SparseSet< Entity >::size()'],['../classentt_1_1PersistentView.html#ad6b816b2acc684733d79ac680005f8da',1,'entt::PersistentView::size()'],['../classentt_1_1View.html#a2244b847c1e148f901ea3b83ec2d6703',1,'entt::View::size()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a2244b847c1e148f901ea3b83ec2d6703',1,'entt::View< Entity, Component >::size()'],['../classentt_1_1RawView.html#a56cd44cbd4cf15fcaacdcfd9e2b0f710',1,'entt::RawView::size()'],['../classentt_1_1RuntimeView.html#a1532f09ceaac574965c9190554c74f55',1,'entt::RuntimeView::size()'],['../classentt_1_1Scheduler.html#a59aea2fac213df785278870474a3abb5',1,'entt::Scheduler::size()'],['../classentt_1_1ResourceCache.html#a1fb9767a303a85f09497751a7d70623f',1,'entt::ResourceCache::size()'],['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#a5f0c4724d805b4ecdd30045a13ed93ec',1,'entt::SigH< Ret(Args...), Collector >::size()']]], - ['snapshot',['Snapshot',['../classentt_1_1Snapshot.html#a80f9a56ce8667a5d9947cdaac686fd8d',1,'entt::Snapshot::Snapshot(const Snapshot &)=delete'],['../classentt_1_1Snapshot.html#a3682df1db11f032bfa9ead93c0cec479',1,'entt::Snapshot::Snapshot(Snapshot &&)=default'],['../classentt_1_1Registry.html#a00a0b4949a4cc0cb87e88cc6d1171a9d',1,'entt::Registry::snapshot()']]], - ['snapshotloader',['SnapshotLoader',['../classentt_1_1SnapshotLoader.html#a7cc32b25447bf6d13ac36a814e446f4c',1,'entt::SnapshotLoader::SnapshotLoader(const SnapshotLoader &)=delete'],['../classentt_1_1SnapshotLoader.html#ad20cadc8bb3699629cb3ae54bf07b39a',1,'entt::SnapshotLoader::SnapshotLoader(SnapshotLoader &&)=default']]], - ['sort',['sort',['../classentt_1_1Registry.html#acb72e05f3128b6604b438707eabdfa4a',1,'entt::Registry::sort(Compare compare, Sort sort=Sort{}, Args &&... args)'],['../classentt_1_1Registry.html#aa3abb830a7ba342266b62ff1a2965754',1,'entt::Registry::sort()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a8d2f225354c91f10b427e02dc211d24f',1,'entt::SparseSet< Entity, Type >::sort()'],['../classentt_1_1PersistentView.html#accde3d4b4a904e79c832f6b05f324b05',1,'entt::PersistentView::sort()']]], - ['sparseset',['SparseSet',['../classentt_1_1SparseSet_3_01Entity_01_4.html#ac21f0c7137814008016648e166061426',1,'entt::SparseSet< Entity >::SparseSet() ENTT_NOEXCEPT=default'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#aa4ad5318f2be78e8e4336bdf4b012905',1,'entt::SparseSet< Entity >::SparseSet(const SparseSet &)=delete'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#acdfceb557303dee515fe906a13ac759e',1,'entt::SparseSet< Entity >::SparseSet(SparseSet &&)=default'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a80cd93fb003c8edd8583fb679464a36e',1,'entt::SparseSet< Entity, Type >::SparseSet() ENTT_NOEXCEPT=default'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a52d68a9763bed211729df965cb7ab859',1,'entt::SparseSet< Entity, Type >::SparseSet(const SparseSet &)=delete'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a11cbb29701b5a1b1a6e4b77d19d29cec',1,'entt::SparseSet< Entity, Type >::SparseSet(SparseSet &&)=default']]], - ['succeed',['succeed',['../classentt_1_1Process.html#ae90a29bf2afabf6a14aec0e1d3809a0f',1,'entt::Process']]], - ['swap',['swap',['../classentt_1_1SparseSet_3_01Entity_01_4.html#ace9db01fbfd9f1b8afa4a6f43d42390e',1,'entt::SparseSet< Entity >']]] + ['basic_5fgroup_3c_20entity_2c_20get_5ft_2c_20owned_2e_2e_2e_20_3e',['basic_group< Entity, get_t, Owned... >',['../structentt_1_1as__group.html#af21610b3a3c165daaeb8f7724ab2b12d',1,'entt::as_group']]], + ['basic_5fview_3c_20entity_2c_20component_2e_2e_2e_20_3e',['basic_view< Entity, Component... >',['../structentt_1_1as__view.html#a6ca2fdd962761c71661b5178f3ec510b',1,'entt::as_view']]], + ['on',['on',['../classentt_1_1emitter.html#a0b580005200bb810a4a3e94320efcd8a',1,'entt::emitter']]], + ['on_5fconstruct',['on_construct',['../classentt_1_1basic__registry.html#a3784cae09a1a72a861c4ccd1e76db86a',1,'entt::basic_registry']]], + ['on_5fdestroy',['on_destroy',['../classentt_1_1basic__registry.html#a2a4af2fe256e5609282686b427f0ebcf',1,'entt::basic_registry']]], + ['on_5freplace',['on_replace',['../classentt_1_1basic__registry.html#a23857b92dfe141d7fd60c450fd14507a',1,'entt::basic_registry']]], + ['once',['once',['../classentt_1_1emitter.html#a79834d452b0600ebe0e70c54f4a21fd6',1,'entt::emitter']]], + ['operator_20bool',['operator bool',['../classentt_1_1meta__any.html#ad1cbe0447f1b0df45706712566f1b2a0',1,'entt::meta_any::operator bool()'],['../classentt_1_1meta__handle.html#a759d3375fd8e5811ca898cb8d6740eda',1,'entt::meta_handle::operator bool()'],['../classentt_1_1meta__prop.html#adb6af4bef4db742083886a0b97646407',1,'entt::meta_prop::operator bool()'],['../classentt_1_1meta__base.html#ad19d5a997c91281da3674a6b17d011bd',1,'entt::meta_base::operator bool()'],['../classentt_1_1meta__conv.html#aa7b17a68e2b9f7a1b614a5aa1e4a7c1a',1,'entt::meta_conv::operator bool()'],['../classentt_1_1meta__ctor.html#ac34d2ccb2c3ff0549775ed5c4c617ba2',1,'entt::meta_ctor::operator bool()'],['../classentt_1_1meta__dtor.html#ad4b53dd0805dd47276c196b093258deb',1,'entt::meta_dtor::operator bool()'],['../classentt_1_1meta__data.html#aebff3cb9edf609deb8577ed29225c508',1,'entt::meta_data::operator bool()'],['../classentt_1_1meta__func.html#a436c57daae914c9222de41c7b7678584',1,'entt::meta_func::operator bool()'],['../classentt_1_1meta__type.html#ae8101e23b4b79a4452f063736f86b3ad',1,'entt::meta_type::operator bool()'],['../classentt_1_1resource__handle.html#a78608879425212e25817c16e3393ee07',1,'entt::resource_handle::operator bool()'],['../classentt_1_1delegate_3_01Ret_07Args_8_8_8_08_4.html#a73e1029cbb6359d803a6cc06b82f80d7',1,'entt::delegate< Ret(Args...)>::operator bool()']]], + ['operator_20const_20char_20_2a',['operator const char *',['../classentt_1_1hashed__string.html#ad2b28732fadfb525cab25b19310617d1',1,'entt::hashed_string']]], + ['operator_20const_20resource_20_26',['operator const Resource &',['../classentt_1_1resource__handle.html#ab22a293cb18602690309a561b97d28cb',1,'entt::resource_handle']]], + ['operator_20hash_5ftype',['operator hash_type',['../classentt_1_1hashed__string.html#abc56b22d4cddd7b05fb41e32adfea8e2',1,'entt::hashed_string']]], + ['operator_20type',['operator Type',['../structentt_1_1monostate.html#ae48c2fc3cb5ca85e12b57a10fee54dfe',1,'entt::monostate']]], + ['operator_21_3d',['operator!=',['../namespaceentt.html#a9bb4a7e4959c087484745324d79efbd9',1,'entt::operator!=(const hashed_string &lhs, const hashed_string &rhs) ENTT_NOEXCEPT'],['../namespaceentt.html#a3e7582fde7d0323ad068543d660116f4',1,'entt::operator!=(const meta_any &lhs, const meta_any &rhs) ENTT_NOEXCEPT'],['../namespaceentt.html#abe07bfd01b0fac902d6d89a76b8b58fe',1,'entt::operator!=(const meta_prop &lhs, const meta_prop &rhs) ENTT_NOEXCEPT'],['../namespaceentt.html#a633d6546a24a66cfba27ad3f8bdbbd30',1,'entt::operator!=(const meta_base &lhs, const meta_base &rhs) ENTT_NOEXCEPT'],['../namespaceentt.html#ae0028b0d2edc4d7fd110069323d80f4b',1,'entt::operator!=(const meta_conv &lhs, const meta_conv &rhs) ENTT_NOEXCEPT'],['../namespaceentt.html#a42e03a0e2b4f0ed2bf7dd7635e4d22e8',1,'entt::operator!=(const meta_ctor &lhs, const meta_ctor &rhs) ENTT_NOEXCEPT'],['../namespaceentt.html#ab4ba1bf1f3ad09a47b477ad9a320393f',1,'entt::operator!=(const meta_dtor &lhs, const meta_dtor &rhs) ENTT_NOEXCEPT'],['../namespaceentt.html#afffe04587aa936ef68791af1d99d380d',1,'entt::operator!=(const meta_data &lhs, const meta_data &rhs) ENTT_NOEXCEPT'],['../namespaceentt.html#a0bccfeb5e95c4ce5ea82cac0b4738f49',1,'entt::operator!=(const meta_func &lhs, const meta_func &rhs) ENTT_NOEXCEPT'],['../namespaceentt.html#a2feb1b10f84534d2ed32aed30c36cb61',1,'entt::operator!=(const meta_type &lhs, const meta_type &rhs) ENTT_NOEXCEPT'],['../namespaceentt.html#a656b2ec80abf493ce1924b314d13fd18',1,'entt::operator!=(const delegate< Ret(Args...)> &lhs, const delegate< Ret(Args...)> &rhs) ENTT_NOEXCEPT']]], + ['operator_28_29',['operator()',['../structentt_1_1std__sort.html#af25b38ddb03e206a71a1f47521eaea46',1,'entt::std_sort::operator()()'],['../structentt_1_1insertion__sort.html#a73a5644fe5b683f9b9376c89ac47f2b8',1,'entt::insertion_sort::operator()()'],['../classentt_1_1basic__prototype.html#a463e0d4a93ce396a069bd181c59ba6e2',1,'entt::basic_prototype::operator()(registry_type &other, const entity_type dst) const ENTT_NOEXCEPT'],['../classentt_1_1basic__prototype.html#a081d19f1dbb870c85f2bb215422700c1',1,'entt::basic_prototype::operator()(const entity_type dst) const ENTT_NOEXCEPT'],['../classentt_1_1basic__prototype.html#a8e47d98dbba3929f3edfe682975db846',1,'entt::basic_prototype::operator()(registry_type &other) const ENTT_NOEXCEPT'],['../classentt_1_1basic__prototype.html#afa55befc754adbf67d25ebae7aed6a75',1,'entt::basic_prototype::operator()() const ENTT_NOEXCEPT'],['../classentt_1_1delegate_3_01Ret_07Args_8_8_8_08_4.html#a0e53caedb53810bc96aa71bce199c990',1,'entt::delegate< Ret(Args...)>::operator()()']]], + ['operator_2a',['operator*',['../classentt_1_1resource__handle.html#a2b014e1f6f871f25329c6bed1048f0ef',1,'entt::resource_handle']]], + ['operator_2d_3e',['operator->',['../classentt_1_1resource__handle.html#ab2b2301a2f2f81f14979a9278c565e78',1,'entt::resource_handle']]], + ['operator_3d',['operator=',['../structentt_1_1monostate.html#a60244e7ef8dfc7c0eea55123b3ed294e',1,'entt::monostate::operator=()'],['../structentt_1_1basic__actor.html#a729116e0ae65677a6ed9ed9d21c111c6',1,'entt::basic_actor::operator=()'],['../classentt_1_1basic__prototype.html#a24a5c455ba9368897c959f722496fa54',1,'entt::basic_prototype::operator=()'],['../classentt_1_1basic__registry.html#a70f7acd3a0e9a8dc4ef7e85172f93a59',1,'entt::basic_registry::operator=()'],['../classentt_1_1basic__snapshot.html#a1484b609195cfd057bbdd8808d4392bc',1,'entt::basic_snapshot::operator=()'],['../classentt_1_1basic__snapshot__loader.html#aa55eeaad2ab4dd117524afff9d6e184b',1,'entt::basic_snapshot_loader::operator=()'],['../classentt_1_1basic__continuous__loader.html#afd396d84cb27e070a6a812bd28140c75',1,'entt::basic_continuous_loader::operator=()'],['../classentt_1_1sparse__set.html#a32a00ca96cc7e78089fb7120d144de34',1,'entt::sparse_set::operator=(const sparse_set &other)'],['../classentt_1_1sparse__set.html#a7cb1c0bffe341b847537956075b398fa',1,'entt::sparse_set::operator=(sparse_set &&)=default'],['../classentt_1_1meta__any.html#a80b825c89dc1509a9099d807b528b3aa',1,'entt::meta_any::operator=()'],['../classentt_1_1scheduler.html#aea6ab78dbf00ba17c6e828ee0505afd9',1,'entt::scheduler::operator=()'],['../classentt_1_1resource__cache.html#a1aecfbf6c4faaadb05ce5005c202223c',1,'entt::resource_cache::operator=()'],['../classentt_1_1emitter.html#ab270d2c6d986621a781467e29e64629c',1,'entt::emitter::operator=()']]], + ['operator_3d_3d',['operator==',['../classentt_1_1hashed__string.html#a6f7720e526da38370d52636a8ecb1b50',1,'entt::hashed_string::operator==()'],['../classentt_1_1meta__any.html#a2673fdc066e710ce94cbb2f5c3994d42',1,'entt::meta_any::operator==()'],['../classentt_1_1meta__prop.html#adbcf1179374bab74c2be1f395078b89e',1,'entt::meta_prop::operator==()'],['../classentt_1_1meta__base.html#a6469955ac7550d5396cf185795c07a15',1,'entt::meta_base::operator==()'],['../classentt_1_1meta__conv.html#a176af5a8c4b2fae4dc1d862509705152',1,'entt::meta_conv::operator==()'],['../classentt_1_1meta__ctor.html#a49299869b3adc7a3a97dc9c9cf9617a8',1,'entt::meta_ctor::operator==()'],['../classentt_1_1meta__dtor.html#a55905a8daf9dafcdc33e38e1247b1e9d',1,'entt::meta_dtor::operator==()'],['../classentt_1_1meta__data.html#ac44372da54f317b93fec85570bb50cfc',1,'entt::meta_data::operator==()'],['../classentt_1_1meta__func.html#a4d29a2982e937d0dff5dac93434099a1',1,'entt::meta_func::operator==()'],['../classentt_1_1meta__type.html#a838362aa3598bfa4cc18041d3445bace',1,'entt::meta_type::operator==()'],['../classentt_1_1delegate_3_01Ret_07Args_8_8_8_08_4.html#a54ca30c9a3f7a9662363c48db4e86aae',1,'entt::delegate< Ret(Args...)>::operator==()']]], + ['operator_5b_5d',['operator[]',['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#a9d0986a0b72def2ddbc12ffada355745',1,'entt::basic_group< Entity, get_t< Get... > >::operator[]()'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html#abd790e8ea6c44818592481c8312fc718',1,'entt::basic_group< Entity, get_t< Get... >, Owned... >::operator[]()'],['../classentt_1_1basic__view_3_01Entity_00_01Component_01_4.html#a08e5f6d88283b8e90ce252fcae447932',1,'entt::basic_view< Entity, Component >::operator[]()']]], + ['orphan',['orphan',['../classentt_1_1basic__registry.html#a10f5e61d4cabab9e9c1e87edc30de551',1,'entt::basic_registry']]], + ['orphans',['orphans',['../classentt_1_1basic__registry.html#ae337ceb77e75c10c73ffa671e09bfff8',1,'entt::basic_registry::orphans()'],['../classentt_1_1basic__snapshot__loader.html#acd881016761f5eb598763fbf3595a625',1,'entt::basic_snapshot_loader::orphans()'],['../classentt_1_1basic__continuous__loader.html#ac8b328bb8c6c4acde51ab5b943f0ea86',1,'entt::basic_continuous_loader::orphans()']]], + ['overload',['overload',['../namespaceentt.html#a386a739051d9d37a5578785b77fc426b',1,'entt::overload(Type Class::*member)'],['../namespaceentt.html#a00d50f88cc654b9326f7844b8cb03370',1,'entt::overload(Type *func)']]], + ['owned',['owned',['../classentt_1_1basic__registry.html#a6685b760dd15f8a1976c2d30f852789d',1,'entt::basic_registry']]] ]; diff --git a/search/functions_e.js b/search/functions_e.js index 8e2bf7748..98542aefe 100644 --- a/search/functions_e.js +++ b/search/functions_e.js @@ -1,8 +1,9 @@ var searchData= [ - ['tag',['tag',['../classentt_1_1Snapshot.html#ac13d5fe79511e27f7b935e84c112e051',1,'entt::Snapshot::tag(Archive &archive) const'],['../classentt_1_1Snapshot.html#a960471c2f13bc1c693a9c58396e63b93',1,'entt::Snapshot::tag(Archive &archive) const'],['../classentt_1_1SnapshotLoader.html#afc4964c76a8fc7a8a1c6a435babc796f',1,'entt::SnapshotLoader::tag()'],['../classentt_1_1ContinuousLoader.html#a8d50d3f90d95b370305561da67da6c3b',1,'entt::ContinuousLoader::tag()']]], - ['temp',['temp',['../classentt_1_1ResourceCache.html#a00ad6d9478d2f6721f0a846b49adec07',1,'entt::ResourceCache']]], - ['tick',['tick',['../classentt_1_1Process.html#a9298c55069b27d4ffa005f4345be4d59',1,'entt::Process']]], - ['trigger',['trigger',['../classentt_1_1Dispatcher.html#a89d44e6fa992fba9ba927f4b1492f66f',1,'entt::Dispatcher']]], - ['type',['type',['../classentt_1_1Family.html#aa5ce983dfef17bf0df6a608308193f6d',1,'entt::Family::type()'],['../classentt_1_1Registry.html#a682552d500d7768b5d9d4e5f547cdfaf',1,'entt::Registry::type(tag_t) ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a484018ca7d1898708ea17a651eddc7e4',1,'entt::Registry::type() ENTT_NOEXCEPT']]] + ['parent',['parent',['../classentt_1_1meta__base.html#ad05e984d2cc36f64c0a64fe951e9cdce',1,'entt::meta_base::parent()'],['../classentt_1_1meta__conv.html#a6ca68ad1f28b7e410133f2fa902e2fd5',1,'entt::meta_conv::parent()'],['../classentt_1_1meta__ctor.html#a776c2812dd8724523fc881defb1116f2',1,'entt::meta_ctor::parent()'],['../classentt_1_1meta__dtor.html#ad5cf3129b534f5cb6f736a713f71e37e',1,'entt::meta_dtor::parent()'],['../classentt_1_1meta__data.html#af951f9f860512984d19c706ca3013fed',1,'entt::meta_data::parent()'],['../classentt_1_1meta__func.html#a63056a4d3f0a16c988d90162240fe74d',1,'entt::meta_func::parent()']]], + ['pause',['pause',['../classentt_1_1process.html#a9bf45a6c430f5e32fc7ab33a7a197abc',1,'entt::process']]], + ['paused',['paused',['../classentt_1_1process.html#a2c1c1f5ea78d3b2fc87cfcdbf7a1b40f',1,'entt::process']]], + ['process_5fadaptor',['process_adaptor',['../structentt_1_1process__adaptor.html#ad1e2c8f3c44bf42abb05ef913b8267ce',1,'entt::process_adaptor']]], + ['prop',['prop',['../classentt_1_1meta__ctor.html#ae63dd6567cc8ec0eb871ce253f49f6a7',1,'entt::meta_ctor::prop(Op op) const ENTT_NOEXCEPT'],['../classentt_1_1meta__ctor.html#a20f04e7acdd1988d7f3981a449fdd437',1,'entt::meta_ctor::prop(Key &&key) const ENTT_NOEXCEPT'],['../classentt_1_1meta__data.html#abffe3a3870ba6d7f05c953b7cea50a68',1,'entt::meta_data::prop(Op op) const ENTT_NOEXCEPT'],['../classentt_1_1meta__data.html#a60c8d19929ecd943c286fad22cc210f4',1,'entt::meta_data::prop(Key &&key) const ENTT_NOEXCEPT'],['../classentt_1_1meta__func.html#a28d919188b186ad646b56e0fd1485fc6',1,'entt::meta_func::prop(Op op) const ENTT_NOEXCEPT'],['../classentt_1_1meta__func.html#a9798c7e2216e7d395d57f25ff53a5042',1,'entt::meta_func::prop(Key &&key) const ENTT_NOEXCEPT'],['../classentt_1_1meta__type.html#a9da6947b4a4df64e23f81b3488fa7dff',1,'entt::meta_type::prop(Op op) const ENTT_NOEXCEPT'],['../classentt_1_1meta__type.html#a59d911f5ba7b0a69606b93289bcc21fa',1,'entt::meta_type::prop(Key &&key) const ENTT_NOEXCEPT']]], + ['publish',['publish',['../classentt_1_1emitter.html#a4ece275ff8736bcdcfb4103087801ea2',1,'entt::emitter::publish()'],['../structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#a33009a1bb0c46ae6500dc8475251babe',1,'entt::sigh< Ret(Args...), Collector >::publish()']]] ]; diff --git a/search/functions_f.js b/search/functions_f.js index 585dca5cd..fcc092879 100644 --- a/search/functions_f.js +++ b/search/functions_f.js @@ -1,6 +1,19 @@ var searchData= [ - ['unpause',['unpause',['../classentt_1_1Process.html#aeb2057ef29594395ef68b965e6b27c7e',1,'entt::Process']]], - ['unset',['unset',['../classentt_1_1Prototype.html#ac75f485a3afa9dada4574269be50166d',1,'entt::Prototype']]], - ['update',['update',['../structentt_1_1ProcessAdaptor.html#a46e837972764bdd457f7512212367eb5',1,'entt::ProcessAdaptor::update()'],['../classentt_1_1Scheduler.html#aff001b4bf5aaa53fe1fda94991e73935',1,'entt::Scheduler::update()'],['../classentt_1_1Dispatcher.html#a2c3ffb218856dd962c7e50a5de14b918',1,'entt::Dispatcher::update()'],['../classentt_1_1Dispatcher.html#a88431e5c4e050d8c2e5ee880b920f5a5',1,'entt::Dispatcher::update() const']]] + ['raw',['raw',['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#a5563e4a99012122c42831db0587466b8',1,'entt::basic_group< Entity, get_t< Get... > >::raw()'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html#a64c80eda73138d8510bc519b21209501',1,'entt::basic_group< Entity, get_t< Get... >, Owned... >::raw()'],['../classentt_1_1basic__registry.html#aa0aa5dd120230aecd3b41474acbaecd2',1,'entt::basic_registry::raw() const ENTT_NOEXCEPT'],['../classentt_1_1basic__registry.html#a79751d793fe0f28e8f0e163e46638cb9',1,'entt::basic_registry::raw() ENTT_NOEXCEPT'],['../classentt_1_1basic__storage.html#a8e38d136d24bb38ef96c02135549c5d8',1,'entt::basic_storage::raw() const ENTT_NOEXCEPT'],['../classentt_1_1basic__storage.html#ae7757471c65eca305d2b83b570571065',1,'entt::basic_storage::raw() ENTT_NOEXCEPT'],['../classentt_1_1basic__view.html#acb3b8c843b1ded37a8bac4e9d434d048',1,'entt::basic_view::raw()'],['../classentt_1_1basic__view_3_01Entity_00_01Component_01_4.html#a28da2cdc89a3600cd01ca820e13352f6',1,'entt::basic_view< Entity, Component >::raw()']]], + ['ref',['ref',['../structentt_1_1service__locator.html#ae24d16726620af40371fadeddf5b5e2e',1,'entt::service_locator']]], + ['reflect',['reflect',['../namespaceentt.html#a9739002a4b8c8e752e612b48d941d85a',1,'entt::reflect(const char *str, Property &&... property) ENTT_NOEXCEPT'],['../namespaceentt.html#a3fdbbdb46e1c539b0141ff86b3201393',1,'entt::reflect() ENTT_NOEXCEPT']]], + ['rejected',['rejected',['../classentt_1_1process.html#a6ac63863bf823806d813b046769b4419',1,'entt::process']]], + ['reload',['reload',['../classentt_1_1resource__cache.html#aae5a27a1ecf361409846a5d64cc58088',1,'entt::resource_cache']]], + ['remove',['remove',['../structentt_1_1basic__actor.html#ab740844d18ada7ad15988f808617a1a1',1,'entt::basic_actor::remove()'],['../classentt_1_1basic__registry.html#a44f5eac6fa4d1999a121f55e67a36c24',1,'entt::basic_registry::remove()']]], + ['remove_5fpointer',['remove_pointer',['../classentt_1_1meta__type.html#a89df1ddbee0b5aef2651f1fc712ada20',1,'entt::meta_type']]], + ['replace',['replace',['../classentt_1_1basic__registry.html#a0411735fcddcc942613463c5401dd661',1,'entt::basic_registry']]], + ['reserve',['reserve',['../classentt_1_1basic__registry.html#a632adf32f7b23f1dae8bf4f8800a0bbe',1,'entt::basic_registry::reserve(const size_type cap)'],['../classentt_1_1basic__registry.html#a97677776c466a310547be1fdfdf84ff9',1,'entt::basic_registry::reserve(const size_type cap)'],['../classentt_1_1sparse__set.html#aabfddf33cb086063a471ee06d1778690',1,'entt::sparse_set::reserve()'],['../classentt_1_1basic__storage.html#a54d09089dd33cf9c0e5ac10a1be3fb29',1,'entt::basic_storage::reserve()']]], + ['reset',['reset',['../classentt_1_1basic__registry.html#a95dd0483f9839dfbce8af5ed120b94c2',1,'entt::basic_registry::reset(const entity_type entity)'],['../classentt_1_1basic__registry.html#ac5b546f2508b2a10a6f1d8c77db12837',1,'entt::basic_registry::reset()'],['../classentt_1_1basic__registry.html#a38a7c3696f749d0e873374086c3c0f88',1,'entt::basic_registry::reset()'],['../classentt_1_1sparse__set.html#a46d1553f6837b467f1ddf8ae3dece3d2',1,'entt::sparse_set::reset()'],['../classentt_1_1basic__storage.html#af899b0dbc254608941bcac7b08a6a7ce',1,'entt::basic_storage::reset()'],['../structentt_1_1service__locator.html#a4d655acab54d87058ad41a266830d0e8',1,'entt::service_locator::reset()'],['../classentt_1_1delegate_3_01Ret_07Args_8_8_8_08_4.html#a0d81bb1bde6abd78914cd0a07084bcd7',1,'entt::delegate< Ret(Args...)>::reset()']]], + ['resolve',['resolve',['../namespaceentt.html#a2129cb8668f5dcbc11854be6a4a0b6e5',1,'entt::resolve() ENTT_NOEXCEPT'],['../namespaceentt.html#a1397da6968def57fbee4afc9b1d09df1',1,'entt::resolve(const char *str) ENTT_NOEXCEPT'],['../namespaceentt.html#aa883472f0bd195810aaf482c55f18dcd',1,'entt::resolve(Op op) ENTT_NOEXCEPT']]], + ['resource_5fcache',['resource_cache',['../classentt_1_1resource__cache.html#a919d10578aeda6ad9dd04e1b969b8a9c',1,'entt::resource_cache::resource_cache()=default'],['../classentt_1_1resource__cache.html#ac785934919090b5755a87ab34804b163',1,'entt::resource_cache::resource_cache(resource_cache &&)=default']]], + ['resource_5fhandle',['resource_handle',['../classentt_1_1resource__handle.html#ac0346238aa57dbf5df3ce775ceba856f',1,'entt::resource_handle']]], + ['respect',['respect',['../classentt_1_1sparse__set.html#a600c39f7f77c58a71eb75eef32916e9d',1,'entt::sparse_set::respect()'],['../classentt_1_1basic__storage.html#aac84c253cdf3bf0357d6d729a7430635',1,'entt::basic_storage::respect()']]], + ['ret',['ret',['../classentt_1_1meta__func.html#a6a1bfe7f9b2e8c833dbfb5dff75bf1e9',1,'entt::meta_func']]], + ['runtime_5fview',['runtime_view',['../classentt_1_1basic__registry.html#af1f17548d9527797e366f610e9de36f6',1,'entt::basic_registry']]] ]; diff --git a/search/pages_0.js b/search/pages_0.js index c4ab0306e..522afee4f 100644 --- a/search/pages_0.js +++ b/search/pages_0.js @@ -2,9 +2,10 @@ var searchData= [ ['contributing',['Contributing',['../autotoc_md0.html',1,'']]], ['crash_20course_3a_20core_20functionalities',['Crash Course: core functionalities',['../autotoc_md1.html',1,'']]], - ['crash_20course_3a_20service_20locator',['Crash Course: service locator',['../autotoc_md41.html',1,'']]], - ['crash_20course_3a_20cooperative_20scheduler',['Crash Course: cooperative scheduler',['../autotoc_md44.html',1,'']]], - ['crash_20course_3a_20resource_20management',['Crash Course: resource management',['../autotoc_md49.html',1,'']]], - ['crash_20course_3a_20events_2c_20signals_20and_20everything_20in_20between',['Crash Course: events, signals and everything in between',['../autotoc_md53.html',1,'']]], + ['crash_20course_3a_20service_20locator',['Crash Course: service locator',['../autotoc_md58.html',1,'']]], + ['crash_20course_3a_20reflection_20system',['Crash Course: reflection system',['../autotoc_md61.html',1,'']]], + ['crash_20course_3a_20cooperative_20scheduler',['Crash Course: cooperative scheduler',['../autotoc_md69.html',1,'']]], + ['crash_20course_3a_20resource_20management',['Crash Course: resource management',['../autotoc_md74.html',1,'']]], + ['crash_20course_3a_20events_2c_20signals_20and_20everything_20in_20between',['Crash Course: events, signals and everything in between',['../autotoc_md77.html',1,'']]], ['crash_20course_3a_20entity_2dcomponent_20system',['Crash Course: entity-component system',['../autotoc_md8.html',1,'']]] ]; diff --git a/search/pages_1.js b/search/pages_1.js index ba654c12b..a79d968c0 100644 --- a/search/pages_1.js +++ b/search/pages_1.js @@ -1,4 +1,4 @@ var searchData= [ - ['entt_20and_20shared_20libraries',['EnTT and shared libraries',['../autotoc_md52.html',1,'']]] + ['entt_20in_20action',['EnTT in Action',['../autotoc_md57.html',1,'']]] ]; diff --git a/search/pages_2.html b/search/pages_2.html new file mode 100644 index 000000000..bd9159398 --- /dev/null +++ b/search/pages_2.html @@ -0,0 +1,26 @@ + + + + + + + + + +
+
Loading...
+
+ +
Searching...
+
No Matches
+ +
+ + diff --git a/search/pages_2.js b/search/pages_2.js new file mode 100644 index 000000000..11307f813 --- /dev/null +++ b/search/pages_2.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['frequently_20asked_20questions',['Frequently Asked Questions',['../autotoc_md46.html',1,'']]] +]; diff --git a/search/pages_3.html b/search/pages_3.html new file mode 100644 index 000000000..bc0e37f20 --- /dev/null +++ b/search/pages_3.html @@ -0,0 +1,26 @@ + + + + + + + + + +
+
Loading...
+
+ +
Searching...
+
No Matches
+ +
+ + diff --git a/search/pages_3.js b/search/pages_3.js new file mode 100644 index 000000000..539bbcf47 --- /dev/null +++ b/search/pages_3.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['push_20entt_20across_20boundaries',['Push EnTT across boundaries',['../autotoc_md50.html',1,'']]] +]; diff --git a/search/related_0.js b/search/related_0.js index 54fef6185..ca99f80cb 100644 --- a/search/related_0.js +++ b/search/related_0.js @@ -1,4 +1,4 @@ var searchData= [ - ['emitter',['Emitter',['../structentt_1_1Emitter_1_1Connection.html#a1cad71ec309b8c8b0beee324b9b65e5a',1,'entt::Emitter::Connection']]] + ['basic_5fregistry_3c_20entity_20_3e',['basic_registry< Entity >',['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#a60c928831c22b7dd2216dbc469f68f24',1,'entt::basic_group< Entity, get_t< Get... > >::basic_registry< Entity >()'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html#a60c928831c22b7dd2216dbc469f68f24',1,'entt::basic_group< Entity, get_t< Get... >, Owned... >::basic_registry< Entity >()'],['../classentt_1_1basic__runtime__view.html#a60c928831c22b7dd2216dbc469f68f24',1,'entt::basic_runtime_view::basic_registry< Entity >()'],['../classentt_1_1basic__snapshot.html#a60c928831c22b7dd2216dbc469f68f24',1,'entt::basic_snapshot::basic_registry< Entity >()'],['../classentt_1_1basic__snapshot__loader.html#a60c928831c22b7dd2216dbc469f68f24',1,'entt::basic_snapshot_loader::basic_registry< Entity >()'],['../classentt_1_1basic__view.html#a60c928831c22b7dd2216dbc469f68f24',1,'entt::basic_view::basic_registry< Entity >()'],['../classentt_1_1basic__view_3_01Entity_00_01Component_01_4.html#a60c928831c22b7dd2216dbc469f68f24',1,'entt::basic_view< Entity, Component >::basic_registry< Entity >()']]] ]; diff --git a/search/related_1.js b/search/related_1.js index 0a3b45193..375ad826b 100644 --- a/search/related_1.js +++ b/search/related_1.js @@ -1,5 +1,4 @@ var searchData= [ - ['registry_3c_20entity_20_3e',['Registry< Entity >',['../classentt_1_1Snapshot.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::Snapshot::Registry< Entity >()'],['../classentt_1_1SnapshotLoader.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::SnapshotLoader::Registry< Entity >()'],['../classentt_1_1PersistentView.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::PersistentView::Registry< Entity >()'],['../classentt_1_1View.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::View::Registry< Entity >()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::View< Entity, Component >::Registry< Entity >()'],['../classentt_1_1RawView.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::RawView::Registry< Entity >()'],['../classentt_1_1RuntimeView.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::RuntimeView::Registry< Entity >()']]], - ['resourcecache_3c_20resource_20_3e',['ResourceCache< Resource >',['../classentt_1_1ResourceHandle.html#a302c9d1bd54cf8e7e958d5e505773b23',1,'entt::ResourceHandle::ResourceCache< Resource >()'],['../classentt_1_1ResourceLoader.html#a302c9d1bd54cf8e7e958d5e505773b23',1,'entt::ResourceLoader::ResourceCache< Resource >()']]] + ['emitter',['emitter',['../structentt_1_1emitter_1_1connection.html#a0f3bb10ad57dc0e06298fc9ba38a7bd9',1,'entt::emitter::connection']]] ]; diff --git a/search/related_2.js b/search/related_2.js index 7c31ec93c..a87c574de 100644 --- a/search/related_2.js +++ b/search/related_2.js @@ -1,5 +1,4 @@ var searchData= [ - ['sigh',['SigH',['../classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html#a06123dbbb14806c157626a76c2a2da01',1,'entt::Sink< Ret(Args...)>']]], - ['swap',['swap',['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#a77dd7bf9e63e5457c080416f31bb232b',1,'entt::SigH< Ret(Args...), Collector >']]] + ['meta_5fnode',['meta_node',['../classentt_1_1meta__type.html#a98457ea639e19ea648d32776ac80cd44',1,'entt::meta_type']]] ]; diff --git a/search/related_3.html b/search/related_3.html new file mode 100644 index 000000000..7b0e1d2af --- /dev/null +++ b/search/related_3.html @@ -0,0 +1,26 @@ + + + + + + + + + +
+
Loading...
+
+ +
Searching...
+
No Matches
+ +
+ + diff --git a/search/related_3.js b/search/related_3.js new file mode 100644 index 000000000..3b199781a --- /dev/null +++ b/search/related_3.js @@ -0,0 +1,5 @@ +var searchData= +[ + ['meta_5ffactory',['meta_factory',['../classentt_1_1meta__prop.html#aedfbba32fc3c4d0017b417d21473cddf',1,'entt::meta_prop::meta_factory()'],['../classentt_1_1meta__base.html#aedfbba32fc3c4d0017b417d21473cddf',1,'entt::meta_base::meta_factory()'],['../classentt_1_1meta__conv.html#aedfbba32fc3c4d0017b417d21473cddf',1,'entt::meta_conv::meta_factory()'],['../classentt_1_1meta__ctor.html#aedfbba32fc3c4d0017b417d21473cddf',1,'entt::meta_ctor::meta_factory()'],['../classentt_1_1meta__dtor.html#aedfbba32fc3c4d0017b417d21473cddf',1,'entt::meta_dtor::meta_factory()'],['../classentt_1_1meta__data.html#aedfbba32fc3c4d0017b417d21473cddf',1,'entt::meta_data::meta_factory()'],['../classentt_1_1meta__func.html#aedfbba32fc3c4d0017b417d21473cddf',1,'entt::meta_func::meta_factory()'],['../classentt_1_1meta__type.html#aedfbba32fc3c4d0017b417d21473cddf',1,'entt::meta_type::meta_factory()']]], + ['meta_5fhandle',['meta_handle',['../classentt_1_1meta__any.html#a8b9314fab6c8ba30425b75c7b2e2977e',1,'entt::meta_any']]] +]; diff --git a/search/related_4.html b/search/related_4.html new file mode 100644 index 000000000..360ddb49f --- /dev/null +++ b/search/related_4.html @@ -0,0 +1,26 @@ + + + + + + + + + +
+
Loading...
+
+ +
Searching...
+
No Matches
+ +
+ + diff --git a/search/related_4.js b/search/related_4.js new file mode 100644 index 000000000..01a1aa186 --- /dev/null +++ b/search/related_4.js @@ -0,0 +1,5 @@ +var searchData= +[ + ['reflect',['reflect',['../classentt_1_1meta__factory.html#aa42fdb45a8b89dcb693ea717ec3106f2',1,'entt::meta_factory']]], + ['resource_5fcache_3c_20resource_20_3e',['resource_cache< Resource >',['../classentt_1_1resource__handle.html#aa58438d97a0e80057bbb837e2a4477d6',1,'entt::resource_handle::resource_cache< Resource >()'],['../classentt_1_1resource__loader.html#aa58438d97a0e80057bbb837e2a4477d6',1,'entt::resource_loader::resource_cache< Resource >()']]] +]; diff --git a/search/related_5.html b/search/related_5.html new file mode 100644 index 000000000..f1dbc2831 --- /dev/null +++ b/search/related_5.html @@ -0,0 +1,26 @@ + + + + + + + + + +
+
Loading...
+
+ +
Searching...
+
No Matches
+ +
+ + diff --git a/search/related_5.js b/search/related_5.js new file mode 100644 index 000000000..be8f1f133 --- /dev/null +++ b/search/related_5.js @@ -0,0 +1,5 @@ +var searchData= +[ + ['sigh',['sigh',['../classentt_1_1sink_3_01Ret_07Args_8_8_8_08_4.html#a312dc0d91e6a3d5eec9f202a263c7e47',1,'entt::sink< Ret(Args...)>']]], + ['swap',['swap',['../classentt_1_1meta__any.html#a939cebbfd07b49ed6365c302f838dc03',1,'entt::meta_any::swap()'],['../structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#a85fb0c034b7e550330ff267bb1bcdfce',1,'entt::sigh< Ret(Args...), Collector >::swap()']]] +]; diff --git a/search/related_6.html b/search/related_6.html new file mode 100644 index 000000000..b1955044b --- /dev/null +++ b/search/related_6.html @@ -0,0 +1,26 @@ + + + + + + + + + +
+
Loading...
+
+ +
Searching...
+
No Matches
+ +
+ + diff --git a/search/related_6.js b/search/related_6.js new file mode 100644 index 000000000..0bfbc9140 --- /dev/null +++ b/search/related_6.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['unregister',['unregister',['../classentt_1_1meta__factory.html#aa43299816c83740fdf20e6d7687f9055',1,'entt::meta_factory']]] +]; diff --git a/search/searchdata.js b/search/searchdata.js index 0e874e987..559cfea78 100644 --- a/search/searchdata.js +++ b/search/searchdata.js @@ -1,13 +1,13 @@ var indexSectionsWithContent = { - 0: "abcdefghilmnoprstuv~", - 1: "acdefhimoprstv", + 0: "abcdefghiklmnoprstuv~", + 1: "abcdefghimnprst", 2: "e", - 3: "abcdefghlmoprstuv~", - 4: "env", - 5: "cdefhilorstv", - 6: "ers", - 7: "ce" + 3: "abcdefghiklmnoprstuv~", + 4: "cegimnstv", + 5: "acdefghilnoprstv", + 6: "beimrsu", + 7: "cefp" }; var indexSectionNames = diff --git a/search/typedefs_0.js b/search/typedefs_0.js index 91753c24d..dd7e12d2a 100644 --- a/search/typedefs_0.js +++ b/search/typedefs_0.js @@ -1,6 +1,4 @@ var searchData= [ - ['collector_5ftype',['collector_type',['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#ad0e4e34e41daec83437b1c607855079a',1,'entt::SigH< Ret(Args...), Collector >']]], - ['component_5ftype',['component_type',['../classentt_1_1Registry.html#aefd07a0cdff88ebf1e35e531d58c3077',1,'entt::Registry']]], - ['const_5fiterator_5ftype',['const_iterator_type',['../classentt_1_1SparseSet_3_01Entity_01_4.html#aba42055f0c8a43cae63d443a17f6a5e2',1,'entt::SparseSet< Entity >::const_iterator_type()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a947d3fd0440167f469331a31b1d8d782',1,'entt::SparseSet< Entity, Type >::const_iterator_type()'],['../classentt_1_1PersistentView.html#a260bd2740fb90caf984ce62c26bb887b',1,'entt::PersistentView::const_iterator_type()'],['../classentt_1_1View.html#a81b76e0389ffeb60195a3391c4c5ce3a',1,'entt::View::const_iterator_type()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a79316bcf7c15b52712689653fff419c3',1,'entt::View< Entity, Component >::const_iterator_type()'],['../classentt_1_1RawView.html#a5fa9cd28fb18ccfe01fd0eb3ea6e3dc7',1,'entt::RawView::const_iterator_type()'],['../classentt_1_1RuntimeView.html#acf976983924a5e0194a19a9b98fdc249',1,'entt::RuntimeView::const_iterator_type()']]] + ['actor',['actor',['../namespaceentt.html#a3effdbc1557d9b1ffaed77f843c5c2cd',1,'entt']]] ]; diff --git a/search/typedefs_1.js b/search/typedefs_1.js index cd708185d..46c25a94e 100644 --- a/search/typedefs_1.js +++ b/search/typedefs_1.js @@ -1,8 +1,7 @@ var searchData= [ - ['defaultactor',['DefaultActor',['../namespaceentt.html#a0790fdd772249d8b22f1cf2d5e2403d4',1,'entt']]], - ['defaultprototype',['DefaultPrototype',['../namespaceentt.html#a94d8a4552b7bd5a3543c2ffc6eaf878c',1,'entt']]], - ['defaultregistry',['DefaultRegistry',['../namespaceentt.html#aa56ef01a9c62f21d68dd60f005296b23',1,'entt']]], - ['delta_5ftype',['delta_type',['../classentt_1_1Process.html#aaa304f69a0344fffd3a53daa922284ad',1,'entt::Process']]], - ['difference_5ftype',['difference_type',['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#ac16a602de26d43d316b497cb11b7c6b2',1,'entt::entt_traits< std::uint16_t >::difference_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#a9809b457e16f4a071a91530b23c930d6',1,'entt::entt_traits< std::uint32_t >::difference_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#afba2f77f80b0bf89a208f6876ab67271',1,'entt::entt_traits< std::uint64_t >::difference_type()']]] + ['collector_5ftype',['collector_type',['../structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#aa1ed972f1fffb437a3b3c115fabe0532',1,'entt::sigh< Ret(Args...), Collector >']]], + ['component_5ftype',['component_type',['../classentt_1_1basic__registry.html#ace85f74fac787b967100f4186860f226',1,'entt::basic_registry']]], + ['const_5fiterator_5ftype',['const_iterator_type',['../classentt_1_1basic__storage.html#aaa02d4db8defee92683bbc47b3eaa869',1,'entt::basic_storage']]], + ['continuous_5floader',['continuous_loader',['../namespaceentt.html#a37b5b489846f6f2a5d143db2b4aea5d0',1,'entt']]] ]; diff --git a/search/typedefs_2.js b/search/typedefs_2.js index 02723bc92..ef73d1a0b 100644 --- a/search/typedefs_2.js +++ b/search/typedefs_2.js @@ -1,4 +1,5 @@ var searchData= [ - ['entity_5ftype',['entity_type',['../structentt_1_1Actor.html#a809cbe96d54fe86b470246a34e873a4e',1,'entt::Actor::entity_type()'],['../classentt_1_1Attachee_3_01Entity_01_4.html#ab29a9628056147ed6eec373a1d0e6b32',1,'entt::Attachee< Entity >::entity_type()'],['../classentt_1_1Attachee_3_01Entity_00_01Type_01_4.html#ae2bc6eb2a7828941bab842f3dd4d4247',1,'entt::Attachee< Entity, Type >::entity_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#a86e202c8932f341626b29c194bd47489',1,'entt::entt_traits< std::uint16_t >::entity_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#aecde3ac9bfc28e7f0f880a74ee2c5d8f',1,'entt::entt_traits< std::uint32_t >::entity_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#a304eb4dc4a1487cf2966d902214f7185',1,'entt::entt_traits< std::uint64_t >::entity_type()'],['../classentt_1_1Prototype.html#ab4542df6834170b6f0d96828d094269d',1,'entt::Prototype::entity_type()'],['../classentt_1_1Registry.html#ad434a1920dd2c6a9a31ab482e2f29038',1,'entt::Registry::entity_type()'],['../classentt_1_1ContinuousLoader.html#ae2ddecfaeb16ddbf340b6ca643036c6f',1,'entt::ContinuousLoader::entity_type()'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a7d36e852257a965a9a0ed3fb636433e2',1,'entt::SparseSet< Entity >::entity_type()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#afe382e2d5c8769fb3d924e1a357cf9b0',1,'entt::SparseSet< Entity, Type >::entity_type()'],['../classentt_1_1PersistentView.html#a5195c9d1dede0fe6c40bea576398022b',1,'entt::PersistentView::entity_type()'],['../classentt_1_1View.html#a61be0e712de89d1eb275e14bbc59174e',1,'entt::View::entity_type()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a75fc64bf381a3003d8acf03ed66728f2',1,'entt::View< Entity, Component >::entity_type()'],['../classentt_1_1RawView.html#a544ee87b4a856cfa5c49ea4581c85a35',1,'entt::RawView::entity_type()'],['../classentt_1_1RuntimeView.html#ad5b5d664d388179dc164814e6268a774',1,'entt::RuntimeView::entity_type()']]] + ['delta_5ftype',['delta_type',['../classentt_1_1process.html#a625b574ea6d83e3a4933acc3d0279295',1,'entt::process']]], + ['difference_5ftype',['difference_type',['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#ac16a602de26d43d316b497cb11b7c6b2',1,'entt::entt_traits< std::uint16_t >::difference_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#a9809b457e16f4a071a91530b23c930d6',1,'entt::entt_traits< std::uint32_t >::difference_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#afba2f77f80b0bf89a208f6876ab67271',1,'entt::entt_traits< std::uint64_t >::difference_type()']]] ]; diff --git a/search/typedefs_3.js b/search/typedefs_3.js index 46c788213..db34c10a8 100644 --- a/search/typedefs_3.js +++ b/search/typedefs_3.js @@ -1,4 +1,5 @@ var searchData= [ - ['family_5ftype',['family_type',['../classentt_1_1Family.html#a263330fe09b437d3d91b8769f6a9fc77',1,'entt::Family']]] + ['entity',['entity',['../namespaceentt.html#ad777a7dd756427c5ee570d7c0543d339',1,'entt']]], + ['entity_5ftype',['entity_type',['../structentt_1_1basic__actor.html#a2c2e10f12014f5269be0b9ab055acfca',1,'entt::basic_actor::entity_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#a86e202c8932f341626b29c194bd47489',1,'entt::entt_traits< std::uint16_t >::entity_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#aecde3ac9bfc28e7f0f880a74ee2c5d8f',1,'entt::entt_traits< std::uint32_t >::entity_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#a304eb4dc4a1487cf2966d902214f7185',1,'entt::entt_traits< std::uint64_t >::entity_type()'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#a6e655df47eca24e9f0885f1114eac566',1,'entt::basic_group< Entity, get_t< Get... > >::entity_type()'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html#a364afe2787baf1f17fe4a8af294356b2',1,'entt::basic_group< Entity, get_t< Get... >, Owned... >::entity_type()'],['../classentt_1_1basic__prototype.html#a0a8606dc36496d42f6188acdad4906f3',1,'entt::basic_prototype::entity_type()'],['../classentt_1_1basic__registry.html#a86f7d4defe404257da3be0e94cc3b6fd',1,'entt::basic_registry::entity_type()'],['../classentt_1_1basic__runtime__view.html#a8347b5b209e9dd8962c7b98c3314bae6',1,'entt::basic_runtime_view::entity_type()'],['../classentt_1_1basic__continuous__loader.html#a90a0d33147978cb3c142408487428277',1,'entt::basic_continuous_loader::entity_type()'],['../classentt_1_1sparse__set.html#a9a1dbe5ab2dbb098beae0bff56bbf780',1,'entt::sparse_set::entity_type()'],['../classentt_1_1basic__storage.html#ab2520abd2591d114866414f275cbdaa7',1,'entt::basic_storage::entity_type()'],['../classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty__v_3_01Type_01_4_01_4_01_4.html#adcf45b53722e877c6c8b92e87ecc7824',1,'entt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >::entity_type()'],['../classentt_1_1basic__view.html#a4d733f92580b2623300174292e47c7cf',1,'entt::basic_view::entity_type()'],['../classentt_1_1basic__view_3_01Entity_00_01Component_01_4.html#aecda0b0101603b9342248086dcb71ec5',1,'entt::basic_view< Entity, Component >::entity_type()']]] ]; diff --git a/search/typedefs_4.js b/search/typedefs_4.js index 899cac939..7cb908829 100644 --- a/search/typedefs_4.js +++ b/search/typedefs_4.js @@ -1,4 +1,5 @@ var searchData= [ - ['hash_5ftype',['hash_type',['../classentt_1_1HashedString.html#af511100177b5e0213bf5b0efb3f4f528',1,'entt::HashedString']]] + ['family_5ftype',['family_type',['../classentt_1_1family.html#a86a662c9342935bcf145b70bf36191cb',1,'entt::family']]], + ['function_5ftype',['function_type',['../classentt_1_1delegate_3_01Ret_07Args_8_8_8_08_4.html#a235927a00f56e4b56dbfdc4e6cf5ddb4',1,'entt::delegate< Ret(Args...)>']]] ]; diff --git a/search/typedefs_5.js b/search/typedefs_5.js index 35223a241..a1ac1da5c 100644 --- a/search/typedefs_5.js +++ b/search/typedefs_5.js @@ -1,6 +1,4 @@ var searchData= [ - ['identifier_5ftype',['identifier_type',['../classentt_1_1Identifier.html#a80c4fd9773928949e788790fac671169',1,'entt::Identifier']]], - ['instance_5ftype',['instance_type',['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#aad306ac41adf5562740f5528bed80014',1,'entt::SigH< Ret(Args...), Collector >']]], - ['iterator_5ftype',['iterator_type',['../classentt_1_1SparseSet_3_01Entity_01_4.html#a1ad77aed1e49af60b61044c996969b9a',1,'entt::SparseSet< Entity >::iterator_type()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a7ff4726f5e0ae6698cb8e3f039289b52',1,'entt::SparseSet< Entity, Type >::iterator_type()'],['../classentt_1_1PersistentView.html#ae563ed31a62fd9f33f93767f0ecdfff5',1,'entt::PersistentView::iterator_type()'],['../classentt_1_1View.html#a738fb04a466b1f858a1eb5d7bc8fd668',1,'entt::View::iterator_type()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a791a1288db896fda8e77acad396aa513',1,'entt::View< Entity, Component >::iterator_type()'],['../classentt_1_1RawView.html#ab34740dea79327742888e84ba5c14328',1,'entt::RawView::iterator_type()'],['../classentt_1_1RuntimeView.html#a59c6645fb86e079986d04887aa7c74e1',1,'entt::RuntimeView::iterator_type()']]] + ['group',['group',['../namespaceentt.html#a010d1bbf234dbca47e6755fc278e36b5',1,'entt']]] ]; diff --git a/search/typedefs_6.js b/search/typedefs_6.js index 1f5add80c..fdab80a04 100644 --- a/search/typedefs_6.js +++ b/search/typedefs_6.js @@ -1,5 +1,4 @@ var searchData= [ - ['label',['label',['../namespaceentt.html#a8512c4b75207424bd97724a17cd1eeb0',1,'entt']]], - ['listener',['Listener',['../classentt_1_1Emitter.html#a1a5bb5d6a7626aec285cc73bfc1e80ef',1,'entt::Emitter']]] + ['hash_5ftype',['hash_type',['../classentt_1_1hashed__string.html#a71cb1793c1193bd6c89c42a00179793f',1,'entt::hashed_string']]] ]; diff --git a/search/typedefs_7.js b/search/typedefs_7.js index e45dcafce..fe2e13d73 100644 --- a/search/typedefs_7.js +++ b/search/typedefs_7.js @@ -1,4 +1,6 @@ var searchData= [ - ['object_5ftype',['object_type',['../classentt_1_1Attachee_3_01Entity_00_01Type_01_4.html#a081468359310ab5cf3807d044ba4a8d6',1,'entt::Attachee< Entity, Type >::object_type()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#af7db79dfb4e031a63fa526d4f7d54915',1,'entt::SparseSet< Entity, Type >::object_type()']]] + ['identifier_5ftype',['identifier_type',['../classentt_1_1identifier.html#ae35c46f5811183291dd25294e7d82f92',1,'entt::identifier']]], + ['instance_5ftype',['instance_type',['../structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#adfd38e6a8d026f9418d60c207edcd295',1,'entt::sigh< Ret(Args...), Collector >']]], + ['iterator_5ftype',['iterator_type',['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#aad8c6789036e02b7c4f2823255e7f16e',1,'entt::basic_group< Entity, get_t< Get... > >::iterator_type()'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html#aafbded588937b50f5ce4ee6d79a559e6',1,'entt::basic_group< Entity, get_t< Get... >, Owned... >::iterator_type()'],['../classentt_1_1basic__runtime__view.html#afbaa87a1aa3eacd54ec3a5462faa10da',1,'entt::basic_runtime_view::iterator_type()'],['../classentt_1_1sparse__set.html#a580b210d5a24c49ca8c255646f3bb469',1,'entt::sparse_set::iterator_type()'],['../classentt_1_1basic__storage.html#a9a1c32a0adebc8c3dc279064742c858f',1,'entt::basic_storage::iterator_type()'],['../classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty__v_3_01Type_01_4_01_4_01_4.html#a2136db82a122b336298bd909c07c629b',1,'entt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >::iterator_type()'],['../classentt_1_1basic__view.html#adad369b0a841ef254549668348fed0c5',1,'entt::basic_view::iterator_type()'],['../classentt_1_1basic__view_3_01Entity_00_01Component_01_4.html#a11420baf6cdbf1a97f3861784bd5fac2',1,'entt::basic_view< Entity, Component >::iterator_type()']]] ]; diff --git a/search/typedefs_8.js b/search/typedefs_8.js index df5c8744d..c8beb8d0d 100644 --- a/search/typedefs_8.js +++ b/search/typedefs_8.js @@ -1,6 +1,4 @@ var searchData= [ - ['raw_5ftype',['raw_type',['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a8bdfb1fbdd4340131be9c70bf02671b5',1,'entt::View< Entity, Component >::raw_type()'],['../classentt_1_1RawView.html#a6a6e2cd0387a63e153a18bd60a1283a3',1,'entt::RawView::raw_type()']]], - ['registry_5ftype',['registry_type',['../structentt_1_1Actor.html#a59ce601affb52396d2cacdc3ffd14928',1,'entt::Actor::registry_type()'],['../classentt_1_1Prototype.html#a8e4a91009c1cbb0bfaadf4e95178eaec',1,'entt::Prototype::registry_type()']]], - ['resource_5ftype',['resource_type',['../classentt_1_1ResourceCache.html#a4936da93a62827d8c5fc04ac444e5456',1,'entt::ResourceCache']]] + ['listener',['listener',['../classentt_1_1emitter.html#a460311b6b4adfabe69b9d964c8d0b579',1,'entt::emitter']]] ]; diff --git a/search/typedefs_9.js b/search/typedefs_9.js index 848e40efc..5f7c7886c 100644 --- a/search/typedefs_9.js +++ b/search/typedefs_9.js @@ -1,6 +1,4 @@ var searchData= [ - ['service_5ftype',['service_type',['../structentt_1_1ServiceLocator.html#a0631b136adf579365fb444bc5e8f1416',1,'entt::ServiceLocator']]], - ['sink_5ftype',['sink_type',['../classentt_1_1Registry.html#ada8da3c42b6f37209255eef008581b0b',1,'entt::Registry::sink_type()'],['../classentt_1_1Dispatcher.html#a3b34b8591cdd82022dba3c542054fe68',1,'entt::Dispatcher::sink_type()'],['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#afe3b68f9dc0a2bfe92081c256d0108b7',1,'entt::SigH< Ret(Args...), Collector >::sink_type()']]], - ['size_5ftype',['size_type',['../classentt_1_1Prototype.html#a2a593566474356ad2a03fea9b122de93',1,'entt::Prototype::size_type()'],['../classentt_1_1Registry.html#a741ffda6e06838c5593ba97adc7658e2',1,'entt::Registry::size_type()'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#ab81c48dcee7a1104ee82794613ee7ed2',1,'entt::SparseSet< Entity >::size_type()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a27a88e2bb0822de41131741d9ffcded5',1,'entt::SparseSet< Entity, Type >::size_type()'],['../classentt_1_1PersistentView.html#ac2e81caacece38b84f46c4430cd8cf4e',1,'entt::PersistentView::size_type()'],['../classentt_1_1View.html#ab3f86ec55935bbbb00077bbe07f15c4b',1,'entt::View::size_type()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#afa754b0f10b28dbdb2149b5b8d0fdf73',1,'entt::View< Entity, Component >::size_type()'],['../classentt_1_1RawView.html#afc530c9c64688b522ac643fdb5a0bb6e',1,'entt::RawView::size_type()'],['../classentt_1_1RuntimeView.html#a64ed96d1933ffff0e76f96a0cb38428e',1,'entt::RuntimeView::size_type()'],['../classentt_1_1Scheduler.html#a2d76dbf324cf960ac8f2fc6d87d40eba',1,'entt::Scheduler::size_type()'],['../classentt_1_1ResourceCache.html#a439daf6009e24ae40b1d7689c60ead48',1,'entt::ResourceCache::size_type()'],['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#a7635c4c773fee73faf6eddda2d4abb87',1,'entt::SigH< Ret(Args...), Collector >::size_type()']]] + ['named_5ftype_5ftraits_5ft',['named_type_traits_t',['../namespaceentt.html#a63a1328e9f26407f68f4f814ab86ad6f',1,'entt']]] ]; diff --git a/search/typedefs_a.js b/search/typedefs_a.js index 8616bb777..6da45a36b 100644 --- a/search/typedefs_a.js +++ b/search/typedefs_a.js @@ -1,4 +1,4 @@ var searchData= [ - ['tag_5ftype',['tag_type',['../classentt_1_1Registry.html#a357cfdc1b3c5abc7a36e8eddbd6ce5c7',1,'entt::Registry']]] + ['object_5ftype',['object_type',['../classentt_1_1basic__storage.html#aa4e4358d25212b71d9629e470b845c53',1,'entt::basic_storage::object_type()'],['../classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty__v_3_01Type_01_4_01_4_01_4.html#af67063212a566afa51deede112b70d2a',1,'entt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >::object_type()']]] ]; diff --git a/search/typedefs_b.js b/search/typedefs_b.js index b8dd61089..1b18b6132 100644 --- a/search/typedefs_b.js +++ b/search/typedefs_b.js @@ -1,4 +1,4 @@ var searchData= [ - ['version_5ftype',['version_type',['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#ab37d10c3be3d59159a63c0bd1e9e2924',1,'entt::entt_traits< std::uint16_t >::version_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#aee59dc7455ea0be015e699c3e46a22d1',1,'entt::entt_traits< std::uint32_t >::version_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#aeac4d9172940a9dec0682860ac176725',1,'entt::entt_traits< std::uint64_t >::version_type()'],['../classentt_1_1Registry.html#a82c8996277034df5e72b5f30a70ebb2d',1,'entt::Registry::version_type()']]] + ['prototype',['prototype',['../namespaceentt.html#a5db962f82244acf52040d0a1eca2c13a',1,'entt']]] ]; diff --git a/search/typedefs_c.html b/search/typedefs_c.html new file mode 100644 index 000000000..28f5aad20 --- /dev/null +++ b/search/typedefs_c.html @@ -0,0 +1,26 @@ + + + + + + + + + +
+
Loading...
+
+ +
Searching...
+
No Matches
+ +
+ + diff --git a/search/typedefs_c.js b/search/typedefs_c.js new file mode 100644 index 000000000..edb985e58 --- /dev/null +++ b/search/typedefs_c.js @@ -0,0 +1,8 @@ +var searchData= +[ + ['raw_5ftype',['raw_type',['../classentt_1_1basic__view_3_01Entity_00_01Component_01_4.html#a07488b51f1575b2e5740f3d5f21e0524',1,'entt::basic_view< Entity, Component >']]], + ['registry',['registry',['../namespaceentt.html#a292643317d1dbb13e45824f757bd1086',1,'entt']]], + ['registry_5ftype',['registry_type',['../structentt_1_1basic__actor.html#a4577b087e2fe3e76dbd4516ae9064c6a',1,'entt::basic_actor::registry_type()'],['../structentt_1_1as__view.html#a458942b049c7ef96d45600337d57a70b',1,'entt::as_view::registry_type()'],['../structentt_1_1as__group.html#a7ede36514bf64187bc93d3d295fe0123',1,'entt::as_group::registry_type()'],['../classentt_1_1basic__prototype.html#aa7b03fff67dee5898849c971bc341962',1,'entt::basic_prototype::registry_type()']]], + ['resource_5ftype',['resource_type',['../classentt_1_1resource__cache.html#a178e741d1df5b41b0d27f814b6d061a7',1,'entt::resource_cache']]], + ['runtime_5fview',['runtime_view',['../namespaceentt.html#a85d470a55d982d87388e899c322e9ddc',1,'entt']]] +]; diff --git a/search/typedefs_d.html b/search/typedefs_d.html new file mode 100644 index 000000000..15794829d --- /dev/null +++ b/search/typedefs_d.html @@ -0,0 +1,26 @@ + + + + + + + + + +
+
Loading...
+
+ +
Searching...
+
No Matches
+ +
+ + diff --git a/search/typedefs_d.js b/search/typedefs_d.js new file mode 100644 index 000000000..bc3109d1c --- /dev/null +++ b/search/typedefs_d.js @@ -0,0 +1,8 @@ +var searchData= +[ + ['service_5ftype',['service_type',['../structentt_1_1service__locator.html#af34a883e56f32a98d7b8a5db87bdf504',1,'entt::service_locator']]], + ['sink_5ftype',['sink_type',['../classentt_1_1dispatcher.html#a9ab3b084146a292b2dd2411cea452273',1,'entt::dispatcher::sink_type()'],['../structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#adcfc3a58cb6421c41637461e9ac97812',1,'entt::sigh< Ret(Args...), Collector >::sink_type()']]], + ['size_5ftype',['size_type',['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_01_4.html#aeeca37a280faff7a53129a9b712ee523',1,'entt::basic_group< Entity, get_t< Get... > >::size_type()'],['../classentt_1_1basic__group_3_01Entity_00_01get__t_3_01Get_8_8_8_01_4_00_01Owned_8_8_8_01_4.html#a515301bf580587caac4bdfdf8d178623',1,'entt::basic_group< Entity, get_t< Get... >, Owned... >::size_type()'],['../classentt_1_1basic__prototype.html#a01d3afe0260e80974f24c1d36b5fbccc',1,'entt::basic_prototype::size_type()'],['../classentt_1_1basic__registry.html#a19addadd1c414778261e7c1ed67eee76',1,'entt::basic_registry::size_type()'],['../classentt_1_1basic__runtime__view.html#af8fef2e30d39eaa7ce736539a55c2a1a',1,'entt::basic_runtime_view::size_type()'],['../classentt_1_1sparse__set.html#a3d2138b0eb8c7ac968e9e38a9e981ec1',1,'entt::sparse_set::size_type()'],['../classentt_1_1basic__storage.html#ab820e508dfbc4442bc9a114cf49efde7',1,'entt::basic_storage::size_type()'],['../classentt_1_1basic__storage_3_01Entity_00_01Type_00_01std_1_1enable__if__t_3_01std_1_1is__empty__v_3_01Type_01_4_01_4_01_4.html#a9c0a52b283bc9b0ac2b7bf72cc76f996',1,'entt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >::size_type()'],['../classentt_1_1basic__view.html#a8f3ec253d7fc6da42e9eb0e5c8f6a655',1,'entt::basic_view::size_type()'],['../classentt_1_1basic__view_3_01Entity_00_01Component_01_4.html#aecab46810f8e3a65a3aa46e14028b40a',1,'entt::basic_view< Entity, Component >::size_type()'],['../classentt_1_1meta__ctor.html#a7a267e333222dab22e7a965137538f18',1,'entt::meta_ctor::size_type()'],['../classentt_1_1meta__func.html#a422ec572c7c56d3cb46d09704be64f65',1,'entt::meta_func::size_type()'],['../classentt_1_1meta__type.html#a7362687fc89444507cded22f57be3ff0',1,'entt::meta_type::size_type()'],['../classentt_1_1scheduler.html#a7b08d5871918b39049c29e4daa62271f',1,'entt::scheduler::size_type()'],['../classentt_1_1resource__cache.html#abfb6bd59f656ca6139602bbc7bb4c24a',1,'entt::resource_cache::size_type()'],['../structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#accb002f3088f2a3b5b5ff1fdd24fd353',1,'entt::sigh< Ret(Args...), Collector >::size_type()']]], + ['snapshot',['snapshot',['../namespaceentt.html#a80012f9fa628920a3507ae947704d447',1,'entt']]], + ['snapshot_5floader',['snapshot_loader',['../namespaceentt.html#ae7e50fc296c4ea68183db332950b99f5',1,'entt']]] +]; diff --git a/search/typedefs_e.html b/search/typedefs_e.html new file mode 100644 index 000000000..f61d902eb --- /dev/null +++ b/search/typedefs_e.html @@ -0,0 +1,26 @@ + + + + + + + + + +
+
Loading...
+
+ +
Searching...
+
No Matches
+ +
+ + diff --git a/search/typedefs_e.js b/search/typedefs_e.js new file mode 100644 index 000000000..8ddb993c9 --- /dev/null +++ b/search/typedefs_e.js @@ -0,0 +1,7 @@ +var searchData= +[ + ['tag',['tag',['../namespaceentt.html#af3e97711799c25b85af58006541601e2',1,'entt']]], + ['type',['type',['../structentt_1_1type__list__cat_3_01type__list_3_01Type_8_8_8_01_4_00_01type__list_3_01Other_8_8_8_01_4_00_01List_8_8_8_01_4.html#ae17db475954ad06eba24fd1eedba5f8b',1,'entt::type_list_cat< type_list< Type... >, type_list< Other... >, List... >::type()'],['../structentt_1_1type__list__cat_3_01type__list_3_01Type_8_8_8_01_4_01_4.html#a0c40287fad9d80f0532d80bf48f219ed',1,'entt::type_list_cat< type_list< Type... > >::type()'],['../structentt_1_1type__list__unique_3_01type__list_3_01Type_00_01Other_8_8_8_01_4_01_4.html#a378823486aa4e4f288b1d73b2703c485',1,'entt::type_list_unique< type_list< Type, Other... > >::type()'],['../structentt_1_1type__list__unique_3_01type__list_3_4_01_4.html#a48245981f9818ca2601b9815cbfa5b79',1,'entt::type_list_unique< type_list<> >::type()']]], + ['type_5flist_5fcat_5ft',['type_list_cat_t',['../namespaceentt.html#a546467a3662e9a915d5d519ad565e801',1,'entt']]], + ['type_5flist_5funique_5ft',['type_list_unique_t',['../namespaceentt.html#a75a277a6037279d65cd3874b46ec7166',1,'entt']]] +]; diff --git a/search/typedefs_f.html b/search/typedefs_f.html new file mode 100644 index 000000000..aefe57589 --- /dev/null +++ b/search/typedefs_f.html @@ -0,0 +1,26 @@ + + + + + + + + + +
+
Loading...
+
+ +
Searching...
+
No Matches
+ +
+ + diff --git a/search/typedefs_f.js b/search/typedefs_f.js new file mode 100644 index 000000000..3236fc051 --- /dev/null +++ b/search/typedefs_f.js @@ -0,0 +1,5 @@ +var searchData= +[ + ['version_5ftype',['version_type',['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#ab37d10c3be3d59159a63c0bd1e9e2924',1,'entt::entt_traits< std::uint16_t >::version_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#aee59dc7455ea0be015e699c3e46a22d1',1,'entt::entt_traits< std::uint32_t >::version_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#aeac4d9172940a9dec0682860ac176725',1,'entt::entt_traits< std::uint64_t >::version_type()'],['../classentt_1_1basic__registry.html#aae2197c81e29459bbe3fa7984656a2b6',1,'entt::basic_registry::version_type()']]], + ['view',['view',['../namespaceentt.html#af2118c00dea16193aee017d1408beb53',1,'entt']]] +]; diff --git a/search/variables_0.js b/search/variables_0.js index ff09483df..ad9dee471 100644 --- a/search/variables_0.js +++ b/search/variables_0.js @@ -1,5 +1,4 @@ var searchData= [ - ['entity_5fmask',['entity_mask',['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#a3b85bff62534fc16597a391161fdc884',1,'entt::entt_traits< std::uint16_t >::entity_mask()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#a10edcf27d0e80e58102f41372d4b8df8',1,'entt::entt_traits< std::uint32_t >::entity_mask()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#a1127933a9ef4bfa4f64ded191b4342dd',1,'entt::entt_traits< std::uint64_t >::entity_mask()']]], - ['entity_5fshift',['entity_shift',['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#aedc1e30160a37f69a5e6cc903a5113cc',1,'entt::entt_traits< std::uint16_t >::entity_shift()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#ad2fb05bba66c9426a4c239222a191650',1,'entt::entt_traits< std::uint32_t >::entity_shift()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#abbf9ff9ddaf2cb92eec8bd08dcc7d5a7',1,'entt::entt_traits< std::uint64_t >::entity_shift()']]] + ['connect_5farg',['connect_arg',['../namespaceentt.html#af1e73acd6f3d892955819677dc2664b7',1,'entt']]] ]; diff --git a/search/variables_1.js b/search/variables_1.js index ae2385a1f..136b09403 100644 --- a/search/variables_1.js +++ b/search/variables_1.js @@ -1,4 +1,6 @@ var searchData= [ - ['null',['null',['../namespaceentt.html#a588326af8f6f902a6c0b57d3f9fc6c17',1,'entt']]] + ['entity_5fmask',['entity_mask',['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#a3b85bff62534fc16597a391161fdc884',1,'entt::entt_traits< std::uint16_t >::entity_mask()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#a10edcf27d0e80e58102f41372d4b8df8',1,'entt::entt_traits< std::uint32_t >::entity_mask()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#a1127933a9ef4bfa4f64ded191b4342dd',1,'entt::entt_traits< std::uint64_t >::entity_mask()']]], + ['entity_5fshift',['entity_shift',['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#aedc1e30160a37f69a5e6cc903a5113cc',1,'entt::entt_traits< std::uint16_t >::entity_shift()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#ad2fb05bba66c9426a4c239222a191650',1,'entt::entt_traits< std::uint32_t >::entity_shift()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#abbf9ff9ddaf2cb92eec8bd08dcc7d5a7',1,'entt::entt_traits< std::uint64_t >::entity_shift()']]], + ['exclude',['exclude',['../namespaceentt.html#a5b73210cef43c4db35ef8ce477cc38a6',1,'entt']]] ]; diff --git a/search/variables_2.js b/search/variables_2.js index 5a7af64e4..fed0ff145 100644 --- a/search/variables_2.js +++ b/search/variables_2.js @@ -1,4 +1,4 @@ var searchData= [ - ['version_5fmask',['version_mask',['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#a83bda73c5a360f5ba8f653d0f888993b',1,'entt::entt_traits< std::uint16_t >::version_mask()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#a6ada978f907780643740d9ca2a8e8762',1,'entt::entt_traits< std::uint32_t >::version_mask()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#a3f9f70e677d638708d0ce72ce1a28c92',1,'entt::entt_traits< std::uint64_t >::version_mask()']]] + ['get',['get',['../namespaceentt.html#a8c24ecc5ab0055f9f2a4725c95afb29e',1,'entt']]] ]; diff --git a/search/variables_3.js b/search/variables_3.js index 5a7af64e4..04efe1a46 100644 --- a/search/variables_3.js +++ b/search/variables_3.js @@ -1,4 +1,4 @@ var searchData= [ - ['version_5fmask',['version_mask',['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#a83bda73c5a360f5ba8f653d0f888993b',1,'entt::entt_traits< std::uint16_t >::version_mask()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#a6ada978f907780643740d9ca2a8e8762',1,'entt::entt_traits< std::uint32_t >::version_mask()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#a3f9f70e677d638708d0ce72ce1a28c92',1,'entt::entt_traits< std::uint64_t >::version_mask()']]] + ['is_5fnamed_5ftype_5fv',['is_named_type_v',['../namespaceentt.html#ab127297f5449d5c90bcef166a12c4358',1,'entt']]] ]; diff --git a/search/variables_4.html b/search/variables_4.html new file mode 100644 index 000000000..d7db285ee --- /dev/null +++ b/search/variables_4.html @@ -0,0 +1,26 @@ + + + + + + + + + +
+
Loading...
+
+ +
Searching...
+
No Matches
+ +
+ + diff --git a/search/variables_4.js b/search/variables_4.js new file mode 100644 index 000000000..b860775c9 --- /dev/null +++ b/search/variables_4.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['monostate_5fv',['monostate_v',['../namespaceentt.html#ab43a13f7ee60bcb0d04a001f92b86fa2',1,'entt']]] +]; diff --git a/search/variables_5.html b/search/variables_5.html new file mode 100644 index 000000000..7bbceeb0d --- /dev/null +++ b/search/variables_5.html @@ -0,0 +1,26 @@ + + + + + + + + + +
+
Loading...
+
+ +
Searching...
+
No Matches
+ +
+ + diff --git a/search/variables_5.js b/search/variables_5.js new file mode 100644 index 000000000..ae2385a1f --- /dev/null +++ b/search/variables_5.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['null',['null',['../namespaceentt.html#a588326af8f6f902a6c0b57d3f9fc6c17',1,'entt']]] +]; diff --git a/search/variables_6.html b/search/variables_6.html new file mode 100644 index 000000000..4eb162d67 --- /dev/null +++ b/search/variables_6.html @@ -0,0 +1,26 @@ + + + + + + + + + +
+
Loading...
+
+ +
Searching...
+
No Matches
+ +
+ + diff --git a/search/variables_6.js b/search/variables_6.js new file mode 100644 index 000000000..5079c9641 --- /dev/null +++ b/search/variables_6.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['size',['size',['../structentt_1_1type__list.html#a430c0675bdbcbb40be9b8f13f7259484',1,'entt::type_list']]] +]; diff --git a/search/variables_7.html b/search/variables_7.html new file mode 100644 index 000000000..040882958 --- /dev/null +++ b/search/variables_7.html @@ -0,0 +1,26 @@ + + + + + + + + + +
+
Loading...
+
+ +
Searching...
+
No Matches
+ +
+ + diff --git a/search/variables_7.js b/search/variables_7.js new file mode 100644 index 000000000..61be14225 --- /dev/null +++ b/search/variables_7.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['type',['type',['../classentt_1_1family.html#ad2c16ecd854f12f1aa70ceaba094e43a',1,'entt::family::type()'],['../classentt_1_1identifier.html#adb3aad553b8d57ef94581af39fc53178',1,'entt::identifier::type()']]] +]; diff --git a/search/variables_8.html b/search/variables_8.html new file mode 100644 index 000000000..d54d09666 --- /dev/null +++ b/search/variables_8.html @@ -0,0 +1,26 @@ + + + + + + + + + +
+
Loading...
+
+ +
Searching...
+
No Matches
+ +
+ + diff --git a/search/variables_8.js b/search/variables_8.js new file mode 100644 index 000000000..5a7af64e4 --- /dev/null +++ b/search/variables_8.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['version_5fmask',['version_mask',['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#a83bda73c5a360f5ba8f653d0f888993b',1,'entt::entt_traits< std::uint16_t >::version_mask()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#a6ada978f907780643740d9ca2a8e8762',1,'entt::entt_traits< std::uint32_t >::version_mask()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#a3f9f70e677d638708d0ce72ce1a28c92',1,'entt::entt_traits< std::uint64_t >::version_mask()']]] +]; diff --git a/shared_8md_source.html b/shared_8md_source.html deleted file mode 100644 index 337d28380..000000000 --- a/shared_8md_source.html +++ /dev/null @@ -1,74 +0,0 @@ - - - - - - - -EnTT: docs/shared.md Source File - - - - - - - - - -
-
-
void entt::Process< Derived, Delta >::pause void entt::process< Derived, Delta >::pause ( ) - + @@ -355,8 +355,8 @@ template<typename Derived, typename Delta> - -

◆ rejected()

+ +

◆ rejected()

@@ -367,7 +367,7 @@ template<typename Derived, typename Delta>
@@ -60,10 +60,10 @@ $(function() {
-
docs/resource.md
+
docs/md/resource.md
-
1 # Crash Course: resource management
2 
3 <!--
4 @cond TURN_OFF_DOXYGEN
5 -->
6 # Table of Contents
7 
8 * [Introduction](#introduction)
9 * [The resource, the loader and the cache](#the-resource-the-loader-and-the-cache)
10 <!--
11 @endcond TURN_OFF_DOXYGEN
12 -->
13 
14 # Introduction
15 
16 Resource management is usually one of the most critical part of a software like
17 a game. Solutions are often tuned to the particular application. There exist
18 several approaches and all of them are perfectly fine as long as they fit the
19 requirements of the piece of software in which they are used.<br/>
20 Examples are loading everything on start, loading on request, predictive
21 loading, and so on.
22 
23 `EnTT` doesn't pretend to offer a _one-fits-all_ solution for the different
24 cases. Instead, it offers a minimal and perhaps trivial cache that can be useful
25 most of the time during prototyping and sometimes even in a production
26 environment.<br/>
27 For those interested in the subject, the plan is to improve it considerably over
28 time in terms of performance, memory usage and functionalities. Hoping to make
29 it, of course, one step at a time.
30 
31 # The resource, the loader and the cache
32 
33 There are three main actors in the model: the resource, the loader and the
34 cache.
35 
36 The _resource_ is whatever users want it to be. An image, a video, an audio,
37 whatever. There are no limits.<br/>
38 As a minimal example:
39 
40 ```cpp
41 struct MyResource { const int value; };
42 ```
43 
44 A _loader_ is a class the aim of which is to load a specific resource. It has to
45 inherit directly from the dedicated base class as in the following example:
46 
47 ```cpp
48 struct MyLoader final: entt::ResourceLoader<MyLoader, MyResource> {
49  // ...
50 };
51 ```
52 
53 Where `MyResource` is the type of resources it creates.<br/>
54 A resource loader must also expose a public const member function named `load`
55 that accepts a variable number of arguments and returns a shared pointer to a
56 resource.<br/>
57 As an example:
58 
59 ```cpp
60 struct MyLoader: entt::ResourceLoader<MyLoader, MyResource> {
61  std::shared_ptr<MyResource> load(int value) const {
62  // ...
63  return std::shared_ptr<MyResource>(new MyResource{ value });
64  }
65 };
66 ```
67 
68 In general, resource loaders should not have a state or retain data of any type.
69 They should let the cache manage their resources instead.<br/>
70 As a side note, base class and CRTP idiom aren't strictly required with the
71 current implementation. One could argue that a cache can easily work with
72 loaders of any type. However, future changes won't be breaking ones by forcing
73 the use of a base class today and that's why the model is already in its place.
74 
75 Finally, a cache is a specialization of a class template tailored to a specific
76 resource:
77 
78 ```cpp
79 using MyResourceCache = entt::ResourceCache<MyResource>;
80 
81 // ...
82 
83 MyResourceCache cache{};
84 ```
85 
86 The idea is to create different caches for different types of resources and to
87 manage each one independently and in the most appropriate way.<br/>
88 As a (very) trivial example, audio tracks can survive in most of the scenes of
89 an application while meshes can be associated with a single scene and then
90 discarded when users leave it.
91 
92 A cache offers a set of basic functionalities to query its internal state and to
93 _organize_ it:
94 
95 ```cpp
96 // gets the number of resources managed by a cache
97 const auto size = cache.size();
98 
99 // checks if a cache contains at least a valid resource
100 const auto empty = cache.empty();
101 
102 // clears a cache and discards its content
103 cache.clear();
104 ```
105 
106 Besides these member functions, it contains what is needed to load, use and
107 discard resources of the given type.<br/>
108 Before to explore this part of the interface, it makes sense to mention how
109 resources are identified. The type of the identifiers to use is defined as:
110 
111 ```cpp
112 entt::ResourceCache<Resource>::resource_type
113 ```
114 
115 Where `resource_type` is an alias for `entt::HashedString`. Therefore, resource
116 identifiers are created explicitly as in the following example:
117 
118 ```cpp
119 constexpr auto identifier = entt::ResourceCache<Resource>::resource_type{"my/resource/identifier"};
120 // this is equivalent to the following
121 constexpr auto hs = entt::HashedString{"my/resource/identifier"};
122 ```
123 
124 The class `HashedString` is described in a dedicated section, so I won't do in
125 details here.
126 
127 Resources are loaded and thus stored in a cache through the `load` member
128 function. It accepts the loader to use as a template parameter, the resource
129 identifier and the parameters used to construct the resource as arguments:
130 
131 ```cpp
132 // uses the identifier declared above
133 cache.load<MyLoader>(identifier, 0);
134 
135 // uses a const char * directly as an identifier
136 cache.load<MyLoader>("another/identifier", 42);
137 ```
138 
139 The return value can be used to know if the resource has been loaded correctly.
140 In case the loader returns an invalid pointer or the resource already exists in
141 the cache, a false value is returned:
142 
143 ```cpp
144 if(!cache.load<MyLoader>("another/identifier", 42)) {
145  // ...
146 }
147 ```
148 
149 Unfortunately, in this case there is no way to know what was the problem
150 exactly. However, before trying to load a resource or after an error, one can
151 use the `contains` member function to know if a cache already contains a
152 specific resource:
153 
154 ```cpp
155 auto exists = cache.contains("my/identifier");
156 ```
157 
158 There exists also a member function to use to force a reload of an already
159 existing resource if needed:
160 
161 ```cpp
162 auto result = cache.reload<MyLoader>("another/identifier", 42);
163 ```
164 
165 As above, the function returns true in case of success, false otherwise. The
166 sole difference in this case is that an error necessarily means that the loader
167 has failed for some reasons to load the resource.<br/>
168 Note that the `reload` member function is a kind of alias of the following
169 snippet:
170 
171 ```cpp
172 cache.discard(identifier);
173 cache.load<MyLoader>(identifier, 42);
174 ```
175 
176 Where the `discard` member function is used to get rid of a resource if loaded.
177 In case the cache doesn't contain a resource for the given identifier, the
178 function does nothing and returns immediately.
179 
180 So far, so good. Resources are finally loaded and stored within the cache.<br/>
181 They are returned to users in the form of handles. To get one of them:
182 
183 ```cpp
184 auto handle = cache.handle("my/identifier");
185 ```
186 
187 The idea behind a handle is the same of the flyweight pattern. In other terms,
188 resources aren't copied around. Instead, instances are shared between handles.
189 Users of a resource owns a handle and it guarantees that a resource isn't
190 destroyed until all the handles are destroyed, even if the resource itself is
191 removed from the cache.<br/>
192 Handles are tiny objects both movable and copyable. They returns the contained
193 resource as a const reference on request:
194 
195 * By means of the `get` member function:
196 
197  ```cpp
198  const auto &resource = handle.get();
199  ```
200 
201 * Using the proper cast operator:
202 
203  ```cpp
204  const auto &resource = handle;
205  ```
206 
207 * Through the dereference operator:
208 
209  ```cpp
210  const auto &resource = *handle;
211  ```
212 
213 The resource can also be accessed directly using the arrow operator if required:
214 
215 ```cpp
216 auto value = handle->value;
217 ```
218 
219 To test if a handle is still valid, the cast operator to `bool` allows users to
220 use it in a guard:
221 
222 ```cpp
223 if(handle) {
224  // ...
225 }
226 ```
227 
228 Finally, in case there is the need to load a resource and thus to get a handle
229 without storing the resource itself in the cache, users can rely on the `temp`
230 member function template.<br/>
231 The declaration is similar to the one of `load` but for the fact that it doesn't
232 return a boolean value. Instead, it returns a (possibly invalid) handle for the
233 resource:
234 
235 ```cpp
236 auto handle = cache.temp<MyLoader>("another/identifier", 42);
237 ```
238 
239 Do not forget to test the handle for validity. Otherwise, getting the reference
240 to the resource it points may result in undefined behavior.
+
1 # Crash Course: resource management
2 
3 <!--
4 @cond TURN_OFF_DOXYGEN
5 -->
6 # Table of Contents
7 
8 * [Introduction](#introduction)
9 * [The resource, the loader and the cache](#the-resource-the-loader-and-the-cache)
10 <!--
11 @endcond TURN_OFF_DOXYGEN
12 -->
13 
14 # Introduction
15 
16 Resource management is usually one of the most critical part of a software like
17 a game. Solutions are often tuned to the particular application. There exist
18 several approaches and all of them are perfectly fine as long as they fit the
19 requirements of the piece of software in which they are used.<br/>
20 Examples are loading everything on start, loading on request, predictive
21 loading, and so on.
22 
23 `EnTT` doesn't pretend to offer a _one-fits-all_ solution for the different
24 cases. Instead, it offers a minimal and perhaps trivial cache that can be useful
25 most of the time during prototyping and sometimes even in a production
26 environment.<br/>
27 For those interested in the subject, the plan is to improve it considerably over
28 time in terms of performance, memory usage and functionalities. Hoping to make
29 it, of course, one step at a time.
30 
31 # The resource, the loader and the cache
32 
33 There are three main actors in the model: the resource, the loader and the
34 cache.
35 
36 The _resource_ is whatever users want it to be. An image, a video, an audio,
37 whatever. There are no limits.<br/>
38 As a minimal example:
39 
40 ```cpp
41 struct my_resource { const int value; };
42 ```
43 
44 A _loader_ is a class the aim of which is to load a specific resource. It has to
45 inherit directly from the dedicated base class as in the following example:
46 
47 ```cpp
48 struct my_loader final: entt::resource_loader<my_loader, my_resource> {
49  // ...
50 };
51 ```
52 
53 Where `my_resource` is the type of resources it creates.<br/>
54 A resource loader must also expose a public const member function named `load`
55 that accepts a variable number of arguments and returns a shared pointer to a
56 resource.<br/>
57 As an example:
58 
59 ```cpp
60 struct my_loader: entt::resource_loader<my_loader, my_resource> {
61  std::shared_ptr<my_resource> load(int value) const {
62  // ...
63  return std::shared_ptr<my_resource>(new my_resource{ value });
64  }
65 };
66 ```
67 
68 In general, resource loaders should not have a state or retain data of any type.
69 They should let the cache manage their resources instead.<br/>
70 As a side note, base class and CRTP idiom aren't strictly required with the
71 current implementation. One could argue that a cache can easily work with
72 loaders of any type. However, future changes won't be breaking ones by forcing
73 the use of a base class today and that's why the model is already in its place.
74 
75 Finally, a cache is a specialization of a class template tailored to a specific
76 resource:
77 
78 ```cpp
79 using my_resource_cache = entt::resource_cache<my_resource>;
80 
81 // ...
82 
83 my_resource_cache cache{};
84 ```
85 
86 The idea is to create different caches for different types of resources and to
87 manage each one independently in the most appropriate way.<br/>
88 As a (very) trivial example, audio tracks can survive in most of the scenes of
89 an application while meshes can be associated with a single scene and then
90 discarded when users leave it.
91 
92 A cache offers a set of basic functionalities to query its internal state and to
93 _organize_ it:
94 
95 ```cpp
96 // gets the number of resources managed by a cache
97 const auto size = cache.size();
98 
99 // checks if a cache contains at least a valid resource
100 const auto empty = cache.empty();
101 
102 // clears a cache and discards its content
103 cache.clear();
104 ```
105 
106 Besides these member functions, a cache contains what is needed to load, use and
107 discard resources of the given type.<br/>
108 Before to explore this part of the interface, it makes sense to mention how
109 resources are identified. The type of the identifiers to use is defined as:
110 
111 ```cpp
112 entt::resource_cache<resource>::resource_type
113 ```
114 
115 Where `resource_type` is an alias for `entt::hashed_string::hash_type`.
116 Therefore, resource identifiers are created explicitly as in the following
117 example:
118 
119 ```cpp
120 constexpr auto identifier = entt::resource_cache<resource>::resource_type{"my/resource/identifier"_hs};
121 // this is equivalent to the following
122 constexpr auto hs = entt::hashed_string{"my/resource/identifier"};
123 ```
124 
125 The class `hashed_string` is described in a dedicated section, so I won't go in
126 details here.
127 
128 Resources are loaded and thus stored in a cache through the `load` member
129 function. It accepts the loader to use as a template parameter, the resource
130 identifier and the parameters used to construct the resource as arguments:
131 
132 ```cpp
133 // uses the identifier declared above
134 cache.load<my_loader>(identifier, 0);
135 
136 // uses a const char * directly as an identifier
137 cache.load<my_loader>("another/identifier"_hs, 42);
138 ```
139 
140 The function returns a handle to the resource, whether it already exists or is
141 loaded. In case the loader returns an invalid pointer, the handle is invalid as
142 well and therefore it can be easily used with an `if` statement:
143 
144 ```cpp
145 if(auto handle = cache.load<my_loader>("another/identifier"_hs, 42); handle) {
146  // ...
147 }
148 ```
149 
150 Before trying to load a resource, the `contains` member function can be used to
151 know if a cache already contains a specific resource:
152 
153 ```cpp
154 auto exists = cache.contains("my/identifier"_hs);
155 ```
156 
157 There exists also a member function to use to force a reload of an already
158 existing resource if needed:
159 
160 ```cpp
161 auto handle = cache.reload<my_loader>("another/identifier"_hs, 42);
162 ```
163 
164 As above, the function returns a handle to the resource that is invalid in case
165 of errors. The `reload` member function is a kind of alias of the following
166 snippet:
167 
168 ```cpp
169 cache.discard(identifier);
170 cache.load<my_loader>(identifier, 42);
171 ```
172 
173 Where the `discard` member function is used to get rid of a resource if loaded.
174 In case the cache doesn't contain a resource for the given identifier, `discard`
175 does nothing and returns immediately.
176 
177 So far, so good. Resources are finally loaded and stored within the cache.<br/>
178 They are returned to users in the form of handles. To get one of them later on:
179 
180 ```cpp
181 auto handle = cache.handle("my/identifier"_hs);
182 ```
183 
184 The idea behind a handle is the same of the flyweight pattern. In other terms,
185 resources aren't copied around. Instead, instances are shared between handles.
186 Users of a resource own a handle that guarantees that a resource isn't destroyed
187 until all the handles are destroyed, even if the resource itself is removed from
188 the cache.<br/>
189 Handles are tiny objects both movable and copyable. They return the contained
190 resource as a const reference on request:
191 
192 * By means of the `get` member function:
193 
194  ```cpp
195  const auto &resource = handle.get();
196  ```
197 
198 * Using the proper cast operator:
199 
200  ```cpp
201  const auto &resource = handle;
202  ```
203 
204 * Through the dereference operator:
205 
206  ```cpp
207  const auto &resource = *handle;
208  ```
209 
210 The resource can also be accessed directly using the arrow operator if required:
211 
212 ```cpp
213 auto value = handle->value;
214 ```
215 
216 To test if a handle is still valid, the cast operator to `bool` allows users to
217 use it in a guard:
218 
219 ```cpp
220 if(handle) {
221  // ...
222 }
223 ```
224 
225 Finally, in case there is the need to load a resource and thus to get a handle
226 without storing the resource itself in the cache, users can rely on the `temp`
227 member function template.<br/>
228 The declaration is similar to that of `load`, a (possibly invalid) handle for
229 the resource is returned also in this case:
230 
231 ```cpp
232 if(auto handle = cache.temp<my_loader>(42); handle) {
233  // ...
234 }
235 ```
236 
237 Do not forget to test the handle for validity. Otherwise, getting a reference to
238 the resource it points may result in undefined behavior.
Generated by   diff --git a/runtime__view_8hpp_source.html b/runtime__view_8hpp_source.html new file mode 100644 index 000000000..78bdb3c38 --- /dev/null +++ b/runtime__view_8hpp_source.html @@ -0,0 +1,99 @@ + + + + + + + +EnTT: src/entt/entity/runtime_view.hpp Source File + + + + + + + + + +
+
+
bool entt::Process< Derived, Delta >::paused bool entt::process< Derived, Delta >::paused ( ) const - + @@ -387,8 +387,8 @@ template<typename Derived, typename Delta> - -

◆ succeed()

+ +

◆ succeed()

@@ -399,7 +399,7 @@ template<typename Derived, typename Delta>
@@ -67,23 +67,23 @@ $(function() {
process.hpp
-
1 #ifndef ENTT_PROCESS_PROCESS_HPP
2 #define ENTT_PROCESS_PROCESS_HPP
3 
4 
5 #include <type_traits>
6 #include <functional>
7 #include <utility>
8 #include "../config/config.h"
9 
10 
11 namespace entt {
12 
13 
72 template<typename Derived, typename Delta>
73 class Process {
74  enum class State: unsigned int {
75  UNINITIALIZED = 0,
76  RUNNING,
77  PAUSED,
78  SUCCEEDED,
79  FAILED,
80  ABORTED,
81  FINISHED
82  };
83 
84  template<State state>
85  using tag = std::integral_constant<State, state>;
86 
87  template<typename Target = Derived>
88  auto tick(int, tag<State::UNINITIALIZED>, void *data)
89  -> decltype(std::declval<Target>().init(data)) {
90  static_cast<Target *>(this)->init(data);
91  }
92 
93  template<typename Target = Derived>
94  auto tick(int, tag<State::RUNNING>, Delta delta, void *data)
95  -> decltype(std::declval<Target>().update(delta, data)) {
96  static_cast<Target *>(this)->update(delta, data);
97  }
98 
99  template<typename Target = Derived>
100  auto tick(int, tag<State::SUCCEEDED>)
101  -> decltype(std::declval<Target>().succeeded()) {
102  static_cast<Target *>(this)->succeeded();
103  }
104 
105  template<typename Target = Derived>
106  auto tick(int, tag<State::FAILED>)
107  -> decltype(std::declval<Target>().failed()) {
108  static_cast<Target *>(this)->failed();
109  }
110 
111  template<typename Target = Derived>
112  auto tick(int, tag<State::ABORTED>)
113  -> decltype(std::declval<Target>().aborted()) {
114  static_cast<Target *>(this)->aborted();
115  }
116 
117  template<State S, typename... Args>
118  void tick(char, tag<S>, Args &&...) const ENTT_NOEXCEPT {}
119 
120 protected:
127  void succeed() ENTT_NOEXCEPT {
128  if(alive()) {
129  current = State::SUCCEEDED;
130  }
131  }
132 
139  void fail() ENTT_NOEXCEPT {
140  if(alive()) {
141  current = State::FAILED;
142  }
143  }
144 
151  void pause() ENTT_NOEXCEPT {
152  if(current == State::RUNNING) {
153  current = State::PAUSED;
154  }
155  }
156 
163  void unpause() ENTT_NOEXCEPT {
164  if(current == State::PAUSED) {
165  current = State::RUNNING;
166  }
167  }
168 
169 public:
171  using delta_type = Delta;
172 
174  virtual ~Process() ENTT_NOEXCEPT {
175  static_assert(std::is_base_of<Process, Derived>::value, "!");
176  }
177 
186  void abort(const bool immediately = false) ENTT_NOEXCEPT {
187  if(alive()) {
188  current = State::ABORTED;
189 
190  if(immediately) {
191  tick(0);
192  }
193  }
194  }
195 
200  bool alive() const ENTT_NOEXCEPT {
201  return current == State::RUNNING || current == State::PAUSED;
202  }
203 
208  bool dead() const ENTT_NOEXCEPT {
209  return current == State::FINISHED;
210  }
211 
216  bool paused() const ENTT_NOEXCEPT {
217  return current == State::PAUSED;
218  }
219 
224  bool rejected() const ENTT_NOEXCEPT {
225  return stopped;
226  }
227 
233  void tick(const Delta delta, void *data = nullptr) {
234  switch (current) {
235  case State::UNINITIALIZED:
236  tick(0, tag<State::UNINITIALIZED>{}, data);
237  current = State::RUNNING;
238  // no break on purpose, tasks are executed immediately
239  case State::RUNNING:
240  tick(0, tag<State::RUNNING>{}, delta, data);
241  default:
242  // suppress warnings
243  break;
244  }
245 
246  // if it's dead, it must be notified and removed immediately
247  switch(current) {
248  case State::SUCCEEDED:
249  tick(0, tag<State::SUCCEEDED>{});
250  current = State::FINISHED;
251  break;
252  case State::FAILED:
253  tick(0, tag<State::FAILED>{});
254  current = State::FINISHED;
255  stopped = true;
256  break;
257  case State::ABORTED:
258  tick(0, tag<State::ABORTED>{});
259  current = State::FINISHED;
260  stopped = true;
261  break;
262  default:
263  // suppress warnings
264  break;
265  }
266  }
267 
268 private:
269  State current{State::UNINITIALIZED};
270  bool stopped{false};
271 };
272 
273 
313 template<typename Func, typename Delta>
314 struct ProcessAdaptor: Process<ProcessAdaptor<Func, Delta>, Delta>, private Func {
320  template<typename... Args>
321  ProcessAdaptor(Args &&... args)
322  : Func{std::forward<Args>(args)...}
323  {}
324 
330  void update(const Delta delta, void *data) {
331  Func::operator()(delta, data, [this]() { this->succeed(); }, [this]() { this->fail(); });
332  }
333 };
334 
335 
336 }
337 
338 
339 #endif // ENTT_PROCESS_PROCESS_HPP
entt::Process
Base class for processes.
Definition: process.hpp:73
-
entt::Process::unpause
void unpause() ENTT_NOEXCEPT
Restarts a process if it&#39;s paused.
Definition: process.hpp:163
-
entt::Process::dead
bool dead() const ENTT_NOEXCEPT
Returns true if a process is already terminated.
Definition: process.hpp:208
-
entt::Process::rejected
bool rejected() const ENTT_NOEXCEPT
Returns true if a process terminated with errors.
Definition: process.hpp:224
-
entt::Process::abort
void abort(const bool immediately=false) ENTT_NOEXCEPT
Aborts a process if it&#39;s still alive.
Definition: process.hpp:186
+
1 #ifndef ENTT_PROCESS_PROCESS_HPP
2 #define ENTT_PROCESS_PROCESS_HPP
3 
4 
5 #include <utility>
6 #include <type_traits>
7 #include "../config/config.h"
8 
9 
10 namespace entt {
11 
12 
72 template<typename Derived, typename Delta>
73 class process {
74  enum class state: unsigned int {
75  UNINITIALIZED = 0,
76  RUNNING,
77  PAUSED,
78  SUCCEEDED,
79  FAILED,
80  ABORTED,
81  FINISHED
82  };
83 
84  template<state value>
85  using state_value_t = std::integral_constant<state, value>;
86 
87  template<typename Target = Derived>
88  auto tick(int, state_value_t<state::UNINITIALIZED>)
89  -> decltype(std::declval<Target>().init()) {
90  static_cast<Target *>(this)->init();
91  }
92 
93  template<typename Target = Derived>
94  auto tick(int, state_value_t<state::RUNNING>, Delta delta, void *data)
95  -> decltype(std::declval<Target>().update(delta, data)) {
96  static_cast<Target *>(this)->update(delta, data);
97  }
98 
99  template<typename Target = Derived>
100  auto tick(int, state_value_t<state::SUCCEEDED>)
101  -> decltype(std::declval<Target>().succeeded()) {
102  static_cast<Target *>(this)->succeeded();
103  }
104 
105  template<typename Target = Derived>
106  auto tick(int, state_value_t<state::FAILED>)
107  -> decltype(std::declval<Target>().failed()) {
108  static_cast<Target *>(this)->failed();
109  }
110 
111  template<typename Target = Derived>
112  auto tick(int, state_value_t<state::ABORTED>)
113  -> decltype(std::declval<Target>().aborted()) {
114  static_cast<Target *>(this)->aborted();
115  }
116 
117  template<state value, typename... Args>
118  void tick(char, state_value_t<value>, Args &&...) const ENTT_NOEXCEPT {}
119 
120 protected:
127  void succeed() ENTT_NOEXCEPT {
128  if(alive()) {
129  current = state::SUCCEEDED;
130  }
131  }
132 
139  void fail() ENTT_NOEXCEPT {
140  if(alive()) {
141  current = state::FAILED;
142  }
143  }
144 
151  void pause() ENTT_NOEXCEPT {
152  if(current == state::RUNNING) {
153  current = state::PAUSED;
154  }
155  }
156 
163  void unpause() ENTT_NOEXCEPT {
164  if(current == state::PAUSED) {
165  current = state::RUNNING;
166  }
167  }
168 
169 public:
171  using delta_type = Delta;
172 
174  virtual ~process() ENTT_NOEXCEPT {
175  static_assert(std::is_base_of_v<process, Derived>);
176  }
177 
186  void abort(const bool immediately = false) ENTT_NOEXCEPT {
187  if(alive()) {
188  current = state::ABORTED;
189 
190  if(immediately) {
191  tick(0);
192  }
193  }
194  }
195 
200  bool alive() const ENTT_NOEXCEPT {
201  return current == state::RUNNING || current == state::PAUSED;
202  }
203 
208  bool dead() const ENTT_NOEXCEPT {
209  return current == state::FINISHED;
210  }
211 
216  bool paused() const ENTT_NOEXCEPT {
217  return current == state::PAUSED;
218  }
219 
224  bool rejected() const ENTT_NOEXCEPT {
225  return stopped;
226  }
227 
233  void tick(const Delta delta, void *data = nullptr) {
234  switch (current) {
235  case state::UNINITIALIZED:
236  tick(0, state_value_t<state::UNINITIALIZED>{});
237  current = state::RUNNING;
238  break;
239  case state::RUNNING:
240  tick(0, state_value_t<state::RUNNING>{}, delta, data);
241  break;
242  default:
243  // suppress warnings
244  break;
245  }
246 
247  // if it's dead, it must be notified and removed immediately
248  switch(current) {
249  case state::SUCCEEDED:
250  tick(0, state_value_t<state::SUCCEEDED>{});
251  current = state::FINISHED;
252  break;
253  case state::FAILED:
254  tick(0, state_value_t<state::FAILED>{});
255  current = state::FINISHED;
256  stopped = true;
257  break;
258  case state::ABORTED:
259  tick(0, state_value_t<state::ABORTED>{});
260  current = state::FINISHED;
261  stopped = true;
262  break;
263  default:
264  // suppress warnings
265  break;
266  }
267  }
268 
269 private:
270  state current{state::UNINITIALIZED};
271  bool stopped{false};
272 };
273 
274 
314 template<typename Func, typename Delta>
315 struct process_adaptor: process<process_adaptor<Func, Delta>, Delta>, private Func {
321  template<typename... Args>
322  process_adaptor(Args &&... args)
323  : Func{std::forward<Args>(args)...}
324  {}
325 
331  void update(const Delta delta, void *data) {
332  Func::operator()(delta, data, [this]() { this->succeed(); }, [this]() { this->fail(); });
333  }
334 };
335 
336 
337 }
338 
339 
340 #endif // ENTT_PROCESS_PROCESS_HPP
entt::process::unpause
void unpause() ENTT_NOEXCEPT
Restarts a process if it&#39;s paused.
Definition: process.hpp:163
+
entt::process::rejected
bool rejected() const ENTT_NOEXCEPT
Returns true if a process terminated with errors.
Definition: process.hpp:224
+
entt::process::alive
bool alive() const ENTT_NOEXCEPT
Returns true if a process is either running or paused.
Definition: process.hpp:200
+
entt::process::dead
bool dead() const ENTT_NOEXCEPT
Returns true if a process is already terminated.
Definition: process.hpp:208
entt
EnTT default namespace.
Definition: algorithm.hpp:10
-
entt::Process::~Process
virtual ~Process() ENTT_NOEXCEPT
Default destructor.
Definition: process.hpp:174
-
entt::ProcessAdaptor::ProcessAdaptor
ProcessAdaptor(Args &&... args)
Constructs a process adaptor from a lambda or a functor.
Definition: process.hpp:321
-
entt::ProcessAdaptor
Adaptor for lambdas and functors to turn them into processes.
Definition: process.hpp:314
-
entt::Process::fail
void fail() ENTT_NOEXCEPT
Terminates a process with errors if it&#39;s still alive.
Definition: process.hpp:139
-
entt::Process::alive
bool alive() const ENTT_NOEXCEPT
Returns true if a process is either running or paused.
Definition: process.hpp:200
-
entt::Process::succeed
void succeed() ENTT_NOEXCEPT
Terminates a process with success if it&#39;s still alive.
Definition: process.hpp:127
-
entt::Process< ProcessAdaptor< Func, Delta >, Delta >::delta_type
Delta delta_type
Type used to provide elapsed time.
Definition: process.hpp:171
-
entt::ProcessAdaptor::update
void update(const Delta delta, void *data)
Updates a process and its internal state if required.
Definition: process.hpp:330
-
entt::Process::pause
void pause() ENTT_NOEXCEPT
Stops a process if it&#39;s in a running state.
Definition: process.hpp:151
-
entt::Process::tick
void tick(const Delta delta, void *data=nullptr)
Updates a process and its internal state if required.
Definition: process.hpp:233
-
entt::Process::paused
bool paused() const ENTT_NOEXCEPT
Returns true if a process is currently paused.
Definition: process.hpp:216
+
entt::process< process_adaptor< Func, Delta >, Delta >::delta_type
Delta delta_type
Type used to provide elapsed time.
Definition: process.hpp:171
+
entt::process::pause
void pause() ENTT_NOEXCEPT
Stops a process if it&#39;s in a running state.
Definition: process.hpp:151
+
entt::process::succeed
void succeed() ENTT_NOEXCEPT
Terminates a process with success if it&#39;s still alive.
Definition: process.hpp:127
+
entt::process::paused
bool paused() const ENTT_NOEXCEPT
Returns true if a process is currently paused.
Definition: process.hpp:216
+
entt::process::abort
void abort(const bool immediately=false) ENTT_NOEXCEPT
Aborts a process if it&#39;s still alive.
Definition: process.hpp:186
+
entt::process::tick
void tick(const Delta delta, void *data=nullptr)
Updates a process and its internal state if required.
Definition: process.hpp:233
+
entt::process::~process
virtual ~process() ENTT_NOEXCEPT
Default destructor.
Definition: process.hpp:174
+
entt::process_adaptor::update
void update(const Delta delta, void *data)
Updates a process and its internal state if required.
Definition: process.hpp:331
+
entt::process
Base class for processes.
Definition: process.hpp:73
+
entt::process_adaptor
Adaptor for lambdas and functors to turn them into processes.
Definition: process.hpp:315
+
entt::process::fail
void fail() ENTT_NOEXCEPT
Terminates a process with errors if it&#39;s still alive.
Definition: process.hpp:139
+
entt::process_adaptor::process_adaptor
process_adaptor(Args &&... args)
Constructs a process adaptor from a lambda or a functor.
Definition: process.hpp:322
diff --git a/process_8md_source.html b/process_8md_source.html index b00e30604..e1f9e9237 100644 --- a/process_8md_source.html +++ b/process_8md_source.html @@ -5,7 +5,7 @@ -EnTT: docs/process.md Source File +EnTT: docs/md/process.md Source File @@ -22,7 +22,7 @@
@@ -60,10 +60,10 @@ $(function() {
-
docs/process.md
+
docs/md/process.md
-
1 # Crash Course: cooperative scheduler
2 
3 <!--
4 @cond TURN_OFF_DOXYGEN
5 -->
6 # Table of Contents
7 
8 * [Introduction](#introduction)
9 * [The process](#the-process)
10  * [Adaptor](#adaptor)
11 * [The scheduler](#the-scheduler)
12 <!--
13 @endcond TURN_OFF_DOXYGEN
14 -->
15 
16 # Introduction
17 
18 Sometimes processes are a useful tool to work around the strict definition of a
19 system and introduce logic in a different way, usually without resorting to the
20 introduction of other components.
21 
22 `EnTT` offers a minimal support to this paradigm by introducing a few classes
23 that users can use to define and execute cooperative processes.
24 
25 # The process
26 
27 A typical process must inherit from the `Process` class template that stays true
28 to the CRTP idiom. Moreover, derived classes must specify what's the intended
29 type for elapsed times.
30 
31 A process should expose publicly the following member functions whether
32 required (note that it isn't required to define a function unless the derived
33 class wants to _override_ the default behavior):
34 
35 * `void update(Delta, void *);`
36 
37  It's invoked once per tick until a process is explicitly aborted or it
38  terminates either with or without errors. Even though it's not mandatory to
39  declare this member function, as a rule of thumb each process should at
40  least define it to work properly. The `void *` parameter is an opaque pointer
41  to user data (if any) forwarded directly to the process during an update.
42 
43 * `void init(void *);`
44 
45  It's invoked at the first tick, immediately before an update. The `void *`
46  parameter is an opaque pointer to user data (if any) forwarded directly to the
47  process during an update.
48 
49 * `void succeeded();`
50 
51  It's invoked in case of success, immediately after an update and during the
52  same tick.
53 
54 * `void failed();`
55 
56  It's invoked in case of errors, immediately after an update and during the
57  same tick.
58 
59 * `void aborted();`
60 
61  It's invoked only if a process is explicitly aborted. There is no guarantee
62  that it executes in the same tick, this depends solely on whether the
63  process is aborted immediately or not.
64 
65 Derived classes can also change the internal state of a process by invoking
66 `succeed` and `fail`, as well as `pause` and `unpause` the process itself. All
67 these are protected member functions made available to be able to manage the
68 life cycle of a process from a derived class.
69 
70 Here is a minimal example for the sake of curiosity:
71 
72 ```cpp
73 struct MyProcess: entt::Process<MyProcess, std::uint32_t> {
74  using delta_type = std::uint32_t;
75 
76  void update(delta_type delta, void *) {
77  remaining = delta > remaining ? delta_type{] : (remaining - delta);
78 
79  // ...
80 
81  if(!remaining) {
82  succeed();
83  }
84  }
85 
86  void init(void *data) {
87  remaining = *static_cast<delta_type *>(data);
88  }
89 
90 private:
91  delta_type remaining;
92 };
93 ```
94 
95 ## Adaptor
96 
97 Lambdas and functors can't be used directly with a scheduler for they are not
98 properly defined processes with managed life cycles.<br/>
99 This class helps in filling the gap and turning lambdas and functors into
100 full featured processes usable by a scheduler.
101 
102 The function call operator has a signature similar to the one of the `update`
103 function of a process but for the fact that it receives two extra arguments to
104 call whenever a process is terminated with success or with an error:
105 
106 ```cpp
107 void(Delta delta, void *data, auto succeed, auto fail);
108 ```
109 
110 Parameters have the following meaning:
111 
112 * `delta` is the elapsed time.
113 * `data` is an opaque pointer to user data if any, `nullptr` otherwise.
114 * `succeed` is a function to call when a process terminates with success.
115 * `fail` is a function to call when a process terminates with errors.
116 
117 Both `succeed` and `fail` accept no parameters at all.
118 
119 Note that usually users shouldn't worry about creating adaptors at all. A
120 scheduler creates them internally each and every time a lambda or a functor is
121 used as a process.
122 
123 # The scheduler
124 
125 A cooperative scheduler runs different processes and helps managing their life
126 cycles.
127 
128 Each process is invoked once per tick. If it terminates, it's removed
129 automatically from the scheduler and it's never invoked again. Otherwise it's
130 a good candidate to run once more the next tick.<br/>
131 A process can also have a child. In this case, the process is replaced with
132 its child when it terminates if it returns with success. In case of errors,
133 both the process and its child are discarded. This way, it's easy to create
134 chain of processes to run sequentially.
135 
136 Using a scheduler is straightforward. To create it, users must provide only the
137 type for the elapsed times and no arguments at all:
138 
139 ```cpp
140 Scheduler<std::uint32_t> scheduler;
141 ```
142 
143 It has member functions to query its internal data structures, like `empty` or
144 `size`, as well as a `clear` utility to reset it to a clean state:
145 
146 ```cpp
147 // checks if there are processes still running
148 const auto empty = scheduler.empty();
149 
150 // gets the number of processes still running
151 Scheduler<std::uint32_t>::size_type size = scheduler.size();
152 
153 // resets the scheduler to its initial state and discards all the processes
154 scheduler.clear();
155 ```
156 
157 To attach a process to a scheduler there are mainly two ways:
158 
159 * If the process inherits from the `Process` class template, it's enough to
160  indicate its type and submit all the parameters required to construct it to
161  the `attach` member function:
162 
163  ```cpp
164  scheduler.attach<MyProcess>("foobar");
165  ```
166 
167 * Otherwise, in case of a lambda or a functor, it's enough to provide an
168  instance of the class to the `attach` member function:
169 
170  ```cpp
171  scheduler.attach([](auto...){ /* ... */ });
172  ```
173 
174 In both cases, the return value is an opaque object that offers a `then` member
175 function to use to create chains of processes to run sequentially.<br/>
176 As a minimal example of use:
177 
178 ```cpp
179 // schedules a task in the form of a lambda function
180 scheduler.attach([](auto delta, void *, auto succeed, auto fail) {
181  // ...
182 })
183 // appends a child in the form of another lambda function
184 .then([](auto delta, void *, auto succeed, auto fail) {
185  // ...
186 })
187 // appends a child in the form of a process class
188 .then<MyProcess>();
189 ```
190 
191 To update a scheduler and thus all its processes, the `update` member function
192 is the way to go:
193 
194 ```cpp
195 // updates all the processes, no user data are provided
196 scheduler.update(delta);
197 
198 // updates all the processes and provides them with custom data
199 scheduler.update(delta, &data);
200 ```
201 
202 In addition to these functions, the scheduler offers an `abort` member function
203 that can be used to discard all the running processes at once:
204 
205 ```cpp
206 // aborts all the processes abruptly ...
207 scheduler.abort(true);
208 
209 // ... or gracefully during the next tick
210 scheduler.abort();
211 ```
+
1 # Crash Course: cooperative scheduler
2 
3 <!--
4 @cond TURN_OFF_DOXYGEN
5 -->
6 # Table of Contents
7 
8 * [Introduction](#introduction)
9 * [The process](#the-process)
10  * [Adaptor](#adaptor)
11 * [The scheduler](#the-scheduler)
12 <!--
13 @endcond TURN_OFF_DOXYGEN
14 -->
15 
16 # Introduction
17 
18 Sometimes processes are a useful tool to work around the strict definition of a
19 system and introduce logic in a different way, usually without resorting to the
20 introduction of other components.
21 
22 `EnTT` offers a minimal support to this paradigm by introducing a few classes
23 that users can use to define and execute cooperative processes.
24 
25 # The process
26 
27 A typical process must inherit from the `process` class template that stays true
28 to the CRTP idiom. Moreover, derived classes must specify what's the intended
29 type for elapsed times.
30 
31 A process should expose publicly the following member functions whether
32 required (note that it isn't required to define a function unless the derived
33 class wants to _override_ the default behavior):
34 
35 * `void update(Delta, void *);`
36 
37  It's invoked once per tick until a process is explicitly aborted or it
38  terminates either with or without errors. Even though it's not mandatory to
39  declare this member function, as a rule of thumb each process should at
40  least define it to work properly. The `void *` parameter is an opaque pointer
41  to user data (if any) forwarded directly to the process during an update.
42 
43 * `void init();`
44 
45  It's invoked when the process joins the running queue of a scheduler. This
46  happens as soon as it's attached to the scheduler if the process is a top
47  level one, otherwise when it replaces its parent if the process is a
48  continuation.
49 
50 * `void succeeded();`
51 
52  It's invoked in case of success, immediately after an update and during the
53  same tick.
54 
55 * `void failed();`
56 
57  It's invoked in case of errors, immediately after an update and during the
58  same tick.
59 
60 * `void aborted();`
61 
62  It's invoked only if a process is explicitly aborted. There is no guarantee
63  that it executes in the same tick, this depends solely on whether the
64  process is aborted immediately or not.
65 
66 Derived classes can also change the internal state of a process by invoking
67 `succeed` and `fail`, as well as `pause` and `unpause` the process itself. All
68 these are protected member functions made available to be able to manage the
69 life cycle of a process from a derived class.
70 
71 Here is a minimal example for the sake of curiosity:
72 
73 ```cpp
74 struct my_process: entt::process<my_process, std::uint32_t> {
75  using delta_type = std::uint32_t;
76 
77  void update(delta_type delta, void *) {
78  remaining -= std::min(remaining, delta);
79 
80  // ...
81 
82  if(!remaining) {
83  succeed();
84  }
85  }
86 
87 private:
88  delta_type remaining{1000u};
89 };
90 ```
91 
92 ## Adaptor
93 
94 Lambdas and functors can't be used directly with a scheduler for they are not
95 properly defined processes with managed life cycles.<br/>
96 This class helps in filling the gap and turning lambdas and functors into
97 full featured processes usable by a scheduler.
98 
99 The function call operator has a signature similar to the one of the `update`
100 function of a process but for the fact that it receives two extra arguments to
101 call whenever a process is terminated with success or with an error:
102 
103 ```cpp
104 void(Delta delta, void *data, auto succeed, auto fail);
105 ```
106 
107 Parameters have the following meaning:
108 
109 * `delta` is the elapsed time.
110 * `data` is an opaque pointer to user data if any, `nullptr` otherwise.
111 * `succeed` is a function to call when a process terminates with success.
112 * `fail` is a function to call when a process terminates with errors.
113 
114 Both `succeed` and `fail` accept no parameters at all.
115 
116 Note that usually users shouldn't worry about creating adaptors at all. A
117 scheduler creates them internally each and every time a lambda or a functor is
118 used as a process.
119 
120 # The scheduler
121 
122 A cooperative scheduler runs different processes and helps managing their life
123 cycles.
124 
125 Each process is invoked once per tick. If it terminates, it's removed
126 automatically from the scheduler and it's never invoked again. Otherwise it's
127 a good candidate to run one more time the next tick.<br/>
128 A process can also have a child. In this case, the parent process is replaced
129 with its child when it terminates and only if it returns with success. In case
130 of errors, both the parent process and its child are discarded. This way, it's
131 easy to create chain of processes to run sequentially.
132 
133 Using a scheduler is straightforward. To create it, users must provide only the
134 type for the elapsed times and no arguments at all:
135 
136 ```cpp
137 entt::scheduler<std::uint32_t> scheduler;
138 ```
139 
140 It has member functions to query its internal data structures, like `empty` or
141 `size`, as well as a `clear` utility to reset it to a clean state:
142 
143 ```cpp
144 // checks if there are processes still running
145 const auto empty = scheduler.empty();
146 
147 // gets the number of processes still running
148 entt::scheduler<std::uint32_t>::size_type size = scheduler.size();
149 
150 // resets the scheduler to its initial state and discards all the processes
151 scheduler.clear();
152 ```
153 
154 To attach a process to a scheduler there are mainly two ways:
155 
156 * If the process inherits from the `process` class template, it's enough to
157  indicate its type and submit all the parameters required to construct it to
158  the `attach` member function:
159 
160  ```cpp
161  scheduler.attach<my_process>("foobar");
162  ```
163 
164 * Otherwise, in case of a lambda or a functor, it's enough to provide an
165  instance of the class to the `attach` member function:
166 
167  ```cpp
168  scheduler.attach([](auto...){ /* ... */ });
169  ```
170 
171 In both cases, the return value is an opaque object that offers a `then` member
172 function to use to create chains of processes to run sequentially.<br/>
173 As a minimal example of use:
174 
175 ```cpp
176 // schedules a task in the form of a lambda function
177 scheduler.attach([](auto delta, void *, auto succeed, auto fail) {
178  // ...
179 })
180 // appends a child in the form of another lambda function
181 .then([](auto delta, void *, auto succeed, auto fail) {
182  // ...
183 })
184 // appends a child in the form of a process class
185 .then<my_process>();
186 ```
187 
188 To update a scheduler and therefore all its processes, the `update` member
189 function is the way to go:
190 
191 ```cpp
192 // updates all the processes, no user data are provided
193 scheduler.update(delta);
194 
195 // updates all the processes and provides them with custom data
196 scheduler.update(delta, &data);
197 ```
198 
199 In addition to these functions, the scheduler offers an `abort` member function
200 that can be used to discard all the running processes at once:
201 
202 ```cpp
203 // aborts all the processes abruptly ...
204 scheduler.abort(true);
205 
206 // ... or gracefully during the next tick
207 scheduler.abort();
208 ```
Generated by   diff --git a/prototype_8hpp_source.html b/prototype_8hpp_source.html index cc869e20a..36f1b7d96 100644 --- a/prototype_8hpp_source.html +++ b/prototype_8hpp_source.html @@ -22,7 +22,7 @@
@@ -67,31 +67,36 @@ $(function() {
prototype.hpp
-
1 #ifndef ENTT_ENTITY_PROTOTYPE_HPP
2 #define ENTT_ENTITY_PROTOTYPE_HPP
3 
4 
5 #include <tuple>
6 #include <utility>
7 #include <cstddef>
8 #include <type_traits>
9 #include <unordered_map>
10 #include "../config/config.h"
11 #include "registry.hpp"
12 #include "entity.hpp"
13 
14 
15 namespace entt {
16 
17 
39 template<typename Entity>
40 class Prototype final {
41  using basic_fn_type = void(const Prototype &, Registry<Entity> &, const Entity);
42  using component_type = typename Registry<Entity>::component_type;
43 
44  template<typename Component>
45  struct Wrapper { Component component; };
46 
47  struct Handler {
48  basic_fn_type *accommodate;
49  basic_fn_type *assign;
50  };
51 
52  void release() {
53  if(registry->valid(entity)) {
54  registry->destroy(entity);
55  }
56  }
57 
58 public:
60  using registry_type = Registry<Entity>;
62  using entity_type = Entity;
64  using size_type = std::size_t;
65 
70  Prototype(Registry<Entity> &registry)
71  : registry{&registry},
72  entity{registry.create()}
73  {}
74 
78  ~Prototype() {
79  release();
80  }
81 
83  Prototype(const Prototype &) = delete;
84 
94  Prototype(Prototype &&other)
95  : handlers{std::move(other.handlers)},
96  registry{other.registry},
97  entity{other.entity}
98  {
99  other.entity = entt::null;
100  }
101 
103  Prototype & operator=(const Prototype &) = delete;
104 
115  Prototype & operator=(Prototype &&other) {
116  if(this != &other) {
117  auto tmp{std::move(other)};
118  handlers.swap(tmp.handlers);
119  std::swap(registry, tmp.registry);
120  std::swap(entity, tmp.entity);
121  }
122 
123  return *this;
124  }
125 
133  template<typename Component, typename... Args>
134  Component & set(Args &&... args) {
135  basic_fn_type *accommodate = [](const Prototype &prototype, Registry<Entity> &other, const Entity dst) {
136  const auto &wrapper = prototype.registry->template get<Wrapper<Component>>(prototype.entity);
137  other.template accommodate<Component>(dst, wrapper.component);
138  };
139 
140  basic_fn_type *assign = [](const Prototype &prototype, Registry<Entity> &other, const Entity dst) {
141  if(!other.template has<Component>(dst)) {
142  const auto &wrapper = prototype.registry->template get<Wrapper<Component>>(prototype.entity);
143  other.template assign<Component>(dst, wrapper.component);
144  }
145  };
146 
147  handlers[registry->template type<Component>()] = Handler{accommodate, assign};
148  auto &wrapper = registry->template accommodate<Wrapper<Component>>(entity, Component{std::forward<Args>(args)...});
149  return wrapper.component;
150  }
151 
156  template<typename Component>
157  void unset() ENTT_NOEXCEPT {
158  registry->template reset<Wrapper<Component>>(entity);
159  handlers.erase(registry->template type<Component>());
160  }
161 
167  template<typename... Component>
168  bool has() const ENTT_NOEXCEPT {
169  return registry->template has<Wrapper<Component>...>(entity);
170  }
171 
184  template<typename Component>
185  const Component & get() const ENTT_NOEXCEPT {
186  return registry->template get<Wrapper<Component>>(entity).component;
187  }
188 
201  template<typename Component>
202  inline Component & get() ENTT_NOEXCEPT {
203  return const_cast<Component &>(const_cast<const Prototype *>(this)->get<Component>());
204  }
205 
218  template<typename... Component>
219  inline std::enable_if_t<(sizeof...(Component) > 1), std::tuple<const Component &...>>
220  get() const ENTT_NOEXCEPT {
221  return std::tuple<const Component &...>{get<Component>()...};
222  }
223 
236  template<typename... Component>
237  inline std::enable_if_t<(sizeof...(Component) > 1), std::tuple<Component &...>>
238  get() ENTT_NOEXCEPT {
239  return std::tuple<Component &...>{get<Component>()...};
240  }
241 
260  entity_type create(registry_type &other) const {
261  const auto entity = other.create();
262  assign(other, entity);
263  return entity;
264  }
265 
283  inline entity_type create() const {
284  return create(*registry);
285  }
286 
308  void assign(registry_type &other, const entity_type dst) const {
309  for(auto &handler: handlers) {
310  handler.second.assign(*this, other, dst);
311  }
312  }
313 
334  inline void assign(const entity_type dst) const {
335  assign(*registry, dst);
336  }
337 
357  void accommodate(registry_type &other, const entity_type dst) const {
358  for(auto &handler: handlers) {
359  handler.second.accommodate(*this, other, dst);
360  }
361  }
362 
381  inline void accommodate(const entity_type dst) const {
382  accommodate(*registry, dst);
383  }
384 
406  inline void operator()(registry_type &other, const entity_type dst) const ENTT_NOEXCEPT {
407  assign(other, dst);
408  }
409 
430  inline void operator()(const entity_type dst) const ENTT_NOEXCEPT {
431  assign(*registry, dst);
432  }
433 
452  inline entity_type operator()(registry_type &other) const ENTT_NOEXCEPT {
453  return create(other);
454  }
455 
473  inline entity_type operator()() const ENTT_NOEXCEPT {
474  return create(*registry);
475  }
476 
477 private:
478  std::unordered_map<component_type, Handler> handlers;
479  Registry<Entity> *registry;
480  entity_type entity;
481 };
482 
483 
491 using DefaultPrototype = Prototype<DefaultRegistry::entity_type>;
492 
493 
494 }
495 
496 
497 #endif // ENTT_ENTITY_PROTOTYPE_HPP
entt::Prototype::size_type
std::size_t size_type
Unsigned integer type.
Definition: prototype.hpp:64
-
entt::Prototype::entity_type
Entity entity_type
Underlying entity identifier.
Definition: prototype.hpp:62
-
entt::Registry
Fast and reliable entity-component system.
Definition: registry.hpp:42
-
entt::Prototype::Prototype
Prototype(Registry< Entity > &registry)
Constructs a prototype that is bound to a given registry.
Definition: prototype.hpp:70
-
entt::Prototype::assign
void assign(const entity_type dst) const
Assigns the components of a prototype to a given entity.
Definition: prototype.hpp:334
-
entt::Prototype::Prototype
Prototype(Prototype &&other)
Move constructor.
Definition: prototype.hpp:94
+
1 #ifndef ENTT_ENTITY_PROTOTYPE_HPP
2 #define ENTT_ENTITY_PROTOTYPE_HPP
3 
4 
5 #include <tuple>
6 #include <utility>
7 #include <cstddef>
8 #include <type_traits>
9 #include <unordered_map>
10 #include "../config/config.h"
11 #include "registry.hpp"
12 #include "entity.hpp"
13 #include "fwd.hpp"
14 
15 
16 namespace entt {
17 
18 
40 template<typename Entity>
41 class basic_prototype {
42  using basic_fn_type = void(const basic_prototype &, basic_registry<Entity> &, const Entity);
43  using component_type = typename basic_registry<Entity>::component_type;
44 
45  template<typename Component>
46  struct component_wrapper { Component component; };
47 
48  struct component_handler {
49  basic_fn_type *assign_or_replace;
50  basic_fn_type *assign;
51  };
52 
53  void release() {
54  if(reg->valid(entity)) {
55  reg->destroy(entity);
56  }
57  }
58 
59 public:
61  using registry_type = basic_registry<Entity>;
63  using entity_type = Entity;
65  using size_type = std::size_t;
66 
71  basic_prototype(registry_type &ref)
72  : reg{&ref},
73  entity{ref.create()}
74  {}
75 
79  ~basic_prototype() {
80  release();
81  }
82 
92  basic_prototype(basic_prototype &&other)
93  : handlers{std::move(other.handlers)},
94  reg{other.reg},
95  entity{other.entity}
96  {
97  other.entity = null;
98  }
99 
110  basic_prototype & operator=(basic_prototype &&other) {
111  if(this != &other) {
112  auto tmp{std::move(other)};
113  handlers.swap(tmp.handlers);
114  std::swap(reg, tmp.reg);
115  std::swap(entity, tmp.entity);
116  }
117 
118  return *this;
119  }
120 
128  template<typename Component, typename... Args>
129  Component & set(Args &&... args) {
130  component_handler handler;
131 
132  handler.assign_or_replace = [](const basic_prototype &proto, registry_type &other, const Entity dst) {
133  const auto &wrapper = proto.reg->template get<component_wrapper<Component>>(proto.entity);
134  other.template assign_or_replace<Component>(dst, wrapper.component);
135  };
136 
137  handler.assign = [](const basic_prototype &proto, registry_type &other, const Entity dst) {
138  if(!other.template has<Component>(dst)) {
139  const auto &wrapper = proto.reg->template get<component_wrapper<Component>>(proto.entity);
140  other.template assign<Component>(dst, wrapper.component);
141  }
142  };
143 
144  handlers[reg->template type<Component>()] = handler;
145  auto &wrapper = reg->template assign_or_replace<component_wrapper<Component>>(entity, Component{std::forward<Args>(args)...});
146  return wrapper.component;
147  }
148 
153  template<typename Component>
154  void unset() ENTT_NOEXCEPT {
155  reg->template reset<component_wrapper<Component>>(entity);
156  handlers.erase(reg->template type<Component>());
157  }
158 
164  template<typename... Component>
165  bool has() const ENTT_NOEXCEPT {
166  return reg->template has<component_wrapper<Component>...>(entity);
167  }
168 
181  template<typename... Component>
182  decltype(auto) get() const ENTT_NOEXCEPT {
183  if constexpr(sizeof...(Component) == 1) {
184  return (std::as_const(*reg).template get<component_wrapper<Component...>>(entity).component);
185  } else {
186  return std::tuple<std::add_const_t<Component> &...>{get<Component>()...};
187  }
188  }
189 
191  template<typename... Component>
192  inline decltype(auto) get() ENTT_NOEXCEPT {
193  if constexpr(sizeof...(Component) == 1) {
194  return (const_cast<Component &>(std::as_const(*this).template get<Component>()), ...);
195  } else {
196  return std::tuple<Component &...>{get<Component>()...};
197  }
198  }
199 
205  template<typename... Component>
206  auto try_get() const ENTT_NOEXCEPT {
207  if constexpr(sizeof...(Component) == 1) {
208  const auto *wrapper = reg->template try_get<component_wrapper<Component...>>(entity);
209  return wrapper ? &wrapper->component : nullptr;
210  } else {
211  return std::tuple<std::add_const_t<Component> *...>{try_get<Component>()...};
212  }
213  }
214 
216  template<typename... Component>
217  inline auto try_get() ENTT_NOEXCEPT {
218  if constexpr(sizeof...(Component) == 1) {
219  return (const_cast<Component *>(std::as_const(*this).template try_get<Component>()), ...);
220  } else {
221  return std::tuple<Component *...>{try_get<Component>()...};
222  }
223  }
224 
243  entity_type create(registry_type &other) const {
244  const auto entt = other.create();
245  assign(other, entt);
246  return entt;
247  }
248 
266  inline entity_type create() const {
267  return create(*reg);
268  }
269 
291  void assign(registry_type &other, const entity_type dst) const {
292  for(auto &handler: handlers) {
293  handler.second.assign(*this, other, dst);
294  }
295  }
296 
317  inline void assign(const entity_type dst) const {
318  assign(*reg, dst);
319  }
320 
340  void assign_or_replace(registry_type &other, const entity_type dst) const {
341  for(auto &handler: handlers) {
342  handler.second.assign_or_replace(*this, other, dst);
343  }
344  }
345 
364  inline void assign_or_replace(const entity_type dst) const {
365  assign_or_replace(*reg, dst);
366  }
367 
389  inline void operator()(registry_type &other, const entity_type dst) const ENTT_NOEXCEPT {
390  assign(other, dst);
391  }
392 
413  inline void operator()(const entity_type dst) const ENTT_NOEXCEPT {
414  assign(*reg, dst);
415  }
416 
435  inline entity_type operator()(registry_type &other) const ENTT_NOEXCEPT {
436  return create(other);
437  }
438 
456  inline entity_type operator()() const ENTT_NOEXCEPT {
457  return create(*reg);
458  }
459 
464  inline const registry_type & backend() const ENTT_NOEXCEPT {
465  return *reg;
466  }
467 
469  inline registry_type & backend() ENTT_NOEXCEPT {
470  return const_cast<registry_type &>(std::as_const(*this).backend());
471  }
472 
473 private:
474  std::unordered_map<component_type, component_handler> handlers;
475  registry_type *reg;
476  entity_type entity;
477 };
478 
479 
480 }
481 
482 
483 #endif // ENTT_ENTITY_PROTOTYPE_HPP
entt::basic_prototype::basic_prototype
basic_prototype(basic_prototype &&other)
Move constructor.
Definition: prototype.hpp:92
+
entt::basic_prototype::assign_or_replace
void assign_or_replace(const entity_type dst) const
Assigns or replaces the components of a prototype for an entity.
Definition: prototype.hpp:364
+
entt::basic_prototype::create
entity_type create(registry_type &other) const
Creates a new entity using a given prototype.
Definition: prototype.hpp:243
+
entt::basic_prototype::entity_type
Entity entity_type
Underlying entity identifier.
Definition: prototype.hpp:63
+
entt::basic_prototype::size_type
std::size_t size_type
Unsigned integer type.
Definition: prototype.hpp:65
entt
EnTT default namespace.
Definition: algorithm.hpp:10
-
entt::Prototype::operator()
void operator()(const entity_type dst) const ENTT_NOEXCEPT
Assigns the components of a prototype to an entity.
Definition: prototype.hpp:430
-
entt::Prototype::create
entity_type create() const
Creates a new entity using a given prototype.
Definition: prototype.hpp:283
-
entt::Prototype::accommodate
void accommodate(registry_type &other, const entity_type dst) const
Assigns or replaces the components of a prototype for an entity.
Definition: prototype.hpp:357
-
entt::Prototype::operator()
void operator()(registry_type &other, const entity_type dst) const ENTT_NOEXCEPT
Assigns the components of a prototype to an entity.
Definition: prototype.hpp:406
-
entt::null
constexpr auto null
Null entity.
Definition: entity.hpp:78
-
entt::Prototype::~Prototype
~Prototype()
Releases all its resources.
Definition: prototype.hpp:78
-
entt::Prototype::unset
void unset() ENTT_NOEXCEPT
Removes the given component from a prototype.
Definition: prototype.hpp:157
-
entt::Registry::create
entity_type create()
Creates a new entity and returns it.
Definition: registry.hpp:521
-
entt::Prototype::operator()
entity_type operator()(registry_type &other) const ENTT_NOEXCEPT
Creates a new entity using a given prototype.
Definition: prototype.hpp:452
-
entt::Prototype::operator=
Prototype & operator=(const Prototype &)=delete
Copying a prototype isn&#39;t allowed.
-
entt::Prototype::has
bool has() const ENTT_NOEXCEPT
Checks if a prototype owns all the given components.
Definition: prototype.hpp:168
-
entt::Registry::component_type
typename component_family::family_type component_type
Unsigned integer type.
Definition: registry.hpp:231
-
entt::Prototype::operator()
entity_type operator()() const ENTT_NOEXCEPT
Creates a new entity using a given prototype.
Definition: prototype.hpp:473
-
entt::Prototype
Prototype container for concepts.
Definition: prototype.hpp:40
-
entt::Prototype::assign
void assign(registry_type &other, const entity_type dst) const
Assigns the components of a prototype to a given entity.
Definition: prototype.hpp:308
-
entt::Prototype::accommodate
void accommodate(const entity_type dst) const
Assigns or replaces the components of a prototype for an entity.
Definition: prototype.hpp:381
-
entt::Prototype::operator=
Prototype & operator=(Prototype &&other)
Move assignment operator.
Definition: prototype.hpp:115
-
entt::Prototype::create
entity_type create(registry_type &other) const
Creates a new entity using a given prototype.
Definition: prototype.hpp:260
+
entt::basic_prototype::~basic_prototype
~basic_prototype()
Releases all its resources.
Definition: prototype.hpp:79
+
entt::basic_prototype::operator()
void operator()(const entity_type dst) const ENTT_NOEXCEPT
Assigns the components of a prototype to an entity.
Definition: prototype.hpp:413
+
entt::basic_registry::create
decltype(auto) create()
Creates a new entity and returns it.
Definition: registry.hpp:569
+
entt::basic_prototype::assign
void assign(const entity_type dst) const
Assigns the components of a prototype to a given entity.
Definition: prototype.hpp:317
+
entt::basic_prototype::basic_prototype
basic_prototype(registry_type &ref)
Constructs a prototype that is bound to a given registry.
Definition: prototype.hpp:71
+
entt::basic_prototype::operator()
void operator()(registry_type &other, const entity_type dst) const ENTT_NOEXCEPT
Assigns the components of a prototype to an entity.
Definition: prototype.hpp:389
+
entt::basic_prototype::create
entity_type create() const
Creates a new entity using a given prototype.
Definition: prototype.hpp:266
+
entt::null
constexpr auto null
Null entity.
Definition: entity.hpp:163
+
entt::basic_prototype::operator()
entity_type operator()() const ENTT_NOEXCEPT
Creates a new entity using a given prototype.
Definition: prototype.hpp:456
+
entt::basic_registry::component_type
ENTT_ID_TYPE component_type
Unsigned integer type.
Definition: registry.hpp:322
+
entt::basic_registry
Fast and reliable entity-component system.
Definition: fwd.hpp:13
+
entt::basic_prototype::try_get
auto try_get() ENTT_NOEXCEPT
Returns pointers to the given components.
Definition: prototype.hpp:217
+
entt::basic_prototype::unset
void unset() ENTT_NOEXCEPT
Removes the given component from a prototype.
Definition: prototype.hpp:154
+
entt::basic_prototype::assign_or_replace
void assign_or_replace(registry_type &other, const entity_type dst) const
Assigns or replaces the components of a prototype for an entity.
Definition: prototype.hpp:340
+
entt::basic_prototype::assign
void assign(registry_type &other, const entity_type dst) const
Assigns the components of a prototype to a given entity.
Definition: prototype.hpp:291
+
entt::basic_prototype
Prototype container for concepts.
Definition: fwd.hpp:33
+
entt::basic_prototype::backend
const registry_type & backend() const ENTT_NOEXCEPT
Returns a reference to the underlying registry.
Definition: prototype.hpp:464
+
entt::basic_prototype::backend
registry_type & backend() ENTT_NOEXCEPT
Returns a reference to the underlying registry.
Definition: prototype.hpp:469
+
entt::basic_prototype::operator()
entity_type operator()(registry_type &other) const ENTT_NOEXCEPT
Creates a new entity using a given prototype.
Definition: prototype.hpp:435
+
entt::basic_prototype::get
decltype(auto) get() const ENTT_NOEXCEPT
Returns references to the given components.
Definition: prototype.hpp:182
+
entt::basic_prototype::try_get
auto try_get() const ENTT_NOEXCEPT
Returns pointers to the given components.
Definition: prototype.hpp:206
+
entt::basic_prototype::has
bool has() const ENTT_NOEXCEPT
Checks if a prototype owns all the given components.
Definition: prototype.hpp:165
+
entt::entity
std::uint32_t entity
Alias declaration for the most common use case.
Definition: fwd.hpp:48
+
entt::basic_prototype::operator=
basic_prototype & operator=(basic_prototype &&other)
Move assignment operator.
Definition: prototype.hpp:110
diff --git a/registry_8hpp_source.html b/registry_8hpp_source.html index f1a2308d3..04ce3edb7 100644 --- a/registry_8hpp_source.html +++ b/registry_8hpp_source.html @@ -22,7 +22,7 @@
@@ -67,91 +67,87 @@ $(function() {
registry.hpp
-
1 #ifndef ENTT_ENTITY_REGISTRY_HPP
2 #define ENTT_ENTITY_REGISTRY_HPP
3 
4 
5 #include <tuple>
6 #include <vector>
7 #include <memory>
8 #include <utility>
9 #include <cstddef>
10 #include <cstdint>
11 #include <cassert>
12 #include <iterator>
13 #include <algorithm>
14 #include <type_traits>
15 #include "../config/config.h"
16 #include "../core/algorithm.hpp"
17 #include "../core/family.hpp"
18 #include "../signal/sigh.hpp"
19 #include "attachee.hpp"
20 #include "entity.hpp"
21 #include "entt_traits.hpp"
22 #include "snapshot.hpp"
23 #include "sparse_set.hpp"
24 #include "utility.hpp"
25 #include "view.hpp"
26 
27 
28 namespace entt {
29 
30 
41 template<typename Entity>
42 class Registry {
43  using tag_family = Family<struct InternalRegistryTagFamily>;
44  using component_family = Family<struct InternalRegistryComponentFamily>;
45  using handler_family = Family<struct InternalRegistryHandlerFamily>;
46  using signal_type = SigH<void(Registry &, const Entity)>;
47  using traits_type = entt_traits<Entity>;
48 
49  template<typename Component>
50  struct Pool: SparseSet<Entity, Component> {
51  Pool(Registry *registry) ENTT_NOEXCEPT
52  : registry{registry}
53  {}
54 
55  template<typename... Args>
56  Component & construct(const Entity entity, Args &&... args) {
57  auto &component = SparseSet<Entity, Component>::construct(entity, std::forward<Args>(args)...);
58  ctor.publish(*registry, entity);
59  return component;
60  }
61 
62  void destroy(const Entity entity) override {
63  dtor.publish(*registry, entity);
64  SparseSet<Entity, Component>::destroy(entity);
65  }
66 
67  typename signal_type::sink_type construction() ENTT_NOEXCEPT {
68  return ctor.sink();
69  }
70 
71  typename signal_type::sink_type destruction() ENTT_NOEXCEPT {
72  return dtor.sink();
73  }
74 
75  private:
76  Registry *registry;
77  signal_type ctor;
78  signal_type dtor;
79  };
80 
81  template<typename Tag>
82  struct Attaching: Attachee<Entity, Tag> {
83  Attaching(Registry *registry)
84  : registry{registry}
85  {}
86 
87  template<typename... Args>
88  Tag & construct(const Entity entity, Args &&... args) ENTT_NOEXCEPT {
89  auto &tag = Attachee<Entity, Tag>::construct(entity, std::forward<Args>(args)...);
90  ctor.publish(*registry, entity);
91  return tag;
92  }
93 
94  void destroy() ENTT_NOEXCEPT override {
95  dtor.publish(*registry, Attachee<Entity>::get());
96  Attachee<Entity, Tag>::destroy();
97  }
98 
99  Entity move(const Entity entity) ENTT_NOEXCEPT {
100  const auto owner = Attachee<Entity>::get();
101  dtor.publish(*registry, owner);
102  Attachee<Entity, Tag>::move(entity);
103  ctor.publish(*registry, entity);
104  return owner;
105  }
106 
107  typename signal_type::sink_type construction() ENTT_NOEXCEPT {
108  return ctor.sink();
109  }
110 
111  typename signal_type::sink_type destruction() ENTT_NOEXCEPT {
112  return dtor.sink();
113  }
114 
115  private:
116  Registry *registry;
117  signal_type ctor;
118  signal_type dtor;
119  };
120 
121  template<typename handler_family::family_type(*Type)(), typename... Component>
122  static void creating(Registry &registry, const Entity entity) {
123  if(registry.has<Component...>(entity)) {
124  registry.handlers[Type()]->construct(entity);
125  }
126  }
127 
128  template<typename... Component>
129  static void destroying(Registry &registry, const Entity entity) {
130  auto &handler = *registry.handlers[handler_family::type<Component...>()];
131  return handler.has(entity) ? handler.destroy(entity) : void();
132  }
133 
134  template<typename Tag>
135  inline bool managed(tag_t) const ENTT_NOEXCEPT {
136  const auto ttype = tag_family::type<Tag>();
137  return ttype < tags.size() && tags[ttype];
138  }
139 
140  template<typename Component>
141  inline bool managed() const ENTT_NOEXCEPT {
142  const auto ctype = component_family::type<Component>();
143  return ctype < pools.size() && pools[ctype];
144  }
145 
146  template<typename Tag>
147  inline const Attaching<Tag> & pool(tag_t) const ENTT_NOEXCEPT {
148  assert(managed<Tag>(tag_t{}));
149  return static_cast<const Attaching<Tag> &>(*tags[tag_family::type<Tag>()]);
150  }
151 
152  template<typename Tag>
153  inline Attaching<Tag> & pool(tag_t) ENTT_NOEXCEPT {
154  return const_cast<Attaching<Tag> &>(const_cast<const Registry *>(this)->pool<Tag>(tag_t{}));
155  }
156 
157  template<typename Component>
158  inline const Pool<Component> & pool() const ENTT_NOEXCEPT {
159  assert(managed<Component>());
160  return static_cast<const Pool<Component> &>(*pools[component_family::type<Component>()]);
161  }
162 
163  template<typename Component>
164  inline Pool<Component> & pool() ENTT_NOEXCEPT {
165  return const_cast<Pool<Component> &>(const_cast<const Registry *>(this)->pool<Component>());
166  }
167 
168  template<typename Comp, std::size_t Pivot, typename... Component, std::size_t... Indexes>
169  void connect(std::index_sequence<Indexes...>) {
170  pool<Comp>().construction().template connect<&Registry::creating<&handler_family::type<Component...>, std::tuple_element_t<(Indexes < Pivot ? Indexes : (Indexes+1)), std::tuple<Component...>>...>>();
171  pool<Comp>().destruction().template connect<&Registry::destroying<Component...>>();
172  }
173 
174  template<typename... Component, std::size_t... Indexes>
175  void connect(std::index_sequence<Indexes...>) {
176  using accumulator_type = int[];
177  accumulator_type accumulator = { (assure<Component>(), connect<Component, Indexes, Component...>(std::make_index_sequence<sizeof...(Component)-1>{}), 0)... };
178  (void)accumulator;
179  }
180 
181  template<typename Comp, std::size_t Pivot, typename... Component, std::size_t... Indexes>
182  void disconnect(std::index_sequence<Indexes...>) {
183  pool<Comp>().construction().template disconnect<&Registry::creating<&handler_family::type<Component...>, std::tuple_element_t<(Indexes < Pivot ? Indexes : (Indexes+1)), std::tuple<Component...>>...>>();
184  pool<Comp>().destruction().template disconnect<&Registry::destroying<Component...>>();
185  }
186 
187  template<typename... Component, std::size_t... Indexes>
188  void disconnect(std::index_sequence<Indexes...>) {
189  using accumulator_type = int[];
190  // if a set exists, pools have already been created for it
191  accumulator_type accumulator = { (disconnect<Component, Indexes, Component...>(std::make_index_sequence<sizeof...(Component)-1>{}), 0)... };
192  (void)accumulator;
193  }
194 
195  template<typename Component>
196  void assure() {
197  const auto ctype = component_family::type<Component>();
198 
199  if(!(ctype < pools.size())) {
200  pools.resize(ctype + 1);
201  }
202 
203  if(!pools[ctype]) {
204  pools[ctype] = std::make_unique<Pool<Component>>(this);
205  }
206  }
207 
208  template<typename Tag>
209  void assure(tag_t) {
210  const auto ttype = tag_family::type<Tag>();
211 
212  if(!(ttype < tags.size())) {
213  tags.resize(ttype + 1);
214  }
215 
216  if(!tags[ttype]) {
217  tags[ttype] = std::make_unique<Attaching<Tag>>(this);
218  }
219  }
220 
221 public:
223  using entity_type = typename traits_type::entity_type;
225  using version_type = typename traits_type::version_type;
227  using size_type = std::size_t;
229  using tag_type = typename tag_family::family_type;
231  using component_type = typename component_family::family_type;
233  using sink_type = typename signal_type::sink_type;
234 
236  Registry() = default;
237 
239  Registry(const Registry &) = delete;
241  Registry(Registry &&) = default;
242 
244  Registry & operator=(const Registry &) = delete;
246  Registry & operator=(Registry &&) = default;
247 
260  template<typename Tag>
261  static tag_type type(tag_t) ENTT_NOEXCEPT {
262  return tag_family::type<Tag>();
263  }
264 
277  template<typename Component>
278  static component_type type() ENTT_NOEXCEPT {
279  return component_family::type<Component>();
280  }
281 
287  template<typename Component>
288  size_type size() const ENTT_NOEXCEPT {
289  return managed<Component>() ? pool<Component>().size() : size_type{};
290  }
291 
296  size_type size() const ENTT_NOEXCEPT {
297  return entities.size();
298  }
299 
304  size_type alive() const ENTT_NOEXCEPT {
305  return entities.size() - available;
306  }
307 
317  template<typename Component>
318  void reserve(const size_type cap) {
319  assure<Component>();
320  pool<Component>().reserve(cap);
321  }
322 
331  void reserve(const size_type cap) {
332  entities.reserve(cap);
333  }
334 
340  template<typename Component>
341  size_type capacity() const ENTT_NOEXCEPT {
342  return managed<Component>() ? pool<Component>().capacity() : size_type{};
343  }
344 
350  size_type capacity() const ENTT_NOEXCEPT {
351  return entities.capacity();
352  }
353 
360  template<typename Component>
361  bool empty() const ENTT_NOEXCEPT {
362  return !managed<Component>() || pool<Component>().empty();
363  }
364 
369  bool empty() const ENTT_NOEXCEPT {
370  return entities.size() == available;
371  }
372 
387  template<typename Component>
388  const Component * raw() const ENTT_NOEXCEPT {
389  return managed<Component>() ? pool<Component>().raw() : nullptr;
390  }
391 
406  template<typename Component>
407  inline Component * raw() ENTT_NOEXCEPT {
408  return const_cast<Component *>(const_cast<const Registry *>(this)->raw<Component>());
409  }
410 
425  template<typename Component>
426  const entity_type * data() const ENTT_NOEXCEPT {
427  return managed<Component>() ? pool<Component>().data() : nullptr;
428  }
429 
435  bool valid(const entity_type entity) const ENTT_NOEXCEPT {
436  const auto pos = size_type(entity & traits_type::entity_mask);
437  return (pos < entities.size() && entities[pos] == entity);
438  }
439 
457  bool fast(const entity_type entity) const ENTT_NOEXCEPT {
458  const auto pos = size_type(entity & traits_type::entity_mask);
459  assert(pos < entities.size());
460  return (entities[pos] == entity);
461  }
462 
468  entity_type entity(const entity_type entity) const ENTT_NOEXCEPT {
469  return entity & traits_type::entity_mask;
470  }
471 
477  version_type version(const entity_type entity) const ENTT_NOEXCEPT {
478  return version_type(entity >> traits_type::entity_shift);
479  }
480 
498  version_type current(const entity_type entity) const ENTT_NOEXCEPT {
499  const auto pos = size_type(entity & traits_type::entity_mask);
500  assert(pos < entities.size());
501  return version_type(entities[pos] >> traits_type::entity_shift);
502  }
503 
521  entity_type create() {
522  entity_type entity;
523 
524  if(available) {
525  const auto entt = next;
526  const auto version = entities[entt] & (traits_type::version_mask << traits_type::entity_shift);
527  next = entities[entt] & traits_type::entity_mask;
528  entity = entt | version;
529  entities[entt] = entity;
530  --available;
531  } else {
532  entity = entity_type(entities.size());
533  entities.push_back(entity);
534  // traits_type::entity_mask is reserved to allow for null identifiers
535  assert(entity < traits_type::entity_mask);
536  }
537 
538  return entity;
539  }
540 
555  template<typename Tag>
556  void destroy(tag_t) {
557  return has<Tag>() ? destroy(attachee<Tag>()) : void();
558  }
559 
582  void destroy(const entity_type entity) {
583  assert(valid(entity));
584 
585  for(auto pos = pools.size(); pos; --pos) {
586  auto &cpool = pools[pos-1];
587 
588  if(cpool && cpool->has(entity)) {
589  cpool->destroy(entity);
590  }
591  };
592 
593  for(auto pos = tags.size(); pos; --pos) {
594  auto &tag = tags[pos-1];
595 
596  if(tag && tag->get() == entity) {
597  tag->destroy();
598  }
599  };
600 
601  // just a way to protect users from listeners that attach components
602  assert(orphan(entity));
603 
604  // lengthens the implicit list of destroyed entities
605  const auto entt = entity & traits_type::entity_mask;
606  const auto version = ((entity >> traits_type::entity_shift) + 1) << traits_type::entity_shift;
607  const auto node = (available ? next : ((entt + 1) & traits_type::entity_mask)) | version;
608  entities[entt] = node;
609  next = entt;
610  ++available;
611  }
612 
628  template<typename... Component, typename... Type>
629  void destroy(Type...) {
630  for(const auto entity: view<Component...>(Type{}...)) {
631  destroy(entity);
632  }
633  }
634 
656  template<typename Tag, typename... Args>
657  Tag & assign(tag_t, const entity_type entity, Args &&... args) {
658  assert(valid(entity));
659  assert(!has<Tag>());
660  assure<Tag>(tag_t{});
661  return pool<Tag>(tag_t{}).construct(entity, std::forward<Args>(args)...);
662  }
663 
684  template<typename Component, typename... Args>
685  Component & assign(const entity_type entity, Args &&... args) {
686  assert(valid(entity));
687  assure<Component>();
688  return pool<Component>().construct(entity, std::forward<Args>(args)...);
689  }
690 
695  template<typename Tag>
696  void remove() {
697  return has<Tag>() ? pool<Tag>(tag_t{}).destroy() : void();
698  }
699 
713  template<typename Component>
714  void remove(const entity_type entity) {
715  assert(valid(entity));
716  assert(managed<Component>());
717  pool<Component>().destroy(entity);
718  }
719 
725  template<typename Tag>
726  bool has() const ENTT_NOEXCEPT {
727  return managed<Tag>(tag_t{}) && tags[tag_family::type<Tag>()]->get() != null;
728  }
729 
743  template<typename Tag>
744  bool has(tag_t, const entity_type entity) const ENTT_NOEXCEPT {
745  return has<Tag>() && attachee<Tag>() == entity;
746  }
747 
760  template<typename... Component>
761  bool has(const entity_type entity) const ENTT_NOEXCEPT {
762  assert(valid(entity));
763  bool all = true;
764  using accumulator_type = bool[];
765  accumulator_type accumulator = { all, (all = all && managed<Component>() && pool<Component>().has(entity))... };
766  (void)accumulator;
767  return all;
768  }
769 
782  template<typename Tag>
783  const Tag & get() const ENTT_NOEXCEPT {
784  assert(has<Tag>());
785  return pool<Tag>(tag_t{}).get();
786  }
787 
800  template<typename Tag>
801  inline Tag & get() ENTT_NOEXCEPT {
802  return const_cast<Tag &>(const_cast<const Registry *>(this)->get<Tag>());
803  }
804 
819  template<typename Component>
820  const Component & get(const entity_type entity) const ENTT_NOEXCEPT {
821  assert(valid(entity));
822  assert(managed<Component>());
823  return pool<Component>().get(entity);
824  }
825 
840  template<typename Component>
841  inline Component & get(const entity_type entity) ENTT_NOEXCEPT {
842  return const_cast<Component &>(const_cast<const Registry *>(this)->get<Component>(entity));
843  }
844 
859  template<typename... Component>
860  inline std::enable_if_t<(sizeof...(Component) > 1), std::tuple<const Component &...>>
861  get(const entity_type entity) const ENTT_NOEXCEPT {
862  return std::tuple<const Component &...>{get<Component>(entity)...};
863  }
864 
879  template<typename... Component>
880  inline std::enable_if_t<(sizeof...(Component) > 1), std::tuple<Component &...>>
881  get(const entity_type entity) ENTT_NOEXCEPT {
882  return std::tuple<Component &...>{get<Component>(entity)...};
883  }
884 
903  template<typename Tag, typename... Args>
904  Tag & replace(tag_t, Args &&... args) {
905  return (get<Tag>() = Tag{std::forward<Args>(args)...});
906  }
907 
928  template<typename Component, typename... Args>
929  Component & replace(const entity_type entity, Args &&... args) {
930  return (get<Component>(entity) = Component{std::forward<Args>(args)...});
931  }
932 
949  template<typename Tag>
950  entity_type move(const entity_type entity) ENTT_NOEXCEPT {
951  assert(valid(entity));
952  assert(has<Tag>());
953  return pool<Tag>(tag_t{}).move(entity);
954  }
955 
962  template<typename Tag>
963  entity_type attachee() const ENTT_NOEXCEPT {
964  return managed<Tag>(tag_t{}) ? tags[tag_family::type<Tag>()]->get() : null;
965  }
966 
993  template<typename Component, typename... Args>
994  Component & accommodate(const entity_type entity, Args &&... args) {
995  assure<Component>();
996  auto &cpool = pool<Component>();
997 
998  return cpool.has(entity)
999  ? cpool.get(entity) = Component{std::forward<Args>(args)...}
1000  : cpool.construct(entity, std::forward<Args>(args)...);
1001  }
1002 
1026  template<typename Tag>
1027  sink_type construction(tag_t) ENTT_NOEXCEPT {
1028  assure<Tag>(tag_t{});
1029  return pool<Tag>(tag_t{}).construction();
1030  }
1031 
1055  template<typename Component>
1056  sink_type construction() ENTT_NOEXCEPT {
1057  assure<Component>();
1058  return pool<Component>().construction();
1059  }
1060 
1084  template<typename Tag>
1085  sink_type destruction(tag_t) ENTT_NOEXCEPT {
1086  assure<Tag>(tag_t{});
1087  return pool<Tag>(tag_t{}).destruction();
1088  }
1089 
1113  template<typename Component>
1114  sink_type destruction() ENTT_NOEXCEPT {
1115  assure<Component>();
1116  return pool<Component>().destruction();
1117  }
1118 
1160  template<typename Component, typename Compare, typename Sort = StdSort, typename... Args>
1161  void sort(Compare compare, Sort sort = Sort{}, Args &&... args) {
1162  assure<Component>();
1163  pool<Component>().sort(std::move(compare), std::move(sort), std::forward<Args>(args)...);
1164  }
1165 
1196  template<typename To, typename From>
1197  void sort() {
1198  assure<To>();
1199  assure<From>();
1200  pool<To>().respect(pool<From>());
1201  }
1202 
1217  template<typename Component>
1218  void reset(const entity_type entity) {
1219  assert(valid(entity));
1220  assure<Component>();
1221  auto &cpool = pool<Component>();
1222 
1223  if(cpool.has(entity)) {
1224  cpool.destroy(entity);
1225  }
1226  }
1227 
1236  template<typename Component>
1237  void reset() {
1238  assure<Component>();
1239  auto &cpool = pool<Component>();
1240 
1241  for(const auto entity: static_cast<SparseSet<Entity> &>(cpool)) {
1242  cpool.destroy(entity);
1243  }
1244  }
1245 
1254  void reset() {
1255  each([this](const auto entity) {
1256  // useless this-> used to suppress a warning with clang
1257  this->destroy(entity);
1258  });
1259  }
1260 
1281  template<typename Func>
1282  void each(Func func) const {
1283  if(available) {
1284  for(auto pos = entities.size(); pos; --pos) {
1285  const auto curr = entity_type(pos - 1);
1286  const auto entity = entities[curr];
1287  const auto entt = entity & traits_type::entity_mask;
1288 
1289  if(curr == entt) {
1290  func(entity);
1291  }
1292  }
1293  } else {
1294  for(auto pos = entities.size(); pos; --pos) {
1295  func(entities[pos-1]);
1296  }
1297  }
1298  }
1299 
1309  bool orphan(const entity_type entity) const {
1310  assert(valid(entity));
1311  bool orphan = true;
1312 
1313  for(std::size_t i = 0; i < pools.size() && orphan; ++i) {
1314  const auto &cpool = pools[i];
1315  orphan = !(cpool && cpool->has(entity));
1316  }
1317 
1318  for(std::size_t i = 0; i < tags.size() && orphan; ++i) {
1319  const auto &tag = tags[i];
1320  orphan = !(tag && (tag->get() == entity));
1321  }
1322 
1323  return orphan;
1324  }
1325 
1342  template<typename Func>
1343  void orphans(Func func) const {
1344  each([func = std::move(func), this](const auto entity) {
1345  if(orphan(entity)) {
1346  func(entity);
1347  }
1348  });
1349  }
1350 
1385  template<typename... Component>
1386  View<Entity, Component...> view() {
1387  return View<Entity, Component...>{(assure<Component>(), pool<Component>())...};
1388  }
1389 
1406  template<typename... Component>
1407  void prepare() {
1408  static_assert(sizeof...(Component) > 1, "!");
1409  const auto htype = handler_family::type<Component...>();
1410 
1411  if(!(htype < handlers.size())) {
1412  handlers.resize(htype + 1);
1413  }
1414 
1415  if(!handlers[htype]) {
1416  connect<Component...>(std::make_index_sequence<sizeof...(Component)>{});
1417  handlers[htype] = std::make_unique<SparseSet<entity_type>>();
1418  auto &handler = *handlers[htype];
1419 
1420  for(auto entity: view<Component...>()) {
1421  handler.construct(entity);
1422  }
1423  }
1424  }
1425 
1441  template<typename... Component>
1442  void discard() {
1443  if(contains<Component...>()) {
1444  disconnect<Component...>(std::make_index_sequence<sizeof...(Component)>{});
1445  handlers[handler_family::type<Component...>()].reset();
1446  }
1447  }
1448 
1454  template<typename... Component>
1455  bool contains() const ENTT_NOEXCEPT {
1456  static_assert(sizeof...(Component) > 1, "!");
1457  const auto htype = handler_family::type<Component...>();
1458  return (htype < handlers.size() && handlers[htype]);
1459  }
1460 
1500  template<typename... Component>
1501  PersistentView<Entity, Component...> view(persistent_t) {
1502  prepare<Component...>();
1503  const auto htype = handler_family::type<Component...>();
1504  return PersistentView<Entity, Component...>{*handlers[htype], (assure<Component>(), pool<Component>())...};
1505  }
1506 
1530  template<typename Component>
1531  RawView<Entity, Component> view(raw_t) {
1532  assure<Component>();
1533  return RawView<Entity, Component>{pool<Component>()};
1534  }
1535 
1562  template<typename It>
1563  RuntimeView<Entity> view(It first, It last) {
1564  static_assert(std::is_convertible<typename std::iterator_traits<It>::value_type, component_type>::value, "!");
1565  std::vector<const SparseSet<Entity> *> set(last - first);
1566 
1567  std::transform(first, last, set.begin(), [this](const component_type ctype) {
1568  return ctype < pools.size() ? pools[ctype].get() : nullptr;
1569  });
1570 
1571  return RuntimeView<Entity>{std::move(set)};
1572  }
1573 
1584  Snapshot<Entity> snapshot() const ENTT_NOEXCEPT {
1585  using follow_fn_type = entity_type(const Registry &, const entity_type);
1586  const entity_type seed = available ? (next | (entities[next] & (traits_type::version_mask << traits_type::entity_shift))) : next;
1587 
1588  follow_fn_type *follow = [](const Registry &registry, const entity_type entity) -> entity_type {
1589  const auto &entities = registry.entities;
1590  const auto entt = entity & traits_type::entity_mask;
1591  const auto next = entities[entt] & traits_type::entity_mask;
1592  return (next | (entities[next] & (traits_type::version_mask << traits_type::entity_shift)));
1593  };
1594 
1595  return { *this, seed, follow };
1596  }
1597 
1613  SnapshotLoader<Entity> restore() ENTT_NOEXCEPT {
1614  using assure_fn_type = void(Registry &, const entity_type, const bool);
1615 
1616  assure_fn_type *assure = [](Registry &registry, const entity_type entity, const bool destroyed) {
1617  using promotion_type = std::conditional_t<sizeof(size_type) >= sizeof(entity_type), size_type, entity_type>;
1618  // explicit promotion to avoid warnings with std::uint16_t
1619  const auto entt = promotion_type{entity} & traits_type::entity_mask;
1620  auto &entities = registry.entities;
1621 
1622  if(!(entt < entities.size())) {
1623  auto curr = entities.size();
1624  entities.resize(entt + 1);
1625  std::iota(entities.data() + curr, entities.data() + entt, entity_type(curr));
1626  }
1627 
1628  entities[entt] = entity;
1629 
1630  if(destroyed) {
1631  registry.destroy(entity);
1632  const auto version = entity & (traits_type::version_mask << traits_type::entity_shift);
1633  entities[entt] = ((entities[entt] & traits_type::entity_mask) | version);
1634  }
1635  };
1636 
1637  return { (*this = {}), assure };
1638  }
1639 
1640 private:
1641  std::vector<std::unique_ptr<SparseSet<Entity>>> handlers;
1642  std::vector<std::unique_ptr<SparseSet<Entity>>> pools;
1643  std::vector<std::unique_ptr<Attachee<Entity>>> tags;
1644  std::vector<entity_type> entities;
1645  size_type available{};
1646  entity_type next{};
1647 };
1648 
1649 
1656 using DefaultRegistry = Registry<std::uint32_t>;
1657 
1658 
1659 }
1660 
1661 
1662 #endif // ENTT_ENTITY_REGISTRY_HPP
entt::Registry::each
void each(Func func) const
Iterates all the entities that are still in use.
Definition: registry.hpp:1282
-
entt::Registry::discard
void discard()
Discards all the data structures used for a given persitent view.
Definition: registry.hpp:1442
-
entt::Registry::sink_type
typename signal_type::sink_type sink_type
Type of sink for the given component.
Definition: registry.hpp:233
-
entt::Registry::sort
void sort(Compare compare, Sort sort=Sort{}, Args &&... args)
Sorts the pool of entities for the given component.
Definition: registry.hpp:1161
-
entt::Registry::orphans
void orphans(Func func) const
Iterates orphans and applies them the given function object.
Definition: registry.hpp:1343
-
entt::Registry::size
size_type size() const ENTT_NOEXCEPT
Returns the number of entities created so far.
Definition: registry.hpp:296
-
entt::Registry::has
bool has() const ENTT_NOEXCEPT
Checks if the given tag has an owner.
Definition: registry.hpp:726
-
entt::Registry::alive
size_type alive() const ENTT_NOEXCEPT
Returns the number of entities still in use.
Definition: registry.hpp:304
-
entt::Registry::reset
void reset()
Resets the pool of the given component.
Definition: registry.hpp:1237
-
entt::Registry::accommodate
Component & accommodate(const entity_type entity, Args &&... args)
Assigns or replaces the given component for an entity.
Definition: registry.hpp:994
-
entt::Registry::destroy
void destroy(const entity_type entity)
Destroys an entity and lets the registry recycle the identifier.
Definition: registry.hpp:582
-
entt::Registry
Fast and reliable entity-component system.
Definition: registry.hpp:42
-
entt::raw_t
Raw view type used to disambiguate overloads.
Definition: utility.hpp:17
-
entt::persistent_t
Persistent view type used to disambiguate overloads.
Definition: utility.hpp:13
-
entt::Registry::destruction
sink_type destruction() ENTT_NOEXCEPT
Returns a sink object for the given component.
Definition: registry.hpp:1114
-
entt::Registry::type
static component_type type() ENTT_NOEXCEPT
Returns the numeric identifier of a type of component at runtime.
Definition: registry.hpp:278
-
entt::Registry::size
size_type size() const ENTT_NOEXCEPT
Returns the number of existing components of the given type.
Definition: registry.hpp:288
-
entt::SnapshotLoader
Utility class to restore a snapshot as a whole.
Definition: snapshot.hpp:265
-
entt::Registry::assign
Component & assign(const entity_type entity, Args &&... args)
Assigns the given component to an entity.
Definition: registry.hpp:685
-
entt::Registry::prepare
void prepare()
Prepares the internal data structures used by persistent views.
Definition: registry.hpp:1407
-
entt::RawView
Raw view.
Definition: view.hpp:1295
-
entt::Registry::move
entity_type move(const entity_type entity) ENTT_NOEXCEPT
Changes the owner of the given tag.
Definition: registry.hpp:950
+
1 #ifndef ENTT_ENTITY_REGISTRY_HPP
2 #define ENTT_ENTITY_REGISTRY_HPP
3 
4 
5 #include <tuple>
6 #include <vector>
7 #include <memory>
8 #include <utility>
9 #include <cstddef>
10 #include <numeric>
11 #include <iterator>
12 #include <algorithm>
13 #include <type_traits>
14 #include "../config/config.h"
15 #include "../core/family.hpp"
16 #include "../core/algorithm.hpp"
17 #include "../core/hashed_string.hpp"
18 #include "../core/type_traits.hpp"
19 #include "../signal/sigh.hpp"
20 #include "runtime_view.hpp"
21 #include "sparse_set.hpp"
22 #include "snapshot.hpp"
23 #include "storage.hpp"
24 #include "entity.hpp"
25 #include "group.hpp"
26 #include "view.hpp"
27 #include "fwd.hpp"
28 
29 
30 namespace entt {
31 
32 
37 template<typename... Type>
38 struct exclude_t: type_list<Type...> {};
39 
40 
45 template<typename... Type>
46 constexpr exclude_t<Type...> exclude{};
47 
48 
59 template<typename Entity>
60 class basic_registry {
61  using context_family = family<struct internal_registry_context_family>;
62  using component_family = family<struct internal_registry_component_family>;
63  using traits_type = entt_traits<Entity>;
64 
65  template<typename Component>
66  struct pool_handler: storage<Entity, Component> {
67  sigh<void(basic_registry &, const Entity, std::conditional_t<std::is_empty_v<Component>, const Component &, Component &>)> on_construct;
68  sigh<void(basic_registry &, const Entity, std::conditional_t<std::is_empty_v<Component>, const Component &, Component &>)> on_replace;
69  sigh<void(basic_registry &, const Entity)> on_destroy;
70  void *group{};
71 
72  pool_handler() ENTT_NOEXCEPT = default;
73 
74  pool_handler(const storage<Entity, Component> &other)
75  : storage<Entity, Component>{other}
76  {}
77 
78  template<typename... Args>
79  decltype(auto) assign(basic_registry &registry, const Entity entt, Args &&... args) {
80  if constexpr(std::is_empty_v<Component>) {
81  storage<Entity, Component>::construct(entt);
82  on_construct.publish(registry, entt, Component{});
83  return Component{std::forward<Args>(args)...};
84  } else {
85  auto &component = storage<Entity, Component>::construct(entt, std::forward<Args>(args)...);
86  on_construct.publish(registry, entt, component);
87  return component;
88  }
89  }
90 
91  template<typename It>
92  Component * batch(basic_registry &registry, It first, It last) {
93  Component *component = nullptr;
94 
95  if constexpr(std::is_empty_v<Component>) {
96  storage<Entity, Component>::batch(first, last);
97 
98  if(!on_construct.empty()) {
99  std::for_each(first, last, [&registry, component = Component{}, this](const auto entt) mutable {
100  on_construct.publish(registry, entt, component);
101  });
102  }
103  } else {
104  component = storage<Entity, Component>::batch(first, last);
105 
106  if(!on_construct.empty()) {
107  std::for_each(first, last, [&registry, component, this](const auto entt) mutable {
108  on_construct.publish(registry, entt, *(component++));
109  });
110  }
111  }
112 
113  return component;
114  }
115 
116  void remove(basic_registry &registry, const Entity entt) {
117  on_destroy.publish(registry, entt);
118  storage<Entity, Component>::destroy(entt);
119  }
120 
121  template<typename... Args>
122  decltype(auto) replace(basic_registry &registry, const Entity entt, Args &&... args) {
123  if constexpr(std::is_empty_v<Component>) {
124  ENTT_ASSERT((storage<Entity, Component>::has(entt)));
125  on_replace.publish(registry, entt, Component{});
126  return Component{std::forward<Args>(args)...};
127  } else {
128  Component component{std::forward<Args>(args)...};
129  on_replace.publish(registry, entt, component);
130  return (storage<Entity, Component>::get(entt) = std::move(component));
131  }
132  }
133  };
134 
135  template<typename Component>
136  using pool_type = pool_handler<std::decay_t<Component>>;
137 
138  template<typename...>
139  struct group_handler;
140 
141  template<typename... Exclude, typename... Get>
142  struct group_handler<type_list<Exclude...>, type_list<Get...>>: sparse_set<Entity> {
143  template<typename Component, typename... Args>
144  void maybe_valid_if(basic_registry &reg, const Entity entt, const Args &...) {
145  if constexpr(std::disjunction_v<std::is_same<Get, Component>...>) {
146  if(((std::is_same_v<Component, Get> || reg.pool<Get>()->has(entt)) && ...) && !(reg.pool<Exclude>()->has(entt) || ...)) {
147  this->construct(entt);
148  }
149  } else if constexpr(std::disjunction_v<std::is_same<Exclude, Component>...>) {
150  if((reg.pool<Get>()->has(entt) && ...) && ((std::is_same_v<Exclude, Component> || !reg.pool<Exclude>()->has(entt)) && ...)) {
151  this->construct(entt);
152  }
153  }
154  }
155 
156  template<typename... Args>
157  void discard_if(basic_registry &, const Entity entt, const Args &...) {
158  if(this->has(entt)) {
159  this->destroy(entt);
160  }
161  }
162  };
163 
164  template<typename... Exclude, typename... Get, typename... Owned>
165  struct group_handler<type_list<Exclude...>, type_list<Get...>, Owned...>: sparse_set<Entity> {
166  std::size_t owned{};
167 
168  template<typename Component, typename... Args>
169  void maybe_valid_if(basic_registry &reg, const Entity entt, const Args &...) {
170  const auto cpools = std::make_tuple(reg.pool<Owned>()...);
171 
172  if constexpr(std::disjunction_v<std::is_same<Owned, Component>..., std::is_same<Get, Component>...>) {
173  if(((std::is_same_v<Component, Owned> || std::get<pool_type<Owned> *>(cpools)->has(entt)) && ...)
174  && ((std::is_same_v<Component, Get> || reg.pool<Get>()->has(entt)) && ...)
175  && !(reg.pool<Exclude>()->has(entt) || ...))
176  {
177  const auto pos = this->owned++;
178  (reg.swap<Owned>(0, std::get<pool_type<Owned> *>(cpools), entt, pos), ...);
179  }
180  } else if constexpr(std::disjunction_v<std::is_same<Exclude, Component>...>) {
181  if((std::get<pool_type<Owned> *>(cpools)->has(entt) && ...)
182  && (reg.pool<Get>()->has(entt) && ...)
183  && ((std::is_same_v<Exclude, Component> || !reg.pool<Exclude>()->has(entt)) && ...))
184  {
185  const auto pos = this->owned++;
186  (reg.swap<Owned>(0, std::get<pool_type<Owned> *>(cpools), entt, pos), ...);
187  }
188  }
189  }
190 
191  template<typename... Args>
192  void discard_if(basic_registry &reg, const Entity entt, const Args &...) {
193  const auto cpools = std::make_tuple(reg.pool<Owned>()...);
194 
195  if(std::get<0>(cpools)->has(entt) && std::get<0>(cpools)->sparse_set<Entity>::get(entt) < this->owned) {
196  const auto pos = --this->owned;
197  (reg.swap<Owned>(0, std::get<pool_type<Owned> *>(cpools), entt, pos), ...);
198  }
199  }
200  };
201 
202  struct pool_data {
203  std::unique_ptr<sparse_set<Entity>> pool;
204  std::unique_ptr<sparse_set<Entity>> (* clone)(const sparse_set<Entity> &);
205  void (* remove)(basic_registry &, const Entity);
206  ENTT_ID_TYPE runtime_type;
207  };
208 
209  struct group_data {
210  const std::size_t extent[3];
211  std::unique_ptr<void, void(*)(void *)> group;
212  bool(* const is_same)(const ENTT_ID_TYPE *);
213  };
214 
215  struct ctx_variable {
216  std::unique_ptr<void, void(*)(void *)> value;
217  ENTT_ID_TYPE runtime_type;
218  };
219 
220  template<typename Type, typename Family>
221  static ENTT_ID_TYPE runtime_type() ENTT_NOEXCEPT {
222  if constexpr(is_named_type_v<Type>) {
223  return named_type_traits<Type>::value;
224  } else {
225  return Family::template type<Type>;
226  }
227  }
228 
229  void release(const Entity entity) {
230  // lengthens the implicit list of destroyed entities
231  const auto entt = entity & traits_type::entity_mask;
232  const auto version = ((entity >> traits_type::entity_shift) + 1) << traits_type::entity_shift;
233  const auto node = (available ? next : ((entt + 1) & traits_type::entity_mask)) | version;
234  entities[entt] = node;
235  next = entt;
236  ++available;
237  }
238 
239  template<typename Component>
240  inline auto swap(int, pool_type<Component> *cpool, const Entity entt, const std::size_t pos)
241  -> decltype(std::swap(cpool->get(entt), cpool->raw()[pos]), void()) {
242  std::swap(cpool->get(entt), cpool->raw()[pos]);
243  cpool->swap(cpool->sparse_set<Entity>::get(entt), pos);
244  }
245 
246  template<typename Component>
247  inline void swap(char, pool_type<Component> *cpool, const Entity entt, const std::size_t pos) {
248  cpool->swap(cpool->sparse_set<Entity>::get(entt), pos);
249  }
250 
251  template<typename Component>
252  inline const auto * pool() const ENTT_NOEXCEPT {
253  const auto ctype = type<Component>();
254 
255  if constexpr(is_named_type_v<Component>) {
256  const auto it = std::find_if(pools.begin()+skip_family_pools, pools.end(), [ctype](const auto &candidate) {
257  return candidate.runtime_type == ctype;
258  });
259 
260  return it == pools.cend() ? nullptr : static_cast<const pool_type<Component> *>(it->pool.get());
261  } else {
262  return ctype < skip_family_pools ? static_cast<const pool_type<Component> *>(pools[ctype].pool.get()) : nullptr;
263  }
264  }
265 
266  template<typename Component>
267  inline auto * pool() ENTT_NOEXCEPT {
268  return const_cast<pool_type<Component> *>(std::as_const(*this).template pool<Component>());
269  }
270 
271  template<typename Component>
272  auto * assure() {
273  const auto ctype = type<Component>();
274  pool_data *pdata = nullptr;
275 
276  if constexpr(is_named_type_v<Component>) {
277  const auto it = std::find_if(pools.begin()+skip_family_pools, pools.end(), [ctype](const auto &candidate) {
278  return candidate.runtime_type == ctype;
279  });
280 
281  pdata = (it == pools.cend() ? &pools.emplace_back() : &(*it));
282  } else {
283  if(!(ctype < skip_family_pools)) {
284  pools.reserve(pools.size()+ctype-skip_family_pools+1);
285 
286  while(!(ctype < skip_family_pools)) {
287  pools.emplace(pools.begin()+(skip_family_pools++), pool_data{});
288  }
289  }
290 
291  pdata = &pools[ctype];
292  }
293 
294  if(!pdata->pool) {
295  pdata->runtime_type = ctype;
296  pdata->pool = std::make_unique<pool_type<Component>>();
297 
298  pdata->clone = +[](const sparse_set<Entity> &other) -> std::unique_ptr<sparse_set<Entity>> {
299  if constexpr(std::is_copy_constructible_v<std::decay_t<Component>>) {
300  return std::make_unique<pool_type<Component>>(static_cast<const pool_type<Component> &>(other));
301  } else {
302  return nullptr;
303  }
304  };
305 
306  pdata->remove = +[](basic_registry &registry, const Entity entt) {
307  registry.pool<Component>()->remove(registry, entt);
308  };
309  }
310 
311  return static_cast<pool_type<Component> *>(pdata->pool.get());
312  }
313 
314 public:
316  using entity_type = typename traits_type::entity_type;
318  using version_type = typename traits_type::version_type;
320  using size_type = typename sparse_set<Entity>::size_type;
322  using component_type = ENTT_ID_TYPE;
323 
325  basic_registry() ENTT_NOEXCEPT = default;
326 
328  basic_registry(basic_registry &&) = default;
329 
331  basic_registry & operator=(basic_registry &&) = default;
332 
343  template<typename Component>
344  inline static component_type type() ENTT_NOEXCEPT {
345  return runtime_type<Component, component_family>();
346  }
347 
353  template<typename Component>
354  size_type size() const ENTT_NOEXCEPT {
355  const auto *cpool = pool<Component>();
356  return cpool ? cpool->size() : size_type{};
357  }
358 
363  size_type size() const ENTT_NOEXCEPT {
364  return entities.size();
365  }
366 
371  size_type alive() const ENTT_NOEXCEPT {
372  return entities.size() - available;
373  }
374 
384  template<typename Component>
385  void reserve(const size_type cap) {
386  assure<Component>()->reserve(cap);
387  }
388 
397  void reserve(const size_type cap) {
398  entities.reserve(cap);
399  }
400 
406  template<typename Component>
407  size_type capacity() const ENTT_NOEXCEPT {
408  const auto *cpool = pool<Component>();
409  return cpool ? cpool->capacity() : size_type{};
410  }
411 
417  size_type capacity() const ENTT_NOEXCEPT {
418  return entities.capacity();
419  }
420 
425  template<typename Component>
426  void shrink_to_fit() {
427  assure<Component>()->shrink_to_fit();
428  }
429 
436  template<typename Component>
437  bool empty() const ENTT_NOEXCEPT {
438  const auto *cpool = pool<Component>();
439  return cpool ? cpool->empty() : true;
440  }
441 
446  bool empty() const ENTT_NOEXCEPT {
447  return entities.size() == available;
448  }
449 
468  template<typename Component>
469  const Component * raw() const ENTT_NOEXCEPT {
470  const auto *cpool = pool<Component>();
471  return cpool ? cpool->raw() : nullptr;
472  }
473 
475  template<typename Component>
476  inline Component * raw() ENTT_NOEXCEPT {
477  return const_cast<Component *>(std::as_const(*this).template raw<Component>());
478  }
479 
493  template<typename Component>
494  const entity_type * data() const ENTT_NOEXCEPT {
495  const auto *cpool = pool<Component>();
496  return cpool ? cpool->data() : nullptr;
497  }
498 
504  bool valid(const entity_type entity) const ENTT_NOEXCEPT {
505  const auto pos = size_type(entity & traits_type::entity_mask);
506  return (pos < entities.size() && entities[pos] == entity);
507  }
508 
514  static entity_type entity(const entity_type entity) ENTT_NOEXCEPT {
515  return entity & traits_type::entity_mask;
516  }
517 
523  static version_type version(const entity_type entity) ENTT_NOEXCEPT {
524  return version_type(entity >> traits_type::entity_shift);
525  }
526 
540  version_type current(const entity_type entity) const ENTT_NOEXCEPT {
541  const auto pos = size_type(entity & traits_type::entity_mask);
542  ENTT_ASSERT(pos < entities.size());
543  return version_type(entities[pos] >> traits_type::entity_shift);
544  }
545 
568  template<typename... Component>
569  decltype(auto) create() {
570  entity_type entity;
571 
572  if(available) {
573  const auto entt = next;
574  const auto version = entities[entt] & (traits_type::version_mask << traits_type::entity_shift);
575  next = entities[entt] & traits_type::entity_mask;
576  entity = entt | version;
577  entities[entt] = entity;
578  --available;
579  } else {
580  entity = entities.emplace_back(entity_type(entities.size()));
581  // traits_type::entity_mask is reserved to allow for null identifiers
582  ENTT_ASSERT(entity < traits_type::entity_mask);
583  }
584 
585  if constexpr(sizeof...(Component) == 0) {
586  return entity;
587  } else {
588  return std::tuple<entity_type, decltype(assign<Component>(entity))...>{entity, assign<Component>(entity)...};
589  }
590  }
591 
605  template<typename... Component, typename It>
606  auto create(It first, It last) {
607  static_assert(std::is_convertible_v<entity_type, typename std::iterator_traits<It>::value_type>);
608  const auto length = size_type(std::distance(first, last));
609  const auto sz = std::min(available, length);
610  [[maybe_unused]] entity_type candidate{};
611 
612  available -= sz;
613 
614  const auto tail = std::generate_n(first, sz, [&candidate, this]() mutable {
615  if constexpr(sizeof...(Component) > 0) {
616  candidate = std::max(candidate, next);
617  } else {
618  // suppress warnings
619  (void)candidate;
620  }
621 
622  const auto entt = next;
623  const auto version = entities[entt] & (traits_type::version_mask << traits_type::entity_shift);
624  next = entities[entt] & traits_type::entity_mask;
625  return (entities[entt] = entt | version);
626  });
627 
628  std::generate(tail, last, [this]() {
629  return entities.emplace_back(entity_type(entities.size()));
630  });
631 
632  if constexpr(sizeof...(Component) > 0) {
633  return std::make_tuple(assure<Component>()->batch(*this, first, last)...);
634  }
635  }
636 
659  void destroy(const entity_type entity) {
660  ENTT_ASSERT(valid(entity));
661 
662  for(auto pos = pools.size(); pos; --pos) {
663  if(auto &pdata = pools[pos-1]; pdata.pool && pdata.pool->has(entity)) {
664  pdata.remove(*this, entity);
665  }
666  };
667 
668  // just a way to protect users from listeners that attach components
669  ENTT_ASSERT(orphan(entity));
670  release(entity);
671  }
672 
679  template<typename It>
680  void destroy(It first, It last) {
681  ENTT_ASSERT(std::all_of(first, last, [this](const auto entity) { return valid(entity); }));
682 
683  for(auto pos = pools.size(); pos; --pos) {
684  if(auto &pdata = pools[pos-1]; pdata.pool) {
685  std::for_each(first, last, [&pdata, this](const auto entity) {
686  if(pdata.pool->has(entity)) {
687  pdata.remove(*this, entity);
688  }
689  });
690  }
691  };
692 
693  // just a way to protect users from listeners that attach components
694  ENTT_ASSERT(std::all_of(first, last, [this](const auto entity) { return orphan(entity); }));
695 
696  std::for_each(first, last, [this](const auto entity) {
697  release(entity);
698  });
699  }
700 
721  template<typename Component, typename... Args>
722  decltype(auto) assign(const entity_type entity, [[maybe_unused]] Args &&... args) {
723  ENTT_ASSERT(valid(entity));
724  return assure<Component>()->assign(*this, entity, std::forward<Args>(args)...);
725  }
726 
740  template<typename Component>
741  void remove(const entity_type entity) {
742  ENTT_ASSERT(valid(entity));
743  pool<Component>()->remove(*this, entity);
744  }
745 
758  template<typename... Component>
759  bool has(const entity_type entity) const ENTT_NOEXCEPT {
760  ENTT_ASSERT(valid(entity));
761  [[maybe_unused]] const auto cpools = std::make_tuple(pool<Component>()...);
762  return ((std::get<const pool_type<Component> *>(cpools) ? std::get<const pool_type<Component> *>(cpools)->has(entity) : false) && ...);
763  }
764 
779  template<typename... Component>
780  decltype(auto) get([[maybe_unused]] const entity_type entity) const ENTT_NOEXCEPT {
781  ENTT_ASSERT(valid(entity));
782 
783  if constexpr(sizeof...(Component) == 1) {
784  return (pool<Component>()->get(entity), ...);
785  } else {
786  return std::tuple<decltype(get<Component>(entity))...>{get<Component>(entity)...};
787  }
788  }
789 
791  template<typename... Component>
792  inline decltype(auto) get([[maybe_unused]] const entity_type entity) ENTT_NOEXCEPT {
793  ENTT_ASSERT(valid(entity));
794 
795  if constexpr(sizeof...(Component) == 1) {
796  return (pool<Component>()->get(entity), ...);
797  } else {
798  return std::tuple<decltype(get<Component>(entity))...>{get<Component>(entity)...};
799  }
800  }
801 
826  template<typename Component, typename... Args>
827  decltype(auto) get_or_assign(const entity_type entity, Args &&... args) ENTT_NOEXCEPT {
828  ENTT_ASSERT(valid(entity));
829  auto *cpool = assure<Component>();
830  return cpool->has(entity) ? cpool->get(entity) : cpool->assign(*this, entity, std::forward<Args>(args)...);
831  }
832 
845  template<typename... Component>
846  auto try_get([[maybe_unused]] const entity_type entity) const ENTT_NOEXCEPT {
847  ENTT_ASSERT(valid(entity));
848 
849  if constexpr(sizeof...(Component) == 1) {
850  const auto cpools = std::make_tuple(pool<Component>()...);
851  return ((std::get<const pool_type<Component> *>(cpools) ? std::get<const pool_type<Component> *>(cpools)->try_get(entity) : nullptr), ...);
852  } else {
853  return std::tuple<std::add_const_t<Component> *...>{try_get<Component>(entity)...};
854  }
855  }
856 
858  template<typename... Component>
859  inline auto try_get([[maybe_unused]] const entity_type entity) ENTT_NOEXCEPT {
860  if constexpr(sizeof...(Component) == 1) {
861  return (const_cast<Component *>(std::as_const(*this).template try_get<Component>(entity)), ...);
862  } else {
863  return std::tuple<Component *...>{try_get<Component>(entity)...};
864  }
865  }
866 
887  template<typename Component, typename... Args>
888  decltype(auto) replace(const entity_type entity, Args &&... args) {
889  ENTT_ASSERT(valid(entity));
890  return pool<Component>()->replace(*this, entity, std::forward<Args>(args)...);
891  }
892 
915  template<typename Component, typename... Args>
916  decltype(auto) assign_or_replace(const entity_type entity, Args &&... args) {
917  ENTT_ASSERT(valid(entity));
918  auto *cpool = assure<Component>();
919  return cpool->has(entity) ? cpool->replace(*this, entity, std::forward<Args>(args)...) : cpool->assign(*this, entity, std::forward<Args>(args)...);
920  }
921 
949  template<typename Component>
950  auto on_construct() ENTT_NOEXCEPT {
951  return assure<Component>()->on_construct.sink();
952  }
953 
980  template<typename Component>
981  auto on_replace() ENTT_NOEXCEPT {
982  return assure<Component>()->on_replace.sink();
983  }
984 
1012  template<typename Component>
1013  auto on_destroy() ENTT_NOEXCEPT {
1014  return assure<Component>()->on_destroy.sink();
1015  }
1016 
1064  template<typename Component, typename Compare, typename Sort = std_sort, typename... Args>
1065  void sort(Compare compare, Sort algo = Sort{}, Args &&... args) {
1066  ENTT_ASSERT(!owned<Component>());
1067  assure<Component>()->sort(std::move(compare), std::move(algo), std::forward<Args>(args)...);
1068  }
1069 
1105  template<typename To, typename From>
1106  void sort() {
1107  ENTT_ASSERT(!owned<To>());
1108  assure<To>()->respect(*assure<From>());
1109  }
1110 
1125  template<typename Component>
1126  void reset(const entity_type entity) {
1127  ENTT_ASSERT(valid(entity));
1128 
1129  if(auto *cpool = assure<Component>(); cpool->has(entity)) {
1130  cpool->remove(*this, entity);
1131  }
1132  }
1133 
1142  template<typename Component>
1143  void reset() {
1144  if(auto *cpool = assure<Component>(); cpool->on_destroy.empty()) {
1145  // no group set, otherwise the signal wouldn't be empty
1146  cpool->reset();
1147  } else {
1148  for(const auto entity: static_cast<const sparse_set<entity_type> &>(*cpool)) {
1149  cpool->remove(*this, entity);
1150  }
1151  }
1152  }
1153 
1162  void reset() {
1163  each([this](const auto entity) {
1164  // useless this-> used to suppress a warning with clang
1165  this->destroy(entity);
1166  });
1167  }
1168 
1186  template<typename Func>
1187  void each(Func func) const {
1188  static_assert(std::is_invocable_v<Func, entity_type>);
1189 
1190  if(available) {
1191  for(auto pos = entities.size(); pos; --pos) {
1192  const auto curr = entity_type(pos - 1);
1193  const auto entity = entities[curr];
1194  const auto entt = entity & traits_type::entity_mask;
1195 
1196  if(curr == entt) {
1197  func(entity);
1198  }
1199  }
1200  } else {
1201  for(auto pos = entities.size(); pos; --pos) {
1202  func(entities[pos-1]);
1203  }
1204  }
1205  }
1206 
1212  bool orphan(const entity_type entity) const {
1213  ENTT_ASSERT(valid(entity));
1214  bool orphan = true;
1215 
1216  for(std::size_t i = {}, last = pools.size(); i < last && orphan; ++i) {
1217  const auto &pdata = pools[i];
1218  orphan = !(pdata.pool && pdata.pool->has(entity));
1219  }
1220 
1221  return orphan;
1222  }
1223 
1240  template<typename Func>
1241  void orphans(Func func) const {
1242  static_assert(std::is_invocable_v<Func, entity_type>);
1243 
1244  each([&func, this](const auto entity) {
1245  if(orphan(entity)) {
1246  func(entity);
1247  }
1248  });
1249  }
1250 
1282  template<typename... Component>
1283  entt::basic_view<Entity, Component...> view() {
1284  return { assure<Component>()... };
1285  }
1286 
1288  template<typename... Component>
1289  inline entt::basic_view<Entity, Component...> view() const {
1290  static_assert(std::conjunction_v<std::is_const<Component>...>);
1291  return const_cast<basic_registry *>(this)->view<Component...>();
1292  }
1293 
1299  template<typename Component>
1300  bool owned() const ENTT_NOEXCEPT {
1301  const auto *cpool = pool<Component>();
1302  return cpool && cpool->group;
1303  }
1304 
1332  template<typename... Owned, typename... Get, typename... Exclude>
1333  inline entt::basic_group<Entity, get_t<Get...>, Owned...> group(get_t<Get...>, exclude_t<Exclude...> = {}) {
1334  static_assert(sizeof...(Owned) + sizeof...(Get) > 0);
1335  static_assert(sizeof...(Owned) + sizeof...(Get) + sizeof...(Exclude) > 1);
1336 
1337  using handler_type = group_handler<type_list<Exclude...>, type_list<Get...>, Owned...>;
1338 
1339  const std::size_t extent[] = { sizeof...(Owned), sizeof...(Get), sizeof...(Exclude) };
1340  const ENTT_ID_TYPE types[] = { type<Owned>()..., type<Get>()..., type<Exclude>()... };
1341  handler_type *curr = nullptr;
1342 
1343  if(auto it = std::find_if(groups.begin(), groups.end(), [&extent, &types](auto &&gdata) {
1344  return std::equal(std::begin(extent), std::end(extent), gdata.extent) && gdata.is_same(types);
1345  }); it != groups.cend())
1346  {
1347  curr = static_cast<handler_type *>(it->group.get());
1348  }
1349 
1350  if(!curr) {
1351  ENTT_ASSERT(!(owned<Owned>() || ...));
1352 
1353  groups.push_back(group_data{
1354  { sizeof...(Owned), sizeof...(Get), sizeof...(Exclude) },
1355  decltype(group_data::group){new handler_type{}, +[](void *gptr) { delete static_cast<handler_type *>(gptr); }},
1356  +[](const ENTT_ID_TYPE *other) {
1357  const std::size_t ctypes[] = { type<Owned>()..., type<Get>()..., type<Exclude>()... };
1358  return std::equal(std::begin(ctypes), std::end(ctypes), other);
1359  }
1360  });
1361 
1362  const auto cpools = std::make_tuple(assure<Owned>()..., assure<Get>()..., assure<Exclude>()...);
1363  curr = static_cast<handler_type *>(groups.back().group.get());
1364 
1365  ((std::get<pool_type<Owned> *>(cpools)->group = curr), ...);
1366  (std::get<pool_type<Owned> *>(cpools)->on_construct.sink().template connect<&handler_type::template maybe_valid_if<Owned, Owned>>(curr), ...);
1367  (std::get<pool_type<Owned> *>(cpools)->on_destroy.sink().template connect<&handler_type::template discard_if<>>(curr), ...);
1368 
1369  (std::get<pool_type<Get> *>(cpools)->on_construct.sink().template connect<&handler_type::template maybe_valid_if<Get, Get>>(curr), ...);
1370  (std::get<pool_type<Get> *>(cpools)->on_destroy.sink().template connect<&handler_type::template discard_if<>>(curr), ...);
1371 
1372  (std::get<pool_type<Exclude> *>(cpools)->on_destroy.sink().template connect<&handler_type::template maybe_valid_if<Exclude>>(curr), ...);
1373  (std::get<pool_type<Exclude> *>(cpools)->on_construct.sink().template connect<&handler_type::template discard_if<Exclude>>(curr), ...);
1374 
1375  const auto *cpool = std::min({
1376  static_cast<sparse_set<Entity> *>(std::get<pool_type<Owned> *>(cpools))...,
1377  static_cast<sparse_set<Entity> *>(std::get<pool_type<Get> *>(cpools))...
1378  }, [](const auto *lhs, const auto *rhs) {
1379  return lhs->size() < rhs->size();
1380  });
1381 
1382  // we cannot iterate backwards because we want to leave behind valid entities in case of owned types
1383  std::for_each(cpool->data(), cpool->data() + cpool->size(), [curr, &cpools, this](const auto entity) {
1384  if((std::get<pool_type<Owned> *>(cpools)->has(entity) && ...)
1385  && (std::get<pool_type<Get> *>(cpools)->has(entity) && ...)
1386  && !(std::get<pool_type<Exclude> *>(cpools)->has(entity) || ...))
1387  {
1388  if constexpr(sizeof...(Owned) == 0) {
1389  curr->construct(entity);
1390  // suppress warnings
1391  (void)this;
1392  } else {
1393  const auto pos = curr->owned++;
1394  // useless this-> used to suppress a warning with clang
1395  (this->swap<Owned>(0, std::get<pool_type<Owned> *>(cpools), entity, pos), ...);
1396  }
1397  }
1398  });
1399  }
1400 
1401  if constexpr(sizeof...(Owned) == 0) {
1402  return { static_cast<sparse_set<Entity> *>(curr), pool<Get>()... };
1403  } else {
1404  return { &curr->owned, pool<Owned>()... , pool<Get>()... };
1405  }
1406  }
1407 
1409  template<typename... Owned, typename... Get, typename... Exclude>
1410  inline entt::basic_group<Entity, get_t<Get...>, Owned...> group(get_t<Get...>, exclude_t<Exclude...> = {}) const {
1411  static_assert(std::conjunction_v<std::is_const<Owned>..., std::is_const<Get>...>);
1412  return const_cast<basic_registry *>(this)->group<Owned...>(entt::get<Get...>, exclude<Exclude...>);
1413  }
1414 
1416  template<typename... Owned, typename... Exclude>
1417  inline entt::basic_group<Entity, get_t<>, Owned...> group(exclude_t<Exclude...> = {}) {
1418  return group<Owned...>(entt::get<>, exclude<Exclude...>);
1419  }
1420 
1422  template<typename... Owned, typename... Exclude>
1423  inline entt::basic_group<Entity, get_t<>, Owned...> group(exclude_t<Exclude...> = {}) const {
1424  static_assert(std::conjunction_v<std::is_const<Owned>...>);
1425  return const_cast<basic_registry *>(this)->group<Owned...>(exclude<Exclude...>);
1426  }
1427 
1448  template<typename It>
1449  entt::basic_runtime_view<Entity> runtime_view(It first, It last) const {
1450  static_assert(std::is_convertible_v<typename std::iterator_traits<It>::value_type, component_type>);
1451  std::vector<const sparse_set<Entity> *> set(std::distance(first, last));
1452 
1453  std::transform(first, last, set.begin(), [this](const component_type ctype) {
1454  auto it = std::find_if(pools.begin(), pools.end(), [ctype](const auto &pdata) {
1455  return pdata.pool && pdata.runtime_type == ctype;
1456  });
1457 
1458  return it != pools.cend() && it->pool ? it->pool.get() : nullptr;
1459  });
1460 
1461  return { std::move(set) };
1462  }
1463 
1492  template<typename... Component>
1493  basic_registry clone() const {
1494  static_assert(std::conjunction_v<std::is_copy_constructible<Component>...>);
1495  basic_registry other;
1496 
1497  other.pools.resize(pools.size());
1498 
1499  for(auto pos = pools.size(); pos; --pos) {
1500  if(auto &pdata = pools[pos-1]; pdata.pool && (!sizeof...(Component) || ... || (pdata.runtime_type == type<Component>()))) {
1501  auto &curr = other.pools[pos-1];
1502  curr.clone = pdata.clone;
1503  curr.pool = curr.clone(*pdata.pool);
1504  curr.runtime_type = pdata.runtime_type;
1505  ENTT_ASSERT(sizeof...(Component) == 0 || curr.pool);
1506  }
1507  }
1508 
1509  other.skip_family_pools = skip_family_pools;
1510  other.entities = entities;
1511  other.available = available;
1512  other.next = next;
1513 
1514  other.pools.erase(std::remove_if(other.pools.begin()+skip_family_pools, other.pools.end(), [](const auto &pdata) {
1515  return !pdata.pool;
1516  }), other.pools.end());
1517 
1518  return other;
1519  }
1520 
1531  entt::basic_snapshot<Entity> snapshot() const ENTT_NOEXCEPT {
1532  using follow_fn_type = entity_type(const basic_registry &, const entity_type);
1533  const entity_type seed = available ? (next | (entities[next] & (traits_type::version_mask << traits_type::entity_shift))) : next;
1534 
1535  follow_fn_type *follow = [](const basic_registry &reg, const entity_type entity) -> entity_type {
1536  const auto &others = reg.entities;
1537  const auto entt = entity & traits_type::entity_mask;
1538  const auto curr = others[entt] & traits_type::entity_mask;
1539  return (curr | (others[curr] & (traits_type::version_mask << traits_type::entity_shift)));
1540  };
1541 
1542  return { this, seed, follow };
1543  }
1544 
1560  basic_snapshot_loader<Entity> loader() ENTT_NOEXCEPT {
1561  using force_fn_type = void(basic_registry &, const entity_type, const bool);
1562 
1563  force_fn_type *force = [](basic_registry &reg, const entity_type entity, const bool destroyed) {
1564  using promotion_type = std::conditional_t<sizeof(size_type) >= sizeof(entity_type), size_type, entity_type>;
1565  // explicit promotion to avoid warnings with std::uint16_t
1566  const auto entt = promotion_type{entity} & traits_type::entity_mask;
1567  auto &others = reg.entities;
1568 
1569  if(!(entt < others.size())) {
1570  auto curr = others.size();
1571  others.resize(entt + 1);
1572  std::iota(others.data() + curr, others.data() + entt, entity_type(curr));
1573  }
1574 
1575  others[entt] = entity;
1576 
1577  if(destroyed) {
1578  reg.destroy(entity);
1579  const auto version = entity & (traits_type::version_mask << traits_type::entity_shift);
1580  others[entt] = ((others[entt] & traits_type::entity_mask) | version);
1581  }
1582  };
1583 
1584  reset();
1585  entities.clear();
1586  available = {};
1587 
1588  return { this, force };
1589  }
1590 
1602  template<typename Type, typename... Args>
1603  Type & set(Args &&... args) {
1604  const auto ctype = runtime_type<Type, context_family>();
1605  auto it = std::find_if(vars.begin(), vars.end(), [ctype](const auto &candidate) {
1606  return candidate.runtime_type == ctype;
1607  });
1608 
1609  if(it == vars.cend()) {
1610  vars.push_back({
1611  decltype(ctx_variable::value){new Type{std::forward<Args>(args)...}, +[](void *ptr) { delete static_cast<Type *>(ptr); }},
1612  ctype
1613  });
1614 
1615  it = std::prev(vars.end());
1616  } else {
1617  it->value.reset(new Type{std::forward<Args>(args)...});
1618  }
1619 
1620  return *static_cast<Type *>(it->value.get());
1621  }
1622 
1627  template<typename Type>
1628  void unset() {
1629  vars.erase(std::remove_if(vars.begin(), vars.end(), [](auto &var) {
1630  return var.runtime_type == runtime_type<Type, context_family>();
1631  }), vars.end());
1632  }
1633 
1640  template<typename Type>
1641  const Type * try_ctx() const ENTT_NOEXCEPT {
1642  const auto it = std::find_if(vars.begin(), vars.end(), [](const auto &var) {
1643  return var.runtime_type == runtime_type<Type, context_family>();
1644  });
1645 
1646  return (it == vars.cend()) ? nullptr : static_cast<const Type *>(it->value.get());
1647  }
1648 
1650  template<typename Type>
1651  inline Type * try_ctx() ENTT_NOEXCEPT {
1652  return const_cast<Type *>(std::as_const(*this).template try_ctx<Type>());
1653  }
1654 
1667  template<typename Type>
1668  const Type & ctx() const ENTT_NOEXCEPT {
1669  const auto *instance = try_ctx<Type>();
1670  ENTT_ASSERT(instance);
1671  return *instance;
1672  }
1673 
1675  template<typename Type>
1676  inline Type & ctx() ENTT_NOEXCEPT {
1677  return const_cast<Type &>(std::as_const(*this).template ctx<Type>());
1678  }
1679 
1680 private:
1681  std::size_t skip_family_pools{};
1682  std::vector<pool_data> pools;
1683  std::vector<group_data> groups;
1684  std::vector<ctx_variable> vars;
1685  std::vector<entity_type> entities;
1686  size_type available{};
1687  entity_type next{};
1688 };
1689 
1690 
1691 }
1692 
1693 
1694 #endif // ENTT_ENTITY_REGISTRY_HPP
entt::basic_registry::orphan
bool orphan(const entity_type entity) const
Checks if an entity has components assigned.
Definition: registry.hpp:1212
+
entt::basic_registry::orphans
void orphans(Func func) const
Iterates orphans and applies them the given function object.
Definition: registry.hpp:1241
+
entt::basic_registry::owned
bool owned() const ENTT_NOEXCEPT
Checks whether a given component belongs to a group.
Definition: registry.hpp:1300
+
entt::basic_storage::batch
object_type * batch(It first, It last)
Assigns one or more entities to a storage and constructs their objects.
Definition: storage.hpp:352
+
entt::basic_registry::current
version_type current(const entity_type entity) const ENTT_NOEXCEPT
Returns the actual version for an entity identifier.
Definition: registry.hpp:540
+
entt::basic_registry::reset
void reset()
Resets the pool of the given component.
Definition: registry.hpp:1143
+
entt::sparse_set
Basic sparse set implementation.
Definition: sparse_set.hpp:46
+
entt::basic_registry::size_type
typename sparse_set< Entity >::size_type size_type
Unsigned integer type.
Definition: registry.hpp:320
+
entt::basic_group
Group.
Definition: fwd.hpp:25
+
entt::sparse_set::size
size_type size() const ENTT_NOEXCEPT
Returns the number of elements in a sparse set.
Definition: sparse_set.hpp:284
+
entt::basic_storage::construct
object_type & construct(const entity_type entt, Args &&... args)
Assigns an entity to a storage and constructs its object.
Definition: storage.hpp:321
+
entt::basic_registry::on_replace
auto on_replace() ENTT_NOEXCEPT
Returns a sink object for the given component.
Definition: registry.hpp:981
+
entt::basic_registry::version
static version_type version(const entity_type entity) ENTT_NOEXCEPT
Returns the version stored along with an entity identifier.
Definition: registry.hpp:523
+
entt::basic_registry::reserve
void reserve(const size_type cap)
Increases the capacity of the pool for the given component.
Definition: registry.hpp:385
+
entt::basic_registry::destroy
void destroy(const entity_type entity)
Destroys an entity and lets the registry recycle the identifier.
Definition: registry.hpp:659
+
entt::basic_registry::data
const entity_type * data() const ENTT_NOEXCEPT
Direct access to the list of entities of a given pool.
Definition: registry.hpp:494
+
entt::basic_registry::on_destroy
auto on_destroy() ENTT_NOEXCEPT
Returns a sink object for the given component.
Definition: registry.hpp:1013
+
entt::basic_registry::reset
void reset(const entity_type entity)
Resets the given component for an entity.
Definition: registry.hpp:1126
entt
EnTT default namespace.
Definition: algorithm.hpp:10
-
entt::Registry::destroy
void destroy(Type...)
Destroys the entities that own the given components, if any.
Definition: registry.hpp:629
-
entt::Snapshot
Utility class to create snapshots from a registry.
Definition: snapshot.hpp:38
-
entt::Registry::empty
bool empty() const ENTT_NOEXCEPT
Checks if there exists at least an entity still in use.
Definition: registry.hpp:369
-
entt::Registry::has
bool has(const entity_type entity) const ENTT_NOEXCEPT
Checks if an entity has all the given components.
Definition: registry.hpp:761
-
entt::Registry::destruction
sink_type destruction(tag_t) ENTT_NOEXCEPT
Returns a sink object for the given tag.
Definition: registry.hpp:1085
-
entt::Registry::destroy
void destroy(tag_t)
Destroys the entity that owns the given tag, if any.
Definition: registry.hpp:556
-
entt::Registry::replace
Tag & replace(tag_t, Args &&... args)
Replaces the given tag.
Definition: registry.hpp:904
-
entt::disconnect
void disconnect(Sink< void(Registry< Entity > &, const Entity)> sink)
Disconnects a dependency function from the given sink.
Definition: helper.hpp:78
-
entt::Registry::Registry
Registry()=default
Default constructor.
-
entt::SparseSet
Sparse set.
Definition: sparse_set.hpp:29
-
entt::Registry::construction
sink_type construction() ENTT_NOEXCEPT
Returns a sink object for the given component.
Definition: registry.hpp:1056
-
entt::Registry::contains
bool contains() const ENTT_NOEXCEPT
Checks if a persistent view has already been prepared.
Definition: registry.hpp:1455
-
entt::Registry::type
static tag_type type(tag_t) ENTT_NOEXCEPT
Returns the numeric identifier of a type of tag at runtime.
Definition: registry.hpp:261
-
entt::null
constexpr auto null
Null entity.
Definition: entity.hpp:78
-
entt::Registry::raw
const Component * raw() const ENTT_NOEXCEPT
Direct access to the list of components of a given pool.
Definition: registry.hpp:388
-
entt::Registry::version
version_type version(const entity_type entity) const ENTT_NOEXCEPT
Returns the version stored along with an entity identifier.
Definition: registry.hpp:477
-
entt::Registry::version_type
typename traits_type::version_type version_type
Underlying version type.
Definition: registry.hpp:225
-
entt::Registry::reset
void reset()
Resets a whole registry.
Definition: registry.hpp:1254
-
entt::SparseSet< Entity >
Basic sparse set implementation.
Definition: sparse_set.hpp:60
-
entt::Family::type
static family_type type() ENTT_NOEXCEPT
Returns an unique identifier for the given type.
Definition: family.hpp:40
-
entt::Registry::create
entity_type create()
Creates a new entity and returns it.
Definition: registry.hpp:521
-
entt::Registry::empty
bool empty() const ENTT_NOEXCEPT
Checks whether the pool of the given component is empty.
Definition: registry.hpp:361
-
entt::Registry::view
View< Entity, Component... > view()
Returns a standard view for the given components.
Definition: registry.hpp:1386
-
entt::Registry::current
version_type current(const entity_type entity) const ENTT_NOEXCEPT
Returns the actual version for an entity identifier.
Definition: registry.hpp:498
-
entt::Attachee
Attachee.
Definition: attachee.hpp:22
-
entt::Registry::reserve
void reserve(const size_type cap)
Increases the capacity of the pool for the given component.
Definition: registry.hpp:318
-
entt::Registry::view
PersistentView< Entity, Component... > view(persistent_t)
Returns a persistent view for the given components.
Definition: registry.hpp:1501
-
entt::Registry::raw
Component * raw() ENTT_NOEXCEPT
Direct access to the list of components of a given pool.
Definition: registry.hpp:407
-
entt::Registry::construction
sink_type construction(tag_t) ENTT_NOEXCEPT
Returns a sink object for the given tag.
Definition: registry.hpp:1027
-
entt::Registry::view
RawView< Entity, Component > view(raw_t)
Returns a raw view for the given component.
Definition: registry.hpp:1531
-
entt::Registry::operator=
Registry & operator=(const Registry &)=delete
Copying a registry isn&#39;t allowed.
-
entt::Registry::size_type
std::size_t size_type
Unsigned integer type.
Definition: registry.hpp:227
-
entt::Registry::sort
void sort()
Sorts two pools of components in the same way.
Definition: registry.hpp:1197
-
entt::Registry::data
const entity_type * data() const ENTT_NOEXCEPT
Direct access to the list of entities of a given pool.
Definition: registry.hpp:426
-
entt::Registry::restore
SnapshotLoader< Entity > restore() ENTT_NOEXCEPT
Returns a temporary object to use to load snapshots.
Definition: registry.hpp:1613
-
entt::Registry::valid
bool valid(const entity_type entity) const ENTT_NOEXCEPT
Checks if an entity identifier refers to a valid entity.
Definition: registry.hpp:435
-
entt::Registry::component_type
typename component_family::family_type component_type
Unsigned integer type.
Definition: registry.hpp:231
-
entt::Registry::entity
entity_type entity(const entity_type entity) const ENTT_NOEXCEPT
Returns the entity identifier without the version.
Definition: registry.hpp:468
-
entt::connect
void connect(Sink< void(Registry< Entity > &, const Entity)> sink)
Connects a dependency function to the given sink.
Definition: helper.hpp:55
-
entt::Registry::assign
Tag & assign(tag_t, const entity_type entity, Args &&... args)
Attaches the given tag to an entity.
Definition: registry.hpp:657
-
entt::Registry::entity_type
typename traits_type::entity_type entity_type
Underlying entity identifier.
Definition: registry.hpp:223
-
entt::View
Multi component view.
Definition: view.hpp:466
-
entt::StdSort
Function object to wrap std::sort in a class type.
Definition: algorithm.hpp:21
-
entt::PersistentView
Persistent view.
Definition: view.hpp:71
- -
entt::Family::family_type
std::size_t family_type
Unsigned integer type.
Definition: family.hpp:33
-
entt::Registry::view
RuntimeView< Entity > view(It first, It last)
Returns a runtime view for the given components.
Definition: registry.hpp:1563
-
entt::Registry::capacity
size_type capacity() const ENTT_NOEXCEPT
Returns the number of entities that a registry has currently allocated space for. ...
Definition: registry.hpp:350
-
entt::Registry::fast
bool fast(const entity_type entity) const ENTT_NOEXCEPT
Checks if an entity identifier refers to a valid entity.
Definition: registry.hpp:457
-
entt::Family
Dynamic identifier generator.
Definition: family.hpp:22
-
entt::Registry::reset
void reset(const entity_type entity)
Resets the given component for an entity.
Definition: registry.hpp:1218
-
entt::tag_t
Tag class type used to disambiguate overloads.
Definition: utility.hpp:9
-
entt::Registry::replace
Component & replace(const entity_type entity, Args &&... args)
Replaces the given component for an entity.
Definition: registry.hpp:929
-
entt::Registry::capacity
size_type capacity() const ENTT_NOEXCEPT
Returns the capacity of the pool for the given component.
Definition: registry.hpp:341
-
entt::Registry::snapshot
Snapshot< Entity > snapshot() const ENTT_NOEXCEPT
Returns a temporary object to use to create snapshots.
Definition: registry.hpp:1584
-
entt::Registry::tag_type
typename tag_family::family_type tag_type
Unsigned integer type.
Definition: registry.hpp:229
-
entt::Registry::has
bool has(tag_t, const entity_type entity) const ENTT_NOEXCEPT
Checks if an entity owns the given tag.
Definition: registry.hpp:744
-
entt::Registry::attachee
entity_type attachee() const ENTT_NOEXCEPT
Gets the owner of the given tag, if any.
Definition: registry.hpp:963
-
entt::Registry::orphan
bool orphan(const entity_type entity) const
Checks if an entity is an orphan.
Definition: registry.hpp:1309
-
entt::RuntimeView
Runtime view.
Definition: view.hpp:1590
-
entt::entt_traits
Entity traits.
Definition: entt_traits.hpp:18
-
entt::Registry::reserve
void reserve(const size_type cap)
Increases the capacity of a registry in terms of entities.
Definition: registry.hpp:331
+
entt::basic_registry::ctx
Type & ctx() ENTT_NOEXCEPT
Returns a reference to an object in the context of the registry.
Definition: registry.hpp:1676
+
entt::basic_registry::entity
static entity_type entity(const entity_type entity) ENTT_NOEXCEPT
Returns the entity identifier without the version.
Definition: registry.hpp:514
+
entt::sparse_set::size_type
std::size_t size_type
Unsigned integer type.
Definition: sparse_set.hpp:176
+
entt::exclude
constexpr exclude_t< Type... > exclude
Variable template for exclusion lists.
Definition: registry.hpp:46
+
entt::basic_registry::group
entt::basic_group< Entity, get_t<>, Owned... > group(exclude_t< Exclude... >={}) const
Returns a group for the given components.
Definition: registry.hpp:1423
+
entt::basic_registry::view
entt::basic_view< Entity, Component... > view()
Returns a view for the given components.
Definition: registry.hpp:1283
+
entt::basic_registry::alive
size_type alive() const ENTT_NOEXCEPT
Returns the number of entities still in use.
Definition: registry.hpp:371
+
entt::basic_registry::shrink_to_fit
void shrink_to_fit()
Requests the removal of unused capacity for a given component.
Definition: registry.hpp:426
+
entt::basic_registry::snapshot
entt::basic_snapshot< Entity > snapshot() const ENTT_NOEXCEPT
Returns a temporary object to use to create snapshots.
Definition: registry.hpp:1531
+
entt::storage
Basic storage implementation.
Definition: storage.hpp:692
+
entt::basic_registry::destroy
void destroy(It first, It last)
Destroys all the entities in a range.
Definition: registry.hpp:680
+
entt::named_type_traits
Traits class used mainly to push things across boundaries.
Definition: type_traits.hpp:99
+
entt::basic_registry::size
size_type size() const ENTT_NOEXCEPT
Returns the number of entities created so far.
Definition: registry.hpp:363
+
entt::family
Dynamic identifier generator.
Definition: family.hpp:20
+
entt::basic_snapshot_loader
Utility class to restore a snapshot as a whole.
Definition: fwd.hpp:41
+
entt::basic_registry::on_construct
auto on_construct() ENTT_NOEXCEPT
Returns a sink object for the given component.
Definition: registry.hpp:950
+
entt::basic_registry::component_type
ENTT_ID_TYPE component_type
Unsigned integer type.
Definition: registry.hpp:322
+
entt::basic_registry::valid
bool valid(const entity_type entity) const ENTT_NOEXCEPT
Checks if an entity identifier refers to a valid entity.
Definition: registry.hpp:504
+
entt::basic_registry
Fast and reliable entity-component system.
Definition: fwd.hpp:13
+
entt::basic_view
Multi component view.
Definition: fwd.hpp:17
+
entt::basic_registry::capacity
size_type capacity() const ENTT_NOEXCEPT
Returns the capacity of the pool for the given component.
Definition: registry.hpp:407
+
entt::basic_registry::each
void each(Func func) const
Iterates all the entities that are still in use.
Definition: registry.hpp:1187
+
entt::basic_registry::loader
basic_snapshot_loader< Entity > loader() ENTT_NOEXCEPT
Returns a temporary object to use to load snapshots.
Definition: registry.hpp:1560
+
entt::basic_registry::entity_type
typename traits_type::entity_type entity_type
Underlying entity identifier.
Definition: registry.hpp:316
+
entt::basic_registry::raw
const Component * raw() const ENTT_NOEXCEPT
Direct access to the list of components of a given pool.
Definition: registry.hpp:469
+
entt::type_list
A class to use to push around lists of types, nothing more.
Definition: type_traits.hpp:17
+
entt::basic_registry::try_get
auto try_get([[maybe_unused]] const entity_type entity) const ENTT_NOEXCEPT
Returns pointers to the given components for an entity.
Definition: registry.hpp:846
+
entt::basic_registry::create
auto create(It first, It last)
Assigns each element in a range an entity.
Definition: registry.hpp:606
+
entt::basic_storage::destroy
void destroy(const entity_type entt) override
Removes an entity from a storage and destroys its object.
Definition: storage.hpp:372
+
entt::std_sort
Function object to wrap std::sort in a class type.
Definition: algorithm.hpp:21
+
entt::basic_registry::ctx
const Type & ctx() const ENTT_NOEXCEPT
Returns a reference to an object in the context of the registry.
Definition: registry.hpp:1668
+
entt::registry
basic_registry< entity > registry
Alias declaration for the most common use case.
Definition: fwd.hpp:51
+
entt::basic_registry::version_type
typename traits_type::version_type version_type
Underlying version type.
Definition: registry.hpp:318
+
entt::basic_registry::group
entt::basic_group< Entity, get_t< Get... >, Owned... > group(get_t< Get... >, exclude_t< Exclude... >={}) const
Returns a group for the given components.
Definition: registry.hpp:1410
+
entt::basic_registry::reset
void reset()
Resets a whole registry.
Definition: registry.hpp:1162
+
entt::basic_registry::group
entt::basic_group< Entity, get_t<>, Owned... > group(exclude_t< Exclude... >={})
Returns a group for the given components.
Definition: registry.hpp:1417
+
entt::exclude_t
Alias for exclusion lists.
Definition: registry.hpp:38
+
entt::basic_registry::sort
void sort()
Sorts two pools of components in the same way.
Definition: registry.hpp:1106
+
entt::basic_registry::try_ctx
const Type * try_ctx() const ENTT_NOEXCEPT
Returns a pointer to an object in the context of the registry.
Definition: registry.hpp:1641
+
entt::get
constexpr get_t< Type... > get
Variable template for lists of observed components.
Definition: group.hpp:31
+
entt::basic_registry::runtime_view
entt::basic_runtime_view< Entity > runtime_view(It first, It last) const
Returns a runtime view for the given components.
Definition: registry.hpp:1449
+
entt::basic_registry::capacity
size_type capacity() const ENTT_NOEXCEPT
Returns the number of entities that a registry has currently allocated space for. ...
Definition: registry.hpp:417
+
entt::basic_registry::raw
Component * raw() ENTT_NOEXCEPT
Direct access to the list of components of a given pool.
Definition: registry.hpp:476
+
entt::basic_registry::reserve
void reserve(const size_type cap)
Increases the capacity of a registry in terms of entities.
Definition: registry.hpp:397
+
entt::get_t
Alias for lists of observed components.
Definition: group.hpp:23
+
entt::sigh
Unmanaged signal handler declaration.
Definition: fwd.hpp:21
+
entt::basic_registry::group
entt::basic_group< Entity, get_t< Get... >, Owned... > group(get_t< Get... >, exclude_t< Exclude... >={})
Returns a group for the given components.
Definition: registry.hpp:1333
+
entt::entity
std::uint32_t entity
Alias declaration for the most common use case.
Definition: fwd.hpp:48
+
entt::basic_registry::view
entt::basic_view< Entity, Component... > view() const
Returns a view for the given components.
Definition: registry.hpp:1289
+
entt::group
basic_group< entity, Types... > group
Alias declaration for the most common use case.
Definition: fwd.hpp:83
+
entt::basic_registry::try_get
auto try_get([[maybe_unused]] const entity_type entity) ENTT_NOEXCEPT
Returns pointers to the given components for an entity.
Definition: registry.hpp:859
+
entt::basic_registry::clone
basic_registry clone() const
Clones the given components and all the entity identifiers.
Definition: registry.hpp:1493
+
entt::basic_snapshot
Utility class to create snapshots from a registry.
Definition: fwd.hpp:37
+
entt::basic_registry::sort
void sort(Compare compare, Sort algo=Sort{}, Args &&... args)
Sorts the pool of entities for the given component.
Definition: registry.hpp:1065
+
entt::basic_registry::unset
void unset()
Unsets a context variable if it exists.
Definition: registry.hpp:1628
+
entt::basic_registry::empty
bool empty() const ENTT_NOEXCEPT
Checks whether the pool of a given component is empty.
Definition: registry.hpp:437
+
entt::entt_traits
Entity traits.
Definition: entity.hpp:18
+
entt::basic_runtime_view
Runtime view.
Definition: fwd.hpp:21
+
entt::basic_registry::empty
bool empty() const ENTT_NOEXCEPT
Checks if there exists at least an entity still in use.
Definition: registry.hpp:446
+
entt::basic_registry::has
bool has(const entity_type entity) const ENTT_NOEXCEPT
Checks if an entity has all the given components.
Definition: registry.hpp:759
+
entt::basic_registry::size
size_type size() const ENTT_NOEXCEPT
Returns the number of existing components of the given type.
Definition: registry.hpp:354
+
entt::basic_registry::try_ctx
Type * try_ctx() ENTT_NOEXCEPT
Returns a pointer to an object in the context of the registry.
Definition: registry.hpp:1651
diff --git a/resource_2fwd_8hpp_source.html b/resource_2fwd_8hpp_source.html new file mode 100644 index 000000000..b66f12308 --- /dev/null +++ b/resource_2fwd_8hpp_source.html @@ -0,0 +1,81 @@ + + + + + + + +EnTT: src/entt/resource/fwd.hpp Source File + + + + + + + + + +
+
+
bool entt::Process< Derived, Delta >::rejected bool entt::process< Derived, Delta >::rejected ( ) const - + @@ -419,8 +419,8 @@ template<typename Derived, typename Delta> - -

◆ tick()

+ +

◆ tick()

@@ -431,7 +431,7 @@ template<typename Derived, typename Delta>
@@ -59,33 +59,157 @@ $(function() {
-
Here is a list of all documented namespace members with links to the namespaces they belong to:
    +
    Here is a list of all documented namespace members with links to the namespaces they belong to:
    + +

    - a -

      +
    • actor +: entt +
      • +
    • as_group() +: entt +
      • +
    • as_view() +: entt +
      • +
    + + +

    - c -

    • connect() -: entt +: entt
      • -
    • DefaultActor -: entt +
    • connect_arg +: entt
      • -
    • DefaultPrototype -: entt +
    • continuous_loader +: entt
      • -
    • DefaultRegistry -: entt +
    + + +

    - d -

    + + +

    - e -

    + + +

    - g -

    + + +

    - i -

      +
    • is_named_type_v +: entt +
      • +
    + + +

    - m -

      +
    • monostate_v +: entt +
      • +
    + + +

    - n -

      +
    • named_type_traits_t +: entt
    • null : entt
      • +
    + + +

    - o -

    + + +

    - p -

      +
    • prototype +: entt +
      • +
    + + +

    - r -

      +
    • reflect() +: entt +
      • +
    • registry +: entt +
      • +
    • resolve() +: entt +
      • +
    • runtime_view +: entt +
      • +
    + + +

    - s -

      +
    • snapshot +: entt +
      • +
    • snapshot_loader +: entt +
      • +
    + + +

    - t -

      +
    • tag +: entt +
      • +
    • type_list_cat_t +: entt +
      • +
    • type_list_unique_t +: entt +
      • +
    + + +

    - u -

      +
    • unregister() +: entt +
      • +
    + + +

    - v -

diff --git a/namespacemembers_func.html b/namespacemembers_func.html index 865b10680..1e7ab8cfd 100644 --- a/namespacemembers_func.html +++ b/namespacemembers_func.html @@ -22,7 +22,7 @@ @@ -60,17 +60,38 @@ $(function() {
 
diff --git a/namespacemembers_type.html b/namespacemembers_type.html index ca0c95816..7fd5f958c 100644 --- a/namespacemembers_type.html +++ b/namespacemembers_type.html @@ -22,7 +22,7 @@ @@ -60,17 +60,47 @@ $(function() {
 
    -
  • DefaultActor -: entt +
  • actor +: entt
    • -
  • DefaultPrototype -: entt +
  • continuous_loader +: entt
    • -
  • DefaultRegistry -: entt +
  • entity +: entt
    • -
  • label -: entt +
  • group +: entt +
    • +
  • named_type_traits_t +: entt +
    • +
  • prototype +: entt +
    • +
  • registry +: entt +
    • +
  • runtime_view +: entt +
    • +
  • snapshot +: entt +
    • +
  • snapshot_loader +: entt +
    • +
  • tag +: entt +
    • +
  • type_list_cat_t +: entt +
    • +
  • type_list_unique_t +: entt +
    • +
  • view +: entt
diff --git a/namespacemembers_vars.html b/namespacemembers_vars.html index 825b4ac05..b34cb132b 100644 --- a/namespacemembers_vars.html +++ b/namespacemembers_vars.html @@ -22,7 +22,7 @@ @@ -60,6 +60,21 @@ $(function() {
 
    +
  • connect_arg +: entt +
    • +
  • exclude +: entt +
    • +
  • get +: entt +
    • +
  • is_named_type_v +: entt +
    • +
  • monostate_v +: entt +
  • null : entt
    • diff --git a/namespaces.html b/namespaces.html index 1be943837..1f9488a9c 100644 --- a/namespaces.html +++ b/namespaces.html @@ -22,7 +22,7 @@
diff --git a/pages.html b/pages.html index 81b7cabaa..569e0c50c 100644 --- a/pages.html +++ b/pages.html @@ -22,7 +22,7 @@ @@ -68,11 +68,14 @@ $(function() { - - - - - + + + + + + + +
void entt::Process< Derived, Delta >::succeed void entt::process< Derived, Delta >::succeed ( ) - + @@ -468,8 +468,8 @@ template<typename Derived, typename Delta> - -

◆ unpause()

+ +

◆ unpause()

@@ -480,7 +480,7 @@ template<typename Derived, typename Delta>
@@ -59,89 +59,82 @@ $(function() {
Public Types | Public Member Functions | -List of all members
+List of all members
-
entt::ResourceCache< Resource > Class Template Reference
+
entt::resource_cache< Resource > Class Template Reference

Simple cache for resources of a given type. - More...

+ More...

#include <cache.hpp>

void entt::Process< Derived, Delta >::tick void entt::process< Derived, Delta >::tick ( const Delta  delta, - + diff --git a/classentt_1_1resource__cache-members.html b/classentt_1_1resource__cache-members.html new file mode 100644 index 000000000..1b2ed74fb --- /dev/null +++ b/classentt_1_1resource__cache-members.html @@ -0,0 +1,95 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
+
+
void entt::Process< Derived, Delta >::unpause void entt::process< Derived, Delta >::unpause ( )
+ + + + + +
+
EnTT +  3.0.0 +
+
+ + + + + + + + + +
+
+ + +
+ +
+ + + +
+
+
entt::resource_cache< Resource > Member List
+
+
+ +

This is the complete list of members for entt::resource_cache< Resource >, including all inherited members.

+ + + + + + + + + + + + + + + +
clear() ENTT_NOEXCEPTentt::resource_cache< Resource >inline
contains(const resource_type id) const ENTT_NOEXCEPTentt::resource_cache< Resource >inline
discard(const resource_type id) ENTT_NOEXCEPTentt::resource_cache< Resource >inline
empty() const ENTT_NOEXCEPTentt::resource_cache< Resource >inline
handle(const resource_type id) constentt::resource_cache< Resource >inline
load(const resource_type id, Args &&... args)entt::resource_cache< Resource >inline
operator=(resource_cache &&)=defaultentt::resource_cache< Resource >
reload(const resource_type id, Args &&... args)entt::resource_cache< Resource >inline
resource_cache()=defaultentt::resource_cache< Resource >
resource_cache(resource_cache &&)=defaultentt::resource_cache< Resource >
resource_type typedefentt::resource_cache< Resource >
size() const ENTT_NOEXCEPTentt::resource_cache< Resource >inline
size_type typedefentt::resource_cache< Resource >
temp(Args &&... args) constentt::resource_cache< Resource >inline
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1ResourceCache.html b/classentt_1_1resource__cache.html similarity index 54% rename from classentt_1_1ResourceCache.html rename to classentt_1_1resource__cache.html index f06006ba6..03baa9463 100644 --- a/classentt_1_1ResourceCache.html +++ b/classentt_1_1resource__cache.html @@ -5,7 +5,7 @@ -EnTT: entt::ResourceCache< Resource > Class Template Reference +EnTT: entt::resource_cache< Resource > Class Template Reference @@ -22,7 +22,7 @@
EnTT -  2.7.3 +  3.0.0
- - - - - - + + + + + +

Public Types

-using size_type = typename container_type::size_type
 Unsigned integer type.
 
-using resource_type = HashedString
 Type of resources managed by a cache.
 
+using size_type = typename container_type::size_type
 Unsigned integer type.
 
+using resource_type = typename hashed_string::hash_type
 Type of resources managed by a cache.
 
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Public Member Functions

- ResourceCache ()=default
 Default constructor.
 
- ResourceCache (const ResourceCache &) ENTT_NOEXCEPT=delete
 Copying a cache isn't allowed.
 
- ResourceCache (ResourceCache &&) ENTT_NOEXCEPT=default
 Default move constructor.
 
ResourceCache & operator= (const ResourceCache &) ENTT_NOEXCEPT=delete
 Copying a cache isn't allowed. More...
 
ResourceCache & operator= (ResourceCache &&) ENTT_NOEXCEPT=default
 Default move assignment operator. More...
 
size_type size () const ENTT_NOEXCEPT
 Number of resources managed by a cache. More...
 
bool empty () const ENTT_NOEXCEPT
 Returns true if a cache contains no resources, false otherwise. More...
 
void clear () ENTT_NOEXCEPT
 Clears a cache and discards all its resources. More...
 
template<typename Loader , typename... Args>
bool load (const resource_type id, Args &&... args)
 Loads the resource that corresponds to a given identifier. More...
 
template<typename Loader , typename... Args>
bool reload (const resource_type id, Args &&... args)
 Reloads a resource or loads it for the first time if not present. More...
 
template<typename Loader , typename... Args>
ResourceHandle< Resource > temp (Args &&... args) const
 Creates a temporary handle for a resource. More...
 
ResourceHandle< Resource > handle (const resource_type id) const
 Creates a handle for a given resource identifier. More...
 
bool contains (const resource_type id) const ENTT_NOEXCEPT
 Checks if a cache contains a given identifier. More...
 
void discard (const resource_type id) ENTT_NOEXCEPT
 Discards the resource that corresponds to a given identifier. More...
 
+ resource_cache ()=default
 Default constructor.
 
+ resource_cache (resource_cache &&)=default
 Default move constructor.
 
resource_cache & operator= (resource_cache &&)=default
 Default move assignment operator. More...
 
size_type size () const ENTT_NOEXCEPT
 Number of resources managed by a cache. More...
 
bool empty () const ENTT_NOEXCEPT
 Returns true if a cache contains no resources, false otherwise. More...
 
void clear () ENTT_NOEXCEPT
 Clears a cache and discards all its resources. More...
 
template<typename Loader , typename... Args>
resource_handle< Resource > load (const resource_type id, Args &&... args)
 Loads the resource that corresponds to a given identifier. More...
 
template<typename Loader , typename... Args>
resource_handle< Resource > reload (const resource_type id, Args &&... args)
 Reloads a resource or loads it for the first time if not present. More...
 
template<typename Loader , typename... Args>
resource_handle< Resource > temp (Args &&... args) const
 Creates a temporary handle for a resource. More...
 
resource_handle< Resource > handle (const resource_type id) const
 Creates a handle for a given resource identifier. More...
 
bool contains (const resource_type id) const ENTT_NOEXCEPT
 Checks if a cache contains a given identifier. More...
 
void discard (const resource_type id) ENTT_NOEXCEPT
 Discards the resource that corresponds to a given identifier. More...
 

Detailed Description

template<typename Resource>
-class entt::ResourceCache< Resource >

+class entt::resource_cache< Resource >

Simple cache for resources of a given type.

Minimal implementation of a cache for resources of a given type. It doesn't offer much functionalities but it's suitable for small or medium sized applications and can be freely inherited to add targeted functionalities for large sized applications.

@@ -152,21 +145,21 @@ class entt::ResourceCache< Resource > -

Definition at line 29 of file cache.hpp.

+

Definition at line 30 of file cache.hpp.

Member Function Documentation

- -

◆ clear()

+ +

◆ clear()

-template<typename Resource >
+template<typename Resource>
- + - + @@ -531,12 +1004,12 @@ template<typename... Dependency, typename Entity >
Returns
True if the two hashed strings are identical, false otherwise.
-

Definition at line 103 of file hashed_string.hpp.

+

Definition at line 195 of file hashed_string.hpp.

- -

◆ operator!=() [2/3]

+ +

◆ operator!=() [2/11]

@@ -546,13 +1019,13 @@ template<typename Ret , typename... Args>
- + - + @@ -563,8 +1036,8 @@ template<typename Ret , typename... Args>
- + @@ -182,25 +175,25 @@ template<typename Resource >

Clears a cache and discards all its resources.

Handles are not invalidated and the memory used by a resource isn't freed as long as at least a handle keeps the resource itself alive.

-

Definition at line 73 of file cache.hpp.

+

Definition at line 70 of file cache.hpp.

- -

◆ contains()

+ +

◆ contains()

-template<typename Resource >
+template<typename Resource>
void entt::ResourceCache< Resource >::clear void entt::resource_cache< Resource >::clear ( )
@@ -67,9 +67,10 @@ $(function() {
monostate.hpp
-
1 #ifndef ENTT_CORE_MONOSTATE_HPP
2 #define ENTT_CORE_MONOSTATE_HPP
3 
4 
5 #include <atomic>
6 #include <cassert>
7 #include "family.hpp"
8 #include "hashed_string.hpp"
9 
10 
11 namespace entt {
12 
13 
25 template<HashedString::hash_type>
26 struct Monostate {
32  template<typename Type>
33  void operator=(Type val) const ENTT_NOEXCEPT {
34  Monostate::value<Type> = val;
35  }
36 
42  template<typename Type>
43  operator Type() const ENTT_NOEXCEPT {
44  return Monostate::value<Type>;
45  }
46 
47 private:
48  template<typename Type>
49  static std::atomic<Type> value;
50 };
51 
52 
53 template<HashedString::hash_type ID>
54 template<typename Type>
55 std::atomic<Type> Monostate<ID>::value{};
56 
57 
58 }
59 
60 
61 #endif // ENTT_CORE_MONOSTATE_HPP
entt::Monostate::operator=
void operator=(Type val) const ENTT_NOEXCEPT
Assigns a value of a specific type to a given key.
Definition: monostate.hpp:33
-
entt::Monostate
Minimal implementation of the monostate pattern.
Definition: monostate.hpp:26
+
1 #ifndef ENTT_CORE_MONOSTATE_HPP
2 #define ENTT_CORE_MONOSTATE_HPP
3 
4 
5 #include <cassert>
6 #include "../config/config.h"
7 #include "hashed_string.hpp"
8 
9 
10 namespace entt {
11 
12 
24 template<hashed_string::hash_type>
25 struct monostate {
31  template<typename Type>
32  void operator=(Type val) const ENTT_NOEXCEPT {
33  value<Type> = val;
34  }
35 
41  template<typename Type>
42  operator Type() const ENTT_NOEXCEPT {
43  return value<Type>;
44  }
45 
46 private:
47  template<typename Type>
48  inline static maybe_atomic_t<Type> value{};
49 };
50 
51 
56 template<hashed_string::hash_type Value>
57 inline monostate<Value> monostate_v = {};
58 
59 
60 }
61 
62 
63 #endif // ENTT_CORE_MONOSTATE_HPP
entt::monostate_v
monostate< Value > monostate_v
Helper variable template.
Definition: monostate.hpp:57
entt
EnTT default namespace.
Definition: algorithm.hpp:10
+
entt::monostate::operator=
void operator=(Type val) const ENTT_NOEXCEPT
Assigns a value of a specific type to a given key.
Definition: monostate.hpp:32
+
entt::monostate
Minimal implementation of the monostate pattern.
Definition: monostate.hpp:25
diff --git a/namespaceentt.html b/namespaceentt.html index 57500d07f..1ef976501 100644 --- a/namespaceentt.html +++ b/namespaceentt.html @@ -22,7 +22,7 @@
@@ -74,32 +74,68 @@ $(function() {
- + - + @@ -221,25 +214,25 @@ template<typename Resource >
Returns
True if the cache contains the resource, false otherwise.
-

Definition at line 173 of file cache.hpp.

+

Definition at line 181 of file cache.hpp.

- -

◆ discard()

+ +

◆ discard()

-template<typename Resource >
+template<typename Resource>
bool entt::ResourceCache< Resource >::contains bool entt::resource_cache< Resource >::contains (const resource_type const resource_type  id) const
@@ -67,9 +67,8 @@ $(function() {
loader.hpp
-
1 #ifndef ENTT_RESOURCE_LOADER_HPP
2 #define ENTT_RESOURCE_LOADER_HPP
3 
4 
5 #include <memory>
6 
7 
8 namespace entt {
9 
10 
11 template<typename Resource>
12 class ResourceCache;
13 
14 
47 template<typename Loader, typename Resource>
48 class ResourceLoader {
50  friend class ResourceCache<Resource>;
51 
52  template<typename... Args>
53  std::shared_ptr<Resource> get(Args &&... args) const {
54  return static_cast<const Loader *>(this)->load(std::forward<Args>(args)...);
55  }
56 };
57 
58 
59 }
60 
61 
62 #endif // ENTT_RESOURCE_LOADER_HPP
entt
EnTT default namespace.
Definition: algorithm.hpp:10
-
entt::ResourceLoader
Base class for resource loaders.
Definition: loader.hpp:48
-
entt::ResourceCache
Simple cache for resources of a given type.
Definition: cache.hpp:29
+
1 #ifndef ENTT_RESOURCE_LOADER_HPP
2 #define ENTT_RESOURCE_LOADER_HPP
3 
4 
5 #include <memory>
6 #include "fwd.hpp"
7 
8 
9 namespace entt {
10 
11 
44 template<typename Loader, typename Resource>
45 class resource_loader {
47  friend class resource_cache<Resource>;
48 
55  template<typename... Args>
56  std::shared_ptr<Resource> get(Args &&... args) const {
57  return static_cast<const Loader *>(this)->load(std::forward<Args>(args)...);
58  }
59 };
60 
61 
62 }
63 
64 
65 #endif // ENTT_RESOURCE_LOADER_HPP
entt::resource_cache
Simple cache for resources of a given type.
Definition: cache.hpp:30
+
entt
EnTT default namespace.
Definition: algorithm.hpp:10
diff --git a/locator_8hpp_source.html b/locator_8hpp_source.html index 9b44e940e..258a2aa66 100644 --- a/locator_8hpp_source.html +++ b/locator_8hpp_source.html @@ -22,7 +22,7 @@
@@ -67,14 +67,14 @@ $(function() {
locator.hpp
-
1 #ifndef ENTT_LOCATOR_LOCATOR_HPP
2 #define ENTT_LOCATOR_LOCATOR_HPP
3 
4 
5 #include <memory>
6 #include <utility>
7 #include <cassert>
8 #include "../config/config.h"
9 
10 
11 namespace entt {
12 
13 
25 template<typename Service>
26 struct ServiceLocator final {
28  using service_type = Service;
29 
31  ServiceLocator() = delete;
33  ~ServiceLocator() = delete;
34 
39  inline static bool empty() ENTT_NOEXCEPT {
40  return !static_cast<bool>(service);
41  }
42 
53  inline static std::weak_ptr<Service> get() ENTT_NOEXCEPT {
54  return service;
55  }
56 
71  inline static Service & ref() ENTT_NOEXCEPT {
72  return *service;
73  }
74 
81  template<typename Impl = Service, typename... Args>
82  inline static void set(Args &&... args) {
83  service = std::make_shared<Impl>(std::forward<Args>(args)...);
84  }
85 
90  inline static void set(std::shared_ptr<Service> ptr) {
91  assert(static_cast<bool>(ptr));
92  service = std::move(ptr);
93  }
94 
100  inline static void reset() {
101  service.reset();
102  }
103 
104 private:
105  static std::shared_ptr<Service> service;
106 };
107 
108 
109 template<typename Service>
110 std::shared_ptr<Service> ServiceLocator<Service>::service{};
111 
112 
113 }
114 
115 
116 #endif // ENTT_LOCATOR_LOCATOR_HPP
entt::ServiceLocator::empty
static bool empty() ENTT_NOEXCEPT
Tests if a valid service implementation is set.
Definition: locator.hpp:39
-
entt::ServiceLocator::reset
static void reset()
Resets a service.
Definition: locator.hpp:100
+
1 #ifndef ENTT_LOCATOR_LOCATOR_HPP
2 #define ENTT_LOCATOR_LOCATOR_HPP
3 
4 
5 #include <memory>
6 #include <utility>
7 #include "../config/config.h"
8 
9 
10 namespace entt {
11 
12 
24 template<typename Service>
25 struct service_locator {
27  using service_type = Service;
28 
30  service_locator() = delete;
32  ~service_locator() = delete;
33 
38  inline static bool empty() ENTT_NOEXCEPT {
39  return !static_cast<bool>(service);
40  }
41 
52  inline static std::weak_ptr<Service> get() ENTT_NOEXCEPT {
53  return service;
54  }
55 
70  inline static Service & ref() ENTT_NOEXCEPT {
71  return *service;
72  }
73 
80  template<typename Impl = Service, typename... Args>
81  inline static void set(Args &&... args) {
82  service = std::make_shared<Impl>(std::forward<Args>(args)...);
83  }
84 
89  inline static void set(std::shared_ptr<Service> ptr) {
90  ENTT_ASSERT(static_cast<bool>(ptr));
91  service = std::move(ptr);
92  }
93 
99  inline static void reset() {
100  service.reset();
101  }
102 
103 private:
104  inline static std::shared_ptr<Service> service = nullptr;
105 };
106 
107 
108 }
109 
110 
111 #endif // ENTT_LOCATOR_LOCATOR_HPP
entt::service_locator::~service_locator
~service_locator()=delete
Default destructor, deleted on purpose.
+
entt::service_locator::ref
static Service & ref() ENTT_NOEXCEPT
Returns a weak reference to a service implementation, if any.
Definition: locator.hpp:70
entt
EnTT default namespace.
Definition: algorithm.hpp:10
-
entt::ServiceLocator::~ServiceLocator
~ServiceLocator()=delete
Default destructor, deleted on purpose.
-
entt::ServiceLocator::ref
static Service & ref() ENTT_NOEXCEPT
Returns a weak reference to a service implementation, if any.
Definition: locator.hpp:71
-
entt::ServiceLocator::ServiceLocator
ServiceLocator()=delete
Default constructor, deleted on purpose.
-
entt::ServiceLocator::service_type
Service service_type
Type of service offered.
Definition: locator.hpp:28
-
entt::ServiceLocator
Service locator, nothing more.
Definition: locator.hpp:26
+
entt::service_locator
Service locator, nothing more.
Definition: locator.hpp:25
+
entt::service_locator::service_type
Service service_type
Type of service offered.
Definition: locator.hpp:27
+
entt::service_locator::reset
static void reset()
Resets a service.
Definition: locator.hpp:99
+
entt::service_locator::service_locator
service_locator()=delete
Default constructor, deleted on purpose.
+
entt::service_locator::empty
static bool empty() ENTT_NOEXCEPT
Tests if a valid service implementation is set.
Definition: locator.hpp:38
diff --git a/locator_8md_source.html b/locator_8md_source.html index 7554cba75..1a1dca001 100644 --- a/locator_8md_source.html +++ b/locator_8md_source.html @@ -5,7 +5,7 @@ -EnTT: docs/locator.md Source File +EnTT: docs/md/locator.md Source File @@ -22,7 +22,7 @@
@@ -60,10 +60,10 @@ $(function() {
-
docs/locator.md
+
docs/md/locator.md
-
1 # Crash Course: service locator
2 
3 <!--
4 @cond TURN_OFF_DOXYGEN
5 -->
6 # Table of Contents
7 
8 * [Introduction](#introduction)
9 * [Service locator](#service-locator)
10 <!--
11 @endcond TURN_OFF_DOXYGEN
12 -->
13 
14 # Introduction
15 
16 Usually service locators are tightly bound to the services they expose and it's
17 hard to define a general purpose solution. This template based implementation
18 tries to fill the gap and to get rid of the burden of defining a different
19 specific locator for each application.<br/>
20 This class is tiny, partially unsafe and thus risky to use. Moreover it doesn't
21 fit probably most of the scenarios in which a service locator is required. Look
22 at it as a small tool that can sometimes be useful if users know how to handle
23 it.
24 
25 # Service locator
26 
27 The API is straightforward. The basic idea is that services are implemented by
28 means of interfaces and rely on polymorphism.<br/>
29 The locator is instantiated with the base type of the service if any and a
30 concrete implementation is provided along with all the parameters required to
31 initialize it. As an example:
32 
33 ```cpp
34 // the service has no base type, a locator is used to treat it as a kind of singleton
35 entt::ServiceLocator<MyService>::set(params...);
36 
37 // sets up an opaque service
38 entt::ServiceLocator<AudioInterface>::set<AudioImplementation>(params...);
39 
40 // resets (destroys) the service
41 entt::ServiceLocator<AudioInterface>::reset();
42 ```
43 
44 The locator can also be queried to know if an active service is currently set
45 and to retrieve it if necessary (either as a pointer or as a reference):
46 
47 ```cpp
48 // no service currently set
49 auto empty = entt::ServiceLocator<AudioInterface>::empty();
50 
51 // gets a (possibly empty) shared pointer to the service ...
52 std::shared_ptr<AudioInterface> ptr = entt::ServiceLocator<AudioInterface>::get();
53 
54 // ... or a reference, but it's undefined behaviour if the service isn't set yet
55 AudioInterface &ref = entt::ServiceLocator<AudioInterface>::ref();
56 ```
57 
58 A common use is to wrap the different locators in a container class, creating
59 aliases for the various services:
60 
61 ```cpp
62 struct Locator {
63  using Camera = entt::ServiceLocator<CameraInterface>;
64  using Audio = entt::ServiceLocator<AudioInterface>;
65  // ...
66 };
67 
68 // ...
69 
70 void init() {
71  Locator::Camera::set<CameraNull>();
72  Locator::Audio::set<AudioImplementation>(params...);
73  // ...
74 }
75 ```
+
1 # Crash Course: service locator
2 
3 <!--
4 @cond TURN_OFF_DOXYGEN
5 -->
6 # Table of Contents
7 
8 * [Introduction](#introduction)
9 * [Service locator](#service-locator)
10 <!--
11 @endcond TURN_OFF_DOXYGEN
12 -->
13 
14 # Introduction
15 
16 Usually service locators are tightly bound to the services they expose and it's
17 hard to define a general purpose solution. This template based implementation
18 tries to fill the gap and to get rid of the burden of defining a different
19 specific locator for each application.<br/>
20 This class is tiny, partially unsafe and thus risky to use. Moreover it doesn't
21 fit probably most of the scenarios in which a service locator is required. Look
22 at it as a small tool that can sometimes be useful if users know how to handle
23 it.
24 
25 # Service locator
26 
27 The API is straightforward. The basic idea is that services are implemented by
28 means of interfaces and rely on polymorphism.<br/>
29 The locator is instantiated with the base type of the service if any and a
30 concrete implementation is provided along with all the parameters required to
31 initialize it. As an example:
32 
33 ```cpp
34 // the service has no base type, a locator is used to treat it as a kind of singleton
35 entt::service_locator<my_service>::set(params...);
36 
37 // sets up an opaque service
38 entt::service_locator<audio_interface>::set<audio_implementation>(params...);
39 
40 // resets (destroys) the service
41 entt::service_locator<audio_interface>::reset();
42 ```
43 
44 The locator can also be queried to know if an active service is currently set
45 and to retrieve it if necessary (either as a pointer or as a reference):
46 
47 ```cpp
48 // no service currently set
49 auto empty = entt::service_locator<audio_interface>::empty();
50 
51 // gets a (possibly empty) shared pointer to the service ...
52 std::shared_ptr<audio_interface> ptr = entt::service_locator<audio_interface>::get();
53 
54 // ... or a reference, but it's undefined behaviour if the service isn't set yet
55 audio_interface &ref = entt::service_locator<audio_interface>::ref();
56 ```
57 
58 A common use is to wrap the different locators in a container class, creating
59 aliases for the various services:
60 
61 ```cpp
62 struct locator {
63  using camera = entt::service_locator<camera_interface>;
64  using audio = entt::service_locator<audio_interface>;
65  // ...
66 };
67 
68 // ...
69 
70 void init() {
71  locator::camera::set<camera_null>();
72  locator::audio::set<audio_implementation>(params...);
73  // ...
74 }
75 ```
Generated by   diff --git a/menudata.js b/menudata.js index f1bfe6713..346b93afb 100644 --- a/menudata.js +++ b/menudata.js @@ -4,7 +4,22 @@ var menudata={children:[ {text:"Namespaces",url:"namespaces.html",children:[ {text:"Namespace List",url:"namespaces.html"}, {text:"Namespace Members",url:"namespacemembers.html",children:[ -{text:"All",url:"namespacemembers.html"}, +{text:"All",url:"namespacemembers.html",children:[ +{text:"a",url:"namespacemembers.html#index_a"}, +{text:"c",url:"namespacemembers.html#index_c"}, +{text:"d",url:"namespacemembers.html#index_d"}, +{text:"e",url:"namespacemembers.html#index_e"}, +{text:"g",url:"namespacemembers.html#index_g"}, +{text:"i",url:"namespacemembers.html#index_i"}, +{text:"m",url:"namespacemembers.html#index_m"}, +{text:"n",url:"namespacemembers.html#index_n"}, +{text:"o",url:"namespacemembers.html#index_o"}, +{text:"p",url:"namespacemembers.html#index_p"}, +{text:"r",url:"namespacemembers.html#index_r"}, +{text:"s",url:"namespacemembers.html#index_s"}, +{text:"t",url:"namespacemembers.html#index_t"}, +{text:"u",url:"namespacemembers.html#index_u"}, +{text:"v",url:"namespacemembers.html#index_v"}]}, {text:"Functions",url:"namespacemembers_func.html"}, {text:"Variables",url:"namespacemembers_vars.html"}, {text:"Typedefs",url:"namespacemembers_type.html"}]}]}, @@ -23,8 +38,10 @@ var menudata={children:[ {text:"g",url:"functions_g.html#index_g"}, {text:"h",url:"functions_h.html#index_h"}, {text:"i",url:"functions_i.html#index_i"}, +{text:"k",url:"functions_k.html#index_k"}, {text:"l",url:"functions_l.html#index_l"}, {text:"m",url:"functions_m.html#index_m"}, +{text:"n",url:"functions_n.html#index_n"}, {text:"o",url:"functions_o.html#index_o"}, {text:"p",url:"functions_p.html#index_p"}, {text:"r",url:"functions_r.html#index_r"}, @@ -42,8 +59,11 @@ var menudata={children:[ {text:"f",url:"functions_func_f.html#index_f"}, {text:"g",url:"functions_func_g.html#index_g"}, {text:"h",url:"functions_func_h.html#index_h"}, +{text:"i",url:"functions_func_i.html#index_i"}, +{text:"k",url:"functions_func_k.html#index_k"}, {text:"l",url:"functions_func_l.html#index_l"}, {text:"m",url:"functions_func_m.html#index_m"}, +{text:"n",url:"functions_func_n.html#index_n"}, {text:"o",url:"functions_func_o.html#index_o"}, {text:"p",url:"functions_func_p.html#index_p"}, {text:"r",url:"functions_func_r.html#index_r"}, diff --git a/meta_8hpp_source.html b/meta_8hpp_source.html index 32dc3d8ca..df0ea2f28 100644 --- a/meta_8hpp_source.html +++ b/meta_8hpp_source.html @@ -22,7 +22,7 @@
@@ -67,31 +67,127 @@ $(function() {
meta.hpp
-
1 #ifndef ENTT_META_META_HPP
2 #define ENTT_META_META_HPP
3 
4 
5 #include <tuple>
6 #include <memory>
7 #include <cassert>
8 #include <cstddef>
9 #include <utility>
10 #include <type_traits>
11 #include "../core/hashed_string.hpp"
12 
13 
14 namespace entt {
15 
16 
17 struct MetaAny;
18 class MetaProp;
19 class MetaCtor;
20 class MetaDtor;
21 class MetaData;
22 class MetaFunc;
23 class MetaType;
24 
25 
26 namespace internal {
27 
28 
29 struct MetaPropNode;
30 struct MetaCtorNode;
31 struct MetaDtorNode;
32 struct MetaDataNode;
33 struct MetaFuncNode;
34 struct MetaTypeNode;
35 
36 
37 template<typename...>
38 struct MetaNode {
39  static MetaTypeNode *type;
40 };
41 
42 
43 template<typename... Type>
44 MetaTypeNode * MetaNode<Type...>::type = nullptr;
45 
46 
47 template<typename Type>
48 struct MetaNode<Type> {
49  static MetaTypeNode *type;
50 
51  template<typename>
52  static MetaCtorNode *ctor;
53 
54  template<typename>
55  static MetaDtorNode *dtor;
56 
57  template<typename>
58  static MetaDataNode *data;
59 
60  template<typename>
61  static MetaFuncNode *func;
62 
63  template<typename, typename...>
64  static MetaPropNode *prop;
65 
66  static internal::MetaTypeNode * resolve() ENTT_NOEXCEPT;
67 };
68 
69 
70 template<typename Type>
71 MetaTypeNode * MetaNode<Type>::type = nullptr;
72 
73 
74 template<typename Type>
75 template<typename>
76 MetaCtorNode * MetaNode<Type>::ctor = nullptr;
77 
78 
79 template<typename Type>
80 template<typename>
81 MetaDtorNode * MetaNode<Type>::dtor = nullptr;
82 
83 
84 template<typename Type>
85 template<typename>
86 MetaDataNode * MetaNode<Type>::data = nullptr;
87 
88 
89 template<typename Type>
90 template<typename>
91 MetaFuncNode * MetaNode<Type>::func = nullptr;
92 
93 
94 template<typename Type>
95 template<typename, typename...>
96 MetaPropNode * MetaNode<Type>::prop = nullptr;
97 
98 
99 template<typename... Type>
100 struct MetaInfo: MetaNode<std::decay_t<Type>...> {};
101 
102 
103 struct MetaPropNode final {
104  MetaPropNode * const next;
105  const MetaAny &(* const key)();
106  const MetaAny &(* const value)();
107  MetaProp *(* const meta)();
108 };
109 
110 
111 struct MetaCtorNode final {
112  using size_type = std::size_t;
113  MetaCtorNode * const next;
114  MetaPropNode * const prop;
115  const size_type size;
116  MetaTypeNode *(* const arg)(size_type);
117  bool(* const accept)(const MetaTypeNode ** const);
118  MetaAny(* const invoke)(const MetaAny * const);
119  MetaCtor *(* const meta)();
120 };
121 
122 
123 struct MetaDtorNode final {
124  MetaPropNode * const prop;
125  void(* const invoke)(void *);
126  MetaDtor *(* const meta)();
127 };
128 
129 
130 struct MetaDataNode final {
131  const HashedString name;
132  MetaDataNode * const next;
133  MetaPropNode * const prop;
134  const bool readonly;
135  const bool shared;
136  MetaTypeNode *(* const type)();
137  void(* const set)(void *, const MetaAny &);
138  MetaAny(* const get)(const void *);
139  bool(* const accept)(const MetaTypeNode * const);
140  MetaData *(* const meta)();
141 };
142 
143 
144 struct MetaFuncNode final {
145  using size_type = std::size_t;
146  const HashedString name;
147  MetaFuncNode * const next;
148  MetaPropNode * const prop;
149  const size_type size;
150  const bool constant;
151  const bool shared;
152  MetaTypeNode *(* const ret)();
153  MetaTypeNode *(* const arg)(size_type);
154  bool(* const accept)(const MetaTypeNode ** const);
155  MetaAny(* const cinvoke)(const void *, const MetaAny *);
156  MetaAny(* const invoke)(void *, const MetaAny *);
157  MetaFunc *(* const meta)();
158 };
159 
160 
161 struct MetaTypeNode final {
162  const HashedString name;
163  MetaTypeNode * const next;
164  MetaPropNode * const prop;
165  void(* const destroy)(void *);
166  MetaType *(* const meta)();
167  MetaCtorNode *ctor;
168  MetaDtorNode *dtor;
169  MetaDataNode *data;
170  MetaFuncNode *func;
171 };
172 
173 
174 struct Holder {
175  virtual ~Holder() = default;
176 
177  virtual MetaTypeNode * node() const ENTT_NOEXCEPT = 0;
178  virtual const void * data() const ENTT_NOEXCEPT = 0;
179  virtual bool operator==(const Holder &) const ENTT_NOEXCEPT = 0;
180 
181  inline void * data() ENTT_NOEXCEPT {
182  return const_cast<void *>(const_cast<const Holder *>(this)->data());
183  }
184 };
185 
186 
187 template<typename Type>
188 struct HolderType: public Holder {
189  template<typename Object>
190  static auto compare(int, const Object &lhs, const Object &rhs)
191  -> decltype(lhs == rhs, bool{})
192  {
193  return lhs == rhs;
194  }
195 
196  template<typename Object>
197  static bool compare(char, const Object &, const Object &) {
198  return false;
199  }
200 
201 public:
202  template<typename... Args>
203  HolderType(Args &&... args)
204  : storage{}
205  {
206  new (&storage) Type{std::forward<Args>(args)...};
207  }
208 
209  ~HolderType() {
210  reinterpret_cast<Type *>(&storage)->~Type();
211  }
212 
213  MetaTypeNode * node() const ENTT_NOEXCEPT override {
214  return MetaInfo<Type>::resolve();
215  }
216 
217  inline const void * data() const ENTT_NOEXCEPT override {
218  return &storage;
219  }
220 
221  bool operator==(const Holder &other) const ENTT_NOEXCEPT override {
222  return node() == other.node() && compare(0, *reinterpret_cast<const Type *>(&storage), *static_cast<const Type *>(other.data()));
223  }
224 
225 private:
226  typename std::aligned_storage_t<sizeof(Type), alignof(Type)> storage;
227 };
228 
229 
230 struct Utils {
231  template<typename Op, typename Node>
232  static auto iterate(Op op, const Node *curr) ENTT_NOEXCEPT {
233  while(curr) {
234  op(curr->meta());
235  curr = curr->next;
236  }
237  }
238 
239  template<typename Key>
240  static MetaProp * property(Key &&key, const MetaPropNode *curr) {
241  MetaProp *prop = nullptr;
242 
243  iterate([&prop, key = std::forward<Key>(key)](auto *curr) {
244  prop = (curr->key().template convertible<Key>() && curr->key() == key) ? curr : prop;
245  }, curr);
246 
247  return prop;
248  }
249 
250  template<typename Node>
251  static auto meta(HashedString name, const Node *curr) {
252  while(curr && curr->name != name) {
253  curr = curr->next;
254  }
255 
256  return curr ? curr->meta() : nullptr;
257  }
258 };
259 
260 
261 }
262 
263 
264 struct MetaAny final {
265  MetaAny() ENTT_NOEXCEPT = default;
266 
267  template<typename Type>
268  MetaAny(Type &&type)
269  : actual{std::make_unique<internal::HolderType<std::decay_t<Type>>>(std::forward<Type>(type))}
270  {}
271 
272  MetaAny(const MetaAny &) = delete;
273  MetaAny(MetaAny &&) = default;
274 
275  MetaAny & operator=(const MetaAny &other) = delete;
276  MetaAny & operator=(MetaAny &&) = default;
277 
278  inline bool valid() const ENTT_NOEXCEPT {
279  return *this;
280  }
281 
282  MetaType * type() const ENTT_NOEXCEPT {
283  return actual ? actual->node()->meta() : nullptr;
284  }
285 
286  template<typename Type>
287  bool convertible() const ENTT_NOEXCEPT {
288  return actual ? internal::MetaInfo<Type>::resolve() == actual->node() : false;
289  }
290 
291  template<typename Type>
292  inline const std::decay_t<Type> & to() const ENTT_NOEXCEPT {
293  return *static_cast<const std::decay_t<Type> *>(actual->data());
294  }
295 
296  template<typename Type>
297  inline std::decay_t<Type> & to() ENTT_NOEXCEPT {
298  return const_cast<std::decay_t<Type> &>(const_cast<const MetaAny *>(this)->to<std::decay_t<Type>>());
299  }
300 
301  template<typename Type>
302  inline const Type * data() const ENTT_NOEXCEPT {
303  return actual ? static_cast<const Type *>(actual->data()) : nullptr;
304  }
305 
306  template<typename Type>
307  inline Type * data() ENTT_NOEXCEPT {
308  return const_cast<Type *>(const_cast<const MetaAny *>(this)->data<Type>());
309  }
310 
311  inline const void * data() const ENTT_NOEXCEPT {
312  return *this;
313  }
314 
315  inline void * data() ENTT_NOEXCEPT {
316  return const_cast<void *>(const_cast<const MetaAny *>(this)->data());
317  }
318 
319  inline operator const void *() const ENTT_NOEXCEPT {
320  return actual ? actual->data() : nullptr;
321  }
322 
323  inline operator void *() ENTT_NOEXCEPT {
324  return const_cast<void *>(const_cast<const MetaAny *>(this)->data());
325  }
326 
327  inline explicit operator bool() const ENTT_NOEXCEPT {
328  return static_cast<bool>(actual);
329  }
330 
331  inline bool operator==(const MetaAny &other) const ENTT_NOEXCEPT {
332  return actual == other.actual || (type() == other.type() && actual && other.actual && *actual == *other.actual);
333  }
334 
335 private:
336  std::unique_ptr<internal::Holder> actual;
337 };
338 
339 
340 class MetaProp {
341  friend class Meta;
342 
343  MetaProp(internal::MetaPropNode * node)
344  : node{node}
345  {}
346 
347 public:
348  inline const MetaAny & key() const ENTT_NOEXCEPT {
349  return node->key();
350  }
351 
352  inline const MetaAny & value() const ENTT_NOEXCEPT {
353  return node->value();
354  }
355 
356 private:
357  internal::MetaPropNode *node;
358 };
359 
360 
361 class MetaCtor {
362  friend class Meta;
363 
364  MetaCtor(internal::MetaCtorNode * node)
365  : node{node}
366  {}
367 
368 public:
369  using size_type = typename internal::MetaCtorNode::size_type;
370 
371  inline size_type size() const ENTT_NOEXCEPT {
372  return node->size;
373  }
374 
375  inline MetaType * arg(size_type index) const ENTT_NOEXCEPT {
376  return index < size() ? node->arg(index)->meta() : nullptr;
377  }
378 
379  template<typename... Args>
380  bool accept() const ENTT_NOEXCEPT {
381  std::array<const internal::MetaTypeNode *, sizeof...(Args)> args{{internal::MetaInfo<Args>::resolve()...}};
382  return sizeof...(Args) == size() ? node->accept(args.data()) : false;
383  }
384 
385  template<typename... Args>
386  MetaAny invoke(Args &&... args) {
387  std::array<const MetaAny, sizeof...(Args)> any{{std::forward<Args>(args)...}};
388  return accept<Args...>() ? node->invoke(any.data()) : MetaAny{};
389  }
390 
391  template<typename Op>
392  inline void properties(Op op) const ENTT_NOEXCEPT {
393  internal::Utils::iterate(std::move(op), node->prop);
394  }
395 
396  template<typename Key>
397  inline MetaProp * property(Key &&key) const ENTT_NOEXCEPT {
398  return internal::Utils::property(std::forward<Key>(key), node->prop);
399  }
400 
401 private:
402  internal::MetaCtorNode *node;
403 };
404 
405 
406 class MetaDtor {
407  friend class Meta;
408 
409  MetaDtor(internal::MetaDtorNode * node)
410  : node{node}
411  {}
412 
413 public:
414  inline void invoke(void *instance) {
415  node->invoke(instance);
416  }
417 
418  template<typename Op>
419  inline void properties(Op op) const ENTT_NOEXCEPT {
420  internal::Utils::iterate(std::move(op), node->prop);
421  }
422 
423  template<typename Key>
424  inline MetaProp * property(Key &&key) const ENTT_NOEXCEPT {
425  return internal::Utils::property(std::forward<Key>(key), node->prop);
426  }
427 
428 private:
429  internal::MetaDtorNode *node;
430 };
431 
432 
433 class MetaData {
434  friend class Meta;
435 
436  MetaData(internal::MetaDataNode * node)
437  : node{node}
438  {}
439 
440 public:
441  inline const char * name() const ENTT_NOEXCEPT {
442  return node->name;
443  }
444 
445  inline bool readonly() const ENTT_NOEXCEPT {
446  return node->readonly;
447  }
448 
449  inline bool shared() const ENTT_NOEXCEPT {
450  return node->shared;
451  }
452 
453  inline MetaType * type() const ENTT_NOEXCEPT {
454  return node->type()->meta();
455  }
456 
457  template<typename Type>
458  bool accept() const ENTT_NOEXCEPT {
459  return node->accept(internal::MetaInfo<Type>::resolve());
460  }
461 
462  template<typename Type>
463  void set(void *instance, Type &&value) {
464  return accept<Type>() ? node->set(instance, MetaAny{std::forward<Type>(value)}) : void();
465  }
466 
467  inline MetaAny get(const void *instance) const ENTT_NOEXCEPT {
468  return node->get(instance);
469  }
470 
471  template<typename Op>
472  inline void properties(Op op) const ENTT_NOEXCEPT {
473  internal::Utils::iterate(std::move(op), node->prop);
474  }
475 
476  template<typename Key>
477  inline MetaProp * property(Key &&key) const ENTT_NOEXCEPT {
478  return internal::Utils::property(std::forward<Key>(key), node->prop);
479  }
480 
481 private:
482  internal::MetaDataNode *node;
483 };
484 
485 
486 class MetaFunc {
487  friend class Meta;
488 
489  MetaFunc(internal::MetaFuncNode * node)
490  : node{node}
491  {}
492 
493 public:
494  using size_type = typename internal::MetaCtorNode::size_type;
495 
496  inline const char * name() const ENTT_NOEXCEPT {
497  return node->name;
498  }
499 
500  inline size_type size() const ENTT_NOEXCEPT {
501  return node->size;
502  }
503 
504  inline bool constant() const ENTT_NOEXCEPT {
505  return node->constant;
506  }
507 
508  inline bool shared() const ENTT_NOEXCEPT {
509  return node->shared;
510  }
511 
512  inline MetaType * ret() const ENTT_NOEXCEPT {
513  return node->ret()->meta();
514  }
515 
516  inline MetaType * arg(size_type index) const ENTT_NOEXCEPT {
517  return index < size() ? node->arg(index)->meta() : nullptr;
518  }
519 
520  template<typename... Args>
521  bool accept() const ENTT_NOEXCEPT {
522  std::array<const internal::MetaTypeNode *, sizeof...(Args)> args{{internal::MetaInfo<Args>::resolve()...}};
523  return sizeof...(Args) == size() ? node->accept(args.data()) : false;
524  }
525 
526  template<typename... Args>
527  MetaAny invoke(const void *instance, Args &&... args) const {
528  std::array<const MetaAny, sizeof...(Args)> any{{std::forward<Args>(args)...}};
529  return accept<Args...>() ? node->cinvoke(instance, any.data()) : MetaAny{};
530  }
531 
532  template<typename... Args>
533  MetaAny invoke(void *instance, Args &&... args) {
534  std::array<const MetaAny, sizeof...(Args)> any{{std::forward<Args>(args)...}};
535  return accept<Args...>() ? node->invoke(instance, any.data()) : MetaAny{};
536  }
537 
538  template<typename Op>
539  inline void properties(Op op) const ENTT_NOEXCEPT {
540  internal::Utils::iterate(std::move(op), node->prop);
541  }
542 
543  template<typename Key>
544  inline MetaProp * property(Key &&key) const ENTT_NOEXCEPT {
545  return internal::Utils::property(std::forward<Key>(key), node->prop);
546  }
547 
548 private:
549  internal::MetaFuncNode *node;
550 };
551 
552 
553 class MetaType {
554  friend class Meta;
555 
556  MetaType(internal::MetaTypeNode * node) ENTT_NOEXCEPT
557  : node{node}
558  {}
559 
560 public:
561  inline const char * name() const ENTT_NOEXCEPT {
562  return node->name;
563  }
564 
565  template<typename Op>
566  inline void ctor(Op op) const ENTT_NOEXCEPT {
567  internal::Utils::iterate(std::move(op), node->ctor);
568  }
569 
570  template<typename... Args>
571  inline MetaCtor * ctor() const ENTT_NOEXCEPT {
572  MetaCtor *meta = nullptr;
573 
574  ctor([&meta](MetaCtor *curr) {
575  meta = curr->accept<Args...>() ? curr : meta;
576  });
577 
578  return meta;
579  }
580 
581  template<typename Op>
582  inline void dtor(Op op) const ENTT_NOEXCEPT {
583  return node->dtor ? op(node->dtor->meta()) : void();
584  }
585 
586  inline MetaDtor * dtor() const ENTT_NOEXCEPT {
587  return node->dtor ? node->dtor->meta() : nullptr;
588  }
589 
590  template<typename Op>
591  inline void data(Op op) const ENTT_NOEXCEPT {
592  internal::Utils::iterate(std::move(op), node->data);
593  }
594 
595  inline MetaData * data(const char *str) const ENTT_NOEXCEPT {
596  return internal::Utils::meta(HashedString{str}, node->data);
597  }
598 
599  template<typename Op>
600  inline void func(Op op) const ENTT_NOEXCEPT {
601  internal::Utils::iterate(std::move(op), node->func);
602  }
603 
604  inline MetaFunc * func(const char *str) const ENTT_NOEXCEPT {
605  return internal::Utils::meta(HashedString{str}, node->func);
606  }
607 
608  template<typename... Args>
609  MetaAny construct(Args &&... args) const {
610  auto *curr = node->ctor;
611 
612  while(curr && !curr->meta()->template accept<Args...>()) {
613  curr = curr->next;
614  }
615 
616  return curr ? curr->meta()->invoke(std::forward<Args>(args)...) : MetaAny{};
617  }
618 
619  inline void destroy(void *instance) {
620  return node->dtor ? node->dtor->invoke(instance) : node->destroy(instance);
621  }
622 
623  template<typename Op>
624  inline void properties(Op op) const ENTT_NOEXCEPT {
625  internal::Utils::iterate(std::move(op), node->prop);
626  }
627 
628  template<typename Key>
629  inline MetaProp * property(Key &&key) const ENTT_NOEXCEPT {
630  return internal::Utils::property(std::forward<Key>(key), node->prop);
631  }
632 
633 private:
634  internal::MetaTypeNode *node;
635 };
636 
637 
638 namespace internal {
639 
640 
641 template<typename Type>
642 struct TypeHelper {
643  static void destroy(void *instance) {
644  static_cast<Type *>(instance)->~Type();
645  }
646 };
647 
648 
649 template<>
650 struct TypeHelper<void> {
651  static void destroy(void *) {
652  assert(false);
653  }
654 };
655 
656 
657 template<typename>
658 struct FunctionHelper;
659 
660 
661 template<typename Ret, typename... Args>
662 struct FunctionHelper<Ret(Args...)> {
663  using return_type = Ret;
664  using args_type = std::tuple<Args...>;
665 
666  static constexpr auto size = sizeof...(Args);
667 
668  static auto arg(typename internal::MetaFuncNode::size_type index) {
669  return std::array<internal::MetaTypeNode *, sizeof...(Args)>{{internal::MetaInfo<Args>::resolve()...}}[index];
670  }
671 
672  static auto accept(const internal::MetaTypeNode ** const types) {
673  std::array<internal::MetaTypeNode *, sizeof...(Args)> args{{internal::MetaInfo<Args>::resolve()...}};
674  return std::equal(args.cbegin(), args.cend(), types);
675  }
676 };
677 
678 
679 template<typename Type, typename... Args>
680 struct CtorHelper {
681  template<std::size_t... Indexes>
682  static MetaAny construct(const MetaAny * const any, std::index_sequence<Indexes...>) {
683  return MetaAny{Type{(any+Indexes)->to<Args>()...}};
684  }
685 };
686 
687 
688 template<typename, typename = void>
689 struct ReflectionHelper;
690 
691 
692 template<typename Class, typename Type, Type Class:: *Member>
693 struct ReflectionHelper<std::integral_constant<Type Class:: *, Member>, std::enable_if_t<std::is_member_object_pointer<Type Class:: *>::value>> {
694  static constexpr auto readonly = false;
695  static constexpr auto shared = false;
696 
697  static void setter(void *instance, const MetaAny &any) {
698  static_cast<Class *>(instance)->*Member = any.to<Type>();
699  }
700 };
701 
702 
703 template<typename Class, typename Type, const Type Class:: *Member>
704 struct ReflectionHelper<std::integral_constant<const Type Class:: *, Member>, std::enable_if_t<std::is_member_object_pointer<const Type Class:: *>::value>> {
705  static constexpr auto readonly = true;
706  static constexpr auto shared = false;
707 
708  static void setter(void *, const MetaAny &) {
709  assert(false);
710  }
711 };
712 
713 
714 template<typename Class, typename Ret, typename... Args, Ret(Class:: *Member)(Args...)>
715 struct ReflectionHelper<std::integral_constant<Ret(Class:: *)(Args...), Member>, std::enable_if_t<std::is_member_function_pointer<Ret(Class:: *)(Args...)>::value>>: FunctionHelper<Ret(Args...)> {
716  static constexpr auto constant = false;
717  static constexpr auto shared = false;
718 
719  template<std::size_t... Indexes>
720  static auto invoke(int, void *instance, const MetaAny *any, std::index_sequence<Indexes...>)
721  -> decltype(MetaAny{(static_cast<Class *>(instance)->*Member)((any+Indexes)->to<Args>()...)}, MetaAny{})
722  {
723  return MetaAny{(static_cast<Class *>(instance)->*Member)((any+Indexes)->to<Args>()...)};
724  }
725 
726  template<std::size_t... Indexes>
727  static auto invoke(char, void *instance, const MetaAny *any, std::index_sequence<Indexes...>) {
728  (static_cast<Class *>(instance)->*Member)((any+Indexes)->to<Args>()...);
729  return MetaAny{};
730  }
731 
732  template<std::size_t... Indexes>
733  static MetaAny invoke(char, const void *, const MetaAny *, std::index_sequence<Indexes...>) {
734  assert(false);
735  return MetaAny{};
736  }
737 };
738 
739 
740 template<typename Class, typename Ret, typename... Args, Ret(Class:: *Member)(Args...) const>
741 struct ReflectionHelper<std::integral_constant<Ret(Class:: *)(Args...) const, Member>, std::enable_if_t<std::is_member_function_pointer<Ret(Class:: *)(Args...) const>::value>>: FunctionHelper<Ret(Args...)> {
742  static constexpr auto constant = true;
743  static constexpr auto shared = false;
744 
745  template<std::size_t... Indexes>
746  static auto invoke(int, const void *instance, const MetaAny *any, std::index_sequence<Indexes...>)
747  -> decltype(MetaAny{(static_cast<const Class *>(instance)->*Member)((any+Indexes)->to<Args>()...)}, MetaAny{})
748  {
749  return MetaAny{(static_cast<const Class *>(instance)->*Member)((any+Indexes)->to<Args>()...)};
750  }
751 
752  template<std::size_t... Indexes>
753  static auto invoke(char, const void *instance, const MetaAny *any, std::index_sequence<Indexes...>) {
754  (static_cast<const Class *>(instance)->*Member)((any+Indexes)->to<Args>()...);
755  return MetaAny{};
756  }
757 };
758 
759 
760 template<typename Type, Type *Data>
761 struct ReflectionHelper<std::integral_constant<Type *, Data>, std::enable_if_t<!std::is_function<Type>::value>> {
762  static constexpr auto readonly = false;
763  static constexpr auto shared = true;
764 
765  static void setter(void *, const MetaAny &any) {
766  *Data = any.to<Type>();
767  }
768 };
769 
770 
771 template<typename Type, const Type *Data>
772 struct ReflectionHelper<std::integral_constant<const Type *, Data>, std::enable_if_t<!std::is_function<const Type>::value>> {
773  static constexpr auto readonly = true;
774  static constexpr auto shared = true;
775 
776  static void setter(void *, const MetaAny &) {
777  assert(false);
778  }
779 };
780 
781 
782 template<typename Ret, typename... Args, Ret(*Func)(Args...)>
783 struct ReflectionHelper<std::integral_constant<Ret(*)(Args...), Func>, std::enable_if_t<std::is_function<Ret(Args...)>::value>>: FunctionHelper<Ret(Args...)> {
784  static constexpr auto constant = false;
785  static constexpr auto shared = true;
786 
787  template<std::size_t... Indexes>
788  static auto invoke(int, const void *, const MetaAny *any, std::index_sequence<Indexes...>)
789  -> decltype(MetaAny{(*Func)((any+Indexes)->to<Args>()...)}, MetaAny{})
790  {
791  return MetaAny{(*Func)((any+Indexes)->to<Args>()...)};
792  }
793 
794  template<std::size_t... Indexes>
795  static auto invoke(char, const void *, const MetaAny *any, std::index_sequence<Indexes...>) {
796  (*Func)((any+Indexes)->to<Args>()...);
797  return MetaAny{};
798  }
799 };
800 
801 
802 template<typename Type>
803 MetaTypeNode * MetaNode<Type>::resolve() ENTT_NOEXCEPT {
804  if(!type) {
805  static MetaTypeNode node{
806  {},
807  nullptr,
808  nullptr,
809  &TypeHelper<Type>::destroy,
810  []() -> MetaType * {
811  return nullptr;
812  }
813  };
814 
815  type = &node;
816  }
817 
818  return type;
819 }
820 
821 
822 }
823 
824 
825 }
826 
827 
828 #endif // ENTT_META_META_HPP
- - - - - - +
1 #ifndef ENTT_META_META_HPP
2 #define ENTT_META_META_HPP
3 
4 
5 #include <tuple>
6 #include <array>
7 #include <memory>
8 #include <cstring>
9 #include <cstddef>
10 #include <utility>
11 #include <functional>
12 #include <type_traits>
13 #include "../config/config.h"
14 #include "../core/hashed_string.hpp"
15 
16 
17 namespace entt {
18 
19 
20 class meta_any;
21 class meta_handle;
22 class meta_prop;
23 class meta_base;
24 class meta_conv;
25 class meta_ctor;
26 class meta_dtor;
27 class meta_data;
28 class meta_func;
29 class meta_type;
30 
31 
38 namespace internal {
39 
40 
41 struct meta_type_node;
42 
43 
44 struct meta_prop_node {
45  meta_prop_node * next;
46  meta_any(* const key)();
47  meta_any(* const value)();
48  meta_prop(* const meta)();
49 };
50 
51 
52 struct meta_base_node {
53  meta_base_node ** const underlying;
54  meta_type_node * const parent;
55  meta_base_node * next;
56  meta_type_node *(* const type)();
57  void *(* const cast)(void *);
58  meta_base(* const meta)();
59 };
60 
61 
62 struct meta_conv_node {
63  meta_conv_node ** const underlying;
64  meta_type_node * const parent;
65  meta_conv_node * next;
66  meta_type_node *(* const type)();
67  meta_any(* const conv)(void *);
68  meta_conv(* const meta)();
69 };
70 
71 
72 struct meta_ctor_node {
73  using size_type = std::size_t;
74  meta_ctor_node ** const underlying;
75  meta_type_node * const parent;
76  meta_ctor_node * next;
77  meta_prop_node * prop;
78  const size_type size;
79  meta_type_node *(* const arg)(size_type);
80  meta_any(* const invoke)(meta_any * const);
81  meta_ctor(* const meta)();
82 };
83 
84 
85 struct meta_dtor_node {
86  meta_dtor_node ** const underlying;
87  meta_type_node * const parent;
88  bool(* const invoke)(meta_handle);
89  meta_dtor(* const meta)();
90 };
91 
92 
93 struct meta_data_node {
94  meta_data_node ** const underlying;
95  hashed_string name;
96  meta_type_node * const parent;
97  meta_data_node * next;
98  meta_prop_node * prop;
99  const bool is_const;
100  const bool is_static;
101  meta_type_node *(* const type)();
102  bool(* const set)(meta_handle, meta_any, meta_any);
103  meta_any(* const get)(meta_handle, meta_any);
104  meta_data(* const meta)();
105 };
106 
107 
108 struct meta_func_node {
109  using size_type = std::size_t;
110  meta_func_node ** const underlying;
111  hashed_string name;
112  meta_type_node * const parent;
113  meta_func_node * next;
114  meta_prop_node * prop;
115  const size_type size;
116  const bool is_const;
117  const bool is_static;
118  meta_type_node *(* const ret)();
119  meta_type_node *(* const arg)(size_type);
120  meta_any(* const invoke)(meta_handle, meta_any *);
121  meta_func(* const meta)();
122 };
123 
124 
125 struct meta_type_node {
126  using size_type = std::size_t;
127  hashed_string name;
128  meta_type_node * next;
129  meta_prop_node * prop;
130  const bool is_void;
131  const bool is_integral;
132  const bool is_floating_point;
133  const bool is_array;
134  const bool is_enum;
135  const bool is_union;
136  const bool is_class;
137  const bool is_pointer;
138  const bool is_function;
139  const bool is_member_object_pointer;
140  const bool is_member_function_pointer;
141  const size_type extent;
142  meta_type(* const remove_pointer)();
143  bool(* const destroy)(meta_handle);
144  meta_type(* const meta)();
145  meta_base_node *base;
146  meta_conv_node *conv;
147  meta_ctor_node *ctor;
148  meta_dtor_node *dtor;
149  meta_data_node *data;
150  meta_func_node *func;
151 };
152 
153 
154 template<typename...>
155 struct meta_node {
156  inline static meta_type_node *type = nullptr;
157 };
158 
159 
160 template<typename Type>
161 struct meta_node<Type> {
162  inline static meta_type_node *type = nullptr;
163 
164  template<typename>
165  inline static meta_base_node *base = nullptr;
166 
167  template<typename>
168  inline static meta_conv_node *conv = nullptr;
169 
170  template<typename>
171  inline static meta_ctor_node *ctor = nullptr;
172 
173  template<auto>
174  inline static meta_dtor_node *dtor = nullptr;
175 
176  template<auto...>
177  inline static meta_data_node *data = nullptr;
178 
179  template<auto>
180  inline static meta_func_node *func = nullptr;
181 
182  inline static meta_type_node * resolve() ENTT_NOEXCEPT;
183 };
184 
185 
186 template<typename... Type>
187 struct meta_info: meta_node<std::remove_cv_t<std::remove_reference_t<Type>>...> {};
188 
189 
190 template<typename Op, typename Node>
191 void iterate(Op op, const Node *curr) ENTT_NOEXCEPT {
192  while(curr) {
193  op(curr);
194  curr = curr->next;
195  }
196 }
197 
198 
199 template<auto Member, typename Op>
200 void iterate(Op op, const meta_type_node *node) ENTT_NOEXCEPT {
201  if(node) {
202  auto *curr = node->base;
203  iterate(op, node->*Member);
204 
205  while(curr) {
206  iterate<Member>(op, curr->type());
207  curr = curr->next;
208  }
209  }
210 }
211 
212 
213 template<typename Op, typename Node>
214 auto find_if(Op op, const Node *curr) ENTT_NOEXCEPT {
215  while(curr && !op(curr)) {
216  curr = curr->next;
217  }
218 
219  return curr;
220 }
221 
222 
223 template<auto Member, typename Op>
224 auto find_if(Op op, const meta_type_node *node) ENTT_NOEXCEPT
225 -> decltype(find_if(op, node->*Member)) {
226  decltype(find_if(op, node->*Member)) ret = nullptr;
227 
228  if(node) {
229  ret = find_if(op, node->*Member);
230  auto *curr = node->base;
231 
232  while(curr && !ret) {
233  ret = find_if<Member>(op, curr->type());
234  curr = curr->next;
235  }
236  }
237 
238  return ret;
239 }
240 
241 
242 template<typename Type>
243 const Type * try_cast(const meta_type_node *node, void *instance) ENTT_NOEXCEPT {
244  const auto *type = meta_info<Type>::resolve();
245  void *ret = nullptr;
246 
247  if(node == type) {
248  ret = instance;
249  } else {
250  const auto *base = find_if<&meta_type_node::base>([type](auto *candidate) {
251  return candidate->type() == type;
252  }, node);
253 
254  ret = base ? base->cast(instance) : nullptr;
255  }
256 
257  return static_cast<const Type *>(ret);
258 }
259 
260 
261 template<auto Member>
262 inline bool can_cast_or_convert(const meta_type_node *from, const meta_type_node *to) ENTT_NOEXCEPT {
263  return (from == to) || find_if<Member>([to](auto *node) {
264  return node->type() == to;
265  }, from);
266 }
267 
268 
269 template<typename... Args, std::size_t... Indexes>
270 inline auto ctor(std::index_sequence<Indexes...>, const meta_type_node *node) ENTT_NOEXCEPT {
271  return internal::find_if([](auto *candidate) {
272  return candidate->size == sizeof...(Args) &&
273  (([](auto *from, auto *to) {
274  return internal::can_cast_or_convert<&internal::meta_type_node::base>(from, to)
275  || internal::can_cast_or_convert<&internal::meta_type_node::conv>(from, to);
276  }(internal::meta_info<Args>::resolve(), candidate->arg(Indexes))) && ...);
277  }, node->ctor);
278 }
279 
280 
281 }
282 
283 
302 class meta_any {
304  friend class meta_handle;
305 
306  using storage_type = std::aligned_storage_t<sizeof(void *), alignof(void *)>;
307  using compare_fn_type = bool(*)(const void *, const void *);
308  using copy_fn_type = void *(*)(storage_type &, const void *);
309  using destroy_fn_type = void(*)(storage_type &);
310 
311  template<typename Type>
312  inline static auto compare(int, const Type &lhs, const Type &rhs)
313  -> decltype(lhs == rhs, bool{}) {
314  return lhs == rhs;
315  }
316 
317  template<typename Type>
318  inline static bool compare(char, const Type &lhs, const Type &rhs) {
319  return &lhs == &rhs;
320  }
321 
322  template<typename Type>
323  static bool compare(const void *lhs, const void *rhs) {
324  return compare(0, *static_cast<const Type *>(lhs), *static_cast<const Type *>(rhs));
325  }
326 
327  template<typename Type>
328  static void * copy_storage(storage_type &storage, const void *instance) {
329  return new (&storage) Type{*static_cast<const Type *>(instance)};
330  }
331 
332  template<typename Type>
333  static void * copy_object(storage_type &storage, const void *instance) {
334  using chunk_type = std::aligned_storage_t<sizeof(Type), alignof(Type)>;
335  auto *chunk = new chunk_type;
336  new (&storage) chunk_type *{chunk};
337  return new (chunk) Type{*static_cast<const Type *>(instance)};
338  }
339 
340  template<typename Type>
341  static void destroy_storage(storage_type &storage) {
342  auto *node = internal::meta_info<Type>::resolve();
343  auto *instance = reinterpret_cast<Type *>(&storage);
344  node->dtor ? node->dtor->invoke(*instance) : node->destroy(*instance);
345  }
346 
347  template<typename Type>
348  static void destroy_object(storage_type &storage) {
349  using chunk_type = std::aligned_storage_t<sizeof(Type), alignof(Type)>;
350  auto *node = internal::meta_info<Type>::resolve();
351  auto *chunk = *reinterpret_cast<chunk_type **>(&storage);
352  auto *instance = reinterpret_cast<Type *>(chunk);
353  node->dtor ? node->dtor->invoke(*instance) : node->destroy(*instance);
354  delete chunk;
355  }
356 
357 public:
359  meta_any() ENTT_NOEXCEPT
360  : storage{},
361  instance{nullptr},
362  node{nullptr},
363  destroy_fn{nullptr},
364  compare_fn{nullptr},
365  copy_fn{nullptr}
366  {}
367 
381  template<typename Type, typename = std::enable_if_t<!std::is_same_v<std::remove_cv_t<std::remove_reference_t<Type>>, meta_any>>>
382  meta_any(Type &&type) {
383  using actual_type = std::remove_cv_t<std::remove_reference_t<Type>>;
384  node = internal::meta_info<Type>::resolve();
385 
386  compare_fn = &compare<actual_type>;
387 
388  if constexpr(sizeof(actual_type) <= sizeof(void *)) {
389  instance = new (&storage) actual_type{std::forward<Type>(type)};
390  destroy_fn = &destroy_storage<actual_type>;
391  copy_fn = &copy_storage<actual_type>;
392  } else {
393  using chunk_type = std::aligned_storage_t<sizeof(actual_type), alignof(actual_type)>;
394 
395  auto *chunk = new chunk_type;
396  instance = new (chunk) actual_type{std::forward<Type>(type)};
397  new (&storage) chunk_type *{chunk};
398 
399  destroy_fn = &destroy_object<actual_type>;
400  copy_fn = &copy_object<actual_type>;
401  }
402  }
403 
408  meta_any(const meta_any &other)
409  : meta_any{}
410  {
411  if(other) {
412  instance = other.copy_fn(storage, other.instance);
413  node = other.node;
414  destroy_fn = other.destroy_fn;
415  compare_fn = other.compare_fn;
416  copy_fn = other.copy_fn;
417  }
418  }
419 
429  meta_any(meta_any &&other) ENTT_NOEXCEPT
430  : meta_any{}
431  {
432  swap(*this, other);
433  }
434 
436  ~meta_any() {
437  if(destroy_fn) {
438  destroy_fn(storage);
439  }
440  }
441 
447  meta_any & operator=(meta_any other) {
448  swap(other, *this);
449  return *this;
450  }
451 
456  inline meta_type type() const ENTT_NOEXCEPT;
457 
462  inline const void * data() const ENTT_NOEXCEPT {
463  return instance;
464  }
465 
467  inline void * data() ENTT_NOEXCEPT {
468  return const_cast<void *>(std::as_const(*this).data());
469  }
470 
476  template<typename Type>
477  inline bool can_cast() const ENTT_NOEXCEPT {
478  const auto *type = internal::meta_info<Type>::resolve();
479  return internal::can_cast_or_convert<&internal::meta_type_node::base>(node, type);
480  }
481 
496  template<typename Type>
497  inline const Type & cast() const ENTT_NOEXCEPT {
498  ENTT_ASSERT(can_cast<Type>());
499  return *internal::try_cast<Type>(node, instance);
500  }
501 
503  template<typename Type>
504  inline Type & cast() ENTT_NOEXCEPT {
505  return const_cast<Type &>(std::as_const(*this).cast<Type>());
506  }
507 
513  template<typename Type>
514  inline bool can_convert() const ENTT_NOEXCEPT {
515  const auto *type = internal::meta_info<Type>::resolve();
516  return internal::can_cast_or_convert<&internal::meta_type_node::conv>(node, type);
517  }
518 
525  template<typename Type>
526  inline meta_any convert() const ENTT_NOEXCEPT {
527  const auto *type = internal::meta_info<Type>::resolve();
528  meta_any any{};
529 
530  if(node == type) {
531  any = *static_cast<const Type *>(instance);
532  } else {
533  const auto *conv = internal::find_if<&internal::meta_type_node::conv>([type](auto *other) {
534  return other->type() == type;
535  }, node);
536 
537  if(conv) {
538  any = conv->conv(instance);
539  }
540  }
541 
542  return any;
543  }
544 
550  template<typename Type>
551  inline bool convert() ENTT_NOEXCEPT {
552  bool valid = (node == internal::meta_info<Type>::resolve());
553 
554  if(!valid) {
555  auto any = std::as_const(*this).convert<Type>();
556 
557  if(any) {
558  std::swap(any, *this);
559  valid = true;
560  }
561  }
562 
563  return valid;
564  }
565 
570  inline explicit operator bool() const ENTT_NOEXCEPT {
571  return destroy_fn;
572  }
573 
580  inline bool operator==(const meta_any &other) const ENTT_NOEXCEPT {
581  return (!instance && !other.instance) || (instance && other.instance && node == other.node && compare_fn(instance, other.instance));
582  }
583 
589  friend void swap(meta_any &lhs, meta_any &rhs) {
590  using std::swap;
591 
592  if(lhs && rhs) {
593  storage_type buffer;
594  void *tmp = lhs.copy_fn(buffer, lhs.instance);
595  lhs.destroy_fn(lhs.storage);
596  lhs.instance = rhs.copy_fn(lhs.storage, rhs.instance);
597  rhs.destroy_fn(rhs.storage);
598  rhs.instance = lhs.copy_fn(rhs.storage, tmp);
599  lhs.destroy_fn(buffer);
600  } else if(lhs) {
601  rhs.instance = lhs.copy_fn(rhs.storage, lhs.instance);
602  lhs.destroy_fn(lhs.storage);
603  lhs.instance = nullptr;
604  } else if(rhs) {
605  lhs.instance = rhs.copy_fn(lhs.storage, rhs.instance);
606  rhs.destroy_fn(rhs.storage);
607  rhs.instance = nullptr;
608  }
609 
610  std::swap(lhs.node, rhs.node);
611  std::swap(lhs.destroy_fn, rhs.destroy_fn);
612  std::swap(lhs.compare_fn, rhs.compare_fn);
613  std::swap(lhs.copy_fn, rhs.copy_fn);
614  }
615 
616 private:
617  storage_type storage;
618  void *instance;
619  internal::meta_type_node *node;
620  destroy_fn_type destroy_fn;
621  compare_fn_type compare_fn;
622  copy_fn_type copy_fn;
623 };
624 
625 
636 class meta_handle {
637  meta_handle(int, meta_any &any) ENTT_NOEXCEPT
638  : node{any.node},
639  instance{any.instance}
640  {}
641 
642  template<typename Type>
643  meta_handle(char, Type &&obj) ENTT_NOEXCEPT
644  : node{internal::meta_info<Type>::resolve()},
645  instance{&obj}
646  {}
647 
648 public:
650  meta_handle() ENTT_NOEXCEPT
651  : node{nullptr},
652  instance{nullptr}
653  {}
654 
660  template<typename Type, typename = std::enable_if_t<!std::is_same_v<std::remove_cv_t<std::remove_reference_t<Type>>, meta_handle>>>
661  meta_handle(Type &&obj) ENTT_NOEXCEPT
662  : meta_handle{0, std::forward<Type>(obj)}
663  {}
664 
669  inline meta_type type() const ENTT_NOEXCEPT;
670 
685  template<typename Type>
686  inline const Type * try_cast() const ENTT_NOEXCEPT {
687  return internal::try_cast<Type>(node, instance);
688  }
689 
691  template<typename Type>
692  inline Type * try_cast() ENTT_NOEXCEPT {
693  return const_cast<Type *>(std::as_const(*this).try_cast<Type>());
694  }
695 
700  inline const void * data() const ENTT_NOEXCEPT {
701  return instance;
702  }
703 
705  inline void * data() ENTT_NOEXCEPT {
706  return const_cast<void *>(std::as_const(*this).data());
707  }
708 
713  inline explicit operator bool() const ENTT_NOEXCEPT {
714  return instance;
715  }
716 
717 private:
718  const internal::meta_type_node *node;
719  void *instance;
720 };
721 
722 
729 inline bool operator!=(const meta_any &lhs, const meta_any &rhs) ENTT_NOEXCEPT {
730  return !(lhs == rhs);
731 }
732 
733 
740 class meta_prop {
742  template<typename> friend class meta_factory;
743 
744  inline meta_prop(const internal::meta_prop_node *curr) ENTT_NOEXCEPT
745  : node{curr}
746  {}
747 
748 public:
750  inline meta_prop() ENTT_NOEXCEPT
751  : node{nullptr}
752  {}
753 
758  inline meta_any key() const ENTT_NOEXCEPT {
759  return node->key();
760  }
761 
766  inline meta_any value() const ENTT_NOEXCEPT {
767  return node->value();
768  }
769 
774  inline explicit operator bool() const ENTT_NOEXCEPT {
775  return node;
776  }
777 
784  inline bool operator==(const meta_prop &other) const ENTT_NOEXCEPT {
785  return node == other.node;
786  }
787 
788 private:
789  const internal::meta_prop_node *node;
790 };
791 
792 
799 inline bool operator!=(const meta_prop &lhs, const meta_prop &rhs) ENTT_NOEXCEPT {
800  return !(lhs == rhs);
801 }
802 
803 
810 class meta_base {
812  template<typename> friend class meta_factory;
813 
814  inline meta_base(const internal::meta_base_node *curr) ENTT_NOEXCEPT
815  : node{curr}
816  {}
817 
818 public:
820  inline meta_base() ENTT_NOEXCEPT
821  : node{nullptr}
822  {}
823 
828  inline meta_type parent() const ENTT_NOEXCEPT;
829 
834  inline meta_type type() const ENTT_NOEXCEPT;
835 
841  inline void * cast(void *instance) const ENTT_NOEXCEPT {
842  return node->cast(instance);
843  }
844 
849  inline explicit operator bool() const ENTT_NOEXCEPT {
850  return node;
851  }
852 
859  inline bool operator==(const meta_base &other) const ENTT_NOEXCEPT {
860  return node == other.node;
861  }
862 
863 private:
864  const internal::meta_base_node *node;
865 };
866 
867 
874 inline bool operator!=(const meta_base &lhs, const meta_base &rhs) ENTT_NOEXCEPT {
875  return !(lhs == rhs);
876 }
877 
878 
885 class meta_conv {
887  template<typename> friend class meta_factory;
888 
889  inline meta_conv(const internal::meta_conv_node *curr) ENTT_NOEXCEPT
890  : node{curr}
891  {}
892 
893 public:
895  inline meta_conv() ENTT_NOEXCEPT
896  : node{nullptr}
897  {}
898 
903  inline meta_type parent() const ENTT_NOEXCEPT;
904 
909  inline meta_type type() const ENTT_NOEXCEPT;
910 
916  inline meta_any convert(void *instance) const ENTT_NOEXCEPT {
917  return node->conv(instance);
918  }
919 
924  inline explicit operator bool() const ENTT_NOEXCEPT {
925  return node;
926  }
927 
934  inline bool operator==(const meta_conv &other) const ENTT_NOEXCEPT {
935  return node == other.node;
936  }
937 
938 private:
939  const internal::meta_conv_node *node;
940 };
941 
942 
949 inline bool operator!=(const meta_conv &lhs, const meta_conv &rhs) ENTT_NOEXCEPT {
950  return !(lhs == rhs);
951 }
952 
953 
960 class meta_ctor {
962  template<typename> friend class meta_factory;
963 
964  inline meta_ctor(const internal::meta_ctor_node *curr) ENTT_NOEXCEPT
965  : node{curr}
966  {}
967 
968 public:
970  using size_type = typename internal::meta_ctor_node::size_type;
971 
973  inline meta_ctor() ENTT_NOEXCEPT
974  : node{nullptr}
975  {}
976 
981  inline meta_type parent() const ENTT_NOEXCEPT;
982 
987  inline size_type size() const ENTT_NOEXCEPT {
988  return node->size;
989  }
990 
996  inline meta_type arg(size_type index) const ENTT_NOEXCEPT;
997 
1009  template<typename... Args>
1010  meta_any invoke(Args &&... args) const {
1011  std::array<meta_any, sizeof...(Args)> arguments{{std::forward<Args>(args)...}};
1012  meta_any any{};
1013 
1014  if(sizeof...(Args) == size()) {
1015  any = node->invoke(arguments.data());
1016  }
1017 
1018  return any;
1019  }
1020 
1026  template<typename Op>
1027  inline std::enable_if_t<std::is_invocable_v<Op, meta_prop>, void>
1028  prop(Op op) const ENTT_NOEXCEPT {
1029  internal::iterate([op = std::move(op)](auto *curr) {
1030  op(curr->meta());
1031  }, node->prop);
1032  }
1033 
1040  template<typename Key>
1041  inline std::enable_if_t<!std::is_invocable_v<Key, meta_prop>, meta_prop>
1042  prop(Key &&key) const ENTT_NOEXCEPT {
1043  const auto *curr = internal::find_if([key = meta_any{std::forward<Key>(key)}](auto *candidate) {
1044  return candidate->key() == key;
1045  }, node->prop);
1046 
1047  return curr ? curr->meta() : meta_prop{};
1048  }
1049 
1054  inline explicit operator bool() const ENTT_NOEXCEPT {
1055  return node;
1056  }
1057 
1064  inline bool operator==(const meta_ctor &other) const ENTT_NOEXCEPT {
1065  return node == other.node;
1066  }
1067 
1068 private:
1069  const internal::meta_ctor_node *node;
1070 };
1071 
1072 
1079 inline bool operator!=(const meta_ctor &lhs, const meta_ctor &rhs) ENTT_NOEXCEPT {
1080  return !(lhs == rhs);
1081 }
1082 
1083 
1090 class meta_dtor {
1092  template<typename> friend class meta_factory;
1093 
1094  inline meta_dtor(const internal::meta_dtor_node *curr) ENTT_NOEXCEPT
1095  : node{curr}
1096  {}
1097 
1098 public:
1100  inline meta_dtor() ENTT_NOEXCEPT
1101  : node{nullptr}
1102  {}
1103 
1108  inline meta_type parent() const ENTT_NOEXCEPT;
1109 
1120  inline bool invoke(meta_handle handle) const {
1121  return node->invoke(handle);
1122  }
1123 
1128  inline explicit operator bool() const ENTT_NOEXCEPT {
1129  return node;
1130  }
1131 
1138  inline bool operator==(const meta_dtor &other) const ENTT_NOEXCEPT {
1139  return node == other.node;
1140  }
1141 
1142 private:
1143  const internal::meta_dtor_node *node;
1144 };
1145 
1146 
1153 inline bool operator!=(const meta_dtor &lhs, const meta_dtor &rhs) ENTT_NOEXCEPT {
1154  return !(lhs == rhs);
1155 }
1156 
1157 
1164 class meta_data {
1166  template<typename> friend class meta_factory;
1167 
1168  inline meta_data(const internal::meta_data_node *curr) ENTT_NOEXCEPT
1169  : node{curr}
1170  {}
1171 
1172 public:
1174  inline meta_data() ENTT_NOEXCEPT
1175  : node{nullptr}
1176  {}
1177 
1182  inline const char * name() const ENTT_NOEXCEPT {
1183  return node->name;
1184  }
1185 
1190  inline meta_type parent() const ENTT_NOEXCEPT;
1191 
1196  inline bool is_const() const ENTT_NOEXCEPT {
1197  return node->is_const;
1198  }
1199 
1208  inline bool is_static() const ENTT_NOEXCEPT {
1209  return node->is_static;
1210  }
1211 
1216  inline meta_type type() const ENTT_NOEXCEPT;
1217 
1232  template<typename Type>
1233  inline bool set(meta_handle handle, Type &&value) const {
1234  return node->set(handle, meta_any{}, std::forward<Type>(value));
1235  }
1236 
1252  template<typename Type>
1253  inline bool set(meta_handle handle, std::size_t index, Type &&value) const {
1254  ENTT_ASSERT(index < node->type()->extent);
1255  return node->set(handle, index, std::forward<Type>(value));
1256  }
1257 
1267  inline meta_any get(meta_handle handle) const ENTT_NOEXCEPT {
1268  return node->get(handle, meta_any{});
1269  }
1270 
1281  inline meta_any get(meta_handle handle, std::size_t index) const ENTT_NOEXCEPT {
1282  ENTT_ASSERT(index < node->type()->extent);
1283  return node->get(handle, index);
1284  }
1285 
1291  template<typename Op>
1292  inline std::enable_if_t<std::is_invocable_v<Op, meta_prop>, void>
1293  prop(Op op) const ENTT_NOEXCEPT {
1294  internal::iterate([op = std::move(op)](auto *curr) {
1295  op(curr->meta());
1296  }, node->prop);
1297  }
1298 
1305  template<typename Key>
1306  inline std::enable_if_t<!std::is_invocable_v<Key, meta_prop>, meta_prop>
1307  prop(Key &&key) const ENTT_NOEXCEPT {
1308  const auto *curr = internal::find_if([key = meta_any{std::forward<Key>(key)}](auto *candidate) {
1309  return candidate->key() == key;
1310  }, node->prop);
1311 
1312  return curr ? curr->meta() : meta_prop{};
1313  }
1314 
1319  inline explicit operator bool() const ENTT_NOEXCEPT {
1320  return node;
1321  }
1322 
1329  inline bool operator==(const meta_data &other) const ENTT_NOEXCEPT {
1330  return node == other.node;
1331  }
1332 
1333 private:
1334  const internal::meta_data_node *node;
1335 };
1336 
1337 
1344 inline bool operator!=(const meta_data &lhs, const meta_data &rhs) ENTT_NOEXCEPT {
1345  return !(lhs == rhs);
1346 }
1347 
1348 
1355 class meta_func {
1357  template<typename> friend class meta_factory;
1358 
1359  inline meta_func(const internal::meta_func_node *curr) ENTT_NOEXCEPT
1360  : node{curr}
1361  {}
1362 
1363 public:
1365  using size_type = typename internal::meta_func_node::size_type;
1366 
1368  inline meta_func() ENTT_NOEXCEPT
1369  : node{nullptr}
1370  {}
1371 
1376  inline const char * name() const ENTT_NOEXCEPT {
1377  return node->name;
1378  }
1379 
1384  inline meta_type parent() const ENTT_NOEXCEPT;
1385 
1390  inline size_type size() const ENTT_NOEXCEPT {
1391  return node->size;
1392  }
1393 
1398  inline bool is_const() const ENTT_NOEXCEPT {
1399  return node->is_const;
1400  }
1401 
1410  inline bool is_static() const ENTT_NOEXCEPT {
1411  return node->is_static;
1412  }
1413 
1418  inline meta_type ret() const ENTT_NOEXCEPT;
1419 
1425  inline meta_type arg(size_type index) const ENTT_NOEXCEPT;
1426 
1442  template<typename... Args>
1443  meta_any invoke(meta_handle handle, Args &&... args) const {
1444  std::array<meta_any, sizeof...(Args)> arguments{{std::forward<Args>(args)...}};
1445  meta_any any{};
1446 
1447  if(sizeof...(Args) == size()) {
1448  any = node->invoke(handle, arguments.data());
1449  }
1450 
1451  return any;
1452  }
1453 
1459  template<typename Op>
1460  inline std::enable_if_t<std::is_invocable_v<Op, meta_prop>, void>
1461  prop(Op op) const ENTT_NOEXCEPT {
1462  internal::iterate([op = std::move(op)](auto *curr) {
1463  op(curr->meta());
1464  }, node->prop);
1465  }
1466 
1473  template<typename Key>
1474  inline std::enable_if_t<!std::is_invocable_v<Key, meta_prop>, meta_prop>
1475  prop(Key &&key) const ENTT_NOEXCEPT {
1476  const auto *curr = internal::find_if([key = meta_any{std::forward<Key>(key)}](auto *candidate) {
1477  return candidate->key() == key;
1478  }, node->prop);
1479 
1480  return curr ? curr->meta() : meta_prop{};
1481  }
1482 
1487  inline explicit operator bool() const ENTT_NOEXCEPT {
1488  return node;
1489  }
1490 
1497  inline bool operator==(const meta_func &other) const ENTT_NOEXCEPT {
1498  return node == other.node;
1499  }
1500 
1501 private:
1502  const internal::meta_func_node *node;
1503 };
1504 
1505 
1512 inline bool operator!=(const meta_func &lhs, const meta_func &rhs) ENTT_NOEXCEPT {
1513  return !(lhs == rhs);
1514 }
1515 
1516 
1523 class meta_type {
1525  template<typename> friend class meta_factory;
1526 
1528  template<typename...> friend struct internal::meta_node;
1529 
1530  inline meta_type(const internal::meta_type_node *curr) ENTT_NOEXCEPT
1531  : node{curr}
1532  {}
1533 
1534 public:
1536  using size_type = typename internal::meta_type_node::size_type;
1537 
1539  inline meta_type() ENTT_NOEXCEPT
1540  : node{nullptr}
1541  {}
1542 
1547  inline const char * name() const ENTT_NOEXCEPT {
1548  return node->name;
1549  }
1550 
1555  inline bool is_void() const ENTT_NOEXCEPT {
1556  return node->is_void;
1557  }
1558 
1564  inline bool is_integral() const ENTT_NOEXCEPT {
1565  return node->is_integral;
1566  }
1567 
1574  inline bool is_floating_point() const ENTT_NOEXCEPT {
1575  return node->is_floating_point;
1576  }
1577 
1583  inline bool is_array() const ENTT_NOEXCEPT {
1584  return node->is_array;
1585  }
1586 
1591  inline bool is_enum() const ENTT_NOEXCEPT {
1592  return node->is_enum;
1593  }
1594 
1599  inline bool is_union() const ENTT_NOEXCEPT {
1600  return node->is_union;
1601  }
1602 
1607  inline bool is_class() const ENTT_NOEXCEPT {
1608  return node->is_class;
1609  }
1610 
1615  inline bool is_pointer() const ENTT_NOEXCEPT {
1616  return node->is_pointer;
1617  }
1618 
1624  inline bool is_function() const ENTT_NOEXCEPT {
1625  return node->is_function;
1626  }
1627 
1634  inline bool is_member_object_pointer() const ENTT_NOEXCEPT {
1635  return node->is_member_object_pointer;
1636  }
1637 
1644  inline bool is_member_function_pointer() const ENTT_NOEXCEPT {
1645  return node->is_member_function_pointer;
1646  }
1647 
1654  inline size_type extent() const ENTT_NOEXCEPT {
1655  return node->extent;
1656  }
1657 
1663  inline meta_type remove_pointer() const ENTT_NOEXCEPT {
1664  return node->remove_pointer();
1665  }
1666 
1675  template<typename Op>
1676  inline void base(Op op) const ENTT_NOEXCEPT {
1677  internal::iterate<&internal::meta_type_node::base>([op = std::move(op)](auto *curr) {
1678  op(curr->meta());
1679  }, node);
1680  }
1681 
1690  inline meta_base base(const char *str) const ENTT_NOEXCEPT {
1691  const auto *curr = internal::find_if<&internal::meta_type_node::base>([name = hashed_string{str}](auto *candidate) {
1692  return candidate->type()->name == name;
1693  }, node);
1694 
1695  return curr ? curr->meta() : meta_base{};
1696  }
1697 
1707  template<typename Op>
1708  inline void conv(Op op) const ENTT_NOEXCEPT {
1709  internal::iterate<&internal::meta_type_node::conv>([op = std::move(op)](auto *curr) {
1710  op(curr->meta());
1711  }, node);
1712  }
1713 
1724  template<typename Type>
1725  inline meta_conv conv() const ENTT_NOEXCEPT {
1726  const auto *curr = internal::find_if<&internal::meta_type_node::conv>([type = internal::meta_info<Type>::resolve()](auto *candidate) {
1727  return candidate->type() == type;
1728  }, node);
1729 
1730  return curr ? curr->meta() : meta_conv{};
1731  }
1732 
1738  template<typename Op>
1739  inline void ctor(Op op) const ENTT_NOEXCEPT {
1740  internal::iterate([op = std::move(op)](auto *curr) {
1741  op(curr->meta());
1742  }, node->ctor);
1743  }
1744 
1750  template<typename... Args>
1751  inline meta_ctor ctor() const ENTT_NOEXCEPT {
1752  const auto *curr = internal::ctor<Args...>(std::make_index_sequence<sizeof...(Args)>{}, node);
1753  return curr ? curr->meta() : meta_ctor{};
1754  }
1755 
1760  inline meta_dtor dtor() const ENTT_NOEXCEPT {
1761  return node->dtor ? node->dtor->meta() : meta_dtor{};
1762  }
1763 
1773  template<typename Op>
1774  inline void data(Op op) const ENTT_NOEXCEPT {
1775  internal::iterate<&internal::meta_type_node::data>([op = std::move(op)](auto *curr) {
1776  op(curr->meta());
1777  }, node);
1778  }
1779 
1790  inline meta_data data(const char *str) const ENTT_NOEXCEPT {
1791  const auto *curr = internal::find_if<&internal::meta_type_node::data>([name = hashed_string{str}](auto *candidate) {
1792  return candidate->name == name;
1793  }, node);
1794 
1795  return curr ? curr->meta() : meta_data{};
1796  }
1797 
1808  template<typename Op>
1809  inline void func(Op op) const ENTT_NOEXCEPT {
1810  internal::iterate<&internal::meta_type_node::func>([op = std::move(op)](auto *curr) {
1811  op(curr->meta());
1812  }, node);
1813  }
1814 
1825  inline meta_func func(const char *str) const ENTT_NOEXCEPT {
1826  const auto *curr = internal::find_if<&internal::meta_type_node::func>([name = hashed_string{str}](auto *candidate) {
1827  return candidate->name == name;
1828  }, node);
1829 
1830  return curr ? curr->meta() : meta_func{};
1831  }
1832 
1844  template<typename... Args>
1845  meta_any construct(Args &&... args) const {
1846  std::array<meta_any, sizeof...(Args)> arguments{{std::forward<Args>(args)...}};
1847  meta_any any{};
1848 
1849  internal::iterate<&internal::meta_type_node::ctor>([data = arguments.data(), &any](auto *curr) -> bool {
1850  any = curr->invoke(data);
1851  return static_cast<bool>(any);
1852  }, node);
1853 
1854  return any;
1855  }
1856 
1866  inline bool destroy(meta_handle handle) const {
1867  return node->dtor ? node->dtor->invoke(handle) : node->destroy(handle);
1868  }
1869 
1879  template<typename Op>
1880  inline std::enable_if_t<std::is_invocable_v<Op, meta_prop>, void>
1881  prop(Op op) const ENTT_NOEXCEPT {
1882  internal::iterate<&internal::meta_type_node::prop>([op = std::move(op)](auto *curr) {
1883  op(curr->meta());
1884  }, node);
1885  }
1886 
1898  template<typename Key>
1899  inline std::enable_if_t<!std::is_invocable_v<Key, meta_prop>, meta_prop>
1900  prop(Key &&key) const ENTT_NOEXCEPT {
1901  const auto *curr = internal::find_if<&internal::meta_type_node::prop>([key = meta_any{std::forward<Key>(key)}](auto *candidate) {
1902  return candidate->key() == key;
1903  }, node);
1904 
1905  return curr ? curr->meta() : meta_prop{};
1906  }
1907 
1912  inline explicit operator bool() const ENTT_NOEXCEPT {
1913  return node;
1914  }
1915 
1922  inline bool operator==(const meta_type &other) const ENTT_NOEXCEPT {
1923  return node == other.node;
1924  }
1925 
1926 private:
1927  const internal::meta_type_node *node;
1928 };
1929 
1930 
1937 inline bool operator!=(const meta_type &lhs, const meta_type &rhs) ENTT_NOEXCEPT {
1938  return !(lhs == rhs);
1939 }
1940 
1941 
1942 inline meta_type meta_any::type() const ENTT_NOEXCEPT {
1943  return node ? node->meta() : meta_type{};
1944 }
1945 
1946 
1947 inline meta_type meta_handle::type() const ENTT_NOEXCEPT {
1948  return node ? node->meta() : meta_type{};
1949 }
1950 
1951 
1952 inline meta_type meta_base::parent() const ENTT_NOEXCEPT {
1953  return node->parent->meta();
1954 }
1955 
1956 
1957 inline meta_type meta_base::type() const ENTT_NOEXCEPT {
1958  return node->type()->meta();
1959 }
1960 
1961 
1962 inline meta_type meta_conv::parent() const ENTT_NOEXCEPT {
1963  return node->parent->meta();
1964 }
1965 
1966 
1967 inline meta_type meta_conv::type() const ENTT_NOEXCEPT {
1968  return node->type()->meta();
1969 }
1970 
1971 
1972 inline meta_type meta_ctor::parent() const ENTT_NOEXCEPT {
1973  return node->parent->meta();
1974 }
1975 
1976 
1977 inline meta_type meta_ctor::arg(size_type index) const ENTT_NOEXCEPT {
1978  return index < size() ? node->arg(index)->meta() : meta_type{};
1979 }
1980 
1981 
1982 inline meta_type meta_dtor::parent() const ENTT_NOEXCEPT {
1983  return node->parent->meta();
1984 }
1985 
1986 
1987 inline meta_type meta_data::parent() const ENTT_NOEXCEPT {
1988  return node->parent->meta();
1989 }
1990 
1991 
1992 inline meta_type meta_data::type() const ENTT_NOEXCEPT {
1993  return node->type()->meta();
1994 }
1995 
1996 
1997 inline meta_type meta_func::parent() const ENTT_NOEXCEPT {
1998  return node->parent->meta();
1999 }
2000 
2001 
2002 inline meta_type meta_func::ret() const ENTT_NOEXCEPT {
2003  return node->ret()->meta();
2004 }
2005 
2006 
2007 inline meta_type meta_func::arg(size_type index) const ENTT_NOEXCEPT {
2008  return index < size() ? node->arg(index)->meta() : meta_type{};
2009 }
2010 
2011 
2018 namespace internal {
2019 
2020 
2021 template<typename...>
2022 struct meta_function_helper;
2023 
2024 
2025 template<typename Ret, typename... Args>
2026 struct meta_function_helper<Ret(Args...)> {
2027  using return_type = Ret;
2028  using args_type = std::tuple<Args...>;
2029 
2030  template<std::size_t Index>
2031  using arg_type = std::decay_t<std::tuple_element_t<Index, args_type>>;
2032 
2033  static constexpr auto size = sizeof...(Args);
2034 
2035  inline static auto arg(typename internal::meta_func_node::size_type index) {
2036  return std::array<meta_type_node *, sizeof...(Args)>{{meta_info<Args>::resolve()...}}[index];
2037  }
2038 };
2039 
2040 
2041 template<typename Class, typename Ret, typename... Args, bool Const, bool Static>
2042 struct meta_function_helper<Class, Ret(Args...), std::bool_constant<Const>, std::bool_constant<Static>>: meta_function_helper<Ret(Args...)> {
2043  using class_type = Class;
2044  static constexpr auto is_const = Const;
2045  static constexpr auto is_static = Static;
2046 };
2047 
2048 
2049 template<typename Ret, typename... Args, typename Class>
2050 constexpr meta_function_helper<Class, Ret(Args...), std::bool_constant<false>, std::bool_constant<false>>
2051 to_meta_function_helper(Ret(Class:: *)(Args...));
2052 
2053 
2054 template<typename Ret, typename... Args, typename Class>
2055 constexpr meta_function_helper<Class, Ret(Args...), std::bool_constant<true>, std::bool_constant<false>>
2056 to_meta_function_helper(Ret(Class:: *)(Args...) const);
2057 
2058 
2059 template<typename Ret, typename... Args>
2060 constexpr meta_function_helper<void, Ret(Args...), std::bool_constant<false>, std::bool_constant<true>>
2061 to_meta_function_helper(Ret(*)(Args...));
2062 
2063 
2064 template<auto Func>
2065 struct meta_function_helper<std::integral_constant<decltype(Func), Func>>: decltype(to_meta_function_helper(Func)) {};
2066 
2067 
2068 template<typename Type>
2069 inline bool destroy([[maybe_unused]] meta_handle handle) {
2070  bool accepted = false;
2071 
2072  if constexpr(std::is_object_v<Type> && !std::is_array_v<Type>) {
2073  accepted = (handle.type() == meta_info<Type>::resolve()->meta());
2074 
2075  if(accepted) {
2076  static_cast<Type *>(handle.data())->~Type();
2077  }
2078  }
2079 
2080  return accepted;
2081 }
2082 
2083 
2084 template<typename Type, typename... Args, std::size_t... Indexes>
2085 inline meta_any construct(meta_any * const args, std::index_sequence<Indexes...>) {
2086  [[maybe_unused]] std::array<bool, sizeof...(Args)> can_cast{{(args+Indexes)->can_cast<std::remove_cv_t<std::remove_reference_t<Args>>>()...}};
2087  [[maybe_unused]] std::array<bool, sizeof...(Args)> can_convert{{(std::get<Indexes>(can_cast) ? false : (args+Indexes)->can_convert<std::remove_cv_t<std::remove_reference_t<Args>>>())...}};
2088  meta_any any{};
2089 
2090  if(((std::get<Indexes>(can_cast) || std::get<Indexes>(can_convert)) && ...)) {
2091  ((std::get<Indexes>(can_convert) ? void((args+Indexes)->convert<std::remove_cv_t<std::remove_reference_t<Args>>>()) : void()), ...);
2092  any = Type{(args+Indexes)->cast<std::remove_cv_t<std::remove_reference_t<Args>>>()...};
2093  }
2094 
2095  return any;
2096 }
2097 
2098 
2099 template<bool Const, typename Type, auto Data>
2100 bool setter([[maybe_unused]] meta_handle handle, [[maybe_unused]] meta_any index, [[maybe_unused]] meta_any value) {
2101  bool accepted = false;
2102 
2103  if constexpr(!Const) {
2104  if constexpr(std::is_function_v<std::remove_pointer_t<decltype(Data)>> || std::is_member_function_pointer_v<decltype(Data)>) {
2105  using helper_type = meta_function_helper<std::integral_constant<decltype(Data), Data>>;
2106  using data_type = std::decay_t<std::tuple_element_t<!std::is_member_function_pointer_v<decltype(Data)>, typename helper_type::args_type>>;
2107  static_assert(std::is_invocable_v<decltype(Data), Type *, data_type>);
2108  accepted = value.can_cast<data_type>() || value.convert<data_type>();
2109  auto *clazz = handle.try_cast<Type>();
2110 
2111  if(accepted && clazz) {
2112  std::invoke(Data, clazz, value.cast<data_type>());
2113  }
2114  } else if constexpr(std::is_member_object_pointer_v<decltype(Data)>) {
2115  using data_type = std::remove_cv_t<std::remove_reference_t<decltype(std::declval<Type>().*Data)>>;
2116  static_assert(std::is_invocable_v<decltype(Data), Type>);
2117  auto *clazz = handle.try_cast<Type>();
2118 
2119  if constexpr(std::is_array_v<data_type>) {
2120  using underlying_type = std::remove_extent_t<data_type>;
2121  accepted = index.can_cast<std::size_t>() && (value.can_cast<underlying_type>() || value.convert<underlying_type>());
2122 
2123  if(accepted && clazz) {
2124  std::invoke(Data, clazz)[index.cast<std::size_t>()] = value.cast<underlying_type>();
2125  }
2126  } else {
2127  accepted = value.can_cast<data_type>() || value.convert<data_type>();
2128 
2129  if(accepted && clazz) {
2130  std::invoke(Data, clazz) = value.cast<data_type>();
2131  }
2132  }
2133  } else {
2134  static_assert(std::is_pointer_v<decltype(Data)>);
2135  using data_type = std::remove_cv_t<std::remove_reference_t<decltype(*Data)>>;
2136 
2137  if constexpr(std::is_array_v<data_type>) {
2138  using underlying_type = std::remove_extent_t<data_type>;
2139  accepted = index.can_cast<std::size_t>() && (value.can_cast<underlying_type>() || value.convert<underlying_type>());
2140 
2141  if(accepted) {
2142  (*Data)[index.cast<std::size_t>()] = value.cast<underlying_type>();
2143  }
2144  } else {
2145  accepted = value.can_cast<data_type>() || value.convert<data_type>();
2146 
2147  if(accepted) {
2148  *Data = value.cast<data_type>();
2149  }
2150  }
2151  }
2152  }
2153 
2154  return accepted;
2155 }
2156 
2157 
2158 template<typename Type, auto Data>
2159 inline meta_any getter([[maybe_unused]] meta_handle handle, [[maybe_unused]] meta_any index) {
2160  if constexpr(std::is_function_v<std::remove_pointer_t<decltype(Data)>> || std::is_member_function_pointer_v<decltype(Data)>) {
2161  static_assert(std::is_invocable_v<decltype(Data), Type *>);
2162  auto *clazz = handle.try_cast<Type>();
2163  return clazz ? std::invoke(Data, clazz) : meta_any{};
2164  } else if constexpr(std::is_member_object_pointer_v<decltype(Data)>) {
2165  using data_type = std::remove_cv_t<std::remove_reference_t<decltype(std::declval<Type>().*Data)>>;
2166  static_assert(std::is_invocable_v<decltype(Data), Type *>);
2167  auto *clazz = handle.try_cast<Type>();
2168 
2169  if constexpr(std::is_array_v<data_type>) {
2170  return (clazz && index.can_cast<std::size_t>()) ? std::invoke(Data, clazz)[index.cast<std::size_t>()] : meta_any{};
2171  } else {
2172  return clazz ? std::invoke(Data, clazz) : meta_any{};
2173  }
2174  } else {
2175  static_assert(std::is_pointer_v<decltype(Data)>);
2176 
2177  if constexpr(std::is_array_v<std::remove_pointer_t<decltype(Data)>>) {
2178  return index.can_cast<std::size_t>() ? (*Data)[index.cast<std::size_t>()] : meta_any{};
2179  } else {
2180  return *Data;
2181  }
2182  }
2183 }
2184 
2185 
2186 template<typename Type, auto Func, std::size_t... Indexes>
2187 std::enable_if_t<std::is_function_v<std::remove_pointer_t<decltype(Func)>>, meta_any>
2188 invoke(const meta_handle &, meta_any *args, std::index_sequence<Indexes...>) {
2189  using helper_type = meta_function_helper<std::integral_constant<decltype(Func), Func>>;
2190  meta_any any{};
2191 
2192  if((((args+Indexes)->can_cast<typename helper_type::template arg_type<Indexes>>()
2193  || (args+Indexes)->convert<typename helper_type::template arg_type<Indexes>>()) && ...))
2194  {
2195  if constexpr(std::is_void_v<typename helper_type::return_type>) {
2196  std::invoke(Func, (args+Indexes)->cast<typename helper_type::template arg_type<Indexes>>()...);
2197  } else {
2198  any = meta_any{std::invoke(Func, (args+Indexes)->cast<typename helper_type::template arg_type<Indexes>>()...)};
2199  }
2200  }
2201 
2202  return any;
2203 }
2204 
2205 
2206 template<typename Type, auto Member, std::size_t... Indexes>
2207 std::enable_if_t<std::is_member_function_pointer_v<decltype(Member)>, meta_any>
2208 invoke(meta_handle &handle, meta_any *args, std::index_sequence<Indexes...>) {
2209  using helper_type = meta_function_helper<std::integral_constant<decltype(Member), Member>>;
2210  static_assert(std::is_base_of_v<typename helper_type::class_type, Type>);
2211  auto *clazz = handle.try_cast<Type>();
2212  meta_any any{};
2213 
2214  if(clazz && (((args+Indexes)->can_cast<typename helper_type::template arg_type<Indexes>>()
2215  || (args+Indexes)->convert<typename helper_type::template arg_type<Indexes>>()) && ...))
2216  {
2217  if constexpr(std::is_void_v<typename helper_type::return_type>) {
2218  std::invoke(Member, clazz, (args+Indexes)->cast<typename helper_type::template arg_type<Indexes>>()...);
2219  } else {
2220  any = meta_any{std::invoke(Member, clazz, (args+Indexes)->cast<typename helper_type::template arg_type<Indexes>>()...)};
2221  }
2222  }
2223 
2224  return any;
2225 }
2226 
2227 
2228 template<typename Type>
2229 meta_type_node * meta_node<Type>::resolve() ENTT_NOEXCEPT {
2230  if(!type) {
2231  static meta_type_node node{
2232  {},
2233  nullptr,
2234  nullptr,
2235  std::is_void_v<Type>,
2236  std::is_integral_v<Type>,
2237  std::is_floating_point_v<Type>,
2238  std::is_array_v<Type>,
2239  std::is_enum_v<Type>,
2240  std::is_union_v<Type>,
2241  std::is_class_v<Type>,
2242  std::is_pointer_v<Type>,
2243  std::is_function_v<Type>,
2244  std::is_member_object_pointer_v<Type>,
2245  std::is_member_function_pointer_v<Type>,
2246  std::extent_v<Type>,
2247  []() -> meta_type {
2248  return internal::meta_info<std::remove_pointer_t<Type>>::resolve();
2249  },
2250  &destroy<Type>,
2251  []() -> meta_type {
2252  return &node;
2253  }
2254  };
2255 
2256  type = &node;
2257  }
2258 
2259  return type;
2260 }
2261 
2262 
2263 }
2264 
2265 
2272 }
2273 
2274 
2275 #endif // ENTT_META_META_HPP
entt::meta_data::name
const char * name() const ENTT_NOEXCEPT
Returns the name assigned to a given meta data.
Definition: meta.hpp:1182
+
entt::meta_func::size_type
typename internal::meta_func_node::size_type size_type
Unsigned integer type.
Definition: meta.hpp:1365
+
entt::meta_type::operator==
bool operator==(const meta_type &other) const ENTT_NOEXCEPT
Checks if two meta objects refer to the same node.
Definition: meta.hpp:1922
+
entt::meta_type::data
void data(Op op) const ENTT_NOEXCEPT
Iterates all the meta data of a meta type.
Definition: meta.hpp:1774
+
entt::meta_base::type
meta_type type() const ENTT_NOEXCEPT
Returns the meta type of a given meta base.
Definition: meta.hpp:1957
+
entt::meta_data::operator==
bool operator==(const meta_data &other) const ENTT_NOEXCEPT
Checks if two meta objects refer to the same node.
Definition: meta.hpp:1329
+
entt::meta_base::cast
void * cast(void *instance) const ENTT_NOEXCEPT
Casts an instance from a parent type to a base type.
Definition: meta.hpp:841
+
entt::meta_any::operator==
bool operator==(const meta_any &other) const ENTT_NOEXCEPT
Checks if two containers differ in their content.
Definition: meta.hpp:580
+
entt::meta_prop::value
meta_any value() const ENTT_NOEXCEPT
Returns the stored value.
Definition: meta.hpp:766
+
entt::meta_any::meta_any
meta_any(const meta_any &other)
Copy constructor.
Definition: meta.hpp:408
+
entt::meta_type::is_enum
bool is_enum() const ENTT_NOEXCEPT
Indicates whether a given meta type refers to an enum or not.
Definition: meta.hpp:1591
+
entt::meta_type::prop
std::enable_if_t< std::is_invocable_v< Op, meta_prop >, void > prop(Op op) const ENTT_NOEXCEPT
Iterates all the properties assigned to a meta type.
Definition: meta.hpp:1881
+
entt::meta_any::cast
const Type & cast() const ENTT_NOEXCEPT
Tries to cast an instance to a given type.
Definition: meta.hpp:497
+
entt::meta_type::func
meta_func func(const char *str) const ENTT_NOEXCEPT
Returns the meta function associated with a given name.
Definition: meta.hpp:1825
+
entt::resolve
meta_type resolve() ENTT_NOEXCEPT
Returns the meta type associated with a given type.
Definition: factory.hpp:652
+
entt::meta_func::ret
meta_type ret() const ENTT_NOEXCEPT
Returns the meta type of the return type of a meta function.
Definition: meta.hpp:2002
+
entt::meta_data::prop
std::enable_if_t<!std::is_invocable_v< Key, meta_prop >, meta_prop > prop(Key &&key) const ENTT_NOEXCEPT
Returns the property associated with a given key.
Definition: meta.hpp:1307
+
entt::meta_ctor::arg
meta_type arg(size_type index) const ENTT_NOEXCEPT
Returns the meta type of the i-th argument of a meta constructor.
Definition: meta.hpp:1977
+
entt::meta_ctor::invoke
meta_any invoke(Args &&... args) const
Creates an instance of the underlying type, if possible.
Definition: meta.hpp:1010
+
entt::meta_ctor::parent
meta_type parent() const ENTT_NOEXCEPT
Returns the meta type to which a meta constructor belongs.
Definition: meta.hpp:1972
+
entt::meta_prop::key
meta_any key() const ENTT_NOEXCEPT
Returns the stored key.
Definition: meta.hpp:758
+
entt::meta_type::extent
size_type extent() const ENTT_NOEXCEPT
If a given meta type refers to an array type, provides the number of elements of the array...
Definition: meta.hpp:1654
+
entt::meta_data::is_static
bool is_static() const ENTT_NOEXCEPT
Indicates whether a given meta data is static or not.
Definition: meta.hpp:1208
+
entt::meta_type::is_floating_point
bool is_floating_point() const ENTT_NOEXCEPT
Indicates whether a given meta type refers to a floating-point type or not.
Definition: meta.hpp:1574
+
entt::meta_any::cast
Type & cast() ENTT_NOEXCEPT
Tries to cast an instance to a given type.
Definition: meta.hpp:504
+
entt::meta_any::data
const void * data() const ENTT_NOEXCEPT
Returns an opaque pointer to the contained instance.
Definition: meta.hpp:462
+
entt::meta_handle::try_cast
Type * try_cast() ENTT_NOEXCEPT
Tries to cast an instance to a given type.
Definition: meta.hpp:692
+
entt::meta_handle::data
void * data() ENTT_NOEXCEPT
Returns an opaque pointer to the contained instance.
Definition: meta.hpp:705
+
entt::meta_func::is_const
bool is_const() const ENTT_NOEXCEPT
Indicates whether a given meta function is constant or not.
Definition: meta.hpp:1398
+
entt::meta_conv::meta_conv
meta_conv() ENTT_NOEXCEPT
Default constructor.
Definition: meta.hpp:895
+
entt::meta_handle::meta_handle
meta_handle() ENTT_NOEXCEPT
Default constructor.
Definition: meta.hpp:650
entt
EnTT default namespace.
Definition: algorithm.hpp:10
- - - -
entt::HashedString
Zero overhead resource identifier.
Definition: hashed_string.hpp:22
- - - - - - - - - - - - - +
entt::meta_ctor::size
size_type size() const ENTT_NOEXCEPT
Returns the number of arguments accepted by a meta constructor.
Definition: meta.hpp:987
+
entt::meta_dtor::parent
meta_type parent() const ENTT_NOEXCEPT
Returns the meta type to which a meta destructor belongs.
Definition: meta.hpp:1982
+
entt::meta_any::meta_any
meta_any(Type &&type)
Constructs a meta any from a given value.
Definition: meta.hpp:382
+
entt::meta_dtor::meta_dtor
meta_dtor() ENTT_NOEXCEPT
Default constructor.
Definition: meta.hpp:1100
+
entt::meta_base::parent
meta_type parent() const ENTT_NOEXCEPT
Returns the meta type to which a meta base belongs.
Definition: meta.hpp:1952
+
entt::meta_handle::type
meta_type type() const ENTT_NOEXCEPT
Returns the meta type of the underlying object.
Definition: meta.hpp:1947
+
entt::hashed_string
Zero overhead unique identifier.
Definition: hashed_string.hpp:57
+
entt::meta_func::name
const char * name() const ENTT_NOEXCEPT
Returns the name assigned to a given meta function.
Definition: meta.hpp:1376
+
entt::meta_data::prop
std::enable_if_t< std::is_invocable_v< Op, meta_prop >, void > prop(Op op) const ENTT_NOEXCEPT
Iterates all the properties assigned to a meta data.
Definition: meta.hpp:1293
+
entt::meta_type::func
void func(Op op) const ENTT_NOEXCEPT
Iterates all the meta functions of a meta type.
Definition: meta.hpp:1809
+
entt::meta_type::is_integral
bool is_integral() const ENTT_NOEXCEPT
Indicates whether a given meta type refers to an integral type or not.
Definition: meta.hpp:1564
+
entt::meta_any::meta_any
meta_any() ENTT_NOEXCEPT
Default constructor.
Definition: meta.hpp:359
+
entt::meta_any::data
void * data() ENTT_NOEXCEPT
Returns an opaque pointer to the contained instance.
Definition: meta.hpp:467
+
entt::meta_type::base
void base(Op op) const ENTT_NOEXCEPT
Iterates all the meta base of a meta type.
Definition: meta.hpp:1676
+
entt::meta_type::destroy
bool destroy(meta_handle handle) const
Destroys an instance of the underlying type.
Definition: meta.hpp:1866
+
entt::meta_type::is_member_object_pointer
bool is_member_object_pointer() const ENTT_NOEXCEPT
Indicates whether a given meta type refers to a pointer to data member or not.
Definition: meta.hpp:1634
+
entt::meta_any::swap
friend void swap(meta_any &lhs, meta_any &rhs)
Swaps two meta any objects.
Definition: meta.hpp:589
+
entt::meta_base::meta_base
meta_base() ENTT_NOEXCEPT
Default constructor.
Definition: meta.hpp:820
+
entt::meta_handle::meta_handle
meta_handle(Type &&obj) ENTT_NOEXCEPT
Constructs a meta handle from a given instance.
Definition: meta.hpp:661
+
entt::storage
Basic storage implementation.
Definition: storage.hpp:692
+
entt::meta_data::meta_data
meta_data() ENTT_NOEXCEPT
Default constructor.
Definition: meta.hpp:1174
+
entt::meta_ctor::operator==
bool operator==(const meta_ctor &other) const ENTT_NOEXCEPT
Checks if two meta objects refer to the same node.
Definition: meta.hpp:1064
+
entt::meta_handle::data
const void * data() const ENTT_NOEXCEPT
Returns an opaque pointer to the contained instance.
Definition: meta.hpp:700
+
entt::meta_type::is_union
bool is_union() const ENTT_NOEXCEPT
Indicates whether a given meta type refers to an union or not.
Definition: meta.hpp:1599
+
entt::meta_type::ctor
meta_ctor ctor() const ENTT_NOEXCEPT
Returns the meta constructor that accepts a given list of types of arguments.
Definition: meta.hpp:1751
+
entt::meta_handle
Meta handle object.
Definition: meta.hpp:636
+
entt::meta_func::meta_func
meta_func() ENTT_NOEXCEPT
Default constructor.
Definition: meta.hpp:1368
+
entt::meta_base
Meta base object.
Definition: meta.hpp:810
+
entt::meta_conv::parent
meta_type parent() const ENTT_NOEXCEPT
Returns the meta type to which a meta conversion function belongs.
Definition: meta.hpp:1962
+
entt::meta_func::prop
std::enable_if_t< std::is_invocable_v< Op, meta_prop >, void > prop(Op op) const ENTT_NOEXCEPT
Iterates all the properties assigned to a meta function.
Definition: meta.hpp:1461
+
entt::meta_type::construct
meta_any construct(Args &&... args) const
Creates an instance of the underlying type, if possible.
Definition: meta.hpp:1845
+
entt::meta_type::is_array
bool is_array() const ENTT_NOEXCEPT
Indicates whether a given meta type refers to an array type or not.
Definition: meta.hpp:1583
+
entt::meta_type::is_pointer
bool is_pointer() const ENTT_NOEXCEPT
Indicates whether a given meta type refers to a pointer or not.
Definition: meta.hpp:1615
+
entt::meta_dtor::invoke
bool invoke(meta_handle handle) const
Destroys an instance of the underlying type.
Definition: meta.hpp:1120
+
entt::meta_type::remove_pointer
meta_type remove_pointer() const ENTT_NOEXCEPT
Provides the meta type for which the pointer is defined.
Definition: meta.hpp:1663
+
entt::meta_prop::meta_prop
meta_prop() ENTT_NOEXCEPT
Default constructor.
Definition: meta.hpp:750
+
entt::meta_ctor::meta_ctor
meta_ctor() ENTT_NOEXCEPT
Default constructor.
Definition: meta.hpp:973
+
entt::meta_type
Meta type object.
Definition: meta.hpp:1523
+
entt::meta_func
Meta function object.
Definition: meta.hpp:1355
+
entt::meta_ctor::prop
std::enable_if_t<!std::is_invocable_v< Key, meta_prop >, meta_prop > prop(Key &&key) const ENTT_NOEXCEPT
Returns the property associated with a given key.
Definition: meta.hpp:1042
+
entt::meta_func::is_static
bool is_static() const ENTT_NOEXCEPT
Indicates whether a given meta function is static or not.
Definition: meta.hpp:1410
+
entt::meta_type::prop
std::enable_if_t<!std::is_invocable_v< Key, meta_prop >, meta_prop > prop(Key &&key) const ENTT_NOEXCEPT
Returns the property associated with a given key.
Definition: meta.hpp:1900
+
entt::meta_type::size_type
typename internal::meta_type_node::size_type size_type
Unsigned integer type.
Definition: meta.hpp:1536
+
entt::meta_data::parent
meta_type parent() const ENTT_NOEXCEPT
Returns the meta type to which a meta data belongs.
Definition: meta.hpp:1987
+
entt::meta_data
Meta data object.
Definition: meta.hpp:1164
+
entt::meta_type::meta_type
meta_type() ENTT_NOEXCEPT
Default constructor.
Definition: meta.hpp:1539
+
entt::meta_ctor
Meta constructor object.
Definition: meta.hpp:960
+
entt::meta_type::ctor
void ctor(Op op) const ENTT_NOEXCEPT
Iterates all the meta constructors of a meta type.
Definition: meta.hpp:1739
+
entt::meta_any::can_convert
bool can_convert() const ENTT_NOEXCEPT
Checks if it&#39;s possible to convert an instance to a given type.
Definition: meta.hpp:514
+
entt::meta_dtor
Meta destructor object.
Definition: meta.hpp:1090
+
entt::meta_func::invoke
meta_any invoke(meta_handle handle, Args &&... args) const
Invokes the underlying function, if possible.
Definition: meta.hpp:1443
+
entt::meta_any::~meta_any
~meta_any()
Frees the internal storage, whatever it means.
Definition: meta.hpp:436
+
entt::meta_func::parent
meta_type parent() const ENTT_NOEXCEPT
Returns the meta type to which a meta function belongs.
Definition: meta.hpp:1997
+
entt::meta_type::conv
void conv(Op op) const ENTT_NOEXCEPT
Iterates all the meta conversion functions of a meta type.
Definition: meta.hpp:1708
+
entt::meta_conv
Meta conversion function object.
Definition: meta.hpp:885
+
entt::meta_ctor::size_type
typename internal::meta_ctor_node::size_type size_type
Unsigned integer type.
Definition: meta.hpp:970
+
entt::meta_conv::operator==
bool operator==(const meta_conv &other) const ENTT_NOEXCEPT
Checks if two meta objects refer to the same node.
Definition: meta.hpp:934
+
entt::meta_func::arg
meta_type arg(size_type index) const ENTT_NOEXCEPT
Returns the meta type of the i-th argument of a meta function.
Definition: meta.hpp:2007
+
entt::meta_type::dtor
meta_dtor dtor() const ENTT_NOEXCEPT
Returns the meta destructor associated with a given type.
Definition: meta.hpp:1760
+
entt::meta_any::convert
bool convert() ENTT_NOEXCEPT
Tries to convert an instance to a given type.
Definition: meta.hpp:551
+
entt::meta_any
Meta any object.
Definition: meta.hpp:302
+
entt::meta_conv::convert
meta_any convert(void *instance) const ENTT_NOEXCEPT
Converts an instance to a given type.
Definition: meta.hpp:916
+
entt::meta_handle::try_cast
const Type * try_cast() const ENTT_NOEXCEPT
Tries to cast an instance to a given type.
Definition: meta.hpp:686
+
entt::meta_ctor::prop
std::enable_if_t< std::is_invocable_v< Op, meta_prop >, void > prop(Op op) const ENTT_NOEXCEPT
Iterates all the properties assigned to a meta constructor.
Definition: meta.hpp:1028
+
entt::meta_dtor::operator==
bool operator==(const meta_dtor &other) const ENTT_NOEXCEPT
Checks if two meta objects refer to the same node.
Definition: meta.hpp:1138
+
entt::meta_type::is_void
bool is_void() const ENTT_NOEXCEPT
Indicates whether a given meta type refers to void or not.
Definition: meta.hpp:1555
+
entt::meta_type::data
meta_data data(const char *str) const ENTT_NOEXCEPT
Returns the meta data associated with a given name.
Definition: meta.hpp:1790
+
entt::meta_any::type
meta_type type() const ENTT_NOEXCEPT
Returns the meta type of the underlying object.
Definition: meta.hpp:1942
+
entt::meta_any::convert
meta_any convert() const ENTT_NOEXCEPT
Tries to convert an instance to a given type and returns it.
Definition: meta.hpp:526
+
entt::meta_data::type
meta_type type() const ENTT_NOEXCEPT
Returns the meta type of a given meta data.
Definition: meta.hpp:1992
+
entt::meta_type::conv
meta_conv conv() const ENTT_NOEXCEPT
Returns the meta conversion function associated with a given type.
Definition: meta.hpp:1725
+
entt::meta_base::operator==
bool operator==(const meta_base &other) const ENTT_NOEXCEPT
Checks if two meta objects refer to the same node.
Definition: meta.hpp:859
+
entt::meta_func::prop
std::enable_if_t<!std::is_invocable_v< Key, meta_prop >, meta_prop > prop(Key &&key) const ENTT_NOEXCEPT
Returns the property associated with a given key.
Definition: meta.hpp:1475
+
entt::meta_any::meta_any
meta_any(meta_any &&other) ENTT_NOEXCEPT
Move constructor.
Definition: meta.hpp:429
+
entt::meta_prop::operator==
bool operator==(const meta_prop &other) const ENTT_NOEXCEPT
Checks if two meta objects refer to the same node.
Definition: meta.hpp:784
+
entt::meta_type::base
meta_base base(const char *str) const ENTT_NOEXCEPT
Returns the meta base associated with a given name.
Definition: meta.hpp:1690
+
entt::meta_prop
Meta property object.
Definition: meta.hpp:740
+
entt::meta_func::size
size_type size() const ENTT_NOEXCEPT
Returns the number of arguments accepted by a meta function.
Definition: meta.hpp:1390
+
entt::meta_func::operator==
bool operator==(const meta_func &other) const ENTT_NOEXCEPT
Checks if two meta objects refer to the same node.
Definition: meta.hpp:1497
+
entt::meta_type::is_class
bool is_class() const ENTT_NOEXCEPT
Indicates whether a given meta type refers to a class or not.
Definition: meta.hpp:1607
+
entt::meta_any::can_cast
bool can_cast() const ENTT_NOEXCEPT
Checks if it&#39;s possible to cast an instance to a given type.
Definition: meta.hpp:477
+
entt::meta_type::is_member_function_pointer
bool is_member_function_pointer() const ENTT_NOEXCEPT
Indicates whether a given meta type refers to a pointer to member function or not.
Definition: meta.hpp:1644
+
entt::meta_type::name
const char * name() const ENTT_NOEXCEPT
Returns the name assigned to a given meta type.
Definition: meta.hpp:1547
+
entt::meta_any::operator=
meta_any & operator=(meta_any other)
Assignment operator.
Definition: meta.hpp:447
+
entt::operator!=
constexpr bool operator!=(const hashed_string &lhs, const hashed_string &rhs) ENTT_NOEXCEPT
Compares two hashed strings.
Definition: hashed_string.hpp:195
+
entt::meta_type::is_function
bool is_function() const ENTT_NOEXCEPT
Indicates whether a given meta type refers to a function type or not.
Definition: meta.hpp:1624
+
entt::meta_conv::type
meta_type type() const ENTT_NOEXCEPT
Returns the meta type of a given meta conversion function.
Definition: meta.hpp:1967
+
entt::meta_factory
A meta factory to be used for reflection purposes.
Definition: factory.hpp:17
+
entt::meta_data::is_const
bool is_const() const ENTT_NOEXCEPT
Indicates whether a given meta data is constant or not.
Definition: meta.hpp:1196
diff --git a/meta_8md_source.html b/meta_8md_source.html new file mode 100644 index 000000000..451351174 --- /dev/null +++ b/meta_8md_source.html @@ -0,0 +1,74 @@ + + + + + + + +EnTT: docs/md/meta.md Source File + + + + + + + + + +
+
+
- + - + @@ -260,23 +253,23 @@ template<typename Resource > -

Definition at line 185 of file cache.hpp.

+

Definition at line 193 of file cache.hpp.

- -

◆ empty()

+ +

◆ empty()

-template<typename Resource >
+template<typename Resource>
void entt::ResourceCache< Resource >::discard void entt::resource_cache< Resource >::discard (const resource_type const resource_type  id)
@@ -66,252 +66,359 @@ $(function() {

Go to the textual class hierarchy

- + @@ -292,25 +285,25 @@ template<typename Resource >

Returns true if a cache contains no resources, false otherwise.

Returns
True if the cache contains no resources, false otherwise.
-

Definition at line 63 of file cache.hpp.

+

Definition at line 60 of file cache.hpp.

- -

◆ handle()

+ +

◆ handle()

-template<typename Resource >
+template<typename Resource>
bool entt::ResourceCache< Resource >::empty bool entt::resource_cache< Resource >::empty ( ) const
@@ -67,9 +67,10 @@ $(function() {
ident.hpp
-
1 #ifndef ENTT_CORE_IDENT_HPP
2 #define ENTT_CORE_IDENT_HPP
3 
4 
5 #include <type_traits>
6 #include <cstddef>
7 #include <utility>
8 #include <tuple>
9 #include "../config/config.h"
10 
11 
12 namespace entt {
13 
14 
21 namespace internal {
22 
23 
24 template<typename...>
25 struct IsPartOf;
26 
27 template<typename Type, typename Current, typename... Other>
28 struct IsPartOf<Type, Current, Other...>: std::conditional_t<std::is_same<Type, Current>::value, std::true_type, IsPartOf<Type, Other...>> {};
29 
30 template<typename Type>
31 struct IsPartOf<Type>: std::false_type {};
32 
33 
34 }
35 
36 
70 template<typename... Types>
71 class Identifier final {
72  using tuple_type = std::tuple<std::decay_t<Types>...>;
73 
74  template<typename Type, std::size_t... Indexes>
75  static constexpr std::size_t get(std::index_sequence<Indexes...>) ENTT_NOEXCEPT {
76  static_assert(internal::IsPartOf<Type, Types...>::value, "!");
77 
78  std::size_t max{};
79  using accumulator_type = std::size_t[];
80  accumulator_type accumulator = { (max = std::is_same<Type, std::tuple_element_t<Indexes, tuple_type>>::value ? Indexes : max)... };
81  (void)accumulator;
82  return max;
83  }
84 
85 public:
87  using identifier_type = std::size_t;
88 
94  template<typename Type>
95  static constexpr identifier_type get() ENTT_NOEXCEPT {
96  return get<std::decay_t<Type>>(std::make_index_sequence<sizeof...(Types)>{});
97  }
98 };
99 
100 
101 }
102 
103 
104 #endif // ENTT_CORE_IDENT_HPP
entt
EnTT default namespace.
Definition: algorithm.hpp:10
-
entt::Identifier
Types identifiers.
Definition: ident.hpp:71
-
entt::Identifier::identifier_type
std::size_t identifier_type
Unsigned integer type.
Definition: ident.hpp:87
+
1 #ifndef ENTT_CORE_IDENT_HPP
2 #define ENTT_CORE_IDENT_HPP
3 
4 
5 #include <tuple>
6 #include <utility>
7 #include <type_traits>
8 #include "../config/config.h"
9 
10 
11 namespace entt {
12 
13 
41 template<typename... Types>
42 class identifier {
43  using tuple_type = std::tuple<std::decay_t<Types>...>;
44 
45  template<typename Type, std::size_t... Indexes>
46  static constexpr ENTT_ID_TYPE get(std::index_sequence<Indexes...>) ENTT_NOEXCEPT {
47  static_assert(std::disjunction_v<std::is_same<Type, Types>...>);
48  return (0 + ... + (std::is_same_v<Type, std::tuple_element_t<Indexes, tuple_type>> ? ENTT_ID_TYPE(Indexes) : ENTT_ID_TYPE{}));
49  }
50 
51 public:
53  using identifier_type = ENTT_ID_TYPE;
54 
56  template<typename Type>
57  static constexpr identifier_type type = get<std::decay_t<Type>>(std::make_index_sequence<sizeof...(Types)>{});
58 };
59 
60 
61 }
62 
63 
64 #endif // ENTT_CORE_IDENT_HPP
entt::identifier::type
static constexpr identifier_type type
Statically generated unique identifier for the given type.
Definition: ident.hpp:57
+
entt::identifier::identifier_type
ENTT_ID_TYPE identifier_type
Unsigned integer type.
Definition: ident.hpp:53
+
entt
EnTT default namespace.
Definition: algorithm.hpp:10
+
entt::identifier
Types identifiers.
Definition: ident.hpp:42
diff --git a/index.html b/index.html index 43ed551c4..acf5a9da3 100644 --- a/index.html +++ b/index.html @@ -22,7 +22,7 @@
@@ -66,46 +66,45 @@ $(function() {
EnTT: Gaming meets modern C++
-

+

Introduction

-

EnTT is a header-only, tiny and easy to use entity-component system (and much more) written in modern C++ and even used by Mojang in Minecraft.
- The entity-component-system (also known as ECS) is an architectural pattern used mostly in game development. For further details:

+

The entity-component-system (also known as ECS) is an architectural pattern used mostly in game development. For further details:

-

A long time ago, the sole entity-component system was part of the project. After a while the codebase has grown and more and more classes have become part of the repository.
+

This project started off as a pure entity-component system. Over time the codebase has grown as more and more classes and functionalities were added.
Here is a brief, yet incomplete list of what it offers today:

    -
  • Statically generated integer identifiers for types (assigned either at compile-time or at runtime).
    • -
  • A constexpr utility for human readable resource identifiers.
    • -
  • A minimal configuration system built on top of the monostate pattern.
    • -
  • An incredibly fast entity-component system based on sparse sets, with its own views and a pay for what you use policy to adjust performance and memory usage according to users' requirements.
    • -
  • A lot of facilities built on top of the entity-component system to help developers and avoid reinventing the wheel (ie dependencies, snapshot, actor class for those who aren't confident with the architecture and so on).
    • -
  • The smallest and most basic implementation of a service locator ever seen.
    • -
  • A cooperative scheduler for processes of any type.
    • -
  • All what is needed for resource management (cache, loaders, handles).
    • -
  • Delegates, signal handlers (with built-in support for collectors) and a tiny event dispatcher.
    • -
  • A general purpose event emitter, that is a CRTP idiom based class template.
    • -
  • An event dispatcher for immediate and delayed events to integrate in loops.
    • -
  • ...
    • -
  • Any other business.
    • +
  • Statically generated integer identifiers for types (assigned either at compile-time or at runtime).
    • +
  • A constexpr utility for human readable resource identifiers.
    • +
  • A minimal configuration system built using the monostate pattern.
    • +
  • An incredibly fast entity-component system based on sparse sets, with its own pay for what you use policy to adjust performance and memory usage according to the users' requirements.
    • +
  • Views and groups to iterate entities and components and allow different access patterns, from perfect SoA to fully random.
    • +
  • A lot of facilities built on top of the entity-component system to support the users and avoid reinventing the wheel (dependencies, snapshot, actor class for those who aren't confident with the architecture and so on).
    • +
  • The smallest and most basic implementation of a service locator ever seen.
    • +
  • A built-in, non-intrusive and macro-free runtime reflection system.
    • +
  • A cooperative scheduler for processes of any type.
    • +
  • All that is needed for resource management (cache, loaders, handles).
    • +
  • Delegates, signal handlers (with built-in support for collectors) and a tiny event dispatcher for immediate and delayed events to integrate in loops.
    • +
  • A general purpose event emitter as a CRTP idiom based class template.
    • +
  • And much more! Check out the wiki.
-

Consider it a work in progress. The whole API is also fully documented in-code for those who are brave enough to read it.

-

Currently, EnTT is tested on Linux, Microsoft Windows and OS X. It has proven to work also on both Android and iOS.
- Most likely it will not be problematic on other systems as well, but has not been sufficiently tested so far.

-

+

Consider this list a work in progress as well as the project. The whole API is fully documented in-code for those who are brave enough to read it.

+

Currently, EnTT is tested on Linux, Microsoft Windows and OSX. It has proven to work also on both Android and iOS.
+ Most likely it won't be problematic on other systems as well, but it hasn't been sufficiently tested so far.

+

Code Example

-
#include <entt/entt.hpp>
#include <cstdint>
struct Position {
float x;
float y;
};
struct Velocity {
float dx;
float dy;
};
void update(entt::DefaultRegistry &registry) {
auto view = registry.view<Position, Velocity>();
for(auto entity: view) {
// gets only the components that are going to be used ...
auto &velocity = view.get<Velocity>(entity);
velocity.dx = 0.;
velocity.dy = 0.;
// ...
}
}
void update(std::uint64_t dt, entt::DefaultRegistry &registry) {
registry.view<Position, Velocity>().each([dt](auto entity, auto &position, auto &velocity) {
// gets all the components of the view at once ...
position.x += velocity.dx * dt;
position.y += velocity.dy * dt;
// ...
});
}
int main() {
entt::DefaultRegistry registry;
std::uint64_t dt = 16;
for(auto i = 0; i < 10; ++i) {
auto entity = registry.create();
registry.assign<Position>(entity, i * 1.f, i * 1.f);
if(i % 2 == 0) { registry.assign<Velocity>(entity, i * .1f, i * .1f); }
}
update(dt, registry);
update(registry);
// ...
}

+
#include <entt/entt.hpp>
#include <cstdint>
struct position {
float x;
float y;
};
struct velocity {
float dx;
float dy;
};
void update(entt::registry &registry) {
auto view = registry.view<position, velocity>();
for(auto entity: view) {
// gets only the components that are going to be used ...
auto &vel = view.get<velocity>(entity);
vel.dx = 0.;
vel.dy = 0.;
// ...
}
}
void update(std::uint64_t dt, entt::registry &registry) {
registry.view<position, velocity>().each([dt](auto &pos, auto &vel) {
// gets all the components of the view at once ...
pos.x += vel.dx * dt;
pos.y += vel.dy * dt;
// ...
});
}
int main() {
entt::registry registry;
std::uint64_t dt = 16;
for(auto i = 0; i < 10; ++i) {
auto entity = registry.create();
registry.assign<position>(entity, i * 1.f, i * 1.f);
if(i % 2 == 0) { registry.assign<velocity>(entity, i * .1f, i * .1f); }
}
update(dt, registry);
update(registry);
// ...
}

Motivation

-

I started working on EnTT because of the wrong reason: my goal was to design an entity-component system that beated another well known open source solution in terms of performance and used (possibly) less memory in the average case.
- In the end, I did it, but it wasn't much satisfying. Actually it wasn't satisfying at all. The fastest and nothing more, fairly little indeed. When I realized it, I tried hard to keep intact the great performance of EnTT and to add all the features I wanted to see in my own library at the same time.

+

I started developing EnTT for the wrong reason: my goal was to design an entity-component system to beat another well known open source solution both in terms of performance and possibly memory usage.
+ In the end, I did it, but it wasn't very satisfying. Actually it wasn't satisfying at all. The fastest and nothing more, fairly little indeed. When I realized it, I tried hard to keep intact the great performance of EnTT and to add all the features I wanted to see in my own library at the same time.

Nowadays, EnTT is finally what I was looking for: still faster than its competitors, lower memory usage in the average case, a really good API and an amazing set of features. And even more, of course.

-

+

Performance

-

As it stands right now, EnTT is just fast enough for my requirements if compared to my first choice (it was already amazingly fast actually).
- Below is a comparison between the two (both of them compiled with GCC 7.3.0 on a Dell XPS 13 out of the mid 2014):

+

As it stands right now, EnTT is just fast enough for my requirements when compared to my first choice (it was already amazingly fast actually).
+ Below is a comparison between the two (both of them compiled with GCC 7.3.0 on a Dell XPS 13 from mid 2014):

- + - + @@ -324,7 +317,7 @@ template<typename Resource >

Creates a handle for a given resource identifier.

A resource handle can be in a either valid or invalid state. In other terms, a resource handle is properly initialized with a resource if the cache contains the resource itself. Otherwise the returned handle is uninitialized and accessing it results in undefined behavior.

-
See also
ResourceHandle
+
See also
resource_handle
Parameters
ResourceHandle<Resource> entt::ResourceCache< Resource >::handle resource_handle<Resource> entt::resource_cache< Resource >::handle (const resource_type const resource_type  id) const
@@ -333,17 +326,17 @@ template<typename Resource >
Returns
A handle for the given resource.
-

Definition at line 163 of file cache.hpp.

+

Definition at line 171 of file cache.hpp.

- -

◆ load()

+ +

◆ load()

-template<typename Resource >
+template<typename Resource>
template<typename Loader , typename... Args>
idUnique resource identifier.
@@ -351,9 +344,9 @@ template<typename Loader , typename... Args> @@ -67,12 +67,12 @@ $(function() {
handle.hpp
-
1 #ifndef ENTT_RESOURCE_HANDLE_HPP
2 #define ENTT_RESOURCE_HANDLE_HPP
3 
4 
5 #include <memory>
6 #include <utility>
7 #include <cassert>
8 #include "../config/config.h"
9 
10 
11 namespace entt {
12 
13 
14 template<typename Resource>
15 class ResourceCache;
16 
17 
30 template<typename Resource>
31 class ResourceHandle final {
33  friend class ResourceCache<Resource>;
34 
35  ResourceHandle(std::shared_ptr<Resource> res) ENTT_NOEXCEPT
36  : resource{std::move(res)}
37  {}
38 
39 public:
41  ResourceHandle(const ResourceHandle &) ENTT_NOEXCEPT = default;
43  ResourceHandle(ResourceHandle &&) ENTT_NOEXCEPT = default;
44 
46  ResourceHandle & operator=(const ResourceHandle &) ENTT_NOEXCEPT = default;
48  ResourceHandle & operator=(ResourceHandle &&) ENTT_NOEXCEPT = default;
49 
60  const Resource & get() const ENTT_NOEXCEPT {
61  assert(static_cast<bool>(resource));
62  return *resource;
63  }
64 
73  inline operator const Resource &() const ENTT_NOEXCEPT { return get(); }
74 
85  inline const Resource & operator *() const ENTT_NOEXCEPT { return get(); }
86 
98  inline const Resource * operator ->() const ENTT_NOEXCEPT {
99  assert(static_cast<bool>(resource));
100  return resource.get();
101  }
102 
106  explicit operator bool() const { return static_cast<bool>(resource); }
107 
108 private:
109  std::shared_ptr<Resource> resource;
110 };
111 
112 
113 }
114 
115 
116 #endif // ENTT_RESOURCE_HANDLE_HPP
entt::ResourceHandle::get
const Resource & get() const ENTT_NOEXCEPT
Gets a reference to the managed resource.
Definition: handle.hpp:60
-
entt::ResourceHandle::operator->
const Resource * operator->() const ENTT_NOEXCEPT
Gets a pointer to the managed resource from a handle.
Definition: handle.hpp:98
+
1 #ifndef ENTT_RESOURCE_HANDLE_HPP
2 #define ENTT_RESOURCE_HANDLE_HPP
3 
4 
5 #include <memory>
6 #include <utility>
7 #include "../config/config.h"
8 #include "fwd.hpp"
9 
10 
11 namespace entt {
12 
13 
26 template<typename Resource>
27 class resource_handle {
29  friend class resource_cache<Resource>;
30 
31  resource_handle(std::shared_ptr<Resource> res) ENTT_NOEXCEPT
32  : resource{std::move(res)}
33  {}
34 
35 public:
37  resource_handle() ENTT_NOEXCEPT = default;
38 
49  const Resource & get() const ENTT_NOEXCEPT {
50  ENTT_ASSERT(static_cast<bool>(resource));
51  return *resource;
52  }
53 
62  inline operator const Resource &() const ENTT_NOEXCEPT { return get(); }
63 
74  inline const Resource & operator *() const ENTT_NOEXCEPT { return get(); }
75 
87  inline const Resource * operator->() const ENTT_NOEXCEPT {
88  ENTT_ASSERT(static_cast<bool>(resource));
89  return resource.get();
90  }
91 
96  explicit operator bool() const { return static_cast<bool>(resource); }
97 
98 private:
99  std::shared_ptr<Resource> resource;
100 };
101 
102 
103 }
104 
105 
106 #endif // ENTT_RESOURCE_HANDLE_HPP
entt::resource_handle::resource_handle
resource_handle() ENTT_NOEXCEPT=default
Default constructor.
+
entt::resource_cache
Simple cache for resources of a given type.
Definition: cache.hpp:30
entt
EnTT default namespace.
Definition: algorithm.hpp:10
-
entt::ResourceHandle
Shared resource handle.
Definition: handle.hpp:31
-
entt::ResourceHandle::operator*
const Resource & operator*() const ENTT_NOEXCEPT
Dereferences a handle to obtain the managed resource.
Definition: handle.hpp:85
-
entt::ResourceCache
Simple cache for resources of a given type.
Definition: cache.hpp:29
+
entt::resource_handle::operator*
const Resource & operator*() const ENTT_NOEXCEPT
Dereferences a handle to obtain the managed resource.
Definition: handle.hpp:74
+
entt::resource_handle::operator->
const Resource * operator->() const ENTT_NOEXCEPT
Gets a pointer to the managed resource from a handle.
Definition: handle.hpp:87
+
entt::resource_handle::get
const Resource & get() const ENTT_NOEXCEPT
Gets a reference to the managed resource.
Definition: handle.hpp:49
diff --git a/hashed__string_8hpp_source.html b/hashed__string_8hpp_source.html index 3f2f03599..00d10d414 100644 --- a/hashed__string_8hpp_source.html +++ b/hashed__string_8hpp_source.html @@ -22,7 +22,7 @@
@@ -67,13 +67,19 @@ $(function() {
hashed_string.hpp
-
1 #ifndef ENTT_CORE_HASHED_STRING_HPP
2 #define ENTT_CORE_HASHED_STRING_HPP
3 
4 
5 #include <cstddef>
6 #include <cstdint>
7 #include "../config/config.h"
8 
9 
10 namespace entt {
11 
12 
22 class HashedString final {
23  struct ConstCharWrapper final {
24  // non-explicit constructor on purpose
25  constexpr ConstCharWrapper(const char *str) ENTT_NOEXCEPT: str{str} {}
26  const char *str;
27  };
28 
29  static constexpr std::uint64_t offset = 14695981039346656037ull;
30  static constexpr std::uint64_t prime = 1099511628211ull;
31 
32  // Fowler–Noll–Vo hash function v. 1a - the good
33  static constexpr std::uint64_t helper(std::uint64_t partial, const char *str) ENTT_NOEXCEPT {
34  return str[0] == 0 ? partial : helper((partial^str[0])*prime, str+1);
35  }
36 
37 public:
39  using hash_type = std::uint64_t;
40 
55  template<std::size_t N>
56  constexpr HashedString(const char (&str)[N]) ENTT_NOEXCEPT
57  : hash{helper(offset, str)}, str{str}
58  {}
59 
66  explicit constexpr HashedString(ConstCharWrapper wrapper) ENTT_NOEXCEPT
67  : hash{helper(offset, wrapper.str)}, str{wrapper.str}
68  {}
69 
74  constexpr operator const char *() const ENTT_NOEXCEPT { return str; }
75 
80  constexpr operator hash_type() const ENTT_NOEXCEPT { return hash; }
81 
87  constexpr bool operator==(const HashedString &other) const ENTT_NOEXCEPT {
88  return hash == other.hash;
89  }
90 
91 private:
92  const hash_type hash;
93  const char *str;
94 };
95 
96 
103 constexpr bool operator!=(const HashedString &lhs, const HashedString &rhs) ENTT_NOEXCEPT {
104  return !(lhs == rhs);
105 }
106 
107 
108 }
109 
110 
116 constexpr entt::HashedString operator"" ENTT_HS_SUFFIX(const char *str, std::size_t) ENTT_NOEXCEPT {
117  return entt::HashedString{str};
118 }
119 
120 
121 #endif // ENTT_CORE_HASHED_STRING_HPP
entt::operator!=
constexpr bool operator!=(const HashedString &lhs, const HashedString &rhs) ENTT_NOEXCEPT
Compares two hashed strings.
Definition: hashed_string.hpp:103
+
1 #ifndef ENTT_CORE_HASHED_STRING_HPP
2 #define ENTT_CORE_HASHED_STRING_HPP
3 
4 
5 #include <cstddef>
6 #include "../config/config.h"
7 
8 
9 namespace entt {
10 
11 
18 namespace internal {
19 
20 
21 template<typename>
22 struct fnv1a_traits;
23 
24 
25 template<>
26 struct fnv1a_traits<std::uint32_t> {
27  static constexpr std::uint32_t offset = 2166136261;
28  static constexpr std::uint32_t prime = 16777619;
29 };
30 
31 
32 template<>
33 struct fnv1a_traits<std::uint64_t> {
34  static constexpr std::uint64_t offset = 14695981039346656037ull;
35  static constexpr std::uint64_t prime = 1099511628211ull;
36 };
37 
38 
39 }
40 
41 
57 class hashed_string {
58  using traits_type = internal::fnv1a_traits<ENTT_ID_TYPE>;
59 
60  struct const_wrapper {
61  // non-explicit constructor on purpose
62  constexpr const_wrapper(const char *curr) ENTT_NOEXCEPT: str{curr} {}
63  const char *str;
64  };
65 
66  // Fowler–Noll–Vo hash function v. 1a - the good
67  inline static constexpr ENTT_ID_TYPE helper(ENTT_ID_TYPE partial, const char *curr) ENTT_NOEXCEPT {
68  return curr[0] == 0 ? partial : helper((partial^curr[0])*traits_type::prime, curr+1);
69  }
70 
71 public:
73  using hash_type = ENTT_ID_TYPE;
74 
90  template<std::size_t N>
91  inline static constexpr hash_type to_value(const char (&str)[N]) ENTT_NOEXCEPT {
92  return helper(traits_type::offset, str);
93  }
94 
100  inline static hash_type to_value(const_wrapper wrapper) ENTT_NOEXCEPT {
101  return helper(traits_type::offset, wrapper.str);
102  }
103 
110  inline static hash_type to_value(const char *str, std::size_t size) ENTT_NOEXCEPT {
111  ENTT_ID_TYPE partial{traits_type::offset};
112  while(size--) { partial = (partial^(str++)[0])*traits_type::prime; }
113  return partial;
114  }
115 
117  constexpr hashed_string() ENTT_NOEXCEPT
118  : str{nullptr}, hash{}
119  {}
120 
135  template<std::size_t N>
136  constexpr hashed_string(const char (&curr)[N]) ENTT_NOEXCEPT
137  : str{curr}, hash{helper(traits_type::offset, curr)}
138  {}
139 
145  explicit constexpr hashed_string(const_wrapper wrapper) ENTT_NOEXCEPT
146  : str{wrapper.str}, hash{helper(traits_type::offset, wrapper.str)}
147  {}
148 
153  constexpr const char * data() const ENTT_NOEXCEPT {
154  return str;
155  }
156 
161  constexpr hash_type value() const ENTT_NOEXCEPT {
162  return hash;
163  }
164 
169  constexpr operator const char *() const ENTT_NOEXCEPT { return str; }
170 
172  constexpr operator hash_type() const ENTT_NOEXCEPT { return hash; }
173 
179  constexpr bool operator==(const hashed_string &other) const ENTT_NOEXCEPT {
180  return hash == other.hash;
181  }
182 
183 private:
184  const char *str;
185  hash_type hash;
186 };
187 
188 
195 constexpr bool operator!=(const hashed_string &lhs, const hashed_string &rhs) ENTT_NOEXCEPT {
196  return !(lhs == rhs);
197 }
198 
199 
200 }
201 
202 
208 constexpr entt::hashed_string operator"" ENTT_HS_SUFFIX(const char *str, std::size_t) ENTT_NOEXCEPT {
209  return entt::hashed_string{str};
210 }
211 
212 
213 #endif // ENTT_CORE_HASHED_STRING_HPP
entt::hashed_string::to_value
static hash_type to_value(const char *str, std::size_t size) ENTT_NOEXCEPT
Returns directly the numeric representation of a string view.
Definition: hashed_string.hpp:110
entt
EnTT default namespace.
Definition: algorithm.hpp:10
-
entt::HashedString::HashedString
constexpr HashedString(ConstCharWrapper wrapper) ENTT_NOEXCEPT
Explicit constructor on purpose to avoid constructing a hashed string directly from a const char *...
Definition: hashed_string.hpp:66
-
entt::HashedString::operator==
constexpr bool operator==(const HashedString &other) const ENTT_NOEXCEPT
Compares two hashed strings.
Definition: hashed_string.hpp:87
-
entt::HashedString
Zero overhead resource identifier.
Definition: hashed_string.hpp:22
-
entt::HashedString::HashedString
constexpr HashedString(const char(&str)[N]) ENTT_NOEXCEPT
Constructs a hashed string from an array of const chars.
Definition: hashed_string.hpp:56
-
entt::HashedString::hash_type
std::uint64_t hash_type
Unsigned integer type.
Definition: hashed_string.hpp:39
+
entt::hashed_string
Zero overhead unique identifier.
Definition: hashed_string.hpp:57
+
entt::hashed_string::hashed_string
constexpr hashed_string() ENTT_NOEXCEPT
Constructs an empty hashed string.
Definition: hashed_string.hpp:117
+
entt::hashed_string::to_value
static constexpr hash_type to_value(const char(&str)[N]) ENTT_NOEXCEPT
Returns directly the numeric representation of a string.
Definition: hashed_string.hpp:91
+
entt::hashed_string::hashed_string
constexpr hashed_string(const char(&curr)[N]) ENTT_NOEXCEPT
Constructs a hashed string from an array of const chars.
Definition: hashed_string.hpp:136
+
entt::hashed_string::operator==
constexpr bool operator==(const hashed_string &other) const ENTT_NOEXCEPT
Compares two hashed strings.
Definition: hashed_string.hpp:179
+
entt::hashed_string::to_value
static hash_type to_value(const_wrapper wrapper) ENTT_NOEXCEPT
Returns directly the numeric representation of a string.
Definition: hashed_string.hpp:100
+
entt::hashed_string::hashed_string
constexpr hashed_string(const_wrapper wrapper) ENTT_NOEXCEPT
Explicit constructor on purpose to avoid constructing a hashed string directly from a const char *...
Definition: hashed_string.hpp:145
+
entt::hashed_string::value
constexpr hash_type value() const ENTT_NOEXCEPT
Returns the numeric representation of a hashed string.
Definition: hashed_string.hpp:161
+
entt::hashed_string::data
constexpr const char * data() const ENTT_NOEXCEPT
Returns the human-readable representation of a hashed string.
Definition: hashed_string.hpp:153
+
entt::hashed_string::hash_type
ENTT_ID_TYPE hash_type
Unsigned integer type.
Definition: hashed_string.hpp:73
+
entt::operator!=
constexpr bool operator!=(const hashed_string &lhs, const hashed_string &rhs) ENTT_NOEXCEPT
Compares two hashed strings.
Definition: hashed_string.hpp:195
diff --git a/helper_8hpp_source.html b/helper_8hpp_source.html index 8735302d5..fd4085115 100644 --- a/helper_8hpp_source.html +++ b/helper_8hpp_source.html @@ -22,7 +22,7 @@
@@ -67,13 +67,22 @@ $(function() {
helper.hpp
-
1 #ifndef ENTT_ENTITY_HELPER_HPP
2 #define ENTT_ENTITY_HELPER_HPP
3 
4 
5 #include <type_traits>
6 #include "../core/hashed_string.hpp"
7 #include "../signal/sigh.hpp"
8 #include "registry.hpp"
9 #include "utility.hpp"
10 
11 
12 namespace entt {
13 
14 
29 template<typename Entity, typename... Component>
30 void dependency(Registry<Entity> &registry, const Entity entity) {
31  using accumulator_type = int[];
32  accumulator_type accumulator = { ((registry.template has<Component>(entity) ? void() : (registry.template assign<Component>(entity), void())), 0)... };
33  (void)accumulator;
34 }
35 
36 
54 template<typename... Dependency, typename Entity>
55 inline void connect(Sink<void(Registry<Entity> &, const Entity)> sink) {
56  sink.template connect<dependency<Entity, Dependency...>>();
57 }
58 
59 
77 template<typename... Dependency, typename Entity>
78 inline void disconnect(Sink<void(Registry<Entity> &, const Entity)> sink) {
79  sink.template disconnect<dependency<Entity, Dependency...>>();
80 }
81 
82 
98 template<typename HashedString::hash_type Value>
99 using label = std::integral_constant<typename HashedString::hash_type, Value>;
100 
101 
102 }
103 
104 
105 #endif // ENTT_ENTITY_HELPER_HPP
entt::Registry
Fast and reliable entity-component system.
Definition: registry.hpp:42
-
entt::Sink
Sink implementation.
Definition: sigh.hpp:108
+
1 #ifndef ENTT_ENTITY_HELPER_HPP
2 #define ENTT_ENTITY_HELPER_HPP
3 
4 
5 #include <type_traits>
6 #include "../config/config.h"
7 #include "../core/hashed_string.hpp"
8 #include "../signal/sigh.hpp"
9 #include "registry.hpp"
10 
11 
12 namespace entt {
13 
14 
20 template<bool Const, typename Entity>
21 struct as_view {
23  using registry_type = std::conditional_t<Const, const entt::basic_registry<Entity>, entt::basic_registry<Entity>>;
24 
29  as_view(registry_type &source) ENTT_NOEXCEPT: reg{source} {}
30 
36  template<typename... Component>
37  inline operator entt::basic_view<Entity, Component...>() const {
38  return reg.template view<Component...>();
39  }
40 
41 private:
42  registry_type &reg;
43 };
44 
45 
54 template<typename Entity>
55 as_view(basic_registry<Entity> &) ENTT_NOEXCEPT -> as_view<false, Entity>;
56 
57 
59 template<typename Entity>
60 as_view(const basic_registry<Entity> &) ENTT_NOEXCEPT -> as_view<true, Entity>;
61 
62 
68 template<bool Const, typename Entity>
69 struct as_group {
71  using registry_type = std::conditional_t<Const, const entt::basic_registry<Entity>, entt::basic_registry<Entity>>;
72 
77  as_group(registry_type &source) ENTT_NOEXCEPT: reg{source} {}
78 
89  template<typename... Owned>
90  inline operator entt::basic_group<Entity, get_t<>, Owned...>() const {
91  return reg.template group<Owned...>();
92  }
93 
94 private:
95  registry_type &reg;
96 };
97 
98 
107 template<typename Entity>
108 as_group(basic_registry<Entity> &) ENTT_NOEXCEPT -> as_group<false, Entity>;
109 
110 
112 template<typename Entity>
113 as_group(const basic_registry<Entity> &) ENTT_NOEXCEPT -> as_group<true, Entity>;
114 
115 
131 template<typename Entity, typename Component, typename... Dependency>
132 void dependency(basic_registry<Entity> &reg, const Entity entt, const Component &) {
133  ((reg.template has<Dependency>(entt) ? void() : (reg.template assign<Dependency>(entt), void())), ...);
134 }
135 
136 
155 template<typename... Dependency, typename Component, typename Entity>
156 inline void connect(sink<void(basic_registry<Entity> &, const Entity, Component &)> sink) {
157  sink.template connect<dependency<Entity, Component, Dependency...>>();
158 }
159 
160 
179 template<typename... Dependency, typename Component, typename Entity>
180 inline void disconnect(sink<void(basic_registry<Entity> &, const Entity, Component &)> sink) {
181  sink.template disconnect<dependency<Entity, Component, Dependency...>>();
182 }
183 
184 
204 template<typename hashed_string::hash_type Value>
205 using tag = std::integral_constant<typename hashed_string::hash_type, Value>;
206 
207 
208 }
209 
210 
211 #endif // ENTT_ENTITY_HELPER_HPP
entt::as_group
as_group(basic_registry< Entity > &) ENTT_NOEXCEPT -> as_group< false, Entity >
Deduction guide.
+
entt::basic_group
Group.
Definition: fwd.hpp:25
+
entt::as_view::registry_type
std::conditional_t< Const, const entt::basic_registry< Entity >, entt::basic_registry< Entity > > registry_type
Type of registry to convert.
Definition: helper.hpp:23
entt
EnTT default namespace.
Definition: algorithm.hpp:10
-
entt::dependency
void dependency(Registry< Entity > &registry, const Entity entity)
Dependency function prototype.
Definition: helper.hpp:30
-
entt::disconnect
void disconnect(Sink< void(Registry< Entity > &, const Entity)> sink)
Disconnects a dependency function from the given sink.
Definition: helper.hpp:78
-
entt::label
std::integral_constant< typename HashedString::hash_type, Value > label
Alias template to ease the assignment of labels to entities.
Definition: helper.hpp:99
-
entt::connect
void connect(Sink< void(Registry< Entity > &, const Entity)> sink)
Connects a dependency function to the given sink.
Definition: helper.hpp:55
+
entt::as_group
Converts a registry to a group.
Definition: helper.hpp:69
+
entt::as_view::as_view
as_view(registry_type &source) ENTT_NOEXCEPT
Constructs a converter for a given registry.
Definition: helper.hpp:29
+
entt::basic_registry
Fast and reliable entity-component system.
Definition: fwd.hpp:13
+
entt::basic_view
Multi component view.
Definition: fwd.hpp:17
+
entt::disconnect
void disconnect(sink< void(basic_registry< Entity > &, const Entity, Component &)> sink)
Disconnects a dependency function from the given sink.
Definition: helper.hpp:180
+
entt::as_view
Converts a registry to a view.
Definition: helper.hpp:21
+
entt::tag
std::integral_constant< typename hashed_string::hash_type, Value > tag
Alias template to ease the assignment of tags to entities.
Definition: helper.hpp:205
+
entt::as_group::as_group
as_group(registry_type &source) ENTT_NOEXCEPT
Constructs a converter for a given registry.
Definition: helper.hpp:77
+
entt::as_group::registry_type
std::conditional_t< Const, const entt::basic_registry< Entity >, entt::basic_registry< Entity > > registry_type
Type of registry to convert.
Definition: helper.hpp:71
+
entt::dependency
void dependency(basic_registry< Entity > &reg, const Entity entt, const Component &)
Dependency function prototype.
Definition: helper.hpp:132
+
entt::sink
Sink implementation.
Definition: fwd.hpp:17
+
entt::connect
void connect(sink< void(basic_registry< Entity > &, const Entity, Component &)> sink)
Connects a dependency function to the given sink.
Definition: helper.hpp:156
diff --git a/hierarchy.html b/hierarchy.html index a08e884cc..2dfc54315 100644 --- a/hierarchy.html +++ b/hierarchy.html @@ -22,7 +22,7 @@
@@ -66,63 +66,92 @@ $(function() {

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
-
[detail level 12]
- + - + @@ -378,6 +371,7 @@ template<typename Loader , typename... Args>

Loads the resource that corresponds to a given identifier.

In case an identifier isn't already present in the cache, it loads its resource and stores it aside for future uses. Arguments are forwarded directly to the loader in order to construct properly the requested resource.

Note
If the identifier is already present in the cache, this function does nothing and the arguments are simply discarded.
+
Warning
If the resource cannot be loaded correctly, the returned handle will be invalid and any use of it will result in undefined behavior.
Template Parameters
bool entt::ResourceCache< Resource >::load resource_handle<Resource> entt::resource_cache< Resource >::load (const resource_type const resource_type  id,
@@ -392,58 +386,27 @@ template<typename Loader , typename... Args>
LoaderType of loader to use to load the resource if required.
-
Returns
True if the resource is ready to use, false otherwise.
+
Returns
A handle for the given resource.
-

Definition at line 96 of file cache.hpp.

+

Definition at line 97 of file cache.hpp.

- -

◆ operator=() [1/2]

+ +

◆ operator=()

-template<typename Resource >
+template<typename Resource>
- - -
- + - - - - -
ResourceCache& entt::ResourceCache< Resource >::operator= resource_cache& entt::resource_cache< Resource >::operator= (const ResourceCache< Resource > & )
- 		-delete
-
- -

Copying a cache isn't allowed.

-
Returns
This cache.
- -
- - -

◆ operator=() [2/2]

- -
-
-
-template<typename Resource >
- - - diff --git a/graph_legend.png b/graph_legend.png index 81788d8b7..3b72bf0e1 100644 Binary files a/graph_legend.png and b/graph_legend.png differ diff --git a/group_8hpp_source.html b/group_8hpp_source.html new file mode 100644 index 000000000..0345ce140 --- /dev/null +++ b/group_8hpp_source.html @@ -0,0 +1,128 @@ + + + + + + + +EnTT: src/entt/entity/group.hpp Source File + + + + + + + + + +
+
+
- - - - - + @@ -460,13 +423,13 @@ template<typename Resource > - -

◆ reload()

+ +

◆ reload()

-template<typename Resource >
+template<typename Resource>
template<typename Loader , typename... Args>
ResourceCache& entt::ResourceCache< Resource >::operator= (ResourceCache< Resource > && resource_cache< Resource > &&  )
@@ -474,9 +437,9 @@ template<typename Loader , typename... Args> @@ -63,80 +63,110 @@ $(function() {

- o -

diff --git a/functions_p.html b/functions_p.html index 4b62714d9..15dcd3991 100644 --- a/functions_p.html +++ b/functions_p.html @@ -22,7 +22,7 @@ @@ -62,24 +62,32 @@ $(function() {
Here is a list of all documented class members with links to the class documentation for each member:

- p -

diff --git a/functions_r.html b/functions_r.html index 71f25f53a..f2ffd35b9 100644 --- a/functions_r.html +++ b/functions_r.html @@ -22,7 +22,7 @@ @@ -63,80 +63,77 @@ $(function() {

- r -

diff --git a/functions_rela.html b/functions_rela.html index 3d16d9d75..81c4f714c 100644 --- a/functions_rela.html +++ b/functions_rela.html @@ -22,7 +22,7 @@ @@ -60,26 +60,49 @@ $(function() {
 
diff --git a/functions_s.html b/functions_s.html index 10ecc7a5b..c96d13347 100644 --- a/functions_s.html +++ b/functions_s.html @@ -22,7 +22,7 @@ @@ -62,82 +62,91 @@ $(function() {
Here is a list of all documented class members with links to the class documentation for each member:

- s -

diff --git a/functions_t.html b/functions_t.html index 21cfeb3da..2a0ba66c5 100644 --- a/functions_t.html +++ b/functions_t.html @@ -22,7 +22,7 @@ @@ -62,26 +62,43 @@ $(function() {
Here is a list of all documented class members with links to the class documentation for each member:

- t -

diff --git a/functions_type.html b/functions_type.html index 7d668a1a8..c387f02fa 100644 --- a/functions_type.html +++ b/functions_type.html @@ -22,7 +22,7 @@ @@ -63,25 +63,20 @@ $(function() {

- c -

- d -

@@ -63,15 +63,19 @@ $(function() {

- u -

diff --git a/functions_v.html b/functions_v.html index 6deaa4698..b76be851a 100644 --- a/functions_v.html +++ b/functions_v.html @@ -22,7 +22,7 @@ @@ -63,10 +63,14 @@ $(function() {

- v -

diff --git a/functions_vars.html b/functions_vars.html index 900a227e7..80f0938eb 100644 --- a/functions_vars.html +++ b/functions_vars.html @@ -22,7 +22,7 @@ @@ -70,6 +70,13 @@ $(function() { , entt::entt_traits< std::uint32_t > , entt::entt_traits< std::uint64_t > +
  • size +: entt::type_list< Type > +
    • +
  • type +: entt::family<... > +, entt::identifier< Types > +
  • version_mask : entt::entt_traits< std::uint16_t > , entt::entt_traits< std::uint32_t > diff --git a/fwd_8hpp_source.html b/fwd_8hpp_source.html new file mode 100644 index 000000000..c9572ea16 --- /dev/null +++ b/fwd_8hpp_source.html @@ -0,0 +1,78 @@ + + + + + + + +EnTT: src/entt/fwd.hpp Source File + + + + + + + + + +
    +
    +
    • - + - + @@ -501,6 +464,7 @@ template<typename Loader , typename... Args>

    Reloads a resource or loads it for the first time if not present.

    Equivalent to the following snippet (pseudocode):

    cache.discard(id);
    cache.load(id, args...);

    Arguments are forwarded directly to the loader in order to construct properly the requested resource.

    +
    Warning
    If the resource cannot be loaded correctly, the returned handle will be invalid and any use of it will result in undefined behavior.
    Template Parameters
    bool entt::ResourceCache< Resource >::reload resource_handle<Resource> entt::resource_cache< Resource >::reload (const resource_type const resource_type  id,
    @@ -515,25 +479,25 @@ template<typename Loader , typename... Args>
    LoaderType of loader to use to load the resource.
    -
    Returns
    True if the resource is ready to use, false otherwise.
    +
    Returns
    A handle for the given resource.
    -

    Definition at line 129 of file cache.hpp.

    +

    Definition at line 137 of file cache.hpp.

    - -

    ◆ size()

    + +

    ◆ size()

    -template<typename Resource >
    +template<typename Resource>
    @@ -62,11 +62,14 @@ $(function() {
    Here is a list of all documented class members with links to the class documentation for each member:

    - l -

    diff --git a/functions_m.html b/functions_m.html index 00e99a3d8..71306880d 100644 --- a/functions_m.html +++ b/functions_m.html @@ -22,7 +22,7 @@ @@ -63,11 +63,48 @@ $(function() {

    - m -

    diff --git a/functions_n.html b/functions_n.html new file mode 100644 index 000000000..8d08cfba7 --- /dev/null +++ b/functions_n.html @@ -0,0 +1,79 @@ + + + + + + + +EnTT: Class Members + + + + + + + + + +
    +
    +
    - + @@ -549,17 +513,17 @@ template<typename Resource >

    Number of resources managed by a cache.

    Returns
    Number of resources currently stored.
    -

    Definition at line 55 of file cache.hpp.

    +

    Definition at line 52 of file cache.hpp.

    - -

    ◆ temp()

    + +

    ◆ temp()

    -template<typename Resource >
    +template<typename Resource>
    template<typename Loader , typename... Args>
    size_type entt::ResourceCache< Resource >::size size_type entt::resource_cache< Resource >::size ( ) const
    @@ -567,7 +531,7 @@ template<typename Loader , typename... Args> @@ -59,67 +59,56 @@ $(function() {
    Public Member Functions | Friends | -List of all members
    +List of all members
    -
    entt::ResourceHandle< Resource > Class Template Referencefinal
    +
    entt::resource_handle< Resource > Class Template Reference

    Shared resource handle. - More...

    + More...

    #include <handle.hpp>

    - + @@ -598,7 +562,7 @@ template<typename Loader , typename... Args>
    Returns
    A handle for the given resource.
    -

    Definition at line 146 of file cache.hpp.

    +

    Definition at line 154 of file cache.hpp.

    diff --git a/classentt_1_1resource__handle-members.html b/classentt_1_1resource__handle-members.html new file mode 100644 index 000000000..fa1477469 --- /dev/null +++ b/classentt_1_1resource__handle-members.html @@ -0,0 +1,88 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
    +
    +
    ResourceHandle<Resource> entt::ResourceCache< Resource >::temp resource_handle<Resource> entt::resource_cache< Resource >::temp ( Args &&...  args)
    + + + + + +
    +
    EnTT +  3.0.0 +
    +
    + + + + + + + + + +
    +
    + + +
    + +
    + + + +
    +
    +
    entt::resource_handle< Resource > Member List
    +
    +
    + +

    This is the complete list of members for entt::resource_handle< Resource >, including all inherited members.

    + + + + + + + + +
    get() const ENTT_NOEXCEPTentt::resource_handle< Resource >inline
    operator bool() constentt::resource_handle< Resource >inlineexplicit
    operator const Resource &() const ENTT_NOEXCEPTentt::resource_handle< Resource >inline
    operator*() const ENTT_NOEXCEPTentt::resource_handle< Resource >inline
    operator->() const ENTT_NOEXCEPTentt::resource_handle< Resource >inline
    resource_cache< Resource > classentt::resource_handle< Resource >friend
    resource_handle() ENTT_NOEXCEPT=defaultentt::resource_handle< Resource >
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/classentt_1_1ResourceHandle.html b/classentt_1_1resource__handle.html similarity index 51% rename from classentt_1_1ResourceHandle.html rename to classentt_1_1resource__handle.html index 80ef468a0..56f9a9681 100644 --- a/classentt_1_1ResourceHandle.html +++ b/classentt_1_1resource__handle.html @@ -5,7 +5,7 @@ -EnTT: entt::ResourceHandle< Resource > Class Template Reference +EnTT: entt::resource_handle< Resource > Class Template Reference @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + +

    Public Member Functions

    - ResourceHandle (const ResourceHandle &) ENTT_NOEXCEPT=default
     Default copy constructor.
     
    - ResourceHandle (ResourceHandle &&) ENTT_NOEXCEPT=default
     Default move constructor.
     
    ResourceHandle & operator= (const ResourceHandle &) ENTT_NOEXCEPT=default
     Default copy assignment operator. More...
     
    ResourceHandle & operator= (ResourceHandle &&) ENTT_NOEXCEPT=default
     Default move assignment operator. More...
     
    const Resource & get () const ENTT_NOEXCEPT
     Gets a reference to the managed resource. More...
     
     operator const Resource & () const ENTT_NOEXCEPT
     Casts a handle and gets a reference to the managed resource. More...
     
    const Resource & operator* () const ENTT_NOEXCEPT
     Dereferences a handle to obtain the managed resource. More...
     
    const Resource * operator-> () const ENTT_NOEXCEPT
     Gets a pointer to the managed resource from a handle. More...
     
    - operator bool () const
     Returns true if the handle contains a resource, false otherwise.
     
    + resource_handle () ENTT_NOEXCEPT=default
     Default constructor.
     
    const Resource & get () const ENTT_NOEXCEPT
     Gets a reference to the managed resource. More...
     
     operator const Resource & () const ENTT_NOEXCEPT
     Casts a handle and gets a reference to the managed resource. More...
     
    const Resource & operator* () const ENTT_NOEXCEPT
     Dereferences a handle to obtain the managed resource. More...
     
    const Resource * operator-> () const ENTT_NOEXCEPT
     Gets a pointer to the managed resource from a handle. More...
     
     operator bool () const
     Returns true if a handle contains a resource, false otherwise. More...
     
    - - - + + +

    Friends

    -class ResourceCache< Resource >
     Resource handles are friends of their caches.
     
    +class resource_cache< Resource >
     Resource handles are friends of their caches.
     

    Detailed Description

    template<typename Resource>
    -class entt::ResourceHandle< Resource >

    +class entt::resource_handle< Resource >

    Shared resource handle.

    A shared resource handle is a small class that wraps a resource and keeps it alive even if it's deleted from the cache. It can be either copied or moved. A handle shares a reference to the same resource with all the other handles constructed for the same identifier.
    @@ -131,10 +120,10 @@ class entt::ResourceHandle< Resource > -

    Definition at line 31 of file handle.hpp.

    +

    Definition at line 17 of file fwd.hpp.

    Member Function Documentation

    - -

    ◆ get()

    + +

    ◆ get()

    @@ -145,7 +134,7 @@ template<typename Resource >
    		- + @@ -163,12 +152,12 @@ template<typename Resource > An assertion will abort the execution at runtime in debug mode if the handle is empty.
    Returns
    A reference to the managed resource.
    -

    Definition at line 60 of file handle.hpp.

    +

    Definition at line 49 of file handle.hpp.

    - -

    ◆ operator const Resource &()

    + +

    ◆ operator bool()

    @@ -179,7 +168,39 @@ template<typename Resource >
    + + +
    const Resource& entt::ResourceHandle< Resource >::get const Resource& entt::resource_handle< Resource >::get ( ) const - + + + + + +
    entt::ResourceHandle< Resource >::operator const Resource & entt::resource_handle< Resource >::operator bool () const
    +     		+inlineexplicit
    +
    + +

    Returns true if a handle contains a resource, false otherwise.

    +
    Returns
    True if the handle contains a resource, false otherwise.
    + +

    Definition at line 96 of file handle.hpp.

    + +
    + + +

    ◆ operator const Resource &()

    + +
    +
    +
    +template<typename Resource >
    + + + @@ -59,7 +59,7 @@ $(function() {
    @@ -67,79 +67,72 @@ $(function() { Classes | Public Types | Public Member Functions | -List of all members
    +List of all members
    -
    entt::Scheduler< Delta > Class Template Referencefinal
    +
    entt::scheduler< Delta > Class Template Reference

    Cooperative scheduler for processes. - More...

    + More...

    #include <scheduler.hpp>

    + + + @@ -196,12 +217,12 @@ template<typename Resource >
    Warning
    The behavior is undefined if the handle doesn't contain a resource.
    An assertion will abort the execution at runtime in debug mode if the handle is empty.
    -

    Definition at line 73 of file handle.hpp.

    +

    Definition at line 62 of file handle.hpp.

    - -

    ◆ operator*()

    + +

    ◆ operator*()

    @@ -212,7 +233,7 @@ template<typename Resource >
    @@ -59,38 +59,38 @@ $(function() {
    Friends | -List of all members
    +List of all members
    -
    entt::ResourceLoader< Loader, Resource > Class Template Reference
    +
    entt::resource_loader< Loader, Resource > Class Template Reference

    Base class for resource loaders. - More...

    + More...

    #include <loader.hpp>

    entt::resource_handle< Resource >::operator const Resource & ( ) const - + @@ -230,12 +251,12 @@ template<typename Resource > An assertion will abort the execution at runtime in debug mode if the handle is empty.
    Returns
    A reference to the managed resource.
    -

    Definition at line 85 of file handle.hpp.

    +

    Definition at line 74 of file handle.hpp.

    - -

    ◆ operator->()

    + +

    ◆ operator->()

    @@ -246,7 +267,7 @@ template<typename Resource >
    @@ -59,18 +59,18 @@ $(function() {
    -
    entt::ResourceLoader< Loader, Resource > Member List
    +
    entt::resource_loader< Loader, Resource > Member List
    -

    This is the complete list of members for entt::ResourceLoader< Loader, Resource >, including all inherited members.

    +

    This is the complete list of members for entt::resource_loader< Loader, Resource >, including all inherited members.

    const Resource& entt::ResourceHandle< Resource >::operator* const Resource& entt::resource_handle< Resource >::operator* ( ) const - + @@ -264,73 +285,12 @@ template<typename Resource > An assertion will abort the execution at runtime in debug mode if the handle is empty.
    Returns
    A pointer to the managed resource or nullptr if the handle contains no resource at all.
    -

    Definition at line 98 of file handle.hpp.

    +

    Definition at line 87 of file handle.hpp.

    - -

    ◆ operator=() [1/2]

    - -
    -
    -
    -template<typename Resource >
    -
    const Resource* entt::ResourceHandle< Resource >::operator-> const Resource* entt::resource_handle< Resource >::operator-> ( ) const
    - - - - -
    - - - - - - - - -
    ResourceHandle& entt::ResourceHandle< Resource >::operator= (const ResourceHandle< Resource > & )
    -     		-default
    -
    - -

    Default copy assignment operator.

    -
    Returns
    This handle.
    - -
    - - -

    ◆ operator=() [2/2]

    - -
    -
    -
    -template<typename Resource >
    - - - - - -
    - - - - - - - - -
    ResourceHandle& entt::ResourceHandle< Resource >::operator= (ResourceHandle< Resource > && )
    -     		-default
    -
    - -

    Default move assignment operator.

    -
    Returns
    This handle.
    - -
    -
    -
    The documentation for this class was generated from the following file:
      +
      The documentation for this class was generated from the following files: diff --git a/classentt_1_1ResourceLoader-members.html b/classentt_1_1resource__loader-members.html similarity index 80% rename from classentt_1_1ResourceLoader-members.html rename to classentt_1_1resource__loader-members.html index 87d364c99..ae6f939d6 100644 --- a/classentt_1_1ResourceLoader-members.html +++ b/classentt_1_1resource__loader-members.html @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    - +
    ResourceCache< Resource > classentt::ResourceLoader< Loader, Resource >friend
    resource_cache< Resource > classentt::resource_loader< Loader, Resource >friend
    diff --git a/classentt_1_1ResourceLoader.html b/classentt_1_1resource__loader.html similarity index 68% rename from classentt_1_1ResourceLoader.html rename to classentt_1_1resource__loader.html index 19a2022e8..2fe78f241 100644 --- a/classentt_1_1ResourceLoader.html +++ b/classentt_1_1resource__loader.html @@ -5,7 +5,7 @@ -EnTT: entt::ResourceLoader< Loader, Resource > Class Template Reference +EnTT: entt::resource_loader< Loader, Resource > Class Template Reference @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    - - - + + +

    Friends

    -class ResourceCache< Resource >
     Resource loaders are friends of their caches.
     
    +class resource_cache< Resource >
     Resource loaders are friends of their caches.
     

    Detailed Description

    template<typename Loader, typename Resource>
    -class entt::ResourceLoader< Loader, Resource >

    +class entt::resource_loader< Loader, Resource >

    Base class for resource loaders.

    Resource loaders must inherit from this class and stay true to the CRTP idiom. Moreover, a resource loader must expose a public, const member function named load that accepts a variable number of arguments and returns a shared pointer to the resource just created.
    As an example:

    -
    struct MyResource {};
    struct MyLoader: entt::ResourceLoader<MyLoader, MyResource> {
    std::shared_ptr<MyResource> load(int) const {
    // use the integer value somehow
    return std::make_shared<MyResource>();
    }
    };

    In general, resource loaders should not have a state or retain data of any type. They should let the cache manage their resources instead.

    +
    struct my_resource {};
    struct my_loader: entt::resource_loader<my_loader, my_resource> {
    std::shared_ptr<my_resource> load(int) const {
    // use the integer value somehow
    return std::make_shared<my_resource>();
    }
    };

    In general, resource loaders should not have a state or retain data of any type. They should let the cache manage their resources instead.

    Note
    Base class and CRTP idiom aren't strictly required with the current implementation. One could argue that a cache can easily work with loaders of any type. However, future changes won't be breaking ones by forcing the use of a base class today and that's why the model is already in its place.
    Template Parameters
    @@ -100,8 +100,9 @@ class entt::ResourceLoader< Loader, Resource > -

    Definition at line 48 of file loader.hpp.

    -
    The documentation for this class was generated from the following file:
      +

      Definition at line 21 of file fwd.hpp.

      +
      The documentation for this class was generated from the following files: diff --git a/classentt_1_1Scheduler-members.html b/classentt_1_1scheduler-members.html similarity index 58% rename from classentt_1_1Scheduler-members.html rename to classentt_1_1scheduler-members.html index 42a97f261..106834d3a 100644 --- a/classentt_1_1Scheduler-members.html +++ b/classentt_1_1scheduler-members.html @@ -22,7 +22,7 @@
    @@ -59,30 +59,28 @@ $(function() {
    -
    entt::Scheduler< Delta > Member List
    +
    entt::scheduler< Delta > Member List
    -

    This is the complete list of members for entt::Scheduler< Delta >, including all inherited members.

    +

    This is the complete list of members for entt::scheduler< Delta >, including all inherited members.

    EnTT -  2.7.3 +  3.0.0
    - - - - - - - - - - - - - + + + + + + + + + + +
    abort(const bool immediately=false)entt::Scheduler< Delta >inline
    attach(Args &&... args)entt::Scheduler< Delta >inline
    attach(Func &&func)entt::Scheduler< Delta >inline
    clear()entt::Scheduler< Delta >inline
    empty() const ENTT_NOEXCEPTentt::Scheduler< Delta >inline
    operator=(const Scheduler &)=deleteentt::Scheduler< Delta >
    operator=(Scheduler &&)=defaultentt::Scheduler< Delta >
    Scheduler() ENTT_NOEXCEPT=defaultentt::Scheduler< Delta >
    Scheduler(const Scheduler &)=deleteentt::Scheduler< Delta >
    Scheduler(Scheduler &&)=defaultentt::Scheduler< Delta >
    size() const ENTT_NOEXCEPTentt::Scheduler< Delta >inline
    size_type typedefentt::Scheduler< Delta >
    update(const Delta delta, void *data=nullptr)entt::Scheduler< Delta >inline
    abort(const bool immediately=false)entt::scheduler< Delta >inline
    attach(Args &&... args)entt::scheduler< Delta >inline
    attach(Func &&func)entt::scheduler< Delta >inline
    clear()entt::scheduler< Delta >inline
    empty() const ENTT_NOEXCEPTentt::scheduler< Delta >inline
    operator=(scheduler &&)=defaultentt::scheduler< Delta >
    scheduler() ENTT_NOEXCEPT=defaultentt::scheduler< Delta >
    scheduler(scheduler &&)=defaultentt::scheduler< Delta >
    size() const ENTT_NOEXCEPTentt::scheduler< Delta >inline
    size_type typedefentt::scheduler< Delta >
    update(const Delta delta, void *data=nullptr)entt::scheduler< Delta >inline
    diff --git a/classentt_1_1Scheduler.html b/classentt_1_1scheduler.html similarity index 57% rename from classentt_1_1Scheduler.html rename to classentt_1_1scheduler.html index 961865b63..71ec5af22 100644 --- a/classentt_1_1Scheduler.html +++ b/classentt_1_1scheduler.html @@ -5,7 +5,7 @@ -EnTT: entt::Scheduler< Delta > Class Template Reference +EnTT: entt::scheduler< Delta > Class Template Reference @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    - - - + + +

    Public Types

    -using size_type = typename std::vector< ProcessHandler >::size_type
     Unsigned integer type.
     
    +using size_type = typename std::vector< process_handler >::size_type
     Unsigned integer type.
     
    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    Public Member Functions

    - Scheduler () ENTT_NOEXCEPT=default
     Default constructor.
     
    - Scheduler (const Scheduler &)=delete
     Copying a scheduler isn't allowed.
     
    - Scheduler (Scheduler &&)=default
     Default move constructor.
     
    Scheduler & operator= (const Scheduler &)=delete
     Copying a scheduler isn't allowed. More...
     
    Scheduler & operator= (Scheduler &&)=default
     Default move assignment operator. More...
     
    size_type size () const ENTT_NOEXCEPT
     Number of processes currently scheduled. More...
     
    bool empty () const ENTT_NOEXCEPT
     Returns true if at least a process is currently scheduled. More...
     
    void clear ()
     Discards all scheduled processes. More...
     
    template<typename Proc , typename... Args>
    auto attach (Args &&... args)
     Schedules a process for the next tick. More...
     
    template<typename Func >
    auto attach (Func &&func)
     Schedules a process for the next tick. More...
     
    void update (const Delta delta, void *data=nullptr)
     Updates all scheduled processes. More...
     
    void abort (const bool immediately=false)
     Aborts all scheduled processes. More...
     
    + scheduler () ENTT_NOEXCEPT=default
     Default constructor.
     
    + scheduler (scheduler &&)=default
     Default move constructor.
     
    scheduler & operator= (scheduler &&)=default
     Default move assignment operator. More...
     
    size_type size () const ENTT_NOEXCEPT
     Number of processes currently scheduled. More...
     
    bool empty () const ENTT_NOEXCEPT
     Returns true if at least a process is currently scheduled. More...
     
    void clear ()
     Discards all scheduled processes. More...
     
    template<typename Proc , typename... Args>
    auto attach (Args &&... args)
     Schedules a process for the next tick. More...
     
    template<typename Func >
    auto attach (Func &&func)
     Schedules a process for the next tick. More...
     
    void update (const Delta delta, void *data=nullptr)
     Updates all scheduled processes. More...
     
    void abort (const bool immediately=false)
     Aborts all scheduled processes. More...
     

    Detailed Description

    template<typename Delta>
    -class entt::Scheduler< Delta >

    +class entt::scheduler< Delta >

    Cooperative scheduler for processes.

    A cooperative scheduler runs processes and helps managing their life cycles.

    Each process is invoked once per tick. If a process terminates, it's removed automatically from the scheduler and it's never invoked again.
    A process can also have a child. In this case, the process is replaced with its child when it terminates if it returns with success. In case of errors, both the process and its child are discarded.

    Example of use (pseudocode):

    -
    scheduler.attach([](auto delta, void *, auto succeed, auto fail) {
    // code
    }).then<MyProcess>(arguments...);

    In order to invoke all scheduled processes, call the update member function passing it the elapsed time to forward to the tasks.

    -
    See also
    Process
    +
    scheduler.attach([](auto delta, void *, auto succeed, auto fail) {
    // code
    }).then<my_process>(arguments...);

    In order to invoke all scheduled processes, call the update member function passing it the elapsed time to forward to the tasks.

    +
    See also
    process
    Template Parameters
    @@ -149,19 +142,19 @@ class entt::Scheduler< Delta >

    Definition at line 44 of file scheduler.hpp.

    Member Function Documentation

    - -

    ◆ abort()

    + +

    ◆ abort()

    -template<typename Delta >
    +template<typename Delta>
    DeltaType to use to provide elapsed time.
    @@ -63,76 +63,106 @@ $(function() {

    - o -

    diff --git a/functions_func_p.html b/functions_func_p.html index 3ac69af0b..abd71374b 100644 --- a/functions_func_p.html +++ b/functions_func_p.html @@ -22,7 +22,7 @@ @@ -62,24 +62,32 @@ $(function() {  

    - p -

    diff --git a/functions_func_r.html b/functions_func_r.html index 92a7c711f..4b24fa208 100644 --- a/functions_func_r.html +++ b/functions_func_r.html @@ -22,7 +22,7 @@ @@ -63,57 +63,58 @@ $(function() {

    - r -

    diff --git a/functions_func_s.html b/functions_func_s.html index 830fea15b..6beaab942 100644 --- a/functions_func_s.html +++ b/functions_func_s.html @@ -22,7 +22,7 @@ @@ -62,57 +62,61 @@ $(function() {  

    - s -

    diff --git a/functions_func_t.html b/functions_func_t.html index 450f54f24..e72c93cd8 100644 --- a/functions_func_t.html +++ b/functions_func_t.html @@ -22,7 +22,7 @@ @@ -62,23 +62,37 @@ $(function() {  

    - t -

    diff --git a/functions_func_u.html b/functions_func_u.html index 263459f75..e703efbb5 100644 --- a/functions_func_u.html +++ b/functions_func_u.html @@ -22,7 +22,7 @@ @@ -63,15 +63,16 @@ $(function() {

    - u -

    diff --git a/functions_func_v.html b/functions_func_v.html index cf06482e1..a39684636 100644 --- a/functions_func_v.html +++ b/functions_func_v.html @@ -22,7 +22,7 @@ @@ -63,13 +63,17 @@ $(function() {

    - v -

    diff --git a/functions_g.html b/functions_g.html index 434a90b94..358f999b2 100644 --- a/functions_g.html +++ b/functions_g.html @@ -22,7 +22,7 @@ @@ -63,18 +63,24 @@ $(function() {

    - g -

    diff --git a/functions_h.html b/functions_h.html index aa45d4a60..acd60920e 100644 --- a/functions_h.html +++ b/functions_h.html @@ -22,7 +22,7 @@ @@ -63,20 +63,20 @@ $(function() {

    - h -

    diff --git a/functions_i.html b/functions_i.html index e4030596e..c944189f4 100644 --- a/functions_i.html +++ b/functions_i.html @@ -22,7 +22,7 @@ @@ -63,18 +63,71 @@ $(function() {

    - i -

    diff --git a/functions_k.html b/functions_k.html new file mode 100644 index 000000000..15968e828 --- /dev/null +++ b/functions_k.html @@ -0,0 +1,77 @@ + + + + + + + +EnTT: Class Members + + + + + + + + + +
    +
    +
    - + @@ -185,17 +178,17 @@ template<typename Delta > -

    Definition at line 291 of file scheduler.hpp.

    +

    Definition at line 280 of file scheduler.hpp.

    - -

    ◆ attach() [1/2]

    + +

    ◆ attach() [1/2]

    -template<typename Delta >
    +template<typename Delta>
    template<typename Proc , typename... Args>
    void entt::Scheduler< Delta >::abort void entt::scheduler< Delta >::abort ( const bool  immediately = false)
    @@ -203,7 +196,7 @@ template<typename Proc , typename... Args> @@ -63,7 +63,10 @@ $(function() {

    - l -

    diff --git a/functions_func_m.html b/functions_func_m.html index c50a4b6ea..ad2adaa3f 100644 --- a/functions_func_m.html +++ b/functions_func_m.html @@ -22,7 +22,7 @@ @@ -63,11 +63,37 @@ $(function() {

    - m -

    diff --git a/functions_func_n.html b/functions_func_n.html new file mode 100644 index 000000000..2eea4988f --- /dev/null +++ b/functions_func_n.html @@ -0,0 +1,79 @@ + + + + + + + +EnTT: Class Members - Functions + + + + + + + + + +
    +
    +
    - + @@ -220,7 +213,7 @@ template<typename Proc , typename... Args>

    Schedules a process for the next tick.

    Returned value is an opaque object that can be used to attach a child to the given process. The child is automatically scheduled when the process terminates and only if the process returns with success.

    Example of use (pseudocode):

    -
    // schedules a task in the form of a process class
    scheduler.attach<MyProcess>(arguments...)
    // appends a child in the form of a lambda function
    .then([](auto delta, void *, auto succeed, auto fail) {
    // code
    })
    // appends a child in the form of another process class
    .then<MyOtherProcess>();
    Template Parameters
    +
    // schedules a task in the form of a process class
    scheduler.attach<my_process>(arguments...)
    // appends a child in the form of a lambda function
    .then([](auto delta, void *, auto succeed, auto fail) {
    // code
    })
    // appends a child in the form of another process class
    .then<my_other_process>();
    Template Parameters
    auto entt::Scheduler< Delta >::attach auto entt::scheduler< Delta >::attach ( Args &&...  args)
    @@ -235,17 +228,17 @@ template<typename Proc , typename... Args>
    Returns
    An opaque object to use to concatenate processes.
    -

    Definition at line 188 of file scheduler.hpp.

    +

    Definition at line 177 of file scheduler.hpp.

    - -

    ◆ attach() [2/2]

    + +

    ◆ attach() [2/2]

    -template<typename Delta >
    +template<typename Delta>
    template<typename Func >
    ProcType of process to schedule.
    ArgsTypes of arguments to use to initialize the process.
    @@ -253,7 +246,7 @@ template<typename Func > @@ -63,34 +63,34 @@ $(function() {

    - a -

    diff --git a/functions_0x7e.html b/functions_0x7e.html index 1dffb8354..d40c82c4d 100644 --- a/functions_0x7e.html +++ b/functions_0x7e.html @@ -22,7 +22,7 @@ @@ -62,27 +62,26 @@ $(function() {
    Here is a list of all documented class members with links to the class documentation for each member:

    - ~ -

    diff --git a/functions_b.html b/functions_b.html index 4eb10204b..998993b20 100644 --- a/functions_b.html +++ b/functions_b.html @@ -22,7 +22,7 @@ @@ -62,13 +62,52 @@ $(function() {
    Here is a list of all documented class members with links to the class documentation for each member:

    - b -

    diff --git a/functions_c.html b/functions_c.html index 75b5e632c..4696185a0 100644 --- a/functions_c.html +++ b/functions_c.html @@ -22,7 +22,7 @@ @@ -62,85 +62,94 @@ $(function() {
    Here is a list of all documented class members with links to the class documentation for each member:

    - c -

    diff --git a/functions_d.html b/functions_d.html index 79f645615..9420aca4d 100644 --- a/functions_d.html +++ b/functions_d.html @@ -22,7 +22,7 @@ @@ -63,35 +63,36 @@ $(function() {

    - d -

    diff --git a/functions_e.html b/functions_e.html index 1a3fa6f54..3867477ed 100644 --- a/functions_e.html +++ b/functions_e.html @@ -22,7 +22,7 @@ @@ -63,49 +63,50 @@ $(function() {

    - e -

    diff --git a/functions_f.html b/functions_f.html index 4bd4b4724..0a181685f 100644 --- a/functions_f.html +++ b/functions_f.html @@ -22,7 +22,7 @@ @@ -63,14 +63,23 @@ $(function() {

    - f -

    diff --git a/functions_func.html b/functions_func.html index c5400101f..450ff393e 100644 --- a/functions_func.html +++ b/functions_func.html @@ -22,7 +22,7 @@ @@ -63,34 +63,34 @@ $(function() {

    - a -

    diff --git a/functions_func_0x7e.html b/functions_func_0x7e.html index 077b45d9f..a53537f4e 100644 --- a/functions_func_0x7e.html +++ b/functions_func_0x7e.html @@ -22,7 +22,7 @@ @@ -62,27 +62,26 @@ $(function() {  

    - ~ -

    diff --git a/functions_func_b.html b/functions_func_b.html index 7b607a591..f30aa53f4 100644 --- a/functions_func_b.html +++ b/functions_func_b.html @@ -22,7 +22,7 @@ @@ -62,13 +62,44 @@ $(function() {  

    - b -

    diff --git a/functions_func_c.html b/functions_func_c.html index 499f883e0..5b90271ec 100644 --- a/functions_func_c.html +++ b/functions_func_c.html @@ -22,7 +22,7 @@ @@ -62,71 +62,85 @@ $(function() {  

    - c -

    diff --git a/functions_func_d.html b/functions_func_d.html index ac6b7eddf..f8e165ff1 100644 --- a/functions_func_d.html +++ b/functions_func_d.html @@ -22,7 +22,7 @@ @@ -63,39 +63,43 @@ $(function() {

    - d -

    diff --git a/functions_func_e.html b/functions_func_e.html index bcf0560ce..c9a24a150 100644 --- a/functions_func_e.html +++ b/functions_func_e.html @@ -22,7 +22,7 @@ @@ -63,54 +63,56 @@ $(function() {

    - e -

    diff --git a/functions_func_f.html b/functions_func_f.html index 76a722cf1..11050393a 100644 --- a/functions_func_f.html +++ b/functions_func_f.html @@ -22,7 +22,7 @@ @@ -63,11 +63,17 @@ $(function() {

    - f -

    diff --git a/functions_func_g.html b/functions_func_g.html index 7038f4629..fd9a0eceb 100644 --- a/functions_func_g.html +++ b/functions_func_g.html @@ -22,7 +22,7 @@ @@ -63,18 +63,24 @@ $(function() {

    - g -

    diff --git a/functions_func_h.html b/functions_func_h.html index 4ccae51c7..9cf22401b 100644 --- a/functions_func_h.html +++ b/functions_func_h.html @@ -22,7 +22,7 @@ @@ -63,17 +63,17 @@ $(function() {

    - h -

    diff --git a/functions_func_i.html b/functions_func_i.html new file mode 100644 index 000000000..46da1dcb6 --- /dev/null +++ b/functions_func_i.html @@ -0,0 +1,123 @@ + + + + + + + +EnTT: Class Members - Functions + + + + + + + + + +
    +
    +
    - + @@ -270,16 +263,17 @@ template<typename Func >

    Schedules a process for the next tick.

    A process can be either a lambda or a functor. The scheduler wraps both of them in a process adaptor internally.
    The signature of the function call operator should be equivalent to the following:

    -
    void(Delta delta, auto succeed, auto fail);

    Where:

    +
    void(Delta delta, void *data, auto succeed, auto fail);

    Where:

    • delta is the elapsed time.
      • +
    • data is an opaque pointer to user data if any, nullptr otherwise.
    • succeed is a function to call when a process terminates with success.
    • fail is a function to call when a process terminates with errors.

    The signature of the function call operator of both succeed and fail is equivalent to the following:

    void();

    Returned value is an opaque object that can be used to attach a child to the given process. The child is automatically scheduled when the process terminates and only if the process returns with success.

    Example of use (pseudocode):

    -
    // schedules a task in the form of a lambda function
    scheduler.attach([](auto delta, void *, auto succeed, auto fail) {
    // code
    })
    // appends a child in the form of another lambda function
    .then([](auto delta, void *, auto succeed, auto fail) {
    // code
    })
    // appends a child in the form of a process class
    .then<MyProcess>(arguments...);
    See also
    ProcessAdaptor
    +
    // schedules a task in the form of a lambda function
    scheduler.attach([](auto delta, void *, auto succeed, auto fail) {
    // code
    })
    // appends a child in the form of another lambda function
    .then([](auto delta, void *, auto succeed, auto fail) {
    // code
    })
    // appends a child in the form of a process class
    .then<my_process>(arguments...);
    See also
    process_adaptor
    Template Parameters
    auto entt::Scheduler< Delta >::attach auto entt::scheduler< Delta >::attach ( Func &&  func)
    @@ -294,23 +288,23 @@ template<typename Func >
    Returns
    An opaque object to use to concatenate processes.
    -

    Definition at line 249 of file scheduler.hpp.

    +

    Definition at line 238 of file scheduler.hpp.

    - -

    ◆ clear()

    + +

    ◆ clear()

    -template<typename Delta >
    +template<typename Delta>
    FuncType of process to schedule.
    @@ -69,39 +69,49 @@ $(function() { - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + +
    - + @@ -326,23 +320,23 @@ template<typename Delta >

    Discards all scheduled processes.

    Processes aren't aborted. They are discarded along with their children and never executed again.

    -

    Definition at line 158 of file scheduler.hpp.

    +

    Definition at line 147 of file scheduler.hpp.

    - -

    ◆ empty()

    + +

    ◆ empty()

    -template<typename Delta >
    +template<typename Delta>
    void entt::Scheduler< Delta >::clear void entt::scheduler< Delta >::clear ( )
    @@ -67,27 +67,34 @@ $(function() {
    factory.hpp
    -
    1 #ifndef ENTT_META_FACTORY_HPP
    2 #define ENTT_META_FACTORY_HPP
    3 
    4 
    5 #include <array>
    6 #include <cassert>
    7 #include <cstddef>
    8 #include <utility>
    9 #include <algorithm>
    10 #include <type_traits>
    11 #include "../core/hashed_string.hpp"
    12 #include "meta.hpp"
    13 
    14 
    15 namespace entt {
    16 
    17 
    18 template<typename Key, typename Value>
    19 inline auto property(Key &&key, Value &&value) {
    20  return std::make_pair(key, value);
    21 }
    22 
    23 
    24 class Meta final {
    25  template<typename Type, typename = void>
    26  struct MetaFactory {
    27  template<typename Func, Func *Ptr, typename... Property>
    28  static auto ctor(Property &&... property) ENTT_NOEXCEPT {
    29  using helper_type = internal::ReflectionHelper<std::integral_constant<Func *, Ptr>>;
    30  static_assert(std::is_same<typename helper_type::return_type, Type>::value, "!");
    31  auto * const type = internal::MetaInfo<Type>::type;
    32 
    33  static internal::MetaCtorNode node{
    34  type->ctor,
    35  properties<Type, typename helper_type::args_type>(std::forward<Property>(property)...),
    36  helper_type::size,
    37  &helper_type::arg,
    38  &helper_type::accept,
    39  [](const MetaAny * const any) {
    40  return helper_type::invoke(0, nullptr, any, std::make_index_sequence<helper_type::size>{});
    41  },
    42  []() {
    43  static MetaCtor meta{&node};
    44  return &meta;
    45  }
    46  };
    47 
    48  assert((!internal::MetaInfo<Type>::template ctor<typename helper_type::args_type>));
    49  internal::MetaInfo<Type>::template ctor<typename helper_type::args_type> = &node;
    50  type->ctor = &node;
    51  return MetaFactory<Type>{};
    52  }
    53 
    54  template<typename... Args, typename... Property>
    55  static auto ctor(Property &&... property) ENTT_NOEXCEPT {
    56  using helper_type = internal::FunctionHelper<void(Args...)>;
    57  auto * const type = internal::MetaInfo<Type>::type;
    58 
    59  static internal::MetaCtorNode node{
    60  type->ctor,
    61  properties<Type, typename helper_type::args_type>(std::forward<Property>(property)...),
    62  helper_type::size,
    63  &helper_type::arg,
    64  &helper_type::accept,
    65  [](const MetaAny * const any) {
    66  return internal::CtorHelper<Type, Args...>::construct(any, std::make_index_sequence<helper_type::size>{});
    67  },
    68  []() {
    69  static MetaCtor meta{&node};
    70  return &meta;
    71  }
    72  };
    73 
    74  assert((!internal::MetaInfo<Type>::template ctor<typename helper_type::args_type>));
    75  internal::MetaInfo<Type>::template ctor<typename helper_type::args_type> = &node;
    76  type->ctor = &node;
    77  return MetaFactory<Type>{};
    78  }
    79 
    80  template<void(*Func)(Type &), typename... Property>
    81  static auto dtor(Property &&... property) ENTT_NOEXCEPT {
    82  static internal::MetaDtorNode node{
    83  properties<Type, std::integral_constant<void(*)(Type &), Func>>(std::forward<Property>(property)...),
    84  [](void *instance) {
    85  (*Func)(*static_cast<Type *>(instance));
    86  },
    87  []() {
    88  static MetaDtor meta{&node};
    89  return &meta;
    90  }
    91  };
    92 
    93  assert(!internal::MetaInfo<Type>::type->dtor);
    94  assert((!internal::MetaInfo<Type>::template dtor<std::integral_constant<void(*)(Type &), Func>>));
    95  internal::MetaInfo<Type>::template dtor<std::integral_constant<void(*)(Type &), Func>> = &node;
    96  internal::MetaInfo<Type>::type->dtor = &node;
    97  return MetaFactory<Type>{};
    98  }
    99 
    100  template<typename Data, Data *Ptr, typename... Property>
    101  static auto data(const char *str, Property &&... property) ENTT_NOEXCEPT {
    102  using helper_type = internal::ReflectionHelper<std::integral_constant<Data *, Ptr>>;
    103  auto * const type = internal::MetaInfo<Type>::type;
    104 
    105  static internal::MetaDataNode node{
    106  HashedString{str},
    107  type->data,
    108  properties<Type, std::integral_constant<Data *, Ptr>>(std::forward<Property>(property)...),
    109  helper_type::readonly,
    110  helper_type::shared,
    111  &internal::MetaInfo<Data>::resolve,
    112  &helper_type::setter,
    113  [](const void *) {
    114  return MetaAny{*Ptr};
    115  },
    116  [](const internal::MetaTypeNode * const other) {
    117  return other == internal::MetaInfo<Data>::resolve();
    118  },
    119  []() {
    120  static MetaData meta{&node};
    121  return &meta;
    122  }
    123  };
    124 
    125  assert(!duplicate(HashedString{str}, node.next));
    126  assert((!internal::MetaInfo<Type>::template data<std::integral_constant<Data *, Ptr>>));
    127  internal::MetaInfo<Type>::template data<std::integral_constant<Data *, Ptr>> = &node;
    128  type->data = &node;
    129  return MetaFactory<Type>{};
    130  }
    131 
    132  template<typename Func, Func *Ptr, typename... Property>
    133  static auto func(const char *str, Property &&... property) ENTT_NOEXCEPT {
    134  using helper_type = internal::ReflectionHelper<std::integral_constant<Func *, Ptr>>;
    135  auto * const type = internal::MetaInfo<Type>::type;
    136 
    137  static internal::MetaFuncNode node{
    138  HashedString{str},
    139  type->func,
    140  properties<Type, std::integral_constant<Func *, Ptr>>(std::forward<Property>(property)...),
    141  helper_type::size,
    142  helper_type::constant,
    143  helper_type::shared,
    144  &internal::MetaInfo<typename helper_type::return_type>::resolve,
    145  &helper_type::arg,
    146  &helper_type::accept,
    147  [](const void *instance, const MetaAny *any) {
    148  return helper_type::invoke(0, instance, any, std::make_index_sequence<helper_type::size>{});
    149  },
    150  [](void *instance, const MetaAny *any) {
    151  return helper_type::invoke(0, instance, any, std::make_index_sequence<helper_type::size>{});
    152  },
    153  []() {
    154  static MetaFunc meta{&node};
    155  return &meta;
    156  }
    157  };
    158 
    159  assert(!duplicate(HashedString{str}, node.next));
    160  assert((!internal::MetaInfo<Type>::template func<std::integral_constant<Func *, Ptr>>));
    161  internal::MetaInfo<Type>::template func<std::integral_constant<Func *, Ptr>> = &node;
    162  type->func = &node;
    163  return MetaFactory<Type>{};
    164  }
    165  };
    166 
    167  template<typename Class>
    168  struct MetaFactory<Class, std::enable_if_t<std::is_class<Class>::value>>: MetaFactory<Class, Class> {
    169  using MetaFactory<Class, Class>::func;
    170 
    171  template<typename Type, Type Class:: *Member, typename... Property>
    172  static std::enable_if_t<std::is_member_object_pointer<Type Class:: *>::value, MetaFactory<Class>>
    173  member(const char *str, Property &&... property) ENTT_NOEXCEPT {
    174  using helper_type = internal::ReflectionHelper<std::integral_constant<Type Class:: *, Member>>;
    175  auto * const type = internal::MetaInfo<Class>::type;
    176 
    177  static internal::MetaDataNode node{
    178  HashedString{str},
    179  type->data,
    180  properties<Class, std::integral_constant<Type Class:: *, Member>>(std::forward<Property>(property)...),
    181  helper_type::readonly,
    182  helper_type::shared,
    183  &internal::MetaInfo<Type>::resolve,
    184  &helper_type::setter,
    185  [](const void *instance) {
    186  return MetaAny{static_cast<const Class *>(instance)->*Member};
    187  },
    188  [](const internal::MetaTypeNode * const other) {
    189  return other == internal::MetaInfo<Type>::resolve();
    190  },
    191  []() {
    192  static MetaData meta{&node};
    193  return &meta;
    194  }
    195  };
    196 
    197  assert(!duplicate(HashedString{str}, node.next));
    198  assert((!internal::MetaInfo<Class>::template data<std::integral_constant<Type Class:: *, Member>>));
    199  internal::MetaInfo<Class>::template data<std::integral_constant<Type Class:: *, Member>> = &node;
    200  type->data = &node;
    201  return MetaFactory<Class>{};
    202  }
    203 
    204  template<typename Type, Type Class:: *Member, typename... Property>
    205  static std::enable_if_t<std::is_member_function_pointer<Type Class:: *>::value, MetaFactory<Class>>
    206  member(const char *str, Property &&... property) ENTT_NOEXCEPT {
    207  using helper_type = internal::ReflectionHelper<std::integral_constant<Type Class:: *, Member>>;
    208  auto * const type = internal::MetaInfo<Class>::type;
    209 
    210  static internal::MetaFuncNode node{
    211  HashedString{str},
    212  type->func,
    213  properties<Class, std::integral_constant<Type Class:: *, Member>>(std::forward<Property>(property)...),
    214  helper_type::size,
    215  helper_type::constant,
    216  helper_type::shared,
    217  &internal::MetaInfo<typename helper_type::return_type>::resolve,
    218  &helper_type::arg,
    219  &helper_type::accept,
    220  [](const void *instance, const MetaAny *any) {
    221  return helper_type::invoke(0, instance, any, std::make_index_sequence<helper_type::size>{});
    222  },
    223  [](void *instance, const MetaAny *any) {
    224  return helper_type::invoke(0, instance, any, std::make_index_sequence<helper_type::size>{});
    225  },
    226  []() {
    227  static MetaFunc meta{&node};
    228  return &meta;
    229  }
    230  };
    231 
    232  assert(!duplicate(HashedString{str}, node.next));
    233  assert((!internal::MetaInfo<Class>::template func<std::integral_constant<Type Class:: *, Member>>));
    234  internal::MetaInfo<Class>::template func<std::integral_constant<Type Class:: *, Member>> = &node;
    235  type->func = &node;
    236  return MetaFactory<Class>{};
    237  }
    238  };
    239 
    240  template<typename Name, typename Node>
    241  inline static bool duplicate(const Name &name, const Node *node) ENTT_NOEXCEPT {
    242  return node ? node->name == name || duplicate(name, node->next) : false;
    243  }
    244 
    245  inline static bool duplicate(const MetaAny &key, const internal::MetaPropNode *node) ENTT_NOEXCEPT {
    246  return node ? node->key() == key || duplicate(key, node->next) : false;
    247  }
    248 
    249  template<typename...>
    250  static internal::MetaPropNode * properties() {
    251  return nullptr;
    252  }
    253 
    254  template<typename Type, typename Owner, typename Property, typename... Other>
    255  static internal::MetaPropNode * properties(const Property &property, const Other &... other) {
    256  static const MetaAny key{property.first};
    257  static const MetaAny value{property.second};
    258 
    259  static internal::MetaPropNode node{
    260  properties<Type, Owner>(other...),
    261  []() -> const MetaAny & {
    262  return key;
    263  },
    264  []() -> const MetaAny & {
    265  return value;
    266  },
    267  []() {
    268  static MetaProp meta{&node};
    269  return &meta;
    270  }
    271  };
    272 
    273  assert(!duplicate(key, node.next));
    274  assert((!internal::MetaInfo<Type>::template prop<Owner, Property, Other...>));
    275  internal::MetaInfo<Type>::template prop<Owner, Property, Other...> = &node;
    276  return &node;
    277  }
    278 
    279  template<typename Type, typename... Property>
    280  static MetaFactory<Type> reflect(HashedString name, Property &&... property) ENTT_NOEXCEPT {
    281  static internal::MetaTypeNode node{
    282  name,
    283  internal::MetaInfo<>::type,
    284  properties<Type, Type>(std::forward<Property>(property)...),
    285  internal::TypeHelper<Type>::destroy,
    286  []() {
    287  static MetaType meta{&node};
    288  return &meta;
    289  }
    290  };
    291 
    292  assert(!duplicate(name, node.next));
    293  assert(!internal::MetaInfo<Type>::type);
    294  internal::MetaInfo<Type>::type = &node;
    295  internal::MetaInfo<>::type = &node;
    296  return MetaFactory<Type>{};
    297  }
    298 
    299 public:
    300  template<typename Type>
    301  using factory_type = MetaFactory<Type>;
    302 
    303  template<typename Type, typename... Property>
    304  inline static factory_type<std::decay_t<Type>> reflect(const char *str, Property &&... property) ENTT_NOEXCEPT {
    305  return reflect<std::decay_t<Type>>(HashedString{str}, std::forward<Property>(property)...);
    306  }
    307 
    308  template<typename Type>
    309  inline static MetaType * resolve() ENTT_NOEXCEPT {
    310  return internal::MetaInfo<Type>::resolve()->meta();
    311  }
    312 
    313  inline static MetaType * resolve(const char *str) ENTT_NOEXCEPT {
    314  return internal::Utils::meta(HashedString{str}, internal::MetaInfo<>::type);
    315  }
    316 };
    317 
    318 
    319 }
    320 
    321 
    322 #endif // ENTT_META_FACTORY_HPP
    - - - - - +
    1 #ifndef ENTT_META_FACTORY_HPP
    2 #define ENTT_META_FACTORY_HPP
    3 
    4 
    5 #include <utility>
    6 #include <algorithm>
    7 #include <type_traits>
    8 #include "../config/config.h"
    9 #include "../core/hashed_string.hpp"
    10 #include "meta.hpp"
    11 
    12 
    13 namespace entt {
    14 
    15 
    16 template<typename>
    17 class meta_factory;
    18 
    19 
    20 template<typename Type, typename... Property>
    21 meta_factory<Type> reflect(const char *str, Property &&... property) ENTT_NOEXCEPT;
    22 
    23 
    24 template<typename Type>
    25 bool unregister() ENTT_NOEXCEPT;
    26 
    27 
    38 template<typename Type>
    39 class meta_factory {
    40  static_assert(std::is_object_v<Type> && !(std::is_const_v<Type> || std::is_volatile_v<Type>));
    41 
    42  template<typename Node>
    43  inline bool duplicate(const hashed_string &name, const Node *node) ENTT_NOEXCEPT {
    44  return node ? node->name == name || duplicate(name, node->next) : false;
    45  }
    46 
    47  inline bool duplicate(const meta_any &key, const internal::meta_prop_node *node) ENTT_NOEXCEPT {
    48  return node ? node->key() == key || duplicate(key, node->next) : false;
    49  }
    50 
    51  template<typename>
    52  internal::meta_prop_node * properties() {
    53  return nullptr;
    54  }
    55 
    56  template<typename Owner, typename Property, typename... Other>
    57  internal::meta_prop_node * properties(Property &&property, Other &&... other) {
    58  static std::remove_cv_t<std::remove_reference_t<Property>> prop{};
    59 
    60  static internal::meta_prop_node node{
    61  nullptr,
    62  []() -> meta_any {
    63  return std::get<0>(prop);
    64  },
    65  []() -> meta_any {
    66  return std::get<1>(prop);
    67  },
    68  []() -> meta_prop {
    69  return &node;
    70  }
    71  };
    72 
    73  prop = std::forward<Property>(property);
    74  node.next = properties<Owner>(std::forward<Other>(other)...);
    75  ENTT_ASSERT(!duplicate(meta_any{std::get<0>(prop)}, node.next));
    76  return &node;
    77  }
    78 
    79  template<typename... Property>
    80  meta_factory type(hashed_string name, Property &&... property) ENTT_NOEXCEPT {
    81  static internal::meta_type_node node{
    82  {},
    83  nullptr,
    84  nullptr,
    85  std::is_void_v<Type>,
    86  std::is_integral_v<Type>,
    87  std::is_floating_point_v<Type>,
    88  std::is_array_v<Type>,
    89  std::is_enum_v<Type>,
    90  std::is_union_v<Type>,
    91  std::is_class_v<Type>,
    92  std::is_pointer_v<Type>,
    93  std::is_function_v<Type>,
    94  std::is_member_object_pointer_v<Type>,
    95  std::is_member_function_pointer_v<Type>,
    96  std::extent_v<Type>,
    97  []() -> meta_type {
    98  return internal::meta_info<std::remove_pointer_t<Type>>::resolve();
    99  },
    100  &internal::destroy<Type>,
    101  []() -> meta_type {
    102  return &node;
    103  }
    104  };
    105 
    106  node.name = name;
    107  node.next = internal::meta_info<>::type;
    108  node.prop = properties<Type>(std::forward<Property>(property)...);
    109  ENTT_ASSERT(!duplicate(name, node.next));
    110  ENTT_ASSERT(!internal::meta_info<Type>::type);
    111  internal::meta_info<Type>::type = &node;
    112  internal::meta_info<>::type = &node;
    113 
    114  return *this;
    115  }
    116 
    117  void unregister_prop(internal::meta_prop_node **prop) {
    118  while(*prop) {
    119  auto *node = *prop;
    120  *prop = node->next;
    121  node->next = nullptr;
    122  }
    123  }
    124 
    125  void unregister_dtor() {
    126  if(auto node = internal::meta_info<Type>::type->dtor; node) {
    127  internal::meta_info<Type>::type->dtor = nullptr;
    128  *node->underlying = nullptr;
    129  }
    130  }
    131 
    132  template<auto Member>
    133  auto unregister_all(int)
    134  -> decltype((internal::meta_info<Type>::type->*Member)->prop, void()) {
    135  while(internal::meta_info<Type>::type->*Member) {
    136  auto node = internal::meta_info<Type>::type->*Member;
    137  internal::meta_info<Type>::type->*Member = node->next;
    138  unregister_prop(&node->prop);
    139  node->next = nullptr;
    140  *node->underlying = nullptr;
    141  }
    142  }
    143 
    144  template<auto Member>
    145  void unregister_all(char) {
    146  while(internal::meta_info<Type>::type->*Member) {
    147  auto node = internal::meta_info<Type>::type->*Member;
    148  internal::meta_info<Type>::type->*Member = node->next;
    149  node->next = nullptr;
    150  *node->underlying = nullptr;
    151  }
    152  }
    153 
    154  bool unregister() ENTT_NOEXCEPT {
    155  const auto registered = internal::meta_info<Type>::type;
    156 
    157  if(registered) {
    158  if(auto *curr = internal::meta_info<>::type; curr == internal::meta_info<Type>::type) {
    159  internal::meta_info<>::type = internal::meta_info<Type>::type->next;
    160  } else {
    161  while(curr && curr->next != internal::meta_info<Type>::type) {
    162  curr = curr->next;
    163  }
    164 
    165  if(curr) {
    166  curr->next = internal::meta_info<Type>::type->next;
    167  }
    168  }
    169 
    170  unregister_prop(&internal::meta_info<Type>::type->prop);
    171  unregister_all<&internal::meta_type_node::base>(0);
    172  unregister_all<&internal::meta_type_node::conv>(0);
    173  unregister_all<&internal::meta_type_node::ctor>(0);
    174  unregister_all<&internal::meta_type_node::data>(0);
    175  unregister_all<&internal::meta_type_node::func>(0);
    176  unregister_dtor();
    177 
    178  internal::meta_info<Type>::type->name = {};
    179  internal::meta_info<Type>::type->next = nullptr;
    180  internal::meta_info<Type>::type = nullptr;
    181  }
    182 
    183  return registered;
    184  }
    185 
    186  meta_factory() ENTT_NOEXCEPT = default;
    187 
    188 public:
    189  template<typename Other, typename... Property>
    190  friend meta_factory<Other> reflect(const char *str, Property &&... property) ENTT_NOEXCEPT;
    191 
    192  template<typename Other>
    193  friend bool unregister() ENTT_NOEXCEPT;
    194 
    203  template<typename Base>
    204  meta_factory base() ENTT_NOEXCEPT {
    205  static_assert(std::is_base_of_v<Base, Type>);
    206  auto * const type = internal::meta_info<Type>::resolve();
    207 
    208  static internal::meta_base_node node{
    209  &internal::meta_info<Type>::template base<Base>,
    210  type,
    211  nullptr,
    212  &internal::meta_info<Base>::resolve,
    213  [](void *instance) -> void * {
    214  return static_cast<Base *>(static_cast<Type *>(instance));
    215  },
    216  []() -> meta_base {
    217  return &node;
    218  }
    219  };
    220 
    221  node.next = type->base;
    222  ENTT_ASSERT((!internal::meta_info<Type>::template base<Base>));
    223  internal::meta_info<Type>::template base<Base> = &node;
    224  type->base = &node;
    225 
    226  return *this;
    227  }
    228 
    238  template<typename To>
    239  meta_factory conv() ENTT_NOEXCEPT {
    240  static_assert(std::is_convertible_v<Type, To>);
    241  auto * const type = internal::meta_info<Type>::resolve();
    242 
    243  static internal::meta_conv_node node{
    244  &internal::meta_info<Type>::template conv<To>,
    245  type,
    246  nullptr,
    247  &internal::meta_info<To>::resolve,
    248  [](void *instance) -> meta_any {
    249  return static_cast<To>(*static_cast<Type *>(instance));
    250  },
    251  []() -> meta_conv {
    252  return &node;
    253  }
    254  };
    255 
    256  node.next = type->conv;
    257  ENTT_ASSERT((!internal::meta_info<Type>::template conv<To>));
    258  internal::meta_info<Type>::template conv<To> = &node;
    259  type->conv = &node;
    260 
    261  return *this;
    262  }
    263 
    278  template<auto Func, typename... Property>
    279  meta_factory ctor(Property &&... property) ENTT_NOEXCEPT {
    280  using helper_type = internal::meta_function_helper<std::integral_constant<decltype(Func), Func>>;
    281  static_assert(std::is_same_v<typename helper_type::return_type, Type>);
    282  auto * const type = internal::meta_info<Type>::resolve();
    283 
    284  static internal::meta_ctor_node node{
    285  &internal::meta_info<Type>::template ctor<typename helper_type::args_type>,
    286  type,
    287  nullptr,
    288  nullptr,
    289  helper_type::size,
    290  &helper_type::arg,
    291  [](meta_any * const any) {
    292  return internal::invoke<Type, Func>(nullptr, any, std::make_index_sequence<helper_type::size>{});
    293  },
    294  []() -> meta_ctor {
    295  return &node;
    296  }
    297  };
    298 
    299  node.next = type->ctor;
    300  node.prop = properties<typename helper_type::args_type>(std::forward<Property>(property)...);
    301  ENTT_ASSERT((!internal::meta_info<Type>::template ctor<typename helper_type::args_type>));
    302  internal::meta_info<Type>::template ctor<typename helper_type::args_type> = &node;
    303  type->ctor = &node;
    304 
    305  return *this;
    306  }
    307 
    320  template<typename... Args, typename... Property>
    321  meta_factory ctor(Property &&... property) ENTT_NOEXCEPT {
    322  using helper_type = internal::meta_function_helper<Type(Args...)>;
    323  auto * const type = internal::meta_info<Type>::resolve();
    324 
    325  static internal::meta_ctor_node node{
    326  &internal::meta_info<Type>::template ctor<typename helper_type::args_type>,
    327  type,
    328  nullptr,
    329  nullptr,
    330  helper_type::size,
    331  &helper_type::arg,
    332  [](meta_any * const any) {
    333  return internal::construct<Type, Args...>(any, std::make_index_sequence<helper_type::size>{});
    334  },
    335  []() -> meta_ctor {
    336  return &node;
    337  }
    338  };
    339 
    340  node.next = type->ctor;
    341  node.prop = properties<typename helper_type::args_type>(std::forward<Property>(property)...);
    342  ENTT_ASSERT((!internal::meta_info<Type>::template ctor<typename helper_type::args_type>));
    343  internal::meta_info<Type>::template ctor<typename helper_type::args_type> = &node;
    344  type->ctor = &node;
    345 
    346  return *this;
    347  }
    348 
    365  template<auto *Func>
    366  meta_factory dtor() ENTT_NOEXCEPT {
    367  static_assert(std::is_invocable_v<decltype(Func), Type *>);
    368  auto * const type = internal::meta_info<Type>::resolve();
    369 
    370  static internal::meta_dtor_node node{
    371  &internal::meta_info<Type>::template dtor<Func>,
    372  type,
    373  [](meta_handle handle) {
    374  return handle.type() == internal::meta_info<Type>::resolve()->meta()
    375  ? ((*Func)(static_cast<Type *>(handle.data())), true)
    376  : false;
    377  },
    378  []() -> meta_dtor {
    379  return &node;
    380  }
    381  };
    382 
    383  ENTT_ASSERT(!internal::meta_info<Type>::type->dtor);
    384  ENTT_ASSERT((!internal::meta_info<Type>::template dtor<Func>));
    385  internal::meta_info<Type>::template dtor<Func> = &node;
    386  internal::meta_info<Type>::type->dtor = &node;
    387 
    388  return *this;
    389  }
    390 
    405  template<auto Data, typename... Property>
    406  meta_factory data(const char *str, Property &&... property) ENTT_NOEXCEPT {
    407  auto * const type = internal::meta_info<Type>::resolve();
    408  internal::meta_data_node *curr = nullptr;
    409 
    410  if constexpr(std::is_same_v<Type, decltype(Data)>) {
    411  static internal::meta_data_node node{
    412  &internal::meta_info<Type>::template data<Data>,
    413  {},
    414  type,
    415  nullptr,
    416  nullptr,
    417  true,
    418  true,
    419  &internal::meta_info<Type>::resolve,
    420  [](meta_handle, meta_any, meta_any) { return false; },
    421  [](meta_handle, meta_any) -> meta_any { return Data; },
    422  []() -> meta_data {
    423  return &node;
    424  }
    425  };
    426 
    427  node.prop = properties<std::integral_constant<Type, Data>>(std::forward<Property>(property)...);
    428  curr = &node;
    429  } else if constexpr(std::is_member_object_pointer_v<decltype(Data)>) {
    430  using data_type = std::remove_reference_t<decltype(std::declval<Type>().*Data)>;
    431 
    432  static internal::meta_data_node node{
    433  &internal::meta_info<Type>::template data<Data>,
    434  {},
    435  type,
    436  nullptr,
    437  nullptr,
    438  std::is_const_v<data_type>,
    439  !std::is_member_object_pointer_v<decltype(Data)>,
    440  &internal::meta_info<data_type>::resolve,
    441  &internal::setter<std::is_const_v<data_type>, Type, Data>,
    442  &internal::getter<Type, Data>,
    443  []() -> meta_data {
    444  return &node;
    445  }
    446  };
    447 
    448  node.prop = properties<std::integral_constant<decltype(Data), Data>>(std::forward<Property>(property)...);
    449  curr = &node;
    450  } else {
    451  static_assert(std::is_pointer_v<decltype(Data)>);
    452  using data_type = std::remove_pointer_t<decltype(Data)>;
    453 
    454  static internal::meta_data_node node{
    455  &internal::meta_info<Type>::template data<Data>,
    456  {},
    457  type,
    458  nullptr,
    459  nullptr,
    460  std::is_const_v<data_type>,
    461  !std::is_member_object_pointer_v<decltype(Data)>,
    462  &internal::meta_info<data_type>::resolve,
    463  &internal::setter<std::is_const_v<data_type>, Type, Data>,
    464  &internal::getter<Type, Data>,
    465  []() -> meta_data {
    466  return &node;
    467  }
    468  };
    469 
    470  node.prop = properties<std::integral_constant<decltype(Data), Data>>(std::forward<Property>(property)...);
    471  curr = &node;
    472  }
    473 
    474  curr->name = hashed_string{str};
    475  curr->next = type->data;
    476  ENTT_ASSERT(!duplicate(hashed_string{str}, curr->next));
    477  ENTT_ASSERT((!internal::meta_info<Type>::template data<Data>));
    478  internal::meta_info<Type>::template data<Data> = curr;
    479  type->data = curr;
    480 
    481  return *this;
    482  }
    483 
    505  template<auto Setter, auto Getter, typename... Property>
    506  meta_factory data(const char *str, Property &&... property) ENTT_NOEXCEPT {
    507  using owner_type = std::tuple<std::integral_constant<decltype(Setter), Setter>, std::integral_constant<decltype(Getter), Getter>>;
    508  using underlying_type = std::invoke_result_t<decltype(Getter), Type *>;
    509  static_assert(std::is_invocable_v<decltype(Setter), Type *, underlying_type>);
    510  auto * const type = internal::meta_info<Type>::resolve();
    511 
    512  static internal::meta_data_node node{
    513  &internal::meta_info<Type>::template data<Setter, Getter>,
    514  {},
    515  type,
    516  nullptr,
    517  nullptr,
    518  false,
    519  false,
    520  &internal::meta_info<underlying_type>::resolve,
    521  &internal::setter<false, Type, Setter>,
    522  &internal::getter<Type, Getter>,
    523  []() -> meta_data {
    524  return &node;
    525  }
    526  };
    527 
    528  node.name = hashed_string{str};
    529  node.next = type->data;
    530  node.prop = properties<owner_type>(std::forward<Property>(property)...);
    531  ENTT_ASSERT(!duplicate(hashed_string{str}, node.next));
    532  ENTT_ASSERT((!internal::meta_info<Type>::template data<Setter, Getter>));
    533  internal::meta_info<Type>::template data<Setter, Getter> = &node;
    534  type->data = &node;
    535 
    536  return *this;
    537  }
    538 
    553  template<auto Func, typename... Property>
    554  meta_factory func(const char *str, Property &&... property) ENTT_NOEXCEPT {
    555  using owner_type = std::integral_constant<decltype(Func), Func>;
    556  using func_type = internal::meta_function_helper<std::integral_constant<decltype(Func), Func>>;
    557  auto * const type = internal::meta_info<Type>::resolve();
    558 
    559  static internal::meta_func_node node{
    560  &internal::meta_info<Type>::template func<Func>,
    561  {},
    562  type,
    563  nullptr,
    564  nullptr,
    565  func_type::size,
    566  func_type::is_const,
    567  func_type::is_static,
    568  &internal::meta_info<typename func_type::return_type>::resolve,
    569  &func_type::arg,
    570  [](meta_handle handle, meta_any *any) {
    571  return internal::invoke<Type, Func>(handle, any, std::make_index_sequence<func_type::size>{});
    572  },
    573  []() -> meta_func {
    574  return &node;
    575  }
    576  };
    577 
    578  node.name = hashed_string{str};
    579  node.next = type->func;
    580  node.prop = properties<owner_type>(std::forward<Property>(property)...);
    581  ENTT_ASSERT(!duplicate(hashed_string{str}, node.next));
    582  ENTT_ASSERT((!internal::meta_info<Type>::template func<Func>));
    583  internal::meta_info<Type>::template func<Func> = &node;
    584  type->func = &node;
    585 
    586  return *this;
    587  }
    588 };
    589 
    590 
    605 template<typename Type, typename... Property>
    606 inline meta_factory<Type> reflect(const char *str, Property &&... property) ENTT_NOEXCEPT {
    607  return meta_factory<Type>{}.type(hashed_string{str}, std::forward<Property>(property)...);
    608 }
    609 
    610 
    622 template<typename Type>
    623 inline meta_factory<Type> reflect() ENTT_NOEXCEPT {
    624  return meta_factory<Type>{};
    625 }
    626 
    627 
    640 template<typename Type>
    641 inline bool unregister() ENTT_NOEXCEPT {
    642  return meta_factory<Type>().unregister();
    643 }
    644 
    645 
    651 template<typename Type>
    652 inline meta_type resolve() ENTT_NOEXCEPT {
    653  return internal::meta_info<Type>::resolve()->meta();
    654 }
    655 
    656 
    662 inline meta_type resolve(const char *str) ENTT_NOEXCEPT {
    663  const auto *curr = internal::find_if([name = hashed_string{str}](auto *node) {
    664  return node->name == name;
    665  }, internal::meta_info<>::type);
    666 
    667  return curr ? curr->meta() : meta_type{};
    668 }
    669 
    670 
    676 template<typename Op>
    677 void resolve(Op op) ENTT_NOEXCEPT {
    678  internal::iterate([op = std::move(op)](auto *node) {
    679  op(node->meta());
    680  }, internal::meta_info<>::type);
    681 }
    682 
    683 
    684 }
    685 
    686 
    687 #endif // ENTT_META_FACTORY_HPP
    entt::meta_data::name
    const char * name() const ENTT_NOEXCEPT
    Returns the name assigned to a given meta data.
    Definition: meta.hpp:1182
    +
    entt::resolve
    meta_type resolve() ENTT_NOEXCEPT
    Returns the meta type associated with a given type.
    Definition: factory.hpp:652
    +
    entt::meta_factory::ctor
    meta_factory ctor(Property &&... property) ENTT_NOEXCEPT
    Assigns a meta constructor to a meta type.
    Definition: factory.hpp:279
    +
    entt::reflect
    meta_factory< Type > reflect(const char *str, Property &&... property) ENTT_NOEXCEPT
    Basic function to use for reflection.
    Definition: factory.hpp:606
    entt
    EnTT default namespace.
    Definition: algorithm.hpp:10
    - - - -
    entt::HashedString
    Zero overhead resource identifier.
    Definition: hashed_string.hpp:22
    - - - - - - - - - - +
    entt::hashed_string
    Zero overhead unique identifier.
    Definition: hashed_string.hpp:57
    +
    entt::meta_func::name
    const char * name() const ENTT_NOEXCEPT
    Returns the name assigned to a given meta function.
    Definition: meta.hpp:1376
    +
    entt::meta_data::prop
    std::enable_if_t< std::is_invocable_v< Op, meta_prop >, void > prop(Op op) const ENTT_NOEXCEPT
    Iterates all the properties assigned to a meta data.
    Definition: meta.hpp:1293
    +
    entt::unregister
    bool unregister() ENTT_NOEXCEPT
    Basic function to unregister a type.
    Definition: factory.hpp:641
    +
    entt::meta_handle
    Meta handle object.
    Definition: meta.hpp:636
    +
    entt::meta_base
    Meta base object.
    Definition: meta.hpp:810
    +
    entt::meta_type
    Meta type object.
    Definition: meta.hpp:1523
    +
    entt::meta_func
    Meta function object.
    Definition: meta.hpp:1355
    +
    entt::meta_data
    Meta data object.
    Definition: meta.hpp:1164
    +
    entt::meta_ctor
    Meta constructor object.
    Definition: meta.hpp:960
    +
    entt::meta_factory::data
    meta_factory data(const char *str, Property &&... property) ENTT_NOEXCEPT
    Assigns a meta data to a meta type.
    Definition: factory.hpp:406
    +
    entt::meta_dtor
    Meta destructor object.
    Definition: meta.hpp:1090
    +
    entt::meta_conv
    Meta conversion function object.
    Definition: meta.hpp:885
    +
    entt::meta_factory::dtor
    meta_factory dtor() ENTT_NOEXCEPT
    Assigns a meta destructor to a meta type.
    Definition: factory.hpp:366
    +
    entt::meta_any
    Meta any object.
    Definition: meta.hpp:302
    +
    entt::meta_ctor::prop
    std::enable_if_t< std::is_invocable_v< Op, meta_prop >, void > prop(Op op) const ENTT_NOEXCEPT
    Iterates all the properties assigned to a meta constructor.
    Definition: meta.hpp:1028
    +
    entt::meta_factory::data
    meta_factory data(const char *str, Property &&... property) ENTT_NOEXCEPT
    Assigns a meta data to a meta type by means of its setter and getter.
    Definition: factory.hpp:506
    +
    entt::hashed_string::data
    constexpr const char * data() const ENTT_NOEXCEPT
    Returns the human-readable representation of a hashed string.
    Definition: hashed_string.hpp:153
    +
    entt::meta_factory::func
    meta_factory func(const char *str, Property &&... property) ENTT_NOEXCEPT
    Assigns a meta funcion to a meta type.
    Definition: factory.hpp:554
    +
    entt::meta_prop
    Meta property object.
    Definition: meta.hpp:740
    +
    entt::meta_type::name
    const char * name() const ENTT_NOEXCEPT
    Returns the name assigned to a given meta type.
    Definition: meta.hpp:1547
    +
    entt::meta_factory
    A meta factory to be used for reflection purposes.
    Definition: factory.hpp:17
    +
    entt::meta_factory::conv
    meta_factory conv() ENTT_NOEXCEPT
    Assigns a meta conversion function to a meta type.
    Definition: factory.hpp:239
    diff --git a/family_8hpp_source.html b/family_8hpp_source.html index c727c484c..52681e160 100644 --- a/family_8hpp_source.html +++ b/family_8hpp_source.html @@ -22,7 +22,7 @@
    @@ -67,10 +67,10 @@ $(function() {
    family.hpp
    -
    1 #ifndef ENTT_CORE_FAMILY_HPP
    2 #define ENTT_CORE_FAMILY_HPP
    3 
    4 
    5 #include <type_traits>
    6 #include <cstddef>
    7 #include <atomic>
    8 #include "../config/config.h"
    9 
    10 
    11 namespace entt {
    12 
    13 
    21 template<typename...>
    22 class Family {
    23  static std::atomic<std::size_t> identifier;
    24 
    25  template<typename...>
    26  static std::size_t family() ENTT_NOEXCEPT {
    27  static const std::size_t value = identifier.fetch_add(1);
    28  return value;
    29  }
    30 
    31 public:
    33  using family_type = std::size_t;
    34 
    39  template<typename... Type>
    40  inline static family_type type() ENTT_NOEXCEPT {
    41  return family<std::decay_t<Type>...>();
    42  }
    43 };
    44 
    45 
    46 template<typename... Types>
    47 std::atomic<std::size_t> Family<Types...>::identifier{};
    48 
    49 
    50 }
    51 
    52 
    53 #endif // ENTT_CORE_FAMILY_HPP
    entt
    EnTT default namespace.
    Definition: algorithm.hpp:10
    -
    entt::Family::type
    static family_type type() ENTT_NOEXCEPT
    Returns an unique identifier for the given type.
    Definition: family.hpp:40
    -
    entt::Family::family_type
    std::size_t family_type
    Unsigned integer type.
    Definition: family.hpp:33
    -
    entt::Family
    Dynamic identifier generator.
    Definition: family.hpp:22
    +
    1 #ifndef ENTT_CORE_FAMILY_HPP
    2 #define ENTT_CORE_FAMILY_HPP
    3 
    4 
    5 #include <type_traits>
    6 #include "../config/config.h"
    7 
    8 
    9 namespace entt {
    10 
    11 
    19 template<typename...>
    20 class family {
    21  inline static maybe_atomic_t<ENTT_ID_TYPE> identifier;
    22 
    23  template<typename...>
    24  inline static const auto inner = identifier++;
    25 
    26 public:
    28  using family_type = ENTT_ID_TYPE;
    29 
    31  template<typename... Type>
    32  // at the time I'm writing, clang crashes during compilation if auto is used in place of family_type here
    33  inline static const family_type type = inner<std::decay_t<Type>...>;
    34 };
    35 
    36 
    37 }
    38 
    39 
    40 #endif // ENTT_CORE_FAMILY_HPP
    entt
    EnTT default namespace.
    Definition: algorithm.hpp:10
    +
    entt::family
    Dynamic identifier generator.
    Definition: family.hpp:20
    +
    entt::identifier
    Types identifiers.
    Definition: ident.hpp:42
    +
    entt::family::family_type
    ENTT_ID_TYPE family_type
    Unsigned integer type.
    Definition: family.hpp:28
    diff --git a/faq_8md_source.html b/faq_8md_source.html new file mode 100644 index 000000000..cb9cee7fa --- /dev/null +++ b/faq_8md_source.html @@ -0,0 +1,74 @@ + + + + + + + +EnTT: docs/md/faq.md Source File + + + + + + + + + +
    +
    +
    - + @@ -358,56 +352,25 @@ template<typename Delta >

    Returns true if at least a process is currently scheduled.

    Returns
    True if there are scheduled processes, false otherwise.
    -

    Definition at line 148 of file scheduler.hpp.

    +

    Definition at line 137 of file scheduler.hpp.

    - -

    ◆ operator=() [1/2]

    + +

    ◆ operator=()

    -template<typename Delta >
    +template<typename Delta>
    bool entt::Scheduler< Delta >::empty bool entt::scheduler< Delta >::empty ( ) const
    - - -
    - + - - - - -
    Scheduler& entt::Scheduler< Delta >::operator= scheduler& entt::scheduler< Delta >::operator= (const Scheduler< Delta > & )
    -     		-delete
    -
    - -

    Copying a scheduler isn't allowed.

    -
    Returns
    This scheduler.
    - -
    - - -

    ◆ operator=() [2/2]

    - -
    -
    -
    -template<typename Delta >
    - - - @@ -67,10 +67,20 @@ $(function() {
    entity.hpp
    -
    1 #ifndef ENTT_ENTITY_ENTITY_HPP
    2 #define ENTT_ENTITY_ENTITY_HPP
    3 
    4 
    5 #include "../config/config.h"
    6 #include "entt_traits.hpp"
    7 
    8 
    9 namespace entt {
    10 
    11 
    18 namespace internal {
    19 
    20 
    21 struct Null {
    22  explicit constexpr Null() = default;
    23 
    24  template<typename Entity>
    25  constexpr operator Entity() const ENTT_NOEXCEPT {
    26  using traits_type = entt::entt_traits<Entity>;
    27  return traits_type::entity_mask | (traits_type::version_mask << traits_type::entity_shift);
    28  }
    29 
    30  constexpr bool operator==(Null) const ENTT_NOEXCEPT {
    31  return true;
    32  }
    33 
    34  constexpr bool operator!=(Null) const ENTT_NOEXCEPT {
    35  return false;
    36  }
    37 
    38  template<typename Entity>
    39  constexpr bool operator==(const Entity entity) const ENTT_NOEXCEPT {
    40  return entity == static_cast<Entity>(*this);
    41  }
    42 
    43  template<typename Entity>
    44  constexpr bool operator!=(const Entity entity) const ENTT_NOEXCEPT {
    45  return entity != static_cast<Entity>(*this);
    46  }
    47 };
    48 
    49 
    50 template<typename Entity>
    51 constexpr bool operator==(const Entity entity, Null null) ENTT_NOEXCEPT {
    52  return null == entity;
    53 }
    54 
    55 
    56 template<typename Entity>
    57 constexpr bool operator!=(const Entity entity, Null null) ENTT_NOEXCEPT {
    58  return null != entity;
    59 }
    60 
    61 
    62 }
    63 
    64 
    78 constexpr auto null = internal::Null{};
    79 
    80 
    81 }
    82 
    83 
    84 #endif // ENTT_ENTITY_ENTITY_HPP
    entt::operator!=
    constexpr bool operator!=(const HashedString &lhs, const HashedString &rhs) ENTT_NOEXCEPT
    Compares two hashed strings.
    Definition: hashed_string.hpp:103
    +
    1 #ifndef ENTT_ENTITY_ENTITY_HPP
    2 #define ENTT_ENTITY_ENTITY_HPP
    3 
    4 
    5 #include "../config/config.h"
    6 
    7 
    8 namespace entt {
    9 
    10 
    17 template<typename>
    18 struct entt_traits;
    19 
    20 
    29 template<>
    30 struct entt_traits<std::uint16_t> {
    32  using entity_type = std::uint16_t;
    34  using version_type = std::uint8_t;
    36  using difference_type = std::int32_t;
    37 
    39  static constexpr std::uint16_t entity_mask = 0xFFF;
    41  static constexpr std::uint16_t version_mask = 0xF;
    43  static constexpr auto entity_shift = 12;
    44 };
    45 
    46 
    55 template<>
    56 struct entt_traits<std::uint32_t> {
    58  using entity_type = std::uint32_t;
    60  using version_type = std::uint16_t;
    62  using difference_type = std::int64_t;
    63 
    65  static constexpr std::uint32_t entity_mask = 0xFFFFF;
    67  static constexpr std::uint32_t version_mask = 0xFFF;
    69  static constexpr auto entity_shift = 20;
    70 };
    71 
    72 
    81 template<>
    82 struct entt_traits<std::uint64_t> {
    84  using entity_type = std::uint64_t;
    86  using version_type = std::uint32_t;
    88  using difference_type = std::int64_t;
    89 
    91  static constexpr std::uint64_t entity_mask = 0xFFFFFFFF;
    93  static constexpr std::uint64_t version_mask = 0xFFFFFFFF;
    95  static constexpr auto entity_shift = 32;
    96 };
    97 
    98 
    105 namespace internal {
    106 
    107 
    108 struct null {
    109  template<typename Entity>
    110  constexpr operator Entity() const ENTT_NOEXCEPT {
    111  using traits_type = entt_traits<Entity>;
    112  return traits_type::entity_mask | (traits_type::version_mask << traits_type::entity_shift);
    113  }
    114 
    115  constexpr bool operator==(null) const ENTT_NOEXCEPT {
    116  return true;
    117  }
    118 
    119  constexpr bool operator!=(null) const ENTT_NOEXCEPT {
    120  return false;
    121  }
    122 
    123  template<typename Entity>
    124  constexpr bool operator==(const Entity entity) const ENTT_NOEXCEPT {
    125  return entity == static_cast<Entity>(*this);
    126  }
    127 
    128  template<typename Entity>
    129  constexpr bool operator!=(const Entity entity) const ENTT_NOEXCEPT {
    130  return entity != static_cast<Entity>(*this);
    131  }
    132 };
    133 
    134 
    135 template<typename Entity>
    136 constexpr bool operator==(const Entity entity, null other) ENTT_NOEXCEPT {
    137  return other == entity;
    138 }
    139 
    140 
    141 template<typename Entity>
    142 constexpr bool operator!=(const Entity entity, null other) ENTT_NOEXCEPT {
    143  return other != entity;
    144 }
    145 
    146 
    147 }
    148 
    149 
    163 constexpr auto null = internal::null{};
    164 
    165 
    166 }
    167 
    168 
    169 #endif // ENTT_ENTITY_ENTITY_HPP
    entt::entt_traits< std::uint64_t >::difference_type
    std::int64_t difference_type
    Difference type.
    Definition: entity.hpp:88
    +
    entt::entt_traits< std::uint32_t >::entity_type
    std::uint32_t entity_type
    Underlying entity type.
    Definition: entity.hpp:58
    +
    entt::entt_traits< std::uint64_t >::entity_type
    std::uint64_t entity_type
    Underlying entity type.
    Definition: entity.hpp:84
    +
    entt::entt_traits< std::uint32_t >::difference_type
    std::int64_t difference_type
    Difference type.
    Definition: entity.hpp:62
    entt
    EnTT default namespace.
    Definition: algorithm.hpp:10
    -
    entt::null
    constexpr auto null
    Null entity.
    Definition: entity.hpp:78
    -
    entt::entt_traits
    Entity traits.
    Definition: entt_traits.hpp:18
    +
    entt::entt_traits< std::uint16_t >::difference_type
    std::int32_t difference_type
    Difference type.
    Definition: entity.hpp:36
    +
    entt::null
    constexpr auto null
    Null entity.
    Definition: entity.hpp:163
    +
    entt::entt_traits< std::uint16_t >::entity_type
    std::uint16_t entity_type
    Underlying entity type.
    Definition: entity.hpp:32
    +
    entt::entt_traits< std::uint64_t >::version_type
    std::uint32_t version_type
    Underlying version type.
    Definition: entity.hpp:86
    +
    entt::entity
    std::uint32_t entity
    Alias declaration for the most common use case.
    Definition: fwd.hpp:48
    +
    entt::entt_traits< std::uint16_t >::version_type
    std::uint8_t version_type
    Underlying version type.
    Definition: entity.hpp:34
    +
    entt::entt_traits< std::uint32_t >::version_type
    std::uint16_t version_type
    Underlying version type.
    Definition: entity.hpp:60
    +
    entt::entt_traits
    Entity traits.
    Definition: entity.hpp:18
    +
    entt::operator!=
    constexpr bool operator!=(const hashed_string &lhs, const hashed_string &rhs) ENTT_NOEXCEPT
    Compares two hashed strings.
    Definition: hashed_string.hpp:195
    diff --git a/entity_8md_source.html b/entity_8md_source.html index d339f5dba..bf03bae84 100644 --- a/entity_8md_source.html +++ b/entity_8md_source.html @@ -5,7 +5,7 @@ -EnTT: docs/entity.md Source File +EnTT: docs/md/entity.md Source File @@ -22,7 +22,7 @@
    @@ -60,10 +60,10 @@ $(function() {
    -
    docs/entity.md
    +
    docs/md/entity.md
    -
    1 # Crash Course: entity-component system
    2 
    3 <!--
    4 @cond TURN_OFF_DOXYGEN
    5 -->
    6 # Table of Contents
    7 
    8 * [Introduction](#introduction)
    9 * [Design choices](#design-choices)
    10  * [A bitset-free entity-component system](#a-bitset-free-entity-component-system)
    11  * [Pay per use](#pay-per-use)
    12 * [Vademecum](#vademecum)
    13 * [The Registry, the Entity and the Component](#the-registry-the-entity-and-the-component)
    14  * [Single instance components](#single-instance-components)
    15  * [Observe changes](#observe-changes)
    16  * [Who let the tags out?](#who-let-the-tags-out)
    17  * [Runtime components](#runtime-components)
    18  * [A journey through a plugin](#a-journey-through-a-plugin)
    19  * [Sorting: is it possible?](#sorting-is-it-possible)
    20  * [Snapshot: complete vs continuous](#snapshot-complete-vs-continuous)
    21  * [Snapshot loader](#snapshot-loader)
    22  * [Continuous loader](#continuous-loader)
    23  * [Archives](#archives)
    24  * [One example to rule them all](#one-example-to-rule-them-all)
    25  * [Prototype](#prototype)
    26  * [Helpers](#helpers)
    27  * [Dependency function](#dependency-function)
    28  * [Labels](#labels)
    29  * [Null entity](#null-entity)
    30 * [View: to persist or not to persist?](#view-to-persist-or-not-to-persist)
    31  * [Standard View](#standard-view)
    32  * [Single component standard view](#single-component-standard-view)
    33  * [Multi component standard view](#multi-component-standard-view)
    34  * [Persistent View](#persistent-view)
    35  * [Raw View](#raw-view)
    36  * [Runtime View](#runtime-view)
    37  * [Give me everything](#give-me-everything)
    38 * [Iterations: what is allowed and what is not](#iterations-what-is-allowed-and-what-is-not)
    39 * [Multithreading](#multithreading)
    40 <!--
    41 @endcond TURN_OFF_DOXYGEN
    42 -->
    43 
    44 # Introduction
    45 
    46 `EnTT` is a header-only, tiny and easy to use entity-component system (and much
    47 more) written in modern C++.<br/>
    48 The entity-component-system (also known as _ECS_) is an architectural pattern
    49 used mostly in game development.
    50 
    51 # Design choices
    52 
    53 ## A bitset-free entity-component system
    54 
    55 `EnTT` is a _bitset-free_ entity-component system that doesn't require users to
    56 specify the component set at compile-time.<br/>
    57 This is why users can instantiate the core class simply like:
    58 
    59 ```cpp
    60 entt::DefaultRegistry registry;
    61 ```
    62 
    63 In place of its more annoying and error-prone counterpart:
    64 
    65 ```cpp
    66 entt::DefaultRegistry<Comp0, Comp1, ..., CompN> registry;
    67 ```
    68 
    69 ## Pay per use
    70 
    71 `EnTT` is entirely designed around the principle that users have to pay only for
    72 what they want.
    73 
    74 When it comes to using an entity-component system, the tradeoff is usually
    75 between performance and memory usage. The faster it is, the more memory it uses.
    76 However, slightly worse performance along non-critical paths are the right price
    77 to pay to reduce memory usage and I've always wondered why this kind of tools do
    78 not leave me the choice.<br/>
    79 `EnTT` follows a completely different approach. It squeezes the best from the
    80 basic data structures and gives users the possibility to pay more for higher
    81 performance where needed.<br/>
    82 The disadvantage of this approach is that users need to know the systems they
    83 are working on and the tools they are using. Otherwise, the risk to ruin the
    84 performance along critical paths is high.
    85 
    86 So far, this choice has proven to be a good one and I really hope it can be for
    87 many others besides me.
    88 
    89 # Vademecum
    90 
    91 The `Registry` to store, the views to iterate. That's all.
    92 
    93 An entity (the _E_ of an _ECS_) is an opaque identifier that users should just
    94 use as-is and store around if needed. Do not try to inspect an entity
    95 identifier, its format can change in future and a registry offers all the
    96 functionalities to query them out-of-the-box. The underlying type of an entity
    97 (either `std::uint16_t`, `std::uint32_t` or `std::uint64_t`) can be specified
    98 when defining a registry (actually the `DefaultRegistry` is nothing more than a
    99 `Registry` where the type of the entities is `std::uint32_t`).<br/>
    100 Components (the _C_ of an _ECS_) should be plain old data structures or more
    101 complex and movable data structures with a proper constructor. Actually, the
    102 sole requirement of a component type is that it must be both move constructible
    103 and move assignable. They are list initialized by using the parameters provided
    104 to construct the component itself. No need to register components or their types
    105 neither with the registry nor with the entity-component system at all.<br/>
    106 Systems (the _S_ of an _ECS_) are just plain functions, functors, lambdas or
    107 whatever users want. They can accept a `Registry` or a view of any type and use
    108 them the way they prefer. No need to register systems or their types neither
    109 with the registry nor with the entity-component system at all.
    110 
    111 The following sections will explain in short how to use the entity-component
    112 system, the core part of the whole library.<br/>
    113 In fact, the project is composed of many other classes in addition to those
    114 describe below. For more details, please refer to the inline documentation.
    115 
    116 # The Registry, the Entity and the Component
    117 
    118 A registry can store and manage entities, as well as create views to iterate the
    119 underlying data structures.<br/>
    120 `Registry` is a class template that lets users decide what's the preferred type
    121 to represent an entity. Because `std::uint32_t` is large enough for almost all
    122 the cases, there exists also an alias named `DefaultRegistry` for
    123 `Registry<std::uint32_t>`.
    124 
    125 Entities are represented by _entity identifiers_. An entity identifier is an
    126 opaque type that users should not inspect or modify in any way. It carries
    127 information about the entity itself and its version.
    128 
    129 A registry can be used both to construct and destroy entities:
    130 
    131 ```cpp
    132 // constructs a naked entity with no components and returns its identifier
    133 auto entity = registry.create();
    134 
    135 // destroys an entity and all its components
    136 registry.destroy(entity);
    137 ```
    138 
    139 Entities can also be destroyed _by type_, that is by specifying the types of the
    140 tags or components that identify them:
    141 
    142 ```cpp
    143 // destroys the entity that owns the given tag, if any
    144 registry.destroy<MyTag>(entt::tag_t{});
    145 
    146 // destroys the entities that own the given components, if any
    147 registry.destroy<AComponent, AnotherComponent>();
    148 ```
    149 
    150 When an entity is destroyed, the registry can freely reuse it internally with a
    151 slightly different identifier. In particular, the version of an entity is
    152 increased each and every time it's discarded.<br/>
    153 In case entity identifiers are stored around, the registry offers all the
    154 functionalities required to test them and get out of the them all the
    155 information they carry:
    156 
    157 ```cpp
    158 // returns true if the entity is still valid, false otherwise
    159 bool b = registry.valid(entity);
    160 
    161 // gets the version contained in the entity identifier
    162 auto version = registry.version(entity);
    163 
    164 // gets the actual version for the given entity
    165 auto curr = registry.current(entity);
    166 ```
    167 
    168 Components can be assigned to or removed from entities at any time with a few
    169 calls to member functions of the registry. As for the entities, the registry
    170 offers also a set of functionalities users can use to work with the components.
    171 
    172 The `assign` member function template creates, initializes and assigns to an
    173 entity the given component. It accepts a variable number of arguments to
    174 construct the component itself if present:
    175 
    176 ```cpp
    177 registry.assign<Position>(entity, 0., 0.);
    178 
    179 // ...
    180 
    181 Velocity &velocity = registry.assign<Velocity>(entity);
    182 velocity.dx = 0.;
    183 velocity.dy = 0.;
    184 ```
    185 
    186 If an entity already has the given component, the `replace` member function
    187 template can be used to replace it:
    188 
    189 ```cpp
    190 registry.replace<Position>(entity, 0., 0.);
    191 
    192 // ...
    193 
    194 Velocity &velocity = registry.replace<Velocity>(entity);
    195 velocity.dx = 0.;
    196 velocity.dy = 0.;
    197 ```
    198 
    199 In case users want to assign a component to an entity, but it's unknown whether
    200 the entity already has it or not, `accommodate` does the work in a single call
    201 (there is a performance penalty to pay for this mainly due to the fact that it
    202 has to check if the entity already has the given component or not):
    203 
    204 ```cpp
    205 registry.accommodate<Position>(entity, 0., 0.);
    206 
    207 // ...
    208 
    209 Velocity &velocity = registry.accommodate<Velocity>(entity);
    210 velocity.dx = 0.;
    211 velocity.dy = 0.;
    212 ```
    213 
    214 Note that `accommodate` is a slightly faster alternative for the following
    215 `if/else` statement and nothing more:
    216 
    217 ```cpp
    218 if(registry.has<Comp>(entity)) {
    219  registry.replace<Comp>(entity, arg1, argN);
    220 } else {
    221  registry.assign<Comp>(entity, arg1, argN);
    222 }
    223 ```
    224 
    225 As already shown, if in doubt about whether or not an entity has one or more
    226 components, the `has` member function template may be useful:
    227 
    228 ```cpp
    229 bool b = registry.has<Position, Velocity>(entity);
    230 ```
    231 
    232 On the other side, if the goal is to delete a single component, the `remove`
    233 member function template is the way to go when it's certain that the entity owns
    234 a copy of the component:
    235 
    236 ```cpp
    237 registry.remove<Position>(entity);
    238 ```
    239 
    240 Otherwise consider to use the `reset` member function. It behaves similarly to
    241 `remove` but with a strictly defined behavior (and a performance penalty is the
    242 price to pay for this). In particular it removes the component if and only if it
    243 exists, otherwise it returns safely to the caller:
    244 
    245 ```cpp
    246 registry.reset<Position>(entity);
    247 ```
    248 
    249 There exist also two other _versions_ of the `reset` member function:
    250 
    251 * If no entity is passed to it, `reset` will remove the given component from
    252  each entity that has it:
    253 
    254  ```cpp
    255  registry.reset<Position>();
    256  ```
    257 
    258 * If neither the entity nor the component are specified, all the entities still
    259  in use and their components are destroyed:
    260 
    261  ```cpp
    262  registry.reset();
    263  ```
    264 
    265 Finally, references to components can be retrieved simply by doing this:
    266 
    267 ```cpp
    268 const auto &cregistry = registry;
    269 
    270 // const and non-const reference
    271 const Position &position = cregistry.get<Position>(entity);
    272 Position &position = registry.get<Position>(entity);
    273 
    274 // const and non-const references
    275 std::tuple<const Position &, const Velocity &> tup = cregistry.get<Position, Velocity>(entity);
    276 std::tuple<Position &, Velocity &> tup = registry.get<Position, Velocity>(entity);
    277 ```
    278 
    279 The `get` member function template gives direct access to the component of an
    280 entity stored in the underlying data structures of the registry.
    281 
    282 ## Single instance components
    283 
    284 In those cases where all what is needed is a single instance component, tags are
    285 the right tool to achieve the purpose.<br/>
    286 Tags undergo the same requirements of components. They can be either plain old
    287 data structures or more complex and movable data structures with a proper
    288 constructor.<br/>
    289 Actually, the same type can be used both as a tag and as a component and the
    290 registry will not complain about it. It is up to users to properly manage their
    291 own types. In some cases, the tag `tag_t` must also be used in order to
    292 disambiguate overloads of member functions.
    293 
    294 Attaching tags to entities and removing them is trivial:
    295 
    296 ```cpp
    297 auto player = registry.create();
    298 auto camera = registry.create();
    299 
    300 // attaches a default-initialized tag to an entity
    301 registry.assign<PlayingCharacter>(entt::tag_t{}, player);
    302 
    303 // attaches a tag to an entity and initializes it
    304 registry.assign<Camera>(entt::tag_t{}, camera, player);
    305 
    306 // removes tags from their owners
    307 registry.remove<PlayingCharacter>();
    308 registry.remove<Camera>();
    309 ```
    310 
    311 In case a tag already has an owner, its content can be updated by means of the
    312 `replace` member function template and the ownership of the tag can be
    313 transferred to another entity using the `move` member function template:
    314 
    315 ```
    316 // replaces the content of the given tag
    317 Point &point = registry.replace<Point>(entt::tag_t{}, 1.f, 1.f);
    318 
    319 // transfers the ownership of the tag to another entity
    320 entity_type prev = registry.move<Point>(next);
    321 ```
    322 
    323 If in doubt about whether or not a tag already has an owner, the `has` member
    324 function template may be useful:
    325 
    326 ```cpp
    327 bool b = registry.has<PlayingCharacter>();
    328 ```
    329 
    330 References to tags can be retrieved simply by doing this:
    331 
    332 ```cpp
    333 const auto &cregistry = registry;
    334 
    335 // either a non-const reference ...
    336 PlayingCharacter &player = registry.get<PlayingCharacter>();
    337 
    338 // ... or a const one
    339 const Camera &camera = cregistry.get<Camera>();
    340 ```
    341 
    342 The `get` member function template gives direct access to the tag as stored in
    343 the underlying data structures of the registry.
    344 
    345 As shown above, in almost all the cases the entity identifier isn't required.
    346 Since a single instance component can have only one associated entity, it
    347 doesn't make much sense to mention it explicitly.<br/>
    348 To find out who the owner is, just do the following:
    349 
    350 ```cpp
    351 auto player = registry.attachee<PlayingCharacter>();
    352 ```
    353 
    354 Note that iterating tags isn't possible for obvious reasons. Tags give direct
    355 access to single entities and nothing more.
    356 
    357 ## Observe changes
    358 
    359 Because of how the registry works internally, it stores a couple of signal
    360 handlers for each pool in order to notify some of its data structures on the
    361 construction and destruction of components.<br/>
    362 These signal handlers are also exposed and made available to users. This is the
    363 basic brick to build fancy things like dependencies and reactive systems.
    364 
    365 To get a sink to be used to connect and disconnect listeners so as to be
    366 notified on the creation of a component, use the `construction` member function:
    367 
    368 ```cpp
    369 // connects a free function
    370 registry.construction<Position>().connect<&MyFreeFunction>();
    371 
    372 // connects a member function
    373 registry.construction<Position>().connect<MyClass, &MyClass::member>(&instance);
    374 
    375 // disconnects a free function
    376 registry.construction<Position>().disconnect<&MyFreeFunction>();
    377 
    378 // disconnects a member function
    379 registry.construction<Position>().disconnect<MyClass, &MyClass::member>(&instance);
    380 ```
    381 
    382 To be notified when components are destroyed, use the `destruction` member
    383 function instead.
    384 
    385 The function type of a listener is the same in both cases:
    386 
    387 ```cpp
    388 void(Registry<Entity> &, Entity);
    389 ```
    390 
    391 In other terms, a listener is provided with the registry that triggered the
    392 notification and the entity affected by the change. Note also that:
    393 
    394 * Listeners are invoked **after** components have been assigned to entities.
    395 * Listeners are invoked **before** components have been removed from entities.
    396 * The order of invocation of the listeners isn't guaranteed in any case.
    397 
    398 There are also some limitations on what a listener can and cannot do. In
    399 particular:
    400 
    401 * Connecting and disconnecting other functions from within the body of a
    402  listener should be avoided. It can lead to undefined behavior in some cases.
    403 * Assigning and removing components and tags from within the body of a listener
    404  that observes the destruction of instances of a given type should be avoided.
    405  It can lead to undefined behavior in some cases. This type of listeners is
    406  intended to provide users with an easy way to perform cleanup and nothing
    407  more.
    408 
    409 To a certain extent, these limitations do not apply. However, it is risky to try
    410 to force them and users should respect the limitations unless they know exactly
    411 what they are doing. Subtle bugs are the price to pay in case of errors
    412 otherwise.
    413 
    414 In general, events and therefore listeners must not be used as replacements for
    415 systems. They should not contain much logic and interactions with a registry
    416 should be kept to a minimum, if possible. Note also that the greater the number
    417 of listeners, the greater the performance hit when components are created or
    418 destroyed.
    419 
    420 ### Who let the tags out?
    421 
    422 As an extension, signals are also provided with tags. Although they are not
    423 strictly required internally, it makes sense that a user expects signal support
    424 even when it comes to tags actually.<br/>
    425 Signals for tags undergo exactly the same requirements of those introduced for
    426 components. Also the function type for a listener is the same and it's invoked
    427 with the same guarantees discussed above.
    428 
    429 To get the sinks for a tag just use tag `tag_t` to disambiguate overloads of
    430 member functions as in the following example:
    431 
    432 ```cpp
    433 registry.construction<MyTag>(entt::tag_t{}).connect<&MyFreeFunction>();
    434 registry.destruction<MyTag>(entt::tag_t{}).connect<MyClass, &MyClass::member>(&instance);
    435 ```
    436 
    437 Listeners for tags and components are managed separately and do not influence
    438 each other in any case. Therefore, note that the greater the number of listeners
    439 for a type, the greater the performance hit when a tag of the given type is
    440 created or destroyed.
    441 
    442 ## Runtime components
    443 
    444 Defining components at runtime is useful to support plugin systems and mods in
    445 general. However, it seems impossible with a tool designed around a bunch of
    446 templates. Indeed it's not that difficult.<br/>
    447 Of course, some features cannot be easily exported into a runtime
    448 environment. As an example, sorting a group of components defined at runtime
    449 isn't for free if compared to most of the other operations. However, the basic
    450 functionalities of an entity-component system such as `EnTT` fit the problem
    451 perfectly and can also be used to manage runtime components if required.<br/>
    452 All that is necessary to do it is to know the identifiers of the components. An
    453 identifier is nothing more than a number or similar that can be used at runtime
    454 to work with the type system.
    455 
    456 In `EnTT`, identifiers are easily accessible:
    457 
    458 ```cpp
    459 entt::DefaultRegistry registry;
    460 
    461 // standard component identifier
    462 auto ctype = registry.type<Position>();
    463 
    464 // single instance component identifier
    465 auto ttype = registry.type<PlayingCharacter>(entt::tag_t{});
    466 ```
    467 
    468 Once the identifiers are made available, almost everything becomes pretty
    469 simple.
    470 
    471 ### A journey through a plugin
    472 
    473 `EnTT` comes with an example (actually a test) that shows how to integrate
    474 compile-time and runtime components in a stack based JavaScript environment. It
    475 uses [`Duktape`](https://github.com/svaarala/duktape) under the hood, mainly
    476 because I wanted to learn how it works at the time I was writing the code.
    477 
    478 The code is not production-ready and overall performance can be highly improved.
    479 However, I sacrificed optimizations in favor of a more readable piece of code. I
    480 hope I succeeded.<br/>
    481 Note also that this isn't neither the only nor (probably) the best way to do it.
    482 In fact, the right way depends on the scripting language and the problem one is
    483 facing in general.<br/>
    484 That being said, feel free to use it at your own risk.
    485 
    486 The basic idea is that of creating a compile-time component aimed to map all the
    487 runtime components assigned to an entity.<br/>
    488 Identifiers come in use to address the right function from a map when invoked
    489 from the runtime environment and to filter entities when iterating.<br/>
    490 With a bit of gymnastic, one can narrow views and improve the performance to
    491 some extent but it was not the goal of the example.
    492 
    493 ## Sorting: is it possible?
    494 
    495 It goes without saying that sorting entities and components is possible with
    496 `EnTT`.<br/>
    497 In fact, there are two functions that respond to slightly different needs:
    498 
    499 * Components can be sorted directly:
    500 
    501  ```cpp
    502  registry.sort<Renderable>([](const auto &lhs, const auto &rhs) {
    503  return lhs.z < rhs.z;
    504 
    505  });
    506  ```
    507 
    508  There exists also the possibility to use a custom sort function object, as
    509  long as it adheres to the requirements described in the inline
    510  documentation.<br/>
    511  This is possible mainly because users can get much more with a custom sort
    512  function object if the pattern of usage is known. As an example, in case of an
    513  almost sorted pool, quick sort could be much, much slower than insertion sort.
    514 
    515 * Components can be sorted according to the order imposed by another component:
    516 
    517  ```cpp
    518  registry.sort<Movement, Physics>();
    519  ```
    520 
    521  In this case, instances of `Movement` are arranged in memory so that cache
    522  misses are minimized when the two components are iterated together.
    523 
    524 ## Snapshot: complete vs continuous
    525 
    526 The `Registry` class offers basic support to serialization.<br/>
    527 It doesn't convert components and tags to bytes directly, there wasn't the need
    528 of another tool for serialization out there. Instead, it accepts an opaque
    529 object with a suitable interface (namely an _archive_) to serialize its internal
    530 data structures and restore them later. The way types and instances are
    531 converted to a bunch of bytes is completely in charge to the archive and thus to
    532 final users.
    533 
    534 The goal of the serialization part is to allow users to make both a dump of the
    535 entire registry or a narrower snapshot, that is to select only the components
    536 and the tags in which they are interested.<br/>
    537 Intuitively, the use cases are different. As an example, the first approach is
    538 suitable for local save/restore functionalities while the latter is suitable for
    539 creating client-server applications and for transferring somehow parts of the
    540 representation side to side.
    541 
    542 To take a snapshot of the registry, use the `snapshot` member function. It
    543 returns a temporary object properly initialized to _save_ the whole registry or
    544 parts of it.
    545 
    546 Example of use:
    547 
    548 ```cpp
    549 OutputArchive output;
    550 
    551 registry.snapshot()
    552  .entities(output)
    553  .destroyed(output)
    554  .component<AComponent, AnotherComponent>(output)
    555  .tag<MyTag>(output);
    556 ```
    557 
    558 It isn't necessary to invoke all these functions each and every time. What
    559 functions to use in which case mostly depends on the goal and there is not a
    560 golden rule to do that.
    561 
    562 The `entities` member function asks the registry to serialize all the entities
    563 that are still in use along with their versions. On the other side, the
    564 `destroyed` member function tells to the registry to serialize the entities that
    565 have been destroyed and are no longer in use.<br/>
    566 These two functions can be used to save and restore the whole set of entities
    567 with the versions they had during serialization.
    568 
    569 The `component` member function is a function template the aim of which is to
    570 store aside components. The presence of a template parameter list is a
    571 consequence of a couple of design choices from the past and in the present:
    572 
    573 * First of all, there is no reason to force a user to serialize all the
    574  components at once and most of the times it isn't desiderable. As an example,
    575  in case the stuff for the HUD in a game is put into the registry for some
    576  reasons, its components can be freely discarded during a serialization step
    577  because probably the software already knows how to reconstruct the HUD
    578  correctly from scratch.
    579 
    580 * Furthermore, the registry makes heavy use of _type-erasure_ techniques
    581  internally and doesn't know at any time what types of components it contains.
    582  Therefore being explicit at the call point is mandatory.
    583 
    584 There exists also another version of the `component` member function that
    585 accepts a range of entities to serialize. This version is a bit slower than the
    586 other one, mainly because it iterates the range of entities more than once for
    587 internal purposes. However, it can be used to filter out those entities that
    588 shouldn't be serialized for some reasons.<br/>
    589 As an example:
    590 
    591 ```cpp
    592 const auto view = registry.view<Serialize>();
    593 OutputArchive output;
    594 
    595 registry.snapshot()
    596  .component<AComponent, AnotherComponent>(output, view.cbegin(), view.cend());
    597 ```
    598 
    599 The `tag` member function is similar to the previous one, apart from the fact
    600 that it works with tags and not with components.<br/>
    601 Note also that both `component` and `tag` store items along with entities. It
    602 means that they work properly without a call to the `entities` member function.
    603 
    604 Once a snapshot is created, there exist mainly two _ways_ to load it: as a whole
    605 and in a kind of _continuous mode_.<br/>
    606 The following sections describe both loaders and archives in details.
    607 
    608 ### Snapshot loader
    609 
    610 A snapshot loader requires that the destination registry be empty and loads all
    611 the data at once while keeping intact the identifiers that the entities
    612 originally had.<br/>
    613 To do that, the registry offers a member function named `restore` that returns a
    614 temporary object properly initialized to _restore_ a snapshot.
    615 
    616 Example of use:
    617 
    618 ```cpp
    619 InputArchive input;
    620 
    621 registry.restore()
    622  .entities(input)
    623  .destroyed(input)
    624  .component<AComponent, AnotherComponent>(input)
    625  .tag<MyTag>(input)
    626  .orphans();
    627 ```
    628 
    629 It isn't necessary to invoke all these functions each and every time. What
    630 functions to use in which case mostly depends on the goal and there is not a
    631 golden rule to do that. For obvious reasons, what is important is that the data
    632 are restored in exactly the same order in which they were serialized.
    633 
    634 The `entities` and `destroyed` member functions restore the sets of entities and
    635 the versions that the entities originally had at the source.
    636 
    637 The `component` member function restores all and only the components specified
    638 and assigns them to the right entities. Note that the template parameter list
    639 must be exactly the same used during the serialization. The same applies to the
    640 `tag` member function.
    641 
    642 The `orphans` member function literally destroys those entities that have
    643 neither components nor tags. It's usually useless if the snapshot is a full dump
    644 of the source. However, in case all the entities are serialized but only few
    645 components and tags are saved, it could happen that some of the entities have
    646 neither components nor tags once restored. The best users can do to deal with
    647 them is to destroy those entities and thus update their versions.
    648 
    649 ### Continuous loader
    650 
    651 A continuous loader is designed to load data from a source registry to a
    652 (possibly) non-empty destination. The loader can accommodate in a registry more
    653 than one snapshot in a sort of _continuous loading_ that updates the
    654 destination one step at a time.<br/>
    655 Identifiers that entities originally had are not transferred to the target.
    656 Instead, the loader maps remote identifiers to local ones while restoring a
    657 snapshot. Because of that, this kind of loader offers a way to update
    658 automatically identifiers that are part of components or tags (as an example, as
    659 data members or gathered in a container).<br/>
    660 Another difference with the snapshot loader is that the continuous loader does
    661 not need to work with the private data structures of a registry. Furthermore, it
    662 has an internal state that must persist over time. Therefore, there is no reason
    663 to create it by means of a registry, or to limit its lifetime to that of a
    664 temporary object.
    665 
    666 Example of use:
    667 
    668 ```cpp
    669 entt::ContinuousLoader<entity_type> loader{registry};
    670 InputArchive input;
    671 
    672 loader.entities(input)
    673  .destroyed(input)
    674  .component<AComponent, AnotherComponent, DirtyComponent>(input, &DirtyComponent::parent, &DirtyComponent::child)
    675  .tag<MyTag, DirtyTag>(input, &DirtyTag::container)
    676  .orphans()
    677  .shrink();
    678 ```
    679 
    680 It isn't necessary to invoke all these functions each and every time. What
    681 functions to use in which case mostly depends on the goal and there is not a
    682 golden rule to do that. For obvious reasons, what is important is that the data
    683 are restored in exactly the same order in which they were serialized.
    684 
    685 The `entities` and `destroyed` member functions restore groups of entities and
    686 map each entity to a local counterpart when required. In other terms, for each
    687 remote entity identifier not yet registered by the loader, the latter creates a
    688 local identifier so that it can keep the local entity in sync with the remote
    689 one.
    690 
    691 The `component` and `tag` member functions restore all and only the components
    692 and the tags specified and assign them to the right entities.<br/>
    693 In case the component or the tag contains entities itself (either as data
    694 members of type `entity_type` or as containers of entities), the loader can
    695 update them automatically. To do that, it's enough to specify the data members
    696 to update as shown in the example.
    697 
    698 The `orphans` member function literally destroys those entities that have
    699 neither components nor tags after a restore. It has exactly the same purpose
    700 described in the previous section and works the same way.
    701 
    702 Finally, `shrink` helps to purge local entities that no longer have a remote
    703 conterpart. Users should invoke this member function after restoring each
    704 snapshot, unless they know exactly what they are doing.
    705 
    706 ### Archives
    707 
    708 Archives must publicly expose a predefined set of member functions. The API is
    709 straightforward and consists only of a group of function call operators that
    710 are invoked by the snapshot class and the loaders.
    711 
    712 In particular:
    713 
    714 * An output archive, the one used when creating a snapshot, must expose a
    715  function call operator with the following signature to store entities:
    716 
    717  ```cpp
    718  void operator()(Entity);
    719  ```
    720 
    721  Where `Entity` is the type of the entities used by the registry. Note that all
    722  the member functions of the snapshot class make also an initial call to this
    723  endpoint to save the _size_ of the set they are going to store.<br/>
    724  In addition, an archive must accept a pair of entity and either component or
    725  tag for each type to be serialized. Therefore, given a type `T`, the archive
    726  must contain a function call operator with the following signature:
    727 
    728  ```cpp
    729  void operator()(Entity, const T &);
    730  ```
    731 
    732  The output archive can freely decide how to serialize the data. The register
    733  is not affected at all by the decision.
    734 
    735 * An input archive, the one used when restoring a snapshot, must expose a
    736  function call operator with the following signature to load entities:
    737 
    738  ```cpp
    739  void operator()(Entity &);
    740  ```
    741 
    742  Where `Entity` is the type of the entities used by the registry. Each time the
    743  function is invoked, the archive must read the next element from the
    744  underlying storage and copy it in the given variable. Note that all the member
    745  functions of a loader class make also an initial call to this endpoint to read
    746  the _size_ of the set they are going to load.<br/>
    747  In addition, the archive must accept a pair of entity and either component or
    748  tag for each type to be restored. Therefore, given a type `T`, the archive
    749  must contain a function call operator with the following signature:
    750 
    751  ```cpp
    752  void operator()(Entity &, T &);
    753  ```
    754 
    755  Every time such an operator is invoked, the archive must read the next
    756  elements from the underlying storage and copy them in the given variables.
    757 
    758 ### One example to rule them all
    759 
    760 `EnTT` comes with some examples (actually some tests) that show how to integrate
    761 a well known library for serialization as an archive. It uses
    762 [`Cereal C++`](https://uscilab.github.io/cereal/) under the hood, mainly
    763 because I wanted to learn how it works at the time I was writing the code.
    764 
    765 The code is not production-ready and it isn't neither the only nor (probably)
    766 the best way to do it. However, feel free to use it at your own risk.
    767 
    768 The basic idea is to store everything in a group of queues in memory, then bring
    769 everything back to the registry with different loaders.
    770 
    771 ## Prototype
    772 
    773 A prototype defines a type of an application in terms of its parts. They can be
    774 used to assign components to entities of a registry at once.<br/>
    775 Roughly speaking, in most cases prototypes can be considered just as templates
    776 to use to initialize entities according to _concepts_. In fact, users can create
    777 how many prototypes they want, each one initialized differently from the others.
    778 
    779 The following is an example of use of a prototype:
    780 
    781 ```cpp
    782 entt::DefaultRegistry registry;
    783 entt::DefaultPrototype prototype{registry};
    784 
    785 prototype.set<Position>(100.f, 100.f);
    786 prototype.set<Velocity>(0.f, 0.f);
    787 
    788 // ...
    789 
    790 const auto entity = prototype();
    791 ```
    792 
    793 To assign and remove components from a prototype, it offers two dedicated member
    794 functions named `set` and `unset`. The `has` member function can be used to know
    795 if a given prototype contains one or more components and the `get` member
    796 function can be used to retrieve the components.
    797 
    798 Creating an entity from a prototype is straightforward:
    799 
    800 * To create a new entity from scratch and assign it a prototype, this is the way
    801  to go:
    802  ```cpp
    803  const auto entity = prototype();
    804  ```
    805  It is equivalent to the following invokation:
    806  ```cpp
    807  const auto entity = prototype.create();
    808  ```
    809 
    810 * In case we want to initialize an already existing entity, we can provide the
    811  `operator()` directly with the entity identifier:
    812  ```cpp
    813  prototype(entity);
    814  ```
    815  It is equivalent to the following invokation:
    816  ```cpp
    817  prototype.assign(entity);
    818  ```
    819  Note that existing components aren't overwritten in this case. Only those
    820  components that the entity doesn't own yet are copied over. All the other
    821  components remain unchanged.
    822 
    823 * Finally, to assign or replace all the components for an entity, thus
    824  overwriting existing ones:
    825  ```cpp
    826  prototype.accommodate(entity);
    827  ```
    828 
    829 In the examples above, the prototype uses its underlying registry to create
    830 entities and components both for its purposes and when it's cloned. To use a
    831 different repository to clone a prototype, all the member functions accept also
    832 a reference to a valid registry as a first argument.
    833 
    834 Prototypes are a very useful tool that can save a lot of typing sometimes.
    835 Furthermore, the codebase may be easier to maintain, since updating a prototype
    836 is much less error prone than jumping around in the codebase to update all the
    837 snippets copied and pasted around to initialize entities and components.
    838 
    839 ## Helpers
    840 
    841 The so called _helpers_ are small classes and functions mainly designed to offer
    842 built-in support for the most basic functionalities.<br/>
    843 The list of helpers will grow longer as time passes and new ideas come out.
    844 
    845 ### Dependency function
    846 
    847 A _dependency function_ is a predefined listener, actually a function template
    848 to use to automatically assign components to an entity when a type has a
    849 dependency on some other types.<br/>
    850 The following adds components `AType` and `AnotherType` whenever `MyType` is
    851 assigned to an entity:
    852 
    853 ```cpp
    854 entt::connnect<AType, AnotherType>(registry.construction<MyType>());
    855 ```
    856 
    857 A component is assigned to an entity and thus default initialized only in case
    858 the entity itself hasn't it yet. It means that already existent components won't
    859 be overriden.<br/>
    860 A dependency can easily be broken by means of the following function template:
    861 
    862 ```cpp
    863 entt::disconnect<AType, AnotherType>(registry.construction<MyType>());
    864 ```
    865 
    866 ### Labels
    867 
    868 There's nothing magical about the way labels can be assigned to entities while
    869 avoiding a performance hit at runtime. Nonetheless, the syntax can be annoying
    870 and that's why a more user-friendly shortcut is provided to do it.<br/>
    871 This shortcut is the alias template `entt::label`.
    872 
    873 If used in combination with hashed strings, it helps to use labels where types
    874 would be required otherwise. As an example:
    875 
    876 ```cpp
    877 registry.assign<entt::label<"enemy"_hs>>(entity);
    878 ```
    879 
    880 ## Null entity
    881 
    882 In `EnTT`, there exists a sort of _null entity_ made available to users that is
    883 accessible via the `entt::null` variable.<br/>
    884 The library guarantees that the following expression always returns false:
    885 
    886 ```cpp
    887 registry.valid(entt::null);
    888 ```
    889 
    890 In other terms, a registry will reject the null entity in all cases because it
    891 isn't considered valid. It means that the null entity cannot own components or
    892 tags for obvious reasons.<br/>
    893 The type of the null entity is internal and should not be used for any purpose
    894 other than defining the null entity itself. However, there exist implicit
    895 conversions from the null entity to identifiers of any allowed type:
    896 
    897 ```cpp
    898 typename entt::DefaultRegistry::entity_type null = entt::null;
    899 ```
    900 
    901 Similarly, the null entity can be compared to any other identifier:
    902 
    903 ```cpp
    904 const auto entity = registry.create();
    905 const bool null = (entity == entt::null);
    906 ```
    907 
    908 # View: to persist or not to persist?
    909 
    910 First of all, it is worth answering an obvious question: why views?<br/>
    911 Roughly speaking, they are a good tool to enforce single responsibility. A
    912 system that has access to a registry can create and destroy entities, as well as
    913 assign and remove components. On the other side, a system that has access to a
    914 view can only iterate entities and their components, then read or update the
    915 data members of the latter.<br/>
    916 It is a subtle difference that can help designing a better software sometimes.
    917 
    918 There are mainly four kinds of views: standard (also known as `View`),
    919 persistent (also known as `PersistentView`), raw (also known as `RawView`) and
    920 runtime (also known as `RuntimeView`).<br/>
    921 All of them have pros and cons to take in consideration. In particular:
    922 
    923 * Standard views:
    924 
    925  Pros:
    926 
    927  * They work out-of-the-box and don't require any dedicated data structure.
    928  * Creating and destroying them isn't expensive at all because they don't have
    929  any type of initialization.
    930  * They are the best tool for iterating entities for a single component.
    931  * They are the best tool for iterating entities for multiple components when
    932  one of the components is assigned to a significantly low number of entities.
    933  * They don't affect any other operations of the registry.
    934 
    935  Cons:
    936 
    937  * Their performance tend to degenerate when the number of components to
    938  iterate grows up and the most of the entities have all of them.
    939 
    940 * Persistent views:
    941 
    942  Pros:
    943 
    944  * Once prepared, creating and destroying them isn't expensive at all because
    945  they don't have any type of initialization.
    946  * They are the best tool for iterating entities for multiple components when
    947  most entities have them all.
    948 
    949  Cons:
    950 
    951  * They have dedicated data structures and thus affect the memory usage to a
    952  minimal extent.
    953  * If not previously prepared, the first time they are used they go through an
    954  initialization step that could take a while.
    955  * They affect to a minimum the creation and destruction of entities and
    956  components. In other terms: the more persistent views there will be, the
    957  less performing will be creating and destroying entities and components.
    958 
    959 * Raw views:
    960 
    961  Pros:
    962 
    963  * They work out-of-the-box and don't require any dedicated data structure.
    964  * Creating and destroying them isn't expensive at all because they don't have
    965  any type of initialization.
    966  * They are the best tool for iterating components when it is not necessary to
    967  know which entities they belong to.
    968  * They don't affect any other operations of the registry.
    969 
    970  Cons:
    971 
    972  * They can be used to iterate only one type of component at a time.
    973  * They don't return the entity to which a component belongs to the caller.
    974 
    975 * Runtime views:
    976 
    977  Pros:
    978 
    979  * Their lists of components are defined at runtime and not at compile-time.
    980  * Creating and destroying them isn't expensive at all because they don't have
    981  any type of initialization.
    982  * They are the best tool for things like plugin systems and mods in general.
    983  * They don't affect any other operations of the registry.
    984 
    985  Cons:
    986 
    987  * Their performances are definitely lower than those of all the other views,
    988  although they are still usable and sufficient for most of the purposes.
    989 
    990 To sum up and as a rule of thumb:
    991 
    992 * Use a raw view to iterate components only (no entities) for a given type.
    993 * Use a standard view to iterate entities and components for a single type.
    994 * Use a standard view to iterate entities and components for multiple types when
    995  the number of types is low. Standard views are really optimized and persistent
    996  views won't add much in this case.
    997 * Use a standard view to iterate entities and components for multiple types when
    998  a significantly low number of entities have one of the components.
    999 * Use a standard view in all those cases where a persistent view would give a
    1000  boost to performance but the iteration isn't performed frequently.
    1001 * Prepare and use a persistent view when you want to iterate only entities for
    1002  multiple components.
    1003 * Prepare and use a persistent view when you want to iterate entities for
    1004  multiple components and each component is assigned to a great number of
    1005  entities but the intersection between the sets of entities is small.
    1006 * Prepare and use a persistent view in all the cases where a standard view
    1007  wouldn't fit well otherwise.
    1008 * Finally, in case you don't know at compile-time what are the components to
    1009  use, choose a runtime view and set them during execution.
    1010 
    1011 To easily iterate entities and components, all the views offer the common
    1012 `begin` and `end` member functions that allow users to use a view in a typical
    1013 range-for loop. Almost all the views offer also a *more functional* `each`
    1014 member function that accepts a callback for convenience.<br/>
    1015 Continue reading for more details or refer to the inline documentation.
    1016 
    1017 ## Standard View
    1018 
    1019 A standard view behaves differently if it's constructed for a single component
    1020 or if it has been requested to iterate multiple components. Even the API is
    1021 different in the two cases.<br/>
    1022 All that they share is the way they are created by means of a registry:
    1023 
    1024 ```cpp
    1025 // single component standard view
    1026 auto single = registry.view<Position>();
    1027 
    1028 // multi component standard view
    1029 auto multi = registry.view<Position, Velocity>();
    1030 ```
    1031 
    1032 For all that remains, it's worth discussing them separately.<br/>
    1033 
    1034 ### Single component standard view
    1035 
    1036 Single component standard views are specialized in order to give a boost in
    1037 terms of performance in all the situation. This kind of views can access the
    1038 underlying data structures directly and avoid superfluous checks.<br/>
    1039 They offer a bunch of functionalities to get the number of entities they are
    1040 going to return and a raw access to the entity list as well as to the component
    1041 list. It's also possible to ask a view if it contains a given entity.<br/>
    1042 Refer to the inline documentation for all the details.
    1043 
    1044 There is no need to store views around for they are extremely cheap to
    1045 construct, even though they can be copied without problems and reused freely. In
    1046 fact, they return newly created and correctly initialized iterators whenever
    1047 `begin` or `end` are invoked.<br/>
    1048 To iterate a single component standard view, either use it in a range-for loop:
    1049 
    1050 ```cpp
    1051 auto view = registry.view<Renderable>();
    1052 
    1053 for(auto entity: view) {
    1054  Renderable &renderable = view.get(entity);
    1055 
    1056  // ...
    1057 }
    1058 ```
    1059 
    1060 Or rely on the `each` member function to iterate entities and get all their
    1061 components at once:
    1062 
    1063 ```cpp
    1064 registry.view<Renderable>().each([](auto entity, auto &renderable) {
    1065  // ...
    1066 });
    1067 ```
    1068 
    1069 The `each` member function is highly optimized. Unless users want to iterate
    1070 only entities, using `each` should be the preferred approach.
    1071 
    1072 **Note**: prefer the `get` member function of a view instead of the `get` member
    1073 function template of a registry during iterations, if possible. However, keep in
    1074 mind that it works only with the components of the view itself.
    1075 
    1076 ### Multi component standard view
    1077 
    1078 Multi component standard views iterate entities that have at least all the given
    1079 components in their bags. During construction, these views look at the number of
    1080 entities available for each component and pick up a reference to the smallest
    1081 set of candidates in order to speed up iterations.<br/>
    1082 They offer fewer functionalities than their companion views for single
    1083 component. In particular, a multi component standard view exposes utility
    1084 functions to get the estimated number of entities it is going to return and to
    1085 know whether it's empty or not. It's also possible to ask a view if it contains
    1086 a given entity.<br/>
    1087 Refer to the inline documentation for all the details.
    1088 
    1089 There is no need to store views around for they are extremely cheap to
    1090 construct, even though they can be copied without problems and reused freely. In
    1091 fact, they return newly created and correctly initialized iterators whenever
    1092 `begin` or `end` are invoked.<br/>
    1093 To iterate a multi component standard view, either use it in a range-for loop:
    1094 
    1095 ```cpp
    1096 auto view = registry.view<Position, Velocity>();
    1097 
    1098 for(auto entity: view) {
    1099  // a component at a time ...
    1100  Position &position = view.get<Position>(entity);
    1101  Velocity &velocity = view.get<Velocity>(entity);
    1102 
    1103  // ... or multiple components at once
    1104  std::tuple<Position &, Velocity &> tup = view.get<Position, Velocity>(entity);
    1105 
    1106  // ...
    1107 }
    1108 ```
    1109 
    1110 Or rely on the `each` member function to iterate entities and get all their
    1111 components at once:
    1112 
    1113 ```cpp
    1114 registry.view<Position, Velocity>().each([](auto entity, auto &position, auto &velocity) {
    1115  // ...
    1116 });
    1117 ```
    1118 
    1119 The `each` member function is highly optimized. Unless users want to iterate
    1120 only entities or get only some of the components, using `each` should be the
    1121 preferred approach.
    1122 
    1123 **Note**: prefer the `get` member function of a view instead of the `get` member
    1124 function template of a registry during iterations, if possible. However, keep in
    1125 mind that it works only with the components of the view itself.
    1126 
    1127 ## Persistent View
    1128 
    1129 A persistent view returns all the entities and only the entities that have at
    1130 least the given components. Moreover, it's guaranteed that the entity list is
    1131 tightly packed in memory for fast iterations.<br/>
    1132 In general, persistent views don't stay true to the order of any set of
    1133 components unless users explicitly sort them.
    1134 
    1135 Persistent views can be used only to iterate multiple components. To create this
    1136 kind of views, the tag `persistent_t` must also be used in order to disambiguate
    1137 overloads of the `view` member function:
    1138 
    1139 ```cpp
    1140 auto view = registry.view<Position, Velocity>(entt::persistent_t{});
    1141 ```
    1142 
    1143 There is no need to store views around for they are extremely cheap to
    1144 construct, even though they can be copied without problems and reused freely. In
    1145 fact, they return newly created and correctly initialized iterators whenever
    1146 `begin` or `end` are invoked.<br/>
    1147 That being said, persistent views perform an initialization step the very first
    1148 time they are constructed and this could be quite costly. To avoid it, consider
    1149 asking to the registry to _prepare_ them when no entities have been created yet:
    1150 
    1151 ```cpp
    1152 registry.prepare<Position, Velocity>();
    1153 ```
    1154 
    1155 If the registry is empty, preparation is extremely fast. Moreover the `prepare`
    1156 member function template is idempotent. Feel free to invoke it even more than
    1157 once: if the view has been already prepared before, the function returns
    1158 immediately and does nothing.
    1159 
    1160 A persistent view offers a bunch of functionalities to get the number of
    1161 entities it's going to return, a raw access to the entity list and the
    1162 possibility to sort the underlying data structures according to the order of one
    1163 of the components for which it has been constructed. It's also possible to ask a
    1164 view if it contains a given entity.<br/>
    1165 Refer to the inline documentation for all the details.
    1166 
    1167 To iterate a persistent view, either use it in a range-for loop:
    1168 
    1169 ```cpp
    1170 auto view = registry.view<Position, Velocity>(entt::persistent_t{});
    1171 
    1172 for(auto entity: view) {
    1173  // a component at a time ...
    1174  Position &position = view.get<Position>(entity);
    1175  Velocity &velocity = view.get<Velocity>(entity);
    1176 
    1177  // ... or multiple components at once
    1178  std::tuple<Position &, Velocity &> tup = view.get<Position, Velocity>(entity);
    1179 
    1180  // ...
    1181 }
    1182 ```
    1183 
    1184 Or rely on the `each` member function to iterate entities and get all their
    1185 components at once:
    1186 
    1187 ```cpp
    1188 registry.view<Position, Velocity>(entt::persistent_t{}).each([](auto entity, auto &position, auto &velocity) {
    1189  // ...
    1190 });
    1191 ```
    1192 
    1193 Performance are more or less the same. The best approach depends mainly on
    1194 whether all the components have to be accessed or not.
    1195 
    1196 **Note**: prefer the `get` member function of a view instead of the `get` member
    1197 function template of a registry during iterations, if possible. However, keep in
    1198 mind that it works only with the components of the view itself.
    1199 
    1200 ## Raw View
    1201 
    1202 Raw views return all the components of a given type. This kind of views can
    1203 access components directly and avoid extra indirections like when components are
    1204 accessed via an entity identifier.<br/>
    1205 They offer a bunch of functionalities to get the number of instances they are
    1206 going to return and a raw access to the entity list as well as to the component
    1207 list.<br/>
    1208 Refer to the inline documentation for all the details.
    1209 
    1210 Raw views can be used only to iterate components for a single type. To create
    1211 this kind of views, the tag `raw_t` must also be used in order to disambiguate
    1212 overloads of the `view` member function:
    1213 
    1214 ```cpp
    1215 auto view = registry.view<Renderable>(entt::raw_t{});
    1216 ```
    1217 
    1218 There is no need to store views around for they are extremely cheap to
    1219 construct, even though they can be copied without problems and reused freely. In
    1220 fact, they return newly created and correctly initialized iterators whenever
    1221 `begin` or `end` are invoked.<br/>
    1222 To iterate a raw view, use it in a range-for loop:
    1223 
    1224 ```cpp
    1225 auto view = registry.view<Renderable>(entt::raw_t{});
    1226 
    1227 for(auto &&component: raw) {
    1228  // ...
    1229 }
    1230 ```
    1231 
    1232 Or rely on the `each` member function:
    1233 
    1234 ```cpp
    1235 registry.view<Renderable>(entt::raw_t{}).each([](auto &renderable) {
    1236  // ...
    1237 });
    1238 ```
    1239 
    1240 Performance are exactly the same in both cases.
    1241 
    1242 **Note**: raw views don't have a `get` member function for obvious reasons.
    1243 
    1244 ## Runtime View
    1245 
    1246 Runtime views iterate entities that have at least all the given components in
    1247 their bags. During construction, these views look at the number of entities
    1248 available for each component and pick up a reference to the smallest
    1249 set of candidates in order to speed up iterations.<br/>
    1250 They offer more or less the same functionalities of a multi component standard
    1251 view. However, they don't expose a `get` member function and users should refer
    1252 to the registry that generated the view to access components. In particular, a
    1253 runtime view exposes utility functions to get the estimated number of entities
    1254 it is going to return and to know whether it's empty or not. It's also possible
    1255 to ask a view if it contains a given entity.<br/>
    1256 Refer to the inline documentation for all the details.
    1257 
    1258 Runtime view are extremely cheap to construct and should not be stored around in
    1259 any case. They should be used immediately after creation and then they should be
    1260 thrown away. The reasons for this go far beyond the scope of this document.<br/>
    1261 To iterate a runtime view, either use it in a range-for loop:
    1262 
    1263 ```cpp
    1264 using component_type = typename decltype(registry)::component_type;
    1265 component_type types[] = { registry.type<Position>(), registry.type<Velocity>() };
    1266 
    1267 auto view = registry.view(std::cbegin(types), std::cend(types));
    1268 
    1269 for(auto entity: view) {
    1270  // a component at a time ...
    1271  Position &position = registry.get<Position>(entity);
    1272  Velocity &velocity = registry.get<Velocity>(entity);
    1273 
    1274  // ... or multiple components at once
    1275  std::tuple<Position &, Velocity &> tup = view.get<Position, Velocity>(entity);
    1276 
    1277  // ...
    1278 }
    1279 ```
    1280 
    1281 Or rely on the `each` member function to iterate entities:
    1282 
    1283 ```cpp
    1284 using component_type = typename decltype(registry)::component_type;
    1285 component_type types[] = { registry.type<Position>(), registry.type<Velocity>() };
    1286 
    1287 auto view = registry.view(std::cbegin(types), std::cend(types)).each([](auto entity) {
    1288  // ...
    1289 });
    1290 ```
    1291 
    1292 Performance are exactly the same in both cases.
    1293 
    1294 **Note**: runtime views are meant for all those cases where users don't know at
    1295 compile-time what components to use to iterate entities. This is particularly
    1296 well suited to plugin systems and mods in general. Where possible, don't use
    1297 runtime views, as their performance are slightly inferior to those of the other
    1298 views.
    1299 
    1300 
    1301 ## Give me everything
    1302 
    1303 Views are narrow windows on the entire list of entities. They work by filtering
    1304 entities according to their components.<br/>
    1305 In some cases there may be the need to iterate all the entities still in use
    1306 regardless of their components. The registry offers a specific member function
    1307 to do that:
    1308 
    1309 ```cpp
    1310 registry.each([](auto entity) {
    1311  // ...
    1312 });
    1313 ```
    1314 
    1315 It returns to the caller all the entities that are still in use by means of the
    1316 given function.<br/>
    1317 As a rule of thumb, consider using a view if the goal is to iterate entities
    1318 that have a determinate set of components. A view is usually much faster than
    1319 combining this function with a bunch of custom tests.<br/>
    1320 In all the other cases, this is the way to go.
    1321 
    1322 There exists also another member function to use to retrieve orphans. An orphan
    1323 is an entity that is still in use and has neither assigned components nor
    1324 tags.<br/>
    1325 The signature of the function is the same of `each`:
    1326 
    1327 ```cpp
    1328 registry.orphans([](auto entity) {
    1329  // ...
    1330 });
    1331 ```
    1332 
    1333 To test the _orphanity_ of a single entity, use the member function `orphan`
    1334 instead. It accepts a valid entity identifer as an argument and returns true in
    1335 case the entity is an orphan, false otherwise.
    1336 
    1337 In general, all these functions can result in poor performance.<br/>
    1338 `each` is fairly slow because of some checks it performs on each and every
    1339 entity. For similar reasons, `orphans` can be even slower. Both functions should
    1340 not be used frequently to avoid the risk of a performance hit.
    1341 
    1342 # Iterations: what is allowed and what is not
    1343 
    1344 Most of the _ECS_ available out there have some annoying limitations (at least
    1345 from my point of view): entities and components cannot be created nor destroyed
    1346 during iterations.<br/>
    1347 `EnTT` partially solves the problem with a few limitations:
    1348 
    1349 * Creating entities and components is allowed during iterations.
    1350 * Deleting an entity or removing its components is allowed during iterations if
    1351  it's the one currently returned by the view. For all the other entities,
    1352  destroying them or removing their components isn't allowed and it can result
    1353  in undefined behavior.
    1354 
    1355 Iterators are invalidated and the behavior is undefined if an entity is modified
    1356 or destroyed and it's not the one currently returned by the view nor a newly
    1357 created one.<br/>
    1358 To work around it, possible approaches are:
    1359 
    1360 * Store aside the entities and the components to be removed and perform the
    1361  operations at the end of the iteration.
    1362 * Mark entities and components with a proper tag component that indicates they
    1363  must be purged, then perform a second iteration to clean them up one by one.
    1364 
    1365 A notable side effect of this feature is that the number of required allocations
    1366 is further reduced in most of the cases.
    1367 
    1368 # Multithreading
    1369 
    1370 In general, the entire registry isn't thread safe as it is. Thread safety isn't
    1371 something that users should want out of the box for several reasons. Just to
    1372 mention one of them: performance.<br/>
    1373 Views and consequently the approach adopted by `EnTT` are the great exception to
    1374 the rule. It's true that views and thus their iterators aren't thread safe by
    1375 themselves. Because of this users shouldn't try to iterate a set of components
    1376 and modify the same set concurrently. However:
    1377 
    1378 * As long as a thread iterates the entities that have the component `X` or
    1379  assign and removes that component from a set of entities, another thread can
    1380  safely do the same with components `Y` and `Z` and everything will work like a
    1381  charm. As a trivial example, users can freely execute the rendering system and
    1382  iterate the renderable entities while updating a physic component concurrently
    1383  on a separate thread.
    1384 
    1385 * Similarly, a single set of components can be iterated by multiple threads as
    1386  long as the components are neither assigned nor removed in the meantime. In
    1387  other words, a hypothetical movement system can start multiple threads, each
    1388  of which will access the components that carry information about velocity and
    1389  position for its entities.
    1390 
    1391 This kind of entity-component systems can be used in single threaded
    1392 applications as well as along with async stuff or multiple threads. Moreover,
    1393 typical thread based models for _ECS_ don't require a fully thread safe registry
    1394 to work. Actually, users can reach the goal with the registry as it is while
    1395 working with most of the common models.
    1396 
    1397 Because of the few reasons mentioned above and many others not mentioned, users
    1398 are completely responsible for synchronization whether required. On the other
    1399 hand, they could get away with it without having to resort to particular
    1400 expedients.
    +
    1 # Crash Course: entity-component system
    2 
    3 <!--
    4 @cond TURN_OFF_DOXYGEN
    5 -->
    6 # Table of Contents
    7 
    8 * [Introduction](#introduction)
    9 * [Design decisions](#design-decisions)
    10  * [A bitset-free entity-component system](#a-bitset-free-entity-component-system)
    11  * [Pay per use](#pay-per-use)
    12  * [All or nothing](#all-or-nothing)
    13  * [Stateless systems](#stateless-systems)
    14 * [Vademecum](#vademecum)
    15 * [The Registry, the Entity and the Component](#the-registry-the-entity-and-the-component)
    16  * [Observe changes](#observe-changes)
    17  * [Runtime components](#runtime-components)
    18  * [A journey through a plugin](#a-journey-through-a-plugin)
    19  * [Sorting: is it possible?](#sorting-is-it-possible)
    20  * [Snapshot: complete vs continuous](#snapshot-complete-vs-continuous)
    21  * [Snapshot loader](#snapshot-loader)
    22  * [Continuous loader](#continuous-loader)
    23  * [Archives](#archives)
    24  * [One example to rule them all](#one-example-to-rule-them-all)
    25  * [Prototype](#prototype)
    26  * [Helpers](#helpers)
    27  * [Dependency function](#dependency-function)
    28  * [Tags](#tags)
    29  * [Null entity](#null-entity)
    30  * [Context variables](#context-variables)
    31 * [Views and Groups](#views-and-groups)
    32  * [Views](#views)
    33  * [Runtime views](#runtime-views)
    34  * [Groups](#groups)
    35  * [Full-owning groups](#full-owning-groups)
    36  * [Partial-owning groups](#partial-owning-groups)
    37  * [Non-owning groups](#non-owning-groups)
    38  * [Types: const, non-const and all in between](#types-const-non-const-and-all-in-between)
    39  * [Give me everything](#give-me-everything)
    40  * [What is allowed and what is not](#what-is-allowed-and-what-is-not)
    41  * [More performance, more constraints](#more-performance-more-constraints)
    42 * [Empty type optimization](#empty-type-optimization)
    43 * [Multithreading](#multithreading)
    44  * [Iterators](#iterators)
    45 <!--
    46 @endcond TURN_OFF_DOXYGEN
    47 -->
    48 
    49 # Introduction
    50 
    51 `EnTT` is a header-only, tiny and easy to use entity-component system (and much
    52 more) written in modern C++.<br/>
    53 The entity-component-system (also known as _ECS_) is an architectural pattern
    54 used mostly in game development.
    55 
    56 # Design decisions
    57 
    58 ## A bitset-free entity-component system
    59 
    60 `EnTT` is a _bitset-free_ entity-component system that doesn't require users to
    61 specify the component set at compile-time.<br/>
    62 This is why users can instantiate the core class simply like:
    63 
    64 ```cpp
    65 entt::registry registry;
    66 ```
    67 
    68 In place of its more annoying and error-prone counterpart:
    69 
    70 ```cpp
    71 entt::registry<comp_0, comp_1, ..., comp_n> registry;
    72 ```
    73 
    74 ## Pay per use
    75 
    76 `EnTT` is entirely designed around the principle that users have to pay only for
    77 what they want.
    78 
    79 When it comes to using an entity-component system, the tradeoff is usually
    80 between performance and memory usage. The faster it is, the more memory it uses.
    81 Even worse, some approaches tend to heavily affect other functionalities like
    82 the construction and destruction of components to favor iterations, even when it
    83 isn't strictly required. In fact, slightly worse performance along non-critical
    84 paths are the right price to pay to reduce memory usage and have overall better
    85 perfomance sometimes and I've always wondered why this kind of tools do not
    86 leave me the choice.<br/>
    87 `EnTT` follows a completely different approach. It gets the best out from the
    88 basic data structures and gives users the possibility to pay more for higher
    89 performance where needed.<br/>
    90 The disadvantage of this approach is that users need to know the systems they
    91 are working on and the tools they are using. Otherwise, the risk to ruin the
    92 performance along critical paths is high.
    93 
    94 So far, this choice has proven to be a good one and I really hope it can be for
    95 many others besides me.
    96 
    97 ## All or nothing
    98 
    99 `EnTT` is such that at every moment a pair `(T *, size)` is available to
    100 directly access all the instances of a given component type `T`.<br/>
    101 This was a guideline and a design decision that influenced many choices, for
    102 better and for worse. I cannot say whether it will be useful or not to the
    103 reader, but it's worth to mention it, because it's one of the corner stones of
    104 this library.
    105 
    106 Many of the tools described below, from the registry to the views and up to the
    107 groups give the possibility to get this information and have been designed
    108 around this need, which was and remains one of my main requirements during the
    109 development.<br/>
    110 The rest is experimentation and the desire to invent something new, hoping to
    111 have succeeded.
    112 
    113 ## Stateless systems
    114 
    115 `EnTT` is designed so that it can work with _stateless systems_. In other words,
    116 all systems can be free functions and there is no need to define them as classes
    117 (although nothing prevents users from doing so).<br/>
    118 This is possible because the main class with which the users will work provides
    119 all what is needed to act as the sole _source of truth_ of an application.
    120 
    121 To be honest, this point became part of the design principles at a later date,
    122 but has also become one of the cornerstones of the library to date, as stateless
    123 systems are widely used and appreciated in general.
    124 
    125 # Vademecum
    126 
    127 The registry to store, the views and the groups to iterate. That's all.
    128 
    129 An entity (the _E_ of an _ECS_) is an opaque identifier that users should just
    130 use as-is and store around if needed. Do not try to inspect an entity
    131 identifier, its format can change in future and a registry offers all the
    132 functionalities to query them out-of-the-box. The underlying type of an entity
    133 (either `std::uint16_t`, `std::uint32_t` or `std::uint64_t`) can be specified
    134 when defining a registry (actually `entt::registry` is nothing more than an
    135 alias for `entt::basic_registry<entt::entity>` and `entt::entity` is an alias
    136 for `std::uint32_t`).<br/>
    137 Components (the _C_ of an _ECS_) should be plain old data structures or more
    138 complex and movable data structures with a proper constructor. Actually, the
    139 sole requirement of a component type is that it must be both move constructible
    140 and move assignable. They are list initialized by using the parameters provided
    141 to construct the component itself. No need to register components or their types
    142 neither with the registry nor with the entity-component system at all.<br/>
    143 Systems (the _S_ of an _ECS_) are just plain functions, functors, lambdas or
    144 whatever users want. They can accept a registry, a view or a group of any type
    145 and use them the way they prefer. No need to register systems or their types
    146 neither with the registry nor with the entity-component system at all.
    147 
    148 The following sections will explain in short how to use the entity-component
    149 system, the core part of the whole library.<br/>
    150 In fact, the project is composed of many other classes in addition to those
    151 describe below. For more details, please refer to the inline documentation.
    152 
    153 # The Registry, the Entity and the Component
    154 
    155 A registry can store and manage entities, as well as create views and groups to
    156 iterate the underlying data structures.<br/>
    157 The class template `basic_registry` lets users decide what's the preferred type
    158 to represent an entity. Because `std::uint32_t` is large enough for almost all
    159 the cases, there exists also the alias `entt::entity` for it, as well as the
    160 alias `entt::registry` for `entt::basic_registry<entt::entity>`.
    161 
    162 Entities are represented by _entity identifiers_. An entity identifier is an
    163 opaque type that users should not inspect or modify in any way. It carries
    164 information about the entity itself and its version.
    165 
    166 A registry can be used both to construct and to destroy entities:
    167 
    168 ```cpp
    169 // constructs a naked entity with no components and returns its identifier
    170 auto entity = registry.create();
    171 
    172 // destroys an entity and all its components
    173 registry.destroy(entity);
    174 ```
    175 
    176 There exists also an overload of the `create` and `destroy` member functions
    177 that accepts two iterators, that is a range to assign or to destroy. It can be
    178 used to create or destroy multiple entities at once:
    179 
    180 ```cpp
    181 // destroys all the entities in a range
    182 auto view = registry.view<a_component, another_component>();
    183 registry.destroy(view.begin(), view.end());
    184 ```
    185 
    186 In both cases, the `create` member function accepts also a list of default
    187 constructible types of components to assign to the entities before to return.
    188 It's a faster alternative to the creation and subsequent assignment of
    189 components in separate steps.
    190 
    191 When an entity is destroyed, the registry can freely reuse it internally with a
    192 slightly different identifier. In particular, the version of an entity is
    193 increased each and every time it's discarded.<br/>
    194 In case entity identifiers are stored around, the registry offers all the
    195 functionalities required to test them and to get out of them the information
    196 they carry:
    197 
    198 ```cpp
    199 // returns true if the entity is still valid, false otherwise
    200 bool b = registry.valid(entity);
    201 
    202 // gets the version contained in the entity identifier
    203 auto version = registry.version(entity);
    204 
    205 // gets the actual version for the given entity
    206 auto curr = registry.current(entity);
    207 ```
    208 
    209 Components can be assigned to or removed from entities at any time with a few
    210 calls to member functions of the registry. As for the entities, the registry
    211 offers also a set of functionalities users can use to work with the components.
    212 
    213 The `assign` member function template creates, initializes and assigns to an
    214 entity the given component. It accepts a variable number of arguments to
    215 construct the component itself if present:
    216 
    217 ```cpp
    218 registry.assign<position>(entity, 0., 0.);
    219 
    220 // ...
    221 
    222 auto &velocity = registry.assign<velocity>(entity);
    223 vel.dx = 0.;
    224 vel.dy = 0.;
    225 ```
    226 
    227 If an entity already has the given component, the `replace` member function
    228 template can be used to replace it:
    229 
    230 ```cpp
    231 registry.replace<position>(entity, 0., 0.);
    232 
    233 // ...
    234 
    235 auto &velocity = registry.replace<velocity>(entity);
    236 vel.dx = 0.;
    237 vel.dy = 0.;
    238 ```
    239 
    240 In case users want to assign a component to an entity, but it's unknown whether
    241 the entity already has it or not, `assign_or_replace` does the work in a single
    242 call (there is a performance penalty to pay for this mainly due to the fact that
    243 it has to check if the entity already has the given component or not):
    244 
    245 ```cpp
    246 registry.assign_or_replace<position>(entity, 0., 0.);
    247 
    248 // ...
    249 
    250 auto &velocity = registry.assign_or_replace<velocity>(entity);
    251 vel.dx = 0.;
    252 vel.dy = 0.;
    253 ```
    254 
    255 Note that `assign_or_replace` is a slightly faster alternative for the following
    256 `if/else` statement and nothing more:
    257 
    258 ```cpp
    259 if(registry.has<comp>(entity)) {
    260  registry.replace<comp>(entity, arg1, argN);
    261 } else {
    262  registry.assign<comp>(entity, arg1, argN);
    263 }
    264 ```
    265 
    266 As already shown, if in doubt about whether or not an entity has one or more
    267 components, the `has` member function template may be useful:
    268 
    269 ```cpp
    270 bool b = registry.has<position, velocity>(entity);
    271 ```
    272 
    273 On the other side, if the goal is to delete a single component, the `remove`
    274 member function template is the way to go when it's certain that the entity owns
    275 a copy of the component:
    276 
    277 ```cpp
    278 registry.remove<position>(entity);
    279 ```
    280 
    281 Otherwise consider to use the `reset` member function. It behaves similarly to
    282 `remove` but with a strictly defined behavior (and a performance penalty is the
    283 price to pay for this). In particular it removes the component if and only if it
    284 exists, otherwise it returns safely to the caller:
    285 
    286 ```cpp
    287 registry.reset<position>(entity);
    288 ```
    289 
    290 There exist also two other _versions_ of the `reset` member function:
    291 
    292 * If no entity is passed to it, `reset` will remove the given component from
    293  each entity that has it:
    294 
    295  ```cpp
    296  registry.reset<position>();
    297  ```
    298 
    299 * If neither the entity nor the component are specified, all the entities still
    300  in use and their components are destroyed:
    301 
    302  ```cpp
    303  registry.reset();
    304  ```
    305 
    306 Finally, references to components can be retrieved simply by doing this:
    307 
    308 ```cpp
    309 const auto &cregistry = registry;
    310 
    311 // const and non-const reference
    312 const auto &crenderable = cregistry.get<renderable>(entity);
    313 auto &renderable = registry.get<renderable>(entity);
    314 
    315 // const and non-const references
    316 const auto &[cpos, cvel] = cregistry.get<position, velocity>(entity);
    317 auto &[pos, vel] = registry.get<position, velocity>(entity);
    318 ```
    319 
    320 The `get` member function template gives direct access to the component of an
    321 entity stored in the underlying data structures of the registry. There exists
    322 also an alternative member function named `try_get` that returns a pointer to
    323 the component owned by an entity if any, a null pointer otherwise.
    324 
    325 ## Observe changes
    326 
    327 Because of how the registry works internally, it stores a bunch of signal
    328 handlers for each pool in order to notify some of its data structures on the
    329 construction and destruction of components or when an instance of a component is
    330 explicitly replaced by the user.<br/>
    331 These signal handlers are also exposed and made available to users. These are
    332 the basic bricks to build fancy things like dependencies and reactive systems.
    333 
    334 To get a sink to be used to connect and disconnect listeners so as to be
    335 notified on the creation of a component, use the `on_construct` member function:
    336 
    337 ```cpp
    338 // connects a free function
    339 registry.on_construct<position>().connect<&my_free_function>();
    340 
    341 // connects a member function
    342 registry.on_construct<position>().connect<&my_class::member>(&instance);
    343 
    344 // disconnects a free function
    345 registry.on_construct<position>().disconnect<&my_free_function>();
    346 
    347 // disconnects a member function
    348 registry.on_construct<position>().disconnect<&my_class::member>(&instance);
    349 ```
    350 
    351 To be notified when components are destroyed, use the `on_destroy` member
    352 function instead. Finally, the `on_replace` member function will return a sink
    353 to which to connect listeners to observe changes on components.
    354 
    355 The function type of a listener for the construction signal should be equivalent
    356 to the following:
    357 
    358 ```cpp
    359 void(entt::registry &, entt::entity, Component &);
    360 ```
    361 
    362 Where `Component` is intuitively the type of component of interest. In other
    363 words, a listener is provided with the registry that triggered the notification
    364 and the entity affected by the change, in addition to the newly created
    365 instance.<br/>
    366 The sink returned by the `on_replace` member function accepts listeners the
    367 signature of which is the same of that of the construction signal. The one of
    368 the destruction signal is also similar, except for the `Component` parameter:
    369 
    370 ```cpp
    371 void(entt::registry &, entt::entity);
    372 ```
    373 
    374 This is mainly due to performance reasons. While the component is made available
    375 after the construction, it is not when destroyed. Because of that, there are no
    376 reasons to get it from the underlying storage unless the user requires so. In
    377 this case, the registry is made available for the purpose.
    378 
    379 Note also that:
    380 
    381 * Listeners for the construction signal are invoked **after** components have
    382  been assigned to entities.
    383 * Listeners designed to observe changes are invoked **before** components have
    384  been replaced and therefore before newly created instances have been assigned
    385  to entities.
    386 * Listeners for the destruction signal are invoked **before** components have
    387  been removed from entities.
    388 * The order of invocation of the listeners isn't guaranteed in any case.
    389 
    390 There are also some limitations on what a listener can and cannot do. In
    391 particular:
    392 
    393 * Connecting and disconnecting other functions from within the body of a
    394  listener should be avoided. It can lead to undefined behavior in some cases.
    395 * Assigning and removing components from within the body of a listener that
    396  observes the destruction of instances of a given type should be avoided. It
    397  can lead to undefined behavior in some cases. This type of listeners is
    398  intended to provide users with an easy way to perform cleanup and nothing
    399  more.
    400 
    401 To a certain extent, these limitations don't apply. However, it's risky to try
    402 to force them and users should respect the limitations unless they know exactly
    403 what they are doing. Subtle bugs are the price to pay in case of errors
    404 otherwise.
    405 
    406 In general, events and therefore listeners must not be used as replacements for
    407 systems. They should not contain much logic and interactions with a registry
    408 should be kept to a minimum, if possible. Note also that the greater the number
    409 of listeners, the greater the performance hit when components are created or
    410 destroyed.
    411 
    412 ## Runtime components
    413 
    414 Defining components at runtime is useful to support plugin systems and mods in
    415 general. However, it seems impossible with a tool designed around a bunch of
    416 templates. Indeed it's not that difficult.<br/>
    417 Of course, some features cannot be easily exported into a runtime
    418 environment. As an example, sorting a group of components defined at runtime
    419 isn't for free if compared to most of the other operations. However, the basic
    420 functionalities of an entity-component system such as `EnTT` fit the problem
    421 perfectly and can also be used to manage runtime components if required.<br/>
    422 All that is necessary to do it is to know the identifiers of the components. An
    423 identifier is nothing more than a number or similar that can be used at runtime
    424 to work with the type system.
    425 
    426 In `EnTT`, identifiers are easily accessible:
    427 
    428 ```cpp
    429 entt::registry registry;
    430 
    431 // component identifier
    432 auto type = registry.type<position>();
    433 ```
    434 
    435 Once the identifiers are made available, almost everything becomes pretty
    436 simple.
    437 
    438 ### A journey through a plugin
    439 
    440 `EnTT` comes with an example (actually a test) that shows how to integrate
    441 compile-time and runtime components in a stack based JavaScript environment. It
    442 uses [`Duktape`](https://github.com/svaarala/duktape) under the hood, mainly
    443 because I wanted to learn how it works at the time I was writing the code.
    444 
    445 The code is not production-ready and overall performance can be highly improved.
    446 However, I sacrificed optimizations in favor of a more readable piece of code. I
    447 hope I succeeded.<br/>
    448 Note also that this isn't neither the only nor (probably) the best way to do it.
    449 In fact, the right way depends on the scripting language and the problem one is
    450 facing in general.<br/>
    451 That being said, feel free to use it at your own risk.
    452 
    453 The basic idea is that of creating a compile-time component aimed to map all the
    454 runtime components assigned to an entity.<br/>
    455 Identifiers come in use to address the right function from a map when invoked
    456 from the runtime environment and to filter entities when iterating.<br/>
    457 With a bit of gymnastic, one can narrow views and improve the performance to
    458 some extent but it was not the goal of the example.
    459 
    460 ## Sorting: is it possible?
    461 
    462 It goes without saying that sorting entities and components is possible with
    463 `EnTT`.<br/>
    464 In fact, there are two functions that respond to slightly different needs:
    465 
    466 * Components can be sorted either directly:
    467 
    468  ```cpp
    469  registry.sort<renderable>([](const auto &lhs, const auto &rhs) {
    470  return lhs.z < rhs.z;
    471 
    472  });
    473  ```
    474 
    475  Or by accessing their entities:
    476 
    477  ```cpp
    478  registry.sort<renderable>([](const entt::entity lhs, const entt::entity rhs) {
    479  return entt::registry::entity(lhs) < entt::registry::entity(rhs);
    480  });
    481  ```
    482 
    483  There exists also the possibility to use a custom sort function object, as
    484  long as it adheres to the requirements described in the inline
    485  documentation.<br/>
    486  This is possible mainly because users can get much more with a custom sort
    487  function object if the usage pattern is known. As an example, in case of an
    488  almost sorted pool, quick sort could be much, much slower than insertion sort.
    489 
    490 * Components can be sorted according to the order imposed by another component:
    491 
    492  ```cpp
    493  registry.sort<movement, physics>();
    494  ```
    495 
    496  In this case, instances of `movement` are arranged in memory so that cache
    497  misses are minimized when the two components are iterated together.
    498 
    499 ## Snapshot: complete vs continuous
    500 
    501 The `registry` class offers basic support to serialization.<br/>
    502 It doesn't convert components to bytes directly, there wasn't the need of
    503 another tool for serialization out there. Instead, it accepts an opaque object
    504 with a suitable interface (namely an _archive_) to serialize its internal data
    505 structures and restore them later. The way types and instances are converted to
    506 a bunch of bytes is completely in charge to the archive and thus to final users.
    507 
    508 The goal of the serialization part is to allow users to make both a dump of the
    509 entire registry or a narrower snapshot, that is to select only the components in
    510 which they are interested.<br/>
    511 Intuitively, the use cases are different. As an example, the first approach is
    512 suitable for local save/restore functionalities while the latter is suitable for
    513 creating client-server applications and for transferring somehow parts of the
    514 representation side to side.
    515 
    516 To take a snapshot of the registry, use the `snapshot` member function. It
    517 returns a temporary object properly initialized to _save_ the whole registry or
    518 parts of it.
    519 
    520 Example of use:
    521 
    522 ```cpp
    523 output_archive output;
    524 
    525 registry.snapshot()
    526  .entities(output)
    527  .destroyed(output)
    528  .component<a_component, another_component>(output);
    529 ```
    530 
    531 It isn't necessary to invoke all these functions each and every time. What
    532 functions to use in which case mostly depends on the goal and there is not a
    533 golden rule to do that.
    534 
    535 The `entities` member function asks the registry to serialize all the entities
    536 that are still in use along with their versions. On the other side, the
    537 `destroyed` member function tells to the registry to serialize the entities that
    538 have been destroyed and are no longer in use.<br/>
    539 These two functions can be used to save and restore the whole set of entities
    540 with the versions they had during serialization.
    541 
    542 The `component` member function is a function template the aim of which is to
    543 store aside components. The presence of a template parameter list is a
    544 consequence of a couple of design choices from the past and in the present:
    545 
    546 * First of all, there is no reason to force a user to serialize all the
    547  components at once and most of the times it isn't desiderable. As an example,
    548  in case the stuff for the HUD in a game is put into the registry for some
    549  reasons, its components can be freely discarded during a serialization step
    550  because probably the software already knows how to reconstruct the HUD
    551  correctly from scratch.
    552 
    553 * Furthermore, the registry makes heavy use of _type-erasure_ techniques
    554  internally and doesn't know at any time what types of components it contains.
    555  Therefore being explicit at the call point is mandatory.
    556 
    557 There exists also another version of the `component` member function that
    558 accepts a range of entities to serialize. This version is a bit slower than the
    559 other one, mainly because it iterates the range of entities more than once for
    560 internal purposes. However, it can be used to filter out those entities that
    561 shouldn't be serialized for some reasons.<br/>
    562 As an example:
    563 
    564 ```cpp
    565 const auto view = registry.view<serialize>();
    566 output_archive output;
    567 
    568 registry.snapshot().component<a_component, another_component>(output, view.cbegin(), view.cend());
    569 ```
    570 
    571 Note that `component` stores items along with entities. It means that it works
    572 properly without a call to the `entities` member function.
    573 
    574 Once a snapshot is created, there exist mainly two _ways_ to load it: as a whole
    575 and in a kind of _continuous mode_.<br/>
    576 The following sections describe both loaders and archives in details.
    577 
    578 ### Snapshot loader
    579 
    580 A snapshot loader requires that the destination registry be empty and loads all
    581 the data at once while keeping intact the identifiers that the entities
    582 originally had.<br/>
    583 To do that, the registry offers a member function named `loader` that returns a
    584 temporary object properly initialized to _restore_ a snapshot.
    585 
    586 Example of use:
    587 
    588 ```cpp
    589 input_archive input;
    590 
    591 registry.loader()
    592  .entities(input)
    593  .destroyed(input)
    594  .component<a_component, another_component>(input)
    595  .orphans();
    596 ```
    597 
    598 It isn't necessary to invoke all these functions each and every time. What
    599 functions to use in which case mostly depends on the goal and there is not a
    600 golden rule to do that. For obvious reasons, what is important is that the data
    601 are restored in exactly the same order in which they were serialized.
    602 
    603 The `entities` and `destroyed` member functions restore the sets of entities and
    604 the versions that the entities originally had at the source.
    605 
    606 The `component` member function restores all and only the components specified
    607 and assigns them to the right entities. Note that the template parameter list
    608 must be exactly the same used during the serialization.
    609 
    610 The `orphans` member function literally destroys those entities that have no
    611 components attached. It's usually useless if the snapshot is a full dump of the
    612 source. However, in case all the entities are serialized but only few components
    613 are saved, it could happen that some of the entities have no components once
    614 restored. The best users can do to deal with them is to destroy those entities
    615 and thus update their versions.
    616 
    617 ### Continuous loader
    618 
    619 A continuous loader is designed to load data from a source registry to a
    620 (possibly) non-empty destination. The loader can accommodate in a registry more
    621 than one snapshot in a sort of _continuous loading_ that updates the
    622 destination one step at a time.<br/>
    623 Identifiers that entities originally had are not transferred to the target.
    624 Instead, the loader maps remote identifiers to local ones while restoring a
    625 snapshot. Because of that, this kind of loader offers a way to update
    626 automatically identifiers that are part of components (as an example, as data
    627 members or gathered in a container).<br/>
    628 Another difference with the snapshot loader is that the continuous loader does
    629 not need to work with the private data structures of a registry. Furthermore, it
    630 has an internal state that must persist over time. Therefore, there is no reason
    631 to create it by means of a registry, or to limit its lifetime to that of a
    632 temporary object.
    633 
    634 Example of use:
    635 
    636 ```cpp
    637 entt::continuous_loader<entt::entity> loader{registry};
    638 input_archive input;
    639 
    640 loader.entities(input)
    641  .destroyed(input)
    642  .component<a_component, another_component, dirty_component>(input, &dirty_component::parent, &dirty_component::child)
    643  .orphans()
    644  .shrink();
    645 ```
    646 
    647 It isn't necessary to invoke all these functions each and every time. What
    648 functions to use in which case mostly depends on the goal and there is not a
    649 golden rule to do that. For obvious reasons, what is important is that the data
    650 are restored in exactly the same order in which they were serialized.
    651 
    652 The `entities` and `destroyed` member functions restore groups of entities and
    653 map each entity to a local counterpart when required. In other terms, for each
    654 remote entity identifier not yet registered by the loader, the latter creates a
    655 local identifier so that it can keep the local entity in sync with the remote
    656 one.
    657 
    658 The `component` member function restores all and only the components specified
    659 and assigns them to the right entities.<br/>
    660 In case the component contains entities itself (either as data members of type
    661 `entt::entity` or as containers of entities), the loader can update them
    662 automatically. To do that, it's enough to specify the data members to update as
    663 shown in the example.
    664 
    665 The `orphans` member function literally destroys those entities that have no
    666 components after a restore. It has exactly the same purpose described in the
    667 previous section and works the same way.
    668 
    669 Finally, `shrink` helps to purge local entities that no longer have a remote
    670 conterpart. Users should invoke this member function after restoring each
    671 snapshot, unless they know exactly what they are doing.
    672 
    673 ### Archives
    674 
    675 Archives must publicly expose a predefined set of member functions. The API is
    676 straightforward and consists only of a group of function call operators that
    677 are invoked by the snapshot class and the loaders.
    678 
    679 In particular:
    680 
    681 * An output archive, the one used when creating a snapshot, must expose a
    682  function call operator with the following signature to store entities:
    683 
    684  ```cpp
    685  void operator()(entt::entity);
    686  ```
    687 
    688  Where `entt::entity` is the type of the entities used by the registry. Note
    689  that all the member functions of the snapshot class make also an initial call
    690  to this endpoint to save the _size_ of the set they are going to store.<br/>
    691  In addition, an archive must accept a pair of entity and component for each
    692  type to be serialized. Therefore, given a type `T`, the archive must contain a
    693  function call operator with the following signature:
    694 
    695  ```cpp
    696  void operator()(entt::entity, const T &);
    697  ```
    698 
    699  The output archive can freely decide how to serialize the data. The register
    700  is not affected at all by the decision.
    701 
    702 * An input archive, the one used when restoring a snapshot, must expose a
    703  function call operator with the following signature to load entities:
    704 
    705  ```cpp
    706  void operator()(entt::entity &);
    707  ```
    708 
    709  Where `entt::entity` is the type of the entities used by the registry. Each
    710  time the function is invoked, the archive must read the next element from the
    711  underlying storage and copy it in the given variable. Note that all the member
    712  functions of a loader class make also an initial call to this endpoint to read
    713  the _size_ of the set they are going to load.<br/>
    714  In addition, the archive must accept a pair of entity and component for each
    715  type to be restored. Therefore, given a type `T`, the archive must contain a
    716  function call operator with the following signature:
    717 
    718  ```cpp
    719  void operator()(entt::entity &, T &);
    720  ```
    721 
    722  Every time such an operator is invoked, the archive must read the next
    723  elements from the underlying storage and copy them in the given variables.
    724 
    725 ### One example to rule them all
    726 
    727 `EnTT` comes with some examples (actually some tests) that show how to integrate
    728 a well known library for serialization as an archive. It uses
    729 [`Cereal C++`](https://uscilab.github.io/cereal/) under the hood, mainly
    730 because I wanted to learn how it works at the time I was writing the code.
    731 
    732 The code is not production-ready and it isn't neither the only nor (probably)
    733 the best way to do it. However, feel free to use it at your own risk.
    734 
    735 The basic idea is to store everything in a group of queues in memory, then bring
    736 everything back to the registry with different loaders.
    737 
    738 ## Prototype
    739 
    740 A prototype defines a type of an application in terms of its parts. They can be
    741 used to assign components to entities of a registry at once.<br/>
    742 Roughly speaking, in most cases prototypes can be considered just as templates
    743 to use to initialize entities according to _concepts_. In fact, users can create
    744 how many prototypes they want, each one initialized differently from the others.
    745 
    746 The following is an example of use of a prototype:
    747 
    748 ```cpp
    749 entt::registry registry;
    750 entt::prototype prototype{registry};
    751 
    752 prototype.set<position>(100.f, 100.f);
    753 prototype.set<velocity>(0.f, 0.f);
    754 
    755 // ...
    756 
    757 const auto entity = prototype();
    758 ```
    759 
    760 To assign and remove components from a prototype, it offers two dedicated member
    761 functions named `set` and `unset`. The `has` member function can be used to know
    762 if a given prototype contains one or more components and the `get` member
    763 function can be used to retrieve the components.
    764 
    765 Creating an entity from a prototype is straightforward:
    766 
    767 * To create a new entity from scratch and assign it a prototype, this is the way
    768  to go:
    769  ```cpp
    770  const auto entity = prototype();
    771  ```
    772  It is equivalent to the following invokation:
    773  ```cpp
    774  const auto entity = prototype.create();
    775  ```
    776 
    777 * In case we want to initialize an already existing entity, we can provide the
    778  `operator()` directly with the entity identifier:
    779  ```cpp
    780  prototype(entity);
    781  ```
    782  It is equivalent to the following invokation:
    783  ```cpp
    784  prototype.assign(entity);
    785  ```
    786  Note that existing components aren't overwritten in this case. Only those
    787  components that the entity doesn't own yet are copied over. All the other
    788  components remain unchanged.
    789 
    790 * Finally, to assign or replace all the components for an entity, thus
    791  overwriting existing ones:
    792  ```cpp
    793  prototype.assign_or_replace(entity);
    794  ```
    795 
    796 In the examples above, the prototype uses its underlying registry to create
    797 entities and components both for its purposes and when it's cloned. To use a
    798 different repository to clone a prototype, all the member functions accept also
    799 a reference to a valid registry as a first argument.
    800 
    801 Prototypes are a very useful tool that can save a lot of typing sometimes.
    802 Furthermore, the codebase may be easier to maintain, since updating a prototype
    803 is much less error prone than jumping around in the codebase to update all the
    804 snippets copied and pasted around to initialize entities and components.
    805 
    806 ## Helpers
    807 
    808 The so called _helpers_ are small classes and functions mainly designed to offer
    809 built-in support for the most basic functionalities.<br/>
    810 The list of helpers will grow longer as time passes and new ideas come out.
    811 
    812 ### Dependency function
    813 
    814 A _dependency function_ is a predefined listener, actually a function template
    815 to use to automatically assign components to an entity when a type has a
    816 dependency on some other types.<br/>
    817 The following adds components `a_type` and `another_type` whenever `my_type` is
    818 assigned to an entity:
    819 
    820 ```cpp
    821 entt::connnect<a_type, another_type>(registry.on_construct<my_type>());
    822 ```
    823 
    824 A component is assigned to an entity and thus default initialized only in case
    825 the entity itself hasn't it yet. It means that already existent components won't
    826 be overriden.<br/>
    827 A dependency can easily be broken by means of the following function template:
    828 
    829 ```cpp
    830 entt::disconnect<a_type, another_type>(registry.on_construct<my_type>());
    831 ```
    832 
    833 ### Tags
    834 
    835 There's nothing magical about the way tags can be assigned to entities while
    836 avoiding a performance hit at runtime. Nonetheless, the syntax can be annoying
    837 and that's why a more user-friendly shortcut is provided to do it.<br/>
    838 This shortcut is the alias template `entt::tag`.
    839 
    840 If used in combination with hashed strings, it helps to use tags where types
    841 would be required otherwise. As an example:
    842 
    843 ```cpp
    844 registry.assign<entt::tag<"enemy"_hs>>(entity);
    845 ```
    846 
    847 ## Null entity
    848 
    849 In `EnTT`, there exists a sort of _null entity_ made available to users that is
    850 accessible via the `entt::null` variable.<br/>
    851 The library guarantees that the following expression always returns false:
    852 
    853 ```cpp
    854 registry.valid(entt::null);
    855 ```
    856 
    857 In other terms, a registry will reject the null entity in all cases because it
    858 isn't considered valid. It means that the null entity cannot own components for
    859 obvious reasons.<br/>
    860 The type of the null entity is internal and should not be used for any purpose
    861 other than defining the null entity itself. However, there exist implicit
    862 conversions from the null entity to identifiers of any allowed type:
    863 
    864 ```cpp
    865 entt::entity null = entt::null;
    866 ```
    867 
    868 Similarly, the null entity can be compared to any other identifier:
    869 
    870 ```cpp
    871 const auto entity = registry.create();
    872 const bool null = (entity == entt::null);
    873 ```
    874 
    875 ## Context variables
    876 
    877 It is often convenient to assign context variables to a registry, so as to make
    878 it the only _source of truth_ of an application.<br/>
    879 This is possible by means of a member function named `set` to use to create a
    880 context variable from a given type. Later on, either `ctx` or `try_ctx` can be
    881 used to retrieve the newly created instance and `unset` is there to literally
    882 reset it if needed.
    883 
    884 Example of use:
    885 
    886 ```cpp
    887 // creates a new context variable initialized with the given values
    888 registry.set<my_type>(42, 'c');
    889 
    890 // gets the context variable
    891 const auto &var = registry.ctx<my_type>();
    892 
    893 // if in doubts, probe the registry to avoid assertions in case of errors
    894 if(auto *ptr = registry.try_ctx<my_type>(); ptr) {
    895  // uses the context variable associated with the registry, if any
    896 }
    897 
    898 // unsets the context variable
    899 registry.unset<my_type>();
    900 ```
    901 
    902 The type of a context variable must be such that it's default constructible and
    903 can be moved. The `set` member function either creates a new instance of the
    904 context variable or overwrites an already existing one if any. The `try_ctx`
    905 member function returns a pointer to the context variable if it exists,
    906 otherwise it returns a null pointer. This fits well with the `if` statement with
    907 initializer.
    908 
    909 # Views and Groups
    910 
    911 First of all, it is worth answering an obvious question: why views and
    912 groups?<br/>
    913 Briefly, they are a good tool to enforce single responsibility. A system that
    914 has access to a registry can create and destroy entities, as well as assign and
    915 remove components. On the other side, a system that has access to a view or a
    916 group can only iterate entities and their components, then read or update the
    917 data members of the latter.<br/>
    918 It is a subtle difference that can help designing a better software sometimes.
    919 
    920 More in details, views are a non-intrusive tool to access entities and
    921 components without affecting other functionalities or increasing the memory
    922 consumption. On the other side, groups are an intrusive tool that allows to
    923 reach higher performance along critical paths but has also a price to pay for
    924 that.
    925 
    926 There are mainly two kinds of views: _compile-time_ (also known as `view`) and
    927 runtime (also known as `runtime_view`).<br/>
    928 The former require that users indicate at compile-time what are the components
    929 involved and can make several optimizations because of that. The latter can be
    930 constructed at runtime instead and are a bit slower to iterate entities and
    931 components.<br/>
    932 In both cases, creating and destroying a view isn't expensive at all because
    933 views don't have any type of initialization. Moreover, views don't affect any
    934 other functionality of the registry and keep memory usage at a minimum.
    935 
    936 Groups come in three different flavors: _full-owning groups_, _partial-owning
    937 groups_ and _non-owning groups_. The main difference between them is in terms of
    938 performance.<br/>
    939 Groups can literally _own_ one or more types of components. It means that they
    940 will be allowed to rearrange pools so as to speed up iterations. Roughly
    941 speaking: the more components a group owns, the faster it is to iterate them.
    942 On the other side, a given component can belong only to one group, so users have
    943 to define groups carefully to get the best out of them.
    944 
    945 Continue reading for more details or refer to the inline documentation.
    946 
    947 ## Views
    948 
    949 A view behaves differently if it's constructed for a single component or if it
    950 has been created to iterate multiple components. Even the API is slightly
    951 different in the two cases.
    952 
    953 Single component views are specialized in order to give a boost in terms of
    954 performance in all the situations. This kind of views can access the underlying
    955 data structures directly and avoid superfluous checks. There is nothing as fast
    956 as a single component view. In fact, they walk through a packed array of
    957 components and return them one at a time.<br/>
    958 Single component views offer a bunch of functionalities to get the number of
    959 entities they are going to return and a raw access to the entity list as well as
    960 to the component list. It's also possible to ask a view if it contains a
    961 given entity.<br/>
    962 Refer to the inline documentation for all the details.
    963 
    964 Multi component views iterate entities that have at least all the given
    965 components in their bags. During construction, these views look at the number of
    966 entities available for each component and pick up a reference to the smallest
    967 set of candidates in order to speed up iterations.<br/>
    968 They offer fewer functionalities than their companion views for single
    969 component. In particular, a multi component view exposes utility functions to
    970 get the estimated number of entities it is going to return and to know whether
    971 it's empty or not. It's also possible to ask a view if it contains a given
    972 entity.<br/>
    973 Refer to the inline documentation for all the details.
    974 
    975 There is no need to store views around for they are extremely cheap to
    976 construct, even though they can be copied without problems and reused freely.
    977 Views also return newly created and correctly initialized iterators whenever
    978 `begin` or `end` are invoked.
    979 
    980 Views share the way they are created by means of a registry:
    981 
    982 ```cpp
    983 // single component view
    984 auto single = registry.view<position>();
    985 
    986 // multi component view
    987 auto multi = registry.view<position, velocity>();
    988 ```
    989 
    990 To iterate a view, either use it in a range-for loop:
    991 
    992 ```cpp
    993 auto view = registry.view<position, velocity>();
    994 
    995 for(auto entity: view) {
    996  // a component at a time ...
    997  auto &position = view.get<position>(entity);
    998  auto &velocity = view.get<velocity>(entity);
    999 
    1000  // ... or multiple components at once
    1001  auto &[pos, vel] = view.get<position, velocity>(entity);
    1002 
    1003  // ...
    1004 }
    1005 ```
    1006 
    1007 Or rely on the `each` member function to iterate entities and get all their
    1008 components at once:
    1009 
    1010 ```cpp
    1011 registry.view<position, velocity>().each([](auto entity, auto &pos, auto &vel) {
    1012  // ...
    1013 });
    1014 ```
    1015 
    1016 The `each` member function is highly optimized. Unless users want to iterate
    1017 only entities or get only some of the components, this should be the preferred
    1018 approach. Note that the entity can also be excluded from the parameter list if
    1019 not required, but this won't improve performance for multi component views.
    1020 
    1021 As a side note, when using a single component view, the most common error is to
    1022 invoke `get` with the type of the component as a template parameter. This is
    1023 probably due to the fact that it's required for multi component views:
    1024 
    1025 ```cpp
    1026 auto view = registry.view<position, const velocity>();
    1027 
    1028 for(auto entity: view) {
    1029  const auto &vel = view.get<const velocity>(entity);
    1030  // ...
    1031 }
    1032 ```
    1033 
    1034 However, in case of a single component view, `get` doesn't accept a template
    1035 parameter, since it's implicitly defined by the view itself:
    1036 
    1037 ```cpp
    1038 auto view = registry.view<const renderable>();
    1039 
    1040 for(auto entity: view) {
    1041  const auto &renderable = view.get(entity);
    1042  // ...
    1043 }
    1044 ```
    1045 
    1046 **Note**: prefer the `get` member function of a view instead of the `get` member
    1047 function template of a registry during iterations, if possible. However, keep in
    1048 mind that it works only with the components of the view itself.
    1049 
    1050 ## Runtime views
    1051 
    1052 Runtime views iterate entities that have at least all the given components in
    1053 their bags. During construction, these views look at the number of entities
    1054 available for each component and pick up a reference to the smallest
    1055 set of candidates in order to speed up iterations.<br/>
    1056 They offer more or less the same functionalities of a multi component view.
    1057 However, they don't expose a `get` member function and users should refer to the
    1058 registry that generated the view to access components. In particular, a runtime
    1059 view exposes utility functions to get the estimated number of entities it is
    1060 going to return and to know whether it's empty or not. It's also possible to ask
    1061 a runtime view if it contains a given entity.<br/>
    1062 Refer to the inline documentation for all the details.
    1063 
    1064 Runtime view are extremely cheap to construct and should not be stored around in
    1065 any case. They should be used immediately after creation and then they should be
    1066 thrown away. The reasons for this go far beyond the scope of this document.<br/>
    1067 To iterate a runtime view, either use it in a range-for loop:
    1068 
    1069 ```cpp
    1070 using component_type = typename decltype(registry)::component_type;
    1071 component_type types[] = { registry.type<position>(), registry.type<velocity>() };
    1072 
    1073 auto view = registry.runtime_view(std::cbegin(types), std::cend(types));
    1074 
    1075 for(auto entity: view) {
    1076  // a component at a time ...
    1077  auto &position = registry.get<position>(entity);
    1078  auto &velocity = registry.get<velocity>(entity);
    1079 
    1080  // ... or multiple components at once
    1081  auto &[pos, vel] = registry.get<position, velocity>(entity);
    1082 
    1083  // ...
    1084 }
    1085 ```
    1086 
    1087 Or rely on the `each` member function to iterate entities:
    1088 
    1089 ```cpp
    1090 using component_type = typename decltype(registry)::component_type;
    1091 component_type types[] = { registry.type<position>(), registry.type<velocity>() };
    1092 
    1093 auto view = registry.runtime_view(std::cbegin(types), std::cend(types)).each([](auto entity) {
    1094  // ...
    1095 });
    1096 ```
    1097 
    1098 Performance are exactly the same in both cases.
    1099 
    1100 **Note**: runtime views are meant for all those cases where users don't know at
    1101 compile-time what components to use to iterate entities. This is particularly
    1102 well suited to plugin systems and mods in general. Where possible, don't use
    1103 runtime views, as their performance are slightly inferior to those of the other
    1104 views.
    1105 
    1106 ## Groups
    1107 
    1108 Groups are meant to iterate multiple components at once and offer a faster
    1109 alternative to views. Roughly speaking, they just play in another league when
    1110 compared to views.<br/>
    1111 Groups overcome the performance of the other tools available but require to get
    1112 the ownership of components and this sets some constraints on pools. On the
    1113 other side, groups aren't an automatism that increases memory consumption,
    1114 affects functionalities and tries to optimize iterations for all the possible
    1115 combinations of components. Users can decide when to pay for groups and to what
    1116 extent.<br/>
    1117 The most interesting aspect of groups is that they fit _usage patterns_. Other
    1118 solutions around usually try to optimize everything, because it is known that
    1119 somewhere within the _everything_ there are also our usage patterns. However
    1120 this has a cost that isn't negligible, both in terms of performance and memory
    1121 usage. Ironically, users pay the price also for things they don't want and this
    1122 isn't something I like much. Even worse, one cannot easily disable such a
    1123 behavior. Groups work differently instead and are designed to optimize only the
    1124 real use cases when users find they need to.<br/>
    1125 Another nice-to-have feature of groups is that they have no impact on memory
    1126 consumption, put aside full non-owning groups that are pretty rare and should be
    1127 avoided as long as possible.
    1128 
    1129 All groups affect to an extent the creation and destruction of their components.
    1130 This is due to the fact that they must _observe_ changes in the pools of
    1131 interest and arrange data _correctly_ when needed for the types they own.<br/>
    1132 That being said, the way groups operate is beyond the scope of this document.
    1133 However, it's unlikely that users will be able to appreciate the impact of
    1134 groups on other functionalities of the registry.
    1135 
    1136 Groups offer a bunch of functionalities to get the number of entities they are
    1137 going to return and a raw access to the entity list as well as to the component
    1138 list for owned components. It's also possible to ask a group if it contains a
    1139 given entity.<br/>
    1140 Refer to the inline documentation for all the details.
    1141 
    1142 There is no need to store groups around for they are extremely cheap to
    1143 construct, even though they can be copied without problems and reused freely.
    1144 A group performs an initialization step the very first time it's requested and
    1145 this could be quite costly. To avoid it, consider creating the group when no
    1146 components have been assigned yet. If the registry is empty, preparation is
    1147 extremely fast. Groups also return newly created and correctly initialized
    1148 iterators whenever `begin` or `end` are invoked.
    1149 
    1150 To iterate groups, either use them in a range-for loop:
    1151 
    1152 ```cpp
    1153 auto group = registry.group<position>(entt::get<velocity>);
    1154 
    1155 for(auto entity: group) {
    1156  // a component at a time ...
    1157  auto &position = group.get<position>(entity);
    1158  auto &velocity = group.get<velocity>(entity);
    1159 
    1160  // ... or multiple components at once
    1161  auto &[pos, vel] = group.get<position, velocity>(entity);
    1162 
    1163  // ...
    1164 }
    1165 ```
    1166 
    1167 Or rely on the `each` member function to iterate entities and get all their
    1168 components at once:
    1169 
    1170 ```cpp
    1171 registry.group<position>(entt::get<velocity>).each([](auto entity, auto &pos, auto &vel) {
    1172  // ...
    1173 });
    1174 ```
    1175 
    1176 The `each` member function is highly optimized. Unless users want to iterate
    1177 only entities, this should be the preferred approach. Note that the entity can
    1178 also be excluded from the parameter list if not required and it can improve even
    1179 further the performance during iterations.
    1180 
    1181 **Note**: prefer the `get` member function of a group instead of the `get`
    1182 member function template of a registry during iterations, if possible. However,
    1183 keep in mind that it works only with the components of the group itself.
    1184 
    1185 Let's go a bit deeper into the different types of groups made available by this
    1186 library to know how they are constructed and what are the differences between
    1187 them.
    1188 
    1189 ### Full-owning groups
    1190 
    1191 A full-owning group is the fastest tool an user can expect to use to iterate
    1192 multiple components at once. It iterates all the components directly, no
    1193 indirection required. This type of groups performs more or less as if users are
    1194 accessing sequentially a bunch of packed arrays of components all sorted
    1195 identically.
    1196 
    1197 A full-owning group is created as:
    1198 
    1199 ```cpp
    1200 auto group = registry.group<position, velocity>();
    1201 ```
    1202 
    1203 Filtering entities by components is also supported:
    1204 
    1205 ```cpp
    1206 auto group = registry.group<position, velocity>(entt::exclude<renderable>);
    1207 ```
    1208 
    1209 Once created, the group gets the ownership of all the components specified in
    1210 the template parameter list and arranges their pools so as to iterate all of
    1211 them as fast as possible.
    1212 
    1213 Sorting owned components is no longer allowed once the group has been created.
    1214 However, full-owning groups can be sorted by means of their `sort` member
    1215 functions, if required. Sorting a full-owning group affects all the instance of
    1216 the same group (it means that users don't have to call `sort` on each instance
    1217 to sort all of them because they share the underlying data structure).
    1218 
    1219 ### Partial-owning groups
    1220 
    1221 A partial-owning group works similarly to a full-owning group for the components
    1222 it owns, but relies on indirection to get components owned by other groups. This
    1223 isn't as fast as a full-owning group, but it's already much faster than views
    1224 when there are only one or two free components to retrieve (the most common
    1225 cases likely). In the worst case, it's not slower than views anyway.
    1226 
    1227 A partial-owning group is created as:
    1228 
    1229 ```cpp
    1230 auto group = registry.group<position>(entt::get<velocity>);
    1231 ```
    1232 
    1233 Filtering entities by components is also supported:
    1234 
    1235 ```cpp
    1236 auto group = registry.group<position>(entt::get<velocity>, entt::exclude<renderable>);
    1237 ```
    1238 
    1239 Once created, the group gets the ownership of all the components specified in
    1240 the template parameter list and arranges their pools so as to iterate all of
    1241 them as fast as possible. The ownership of the types provided via `entt::get`
    1242 doesn't pass to the group instead.
    1243 
    1244 Sorting owned components is no longer allowed once the group has been created.
    1245 However, partial-owning groups can be sorted by means of their `sort` member
    1246 functions, if required. Sorting a partial-owning group affects all the instance
    1247 of the same group (it means that users don't have to call `sort` on each
    1248 instance to sort all of them because they share the underlying data structure).
    1249 
    1250 ### Non-owning groups
    1251 
    1252 Non-owning groups are usually fast enough, for sure faster than views and well
    1253 suited for most of the cases. However, they require custom data structures to
    1254 work properly and they increase memory consumption. As a rule of thumb, users
    1255 should avoid using non-owning groups, if possible.
    1256 
    1257 A non-owning group is created as:
    1258 
    1259 ```cpp
    1260 auto group = registry.group<>(entt::get<position, velocity>);
    1261 ```
    1262 
    1263 Filtering entities by components is also supported:
    1264 
    1265 ```cpp
    1266 auto group = registry.group<>(entt::get<position, velocity>, entt::exclude<renderable>);
    1267 ```
    1268 
    1269 The group doesn't receive the ownership of any type of component in this
    1270 case. This type of groups is therefore the least performing in general, but also
    1271 the only one that can be used in any situation to improve a performance where
    1272 necessary.
    1273 
    1274 Non-owning groups can be sorted by means of their `sort` member functions, if
    1275 required. Sorting a non-owning group affects all the instance of the same group
    1276 (it means that users don't have to call `sort` on each instance to sort all of
    1277 them because they share the set of entities).
    1278 
    1279 # Types: const, non-const and all in between
    1280 
    1281 The `registry` class offers two overloads when it comes to constructing views
    1282 and groups: a const version and a non-const one. The former accepts both const
    1283 and non-const types as template parameters, the latter accepts only const types
    1284 instead.<br/>
    1285 It means that views and groups can be constructed also from a const registry and
    1286 they propagate the constness of the registry to the types involved. As an
    1287 example:
    1288 
    1289 ```cpp
    1290 entt::view<const position, const velocity> view = std::as_const(registry).view<const position, const velocity>();
    1291 ```
    1292 
    1293 Consider the following definition for a non-const view instead:
    1294 
    1295 ```cpp
    1296 entt::view<position, const velocity> view = registry.view<position, const velocity>();
    1297 ```
    1298 
    1299 In the example above, `view` can be used to access either read-only or writable
    1300 `position` components while `velocity` components are read-only in all
    1301 cases.<br/>
    1302 In other terms, these statements are all valid:
    1303 
    1304 ```cpp
    1305 position &pos = view.get<position>(entity);
    1306 const position &cpos = view.get<const position>(entity);
    1307 const velocity &cpos = view.get<const velocity>(entity);
    1308 std::tuple<position &, const velocity &> tup = view.get<position, const velocity>(entity);
    1309 std::tuple<const position &, const velocity &> ctup = view.get<const position, const velocity>(entity);
    1310 ```
    1311 
    1312 It's not possible to get non-const references to `velocity` components from the
    1313 same view instead and these will result in compilation errors:
    1314 
    1315 ```cpp
    1316 velocity &cpos = view.get<velocity>(entity);
    1317 std::tuple<position &, velocity &> tup = view.get<position, velocity>(entity);
    1318 std::tuple<const position &, velocity &> ctup = view.get<const position, velocity>(entity);
    1319 ```
    1320 
    1321 Similarly, the `each` member functions will propagate constness to the type of
    1322 the components returned during iterations:
    1323 
    1324 ```cpp
    1325 view.each([](auto entity, position &pos, const velocity &vel) {
    1326  // ...
    1327 });
    1328 ```
    1329 
    1330 Obviously, a caller can still refer to the `position` components through a const
    1331 reference because of the rules of the language that fortunately already allow
    1332 it.
    1333 
    1334 The same concepts apply to groups as well.
    1335 
    1336 ## Give me everything
    1337 
    1338 Views and groups are narrow windows on the entire list of entities. They work by
    1339 filtering entities according to their components.<br/>
    1340 In some cases there may be the need to iterate all the entities still in use
    1341 regardless of their components. The registry offers a specific member function
    1342 to do that:
    1343 
    1344 ```cpp
    1345 registry.each([](auto entity) {
    1346  // ...
    1347 });
    1348 ```
    1349 
    1350 It returns to the caller all the entities that are still in use by means of the
    1351 given function.<br/>
    1352 As a rule of thumb, consider using a view or a group if the goal is to iterate
    1353 entities that have a determinate set of components. These tools are usually much
    1354 faster than combining this function with a bunch of custom tests.<br/>
    1355 In all the other cases, this is the way to go.
    1356 
    1357 There exists also another member function to use to retrieve orphans. An orphan
    1358 is an entity that is still in use and has no assigned components.<br/>
    1359 The signature of the function is the same of `each`:
    1360 
    1361 ```cpp
    1362 registry.orphans([](auto entity) {
    1363  // ...
    1364 });
    1365 ```
    1366 
    1367 To test the _orphanity_ of a single entity, use the member function `orphan`
    1368 instead. It accepts a valid entity identifer as an argument and returns true in
    1369 case the entity is an orphan, false otherwise.
    1370 
    1371 In general, all these functions can result in poor performance.<br/>
    1372 `each` is fairly slow because of some checks it performs on each and every
    1373 entity. For similar reasons, `orphans` can be even slower. Both functions should
    1374 not be used frequently to avoid the risk of a performance hit.
    1375 
    1376 ## What is allowed and what is not
    1377 
    1378 Most of the _ECS_ available out there don't allow to create and destroy entities
    1379 and components during iterations.<br/>
    1380 `EnTT` partially solves the problem with a few limitations:
    1381 
    1382 * Creating entities and components is allowed during iterations in almost all
    1383  cases.
    1384 * Deleting the current entity or removing its components is allowed during
    1385  iterations. For all the other entities, destroying them or removing their
    1386  components isn't allowed and can result in undefined behavior.
    1387 
    1388 In these cases, iterators aren't invalidated. To be clear, it doesn't mean that
    1389 also references will continue to be valid.<br/>
    1390 Consider the following example:
    1391 
    1392 ```cpp
    1393 registry.view<position>([&](const auto entity, auto &pos) {
    1394  registry.assign<position>(registry.create(), 0., 0.);
    1395  pos.x = 0.; // warning: dangling pointer
    1396 });
    1397 ```
    1398 
    1399 The `each` member function won't break (because iterators aren't invalidated)
    1400 but there are no guarantees on references. Use a common range-for loop and get
    1401 components directly from the view or move the creation of components at the end
    1402 of the function to avoid dangling pointers.
    1403 
    1404 Iterators are invalidated instead and the behavior is undefined if an entity is
    1405 modified or destroyed and it's not the one currently returned by the iterator
    1406 nor a newly created one.<br/>
    1407 To work around it, possible approaches are:
    1408 
    1409 * Store aside the entities and the components to be removed and perform the
    1410  operations at the end of the iteration.
    1411 * Mark entities and components with a proper tag component that indicates they
    1412  must be purged, then perform a second iteration to clean them up one by one.
    1413 
    1414 A notable side effect of this feature is that the number of required allocations
    1415 is further reduced in most of the cases.
    1416 
    1417 ### More performance, more constraints
    1418 
    1419 Groups are a (much) faster alternative to views. However, the higher the
    1420 performance, the greater the constraints on what is allowed and what is
    1421 not.<br/>
    1422 In particular, groups add in some rare cases a limitation on the creation of
    1423 components during iterations. It happens in quite particular cases. Given the
    1424 nature and the scope of the groups, it isn't something in which it will happen
    1425 to come across probably, but it's good to know it anyway.
    1426 
    1427 First of all, it must be said that creating components while iterating a group
    1428 isn't a problem at all and can be done freely as it happens with the views. The
    1429 same applies to the destruction of components and entities, for which the rules
    1430 mentioned above apply.
    1431 
    1432 The additional limitation pops out instead when a given component that is owned
    1433 by a group is iterated outside of it. In this case, adding components that are
    1434 part of the group itself may invalidate the iterators. There are no further
    1435 limitations to the destruction of components and entities.<br/>
    1436 Fortunately, this isn't always true. In fact, it almost never is and this
    1437 happens only under certain conditions. In particular:
    1438 
    1439 * Iterating a type of component that is part of a group with a single component
    1440  view and adding to an entity all the components required to get it into the
    1441  group may invalidate the iterators.
    1442 
    1443 * Iterating a type of component that is part of a group with a multi component
    1444  view and adding to an entity all the components required to get it into the
    1445  group can invalidate the iterators, unless users specify another type of
    1446  component to use to induce the order of iteration of the view (in this case,
    1447  the former is treated as a free type and isn't affected by the limitation).
    1448 
    1449 In other words, the limitation doesn't exist as long as a type is treated as a
    1450 free type (as an example with multi component views and partial- or non-owning
    1451 groups) or iterated with its own group, but it can occur if the type is used as
    1452 a main type to rule on an iteration.<br/>
    1453 This happens because groups own the pools of their components and organize the
    1454 data internally to maximize performance. Because of that, full consistency for
    1455 owned components is guaranteed only when they are iterated as part of their
    1456 groups or as free types with multi component views and groups in general.
    1457 
    1458 # Empty type optimization
    1459 
    1460 An empty type `T` is such that `std::is_empty_v<T>` returns true. They are also
    1461 the same types for which _empty base optimization_ (EBO) is possibile.<br/>
    1462 `EnTT` handles these types in a special way, optimizing both in terms of
    1463 performance and memory usage. However, this also has consequences that are worth
    1464 mentioning.
    1465 
    1466 When an empty type is detected, it's not instantiated in any case. Therefore,
    1467 only the entities to which it's assigned are made available. All the iterators
    1468 as well as the `get` member functions of the registry, the views and the groups
    1469 will return temporary objects. Similarly, some functions such as `try_get` or
    1470 the raw access to the list of components aren't available for this kind of
    1471 types.<br/>
    1472 On the other hand, iterations are faster because only the entities to which the
    1473 type is assigned are considered. Moreover, less memory is used, since there
    1474 doesn't exist any instance of the component, no matter how many entities it is
    1475 assigned to.
    1476 
    1477 For similar reasons, wherever a function type of a listener accepts a component,
    1478 it cannot be caught by a non-const reference. Capture it by copy or by const
    1479 reference instead.
    1480 
    1481 More in general, none of the features offered by the library is affected, but
    1482 for the ones that require to return actual instances.
    1483 
    1484 # Multithreading
    1485 
    1486 In general, the entire registry isn't thread safe as it is. Thread safety isn't
    1487 something that users should want out of the box for several reasons. Just to
    1488 mention one of them: performance.<br/>
    1489 Views, groups and consequently the approach adopted by `EnTT` are the great
    1490 exception to the rule. It's true that views, groups and iterators in general
    1491 aren't thread safe by themselves. Because of this users shouldn't try to iterate
    1492 a set of components and modify the same set concurrently. However:
    1493 
    1494 * As long as a thread iterates the entities that have the component `X` or
    1495  assign and removes that component from a set of entities, another thread can
    1496  safely do the same with components `Y` and `Z` and everything will work like a
    1497  charm. As a trivial example, users can freely execute the rendering system and
    1498  iterate the renderable entities while updating a physic component concurrently
    1499  on a separate thread.
    1500 
    1501 * Similarly, a single set of components can be iterated by multiple threads as
    1502  long as the components are neither assigned nor removed in the meantime. In
    1503  other words, a hypothetical movement system can start multiple threads, each
    1504  of which will access the components that carry information about velocity and
    1505  position for its entities.
    1506 
    1507 This kind of entity-component systems can be used in single threaded
    1508 applications as well as along with async stuff or multiple threads. Moreover,
    1509 typical thread based models for _ECS_ don't require a fully thread safe registry
    1510 to work. Actually, users can reach the goal with the registry as it is while
    1511 working with most of the common models.
    1512 
    1513 Because of the few reasons mentioned above and many others not mentioned, users
    1514 are completely responsible for synchronization whether required. On the other
    1515 hand, they could get away with it without having to resort to particular
    1516 expedients.
    1517 
    1518 ## Iterators
    1519 
    1520 A special mention is needed for the iterators returned by the views and the
    1521 groups. Most of the time they meet the requirements of random access iterators,
    1522 in all cases they meet at least the requirements of forward iterators.<br/>
    1523 In other terms, they are suitable for use with the parallel algorithms of the
    1524 standard library. If it's not clear, this is a great thing.
    1525 
    1526 As an example, this kind of iterators can be used in combination with
    1527 `std::for_each` and `std::execution::par` to parallelize the visit and therefore
    1528 the update of the components returned by a view or a group, as long as the
    1529 constraints previously discussed are respected:
    1530 
    1531 ```cpp
    1532 auto view = registry.view<position, const velocity>();
    1533 
    1534 std::for_each(std::execution::par_unseq, view.begin(), view.end(), [&view](auto entity) {
    1535  // ...
    1536 });
    1537 ```
    1538 
    1539 This can increase the throughput considerably, even without resorting to who
    1540 knows what artifacts that are difficult to maintain over time.
    1541 
    1542 Unfortunately, because of the limitations of the current revision of the
    1543 standard, the parallel `std::for_each` accepts only forward iterators. This
    1544 means that the iterators provided by the library cannot return proxy objects as
    1545 references and **must** return actual reference types instead.<br/>
    1546 This may change in the future and the iterators will almost certainly return
    1547 both the entities and a list of references to their components sooner or later.
    1548 Multi-pass guarantee won't break in any case and the performance should even
    1549 benefit from it further.
    Generated by   diff --git a/entt_8hpp_source.html b/entt_8hpp_source.html index 1acf28d47..758a79110 100644 --- a/entt_8hpp_source.html +++ b/entt_8hpp_source.html @@ -22,7 +22,7 @@
    @@ -67,7 +67,7 @@ $(function() {
    entt.hpp
    -
    1 #include "core/algorithm.hpp"
    2 #include "core/family.hpp"
    3 #include "core/hashed_string.hpp"
    4 #include "core/ident.hpp"
    5 #include "core/monostate.hpp"
    6 #include "entity/actor.hpp"
    7 #include "entity/attachee.hpp"
    8 #include "entity/entity.hpp"
    9 #include "entity/entt_traits.hpp"
    10 #include "entity/helper.hpp"
    11 #include "entity/prototype.hpp"
    12 #include "entity/registry.hpp"
    13 #include "entity/snapshot.hpp"
    14 #include "entity/sparse_set.hpp"
    15 #include "entity/utility.hpp"
    16 #include "entity/view.hpp"
    17 #include "locator/locator.hpp"
    18 #include "process/process.hpp"
    19 #include "process/scheduler.hpp"
    20 #include "resource/cache.hpp"
    21 #include "resource/handle.hpp"
    22 #include "resource/loader.hpp"
    23 #include "signal/delegate.hpp"
    24 #include "signal/dispatcher.hpp"
    25 #include "signal/emitter.hpp"
    26 #include "signal/sigh.hpp"
    +
    1 #include "core/algorithm.hpp"
    2 #include "core/family.hpp"
    3 #include "core/hashed_string.hpp"
    4 #include "core/ident.hpp"
    5 #include "core/monostate.hpp"
    6 #include "core/type_traits.hpp"
    7 #include "core/utility.hpp"
    8 #include "entity/actor.hpp"
    9 #include "entity/entity.hpp"
    10 #include "entity/group.hpp"
    11 #include "entity/helper.hpp"
    12 #include "entity/prototype.hpp"
    13 #include "entity/registry.hpp"
    14 #include "entity/runtime_view.hpp"
    15 #include "entity/snapshot.hpp"
    16 #include "entity/sparse_set.hpp"
    17 #include "entity/storage.hpp"
    18 #include "entity/view.hpp"
    19 #include "locator/locator.hpp"
    20 #include "meta/factory.hpp"
    21 #include "meta/meta.hpp"
    22 #include "process/process.hpp"
    23 #include "process/scheduler.hpp"
    24 #include "resource/cache.hpp"
    25 #include "resource/handle.hpp"
    26 #include "resource/loader.hpp"
    27 #include "signal/delegate.hpp"
    28 #include "signal/dispatcher.hpp"
    29 #include "signal/emitter.hpp"
    30 #include "signal/sigh.hpp"
    Generated by   diff --git a/entt__traits_8hpp_source.html b/entt__traits_8hpp_source.html deleted file mode 100644 index e39c0ac61..000000000 --- a/entt__traits_8hpp_source.html +++ /dev/null @@ -1,89 +0,0 @@ - - - - - - - -EnTT: src/entt/entity/entt_traits.hpp Source File - - - - - - - - - -
    -
    -
    - - - - - + @@ -424,19 +387,19 @@ template<typename Delta > - -

    ◆ size()

    + +

    ◆ size()

    -template<typename Delta >
    +template<typename Delta>
    Scheduler& entt::Scheduler< Delta >::operator= (Scheduler< Delta > && scheduler< Delta > &&  )
    @@ -67,7 +67,7 @@ $(function() {
    config.h
    -
    1 #ifndef ENTT_CONFIG_CONFIG_H
    2 #define ENTT_CONFIG_CONFIG_H
    3 
    4 
    5 #ifndef ENTT_NOEXCEPT
    6 #define ENTT_NOEXCEPT noexcept
    7 #endif // ENTT_NOEXCEPT
    8 
    9 
    10 #ifndef ENTT_HS_SUFFIX
    11 #define ENTT_HS_SUFFIX _hs
    12 #endif // ENTT_HS_SUFFIX
    13 
    14 
    15 
    16 #endif // ENTT_CONFIG_CONFIG_H
    +
    1 #ifndef ENTT_CONFIG_CONFIG_H
    2 #define ENTT_CONFIG_CONFIG_H
    3 
    4 
    5 #ifndef ENTT_NOEXCEPT
    6 #define ENTT_NOEXCEPT noexcept
    7 #endif // ENTT_NOEXCEPT
    8 
    9 
    10 #ifndef ENTT_HS_SUFFIX
    11 #define ENTT_HS_SUFFIX _hs
    12 #endif // ENTT_HS_SUFFIX
    13 
    14 
    15 #ifndef ENTT_NO_ATOMIC
    16 #include <atomic>
    17 template<typename Type>
    18 using maybe_atomic_t = std::atomic<Type>;
    19 #else // ENTT_NO_ATOMIC
    20 template<typename Type>
    21 using maybe_atomic_t = Type;
    22 #endif // ENTT_NO_ATOMIC
    23 
    24 
    25 #ifndef ENTT_ID_TYPE
    26 #include <cstdint>
    27 #define ENTT_ID_TYPE std::uint32_t
    28 #endif // ENTT_ID_TYPE
    29 
    30 
    31 #ifndef ENTT_PAGE_SIZE
    32 #define ENTT_PAGE_SIZE 32768
    33 #endif
    34 
    35 
    36 #ifndef ENTT_DISABLE_ASSERT
    37 #include <cassert>
    38 #define ENTT_ASSERT(condition) assert(condition)
    39 #else // ENTT_DISABLE_ASSERT
    40 #define ENTT_ASSERT(...) ((void)0)
    41 #endif // ENTT_DISABLE_ASSERT
    42 
    43 
    44 #endif // ENTT_CONFIG_CONFIG_H
    Generated by   diff --git a/core_8md_source.html b/core_8md_source.html index 6af4d70bc..cee98b755 100644 --- a/core_8md_source.html +++ b/core_8md_source.html @@ -5,7 +5,7 @@ -EnTT: docs/core.md Source File +EnTT: docs/md/core.md Source File @@ -22,7 +22,7 @@
    @@ -60,10 +60,10 @@ $(function() {
    -
    docs/core.md
    +
    docs/md/core.md
    -
    1 # Crash Course: core functionalities
    2 
    3 <!--
    4 @cond TURN_OFF_DOXYGEN
    5 -->
    6 # Table of Contents
    7 
    8 * [Introduction](#introduction)
    9 * [Compile-time identifiers](#compile-time-identifiers)
    10 * [Runtime identifiers](#runtime-identifiers)
    11 * [Hashed strings](#hashed-strings)
    12  * [Conflicts](#conflicts)
    13 * [Monostate](#monostate)
    14 <!--
    15 @endcond TURN_OFF_DOXYGEN
    16 -->
    17 
    18 # Introduction
    19 
    20 `EnTT` comes with a bunch of core functionalities mostly used by the other parts
    21 of the library itself.<br/>
    22 Hardly users will include these features in their code, but it's worth
    23 describing what `EnTT` offers so as not to reinvent the wheel in case of need.
    24 
    25 # Compile-time identifiers
    26 
    27 Sometimes it's useful to be able to give unique identifiers to types at
    28 compile-time.<br/>
    29 There are plenty of different solutions out there and I could have used one of
    30 them. However, I decided to spend my time to define a compact and versatile tool
    31 that fully embraces what the modern C++ has to offer.
    32 
    33 The _result of my efforts_ is the `Identifier` class template:
    34 
    35 ```cpp
    36 #include <ident.hpp>
    37 
    38 // defines the identifiers for the given types
    39 using ID = entt::Identifier<AType, AnotherType>;
    40 
    41 // ...
    42 
    43 switch(aTypeIdentifier) {
    44 case ID::get<AType>():
    45  // ...
    46  break;
    47 case ID::get<AnotherType>():
    48  // ...
    49  break;
    50 default:
    51  // ...
    52 }
    53 ```
    54 
    55 This is all what the class template has to offer: a static `get` member function
    56 that returns a numerical identifier for the given type. It can be used in any
    57 context where constant expressions are required.
    58 
    59 As long as the list remains unchanged, identifiers are also guaranteed to be the
    60 same for every run. In case they have been used in a production environment and
    61 a type has to be removed, one can just use a placeholder to left the other
    62 identifiers unchanged:
    63 
    64 ```cpp
    65 template<typename> struct IgnoreType {};
    66 
    67 using ID = entt::Identifier<
    68  ATypeStillValid,
    69  IgnoreType<ATypeNoLongerValid>,
    70  AnotherTypeStillValid
    71 >;
    72 ```
    73 
    74 A bit ugly to see, but it works at least.
    75 
    76 # Runtime identifiers
    77 
    78 Sometimes it's useful to be able to give unique identifiers to types at
    79 runtime.<br/>
    80 There are plenty of different solutions out there and I could have used one of
    81 them. In fact, I adapted the most common one to my requirements and used it
    82 extensively within the entire library.
    83 
    84 It's the `Family` class. Here is an example of use directly from the
    85 entity-component system:
    86 
    87 ```cpp
    88 using component_family = entt::Family<struct InternalRegistryComponentFamily>;
    89 
    90 // ...
    91 
    92 template<typename Component>
    93 component_type component() const noexcept {
    94  return component_family::type<Component>();
    95 }
    96 ```
    97 
    98 This is all what a _family_ has to offer: a `type` member function that returns
    99 a numerical identifier for the given type.
    100 
    101 Please, note that identifiers aren't guaranteed to be the same for every run.
    102 Indeed it mostly depends on the flow of execution.
    103 
    104 # Hashed strings
    105 
    106 A hashed string is a zero overhead resource identifier. Users can use
    107 human-readable identifiers in the codebase while using their numeric
    108 counterparts at runtime, thus without affecting performance.<br/>
    109 The class has an implicit `constexpr` constructor that chews a bunch of
    110 characters. Once created, all what one can do with it is getting back the
    111 original string or converting it into a number.<br/>
    112 The good part is that a hashed string can be used wherever a constant expression
    113 is required and no _string-to-number_ conversion will take place at runtime if
    114 used carefully.
    115 
    116 Example of use:
    117 
    118 ```cpp
    119 auto load(entt::HashedString::hash_type resource) {
    120  // uses the numeric representation of the resource to load and return it
    121 }
    122 
    123 auto resource = load(entt::HashedString{"gui/background"});
    124 ```
    125 
    126 There is also a _user defined literal_ dedicated to hashed strings to make them
    127 more user-friendly:
    128 
    129 ```cpp
    130 constexpr auto str = "text"_hs;
    131 ```
    132 
    133 ## Conflicts
    134 
    135 The hashed string class uses internally FNV-1a to compute the numeric
    136 counterpart of a string. Because of the _pigeonhole principle_, conflicts are
    137 possible. This is a fact.<br/>
    138 There is no silver bullet to solve the problem of conflicts when dealing with
    139 hashing functions. In this case, the best solution seemed to be to give up.
    140 That's all.<br/>
    141 After all, human-readable resource identifiers aren't something strictly defined
    142 and over which users have not the control. Choosing a slightly different
    143 identifier is probably the best solution to make the conflict disappear in this
    144 case.
    145 
    146 # Monostate
    147 
    148 The monostate pattern is often presented as an alternative to a singleton based
    149 configuration system. This is exactly its purpose in `EnTT`. Moreover, this
    150 implementation is thread safe by design (hopefully).<br/>
    151 Keys are represented by hashed strings, values are basic types like `int`s or
    152 `bool`s. Values of different types can be associated to each key, even more than
    153 one at a time. Because of this, users must pay attention to use the same type
    154 both during an assignment and when they try to read back their data. Otherwise,
    155 they will probably incur in unexpected results.
    156 
    157 Example of use:
    158 
    159 ```cpp
    160 entt::Monostate<entt::HashedString{"mykey"}>{} = true;
    161 entt::Monostate<"mykey"_hs>{} = 42;
    162 
    163 // ...
    164 
    165 const bool b = entt::Monostate<"mykey"_hs>{};
    166 const int i = entt::Monostate<entt::HashedString{"mykey"}>{};
    167 ```
    +
    1 # Crash Course: core functionalities
    2 
    3 <!--
    4 @cond TURN_OFF_DOXYGEN
    5 -->
    6 # Table of Contents
    7 
    8 * [Introduction](#introduction)
    9 * [Compile-time identifiers](#compile-time-identifiers)
    10 * [Runtime identifiers](#runtime-identifiers)
    11 * [Hashed strings](#hashed-strings)
    12  * [Conflicts](#conflicts)
    13 * [Monostate](#monostate)
    14 <!--
    15 @endcond TURN_OFF_DOXYGEN
    16 -->
    17 
    18 # Introduction
    19 
    20 `EnTT` comes with a bunch of core functionalities mostly used by the other parts
    21 of the library itself.<br/>
    22 Hardly users will include these features in their code, but it's worth
    23 describing what `EnTT` offers so as not to reinvent the wheel in case of need.
    24 
    25 # Compile-time identifiers
    26 
    27 Sometimes it's useful to be able to give unique identifiers to types at
    28 compile-time.<br/>
    29 There are plenty of different solutions out there and I could have used one of
    30 them. However, I decided to spend my time to define a compact and versatile tool
    31 that fully embraces what the modern C++ has to offer.
    32 
    33 The _result of my efforts_ is the `identifier` class template:
    34 
    35 ```cpp
    36 #include <ident.hpp>
    37 
    38 // defines the identifiers for the given types
    39 using id = entt::identifier<a_type, another_type>;
    40 
    41 // ...
    42 
    43 switch(a_type_identifier) {
    44 case id::type<a_type>:
    45  // ...
    46  break;
    47 case id::type<another_type>:
    48  // ...
    49  break;
    50 default:
    51  // ...
    52 }
    53 ```
    54 
    55 This is all what the class template has to offer: a `type` inline variable that
    56 contains a numerical identifier for the given type. It can be used in any
    57 context where constant expressions are required.
    58 
    59 As long as the list remains unchanged, identifiers are also guaranteed to be the
    60 same for every run. In case they have been used in a production environment and
    61 a type has to be removed, one can just use a placeholder to left the other
    62 identifiers unchanged:
    63 
    64 ```cpp
    65 template<typename> struct ignore_type {};
    66 
    67 using id = entt::identifier<
    68  a_type_still_valid,
    69  ignore_type<a_type_no_longer_valid>,
    70  another_type_still_valid
    71 >;
    72 ```
    73 
    74 A bit ugly to see, but it works at least.
    75 
    76 # Runtime identifiers
    77 
    78 Sometimes it's useful to be able to give unique identifiers to types at
    79 runtime.<br/>
    80 There are plenty of different solutions out there and I could have used one of
    81 them. In fact, I adapted the most common one to my requirements and used it
    82 extensively within the entire library.
    83 
    84 It's the `family` class. Here is an example of use directly from the
    85 entity-component system:
    86 
    87 ```cpp
    88 using component_family = entt::family<struct internal_registry_component_family>;
    89 
    90 // ...
    91 
    92 template<typename Component>
    93 component_type component() const noexcept {
    94  return component_family::type<Component>;
    95 }
    96 ```
    97 
    98 This is all what a _family_ has to offer: a `type` inline variable that contains
    99 a numerical identifier for the given type.
    100 
    101 Please, note that identifiers aren't guaranteed to be the same for every run.
    102 Indeed it mostly depends on the flow of execution.
    103 
    104 # Hashed strings
    105 
    106 A hashed string is a zero overhead unique identifier. Users can use
    107 human-readable identifiers in the codebase while using their numeric
    108 counterparts at runtime, thus without affecting performance.<br/>
    109 The class has an implicit `constexpr` constructor that chews a bunch of
    110 characters. Once created, all what one can do with it is getting back the
    111 original string or converting it into a number.<br/>
    112 The good part is that a hashed string can be used wherever a constant expression
    113 is required and no _string-to-number_ conversion will take place at runtime if
    114 used carefully.
    115 
    116 Example of use:
    117 
    118 ```cpp
    119 auto load(entt::hashed_string::hash_type resource) {
    120  // uses the numeric representation of the resource to load and return it
    121 }
    122 
    123 auto resource = load(entt::hashed_string{"gui/background"});
    124 ```
    125 
    126 There is also a _user defined literal_ dedicated to hashed strings to make them
    127 more user-friendly:
    128 
    129 ```cpp
    130 constexpr auto str = "text"_hs;
    131 ```
    132 
    133 ## Conflicts
    134 
    135 The hashed string class uses internally FNV-1a to compute the numeric
    136 counterpart of a string. Because of the _pigeonhole principle_, conflicts are
    137 possible. This is a fact.<br/>
    138 There is no silver bullet to solve the problem of conflicts when dealing with
    139 hashing functions. In this case, the best solution seemed to be to give up.
    140 That's all.<br/>
    141 After all, human-readable unique identifiers aren't something strictly defined
    142 and over which users have not the control. Choosing a slightly different
    143 identifier is probably the best solution to make the conflict disappear in this
    144 case.
    145 
    146 # Monostate
    147 
    148 The monostate pattern is often presented as an alternative to a singleton based
    149 configuration system. This is exactly its purpose in `EnTT`. Moreover, this
    150 implementation is thread safe by design (hopefully).<br/>
    151 Keys are represented by hashed strings, values are basic types like `int`s or
    152 `bool`s. Values of different types can be associated to each key, even more than
    153 one at a time. Because of this, users must pay attention to use the same type
    154 both during an assignment and when they try to read back their data. Otherwise,
    155 they will probably incur in unexpected results.
    156 
    157 Example of use:
    158 
    159 ```cpp
    160 entt::monostate<entt::hashed_string{"mykey"}>{} = true;
    161 entt::monostate<"mykey"_hs>{} = 42;
    162 
    163 // ...
    164 
    165 const bool b = entt::monostate<"mykey"_hs>{};
    166 const int i = entt::monostate<entt::hashed_string{"mykey"}>{};
    167 ```
    Generated by   diff --git a/delegate_8hpp_source.html b/delegate_8hpp_source.html index 84bc0b1c8..07cdbe915 100644 --- a/delegate_8hpp_source.html +++ b/delegate_8hpp_source.html @@ -22,7 +22,7 @@
    @@ -67,16 +67,22 @@ $(function() {
    delegate.hpp
    -
    1 #ifndef ENTT_SIGNAL_DELEGATE_HPP
    2 #define ENTT_SIGNAL_DELEGATE_HPP
    3 
    4 
    5 #include <utility>
    6 #include "../config/config.h"
    7 
    8 
    9 namespace entt {
    10 
    11 
    18 template<typename>
    19 class Delegate;
    20 
    21 
    35 template<typename Ret, typename... Args>
    36 class Delegate<Ret(Args...)> final {
    37  using proto_fn_type = Ret(void *, Args...);
    38  using stub_type = std::pair<void *, proto_fn_type *>;
    39 
    40  template<Ret(*Function)(Args...)>
    41  static Ret proto(void *, Args... args) {
    42  return (Function)(args...);
    43  }
    44 
    45  template<typename Class, Ret(Class:: *Member)(Args...) const>
    46  static Ret proto(void *instance, Args... args) {
    47  return (static_cast<const Class *>(instance)->*Member)(args...);
    48  }
    49 
    50  template<typename Class, Ret(Class:: *Member)(Args...)>
    51  static Ret proto(void *instance, Args... args) {
    52  return (static_cast<Class *>(instance)->*Member)(args...);
    53  }
    54 
    55 public:
    57  Delegate() ENTT_NOEXCEPT
    58  : stub{}
    59  {}
    60 
    65  bool empty() const ENTT_NOEXCEPT {
    66  // no need to test also stub.first
    67  return !stub.second;
    68  }
    69 
    74  template<Ret(*Function)(Args...)>
    75  void connect() ENTT_NOEXCEPT {
    76  stub = std::make_pair(nullptr, &proto<Function>);
    77  }
    78 
    90  template<typename Class, Ret(Class:: *Member)(Args...) const>
    91  void connect(Class *instance) ENTT_NOEXCEPT {
    92  stub = std::make_pair(instance, &proto<Class, Member>);
    93  }
    94 
    106  template<typename Class, Ret(Class:: *Member)(Args...)>
    107  void connect(Class *instance) ENTT_NOEXCEPT {
    108  stub = std::make_pair(instance, &proto<Class, Member>);
    109  }
    110 
    116  void reset() ENTT_NOEXCEPT {
    117  stub.second = nullptr;
    118  }
    119 
    125  Ret operator()(Args... args) const {
    126  return stub.second(stub.first, args...);
    127  }
    128 
    137  bool operator==(const Delegate<Ret(Args...)> &other) const ENTT_NOEXCEPT {
    138  return stub.first == other.stub.first && stub.second == other.stub.second;
    139  }
    140 
    141 private:
    142  stub_type stub;
    143 };
    144 
    145 
    157 template<typename Ret, typename... Args>
    158 bool operator!=(const Delegate<Ret(Args...)> &lhs, const Delegate<Ret(Args...)> &rhs) ENTT_NOEXCEPT {
    159  return !(lhs == rhs);
    160 }
    161 
    162 
    163 }
    164 
    165 
    166 #endif // ENTT_SIGNAL_DELEGATE_HPP
    entt::operator!=
    constexpr bool operator!=(const HashedString &lhs, const HashedString &rhs) ENTT_NOEXCEPT
    Compares two hashed strings.
    Definition: hashed_string.hpp:103
    -
    entt::Delegate< Ret(Args...)>::connect
    void connect() ENTT_NOEXCEPT
    Binds a free function to a delegate.
    Definition: delegate.hpp:75
    -
    entt::Delegate< Ret(Args...)>::operator()
    Ret operator()(Args... args) const
    Triggers a delegate.
    Definition: delegate.hpp:125
    +
    1 #ifndef ENTT_SIGNAL_DELEGATE_HPP
    2 #define ENTT_SIGNAL_DELEGATE_HPP
    3 
    4 
    5 #include <cstring>
    6 #include <algorithm>
    7 #include <functional>
    8 #include <type_traits>
    9 #include "../config/config.h"
    10 
    11 
    12 namespace entt {
    13 
    14 
    21 namespace internal {
    22 
    23 
    24 template<typename Ret, typename... Args>
    25 auto to_function_pointer(Ret(*)(Args...)) -> Ret(*)(Args...);
    26 
    27 
    28 template<typename Ret, typename... Args, typename Type>
    29 auto to_function_pointer(Ret(*)(Type *, Args...), Type *) -> Ret(*)(Args...);
    30 
    31 
    32 template<typename Class, typename Ret, typename... Args>
    33 auto to_function_pointer(Ret(Class:: *)(Args...), Class *) -> Ret(*)(Args...);
    34 
    35 
    36 template<typename Class, typename Ret, typename... Args>
    37 auto to_function_pointer(Ret(Class:: *)(Args...) const, Class *) -> Ret(*)(Args...);
    38 
    39 
    40 }
    41 
    42 
    50 template<auto>
    51 struct connect_arg_t {};
    52 
    53 
    55 template<auto Func>
    56 constexpr connect_arg_t<Func> connect_arg{};
    57 
    58 
    65 template<typename>
    66 class delegate;
    67 
    68 
    82 template<typename Ret, typename... Args>
    83 class delegate<Ret(Args...)> {
    84  using proto_fn_type = Ret(const void *, Args...);
    85 
    86 public:
    88  using function_type = Ret(Args...);
    89 
    91  delegate() ENTT_NOEXCEPT
    92  : fn{nullptr}, data{nullptr}
    93  {}
    94 
    99  template<auto Function>
    100  delegate(connect_arg_t<Function>) ENTT_NOEXCEPT
    101  : delegate{}
    102  {
    103  connect<Function>();
    104  }
    105 
    113  template<auto Candidate, typename Type>
    114  delegate(connect_arg_t<Candidate>, Type *value_or_instance) ENTT_NOEXCEPT
    115  : delegate{}
    116  {
    117  connect<Candidate>(value_or_instance);
    118  }
    119 
    124  template<auto Function>
    125  void connect() ENTT_NOEXCEPT {
    126  static_assert(std::is_invocable_r_v<Ret, decltype(Function), Args...>);
    127  data = nullptr;
    128 
    129  fn = [](const void *, Args... args) -> Ret {
    130  // this allows void(...) to eat return values and avoid errors
    131  return Ret(std::invoke(Function, args...));
    132  };
    133  }
    134 
    150  template<auto Candidate, typename Type>
    151  void connect(Type *value_or_instance) ENTT_NOEXCEPT {
    152  static_assert(std::is_invocable_r_v<Ret, decltype(Candidate), Type *, Args...>);
    153  data = value_or_instance;
    154 
    155  fn = [](const void *payload, Args... args) -> Ret {
    156  Type *curr = nullptr;
    157 
    158  if constexpr(std::is_const_v<Type>) {
    159  curr = static_cast<Type *>(payload);
    160  } else {
    161  curr = static_cast<Type *>(const_cast<void *>(payload));
    162  }
    163 
    164  // this allows void(...) to eat return values and avoid errors
    165  return Ret(std::invoke(Candidate, curr, args...));
    166  };
    167  }
    168 
    174  void reset() ENTT_NOEXCEPT {
    175  fn = nullptr;
    176  data = nullptr;
    177  }
    178 
    183  const void * instance() const ENTT_NOEXCEPT {
    184  return data;
    185  }
    186 
    201  Ret operator()(Args... args) const {
    202  ENTT_ASSERT(fn);
    203  return fn(data, args...);
    204  }
    205 
    210  explicit operator bool() const ENTT_NOEXCEPT {
    211  // no need to test also data
    212  return fn;
    213  }
    214 
    224  bool operator==(const delegate<Ret(Args...)> &other) const ENTT_NOEXCEPT {
    225  return fn == other.fn;
    226  }
    227 
    228 private:
    229  proto_fn_type *fn;
    230  const void *data;
    231 };
    232 
    233 
    246 template<typename Ret, typename... Args>
    247 bool operator!=(const delegate<Ret(Args...)> &lhs, const delegate<Ret(Args...)> &rhs) ENTT_NOEXCEPT {
    248  return !(lhs == rhs);
    249 }
    250 
    251 
    260 template<auto Function>
    261 delegate(connect_arg_t<Function>) ENTT_NOEXCEPT
    262 -> delegate<std::remove_pointer_t<decltype(internal::to_function_pointer(Function))>>;
    263 
    264 
    274 template<auto Candidate, typename Type>
    275 delegate(connect_arg_t<Candidate>, Type *) ENTT_NOEXCEPT
    276 -> delegate<std::remove_pointer_t<decltype(internal::to_function_pointer(Candidate, std::declval<Type *>()))>>;
    277 
    278 
    279 }
    280 
    281 
    282 #endif // ENTT_SIGNAL_DELEGATE_HPP
    entt::connect_arg
    constexpr connect_arg_t< Func > connect_arg
    Constant of type connect_arg_t used to disambiguate calls.
    Definition: delegate.hpp:56
    +
    entt::connect_arg_t
    Used to wrap a function or a member of a specified type.
    Definition: delegate.hpp:51
    entt
    EnTT default namespace.
    Definition: algorithm.hpp:10
    -
    entt::Delegate
    Basic delegate implementation.
    Definition: delegate.hpp:19
    -
    entt::Delegate< Ret(Args...)>::Delegate
    Delegate() ENTT_NOEXCEPT
    Default constructor.
    Definition: delegate.hpp:57
    -
    entt::Delegate< Ret(Args...)>::operator==
    bool operator==(const Delegate< Ret(Args...)> &other) const ENTT_NOEXCEPT
    Checks if the contents of the two delegates are different.
    Definition: delegate.hpp:137
    -
    entt::Delegate< Ret(Args...)>::empty
    bool empty() const ENTT_NOEXCEPT
    Checks whether a delegate actually stores a listener.
    Definition: delegate.hpp:65
    -
    entt::Delegate< Ret(Args...)>::reset
    void reset() ENTT_NOEXCEPT
    Resets a delegate.
    Definition: delegate.hpp:116
    -
    entt::Delegate< Ret(Args...)>::connect
    void connect(Class *instance) ENTT_NOEXCEPT
    Connects a member function for a given instance to a delegate.
    Definition: delegate.hpp:91
    +
    entt::delegate< Ret(Args...)>::connect
    void connect() ENTT_NOEXCEPT
    Connects a free function to a delegate.
    Definition: delegate.hpp:125
    +
    entt::delegate< Ret(Args...)>::connect
    void connect(Type *value_or_instance) ENTT_NOEXCEPT
    Connects a member function for a given instance or a free function with payload to a delegate...
    Definition: delegate.hpp:151
    +
    entt::delegate
    Basic delegate implementation.
    Definition: delegate.hpp:66
    +
    entt::delegate< Ret(Args...)>::instance
    const void * instance() const ENTT_NOEXCEPT
    Returns the instance linked to a delegate, if any.
    Definition: delegate.hpp:183
    +
    entt::delegate< Ret(Args...)>::operator()
    Ret operator()(Args... args) const
    Triggers a delegate.
    Definition: delegate.hpp:201
    +
    entt::delegate< Ret(Args...)>::function_type
    Ret(Args...) function_type
    Function type of the delegate.
    Definition: delegate.hpp:88
    +
    entt::delegate< Ret(Args...)>::reset
    void reset() ENTT_NOEXCEPT
    Resets a delegate.
    Definition: delegate.hpp:174
    +
    entt::delegate< Ret(Args...)>::delegate
    delegate(connect_arg_t< Function >) ENTT_NOEXCEPT
    Constructs a delegate and connects a free function to it.
    Definition: delegate.hpp:100
    +
    entt::delegate< Ret(Args...)>::delegate
    delegate(connect_arg_t< Candidate >, Type *value_or_instance) ENTT_NOEXCEPT
    Constructs a delegate and connects a member for a given instance or a free function with payload...
    Definition: delegate.hpp:114
    +
    entt::delegate
    delegate(connect_arg_t< Function >) ENTT_NOEXCEPT -> delegate< std::remove_pointer_t< decltype(internal::to_function_pointer(Function))>>
    Deduction guide.
    +
    entt::delegate< Ret(Args...)>::delegate
    delegate() ENTT_NOEXCEPT
    Default constructor.
    Definition: delegate.hpp:91
    +
    entt::delegate< Ret(Args...)>::operator==
    bool operator==(const delegate< Ret(Args...)> &other) const ENTT_NOEXCEPT
    Checks if the connected functions differ.
    Definition: delegate.hpp:224
    +
    entt::operator!=
    constexpr bool operator!=(const hashed_string &lhs, const hashed_string &rhs) ENTT_NOEXCEPT
    Compares two hashed strings.
    Definition: hashed_string.hpp:195
    diff --git a/dir_66e9674e8206a335795995fa32a03c91.html b/dir_66e9674e8206a335795995fa32a03c91.html index 6eb5887fc..1381c3187 100644 --- a/dir_66e9674e8206a335795995fa32a03c91.html +++ b/dir_66e9674e8206a335795995fa32a03c91.html @@ -22,7 +22,7 @@
    diff --git a/dir_68267d1309a1af8e8297ef4c3efbcdba.html b/dir_68267d1309a1af8e8297ef4c3efbcdba.html index 0b3d64bdc..70671e069 100644 --- a/dir_68267d1309a1af8e8297ef4c3efbcdba.html +++ b/dir_68267d1309a1af8e8297ef4c3efbcdba.html @@ -22,7 +22,7 @@ diff --git a/dir_721f6154dba3c88bcdead5f446bce319.html b/dir_721f6154dba3c88bcdead5f446bce319.html index 0160c8243..f39229a53 100644 --- a/dir_721f6154dba3c88bcdead5f446bce319.html +++ b/dir_721f6154dba3c88bcdead5f446bce319.html @@ -22,7 +22,7 @@ diff --git a/dir_7929ab29d3f740cf727ccbd263321562.html b/dir_7929ab29d3f740cf727ccbd263321562.html index 0eaeaa7e3..376a9d154 100644 --- a/dir_7929ab29d3f740cf727ccbd263321562.html +++ b/dir_7929ab29d3f740cf727ccbd263321562.html @@ -22,7 +22,7 @@ diff --git a/dir_85dbee8884f1b3a817fa7eff8dff73ec.html b/dir_85dbee8884f1b3a817fa7eff8dff73ec.html index 45c9f9778..cda555466 100644 --- a/dir_85dbee8884f1b3a817fa7eff8dff73ec.html +++ b/dir_85dbee8884f1b3a817fa7eff8dff73ec.html @@ -22,7 +22,7 @@ diff --git a/dir_a53318306f6ac0f7fe657839abd543ab.html b/dir_a53318306f6ac0f7fe657839abd543ab.html index 0de5b30f0..91badae34 100644 --- a/dir_a53318306f6ac0f7fe657839abd543ab.html +++ b/dir_a53318306f6ac0f7fe657839abd543ab.html @@ -22,7 +22,7 @@ diff --git a/dir_b64489a1e8130d5ebf6d86d282f500f0.html b/dir_b64489a1e8130d5ebf6d86d282f500f0.html index 027c8db2a..fe5e6f1b5 100644 --- a/dir_b64489a1e8130d5ebf6d86d282f500f0.html +++ b/dir_b64489a1e8130d5ebf6d86d282f500f0.html @@ -22,7 +22,7 @@ diff --git a/dir_c5715f7ee899854a669b87bbaa642de0.html b/dir_c5715f7ee899854a669b87bbaa642de0.html index ca77cfa03..ffbc99848 100644 --- a/dir_c5715f7ee899854a669b87bbaa642de0.html +++ b/dir_c5715f7ee899854a669b87bbaa642de0.html @@ -22,7 +22,7 @@ diff --git a/dir_de8f4e6ba3f54a2a21309f742e93a373.html b/dir_de8f4e6ba3f54a2a21309f742e93a373.html index f6db24e45..0756f21f3 100644 --- a/dir_de8f4e6ba3f54a2a21309f742e93a373.html +++ b/dir_de8f4e6ba3f54a2a21309f742e93a373.html @@ -22,7 +22,7 @@ diff --git a/dir_e3a7bb56c55e5c2286e2fe96e197d4f5.html b/dir_e3a7bb56c55e5c2286e2fe96e197d4f5.html index 25fdac6ed..ecbe78687 100644 --- a/dir_e3a7bb56c55e5c2286e2fe96e197d4f5.html +++ b/dir_e3a7bb56c55e5c2286e2fe96e197d4f5.html @@ -22,7 +22,7 @@ diff --git a/dispatcher_8hpp_source.html b/dispatcher_8hpp_source.html index c40667af7..f609d3144 100644 --- a/dispatcher_8hpp_source.html +++ b/dispatcher_8hpp_source.html @@ -22,7 +22,7 @@ @@ -67,16 +67,19 @@ $(function() {
    dispatcher.hpp
    -
    1 #ifndef ENTT_SIGNAL_DISPATCHER_HPP
    2 #define ENTT_SIGNAL_DISPATCHER_HPP
    3 
    4 
    5 #include <vector>
    6 #include <memory>
    7 #include <utility>
    8 #include <cstdint>
    9 #include <algorithm>
    10 #include <type_traits>
    11 #include "../config/config.h"
    12 #include "../core/family.hpp"
    13 #include "sigh.hpp"
    14 
    15 
    16 namespace entt {
    17 
    18 
    35 class Dispatcher final {
    36  using event_family = Family<struct InternalDispatcherEventFamily>;
    37 
    38  template<typename Class, typename Event>
    39  using instance_type = typename SigH<void(const Event &)>::template instance_type<Class>;
    40 
    41  struct BaseSignalWrapper {
    42  virtual ~BaseSignalWrapper() = default;
    43  virtual void publish() = 0;
    44  };
    45 
    46  template<typename Event>
    47  struct SignalWrapper final: BaseSignalWrapper {
    48  using sink_type = typename SigH<void(const Event &)>::sink_type;
    49 
    50  void publish() override {
    51  const auto &curr = current++;
    52  current %= std::extent<decltype(events)>::value;
    53  std::for_each(events[curr].cbegin(), events[curr].cend(), [this](const auto &event) { signal.publish(event); });
    54  events[curr].clear();
    55  }
    56 
    57  inline sink_type sink() ENTT_NOEXCEPT {
    58  return signal.sink();
    59  }
    60 
    61  template<typename... Args>
    62  inline void trigger(Args &&... args) {
    63  signal.publish({ std::forward<Args>(args)... });
    64  }
    65 
    66  template<typename... Args>
    67  inline void enqueue(Args &&... args) {
    68  events[current].push_back({ std::forward<Args>(args)... });
    69  }
    70 
    71  private:
    72  SigH<void(const Event &)> signal{};
    73  std::vector<Event> events[2];
    74  int current{};
    75  };
    76 
    77  template<typename Event>
    78  SignalWrapper<Event> & wrapper() {
    79  const auto type = event_family::type<Event>();
    80 
    81  if(!(type < wrappers.size())) {
    82  wrappers.resize(type + 1);
    83  }
    84 
    85  if(!wrappers[type]) {
    86  wrappers[type] = std::make_unique<SignalWrapper<Event>>();
    87  }
    88 
    89  return static_cast<SignalWrapper<Event> &>(*wrappers[type]);
    90  }
    91 
    92 public:
    94  template<typename Event>
    95  using sink_type = typename SignalWrapper<Event>::sink_type;
    96 
    114  template<typename Event>
    115  inline sink_type<Event> sink() ENTT_NOEXCEPT {
    116  return wrapper<Event>().sink();
    117  }
    118 
    129  template<typename Event, typename... Args>
    130  inline void trigger(Args &&... args) {
    131  wrapper<Event>().trigger(std::forward<Args>(args)...);
    132  }
    133 
    144  template<typename Event, typename... Args>
    145  inline void enqueue(Args &&... args) {
    146  wrapper<Event>().enqueue(std::forward<Args>(args)...);
    147  }
    148 
    158  template<typename Event>
    159  inline void update() {
    160  wrapper<Event>().publish();
    161  }
    162 
    170  inline void update() const {
    171  for(auto pos = wrappers.size(); pos; --pos) {
    172  auto &wrapper = wrappers[pos-1];
    173 
    174  if(wrapper) {
    175  wrapper->publish();
    176  }
    177  }
    178  }
    179 
    180 private:
    181  std::vector<std::unique_ptr<BaseSignalWrapper>> wrappers;
    182 };
    183 
    184 
    185 }
    186 
    187 
    188 #endif // ENTT_SIGNAL_DISPATCHER_HPP
    entt::Dispatcher::sink_type
    typename SignalWrapper< Event >::sink_type sink_type
    Type of sink for the given event.
    Definition: dispatcher.hpp:95
    -
    entt::Dispatcher::sink
    sink_type< Event > sink() ENTT_NOEXCEPT
    Returns a sink object for the given event.
    Definition: dispatcher.hpp:115
    +
    1 #ifndef ENTT_SIGNAL_DISPATCHER_HPP
    2 #define ENTT_SIGNAL_DISPATCHER_HPP
    3 
    4 
    5 #include <vector>
    6 #include <memory>
    7 #include <utility>
    8 #include <type_traits>
    9 #include "../config/config.h"
    10 #include "../core/family.hpp"
    11 #include "../core/type_traits.hpp"
    12 #include "sigh.hpp"
    13 
    14 
    15 namespace entt {
    16 
    17 
    31 class dispatcher {
    32  using event_family = family<struct internal_dispatcher_event_family>;
    33 
    34  template<typename Class, typename Event>
    35  using instance_type = typename sigh<void(const Event &)>::template instance_type<Class>;
    36 
    37  struct base_wrapper {
    38  virtual ~base_wrapper() = default;
    39  virtual void publish() = 0;
    40  };
    41 
    42  template<typename Event>
    43  struct signal_wrapper: base_wrapper {
    44  using signal_type = sigh<void(const Event &)>;
    45  using sink_type = typename signal_type::sink_type;
    46 
    47  void publish() override {
    48  for(const auto &event: events[current]) {
    49  signal.publish(event);
    50  }
    51 
    52  events[current++].clear();
    53  current %= std::extent<decltype(events)>::value;
    54  }
    55 
    56  inline sink_type sink() ENTT_NOEXCEPT {
    57  return signal.sink();
    58  }
    59 
    60  template<typename... Args>
    61  inline void trigger(Args &&... args) {
    62  signal.publish({ std::forward<Args>(args)... });
    63  }
    64 
    65  template<typename... Args>
    66  inline void enqueue(Args &&... args) {
    67  events[current].emplace_back(std::forward<Args>(args)...);
    68  }
    69 
    70  private:
    71  signal_type signal{};
    72  std::vector<Event> events[2];
    73  int current{};
    74  };
    75 
    76  struct wrapper_data {
    77  std::unique_ptr<base_wrapper> wrapper;
    78  ENTT_ID_TYPE runtime_type;
    79  };
    80 
    81  template<typename Event>
    82  static auto type() ENTT_NOEXCEPT {
    83  if constexpr(is_named_type_v<Event>) {
    84  return named_type_traits<Event>::value;
    85  } else {
    86  return event_family::type<Event>;
    87  }
    88  }
    89 
    90  template<typename Event>
    91  signal_wrapper<Event> & assure() {
    92  const auto wtype = type<Event>();
    93  wrapper_data *wdata = nullptr;
    94 
    95  if constexpr(is_named_type_v<Event>) {
    96  const auto it = std::find_if(wrappers.begin(), wrappers.end(), [wtype](const auto &candidate) {
    97  return candidate.wrapper && candidate.runtime_type == wtype;
    98  });
    99 
    100  wdata = (it == wrappers.cend() ? &wrappers.emplace_back() : &(*it));
    101  } else {
    102  if(!(wtype < wrappers.size())) {
    103  wrappers.resize(wtype+1);
    104  }
    105 
    106  wdata = &wrappers[wtype];
    107 
    108  if(wdata->wrapper && wdata->runtime_type != wtype) {
    109  wrappers.emplace_back();
    110  std::swap(wrappers[wtype], wrappers.back());
    111  wdata = &wrappers[wtype];
    112  }
    113  }
    114 
    115  if(!wdata->wrapper) {
    116  wdata->wrapper = std::make_unique<signal_wrapper<Event>>();
    117  wdata->runtime_type = wtype;
    118  }
    119 
    120  return static_cast<signal_wrapper<Event> &>(*wdata->wrapper);
    121  }
    122 
    123 public:
    125  template<typename Event>
    126  using sink_type = typename signal_wrapper<Event>::sink_type;
    127 
    145  template<typename Event>
    146  inline sink_type<Event> sink() ENTT_NOEXCEPT {
    147  return assure<Event>().sink();
    148  }
    149 
    160  template<typename Event, typename... Args>
    161  inline void trigger(Args &&... args) {
    162  assure<Event>().trigger(std::forward<Args>(args)...);
    163  }
    164 
    174  template<typename Event>
    175  inline void trigger(Event &&event) {
    176  assure<std::decay_t<Event>>().trigger(std::forward<Event>(event));
    177  }
    178 
    189  template<typename Event, typename... Args>
    190  inline void enqueue(Args &&... args) {
    191  assure<Event>().enqueue(std::forward<Args>(args)...);
    192  }
    193 
    203  template<typename Event>
    204  inline void enqueue(Event &&event) {
    205  assure<std::decay_t<Event>>().enqueue(std::forward<Event>(event));
    206  }
    207 
    217  template<typename Event>
    218  inline void update() {
    219  assure<Event>().publish();
    220  }
    221 
    229  inline void update() const {
    230  for(auto pos = wrappers.size(); pos; --pos) {
    231  auto &wdata = wrappers[pos-1];
    232 
    233  if(wdata.wrapper) {
    234  wdata.wrapper->publish();
    235  }
    236  }
    237  }
    238 
    239 private:
    240  std::vector<wrapper_data> wrappers;
    241 };
    242 
    243 
    244 }
    245 
    246 
    247 #endif // ENTT_SIGNAL_DISPATCHER_HPP
    entt::dispatcher::trigger
    void trigger(Event &&event)
    Triggers an immediate event of the given type.
    Definition: dispatcher.hpp:175
    entt
    EnTT default namespace.
    Definition: algorithm.hpp:10
    -
    entt::Dispatcher::enqueue
    void enqueue(Args &&... args)
    Enqueues an event of the given type.
    Definition: dispatcher.hpp:145
    -
    entt::Dispatcher::update
    void update() const
    Delivers all the pending events.
    Definition: dispatcher.hpp:170
    -
    entt::Dispatcher::trigger
    void trigger(Args &&... args)
    Triggers an immediate event of the given type.
    Definition: dispatcher.hpp:130
    -
    entt::Dispatcher
    Basic dispatcher implementation.
    Definition: dispatcher.hpp:35
    -
    entt::Dispatcher::update
    void update()
    Delivers all the pending events of the given type.
    Definition: dispatcher.hpp:159
    -
    entt::SigH
    Unmanaged signal handler declaration.
    Definition: sigh.hpp:121
    -
    entt::Family
    Dynamic identifier generator.
    Definition: family.hpp:22
    +
    entt::dispatcher::update
    void update()
    Delivers all the pending events of the given type.
    Definition: dispatcher.hpp:218
    +
    entt::dispatcher::sink
    sink_type< Event > sink() ENTT_NOEXCEPT
    Returns a sink object for the given event.
    Definition: dispatcher.hpp:146
    +
    entt::dispatcher::sink_type
    typename signal_wrapper< Event >::sink_type sink_type
    Type of sink for the given event.
    Definition: dispatcher.hpp:126
    +
    entt::named_type_traits
    Traits class used mainly to push things across boundaries.
    Definition: type_traits.hpp:99
    +
    entt::family
    Dynamic identifier generator.
    Definition: family.hpp:20
    +
    entt::dispatcher::trigger
    void trigger(Args &&... args)
    Triggers an immediate event of the given type.
    Definition: dispatcher.hpp:161
    +
    entt::dispatcher::enqueue
    void enqueue(Args &&... args)
    Enqueues an event of the given type.
    Definition: dispatcher.hpp:190
    +
    entt::dispatcher::update
    void update() const
    Delivers all the pending events.
    Definition: dispatcher.hpp:229
    +
    entt::dispatcher::enqueue
    void enqueue(Event &&event)
    Enqueues an event of the given type.
    Definition: dispatcher.hpp:204
    +
    entt::sigh
    Unmanaged signal handler declaration.
    Definition: fwd.hpp:21
    +
    entt::dispatcher
    Basic dispatcher implementation.
    Definition: dispatcher.hpp:31
    diff --git a/emitter_8hpp_source.html b/emitter_8hpp_source.html index fc6e1d69e..321af1ce3 100644 --- a/emitter_8hpp_source.html +++ b/emitter_8hpp_source.html @@ -22,7 +22,7 @@
    @@ -67,22 +67,23 @@ $(function() {
    emitter.hpp
    -
    1 #ifndef ENTT_SIGNAL_EMITTER_HPP
    2 #define ENTT_SIGNAL_EMITTER_HPP
    3 
    4 
    5 #include <type_traits>
    6 #include <functional>
    7 #include <algorithm>
    8 #include <utility>
    9 #include <cstdint>
    10 #include <memory>
    11 #include <vector>
    12 #include <list>
    13 #include "../config/config.h"
    14 #include "../core/family.hpp"
    15 
    16 
    17 namespace entt {
    18 
    19 
    41 template<typename Derived>
    42 class Emitter {
    43  using handler_family = Family<struct InternalEmitterHandlerFamily>;
    44 
    45  struct BaseHandler {
    46  virtual ~BaseHandler() = default;
    47  virtual bool empty() const ENTT_NOEXCEPT = 0;
    48  virtual void clear() ENTT_NOEXCEPT = 0;
    49  };
    50 
    51  template<typename Event>
    52  struct Handler final: BaseHandler {
    53  using listener_type = std::function<void(const Event &, Derived &)>;
    54  using element_type = std::pair<bool, listener_type>;
    55  using container_type = std::list<element_type>;
    56  using connection_type = typename container_type::iterator;
    57 
    58  bool empty() const ENTT_NOEXCEPT override {
    59  auto pred = [](auto &&element) { return element.first; };
    60 
    61  return std::all_of(onceL.cbegin(), onceL.cend(), pred) &&
    62  std::all_of(onL.cbegin(), onL.cend(), pred);
    63  }
    64 
    65  void clear() ENTT_NOEXCEPT override {
    66  if(publishing) {
    67  auto func = [](auto &&element) { element.first = true; };
    68  std::for_each(onceL.begin(), onceL.end(), func);
    69  std::for_each(onL.begin(), onL.end(), func);
    70  } else {
    71  onceL.clear();
    72  onL.clear();
    73  }
    74  }
    75 
    76  inline connection_type once(listener_type listener) {
    77  return onceL.emplace(onceL.cend(), false, std::move(listener));
    78  }
    79 
    80  inline connection_type on(listener_type listener) {
    81  return onL.emplace(onL.cend(), false, std::move(listener));
    82  }
    83 
    84  void erase(connection_type conn) ENTT_NOEXCEPT {
    85  conn->first = true;
    86 
    87  if(!publishing) {
    88  auto pred = [](auto &&element) { return element.first; };
    89  onceL.remove_if(pred);
    90  onL.remove_if(pred);
    91  }
    92  }
    93 
    94  void publish(const Event &event, Derived &ref) {
    95  container_type currentL;
    96  onceL.swap(currentL);
    97 
    98  auto func = [&event, &ref](auto &&element) {
    99  return element.first ? void() : element.second(event, ref);
    100  };
    101 
    102  publishing = true;
    103 
    104  std::for_each(onL.rbegin(), onL.rend(), func);
    105  std::for_each(currentL.rbegin(), currentL.rend(), func);
    106 
    107  publishing = false;
    108 
    109  onL.remove_if([](auto &&element) { return element.first; });
    110  }
    111 
    112  private:
    113  bool publishing{false};
    114  container_type onceL{};
    115  container_type onL{};
    116  };
    117 
    118  template<typename Event>
    119  Handler<Event> & handler() ENTT_NOEXCEPT {
    120  const std::size_t family = handler_family::type<Event>();
    121 
    122  if(!(family < handlers.size())) {
    123  handlers.resize(family+1);
    124  }
    125 
    126  if(!handlers[family]) {
    127  handlers[family] = std::make_unique<Handler<Event>>();
    128  }
    129 
    130  return static_cast<Handler<Event> &>(*handlers[family]);
    131  }
    132 
    133 public:
    135  template<typename Event>
    136  using Listener = typename Handler<Event>::listener_type;
    137 
    147  template<typename Event>
    148  struct Connection final: private Handler<Event>::connection_type {
    150  friend class Emitter;
    151 
    153  Connection() ENTT_NOEXCEPT = default;
    154 
    159  Connection(typename Handler<Event>::connection_type conn)
    160  : Handler<Event>::connection_type{std::move(conn)}
    161  {}
    162 
    164  Connection(const Connection &) = default;
    166  Connection(Connection &&) = default;
    167 
    172  Connection & operator=(const Connection &) = default;
    173 
    178  Connection & operator=(Connection &&) = default;
    179  };
    180 
    182  Emitter() ENTT_NOEXCEPT = default;
    183 
    185  virtual ~Emitter() ENTT_NOEXCEPT {
    186  static_assert(std::is_base_of<Emitter<Derived>, Derived>::value, "!");
    187  }
    188 
    190  Emitter(const Emitter &) = delete;
    192  Emitter(Emitter &&) = default;
    193 
    195  Emitter & operator=(const Emitter &) = delete;
    197  Emitter & operator=(Emitter &&) = default;
    198 
    210  template<typename Event, typename... Args>
    211  void publish(Args &&... args) {
    212  handler<Event>().publish({ std::forward<Args>(args)... }, *static_cast<Derived *>(this));
    213  }
    214 
    235  template<typename Event>
    236  Connection<Event> on(Listener<Event> listener) {
    237  return handler<Event>().on(std::move(listener));
    238  }
    239 
    260  template<typename Event>
    261  Connection<Event> once(Listener<Event> listener) {
    262  return handler<Event>().once(std::move(listener));
    263  }
    264 
    274  template<typename Event>
    275  void erase(Connection<Event> conn) ENTT_NOEXCEPT {
    276  handler<Event>().erase(std::move(conn));
    277  }
    278 
    287  template<typename Event>
    288  void clear() ENTT_NOEXCEPT {
    289  handler<Event>().clear();
    290  }
    291 
    298  void clear() ENTT_NOEXCEPT {
    299  std::for_each(handlers.begin(), handlers.end(), [](auto &&handler) {
    300  return handler ? handler->clear() : void();
    301  });
    302  }
    303 
    309  template<typename Event>
    310  bool empty() const ENTT_NOEXCEPT {
    311  const std::size_t family = handler_family::type<Event>();
    312 
    313  return (!(family < handlers.size()) ||
    314  !handlers[family] ||
    315  static_cast<Handler<Event> &>(*handlers[family]).empty());
    316  }
    317 
    322  bool empty() const ENTT_NOEXCEPT {
    323  return std::all_of(handlers.cbegin(), handlers.cend(), [](auto &&handler) {
    324  return !handler || handler->empty();
    325  });
    326  }
    327 
    328 private:
    329  std::vector<std::unique_ptr<BaseHandler>> handlers{};
    330 };
    331 
    332 
    333 }
    334 
    335 
    336 #endif // ENTT_SIGNAL_EMITTER_HPP
    entt::Emitter::empty
    bool empty() const ENTT_NOEXCEPT
    Checks if there are listeners registered for the specific event.
    Definition: emitter.hpp:310
    -
    entt::Emitter::empty
    bool empty() const ENTT_NOEXCEPT
    Checks if there are listeners registered with the event emitter.
    Definition: emitter.hpp:322
    -
    entt::Emitter::on
    Connection< Event > on(Listener< Event > listener)
    Registers a long-lived listener with the event emitter.
    Definition: emitter.hpp:236
    -
    entt::Emitter::operator=
    Emitter & operator=(const Emitter &)=delete
    Copying an emitter isn&#39;t allowed.
    +
    1 #ifndef ENTT_SIGNAL_EMITTER_HPP
    2 #define ENTT_SIGNAL_EMITTER_HPP
    3 
    4 
    5 #include <type_traits>
    6 #include <functional>
    7 #include <algorithm>
    8 #include <utility>
    9 #include <memory>
    10 #include <vector>
    11 #include <list>
    12 #include "../config/config.h"
    13 #include "../core/family.hpp"
    14 #include "../core/type_traits.hpp"
    15 
    16 
    17 namespace entt {
    18 
    19 
    41 template<typename Derived>
    42 class emitter {
    43  using handler_family = family<struct internal_emitter_handler_family>;
    44 
    45  struct base_handler {
    46  virtual ~base_handler() = default;
    47  virtual bool empty() const ENTT_NOEXCEPT = 0;
    48  virtual void clear() ENTT_NOEXCEPT = 0;
    49  };
    50 
    51  template<typename Event>
    52  struct event_handler: base_handler {
    53  using listener_type = std::function<void(const Event &, Derived &)>;
    54  using element_type = std::pair<bool, listener_type>;
    55  using container_type = std::list<element_type>;
    56  using connection_type = typename container_type::iterator;
    57 
    58  bool empty() const ENTT_NOEXCEPT override {
    59  auto pred = [](auto &&element) { return element.first; };
    60 
    61  return std::all_of(once_list.cbegin(), once_list.cend(), pred) &&
    62  std::all_of(on_list.cbegin(), on_list.cend(), pred);
    63  }
    64 
    65  void clear() ENTT_NOEXCEPT override {
    66  if(publishing) {
    67  auto func = [](auto &&element) { element.first = true; };
    68  std::for_each(once_list.begin(), once_list.end(), func);
    69  std::for_each(on_list.begin(), on_list.end(), func);
    70  } else {
    71  once_list.clear();
    72  on_list.clear();
    73  }
    74  }
    75 
    76  inline connection_type once(listener_type listener) {
    77  return once_list.emplace(once_list.cend(), false, std::move(listener));
    78  }
    79 
    80  inline connection_type on(listener_type listener) {
    81  return on_list.emplace(on_list.cend(), false, std::move(listener));
    82  }
    83 
    84  void erase(connection_type conn) ENTT_NOEXCEPT {
    85  conn->first = true;
    86 
    87  if(!publishing) {
    88  auto pred = [](auto &&element) { return element.first; };
    89  once_list.remove_if(pred);
    90  on_list.remove_if(pred);
    91  }
    92  }
    93 
    94  void publish(const Event &event, Derived &ref) {
    95  container_type swap_list;
    96  once_list.swap(swap_list);
    97 
    98  auto func = [&event, &ref](auto &&element) {
    99  return element.first ? void() : element.second(event, ref);
    100  };
    101 
    102  publishing = true;
    103 
    104  std::for_each(on_list.rbegin(), on_list.rend(), func);
    105  std::for_each(swap_list.rbegin(), swap_list.rend(), func);
    106 
    107  publishing = false;
    108 
    109  on_list.remove_if([](auto &&element) { return element.first; });
    110  }
    111 
    112  private:
    113  bool publishing{false};
    114  container_type once_list{};
    115  container_type on_list{};
    116  };
    117 
    118  struct handler_data {
    119  std::unique_ptr<base_handler> handler;
    120  ENTT_ID_TYPE runtime_type;
    121  };
    122 
    123  template<typename Event>
    124  static auto type() ENTT_NOEXCEPT {
    125  if constexpr(is_named_type_v<Event>) {
    126  return named_type_traits<Event>::value;
    127  } else {
    128  return handler_family::type<Event>;
    129  }
    130  }
    131 
    132  template<typename Event>
    133  event_handler<Event> * assure() const ENTT_NOEXCEPT {
    134  const auto htype = type<Event>();
    135  handler_data *hdata = nullptr;
    136 
    137  if constexpr(is_named_type_v<Event>) {
    138  const auto it = std::find_if(handlers.begin(), handlers.end(), [htype](const auto &candidate) {
    139  return candidate.handler && candidate.runtime_type == htype;
    140  });
    141 
    142  hdata = (it == handlers.cend() ? &handlers.emplace_back() : &(*it));
    143  } else {
    144  if(!(htype < handlers.size())) {
    145  handlers.resize(htype+1);
    146  }
    147 
    148  hdata = &handlers[htype];
    149 
    150  if(hdata->handler && hdata->runtime_type != htype) {
    151  handlers.emplace_back();
    152  std::swap(handlers[htype], handlers.back());
    153  hdata = &handlers[htype];
    154  }
    155  }
    156 
    157  if(!hdata->handler) {
    158  hdata->handler = std::make_unique<event_handler<Event>>();
    159  hdata->runtime_type = htype;
    160  }
    161 
    162  return static_cast<event_handler<Event> *>(hdata->handler.get());
    163  }
    164 
    165 public:
    167  template<typename Event>
    168  using listener = typename event_handler<Event>::listener_type;
    169 
    179  template<typename Event>
    180  struct connection: private event_handler<Event>::connection_type {
    182  friend class emitter;
    183 
    185  connection() ENTT_NOEXCEPT = default;
    186 
    191  connection(typename event_handler<Event>::connection_type conn)
    192  : event_handler<Event>::connection_type{std::move(conn)}
    193  {}
    194  };
    195 
    197  emitter() ENTT_NOEXCEPT = default;
    198 
    200  virtual ~emitter() ENTT_NOEXCEPT {
    201  static_assert(std::is_base_of_v<emitter<Derived>, Derived>);
    202  }
    203 
    205  emitter(emitter &&) = default;
    206 
    208  emitter & operator=(emitter &&) = default;
    209 
    221  template<typename Event, typename... Args>
    222  void publish(Args &&... args) {
    223  assure<Event>()->publish({ std::forward<Args>(args)... }, *static_cast<Derived *>(this));
    224  }
    225 
    246  template<typename Event>
    247  connection<Event> on(listener<Event> instance) {
    248  return assure<Event>()->on(std::move(instance));
    249  }
    250 
    271  template<typename Event>
    272  connection<Event> once(listener<Event> instance) {
    273  return assure<Event>()->once(std::move(instance));
    274  }
    275 
    285  template<typename Event>
    286  void erase(connection<Event> conn) ENTT_NOEXCEPT {
    287  assure<Event>()->erase(std::move(conn));
    288  }
    289 
    298  template<typename Event>
    299  void clear() ENTT_NOEXCEPT {
    300  assure<Event>()->clear();
    301  }
    302 
    309  void clear() ENTT_NOEXCEPT {
    310  std::for_each(handlers.begin(), handlers.end(), [](auto &&hdata) {
    311  return hdata.handler ? hdata.handler->clear() : void();
    312  });
    313  }
    314 
    320  template<typename Event>
    321  bool empty() const ENTT_NOEXCEPT {
    322  return assure<Event>()->empty();
    323  }
    324 
    329  bool empty() const ENTT_NOEXCEPT {
    330  return std::all_of(handlers.cbegin(), handlers.cend(), [](auto &&hdata) {
    331  return !hdata.handler || hdata.handler->empty();
    332  });
    333  }
    334 
    335 private:
    336  mutable std::vector<handler_data> handlers{};
    337 };
    338 
    339 
    340 }
    341 
    342 
    343 #endif // ENTT_SIGNAL_EMITTER_HPP
    entt::emitter::on
    connection< Event > on(listener< Event > instance)
    Registers a long-lived listener with the event emitter.
    Definition: emitter.hpp:247
    +
    entt::emitter::once
    connection< Event > once(listener< Event > instance)
    Registers a short-lived listener with the event emitter.
    Definition: emitter.hpp:272
    +
    entt::emitter::operator=
    emitter & operator=(emitter &&)=default
    Default move assignment operator.
    entt
    EnTT default namespace.
    Definition: algorithm.hpp:10
    -
    entt::Emitter::Connection
    Generic connection type for events.
    Definition: emitter.hpp:148
    -
    entt::Emitter::publish
    void publish(Args &&... args)
    Emits the given event.
    Definition: emitter.hpp:211
    -
    entt::Emitter::once
    Connection< Event > once(Listener< Event > listener)
    Registers a short-lived listener with the event emitter.
    Definition: emitter.hpp:261
    -
    entt::Emitter::clear
    void clear() ENTT_NOEXCEPT
    Disconnects all the listeners for the given event type.
    Definition: emitter.hpp:288
    -
    entt::Emitter::clear
    void clear() ENTT_NOEXCEPT
    Disconnects all the listeners.
    Definition: emitter.hpp:298
    -
    entt::Emitter
    General purpose event emitter.
    Definition: emitter.hpp:42
    -
    entt::Emitter::Emitter
    Emitter() ENTT_NOEXCEPT=default
    Default constructor.
    -
    entt::Emitter::~Emitter
    virtual ~Emitter() ENTT_NOEXCEPT
    Default destructor.
    Definition: emitter.hpp:185
    -
    entt::Emitter::erase
    void erase(Connection< Event > conn) ENTT_NOEXCEPT
    Disconnects a listener from the event emitter.
    Definition: emitter.hpp:275
    -
    entt::Emitter::Listener
    typename Handler< Event >::listener_type Listener
    Type of listeners accepted for the given event.
    Definition: emitter.hpp:136
    -
    entt::Family
    Dynamic identifier generator.
    Definition: family.hpp:22
    +
    entt::emitter::publish
    void publish(Args &&... args)
    Emits the given event.
    Definition: emitter.hpp:222
    +
    entt::emitter::connection
    Generic connection type for events.
    Definition: emitter.hpp:180
    +
    entt::named_type_traits
    Traits class used mainly to push things across boundaries.
    Definition: type_traits.hpp:99
    +
    entt::family
    Dynamic identifier generator.
    Definition: family.hpp:20
    +
    entt::emitter
    General purpose event emitter.
    Definition: emitter.hpp:42
    +
    entt::emitter::empty
    bool empty() const ENTT_NOEXCEPT
    Checks if there are listeners registered for the specific event.
    Definition: emitter.hpp:321
    +
    entt::emitter::erase
    void erase(connection< Event > conn) ENTT_NOEXCEPT
    Disconnects a listener from the event emitter.
    Definition: emitter.hpp:286
    +
    entt::emitter::empty
    bool empty() const ENTT_NOEXCEPT
    Checks if there are listeners registered with the event emitter.
    Definition: emitter.hpp:329
    +
    entt::emitter::~emitter
    virtual ~emitter() ENTT_NOEXCEPT
    Default destructor.
    Definition: emitter.hpp:200
    +
    entt::emitter::listener
    typename event_handler< Event >::listener_type listener
    Type of listeners accepted for the given event.
    Definition: emitter.hpp:168
    +
    entt::emitter::clear
    void clear() ENTT_NOEXCEPT
    Disconnects all the listeners for the given event type.
    Definition: emitter.hpp:299
    +
    entt::emitter::emitter
    emitter() ENTT_NOEXCEPT=default
    Default constructor.
    +
    entt::emitter::clear
    void clear() ENTT_NOEXCEPT
    Disconnects all the listeners.
    Definition: emitter.hpp:309
    diff --git a/entity_2fwd_8hpp_source.html b/entity_2fwd_8hpp_source.html new file mode 100644 index 000000000..b69afa972 --- /dev/null +++ b/entity_2fwd_8hpp_source.html @@ -0,0 +1,89 @@ + + + + + + + +EnTT: src/entt/entity/fwd.hpp Source File + + + + + + + + + +
    +
    +
    - + @@ -452,23 +415,23 @@ template<typename Delta >

    Number of processes currently scheduled.

    Returns
    Number of processes currently scheduled.
    -

    Definition at line 140 of file scheduler.hpp.

    +

    Definition at line 129 of file scheduler.hpp.

    - -

    ◆ update()

    + +

    ◆ update()

    -template<typename Delta >
    +template<typename Delta>
    size_type entt::Scheduler< Delta >::size size_type entt::scheduler< Delta >::size ( ) const
    @@ -63,42 +63,48 @@ $(function() {
    Class Index
    -
    a | c | d | e | f | h | i | m | o | p | r | s | t | v
    +
    a | b | c | d | e | f | g | h | i | m | n | p | r | s | t
    - + @@ -503,7 +466,7 @@ template<typename Delta > -

    Definition at line 265 of file scheduler.hpp.

    +

    Definition at line 254 of file scheduler.hpp.

    diff --git a/classentt_1_1Sink.html b/classentt_1_1sink.html similarity index 80% rename from classentt_1_1Sink.html rename to classentt_1_1sink.html index a934536e4..6e7581a0b 100644 --- a/classentt_1_1Sink.html +++ b/classentt_1_1sink.html @@ -5,7 +5,7 @@ -EnTT: entt::Sink< Function > Class Template Reference +EnTT: entt::sink< typename > Class Template Reference @@ -22,7 +22,7 @@ @@ -59,24 +59,24 @@ $(function() {
    -
    entt::Sink< Function > Class Template Reference
    +
    entt::sink< typename > Class Template Reference
    -

    Sink implementation. - More...

    +

    Sink implementation. + More...

    #include <sigh.hpp>

    Detailed Description

    -

    template<typename Function>
    -class entt::Sink< Function >

    +

    template<typename>
    +class entt::sink< typename >

    -

    Sink implementation.

    +

    Sink implementation.

    TURN_OFF_DOXYGEN Primary template isn't defined on purpose. All the specializations give a compile-time error unless the template parameter is a function type.

    Template Parameters
    void entt::Scheduler< Delta >::update void entt::scheduler< Delta >::update ( const Delta  delta,
    EnTT -  2.7.3 +  3.0.0
    @@ -85,9 +85,9 @@ class entt::Sink< Function > -

    Definition at line 108 of file sigh.hpp.

    +

    Definition at line 17 of file fwd.hpp.

    The documentation for this class was generated from the following file: diff --git a/classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4-members.html b/classentt_1_1sink_3_01Ret_07Args_8_8_8_08_4-members.html similarity index 51% rename from classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4-members.html rename to classentt_1_1sink_3_01Ret_07Args_8_8_8_08_4-members.html index 59252e5ba..93295fc25 100644 --- a/classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4-members.html +++ b/classentt_1_1sink_3_01Ret_07Args_8_8_8_08_4-members.html @@ -22,7 +22,7 @@ @@ -59,26 +59,24 @@ $(function() {
    -
    entt::Sink< Ret(Args...)> Member List
    +
    entt::sink< Ret(Args...)> Member List
    -

    This is the complete list of members for entt::Sink< Ret(Args...)>, including all inherited members.

    +

    This is the complete list of members for entt::sink< Ret(Args...)>, including all inherited members.

    EnTT -  2.7.3 +  3.0.0
    - - - - - - - - - + + + + + + +
    connect()entt::Sink< Ret(Args...)>inline
    connect(Class *instance)entt::Sink< Ret(Args...)>inline
    connect(Class *instance)entt::Sink< Ret(Args...)>inline
    disconnect()entt::Sink< Ret(Args...)>inline
    disconnect(Class *instance)entt::Sink< Ret(Args...)>inline
    disconnect(Class *instance)entt::Sink< Ret(Args...)>inline
    disconnect(Class *instance)entt::Sink< Ret(Args...)>inline
    disconnect()entt::Sink< Ret(Args...)>inline
    SigH classentt::Sink< Ret(Args...)>friend
    connect()entt::sink< Ret(Args...)>inline
    connect(Type *value_or_instance)entt::sink< Ret(Args...)>inline
    disconnect()entt::sink< Ret(Args...)>inline
    disconnect(Class *instance)entt::sink< Ret(Args...)>inline
    disconnect()entt::sink< Ret(Args...)>inline
    empty() const ENTT_NOEXCEPTentt::sink< Ret(Args...)>inline
    sighentt::sink< Ret(Args...)>friend
    diff --git a/classentt_1_1sink_3_01Ret_07Args_8_8_8_08_4.html b/classentt_1_1sink_3_01Ret_07Args_8_8_8_08_4.html new file mode 100644 index 000000000..09e4a9e79 --- /dev/null +++ b/classentt_1_1sink_3_01Ret_07Args_8_8_8_08_4.html @@ -0,0 +1,350 @@ + + + + + + + +EnTT: entt::sink< Ret(Args...)> Class Template Reference + + + + + + + + + +
    +
    + + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +Public Member Functions | +Friends | +List of all members
    +
    +
    entt::sink< Ret(Args...)> Class Template Reference
    +
    +
    + +

    Sink implementation. + More...

    + +

    #include <sigh.hpp>

    + + + + + + + + + + + + + + + + + + + + + + + + +

    +Public Member Functions

    bool empty () const ENTT_NOEXCEPT
     Returns false if at least a listener is connected to the sink. More...
     
    template<auto Function>
    void connect ()
     Connects a free function to a signal. More...
     
    template<auto Candidate, typename Type >
    void connect (Type *value_or_instance)
     Connects a member function or a free function with payload to a signal. More...
     
    template<auto Function>
    void disconnect ()
     Disconnects a free function from a signal. More...
     
    template<auto Member, typename Class >
    void disconnect (Class *instance)
     Disconnects a given member function from a signal. More...
     
    +void disconnect ()
     Disconnects all the listeners from a signal.
     
    + + + + + +

    +Friends

    +template<typename , typename >
    struct sigh
     A signal is allowed to create sinks.
     
    +

    Detailed Description

    +

    template<typename Ret, typename... Args>
    +class entt::sink< Ret(Args...)>

    + +

    Sink implementation.

    +

    A sink is an opaque object used to connect listeners to signals.
    + The function type for a listener is the one of the signal to which it belongs.

    +

    The clear separation between a signal and a sink permits to store the former as private data member without exposing the publish functionality to the users of a class.

    +
    Template Parameters
    + + + +
    RetReturn type of a function type.
    ArgsTypes of arguments of a function type.
    +
    +
    + +

    Definition at line 128 of file sigh.hpp.

    +

    Member Function Documentation

    + +

    ◆ connect() [1/2]

    + +
    +
    +
    +template<typename Ret , typename... Args>
    +
    +template<auto Function>
    + + + + + +
    + + + + + + + +
    void entt::sink< Ret(Args...)>::connect ()
    +     		+inline
    +
    + +

    Connects a free function to a signal.

    +

    The signal handler performs checks to avoid multiple connections for free functions.

    +
    Template Parameters
    + + +
    FunctionA valid free function pointer.
    +
    +
    + +

    Definition at line 158 of file sigh.hpp.

    + +
    +
    + +

    ◆ connect() [2/2]

    + +
    +
    +
    +template<typename Ret , typename... Args>
    +
    +template<auto Candidate, typename Type >
    + + + + + +
    + + + + + + + + +
    void entt::sink< Ret(Args...)>::connect (Type * value_or_instance)
    +     		+inline
    +
    + +

    Connects a member function or a free function with payload to a signal.

    +

    The signal isn't responsible for the connected object or the payload. Users must always guarantee that the lifetime of the instance overcomes the one of the delegate. On the other side, the signal handler performs checks to avoid multiple connections for the same function.
    + When used to connect a free function with payload, its signature must be such that the instance is the first argument before the ones used to define the delegate itself.

    +
    Template Parameters
    + + + +
    CandidateMember or free function to connect to the delegate.
    TypeType of class or type of payload.
    +
    +
    +
    Parameters
    + + +
    value_or_instanceA valid pointer that fits the purpose.
    +
    +
    + +

    Definition at line 182 of file sigh.hpp.

    + +
    +
    + +

    ◆ disconnect() [1/2]

    + +
    +
    +
    +template<typename Ret , typename... Args>
    +
    +template<auto Function>
    + + + + + +
    + + + + + + + +
    void entt::sink< Ret(Args...)>::disconnect ()
    +     		+inline
    +
    + +

    Disconnects a free function from a signal.

    +
    Template Parameters
    + + +
    FunctionA valid free function pointer.
    +
    +
    + +

    Definition at line 199 of file sigh.hpp.

    + +
    +
    + +

    ◆ disconnect() [2/2]

    + +
    +
    +
    +template<typename Ret , typename... Args>
    +
    +template<auto Member, typename Class >
    + + + + + +
    + + + + + + + + +
    void entt::sink< Ret(Args...)>::disconnect (Class * instance)
    +     		+inline
    +
    + +

    Disconnects a given member function from a signal.

    +
    Template Parameters
    + + + +
    MemberMember function to disconnect from the signal.
    ClassType of class to which the member function belongs.
    +
    +
    +
    Parameters
    + + +
    instanceA valid instance of type pointer to Class.
    +
    +
    + +

    Definition at line 219 of file sigh.hpp.

    + +
    +
    + +

    ◆ empty()

    + +
    +
    +
    +template<typename Ret , typename... Args>
    + + + + + +
    + + + + + + + +
    bool entt::sink< Ret(Args...)>::empty () const
    +     		+inline
    +
    + +

    Returns false if at least a listener is connected to the sink.

    +
    Returns
    True if the sink has no listeners connected, false otherwise.
    + +

    Definition at line 145 of file sigh.hpp.

    + +
    +
    +
    The documentation for this class was generated from the following file: +
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/classentt_1_1sparse__set-members.html b/classentt_1_1sparse__set-members.html new file mode 100644 index 000000000..1a1fd6168 --- /dev/null +++ b/classentt_1_1sparse__set-members.html @@ -0,0 +1,108 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
    +
    + + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +
    entt::sparse_set< Entity > Member List
    +
    +
    + +

    This is the complete list of members for entt::sparse_set< Entity >, including all inherited members.

    + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    batch(It first, It last)entt::sparse_set< Entity >inline
    begin() const ENTT_NOEXCEPTentt::sparse_set< Entity >inline
    capacity() const ENTT_NOEXCEPTentt::sparse_set< Entity >inline
    construct(const entity_type entt)entt::sparse_set< Entity >inline
    data() const ENTT_NOEXCEPTentt::sparse_set< Entity >inline
    destroy(const entity_type entt)entt::sparse_set< Entity >inlinevirtual
    empty() const ENTT_NOEXCEPTentt::sparse_set< Entity >inline
    end() const ENTT_NOEXCEPTentt::sparse_set< Entity >inline
    entity_type typedefentt::sparse_set< Entity >
    extent() const ENTT_NOEXCEPTentt::sparse_set< Entity >inline
    find(const entity_type entt) const ENTT_NOEXCEPTentt::sparse_set< Entity >inline
    get(const entity_type entt) const ENTT_NOEXCEPTentt::sparse_set< Entity >inline
    has(const entity_type entt) const ENTT_NOEXCEPTentt::sparse_set< Entity >inline
    iterator_type typedefentt::sparse_set< Entity >
    operator=(const sparse_set &other)entt::sparse_set< Entity >inline
    operator=(sparse_set &&)=defaultentt::sparse_set< Entity >
    reserve(const size_type cap)entt::sparse_set< Entity >inlinevirtual
    reset()entt::sparse_set< Entity >inlinevirtual
    respect(const sparse_set &other) ENTT_NOEXCEPTentt::sparse_set< Entity >inlinevirtual
    shrink_to_fit()entt::sparse_set< Entity >inlinevirtual
    size() const ENTT_NOEXCEPTentt::sparse_set< Entity >inline
    size_type typedefentt::sparse_set< Entity >
    sparse_set()=defaultentt::sparse_set< Entity >
    sparse_set(const sparse_set &other)entt::sparse_set< Entity >inline
    sparse_set(sparse_set &&)=defaultentt::sparse_set< Entity >
    swap(const size_type lhs, const size_type rhs) ENTT_NOEXCEPTentt::sparse_set< Entity >inline
    ~sparse_set() ENTT_NOEXCEPT=defaultentt::sparse_set< Entity >virtual
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/classentt_1_1sparse__set.html b/classentt_1_1sparse__set.html new file mode 100644 index 000000000..9f690ab4f --- /dev/null +++ b/classentt_1_1sparse__set.html @@ -0,0 +1,960 @@ + + + + + + + +EnTT: entt::sparse_set< Entity > Class Template Reference + + + + + + + + + +
    +
    + + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +Classes | +Public Types | +Public Member Functions | +List of all members
    +
    +
    entt::sparse_set< Entity > Class Template Reference
    +
    +
    + +

    Basic sparse set implementation. + More...

    + +

    #include <sparse_set.hpp>

    +
    +Inheritance diagram for entt::sparse_set< Entity >:
    +
    +
    Inheritance graph
    + + + + + + + + +
    [legend]
    + + + + + + + + + + + +

    +Public Types

    +using entity_type = Entity
     Underlying entity identifier.
     
    +using size_type = std::size_t
     Unsigned integer type.
     
    +using iterator_type = iterator
     Random access iterator type.
     
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    +Public Member Functions

    + sparse_set ()=default
     Default constructor.
     
     sparse_set (const sparse_set &other)
     Copy constructor. More...
     
    + sparse_set (sparse_set &&)=default
     Default move constructor.
     
    +virtual ~sparse_set () ENTT_NOEXCEPT=default
     Default destructor.
     
    sparse_set & operator= (const sparse_set &other)
     Copy assignment operator. More...
     
    sparse_set & operator= (sparse_set &&)=default
     Default move assignment operator. More...
     
    virtual void reserve (const size_type cap)
     Increases the capacity of a sparse set. More...
     
    size_type capacity () const ENTT_NOEXCEPT
     Returns the number of elements that a sparse set has currently allocated space for. More...
     
    +virtual void shrink_to_fit ()
     Requests the removal of unused capacity.
     
    size_type extent () const ENTT_NOEXCEPT
     Returns the extent of a sparse set. More...
     
    size_type size () const ENTT_NOEXCEPT
     Returns the number of elements in a sparse set. More...
     
    bool empty () const ENTT_NOEXCEPT
     Checks whether a sparse set is empty. More...
     
    const entity_type * data () const ENTT_NOEXCEPT
     Direct access to the internal packed array. More...
     
    iterator_type begin () const ENTT_NOEXCEPT
     Returns an iterator to the beginning. More...
     
    iterator_type end () const ENTT_NOEXCEPT
     Returns an iterator to the end. More...
     
    iterator_type find (const entity_type entt) const ENTT_NOEXCEPT
     Finds an entity. More...
     
    bool has (const entity_type entt) const ENTT_NOEXCEPT
     Checks if a sparse set contains an entity. More...
     
    size_type get (const entity_type entt) const ENTT_NOEXCEPT
     Returns the position of an entity in a sparse set. More...
     
    void construct (const entity_type entt)
     Assigns an entity to a sparse set. More...
     
    template<typename It >
    void batch (It first, It last)
     Assigns one or more entities to a sparse set. More...
     
    virtual void destroy (const entity_type entt)
     Removes an entity from a sparse set. More...
     
    void swap (const size_type lhs, const size_type rhs) ENTT_NOEXCEPT
     Swaps the position of two entities in the internal packed array. More...
     
    virtual void respect (const sparse_set &other) ENTT_NOEXCEPT
     Sort entities according to their order in another sparse set. More...
     
    +virtual void reset ()
     Resets a sparse set.
     
    +

    Detailed Description

    +

    template<typename Entity>
    +class entt::sparse_set< Entity >

    + +

    Basic sparse set implementation.

    +

    Sparse set or packed array or whatever is the name users give it.
    + Two arrays: an external one and an internal one; a sparse one and a packed one; one used for direct access through contiguous memory, the other one used to get the data through an extra level of indirection.
    + This is largely used by the registry to offer users the fastest access ever to the components. Views and groups in general are almost entirely designed around sparse sets.

    +

    This type of data structure is widely documented in the literature and on the web. This is nothing more than a customized implementation suitable for the purpose of the framework.

    +
    Note
    There are no guarantees that entities are returned in the insertion order when iterate a sparse set. Do not make assumption on the order in any case.
    +
    +Internal data structures arrange elements to maximize performance. Because of that, there are no guarantees that elements have the expected order when iterate directly the internal packed array (see data and size member functions for that). Use begin and end instead.
    +
    Template Parameters
    + + +
    EntityA valid entity type (see entt_traits for more details).
    +
    +
    + +

    Definition at line 46 of file sparse_set.hpp.

    +

    Constructor & Destructor Documentation

    + +

    ◆ sparse_set()

    + +
    +
    +
    +template<typename Entity>
    + + + + + +
    + + + + + + + + +
    entt::sparse_set< Entity >::sparse_set (const sparse_set< Entity > & other)
    +     		+inline
    +
    + +

    Copy constructor.

    +
    Parameters
    + + +
    otherThe instance to copy from.
    +
    +
    + +

    Definition at line 187 of file sparse_set.hpp.

    + +
    +
    +

    Member Function Documentation

    + +

    ◆ batch()

    + +
    +
    +
    +template<typename Entity>
    +
    +template<typename It >
    + + + + + +
    + + + + + + + + + + + + + + + + + + +
    void entt::sparse_set< Entity >::batch (It first,
    It last 
    )
    +     		+inline
    +
    + +

    Assigns one or more entities to a sparse set.

    +
    Warning
    Attempting to assign an entity that already belongs to the sparse set results in undefined behavior.
    + An assertion will abort the execution at runtime in debug mode if the sparse set already contains the given entity.
    +
    Template Parameters
    + + +
    ItType of forward iterator.
    +
    +
    +
    Parameters
    + + + +
    firstAn iterator to the first element of the range of entities.
    lastAn iterator past the last element of the range of entities.
    +
    +
    + +

    Definition at line 422 of file sparse_set.hpp.

    + +
    +
    + +

    ◆ begin()

    + +
    +
    +
    +template<typename Entity>
    + + + + + +
    + + + + + + + +
    iterator_type entt::sparse_set< Entity >::begin () const
    +     		+inline
    +
    + +

    Returns an iterator to the beginning.

    +

    The returned iterator points to the first entity of the internal packed array. If the sparse set is empty, the returned iterator will be equal to end().

    +
    Note
    Input iterators stay true to the order imposed by a call to respect.
    +
    Returns
    An iterator to the first entity of the internal packed array.
    + +

    Definition at line 327 of file sparse_set.hpp.

    + +
    +
    + +

    ◆ capacity()

    + +
    +
    +
    +template<typename Entity>
    + + + + + +
    + + + + + + + +
    size_type entt::sparse_set< Entity >::capacity () const
    +     		+inline
    +
    + +

    Returns the number of elements that a sparse set has currently allocated space for.

    +
    Returns
    Capacity of the sparse set.
    + +

    Definition at line 240 of file sparse_set.hpp.

    + +
    +
    + +

    ◆ construct()

    + +
    +
    +
    +template<typename Entity>
    + + + + + +
    + + + + + + + + +
    void entt::sparse_set< Entity >::construct (const entity_type entt)
    +     		+inline
    +
    + +

    Assigns an entity to a sparse set.

    +
    Warning
    Attempting to assign an entity that already belongs to the sparse set results in undefined behavior.
    + An assertion will abort the execution at runtime in debug mode if the sparse set already contains the given entity.
    +
    Parameters
    + + +
    enttA valid entity identifier.
    +
    +
    + +

    Definition at line 399 of file sparse_set.hpp.

    + +
    +
    + +

    ◆ data()

    + +
    +
    +
    +template<typename Entity>
    + + + + + +
    + + + + + + + +
    const entity_type* entt::sparse_set< Entity >::data () const
    +     		+inline
    +
    + +

    Direct access to the internal packed array.

    +

    The returned pointer is such that range [data(), data() + size()] is always a valid range, even if the container is empty.

    +
    Note
    There are no guarantees on the order, even though respect has been previously invoked. Internal data structures arrange elements to maximize performance. Accessing them directly gives a performance boost but less guarantees. Use begin and end if you want to iterate the sparse set in the expected order.
    +
    Returns
    A pointer to the internal packed array.
    + +

    Definition at line 311 of file sparse_set.hpp.

    + +
    +
    + +

    ◆ destroy()

    + +
    +
    +
    +template<typename Entity>
    + + + + + +
    + + + + + + + + +
    virtual void entt::sparse_set< Entity >::destroy (const entity_type entt)
    +     		+inlinevirtual
    +
    + +

    Removes an entity from a sparse set.

    +
    Warning
    Attempting to remove an entity that doesn't belong to the sparse set results in undefined behavior.
    + An assertion will abort the execution at runtime in debug mode if the sparse set doesn't contain the given entity.
    +
    Parameters
    + + +
    enttA valid entity identifier.
    +
    +
    + +

    Reimplemented in entt::basic_storage< Entity, Type, typename >, entt::basic_storage< Entity, Type >, and entt::basic_storage< Entity, Component >.

    + +

    Definition at line 445 of file sparse_set.hpp.

    + +
    +
    + +

    ◆ empty()

    + +
    +
    +
    +template<typename Entity>
    + + + + + +
    + + + + + + + +
    bool entt::sparse_set< Entity >::empty () const
    +     		+inline
    +
    + +

    Checks whether a sparse set is empty.

    +
    Returns
    True if the sparse set is empty, false otherwise.
    + +

    Definition at line 292 of file sparse_set.hpp.

    + +
    +
    + +

    ◆ end()

    + +
    +
    +
    +template<typename Entity>
    + + + + + +
    + + + + + + + +
    iterator_type entt::sparse_set< Entity >::end () const
    +     		+inline
    +
    + +

    Returns an iterator to the end.

    +

    The returned iterator points to the element following the last entity in the internal packed array. Attempting to dereference the returned iterator results in undefined behavior.

    +
    Note
    Input iterators stay true to the order imposed by a call to respect.
    +
    Returns
    An iterator to the element following the last entity of the internal packed array.
    + +

    Definition at line 345 of file sparse_set.hpp.

    + +
    +
    + +

    ◆ extent()

    + +
    +
    +
    +template<typename Entity>
    + + + + + +
    + + + + + + + +
    size_type entt::sparse_set< Entity >::extent () const
    +     		+inline
    +
    + +

    Returns the extent of a sparse set.

    +

    The extent of a sparse set is also the size of the internal sparse array. There is no guarantee that the internal packed array has the same size. Usually the size of the internal sparse array is equal or greater than the one of the internal packed array.

    +
    Returns
    Extent of the sparse set.
    + +

    Definition at line 270 of file sparse_set.hpp.

    + +
    +
    + +

    ◆ find()

    + +
    +
    +
    +template<typename Entity>
    + + + + + +
    + + + + + + + + +
    iterator_type entt::sparse_set< Entity >::find (const entity_type entt) const
    +     		+inline
    +
    + +

    Finds an entity.

    +
    Parameters
    + + +
    enttA valid entity identifier.
    +
    +
    +
    Returns
    An iterator to the given entity if it's found, past the end iterator otherwise.
    + +

    Definition at line 355 of file sparse_set.hpp.

    + +
    +
    + +

    ◆ get()

    + +
    +
    +
    +template<typename Entity>
    + + + + + +
    + + + + + + + + +
    size_type entt::sparse_set< Entity >::get (const entity_type entt) const
    +     		+inline
    +
    + +

    Returns the position of an entity in a sparse set.

    +
    Warning
    Attempting to get the position of an entity that doesn't belong to the sparse set results in undefined behavior.
    + An assertion will abort the execution at runtime in debug mode if the sparse set doesn't contain the given entity.
    +
    Parameters
    + + +
    enttA valid entity identifier.
    +
    +
    +
    Returns
    The position of the entity in the sparse set.
    + +

    Definition at line 382 of file sparse_set.hpp.

    + +
    +
    + +

    ◆ has()

    + +
    +
    +
    +template<typename Entity>
    + + + + + +
    + + + + + + + + +
    bool entt::sparse_set< Entity >::has (const entity_type entt) const
    +     		+inline
    +
    + +

    Checks if a sparse set contains an entity.

    +
    Parameters
    + + +
    enttA valid entity identifier.
    +
    +
    +
    Returns
    True if the sparse set contains the entity, false otherwise.
    + +

    Definition at line 364 of file sparse_set.hpp.

    + +
    +
    + +

    ◆ operator=() [1/2]

    + +
    +
    +
    +template<typename Entity>
    + + + + + +
    + + + + + + + + +
    sparse_set& entt::sparse_set< Entity >::operator= (const sparse_set< Entity > & other)
    +     		+inline
    +
    + +

    Copy assignment operator.

    +
    Parameters
    + + +
    otherThe instance to copy from.
    +
    +
    +
    Returns
    This sparse set.
    + +

    Definition at line 211 of file sparse_set.hpp.

    + +
    +
    + +

    ◆ operator=() [2/2]

    + +
    +
    +
    +template<typename Entity>
    + + + + + +
    + + + + + + + + +
    sparse_set& entt::sparse_set< Entity >::operator= (sparse_set< Entity > && )
    +     		+default
    +
    + +

    Default move assignment operator.

    +
    Returns
    This sparse set.
    + +
    +
    + +

    ◆ reserve()

    + +
    +
    +
    +template<typename Entity>
    + + + + + +
    + + + + + + + + +
    virtual void entt::sparse_set< Entity >::reserve (const size_type cap)
    +     		+inlinevirtual
    +
    + +

    Increases the capacity of a sparse set.

    +

    If the new capacity is greater than the current capacity, new storage is allocated, otherwise the method does nothing.

    +
    Parameters
    + + +
    capDesired capacity.
    +
    +
    + +

    Reimplemented in entt::basic_storage< Entity, Type, typename >, entt::basic_storage< Entity, Type >, and entt::basic_storage< Entity, Component >.

    + +

    Definition at line 231 of file sparse_set.hpp.

    + +
    +
    + +

    ◆ respect()

    + +
    +
    +
    +template<typename Entity>
    + + + + + +
    + + + + + + + + +
    virtual void entt::sparse_set< Entity >::respect (const sparse_set< Entity > & other)
    +     		+inlinevirtual
    +
    + +

    Sort entities according to their order in another sparse set.

    +

    Entities that are part of both the sparse sets are ordered internally according to the order they have in other. All the other entities goes to the end of the list and there are no guarantess on their order.
    + In other terms, this function can be used to impose the same order on two sets by using one of them as a master and the other one as a slave.

    +

    Iterating the sparse set with a couple of iterators returns elements in the expected order after a call to respect. See begin and end for more details.

    +
    Note
    Attempting to iterate elements using the raw pointer returned by data gives no guarantees on the order, even though respect has been invoked.
    +
    Parameters
    + + +
    otherThe sparse sets that imposes the order of the entities.
    +
    +
    + +

    Reimplemented in entt::basic_storage< Entity, Type, typename >, entt::basic_storage< Entity, Type >, and entt::basic_storage< Entity, Component >.

    + +

    Definition at line 499 of file sparse_set.hpp.

    + +
    +
    + +

    ◆ size()

    + +
    +
    +
    +template<typename Entity>
    + + + + + +
    + + + + + + + +
    size_type entt::sparse_set< Entity >::size () const
    +     		+inline
    +
    + +

    Returns the number of elements in a sparse set.

    +

    The number of elements is also the size of the internal packed array. There is no guarantee that the internal sparse array has the same size. Usually the size of the internal sparse array is equal or greater than the one of the internal packed array.

    +
    Returns
    Number of elements.
    + +

    Definition at line 284 of file sparse_set.hpp.

    + +
    +
    + +

    ◆ swap()

    + +
    +
    +
    +template<typename Entity>
    + + + + + +
    + + + + + + + + + + + + + + + + + + +
    void entt::sparse_set< Entity >::swap (const size_type lhs,
    const size_type rhs 
    )
    +     		+inline
    +
    + +

    Swaps the position of two entities in the internal packed array.

    +

    For what it's worth, this function affects both the internal sparse array and the internal packed array. Users should not care of that anyway.

    +
    Warning
    Attempting to swap entities that don't belong to the sparse set results in undefined behavior.
    + An assertion will abort the execution at runtime in debug mode if the sparse set doesn't contain the given entities.
    +
    Parameters
    + + + +
    lhsA valid position within the sparse set.
    rhsA valid position within the sparse set.
    +
    +
    + +

    Definition at line 471 of file sparse_set.hpp.

    + +
    +
    +
    The documentation for this class was generated from the following file: +
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/classentt_1_1sparse__set__inherit__graph.map b/classentt_1_1sparse__set__inherit__graph.map new file mode 100644 index 000000000..25506fc8c --- /dev/null +++ b/classentt_1_1sparse__set__inherit__graph.map @@ -0,0 +1,8 @@ + + + + + + + + diff --git a/classentt_1_1sparse__set__inherit__graph.md5 b/classentt_1_1sparse__set__inherit__graph.md5 new file mode 100644 index 000000000..71305b12f --- /dev/null +++ b/classentt_1_1sparse__set__inherit__graph.md5 @@ -0,0 +1 @@ +74e463e95edabb11fc5dbc46ee045512 \ No newline at end of file diff --git a/classentt_1_1sparse__set__inherit__graph.png b/classentt_1_1sparse__set__inherit__graph.png new file mode 100644 index 000000000..633210aae Binary files /dev/null and b/classentt_1_1sparse__set__inherit__graph.png differ diff --git a/classes.html b/classes.html index 4f494d07a..9296c4583 100644 --- a/classes.html +++ b/classes.html @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    - - - - - + + + + + + + + - - - - - - - - - - - + + + + + + + + + + + + +
      a  
    -
      e  
    -    		InsertionSort (entt)   RawView (entt)   SnapshotLoader (entt)   
      m  
    -    		Registry (entt)   SparseSet (entt)   
    Actor (entt)   Emitter (entt)   ResourceCache (entt)   SparseSet< Entity > (entt)   
    Attachee (entt)   entt_traits (entt)   Monostate (entt)   ResourceHandle (entt)   SparseSet< Entity, Type > (entt)   
    Attachee< Entity > (entt)   entt_traits< std::uint16_t > (entt)   
      o  
    -    		ResourceLoader (entt)   StdSort (entt)   
    Attachee< Entity, Type > (entt)   entt_traits< std::uint32_t > (entt)   RuntimeView (entt)   
      t  
    +
      c  
    +
      g  
    +    		meta_factory (entt)   service_locator (entt)   
    meta_func (entt)   sigh (entt)   
    as_group (entt)   connect_arg_t (entt)   get_t (entt)   meta_handle (entt)   sigh< Ret(Args...), Collector > (entt)   
    as_view (entt)   emitter::connection (entt)   
      h  
    +    		meta_prop (entt)   sink (entt)   
      b  
    +
      d  
    +    		meta_type (entt)   sink< Ret(Args...)> (entt)   
    hashed_string (entt)   monostate (entt)   sparse_set (entt)   
    basic_actor (entt)   delegate (entt)   
      i  
    +
      n  
    +    		std_sort (entt)   
    basic_continuous_loader (entt)   delegate< Ret(Args...)> (entt)   storage (entt)   
    basic_group (entt)   dispatcher (entt)   identifier (entt)   named_type_traits (entt)   
      t  
      c  
    -    		entt_traits< std::uint64_t > (entt)   OneShotBubbleSort (entt)   
      s  
    -
      f  
    -
      p  
    -    		tag_t (entt)   
    Emitter::Connection (entt)   Scheduler (entt)   
      v  
    -
    ContinuousLoader (entt)   Family (entt)   persistent_t (entt)   ServiceLocator (entt)   
      d  
    -
      h  
    -    		PersistentView (entt)   SigH (entt)   View (entt)   
    Process (entt)   SigH< Ret(Args...), Collector > (entt)   View< Entity, Component > (entt)   
    Delegate (entt)   HashedString (entt)   ProcessAdaptor (entt)   Sink (entt)   
    Delegate< Ret(Args...)> (entt)   
      i  
    -    		Prototype (entt)   Sink< Ret(Args...)> (entt)   
    Dispatcher (entt)   
      r  
    -    		Snapshot (entt)   
    Identifier (entt)   
    raw_t (entt)   
    basic_group< Entity, get_t< Get... > > (entt)   
      e  
    +    		insertion_sort (entt)   named_type_traits< const Type > (entt)   
    basic_group< Entity, get_t< Get... >, Owned... > (entt)   is_named_type (entt)   
      p  
    +    		type_list (entt)   
    basic_prototype (entt)   emitter (entt)   is_named_type< Type, std::void_t< named_type_traits_t< std::decay_t< Type > > > > (entt)   type_list_cat (entt)   
    basic_registry (entt)   entt_traits (entt)   
      m  
    +    		process (entt)   type_list_cat< type_list< Type... > > (entt)   
    basic_runtime_view (entt)   entt_traits< std::uint16_t > (entt)   process_adaptor (entt)   type_list_cat< type_list< Type... >, type_list< Other... >, List... > (entt)   
    basic_snapshot (entt)   entt_traits< std::uint32_t > (entt)   meta_any (entt)   
      r  
    +    		type_list_unique (entt)   
    basic_snapshot_loader (entt)   entt_traits< std::uint64_t > (entt)   meta_base (entt)   type_list_unique< type_list< Type, Other... > > (entt)   
    basic_storage (entt)   exclude_t (entt)   meta_conv (entt)   resource_cache (entt)   type_list_unique< type_list<> > (entt)   
    basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > > (entt)   
      f  
    +    		meta_ctor (entt)   resource_handle (entt)   
    basic_view (entt)   meta_data (entt)   resource_loader (entt)   
    basic_view< Entity, Component > (entt)   family (entt)   meta_dtor (entt)   
      s  
    +
    scheduler (entt)   
    -
    a | c | d | e | f | h | i | m | o | p | r | s | t | v
    +
    a | b | c | d | e | f | g | h | i | m | n | p | r | s | t
    diff --git a/config_8h_source.html b/config_8h_source.html index b9835d9b7..db5c36c1f 100644 --- a/config_8h_source.html +++ b/config_8h_source.html @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.2 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    + + + + + +
    +
    EnTT +  3.0.0 +
    +
    + + + + + + + + + +
    +
    + + +
    + +
    + + + +
    +
    +
    fwd.hpp
    +
    +
    +
    1 #ifndef ENTT_ENTITY_FWD_HPP
    2 #define ENTT_ENTITY_FWD_HPP
    3 
    4 
    5 #include <cstdint>
    6 #include "../config/config.h"
    7 
    8 
    9 namespace entt {
    10 
    12 template <typename>
    13 class basic_registry;
    14 
    16 template<typename, typename...>
    17 class basic_view;
    18 
    20 template<typename>
    21 class basic_runtime_view;
    22 
    24 template<typename...>
    25 class basic_group;
    26 
    28 template <typename>
    29 struct basic_actor;
    30 
    32 template<typename>
    33 class basic_prototype;
    34 
    36 template<typename>
    37 class basic_snapshot;
    38 
    40 template<typename>
    41 class basic_snapshot_loader;
    42 
    44 template<typename>
    45 class basic_continuous_loader;
    46 
    48 using entity = std::uint32_t;
    49 
    51 using registry = basic_registry<entity>;
    52 
    54 using actor = basic_actor<entity>;
    55 
    57 using prototype = basic_prototype<entity>;
    58 
    60 using snapshot = basic_snapshot<entity>;
    61 
    63 using snapshot_loader = basic_snapshot_loader<entity>;
    64 
    66 using continuous_loader = basic_continuous_loader<entity>;
    67 
    72 template<typename... Types>
    73 using view = basic_view<entity, Types...>;
    74 
    76 using runtime_view = basic_runtime_view<entity>;
    77 
    82 template<typename... Types>
    83 using group = basic_group<entity, Types...>;
    84 
    85 
    86 }
    87 
    88 
    89 #endif // ENTT_ENTITY_FWD_HPP
    entt::basic_group
    Group.
    Definition: fwd.hpp:25
    +
    entt
    EnTT default namespace.
    Definition: algorithm.hpp:10
    +
    entt::basic_continuous_loader
    Utility class for continuous loading.
    Definition: fwd.hpp:45
    +
    entt::basic_snapshot_loader
    Utility class to restore a snapshot as a whole.
    Definition: fwd.hpp:41
    +
    entt::basic_registry
    Fast and reliable entity-component system.
    Definition: fwd.hpp:13
    +
    entt::basic_view
    Multi component view.
    Definition: fwd.hpp:17
    +
    entt::basic_prototype
    Prototype container for concepts.
    Definition: fwd.hpp:33
    +
    entt::entity
    std::uint32_t entity
    Alias declaration for the most common use case.
    Definition: fwd.hpp:48
    +
    entt::basic_actor
    Dedicated to those who aren&#39;t confident with entity-component systems.
    Definition: actor.hpp:26
    +
    entt::basic_snapshot
    Utility class to create snapshots from a registry.
    Definition: fwd.hpp:37
    +
    entt::basic_runtime_view
    Runtime view.
    Definition: fwd.hpp:21
    +
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/entity_8hpp_source.html b/entity_8hpp_source.html index 930b878aa..44f3f0f8a 100644 --- a/entity_8hpp_source.html +++ b/entity_8hpp_source.html @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - -     -
    -
    -
    -
    entt_traits.hpp
    -
    -
    -
    1 #ifndef ENTT_ENTITY_ENTT_TRAITS_HPP
    2 #define ENTT_ENTITY_ENTT_TRAITS_HPP
    3 
    4 
    5 #include <cstdint>
    6 
    7 
    8 namespace entt {
    9 
    10 
    17 template<typename>
    18 struct entt_traits;
    19 
    20 
    29 template<>
    30 struct entt_traits<std::uint16_t> {
    32  using entity_type = std::uint16_t;
    34  using version_type = std::uint8_t;
    36  using difference_type = std::int32_t;
    37 
    39  static constexpr std::uint16_t entity_mask = 0xFFF;
    41  static constexpr std::uint16_t version_mask = 0xF;
    43  static constexpr auto entity_shift = 12;
    44 };
    45 
    46 
    55 template<>
    56 struct entt_traits<std::uint32_t> {
    58  using entity_type = std::uint32_t;
    60  using version_type = std::uint16_t;
    62  using difference_type = std::int64_t;
    63 
    65  static constexpr std::uint32_t entity_mask = 0xFFFFF;
    67  static constexpr std::uint32_t version_mask = 0xFFF;
    69  static constexpr auto entity_shift = 20;
    70 };
    71 
    72 
    81 template<>
    82 struct entt_traits<std::uint64_t> {
    84  using entity_type = std::uint64_t;
    86  using version_type = std::uint32_t;
    88  using difference_type = std::int64_t;
    89 
    91  static constexpr std::uint64_t entity_mask = 0xFFFFFFFF;
    93  static constexpr std::uint64_t version_mask = 0xFFFFFFFF;
    95  static constexpr auto entity_shift = 32;
    96 };
    97 
    98 
    99 }
    100 
    101 
    102 #endif // ENTT_ENTITY_ENTT_TRAITS_HPP
    entt::entt_traits< std::uint64_t >::difference_type
    std::int64_t difference_type
    Difference type.
    Definition: entt_traits.hpp:88
    -
    entt::entt_traits< std::uint32_t >::entity_type
    std::uint32_t entity_type
    Underlying entity type.
    Definition: entt_traits.hpp:58
    -
    entt::entt_traits< std::uint64_t >::entity_type
    std::uint64_t entity_type
    Underlying entity type.
    Definition: entt_traits.hpp:84
    -
    entt::entt_traits< std::uint32_t >::difference_type
    std::int64_t difference_type
    Difference type.
    Definition: entt_traits.hpp:62
    -
    entt
    EnTT default namespace.
    Definition: algorithm.hpp:10
    -
    entt::entt_traits< std::uint16_t >::difference_type
    std::int32_t difference_type
    Difference type.
    Definition: entt_traits.hpp:36
    -
    entt::entt_traits< std::uint16_t >::entity_type
    std::uint16_t entity_type
    Underlying entity type.
    Definition: entt_traits.hpp:32
    -
    entt::entt_traits< std::uint64_t >::version_type
    std::uint32_t version_type
    Underlying version type.
    Definition: entt_traits.hpp:86
    -
    entt::entt_traits< std::uint16_t >::version_type
    std::uint8_t version_type
    Underlying version type.
    Definition: entt_traits.hpp:34
    -
    entt::entt_traits< std::uint32_t >::version_type
    std::uint16_t version_type
    Underlying version type.
    Definition: entt_traits.hpp:60
    -
    entt::entt_traits
    Entity traits.
    Definition: entt_traits.hpp:18
    -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/factory_8hpp_source.html b/factory_8hpp_source.html index a172863cf..b147419f0 100644 --- a/factory_8hpp_source.html +++ b/factory_8hpp_source.html @@ -22,7 +22,7 @@
    EnTT -  2.7.2 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    + + + + + +
    +
    EnTT +  3.0.0 +
    +
    + + + + + + + + + + +
    +
    + + +
    + +
    + +
    +
    +
    docs/md/faq.md
    +
    +
    +
    1 # Frequently Asked Questions
    2 
    3 <!--
    4 @cond TURN_OFF_DOXYGEN
    5 -->
    6 # Table of Contents
    7 
    8 * [Introduction](#introduction)
    9 * [FAQ](#faq)
    10  * [Why is my debug build on Windows so slow?](#why-is-my-debug-build-on-windows-so-slow)
    11 <!--
    12 @endcond TURN_OFF_DOXYGEN
    13 -->
    14 
    15 # Introduction
    16 
    17 This is a constantly updated section where I'll try to put the answers to the
    18 most frequently asked questions.<br/>
    19 If you don't find your answer here, there are two cases: nobody has done it yet
    20 or this section needs updating. In both cases, try to
    21 [open a new issue](https://github.com/skypjack/entt/issues/new) or enter the
    22 [gitter channel](https://gitter.im/skypjack/entt) and ask your question.
    23 Probably someone already has an answer for you and we can then integrate this
    24 part of the documentation.
    25 
    26 # FAQ
    27 
    28 ## Why is my debug build on Windows so slow?
    29 
    30 `EnTT` is an experimental project that I also use to keep me up-to-date with the
    31 latest revision of the language and the standard library. For this reason, it's
    32 likely that some classes you're working with are using standard containers under
    33 the hood.<br/>
    34 Unfortunately, it's known that the standard containers aren't particularly
    35 performing in debugging (the reasons for this go beyond this document) and are
    36 even less so on Windows apparently. Fortunately this can also be mitigated a
    37 lot, achieving good results in many cases.
    38 
    39 First of all, there are two things to do in a Windows project:
    40 
    41 * Disable the [`/JMC`](https://docs.microsoft.com/cpp/build/reference/jmc)
    42  option (_Just My Code_ debugging), available starting in Visual Studio 2017
    43  version 15.8.
    44 
    45 * Set the [`_ITERATOR_DEBUG_LEVEL`](https://docs.microsoft.com/cpp/standard-library/iterator-debug-level)
    46  macro to 0. This will disable checked iterators and iterator debugging.
    47 
    48 Moreover, the macro `ENTT_DISABLE_ASSERT` should be defined to disable internal
    49 checks made by `EnTT` in debug. These are asserts introduced to help the users,
    50 but require to access to the underlying containers and therefore risk ruining
    51 the performance in some cases.
    52 
    53 With these changes, debug performance should increase enough for most cases. If
    54 you want something more, you can can also switch to an optimization level `O0`
    55 or preferably `O1`.
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/files.html b/files.html index 786fc6647..b4b5732bd 100644 --- a/files.html +++ b/files.html @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
     ▼ entt
     ▼ config
     config.h
     ▼ core
     algorithm.hpp
     family.hpp
     hashed_string.hpp
     ident.hpp
     monostate.hpp
     ▼ entity
     actor.hpp
     attachee.hpp
     entity.hpp
     entt_traits.hpp
     helper.hpp
     prototype.hpp
     registry.hpp
     snapshot.hpp
     sparse_set.hpp
     utility.hpp
     view.hpp
     version.h
     ▼ core
     algorithm.hpp
     family.hpp
     hashed_string.hpp
     ident.hpp
     monostate.hpp
     type_traits.hpp
     utility.hpp
     ▼ entity
     actor.hpp
     entity.hpp
     fwd.hpp
     group.hpp
     helper.hpp
     prototype.hpp
     registry.hpp
     runtime_view.hpp
     snapshot.hpp
     sparse_set.hpp
     storage.hpp
     view.hpp
     ▼ locator
     locator.hpp
     ▼ process
     process.hpp
     scheduler.hpp
     ▼ resource
     cache.hpp
     handle.hpp
     loader.hpp
     ▼ signal
     delegate.hpp
     dispatcher.hpp
     emitter.hpp
     sigh.hpp
     entt.hpp
     ▼ meta
     factory.hpp
     meta.hpp
     ▼ process
     process.hpp
     scheduler.hpp
     ▼ resource
     cache.hpp
     fwd.hpp
     handle.hpp
     loader.hpp
     ▼ signal
     delegate.hpp
     dispatcher.hpp
     emitter.hpp
     fwd.hpp
     sigh.hpp
     entt.hpp
     fwd.hpp
    diff --git a/functions.html b/functions.html index e016ee8b5..7243fa7e9 100644 --- a/functions.html +++ b/functions.html @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    + + + + + +
    +
    EnTT +  3.0.0 +
    +
    + + + + + + + + + + +
    +
    + + +
    + +
    + +
    +  + +

    - i -

    +
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/functions_func_k.html b/functions_func_k.html new file mode 100644 index 000000000..31a62d2f1 --- /dev/null +++ b/functions_func_k.html @@ -0,0 +1,77 @@ + + + + + + + +EnTT: Class Members - Functions + + + + + + + + + +
    +
    + + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + +
    + +
    +
    + + +
    + +
    + +
    +  + +

    - k -

    +
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/functions_func_l.html b/functions_func_l.html index 019161380..0ffb65ced 100644 --- a/functions_func_l.html +++ b/functions_func_l.html @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    + + + + + +
    +
    EnTT +  3.0.0 +
    +
    + + + + + + + + + + +
    +
    + + +
    + +
    + +
    +  + +

    - n -

    +
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/functions_func_o.html b/functions_func_o.html index 87bff096f..bc944818f 100644 --- a/functions_func_o.html +++ b/functions_func_o.html @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + +
    + +
    +
    + + +
    + +
    + +
    +
    Here is a list of all documented class members with links to the class documentation for each member:
    + +

    - k -

    +
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/functions_l.html b/functions_l.html index e0b24510f..a7ebeb658 100644 --- a/functions_l.html +++ b/functions_l.html @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + + + +
    +
    + + +
    + +
    + +
    +
    Here is a list of all documented class members with links to the class documentation for each member:
    + +

    - n -

    +
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/functions_o.html b/functions_o.html index 8359603cc..e4853530d 100644 --- a/functions_o.html +++ b/functions_o.html @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    + + + + + +
    +
    EnTT +  3.0.0 +
    +
    + + + + + + + + + +
    +
    + + +
    + +
    + + + +
    +
    +
    fwd.hpp
    +
    +
    +
    1 #include "entity/fwd.hpp"
    2 #include "resource/fwd.hpp"
    3 #include "signal/fwd.hpp"
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/graph_legend.html b/graph_legend.html index 170dc9b93..b6771d54f 100644 --- a/graph_legend.html +++ b/graph_legend.html @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +
    group.hpp
    +
    +
    +
    1 #ifndef ENTT_ENTITY_GROUP_HPP
    2 #define ENTT_ENTITY_GROUP_HPP
    3 
    4 
    5 #include <tuple>
    6 #include <utility>
    7 #include <type_traits>
    8 #include "../config/config.h"
    9 #include "../core/type_traits.hpp"
    10 #include "sparse_set.hpp"
    11 #include "storage.hpp"
    12 #include "fwd.hpp"
    13 
    14 
    15 namespace entt {
    16 
    17 
    22 template<typename... Type>
    23 struct get_t: type_list<Type...> {};
    24 
    25 
    30 template<typename... Type>
    31 constexpr get_t<Type...> get{};
    32 
    33 
    40 template<typename...>
    41 class basic_group;
    42 
    43 
    81 template<typename Entity, typename... Get>
    82 class basic_group<Entity, get_t<Get...>> {
    83  static_assert(sizeof...(Get) > 0);
    84 
    86  friend class basic_registry<Entity>;
    87 
    88  template<typename Component>
    89  using pool_type = std::conditional_t<std::is_const_v<Component>, const storage<Entity, std::remove_const_t<Component>>, storage<Entity, Component>>;
    90 
    91  // we could use pool_type<Get> *..., but vs complains about it and refuses to compile for unknown reasons (likely a bug)
    92  basic_group(sparse_set<Entity> *ref, storage<Entity, std::remove_const_t<Get>> *... get) ENTT_NOEXCEPT
    93  : handler{ref},
    94  pools{get...}
    95  {}
    96 
    97 public:
    99  using entity_type = typename sparse_set<Entity>::entity_type;
    101  using size_type = typename sparse_set<Entity>::size_type;
    103  using iterator_type = typename sparse_set<Entity>::iterator_type;
    104 
    110  template<typename Component>
    111  size_type size() const ENTT_NOEXCEPT {
    112  return std::get<pool_type<Component> *>(pools)->size();
    113  }
    114 
    119  size_type size() const ENTT_NOEXCEPT {
    120  return handler->size();
    121  }
    122 
    128  size_type capacity() const ENTT_NOEXCEPT {
    129  return handler->capacity();
    130  }
    131 
    133  void shrink_to_fit() {
    134  handler->shrink_to_fit();
    135  }
    136 
    143  template<typename Component>
    144  bool empty() const ENTT_NOEXCEPT {
    145  return std::get<pool_type<Component> *>(pools)->empty();
    146  }
    147 
    152  bool empty() const ENTT_NOEXCEPT {
    153  return handler->empty();
    154  }
    155 
    170  template<typename Component>
    171  Component * raw() const ENTT_NOEXCEPT {
    172  return std::get<pool_type<Component> *>(pools)->raw();
    173  }
    174 
    189  template<typename Component>
    190  const entity_type * data() const ENTT_NOEXCEPT {
    191  return std::get<pool_type<Component> *>(pools)->data();
    192  }
    193 
    206  const entity_type * data() const ENTT_NOEXCEPT {
    207  return handler->data();
    208  }
    209 
    224  iterator_type begin() const ENTT_NOEXCEPT {
    225  return handler->begin();
    226  }
    227 
    243  iterator_type end() const ENTT_NOEXCEPT {
    244  return handler->end();
    245  }
    246 
    253  iterator_type find(const entity_type entt) const ENTT_NOEXCEPT {
    254  const auto it = handler->find(entt);
    255  return it != end() && *it == entt ? it : end();
    256  }
    257 
    263  entity_type operator[](const size_type pos) const ENTT_NOEXCEPT {
    264  return begin()[pos];
    265  }
    266 
    272  bool contains(const entity_type entt) const ENTT_NOEXCEPT {
    273  return find(entt) != end();
    274  }
    275 
    293  template<typename... Component>
    294  decltype(auto) get([[maybe_unused]] const entity_type entt) const ENTT_NOEXCEPT {
    295  ENTT_ASSERT(contains(entt));
    296 
    297  if constexpr(sizeof...(Component) == 1) {
    298  return (std::get<pool_type<Component> *>(pools)->get(entt), ...);
    299  } else {
    300  return std::tuple<decltype(get<Component>(entt))...>{get<Component>(entt)...};
    301  }
    302  }
    303 
    327  template<typename Func>
    328  inline void each(Func func) const {
    329  for(const auto entt: *handler) {
    330  if constexpr(std::is_invocable_v<Func, decltype(get<Get>({}))...>) {
    331  func(std::get<pool_type<Get> *>(pools)->get(entt)...);
    332  } else {
    333  func(entt, std::get<pool_type<Get> *>(pools)->get(entt)...);
    334  }
    335  };
    336  }
    337 
    354  template<typename Component>
    355  void sort() const {
    356  handler->respect(*std::get<pool_type<Component> *>(pools));
    357  }
    358 
    359 private:
    360  sparse_set<entity_type> *handler;
    361  const std::tuple<pool_type<Get> *...> pools;
    362 };
    363 
    364 
    410 template<typename Entity, typename... Get, typename... Owned>
    411 class basic_group<Entity, get_t<Get...>, Owned...> {
    412  static_assert(sizeof...(Get) + sizeof...(Owned) > 0);
    413 
    415  friend class basic_registry<Entity>;
    416 
    417  template<typename Component>
    418  using pool_type = std::conditional_t<std::is_const_v<Component>, const storage<Entity, std::remove_const_t<Component>>, storage<Entity, Component>>;
    419 
    420  template<typename Component>
    421  using component_iterator_type = decltype(std::declval<pool_type<Component>>().begin());
    422 
    423  template<typename Component>
    424  decltype(auto) from_index(const typename sparse_set<Entity>::size_type index) {
    425  static_assert(!std::is_empty_v<Component>);
    426 
    427  if constexpr(std::disjunction_v<std::is_same<Component, Owned>...>) {
    428  return std::as_const(*std::get<pool_type<Component> *>(pools)).raw()[index];
    429  } else {
    430  return std::as_const(*std::get<pool_type<Component> *>(pools)).get(data()[index]);
    431  }
    432  }
    433 
    434  template<typename Component>
    435  inline auto swap(int, pool_type<Component> *cpool, const std::size_t lhs, const std::size_t rhs)
    436  -> decltype(cpool->raw(), void()) {
    437  std::swap(cpool->raw()[lhs], cpool->raw()[rhs]);
    438  cpool->swap(lhs, rhs);
    439  }
    440 
    441  template<typename Component>
    442  inline void swap(char, pool_type<Component> *cpool, const std::size_t lhs, const std::size_t rhs) {
    443  cpool->swap(lhs, rhs);
    444  }
    445 
    446  // we could use pool_type<Type> *..., but vs complains about it and refuses to compile for unknown reasons (likely a bug)
    447  basic_group(const typename basic_registry<Entity>::size_type *sz, storage<Entity, std::remove_const_t<Owned>> *... owned, storage<Entity, std::remove_const_t<Get>> *... get) ENTT_NOEXCEPT
    448  : length{sz},
    449  pools{owned..., get...}
    450  {}
    451 
    452 public:
    454  using entity_type = typename sparse_set<Entity>::entity_type;
    456  using size_type = typename sparse_set<Entity>::size_type;
    458  using iterator_type = typename sparse_set<Entity>::iterator_type;
    459 
    465  template<typename Component>
    466  size_type size() const ENTT_NOEXCEPT {
    467  return std::get<pool_type<Component> *>(pools)->size();
    468  }
    469 
    474  size_type size() const ENTT_NOEXCEPT {
    475  return *length;
    476  }
    477 
    484  template<typename Component>
    485  bool empty() const ENTT_NOEXCEPT {
    486  return std::get<pool_type<Component> *>(pools)->empty();
    487  }
    488 
    493  bool empty() const ENTT_NOEXCEPT {
    494  return !*length;
    495  }
    496 
    514  template<typename Component>
    515  Component * raw() const ENTT_NOEXCEPT {
    516  return std::get<pool_type<Component> *>(pools)->raw();
    517  }
    518 
    536  template<typename Component>
    537  const entity_type * data() const ENTT_NOEXCEPT {
    538  return std::get<pool_type<Component> *>(pools)->data();
    539  }
    540 
    553  const entity_type * data() const ENTT_NOEXCEPT {
    554  return std::get<0>(pools)->data();
    555  }
    556 
    571  iterator_type begin() const ENTT_NOEXCEPT {
    572  return std::get<0>(pools)->sparse_set<entity_type>::end() - *length;
    573  }
    574 
    590  iterator_type end() const ENTT_NOEXCEPT {
    591  return std::get<0>(pools)->sparse_set<entity_type>::end();
    592  }
    593 
    600  iterator_type find(const entity_type entt) const ENTT_NOEXCEPT {
    601  const auto it = std::get<0>(pools)->find(entt);
    602  return it != end() && it >= begin() && *it == entt ? it : end();
    603  }
    604 
    610  entity_type operator[](const size_type pos) const ENTT_NOEXCEPT {
    611  return begin()[pos];
    612  }
    613 
    619  bool contains(const entity_type entt) const ENTT_NOEXCEPT {
    620  return find(entt) != end();
    621  }
    622 
    640  template<typename... Component>
    641  decltype(auto) get([[maybe_unused]] const entity_type entt) const ENTT_NOEXCEPT {
    642  ENTT_ASSERT(contains(entt));
    643 
    644  if constexpr(sizeof...(Component) == 1) {
    645  return (std::get<pool_type<Component> *>(pools)->get(entt), ...);
    646  } else {
    647  return std::tuple<decltype(get<Component>(entt))...>{get<Component>(entt)...};
    648  }
    649  }
    650 
    674  template<typename Func>
    675  inline void each(Func func) const {
    676  auto raw = std::make_tuple((std::get<pool_type<Owned> *>(pools)->end() - *length)...);
    677  [[maybe_unused]] auto data = std::get<0>(pools)->sparse_set<entity_type>::end() - *length;
    678 
    679  for(auto next = *length; next; --next) {
    680  if constexpr(std::is_invocable_v<Func, decltype(get<Owned>({}))..., decltype(get<Get>({}))...>) {
    681  if constexpr(sizeof...(Get) == 0) {
    682  func(*(std::get<component_iterator_type<Owned>>(raw)++)...);
    683  } else {
    684  const auto entt = *(data++);
    685  func(*(std::get<component_iterator_type<Owned>>(raw)++)..., std::get<pool_type<Get> *>(pools)->get(entt)...);
    686  }
    687  } else {
    688  const auto entt = *(data++);
    689  func(entt, *(std::get<component_iterator_type<Owned>>(raw)++)..., std::get<pool_type<Get> *>(pools)->get(entt)...);
    690  }
    691  }
    692  }
    693 
    739  template<typename... Component, typename Compare, typename Sort = std_sort, typename... Args>
    740  void sort(Compare compare, Sort algo = Sort{}, Args &&... args) {
    741  std::vector<size_type> copy(*length);
    742  std::iota(copy.begin(), copy.end(), 0);
    743 
    744  if constexpr(sizeof...(Component) == 0) {
    745  algo(copy.rbegin(), copy.rend(), [compare = std::move(compare), data = data()](const auto lhs, const auto rhs) {
    746  return compare(data[lhs], data[rhs]);
    747  }, std::forward<Args>(args)...);
    748  } else {
    749  algo(copy.rbegin(), copy.rend(), [compare = std::move(compare), this](const auto lhs, const auto rhs) {
    750  // useless this-> used to suppress a warning with clang
    751  return compare(this->from_index<Component>(lhs)..., this->from_index<Component>(rhs)...);
    752  }, std::forward<Args>(args)...);
    753  }
    754 
    755  for(size_type pos = 0, last = copy.size(); pos < last; ++pos) {
    756  auto curr = pos;
    757  auto next = copy[curr];
    758 
    759  while(curr != next) {
    760  const auto lhs = copy[curr];
    761  const auto rhs = copy[next];
    762  (swap<Owned>(0, std::get<pool_type<Owned> *>(pools), lhs, rhs), ...);
    763  copy[curr] = curr;
    764  curr = next;
    765  next = copy[curr];
    766  }
    767  }
    768  }
    769 
    770 private:
    771  const typename basic_registry<Entity>::size_type *length;
    772  const std::tuple<pool_type<Owned> *..., pool_type<Get> *...> pools;
    773 };
    774 
    775 
    776 }
    777 
    778 
    779 #endif // ENTT_ENTITY_GROUP_HPP
    entt::basic_group< Entity, get_t< Get... >, Owned... >::operator[]
    entity_type operator[](const size_type pos) const ENTT_NOEXCEPT
    Returns the identifier that occupies the given position.
    Definition: group.hpp:610
    +
    entt::basic_group< Entity, get_t< Get... > >::size
    size_type size() const ENTT_NOEXCEPT
    Returns the number of entities that have the given components.
    Definition: group.hpp:119
    +
    entt::sparse_set
    Basic sparse set implementation.
    Definition: sparse_set.hpp:46
    +
    entt::basic_group< Entity, get_t< Get... >, Owned... >::size
    size_type size() const ENTT_NOEXCEPT
    Returns the number of entities that have the given components.
    Definition: group.hpp:474
    +
    entt::basic_group< Entity, get_t< Get... > >::find
    iterator_type find(const entity_type entt) const ENTT_NOEXCEPT
    Finds an entity.
    Definition: group.hpp:253
    +
    entt::basic_group< Entity, get_t< Get... >, Owned... >::raw
    Component * raw() const ENTT_NOEXCEPT
    Direct access to the list of components of a given pool.
    Definition: group.hpp:515
    +
    entt::basic_registry::size_type
    typename sparse_set< Entity >::size_type size_type
    Unsigned integer type.
    Definition: registry.hpp:320
    +
    entt::basic_group< Entity, get_t< Get... >, Owned... >::contains
    bool contains(const entity_type entt) const ENTT_NOEXCEPT
    Checks if a group contains an entity.
    Definition: group.hpp:619
    +
    entt::basic_group
    Group.
    Definition: fwd.hpp:25
    +
    entt::basic_group< Entity, get_t< Get... > >::empty
    bool empty() const ENTT_NOEXCEPT
    Checks whether the pool of a given component is empty.
    Definition: group.hpp:144
    +
    entt
    EnTT default namespace.
    Definition: algorithm.hpp:10
    +
    entt::basic_group< Entity, get_t< Get... > >::operator[]
    entity_type operator[](const size_type pos) const ENTT_NOEXCEPT
    Returns the identifier that occupies the given position.
    Definition: group.hpp:263
    +
    entt::sparse_set::size_type
    std::size_t size_type
    Unsigned integer type.
    Definition: sparse_set.hpp:176
    +
    entt::basic_group< Entity, get_t< Get... >, Owned... >::data
    const entity_type * data() const ENTT_NOEXCEPT
    Direct access to the list of entities.
    Definition: group.hpp:553
    +
    entt::basic_group< Entity, get_t< Get... >, Owned... >::iterator_type
    typename sparse_set< Entity >::iterator_type iterator_type
    Input iterator type.
    Definition: group.hpp:458
    +
    entt::basic_group< Entity, get_t< Get... > >::sort
    void sort() const
    Sort the shared pool of entities according to the given component.
    Definition: group.hpp:355
    +
    entt::basic_group< Entity, get_t< Get... > >::size_type
    typename sparse_set< Entity >::size_type size_type
    Unsigned integer type.
    Definition: group.hpp:101
    +
    entt::basic_group< Entity, get_t< Get... > >::data
    const entity_type * data() const ENTT_NOEXCEPT
    Direct access to the list of entities.
    Definition: group.hpp:206
    +
    entt::basic_group< Entity, get_t< Get... > >::end
    iterator_type end() const ENTT_NOEXCEPT
    Returns an iterator that is past the last entity that has the given components.
    Definition: group.hpp:243
    +
    entt::storage
    Basic storage implementation.
    Definition: storage.hpp:692
    +
    entt::basic_group< Entity, get_t< Get... >, Owned... >::find
    iterator_type find(const entity_type entt) const ENTT_NOEXCEPT
    Finds an entity.
    Definition: group.hpp:600
    +
    entt::basic_group< Entity, get_t< Get... > >::data
    const entity_type * data() const ENTT_NOEXCEPT
    Direct access to the list of entities of a given pool.
    Definition: group.hpp:190
    +
    entt::basic_group< Entity, get_t< Get... >, Owned... >::each
    void each(Func func) const
    Iterates entities and components and applies the given function object to them.
    Definition: group.hpp:675
    +
    entt::basic_registry
    Fast and reliable entity-component system.
    Definition: fwd.hpp:13
    +
    entt::basic_group< Entity, get_t< Get... > >::empty
    bool empty() const ENTT_NOEXCEPT
    Checks whether the group is empty.
    Definition: group.hpp:152
    +
    entt::basic_group< Entity, get_t< Get... >, Owned... >::sort
    void sort(Compare compare, Sort algo=Sort{}, Args &&... args)
    Sort a group according to the given comparison function.
    Definition: group.hpp:740
    +
    entt::sparse_set::entity_type
    Entity entity_type
    Underlying entity identifier.
    Definition: sparse_set.hpp:174
    +
    entt::basic_group< Entity, get_t< Get... > >::shrink_to_fit
    void shrink_to_fit()
    Requests the removal of unused capacity.
    Definition: group.hpp:133
    +
    entt::type_list
    A class to use to push around lists of types, nothing more.
    Definition: type_traits.hpp:17
    +
    entt::std_sort
    Function object to wrap std::sort in a class type.
    Definition: algorithm.hpp:21
    +
    entt::type_list< Type... >::size
    static constexpr auto size
    Unsigned integer type.
    Definition: type_traits.hpp:19
    +
    entt::basic_group< Entity, get_t< Get... >, Owned... >::end
    iterator_type end() const ENTT_NOEXCEPT
    Returns an iterator that is past the last entity that has the given components.
    Definition: group.hpp:590
    +
    entt::basic_group< Entity, get_t< Get... > >::contains
    bool contains(const entity_type entt) const ENTT_NOEXCEPT
    Checks if a group contains an entity.
    Definition: group.hpp:272
    +
    entt::basic_group< Entity, get_t< Get... >, Owned... >::begin
    iterator_type begin() const ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given components.
    Definition: group.hpp:571
    +
    entt::basic_group< Entity, get_t< Get... >, Owned... >::entity_type
    typename sparse_set< Entity >::entity_type entity_type
    Underlying entity identifier.
    Definition: group.hpp:454
    +
    entt::basic_group< Entity, get_t< Get... > >::capacity
    size_type capacity() const ENTT_NOEXCEPT
    Returns the number of elements that a group has currently allocated space for.
    Definition: group.hpp:128
    +
    entt::basic_group< Entity, get_t< Get... >, Owned... >::empty
    bool empty() const ENTT_NOEXCEPT
    Checks whether the group is empty.
    Definition: group.hpp:493
    +
    entt::basic_group< Entity, get_t< Get... > >::size
    size_type size() const ENTT_NOEXCEPT
    Returns the number of existing components of the given type.
    Definition: group.hpp:111
    +
    entt::basic_group< Entity, get_t< Get... >, Owned... >::data
    const entity_type * data() const ENTT_NOEXCEPT
    Direct access to the list of entities of a given pool.
    Definition: group.hpp:537
    +
    entt::get
    constexpr get_t< Type... > get
    Variable template for lists of observed components.
    Definition: group.hpp:31
    +
    entt::basic_group< Entity, get_t< Get... >, Owned... >::empty
    bool empty() const ENTT_NOEXCEPT
    Checks whether the pool of a given component is empty.
    Definition: group.hpp:485
    +
    entt::basic_group< Entity, get_t< Get... > >::each
    void each(Func func) const
    Iterates entities and components and applies the given function object to them.
    Definition: group.hpp:328
    +
    entt::basic_group< Entity, get_t< Get... > >::entity_type
    typename sparse_set< Entity >::entity_type entity_type
    Underlying entity identifier.
    Definition: group.hpp:99
    +
    entt::get_t
    Alias for lists of observed components.
    Definition: group.hpp:23
    +
    entt::basic_group< Entity, get_t< Get... >, Owned... >::size_type
    typename sparse_set< Entity >::size_type size_type
    Unsigned integer type.
    Definition: group.hpp:456
    +
    entt::basic_group< Entity, get_t< Get... > >::begin
    iterator_type begin() const ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given components.
    Definition: group.hpp:224
    +
    entt::basic_group< Entity, get_t< Get... >, Owned... >::size
    size_type size() const ENTT_NOEXCEPT
    Returns the number of existing components of the given type.
    Definition: group.hpp:466
    +
    entt::basic_group< Entity, get_t< Get... > >::raw
    Component * raw() const ENTT_NOEXCEPT
    Direct access to the list of components of a given pool.
    Definition: group.hpp:171
    +
    entt::basic_group< Entity, get_t< Get... > >::iterator_type
    typename sparse_set< Entity >::iterator_type iterator_type
    Input iterator type.
    Definition: group.hpp:103
    +
    entt::sparse_set::iterator_type
    iterator iterator_type
    Random access iterator type.
    Definition: sparse_set.hpp:178
    +
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/handle_8hpp_source.html b/handle_8hpp_source.html index 4d2ebb957..21322ce63 100644 --- a/handle_8hpp_source.html +++ b/handle_8hpp_source.html @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
    [detail level 123]
     Centt::Actor< Entity >Dedicated to those who aren't confident with entity-component systems
     Centt::Attachee<... >Attachee
     ▼Centt::Attachee< Entity >Basic attachee implementation
     Centt::Attachee< Entity, Type >Extended attachee implementation
     Centt::Attachee< Entity, Tag >
     ▼Cconnection_type
     Centt::Emitter< Derived >::Connection< Event >Generic connection type for events
     Centt::ContinuousLoader< Entity >Utility class for continuous loading
     Centt::Delegate< typename >Basic delegate implementation
     Centt::Delegate< Ret(Args...)>Utility class to send around functions and member functions
     Centt::DispatcherBasic dispatcher implementation
     Centt::Emitter< Derived >General purpose event emitter
     Centt::entt_traits< typename >Entity traits
     Centt::entt_traits< std::uint16_t >Entity traits for a 16 bits entity identifier
     Centt::entt_traits< std::uint32_t >Entity traits for a 32 bits entity identifier
     Centt::entt_traits< std::uint64_t >Entity traits for a 64 bits entity identifier
     Centt::Family<... >Dynamic identifier generator
     ▼CFunc
     Centt::ProcessAdaptor< Func, Delta >Adaptor for lambdas and functors to turn them into processes
     Centt::HashedStringZero overhead resource identifier
     Centt::Identifier< Types >Types identifiers
     Centt::InsertionSortFunction object for performing insertion sort
     ▼CInvoker
     Centt::SigH< Ret(Args...), Collector >Unmanaged signal handler definition
     Centt::Monostate< hash_type >Minimal implementation of the monostate pattern
     Centt::OneShotBubbleSortFunction object for performing bubble sort (single iteration)
     Centt::persistent_tPersistent view type used to disambiguate overloads
     Centt::PersistentView< Entity, Component >Persistent view
     Centt::Process< Derived, Delta >Base class for processes
     ▼Centt::Process< ProcessAdaptor< Func, Delta >, Delta >
     Centt::ProcessAdaptor< Func, Delta >Adaptor for lambdas and functors to turn them into processes
     Centt::Prototype< Entity >Prototype container for concepts
     Centt::raw_tRaw view type used to disambiguate overloads
     Centt::RawView< Entity, Component >Raw view
     Centt::Registry< Entity >Fast and reliable entity-component system
     Centt::ResourceCache< Resource >Simple cache for resources of a given type
     Centt::ResourceHandle< Resource >Shared resource handle
     Centt::ResourceLoader< Loader, Resource >Base class for resource loaders
     Centt::RuntimeView< Entity >Runtime view
     Centt::Scheduler< Delta >Cooperative scheduler for processes
     Centt::ServiceLocator< Service >Service locator, nothing more
     Centt::SigH< Function, Collector >Unmanaged signal handler declaration
     Centt::SigH< void(const Event &)>
     Centt::SigH< void(Registry &, const Entity)>
     Centt::Sink< Function >Sink implementation
     Centt::Sink< Ret(Args...)>Sink implementation
     Centt::Snapshot< Entity >Utility class to create snapshots from a registry
     Centt::SnapshotLoader< Entity >Utility class to restore a snapshot as a whole
     Centt::SparseSet<... >Sparse set
     ▼Centt::SparseSet< Entity >Basic sparse set implementation
     Centt::SparseSet< Entity, Type >Extended sparse set implementation
     Centt::SparseSet< Entity, Component >
     Centt::StdSortFunction object to wrap std::sort in a class type
     Centt::tag_tTag class type used to disambiguate overloads
     Centt::View< Entity, Component >Multi component view
     Centt::View< Entity, Component >Single component view specialization
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
     Centt::as_group< Const, Entity >Converts a registry to a group
     Centt::as_view< Const, Entity >Converts a registry to a view
     Centt::basic_actor< Entity >Dedicated to those who aren't confident with entity-component systems
     Centt::basic_continuous_loader< Entity >Utility class for continuous loading
     Centt::basic_group<... >Group
     Centt::basic_group< Entity, get_t< Get... > >Non-owning group
     Centt::basic_group< Entity, get_t< Get... >, Owned... >Owning group
     Centt::basic_prototype< Entity >Prototype container for concepts
     Centt::basic_registry< Entity >Fast and reliable entity-component system
     Centt::basic_runtime_view< Entity >Runtime view
     Centt::basic_snapshot< Entity >Utility class to create snapshots from a registry
     Centt::basic_snapshot_loader< Entity >Utility class to restore a snapshot as a whole
     Centt::basic_view< Entity, Component >Multi component view
     Centt::basic_view< Entity, Component >Single component view specialization
     Centt::connect_arg_t< auto >Used to wrap a function or a member of a specified type
     ▼Cconnection_type
     Centt::emitter< Derived >::connection< Event >Generic connection type for events
     Centt::delegate< typename >Basic delegate implementation
     Centt::delegate< Ret(Args...)>Utility class to use to send around functions and members
     Centt::dispatcherBasic dispatcher implementation
     Centt::emitter< Derived >General purpose event emitter
     Centt::entt_traits< typename >Entity traits
     Centt::entt_traits< std::uint16_t >Entity traits for a 16 bits entity identifier
     Centt::entt_traits< std::uint32_t >Entity traits for a 32 bits entity identifier
     Centt::entt_traits< std::uint64_t >Entity traits for a 64 bits entity identifier
     ▼Cfalse_type
     Centt::is_named_type< typename, typename >Provides the member constant value to true if a given type has a name. In all other cases, value is false
     Centt::family<... >Dynamic identifier generator
     ▼CFunc
     Centt::process_adaptor< Func, Delta >Adaptor for lambdas and functors to turn them into processes
     Centt::hashed_stringZero overhead unique identifier
     Centt::identifier< Types >Types identifiers
     Centt::insertion_sortFunction object for performing insertion sort
     ▼Cinvoker
     Centt::sigh< Ret(Args...), Collector >Unmanaged signal handler definition
     Centt::meta_anyMeta any object
     Centt::meta_baseMeta base object
     Centt::meta_convMeta conversion function object
     Centt::meta_ctorMeta constructor object
     Centt::meta_dataMeta data object
     Centt::meta_dtorMeta destructor object
     Centt::meta_factory< Type >A meta factory to be used for reflection purposes
     Centt::meta_funcMeta function object
     Centt::meta_handleMeta handle object
     Centt::meta_propMeta property object
     Centt::meta_typeMeta type object
     Centt::monostate< hash_type >Minimal implementation of the monostate pattern
     Centt::named_type_traits< typename >Traits class used mainly to push things across boundaries
     ▼Centt::named_type_traits< Type >
     Centt::named_type_traits< const Type >Specialization used to get rid of constness
     Centt::process< Derived, Delta >Base class for processes
     ▼Centt::process< process_adaptor< Func, Delta >, Delta >
     Centt::process_adaptor< Func, Delta >Adaptor for lambdas and functors to turn them into processes
     Centt::resource_cache< Resource >Simple cache for resources of a given type
     Centt::resource_handle< Resource >Shared resource handle
     Centt::resource_loader< Loader, Resource >Base class for resource loaders
     Centt::scheduler< Delta >Cooperative scheduler for processes
     Centt::service_locator< Service >Service locator, nothing more
     Centt::sigh< typename, typename >Unmanaged signal handler declaration
     Centt::sigh< void(const Event &)>
     Centt::sigh< void(entt::basic_registry &, const Entity)>
     Centt::sigh< void(entt::basic_registry &, const Entity, std::conditional_t< std::is_empty_v< Component >, const Component &, Component &>)>
     Centt::sink< typename >Sink implementation
     Centt::sink< Ret(Args...)>Sink implementation
     ▼Centt::sparse_set< Entity >Basic sparse set implementation
     ▼Centt::basic_storage< Entity, Component >
     Centt::storage< Entity, Component >
     Centt::basic_storage< Entity, Type >
     ▼Centt::basic_storage< Entity, Type, typename >Basic storage implementation
     Centt::storage< Entity, Type >Basic storage implementation.
     Centt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >Basic storage implementation.
     Centt::sparse_set< entity_type >
     Centt::std_sortFunction object to wrap std::sort in a class type
     ▼Ctrue_type
     Centt::is_named_type< Type, std::void_t< named_type_traits_t< std::decay_t< Type > > > >Provides the member constant value to true if a given type has a name. In all other cases, value is false
     Centt::type_list< Type >A class to use to push around lists of types, nothing more
     ▼Centt::type_list< Type... >
     Centt::exclude_t< Type >Alias for exclusion lists
     Centt::get_t< Type >Alias for lists of observed components
     Centt::type_list_cat<... >Primary template isn't defined on purpose
     Centt::type_list_cat< type_list< Type... > >Concatenates multiple type lists
     Centt::type_list_cat< type_list< Type... >, type_list< Other... >, List... >Concatenates multiple type lists
     Centt::type_list_unique< typename >Primary template isn't defined on purpose
     Centt::type_list_unique< type_list< Type, Other... > >Removes duplicates types from a type list
     Centt::type_list_unique< type_list<> >Removes duplicates types from a type list
    diff --git a/ident_8hpp_source.html b/ident_8hpp_source.html index 097cc9e4b..115b75d8b 100644 --- a/ident_8hpp_source.html +++ b/ident_8hpp_source.html @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    @@ -147,81 +146,62 @@ Arrays are almost sorted, std::sort
    Benchmark EntityX (compile-time) EnTT
    - 0.0035s
    - 0.0007s

    Note: The default version of EntityX (master branch) wasn't added to the comparison because it's already much slower than its compile-time counterpart.

    -

    Pretty interesting, aren't them? In fact, these benchmarks are the same used by EntityX to show how fast it is. To be honest, they aren't so good and these results shouldn't be taken much seriously (they are completely unrealistic indeed).
    - The proposed entity-component system is incredibly fast to iterate entities, this is a fact. The compiler can make a lot of optimizations because of how EnTT works, even more when components aren't used at all. This is exactly the case for these benchmarks. On the other hand and if we consider real world cases, EnTT is in the middle between a bit and much faster than the other solutions around when users also access the components and not just the entities, although it is not as fast as reported by these benchmarks.
    - This is why they are completely wrong and cannot be used to evaluate any of the entity-component systems.

    -

    If you decide to use EnTT, choose it because of its API, features and performance, not because there is a benchmark somewhere that makes it seem the fastest.

    -

    Probably I'll try to get out of EnTT more features and even better performance in the future, mainly for fun.
    - If you want to contribute and/or have any suggestion, feel free to make a PR or open an issue to discuss your idea.

    -

    +

    Pretty interesting results, aren't them? In fact, these benchmarks are the ones used by EntityX to show how fast it is. To be honest, they aren't so good and these results shouldn't be taken too seriously (indeed they are completely unrealistic).
    + The proposed entity-component system is incredibly fast to iterate entities, this is a fact. The compiler can make a lot of optimizations because of how EnTT works, even more when components aren't used at all. This is exactly the case for these benchmarks. On the other hand, if we consider real world cases, EnTT is somewhere between a bit and much faster than the other solutions around when users also access the components and not just the entities, although it isn't as fast as reported by these benchmarks.
    + This is why they are completely wrong and cannot be used to evaluate any of the entity-component-system libraries out there.

    +

    The choice to use EnTT should be based on its carefully designed API, its set of features and the general performance, not because some single benchmark shows it to be the fastest tool available.

    +

    In the future I'll likely try to get even better performance while still adding new features, mainly for fun.
    + If you want to contribute and/or have suggestions, feel free to make a PR or open an issue to discuss your idea.

    +

    Build Instructions

    -

    +

    Requirements

    -

    To be able to use EnTT, users must provide a full-featured compiler that supports at least C++14.
    +

    To be able to use EnTT, users must provide a full-featured compiler that supports at least C++17.
    The requirements below are mandatory to compile the tests and to extract the documentation:

    • CMake version 3.2 or later.
    • Doxygen version 1.8 or later.
    -

    +

    If you are looking for a C++14 version of EnTT, check out the git tag cpp14.

    +

    Library

    EnTT is a header-only library. This means that including the entt.hpp header is enough to include the library as a whole and use it. For those who are interested only in the entity-component system, consider to include the sole entity/registry.hpp header instead.
    It's a matter of adding the following line to the top of a file:

    #include <entt/entt.hpp>

    Use the line below to include only the entity-component system instead:

    #include <entt/entity/registry.hpp>

    Then pass the proper -I argument to the compiler to add the src directory to the include paths.

    -

    +

    Documentation

    -

    The documentation is based on doxygen. To build it: 

    $ cd build
+
    The documentation is based on doxygen. To build it: 
    $ cd build
 $ cmake .. -DBUILD_DOCS=ON
 $ make
 
    The API reference will be created in HTML format within the directory build/docs/html. To navigate it with your favorite browser: 
    $ cd build
 $ your_favorite_browser docs/html/index.html
-
    
+

    Tests

    To compile and run the tests, EnTT requires googletest.
    - cmake will download and compile the library before compiling anything else. In order to build without tests set CMake option BUILD_TESTING=OFF.

    + cmake will download and compile the library before compiling anything else. In order to build the tests, set the CMake option BUILD_TESTING to ON.

    To build the most basic set of tests:

    • $ cd build
      • -
    • $ cmake ..
      • +
    • $ cmake -DBUILD_TESTING=ON ..
    • $ make
    • $ make test

    Note that benchmarks are not part of this set.

    -

    +

    Packaging Tools

    EnTT is available for some of the most known packaging tools. In particular:

      -
    • vcpkg, Microsoft VC++ Packaging Tool.
      • +
    • Conan, the C/C++ Package Manager for Developers.
    • Homebrew, the missing package manager for macOS.
      Available as a homebrew formula. Just type the following to install it:
      brew install skypjack/entt/entt
      • +
    • vcpkg, Microsoft VC++ Packaging Tool.

    Consider this list a work in progress and help me to make it longer.

    -

    -EnTT in Action

    -

    EnTT is widely used in private and commercial applications. I cannot even mention most of them because of some signatures I put on some documents time ago.
    - Fortunately, there are also people who took the time to implement open source projects based on EnTT and did not hold back when it came to documenting them.

    -

    Below an incomplete list of projects and articles:

    - -

    If you know of other resources out there that are about EnTT, feel free to open an issue or a PR and I'll be glad to add them to the list.

    -

    +

    License

    -

    Code and documentation Copyright (c) 2017-2018 Michele Caini.
    - Logo Copyright (c) 2018 Richard Caseres.

    +

    Code and documentation Copyright (c) 2017-2019 Michele Caini.
    + Logo Copyright (c) 2018-2019 Richard Caseres.

    Code released under the MIT license. Documentation released under CC BY 4.0.
    Logo released under CC BY-SA 4.0.

    diff --git a/inherit_graph_0.map b/inherit_graph_0.map index 751b92afa..3cfa468fe 100644 --- a/inherit_graph_0.map +++ b/inherit_graph_0.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_0.md5 b/inherit_graph_0.md5 index e7d691c45..8fba7300d 100644 --- a/inherit_graph_0.md5 +++ b/inherit_graph_0.md5 @@ -1 +1 @@ -d098eb332a613eb34c2d188029c17c79 \ No newline at end of file +f4bdbf9a3db74093cba8790a25eb25f4 \ No newline at end of file diff --git a/inherit_graph_0.png b/inherit_graph_0.png index 370273d37..de41861c8 100644 Binary files a/inherit_graph_0.png and b/inherit_graph_0.png differ diff --git a/inherit_graph_1.map b/inherit_graph_1.map index 03d2d5ee4..31a8ca038 100644 --- a/inherit_graph_1.map +++ b/inherit_graph_1.map @@ -1,4 +1,3 @@ - - + diff --git a/inherit_graph_1.md5 b/inherit_graph_1.md5 index e59ab0f50..4fe6c5170 100644 --- a/inherit_graph_1.md5 +++ b/inherit_graph_1.md5 @@ -1 +1 @@ -dc0bf6f854a30eb0c824766d7f0bd703 \ No newline at end of file +643b0c5706c0314b13af48323d8bc656 \ No newline at end of file diff --git a/inherit_graph_1.png b/inherit_graph_1.png index e224535e1..3f5d3b2e6 100644 Binary files a/inherit_graph_1.png and b/inherit_graph_1.png differ diff --git a/inherit_graph_10.map b/inherit_graph_10.map index 67ce56a1d..fad5d2b78 100644 --- a/inherit_graph_10.map +++ b/inherit_graph_10.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_10.md5 b/inherit_graph_10.md5 index 6c5102097..5c4d5789a 100644 --- a/inherit_graph_10.md5 +++ b/inherit_graph_10.md5 @@ -1 +1 @@ -5280b3511ad40df37cde82cb9e2eb1e1 \ No newline at end of file +dffcbdd14e8c5179f66da4867d59cb3e \ No newline at end of file diff --git a/inherit_graph_10.png b/inherit_graph_10.png index 9f9dae19c..b5a2fb032 100644 Binary files a/inherit_graph_10.png and b/inherit_graph_10.png differ diff --git a/inherit_graph_11.map b/inherit_graph_11.map index ed3bfca0e..21be30f41 100644 --- a/inherit_graph_11.map +++ b/inherit_graph_11.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_11.md5 b/inherit_graph_11.md5 index c5a8451da..34baedc18 100644 --- a/inherit_graph_11.md5 +++ b/inherit_graph_11.md5 @@ -1 +1 @@ -820ea685d52a50407520850e381b91f8 \ No newline at end of file +ed1335c52727f112c98593c9bb6cc7b9 \ No newline at end of file diff --git a/inherit_graph_11.png b/inherit_graph_11.png index 486514c53..c42658e4b 100644 Binary files a/inherit_graph_11.png and b/inherit_graph_11.png differ diff --git a/inherit_graph_12.map b/inherit_graph_12.map index 083843f3f..7d4c6aed9 100644 --- a/inherit_graph_12.map +++ b/inherit_graph_12.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_12.md5 b/inherit_graph_12.md5 index b88f7ce0c..3f8c4551f 100644 --- a/inherit_graph_12.md5 +++ b/inherit_graph_12.md5 @@ -1 +1 @@ -448f5f138376e0a71e7cc0def9a0dc84 \ No newline at end of file +d4e385e8dc9bba0e8019d52e698ed2cd \ No newline at end of file diff --git a/inherit_graph_12.png b/inherit_graph_12.png index b2cac4746..78ef5362c 100644 Binary files a/inherit_graph_12.png and b/inherit_graph_12.png differ diff --git a/inherit_graph_13.map b/inherit_graph_13.map index ef02b4372..9af04480b 100644 --- a/inherit_graph_13.map +++ b/inherit_graph_13.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_13.md5 b/inherit_graph_13.md5 index 9d8243a80..8e94b5939 100644 --- a/inherit_graph_13.md5 +++ b/inherit_graph_13.md5 @@ -1 +1 @@ -b73da3bdeb56ed8b3261b9f6de7dc7ed \ No newline at end of file +b3997ec2ed2d4aa30cb35287ee48a1dc \ No newline at end of file diff --git a/inherit_graph_13.png b/inherit_graph_13.png index 3eb1597c1..78ef5362c 100644 Binary files a/inherit_graph_13.png and b/inherit_graph_13.png differ diff --git a/inherit_graph_14.map b/inherit_graph_14.map index eb27d4bf3..040f6cd2d 100644 --- a/inherit_graph_14.map +++ b/inherit_graph_14.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_14.md5 b/inherit_graph_14.md5 index c9dce4020..f38442367 100644 --- a/inherit_graph_14.md5 +++ b/inherit_graph_14.md5 @@ -1 +1 @@ -09580e735d0e3bb01d18b482b6830ac0 \ No newline at end of file +f3d3e793f2e53d14c1a7da42d7115bbf \ No newline at end of file diff --git a/inherit_graph_14.png b/inherit_graph_14.png index 00a1590bc..695248825 100644 Binary files a/inherit_graph_14.png and b/inherit_graph_14.png differ diff --git a/inherit_graph_15.map b/inherit_graph_15.map index c694a417c..8e7383ffe 100644 --- a/inherit_graph_15.map +++ b/inherit_graph_15.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_15.md5 b/inherit_graph_15.md5 index db47bd787..def13ade1 100644 --- a/inherit_graph_15.md5 +++ b/inherit_graph_15.md5 @@ -1 +1 @@ -767a37ccf50cdbc3532e1a834ba5df4d \ No newline at end of file +83b9f0e926e95b955f447a2b793991de \ No newline at end of file diff --git a/inherit_graph_15.png b/inherit_graph_15.png index b050192ae..1a55ea4ed 100644 Binary files a/inherit_graph_15.png and b/inherit_graph_15.png differ diff --git a/inherit_graph_16.map b/inherit_graph_16.map index 0a22de5e5..f914a0523 100644 --- a/inherit_graph_16.map +++ b/inherit_graph_16.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_16.md5 b/inherit_graph_16.md5 index 846adf7dc..a562c1461 100644 --- a/inherit_graph_16.md5 +++ b/inherit_graph_16.md5 @@ -1 +1 @@ -f08dc4dc73fa40e661d5b156da7ea472 \ No newline at end of file +7ecb79bda70b1375451851a01b7fb935 \ No newline at end of file diff --git a/inherit_graph_16.png b/inherit_graph_16.png index dc7261e0b..67ce5397b 100644 Binary files a/inherit_graph_16.png and b/inherit_graph_16.png differ diff --git a/inherit_graph_17.map b/inherit_graph_17.map index 5b01a5f9b..4b137bf19 100644 --- a/inherit_graph_17.map +++ b/inherit_graph_17.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_17.md5 b/inherit_graph_17.md5 index 693a576ce..37d4400ac 100644 --- a/inherit_graph_17.md5 +++ b/inherit_graph_17.md5 @@ -1 +1 @@ -346d632c706916a7b10653e1b85bd7a5 \ No newline at end of file +9ea7eb13089be72a6a409f2c5e734b0a \ No newline at end of file diff --git a/inherit_graph_17.png b/inherit_graph_17.png index 7956e292e..293e389d6 100644 Binary files a/inherit_graph_17.png and b/inherit_graph_17.png differ diff --git a/inherit_graph_18.map b/inherit_graph_18.map index 83769395a..51bfc1436 100644 --- a/inherit_graph_18.map +++ b/inherit_graph_18.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_18.md5 b/inherit_graph_18.md5 index 1bf4a4084..c8985cfc8 100644 --- a/inherit_graph_18.md5 +++ b/inherit_graph_18.md5 @@ -1 +1 @@ -469876f5b4b08c1af3415a4c19dd7941 \ No newline at end of file +efb47abdd9e48d0f04d9837176e37751 \ No newline at end of file diff --git a/inherit_graph_18.png b/inherit_graph_18.png index 0838f9849..1ecbbd8a8 100644 Binary files a/inherit_graph_18.png and b/inherit_graph_18.png differ diff --git a/inherit_graph_19.map b/inherit_graph_19.map index 7aef5d7c1..2057baf39 100644 --- a/inherit_graph_19.map +++ b/inherit_graph_19.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_19.md5 b/inherit_graph_19.md5 index 432af4f8d..3de09396e 100644 --- a/inherit_graph_19.md5 +++ b/inherit_graph_19.md5 @@ -1 +1 @@ -4f41409bd2b6db723b3ecd9e2b752c70 \ No newline at end of file +a3093c1860e145108373386f3b293c14 \ No newline at end of file diff --git a/inherit_graph_19.png b/inherit_graph_19.png index c2668d595..556590a91 100644 Binary files a/inherit_graph_19.png and b/inherit_graph_19.png differ diff --git a/inherit_graph_2.map b/inherit_graph_2.map index 7432c8dab..a2c820136 100644 --- a/inherit_graph_2.map +++ b/inherit_graph_2.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_2.md5 b/inherit_graph_2.md5 index d3008f52a..792511af3 100644 --- a/inherit_graph_2.md5 +++ b/inherit_graph_2.md5 @@ -1 +1 @@ -c02a202d51fb26d10ad243fe3d66c600 \ No newline at end of file +541f0396af842616a4840c737250d56c \ No newline at end of file diff --git a/inherit_graph_2.png b/inherit_graph_2.png index 2c2d7fbc3..be4aec68b 100644 Binary files a/inherit_graph_2.png and b/inherit_graph_2.png differ diff --git a/inherit_graph_20.map b/inherit_graph_20.map index 68b105f9f..67ce56a1d 100644 --- a/inherit_graph_20.map +++ b/inherit_graph_20.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_20.md5 b/inherit_graph_20.md5 index b4cc67996..6c5102097 100644 --- a/inherit_graph_20.md5 +++ b/inherit_graph_20.md5 @@ -1 +1 @@ -20c874a300d88122441dac8e77bf11e8 \ No newline at end of file +5280b3511ad40df37cde82cb9e2eb1e1 \ No newline at end of file diff --git a/inherit_graph_20.png b/inherit_graph_20.png index 6ce02376d..d05441aa6 100644 Binary files a/inherit_graph_20.png and b/inherit_graph_20.png differ diff --git a/inherit_graph_21.map b/inherit_graph_21.map index f59ca3c15..ed3bfca0e 100644 --- a/inherit_graph_21.map +++ b/inherit_graph_21.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_21.md5 b/inherit_graph_21.md5 index 9e985e6b1..c5a8451da 100644 --- a/inherit_graph_21.md5 +++ b/inherit_graph_21.md5 @@ -1 +1 @@ -68c3f1d2aaee71c81615b1ee951d2af7 \ No newline at end of file +820ea685d52a50407520850e381b91f8 \ No newline at end of file diff --git a/inherit_graph_21.png b/inherit_graph_21.png index 924d0c1dc..fc2ff595f 100644 Binary files a/inherit_graph_21.png and b/inherit_graph_21.png differ diff --git a/inherit_graph_22.map b/inherit_graph_22.map index 65672c65c..083843f3f 100644 --- a/inherit_graph_22.map +++ b/inherit_graph_22.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_22.md5 b/inherit_graph_22.md5 index 95847419f..b88f7ce0c 100644 --- a/inherit_graph_22.md5 +++ b/inherit_graph_22.md5 @@ -1 +1 @@ -c978a805ca3e2559509fb10fb22ba569 \ No newline at end of file +448f5f138376e0a71e7cc0def9a0dc84 \ No newline at end of file diff --git a/inherit_graph_22.png b/inherit_graph_22.png index bfd542e06..c3998e73f 100644 Binary files a/inherit_graph_22.png and b/inherit_graph_22.png differ diff --git a/inherit_graph_23.map b/inherit_graph_23.map index 406d96210..ef02b4372 100644 --- a/inherit_graph_23.map +++ b/inherit_graph_23.map @@ -1,4 +1,3 @@ - - + diff --git a/inherit_graph_23.md5 b/inherit_graph_23.md5 index a7e4e2280..9d8243a80 100644 --- a/inherit_graph_23.md5 +++ b/inherit_graph_23.md5 @@ -1 +1 @@ -daf048dcdb4e178bd704bfc82bad3399 \ No newline at end of file +b73da3bdeb56ed8b3261b9f6de7dc7ed \ No newline at end of file diff --git a/inherit_graph_23.png b/inherit_graph_23.png index 7d998f344..b2200c94b 100644 Binary files a/inherit_graph_23.png and b/inherit_graph_23.png differ diff --git a/inherit_graph_24.map b/inherit_graph_24.map index 0ec2cbabf..fa81b917b 100644 --- a/inherit_graph_24.map +++ b/inherit_graph_24.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_24.md5 b/inherit_graph_24.md5 index 96a74eaf2..440a519ec 100644 --- a/inherit_graph_24.md5 +++ b/inherit_graph_24.md5 @@ -1 +1 @@ -8717e582ab01906c25cce74e94efc8ba \ No newline at end of file +a11695c55d1c3d888dc9ef427191a016 \ No newline at end of file diff --git a/inherit_graph_24.png b/inherit_graph_24.png index 8001af7f7..8873318eb 100644 Binary files a/inherit_graph_24.png and b/inherit_graph_24.png differ diff --git a/inherit_graph_25.map b/inherit_graph_25.map index 4a54762fb..e440ae8db 100644 --- a/inherit_graph_25.map +++ b/inherit_graph_25.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_25.md5 b/inherit_graph_25.md5 index cee282778..2c4ac46c1 100644 --- a/inherit_graph_25.md5 +++ b/inherit_graph_25.md5 @@ -1 +1 @@ -290a5b9298ed0c6980ce61d3800f8661 \ No newline at end of file +79a6235c4d3f4d9c722860d20dcceef2 \ No newline at end of file diff --git a/inherit_graph_25.png b/inherit_graph_25.png index d4e6d5031..ce129aece 100644 Binary files a/inherit_graph_25.png and b/inherit_graph_25.png differ diff --git a/inherit_graph_26.map b/inherit_graph_26.map index 6aba09019..74eda95cc 100644 --- a/inherit_graph_26.map +++ b/inherit_graph_26.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_26.md5 b/inherit_graph_26.md5 index e148f959b..d73d54e68 100644 --- a/inherit_graph_26.md5 +++ b/inherit_graph_26.md5 @@ -1 +1 @@ -9a33b8231c878d5e6ebdbdd360973b53 \ No newline at end of file +935f82d3ec03e986d1749537bc8c13c3 \ No newline at end of file diff --git a/inherit_graph_26.png b/inherit_graph_26.png index 5250f1daa..0b8f20898 100644 Binary files a/inherit_graph_26.png and b/inherit_graph_26.png differ diff --git a/inherit_graph_27.map b/inherit_graph_27.map index 9f5c41240..2f9109491 100644 --- a/inherit_graph_27.map +++ b/inherit_graph_27.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_27.md5 b/inherit_graph_27.md5 index 75b65452a..fe34156b0 100644 --- a/inherit_graph_27.md5 +++ b/inherit_graph_27.md5 @@ -1 +1 @@ -4e394cd62968962a42441b4a70fd88e4 \ No newline at end of file +5e7de526b207623fba83b89bdcbf9306 \ No newline at end of file diff --git a/inherit_graph_27.png b/inherit_graph_27.png index d34389072..0faed39f6 100644 Binary files a/inherit_graph_27.png and b/inherit_graph_27.png differ diff --git a/inherit_graph_28.map b/inherit_graph_28.map index 35299d892..b6774e8ee 100644 --- a/inherit_graph_28.map +++ b/inherit_graph_28.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_28.md5 b/inherit_graph_28.md5 index da199b4a4..1ea73df28 100644 --- a/inherit_graph_28.md5 +++ b/inherit_graph_28.md5 @@ -1 +1 @@ -51bd2d62cec2bcbbf0df1dd79babf051 \ No newline at end of file +423bcb82b2dc7aac79ef9713cfc20084 \ No newline at end of file diff --git a/inherit_graph_28.png b/inherit_graph_28.png index c96052a26..f2bcb005d 100644 Binary files a/inherit_graph_28.png and b/inherit_graph_28.png differ diff --git a/inherit_graph_29.map b/inherit_graph_29.map index 62d3a9d46..9eb4013b9 100644 --- a/inherit_graph_29.map +++ b/inherit_graph_29.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_29.md5 b/inherit_graph_29.md5 index 6fed19d4c..745c6acdf 100644 --- a/inherit_graph_29.md5 +++ b/inherit_graph_29.md5 @@ -1 +1 @@ -79f5be431b4e27136879c42af4894284 \ No newline at end of file +05260045a862cc48e553a490fe10f1f5 \ No newline at end of file diff --git a/inherit_graph_29.png b/inherit_graph_29.png index bbb8862d7..94e0d6605 100644 Binary files a/inherit_graph_29.png and b/inherit_graph_29.png differ diff --git a/inherit_graph_3.map b/inherit_graph_3.map index 6b340a0c4..d1b41dbfc 100644 --- a/inherit_graph_3.map +++ b/inherit_graph_3.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_3.md5 b/inherit_graph_3.md5 index e35160a40..2656cf65f 100644 --- a/inherit_graph_3.md5 +++ b/inherit_graph_3.md5 @@ -1 +1 @@ -8c3587b875095159f6406a954b427428 \ No newline at end of file +ae4b733bfd5e18eafcb23c81b86c38ad \ No newline at end of file diff --git a/inherit_graph_3.png b/inherit_graph_3.png index 58f14aeb4..80a138ed2 100644 Binary files a/inherit_graph_3.png and b/inherit_graph_3.png differ diff --git a/inherit_graph_30.map b/inherit_graph_30.map index ee7694b54..9d981b71d 100644 --- a/inherit_graph_30.map +++ b/inherit_graph_30.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_30.md5 b/inherit_graph_30.md5 index e363686c9..83bddb092 100644 --- a/inherit_graph_30.md5 +++ b/inherit_graph_30.md5 @@ -1 +1 @@ -b13e94c37667394c061cef177073e658 \ No newline at end of file +edebaf18b55c64b93f8da93565bedbab \ No newline at end of file diff --git a/inherit_graph_30.png b/inherit_graph_30.png index 37a607526..97de159a3 100644 Binary files a/inherit_graph_30.png and b/inherit_graph_30.png differ diff --git a/inherit_graph_31.map b/inherit_graph_31.map index 80abd0278..127d45c76 100644 --- a/inherit_graph_31.map +++ b/inherit_graph_31.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_31.md5 b/inherit_graph_31.md5 index dbd2320db..e6b5cd664 100644 --- a/inherit_graph_31.md5 +++ b/inherit_graph_31.md5 @@ -1 +1 @@ -27181bb2a8663aecc220cf73a1a33ee4 \ No newline at end of file +715260cd6ef0aa402a49d54cbd829e34 \ No newline at end of file diff --git a/inherit_graph_31.png b/inherit_graph_31.png index 616d06561..0cd004f05 100644 Binary files a/inherit_graph_31.png and b/inherit_graph_31.png differ diff --git a/inherit_graph_32.map b/inherit_graph_32.map index a8b498de3..2e1bf5f57 100644 --- a/inherit_graph_32.map +++ b/inherit_graph_32.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_32.md5 b/inherit_graph_32.md5 index d815e7823..2efda107c 100644 --- a/inherit_graph_32.md5 +++ b/inherit_graph_32.md5 @@ -1 +1 @@ -fcd13fd54c20a3b15b68df42f79e8750 \ No newline at end of file +29fa72f95559130f20ef647383b83ae6 \ No newline at end of file diff --git a/inherit_graph_32.png b/inherit_graph_32.png index d5e41b427..e5c3d9db9 100644 Binary files a/inherit_graph_32.png and b/inherit_graph_32.png differ diff --git a/inherit_graph_33.map b/inherit_graph_33.map index f63e56225..eb63b078c 100644 --- a/inherit_graph_33.map +++ b/inherit_graph_33.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_33.md5 b/inherit_graph_33.md5 index 8f03789a1..370b66a90 100644 --- a/inherit_graph_33.md5 +++ b/inherit_graph_33.md5 @@ -1 +1 @@ -041e5c12848cb9cfed45decbf29ab84a \ No newline at end of file +16ec52e1c3dc68bb941a90fb1113f903 \ No newline at end of file diff --git a/inherit_graph_33.png b/inherit_graph_33.png index 3b0848620..9accaca23 100644 Binary files a/inherit_graph_33.png and b/inherit_graph_33.png differ diff --git a/inherit_graph_34.map b/inherit_graph_34.map index 286c35707..30e1b9db4 100644 --- a/inherit_graph_34.map +++ b/inherit_graph_34.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_34.md5 b/inherit_graph_34.md5 index a6cb78e10..03cb93539 100644 --- a/inherit_graph_34.md5 +++ b/inherit_graph_34.md5 @@ -1 +1 @@ -e0f7a1b094358c98dff7a3cba8246d13 \ No newline at end of file +a5ea2062d288f2b500c73ec7b56f3f2f \ No newline at end of file diff --git a/inherit_graph_34.png b/inherit_graph_34.png index c561eac44..e90912d1d 100644 Binary files a/inherit_graph_34.png and b/inherit_graph_34.png differ diff --git a/inherit_graph_35.map b/inherit_graph_35.map index 41d8fb1ad..93c336bf9 100644 --- a/inherit_graph_35.map +++ b/inherit_graph_35.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_35.md5 b/inherit_graph_35.md5 index 3ae040af8..b62a325b3 100644 --- a/inherit_graph_35.md5 +++ b/inherit_graph_35.md5 @@ -1 +1 @@ -83df1a4b01754426ffc4b313ca2c15d8 \ No newline at end of file +17b863e9ea005228c1620abf5d616afd \ No newline at end of file diff --git a/inherit_graph_35.png b/inherit_graph_35.png index c476458de..0c1841cc0 100644 Binary files a/inherit_graph_35.png and b/inherit_graph_35.png differ diff --git a/inherit_graph_36.map b/inherit_graph_36.map index 2c9d579f9..567802d55 100644 --- a/inherit_graph_36.map +++ b/inherit_graph_36.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_36.md5 b/inherit_graph_36.md5 index 7567b4969..bf366057f 100644 --- a/inherit_graph_36.md5 +++ b/inherit_graph_36.md5 @@ -1 +1 @@ -32f62226ed08bbc862cab90e19b0b664 \ No newline at end of file +795d2b23ea70cf6ac0a8a6f26a6c4a6c \ No newline at end of file diff --git a/inherit_graph_36.png b/inherit_graph_36.png index 6dc9a20bb..baa73aa8b 100644 Binary files a/inherit_graph_36.png and b/inherit_graph_36.png differ diff --git a/inherit_graph_37.map b/inherit_graph_37.map index 5ae06848a..bb69fd3a2 100644 --- a/inherit_graph_37.map +++ b/inherit_graph_37.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_37.md5 b/inherit_graph_37.md5 index 207cf7797..26e3c9cc3 100644 --- a/inherit_graph_37.md5 +++ b/inherit_graph_37.md5 @@ -1 +1 @@ -7bf5045fb3eeac379a8a02966be19ee1 \ No newline at end of file +0a8ff250bb529170a1bc701aff3f4136 \ No newline at end of file diff --git a/inherit_graph_37.png b/inherit_graph_37.png index 05dc24ea3..4e0bb432e 100644 Binary files a/inherit_graph_37.png and b/inherit_graph_37.png differ diff --git a/inherit_graph_38.map b/inherit_graph_38.map index b0c28a377..1e0c9fabd 100644 --- a/inherit_graph_38.map +++ b/inherit_graph_38.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_38.md5 b/inherit_graph_38.md5 index 9c537fb89..924ae6fbc 100644 --- a/inherit_graph_38.md5 +++ b/inherit_graph_38.md5 @@ -1 +1 @@ -38369dcd720ab0039d7bc3ae6bd935b7 \ No newline at end of file +3184fc021b4708e2f1c3028a1e10fe47 \ No newline at end of file diff --git a/inherit_graph_38.png b/inherit_graph_38.png index d7273b5ec..c00cc6330 100644 Binary files a/inherit_graph_38.png and b/inherit_graph_38.png differ diff --git a/inherit_graph_39.map b/inherit_graph_39.map index 7902bf72e..09154f963 100644 --- a/inherit_graph_39.map +++ b/inherit_graph_39.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_39.md5 b/inherit_graph_39.md5 index c66e60a30..f688046f8 100644 --- a/inherit_graph_39.md5 +++ b/inherit_graph_39.md5 @@ -1 +1 @@ -452c0cc41e45b4a0855838fb8e7a10ff \ No newline at end of file +ae9a648683edfa0db63586e6b76f5289 \ No newline at end of file diff --git a/inherit_graph_39.png b/inherit_graph_39.png index abac03b9a..419f8c82f 100644 Binary files a/inherit_graph_39.png and b/inherit_graph_39.png differ diff --git a/inherit_graph_4.map b/inherit_graph_4.map index d0d6ad851..c652f4b79 100644 --- a/inherit_graph_4.map +++ b/inherit_graph_4.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_4.md5 b/inherit_graph_4.md5 index 06e5fdeab..cfea4316e 100644 --- a/inherit_graph_4.md5 +++ b/inherit_graph_4.md5 @@ -1 +1 @@ -3ca451329752e1552e544d25392638fd \ No newline at end of file +3960965356b11a04dc8b8b65cf3d25cc \ No newline at end of file diff --git a/inherit_graph_4.png b/inherit_graph_4.png index 7099b1f5e..6c5c5ae31 100644 Binary files a/inherit_graph_4.png and b/inherit_graph_4.png differ diff --git a/inherit_graph_40.map b/inherit_graph_40.map index 85ec12751..589918e35 100644 --- a/inherit_graph_40.map +++ b/inherit_graph_40.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_40.md5 b/inherit_graph_40.md5 index affeb35a9..fedda9192 100644 --- a/inherit_graph_40.md5 +++ b/inherit_graph_40.md5 @@ -1 +1 @@ -8abb22caca0c349e0d2a583fd575dc99 \ No newline at end of file +573b348d5e64c90e969ed7158a7f5eb1 \ No newline at end of file diff --git a/inherit_graph_40.png b/inherit_graph_40.png index f5b0eb482..0438e194a 100644 Binary files a/inherit_graph_40.png and b/inherit_graph_40.png differ diff --git a/inherit_graph_41.map b/inherit_graph_41.map index c511abbe7..e03de4480 100644 --- a/inherit_graph_41.map +++ b/inherit_graph_41.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_41.md5 b/inherit_graph_41.md5 index da5341960..01f64da3a 100644 --- a/inherit_graph_41.md5 +++ b/inherit_graph_41.md5 @@ -1 +1 @@ -1fadc2ef69a803635ec75ea2c3f6a5f2 \ No newline at end of file +0b22bf6c2ece786e7466735ad2c8f187 \ No newline at end of file diff --git a/inherit_graph_41.png b/inherit_graph_41.png index 270cb90fe..2db4f8b53 100644 Binary files a/inherit_graph_41.png and b/inherit_graph_41.png differ diff --git a/inherit_graph_42.map b/inherit_graph_42.map index b11003411..3ef50a2ee 100644 --- a/inherit_graph_42.map +++ b/inherit_graph_42.map @@ -1,4 +1,4 @@ - - + + diff --git a/inherit_graph_42.md5 b/inherit_graph_42.md5 index c522d3c5e..108cec972 100644 --- a/inherit_graph_42.md5 +++ b/inherit_graph_42.md5 @@ -1 +1 @@ -8b49e5d4ab6821a094273ac533350361 \ No newline at end of file +1e815e8823ca8b52deae56b852514a76 \ No newline at end of file diff --git a/inherit_graph_42.png b/inherit_graph_42.png index 9c3ded490..5a2eb49d5 100644 Binary files a/inherit_graph_42.png and b/inherit_graph_42.png differ diff --git a/inherit_graph_43.map b/inherit_graph_43.map index 84291e569..643ee7932 100644 --- a/inherit_graph_43.map +++ b/inherit_graph_43.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_43.md5 b/inherit_graph_43.md5 index 492aeb8b7..b523988cc 100644 --- a/inherit_graph_43.md5 +++ b/inherit_graph_43.md5 @@ -1 +1 @@ -d277977b1425339c8f946591267cbe20 \ No newline at end of file +6125b6c8684a93234b3ff16e3ade2e04 \ No newline at end of file diff --git a/inherit_graph_43.png b/inherit_graph_43.png index 07279d19a..0765133e2 100644 Binary files a/inherit_graph_43.png and b/inherit_graph_43.png differ diff --git a/inherit_graph_44.map b/inherit_graph_44.map index 8b565bf7e..4ae3fce72 100644 --- a/inherit_graph_44.map +++ b/inherit_graph_44.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_44.md5 b/inherit_graph_44.md5 index b79b6846b..2c56d7d37 100644 --- a/inherit_graph_44.md5 +++ b/inherit_graph_44.md5 @@ -1 +1 @@ -621c711cd444e7dcd7b795f1703c5cd0 \ No newline at end of file +0aea804ed9c20fc7881e5ceb601498e1 \ No newline at end of file diff --git a/inherit_graph_44.png b/inherit_graph_44.png index 3b9f3f3b9..b3cf8801c 100644 Binary files a/inherit_graph_44.png and b/inherit_graph_44.png differ diff --git a/inherit_graph_45.map b/inherit_graph_45.map index f3f0e77bd..8398b39cf 100644 --- a/inherit_graph_45.map +++ b/inherit_graph_45.map @@ -1,3 +1,4 @@ - + + diff --git a/inherit_graph_45.md5 b/inherit_graph_45.md5 index 177fc5aa0..6a4f26481 100644 --- a/inherit_graph_45.md5 +++ b/inherit_graph_45.md5 @@ -1 +1 @@ -ed043cf7fc8e24545bbc5bcb24759660 \ No newline at end of file +207829a507f2e635daa5d07bb1613d99 \ No newline at end of file diff --git a/inherit_graph_45.png b/inherit_graph_45.png index 5697d7f2a..e3fa291eb 100644 Binary files a/inherit_graph_45.png and b/inherit_graph_45.png differ diff --git a/inherit_graph_46.map b/inherit_graph_46.map index 8c48d78eb..31b827d25 100644 --- a/inherit_graph_46.map +++ b/inherit_graph_46.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_46.md5 b/inherit_graph_46.md5 index cc16fa558..ed509ddfd 100644 --- a/inherit_graph_46.md5 +++ b/inherit_graph_46.md5 @@ -1 +1 @@ -38a5043984aa729fe65aca223c7ae6b5 \ No newline at end of file +a6cdef04701dbb9031abf3e10119e1fa \ No newline at end of file diff --git a/inherit_graph_46.png b/inherit_graph_46.png index 1859301ff..40fdaf308 100644 Binary files a/inherit_graph_46.png and b/inherit_graph_46.png differ diff --git a/inherit_graph_47.map b/inherit_graph_47.map index cd9cba107..e308cd910 100644 --- a/inherit_graph_47.map +++ b/inherit_graph_47.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_47.md5 b/inherit_graph_47.md5 index dcda05878..fd6171f73 100644 --- a/inherit_graph_47.md5 +++ b/inherit_graph_47.md5 @@ -1 +1 @@ -4dcecc0d02b196a20c46b12b739ad30e \ No newline at end of file +86a69bd17742847923a0730899f641ff \ No newline at end of file diff --git a/inherit_graph_47.png b/inherit_graph_47.png index 0c5a70d46..934d8563e 100644 Binary files a/inherit_graph_47.png and b/inherit_graph_47.png differ diff --git a/inherit_graph_48.map b/inherit_graph_48.map index d4b0989d5..4a1b91945 100644 --- a/inherit_graph_48.map +++ b/inherit_graph_48.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_48.md5 b/inherit_graph_48.md5 index 054df0392..4e9d20ed7 100644 --- a/inherit_graph_48.md5 +++ b/inherit_graph_48.md5 @@ -1 +1 @@ -e858ed2f3c399ac5179f89b14a40a3d7 \ No newline at end of file +2c3ef04f2ec7adbd6c8b7830240443ac \ No newline at end of file diff --git a/inherit_graph_48.png b/inherit_graph_48.png index 0c5a70d46..5e1095655 100644 Binary files a/inherit_graph_48.png and b/inherit_graph_48.png differ diff --git a/inherit_graph_49.map b/inherit_graph_49.map index 68b105f9f..3335a9aea 100644 --- a/inherit_graph_49.map +++ b/inherit_graph_49.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_49.md5 b/inherit_graph_49.md5 index b4cc67996..22416be93 100644 --- a/inherit_graph_49.md5 +++ b/inherit_graph_49.md5 @@ -1 +1 @@ -20c874a300d88122441dac8e77bf11e8 \ No newline at end of file +a26af94c0ac7be6391d18fc4e3dc43d1 \ No newline at end of file diff --git a/inherit_graph_49.png b/inherit_graph_49.png index 6ce02376d..14075c59a 100644 Binary files a/inherit_graph_49.png and b/inherit_graph_49.png differ diff --git a/inherit_graph_5.map b/inherit_graph_5.map index afd588bdd..aecfabe5a 100644 --- a/inherit_graph_5.map +++ b/inherit_graph_5.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_5.md5 b/inherit_graph_5.md5 index 940882b89..cae61afea 100644 --- a/inherit_graph_5.md5 +++ b/inherit_graph_5.md5 @@ -1 +1 @@ -b91a71f16ca58a859bf154a0affdcc77 \ No newline at end of file +0c6374c674c1fc7e2a25e3b679dbc69c \ No newline at end of file diff --git a/inherit_graph_5.png b/inherit_graph_5.png index d22b3f61a..cb6813099 100644 Binary files a/inherit_graph_5.png and b/inherit_graph_5.png differ diff --git a/inherit_graph_50.map b/inherit_graph_50.map index f59ca3c15..608d88807 100644 --- a/inherit_graph_50.map +++ b/inherit_graph_50.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_50.md5 b/inherit_graph_50.md5 index 9e985e6b1..a4d32bd63 100644 --- a/inherit_graph_50.md5 +++ b/inherit_graph_50.md5 @@ -1 +1 @@ -68c3f1d2aaee71c81615b1ee951d2af7 \ No newline at end of file +2396c3c9c6c4dfb98cf8dfde69632cf1 \ No newline at end of file diff --git a/inherit_graph_50.png b/inherit_graph_50.png index 924d0c1dc..518d429f5 100644 Binary files a/inherit_graph_50.png and b/inherit_graph_50.png differ diff --git a/inherit_graph_51.map b/inherit_graph_51.map index 65672c65c..d3c8800a0 100644 --- a/inherit_graph_51.map +++ b/inherit_graph_51.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_51.md5 b/inherit_graph_51.md5 index 95847419f..4ffe6c1bc 100644 --- a/inherit_graph_51.md5 +++ b/inherit_graph_51.md5 @@ -1 +1 @@ -c978a805ca3e2559509fb10fb22ba569 \ No newline at end of file +53998f440f355809a0191328ce5ca36a \ No newline at end of file diff --git a/inherit_graph_51.png b/inherit_graph_51.png index bfd542e06..eb9a0267a 100644 Binary files a/inherit_graph_51.png and b/inherit_graph_51.png differ diff --git a/inherit_graph_52.map b/inherit_graph_52.map index 406d96210..09685877d 100644 --- a/inherit_graph_52.map +++ b/inherit_graph_52.map @@ -1,4 +1,3 @@ - - + diff --git a/inherit_graph_52.md5 b/inherit_graph_52.md5 index ecf1b5e37..5c1ea1569 100644 --- a/inherit_graph_52.md5 +++ b/inherit_graph_52.md5 @@ -1 +1 @@ -c959a98fb9bd924fbd66fdc47f9c7d1f \ No newline at end of file +d14699129fd1e980a92ad6f8e75dd5f1 \ No newline at end of file diff --git a/inherit_graph_52.png b/inherit_graph_52.png index 7d998f344..5b10d97a7 100644 Binary files a/inherit_graph_52.png and b/inherit_graph_52.png differ diff --git a/inherit_graph_53.map b/inherit_graph_53.map index 0ec2cbabf..1fc658fc9 100644 --- a/inherit_graph_53.map +++ b/inherit_graph_53.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_53.md5 b/inherit_graph_53.md5 index 96a74eaf2..dd3c44a2f 100644 --- a/inherit_graph_53.md5 +++ b/inherit_graph_53.md5 @@ -1 +1 @@ -8717e582ab01906c25cce74e94efc8ba \ No newline at end of file +83256d9fb8c164d14de003afba38e61f \ No newline at end of file diff --git a/inherit_graph_53.png b/inherit_graph_53.png index 8001af7f7..b03aee224 100644 Binary files a/inherit_graph_53.png and b/inherit_graph_53.png differ diff --git a/inherit_graph_54.map b/inherit_graph_54.map index 4a54762fb..0f67620c3 100644 --- a/inherit_graph_54.map +++ b/inherit_graph_54.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_54.md5 b/inherit_graph_54.md5 index cee282778..eb04711ec 100644 --- a/inherit_graph_54.md5 +++ b/inherit_graph_54.md5 @@ -1 +1 @@ -290a5b9298ed0c6980ce61d3800f8661 \ No newline at end of file +6989326d3796b584168bee2aef16fc76 \ No newline at end of file diff --git a/inherit_graph_54.png b/inherit_graph_54.png index d4e6d5031..f39efa087 100644 Binary files a/inherit_graph_54.png and b/inherit_graph_54.png differ diff --git a/inherit_graph_55.map b/inherit_graph_55.map index 6aba09019..4af9e686f 100644 --- a/inherit_graph_55.map +++ b/inherit_graph_55.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_55.md5 b/inherit_graph_55.md5 index e148f959b..00b0e54b8 100644 --- a/inherit_graph_55.md5 +++ b/inherit_graph_55.md5 @@ -1 +1 @@ -9a33b8231c878d5e6ebdbdd360973b53 \ No newline at end of file +cf25a39f4bdc13c623655ac44f2fd549 \ No newline at end of file diff --git a/inherit_graph_55.png b/inherit_graph_55.png index 5250f1daa..746cc5411 100644 Binary files a/inherit_graph_55.png and b/inherit_graph_55.png differ diff --git a/inherit_graph_56.map b/inherit_graph_56.map index 9f5c41240..827ed0216 100644 --- a/inherit_graph_56.map +++ b/inherit_graph_56.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_56.md5 b/inherit_graph_56.md5 index 75b65452a..56a13ca58 100644 --- a/inherit_graph_56.md5 +++ b/inherit_graph_56.md5 @@ -1 +1 @@ -4e394cd62968962a42441b4a70fd88e4 \ No newline at end of file +c50bc367f9c20c578d10146a848ac532 \ No newline at end of file diff --git a/inherit_graph_56.png b/inherit_graph_56.png index d34389072..11c507f5d 100644 Binary files a/inherit_graph_56.png and b/inherit_graph_56.png differ diff --git a/inherit_graph_57.map b/inherit_graph_57.map index 35299d892..fa9ac7e6e 100644 --- a/inherit_graph_57.map +++ b/inherit_graph_57.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_57.md5 b/inherit_graph_57.md5 index da199b4a4..cc9049df5 100644 --- a/inherit_graph_57.md5 +++ b/inherit_graph_57.md5 @@ -1 +1 @@ -51bd2d62cec2bcbbf0df1dd79babf051 \ No newline at end of file +ec9c4184d1f5c3b1bfaed12405c1d5e1 \ No newline at end of file diff --git a/inherit_graph_57.png b/inherit_graph_57.png index c96052a26..9bff33db2 100644 Binary files a/inherit_graph_57.png and b/inherit_graph_57.png differ diff --git a/inherit_graph_58.map b/inherit_graph_58.map index 62d3a9d46..89dff4e5a 100644 --- a/inherit_graph_58.map +++ b/inherit_graph_58.map @@ -1,3 +1,9 @@ - + + + + + + + diff --git a/inherit_graph_58.md5 b/inherit_graph_58.md5 index 6fed19d4c..e5e3cb498 100644 --- a/inherit_graph_58.md5 +++ b/inherit_graph_58.md5 @@ -1 +1 @@ -79f5be431b4e27136879c42af4894284 \ No newline at end of file +93852a875e1ee1500096e66a5a1e522d \ No newline at end of file diff --git a/inherit_graph_58.png b/inherit_graph_58.png index bbb8862d7..fcdb9970f 100644 Binary files a/inherit_graph_58.png and b/inherit_graph_58.png differ diff --git a/inherit_graph_59.map b/inherit_graph_59.map index ee7694b54..e78de687b 100644 --- a/inherit_graph_59.map +++ b/inherit_graph_59.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_59.md5 b/inherit_graph_59.md5 index e363686c9..6cdfff59b 100644 --- a/inherit_graph_59.md5 +++ b/inherit_graph_59.md5 @@ -1 +1 @@ -b13e94c37667394c061cef177073e658 \ No newline at end of file +f0d98934797f873b7fd6cb6526679f73 \ No newline at end of file diff --git a/inherit_graph_59.png b/inherit_graph_59.png index 37a607526..4019ea20f 100644 Binary files a/inherit_graph_59.png and b/inherit_graph_59.png differ diff --git a/inherit_graph_6.map b/inherit_graph_6.map index ea5108771..428977737 100644 --- a/inherit_graph_6.map +++ b/inherit_graph_6.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_6.md5 b/inherit_graph_6.md5 index fcf73b4ca..433dec8d5 100644 --- a/inherit_graph_6.md5 +++ b/inherit_graph_6.md5 @@ -1 +1 @@ -d9cdeda0f0499a107ef7b9ba53e072e5 \ No newline at end of file +db6b1fba475fa21600fc88fc05b0933d \ No newline at end of file diff --git a/inherit_graph_6.png b/inherit_graph_6.png index a7723732c..480ca2b2b 100644 Binary files a/inherit_graph_6.png and b/inherit_graph_6.png differ diff --git a/inherit_graph_60.map b/inherit_graph_60.map index 80abd0278..57e8de8f6 100644 --- a/inherit_graph_60.map +++ b/inherit_graph_60.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_60.md5 b/inherit_graph_60.md5 index dbd2320db..b1de692be 100644 --- a/inherit_graph_60.md5 +++ b/inherit_graph_60.md5 @@ -1 +1 @@ -27181bb2a8663aecc220cf73a1a33ee4 \ No newline at end of file +7c8657ebec4948f12f72f3ce1ea3e6f1 \ No newline at end of file diff --git a/inherit_graph_60.png b/inherit_graph_60.png index 616d06561..396b85528 100644 Binary files a/inherit_graph_60.png and b/inherit_graph_60.png differ diff --git a/inherit_graph_61.map b/inherit_graph_61.map index a8b498de3..5f531ce63 100644 --- a/inherit_graph_61.map +++ b/inherit_graph_61.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_61.md5 b/inherit_graph_61.md5 index d815e7823..22cdc760c 100644 --- a/inherit_graph_61.md5 +++ b/inherit_graph_61.md5 @@ -1 +1 @@ -fcd13fd54c20a3b15b68df42f79e8750 \ No newline at end of file +ffbb6fc0d194b2ec04de1279609b3259 \ No newline at end of file diff --git a/inherit_graph_61.png b/inherit_graph_61.png index d5e41b427..26a11484c 100644 Binary files a/inherit_graph_61.png and b/inherit_graph_61.png differ diff --git a/inherit_graph_62.map b/inherit_graph_62.map index f63e56225..efb9005ae 100644 --- a/inherit_graph_62.map +++ b/inherit_graph_62.map @@ -1,3 +1,5 @@ - + + + diff --git a/inherit_graph_62.md5 b/inherit_graph_62.md5 index 8f03789a1..78f21e062 100644 --- a/inherit_graph_62.md5 +++ b/inherit_graph_62.md5 @@ -1 +1 @@ -041e5c12848cb9cfed45decbf29ab84a \ No newline at end of file +ed732f965f7fda691bcc3b00421de018 \ No newline at end of file diff --git a/inherit_graph_62.png b/inherit_graph_62.png index 3b0848620..bf2ae8a5e 100644 Binary files a/inherit_graph_62.png and b/inherit_graph_62.png differ diff --git a/inherit_graph_63.map b/inherit_graph_63.map index 286c35707..8a9badaf4 100644 --- a/inherit_graph_63.map +++ b/inherit_graph_63.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_63.md5 b/inherit_graph_63.md5 index a6cb78e10..add945e15 100644 --- a/inherit_graph_63.md5 +++ b/inherit_graph_63.md5 @@ -1 +1 @@ -e0f7a1b094358c98dff7a3cba8246d13 \ No newline at end of file +df08f1e968b4cc2cc7daa157801ed78f \ No newline at end of file diff --git a/inherit_graph_63.png b/inherit_graph_63.png index c561eac44..2470538cf 100644 Binary files a/inherit_graph_63.png and b/inherit_graph_63.png differ diff --git a/inherit_graph_64.map b/inherit_graph_64.map index 41d8fb1ad..7adac6fc2 100644 --- a/inherit_graph_64.map +++ b/inherit_graph_64.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_64.md5 b/inherit_graph_64.md5 index 429fd5c82..2131cdeb4 100644 --- a/inherit_graph_64.md5 +++ b/inherit_graph_64.md5 @@ -1 +1 @@ -266fcd262440912e662749ffd7723e83 \ No newline at end of file +af7001ccbe19c37aec36fd176a0ffac8 \ No newline at end of file diff --git a/inherit_graph_64.png b/inherit_graph_64.png index c476458de..48c622b75 100644 Binary files a/inherit_graph_64.png and b/inherit_graph_64.png differ diff --git a/inherit_graph_65.map b/inherit_graph_65.map index 2c9d579f9..88429a650 100644 --- a/inherit_graph_65.map +++ b/inherit_graph_65.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_65.md5 b/inherit_graph_65.md5 index 7567b4969..86b004f22 100644 --- a/inherit_graph_65.md5 +++ b/inherit_graph_65.md5 @@ -1 +1 @@ -32f62226ed08bbc862cab90e19b0b664 \ No newline at end of file +819b2f7e5f86d24470850ff7ee4e241d \ No newline at end of file diff --git a/inherit_graph_65.png b/inherit_graph_65.png index 6dc9a20bb..cb9c1b01f 100644 Binary files a/inherit_graph_65.png and b/inherit_graph_65.png differ diff --git a/inherit_graph_66.map b/inherit_graph_66.map index 5ae06848a..5d8c2289c 100644 --- a/inherit_graph_66.map +++ b/inherit_graph_66.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_66.md5 b/inherit_graph_66.md5 index 207cf7797..1b01b039c 100644 --- a/inherit_graph_66.md5 +++ b/inherit_graph_66.md5 @@ -1 +1 @@ -7bf5045fb3eeac379a8a02966be19ee1 \ No newline at end of file +ddf3b878e6241ab3d9dc40b5c004b15d \ No newline at end of file diff --git a/inherit_graph_66.png b/inherit_graph_66.png index 05dc24ea3..ab9370ae3 100644 Binary files a/inherit_graph_66.png and b/inherit_graph_66.png differ diff --git a/inherit_graph_67.map b/inherit_graph_67.map index b0c28a377..347a4489a 100644 --- a/inherit_graph_67.map +++ b/inherit_graph_67.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_67.md5 b/inherit_graph_67.md5 index 9c537fb89..4b36cf187 100644 --- a/inherit_graph_67.md5 +++ b/inherit_graph_67.md5 @@ -1 +1 @@ -38369dcd720ab0039d7bc3ae6bd935b7 \ No newline at end of file +044b1a967424a88ee007854389354a9e \ No newline at end of file diff --git a/inherit_graph_67.png b/inherit_graph_67.png index d7273b5ec..7710cef21 100644 Binary files a/inherit_graph_67.png and b/inherit_graph_67.png differ diff --git a/inherit_graph_68.map b/inherit_graph_68.map index 7902bf72e..cbf6e0dba 100644 --- a/inherit_graph_68.map +++ b/inherit_graph_68.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_68.md5 b/inherit_graph_68.md5 index c66e60a30..d4f69cf6a 100644 --- a/inherit_graph_68.md5 +++ b/inherit_graph_68.md5 @@ -1 +1 @@ -452c0cc41e45b4a0855838fb8e7a10ff \ No newline at end of file +9c42650049ecc6696a1dc77887ea11b6 \ No newline at end of file diff --git a/inherit_graph_68.png b/inherit_graph_68.png index abac03b9a..a45a952dc 100644 Binary files a/inherit_graph_68.png and b/inherit_graph_68.png differ diff --git a/inherit_graph_69.map b/inherit_graph_69.map deleted file mode 100644 index 85ec12751..000000000 --- a/inherit_graph_69.map +++ /dev/null @@ -1,3 +0,0 @@ - - - diff --git a/inherit_graph_69.md5 b/inherit_graph_69.md5 deleted file mode 100644 index affeb35a9..000000000 --- a/inherit_graph_69.md5 +++ /dev/null @@ -1 +0,0 @@ -8abb22caca0c349e0d2a583fd575dc99 \ No newline at end of file diff --git a/inherit_graph_69.png b/inherit_graph_69.png deleted file mode 100644 index f5b0eb482..000000000 Binary files a/inherit_graph_69.png and /dev/null differ diff --git a/inherit_graph_7.map b/inherit_graph_7.map index 5f1ff849c..8bf94008c 100644 --- a/inherit_graph_7.map +++ b/inherit_graph_7.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_7.md5 b/inherit_graph_7.md5 index 28fd1bf9b..32db86037 100644 --- a/inherit_graph_7.md5 +++ b/inherit_graph_7.md5 @@ -1 +1 @@ -29c44df76a27214cab398ed06d8d617f \ No newline at end of file +984981c2ee8fa83b4329c07f57168cf1 \ No newline at end of file diff --git a/inherit_graph_7.png b/inherit_graph_7.png index 58b7c76e0..7a36cce0f 100644 Binary files a/inherit_graph_7.png and b/inherit_graph_7.png differ diff --git a/inherit_graph_70.map b/inherit_graph_70.map deleted file mode 100644 index c511abbe7..000000000 --- a/inherit_graph_70.map +++ /dev/null @@ -1,3 +0,0 @@ - - - diff --git a/inherit_graph_70.md5 b/inherit_graph_70.md5 deleted file mode 100644 index da5341960..000000000 --- a/inherit_graph_70.md5 +++ /dev/null @@ -1 +0,0 @@ -1fadc2ef69a803635ec75ea2c3f6a5f2 \ No newline at end of file diff --git a/inherit_graph_70.png b/inherit_graph_70.png deleted file mode 100644 index 270cb90fe..000000000 Binary files a/inherit_graph_70.png and /dev/null differ diff --git a/inherit_graph_71.map b/inherit_graph_71.map deleted file mode 100644 index b11003411..000000000 --- a/inherit_graph_71.map +++ /dev/null @@ -1,4 +0,0 @@ - - - - diff --git a/inherit_graph_71.md5 b/inherit_graph_71.md5 deleted file mode 100644 index c522d3c5e..000000000 --- a/inherit_graph_71.md5 +++ /dev/null @@ -1 +0,0 @@ -8b49e5d4ab6821a094273ac533350361 \ No newline at end of file diff --git a/inherit_graph_71.png b/inherit_graph_71.png deleted file mode 100644 index 9c3ded490..000000000 Binary files a/inherit_graph_71.png and /dev/null differ diff --git a/inherit_graph_72.map b/inherit_graph_72.map deleted file mode 100644 index 84291e569..000000000 --- a/inherit_graph_72.map +++ /dev/null @@ -1,3 +0,0 @@ - - - diff --git a/inherit_graph_72.md5 b/inherit_graph_72.md5 deleted file mode 100644 index 492aeb8b7..000000000 --- a/inherit_graph_72.md5 +++ /dev/null @@ -1 +0,0 @@ -d277977b1425339c8f946591267cbe20 \ No newline at end of file diff --git a/inherit_graph_72.png b/inherit_graph_72.png deleted file mode 100644 index 07279d19a..000000000 Binary files a/inherit_graph_72.png and /dev/null differ diff --git a/inherit_graph_73.map b/inherit_graph_73.map deleted file mode 100644 index 8b565bf7e..000000000 --- a/inherit_graph_73.map +++ /dev/null @@ -1,3 +0,0 @@ - - - diff --git a/inherit_graph_73.md5 b/inherit_graph_73.md5 deleted file mode 100644 index b79b6846b..000000000 --- a/inherit_graph_73.md5 +++ /dev/null @@ -1 +0,0 @@ -621c711cd444e7dcd7b795f1703c5cd0 \ No newline at end of file diff --git a/inherit_graph_73.png b/inherit_graph_73.png deleted file mode 100644 index 3b9f3f3b9..000000000 Binary files a/inherit_graph_73.png and /dev/null differ diff --git a/inherit_graph_74.map b/inherit_graph_74.map deleted file mode 100644 index f3f0e77bd..000000000 --- a/inherit_graph_74.map +++ /dev/null @@ -1,3 +0,0 @@ - - - diff --git a/inherit_graph_74.md5 b/inherit_graph_74.md5 deleted file mode 100644 index 177fc5aa0..000000000 --- a/inherit_graph_74.md5 +++ /dev/null @@ -1 +0,0 @@ -ed043cf7fc8e24545bbc5bcb24759660 \ No newline at end of file diff --git a/inherit_graph_74.png b/inherit_graph_74.png deleted file mode 100644 index 5697d7f2a..000000000 Binary files a/inherit_graph_74.png and /dev/null differ diff --git a/inherit_graph_75.map b/inherit_graph_75.map deleted file mode 100644 index 8c48d78eb..000000000 --- a/inherit_graph_75.map +++ /dev/null @@ -1,3 +0,0 @@ - - - diff --git a/inherit_graph_75.md5 b/inherit_graph_75.md5 deleted file mode 100644 index cc16fa558..000000000 --- a/inherit_graph_75.md5 +++ /dev/null @@ -1 +0,0 @@ -38a5043984aa729fe65aca223c7ae6b5 \ No newline at end of file diff --git a/inherit_graph_75.png b/inherit_graph_75.png deleted file mode 100644 index 1859301ff..000000000 Binary files a/inherit_graph_75.png and /dev/null differ diff --git a/inherit_graph_76.map b/inherit_graph_76.map deleted file mode 100644 index cd9cba107..000000000 --- a/inherit_graph_76.map +++ /dev/null @@ -1,3 +0,0 @@ - - - diff --git a/inherit_graph_76.md5 b/inherit_graph_76.md5 deleted file mode 100644 index dcda05878..000000000 --- a/inherit_graph_76.md5 +++ /dev/null @@ -1 +0,0 @@ -4dcecc0d02b196a20c46b12b739ad30e \ No newline at end of file diff --git a/inherit_graph_76.png b/inherit_graph_76.png deleted file mode 100644 index 0c5a70d46..000000000 Binary files a/inherit_graph_76.png and /dev/null differ diff --git a/inherit_graph_77.map b/inherit_graph_77.map deleted file mode 100644 index d4b0989d5..000000000 --- a/inherit_graph_77.map +++ /dev/null @@ -1,3 +0,0 @@ - - - diff --git a/inherit_graph_77.md5 b/inherit_graph_77.md5 deleted file mode 100644 index 054df0392..000000000 --- a/inherit_graph_77.md5 +++ /dev/null @@ -1 +0,0 @@ -e858ed2f3c399ac5179f89b14a40a3d7 \ No newline at end of file diff --git a/inherit_graph_77.png b/inherit_graph_77.png deleted file mode 100644 index 0c5a70d46..000000000 Binary files a/inherit_graph_77.png and /dev/null differ diff --git a/inherit_graph_8.map b/inherit_graph_8.map index 972e3f3f3..a50858843 100644 --- a/inherit_graph_8.map +++ b/inherit_graph_8.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_8.md5 b/inherit_graph_8.md5 index 6651bb382..9b4d3b7c8 100644 --- a/inherit_graph_8.md5 +++ b/inherit_graph_8.md5 @@ -1 +1 @@ -7e6cf494988715f4dfb34fea66a21c82 \ No newline at end of file +e6b9be63a8f214f5456c5f9a1c76dbe1 \ No newline at end of file diff --git a/inherit_graph_8.png b/inherit_graph_8.png index 09df3da45..241b50b30 100644 Binary files a/inherit_graph_8.png and b/inherit_graph_8.png differ diff --git a/inherit_graph_9.map b/inherit_graph_9.map index 6eb2dea42..c96d9aa87 100644 --- a/inherit_graph_9.map +++ b/inherit_graph_9.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_9.md5 b/inherit_graph_9.md5 index b3ac108ab..60dc209aa 100644 --- a/inherit_graph_9.md5 +++ b/inherit_graph_9.md5 @@ -1 +1 @@ -0a6ddadac75000e74623589449a3947d \ No newline at end of file +8b9bbcdb006a68b13b13b198ff843d09 \ No newline at end of file diff --git a/inherit_graph_9.png b/inherit_graph_9.png index 39cd9edbd..f5af25986 100644 Binary files a/inherit_graph_9.png and b/inherit_graph_9.png differ diff --git a/inherits.html b/inherits.html index 48ac101bf..d9c6628cc 100644 --- a/inherits.html +++ b/inherits.html @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    - - - - - - - - - - - + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + +
    - - +
    + +
    - - - +
    + +
    - - +
    + +
    - - +
    + +
    - - +
    + +
    - - +
    + +
    - - +
    + +
    - - +
    + +
    - - +
    + +
    - - +
    + +
    +
    + + + +
    + + + +
    + + + +
    + + + +
    + + + +
    + + + +
    + + + +
    + + + +
    + + + +
    + + + +
    +
    +
    +
    - - +
    + +
    - - +
    + +
    - - +
    + +
    - - +
    + +
    - - +
    + +
    - - +
    + +
    - - +
    + +
    - - +
    + +
    - - +
    + +
    - - - +
    + +
    - - +
    + +
    - - +
    + +
    - - +
    + +
    - - +
    + +
    - - +
    + +
    - - +
    + +
    - - +
    + +
    - - +
    + +
    - - +
    + + +
    - - +
    + +
    - - +
    + +
    - - +
    + + +
    - - +
    + +
    - - +
    + +
    - - +
    + +
    - - +
    + +
    - - +
    + +
    - - +
    + +
    - - - +
    + +
    - - +
    + +
    - - +
    + +
    - - +
    + +
    - - +
    + +
    - - +
    + +
    - - +
    + + + + + + + + + +
    + + + +
    + + + +
    + + + +
    + + + + + +
    + + + +
    + + + +
    + + + +
    + + + +
    + + + +
    + +
    diff --git a/lib_8md_source.html b/lib_8md_source.html new file mode 100644 index 000000000..08ee8d4b9 --- /dev/null +++ b/lib_8md_source.html @@ -0,0 +1,74 @@ + + + + + + + +EnTT: docs/md/lib.md Source File + + + + + + + + + +
    +
    + + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + +
    + +
    +
    + + +
    + +
    + +
    +
    +
    docs/md/lib.md
    +
    +
    +
    1 # Push EnTT across boundaries
    2 
    3 <!--
    4 @cond TURN_OFF_DOXYGEN
    5 -->
    6 # Table of Contents
    7 
    8 * [Introduction](#introduction)
    9 * [Named types and traits class](#named-types-and-traits-class)
    10  * [Do not mix types](#do-not-mix-types)
    11 * [Macros, macros everywhere](#macros-macros-everywhere)
    12  * [Conflicts](#conflicts)
    13 * [Allocations: the dark side of the force](#allocations-the-dark-side-of-the-force)
    14 <!--
    15 @endcond TURN_OFF_DOXYGEN
    16 -->
    17 
    18 # Introduction
    19 
    20 `EnTT` has historically had a limit when used across boundaries on Windows in
    21 general and on GNU/Linux when default visibility was set to _hidden_. The
    22 limitation is due mainly to a custom utility used to assign unique, sequential
    23 identifiers to different types. Unfortunately, this tool is used by several core
    24 classes (the `registry` among the others) that are thus almost unusable across
    25 boundaries.<br/>
    26 The reasons for that are beyond the purposes of this document. However, the good
    27 news is that `EnTT` also offers now a way to overcome this limit and to push
    28 things across boundaries without problems when needed.
    29 
    30 # Named types and traits class
    31 
    32 To allow a type to work properly across boundaries when used by a class that
    33 requires to assign unique identifiers to types, users must specialize a class
    34 template to literally give a compile-time name to the type itself.<br/>
    35 The name of the class template is `name_type_traits` and the specialization must
    36 be such that it exposes a static constexpr data member named `value` having type
    37 either `ENTT_ID_TYPE` or `entt::hashed_string::hash_type`. Its value is the user
    38 defined unique identifier assigned to the specific type.<br/>
    39 Identifiers are not to be sequentially generated in this case.
    40 
    41 As an example:
    42 
    43 ```cpp
    44 struct my_type { /* ... */ };
    45 
    46 template<>
    47 struct entt::named_type_traits<my_type> {
    48  static constexpr auto value = "my_type"_hs;
    49 };
    50 ```
    51 
    52 Because of the rules of the language, the specialization must reside in the
    53 global namespace or in the `entt` namespace. There is no way to change this rule
    54 unfortunately, because it doesn't depend on the library itself.
    55 
    56 The good aspect of this approach is that it's not intrusive at all. The other
    57 way around was in fact forcing users to inherit all their classes from a common
    58 base. Something to avoid, at least from my point of view.<br/>
    59 However, despite the fact that it's not intrusive, it would be great if it was
    60 also easier to use and a bit less error-prone. This is why a bunch of macros
    61 exist to ease defining named types.
    62 
    63 ## Do not mix types
    64 
    65 Someone might think that this trick is valid only for the types to push across
    66 boundaries. This isn't how things work. In fact, the problem is more complex
    67 than that.<br/>
    68 As a rule of thumb, users should never mix named and non-named types. Whenever
    69 a type is given a name, all the types must be given a name. As an example,
    70 consider the `registry` class template: in case it is pushed across boundaries,
    71 all the types of components should be assigned a name to avoid subtle bugs.
    72 
    73 Indeed, this constraint can be relaxed in many cases. However, it is difficult
    74 to define a general rule to follow that is not the most stringent, unless users
    75 know exactly what they are doing. Therefore, I won't elaborate on giving further
    76 details on the topic.
    77 
    78 # Macros, macros everywhere
    79 
    80 The library comes with a set of predefined macros to use to declare named types
    81 or export already existing ones. In particular:
    82 
    83 * `ENTT_NAMED_TYPE` can be used to assign a name to already existing types. This
    84  macro must be used in the global namespace even when the types to be named are
    85  not.
    86 
    87  ```cpp
    88  ENTT_NAMED_TYPE(my_type)
    89  ENTT_NAMED_TYPE(ns::another_type)
    90  ```
    91 
    92 * `ENTT_NAMED_STRUCT` can be used to define and export a struct at the same
    93  time. It accepts also an optional namespace in which to define the given type.
    94  This macro must be used in the global namespace.
    95 
    96  ```cpp
    97  ENTT_NAMED_STRUCT(my_type, { /* struct definition */})
    98  ENTT_NAMED_STRUCT(ns, another_type, { /* struct definition */})
    99  ```
    100 
    101 * `ENTT_NAMED_CLASS` can be used to define and export a class at the same
    102  time. It accepts also an optional namespace in which to define the given type.
    103  This macro must be used in the global namespace.
    104 
    105  ```cpp
    106  ENTT_NAMED_CLASS(my_type, { /* class definition */})
    107  ENTT_NAMED_CLASS(ns, another_type, { /* class definition */})
    108  ```
    109 
    110 Nested namespaces are supported out of the box as well in all cases. As an
    111 example:
    112 
    113 ```cpp
    114 ENTT_NAMED_STRUCT(nested::ns, my_type, { /* struct definition */})
    115 ```
    116 
    117 These macros can be used to avoid specializing the `named_type_traits` class
    118 template. In all cases, the name of the class is used also as a seed to generate
    119 the compile-time unique identifier.
    120 
    121 ## Conflicts
    122 
    123 When using macros, unique identifiers are 32/64 bit integers generated by
    124 hashing strings during compilation. Therefore, conflicts are rare but still
    125 possible. In case of conflicts, everything simply will get broken at runtime and
    126 the strangest things will probably take place.<br/>
    127 Unfortunately, there is no safe way to prevent it. If this happens, it will be
    128 enough to give a different value to one of the conflicting types to solve the
    129 problem. To do this, users can either assign a different name to the class or
    130 directly define a specialization for the `named_type_traits` class template.
    131 
    132 # Allocations: the dark side of the force
    133 
    134 As long as `EnTT` won't support custom allocators, another problem with
    135 allocations will remain alive instead. This is in fact easily solved, or at
    136 least it is if one knows it.
    137 
    138 To allow users to add types dynamically, the library makes extensive use of type
    139 erasure techniques and dynamic allocations for pools (whether they are for
    140 components, events or anything else). The problem occurs when, for example, a
    141 registry is created on one side of a boundary and a pool is dynamically created
    142 on the other side. In the best case, everything will crash at the exit, while at
    143 worst it will do so at runtime.<br/>
    144 To avoid problems, the pools must be generated from the same side of the
    145 boundary where the object that owns them is also created. As an example, when
    146 the registry is created in the main executable and used across boundaries for a
    147 given type of component, the pool for that type must be created before passing
    148 around the registry itself. To do this is fortunately quite easy, since it is
    149 sufficient to invoke any of the methods that involve the given type (continuing
    150 the example with the registry, a call to `reserve` or `size` is more than
    151 enough).
    152 
    153 Maybe one day some dedicated methods will be added that do nothing but create a
    154 pool for a given type. Until now it has been preferred to keep the API cleaner
    155 as they are not strictly necessary.
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/links_8md_source.html b/links_8md_source.html new file mode 100644 index 000000000..ed7bf9a75 --- /dev/null +++ b/links_8md_source.html @@ -0,0 +1,74 @@ + + + + + + + +EnTT: docs/md/links.md Source File + + + + + + + + + +
    +
    + + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + +
    + +
    +
    + + +
    + +
    + +
    +
    +
    docs/md/links.md
    +
    +
    +
    1 # EnTT in Action
    2 
    3 `EnTT` is widely used in private and commercial applications. I cannot even
    4 mention most of them because of some signatures I put on some documents time
    5 ago. Fortunately, there are also people who took the time to implement open
    6 source projects based on `EnTT` and did not hold back when it came to
    7 documenting them.
    8 
    9 Below an incomplete list of games, applications and articles that can be used as
    10 a reference. Where I put the word _apparently_ means that the use of `EnTT` is
    11 documented but the authors didn't make explicit announcements or contacted me
    12 directly.
    13 
    14 I hope this list can grow much more in the future:
    15 
    16 * Games:
    17  * [Minecraft](https://minecraft.net/en-us/attribution/) by
    18  [Mojang](https://mojang.com/): of course, **that** Minecraft, see the
    19  open source attributions page for more details.
    20  * [Face Smash](https://play.google.com/store/apps/details?id=com.gamee.facesmash):
    21  a game to play with your face.
    22  * [EnTT Pacman](https://github.com/Kerndog73/EnTT-Pacman): an example of how
    23  to make Pacman with `EnTT`.
    24  * [Classic Tower Defence](https://github.com/kerndog73/Classic-Tower-Defence):
    25  a tiny little tower defence game featuring a homemade font.
    26  [Check it out](https://indi-kernick.itch.io/classic-tower-defence).
    27  * [The Machine](https://github.com/Kerndog73/The-Machine): a box pushing
    28  puzzler with logic gates and other cool stuff.
    29  [Check it out](https://indi-kernick.itch.io/the-machine-web-version).
    30  * [EnttPong](https://github.com/reworks/EnttPong): an example of how to make
    31  Pong with `EnTT`.
    32  * [Randballs](https://github.com/gale93/randballs): simple `SFML` and `EnTT`
    33  playground.
    34  * [EnTT Tower Defense](https://github.com/Daivuk/tddod): a data oriented tower
    35  defense example.
    36  * [EnTT Breakout](https://github.com/vblanco20-1/entt-breakout): simple
    37  example of a breakout game, using `SDL` and `EnTT`.
    38 
    39 * Engines/Frameworks:
    40  * [The Forge](https://github.com/ConfettiFX/The-Forge) by
    41  [Confett](http://www.confettispecialfx.com/): a cross-platform rendering
    42  framework.
    43  * [Apparently](https://teamwisp.github.io/credits/)
    44  [Wisp](https://teamwisp.github.io/product/) by
    45  [Team Wisp](https://teamwisp.github.io/): an advanced real-time ray tracing
    46  renderer built for the demands of video game artists.
    47  * [starlight](https://github.com/DomRe/starlight): game programming framework
    48  using `Allegro`, `Lua` and modern C++.
    49  * [Apparently](https://github.com/JosiahWI/qub3d-libdeps)
    50  [Qub3d](https://qub3d.org/): because blocks should be open source.
    51  * [shiva](https://github.com/Milerius/shiva): modern C++ engine with
    52  modularity.
    53 
    54 * Emulators:
    55  * [NovusCore](https://github.com/novuscore/NovusCore): A modern take on World
    56  of Warcraft emulation.
    57 
    58 * Articles and blog posts
    59  * [Some posts](https://skypjack.github.io/tags/#entt) on my personal
    60  [blog](https://skypjack.github.io/) are about `EnTT`, for those who want to
    61  know **more** on this project.
    62  * [Space Battle: Huge edition](http://victor.madtriangles.com/code%20experiment/2018/06/11/post-ecs-battle-huge.html):
    63  huge space battle built entirely from scratch.
    64  * [Space Battle](https://github.com/vblanco20-1/ECS_SpaceBattle): huge space
    65  battle built on `UE4`.
    66  * [Experimenting with ECS in UE4](http://victor.madtriangles.com/code%20experiment/2018/03/25/post-ue4-ecs-battle.html):
    67  interesting article about `UE4` and `EnTT`.
    68  * [Implementing ECS architecture in UE4](https://forums.unrealengine.com/development-discussion/c-gameplay-programming/1449913-implementing-ecs-architecture-in-ue4-giant-space-battle):
    69  giant space battle.
    70  * [Conan Adventures (SFML and EnTT in C++)](https://leinnan.github.io/blog/conan-adventuressfml-and-entt-in-c.html):
    71  create projects in modern C++ using `SFML`, `EnTT`, `Conan` and `CMake`.
    72 
    73 * Any Other Business:
    74  * The [ArcGIS Runtime SDKs](https://developers.arcgis.com/arcgis-runtime/)
    75  by [Esri](https://www.esri.com/): they use `EnTT` for the internal ECS and
    76  the cross platform C++ rendering engine. The SDKs are utilized by a lot of
    77  enterprise custom apps, as well as by Esri for its own public applications
    78  such as
    79  [Explorer](https://play.google.com/store/apps/details?id=com.esri.explorer),
    80  [Collector](https://play.google.com/store/apps/details?id=com.esri.arcgis.collector)
    81  and
    82  [Navigator](https://play.google.com/store/apps/details?id=com.esri.navigator).
    83  * [Apparently](https://www.linkedin.com/in/skypjack/)
    84  [NIO](https://www.nio.io/): there was a collaboration to make some changes
    85  to `EnTT`, at the time used for internal projects.
    86  * [MatchOneEntt](https://github.com/mhaemmerle/MatchOneEntt): port of
    87  [Match One](https://github.com/sschmid/Match-One) for `Entitas-CSharp`.
    88  * GitHub contains also
    89  [many other examples](https://github.com/search?o=desc&q=%22skypjack%2Fentt%22&s=indexed&type=Code)
    90  of use of `EnTT` from which to take inspiration if interested.
    91 
    92 If you know of other resources out there that are about `EnTT`, feel free to
    93 open an issue or a PR and I'll be glad to add them to this page.
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/loader_8hpp_source.html b/loader_8hpp_source.html index 61cebbc45..e75178fc1 100644 --- a/loader_8hpp_source.html +++ b/loader_8hpp_source.html @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.2 +  3.0.0
    + + + + + +
    +
    EnTT +  3.0.0 +
    +
    + + + + + + + + + + +
    +
    + + +
    + +
    + +
    +
    +
    docs/md/meta.md
    +
    +
    +
    1 # Crash Course: reflection system
    2 
    3 <!--
    4 @cond TURN_OFF_DOXYGEN
    5 -->
    6 # Table of Contents
    7 
    8 * [Introduction](#introduction)
    9 * [Reflection in a nutshell](#reflection-in-a-nutshell)
    10 * [Any as in any type](#any-as-in-any-type)
    11 * [Enjoy the runtime](#enjoy-the-runtime)
    12 * [Named constants and enums](#named-constants-and-enums)
    13 * [Properties and meta objects](#properties-and-meta-objects)
    14 * [Unregister types](#unregister-types)
    15 <!--
    16 @endcond TURN_OFF_DOXYGEN
    17 -->
    18 
    19 # Introduction
    20 
    21 Reflection (or rather, its lack) is a trending topic in the C++ world and, in
    22 the specific case of `EnTT`, a tool that can unlock a lot of other features. I
    23 looked for a third-party library that met my needs on the subject, but I always
    24 came across some details that I didn't like: macros, being intrusive, too many
    25 allocations. In one word: unsatisfactory.<br/>
    26 I finally decided to write a built-in, non-intrusive and macro-free runtime
    27 reflection system for `EnTT`. Maybe I didn't do better than others or maybe yes,
    28 time will tell me, but at least I can model this tool around the library to
    29 which it belongs and not vice versa.
    30 
    31 # Reflection in a nutshell
    32 
    33 Reflection always starts from real types (users cannot reflect imaginary types
    34 and it would not make much sense, we wouldn't be talking about reflection
    35 anymore).<br/>
    36 To _reflect_ a type, the library provides the `reflect` function:
    37 
    38 ```cpp
    39 auto factory = entt::reflect<my_type>("reflected_type");
    40 ```
    41 
    42 It accepts the type to reflect as a template parameter and an optional name as
    43 an argument. Names are important because users can retrieve meta types at
    44 runtime by searching for them by name. However, there are cases in which users
    45 can be interested in adding features to a reflected type so that the reflection
    46 system can use it correctly under the hood, but they don't want to allow
    47 searching the type by name.<br/>
    48 In both cases, the returned value is a factory object to use to continue
    49 building the meta type.
    50 
    51 A factory is such that all its member functions returns the factory itself.
    52 It can be used to extend the reflected type and add the following:
    53 
    54 * _Constructors_. Actual constructors can be assigned to a reflected type by
    55  specifying their list of arguments. Free functions (namely, factories) can be
    56  used as well, as long as the return type is the expected one. From a client's
    57  point of view, nothing changes if a constructor is a free function or an
    58  actual constructor.<br/>
    59  Use the `ctor` member function for this purpose:
    60 
    61  ```cpp
    62  entt::reflect<my_type>("reflected").ctor<int, char>().ctor<&factory>();
    63  ```
    64 
    65 * _Destructors_. Free functions can be set as destructors of reflected types.
    66  The purpose is to give users the ability to free up resources that require
    67  special treatment before an object is actually destroyed.<br/>
    68  Use the `dtor` member function for this purpose:
    69 
    70  ```cpp
    71  entt::reflect<my_type>("reflected").dtor<&destroy>();
    72  ```
    73 
    74 * _Data members_. Both real data members of the underlying type and static and
    75  global variables, as well as constants of any kind, can be attached to a meta
    76  type. From a client's point of view, all the variables associated with the
    77  reflected type will appear as if they were part of the type itself.<br/>
    78  Use the `data` member function for this purpose:
    79 
    80  ```cpp
    81  entt::reflect<my_type>("reflected")
    82  .data<&my_type::static_variable>("static")
    83  .data<&my_type::data_member>("member")
    84  .data<&global_variable>("global");
    85  ```
    86 
    87  This function requires as an argument the name to give to the meta data once
    88  created. Users can then access meta data at runtime by searching for them by
    89  name.<br/>
    90  Data members can be set also by means of a couple of functions, namely a
    91  setter and a getter. Setters and getters can be either free functions, member
    92  functions or mixed ones, as long as they respect the required signatures.<br/>
    93  Refer to the inline documentation for all the details.
    94 
    95 * _Member functions_. Both real member functions of the underlying type and free
    96  functions can be attached to a meta type. From a client's point of view, all
    97  the functions associated with the reflected type will appear as if they were
    98  part of the type itself.<br/>
    99  Use the `func` member function for this purpose:
    100 
    101  ```cpp
    102  entt::reflect<my_type>("reflected")
    103  .func<&my_type::static_function>("static")
    104  .func<&my_type::member_function>("member")
    105  .func<&free_function>("free");
    106  ```
    107 
    108  This function requires as an argument the name to give to the meta function
    109  once created. Users can then access meta functions at runtime by searching for
    110  them by name.
    111 
    112 * _Base classes_. A base class is such that the underlying type is actually
    113  derived from it. In this case, the reflection system tracks the relationship
    114  and allows for implicit casts at runtime when required.<br/>
    115  Use the `base` member function for this purpose:
    116 
    117  ```cpp
    118  entt::reflect<derived_type>("derived").base<base_type>();
    119  ```
    120 
    121  From now on, wherever a `base_type` is required, an instance of `derived_type`
    122  will also be accepted.
    123 
    124 * _Conversion functions_. Actual types can be converted, this is a fact. Just
    125  think of the relationship between a `double` and an `int` to see it. Similar
    126  to bases, conversion functions allow users to define conversions that will be
    127  implicitly performed by the reflection system when required.<br/>
    128  Use the `conv` member function for this purpose:
    129 
    130  ```cpp
    131  entt::reflect<double>().conv<int>();
    132  ```
    133 
    134 That's all, everything users need to create meta types and enjoy the reflection
    135 system. At first glance it may not seem that much, but users usually learn to
    136 appreciate it over time.<br/>
    137 Also, do not forget what these few lines hide under the hood: a built-in,
    138 non-intrusive and macro-free system for reflection in C++. Features that are
    139 definitely worth the price, at least for me.
    140 
    141 # Any as in any type
    142 
    143 The reflection system comes with its own meta any type. It may seem redundant
    144 since C++17 introduced `std::any`, but it is not.<br/>
    145 In fact, the _type_ returned by an `std::any` is a const reference to an
    146 `std::type_info`, an implementation defined class that's not something everyone
    147 wants to see in a software. Furthermore, the class `std::type_info` suffers from
    148 some design flaws and there is even no way to _convert_ an `std::type_info` into
    149 a meta type, thus linking the two worlds.
    150 
    151 A meta any object provides an API similar to that of its most famous counterpart
    152 and serves the same purpose of being an opaque container for any type of
    153 value.<br/>
    154 It minimizes the allocations required, which are almost absent thanks to _SBO_
    155 techniques. In fact, unless users deal with _fat types_ and create instances of
    156 them though the reflection system, allocations are at zero.
    157 
    158 A meta any object can be created by any other object or as an empty container
    159 to initialize later:
    160 
    161 ```cpp
    162 // a meta any object that contains an int
    163 entt::meta_any any{0};
    164 
    165 // an empty meta any object
    166 entt::meta_any empty{};
    167 ```
    168 
    169 It can be constructed or assigned by copy and move and it takes the burden of
    170 destroying the contained object when required.<br/>
    171 A meta any object has a `type` member function that returns the meta type of the
    172 contained value, if any. The member functions `can_cast` and `can_convert` are
    173 used to know if the underlying object has a given type as a base or if it can be
    174 converted implicitly to it. Similarly, `cast` and `convert` do what they promise
    175 and return the expected value.
    176 
    177 # Enjoy the runtime
    178 
    179 Once the web of reflected types has been constructed, it's a matter of using it
    180 at runtime where required.<br/>
    181 All this has the great merit that, unlike the vast majority of the things
    182 present in this library and closely linked to the compile-time, the reflection
    183 system stands in fact as a non-intrusive tool for the runtime.
    184 
    185 To search for a reflected type there are two options: by type or by name. In
    186 both cases, the search can be done by means of the `resolve` function:
    187 
    188 ```cpp
    189 // search for a reflected type by type
    190 auto by_type = entt::resolve<my_type>();
    191 
    192 // search for a reflected type by name
    193 auto by_name = entt::resolve("reflected_type");
    194 ```
    195 
    196 There exits also a third overload of the `resolve` function to use to iterate
    197 all the reflected types at once:
    198 
    199 ```cpp
    200 resolve([](auto type) {
    201  // ...
    202 });
    203 ```
    204 
    205 In all cases, the returned value is an instance of `meta_type`. This type of
    206 objects offer an API to know the _runtime name_ of the type, to iterate all the
    207 meta objects associated with them and even to build or destroy instances of the
    208 underlying type.<br/>
    209 Refer to the inline documentation for all the details.
    210 
    211 The meta objects that compose a meta type are accessed in the following ways:
    212 
    213 * _Meta constructors_. They are accessed by types of arguments:
    214 
    215  ```cpp
    216  auto ctor = entt::resolve<my_type>().ctor<int, char>();
    217  ```
    218 
    219  The returned type is `meta_ctor` and may be invalid if there is no constructor
    220  that accepts the supplied arguments or at least some types from which they are
    221  derived or to which they can be converted.<br/>
    222  A meta constructor offers an API to know the number of arguments, the expected
    223  meta types and to invoke it, therefore to construct a new instance of the
    224  underlying type.
    225 
    226 * _Meta destructor_. It's returned by a dedicated function:
    227 
    228  ```cpp
    229  auto dtor = entt::resolve<my_type>().dtor();
    230  ```
    231 
    232  The returned type is `meta_dtor` and may be invalid if there is no custom
    233  destructor set for the given meta type.<br/>
    234  All what a meta destructor has to offer is a way to invoke it on a given
    235  instance. Be aware that the result may not be what is expected.
    236 
    237 * _Meta data_. They are accessed by name:
    238 
    239  ```cpp
    240  auto data = entt::resolve<my_type>().data("member");
    241  ```
    242 
    243  The returned type is `meta_data` and may be invalid if there is no meta data
    244  object associated with the given name.<br/>
    245  A meta data object offers an API to query the underlying type (ie to know if
    246  it's a const or a static one), to get the meta type of the variable and to set
    247  or get the contained value.
    248 
    249 * _Meta functions_. They are accessed by name:
    250 
    251  ```cpp
    252  auto func = entt::resolve<my_type>().func("member");
    253  ```
    254 
    255  The returned type is `meta_func` and may be invalid if there is no meta
    256  function object associated with the given name.<br/>
    257  A meta function object offers an API to query the underlying type (ie to know
    258  if it's a const or a static function), to know the number of arguments, the
    259  meta return type and the meta types of the parameters. In addition, a meta
    260  function object can be used to invoke the underlying function and then get the
    261  return value in the form of meta any object.
    262 
    263 
    264 * _Meta bases_. They are accessed through the name of the base types:
    265 
    266  ```cpp
    267  auto base = entt::resolve<derived_type>().base("base");
    268  ```
    269 
    270  The returned type is `meta_base` and may be invalid if there is no meta base
    271  object associated with the given name.<br/>
    272  Meta bases aren't meant to be used directly, even though they are freely
    273  accessible. They expose only a few methods to use to know the meta type of the
    274  base class and to convert a raw pointer between types.
    275 
    276 * _Meta conversion functions_. They are accessed by type:
    277 
    278  ```cpp
    279  auto conv = entt::resolve<double>().conv<int>();
    280  ```
    281 
    282  The returned type is `meta_conv` and may be invalid if there is no meta
    283  conversion function associated with the given type.<br/>
    284  The meta conversion functions are as thin as the meta bases and with a very
    285  similar interface. The sole difference is that they return a newly created
    286  instance wrapped in a meta any object when they convert between different
    287  types.
    288 
    289 All the objects thus obtained as well as the meta types can be explicitly
    290 converted to a boolean value to check if they are valid:
    291 
    292 ```cpp
    293 auto func = entt::resolve<my_type>().func("member");
    294 
    295 if(func) {
    296  // ...
    297 }
    298 ```
    299 
    300 Furthermore, all meta objects with the exception of meta destructors can be
    301 iterated through an overload that accepts a callback through which to return
    302 them. As an example:
    303 
    304 ```cpp
    305 entt::resolve<my_type>().data([](auto data) {
    306  // ...
    307 });
    308 ```
    309 
    310 A meta type can also be used to `construct` or `destroy` actual instances of the
    311 underlying type.<br/>
    312 In particular, the `construct` member function accepts a variable number of
    313 arguments and searches for a match. It returns a `meta_any` object that may or
    314 may not be initialized, depending on whether a suitable constructor has been
    315 found or not. On the other side, the `destroy` member function accepts instances
    316 of `meta_any` as well as actual objects by reference and invokes the registered
    317 destructor if any or a default one.<br/>
    318 Be aware that the result of a call to `destroy` may not be what is expected.
    319 
    320 Meta types and meta objects in general contain much more than what is said: a
    321 plethora of functions in addition to those listed whose purposes and uses go
    322 unfortunately beyond the scope of this document.<br/>
    323 I invite anyone interested in the subject to look at the code, experiment and
    324 read the official documentation to get the best out of this powerful tool.
    325 
    326 # Named constants and enums
    327 
    328 A special mention should be made for constant values and enums. It wouldn't be
    329 necessary, but it will help distracted readers.
    330 
    331 As mentioned, the `data` member function can be used to reflect constants of any
    332 type among the other things.<br/>
    333 This allows users to create meta types for enums that will work exactly like any
    334 other meta type built from a class. Similarly, arithmetic types can be enriched
    335 with constants of special meaning where required.<br/>
    336 Personally, I find it very useful not to export what is the difference between
    337 enums and classes in C++ directly in the space of the reflected types.
    338 
    339 All the values thus exported will appear to users as if they were constant data
    340 members of the reflected types.
    341 
    342 Exporting constant values or elements from an enum is as simple as ever:
    343 
    344 ```cpp
    345 entt::reflect<my_enum>()
    346  .data<my_enum::a_value>("a_value")
    347  .data<my_enum::another_value>("another_value");
    348 
    349 entt::reflect<int>().data<2048>("max_int");
    350 ```
    351 
    352 It goes without saying that accessing them is trivial as well. It's a matter of
    353 doing the following, as with any other data member of a meta type:
    354 
    355 ```cpp
    356 auto value = entt::resolve<my_enum>().data("a_value").get({}).cast<my_enum>();
    357 auto max = entt::resolve<int>().data("max_int").get({}).cast<int>();
    358 ```
    359 
    360 As a side note, remember that all this happens behind the scenes without any
    361 allocation because of the small object optimization performed by the meta any
    362 class.
    363 
    364 # Properties and meta objects
    365 
    366 Sometimes (ie when it comes to creating an editor) it might be useful to be able
    367 to attach properties to the meta objects created. Fortunately, this is possible
    368 for most of them.<br/>
    369 To attach a property to a meta object, no matter what as long as it supports
    370 properties, it is sufficient to provide an object at the time of construction
    371 such that `std::get<0>` and `std::get<1>` are valid for it. In other terms, the
    372 properties are nothing more than key/value pairs users can put in an
    373 `std::pair`. As an example:
    374 
    375 ```cpp
    376 entt::reflect<my_type>("reflected", std::make_pair("tooltip"_hs, "message"));
    377 ```
    378 
    379 The meta objects that support properties offer then a couple of member functions
    380 named `prop` to iterate them at once and to search a specific property by key:
    381 
    382 ```cpp
    383 // iterate all the properties of a meta type
    384 entt::resolve<my_type>().prop([](auto prop) {
    385  // ...
    386 });
    387 
    388 // search for a given property by name
    389 auto prop = entt::resolve<my_type>().prop("tooltip"_hs);
    390 ```
    391 
    392 Meta properties are objects having a fairly poor interface, all in all. They
    393 only provide the `key` and the `value` member functions to be used to retrieve
    394 the key and the value contained in the form of meta any objects, respectively.
    395 
    396 # Unregister types
    397 
    398 A type registered with the reflection system can also be unregistered. This
    399 means unregistering all its data members, member functions, conversion functions
    400 and so on. However, the base classes won't be unregistered, since they don't
    401 necessarily depend on it. Similarly, implicitly generated types (as an example,
    402 the meta types implicitly generated for function parameters when needed) won't
    403 be unregistered.
    404 
    405 To unregister a type, users can use the `unregister` function from the global
    406 namespace:
    407 
    408 ```cpp
    409 entt::unregister<my_type>();
    410 ```
    411 
    412 This function returns a boolean value that is true if the type is actually
    413 registered with the reflection system, false otherwise.<br/>
    414 The type can be re-registered later with a completely different name and form.
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/monostate_8hpp_source.html b/monostate_8hpp_source.html index ced16ca02..5a6ec6a9a 100644 --- a/monostate_8hpp_source.html +++ b/monostate_8hpp_source.html @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -113,252 +149,611 @@ Classes - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    Classes

    struct  Actor
     Dedicated to those who aren't confident with entity-component systems. More...
    struct  as_group
     Converts a registry to a group. More...
     
    class  Attachee
     Attachee. More...
    struct  as_view
     Converts a registry to a view. More...
     
    class  Attachee< Entity >
     Basic attachee implementation. More...
    class  basic_actor
     Dedicated to those who aren't confident with entity-component systems. More...
     
    class  Attachee< Entity, Type >
     Extended attachee implementation. More...
    class  basic_continuous_loader
     Utility class for continuous loading. More...
     
    class  ContinuousLoader
     Utility class for continuous loading. More...
    class  basic_group
     Group. More...
     
    class  Delegate
     Basic delegate implementation. More...
    class  basic_group< Entity, get_t< Get... > >
     Non-owning group. More...
     
    class  Delegate< Ret(Args...)>
     Utility class to send around functions and member functions. More...
    class  basic_group< Entity, get_t< Get... >, Owned... >
     Owning group. More...
     
    class  Dispatcher
     Basic dispatcher implementation. More...
    class  basic_prototype
     Prototype container for concepts. More...
     
    class  Emitter
     General purpose event emitter. More...
    class  basic_registry
     Fast and reliable entity-component system. More...
     
    class  basic_runtime_view
     Runtime view. More...
     
    class  basic_snapshot
     Utility class to create snapshots from a registry. More...
     
    class  basic_snapshot_loader
     Utility class to restore a snapshot as a whole. More...
     
    class  basic_storage
     Basic storage implementation. More...
     
    class  basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >
     Basic storage implementation. More...
     
    class  basic_view
     Multi component view. More...
     
    class  basic_view< Entity, Component >
     Single component view specialization. More...
     
    struct  connect_arg_t
     Used to wrap a function or a member of a specified type. More...
     
    class  delegate
     Basic delegate implementation. More...
     
    class  delegate< Ret(Args...)>
     Utility class to use to send around functions and members. More...
     
    class  dispatcher
     Basic dispatcher implementation. More...
     
    class  emitter
     General purpose event emitter. More...
     
    struct  entt_traits
     Entity traits. More...
    struct  entt_traits< std::uint64_t >
     Entity traits for a 64 bits entity identifier. More...
     
    class  Family
     Dynamic identifier generator. More...
    struct  exclude_t
     Alias for exclusion lists. More...
     
    class  HashedString
     Zero overhead resource identifier. More...
    class  family
     Dynamic identifier generator. More...
     
    class  Identifier
     Types identifiers. More...
    struct  get_t
     Alias for lists of observed components. More...
     
    struct  InsertionSort
     Function object for performing insertion sort. More...
    class  hashed_string
     Zero overhead unique identifier. More...
     
    struct  Monostate
     Minimal implementation of the monostate pattern. More...
    class  identifier
     Types identifiers. More...
     
    struct  OneShotBubbleSort
     Function object for performing bubble sort (single iteration). More...
    struct  insertion_sort
     Function object for performing insertion sort. More...
     
    struct  persistent_t
     Persistent view type used to disambiguate overloads. More...
    struct  is_named_type
     Provides the member constant value to true if a given type has a name. In all other cases, value is false. More...
     
    class  PersistentView
     Persistent view. More...
    struct  is_named_type< Type, std::void_t< named_type_traits_t< std::decay_t< Type > > > >
     Provides the member constant value to true if a given type has a name. In all other cases, value is false. More...
     
    class  Process
     Base class for processes. More...
    class  meta_any
     Meta any object. More...
     
    struct  ProcessAdaptor
     Adaptor for lambdas and functors to turn them into processes. More...
    class  meta_base
     Meta base object. More...
     
    class  Prototype
     Prototype container for concepts. More...
    class  meta_conv
     Meta conversion function object. More...
     
    struct  raw_t
     Raw view type used to disambiguate overloads. More...
    class  meta_ctor
     Meta constructor object. More...
     
    class  RawView
     Raw view. More...
    class  meta_data
     Meta data object. More...
     
    class  Registry
     Fast and reliable entity-component system. More...
    class  meta_dtor
     Meta destructor object. More...
     
    class  ResourceCache
     Simple cache for resources of a given type. More...
    class  meta_factory
     A meta factory to be used for reflection purposes. More...
     
    class  ResourceHandle
     Shared resource handle. More...
    class  meta_func
     Meta function object. More...
     
    class  ResourceLoader
     Base class for resource loaders. More...
    class  meta_handle
     Meta handle object. More...
     
    class  RuntimeView
     Runtime view. More...
    class  meta_prop
     Meta property object. More...
     
    class  Scheduler
     Cooperative scheduler for processes. More...
    class  meta_type
     Meta type object. More...
     
    struct  ServiceLocator
     Service locator, nothing more. More...
    struct  monostate
     Minimal implementation of the monostate pattern. More...
     
    class  SigH
     Unmanaged signal handler declaration. More...
    struct  named_type_traits
     Traits class used mainly to push things across boundaries. More...
     
    class  SigH< Ret(Args...), Collector >
     Unmanaged signal handler definition. More...
    struct  named_type_traits< const Type >
     Specialization used to get rid of constness. More...
     
    class  Sink
     Sink implementation. More...
    class  process
     Base class for processes. More...
     
    class  Sink< Ret(Args...)>
     Sink implementation. More...
    struct  process_adaptor
     Adaptor for lambdas and functors to turn them into processes. More...
     
    class  Snapshot
     Utility class to create snapshots from a registry. More...
    class  resource_cache
     Simple cache for resources of a given type. More...
     
    class  SnapshotLoader
     Utility class to restore a snapshot as a whole. More...
    class  resource_handle
     Shared resource handle. More...
     
    class  SparseSet
     Sparse set. More...
    class  resource_loader
     Base class for resource loaders. More...
     
    class  SparseSet< Entity >
     Basic sparse set implementation. More...
    class  scheduler
     Cooperative scheduler for processes. More...
     
    class  SparseSet< Entity, Type >
     Extended sparse set implementation. More...
    struct  service_locator
     Service locator, nothing more. More...
     
    struct  StdSort
     Function object to wrap std::sort in a class type. More...
    class  sigh
     Unmanaged signal handler declaration. More...
     
    struct  tag_t
     Tag class type used to disambiguate overloads. More...
    struct  sigh< Ret(Args...), Collector >
     Unmanaged signal handler definition. More...
     
    class  View
     Multi component view. More...
    class  sink
     Sink implementation. More...
     
    class  View< Entity, Component >
     Single component view specialization. More...
    class  sink< Ret(Args...)>
     Sink implementation. More...
     
    class  sparse_set
     Basic sparse set implementation. More...
     
    struct  std_sort
     Function object to wrap std::sort in a class type. More...
     
    struct  storage
     Basic storage implementation. More...
     
    struct  type_list
     A class to use to push around lists of types, nothing more. More...
     
    struct  type_list_cat
     Primary template isn't defined on purpose. More...
     
    struct  type_list_cat< type_list< Type... > >
     Concatenates multiple type lists. More...
     
    struct  type_list_cat< type_list< Type... >, type_list< Other... >, List... >
     Concatenates multiple type lists. More...
     
    struct  type_list_unique
     Primary template isn't defined on purpose. More...
     
    struct  type_list_unique< type_list< Type, Other... > >
     Removes duplicates types from a type list. More...
     
    struct  type_list_unique< type_list<> >
     Removes duplicates types from a type list. More...
     
    - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    Typedefs

    using DefaultActor = Actor< DefaultRegistry::entity_type >
     Default actor class. More...
     
    template<typename HashedString::hash_type Value>
    using label = std::integral_constant< typename HashedString::hash_type, Value >
     Alias template to ease the assignment of labels to entities. More...
     
    using DefaultPrototype = Prototype< DefaultRegistry::entity_type >
     Default prototype. More...
     
    using DefaultRegistry = Registry< std::uint32_t >
     Default registry class. More...
     
    template<typename... List>
    using type_list_cat_t = typename type_list_cat< List... >::type
     Helper type. More...
     
    template<typename Type >
    using type_list_unique_t = typename type_list_unique< Type >::type
     Helper type. More...
     
    template<typename Type >
    using named_type_traits_t = typename named_type_traits< Type >::type
     Helper type. More...
     
    +using entity = std::uint32_t
     Alias declaration for the most common use case.
     
    +using registry = basic_registry< entity >
     Alias declaration for the most common use case.
     
    +using actor = basic_actor< entity >
     Alias declaration for the most common use case.
     
    +using prototype = basic_prototype< entity >
     Alias declaration for the most common use case.
     
    +using snapshot = basic_snapshot< entity >
     Alias declaration for the most common use case.
     
    +using snapshot_loader = basic_snapshot_loader< entity >
     Alias declaration for the most common use case.
     
    +using continuous_loader = basic_continuous_loader< entity >
     Alias declaration for the most common use case.
     
    template<typename... Types>
    using view = basic_view< entity, Types... >
     Alias declaration for the most common use case. More...
     
    +using runtime_view = basic_runtime_view< entity >
     Alias declaration for the most common use case.
     
    template<typename... Types>
    using group = basic_group< entity, Types... >
     Alias declaration for the most common use case. More...
     
    template<typename hashed_string::hash_type Value>
    using tag = std::integral_constant< typename hashed_string::hash_type, Value >
     Alias template to ease the assignment of tags to entities. More...
     
    - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    Functions

    constexpr bool operator!= (const HashedString &lhs, const HashedString &rhs) ENTT_NOEXCEPT
     Compares two hashed strings. More...
     
    template<typename Entity , typename... Component>
    void dependency (Registry< Entity > &registry, const Entity entity)
     Dependency function prototype. More...
     
    template<typename... Dependency, typename Entity >
    void connect (Sink< void(Registry< Entity > &, const Entity)> sink)
     Connects a dependency function to the given sink. More...
     
    template<typename... Dependency, typename Entity >
    void disconnect (Sink< void(Registry< Entity > &, const Entity)> sink)
     Disconnects a dependency function from the given sink. More...
     
    template<typename Ret , typename... Args>
    bool operator!= (const Delegate< Ret(Args...)> &lhs, const Delegate< Ret(Args...)> &rhs) ENTT_NOEXCEPT
     Checks if the contents of the two delegates are different. More...
     
    template<typename Ret , typename... Args>
    bool operator!= (const SigH< Ret(Args...)> &lhs, const SigH< Ret(Args...)> &rhs) ENTT_NOEXCEPT
     Checks if the contents of the two signals are different. More...
     
    constexpr bool operator!= (const hashed_string &lhs, const hashed_string &rhs) ENTT_NOEXCEPT
     Compares two hashed strings. More...
     
    template<typename Type , typename Class >
    constexpr auto overload (Type Class::*member)
     Constant utility to disambiguate overloaded member functions. More...
     
    template<typename Type >
    constexpr auto overload (Type *func)
     Constant utility to disambiguate overloaded functions. More...
     
    template<typename Entity >
     as_view (basic_registry< Entity > &) ENTT_NOEXCEPT -> as_view< false, Entity >
     Deduction guide. More...
     
    template<typename Entity >
     as_view (const basic_registry< Entity > &) ENTT_NOEXCEPT -> as_view< true, Entity >
     Deduction guide. More...
     
    template<typename Entity >
     as_group (basic_registry< Entity > &) ENTT_NOEXCEPT -> as_group< false, Entity >
     Deduction guide. More...
     
    template<typename Entity >
     as_group (const basic_registry< Entity > &) ENTT_NOEXCEPT -> as_group< true, Entity >
     Deduction guide. More...
     
    template<typename Entity , typename Component , typename... Dependency>
    void dependency (basic_registry< Entity > &reg, const Entity entt, const Component &)
     Dependency function prototype. More...
     
    template<typename... Dependency, typename Component , typename Entity >
    void connect (sink< void(basic_registry< Entity > &, const Entity, Component &)> sink)
     Connects a dependency function to the given sink. More...
     
    template<typename... Dependency, typename Component , typename Entity >
    void disconnect (sink< void(basic_registry< Entity > &, const Entity, Component &)> sink)
     Disconnects a dependency function from the given sink. More...
     
    template<typename Type , typename... Property>
    meta_factory< Type > reflect (const char *str, Property &&... property) ENTT_NOEXCEPT
     Basic function to use for reflection. More...
     
    template<typename Type >
    bool unregister () ENTT_NOEXCEPT
     Basic function to unregister a type. More...
     
    template<typename Type >
    meta_factory< Type > reflect () ENTT_NOEXCEPT
     Basic function to use for reflection. More...
     
    template<typename Type >
    meta_type resolve () ENTT_NOEXCEPT
     Returns the meta type associated with a given type. More...
     
    meta_type resolve (const char *str) ENTT_NOEXCEPT
     Returns the meta type associated with a given name. More...
     
    template<typename Op >
    void resolve (Op op) ENTT_NOEXCEPT
     Iterates all the reflected types. More...
     
    bool operator!= (const meta_any &lhs, const meta_any &rhs) ENTT_NOEXCEPT
     Checks if two containers differ in their content. More...
     
    bool operator!= (const meta_prop &lhs, const meta_prop &rhs) ENTT_NOEXCEPT
     Checks if two meta objects refer to the same node. More...
     
    bool operator!= (const meta_base &lhs, const meta_base &rhs) ENTT_NOEXCEPT
     Checks if two meta objects refer to the same node. More...
     
    bool operator!= (const meta_conv &lhs, const meta_conv &rhs) ENTT_NOEXCEPT
     Checks if two meta objects refer to the same node. More...
     
    bool operator!= (const meta_ctor &lhs, const meta_ctor &rhs) ENTT_NOEXCEPT
     Checks if two meta objects refer to the same node. More...
     
    bool operator!= (const meta_dtor &lhs, const meta_dtor &rhs) ENTT_NOEXCEPT
     Checks if two meta objects refer to the same node. More...
     
    bool operator!= (const meta_data &lhs, const meta_data &rhs) ENTT_NOEXCEPT
     Checks if two meta objects refer to the same node. More...
     
    bool operator!= (const meta_func &lhs, const meta_func &rhs) ENTT_NOEXCEPT
     Checks if two meta objects refer to the same node. More...
     
    bool operator!= (const meta_type &lhs, const meta_type &rhs) ENTT_NOEXCEPT
     Checks if two meta objects refer to the same node. More...
     
    template<typename Ret , typename... Args>
    bool operator!= (const delegate< Ret(Args...)> &lhs, const delegate< Ret(Args...)> &rhs) ENTT_NOEXCEPT
     Checks if the connected functions differ. More...
     
    template<auto Function>
     delegate (connect_arg_t< Function >) ENTT_NOEXCEPT -> delegate< std::remove_pointer_t< decltype(internal::to_function_pointer(Function))>>
     Deduction guide. More...
     
    template<auto Candidate, typename Type >
     delegate (connect_arg_t< Candidate >, Type *) ENTT_NOEXCEPT -> delegate< std::remove_pointer_t< decltype(internal::to_function_pointer(Candidate, std::declval< Type *>()))>>
     Deduction guide. More...
     
    - + + + + + + + + + + + + + + + + + + + + +

    Variables

    constexpr auto null = internal::Null{}
    template<hashed_string::hash_type Value>
    monostate< Value > monostate_v = {}
     Helper variable template. More...
     
    template<class Type >
    constexpr auto is_named_type_v = is_named_type<Type>::value
     Helper variable template. More...
     
    constexpr auto null = internal::null{}
     Null entity. More...
     
    template<typename... Type>
    constexpr get_t< Type... > get {}
     Variable template for lists of observed components. More...
     
    template<typename... Type>
    constexpr exclude_t< Type... > exclude {}
     Variable template for exclusion lists. More...
     
    +template<auto Func>
    constexpr connect_arg_t< Func > connect_arg {}
     Constant of type connect_arg_t used to disambiguate calls.
     

    Detailed Description

    EnTT default namespace.

    Typedef Documentation

    - -

    ◆ DefaultActor

    - -
    -
    - - - - -
    using entt::DefaultActor = typedef Actor<DefaultRegistry::entity_type>
    -
    - -

    Default actor class.

    -

    The default actor is the best choice for almost all the applications.
    - Users should have a really good reason to choose something different.

    - -

    Definition at line 237 of file actor.hpp.

    - -
    -
    - -

    ◆ DefaultPrototype

    - -
    -
    - - - - -
    using entt::DefaultPrototype = typedef Prototype<DefaultRegistry::entity_type>
    -
    - -

    Default prototype.

    -

    The default prototype is the best choice for almost all the applications.
    - Users should have a really good reason to choose something different.

    - -

    Definition at line 491 of file prototype.hpp.

    - -
    -
    - -

    ◆ DefaultRegistry

    - -
    -
    - - - - -
    using entt::DefaultRegistry = typedef Registry<std::uint32_t>
    -
    - -

    Default registry class.

    -

    The default registry is the best choice for almost all the applications.
    - Users should have a really good reason to choose something different.

    - -

    Definition at line 1656 of file registry.hpp.

    - -
    -
    - -

    ◆ label

    + +

    ◆ group

    -template<typename HashedString::hash_type Value>
    +template<typename... Types>
    - +
    using entt::label = typedef std::integral_constant<typename HashedString::hash_type, Value>using entt::group = typedef basic_group<entity, Types...>
    -

    Alias template to ease the assignment of labels to entities.

    -

    If used in combination with hashed strings, it simplifies the assignment of labels to entities and the use of labels in general where a type would be required otherwise.
    - As an example and where the user defined literal for hashed strings hasn't been changed:

    entt::DefaultRegistry registry;
    registry.assign<entt::label<"enemy"_hs>>(entity);
    Template Parameters
    +

    Alias declaration for the most common use case.

    +
    Template Parameters
    + + +
    TypesTypes of components iterated by the group.
    +
    +
    + +

    Definition at line 83 of file fwd.hpp.

    + +
    + + +

    ◆ named_type_traits_t

    + +
    +
    +
    +template<typename Type >
    + + + + +
    using entt::named_type_traits_t = typedef typename named_type_traits<Type>::type
    +
    + +

    Helper type.

    +
    Template Parameters
    + + +
    TypePotentially named type.
    +
    +
    + +

    Definition at line 117 of file type_traits.hpp.

    + +
    +
    + +

    ◆ tag

    + +
    +
    +
    +template<typename hashed_string::hash_type Value>
    + + + + +
    using entt::tag = typedef std::integral_constant<typename hashed_string::hash_type, Value>
    +
    + +

    Alias template to ease the assignment of tags to entities.

    +

    If used in combination with hashed strings, it simplifies the assignment of tags to entities and the use of tags in general where a type would be required otherwise.
    + As an example and where the user defined literal for hashed strings hasn't been changed:

    entt::registry registry;
    registry.assign<entt::tag<"enemy"_hs>>(entity);
    Note
    Tags are empty components and therefore candidates for the empty component optimization.
    +
    Template Parameters
    ValueThe numeric representation of an instance of hashed string.
    -

    Definition at line 99 of file helper.hpp.

    +

    Definition at line 205 of file helper.hpp.

    -

    Function Documentation

    - -

    ◆ connect()

    + +

    ◆ type_list_cat_t

    -template<typename... Dependency, typename Entity >
    +template<typename... List>
    + + + + +
    using entt::type_list_cat_t = typedef typename type_list_cat<List...>::type
    +
    + +

    Helper type.

    +
    Template Parameters
    + + +
    ListType lists to concatenate.
    +
    +
    + +

    Definition at line 57 of file type_traits.hpp.

    + +
    + + +

    ◆ type_list_unique_t

    + +
    +
    +
    +template<typename Type >
    + + + + +
    using entt::type_list_unique_t = typedef typename type_list_unique<Type>::type
    +
    + +

    Helper type.

    +
    Template Parameters
    + + +
    TypeA type list.
    +
    +
    + +

    Definition at line 94 of file type_traits.hpp.

    + +
    +
    + +

    ◆ view

    + +
    +
    +
    +template<typename... Types>
    + + + + +
    using entt::view = typedef basic_view<entity, Types...>
    +
    + +

    Alias declaration for the most common use case.

    +
    Template Parameters
    + + +
    ComponentTypes of components iterated by the view.
    +
    +
    + +

    Definition at line 73 of file fwd.hpp.

    + +
    +
    +

    Function Documentation

    + +

    ◆ as_group() [1/2]

    + +
    +
    +
    +template<typename Entity >
    + + + + + + + + +
    entt::as_group (basic_registry< Entity > & ) -> as_group< false, Entity >
    +
    + +

    Deduction guide.

    +

    It allows to deduce the constness of a registry directly from the instance provided to the constructor.

    +
    Template Parameters
    + + +
    EntityA valid entity type (see entt_traits for more details).
    +
    +
    + +
    +
    + +

    ◆ as_group() [2/2]

    + +
    +
    +
    +template<typename Entity >
    + + + + + + + + +
    entt::as_group (const basic_registry< Entity > & ) -> as_group< true, Entity >
    +
    + +

    Deduction guide.

    +

    It allows to deduce the constness of a registry directly from the instance provided to the constructor.

    +
    Template Parameters
    + + +
    EntityA valid entity type (see entt_traits for more details).
    +
    +
    + +
    +
    + +

    ◆ as_view() [1/2]

    + +
    +
    +
    +template<typename Entity >
    + + + + + + + + +
    entt::as_view (basic_registry< Entity > & ) -> as_view< false, Entity >
    +
    + +

    Deduction guide.

    +

    It allows to deduce the constness of a registry directly from the instance provided to the constructor.

    +
    Template Parameters
    + + +
    EntityA valid entity type (see entt_traits for more details).
    +
    +
    + +
    +
    + +

    ◆ as_view() [2/2]

    + +
    +
    +
    +template<typename Entity >
    + + + + + + + + +
    entt::as_view (const basic_registry< Entity > & ) -> as_view< true, Entity >
    +
    + +

    Deduction guide.

    +

    It allows to deduce the constness of a registry directly from the instance provided to the constructor.

    +
    Template Parameters
    + + +
    EntityA valid entity type (see entt_traits for more details).
    +
    +
    + +
    +
    + +

    ◆ connect()

    + +
    +
    +
    +template<typename... Dependency, typename Component , typename Entity >
    - + @@ -380,9 +775,10 @@ template<typename... Dependency, typename Entity >

    Connects a dependency function to the given sink.

    A dependency function is a built-in listener to use to automatically assign components to an entity when a type has a dependency on some other types.

    -

    The following adds components AType and AnotherType whenever MyType is assigned to an entity:

    entt::DefaultRegistry registry;
    entt::connect<AType, AnotherType>(registry.construction<MyType>());
    Template Parameters
    +

    The following adds components a_type and another_type whenever my_type is assigned to an entity:

    entt::registry registry;
    entt::connect<a_type, another_type>(registry.construction<my_type>());
    Template Parameters
    @@ -366,7 +761,7 @@ template<typename... Dependency, typename Entity >
    void entt::connect (Sink< void(Registry< Entity > &, const Entity)> sink< void(basic_registry< Entity > &, const Entity, Component &)>  sink)
    +
    DependencyTypes of components to assign to an entity if triggered.
    ComponentType of component that triggers the dependency handler.
    EntityA valid entity type (see entt_traits for more details).
    @@ -394,29 +790,104 @@ template<typename... Dependency, typename Entity >
    -

    Definition at line 55 of file helper.hpp.

    +

    Definition at line 156 of file helper.hpp.

    - -

    ◆ dependency()

    + +

    ◆ delegate() [1/2]

    -template<typename Entity , typename... Component>
    +template<auto Function>
    + + + + + + + + +
    entt::delegate (connect_arg_t< Function > ) -> delegate< std::remove_pointer_t< decltype(internal::to_function_pointer(Function))>>
    +
    + +

    Deduction guide.

    +

    It allows to deduce the function type of the delegate directly from a function provided to the constructor.

    +
    Template Parameters
    + + +
    FunctionA valid free function pointer.
    +
    +
    + +
    + + +

    ◆ delegate() [2/2]

    + +
    +
    +
    +template<auto Candidate, typename Type >
    + + + + + + + + + + + + + + + + + + +
    entt::delegate (connect_arg_t< Candidate > ,
    Type *  
    ) -> delegate< std::remove_pointer_t< decltype(internal::to_function_pointer(Candidate, std::declval< Type *>()))>>
    +
    + +

    Deduction guide.

    +

    It allows to deduce the function type of the delegate directly from a member or a free function with payload provided to the constructor.

    +
    Template Parameters
    + + + +
    CandidateMember or free function to connect to the delegate.
    TypeType of class or type of payload.
    +
    +
    + +
    +
    + +

    ◆ dependency()

    + +
    +
    +
    +template<typename Entity , typename Component , typename... Dependency>
    - - + + - + + + + + + + @@ -433,29 +904,30 @@ template<typename Entity , typename... Component>
    Template Parameters
    void entt::dependency (Registry< Entity > & registry, basic_registry< Entity > & reg,
    const Entity entity entt,
    const Component &  
    - + +
    EntityA valid entity type (see entt_traits for more details).
    ComponentTypes of components to assign to an entity if triggered.
    ComponentType of component that triggers the dependency handler.
    DependencyTypes of components to assign to an entity if triggered.
    Parameters
    - - + +
    registryA valid reference to a registry.
    entityA valid entity identifier.
    regA valid reference to a registry.
    enttA valid entity identifier.
    -

    Definition at line 30 of file helper.hpp.

    +

    Definition at line 132 of file helper.hpp.

    - -

    ◆ disconnect()

    + +

    ◆ disconnect()

    -template<typename... Dependency, typename Entity >
    +template<typename... Dependency, typename Component , typename Entity >
    - + @@ -477,9 +949,10 @@ template<typename... Dependency, typename Entity >

    Disconnects a dependency function from the given sink.

    A dependency function is a built-in listener to use to automatically assign components to an entity when a type has a dependency on some other types.

    -

    The following breaks the dependency between the component MyType and the components AType and AnotherType:

    entt::DefaultRegistry registry;
    entt::disconnect<AType, AnotherType>(registry.construction<MyType>());
    Template Parameters
    +

    The following breaks the dependency between the component my_type and the components a_type and another_type:

    entt::registry registry;
    entt::disconnect<a_type, another_type>(registry.construction<my_type>());
    Template Parameters
    @@ -463,7 +935,7 @@ template<typename... Dependency, typename Entity >
    void entt::disconnect (Sink< void(Registry< Entity > &, const Entity)> sink< void(basic_registry< Entity > &, const Entity, Component &)>  sink)
    +
    DependencyTypes of components used to create the dependency.
    ComponentType of component that triggers the dependency handler.
    EntityA valid entity type (see entt_traits for more details).
    @@ -491,12 +964,12 @@ template<typename... Dependency, typename Entity >
    -

    Definition at line 78 of file helper.hpp.

    +

    Definition at line 180 of file helper.hpp.

    - -

    ◆ operator!=() [1/3]

    + +

    ◆ operator!=() [1/11]

    @@ -504,13 +977,13 @@ template<typename... Dependency, typename Entity >
    constexpr bool entt::operator!= (const HashedString & const hashed_string &  lhs,
    const HashedString & const hashed_string &  rhs 
    bool entt::operator!= (const Delegate< Ret(Args...)> & const delegate< Ret(Args...)> &  lhs,
    const Delegate< Ret(Args...)> & const delegate< Ret(Args...)> &  rhs 
    -

    Checks if the contents of the two delegates are different.

    -

    Two delegates are identical if they contain the same listener.

    +

    Checks if the connected functions differ.

    +

    Instances connected to delegates are ignored by this operator. Use the instance member function instead.

    Template Parameters
    @@ -579,30 +1052,31 @@ template<typename Ret , typename... Args>
    RetReturn type of a function type.
    -
    Returns
    True if the two delegates are different, false otherwise.
    +
    Returns
    True if the connected functions differ, false otherwise.
    -

    Definition at line 158 of file delegate.hpp.

    +

    Definition at line 247 of file delegate.hpp.

    - -

    ◆ operator!=() [3/3]

    + +

    ◆ operator!=() [3/11]

    -
    -template<typename Ret , typename... Args>
    + + + + + +
    - + - + @@ -611,31 +1085,850 @@ template<typename Ret , typename... Args>
    bool entt::operator!= (const SigH< Ret(Args...)> & const meta_any &  lhs,
    const SigH< Ret(Args...)> & const meta_any &  rhs 
    +     		+inline
    -

    Checks if the contents of the two signals are different.

    -

    Two signals are identical if they have the same size and the same listeners registered exactly in the same order.

    +

    Checks if two containers differ in their content.

    +
    Parameters
    + + + +
    lhsA meta any object, either empty or not.
    rhsA meta any object, either empty or not.
    +
    +
    +
    Returns
    True if the two containers differ in their content, false otherwise.
    + +

    Definition at line 729 of file meta.hpp.

    + +
    +
    + +

    ◆ operator!=() [4/11]

    + +
    +
    + + + + + +
    + + + + + + + + + + + + + + + + + + +
    bool entt::operator!= (const meta_prop & lhs,
    const meta_prop & rhs 
    )
    +     		+inline
    +
    + +

    Checks if two meta objects refer to the same node.

    +
    Parameters
    + + + +
    lhsA meta object, either valid or not.
    rhsA meta object, either valid or not.
    +
    +
    +
    Returns
    True if the two meta objects refer to the same node, false otherwise.
    + +

    Definition at line 799 of file meta.hpp.

    + +
    +
    + +

    ◆ operator!=() [5/11]

    + +
    +
    + + + + + +
    + + + + + + + + + + + + + + + + + + +
    bool entt::operator!= (const meta_base & lhs,
    const meta_base & rhs 
    )
    +     		+inline
    +
    + +

    Checks if two meta objects refer to the same node.

    +
    Parameters
    + + + +
    lhsA meta object, either valid or not.
    rhsA meta object, either valid or not.
    +
    +
    +
    Returns
    True if the two meta objects refer to the same node, false otherwise.
    + +

    Definition at line 874 of file meta.hpp.

    + +
    +
    + +

    ◆ operator!=() [6/11]

    + +
    +
    + + + + + +
    + + + + + + + + + + + + + + + + + + +
    bool entt::operator!= (const meta_conv & lhs,
    const meta_conv & rhs 
    )
    +     		+inline
    +
    + +

    Checks if two meta objects refer to the same node.

    +
    Parameters
    + + + +
    lhsA meta object, either valid or not.
    rhsA meta object, either valid or not.
    +
    +
    +
    Returns
    True if the two meta objects refer to the same node, false otherwise.
    + +

    Definition at line 949 of file meta.hpp.

    + +
    +
    + +

    ◆ operator!=() [7/11]

    + +
    +
    + + + + + +
    + + + + + + + + + + + + + + + + + + +
    bool entt::operator!= (const meta_ctor & lhs,
    const meta_ctor & rhs 
    )
    +     		+inline
    +
    + +

    Checks if two meta objects refer to the same node.

    +
    Parameters
    + + + +
    lhsA meta object, either valid or not.
    rhsA meta object, either valid or not.
    +
    +
    +
    Returns
    True if the two meta objects refer to the same node, false otherwise.
    + +

    Definition at line 1079 of file meta.hpp.

    + +
    +
    + +

    ◆ operator!=() [8/11]

    + +
    +
    + + + + + +
    + + + + + + + + + + + + + + + + + + +
    bool entt::operator!= (const meta_dtor & lhs,
    const meta_dtor & rhs 
    )
    +     		+inline
    +
    + +

    Checks if two meta objects refer to the same node.

    +
    Parameters
    + + + +
    lhsA meta object, either valid or not.
    rhsA meta object, either valid or not.
    +
    +
    +
    Returns
    True if the two meta objects refer to the same node, false otherwise.
    + +

    Definition at line 1153 of file meta.hpp.

    + +
    +
    + +

    ◆ operator!=() [9/11]

    + +
    +
    + + + + + +
    + + + + + + + + + + + + + + + + + + +
    bool entt::operator!= (const meta_data & lhs,
    const meta_data & rhs 
    )
    +     		+inline
    +
    + +

    Checks if two meta objects refer to the same node.

    +
    Parameters
    + + + +
    lhsA meta object, either valid or not.
    rhsA meta object, either valid or not.
    +
    +
    +
    Returns
    True if the two meta objects refer to the same node, false otherwise.
    + +

    Definition at line 1344 of file meta.hpp.

    + +
    +
    + +

    ◆ operator!=() [10/11]

    + +
    +
    + + + + + +
    + + + + + + + + + + + + + + + + + + +
    bool entt::operator!= (const meta_func & lhs,
    const meta_func & rhs 
    )
    +     		+inline
    +
    + +

    Checks if two meta objects refer to the same node.

    +
    Parameters
    + + + +
    lhsA meta object, either valid or not.
    rhsA meta object, either valid or not.
    +
    +
    +
    Returns
    True if the two meta objects refer to the same node, false otherwise.
    + +

    Definition at line 1512 of file meta.hpp.

    + +
    +
    + +

    ◆ operator!=() [11/11]

    + +
    +
    + + + + + +
    + + + + + + + + + + + + + + + + + + +
    bool entt::operator!= (const meta_type & lhs,
    const meta_type & rhs 
    )
    +     		+inline
    +
    + +

    Checks if two meta objects refer to the same node.

    +
    Parameters
    + + + +
    lhsA meta object, either valid or not.
    rhsA meta object, either valid or not.
    +
    +
    +
    Returns
    True if the two meta objects refer to the same node, false otherwise.
    + +

    Definition at line 1937 of file meta.hpp.

    + +
    +
    + +

    ◆ overload() [1/2]

    + +
    +
    +
    +template<typename Type , typename Class >
    + + + + + + + + +
    constexpr auto entt::overload (Type Class::* member)
    +
    + +

    Constant utility to disambiguate overloaded member functions.

    Template Parameters
    - - + +
    RetReturn type of a function type.
    ArgsTypes of arguments of a function type.
    TypeFunction type of the desired overload.
    ClassType of class to which the member functions belong.
    Parameters
    - - +
    lhsA valid signal object.
    rhsA valid signal object.
    memberA valid pointer to a member function.
    -
    Returns
    True if the two signals are different, false otherwise.
    +
    Returns
    Pointer to the member function.
    -

    Definition at line 418 of file sigh.hpp.

    +

    Definition at line 16 of file utility.hpp.

    + +
    +
    + +

    ◆ overload() [2/2]

    + +
    +
    +
    +template<typename Type >
    + + + + + + + + +
    constexpr auto entt::overload (Type * func)
    +
    + +

    Constant utility to disambiguate overloaded functions.

    +
    Template Parameters
    + + +
    TypeFunction type of the desired overload.
    +
    +
    +
    Parameters
    + + +
    funcA valid pointer to a function.
    +
    +
    +
    Returns
    Pointer to the function.
    + +

    Definition at line 26 of file utility.hpp.

    + +
    +
    + +

    ◆ reflect() [1/2]

    + +
    +
    +
    +template<typename Type , typename... Property>
    + + + + + +
    + + + + + + + + + + + + + + + + + + +
    meta_factory< Type > entt::reflect (const char * str,
    Property &&... property 
    )
    +     		+inline
    +
    + +

    Basic function to use for reflection.

    +

    This is the point from which everything starts.
    + By invoking this function with a type that is not yet reflected, a meta type is created to which it will be possible to attach data and functions through a dedicated factory.

    +
    Template Parameters
    + + + +
    TypeType to reflect.
    PropertyTypes of properties to assign to the reflected type.
    +
    +
    +
    Parameters
    + + + +
    strThe name to assign to the reflected type.
    propertyProperties to assign to the reflected type.
    +
    +
    +
    Returns
    A meta factory for the given type.
    + +

    Definition at line 606 of file factory.hpp.

    + +
    +
    + +

    ◆ reflect() [2/2]

    + +
    +
    +
    +template<typename Type >
    + + + + + +
    + + + + + + + +
    meta_factory<Type> entt::reflect ()
    +     		+inline
    +
    + +

    Basic function to use for reflection.

    +

    This is the point from which everything starts.
    + By invoking this function with a type that is not yet reflected, a meta type is created to which it will be possible to attach data and functions through a dedicated factory.

    +
    Template Parameters
    + + +
    TypeType to reflect.
    +
    +
    +
    Returns
    A meta factory for the given type.
    + +

    Definition at line 623 of file factory.hpp.

    + +
    +
    + +

    ◆ resolve() [1/3]

    + +
    +
    +
    +template<typename Type >
    + + + + + +
    + + + + + + + +
    meta_type entt::resolve ()
    +     		+inline
    +
    + +

    Returns the meta type associated with a given type.

    +
    Template Parameters
    + + +
    TypeType to use to search for a meta type.
    +
    +
    +
    Returns
    The meta type associated with the given type, if any.
    + +

    Definition at line 652 of file factory.hpp.

    + +
    +
    + +

    ◆ resolve() [2/3]

    + +
    +
    + + + + + +
    + + + + + + + + +
    meta_type entt::resolve (const char * str)
    +     		+inline
    +
    + +

    Returns the meta type associated with a given name.

    +
    Parameters
    + + +
    strThe name to use to search for a meta type.
    +
    +
    +
    Returns
    The meta type associated with the given name, if any.
    + +

    Definition at line 662 of file factory.hpp.

    + +
    +
    + +

    ◆ resolve() [3/3]

    + +
    +
    +
    +template<typename Op >
    + + + + + + + + +
    void entt::resolve (Op op)
    +
    + +

    Iterates all the reflected types.

    +
    Template Parameters
    + + +
    OpType of the function object to invoke.
    +
    +
    +
    Parameters
    + + +
    opA valid function object.
    +
    +
    + +

    Definition at line 677 of file factory.hpp.

    + +
    +
    + +

    ◆ unregister()

    + +
    +
    +
    +template<typename Type >
    + + + + + +
    + + + + + + + +
    bool entt::unregister ()
    +     		+inline
    +
    + +

    Basic function to unregister a type.

    +

    This function unregisters a type and all its data members, member functions and properties, as well as its constructors, destructors and conversion functions if any.
    + Base classes aren't unregistered but the link between the two types is removed.

    +
    Template Parameters
    + + +
    TypeType to unregister.
    +
    +
    +
    Returns
    True if the type to unregister exists, false otherwise.
    + +

    Definition at line 641 of file factory.hpp.

    Variable Documentation

    + +

    ◆ exclude

    + +
    +
    +
    +template<typename... Type>
    + + + + +
    constexpr exclude_t<Type...> entt::exclude {}
    +
    + +

    Variable template for exclusion lists.

    +
    Template Parameters
    + + +
    TypeList of types.
    +
    +
    + +

    Definition at line 46 of file registry.hpp.

    + +
    +
    + +

    ◆ get

    + +
    +
    +
    +template<typename... Type>
    + + + + +
    constexpr get_t<Type...> entt::get {}
    +
    + +

    Variable template for lists of observed components.

    +
    Template Parameters
    + + +
    TypeList of types.
    +
    +
    + +

    Definition at line 31 of file group.hpp.

    + +
    +
    + +

    ◆ is_named_type_v

    + +
    +
    +
    +template<class Type >
    + + + + +
    constexpr auto entt::is_named_type_v = is_named_type<Type>::value
    +
    + +

    Helper variable template.

    +

    True if a given type has a name, false otherwise.

    +
    Template Parameters
    + + +
    TypePotentially named type.
    +
    +
    + +

    Definition at line 145 of file type_traits.hpp.

    + +
    +
    + +

    ◆ monostate_v

    + +
    +
    +
    +template<hashed_string::hash_type Value>
    + + + + + +
    + + + + +
    monostate<Value> entt::monostate_v = {}
    +     		+inline
    +
    + +

    Helper variable template.

    +
    Template Parameters
    + + +
    ValueValue used to differentiate between different variables.
    +
    +
    + +

    Definition at line 57 of file monostate.hpp.

    + +
    +

    ◆ null

    @@ -643,7 +1936,7 @@ template<typename Ret , typename... Args>
    - +
    constexpr auto entt::null = internal::Null{}constexpr auto entt::null = internal::null{}
    @@ -651,7 +1944,7 @@ template<typename Ret , typename... Args>

    Null entity.

    TURN_OFF_DOXYGEN There exist implicit conversions from this variable to entity identifiers of any allowed type. Similarly, there exist comparision operators between the null entity and any other entity identifier.

    -

    Definition at line 78 of file entity.hpp.

    +

    Definition at line 163 of file entity.hpp.

    diff --git a/namespacemembers.html b/namespacemembers.html index b1a52049c..2d1e6f65b 100644 --- a/namespacemembers.html +++ b/namespacemembers.html @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
     Contributing
     Crash Course: core functionalities
     Crash Course: entity-component system
     Crash Course: service locator
     Crash Course: cooperative scheduler
     Crash Course: resource management
     EnTT and shared libraries
     Crash Course: events, signals and everything in between
     Frequently Asked Questions
     Push EnTT across boundaries
     EnTT in Action
     Crash Course: service locator
     Crash Course: reflection system
     Crash Course: cooperative scheduler
     Crash Course: resource management
     Crash Course: events, signals and everything in between
    diff --git a/process_8hpp_source.html b/process_8hpp_source.html index 9f84d61ac..d8ae38546 100644 --- a/process_8hpp_source.html +++ b/process_8hpp_source.html @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    + + + + + +
    +
    EnTT +  3.0.0 +
    +
    + + + + + + + + + +
    +
    + + +
    + +
    + + + +
    +
    +
    fwd.hpp
    +
    +
    +
    1 #ifndef ENTT_RESOURCE_FWD_HPP
    2 #define ENTT_RESOURCE_FWD_HPP
    3 
    4 
    5 #include "../config/config.h"
    6 
    7 
    8 namespace entt {
    9 
    10 
    12 template<typename>
    13 class resource_cache;
    14 
    16 template<typename>
    17 class resource_handle;
    18 
    20 template<typename, typename>
    21 class resource_loader;
    22 
    23 
    24 }
    25 
    26 
    27 #endif // ENTT_RESOURCE_FWD_HPP
    entt::resource_loader
    Base class for resource loaders.
    Definition: fwd.hpp:21
    +
    entt
    EnTT default namespace.
    Definition: algorithm.hpp:10
    +
    entt::resource_handle
    Shared resource handle.
    Definition: fwd.hpp:17
    +
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/resource_8md_source.html b/resource_8md_source.html index d3fa50657..eaa1e4c15 100644 --- a/resource_8md_source.html +++ b/resource_8md_source.html @@ -5,7 +5,7 @@ -EnTT: docs/resource.md Source File +EnTT: docs/md/resource.md Source File @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    + + + + + +
    +
    EnTT +  3.0.0 +
    +
    + + + + + + + + + +
    +
    + + +
    + +
    + +     + +
    +
    +
    runtime_view.hpp
    +
    +
    +
    1 #ifndef ENTT_ENTITY_RUNTIME_VIEW_HPP
    2 #define ENTT_ENTITY_RUNTIME_VIEW_HPP
    3 
    4 
    5 #include <iterator>
    6 #include <cassert>
    7 #include <vector>
    8 #include <utility>
    9 #include <algorithm>
    10 #include "../config/config.h"
    11 #include "sparse_set.hpp"
    12 #include "entity.hpp"
    13 #include "fwd.hpp"
    14 
    15 
    16 namespace entt {
    17 
    18 
    56 template<typename Entity>
    57 class basic_runtime_view {
    59  friend class basic_registry<Entity>;
    60 
    61  using underlying_iterator_type = typename sparse_set<Entity>::iterator_type;
    62  using extent_type = typename sparse_set<Entity>::size_type;
    63  using traits_type = entt_traits<Entity>;
    64 
    65  class iterator {
    66  friend class basic_runtime_view<Entity>;
    67 
    68  iterator(underlying_iterator_type first, underlying_iterator_type last, const sparse_set<Entity> * const *others, const sparse_set<Entity> * const *length, extent_type ext) ENTT_NOEXCEPT
    69  : begin{first},
    70  end{last},
    71  from{others},
    72  to{length},
    73  extent{ext}
    74  {
    75  if(begin != end && !valid()) {
    76  ++(*this);
    77  }
    78  }
    79 
    80  bool valid() const ENTT_NOEXCEPT {
    81  const auto entt = *begin;
    82  const auto sz = size_type(entt & traits_type::entity_mask);
    83 
    84  return sz < extent && std::all_of(from, to, [entt](const auto *view) {
    85  return view->has(entt);
    86  });
    87  }
    88 
    89  public:
    90  using difference_type = typename underlying_iterator_type::difference_type;
    91  using value_type = typename underlying_iterator_type::value_type;
    92  using pointer = typename underlying_iterator_type::pointer;
    93  using reference = typename underlying_iterator_type::reference;
    94  using iterator_category = std::forward_iterator_tag;
    95 
    96  iterator() ENTT_NOEXCEPT = default;
    97 
    98  iterator & operator++() ENTT_NOEXCEPT {
    99  return (++begin != end && !valid()) ? ++(*this) : *this;
    100  }
    101 
    102  iterator operator++(int) ENTT_NOEXCEPT {
    103  iterator orig = *this;
    104  return ++(*this), orig;
    105  }
    106 
    107  bool operator==(const iterator &other) const ENTT_NOEXCEPT {
    108  return other.begin == begin;
    109  }
    110 
    111  inline bool operator!=(const iterator &other) const ENTT_NOEXCEPT {
    112  return !(*this == other);
    113  }
    114 
    115  pointer operator->() const ENTT_NOEXCEPT {
    116  return begin.operator->();
    117  }
    118 
    119  inline reference operator*() const ENTT_NOEXCEPT {
    120  return *operator->();
    121  }
    122 
    123  private:
    124  underlying_iterator_type begin;
    125  underlying_iterator_type end;
    126  const sparse_set<Entity> * const *from;
    127  const sparse_set<Entity> * const *to;
    128  extent_type extent;
    129  };
    130 
    131  basic_runtime_view(std::vector<const sparse_set<Entity> *> others) ENTT_NOEXCEPT
    132  : pools{std::move(others)}
    133  {
    134  const auto it = std::min_element(pools.begin(), pools.end(), [](const auto *lhs, const auto *rhs) {
    135  return (!lhs && rhs) || (lhs && rhs && lhs->size() < rhs->size());
    136  });
    137 
    138  // brings the best candidate (if any) on front of the vector
    139  std::rotate(pools.begin(), it, pools.end());
    140  }
    141 
    142  extent_type min() const ENTT_NOEXCEPT {
    143  extent_type extent{};
    144 
    145  if(valid()) {
    146  const auto it = std::min_element(pools.cbegin(), pools.cend(), [](const auto *lhs, const auto *rhs) {
    147  return lhs->extent() < rhs->extent();
    148  });
    149 
    150  extent = (*it)->extent();
    151  }
    152 
    153  return extent;
    154  }
    155 
    156  inline bool valid() const ENTT_NOEXCEPT {
    157  return !pools.empty() && pools.front();
    158  }
    159 
    160 public:
    162  using entity_type = typename sparse_set<Entity>::entity_type;
    164  using size_type = typename sparse_set<Entity>::size_type;
    166  using iterator_type = iterator;
    167 
    172  size_type size() const ENTT_NOEXCEPT {
    173  return valid() ? pools.front()->size() : size_type{};
    174  }
    175 
    180  bool empty() const ENTT_NOEXCEPT {
    181  return !valid() || pools.front()->empty();
    182  }
    183 
    198  iterator_type begin() const ENTT_NOEXCEPT {
    199  iterator_type it{};
    200 
    201  if(valid()) {
    202  const auto &pool = *pools.front();
    203  const auto * const *data = pools.data();
    204  it = { pool.begin(), pool.end(), data + 1, data + pools.size(), min() };
    205  }
    206 
    207  return it;
    208  }
    209 
    225  iterator_type end() const ENTT_NOEXCEPT {
    226  iterator_type it{};
    227 
    228  if(valid()) {
    229  const auto &pool = *pools.front();
    230  it = { pool.end(), pool.end(), nullptr, nullptr, min() };
    231  }
    232 
    233  return it;
    234  }
    235 
    241  bool contains(const entity_type entt) const ENTT_NOEXCEPT {
    242  return valid() && std::all_of(pools.cbegin(), pools.cend(), [entt](const auto *view) {
    243  return view->has(entt) && view->data()[view->get(entt)] == entt;
    244  });
    245  }
    246 
    262  template<typename Func>
    263  void each(Func func) const {
    264  std::for_each(begin(), end(), func);
    265  }
    266 
    267 private:
    268  std::vector<const sparse_set<Entity> *> pools;
    269 };
    270 
    271 
    272 }
    273 
    274 
    275 #endif // ENTT_ENTITY_RUNTIME_VIEW_HPP
    entt::basic_runtime_view::contains
    bool contains(const entity_type entt) const ENTT_NOEXCEPT
    Checks if a view contains an entity.
    Definition: runtime_view.hpp:241
    +
    entt::sparse_set
    Basic sparse set implementation.
    Definition: sparse_set.hpp:46
    +
    entt::basic_runtime_view::size_type
    typename sparse_set< Entity >::size_type size_type
    Unsigned integer type.
    Definition: runtime_view.hpp:164
    +
    entt::basic_runtime_view::iterator_type
    iterator iterator_type
    Input iterator type.
    Definition: runtime_view.hpp:166
    +
    entt::basic_view::data
    const entity_type * data() const ENTT_NOEXCEPT
    Direct access to the list of entities of a given pool.
    Definition: view.hpp:270
    +
    entt
    EnTT default namespace.
    Definition: algorithm.hpp:10
    +
    entt::sparse_set::size_type
    std::size_t size_type
    Unsigned integer type.
    Definition: sparse_set.hpp:176
    +
    entt::basic_runtime_view::entity_type
    typename sparse_set< Entity >::entity_type entity_type
    Underlying entity identifier.
    Definition: runtime_view.hpp:162
    +
    entt::basic_registry
    Fast and reliable entity-component system.
    Definition: fwd.hpp:13
    +
    entt::basic_view
    Multi component view.
    Definition: fwd.hpp:17
    +
    entt::sparse_set::entity_type
    Entity entity_type
    Underlying entity identifier.
    Definition: sparse_set.hpp:174
    +
    entt::basic_runtime_view::empty
    bool empty() const ENTT_NOEXCEPT
    Checks if the view is definitely empty.
    Definition: runtime_view.hpp:180
    +
    entt::basic_runtime_view::begin
    iterator_type begin() const ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given components.
    Definition: runtime_view.hpp:198
    +
    entt::basic_runtime_view::each
    void each(Func func) const
    Iterates entities and applies the given function object to them.
    Definition: runtime_view.hpp:263
    +
    entt::view
    basic_view< entity, Types... > view
    Alias declaration for the most common use case.
    Definition: fwd.hpp:73
    +
    entt::basic_runtime_view::size
    size_type size() const ENTT_NOEXCEPT
    Estimates the number of entities that have the given components.
    Definition: runtime_view.hpp:172
    +
    entt::basic_runtime_view::end
    iterator_type end() const ENTT_NOEXCEPT
    Returns an iterator that is past the last entity that has the given components.
    Definition: runtime_view.hpp:225
    +
    entt::entt_traits
    Entity traits.
    Definition: entity.hpp:18
    +
    entt::basic_runtime_view
    Runtime view.
    Definition: fwd.hpp:21
    +
    entt::operator!=
    constexpr bool operator!=(const hashed_string &lhs, const hashed_string &rhs) ENTT_NOEXCEPT
    Compares two hashed strings.
    Definition: hashed_string.hpp:195
    +
    entt::sparse_set::iterator_type
    iterator iterator_type
    Random access iterator type.
    Definition: sparse_set.hpp:178
    +
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/scheduler_8hpp_source.html b/scheduler_8hpp_source.html index de034ab5c..b89f74e50 100644 --- a/scheduler_8hpp_source.html +++ b/scheduler_8hpp_source.html @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    - - - - - -
    -
    EnTT -  2.7.3 -
    -
    - - - - - - - - - - -
    -
    - - -
    - -
    - -
    -
    -
    docs/shared.md
    -
    -
    -
    1 ### EnTT and shared libraries
    2 
    3 To make sure that an application and a shared library that use both `EnTT` can
    4 interact correctly when symbols are hidden by default, there are some tricks to
    5 follow.<br/>
    6 In particular and in order to avoid undefined behaviors, all the instantiation
    7 of the `Family` class template shall be made explicit along with the system-wide
    8 specifier to use to export them.
    9 
    10 At the time I'm writing this document, the classes that use internally the above
    11 mentioned class template are `Dispatcher`, `Emitter` and `Registry`. Therefore
    12 and as an example, if you use the `Registry` class template in your shared
    13 library and want to set symbols visibility to _hidden_ by default, the following
    14 lines are required to allow it to function properly with a client that also uses
    15 the `Registry` somehow:
    16 
    17 * On GNU/Linux:
    18 
    19  ```cpp
    20  namespace entt {
    21  template class __attribute__((visibility("default"))) Family<struct InternalRegistryTagFamily>;
    22  template class __attribute__((visibility("default"))) Family<struct InternalRegistryComponentFamily>;
    23  template class __attribute__((visibility("default"))) Family<struct InternalRegistryHandlerFamily>;
    24  }
    25  ```
    26 
    27 * On Windows:
    28 
    29  ```cpp
    30  namespace entt {
    31  template class __declspec(dllexport) Family<struct InternalRegistryTagFamily>;
    32  template class __declspec(dllexport) Family<struct InternalRegistryComponentFamily>;
    33  template class __declspec(dllexport) Family<struct InternalRegistryHandlerFamily>;
    34  }
    35  ```
    36 
    37 Otherwise, the risk is that type identifiers are different between the shared
    38 library and the application and this will prevent the whole thing from
    39 functioning correctly for obvious reasons.
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/sigh_8hpp_source.html b/sigh_8hpp_source.html index 65dd16d96..ad5f6e16e 100644 --- a/sigh_8hpp_source.html +++ b/sigh_8hpp_source.html @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    + + + + + +
    +
    EnTT +  3.0.0 +
    +
    + + + + + + + + + +
    +
    + + +
    + +
    + + + +
    +
    +
    fwd.hpp
    +
    +
    +
    1 #ifndef ENTT_SIGNAL_FWD_HPP
    2 #define ENTT_SIGNAL_FWD_HPP
    3 
    4 
    5 #include "../config/config.h"
    6 
    7 
    8 namespace entt {
    9 
    10 
    12 template<typename>
    13 class delegate;
    14 
    16 template<typename>
    17 class sink;
    18 
    20 template<typename, typename>
    21 struct sigh;
    22 
    23 
    24 }
    25 
    26 
    27 #endif // ENTT_SIGNAL_FWD_HPP
    entt
    EnTT default namespace.
    Definition: algorithm.hpp:10
    +
    entt::delegate
    delegate(connect_arg_t< Function >) ENTT_NOEXCEPT -> delegate< std::remove_pointer_t< decltype(internal::to_function_pointer(Function))>>
    Deduction guide.
    +
    entt::sigh
    Unmanaged signal handler declaration.
    Definition: fwd.hpp:21
    +
    entt::sink
    Sink implementation.
    Definition: fwd.hpp:17
    +
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/signal_8md_source.html b/signal_8md_source.html index a2ddcd960..488e79c5d 100644 --- a/signal_8md_source.html +++ b/signal_8md_source.html @@ -5,7 +5,7 @@ -EnTT: docs/signal.md Source File +EnTT: docs/md/signal.md Source File @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    + + + + + +
    +
    EnTT +  3.0.0 +
    +
    + + + + + + + + + +
    +
    + + +
    + +
    + + + +
    +
    +
    storage.hpp
    +
    +
    +
    1 #ifndef ENTT_ENTITY_STORAGE_HPP
    2 #define ENTT_ENTITY_STORAGE_HPP
    3 
    4 
    5 #include <algorithm>
    6 #include <iterator>
    7 #include <numeric>
    8 #include <utility>
    9 #include <vector>
    10 #include <cstddef>
    11 #include <type_traits>
    12 #include "../config/config.h"
    13 #include "../core/algorithm.hpp"
    14 #include "sparse_set.hpp"
    15 #include "entity.hpp"
    16 
    17 
    18 namespace entt {
    19 
    20 
    49 template<typename Entity, typename Type, typename = std::void_t<>>
    50 class basic_storage: public sparse_set<Entity> {
    51  using underlying_type = sparse_set<Entity>;
    52  using traits_type = entt_traits<Entity>;
    53 
    54  template<bool Const>
    55  class iterator {
    56  friend class basic_storage<Entity, Type>;
    57 
    58  using instance_type = std::conditional_t<Const, const std::vector<Type>, std::vector<Type>>;
    59  using index_type = typename traits_type::difference_type;
    60 
    61  iterator(instance_type *ref, const index_type idx) ENTT_NOEXCEPT
    62  : instances{ref}, index{idx}
    63  {}
    64 
    65  public:
    66  using difference_type = index_type;
    67  using value_type = Type;
    68  using pointer = std::conditional_t<Const, const value_type *, value_type *>;
    69  using reference = std::conditional_t<Const, const value_type &, value_type &>;
    70  using iterator_category = std::random_access_iterator_tag;
    71 
    72  iterator() ENTT_NOEXCEPT = default;
    73 
    74  iterator & operator++() ENTT_NOEXCEPT {
    75  return --index, *this;
    76  }
    77 
    78  iterator operator++(int) ENTT_NOEXCEPT {
    79  iterator orig = *this;
    80  return ++(*this), orig;
    81  }
    82 
    83  iterator & operator--() ENTT_NOEXCEPT {
    84  return ++index, *this;
    85  }
    86 
    87  iterator operator--(int) ENTT_NOEXCEPT {
    88  iterator orig = *this;
    89  return --(*this), orig;
    90  }
    91 
    92  iterator & operator+=(const difference_type value) ENTT_NOEXCEPT {
    93  index -= value;
    94  return *this;
    95  }
    96 
    97  iterator operator+(const difference_type value) const ENTT_NOEXCEPT {
    98  return iterator{instances, index-value};
    99  }
    100 
    101  inline iterator & operator-=(const difference_type value) ENTT_NOEXCEPT {
    102  return (*this += -value);
    103  }
    104 
    105  inline iterator operator-(const difference_type value) const ENTT_NOEXCEPT {
    106  return (*this + -value);
    107  }
    108 
    109  difference_type operator-(const iterator &other) const ENTT_NOEXCEPT {
    110  return other.index - index;
    111  }
    112 
    113  reference operator[](const difference_type value) const ENTT_NOEXCEPT {
    114  const auto pos = size_type(index-value-1);
    115  return (*instances)[pos];
    116  }
    117 
    118  bool operator==(const iterator &other) const ENTT_NOEXCEPT {
    119  return other.index == index;
    120  }
    121 
    122  inline bool operator!=(const iterator &other) const ENTT_NOEXCEPT {
    123  return !(*this == other);
    124  }
    125 
    126  bool operator<(const iterator &other) const ENTT_NOEXCEPT {
    127  return index > other.index;
    128  }
    129 
    130  bool operator>(const iterator &other) const ENTT_NOEXCEPT {
    131  return index < other.index;
    132  }
    133 
    134  inline bool operator<=(const iterator &other) const ENTT_NOEXCEPT {
    135  return !(*this > other);
    136  }
    137 
    138  inline bool operator>=(const iterator &other) const ENTT_NOEXCEPT {
    139  return !(*this < other);
    140  }
    141 
    142  pointer operator->() const ENTT_NOEXCEPT {
    143  const auto pos = size_type(index-1);
    144  return &(*instances)[pos];
    145  }
    146 
    147  inline reference operator*() const ENTT_NOEXCEPT {
    148  return *operator->();
    149  }
    150 
    151  private:
    152  instance_type *instances;
    153  index_type index;
    154  };
    155 
    156 public:
    158  using object_type = Type;
    160  using entity_type = typename underlying_type::entity_type;
    162  using size_type = typename underlying_type::size_type;
    164  using iterator_type = iterator<false>;
    166  using const_iterator_type = iterator<true>;
    167 
    176  void reserve(const size_type cap) override {
    177  underlying_type::reserve(cap);
    178  instances.reserve(cap);
    179  }
    180 
    182  void shrink_to_fit() override {
    183  underlying_type::shrink_to_fit();
    184  instances.shrink_to_fit();
    185  }
    186 
    202  const object_type * raw() const ENTT_NOEXCEPT {
    203  return instances.data();
    204  }
    205 
    207  object_type * raw() ENTT_NOEXCEPT {
    208  return const_cast<object_type *>(std::as_const(*this).raw());
    209  }
    210 
    223  const_iterator_type cbegin() const ENTT_NOEXCEPT {
    224  const typename traits_type::difference_type pos = underlying_type::size();
    225  return const_iterator_type{&instances, pos};
    226  }
    227 
    229  inline const_iterator_type begin() const ENTT_NOEXCEPT {
    230  return cbegin();
    231  }
    232 
    234  iterator_type begin() ENTT_NOEXCEPT {
    235  const typename traits_type::difference_type pos = underlying_type::size();
    236  return iterator_type{&instances, pos};
    237  }
    238 
    253  const_iterator_type cend() const ENTT_NOEXCEPT {
    254  return const_iterator_type{&instances, {}};
    255  }
    256 
    258  inline const_iterator_type end() const ENTT_NOEXCEPT {
    259  return cend();
    260  }
    261 
    263  iterator_type end() ENTT_NOEXCEPT {
    264  return iterator_type{&instances, {}};
    265  }
    266 
    279  const object_type & get(const entity_type entt) const ENTT_NOEXCEPT {
    280  return instances[underlying_type::get(entt)];
    281  }
    282 
    284  inline object_type & get(const entity_type entt) ENTT_NOEXCEPT {
    285  return const_cast<object_type &>(std::as_const(*this).get(entt));
    286  }
    287 
    293  const object_type * try_get(const entity_type entt) const ENTT_NOEXCEPT {
    294  return underlying_type::has(entt) ? (instances.data() + underlying_type::get(entt)) : nullptr;
    295  }
    296 
    298  inline object_type * try_get(const entity_type entt) ENTT_NOEXCEPT {
    299  return const_cast<object_type *>(std::as_const(*this).try_get(entt));
    300  }
    301 
    320  template<typename... Args>
    321  object_type & construct(const entity_type entt, Args &&... args) {
    322  if constexpr(std::is_aggregate_v<object_type>) {
    323  instances.emplace_back(Type{std::forward<Args>(args)...});
    324  } else {
    325  instances.emplace_back(std::forward<Args>(args)...);
    326  }
    327 
    328  // entity goes after component in case constructor throws
    329  underlying_type::construct(entt);
    330  return instances.back();
    331  }
    332 
    351  template<typename It>
    352  object_type * batch(It first, It last) {
    353  static_assert(std::is_default_constructible_v<object_type>);
    354  const auto skip = instances.size();
    355  instances.insert(instances.end(), last-first, {});
    356  // entity goes after component in case constructor throws
    357  underlying_type::batch(first, last);
    358  return instances.data() + skip;
    359  }
    360 
    372  void destroy(const entity_type entt) override {
    373  std::swap(instances[underlying_type::get(entt)], instances.back());
    374  instances.pop_back();
    375  underlying_type::destroy(entt);
    376  }
    377 
    420  template<typename Compare, typename Sort = std_sort, typename... Args>
    421  void sort(Compare compare, Sort algo = Sort{}, Args &&... args) {
    422  std::vector<size_type> copy(instances.size());
    423  std::iota(copy.begin(), copy.end(), 0);
    424 
    425  if constexpr(std::is_invocable_v<Compare, const object_type &, const object_type &>) {
    426  static_assert(!std::is_empty_v<object_type>);
    427 
    428  algo(copy.rbegin(), copy.rend(), [this, compare = std::move(compare)](const auto lhs, const auto rhs) {
    429  return compare(std::as_const(instances[lhs]), std::as_const(instances[rhs]));
    430  }, std::forward<Args>(args)...);
    431  } else {
    432  algo(copy.rbegin(), copy.rend(), [compare = std::move(compare), data = underlying_type::data()](const auto lhs, const auto rhs) {
    433  return compare(data[lhs], data[rhs]);
    434  }, std::forward<Args>(args)...);
    435  }
    436 
    437  for(size_type pos = 0, last = copy.size(); pos < last; ++pos) {
    438  auto curr = pos;
    439  auto next = copy[curr];
    440 
    441  while(curr != next) {
    442  const auto lhs = copy[curr];
    443  const auto rhs = copy[next];
    444  std::swap(instances[lhs], instances[rhs]);
    445  underlying_type::swap(lhs, rhs);
    446  copy[curr] = curr;
    447  curr = next;
    448  next = copy[curr];
    449  }
    450  }
    451  }
    452 
    475  void respect(const sparse_set<Entity> &other) ENTT_NOEXCEPT override {
    476  const auto to = other.end();
    477  auto from = other.begin();
    478 
    479  size_type pos = underlying_type::size() - 1;
    480  const auto *local = underlying_type::data();
    481 
    482  while(pos && from != to) {
    483  const auto curr = *from;
    484 
    485  if(underlying_type::has(curr)) {
    486  if(curr != *(local + pos)) {
    487  auto candidate = underlying_type::get(curr);
    488  std::swap(instances[pos], instances[candidate]);
    489  underlying_type::swap(pos, candidate);
    490  }
    491 
    492  --pos;
    493  }
    494 
    495  ++from;
    496  }
    497  }
    498 
    500  void reset() override {
    501  underlying_type::reset();
    502  instances.clear();
    503  }
    504 
    505 private:
    506  std::vector<object_type> instances;
    507 };
    508 
    509 
    511 template<typename Entity, typename Type>
    512 class basic_storage<Entity, Type, std::enable_if_t<std::is_empty_v<Type>>>: public sparse_set<Entity> {
    513  using underlying_type = sparse_set<Entity>;
    514  using traits_type = entt_traits<Entity>;
    515 
    516  class iterator {
    517  friend class basic_storage<Entity, Type>;
    518 
    519  using index_type = typename traits_type::difference_type;
    520 
    521  iterator(const index_type idx) ENTT_NOEXCEPT
    522  : index{idx}
    523  {}
    524 
    525  public:
    526  using difference_type = index_type;
    527  using value_type = Type;
    528  using pointer = const value_type *;
    529  using reference = value_type;
    530  using iterator_category = std::input_iterator_tag;
    531 
    532  iterator() ENTT_NOEXCEPT = default;
    533 
    534  iterator & operator++() ENTT_NOEXCEPT {
    535  return --index, *this;
    536  }
    537 
    538  iterator operator++(int) ENTT_NOEXCEPT {
    539  iterator orig = *this;
    540  return ++(*this), orig;
    541  }
    542 
    543  iterator & operator--() ENTT_NOEXCEPT {
    544  return ++index, *this;
    545  }
    546 
    547  iterator operator--(int) ENTT_NOEXCEPT {
    548  iterator orig = *this;
    549  return --(*this), orig;
    550  }
    551 
    552  iterator & operator+=(const difference_type value) ENTT_NOEXCEPT {
    553  index -= value;
    554  return *this;
    555  }
    556 
    557  iterator operator+(const difference_type value) const ENTT_NOEXCEPT {
    558  return iterator{index-value};
    559  }
    560 
    561  inline iterator & operator-=(const difference_type value) ENTT_NOEXCEPT {
    562  return (*this += -value);
    563  }
    564 
    565  inline iterator operator-(const difference_type value) const ENTT_NOEXCEPT {
    566  return (*this + -value);
    567  }
    568 
    569  difference_type operator-(const iterator &other) const ENTT_NOEXCEPT {
    570  return other.index - index;
    571  }
    572 
    573  reference operator[](const difference_type) const ENTT_NOEXCEPT {
    574  return {};
    575  }
    576 
    577  bool operator==(const iterator &other) const ENTT_NOEXCEPT {
    578  return other.index == index;
    579  }
    580 
    581  inline bool operator!=(const iterator &other) const ENTT_NOEXCEPT {
    582  return !(*this == other);
    583  }
    584 
    585  bool operator<(const iterator &other) const ENTT_NOEXCEPT {
    586  return index > other.index;
    587  }
    588 
    589  bool operator>(const iterator &other) const ENTT_NOEXCEPT {
    590  return index < other.index;
    591  }
    592 
    593  inline bool operator<=(const iterator &other) const ENTT_NOEXCEPT {
    594  return !(*this > other);
    595  }
    596 
    597  inline bool operator>=(const iterator &other) const ENTT_NOEXCEPT {
    598  return !(*this < other);
    599  }
    600 
    601  pointer operator->() const ENTT_NOEXCEPT {
    602  return nullptr;
    603  }
    604 
    605  inline reference operator*() const ENTT_NOEXCEPT {
    606  return {};
    607  }
    608 
    609  private:
    610  index_type index;
    611  };
    612 
    613 public:
    615  using object_type = Type;
    617  using entity_type = typename underlying_type::entity_type;
    619  using size_type = typename underlying_type::size_type;
    621  using iterator_type = iterator;
    622 
    635  iterator_type cbegin() const ENTT_NOEXCEPT {
    636  const typename traits_type::difference_type pos = underlying_type::size();
    637  return iterator_type{pos};
    638  }
    639 
    641  inline iterator_type begin() const ENTT_NOEXCEPT {
    642  return cbegin();
    643  }
    644 
    659  iterator_type cend() const ENTT_NOEXCEPT {
    660  return iterator_type{};
    661  }
    662 
    664  inline iterator_type end() const ENTT_NOEXCEPT {
    665  return cend();
    666  }
    667 
    684  object_type get([[maybe_unused]] const entity_type entt) const ENTT_NOEXCEPT {
    685  ENTT_ASSERT(underlying_type::has(entt));
    686  return {};
    687  }
    688 };
    689 
    691 template<typename Entity, typename Type>
    692 struct storage: basic_storage<Entity, Type> {};
    693 
    694 
    695 }
    696 
    697 
    698 #endif // ENTT_ENTITY_STORAGE_HPP
    entt::basic_storage::reset
    void reset() override
    Resets a storage.
    Definition: storage.hpp:500
    +
    entt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >::cbegin
    iterator_type cbegin() const ENTT_NOEXCEPT
    Returns an iterator to the beginning.
    Definition: storage.hpp:635
    +
    entt::sparse_set::swap
    void swap(const size_type lhs, const size_type rhs) ENTT_NOEXCEPT
    Swaps the position of two entities in the internal packed array.
    Definition: sparse_set.hpp:471
    +
    entt::basic_storage::batch
    object_type * batch(It first, It last)
    Assigns one or more entities to a storage and constructs their objects.
    Definition: storage.hpp:352
    +
    entt::sparse_set
    Basic sparse set implementation.
    Definition: sparse_set.hpp:46
    +
    entt::basic_storage< Entity, Component >::const_iterator_type
    iterator< true > const_iterator_type
    Constant random access iterator type.
    Definition: storage.hpp:166
    +
    entt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >::end
    iterator_type end() const ENTT_NOEXCEPT
    Returns an iterator to the end.
    Definition: storage.hpp:664
    +
    entt::basic_storage::try_get
    const object_type * try_get(const entity_type entt) const ENTT_NOEXCEPT
    Returns a pointer to the object associated with an entity, if any.
    Definition: storage.hpp:293
    +
    entt::sparse_set::size
    size_type size() const ENTT_NOEXCEPT
    Returns the number of elements in a sparse set.
    Definition: sparse_set.hpp:284
    +
    entt::basic_storage::construct
    object_type & construct(const entity_type entt, Args &&... args)
    Assigns an entity to a storage and constructs its object.
    Definition: storage.hpp:321
    +
    entt::basic_storage::end
    const_iterator_type end() const ENTT_NOEXCEPT
    Returns an iterator to the end.
    Definition: storage.hpp:258
    +
    entt::sparse_set::batch
    void batch(It first, It last)
    Assigns one or more entities to a sparse set.
    Definition: sparse_set.hpp:422
    +
    entt::sparse_set::data
    const entity_type * data() const ENTT_NOEXCEPT
    Direct access to the internal packed array.
    Definition: sparse_set.hpp:311
    +
    entt::sparse_set::get
    size_type get(const entity_type entt) const ENTT_NOEXCEPT
    Returns the position of an entity in a sparse set.
    Definition: sparse_set.hpp:382
    +
    entt::basic_storage::begin
    iterator_type begin() ENTT_NOEXCEPT
    Returns an iterator to the beginning.
    Definition: storage.hpp:234
    +
    entt
    EnTT default namespace.
    Definition: algorithm.hpp:10
    +
    entt::sparse_set::has
    bool has(const entity_type entt) const ENTT_NOEXCEPT
    Checks if a sparse set contains an entity.
    Definition: sparse_set.hpp:364
    +
    entt::sparse_set::size_type
    std::size_t size_type
    Unsigned integer type.
    Definition: sparse_set.hpp:176
    +
    entt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >::begin
    iterator_type begin() const ENTT_NOEXCEPT
    Returns an iterator to the beginning.
    Definition: storage.hpp:641
    +
    entt::sparse_set::reserve
    virtual void reserve(const size_type cap)
    Increases the capacity of a sparse set.
    Definition: sparse_set.hpp:231
    +
    entt::sparse_set::reset
    virtual void reset()
    Resets a sparse set.
    Definition: sparse_set.hpp:521
    +
    entt::basic_storage::shrink_to_fit
    void shrink_to_fit() override
    Requests the removal of unused capacity.
    Definition: storage.hpp:182
    +
    entt::storage
    Basic storage implementation.
    Definition: storage.hpp:692
    +
    entt::basic_storage::cbegin
    const_iterator_type cbegin() const ENTT_NOEXCEPT
    Returns an iterator to the beginning.
    Definition: storage.hpp:223
    +
    entt::basic_storage::begin
    const_iterator_type begin() const ENTT_NOEXCEPT
    Returns an iterator to the beginning.
    Definition: storage.hpp:229
    +
    entt::sparse_set::shrink_to_fit
    virtual void shrink_to_fit()
    Requests the removal of unused capacity.
    Definition: sparse_set.hpp:245
    +
    entt::basic_storage
    Basic storage implementation.
    Definition: storage.hpp:50
    +
    entt::sparse_set::entity_type
    Entity entity_type
    Underlying entity identifier.
    Definition: sparse_set.hpp:174
    +
    entt::sparse_set::destroy
    virtual void destroy(const entity_type entt)
    Removes an entity from a sparse set.
    Definition: sparse_set.hpp:445
    +
    entt::basic_storage::try_get
    object_type * try_get(const entity_type entt) ENTT_NOEXCEPT
    Returns a pointer to the object associated with an entity, if any.
    Definition: storage.hpp:298
    +
    entt::basic_storage::destroy
    void destroy(const entity_type entt) override
    Removes an entity from a storage and destroys its object.
    Definition: storage.hpp:372
    +
    entt::std_sort
    Function object to wrap std::sort in a class type.
    Definition: algorithm.hpp:21
    +
    entt::basic_storage::size_type
    typename underlying_type::size_type size_type
    Unsigned integer type.
    Definition: storage.hpp:162
    +
    entt::basic_storage::raw
    object_type * raw() ENTT_NOEXCEPT
    Direct access to the array of objects.
    Definition: storage.hpp:207
    +
    entt::basic_storage::end
    iterator_type end() ENTT_NOEXCEPT
    Returns an iterator to the end.
    Definition: storage.hpp:263
    +
    entt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >::object_type
    Type object_type
    Type of the objects associated with the entities.
    Definition: storage.hpp:615
    +
    entt::basic_storage< Entity, Component >::object_type
    Component object_type
    Type of the objects associated with the entities.
    Definition: storage.hpp:158
    +
    entt::basic_storage::sort
    void sort(Compare compare, Sort algo=Sort{}, Args &&... args)
    Sort instances according to the given comparison function.
    Definition: storage.hpp:421
    +
    entt::basic_storage::cend
    const_iterator_type cend() const ENTT_NOEXCEPT
    Returns an iterator to the end.
    Definition: storage.hpp:253
    +
    entt::basic_storage::raw
    const object_type * raw() const ENTT_NOEXCEPT
    Direct access to the array of objects.
    Definition: storage.hpp:202
    +
    entt::basic_storage::respect
    void respect(const sparse_set< Entity > &other) ENTT_NOEXCEPT override
    Sort instances according to the order of the entities in another sparse set.
    Definition: storage.hpp:475
    +
    entt::basic_storage::reserve
    void reserve(const size_type cap) override
    Increases the capacity of a storage.
    Definition: storage.hpp:176
    +
    entt::basic_storage< Entity, Type, std::enable_if_t< std::is_empty_v< Type > > >::cend
    iterator_type cend() const ENTT_NOEXCEPT
    Returns an iterator to the end.
    Definition: storage.hpp:659
    +
    entt::entt_traits
    Entity traits.
    Definition: entity.hpp:18
    +
    entt::operator!=
    constexpr bool operator!=(const hashed_string &lhs, const hashed_string &rhs) ENTT_NOEXCEPT
    Compares two hashed strings.
    Definition: hashed_string.hpp:195
    +
    entt::sparse_set::iterator_type
    iterator iterator_type
    Random access iterator type.
    Definition: sparse_set.hpp:178
    +
    entt::sparse_set::construct
    void construct(const entity_type entt)
    Assigns an entity to a sparse set.
    Definition: sparse_set.hpp:399
    +
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/structentt_1_1Actor-members.html b/structentt_1_1Actor-members.html deleted file mode 100644 index a85581094..000000000 --- a/structentt_1_1Actor-members.html +++ /dev/null @@ -1,102 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::Actor< Entity > Member List
    -
    -
    - -

    This is the complete list of members for entt::Actor< Entity >, including all inherited members.

    - - - - - - - - - - - - - - - - - - - - - - -
    Actor(Registry< Entity > &reg)entt::Actor< Entity >inline
    Actor(const Actor &)=deleteentt::Actor< Entity >
    Actor(Actor &&other)entt::Actor< Entity >inline
    assign(tag_t, Args &&... args)entt::Actor< Entity >inline
    assign(Args &&... args)entt::Actor< Entity >inline
    entity() const ENTT_NOEXCEPTentt::Actor< Entity >inline
    entity_type typedefentt::Actor< Entity >
    get(tag_t) const ENTT_NOEXCEPTentt::Actor< Entity >inline
    get(tag_t) ENTT_NOEXCEPTentt::Actor< Entity >inline
    get() const ENTT_NOEXCEPTentt::Actor< Entity >inline
    get() ENTT_NOEXCEPTentt::Actor< Entity >inline
    has(tag_t) const ENTT_NOEXCEPTentt::Actor< Entity >inline
    has() const ENTT_NOEXCEPTentt::Actor< Entity >inline
    operator=(const Actor &)=deleteentt::Actor< Entity >
    operator=(Actor &&other)entt::Actor< Entity >inline
    registry() const ENTT_NOEXCEPTentt::Actor< Entity >inline
    registry() ENTT_NOEXCEPTentt::Actor< Entity >inline
    registry_type typedefentt::Actor< Entity >
    remove(tag_t)entt::Actor< Entity >inline
    remove()entt::Actor< Entity >inline
    ~Actor()entt::Actor< Entity >inlinevirtual
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1Actor.html b/structentt_1_1Actor.html deleted file mode 100644 index d9ebf88a5..000000000 --- a/structentt_1_1Actor.html +++ /dev/null @@ -1,865 +0,0 @@ - - - - - - - -EnTT: entt::Actor< Entity > Struct Template Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Public Types | -Public Member Functions | -List of all members
    -
    -
    entt::Actor< Entity > Struct Template Reference
    -
    -
    - -

    Dedicated to those who aren't confident with entity-component systems. - More...

    - -

    #include <actor.hpp>

    - - - - - - - - -

    -Public Types

    -using registry_type = Registry< Entity >
     Type of registry used internally.
     
    -using entity_type = Entity
     Underlying entity identifier.
     
    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

    -Public Member Functions

     Actor (Registry< Entity > &reg)
     Constructs an actor by using the given registry. More...
     
    -virtual ~Actor ()
     Default destructor.
     
    - Actor (const Actor &)=delete
     Copying an actor isn't allowed.
     
     Actor (Actor &&other)
     Move constructor. More...
     
    Actor & operator= (const Actor &)=delete
     Default copy assignment operator. More...
     
    Actor & operator= (Actor &&other)
     Move assignment operator. More...
     
    template<typename Tag , typename... Args>
    Tag & assign (tag_t, Args &&... args)
     Assigns the given tag to an actor. More...
     
    template<typename Component , typename... Args>
    Component & assign (Args &&... args)
     Assigns the given component to an actor. More...
     
    template<typename Tag >
    void remove (tag_t)
     Removes the given tag from an actor. More...
     
    template<typename Component >
    void remove ()
     Removes the given component from an actor. More...
     
    template<typename Tag >
    bool has (tag_t) const ENTT_NOEXCEPT
     Checks if an actor owns the given tag. More...
     
    template<typename Component >
    bool has () const ENTT_NOEXCEPT
     Checks if an actor has the given component. More...
     
    template<typename Tag >
    const Tag & get (tag_t) const ENTT_NOEXCEPT
     Returns a reference to the given tag for an actor. More...
     
    template<typename Tag >
    Tag & get (tag_t) ENTT_NOEXCEPT
     Returns a reference to the given tag for an actor. More...
     
    template<typename Component >
    const Component & get () const ENTT_NOEXCEPT
     Returns a reference to the given component for an actor. More...
     
    template<typename Component >
    Component & get () ENTT_NOEXCEPT
     Returns a reference to the given component for an actor. More...
     
    const registry_type & registry () const ENTT_NOEXCEPT
     Returns a reference to the underlying registry. More...
     
    registry_type & registry () ENTT_NOEXCEPT
     Returns a reference to the underlying registry. More...
     
    entity_type entity () const ENTT_NOEXCEPT
     Returns the entity associated with an actor. More...
     
    -

    Detailed Description

    -

    template<typename Entity>
    -struct entt::Actor< Entity >

    - -

    Dedicated to those who aren't confident with entity-component systems.

    -

    Tiny wrapper around a registry, for all those users that aren't confident with entity-component systems and prefer to iterate objects directly.

    -
    Template Parameters
    - - -
    EntityA valid entity type (see entt_traits for more details).
    -
    -
    - -

    Definition at line 24 of file actor.hpp.

    -

    Constructor & Destructor Documentation

    - -

    ◆ Actor() [1/2]

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - - -
    entt::Actor< Entity >::Actor (Registry< Entity > & reg)
    -     		-inline
    -
    - -

    Constructs an actor by using the given registry.

    -
    Parameters
    - - -
    regAn entity-component system properly initialized.
    -
    -
    - -

    Definition at line 34 of file actor.hpp.

    - -
    -
    - -

    ◆ Actor() [2/2]

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - - -
    entt::Actor< Entity >::Actor (Actor< Entity > && other)
    -     		-inline
    -
    - -

    Move constructor.

    -

    After actor move construction, instances that have been moved from are placed in a valid but unspecified state. It's highly discouraged to continue using them.

    -
    Parameters
    - - -
    otherThe instance to move from.
    -
    -
    - -

    Definition at line 55 of file actor.hpp.

    - -
    -
    -

    Member Function Documentation

    - -

    ◆ assign() [1/2]

    - -
    -
    -
    -template<typename Entity >
    -
    -template<typename Tag , typename... Args>
    - - - - - -
    - - - - - - - - - - - - - - - - - - -
    Tag& entt::Actor< Entity >::assign (tag_t ,
    Args &&... args 
    )
    -     		-inline
    -
    - -

    Assigns the given tag to an actor.

    -

    A new instance of the given tag is created and initialized with the arguments provided (the tag must have a proper constructor or be of aggregate type). Then the tag is removed from its previous owner (if any) and assigned to the actor.

    -
    Template Parameters
    - - - -
    TagType of the tag to create.
    ArgsTypes of arguments to use to construct the tag.
    -
    -
    -
    Parameters
    - - -
    argsParameters to use to initialize the tag.
    -
    -
    -
    Returns
    A reference to the newly created tag.
    - -

    Definition at line 98 of file actor.hpp.

    - -
    -
    - -

    ◆ assign() [2/2]

    - -
    -
    -
    -template<typename Entity >
    -
    -template<typename Component , typename... Args>
    - - - - - -
    - - - - - - - - -
    Component& entt::Actor< Entity >::assign (Args &&... args)
    -     		-inline
    -
    - -

    Assigns the given component to an actor.

    -

    A new instance of the given component is created and initialized with the arguments provided (the component must have a proper constructor or be of aggregate type). Then the component is assigned to the actor.
    - In case the actor already has a component of the given type, it's replaced with the new one.

    -
    Template Parameters
    - - - -
    ComponentType of the component to create.
    ArgsTypes of arguments to use to construct the component.
    -
    -
    -
    Parameters
    - - -
    argsParameters to use to initialize the component.
    -
    -
    -
    Returns
    A reference to the newly created component.
    - -

    Definition at line 117 of file actor.hpp.

    - -
    -
    - -

    ◆ entity()

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - -
    entity_type entt::Actor< Entity >::entity () const
    -     		-inline
    -
    - -

    Returns the entity associated with an actor.

    -
    Returns
    The entity associated with the actor.
    - -

    Definition at line 221 of file actor.hpp.

    - -
    -
    - -

    ◆ get() [1/4]

    - -
    -
    -
    -template<typename Entity >
    -
    -template<typename Tag >
    - - - - - -
    - - - - - - - - -
    const Tag& entt::Actor< Entity >::get (tag_t ) const
    -     		-inline
    -
    - -

    Returns a reference to the given tag for an actor.

    -
    Template Parameters
    - - -
    TagType of the tag to get.
    -
    -
    -
    Returns
    A reference to the instance of the tag owned by the actor.
    - -

    Definition at line 166 of file actor.hpp.

    - -
    -
    - -

    ◆ get() [2/4]

    - -
    -
    -
    -template<typename Entity >
    -
    -template<typename Tag >
    - - - - - -
    - - - - - - - - -
    Tag& entt::Actor< Entity >::get (tag_t )
    -     		-inline
    -
    - -

    Returns a reference to the given tag for an actor.

    -
    Template Parameters
    - - -
    TagType of the tag to get.
    -
    -
    -
    Returns
    A reference to the instance of the tag owned by the actor.
    - -

    Definition at line 177 of file actor.hpp.

    - -
    -
    - -

    ◆ get() [3/4]

    - -
    -
    -
    -template<typename Entity >
    -
    -template<typename Component >
    - - - - - -
    - - - - - - - -
    const Component& entt::Actor< Entity >::get () const
    -     		-inline
    -
    - -

    Returns a reference to the given component for an actor.

    -
    Template Parameters
    - - -
    ComponentType of the component to get.
    -
    -
    -
    Returns
    A reference to the instance of the component owned by the actor.
    - -

    Definition at line 187 of file actor.hpp.

    - -
    -
    - -

    ◆ get() [4/4]

    - -
    -
    -
    -template<typename Entity >
    -
    -template<typename Component >
    - - - - - -
    - - - - - - - -
    Component& entt::Actor< Entity >::get ()
    -     		-inline
    -
    - -

    Returns a reference to the given component for an actor.

    -
    Template Parameters
    - - -
    ComponentType of the component to get.
    -
    -
    -
    Returns
    A reference to the instance of the component owned by the actor.
    - -

    Definition at line 197 of file actor.hpp.

    - -
    -
    - -

    ◆ has() [1/2]

    - -
    -
    -
    -template<typename Entity >
    -
    -template<typename Tag >
    - - - - - -
    - - - - - - - - -
    bool entt::Actor< Entity >::has (tag_t ) const
    -     		-inline
    -
    - -

    Checks if an actor owns the given tag.

    -
    Template Parameters
    - - -
    TagType of the tag for which to perform the check.
    -
    -
    -
    Returns
    True if the actor owns the tag, false otherwise.
    - -

    Definition at line 146 of file actor.hpp.

    - -
    -
    - -

    ◆ has() [2/2]

    - -
    -
    -
    -template<typename Entity >
    -
    -template<typename Component >
    - - - - - -
    - - - - - - - -
    bool entt::Actor< Entity >::has () const
    -     		-inline
    -
    - -

    Checks if an actor has the given component.

    -
    Template Parameters
    - - -
    ComponentType of the component for which to perform the check.
    -
    -
    -
    Returns
    True if the actor has the component, false otherwise.
    - -

    Definition at line 156 of file actor.hpp.

    - -
    -
    - -

    ◆ operator=() [1/2]

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - - -
    Actor& entt::Actor< Entity >::operator= (const Actor< Entity > & )
    -     		-delete
    -
    - -

    Default copy assignment operator.

    -
    Returns
    This actor.
    - -
    -
    - -

    ◆ operator=() [2/2]

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - - -
    Actor& entt::Actor< Entity >::operator= (Actor< Entity > && other)
    -     		-inline
    -
    - -

    Move assignment operator.

    -

    After actor move assignment, instances that have been moved from are placed in a valid but unspecified state. It's highly discouraged to continue using them.

    -
    Parameters
    - - -
    otherThe instance to move from.
    -
    -
    -
    Returns
    This actor.
    - -

    Definition at line 74 of file actor.hpp.

    - -
    -
    - -

    ◆ registry() [1/2]

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - -
    const registry_type& entt::Actor< Entity >::registry () const
    -     		-inline
    -
    - -

    Returns a reference to the underlying registry.

    -
    Returns
    A reference to the underlying registry.
    - -

    Definition at line 205 of file actor.hpp.

    - -
    -
    - -

    ◆ registry() [2/2]

    - -
    -
    -
    -template<typename Entity >
    - - - - - -
    - - - - - - - -
    registry_type& entt::Actor< Entity >::registry ()
    -     		-inline
    -
    - -

    Returns a reference to the underlying registry.

    -
    Returns
    A reference to the underlying registry.
    - -

    Definition at line 213 of file actor.hpp.

    - -
    -
    - -

    ◆ remove() [1/2]

    - -
    -
    -
    -template<typename Entity >
    -
    -template<typename Tag >
    - - - - - -
    - - - - - - - - -
    void entt::Actor< Entity >::remove (tag_t )
    -     		-inline
    -
    - -

    Removes the given tag from an actor.

    -
    Template Parameters
    - - -
    TagType of the tag to remove.
    -
    -
    - -

    Definition at line 126 of file actor.hpp.

    - -
    -
    - -

    ◆ remove() [2/2]

    - -
    -
    -
    -template<typename Entity >
    -
    -template<typename Component >
    - - - - - -
    - - - - - - - -
    void entt::Actor< Entity >::remove ()
    -     		-inline
    -
    - -

    Removes the given component from an actor.

    -
    Template Parameters
    - - -
    ComponentType of the component to remove.
    -
    -
    - -

    Definition at line 136 of file actor.hpp.

    - -
    -
    -
    The documentation for this struct was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1Emitter_1_1Connection-members.html b/structentt_1_1Emitter_1_1Connection-members.html deleted file mode 100644 index cfb0d46b4..000000000 --- a/structentt_1_1Emitter_1_1Connection-members.html +++ /dev/null @@ -1,88 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::Emitter< Derived >::Connection< Event > Member List
    -
    -
    - -

    This is the complete list of members for entt::Emitter< Derived >::Connection< Event >, including all inherited members.

    - - - - - - - - -
    Connection() ENTT_NOEXCEPT=defaultentt::Emitter< Derived >::Connection< Event >
    Connection(typename Handler< Event >::connection_type conn)entt::Emitter< Derived >::Connection< Event >inline
    Connection(const Connection &)=defaultentt::Emitter< Derived >::Connection< Event >
    Connection(Connection &&)=defaultentt::Emitter< Derived >::Connection< Event >
    Emitter classentt::Emitter< Derived >::Connection< Event >friend
    operator=(const Connection &)=defaultentt::Emitter< Derived >::Connection< Event >
    operator=(Connection &&)=defaultentt::Emitter< Derived >::Connection< Event >
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1Emitter_1_1Connection.html b/structentt_1_1Emitter_1_1Connection.html deleted file mode 100644 index e6de51638..000000000 --- a/structentt_1_1Emitter_1_1Connection.html +++ /dev/null @@ -1,256 +0,0 @@ - - - - - - - -EnTT: entt::Emitter< Derived >::Connection< Event > Struct Template Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Public Member Functions | -Friends | -List of all members
    -
    -
    entt::Emitter< Derived >::Connection< Event > Struct Template Referencefinal
    -
    -
    - -

    Generic connection type for events. - More...

    - -

    #include <emitter.hpp>

    -
    -Inheritance diagram for entt::Emitter< Derived >::Connection< Event >:
    -
    -
    Inheritance graph
    -
    [legend]
    -
    -Collaboration diagram for entt::Emitter< Derived >::Connection< Event >:
    -
    -
    Collaboration graph
    -
    [legend]
    - - - - - - - - - - - - - - - - - - - - -

    -Public Member Functions

    - Connection () ENTT_NOEXCEPT=default
     Default constructor.
     
     Connection (typename Handler< Event >::connection_type conn)
     Creates a connection that wraps its underlying instance. More...
     
    - Connection (const Connection &)=default
     Default copy constructor.
     
    - Connection (Connection &&)=default
     Default move constructor.
     
    Connection & operator= (const Connection &)=default
     Default copy assignment operator. More...
     
    Connection & operator= (Connection &&)=default
     Default move assignment operator. More...
     
    - - - - -

    -Friends

    -class Emitter
     Event emitters are friend classes of connections.
     
    -

    Detailed Description

    -

    template<typename Derived>
    -template<typename Event>
    -struct entt::Emitter< Derived >::Connection< Event >

    - -

    Generic connection type for events.

    -

    Type of the connection object returned by the event emitter whenever a listener for the given type is registered.
    - It can be used to break connections still in use.

    -
    Template Parameters
    - - -
    EventType of event for which the connection is created.
    -
    -
    - -

    Definition at line 148 of file emitter.hpp.

    -

    Constructor & Destructor Documentation

    - -

    ◆ Connection()

    - -
    -
    -
    -template<typename Derived >
    -
    -template<typename Event>
    - - - - - -
    - - - - - - - - -
    entt::Emitter< Derived >::Connection< Event >::Connection (typename Handler< Event >::connection_type conn)
    -     		-inline
    -
    - -

    Creates a connection that wraps its underlying instance.

    -
    Parameters
    - - -
    connA connection object to wrap.
    -
    -
    - -

    Definition at line 159 of file emitter.hpp.

    - -
    -
    -

    Member Function Documentation

    - -

    ◆ operator=() [1/2]

    - -
    -
    -
    -template<typename Derived >
    -
    -template<typename Event>
    - - - - - -
    - - - - - - - - -
    Connection& entt::Emitter< Derived >::Connection< Event >::operator= (const Connection< Event > & )
    -     		-default
    -
    - -

    Default copy assignment operator.

    -
    Returns
    This connection.
    - -
    -
    - -

    ◆ operator=() [2/2]

    - -
    -
    -
    -template<typename Derived >
    -
    -template<typename Event>
    - - - - - -
    - - - - - - - - -
    Connection& entt::Emitter< Derived >::Connection< Event >::operator= (Connection< Event > && )
    -     		-default
    -
    - -

    Default move assignment operator.

    -
    Returns
    This connection.
    - -
    -
    -
    The documentation for this struct was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1Emitter_1_1Connection__coll__graph.map b/structentt_1_1Emitter_1_1Connection__coll__graph.map deleted file mode 100644 index 806b027f5..000000000 --- a/structentt_1_1Emitter_1_1Connection__coll__graph.map +++ /dev/null @@ -1,2 +0,0 @@ - - diff --git a/structentt_1_1Emitter_1_1Connection__coll__graph.md5 b/structentt_1_1Emitter_1_1Connection__coll__graph.md5 deleted file mode 100644 index a17e69278..000000000 --- a/structentt_1_1Emitter_1_1Connection__coll__graph.md5 +++ /dev/null @@ -1 +0,0 @@ -ec6823a57284c490578d2bb95074b9df \ No newline at end of file diff --git a/structentt_1_1Emitter_1_1Connection__coll__graph.png b/structentt_1_1Emitter_1_1Connection__coll__graph.png deleted file mode 100644 index 89400e124..000000000 Binary files a/structentt_1_1Emitter_1_1Connection__coll__graph.png and /dev/null differ diff --git a/structentt_1_1Emitter_1_1Connection__inherit__graph.map b/structentt_1_1Emitter_1_1Connection__inherit__graph.map deleted file mode 100644 index 806b027f5..000000000 --- a/structentt_1_1Emitter_1_1Connection__inherit__graph.map +++ /dev/null @@ -1,2 +0,0 @@ - - diff --git a/structentt_1_1Emitter_1_1Connection__inherit__graph.md5 b/structentt_1_1Emitter_1_1Connection__inherit__graph.md5 deleted file mode 100644 index 9f7fc8bc0..000000000 --- a/structentt_1_1Emitter_1_1Connection__inherit__graph.md5 +++ /dev/null @@ -1 +0,0 @@ -4946d4a1c9c29f738db9053133bb558f \ No newline at end of file diff --git a/structentt_1_1Emitter_1_1Connection__inherit__graph.png b/structentt_1_1Emitter_1_1Connection__inherit__graph.png deleted file mode 100644 index 89400e124..000000000 Binary files a/structentt_1_1Emitter_1_1Connection__inherit__graph.png and /dev/null differ diff --git a/structentt_1_1MetaAny-members.html b/structentt_1_1MetaAny-members.html deleted file mode 100644 index 288c49597..000000000 --- a/structentt_1_1MetaAny-members.html +++ /dev/null @@ -1,100 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::MetaAny Member List
    -
    -
    - -

    This is the complete list of members for entt::MetaAny, including all inherited members.

    - - - - - - - - - - - - - - - - - - - - -
    convertible() const ENTT_NOEXCEPT (defined in entt::MetaAny)entt::MetaAnyinline
    data() const ENTT_NOEXCEPT (defined in entt::MetaAny)entt::MetaAnyinline
    data() ENTT_NOEXCEPT (defined in entt::MetaAny)entt::MetaAnyinline
    data() const ENTT_NOEXCEPT (defined in entt::MetaAny)entt::MetaAnyinline
    data() ENTT_NOEXCEPT (defined in entt::MetaAny)entt::MetaAnyinline
    MetaAny() ENTT_NOEXCEPT=default (defined in entt::MetaAny)entt::MetaAny
    MetaAny(Type &&type) (defined in entt::MetaAny)entt::MetaAnyinline
    MetaAny(const MetaAny &)=delete (defined in entt::MetaAny)entt::MetaAny
    MetaAny(MetaAny &&)=default (defined in entt::MetaAny)entt::MetaAny
    operator bool() const ENTT_NOEXCEPT (defined in entt::MetaAny)entt::MetaAnyinlineexplicit
    operator const void *() const ENTT_NOEXCEPT (defined in entt::MetaAny)entt::MetaAnyinline
    operator void *() ENTT_NOEXCEPT (defined in entt::MetaAny)entt::MetaAnyinline
    operator=(const MetaAny &other)=delete (defined in entt::MetaAny)entt::MetaAny
    operator=(MetaAny &&)=default (defined in entt::MetaAny)entt::MetaAny
    operator==(const MetaAny &other) const ENTT_NOEXCEPT (defined in entt::MetaAny)entt::MetaAnyinline
    to() const ENTT_NOEXCEPT (defined in entt::MetaAny)entt::MetaAnyinline
    to() ENTT_NOEXCEPT (defined in entt::MetaAny)entt::MetaAnyinline
    type() const ENTT_NOEXCEPT (defined in entt::MetaAny)entt::MetaAnyinline
    valid() const ENTT_NOEXCEPT (defined in entt::MetaAny)entt::MetaAnyinline
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1MetaAny.html b/structentt_1_1MetaAny.html deleted file mode 100644 index 4c06ff190..000000000 --- a/structentt_1_1MetaAny.html +++ /dev/null @@ -1,151 +0,0 @@ - - - - - - - -EnTT: entt::MetaAny Struct Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Public Member Functions | -List of all members
    -
    -
    entt::MetaAny Struct Referencefinal
    -
    -
    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

    -Public Member Functions

    -template<typename Type >
     MetaAny (Type &&type)
     
    - MetaAny (const MetaAny &)=delete
     
    - MetaAny (MetaAny &&)=default
     
    -MetaAny & operator= (const MetaAny &other)=delete
     
    -MetaAny & operator= (MetaAny &&)=default
     
    -bool valid () const ENTT_NOEXCEPT
     
    -MetaType * type () const ENTT_NOEXCEPT
     
    -template<typename Type >
    bool convertible () const ENTT_NOEXCEPT
     
    -template<typename Type >
    const std::decay_t< Type > & to () const ENTT_NOEXCEPT
     
    -template<typename Type >
    std::decay_t< Type > & to () ENTT_NOEXCEPT
     
    -template<typename Type >
    const Type * data () const ENTT_NOEXCEPT
     
    -template<typename Type >
    Type * data () ENTT_NOEXCEPT
     
    -const void * data () const ENTT_NOEXCEPT
     
    -void * data () ENTT_NOEXCEPT
     
    - operator const void * () const ENTT_NOEXCEPT
     
    - operator void * () ENTT_NOEXCEPT
     
    - operator bool () const ENTT_NOEXCEPT
     
    -bool operator== (const MetaAny &other) const ENTT_NOEXCEPT
     
    -

    Detailed Description

    -
    -

    Definition at line 264 of file meta.hpp.

    -
    The documentation for this struct was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1OneShotBubbleSort.html b/structentt_1_1OneShotBubbleSort.html deleted file mode 100644 index 26b01646e..000000000 --- a/structentt_1_1OneShotBubbleSort.html +++ /dev/null @@ -1,166 +0,0 @@ - - - - - - - -EnTT: entt::OneShotBubbleSort Struct Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Public Member Functions | -List of all members
    -
    -
    entt::OneShotBubbleSort Struct Referencefinal
    -
    -
    - -

    Function object for performing bubble sort (single iteration). - More...

    - -

    #include <algorithm.hpp>

    - - - - - - -

    -Public Member Functions

    template<typename It , typename Compare = std::less<>>
    void operator() (It first, It last, Compare compare=Compare{}) const
     Tries to sort the elements in a range. More...
     
    -

    Detailed Description

    -

    Function object for performing bubble sort (single iteration).

    - -

    Definition at line 76 of file algorithm.hpp.

    -

    Member Function Documentation

    - -

    ◆ operator()()

    - -
    -
    -
    -template<typename It , typename Compare = std::less<>>
    - - - - - -
    - - - - - - - - - - - - - - - - - - - - - - - - -
    void entt::OneShotBubbleSort::operator() (It first,
    It last,
    Compare compare = Compare{} 
    ) const
    -     		-inline
    -
    - -

    Tries to sort the elements in a range.

    -

    Performs a single iteration to sort the elements in a range using the given binary comparison function. The range may not be completely sorted after running this function.

    -
    Template Parameters
    - - - -
    ItType of random access iterator.
    CompareType of comparison function object.
    -
    -
    -
    Parameters
    - - - - -
    firstAn iterator to the first element of the range to sort.
    lastAn iterator past the last element of the range to sort.
    compareA valid comparison function object.
    -
    -
    - -

    Definition at line 91 of file algorithm.hpp.

    - -
    -
    -
    The documentation for this struct was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1ProcessAdaptor-members.html b/structentt_1_1ProcessAdaptor-members.html deleted file mode 100644 index 69ce12e8b..000000000 --- a/structentt_1_1ProcessAdaptor-members.html +++ /dev/null @@ -1,95 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::ProcessAdaptor< Func, Delta > Member List
    -
    -
    - -

    This is the complete list of members for entt::ProcessAdaptor< Func, Delta >, including all inherited members.

    - - - - - - - - - - - - - - - -
    abort(const bool immediately=false) ENTT_NOEXCEPTentt::Process< ProcessAdaptor< Func, Delta >, Delta >inline
    alive() const ENTT_NOEXCEPTentt::Process< ProcessAdaptor< Func, Delta >, Delta >inline
    dead() const ENTT_NOEXCEPTentt::Process< ProcessAdaptor< Func, Delta >, Delta >inline
    delta_type typedefentt::Process< ProcessAdaptor< Func, Delta >, Delta >
    fail() ENTT_NOEXCEPTentt::Process< ProcessAdaptor< Func, Delta >, Delta >inlineprotected
    pause() ENTT_NOEXCEPTentt::Process< ProcessAdaptor< Func, Delta >, Delta >inlineprotected
    paused() const ENTT_NOEXCEPTentt::Process< ProcessAdaptor< Func, Delta >, Delta >inline
    ProcessAdaptor(Args &&... args)entt::ProcessAdaptor< Func, Delta >inline
    rejected() const ENTT_NOEXCEPTentt::Process< ProcessAdaptor< Func, Delta >, Delta >inline
    succeed() ENTT_NOEXCEPTentt::Process< ProcessAdaptor< Func, Delta >, Delta >inlineprotected
    tick(const Delta delta, void *data=nullptr)entt::Process< ProcessAdaptor< Func, Delta >, Delta >inline
    unpause() ENTT_NOEXCEPTentt::Process< ProcessAdaptor< Func, Delta >, Delta >inlineprotected
    update(const Delta delta, void *data)entt::ProcessAdaptor< Func, Delta >inline
    ~Process() ENTT_NOEXCEPTentt::Process< ProcessAdaptor< Func, Delta >, Delta >inlinevirtual
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1ProcessAdaptor.html b/structentt_1_1ProcessAdaptor.html deleted file mode 100644 index 50364a81a..000000000 --- a/structentt_1_1ProcessAdaptor.html +++ /dev/null @@ -1,286 +0,0 @@ - - - - - - - -EnTT: entt::ProcessAdaptor< Func, Delta > Struct Template Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Public Member Functions | -List of all members
    -
    -
    entt::ProcessAdaptor< Func, Delta > Struct Template Reference
    -
    -
    - -

    Adaptor for lambdas and functors to turn them into processes. - More...

    - -

    #include <process.hpp>

    -
    -Inheritance diagram for entt::ProcessAdaptor< Func, Delta >:
    -
    -
    Inheritance graph
    - - - -
    [legend]
    -
    -Collaboration diagram for entt::ProcessAdaptor< Func, Delta >:
    -
    -
    Collaboration graph
    - - - -
    [legend]
    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

    -Public Member Functions

    template<typename... Args>
     ProcessAdaptor (Args &&... args)
     Constructs a process adaptor from a lambda or a functor. More...
     
    void update (const Delta delta, void *data)
     Updates a process and its internal state if required. More...
     
    - Public Member Functions inherited from entt::Process< ProcessAdaptor< Func, Delta >, Delta >
    void tick (const Delta delta, void *data=nullptr)
     Updates a process and its internal state if required. More...
     
    -virtual ~Process () ENTT_NOEXCEPT
     Default destructor.
     
    void abort (const bool immediately=false) ENTT_NOEXCEPT
     Aborts a process if it's still alive. More...
     
    bool alive () const ENTT_NOEXCEPT
     Returns true if a process is either running or paused. More...
     
    bool dead () const ENTT_NOEXCEPT
     Returns true if a process is already terminated. More...
     
    bool paused () const ENTT_NOEXCEPT
     Returns true if a process is currently paused. More...
     
    bool rejected () const ENTT_NOEXCEPT
     Returns true if a process terminated with errors. More...
     
    - - - - - - - - - - - - - - - - - - -

    -Additional Inherited Members

    - Public Types inherited from entt::Process< ProcessAdaptor< Func, Delta >, Delta >
    -using delta_type = Delta
     Type used to provide elapsed time.
     
    - Protected Member Functions inherited from entt::Process< ProcessAdaptor< Func, Delta >, Delta >
    void succeed () ENTT_NOEXCEPT
     Terminates a process with success if it's still alive. More...
     
    void fail () ENTT_NOEXCEPT
     Terminates a process with errors if it's still alive. More...
     
    void pause () ENTT_NOEXCEPT
     Stops a process if it's in a running state. More...
     
    void unpause () ENTT_NOEXCEPT
     Restarts a process if it's paused. More...
     
    -

    Detailed Description

    -

    template<typename Func, typename Delta>
    -struct entt::ProcessAdaptor< Func, Delta >

    - -

    Adaptor for lambdas and functors to turn them into processes.

    -

    Lambdas and functors can't be used directly with a scheduler for they are not properly defined processes with managed life cycles.
    - This class helps in filling the gap and turning lambdas and functors into full featured processes usable by a scheduler.

    -

    The signature of the function call operator should be equivalent to the following:

    -
    void(Delta delta, void *data, auto succeed, auto fail);

    Where:

    -
      -
    • delta is the elapsed time.
      • -
    • data is an opaque pointer to user data if any, nullptr otherwise.
      • -
    • succeed is a function to call when a process terminates with success.
      • -
    • fail is a function to call when a process terminates with errors.
      • -
    -

    The signature of the function call operator of both succeed and fail is equivalent to the following:

    -
    void();

    Usually users shouldn't worry about creating adaptors. A scheduler will create them internally each and avery time a lambda or a functor is used as a process.

    -
    See also
    Process
    -
    -Scheduler
    -
    Template Parameters
    - - - -
    FuncActual type of process.
    DeltaType to use to provide elapsed time.
    -
    -
    - -

    Definition at line 314 of file process.hpp.

    -

    Constructor & Destructor Documentation

    - -

    ◆ ProcessAdaptor()

    - -
    -
    -
    -template<typename Func, typename Delta>
    -
    -template<typename... Args>
    - - - - - -
    - - - - - - - - -
    entt::ProcessAdaptor< Func, Delta >::ProcessAdaptor (Args &&... args)
    -     		-inline
    -
    - -

    Constructs a process adaptor from a lambda or a functor.

    -
    Template Parameters
    - - -
    ArgsTypes of arguments to use to initialize the actual process.
    -
    -
    -
    Parameters
    - - -
    argsParameters to use to initialize the actual process.
    -
    -
    - -

    Definition at line 321 of file process.hpp.

    - -
    -
    -

    Member Function Documentation

    - -

    ◆ update()

    - -
    -
    -
    -template<typename Func, typename Delta>
    - - - - - -
    - - - - - - - - - - - - - - - - - - -
    void entt::ProcessAdaptor< Func, Delta >::update (const Delta delta,
    void * data 
    )
    -     		-inline
    -
    - -

    Updates a process and its internal state if required.

    -
    Parameters
    - - - -
    deltaElapsed time.
    dataOptional data.
    -
    -
    - -

    Definition at line 330 of file process.hpp.

    - -
    -
    -
    The documentation for this struct was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1ProcessAdaptor__coll__graph.map b/structentt_1_1ProcessAdaptor__coll__graph.map deleted file mode 100644 index c5d3d93d0..000000000 --- a/structentt_1_1ProcessAdaptor__coll__graph.map +++ /dev/null @@ -1,3 +0,0 @@ - - - diff --git a/structentt_1_1ProcessAdaptor__coll__graph.md5 b/structentt_1_1ProcessAdaptor__coll__graph.md5 deleted file mode 100644 index 3587af442..000000000 --- a/structentt_1_1ProcessAdaptor__coll__graph.md5 +++ /dev/null @@ -1 +0,0 @@ -044ffff30b9bc69459ae2dbbea413081 \ No newline at end of file diff --git a/structentt_1_1ProcessAdaptor__coll__graph.png b/structentt_1_1ProcessAdaptor__coll__graph.png deleted file mode 100644 index 01facabed..000000000 Binary files a/structentt_1_1ProcessAdaptor__coll__graph.png and /dev/null differ diff --git a/structentt_1_1ProcessAdaptor__inherit__graph.map b/structentt_1_1ProcessAdaptor__inherit__graph.map deleted file mode 100644 index c5d3d93d0..000000000 --- a/structentt_1_1ProcessAdaptor__inherit__graph.map +++ /dev/null @@ -1,3 +0,0 @@ - - - diff --git a/structentt_1_1ProcessAdaptor__inherit__graph.md5 b/structentt_1_1ProcessAdaptor__inherit__graph.md5 deleted file mode 100644 index f95df639b..000000000 --- a/structentt_1_1ProcessAdaptor__inherit__graph.md5 +++ /dev/null @@ -1 +0,0 @@ -4cec6692a9e3e50361142808429572c1 \ No newline at end of file diff --git a/structentt_1_1ProcessAdaptor__inherit__graph.png b/structentt_1_1ProcessAdaptor__inherit__graph.png deleted file mode 100644 index 01facabed..000000000 Binary files a/structentt_1_1ProcessAdaptor__inherit__graph.png and /dev/null differ diff --git a/structentt_1_1ServiceLocator-members.html b/structentt_1_1ServiceLocator-members.html deleted file mode 100644 index 0eff0bc22..000000000 --- a/structentt_1_1ServiceLocator-members.html +++ /dev/null @@ -1,90 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.3 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::ServiceLocator< Service > Member List
    -
    -
    - -

    This is the complete list of members for entt::ServiceLocator< Service >, including all inherited members.

    - - - - - - - - - - -
    empty() ENTT_NOEXCEPTentt::ServiceLocator< Service >inlinestatic
    get() ENTT_NOEXCEPTentt::ServiceLocator< Service >inlinestatic
    ref() ENTT_NOEXCEPTentt::ServiceLocator< Service >inlinestatic
    reset()entt::ServiceLocator< Service >inlinestatic
    service_type typedefentt::ServiceLocator< Service >
    ServiceLocator()=deleteentt::ServiceLocator< Service >
    set(Args &&... args)entt::ServiceLocator< Service >inlinestatic
    set(std::shared_ptr< Service > ptr)entt::ServiceLocator< Service >inlinestatic
    ~ServiceLocator()=deleteentt::ServiceLocator< Service >
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1as__group-members.html b/structentt_1_1as__group-members.html new file mode 100644 index 000000000..9efe65309 --- /dev/null +++ b/structentt_1_1as__group-members.html @@ -0,0 +1,84 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
    +
    + + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +
    entt::as_group< Const, Entity > Member List
    +
    +
    + +

    This is the complete list of members for entt::as_group< Const, Entity >, including all inherited members.

    + + + + +
    as_group(registry_type &source) ENTT_NOEXCEPTentt::as_group< Const, Entity >inline
    operator entt::basic_group< Entity, get_t, Owned... >() constentt::as_group< Const, Entity >inline
    registry_type typedefentt::as_group< Const, Entity >
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/structentt_1_1as__group.html b/structentt_1_1as__group.html new file mode 100644 index 000000000..ef11e19cb --- /dev/null +++ b/structentt_1_1as__group.html @@ -0,0 +1,203 @@ + + + + + + + +EnTT: entt::as_group< Const, Entity > Struct Template Reference + + + + + + + + + +
    +
    + + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +Public Types | +Public Member Functions | +List of all members
    +
    +
    entt::as_group< Const, Entity > Struct Template Reference
    +
    +
    + +

    Converts a registry to a group. + More...

    + +

    #include <helper.hpp>

    + + + + + +

    +Public Types

    +using registry_type = std::conditional_t< Const, const entt::basic_registry< Entity >, entt::basic_registry< Entity > >
     Type of registry to convert.
     
    + + + + + + + + +

    +Public Member Functions

     as_group (registry_type &source) ENTT_NOEXCEPT
     Constructs a converter for a given registry. More...
     
    template<typename... Owned>
     operator entt::basic_group< Entity, get_t, Owned... > () const
     Conversion function from a registry to a group. More...
     
    +

    Detailed Description

    +

    template<bool Const, typename Entity>
    +struct entt::as_group< Const, Entity >

    + +

    Converts a registry to a group.

    +
    Template Parameters
    + + + +
    ConstConstness of the accepted registry.
    EntityA valid entity type (see entt_traits for more details).
    +
    +
    + +

    Definition at line 69 of file helper.hpp.

    +

    Constructor & Destructor Documentation

    + +

    ◆ as_group()

    + +
    +
    +
    +template<bool Const, typename Entity >
    + + + + + +
    + + + + + + + + +
    entt::as_group< Const, Entity >::as_group (registry_type & source)
    +     		+inline
    +
    + +

    Constructs a converter for a given registry.

    +
    Parameters
    + + +
    sourceA valid reference to a registry.
    +
    +
    + +

    Definition at line 77 of file helper.hpp.

    + +
    +
    +

    Member Function Documentation

    + +

    ◆ operator entt::basic_group< Entity, get_t, Owned... >()

    + +
    +
    +
    +template<bool Const, typename Entity >
    +
    +template<typename... Owned>
    + + + + + +
    + + + + + + + +
    entt::as_group< Const, Entity >::operator entt::basic_group< Entity, get_t, Owned... > () const
    +     		+inline
    +
    + +

    Conversion function from a registry to a group.

    +
    Note
    Unfortunately, only full owning groups are supported because of an issue with msvc that doesn't manage to correctly deduce types.
    +
    Template Parameters
    + + +
    OwnedTypes of components owned by the group.
    +
    +
    +
    Returns
    A newly created group.
    + +

    Definition at line 90 of file helper.hpp.

    + +
    +
    +
    The documentation for this struct was generated from the following file: +
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/structentt_1_1as__view-members.html b/structentt_1_1as__view-members.html new file mode 100644 index 000000000..97d6e97e8 --- /dev/null +++ b/structentt_1_1as__view-members.html @@ -0,0 +1,84 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
    +
    + + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +
    entt::as_view< Const, Entity > Member List
    +
    +
    + +

    This is the complete list of members for entt::as_view< Const, Entity >, including all inherited members.

    + + + + +
    as_view(registry_type &source) ENTT_NOEXCEPTentt::as_view< Const, Entity >inline
    operator entt::basic_view< Entity, Component... >() constentt::as_view< Const, Entity >inline
    registry_type typedefentt::as_view< Const, Entity >
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/structentt_1_1as__view.html b/structentt_1_1as__view.html new file mode 100644 index 000000000..635d9d5f4 --- /dev/null +++ b/structentt_1_1as__view.html @@ -0,0 +1,202 @@ + + + + + + + +EnTT: entt::as_view< Const, Entity > Struct Template Reference + + + + + + + + + +
    +
    + + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +Public Types | +Public Member Functions | +List of all members
    +
    +
    entt::as_view< Const, Entity > Struct Template Reference
    +
    +
    + +

    Converts a registry to a view. + More...

    + +

    #include <helper.hpp>

    + + + + + +

    +Public Types

    +using registry_type = std::conditional_t< Const, const entt::basic_registry< Entity >, entt::basic_registry< Entity > >
     Type of registry to convert.
     
    + + + + + + + + +

    +Public Member Functions

     as_view (registry_type &source) ENTT_NOEXCEPT
     Constructs a converter for a given registry. More...
     
    template<typename... Component>
     operator entt::basic_view< Entity, Component... > () const
     Conversion function from a registry to a view. More...
     
    +

    Detailed Description

    +

    template<bool Const, typename Entity>
    +struct entt::as_view< Const, Entity >

    + +

    Converts a registry to a view.

    +
    Template Parameters
    + + + +
    ConstConstness of the accepted registry.
    EntityA valid entity type (see entt_traits for more details).
    +
    +
    + +

    Definition at line 21 of file helper.hpp.

    +

    Constructor & Destructor Documentation

    + +

    ◆ as_view()

    + +
    +
    +
    +template<bool Const, typename Entity >
    + + + + + +
    + + + + + + + + +
    entt::as_view< Const, Entity >::as_view (registry_type & source)
    +     		+inline
    +
    + +

    Constructs a converter for a given registry.

    +
    Parameters
    + + +
    sourceA valid reference to a registry.
    +
    +
    + +

    Definition at line 29 of file helper.hpp.

    + +
    +
    +

    Member Function Documentation

    + +

    ◆ operator entt::basic_view< Entity, Component... >()

    + +
    +
    +
    +template<bool Const, typename Entity >
    +
    +template<typename... Component>
    + + + + + +
    + + + + + + + +
    entt::as_view< Const, Entity >::operator entt::basic_view< Entity, Component... > () const
    +     		+inline
    +
    + +

    Conversion function from a registry to a view.

    +
    Template Parameters
    + + +
    ComponentType of components used to construct the view.
    +
    +
    +
    Returns
    A newly created view.
    + +

    Definition at line 37 of file helper.hpp.

    + +
    +
    +
    The documentation for this struct was generated from the following file: +
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/structentt_1_1basic__actor-members.html b/structentt_1_1basic__actor-members.html new file mode 100644 index 000000000..cbd4fd7cd --- /dev/null +++ b/structentt_1_1basic__actor-members.html @@ -0,0 +1,97 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
    +
    + + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +
    entt::basic_actor< Entity > Member List
    +
    +
    + +

    This is the complete list of members for entt::basic_actor< Entity >, including all inherited members.

    + + + + + + + + + + + + + + + + + +
    assign(Args &&... args)entt::basic_actor< Entity >inline
    backend() const ENTT_NOEXCEPTentt::basic_actor< Entity >inline
    backend() ENTT_NOEXCEPTentt::basic_actor< Entity >inline
    basic_actor(registry_type &ref)entt::basic_actor< Entity >inline
    basic_actor(basic_actor &&other)entt::basic_actor< Entity >inline
    entity() const ENTT_NOEXCEPTentt::basic_actor< Entity >inline
    entity_type typedefentt::basic_actor< Entity >
    get() const ENTT_NOEXCEPTentt::basic_actor< Entity >inline
    get() ENTT_NOEXCEPTentt::basic_actor< Entity >inline
    has() const ENTT_NOEXCEPTentt::basic_actor< Entity >inline
    operator=(basic_actor &&other)entt::basic_actor< Entity >inline
    registry_type typedefentt::basic_actor< Entity >
    remove()entt::basic_actor< Entity >inline
    try_get() const ENTT_NOEXCEPTentt::basic_actor< Entity >inline
    try_get() ENTT_NOEXCEPTentt::basic_actor< Entity >inline
    ~basic_actor()entt::basic_actor< Entity >inlinevirtual
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/structentt_1_1basic__actor.html b/structentt_1_1basic__actor.html new file mode 100644 index 000000000..1626bb4b3 --- /dev/null +++ b/structentt_1_1basic__actor.html @@ -0,0 +1,673 @@ + + + + + + + +EnTT: entt::basic_actor< Entity > Class Template Reference + + + + + + + + + +
    +
    + + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +Public Types | +Public Member Functions | +List of all members
    +
    +
    entt::basic_actor< Entity > Class Template Reference
    +
    +
    + +

    Dedicated to those who aren't confident with entity-component systems. + More...

    + +

    #include <actor.hpp>

    + + + + + + + + +

    +Public Types

    +using registry_type = basic_registry< Entity >
     Type of registry used internally.
     
    +using entity_type = Entity
     Underlying entity identifier.
     
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    +Public Member Functions

     basic_actor (registry_type &ref)
     Constructs an actor by using the given registry. More...
     
    +virtual ~basic_actor ()
     Default destructor.
     
     basic_actor (basic_actor &&other)
     Move constructor. More...
     
    basic_actor & operator= (basic_actor &&other)
     Move assignment operator. More...
     
    template<typename Component , typename... Args>
    decltype(auto) assign (Args &&... args)
     Assigns the given component to an actor. More...
     
    template<typename Component >
    void remove ()
     Removes the given component from an actor. More...
     
    template<typename Component >
    bool has () const ENTT_NOEXCEPT
     Checks if an actor has the given component. More...
     
    template<typename... Component>
    decltype(auto) get () const ENTT_NOEXCEPT
     Returns references to the given components for an actor. More...
     
    template<typename... Component>
    decltype(auto) get () ENTT_NOEXCEPT
     Returns references to the given components for an actor. More...
     
    template<typename... Component>
    auto try_get () const ENTT_NOEXCEPT
     Returns pointers to the given components for an actor. More...
     
    template<typename... Component>
    auto try_get () ENTT_NOEXCEPT
     Returns pointers to the given components for an actor. More...
     
    const registry_type & backend () const ENTT_NOEXCEPT
     Returns a reference to the underlying registry. More...
     
    registry_type & backend () ENTT_NOEXCEPT
     Returns a reference to the underlying registry. More...
     
    entity_type entity () const ENTT_NOEXCEPT
     Returns the entity associated with an actor. More...
     
    +

    Detailed Description

    +

    template<typename Entity>
    +class entt::basic_actor< Entity >

    + +

    Dedicated to those who aren't confident with entity-component systems.

    +

    Tiny wrapper around a registry, for all those users that aren't confident with entity-component systems and prefer to iterate objects directly.

    +
    Template Parameters
    + + +
    EntityA valid entity type (see entt_traits for more details).
    +
    +
    + +

    Definition at line 26 of file actor.hpp.

    +

    Constructor & Destructor Documentation

    + +

    ◆ basic_actor() [1/2]

    + +
    +
    +
    +template<typename Entity >
    + + + + + +
    + + + + + + + + +
    entt::basic_actor< Entity >::basic_actor (registry_type & ref)
    +     		+inline
    +
    + +

    Constructs an actor by using the given registry.

    +
    Parameters
    + + +
    refAn entity-component system properly initialized.
    +
    +
    + +

    Definition at line 36 of file actor.hpp.

    + +
    +
    + +

    ◆ basic_actor() [2/2]

    + +
    +
    +
    +template<typename Entity >
    + + + + + +
    + + + + + + + + +
    entt::basic_actor< Entity >::basic_actor (basic_actor< Entity > && other)
    +     		+inline
    +
    + +

    Move constructor.

    +

    After actor move construction, instances that have been moved from are placed in a valid but unspecified state. It's highly discouraged to continue using them.

    +
    Parameters
    + + +
    otherThe instance to move from.
    +
    +
    + +

    Definition at line 54 of file actor.hpp.

    + +
    +
    +

    Member Function Documentation

    + +

    ◆ assign()

    + +
    +
    +
    +template<typename Entity >
    +
    +template<typename Component , typename... Args>
    + + + + + +
    + + + + + + + + +
    decltype(auto) entt::basic_actor< Entity >::assign (Args &&... args)
    +     		+inline
    +
    + +

    Assigns the given component to an actor.

    +

    A new instance of the given component is created and initialized with the arguments provided (the component must have a proper constructor or be of aggregate type). Then the component is assigned to the actor.
    + In case the actor already has a component of the given type, it's replaced with the new one.

    +
    Template Parameters
    + + + +
    ComponentType of the component to create.
    ArgsTypes of arguments to use to construct the component.
    +
    +
    +
    Parameters
    + + +
    argsParameters to use to initialize the component.
    +
    +
    +
    Returns
    A reference to the newly created component.
    + +

    Definition at line 95 of file actor.hpp.

    + +
    +
    + +

    ◆ backend() [1/2]

    + +
    +
    +
    +template<typename Entity >
    + + + + + +
    + + + + + + + +
    const registry_type& entt::basic_actor< Entity >::backend () const
    +     		+inline
    +
    + +

    Returns a reference to the underlying registry.

    +
    Returns
    A reference to the underlying registry.
    + +

    Definition at line 154 of file actor.hpp.

    + +
    +
    + +

    ◆ backend() [2/2]

    + +
    +
    +
    +template<typename Entity >
    + + + + + +
    + + + + + + + +
    registry_type& entt::basic_actor< Entity >::backend ()
    +     		+inline
    +
    + +

    Returns a reference to the underlying registry.

    +
    Returns
    A reference to the underlying registry.
    + +

    Definition at line 159 of file actor.hpp.

    + +
    +
    + +

    ◆ entity()

    + +
    +
    +
    +template<typename Entity >
    + + + + + +
    + + + + + + + +
    entity_type entt::basic_actor< Entity >::entity () const
    +     		+inline
    +
    + +

    Returns the entity associated with an actor.

    +
    Returns
    The entity associated with the actor.
    + +

    Definition at line 167 of file actor.hpp.

    + +
    +
    + +

    ◆ get() [1/2]

    + +
    +
    +
    +template<typename Entity >
    +
    +template<typename... Component>
    + + + + + +
    + + + + + + + +
    decltype(auto) entt::basic_actor< Entity >::get () const
    +     		+inline
    +
    + +

    Returns references to the given components for an actor.

    +
    Template Parameters
    + + +
    ComponentTypes of components to get.
    +
    +
    +
    Returns
    References to the components owned by the actor.
    + +

    Definition at line 124 of file actor.hpp.

    + +
    +
    + +

    ◆ get() [2/2]

    + +
    +
    +
    +template<typename Entity >
    +
    +template<typename... Component>
    + + + + + +
    + + + + + + + +
    decltype(auto) entt::basic_actor< Entity >::get ()
    +     		+inline
    +
    + +

    Returns references to the given components for an actor.

    +
    Template Parameters
    + + +
    ComponentTypes of components to get.
    +
    +
    +
    Returns
    References to the components owned by the actor.
    + +

    Definition at line 130 of file actor.hpp.

    + +
    +
    + +

    ◆ has()

    + +
    +
    +
    +template<typename Entity >
    +
    +template<typename Component >
    + + + + + +
    + + + + + + + +
    bool entt::basic_actor< Entity >::has () const
    +     		+inline
    +
    + +

    Checks if an actor has the given component.

    +
    Template Parameters
    + + +
    ComponentType of the component for which to perform the check.
    +
    +
    +
    Returns
    True if the actor has the component, false otherwise.
    + +

    Definition at line 114 of file actor.hpp.

    + +
    +
    + +

    ◆ operator=()

    + +
    +
    +
    +template<typename Entity >
    + + + + + +
    + + + + + + + + +
    basic_actor& entt::basic_actor< Entity >::operator= (basic_actor< Entity > && other)
    +     		+inline
    +
    + +

    Move assignment operator.

    +

    After actor move assignment, instances that have been moved from are placed in a valid but unspecified state. It's highly discouraged to continue using them.

    +
    Parameters
    + + +
    otherThe instance to move from.
    +
    +
    +
    Returns
    This actor.
    + +

    Definition at line 70 of file actor.hpp.

    + +
    +
    + +

    ◆ remove()

    + +
    +
    +
    +template<typename Entity >
    +
    +template<typename Component >
    + + + + + +
    + + + + + + + +
    void entt::basic_actor< Entity >::remove ()
    +     		+inline
    +
    + +

    Removes the given component from an actor.

    +
    Template Parameters
    + + +
    ComponentType of the component to remove.
    +
    +
    + +

    Definition at line 104 of file actor.hpp.

    + +
    +
    + +

    ◆ try_get() [1/2]

    + +
    +
    +
    +template<typename Entity >
    +
    +template<typename... Component>
    + + + + + +
    + + + + + + + +
    auto entt::basic_actor< Entity >::try_get () const
    +     		+inline
    +
    + +

    Returns pointers to the given components for an actor.

    +
    Template Parameters
    + + +
    ComponentTypes of components to get.
    +
    +
    +
    Returns
    Pointers to the components owned by the actor.
    + +

    Definition at line 140 of file actor.hpp.

    + +
    +
    + +

    ◆ try_get() [2/2]

    + +
    +
    +
    +template<typename Entity >
    +
    +template<typename... Component>
    + + + + + +
    + + + + + + + +
    auto entt::basic_actor< Entity >::try_get ()
    +     		+inline
    +
    + +

    Returns pointers to the given components for an actor.

    +
    Template Parameters
    + + +
    ComponentTypes of components to get.
    +
    +
    +
    Returns
    Pointers to the components owned by the actor.
    + +

    Definition at line 146 of file actor.hpp.

    + +
    +
    +
    The documentation for this class was generated from the following file: +
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/structentt_1_1persistent__t.html b/structentt_1_1connect__arg__t.html similarity index 73% rename from structentt_1_1persistent__t.html rename to structentt_1_1connect__arg__t.html index b072410cd..a567b3f4d 100644 --- a/structentt_1_1persistent__t.html +++ b/structentt_1_1connect__arg__t.html @@ -5,7 +5,7 @@ -EnTT: entt::persistent_t Struct Reference +EnTT: entt::connect_arg_t< auto > Struct Template Reference @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    + + + + + +
    +
    EnTT +  3.0.0 +
    +
    + + + + + + + + + +
    +
    + + +
    + +
    + + + +
    +
    +
    entt::emitter< Derived >::connection< Event > Member List
    +
    +
    + +

    This is the complete list of members for entt::emitter< Derived >::connection< Event >, including all inherited members.

    + + + + +
    connection() ENTT_NOEXCEPT=defaultentt::emitter< Derived >::connection< Event >
    connection(typename event_handler< Event >::connection_type conn)entt::emitter< Derived >::connection< Event >inline
    emitter classentt::emitter< Derived >::connection< Event >friend
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/structentt_1_1emitter_1_1connection.html b/structentt_1_1emitter_1_1connection.html new file mode 100644 index 000000000..d48802837 --- /dev/null +++ b/structentt_1_1emitter_1_1connection.html @@ -0,0 +1,175 @@ + + + + + + + +EnTT: entt::emitter< Derived >::connection< Event > Struct Template Reference + + + + + + + + + +
    +
    + + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +Public Member Functions | +Friends | +List of all members
    +
    +
    entt::emitter< Derived >::connection< Event > Struct Template Reference
    +
    +
    + +

    Generic connection type for events. + More...

    + +

    #include <emitter.hpp>

    +
    +Inheritance diagram for entt::emitter< Derived >::connection< Event >:
    +
    +
    Inheritance graph
    +
    [legend]
    +
    +Collaboration diagram for entt::emitter< Derived >::connection< Event >:
    +
    +
    Collaboration graph
    +
    [legend]
    + + + + + + + + +

    +Public Member Functions

    + connection () ENTT_NOEXCEPT=default
     Default constructor.
     
     connection (typename event_handler< Event >::connection_type conn)
     Creates a connection that wraps its underlying instance. More...
     
    + + + + +

    +Friends

    +class emitter
     Event emitters are friend classes of connections.
     
    +

    Detailed Description

    +

    template<typename Derived>
    +template<typename Event>
    +struct entt::emitter< Derived >::connection< Event >

    + +

    Generic connection type for events.

    +

    Type of the connection object returned by the event emitter whenever a listener for the given type is registered.
    + It can be used to break connections still in use.

    +
    Template Parameters
    + + +
    EventType of event for which the connection is created.
    +
    +
    + +

    Definition at line 180 of file emitter.hpp.

    +

    Constructor & Destructor Documentation

    + +

    ◆ connection()

    + +
    +
    +
    +template<typename Derived >
    +
    +template<typename Event>
    + + + + + +
    + + + + + + + + +
    entt::emitter< Derived >::connection< Event >::connection (typename event_handler< Event >::connection_type conn)
    +     		+inline
    +
    + +

    Creates a connection that wraps its underlying instance.

    +
    Parameters
    + + +
    connA connection object to wrap.
    +
    +
    + +

    Definition at line 191 of file emitter.hpp.

    + +
    +
    +
    The documentation for this struct was generated from the following file: +
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/structentt_1_1emitter_1_1connection__coll__graph.map b/structentt_1_1emitter_1_1connection__coll__graph.map new file mode 100644 index 000000000..cf5f3cec0 --- /dev/null +++ b/structentt_1_1emitter_1_1connection__coll__graph.map @@ -0,0 +1,2 @@ + + diff --git a/structentt_1_1emitter_1_1connection__coll__graph.md5 b/structentt_1_1emitter_1_1connection__coll__graph.md5 new file mode 100644 index 000000000..1acfe1c25 --- /dev/null +++ b/structentt_1_1emitter_1_1connection__coll__graph.md5 @@ -0,0 +1 @@ +696261886d2bbaf751e07daa95bf9403 \ No newline at end of file diff --git a/structentt_1_1emitter_1_1connection__coll__graph.png b/structentt_1_1emitter_1_1connection__coll__graph.png new file mode 100644 index 000000000..55fe23d98 Binary files /dev/null and b/structentt_1_1emitter_1_1connection__coll__graph.png differ diff --git a/structentt_1_1emitter_1_1connection__inherit__graph.map b/structentt_1_1emitter_1_1connection__inherit__graph.map new file mode 100644 index 000000000..cf5f3cec0 --- /dev/null +++ b/structentt_1_1emitter_1_1connection__inherit__graph.map @@ -0,0 +1,2 @@ + + diff --git a/structentt_1_1emitter_1_1connection__inherit__graph.md5 b/structentt_1_1emitter_1_1connection__inherit__graph.md5 new file mode 100644 index 000000000..2de6fefcc --- /dev/null +++ b/structentt_1_1emitter_1_1connection__inherit__graph.md5 @@ -0,0 +1 @@ +65e3fb447ad2ca961e64fa52565cb0e0 \ No newline at end of file diff --git a/structentt_1_1emitter_1_1connection__inherit__graph.png b/structentt_1_1emitter_1_1connection__inherit__graph.png new file mode 100644 index 000000000..55fe23d98 Binary files /dev/null and b/structentt_1_1emitter_1_1connection__inherit__graph.png differ diff --git a/structentt_1_1entt__traits.html b/structentt_1_1entt__traits.html index 08ec1a5dc..737c2fad4 100644 --- a/structentt_1_1entt__traits.html +++ b/structentt_1_1entt__traits.html @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    @@ -118,9 +118,9 @@ struct entt::entt_traits< std::uint16_t >
  • 4 bit for the version (resets in [0-15]).
    • -

    Definition at line 30 of file entt_traits.hpp.

    +

    Definition at line 30 of file entity.hpp.

    The documentation for this struct was generated from the following file: diff --git a/structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4-members.html b/structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4-members.html index 229c8a5ad..2d844227a 100644 --- a/structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4-members.html +++ b/structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4-members.html @@ -22,7 +22,7 @@ diff --git a/structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html b/structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html index 55a337142..9355b92aa 100644 --- a/structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html +++ b/structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html @@ -22,7 +22,7 @@ @@ -75,7 +75,7 @@ $(function() {

    Entity traits for a 32 bits entity identifier. More...

    -

    #include <entt_traits.hpp>

    +

    #include <entity.hpp>

    Public Types

    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    @@ -118,9 +118,9 @@ struct entt::entt_traits< std::uint32_t >
  • 12 bit for the version (resets in [0-4095]).
    • -

    Definition at line 56 of file entt_traits.hpp.

    +

    Definition at line 56 of file entity.hpp.

    The documentation for this struct was generated from the following file: diff --git a/structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4-members.html b/structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4-members.html index ebf44974f..876b1df48 100644 --- a/structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4-members.html +++ b/structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4-members.html @@ -22,7 +22,7 @@ diff --git a/structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html b/structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html index c9f68a1e7..60cfb1ab8 100644 --- a/structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html +++ b/structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html @@ -22,7 +22,7 @@ @@ -75,7 +75,7 @@ $(function() {

    Entity traits for a 64 bits entity identifier. More...

    -

    #include <entt_traits.hpp>

    +

    #include <entity.hpp>

    Public Types

    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    @@ -118,9 +118,9 @@ struct entt::entt_traits< std::uint64_t >
  • 32 bit for the version (an indecently large number).
    • -

    Definition at line 82 of file entt_traits.hpp.

    +

    Definition at line 82 of file entity.hpp.

    The documentation for this struct was generated from the following file: diff --git a/structentt_1_1StdSort-members.html b/structentt_1_1exclude__t-members.html similarity index 82% rename from structentt_1_1StdSort-members.html rename to structentt_1_1exclude__t-members.html index e244887ee..eb7f129c5 100644 --- a/structentt_1_1StdSort-members.html +++ b/structentt_1_1exclude__t-members.html @@ -22,7 +22,7 @@ @@ -59,18 +59,18 @@ $(function() {
    -
    entt::StdSort Member List
    +
    entt::exclude_t< Type > Member List
    -

    This is the complete list of members for entt::StdSort, including all inherited members.

    +

    This is the complete list of members for entt::exclude_t< Type >, including all inherited members.

    Public Types

    EnTT -  2.7.3 +  3.0.0
    - +
    operator()(It first, It last, Compare compare=Compare{}, Args &&... args) constentt::StdSortinline
    sizeentt::type_list< Type... >static
    diff --git a/structentt_1_1exclude__t.html b/structentt_1_1exclude__t.html new file mode 100644 index 000000000..96444c78d --- /dev/null +++ b/structentt_1_1exclude__t.html @@ -0,0 +1,126 @@ + + + + + + + +EnTT: entt::exclude_t< Type > Struct Template Reference + + + + + + + + + +
    +
    + + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +List of all members
    +
    +
    entt::exclude_t< Type > Struct Template Reference
    +
    +
    + +

    Alias for exclusion lists. + More...

    + +

    #include <registry.hpp>

    +
    +Inheritance diagram for entt::exclude_t< Type >:
    +
    +
    Inheritance graph
    + + + +
    [legend]
    +
    +Collaboration diagram for entt::exclude_t< Type >:
    +
    +
    Collaboration graph
    + + + +
    [legend]
    + + + + + + +

    +Additional Inherited Members

    - Static Public Attributes inherited from entt::type_list< Type... >
    +static constexpr auto size
     Unsigned integer type.
     
    +

    Detailed Description

    +

    template<typename... Type>
    +struct entt::exclude_t< Type >

    + +

    Alias for exclusion lists.

    +
    Template Parameters
    + + +
    TypeList of types.
    +
    +
    + +

    Definition at line 38 of file registry.hpp.

    +
    The documentation for this struct was generated from the following file: +
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/structentt_1_1exclude__t__coll__graph.map b/structentt_1_1exclude__t__coll__graph.map new file mode 100644 index 000000000..3d61520e9 --- /dev/null +++ b/structentt_1_1exclude__t__coll__graph.map @@ -0,0 +1,3 @@ + + + diff --git a/structentt_1_1exclude__t__coll__graph.md5 b/structentt_1_1exclude__t__coll__graph.md5 new file mode 100644 index 000000000..f230a25cf --- /dev/null +++ b/structentt_1_1exclude__t__coll__graph.md5 @@ -0,0 +1 @@ +b59d3cba3fc4ecfa313d40fb9005acd7 \ No newline at end of file diff --git a/structentt_1_1exclude__t__coll__graph.png b/structentt_1_1exclude__t__coll__graph.png new file mode 100644 index 000000000..b4e9f4a86 Binary files /dev/null and b/structentt_1_1exclude__t__coll__graph.png differ diff --git a/structentt_1_1exclude__t__inherit__graph.map b/structentt_1_1exclude__t__inherit__graph.map new file mode 100644 index 000000000..3d61520e9 --- /dev/null +++ b/structentt_1_1exclude__t__inherit__graph.map @@ -0,0 +1,3 @@ + + + diff --git a/structentt_1_1exclude__t__inherit__graph.md5 b/structentt_1_1exclude__t__inherit__graph.md5 new file mode 100644 index 000000000..bc4bcddb2 --- /dev/null +++ b/structentt_1_1exclude__t__inherit__graph.md5 @@ -0,0 +1 @@ +bea56ce62e8439efd7c0b85da10f7696 \ No newline at end of file diff --git a/structentt_1_1exclude__t__inherit__graph.png b/structentt_1_1exclude__t__inherit__graph.png new file mode 100644 index 000000000..b4e9f4a86 Binary files /dev/null and b/structentt_1_1exclude__t__inherit__graph.png differ diff --git a/structentt_1_1InsertionSort-members.html b/structentt_1_1get__t-members.html similarity index 81% rename from structentt_1_1InsertionSort-members.html rename to structentt_1_1get__t-members.html index c65ef9812..a83493272 100644 --- a/structentt_1_1InsertionSort-members.html +++ b/structentt_1_1get__t-members.html @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    - +
    operator()(It first, It last, Compare compare=Compare{}) constentt::InsertionSortinline
    sizeentt::type_list< Type... >static
    diff --git a/structentt_1_1get__t.html b/structentt_1_1get__t.html new file mode 100644 index 000000000..0370a1e48 --- /dev/null +++ b/structentt_1_1get__t.html @@ -0,0 +1,126 @@ + + + + + + + +EnTT: entt::get_t< Type > Struct Template Reference + + + + + + + + + +
    +
    + + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +List of all members
    +
    +
    entt::get_t< Type > Struct Template Reference
    +
    +
    + +

    Alias for lists of observed components. + More...

    + +

    #include <group.hpp>

    +
    +Inheritance diagram for entt::get_t< Type >:
    +
    +
    Inheritance graph
    + + + +
    [legend]
    +
    +Collaboration diagram for entt::get_t< Type >:
    +
    +
    Collaboration graph
    + + + +
    [legend]
    + + + + + + +

    +Additional Inherited Members

    - Static Public Attributes inherited from entt::type_list< Type... >
    +static constexpr auto size
     Unsigned integer type.
     
    +

    Detailed Description

    +

    template<typename... Type>
    +struct entt::get_t< Type >

    + +

    Alias for lists of observed components.

    +
    Template Parameters
    + + +
    TypeList of types.
    +
    +
    + +

    Definition at line 23 of file group.hpp.

    +
    The documentation for this struct was generated from the following file: +
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/structentt_1_1get__t__coll__graph.map b/structentt_1_1get__t__coll__graph.map new file mode 100644 index 000000000..1adff6c7f --- /dev/null +++ b/structentt_1_1get__t__coll__graph.map @@ -0,0 +1,3 @@ + + + diff --git a/structentt_1_1get__t__coll__graph.md5 b/structentt_1_1get__t__coll__graph.md5 new file mode 100644 index 000000000..9c9662fee --- /dev/null +++ b/structentt_1_1get__t__coll__graph.md5 @@ -0,0 +1 @@ +de8ed796fa0befd52014ea09ff1bff1d \ No newline at end of file diff --git a/structentt_1_1get__t__coll__graph.png b/structentt_1_1get__t__coll__graph.png new file mode 100644 index 000000000..22b209a4d Binary files /dev/null and b/structentt_1_1get__t__coll__graph.png differ diff --git a/structentt_1_1get__t__inherit__graph.map b/structentt_1_1get__t__inherit__graph.map new file mode 100644 index 000000000..1adff6c7f --- /dev/null +++ b/structentt_1_1get__t__inherit__graph.map @@ -0,0 +1,3 @@ + + + diff --git a/structentt_1_1get__t__inherit__graph.md5 b/structentt_1_1get__t__inherit__graph.md5 new file mode 100644 index 000000000..43597f6da --- /dev/null +++ b/structentt_1_1get__t__inherit__graph.md5 @@ -0,0 +1 @@ +ae5e7f61605ed19d01d8b0a089cb2f41 \ No newline at end of file diff --git a/structentt_1_1get__t__inherit__graph.png b/structentt_1_1get__t__inherit__graph.png new file mode 100644 index 000000000..22b209a4d Binary files /dev/null and b/structentt_1_1get__t__inherit__graph.png differ diff --git a/structentt_1_1insertion__sort-members.html b/structentt_1_1insertion__sort-members.html new file mode 100644 index 000000000..172b2f63b --- /dev/null +++ b/structentt_1_1insertion__sort-members.html @@ -0,0 +1,82 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
    +
    + + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +
    entt::insertion_sort Member List
    +
    +
    + +

    This is the complete list of members for entt::insertion_sort, including all inherited members.

    + + +
    operator()(It first, It last, Compare compare=Compare{}) constentt::insertion_sortinline
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/structentt_1_1InsertionSort.html b/structentt_1_1insertion__sort.html similarity index 83% rename from structentt_1_1InsertionSort.html rename to structentt_1_1insertion__sort.html index 08d08f890..9c07a4daf 100644 --- a/structentt_1_1InsertionSort.html +++ b/structentt_1_1insertion__sort.html @@ -5,7 +5,7 @@ -EnTT: entt::InsertionSort Struct Reference +EnTT: entt::insertion_sort Struct Reference @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    - - - - + + + +

    Public Member Functions

    template<typename It , typename Compare = std::less<>>
    void operator() (It first, It last, Compare compare=Compare{}) const
     Sorts the elements in a range. More...
     
    template<typename It , typename Compare = std::less<>>
    void operator() (It first, It last, Compare compare=Compare{}) const
     Sorts the elements in a range. More...
     

    Detailed Description

    Function object for performing insertion sort.

    Definition at line 43 of file algorithm.hpp.

    Member Function Documentation

    - -

    ◆ operator()()

    + +

    ◆ operator()()

    @@ -100,7 +100,7 @@ template<typename It , typename Compare = std::less<>>
    		- + diff --git a/structentt_1_1internal_1_1CtorHelper-members.html b/structentt_1_1internal_1_1CtorHelper-members.html deleted file mode 100644 index 7b4976cf8..000000000 --- a/structentt_1_1internal_1_1CtorHelper-members.html +++ /dev/null @@ -1,82 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    -
    void entt::InsertionSort::operator() void entt::insertion_sort::operator() ( It  first,
    - - - - - -
    -
    EnTT -  2.7.2 -
    -
    - - - - - - - - - -
    -
    - - -
    - -
    - - - -
    -
    -
    entt::internal::CtorHelper< Type, Args > Member List
    -
    -
    - -

    This is the complete list of members for entt::internal::CtorHelper< Type, Args >, including all inherited members.

    - - -
    construct(const MetaAny *const any, std::index_sequence< Indexes... >) (defined in entt::internal::CtorHelper< Type, Args >)entt::internal::CtorHelper< Type, Args >inlinestatic
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1FunctionHelper_3_01Ret_07Args_8_8_8_08_4-members.html b/structentt_1_1internal_1_1FunctionHelper_3_01Ret_07Args_8_8_8_08_4-members.html deleted file mode 100644 index 184d93c00..000000000 --- a/structentt_1_1internal_1_1FunctionHelper_3_01Ret_07Args_8_8_8_08_4-members.html +++ /dev/null @@ -1,86 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::internal::FunctionHelper< Ret(Args...)> Member List
    -
    -
    - -

    This is the complete list of members for entt::internal::FunctionHelper< Ret(Args...)>, including all inherited members.

    - - - - - - -
    accept(const internal::MetaTypeNode **const types) (defined in entt::internal::FunctionHelper< Ret(Args...)>)entt::internal::FunctionHelper< Ret(Args...)>inlinestatic
    arg(typename internal::MetaFuncNode::size_type index) (defined in entt::internal::FunctionHelper< Ret(Args...)>)entt::internal::FunctionHelper< Ret(Args...)>inlinestatic
    args_type typedef (defined in entt::internal::FunctionHelper< Ret(Args...)>)entt::internal::FunctionHelper< Ret(Args...)>
    return_type typedef (defined in entt::internal::FunctionHelper< Ret(Args...)>)entt::internal::FunctionHelper< Ret(Args...)>
    size (defined in entt::internal::FunctionHelper< Ret(Args...)>)entt::internal::FunctionHelper< Ret(Args...)>static
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1FunctionHelper_3_01Ret_07Args_8_8_8_08_4.html b/structentt_1_1internal_1_1FunctionHelper_3_01Ret_07Args_8_8_8_08_4.html deleted file mode 100644 index 15c13a07f..000000000 --- a/structentt_1_1internal_1_1FunctionHelper_3_01Ret_07Args_8_8_8_08_4.html +++ /dev/null @@ -1,127 +0,0 @@ - - - - - - - -EnTT: entt::internal::FunctionHelper< Ret(Args...)> Struct Template Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Public Types | -Static Public Member Functions | -Static Public Attributes | -List of all members
    -
    -
    entt::internal::FunctionHelper< Ret(Args...)> Struct Template Reference
    -
    -
    -
    -Inheritance diagram for entt::internal::FunctionHelper< Ret(Args...)>:
    -
    -
    Inheritance graph
    - - - - - -
    [legend]
    - - - - - - -

    -Public Types

    -using return_type = Ret
     
    -using args_type = std::tuple< Args... >
     
    - - - - - -

    -Static Public Member Functions

    -static auto arg (typename internal::MetaFuncNode::size_type index)
     
    -static auto accept (const internal::MetaTypeNode **const types)
     
    - - - -

    -Static Public Attributes

    -static constexpr auto size = sizeof...(Args)
     
    -

    Detailed Description

    -

    template<typename Ret, typename... Args>
    -struct entt::internal::FunctionHelper< Ret(Args...)>

    - - -

    Definition at line 662 of file meta.hpp.

    -
    The documentation for this struct was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1FunctionHelper_3_01Ret_07Args_8_8_8_08_4__inherit__graph.map b/structentt_1_1internal_1_1FunctionHelper_3_01Ret_07Args_8_8_8_08_4__inherit__graph.map deleted file mode 100644 index fb55618df..000000000 --- a/structentt_1_1internal_1_1FunctionHelper_3_01Ret_07Args_8_8_8_08_4__inherit__graph.map +++ /dev/null @@ -1,5 +0,0 @@ - - - - - diff --git a/structentt_1_1internal_1_1FunctionHelper_3_01Ret_07Args_8_8_8_08_4__inherit__graph.md5 b/structentt_1_1internal_1_1FunctionHelper_3_01Ret_07Args_8_8_8_08_4__inherit__graph.md5 deleted file mode 100644 index f503e84c5..000000000 --- a/structentt_1_1internal_1_1FunctionHelper_3_01Ret_07Args_8_8_8_08_4__inherit__graph.md5 +++ /dev/null @@ -1 +0,0 @@ -7defb4f95dfa6f0b44a8fae774e6a3fa \ No newline at end of file diff --git a/structentt_1_1internal_1_1FunctionHelper_3_01Ret_07Args_8_8_8_08_4__inherit__graph.png b/structentt_1_1internal_1_1FunctionHelper_3_01Ret_07Args_8_8_8_08_4__inherit__graph.png deleted file mode 100644 index e636d4bf1..000000000 Binary files a/structentt_1_1internal_1_1FunctionHelper_3_01Ret_07Args_8_8_8_08_4__inherit__graph.png and /dev/null differ diff --git a/structentt_1_1internal_1_1Holder.html b/structentt_1_1internal_1_1Holder.html deleted file mode 100644 index a476b00ee..000000000 --- a/structentt_1_1internal_1_1Holder.html +++ /dev/null @@ -1,111 +0,0 @@ - - - - - - - -EnTT: entt::internal::Holder Struct Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Public Member Functions | -List of all members
    -
    -
    entt::internal::Holder Struct Referenceabstract
    -
    -
    -
    -Inheritance diagram for entt::internal::Holder:
    -
    -
    Inheritance graph
    - - - -
    [legend]
    - - - - - - - - - - -

    -Public Member Functions

    -virtual MetaTypeNode * node () const ENTT_NOEXCEPT=0
     
    -virtual const void * data () const ENTT_NOEXCEPT=0
     
    -virtual bool operator== (const Holder &) const ENTT_NOEXCEPT=0
     
    -void * data () ENTT_NOEXCEPT
     
    -

    Detailed Description

    -
    -

    Definition at line 174 of file meta.hpp.

    -
    The documentation for this struct was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1HolderType-members.html b/structentt_1_1internal_1_1HolderType-members.html deleted file mode 100644 index e31b40bb5..000000000 --- a/structentt_1_1internal_1_1HolderType-members.html +++ /dev/null @@ -1,90 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::internal::HolderType< Type > Member List
    -
    -
    - -

    This is the complete list of members for entt::internal::HolderType< Type >, including all inherited members.

    - - - - - - - - - - -
    compare(int, const Object &lhs, const Object &rhs) -> decltype(lhs==rhs, bool (defined in entt::internal::HolderType< Type >)entt::internal::HolderType< Type >inlinestatic
    compare(char, const Object &, const Object &) (defined in entt::internal::HolderType< Type >)entt::internal::HolderType< Type >inlinestatic
    data() const ENTT_NOEXCEPT override (defined in entt::internal::HolderType< Type >)entt::internal::HolderType< Type >inlinevirtual
    data() ENTT_NOEXCEPT (defined in entt::internal::Holder)entt::internal::Holderinline
    HolderType(Args &&... args) (defined in entt::internal::HolderType< Type >)entt::internal::HolderType< Type >inline
    node() const ENTT_NOEXCEPT override (defined in entt::internal::HolderType< Type >)entt::internal::HolderType< Type >inlinevirtual
    operator==(const Holder &other) const ENTT_NOEXCEPT override (defined in entt::internal::HolderType< Type >)entt::internal::HolderType< Type >inlinevirtual
    ~Holder()=default (defined in entt::internal::Holder)entt::internal::Holdervirtual
    ~HolderType() (defined in entt::internal::HolderType< Type >)entt::internal::HolderType< Type >inline
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1HolderType.html b/structentt_1_1internal_1_1HolderType.html deleted file mode 100644 index d549665f1..000000000 --- a/structentt_1_1internal_1_1HolderType.html +++ /dev/null @@ -1,139 +0,0 @@ - - - - - - - -EnTT: entt::internal::HolderType< Type > Struct Template Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Public Member Functions | -Static Public Member Functions | -List of all members
    -
    -
    entt::internal::HolderType< Type > Struct Template Reference
    -
    -
    -
    -Inheritance diagram for entt::internal::HolderType< Type >:
    -
    -
    Inheritance graph
    - - - -
    [legend]
    -
    -Collaboration diagram for entt::internal::HolderType< Type >:
    -
    -
    Collaboration graph
    - - - -
    [legend]
    - - - - - - - - - - - - - - -

    -Public Member Functions

    -template<typename... Args>
     HolderType (Args &&... args)
     
    -MetaTypeNode * node () const ENTT_NOEXCEPT override
     
    -const void * data () const ENTT_NOEXCEPT override
     
    -bool operator== (const Holder &other) const ENTT_NOEXCEPT override
     
    - Public Member Functions inherited from entt::internal::Holder
    -void * data () ENTT_NOEXCEPT
     
    - - - - - - - -

    -Static Public Member Functions

    -template<typename Object >
    static auto compare (int, const Object &lhs, const Object &rhs) -> decltype(lhs==rhs, bool
     
    -template<typename Object >
    static bool compare (char, const Object &, const Object &)
     
    -

    Detailed Description

    -

    template<typename Type>
    -struct entt::internal::HolderType< Type >

    - - -

    Definition at line 188 of file meta.hpp.

    -
    The documentation for this struct was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1HolderType__coll__graph.map b/structentt_1_1internal_1_1HolderType__coll__graph.map deleted file mode 100644 index 534b1cf71..000000000 --- a/structentt_1_1internal_1_1HolderType__coll__graph.map +++ /dev/null @@ -1,3 +0,0 @@ - - - diff --git a/structentt_1_1internal_1_1HolderType__coll__graph.md5 b/structentt_1_1internal_1_1HolderType__coll__graph.md5 deleted file mode 100644 index ca0119d90..000000000 --- a/structentt_1_1internal_1_1HolderType__coll__graph.md5 +++ /dev/null @@ -1 +0,0 @@ -344a5cf6f6d973295d8aec18a46cefc6 \ No newline at end of file diff --git a/structentt_1_1internal_1_1HolderType__coll__graph.png b/structentt_1_1internal_1_1HolderType__coll__graph.png deleted file mode 100644 index 0e3ff49e8..000000000 Binary files a/structentt_1_1internal_1_1HolderType__coll__graph.png and /dev/null differ diff --git a/structentt_1_1internal_1_1HolderType__inherit__graph.map b/structentt_1_1internal_1_1HolderType__inherit__graph.map deleted file mode 100644 index 534b1cf71..000000000 --- a/structentt_1_1internal_1_1HolderType__inherit__graph.map +++ /dev/null @@ -1,3 +0,0 @@ - - - diff --git a/structentt_1_1internal_1_1HolderType__inherit__graph.md5 b/structentt_1_1internal_1_1HolderType__inherit__graph.md5 deleted file mode 100644 index c9571bb34..000000000 --- a/structentt_1_1internal_1_1HolderType__inherit__graph.md5 +++ /dev/null @@ -1 +0,0 @@ -b4012819678925105f43d49c3b330eba \ No newline at end of file diff --git a/structentt_1_1internal_1_1HolderType__inherit__graph.png b/structentt_1_1internal_1_1HolderType__inherit__graph.png deleted file mode 100644 index 0e3ff49e8..000000000 Binary files a/structentt_1_1internal_1_1HolderType__inherit__graph.png and /dev/null differ diff --git a/structentt_1_1internal_1_1Holder__inherit__graph.map b/structentt_1_1internal_1_1Holder__inherit__graph.map deleted file mode 100644 index 205d227fb..000000000 --- a/structentt_1_1internal_1_1Holder__inherit__graph.map +++ /dev/null @@ -1,3 +0,0 @@ - - - diff --git a/structentt_1_1internal_1_1Holder__inherit__graph.md5 b/structentt_1_1internal_1_1Holder__inherit__graph.md5 deleted file mode 100644 index 952d5dd0b..000000000 --- a/structentt_1_1internal_1_1Holder__inherit__graph.md5 +++ /dev/null @@ -1 +0,0 @@ -82e15e6bf70ba238ce9849de6cd29e05 \ No newline at end of file diff --git a/structentt_1_1internal_1_1Holder__inherit__graph.png b/structentt_1_1internal_1_1Holder__inherit__graph.png deleted file mode 100644 index 32b68ded4..000000000 Binary files a/structentt_1_1internal_1_1Holder__inherit__graph.png and /dev/null differ diff --git a/structentt_1_1internal_1_1MetaCtorNode-members.html b/structentt_1_1internal_1_1MetaCtorNode-members.html deleted file mode 100644 index 85b6a6bc1..000000000 --- a/structentt_1_1internal_1_1MetaCtorNode-members.html +++ /dev/null @@ -1,89 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::internal::MetaCtorNode Member List
    -
    -
    - -

    This is the complete list of members for entt::internal::MetaCtorNode, including all inherited members.

    - - - - - - - - - -
    accept (defined in entt::internal::MetaCtorNode)entt::internal::MetaCtorNode
    arg (defined in entt::internal::MetaCtorNode)entt::internal::MetaCtorNode
    invoke (defined in entt::internal::MetaCtorNode)entt::internal::MetaCtorNode
    meta (defined in entt::internal::MetaCtorNode)entt::internal::MetaCtorNode
    next (defined in entt::internal::MetaCtorNode)entt::internal::MetaCtorNode
    prop (defined in entt::internal::MetaCtorNode)entt::internal::MetaCtorNode
    size (defined in entt::internal::MetaCtorNode)entt::internal::MetaCtorNode
    size_type typedef (defined in entt::internal::MetaCtorNode)entt::internal::MetaCtorNode
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1MetaCtorNode.html b/structentt_1_1internal_1_1MetaCtorNode.html deleted file mode 100644 index dc8d178ec..000000000 --- a/structentt_1_1internal_1_1MetaCtorNode.html +++ /dev/null @@ -1,139 +0,0 @@ - - - - - - - -EnTT: entt::internal::MetaCtorNode Struct Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Public Types | -Public Attributes | -List of all members
    -
    -
    entt::internal::MetaCtorNode Struct Referencefinal
    -
    -
    -
    -Collaboration diagram for entt::internal::MetaCtorNode:
    -
    -
    Collaboration graph
    - - - - - - - - - - - - - - - -
    [legend]
    - - - - -

    -Public Types

    -using size_type = std::size_t
     
    - - - - - - - - - - - - - - - -

    -Public Attributes

    -MetaCtorNode *const next
     
    -MetaPropNode *const prop
     
    -const size_type size
     
    -MetaTypeNode *(*const arg )(size_type)
     
    -bool(*const accept )(const MetaTypeNode **const)
     
    -MetaAny(*const invoke )(const MetaAny *const)
     
    -MetaCtor *(*const meta )()
     
    -

    Detailed Description

    -
    -

    Definition at line 111 of file meta.hpp.

    -
    The documentation for this struct was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1MetaCtorNode__coll__graph.map b/structentt_1_1internal_1_1MetaCtorNode__coll__graph.map deleted file mode 100644 index 6383ec0a1..000000000 --- a/structentt_1_1internal_1_1MetaCtorNode__coll__graph.map +++ /dev/null @@ -1,15 +0,0 @@ - - - - - - - - - - - - - - - diff --git a/structentt_1_1internal_1_1MetaCtorNode__coll__graph.md5 b/structentt_1_1internal_1_1MetaCtorNode__coll__graph.md5 deleted file mode 100644 index b9ea1f531..000000000 --- a/structentt_1_1internal_1_1MetaCtorNode__coll__graph.md5 +++ /dev/null @@ -1 +0,0 @@ -f6c667243f7085b942b68eab24f75333 \ No newline at end of file diff --git a/structentt_1_1internal_1_1MetaCtorNode__coll__graph.png b/structentt_1_1internal_1_1MetaCtorNode__coll__graph.png deleted file mode 100644 index 7e633d541..000000000 Binary files a/structentt_1_1internal_1_1MetaCtorNode__coll__graph.png and /dev/null differ diff --git a/structentt_1_1internal_1_1MetaDataNode-members.html b/structentt_1_1internal_1_1MetaDataNode-members.html deleted file mode 100644 index c3e60cca0..000000000 --- a/structentt_1_1internal_1_1MetaDataNode-members.html +++ /dev/null @@ -1,91 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::internal::MetaDataNode Member List
    -
    -
    - -

    This is the complete list of members for entt::internal::MetaDataNode, including all inherited members.

    - - - - - - - - - - - -
    accept (defined in entt::internal::MetaDataNode)entt::internal::MetaDataNode
    get (defined in entt::internal::MetaDataNode)entt::internal::MetaDataNode
    meta (defined in entt::internal::MetaDataNode)entt::internal::MetaDataNode
    name (defined in entt::internal::MetaDataNode)entt::internal::MetaDataNode
    next (defined in entt::internal::MetaDataNode)entt::internal::MetaDataNode
    prop (defined in entt::internal::MetaDataNode)entt::internal::MetaDataNode
    readonly (defined in entt::internal::MetaDataNode)entt::internal::MetaDataNode
    set (defined in entt::internal::MetaDataNode)entt::internal::MetaDataNode
    shared (defined in entt::internal::MetaDataNode)entt::internal::MetaDataNode
    type (defined in entt::internal::MetaDataNode)entt::internal::MetaDataNode
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1MetaDataNode.html b/structentt_1_1internal_1_1MetaDataNode.html deleted file mode 100644 index c769b1c4a..000000000 --- a/structentt_1_1internal_1_1MetaDataNode.html +++ /dev/null @@ -1,141 +0,0 @@ - - - - - - - -EnTT: entt::internal::MetaDataNode Struct Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Public Attributes | -List of all members
    -
    -
    entt::internal::MetaDataNode Struct Referencefinal
    -
    -
    -
    -Collaboration diagram for entt::internal::MetaDataNode:
    -
    -
    Collaboration graph
    - - - - - - - - - - - - - - - -
    [legend]
    - - - - - - - - - - - - - - - - - - - - - - -

    -Public Attributes

    -const HashedString name
     
    -MetaDataNode *const next
     
    -MetaPropNode *const prop
     
    -const bool readonly
     
    -const bool shared
     
    -MetaTypeNode *(*const type )()
     
    -void(*const set )(void *, const MetaAny &)
     
    -MetaAny(*const get )(const void *)
     
    -bool(*const accept )(const MetaTypeNode *const)
     
    -MetaData *(*const meta )()
     
    -

    Detailed Description

    -
    -

    Definition at line 130 of file meta.hpp.

    -
    The documentation for this struct was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1MetaDataNode__coll__graph.map b/structentt_1_1internal_1_1MetaDataNode__coll__graph.map deleted file mode 100644 index 42ff8752b..000000000 --- a/structentt_1_1internal_1_1MetaDataNode__coll__graph.map +++ /dev/null @@ -1,15 +0,0 @@ - - - - - - - - - - - - - - - diff --git a/structentt_1_1internal_1_1MetaDataNode__coll__graph.md5 b/structentt_1_1internal_1_1MetaDataNode__coll__graph.md5 deleted file mode 100644 index 4ec79a540..000000000 --- a/structentt_1_1internal_1_1MetaDataNode__coll__graph.md5 +++ /dev/null @@ -1 +0,0 @@ -8c30af7d3cfc36d64aa3d0874e148745 \ No newline at end of file diff --git a/structentt_1_1internal_1_1MetaDataNode__coll__graph.png b/structentt_1_1internal_1_1MetaDataNode__coll__graph.png deleted file mode 100644 index 310a472c8..000000000 Binary files a/structentt_1_1internal_1_1MetaDataNode__coll__graph.png and /dev/null differ diff --git a/structentt_1_1internal_1_1MetaDtorNode-members.html b/structentt_1_1internal_1_1MetaDtorNode-members.html deleted file mode 100644 index 41a33efab..000000000 --- a/structentt_1_1internal_1_1MetaDtorNode-members.html +++ /dev/null @@ -1,84 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::internal::MetaDtorNode Member List
    -
    -
    - -

    This is the complete list of members for entt::internal::MetaDtorNode, including all inherited members.

    - - - - -
    invoke (defined in entt::internal::MetaDtorNode)entt::internal::MetaDtorNode
    meta (defined in entt::internal::MetaDtorNode)entt::internal::MetaDtorNode
    prop (defined in entt::internal::MetaDtorNode)entt::internal::MetaDtorNode
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1MetaDtorNode.html b/structentt_1_1internal_1_1MetaDtorNode.html deleted file mode 100644 index 7a123b1b7..000000000 --- a/structentt_1_1internal_1_1MetaDtorNode.html +++ /dev/null @@ -1,111 +0,0 @@ - - - - - - - -EnTT: entt::internal::MetaDtorNode Struct Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Public Attributes | -List of all members
    -
    -
    entt::internal::MetaDtorNode Struct Referencefinal
    -
    -
    -
    -Collaboration diagram for entt::internal::MetaDtorNode:
    -
    -
    Collaboration graph
    - - - - - - -
    [legend]
    - - - - - - - - -

    -Public Attributes

    -MetaPropNode *const prop
     
    -void(*const invoke )(void *)
     
    -MetaDtor *(*const meta )()
     
    -

    Detailed Description

    -
    -

    Definition at line 123 of file meta.hpp.

    -
    The documentation for this struct was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1MetaDtorNode__coll__graph.map b/structentt_1_1internal_1_1MetaDtorNode__coll__graph.map deleted file mode 100644 index eb8855ac2..000000000 --- a/structentt_1_1internal_1_1MetaDtorNode__coll__graph.map +++ /dev/null @@ -1,6 +0,0 @@ - - - - - - diff --git a/structentt_1_1internal_1_1MetaDtorNode__coll__graph.md5 b/structentt_1_1internal_1_1MetaDtorNode__coll__graph.md5 deleted file mode 100644 index 469bc6197..000000000 --- a/structentt_1_1internal_1_1MetaDtorNode__coll__graph.md5 +++ /dev/null @@ -1 +0,0 @@ -980cf114f0a164360881292c801a7424 \ No newline at end of file diff --git a/structentt_1_1internal_1_1MetaDtorNode__coll__graph.png b/structentt_1_1internal_1_1MetaDtorNode__coll__graph.png deleted file mode 100644 index 16de1faeb..000000000 Binary files a/structentt_1_1internal_1_1MetaDtorNode__coll__graph.png and /dev/null differ diff --git a/structentt_1_1internal_1_1MetaFuncNode-members.html b/structentt_1_1internal_1_1MetaFuncNode-members.html deleted file mode 100644 index bab5bb97c..000000000 --- a/structentt_1_1internal_1_1MetaFuncNode-members.html +++ /dev/null @@ -1,94 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::internal::MetaFuncNode Member List
    -
    -
    - -

    This is the complete list of members for entt::internal::MetaFuncNode, including all inherited members.

    - - - - - - - - - - - - - - -
    accept (defined in entt::internal::MetaFuncNode)entt::internal::MetaFuncNode
    arg (defined in entt::internal::MetaFuncNode)entt::internal::MetaFuncNode
    cinvoke (defined in entt::internal::MetaFuncNode)entt::internal::MetaFuncNode
    constant (defined in entt::internal::MetaFuncNode)entt::internal::MetaFuncNode
    invoke (defined in entt::internal::MetaFuncNode)entt::internal::MetaFuncNode
    meta (defined in entt::internal::MetaFuncNode)entt::internal::MetaFuncNode
    name (defined in entt::internal::MetaFuncNode)entt::internal::MetaFuncNode
    next (defined in entt::internal::MetaFuncNode)entt::internal::MetaFuncNode
    prop (defined in entt::internal::MetaFuncNode)entt::internal::MetaFuncNode
    ret (defined in entt::internal::MetaFuncNode)entt::internal::MetaFuncNode
    shared (defined in entt::internal::MetaFuncNode)entt::internal::MetaFuncNode
    size (defined in entt::internal::MetaFuncNode)entt::internal::MetaFuncNode
    size_type typedef (defined in entt::internal::MetaFuncNode)entt::internal::MetaFuncNode
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1MetaFuncNode.html b/structentt_1_1internal_1_1MetaFuncNode.html deleted file mode 100644 index 96474c7d2..000000000 --- a/structentt_1_1internal_1_1MetaFuncNode.html +++ /dev/null @@ -1,154 +0,0 @@ - - - - - - - -EnTT: entt::internal::MetaFuncNode Struct Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Public Types | -Public Attributes | -List of all members
    -
    -
    entt::internal::MetaFuncNode Struct Referencefinal
    -
    -
    -
    -Collaboration diagram for entt::internal::MetaFuncNode:
    -
    -
    Collaboration graph
    - - - - - - - - - - - - - - - -
    [legend]
    - - - - -

    -Public Types

    -using size_type = std::size_t
     
    - - - - - - - - - - - - - - - - - - - - - - - - - -

    -Public Attributes

    -const HashedString name
     
    -MetaFuncNode *const next
     
    -MetaPropNode *const prop
     
    -const size_type size
     
    -const bool constant
     
    -const bool shared
     
    -MetaTypeNode *(*const ret )()
     
    -MetaTypeNode *(*const arg )(size_type)
     
    -bool(*const accept )(const MetaTypeNode **const)
     
    -MetaAny(*const cinvoke )(const void *, const MetaAny *)
     
    -MetaAny(*const invoke )(void *, const MetaAny *)
     
    -MetaFunc *(*const meta )()
     
    -

    Detailed Description

    -
    -

    Definition at line 144 of file meta.hpp.

    -
    The documentation for this struct was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1MetaFuncNode__coll__graph.map b/structentt_1_1internal_1_1MetaFuncNode__coll__graph.map deleted file mode 100644 index 4cae91139..000000000 --- a/structentt_1_1internal_1_1MetaFuncNode__coll__graph.map +++ /dev/null @@ -1,15 +0,0 @@ - - - - - - - - - - - - - - - diff --git a/structentt_1_1internal_1_1MetaFuncNode__coll__graph.md5 b/structentt_1_1internal_1_1MetaFuncNode__coll__graph.md5 deleted file mode 100644 index 71a9a9aa2..000000000 --- a/structentt_1_1internal_1_1MetaFuncNode__coll__graph.md5 +++ /dev/null @@ -1 +0,0 @@ -b76baee2dce182f3db3cc734a931cb0e \ No newline at end of file diff --git a/structentt_1_1internal_1_1MetaFuncNode__coll__graph.png b/structentt_1_1internal_1_1MetaFuncNode__coll__graph.png deleted file mode 100644 index 53e42096d..000000000 Binary files a/structentt_1_1internal_1_1MetaFuncNode__coll__graph.png and /dev/null differ diff --git a/structentt_1_1internal_1_1MetaInfo-members.html b/structentt_1_1internal_1_1MetaInfo-members.html deleted file mode 100644 index 50b238c81..000000000 --- a/structentt_1_1internal_1_1MetaInfo-members.html +++ /dev/null @@ -1,82 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::internal::MetaInfo< Type > Member List
    -
    -
    - -

    This is the complete list of members for entt::internal::MetaInfo< Type >, including all inherited members.

    - - -
    type (defined in entt::internal::MetaNode< std::decay_t< Type >... >)entt::internal::MetaNode< std::decay_t< Type >... >static
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1MetaInfo.html b/structentt_1_1internal_1_1MetaInfo.html deleted file mode 100644 index 1f68e1a0b..000000000 --- a/structentt_1_1internal_1_1MetaInfo.html +++ /dev/null @@ -1,127 +0,0 @@ - - - - - - - -EnTT: entt::internal::MetaInfo< Type > Struct Template Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -List of all members
    -
    -
    entt::internal::MetaInfo< Type > Struct Template Reference
    -
    -
    -
    -Inheritance diagram for entt::internal::MetaInfo< Type >:
    -
    -
    Inheritance graph
    - - - -
    [legend]
    -
    -Collaboration diagram for entt::internal::MetaInfo< Type >:
    -
    -
    Collaboration graph
    - - - - - - - - - - - - - - - - - -
    [legend]
    - - - - - -

    -Additional Inherited Members

    - Static Public Attributes inherited from entt::internal::MetaNode< std::decay_t< Type >... >
    -static MetaTypeNode * type
     
    -

    Detailed Description

    -

    template<typename... Type>
    -struct entt::internal::MetaInfo< Type >

    - - -

    Definition at line 100 of file meta.hpp.

    -
    The documentation for this struct was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1MetaInfo__coll__graph.map b/structentt_1_1internal_1_1MetaInfo__coll__graph.map deleted file mode 100644 index 7ae5d204e..000000000 --- a/structentt_1_1internal_1_1MetaInfo__coll__graph.map +++ /dev/null @@ -1,17 +0,0 @@ - - - - - - - - - - - - - - - - - diff --git a/structentt_1_1internal_1_1MetaInfo__coll__graph.md5 b/structentt_1_1internal_1_1MetaInfo__coll__graph.md5 deleted file mode 100644 index 7d0a8049c..000000000 --- a/structentt_1_1internal_1_1MetaInfo__coll__graph.md5 +++ /dev/null @@ -1 +0,0 @@ -6f367000e8d80ca706b9208ded46cc8a \ No newline at end of file diff --git a/structentt_1_1internal_1_1MetaInfo__coll__graph.png b/structentt_1_1internal_1_1MetaInfo__coll__graph.png deleted file mode 100644 index b17e672d8..000000000 Binary files a/structentt_1_1internal_1_1MetaInfo__coll__graph.png and /dev/null differ diff --git a/structentt_1_1internal_1_1MetaInfo__inherit__graph.map b/structentt_1_1internal_1_1MetaInfo__inherit__graph.map deleted file mode 100644 index 489512204..000000000 --- a/structentt_1_1internal_1_1MetaInfo__inherit__graph.map +++ /dev/null @@ -1,3 +0,0 @@ - - - diff --git a/structentt_1_1internal_1_1MetaInfo__inherit__graph.md5 b/structentt_1_1internal_1_1MetaInfo__inherit__graph.md5 deleted file mode 100644 index 3ec3696ea..000000000 --- a/structentt_1_1internal_1_1MetaInfo__inherit__graph.md5 +++ /dev/null @@ -1 +0,0 @@ -ca88f09ed832f157ca4d5a4abf562b8e \ No newline at end of file diff --git a/structentt_1_1internal_1_1MetaInfo__inherit__graph.png b/structentt_1_1internal_1_1MetaInfo__inherit__graph.png deleted file mode 100644 index 773584579..000000000 Binary files a/structentt_1_1internal_1_1MetaInfo__inherit__graph.png and /dev/null differ diff --git a/structentt_1_1internal_1_1MetaNode-members.html b/structentt_1_1internal_1_1MetaNode-members.html deleted file mode 100644 index 9c4672daa..000000000 --- a/structentt_1_1internal_1_1MetaNode-members.html +++ /dev/null @@ -1,82 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::internal::MetaNode<... > Member List
    -
    -
    - -

    This is the complete list of members for entt::internal::MetaNode<... >, including all inherited members.

    - - -
    type (defined in entt::internal::MetaNode<... >)entt::internal::MetaNode<... >static
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1MetaNode.html b/structentt_1_1internal_1_1MetaNode.html deleted file mode 100644 index 2600985b0..000000000 --- a/structentt_1_1internal_1_1MetaNode.html +++ /dev/null @@ -1,118 +0,0 @@ - - - - - - - -EnTT: entt::internal::MetaNode<... > Struct Template Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Static Public Attributes | -List of all members
    -
    -
    entt::internal::MetaNode<... > Struct Template Reference
    -
    -
    -
    -Collaboration diagram for entt::internal::MetaNode<... >:
    -
    -
    Collaboration graph
    - - - - - - - - - - - - - - - - -
    [legend]
    - - - - -

    -Static Public Attributes

    -static MetaTypeNode * type = nullptr
     
    -

    Detailed Description

    -

    template<typename...>
    -struct entt::internal::MetaNode<... >

    - - -

    Definition at line 38 of file meta.hpp.

    -
    The documentation for this struct was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1MetaNode_3_01Type_01_4-members.html b/structentt_1_1internal_1_1MetaNode_3_01Type_01_4-members.html deleted file mode 100644 index 8bbaf467b..000000000 --- a/structentt_1_1internal_1_1MetaNode_3_01Type_01_4-members.html +++ /dev/null @@ -1,88 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::internal::MetaNode< Type > Member List
    -
    -
    - -

    This is the complete list of members for entt::internal::MetaNode< Type >, including all inherited members.

    - - - - - - - - -
    ctor (defined in entt::internal::MetaNode< Type >)entt::internal::MetaNode< Type >static
    data (defined in entt::internal::MetaNode< Type >)entt::internal::MetaNode< Type >static
    dtor (defined in entt::internal::MetaNode< Type >)entt::internal::MetaNode< Type >static
    func (defined in entt::internal::MetaNode< Type >)entt::internal::MetaNode< Type >static
    prop (defined in entt::internal::MetaNode< Type >)entt::internal::MetaNode< Type >static
    resolve() ENTT_NOEXCEPT (defined in entt::internal::MetaNode< Type >)entt::internal::MetaNode< Type >static
    type (defined in entt::internal::MetaNode< Type >)entt::internal::MetaNode< Type >static
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1MetaNode_3_01Type_01_4.html b/structentt_1_1internal_1_1MetaNode_3_01Type_01_4.html deleted file mode 100644 index 64f47264e..000000000 --- a/structentt_1_1internal_1_1MetaNode_3_01Type_01_4.html +++ /dev/null @@ -1,145 +0,0 @@ - - - - - - - -EnTT: entt::internal::MetaNode< Type > Struct Template Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Static Public Member Functions | -Static Public Attributes | -List of all members
    -
    -
    entt::internal::MetaNode< Type > Struct Template Reference
    -
    -
    -
    -Collaboration diagram for entt::internal::MetaNode< Type >:
    -
    -
    Collaboration graph
    - - - - - - - - - - - - - - - - -
    [legend]
    - - - - -

    -Static Public Member Functions

    -static internal::MetaTypeNode * resolve () ENTT_NOEXCEPT
     
    - - - - - - - - - - - - - - - - - - -

    -Static Public Attributes

    -static MetaTypeNode * type = nullptr
     
    -template<typename >
    static MetaCtorNode * ctor = nullptr
     
    -template<typename >
    static MetaDtorNode * dtor = nullptr
     
    -template<typename >
    static MetaDataNode * data = nullptr
     
    -template<typename >
    static MetaFuncNode * func = nullptr
     
    -template<typename , typename... >
    static MetaPropNode * prop = nullptr
     
    -

    Detailed Description

    -

    template<typename Type>
    -struct entt::internal::MetaNode< Type >

    - - -

    Definition at line 48 of file meta.hpp.

    -
    The documentation for this struct was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1MetaNode_3_01Type_01_4__coll__graph.map b/structentt_1_1internal_1_1MetaNode_3_01Type_01_4__coll__graph.map deleted file mode 100644 index fd7342630..000000000 --- a/structentt_1_1internal_1_1MetaNode_3_01Type_01_4__coll__graph.map +++ /dev/null @@ -1,16 +0,0 @@ - - - - - - - - - - - - - - - - diff --git a/structentt_1_1internal_1_1MetaNode_3_01Type_01_4__coll__graph.md5 b/structentt_1_1internal_1_1MetaNode_3_01Type_01_4__coll__graph.md5 deleted file mode 100644 index d3432bc30..000000000 --- a/structentt_1_1internal_1_1MetaNode_3_01Type_01_4__coll__graph.md5 +++ /dev/null @@ -1 +0,0 @@ -fee56bd5a910124e4cddbd58708f66a7 \ No newline at end of file diff --git a/structentt_1_1internal_1_1MetaNode_3_01Type_01_4__coll__graph.png b/structentt_1_1internal_1_1MetaNode_3_01Type_01_4__coll__graph.png deleted file mode 100644 index 90fea8841..000000000 Binary files a/structentt_1_1internal_1_1MetaNode_3_01Type_01_4__coll__graph.png and /dev/null differ diff --git a/structentt_1_1internal_1_1MetaNode__coll__graph.map b/structentt_1_1internal_1_1MetaNode__coll__graph.map deleted file mode 100644 index dd11f6165..000000000 --- a/structentt_1_1internal_1_1MetaNode__coll__graph.map +++ /dev/null @@ -1,16 +0,0 @@ - - - - - - - - - - - - - - - - diff --git a/structentt_1_1internal_1_1MetaNode__coll__graph.md5 b/structentt_1_1internal_1_1MetaNode__coll__graph.md5 deleted file mode 100644 index 1bfd06239..000000000 --- a/structentt_1_1internal_1_1MetaNode__coll__graph.md5 +++ /dev/null @@ -1 +0,0 @@ -513294c68e17adc0d4edb946fed6bd80 \ No newline at end of file diff --git a/structentt_1_1internal_1_1MetaNode__coll__graph.png b/structentt_1_1internal_1_1MetaNode__coll__graph.png deleted file mode 100644 index 816be0683..000000000 Binary files a/structentt_1_1internal_1_1MetaNode__coll__graph.png and /dev/null differ diff --git a/structentt_1_1internal_1_1MetaPropNode-members.html b/structentt_1_1internal_1_1MetaPropNode-members.html deleted file mode 100644 index 76486d2bf..000000000 --- a/structentt_1_1internal_1_1MetaPropNode-members.html +++ /dev/null @@ -1,85 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::internal::MetaPropNode Member List
    -
    -
    - -

    This is the complete list of members for entt::internal::MetaPropNode, including all inherited members.

    - - - - - -
    key (defined in entt::internal::MetaPropNode)entt::internal::MetaPropNode
    meta (defined in entt::internal::MetaPropNode)entt::internal::MetaPropNode
    next (defined in entt::internal::MetaPropNode)entt::internal::MetaPropNode
    value (defined in entt::internal::MetaPropNode)entt::internal::MetaPropNode
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1MetaPropNode.html b/structentt_1_1internal_1_1MetaPropNode.html deleted file mode 100644 index 5e7b955e0..000000000 --- a/structentt_1_1internal_1_1MetaPropNode.html +++ /dev/null @@ -1,112 +0,0 @@ - - - - - - - -EnTT: entt::internal::MetaPropNode Struct Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Public Attributes | -List of all members
    -
    -
    entt::internal::MetaPropNode Struct Referencefinal
    -
    -
    -
    -Collaboration diagram for entt::internal::MetaPropNode:
    -
    -
    Collaboration graph
    - - - - -
    [legend]
    - - - - - - - - - - -

    -Public Attributes

    -MetaPropNode *const next
     
    -const MetaAny &(*const key )()
     
    -const MetaAny &(*const value )()
     
    -MetaProp *(*const meta )()
     
    -

    Detailed Description

    -
    -

    Definition at line 103 of file meta.hpp.

    -
    The documentation for this struct was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1MetaPropNode__coll__graph.map b/structentt_1_1internal_1_1MetaPropNode__coll__graph.map deleted file mode 100644 index 220bee3db..000000000 --- a/structentt_1_1internal_1_1MetaPropNode__coll__graph.map +++ /dev/null @@ -1,4 +0,0 @@ - - - - diff --git a/structentt_1_1internal_1_1MetaPropNode__coll__graph.md5 b/structentt_1_1internal_1_1MetaPropNode__coll__graph.md5 deleted file mode 100644 index 037043288..000000000 --- a/structentt_1_1internal_1_1MetaPropNode__coll__graph.md5 +++ /dev/null @@ -1 +0,0 @@ -d63e2eeea34020ddafe32e7e73da5df7 \ No newline at end of file diff --git a/structentt_1_1internal_1_1MetaPropNode__coll__graph.png b/structentt_1_1internal_1_1MetaPropNode__coll__graph.png deleted file mode 100644 index b9317ba55..000000000 Binary files a/structentt_1_1internal_1_1MetaPropNode__coll__graph.png and /dev/null differ diff --git a/structentt_1_1internal_1_1MetaTypeNode-members.html b/structentt_1_1internal_1_1MetaTypeNode-members.html deleted file mode 100644 index a5c45378b..000000000 --- a/structentt_1_1internal_1_1MetaTypeNode-members.html +++ /dev/null @@ -1,90 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::internal::MetaTypeNode Member List
    -
    -
    - -

    This is the complete list of members for entt::internal::MetaTypeNode, including all inherited members.

    - - - - - - - - - - -
    ctor (defined in entt::internal::MetaTypeNode)entt::internal::MetaTypeNode
    data (defined in entt::internal::MetaTypeNode)entt::internal::MetaTypeNode
    destroy (defined in entt::internal::MetaTypeNode)entt::internal::MetaTypeNode
    dtor (defined in entt::internal::MetaTypeNode)entt::internal::MetaTypeNode
    func (defined in entt::internal::MetaTypeNode)entt::internal::MetaTypeNode
    meta (defined in entt::internal::MetaTypeNode)entt::internal::MetaTypeNode
    name (defined in entt::internal::MetaTypeNode)entt::internal::MetaTypeNode
    next (defined in entt::internal::MetaTypeNode)entt::internal::MetaTypeNode
    prop (defined in entt::internal::MetaTypeNode)entt::internal::MetaTypeNode
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1MetaTypeNode.html b/structentt_1_1internal_1_1MetaTypeNode.html deleted file mode 100644 index d4988a995..000000000 --- a/structentt_1_1internal_1_1MetaTypeNode.html +++ /dev/null @@ -1,138 +0,0 @@ - - - - - - - -EnTT: entt::internal::MetaTypeNode Struct Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Public Attributes | -List of all members
    -
    -
    entt::internal::MetaTypeNode Struct Referencefinal
    -
    -
    -
    -Collaboration diagram for entt::internal::MetaTypeNode:
    -
    -
    Collaboration graph
    - - - - - - - - - - - - - - - -
    [legend]
    - - - - - - - - - - - - - - - - - - - - -

    -Public Attributes

    -const HashedString name
     
    -MetaTypeNode *const next
     
    -MetaPropNode *const prop
     
    -void(*const destroy )(void *)
     
    -MetaType *(*const meta )()
     
    -MetaCtorNode * ctor
     
    -MetaDtorNode * dtor
     
    -MetaDataNode * data
     
    -MetaFuncNode * func
     
    -

    Detailed Description

    -
    -

    Definition at line 161 of file meta.hpp.

    -
    The documentation for this struct was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1MetaTypeNode__coll__graph.map b/structentt_1_1internal_1_1MetaTypeNode__coll__graph.map deleted file mode 100644 index e865b4f8a..000000000 --- a/structentt_1_1internal_1_1MetaTypeNode__coll__graph.map +++ /dev/null @@ -1,15 +0,0 @@ - - - - - - - - - - - - - - - diff --git a/structentt_1_1internal_1_1MetaTypeNode__coll__graph.md5 b/structentt_1_1internal_1_1MetaTypeNode__coll__graph.md5 deleted file mode 100644 index 847610e6b..000000000 --- a/structentt_1_1internal_1_1MetaTypeNode__coll__graph.md5 +++ /dev/null @@ -1 +0,0 @@ -f0b8c1b921139233b9951b8057f67f30 \ No newline at end of file diff --git a/structentt_1_1internal_1_1MetaTypeNode__coll__graph.png b/structentt_1_1internal_1_1MetaTypeNode__coll__graph.png deleted file mode 100644 index e785980e0..000000000 Binary files a/structentt_1_1internal_1_1MetaTypeNode__coll__graph.png and /dev/null differ diff --git a/structentt_1_1internal_1_1ReflectionHelper.html b/structentt_1_1internal_1_1ReflectionHelper.html deleted file mode 100644 index 41ab200ed..000000000 --- a/structentt_1_1internal_1_1ReflectionHelper.html +++ /dev/null @@ -1,87 +0,0 @@ - - - - - - - -EnTT: entt::internal::ReflectionHelper< typename, typename > Struct Template Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::internal::ReflectionHelper< typename, typename > Struct Template Reference
    -
    -
    -

    Detailed Description

    -

    template<typename, typename = void>
    -struct entt::internal::ReflectionHelper< typename, typename >

    - - -

    Definition at line 689 of file meta.hpp.

    -
    The documentation for this struct was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_00d602dc6ec169f254929375e78a46dac.html b/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_00d602dc6ec169f254929375e78a46dac.html deleted file mode 100644 index d7bd25c87..000000000 --- a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_00d602dc6ec169f254929375e78a46dac.html +++ /dev/null @@ -1,145 +0,0 @@ - - - - - - - -EnTT: entt::internal::ReflectionHelper< std::integral_constant< Ret(Class::*)(Args...) const, Member >, std::enable_if_t< std::is_member_function_pointer< Ret(Class::*)(Args...) const >::value > > Struct Template Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Static Public Member Functions | -Static Public Attributes | -List of all members
    -
    -
    entt::internal::ReflectionHelper< std::integral_constant< Ret(Class::*)(Args...) const, Member >, std::enable_if_t< std::is_member_function_pointer< Ret(Class::*)(Args...) const >::value > > Struct Template Reference
    -
    -
    -
    -Inheritance diagram for entt::internal::ReflectionHelper< std::integral_constant< Ret(Class::*)(Args...) const, Member >, std::enable_if_t< std::is_member_function_pointer< Ret(Class::*)(Args...) const >::value > >:
    -
    -
    Inheritance graph
    - - - -
    [legend]
    -
    -Collaboration diagram for entt::internal::ReflectionHelper< std::integral_constant< Ret(Class::*)(Args...) const, Member >, std::enable_if_t< std::is_member_function_pointer< Ret(Class::*)(Args...) const >::value > >:
    -
    -
    Collaboration graph
    - - - -
    [legend]
    - - - - - - - - - - -

    -Static Public Member Functions

    -template<std::size_t... Indexes>
    static auto invoke (int, const void *instance, const MetaAny *any, std::index_sequence< Indexes... >) -> decltype(MetaAny
     
    - Static Public Member Functions inherited from entt::internal::FunctionHelper< Ret(Args...)>
    -static auto arg (typename internal::MetaFuncNode::size_type index)
     
    -static auto accept (const internal::MetaTypeNode **const types)
     
    - - - - - - - - -

    -Static Public Attributes

    -static constexpr auto constant = true
     
    -static constexpr auto shared = false
     
    - Static Public Attributes inherited from entt::internal::FunctionHelper< Ret(Args...)>
    -static constexpr auto size = sizeof...(Args)
     
    - - - - - - -

    -Additional Inherited Members

    - Public Types inherited from entt::internal::FunctionHelper< Ret(Args...)>
    -using return_type = Ret
     
    -using args_type = std::tuple< Args... >
     
    -

    Detailed Description

    -

    template<typename Class, typename Ret, typename... Args, Ret(Class::*)(Args...) const Member>
    -struct entt::internal::ReflectionHelper< std::integral_constant< Ret(Class::*)(Args...) const, Member >, std::enable_if_t< std::is_member_function_pointer< Ret(Class::*)(Args...) const >::value > >

    - - -

    Definition at line 741 of file meta.hpp.

    -
    The documentation for this struct was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_015539704a649a59d142205c030330d2b.html b/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_015539704a649a59d142205c030330d2b.html deleted file mode 100644 index 1dc42c64e..000000000 --- a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_015539704a649a59d142205c030330d2b.html +++ /dev/null @@ -1,89 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::internal::ReflectionHelper< std::integral_constant< Ret(Class::*)(Args...) const, Member >, std::enable_if_t< std::is_member_function_pointer< Ret(Class::*)(Args...) const >::value > > Member List
    -
    -
    - -

    This is the complete list of members for entt::internal::ReflectionHelper< std::integral_constant< Ret(Class::*)(Args...) const, Member >, std::enable_if_t< std::is_member_function_pointer< Ret(Class::*)(Args...) const >::value > >, including all inherited members.

    - - - - - - - - - -
    accept(const internal::MetaTypeNode **const types) (defined in entt::internal::FunctionHelper< Ret(Args...)>)entt::internal::FunctionHelper< Ret(Args...)>inlinestatic
    arg(typename internal::MetaFuncNode::size_type index) (defined in entt::internal::FunctionHelper< Ret(Args...)>)entt::internal::FunctionHelper< Ret(Args...)>inlinestatic
    args_type typedef (defined in entt::internal::FunctionHelper< Ret(Args...)>)entt::internal::FunctionHelper< Ret(Args...)>
    constant (defined in entt::internal::ReflectionHelper< std::integral_constant< Ret(Class::*)(Args...) const, Member >, std::enable_if_t< std::is_member_function_pointer< Ret(Class::*)(Args...) const >::value > >)entt::internal::ReflectionHelper< std::integral_constant< Ret(Class::*)(Args...) const, Member >, std::enable_if_t< std::is_member_function_pointer< Ret(Class::*)(Args...) const >::value > >static
    invoke(int, const void *instance, const MetaAny *any, std::index_sequence< Indexes... >) -> decltype(MetaAny (defined in entt::internal::ReflectionHelper< std::integral_constant< Ret(Class::*)(Args...) const, Member >, std::enable_if_t< std::is_member_function_pointer< Ret(Class::*)(Args...) const >::value > >)entt::internal::ReflectionHelper< std::integral_constant< Ret(Class::*)(Args...) const, Member >, std::enable_if_t< std::is_member_function_pointer< Ret(Class::*)(Args...) const >::value > >inlinestatic
    return_type typedef (defined in entt::internal::FunctionHelper< Ret(Args...)>)entt::internal::FunctionHelper< Ret(Args...)>
    shared (defined in entt::internal::ReflectionHelper< std::integral_constant< Ret(Class::*)(Args...) const, Member >, std::enable_if_t< std::is_member_function_pointer< Ret(Class::*)(Args...) const >::value > >)entt::internal::ReflectionHelper< std::integral_constant< Ret(Class::*)(Args...) const, Member >, std::enable_if_t< std::is_member_function_pointer< Ret(Class::*)(Args...) const >::value > >static
    size (defined in entt::internal::FunctionHelper< Ret(Args...)>)entt::internal::FunctionHelper< Ret(Args...)>static
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_0420e89fa634eb8a1fc577ac631093008.map b/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_0420e89fa634eb8a1fc577ac631093008.map deleted file mode 100644 index a105b736d..000000000 --- a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_0420e89fa634eb8a1fc577ac631093008.map +++ /dev/null @@ -1,3 +0,0 @@ - - - diff --git a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_0420e89fa634eb8a1fc577ac631093008.md5 b/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_0420e89fa634eb8a1fc577ac631093008.md5 deleted file mode 100644 index 491294eba..000000000 --- a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_0420e89fa634eb8a1fc577ac631093008.md5 +++ /dev/null @@ -1 +0,0 @@ -6aaa3f2d5067ef4ec99037fa663f67e0 \ No newline at end of file diff --git a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_0420e89fa634eb8a1fc577ac631093008.png b/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_0420e89fa634eb8a1fc577ac631093008.png deleted file mode 100644 index 68a6be2f7..000000000 Binary files a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_0420e89fa634eb8a1fc577ac631093008.png and /dev/null differ diff --git a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_0868046ef5528de2d018c38a0bece18e0.html b/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_0868046ef5528de2d018c38a0bece18e0.html deleted file mode 100644 index 18324d7d2..000000000 --- a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_0868046ef5528de2d018c38a0bece18e0.html +++ /dev/null @@ -1,145 +0,0 @@ - - - - - - - -EnTT: entt::internal::ReflectionHelper< std::integral_constant< Ret(Class::*)(Args...), Member >, std::enable_if_t< std::is_member_function_pointer< Ret(Class::*)(Args...)>::value > > Struct Template Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Static Public Member Functions | -Static Public Attributes | -List of all members
    -
    -
    entt::internal::ReflectionHelper< std::integral_constant< Ret(Class::*)(Args...), Member >, std::enable_if_t< std::is_member_function_pointer< Ret(Class::*)(Args...)>::value > > Struct Template Reference
    -
    -
    -
    -Inheritance diagram for entt::internal::ReflectionHelper< std::integral_constant< Ret(Class::*)(Args...), Member >, std::enable_if_t< std::is_member_function_pointer< Ret(Class::*)(Args...)>::value > >:
    -
    -
    Inheritance graph
    - - - -
    [legend]
    -
    -Collaboration diagram for entt::internal::ReflectionHelper< std::integral_constant< Ret(Class::*)(Args...), Member >, std::enable_if_t< std::is_member_function_pointer< Ret(Class::*)(Args...)>::value > >:
    -
    -
    Collaboration graph
    - - - -
    [legend]
    - - - - - - - - - - -

    -Static Public Member Functions

    -template<std::size_t... Indexes>
    static auto invoke (int, void *instance, const MetaAny *any, std::index_sequence< Indexes... >) -> decltype(MetaAny
     
    - Static Public Member Functions inherited from entt::internal::FunctionHelper< Ret(Args...)>
    -static auto arg (typename internal::MetaFuncNode::size_type index)
     
    -static auto accept (const internal::MetaTypeNode **const types)
     
    - - - - - - - - -

    -Static Public Attributes

    -static constexpr auto constant = false
     
    -static constexpr auto shared = false
     
    - Static Public Attributes inherited from entt::internal::FunctionHelper< Ret(Args...)>
    -static constexpr auto size = sizeof...(Args)
     
    - - - - - - -

    -Additional Inherited Members

    - Public Types inherited from entt::internal::FunctionHelper< Ret(Args...)>
    -using return_type = Ret
     
    -using args_type = std::tuple< Args... >
     
    -

    Detailed Description

    -

    template<typename Class, typename Ret, typename... Args, Ret(Class::*)(Args...) Member>
    -struct entt::internal::ReflectionHelper< std::integral_constant< Ret(Class::*)(Args...), Member >, std::enable_if_t< std::is_member_function_pointer< Ret(Class::*)(Args...)>::value > >

    - - -

    Definition at line 715 of file meta.hpp.

    -
    The documentation for this struct was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_09ed366b0b925f8491739847cc864d665.map b/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_09ed366b0b925f8491739847cc864d665.map deleted file mode 100644 index 54c4db87c..000000000 --- a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_09ed366b0b925f8491739847cc864d665.map +++ /dev/null @@ -1,3 +0,0 @@ - - - diff --git a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_09ed366b0b925f8491739847cc864d665.md5 b/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_09ed366b0b925f8491739847cc864d665.md5 deleted file mode 100644 index b4f3c8892..000000000 --- a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_09ed366b0b925f8491739847cc864d665.md5 +++ /dev/null @@ -1 +0,0 @@ -2f746a12b23c38278c81ddb2d814871d \ No newline at end of file diff --git a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_09ed366b0b925f8491739847cc864d665.png b/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_09ed366b0b925f8491739847cc864d665.png deleted file mode 100644 index 338f99650..000000000 Binary files a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_09ed366b0b925f8491739847cc864d665.png and /dev/null differ diff --git a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_0a1cab8ad1dbb86fac6e7c34dde0c3c6b.html b/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_0a1cab8ad1dbb86fac6e7c34dde0c3c6b.html deleted file mode 100644 index 8e645e7a9..000000000 --- a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_0a1cab8ad1dbb86fac6e7c34dde0c3c6b.html +++ /dev/null @@ -1,89 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::internal::ReflectionHelper< std::integral_constant< Ret(Class::*)(Args...), Member >, std::enable_if_t< std::is_member_function_pointer< Ret(Class::*)(Args...)>::value > > Member List
    -
    -
    - -

    This is the complete list of members for entt::internal::ReflectionHelper< std::integral_constant< Ret(Class::*)(Args...), Member >, std::enable_if_t< std::is_member_function_pointer< Ret(Class::*)(Args...)>::value > >, including all inherited members.

    - - - - - - - - - -
    accept(const internal::MetaTypeNode **const types) (defined in entt::internal::FunctionHelper< Ret(Args...)>)entt::internal::FunctionHelper< Ret(Args...)>inlinestatic
    arg(typename internal::MetaFuncNode::size_type index) (defined in entt::internal::FunctionHelper< Ret(Args...)>)entt::internal::FunctionHelper< Ret(Args...)>inlinestatic
    args_type typedef (defined in entt::internal::FunctionHelper< Ret(Args...)>)entt::internal::FunctionHelper< Ret(Args...)>
    constant (defined in entt::internal::ReflectionHelper< std::integral_constant< Ret(Class::*)(Args...), Member >, std::enable_if_t< std::is_member_function_pointer< Ret(Class::*)(Args...)>::value > >)entt::internal::ReflectionHelper< std::integral_constant< Ret(Class::*)(Args...), Member >, std::enable_if_t< std::is_member_function_pointer< Ret(Class::*)(Args...)>::value > >static
    invoke(int, void *instance, const MetaAny *any, std::index_sequence< Indexes... >) -> decltype(MetaAny (defined in entt::internal::ReflectionHelper< std::integral_constant< Ret(Class::*)(Args...), Member >, std::enable_if_t< std::is_member_function_pointer< Ret(Class::*)(Args...)>::value > >)entt::internal::ReflectionHelper< std::integral_constant< Ret(Class::*)(Args...), Member >, std::enable_if_t< std::is_member_function_pointer< Ret(Class::*)(Args...)>::value > >inlinestatic
    return_type typedef (defined in entt::internal::FunctionHelper< Ret(Args...)>)entt::internal::FunctionHelper< Ret(Args...)>
    shared (defined in entt::internal::ReflectionHelper< std::integral_constant< Ret(Class::*)(Args...), Member >, std::enable_if_t< std::is_member_function_pointer< Ret(Class::*)(Args...)>::value > >)entt::internal::ReflectionHelper< std::integral_constant< Ret(Class::*)(Args...), Member >, std::enable_if_t< std::is_member_function_pointer< Ret(Class::*)(Args...)>::value > >static
    size (defined in entt::internal::FunctionHelper< Ret(Args...)>)entt::internal::FunctionHelper< Ret(Args...)>static
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_0c965b95e1f82696bad2e71b49fa6d8dd.map b/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_0c965b95e1f82696bad2e71b49fa6d8dd.map deleted file mode 100644 index 54c4db87c..000000000 --- a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_0c965b95e1f82696bad2e71b49fa6d8dd.map +++ /dev/null @@ -1,3 +0,0 @@ - - - diff --git a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_0c965b95e1f82696bad2e71b49fa6d8dd.md5 b/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_0c965b95e1f82696bad2e71b49fa6d8dd.md5 deleted file mode 100644 index 73af9b09e..000000000 --- a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_0c965b95e1f82696bad2e71b49fa6d8dd.md5 +++ /dev/null @@ -1 +0,0 @@ -a561873cc6124772ceeb6c74b77ebbf8 \ No newline at end of file diff --git a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_0c965b95e1f82696bad2e71b49fa6d8dd.png b/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_0c965b95e1f82696bad2e71b49fa6d8dd.png deleted file mode 100644 index 338f99650..000000000 Binary files a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_0c965b95e1f82696bad2e71b49fa6d8dd.png and /dev/null differ diff --git a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_0fd3deeb7c311fb4d4563e7d5ae0b9955.map b/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_0fd3deeb7c311fb4d4563e7d5ae0b9955.map deleted file mode 100644 index a105b736d..000000000 --- a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_0fd3deeb7c311fb4d4563e7d5ae0b9955.map +++ /dev/null @@ -1,3 +0,0 @@ - - - diff --git a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_0fd3deeb7c311fb4d4563e7d5ae0b9955.md5 b/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_0fd3deeb7c311fb4d4563e7d5ae0b9955.md5 deleted file mode 100644 index 311c002e1..000000000 --- a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_0fd3deeb7c311fb4d4563e7d5ae0b9955.md5 +++ /dev/null @@ -1 +0,0 @@ -5426b964545e3abe40436b5a3a21f33f \ No newline at end of file diff --git a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_0fd3deeb7c311fb4d4563e7d5ae0b9955.png b/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_0fd3deeb7c311fb4d4563e7d5ae0b9955.png deleted file mode 100644 index 68a6be2f7..000000000 Binary files a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07Class_1_1_5_0fd3deeb7c311fb4d4563e7d5ae0b9955.png and /dev/null differ diff --git a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07_5_08_07Args_502ffb16ff5bf47e94661cfa018f4eed.map b/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07_5_08_07Args_502ffb16ff5bf47e94661cfa018f4eed.map deleted file mode 100644 index fb19b1481..000000000 --- a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07_5_08_07Args_502ffb16ff5bf47e94661cfa018f4eed.map +++ /dev/null @@ -1,3 +0,0 @@ - - - diff --git a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07_5_08_07Args_502ffb16ff5bf47e94661cfa018f4eed.md5 b/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07_5_08_07Args_502ffb16ff5bf47e94661cfa018f4eed.md5 deleted file mode 100644 index 5672b725e..000000000 --- a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07_5_08_07Args_502ffb16ff5bf47e94661cfa018f4eed.md5 +++ /dev/null @@ -1 +0,0 @@ -e2da69d27930488ab5891982e3165c26 \ No newline at end of file diff --git a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07_5_08_07Args_502ffb16ff5bf47e94661cfa018f4eed.png b/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07_5_08_07Args_502ffb16ff5bf47e94661cfa018f4eed.png deleted file mode 100644 index 7f33a1c88..000000000 Binary files a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07_5_08_07Args_502ffb16ff5bf47e94661cfa018f4eed.png and /dev/null differ diff --git a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07_5_08_07Args_858d6f74f0eb72d4936c15a8caa3af63.html b/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07_5_08_07Args_858d6f74f0eb72d4936c15a8caa3af63.html deleted file mode 100644 index dcf35d8d1..000000000 --- a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07_5_08_07Args_858d6f74f0eb72d4936c15a8caa3af63.html +++ /dev/null @@ -1,145 +0,0 @@ - - - - - - - -EnTT: entt::internal::ReflectionHelper< std::integral_constant< Ret(*)(Args...), Func >, std::enable_if_t< std::is_function< Ret(Args...)>::value > > Struct Template Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Static Public Member Functions | -Static Public Attributes | -List of all members
    -
    -
    entt::internal::ReflectionHelper< std::integral_constant< Ret(*)(Args...), Func >, std::enable_if_t< std::is_function< Ret(Args...)>::value > > Struct Template Reference
    -
    -
    -
    -Inheritance diagram for entt::internal::ReflectionHelper< std::integral_constant< Ret(*)(Args...), Func >, std::enable_if_t< std::is_function< Ret(Args...)>::value > >:
    -
    -
    Inheritance graph
    - - - -
    [legend]
    -
    -Collaboration diagram for entt::internal::ReflectionHelper< std::integral_constant< Ret(*)(Args...), Func >, std::enable_if_t< std::is_function< Ret(Args...)>::value > >:
    -
    -
    Collaboration graph
    - - - -
    [legend]
    - - - - - - - - - - -

    -Static Public Member Functions

    -template<std::size_t... Indexes>
    static auto invoke (int, const void *, const MetaAny *any, std::index_sequence< Indexes... >) -> decltype(MetaAny
     
    - Static Public Member Functions inherited from entt::internal::FunctionHelper< Ret(Args...)>
    -static auto arg (typename internal::MetaFuncNode::size_type index)
     
    -static auto accept (const internal::MetaTypeNode **const types)
     
    - - - - - - - - -

    -Static Public Attributes

    -static constexpr auto constant = false
     
    -static constexpr auto shared = true
     
    - Static Public Attributes inherited from entt::internal::FunctionHelper< Ret(Args...)>
    -static constexpr auto size = sizeof...(Args)
     
    - - - - - - -

    -Additional Inherited Members

    - Public Types inherited from entt::internal::FunctionHelper< Ret(Args...)>
    -using return_type = Ret
     
    -using args_type = std::tuple< Args... >
     
    -

    Detailed Description

    -

    template<typename Ret, typename... Args, Ret(*)(Args...) Func>
    -struct entt::internal::ReflectionHelper< std::integral_constant< Ret(*)(Args...), Func >, std::enable_if_t< std::is_function< Ret(Args...)>::value > >

    - - -

    Definition at line 783 of file meta.hpp.

    -
    The documentation for this struct was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07_5_08_07Args_d401927d8e36c51002e803efb588b956.html b/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07_5_08_07Args_d401927d8e36c51002e803efb588b956.html deleted file mode 100644 index 6537fd568..000000000 --- a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07_5_08_07Args_d401927d8e36c51002e803efb588b956.html +++ /dev/null @@ -1,89 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::internal::ReflectionHelper< std::integral_constant< Ret(*)(Args...), Func >, std::enable_if_t< std::is_function< Ret(Args...)>::value > > Member List
    -
    -
    - -

    This is the complete list of members for entt::internal::ReflectionHelper< std::integral_constant< Ret(*)(Args...), Func >, std::enable_if_t< std::is_function< Ret(Args...)>::value > >, including all inherited members.

    - - - - - - - - - -
    accept(const internal::MetaTypeNode **const types) (defined in entt::internal::FunctionHelper< Ret(Args...)>)entt::internal::FunctionHelper< Ret(Args...)>inlinestatic
    arg(typename internal::MetaFuncNode::size_type index) (defined in entt::internal::FunctionHelper< Ret(Args...)>)entt::internal::FunctionHelper< Ret(Args...)>inlinestatic
    args_type typedef (defined in entt::internal::FunctionHelper< Ret(Args...)>)entt::internal::FunctionHelper< Ret(Args...)>
    constant (defined in entt::internal::ReflectionHelper< std::integral_constant< Ret(*)(Args...), Func >, std::enable_if_t< std::is_function< Ret(Args...)>::value > >)entt::internal::ReflectionHelper< std::integral_constant< Ret(*)(Args...), Func >, std::enable_if_t< std::is_function< Ret(Args...)>::value > >static
    invoke(int, const void *, const MetaAny *any, std::index_sequence< Indexes... >) -> decltype(MetaAny (defined in entt::internal::ReflectionHelper< std::integral_constant< Ret(*)(Args...), Func >, std::enable_if_t< std::is_function< Ret(Args...)>::value > >)entt::internal::ReflectionHelper< std::integral_constant< Ret(*)(Args...), Func >, std::enable_if_t< std::is_function< Ret(Args...)>::value > >inlinestatic
    return_type typedef (defined in entt::internal::FunctionHelper< Ret(Args...)>)entt::internal::FunctionHelper< Ret(Args...)>
    shared (defined in entt::internal::ReflectionHelper< std::integral_constant< Ret(*)(Args...), Func >, std::enable_if_t< std::is_function< Ret(Args...)>::value > >)entt::internal::ReflectionHelper< std::integral_constant< Ret(*)(Args...), Func >, std::enable_if_t< std::is_function< Ret(Args...)>::value > >static
    size (defined in entt::internal::FunctionHelper< Ret(Args...)>)entt::internal::FunctionHelper< Ret(Args...)>static
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07_5_08_07Args_eba2d57ab4ca242c26bb20abfcabfd26.map b/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07_5_08_07Args_eba2d57ab4ca242c26bb20abfcabfd26.map deleted file mode 100644 index fb19b1481..000000000 --- a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07_5_08_07Args_eba2d57ab4ca242c26bb20abfcabfd26.map +++ /dev/null @@ -1,3 +0,0 @@ - - - diff --git a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07_5_08_07Args_eba2d57ab4ca242c26bb20abfcabfd26.md5 b/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07_5_08_07Args_eba2d57ab4ca242c26bb20abfcabfd26.md5 deleted file mode 100644 index 025373281..000000000 --- a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07_5_08_07Args_eba2d57ab4ca242c26bb20abfcabfd26.md5 +++ /dev/null @@ -1 +0,0 @@ -3bf76af8f529b8a6224e3a191e37423a \ No newline at end of file diff --git a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07_5_08_07Args_eba2d57ab4ca242c26bb20abfcabfd26.png b/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07_5_08_07Args_eba2d57ab4ca242c26bb20abfcabfd26.png deleted file mode 100644 index 7f33a1c88..000000000 Binary files a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Ret_07_5_08_07Args_eba2d57ab4ca242c26bb20abfcabfd26.png and /dev/null differ diff --git a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Type_01Class_1_1_5_18969de809d65f64025243166eb229a2.html b/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Type_01Class_1_1_5_18969de809d65f64025243166eb229a2.html deleted file mode 100644 index b919a8bcb..000000000 --- a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Type_01Class_1_1_5_18969de809d65f64025243166eb229a2.html +++ /dev/null @@ -1,84 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::internal::ReflectionHelper< std::integral_constant< Type Class::*, Member >, std::enable_if_t< std::is_member_object_pointer< Type Class::* >::value > > Member List
    -
    -
    - -

    This is the complete list of members for entt::internal::ReflectionHelper< std::integral_constant< Type Class::*, Member >, std::enable_if_t< std::is_member_object_pointer< Type Class::* >::value > >, including all inherited members.

    - - - - -
    readonly (defined in entt::internal::ReflectionHelper< std::integral_constant< Type Class::*, Member >, std::enable_if_t< std::is_member_object_pointer< Type Class::* >::value > >)entt::internal::ReflectionHelper< std::integral_constant< Type Class::*, Member >, std::enable_if_t< std::is_member_object_pointer< Type Class::* >::value > >static
    setter(void *instance, const MetaAny &any) (defined in entt::internal::ReflectionHelper< std::integral_constant< Type Class::*, Member >, std::enable_if_t< std::is_member_object_pointer< Type Class::* >::value > >)entt::internal::ReflectionHelper< std::integral_constant< Type Class::*, Member >, std::enable_if_t< std::is_member_object_pointer< Type Class::* >::value > >inlinestatic
    shared (defined in entt::internal::ReflectionHelper< std::integral_constant< Type Class::*, Member >, std::enable_if_t< std::is_member_object_pointer< Type Class::* >::value > >)entt::internal::ReflectionHelper< std::integral_constant< Type Class::*, Member >, std::enable_if_t< std::is_member_object_pointer< Type Class::* >::value > >static
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Type_01Class_1_1_5_a9c4ab474d7f81ef29f999b86b0cb449.html b/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Type_01Class_1_1_5_a9c4ab474d7f81ef29f999b86b0cb449.html deleted file mode 100644 index 474ab851c..000000000 --- a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Type_01Class_1_1_5_a9c4ab474d7f81ef29f999b86b0cb449.html +++ /dev/null @@ -1,107 +0,0 @@ - - - - - - - -EnTT: entt::internal::ReflectionHelper< std::integral_constant< Type Class::*, Member >, std::enable_if_t< std::is_member_object_pointer< Type Class::* >::value > > Struct Template Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Static Public Member Functions | -Static Public Attributes | -List of all members
    -
    -
    entt::internal::ReflectionHelper< std::integral_constant< Type Class::*, Member >, std::enable_if_t< std::is_member_object_pointer< Type Class::* >::value > > Struct Template Reference
    -
    -
    - - - - -

    -Static Public Member Functions

    -static void setter (void *instance, const MetaAny &any)
     
    - - - - - -

    -Static Public Attributes

    -static constexpr auto readonly = false
     
    -static constexpr auto shared = false
     
    -

    Detailed Description

    -

    template<typename Class, typename Type, Type Class::* Member>
    -struct entt::internal::ReflectionHelper< std::integral_constant< Type Class::*, Member >, std::enable_if_t< std::is_member_object_pointer< Type Class::* >::value > >

    - - -

    Definition at line 693 of file meta.hpp.

    -
    The documentation for this struct was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Type_01_5_00_01Data32bead6fb6a894c5b73d1813ddcab196.html b/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Type_01_5_00_01Data32bead6fb6a894c5b73d1813ddcab196.html deleted file mode 100644 index 948fcb01d..000000000 --- a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Type_01_5_00_01Data32bead6fb6a894c5b73d1813ddcab196.html +++ /dev/null @@ -1,84 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::internal::ReflectionHelper< std::integral_constant< Type *, Data >, std::enable_if_t<!std::is_function< Type >::value > > Member List
    -
    -
    - -

    This is the complete list of members for entt::internal::ReflectionHelper< std::integral_constant< Type *, Data >, std::enable_if_t<!std::is_function< Type >::value > >, including all inherited members.

    - - - - -
    readonly (defined in entt::internal::ReflectionHelper< std::integral_constant< Type *, Data >, std::enable_if_t<!std::is_function< Type >::value > >)entt::internal::ReflectionHelper< std::integral_constant< Type *, Data >, std::enable_if_t<!std::is_function< Type >::value > >static
    setter(void *, const MetaAny &any) (defined in entt::internal::ReflectionHelper< std::integral_constant< Type *, Data >, std::enable_if_t<!std::is_function< Type >::value > >)entt::internal::ReflectionHelper< std::integral_constant< Type *, Data >, std::enable_if_t<!std::is_function< Type >::value > >inlinestatic
    shared (defined in entt::internal::ReflectionHelper< std::integral_constant< Type *, Data >, std::enable_if_t<!std::is_function< Type >::value > >)entt::internal::ReflectionHelper< std::integral_constant< Type *, Data >, std::enable_if_t<!std::is_function< Type >::value > >static
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Type_01_5_00_01Datab92364bff7ad5f1dfeed3ce3d11c82e8.html b/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Type_01_5_00_01Datab92364bff7ad5f1dfeed3ce3d11c82e8.html deleted file mode 100644 index ebb4572a6..000000000 --- a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01Type_01_5_00_01Datab92364bff7ad5f1dfeed3ce3d11c82e8.html +++ /dev/null @@ -1,107 +0,0 @@ - - - - - - - -EnTT: entt::internal::ReflectionHelper< std::integral_constant< Type *, Data >, std::enable_if_t<!std::is_function< Type >::value > > Struct Template Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Static Public Member Functions | -Static Public Attributes | -List of all members
    -
    -
    entt::internal::ReflectionHelper< std::integral_constant< Type *, Data >, std::enable_if_t<!std::is_function< Type >::value > > Struct Template Reference
    -
    -
    - - - - -

    -Static Public Member Functions

    -static void setter (void *, const MetaAny &any)
     
    - - - - - -

    -Static Public Attributes

    -static constexpr auto readonly = false
     
    -static constexpr auto shared = true
     
    -

    Detailed Description

    -

    template<typename Type, Type * Data>
    -struct entt::internal::ReflectionHelper< std::integral_constant< Type *, Data >, std::enable_if_t<!std::is_function< Type >::value > >

    - - -

    Definition at line 761 of file meta.hpp.

    -
    The documentation for this struct was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01const_01Type_01Clas693684ab033d6c2c6a6373a3be8f3e53.html b/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01const_01Type_01Clas693684ab033d6c2c6a6373a3be8f3e53.html deleted file mode 100644 index 7c9d4c44c..000000000 --- a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01const_01Type_01Clas693684ab033d6c2c6a6373a3be8f3e53.html +++ /dev/null @@ -1,84 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::internal::ReflectionHelper< std::integral_constant< const Type Class::*, Member >, std::enable_if_t< std::is_member_object_pointer< const Type Class::* >::value > > Member List
    -
    -
    - -

    This is the complete list of members for entt::internal::ReflectionHelper< std::integral_constant< const Type Class::*, Member >, std::enable_if_t< std::is_member_object_pointer< const Type Class::* >::value > >, including all inherited members.

    - - - - -
    readonly (defined in entt::internal::ReflectionHelper< std::integral_constant< const Type Class::*, Member >, std::enable_if_t< std::is_member_object_pointer< const Type Class::* >::value > >)entt::internal::ReflectionHelper< std::integral_constant< const Type Class::*, Member >, std::enable_if_t< std::is_member_object_pointer< const Type Class::* >::value > >static
    setter(void *, const MetaAny &) (defined in entt::internal::ReflectionHelper< std::integral_constant< const Type Class::*, Member >, std::enable_if_t< std::is_member_object_pointer< const Type Class::* >::value > >)entt::internal::ReflectionHelper< std::integral_constant< const Type Class::*, Member >, std::enable_if_t< std::is_member_object_pointer< const Type Class::* >::value > >inlinestatic
    shared (defined in entt::internal::ReflectionHelper< std::integral_constant< const Type Class::*, Member >, std::enable_if_t< std::is_member_object_pointer< const Type Class::* >::value > >)entt::internal::ReflectionHelper< std::integral_constant< const Type Class::*, Member >, std::enable_if_t< std::is_member_object_pointer< const Type Class::* >::value > >static
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01const_01Type_01Clasc540f55fdf60969a618f02a1d390fabd.html b/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01const_01Type_01Clasc540f55fdf60969a618f02a1d390fabd.html deleted file mode 100644 index f30724d72..000000000 --- a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01const_01Type_01Clasc540f55fdf60969a618f02a1d390fabd.html +++ /dev/null @@ -1,107 +0,0 @@ - - - - - - - -EnTT: entt::internal::ReflectionHelper< std::integral_constant< const Type Class::*, Member >, std::enable_if_t< std::is_member_object_pointer< const Type Class::* >::value > > Struct Template Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Static Public Member Functions | -Static Public Attributes | -List of all members
    -
    -
    entt::internal::ReflectionHelper< std::integral_constant< const Type Class::*, Member >, std::enable_if_t< std::is_member_object_pointer< const Type Class::* >::value > > Struct Template Reference
    -
    -
    - - - - -

    -Static Public Member Functions

    -static void setter (void *, const MetaAny &)
     
    - - - - - -

    -Static Public Attributes

    -static constexpr auto readonly = true
     
    -static constexpr auto shared = false
     
    -

    Detailed Description

    -

    template<typename Class, typename Type, const Type Class::* Member>
    -struct entt::internal::ReflectionHelper< std::integral_constant< const Type Class::*, Member >, std::enable_if_t< std::is_member_object_pointer< const Type Class::* >::value > >

    - - -

    Definition at line 704 of file meta.hpp.

    -
    The documentation for this struct was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01const_01Type_01_5_05e1cabbf44c196359d3ef7436afd34e3.html b/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01const_01Type_01_5_05e1cabbf44c196359d3ef7436afd34e3.html deleted file mode 100644 index ac66e9542..000000000 --- a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01const_01Type_01_5_05e1cabbf44c196359d3ef7436afd34e3.html +++ /dev/null @@ -1,84 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::internal::ReflectionHelper< std::integral_constant< const Type *, Data >, std::enable_if_t<!std::is_function< const Type >::value > > Member List
    -
    -
    - -

    This is the complete list of members for entt::internal::ReflectionHelper< std::integral_constant< const Type *, Data >, std::enable_if_t<!std::is_function< const Type >::value > >, including all inherited members.

    - - - - -
    readonly (defined in entt::internal::ReflectionHelper< std::integral_constant< const Type *, Data >, std::enable_if_t<!std::is_function< const Type >::value > >)entt::internal::ReflectionHelper< std::integral_constant< const Type *, Data >, std::enable_if_t<!std::is_function< const Type >::value > >static
    setter(void *, const MetaAny &) (defined in entt::internal::ReflectionHelper< std::integral_constant< const Type *, Data >, std::enable_if_t<!std::is_function< const Type >::value > >)entt::internal::ReflectionHelper< std::integral_constant< const Type *, Data >, std::enable_if_t<!std::is_function< const Type >::value > >inlinestatic
    shared (defined in entt::internal::ReflectionHelper< std::integral_constant< const Type *, Data >, std::enable_if_t<!std::is_function< const Type >::value > >)entt::internal::ReflectionHelper< std::integral_constant< const Type *, Data >, std::enable_if_t<!std::is_function< const Type >::value > >static
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01const_01Type_01_5_0b9659031a38e282dc2052fd28bd776a7.html b/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01const_01Type_01_5_0b9659031a38e282dc2052fd28bd776a7.html deleted file mode 100644 index be8ec9f12..000000000 --- a/structentt_1_1internal_1_1ReflectionHelper_3_01std_1_1integral__constant_3_01const_01Type_01_5_0b9659031a38e282dc2052fd28bd776a7.html +++ /dev/null @@ -1,107 +0,0 @@ - - - - - - - -EnTT: entt::internal::ReflectionHelper< std::integral_constant< const Type *, Data >, std::enable_if_t<!std::is_function< const Type >::value > > Struct Template Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Static Public Member Functions | -Static Public Attributes | -List of all members
    -
    -
    entt::internal::ReflectionHelper< std::integral_constant< const Type *, Data >, std::enable_if_t<!std::is_function< const Type >::value > > Struct Template Reference
    -
    -
    - - - - -

    -Static Public Member Functions

    -static void setter (void *, const MetaAny &)
     
    - - - - - -

    -Static Public Attributes

    -static constexpr auto readonly = true
     
    -static constexpr auto shared = true
     
    -

    Detailed Description

    -

    template<typename Type, const Type * Data>
    -struct entt::internal::ReflectionHelper< std::integral_constant< const Type *, Data >, std::enable_if_t<!std::is_function< const Type >::value > >

    - - -

    Definition at line 772 of file meta.hpp.

    -
    The documentation for this struct was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1TypeHelper-members.html b/structentt_1_1internal_1_1TypeHelper-members.html deleted file mode 100644 index dc23f40b7..000000000 --- a/structentt_1_1internal_1_1TypeHelper-members.html +++ /dev/null @@ -1,82 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::internal::TypeHelper< Type > Member List
    -
    -
    - -

    This is the complete list of members for entt::internal::TypeHelper< Type >, including all inherited members.

    - - -
    destroy(void *instance) (defined in entt::internal::TypeHelper< Type >)entt::internal::TypeHelper< Type >inlinestatic
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1TypeHelper_3_01void_01_4-members.html b/structentt_1_1internal_1_1TypeHelper_3_01void_01_4-members.html deleted file mode 100644 index c346b16ab..000000000 --- a/structentt_1_1internal_1_1TypeHelper_3_01void_01_4-members.html +++ /dev/null @@ -1,82 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::internal::TypeHelper< void > Member List
    -
    -
    - -

    This is the complete list of members for entt::internal::TypeHelper< void >, including all inherited members.

    - - -
    destroy(void *) (defined in entt::internal::TypeHelper< void >)entt::internal::TypeHelper< void >inlinestatic
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1Utils-members.html b/structentt_1_1internal_1_1Utils-members.html deleted file mode 100644 index 755bc882a..000000000 --- a/structentt_1_1internal_1_1Utils-members.html +++ /dev/null @@ -1,84 +0,0 @@ - - - - - - - -EnTT: Member List - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    entt::internal::Utils Member List
    -
    -
    - -

    This is the complete list of members for entt::internal::Utils, including all inherited members.

    - - - - -
    iterate(Op op, const Node *curr) ENTT_NOEXCEPT (defined in entt::internal::Utils)entt::internal::Utilsinlinestatic
    meta(HashedString name, const Node *curr) (defined in entt::internal::Utils)entt::internal::Utilsinlinestatic
    property(Key &&key, const MetaPropNode *curr) (defined in entt::internal::Utils)entt::internal::Utilsinlinestatic
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1internal_1_1Utils.html b/structentt_1_1internal_1_1Utils.html deleted file mode 100644 index 86c590db4..000000000 --- a/structentt_1_1internal_1_1Utils.html +++ /dev/null @@ -1,103 +0,0 @@ - - - - - - - -EnTT: entt::internal::Utils Struct Reference - - - - - - - - - -
    -
    - - - - - - -
    -
    EnTT -  2.7.2 -
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -Static Public Member Functions | -List of all members
    -
    -
    entt::internal::Utils Struct Reference
    -
    -
    - - - - - - - - - - - -

    -Static Public Member Functions

    -template<typename Op , typename Node >
    static auto iterate (Op op, const Node *curr) ENTT_NOEXCEPT
     
    -template<typename Key >
    static MetaProp * property (Key &&key, const MetaPropNode *curr)
     
    -template<typename Node >
    static auto meta (HashedString name, const Node *curr)
     
    -

    Detailed Description

    -
    -

    Definition at line 230 of file meta.hpp.

    -
    The documentation for this struct was generated from the following file: -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/structentt_1_1is__named__type.html b/structentt_1_1is__named__type.html new file mode 100644 index 000000000..e5967bb6a --- /dev/null +++ b/structentt_1_1is__named__type.html @@ -0,0 +1,103 @@ + + + + + + + +EnTT: entt::is_named_type< typename, typename > Struct Template Reference + + + + + + + + + +
    +
    + + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +
    entt::is_named_type< typename, typename > Struct Template Reference
    +
    +
    + +

    Provides the member constant value to true if a given type has a name. In all other cases, value is false. + More...

    + +

    #include <type_traits.hpp>

    +
    +Inheritance diagram for entt::is_named_type< typename, typename >:
    +
    +
    Inheritance graph
    +
    [legend]
    +
    +Collaboration diagram for entt::is_named_type< typename, typename >:
    +
    +
    Collaboration graph
    +
    [legend]
    +

    Detailed Description

    +

    template<typename, typename = std::void_t<>>
    +struct entt::is_named_type< typename, typename >

    + +

    Provides the member constant value to true if a given type has a name. In all other cases, value is false.

    + +

    Definition at line 125 of file type_traits.hpp.

    +
    The documentation for this struct was generated from the following file: +
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/structentt_1_1is__named__type_3_01Type_00_01std_1_1void__t_3_01named__type__traits__t_3_01std_1_0c6058b8ba47cc9c6693d18c8fb48d92.map b/structentt_1_1is__named__type_3_01Type_00_01std_1_1void__t_3_01named__type__traits__t_3_01std_1_0c6058b8ba47cc9c6693d18c8fb48d92.map new file mode 100644 index 000000000..f4836835a --- /dev/null +++ b/structentt_1_1is__named__type_3_01Type_00_01std_1_1void__t_3_01named__type__traits__t_3_01std_1_0c6058b8ba47cc9c6693d18c8fb48d92.map @@ -0,0 +1,2 @@ + + diff --git a/structentt_1_1is__named__type_3_01Type_00_01std_1_1void__t_3_01named__type__traits__t_3_01std_1_0c6058b8ba47cc9c6693d18c8fb48d92.md5 b/structentt_1_1is__named__type_3_01Type_00_01std_1_1void__t_3_01named__type__traits__t_3_01std_1_0c6058b8ba47cc9c6693d18c8fb48d92.md5 new file mode 100644 index 000000000..13a24bcad --- /dev/null +++ b/structentt_1_1is__named__type_3_01Type_00_01std_1_1void__t_3_01named__type__traits__t_3_01std_1_0c6058b8ba47cc9c6693d18c8fb48d92.md5 @@ -0,0 +1 @@ +fa3c3f23b54068a05c7aabe3cb8b332d \ No newline at end of file diff --git a/structentt_1_1is__named__type_3_01Type_00_01std_1_1void__t_3_01named__type__traits__t_3_01std_1_0c6058b8ba47cc9c6693d18c8fb48d92.png b/structentt_1_1is__named__type_3_01Type_00_01std_1_1void__t_3_01named__type__traits__t_3_01std_1_0c6058b8ba47cc9c6693d18c8fb48d92.png new file mode 100644 index 000000000..a8f87dbbc Binary files /dev/null and b/structentt_1_1is__named__type_3_01Type_00_01std_1_1void__t_3_01named__type__traits__t_3_01std_1_0c6058b8ba47cc9c6693d18c8fb48d92.png differ diff --git a/structentt_1_1is__named__type_3_01Type_00_01std_1_1void__t_3_01named__type__traits__t_3_01std_1_268fa5a871b2de95e24d77c0786df19e.html b/structentt_1_1is__named__type_3_01Type_00_01std_1_1void__t_3_01named__type__traits__t_3_01std_1_268fa5a871b2de95e24d77c0786df19e.html new file mode 100644 index 000000000..ebc442fcd --- /dev/null +++ b/structentt_1_1is__named__type_3_01Type_00_01std_1_1void__t_3_01named__type__traits__t_3_01std_1_268fa5a871b2de95e24d77c0786df19e.html @@ -0,0 +1,109 @@ + + + + + + + +EnTT: entt::is_named_type< Type, std::void_t< named_type_traits_t< std::decay_t< Type > > > > Struct Template Reference + + + + + + + + + +
    +
    + + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +
    entt::is_named_type< Type, std::void_t< named_type_traits_t< std::decay_t< Type > > > > Struct Template Reference
    +
    +
    + +

    Provides the member constant value to true if a given type has a name. In all other cases, value is false. + More...

    + +

    #include <type_traits.hpp>

    +
    +Inheritance diagram for entt::is_named_type< Type, std::void_t< named_type_traits_t< std::decay_t< Type > > > >:
    +
    +
    Inheritance graph
    +
    [legend]
    +
    +Collaboration diagram for entt::is_named_type< Type, std::void_t< named_type_traits_t< std::decay_t< Type > > > >:
    +
    +
    Collaboration graph
    +
    [legend]
    +

    Detailed Description

    +

    template<typename Type>
    +struct entt::is_named_type< Type, std::void_t< named_type_traits_t< std::decay_t< Type > > > >

    + +

    Provides the member constant value to true if a given type has a name. In all other cases, value is false.

    +
    Template Parameters
    + + +
    TypePotentially named type.
    +
    +
    + +

    Definition at line 134 of file type_traits.hpp.

    +
    The documentation for this struct was generated from the following file: +
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/structentt_1_1is__named__type_3_01Type_00_01std_1_1void__t_3_01named__type__traits__t_3_01std_1_9aa8d80f3ceacce258d85ba16cdb7265.map b/structentt_1_1is__named__type_3_01Type_00_01std_1_1void__t_3_01named__type__traits__t_3_01std_1_9aa8d80f3ceacce258d85ba16cdb7265.map new file mode 100644 index 000000000..f4836835a --- /dev/null +++ b/structentt_1_1is__named__type_3_01Type_00_01std_1_1void__t_3_01named__type__traits__t_3_01std_1_9aa8d80f3ceacce258d85ba16cdb7265.map @@ -0,0 +1,2 @@ + + diff --git a/structentt_1_1is__named__type_3_01Type_00_01std_1_1void__t_3_01named__type__traits__t_3_01std_1_9aa8d80f3ceacce258d85ba16cdb7265.md5 b/structentt_1_1is__named__type_3_01Type_00_01std_1_1void__t_3_01named__type__traits__t_3_01std_1_9aa8d80f3ceacce258d85ba16cdb7265.md5 new file mode 100644 index 000000000..d8ec228a9 --- /dev/null +++ b/structentt_1_1is__named__type_3_01Type_00_01std_1_1void__t_3_01named__type__traits__t_3_01std_1_9aa8d80f3ceacce258d85ba16cdb7265.md5 @@ -0,0 +1 @@ +3d98da1b2b872cbd32659ce5a804df34 \ No newline at end of file diff --git a/structentt_1_1is__named__type_3_01Type_00_01std_1_1void__t_3_01named__type__traits__t_3_01std_1_9aa8d80f3ceacce258d85ba16cdb7265.png b/structentt_1_1is__named__type_3_01Type_00_01std_1_1void__t_3_01named__type__traits__t_3_01std_1_9aa8d80f3ceacce258d85ba16cdb7265.png new file mode 100644 index 000000000..a8f87dbbc Binary files /dev/null and b/structentt_1_1is__named__type_3_01Type_00_01std_1_1void__t_3_01named__type__traits__t_3_01std_1_9aa8d80f3ceacce258d85ba16cdb7265.png differ diff --git a/structentt_1_1is__named__type__coll__graph.map b/structentt_1_1is__named__type__coll__graph.map new file mode 100644 index 000000000..02eae45f6 --- /dev/null +++ b/structentt_1_1is__named__type__coll__graph.map @@ -0,0 +1,2 @@ + + diff --git a/structentt_1_1is__named__type__coll__graph.md5 b/structentt_1_1is__named__type__coll__graph.md5 new file mode 100644 index 000000000..826a51d58 --- /dev/null +++ b/structentt_1_1is__named__type__coll__graph.md5 @@ -0,0 +1 @@ +b2a5caf294eecd0e32ddd92298ec2f0a \ No newline at end of file diff --git a/structentt_1_1is__named__type__coll__graph.png b/structentt_1_1is__named__type__coll__graph.png new file mode 100644 index 000000000..715374733 Binary files /dev/null and b/structentt_1_1is__named__type__coll__graph.png differ diff --git a/structentt_1_1is__named__type__inherit__graph.map b/structentt_1_1is__named__type__inherit__graph.map new file mode 100644 index 000000000..02eae45f6 --- /dev/null +++ b/structentt_1_1is__named__type__inherit__graph.map @@ -0,0 +1,2 @@ + + diff --git a/structentt_1_1is__named__type__inherit__graph.md5 b/structentt_1_1is__named__type__inherit__graph.md5 new file mode 100644 index 000000000..4414fb024 --- /dev/null +++ b/structentt_1_1is__named__type__inherit__graph.md5 @@ -0,0 +1 @@ +8c204781b58f75eaf165aba4353c398f \ No newline at end of file diff --git a/structentt_1_1is__named__type__inherit__graph.png b/structentt_1_1is__named__type__inherit__graph.png new file mode 100644 index 000000000..715374733 Binary files /dev/null and b/structentt_1_1is__named__type__inherit__graph.png differ diff --git a/structentt_1_1Monostate-members.html b/structentt_1_1monostate-members.html similarity index 83% rename from structentt_1_1Monostate-members.html rename to structentt_1_1monostate-members.html index 36c23b3b4..a1175b7cb 100644 --- a/structentt_1_1Monostate-members.html +++ b/structentt_1_1monostate-members.html @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    - - + +
    operator Type() const ENTT_NOEXCEPTentt::Monostate< hash_type >inline
    operator=(Type val) const ENTT_NOEXCEPTentt::Monostate< hash_type >inline
    operator Type() const ENTT_NOEXCEPTentt::monostate< hash_type >inline
    operator=(Type val) const ENTT_NOEXCEPTentt::monostate< hash_type >inline
    diff --git a/structentt_1_1Monostate.html b/structentt_1_1monostate.html similarity index 76% rename from structentt_1_1Monostate.html rename to structentt_1_1monostate.html index dde3b4113..6d2571fb0 100644 --- a/structentt_1_1Monostate.html +++ b/structentt_1_1monostate.html @@ -5,7 +5,7 @@ -EnTT: entt::Monostate< hash_type > Struct Template Reference +EnTT: entt::monostate< hash_type > Struct Template Reference @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    - - - - - - - - + + + + + + + +

    Public Member Functions

    template<typename Type >
    void operator= (Type val) const ENTT_NOEXCEPT
     Assigns a value of a specific type to a given key. More...
     
    template<typename Type >
     operator Type () const ENTT_NOEXCEPT
     Gets a value of a specific type for a given key. More...
     
    template<typename Type >
    void operator= (Type val) const ENTT_NOEXCEPT
     Assigns a value of a specific type to a given key. More...
     
    template<typename Type >
     operator Type () const ENTT_NOEXCEPT
     Gets a value of a specific type for a given key. More...
     

    Detailed Description

    -

    template<HashedString::hash_type>
    -struct entt::Monostate< hash_type >

    +

    template<hashed_string::hash_type>
    +struct entt::monostate< hash_type >

    Minimal implementation of the monostate pattern.

    A minimal, yet complete configuration system built on top of the monostate pattern. Thread safe by design, it works only with basic types like ints or bools.
    Multiple types and therefore more than one value can be associated with a single key. Because of this, users must pay attention to use the same type both during an assignment and when they try to read back their data. Otherwise, they can incur in unexpected results.

    -

    Definition at line 26 of file monostate.hpp.

    +

    Definition at line 25 of file monostate.hpp.

    Member Function Documentation

    - -

    ◆ operator Type()

    + +

    ◆ operator Type()

    -template<HashedString::hash_type >
    +template<hashed_string::hash_type >
    template<typename Type >
    @@ -111,7 +111,7 @@ template<typename Type >
    - + @@ -133,17 +133,17 @@ template<typename Type >
    Returns
    Stored value, if any.
    -

    Definition at line 43 of file monostate.hpp.

    +

    Definition at line 42 of file monostate.hpp.

    - -

    ◆ operator=()

    + +

    ◆ operator=()

    -template<HashedString::hash_type >
    +template<hashed_string::hash_type >
    template<typename Type >
    entt::Monostate< hash_type >::operator Type entt::monostate< hash_type >::operator Type ( ) const
    @@ -151,7 +151,7 @@ template<typename Type > @@ -59,7 +59,7 @@ $(function() {
    @@ -67,60 +67,60 @@ $(function() { Public Types | Public Member Functions | Static Public Member Functions | -List of all members
    +List of all members
    -
    entt::ServiceLocator< Service > Struct Template Referencefinal
    +
    entt::service_locator< Service > Struct Template Reference

    Service locator, nothing more. - More...

    + More...

    #include <locator.hpp>

    - + @@ -179,7 +179,7 @@ template<typename Type > -

    Definition at line 33 of file monostate.hpp.

    +

    Definition at line 32 of file monostate.hpp.

    diff --git a/structentt_1_1raw__t.html b/structentt_1_1named__type__traits.html similarity index 72% rename from structentt_1_1raw__t.html rename to structentt_1_1named__type__traits.html index d54447221..65c5669c3 100644 --- a/structentt_1_1raw__t.html +++ b/structentt_1_1named__type__traits.html @@ -5,7 +5,7 @@ -EnTT: entt::raw_t Struct Reference +EnTT: entt::named_type_traits< typename > Struct Template Reference @@ -22,7 +22,7 @@ @@ -59,25 +59,28 @@ $(function() {
    -
    entt::raw_t Struct Referencefinal
    +
    entt::named_type_traits< typename > Struct Template Reference
    -

    Raw view type used to disambiguate overloads. - More...

    +

    Traits class used mainly to push things across boundaries. + More...

    -

    #include <utility.hpp>

    +

    #include <type_traits.hpp>

    Detailed Description

    -

    Raw view type used to disambiguate overloads.

    +

    template<typename>
    +struct entt::named_type_traits< typename >

    -

    Definition at line 17 of file utility.hpp.

    +

    Traits class used mainly to push things across boundaries.

    + +

    Definition at line 99 of file type_traits.hpp.

    The documentation for this struct was generated from the following file:
    diff --git a/structentt_1_1named__type__traits_3_01const_01Type_01_4.html b/structentt_1_1named__type__traits_3_01const_01Type_01_4.html new file mode 100644 index 000000000..4201fb1c6 --- /dev/null +++ b/structentt_1_1named__type__traits_3_01const_01Type_01_4.html @@ -0,0 +1,115 @@ + + + + + + + +EnTT: entt::named_type_traits< const Type > Struct Template Reference + + + + + + + + + +
    +
    +
    void entt::Monostate< hash_type >::operator= void entt::monostate< hash_type >::operator= ( Type  val)
    EnTT -  2.7.3 +  3.0.0
    + + + + + +
    +
    EnTT +  3.0.0 +
    +
    + + + + + + + + + +
    +
    + + +
    + +
    + + + +
    +
    +
    entt::named_type_traits< const Type > Struct Template Reference
    +
    +
    + +

    Specialization used to get rid of constness. + More...

    + +

    #include <type_traits.hpp>

    +
    +Inheritance diagram for entt::named_type_traits< const Type >:
    +
    +
    Inheritance graph
    + + + +
    [legend]
    +
    +Collaboration diagram for entt::named_type_traits< const Type >:
    +
    +
    Collaboration graph
    + + + +
    [legend]
    +

    Detailed Description

    +

    template<typename Type>
    +struct entt::named_type_traits< const Type >

    + +

    Specialization used to get rid of constness.

    +
    Template Parameters
    + + +
    TypeNamed type.
    +
    +
    + +

    Definition at line 107 of file type_traits.hpp.

    +
    The documentation for this struct was generated from the following file: +
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/structentt_1_1named__type__traits_3_01const_01Type_01_4__coll__graph.map b/structentt_1_1named__type__traits_3_01const_01Type_01_4__coll__graph.map new file mode 100644 index 000000000..68e66aa2f --- /dev/null +++ b/structentt_1_1named__type__traits_3_01const_01Type_01_4__coll__graph.map @@ -0,0 +1,3 @@ + + + diff --git a/structentt_1_1named__type__traits_3_01const_01Type_01_4__coll__graph.md5 b/structentt_1_1named__type__traits_3_01const_01Type_01_4__coll__graph.md5 new file mode 100644 index 000000000..7d6fc6a65 --- /dev/null +++ b/structentt_1_1named__type__traits_3_01const_01Type_01_4__coll__graph.md5 @@ -0,0 +1 @@ +af406f619646e2f2b7f5ca50a3ab5393 \ No newline at end of file diff --git a/structentt_1_1named__type__traits_3_01const_01Type_01_4__coll__graph.png b/structentt_1_1named__type__traits_3_01const_01Type_01_4__coll__graph.png new file mode 100644 index 000000000..32b2da69c Binary files /dev/null and b/structentt_1_1named__type__traits_3_01const_01Type_01_4__coll__graph.png differ diff --git a/structentt_1_1named__type__traits_3_01const_01Type_01_4__inherit__graph.map b/structentt_1_1named__type__traits_3_01const_01Type_01_4__inherit__graph.map new file mode 100644 index 000000000..68e66aa2f --- /dev/null +++ b/structentt_1_1named__type__traits_3_01const_01Type_01_4__inherit__graph.map @@ -0,0 +1,3 @@ + + + diff --git a/structentt_1_1named__type__traits_3_01const_01Type_01_4__inherit__graph.md5 b/structentt_1_1named__type__traits_3_01const_01Type_01_4__inherit__graph.md5 new file mode 100644 index 000000000..c086f65c5 --- /dev/null +++ b/structentt_1_1named__type__traits_3_01const_01Type_01_4__inherit__graph.md5 @@ -0,0 +1 @@ +c1b62f210feb840c8882c017c960512b \ No newline at end of file diff --git a/structentt_1_1named__type__traits_3_01const_01Type_01_4__inherit__graph.png b/structentt_1_1named__type__traits_3_01const_01Type_01_4__inherit__graph.png new file mode 100644 index 000000000..32b2da69c Binary files /dev/null and b/structentt_1_1named__type__traits_3_01const_01Type_01_4__inherit__graph.png differ diff --git a/structentt_1_1process__adaptor-members.html b/structentt_1_1process__adaptor-members.html new file mode 100644 index 000000000..37d0afbc5 --- /dev/null +++ b/structentt_1_1process__adaptor-members.html @@ -0,0 +1,95 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
    +
    + + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +
    entt::process_adaptor< Func, Delta > Member List
    +
    +
    + +

    This is the complete list of members for entt::process_adaptor< Func, Delta >, including all inherited members.

    + + + + + + + + + + + + + + + +
    abort(const bool immediately=false) ENTT_NOEXCEPTentt::process< process_adaptor< Func, Delta >, Delta >inline
    alive() const ENTT_NOEXCEPTentt::process< process_adaptor< Func, Delta >, Delta >inline
    dead() const ENTT_NOEXCEPTentt::process< process_adaptor< Func, Delta >, Delta >inline
    delta_type typedefentt::process< process_adaptor< Func, Delta >, Delta >
    fail() ENTT_NOEXCEPTentt::process< process_adaptor< Func, Delta >, Delta >inlineprotected
    pause() ENTT_NOEXCEPTentt::process< process_adaptor< Func, Delta >, Delta >inlineprotected
    paused() const ENTT_NOEXCEPTentt::process< process_adaptor< Func, Delta >, Delta >inline
    process_adaptor(Args &&... args)entt::process_adaptor< Func, Delta >inline
    rejected() const ENTT_NOEXCEPTentt::process< process_adaptor< Func, Delta >, Delta >inline
    succeed() ENTT_NOEXCEPTentt::process< process_adaptor< Func, Delta >, Delta >inlineprotected
    tick(const Delta delta, void *data=nullptr)entt::process< process_adaptor< Func, Delta >, Delta >inline
    unpause() ENTT_NOEXCEPTentt::process< process_adaptor< Func, Delta >, Delta >inlineprotected
    update(const Delta delta, void *data)entt::process_adaptor< Func, Delta >inline
    ~process() ENTT_NOEXCEPTentt::process< process_adaptor< Func, Delta >, Delta >inlinevirtual
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/structentt_1_1process__adaptor.html b/structentt_1_1process__adaptor.html new file mode 100644 index 000000000..2fcb1bd70 --- /dev/null +++ b/structentt_1_1process__adaptor.html @@ -0,0 +1,286 @@ + + + + + + + +EnTT: entt::process_adaptor< Func, Delta > Struct Template Reference + + + + + + + + + +
    +
    + + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +Public Member Functions | +List of all members
    +
    +
    entt::process_adaptor< Func, Delta > Struct Template Reference
    +
    +
    + +

    Adaptor for lambdas and functors to turn them into processes. + More...

    + +

    #include <process.hpp>

    +
    +Inheritance diagram for entt::process_adaptor< Func, Delta >:
    +
    +
    Inheritance graph
    + + + +
    [legend]
    +
    +Collaboration diagram for entt::process_adaptor< Func, Delta >:
    +
    +
    Collaboration graph
    + + + +
    [legend]
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    +Public Member Functions

    template<typename... Args>
     process_adaptor (Args &&... args)
     Constructs a process adaptor from a lambda or a functor. More...
     
    void update (const Delta delta, void *data)
     Updates a process and its internal state if required. More...
     
    - Public Member Functions inherited from entt::process< process_adaptor< Func, Delta >, Delta >
    void tick (const Delta delta, void *data=nullptr)
     Updates a process and its internal state if required. More...
     
    +virtual ~process () ENTT_NOEXCEPT
     Default destructor.
     
    void abort (const bool immediately=false) ENTT_NOEXCEPT
     Aborts a process if it's still alive. More...
     
    bool alive () const ENTT_NOEXCEPT
     Returns true if a process is either running or paused. More...
     
    bool dead () const ENTT_NOEXCEPT
     Returns true if a process is already terminated. More...
     
    bool paused () const ENTT_NOEXCEPT
     Returns true if a process is currently paused. More...
     
    bool rejected () const ENTT_NOEXCEPT
     Returns true if a process terminated with errors. More...
     
    + + + + + + + + + + + + + + + + + + +

    +Additional Inherited Members

    - Public Types inherited from entt::process< process_adaptor< Func, Delta >, Delta >
    +using delta_type = Delta
     Type used to provide elapsed time.
     
    - Protected Member Functions inherited from entt::process< process_adaptor< Func, Delta >, Delta >
    void succeed () ENTT_NOEXCEPT
     Terminates a process with success if it's still alive. More...
     
    void fail () ENTT_NOEXCEPT
     Terminates a process with errors if it's still alive. More...
     
    void pause () ENTT_NOEXCEPT
     Stops a process if it's in a running state. More...
     
    void unpause () ENTT_NOEXCEPT
     Restarts a process if it's paused. More...
     
    +

    Detailed Description

    +

    template<typename Func, typename Delta>
    +struct entt::process_adaptor< Func, Delta >

    + +

    Adaptor for lambdas and functors to turn them into processes.

    +

    Lambdas and functors can't be used directly with a scheduler for they are not properly defined processes with managed life cycles.
    + This class helps in filling the gap and turning lambdas and functors into full featured processes usable by a scheduler.

    +

    The signature of the function call operator should be equivalent to the following:

    +
    void(Delta delta, void *data, auto succeed, auto fail);

    Where:

    +
      +
    • delta is the elapsed time.
      • +
    • data is an opaque pointer to user data if any, nullptr otherwise.
      • +
    • succeed is a function to call when a process terminates with success.
      • +
    • fail is a function to call when a process terminates with errors.
      • +
    +

    The signature of the function call operator of both succeed and fail is equivalent to the following:

    +
    void();

    Usually users shouldn't worry about creating adaptors. A scheduler will create them internally each and avery time a lambda or a functor is used as a process.

    +
    See also
    process
    +
    +scheduler
    +
    Template Parameters
    + + + +
    FuncActual type of process.
    DeltaType to use to provide elapsed time.
    +
    +
    + +

    Definition at line 315 of file process.hpp.

    +

    Constructor & Destructor Documentation

    + +

    ◆ process_adaptor()

    + +
    +
    +
    +template<typename Func, typename Delta>
    +
    +template<typename... Args>
    + + + + + +
    + + + + + + + + +
    entt::process_adaptor< Func, Delta >::process_adaptor (Args &&... args)
    +     		+inline
    +
    + +

    Constructs a process adaptor from a lambda or a functor.

    +
    Template Parameters
    + + +
    ArgsTypes of arguments to use to initialize the actual process.
    +
    +
    +
    Parameters
    + + +
    argsParameters to use to initialize the actual process.
    +
    +
    + +

    Definition at line 322 of file process.hpp.

    + +
    +
    +

    Member Function Documentation

    + +

    ◆ update()

    + +
    +
    +
    +template<typename Func, typename Delta>
    + + + + + +
    + + + + + + + + + + + + + + + + + + +
    void entt::process_adaptor< Func, Delta >::update (const Delta delta,
    void * data 
    )
    +     		+inline
    +
    + +

    Updates a process and its internal state if required.

    +
    Parameters
    + + + +
    deltaElapsed time.
    dataOptional data.
    +
    +
    + +

    Definition at line 331 of file process.hpp.

    + +
    +
    +
    The documentation for this struct was generated from the following file: +
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/structentt_1_1process__adaptor__coll__graph.map b/structentt_1_1process__adaptor__coll__graph.map new file mode 100644 index 000000000..c144d60e1 --- /dev/null +++ b/structentt_1_1process__adaptor__coll__graph.map @@ -0,0 +1,3 @@ + + + diff --git a/structentt_1_1process__adaptor__coll__graph.md5 b/structentt_1_1process__adaptor__coll__graph.md5 new file mode 100644 index 000000000..13d452590 --- /dev/null +++ b/structentt_1_1process__adaptor__coll__graph.md5 @@ -0,0 +1 @@ +be60efd3d08498098f5627e9d88e9562 \ No newline at end of file diff --git a/structentt_1_1process__adaptor__coll__graph.png b/structentt_1_1process__adaptor__coll__graph.png new file mode 100644 index 000000000..575af8e68 Binary files /dev/null and b/structentt_1_1process__adaptor__coll__graph.png differ diff --git a/structentt_1_1process__adaptor__inherit__graph.map b/structentt_1_1process__adaptor__inherit__graph.map new file mode 100644 index 000000000..c144d60e1 --- /dev/null +++ b/structentt_1_1process__adaptor__inherit__graph.map @@ -0,0 +1,3 @@ + + + diff --git a/structentt_1_1process__adaptor__inherit__graph.md5 b/structentt_1_1process__adaptor__inherit__graph.md5 new file mode 100644 index 000000000..fc2c324f3 --- /dev/null +++ b/structentt_1_1process__adaptor__inherit__graph.md5 @@ -0,0 +1 @@ +d4249c5b7ebfd4467b94d2c46e1d2054 \ No newline at end of file diff --git a/structentt_1_1process__adaptor__inherit__graph.png b/structentt_1_1process__adaptor__inherit__graph.png new file mode 100644 index 000000000..575af8e68 Binary files /dev/null and b/structentt_1_1process__adaptor__inherit__graph.png differ diff --git a/structentt_1_1service__locator-members.html b/structentt_1_1service__locator-members.html new file mode 100644 index 000000000..98bcada13 --- /dev/null +++ b/structentt_1_1service__locator-members.html @@ -0,0 +1,90 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
    +
    + + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +
    entt::service_locator< Service > Member List
    +
    +
    + +

    This is the complete list of members for entt::service_locator< Service >, including all inherited members.

    + + + + + + + + + + +
    empty() ENTT_NOEXCEPTentt::service_locator< Service >inlinestatic
    get() ENTT_NOEXCEPTentt::service_locator< Service >inlinestatic
    ref() ENTT_NOEXCEPTentt::service_locator< Service >inlinestatic
    reset()entt::service_locator< Service >inlinestatic
    service_locator()=deleteentt::service_locator< Service >
    service_type typedefentt::service_locator< Service >
    set(Args &&... args)entt::service_locator< Service >inlinestatic
    set(std::shared_ptr< Service > ptr)entt::service_locator< Service >inlinestatic
    ~service_locator()=deleteentt::service_locator< Service >
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/structentt_1_1ServiceLocator.html b/structentt_1_1service__locator.html similarity index 67% rename from structentt_1_1ServiceLocator.html rename to structentt_1_1service__locator.html index fb4d3f214..c85555cb3 100644 --- a/structentt_1_1ServiceLocator.html +++ b/structentt_1_1service__locator.html @@ -5,7 +5,7 @@ -EnTT: entt::ServiceLocator< Service > Struct Template Reference +EnTT: entt::service_locator< Service > Struct Template Reference @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    - - - + + +

    Public Types

    -using service_type = Service
     Type of service offered.
     
    +using service_type = Service
     Type of service offered.
     
    - - - - - - + + + + + +

    Public Member Functions

    - ServiceLocator ()=delete
     Default constructor, deleted on purpose.
     
    - ~ServiceLocator ()=delete
     Default destructor, deleted on purpose.
     
    + service_locator ()=delete
     Default constructor, deleted on purpose.
     
    + ~service_locator ()=delete
     Default destructor, deleted on purpose.
     
    - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + +

    Static Public Member Functions

    static bool empty () ENTT_NOEXCEPT
     Tests if a valid service implementation is set. More...
     
    static std::weak_ptr< Service > get () ENTT_NOEXCEPT
     Returns a weak pointer to a service implementation, if any. More...
     
    static Service & ref () ENTT_NOEXCEPT
     Returns a weak reference to a service implementation, if any. More...
     
    template<typename Impl = Service, typename... Args>
    static void set (Args &&... args)
     Sets or replaces a service. More...
     
    static void set (std::shared_ptr< Service > ptr)
     Sets or replaces a service. More...
     
    static void reset ()
     Resets a service. More...
     
    static bool empty () ENTT_NOEXCEPT
     Tests if a valid service implementation is set. More...
     
    static std::weak_ptr< Service > get () ENTT_NOEXCEPT
     Returns a weak pointer to a service implementation, if any. More...
     
    static Service & ref () ENTT_NOEXCEPT
     Returns a weak reference to a service implementation, if any. More...
     
    template<typename Impl = Service, typename... Args>
    static void set (Args &&... args)
     Sets or replaces a service. More...
     
    static void set (std::shared_ptr< Service > ptr)
     Sets or replaces a service. More...
     
    static void reset ()
     Resets a service. More...
     

    Detailed Description

    template<typename Service>
    -struct entt::ServiceLocator< Service >

    +struct entt::service_locator< Service >

    Service locator, nothing more.

    A service locator can be used to do what it promises: locate services.
    @@ -132,10 +132,10 @@ struct entt::ServiceLocator< Service > -

    Definition at line 26 of file locator.hpp.

    +

    Definition at line 25 of file locator.hpp.

    Member Function Documentation

    - -

    ◆ empty()

    + +

    ◆ empty()

    @@ -146,7 +146,7 @@ template<typename Service>
    		- + @@ -162,12 +162,12 @@ template<typename Service>

    Tests if a valid service implementation is set.

    Returns
    True if the service is set, false otherwise.
    -

    Definition at line 39 of file locator.hpp.

    +

    Definition at line 38 of file locator.hpp.

    - -

    ◆ get()

    + +

    ◆ get()

    @@ -178,7 +178,7 @@ template<typename Service>
    static bool entt::ServiceLocator< Service >::empty static bool entt::service_locator< Service >::empty ( ) - + @@ -195,12 +195,12 @@ template<typename Service>

    Clients of a service shouldn't retain references to it. The recommended way is to retrieve the service implementation currently set each and every time the need of using it arises. Otherwise users can incur in unexpected behaviors.

    Returns
    A reference to the service implementation currently set, if any.
    -

    Definition at line 53 of file locator.hpp.

    +

    Definition at line 52 of file locator.hpp.

    - -

    ◆ ref()

    + +

    ◆ ref()

    @@ -211,7 +211,7 @@ template<typename Service>
    @@ -59,7 +59,7 @@ $(function() {
    @@ -67,10 +67,8 @@ $(function() {
    utility.hpp
    -
    1 #ifndef ENTT_ENTITY_UTILITY_HPP
    2 #define ENTT_ENTITY_UTILITY_HPP
    3 
    4 
    5 namespace entt {
    6 
    7 
    9 struct tag_t final {};
    10 
    11 
    13 struct persistent_t final {};
    14 
    15 
    17 struct raw_t final {};
    18 
    19 
    20 }
    21 
    22 
    23 #endif // ENTT_ENTITY_UTILITY_HPP
    entt::raw_t
    Raw view type used to disambiguate overloads.
    Definition: utility.hpp:17
    -
    entt::persistent_t
    Persistent view type used to disambiguate overloads.
    Definition: utility.hpp:13
    -
    entt
    EnTT default namespace.
    Definition: algorithm.hpp:10
    -
    entt::tag_t
    Tag class type used to disambiguate overloads.
    Definition: utility.hpp:9
    +
    1 #ifndef ENTT_CORE_UTILITY_HPP
    2 #define ENTT_CORE_UTILITY_HPP
    3 
    4 
    5 namespace entt {
    6 
    7 
    15 template<typename Type, typename Class>
    16 constexpr auto overload(Type Class:: *member) { return member; }
    17 
    18 
    25 template<typename Type>
    26 constexpr auto overload(Type *func) { return func; }
    27 
    28 
    29 }
    30 
    31 
    32 #endif // ENTT_CORE_UTILITY_HPP
    entt
    EnTT default namespace.
    Definition: algorithm.hpp:10
    +
    entt::overload
    constexpr auto overload(Type Class::*member)
    Constant utility to disambiguate overloaded member functions.
    Definition: utility.hpp:16
    diff --git a/classentt_1_1Attachee.html b/version_8h_source.html similarity index 57% rename from classentt_1_1Attachee.html rename to version_8h_source.html index 95b8ffe61..36b3b95cb 100644 --- a/classentt_1_1Attachee.html +++ b/version_8h_source.html @@ -5,7 +5,7 @@ -EnTT: entt::Attachee<... > Class Template Reference +EnTT: src/entt/config/version.h Source File @@ -22,7 +22,7 @@
    @@ -59,31 +59,15 @@ $(function() {
    -
    entt::Attachee<... > Class Template Reference
    +
    version.h
    - -

    Attachee. - More...

    - -

    #include <attachee.hpp>

    -

    Detailed Description

    -

    template<typename...>
    -class entt::Attachee<... >

    - -

    Attachee.

    -

    Primary template isn't defined on purpose. All the specializations give a compile-time error, but for a few reasonable cases.

    - -

    Definition at line 22 of file attachee.hpp.

    -
    The documentation for this class was generated from the following file: -
    +
    1 #ifndef ENTT_CONFIG_VERSION_H
    2 #define ENTT_CONFIG_VERSION_H
    3 
    4 
    5 #define ENTT_VERSION "3.0.0"
    6 #define ENTT_VERSION_MAJOR 3
    7 #define ENTT_VERSION_MINOR 0
    8 #define ENTT_VERSION_PATCH 0
    9 
    10 
    11 #endif // ENTT_CONFIG_VERSION_H
    Generated by   diff --git a/view_8hpp_source.html b/view_8hpp_source.html index 02554400c..8db2dfe55 100644 --- a/view_8hpp_source.html +++ b/view_8hpp_source.html @@ -22,7 +22,7 @@
    @@ -67,117 +67,51 @@ $(function() {
    view.hpp
    -
    1 #ifndef ENTT_ENTITY_VIEW_HPP
    2 #define ENTT_ENTITY_VIEW_HPP
    3 
    4 
    5 #include <iterator>
    6 #include <cassert>
    7 #include <array>
    8 #include <tuple>
    9 #include <vector>
    10 #include <utility>
    11 #include <algorithm>
    12 #include <type_traits>
    13 #include "../config/config.h"
    14 #include "entt_traits.hpp"
    15 #include "sparse_set.hpp"
    16 
    17 
    18 namespace entt {
    19 
    20 
    24 template<typename>
    25 class Registry;
    26 
    27 
    70 template<typename Entity, typename... Component>
    71 class PersistentView final {
    72  static_assert(sizeof...(Component) > 1, "!");
    73 
    75  friend class Registry<Entity>;
    76 
    77  template<typename Comp>
    78  using pool_type = SparseSet<Entity, Comp>;
    79 
    80  using view_type = SparseSet<Entity>;
    81  using pattern_type = std::tuple<pool_type<Component> &...>;
    82 
    83  PersistentView(view_type &view, pool_type<Component> &... pools) ENTT_NOEXCEPT
    84  : view{view}, pools{pools...}
    85  {}
    86 
    87 public:
    89  using entity_type = typename view_type::entity_type;
    91  using size_type = typename view_type::size_type;
    93  using iterator_type = typename view_type::iterator_type;
    95  using const_iterator_type = typename view_type::const_iterator_type;
    96 
    101  size_type size() const ENTT_NOEXCEPT {
    102  return view.size();
    103  }
    104 
    109  bool empty() const ENTT_NOEXCEPT {
    110  return view.empty();
    111  }
    112 
    125  const entity_type * data() const ENTT_NOEXCEPT {
    126  return view.data();
    127  }
    128 
    143  const_iterator_type cbegin() const ENTT_NOEXCEPT {
    144  return view.cbegin();
    145  }
    146 
    161  inline const_iterator_type begin() const ENTT_NOEXCEPT {
    162  return cbegin();
    163  }
    164 
    179  iterator_type begin() ENTT_NOEXCEPT {
    180  return view.begin();
    181  }
    182 
    198  const_iterator_type cend() const ENTT_NOEXCEPT {
    199  return view.cend();
    200  }
    201 
    217  inline const_iterator_type end() const ENTT_NOEXCEPT {
    218  return cend();
    219  }
    220 
    236  iterator_type end() ENTT_NOEXCEPT {
    237  return view.end();
    238  }
    239 
    245  const entity_type & operator[](const size_type pos) const ENTT_NOEXCEPT {
    246  return view[pos];
    247  }
    248 
    254  bool contains(const entity_type entity) const ENTT_NOEXCEPT {
    255  return view.has(entity) && (view.data()[view.get(entity)] == entity);
    256  }
    257 
    275  template<typename Comp>
    276  const Comp & get(const entity_type entity) const ENTT_NOEXCEPT {
    277  assert(contains(entity));
    278  return std::get<pool_type<Comp> &>(pools).get(entity);
    279  }
    280 
    298  template<typename Comp>
    299  inline Comp & get(const entity_type entity) ENTT_NOEXCEPT {
    300  return const_cast<Comp &>(const_cast<const PersistentView *>(this)->get<Comp>(entity));
    301  }
    302 
    320  template<typename... Comp>
    321  inline std::enable_if_t<(sizeof...(Comp) > 1), std::tuple<const Comp &...>>
    322  get(const entity_type entity) const ENTT_NOEXCEPT {
    323  assert(contains(entity));
    324  return std::tuple<const Comp &...>{get<Comp>(entity)...};
    325  }
    326 
    344  template<typename... Comp>
    345  inline std::enable_if_t<(sizeof...(Comp) > 1), std::tuple<Comp &...>>
    346  get(const entity_type entity) ENTT_NOEXCEPT {
    347  assert(contains(entity));
    348  return std::tuple<Comp &...>{get<Comp>(entity)...};
    349  }
    350 
    367  template<typename Func>
    368  void each(Func func) const {
    369  std::for_each(view.cbegin(), view.cend(), [&func, this](const auto entity) {
    370  func(entity, std::get<pool_type<Component> &>(pools).get(entity)...);
    371  });
    372  }
    373 
    390  template<typename Func>
    391  inline void each(Func func) {
    392  const_cast<const PersistentView *>(this)->each([&func](const entity_type entity, const Component &... component) {
    393  func(entity, const_cast<Component &>(component)...);
    394  });
    395  }
    396 
    413  template<typename Comp>
    414  void sort() {
    415  view.respect(std::get<pool_type<Comp> &>(pools));
    416  }
    417 
    418 private:
    419  view_type &view;
    420  const pattern_type pools;
    421 };
    422 
    423 
    465 template<typename Entity, typename... Component>
    466 class View final {
    467  static_assert(sizeof...(Component) > 1, "!");
    468 
    470  friend class Registry<Entity>;
    471 
    472  template<typename Comp>
    473  using pool_type = SparseSet<Entity, Comp>;
    474 
    475  template<typename Comp>
    476  using component_iterator_type = typename pool_type<Comp>::const_iterator_type;
    477 
    478  using view_type = SparseSet<Entity>;
    479  using underlying_iterator_type = typename view_type::const_iterator_type;
    480  using unchecked_type = std::array<const view_type *, (sizeof...(Component) - 1)>;
    481  using pattern_type = std::tuple<pool_type<Component> &...>;
    482  using traits_type = entt_traits<Entity>;
    483 
    484  class Iterator {
    485  friend class View<Entity, Component...>;
    486 
    487  using extent_type = typename view_type::size_type;
    488 
    489  Iterator(unchecked_type unchecked, underlying_iterator_type begin, underlying_iterator_type end) ENTT_NOEXCEPT
    490  : unchecked{unchecked},
    491  begin{begin},
    492  end{end},
    493  extent{min(std::make_index_sequence<unchecked.size()>{})}
    494  {
    495  if(begin != end && !valid()) {
    496  ++(*this);
    497  }
    498  }
    499 
    500  template<std::size_t... Indexes>
    501  extent_type min(std::index_sequence<Indexes...>) const ENTT_NOEXCEPT {
    502  return std::min({ std::get<Indexes>(unchecked)->extent()... });
    503  }
    504 
    505  bool valid() const ENTT_NOEXCEPT {
    506  const auto entity = *begin;
    507  const auto sz = size_type(entity & traits_type::entity_mask);
    508 
    509  return sz < extent && std::all_of(unchecked.cbegin(), unchecked.cend(), [entity](const view_type *view) {
    510  return view->fast(entity);
    511  });
    512  }
    513 
    514  public:
    515  using difference_type = typename underlying_iterator_type::difference_type;
    516  using value_type = typename underlying_iterator_type::value_type;
    517  using pointer = typename underlying_iterator_type::pointer;
    518  using reference = typename underlying_iterator_type::reference;
    519  using iterator_category = std::forward_iterator_tag;
    520 
    521  Iterator() ENTT_NOEXCEPT = default;
    522 
    523  Iterator(const Iterator &) ENTT_NOEXCEPT = default;
    524  Iterator & operator=(const Iterator &) ENTT_NOEXCEPT = default;
    525 
    526  Iterator & operator++() ENTT_NOEXCEPT {
    527  return (++begin != end && !valid()) ? ++(*this) : *this;
    528  }
    529 
    530  Iterator operator++(int) ENTT_NOEXCEPT {
    531  Iterator orig = *this;
    532  return ++(*this), orig;
    533  }
    534 
    535  bool operator==(const Iterator &other) const ENTT_NOEXCEPT {
    536  return other.begin == begin;
    537  }
    538 
    539  inline bool operator!=(const Iterator &other) const ENTT_NOEXCEPT {
    540  return !(*this == other);
    541  }
    542 
    543  pointer operator->() const ENTT_NOEXCEPT {
    544  return begin.operator->();
    545  }
    546 
    547  inline reference operator*() const ENTT_NOEXCEPT {
    548  return *operator->();
    549  }
    550 
    551  private:
    552  unchecked_type unchecked;
    553  underlying_iterator_type begin;
    554  underlying_iterator_type end;
    555  extent_type extent;
    556  };
    557 
    558  View(pool_type<Component> &... pools) ENTT_NOEXCEPT
    559  : pools{pools...}
    560  {}
    561 
    562  template<typename Comp>
    563  const pool_type<Comp> & pool() const ENTT_NOEXCEPT {
    564  return std::get<pool_type<Comp> &>(pools);
    565  }
    566 
    567  const view_type * candidate() const ENTT_NOEXCEPT {
    568  return std::min({ static_cast<const view_type *>(&pool<Component>())... }, [](const auto *lhs, const auto *rhs) {
    569  return lhs->size() < rhs->size();
    570  });
    571  }
    572 
    573  unchecked_type unchecked(const view_type *view) const ENTT_NOEXCEPT {
    574  unchecked_type other{};
    575  std::size_t pos{};
    576  using accumulator_type = const view_type *[];
    577  accumulator_type accumulator = { (&pool<Component>() == view ? view : other[pos++] = &pool<Component>())... };
    578  (void)accumulator;
    579  return other;
    580  }
    581 
    582  template<typename Comp, typename Other>
    583  inline std::enable_if_t<std::is_same<Comp, Other>::value, const Other &>
    584  get(const component_iterator_type<Comp> &it, const Entity) const ENTT_NOEXCEPT { return *it; }
    585 
    586  template<typename Comp, typename Other>
    587  inline std::enable_if_t<!std::is_same<Comp, Other>::value, const Other &>
    588  get(const component_iterator_type<Comp> &, const Entity entity) const ENTT_NOEXCEPT { return pool<Other>().get(entity); }
    589 
    590  template<typename Comp, typename Func, std::size_t... Indexes>
    591  void each(const pool_type<Comp> &cpool, Func func, std::index_sequence<Indexes...>) const {
    592  const auto other = unchecked(&cpool);
    593  std::array<underlying_iterator_type, sizeof...(Indexes)> data{{std::get<Indexes>(other)->cbegin()...}};
    594  const auto extent = std::min({ pool<Component>().extent()... });
    595  auto raw = std::make_tuple(pool<Component>().cbegin()...);
    596  const auto end = cpool.view_type::cend();
    597  auto begin = cpool.view_type::cbegin();
    598 
    599  // we can directly use the raw iterators if pools are ordered
    600  while(begin != end && std::min({ (*(std::get<Indexes>(data)++) == *begin)... })) {
    601  func(*(begin++), *(std::get<component_iterator_type<Component>>(raw)++)...);
    602  }
    603 
    604  // fallback to visit what remains using indirections
    605  while(begin != end) {
    606  const auto entity = *(begin++);
    607  const auto it = std::get<component_iterator_type<Comp>>(raw)++;
    608  const auto sz = size_type(entity & traits_type::entity_mask);
    609 
    610  if(sz < extent && std::all_of(other.cbegin(), other.cend(), [entity](const view_type *view) { return view->fast(entity); })) {
    611  // avoided at least the indirection due to the sparse set for the pivot type (see get for more details)
    612  func(entity, get<Comp, Component>(it, entity)...);
    613  }
    614  }
    615  }
    616 
    617 public:
    619  using entity_type = typename view_type::entity_type;
    621  using size_type = typename view_type::size_type;
    623  using iterator_type = Iterator;
    625  using const_iterator_type = Iterator;
    626 
    631  size_type size() const ENTT_NOEXCEPT {
    632  return std::min({ pool<Component>().size()... });
    633  }
    634 
    639  bool empty() const ENTT_NOEXCEPT {
    640  return std::max({ pool<Component>().empty()... });
    641  }
    642 
    657  const_iterator_type cbegin() const ENTT_NOEXCEPT {
    658  const auto *view = candidate();
    659  return const_iterator_type{unchecked(view), view->cbegin(), view->cend()};
    660  }
    661 
    676  inline const_iterator_type begin() const ENTT_NOEXCEPT {
    677  return cbegin();
    678  }
    679 
    694  inline iterator_type begin() ENTT_NOEXCEPT {
    695  return cbegin();
    696  }
    697 
    713  const_iterator_type cend() const ENTT_NOEXCEPT {
    714  const auto *view = candidate();
    715  return const_iterator_type{unchecked(view), view->cend(), view->cend()};
    716  }
    717 
    733  inline const_iterator_type end() const ENTT_NOEXCEPT {
    734  return cend();
    735  }
    736 
    752  inline iterator_type end() ENTT_NOEXCEPT {
    753  return cend();
    754  }
    755 
    761  bool contains(const entity_type entity) const ENTT_NOEXCEPT {
    762  const auto sz = size_type(entity & traits_type::entity_mask);
    763  const auto extent = std::min({ pool<Component>().extent()... });
    764  return sz < extent && std::min({ (pool<Component>().has(entity) && (pool<Component>().data()[pool<Component>().view_type::get(entity)] == entity))... });
    765  }
    766 
    784  template<typename Comp>
    785  const Comp & get(const entity_type entity) const ENTT_NOEXCEPT {
    786  assert(contains(entity));
    787  return pool<Comp>().get(entity);
    788  }
    789 
    807  template<typename Comp>
    808  inline Comp & get(const entity_type entity) ENTT_NOEXCEPT {
    809  return const_cast<Comp &>(const_cast<const View *>(this)->get<Comp>(entity));
    810  }
    811 
    829  template<typename... Comp>
    830  inline std::enable_if_t<(sizeof...(Comp) > 1), std::tuple<const Comp &...>>
    831  get(const entity_type entity) const ENTT_NOEXCEPT {
    832  assert(contains(entity));
    833  return std::tuple<const Comp &...>{get<Comp>(entity)...};
    834  }
    835 
    853  template<typename... Comp>
    854  inline std::enable_if_t<(sizeof...(Comp) > 1), std::tuple<Comp &...>>
    855  get(const entity_type entity) ENTT_NOEXCEPT {
    856  assert(contains(entity));
    857  return std::tuple<Comp &...>{get<Comp>(entity)...};
    858  }
    859 
    876  template<typename Func>
    877  void each(Func func) const {
    878  const auto *view = candidate();
    879  using accumulator_type = int[];
    880  accumulator_type accumulator = { (&pool<Component>() == view ? (each(pool<Component>(), std::move(func), std::make_index_sequence<sizeof...(Component)-1>{}), 0) : 0)... };
    881  (void)accumulator;
    882  }
    883 
    900  template<typename Func>
    901  inline void each(Func func) {
    902  const_cast<const View *>(this)->each([&func](const entity_type entity, const Component &... component) {
    903  func(entity, const_cast<Component &>(component)...);
    904  });
    905  }
    906 
    907 private:
    908  const pattern_type pools;
    909 };
    910 
    911 
    950 template<typename Entity, typename Component>
    951 class View<Entity, Component> final {
    953  friend class Registry<Entity>;
    954 
    955  using view_type = SparseSet<Entity>;
    956  using pool_type = SparseSet<Entity, Component>;
    957 
    958  View(pool_type &pool) ENTT_NOEXCEPT
    959  : pool{pool}
    960  {}
    961 
    962 public:
    964  using raw_type = typename pool_type::object_type;
    966  using entity_type = typename pool_type::entity_type;
    968  using size_type = typename pool_type::size_type;
    970  using iterator_type = typename view_type::iterator_type;
    972  using const_iterator_type = typename view_type::const_iterator_type;
    973 
    978  size_type size() const ENTT_NOEXCEPT {
    979  return pool.size();
    980  }
    981 
    986  bool empty() const ENTT_NOEXCEPT {
    987  return pool.empty();
    988  }
    989 
    1002  const raw_type * raw() const ENTT_NOEXCEPT {
    1003  return pool.raw();
    1004  }
    1005 
    1018  inline raw_type * raw() ENTT_NOEXCEPT {
    1019  return const_cast<raw_type *>(const_cast<const View *>(this)->raw());
    1020  }
    1021 
    1034  const entity_type * data() const ENTT_NOEXCEPT {
    1035  return pool.data();
    1036  }
    1037 
    1052  const_iterator_type cbegin() const ENTT_NOEXCEPT {
    1053  return pool.view_type::cbegin();
    1054  }
    1055 
    1070  inline const_iterator_type begin() const ENTT_NOEXCEPT {
    1071  return cbegin();
    1072  }
    1073 
    1088  iterator_type begin() ENTT_NOEXCEPT {
    1089  return pool.view_type::begin();
    1090  }
    1091 
    1107  const_iterator_type cend() const ENTT_NOEXCEPT {
    1108  return pool.view_type::cend();
    1109  }
    1110 
    1126  inline const_iterator_type end() const ENTT_NOEXCEPT {
    1127  return cend();
    1128  }
    1129 
    1145  iterator_type end() ENTT_NOEXCEPT {
    1146  return pool.view_type::end();
    1147  }
    1148 
    1154  const entity_type & operator[](const size_type pos) const ENTT_NOEXCEPT {
    1155  return pool.view_type::operator[](pos);
    1156  }
    1157 
    1163  bool contains(const entity_type entity) const ENTT_NOEXCEPT {
    1164  return pool.has(entity) && (pool.data()[pool.view_type::get(entity)] == entity);
    1165  }
    1166 
    1182  const Component & get(const entity_type entity) const ENTT_NOEXCEPT {
    1183  assert(contains(entity));
    1184  return pool.get(entity);
    1185  }
    1186 
    1202  inline Component & get(const entity_type entity) ENTT_NOEXCEPT {
    1203  return const_cast<Component &>(const_cast<const View *>(this)->get(entity));
    1204  }
    1205 
    1221  template<typename Func>
    1222  void each(Func func) const {
    1223  std::for_each(pool.view_type::cbegin(), pool.view_type::cend(), [&func, raw = pool.cbegin()](const auto entity) mutable {
    1224  func(entity, *(raw++));
    1225  });
    1226  }
    1227 
    1243  template<typename Func>
    1244  inline void each(Func func) {
    1245  const_cast<const View *>(this)->each([&func](const entity_type entity, const Component &component) {
    1246  func(entity, const_cast<Component &>(component));
    1247  });
    1248  }
    1249 
    1250 private:
    1251  pool_type &pool;
    1252 };
    1253 
    1254 
    1294 template<typename Entity, typename Component>
    1295 class RawView final {
    1297  friend class Registry<Entity>;
    1298 
    1299  using pool_type = SparseSet<Entity, Component>;
    1300 
    1301  RawView(pool_type &pool) ENTT_NOEXCEPT
    1302  : pool{pool}
    1303  {}
    1304 
    1305 public:
    1307  using raw_type = typename pool_type::object_type;
    1309  using entity_type = typename pool_type::entity_type;
    1311  using size_type = typename pool_type::size_type;
    1313  using iterator_type = typename pool_type::iterator_type;
    1315  using const_iterator_type = typename pool_type::const_iterator_type;
    1316 
    1321  size_type size() const ENTT_NOEXCEPT {
    1322  return pool.size();
    1323  }
    1324 
    1329  bool empty() const ENTT_NOEXCEPT {
    1330  return pool.empty();
    1331  }
    1332 
    1345  const raw_type * raw() const ENTT_NOEXCEPT {
    1346  return pool.raw();
    1347  }
    1348 
    1361  inline raw_type * raw() ENTT_NOEXCEPT {
    1362  return const_cast<raw_type *>(const_cast<const RawView *>(this)->raw());
    1363  }
    1364 
    1377  const entity_type * data() const ENTT_NOEXCEPT {
    1378  return pool.data();
    1379  }
    1380 
    1393  const_iterator_type cbegin() const ENTT_NOEXCEPT {
    1394  return pool.cbegin();
    1395  }
    1396 
    1409  inline const_iterator_type begin() const ENTT_NOEXCEPT {
    1410  return cbegin();
    1411  }
    1412 
    1425  iterator_type begin() ENTT_NOEXCEPT {
    1426  return pool.begin();
    1427  }
    1428 
    1444  const_iterator_type cend() const ENTT_NOEXCEPT {
    1445  return pool.cend();
    1446  }
    1447 
    1463  inline const_iterator_type end() const ENTT_NOEXCEPT {
    1464  return cend();
    1465  }
    1466 
    1482  iterator_type end() ENTT_NOEXCEPT {
    1483  return pool.end();
    1484  }
    1485 
    1491  const raw_type & operator[](const size_type pos) const ENTT_NOEXCEPT {
    1492  return pool[pos];
    1493  }
    1494 
    1500  inline raw_type & operator[](const size_type pos) ENTT_NOEXCEPT {
    1501  return const_cast<raw_type &>(const_cast<const RawView *>(this)->operator[](pos));
    1502  }
    1503 
    1518  template<typename Func>
    1519  void each(Func func) const {
    1520  std::for_each(pool.cbegin(), pool.cend(), func);
    1521  }
    1522 
    1537  template<typename Func>
    1538  void each(Func func) {
    1539  std::for_each(pool.begin(), pool.end(), func);
    1540  }
    1541 
    1542 private:
    1543  pool_type &pool;
    1544 };
    1545 
    1546 
    1589 template<typename Entity>
    1590 class RuntimeView {
    1592  friend class Registry<Entity>;
    1593 
    1594  using view_type = SparseSet<Entity>;
    1595  using underlying_iterator_type = typename view_type::const_iterator_type;
    1596  using pattern_type = std::vector<const view_type *>;
    1597  using extent_type = typename view_type::size_type;
    1598  using traits_type = entt_traits<Entity>;
    1599 
    1600  class Iterator {
    1601  friend class RuntimeView<Entity>;
    1602 
    1603  Iterator(underlying_iterator_type begin, underlying_iterator_type end, const view_type * const *first, const view_type * const *last, extent_type extent) ENTT_NOEXCEPT
    1604  : begin{begin},
    1605  end{end},
    1606  first{first},
    1607  last{last},
    1608  extent{extent}
    1609  {
    1610  if(begin != end && !valid()) {
    1611  ++(*this);
    1612  }
    1613  }
    1614 
    1615  bool valid() const ENTT_NOEXCEPT {
    1616  const auto entity = *begin;
    1617  const auto sz = size_type(entity & traits_type::entity_mask);
    1618 
    1619  return sz < extent && std::all_of(first, last, [entity](const auto *view) {
    1620  return view->fast(entity);
    1621  });
    1622  }
    1623 
    1624  public:
    1625  using difference_type = typename underlying_iterator_type::difference_type;
    1626  using value_type = typename underlying_iterator_type::value_type;
    1627  using pointer = typename underlying_iterator_type::pointer;
    1628  using reference = typename underlying_iterator_type::reference;
    1629  using iterator_category = std::forward_iterator_tag;
    1630 
    1631  Iterator() ENTT_NOEXCEPT = default;
    1632 
    1633  Iterator(const Iterator &) ENTT_NOEXCEPT = default;
    1634  Iterator & operator=(const Iterator &) ENTT_NOEXCEPT = default;
    1635 
    1636  Iterator & operator++() ENTT_NOEXCEPT {
    1637  return (++begin != end && !valid()) ? ++(*this) : *this;
    1638  }
    1639 
    1640  Iterator operator++(int) ENTT_NOEXCEPT {
    1641  Iterator orig = *this;
    1642  return ++(*this), orig;
    1643  }
    1644 
    1645  bool operator==(const Iterator &other) const ENTT_NOEXCEPT {
    1646  return other.begin == begin;
    1647  }
    1648 
    1649  inline bool operator!=(const Iterator &other) const ENTT_NOEXCEPT {
    1650  return !(*this == other);
    1651  }
    1652 
    1653  pointer operator->() const ENTT_NOEXCEPT {
    1654  return begin.operator->();
    1655  }
    1656 
    1657  inline reference operator*() const ENTT_NOEXCEPT {
    1658  return *operator->();
    1659  }
    1660 
    1661  private:
    1662  underlying_iterator_type begin;
    1663  underlying_iterator_type end;
    1664  const view_type * const *first;
    1665  const view_type * const *last;
    1666  extent_type extent;
    1667  };
    1668 
    1669  RuntimeView(pattern_type others) ENTT_NOEXCEPT
    1670  : pools{std::move(others)}
    1671  {
    1672  const auto it = std::min_element(pools.begin(), pools.end(), [](const auto *lhs, const auto *rhs) {
    1673  return (!lhs && rhs) || (lhs && rhs && lhs->size() < rhs->size());
    1674  });
    1675 
    1676  // brings the best candidate (if any) on front of the vector
    1677  std::rotate(pools.begin(), it, pools.end());
    1678  }
    1679 
    1680  extent_type min() const ENTT_NOEXCEPT {
    1681  extent_type extent{};
    1682 
    1683  if(valid()) {
    1684  const auto it = std::min_element(pools.cbegin(), pools.cend(), [](const auto *lhs, const auto *rhs) {
    1685  return lhs->extent() < rhs->extent();
    1686  });
    1687 
    1688  extent = (*it)->extent();
    1689  }
    1690 
    1691  return extent;
    1692  }
    1693 
    1694  inline bool valid() const ENTT_NOEXCEPT {
    1695  return !pools.empty() && pools.front();
    1696  }
    1697 
    1698 public:
    1700  using entity_type = typename view_type::entity_type;
    1702  using size_type = typename view_type::size_type;
    1704  using iterator_type = Iterator;
    1706  using const_iterator_type = Iterator;
    1707 
    1712  size_type size() const ENTT_NOEXCEPT {
    1713  return valid() ? pools.front()->size() : size_type{};
    1714  }
    1715 
    1720  bool empty() const ENTT_NOEXCEPT {
    1721  return !valid() || pools.front()->empty();
    1722  }
    1723 
    1738  const_iterator_type cbegin() const ENTT_NOEXCEPT {
    1739  const_iterator_type it{};
    1740 
    1741  if(valid()) {
    1742  const auto &pool = *pools.front();
    1743  const auto * const *data = pools.data();
    1744  it = { pool.cbegin(), pool.cend(), data + 1, data + pools.size(), min() };
    1745  }
    1746 
    1747  return it;
    1748  }
    1749 
    1764  inline const_iterator_type begin() const ENTT_NOEXCEPT {
    1765  return cbegin();
    1766  }
    1767 
    1782  inline iterator_type begin() ENTT_NOEXCEPT {
    1783  return cbegin();
    1784  }
    1785 
    1801  const_iterator_type cend() const ENTT_NOEXCEPT {
    1802  const_iterator_type it{};
    1803 
    1804  if(valid()) {
    1805  const auto &pool = *pools.front();
    1806  it = { pool.cend(), pool.cend(), nullptr, nullptr, min() };
    1807  }
    1808 
    1809  return it;
    1810  }
    1811 
    1827  inline const_iterator_type end() const ENTT_NOEXCEPT {
    1828  return cend();
    1829  }
    1830 
    1846  inline iterator_type end() ENTT_NOEXCEPT {
    1847  return cend();
    1848  }
    1849 
    1855  bool contains(const entity_type entity) const ENTT_NOEXCEPT {
    1856  return valid() && std::all_of(pools.cbegin(), pools.cend(), [entity](const auto *view) {
    1857  return view->has(entity) && view->data()[view->get(entity)] == entity;
    1858  });
    1859  }
    1860 
    1876  template<typename Func>
    1877  void each(Func func) const {
    1878  std::for_each(cbegin(), cend(), func);
    1879  }
    1880 
    1881 private:
    1882  pattern_type pools;
    1883 };
    1884 
    1885 
    1886 }
    1887 
    1888 
    1889 #endif // ENTT_ENTITY_VIEW_HPP
    entt::RawView::const_iterator_type
    typename pool_type::const_iterator_type const_iterator_type
    Constant input iterator type.
    Definition: view.hpp:1315
    -
    entt::View< Entity, Component >::size_type
    typename pool_type::size_type size_type
    Unsigned integer type.
    Definition: view.hpp:968
    -
    entt::RawView::empty
    bool empty() const ENTT_NOEXCEPT
    Checks whether the view is empty.
    Definition: view.hpp:1329
    -
    entt::operator!=
    constexpr bool operator!=(const HashedString &lhs, const HashedString &rhs) ENTT_NOEXCEPT
    Compares two hashed strings.
    Definition: hashed_string.hpp:103
    -
    entt::View::cend
    const_iterator_type cend() const ENTT_NOEXCEPT
    Returns an iterator that is past the last entity that has the given components.
    Definition: view.hpp:713
    -
    entt::PersistentView::const_iterator_type
    typename view_type::const_iterator_type const_iterator_type
    Constant input iterator type.
    Definition: view.hpp:95
    -
    entt::PersistentView::operator[]
    const entity_type & operator[](const size_type pos) const ENTT_NOEXCEPT
    Returns a reference to the element at the given position.
    Definition: view.hpp:245
    -
    entt::PersistentView::entity_type
    typename view_type::entity_type entity_type
    Underlying entity identifier.
    Definition: view.hpp:89
    -
    entt::RuntimeView::empty
    bool empty() const ENTT_NOEXCEPT
    Checks if the view is definitely empty.
    Definition: view.hpp:1720
    -
    entt::RawView::begin
    iterator_type begin() ENTT_NOEXCEPT
    Returns an iterator to the first instance of the given type.
    Definition: view.hpp:1425
    -
    entt::PersistentView::size
    size_type size() const ENTT_NOEXCEPT
    Returns the number of entities that have the given components.
    Definition: view.hpp:101
    -
    entt::RuntimeView::size
    size_type size() const ENTT_NOEXCEPT
    Estimates the number of entities that have the given components.
    Definition: view.hpp:1712
    -
    entt::RawView::operator[]
    raw_type & operator[](const size_type pos) ENTT_NOEXCEPT
    Returns a reference to the element at the given position.
    Definition: view.hpp:1500
    -
    entt::Registry
    Fast and reliable entity-component system.
    Definition: registry.hpp:42
    -
    entt::RuntimeView::begin
    const_iterator_type begin() const ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given components.
    Definition: view.hpp:1764
    -
    entt::View< Entity, Component >::end
    const_iterator_type end() const ENTT_NOEXCEPT
    Returns an iterator that is past the last entity that has the given component.
    Definition: view.hpp:1126
    -
    entt::SparseSet< Entity >::empty
    bool empty() const ENTT_NOEXCEPT
    Checks whether a sparse set is empty.
    Definition: sparse_set.hpp:246
    -
    entt::PersistentView::end
    const_iterator_type end() const ENTT_NOEXCEPT
    Returns an iterator that is past the last entity that has the given components.
    Definition: view.hpp:217
    -
    entt::PersistentView::each
    void each(Func func)
    Iterates entities and components and applies the given function object to them.
    Definition: view.hpp:391
    -
    entt::View::size_type
    typename view_type::size_type size_type
    Unsigned integer type.
    Definition: view.hpp:621
    -
    entt::RawView::raw
    raw_type * raw() ENTT_NOEXCEPT
    Direct access to the list of components.
    Definition: view.hpp:1361
    -
    entt::RawView::iterator_type
    typename pool_type::iterator_type iterator_type
    Input iterator type.
    Definition: view.hpp:1313
    -
    entt::RawView
    Raw view.
    Definition: view.hpp:1295
    -
    entt::RawView::each
    void each(Func func)
    Iterates components and applies the given function object to them.
    Definition: view.hpp:1538
    -
    entt::PersistentView::empty
    bool empty() const ENTT_NOEXCEPT
    Checks whether the view is empty.
    Definition: view.hpp:109
    +
    1 #ifndef ENTT_ENTITY_VIEW_HPP
    2 #define ENTT_ENTITY_VIEW_HPP
    3 
    4 
    5 #include <iterator>
    6 #include <array>
    7 #include <tuple>
    8 #include <utility>
    9 #include <algorithm>
    10 #include <type_traits>
    11 #include "../config/config.h"
    12 #include "../core/type_traits.hpp"
    13 #include "sparse_set.hpp"
    14 #include "storage.hpp"
    15 #include "entity.hpp"
    16 #include "fwd.hpp"
    17 
    18 
    19 namespace entt {
    20 
    21 
    58 template<typename Entity, typename... Component>
    59 class basic_view {
    60  static_assert(sizeof...(Component) > 1);
    61 
    63  friend class basic_registry<Entity>;
    64 
    65  template<typename Comp>
    66  using pool_type = std::conditional_t<std::is_const_v<Comp>, const storage<Entity, std::remove_const_t<Comp>>, storage<Entity, Comp>>;
    67 
    68  template<typename Comp>
    69  using component_iterator_type = decltype(std::declval<pool_type<Comp>>().begin());
    70 
    71  using underlying_iterator_type = typename sparse_set<Entity>::iterator_type;
    72  using unchecked_type = std::array<const sparse_set<Entity> *, (sizeof...(Component) - 1)>;
    73  using traits_type = entt_traits<Entity>;
    74 
    75  class iterator {
    76  friend class basic_view<Entity, Component...>;
    77 
    78  using extent_type = typename sparse_set<Entity>::size_type;
    79 
    80  iterator(unchecked_type other, underlying_iterator_type first, underlying_iterator_type last) ENTT_NOEXCEPT
    81  : unchecked{other},
    82  begin{first},
    83  end{last},
    84  extent{min(std::make_index_sequence<other.size()>{})}
    85  {
    86  if(begin != end && !valid()) {
    87  ++(*this);
    88  }
    89  }
    90 
    91  template<auto... Indexes>
    92  extent_type min(std::index_sequence<Indexes...>) const ENTT_NOEXCEPT {
    93  return std::min({ std::get<Indexes>(unchecked)->extent()... });
    94  }
    95 
    96  bool valid() const ENTT_NOEXCEPT {
    97  const auto entt = *begin;
    98  const auto sz = size_type(entt& traits_type::entity_mask);
    99 
    100  return sz < extent && std::all_of(unchecked.cbegin(), unchecked.cend(), [entt](const sparse_set<Entity> *view) {
    101  return view->has(entt);
    102  });
    103  }
    104 
    105  public:
    106  using difference_type = typename underlying_iterator_type::difference_type;
    107  using value_type = typename underlying_iterator_type::value_type;
    108  using pointer = typename underlying_iterator_type::pointer;
    109  using reference = typename underlying_iterator_type::reference;
    110  using iterator_category = std::forward_iterator_tag;
    111 
    112  iterator() ENTT_NOEXCEPT = default;
    113 
    114  iterator & operator++() ENTT_NOEXCEPT {
    115  return (++begin != end && !valid()) ? ++(*this) : *this;
    116  }
    117 
    118  iterator operator++(int) ENTT_NOEXCEPT {
    119  iterator orig = *this;
    120  return ++(*this), orig;
    121  }
    122 
    123  bool operator==(const iterator &other) const ENTT_NOEXCEPT {
    124  return other.begin == begin;
    125  }
    126 
    127  inline bool operator!=(const iterator &other) const ENTT_NOEXCEPT {
    128  return !(*this == other);
    129  }
    130 
    131  pointer operator->() const ENTT_NOEXCEPT {
    132  return begin.operator->();
    133  }
    134 
    135  inline reference operator*() const ENTT_NOEXCEPT {
    136  return *operator->();
    137  }
    138 
    139  private:
    140  unchecked_type unchecked;
    141  underlying_iterator_type begin;
    142  underlying_iterator_type end;
    143  extent_type extent;
    144  };
    145 
    146  // we could use pool_type<Component> *..., but vs complains about it and refuses to compile for unknown reasons (likely a bug)
    147  basic_view(storage<Entity, std::remove_const_t<Component>> *... ref) ENTT_NOEXCEPT
    148  : pools{ref...}
    149  {}
    150 
    151  const sparse_set<Entity> * candidate() const ENTT_NOEXCEPT {
    152  return std::min({ static_cast<const sparse_set<Entity> *>(std::get<pool_type<Component> *>(pools))... }, [](const auto *lhs, const auto *rhs) {
    153  return lhs->size() < rhs->size();
    154  });
    155  }
    156 
    157  unchecked_type unchecked(const sparse_set<Entity> *view) const ENTT_NOEXCEPT {
    158  unchecked_type other{};
    159  typename unchecked_type::size_type pos{};
    160  ((std::get<pool_type<Component> *>(pools) == view ? nullptr : (other[pos++] = std::get<pool_type<Component> *>(pools))), ...);
    161  return other;
    162  }
    163 
    164  template<typename Comp, typename Other>
    165  inline decltype(auto) get([[maybe_unused]] component_iterator_type<Comp> it, [[maybe_unused]] pool_type<Other> *cpool, [[maybe_unused]] const Entity entt) const ENTT_NOEXCEPT {
    166  if constexpr(std::is_same_v<Comp, Other>) {
    167  return *it;
    168  } else {
    169  return cpool->get(entt);
    170  }
    171  }
    172 
    173  template<typename Comp, typename... Other, typename Func>
    174  void each(type_list<Other...>, Func func) const {
    175  const auto end = std::get<pool_type<Comp> *>(pools)->sparse_set<Entity>::end();
    176  auto begin = std::get<pool_type<Comp> *>(pools)->sparse_set<Entity>::begin();
    177 
    178  std::for_each(begin, end, [raw = std::get<pool_type<Comp> *>(pools)->begin(), &func, this](const auto entity) mutable {
    179  auto curr = raw++;
    180 
    181  if((std::get<pool_type<Other> *>(pools)->has(entity) && ...)) {
    182  if constexpr(std::is_invocable_v<Func, decltype(get<Component>({}))...>) {
    183  func(get<Comp, Component>(curr, std::get<pool_type<Component> *>(pools), entity)...);
    184  } else {
    185  func(entity, get<Comp, Component>(curr, std::get<pool_type<Component> *>(pools), entity)...);
    186  }
    187  }
    188  });
    189  }
    190 
    191 public:
    193  using entity_type = typename sparse_set<Entity>::entity_type;
    195  using size_type = typename sparse_set<Entity>::size_type;
    197  using iterator_type = iterator;
    198 
    204  template<typename Comp>
    205  size_type size() const ENTT_NOEXCEPT {
    206  return std::get<pool_type<Comp> *>(pools)->size();
    207  }
    208 
    213  size_type size() const ENTT_NOEXCEPT {
    214  return std::min({ std::get<pool_type<Component> *>(pools)->size()... });
    215  }
    216 
    223  template<typename Comp>
    224  bool empty() const ENTT_NOEXCEPT {
    225  return std::get<pool_type<Comp> *>(pools)->empty();
    226  }
    227 
    232  bool empty() const ENTT_NOEXCEPT {
    233  return (std::get<pool_type<Component> *>(pools)->empty() || ...);
    234  }
    235 
    250  template<typename Comp>
    251  Comp * raw() const ENTT_NOEXCEPT {
    252  return std::get<pool_type<Comp> *>(pools)->raw();
    253  }
    254 
    269  template<typename Comp>
    270  const entity_type * data() const ENTT_NOEXCEPT {
    271  return std::get<pool_type<Comp> *>(pools)->data();
    272  }
    273 
    288  iterator_type begin() const ENTT_NOEXCEPT {
    289  const auto *view = candidate();
    290  return iterator_type{unchecked(view), view->begin(), view->end()};
    291  }
    292 
    308  iterator_type end() const ENTT_NOEXCEPT {
    309  const auto *view = candidate();
    310  return iterator_type{unchecked(view), view->end(), view->end()};
    311  }
    312 
    319  iterator_type find(const entity_type entt) const ENTT_NOEXCEPT {
    320  const auto *view = candidate();
    321  iterator_type it{unchecked(view), view->find(entt), view->end()};
    322  return (it != end() && *it == entt) ? it : end();
    323  }
    324 
    330  bool contains(const entity_type entt) const ENTT_NOEXCEPT {
    331  return find(entt) != end();
    332  }
    333 
    351  template<typename... Comp>
    352  decltype(auto) get([[maybe_unused]] const entity_type entt) const ENTT_NOEXCEPT {
    353  ENTT_ASSERT(contains(entt));
    354 
    355  if constexpr(sizeof...(Comp) == 1) {
    356  return (std::get<pool_type<Comp> *>(pools)->get(entt), ...);
    357  } else {
    358  return std::tuple<decltype(get<Comp>(entt))...>{get<Comp>(entt)...};
    359  }
    360  }
    361 
    385  template<typename Func>
    386  inline void each(Func func) const {
    387  const auto *view = candidate();
    388  ((std::get<pool_type<Component> *>(pools) == view ? each<Component>(std::move(func)) : void()), ...);
    389  }
    390 
    421  template<typename Comp, typename Func>
    422  inline void each(Func func) const {
    423  using other_type = type_list_cat_t<std::conditional_t<std::is_same_v<Comp, Component>, type_list<>, type_list<Component>>...>;
    424  each<Comp>(other_type{}, std::move(func));
    425  }
    426 
    427 private:
    428  const std::tuple<pool_type<Component> *...> pools;
    429 };
    430 
    431 
    465 template<typename Entity, typename Component>
    466 class basic_view<Entity, Component> {
    468  friend class basic_registry<Entity>;
    469 
    470  using pool_type = std::conditional_t<std::is_const_v<Component>, const storage<Entity, std::remove_const_t<Component>>, storage<Entity, Component>>;
    471 
    472  basic_view(pool_type *ref) ENTT_NOEXCEPT
    473  : pool{ref}
    474  {}
    475 
    476 public:
    478  using raw_type = Component;
    480  using entity_type = typename pool_type::entity_type;
    482  using size_type = typename pool_type::size_type;
    484  using iterator_type = typename sparse_set<Entity>::iterator_type;
    485 
    490  size_type size() const ENTT_NOEXCEPT {
    491  return pool->size();
    492  }
    493 
    498  bool empty() const ENTT_NOEXCEPT {
    499  return pool->empty();
    500  }
    501 
    514  raw_type * raw() const ENTT_NOEXCEPT {
    515  return pool->raw();
    516  }
    517 
    530  const entity_type * data() const ENTT_NOEXCEPT {
    531  return pool->data();
    532  }
    533 
    548  iterator_type begin() const ENTT_NOEXCEPT {
    549  return pool->sparse_set<Entity>::begin();
    550  }
    551 
    567  iterator_type end() const ENTT_NOEXCEPT {
    568  return pool->sparse_set<Entity>::end();
    569  }
    570 
    577  iterator_type find(const entity_type entt) const ENTT_NOEXCEPT {
    578  const auto it = pool->find(entt);
    579  return it != end() && *it == entt ? it : end();
    580  }
    581 
    587  entity_type operator[](const size_type pos) const ENTT_NOEXCEPT {
    588  return begin()[pos];
    589  }
    590 
    596  bool contains(const entity_type entt) const ENTT_NOEXCEPT {
    597  return find(entt) != end();
    598  }
    599 
    615  decltype(auto) get(const entity_type entt) const ENTT_NOEXCEPT {
    616  ENTT_ASSERT(contains(entt));
    617  return pool->get(entt);
    618  }
    619 
    643  template<typename Func>
    644  void each(Func func) const {
    645  if constexpr(std::is_invocable_v<Func, decltype(get({}))>) {
    646  std::for_each(pool->begin(), pool->end(), std::move(func));
    647  } else {
    648  std::for_each(pool->sparse_set<Entity>::begin(), pool->sparse_set<Entity>::end(), [&func, raw = pool->begin()](const auto entt) mutable {
    649  func(entt, *(raw++));
    650  });
    651  }
    652  }
    653 
    654 private:
    655  pool_type *pool;
    656 };
    657 
    658 
    659 }
    660 
    661 
    662 #endif // ENTT_ENTITY_VIEW_HPP
    entt::basic_view< Entity, Component >::size_type
    typename pool_type::size_type size_type
    Unsigned integer type.
    Definition: view.hpp:482
    +
    entt::basic_view::raw
    Comp * raw() const ENTT_NOEXCEPT
    Direct access to the list of components of a given pool.
    Definition: view.hpp:251
    +
    entt::basic_view< Entity, Component >::find
    iterator_type find(const entity_type entt) const ENTT_NOEXCEPT
    Finds an entity.
    Definition: view.hpp:577
    +
    entt::basic_view::size
    size_type size() const ENTT_NOEXCEPT
    Estimates the number of entities that have the given components.
    Definition: view.hpp:213
    +
    entt::basic_view< Entity, Component >::raw_type
    Component raw_type
    Type of component iterated by the view.
    Definition: view.hpp:478
    +
    entt::sparse_set
    Basic sparse set implementation.
    Definition: sparse_set.hpp:46
    +
    entt::basic_view< Entity, Component >::begin
    iterator_type begin() const ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given component.
    Definition: view.hpp:548
    +
    entt::basic_view< Entity, Component >::contains
    bool contains(const entity_type entt) const ENTT_NOEXCEPT
    Checks if a view contains an entity.
    Definition: view.hpp:596
    +
    entt::basic_view::entity_type
    typename sparse_set< Entity >::entity_type entity_type
    Underlying entity identifier.
    Definition: view.hpp:193
    +
    entt::basic_view< Entity, Component >::entity_type
    typename pool_type::entity_type entity_type
    Underlying entity identifier.
    Definition: view.hpp:480
    +
    entt::sparse_set::size
    size_type size() const ENTT_NOEXCEPT
    Returns the number of elements in a sparse set.
    Definition: sparse_set.hpp:284
    +
    entt::basic_view::data
    const entity_type * data() const ENTT_NOEXCEPT
    Direct access to the list of entities of a given pool.
    Definition: view.hpp:270
    +
    entt::basic_view< Entity, Component >::operator[]
    entity_type operator[](const size_type pos) const ENTT_NOEXCEPT
    Returns the identifier that occupies the given position.
    Definition: view.hpp:587
    +
    entt::sparse_set::get
    size_type get(const entity_type entt) const ENTT_NOEXCEPT
    Returns the position of an entity in a sparse set.
    Definition: sparse_set.hpp:382
    entt
    EnTT default namespace.
    Definition: algorithm.hpp:10
    -
    entt::RuntimeView::const_iterator_type
    Iterator const_iterator_type
    Constant input iterator type.
    Definition: view.hpp:1706
    -
    entt::View< Entity, Component >::contains
    bool contains(const entity_type entity) const ENTT_NOEXCEPT
    Checks if a view contains an entity.
    Definition: view.hpp:1163
    -
    entt::SparseSet< Entity >::has
    bool has(const entity_type entity) const ENTT_NOEXCEPT
    Checks if a sparse set contains an entity.
    Definition: sparse_set.hpp:383
    -
    entt::View< Entity, Component >::raw_type
    typename pool_type::object_type raw_type
    Type of component iterated by the view.
    Definition: view.hpp:964
    -
    entt::RawView::data
    const entity_type * data() const ENTT_NOEXCEPT
    Direct access to the list of entities.
    Definition: view.hpp:1377
    -
    entt::View::end
    const_iterator_type end() const ENTT_NOEXCEPT
    Returns an iterator that is past the last entity that has the given components.
    Definition: view.hpp:733
    -
    entt::View< Entity, Component >::const_iterator_type
    typename view_type::const_iterator_type const_iterator_type
    Constant input iterator type.
    Definition: view.hpp:972
    -
    entt::SparseSet< Entity >::begin
    const_iterator_type begin() const ENTT_NOEXCEPT
    Returns an iterator to the beginning.
    Definition: sparse_set.hpp:298
    -
    entt::View::contains
    bool contains(const entity_type entity) const ENTT_NOEXCEPT
    Checks if a view contains an entity.
    Definition: view.hpp:761
    -
    entt::View< Entity, Component >::raw
    const raw_type * raw() const ENTT_NOEXCEPT
    Direct access to the list of components.
    Definition: view.hpp:1002
    -
    entt::PersistentView::end
    iterator_type end() ENTT_NOEXCEPT
    Returns an iterator that is past the last entity that has the given components.
    Definition: view.hpp:236
    -
    entt::PersistentView::begin
    const_iterator_type begin() const ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given components.
    Definition: view.hpp:161
    -
    entt::View::const_iterator_type
    Iterator const_iterator_type
    Constant input iterator type.
    Definition: view.hpp:625
    -
    entt::View< Entity, Component >::begin
    iterator_type begin() ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given component.
    Definition: view.hpp:1088
    -
    entt::PersistentView::cend
    const_iterator_type cend() const ENTT_NOEXCEPT
    Returns an iterator that is past the last entity that has the given components.
    Definition: view.hpp:198
    -
    entt::SparseSet
    Sparse set.
    Definition: sparse_set.hpp:29
    -
    entt::RawView::cbegin
    const_iterator_type cbegin() const ENTT_NOEXCEPT
    Returns an iterator to the first instance of the given type.
    Definition: view.hpp:1393
    -
    entt::View< Entity, Component >::each
    void each(Func func)
    Iterates entities and components and applies the given function object to them.
    Definition: view.hpp:1244
    -
    entt::RawView::each
    void each(Func func) const
    Iterates components and applies the given function object to them.
    Definition: view.hpp:1519
    -
    entt::SparseSet< Entity >::size_type
    std::size_t size_type
    Unsigned integer type.
    Definition: sparse_set.hpp:171
    -
    entt::View::empty
    bool empty() const ENTT_NOEXCEPT
    Checks if the view is definitely empty.
    Definition: view.hpp:639
    -
    entt::RuntimeView::iterator_type
    Iterator iterator_type
    Input iterator type.
    Definition: view.hpp:1704
    -
    entt::RawView::size
    size_type size() const ENTT_NOEXCEPT
    Returns the number of instances of the given type.
    Definition: view.hpp:1321
    -
    entt::RuntimeView::contains
    bool contains(const entity_type entity) const ENTT_NOEXCEPT
    Checks if a view contains an entity.
    Definition: view.hpp:1855
    -
    entt::View< Entity, Component >::data
    const entity_type * data() const ENTT_NOEXCEPT
    Direct access to the list of entities.
    Definition: view.hpp:1034
    -
    entt::RuntimeView::entity_type
    typename view_type::entity_type entity_type
    Underlying entity identifier.
    Definition: view.hpp:1700
    -
    entt::SparseSet< Entity >::entity_type
    Entity entity_type
    Underlying entity identifier.
    Definition: sparse_set.hpp:169
    -
    entt::SparseSet< Entity >::iterator_type
    Iterator iterator_type
    Input iterator type.
    Definition: sparse_set.hpp:173
    -
    entt::View< Entity, Component >::entity_type
    typename pool_type::entity_type entity_type
    Underlying entity identifier.
    Definition: view.hpp:966
    -
    entt::SparseSet< Entity >
    Basic sparse set implementation.
    Definition: sparse_set.hpp:60
    -
    entt::View::begin
    iterator_type begin() ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given components.
    Definition: view.hpp:694
    -
    entt::RawView::end
    const_iterator_type end() const ENTT_NOEXCEPT
    Returns an iterator that is past the last instance of the given type.
    Definition: view.hpp:1463
    -
    entt::View::end
    iterator_type end() ENTT_NOEXCEPT
    Returns an iterator that is past the last entity that has the given components.
    Definition: view.hpp:752
    -
    entt::RawView::cend
    const_iterator_type cend() const ENTT_NOEXCEPT
    Returns an iterator that is past the last instance of the given type.
    Definition: view.hpp:1444
    -
    entt::SparseSet< Entity >::const_iterator_type
    Iterator const_iterator_type
    Constant input iterator type.
    Definition: sparse_set.hpp:175
    -
    entt::View< Entity, Component >::cbegin
    const_iterator_type cbegin() const ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given component.
    Definition: view.hpp:1052
    -
    entt::View< Entity, Component >::each
    void each(Func func) const
    Iterates entities and components and applies the given function object to them.
    Definition: view.hpp:1222
    -
    entt::RuntimeView::end
    iterator_type end() ENTT_NOEXCEPT
    Returns an iterator that is past the last entity that has the given components.
    Definition: view.hpp:1846
    -
    entt::View::begin
    const_iterator_type begin() const ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given components.
    Definition: view.hpp:676
    -
    entt::View::iterator_type
    Iterator iterator_type
    Input iterator type.
    Definition: view.hpp:623
    -
    entt::View< Entity, Component >::empty
    bool empty() const ENTT_NOEXCEPT
    Checks whether the view is empty.
    Definition: view.hpp:986
    -
    entt::RuntimeView::each
    void each(Func func) const
    Iterates entities and applies the given function object to them.
    Definition: view.hpp:1877
    -
    entt::SparseSet< Entity >::size
    size_type size() const ENTT_NOEXCEPT
    Returns the number of elements in a sparse set.
    Definition: sparse_set.hpp:238
    -
    entt::View< Entity, Component >::begin
    const_iterator_type begin() const ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given component.
    Definition: view.hpp:1070
    -
    entt::PersistentView::iterator_type
    typename view_type::iterator_type iterator_type
    Input iterator type.
    Definition: view.hpp:93
    -
    entt::PersistentView::sort
    void sort()
    Sort the shared pool of entities according to the given component.
    Definition: view.hpp:414
    -
    entt::View< Entity, Component >::raw
    raw_type * raw() ENTT_NOEXCEPT
    Direct access to the list of components.
    Definition: view.hpp:1018
    -
    entt::RuntimeView::cbegin
    const_iterator_type cbegin() const ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given components.
    Definition: view.hpp:1738
    -
    entt::RawView::begin
    const_iterator_type begin() const ENTT_NOEXCEPT
    Returns an iterator to the first instance of the given type.
    Definition: view.hpp:1409
    -
    entt::RawView::raw_type
    typename pool_type::object_type raw_type
    Type of component iterated by the view.
    Definition: view.hpp:1307
    -
    entt::View< Entity, Component >::iterator_type
    typename view_type::iterator_type iterator_type
    Input iterator type.
    Definition: view.hpp:970
    -
    entt::View< Entity, Component >::size
    size_type size() const ENTT_NOEXCEPT
    Returns the number of entities that have the given component.
    Definition: view.hpp:978
    -
    entt::SparseSet< Entity >::cend
    const_iterator_type cend() const ENTT_NOEXCEPT
    Returns an iterator to the end.
    Definition: sparse_set.hpp:331
    -
    entt::View
    Multi component view.
    Definition: view.hpp:466
    -
    entt::RuntimeView::end
    const_iterator_type end() const ENTT_NOEXCEPT
    Returns an iterator that is past the last entity that has the given components.
    Definition: view.hpp:1827
    -
    entt::PersistentView
    Persistent view.
    Definition: view.hpp:71
    -
    entt::SparseSet< Entity >::get
    size_type get(const entity_type entity) const ENTT_NOEXCEPT
    Returns the position of an entity in a sparse set.
    Definition: sparse_set.hpp:425
    -
    entt::View< Entity, Component >::operator[]
    const entity_type & operator[](const size_type pos) const ENTT_NOEXCEPT
    Returns a reference to the element at the given position.
    Definition: view.hpp:1154
    -
    entt::RawView::operator[]
    const raw_type & operator[](const size_type pos) const ENTT_NOEXCEPT
    Returns a reference to the element at the given position.
    Definition: view.hpp:1491
    -
    entt::View::cbegin
    const_iterator_type cbegin() const ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given components.
    Definition: view.hpp:657
    -
    entt::RuntimeView::size_type
    typename view_type::size_type size_type
    Unsigned integer type.
    Definition: view.hpp:1702
    -
    entt::PersistentView::cbegin
    const_iterator_type cbegin() const ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given components.
    Definition: view.hpp:143
    -
    entt::RuntimeView::begin
    iterator_type begin() ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given components.
    Definition: view.hpp:1782
    -
    entt::SparseSet< Entity >::respect
    void respect(const SparseSet< Entity > &other) ENTT_NOEXCEPT
    Sort entities according to their order in another sparse set.
    Definition: sparse_set.hpp:520
    -
    entt::View< Entity, Component >::end
    iterator_type end() ENTT_NOEXCEPT
    Returns an iterator that is past the last entity that has the given component.
    Definition: view.hpp:1145
    -
    entt::View::each
    void each(Func func)
    Iterates entities and components and applies the given function object to them.
    Definition: view.hpp:901
    -
    entt::RawView::end
    iterator_type end() ENTT_NOEXCEPT
    Returns an iterator that is past the last instance of the given type.
    Definition: view.hpp:1482
    -
    entt::SparseSet< Entity >::data
    const entity_type * data() const ENTT_NOEXCEPT
    Direct access to the internal packed array.
    Definition: sparse_set.hpp:265
    -
    entt::SparseSet< Entity >::cbegin
    const_iterator_type cbegin() const ENTT_NOEXCEPT
    Returns an iterator to the beginning.
    Definition: sparse_set.hpp:281
    -
    entt::View< Entity, Component >::cend
    const_iterator_type cend() const ENTT_NOEXCEPT
    Returns an iterator that is past the last entity that has the given component.
    Definition: view.hpp:1107
    -
    entt::SparseSet< Entity >::end
    const_iterator_type end() const ENTT_NOEXCEPT
    Returns an iterator to the end.
    Definition: sparse_set.hpp:348
    -
    entt::PersistentView::begin
    iterator_type begin() ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given components.
    Definition: view.hpp:179
    -
    entt::View::each
    void each(Func func) const
    Iterates entities and components and applies the given function object to them.
    Definition: view.hpp:877
    -
    entt::RawView::size_type
    typename pool_type::size_type size_type
    Unsigned integer type.
    Definition: view.hpp:1311
    -
    entt::RuntimeView::cend
    const_iterator_type cend() const ENTT_NOEXCEPT
    Returns an iterator that is past the last entity that has the given components.
    Definition: view.hpp:1801
    -
    entt::PersistentView::data
    const entity_type * data() const ENTT_NOEXCEPT
    Direct access to the list of entities.
    Definition: view.hpp:125
    -
    entt::RawView::entity_type
    typename pool_type::entity_type entity_type
    Underlying entity identifier.
    Definition: view.hpp:1309
    -
    entt::View::entity_type
    typename view_type::entity_type entity_type
    Underlying entity identifier.
    Definition: view.hpp:619
    -
    entt::PersistentView::each
    void each(Func func) const
    Iterates entities and components and applies the given function object to them.
    Definition: view.hpp:368
    -
    entt::RuntimeView
    Runtime view.
    Definition: view.hpp:1590
    -
    entt::entt_traits
    Entity traits.
    Definition: entt_traits.hpp:18
    -
    entt::RawView::raw
    const raw_type * raw() const ENTT_NOEXCEPT
    Direct access to the list of components.
    Definition: view.hpp:1345
    -
    entt::PersistentView::size_type
    typename view_type::size_type size_type
    Unsigned integer type.
    Definition: view.hpp:91
    -
    entt::View::size
    size_type size() const ENTT_NOEXCEPT
    Estimates the number of entities that have the given components.
    Definition: view.hpp:631
    -
    entt::PersistentView::contains
    bool contains(const entity_type entity) const ENTT_NOEXCEPT
    Checks if a view contains an entity.
    Definition: view.hpp:254
    +
    entt::sparse_set::size_type
    std::size_t size_type
    Unsigned integer type.
    Definition: sparse_set.hpp:176
    +
    entt::storage
    Basic storage implementation.
    Definition: storage.hpp:692
    +
    entt::basic_view< Entity, Component >::iterator_type
    typename sparse_set< Entity >::iterator_type iterator_type
    Input iterator type.
    Definition: view.hpp:484
    +
    entt::basic_view::empty
    bool empty() const ENTT_NOEXCEPT
    Checks whether the pool of a given component is empty.
    Definition: view.hpp:224
    +
    entt::basic_view< Entity, Component >::raw
    raw_type * raw() const ENTT_NOEXCEPT
    Direct access to the list of components.
    Definition: view.hpp:514
    +
    entt::type_list_cat_t
    typename type_list_cat< List... >::type type_list_cat_t
    Helper type.
    Definition: type_traits.hpp:57
    +
    entt::basic_view::end
    iterator_type end() const ENTT_NOEXCEPT
    Returns an iterator that is past the last entity that has the given components.
    Definition: view.hpp:308
    +
    entt::basic_registry
    Fast and reliable entity-component system.
    Definition: fwd.hpp:13
    +
    entt::basic_view::iterator_type
    iterator iterator_type
    Input iterator type.
    Definition: view.hpp:197
    +
    entt::basic_view
    Multi component view.
    Definition: fwd.hpp:17
    +
    entt::sparse_set::entity_type
    Entity entity_type
    Underlying entity identifier.
    Definition: sparse_set.hpp:174
    +
    entt::type_list
    A class to use to push around lists of types, nothing more.
    Definition: type_traits.hpp:17
    +
    entt::basic_view::each
    void each(Func func) const
    Iterates entities and components and applies the given function object to them.
    Definition: view.hpp:386
    +
    entt::basic_view::contains
    bool contains(const entity_type entt) const ENTT_NOEXCEPT
    Checks if a view contains an entity.
    Definition: view.hpp:330
    +
    entt::basic_view::begin
    iterator_type begin() const ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given components.
    Definition: view.hpp:288
    +
    entt::basic_view::each
    void each(Func func) const
    Iterates entities and components and applies the given function object to them.
    Definition: view.hpp:422
    +
    entt::basic_view::size_type
    typename sparse_set< Entity >::size_type size_type
    Unsigned integer type.
    Definition: view.hpp:195
    +
    entt::basic_view::empty
    bool empty() const ENTT_NOEXCEPT
    Checks if the view is definitely empty.
    Definition: view.hpp:232
    +
    entt::basic_view< Entity, Component >::data
    const entity_type * data() const ENTT_NOEXCEPT
    Direct access to the list of entities.
    Definition: view.hpp:530
    +
    entt::basic_view::find
    iterator_type find(const entity_type entt) const ENTT_NOEXCEPT
    Finds an entity.
    Definition: view.hpp:319
    +
    entt::basic_view< Entity, Component >::size
    size_type size() const ENTT_NOEXCEPT
    Returns the number of entities that have the given component.
    Definition: view.hpp:490
    +
    entt::basic_view< Entity, Component >::empty
    bool empty() const ENTT_NOEXCEPT
    Checks whether the view is empty.
    Definition: view.hpp:498
    +
    entt::view
    basic_view< entity, Types... > view
    Alias declaration for the most common use case.
    Definition: fwd.hpp:73
    +
    entt::entity
    std::uint32_t entity
    Alias declaration for the most common use case.
    Definition: fwd.hpp:48
    +
    entt::basic_view::size
    size_type size() const ENTT_NOEXCEPT
    Returns the number of existing components of the given type.
    Definition: view.hpp:205
    +
    entt::basic_view< Entity, Component >::each
    void each(Func func) const
    Iterates entities and components and applies the given function object to them.
    Definition: view.hpp:644
    +
    entt::basic_view< Entity, Component >::end
    iterator_type end() const ENTT_NOEXCEPT
    Returns an iterator that is past the last entity that has the given component.
    Definition: view.hpp:567
    +
    entt::entt_traits
    Entity traits.
    Definition: entity.hpp:18
    +
    entt::operator!=
    constexpr bool operator!=(const hashed_string &lhs, const hashed_string &rhs) ENTT_NOEXCEPT
    Compares two hashed strings.
    Definition: hashed_string.hpp:195
    +
    entt::sparse_set::iterator_type
    iterator iterator_type
    Random access iterator type.
    Definition: sparse_set.hpp:178
    static std::weak_ptr<Service> entt::ServiceLocator< Service >::get static std::weak_ptr<Service> entt::service_locator< Service >::get ( ) - + @@ -229,12 +229,12 @@ template<typename Service>
    Warning
    In case no service implementation has been set, a call to this function results in undefined behavior.
    Returns
    A reference to the service implementation currently set, if any.
    -

    Definition at line 71 of file locator.hpp.

    +

    Definition at line 70 of file locator.hpp.

    - -

    ◆ reset()

    + +

    ◆ reset()

    @@ -245,7 +245,7 @@ template<typename Service>
    @@ -59,32 +59,39 @@ $(function() {
    -Static Public Member Functions | -List of all members
    +Public Types | +List of all members
    -
    entt::internal::TypeHelper< void > Struct Template Reference
    +
    entt::type_list_unique< type_list<> > Struct Template Reference
    + +

    Removes duplicates types from a type list. + More...

    + +

    #include <type_traits.hpp>

    static Service& entt::ServiceLocator< Service >::ref static Service& entt::service_locator< Service >::ref ( ) - + @@ -261,12 +261,12 @@ template<typename Service>

    Resets a service.

    The service is no longer valid after a reset.

    -

    Definition at line 100 of file locator.hpp.

    +

    Definition at line 99 of file locator.hpp.

    - -

    ◆ set() [1/2]

    + +

    ◆ set() [1/2]

    @@ -279,7 +279,7 @@ template<typename Impl = Service, typename... Args>
    @@ -59,22 +59,28 @@ $(function() {
    -
    entt::internal::FunctionHelper< typename > Struct Template Reference
    +
    entt::type_list_unique< typename > Struct Template Reference
    + +

    Primary template isn't defined on purpose. + More...

    + +

    #include <type_traits.hpp>

    Detailed Description

    template<typename>
    -struct entt::internal::FunctionHelper< typename >

    +struct entt::type_list_unique< typename > +

    Primary template isn't defined on purpose.

    -

    Definition at line 658 of file meta.hpp.

    +

    Definition at line 62 of file type_traits.hpp.

    The documentation for this struct was generated from the following file:
    diff --git a/structentt_1_1type__list__unique_3_01type__list_3_01Type_00_01Other_8_8_8_01_4_01_4-members.html b/structentt_1_1type__list__unique_3_01type__list_3_01Type_00_01Other_8_8_8_01_4_01_4-members.html new file mode 100644 index 000000000..4fc2b3fdf --- /dev/null +++ b/structentt_1_1type__list__unique_3_01type__list_3_01Type_00_01Other_8_8_8_01_4_01_4-members.html @@ -0,0 +1,82 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
    +
    +
    static void entt::ServiceLocator< Service >::reset static void entt::service_locator< Service >::reset ( ) - + @@ -308,12 +308,12 @@ template<typename Impl = Service, typename... Args> -

    Definition at line 82 of file locator.hpp.

    +

    Definition at line 81 of file locator.hpp.

    - -

    ◆ set() [2/2]

    + +

    ◆ set() [2/2]

    @@ -324,7 +324,7 @@ template<typename Service>
    @@ -59,7 +59,7 @@ $(function() {
    @@ -67,76 +67,73 @@ $(function() { Public Types | Public Member Functions | Friends | -List of all members
    +List of all members
    -
    entt::SigH< Ret(Args...), Collector > Class Template Referencefinal
    +
    entt::sigh< Ret(Args...), Collector > Struct Template Reference

    Unmanaged signal handler definition. - More...

    + More...

    #include <sigh.hpp>

    -Inheritance diagram for entt::SigH< Ret(Args...), Collector >:
    +Inheritance diagram for entt::sigh< Ret(Args...), Collector >:
    -
    Inheritance graph
    +
    Inheritance graph
    [legend]
    -Collaboration diagram for entt::SigH< Ret(Args...), Collector >:
    +Collaboration diagram for entt::sigh< Ret(Args...), Collector >:
    -
    Collaboration graph
    +
    Collaboration graph
    [legend]
    static void entt::ServiceLocator< Service >::set static void entt::service_locator< Service >::set ( Args &&...  args) - + @@ -346,7 +346,7 @@ template<typename Service> -

    Definition at line 90 of file locator.hpp.

    +

    Definition at line 89 of file locator.hpp.

    diff --git a/classentt_1_1SigH.html b/structentt_1_1sigh.html similarity index 82% rename from classentt_1_1SigH.html rename to structentt_1_1sigh.html index f05ffecb7..c1ae22a33 100644 --- a/classentt_1_1SigH.html +++ b/structentt_1_1sigh.html @@ -5,7 +5,7 @@ -EnTT: entt::SigH< Function, Collector > Class Template Reference +EnTT: entt::sigh< typename, typename > Class Template Reference @@ -22,7 +22,7 @@ @@ -59,22 +59,22 @@ $(function() {
    -
    entt::SigH< Function, Collector > Class Template Reference
    +
    entt::sigh< typename, typename > Class Template Reference

    Unmanaged signal handler declaration. - More...

    + More...

    #include <sigh.hpp>

    Detailed Description

    -

    template<typename Function, typename Collector = internal::DefaultCollectorType<Function>>
    -class entt::SigH< Function, Collector >

    +

    template<typename, typename>
    +class entt::sigh< typename, typename >

    Unmanaged signal handler declaration.

    Primary template isn't defined on purpose. All the specializations give a compile-time error unless the template parameter is a function type.

    @@ -86,9 +86,9 @@ class entt::SigH< Function, Collector > -

    Definition at line 121 of file sigh.hpp.

    +

    Definition at line 21 of file fwd.hpp.

    The documentation for this class was generated from the following file:
    diff --git a/structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4-members.html b/structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4-members.html new file mode 100644 index 000000000..5503a4ef9 --- /dev/null +++ b/structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4-members.html @@ -0,0 +1,91 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
    +
    +
    static void entt::ServiceLocator< Service >::set static void entt::service_locator< Service >::set ( std::shared_ptr< Service >  ptr)
    EnTT -  2.7.3 +  3.0.0
    + + + + + +
    +
    EnTT +  3.0.0 +
    +
    + + + + + + + + + +
    +
    + + +
    + +
    + + + +
    +
    +
    entt::sigh< Ret(Args...), Collector > Member List
    +
    +
    + +

    This is the complete list of members for entt::sigh< Ret(Args...), Collector >, including all inherited members.

    + + + + + + + + + + + +
    collect(Args... args) constentt::sigh< Ret(Args...), Collector >inline
    collector_type typedefentt::sigh< Ret(Args...), Collector >
    empty() const ENTT_NOEXCEPTentt::sigh< Ret(Args...), Collector >inline
    instance_type typedefentt::sigh< Ret(Args...), Collector >
    publish(Args... args) constentt::sigh< Ret(Args...), Collector >inline
    sink() ENTT_NOEXCEPTentt::sigh< Ret(Args...), Collector >inline
    sink_type typedefentt::sigh< Ret(Args...), Collector >
    size() const ENTT_NOEXCEPTentt::sigh< Ret(Args...), Collector >inline
    size_type typedefentt::sigh< Ret(Args...), Collector >
    swap(sigh &lhs, sigh &rhs)entt::sigh< Ret(Args...), Collector >friend
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html b/structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html similarity index 51% rename from classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html rename to structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html index 7ef7d6647..fcfdb8d61 100644 --- a/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html +++ b/structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html @@ -5,7 +5,7 @@ -EnTT: entt::SigH< Ret(Args...), Collector > Class Template Reference +EnTT: entt::sigh< Ret(Args...), Collector > Struct Template Reference @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    - - - - - - - - - - - - - + + + + + + + + + + + + +

    Public Types

    -using size_type = typename std::vector< call_type >::size_type
     Unsigned integer type.
     
    -using collector_type = Collector
     Collector type.
     
    -using sink_type = Sink< Ret(Args...)>
     Sink type.
     
    template<typename Class >
    using instance_type = Class *
     Instance type when it comes to connecting member functions. More...
     
    +using size_type = typename std::vector< delegate< Ret(Args...)> >::size_type
     Unsigned integer type.
     
    +using collector_type = Collector
     Collector type.
     
    +using sink_type = entt::sink< Ret(Args...)>
     Sink type.
     
    template<typename Class >
    using instance_type = Class *
     Instance type when it comes to connecting member functions. More...
     
    - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + +

    Public Member Functions

    size_type size () const ENTT_NOEXCEPT
     Number of listeners connected to the signal. More...
     
    bool empty () const ENTT_NOEXCEPT
     Returns false if at least a listener is connected to the signal. More...
     
    sink_type sink () ENTT_NOEXCEPT
     Returns a sink object for the given signal. More...
     
    void publish (Args... args) const
     Triggers a signal. More...
     
    collector_type collect (Args... args) const
     Collects return values from the listeners. More...
     
    bool operator== (const SigH &other) const ENTT_NOEXCEPT
     Checks if the contents of the two signals are identical. More...
     
    size_type size () const ENTT_NOEXCEPT
     Number of listeners connected to the signal. More...
     
    bool empty () const ENTT_NOEXCEPT
     Returns false if at least a listener is connected to the signal. More...
     
    sink_type sink () ENTT_NOEXCEPT
     Returns a sink object for the given signal. More...
     
    void publish (Args... args) const
     Triggers a signal. More...
     
    collector_type collect (Args... args) const
     Collects return values from the listeners. More...
     
    - - - + + +

    Friends

    void swap (SigH &lhs, SigH &rhs)
     Swaps listeners between the two signals. More...
     
    void swap (sigh &lhs, sigh &rhs)
     Swaps listeners between the two signals. More...
     

    Detailed Description

    template<typename Ret, typename... Args, typename Collector>
    -class entt::SigH< Ret(Args...), Collector >

    +struct entt::sigh< Ret(Args...), Collector >

    Unmanaged signal handler definition.

    Unmanaged signal handler. It works directly with naked pointers to classes and pointers to member functions as well as pointers to free functions. Users of this class are in charge of disconnecting instances before deleting them.

    @@ -159,10 +156,10 @@ class entt::SigH< Ret(Args...), Collector > -

    Definition at line 299 of file sigh.hpp.

    +

    Definition at line 264 of file sigh.hpp.

    Member Typedef Documentation

    - -

    ◆ instance_type

    + +

    ◆ instance_type

    @@ -172,7 +169,7 @@ template<typename Ret , typename... Args, typename Collector >
    template<typename Class >
    - +
    using entt::SigH< Ret(Args...), Collector >::instance_type = Class *using entt::sigh< Ret(Args...), Collector >::instance_type = Class *
    @@ -185,13 +182,13 @@ template<typename Class >
    -

    Definition at line 315 of file sigh.hpp.

    +

    Definition at line 277 of file sigh.hpp.

    Member Function Documentation

    - -

    ◆ collect()

    + +

    ◆ collect()

    @@ -202,7 +199,7 @@ template<typename Ret , typename... Args, typename Collector >
    		- + @@ -225,12 +222,12 @@ template<typename Ret , typename... Args, typename Collector >
    Returns
    An instance of the collector filled with collected data.
    -

    Definition at line 365 of file sigh.hpp.

    +

    Definition at line 327 of file sigh.hpp.

    - -

    ◆ empty()

    + +

    ◆ empty()

    @@ -241,7 +238,7 @@ template<typename Ret , typename... Args, typename Collector >
    @@ -59,33 +59,45 @@ $(function() {
    -Static Public Member Functions | -List of all members
    +Public Types | +List of all members
    -
    entt::internal::CtorHelper< Type, Args > Struct Template Reference
    +
    entt::type_list_cat< type_list< Type... > > Struct Template Reference
    + +

    Concatenates multiple type lists. + More...

    + +

    #include <type_traits.hpp>

    collector_type entt::SigH< Ret(Args...), Collector >::collect collector_type entt::sigh< Ret(Args...), Collector >::collect ( Args...  args) - + @@ -257,12 +254,12 @@ template<typename Ret , typename... Args, typename Collector >

    Returns false if at least a listener is connected to the signal.

    Returns
    True if the signal has no listeners connected, false otherwise.
    -

    Definition at line 329 of file sigh.hpp.

    +

    Definition at line 291 of file sigh.hpp.

    - -

    ◆ operator==()

    + +

    ◆ publish()

    @@ -273,47 +270,7 @@ template<typename Ret , typename... Args, typename Collector >
    - - -
    bool entt::SigH< Ret(Args...), Collector >::empty bool entt::sigh< Ret(Args...), Collector >::empty ( ) const - - - - - - -
    bool entt::SigH< Ret(Args...), Collector >::operator== (const SigH< Ret(Args...), Collector > & other) const
    -     		-inline
    -
    - -

    Checks if the contents of the two signals are identical.

    -

    Two signals are identical if they have the same size and the same listeners registered exactly in the same order.

    -
    Parameters
    - - -
    otherSignal with which to compare.
    -
    -
    -
    Returns
    True if the two signals are identical, false otherwise.
    - -

    Definition at line 396 of file sigh.hpp.

    - -
    - - -

    ◆ publish()

    - -
    -
    -
    -template<typename Ret , typename... Args, typename Collector >
    - - - @@ -59,25 +59,28 @@ $(function() {
    -
    entt::tag_t Struct Referencefinal
    +
    entt::type_list_cat<... > Struct Template Reference
    -

    Tag class type used to disambiguate overloads. - More...

    +

    Primary template isn't defined on purpose. + More...

    -

    #include <utility.hpp>

    +

    #include <type_traits.hpp>

    Detailed Description

    -

    Tag class type used to disambiguate overloads.

    +

    template<typename...>
    +struct entt::type_list_cat<... >

    -

    Definition at line 9 of file utility.hpp.

    +

    Primary template isn't defined on purpose.

    + +

    Definition at line 25 of file type_traits.hpp.

    The documentation for this struct was generated from the following file:
    diff --git a/structentt_1_1type__list__cat_3_01type__list_3_01Type_8_8_8_01_4_00_01type__list_3_01Other_8_8_8_01_4_00_01List_8_8_8_01_4.html b/structentt_1_1type__list__cat_3_01type__list_3_01Type_8_8_8_01_4_00_01type__list_3_01Other_8_8_8_01_4_00_01List_8_8_8_01_4.html new file mode 100644 index 000000000..4056f05b9 --- /dev/null +++ b/structentt_1_1type__list__cat_3_01type__list_3_01Type_8_8_8_01_4_00_01type__list_3_01Other_8_8_8_01_4_00_01List_8_8_8_01_4.html @@ -0,0 +1,112 @@ + + + + + + + +EnTT: entt::type_list_cat< type_list< Type... >, type_list< Other... >, List... > Struct Template Reference + + + + + + + + + +
    +
    +
    - - - + @@ -336,12 +293,12 @@ template<typename Ret , typename... Args, typename Collector > -

    Definition at line 353 of file sigh.hpp.

    +

    Definition at line 315 of file sigh.hpp.

    - -

    ◆ sink()

    + +

    ◆ sink()

    @@ -352,7 +309,7 @@ template<typename Ret , typename... Args, typename Collector >

    Definition at line 21 of file algorithm.hpp.

    Member Function Documentation

    - -

    ◆ operator()()

    + +

    ◆ operator()()

    @@ -102,7 +102,7 @@ template<typename It , typename Compare = std::less<>, typename... Arg
    @@ -59,32 +59,45 @@ $(function() {
    -Static Public Member Functions | -List of all members
    +Static Public Attributes | +List of all members
    -
    entt::internal::TypeHelper< Type > Struct Template Reference
    +
    entt::type_list< Type > Struct Template Reference
    + +

    A class to use to push around lists of types, nothing more. + More...

    + +

    #include <type_traits.hpp>

    void entt::SigH< Ret(Args...), Collector >::publish void entt::sigh< Ret(Args...), Collector >::publish ( Args...  args) - + @@ -370,12 +327,12 @@ template<typename Ret , typename... Args, typename Collector > The function type for a listener is the one of the signal to which it belongs. The order of invocation of the listeners isn't guaranteed.

    Returns
    A temporary sink object.
    -

    Definition at line 342 of file sigh.hpp.

    +

    Definition at line 304 of file sigh.hpp.

    - -

    ◆ size()

    + +

    ◆ size()

    @@ -386,7 +343,7 @@ template<typename Ret , typename... Args, typename Collector >
    @@ -59,29 +59,29 @@ $(function() {
    Public Member Functions | -List of all members
    +List of all members
    -
    entt::StdSort Struct Referencefinal
    +
    entt::std_sort Struct Reference

    Function object to wrap std::sort in a class type. - More...

    + More...

    #include <algorithm.hpp>

    sink_type entt::SigH< Ret(Args...), Collector >::sink sink_type entt::sigh< Ret(Args...), Collector >::sink ( ) - + @@ -402,13 +359,13 @@ template<typename Ret , typename... Args, typename Collector >

    Number of listeners connected to the signal.

    Returns
    Number of listeners currently connected.
    -

    Definition at line 321 of file sigh.hpp.

    +

    Definition at line 283 of file sigh.hpp.

    Friends And Related Function Documentation

    - -

    ◆ swap

    + +

    ◆ swap

    @@ -421,13 +378,13 @@ template<typename Ret , typename... Args, typename Collector >
    - + - + @@ -452,11 +409,11 @@ template<typename Ret , typename... Args, typename Collector > -

    Definition at line 382 of file sigh.hpp.

    +

    Definition at line 344 of file sigh.hpp.

    -
    The documentation for this class was generated from the following file:
      +
      The documentation for this struct was generated from the following file: diff --git a/structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__coll__graph.map b/structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__coll__graph.map new file mode 100644 index 000000000..4e227cf0b --- /dev/null +++ b/structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__coll__graph.map @@ -0,0 +1,2 @@ + + diff --git a/structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__coll__graph.md5 b/structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__coll__graph.md5 new file mode 100644 index 000000000..2b0bf6c10 --- /dev/null +++ b/structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__coll__graph.md5 @@ -0,0 +1 @@ +7f8d8e17cea628875b39c1e0ba7d258f \ No newline at end of file diff --git a/structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__coll__graph.png b/structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__coll__graph.png new file mode 100644 index 000000000..e14a36d3e Binary files /dev/null and b/structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__coll__graph.png differ diff --git a/structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__inherit__graph.map b/structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__inherit__graph.map new file mode 100644 index 000000000..4e227cf0b --- /dev/null +++ b/structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__inherit__graph.map @@ -0,0 +1,2 @@ + + diff --git a/structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__inherit__graph.md5 b/structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__inherit__graph.md5 new file mode 100644 index 000000000..c88df227d --- /dev/null +++ b/structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__inherit__graph.md5 @@ -0,0 +1 @@ +7f7f0c463445dcfc481242c77d72f687 \ No newline at end of file diff --git a/structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__inherit__graph.png b/structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__inherit__graph.png new file mode 100644 index 000000000..e14a36d3e Binary files /dev/null and b/structentt_1_1sigh_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__inherit__graph.png differ diff --git a/structentt_1_1OneShotBubbleSort-members.html b/structentt_1_1std__sort-members.html similarity index 82% rename from structentt_1_1OneShotBubbleSort-members.html rename to structentt_1_1std__sort-members.html index e4365cf4b..299d4665f 100644 --- a/structentt_1_1OneShotBubbleSort-members.html +++ b/structentt_1_1std__sort-members.html @@ -22,7 +22,7 @@
    @@ -59,18 +59,18 @@ $(function() {
    -
    entt::OneShotBubbleSort Member List
    +
    entt::std_sort Member List
    -

    This is the complete list of members for entt::OneShotBubbleSort, including all inherited members.

    +

    This is the complete list of members for entt::std_sort, including all inherited members.

    size_type entt::SigH< Ret(Args...), Collector >::size size_type entt::sigh< Ret(Args...), Collector >::size ( ) const
    void swap (SigH< Ret(Args...), Collector > & sigh< Ret(Args...), Collector > &  lhs,
    SigH< Ret(Args...), Collector > & sigh< Ret(Args...), Collector > &  rhs 
    EnTT -  2.7.3 +  3.0.0
    - +
    operator()(It first, It last, Compare compare=Compare{}) constentt::OneShotBubbleSortinline
    operator()(It first, It last, Compare compare=Compare{}, Args &&... args) constentt::std_sortinline
    diff --git a/structentt_1_1StdSort.html b/structentt_1_1std__sort.html similarity index 84% rename from structentt_1_1StdSort.html rename to structentt_1_1std__sort.html index 147bef490..db29c4ff7 100644 --- a/structentt_1_1StdSort.html +++ b/structentt_1_1std__sort.html @@ -5,7 +5,7 @@ -EnTT: entt::StdSort Struct Reference +EnTT: entt::std_sort Struct Reference @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    - - - - + + + +

    Public Member Functions

    template<typename It , typename Compare = std::less<>, typename... Args>
    void operator() (It first, It last, Compare compare=Compare{}, Args &&... args) const
     Sorts the elements in a range. More...
     
    template<typename It , typename Compare = std::less<>, typename... Args>
    void operator() (It first, It last, Compare compare=Compare{}, Args &&... args) const
     Sorts the elements in a range. More...
     

    Detailed Description

    Function object to wrap std::sort in a class type.

    @@ -90,8 +90,8 @@ Public Member Functions
    - + diff --git a/structentt_1_1storage-members.html b/structentt_1_1storage-members.html new file mode 100644 index 000000000..2ed1fcd6d --- /dev/null +++ b/structentt_1_1storage-members.html @@ -0,0 +1,121 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
    +
    +
    void entt::StdSort::operator() void entt::std_sort::operator() ( It  first,
    + + + + + +
    +
    EnTT +  3.0.0 +
    +
    + + + + + + + + + +
    +
    + + +
    + +
    + + + +
    +
    +
    entt::storage< Entity, Type > Member List
    +
    +
    + +

    This is the complete list of members for entt::storage< Entity, Type >, including all inherited members.

    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    batch(It first, It last)entt::basic_storage< Entity, Type, typename >inline
    begin() const ENTT_NOEXCEPTentt::basic_storage< Entity, Type, typename >inline
    begin() ENTT_NOEXCEPTentt::basic_storage< Entity, Type, typename >inline
    capacity() const ENTT_NOEXCEPTentt::sparse_set< Entity >inline
    cbegin() const ENTT_NOEXCEPTentt::basic_storage< Entity, Type, typename >inline
    cend() const ENTT_NOEXCEPTentt::basic_storage< Entity, Type, typename >inline
    const_iterator_type typedefentt::basic_storage< Entity, Type, typename >
    construct(const entity_type entt, Args &&... args)entt::basic_storage< Entity, Type, typename >inline
    entt::sparse_set::construct(const entity_type entt)entt::sparse_set< Entity >inline
    data() const ENTT_NOEXCEPTentt::sparse_set< Entity >inline
    destroy(const entity_type entt) overrideentt::basic_storage< Entity, Type, typename >inlinevirtual
    empty() const ENTT_NOEXCEPTentt::sparse_set< Entity >inline
    end() const ENTT_NOEXCEPTentt::basic_storage< Entity, Type, typename >inline
    end() ENTT_NOEXCEPTentt::basic_storage< Entity, Type, typename >inline
    entity_type typedefentt::basic_storage< Entity, Type, typename >
    extent() const ENTT_NOEXCEPTentt::sparse_set< Entity >inline
    find(const entity_type entt) const ENTT_NOEXCEPTentt::sparse_set< Entity >inline
    get(const entity_type entt) const ENTT_NOEXCEPTentt::basic_storage< Entity, Type, typename >inline
    get(const entity_type entt) ENTT_NOEXCEPTentt::basic_storage< Entity, Type, typename >inline
    has(const entity_type entt) const ENTT_NOEXCEPTentt::sparse_set< Entity >inline
    iterator_type typedefentt::basic_storage< Entity, Type, typename >
    object_type typedefentt::basic_storage< Entity, Type, typename >
    operator=(const sparse_set &other)entt::sparse_set< Entity >inline
    operator=(sparse_set &&)=defaultentt::sparse_set< Entity >
    raw() const ENTT_NOEXCEPTentt::basic_storage< Entity, Type, typename >inline
    raw() ENTT_NOEXCEPTentt::basic_storage< Entity, Type, typename >inline
    reserve(const size_type cap) overrideentt::basic_storage< Entity, Type, typename >inlinevirtual
    reset() overrideentt::basic_storage< Entity, Type, typename >inlinevirtual
    respect(const sparse_set< Entity > &other) ENTT_NOEXCEPT overrideentt::basic_storage< Entity, Type, typename >inlinevirtual
    shrink_to_fit() overrideentt::basic_storage< Entity, Type, typename >inlinevirtual
    size() const ENTT_NOEXCEPTentt::sparse_set< Entity >inline
    size_type typedefentt::basic_storage< Entity, Type, typename >
    sort(Compare compare, Sort algo=Sort{}, Args &&... args)entt::basic_storage< Entity, Type, typename >inline
    sparse_set()=defaultentt::sparse_set< Entity >
    sparse_set(const sparse_set &other)entt::sparse_set< Entity >inline
    sparse_set(sparse_set &&)=defaultentt::sparse_set< Entity >
    swap(const size_type lhs, const size_type rhs) ENTT_NOEXCEPTentt::sparse_set< Entity >inline
    try_get(const entity_type entt) const ENTT_NOEXCEPTentt::basic_storage< Entity, Type, typename >inline
    try_get(const entity_type entt) ENTT_NOEXCEPTentt::basic_storage< Entity, Type, typename >inline
    ~sparse_set() ENTT_NOEXCEPT=defaultentt::sparse_set< Entity >virtual
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/structentt_1_1storage.html b/structentt_1_1storage.html new file mode 100644 index 000000000..518781398 --- /dev/null +++ b/structentt_1_1storage.html @@ -0,0 +1,292 @@ + + + + + + + +EnTT: entt::storage< Entity, Type > Struct Template Reference + + + + + + + + + +
    +
    + + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +List of all members
    +
    +
    entt::storage< Entity, Type > Struct Template Reference
    +
    +
    + +

    Basic storage implementation. + More...

    + +

    #include <storage.hpp>

    +
    +Inheritance diagram for entt::storage< Entity, Type >:
    +
    +
    Inheritance graph
    + + + + +
    [legend]
    +
    +Collaboration diagram for entt::storage< Entity, Type >:
    +
    +
    Collaboration graph
    + + + + +
    [legend]
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    +Additional Inherited Members

    - Public Types inherited from entt::basic_storage< Entity, Type, typename >
    +using object_type = Type
     Type of the objects associated with the entities.
     
    +using entity_type = typename underlying_type::entity_type
     Underlying entity identifier.
     
    +using size_type = typename underlying_type::size_type
     Unsigned integer type.
     
    +using iterator_type = iterator< false >
     Random access iterator type.
     
    +using const_iterator_type = iterator< true >
     Constant random access iterator type.
     
    - Public Types inherited from entt::sparse_set< Entity >
    +using entity_type = Entity
     Underlying entity identifier.
     
    +using size_type = std::size_t
     Unsigned integer type.
     
    +using iterator_type = iterator
     Random access iterator type.
     
    - Public Member Functions inherited from entt::basic_storage< Entity, Type, typename >
    void reserve (const size_type cap) override
     Increases the capacity of a storage. More...
     
    +void shrink_to_fit () override
     Requests the removal of unused capacity.
     
    const object_type * raw () const ENTT_NOEXCEPT
     Direct access to the array of objects. More...
     
    object_type * raw () ENTT_NOEXCEPT
     Direct access to the array of objects. More...
     
    const_iterator_type cbegin () const ENTT_NOEXCEPT
     Returns an iterator to the beginning. More...
     
    const_iterator_type begin () const ENTT_NOEXCEPT
     Returns an iterator to the beginning. More...
     
    iterator_type begin () ENTT_NOEXCEPT
     Returns an iterator to the beginning. More...
     
    const_iterator_type cend () const ENTT_NOEXCEPT
     Returns an iterator to the end. More...
     
    const_iterator_type end () const ENTT_NOEXCEPT
     Returns an iterator to the end. More...
     
    iterator_type end () ENTT_NOEXCEPT
     Returns an iterator to the end. More...
     
    const object_type & get (const entity_type entt) const ENTT_NOEXCEPT
     Returns the object associated with an entity. More...
     
    object_type & get (const entity_type entt) ENTT_NOEXCEPT
     Returns the object associated with an entity. More...
     
    const object_type * try_get (const entity_type entt) const ENTT_NOEXCEPT
     Returns a pointer to the object associated with an entity, if any. More...
     
    object_type * try_get (const entity_type entt) ENTT_NOEXCEPT
     Returns a pointer to the object associated with an entity, if any. More...
     
    template<typename... Args>
    object_type & construct (const entity_type entt, Args &&... args)
     Assigns an entity to a storage and constructs its object. More...
     
    template<typename It >
    object_type * batch (It first, It last)
     Assigns one or more entities to a storage and constructs their objects. More...
     
    void destroy (const entity_type entt) override
     Removes an entity from a storage and destroys its object. More...
     
    template<typename Compare , typename Sort = std_sort, typename... Args>
    void sort (Compare compare, Sort algo=Sort{}, Args &&... args)
     Sort instances according to the given comparison function. More...
     
    void respect (const sparse_set< Entity > &other) ENTT_NOEXCEPT override
     Sort instances according to the order of the entities in another sparse set. More...
     
    +void reset () override
     Resets a storage.
     
    - Public Member Functions inherited from entt::sparse_set< Entity >
    + sparse_set ()=default
     Default constructor.
     
     sparse_set (const sparse_set &other)
     Copy constructor. More...
     
    + sparse_set (sparse_set &&)=default
     Default move constructor.
     
    +virtual ~sparse_set () ENTT_NOEXCEPT=default
     Default destructor.
     
    sparse_set & operator= (const sparse_set &other)
     Copy assignment operator. More...
     
    sparse_set & operator= (sparse_set &&)=default
     Default move assignment operator. More...
     
    size_type capacity () const ENTT_NOEXCEPT
     Returns the number of elements that a sparse set has currently allocated space for. More...
     
    size_type extent () const ENTT_NOEXCEPT
     Returns the extent of a sparse set. More...
     
    size_type size () const ENTT_NOEXCEPT
     Returns the number of elements in a sparse set. More...
     
    bool empty () const ENTT_NOEXCEPT
     Checks whether a sparse set is empty. More...
     
    const entity_type * data () const ENTT_NOEXCEPT
     Direct access to the internal packed array. More...
     
    iterator_type begin () const ENTT_NOEXCEPT
     Returns an iterator to the beginning. More...
     
    iterator_type end () const ENTT_NOEXCEPT
     Returns an iterator to the end. More...
     
    iterator_type find (const entity_type entt) const ENTT_NOEXCEPT
     Finds an entity. More...
     
    bool has (const entity_type entt) const ENTT_NOEXCEPT
     Checks if a sparse set contains an entity. More...
     
    size_type get (const entity_type entt) const ENTT_NOEXCEPT
     Returns the position of an entity in a sparse set. More...
     
    void construct (const entity_type entt)
     Assigns an entity to a sparse set. More...
     
    template<typename It >
    void batch (It first, It last)
     Assigns one or more entities to a sparse set. More...
     
    void swap (const size_type lhs, const size_type rhs) ENTT_NOEXCEPT
     Swaps the position of two entities in the internal packed array. More...
     
    +

    Detailed Description

    +

    template<typename Entity, typename Type>
    +struct entt::storage< Entity, Type >

    + +

    Basic storage implementation.

    +

    This class is a refinement of a sparse set that associates an object to an entity. The main purpose of this class is to extend sparse sets to store components in a registry. It guarantees fast access both to the elements and to the entities.

    +
    Note
    Entities and objects have the same order. It's guaranteed both in case of raw access (either to entities or objects) and when using input iterators.
    +
    +Internal data structures arrange elements to maximize performance. Because of that, there are no guarantees that elements have the expected order when iterate directly the internal packed array (see raw and size member functions for that). Use begin and end instead.
    +
    Warning
    Empty types aren't explicitly instantiated. Temporary objects are returned in place of the instances of the components and raw access isn't available for them.
    +
    See also
    sparse_set<Entity>
    +
    Template Parameters
    + + + +
    EntityA valid entity type (see entt_traits for more details).
    TypeType of objects assigned to the entities.
    +
    +
    + +

    Definition at line 692 of file storage.hpp.

    +
    The documentation for this struct was generated from the following file: +
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/structentt_1_1storage__coll__graph.map b/structentt_1_1storage__coll__graph.map new file mode 100644 index 000000000..61d770ab3 --- /dev/null +++ b/structentt_1_1storage__coll__graph.map @@ -0,0 +1,4 @@ + + + + diff --git a/structentt_1_1storage__coll__graph.md5 b/structentt_1_1storage__coll__graph.md5 new file mode 100644 index 000000000..df4f1c11f --- /dev/null +++ b/structentt_1_1storage__coll__graph.md5 @@ -0,0 +1 @@ +e5ba0f67ea6b5a7197c757a644fb560b \ No newline at end of file diff --git a/structentt_1_1storage__coll__graph.png b/structentt_1_1storage__coll__graph.png new file mode 100644 index 000000000..864933759 Binary files /dev/null and b/structentt_1_1storage__coll__graph.png differ diff --git a/structentt_1_1storage__inherit__graph.map b/structentt_1_1storage__inherit__graph.map new file mode 100644 index 000000000..61d770ab3 --- /dev/null +++ b/structentt_1_1storage__inherit__graph.map @@ -0,0 +1,4 @@ + + + + diff --git a/structentt_1_1storage__inherit__graph.md5 b/structentt_1_1storage__inherit__graph.md5 new file mode 100644 index 000000000..75bd81043 --- /dev/null +++ b/structentt_1_1storage__inherit__graph.md5 @@ -0,0 +1 @@ +87d4821aa2cab92dde5366cd6135b021 \ No newline at end of file diff --git a/structentt_1_1storage__inherit__graph.png b/structentt_1_1storage__inherit__graph.png new file mode 100644 index 000000000..864933759 Binary files /dev/null and b/structentt_1_1storage__inherit__graph.png differ diff --git a/structentt_1_1type__list-members.html b/structentt_1_1type__list-members.html new file mode 100644 index 000000000..563321d1b --- /dev/null +++ b/structentt_1_1type__list-members.html @@ -0,0 +1,82 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
    +
    + + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +
    entt::type_list< Type > Member List
    +
    +
    + +

    This is the complete list of members for entt::type_list< Type >, including all inherited members.

    + + +
    sizeentt::type_list< Type >static
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/structentt_1_1internal_1_1TypeHelper.html b/structentt_1_1type__list.html similarity index 59% rename from structentt_1_1internal_1_1TypeHelper.html rename to structentt_1_1type__list.html index 3b44c23cb..9e0779b66 100644 --- a/structentt_1_1internal_1_1TypeHelper.html +++ b/structentt_1_1type__list.html @@ -5,7 +5,7 @@ -EnTT: entt::internal::TypeHelper< Type > Struct Template Reference +EnTT: entt::type_list< Type > Struct Template Reference @@ -22,7 +22,7 @@
    EnTT -  2.7.2 +  3.0.0
    - - - + + + +

    -Static Public Member Functions

    -static void destroy (void *instance)
     

    +Static Public Attributes

    +static constexpr auto size = sizeof...(Type)
     Unsigned integer type.
     

    Detailed Description

    -

    template<typename Type>
    -struct entt::internal::TypeHelper< Type >

    +

    template<typename... Type>
    +struct entt::type_list< Type >

    +

    A class to use to push around lists of types, nothing more.

    +
    Template Parameters
    + + +
    TypeTypes provided by the given type list.
    +
    +
    -

    Definition at line 642 of file meta.hpp.

    +

    Definition at line 17 of file type_traits.hpp.

    The documentation for this struct was generated from the following file:
    diff --git a/structentt_1_1tag__t.html b/structentt_1_1type__list__cat.html similarity index 75% rename from structentt_1_1tag__t.html rename to structentt_1_1type__list__cat.html index ebb8070a5..6d56f3827 100644 --- a/structentt_1_1tag__t.html +++ b/structentt_1_1type__list__cat.html @@ -5,7 +5,7 @@ -EnTT: entt::tag_t Struct Reference +EnTT: entt::type_list_cat<... > Struct Template Reference @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +Public Types | +List of all members
    +
    +
    entt::type_list_cat< type_list< Type... >, type_list< Other... >, List... > Struct Template Reference
    +
    +
    + +

    Concatenates multiple type lists. + More...

    + +

    #include <type_traits.hpp>

    + + + + + +

    +Public Types

    +using type = typename type_list_cat< type_list< Type..., Other... >, List... >::type
     A type list composed by the types of all the type lists.
     
    +

    Detailed Description

    +

    template<typename... Type, typename... Other, typename... List>
    +struct entt::type_list_cat< type_list< Type... >, type_list< Other... >, List... >

    + +

    Concatenates multiple type lists.

    +
    Template Parameters
    + + + + +
    TypeTypes provided by the first type list.
    OtherTypes provided by the second type list.
    ListOther type lists, if any.
    +
    +
    + +

    Definition at line 35 of file type_traits.hpp.

    +
    The documentation for this struct was generated from the following file: +
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/structentt_1_1type__list__cat_3_01type__list_3_01Type_8_8_8_01_4_00_01type__list_3_01Other_8_8_8b5f6e6ed6191612d6e0fe24c4ff408dc.html b/structentt_1_1type__list__cat_3_01type__list_3_01Type_8_8_8_01_4_00_01type__list_3_01Other_8_8_8b5f6e6ed6191612d6e0fe24c4ff408dc.html new file mode 100644 index 000000000..7d5a21f28 --- /dev/null +++ b/structentt_1_1type__list__cat_3_01type__list_3_01Type_8_8_8_01_4_00_01type__list_3_01Other_8_8_8b5f6e6ed6191612d6e0fe24c4ff408dc.html @@ -0,0 +1,82 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
    +
    + + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +
    entt::type_list_cat< type_list< Type... >, type_list< Other... >, List... > Member List
    +
    +
    + +

    This is the complete list of members for entt::type_list_cat< type_list< Type... >, type_list< Other... >, List... >, including all inherited members.

    + + +
    type typedefentt::type_list_cat< type_list< Type... >, type_list< Other... >, List... >
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/structentt_1_1type__list__cat_3_01type__list_3_01Type_8_8_8_01_4_01_4-members.html b/structentt_1_1type__list__cat_3_01type__list_3_01Type_8_8_8_01_4_01_4-members.html new file mode 100644 index 000000000..c5971f922 --- /dev/null +++ b/structentt_1_1type__list__cat_3_01type__list_3_01Type_8_8_8_01_4_01_4-members.html @@ -0,0 +1,82 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
    +
    + + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +
    entt::type_list_cat< type_list< Type... > > Member List
    +
    +
    + +

    This is the complete list of members for entt::type_list_cat< type_list< Type... > >, including all inherited members.

    + + +
    type typedefentt::type_list_cat< type_list< Type... > >
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/structentt_1_1internal_1_1CtorHelper.html b/structentt_1_1type__list__cat_3_01type__list_3_01Type_8_8_8_01_4_01_4.html similarity index 56% rename from structentt_1_1internal_1_1CtorHelper.html rename to structentt_1_1type__list__cat_3_01type__list_3_01Type_8_8_8_01_4_01_4.html index ac7e04f58..76360d184 100644 --- a/structentt_1_1internal_1_1CtorHelper.html +++ b/structentt_1_1type__list__cat_3_01type__list_3_01Type_8_8_8_01_4_01_4.html @@ -5,7 +5,7 @@ -EnTT: entt::internal::CtorHelper< Type, Args > Struct Template Reference +EnTT: entt::type_list_cat< type_list< Type... > > Struct Template Reference @@ -22,7 +22,7 @@
    EnTT -  2.7.2 +  3.0.0
    - - - - + + + +

    -Static Public Member Functions

    -template<std::size_t... Indexes>
    static MetaAny construct (const MetaAny *const any, std::index_sequence< Indexes... >)
     

    +Public Types

    +using type = type_list< Type... >
     A type list composed by the types of all the type lists.
     

    Detailed Description

    -

    template<typename Type, typename... Args>
    -struct entt::internal::CtorHelper< Type, Args >

    +

    template<typename... Type>
    +struct entt::type_list_cat< type_list< Type... > >

    +

    Concatenates multiple type lists.

    +
    Template Parameters
    + + +
    TypeTypes provided by the type list.
    +
    +
    -

    Definition at line 680 of file meta.hpp.

    +

    Definition at line 46 of file type_traits.hpp.

    The documentation for this struct was generated from the following file:
    diff --git a/structentt_1_1internal_1_1FunctionHelper.html b/structentt_1_1type__list__unique.html similarity index 74% rename from structentt_1_1internal_1_1FunctionHelper.html rename to structentt_1_1type__list__unique.html index 184a55acb..45d61b8e5 100644 --- a/structentt_1_1internal_1_1FunctionHelper.html +++ b/structentt_1_1type__list__unique.html @@ -5,7 +5,7 @@ -EnTT: entt::internal::FunctionHelper< typename > Struct Template Reference +EnTT: entt::type_list_unique< typename > Struct Template Reference @@ -22,7 +22,7 @@
    EnTT -  2.7.2 +  3.0.0
    + + + + + +
    +
    EnTT +  3.0.0 +
    +
    + + + + + + + + + +
    +
    + + +
    + +
    + + + +
    +
    +
    entt::type_list_unique< type_list< Type, Other... > > Member List
    +
    +
    + +

    This is the complete list of members for entt::type_list_unique< type_list< Type, Other... > >, including all inherited members.

    + + +
    type typedefentt::type_list_unique< type_list< Type, Other... > >
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/structentt_1_1type__list__unique_3_01type__list_3_01Type_00_01Other_8_8_8_01_4_01_4.html b/structentt_1_1type__list__unique_3_01type__list_3_01Type_00_01Other_8_8_8_01_4_01_4.html new file mode 100644 index 000000000..ce45fd63b --- /dev/null +++ b/structentt_1_1type__list__unique_3_01type__list_3_01Type_00_01Other_8_8_8_01_4_01_4.html @@ -0,0 +1,111 @@ + + + + + + + +EnTT: entt::type_list_unique< type_list< Type, Other... > > Struct Template Reference + + + + + + + + + +
    +
    + + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +Public Types | +List of all members
    +
    +
    entt::type_list_unique< type_list< Type, Other... > > Struct Template Reference
    +
    +
    + +

    Removes duplicates types from a type list. + More...

    + +

    #include <type_traits.hpp>

    + + + + + +

    +Public Types

    +using type = std::conditional_t< std::disjunction_v< std::is_same< Type, Other >... >, typename type_list_unique< type_list< Other... > >::type, type_list_cat_t< type_list< Type >, typename type_list_unique< type_list< Other... > >::type > >
     A type list without duplicate types.
     
    +

    Detailed Description

    +

    template<typename Type, typename... Other>
    +struct entt::type_list_unique< type_list< Type, Other... > >

    + +

    Removes duplicates types from a type list.

    +
    Template Parameters
    + + + +
    TypeOne of the types provided by the given type list.
    OtherThe other types provided by the given type list.
    +
    +
    + +

    Definition at line 71 of file type_traits.hpp.

    +
    The documentation for this struct was generated from the following file: +
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/structentt_1_1type__list__unique_3_01type__list_3_4_01_4-members.html b/structentt_1_1type__list__unique_3_01type__list_3_4_01_4-members.html new file mode 100644 index 000000000..a73207e83 --- /dev/null +++ b/structentt_1_1type__list__unique_3_01type__list_3_4_01_4-members.html @@ -0,0 +1,82 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
    +
    + + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +
    entt::type_list_unique< type_list<> > Member List
    +
    +
    + +

    This is the complete list of members for entt::type_list_unique< type_list<> >, including all inherited members.

    + + +
    type typedefentt::type_list_unique< type_list<> >
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/structentt_1_1internal_1_1TypeHelper_3_01void_01_4.html b/structentt_1_1type__list__unique_3_01type__list_3_4_01_4.html similarity index 60% rename from structentt_1_1internal_1_1TypeHelper_3_01void_01_4.html rename to structentt_1_1type__list__unique_3_01type__list_3_4_01_4.html index 9926b850b..61f85a105 100644 --- a/structentt_1_1internal_1_1TypeHelper_3_01void_01_4.html +++ b/structentt_1_1type__list__unique_3_01type__list_3_4_01_4.html @@ -5,7 +5,7 @@ -EnTT: entt::internal::TypeHelper< void > Struct Template Reference +EnTT: entt::type_list_unique< type_list<> > Struct Template Reference @@ -22,7 +22,7 @@
    EnTT -  2.7.2 +  3.0.0
    - - - + + + +

    -Static Public Member Functions

    -static void destroy (void *)
     

    +Public Types

    +using type = type_list<>
     A type list without duplicate types.
     

    Detailed Description

    template<>
    -struct entt::internal::TypeHelper< void >

    +struct entt::type_list_unique< type_list<> > +

    Removes duplicates types from a type list.

    -

    Definition at line 650 of file meta.hpp.

    +

    Definition at line 83 of file type_traits.hpp.

    The documentation for this struct was generated from the following file: diff --git a/type__traits_8hpp_source.html b/type__traits_8hpp_source.html new file mode 100644 index 000000000..f024aca42 --- /dev/null +++ b/type__traits_8hpp_source.html @@ -0,0 +1,91 @@ + + + + + + + +EnTT: src/entt/core/type_traits.hpp Source File + + + + + + + + + +
    +
    + + + + + + +
    +
    EnTT +  3.0.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +
    type_traits.hpp
    +
    +
    +
    1 #ifndef ENTT_CORE_TYPE_TRAITS_HPP
    2 #define ENTT_CORE_TYPE_TRAITS_HPP
    3 
    4 
    5 #include <type_traits>
    6 #include "../core/hashed_string.hpp"
    7 
    8 
    9 namespace entt {
    10 
    11 
    16 template<typename... Type>
    17 struct type_list {
    19  static constexpr auto size = sizeof...(Type);
    20 };
    21 
    22 
    24 template<typename...>
    25 struct type_list_cat;
    26 
    27 
    34 template<typename... Type, typename... Other, typename... List>
    35 struct type_list_cat<type_list<Type...>, type_list<Other...>, List...> {
    37  using type = typename type_list_cat<type_list<Type..., Other...>, List...>::type;
    38 };
    39 
    40 
    45 template<typename... Type>
    46 struct type_list_cat<type_list<Type...>> {
    48  using type = type_list<Type...>;
    49 };
    50 
    51 
    56 template<typename... List>
    57 using type_list_cat_t = typename type_list_cat<List...>::type;
    58 
    59 
    61 template<typename>
    62 struct type_list_unique;
    63 
    64 
    70 template<typename Type, typename... Other>
    71 struct type_list_unique<type_list<Type, Other...>> {
    73  using type = std::conditional_t<
    74  std::disjunction_v<std::is_same<Type, Other>...>,
    75  typename type_list_unique<type_list<Other...>>::type,
    76  type_list_cat_t<type_list<Type>, typename type_list_unique<type_list<Other...>>::type>
    77  >;
    78 };
    79 
    80 
    82 template<>
    83 struct type_list_unique<type_list<>> {
    85  using type = type_list<>;
    86 };
    87 
    88 
    93 template<typename Type>
    94 using type_list_unique_t = typename type_list_unique<Type>::type;
    95 
    96 
    98 template<typename>
    99 struct named_type_traits;
    100 
    101 
    106 template<typename Type>
    107 struct named_type_traits<const Type>
    108  : named_type_traits<Type>
    109 {};
    110 
    111 
    116 template<typename Type>
    117 using named_type_traits_t = typename named_type_traits<Type>::type;
    118 
    119 
    124 template<typename, typename = std::void_t<>>
    125 struct is_named_type: std::false_type {};
    126 
    127 
    133 template<typename Type>
    134 struct is_named_type<Type, std::void_t<named_type_traits_t<std::decay_t<Type>>>>: std::true_type {};
    135 
    136 
    144 template<class Type>
    145 constexpr auto is_named_type_v = is_named_type<Type>::value;
    146 
    147 
    148 }
    149 
    150 
    158 #define ENTT_EXPAND(args) args
    159 
    160 
    165 #define ENTT_NAMED_TYPE(type)\
    166  template<>\
    167  struct entt::named_type_traits<type>\
    168  : std::integral_constant<typename entt::hashed_string::hash_type, entt::hashed_string::to_value(#type)>\
    169  {\
    170  static_assert(std::is_same_v<std::decay_t<type>, type>);\
    171  };
    172 
    173 
    179 #define ENTT_NAMED_STRUCT_ONLY(clazz, body)\
    180  struct clazz body;\
    181  ENTT_NAMED_TYPE(clazz)
    182 
    183 
    190 #define ENTT_NAMED_STRUCT_WITH_NAMESPACE(ns, clazz, body)\
    191  namespace ns { struct clazz body; }\
    192  ENTT_NAMED_TYPE(ns::clazz)
    193 
    194 
    196 #define ENTT_NAMED_STRUCT_OVERLOAD(_1, _2, _3, FUNC, ...) FUNC
    197 
    198 #define ENTT_NAMED_STRUCT(...) ENTT_EXPAND(ENTT_NAMED_STRUCT_OVERLOAD(__VA_ARGS__, ENTT_NAMED_STRUCT_WITH_NAMESPACE, ENTT_NAMED_STRUCT_ONLY,)(__VA_ARGS__))
    199 
    200 
    206 #define ENTT_NAMED_CLASS_ONLY(clazz, body)\
    207  class clazz body;\
    208  ENTT_NAMED_TYPE(clazz)
    209 
    210 
    217 #define ENTT_NAMED_CLASS_WITH_NAMESPACE(ns, clazz, body)\
    218  namespace ns { class clazz body; }\
    219  ENTT_NAMED_TYPE(ns::clazz)
    220 
    221 
    223 #define ENTT_NAMED_CLASS_MACRO(_1, _2, _3, FUNC, ...) FUNC
    224 
    225 #define ENTT_NAMED_CLASS(...) ENTT_EXPAND(ENTT_NAMED_CLASS_MACRO(__VA_ARGS__, ENTT_NAMED_CLASS_WITH_NAMESPACE, ENTT_NAMED_CLASS_ONLY,)(__VA_ARGS__))
    226 
    227 
    228 #endif // ENTT_CORE_TYPE_TRAITS_HPP
    entt::type_list_cat
    Primary template isn&#39;t defined on purpose.
    Definition: type_traits.hpp:25
    +
    entt::type_list_unique< type_list< Type, Other... > >::type
    std::conditional_t< std::disjunction_v< std::is_same< Type, Other >... >, typename type_list_unique< type_list< Other... > >::type, type_list_cat_t< type_list< Type >, typename type_list_unique< type_list< Other... > >::type > > type
    A type list without duplicate types.
    Definition: type_traits.hpp:77
    +
    entt::named_type_traits_t
    typename named_type_traits< Type >::type named_type_traits_t
    Helper type.
    Definition: type_traits.hpp:117
    +
    entt::is_named_type
    Provides the member constant value to true if a given type has a name. In all other cases...
    Definition: type_traits.hpp:125
    +
    entt
    EnTT default namespace.
    Definition: algorithm.hpp:10
    +
    entt::named_type_traits
    Traits class used mainly to push things across boundaries.
    Definition: type_traits.hpp:99
    +
    entt::type_list_cat_t
    typename type_list_cat< List... >::type type_list_cat_t
    Helper type.
    Definition: type_traits.hpp:57
    +
    entt::type_list_cat< type_list< Type... >, type_list< Other... >, List... >::type
    typename type_list_cat< type_list< Type..., Other... >, List... >::type type
    A type list composed by the types of all the type lists.
    Definition: type_traits.hpp:37
    +
    entt::type_list_unique
    Primary template isn&#39;t defined on purpose.
    Definition: type_traits.hpp:62
    +
    entt::type_list
    A class to use to push around lists of types, nothing more.
    Definition: type_traits.hpp:17
    +
    entt::type_list::size
    static constexpr auto size
    Unsigned integer type.
    Definition: type_traits.hpp:19
    +
    entt::is_named_type_v
    constexpr auto is_named_type_v
    Helper variable template.
    Definition: type_traits.hpp:145
    +
    entt::type_list_unique_t
    typename type_list_unique< Type >::type type_list_unique_t
    Helper type.
    Definition: type_traits.hpp:94
    +
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/utility_8hpp_source.html b/utility_8hpp_source.html index c6f40e085..4eb5d5502 100644 --- a/utility_8hpp_source.html +++ b/utility_8hpp_source.html @@ -5,7 +5,7 @@ -EnTT: src/entt/entity/utility.hpp Source File +EnTT: src/entt/core/utility.hpp Source File @@ -22,7 +22,7 @@
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0
    EnTT -  2.7.3 +  3.0.0