From e9b4a6dd1f6c7e6baa31b716f698310b68880970 Mon Sep 17 00:00:00 2001 From: Michele Caini Date: Wed, 15 Nov 2017 22:49:45 +0100 Subject: [PATCH] API reference v2.2.0 --- README_8md_source.html | 4 +- actor_8hpp_source.html | 92 +++ annotated.html | 60 +- bus_8hpp_source.html | 30 +- cache_8hpp_source.html | 93 +++ classentt_1_1Bus.html | 2 +- ...01Event_00_01Other_8_8_8_01_4-members.html | 28 +- ...1Sig_00_01Event_00_01Other_8_8_8_01_4.html | 104 +-- ..._1Bus_3_01Sig_00_01Event_01_4-members.html | 24 +- classentt_1_1Bus_3_01Sig_00_01Event_01_4.html | 106 +-- classentt_1_1Delegate.html | 2 +- ...ate_3_01Ret_07Args_8_8_8_08_4-members.html | 4 +- ...1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html | 8 +- classentt_1_1Dispatcher-members.html | 9 +- classentt_1_1Dispatcher.html | 94 +-- classentt_1_1Emitter-members.html | 4 +- classentt_1_1Emitter.html | 28 +- classentt_1_1Family-members.html | 2 +- classentt_1_1Family.html | 2 +- classentt_1_1HashedString-members.html | 87 +++ classentt_1_1HashedString.html | 304 +++++++++ classentt_1_1PersistentView-members.html | 4 +- classentt_1_1PersistentView.html | 33 +- classentt_1_1Process-members.html | 95 +++ classentt_1_1Process.html | 512 ++++++++++++++ classentt_1_1Process__coll__graph.map | 2 + classentt_1_1Process__coll__graph.md5 | 1 + classentt_1_1Process__coll__graph.png | Bin 0 -> 4373 bytes classentt_1_1Process__inherit__graph.map | 2 + classentt_1_1Process__inherit__graph.md5 | 1 + classentt_1_1Process__inherit__graph.png | Bin 0 -> 4373 bytes classentt_1_1Registry-members.html | 37 +- classentt_1_1Registry.html | 637 ++++++++++++++---- classentt_1_1ResourceCache-members.html | 96 +++ classentt_1_1ResourceCache.html | 563 ++++++++++++++++ classentt_1_1ResourceHandle-members.html | 91 +++ classentt_1_1ResourceHandle.html | 344 ++++++++++ classentt_1_1ResourceLoader-members.html | 82 +++ classentt_1_1ResourceLoader.html | 115 ++++ classentt_1_1Scheduler-members.html | 94 +++ classentt_1_1Scheduler.html | 510 ++++++++++++++ classentt_1_1SigH.html | 2 +- ..._8_8_8_08_00_01Collector_01_4-members.html | 14 +- ...t_07Args_8_8_8_08_00_01Collector_01_4.html | 214 +----- classentt_1_1Signal.html | 2 +- ...al_3_01void_07Args_8_8_8_08_4-members.html | 14 +- ..._1_1Signal_3_01void_07Args_8_8_8_08_4.html | 202 +----- classentt_1_1SparseSet.html | 2 +- ...Set_3_01Entity_00_01Type_01_4-members.html | 40 +- ..._1SparseSet_3_01Entity_00_01Type_01_4.html | 136 ++-- ..._1_1SparseSet_3_01Entity_01_4-members.html | 6 +- classentt_1_1SparseSet_3_01Entity_01_4.html | 85 ++- classentt_1_1View-members.html | 4 +- classentt_1_1View.html | 28 +- ..._01Entity_00_01Component_01_4-members.html | 6 +- ..._1View_3_01Entity_00_01Component_01_4.html | 54 +- classes.html | 42 +- delegate_8hpp_source.html | 8 +- dir_66e9674e8206a335795995fa32a03c91.html | 2 +- dir_68267d1309a1af8e8297ef4c3efbcdba.html | 2 +- dir_721f6154dba3c88bcdead5f446bce319.html | 78 +++ dir_85dbee8884f1b3a817fa7eff8dff73ec.html | 78 +++ dir_a53318306f6ac0f7fe657839abd543ab.html | 2 +- dir_b64489a1e8130d5ebf6d86d282f500f0.html | 2 +- dir_de8f4e6ba3f54a2a21309f742e93a373.html | 2 +- dir_e3a7bb56c55e5c2286e2fe96e197d4f5.html | 2 +- dispatcher_8hpp_source.html | 16 +- emitter_8hpp_source.html | 23 +- entt_8hpp_source.html | 4 +- family_8hpp_source.html | 2 +- files.html | 39 +- functions.html | 19 +- functions_0x7e.html | 23 +- functions_b.html | 6 +- functions_c.html | 20 +- functions_d.html | 17 +- functions_e.html | 9 +- functions_f.html | 5 +- functions_func.html | 341 +--------- functions_func_0x7e.html | 89 +++ functions_func_b.html | 80 +++ functions_func_c.html | 112 +++ functions_func_d.html | 104 +++ functions_func_e.html | 106 +++ functions_func_f.html | 77 +++ functions_func_g.html | 85 +++ functions_func_h.html | 85 +++ functions_func_l.html | 77 +++ functions_func_o.html | 118 ++++ functions_func_p.html | 99 +++ functions_func_r.html | 120 ++++ functions_func_s.html | 112 +++ functions_func_t.html | 83 +++ functions_func_u.html | 90 +++ functions_func_v.html | 87 +++ functions_g.html | 14 +- functions_h.html | 14 +- functions_i.html | 2 +- functions_l.html | 5 +- functions_o.html | 35 +- functions_p.html | 11 +- functions_r.html | 35 +- functions_rela.html | 6 +- functions_s.html | 27 +- functions_t.html | 6 +- functions_type.html | 41 +- functions_u.html | 13 +- functions_v.html | 7 +- functions_vars.html | 12 +- graph_legend.html | 2 +- handle_8hpp_source.html | 84 +++ hashed__string_8hpp_source.html | 85 +++ hierarchy.html | 71 +- ident_8hpp_source.html | 2 +- index.html | 137 ++-- inherit_graph_0.map | 2 +- inherit_graph_0.md5 | 2 +- inherit_graph_0.png | Bin 1564 -> 2125 bytes inherit_graph_1.map | 4 +- inherit_graph_1.md5 | 2 +- inherit_graph_1.png | Bin 6519 -> 1564 bytes inherit_graph_10.map | 2 +- inherit_graph_10.md5 | 2 +- inherit_graph_10.png | Bin 1857 -> 1985 bytes inherit_graph_11.map | 2 +- inherit_graph_11.md5 | 2 +- inherit_graph_11.png | Bin 1340 -> 1857 bytes inherit_graph_12.map | 2 +- inherit_graph_12.md5 | 2 +- inherit_graph_12.png | Bin 2696 -> 1340 bytes inherit_graph_13.map | 2 +- inherit_graph_13.md5 | 2 +- inherit_graph_13.png | Bin 1735 -> 1637 bytes inherit_graph_14.map | 2 +- inherit_graph_14.md5 | 2 +- inherit_graph_14.png | Bin 2063 -> 2696 bytes inherit_graph_15.map | 2 +- inherit_graph_15.md5 | 2 +- inherit_graph_15.png | Bin 2336 -> 2282 bytes inherit_graph_16.map | 3 +- inherit_graph_16.md5 | 2 +- inherit_graph_16.png | Bin 2783 -> 7272 bytes inherit_graph_17.map | 2 +- inherit_graph_17.md5 | 2 +- inherit_graph_17.png | Bin 1890 -> 1735 bytes inherit_graph_18.map | 2 +- inherit_graph_18.md5 | 2 +- inherit_graph_18.png | Bin 2841 -> 2193 bytes inherit_graph_19.map | 3 +- inherit_graph_19.md5 | 2 +- inherit_graph_19.png | Bin 3598 -> 2061 bytes inherit_graph_2.map | 4 +- inherit_graph_2.md5 | 2 +- inherit_graph_2.png | Bin 2312 -> 6519 bytes inherit_graph_20.map | 2 +- inherit_graph_20.md5 | 2 +- inherit_graph_20.png | Bin 2546 -> 2168 bytes inherit_graph_21.map | 2 +- inherit_graph_21.md5 | 2 +- inherit_graph_21.png | Bin 1567 -> 1830 bytes inherit_graph_22.map | 2 +- inherit_graph_22.md5 | 2 +- inherit_graph_22.png | Bin 2384 -> 2063 bytes inherit_graph_23.map | 2 +- inherit_graph_23.md5 | 2 +- inherit_graph_23.png | Bin 2360 -> 2336 bytes inherit_graph_24.map | 3 + inherit_graph_24.md5 | 1 + inherit_graph_24.png | Bin 0 -> 2783 bytes inherit_graph_25.map | 3 + inherit_graph_25.md5 | 1 + inherit_graph_25.png | Bin 0 -> 1890 bytes inherit_graph_26.map | 3 + inherit_graph_26.md5 | 1 + inherit_graph_26.png | Bin 0 -> 2841 bytes inherit_graph_27.map | 4 + inherit_graph_27.md5 | 1 + inherit_graph_27.png | Bin 0 -> 3598 bytes inherit_graph_28.map | 3 + inherit_graph_28.md5 | 1 + inherit_graph_28.png | Bin 0 -> 2546 bytes inherit_graph_29.map | 3 + inherit_graph_29.md5 | 1 + inherit_graph_29.png | Bin 0 -> 1567 bytes inherit_graph_3.map | 2 +- inherit_graph_3.md5 | 2 +- inherit_graph_3.png | Bin 1858 -> 2312 bytes inherit_graph_30.map | 3 + inherit_graph_30.md5 | 1 + inherit_graph_30.png | Bin 0 -> 2384 bytes inherit_graph_31.map | 3 + inherit_graph_31.md5 | 1 + inherit_graph_31.png | Bin 0 -> 2360 bytes inherit_graph_4.map | 2 +- inherit_graph_4.md5 | 2 +- inherit_graph_4.png | Bin 2050 -> 1858 bytes inherit_graph_5.map | 2 +- inherit_graph_5.md5 | 2 +- inherit_graph_5.png | Bin 1537 -> 2050 bytes inherit_graph_6.map | 2 +- inherit_graph_6.md5 | 2 +- inherit_graph_6.png | Bin 3880 -> 1537 bytes inherit_graph_7.map | 2 +- inherit_graph_7.md5 | 2 +- inherit_graph_7.png | Bin 1910 -> 3880 bytes inherit_graph_8.map | 2 +- inherit_graph_8.md5 | 2 +- inherit_graph_8.png | Bin 2037 -> 1910 bytes inherit_graph_9.map | 2 +- inherit_graph_9.md5 | 2 +- inherit_graph_9.png | Bin 1985 -> 2037 bytes inherits.html | 93 ++- loader_8hpp_source.html | 81 +++ locator_8hpp_source.html | 2 +- menudata.js | 34 +- namespaceentt.html | 131 +++- namespacemembers.html | 7 +- namespacemembers_func.html | 4 +- namespacemembers_type.html | 5 +- namespacemembers_vars.html | 2 +- namespaces.html | 2 +- process_8hpp_source.html | 95 +++ registry_8hpp_source.html | 68 +- scheduler_8hpp_source.html | 91 +++ search/all_0.js | 7 +- search/all_1.js | 2 +- search/all_10.js | 4 +- search/all_11.js | 3 +- search/all_12.js | 8 +- search/all_2.js | 7 +- search/all_3.js | 6 +- search/all_4.js | 3 +- search/all_5.js | 1 + search/all_6.js | 2 +- search/all_7.js | 5 +- search/all_9.js | 3 +- search/all_b.js | 13 +- search/all_c.js | 5 + search/all_d.js | 16 +- search/all_e.js | 12 +- search/all_f.js | 3 +- search/classes_0.js | 5 +- search/classes_1.js | 5 +- search/classes_2.js | 4 +- search/classes_3.js | 8 +- search/classes_4.js | 6 +- search/classes_5.js | 2 +- search/classes_6.js | 2 +- search/classes_7.js | 13 +- search/classes_8.js | 6 +- search/classes_9.html | 26 + search/classes_9.js | 13 + search/classes_a.html | 26 + search/classes_a.js | 5 + search/functions_0.js | 7 +- search/functions_1.js | 3 +- search/functions_10.html | 26 + search/functions_10.js | 8 + search/functions_2.js | 7 +- search/functions_3.js | 4 +- search/functions_4.js | 2 +- search/functions_5.js | 2 +- search/functions_6.js | 2 +- search/functions_7.js | 9 +- search/functions_8.js | 5 +- search/functions_9.js | 20 +- search/functions_a.js | 15 +- search/functions_b.js | 14 +- search/functions_c.js | 10 +- search/functions_d.js | 6 +- search/functions_e.js | 13 +- search/functions_f.html | 26 + search/functions_f.js | 6 + search/related_1.js | 2 +- search/related_2.html | 26 + search/related_2.js | 4 + search/searchdata.js | 8 +- search/typedefs_1.js | 4 +- search/typedefs_4.js | 3 +- search/typedefs_5.js | 3 +- search/typedefs_6.js | 3 +- search/typedefs_7.js | 3 +- search/typedefs_8.js | 2 +- search/typedefs_9.js | 3 +- search/typedefs_a.js | 4 +- search/typedefs_b.js | 4 +- search/typedefs_c.js | 3 +- search/typedefs_d.html | 26 + search/typedefs_d.js | 4 + search/variables_0.js | 3 +- search/variables_2.js | 3 +- sigh_8hpp_source.html | 37 +- signal_8hpp_source.html | 29 +- sparse__set_8hpp_source.html | 50 +- structentt_1_1Actor-members.html | 97 +++ structentt_1_1Actor.html | 581 ++++++++++++++++ ...entt_1_1Emitter_1_1Connection-members.html | 9 +- structentt_1_1Emitter_1_1Connection.html | 22 +- structentt_1_1ProcessAdaptor-members.html | 95 +++ structentt_1_1ProcessAdaptor.html | 274 ++++++++ structentt_1_1ProcessAdaptor__coll__graph.map | 3 + structentt_1_1ProcessAdaptor__coll__graph.md5 | 1 + structentt_1_1ProcessAdaptor__coll__graph.png | Bin 0 -> 10957 bytes ...entt_1_1ProcessAdaptor__inherit__graph.map | 3 + ...entt_1_1ProcessAdaptor__inherit__graph.md5 | 1 + ...entt_1_1ProcessAdaptor__inherit__graph.png | Bin 0 -> 10957 bytes structentt_1_1ServiceLocator-members.html | 2 +- structentt_1_1ServiceLocator.html | 2 +- structentt_1_1entt__traits.html | 2 +- ...its_3_01std_1_1uint16__t_01_4-members.html | 8 +- ...ntt__traits_3_01std_1_1uint16__t_01_4.html | 15 +- ...its_3_01std_1_1uint32__t_01_4-members.html | 8 +- ...ntt__traits_3_01std_1_1uint32__t_01_4.html | 15 +- ...its_3_01std_1_1uint64__t_01_4-members.html | 8 +- ...ntt__traits_3_01std_1_1uint64__t_01_4.html | 15 +- traits_8hpp_source.html | 14 +- view_8hpp_source.html | 82 +-- 317 files changed, 8482 insertions(+), 2145 deletions(-) create mode 100644 actor_8hpp_source.html create mode 100644 cache_8hpp_source.html create mode 100644 classentt_1_1HashedString-members.html create mode 100644 classentt_1_1HashedString.html create mode 100644 classentt_1_1Process-members.html create mode 100644 classentt_1_1Process.html create mode 100644 classentt_1_1Process__coll__graph.map create mode 100644 classentt_1_1Process__coll__graph.md5 create mode 100644 classentt_1_1Process__coll__graph.png create mode 100644 classentt_1_1Process__inherit__graph.map create mode 100644 classentt_1_1Process__inherit__graph.md5 create mode 100644 classentt_1_1Process__inherit__graph.png create mode 100644 classentt_1_1ResourceCache-members.html create mode 100644 classentt_1_1ResourceCache.html create mode 100644 classentt_1_1ResourceHandle-members.html create mode 100644 classentt_1_1ResourceHandle.html create mode 100644 classentt_1_1ResourceLoader-members.html create mode 100644 classentt_1_1ResourceLoader.html create mode 100644 classentt_1_1Scheduler-members.html create mode 100644 classentt_1_1Scheduler.html create mode 100644 dir_721f6154dba3c88bcdead5f446bce319.html create mode 100644 dir_85dbee8884f1b3a817fa7eff8dff73ec.html create mode 100644 functions_func_0x7e.html create mode 100644 functions_func_b.html create mode 100644 functions_func_c.html create mode 100644 functions_func_d.html create mode 100644 functions_func_e.html create mode 100644 functions_func_f.html create mode 100644 functions_func_g.html create mode 100644 functions_func_h.html create mode 100644 functions_func_l.html create mode 100644 functions_func_o.html create mode 100644 functions_func_p.html create mode 100644 functions_func_r.html create mode 100644 functions_func_s.html create mode 100644 functions_func_t.html create mode 100644 functions_func_u.html create mode 100644 functions_func_v.html create mode 100644 handle_8hpp_source.html create mode 100644 hashed__string_8hpp_source.html create mode 100644 inherit_graph_24.map create mode 100644 inherit_graph_24.md5 create mode 100644 inherit_graph_24.png create mode 100644 inherit_graph_25.map create mode 100644 inherit_graph_25.md5 create mode 100644 inherit_graph_25.png create mode 100644 inherit_graph_26.map create mode 100644 inherit_graph_26.md5 create mode 100644 inherit_graph_26.png create mode 100644 inherit_graph_27.map create mode 100644 inherit_graph_27.md5 create mode 100644 inherit_graph_27.png create mode 100644 inherit_graph_28.map create mode 100644 inherit_graph_28.md5 create mode 100644 inherit_graph_28.png create mode 100644 inherit_graph_29.map create mode 100644 inherit_graph_29.md5 create mode 100644 inherit_graph_29.png create mode 100644 inherit_graph_30.map create mode 100644 inherit_graph_30.md5 create mode 100644 inherit_graph_30.png create mode 100644 inherit_graph_31.map create mode 100644 inherit_graph_31.md5 create mode 100644 inherit_graph_31.png create mode 100644 loader_8hpp_source.html create mode 100644 process_8hpp_source.html create mode 100644 scheduler_8hpp_source.html create mode 100644 search/classes_9.html create mode 100644 search/classes_9.js create mode 100644 search/classes_a.html create mode 100644 search/classes_a.js create mode 100644 search/functions_10.html create mode 100644 search/functions_10.js create mode 100644 search/functions_f.html create mode 100644 search/functions_f.js create mode 100644 search/related_2.html create mode 100644 search/related_2.js create mode 100644 search/typedefs_d.html create mode 100644 search/typedefs_d.js create mode 100644 structentt_1_1Actor-members.html create mode 100644 structentt_1_1Actor.html create mode 100644 structentt_1_1ProcessAdaptor-members.html create mode 100644 structentt_1_1ProcessAdaptor.html create mode 100644 structentt_1_1ProcessAdaptor__coll__graph.map create mode 100644 structentt_1_1ProcessAdaptor__coll__graph.md5 create mode 100644 structentt_1_1ProcessAdaptor__coll__graph.png create mode 100644 structentt_1_1ProcessAdaptor__inherit__graph.map create mode 100644 structentt_1_1ProcessAdaptor__inherit__graph.md5 create mode 100644 structentt_1_1ProcessAdaptor__inherit__graph.png diff --git a/README_8md_source.html b/README_8md_source.html index 57d69017b..4acb6f77b 100644 --- a/README_8md_source.html +++ b/README_8md_source.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0
@@ -63,7 +63,7 @@ $(function() {
README.md
-
1 # EnTT Framework
2 
3 [![Build Status](https://travis-ci.org/skypjack/entt.svg?branch=master)](https://travis-ci.org/skypjack/entt)
4 [![Build status](https://ci.appveyor.com/api/projects/status/rvhaabjmghg715ck?svg=true)](https://ci.appveyor.com/project/skypjack/entt)
5 [![Coverage Status](https://coveralls.io/repos/github/skypjack/entt/badge.svg?branch=master)](https://coveralls.io/github/skypjack/entt?branch=master)
6 [![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)
7 
8 # Introduction
9 
10 `EnTT` is a header-only, tiny and easy to use framework written in modern
11 C++.<br/>
12 It was originally designed entirely around an architectural pattern called _ECS_
13 that is used mostly in game development. For further details:
14 
15 * [Entity Systems Wiki](http://entity-systems.wikidot.com/)
16 * [Evolve Your Hierarchy](http://cowboyprogramming.com/2007/01/05/evolve-your-heirachy/)
17 * [ECS on Wikipedia](https://en.wikipedia.org/wiki/Entity%E2%80%93component%E2%80%93system)
18 
19 A long time ago, the sole entity-component system was part of the project. After
20 a while the codebase has grown and more and more classes have become part
21 of the repository.<br/>
22 That's why today it's called _the EnTT Framework_.
23 
24 ## The framework
25 
26 `EnTT` was written initially as a faster alternative to other well known and
27 open source entity-component systems. Nowadays the `EnTT` framework is moving
28 its first steps. Much more will come in the future and hopefully I'm going to
29 work on it for a long time.<br/>
30 Requests for feature, PR, suggestions ad feedback are highly appreciated.
31 
32 If you find you can help me and want to contribute to the `EnTT` framework with
33 your experience or you do want to get part of the project for some other
34 reason, feel free to contact me directly (you can find the mail in the
35 [profile](https://github.com/skypjack)).<br/>
36 I can't promise that each and every contribution will be accepted, but I can
37 assure that I'll do my best to take them all seriously.
38 
39 ### State of the art
40 
41 Here is a brief list of what it offers today:
42 
43 * Statically generated integer identifiers for types (assigned either at
44 compile-time or at runtime).
45 * An incredibly fast entity-component system based on sparse sets, with its own
46 views and a _pay for what you use_ policy to adjust performance and memory
47 pressure according to the users' requirements.
48 * Signal handlers of any type, delegates and an event bus.
49 * A general purpose event emitter, that is a CRTP idiom based class template.
50 * An event dispatcher for immediate and delayed events to integrate in loops.
51 * The smallest and most basic implementation of a service locator ever seen.
52 * ...
53 * Any other business.
54 
55 Consider it a work in progress. For more details and an updated list, please
56 refer to the [online documentation](https://skypjack.github.io/entt/).
57 
58 ### A note about the README
59 
60 The README file stays true to the original project and it describes only the
61 entity-component system. However, the whole API is fully documented in-code and
62 the [online documentation](https://skypjack.github.io/entt/) contains much
63 more.<br/>
64 Continue reading to know how the core part of the project works or follow the
65 link above to take a look at the API reference for all other available classes.
66 
67 ## Code Example
68 
69 ```cpp
70 #include <entt/entt.hpp>
71 #include <cstdint>
72 
73 struct Position {
74  float x;
75  float y;
76 };
77 
78 struct Velocity {
79  float dx;
80  float dy;
81 };
82 
83 void update(entt::DefaultRegistry &registry) {
84  auto view = registry.view<Position, Velocity>();
85 
86  for(auto entity: view) {
87  // gets only the components that are going to be used ...
88 
89  auto &velocity = view.get<Velocity>(entity);
90 
91  velocity.dx = 0.;
92  velocity.dy = 0.;
93 
94  // ...
95  }
96 }
97 
98 void update(std::uint64_t dt, entt::DefaultRegistry &registry) {
99  registry.view<Position, Velocity>().each([dt](auto entity, auto &position, auto &velocity) {
100  // gets all the components of the view at once ...
101 
102  position.x += velocity.dx * dt;
103  position.y += velocity.dy * dt;
104 
105  // ...
106  });
107 }
108 
109 int main() {
110  entt::DefaultRegistry registry;
111  std::uint64_t dt = 16;
112 
113  for(auto i = 0; i < 10; ++i) {
114  auto entity = registry.create(Position{i * 1.f, i * 1.f});
115  if(i % 2 == 0) { registry.assign<Velocity>(entity, i * .1f, i * .1f); }
116  }
117 
118  update(dt, registry);
119  update(registry);
120 
121  // ...
122 }
123 ```
124 
125 ## Motivation
126 
127 I started working on `EnTT` because of the wrong reason: my goal was to design
128 an entity-component system that beated another well known open source solution
129 in terms of performance.<br/>
130 I did it, of course, but it wasn't much satisfying. Actually it wasn't
131 satisfying at all. The fastest and nothing more, fairly little indeed. When I
132 realized it, I tried hard to keep intact the great performance of `EnTT` and to
133 add all the features I wanted to see in *my* entity-component system at the same
134 time.
135 
136 Today `EnTT` is finally what I was looking for: still faster than its
137 _competitors_, a really good API and an amazing set of features. And even more,
138 of course.
139 
140 ## Performance
141 
142 As it stands right now, `EnTT` is just fast enough for my requirements if
143 compared to my first choice (that was already amazingly fast indeed).<br/>
144 Here is a comparision between the two (both of them compiled with GCC 7.2.0 on a
145 Dell XPS 13 out of the mid 2014):
146 
147 | Benchmark | EntityX (experimental/compile_time) | EnTT |
148 |-----------|-------------|-------------|
149 | Creating 10M entities | 0.128881s | **0.0408754s** |
150 | Destroying 10M entities | **0.0531374s** | 0.0545839s |
151 | Iterating over 10M entities, unpacking one component, standard view | 0.010661s | **1.58e-07s** |
152 | Iterating over 10M entities, unpacking two components, standard view | **0.0112664s** | 0.0840068s |
153 | Iterating over 10M entities, unpacking two components, standard view, half of the entities have all the components | **0.0077951s** | 0.042168s |
154 | Iterating over 10M entities, unpacking two components, standard view, one of the entities has all the components | 0.00713398s | **8.93e-07s** |
155 | Iterating over 10M entities, unpacking two components, persistent view | 0.0112664s | **5.68e-07s** |
156 | Iterating over 10M entities, unpacking five components, standard view | **0.00905084s** | 0.137757s |
157 | Iterating over 10M entities, unpacking five components, persistent view | 0.00905084s | **2.9e-07s** |
158 | Iterating over 10M entities, unpacking ten components, standard view | **0.0104708s** | 0.388602s |
159 | Iterating over 10M entities, unpacking ten components, standard view, half of the entities have all the components | **0.00899859s** | 0.200752s |
160 | Iterating over 10M entities, unpacking ten components, standard view, one of the entities has all the components | 0.00700349s | **2.565e-06s** |
161 | Iterating over 10M entities, unpacking ten components, persistent view | 0.0104708s | **6.23e-07s** |
162 | Sort 150k entities, one component | - | **0.0080046s** |
163 | Sort 150k entities, match two components | - | **0.00608322s** |
164 
165 `EnTT` includes its own tests and benchmarks. See
166 [benchmark.cpp](https://github.com/skypjack/entt/blob/master/test/benchmark.cpp)
167 for further details.<br/>
168 On Github users can find also a
169 [benchmark suite](https://github.com/abeimler/ecs_benchmark) that compares a
170 bunch of different projects, one of which is `EnTT`.
171 
172 Of course, probably I'll try to get out of `EnTT` more features and better
173 performance in the future, mainly for fun.<br/>
174 If you want to contribute and/or have any suggestion, feel free to make a PR or
175 open an issue to discuss your idea.
176 
177 # Build Instructions
178 
179 ## Requirements
180 
181 To be able to use `EnTT`, users must provide a full-featured compiler that
182 supports at least C++14.<br/>
183 The requirements below are mandatory to compile the tests and to extract the
184 documentation:
185 
186 * CMake version 3.2 or later.
187 * Doxygen version 1.8 or later.
188 
189 ## Library
190 
191 `EnTT` is a header-only library. This means that including the `entt.hpp`
192 header is enough to include the whole framework and use it. For those who are
193 interested only in the entity-component system, consider to include the sole
194 `entity/registry.hpp` header instead.<br/>
195 It's a matter of adding the following line to the top of a file:
196 
197 ```cpp
198 #include <entt/entt.hpp>
199 ```
200 
201 Use the line below to include only the entity-component system instead:
202 
203 ```cpp
204 #include <entt/entity/registry.hpp>
205 ```
206 
207 Then pass the proper `-I` argument to the compiler to add the `src` directory to
208 the include paths.
209 
210 ## Documentation
211 
212 The documentation is based on [doxygen](http://www.stack.nl/~dimitri/doxygen/).
213 To build it:
214 
215  $ cd build
216  $ cmake ..
217  $ make docs
218 
219 The API reference will be created in HTML format within the directory
220 `build/docs/html`. To navigate it with your favorite browser:
221 
222  $ cd build
223  $ your_favorite_browser docs/html/index.html
224 
225 The API reference is also available [online](https://skypjack.github.io/entt/)
226 for the latest version.
227 
228 ## Tests
229 
230 To compile and run the tests, `EnTT` requires *googletest*.<br/>
231 `cmake` will download and compile the library before to compile anything else.
232 
233 To build the tests:
234 
235 * `$ cd build`
236 * `$ cmake ..`
237 * `$ make`
238 * `$ make test`
239 
240 To build the benchmarks, use the following line instead:
241 
242 * `$ cmake -DCMAKE_BUILD_TYPE=Release ..`
243 
244 Benchmarks are compiled only in release mode currently.
245 
246 # Crash Course
247 
248 ## Design choices
249 
250 `EnTT` is entirely designed around the principle that users have to pay only for
251 what they want.
252 
253 When it comes to use an entity-componet system, the tradeoff is usually between
254 performance and memory usage. The faster it is, the more memory it uses.
255 However, slightly worse performance along non-critical paths are the right price
256 to pay to reduce memory usage and I've always wondered why this kind of tools do
257 not leave me the choice.<br/>
258 `EnTT` follows a completely different approach. It squezees the best from the
259 basic data structures and gives users the possibility to pay more for higher
260 performance where needed.<br/>
261 The disadvantage of this approach is that users need to know the systems they
262 are working on and the tools they are using. Otherwise, the risk to ruin the
263 performance along critical paths is high.
264 
265 So far, this choice has proved to be a good one and I really hope it can be for
266 many others besides me.
267 
268 ## Vademecum
269 
270 The `Registry` to store, the `View`s to iterate. That's all.
271 
272 An entity (the _E_ of an _ECS_) is an opaque identifier that users should just
273 use as-is and store around if needed. Do not try to inspect an entity
274 identifier, its type can change in future and a registry offers all the
275 functionalities to query them out-of-the-box. The underlying type of an entity
276 (either `std::uint16_t`, `std::uint32_t` or `std::uint64_t`) can be specified
277 when defining a registry (actually the DefaultRegistry is nothing more than a
278 Registry where the type of the entities is `std::uint32_t`).<br/>
279 Components (the _C_ of an _ECS_) should be plain old data structures or more
280 complex and moveable data structures with a proper constructor. Actually, the
281 sole requirement of a component type is that it must be both move constructible
282 and move assignable. They are list initialized by using the parameters provided
283 to construct the component itself. No need to register components or their types
284 neither with the registry nor with the entity-component system at all.<br/>
285 Systems (the _S_ of an _ECS_) are just plain functions, functors, lambdas or
286 whatever the users want. They can accept a Registry, a View or a PersistentView
287 and use them the way they prefer. No need to register systems or their types
288 neither with the registry nor with the entity-component system at all.
289 
290 The following sections will explain in short how to use the entity-component
291 system, the core part of the whole framework.<br/>
292 In fact, the framework is composed of many other classes in addition to those
293 describe below. For more details, please refer to the
294 [online documentation](https://skypjack.github.io/entt/).
295 
296 ## The Registry, the Entity and the Component
297 
298 A registry is used to store and manage entities as well as to create views to
299 iterate the underlying data structures.<br/>
300 Registry is a class template that lets the users decide what's the preferred
301 type to represent an entity. Because `std::uint32_t` is large enough for almost
302 all the cases, there exists also an alias named DefaultRegistry for
303 `Registry<std::uint32_t>`.
304 
305 Entities are represented by _entitiy identifiers_. An entity identifier is an
306 opaque type that users should not inspect or modify in any way. It carries
307 information about the entity itself and its version.
308 
309 A registry can be used both to construct and to destroy entities:
310 
311 ```cpp
312 // constructs a naked entity with no components ad returns its identifier
313 auto entity = registry.create();
314 
315 // constructs an entity and assigns it default-initialized components
316 auto another = registry.create<Position, Velocity>();
317 
318 // destroys an entity and all its components
319 registry.destroy(entity);
320 ```
321 
322 Once an entity is deleted, the registry can freely reuse it internally with a
323 slightly different identifier. In particular, the version of an entity is
324 increased each and every time it's destroyed.<br/>
325 In case entity identifiers are stored around, the registry offers all the
326 functionalities required to test them and get out of the them all the
327 information they carry:
328 
329 ```cpp
330 // returns true if the entity is still valid, false otherwise
331 bool b = registry.valid(entity);
332 
333 // gets the version contained in the entity identifier
334 auto version = registry.version(entity);
335 
336 // gets the actual version for the given entity
337 auto curr = registry.current(entity);
338 ```
339 
340 Components can be assigned to or removed from entities at any time with a few
341 calls to member functions of the registry. As for the entities, the registry
342 offers also a set of functionalities users can use to work with the components.
343 
344 The `assign` member function template creates, initializes and assigns to an
345 entity the given component. It accepts a variable number of arguments that are
346 used to construct the component itself if present:
347 
348 ```cpp
349 registry.assign<Position>(entity, 0., 0.);
350 
351 // ...
352 
353 auto &velocity = registry.assign<Velocity>(entity);
354 velocity.dx = 0.;
355 velocity.dy = 0.;
356 ```
357 
358 If the entity already has the given component, the `replace` member function
359 template can be used to replace it:
360 
361 ```cpp
362 registry.replace<Position>(entity, 0., 0.);
363 
364 // ...
365 
366 auto &velocity = registry.replace<Velocity>(entity);
367 velocity.dx = 0.;
368 velocity.dy = 0.;
369 ```
370 
371 In case users want to assign a component to an entity, but it's unknown whether
372 the entity already has it or not, `accomodate` does the work in a single call
373 (there is a performance penalty to pay for that mainly due to the fact that it
374 must check if `entity` already has the given component or not):
375 
376 ```cpp
377 registry.accomodate<Position>(entity, 0., 0.);
378 
379 // ...
380 
381 auto &velocity = registry.accomodate<Velocity>(entity);
382 velocity.dx = 0.;
383 velocity.dy = 0.;
384 ```
385 
386 Note that `accomodate` is a sliglhty faster alternative for the following
387 `if`/`else` statement and nothing more:
388 
389 ```cpp
390 if(registry.has<Comp>(entity)) {
391  registry.replace<Comp>(entity, arg1, argN);
392 } else {
393  registry.assign<Comp>(entity, arg1, argN);
394 }
395 ```
396 
397 As already shown, if in doubt about whether or not an entity has one or more
398 components, the `has` member function template may be useful:
399 
400 ```cpp
401 bool b = registry.has<Position, Velocity>(entity);
402 ```
403 
404 On the other side, if the goal is to delete a single component, the `remove`
405 member function template is the way to go when it's certain that the entity owns
406 a copy of the component:
407 
408 ```cpp
409 registry.remove<Position>(entity);
410 ```
411 
412 Otherwise consider to use the `reset` member function. It behaves similarly to
413 `remove` but with a strictly defined behaviour (and a performance penalty is the
414 price to pay for that). In particular it removes the component if and only if it
415 exists, otherwise it returns safely to the caller:
416 
417 ```cpp
418 registry.reset<Position>(entity);
419 ```
420 
421 There exist also two other _versions_ of the `reset` member function:
422 
423 * If no entity is passed to it, `reset` will remove the given component from
424 each entity that has it:
425 
426  ```cpp
427  registry.reset<Position>();
428  ```
429 
430 * If neither the entity nor the component are specified, all the entities and
431 their components are destroyed:
432 
433  ```cpp
434  registry.reset();
435  ```
436 
437 Finally, references to components can be retrieved by just doing this:
438 
439 ```cpp
440 // either a non-const reference ...
441 DefaultRegistry registry;
442 auto &position = registry.get<Position>(entity);
443 
444 // ... or a const one
445 const auto &cregistry = registry;
446 const auto &position = cregistry.get<Position>(entity);
447 ```
448 
449 The `get` member function template gives direct access to the component of an
450 entity stored in the underlying data structures of the registry.
451 
452 ### Sorting: is it possible?
453 
454 It goes without saying that sorting entities and components is possible with
455 `EnTT`.<br/>
456 In fact, there are two functions that respond to slightly different needs:
457 
458 * Components can be sorted directly:
459 
460  ```cpp
461  registry.sort<Renderable>([](const auto &lhs, const auto &rhs) {
462  return lhs.z < rhs.z;
463  });
464  ```
465 
466 * Components can be sorted according to the order imposed by another component:
467 
468  ```cpp
469  registry.sort<Movement, Physics>();
470  ```
471 
472  In this case, instances of `Movement` are arranged in memory so that cache
473  misses are minimized when the two components are iterated together.
474 
475 ## View: to persist or not to persist?
476 
477 There are mainly two kinds of views: standard (also known as View) and
478 persistent (alsa known as PersistentView).<br/>
479 Both of them have pros and cons to take in consideration. In particular:
480 
481 * Standard views:
482 
483  Pros:
484  * They work out-of-the-box and don't require any dedicated data
485  structure.
486  * Creating and destroying them isn't expensive at all because they don't
487  have any type of initialization.
488  * They are the best tool to iterate single components.
489  * They are the best tool to iterate multiple components at once when
490  tags are involved or one of the component is assigned to a
491  significantly low number of entities.
492  * They don't affect any other operations of the registry.
493 
494  Cons:
495  * Their performance tend to degenerate when the number of components
496  to iterate grows up and the most of the entities have all of them.
497 
498 * Persistent views:
499 
500  Pros:
501  * Once prepared, creating and destroying them isn't expensive at all
502  because they don't have any type of initialization.
503  * They are the best tool to iterate multiple components at once when
504  the most of the entities have all of them.
505 
506  Cons:
507  * They have dedicated data structures and thus affect the memory
508  pressure to a minimal extent.
509  * If not previously prepared, the first time they are used they go
510  through an initialization step that could take a while.
511  * They affect to a minimum the creation and destruction of entities and
512  components. In other terms: the more persistent views there will be,
513  the less performing will be creating and destroying entities and
514  components.
515 
516 To sum up and as a rule of thumb, use a standard view:
517 * To iterate entities for a single component.
518 * To iterate entities for multiple components when a significantly low
519  number of entities have one of the components.
520 * In all those cases where a persistent view would give a boost to
521  performance but the iteration isn't performed frequently.
522 
523 Use a persistent view in all the other cases.
524 
525 To easily iterate entities, all the views offer the common `begin` and `end`
526 member functions that allow users to use a view in a typical range-for
527 loop.<br/>
528 Continue reading for more details or refer to the
529 [official documentation](https://skypjack.github.io/entt/).
530 
531 ### Standard View
532 
533 A standard view behaves differently if it's constructed for a single component
534 or if it has been requested to iterate multiple components. Even the API is
535 different in the two cases.<br/>
536 All that they share is the way they are created by means of a registry:
537 
538 ```cpp
539 // single component standard view
540 auto single = registry.view<Position>();
541 
542 // multi component standard view
543 auto multi = registry.view<Position, Velocity>();
544 ```
545 
546 For all that remains, it's worth discussing them separately.<br/>
547 
548 #### Single component standard view
549 
550 Single component standard views are specialized in order to give a boost in
551 terms of performance in all the situation. This kind of views can access the
552 underlying data structures directly and avoid superflous checks.<br/>
553 They offer a bunch of functionalities to get the number of entities they are
554 going to return and a raw access to the entity list as well as to the component
555 list.<br/>
556 Refer to the [official documentation](https://skypjack.github.io/entt/) for all
557 the details.
558 
559 There is no need to store views around for they are extremely cheap to
560 construct, even though they can be copied without problems and reused
561 freely. In fact, they return newly created and correctly initialized iterators
562 whenever `begin` or `end` are invoked.<br/>
563 To iterate a single component standard view, either use it in range-for loop:
564 
565 ```cpp
566 auto view = registry.view<Renderable>();
567 
568 for(auto entity: view) {
569  auto &renderable = view.get(entity);
570 
571  // ...
572 }
573 ```
574 
575 Or rely on the `each` member function to iterate entities and get all their
576 components at once:
577 
578 ```cpp
579 registry.view<Renderable>().each([](auto entity, auto &renderable) {
580  // ...
581 });
582 ```
583 
584 Performance are more or less the same. The best approach depends mainly on
585 whether all the components have to be accessed or not.
586 
587 **Note**: prefer the `get` member function of a view instead of the `get` member
588 function template of a registry during iterations, if possible. However, keep in
589 mind that it works only with the components of the view itself.
590 
591 #### Multi component standard view
592 
593 Multi component standard views iterate entities that have at least all the given
594 components in their bags. During construction, these views look at the number
595 of entities available for each component and pick up a reference to the smallest
596 set of candidates in order to speed up iterations.<br/>
597 They offer fewer functionalities than their companion views for single
598 component, the most important of which can be used to reset the view and refresh
599 the reference to the set of candidate entities to iterate.<br/>
600 Refer to the [official documentation](https://skypjack.github.io/entt/) for all
601 the details.
602 
603 There is no need to store views around for they are extremely cheap to
604 construct, even though they can be copied without problems and reused
605 freely. In fact, they return newly created and correctly initialized iterators
606 whenever `begin` or `end` are invoked.<br/>
607 To iterate a multi component standard view, either use it in range-for loop:
608 
609 ```cpp
610 auto view = registry.view<Position, Velocity>();
611 
612 for(auto entity: view) {
613  auto &position = view.get<Position>(entity);
614  auto &velocity = view.get<Velocity>(entity);
615 
616  // ...
617 }
618 ```
619 
620 Or rely on the `each` member function to iterate entities and get all their
621 components at once:
622 
623 ```cpp
624 registry.view<Position, Velocity>().each([](auto entity, auto &position, auto &velocity) {
625  // ...
626 });
627 ```
628 
629 Performance are more or less the same. The best approach depends mainly on
630 whether all the components have to be accessed or not.
631 
632 **Note**: prefer the `get` member function of a view instead of the `get` member
633 function template of a registry during iterations, if possible. However, keep in
634 mind that it works only with the components of the view itself.
635 
636 ### Persistent View
637 
638 A persistent view returns all the entities and only the entities that have at
639 least the given components. Moreover, it's guaranteed that the entity list is
640 thightly packed in memory for fast iterations.<br/>
641 In general, persistent views don't stay true to the order of any set of
642 components unless users explicitly sort them.
643 
644 Persistent views can be used only to iterate multiple components. Create them
645 as it follows:
646 
647 ```cpp
648 auto view = registry.persistent<Position, Velocity>();
649 ```
650 
651 There is no need to store views around for they are extremely cheap to
652 construct, even though they can be copied without problems and reused
653 freely. In fact, they return newly created and correctly initialized iterators
654 whenever `begin` or `end` are invoked.<br/>
655 That being said, persistent views perform an initialization step the very first
656 time they are constructed and this could be quite costly. To avoid it, consider
657 asking to the registry to _prepare_ them when no entities have been created yet:
658 
659 ```cpp
660 registry.prepare<Position, Velocity>();
661 ```
662 
663 If the registry is empty, preparation is extremely fast. Moreover the `prepare`
664 member function template is idempotent. Feel free to invoke it even more than
665 once: if the view has been alreadt prepared before, the function returns
666 immediately and does nothing.
667 
668 A persistent view offers a bunch of functionalities to get the number of
669 entities it's going to return, a raw access to the entity list and the
670 possibility to sort the underlying data structures according to the order of one
671 of the components for which it has been constructed.<br/>
672 Refer to the [official documentation](https://skypjack.github.io/entt/) for all
673 the details.
674 
675 To iterate a persistent view, either use it in range-for loop:
676 
677 ```cpp
678 auto view = registry.persistent<Position, Velocity>();
679 
680 for(auto entity: view) {
681  auto &position = view.get<Position>(entity);
682  auto &velocity = view.get<Velocity>(entity);
683 
684  // ...
685 }
686 ```
687 
688 Or rely on the `each` member function to iterate entities and get all their
689 components at once:
690 
691 ```cpp
692 registry.persistent<Position, Velocity>().each([](auto entity, auto &position, auto &velocity) {
693  // ...
694 });
695 ```
696 
697 Performance are more or less the same. The best approach depends mainly on
698 whether all the components have to be accessed or not.
699 
700 **Note**: prefer the `get` member function of a view instead of the `get` member
701 function template of a registry during iterations, if possible. However, keep in
702 mind that it works only with the components of the view itself.
703 
704 ## Side notes
705 
706 * Entity identifiers are numbers and nothing more. They are not classes and they
707  have no member functions at all. As already mentioned, do no try to inspect or
708  modify an entity descriptor in any way.
709 
710 * As shown in the examples above, the preferred way to get references to the
711  components while iterating a view is by using the view itself. It's a faster
712  alternative to the `get` member function template that is part of the API of
713  the Registry. That's because the registry must ensure that a pool for the
714  given component exists before to use it; on the other side, views force the
715  construction of the pools for all their components and access them directly,
716  thus avoiding all the checks.
717 
718 * Most of the _ECS_ available out there have an annoying limitation (at least
719  from my point of view): entities and components cannot be created and/or
720  deleted during iterations.<br/>
721  `EnTT` partially solves the problem with a few limitations:
722 
723  * Creating entities and components is allowed during iterations.
724  * Deleting an entity or removing its components is allowed during
725  iterations if it's the one currently returned by a view. For all the
726  other entities, destroying them or removing their components isn't
727  allowed and it can result in undefined behavior.
728 
729  Iterators are invalidated and the behaviour is undefined if an entity is
730  modified or destroyed and it's not the one currently returned by the
731  view.<br/>
732  To work around it, possible approaches are:
733 
734  * Store aside the entities and the components to be removed and perform the
735  operations at the end of the iteration.
736  * Mark entities and components with a proper tag component that indicates
737  they must be purged, then perform a second iteration to clean them up one
738  by one.
739 
740 * Views and thus their iterators aren't thread safe. Do no try to iterate a set
741  of components and modify the same set concurrently.<br/>
742  That being said, as long as a thread iterates the entities that have the
743  component `X` or assign and removes that component from a set of entities,
744  another thread can safely do the same with components `Y` and `Z` and
745  everything will work like a charm.<br/>
746  As an example, users can freely execute the rendering system and iterate the
747  renderable entities while updating a physic component concurrently on a
748  separate thread if needed.
749 
750 # Contributors
751 
752 If you want to contribute, please send patches as pull requests against the
753 branch `master`.<br/>
754 Check the
755 [contributors list](https://github.com/skypjack/entt/blob/master/AUTHORS) to see
756 who has partecipated so far.
757 
758 # License
759 
760 Code and documentation Copyright (c) 2017 Michele Caini.<br/>
761 Code released under
762 [the MIT license](https://github.com/skypjack/entt/blob/master/LICENSE).
763 Docs released under
764 [Creative Commons](https://github.com/skypjack/entt/blob/master/docs/LICENSE).
765 
766 # Donation
767 
768 Developing and maintaining `EnTT` takes some time and lots of coffee. I'd like
769 to add more and more functionalities in future and turn it in a full-featured
770 framework.<br/>
771 If you want to support this project, you can offer me an espresso. I'm from
772 Italy, we're used to turning the best coffee ever in code. If you find that
773 it's not enough, feel free to support me the way you prefer.<br/>
774 Take a look at the donation button at the top of the page for more details or
775 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).
+
1 # EnTT Framework
2 
3 [![Build Status](https://travis-ci.org/skypjack/entt.svg?branch=master)](https://travis-ci.org/skypjack/entt)
4 [![Build status](https://ci.appveyor.com/api/projects/status/rvhaabjmghg715ck?svg=true)](https://ci.appveyor.com/project/skypjack/entt)
5 [![Coverage Status](https://coveralls.io/repos/github/skypjack/entt/badge.svg?branch=master)](https://coveralls.io/github/skypjack/entt?branch=master)
6 [![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)
7 
8 # Introduction
9 
10 `EnTT` is a header-only, tiny and easy to use framework written in modern
11 C++.<br/>
12 It was originally designed entirely around an architectural pattern called _ECS_
13 that is used mostly in game development. For further details:
14 
15 * [Entity Systems Wiki](http://entity-systems.wikidot.com/)
16 * [Evolve Your Hierarchy](http://cowboyprogramming.com/2007/01/05/evolve-your-heirachy/)
17 * [ECS on Wikipedia](https://en.wikipedia.org/wiki/Entity%E2%80%93component%E2%80%93system)
18 
19 A long time ago, the sole entity-component system was part of the project. After
20 a while the codebase has grown and more and more classes have become part
21 of the repository.<br/>
22 That's why today it's called _the EnTT Framework_.
23 
24 Currently, `EnTT` is tested on Linux, Microsoft Windows and OS X. It has proven
25 to work also on both Android and iOS.<br/>
26 Most likely it will not be problematic on other systems as well, but has not
27 been sufficiently tested so far.
28 
29 ## The framework
30 
31 `EnTT` was written initially as a faster alternative to other well known and
32 open source entity-component systems. Nowadays the `EnTT` framework is moving
33 its first steps. Much more will come in the future and hopefully I'm going to
34 work on it for a long time.<br/>
35 Requests for feature, PR, suggestions ad feedback are highly appreciated.
36 
37 If you find you can help me and want to contribute to the `EnTT` framework with
38 your experience or you do want to get part of the project for some other
39 reason, feel free to contact me directly (you can find the mail in the
40 [profile](https://github.com/skypjack)).<br/>
41 I can't promise that each and every contribution will be accepted, but I can
42 assure that I'll do my best to take them all seriously.
43 
44 ### State of the art
45 
46 Here is a brief list of what it offers today:
47 
48 * Statically generated integer identifiers for types (assigned either at
49 compile-time or at runtime).
50 * A constexpr utility for human readable resource identifiers.
51 * An incredibly fast entity-component system based on sparse sets, with its own
52 views and a _pay for what you use_ policy to adjust performance and memory
53 pressure according to the users' requirements.
54 * Actor class for those who aren't confident with entity-component systems.
55 * The smallest and most basic implementation of a service locator ever seen.
56 * A cooperative scheduler for processes of any type.
57 * All what is needed for resource management (cache, loaders, handles).
58 * Signal handlers of any type, delegates and an event bus.
59 * A general purpose event emitter, that is a CRTP idiom based class template.
60 * An event dispatcher for immediate and delayed events to integrate in loops.
61 * ...
62 * Any other business.
63 
64 Consider it a work in progress. For more details and an updated list, please
65 refer to the [online documentation](https://skypjack.github.io/entt/).
66 
67 ### A note about the README
68 
69 The README file stays true to the original project and it describes only the
70 entity-component system. However, the whole API is fully documented in-code and
71 the [online documentation](https://skypjack.github.io/entt/) contains much
72 more.<br/>
73 Continue reading to know how the core part of the project works or follow the
74 link above to take a look at the API reference for all other available classes.
75 
76 ## Code Example
77 
78 ```cpp
79 #include <entt/entt.hpp>
80 #include <cstdint>
81 
82 struct Position {
83  float x;
84  float y;
85 };
86 
87 struct Velocity {
88  float dx;
89  float dy;
90 };
91 
92 void update(entt::DefaultRegistry &registry) {
93  auto view = registry.view<Position, Velocity>();
94 
95  for(auto entity: view) {
96  // gets only the components that are going to be used ...
97 
98  auto &velocity = view.get<Velocity>(entity);
99 
100  velocity.dx = 0.;
101  velocity.dy = 0.;
102 
103  // ...
104  }
105 }
106 
107 void update(std::uint64_t dt, entt::DefaultRegistry &registry) {
108  registry.view<Position, Velocity>().each([dt](auto entity, auto &position, auto &velocity) {
109  // gets all the components of the view at once ...
110 
111  position.x += velocity.dx * dt;
112  position.y += velocity.dy * dt;
113 
114  // ...
115  });
116 }
117 
118 int main() {
119  entt::DefaultRegistry registry;
120  std::uint64_t dt = 16;
121 
122  for(auto i = 0; i < 10; ++i) {
123  auto entity = registry.create(Position{i * 1.f, i * 1.f});
124  if(i % 2 == 0) { registry.assign<Velocity>(entity, i * .1f, i * .1f); }
125  }
126 
127  update(dt, registry);
128  update(registry);
129 
130  // ...
131 }
132 ```
133 
134 ## Motivation
135 
136 I started working on `EnTT` because of the wrong reason: my goal was to design
137 an entity-component system that beated another well known open source solution
138 in terms of performance.<br/>
139 I did it, of course, but it wasn't much satisfying. Actually it wasn't
140 satisfying at all. The fastest and nothing more, fairly little indeed. When I
141 realized it, I tried hard to keep intact the great performance of `EnTT` and to
142 add all the features I wanted to see in *my* entity-component system at the same
143 time.
144 
145 Today `EnTT` is finally what I was looking for: still faster than its
146 _competitors_, a really good API and an amazing set of features. And even more,
147 of course.
148 
149 ## Performance
150 
151 As it stands right now, `EnTT` is just fast enough for my requirements if
152 compared to my first choice (that was already amazingly fast indeed).<br/>
153 Here is a comparision between the two (both of them compiled with GCC 7.2.0 on a
154 Dell XPS 13 out of the mid 2014):
155 
156 | Benchmark | EntityX (compile-time) | EnTT |
157 |-----------|-------------|-------------|
158 | Create 10M entities | 0.1289s | **0.0409s** |
159 | Destroy 10M entities | **0.0531s** | 0.0546s |
160 | Standard view, 10M entities, one component | 0.0107s | **1.6e-07s** |
161 | Standard view, 10M entities, two components | **0.0113s** | 0.0295s |
162 | Standard view, 10M entities, two components<br/>Half of the entities have all the components | **0.0078s** | 0.0150s |
163 | Standard view, 10M entities, two components<br/>One of the entities has all the components | 0.0071s | **8.8e-07s** |
164 | Persistent view, 10M entities, two components | 0.0113s | **5.7e-07s** |
165 | Standard view, 10M entities, five components | **0.0091s** | 0.0688s |
166 | Persistent view, 10M entities, five components | 0.0091s | **2.9e-07s** |
167 | Standard view, 10M entities, ten components | **0.0105s** | 0.1403s |
168 | Standard view, 10M entities, ten components<br/>Half of the entities have all the components | **0.0090s** | 0.0620s |
169 | Standard view, 10M entities, ten components<br/>One of the entities has all the components | 0.0070s | **1.3e-06s** |
170 | Persistent view, 10M entities, ten components | 0.0105s | **6.2e-07s** |
171 | Sort 150k entities, one component | - | **0.0084s** |
172 | Sort 150k entities, enforce permutation | - | **0.0067s** |
173 
174 `EnTT` includes its own tests and benchmarks. See
175 [benchmark.cpp](https://github.com/skypjack/entt/blob/master/test/benchmark.cpp)
176 for further details.<br/>
177 On Github users can find also a
178 [benchmark suite](https://github.com/abeimler/ecs_benchmark) that compares a
179 bunch of different projects, one of which is `EnTT`.
180 
181 Of course, probably I'll try to get out of `EnTT` more features and better
182 performance in the future, mainly for fun.<br/>
183 If you want to contribute and/or have any suggestion, feel free to make a PR or
184 open an issue to discuss your idea.
185 
186 # Build Instructions
187 
188 ## Requirements
189 
190 To be able to use `EnTT`, users must provide a full-featured compiler that
191 supports at least C++14.<br/>
192 The requirements below are mandatory to compile the tests and to extract the
193 documentation:
194 
195 * CMake version 3.2 or later.
196 * Doxygen version 1.8 or later.
197 
198 ## Library
199 
200 `EnTT` is a header-only library. This means that including the `entt.hpp`
201 header is enough to include the whole framework and use it. For those who are
202 interested only in the entity-component system, consider to include the sole
203 `entity/registry.hpp` header instead.<br/>
204 It's a matter of adding the following line to the top of a file:
205 
206 ```cpp
207 #include <entt/entt.hpp>
208 ```
209 
210 Use the line below to include only the entity-component system instead:
211 
212 ```cpp
213 #include <entt/entity/registry.hpp>
214 ```
215 
216 Then pass the proper `-I` argument to the compiler to add the `src` directory to
217 the include paths.
218 
219 ## Documentation
220 
221 The documentation is based on [doxygen](http://www.stack.nl/~dimitri/doxygen/).
222 To build it:
223 
224  $ cd build
225  $ cmake ..
226  $ make docs
227 
228 The API reference will be created in HTML format within the directory
229 `build/docs/html`. To navigate it with your favorite browser:
230 
231  $ cd build
232  $ your_favorite_browser docs/html/index.html
233 
234 The API reference is also available [online](https://skypjack.github.io/entt/)
235 for the latest version.
236 
237 ## Tests
238 
239 To compile and run the tests, `EnTT` requires *googletest*.<br/>
240 `cmake` will download and compile the library before to compile anything else.
241 
242 To build the tests:
243 
244 * `$ cd build`
245 * `$ cmake ..`
246 * `$ make`
247 * `$ make test`
248 
249 To build the benchmarks, use the following line instead:
250 
251 * `$ cmake -DCMAKE_BUILD_TYPE=Release ..`
252 
253 Benchmarks are compiled only in release mode currently.
254 
255 # Crash Course
256 
257 ## Design choices
258 
259 ### A bitset-free entity-component system
260 
261 `EnTT` is a _bitset-free_ entity-component system that doesn't require users to
262 specify the component set at compile-time.<br/>
263 That's the reason for which users can instantiate the core class simply as:
264 
265 ```cpp
266 entt::DefaultRegistry registry;
267 ```
268 
269 In place of its more annoying and error-prone counterpart:
270 
271 ```cpp
272 entt::DefaultRegistry<Comp0, Comp1, ..., CompN> registry;
273 ```
274 
275 ### Pay per use
276 
277 `EnTT` is entirely designed around the principle that users have to pay only for
278 what they want.
279 
280 When it comes to use an entity-componet system, the tradeoff is usually between
281 performance and memory usage. The faster it is, the more memory it uses.
282 However, slightly worse performance along non-critical paths are the right price
283 to pay to reduce memory usage and I've always wondered why this kind of tools do
284 not leave me the choice.<br/>
285 `EnTT` follows a completely different approach. It squezees the best from the
286 basic data structures and gives users the possibility to pay more for higher
287 performance where needed.<br/>
288 The disadvantage of this approach is that users need to know the systems they
289 are working on and the tools they are using. Otherwise, the risk to ruin the
290 performance along critical paths is high.
291 
292 So far, this choice has proven to be a good one and I really hope it can be for
293 many others besides me.
294 
295 ## Vademecum
296 
297 The `Registry` to store, the `View`s to iterate. That's all.
298 
299 An entity (the _E_ of an _ECS_) is an opaque identifier that users should just
300 use as-is and store around if needed. Do not try to inspect an entity
301 identifier, its type can change in future and a registry offers all the
302 functionalities to query them out-of-the-box. The underlying type of an entity
303 (either `std::uint16_t`, `std::uint32_t` or `std::uint64_t`) can be specified
304 when defining a registry (actually the DefaultRegistry is nothing more than a
305 Registry where the type of the entities is `std::uint32_t`).<br/>
306 Components (the _C_ of an _ECS_) should be plain old data structures or more
307 complex and moveable data structures with a proper constructor. Actually, the
308 sole requirement of a component type is that it must be both move constructible
309 and move assignable. They are list initialized by using the parameters provided
310 to construct the component itself. No need to register components or their types
311 neither with the registry nor with the entity-component system at all.<br/>
312 Systems (the _S_ of an _ECS_) are just plain functions, functors, lambdas or
313 whatever the users want. They can accept a Registry, a View or a PersistentView
314 and use them the way they prefer. No need to register systems or their types
315 neither with the registry nor with the entity-component system at all.
316 
317 The following sections will explain in short how to use the entity-component
318 system, the core part of the whole framework.<br/>
319 In fact, the framework is composed of many other classes in addition to those
320 describe below. For more details, please refer to the
321 [online documentation](https://skypjack.github.io/entt/).
322 
323 ## The Registry, the Entity and the Component
324 
325 A registry is used to store and manage entities as well as to create views to
326 iterate the underlying data structures.<br/>
327 Registry is a class template that lets the users decide what's the preferred
328 type to represent an entity. Because `std::uint32_t` is large enough for almost
329 all the cases, there exists also an alias named DefaultRegistry for
330 `Registry<std::uint32_t>`.
331 
332 Entities are represented by _entitiy identifiers_. An entity identifier is an
333 opaque type that users should not inspect or modify in any way. It carries
334 information about the entity itself and its version.
335 
336 A registry can be used both to construct and to destroy entities:
337 
338 ```cpp
339 // constructs a naked entity with no components ad returns its identifier
340 auto entity = registry.create();
341 
342 // constructs an entity and assigns it default-initialized components
343 auto another = registry.create<Position, Velocity>();
344 
345 // destroys an entity and all its components
346 registry.destroy(entity);
347 ```
348 
349 Once an entity is deleted, the registry can freely reuse it internally with a
350 slightly different identifier. In particular, the version of an entity is
351 increased each and every time it's destroyed.<br/>
352 In case entity identifiers are stored around, the registry offers all the
353 functionalities required to test them and get out of the them all the
354 information they carry:
355 
356 ```cpp
357 // returns true if the entity is still valid, false otherwise
358 bool b = registry.valid(entity);
359 
360 // gets the version contained in the entity identifier
361 auto version = registry.version(entity);
362 
363 // gets the actual version for the given entity
364 auto curr = registry.current(entity);
365 ```
366 
367 Components can be assigned to or removed from entities at any time with a few
368 calls to member functions of the registry. As for the entities, the registry
369 offers also a set of functionalities users can use to work with the components.
370 
371 The `assign` member function template creates, initializes and assigns to an
372 entity the given component. It accepts a variable number of arguments that are
373 used to construct the component itself if present:
374 
375 ```cpp
376 registry.assign<Position>(entity, 0., 0.);
377 
378 // ...
379 
380 auto &velocity = registry.assign<Velocity>(entity);
381 velocity.dx = 0.;
382 velocity.dy = 0.;
383 ```
384 
385 If the entity already has the given component, the `replace` member function
386 template can be used to replace it:
387 
388 ```cpp
389 registry.replace<Position>(entity, 0., 0.);
390 
391 // ...
392 
393 auto &velocity = registry.replace<Velocity>(entity);
394 velocity.dx = 0.;
395 velocity.dy = 0.;
396 ```
397 
398 In case users want to assign a component to an entity, but it's unknown whether
399 the entity already has it or not, `accomodate` does the work in a single call
400 (there is a performance penalty to pay for that mainly due to the fact that it
401 must check if `entity` already has the given component or not):
402 
403 ```cpp
404 registry.accomodate<Position>(entity, 0., 0.);
405 
406 // ...
407 
408 auto &velocity = registry.accomodate<Velocity>(entity);
409 velocity.dx = 0.;
410 velocity.dy = 0.;
411 ```
412 
413 Note that `accomodate` is a sliglhty faster alternative for the following
414 `if`/`else` statement and nothing more:
415 
416 ```cpp
417 if(registry.has<Comp>(entity)) {
418  registry.replace<Comp>(entity, arg1, argN);
419 } else {
420  registry.assign<Comp>(entity, arg1, argN);
421 }
422 ```
423 
424 As already shown, if in doubt about whether or not an entity has one or more
425 components, the `has` member function template may be useful:
426 
427 ```cpp
428 bool b = registry.has<Position, Velocity>(entity);
429 ```
430 
431 On the other side, if the goal is to delete a single component, the `remove`
432 member function template is the way to go when it's certain that the entity owns
433 a copy of the component:
434 
435 ```cpp
436 registry.remove<Position>(entity);
437 ```
438 
439 Otherwise consider to use the `reset` member function. It behaves similarly to
440 `remove` but with a strictly defined behaviour (and a performance penalty is the
441 price to pay for that). In particular it removes the component if and only if it
442 exists, otherwise it returns safely to the caller:
443 
444 ```cpp
445 registry.reset<Position>(entity);
446 ```
447 
448 There exist also two other _versions_ of the `reset` member function:
449 
450 * If no entity is passed to it, `reset` will remove the given component from
451 each entity that has it:
452 
453  ```cpp
454  registry.reset<Position>();
455  ```
456 
457 * If neither the entity nor the component are specified, all the entities and
458 their components are destroyed:
459 
460  ```cpp
461  registry.reset();
462  ```
463 
464 Finally, references to components can be retrieved simply by doing this:
465 
466 ```cpp
467 // either a non-const reference ...
468 entt::DefaultRegistry registry;
469 auto &position = registry.get<Position>(entity);
470 
471 // ... or a const one
472 const auto &cregistry = registry;
473 const auto &position = cregistry.get<Position>(entity);
474 ```
475 
476 The `get` member function template gives direct access to the component of an
477 entity stored in the underlying data structures of the registry.
478 
479 ### Single instance components
480 
481 In those cases where all what is needed is a single instance component, tags are
482 the right tool to achieve the purpose.<br/>
483 Tags undergo the same requirements of components. They can be either plain old
484 data structures or more complex and moveable data structures with a proper
485 constructor.<br/>
486 Actually, the same type can be used both as a tag and as a component and the
487 registry will not complain about it. It is up to the users to properly manage
488 their own types.
489 
490 Attaching tags to entities and removing them is trivial:
491 
492 ```cpp
493 auto player = registry.create();
494 auto camera = registry.create();
495 
496 // attaches a default-initialized tag to an entity
497 registry.attach<PlayingCharacter>(player);
498 
499 // attaches a tag to an entity and initializes it
500 registry.attach<Camera>(camera, player);
501 
502 // removes tags from their owners
503 registry.remove<PlayingCharacter>();
504 registry.remove<Camera>();
505 ```
506 
507 If in doubt about whether or not a tag has already an owner, the `has` member
508 function template may be useful:
509 
510 ```cpp
511 bool b = registry.has<PlayingCharacter>();
512 ```
513 
514 References to tags can be retrieved simply by doing this:
515 
516 ```cpp
517 // either a non-const reference ...
518 entt::DefaultRegistry registry;
519 auto &player = registry.get<PlayingCharacter>();
520 
521 // ... or a const one
522 const auto &cregistry = registry;
523 const auto &camera = cregistry.get<Camera>();
524 ```
525 
526 The `get` member function template gives direct access to the tag as stored in
527 the underlying data structures of the registry.
528 
529 As shown above, in almost all the cases the entity identifier isn't required,
530 since a single instance component can have only one associated entity and
531 therefore it doesn't make much sense to mention it explicitly.<br/>
532 To find out who the owner is, just do the following:
533 
534 ```cpp
535 auto player = registry.attachee<PlayingCharacter>();
536 ```
537 
538 Note that iterating tags isn't possible for obvious reasons. Tags give direct
539 access to single entities and nothing more.
540 
541 ### Sorting: is it possible?
542 
543 It goes without saying that sorting entities and components is possible with
544 `EnTT`.<br/>
545 In fact, there are two functions that respond to slightly different needs:
546 
547 * Components can be sorted directly:
548 
549  ```cpp
550  registry.sort<Renderable>([](const auto &lhs, const auto &rhs) {
551  return lhs.z < rhs.z;
552  });
553  ```
554 
555 * Components can be sorted according to the order imposed by another component:
556 
557  ```cpp
558  registry.sort<Movement, Physics>();
559  ```
560 
561  In this case, instances of `Movement` are arranged in memory so that cache
562  misses are minimized when the two components are iterated together.
563 
564 ## View: to persist or not to persist?
565 
566 There are mainly two kinds of views: standard (also known as View) and
567 persistent (alsa known as PersistentView).<br/>
568 Both of them have pros and cons to take in consideration. In particular:
569 
570 * Standard views:
571 
572  Pros:
573  * They work out-of-the-box and don't require any dedicated data
574  structure.
575  * Creating and destroying them isn't expensive at all because they don't
576  have any type of initialization.
577  * They are the best tool to iterate single components.
578  * They are the best tool to iterate multiple components at once when
579  tags are involved or one of the component is assigned to a
580  significantly low number of entities.
581  * They don't affect any other operations of the registry.
582 
583  Cons:
584  * Their performance tend to degenerate when the number of components
585  to iterate grows up and the most of the entities have all of them.
586 
587 * Persistent views:
588 
589  Pros:
590  * Once prepared, creating and destroying them isn't expensive at all
591  because they don't have any type of initialization.
592  * They are the best tool to iterate multiple components at once when
593  the most of the entities have all of them.
594 
595  Cons:
596  * They have dedicated data structures and thus affect the memory
597  pressure to a minimal extent.
598  * If not previously prepared, the first time they are used they go
599  through an initialization step that could take a while.
600  * They affect to a minimum the creation and destruction of entities and
601  components. In other terms: the more persistent views there will be,
602  the less performing will be creating and destroying entities and
603  components.
604 
605 To sum up and as a rule of thumb, use a standard view:
606 * To iterate entities for a single component.
607 * To iterate entities for multiple components when a significantly low
608  number of entities have one of the components.
609 * In all those cases where a persistent view would give a boost to
610  performance but the iteration isn't performed frequently.
611 
612 Use a persistent view in all the other cases.
613 
614 To easily iterate entities, all the views offer the common `begin` and `end`
615 member functions that allow users to use a view in a typical range-for
616 loop.<br/>
617 Continue reading for more details or refer to the
618 [official documentation](https://skypjack.github.io/entt/).
619 
620 ### Standard View
621 
622 A standard view behaves differently if it's constructed for a single component
623 or if it has been requested to iterate multiple components. Even the API is
624 different in the two cases.<br/>
625 All that they share is the way they are created by means of a registry:
626 
627 ```cpp
628 // single component standard view
629 auto single = registry.view<Position>();
630 
631 // multi component standard view
632 auto multi = registry.view<Position, Velocity>();
633 ```
634 
635 For all that remains, it's worth discussing them separately.<br/>
636 
637 #### Single component standard view
638 
639 Single component standard views are specialized in order to give a boost in
640 terms of performance in all the situation. This kind of views can access the
641 underlying data structures directly and avoid superflous checks.<br/>
642 They offer a bunch of functionalities to get the number of entities they are
643 going to return and a raw access to the entity list as well as to the component
644 list.<br/>
645 Refer to the [official documentation](https://skypjack.github.io/entt/) for all
646 the details.
647 
648 There is no need to store views around for they are extremely cheap to
649 construct, even though they can be copied without problems and reused
650 freely. In fact, they return newly created and correctly initialized iterators
651 whenever `begin` or `end` are invoked.<br/>
652 To iterate a single component standard view, either use it in range-for loop:
653 
654 ```cpp
655 auto view = registry.view<Renderable>();
656 
657 for(auto entity: view) {
658  auto &renderable = view.get(entity);
659 
660  // ...
661 }
662 ```
663 
664 Or rely on the `each` member function to iterate entities and get all their
665 components at once:
666 
667 ```cpp
668 registry.view<Renderable>().each([](auto entity, auto &renderable) {
669  // ...
670 });
671 ```
672 
673 Performance are more or less the same. The best approach depends mainly on
674 whether all the components have to be accessed or not.
675 
676 **Note**: prefer the `get` member function of a view instead of the `get` member
677 function template of a registry during iterations, if possible. However, keep in
678 mind that it works only with the components of the view itself.
679 
680 #### Multi component standard view
681 
682 Multi component standard views iterate entities that have at least all the given
683 components in their bags. During construction, these views look at the number
684 of entities available for each component and pick up a reference to the smallest
685 set of candidates in order to speed up iterations.<br/>
686 They offer fewer functionalities than their companion views for single
687 component, the most important of which can be used to reset the view and refresh
688 the reference to the set of candidate entities to iterate.<br/>
689 Refer to the [official documentation](https://skypjack.github.io/entt/) for all
690 the details.
691 
692 There is no need to store views around for they are extremely cheap to
693 construct, even though they can be copied without problems and reused
694 freely. In fact, they return newly created and correctly initialized iterators
695 whenever `begin` or `end` are invoked.<br/>
696 To iterate a multi component standard view, either use it in range-for loop:
697 
698 ```cpp
699 auto view = registry.view<Position, Velocity>();
700 
701 for(auto entity: view) {
702  auto &position = view.get<Position>(entity);
703  auto &velocity = view.get<Velocity>(entity);
704 
705  // ...
706 }
707 ```
708 
709 Or rely on the `each` member function to iterate entities and get all their
710 components at once:
711 
712 ```cpp
713 registry.view<Position, Velocity>().each([](auto entity, auto &position, auto &velocity) {
714  // ...
715 });
716 ```
717 
718 Performance are more or less the same. The best approach depends mainly on
719 whether all the components have to be accessed or not.
720 
721 **Note**: prefer the `get` member function of a view instead of the `get` member
722 function template of a registry during iterations, if possible. However, keep in
723 mind that it works only with the components of the view itself.
724 
725 ### Persistent View
726 
727 A persistent view returns all the entities and only the entities that have at
728 least the given components. Moreover, it's guaranteed that the entity list is
729 thightly packed in memory for fast iterations.<br/>
730 In general, persistent views don't stay true to the order of any set of
731 components unless users explicitly sort them.
732 
733 Persistent views can be used only to iterate multiple components. Create them
734 as it follows:
735 
736 ```cpp
737 auto view = registry.persistent<Position, Velocity>();
738 ```
739 
740 There is no need to store views around for they are extremely cheap to
741 construct, even though they can be copied without problems and reused
742 freely. In fact, they return newly created and correctly initialized iterators
743 whenever `begin` or `end` are invoked.<br/>
744 That being said, persistent views perform an initialization step the very first
745 time they are constructed and this could be quite costly. To avoid it, consider
746 asking to the registry to _prepare_ them when no entities have been created yet:
747 
748 ```cpp
749 registry.prepare<Position, Velocity>();
750 ```
751 
752 If the registry is empty, preparation is extremely fast. Moreover the `prepare`
753 member function template is idempotent. Feel free to invoke it even more than
754 once: if the view has been alreadt prepared before, the function returns
755 immediately and does nothing.
756 
757 A persistent view offers a bunch of functionalities to get the number of
758 entities it's going to return, a raw access to the entity list and the
759 possibility to sort the underlying data structures according to the order of one
760 of the components for which it has been constructed.<br/>
761 Refer to the [official documentation](https://skypjack.github.io/entt/) for all
762 the details.
763 
764 To iterate a persistent view, either use it in range-for loop:
765 
766 ```cpp
767 auto view = registry.persistent<Position, Velocity>();
768 
769 for(auto entity: view) {
770  auto &position = view.get<Position>(entity);
771  auto &velocity = view.get<Velocity>(entity);
772 
773  // ...
774 }
775 ```
776 
777 Or rely on the `each` member function to iterate entities and get all their
778 components at once:
779 
780 ```cpp
781 registry.persistent<Position, Velocity>().each([](auto entity, auto &position, auto &velocity) {
782  // ...
783 });
784 ```
785 
786 Performance are more or less the same. The best approach depends mainly on
787 whether all the components have to be accessed or not.
788 
789 **Note**: prefer the `get` member function of a view instead of the `get` member
790 function template of a registry during iterations, if possible. However, keep in
791 mind that it works only with the components of the view itself.
792 
793 ## Side notes
794 
795 * Entity identifiers are numbers and nothing more. They are not classes and they
796  have no member functions at all. As already mentioned, do no try to inspect or
797  modify an entity descriptor in any way.
798 
799 * As shown in the examples above, the preferred way to get references to the
800  components while iterating a view is by using the view itself. It's a faster
801  alternative to the `get` member function template that is part of the API of
802  the Registry. That's because the registry must ensure that a pool for the
803  given component exists before to use it; on the other side, views force the
804  construction of the pools for all their components and access them directly,
805  thus avoiding all the checks.
806 
807 * Most of the _ECS_ available out there have an annoying limitation (at least
808  from my point of view): entities and components cannot be created and/or
809  deleted during iterations.<br/>
810  `EnTT` partially solves the problem with a few limitations:
811 
812  * Creating entities and components is allowed during iterations.
813  * Deleting an entity or removing its components is allowed during
814  iterations if it's the one currently returned by a view. For all the
815  other entities, destroying them or removing their components isn't
816  allowed and it can result in undefined behavior.
817 
818  Iterators are invalidated and the behaviour is undefined if an entity is
819  modified or destroyed and it's not the one currently returned by the
820  view.<br/>
821  To work around it, possible approaches are:
822 
823  * Store aside the entities and the components to be removed and perform the
824  operations at the end of the iteration.
825  * Mark entities and components with a proper tag component that indicates
826  they must be purged, then perform a second iteration to clean them up one
827  by one.
828 
829 * Views and thus their iterators aren't thread safe. Do no try to iterate a set
830  of components and modify the same set concurrently.<br/>
831  That being said, as long as a thread iterates the entities that have the
832  component `X` or assign and removes that component from a set of entities,
833  another thread can safely do the same with components `Y` and `Z` and
834  everything will work like a charm.<br/>
835  As an example, users can freely execute the rendering system and iterate the
836  renderable entities while updating a physic component concurrently on a
837  separate thread if needed.
838 
839 # Contributors
840 
841 If you want to contribute, please send patches as pull requests against the
842 branch `master`.<br/>
843 Check the
844 [contributors list](https://github.com/skypjack/entt/blob/master/AUTHORS) to see
845 who has partecipated so far.
846 
847 # License
848 
849 Code and documentation Copyright (c) 2017 Michele Caini.<br/>
850 Code released under
851 [the MIT license](https://github.com/skypjack/entt/blob/master/LICENSE).
852 Docs released under
853 [Creative Commons](https://github.com/skypjack/entt/blob/master/docs/LICENSE).
854 
855 # Donation
856 
857 Developing and maintaining `EnTT` takes some time and lots of coffee. I'd like
858 to add more and more functionalities in future and turn it in a full-featured
859 framework.<br/>
860 If you want to support this project, you can offer me an espresso. I'm from
861 Italy, we're used to turning the best coffee ever in code. If you find that
862 it's not enough, feel free to support me the way you prefer.<br/>
863 Take a look at the donation button at the top of the page for more details or
864 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).
Generated by   diff --git a/actor_8hpp_source.html b/actor_8hpp_source.html new file mode 100644 index 000000000..197694a6c --- /dev/null +++ b/actor_8hpp_source.html @@ -0,0 +1,92 @@ + + + + + + + +entt: src/entt/entity/actor.hpp Source File + + + + + + + + + + +
+
+
actor.hpp
+
+
+
1 #ifndef ENTT_ENTITY_ACTOR_HPP
2 #define ENTT_ENTITY_ACTOR_HPP
3 
4 
5 #include <utility>
6 #include "registry.hpp"
7 
8 
9 namespace entt {
10 
11 
21 template<typename Entity, typename Delta>
22 struct Actor {
24  using registry_type = Registry<Entity>;
26  using delta_type = Delta;
27 
32  Actor(Registry<Entity> &reg)
33  : reg{reg}, entity{reg.create()}
34  {}
35 
37  virtual ~Actor() {
38  reg.destroy(entity);
39  }
40 
42  Actor(const Actor &) = default;
44  Actor(Actor &&) = default;
45 
47  Actor & operator=(const Actor &) = default;
49  Actor & operator=(Actor &&) = default;
50 
65  template<typename Component, typename... Args>
66  Component & set(Args&&... args) {
67  return reg.template accomodate<Component>(entity, std::forward<Args>(args)...);
68  }
69 
74  template<typename Component>
75  void unset() {
76  reg.template remove<Component>(entity);
77  }
78 
84  template<typename Component>
85  bool has() const noexcept {
86  return reg.template has<Component>(entity);
87  }
88 
94  template<typename Component>
95  const Component & get() const noexcept {
96  return reg.template get<Component>(entity);
97  }
98 
104  template<typename Component>
105  Component & get() noexcept {
106  return const_cast<Component &>(const_cast<const Actor *>(this)->get<Component>());
107  }
108 
113  const registry_type & registry() const noexcept {
114  return reg;
115  }
116 
121  registry_type & registry() noexcept {
122  return const_cast<registry_type &>(const_cast<const Actor *>(this)->registry());
123  }
124 
129  virtual void update(delta_type delta) = 0;
130 
131 private:
132  registry_type &reg;
133  Entity entity;
134 };
135 
136 
145 template<typename Delta>
146 using DefaultActor = Actor<std::uint32_t, Delta>;
147 
148 
149 }
150 
151 
152 #endif // ENTT_ENTITY_ACTOR_HPP
entt::Registry
Fast and reliable entity-component system.
Definition: registry.hpp:31
+
entt
EnTT default namespace.
Definition: family.hpp:9
+
entt::Actor::operator=
Actor & operator=(const Actor &)=default
Default copy assignment operator.
+
entt::Actor::update
virtual void update(delta_type delta)=0
Updates an actor, whatever it means to update it.
+
entt::Actor::Actor
Actor(Registry< Entity > &reg)
Constructs an actor by using the given registry.
Definition: actor.hpp:32
+
entt::Actor::delta_type
Delta delta_type
Type used to provide elapsed time.
Definition: actor.hpp:26
+
entt::Registry::create
entity_type create(Component &&... components) noexcept
Returns a new entity initialized with the given components.
Definition: registry.hpp:285
+
entt::Actor
Dedicated to those who aren&#39;t confident with entity-component systems.
Definition: actor.hpp:22
+
entt::Actor::has
bool has() const noexcept
Checks if an actor has the given component.
Definition: actor.hpp:85
+
entt::Actor::registry
const registry_type & registry() const noexcept
Returns a reference to the underlying registry.
Definition: actor.hpp:113
+
entt::Registry::destroy
void destroy(entity_type entity)
Destroys an entity and lets the registry recycle the identifier.
Definition: registry.hpp:368
+
entt::Actor::~Actor
virtual ~Actor()
Default destructor.
Definition: actor.hpp:37
+
entt::Actor::unset
void unset()
Removes the given component from an actor.
Definition: actor.hpp:75
+
entt::Actor::registry
registry_type & registry() noexcept
Returns a reference to the underlying registry.
Definition: actor.hpp:121
+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/annotated.html b/annotated.html index fdad8ab57..65cb1381c 100644 --- a/annotated.html +++ b/annotated.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0
@@ -66,31 +66,39 @@ $(function() {
Here are the classes, structs, unions and interfaces with brief descriptions:
[detail level 123]
- - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
 ▼NenttEnTT default namespace
 CBusMinimal event bus
 CBus< Sig, Event >Event bus specialization for a single type
 CBus< Sig, Event, Other... >Event bus specialization for multiple types
 CDelegateBasic delegate implementation
 CDelegate< Ret(Args...)>A delegate 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
 CPersistentViewPersistent view
 CRegistryFast and reliable entity-component system
 CServiceLocatorService locator, nothing more
 CSigHUnmanaged signal handler declaration
 CSigH< Ret(Args...), Collector >Unmanaged signal handler definition
 CSignalManaged signal handler declaration
 CSignal< void(Args...)>Managed signal handler definition
 CSparseSetSparse set
 CSparseSet< Entity >Basic sparse set implementation
 CSparseSet< Entity, Type >Extended sparse set implementation
 CViewMulti component view
 CView< Entity, Component >Single component view specialization
 CActorDedicated to those who aren't confident with entity-component systems
 CBusMinimal event bus
 CBus< Sig, Event >Event bus specialization for a single type
 CBus< Sig, Event, Other... >Event bus specialization for multiple types
 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
 CPersistentViewPersistent view
 CProcessBase class for processes
 CProcessAdaptorAdaptor for lambdas and functors to turn them into processes
 CRegistryFast and reliable entity-component system
 CResourceCacheSimple cache for resources of a given type
 CResourceHandleShared resource handle
 CResourceLoaderBase class for resource loaders
 CSchedulerCooperative scheduler for processes
 CServiceLocatorService locator, nothing more
 CSigHUnmanaged signal handler declaration
 CSigH< Ret(Args...), Collector >Unmanaged signal handler definition
 CSignalManaged signal handler declaration
 CSignal< void(Args...)>Managed signal handler definition
 CSparseSetSparse set
 CSparseSet< Entity >Basic sparse set implementation
 CSparseSet< Entity, Type >Extended sparse set implementation
 CViewMulti component view
 CView< Entity, Component >Single component view specialization
diff --git a/bus_8hpp_source.html b/bus_8hpp_source.html index 24796007f..4095d052d 100644 --- a/bus_8hpp_source.html +++ b/bus_8hpp_source.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0
@@ -67,24 +67,26 @@ $(function() {
bus.hpp
-
1 #ifndef ENTT_SIGNAL_BUS_HPP
2 #define ENTT_SIGNAL_BUS_HPP
3 
4 
5 #include <cstddef>
6 #include <utility>
7 #include "signal.hpp"
8 #include "sigh.hpp"
9 
10 
11 namespace entt {
12 
13 
21 template<template<typename...> class, typename...>
22 class Bus;
23 
24 
41 template<template<typename...> class Sig, typename Event, typename... Other>
42 class Bus<Sig, Event, Other...>
43  : private Bus<Sig, Event>, private Bus<Sig, Other>...
44 {
45 public:
47  using size_type = std::size_t;
48 
50  explicit Bus() noexcept = default;
52  ~Bus() noexcept = default;
53 
55  Bus(const Bus &) = default;
57  Bus(Bus &&) = default;
58 
60  Bus & operator=(const Bus &) = default;
62  Bus & operator=(Bus &&) = default;
63 
76  template<typename Instance>
77  void unreg(Instance instance) {
78  using accumulator_type = int[];
79  accumulator_type accumulator = {
80  (Bus<Sig, Event>::unreg(instance), 0),
81  (Bus<Sig, Other>::unreg(instance), 0)...
82  };
83  return void(accumulator);
84  }
85 
98  template<typename Instance>
99  void reg(Instance instance) {
100  using accumulator_type = int[];
101  accumulator_type accumulator = {
102  (Bus<Sig, Event>::reg(instance), 0),
103  (Bus<Sig, Other>::reg(instance), 0)...
104  };
105  return void(accumulator);
106  }
107 
112  size_type size() const noexcept {
113  using accumulator_type = std::size_t[];
114  std::size_t sz = Bus<Sig, Event>::size();
115  accumulator_type accumulator = { sz, (sz += Bus<Sig, Other>::size())... };
116  return void(accumulator), sz;
117  }
118 
123  bool empty() const noexcept {
124  using accumulator_type = bool[];
125  bool ret = Bus<Sig, Event>::empty();
126  accumulator_type accumulator = { ret, (ret = ret && Bus<Sig, Other>::empty())... };
127  return void(accumulator), ret;
128  }
129 
135  template<typename Type, void(*Function)(const Type &)>
136  void connect() {
137  Bus<Sig, Type>::template connect<Function>();
138  }
139 
145  template<typename Type, void(*Function)(const Type &)>
146  void disconnect() {
147  Bus<Sig, Type>::template disconnect<Function>();
148  }
149 
159  template<typename Type, typename... Args>
160  void publish(Args&&... args) {
161  Bus<Sig, Type>::publish(std::forward<Args>(args)...);
162  }
163 };
164 
165 
180 template<template<typename...> class Sig, typename Event>
181 class Bus<Sig, Event> {
182  using signal_type = Sig<void(const Event &)>;
183 
184  template<typename Class>
185  using instance_type = typename signal_type::template instance_type<Class>;
186 
187  template<typename Class>
188  auto disconnect(int, instance_type<Class> instance)
189  -> decltype(std::declval<Class>().receive(std::declval<Event>()), void()) {
190  signal.template disconnect<Class, &Class::receive>(std::move(instance));
191  }
192 
193  template<typename Class>
194  auto connect(int, instance_type<Class> instance)
195  -> decltype(std::declval<Class>().receive(std::declval<Event>()), void()) {
196  signal.template connect<Class, &Class::receive>(std::move(instance));
197  }
198 
199  template<typename Class> void disconnect(char, instance_type<Class>) {}
200  template<typename Class> void connect(char, instance_type<Class>) {}
201 
202 public:
204  using size_type = typename signal_type::size_type;
205 
207  explicit Bus() noexcept = default;
209  virtual ~Bus() noexcept = default;
210 
212  Bus(const Bus &) = default;
214  Bus(Bus &&) = default;
215 
217  Bus & operator=(const Bus &) = default;
219  Bus & operator=(Bus &&) = default;
220 
232  template<typename Class>
233  void unreg(instance_type<Class> instance) {
234  disconnect(0, std::move(instance));
235  }
236 
248  template<typename Class>
249  void reg(instance_type<Class> instance) {
250  connect(0, std::move(instance));
251  }
252 
257  size_type size() const noexcept {
258  return signal.size();
259  }
260 
265  bool empty() const noexcept {
266  return signal.empty();
267  }
268 
273  template<void(*Function)(const Event &)>
274  void connect() {
275  signal.template connect<Function>();
276  }
277 
282  template<void(*Function)(const Event &)>
283  void disconnect() {
284  signal.template disconnect<Function>();
285  }
286 
295  template<typename... Args>
296  void publish(Args&&... args) {
297  signal.publish({ std::forward<Args>(args)... });
298  }
299 
300 private:
301  signal_type signal;
302 };
303 
304 
314 template<typename... Event>
315 using ManagedBus = Bus<Signal, Event...>;
316 
328 template<typename... Event>
329 using UnmanagedBus = Bus<SigH, Event...>;
330 
331 
332 }
333 
334 
335 #endif // ENTT_SIGNAL_BUS_HPP
entt::Bus< Sig, Event >::disconnect
void disconnect()
Disconnects a free function from the bus.
Definition: bus.hpp:283
-
entt::Bus< Sig, Event >::size
size_type size() const noexcept
Number of listeners connected to the bus.
Definition: bus.hpp:257
-
entt::Bus< Sig, Event, Other... >::connect
void connect()
Connects a free function to the bus.
Definition: bus.hpp:136
-
entt::Bus< Sig, Event >::size_type
typename signal_type::size_type size_type
Unsigned integer type.
Definition: bus.hpp:204
+
1 #ifndef ENTT_SIGNAL_BUS_HPP
2 #define ENTT_SIGNAL_BUS_HPP
3 
4 
5 #include <cstddef>
6 #include <utility>
7 #include "signal.hpp"
8 #include "sigh.hpp"
9 
10 
11 namespace entt {
12 
13 
21 template<template<typename...> class, typename...>
22 class Bus;
23 
24 
41 template<template<typename...> class Sig, typename Event, typename... Other>
42 class Bus<Sig, Event, Other...>
43  : private Bus<Sig, Event>, private Bus<Sig, Other>...
44 {
45 public:
47  using size_type = std::size_t;
48 
61  template<typename Instance>
62  void unreg(Instance instance) {
63  using accumulator_type = int[];
64  accumulator_type accumulator = {
65  (Bus<Sig, Event>::unreg(instance), 0),
66  (Bus<Sig, Other>::unreg(instance), 0)...
67  };
68  return void(accumulator);
69  }
70 
83  template<typename Instance>
84  void reg(Instance instance) {
85  using accumulator_type = int[];
86  accumulator_type accumulator = {
87  (Bus<Sig, Event>::reg(instance), 0),
88  (Bus<Sig, Other>::reg(instance), 0)...
89  };
90  return void(accumulator);
91  }
92 
97  size_type size() const noexcept {
98  using accumulator_type = std::size_t[];
99  std::size_t sz = Bus<Sig, Event>::size();
100  accumulator_type accumulator = { sz, (sz += Bus<Sig, Other>::size())... };
101  return void(accumulator), sz;
102  }
103 
108  bool empty() const noexcept {
109  using accumulator_type = bool[];
110  bool ret = Bus<Sig, Event>::empty();
111  accumulator_type accumulator = { ret, (ret = ret && Bus<Sig, Other>::empty())... };
112  return void(accumulator), ret;
113  }
114 
120  template<typename Type, void(*Function)(const Type &)>
121  void connect() {
122  Bus<Sig, Type>::template connect<Function>();
123  }
124 
130  template<typename Type, void(*Function)(const Type &)>
131  void disconnect() {
132  Bus<Sig, Type>::template disconnect<Function>();
133  }
134 
144  template<typename Type, typename... Args>
145  void publish(Args&&... args) {
146  Bus<Sig, Type>::publish(std::forward<Args>(args)...);
147  }
148 };
149 
150 
165 template<template<typename...> class Sig, typename Event>
166 class Bus<Sig, Event> {
167  using signal_type = Sig<void(const Event &)>;
168 
169  template<typename Class>
170  using instance_type = typename signal_type::template instance_type<Class>;
171 
172  template<typename Class>
173  auto disconnect(int, instance_type<Class> instance)
174  -> decltype(std::declval<Class>().receive(std::declval<Event>()), void()) {
175  signal.template disconnect<Class, &Class::receive>(std::move(instance));
176  }
177 
178  template<typename Class>
179  auto connect(int, instance_type<Class> instance)
180  -> decltype(std::declval<Class>().receive(std::declval<Event>()), void()) {
181  signal.template connect<Class, &Class::receive>(std::move(instance));
182  }
183 
184  template<typename Class> void disconnect(char, instance_type<Class>) {}
185  template<typename Class> void connect(char, instance_type<Class>) {}
186 
187 public:
189  using size_type = typename signal_type::size_type;
190 
202  template<typename Class>
203  void unreg(instance_type<Class> instance) {
204  disconnect(0, std::move(instance));
205  }
206 
218  template<typename Class>
219  void reg(instance_type<Class> instance) {
220  connect(0, std::move(instance));
221  }
222 
227  size_type size() const noexcept {
228  return signal.size();
229  }
230 
235  bool empty() const noexcept {
236  return signal.empty();
237  }
238 
243  template<void(*Function)(const Event &)>
244  void connect() {
245  signal.template connect<Function>();
246  }
247 
252  template<void(*Function)(const Event &)>
253  void disconnect() {
254  signal.template disconnect<Function>();
255  }
256 
265  template<typename... Args>
266  void publish(Args&&... args) {
267  signal.publish({ std::forward<Args>(args)... });
268  }
269 
270 private:
271  signal_type signal;
272 };
273 
274 
284 template<typename... Event>
285 using ManagedBus = Bus<Signal, Event...>;
286 
298 template<typename... Event>
299 using UnmanagedBus = Bus<SigH, Event...>;
300 
301 
302 }
303 
304 
305 #endif // ENTT_SIGNAL_BUS_HPP
entt::Bus< Sig, Event >::unreg
void unreg(instance_type< Class > instance)
Unregisters member functions of instances.
Definition: bus.hpp:203
+
entt::Bus< Sig, Event >::disconnect
void disconnect()
Disconnects a free function from the bus.
Definition: bus.hpp:253
+
entt::Bus< Sig, Event >::size
size_type size() const noexcept
Number of listeners connected to the bus.
Definition: bus.hpp:227
+
entt::Bus< Sig, Event, Other... >::connect
void connect()
Connects a free function to the bus.
Definition: bus.hpp:121
+
entt::Bus< Sig, Event >::size_type
typename signal_type::size_type size_type
Unsigned integer type.
Definition: bus.hpp:189
entt::Bus
Minimal event bus.
Definition: bus.hpp:22
entt
EnTT default namespace.
Definition: family.hpp:9
-
entt::Bus< Sig, Event >::publish
void publish(Args &&... args)
Publishes an event.
Definition: bus.hpp:296
-
entt::Bus< Sig, Event, Other... >::empty
bool empty() const noexcept
Returns false is at least a listener is connected to the bus.
Definition: bus.hpp:123
+
entt::Bus< Sig, Event >::publish
void publish(Args &&... args)
Publishes an event.
Definition: bus.hpp:266
+
entt::Bus< Sig, Event, Other... >::unreg
void unreg(Instance instance)
Unregisters all the member functions of an instance.
Definition: bus.hpp:62
+
entt::Bus< Sig, Event, Other... >::empty
bool empty() const noexcept
Returns false if at least a listener is connected to the bus.
Definition: bus.hpp:108
entt::Bus< Sig, Event, Other... >::size_type
std::size_t size_type
Unsigned integer type.
Definition: bus.hpp:47
entt::Signal
Managed signal handler declaration.
Definition: signal.hpp:23
-
entt::Bus< Sig, Event, Other... >::size
size_type size() const noexcept
Number of listeners connected to the bus.
Definition: bus.hpp:112
+
entt::Bus< Sig, Event, Other... >::size
size_type size() const noexcept
Number of listeners connected to the bus.
Definition: bus.hpp:97
entt::SigH
Unmanaged signal handler declaration.
Definition: sigh.hpp:83
-
entt::Bus< Sig, Event, Other... >::disconnect
void disconnect()
Disconnects a free function from the bus.
Definition: bus.hpp:146
-
entt::Bus< Sig, Event >::reg
void reg(instance_type< Class > instance)
Tries to register an instance.
Definition: bus.hpp:249
-
entt::Bus< Sig, Event >::connect
void connect()
Connects a free function to the bus.
Definition: bus.hpp:274
-
entt::Bus< Sig, Event, Other... >::reg
void reg(Instance instance)
Registers all the member functions of an instance.
Definition: bus.hpp:99
-
entt::Bus< Sig, Event, Other... >::publish
void publish(Args &&... args)
Publishes an event.
Definition: bus.hpp:160
-
entt::Bus< Sig, Event >::empty
bool empty() const noexcept
Returns false is at least a listener is connected to the bus.
Definition: bus.hpp:265
+
entt::Bus< Sig, Event, Other... >::disconnect
void disconnect()
Disconnects a free function from the bus.
Definition: bus.hpp:131
+
entt::Bus< Sig, Event >::reg
void reg(instance_type< Class > instance)
Tries to register an instance.
Definition: bus.hpp:219
+
entt::Bus< Sig, Event >::connect
void connect()
Connects a free function to the bus.
Definition: bus.hpp:244
+
entt::Bus< Sig, Event, Other... >::reg
void reg(Instance instance)
Registers all the member functions of an instance.
Definition: bus.hpp:84
+
entt::Bus< Sig, Event, Other... >::publish
void publish(Args &&... args)
Publishes an event.
Definition: bus.hpp:145
+
entt::Bus< Sig, Event >::empty
bool empty() const noexcept
Returns false if at least a listener is connected to the bus.
Definition: bus.hpp:235
diff --git a/cache_8hpp_source.html b/cache_8hpp_source.html new file mode 100644 index 000000000..b11ec6148 --- /dev/null +++ b/cache_8hpp_source.html @@ -0,0 +1,93 @@ + + + + + + + +entt: src/entt/resource/cache.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
entt +  2.2.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
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 "../core/hashed_string.hpp"
10 #include "handle.hpp"
11 #include "loader.hpp"
12 
13 
14 namespace entt {
15 
16 
27 template<typename Resource>
28 class ResourceCache {
29  using container_type = std::unordered_map<HashedString::hash_type, std::shared_ptr<Resource>>;
30 
31 public:
33  using size_type = typename container_type::size_type;
35  using resource_type = HashedString;
36 
38  ResourceCache() = default;
39 
41  ResourceCache(const ResourceCache &) noexcept = delete;
43  ResourceCache(ResourceCache &&) noexcept = default;
44 
46  ResourceCache & operator=(const ResourceCache &) noexcept = delete;
48  ResourceCache & operator=(ResourceCache &&) noexcept = default;
49 
54  size_type size() const noexcept {
55  return resources.size();
56  }
57 
62  bool empty() const noexcept {
63  return resources.empty();
64  }
65 
72  void clear() noexcept {
73  resources.clear();
74  }
75 
94  template<typename Loader, typename... Args>
95  bool load(resource_type id, Args&&... args) {
96  static_assert(std::is_base_of<ResourceLoader<Loader, Resource>, Loader>::value, "!");
97 
98  bool loaded = true;
99 
100  if(resources.find(id) == resources.cend()) {
101  std::shared_ptr<Resource> resource = Loader{}.get(std::forward<Args>(args)...);
102  loaded = (static_cast<bool>(resource) ? (resources[id] = std::move(resource), loaded) : false);
103  }
104 
105  return loaded;
106  }
107 
127  template<typename Loader, typename... Args>
128  void reload(resource_type id, Args&&... args) {
129  return (discard(id), load(id, std::forward<Args>(args)...));
130  }
131 
145  ResourceHandle<Resource> handle(resource_type id) const {
146  auto it = resources.find(id);
147  return { it == resources.end() ? nullptr : it->second };
148  }
149 
155  bool contains(resource_type id) const noexcept {
156  return !(resources.find(id) == resources.cend());
157  }
158 
167  void discard(resource_type id) noexcept {
168  auto it = resources.find(id);
169 
170  if(it != resources.end()) {
171  resources.erase(it);
172  }
173  }
174 
175 private:
176  container_type resources;
177 };
178 
179 
180 }
181 
182 
183 #endif // ENTT_RESOURCE_CACHE_HPP
entt::ResourceCache::size_type
typename container_type::size_type size_type
Unsigned integer type.
Definition: cache.hpp:33
+
entt::ResourceCache::contains
bool contains(resource_type id) const noexcept
Checks if a cache contains the given identifier.
Definition: cache.hpp:155
+
entt::ResourceCache::load
bool load(resource_type id, Args &&... args)
Loads the resource that corresponds to the given identifier.
Definition: cache.hpp:95
+
entt::ResourceCache::empty
bool empty() const noexcept
Returns true if a cache contains no resources, false otherwise.
Definition: cache.hpp:62
+
entt
EnTT default namespace.
Definition: family.hpp:9
+
entt::ResourceCache::discard
void discard(resource_type id) noexcept
Discards the resource that corresponds to the given identifier.
Definition: cache.hpp:167
+
entt::ResourceCache::ResourceCache
ResourceCache()=default
Default constructor.
+
entt::ResourceCache::handle
ResourceHandle< Resource > handle(resource_type id) const
Creates a handle for the given resource identifier.
Definition: cache.hpp:145
+
entt::HashedString
Zero overhead resource identifier.
Definition: hashed_string.hpp:20
+
entt::ResourceCache::reload
void reload(resource_type id, Args &&... args)
Reloads a resource or loads it for the first time if not present.
Definition: cache.hpp:128
+
entt::ResourceLoader
Base class for resource loaders.
Definition: loader.hpp:48
+
entt::ResourceCache::size
size_type size() const noexcept
Number of resources managed by a cache.
Definition: cache.hpp:54
+
entt::ResourceHandle
Shared resource handle.
Definition: handle.hpp:30
+
entt::ResourceCache::clear
void clear() noexcept
Clears a cache and discards all its resources.
Definition: cache.hpp:72
+
entt::ResourceCache
Simple cache for resources of a given type.
Definition: cache.hpp:28
+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1Bus.html b/classentt_1_1Bus.html index 20e79fbd2..de3474830 100644 --- a/classentt_1_1Bus.html +++ b/classentt_1_1Bus.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0
diff --git a/classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4-members.html b/classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4-members.html index e41ad27fd..733b4bd6d 100644 --- a/classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4-members.html +++ b/classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4-members.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0
@@ -70,22 +70,16 @@ $(function() {

This is the complete list of members for entt::Bus< Sig, Event, Other... >, including all inherited members.

- - - - - - - - - - - - - - - - + + + + + + + + + +
Bus() noexcept=defaultentt::Bus< Sig, Event, Other... >explicit
Bus(const Bus &)=defaultentt::Bus< Sig, Event, Other... >
Bus(Bus &&)=defaultentt::Bus< Sig, Event, Other... >
connect()entt::Bus< Sig, Event, Other... >inline
disconnect()entt::Bus< Sig, Event, Other... >inline
empty() const noexceptentt::Bus< Sig, Event, Other... >inline
operator=(const Bus &)=defaultentt::Bus< Sig, Event, Other... >
operator=(Bus &&)=defaultentt::Bus< Sig, Event, Other... >
publish(Args &&... args)entt::Bus< Sig, Event, Other... >inline
reg(Instance instance)entt::Bus< Sig, Event, Other... >inline
entt::Bus< Sig, Event >::reg(instance_type< Class > instance)entt::Bus< Sig, Event >inlineprivate
size() const noexceptentt::Bus< Sig, Event, Other... >inline
size_type typedefentt::Bus< Sig, Event, Other... >
unreg(Instance instance)entt::Bus< Sig, Event, Other... >inline
entt::Bus< Sig, Event >::unreg(instance_type< Class > instance)entt::Bus< Sig, Event >inlineprivate
~Bus() noexcept=defaultentt::Bus< Sig, Event, Other... >virtual
connect()entt::Bus< Sig, Event, Other... >inline
disconnect()entt::Bus< Sig, Event, Other... >inline
empty() const noexceptentt::Bus< Sig, Event, Other... >inline
publish(Args &&... args)entt::Bus< Sig, Event, Other... >inline
reg(Instance instance)entt::Bus< Sig, Event, Other... >inline
entt::Bus< Sig, Event >::reg(instance_type< Class > instance)entt::Bus< Sig, Event >inlineprivate
size() const noexceptentt::Bus< Sig, Event, Other... >inline
size_type typedefentt::Bus< Sig, Event, Other... >
unreg(Instance instance)entt::Bus< Sig, Event, Other... >inline
entt::Bus< Sig, Event >::unreg(instance_type< Class > instance)entt::Bus< Sig, Event >inlineprivate
diff --git a/classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4.html b/classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4.html index 6685dc0d4..bcd275364 100644 --- a/classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4.html +++ b/classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0
@@ -104,28 +104,6 @@ using 

Public Member Functions

- - Bus () noexcept=default - Default constructor, explicit on purpose.
-  - - ~Bus () noexcept=default - Default destructor.
-  - - Bus (const Bus &)=default - Default copy constructor.
-  - - Bus (Bus &&)=default - Default move constructor.
-  -Bus & operator= (const Bus &)=default - Default copy assignment operator. More...
-  -Bus & operator= (Bus &&)=default - Default move assignment operator. More...
-  template<typename Instance > void unreg (Instance instance)  Unregisters all the member functions of an instance. More...
@@ -138,7 +116,7 @@ Public Member Functions  Number of listeners connected to the bus. More...
  bool empty () const noexcept - Returns false is at least a listener is connected to the bus. More...
+ Returns false if at least a listener is connected to the bus. More...
  template<typename Type , void(*)(const Type &) Function> void connect () @@ -206,7 +184,7 @@ template<typename Type , void(*)(const Type &) Function> -

Definition at line 136 of file bus.hpp.

+

Definition at line 121 of file bus.hpp.

@@ -246,7 +224,7 @@ template<typename Type , void(*)(const Type &) Function> -

Definition at line 146 of file bus.hpp.

+

Definition at line 131 of file bus.hpp.

@@ -275,72 +253,10 @@ template<template< typename... > class Sig, typename Event , typename..
-

Returns false is at least a listener is connected to the bus.

+

Returns false if at least a listener is connected to the bus.

Returns
True if the bus has no listeners connected, false otherwise.
-

Definition at line 123 of file bus.hpp.

- -
- - -

◆ operator=() [1/2]

- -
-
-
-template<template< typename... > class Sig, typename Event , typename... Other>
- - - - - -
- - - - - - - - -
Bus& entt::Bus< Sig, Event, Other... >::operator= (const Bus< Sig, Event, Other... > & )
- 		-default
-
- -

Default copy assignment operator.

-
Returns
This bus.
- -
-
- -

◆ operator=() [2/2]

- -
-
-
-template<template< typename... > class Sig, typename Event , typename... Other>
- - - - - -
- - - - - - - - -
Bus& entt::Bus< Sig, Event, Other... >::operator= (Bus< Sig, Event, Other... > && )
- 		-default
-
- -

Default move assignment operator.

-
Returns
This bus.
+

Definition at line 108 of file bus.hpp.

@@ -388,7 +304,7 @@ template<typename Type , typename... Args> -

Definition at line 160 of file bus.hpp.

+

Definition at line 145 of file bus.hpp.

@@ -436,7 +352,7 @@ template<typename Instance > -

Definition at line 99 of file bus.hpp.

+

Definition at line 84 of file bus.hpp.

@@ -468,7 +384,7 @@ template<template< typename... > class Sig, typename Event , typename..

Number of listeners connected to the bus.

Returns
Number of listeners currently connected.
-

Definition at line 112 of file bus.hpp.

+

Definition at line 97 of file bus.hpp.

@@ -516,7 +432,7 @@ template<typename Instance > -

Definition at line 77 of file bus.hpp.

+

Definition at line 62 of file bus.hpp.

diff --git a/classentt_1_1Bus_3_01Sig_00_01Event_01_4-members.html b/classentt_1_1Bus_3_01Sig_00_01Event_01_4-members.html index 365de805c..e1e9a4f18 100644 --- a/classentt_1_1Bus_3_01Sig_00_01Event_01_4-members.html +++ b/classentt_1_1Bus_3_01Sig_00_01Event_01_4-members.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0
@@ -70,20 +70,14 @@ $(function() {

This is the complete list of members for entt::Bus< Sig, Event >, including all inherited members.

- - - - - - - - - - - - - - + + + + + + + +
Bus() noexcept=defaultentt::Bus< Sig, Event >explicit
Bus(const Bus &)=defaultentt::Bus< Sig, Event >
Bus(Bus &&)=defaultentt::Bus< Sig, Event >
connect()entt::Bus< Sig, Event >inline
disconnect()entt::Bus< Sig, Event >inline
empty() const noexceptentt::Bus< Sig, Event >inline
operator=(const Bus &)=defaultentt::Bus< Sig, Event >
operator=(Bus &&)=defaultentt::Bus< Sig, Event >
publish(Args &&... args)entt::Bus< Sig, Event >inline
reg(instance_type< Class > instance)entt::Bus< Sig, Event >inline
size() const noexceptentt::Bus< Sig, Event >inline
size_type typedefentt::Bus< Sig, Event >
unreg(instance_type< Class > instance)entt::Bus< Sig, Event >inline
~Bus() noexcept=defaultentt::Bus< Sig, Event >virtual
connect()entt::Bus< Sig, Event >inline
disconnect()entt::Bus< Sig, Event >inline
empty() const noexceptentt::Bus< Sig, Event >inline
publish(Args &&... args)entt::Bus< Sig, Event >inline
reg(instance_type< Class > instance)entt::Bus< Sig, Event >inline
size() const noexceptentt::Bus< Sig, Event >inline
size_type typedefentt::Bus< Sig, Event >
unreg(instance_type< Class > instance)entt::Bus< Sig, Event >inline
diff --git a/classentt_1_1Bus_3_01Sig_00_01Event_01_4.html b/classentt_1_1Bus_3_01Sig_00_01Event_01_4.html index f6d7c8788..28cd54241 100644 --- a/classentt_1_1Bus_3_01Sig_00_01Event_01_4.html +++ b/classentt_1_1Bus_3_01Sig_00_01Event_01_4.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0
@@ -94,28 +94,6 @@ using 

Public Member Functions

- - Bus () noexcept=default - Default constructor, explicit on purpose.
-  - -virtual ~Bus () noexcept=default - Default destructor.
-  - - Bus (const Bus &)=default - Default copy constructor.
-  - - Bus (Bus &&)=default - Default move constructor.
-  -Bus & operator= (const Bus &)=default - Default copy assignment operator. More...
-  -Bus & operator= (Bus &&)=default - Default move assignment operator. More...
-  template<typename Class > void unreg (instance_type< Class > instance)  Unregisters member functions of instances. More...
@@ -128,7 +106,7 @@ virtual  Number of listeners connected to the bus. More...
  bool empty () const noexcept - Returns false is at least a listener is connected to the bus. More...
+ Returns false if at least a listener is connected to the bus. More...
  template<void(*)(const Event &) Function> void connect () @@ -158,7 +136,7 @@ class entt::Bus< Sig, Event > -

Definition at line 181 of file bus.hpp.

+

Definition at line 166 of file bus.hpp.

Member Function Documentation

◆ connect()

@@ -195,7 +173,7 @@ template<void(*)(const Event &) Function> -

Definition at line 274 of file bus.hpp.

+

Definition at line 244 of file bus.hpp.

@@ -234,7 +212,7 @@ template<void(*)(const Event &) Function> -

Definition at line 283 of file bus.hpp.

+

Definition at line 253 of file bus.hpp.

@@ -263,72 +241,10 @@ template<template< typename... > class Sig, typename Event >
-

Returns false is at least a listener is connected to the bus.

+

Returns false if at least a listener is connected to the bus.

Returns
True if the bus has no listeners connected, false otherwise.
-

Definition at line 265 of file bus.hpp.

- -
- - -

◆ operator=() [1/2]

- -
-
-
-template<template< typename... > class Sig, typename Event >
- - - - - -
- - - - - - - - -
Bus& entt::Bus< Sig, Event >::operator= (const Bus< Sig, Event > & )
- 		-default
-
- -

Default copy assignment operator.

-
Returns
This bus.
- -
-
- -

◆ operator=() [2/2]

- -
-
-
-template<template< typename... > class Sig, typename Event >
- - - - - -
- - - - - - - - -
Bus& entt::Bus< Sig, Event >::operator= (Bus< Sig, Event > && )
- 		-default
-
- -

Default move assignment operator.

-
Returns
This bus.
+

Definition at line 235 of file bus.hpp.

@@ -375,7 +291,7 @@ template<typename... Args> -

Definition at line 296 of file bus.hpp.

+

Definition at line 266 of file bus.hpp.

@@ -423,7 +339,7 @@ template<typename Class > -

Definition at line 249 of file bus.hpp.

+

Definition at line 219 of file bus.hpp.

@@ -455,7 +371,7 @@ template<template< typename... > class Sig, typename Event >

Number of listeners connected to the bus.

Returns
Number of listeners currently connected.
-

Definition at line 257 of file bus.hpp.

+

Definition at line 227 of file bus.hpp.

@@ -503,7 +419,7 @@ template<typename Class > -

Definition at line 233 of file bus.hpp.

+

Definition at line 203 of file bus.hpp.

diff --git a/classentt_1_1Delegate.html b/classentt_1_1Delegate.html index 138c73b48..d8c10c12d 100644 --- a/classentt_1_1Delegate.html +++ b/classentt_1_1Delegate.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0
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 index 5c42d7448..2b7f52261 100644 --- 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 @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0
@@ -72,7 +72,7 @@ $(function() { - + 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 index 0a4f164db..233e84733 100644 --- 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 @@ -22,7 +22,7 @@ @@ -71,7 +71,7 @@ $(function() {
-

A delegate class to send around functions and member functions. +

Utility class to send around functions and member functions. More...

#include <delegate.hpp>

@@ -80,7 +80,7 @@ $(function() { Public Member Functions
- + @@ -104,7 +104,7 @@ Public Member Functions

template<typename Ret, typename... Args>
class entt::Delegate< Ret(Args...)>

-

A delegate class to send around functions and member functions.

+

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
diff --git a/classentt_1_1Dispatcher-members.html b/classentt_1_1Dispatcher-members.html index 5561f0d8f..1ab1c4b2d 100644 --- a/classentt_1_1Dispatcher-members.html +++ b/classentt_1_1Dispatcher-members.html @@ -22,7 +22,7 @@
@@ -72,15 +72,10 @@ $(function() {
connect() noexceptentt::Delegate< Ret(Args...)>inline
connect(Class *instance) noexceptentt::Delegate< Ret(Args...)>inline
Delegate() noexceptentt::Delegate< Ret(Args...)>inlineexplicit
Delegate() noexceptentt::Delegate< Ret(Args...)>inline
operator()(Args... args)entt::Delegate< Ret(Args...)>inline
operator==(const Delegate< Ret(Args...)> &other) const noexceptentt::Delegate< Ret(Args...)>inline
reset() noexceptentt::Delegate< Ret(Args...)>inline
entt -  2.1.0 +  2.2.0
 Delegate () noexcept
 Default constructor, explicit on purpose.
 Default constructor.
 
template<Ret(*)(Args...) Function>
void connect () noexcept
entt -  2.1.0 +  2.2.0
- - - + - - -
connect(instance_type< Class, Event > instance) noexceptentt::Dispatcher< Sig >inline
disconnect(instance_type< Class, Event > instance) noexceptentt::Dispatcher< Sig >inline
Dispatcher() noexceptentt::Dispatcher< Sig >inlineexplicit
Dispatcher(const Dispatcher &)=defaultentt::Dispatcher< Sig >
Dispatcher(Dispatcher &&)=defaultentt::Dispatcher< Sig >
Dispatcher() noexceptentt::Dispatcher< Sig >inline
enqueue(Args &&... args)entt::Dispatcher< Sig >inline
operator=(const Dispatcher &)=defaultentt::Dispatcher< Sig >
operator=(Dispatcher &&)=defaultentt::Dispatcher< Sig >
trigger(Args &&... args)entt::Dispatcher< Sig >inline
update()entt::Dispatcher< Sig >inline
~Dispatcher()=defaultentt::Dispatcher< Sig >
diff --git a/classentt_1_1Dispatcher.html b/classentt_1_1Dispatcher.html index 04d57785f..dfb701e1f 100644 --- a/classentt_1_1Dispatcher.html +++ b/classentt_1_1Dispatcher.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0
@@ -81,26 +81,8 @@ $(function() { Public Member Functions  Dispatcher () noexcept - Default constructor, explicit on purpose.
+ Default constructor.
  - - ~Dispatcher ()=default - Default destructor.
-  - - Dispatcher (const Dispatcher &)=default - Default copy constructor.
-  - - Dispatcher (Dispatcher &&)=default - Default move constructor.
-  -Dispatcher & operator= (const Dispatcher &)=default - Default copy assignment operator. More...
-  -Dispatcher & operator= (Dispatcher &&)=default - Default move assignment operator. More...
-  template<typename Event , typename Class , void(Class::*)(const Event &) Member = &Class::receive> void connect (instance_type< Class, Event > instance) noexcept  Registers a listener given in the form of a member function. More...
@@ -183,7 +165,7 @@ template<typename Event , typename Class , void(Class::*)(const Event &) -

Definition at line 131 of file dispatcher.hpp.

+

Definition at line 118 of file dispatcher.hpp.

@@ -233,7 +215,7 @@ template<typename Event , typename Class , void(Class::*)(const Event &) -

Definition at line 152 of file dispatcher.hpp.

+

Definition at line 139 of file dispatcher.hpp.

@@ -281,69 +263,7 @@ template<typename Event , typename... Args> -

Definition at line 182 of file dispatcher.hpp.

- - - - -

◆ operator=() [1/2]

- -
-
-
-template<template< typename... > class Sig>
- - - - - -
- - - - - - - - -
Dispatcher& entt::Dispatcher< Sig >::operator= (const Dispatcher< Sig > & )
- 		-default
-
- -

Default copy assignment operator.

-
Returns
This dispatcher.
- -
-
- -

◆ operator=() [2/2]

- -
-
-
-template<template< typename... > class Sig>
- - - - - -
- - - - - - - - -
Dispatcher& entt::Dispatcher< Sig >::operator= (Dispatcher< Sig > && )
- 		-default
-
- -

Default move assignment operator.

-
Returns
This dispatcher.
+

Definition at line 169 of file dispatcher.hpp.

@@ -391,7 +311,7 @@ template<typename Event , typename... Args> -

Definition at line 167 of file dispatcher.hpp.

+

Definition at line 154 of file dispatcher.hpp.

@@ -423,7 +343,7 @@ template<template< typename... > class Sig>

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 responsability of the users to reduce at a minimum the time spent in the bodies of the listeners.

-

Definition at line 193 of file dispatcher.hpp.

+

Definition at line 180 of file dispatcher.hpp.

diff --git a/classentt_1_1Emitter-members.html b/classentt_1_1Emitter-members.html index 4f7240256..54ce35aac 100644 --- a/classentt_1_1Emitter-members.html +++ b/classentt_1_1Emitter-members.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0
@@ -72,7 +72,7 @@ $(function() { - + diff --git a/classentt_1_1Emitter.html b/classentt_1_1Emitter.html index 04d1490e3..f20108a5c 100644 --- a/classentt_1_1Emitter.html +++ b/classentt_1_1Emitter.html @@ -22,7 +22,7 @@ @@ -96,8 +96,12 @@ template<typename Event > Public Member Functions - + + + + @@ -106,10 +110,6 @@ Public Member Functions   - - - @@ -200,7 +200,7 @@ template<typename Event > -

Definition at line 298 of file emitter.hpp.

+

Definition at line 295 of file emitter.hpp.

@@ -232,7 +232,7 @@ template<typename Derived >

Disconnects all the listeners.

All the connections previously returned are invalidated. Using them results in undefined behaviour.

-

Definition at line 308 of file emitter.hpp.

+

Definition at line 305 of file emitter.hpp.

@@ -272,7 +272,7 @@ template<typename Event >
Returns
True if there are no listeners registered, false otherwise.
-

Definition at line 319 of file emitter.hpp.

+

Definition at line 316 of file emitter.hpp.

@@ -304,7 +304,7 @@ 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 331 of file emitter.hpp.

+

Definition at line 328 of file emitter.hpp.

@@ -351,7 +351,7 @@ template<typename Event > -

Definition at line 285 of file emitter.hpp.

+

Definition at line 282 of file emitter.hpp.

@@ -402,7 +402,7 @@ template<typename Event >
Returns
Connection object that can be used to disconnect the listener.
-

Definition at line 246 of file emitter.hpp.

+

Definition at line 243 of file emitter.hpp.

@@ -453,7 +453,7 @@ template<typename Event >
Returns
Connection object that can be used to disconnect the listener.
-

Definition at line 271 of file emitter.hpp.

+

Definition at line 268 of file emitter.hpp.

@@ -563,7 +563,7 @@ template<typename Event , typename... Args> -

Definition at line 221 of file emitter.hpp.

+

Definition at line 218 of file emitter.hpp.

diff --git a/classentt_1_1Family-members.html b/classentt_1_1Family-members.html index 852202e71..b24f06bbc 100644 --- a/classentt_1_1Family-members.html +++ b/classentt_1_1Family-members.html @@ -22,7 +22,7 @@ diff --git a/classentt_1_1Family.html b/classentt_1_1Family.html index f03363f1e..3e3b66919 100644 --- a/classentt_1_1Family.html +++ b/classentt_1_1Family.html @@ -22,7 +22,7 @@ diff --git a/classentt_1_1HashedString-members.html b/classentt_1_1HashedString-members.html new file mode 100644 index 000000000..529d2a698 --- /dev/null +++ b/classentt_1_1HashedString-members.html @@ -0,0 +1,87 @@ + + + + + + + +entt: Member List + + + + + + + + + +
+
+
clear() noexceptentt::Emitter< Derived >inline
clear() noexceptentt::Emitter< Derived >inline
Emitter() noexcept=defaultentt::Emitter< Derived >explicit
Emitter() noexcept=defaultentt::Emitter< Derived >
Emitter(const Emitter &)=deleteentt::Emitter< Derived >
Emitter(Emitter &&)=defaultentt::Emitter< Derived >
empty() const noexceptentt::Emitter< Derived >inline
entt -  2.1.0 +  2.2.0
 Emitter () noexcept=default
 Default constructor, explicit on purpose.
 Default constructor.
 
+virtual ~Emitter () noexcept
 Default destructor.
 
 Emitter (const Emitter &)=delete
 Copying an emitter isn't allowed.
Emitter (Emitter &&)=default
 Default move constructor.
 
-virtual ~Emitter () noexcept
 Default destructor.
 
Emitter & operator= (const Emitter &)=delete
 Copying an emitter isn't allowed. More...
 
entt -  2.1.0 +  2.2.0
entt -  2.1.0 +  2.2.0
+ + + + + +
+
entt +  2.2.0 +
+
+ + + + + + + + + +
+
+ + +
+ +
+ + + +
+
+
entt::HashedString Member List
+
+
+ +

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

+ + + + + + + +
hash_type typedefentt::HashedString
HashedString(const char(&str)[N]) noexceptentt::HashedStringinline
HashedString(ConstCharWrapper wrapper) noexceptentt::HashedStringinlineexplicit
operator const char *() const noexceptentt::HashedStringinline
operator hash_type() const noexceptentt::HashedStringinline
operator==(const HashedString &other) const noexceptentt::HashedStringinline
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1HashedString.html b/classentt_1_1HashedString.html new file mode 100644 index 000000000..e5f2d1e6a --- /dev/null +++ b/classentt_1_1HashedString.html @@ -0,0 +1,304 @@ + + + + + + + +entt: entt::HashedString Class Reference + + + + + + + + + +
+
+ + + + + + +
+
entt +  2.2.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+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]) noexcept
 Constructs a hashed string from an array of const chars. More...
 
constexpr HashedString (ConstCharWrapper wrapper) noexcept
 Explicit constructor on purpose to avoid constructing a hashed string directly from a const char *. More...
 
constexpr operator const char * () const noexcept
 Returns the human-readable representation of a hashed string. More...
 
constexpr operator hash_type () const noexcept
 Returns the numeric representation of a hashed string. More...
 
constexpr bool operator== (const HashedString &other) const 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 20 of file hashed_string.hpp.

+

Constructor & Destructor Documentation

+ +

◆ HashedString() [1/2]

+ +
+
+
+template<std::size_t N>
+ + + + + +
+ + + + + + + + +
constexpr entt::HashedString::HashedString (const char(&) str[N])
+ 		+inlinenoexcept
+
+ +

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 54 of file hashed_string.hpp.

+ +
+
+ +

◆ HashedString() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + +
constexpr entt::HashedString::HashedString (ConstCharWrapper wrapper)
+ 		+inlineexplicitnoexcept
+
+ +

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 64 of file hashed_string.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ operator const char *()

+ +
+
+ + + + + +
+ + + + + + + +
constexpr entt::HashedString::operator const char * () const
+ 		+inlinenoexcept
+
+ +

Returns the human-readable representation of a hashed string.

+
Returns
The string used to initialize the instance.
+ +

Definition at line 72 of file hashed_string.hpp.

+ +
+
+ +

◆ operator hash_type()

+ +
+
+ + + + + +
+ + + + + + + +
constexpr entt::HashedString::operator hash_type () const
+ 		+inlinenoexcept
+
+ +

Returns the numeric representation of a hashed string.

+
Returns
The numeric representation of the instance.
+ +

Definition at line 78 of file hashed_string.hpp.

+ +
+
+ +

◆ operator==()

+ +
+
+ + + + + +
+ + + + + + + + +
constexpr bool entt::HashedString::operator== (const HashedString & other) const
+ 		+inlinenoexcept
+
+ +

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 85 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_1PersistentView-members.html b/classentt_1_1PersistentView-members.html index 982bf6fb0..dcec9f703 100644 --- a/classentt_1_1PersistentView-members.html +++ b/classentt_1_1PersistentView-members.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0
@@ -79,7 +79,7 @@ $(function() { get(entity_type entity) const noexceptentt::PersistentView< Entity, Component >inline get(entity_type entity) noexceptentt::PersistentView< Entity, Component >inline iterator_type typedefentt::PersistentView< Entity, Component > - PersistentView(view_type &view, pool_type< Component > &... pools) noexceptentt::PersistentView< Entity, Component >inlineexplicit + PersistentView(view_type &view, pool_type< Component > &... pools) noexceptentt::PersistentView< Entity, Component >inline size() const noexceptentt::PersistentView< Entity, Component >inline size_type typedefentt::PersistentView< Entity, Component > sort()entt::PersistentView< Entity, Component >inline diff --git a/classentt_1_1PersistentView.html b/classentt_1_1PersistentView.html index b697f3d50..0147e97f4 100644 --- a/classentt_1_1PersistentView.html +++ b/classentt_1_1PersistentView.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0
@@ -209,13 +209,14 @@ template<typename Entity , typename... Component> -inlineexplicitnoexcept +inlinenoexcept

Constructs a persistent view around a dedicated pool of entities.

-

A persistent view is created out of:

    +

    A persistent view is created out of:

    +
    • A dedicated pool of entities that is shared between all the persistent views of the same type.
    • A bunch of pools of components to which to refer to get instances.
    @@ -227,7 +228,7 @@ template<typename Entity , typename... Component>
-

Definition at line 80 of file view.hpp.

+

Definition at line 81 of file view.hpp.

@@ -262,7 +263,7 @@ template<typename Entity , typename... Component>
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 122 of file view.hpp.

+

Definition at line 123 of file view.hpp.

@@ -296,7 +297,7 @@ template<typename Entity , typename... Component>
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 104 of file view.hpp.

+

Definition at line 105 of file view.hpp.

@@ -344,7 +345,7 @@ template<typename Func > -

Definition at line 205 of file view.hpp.

+

Definition at line 206 of file view.hpp.

@@ -392,7 +393,7 @@ template<typename Func > -

Definition at line 227 of file view.hpp.

+

Definition at line 228 of file view.hpp.

@@ -426,7 +427,7 @@ template<typename Entity , typename... Component>
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 141 of file view.hpp.

+

Definition at line 142 of file view.hpp.

@@ -459,7 +460,7 @@ template<typename Comp >

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.

+

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
@@ -476,7 +477,7 @@ template<typename Comp >
Returns
The component assigned to the entity.
-

Definition at line 163 of file view.hpp.

+

Definition at line 164 of file view.hpp.

@@ -509,7 +510,7 @@ template<typename Comp >

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.

+

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
@@ -526,7 +527,7 @@ template<typename Comp >
Returns
The component assigned to the entity.
-

Definition at line 185 of file view.hpp.

+

Definition at line 186 of file view.hpp.

@@ -558,7 +559,7 @@ template<typename Entity , typename... Component>

Returns the number of entities that have the given components.

Returns
Number of entities that have the given components.
-

Definition at line 88 of file view.hpp.

+

Definition at line 89 of file view.hpp.

@@ -591,7 +592,7 @@ template<typename Comp >

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 of components that it tracks. Therefore changes to the pools of components can quickly ruin the order imposed to the pool of entities shared between the persistent views.
+
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
@@ -599,7 +600,7 @@ template<typename Comp > -

Definition at line 250 of file view.hpp.

+

Definition at line 251 of file view.hpp.

diff --git a/classentt_1_1Process-members.html b/classentt_1_1Process-members.html new file mode 100644 index 000000000..ed3c7006e --- /dev/null +++ b/classentt_1_1Process-members.html @@ -0,0 +1,95 @@ + + + + + + + +entt: Member List + + + + + + + + + +
+
+
CompType of the component to use to impose the order.
+ + + + + +
+
entt +  2.2.0 +
+
+ + + + + + + + + +
+
+ + +
+ +
+ + + +
+
+
entt::Process< Derived, Delta > Member List
+
+
+ +

This is the complete list of members for entt::Process< Derived, Delta >, including all inherited members.

+ + + + + + + + + + + + + + + +
abort(bool immediately=false) noexceptentt::Process< Derived, Delta >inline
alive() const noexceptentt::Process< Derived, Delta >inline
dead() const noexceptentt::Process< Derived, Delta >inline
delta_type typedefentt::Process< Derived, Delta >
fail() noexceptentt::Process< Derived, Delta >inlineprotected
pause() noexceptentt::Process< Derived, Delta >inlineprotected
paused() const noexceptentt::Process< Derived, Delta >inline
rejected() const noexceptentt::Process< Derived, Delta >inline
State enum name (defined in entt::BaseProcess)entt::BaseProcessprivate
succeed() noexceptentt::Process< Derived, Delta >inlineprotected
tag typedef (defined in entt::BaseProcess)entt::BaseProcessprivate
tick(Delta delta)entt::Process< Derived, Delta >inline
unpause() noexceptentt::Process< Derived, Delta >inlineprotected
~Process() noexceptentt::Process< Derived, Delta >inline
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1Process.html b/classentt_1_1Process.html new file mode 100644 index 000000000..5ab402c70 --- /dev/null +++ b/classentt_1_1Process.html @@ -0,0 +1,512 @@ + + + + + + + +entt: entt::Process< Derived, Delta > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
entt +  2.2.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+Public Types | +Public Member Functions | +Protected Member Functions | +List of all members
+
+
entt::Process< Derived, Delta > Class Template Reference
+
+
+ +

Base class for processes. + More...

+ +

#include <process.hpp>

+
+Inheritance diagram for entt::Process< Derived, Delta >:
+
+
Inheritance graph
+ + +
[legend]
+
+Collaboration diagram for entt::Process< Derived, Delta >:
+
+
Collaboration graph
+ + +
[legend]
+ + + + + +

+Public Types

+using delta_type = Delta
 Type used to provide elapsed time.
 
+ + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+ ~Process () noexcept
 Default destructor.
 
void abort (bool immediately=false) noexcept
 Aborts a process if it's still alive. More...
 
bool alive () const noexcept
 Returns true if a process is either running or paused. More...
 
bool dead () const noexcept
 Returns true if a process is already terminated. More...
 
bool paused () const noexcept
 Returns true if a process is currently paused. More...
 
bool rejected () const noexcept
 Returns true if a process terminated with errors. More...
 
void tick (Delta delta)
 Updates a process and its internal state if required. More...
 
+ + + + + + + + + + + + + +

+Protected Member Functions

void succeed () noexcept
 Terminates a process with success if it's still alive. More...
 
void fail () noexcept
 Terminates a process with errors if it's still alive. More...
 
void pause () noexcept
 Stops a process if it's in a running state. More...
 
void unpause () noexcept
 Restarts a process if it's paused. More...
 
+

Detailed Description

+

template<typename Derived, typename 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.
+ A process should expose publicly the following member functions whether required:

+
    +
  • void update(Delta);
    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.
    • +
  • void init();
    It's invoked at the first tick, immediately before an update.
    • +
  • void succeeded();
    It's invoked in case of success, immediately after an update and during the same tick.
    • +
  • void failed();
    It's invoked in case of errors, immediately after an update and during the same tick.
    • +
  • void aborted();
    It's invoked only if a process is explicitly aborted. There is no guarantee that it executes in the same tick, this depends solely on whether the process is aborted immediately or not.
    • +
+

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
+
Template Parameters
+ + + +
DerivedActual type of process that extends the class template.
DeltaType to use to provide elapsed time.
+
+
+ +

Definition at line 85 of file process.hpp.

+

Member Function Documentation

+ +

◆ abort()

+ +
+
+
+template<typename Derived, typename Delta>
+ + + + + +
+ + + + + + + + +
void entt::Process< Derived, Delta >::abort (bool immediately = false)
+ 		+inlinenoexcept
+
+ +

Aborts a process if it's still alive.

+

The function is idempotent and it does nothing if the process isn't alive.

+
Parameters
+ + +
immediatelyRequests an immediate operation.
+
+
+ +

Definition at line 185 of file process.hpp.

+ +
+
+ +

◆ alive()

+ +
+
+
+template<typename Derived, typename Delta>
+ + + + + +
+ + + + + + + +
bool entt::Process< Derived, Delta >::alive () const
+ 		+inlinenoexcept
+
+ +

Returns true if a process is either running or paused.

+
Returns
True if the process is still alive, false otherwise.
+ +

Definition at line 199 of file process.hpp.

+ +
+
+ +

◆ dead()

+ +
+
+
+template<typename Derived, typename Delta>
+ + + + + +
+ + + + + + + +
bool entt::Process< Derived, Delta >::dead () const
+ 		+inlinenoexcept
+
+ +

Returns true if a process is already terminated.

+
Returns
True if the process is terminated, false otherwise.
+ +

Definition at line 207 of file process.hpp.

+ +
+
+ +

◆ fail()

+ +
+
+
+template<typename Derived, typename Delta>
+ + + + + +
+ + + + + + + +
void entt::Process< Derived, Delta >::fail ()
+ 		+inlineprotectednoexcept
+
+ +

Terminates a process with errors if it's still alive.

+

The function is idempotent and it does nothing if the process isn't alive.

+ +

Definition at line 138 of file process.hpp.

+ +
+
+ +

◆ pause()

+ +
+
+
+template<typename Derived, typename Delta>
+ + + + + +
+ + + + + + + +
void entt::Process< Derived, Delta >::pause ()
+ 		+inlineprotectednoexcept
+
+ +

Stops a process if it's in a running state.

+

The function is idempotent and it does nothing if the process isn't running.

+ +

Definition at line 150 of file process.hpp.

+ +
+
+ +

◆ paused()

+ +
+
+
+template<typename Derived, typename Delta>
+ + + + + +
+ + + + + + + +
bool entt::Process< Derived, Delta >::paused () const
+ 		+inlinenoexcept
+
+ +

Returns true if a process is currently paused.

+
Returns
True if the process is paused, false otherwise.
+ +

Definition at line 215 of file process.hpp.

+ +
+
+ +

◆ rejected()

+ +
+
+
+template<typename Derived, typename Delta>
+ + + + + +
+ + + + + + + +
bool entt::Process< Derived, Delta >::rejected () const
+ 		+inlinenoexcept
+
+ +

Returns true if a process terminated with errors.

+
Returns
True if the process terminated with errors, false otherwise.
+ +

Definition at line 223 of file process.hpp.

+ +
+
+ +

◆ succeed()

+ +
+
+
+template<typename Derived, typename Delta>
+ + + + + +
+ + + + + + + +
void entt::Process< Derived, Delta >::succeed ()
+ 		+inlineprotectednoexcept
+
+ +

Terminates a process with success if it's still alive.

+

The function is idempotent and it does nothing if the process isn't alive.

+ +

Definition at line 126 of file process.hpp.

+ +
+
+ +

◆ tick()

+ +
+
+
+template<typename Derived, typename Delta>
+ + + + + +
+ + + + + + + + +
void entt::Process< Derived, Delta >::tick (Delta delta)
+ 		+inline
+
+ +

Updates a process and its internal state if required.

+
Parameters
+ + +
deltaElapsed time.
+
+
+ +

Definition at line 231 of file process.hpp.

+ +
+
+ +

◆ unpause()

+ +
+
+
+template<typename Derived, typename Delta>
+ + + + + +
+ + + + + + + +
void entt::Process< Derived, Delta >::unpause ()
+ 		+inlineprotectednoexcept
+
+ +

Restarts a process if it's paused.

+

The function is idempotent and it does nothing if the process isn't paused.

+ +

Definition at line 162 of file process.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1Process__coll__graph.map b/classentt_1_1Process__coll__graph.map new file mode 100644 index 000000000..680b2b4da --- /dev/null +++ b/classentt_1_1Process__coll__graph.map @@ -0,0 +1,2 @@ + + diff --git a/classentt_1_1Process__coll__graph.md5 b/classentt_1_1Process__coll__graph.md5 new file mode 100644 index 000000000..d4fe9c013 --- /dev/null +++ b/classentt_1_1Process__coll__graph.md5 @@ -0,0 +1 @@ +ec90fe41b5ee1556e1577ee993980046 \ No newline at end of file diff --git a/classentt_1_1Process__coll__graph.png b/classentt_1_1Process__coll__graph.png new file mode 100644 index 0000000000000000000000000000000000000000..a7c0edc1f4f81c7e2b51c372efaa6c62642ba381 GIT binary patch literal 4373 zcmcIoc{Ei2-@lDDktNGawvwHM5|Oct=u3;37($pVF(hQko@J<+R3a*ANT{J23K#?3F#;yWgJSt3eW8p^G?2S3~H<6HW(e9PCbMVC(kjf>)Y zN+Jgwib;)zm}$lS+b%gWAlx_P1{LE%5yd7;7f z_A8s)+YLiQu*Nu^Xq0ll3Vk)GrKP2=>^^;bdOA*AC&2yHKiL+_w`;^CBqV|+Vns+! zjqK+%G+?7D>gocYt@68=!1ynq5$mX?iBw6e5x%+(Bd`e?Zy zc6Vzg1M_FLOIcfccs5{bYl|4Mzjr0u0vu{)W`_P!&3s)V0bnK?Vz0<175@5lhdr_* zLocKCj(SRJs(bgUnW-s?mXqtXvr4D7kBz;Pk(MTX`lJ}}tA$@ykjn;vU_s;5@{n!d z>)YYW!NI{-q@Jf%kCL6wMtOOAyEZj74a+UAO?~4AloS-4a1_?rhS(!GwdR+m*#T)5 zd3PXDkwQX3cQ=yL(pnuJ&dFra^7=fc=jK{FGxWYg(TnMUV@`#Ig~MThBRF|&8s%PK zKqxvY*)+SotLu3}le1Tbq+WRYx#RfOnJXFZBv5Z)0-UjiFO!p<_Wo|Ap1UjXA}L9S zcs6Lo5s1`Z+1Ke7NMKb==8}4Td1o-5|J2HOJxdmCXlTd@bO9J_{i|1b!vC(CuySyS z>N;2_{(MYHi)wlgPOHA>d2<-!=XVwYfvl`jCFwI6 z5zSF79NI**+dyF@3&+tI{S$TRI)TNB$tfw$EzeFGm$F0#{tOd=!C+d!YtpjU-{A-d z>}&f{1*-MuJ|J>!&6k1ZiiP-=izz55Ji9E7D#5^9JKrA8LwW@8*d2J)-96Gy1*?Ao z+*3=uXaJy|);=2mi2@7^4B~OPuhk(N=164B>02cyq@_RfpljCqZ<&AYi%&?Xe<5R5 zfh;YgS5{O&01FF?6G^S4i2d+%FSqv8sNP=WWod!GzrX8|$mHniYTd|`A@6Mm7p?EZ zXaPjKc%yprV1a#Q>YF#BznM(egoFfTEv-}@F|B86&Hl|~2JOLv2bj6;?1KcufNsU? zZm$#b^748ZP&8(JzOQ{~D6MZ`V4=5rDBz<+#150u-q)90{det~vYecW+m$ydDa}>Y z)oIbuEWcM*oxqR`yD+G=ALr-LC<(N#U)-NYEbsl_(^s#gYxfOjLn$ubghwg^ug{#8 zQK|HqfH;J$-{gj>)(vOR_R(h=naHbGujc0F);&LEveKdX6IJAmXTTdGh9?dLj#0-Il}sXQH1W^tAhD?56@SQCCzdgIw3)*asgTo znq^^p9FR!FW@buxzH%<1si^^xud*_Ub_rWS7bV2R#EABB2D;2^BG$Somwje$??ZqX zhuWuO@7`Gzw3PgS_BVLDxIUuJL{n$7v~+00Q-fk$#8{zpZ8p3u58f7^X_-T`f7(H) zvo-hn=kT6_3Okeq+Njsml)JTX#`Benr94U4UrFgmfY-jFf&5nn*)1RSoB`hcqoXH> za3inS3vZF2*VFUwvzPmpYY`9k!?9GCsj1xU<%oRq=U$n0wk`QYPZvpqCUXh?-?(b7UGd2>N;Kgu@mT-j6OY{UBj=X*Ok zzLV5xMp0p=Qv(Hryrlgw0O;W1k*^Kkg(2_I+}FNYTC`1_wjPw*XYc`gL2Gh9YrOVg z96#$1oto*4{n0v?HsEe1PZ}M^prF9`PwY_}FeC^B3{!*%JOkS zf$jOp0h)@+qL+xs=YjgEGg10=YrlWfs7VhtXKUKpOmmTn7+OjGu9UN^o~KBiQ&(44 zE|Ivn5=8y}I@Ec-H*eI2_oVS96O)Cox6Py&Fx>xb+}5! zL$!R~Cx4oUGj?>`f1Cg-nUs_iq@bX{b@@wXCgh388Dj^BciETJ@LWP5qK9^T z@837@@$u0_4uuhgQO(c~7J2n0c_SkuKT7Z2{AQPI;j-ickq zw*vzMapF3{IsuE3IXQCI(zRWfHQRsYqIvcHl0-i(!i5hLZS##SECe7dENb`0E`Fs_ z5!n`p+=F42{&NC`2!vYTlHG?79{>Pc6#zUDKHW`Yw{@@`uHi1Zx4?Loo?h~?e?4M{ zp;@&t79y{#Yy?&&XEeIdu^z(8&MtNGz+zbzzN>xhtyWY|&UJcs zwplzL-!xVoa({m>>;rrY>5UFU$_vIneQK<)57g{3Zz9v&>I?JuvWsCXqDKKw4xs^{a?#-=AC6o%(OLH*d6#FyH=imotMSJ%nSRXU2| zA!K1`S?E7!k&d=`eF+k>G;)D>tMn+Sl~$NcV-yPNJyJ%nuK`2yXTI+U*|h@#wA@io zVlFH$az{i&M0)|Ka$lM0_B0mom$H3@pn4kjjT<+#7h+;#oj^eFam8vy>|KO!&z=f; z_^^RS6aDt;jET3mO3nUW2oY5Xad2<|-_-o^>YH&oz2~l^#&Mp-#l`m)dE<+VxC?&M z}^PU4(*$OoiyJli*dz_tD0^^@9ayyhCFt@hmpxEY<_nw_ZnA_Xu@76HR z=hF_w?aYGSC`94Tx^<2Z7NVgSe5HlYIN;RK%}{&h!k1d-na=c7RVRqlsZ(kmy}2qG z(V%8Xhd*G37Bj4sI5;?}wx-{d1+7X|RaNqcm9;ep z@G>Q3vMpH&RTZQLG=^cky^Sp`kHL2q&#E>*d-V#tzA$hKtVxE1ALHtpnwmku!2}YC z4`c)c_GsVXs>WV=aV~7zUs_uFeNmBsi;K%(@!h0OR4=sL&YLtkI2ix-tyr{|-|ANA z=GK;hvT)X?Ph1;IqX=JLbyrZ>q@8t>QcyS?xIA{r#s+qPzneE*EF=fM+)f0s-rL`A zsF>W)*?ANaRX1BS(TGKZ$O1jjvGlVxQN}FA5q#9<&T=iDInkA6lKc5H0+fh*n{-~x zXoV2y7EW&Nb9q+i=0wRvYN8~4wku0K&LNHo0~sbJhSjbn6b1^T14x2GltP>O^$Yb! zT=a>Z6T;B&S!!xL#dE+g4>^g~9Mca9D(muM=Q++QDJiLJTg-Xk!UgeR{clOfL_~6Q zgBdjYLhn)S_$KEVEEaKs&k^L$;m^5-gt}(DD8XD_)v19M1j>V9laP=Q%t#r3Yin!# zlP8T}ev!Or=e4x7fXFTvV0>yS_Bwovl|Ue91ultYW@QxyE<1q2N&nuiXFstkT+gu% zz`@S4V~>hIB9r}cC?(Zx^QZVYRbAQy|NiN@o~rKhxKkam?|cMa2QNB zQt)qAqJ5<>z$YStEksl2dpFJn5l7>9f3+rYa&gV4R0@9Z!>Oq@6XCcbK|MXaJ1#D1 zVRD_{zw^$`&1ruT1E}{phNUDDIV2L@80yN+0|TXIrFfn~yd=6C-9)9{@{c&E+UKO* z>37`_4`!5Qx*rvg7$}ePNNcwYe!Bes_%5sZ;5_oywrhrch5unC>w>Q!_W1<`V{ka` zYU)B8E`NrNt)F$eGY+EN3HQWcjILbaHpU;1EiOJ66BlQwEWD7;iL|wSyzw(a5_Cm( zIn7v}B&!y9{w18rWNP{T;sg;mv9$EmAe#Nq4?RDxk+S<*p_{5=;^GHk!i-hHG`&Y= z&8ffR$7EEa%E^R3{G6rT6|vDu?@_-d93vnVufA@vw6?|;6{&-CLr=DL=t{$` zT+FO1`90fp>Y$6v>Uv*QC6;q7U0qAm0~Fux-rmhiqm?HG60}D)*lk@iz}zxWd6iXO z4hw}#f=XE{U=a$;rni2DHlC^d`)Ijl=P1~_t!!*y!A7`KDg50HM_OSoCYMS6{%~Un zfAh1|Nm*HTu-7p5@lgc{HxBHG0)k54gS8ZlCMPGSJ`(vd;FA<#$X54-ZT?b9ZRfZE zf=rpUePz z?d@srlaBs4hBADpe!NlO8lmpLj2}?l?-AoHe6fE>=-9^@j9Ex3_&*2m&!uZd1%{4~ F{slM=XiWeB literal 0 HcmV?d00001 diff --git a/classentt_1_1Process__inherit__graph.map b/classentt_1_1Process__inherit__graph.map new file mode 100644 index 000000000..680b2b4da --- /dev/null +++ b/classentt_1_1Process__inherit__graph.map @@ -0,0 +1,2 @@ + + diff --git a/classentt_1_1Process__inherit__graph.md5 b/classentt_1_1Process__inherit__graph.md5 new file mode 100644 index 000000000..c08932247 --- /dev/null +++ b/classentt_1_1Process__inherit__graph.md5 @@ -0,0 +1 @@ +1e3fa5c952b53d4982e9051e493f5548 \ No newline at end of file diff --git a/classentt_1_1Process__inherit__graph.png b/classentt_1_1Process__inherit__graph.png new file mode 100644 index 0000000000000000000000000000000000000000..a7c0edc1f4f81c7e2b51c372efaa6c62642ba381 GIT binary patch literal 4373 zcmcIoc{Ei2-@lDDktNGawvwHM5|Oct=u3;37($pVF(hQko@J<+R3a*ANT{J23K#?3F#;yWgJSt3eW8p^G?2S3~H<6HW(e9PCbMVC(kjf>)Y zN+Jgwib;)zm}$lS+b%gWAlx_P1{LE%5yd7;7f z_A8s)+YLiQu*Nu^Xq0ll3Vk)GrKP2=>^^;bdOA*AC&2yHKiL+_w`;^CBqV|+Vns+! zjqK+%G+?7D>gocYt@68=!1ynq5$mX?iBw6e5x%+(Bd`e?Zy zc6Vzg1M_FLOIcfccs5{bYl|4Mzjr0u0vu{)W`_P!&3s)V0bnK?Vz0<175@5lhdr_* zLocKCj(SRJs(bgUnW-s?mXqtXvr4D7kBz;Pk(MTX`lJ}}tA$@ykjn;vU_s;5@{n!d z>)YYW!NI{-q@Jf%kCL6wMtOOAyEZj74a+UAO?~4AloS-4a1_?rhS(!GwdR+m*#T)5 zd3PXDkwQX3cQ=yL(pnuJ&dFra^7=fc=jK{FGxWYg(TnMUV@`#Ig~MThBRF|&8s%PK zKqxvY*)+SotLu3}le1Tbq+WRYx#RfOnJXFZBv5Z)0-UjiFO!p<_Wo|Ap1UjXA}L9S zcs6Lo5s1`Z+1Ke7NMKb==8}4Td1o-5|J2HOJxdmCXlTd@bO9J_{i|1b!vC(CuySyS z>N;2_{(MYHi)wlgPOHA>d2<-!=XVwYfvl`jCFwI6 z5zSF79NI**+dyF@3&+tI{S$TRI)TNB$tfw$EzeFGm$F0#{tOd=!C+d!YtpjU-{A-d z>}&f{1*-MuJ|J>!&6k1ZiiP-=izz55Ji9E7D#5^9JKrA8LwW@8*d2J)-96Gy1*?Ao z+*3=uXaJy|);=2mi2@7^4B~OPuhk(N=164B>02cyq@_RfpljCqZ<&AYi%&?Xe<5R5 zfh;YgS5{O&01FF?6G^S4i2d+%FSqv8sNP=WWod!GzrX8|$mHniYTd|`A@6Mm7p?EZ zXaPjKc%yprV1a#Q>YF#BznM(egoFfTEv-}@F|B86&Hl|~2JOLv2bj6;?1KcufNsU? zZm$#b^748ZP&8(JzOQ{~D6MZ`V4=5rDBz<+#150u-q)90{det~vYecW+m$ydDa}>Y z)oIbuEWcM*oxqR`yD+G=ALr-LC<(N#U)-NYEbsl_(^s#gYxfOjLn$ubghwg^ug{#8 zQK|HqfH;J$-{gj>)(vOR_R(h=naHbGujc0F);&LEveKdX6IJAmXTTdGh9?dLj#0-Il}sXQH1W^tAhD?56@SQCCzdgIw3)*asgTo znq^^p9FR!FW@buxzH%<1si^^xud*_Ub_rWS7bV2R#EABB2D;2^BG$Somwje$??ZqX zhuWuO@7`Gzw3PgS_BVLDxIUuJL{n$7v~+00Q-fk$#8{zpZ8p3u58f7^X_-T`f7(H) zvo-hn=kT6_3Okeq+Njsml)JTX#`Benr94U4UrFgmfY-jFf&5nn*)1RSoB`hcqoXH> za3inS3vZF2*VFUwvzPmpYY`9k!?9GCsj1xU<%oRq=U$n0wk`QYPZvpqCUXh?-?(b7UGd2>N;Kgu@mT-j6OY{UBj=X*Ok zzLV5xMp0p=Qv(Hryrlgw0O;W1k*^Kkg(2_I+}FNYTC`1_wjPw*XYc`gL2Gh9YrOVg z96#$1oto*4{n0v?HsEe1PZ}M^prF9`PwY_}FeC^B3{!*%JOkS zf$jOp0h)@+qL+xs=YjgEGg10=YrlWfs7VhtXKUKpOmmTn7+OjGu9UN^o~KBiQ&(44 zE|Ivn5=8y}I@Ec-H*eI2_oVS96O)Cox6Py&Fx>xb+}5! zL$!R~Cx4oUGj?>`f1Cg-nUs_iq@bX{b@@wXCgh388Dj^BciETJ@LWP5qK9^T z@837@@$u0_4uuhgQO(c~7J2n0c_SkuKT7Z2{AQPI;j-ickq zw*vzMapF3{IsuE3IXQCI(zRWfHQRsYqIvcHl0-i(!i5hLZS##SECe7dENb`0E`Fs_ z5!n`p+=F42{&NC`2!vYTlHG?79{>Pc6#zUDKHW`Yw{@@`uHi1Zx4?Loo?h~?e?4M{ zp;@&t79y{#Yy?&&XEeIdu^z(8&MtNGz+zbzzN>xhtyWY|&UJcs zwplzL-!xVoa({m>>;rrY>5UFU$_vIneQK<)57g{3Zz9v&>I?JuvWsCXqDKKw4xs^{a?#-=AC6o%(OLH*d6#FyH=imotMSJ%nSRXU2| zA!K1`S?E7!k&d=`eF+k>G;)D>tMn+Sl~$NcV-yPNJyJ%nuK`2yXTI+U*|h@#wA@io zVlFH$az{i&M0)|Ka$lM0_B0mom$H3@pn4kjjT<+#7h+;#oj^eFam8vy>|KO!&z=f; z_^^RS6aDt;jET3mO3nUW2oY5Xad2<|-_-o^>YH&oz2~l^#&Mp-#l`m)dE<+VxC?&M z}^PU4(*$OoiyJli*dz_tD0^^@9ayyhCFt@hmpxEY<_nw_ZnA_Xu@76HR z=hF_w?aYGSC`94Tx^<2Z7NVgSe5HlYIN;RK%}{&h!k1d-na=c7RVRqlsZ(kmy}2qG z(V%8Xhd*G37Bj4sI5;?}wx-{d1+7X|RaNqcm9;ep z@G>Q3vMpH&RTZQLG=^cky^Sp`kHL2q&#E>*d-V#tzA$hKtVxE1ALHtpnwmku!2}YC z4`c)c_GsVXs>WV=aV~7zUs_uFeNmBsi;K%(@!h0OR4=sL&YLtkI2ix-tyr{|-|ANA z=GK;hvT)X?Ph1;IqX=JLbyrZ>q@8t>QcyS?xIA{r#s+qPzneE*EF=fM+)f0s-rL`A zsF>W)*?ANaRX1BS(TGKZ$O1jjvGlVxQN}FA5q#9<&T=iDInkA6lKc5H0+fh*n{-~x zXoV2y7EW&Nb9q+i=0wRvYN8~4wku0K&LNHo0~sbJhSjbn6b1^T14x2GltP>O^$Yb! zT=a>Z6T;B&S!!xL#dE+g4>^g~9Mca9D(muM=Q++QDJiLJTg-Xk!UgeR{clOfL_~6Q zgBdjYLhn)S_$KEVEEaKs&k^L$;m^5-gt}(DD8XD_)v19M1j>V9laP=Q%t#r3Yin!# zlP8T}ev!Or=e4x7fXFTvV0>yS_Bwovl|Ue91ultYW@QxyE<1q2N&nuiXFstkT+gu% zz`@S4V~>hIB9r}cC?(Zx^QZVYRbAQy|NiN@o~rKhxKkam?|cMa2QNB zQt)qAqJ5<>z$YStEksl2dpFJn5l7>9f3+rYa&gV4R0@9Z!>Oq@6XCcbK|MXaJ1#D1 zVRD_{zw^$`&1ruT1E}{phNUDDIV2L@80yN+0|TXIrFfn~yd=6C-9)9{@{c&E+UKO* z>37`_4`!5Qx*rvg7$}ePNNcwYe!Bes_%5sZ;5_oywrhrch5unC>w>Q!_W1<`V{ka` zYU)B8E`NrNt)F$eGY+EN3HQWcjILbaHpU;1EiOJ66BlQwEWD7;iL|wSyzw(a5_Cm( zIn7v}B&!y9{w18rWNP{T;sg;mv9$EmAe#Nq4?RDxk+S<*p_{5=;^GHk!i-hHG`&Y= z&8ffR$7EEa%E^R3{G6rT6|vDu?@_-d93vnVufA@vw6?|;6{&-CLr=DL=t{$` zT+FO1`90fp>Y$6v>Uv*QC6;q7U0qAm0~Fux-rmhiqm?HG60}D)*lk@iz}zxWd6iXO z4hw}#f=XE{U=a$;rni2DHlC^d`)Ijl=P1~_t!!*y!A7`KDg50HM_OSoCYMS6{%~Un zfAh1|Nm*HTu-7p5@lgc{HxBHG0)k54gS8ZlCMPGSJ`(vd;FA<#$X54-ZT?b9ZRfZE zf=rpUePz z?d@srlaBs4hBADpe!NlO8lmpLj2}?l?-AoHe6fE>=-9^@j9Ex3_&*2m&!uZd1%{4~ F{slM=XiWeB literal 0 HcmV?d00001 diff --git a/classentt_1_1Registry-members.html b/classentt_1_1Registry-members.html index b085da50b..2cd6eb018 100644 --- a/classentt_1_1Registry-members.html +++ b/classentt_1_1Registry-members.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0
@@ -72,25 +72,33 @@ $(function() { + + - - - - - + + + + + + + + + - - - - - - - - + + + + + + + + + + @@ -105,7 +113,6 @@ $(function() { -
accomodate(entity_type entity, Args &&... args)entt::Registry< Entity >inline
assign(entity_type entity, Args &&... args)entt::Registry< Entity >inline
attach(entity_type entity, Args &&... args)entt::Registry< Entity >inline
attachee() const noexceptentt::Registry< Entity >inline
capacity() const noexceptentt::Registry< Entity >inline
create(Component &&... components) noexceptentt::Registry< Entity >inline
create() noexceptentt::Registry< Entity >inline
create() noexceptentt::Registry< Entity >inline
current(entity_type entity) const noexceptentt::Registry< Entity >inline
destroy(entity_type entity)entt::Registry< Entity >inline
contains() const noexceptentt::Registry< Entity >inline
create(Component &&... components) noexceptentt::Registry< Entity >inline
create() noexceptentt::Registry< Entity >inline
create() noexceptentt::Registry< Entity >inline
current(entity_type entity) const noexceptentt::Registry< Entity >inline
destroy(entity_type entity)entt::Registry< Entity >inline
discard()entt::Registry< Entity >inline
empty() const noexceptentt::Registry< Entity >inline
empty() const noexceptentt::Registry< Entity >inline
entity_type typedefentt::Registry< Entity >
get() const noexceptentt::Registry< Entity >inline
get() noexceptentt::Registry< Entity >inline
get(entity_type entity) const noexceptentt::Registry< Entity >inline
get(entity_type entity) noexceptentt::Registry< Entity >inline
has(entity_type entity) const noexceptentt::Registry< Entity >inline
operator=(const Registry &)=deleteentt::Registry< Entity >
operator=(Registry &&)=deleteentt::Registry< Entity >
persistent()entt::Registry< Entity >inline
prepare()entt::Registry< Entity >inline
Registry()=defaultentt::Registry< Entity >explicit
Registry(const Registry &)=deleteentt::Registry< Entity >
Registry(Registry &&)=deleteentt::Registry< Entity >
has() const noexceptentt::Registry< Entity >inline
has(entity_type entity) const noexceptentt::Registry< Entity >inline
operator=(const Registry &)=deleteentt::Registry< Entity >
operator=(Registry &&)=defaultentt::Registry< Entity >
persistent()entt::Registry< Entity >inline
prepare()entt::Registry< Entity >inline
Registry()=defaultentt::Registry< Entity >
Registry(const Registry &)=deleteentt::Registry< Entity >
Registry(Registry &&)=defaultentt::Registry< Entity >
remove()entt::Registry< Entity >inline
remove(entity_type entity)entt::Registry< Entity >inline
replace(entity_type entity, Args &&... args)entt::Registry< Entity >inline
reset(entity_type entity)entt::Registry< Entity >inline
version(entity_type entity) const noexceptentt::Registry< Entity >inline
version_type typedefentt::Registry< Entity >
view()entt::Registry< Entity >inline
~Registry()=defaultentt::Registry< Entity >
diff --git a/classentt_1_1Registry.html b/classentt_1_1Registry.html index 7e90fc6a6..c972e0d6e 100644 --- a/classentt_1_1Registry.html +++ b/classentt_1_1Registry.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0
@@ -97,26 +97,22 @@ using   Registry ()=default - Default constructor, explicit on purpose.
+ Default constructor.
  - - ~Registry ()=default - Default destructor.
-   Registry (const Registry &)=delete  Copying a registry isn't allowed.
  - - Registry (Registry &&)=delete - Moving 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 &&)=delete - Moving a registry isn't allowed. More...
-  +Registry & operator= (Registry &&)=default + Default move assignment operator. More...
+  template<typename Component > size_type size () const noexcept  Returns the number of existing components of the given type. More...
@@ -135,13 +131,13 @@ Public Member Functions  Checks if there exists at least an entity still in use. More...
  bool valid (entity_type entity) const noexcept - Verifies if the entity identifier still refers to a valid entity. More...
+ Verifies if an entity identifier still refers to a valid entity. More...
  version_type version (entity_type entity) const noexcept - Returns the version stored along with the given entity identifier. More...
+ Returns the version stored along with an entity identifier. More...
  version_type current (entity_type entity) const noexcept - Returns the actual version for the given entity identifier. More...
+ Returns the actual version for an entity identifier. More...
  template<typename... Component> entity_type create (Component &&... components) noexcept @@ -157,37 +153,61 @@ Public Member Functions void destroy (entity_type entity)  Destroys an entity and lets the registry recycle the identifier. More...
  +template<typename Tag , typename... Args> +Tag & attach (entity_type entity, Args &&... args) + Attaches a tag to an entity. More...
+  +template<typename Tag > +void remove () + Removes a tag from its owner, if any. More...
+  +template<typename Tag > +bool has () const noexcept + Checks if a tag has an owner. More...
+  +template<typename Tag > +const Tag & get () const noexcept + Returns a reference to a tag. More...
+  +template<typename Tag > +Tag & get () noexcept + Returns a reference to a tag. More...
+  +template<typename Tag > +entity_type attachee () const noexcept + Gets the owner of a tag, if any. More...
+  template<typename Component , typename... Args> Component & assign (entity_type entity, Args &&... args) - Assigns the given component to the given entity. More...
+ Assigns the given component to an entity. More...
  template<typename Component > void remove (entity_type entity) - Removes the given component from the given entity. More...
+ Removes the given component from an entity. More...
  template<typename... Component> bool has (entity_type entity) const noexcept - Checks if the given entity has all the given components. More...
+ Checks if an entity has all the given components. More...
  template<typename Component > const Component & get (entity_type entity) const noexcept - Gets a reference to the given component owned by the given entity. More...
+ Returns a reference to the given component for an entity. More...
  template<typename Component > Component & get (entity_type entity) noexcept - Gets a reference to the given component owned by the given entity. More...
+ Returns a reference to the given component for an entity. More...
  template<typename Component , typename... Args> Component & replace (entity_type entity, Args &&... args) - Replaces the given component for the given entity. More...
+ Replaces the given component for an entity. More...
  template<typename Component , typename... Args> Component & accomodate (entity_type entity, Args &&... args) - Assigns or replaces the given component to the given entity. More...
+ Assigns or replaces the given component for an entity. More...
  template<typename Component , typename Compare > void sort (Compare compare) - Sorts the pool of the given component. More...
+ Sorts the pool of entities for the given component. More...
  template<typename To , typename From > void sort () @@ -195,14 +215,14 @@ Public Member Functions   template<typename Component > void reset (entity_type entity) - Resets the given component for the given entity. More...
+ Resets the given component for an entity. More...
  template<typename Component > void reset ()  Resets the pool of the given component. More...
  void reset () - Resets the whole registry. More...
+ Resets a whole registry. More...
  template<typename... Component> View< Entity, Component... > view () @@ -212,6 +232,14 @@ Public Member Functions 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 noexcept + Checks if a persistent view has already been prepared. More...
+  template<typename... Component> PersistentView< Entity, Component... > persistent ()  Returns a persistent view for the given components. More...
@@ -231,7 +259,7 @@ class entt::Registry< Entity >
-

Definition at line 30 of file registry.hpp.

+

Definition at line 31 of file registry.hpp.

Member Function Documentation

◆ accomodate()

@@ -239,7 +267,7 @@ class entt::Registry< Entity >
-template<typename Entity >
+template<typename Entity>
template<typename Component , typename... Args>
@@ -271,14 +299,14 @@ template<typename Component , typename... Args>
-

Assigns or replaces the given component to the given entity.

+

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 slighlty 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 the component to assign or replace.
ComponentType of component to assign or replace.
ArgsTypes of arguments to use to construct the component.
@@ -292,7 +320,7 @@ template<typename Component , typename... Args>
Returns
A reference to the newly created component.
-

Definition at line 492 of file registry.hpp.

+

Definition at line 661 of file registry.hpp.

@@ -302,7 +330,7 @@ template<typename Component , typename... Args>
-template<typename Entity >
+template<typename Entity>
template<typename Component , typename... Args>
@@ -334,13 +362,13 @@ template<typename Component , typename... Args>
-

Assigns the given component to the given entity.

+

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 the component to create.
ComponentType of component to create.
ArgsTypes of arguments to use to construct the component.
@@ -354,7 +382,112 @@ template<typename Component , typename... Args>
Returns
A reference to the newly created component.
-

Definition at line 352 of file registry.hpp.

+

Definition at line 521 of file registry.hpp.

+ + + + +

◆ attach()

+ +
+
+
+template<typename Entity>
+
+template<typename Tag , typename... Args>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Tag& entt::Registry< Entity >::attach (entity_type entity,
Args &&... args 
)
+ 		+inline
+
+ +

Attaches a 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 406 of file registry.hpp.

+ +
+
+ +

◆ attachee()

+ +
+
+
+template<typename Entity>
+
+template<typename Tag >
+ + + + + +
+ + + + + + + +
entity_type entt::Registry< Entity >::attachee () const
+ 		+inlinenoexcept
+
+ +

Gets the owner of a tag, if any.

+
Warning
Attempting to get the owner of a tag that hasn't been previously attached to an entity results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode if the tag hasn't an owner.
+
Template Parameters
+ + +
TagType of tag of which to get the owner.
+
+
+
Returns
A valid entity identifier.
+ +

Definition at line 495 of file registry.hpp.

@@ -364,7 +497,7 @@ template<typename Component , typename... Args>
-template<typename Entity >
+template<typename Entity>
@@ -91,31 +91,11 @@ using  - - - - - - - - - - - - - - - - - - - + @@ -196,83 +176,6 @@ template<typename Class >

Definition at line 71 of file signal.hpp.

- - -

Constructor & Destructor Documentation

- -

◆ Signal() [1/2]

- -
-
-
-template<typename... Args>
-
@@ -386,7 +519,47 @@ template<typename Entity >

Returns the number of entities ever created.

Returns
Number of entities ever created.
-

Definition at line 150 of file registry.hpp.

+

Definition at line 200 of file registry.hpp.

+ + + + +

◆ contains()

+ +
+
+
+template<typename Entity>
+
+template<typename... Component>
+ + + + + +
+ + + + + + + +
bool entt::Registry< Entity >::contains () const
+ 		+inlinenoexcept
+
+ +

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 913 of file registry.hpp.

@@ -396,7 +569,7 @@ template<typename Entity >
-template<typename Entity >
+template<typename Entity>
template<typename... Component>
@@ -419,7 +592,8 @@ template<typename... Component>

Returns a new entity initialized with the given components.

-

There are two kinds of entity identifiers:

    +

    There are two kinds of entity identifiers:

    +
    • Newly created ones in case no entities have been previously destroyed.
    • Recycled one with updated versions.
    @@ -439,7 +613,7 @@ template<typename... Component>
Returns
A valid entity identifier.
-

Definition at line 234 of file registry.hpp.

+

Definition at line 285 of file registry.hpp.

@@ -449,7 +623,7 @@ template<typename... Component>
-template<typename Entity >
+template<typename Entity>
template<typename... Component>
@@ -471,7 +645,8 @@ template<typename... Component>

Returns a new entity to which the given components are assigned.

-

There are two kinds of entity identifiers:

    +

    There are two kinds of entity identifiers:

    +
    • Newly created ones in case no entities have been previously destroyed.
    • Recycled one with updated versions.
    @@ -485,7 +660,7 @@ template<typename... Component>
Returns
A valid entity identifier.
-

Definition at line 260 of file registry.hpp.

+

Definition at line 312 of file registry.hpp.

@@ -495,7 +670,7 @@ template<typename... Component>
-template<typename Entity >
+template<typename Entity>
diff --git a/classentt_1_1Signal_3_01void_07Args_8_8_8_08_4-members.html b/classentt_1_1Signal_3_01void_07Args_8_8_8_08_4-members.html index b49f306af..e20c71261 100644 --- a/classentt_1_1Signal_3_01void_07Args_8_8_8_08_4-members.html +++ b/classentt_1_1Signal_3_01void_07Args_8_8_8_08_4-members.html @@ -22,7 +22,7 @@ @@ -78,17 +78,11 @@ $(function() { - - - - - - - - - + + +
@@ -515,7 +690,8 @@ template<typename Entity >

Creates a new entity and returns it.

-

There are two kinds of entity identifiers:

    +

    There are two kinds of entity identifiers:

    +
    • Newly created ones in case no entities have been previously destroyed.
    • Recycled one with updated versions.
    @@ -523,7 +699,7 @@ template<typename Entity >

The returned entity has no components assigned.

Returns
A valid entity identifier.
-

Definition at line 284 of file registry.hpp.

+

Definition at line 337 of file registry.hpp.

@@ -533,7 +709,7 @@ template<typename Entity >
-template<typename Entity >
+template<typename Entity>
@@ -553,7 +729,7 @@ template<typename Entity >
-

Returns the actual version for the given entity identifier.

+

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.
@@ -565,7 +741,7 @@ template<typename Entity >
Returns
Actual version for the given entity identifier.
-

Definition at line 209 of file registry.hpp.

+

Definition at line 259 of file registry.hpp.

@@ -575,7 +751,7 @@ template<typename Entity >
-template<typename Entity >
+template<typename Entity>
@@ -606,7 +782,49 @@ template<typename Entity > -

Definition at line 315 of file registry.hpp.

+

Definition at line 368 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 persisten 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 895 of file registry.hpp.

@@ -616,7 +834,7 @@ template<typename Entity >
-template<typename Entity >
+template<typename Entity>
template<typename Component >
@@ -646,7 +864,7 @@ template<typename Component >
Returns
True if the pool for the given component is empty, false otherwise.
-

Definition at line 161 of file registry.hpp.

+

Definition at line 211 of file registry.hpp.

@@ -656,7 +874,7 @@ template<typename Component >
-template<typename Entity >
+template<typename Entity>
@@ -109,31 +109,11 @@ using  - - - - - - - - - - - - - - - - - - - + @@ -181,11 +161,13 @@ class 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.

-

This class serves mainly two purposes:

    +

    This class serves mainly two purposes:

    +
    • Creating signals used later to notify a bunch of listeners.
    • Collecting results from a set of functions like in a voting system.
    -

    The default collector does nothing. To properly collect data, define and use a class that has a call operator the signature of which is bool(Param) and:

      +

      The default collector does nothing. To properly collect data, define and use a class that has a call operator the signature of which is bool(Param) and:

      +
      • Param is a type to which Ret can be converted.
      • The return type is true if the handler must stop collecting data, false otherwise.
      @@ -198,7 +180,7 @@ class entt::SigH< Ret(Args...), Collector > -

      Definition at line 108 of file sigh.hpp.

      +

      Definition at line 110 of file sigh.hpp.

      Member Typedef Documentation

      ◆ instance_type

      @@ -224,84 +206,7 @@ template<typename Class > -

      Definition at line 132 of file sigh.hpp.

      - - - -

      Constructor & Destructor Documentation

      - -

      ◆ SigH() [1/2]

      - -
      -
      -
      -template<typename Ret , typename... Args, typename Collector >
      -
@@ -678,17 +896,101 @@ template<typename Entity >

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 169 of file registry.hpp.

+

Definition at line 219 of file registry.hpp.

- -

◆ get() [1/2]

+ +

◆ get() [1/4]

-template<typename Entity >
+template<typename Entity>
+
+template<typename Tag >
+ + + + + +
+ + + + + + + +
const Tag& entt::Registry< Entity >::get () const
+ 		+inlinenoexcept
+
+ +

Returns a reference to a 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 460 of file registry.hpp.

+ +
+ + +

◆ get() [2/4]

+ +
+
+
+template<typename Entity>
+
+template<typename Tag >
+ + + + + +
+ + + + + + + +
Tag& entt::Registry< Entity >::get ()
+ 		+inlinenoexcept
+
+ +

Returns a reference to a 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 478 of file registry.hpp.

+ +
+
+ +

◆ get() [3/4]

+ +
+
+
+template<typename Entity>
template<typename Component >
@@ -710,12 +1012,12 @@ template<typename Component >
-

Gets a reference to the given component owned by the given entity.

+

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 the component to get.
ComponentType of component to get.
@@ -727,17 +1029,17 @@ template<typename Component >
Returns
A reference to the instance of the component owned by the entity.
-

Definition at line 414 of file registry.hpp.

+

Definition at line 583 of file registry.hpp.

-

◆ get() [2/2]

+

◆ get() [4/4]

-template<typename Entity >
+template<typename Entity>
template<typename Component >
@@ -759,12 +1061,12 @@ template<typename Component >
-

Gets a reference to the given component owned by the given entity.

+

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 the component to get.
ComponentType of component to get.
@@ -776,17 +1078,57 @@ template<typename Component >
Returns
A reference to the instance of the component owned by the entity.
-

Definition at line 434 of file registry.hpp.

+

Definition at line 603 of file registry.hpp.

- -

◆ has()

+ +

◆ has() [1/2]

-template<typename Entity >
+template<typename Entity>
+
+template<typename Tag >
+ + + + + +
+ + + + + + + +
bool entt::Registry< Entity >::has () const
+ 		+inlinenoexcept
+
+ +

Checks if a 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 438 of file registry.hpp.

+ +
+ + +

◆ has() [2/2]

+ +
+
+
+template<typename Entity>
template<typename... Component>
@@ -808,7 +1150,7 @@ template<typename... Component>
-

Checks if the given entity has all the given components.

+

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
@@ -825,7 +1167,7 @@ template<typename... Component>
Returns
True if the entity has all the components, false otherwise.
-

Definition at line 389 of file registry.hpp.

+

Definition at line 558 of file registry.hpp.

@@ -835,7 +1177,7 @@ template<typename... Component>
-template<typename Entity >
+template<typename Entity>
+default
@@ -860,13 +1202,13 @@ template<typename Entity > - -

◆ operator=() [2/2]

+ +

◆ operator=() [2/2]

-template<typename Entity >
+template<typename Entity>
@@ -881,12 +1223,12 @@ template<typename Entity >
-delete
-

Moving a registry isn't allowed.

+

Default move assignment operator.

Returns
This registry.
@@ -897,7 +1239,7 @@ template<typename Entity >
-template<typename Entity >
+template<typename Entity>
template<typename... Component>
@@ -923,7 +1265,8 @@ template<typename... Component> 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 entites when the number of components grows up and the most of the entities have all the given components.
- However they have also drawbacks:

    + 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.
    @@ -936,13 +1279,13 @@ template<typename... Component> PersistentView
    Template Parameters
- +
ComponentTypes of the components used to construct the view.
ComponentTypes of components used to construct the view.
Returns
A newly created persistent view.
-

Definition at line 753 of file registry.hpp.

+

Definition at line 957 of file registry.hpp.

@@ -952,7 +1295,7 @@ template<typename... Component>
-template<typename Entity >
+template<typename Entity>
template<typename... Component>
@@ -979,22 +1322,61 @@ template<typename... Component> 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 contruct the view.

Template Parameters
- +
ComponentTypes of the components used to prepare the view.
ComponentTypes of components used to prepare the view.
-

Definition at line 690 of file registry.hpp.

+

Definition at line 875 of file registry.hpp.

- -

◆ remove()

+ +

◆ remove() [1/2]

-template<typename Entity >
+template<typename Entity>
+
+template<typename Tag >
+ + + + + +
+ + + + + + + +
void entt::Registry< Entity >::remove ()
+ 		+inline
+
+ +

Removes a tag from its owner, if any.

+
Template Parameters
+ + +
TagType of tag to remove.
+
+
+ +

Definition at line 426 of file registry.hpp.

+ +
+ + +

◆ remove() [2/2]

+ +
+
+
+template<typename Entity>
template<typename Component >
@@ -1016,12 +1398,12 @@ template<typename Component >
-

Removes the given component from the given entity.

+

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 the component to remove.
ComponentType of component to remove.
@@ -1032,7 +1414,7 @@ template<typename Component >
-

Definition at line 371 of file registry.hpp.

+

Definition at line 540 of file registry.hpp.

@@ -1042,7 +1424,7 @@ template<typename Component >
-template<typename Entity >
+template<typename Entity>
template<typename Component , typename... Args>
@@ -1074,13 +1456,13 @@ template<typename Component , typename... Args>
-

Replaces the given component for the given entity.

+

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 the component to replace.
ComponentType of component to replace.
ArgsTypes of arguments to use to construct the component.
@@ -1094,7 +1476,7 @@ template<typename Component , typename... Args>
Returns
A reference to the newly created component.
-

Definition at line 459 of file registry.hpp.

+

Definition at line 628 of file registry.hpp.

@@ -1104,7 +1486,7 @@ template<typename Component , typename... Args>
-template<typename Entity >
+template<typename Entity>
template<typename Component >
@@ -1126,13 +1508,13 @@ template<typename Component >
-

Resets the given component for the given entity.

+

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 the component to reset.
ComponentType of component to reset.
@@ -1143,7 +1525,7 @@ template<typename Component >
-

Definition at line 585 of file registry.hpp.

+

Definition at line 754 of file registry.hpp.

@@ -1153,7 +1535,7 @@ template<typename Component >
-template<typename Entity >
+template<typename Entity>
template<typename Component >
@@ -1178,12 +1560,12 @@ template<typename Component >

For each entity that has an instance of the given component, the component itself is removed and thus destroyed.

Template Parameters
- +
Componenttype of the component whose pool must be reset.
ComponentType of component whose pool must be reset.
-

Definition at line 606 of file registry.hpp.

+

Definition at line 775 of file registry.hpp.

@@ -1193,7 +1575,7 @@ template<typename Component >
-template<typename Entity >
+template<typename Entity>
@@ -1212,10 +1594,10 @@ template<typename Entity >
-

Resets the whole registry.

+

Resets a whole registry.

Destroys all the entities. After a call to reset, all the entities previously created are recycled with a new version number. In case entity identifers are stored around, the current member function can be used to know if they are still valid.

-

Definition at line 626 of file registry.hpp.

+

Definition at line 795 of file registry.hpp.

@@ -1225,7 +1607,7 @@ template<typename Entity >
-template<typename Entity >
+template<typename Entity>
template<typename Component >
@@ -1255,7 +1637,7 @@ template<typename Component >
Returns
Number of existing components of the given type.
-

Definition at line 134 of file registry.hpp.

+

Definition at line 184 of file registry.hpp.

@@ -1265,7 +1647,7 @@ template<typename Component >
-template<typename Entity >
+template<typename Entity>
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 index edd6666ba..12d73fc60 100644 --- 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 @@ -22,7 +22,7 @@ @@ -80,17 +80,11 @@ $(function() { - - - - - - - - - + + +
@@ -1287,7 +1669,7 @@ template<typename Entity >

Returns the number of entities still in use.

Returns
Number of entities still in use.
-

Definition at line 142 of file registry.hpp.

+

Definition at line 192 of file registry.hpp.

@@ -1297,7 +1679,7 @@ template<typename Entity >
-template<typename Entity >
+template<typename Entity>
template<typename Component , typename Compare >
@@ -1319,15 +1701,15 @@ template<typename Component , typename Compare >
-

Sorts the pool of the given component.

+

Sorts the pool of entities for the given component.

The order of the elements in a pool is highly affected by assignements 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 for 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(auto e1, auto e2)

Where e1 and e2 are valid entity identifiers.

Template Parameters
- - + +
ComponentType of the components to sort.
CompareType of the comparison function object.
ComponentType of components to sort.
CompareType of comparison function object.
@@ -1338,7 +1720,7 @@ template<typename Component , typename Compare >
-

Definition at line 527 of file registry.hpp.

+

Definition at line 696 of file registry.hpp.

@@ -1348,7 +1730,7 @@ template<typename Component , typename Compare >
-template<typename Entity >
+template<typename Entity>
template<typename To , typename From >
@@ -1381,13 +1763,13 @@ template<typename To , typename From >

Any subsequent change to B won't affect the order in A.

Template Parameters
- - + +
ToType of the components to sort.
FromType of the components to use to sort.
ToType of components to sort.
FromType of components to use to sort.
-

Definition at line 566 of file registry.hpp.

+

Definition at line 735 of file registry.hpp.

@@ -1397,7 +1779,7 @@ template<typename To , typename From >
-template<typename Entity >
+template<typename Entity>
@@ -1417,7 +1799,7 @@ template<typename Entity >
-

Verifies if the entity identifier still refers to a valid entity.

+

Verifies if an entity identifier still refers to a valid entity.

Parameters
@@ -1426,7 +1808,7 @@ template<typename Entity >
Returns
True if the identifier is still valid, false otherwise.
-

Definition at line 178 of file registry.hpp.

+

Definition at line 228 of file registry.hpp.

@@ -1436,7 +1818,7 @@ template<typename Entity >
-template<typename Entity >
+template<typename Entity>
entityAn entity identifier, either valid or not.
@@ -1456,7 +1838,7 @@ template<typename Entity >
-

Returns the version stored along with the given entity identifier.

+

Returns the version stored along with an entity identifier.

Parameters
@@ -1465,7 +1847,7 @@ template<typename Entity >
Returns
Version stored along with the given entity identifier.
-

Definition at line 188 of file registry.hpp.

+

Definition at line 238 of file registry.hpp.

@@ -1475,7 +1857,7 @@ template<typename Entity >
-template<typename Entity >
+template<typename Entity>
template<typename... Component>
entityAn entity identifier, either valid or not.
@@ -1500,7 +1882,8 @@ template<typename... 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.

-

Standard views do their best to iterate the smallest set of candidate entites. In particular:

    +

    Standard views do their best to iterate the smallest set of candidate entites. 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.
    @@ -1513,13 +1896,13 @@ template<typename... Component> PersistentView
    Template Parameters
- +
ComponentType of the components used to construct the view.
ComponentType of components used to construct the view.
Returns
A newly created standard view.
-

Definition at line 669 of file registry.hpp.

+

Definition at line 854 of file registry.hpp.

diff --git a/classentt_1_1ResourceCache-members.html b/classentt_1_1ResourceCache-members.html new file mode 100644 index 000000000..3320c092b --- /dev/null +++ b/classentt_1_1ResourceCache-members.html @@ -0,0 +1,96 @@ + + + + + + + +entt: Member List + + + + + + + + + +
+
+ + + + + + +
+
entt +  2.2.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
entt::ResourceCache< Resource > Member List
+
+
+ +

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

+ + + + + + + + + + + + + + + + +
clear() noexceptentt::ResourceCache< Resource >inline
contains(resource_type id) const noexceptentt::ResourceCache< Resource >inline
discard(resource_type id) noexceptentt::ResourceCache< Resource >inline
empty() const noexceptentt::ResourceCache< Resource >inline
handle(resource_type id) constentt::ResourceCache< Resource >inline
load(resource_type id, Args &&... args)entt::ResourceCache< Resource >inline
operator=(const ResourceCache &) noexcept=deleteentt::ResourceCache< Resource >
operator=(ResourceCache &&) noexcept=defaultentt::ResourceCache< Resource >
reload(resource_type id, Args &&... args)entt::ResourceCache< Resource >inline
resource_type typedefentt::ResourceCache< Resource >
ResourceCache()=defaultentt::ResourceCache< Resource >
ResourceCache(const ResourceCache &) noexcept=deleteentt::ResourceCache< Resource >
ResourceCache(ResourceCache &&) noexcept=defaultentt::ResourceCache< Resource >
size() const noexceptentt::ResourceCache< Resource >inline
size_type typedefentt::ResourceCache< Resource >
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1ResourceCache.html b/classentt_1_1ResourceCache.html new file mode 100644 index 000000000..d61ffce67 --- /dev/null +++ b/classentt_1_1ResourceCache.html @@ -0,0 +1,563 @@ + + + + + + + +entt: entt::ResourceCache< Resource > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
entt +  2.2.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+Public Types | +Public Member Functions | +List of all members
+
+
entt::ResourceCache< Resource > Class Template Reference
+
+
+ +

Simple cache for resources of a given type. + More...

+ +

#include <cache.hpp>

+ + + + + + + + +

+Public Types

+using size_type = typename container_type::size_type
 Unsigned integer type.
 
+using resource_type = HashedString
 Type of resources managed by a cache.
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+ ResourceCache ()=default
 Default constructor.
 
+ ResourceCache (const ResourceCache &) noexcept=delete
 Copying a cache isn't allowed.
 
+ ResourceCache (ResourceCache &&) noexcept=default
 Default move constructor.
 
ResourceCache & operator= (const ResourceCache &) noexcept=delete
 Copying a cache isn't allowed. More...
 
ResourceCache & operator= (ResourceCache &&) noexcept=default
 Default move assignment operator. More...
 
size_type size () const noexcept
 Number of resources managed by a cache. More...
 
bool empty () const noexcept
 Returns true if a cache contains no resources, false otherwise. More...
 
void clear () noexcept
 Clears a cache and discards all its resources. More...
 
template<typename Loader , typename... Args>
bool load (resource_type id, Args &&... args)
 Loads the resource that corresponds to the given identifier. More...
 
template<typename Loader , typename... Args>
void reload (resource_type id, Args &&... args)
 Reloads a resource or loads it for the first time if not present. More...
 
ResourceHandle< Resource > handle (resource_type id) const
 Creates a handle for the given resource identifier. More...
 
bool contains (resource_type id) const noexcept
 Checks if a cache contains the given identifier. More...
 
void discard (resource_type id) noexcept
 Discards the resource that corresponds to the given identifier. More...
 
+

Detailed Description

+

template<typename Resource>
+class entt::ResourceCache< 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.

+
Template Parameters
+ + +
ResourceType of resources managed by a cache.
+
+
+ +

Definition at line 28 of file cache.hpp.

+

Member Function Documentation

+ +

◆ clear()

+ +
+
+
+template<typename Resource >
+ + + + + +
+ + + + + + + +
void entt::ResourceCache< Resource >::clear ()
+ 		+inlinenoexcept
+
+ +

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 72 of file cache.hpp.

+ +
+
+ +

◆ contains()

+ +
+
+
+template<typename Resource >
+ + + + + +
+ + + + + + + + +
bool entt::ResourceCache< Resource >::contains (resource_type id) const
+ 		+inlinenoexcept
+
+ +

Checks if a cache contains the given identifier.

+
Parameters
+ + +
idUnique resource identifier.
+
+
+
Returns
True if the cache contains the resource, false otherwise.
+ +

Definition at line 155 of file cache.hpp.

+ +
+
+ +

◆ discard()

+ +
+
+
+template<typename Resource >
+ + + + + +
+ + + + + + + + +
void entt::ResourceCache< Resource >::discard (resource_type id)
+ 		+inlinenoexcept
+
+ +

Discards the resource that corresponds to the given identifier.

+

Handles are not invalidated and the memory used by the resource isn't freed as long as at least a handle keeps the resource itself alive.

+
Parameters
+ + +
idUnique resource identifier.
+
+
+ +

Definition at line 167 of file cache.hpp.

+ +
+
+ +

◆ empty()

+ +
+
+
+template<typename Resource >
+ + + + + +
+ + + + + + + +
bool entt::ResourceCache< Resource >::empty () const
+ 		+inlinenoexcept
+
+ +

Returns true if a cache contains no resources, false otherwise.

+
Returns
True if the cache contains no resources, false otherwise.
+ +

Definition at line 62 of file cache.hpp.

+ +
+
+ +

◆ handle()

+ +
+
+
+template<typename Resource >
+ + + + + +
+ + + + + + + + +
ResourceHandle<Resource> entt::ResourceCache< Resource >::handle (resource_type id) const
+ 		+inline
+
+ +

Creates a handle for the 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
+
Parameters
+ + +
idUnique resource identifier.
+
+
+
Returns
A handle for the given resource.
+ +

Definition at line 145 of file cache.hpp.

+ +
+
+ +

◆ load()

+ +
+
+
+template<typename Resource >
+
+template<typename Loader , typename... Args>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool entt::ResourceCache< Resource >::load (resource_type id,
Args &&... args 
)
+ 		+inline
+
+ +

Loads the resource that corresponds to the 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.
+
Template Parameters
+ + + +
LoaderType of loader to use to load the resource if required.
ArgsTypes of arguments to use to load the resource if required.
+
+
+
Parameters
+ + + +
idUnique resource identifier.
argsArguments to use to load the resource if required.
+
+
+
Returns
True if the resource is ready to use, false otherwise.
+ +

Definition at line 95 of file cache.hpp.

+ +
+
+ +

◆ operator=() [1/2]

+ +
+
+
+template<typename Resource >
+ + + + + +
+ + + + + + + + +
ResourceCache& entt::ResourceCache< Resource >::operator= (const ResourceCache< Resource > & )
+ 		+deletenoexcept
+
+ +

Copying a cache isn't allowed.

+
Returns
This cache.
+ +
+
+ +

◆ operator=() [2/2]

+ +
+
+
+template<typename Resource >
+ + + + + +
+ + + + + + + + +
ResourceCache& entt::ResourceCache< Resource >::operator= (ResourceCache< Resource > && )
+ 		+defaultnoexcept
+
+ +

Default move assignment operator.

+
Returns
This cache.
+ +
+
+ +

◆ reload()

+ +
+
+
+template<typename Resource >
+
+template<typename Loader , typename... Args>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void entt::ResourceCache< Resource >::reload (resource_type id,
Args &&... args 
)
+ 		+inline
+
+ +

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.

+
Template Parameters
+ + + +
LoaderType of loader to use to load the resource.
ArgsTypes of arguments to use to load the resource.
+
+
+
Parameters
+ + + +
idUnique resource identifier.
argsArguments to use to load the resource.
+
+
+
Returns
True if the resource is ready to use, false otherwise.
+ +

Definition at line 128 of file cache.hpp.

+ +
+
+ +

◆ size()

+ +
+
+
+template<typename Resource >
+ + + + + +
+ + + + + + + +
size_type entt::ResourceCache< Resource >::size () const
+ 		+inlinenoexcept
+
+ +

Number of resources managed by a cache.

+
Returns
Number of resources currently stored.
+ +

Definition at line 54 of file cache.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1ResourceHandle-members.html b/classentt_1_1ResourceHandle-members.html new file mode 100644 index 000000000..cfb864186 --- /dev/null +++ b/classentt_1_1ResourceHandle-members.html @@ -0,0 +1,91 @@ + + + + + + + +entt: Member List + + + + + + + + + +
+
+ + + + + + +
+
entt +  2.2.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
entt::ResourceHandle< Resource > Member List
+
+
+ +

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

+ + + + + + + + + + + +
get() const noexceptentt::ResourceHandle< Resource >inline
operator bool() constentt::ResourceHandle< Resource >inlineexplicit
operator const Resource &() const noexceptentt::ResourceHandle< Resource >inline
operator*() const noexceptentt::ResourceHandle< Resource >inline
operator->() const noexceptentt::ResourceHandle< Resource >inline
operator=(const ResourceHandle &) noexcept=defaultentt::ResourceHandle< Resource >
operator=(ResourceHandle &&) noexcept=defaultentt::ResourceHandle< Resource >
ResourceCache< Resource > classentt::ResourceHandle< Resource >friend
ResourceHandle(const ResourceHandle &) noexcept=defaultentt::ResourceHandle< Resource >
ResourceHandle(ResourceHandle &&) noexcept=defaultentt::ResourceHandle< Resource >
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1ResourceHandle.html b/classentt_1_1ResourceHandle.html new file mode 100644 index 000000000..6391ac959 --- /dev/null +++ b/classentt_1_1ResourceHandle.html @@ -0,0 +1,344 @@ + + + + + + + +entt: entt::ResourceHandle< Resource > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
entt +  2.2.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+Public Member Functions | +Friends | +List of all members
+
+
entt::ResourceHandle< Resource > Class Template Referencefinal
+
+
+ +

Shared resource handle. + More...

+ +

#include <handle.hpp>

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+ ResourceHandle (const ResourceHandle &) noexcept=default
 Default copy constructor.
 
+ ResourceHandle (ResourceHandle &&) noexcept=default
 Default move constructor.
 
ResourceHandle & operator= (const ResourceHandle &) noexcept=default
 Default copy assignment operator. More...
 
ResourceHandle & operator= (ResourceHandle &&) noexcept=default
 Default move assignment operator. More...
 
const Resource & get () const noexcept
 Gets a reference to the managed resource. More...
 
 operator const Resource & () const noexcept
 Casts a handle and gets a reference to the managed resource. More...
 
const Resource & operator* () const noexcept
 Dereferences a handle to obtain the managed resource. More...
 
const Resource * operator-> () const 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.
 
+ + + + +

+Friends

+class ResourceCache< Resource >
 Resource handles are friends of their caches.
 
+

Detailed Description

+

template<typename Resource>
+class entt::ResourceHandle< 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.
+ As a rule of thumb, resources should never be copied nor moved. Handles are the way to go to keep references to them.

+
Template Parameters
+ + +
ResourceType of resource managed by a handle.
+
+
+ +

Definition at line 30 of file handle.hpp.

+

Member Function Documentation

+ +

◆ get()

+ +
+
+
+template<typename Resource >
+ + + + + +
+ + + + + + + +
const Resource& entt::ResourceHandle< Resource >::get () const
+ 		+inlinenoexcept
+
+ +

Gets a reference to the managed 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.
+
Returns
A reference to the managed resource.
+ +

Definition at line 59 of file handle.hpp.

+ +
+
+ +

◆ operator const Resource &()

+ +
+
+
+template<typename Resource >
+ + + + + +
+ + + + + + + +
entt::ResourceHandle< Resource >::operator const Resource & () const
+ 		+inlinenoexcept
+
+ +

Casts a handle and gets a reference to the managed 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 72 of file handle.hpp.

+ +
+
+ +

◆ operator*()

+ +
+
+
+template<typename Resource >
+ + + + + +
+ + + + + + + +
const Resource& entt::ResourceHandle< Resource >::operator* () const
+ 		+inlinenoexcept
+
+ +

Dereferences a handle to obtain the managed 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.
+
Returns
A reference to the managed resource.
+ +

Definition at line 84 of file handle.hpp.

+ +
+
+ +

◆ operator->()

+ +
+
+
+template<typename Resource >
+ + + + + +
+ + + + + + + +
const Resource* entt::ResourceHandle< Resource >::operator-> () const
+ 		+inlinenoexcept
+
+ +

Gets a pointer to the managed resource from a handle .

+
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.
+
Returns
A pointer to the managed resource or nullptr if the handle contains no resource at all.
+ +

Definition at line 97 of file handle.hpp.

+ +
+
+ +

◆ operator=() [1/2]

+ +
+
+
+template<typename Resource >
+ + + + + +
+ + + + + + + + +
ResourceHandle& entt::ResourceHandle< Resource >::operator= (const ResourceHandle< Resource > & )
+ 		+defaultnoexcept
+
+ +

Default copy assignment operator.

+
Returns
This handle.
+ +
+
+ +

◆ operator=() [2/2]

+ +
+
+
+template<typename Resource >
+ + + + + +
+ + + + + + + + +
ResourceHandle& entt::ResourceHandle< Resource >::operator= (ResourceHandle< Resource > && )
+ 		+defaultnoexcept
+
+ +

Default move assignment operator.

+
Returns
This handle.
+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1ResourceLoader-members.html b/classentt_1_1ResourceLoader-members.html new file mode 100644 index 000000000..68c3e8302 --- /dev/null +++ b/classentt_1_1ResourceLoader-members.html @@ -0,0 +1,82 @@ + + + + + + + +entt: Member List + + + + + + + + + +
+
+ + + + + + +
+
entt +  2.2.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
entt::ResourceLoader< Loader, Resource > Member List
+
+
+ +

This is the complete list of members for entt::ResourceLoader< Loader, Resource >, including all inherited members.

+ + +
ResourceCache< Resource > classentt::ResourceLoader< Loader, Resource >friend
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1ResourceLoader.html b/classentt_1_1ResourceLoader.html new file mode 100644 index 000000000..bab0938f1 --- /dev/null +++ b/classentt_1_1ResourceLoader.html @@ -0,0 +1,115 @@ + + + + + + + +entt: entt::ResourceLoader< Loader, Resource > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
entt +  2.2.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+Friends | +List of all members
+
+
entt::ResourceLoader< Loader, Resource > Class Template Reference
+
+
+ +

Base class for resource loaders. + More...

+ +

#include <loader.hpp>

+ + + + + +

+Friends

+class ResourceCache< Resource >
 Resource loaders are friends of their caches.
 
+

Detailed Description

+

template<typename Loader, typename Resource>
+class entt::ResourceLoader< 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 return 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.

+
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
+ + + +
LoaderType of the derived class.
ResourceType of resource for which to use the loader.
+
+
+ +

Definition at line 48 of file loader.hpp.

+
The documentation for this class was generated from the following file: +
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1Scheduler-members.html b/classentt_1_1Scheduler-members.html new file mode 100644 index 000000000..d174f8263 --- /dev/null +++ b/classentt_1_1Scheduler-members.html @@ -0,0 +1,94 @@ + + + + + + + +entt: Member List + + + + + + + + + +
+
+ + + + + + +
+
entt +  2.2.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
entt::Scheduler< Delta > Member List
+
+
+ +

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

+ + + + + + + + + + + + + + +
abort(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 noexceptentt::Scheduler< Delta >inline
operator=(const Scheduler &)=deleteentt::Scheduler< Delta >
operator=(Scheduler &&)=defaultentt::Scheduler< Delta >
Scheduler() noexcept=defaultentt::Scheduler< Delta >
Scheduler(const Scheduler &)=deleteentt::Scheduler< Delta >
Scheduler(Scheduler &&)=defaultentt::Scheduler< Delta >
size() const noexceptentt::Scheduler< Delta >inline
size_type typedefentt::Scheduler< Delta >
update(Delta delta)entt::Scheduler< Delta >inline
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1Scheduler.html b/classentt_1_1Scheduler.html new file mode 100644 index 000000000..58f7e9096 --- /dev/null +++ b/classentt_1_1Scheduler.html @@ -0,0 +1,510 @@ + + + + + + + +entt: entt::Scheduler< Delta > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
entt +  2.2.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+Classes | +Public Types | +Public Member Functions | +List of all members
+
+
entt::Scheduler< Delta > Class Template Referencefinal
+
+
+ +

Cooperative scheduler for processes. + More...

+ +

#include <scheduler.hpp>

+ + + + + +

+Public Types

+using size_type = typename std::vector< ProcessHandler >::size_type
 Unsigned integer type.
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+ Scheduler () 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 assignament operator. More...
 
size_type size () const noexcept
 Number of processes currently scheduled. More...
 
bool empty () const 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 (Delta delta)
 Updates all scheduled processes. More...
 
void abort (bool immediately=false)
 Aborts all scheduled processes. More...
 
+

Detailed Description

+

template<typename 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, 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
+
Template Parameters
+ + +
DeltaType to use to provide elapsed time.
+
+
+ +

Definition at line 44 of file scheduler.hpp.

+

Member Function Documentation

+ +

◆ abort()

+ +
+
+
+template<typename Delta >
+ + + + + +
+ + + + + + + + +
void entt::Scheduler< Delta >::abort (bool immediately = false)
+ 		+inline
+
+ +

Aborts all scheduled processes.

+

Unless an immediate operation is requested, the abort is scheduled for the next tick. Processes won't be executed anymore in any case.
+ Once a process is fully aborted and thus finished, it's discarded along with its child, if any.

+
Parameters
+ + +
immediatelyRequests an immediate operation.
+
+
+ +

Definition at line 299 of file scheduler.hpp.

+ +
+
+ +

◆ attach() [1/2]

+ +
+
+
+template<typename Delta >
+
+template<typename Proc , typename... Args>
+ + + + + +
+ + + + + + + + +
auto entt::Scheduler< Delta >::attach (Args &&... args)
+ 		+inline
+
+ +

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, auto succeed, auto fail) {
// code
})
// appends a child in the form of another process class
.then<MyOtherProcess>();
Template Parameters
+ + + +
ProcType of process to schedule.
ArgsTypes of arguments to use to initialize the process.
+
+
+
Parameters
+ + +
argsParameters to use to initialize the process.
+
+
+
Returns
An opaque object to use to concatenate processes.
+ +

Definition at line 197 of file scheduler.hpp.

+ +
+
+ +

◆ attach() [2/2]

+ +
+
+
+template<typename Delta >
+
+template<typename Func >
+ + + + + +
+ + + + + + + + +
auto entt::Scheduler< Delta >::attach (Func && func)
+ 		+inline
+
+ +

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:

+
    +
  • delta is the elapsed time.
    • +
  • 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, auto succeed, auto fail) {
// code
})
// appends a child in the form of another lambda function
.then([](auto delta, auto succeed, auto fail) {
// code
})
// appends a child in the form of a process class
.then<MyProcess>(arguments...);
See also
ProcessAdaptor
+
Template Parameters
+ + +
FuncType of process to schedule.
+
+
+
Parameters
+ + +
funcEither a lambda or a functor to use as a process.
+
+
+
Returns
An opaque object to use to concatenate processes.
+ +

Definition at line 258 of file scheduler.hpp.

+ +
+
+ +

◆ clear()

+ +
+
+
+template<typename Delta >
+ + + + + +
+ + + + + + + +
void entt::Scheduler< Delta >::clear ()
+ 		+inline
+
+ +

Discards all scheduled processes.

+

Processes aren't aborted. They are discarded along with their children and never executed again.

+ +

Definition at line 167 of file scheduler.hpp.

+ +
+
+ +

◆ empty()

+ +
+
+
+template<typename Delta >
+ + + + + +
+ + + + + + + +
bool entt::Scheduler< Delta >::empty () const
+ 		+inlinenoexcept
+
+ +

Returns true if at least a process is currently scheduled.

+
Returns
True if there are scheduled processes, false otherwise.
+ +

Definition at line 157 of file scheduler.hpp.

+ +
+
+ +

◆ operator=() [1/2]

+ +
+
+
+template<typename Delta >
+ + + + + +
+ + + + + + + + +
Scheduler& entt::Scheduler< Delta >::operator= (const Scheduler< Delta > & )
+ 		+delete
+
+ +

Copying a scheduler isn't allowed.

+
Returns
This scheduler.
+ +
+
+ +

◆ operator=() [2/2]

+ +
+
+
+template<typename Delta >
+ + + + + +
+ + + + + + + + +
Scheduler& entt::Scheduler< Delta >::operator= (Scheduler< Delta > && )
+ 		+default
+
+ +

Default move assignament operator.

+
Returns
This scheduler.
+ +
+
+ +

◆ size()

+ +
+
+
+template<typename Delta >
+ + + + + +
+ + + + + + + +
size_type entt::Scheduler< Delta >::size () const
+ 		+inlinenoexcept
+
+ +

Number of processes currently scheduled.

+
Returns
Number of processes currently scheduled.
+ +

Definition at line 149 of file scheduler.hpp.

+ +
+
+ +

◆ update()

+ +
+
+
+template<typename Delta >
+ + + + + +
+ + + + + + + + +
void entt::Scheduler< Delta >::update (Delta delta)
+ 		+inline
+
+ +

Updates all scheduled processes.

+

All scheduled processes are executed in no specific order.
+ If a process terminates with success, it's replaced with its child, if any. Otherwise, if a process terminates with an error, it's removed along with its child.

+
Parameters
+ + +
deltaElapsed time.
+
+
+ +

Definition at line 273 of file scheduler.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1SigH.html b/classentt_1_1SigH.html index 1ab50619d..05bddf28f 100644 --- a/classentt_1_1SigH.html +++ b/classentt_1_1SigH.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0
entt -  2.1.0 +  2.2.0
disconnect(instance_type< Class > instance)entt::SigH< Ret(Args...), Collector >inline
empty() const noexceptentt::SigH< Ret(Args...), Collector >inline
instance_type typedefentt::SigH< Ret(Args...), Collector >
operator=(const SigH &other)entt::SigH< Ret(Args...), Collector >inline
operator=(SigH &&other)entt::SigH< Ret(Args...), Collector >inline
operator==(const SigH &other) const noexceptentt::SigH< Ret(Args...), Collector >inline
publish(Args... args)entt::SigH< Ret(Args...), Collector >inline
SigH() noexcept=defaultentt::SigH< Ret(Args...), Collector >explicit
SigH(const SigH &other)entt::SigH< Ret(Args...), Collector >inline
SigH(SigH &&other)entt::SigH< Ret(Args...), Collector >inline
size() const noexceptentt::SigH< Ret(Args...), Collector >inline
size_type typedefentt::SigH< Ret(Args...), Collector >
swap(SigH &lhs, SigH &rhs)entt::SigH< Ret(Args...), Collector >friend
~SigH() noexcept=defaultentt::SigH< Ret(Args...), Collector >
size() const noexceptentt::SigH< Ret(Args...), Collector >inline
size_type typedefentt::SigH< Ret(Args...), Collector >
swap(SigH &lhs, SigH &rhs)entt::SigH< Ret(Args...), Collector >friend
diff --git a/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html b/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html index f5ea7174f..cfe005c30 100644 --- a/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html +++ b/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0

Public Member Functions

- SigH () noexcept=default
 Default constructor, explicit on purpose.
 
- ~SigH () noexcept=default
 Default destructor.
 
 SigH (const SigH &other)
 Copy constructor, listeners are also connected to this signal. More...
 
 SigH (SigH &&other)
 Default move constructor. More...
 
SigH & operator= (const SigH &other)
 Copy assignment operator. More...
 
SigH & operator= (SigH &&other)
 Move assignment operator. More...
 
size_type size () const noexcept
 Number of listeners connected to the signal. More...
 
bool empty () const noexcept
 Returns false is at least a listener is connected to the signal. More...
 Returns false if at least a listener is connected to the signal. More...
 
void clear () noexcept
- - - - -
- - - - - - - - -
entt::SigH< Ret(Args...), Collector >::SigH (const SigH< Ret(Args...), Collector > & other)
- 		-inline
-
- -

Copy constructor, listeners are also connected to this signal.

-
Parameters
- - -
otherA signal to use as source to initialize this instance.
-
-
- -

Definition at line 144 of file sigh.hpp.

- -
- - -

◆ SigH() [2/2]

- -
-
-
-template<typename Ret , typename... Args, typename Collector >
- - - - - -
- - - - - - - - -
entt::SigH< Ret(Args...), Collector >::SigH (SigH< Ret(Args...), Collector > && other)
- 		-inline
-
- -

Default move constructor.

-
Parameters
- - -
otherA signal to use as source to initialize this instance.
-
-
- -

Definition at line 152 of file sigh.hpp.

+

Definition at line 134 of file sigh.hpp.

@@ -341,7 +246,7 @@ template<typename Ret , typename... Args, typename Collector >
Returns
An instance of the collector filled with collected data.
-

Definition at line 285 of file sigh.hpp.

+

Definition at line 242 of file sigh.hpp.

@@ -381,7 +286,7 @@ template<Ret(*)(Args...) Function> -

Definition at line 211 of file sigh.hpp.

+

Definition at line 168 of file sigh.hpp.

@@ -429,7 +334,7 @@ template<typename Class , Ret(Class::*)(Args...) Member> -

Definition at line 229 of file sigh.hpp.

+

Definition at line 186 of file sigh.hpp.

@@ -468,7 +373,7 @@ template<Ret(*)(Args...) Function> -

Definition at line 239 of file sigh.hpp.

+

Definition at line 196 of file sigh.hpp.

@@ -515,7 +420,7 @@ template<typename Class , Ret(Class::*)(Args...) Member> -

Definition at line 251 of file sigh.hpp.

+

Definition at line 208 of file sigh.hpp.

@@ -561,7 +466,7 @@ template<typename Class > -

Definition at line 262 of file sigh.hpp.

+

Definition at line 219 of file sigh.hpp.

@@ -590,89 +495,10 @@ template<typename Ret , typename... Args, typename Collector >
-

Returns false is at least a listener is connected to the signal.

+

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 191 of file sigh.hpp.

- -
- - -

◆ operator=() [1/2]

- -
-
-
-template<typename Ret , typename... Args, typename Collector >
- - - - - -
- - - - - - - - -
SigH& entt::SigH< Ret(Args...), Collector >::operator= (const SigH< Ret(Args...), Collector > & other)
- 		-inline
-
- -

Copy assignment operator.

-

Listeners are also connected to this signal.

-
Parameters
- - -
otherA signal to use as source to initialize this instance.
-
-
-
Returns
This signal.
- -

Definition at line 164 of file sigh.hpp.

- -
-
- -

◆ operator=() [2/2]

- -
-
-
-template<typename Ret , typename... Args, typename Collector >
- - - - - -
- - - - - - - - -
SigH& entt::SigH< Ret(Args...), Collector >::operator= (SigH< Ret(Args...), Collector > && other)
- 		-inline
-
- -

Move assignment operator.

-
Parameters
- - -
otherA signal to use as source to initialize this instance.
-
-
-
Returns
This signal.
- -

Definition at line 174 of file sigh.hpp.

+

Definition at line 148 of file sigh.hpp.

@@ -712,7 +538,7 @@ template<typename Ret , typename... Args, typename Collector >
Returns
True if the two signals are identical, false otherwise.
-

Definition at line 316 of file sigh.hpp.

+

Definition at line 273 of file sigh.hpp.

@@ -751,7 +577,7 @@ template<typename Ret , typename... Args, typename Collector > -

Definition at line 274 of file sigh.hpp.

+

Definition at line 231 of file sigh.hpp.

@@ -783,7 +609,7 @@ template<typename Ret , typename... Args, typename Collector >

Number of listeners connected to the signal.

Returns
Number of listeners currently connected.
-

Definition at line 183 of file sigh.hpp.

+

Definition at line 140 of file sigh.hpp.

@@ -833,7 +659,7 @@ template<typename Ret , typename... Args, typename Collector > -

Definition at line 302 of file sigh.hpp.

+

Definition at line 259 of file sigh.hpp.

diff --git a/classentt_1_1Signal.html b/classentt_1_1Signal.html index d2b87ea11..38b79e683 100644 --- a/classentt_1_1Signal.html +++ b/classentt_1_1Signal.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0
entt -  2.1.0 +  2.2.0
disconnect(instance_type< Class > instance)entt::Signal< void(Args...)>inline
empty() const noexceptentt::Signal< void(Args...)>inline
instance_type typedefentt::Signal< void(Args...)>
operator=(const Signal &other)entt::Signal< void(Args...)>inline
operator=(Signal &&other)entt::Signal< void(Args...)>inline
operator==(const Signal &other) const noexceptentt::Signal< void(Args...)>inline
publish(Args... args)entt::Signal< void(Args...)>inline
Signal() noexcept=defaultentt::Signal< void(Args...)>explicit
Signal(const Signal &other)entt::Signal< void(Args...)>inline
Signal(Signal &&other)entt::Signal< void(Args...)>inline
size() const noexceptentt::Signal< void(Args...)>inline
size_type typedefentt::Signal< void(Args...)>
swap(Signal &lhs, Signal &rhs)entt::Signal< void(Args...)>friend
~Signal() noexcept=defaultentt::Signal< void(Args...)>
size() const noexceptentt::Signal< void(Args...)>inline
size_type typedefentt::Signal< void(Args...)>
swap(Signal &lhs, Signal &rhs)entt::Signal< void(Args...)>friend
diff --git a/classentt_1_1Signal_3_01void_07Args_8_8_8_08_4.html b/classentt_1_1Signal_3_01void_07Args_8_8_8_08_4.html index cc5137a3c..01a105cbe 100644 --- a/classentt_1_1Signal_3_01void_07Args_8_8_8_08_4.html +++ b/classentt_1_1Signal_3_01void_07Args_8_8_8_08_4.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0

Public Member Functions

- Signal () noexcept=default
 Default constructor, explicit on purpose.
 
- ~Signal () noexcept=default
 Default destructor.
 
 Signal (const Signal &other)
 Copy constructor, listeners are also connected to this signal. More...
 
 Signal (Signal &&other)
 Default move constructor. More...
 
Signal & operator= (const Signal &other)
 Copy assignment operator. More...
 
Signal & operator= (Signal &&other)
 Move assignment operator. More...
 
size_type size () const noexcept
 Number of listeners connected to the signal. More...
 
bool empty () const noexcept
 Returns false is at least a listener is connected to the signal. More...
 Returns false if at least a listener is connected to the signal. More...
 
void clear () noexcept
- - - - -
- - - - - - - - -
entt::Signal< void(Args...)>::Signal (const Signal< void(Args...)> & other)
- 		-inline
-
- -

Copy constructor, listeners are also connected to this signal.

-
Parameters
- - -
otherA signal to use as source to initialize this instance.
-
-
- -

Definition at line 83 of file signal.hpp.

- -
- - -

◆ Signal() [2/2]

- -
-
-
-template<typename... Args>
- - - - - -
- - - - - - - - -
entt::Signal< void(Args...)>::Signal (Signal< void(Args...)> && other)
- 		-inline
-
- -

Default move constructor.

-
Parameters
- - -
otherA signal to use as source to initialize this instance.
-
-
- -

Definition at line 91 of file signal.hpp.

-

Member Function Documentation

@@ -312,7 +215,7 @@ template<void(*)(Args...) Function> -

Definition at line 150 of file signal.hpp.

+

Definition at line 105 of file signal.hpp.

@@ -360,7 +263,7 @@ template<typename Class , void(Class::*)(Args...) Member> -

Definition at line 166 of file signal.hpp.

+

Definition at line 121 of file signal.hpp.

@@ -399,7 +302,7 @@ template<void(*)(Args...) Function> -

Definition at line 176 of file signal.hpp.

+

Definition at line 131 of file signal.hpp.

@@ -446,7 +349,7 @@ template<typename Class , void(Class::*)(Args...) Member> -

Definition at line 189 of file signal.hpp.

+

Definition at line 144 of file signal.hpp.

@@ -492,7 +395,7 @@ template<typename Class > -

Definition at line 201 of file signal.hpp.

+

Definition at line 156 of file signal.hpp.

@@ -521,89 +424,10 @@ template<typename... Args>
-

Returns false is at least a listener is connected to the signal.

+

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 130 of file signal.hpp.

- -
- - -

◆ operator=() [1/2]

- -
-
-
-template<typename... Args>
- - - - - -
- - - - - - - - -
Signal& entt::Signal< void(Args...)>::operator= (const Signal< void(Args...)> & other)
- 		-inline
-
- -

Copy assignment operator.

-

Listeners are also connected to this signal.

-
Parameters
- - -
otherA signal to use as source to initialize this instance.
-
-
-
Returns
This signal.
- -

Definition at line 103 of file signal.hpp.

- -
-
- -

◆ operator=() [2/2]

- -
-
-
-template<typename... Args>
- - - - - -
- - - - - - - - -
Signal& entt::Signal< void(Args...)>::operator= (Signal< void(Args...)> && other)
- 		-inline
-
- -

Move assignment operator.

-
Parameters
- - -
otherA signal to use as source to initialize this instance.
-
-
-
Returns
This signal.
- -

Definition at line 113 of file signal.hpp.

+

Definition at line 85 of file signal.hpp.

@@ -643,7 +467,7 @@ template<typename... Args>
Returns
True if the two signals are identical, false otherwise.
-

Definition at line 241 of file signal.hpp.

+

Definition at line 196 of file signal.hpp.

@@ -682,7 +506,7 @@ template<typename... Args> -

Definition at line 214 of file signal.hpp.

+

Definition at line 169 of file signal.hpp.

@@ -714,7 +538,7 @@ template<typename... Args>

Number of listeners connected to the signal.

Returns
Number of listeners currently connected.
-

Definition at line 122 of file signal.hpp.

+

Definition at line 77 of file signal.hpp.

@@ -764,7 +588,7 @@ template<typename... Args> -

Definition at line 227 of file signal.hpp.

+

Definition at line 182 of file signal.hpp.

diff --git a/classentt_1_1SparseSet.html b/classentt_1_1SparseSet.html index 9d61d9b35..b03f695c2 100644 --- a/classentt_1_1SparseSet.html +++ b/classentt_1_1SparseSet.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0
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 index 08ec08edf..c6318d75b 100644 --- a/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4-members.html +++ b/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4-members.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0
@@ -71,32 +71,32 @@ $(function() {

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

- - + + - - + + - - - - - - - - - - - - - - - + + + + + + + + + + + + + + +
begin() const noexceptentt::SparseSet< Entity >inline
construct(entity_type entity, Args &&... args)entt::SparseSet< Entity, Type >inline
entt::SparseSet< Entity >::construct(entity_type entity)entt::SparseSet< Entity >inline
construct(entity_type entity, Args &&... args)entt::SparseSet< Entity, Type >inline
entt::SparseSet< Entity >::construct(entity_type entity)entt::SparseSet< Entity >inline
data() const noexceptentt::SparseSet< Entity >inline
destroy(entity_type entity) overrideentt::SparseSet< Entity, Type >inlinevirtual
empty() const noexceptentt::SparseSet< Entity >inline
end() const noexceptentt::SparseSet< Entity >inline
entity_type typedefentt::SparseSet< Entity, Type >
get(entity_type entity) const noexceptentt::SparseSet< Entity, Type >inline
get(entity_type entity) noexceptentt::SparseSet< Entity, Type >inline
get(entity_type entity) const noexceptentt::SparseSet< Entity, Type >inline
get(entity_type entity) noexceptentt::SparseSet< Entity, Type >inline
has(entity_type entity) const noexceptentt::SparseSet< Entity >inline
iterator_type typedefentt::SparseSet< Entity, Type >
operator=(const SparseSet &)=deleteentt::SparseSet< Entity, Type >
operator=(SparseSet &&)=defaultentt::SparseSet< Entity, Type >
pos_type typedefentt::SparseSet< Entity, Type >
raw() const noexceptentt::SparseSet< Entity, Type >inline
raw() noexceptentt::SparseSet< Entity, Type >inline
reset() overrideentt::SparseSet< Entity, Type >inlinevirtual
respect(const SparseSet< Entity > &other)entt::SparseSet< Entity >inline
size() const noexceptentt::SparseSet< Entity >inline
size_type typedefentt::SparseSet< Entity, Type >
sort(Compare compare)entt::SparseSet< Entity >inline
SparseSet() noexcept=defaultentt::SparseSet< Entity, Type >explicit
SparseSet(const SparseSet &)=deleteentt::SparseSet< Entity, Type >
SparseSet(SparseSet &&)=defaultentt::SparseSet< Entity, Type >
swap(entity_type lhs, entity_type rhs) overrideentt::SparseSet< Entity, Type >inlinevirtual
type typedefentt::SparseSet< Entity, Type >
object_type typedefentt::SparseSet< Entity, Type >
operator=(const SparseSet &)=deleteentt::SparseSet< Entity, Type >
operator=(SparseSet &&)=defaultentt::SparseSet< Entity, Type >
pos_type typedefentt::SparseSet< Entity, Type >
raw() const noexceptentt::SparseSet< Entity, Type >inline
raw() noexceptentt::SparseSet< Entity, Type >inline
reset() overrideentt::SparseSet< Entity, Type >inlinevirtual
respect(const SparseSet< Entity > &other)entt::SparseSet< Entity >inline
size() const noexceptentt::SparseSet< Entity >inline
size_type typedefentt::SparseSet< Entity, Type >
sort(Compare compare)entt::SparseSet< Entity >inline
SparseSet() noexcept=defaultentt::SparseSet< Entity, Type >
SparseSet(const SparseSet &)=deleteentt::SparseSet< Entity, Type >
SparseSet(SparseSet &&)=defaultentt::SparseSet< Entity, Type >
swap(entity_type lhs, entity_type rhs) overrideentt::SparseSet< Entity, Type >inlinevirtual
~SparseSet() noexcept=defaultentt::SparseSet< Entity >virtual
diff --git a/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html b/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html index 4a0cb8978..76529e6a6 100644 --- a/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html +++ b/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0
@@ -95,10 +95,10 @@ Collaboration diagram for entt::SparseSet< Entity, Type >: - - - + + + @@ -137,7 +137,7 @@ using  - + @@ -153,37 +153,41 @@ Public Member Functions - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + - + - + - + - + + + + @@ -192,10 +196,6 @@ void  - - - @@ -203,10 +203,10 @@ virtual  - + - + @@ -218,20 +218,20 @@ virtual  - + - + - - - + + + - +

Public Types

-using type = Type
 Type of the objects associated to the entities.
 
+using object_type = Type
 Type of the objects associated to the entities.
 
using entity_type = typename underlying_type::entity_type
 Underlying entity identifier.
 SparseSet () noexcept=default
 Default constructor, explicit on purpose.
 Default constructor.
 
 SparseSet (const SparseSet &)=delete
SparseSet & operator= (SparseSet &&)=default
 Default move assignment operator. More...
 
const type * raw () const noexcept
 Direct access to the array of objects. More...
 
type * raw () noexcept
 Direct access to the array of objects. More...
 
const type & get (entity_type entity) const noexcept
 Returns the object associated to the given entity. More...
 
type & get (entity_type entity) noexcept
 Returns the object associated to the given entity. More...
 
template<typename... Args>
type & construct (entity_type entity, Args &&... args)
 Assigns an entity to the sparse set and constructs its object. More...
 
const object_type * raw () const noexcept
 Direct access to the array of objects. More...
 
object_type * raw () noexcept
 Direct access to the array of objects. More...
 
const object_type & get (entity_type entity) const noexcept
 Returns the object associated to an entity. More...
 
object_type & get (entity_type entity) noexcept
 Returns the object associated to an entity. More...
 
template<typename... Args>
object_type & construct (entity_type entity, Args &&... args)
 Assigns an entity to a sparse set and constructs its object. More...
 
void destroy (entity_type entity) override
 Removes an entity from the sparse set and destroies its object. More...
 Removes an entity from a sparse set and destroies its object. More...
 
void swap (entity_type lhs, entity_type rhs) override
 Swaps the two entities and their objects. More...
 Swaps two entities and their objects. More...
 
void reset () override
 Resets the sparse set.
 Resets a sparse set.
 
- Public Member Functions inherited from entt::SparseSet< Entity >
 SparseSet () noexcept=default
 Default constructor, explicit on purpose.
 Default constructor.
 
+virtual ~SparseSet () noexcept=default
 Default destructor.
 
 SparseSet (const SparseSet &)=delete
 Copying a sparse set isn't allowed.
SparseSet (SparseSet &&)=default
 Default move constructor.
 
-virtual ~SparseSet () noexcept=default
 Default destructor.
 
SparseSet & operator= (const SparseSet &)=delete
 Copying a sparse set isn't allowed. More...
 
 Default move assignment operator. More...
 
size_type size () const noexcept
 Returns the number of elements in the sparse set. More...
 Returns the number of elements in a sparse set. More...
 
bool empty () const noexcept
 Checks whether the sparse set is empty. More...
 Checks whether a sparse set is empty. More...
 
const entity_type * data () const noexcept
 Direct access to the internal packed array. More...
 Returns an iterator to the end. More...
 
bool has (entity_type entity) const noexcept
 Checks if the sparse set contains the given entity. More...
 Checks if a sparse set contains an entity. More...
 
pos_type get (entity_type entity) const noexcept
 Returns the position of the entity in the sparse set. More...
 Returns the position of an entity in a sparse set. More...
 
pos_type construct (entity_type entity)
 Assigns an entity to the sparse set. More...
 
void construct (entity_type entity)
 Assigns an entity to a sparse set. More...
 
template<typename Compare >
void sort (Compare compare)
 Sort entities according to the given comparison function. More...
 
void respect (const SparseSet< Entity > &other)
 Sort entities according to their order in the given sparse set. More...
 Sort entities according to their order in a sparse set. More...
 

Detailed Description

@@ -252,10 +252,10 @@ Internal data structures arrange elements to maximize performance. Because of th -

Definition at line 402 of file sparse_set.hpp.

+

Definition at line 410 of file sparse_set.hpp.

Member Function Documentation

- -

◆ construct()

+ +

◆ construct()

@@ -268,7 +268,7 @@ template<typename... Args>
- + @@ -292,7 +292,7 @@ template<typename... Args>
type& entt::SparseSet< Entity, Type >::construct object_type& entt::SparseSet< Entity, Type >::construct ( entity_type  entity,
-

Assigns an entity to the sparse set and constructs its object.

+

Assigns an entity to a sparse set and constructs its object.

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
@@ -310,7 +310,7 @@ template<typename... Args>
Returns
The object associated to the entity.
-

Definition at line 515 of file sparse_set.hpp.

+

Definition at line 523 of file sparse_set.hpp.

@@ -340,7 +340,7 @@ template<typename Entity , typename Type >
-

Removes an entity from the sparse set and destroies its object.

+

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
@@ -352,12 +352,12 @@ template<typename Entity , typename Type >

Reimplemented from entt::SparseSet< Entity >.

-

Definition at line 532 of file sparse_set.hpp.

+

Definition at line 541 of file sparse_set.hpp.

- -

◆ get() [1/2]

+ +

◆ get() [1/2]

@@ -368,7 +368,7 @@ template<typename Entity , typename Type >
- + @@ -382,7 +382,7 @@ template<typename Entity , typename Type >
const type& entt::SparseSet< Entity, Type >::get const object_type& entt::SparseSet< Entity, Type >::get ( entity_type  entity)
-

Returns the object associated to the given entity.

+

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
@@ -393,12 +393,12 @@ template<typename Entity , typename Type >
Returns
The object associated to the entity.
-

Definition at line 480 of file sparse_set.hpp.

+

Definition at line 488 of file sparse_set.hpp.

- -

◆ get() [2/2]

+ +

◆ get() [2/2]

@@ -409,7 +409,7 @@ template<typename Entity , typename Type >
- + @@ -423,7 +423,7 @@ template<typename Entity , typename Type >
type& entt::SparseSet< Entity, Type >::get object_type& entt::SparseSet< Entity, Type >::get ( entity_type  entity)
-

Returns the object associated to the given entity.

+

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
@@ -434,7 +434,7 @@ template<typename Entity , typename Type >
Returns
The object associated to the entity.
-

Definition at line 496 of file sparse_set.hpp.

+

Definition at line 504 of file sparse_set.hpp.

@@ -500,8 +500,8 @@ template<typename Entity , typename Type > - -

◆ raw() [1/2]

+ +

◆ raw() [1/2]

@@ -512,7 +512,7 @@ template<typename Entity , typename Type >
- + @@ -526,16 +526,16 @@ template<typename Entity , typename Type >

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.

+

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 sort 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 445 of file sparse_set.hpp.

+

Definition at line 453 of file sparse_set.hpp.

- -

◆ raw() [2/2]

+ +

◆ raw() [2/2]

@@ -546,7 +546,7 @@ template<typename Entity , typename Type >
@@ -71,7 +71,7 @@ $(function() {

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

const type* entt::SparseSet< Entity, Type >::raw const object_type* entt::SparseSet< Entity, Type >::raw ( ) const - + @@ -560,11 +560,11 @@ template<typename Entity , typename Type >

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.

+

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 sort 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 464 of file sparse_set.hpp.

+

Definition at line 472 of file sparse_set.hpp.

@@ -604,7 +604,7 @@ template<typename Entity , typename Type >
type* entt::SparseSet< Entity, Type >::raw object_type* entt::SparseSet< Entity, Type >::raw ( )
-

Swaps the two entities and their objects.

+

Swaps two entities and their objects.

Note
This function doesn't swap objects between entities. It exchanges entity and object positions in the sparse set. It's used mainly for sorting.
Warning
Attempting to use 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.
@@ -618,7 +618,7 @@ template<typename Entity , typename Type >

Reimplemented from entt::SparseSet< Entity >.

-

Definition at line 554 of file sparse_set.hpp.

+

Definition at line 564 of file sparse_set.hpp.

diff --git a/classentt_1_1SparseSet_3_01Entity_01_4-members.html b/classentt_1_1SparseSet_3_01Entity_01_4-members.html index 59a5b4d2d..5a0f646d6 100644 --- a/classentt_1_1SparseSet_3_01Entity_01_4-members.html +++ b/classentt_1_1SparseSet_3_01Entity_01_4-members.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0
- + @@ -88,7 +88,7 @@ $(function() { - + diff --git a/classentt_1_1SparseSet_3_01Entity_01_4.html b/classentt_1_1SparseSet_3_01Entity_01_4.html index fc048e22e..e7090708b 100644 --- a/classentt_1_1SparseSet_3_01Entity_01_4.html +++ b/classentt_1_1SparseSet_3_01Entity_01_4.html @@ -22,7 +22,7 @@ @@ -109,8 +109,12 @@ using  - + + + + @@ -119,10 +123,6 @@ Public Member Functions   - - - @@ -130,10 +130,10 @@ virtual  - + - + @@ -145,30 +145,30 @@ virtual  - + - + - - - + + + - + - + - + - +
begin() const noexceptentt::SparseSet< Entity >inline
construct(entity_type entity)entt::SparseSet< Entity >inline
construct(entity_type entity)entt::SparseSet< Entity >inline
data() const noexceptentt::SparseSet< Entity >inline
destroy(entity_type entity)entt::SparseSet< Entity >inlinevirtual
empty() const noexceptentt::SparseSet< Entity >inline
size() const noexceptentt::SparseSet< Entity >inline
size_type typedefentt::SparseSet< Entity >
sort(Compare compare)entt::SparseSet< Entity >inline
SparseSet() noexcept=defaultentt::SparseSet< Entity >explicit
SparseSet() noexcept=defaultentt::SparseSet< Entity >
SparseSet(const SparseSet &)=deleteentt::SparseSet< Entity >
SparseSet(SparseSet &&)=defaultentt::SparseSet< Entity >
swap(entity_type lhs, entity_type rhs)entt::SparseSet< Entity >inlinevirtual
entt -  2.1.0 +  2.2.0
 SparseSet () noexcept=default
 Default constructor, explicit on purpose.
 Default constructor.
 
+virtual ~SparseSet () noexcept=default
 Default destructor.
 
 SparseSet (const SparseSet &)=delete
 Copying a sparse set isn't allowed.
SparseSet (SparseSet &&)=default
 Default move constructor.
 
-virtual ~SparseSet () noexcept=default
 Default destructor.
 
SparseSet & operator= (const SparseSet &)=delete
 Copying a sparse set isn't allowed. More...
 
 Default move assignment operator. More...
 
size_type size () const noexcept
 Returns the number of elements in the sparse set. More...
 Returns the number of elements in a sparse set. More...
 
bool empty () const noexcept
 Checks whether the sparse set is empty. More...
 Checks whether a sparse set is empty. More...
 
const entity_type * data () const noexcept
 Direct access to the internal packed array. More...
 Returns an iterator to the end. More...
 
bool has (entity_type entity) const noexcept
 Checks if the sparse set contains the given entity. More...
 Checks if a sparse set contains an entity. More...
 
pos_type get (entity_type entity) const noexcept
 Returns the position of the entity in the sparse set. More...
 Returns the position of an entity in a sparse set. More...
 
pos_type construct (entity_type entity)
 Assigns an entity to the sparse set. More...
 
void construct (entity_type entity)
 Assigns an entity to a sparse set. More...
 
virtual void destroy (entity_type entity)
 Removes the given entity from the sparse set. More...
 Removes an entity from a sparse set. More...
 
virtual void swap (entity_type lhs, entity_type rhs)
 Swaps the position of the entities in the internal packed array. More...
 Swaps the position of two entities in the internal packed array. More...
 
template<typename Compare >
void sort (Compare compare)
 Sort entities according to the given comparison function. More...
 
void respect (const SparseSet< Entity > &other)
 Sort entities according to their order in the given sparse set. More...
 Sort entities according to their order in a sparse set. More...
 
virtual void reset ()
 Resets the sparse set.
 Resets a sparse set.
 

Detailed Description

@@ -222,12 +222,12 @@ template<typename Entity >
Note
Input iterators stay true to the order imposed by a call to sort.
Returns
An iterator to the first element of the internal packed array.
-

Definition at line 169 of file sparse_set.hpp.

+

Definition at line 171 of file sparse_set.hpp.

- -

◆ construct()

+ +

◆ construct()

@@ -238,7 +238,7 @@ template<typename Entity >
- + @@ -252,7 +252,7 @@ template<typename Entity >
pos_type entt::SparseSet< Entity >::construct void entt::SparseSet< Entity >::construct ( entity_type  entity)
-

Assigns an entity to the sparse set.

+

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
@@ -261,9 +261,8 @@ template<typename Entity >
-
Returns
The position of the entity in the internal packed array.
-

Definition at line 229 of file sparse_set.hpp.

+

Definition at line 233 of file sparse_set.hpp.

@@ -293,11 +292,11 @@ template<typename Entity >

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.

+

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 sort 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 153 of file sparse_set.hpp.

+

Definition at line 155 of file sparse_set.hpp.

@@ -327,7 +326,7 @@ template<typename Entity >
-

Removes the given entity from the sparse set.

+

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
@@ -339,7 +338,7 @@ template<typename Entity >

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

-

Definition at line 255 of file sparse_set.hpp.

+

Definition at line 258 of file sparse_set.hpp.

@@ -368,10 +367,10 @@ template<typename Entity >
-

Checks whether the sparse set is empty.

-
Returns
True is the sparse set is empty, false otherwise.
+

Checks whether a sparse set is empty.

+
Returns
True if the sparse set is empty, false otherwise.
-

Definition at line 134 of file sparse_set.hpp.

+

Definition at line 136 of file sparse_set.hpp.

@@ -405,7 +404,7 @@ template<typename Entity >
Note
Input iterators stay true to the order imposed by a call to sort.
Returns
An iterator to the element following the last element of the internal packed array.
-

Definition at line 186 of file sparse_set.hpp.

+

Definition at line 188 of file sparse_set.hpp.

@@ -435,7 +434,7 @@ template<typename Entity >
-

Returns the position of the entity in the sparse set.

+

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
@@ -446,7 +445,7 @@ template<typename Entity >
Returns
The position of the entity in the sparse set.
-

Definition at line 212 of file sparse_set.hpp.

+

Definition at line 215 of file sparse_set.hpp.

@@ -476,7 +475,7 @@ template<typename Entity >
-

Checks if the sparse set contains the given entity.

+

Checks if a sparse set contains an entity.

Parameters
@@ -485,7 +484,7 @@ template<typename Entity >
Returns
True if the sparse set contains the entity, false otherwise.
-

Definition at line 195 of file sparse_set.hpp.

+

Definition at line 197 of file sparse_set.hpp.

@@ -577,7 +576,7 @@ template<typename Entity >
entityA valid entity identifier.
-

Sort entities according to their order in the given sparse set.

+

Sort entities according to their order in a 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 sort. See begin and end for more details.

@@ -589,7 +588,7 @@ template<typename Entity >
-

Definition at line 337 of file sparse_set.hpp.

+

Definition at line 345 of file sparse_set.hpp.

@@ -618,11 +617,11 @@ template<typename Entity >
-

Returns the number of elements in the sparse set.

+

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 126 of file sparse_set.hpp.

+

Definition at line 128 of file sparse_set.hpp.

@@ -670,7 +669,7 @@ template<typename Compare > -

Definition at line 305 of file sparse_set.hpp.

+

Definition at line 313 of file sparse_set.hpp.

@@ -710,7 +709,7 @@ template<typename Entity >
-

Swaps the position of the entities in the internal packed array.

+

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.
@@ -724,7 +723,7 @@ template<typename Entity >

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

-

Definition at line 280 of file sparse_set.hpp.

+

Definition at line 287 of file sparse_set.hpp.

diff --git a/classentt_1_1View-members.html b/classentt_1_1View-members.html index dbd74ee77..65d90bba0 100644 --- a/classentt_1_1View-members.html +++ b/classentt_1_1View-members.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0
@@ -80,7 +80,7 @@ $(function() { iterator_type typedefentt::View< Entity, First, Other > reset()entt::View< Entity, First, Other >inline size_type typedefentt::View< Entity, First, Other > - View(pool_type< First > &pool, pool_type< Other > &... other) noexceptentt::View< Entity, First, Other >inlineexplicit + View(pool_type< First > &pool, pool_type< Other > &... other) noexceptentt::View< Entity, First, Other >inline
diff --git a/classentt_1_1View.html b/classentt_1_1View.html index 1d42b3b7d..dd495252f 100644 --- a/classentt_1_1View.html +++ b/classentt_1_1View.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0
@@ -150,7 +150,7 @@ class entt::View< Entity, First, Other > -

Definition at line 300 of file view.hpp.

+

Definition at line 301 of file view.hpp.

Member Typedef Documentation

◆ iterator_type

@@ -167,7 +167,7 @@ template<typename Entity , typename First , typename... Other>

Input iterator type.

-

Definition at line 360 of file view.hpp.

+

Definition at line 361 of file view.hpp.

@@ -203,7 +203,7 @@ template<typename Entity , typename First , typename... Other> -inlineexplicitnoexcept +inlinenoexcept
@@ -217,7 +217,7 @@ template<typename Entity , typename First , typename... Other>
-

Definition at line 371 of file view.hpp.

+

Definition at line 372 of file view.hpp.

@@ -252,7 +252,7 @@ template<typename Entity , typename First , typename... Other>
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 391 of file view.hpp.

+

Definition at line 392 of file view.hpp.

@@ -300,7 +300,7 @@ template<typename Func > -

Definition at line 474 of file view.hpp.

+

Definition at line 475 of file view.hpp.

@@ -348,7 +348,7 @@ template<typename Func > -

Definition at line 496 of file view.hpp.

+

Definition at line 497 of file view.hpp.

@@ -382,7 +382,7 @@ template<typename Entity , typename First , typename... Other>
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 410 of file view.hpp.

+

Definition at line 411 of file view.hpp.

@@ -415,7 +415,7 @@ template<typename Component >

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.

+

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
@@ -432,7 +432,7 @@ template<typename Component >
Returns
The component assigned to the entity.
-

Definition at line 432 of file view.hpp.

+

Definition at line 433 of file view.hpp.

@@ -465,7 +465,7 @@ template<typename Component >

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.

+

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
@@ -482,7 +482,7 @@ template<typename Component >
Returns
The component assigned to the entity.
-

Definition at line 454 of file view.hpp.

+

Definition at line 455 of file view.hpp.

@@ -515,7 +515,7 @@ template<typename Entity , typename First , typename... Other>

A multi component view keeps a reference to the smallest set of candidate entities to iterate. Resetting a view means querying the underlying data structures and reinitializing the view.
Use it only if copies of views are stored around and there is a possibility that a component has become the best candidate in the meantime.

-

Definition at line 512 of file view.hpp.

+

Definition at line 513 of file view.hpp.

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 index b6bea6783..11c13f5b6 100644 --- a/classentt_1_1View_3_01Entity_00_01Component_01_4-members.html +++ b/classentt_1_1View_3_01Entity_00_01Component_01_4-members.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0
@@ -81,10 +81,10 @@ $(function() { iterator_type typedefentt::View< Entity, Component > raw() noexceptentt::View< Entity, Component >inline raw() const noexceptentt::View< Entity, Component >inline - raw_type typedefentt::View< Entity, Component > + raw_type typedefentt::View< Entity, Component > size() const noexceptentt::View< Entity, Component >inline size_type typedefentt::View< Entity, Component > - View(pool_type &pool) noexceptentt::View< Entity, Component >inlineexplicit + View(pool_type &pool) noexceptentt::View< Entity, Component >inline
diff --git a/classentt_1_1View_3_01Entity_00_01Component_01_4.html b/classentt_1_1View_3_01Entity_00_01Component_01_4.html index ddc07b644..7dc2a2c3f 100644 --- a/classentt_1_1View_3_01Entity_00_01Component_01_4.html +++ b/classentt_1_1View_3_01Entity_00_01Component_01_4.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0
@@ -89,8 +89,8 @@ using size_type = typename pool_type::size_type  Unsigned integer type.
  -using raw_type = typename pool_type::type -  +using raw_type = typename pool_type::object_type +  @@ -100,10 +100,10 @@ Public Member Functions - + - + @@ -157,7 +157,7 @@ class entt::View< Entity, Component > -

Definition at line 562 of file view.hpp.

+

Definition at line 563 of file view.hpp.

Member Typedef Documentation

◆ iterator_type

@@ -174,12 +174,12 @@ template<typename Entity , typename Component >

Input iterator type.

-

Definition at line 567 of file view.hpp.

+

Definition at line 568 of file view.hpp.

- -

◆ raw_type

+ +

◆ raw_type

@@ -187,13 +187,13 @@ template<typename Entity , typename Component >
template<typename Entity , typename Component >

Public Member Functions

size_type size () const noexcept
 Returns the number of entities that have the given component. More...
 
raw_type * raw () noexcept
raw_type * raw () noexcept
 Direct access to the list of components. More...
 
const raw_type * raw () const noexcept
const raw_type * raw () const noexcept
 Direct access to the list of components. More...
 
const entity_type * data () const noexcept
- +
using entt::View< Entity, Component >::raw_type = typename pool_type::typeusing entt::View< Entity, Component >::raw_type = typename pool_type::object_type

Type of the component iterated by the view.

-

Definition at line 573 of file view.hpp.

+

Definition at line 574 of file view.hpp.

@@ -219,7 +219,7 @@ template<typename Entity , typename Component > -inlineexplicitnoexcept +inlinenoexcept
@@ -232,7 +232,7 @@ template<typename Entity , typename Component >
-

Definition at line 579 of file view.hpp.

+

Definition at line 580 of file view.hpp.

@@ -267,7 +267,7 @@ template<typename Entity , typename Component >
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 653 of file view.hpp.

+

Definition at line 654 of file view.hpp.

@@ -301,7 +301,7 @@ template<typename Entity , typename Component >
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 635 of file view.hpp.

+

Definition at line 636 of file view.hpp.

@@ -349,7 +349,7 @@ template<typename Func > -

Definition at line 729 of file view.hpp.

+

Definition at line 730 of file view.hpp.

@@ -397,7 +397,7 @@ template<typename Func > -

Definition at line 750 of file view.hpp.

+

Definition at line 751 of file view.hpp.

@@ -431,7 +431,7 @@ template<typename Entity , typename Component >
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 672 of file view.hpp.

+

Definition at line 673 of file view.hpp.

@@ -462,7 +462,7 @@ template<typename Entity , typename Component >

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.

+

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
@@ -473,7 +473,7 @@ template<typename Entity , typename Component >
Returns
The component assigned to the entity.
-

Definition at line 691 of file view.hpp.

+

Definition at line 692 of file view.hpp.

@@ -504,7 +504,7 @@ template<typename Entity , typename Component >

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.

+

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
@@ -515,7 +515,7 @@ template<typename Entity , typename Component >
Returns
The component assigned to the entity.
-

Definition at line 710 of file view.hpp.

+

Definition at line 711 of file view.hpp.

@@ -531,7 +531,7 @@ template<typename Entity , typename Component > - + @@ -549,7 +549,7 @@ template<typename Entity , typename Component >
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 603 of file view.hpp.

+

Definition at line 604 of file view.hpp.

@@ -565,7 +565,7 @@ template<typename Entity , typename Component > @@ -67,15 +67,15 @@ $(function() {
delegate.hpp
-
1 #ifndef ENTT_SIGNAL_DELEGATE_HPP
2 #define ENTT_SIGNAL_DELEGATE_HPP
3 
4 
5 #include <utility>
6 
7 
8 namespace entt {
9 
10 
17 template<typename>
18 class Delegate;
19 
20 
34 template<typename Ret, typename... Args>
35 class Delegate<Ret(Args...)> final {
36  using proto_type = Ret(*)(void *, Args...);
37  using stub_type = std::pair<void *, proto_type>;
38 
39  static Ret fallback(void *, Args...) noexcept { return {}; }
40 
41  template<Ret(*Function)(Args...)>
42  static Ret proto(void *, Args... args) {
43  return (Function)(args...);
44  }
45 
46  template<typename Class, Ret(Class::*Member)(Args...)>
47  static Ret proto(void *instance, Args... args) {
48  return (static_cast<Class *>(instance)->*Member)(args...);
49  }
50 
51 public:
53  explicit Delegate() noexcept
54  : stub{std::make_pair(nullptr, &fallback)}
55  {}
56 
61  template<Ret(*Function)(Args...)>
62  void connect() noexcept {
63  stub = std::make_pair(nullptr, &proto<Function>);
64  }
65 
77  template<typename Class, Ret(Class::*Member)(Args...)>
78  void connect(Class *instance) noexcept {
79  stub = std::make_pair(instance, &proto<Class, Member>);
80  }
81 
87  void reset() noexcept {
88  stub = std::make_pair(nullptr, &fallback);
89  }
90 
96  Ret operator()(Args... args) {
97  return stub.second(stub.first, args...);
98  }
99 
108  bool operator==(const Delegate<Ret(Args...)> &other) const noexcept {
109  return stub.first == other.stub.first && stub.second == other.stub.second;
110  }
111 
112 private:
113  stub_type stub;
114 };
115 
116 
128 template<typename Ret, typename... Args>
129 bool operator!=(const Delegate<Ret(Args...)> &lhs, const Delegate<Ret(Args...)> &rhs) noexcept {
130  return !(lhs == rhs);
131 }
132 
133 
134 }
135 
136 
137 #endif // ENTT_SIGNAL_DELEGATE_HPP
entt::operator!=
bool operator!=(const Delegate< Ret(Args...)> &lhs, const Delegate< Ret(Args...)> &rhs) noexcept
Checks if the contents of the two delegates are different.
Definition: delegate.hpp:129
-
entt
EnTT default namespace.
Definition: family.hpp:9
-
entt::Delegate< Ret(Args...)>::Delegate
Delegate() noexcept
Default constructor, explicit on purpose.
Definition: delegate.hpp:53
+
1 #ifndef ENTT_SIGNAL_DELEGATE_HPP
2 #define ENTT_SIGNAL_DELEGATE_HPP
3 
4 
5 #include <utility>
6 
7 
8 namespace entt {
9 
10 
17 template<typename>
18 class Delegate;
19 
20 
34 template<typename Ret, typename... Args>
35 class Delegate<Ret(Args...)> final {
36  using proto_type = Ret(*)(void *, Args...);
37  using stub_type = std::pair<void *, proto_type>;
38 
39  static Ret fallback(void *, Args...) noexcept { return {}; }
40 
41  template<Ret(*Function)(Args...)>
42  static Ret proto(void *, Args... args) {
43  return (Function)(args...);
44  }
45 
46  template<typename Class, Ret(Class::*Member)(Args...)>
47  static Ret proto(void *instance, Args... args) {
48  return (static_cast<Class *>(instance)->*Member)(args...);
49  }
50 
51 public:
53  Delegate() noexcept
54  : stub{std::make_pair(nullptr, &fallback)}
55  {}
56 
61  template<Ret(*Function)(Args...)>
62  void connect() noexcept {
63  stub = std::make_pair(nullptr, &proto<Function>);
64  }
65 
77  template<typename Class, Ret(Class::*Member)(Args...)>
78  void connect(Class *instance) noexcept {
79  stub = std::make_pair(instance, &proto<Class, Member>);
80  }
81 
87  void reset() noexcept {
88  stub = std::make_pair(nullptr, &fallback);
89  }
90 
96  Ret operator()(Args... args) {
97  return stub.second(stub.first, args...);
98  }
99 
108  bool operator==(const Delegate<Ret(Args...)> &other) const noexcept {
109  return stub.first == other.stub.first && stub.second == other.stub.second;
110  }
111 
112 private:
113  stub_type stub;
114 };
115 
116 
128 template<typename Ret, typename... Args>
129 bool operator!=(const Delegate<Ret(Args...)> &lhs, const Delegate<Ret(Args...)> &rhs) noexcept {
130  return !(lhs == rhs);
131 }
132 
133 
134 }
135 
136 
137 #endif // ENTT_SIGNAL_DELEGATE_HPP
entt
EnTT default namespace.
Definition: family.hpp:9
+
entt::Delegate< Ret(Args...)>::Delegate
Delegate() noexcept
Default constructor.
Definition: delegate.hpp:53
entt::Delegate
Basic delegate implementation.
Definition: delegate.hpp:18
entt::Delegate< Ret(Args...)>::operator==
bool operator==(const Delegate< Ret(Args...)> &other) const noexcept
Checks if the contents of the two delegates are different.
Definition: delegate.hpp:108
entt::Delegate< Ret(Args...)>::connect
void connect(Class *instance) noexcept
Connects a member function for a given instance to a delegate.
Definition: delegate.hpp:78
entt::Delegate< Ret(Args...)>::connect
void connect() noexcept
Binds a free function to a delegate.
Definition: delegate.hpp:62
entt::Delegate< Ret(Args...)>::operator()
Ret operator()(Args... args)
Triggers a delegate.
Definition: delegate.hpp:96
entt::Delegate< Ret(Args...)>::reset
void reset() noexcept
Resets a delegate.
Definition: delegate.hpp:87
+
entt::operator!=
constexpr bool operator!=(const HashedString &lhs, const HashedString &rhs) noexcept
Compares two hashed strings.
Definition: hashed_string.hpp:101
diff --git a/dir_66e9674e8206a335795995fa32a03c91.html b/dir_66e9674e8206a335795995fa32a03c91.html index 40d38ed77..874d37f9c 100644 --- a/dir_66e9674e8206a335795995fa32a03c91.html +++ b/dir_66e9674e8206a335795995fa32a03c91.html @@ -22,7 +22,7 @@
diff --git a/dir_68267d1309a1af8e8297ef4c3efbcdba.html b/dir_68267d1309a1af8e8297ef4c3efbcdba.html index cc045d1ca..04cc9bf76 100644 --- a/dir_68267d1309a1af8e8297ef4c3efbcdba.html +++ b/dir_68267d1309a1af8e8297ef4c3efbcdba.html @@ -22,7 +22,7 @@ diff --git a/dir_721f6154dba3c88bcdead5f446bce319.html b/dir_721f6154dba3c88bcdead5f446bce319.html new file mode 100644 index 000000000..be466dd1c --- /dev/null +++ b/dir_721f6154dba3c88bcdead5f446bce319.html @@ -0,0 +1,78 @@ + + + + + + + +entt: src/entt/process Directory Reference + + + + + + + + + +
+
+
raw_type* entt::View< Entity, Component >::raw raw_type* entt::View< Entity, Component >::raw ( ) - + @@ -583,7 +583,7 @@ template<typename Entity , typename Component >
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 619 of file view.hpp.

+

Definition at line 620 of file view.hpp.

@@ -615,7 +615,7 @@ template<typename Entity , typename Component >

Returns the number of entities that have the given component.

Returns
Number of entities that have the given component.
-

Definition at line 587 of file view.hpp.

+

Definition at line 588 of file view.hpp.

diff --git a/classes.html b/classes.html index 0a83f24ae..09a6c2175 100644 --- a/classes.html +++ b/classes.html @@ -22,7 +22,7 @@ @@ -63,31 +63,33 @@ $(function() {
Class Index
-
b | c | d | e | f | p | r | s | v
+
a | b | c | d | e | f | h | p | r | s | v
const raw_type* entt::View< Entity, Component >::raw const raw_type* entt::View< Entity, Component >::raw ( ) const
entt -  2.1.0 +  2.2.0
+ + + - + + - - + + + - - - - - + + +
  a  
+
  d  
+		entt_traits< std::uint64_t > (entt)   ProcessAdaptor (entt)   SigH (entt)   
  f  
+
  r  
+		SigH< Ret(Args...), Collector > (entt)   
Actor (entt)   Delegate (entt)   Signal (entt)   
  b  
-		Delegate< Ret(Args...)> (entt)   
  f  
-
  s  
-		SparseSet< Entity, Type > (entt)   
Dispatcher (entt)   
  v  
-
Delegate< Ret(Args...)> (entt)   Family (entt)   Registry (entt)   Signal< void(Args...)> (entt)   
Dispatcher (entt)   
  h  
+		ResourceCache (entt)   SparseSet (entt)   
Bus (entt)   
  e  
-		Family (entt)   ServiceLocator (entt)   
Bus< Sig, Event > (entt)   
  p  
-		SigH (entt)   View (entt)   
Bus< Sig, Event, Other... > (entt)   Emitter (entt)   SigH< Ret(Args...), Collector > (entt)   View< Entity, Component > (entt)   
ResourceHandle (entt)   SparseSet< Entity > (entt)   
Bus< Sig, Event > (entt)   HashedString (entt)   ResourceLoader (entt)   SparseSet< Entity, Type > (entt)   
Bus< Sig, Event, Other... > (entt)   Emitter (entt)   
  p  
+
  s  
+
  v  
+
  c  
-		entt_traits (entt)   PersistentView (entt)   Signal (entt)   
entt_traits< std::uint16_t > (entt)   
  r  
-		Signal< void(Args...)> (entt)   
Emitter::Connection (entt)   entt_traits< std::uint32_t > (entt)   SparseSet (entt)   
  d  
-		entt_traits< std::uint64_t > (entt)   Registry (entt)   SparseSet< Entity > (entt)   
Delegate (entt)   
entt_traits (entt)   
entt_traits< std::uint16_t > (entt)   PersistentView (entt)   Scheduler (entt)   View (entt)   
Emitter::Connection (entt)   entt_traits< std::uint32_t > (entt)   Process (entt)   ServiceLocator (entt)   View< Entity, Component > (entt)   
-
b | c | d | e | f | p | r | s | v
+
a | b | c | d | e | f | h | p | r | s | v
diff --git a/delegate_8hpp_source.html b/delegate_8hpp_source.html index 8a5270da4..d7bae5bef 100644 --- a/delegate_8hpp_source.html +++ b/delegate_8hpp_source.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0
entt -  2.1.0 +  2.2.0
entt -  2.1.0 +  2.2.0
+ + + + + +
+
entt +  2.2.0 +
+
+ + + + + + + + + +
+
+ + +
+ +
+ + + +
+
+
process Directory Reference
+
+
+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/dir_85dbee8884f1b3a817fa7eff8dff73ec.html b/dir_85dbee8884f1b3a817fa7eff8dff73ec.html new file mode 100644 index 000000000..0775deda0 --- /dev/null +++ b/dir_85dbee8884f1b3a817fa7eff8dff73ec.html @@ -0,0 +1,78 @@ + + + + + + + +entt: src/entt/resource Directory Reference + + + + + + + + + +
+
+ + + + + + +
+
entt +  2.2.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
resource Directory Reference
+
+
+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/dir_a53318306f6ac0f7fe657839abd543ab.html b/dir_a53318306f6ac0f7fe657839abd543ab.html index c99c9b00f..f5f4ef8c6 100644 --- a/dir_a53318306f6ac0f7fe657839abd543ab.html +++ b/dir_a53318306f6ac0f7fe657839abd543ab.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0
diff --git a/dir_b64489a1e8130d5ebf6d86d282f500f0.html b/dir_b64489a1e8130d5ebf6d86d282f500f0.html index 4e0bb71eb..999d8c3cf 100644 --- a/dir_b64489a1e8130d5ebf6d86d282f500f0.html +++ b/dir_b64489a1e8130d5ebf6d86d282f500f0.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0
diff --git a/dir_de8f4e6ba3f54a2a21309f742e93a373.html b/dir_de8f4e6ba3f54a2a21309f742e93a373.html index 91d69cabb..db3bc4cf5 100644 --- a/dir_de8f4e6ba3f54a2a21309f742e93a373.html +++ b/dir_de8f4e6ba3f54a2a21309f742e93a373.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0
diff --git a/dir_e3a7bb56c55e5c2286e2fe96e197d4f5.html b/dir_e3a7bb56c55e5c2286e2fe96e197d4f5.html index 6359ab7e3..b908442b5 100644 --- a/dir_e3a7bb56c55e5c2286e2fe96e197d4f5.html +++ b/dir_e3a7bb56c55e5c2286e2fe96e197d4f5.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0
diff --git a/dispatcher_8hpp_source.html b/dispatcher_8hpp_source.html index 3c0a31dd3..3ea76ec75 100644 --- a/dispatcher_8hpp_source.html +++ b/dispatcher_8hpp_source.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0
@@ -67,17 +67,15 @@ $(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 "../core/family.hpp"
10 #include "signal.hpp"
11 #include "sigh.hpp"
12 
13 
14 namespace entt {
15 
16 
29 template<template<typename...> class Sig>
30 class Dispatcher final {
31  using event_family = Family<struct InternalDispatcherEventFamily>;
32 
33  template<typename Class, typename Event>
34  using instance_type = typename Sig<void(const Event &)>::template instance_type<Class>;
35 
36  struct BaseSignalWrapper {
37  virtual ~BaseSignalWrapper() = default;
38  virtual void publish(std::size_t) = 0;
39  };
40 
41  template<typename Event>
42  struct SignalWrapper final: BaseSignalWrapper {
43  void publish(std::size_t current) final override {
44  for(auto &&event: events[current]) {
45  signal.publish(event);
46  }
47 
48  events[current].clear();
49  }
50 
51  template<typename Class, void(Class::*Member)(const Event &)>
52  inline void connect(instance_type<Class, Event> instance) noexcept {
53  signal.template connect<Class, Member>(std::move(instance));
54  }
55 
56  template<typename Class, void(Class::*Member)(const Event &)>
57  inline void disconnect(instance_type<Class, Event> instance) noexcept {
58  signal.template disconnect<Class, Member>(std::move(instance));
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(std::size_t current, Args&&... args) {
68  events[current].push_back({ std::forward<Args>(args)... });
69  }
70 
71  private:
72  Sig<void(const Event &)> signal{};
73  std::vector<Event> events[2];
74  };
75 
76  inline static std::size_t buffer(bool mode) {
77  return mode ? 0 : 1;
78  }
79 
80  template<typename Event>
81  SignalWrapper<Event> & wrapper() {
82  auto type = event_family::type<Event>();
83 
84  if(!(type < wrappers.size())) {
85  wrappers.resize(type + 1);
86  }
87 
88  if(!wrappers[type]) {
89  wrappers[type] = std::make_unique<SignalWrapper<Event>>();
90  }
91 
92  return static_cast<SignalWrapper<Event> &>(*wrappers[type]);
93  }
94 
95 public:
97  explicit Dispatcher() noexcept
98  : wrappers{}, mode{false}
99  {}
100 
102  ~Dispatcher() = default;
103 
105  Dispatcher(const Dispatcher &) = default;
107  Dispatcher(Dispatcher &&) = default;
108 
110  Dispatcher & operator=(const Dispatcher &) = default;
112  Dispatcher & operator=(Dispatcher &&) = default;
113 
130  template<typename Event, typename Class, void(Class::*Member)(const Event &) = &Class::receive>
131  void connect(instance_type<Class, Event> instance) noexcept {
132  wrapper<Event>().template connect<Class, Member>(std::move(instance));
133  }
134 
151  template<typename Event, typename Class, void(Class::*Member)(const Event &) = &Class::receive>
152  void disconnect(instance_type<Class, Event> instance) noexcept {
153  wrapper<Event>().template disconnect<Class, Member>(std::move(instance));
154  }
155 
166  template<typename Event, typename... Args>
167  void trigger(Args&&... args) {
168  wrapper<Event>().trigger(std::forward<Args>(args)...);
169  }
170 
181  template<typename Event, typename... Args>
182  void enqueue(Args&&... args) {
183  wrapper<Event>().enqueue(buffer(mode), std::forward<Args>(args)...);
184  }
185 
193  void update() {
194  auto buf = buffer(mode);
195  mode = !mode;
196 
197  for(auto &&wrapper: wrappers) {
198  if(wrapper) {
199  wrapper->publish(buf);
200  }
201  }
202  }
203 
204 private:
205  std::vector<std::unique_ptr<BaseSignalWrapper>> wrappers;
206  bool mode;
207 };
208 
209 
217 using ManagedDispatcher = Dispatcher<Signal>;
218 
219 
229 using UnmanagedDispatcher = Dispatcher<SigH>;
230 
231 
232 }
233 
234 
235 #endif // ENTT_SIGNAL_DISPATCHER_HPP
entt::Dispatcher::Dispatcher
Dispatcher() noexcept
Default constructor, explicit on purpose.
Definition: dispatcher.hpp:97
+
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 "../core/family.hpp"
10 #include "signal.hpp"
11 #include "sigh.hpp"
12 
13 
14 namespace entt {
15 
16 
29 template<template<typename...> class Sig>
30 class Dispatcher final {
31  using event_family = Family<struct InternalDispatcherEventFamily>;
32 
33  template<typename Class, typename Event>
34  using instance_type = typename Sig<void(const Event &)>::template instance_type<Class>;
35 
36  struct BaseSignalWrapper {
37  virtual ~BaseSignalWrapper() = default;
38  virtual void publish(std::size_t) = 0;
39  };
40 
41  template<typename Event>
42  struct SignalWrapper final: BaseSignalWrapper {
43  void publish(std::size_t current) final override {
44  for(auto &&event: events[current]) {
45  signal.publish(event);
46  }
47 
48  events[current].clear();
49  }
50 
51  template<typename Class, void(Class::*Member)(const Event &)>
52  inline void connect(instance_type<Class, Event> instance) noexcept {
53  signal.template connect<Class, Member>(std::move(instance));
54  }
55 
56  template<typename Class, void(Class::*Member)(const Event &)>
57  inline void disconnect(instance_type<Class, Event> instance) noexcept {
58  signal.template disconnect<Class, Member>(std::move(instance));
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(std::size_t current, Args&&... args) {
68  events[current].push_back({ std::forward<Args>(args)... });
69  }
70 
71  private:
72  Sig<void(const Event &)> signal{};
73  std::vector<Event> events[2];
74  };
75 
76  inline static std::size_t buffer(bool mode) {
77  return mode ? 0 : 1;
78  }
79 
80  template<typename Event>
81  SignalWrapper<Event> & wrapper() {
82  auto type = event_family::type<Event>();
83 
84  if(!(type < wrappers.size())) {
85  wrappers.resize(type + 1);
86  }
87 
88  if(!wrappers[type]) {
89  wrappers[type] = std::make_unique<SignalWrapper<Event>>();
90  }
91 
92  return static_cast<SignalWrapper<Event> &>(*wrappers[type]);
93  }
94 
95 public:
97  Dispatcher() noexcept
98  : wrappers{}, mode{false}
99  {}
100 
117  template<typename Event, typename Class, void(Class::*Member)(const Event &) = &Class::receive>
118  void connect(instance_type<Class, Event> instance) noexcept {
119  wrapper<Event>().template connect<Class, Member>(std::move(instance));
120  }
121 
138  template<typename Event, typename Class, void(Class::*Member)(const Event &) = &Class::receive>
139  void disconnect(instance_type<Class, Event> instance) noexcept {
140  wrapper<Event>().template disconnect<Class, Member>(std::move(instance));
141  }
142 
153  template<typename Event, typename... Args>
154  void trigger(Args&&... args) {
155  wrapper<Event>().trigger(std::forward<Args>(args)...);
156  }
157 
168  template<typename Event, typename... Args>
169  void enqueue(Args&&... args) {
170  wrapper<Event>().enqueue(buffer(mode), std::forward<Args>(args)...);
171  }
172 
180  void update() {
181  auto buf = buffer(mode);
182  mode = !mode;
183 
184  for(auto &&wrapper: wrappers) {
185  if(wrapper) {
186  wrapper->publish(buf);
187  }
188  }
189  }
190 
191 private:
192  std::vector<std::unique_ptr<BaseSignalWrapper>> wrappers;
193  bool mode;
194 };
195 
196 
204 using ManagedDispatcher = Dispatcher<Signal>;
205 
206 
216 using UnmanagedDispatcher = Dispatcher<SigH>;
217 
218 
219 }
220 
221 
222 #endif // ENTT_SIGNAL_DISPATCHER_HPP
entt::Dispatcher::Dispatcher
Dispatcher() noexcept
Default constructor.
Definition: dispatcher.hpp:97
entt
EnTT default namespace.
Definition: family.hpp:9
-
entt::Dispatcher::~Dispatcher
~Dispatcher()=default
Default destructor.
-
entt::Dispatcher::update
void update()
Delivers all the pending events.
Definition: dispatcher.hpp:193
-
entt::Dispatcher::operator=
Dispatcher & operator=(const Dispatcher &)=default
Default copy assignment operator.
-
entt::Dispatcher::trigger
void trigger(Args &&... args)
Triggers an immediate event of the given type.
Definition: dispatcher.hpp:167
-
entt::Dispatcher::connect
void connect(instance_type< Class, Event > instance) noexcept
Registers a listener given in the form of a member function.
Definition: dispatcher.hpp:131
-
entt::Dispatcher::enqueue
void enqueue(Args &&... args)
Enqueues an event of the given type.
Definition: dispatcher.hpp:182
+
entt::Dispatcher::update
void update()
Delivers all the pending events.
Definition: dispatcher.hpp:180
+
entt::Dispatcher::trigger
void trigger(Args &&... args)
Triggers an immediate event of the given type.
Definition: dispatcher.hpp:154
+
entt::Dispatcher::connect
void connect(instance_type< Class, Event > instance) noexcept
Registers a listener given in the form of a member function.
Definition: dispatcher.hpp:118
+
entt::Dispatcher::enqueue
void enqueue(Args &&... args)
Enqueues an event of the given type.
Definition: dispatcher.hpp:169
entt::Dispatcher
Basic dispatcher implementation.
Definition: dispatcher.hpp:30
entt::Family
Dynamic identifier generator.
Definition: family.hpp:20
-
entt::Dispatcher::disconnect
void disconnect(instance_type< Class, Event > instance) noexcept
Unregisters a listener given in the form of a member function.
Definition: dispatcher.hpp:152
+
entt::Dispatcher::disconnect
void disconnect(instance_type< Class, Event > instance) noexcept
Unregisters a listener given in the form of a member function.
Definition: dispatcher.hpp:139
diff --git a/emitter_8hpp_source.html b/emitter_8hpp_source.html index 2191bd197..8152a3930 100644 --- a/emitter_8hpp_source.html +++ b/emitter_8hpp_source.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0
@@ -67,22 +67,21 @@ $(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 
14 
15 namespace entt {
16 
17 
39 template<typename Derived>
40 class Emitter {
41  struct BaseHandler {
42  virtual ~BaseHandler() = default;
43  virtual bool empty() const noexcept = 0;
44  virtual void clear() noexcept = 0;
45  };
46 
47  template<typename Event>
48  struct Handler final: BaseHandler {
49  using listener_type = std::function<void(const Event &, Derived &)>;
50  using element_type = std::pair<bool, listener_type>;
51  using container_type = std::list<element_type>;
52  using connection_type = typename container_type::iterator;
53 
54  bool empty() const noexcept override {
55  auto pred = [](auto &&element){ return element.first; };
56 
57  return std::all_of(onceL.cbegin(), onceL.cend(), pred) &&
58  std::all_of(onL.cbegin(), onL.cend(), pred);
59  }
60 
61  void clear() noexcept override {
62  if(publishing) {
63  auto func = [](auto &&element){ element.first = true; };
64  std::for_each(onceL.begin(), onceL.end(), func);
65  std::for_each(onL.begin(), onL.end(), func);
66  } else {
67  onceL.clear();
68  onL.clear();
69  }
70  }
71 
72  inline connection_type once(listener_type listener) {
73  return onceL.emplace(onceL.cend(), false, std::move(listener));
74  }
75 
76  inline connection_type on(listener_type listener) {
77  return onL.emplace(onL.cend(), false, std::move(listener));
78  }
79 
80  void erase(connection_type conn) noexcept {
81  conn->first = true;
82 
83  if(!publishing) {
84  auto pred = [](auto &&element){ return element.first; };
85  onceL.remove_if(pred);
86  onL.remove_if(pred);
87  }
88  }
89 
90  void publish(const Event &event, Derived &ref) {
91  container_type currentL;
92  onceL.swap(currentL);
93 
94  auto func = [&event, &ref](auto &&element) {
95  return element.first ? void() : element.second(event, ref);
96  };
97 
98  publishing = true;
99 
100  std::for_each(onL.rbegin(), onL.rend(), func);
101  std::for_each(currentL.rbegin(), currentL.rend(), func);
102 
103  publishing = false;
104 
105  onL.remove_if([](auto &&element){ return element.first; });
106  }
107 
108  private:
109  bool publishing{false};
110  container_type onceL{};
111  container_type onL{};
112  };
113 
114  static std::size_t next() noexcept {
115  static std::size_t counter = 0;
116  return counter++;
117  }
118 
119  template<typename>
120  static std::size_t type() noexcept {
121  static std::size_t value = next();
122  return value;
123  }
124 
125  template<typename Event>
126  Handler<Event> & handler() noexcept {
127  std::size_t family = type<Event>();
128 
129  if(!(family < handlers.size())) {
130  handlers.resize(family+1);
131  }
132 
133  if(!handlers[family]) {
134  handlers[family] = std::make_unique<Handler<Event>>();
135  }
136 
137  return static_cast<Handler<Event> &>(*handlers[family]);
138  }
139 
140 public:
142  template<typename Event>
143  using Listener = typename Handler<Event>::listener_type;
144 
154  template<typename Event>
155  struct Connection final: private Handler<Event>::connection_type {
157  friend class Emitter;
158 
160  explicit Connection() = default;
161 
163  Connection(const Connection &) = default;
165  Connection(Connection &&) = default;
166 
168  ~Connection() = default;
169 
174  Connection(typename Handler<Event>::connection_type conn)
175  : Handler<Event>::connection_type{std::move(conn)}
176  {}
177 
182  Connection & operator=(const Connection &) = default;
183 
188  Connection & operator=(Connection &&) = default;
189  };
190 
192  explicit Emitter() noexcept = default;
193 
195  Emitter(const Emitter &) = delete;
197  Emitter(Emitter &&) = default;
198 
200  virtual ~Emitter() noexcept {
201  static_assert(std::is_base_of<Emitter<Derived>, Derived>::value, "!");
202  }
203 
205  Emitter & operator=(const Emitter &) = delete;
207  Emitter & operator=(Emitter &&) = default;
208 
220  template<typename Event, typename... Args>
221  void publish(Args&&... args) {
222  handler<Event>().publish({ std::forward<Args>(args)... }, *static_cast<Derived *>(this));
223  }
224 
245  template<typename Event>
246  Connection<Event> on(Listener<Event> listener) {
247  return handler<Event>().on(std::move(listener));
248  }
249 
270  template<typename Event>
271  Connection<Event> once(Listener<Event> listener) {
272  return handler<Event>().once(std::move(listener));
273  }
274 
284  template<typename Event>
285  void erase(Connection<Event> conn) noexcept {
286  handler<Event>().erase(std::move(conn));
287  }
288 
297  template<typename Event>
298  void clear() noexcept {
299  handler<Event>().clear();
300  }
301 
308  void clear() noexcept {
309  std::for_each(handlers.begin(), handlers.end(),
310  [](auto &&handler){ if(handler) { handler->clear(); } });
311  }
312 
318  template<typename Event>
319  bool empty() const noexcept {
320  std::size_t family = type<Event>();
321 
322  return (!(family < handlers.size()) ||
323  !handlers[family] ||
324  static_cast<Handler<Event> &>(*handlers[family]).empty());
325  }
326 
331  bool empty() const noexcept {
332  return std::all_of(handlers.cbegin(), handlers.cend(),
333  [](auto &&handler){ return !handler || handler->empty(); });
334  }
335 
336 private:
337  std::vector<std::unique_ptr<BaseHandler>> handlers{};
338 };
339 
340 
341 }
342 
343 
344 #endif // ENTT_SIGNAL_EMITTER_HPP
entt::Emitter::Emitter
Emitter() noexcept=default
Default constructor, explicit on purpose.
-
entt::Emitter::empty
bool empty() const noexcept
Checks if there are listeners registered with the event emitter.
Definition: emitter.hpp:331
-
entt::Emitter::on
Connection< Event > on(Listener< Event > listener)
Registers a long-lived listener with the event emitter.
Definition: emitter.hpp:246
+
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 
14 
15 namespace entt {
16 
17 
39 template<typename Derived>
40 class Emitter {
41  struct BaseHandler {
42  virtual ~BaseHandler() = default;
43  virtual bool empty() const noexcept = 0;
44  virtual void clear() noexcept = 0;
45  };
46 
47  template<typename Event>
48  struct Handler final: BaseHandler {
49  using listener_type = std::function<void(const Event &, Derived &)>;
50  using element_type = std::pair<bool, listener_type>;
51  using container_type = std::list<element_type>;
52  using connection_type = typename container_type::iterator;
53 
54  bool empty() const noexcept override {
55  auto pred = [](auto &&element){ return element.first; };
56 
57  return std::all_of(onceL.cbegin(), onceL.cend(), pred) &&
58  std::all_of(onL.cbegin(), onL.cend(), pred);
59  }
60 
61  void clear() noexcept override {
62  if(publishing) {
63  auto func = [](auto &&element){ element.first = true; };
64  std::for_each(onceL.begin(), onceL.end(), func);
65  std::for_each(onL.begin(), onL.end(), func);
66  } else {
67  onceL.clear();
68  onL.clear();
69  }
70  }
71 
72  inline connection_type once(listener_type listener) {
73  return onceL.emplace(onceL.cend(), false, std::move(listener));
74  }
75 
76  inline connection_type on(listener_type listener) {
77  return onL.emplace(onL.cend(), false, std::move(listener));
78  }
79 
80  void erase(connection_type conn) noexcept {
81  conn->first = true;
82 
83  if(!publishing) {
84  auto pred = [](auto &&element){ return element.first; };
85  onceL.remove_if(pred);
86  onL.remove_if(pred);
87  }
88  }
89 
90  void publish(const Event &event, Derived &ref) {
91  container_type currentL;
92  onceL.swap(currentL);
93 
94  auto func = [&event, &ref](auto &&element) {
95  return element.first ? void() : element.second(event, ref);
96  };
97 
98  publishing = true;
99 
100  std::for_each(onL.rbegin(), onL.rend(), func);
101  std::for_each(currentL.rbegin(), currentL.rend(), func);
102 
103  publishing = false;
104 
105  onL.remove_if([](auto &&element){ return element.first; });
106  }
107 
108  private:
109  bool publishing{false};
110  container_type onceL{};
111  container_type onL{};
112  };
113 
114  static std::size_t next() noexcept {
115  static std::size_t counter = 0;
116  return counter++;
117  }
118 
119  template<typename>
120  static std::size_t type() noexcept {
121  static std::size_t value = next();
122  return value;
123  }
124 
125  template<typename Event>
126  Handler<Event> & handler() noexcept {
127  std::size_t family = type<Event>();
128 
129  if(!(family < handlers.size())) {
130  handlers.resize(family+1);
131  }
132 
133  if(!handlers[family]) {
134  handlers[family] = std::make_unique<Handler<Event>>();
135  }
136 
137  return static_cast<Handler<Event> &>(*handlers[family]);
138  }
139 
140 public:
142  template<typename Event>
143  using Listener = typename Handler<Event>::listener_type;
144 
154  template<typename Event>
155  struct Connection final: private Handler<Event>::connection_type {
157  friend class Emitter;
158 
160  Connection() noexcept = default;
161 
166  Connection(typename Handler<Event>::connection_type conn)
167  : Handler<Event>::connection_type{std::move(conn)}
168  {}
169 
171  Connection(const Connection &) = default;
173  Connection(Connection &&) = default;
174 
179  Connection & operator=(const Connection &) = default;
180 
185  Connection & operator=(Connection &&) = default;
186  };
187 
189  Emitter() noexcept = default;
190 
192  virtual ~Emitter() noexcept {
193  static_assert(std::is_base_of<Emitter<Derived>, Derived>::value, "!");
194  }
195 
197  Emitter(const Emitter &) = delete;
199  Emitter(Emitter &&) = default;
200 
202  Emitter & operator=(const Emitter &) = delete;
204  Emitter & operator=(Emitter &&) = default;
205 
217  template<typename Event, typename... Args>
218  void publish(Args&&... args) {
219  handler<Event>().publish({ std::forward<Args>(args)... }, *static_cast<Derived *>(this));
220  }
221 
242  template<typename Event>
243  Connection<Event> on(Listener<Event> listener) {
244  return handler<Event>().on(std::move(listener));
245  }
246 
267  template<typename Event>
268  Connection<Event> once(Listener<Event> listener) {
269  return handler<Event>().once(std::move(listener));
270  }
271 
281  template<typename Event>
282  void erase(Connection<Event> conn) noexcept {
283  handler<Event>().erase(std::move(conn));
284  }
285 
294  template<typename Event>
295  void clear() noexcept {
296  handler<Event>().clear();
297  }
298 
305  void clear() noexcept {
306  std::for_each(handlers.begin(), handlers.end(),
307  [](auto &&handler){ if(handler) { handler->clear(); } });
308  }
309 
315  template<typename Event>
316  bool empty() const noexcept {
317  std::size_t family = type<Event>();
318 
319  return (!(family < handlers.size()) ||
320  !handlers[family] ||
321  static_cast<Handler<Event> &>(*handlers[family]).empty());
322  }
323 
328  bool empty() const noexcept {
329  return std::all_of(handlers.cbegin(), handlers.cend(),
330  [](auto &&handler){ return !handler || handler->empty(); });
331  }
332 
333 private:
334  std::vector<std::unique_ptr<BaseHandler>> handlers{};
335 };
336 
337 
338 }
339 
340 
341 #endif // ENTT_SIGNAL_EMITTER_HPP
entt::Emitter::Emitter
Emitter() noexcept=default
Default constructor.
+
entt::Emitter::empty
bool empty() const noexcept
Checks if there are listeners registered with the event emitter.
Definition: emitter.hpp:328
+
entt::Emitter::on
Connection< Event > on(Listener< Event > listener)
Registers a long-lived listener with the event emitter.
Definition: emitter.hpp:243
entt::Emitter::operator=
Emitter & operator=(const Emitter &)=delete
Copying an emitter isn&#39;t allowed.
entt
EnTT default namespace.
Definition: family.hpp:9
entt::Emitter::Connection
Generic connection type for events.
Definition: emitter.hpp:155
-
entt::Emitter::Connection::Connection
Connection(typename Handler< Event >::connection_type conn)
Creates a connection that wraps its underlying instance.
Definition: emitter.hpp:174
-
entt::Emitter::empty
bool empty() const noexcept
Checks if there are listeners registered for the specific event.
Definition: emitter.hpp:319
-
entt::Emitter::publish
void publish(Args &&... args)
Emits the given event.
Definition: emitter.hpp:221
-
entt::Emitter::once
Connection< Event > once(Listener< Event > listener)
Registers a short-lived listener with the event emitter.
Definition: emitter.hpp:271
-
entt::Emitter::clear
void clear() noexcept
Disconnects all the listeners for the given event type.
Definition: emitter.hpp:298
+
entt::Emitter::empty
bool empty() const noexcept
Checks if there are listeners registered for the specific event.
Definition: emitter.hpp:316
+
entt::Emitter::publish
void publish(Args &&... args)
Emits the given event.
Definition: emitter.hpp:218
+
entt::Emitter::once
Connection< Event > once(Listener< Event > listener)
Registers a short-lived listener with the event emitter.
Definition: emitter.hpp:268
+
entt::Emitter::clear
void clear() noexcept
Disconnects all the listeners for the given event type.
Definition: emitter.hpp:295
entt::Emitter
General purpose event emitter.
Definition: emitter.hpp:40
-
entt::Emitter::erase
void erase(Connection< Event > conn) noexcept
Disconnects a listener from the event emitter.
Definition: emitter.hpp:285
-
entt::Emitter::clear
void clear() noexcept
Disconnects all the listeners.
Definition: emitter.hpp:308
+
entt::Emitter::erase
void erase(Connection< Event > conn) noexcept
Disconnects a listener from the event emitter.
Definition: emitter.hpp:282
+
entt::Emitter::clear
void clear() noexcept
Disconnects all the listeners.
Definition: emitter.hpp:305
entt::Emitter::Listener
typename Handler< Event >::listener_type Listener
Type of listeners accepted for the given type of event.
Definition: emitter.hpp:143
-
entt::Emitter::~Emitter
virtual ~Emitter() noexcept
Default destructor.
Definition: emitter.hpp:200
+
entt::Emitter::~Emitter
virtual ~Emitter() noexcept
Default destructor.
Definition: emitter.hpp:192
diff --git a/entt_8hpp_source.html b/entt_8hpp_source.html index 01f39440c..078c0ca69 100644 --- a/entt_8hpp_source.html +++ b/entt_8hpp_source.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0
@@ -67,7 +67,7 @@ $(function() {
entt.hpp
-
1 #include "core/family.hpp"
2 #include "core/ident.hpp"
3 #include "entity/registry.hpp"
4 #include "entity/sparse_set.hpp"
5 #include "entity/traits.hpp"
6 #include "entity/view.hpp"
7 #include "locator/locator.hpp"
8 #include "signal/bus.hpp"
9 #include "signal/delegate.hpp"
10 #include "signal/emitter.hpp"
11 #include "signal/sigh.hpp"
12 #include "signal/signal.hpp"
+
1 #include "core/family.hpp"
2 #include "core/hashed_string.hpp"
3 #include "core/ident.hpp"
4 #include "entity/actor.hpp"
5 #include "entity/registry.hpp"
6 #include "entity/sparse_set.hpp"
7 #include "entity/traits.hpp"
8 #include "entity/view.hpp"
9 #include "locator/locator.hpp"
10 #include "process/process.hpp"
11 #include "process/scheduler.hpp"
12 #include "resource/cache.hpp"
13 #include "resource/handle.hpp"
14 #include "resource/loader.hpp"
15 #include "signal/bus.hpp"
16 #include "signal/delegate.hpp"
17 #include "signal/emitter.hpp"
18 #include "signal/sigh.hpp"
19 #include "signal/signal.hpp"
Generated by   diff --git a/family_8hpp_source.html b/family_8hpp_source.html index 5c9dffd48..527e0ea5b 100644 --- a/family_8hpp_source.html +++ b/family_8hpp_source.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0
diff --git a/files.html b/files.html index 563b2f6ed..262d5c598 100644 --- a/files.html +++ b/files.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0
@@ -69,22 +69,31 @@ $(function() {  ▼ entt  ▼ core  family.hpp - ident.hpp - ▼ entity - registry.hpp - sparse_set.hpp - traits.hpp - view.hpp + hashed_string.hpp + ident.hpp + ▼ entity + actor.hpp + registry.hpp + sparse_set.hpp + traits.hpp + view.hpp  ▼ locator  locator.hpp - ▼ signal - bus.hpp - delegate.hpp - dispatcher.hpp - emitter.hpp - sigh.hpp - signal.hpp - entt.hpp + ▼ process + process.hpp + scheduler.hpp + ▼ resource + cache.hpp + handle.hpp + loader.hpp + ▼ signal + bus.hpp + delegate.hpp + dispatcher.hpp + emitter.hpp + sigh.hpp + signal.hpp + entt.hpp diff --git a/functions.html b/functions.html index dd649998e..6f785ce46 100644 --- a/functions.html +++ b/functions.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0
@@ -62,12 +62,29 @@ $(function() {
Here is a list of all documented class members with links to the class documentation for each member:

- a -

diff --git a/functions_0x7e.html b/functions_0x7e.html index 31e66ab1a..bc00ab7af 100644 --- a/functions_0x7e.html +++ b/functions_0x7e.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0
@@ -62,31 +62,18 @@ $(function() {
Here is a list of all documented class members with links to the class documentation for each member:

- ~ -

diff --git a/functions_c.html b/functions_c.html index 1982c4740..ce1ca4d3c 100644 --- a/functions_c.html +++ b/functions_c.html @@ -22,7 +22,7 @@
entt -  2.1.0 +  2.2.0
@@ -67,6 +67,8 @@ $(function() {
  • clear() : entt::Emitter< Derived > +, entt::ResourceCache< Resource > +, entt::Scheduler< Delta > , entt::SigH< Ret(Args...), Collector > , entt::Signal< void(Args...)>
    • @@ -81,18 +83,22 @@ $(function() { , entt::Bus< Sig, Event, Other... > , entt::Delegate< Ret(Args...)> , entt::Dispatcher< Sig > -, entt::SigH< Ret(Args...), Collector > -, entt::Signal< void(Args...)> +, entt::SigH< Ret(Args...), Collector > +, entt::Signal< void(Args...)>
  • Connection() -: entt::Emitter< Derived >::Connection< Event > +: entt::Emitter< Derived >::Connection< Event >
  • construct() -: entt::SparseSet< Entity > -, entt::SparseSet< Entity, Type > +: entt::SparseSet< Entity > +, entt::SparseSet< Entity, Type > +
    • +
  • contains() +: entt::Registry< Entity > +, entt::ResourceCache< Resource >
  • create() -: entt::Registry< Entity > +: entt::Registry< Entity >
  • current() : entt::Registry< Entity > diff --git a/functions_d.html b/functions_d.html index 9eb35d9c9..dc62bae88 100644 --- a/functions_d.html +++ b/functions_d.html @@ -22,7 +22,7 @@
    entt -  2.1.0 +  2.2.0
    @@ -67,20 +67,31 @@ $(function() { , entt::SparseSet< Entity > , entt::View< Entity, Component >
    • +
  • dead() +: entt::Process< Derived, Delta > +
  • Delegate() : entt::Delegate< Ret(Args...)>
    • +
  • delta_type +: entt::Actor< Entity, Delta > +, entt::Process< Derived, Delta > +
  • destroy() : entt::Registry< Entity > , entt::SparseSet< Entity > , entt::SparseSet< Entity, Type >
    • +
  • discard() +: entt::Registry< Entity > +, entt::ResourceCache< Resource > +
  • disconnect() : entt::Bus< Sig, Event > , entt::Bus< Sig, Event, Other... > , entt::Dispatcher< Sig > -, entt::SigH< Ret(Args...), Collector > -, entt::Signal< void(Args...)> +, entt::SigH< Ret(Args...), Collector > +, entt::Signal< void(Args...)>
  • Dispatcher() : entt::Dispatcher< Sig > diff --git a/functions_e.html b/functions_e.html index 43734c3ce..ad12fc697 100644 --- a/functions_e.html +++ b/functions_e.html @@ -22,7 +22,7 @@
    entt -  2.1.0 +  2.2.0
    @@ -76,6 +76,8 @@ $(function() { , entt::Bus< Sig, Event, Other... > , entt::Emitter< Derived > , entt::Registry< Entity > +, entt::ResourceCache< Resource > +, entt::Scheduler< Delta > , entt::ServiceLocator< Service > , entt::SigH< Ret(Args...), Collector > , entt::Signal< void(Args...)> @@ -95,6 +97,11 @@ $(function() { , entt::entt_traits< std::uint32_t > , entt::entt_traits< std::uint64_t >
    • +
  • entity_shift +: entt::entt_traits< std::uint16_t > +, entt::entt_traits< std::uint32_t > +, entt::entt_traits< std::uint64_t > +
  • entity_type : entt::entt_traits< std::uint16_t > , entt::entt_traits< std::uint32_t > diff --git a/functions_f.html b/functions_f.html index 23f33f147..b6c7aeddd 100644 --- a/functions_f.html +++ b/functions_f.html @@ -22,7 +22,7 @@
    entt -  2.1.0 +  2.2.0
    @@ -62,6 +62,9 @@ $(function() {
    Here is a list of all documented class members with links to the class documentation for each member:

    - f -

    diff --git a/functions_o.html b/functions_o.html index 8bd55d2dd..90b37bce3 100644 --- a/functions_o.html +++ b/functions_o.html @@ -22,7 +22,7 @@
    entt -  2.1.0 +  2.2.0
    @@ -62,29 +62,50 @@ $(function() {
    Here is a list of all documented class members with links to the class documentation for each member:

    - o -