From 74f3ad98f0a257058304472221f614de7c1d8b35 Mon Sep 17 00:00:00 2001 From: Michele Caini Date: Wed, 30 May 2018 22:49:40 +0200 Subject: [PATCH] API reference v2.6.0 --- README_8md_source.html | 4 +- actor_8hpp_source.html | 34 +- algorithm_8hpp_source.html | 83 + annotated.html | 72 +- bus_8hpp_source.html | 98 - cache_8hpp_source.html | 30 +- ...01Event_00_01Other_8_8_8_01_4-members.html | 91 - ...1Sig_00_01Event_00_01Other_8_8_8_01_4.html | 450 ----- ...ent_00_01Other_8_8_8_01_4__coll__graph.map | 4 - ...ent_00_01Other_8_8_8_01_4__coll__graph.md5 | 1 - ...ent_00_01Other_8_8_8_01_4__coll__graph.png | Bin 7996 -> 0 bytes ..._00_01Other_8_8_8_01_4__inherit__graph.map | 4 - ..._00_01Other_8_8_8_01_4__inherit__graph.md5 | 1 - ..._00_01Other_8_8_8_01_4__inherit__graph.png | Bin 7996 -> 0 bytes classentt_1_1Bus_3_01Sig_00_01Event_01_4.html | 437 ----- ..._01Sig_00_01Event_01_4__inherit__graph.map | 3 - ..._01Sig_00_01Event_01_4__inherit__graph.md5 | 1 - ..._01Sig_00_01Event_01_4__inherit__graph.png | Bin 5281 -> 0 bytes classentt_1_1ContinuousLoader-members.html | 32 +- classentt_1_1ContinuousLoader.html | 200 +- classentt_1_1Delegate.html | 4 +- ...ate_3_01Ret_07Args_8_8_8_08_4-members.html | 12 +- ...1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html | 74 +- classentt_1_1Dispatcher-members.html | 18 +- classentt_1_1Dispatcher.html | 279 ++- classentt_1_1Emitter-members.html | 16 +- classentt_1_1Emitter.html | 110 +- classentt_1_1Family-members.html | 4 +- classentt_1_1Family.html | 20 +- classentt_1_1HashedString-members.html | 12 +- classentt_1_1HashedString.html | 78 +- classentt_1_1PersistentView-members.html | 26 +- classentt_1_1PersistentView.html | 361 +++- classentt_1_1Process-members.html | 24 +- classentt_1_1Process.html | 154 +- classentt_1_1Prototype-members.html | 96 + classentt_1_1Prototype.html | 707 ++++++++ classentt_1_1RawView-members.html | 22 +- classentt_1_1RawView.html | 449 ++++- classentt_1_1Registry-members.html | 108 +- classentt_1_1Registry.html | 1614 ++++++++++------- classentt_1_1ResourceCache-members.html | 26 +- classentt_1_1ResourceCache.html | 166 +- classentt_1_1ResourceHandle-members.html | 18 +- classentt_1_1ResourceHandle.html | 100 +- classentt_1_1ResourceLoader-members.html | 2 +- classentt_1_1ResourceLoader.html | 2 +- classentt_1_1Scheduler-members.html | 12 +- classentt_1_1Scheduler.html | 78 +- classentt_1_1SigH.html | 6 +- ..._8_8_8_08_00_01Collector_01_4-members.html | 20 +- ...t_07Args_8_8_8_08_00_01Collector_01_4.html | 341 +--- ..._8_08_00_01Collector_01_4__coll__graph.md5 | 2 +- ..._8_08_00_01Collector_01_4__coll__graph.png | Bin 5010 -> 6315 bytes ...08_00_01Collector_01_4__inherit__graph.md5 | 2 +- ...08_00_01Collector_01_4__inherit__graph.png | Bin 5010 -> 6315 bytes ...al_3_01void_07Args_8_8_8_08_4-members.html | 94 - ..._1_1Signal_3_01void_07Args_8_8_8_08_4.html | 606 ------- ...t_1_1Signal.html => classentt_1_1Sink.html | 32 +- ...ink_3_01Ret_07Args_8_8_8_08_4-members.html | 23 +- ...ntt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html | 364 ++++ classentt_1_1Snapshot-members.html | 17 +- classentt_1_1Snapshot.html | 334 +++- classentt_1_1SnapshotLoader-members.html | 16 +- classentt_1_1SnapshotLoader.html | 168 +- classentt_1_1SparseSet.html | 4 +- ...Set_3_01Entity_00_01Type_01_4-members.html | 56 +- ..._1SparseSet_3_01Entity_00_01Type_01_4.html | 548 ++++-- ..._1_1SparseSet_3_01Entity_01_4-members.html | 40 +- classentt_1_1SparseSet_3_01Entity_01_4.html | 444 +++-- classentt_1_1View-members.html | 27 +- classentt_1_1View.html | 381 ++-- ..._01Entity_00_01Component_01_4-members.html | 26 +- ..._1View_3_01Entity_00_01Component_01_4.html | 405 +++-- classes.html | 50 +- config_8h_source.html | 78 + delegate_8hpp_source.html | 20 +- dir_66e9674e8206a335795995fa32a03c91.html | 2 +- dir_68267d1309a1af8e8297ef4c3efbcdba.html | 2 +- dir_721f6154dba3c88bcdead5f446bce319.html | 2 +- dir_7929ab29d3f740cf727ccbd263321562.html | 78 + dir_85dbee8884f1b3a817fa7eff8dff73ec.html | 2 +- dir_a53318306f6ac0f7fe657839abd543ab.html | 2 +- dir_b64489a1e8130d5ebf6d86d282f500f0.html | 2 +- dir_de8f4e6ba3f54a2a21309f742e93a373.html | 2 +- dir_e3a7bb56c55e5c2286e2fe96e197d4f5.html | 2 +- dispatcher_8hpp_source.html | 21 +- emitter_8hpp_source.html | 30 +- entt_8hpp_source.html | 4 +- entt__traits_8hpp_source.html | 4 +- family_8hpp_source.html | 10 +- files.html | 62 +- functions.html | 22 +- functions_0x7e.html | 10 +- functions_b.html | 12 +- functions_c.html | 75 +- functions_d.html | 42 +- functions_e.html | 51 +- functions_f.html | 8 +- functions_func.html | 22 +- functions_func_0x7e.html | 10 +- functions_func_b.html | 12 +- functions_func_c.html | 68 +- functions_func_d.html | 39 +- functions_func_e.html | 48 +- functions_func_f.html | 8 +- functions_func_g.html | 19 +- functions_func_h.html | 13 +- functions_func_l.html | 4 +- functions_func_m.html | 4 +- functions_func_o.html | 42 +- functions_func_p.html | 14 +- functions_func_r.html | 44 +- functions_func_s.html | 48 +- functions_func_t.html | 16 +- functions_func_u.html | 17 +- functions_func_v.html | 8 +- functions_g.html | 19 +- functions_h.html | 13 +- functions_i.html | 5 +- functions_l.html | 4 +- functions_m.html | 4 +- functions_o.html | 40 +- functions_p.html | 14 +- functions_r.html | 49 +- functions_rela.html | 6 +- functions_s.html | 63 +- functions_t.html | 16 +- functions_type.html | 32 +- functions_u.html | 17 +- functions_v.html | 8 +- functions_vars.html | 2 +- graph_legend.html | 2 +- handle_8hpp_source.html | 14 +- hashed__string_8hpp_source.html | 16 +- helper_8hpp_source.html | 83 + hierarchy.html | 93 +- ident_8hpp_source.html | 6 +- index.html | 374 ++-- inherit_graph_0.map | 2 +- inherit_graph_0.md5 | 2 +- inherit_graph_0.png | Bin 2118 -> 1607 bytes inherit_graph_1.map | 2 +- inherit_graph_1.md5 | 2 +- inherit_graph_1.png | Bin 1566 -> 1047 bytes inherit_graph_10.map | 2 +- inherit_graph_10.md5 | 2 +- inherit_graph_10.png | Bin 2036 -> 1983 bytes inherit_graph_11.map | 2 +- inherit_graph_11.md5 | 2 +- inherit_graph_11.png | Bin 1983 -> 1851 bytes inherit_graph_12.map | 2 +- inherit_graph_12.md5 | 2 +- inherit_graph_12.png | Bin 1851 -> 1336 bytes inherit_graph_13.map | 2 +- inherit_graph_13.md5 | 2 +- inherit_graph_13.png | Bin 1336 -> 1633 bytes inherit_graph_14.map | 2 +- inherit_graph_14.md5 | 2 +- inherit_graph_14.png | Bin 1633 -> 1281 bytes inherit_graph_15.map | 2 +- inherit_graph_15.md5 | 2 +- inherit_graph_15.png | Bin 2696 -> 1138 bytes inherit_graph_16.map | 2 +- inherit_graph_16.md5 | 2 +- inherit_graph_16.png | Bin 2274 -> 2696 bytes inherit_graph_17.map | 3 +- inherit_graph_17.md5 | 2 +- inherit_graph_17.png | Bin 7482 -> 2274 bytes inherit_graph_18.map | 3 +- inherit_graph_18.md5 | 2 +- inherit_graph_18.png | Bin 2626 -> 7482 bytes inherit_graph_19.map | 2 +- inherit_graph_19.md5 | 2 +- inherit_graph_19.png | Bin 1730 -> 1637 bytes inherit_graph_2.map | 4 +- inherit_graph_2.md5 | 2 +- inherit_graph_2.png | Bin 6493 -> 2271 bytes inherit_graph_20.map | 2 +- inherit_graph_20.md5 | 2 +- inherit_graph_20.png | Bin 2193 -> 1090 bytes inherit_graph_21.map | 2 +- inherit_graph_21.md5 | 2 +- inherit_graph_21.png | Bin 2056 -> 2626 bytes inherit_graph_22.map | 2 +- inherit_graph_22.md5 | 2 +- inherit_graph_22.png | Bin 2161 -> 1730 bytes inherit_graph_23.map | 2 +- inherit_graph_23.md5 | 2 +- inherit_graph_23.png | Bin 1819 -> 2193 bytes inherit_graph_24.map | 2 +- inherit_graph_24.md5 | 2 +- inherit_graph_24.png | Bin 2059 -> 2056 bytes inherit_graph_25.map | 2 +- inherit_graph_25.md5 | 2 +- inherit_graph_25.png | Bin 2332 -> 2161 bytes inherit_graph_26.map | 2 +- inherit_graph_26.md5 | 2 +- inherit_graph_26.png | Bin 2781 -> 1819 bytes inherit_graph_27.map | 2 +- inherit_graph_27.md5 | 2 +- inherit_graph_27.png | Bin 1878 -> 2059 bytes inherit_graph_28.map | 2 +- inherit_graph_28.md5 | 2 +- inherit_graph_28.png | Bin 2827 -> 2332 bytes inherit_graph_29.map | 2 +- inherit_graph_29.md5 | 2 +- inherit_graph_29.png | Bin 1954 -> 3872 bytes inherit_graph_3.map | 2 +- inherit_graph_3.md5 | 2 +- inherit_graph_3.png | Bin 2271 -> 2308 bytes inherit_graph_30.map | 2 +- inherit_graph_30.md5 | 2 +- inherit_graph_30.png | Bin 2414 -> 2675 bytes inherit_graph_31.map | 3 +- inherit_graph_31.md5 | 2 +- inherit_graph_31.png | Bin 3584 -> 1767 bytes inherit_graph_32.map | 2 +- inherit_graph_32.md5 | 2 +- inherit_graph_32.png | Bin 2545 -> 2140 bytes inherit_graph_33.map | 2 +- inherit_graph_33.md5 | 2 +- inherit_graph_33.png | Bin 1551 -> 1954 bytes inherit_graph_34.map | 2 +- inherit_graph_34.md5 | 2 +- inherit_graph_34.png | Bin 2384 -> 2414 bytes inherit_graph_35.map | 3 +- inherit_graph_35.md5 | 2 +- inherit_graph_35.png | Bin 2384 -> 3584 bytes inherit_graph_36.map | 3 + inherit_graph_36.md5 | 1 + inherit_graph_36.png | Bin 0 -> 1551 bytes inherit_graph_37.map | 3 + inherit_graph_37.md5 | 1 + inherit_graph_37.png | Bin 0 -> 1250 bytes inherit_graph_38.map | 3 + inherit_graph_38.md5 | 1 + inherit_graph_38.png | Bin 0 -> 965 bytes inherit_graph_39.map | 3 + inherit_graph_39.md5 | 1 + inherit_graph_39.png | Bin 0 -> 2384 bytes inherit_graph_4.map | 2 +- inherit_graph_4.md5 | 2 +- inherit_graph_4.png | Bin 2308 -> 1844 bytes inherit_graph_40.map | 3 + inherit_graph_40.md5 | 1 + inherit_graph_40.png | Bin 0 -> 2384 bytes inherit_graph_5.map | 2 +- inherit_graph_5.md5 | 2 +- inherit_graph_5.png | Bin 1844 -> 1425 bytes inherit_graph_6.map | 2 +- inherit_graph_6.md5 | 2 +- inherit_graph_6.png | Bin 2047 -> 1508 bytes inherit_graph_7.map | 2 +- inherit_graph_7.md5 | 2 +- inherit_graph_7.png | Bin 1508 -> 3863 bytes inherit_graph_8.map | 2 +- inherit_graph_8.md5 | 2 +- inherit_graph_8.png | Bin 3863 -> 1908 bytes inherit_graph_9.map | 2 +- inherit_graph_9.md5 | 2 +- inherit_graph_9.png | Bin 1908 -> 2036 bytes inherits.html | 139 +- loader_8hpp_source.html | 6 +- locator_8hpp_source.html | 14 +- namespaceentt.html | 457 +++-- namespacemembers.html | 24 +- namespacemembers_func.html | 7 +- namespacemembers_type.html | 19 +- namespacemembers_vars.html | 2 +- namespaces.html | 2 +- process_8hpp_source.html | 36 +- prototype_8hpp_source.html | 93 + registry_8hpp_source.html | 130 +- scheduler_8hpp_source.html | 28 +- search/all_0.js | 14 +- search/all_1.js | 7 +- search/all_10.js | 9 +- search/all_11.js | 6 +- search/all_12.js | 8 +- search/all_2.js | 25 +- search/all_3.js | 23 +- search/all_4.js | 19 +- search/all_5.js | 4 +- search/all_6.js | 2 +- search/all_7.js | 6 +- search/all_8.js | 5 +- search/all_9.js | 2 +- search/all_a.js | 4 +- search/all_b.js | 22 +- search/all_c.js | 9 +- search/all_d.js | 28 +- search/all_e.js | 30 +- search/all_f.js | 9 +- search/classes_1.js | 5 +- search/classes_7.js | 5 +- search/classes_8.js | 11 +- search/classes_9.js | 18 +- search/classes_a.js | 15 +- search/{typedefs_d.html => classes_b.html} | 2 +- search/classes_b.js | 4 + search/{typedefs_e.html => classes_c.html} | 2 +- search/classes_c.js | 5 + search/functions_0.js | 14 +- search/functions_1.js | 2 +- search/functions_10.js | 6 +- search/functions_11.js | 8 +- search/functions_2.js | 24 +- search/functions_3.js | 17 +- search/functions_4.js | 17 +- search/functions_5.js | 4 +- search/functions_6.js | 2 +- search/functions_7.js | 6 +- search/functions_8.js | 2 +- search/functions_9.js | 2 +- search/functions_a.js | 22 +- search/functions_b.js | 7 +- search/functions_c.js | 25 +- search/functions_d.js | 18 +- search/functions_e.js | 8 +- search/functions_f.js | 7 +- search/related_2.js | 3 +- search/searchdata.js | 4 +- search/typedefs_0.js | 3 +- search/typedefs_1.js | 5 +- search/typedefs_2.js | 2 +- search/typedefs_5.js | 4 +- search/typedefs_7.js | 3 +- search/typedefs_8.js | 2 +- search/typedefs_9.js | 4 +- search/typedefs_a.js | 6 +- search/typedefs_b.js | 3 +- search/typedefs_c.js | 2 +- search/typedefs_d.js | 5 - search/typedefs_e.js | 4 - sigh_8hpp_source.html | 41 +- signal_8hpp_source.html | 94 - snapshot_8hpp_source.html | 59 +- sparse__set_8hpp_source.html | 79 +- structentt_1_1Actor-members.html | 44 +- structentt_1_1Actor.html | 903 +++++---- ...entt_1_1Emitter_1_1Connection-members.html | 4 +- structentt_1_1Emitter_1_1Connection.html | 18 +- structentt_1_1InsertionSort-members.html | 82 + structentt_1_1InsertionSort.html | 166 ++ structentt_1_1ProcessAdaptor-members.html | 26 +- structentt_1_1ProcessAdaptor.html | 90 +- structentt_1_1ServiceLocator-members.html | 8 +- structentt_1_1ServiceLocator.html | 52 +- structentt_1_1StdSort-members.html | 82 + structentt_1_1StdSort.html | 168 ++ ...1_1Bus.html => structentt_1_1break__t.html | 26 +- structentt_1_1entt__traits.html | 2 +- ...its_3_01std_1_1uint16__t_01_4-members.html | 2 +- ...ntt__traits_3_01std_1_1uint16__t_01_4.html | 2 +- ...its_3_01std_1_1uint32__t_01_4-members.html | 2 +- ...ntt__traits_3_01std_1_1uint32__t_01_4.html | 2 +- ...its_3_01std_1_1uint64__t_01_4-members.html | 2 +- ...ntt__traits_3_01std_1_1uint64__t_01_4.html | 2 +- structentt_1_1persistent__t.html | 90 + structentt_1_1raw__t.html | 90 + structentt_1_1tag__t.html | 90 + utility_8hpp_source.html | 83 + view_8hpp_source.html | 155 +- 364 files changed, 9411 insertions(+), 6722 deletions(-) create mode 100644 algorithm_8hpp_source.html delete mode 100644 bus_8hpp_source.html delete mode 100644 classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4-members.html delete mode 100644 classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4.html delete mode 100644 classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4__coll__graph.map delete mode 100644 classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4__coll__graph.md5 delete mode 100644 classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4__coll__graph.png delete mode 100644 classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4__inherit__graph.map delete mode 100644 classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4__inherit__graph.md5 delete mode 100644 classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4__inherit__graph.png delete mode 100644 classentt_1_1Bus_3_01Sig_00_01Event_01_4.html delete mode 100644 classentt_1_1Bus_3_01Sig_00_01Event_01_4__inherit__graph.map delete mode 100644 classentt_1_1Bus_3_01Sig_00_01Event_01_4__inherit__graph.md5 delete mode 100644 classentt_1_1Bus_3_01Sig_00_01Event_01_4__inherit__graph.png create mode 100644 classentt_1_1Prototype-members.html create mode 100644 classentt_1_1Prototype.html delete mode 100644 classentt_1_1Signal_3_01void_07Args_8_8_8_08_4-members.html delete mode 100644 classentt_1_1Signal_3_01void_07Args_8_8_8_08_4.html rename classentt_1_1Signal.html => classentt_1_1Sink.html (73%) rename classentt_1_1Bus_3_01Sig_00_01Event_01_4-members.html => classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4-members.html (51%) create mode 100644 classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html create mode 100644 config_8h_source.html create mode 100644 dir_7929ab29d3f740cf727ccbd263321562.html create mode 100644 helper_8hpp_source.html create mode 100644 inherit_graph_36.map create mode 100644 inherit_graph_36.md5 create mode 100644 inherit_graph_36.png create mode 100644 inherit_graph_37.map create mode 100644 inherit_graph_37.md5 create mode 100644 inherit_graph_37.png create mode 100644 inherit_graph_38.map create mode 100644 inherit_graph_38.md5 create mode 100644 inherit_graph_38.png create mode 100644 inherit_graph_39.map create mode 100644 inherit_graph_39.md5 create mode 100644 inherit_graph_39.png create mode 100644 inherit_graph_40.map create mode 100644 inherit_graph_40.md5 create mode 100644 inherit_graph_40.png create mode 100644 prototype_8hpp_source.html rename search/{typedefs_d.html => classes_b.html} (94%) create mode 100644 search/classes_b.js rename search/{typedefs_e.html => classes_c.html} (94%) create mode 100644 search/classes_c.js delete mode 100644 search/typedefs_d.js delete mode 100644 search/typedefs_e.js delete mode 100644 signal_8hpp_source.html create mode 100644 structentt_1_1InsertionSort-members.html create mode 100644 structentt_1_1InsertionSort.html create mode 100644 structentt_1_1StdSort-members.html create mode 100644 structentt_1_1StdSort.html rename classentt_1_1Bus.html => structentt_1_1break__t.html (69%) create mode 100644 structentt_1_1persistent__t.html create mode 100644 structentt_1_1raw__t.html create mode 100644 structentt_1_1tag__t.html create mode 100644 utility_8hpp_source.html diff --git a/README_8md_source.html b/README_8md_source.html index ef2f31936..b0fba8acb 100644 --- a/README_8md_source.html +++ b/README_8md_source.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.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 # Table of Contents
9 
10 * [Introduction](#introduction)
11 * [Build Instructions](#build-instructions)
12 * [Crash Course: entity-component system](#crash-course-entity-component-system)
13  * [Design choices](#design-choices)
14  * [A bitset-free entity-component system](#a-bitset-free-entity-component-system)
15  * [Pay per use](#pay-per-use)
16  * [Vademecum](#vademecum)
17  * [The Registry, the Entity and the Component](#the-registry-the-entity-and-the-component)
18  * [Single instance components](#single-instance-components)
19  * [Runtime components](#runtime-components)
20  * [A journey through a plugin](#a-journey-through-a-plugin)
21  * [Sorting: is it possible?](#sorting-is-it-possible)
22  * [Snapshot: complete vs continuous](#snapshot-complete-vs-continuous)
23  * [Snapshot loader](#snapshot-loader)
24  * [Continuous loader](#continuous-loader)
25  * [Archives](#archives)
26  * [One example to rule them all](#one-example-to-rule-them-all)
27  * [View: to persist or not to persist?](#view-to-persist-or-not-to-persist)
28  * [Standard View](#standard-view)
29  * [Single component standard view](#single-component-standard-view)
30  * [Multi component standard view](#multi-component-standard-view)
31  * [Persistent View](#persistent-view)
32  * [Raw View](#raw-view)
33  * [Give me everything](#give-me-everything)
34  * [Side notes](#side-notes)
35 * [Crash Course: core functionalities](#crash-course-core-functionalities)
36  * [Compile-time identifiers](#compile-time-identifiers)
37  * [Runtime identifiers](#runtime-identifiers)
38  * [Hashed strings](#hashed-strings)
39 * [Crash Course: service locator](#crash-course-service-locator)
40 * [Crash Course: cooperative scheduler](#crash-course-cooperative-scheduler)
41  * [The process](#the-process)
42  * [The scheduler](#the-scheduler)
43 * [Crash Course: resource management](#crash-course-resource-management)
44  * [The resource, the loader and the cache](#the-resource-the-loader-and-the-cache)
45 * [Crash Course: events, signals and everything in between](#crash-course-events-signals-and-everything-in-between)
46  * [Signals](#signals)
47  * [Compile-time event bus](#compile-time-event-bus)
48  * [Delegate](#delegate)
49  * [Event dispatcher](#event-dispatcher)
50  * [Event emitter](#event-emitter)
51 * [License](#license)
52 * [Support](#support)
53  * [Donation](#donation)
54  * [Hire me](#hire-me)
55 
56 # Introduction
57 
58 `EnTT` is a header-only, tiny and easy to use framework written in modern
59 C++.<br/>
60 It was originally designed entirely around an architectural pattern called _ECS_
61 that is used mostly in game development. For further details:
62 
63 * [Entity Systems Wiki](http://entity-systems.wikidot.com/)
64 * [Evolve Your Hierarchy](http://cowboyprogramming.com/2007/01/05/evolve-your-heirachy/)
65 * [ECS on Wikipedia](https://en.wikipedia.org/wiki/Entity%E2%80%93component%E2%80%93system)
66 
67 A long time ago, the sole entity-component system was part of the project. After
68 a while the codebase has grown and more and more classes have become part of the
69 repository.<br/>
70 That's why today it's called _the EnTT Framework_.
71 
72 Currently, `EnTT` is tested on Linux, Microsoft Windows and OS X. It has proven
73 to work also on both Android and iOS.<br/>
74 Most likely it will not be problematic on other systems as well, but has not
75 been sufficiently tested so far.
76 
77 ## The framework
78 
79 `EnTT` was written initially as a faster alternative to other well known and
80 open source entity-component systems. Nowadays the `EnTT` framework is moving
81 its first steps. Much more will come in the future and hopefully I'm going to
82 work on it for a long time.<br/>
83 Requests for feature, PR, suggestions ad feedback are highly appreciated.
84 
85 If you find you can help me and want to contribute to the `EnTT` framework with
86 your experience or you do want to get part of the project for some other
87 reasons, feel free to contact me directly (you can find the mail in the
88 [profile](https://github.com/skypjack)).<br/>
89 I can't promise that each and every contribution will be accepted, but I can
90 assure that I'll do my best to take them all seriously.
91 
92 ### State of the art
93 
94 Here is a brief list of what it offers today:
95 
96 * Statically generated integer identifiers for types (assigned either at
97  compile-time or at runtime).
98 * A constexpr utility for human readable resource identifiers.
99 * An incredibly fast entity-component system based on sparse sets, with its own
100  views and a _pay for what you use_ policy to adjust performance and memory
101  usage according to the users' requirements.
102 * Actor class for those who aren't confident with entity-component systems.
103 * The smallest and most basic implementation of a service locator ever seen.
104 * A cooperative scheduler for processes of any type.
105 * All what is needed for resource management (cache, loaders, handles).
106 * Signal handlers of any type, delegates and an event bus.
107 * A general purpose event emitter, that is a CRTP idiom based class template.
108 * An event dispatcher for immediate and delayed events to integrate in loops.
109 * ...
110 * Any other business.
111 
112 Consider it a work in progress. For more details and an updated list, please
113 refer to the [online documentation](https://skypjack.github.io/entt/). It
114 probably contains much more. Moreover, the whole API is fully documented in-code
115 for those who are brave enough to read it.<br/>
116 Continue reading to know how the different parts of the project work or follow
117 the link above to take a look at the API reference.
118 
119 ## Code Example
120 
121 ```cpp
122 #include <entt/entt.hpp>
123 #include <cstdint>
124 
125 struct Position {
126  float x;
127  float y;
128 };
129 
130 struct Velocity {
131  float dx;
132  float dy;
133 };
134 
135 void update(entt::DefaultRegistry &registry) {
136  auto view = registry.view<Position, Velocity>();
137 
138  for(auto entity: view) {
139  // gets only the components that are going to be used ...
140 
141  auto &velocity = view.get<Velocity>(entity);
142 
143  velocity.dx = 0.;
144  velocity.dy = 0.;
145 
146  // ...
147  }
148 }
149 
150 void update(std::uint64_t dt, entt::DefaultRegistry &registry) {
151  registry.view<Position, Velocity>().each([dt](auto entity, auto &position, auto &velocity) {
152  // gets all the components of the view at once ...
153 
154  position.x += velocity.dx * dt;
155  position.y += velocity.dy * dt;
156 
157  // ...
158  });
159 }
160 
161 int main() {
162  entt::DefaultRegistry registry;
163  std::uint64_t dt = 16;
164 
165  for(auto i = 0; i < 10; ++i) {
166  auto entity = registry.create(Position{i * 1.f, i * 1.f});
167  if(i % 2 == 0) { registry.assign<Velocity>(entity, i * .1f, i * .1f); }
168  }
169 
170  update(dt, registry);
171  update(registry);
172 
173  // ...
174 }
175 ```
176 
177 ## Motivation
178 
179 I started working on `EnTT` because of the wrong reason: my goal was to design
180 an entity-component system that beated another well known open source solution
181 in terms of performance and used (possibly) less memory in the average
182 case.<br/>
183 In the end, I did it, but it wasn't much satisfying. Actually it wasn't
184 satisfying at all. The fastest and nothing more, fairly little indeed. When I
185 realized it, I tried hard to keep intact the great performance of `EnTT` and to
186 add all the features I wanted to see in *my own library* at the same time.
187 
188 Today `EnTT` is finally what I was looking for: still faster than its
189 _competitors_, lower memory usage in the average case, a really good API and an
190 amazing set of features. And even more, of course.
191 
192 ## Performance
193 
194 As it stands right now, `EnTT` is just fast enough for my requirements if
195 compared to my first choice (it was already amazingly fast actually).<br/>
196 Below is a comparison between the two (both of them compiled with GCC 7.3.0 on a
197 Dell XPS 13 out of the mid 2014):
198 
199 | Benchmark | EntityX (compile-time) | EnTT |
200 |-----------|-------------|-------------|
201 | Create 1M entities | 0.0167s | **0.0046s** |
202 | Destroy 1M entities | 0.0053s | **0.0039s** |
203 | Standard view, 1M entities, one component | 0.0012s | **1.9e-07s** |
204 | Standard view, 1M entities, two components | 0.0012s | **3.8e-07s** |
205 | Standard view, 1M entities, two components<br/>Half of the entities have all the components | 0.0009s | **3.8e-07s** |
206 | Standard view, 1M entities, two components<br/>One of the entities has all the components | 0.0008s | **1.0e-06s** |
207 | Persistent view, 1M entities, two components | 0.0012s | **2.8e-07s** |
208 | Standard view, 1M entities, five components | 0.0010s | **7.0e-07s** |
209 | Persistent view, 1M entities, five components | 0.0010s | **2.8e-07s** |
210 | Standard view, 1M entities, ten components | 0.0011s | **1.2e-06s** |
211 | Standard view, 1M entities, ten components<br/>Half of the entities have all the components | 0.0010s | **1.2e-06s** |
212 | Standard view, 1M entities, ten components<br/>One of the entities has all the components | 0.0008s | **1.2e-06s** |
213 | Persistent view, 1M entities, ten components | 0.0011s | **3.0e-07s** |
214 | Raw view, 1M entities | - | **2.2e-07s** |
215 | Sort 150k entities, one component<br/>Arrays are in reverse order | - | **0.0036s** |
216 | Sort 150k entities, enforce permutation<br/>Arrays are in reverse order | - | **0.0005s** |
217 
218 Note: The default version of `EntityX` (`master` branch) wasn't added to the
219 comparison because it's already much slower than its compile-time counterpart.
220 
221 Pretty interesting, aren't them? In fact, these benchmarks are the same used by
222 `EntityX` to show _how fast it is_. To be honest, they aren't so good and these
223 results shouldn't be taken much seriously (they are completely unrealistic
224 indeed).<br/>
225 The proposed entity-component system is incredibly fast to iterate entities,
226 this is a fact. The compiler can make a lot of optimizations because of how
227 `EnTT` works, even more when components aren't used at all. This is exactly the
228 case for these benchmarks.<br/>
229 This is why they are completely wrong and cannot be used to evaluate any of the
230 entity-component systems.
231 
232 If you decide to use `EnTT`, choose it because of its API and its performance,
233 not because there is a benchmark somewhere that makes it seem the fastest.
234 
235 Probably I'll try to get out of `EnTT` more features and even better performance
236 in the future, mainly for fun.<br/>
237 If you want to contribute and/or have any suggestion, feel free to make a PR or
238 open an issue to discuss your idea.
239 
240 # Build Instructions
241 
242 ## Requirements
243 
244 To be able to use `EnTT`, users must provide a full-featured compiler that
245 supports at least C++14.<br/>
246 The requirements below are mandatory to compile the tests and to extract the
247 documentation:
248 
249 * CMake version 3.2 or later.
250 * Doxygen version 1.8 or later.
251 
252 ## Library
253 
254 `EnTT` is a header-only library. This means that including the `entt.hpp`
255 header is enough to include the whole framework and use it. For those who are
256 interested only in the entity-component system, consider to include the sole
257 `entity/registry.hpp` header instead.<br/>
258 It's a matter of adding the following line to the top of a file:
259 
260 ```cpp
261 #include <entt/entt.hpp>
262 ```
263 
264 Use the line below to include only the entity-component system instead:
265 
266 ```cpp
267 #include <entt/entity/registry.hpp>
268 ```
269 
270 Then pass the proper `-I` argument to the compiler to add the `src` directory to
271 the include paths.
272 
273 ## Documentation
274 
275 The documentation is based on [doxygen](http://www.stack.nl/~dimitri/doxygen/).
276 To build it:
277 
278  $ cd build
279  $ cmake ..
280  $ make docs
281 
282 The API reference will be created in HTML format within the directory
283 `build/docs/html`. To navigate it with your favorite browser:
284 
285  $ cd build
286  $ your_favorite_browser docs/html/index.html
287 
288 The API reference is also available [online](https://skypjack.github.io/entt/)
289 for the latest version.
290 
291 ## Tests
292 
293 To compile and run the tests, `EnTT` requires *googletest*.<br/>
294 `cmake` will download and compile the library before to compile anything else.
295 
296 To build the most basic set of tests:
297 
298 * `$ cd build`
299 * `$ cmake ..`
300 * `$ make`
301 * `$ make test`
302 
303 Note that benchmarks are not part of this set.
304 
305 # Crash Course: entity-component system
306 
307 ## Design choices
308 
309 ### A bitset-free entity-component system
310 
311 `EnTT` is a _bitset-free_ entity-component system that doesn't require users to
312 specify the component set at compile-time.<br/>
313 This is why users can instantiate the core class simply like:
314 
315 ```cpp
316 entt::DefaultRegistry registry;
317 ```
318 
319 In place of its more annoying and error-prone counterpart:
320 
321 ```cpp
322 entt::DefaultRegistry<Comp0, Comp1, ..., CompN> registry;
323 ```
324 
325 ### Pay per use
326 
327 `EnTT` is entirely designed around the principle that users have to pay only for
328 what they want.
329 
330 When it comes to using an entity-component system, the tradeoff is usually
331 between performance and memory usage. The faster it is, the more memory it uses.
332 However, slightly worse performance along non-critical paths are the right price
333 to pay to reduce memory usage and I've always wondered why this kind of tools do
334 not leave me the choice.<br/>
335 `EnTT` follows a completely different approach. It squeezes the best from the
336 basic data structures and gives users the possibility to pay more for higher
337 performance where needed.<br/>
338 The disadvantage of this approach is that users need to know the systems they
339 are working on and the tools they are using. Otherwise, the risk to ruin the
340 performance along critical paths is high.
341 
342 So far, this choice has proven to be a good one and I really hope it can be for
343 many others besides me.
344 
345 ## Vademecum
346 
347 The `Registry` to store, the views to iterate. That's all.
348 
349 An entity (the _E_ of an _ECS_) is an opaque identifier that users should just
350 use as-is and store around if needed. Do not try to inspect an entity
351 identifier, its format can change in future and a registry offers all the
352 functionalities to query them out-of-the-box. The underlying type of an entity
353 (either `std::uint16_t`, `std::uint32_t` or `std::uint64_t`) can be specified
354 when defining a registry (actually the `DefaultRegistry` is nothing more than a
355 `Registry` where the type of the entities is `std::uint32_t`).<br/>
356 Components (the _C_ of an _ECS_) should be plain old data structures or more
357 complex and movable data structures with a proper constructor. Actually, the
358 sole requirement of a component type is that it must be both move constructible
359 and move assignable. They are list initialized by using the parameters provided
360 to construct the component itself. No need to register components or their types
361 neither with the registry nor with the entity-component system at all.<br/>
362 Systems (the _S_ of an _ECS_) are just plain functions, functors, lambdas or
363 whatever the users want. They can accept a `Registry` or a view of any type and
364 use them the way they prefer. No need to register systems or their types neither
365 with the registry nor with the entity-component system at all.
366 
367 The following sections will explain in short how to use the entity-component
368 system, the core part of the whole framework.<br/>
369 In fact, the framework is composed of many other classes in addition to those
370 describe below. For more details, please refer to the
371 [online documentation](https://skypjack.github.io/entt/).
372 
373 ## The Registry, the Entity and the Component
374 
375 A registry can store and manage entities, as well as create views to iterate the
376 underlying data structures.<br/>
377 `Registry` is a class template that lets the users decide what's the preferred
378 type to represent an entity. Because `std::uint32_t` is large enough for almost
379 all the cases, there exists also an alias named `DefaultRegistry` for
380 `Registry<std::uint32_t>`.
381 
382 Entities are represented by _entity identifiers_. An entity identifier is an
383 opaque type that users should not inspect or modify in any way. It carries
384 information about the entity itself and its version.
385 
386 A registry can be used both to construct and to destroy entities:
387 
388 ```cpp
389 // constructs a naked entity with no components and returns its identifier
390 auto entity = registry.create();
391 
392 // constructs an entity and assigns it default-initialized components
393 auto another = registry.create<Position, Velocity>();
394 
395 // destroys an entity and all its components
396 registry.destroy(entity);
397 ```
398 
399 Once an entity is deleted, the registry can freely reuse it internally with a
400 slightly different identifier. In particular, the version of an entity is
401 increased each and every time it's destroyed.<br/>
402 In case entity identifiers are stored around, the registry offers all the
403 functionalities required to test them and get out of the them all the
404 information they carry:
405 
406 ```cpp
407 // returns true if the entity is still valid, false otherwise
408 bool b = registry.valid(entity);
409 
410 // gets the version contained in the entity identifier
411 auto version = registry.version(entity);
412 
413 // gets the actual version for the given entity
414 auto curr = registry.current(entity);
415 ```
416 
417 Components can be assigned to or removed from entities at any time with a few
418 calls to member functions of the registry. As for the entities, the registry
419 offers also a set of functionalities users can use to work with the components.
420 
421 The `assign` member function template creates, initializes and assigns to an
422 entity the given component. It accepts a variable number of arguments to
423 construct the component itself if present:
424 
425 ```cpp
426 registry.assign<Position>(entity, 0., 0.);
427 
428 // ...
429 
430 Velocity &velocity = registry.assign<Velocity>(entity);
431 velocity.dx = 0.;
432 velocity.dy = 0.;
433 ```
434 
435 If an entity already has the given component, the `replace` member function
436 template can be used to replace it:
437 
438 ```cpp
439 registry.replace<Position>(entity, 0., 0.);
440 
441 // ...
442 
443 Velocity &velocity = registry.replace<Velocity>(entity);
444 velocity.dx = 0.;
445 velocity.dy = 0.;
446 ```
447 
448 In case users want to assign a component to an entity, but it's unknown whether
449 the entity already has it or not, `accommodate` does the work in a single call
450 (there is a performance penalty to pay for this mainly due to the fact that it
451 has to check if the entity already has the given component or not):
452 
453 ```cpp
454 registry.accommodate<Position>(entity, 0., 0.);
455 
456 // ...
457 
458 Velocity &velocity = registry.accommodate<Velocity>(entity);
459 velocity.dx = 0.;
460 velocity.dy = 0.;
461 ```
462 
463 Note that `accommodate` is a slightly faster alternative for the following
464 `if`/`else` statement and nothing more:
465 
466 ```cpp
467 if(registry.has<Comp>(entity)) {
468  registry.replace<Comp>(entity, arg1, argN);
469 } else {
470  registry.assign<Comp>(entity, arg1, argN);
471 }
472 ```
473 
474 As already shown, if in doubt about whether or not an entity has one or more
475 components, the `has` member function template may be useful:
476 
477 ```cpp
478 bool b = registry.has<Position, Velocity>(entity);
479 ```
480 
481 On the other side, if the goal is to delete a single component, the `remove`
482 member function template is the way to go when it's certain that the entity owns
483 a copy of the component:
484 
485 ```cpp
486 registry.remove<Position>(entity);
487 ```
488 
489 Otherwise consider to use the `reset` member function. It behaves similarly to
490 `remove` but with a strictly defined behavior (and a performance penalty is the
491 price to pay for this). In particular it removes the component if and only if it
492 exists, otherwise it returns safely to the caller:
493 
494 ```cpp
495 registry.reset<Position>(entity);
496 ```
497 
498 There exist also two other _versions_ of the `reset` member function:
499 
500 * If no entity is passed to it, `reset` will remove the given component from
501  each entity that has it:
502 
503  ```cpp
504  registry.reset<Position>();
505  ```
506 
507 * If neither the entity nor the component are specified, all the entities still
508  in use and their components are destroyed:
509 
510  ```cpp
511  registry.reset();
512  ```
513 
514 Finally, references to components can be retrieved simply by doing this:
515 
516 ```cpp
517 const auto &cregistry = registry;
518 
519 // const and non-const reference
520 const Position &position = cregistry.get<Position>(entity);
521 Position &position = registry.get<Position>(entity);
522 
523 // const and non-const references
524 std::tuple<const Position &, const Velocity &> tup = cregistry.get<Position, Velocity>(entity);
525 std::tuple<Position &, Velocity &> tup = registry.get<Position, Velocity>(entity);
526 ```
527 
528 The `get` member function template gives direct access to the component of an
529 entity stored in the underlying data structures of the registry.
530 
531 ### Single instance components
532 
533 In those cases where all what is needed is a single instance component, tags are
534 the right tool to achieve the purpose.<br/>
535 Tags undergo the same requirements of components. They can be either plain old
536 data structures or more complex and movable data structures with a proper
537 constructor.<br/>
538 Actually, the same type can be used both as a tag and as a component and the
539 registry will not complain about it. It is up to the users to properly manage
540 their own types.
541 
542 Attaching tags to entities and removing them is trivial:
543 
544 ```cpp
545 auto player = registry.create();
546 auto camera = registry.create();
547 
548 // attaches a default-initialized tag to an entity
549 registry.attach<PlayingCharacter>(player);
550 
551 // attaches a tag to an entity and initializes it
552 registry.attach<Camera>(camera, player);
553 
554 // removes tags from their owners
555 registry.remove<PlayingCharacter>();
556 registry.remove<Camera>();
557 ```
558 
559 In case a tag already has an owner, its content can be updated by means of the
560 `set` member function template and the ownership of the tag can be transferred
561 to another entity using the `move` member function template:
562 
563 ```
564 // replaces the content of the given tag
565 Point &point = registry.set<Point>(1.f, 1.f);
566 
567 // transfers the ownership of the tag to another entity
568 entity_type prev = registry.move<Point>(next);
569 ```
570 
571 If in doubt about whether or not a tag already has an owner, the `has` member
572 function template may be useful:
573 
574 ```cpp
575 bool b = registry.has<PlayingCharacter>();
576 ```
577 
578 References to tags can be retrieved simply by doing this:
579 
580 ```cpp
581 const auto &cregistry = registry;
582 
583 // either a non-const reference ...
584 PlayingCharacter &player = registry.get<PlayingCharacter>();
585 
586 // ... or a const one
587 const Camera &camera = cregistry.get<Camera>();
588 ```
589 
590 The `get` member function template gives direct access to the tag as stored in
591 the underlying data structures of the registry.
592 
593 As shown above, in almost all the cases the entity identifier isn't required.
594 Since a single instance component can have only one associated entity, it
595 doesn't make much sense to mention it explicitly.<br/>
596 To find out who the owner is, just do the following:
597 
598 ```cpp
599 auto player = registry.attachee<PlayingCharacter>();
600 ```
601 
602 Note that iterating tags isn't possible for obvious reasons. Tags give direct
603 access to single entities and nothing more.
604 
605 ### Runtime components
606 
607 Defining components at runtime is useful to support plugins and mods in general.
608 However, it seems impossible with a tool designed around a bunch of templates.
609 Indeed it's not that difficult.<br/>
610 Of course, some features cannot be easily exported into a runtime
611 environment. As an example, sorting a group of components defined at runtime
612 isn't for free if compared to most of the other operations. However, the basic
613 functionalities of an entity-component system such as `EnTT` fit the problem
614 perfectly and can also be used to manage runtime components if required.<br/>
615 All that is necessary to do it is to know the identifiers of the components. An
616 identifier is nothing more than a number or similar that can be used at runtime
617 to work with the type system.
618 
619 In `EnTT`, identifiers are easily accessible:
620 
621 ```cpp
622 entt::DefaultRegistry registry;
623 
624 // standard component identifier
625 auto ctype = registry.component<Position>();
626 
627 // single instance component identifier
628 auto ttype = registry.tag<PlayingCharacter>();
629 ```
630 
631 Once the identifiers are made available, almost everything becomes pretty
632 simple.
633 
634 #### A journey through a plugin
635 
636 `EnTT` comes with an example (actually a test) that shows how to integrate
637 compile-time and runtime components in a stack based JavaScript environment. It
638 uses [`Duktape`](https://github.com/svaarala/duktape) under the hood, mainly
639 because I wanted to learn how it works at the time I was writing the code.
640 
641 The code is not production-ready and overall performance can be highly improved.
642 However, I sacrificed optimizations in favor of a more readable piece of code. I
643 hope I succeeded.<br/>
644 Note also that this isn't neither the only nor (probably) the best way to do it.
645 In fact, the right way depends on the scripting language and the problem one is
646 facing in general.<br/>
647 That being said, feel free to use it at your own risk.
648 
649 The basic idea is that of creating a compile-time component aimed to map all the
650 runtime components assigned to an entity.<br/>
651 Identifiers come in use to address the right function from a map when invoked
652 from the runtime environment and to filter entities when iterating.<br/>
653 With a bit of gymnastic, one can narrow views and improve the performance to
654 some extent but it was not the goal of the example.
655 
656 ### Sorting: is it possible?
657 
658 It goes without saying that sorting entities and components is possible with
659 `EnTT`.<br/>
660 In fact, there are two functions that respond to slightly different needs:
661 
662 * Components can be sorted directly:
663 
664  ```cpp
665  registry.sort<Renderable>([](const auto &lhs, const auto &rhs) {
666  return lhs.z < rhs.z;
667  });
668  ```
669 
670 * Components can be sorted according to the order imposed by another component:
671 
672  ```cpp
673  registry.sort<Movement, Physics>();
674  ```
675 
676  In this case, instances of `Movement` are arranged in memory so that cache
677  misses are minimized when the two components are iterated together.
678 
679 ### Snapshot: complete vs continuous
680 
681 The `Registry` class offers basic support to serialization.<br/>
682 It doesn't convert components and tags to bytes directly, there wasn't the need
683 of another tool for serialization out there. Instead, it accepts an opaque
684 object with a suitable interface (namely an _archive_) to serialize its internal
685 data structures and restore them later. The way types and instances are
686 converted to a bunch of bytes is completely in charge to the archive and thus to
687 the users.
688 
689 The goal of the serialization part is to allow users to make both a dump of the
690 entire registry or a narrower snapshot, that is to select only the components
691 and the tags in which they are interested.<br/>
692 Intuitively, the use cases are different. As an example, the first approach is
693 suitable for local save/restore functionalities while the latter is suitable for
694 creating client-server applications and for transferring somehow parts of the
695 representation side to side.
696 
697 To take a snapshot of the registry, use the `snapshot` member function. It
698 returns a temporary object properly initialized to _save_ the whole registry or
699 parts of it.
700 
701 Example of use:
702 
703 ```cpp
704 OutputArchive output;
705 
706 registry.snapshot()
707  .entities(output)
708  .destroyed(output)
709  .component<AComponent, AnotherComponent>(output)
710  .tag<MyTag>(output);
711 ```
712 
713 It isn't necessary to invoke all these functions each and every time. What
714 functions to use in which case mostly depends on the goal and there is not a
715 golden rule to do that.
716 
717 The `entities` member function asks to the registry to serialize all the
718 entities that are still in use along with their versions. On the other side, the
719 `destroyed` member function tells to the registry to serialize the entities that
720 have been destroyed and are no longer in use.<br/>
721 These two functions can be used to save and restore the whole set of entities
722 with the versions they had during serialization.
723 
724 The `component` member function is a function template the aim of which is to
725 store aside components. The presence of a template parameter list is a
726 consequence of a couple of design choices from the past and in the present:
727 
728 * First of all, there is no reason to force an user to serialize all the
729  components at once and most of the times it isn't desiderable. As an example,
730  in case the stuff for the HUD in a game is put into the registry for some
731  reasons, its components can be freely discarded during a serialization step
732  because probably the software already knows how to reconstruct the HUD
733  correctly from scratch.
734 
735 * Furthermore, the registry makes heavy use of _type-erasure_ techniques
736  internally and doesn't know at any time what types of components it contains.
737  Therefore being explicit at the call point is mandatory.
738 
739 The `tag` member function is similar to the previous one, apart from the fact
740 that it works with tags and not with components.<br/>
741 Note also that both `component` and `tag` store items along with entities. It
742 means that they work properly without a call to the `entities` member function.
743 
744 Once a snapshot is created, there exist mainly two _ways_ to load it: as a whole
745 and in a kind of _continuous mode_.<br/>
746 The following sections describe both loaders and archives in details.
747 
748 #### Snapshot loader
749 
750 A snapshot loader requires that the destination registry be empty and loads all
751 the data at once while keeping intact the identifiers that the entities
752 originally had.<br/>
753 To do that, the registry offers a member function named `restore` that returns a
754 temporary object properly initialized to _restore_ a snapshot.
755 
756 Example of use:
757 
758 ```cpp
759 InputArchive input;
760 
761 registry.restore()
762  .entities()
763  .destroyed()
764  .component<AComponent, AnotherComponent>(output)
765  .tag<MyTag>(output)
766  .orphans();
767 ```
768 
769 It isn't necessary to invoke all these functions each and every time. What
770 functions to use in which case mostly depends on the goal and there is not a
771 golden rule to do that. For obvious reasons, what is important is that the data
772 are restored in exactly the same order in which they were serialized.
773 
774 The `entities` and `destroyed` member functions restore the sets of entities and
775 the versions that the entities originally had at the source.
776 
777 The `component` member function restores all and only the components specified
778 and assigns them to the right entities. Note that the template parameter list
779 must be exactly the same used during the serialization. The same applies to the
780 `tag` member function.
781 
782 The `orphans` member function literally destroys those entities that have
783 neither components nor tags. It's usually useless if the snapshot is a full dump
784 of the source. However, in case all the entities are serialized but only few
785 components and tags are saved, it could happen that some of the entities have
786 neither components nor tags once restored. The best users can do to deal with
787 them is to destroy those entities and thus update their versions.
788 
789 #### Continuous loader
790 
791 A continuous loader is designed to load data from a source registry to a
792 (possibly) non-empty destination. The loader can accomodate in a registry more
793 than one snapshot in a sort of _continuous loading_ that updates the
794 destination one step at a time.<br/>
795 Identifiers that entities originally had are not transferred to the target.
796 Instead, the loader maps remote identifiers to local ones while restoring a
797 snapshot. Because of that, this kind of loader offers a way to update
798 automatically identifiers that are part of components or tags (as an example, as
799 data members or gathered in a container).<br/>
800 Another difference with the snapshot loader is that the continuous loader does
801 not need to work with the private data structures of a registry. Furthermore, it
802 has an internal state that must persist over time. Therefore, there is no reason
803 to create it by means of a registry, or to limit its lifetime to that of a
804 temporary object.
805 
806 Example of use:
807 
808 ```cpp
809 entt::ContinuousLoader<entity_type> loader{registry};
810 InputArchive input;
811 
812 loader.entities(input)
813  .destroyed(input)
814  .component<AComponent, AnotherComponent>(input)
815  .component<DirtyComponent>(input, &DirtyComponent::parent, &DirtyComponent::child)
816  .tag<MyTag>(input)
817  .tag<DirtyTag>(input, &DirtyTag::container)
818  .orphans()
819  .shrink();
820 ```
821 
822 It isn't necessary to invoke all these functions each and every time. What
823 functions to use in which case mostly depends on the goal and there is not a
824 golden rule to do that. For obvious reasons, what is important is that the data
825 are restored in exactly the same order in which they were serialized.
826 
827 The `entities` and `destroyed` member functions restore groups of entities and
828 map each entity to a local counterpart when required. In other terms, for each
829 remote entity identifier not yet registered by the loader, the latter creates a
830 local identifier so that it can keep the local entity in sync with the remote
831 one.
832 
833 The `component` and `tag` member functions restore all and only the components
834 and the tags specified and assign them to the right entities.<br/>
835 In case the component or the tag contains entities itself (either as data
836 members of type `entity_type` or as containers of entities), the loader can
837 update them automatically. To do that, it's enough to specify the data members
838 to update as shown in the example. If the component or the tag was in the middle
839 of the template parameter list during serialization, multiple commands are
840 required during a restore:
841 
842 ```cpp
843 registry.snapshot().component<ASimpleComponent, AnotherSimpleComponent, AMoreComplexComponent, TheLastComponent>();
844 
845 // ...
846 
847 loader
848  .component<ASimpleComponent, AnotherSimpleComponent>(input)
849  .component<AMoreComplexComponent>(input, &AMoreComplexComponent::entity);
850  .component<TheLastComponent>(input);
851 ```
852 
853 The `orphans` member function literally destroys those entities that have
854 neither components nor tags after a restore. It has exactly the same purpose
855 described in the previous section and works the same way.
856 
857 Finally, `shrink` helps to purge local entities that no longer have a remote
858 conterpart. Users should invoke this member function after restoring each
859 snapshot, unless they know exactly what they are doing.
860 
861 #### Archives
862 
863 Archives must publicly expose a predefined set of member functions. The API is
864 straightforward and consists only of a group of function call operators that
865 are invoked by the registry.
866 
867 In particular:
868 
869 * An output archive, the one used when creating a snapshot, must expose a
870  function call operator with the following signature to store entities:
871 
872  ```cpp
873  void operator()(Entity);
874  ```
875 
876  Where `Entity` is the type of the entities used by the registry.<br/>
877  In addition, it must accept the types of both the components and the tags to
878  serialize. Therefore, given a type `T` (either a component or a tag), it must
879  contain a function call operator with the following signature:
880 
881  ```cpp
882  void operator()(const T &);
883  ```
884 
885  The output archive can freely decide how to serialize the data. The register
886  is not affected at all by the decision.
887 
888 * An input archive, the one used when restoring a snapshot, must expose a
889  function call operator with the following signature to load entities:
890 
891  ```cpp
892  void operator()(Entity &);
893  ```
894 
895  Where `Entity` is the type of the entities used by the registry. Each time the
896  function is invoked, the archive must read the next element from the
897  underlying storage and copy it in the given variable.<br/>
898  In addition, it must accept the types of both the components and the tags to
899  restore. Therefore, given a type `T` (either a component or a tag), it must
900  contain a function call operator with the following signature:
901 
902  ```cpp
903  void operator()(T &);
904  ```
905 
906  Every time such an operator is invoked, the archive must read the next element
907  from the underlying storage and copy it in the given variable.
908 
909 #### One example to rule them all
910 
911 `EnTT` comes with some examples (actually some tests) that show how to integrate
912 a well known library for serialization as an archive. It uses
913 [`Cereal C++`](https://uscilab.github.io/cereal/) under the hood, mainly
914 because I wanted to learn how it works at the time I was writing the code.
915 
916 The code is not production-ready and it isn't neither the only nor (probably)
917 the best way to do it. However, feel free to use it at your own risk.
918 
919 The basic idea is to store everything in a group of queues in memory, then bring
920 everything back to the registry with different loaders.
921 
922 ## View: to persist or not to persist?
923 
924 First of all, it is worth answering an obvious question: why views?<br/>
925 Roughly speaking, they are a good tool to enforce single responsibility. A
926 system that has access to a registry can create and destroy entities, as well as
927 assign and remove components. On the other side, a system that has access to a
928 view can only iterate entities and their components, then read or update the
929 data members of the latter.<br/>
930 It is a subtle difference that can help designing a better software sometimes.
931 
932 There are mainly three kinds of views: standard (also known as `View`),
933 persistent (also known as `PersistentView`) and raw (also known as
934 `RawView`).<br/>
935 All of them have pros and cons to take in consideration. In particular:
936 
937 * Standard views:
938 
939  Pros:
940  * They work out-of-the-box and don't require any dedicated data structure.
941  * Creating and destroying them isn't expensive at all because they don't have
942  any type of initialization.
943  * They are the best tool for iterating entities for a single component.
944  * They are the best tool for iterating entities for multiple components when
945  one of the components is assigned to a significantly low number of entities.
946  * They don't affect any other operations of the registry.
947 
948  Cons:
949  * Their performance tend to degenerate when the number of components to
950  iterate grows up and the most of the entities have all of them.
951 
952 * Persistent views:
953 
954  Pros:
955  * Once prepared, creating and destroying them isn't expensive at all because
956  they don't have any type of initialization.
957  * They are the best tool for iterating entities for mmultiple components and
958  most entities have them all.
959 
960  Cons:
961  * They have dedicated data structures and thus affect the memory usage to a
962  minimal extent.
963  * If not previously prepared, the first time they are used they go through an
964  initialization step that could take a while.
965  * They affect to a minimum the creation and destruction of entities and
966  components. In other terms: the more persistent views there will be, the
967  less performing will be creating and destroying entities and components.
968 
969 * Raw views:
970 
971  Pros:
972  * They work out-of-the-box and don't require any dedicated data structure.
973  * Creating and destroying them isn't expensive at all because they don't have
974  any type of initialization.
975  * They are the best tool for iterating components when it is not necessary to
976  know which entities they belong to.
977  * They don't affect any other operations of the registry.
978 
979  Cons:
980  * They can be used to iterate only one type of component at a time.
981  * They don't return the entity to which a component belongs to the caller.
982 
983 To sum up and as a rule of thumb:
984 * Use a raw view to iterate components only (no entities) for a given type.
985 * Use a standard view to iterate entities for a single component.
986 * Use a standard view to iterate entities for multiple components when a
987  significantly low number of entities have one of the components.
988 * Use a standard view in all those cases where a persistent view would give a
989  boost to performance but the iteration isn't performed frequently.
990 * Prepare and use a persistent view in all the other cases.
991 
992 To easily iterate entities and components, all the views offer the common
993 `begin` and `end` member functions that allow users to use a view in a typical
994 range-for loop. Almost all the views offer also a *more functional* `each`
995 member function that accepts a callback for convenience.<br/>
996 Continue reading for more details or refer to the
997 [official documentation](https://skypjack.github.io/entt/).
998 
999 ### Standard View
1000 
1001 A standard view behaves differently if it's constructed for a single component
1002 or if it has been requested to iterate multiple components. Even the API is
1003 different in the two cases.<br/>
1004 All that they share is the way they are created by means of a registry:
1005 
1006 ```cpp
1007 // single component standard view
1008 auto single = registry.view<Position>();
1009 
1010 // multi component standard view
1011 auto multi = registry.view<Position, Velocity>();
1012 ```
1013 
1014 For all that remains, it's worth discussing them separately.<br/>
1015 
1016 #### Single component standard view
1017 
1018 Single component standard views are specialized in order to give a boost in
1019 terms of performance in all the situation. This kind of views can access the
1020 underlying data structures directly and avoid superfluous checks.<br/>
1021 They offer a bunch of functionalities to get the number of entities they are
1022 going to return and a raw access to the entity list as well as to the component
1023 list. It's also possible to ask a view if it contains a given entity.<br/>
1024 Refer to the [official documentation](https://skypjack.github.io/entt/) for all
1025 the details.
1026 
1027 There is no need to store views around for they are extremely cheap to
1028 construct, even though they can be copied without problems and reused freely. In
1029 fact, they return newly created and correctly initialized iterators whenever
1030 `begin` or `end` are invoked.<br/>
1031 To iterate a single component standard view, either use it in range-for loop:
1032 
1033 ```cpp
1034 auto view = registry.view<Renderable>();
1035 
1036 for(auto entity: view) {
1037  Renderable &renderable = view.get(entity);
1038 
1039  // ...
1040 }
1041 ```
1042 
1043 Or rely on the `each` member function to iterate entities and get all their
1044 components at once:
1045 
1046 ```cpp
1047 registry.view<Renderable>().each([](auto entity, auto &renderable) {
1048  // ...
1049 });
1050 ```
1051 
1052 Performance are more or less the same. The best approach depends mainly on
1053 whether all the components have to be accessed or not.
1054 
1055 **Note**: prefer the `get` member function of a view instead of the `get` member
1056 function template of a registry during iterations, if possible. However, keep in
1057 mind that it works only with the components of the view itself.
1058 
1059 #### Multi component standard view
1060 
1061 Multi component standard views iterate entities that have at least all the given
1062 components in their bags. During construction, these views look at the number of
1063 entities available for each component and pick up a reference to the smallest
1064 set of candidates in order to speed up iterations.<br/>
1065 They offer fewer functionalities than their companion views for single
1066 component. In particular, a multi component standard view exposes utility
1067 functions to reset its internal state (optimization purposes) and to get the
1068 estimated number of entities it is going to return. It's also possible to ask a
1069 view if it contains a given entity.<br/>
1070 Refer to the [official documentation](https://skypjack.github.io/entt/) for all
1071 the details.
1072 
1073 There is no need to store views around for they are extremely cheap to
1074 construct, even though they can be copied without problems and reused freely. In
1075 fact, they return newly created and correctly initialized iterators whenever
1076 `begin` or `end` are invoked.<br/>
1077 To iterate a multi component standard view, either use it in range-for loop:
1078 
1079 ```cpp
1080 auto view = registry.view<Position, Velocity>();
1081 
1082 for(auto entity: view) {
1083  // a component at a time ...
1084  Position &position = view.get<Position>(entity);
1085  Velocity &velocity = view.get<Velocity>(entity);
1086 
1087  // ... or multiple components at once
1088  std::tuple<Position &, Velocity &> tup = view.get<Position, Velocity>(entity);
1089 
1090  // ...
1091 }
1092 ```
1093 
1094 Or rely on the `each` member function to iterate entities and get all their
1095 components at once:
1096 
1097 ```cpp
1098 registry.view<Position, Velocity>().each([](auto entity, auto &position, auto &velocity) {
1099  // ...
1100 });
1101 ```
1102 
1103 Performance are more or less the same. The best approach depends mainly on
1104 whether all the components have to be accessed or not.
1105 
1106 **Note**: prefer the `get` member function of a view instead of the `get` member
1107 function template of a registry during iterations, if possible. However, keep in
1108 mind that it works only with the components of the view itself.
1109 
1110 ### Persistent View
1111 
1112 A persistent view returns all the entities and only the entities that have at
1113 least the given components. Moreover, it's guaranteed that the entity list is
1114 tightly packed in memory for fast iterations.<br/>
1115 In general, persistent views don't stay true to the order of any set of
1116 components unless users explicitly sort them.
1117 
1118 Persistent views can be used only to iterate multiple components. Create them
1119 as it follows:
1120 
1121 ```cpp
1122 auto view = registry.persistent<Position, Velocity>();
1123 ```
1124 
1125 There is no need to store views around for they are extremely cheap to
1126 construct, even though they can be copied without problems and reused freely. In
1127 fact, they return newly created and correctly initialized iterators whenever
1128 `begin` or `end` are invoked.<br/>
1129 That being said, persistent views perform an initialization step the very first
1130 time they are constructed and this could be quite costly. To avoid it, consider
1131 asking to the registry to _prepare_ them when no entities have been created yet:
1132 
1133 ```cpp
1134 registry.prepare<Position, Velocity>();
1135 ```
1136 
1137 If the registry is empty, preparation is extremely fast. Moreover the `prepare`
1138 member function template is idempotent. Feel free to invoke it even more than
1139 once: if the view has been already prepared before, the function returns
1140 immediately and does nothing.
1141 
1142 A persistent view offers a bunch of functionalities to get the number of
1143 entities it's going to return, a raw access to the entity list and the
1144 possibility to sort the underlying data structures according to the order of one
1145 of the components for which it has been constructed. It's also possible to ask a
1146 view if it contains a given entity.<br/>
1147 Refer to the [official documentation](https://skypjack.github.io/entt/) for all
1148 the details.
1149 
1150 To iterate a persistent view, either use it in range-for loop:
1151 
1152 ```cpp
1153 auto view = registry.persistent<Position, Velocity>();
1154 
1155 for(auto entity: view) {
1156  // a component at a time ...
1157  Position &position = view.get<Position>(entity);
1158  Velocity &velocity = view.get<Velocity>(entity);
1159 
1160  // ... or multiple components at once
1161  std::tuple<Position &, Velocity &> tup = view.get<Position, Velocity>(entity);
1162 
1163  // ...
1164 }
1165 ```
1166 
1167 Or rely on the `each` member function to iterate entities and get all their
1168 components at once:
1169 
1170 ```cpp
1171 registry.persistent<Position, Velocity>().each([](auto entity, auto &position, auto &velocity) {
1172  // ...
1173 });
1174 ```
1175 
1176 Performance are more or less the same. The best approach depends mainly on
1177 whether all the components have to be accessed or not.
1178 
1179 **Note**: prefer the `get` member function of a view instead of the `get` member
1180 function template of a registry during iterations, if possible. However, keep in
1181 mind that it works only with the components of the view itself.
1182 
1183 ### Raw View
1184 
1185 Raw views return all the components of a given type. This kind of views can
1186 access components directly and avoid extra indirections as if components were
1187 accessed via an entity identifier.<br/>
1188 They offer a bunch of functionalities to get the number of instances they are
1189 going to return and a raw access to the entity list as well as to the component
1190 list.<br/>
1191 Refer to the [official documentation](https://skypjack.github.io/entt/) for all
1192 the details.
1193 
1194 There is no need to store views around for they are extremely cheap to
1195 construct, even though they can be copied without problems and reused freely. In
1196 fact, they return newly created and correctly initialized iterators whenever
1197 `begin` or `end` are invoked.<br/>
1198 To iterate a raw view, use it in range-for loop:
1199 
1200 ```cpp
1201 auto view = registry.raw<Renderable>();
1202 
1203 for(auto &&component: raw) {
1204  // ...
1205 }
1206 ```
1207 
1208 **Note**: raw views don't have the `each` nor the `get` member function for
1209 obvious reasons. The former would only return the components and therefore it
1210 would be redundant, the latter isn't required at all.
1211 
1212 ### Give me everything
1213 
1214 Views are narrow windows on the entire list of entities. They work by filtering
1215 entities according to their components.<br/>
1216 In some cases there may be the need to iterate all the entities still in use
1217 regardless of their components. The registry offers a specific member function
1218 to do that:
1219 
1220 ```cpp
1221 registry.each([](auto entity) {
1222  // ...
1223 });
1224 ```
1225 
1226 It returns to the caller all the entities that are still in use by means of the
1227 given function.<br/>
1228 As a rule of thumb, consider using a view if the goal is to iterate entities
1229 that have a determinate set of components. A view is usually much faster than
1230 combining this function with a bunch of custom tests.<br/>
1231 In all the other cases, this is the way to go.
1232 
1233 There exists also another member function to use to retrieve orphans. An orphan
1234 is an entity that is still in use and has neither assigned components nor
1235 tags.<br/>
1236 The signature of the function is the same of `each`:
1237 
1238 ```cpp
1239 registry.orphans([](auto entity) {
1240  // ...
1241 });
1242 ```
1243 
1244 To test the _orphanity_ of a single entity, use the member function `orphan`
1245 instead. It accepts a valid entity identifer as an argument and returns true in
1246 case the entity is an orphan, false otherwise.
1247 
1248 In general, all these functions can result in poor performance.<br/>
1249 `each` is fairly slow because of some checks it performs on each and every
1250 entity. For similar reasons, `orphans` can be even slower. Both functions should
1251 not be used frequently to avoid the risk of a performance hit.
1252 
1253 ## Side notes
1254 
1255 * Entity identifiers are numbers and nothing more. They are not classes and they
1256  have no member functions at all. As already mentioned, do no try to inspect or
1257  modify an entity descriptor in any way.
1258 
1259 * As shown in the examples above, the preferred way to get references to the
1260  components while iterating a view is by using the view itself. It's a faster
1261  alternative to the `get` member function template that is part of the API of
1262  the `Registry`. This is because the registry must ensure that a pool for the
1263  given component exists before to use it; on the other side, views force the
1264  construction of the pools for all their components and access them directly,
1265  thus avoiding all the checks.
1266 
1267 * Most of the _ECS_ available out there have an annoying limitation (at least
1268  from my point of view): entities and components cannot be created and/or
1269  destroyed during iterations.<br/>
1270  `EnTT` partially solves the problem with a few limitations:
1271 
1272  * Creating entities and components is allowed during iterations.
1273  * Deleting an entity or removing its components is allowed during
1274  iterations if it's the one currently returned by a view. For all the
1275  other entities, destroying them or removing their components isn't
1276  allowed and it can result in undefined behavior.
1277 
1278  Iterators are invalidated and the behavior is undefined if an entity is
1279  modified or destroyed and it's not the one currently returned by the
1280  view.<br/>
1281  To work around it, possible approaches are:
1282 
1283  * Store aside the entities and the components to be removed and perform the
1284  operations at the end of the iteration.
1285  * Mark entities and components with a proper tag component that indicates
1286  they must be purged, then perform a second iteration to clean them up one
1287  by one.
1288 
1289 * Views and thus their iterators aren't thread safe. Do no try to iterate a set
1290  of components and modify the same set concurrently.<br/>
1291  That being said, as long as a thread iterates the entities that have the
1292  component `X` or assign and removes that component from a set of entities,
1293  another thread can safely do the same with components `Y` and `Z` and
1294  everything will work like a charm.<br/>
1295  As a trivial example, users can freely execute the rendering system and
1296  iterate the renderable entities while updating a physic component concurrently
1297  on a separate thread.
1298 
1299 * In general, the entire registry isn't thread safe as it is. Thread safety
1300  isn't something that users should want out of the box for several reasons.
1301  Just to mention one of them: performance.<br/>
1302  This kind of entity-component systems can be used in single threaded
1303  applications as well as along with async stuff. Moreover, typical thread based
1304  models for ECS don't require a fully thread safe registry to work. Actually
1305  one could reach the goal with the registry as it is while working with most of
1306  the common models, after all.<br/>
1307  Because of the few reasons mentioned above and many others not mentioned,
1308  users are completely responsible for synchronization whether required.
1309 
1310 # Crash Course: core functionalities
1311 
1312 The `EnTT` framework comes with a bunch of core functionalities mostly used by
1313 the other parts of the library itself.<br/>
1314 Hardly users of the framework will include these features in their code, but
1315 it's worth describing what `EnTT` offers so as not to reinvent the wheel in case
1316 of need.
1317 
1318 ## Compile-time identifiers
1319 
1320 Sometimes it's useful to be able to give unique identifiers to types at
1321 compile-time.<br/>
1322 There are plenty of different solutions out there and I could have used one of
1323 them. However, I decided to spend my time to define a compact and versatile tool
1324 that fully embraces what the modern C++ has to offer.
1325 
1326 The _result of my efforts_ is the `ident` `constexpr` variable:
1327 
1328 ```cpp
1329 #include <ident.hpp>
1330 
1331 // defines the identifiers for the given types
1332 constexpr auto identifiers = entt::ident<AType, AnotherType>;
1333 
1334 // ...
1335 
1336 switch(aTypeIdentifier) {
1337 case identifers.get<AType>():
1338  // ...
1339  break;
1340 case identifers.get<AnotherType>():
1341  // ...
1342  break;
1343 default:
1344  // ...
1345 }
1346 ```
1347 
1348 This is all what the variable has to offer: a `get` member function that returns
1349 a numerical identifier for the given type. It can be used in any context where
1350 constant expressions are required.
1351 
1352 As long as the list remains unchanged, identifiers are also guaranteed to be the
1353 same for every run. In case they have been used in a production environment and
1354 a type has to be removed, one can just use a placeholder to left the other
1355 identifiers unchanged:
1356 
1357 ```cpp
1358 template<typename> struct IgnoreType {};
1359 
1360 constexpr auto identifiers = entt::ident<
1361  ATypeStillValid,
1362  IgnoreType<ATypeNoLongerValid>,
1363  AnotherTypeStillValid
1364 >;
1365 ```
1366 
1367 A bit ugly to see, but it works at least.
1368 
1369 ## Runtime identifiers
1370 
1371 Sometimes it's useful to be able to give unique identifiers to types at
1372 runtime.<br/>
1373 There are plenty of different solutions out there and I could have used one of
1374 them. In fact, I adapted the most common one to my requirements and used it
1375 extensively within the entire framework.
1376 
1377 It's the `Family` class. Here is an example of use directly from the
1378 entity-component system:
1379 
1380 ```cpp
1381 using component_family = entt::Family<struct InternalRegistryComponentFamily>;
1382 
1383 // ...
1384 
1385 template<typename Component>
1386 component_type component() const noexcept {
1387  return component_family::type<Component>();
1388 }
1389 ```
1390 
1391 This is all what a _family_ has to offer: a `type` member function that returns
1392 a numerical identifier for the given type.
1393 
1394 Please, note that identifiers aren't guaranteed to be the same for every run.
1395 Indeed it mostly depends on the flow of execution.
1396 
1397 ## Hashed strings
1398 
1399 A hashed string is a zero overhead resource identifier. Users can use
1400 human-readable identifiers in the codebase while using their numeric
1401 counterparts at runtime, thus without affecting performance.<br/>
1402 The class has an implicit `constexpr` constructor that chews a bunch of
1403 characters. Once created, all what one can do with it is getting back the
1404 original string or converting it into a number.<br/>
1405 The good part is that a hashed string can be used wherever a constant expression
1406 is required and no _string-to-number_ conversion will take place at runtime if
1407 used carefully.
1408 
1409 Example of use:
1410 
1411 ```cpp
1412 auto load(entt::HashedString::hash_type resource) {
1413  // uses the numeric representation of the resource to load and return it
1414 }
1415 
1416 auto resource = load(entt::HashedString{"gui/background"});
1417 ```
1418 
1419 ### Conflicts
1420 
1421 The hashed string class uses internally FNV-1a to compute the numeric
1422 counterpart of a string. Because of the _pigeonhole principle_, conflicts are
1423 possible. This is a fact.<br/>
1424 There is no silver bullet to solve the problem of conflicts when dealing with
1425 hashing functions. In this case, the best solution seemed to be to give up.
1426 That's all.<br/>
1427 After all, human-readable resource identifiers aren't something strictly defined
1428 and over which users have not the control. Choosing a slightly different
1429 identifier is probably the best solution to make the conflict disappear in this
1430 case.
1431 
1432 # Crash Course: service locator
1433 
1434 Usually service locators are tightly bound to the services they expose and it's
1435 hard to define a general purpose solution. This template based implementation
1436 tries to fill the gap and to get rid of the burden of defining a different
1437 specific locator for each application.<br/>
1438 This class is tiny, partially unsafe and thus risky to use. Moreover it doesn't
1439 fit probably most of the scenarios in which a service locator is required. Look
1440 at it as a small tool that can sometimes be useful if the user knows how to
1441 handle it.
1442 
1443 The API is straightforward. The basic idea is that services are implemented by
1444 means of interfaces and rely on polymorphism.<br/>
1445 The locator is instantiated with the base type of the service if any and a
1446 concrete implementation is provided along with all the parameters required to
1447 initialize it. As an example:
1448 
1449 ```cpp
1450 // the service has no base type, a locator is used to treat it as a kind of singleton
1451 entt::ServiceLocator<MyService>::set(params...);
1452 
1453 // sets up an opaque service
1454 entt::ServiceLocator<AudioInterface>::set<AudioImplementation>(params...);
1455 
1456 // resets (destroys) the service
1457 entt::ServiceLocator<AudioInterface>::reset();
1458 ```
1459 
1460 The locator can also be queried to know if an active service is currently set
1461 and to retrieve it if necessary (either as a pointer or as a reference):
1462 
1463 ```cpp
1464 // no service currently set
1465 auto empty = entt::ServiceLocator<AudioInterface>::empty();
1466 
1467 // gets a (possibly empty) shared pointer to the service ...
1468 std::shared_ptr<AudioInterface> ptr = entt::ServiceLocator<AudioInterface>::get();
1469 
1470 // ... or a reference, but it's undefined behaviour if the service isn't set yet
1471 AudioInterface &ref = entt::ServiceLocator<AudioInterface>::ref();
1472 ```
1473 
1474 A common use is to wrap the different locators in a container class, creating
1475 aliases for the various services:
1476 
1477 ```cpp
1478 struct Locator {
1479  using Camera = entt::ServiceLocator<CameraInterface>;
1480  using Audio = entt::ServiceLocator<AudioInterface>;
1481  // ...
1482 };
1483 
1484 // ...
1485 
1486 void init() {
1487  Locator::Camera::set<CameraNull>();
1488  Locator::Audio::set<AudioImplementation>(params...);
1489  // ...
1490 }
1491 ```
1492 
1493 # Crash Course: cooperative scheduler
1494 
1495 Sometimes processes are a useful tool to work around the strict definition of a
1496 system and introduce logic in a different way, usually without resorting to the
1497 introduction of other components.
1498 
1499 The `EnTT` framework offers a minimal support to this paradigm by introducing a
1500 few classes that users can use to define and execute cooperative processes.
1501 
1502 ## The process
1503 
1504 A typical process must inherit from the `Process` class template that stays true
1505 to the CRTP idiom. Moreover, derived classes must specify what's the intended
1506 type for elapsed times.
1507 
1508 A process should expose publicly the following member functions whether
1509 required (note that it isn't required to define a function unless the derived
1510 class wants to _override_ the default behavior):
1511 
1512 * `void update(Delta, void *);`
1513 
1514  It's invoked once per tick until a process is explicitly aborted or it
1515  terminates either with or without errors. Even though it's not mandatory to
1516  declare this member function, as a rule of thumb each process should at
1517  least define it to work properly. The `void *` parameter is an opaque pointer
1518  to user data (if any) forwarded directly to the process during an update.
1519 
1520 * `void init(void *);`
1521 
1522  It's invoked at the first tick, immediately before an update. The `void *`
1523  parameter is an opaque pointer to user data (if any) forwarded directly to the
1524  process during an update.
1525 
1526 * `void succeeded();`
1527 
1528  It's invoked in case of success, immediately after an update and during the
1529  same tick.
1530 
1531 * `void failed();`
1532 
1533  It's invoked in case of errors, immediately after an update and during the
1534  same tick.
1535 
1536 * `void aborted();`
1537 
1538  It's invoked only if a process is explicitly aborted. There is no guarantee
1539  that it executes in the same tick, this depends solely on whether the
1540  process is aborted immediately or not.
1541 
1542 Derived classes can also change the internal state of a process by invoking
1543 `succeed` and `fail`, as well as `pause` and `unpause` the process itself. All
1544 these are protected member functions made available to be able to manage the
1545 life cycle of a process from a derived class.
1546 
1547 Here is a minimal example for the sake of curiosity:
1548 
1549 ```cpp
1550 struct MyProcess: entt::Process<MyProcess, std::uint32_t> {
1551  using delta_type = std::uint32_t;
1552 
1553  void update(delta_type delta, void *) {
1554  remaining = delta > remaining ? delta_type{] : (remaining - delta);
1555 
1556  // ...
1557 
1558  if(!remaining) {
1559  succeed();
1560  }
1561  }
1562 
1563  void init(void *data) {
1564  remaining = *static_cast<delta_type *>(data);
1565  }
1566 
1567 private:
1568  delta_type remaining;
1569 };
1570 ```
1571 
1572 ### Adaptor
1573 
1574 Lambdas and functors can't be used directly with a scheduler for they are not
1575 properly defined processes with managed life cycles.<br/>
1576 This class helps in filling the gap and turning lambdas and functors into
1577 full featured processes usable by a scheduler.
1578 
1579 The function call operator has a signature similar to the one of the `update`
1580 function of a process but for the fact that it receives two extra arguments to
1581 call whenever a process is terminated with success or with an error:
1582 
1583 ```cpp
1584 void(Delta delta, void *data, auto succeed, auto fail);
1585 ```
1586 
1587 Parameters have the following meaning:
1588 
1589 * `delta` is the elapsed time.
1590 * `data` is an opaque pointer to user data if any, `nullptr` otherwise.
1591 * `succeed` is a function to call when a process terminates with success.
1592 * `fail` is a function to call when a process terminates with errors.
1593 
1594 Both `succeed` and `fail` accept no parameters at all.
1595 
1596 Note that usually users shouldn't worry about creating adaptors at all. A
1597 scheduler creates them internally each and every time a lambda or a functor is
1598 used as a process.
1599 
1600 ## The scheduler
1601 
1602 A cooperative scheduler runs different processes and helps managing their life
1603 cycles.
1604 
1605 Each process is invoked once per tick. If it terminates, it's removed
1606 automatically from the scheduler and it's never invoked again. Otherwise it's
1607 a good candidate to run once more the next tick.<br/>
1608 A process can also have a child. In this case, the process is replaced with
1609 its child when it terminates if it returns with success. In case of errors,
1610 both the process and its child are discarded. This way, it's easy to create
1611 chain of processes to run sequentially.
1612 
1613 Using a scheduler is straightforward. To create it, users must provide only the
1614 type for the elapsed times and no arguments at all:
1615 
1616 ```cpp
1617 Scheduler<std::uint32_t> scheduler;
1618 ```
1619 
1620 It has member functions to query its internal data structures, like `empty` or
1621 `size`, as well as a `clear` utility to reset it to a clean state:
1622 
1623 ```cpp
1624 // checks if there are processes still running
1625 bool empty = scheduler.empty();
1626 
1627 // gets the number of processes still running
1628 Scheduler<std::uint32_t>::size_type size = scheduler.size();
1629 
1630 // resets the scheduler to its initial state and discards all the processes
1631 scheduler.clear();
1632 ```
1633 
1634 To attach a process to a scheduler there are mainly two ways:
1635 
1636 * If the process inherits from the `Process` class template, it's enough to
1637  indicate its type and submit all the parameters required to construct it to
1638  the `attach` member function:
1639 
1640  ```cpp
1641  scheduler.attach<MyProcess>("foobar");
1642  ```
1643 
1644 * Otherwise, in case of a lambda or a functor, it's enough to provide an
1645  instance of the class to the `attach` member function:
1646 
1647  ```cpp
1648  scheduler.attach([](auto...){ /* ... */ });
1649  ```
1650 
1651 In both cases, the return value is an opaque object that offers a `then` member
1652 function to use to create chains of processes to run sequentially.<br/>
1653 As a minimal example of use:
1654 
1655 ```cpp
1656 // schedules a task in the form of a lambda function
1657 scheduler.attach([](auto delta, void *, auto succeed, auto fail) {
1658  // ...
1659 })
1660 // appends a child in the form of another lambda function
1661 .then([](auto delta, void *, auto succeed, auto fail) {
1662  // ...
1663 })
1664 // appends a child in the form of a process class
1665 .then<MyProcess>();
1666 ```
1667 
1668 To update a scheduler and thus all its processes, the `update` member function
1669 is the way to go:
1670 
1671 ```cpp
1672 // updates all the processes, no user data are provided
1673 scheduler.update(delta);
1674 
1675 // updates all the processes and provides them with custom data
1676 scheduler.update(delta, &data);
1677 ```
1678 
1679 In addition to these functions, the scheduler offers an `abort` member function
1680 that can be used to discard all the running processes at once:
1681 
1682 ```cpp
1683 // aborts all the processes abruptly ...
1684 scheduler.abort(true);
1685 
1686 // ... or gracefully during the next tick
1687 scheduler.abort();
1688 ```
1689 
1690 # Crash Course: resource management
1691 
1692 Resource management is usually one of the most critical part of a software like
1693 a game. Solutions are often tuned to the particular application. There exist
1694 several approaches and all of them are perfectly fine as long as they fit the
1695 requirements of the piece of software in which they are used.<br/>
1696 Examples are loading everything on start, loading on request, predictive
1697 loading, and so on.
1698 
1699 The `EnTT` framework doesn't pretend to offer a _one-fits-all_ solution for the
1700 different cases. Instead, it offers a minimal and perhaps trivial cache that can
1701 be useful most of the time during prototyping and sometimes even in a production
1702 environment.<br/>
1703 For those interested in the subject, the plan is to improve it considerably over
1704 time in terms of performance, memory usage and functionalities. Hoping to make
1705 it, of course, one step at a time.
1706 
1707 ## The resource, the loader and the cache
1708 
1709 There are three main actors in the model: the resource, the loader and the
1710 cache.
1711 
1712 The _resource_ is whatever the user wants it to be. An image, a video, an audio,
1713 whatever. There are no limits.<br/>
1714 As a minimal example:
1715 
1716 ```cpp
1717 struct MyResource { const int value; };
1718 ```
1719 
1720 A _loader_ is a class the aim of which is to load a specific resource. It has to
1721 inherit directly from the dedicated base class as in the following example:
1722 
1723 ```cpp
1724 struct MyLoader final: entt::ResourceLoader<MyLoader, MyResource> {
1725  // ...
1726 };
1727 ```
1728 
1729 Where `MyResource` is the type of resources it creates.<br/>
1730 A resource loader must also expose a public const member function named `load`
1731 that accepts a variable number of arguments and returns a shared pointer to a
1732 resource.<br/>
1733 As an example:
1734 
1735 ```cpp
1736 struct MyLoader: entt::ResourceLoader<MyLoader, MyResource> {
1737  std::shared_ptr<MyResource> load(int value) const {
1738  // ...
1739  return std::shared_ptr<MyResource>(new MyResource{ value });
1740  }
1741 };
1742 ```
1743 
1744 In general, resource loaders should not have a state or retain data of any type.
1745 They should let the cache manage their resources instead.<br/>
1746 As a side note, base class and CRTP idiom aren't strictly required with the
1747 current implementation. One could argue that a cache can easily work with
1748 loaders of any type. However, future changes won't be breaking ones by forcing
1749 the use of a base class today and that's why the model is already in its place.
1750 
1751 Finally, a cache is a specialization of a class template tailored to a specific
1752 resource:
1753 
1754 ```cpp
1755 using MyResourceCache = entt::ResourceCache<MyResource>;
1756 
1757 // ...
1758 
1759 MyResourceCache cache{};
1760 ```
1761 
1762 The idea is to create different caches for different types of resources and to
1763 manage each one independently and in the most appropriate way.<br/>
1764 As a (very) trivial example, audio tracks can survive in most of the scenes of
1765 an application while meshes can be associated with a single scene and then
1766 discarded when the user leaves it.
1767 
1768 A cache offers a set of basic functionalities to query its internal state and to
1769 _organize_ it:
1770 
1771 ```cpp
1772 // gets the number of resources managed by a cache
1773 auto size = cache.size();
1774 
1775 // checks if a cache contains at least a valid resource
1776 auto empty = cache.empty();
1777 
1778 // clears a cache and discards its content
1779 cache.clear();
1780 ```
1781 
1782 Besides these member functions, it contains what is needed to load, use and
1783 discard resources of the given type.<br/>
1784 Before to explore this part of the interface, it makes sense to mention how
1785 resources are identified. The type of the identifiers to use is defined as:
1786 
1787 ```cpp
1788 entt::ResourceCache<Resource>::resource_type
1789 ```
1790 
1791 Where `resource_type` is an alias for `entt::HashedString`. Therefore, resource
1792 identifiers are created explicitly as in the following example:
1793 
1794 ```cpp
1795 constexpr auto identifier = entt::ResourceCache<Resource>::resource_type{"my/resource/identifier"};
1796 // this is equivalent to the following
1797 constexpr auto hs = entt::HashedString{"my/resource/identifier"};
1798 ```
1799 
1800 The class `HashedString` is described in a dedicated section, so I won't do in
1801 details here.
1802 
1803 Resources are loaded and thus stored in a cache through the `load` member
1804 function. It accepts the loader to use as a template parameter, the resource
1805 identifier and the parameters used to construct the resource as arguments:
1806 
1807 ```cpp
1808 // uses the identifier declared above
1809 cache.load<MyLoader>(identifier, 0);
1810 
1811 // uses a const char * directly as an identifier
1812 cache.load<MyLoader>("another/identifier", 42);
1813 ```
1814 
1815 The return value can be used to know if the resource has been loaded correctly.
1816 In case the loader returns an invalid pointer or the resource already exists in
1817 the cache, a false value is returned:
1818 
1819 ```cpp
1820 if(!cache.load<MyLoader>("another/identifier", 42)) {
1821  // ...
1822 }
1823 ```
1824 
1825 Unfortunately, in this case there is no way to know what was the problem
1826 exactly. However, before trying to load a resource or after an error, one can
1827 use the `contains` member function to know if a cache already contains a
1828 specific resource:
1829 
1830 ```cpp
1831 auto exists = cache.contains("my/identifier");
1832 ```
1833 
1834 There exists also a member function to use to force a reload of an already
1835 existing resource if needed:
1836 
1837 ```cpp
1838 auto result = cache.reload<MyLoader>("another/identifier", 42);
1839 ```
1840 
1841 As above, the function returns true in case of success, false otherwise. The
1842 sole difference in this case is that an error necessarily means that the loader
1843 has failed for some reasons to load the resource.<br/>
1844 Note that the `reload` member function is a kind of alias of the following
1845 snippet:
1846 
1847 ```cpp
1848 cache.discard(identifier);
1849 cache.load<MyLoader>(identifier, 42);
1850 ```
1851 
1852 Where the `discard` member function is used to get rid of a resource if loaded.
1853 In case the cache doesn't contain a resource for the given identifier, the
1854 function does nothing and returns immediately.
1855 
1856 So far, so good. Resources are finally loaded and stored within the cache.<br/>
1857 They are returned to the users in the form of handles. To get one of them:
1858 
1859 ```cpp
1860 auto handle = cache.handle("my/identifier");
1861 ```
1862 
1863 The idea behind a handle is the same of the flyweight pattern. In other terms,
1864 resources aren't copied around. Instead, instances are shared between handles.
1865 Users of a resource owns a handle and it guarantees that a resource isn't
1866 destroyed until all the handles are destroyed, even if the resource itself is
1867 removed from the cache.<br/>
1868 Handles are tiny objects both movable and copyable. They returns the contained
1869 resource as a const reference on request:
1870 
1871 * By means of the `get` member function:
1872 
1873  ```cpp
1874  const auto &resource = handle.get();
1875  ```
1876 
1877 * Using the proper cast operator:
1878 
1879  ```cpp
1880  const auto &resource = handle;
1881  ```
1882 
1883 * Through the dereference operator:
1884 
1885  ```cpp
1886  const auto &resource = *handle;
1887  ```
1888 
1889 The resource can also be accessed directly using the arrow operator if required:
1890 
1891 ```cpp
1892 auto value = handle->value;
1893 ```
1894 
1895 To test if a handle is still valid, the cast operator to `bool` allows the users
1896 to use it in a guard:
1897 
1898 ```cpp
1899 if(handle) {
1900  // ...
1901 }
1902 ```
1903 
1904 Finally, in case there is the need to load a resource and thus to get a handle
1905 without storing the resource itself in the cache, users can rely on the `temp`
1906 member function template.<br/>
1907 The declaration is similar to the one of `load` but for the fact that it doesn't
1908 return a boolean value. Instead, it returns a (possibly invalid) handle for the
1909 resource:
1910 
1911 ```cpp
1912 auto handle = cache.temp<MyLoader>("another/identifier", 42);
1913 ```
1914 
1915 Do not forget to test the handle for validity. Otherwise, getting the reference
1916 to the resource it points may result in undefined behavior.
1917 
1918 # Crash Course: events, signals and everything in between
1919 
1920 Signals are usually a core part of games and software architectures in
1921 general.<br/>
1922 Roughly speaking, they help to decouple the various parts of a system while
1923 allowing them to communicate with each other somehow.
1924 
1925 The so called _modern C++_ comes with a tool that can be useful in these terms,
1926 the `std::function`. As an example, it can be used to create delegates.<br/>
1927 However, there is no guarantee that an `std::function` does not perform
1928 allocations under the hood and this could be problematic sometimes. Furthermore,
1929 it solves a problem but may not adapt well to other requirements that may arise
1930 from time to time.
1931 
1932 In case that the flexibility and potential of an `std::function` are not
1933 required or where you are looking for something different, the `EnTT` framework
1934 offers a full set of classes to solve completely different problems.
1935 
1936 ## Signals
1937 
1938 There are two types of signal handlers in `EnTT`, internally called _managed_
1939 and _unmanaged_.<br/>
1940 They differ in the way they work around the tradeoff between performance, memory
1941 usage and safety. Managed listeners must be wrapped in an `std::shared_ptr` and
1942 the sink will take care of disconnecting them whenever they die. Unmanaged
1943 listeners can be any kind of objects and the client is in charge of connecting
1944 and disconnecting them from a sink to avoid crashes due to different lifetimes.
1945 
1946 ### Managed signal handler
1947 
1948 A managed signal handler works with weak pointers to classes and pointers to
1949 member functions as well as pointers to free functions. References are
1950 automatically removed when the instances to which they point are freed.<br/>
1951 In other terms, users can simply connect a listener and forget about it, thus
1952 getting rid of the burden of controlling its lifetime. The drawback is that
1953 listeners must be allocated on the dynamic storage and wrapped into an
1954 `std::shared_ptr`. Performance and memory management can suffer from this in
1955 real world softwares.
1956 
1957 To create an instance of this type of handler, the function type is all what is
1958 needed:
1959 
1960 ```cpp
1961 entt::Signal<void(int, char)> signal;
1962 ```
1963 
1964 From now on, free functions and member functions that respect the given
1965 signature can be easily connected to and disconnected from the signal:
1966 
1967 ```cpp
1968 void foo(int, char) { /* ... */ }
1969 
1970 struct S {
1971  void bar(int, char) { /* ... */ }
1972 };
1973 
1974 // ...
1975 
1976 auto instance = std::make_shared<S>();
1977 
1978 signal.connect<&foo>();
1979 signal.connect<S, &S::bar>(instance);
1980 
1981 // ...
1982 
1983 signal.disconnect<&foo>();
1984 
1985 // disconnect a specific member function of an instance ...
1986 signal.disconnect<S, &S::bar>(instance);
1987 
1988 // ... or an instance as a whole
1989 signal.disconnect(instance);
1990 ```
1991 
1992 Once listeners are attached (or even if there are no listeners at all), events
1993 and data in general can be published through a signal by means of the `publish`
1994 member function:
1995 
1996 ```cpp
1997 signal.publish(42, 'c');
1998 ```
1999 
2000 This is more or less all what a managed signal handler has to offer.<br/>
2001 A bunch of other member functions are exposed actually. As an example, there is
2002 a method to use to know how many listeners a managed signal handler contains
2003 (`size`) or if it contains at least a listener (`empty`), to reset it to its
2004 initial state (`clear`) and even to swap two handlers (`swap`).<br/>
2005 Refer to the [official documentation](https://skypjack.github.io/entt/) for all
2006 the details.
2007 
2008 ### Unmanaged signal handler
2009 
2010 An unmanaged signal handler works with naked pointers to classes and pointers to
2011 member functions as well as pointers to free functions. Removing references when
2012 the instances to which they point are freed is in charge to the users.<br/>
2013 In other terms, users must explicitly disconnect a listener before to delete the
2014 class to which it belongs, thus taking care of the lifetime of each instance. On
2015 the other side, performance shouldn't be affected that much by the presence of
2016 such a signal handler.
2017 
2018 The API of an unmanaged signal handler is similar to the one of a managed signal
2019 handler.<br/>
2020 The most important difference is that it comes in two forms: with and without a
2021 collector. In case it is associated with a collector, all the values returned by
2022 the listeners can be literally _collected_ and used later by the caller.<br/>
2023 
2024 **Note**: collectors are allowed only in case of function types whose the return
2025 type isn't `void` for obvious reasons.
2026 
2027 To create instances of this type of handler there exist mainly two ways:
2028 
2029 ```cpp
2030 // no collector type
2031 entt::SigH<void(int, char)> signal;
2032 
2033 // explicit collector type
2034 entt::SigH<void(int, char), MyCollector<bool>> collector;
2035 ```
2036 
2037 As expected, an unmanaged signal handler offers all the basic functionalities
2038 required to know how many listeners it contains (`size`) or if it contains at
2039 least a listener (`empty`), to reset it to its initial state (`clear`) and even
2040 to swap two handlers (`swap`).
2041 
2042 Besides them, there are member functions to use both to connect and disconnect
2043 listeners in all their forms:
2044 
2045 ```cpp
2046 void foo(int, char) { /* ... */ }
2047 
2048 struct S {
2049  void bar(int, char) { /* ... */ }
2050 };
2051 
2052 // ...
2053 
2054 S instance;
2055 
2056 signal.connect<&foo>();
2057 signal.connect<S, &S::bar>(&instance);
2058 
2059 // ...
2060 
2061 signal.disconnect<&foo>();
2062 
2063 // disconnect a specific member function of an instance ...
2064 signal.disconnect<S, &S::bar>(&instance);
2065 
2066 // ... or an instance as a whole
2067 signal.disconnect(&instance);
2068 ```
2069 
2070 Once listeners are attached (or even if there are no listeners at all), events
2071 and data in general can be published through a signal by means of the `publish`
2072 member function:
2073 
2074 ```cpp
2075 signal.publish(42, 'c');
2076 ```
2077 
2078 To collect data, the `collect` member function should be used instead. Below is
2079 a minimal example to show how to use it:
2080 
2081 ```cpp
2082 struct MyCollector {
2083  std::vector<int> vec{};
2084 
2085  bool operator()(int v) noexcept {
2086  vec.push_back(v);
2087  return true;
2088  }
2089 };
2090 
2091 int f() { return 0; }
2092 int g() { return 1; }
2093 
2094 // ...
2095 
2096 entt::SigH<int(), MyCollector<int>> signal;
2097 
2098 signal.connect<&f>();
2099 signal.connect<&g>();
2100 
2101 MyCollector collector = signal.collect();
2102 
2103 assert(collector.vec[0] == 0);
2104 assert(collector.vec[1] == 1);
2105 ```
2106 
2107 As shown above, a collector must expose a function operator that accepts as an
2108 argument a type to which the return type of the listeners can be converted.
2109 Moreover, it has to return a boolean value that is false to stop collecting
2110 data, true otherwise. This way one can avoid calling all the listeners in case
2111 it isn't necessary.
2112 
2113 ## Compile-time event bus
2114 
2115 A bus can be used to create a compile-time backbone for event management.<br/>
2116 The intended use is as a base class, which is the opposite of what the signals
2117 are meant for. Internally it uses either managed or unmanaged signal handlers,
2118 that is why there exist both a managed and an unmanaged event bus.
2119 
2120 The API of a bus is a kind of subset of the one of a signal. First of all, it
2121 requires that all the types of events are specified when the bus is declared:
2122 
2123 ```cpp
2124 struct AnEvent { int value; };
2125 struct AnotherEvent {};
2126 
2127 // define a managed bus that works with std::shared_ptr/std::weak_ptr
2128 entt::ManagedBus<AnEvent, AnotherEvent> managed;
2129 
2130 // define an unmanaged bus that works with naked pointers
2131 entt::UnmanagedBus<AnEvent, AnotherEvent> unmanaged;
2132 ```
2133 
2134 For the sake of brevity, below is described the interface of the sole unmanaged
2135 bus. The interface of the managed bus is almost the same but for the fact that
2136 it accepts smart pointers instead of naked pointers.
2137 
2138 In order to register an instance of a class to a bus, its type must expose one
2139 or more member functions named `receive` of which the return types are `void`
2140 and the argument lists are `const E &`, for each type of event `E`.<br/>
2141 The `reg` member function is the way to go to register such an instance:
2142 
2143 ```cpp
2144 struct Listener
2145 {
2146  void receive(const AnEvent &) { /* ... */ }
2147  void receive(const AnotherEvent &) { /* ... */ }
2148 };
2149 
2150 // ...
2151 
2152 Listener listener;
2153 bus.reg(&listener);
2154 ```
2155 
2156 To disconnect an instance of a class from a bus, use the `unreg` member
2157 function instead:
2158 
2159 ```cpp
2160 bus.unreg(&listener);
2161 ```
2162 
2163 Each function that respects the accepted signature is automatically registered
2164 and/or unregistered. Note that invoking `unreg` with an instance of a class that
2165 hasn't been previously registered is a perfectly valid operation.
2166 
2167 Free functions can be registered and unregistered as well by means of the
2168 dedicated member functions, namely `connect` and `disconnect`:
2169 
2170 ```cpp
2171 void foo(const AnEvent &) { /* ... */ }
2172 void bar(const AnotherEvent &) { /* ... */ }
2173 
2174 // ...
2175 
2176 bus.connect<AnEvent, &foo>();
2177 bus.connect<AnotherEvent, &bar>();
2178 
2179 // ...
2180 
2181 bus.disconnect<AnEvent, &foo>();
2182 bus.disconnect<AnotherEvent, &bar>();
2183 ```
2184 
2185 Whenever the need to send an event arises, it can be done through the `publish`
2186 member function:
2187 
2188 ```cpp
2189 bus.publish<AnEvent>(42);
2190 bus.publish<AnotherEvent>();
2191 ```
2192 
2193 Finally, there are another few functions to use to query the internal state of a
2194 bus like `empty` and `size` whose meaning is quite intuitive.
2195 
2196 ## Delegate
2197 
2198 A delegate can be used as general purpose invoker with no memory overhead for
2199 free functions and member functions provided along with an instance on which
2200 to invoke them.<br/>
2201 It does not claim to be a drop-in replacement for an `std::function`, so do not
2202 expect to use it whenever an `std::function` fits well. However, it can be used
2203 to send opaque delegates around to be used to invoke functions as needed.
2204 
2205 The interface is trivial. It offers a default constructor to create empty
2206 delegates:
2207 
2208 ```cpp
2209 entt::Delegate<int(int)> delegate{};
2210 ```
2211 
2212 All what is needed to create an instance is to specify the type of the function
2213 the delegate will _contain_, that is the signature of the free function or the
2214 member function one wants to assign to it.
2215 
2216 Attempting to use an empty delegate by invoking its function call operator
2217 results in undefined behavior, most likely a crash actually. Before to use a
2218 delegate, it must be initialized.<br/>
2219 There exist two functions to do that, both named `connect`:
2220 
2221 ```cpp
2222 int f(int i) { return i; }
2223 
2224 struct MyStruct {
2225  int f(int i) { return i }
2226 };
2227 
2228 // bind a free function to the delegate
2229 delegate.connect<&f>();
2230 
2231 // bind a member function to the delegate
2232 MyStruct instance;
2233 delegate.connect<MyStruct, &MyStruct::f>(&instance);
2234 ```
2235 
2236 It hasn't a `disconnect` counterpart. Instead, there exists a `reset` member
2237 function to clear it.<br/>
2238 Finally, to invoke a delegate, the function call operator is the way to go as
2239 usual:
2240 
2241 ```cpp
2242 auto ret = delegate(42);
2243 ```
2244 
2245 Probably too much small and pretty poor of functionalities, but the delegate
2246 class can help in a lot of cases and it has shown that it is worth keeping it
2247 within the framework.
2248 
2249 ## Event dispatcher
2250 
2251 The event dispatcher class is designed so as to be used in a loop. It allows
2252 users both to trigger immediate events or to queue events to be published all
2253 together once per tick.<br/>
2254 Internally it uses either managed or unmanaged signal handlers, that is why
2255 there exist both a managed and an unmanaged event dispatcher.
2256 
2257 This class shares part of its API with the one of the signals, but it doesn't
2258 require that all the types of events are specified when declared:
2259 
2260 ```cpp
2261 // define a managed dispatcher that works with std::shared_ptr/std::weak_ptr
2262 entt::Dispatcher<entt::Signal> managed{};
2263 
2264 // define an unmanaged dispatcher that works with naked pointers
2265 entt::Dispatcher<entt::SigH> unmanaged{};
2266 ```
2267 
2268 Actually there exist two aliases for the classes shown in the previous example:
2269 `entt::ManagedDispatcher` and `entt::UnmanagedDispatcher`.
2270 
2271 For the sake of brevity, below is described the interface of the sole unmanaged
2272 dispatcher. The interface of the managed dispatcher is almost the same but for
2273 the fact that it accepts smart pointers instead of naked pointers.
2274 
2275 In order to register an instance of a class to a dispatcher, its type must
2276 expose one or more member functions of which the return types are `void` and the
2277 argument lists are `const E &`, for each type of event `E`.<br/>
2278 To ease the development, member functions that are named `receive` are
2279 automatically detected and have not to be explicitly specified when registered.
2280 In all the other cases, the name of the member function aimed to receive the
2281 event must be provided to the `connect` member function:
2282 
2283 ```cpp
2284 struct AnEvent { int value; };
2285 struct AnotherEvent {};
2286 
2287 struct Listener
2288 {
2289  void receive(const AnEvent &) { /* ... */ }
2290  void method(const AnotherEvent &) { /* ... */ }
2291 };
2292 
2293 // ...
2294 
2295 Listener listener;
2296 dispatcher.connect<AnEvent>(&listener);
2297 dispatcher.connect<AnotherEvent, Listener, &Listener::method>(&listener);
2298 ```
2299 
2300 The `disconnect` member function follows the same pattern and can be used to
2301 selectively remove listeners:
2302 
2303 ```cpp
2304 dispatcher.disconnect<AnEvent>(&listener);
2305 dispatcher.disconnect<AnotherEvent, Listener, &Listener::method>(&listener);
2306 ```
2307 
2308 The `trigger` member function serves the purpose of sending an immediate event
2309 to all the listeners registered so far. It offers a convenient approach that
2310 relieves the user from having to create the event itself. Instead, it's enough
2311 to specify the type of event and provide all the parameters required to
2312 construct it.<br/>
2313 As an example:
2314 
2315 ```cpp
2316 dispatcher.trigger<AnEvent>(42);
2317 dispatcher.trigger<AnotherEvent>();
2318 ```
2319 
2320 Listeners are invoked immediately, order of execution isn't guaranteed. This
2321 method can be used to push around urgent messages like an _is terminating_
2322 notification on a mobile app.
2323 
2324 On the other hand, the `enqueue` member function queues messages together and
2325 allows to maintain control over the moment they are sent to listeners. The
2326 signature of this method is more or less the same of `trigger`:
2327 
2328 ```cpp
2329 dispatcher.enqueue<AnEvent>(42);
2330 dispatcher.enqueue<AnotherEvent>();
2331 ```
2332 
2333 Events are stored aside until the `update` member function is invoked, then all
2334 the messages that are still pending are sent to the listeners at once:
2335 
2336 ```cpp
2337 dispatcher.update();
2338 ```
2339 
2340 This way users can embed the dispatcher in a loop and literally dispatch events
2341 once per tick to their systems.
2342 
2343 ## Event emitter
2344 
2345 A general purpose event emitter thought mainly for those cases where it comes to
2346 working with asynchronous stuff.<br/>
2347 Originally designed to fit the requirements of
2348 [`uvw`](https://github.com/skypjack/uvw) (a wrapper for `libuv` written in
2349 modern C++), it was adapted later to be included in this library.
2350 
2351 To create a custom emitter type, derived classes must inherit directly from the
2352 base class as:
2353 
2354 ```cpp
2355 struct MyEmitter: Emitter<MyEmitter> {
2356  // ...
2357 }
2358 ```
2359 
2360 The full list of accepted types of events isn't required. Handlers are created
2361 internally on the fly and thus each type of event is accepted by default.
2362 
2363 Whenever an event is published, an emitter provides the listeners with a
2364 reference to itself along with a const reference to the event. Therefore
2365 listeners have an handy way to work with it without incurring in the need of
2366 capturing a reference to the emitter itself.<br/>
2367 In addition, an opaque object is returned each time a connection is established
2368 between an emitter and a listener, allowing the caller to disconnect them at a
2369 later time.<br/>
2370 The opaque object used to handle connections is both movable and copyable. On
2371 the other side, an event emitter is movable but not copyable by default.
2372 
2373 To create new instances of an emitter, no arguments are required:
2374 
2375 ```cpp
2376 MyEmitter emitter{};
2377 ```
2378 
2379 Listeners must be movable and callable objects (free functions, lambdas,
2380 functors, `std::function`s, whatever) whose function type is:
2381 
2382 ```cpp
2383 void(const Event &, MyEmitter &)
2384 ```
2385 
2386 Where `Event` is the type of event they want to listen.<br/>
2387 There are two ways to attach a listener to an event emitter that differ
2388 slightly from each other:
2389 
2390 * To register a long-lived listener, use the `on` member function. It is meant
2391  to register a listener designed to be invoked more than once for the given
2392  event type.<br/>
2393  As an example:
2394 
2395  ```cpp
2396  auto conn = emitter.on<MyEvent>([](const MyEvent &event, MyEmitter &emitter) {
2397  // ...
2398  });
2399  ```
2400 
2401  The connection object can be freely discarded. Otherwise, it can be used later
2402  to disconnect the listener if required.
2403 
2404 * To register a short-lived listener, use the `once` member function. It is
2405  meant to register a listener designed to be invoked only once for the given
2406  event type. The listener is automatically disconnected after the first
2407  invocation.<br/>
2408  As an example:
2409 
2410  ```cpp
2411  auto conn = emitter.once<MyEvent>([](const MyEvent &event, MyEmitter &emitter) {
2412  // ...
2413  });
2414  ```
2415 
2416  The connection object can be freely discarded. Otherwise, it can be used later
2417  to disconnect the listener if required.
2418 
2419 In both cases, the connection object can be used with the `erase` member
2420 function:
2421 
2422 ```cpp
2423 emitter.erase(conn);
2424 ```
2425 
2426 There are also two member functions to use either to disconnect all the
2427 listeners for a given type of event or to clear the emitter:
2428 
2429 ```cpp
2430 // removes all the listener for the specific event
2431 emitter.clear<MyEvent>();
2432 
2433 // removes all the listeners registered so far
2434 emitter.clear();
2435 ```
2436 
2437 To send an event to all the listeners that are interested in it, the `publish`
2438 member function offers a convenient approach that relieves the user from having
2439 to create the event:
2440 
2441 ```cpp
2442 struct MyEvent { int i; };
2443 
2444 // ...
2445 
2446 emitter.publish<MyEvent>(42);
2447 ```
2448 
2449 Finally, the `empty` member function tests if there exists at least either a
2450 listener registered with the event emitter or to a given type of event:
2451 
2452 ```cpp
2453 bool empty;
2454 
2455 // checks if there is any listener registered for the specific event
2456 empty = emitter.empty<MyEvent>();
2457 
2458 // checks it there are listeners registered with the event emitter
2459 empty = emitter.empty();
2460 ```
2461 
2462 In general, the event emitter is a handy tool when the derived classes _wrap_
2463 asynchronous operations, because it introduces a _nice-to-have_ model based on
2464 events and listeners that kindly hides the complexity behind the scenes. However
2465 it is not limited to such uses.
2466 
2467 # Contributors
2468 
2469 If you want to contribute, please send patches as pull requests against the
2470 branch `master`.<br/>
2471 See the
2472 [contributors list](https://github.com/skypjack/entt/blob/master/AUTHORS) to
2473 know who has participated so far.
2474 
2475 # License
2476 
2477 Code and documentation Copyright (c) 2018 Michele Caini.<br/>
2478 Code released under
2479 [the MIT license](https://github.com/skypjack/entt/blob/master/LICENSE).
2480 Docs released under
2481 [Creative Commons](https://github.com/skypjack/entt/blob/master/docs/LICENSE).
2482 
2483 # Support
2484 
2485 ## Donation
2486 
2487 Developing and maintaining `EnTT` takes some time and lots of coffee. I'd like
2488 to add more and more functionalities in future and turn it in a full-featured
2489 framework.<br/>
2490 If you want to support this project, you can offer me an espresso. I'm from
2491 Italy, we're used to turning the best coffee ever in code. If you find that
2492 it's not enough, feel free to support me the way you prefer.<br/>
2493 Take a look at the donation button at the top of the page for more details or
2494 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).
2495 
2496 ## Hire me
2497 
2498 If you start using `EnTT` and need help, if you want a new feature and want me
2499 to give it the highest priority, if you have any other reason to contact me:
2500 do not hesitate. I'm available for hiring.<br/>
2501 Feel free to take a look at my [profile](https://github.com/skypjack) and
2502 contact me by mail.
+
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 # Table of Contents
9 
10 * [Introduction](#introduction)
11 * [Build Instructions](#build-instructions)
12 * [Crash Course: entity-component system](#crash-course-entity-component-system)
13  * [Design choices](#design-choices)
14  * [A bitset-free entity-component system](#a-bitset-free-entity-component-system)
15  * [Pay per use](#pay-per-use)
16  * [Vademecum](#vademecum)
17  * [The Registry, the Entity and the Component](#the-registry-the-entity-and-the-component)
18  * [Single instance components](#single-instance-components)
19  * [Observe changes](#observe-changes)
20  * [Who let the tags out?](#who-let-the-tags-out)
21  * [Runtime components](#runtime-components)
22  * [A journey through a plugin](#a-journey-through-a-plugin)
23  * [Sorting: is it possible?](#sorting-is-it-possible)
24  * [Snapshot: complete vs continuous](#snapshot-complete-vs-continuous)
25  * [Snapshot loader](#snapshot-loader)
26  * [Continuous loader](#continuous-loader)
27  * [Archives](#archives)
28  * [One example to rule them all](#one-example-to-rule-them-all)
29  * [Prototype](#prototype)
30  * [Helpers](#helpers)
31  * [Dependency function](#dependency-function)
32  * [View: to persist or not to persist?](#view-to-persist-or-not-to-persist)
33  * [Standard View](#standard-view)
34  * [Single component standard view](#single-component-standard-view)
35  * [Multi component standard view](#multi-component-standard-view)
36  * [Persistent View](#persistent-view)
37  * [Raw View](#raw-view)
38  * [Give me everything](#give-me-everything)
39  * [Side notes](#side-notes)
40 * [Crash Course: core functionalities](#crash-course-core-functionalities)
41  * [Compile-time identifiers](#compile-time-identifiers)
42  * [Runtime identifiers](#runtime-identifiers)
43  * [Hashed strings](#hashed-strings)
44 * [Crash Course: service locator](#crash-course-service-locator)
45 * [Crash Course: cooperative scheduler](#crash-course-cooperative-scheduler)
46  * [The process](#the-process)
47  * [The scheduler](#the-scheduler)
48 * [Crash Course: resource management](#crash-course-resource-management)
49  * [The resource, the loader and the cache](#the-resource-the-loader-and-the-cache)
50 * [Crash Course: events, signals and everything in between](#crash-course-events-signals-and-everything-in-between)
51  * [Signals](#signals)
52  * [Delegate](#delegate)
53  * [Event dispatcher](#event-dispatcher)
54  * [Event emitter](#event-emitter)
55 * [Packaging Tools](#packaging-tools)
56 * [EnTT in Action](#entt-in-action)
57 * [License](#license)
58 * [Support](#support)
59  * [Donation](#donation)
60  * [Hire me](#hire-me)
61 
62 # Introduction
63 
64 `EnTT` is a header-only, tiny and easy to use framework written in modern
65 C++.<br/>
66 It was originally designed entirely around an architectural pattern called _ECS_
67 that is used mostly in game development. For further details:
68 
69 * [Entity Systems Wiki](http://entity-systems.wikidot.com/)
70 * [Evolve Your Hierarchy](http://cowboyprogramming.com/2007/01/05/evolve-your-heirachy/)
71 * [ECS on Wikipedia](https://en.wikipedia.org/wiki/Entity%E2%80%93component%E2%80%93system)
72 
73 A long time ago, the sole entity-component system was part of the project. After
74 a while the codebase has grown and more and more classes have become part of the
75 repository.<br/>
76 That's why today it's called _the EnTT Framework_.
77 
78 Currently, `EnTT` is tested on Linux, Microsoft Windows and OS X. It has proven
79 to work also on both Android and iOS.<br/>
80 Most likely it will not be problematic on other systems as well, but has not
81 been sufficiently tested so far.
82 
83 ## The framework
84 
85 `EnTT` was written initially as a faster alternative to other well known and
86 open source entity-component systems. Nowadays the `EnTT` framework is moving
87 its first steps. Much more will come in the future and hopefully I'm going to
88 work on it for a long time.<br/>
89 Requests for feature, PR, suggestions ad feedback are highly appreciated.
90 
91 If you find you can help me and want to contribute to the `EnTT` framework with
92 your experience or you do want to get part of the project for some other
93 reasons, feel free to contact me directly (you can find the mail in the
94 [profile](https://github.com/skypjack)).<br/>
95 I can't promise that each and every contribution will be accepted, but I can
96 assure that I'll do my best to take them all seriously.
97 
98 ### State of the art
99 
100 Here is a brief list of what it offers today:
101 
102 * Statically generated integer identifiers for types (assigned either at
103  compile-time or at runtime).
104 * A constexpr utility for human readable resource identifiers.
105 * An incredibly fast entity-component system based on sparse sets, with its own
106  views and a _pay for what you use_ policy to adjust performance and memory
107  usage according to users' requirements.
108 * Actor class for those who aren't confident with entity-component systems.
109 * The smallest and most basic implementation of a service locator ever seen.
110 * A cooperative scheduler for processes of any type.
111 * All what is needed for resource management (cache, loaders, handles).
112 * Delegates, signal handlers (with built-in support for collectors) and a tiny
113  event dispatcher.
114 * A general purpose event emitter, that is a CRTP idiom based class template.
115 * An event dispatcher for immediate and delayed events to integrate in loops.
116 * ...
117 * Any other business.
118 
119 Consider it a work in progress. For more details and an updated list, please
120 refer to the [online documentation](https://skypjack.github.io/entt/). It
121 probably contains much more. Moreover, the whole API is fully documented in-code
122 for those who are brave enough to read it.<br/>
123 Continue reading to know how the different parts of the project work or follow
124 the link above to take a look at the API reference.
125 
126 ## Code Example
127 
128 ```cpp
129 #include <entt/entt.hpp>
130 #include <cstdint>
131 
132 struct Position {
133  float x;
134  float y;
135 };
136 
137 struct Velocity {
138  float dx;
139  float dy;
140 };
141 
142 void update(entt::DefaultRegistry &registry) {
143  auto view = registry.view<Position, Velocity>();
144 
145  for(auto entity: view) {
146  // gets only the components that are going to be used ...
147 
148  auto &velocity = view.get<Velocity>(entity);
149 
150  velocity.dx = 0.;
151  velocity.dy = 0.;
152 
153  // ...
154  }
155 }
156 
157 void update(std::uint64_t dt, entt::DefaultRegistry &registry) {
158  registry.view<Position, Velocity>().each([dt](auto entity, auto &position, auto &velocity) {
159  // gets all the components of the view at once ...
160 
161  position.x += velocity.dx * dt;
162  position.y += velocity.dy * dt;
163 
164  // ...
165  });
166 }
167 
168 int main() {
169  entt::DefaultRegistry registry;
170  std::uint64_t dt = 16;
171 
172  for(auto i = 0; i < 10; ++i) {
173  auto entity = registry.create();
174  registry.assign<Position>(entity, i * 1.f, i * 1.f);
175  if(i % 2 == 0) { registry.assign<Velocity>(entity, i * .1f, i * .1f); }
176  }
177 
178  update(dt, registry);
179  update(registry);
180 
181  // ...
182 }
183 ```
184 
185 ## Motivation
186 
187 I started working on `EnTT` because of the wrong reason: my goal was to design
188 an entity-component system that beated another well known open source solution
189 in terms of performance and used (possibly) less memory in the average
190 case.<br/>
191 In the end, I did it, but it wasn't much satisfying. Actually it wasn't
192 satisfying at all. The fastest and nothing more, fairly little indeed. When I
193 realized it, I tried hard to keep intact the great performance of `EnTT` and to
194 add all the features I wanted to see in *my own library* at the same time.
195 
196 Today `EnTT` is finally what I was looking for: still faster than its
197 _competitors_, lower memory usage in the average case, a really good API and an
198 amazing set of features. And even more, of course.
199 
200 ## Performance
201 
202 As it stands right now, `EnTT` is just fast enough for my requirements if
203 compared to my first choice (it was already amazingly fast actually).<br/>
204 Below is a comparison between the two (both of them compiled with GCC 7.3.0 on a
205 Dell XPS 13 out of the mid 2014):
206 
207 | Benchmark | EntityX (compile-time) | EnTT |
208 |-----------|-------------|-------------|
209 | Create 1M entities | 0.0147s | **0.0046s** |
210 | Destroy 1M entities | 0.0053s | **0.0045s** |
211 | Standard view, 1M entities, one component | 0.0012s | **1.9e-07s** |
212 | Standard view, 1M entities, two components | 0.0012s | **3.8e-07s** |
213 | Standard view, 1M entities, two components<br/>Half of the entities have all the components | 0.0009s | **3.8e-07s** |
214 | Standard view, 1M entities, two components<br/>One of the entities has all the components | 0.0008s | **1.0e-06s** |
215 | Persistent view, 1M entities, two components | 0.0012s | **2.8e-07s** |
216 | Standard view, 1M entities, five components | 0.0010s | **7.0e-07s** |
217 | Persistent view, 1M entities, five components | 0.0010s | **2.8e-07s** |
218 | Standard view, 1M entities, ten components | 0.0011s | **1.2e-06s** |
219 | Standard view, 1M entities, ten components<br/>Half of the entities have all the components | 0.0010s | **1.2e-06s** |
220 | Standard view, 1M entities, ten components<br/>One of the entities has all the components | 0.0008s | **1.2e-06s** |
221 | Persistent view, 1M entities, ten components | 0.0011s | **3.0e-07s** |
222 | Raw view, 1M entities | - | **2.2e-07s** |
223 | Sort 150k entities, one component<br/>Arrays are in reverse order | - | **0.0036s** |
224 | Sort 150k entities, enforce permutation<br/>Arrays are in reverse order | - | **0.0005s** |
225 | Sort 150k entities, one component<br/>Arrays are almost sorted, std::sort | - | **0.0035s** |
226 | Sort 150k entities, one component<br/>Arrays are almost sorted, insertion sort | - | **0.0007s** |
227 
228 Note: The default version of `EntityX` (`master` branch) wasn't added to the
229 comparison because it's already much slower than its compile-time counterpart.
230 
231 Pretty interesting, aren't them? In fact, these benchmarks are the same used by
232 `EntityX` to show _how fast it is_. To be honest, they aren't so good and these
233 results shouldn't be taken much seriously (they are completely unrealistic
234 indeed).<br/>
235 The proposed entity-component system is incredibly fast to iterate entities,
236 this is a fact. The compiler can make a lot of optimizations because of how
237 `EnTT` works, even more when components aren't used at all. This is exactly the
238 case for these benchmarks. On the other hand and if we consider real world
239 cases, `EnTT` is in the middle between a bit and much faster than the other
240 solutions around when users also access the components and not just the
241 entities, although it is not as fast as reported by these benchmarks.<br/>
242 This is why they are completely wrong and cannot be used to evaluate any of the
243 entity-component systems.
244 
245 If you decide to use `EnTT`, choose it because of its API, features and
246 performance, not because there is a benchmark somewhere that makes it seem the
247 fastest.
248 
249 Probably I'll try to get out of `EnTT` more features and even better performance
250 in the future, mainly for fun.<br/>
251 If you want to contribute and/or have any suggestion, feel free to make a PR or
252 open an issue to discuss your idea.
253 
254 # Build Instructions
255 
256 ## Requirements
257 
258 To be able to use `EnTT`, users must provide a full-featured compiler that
259 supports at least C++14.<br/>
260 The requirements below are mandatory to compile the tests and to extract the
261 documentation:
262 
263 * CMake version 3.2 or later.
264 * Doxygen version 1.8 or later.
265 
266 ## Library
267 
268 `EnTT` is a header-only library. This means that including the `entt.hpp`
269 header is enough to include the whole framework and use it. For those who are
270 interested only in the entity-component system, consider to include the sole
271 `entity/registry.hpp` header instead.<br/>
272 It's a matter of adding the following line to the top of a file:
273 
274 ```cpp
275 #include <entt/entt.hpp>
276 ```
277 
278 Use the line below to include only the entity-component system instead:
279 
280 ```cpp
281 #include <entt/entity/registry.hpp>
282 ```
283 
284 Then pass the proper `-I` argument to the compiler to add the `src` directory to
285 the include paths.
286 
287 ## Documentation
288 
289 The documentation is based on [doxygen](http://www.stack.nl/~dimitri/doxygen/).
290 To build it:
291 
292  $ cd build
293  $ cmake ..
294  $ make docs
295 
296 The API reference will be created in HTML format within the directory
297 `build/docs/html`. To navigate it with your favorite browser:
298 
299  $ cd build
300  $ your_favorite_browser docs/html/index.html
301 
302 The API reference is also available [online](https://skypjack.github.io/entt/)
303 for the latest version.
304 
305 ## Tests
306 
307 To compile and run the tests, `EnTT` requires *googletest*.<br/>
308 `cmake` will download and compile the library before to compile anything else.
309 
310 To build the most basic set of tests:
311 
312 * `$ cd build`
313 * `$ cmake ..`
314 * `$ make`
315 * `$ make test`
316 
317 Note that benchmarks are not part of this set.
318 
319 # Crash Course: entity-component system
320 
321 ## Design choices
322 
323 ### A bitset-free entity-component system
324 
325 `EnTT` is a _bitset-free_ entity-component system that doesn't require users to
326 specify the component set at compile-time.<br/>
327 This is why users can instantiate the core class simply like:
328 
329 ```cpp
330 entt::DefaultRegistry registry;
331 ```
332 
333 In place of its more annoying and error-prone counterpart:
334 
335 ```cpp
336 entt::DefaultRegistry<Comp0, Comp1, ..., CompN> registry;
337 ```
338 
339 ### Pay per use
340 
341 `EnTT` is entirely designed around the principle that users have to pay only for
342 what they want.
343 
344 When it comes to using an entity-component system, the tradeoff is usually
345 between performance and memory usage. The faster it is, the more memory it uses.
346 However, slightly worse performance along non-critical paths are the right price
347 to pay to reduce memory usage and I've always wondered why this kind of tools do
348 not leave me the choice.<br/>
349 `EnTT` follows a completely different approach. It squeezes the best from the
350 basic data structures and gives users the possibility to pay more for higher
351 performance where needed.<br/>
352 The disadvantage of this approach is that users need to know the systems they
353 are working on and the tools they are using. Otherwise, the risk to ruin the
354 performance along critical paths is high.
355 
356 So far, this choice has proven to be a good one and I really hope it can be for
357 many others besides me.
358 
359 ## Vademecum
360 
361 The `Registry` to store, the views to iterate. That's all.
362 
363 An entity (the _E_ of an _ECS_) is an opaque identifier that users should just
364 use as-is and store around if needed. Do not try to inspect an entity
365 identifier, its format can change in future and a registry offers all the
366 functionalities to query them out-of-the-box. The underlying type of an entity
367 (either `std::uint16_t`, `std::uint32_t` or `std::uint64_t`) can be specified
368 when defining a registry (actually the `DefaultRegistry` is nothing more than a
369 `Registry` where the type of the entities is `std::uint32_t`).<br/>
370 Components (the _C_ of an _ECS_) should be plain old data structures or more
371 complex and movable data structures with a proper constructor. Actually, the
372 sole requirement of a component type is that it must be both move constructible
373 and move assignable. They are list initialized by using the parameters provided
374 to construct the component itself. No need to register components or their types
375 neither with the registry nor with the entity-component system at all.<br/>
376 Systems (the _S_ of an _ECS_) are just plain functions, functors, lambdas or
377 whatever users want. They can accept a `Registry` or a view of any type and use
378 them the way they prefer. No need to register systems or their types neither
379 with the registry nor with the entity-component system at all.
380 
381 The following sections will explain in short how to use the entity-component
382 system, the core part of the whole framework.<br/>
383 In fact, the framework is composed of many other classes in addition to those
384 describe below. For more details, please refer to the inline documentation.
385 
386 ## The Registry, the Entity and the Component
387 
388 A registry can store and manage entities, as well as create views to iterate the
389 underlying data structures.<br/>
390 `Registry` is a class template that lets users decide what's the preferred type
391 to represent an entity. Because `std::uint32_t` is large enough for almost all
392 the cases, there exists also an alias named `DefaultRegistry` for
393 `Registry<std::uint32_t>`.
394 
395 Entities are represented by _entity identifiers_. An entity identifier is an
396 opaque type that users should not inspect or modify in any way. It carries
397 information about the entity itself and its version.
398 
399 A registry can be used both to construct and destroy entities, as well as to
400 clone already existing entities:
401 
402 ```cpp
403 // constructs a naked entity with no components and returns its identifier
404 auto entity = registry.create();
405 
406 // clones an entity and assigns all its components by copy to the newly created one
407 auto other = registry.clone(entity);
408 
409 // destroys an entity and all its components
410 registry.destroy(entity);
411 ```
412 
413 Be aware that cloning an entity can lead to unexpected results under certain
414 conditions. Please refer to the inline documentation for more details.<br/>
415 Once an entity is deleted, the registry can freely reuse it internally with a
416 slightly different identifier. In particular, the version of an entity is
417 increased each and every time it's destroyed.<br/>
418 In case entity identifiers are stored around, the registry offers all the
419 functionalities required to test them and get out of the them all the
420 information they carry:
421 
422 ```cpp
423 // returns true if the entity is still valid, false otherwise
424 bool b = registry.valid(entity);
425 
426 // gets the version contained in the entity identifier
427 auto version = registry.version(entity);
428 
429 // gets the actual version for the given entity
430 auto curr = registry.current(entity);
431 ```
432 
433 Finally, there is also a sort of _null identifier_ made available to users. It's
434 treated as if it were a _null pointer_ that doesn't identify any entity. A
435 registry will reject this identifier in all cases because it isn't considered
436 valid.<br/>
437 The rules that define a _null identifier_ are a bit tricky to explain. However,
438 being `Entity` the type of the entities (for example, `std::uint32_t`), users
439 can easily construct a _null identifier_ by flipping all the bits of the _zero_:
440 
441 ```cpp
442 using Entity = std::uint32_t;
443 const auto null = ~Entity{};
444 ```
445 
446 Components can be assigned to or removed from entities at any time with a few
447 calls to member functions of the registry. As for the entities, the registry
448 offers also a set of functionalities users can use to work with the components.
449 
450 The `assign` member function template creates, initializes and assigns to an
451 entity the given component. It accepts a variable number of arguments to
452 construct the component itself if present:
453 
454 ```cpp
455 registry.assign<Position>(entity, 0., 0.);
456 
457 // ...
458 
459 Velocity &velocity = registry.assign<Velocity>(entity);
460 velocity.dx = 0.;
461 velocity.dy = 0.;
462 ```
463 
464 If an entity already has the given component, the `replace` member function
465 template can be used to replace it:
466 
467 ```cpp
468 registry.replace<Position>(entity, 0., 0.);
469 
470 // ...
471 
472 Velocity &velocity = registry.replace<Velocity>(entity);
473 velocity.dx = 0.;
474 velocity.dy = 0.;
475 ```
476 
477 In case users want to assign a component to an entity, but it's unknown whether
478 the entity already has it or not, `accommodate` does the work in a single call
479 (there is a performance penalty to pay for this mainly due to the fact that it
480 has to check if the entity already has the given component or not):
481 
482 ```cpp
483 registry.accommodate<Position>(entity, 0., 0.);
484 
485 // ...
486 
487 Velocity &velocity = registry.accommodate<Velocity>(entity);
488 velocity.dx = 0.;
489 velocity.dy = 0.;
490 ```
491 
492 Note that `accommodate` is a slightly faster alternative for the following
493 `if/else` statement and nothing more:
494 
495 ```cpp
496 if(registry.has<Comp>(entity)) {
497  registry.replace<Comp>(entity, arg1, argN);
498 } else {
499  registry.assign<Comp>(entity, arg1, argN);
500 }
501 ```
502 
503 As already shown, if in doubt about whether or not an entity has one or more
504 components, the `has` member function template may be useful:
505 
506 ```cpp
507 bool b = registry.has<Position, Velocity>(entity);
508 ```
509 
510 On the other side, if the goal is to delete a single component, the `remove`
511 member function template is the way to go when it's certain that the entity owns
512 a copy of the component:
513 
514 ```cpp
515 registry.remove<Position>(entity);
516 ```
517 
518 Otherwise consider to use the `reset` member function. It behaves similarly to
519 `remove` but with a strictly defined behavior (and a performance penalty is the
520 price to pay for this). In particular it removes the component if and only if it
521 exists, otherwise it returns safely to the caller:
522 
523 ```cpp
524 registry.reset<Position>(entity);
525 ```
526 
527 There exist also two other _versions_ of the `reset` member function:
528 
529 * If no entity is passed to it, `reset` will remove the given component from
530  each entity that has it:
531 
532  ```cpp
533  registry.reset<Position>();
534  ```
535 
536 * If neither the entity nor the component are specified, all the entities still
537  in use and their components are destroyed:
538 
539  ```cpp
540  registry.reset();
541  ```
542 
543 Finally, references to components can be retrieved simply by doing this:
544 
545 ```cpp
546 const auto &cregistry = registry;
547 
548 // const and non-const reference
549 const Position &position = cregistry.get<Position>(entity);
550 Position &position = registry.get<Position>(entity);
551 
552 // const and non-const references
553 std::tuple<const Position &, const Velocity &> tup = cregistry.get<Position, Velocity>(entity);
554 std::tuple<Position &, Velocity &> tup = registry.get<Position, Velocity>(entity);
555 ```
556 
557 The `get` member function template gives direct access to the component of an
558 entity stored in the underlying data structures of the registry.
559 
560 ### Single instance components
561 
562 In those cases where all what is needed is a single instance component, tags are
563 the right tool to achieve the purpose.<br/>
564 Tags undergo the same requirements of components. They can be either plain old
565 data structures or more complex and movable data structures with a proper
566 constructor.<br/>
567 Actually, the same type can be used both as a tag and as a component and the
568 registry will not complain about it. It is up to users to properly manage their
569 own types. In some cases, the tag `tag_t` must also be used in order to
570 disambiguate overloads of member functions.
571 
572 Attaching tags to entities and removing them is trivial:
573 
574 ```cpp
575 auto player = registry.create();
576 auto camera = registry.create();
577 
578 // attaches a default-initialized tag to an entity
579 registry.assign<PlayingCharacter>(entt::tag_t{}, player);
580 
581 // attaches a tag to an entity and initializes it
582 registry.assign<Camera>(entt::tag_t{}, camera, player);
583 
584 // removes tags from their owners
585 registry.remove<PlayingCharacter>();
586 registry.remove<Camera>();
587 ```
588 
589 In case a tag already has an owner, its content can be updated by means of the
590 `replace` member function template and the ownership of the tag can be
591 transferred to another entity using the `move` member function template:
592 
593 ```
594 // replaces the content of the given tag
595 Point &point = registry.replace<Point>(entt::tag_t{}, 1.f, 1.f);
596 
597 // transfers the ownership of the tag to another entity
598 entity_type prev = registry.move<Point>(next);
599 ```
600 
601 If in doubt about whether or not a tag already has an owner, the `has` member
602 function template may be useful:
603 
604 ```cpp
605 bool b = registry.has<PlayingCharacter>();
606 ```
607 
608 References to tags can be retrieved simply by doing this:
609 
610 ```cpp
611 const auto &cregistry = registry;
612 
613 // either a non-const reference ...
614 PlayingCharacter &player = registry.get<PlayingCharacter>();
615 
616 // ... or a const one
617 const Camera &camera = cregistry.get<Camera>();
618 ```
619 
620 The `get` member function template gives direct access to the tag as stored in
621 the underlying data structures of the registry.
622 
623 As shown above, in almost all the cases the entity identifier isn't required.
624 Since a single instance component can have only one associated entity, it
625 doesn't make much sense to mention it explicitly.<br/>
626 To find out who the owner is, just do the following:
627 
628 ```cpp
629 auto player = registry.attachee<PlayingCharacter>();
630 ```
631 
632 Note that iterating tags isn't possible for obvious reasons. Tags give direct
633 access to single entities and nothing more.
634 
635 ### Observe changes
636 
637 Because of how the registry works internally, it stores a couple of signal
638 handlers for each pool in order to notify some of its data structures on the
639 construction and destruction of components.<br/>
640 These signal handlers are also exposed and made available to users. This is the
641 basic brick to build fancy things like dependencies and reactive systems.
642 
643 To get a sink to be used to connect and disconnect listeners so as to be
644 notified on the creation of a component, use the `construction` member function:
645 
646 ```cpp
647 // connects a free function
648 registry.construction<Position>().connect<&MyFreeFunction>();
649 
650 // connects a member function
651 registry.construction<Position>().connect<MyClass, &MyClass::member>(&instance);
652 
653 // disconnects a free function
654 registry.construction<Position>().disconnect<&MyFreeFunction>();
655 
656 // disconnects a member function
657 registry.construction<Position>().disconnect<MyClass, &MyClass::member>(&instance);
658 ```
659 
660 To be notified when components are destroyed, use the `destruction` member
661 function instead.
662 
663 The function type of a listener is the same in both cases:
664 
665 ```cpp
666 void(Registry<Entity> &, Entity);
667 ```
668 
669 In other terms, a listener is provided with the registry that triggered the
670 notification and the entity affected by the change. Note also that:
671 
672 * Listeners are invoked **after** components have been assigned to entities.
673 * Listeners are invoked **before** components have been removed from entities.
674 * The order of invocation of the listeners isn't guaranteed in any case.
675 
676 There are also some limitations on what a listener can and cannot do. In
677 particular:
678 
679 * Connecting and disconnecting other functions from within the body of a
680  listener should be avoided. It can lead to undefined behavior in some cases.
681 * Assigning and removing components and tags from within the body of a listener
682  that observes the destruction of instances of a given type should be avoided.
683  It can lead to undefined behavior in some cases. This type of listeners is
684  intended to provide users with an easy way to perform cleanup and nothing
685  more.
686 
687 To a certain extent, these limitations do not apply. However, it is risky to try
688 to force them and users should respect the limitations unless they know exactly
689 what they are doing. Subtle bugs are the price to pay in case of errors
690 otherwise.
691 
692 In general, events and therefore listeners must not be used as replacements for
693 systems. They should not contain much logic and interactions with a registry
694 should be kept to a minimum, if possible. Note also that the greater the number
695 of listeners, the greater the performance hit when components are created or
696 destroyed.
697 
698 #### Who let the tags out?
699 
700 As an extension, signals are also provided with tags. Although they are not
701 strictly required internally, it makes sense that a user expects signal support
702 even when it comes to tags actually.<br/>
703 Signals for tags undergo exactly the same requirements of those introduced for
704 components. Also the function type for a listener is the same and it's invoked
705 with the same guarantees discussed above.
706 
707 To get the sinks for a tag just use tag `tag_t` to disambiguate overloads of
708 member functions as in the following example:
709 
710 ```cpp
711 registry.construction<MyTag>(entt::tag_t{}).connect<&MyFreeFunction>();
712 registry.destruction<MyTag>(entt::tag_t{}).connect<MyClass, &MyClass::member>(&instance);
713 ```
714 
715 Listeners for tags and components are managed separately and do not influence
716 each other in any case. Therefore, note that the greater the number of listeners
717 for a type, the greater the performance hit when a tag of the given type is
718 created or destroyed.
719 
720 ### Runtime components
721 
722 Defining components at runtime is useful to support plugins and mods in general.
723 However, it seems impossible with a tool designed around a bunch of templates.
724 Indeed it's not that difficult.<br/>
725 Of course, some features cannot be easily exported into a runtime
726 environment. As an example, sorting a group of components defined at runtime
727 isn't for free if compared to most of the other operations. However, the basic
728 functionalities of an entity-component system such as `EnTT` fit the problem
729 perfectly and can also be used to manage runtime components if required.<br/>
730 All that is necessary to do it is to know the identifiers of the components. An
731 identifier is nothing more than a number or similar that can be used at runtime
732 to work with the type system.
733 
734 In `EnTT`, identifiers are easily accessible:
735 
736 ```cpp
737 entt::DefaultRegistry registry;
738 
739 // standard component identifier
740 auto ctype = registry.component<Position>();
741 
742 // single instance component identifier
743 auto ttype = registry.tag<PlayingCharacter>();
744 ```
745 
746 Once the identifiers are made available, almost everything becomes pretty
747 simple.
748 
749 #### A journey through a plugin
750 
751 `EnTT` comes with an example (actually a test) that shows how to integrate
752 compile-time and runtime components in a stack based JavaScript environment. It
753 uses [`Duktape`](https://github.com/svaarala/duktape) under the hood, mainly
754 because I wanted to learn how it works at the time I was writing the code.
755 
756 The code is not production-ready and overall performance can be highly improved.
757 However, I sacrificed optimizations in favor of a more readable piece of code. I
758 hope I succeeded.<br/>
759 Note also that this isn't neither the only nor (probably) the best way to do it.
760 In fact, the right way depends on the scripting language and the problem one is
761 facing in general.<br/>
762 That being said, feel free to use it at your own risk.
763 
764 The basic idea is that of creating a compile-time component aimed to map all the
765 runtime components assigned to an entity.<br/>
766 Identifiers come in use to address the right function from a map when invoked
767 from the runtime environment and to filter entities when iterating.<br/>
768 With a bit of gymnastic, one can narrow views and improve the performance to
769 some extent but it was not the goal of the example.
770 
771 ### Sorting: is it possible?
772 
773 It goes without saying that sorting entities and components is possible with
774 `EnTT`.<br/>
775 In fact, there are two functions that respond to slightly different needs:
776 
777 * Components can be sorted directly:
778 
779  ```cpp
780  registry.sort<Renderable>([](const auto &lhs, const auto &rhs) {
781  return lhs.z < rhs.z;
782 
783  });
784  ```
785 
786  There exists also the possibility to use a custom sort function object, as
787  long as it adheres to the requirements described in the inline
788  documentation.<br/>
789  This is possible mainly because users can get much more with a custom sort
790  function object if the pattern of usage is known. As an example, in case of an
791  almost sorted pool, quick sort could be much, much slower than insertion sort.
792 
793 * Components can be sorted according to the order imposed by another component:
794 
795  ```cpp
796  registry.sort<Movement, Physics>();
797  ```
798 
799  In this case, instances of `Movement` are arranged in memory so that cache
800  misses are minimized when the two components are iterated together.
801 
802 ### Snapshot: complete vs continuous
803 
804 The `Registry` class offers basic support to serialization.<br/>
805 It doesn't convert components and tags to bytes directly, there wasn't the need
806 of another tool for serialization out there. Instead, it accepts an opaque
807 object with a suitable interface (namely an _archive_) to serialize its internal
808 data structures and restore them later. The way types and instances are
809 converted to a bunch of bytes is completely in charge to the archive and thus to
810 final users.
811 
812 The goal of the serialization part is to allow users to make both a dump of the
813 entire registry or a narrower snapshot, that is to select only the components
814 and the tags in which they are interested.<br/>
815 Intuitively, the use cases are different. As an example, the first approach is
816 suitable for local save/restore functionalities while the latter is suitable for
817 creating client-server applications and for transferring somehow parts of the
818 representation side to side.
819 
820 To take a snapshot of the registry, use the `snapshot` member function. It
821 returns a temporary object properly initialized to _save_ the whole registry or
822 parts of it.
823 
824 Example of use:
825 
826 ```cpp
827 OutputArchive output;
828 
829 registry.snapshot()
830  .entities(output)
831  .destroyed(output)
832  .component<AComponent, AnotherComponent>(output)
833  .tag<MyTag>(output);
834 ```
835 
836 It isn't necessary to invoke all these functions each and every time. What
837 functions to use in which case mostly depends on the goal and there is not a
838 golden rule to do that.
839 
840 The `entities` member function asks the registry to serialize all the entities
841 that are still in use along with their versions. On the other side, the
842 `destroyed` member function tells to the registry to serialize the entities that
843 have been destroyed and are no longer in use.<br/>
844 These two functions can be used to save and restore the whole set of entities
845 with the versions they had during serialization.
846 
847 The `component` member function is a function template the aim of which is to
848 store aside components. The presence of a template parameter list is a
849 consequence of a couple of design choices from the past and in the present:
850 
851 * First of all, there is no reason to force a user to serialize all the
852  components at once and most of the times it isn't desiderable. As an example,
853  in case the stuff for the HUD in a game is put into the registry for some
854  reasons, its components can be freely discarded during a serialization step
855  because probably the software already knows how to reconstruct the HUD
856  correctly from scratch.
857 
858 * Furthermore, the registry makes heavy use of _type-erasure_ techniques
859  internally and doesn't know at any time what types of components it contains.
860  Therefore being explicit at the call point is mandatory.
861 
862 There exists also another version of the `component` member function that
863 accepts a range of entities to serialize. This version is a bit slower than the
864 other one, mainly because it iterates the range of entities more than once for
865 internal purposes. However, it can be used to filter out those entities that
866 shouldn't be serialized for some reasons.<br/>
867 As an example:
868 
869 ```cpp
870 const auto view = registry.view<Serialize>();
871 OutputArchive output;
872 
873 registry.snapshot()
874  .component<AComponent, AnotherComponent>(output, view.cbegin(), view.cend());
875 ```
876 
877 The `tag` member function is similar to the previous one, apart from the fact
878 that it works with tags and not with components.<br/>
879 Note also that both `component` and `tag` store items along with entities. It
880 means that they work properly without a call to the `entities` member function.
881 
882 Once a snapshot is created, there exist mainly two _ways_ to load it: as a whole
883 and in a kind of _continuous mode_.<br/>
884 The following sections describe both loaders and archives in details.
885 
886 #### Snapshot loader
887 
888 A snapshot loader requires that the destination registry be empty and loads all
889 the data at once while keeping intact the identifiers that the entities
890 originally had.<br/>
891 To do that, the registry offers a member function named `restore` that returns a
892 temporary object properly initialized to _restore_ a snapshot.
893 
894 Example of use:
895 
896 ```cpp
897 InputArchive input;
898 
899 registry.restore()
900  .entities(input)
901  .destroyed(input)
902  .component<AComponent, AnotherComponent>(input)
903  .tag<MyTag>(input)
904  .orphans();
905 ```
906 
907 It isn't necessary to invoke all these functions each and every time. What
908 functions to use in which case mostly depends on the goal and there is not a
909 golden rule to do that. For obvious reasons, what is important is that the data
910 are restored in exactly the same order in which they were serialized.
911 
912 The `entities` and `destroyed` member functions restore the sets of entities and
913 the versions that the entities originally had at the source.
914 
915 The `component` member function restores all and only the components specified
916 and assigns them to the right entities. Note that the template parameter list
917 must be exactly the same used during the serialization. The same applies to the
918 `tag` member function.
919 
920 The `orphans` member function literally destroys those entities that have
921 neither components nor tags. It's usually useless if the snapshot is a full dump
922 of the source. However, in case all the entities are serialized but only few
923 components and tags are saved, it could happen that some of the entities have
924 neither components nor tags once restored. The best users can do to deal with
925 them is to destroy those entities and thus update their versions.
926 
927 #### Continuous loader
928 
929 A continuous loader is designed to load data from a source registry to a
930 (possibly) non-empty destination. The loader can accommodate in a registry more
931 than one snapshot in a sort of _continuous loading_ that updates the
932 destination one step at a time.<br/>
933 Identifiers that entities originally had are not transferred to the target.
934 Instead, the loader maps remote identifiers to local ones while restoring a
935 snapshot. Because of that, this kind of loader offers a way to update
936 automatically identifiers that are part of components or tags (as an example, as
937 data members or gathered in a container).<br/>
938 Another difference with the snapshot loader is that the continuous loader does
939 not need to work with the private data structures of a registry. Furthermore, it
940 has an internal state that must persist over time. Therefore, there is no reason
941 to create it by means of a registry, or to limit its lifetime to that of a
942 temporary object.
943 
944 Example of use:
945 
946 ```cpp
947 entt::ContinuousLoader<entity_type> loader{registry};
948 InputArchive input;
949 
950 loader.entities(input)
951  .destroyed(input)
952  .component<AComponent, AnotherComponent, DirtyComponent>(input, &DirtyComponent::parent, &DirtyComponent::child)
953  .tag<MyTag, DirtyTag>(input, &DirtyTag::container)
954  .orphans()
955  .shrink();
956 ```
957 
958 It isn't necessary to invoke all these functions each and every time. What
959 functions to use in which case mostly depends on the goal and there is not a
960 golden rule to do that. For obvious reasons, what is important is that the data
961 are restored in exactly the same order in which they were serialized.
962 
963 The `entities` and `destroyed` member functions restore groups of entities and
964 map each entity to a local counterpart when required. In other terms, for each
965 remote entity identifier not yet registered by the loader, the latter creates a
966 local identifier so that it can keep the local entity in sync with the remote
967 one.
968 
969 The `component` and `tag` member functions restore all and only the components
970 and the tags specified and assign them to the right entities.<br/>
971 In case the component or the tag contains entities itself (either as data
972 members of type `entity_type` or as containers of entities), the loader can
973 update them automatically. To do that, it's enough to specify the data members
974 to update as shown in the example.
975 
976 The `orphans` member function literally destroys those entities that have
977 neither components nor tags after a restore. It has exactly the same purpose
978 described in the previous section and works the same way.
979 
980 Finally, `shrink` helps to purge local entities that no longer have a remote
981 conterpart. Users should invoke this member function after restoring each
982 snapshot, unless they know exactly what they are doing.
983 
984 #### Archives
985 
986 Archives must publicly expose a predefined set of member functions. The API is
987 straightforward and consists only of a group of function call operators that
988 are invoked by the snapshot class and the loaders.
989 
990 In particular:
991 
992 * An output archive, the one used when creating a snapshot, must expose a
993  function call operator with the following signature to store entities:
994 
995  ```cpp
996  void operator()(Entity);
997  ```
998 
999  Where `Entity` is the type of the entities used by the registry. Note that all
1000  the member functions of the snapshot class make also an initial call to this
1001  endpoint to save the _size_ of the set they are going to store.<br/>
1002  In addition, an archive must accept a pair of entity and either component or
1003  tag for each type to be serialized. Therefore, given a type `T`, the archive
1004  must contain a function call operator with the following signature:
1005 
1006  ```cpp
1007  void operator()(Entity, const T &);
1008  ```
1009 
1010  The output archive can freely decide how to serialize the data. The register
1011  is not affected at all by the decision.
1012 
1013 * An input archive, the one used when restoring a snapshot, must expose a
1014  function call operator with the following signature to load entities:
1015 
1016  ```cpp
1017  void operator()(Entity &);
1018  ```
1019 
1020  Where `Entity` is the type of the entities used by the registry. Each time the
1021  function is invoked, the archive must read the next element from the
1022  underlying storage and copy it in the given variable. Note that all the member
1023  functions of a loader class make also an initial call to this endpoint to read
1024  the _size_ of the set they are going to load.<br/>
1025  In addition, the archive must accept a pair of entity and either component or
1026  tag for each type to be restored. Therefore, given a type `T`, the archive
1027  must contain a function call operator with the following signature:
1028 
1029  ```cpp
1030  void operator()(Entity &, T &);
1031  ```
1032 
1033  Every time such an operator is invoked, the archive must read the next
1034  elements from the underlying storage and copy them in the given variables.
1035 
1036 #### One example to rule them all
1037 
1038 `EnTT` comes with some examples (actually some tests) that show how to integrate
1039 a well known library for serialization as an archive. It uses
1040 [`Cereal C++`](https://uscilab.github.io/cereal/) under the hood, mainly
1041 because I wanted to learn how it works at the time I was writing the code.
1042 
1043 The code is not production-ready and it isn't neither the only nor (probably)
1044 the best way to do it. However, feel free to use it at your own risk.
1045 
1046 The basic idea is to store everything in a group of queues in memory, then bring
1047 everything back to the registry with different loaders.
1048 
1049 ### Prototype
1050 
1051 A prototype defines a type of an application in terms of its parts. They can be
1052 used to assign components to entities of a registry at once.<br/>
1053 Roughly speaking, in most cases prototypes can be considered just as templates
1054 to use to initialize entities according to _concepts_. In fact, users can create
1055 how many prototypes they want, each one initialized differently from the others.
1056 
1057 The following is an example of use of a prototype:
1058 
1059 ```cpp
1060 entt::DefaultPrototype prototype;
1061 
1062 prototype.set<Position>(100.f, 100.f);
1063 prototype.set<Velocity>(0.f, 0.f);
1064 
1065 // ...
1066 
1067 entt::DefaultRegistry registry;
1068 
1069 const auto entity = prototype(registry);
1070 ```
1071 
1072 To assign and remove components from a prototype, it offers two dedicated member
1073 functions named `set` and `unset`. The `has` member function can be used to know
1074 if a given prototype contains one or more components and the `get` member
1075 function can be used to retrieve the components.
1076 
1077 Creating an entity from a prototype is straightforward:
1078 
1079 * To create a new entity from scratch and assign it a prototype, this is the way
1080  to go:
1081  ```cpp
1082  const auto entity = prototype(registry);
1083  ```
1084  It is equivalent to the following invokation:
1085  ```cpp
1086  const auto entity = prototype.create(registry);
1087  ```
1088 
1089 * In case we want to initialize an already existing entity, we can provide the
1090  `operator()` directly with the entity identifier:
1091  ```cpp
1092  prototype(registry, entity);
1093  ```
1094  It is equivalent to the following invokation:
1095  ```cpp
1096  prototype.assign(registry, entity);
1097  ```
1098  Note that existing components aren't overwritten in this case. Only those
1099  components that the entity doesn't own yet are copied over. All the other
1100  components remain unchanged.
1101 
1102 * Finally, to assign or replace all the components for an entity, thus
1103  overwriting existing ones:
1104  ```cpp
1105  prototype.accommodate(registry, entity);
1106  ```
1107 
1108 Prototypes are a very useful tool that can save a lot of typing sometimes.
1109 Furthermore, the codebase may be easier to maintain, since updating a prototype
1110 is much less error prone than jumping around in the codebase to update all the
1111 snippets copied and pasted around to initialize entities and components.
1112 
1113 ### Helpers
1114 
1115 The so called _helpers_ are small classes and functions mainly designed to offer
1116 built-in support for the most basic functionalities.<br/>
1117 The list of helpers will grow longer as time passes and new ideas come out.
1118 
1119 #### Dependency function
1120 
1121 A _dependency function_ is a predefined listener, actually a function template
1122 to use to automatically assign components to an entity when a type has a
1123 dependency on some other types.<br/>
1124 The following adds components `AType` and `AnotherType` whenever `MyType` is
1125 assigned to an entity:
1126 
1127 ```cpp
1128 entt::dependency<AType, AnotherType>(registry.construction<MyType>());
1129 ```
1130 
1131 A component is assigned to an entity and thus default initialized only in case
1132 the entity itself hasn't it yet. It means that already existent components won't
1133 be overriden.<br/>
1134 A dependency can easily be broken by means of the same function template:
1135 
1136 ```cpp
1137 entt::dependency<AType, AnotherType>(entt::break_t{}, registry.construction<MyType>());
1138 ```
1139 
1140 ## View: to persist or not to persist?
1141 
1142 First of all, it is worth answering an obvious question: why views?<br/>
1143 Roughly speaking, they are a good tool to enforce single responsibility. A
1144 system that has access to a registry can create and destroy entities, as well as
1145 assign and remove components. On the other side, a system that has access to a
1146 view can only iterate entities and their components, then read or update the
1147 data members of the latter.<br/>
1148 It is a subtle difference that can help designing a better software sometimes.
1149 
1150 There are mainly three kinds of views: standard (also known as `View`),
1151 persistent (also known as `PersistentView`) and raw (also known as
1152 `RawView`).<br/>
1153 All of them have pros and cons to take in consideration. In particular:
1154 
1155 * Standard views:
1156 
1157  Pros:
1158 
1159  * They work out-of-the-box and don't require any dedicated data structure.
1160  * Creating and destroying them isn't expensive at all because they don't have
1161  any type of initialization.
1162  * They are the best tool for iterating entities for a single component.
1163  * They are the best tool for iterating entities for multiple components when
1164  one of the components is assigned to a significantly low number of entities.
1165  * They don't affect any other operations of the registry.
1166 
1167  Cons:
1168 
1169  * Their performance tend to degenerate when the number of components to
1170  iterate grows up and the most of the entities have all of them.
1171 
1172 * Persistent views:
1173 
1174  Pros:
1175 
1176  * Once prepared, creating and destroying them isn't expensive at all because
1177  they don't have any type of initialization.
1178  * They are the best tool for iterating entities for multiple components when
1179  most entities have them all.
1180 
1181  Cons:
1182 
1183  * They have dedicated data structures and thus affect the memory usage to a
1184  minimal extent.
1185  * If not previously prepared, the first time they are used they go through an
1186  initialization step that could take a while.
1187  * They affect to a minimum the creation and destruction of entities and
1188  components. In other terms: the more persistent views there will be, the
1189  less performing will be creating and destroying entities and components.
1190 
1191 * Raw views:
1192 
1193  Pros:
1194 
1195  * They work out-of-the-box and don't require any dedicated data structure.
1196  * Creating and destroying them isn't expensive at all because they don't have
1197  any type of initialization.
1198  * They are the best tool for iterating components when it is not necessary to
1199  know which entities they belong to.
1200  * They don't affect any other operations of the registry.
1201 
1202  Cons:
1203 
1204  * They can be used to iterate only one type of component at a time.
1205  * They don't return the entity to which a component belongs to the caller.
1206 
1207 To sum up and as a rule of thumb:
1208 
1209 * Use a raw view to iterate components only (no entities) for a given type.
1210 * Use a standard view to iterate entities and components for a single type.
1211 * Use a standard view to iterate entities and components for multiple types when
1212  the number of types is low. Standard views are really optimized and persistent
1213  views won't add much in this case.
1214 * Use a standard view to iterate entities and components for multiple types when
1215  a significantly low number of entities have one of the components.
1216 * Use a standard view in all those cases where a persistent view would give a
1217  boost to performance but the iteration isn't performed frequently.
1218 * Prepare and use a persistent view when you want to iterate only entities for
1219  multiple components.
1220 * Prepare and use a persistent view when you want to iterate entities for
1221  multiple components and each component is assigned to a great number of
1222  entities but the intersection between the sets of entities is small.
1223 * Prepare and use a persistent view in all the cases where a standard view
1224  wouldn't fit well otherwise.
1225 
1226 To easily iterate entities and components, all the views offer the common
1227 `begin` and `end` member functions that allow users to use a view in a typical
1228 range-for loop. Almost all the views offer also a *more functional* `each`
1229 member function that accepts a callback for convenience.<br/>
1230 Continue reading for more details or refer to the inline documentation.
1231 
1232 ### Standard View
1233 
1234 A standard view behaves differently if it's constructed for a single component
1235 or if it has been requested to iterate multiple components. Even the API is
1236 different in the two cases.<br/>
1237 All that they share is the way they are created by means of a registry:
1238 
1239 ```cpp
1240 // single component standard view
1241 auto single = registry.view<Position>();
1242 
1243 // multi component standard view
1244 auto multi = registry.view<Position, Velocity>();
1245 ```
1246 
1247 For all that remains, it's worth discussing them separately.<br/>
1248 
1249 #### Single component standard view
1250 
1251 Single component standard views are specialized in order to give a boost in
1252 terms of performance in all the situation. This kind of views can access the
1253 underlying data structures directly and avoid superfluous checks.<br/>
1254 They offer a bunch of functionalities to get the number of entities they are
1255 going to return and a raw access to the entity list as well as to the component
1256 list. It's also possible to ask a view if it contains a given entity.<br/>
1257 Refer to the inline documentation for all the details.
1258 
1259 There is no need to store views around for they are extremely cheap to
1260 construct, even though they can be copied without problems and reused freely. In
1261 fact, they return newly created and correctly initialized iterators whenever
1262 `begin` or `end` are invoked.<br/>
1263 To iterate a single component standard view, either use it in range-for loop:
1264 
1265 ```cpp
1266 auto view = registry.view<Renderable>();
1267 
1268 for(auto entity: view) {
1269  Renderable &renderable = view.get(entity);
1270 
1271  // ...
1272 }
1273 ```
1274 
1275 Or rely on the `each` member function to iterate entities and get all their
1276 components at once:
1277 
1278 ```cpp
1279 registry.view<Renderable>().each([](auto entity, auto &renderable) {
1280  // ...
1281 });
1282 ```
1283 
1284 Performance are more or less the same. The best approach depends mainly on
1285 whether all the components have to be accessed or not.
1286 
1287 **Note**: prefer the `get` member function of a view instead of the `get` member
1288 function template of a registry during iterations, if possible. However, keep in
1289 mind that it works only with the components of the view itself.
1290 
1291 #### Multi component standard view
1292 
1293 Multi component standard views iterate entities that have at least all the given
1294 components in their bags. During construction, these views look at the number of
1295 entities available for each component and pick up a reference to the smallest
1296 set of candidates in order to speed up iterations.<br/>
1297 They offer fewer functionalities than their companion views for single
1298 component. In particular, a multi component standard view exposes utility
1299 functions to get the estimated number of entities it is going to return and to
1300 know whether it's empty or not. It's also possible to ask a view if it contains
1301 a given entity.<br/>
1302 Refer to the inline documentation for all the details.
1303 
1304 There is no need to store views around for they are extremely cheap to
1305 construct, even though they can be copied without problems and reused freely. In
1306 fact, they return newly created and correctly initialized iterators whenever
1307 `begin` or `end` are invoked.<br/>
1308 To iterate a multi component standard view, either use it in range-for loop:
1309 
1310 ```cpp
1311 auto view = registry.view<Position, Velocity>();
1312 
1313 for(auto entity: view) {
1314  // a component at a time ...
1315  Position &position = view.get<Position>(entity);
1316  Velocity &velocity = view.get<Velocity>(entity);
1317 
1318  // ... or multiple components at once
1319  std::tuple<Position &, Velocity &> tup = view.get<Position, Velocity>(entity);
1320 
1321  // ...
1322 }
1323 ```
1324 
1325 Or rely on the `each` member function to iterate entities and get all their
1326 components at once:
1327 
1328 ```cpp
1329 registry.view<Position, Velocity>().each([](auto entity, auto &position, auto &velocity) {
1330  // ...
1331 });
1332 ```
1333 
1334 Performance are more or less the same. The best approach depends mainly on
1335 whether all the components have to be accessed or not.
1336 
1337 **Note**: prefer the `get` member function of a view instead of the `get` member
1338 function template of a registry during iterations, if possible. However, keep in
1339 mind that it works only with the components of the view itself.
1340 
1341 ### Persistent View
1342 
1343 A persistent view returns all the entities and only the entities that have at
1344 least the given components. Moreover, it's guaranteed that the entity list is
1345 tightly packed in memory for fast iterations.<br/>
1346 In general, persistent views don't stay true to the order of any set of
1347 components unless users explicitly sort them.
1348 
1349 Persistent views can be used only to iterate multiple components. To create this
1350 kind of views, the tag `persistent_t` must also be used in order to disambiguate
1351 overloads of the `view` member function:
1352 
1353 ```cpp
1354 auto view = registry.view<Position, Velocity>(entt::persistent_t{});
1355 ```
1356 
1357 There is no need to store views around for they are extremely cheap to
1358 construct, even though they can be copied without problems and reused freely. In
1359 fact, they return newly created and correctly initialized iterators whenever
1360 `begin` or `end` are invoked.<br/>
1361 That being said, persistent views perform an initialization step the very first
1362 time they are constructed and this could be quite costly. To avoid it, consider
1363 asking to the registry to _prepare_ them when no entities have been created yet:
1364 
1365 ```cpp
1366 registry.prepare<Position, Velocity>();
1367 ```
1368 
1369 If the registry is empty, preparation is extremely fast. Moreover the `prepare`
1370 member function template is idempotent. Feel free to invoke it even more than
1371 once: if the view has been already prepared before, the function returns
1372 immediately and does nothing.
1373 
1374 A persistent view offers a bunch of functionalities to get the number of
1375 entities it's going to return, a raw access to the entity list and the
1376 possibility to sort the underlying data structures according to the order of one
1377 of the components for which it has been constructed. It's also possible to ask a
1378 view if it contains a given entity.<br/>
1379 Refer to the inline documentation for all the details.
1380 
1381 To iterate a persistent view, either use it in range-for loop:
1382 
1383 ```cpp
1384 auto view = registry.view<Position, Velocity>(entt::persistent_t{});
1385 
1386 for(auto entity: view) {
1387  // a component at a time ...
1388  Position &position = view.get<Position>(entity);
1389  Velocity &velocity = view.get<Velocity>(entity);
1390 
1391  // ... or multiple components at once
1392  std::tuple<Position &, Velocity &> tup = view.get<Position, Velocity>(entity);
1393 
1394  // ...
1395 }
1396 ```
1397 
1398 Or rely on the `each` member function to iterate entities and get all their
1399 components at once:
1400 
1401 ```cpp
1402 registry.view<Position, Velocity>(entt::persistent_t{}).each([](auto entity, auto &position, auto &velocity) {
1403  // ...
1404 });
1405 ```
1406 
1407 Performance are more or less the same. The best approach depends mainly on
1408 whether all the components have to be accessed or not.
1409 
1410 **Note**: prefer the `get` member function of a view instead of the `get` member
1411 function template of a registry during iterations, if possible. However, keep in
1412 mind that it works only with the components of the view itself.
1413 
1414 ### Raw View
1415 
1416 Raw views return all the components of a given type. This kind of views can
1417 access components directly and avoid extra indirections like when components are
1418 accessed via an entity identifier.<br/>
1419 They offer a bunch of functionalities to get the number of instances they are
1420 going to return and a raw access to the entity list as well as to the component
1421 list.<br/>
1422 Refer to the inline documentation for all the details.
1423 
1424 Raw views can be used only to iterate components for a single type. To create
1425 this kind of views, the tag `raw_t` must also be used in order to disambiguate
1426 overloads of the `view` member function:
1427 
1428 ```cpp
1429 auto view = registry.view<Renderable>(entt::raw_t{});
1430 ```
1431 
1432 There is no need to store views around for they are extremely cheap to
1433 construct, even though they can be copied without problems and reused freely. In
1434 fact, they return newly created and correctly initialized iterators whenever
1435 `begin` or `end` are invoked.<br/>
1436 To iterate a raw view, use it in range-for loop:
1437 
1438 ```cpp
1439 auto view = registry.view<Renderable>(entt::raw_t{});
1440 
1441 for(auto &&component: raw) {
1442  // ...
1443 }
1444 ```
1445 
1446 **Note**: raw views don't have the `each` nor the `get` member function for
1447 obvious reasons. The former would only return the components and therefore it
1448 would be redundant, the latter isn't required at all.
1449 
1450 ### Give me everything
1451 
1452 Views are narrow windows on the entire list of entities. They work by filtering
1453 entities according to their components.<br/>
1454 In some cases there may be the need to iterate all the entities still in use
1455 regardless of their components. The registry offers a specific member function
1456 to do that:
1457 
1458 ```cpp
1459 registry.each([](auto entity) {
1460  // ...
1461 });
1462 ```
1463 
1464 It returns to the caller all the entities that are still in use by means of the
1465 given function.<br/>
1466 As a rule of thumb, consider using a view if the goal is to iterate entities
1467 that have a determinate set of components. A view is usually much faster than
1468 combining this function with a bunch of custom tests.<br/>
1469 In all the other cases, this is the way to go.
1470 
1471 There exists also another member function to use to retrieve orphans. An orphan
1472 is an entity that is still in use and has neither assigned components nor
1473 tags.<br/>
1474 The signature of the function is the same of `each`:
1475 
1476 ```cpp
1477 registry.orphans([](auto entity) {
1478  // ...
1479 });
1480 ```
1481 
1482 To test the _orphanity_ of a single entity, use the member function `orphan`
1483 instead. It accepts a valid entity identifer as an argument and returns true in
1484 case the entity is an orphan, false otherwise.
1485 
1486 In general, all these functions can result in poor performance.<br/>
1487 `each` is fairly slow because of some checks it performs on each and every
1488 entity. For similar reasons, `orphans` can be even slower. Both functions should
1489 not be used frequently to avoid the risk of a performance hit.
1490 
1491 ## Side notes
1492 
1493 * Entity identifiers are numbers and nothing more. They are not classes and they
1494  have no member functions at all. As already mentioned, do no try to inspect or
1495  modify an entity descriptor in any way.
1496 
1497 * As shown in the examples above, the preferred way to get references to the
1498  components while iterating a view is by using the view itself. It's a faster
1499  alternative to the `get` member function template that is part of the API of
1500  the `Registry`. This is because the registry must ensure that a pool for the
1501  given component exists before to use it; on the other side, views force the
1502  construction of the pools for all their components and access them directly,
1503  thus avoiding all the checks.
1504 
1505 * Most of the _ECS_ available out there have some annoying limitations (at least
1506  from my point of view): entities and components cannot be created and/or
1507  destroyed during iterations.<br/>
1508  `EnTT` partially solves the problem with a few limitations:
1509 
1510  * Creating entities and components is allowed during iterations.
1511  * Deleting an entity or removing its components is allowed during iterations
1512  if it's the one currently returned by a view. For all the other entities,
1513  destroying them or removing their components isn't allowed and it can result
1514  in undefined behavior.
1515 
1516  Iterators are invalidated and the behavior is undefined if an entity is
1517  modified or destroyed and it's not the one currently returned by the
1518  view.<br/>
1519  To work around it, possible approaches are:
1520 
1521  * Store aside the entities and the components to be removed and perform the
1522  operations at the end of the iteration.
1523  * Mark entities and components with a proper tag component that indicates
1524  they must be purged, then perform a second iteration to clean them up one
1525  by one.
1526 
1527 * Views and thus their iterators aren't thread safe. Do no try to iterate a set
1528  of components and modify the same set concurrently.<br/>
1529  That being said, as long as a thread iterates the entities that have the
1530  component `X` or assign and removes that component from a set of entities,
1531  another thread can safely do the same with components `Y` and `Z` and
1532  everything will work like a charm.<br/>
1533  As a trivial example, users can freely execute the rendering system and
1534  iterate the renderable entities while updating a physic component concurrently
1535  on a separate thread.
1536 
1537 * In general, the entire registry isn't thread safe as it is. Thread safety
1538  isn't something that users should want out of the box for several reasons.
1539  Just to mention one of them: performance.<br/>
1540  This kind of entity-component systems can be used in single threaded
1541  applications as well as along with async stuff. Moreover, typical thread based
1542  models for ECS don't require a fully thread safe registry to work. Actually
1543  one could reach the goal with the registry as it is while working with most of
1544  the common models, after all.<br/>
1545  Because of the few reasons mentioned above and many others not mentioned,
1546  users are completely responsible for synchronization whether required.
1547 
1548 # Crash Course: core functionalities
1549 
1550 The `EnTT` framework comes with a bunch of core functionalities mostly used by
1551 the other parts of the library itself.<br/>
1552 Hardly users of the framework will include these features in their code, but
1553 it's worth describing what `EnTT` offers so as not to reinvent the wheel in case
1554 of need.
1555 
1556 ## Compile-time identifiers
1557 
1558 Sometimes it's useful to be able to give unique identifiers to types at
1559 compile-time.<br/>
1560 There are plenty of different solutions out there and I could have used one of
1561 them. However, I decided to spend my time to define a compact and versatile tool
1562 that fully embraces what the modern C++ has to offer.
1563 
1564 The _result of my efforts_ is the `ident` `constexpr` variable:
1565 
1566 ```cpp
1567 #include <ident.hpp>
1568 
1569 // defines the identifiers for the given types
1570 constexpr auto identifiers = entt::ident<AType, AnotherType>;
1571 
1572 // ...
1573 
1574 switch(aTypeIdentifier) {
1575 case identifers.get<AType>():
1576  // ...
1577  break;
1578 case identifers.get<AnotherType>():
1579  // ...
1580  break;
1581 default:
1582  // ...
1583 }
1584 ```
1585 
1586 This is all what the variable has to offer: a `get` member function that returns
1587 a numerical identifier for the given type. It can be used in any context where
1588 constant expressions are required.
1589 
1590 As long as the list remains unchanged, identifiers are also guaranteed to be the
1591 same for every run. In case they have been used in a production environment and
1592 a type has to be removed, one can just use a placeholder to left the other
1593 identifiers unchanged:
1594 
1595 ```cpp
1596 template<typename> struct IgnoreType {};
1597 
1598 constexpr auto identifiers = entt::ident<
1599  ATypeStillValid,
1600  IgnoreType<ATypeNoLongerValid>,
1601  AnotherTypeStillValid
1602 >;
1603 ```
1604 
1605 A bit ugly to see, but it works at least.
1606 
1607 ## Runtime identifiers
1608 
1609 Sometimes it's useful to be able to give unique identifiers to types at
1610 runtime.<br/>
1611 There are plenty of different solutions out there and I could have used one of
1612 them. In fact, I adapted the most common one to my requirements and used it
1613 extensively within the entire framework.
1614 
1615 It's the `Family` class. Here is an example of use directly from the
1616 entity-component system:
1617 
1618 ```cpp
1619 using component_family = entt::Family<struct InternalRegistryComponentFamily>;
1620 
1621 // ...
1622 
1623 template<typename Component>
1624 component_type component() const noexcept {
1625  return component_family::type<Component>();
1626 }
1627 ```
1628 
1629 This is all what a _family_ has to offer: a `type` member function that returns
1630 a numerical identifier for the given type.
1631 
1632 Please, note that identifiers aren't guaranteed to be the same for every run.
1633 Indeed it mostly depends on the flow of execution.
1634 
1635 ## Hashed strings
1636 
1637 A hashed string is a zero overhead resource identifier. Users can use
1638 human-readable identifiers in the codebase while using their numeric
1639 counterparts at runtime, thus without affecting performance.<br/>
1640 The class has an implicit `constexpr` constructor that chews a bunch of
1641 characters. Once created, all what one can do with it is getting back the
1642 original string or converting it into a number.<br/>
1643 The good part is that a hashed string can be used wherever a constant expression
1644 is required and no _string-to-number_ conversion will take place at runtime if
1645 used carefully.
1646 
1647 Example of use:
1648 
1649 ```cpp
1650 auto load(entt::HashedString::hash_type resource) {
1651  // uses the numeric representation of the resource to load and return it
1652 }
1653 
1654 auto resource = load(entt::HashedString{"gui/background"});
1655 ```
1656 
1657 ### Conflicts
1658 
1659 The hashed string class uses internally FNV-1a to compute the numeric
1660 counterpart of a string. Because of the _pigeonhole principle_, conflicts are
1661 possible. This is a fact.<br/>
1662 There is no silver bullet to solve the problem of conflicts when dealing with
1663 hashing functions. In this case, the best solution seemed to be to give up.
1664 That's all.<br/>
1665 After all, human-readable resource identifiers aren't something strictly defined
1666 and over which users have not the control. Choosing a slightly different
1667 identifier is probably the best solution to make the conflict disappear in this
1668 case.
1669 
1670 # Crash Course: service locator
1671 
1672 Usually service locators are tightly bound to the services they expose and it's
1673 hard to define a general purpose solution. This template based implementation
1674 tries to fill the gap and to get rid of the burden of defining a different
1675 specific locator for each application.<br/>
1676 This class is tiny, partially unsafe and thus risky to use. Moreover it doesn't
1677 fit probably most of the scenarios in which a service locator is required. Look
1678 at it as a small tool that can sometimes be useful if the user knows how to
1679 handle it.
1680 
1681 The API is straightforward. The basic idea is that services are implemented by
1682 means of interfaces and rely on polymorphism.<br/>
1683 The locator is instantiated with the base type of the service if any and a
1684 concrete implementation is provided along with all the parameters required to
1685 initialize it. As an example:
1686 
1687 ```cpp
1688 // the service has no base type, a locator is used to treat it as a kind of singleton
1689 entt::ServiceLocator<MyService>::set(params...);
1690 
1691 // sets up an opaque service
1692 entt::ServiceLocator<AudioInterface>::set<AudioImplementation>(params...);
1693 
1694 // resets (destroys) the service
1695 entt::ServiceLocator<AudioInterface>::reset();
1696 ```
1697 
1698 The locator can also be queried to know if an active service is currently set
1699 and to retrieve it if necessary (either as a pointer or as a reference):
1700 
1701 ```cpp
1702 // no service currently set
1703 auto empty = entt::ServiceLocator<AudioInterface>::empty();
1704 
1705 // gets a (possibly empty) shared pointer to the service ...
1706 std::shared_ptr<AudioInterface> ptr = entt::ServiceLocator<AudioInterface>::get();
1707 
1708 // ... or a reference, but it's undefined behaviour if the service isn't set yet
1709 AudioInterface &ref = entt::ServiceLocator<AudioInterface>::ref();
1710 ```
1711 
1712 A common use is to wrap the different locators in a container class, creating
1713 aliases for the various services:
1714 
1715 ```cpp
1716 struct Locator {
1717  using Camera = entt::ServiceLocator<CameraInterface>;
1718  using Audio = entt::ServiceLocator<AudioInterface>;
1719  // ...
1720 };
1721 
1722 // ...
1723 
1724 void init() {
1725  Locator::Camera::set<CameraNull>();
1726  Locator::Audio::set<AudioImplementation>(params...);
1727  // ...
1728 }
1729 ```
1730 
1731 # Crash Course: cooperative scheduler
1732 
1733 Sometimes processes are a useful tool to work around the strict definition of a
1734 system and introduce logic in a different way, usually without resorting to the
1735 introduction of other components.
1736 
1737 The `EnTT` framework offers a minimal support to this paradigm by introducing a
1738 few classes that users can use to define and execute cooperative processes.
1739 
1740 ## The process
1741 
1742 A typical process must inherit from the `Process` class template that stays true
1743 to the CRTP idiom. Moreover, derived classes must specify what's the intended
1744 type for elapsed times.
1745 
1746 A process should expose publicly the following member functions whether
1747 required (note that it isn't required to define a function unless the derived
1748 class wants to _override_ the default behavior):
1749 
1750 * `void update(Delta, void *);`
1751 
1752  It's invoked once per tick until a process is explicitly aborted or it
1753  terminates either with or without errors. Even though it's not mandatory to
1754  declare this member function, as a rule of thumb each process should at
1755  least define it to work properly. The `void *` parameter is an opaque pointer
1756  to user data (if any) forwarded directly to the process during an update.
1757 
1758 * `void init(void *);`
1759 
1760  It's invoked at the first tick, immediately before an update. The `void *`
1761  parameter is an opaque pointer to user data (if any) forwarded directly to the
1762  process during an update.
1763 
1764 * `void succeeded();`
1765 
1766  It's invoked in case of success, immediately after an update and during the
1767  same tick.
1768 
1769 * `void failed();`
1770 
1771  It's invoked in case of errors, immediately after an update and during the
1772  same tick.
1773 
1774 * `void aborted();`
1775 
1776  It's invoked only if a process is explicitly aborted. There is no guarantee
1777  that it executes in the same tick, this depends solely on whether the
1778  process is aborted immediately or not.
1779 
1780 Derived classes can also change the internal state of a process by invoking
1781 `succeed` and `fail`, as well as `pause` and `unpause` the process itself. All
1782 these are protected member functions made available to be able to manage the
1783 life cycle of a process from a derived class.
1784 
1785 Here is a minimal example for the sake of curiosity:
1786 
1787 ```cpp
1788 struct MyProcess: entt::Process<MyProcess, std::uint32_t> {
1789  using delta_type = std::uint32_t;
1790 
1791  void update(delta_type delta, void *) {
1792  remaining = delta > remaining ? delta_type{] : (remaining - delta);
1793 
1794  // ...
1795 
1796  if(!remaining) {
1797  succeed();
1798  }
1799  }
1800 
1801  void init(void *data) {
1802  remaining = *static_cast<delta_type *>(data);
1803  }
1804 
1805 private:
1806  delta_type remaining;
1807 };
1808 ```
1809 
1810 ### Adaptor
1811 
1812 Lambdas and functors can't be used directly with a scheduler for they are not
1813 properly defined processes with managed life cycles.<br/>
1814 This class helps in filling the gap and turning lambdas and functors into
1815 full featured processes usable by a scheduler.
1816 
1817 The function call operator has a signature similar to the one of the `update`
1818 function of a process but for the fact that it receives two extra arguments to
1819 call whenever a process is terminated with success or with an error:
1820 
1821 ```cpp
1822 void(Delta delta, void *data, auto succeed, auto fail);
1823 ```
1824 
1825 Parameters have the following meaning:
1826 
1827 * `delta` is the elapsed time.
1828 * `data` is an opaque pointer to user data if any, `nullptr` otherwise.
1829 * `succeed` is a function to call when a process terminates with success.
1830 * `fail` is a function to call when a process terminates with errors.
1831 
1832 Both `succeed` and `fail` accept no parameters at all.
1833 
1834 Note that usually users shouldn't worry about creating adaptors at all. A
1835 scheduler creates them internally each and every time a lambda or a functor is
1836 used as a process.
1837 
1838 ## The scheduler
1839 
1840 A cooperative scheduler runs different processes and helps managing their life
1841 cycles.
1842 
1843 Each process is invoked once per tick. If it terminates, it's removed
1844 automatically from the scheduler and it's never invoked again. Otherwise it's
1845 a good candidate to run once more the next tick.<br/>
1846 A process can also have a child. In this case, the process is replaced with
1847 its child when it terminates if it returns with success. In case of errors,
1848 both the process and its child are discarded. This way, it's easy to create
1849 chain of processes to run sequentially.
1850 
1851 Using a scheduler is straightforward. To create it, users must provide only the
1852 type for the elapsed times and no arguments at all:
1853 
1854 ```cpp
1855 Scheduler<std::uint32_t> scheduler;
1856 ```
1857 
1858 It has member functions to query its internal data structures, like `empty` or
1859 `size`, as well as a `clear` utility to reset it to a clean state:
1860 
1861 ```cpp
1862 // checks if there are processes still running
1863 bool empty = scheduler.empty();
1864 
1865 // gets the number of processes still running
1866 Scheduler<std::uint32_t>::size_type size = scheduler.size();
1867 
1868 // resets the scheduler to its initial state and discards all the processes
1869 scheduler.clear();
1870 ```
1871 
1872 To attach a process to a scheduler there are mainly two ways:
1873 
1874 * If the process inherits from the `Process` class template, it's enough to
1875  indicate its type and submit all the parameters required to construct it to
1876  the `attach` member function:
1877 
1878  ```cpp
1879  scheduler.attach<MyProcess>("foobar");
1880  ```
1881 
1882 * Otherwise, in case of a lambda or a functor, it's enough to provide an
1883  instance of the class to the `attach` member function:
1884 
1885  ```cpp
1886  scheduler.attach([](auto...){ /* ... */ });
1887  ```
1888 
1889 In both cases, the return value is an opaque object that offers a `then` member
1890 function to use to create chains of processes to run sequentially.<br/>
1891 As a minimal example of use:
1892 
1893 ```cpp
1894 // schedules a task in the form of a lambda function
1895 scheduler.attach([](auto delta, void *, auto succeed, auto fail) {
1896  // ...
1897 })
1898 // appends a child in the form of another lambda function
1899 .then([](auto delta, void *, auto succeed, auto fail) {
1900  // ...
1901 })
1902 // appends a child in the form of a process class
1903 .then<MyProcess>();
1904 ```
1905 
1906 To update a scheduler and thus all its processes, the `update` member function
1907 is the way to go:
1908 
1909 ```cpp
1910 // updates all the processes, no user data are provided
1911 scheduler.update(delta);
1912 
1913 // updates all the processes and provides them with custom data
1914 scheduler.update(delta, &data);
1915 ```
1916 
1917 In addition to these functions, the scheduler offers an `abort` member function
1918 that can be used to discard all the running processes at once:
1919 
1920 ```cpp
1921 // aborts all the processes abruptly ...
1922 scheduler.abort(true);
1923 
1924 // ... or gracefully during the next tick
1925 scheduler.abort();
1926 ```
1927 
1928 # Crash Course: resource management
1929 
1930 Resource management is usually one of the most critical part of a software like
1931 a game. Solutions are often tuned to the particular application. There exist
1932 several approaches and all of them are perfectly fine as long as they fit the
1933 requirements of the piece of software in which they are used.<br/>
1934 Examples are loading everything on start, loading on request, predictive
1935 loading, and so on.
1936 
1937 The `EnTT` framework doesn't pretend to offer a _one-fits-all_ solution for the
1938 different cases. Instead, it offers a minimal and perhaps trivial cache that can
1939 be useful most of the time during prototyping and sometimes even in a production
1940 environment.<br/>
1941 For those interested in the subject, the plan is to improve it considerably over
1942 time in terms of performance, memory usage and functionalities. Hoping to make
1943 it, of course, one step at a time.
1944 
1945 ## The resource, the loader and the cache
1946 
1947 There are three main actors in the model: the resource, the loader and the
1948 cache.
1949 
1950 The _resource_ is whatever the user wants it to be. An image, a video, an audio,
1951 whatever. There are no limits.<br/>
1952 As a minimal example:
1953 
1954 ```cpp
1955 struct MyResource { const int value; };
1956 ```
1957 
1958 A _loader_ is a class the aim of which is to load a specific resource. It has to
1959 inherit directly from the dedicated base class as in the following example:
1960 
1961 ```cpp
1962 struct MyLoader final: entt::ResourceLoader<MyLoader, MyResource> {
1963  // ...
1964 };
1965 ```
1966 
1967 Where `MyResource` is the type of resources it creates.<br/>
1968 A resource loader must also expose a public const member function named `load`
1969 that accepts a variable number of arguments and returns a shared pointer to a
1970 resource.<br/>
1971 As an example:
1972 
1973 ```cpp
1974 struct MyLoader: entt::ResourceLoader<MyLoader, MyResource> {
1975  std::shared_ptr<MyResource> load(int value) const {
1976  // ...
1977  return std::shared_ptr<MyResource>(new MyResource{ value });
1978  }
1979 };
1980 ```
1981 
1982 In general, resource loaders should not have a state or retain data of any type.
1983 They should let the cache manage their resources instead.<br/>
1984 As a side note, base class and CRTP idiom aren't strictly required with the
1985 current implementation. One could argue that a cache can easily work with
1986 loaders of any type. However, future changes won't be breaking ones by forcing
1987 the use of a base class today and that's why the model is already in its place.
1988 
1989 Finally, a cache is a specialization of a class template tailored to a specific
1990 resource:
1991 
1992 ```cpp
1993 using MyResourceCache = entt::ResourceCache<MyResource>;
1994 
1995 // ...
1996 
1997 MyResourceCache cache{};
1998 ```
1999 
2000 The idea is to create different caches for different types of resources and to
2001 manage each one independently and in the most appropriate way.<br/>
2002 As a (very) trivial example, audio tracks can survive in most of the scenes of
2003 an application while meshes can be associated with a single scene and then
2004 discarded when the user leaves it.
2005 
2006 A cache offers a set of basic functionalities to query its internal state and to
2007 _organize_ it:
2008 
2009 ```cpp
2010 // gets the number of resources managed by a cache
2011 auto size = cache.size();
2012 
2013 // checks if a cache contains at least a valid resource
2014 auto empty = cache.empty();
2015 
2016 // clears a cache and discards its content
2017 cache.clear();
2018 ```
2019 
2020 Besides these member functions, it contains what is needed to load, use and
2021 discard resources of the given type.<br/>
2022 Before to explore this part of the interface, it makes sense to mention how
2023 resources are identified. The type of the identifiers to use is defined as:
2024 
2025 ```cpp
2026 entt::ResourceCache<Resource>::resource_type
2027 ```
2028 
2029 Where `resource_type` is an alias for `entt::HashedString`. Therefore, resource
2030 identifiers are created explicitly as in the following example:
2031 
2032 ```cpp
2033 constexpr auto identifier = entt::ResourceCache<Resource>::resource_type{"my/resource/identifier"};
2034 // this is equivalent to the following
2035 constexpr auto hs = entt::HashedString{"my/resource/identifier"};
2036 ```
2037 
2038 The class `HashedString` is described in a dedicated section, so I won't do in
2039 details here.
2040 
2041 Resources are loaded and thus stored in a cache through the `load` member
2042 function. It accepts the loader to use as a template parameter, the resource
2043 identifier and the parameters used to construct the resource as arguments:
2044 
2045 ```cpp
2046 // uses the identifier declared above
2047 cache.load<MyLoader>(identifier, 0);
2048 
2049 // uses a const char * directly as an identifier
2050 cache.load<MyLoader>("another/identifier", 42);
2051 ```
2052 
2053 The return value can be used to know if the resource has been loaded correctly.
2054 In case the loader returns an invalid pointer or the resource already exists in
2055 the cache, a false value is returned:
2056 
2057 ```cpp
2058 if(!cache.load<MyLoader>("another/identifier", 42)) {
2059  // ...
2060 }
2061 ```
2062 
2063 Unfortunately, in this case there is no way to know what was the problem
2064 exactly. However, before trying to load a resource or after an error, one can
2065 use the `contains` member function to know if a cache already contains a
2066 specific resource:
2067 
2068 ```cpp
2069 auto exists = cache.contains("my/identifier");
2070 ```
2071 
2072 There exists also a member function to use to force a reload of an already
2073 existing resource if needed:
2074 
2075 ```cpp
2076 auto result = cache.reload<MyLoader>("another/identifier", 42);
2077 ```
2078 
2079 As above, the function returns true in case of success, false otherwise. The
2080 sole difference in this case is that an error necessarily means that the loader
2081 has failed for some reasons to load the resource.<br/>
2082 Note that the `reload` member function is a kind of alias of the following
2083 snippet:
2084 
2085 ```cpp
2086 cache.discard(identifier);
2087 cache.load<MyLoader>(identifier, 42);
2088 ```
2089 
2090 Where the `discard` member function is used to get rid of a resource if loaded.
2091 In case the cache doesn't contain a resource for the given identifier, the
2092 function does nothing and returns immediately.
2093 
2094 So far, so good. Resources are finally loaded and stored within the cache.<br/>
2095 They are returned to users in the form of handles. To get one of them:
2096 
2097 ```cpp
2098 auto handle = cache.handle("my/identifier");
2099 ```
2100 
2101 The idea behind a handle is the same of the flyweight pattern. In other terms,
2102 resources aren't copied around. Instead, instances are shared between handles.
2103 Users of a resource owns a handle and it guarantees that a resource isn't
2104 destroyed until all the handles are destroyed, even if the resource itself is
2105 removed from the cache.<br/>
2106 Handles are tiny objects both movable and copyable. They returns the contained
2107 resource as a const reference on request:
2108 
2109 * By means of the `get` member function:
2110 
2111  ```cpp
2112  const auto &resource = handle.get();
2113  ```
2114 
2115 * Using the proper cast operator:
2116 
2117  ```cpp
2118  const auto &resource = handle;
2119  ```
2120 
2121 * Through the dereference operator:
2122 
2123  ```cpp
2124  const auto &resource = *handle;
2125  ```
2126 
2127 The resource can also be accessed directly using the arrow operator if required:
2128 
2129 ```cpp
2130 auto value = handle->value;
2131 ```
2132 
2133 To test if a handle is still valid, the cast operator to `bool` allows users to
2134 use it in a guard:
2135 
2136 ```cpp
2137 if(handle) {
2138  // ...
2139 }
2140 ```
2141 
2142 Finally, in case there is the need to load a resource and thus to get a handle
2143 without storing the resource itself in the cache, users can rely on the `temp`
2144 member function template.<br/>
2145 The declaration is similar to the one of `load` but for the fact that it doesn't
2146 return a boolean value. Instead, it returns a (possibly invalid) handle for the
2147 resource:
2148 
2149 ```cpp
2150 auto handle = cache.temp<MyLoader>("another/identifier", 42);
2151 ```
2152 
2153 Do not forget to test the handle for validity. Otherwise, getting the reference
2154 to the resource it points may result in undefined behavior.
2155 
2156 # Crash Course: events, signals and everything in between
2157 
2158 Signals are usually a core part of games and software architectures in
2159 general.<br/>
2160 Roughly speaking, they help to decouple the various parts of a system while
2161 allowing them to communicate with each other somehow.
2162 
2163 The so called _modern C++_ comes with a tool that can be useful in these terms,
2164 the `std::function`. As an example, it can be used to create delegates.<br/>
2165 However, there is no guarantee that an `std::function` does not perform
2166 allocations under the hood and this could be problematic sometimes. Furthermore,
2167 it solves a problem but may not adapt well to other requirements that may arise
2168 from time to time.
2169 
2170 In case that the flexibility and potential of an `std::function` are not
2171 required or where you are looking for something different, the `EnTT` framework
2172 offers a full set of classes to solve completely different problems.
2173 
2174 ## Signals
2175 
2176 Signal handlers work with naked pointers, function pointers and pointers to
2177 member functions. Listeners can be any kind of objects and the user is in charge
2178 of connecting and disconnecting them from a signal to avoid crashes due to
2179 different lifetimes. On the other side, performance shouldn't be affected that
2180 much by the presence of such a signal handler.<br/>
2181 A signal handler can be used as a private data member without exposing any
2182 _publish_ functionality to the clients of a class. The basic idea is to impose a
2183 clear separation between the signal itself and its _sink_ class, that is a tool
2184 to be used to connect and disconnect listeners on the fly.
2185 
2186 The API of a signal handler is straightforward. The most important thing is that
2187 it comes in two forms: with and without a collector. In case a signal is
2188 associated with a collector, all the values returned by the listeners can be
2189 literally _collected_ and used later by the caller. Otherwise it works just like
2190 a plain signal that emits events from time to time.<br/>
2191 
2192 **Note**: collectors are allowed only in case of function types whose the return
2193 type isn't `void` for obvious reasons.
2194 
2195 To create instances of signal handlers there exist mainly two ways:
2196 
2197 ```cpp
2198 // no collector type
2199 entt::SigH<void(int, char)> signal;
2200 
2201 // explicit collector type
2202 entt::SigH<void(int, char), MyCollector<bool>> collector;
2203 ```
2204 
2205 As expected, they offer all the basic functionalities required to know how many
2206 listeners they contain (`size`) or if they contain at least a listener (`empty`)
2207 and even to swap two signal handlers (`swap`).
2208 
2209 Besides them, there are member functions to use both to connect and disconnect
2210 listeners in all their forms by means of a sink::
2211 
2212 ```cpp
2213 void foo(int, char) { /* ... */ }
2214 
2215 struct S {
2216  void bar(int, char) { /* ... */ }
2217 };
2218 
2219 // ...
2220 
2221 S instance;
2222 
2223 signal.sink().connect<&foo>();
2224 signal.sink().connect<S, &S::bar>(&instance);
2225 
2226 // ...
2227 
2228 // disconnects a free function
2229 signal.sink().disconnect<&foo>();
2230 
2231 // disconnect a specific member function of an instance ...
2232 signal.sink().disconnect<S, &S::bar>(&instance);
2233 
2234 // ... or an instance as a whole
2235 signal.sink().disconnect(&instance);
2236 
2237 // discards all the listeners at once
2238 signal.sink().disconnect();
2239 ```
2240 
2241 Once listeners are attached (or even if there are no listeners at all), events
2242 and data in general can be published through a signal by means of the `publish`
2243 member function:
2244 
2245 ```cpp
2246 signal.publish(42, 'c');
2247 ```
2248 
2249 To collect data, the `collect` member function should be used instead. Below is
2250 a minimal example to show how to use it:
2251 
2252 ```cpp
2253 struct MyCollector {
2254  std::vector<int> vec{};
2255 
2256  bool operator()(int v) noexcept {
2257  vec.push_back(v);
2258  return true;
2259  }
2260 };
2261 
2262 int f() { return 0; }
2263 int g() { return 1; }
2264 
2265 // ...
2266 
2267 entt::SigH<int(), MyCollector<int>> signal;
2268 
2269 signal.sink().connect<&f>();
2270 signal.sink().connect<&g>();
2271 
2272 MyCollector collector = signal.collect();
2273 
2274 assert(collector.vec[0] == 0);
2275 assert(collector.vec[1] == 1);
2276 ```
2277 
2278 As shown above, a collector must expose a function operator that accepts as an
2279 argument a type to which the return type of the listeners can be converted.
2280 Moreover, it has to return a boolean value that is false to stop collecting
2281 data, true otherwise. This way one can avoid calling all the listeners in case
2282 it isn't necessary.
2283 
2284 ## Delegate
2285 
2286 A delegate can be used as general purpose invoker with no memory overhead for
2287 free functions and member functions provided along with an instance on which
2288 to invoke them.<br/>
2289 It does not claim to be a drop-in replacement for an `std::function`, so do not
2290 expect to use it whenever an `std::function` fits well. However, it can be used
2291 to send opaque delegates around to be used to invoke functions as needed.
2292 
2293 The interface is trivial. It offers a default constructor to create empty
2294 delegates:
2295 
2296 ```cpp
2297 entt::Delegate<int(int)> delegate{};
2298 ```
2299 
2300 All what is needed to create an instance is to specify the type of the function
2301 the delegate will _contain_, that is the signature of the free function or the
2302 member function one wants to assign to it.
2303 
2304 Attempting to use an empty delegate by invoking its function call operator
2305 results in undefined behavior, most likely a crash actually. Before to use a
2306 delegate, it must be initialized.<br/>
2307 There exist two functions to do that, both named `connect`:
2308 
2309 ```cpp
2310 int f(int i) { return i; }
2311 
2312 struct MyStruct {
2313  int f(int i) { return i }
2314 };
2315 
2316 // bind a free function to the delegate
2317 delegate.connect<&f>();
2318 
2319 // bind a member function to the delegate
2320 MyStruct instance;
2321 delegate.connect<MyStruct, &MyStruct::f>(&instance);
2322 ```
2323 
2324 It hasn't a `disconnect` counterpart. Instead, there exists a `reset` member
2325 function to clear it.<br/>
2326 Finally, to invoke a delegate, the function call operator is the way to go as
2327 usual:
2328 
2329 ```cpp
2330 auto ret = delegate(42);
2331 ```
2332 
2333 Probably too much small and pretty poor of functionalities, but the delegate
2334 class can help in a lot of cases and it has shown that it is worth keeping it
2335 within the framework.
2336 
2337 ## Event dispatcher
2338 
2339 The event dispatcher class is designed so as to be used in a loop. It allows
2340 users both to trigger immediate events or to queue events to be published all
2341 together once per tick.<br/>
2342 This class shares part of its API with the one of the signal handler, but it
2343 doesn't require that all the types of events are specified when declared:
2344 
2345 ```cpp
2346 // define a general purpose dispatcher that works with naked pointers
2347 entt::Dispatcher dispatcher{};
2348 ```
2349 
2350 In order to register an instance of a class to a dispatcher, its type must
2351 expose one or more member functions of which the return types are `void` and the
2352 argument lists are `const E &`, for each type of event `E`.<br/>
2353 To ease the development, member functions that are named `receive` are
2354 automatically detected and have not to be explicitly specified when registered.
2355 In all the other cases, the name of the member function aimed to receive the
2356 event must be provided to the `connect` member function of the sink bound to the
2357 specific event:
2358 
2359 ```cpp
2360 struct AnEvent { int value; };
2361 struct AnotherEvent {};
2362 
2363 struct Listener
2364 {
2365  void receive(const AnEvent &) { /* ... */ }
2366  void method(const AnotherEvent &) { /* ... */ }
2367 };
2368 
2369 // ...
2370 
2371 Listener listener;
2372 dispatcher.sink<AnEvent>().connect(&listener);
2373 dispatcher.sink<AnotherEvent>().connect<Listener, &Listener::method>(&listener);
2374 ```
2375 
2376 The `disconnect` member function follows the same pattern and can be used to
2377 selectively remove listeners:
2378 
2379 ```cpp
2380 dispatcher.sink<AnEvent>().disconnect(&listener);
2381 dispatcher.sink<AnotherEvent>().disconnect<Listener, &Listener::method>(&listener);
2382 ```
2383 
2384 The `trigger` member function serves the purpose of sending an immediate event
2385 to all the listeners registered so far. It offers a convenient approach that
2386 relieves the user from having to create the event itself. Instead, it's enough
2387 to specify the type of event and provide all the parameters required to
2388 construct it.<br/>
2389 As an example:
2390 
2391 ```cpp
2392 dispatcher.trigger<AnEvent>(42);
2393 dispatcher.trigger<AnotherEvent>();
2394 ```
2395 
2396 Listeners are invoked immediately, order of execution isn't guaranteed. This
2397 method can be used to push around urgent messages like an _is terminating_
2398 notification on a mobile app.
2399 
2400 On the other hand, the `enqueue` member function queues messages together and
2401 allows to maintain control over the moment they are sent to listeners. The
2402 signature of this method is more or less the same of `trigger`:
2403 
2404 ```cpp
2405 dispatcher.enqueue<AnEvent>(42);
2406 dispatcher.enqueue<AnotherEvent>();
2407 ```
2408 
2409 Events are stored aside until the `update` member function is invoked, then all
2410 the messages that are still pending are sent to the listeners at once:
2411 
2412 ```cpp
2413 // emits all the events of the given type at once
2414 dispatcher.update<MyEvent>();
2415 
2416 // emits all the events queued so far at once
2417 dispatcher.update();
2418 ```
2419 
2420 This way users can embed the dispatcher in a loop and literally dispatch events
2421 once per tick to their systems.
2422 
2423 ## Event emitter
2424 
2425 A general purpose event emitter thought mainly for those cases where it comes to
2426 working with asynchronous stuff.<br/>
2427 Originally designed to fit the requirements of
2428 [`uvw`](https://github.com/skypjack/uvw) (a wrapper for `libuv` written in
2429 modern C++), it was adapted later to be included in this library.
2430 
2431 To create a custom emitter type, derived classes must inherit directly from the
2432 base class as:
2433 
2434 ```cpp
2435 struct MyEmitter: Emitter<MyEmitter> {
2436  // ...
2437 }
2438 ```
2439 
2440 The full list of accepted types of events isn't required. Handlers are created
2441 internally on the fly and thus each type of event is accepted by default.
2442 
2443 Whenever an event is published, an emitter provides the listeners with a
2444 reference to itself along with a const reference to the event. Therefore
2445 listeners have an handy way to work with it without incurring in the need of
2446 capturing a reference to the emitter itself.<br/>
2447 In addition, an opaque object is returned each time a connection is established
2448 between an emitter and a listener, allowing the caller to disconnect them at a
2449 later time.<br/>
2450 The opaque object used to handle connections is both movable and copyable. On
2451 the other side, an event emitter is movable but not copyable by default.
2452 
2453 To create new instances of an emitter, no arguments are required:
2454 
2455 ```cpp
2456 MyEmitter emitter{};
2457 ```
2458 
2459 Listeners must be movable and callable objects (free functions, lambdas,
2460 functors, `std::function`s, whatever) whose function type is:
2461 
2462 ```cpp
2463 void(const Event &, MyEmitter &)
2464 ```
2465 
2466 Where `Event` is the type of event they want to listen.<br/>
2467 There are two ways to attach a listener to an event emitter that differ
2468 slightly from each other:
2469 
2470 * To register a long-lived listener, use the `on` member function. It is meant
2471  to register a listener designed to be invoked more than once for the given
2472  event type.<br/>
2473  As an example:
2474 
2475  ```cpp
2476  auto conn = emitter.on<MyEvent>([](const MyEvent &event, MyEmitter &emitter) {
2477  // ...
2478  });
2479  ```
2480 
2481  The connection object can be freely discarded. Otherwise, it can be used later
2482  to disconnect the listener if required.
2483 
2484 * To register a short-lived listener, use the `once` member function. It is
2485  meant to register a listener designed to be invoked only once for the given
2486  event type. The listener is automatically disconnected after the first
2487  invocation.<br/>
2488  As an example:
2489 
2490  ```cpp
2491  auto conn = emitter.once<MyEvent>([](const MyEvent &event, MyEmitter &emitter) {
2492  // ...
2493  });
2494  ```
2495 
2496  The connection object can be freely discarded. Otherwise, it can be used later
2497  to disconnect the listener if required.
2498 
2499 In both cases, the connection object can be used with the `erase` member
2500 function:
2501 
2502 ```cpp
2503 emitter.erase(conn);
2504 ```
2505 
2506 There are also two member functions to use either to disconnect all the
2507 listeners for a given type of event or to clear the emitter:
2508 
2509 ```cpp
2510 // removes all the listener for the specific event
2511 emitter.clear<MyEvent>();
2512 
2513 // removes all the listeners registered so far
2514 emitter.clear();
2515 ```
2516 
2517 To send an event to all the listeners that are interested in it, the `publish`
2518 member function offers a convenient approach that relieves the user from having
2519 to create the event:
2520 
2521 ```cpp
2522 struct MyEvent { int i; };
2523 
2524 // ...
2525 
2526 emitter.publish<MyEvent>(42);
2527 ```
2528 
2529 Finally, the `empty` member function tests if there exists at least either a
2530 listener registered with the event emitter or to a given type of event:
2531 
2532 ```cpp
2533 bool empty;
2534 
2535 // checks if there is any listener registered for the specific event
2536 empty = emitter.empty<MyEvent>();
2537 
2538 // checks it there are listeners registered with the event emitter
2539 empty = emitter.empty();
2540 ```
2541 
2542 In general, the event emitter is a handy tool when the derived classes _wrap_
2543 asynchronous operations, because it introduces a _nice-to-have_ model based on
2544 events and listeners that kindly hides the complexity behind the scenes. However
2545 it is not limited to such uses.
2546 
2547 # Packaging Tools
2548 
2549 `EnTT` is available for some of the most known packaging tools. In particular:
2550 
2551 * [`vcpkg`](https://github.com/Microsoft/vcpkg/tree/master/ports/entt),
2552  Microsoft VC++ Packaging Tool.
2553 * [`Homebrew`](https://github.com/skypjack/homebrew-entt), the missing package
2554  manager for macOS.<br/>
2555  Available as a homebrew formula. Just type the following to install it:
2556  ```
2557  brew install skypjack/entt/entt
2558  ```
2559 
2560 Consider this list a work in progress and help me to make it longer.
2561 
2562 # EnTT in Action
2563 
2564 `EnTT` is widely used in private and commercial applications. I cannot even
2565 mention most of them because of some signatures I put on some documents time
2566 ago.<br/>
2567 Fortunately, there are also people who took the time to implement open source
2568 projects based on EnTT and did not hold back when it came to documenting them.
2569 
2570 Below an incomplete list of projects and articles:
2571 
2572 * [EnttPong](https://github.com/reworks/EnttPong): example game for `EnTT`
2573  framework.
2574 * [ECS_SpaceBattle](https://github.com/vblanco20-1/ECS_SpaceBattle): huge space
2575  battle built on `UE4`.
2576 * [Experimenting with ECS in UE4](http://victor.madtriangles.com/code%20experiment/2018/03/25/post-ue4-ecs-battle.html):
2577  interesting article about `UE4` and `EnTT`.
2578 * [Implementing ECS architecture in UE4](https://forums.unrealengine.com/development-discussion/c-gameplay-programming/1449913-implementing-ecs-architecture-in-ue4-giant-space-battle):
2579  giant space battle.
2580 * [MatchOneEntt](https://github.com/mhaemmerle/MatchOneEntt): port of
2581  [Match One](https://github.com/sschmid/Match-One) for `Entitas-CSharp`.
2582 * [Randballs](https://github.com/gale93/randballs): simple `SFML` and `EnTT`
2583  playground.
2584 * ...
2585 
2586 If you know of other resources out there that are about `EnTT`, feel free to
2587 open an issue or a PR and I'll be glad to add them to the list.
2588 
2589 # Contributors
2590 
2591 If you want to participate, please see the guidelines for
2592 [contributing](https://github.com/skypjack/entt/blob/master/CONTRIBUTING)
2593 before to create issues or pull requests.<br/>
2594 Take also a look at the
2595 [contributors list](https://github.com/skypjack/entt/blob/master/AUTHORS) to
2596 know who has participated so far.
2597 
2598 # License
2599 
2600 Code and documentation Copyright (c) 2018 Michele Caini.<br/>
2601 Code released under
2602 [the MIT license](https://github.com/skypjack/entt/blob/master/LICENSE).
2603 Docs released under
2604 [Creative Commons](https://github.com/skypjack/entt/blob/master/docs/LICENSE).
2605 
2606 # Support
2607 
2608 ## Donation
2609 
2610 Developing and maintaining `EnTT` takes some time and lots of coffee. I'd like
2611 to add more and more functionalities in future and turn it in a full-featured
2612 framework.<br/>
2613 If you want to support this project, you can offer me an espresso. I'm from
2614 Italy, we're used to turning the best coffee ever in code. If you find that
2615 it's not enough, feel free to support me the way you prefer.<br/>
2616 Take a look at the donation button at the top of the page for more details or
2617 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).
2618 
2619 ## Hire me
2620 
2621 If you start using `EnTT` and need help, if you want a new feature and want me
2622 to give it the highest priority, if you have any other reason to contact me:
2623 do not hesitate. I'm available for hiring.<br/>
2624 Feel free to take a look at my [profile](https://github.com/skypjack) and
2625 contact me by mail.
Generated by   diff --git a/actor_8hpp_source.html b/actor_8hpp_source.html index d906dc150..65db07ab4 100644 --- a/actor_8hpp_source.html +++ b/actor_8hpp_source.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -67,21 +67,23 @@ $(function() {
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 entity_type = Entity;
28  using delta_type = Delta;
29 
34  Actor(Registry<Entity> &reg)
35  : reg{reg}, entity{reg.create()}
36  {}
37 
39  virtual ~Actor() {
40  reg.destroy(entity);
41  }
42 
44  Actor(const Actor &) = default;
46  Actor(Actor &&) = default;
47 
49  Actor & operator=(const Actor &) = default;
51  Actor & operator=(Actor &&) = default;
52 
67  template<typename Component, typename... Args>
68  Component & set(Args &&... args) {
69  return reg.template accommodate<Component>(entity, std::forward<Args>(args)...);
70  }
71 
76  template<typename Component>
77  void unset() {
78  reg.template remove<Component>(entity);
79  }
80 
86  template<typename Component>
87  bool has() const noexcept {
88  return reg.template has<Component>(entity);
89  }
90 
96  template<typename Component>
97  const Component & get() const noexcept {
98  return reg.template get<Component>(entity);
99  }
100 
106  template<typename Component>
107  Component & get() noexcept {
108  return const_cast<Component &>(const_cast<const Actor *>(this)->get<Component>());
109  }
110 
115  const registry_type & registry() const noexcept {
116  return reg;
117  }
118 
123  registry_type & registry() noexcept {
124  return const_cast<registry_type &>(const_cast<const Actor *>(this)->registry());
125  }
126 
131  virtual void update(delta_type delta) = 0;
132 
133 private:
134  registry_type &reg;
135  Entity entity;
136 };
137 
138 
147 template<typename Delta>
148 using DefaultActor = Actor<DefaultRegistry::entity_type, Delta>;
149 
150 
151 }
152 
153 
154 #endif // ENTT_ENTITY_ACTOR_HPP
entt::Registry
Fast and reliable entity-component system.
Definition: registry.hpp:35
-
entt
EnTT default namespace.
Definition: family.hpp:10
-
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:34
-
entt::Actor::delta_type
Delta delta_type
Type used to provide elapsed time.
Definition: actor.hpp:28
-
entt::Registry::create
entity_type create(Component &&... components) noexcept
Returns a new entity initialized with the given components.
Definition: registry.hpp:375
-
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:87
-
entt::Actor::registry
const registry_type & registry() const noexcept
Returns a reference to the underlying registry.
Definition: actor.hpp:115
-
entt::Registry::destroy
void destroy(entity_type entity)
Destroys an entity and lets the registry recycle the identifier.
Definition: registry.hpp:462
-
entt::Actor::entity_type
Entity entity_type
Underlying entity identifier.
Definition: actor.hpp:26
-
entt::Actor::~Actor
virtual ~Actor()
Default destructor.
Definition: actor.hpp:39
-
entt::Actor::unset
void unset()
Removes the given component from an actor.
Definition: actor.hpp:77
-
entt::Actor::registry
registry_type & registry() noexcept
Returns a reference to the underlying registry.
Definition: actor.hpp:123
+
1 #ifndef ENTT_ENTITY_ACTOR_HPP
2 #define ENTT_ENTITY_ACTOR_HPP
3 
4 
5 #include <cassert>
6 #include <utility>
7 #include "../config/config.h"
8 #include "registry.hpp"
9 
10 
11 namespace entt {
12 
13 
22 template<typename Entity>
23 struct Actor {
25  using registry_type = Registry<Entity>;
27  using entity_type = Entity;
28 
33  Actor(Registry<Entity> &reg)
34  : reg{reg}, entt{reg.create()}
35  {}
36 
38  virtual ~Actor() {
39  reg.destroy(entt);
40  }
41 
43  Actor(const Actor &) = default;
45  Actor(Actor &&) = default;
46 
48  Actor & operator=(const Actor &) = default;
50  Actor & operator=(Actor &&) = default;
51 
65  template<typename Tag, typename... Args>
66  Tag & assign(tag_t, Args &&... args) {
67  return (reg.template remove<Tag>(), reg.template assign<Tag>(tag_t{}, entt, std::forward<Args>(args)...));
68  }
69 
84  template<typename Component, typename... Args>
85  Component & assign(Args &&... args) {
86  return reg.template accommodate<Component>(entt, std::forward<Args>(args)...);
87  }
88 
93  template<typename Tag>
94  void remove(tag_t) {
95  assert(has<Tag>(tag_t{}));
96  reg.template remove<Tag>();
97  }
98 
103  template<typename Component>
104  void remove() {
105  reg.template remove<Component>(entt);
106  }
107 
113  template<typename Tag>
114  bool has(tag_t) const ENTT_NOEXCEPT {
115  return (reg.template has<Tag>() && (reg.template attachee<Tag>() == entt));
116  }
117 
123  template<typename Component>
124  bool has() const ENTT_NOEXCEPT {
125  return reg.template has<Component>(entt);
126  }
127 
133  template<typename Tag>
134  const Tag & get(tag_t) const ENTT_NOEXCEPT {
135  assert(has<Tag>(tag_t{}));
136  return reg.template get<Tag>();
137  }
138 
144  template<typename Tag>
145  inline Tag & get(tag_t) ENTT_NOEXCEPT {
146  return const_cast<Tag &>(const_cast<const Actor *>(this)->get<Tag>(tag_t{}));
147  }
148 
154  template<typename Component>
155  const Component & get() const ENTT_NOEXCEPT {
156  return reg.template get<Component>(entt);
157  }
158 
164  template<typename Component>
165  inline Component & get() ENTT_NOEXCEPT {
166  return const_cast<Component &>(const_cast<const Actor *>(this)->get<Component>());
167  }
168 
173  const registry_type & registry() const ENTT_NOEXCEPT {
174  return reg;
175  }
176 
181  inline registry_type & registry() ENTT_NOEXCEPT {
182  return const_cast<registry_type &>(const_cast<const Actor *>(this)->registry());
183  }
184 
189  entity_type entity() const ENTT_NOEXCEPT {
190  return entt;
191  }
192 
193 private:
194  registry_type &reg;
195  Entity entt;
196 };
197 
198 
205 using DefaultActor = Actor<DefaultRegistry::entity_type>;
206 
207 
208 }
209 
210 
211 #endif // ENTT_ENTITY_ACTOR_HPP
entt::Actor::registry
registry_type & registry() ENTT_NOEXCEPT
Returns a reference to the underlying registry.
Definition: actor.hpp:181
+
entt::Actor::entity_type
Entity entity_type
Underlying entity identifier.
Definition: actor.hpp:27
+
entt::Actor::registry
const registry_type & registry() const ENTT_NOEXCEPT
Returns a reference to the underlying registry.
Definition: actor.hpp:173
+
entt::Registry::destroy
void destroy(const entity_type entity)
Destroys an entity and lets the registry recycle the identifier.
Definition: registry.hpp:478
+
entt::Registry
Fast and reliable entity-component system.
Definition: registry.hpp:39
+
entt::Actor::has
bool has() const ENTT_NOEXCEPT
Checks if an actor has the given component.
Definition: actor.hpp:124
+
entt::Actor::Actor
Actor(Registry< Entity > &reg)
Constructs an actor by using the given registry.
Definition: actor.hpp:33
+
entt::Registry::create
entity_type create() ENTT_NOEXCEPT
Creates a new entity and returns it.
Definition: registry.hpp:390
+
entt
EnTT default namespace.
Definition: algorithm.hpp:10
+
entt::Actor::entity
entity_type entity() const ENTT_NOEXCEPT
Returns the entity associated with an actor.
Definition: actor.hpp:189
+
entt::Actor::assign
Tag & assign(tag_t, Args &&... args)
Assigns the given tag to an actor.
Definition: actor.hpp:66
+
entt::Actor::assign
Component & assign(Args &&... args)
Assigns the given component to an actor.
Definition: actor.hpp:85
+
entt::Actor::operator=
Actor & operator=(const Actor &)=default
Default copy assignment operator.
+
entt::Actor::has
bool has(tag_t) const ENTT_NOEXCEPT
Checks if an actor owns the given tag.
Definition: actor.hpp:114
+
entt::Actor
Dedicated to those who aren&#39;t confident with entity-component systems.
Definition: actor.hpp:23
+
entt::tag_t
Tag class type used to disambiguate overloads.
Definition: utility.hpp:9
+
entt::Actor::~Actor
virtual ~Actor()
Default destructor.
Definition: actor.hpp:38
diff --git a/algorithm_8hpp_source.html b/algorithm_8hpp_source.html new file mode 100644 index 000000000..11785e758 --- /dev/null +++ b/algorithm_8hpp_source.html @@ -0,0 +1,83 @@ + + + + + + + +entt: src/entt/core/algorithm.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
entt +  2.6.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
algorithm.hpp
+
+
+
1 #ifndef ENTT_CORE_ALGORITHM_HPP
2 #define ENTT_CORE_ALGORITHM_HPP
3 
4 
5 #include <functional>
6 #include <algorithm>
7 #include <utility>
8 
9 
10 namespace entt {
11 
12 
21 struct StdSort {
33  template<typename It, typename Compare = std::less<>>
34  void operator()(It first, It last, Compare compare = Compare{}) {
35  std::sort(std::move(first), std::move(last), std::move(compare));
36  }
37 };
38 
39 
41 struct InsertionSort {
53  template<typename It, typename Compare = std::less<>>
54  void operator()(It first, It last, Compare compare = Compare{}) {
55  auto it = first + 1;
56 
57  while(it != last) {
58  auto value = *it;
59  auto pre = it;
60 
61  while(pre != first && compare(value, *(pre-1))) {
62  *pre = *(pre-1);
63  --pre;
64  }
65 
66  *pre = value;
67  ++it;
68  }
69  }
70 };
71 
72 
73 }
74 
75 
76 #endif // ENTT_CORE_ALGORITHM_HPP
entt
EnTT default namespace.
Definition: algorithm.hpp:10
+
entt::StdSort::operator()
void operator()(It first, It last, Compare compare=Compare{})
Sorts the element in a range.
Definition: algorithm.hpp:34
+
entt::InsertionSort::operator()
void operator()(It first, It last, Compare compare=Compare{})
Sorts the element in a range.
Definition: algorithm.hpp:54
+
entt::InsertionSort
Function object for performing insertion sort.
Definition: algorithm.hpp:41
+
entt::StdSort
Function object to wrap std::sort in a class type.
Definition: algorithm.hpp:21
+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/annotated.html b/annotated.html index 805e9626b..08be96a7a 100644 --- a/annotated.html +++ b/annotated.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -67,42 +67,46 @@ $(function() {
[detail level 123]
- - - - - - - - - - - - - - - + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + +
 ▼NenttEnTT default namespace
 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
 CContinuousLoaderUtility class for continuous loading
 CDelegateBasic delegate implementation
 CDelegate< Ret(Args...)>Utility class to send around functions and member functions
 CDispatcherBasic dispatcher implementation
 ▼CEmitterGeneral purpose event emitter
 CConnectionGeneric connection type for events
 Centt_traitsEntity traits
 Centt_traits< std::uint16_t >Entity traits for a 16 bits entity identifier
 Centt_traits< std::uint32_t >Entity traits for a 32 bits entity identifier
 Centt_traits< std::uint64_t >Entity traits for a 64 bits entity identifier
 CFamilyDynamic identifier generator
 CHashedStringZero overhead resource identifier
 Cbreak_tBreak type used to disambiguate overloads
 CContinuousLoaderUtility class for continuous loading
 CDelegateBasic delegate implementation
 CDelegate< Ret(Args...)>Utility class to send around functions and member functions
 CDispatcherBasic dispatcher implementation
 ▼CEmitterGeneral purpose event emitter
 CConnectionGeneric connection type for events
 Centt_traitsEntity traits
 Centt_traits< std::uint16_t >Entity traits for a 16 bits entity identifier
 Centt_traits< std::uint32_t >Entity traits for a 32 bits entity identifier
 Centt_traits< std::uint64_t >Entity traits for a 64 bits entity identifier
 CFamilyDynamic identifier generator
 CHashedStringZero overhead resource identifier
 CInsertionSortFunction object for performing insertion sort
 Cpersistent_tPersistent view type used to disambiguate overloads
 CPersistentViewPersistent view
 CProcessBase class for processes
 CProcessAdaptorAdaptor for lambdas and functors to turn them into processes
 CRawViewRaw view
 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
 CSnapshotUtility class to create snapshots from a registry
 CSnapshotLoaderUtility class to restore a snapshot as a whole
 CSparseSetSparse set
 CSparseSet< Entity >Basic sparse set implementation
 CSparseSet< Entity, Type >Extended sparse set implementation
 CViewMulti component view
 CView< Entity, Component >Single component view specialization
 CPrototypePrototype container for concepts
 Craw_tRaw view type used to disambiguate overloads
 CRawViewRaw view
 CRegistryFast and reliable entity-component system
 CResourceCacheSimple cache for resources of a given type
 CResourceHandleShared resource handle
 CResourceLoaderBase class for resource loaders
 CSchedulerCooperative scheduler for processes
 CServiceLocatorService locator, nothing more
 CSigHUnmanaged signal handler declaration
 CSigH< Ret(Args...), Collector >Unmanaged signal handler definition
 CSinkSink implementation
 CSink< Ret(Args...)>Sink implementation
 CSnapshotUtility class to create snapshots from a registry
 CSnapshotLoaderUtility class to restore a snapshot as a whole
 CSparseSetSparse set
 CSparseSet< Entity >Basic sparse set implementation
 CSparseSet< Entity, Type >Extended sparse set implementation
 CStdSortFunction object to wrap std::sort in a class type
 Ctag_tTag class type used to disambiguate overloads
 CViewMulti component view
 CView< Entity, Component >Single component view specialization
diff --git a/bus_8hpp_source.html b/bus_8hpp_source.html deleted file mode 100644 index b5151fc01..000000000 --- a/bus_8hpp_source.html +++ /dev/null @@ -1,98 +0,0 @@ - - - - - - - -entt: src/entt/signal/bus.hpp Source File - - - - - - - - - -
-
- - - - - - -
-
entt -  2.5.0 -
-
-
- - - - - - - - -
-
- - -
- -
- - -
-
-
-
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 
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:10
-
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:97
-
entt::SigH
Unmanaged signal handler declaration.
Definition: sigh.hpp:87
-
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
-
- -
-Generated by   -doxygen - 1.8.13 -
- - diff --git a/cache_8hpp_source.html b/cache_8hpp_source.html index 14debb8c3..492a8a8e0 100644 --- a/cache_8hpp_source.html +++ b/cache_8hpp_source.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -67,22 +67,22 @@ $(function() {
cache.hpp
-
1 #ifndef ENTT_RESOURCE_CACHE_HPP
2 #define ENTT_RESOURCE_CACHE_HPP
3 
4 
5 #include <memory>
6 #include <utility>
7 #include <type_traits>
8 #include <unordered_map>
9 #include "../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  bool reload(resource_type id, Args &&... args) {
129  return (discard(id), load<Loader>(id, std::forward<Args>(args)...));
130  }
131 
144  template<typename Loader, typename... Args>
145  ResourceHandle<Resource> temp(Args &&... args) const {
146  return { Loader{}.get(std::forward<Args>(args)...) };
147  }
148 
162  ResourceHandle<Resource> handle(resource_type id) const {
163  auto it = resources.find(id);
164  return { it == resources.end() ? nullptr : it->second };
165  }
166 
172  bool contains(resource_type id) const noexcept {
173  return !(resources.find(id) == resources.cend());
174  }
175 
184  void discard(resource_type id) noexcept {
185  auto it = resources.find(id);
186 
187  if(it != resources.end()) {
188  resources.erase(it);
189  }
190  }
191 
192 private:
193  container_type resources;
194 };
195 
196 
197 }
198 
199 
200 #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 a given identifier.
Definition: cache.hpp:172
-
entt::ResourceCache::load
bool load(resource_type id, Args &&... args)
Loads the resource that corresponds to a 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:10
-
entt::ResourceCache::temp
ResourceHandle< Resource > temp(Args &&... args) const
Creates a temporary handle for a resource.
Definition: cache.hpp:145
-
entt::ResourceCache::discard
void discard(resource_type id) noexcept
Discards the resource that corresponds to a given identifier.
Definition: cache.hpp:184
+
1 #ifndef ENTT_RESOURCE_CACHE_HPP
2 #define ENTT_RESOURCE_CACHE_HPP
3 
4 
5 #include <memory>
6 #include <utility>
7 #include <type_traits>
8 #include <unordered_map>
9 #include "../config/config.h"
10 #include "../core/hashed_string.hpp"
11 #include "handle.hpp"
12 #include "loader.hpp"
13 
14 
15 namespace entt {
16 
17 
28 template<typename Resource>
29 class ResourceCache {
30  using container_type = std::unordered_map<HashedString::hash_type, std::shared_ptr<Resource>>;
31 
32 public:
34  using size_type = typename container_type::size_type;
36  using resource_type = HashedString;
37 
39  ResourceCache() = default;
40 
42  ResourceCache(const ResourceCache &) ENTT_NOEXCEPT = delete;
44  ResourceCache(ResourceCache &&) ENTT_NOEXCEPT = default;
45 
47  ResourceCache & operator=(const ResourceCache &) ENTT_NOEXCEPT = delete;
49  ResourceCache & operator=(ResourceCache &&) ENTT_NOEXCEPT = default;
50 
55  size_type size() const ENTT_NOEXCEPT {
56  return resources.size();
57  }
58 
63  bool empty() const ENTT_NOEXCEPT {
64  return resources.empty();
65  }
66 
73  void clear() ENTT_NOEXCEPT {
74  resources.clear();
75  }
76 
95  template<typename Loader, typename... Args>
96  bool load(const resource_type id, Args &&... args) {
97  static_assert(std::is_base_of<ResourceLoader<Loader, Resource>, Loader>::value, "!");
98 
99  bool loaded = true;
100 
101  if(resources.find(id) == resources.cend()) {
102  std::shared_ptr<Resource> resource = Loader{}.get(std::forward<Args>(args)...);
103  loaded = (static_cast<bool>(resource) ? (resources[id] = std::move(resource), loaded) : false);
104  }
105 
106  return loaded;
107  }
108 
128  template<typename Loader, typename... Args>
129  bool reload(const resource_type id, Args &&... args) {
130  return (discard(id), load<Loader>(id, std::forward<Args>(args)...));
131  }
132 
145  template<typename Loader, typename... Args>
146  ResourceHandle<Resource> temp(Args &&... args) const {
147  return { Loader{}.get(std::forward<Args>(args)...) };
148  }
149 
163  ResourceHandle<Resource> handle(const resource_type id) const {
164  auto it = resources.find(id);
165  return { it == resources.end() ? nullptr : it->second };
166  }
167 
173  bool contains(const resource_type id) const ENTT_NOEXCEPT {
174  return (resources.find(id) != resources.cend());
175  }
176 
185  void discard(const resource_type id) ENTT_NOEXCEPT {
186  auto it = resources.find(id);
187 
188  if(it != resources.end()) {
189  resources.erase(it);
190  }
191  }
192 
193 private:
194  container_type resources;
195 };
196 
197 
198 }
199 
200 
201 #endif // ENTT_RESOURCE_CACHE_HPP
entt::ResourceCache::size_type
typename container_type::size_type size_type
Unsigned integer type.
Definition: cache.hpp:34
+
entt::ResourceCache::discard
void discard(const resource_type id) ENTT_NOEXCEPT
Discards the resource that corresponds to a given identifier.
Definition: cache.hpp:185
+
entt::ResourceCache::contains
bool contains(const resource_type id) const ENTT_NOEXCEPT
Checks if a cache contains a given identifier.
Definition: cache.hpp:173
+
entt::ResourceCache::reload
bool reload(const resource_type id, Args &&... args)
Reloads a resource or loads it for the first time if not present.
Definition: cache.hpp:129
+
entt
EnTT default namespace.
Definition: algorithm.hpp:10
+
entt::ResourceCache::temp
ResourceHandle< Resource > temp(Args &&... args) const
Creates a temporary handle for a resource.
Definition: cache.hpp:146
entt::ResourceCache::ResourceCache
ResourceCache()=default
Default constructor.
-
entt::ResourceCache::handle
ResourceHandle< Resource > handle(resource_type id) const
Creates a handle for a given resource identifier.
Definition: cache.hpp:162
-
entt::HashedString
Zero overhead resource identifier.
Definition: hashed_string.hpp:21
+
entt::HashedString
Zero overhead resource identifier.
Definition: hashed_string.hpp:22
+
entt::ResourceCache::size
size_type size() const ENTT_NOEXCEPT
Number of resources managed by a cache.
Definition: cache.hpp:55
+
entt::ResourceCache::empty
bool empty() const ENTT_NOEXCEPT
Returns true if a cache contains no resources, false otherwise.
Definition: cache.hpp:63
entt::ResourceLoader
Base class for resource loaders.
Definition: loader.hpp:48
-
entt::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
-
entt::ResourceCache::reload
bool reload(resource_type id, Args &&... args)
Reloads a resource or loads it for the first time if not present.
Definition: cache.hpp:128
+
entt::ResourceHandle
Shared resource handle.
Definition: handle.hpp:31
+
entt::ResourceCache::load
bool load(const resource_type id, Args &&... args)
Loads the resource that corresponds to a given identifier.
Definition: cache.hpp:96
+
entt::ResourceCache::handle
ResourceHandle< Resource > handle(const resource_type id) const
Creates a handle for a given resource identifier.
Definition: cache.hpp:163
+
entt::ResourceCache
Simple cache for resources of a given type.
Definition: cache.hpp:29
+
entt::ResourceCache::clear
void clear() ENTT_NOEXCEPT
Clears a cache and discards all its resources.
Definition: cache.hpp:73
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 deleted file mode 100644 index 3f5db4287..000000000 --- a/classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4-members.html +++ /dev/null @@ -1,91 +0,0 @@ - - - - - - - -entt: Member List - - - - - - - - - -
-
- - - - - - -
-
entt -  2.5.0 -
-
-
- - - - - - - - -
-
- - -
- -
- - -
-
-
-
entt::Bus< Sig, Event, Other... > Member List
-
-
- -

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

- - - - - - - - - - - -
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
- -
-Generated by   -doxygen - 1.8.13 -
- - 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 deleted file mode 100644 index b24f0ceea..000000000 --- a/classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4.html +++ /dev/null @@ -1,450 +0,0 @@ - - - - - - - -entt: entt::Bus< Sig, Event, Other... > Class Template Reference - - - - - - - - - -
-
- - - - - - -
-
entt -  2.5.0 -
-
-
- - - - - - - - -
-
- - -
- -
- - -
-
-
-Public Types | -Public Member Functions | -List of all members
-
-
entt::Bus< Sig, Event, Other... > Class Template Reference
-
-
- -

Event bus specialization for multiple types. - More...

- -

#include <bus.hpp>

-
-Inheritance diagram for entt::Bus< Sig, Event, Other... >:
-
-
Inheritance graph
- - - - -
[legend]
-
-Collaboration diagram for entt::Bus< Sig, Event, Other... >:
-
-
Collaboration graph
- - - - -
[legend]
- - - - - -

-Public Types

-using size_type = std::size_t
 Unsigned integer type.
 
- - - - - - - - - - - - - - - - - - - - - - - - - - - -

-Public Member Functions

template<typename Instance >
void unreg (Instance instance)
 Unregisters all the member functions of an instance. More...
 
template<typename Instance >
void reg (Instance instance)
 Registers all the member functions of an instance. More...
 
size_type size () const noexcept
 Number of listeners connected to the bus. More...
 
bool empty () const noexcept
 Returns false if at least a listener is connected to the bus. More...
 
template<typename Type , void(*)(const Type &) Function>
void connect ()
 Connects a free function to the bus. More...
 
template<typename Type , void(*)(const Type &) Function>
void disconnect ()
 Disconnects a free function from the bus. More...
 
template<typename Type , typename... Args>
void publish (Args &&... args)
 Publishes an event. More...
 
-

Detailed Description

-

template<template< typename... > class Sig, typename Event, typename... Other>
-class entt::Bus< Sig, Event, Other... >

- -

Event bus specialization for multiple types.

-

The event bus is designed to allow an easy registration of specific member functions to a bunch of signal handlers (either manager or unmanaged). Classes must publicly expose the required member functions to allow the bus to detect them for the purpose of registering and unregistering instances.
- In particular, for each event type E, a matching member function has the following signature: void receive(const E &). Events will be properly redirected to all the listeners by calling the right member functions, if any.

-
Template Parameters
- - - -
SigType of signal handler to use.
EventThe list of events managed by the bus.
-
-
- -

Definition at line 42 of file bus.hpp.

-

Member Function Documentation

- -

◆ connect()

- -
-
-
-template<template< typename... > class Sig, typename Event , typename... Other>
-
-template<typename Type , void(*)(const Type &) Function>
- - - - - -
- - - - - - - -
void entt::Bus< Sig, Event, Other... >::connect ()
- 		-inline
-
- -

Connects a free function to the bus.

-
Template Parameters
- - - -
TypeType of event to which to connect the function.
FunctionA valid free function pointer.
-
-
- -

Definition at line 121 of file bus.hpp.

- -
-
- -

◆ disconnect()

- -
-
-
-template<template< typename... > class Sig, typename Event , typename... Other>
-
-template<typename Type , void(*)(const Type &) Function>
- - - - - -
- - - - - - - -
void entt::Bus< Sig, Event, Other... >::disconnect ()
- 		-inline
-
- -

Disconnects a free function from the bus.

-
Template Parameters
- - - -
TypeType of event from which to disconnect the function.
FunctionA valid free function pointer.
-
-
- -

Definition at line 131 of file bus.hpp.

- -
-
- -

◆ empty()

- -
-
-
-template<template< typename... > class Sig, typename Event , typename... Other>
- - - - - -
- - - - - - - -
bool entt::Bus< Sig, Event, Other... >::empty () const
- 		-inlinenoexcept
-
- -

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 108 of file bus.hpp.

- -
-
- -

◆ publish()

- -
-
-
-template<template< typename... > class Sig, typename Event , typename... Other>
-
-template<typename Type , typename... Args>
- - - - - -
- - - - - - - - -
void entt::Bus< Sig, Event, Other... >::publish (Args &&... args)
- 		-inline
-
- -

Publishes an event.

-

All the listeners are notified. Order isn't guaranteed.

-
Template Parameters
- - - -
TypeType of event to publish.
ArgsTypes of arguments to use to construct the event.
-
-
-
Parameters
- - -
argsArguments to use to construct the event.
-
-
- -

Definition at line 145 of file bus.hpp.

- -
-
- -

◆ reg()

- -
-
-
-template<template< typename... > class Sig, typename Event , typename... Other>
-
-template<typename Instance >
- - - - - -
- - - - - - - - -
void entt::Bus< Sig, Event, Other... >::reg (Instance instance)
- 		-inline
-
- -

Registers all the member functions of an instance.

-

A bus is used to convey a certain set of events. This method detects and registers to the bus all the matching member functions of an instance.
- For each event type E, a matching member function has the following signature: void receive(const E &).

-
Template Parameters
- - -
InstanceType of instance to register.
-
-
-
Parameters
- - -
instanceA valid instance of the right type.
-
-
- -

Definition at line 84 of file bus.hpp.

- -
-
- -

◆ size()

- -
-
-
-template<template< typename... > class Sig, typename Event , typename... Other>
- - - - - -
- - - - - - - -
size_type entt::Bus< Sig, Event, Other... >::size () const
- 		-inlinenoexcept
-
- -

Number of listeners connected to the bus.

-
Returns
Number of listeners currently connected.
- -

Definition at line 97 of file bus.hpp.

- -
-
- -

◆ unreg()

- -
-
-
-template<template< typename... > class Sig, typename Event , typename... Other>
-
-template<typename Instance >
- - - - - -
- - - - - - - - -
void entt::Bus< Sig, Event, Other... >::unreg (Instance instance)
- 		-inline
-
- -

Unregisters all the member functions of an instance.

-

A bus is used to convey a certain set of events. This method detects and unregisters from the bus all the matching member functions of an instance.
- For each event type E, a matching member function has the following signature: void receive(const E &).

-
Template Parameters
- - -
InstanceType of instance to unregister.
-
-
-
Parameters
- - -
instanceA valid instance of the right type.
-
-
- -

Definition at line 62 of file bus.hpp.

- -
-
-
The documentation for this class was generated from the following file: -
- -
-Generated by   -doxygen - 1.8.13 -
- - diff --git a/classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4__coll__graph.map b/classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4__coll__graph.map deleted file mode 100644 index 47d468410..000000000 --- a/classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4__coll__graph.map +++ /dev/null @@ -1,4 +0,0 @@ - - - - diff --git a/classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4__coll__graph.md5 b/classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4__coll__graph.md5 deleted file mode 100644 index b128f8f11..000000000 --- a/classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4__coll__graph.md5 +++ /dev/null @@ -1 +0,0 @@ -1a48fa2a64a80bf1b604b2ec4ccf6ac6 \ No newline at end of file diff --git a/classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4__coll__graph.png b/classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4__coll__graph.png deleted file mode 100644 index 8d4e525efb5ab4397350568c863e0ffc0d9d6462..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 7996 zcma)hbyU<*xb4s_Fdz)wf}(_U2m(X5NJ=B!5`uIN14v5?0umz9Al)S)A>AM%GITfh zaMye5y>;*XpTF&SC z_##CfMw>@<$+@Y@_-W^SP_3s@E@+g`+v5g_TGPJ-DkbMXK#OJOVD4ikjB3kVV(1bl z9E9|@(WMTfyw|;jPZ#S?-Tu-_%=-wtamDiXJjZ1U= zWEG6`_4U6k-ayI7;**lbi+dU2=^Gn1udS>E^%j>S>vZgm<4KqYDlB@J*Ve{2d#Oa; zu-3Sat$T@QjsF>!SHWeX&4d5f(S8b<+WT9vDLOiOd2=%|I5=1^R+fX@d?;ODW2%gy zy1Lrb))uLnA(+$DL<@<_%HpcZyV0JI+-=|iQt35A>&;VLSG^v~Xf`dywdadF-Is#}H)fx%$QQQR$YbNhC~jW=Iwnw+jV z`0Rd{m3{t<*%?mMIg}w(;W#IFb#u9^*Xa2qhE@dK$HylEo*OgqK>wMhrlv~2dA+i- za-y)>^&2+`Fv=D>P-EWj%8Ys zWqD6#mrC@jroo@VF)Uh>#u+*BRk!MN(I-}0S6BHlC4Si8;9zuEc(~HFc>URe*L{fI z%a<=h{=BJYE-fzZxHv|QHokR+QB#}$8_V}PKVSBHZ7ntsv z2^nejdHcok)5Cc|$7a&J6N;9OuEK8Ok?Z-N zffOEo{;o7WYe-*V%clKS)j!;#_un09Bz@0#1fAw_B}|^m0tcBLZ%zpNo|O*@dhf5w z>gnsZx3xh`{Ek0()t88tyuTdFSLP8A=&rG!O21C)Q@tL%64hmW_1(#`%4*0wEiG+p zxAoSlwzk$`qF8&i6;fqAY!wz3_L!eP3C(mkThe)QLRwRklz@ongFbef(^AWjl9H01 zt1GXvqM{kt_Tbc%?xqAPSy@RbH9ei003Y96JzK)^@^shwqo{|ubWVBu`9hO-qPLe9 z4;dL*^2d))j`;ZC8d|k zu&(X#2{6x%$2^Uq@Z{TdCbkNzIhQEiaGi1l~9^)*RKLq3pO^ktu7=P^fF!>QFEEb zZwrlzjD+6OPbBDquc^=8uP}sGbTpWF=qh(+i4!=kDNMf(7^`;+YQBqm?!WYF@ zHdlMW{p{JZWPmu2Y>xq1Sy>esnGh^&>_{3bMMXR^Bs`k8r+;8zCPxM_9YM;H`t943 zIgn%__{Hk1(2Avi+mDV54IgHvr_0qoidOXX^+>Cif*kBWq=7YKYpBP@IZC#rpWs#9s&@QO0}M``Em_0{$1(o>5Bd0=wc1hk@{z$&E2 z+|-m&Vz2e~hLbcxoW^$H<`ZC#TFU_nD?7VK9@$^Me1ZO1TYJ5}zTVT|{;%VKS|-Ph zW$`t^#>z^&(|q0NYg*}?I9WM4!HwbKZ*>hYwq4`@bCqQ+XZQ0?{7x@m1;XTBx{^@z(6uI{sd0 zd}~d~Wf<4M#laEbcea9fO6IyyYkYc`co)MjB_$3|OOva&XT1!*#nu5IDkv*sd{x}y zc>Fji^<}=lq`Lj+_;^>P<-p$Fij26=iAqzGXWamx_U-`?BuyQi@Vz~kwY9aj&Q1)n z2P)4&;zz%Kzu!aS%*e!qHdShrxIvaE#|mxl?#6n%Gas+#V-`|ftmyw>ny0g#- z9k@CFo2@Ic)FUh=#v&?8?dt04h5Gj0)X9mtjQ_K$>wvlj;SJU1%s#kn+T`kd)nHTYRxQ@29B?|zV(9T zB_t%g_LkAWnuv#51*TwcL+_jw6_JAnQIy=}&Px($mXN-oAz3xGdvD&n*#o@pFkeU7 z{O&loqJsD6_!tecva-U##pOiu3x~lsuoFSd!p@H4?d`pMc&?$P6;e|pz-8PN0qBpB zjSVX~Ia#mV6wPU&f$f+UL~MC|9h;q=4K`mTxy3_hnc6~q+yhh zpg%u9uXFzg_4V`XMxAcYAtTZa9y!UH|tnCiZ}f1 z%nO7bgGD|jRDrbva25$EDH;n)p4IlNctGfLf-SDULf= zZS8Kk_tf3M9)M`6w2A`6?WaY@@W@Df8c}x+Wfc{2=idNXz*{qcXc*J~eigDU2CVgw zT3K23j89C=e3A;8{*lO@pJf6}nX9nC;S&}fL z4%ZjQCAqoMc3S|DgZ=%H|28+Dg42%zpc1T*?{9T{cVL$_h(CLlR$A&567aJxuVpg| zi8RZTdv6Z1*^=9&C5g&Mi@e4@c-CvK*0sm3K?eAJCXPuawYFA}M%;_%ay`QtoB?Tr z!&*8adjH;1M@J{RBE7$VXvlHj zb@qkZ#ZJkm*{V$`+x+E%wPHZyS zmE+mUZfi(kG5%0{NPA-EUe3uQUfv4Tn8Xhs^2Z&U8a`uoprŸ>Alp4Pt;d%#C3 zCL&T}NvouuGTfV9YNXi>gN8~QazByPWQh%BdXkuw^f}3K{-r8WUQLbJx16ByNc^q2 z#uQW>E@Uxa>4XuVasP7Hb!drUdB5%V;pp%pz4K58LSnZGW8`q7&%T%(-*vYOZ+^Cw zVfgm?yA@M5aV!Dlh-DkZDTD>WLCTp_eDEeTnie_MB+k>*rmG!RRE+=bnNLU00-cPZ z;is8;zA3W=PiDzybZ>KW_pJ3`kCc^zZmsBke=RoO+nPyT-W~RcSd&bOxIefQA20mf z?!Lx%126HtTa=JswlJyl6TQGJ=hh+3P4XQT-IYvW*r_CR_QYw21agy`zlHduG`vgC^5! z^Tvf+l==q~6UWd1M(l9PtiM-rF|64fOU~~`1Vb7hYwcpEUvBL6)oHh`@?{&Vs6GTt&Y6Ex8ONLl zFKO#3(Pydg3GV%!^S3X4<8Y^u7A{K;jm1H!O9c66OAsaSnrPqm>y6IgdW_*^TZT-RG zl$ZAulU_^M;Gf-Ri_g4Q0SgR$$xVt;+B*?tg!N1uo$0;UzD=~ECZ`{{7 zl*W?b+S(B&jTCQV=|ZlBmf8#$ZOVrd*IvIiYK>V@PIe(-^1h!GA%@-)M?w-9N+-ti zt{Xr4EKo9DV+bSj(wew|tVdy)E{A@-r<6-3*^ z0=yDz#kAEE=3hRE6zIc(+vb@}~7c0&Z*fbp3GeXrF} z@Q>y8RJ!}Jigg&d@Odc@DjrC%R$-f#W_$b>t$3f^yUC|q*dO7u{~hiPwEe}yBHq+q zL^Z~%!MxMv-ryOg<<3tyI7lMm_MkE$q3#~CDVV15?SHy|{U4I}?N*#fET-*kQLG-` z%T`|`U$$TPc$GD;?O!!Qcb8>R)-hZiqxS@;$(6DQ+-c{T;2bBXyWLT-nOnBQxB{*P zoUm~$w!(?L<_4lr5fS7c^7DmjY)I*i8pFRxNo_bg4|^zlCK_pusRRH#8Q{*DYZkk6 z{n-yPYWot?eti7BLrJam$_m-r`&K(MjC*+0-&3@G*6c^a zKEIGNl_x(0GqbP&A##j{RzL?D0~kip(fA1oc@Fo?HavHKdMGHd|L(t^X;=Z>Z=(q|+>0(XjnlkCM`bi5O z(H23m5a)R#eqF%=-SCfy*ayvJs|V-NyW@^94^&)sa=5F%KP0x-!)Dvq+l&2eyYu0z~VPIeIAPwdRM1&@ln6pNWtC`=09z{m-xL$g0b~*&*4ytt3HRLwr z=2}IU*NaRskz&ahk--b1Idxs$-1xc&9I8?q9H$@bEXhZI0)QJ3}PcA>a%82gks{+bJpB>(!i);xe1gnhX*_>bIu>$ zl(;IY-7_~d(mc5m0jv_VPvh(YG8U1vD}?A9GG%ACp{8CP&z0pE815Z^<};$Gm53^z zRWVjl0_kdGgsb*3*eRC&Zi$DREDxR}U;oWMv;9fCak@j)yXRs6#D-^ z;=tUczks38G?^cK3+e5&ady7*=W2l}$IqWVIJc((+jb=tfY-a~>ZQ)Ms4~?v0|A@f zEy1ywuEEnALl=^mNH%5GH$g%~G>zJ1-Z*zlLc$FZzZ@twH&Y7=5g6y^97Uz;qO|q7 zCO+L`{#@!wg9WM?b@!xNU?J*0zH3kmy+!)p$t$3@iin9>7bSc_%w~>tEO9KGpd*dc z+aD1&m&RRzvHiF4x+fqvExuHsDdG_n z?5T78%}9d#sh}X7T|MhLBgrz5X`V>vTpyMy(_gapBcK%t{lMT{*(eek8qS(|!^XF} za;G~B?JyZ*V|vf+*|4^@=Oy;P3q7}HYY2ei5|*9KprWD@7at!4J|U;1v^YQbGcr0F z6h+%=XXLZ!_{Rf*_<<-@pg@x=12?=XJ;WKQ0 zcb|ZgD>N(&3v?!Cj*jmw2a=gU2MqaCSct$Ppy=E7s`+blJ7Hk_-CyDIIXEDTN=xNz zY&fijvxsnTaKKSXrmd|Fv2)5RGpr8|BcL?j9RGq#OpF70Y}^Ec@VJ4x$`ayru!ih% z^t!I(_mwc2e=<6LS!UcE3Hm{^)h?uqtE-f+uW#NZ*P}<$va(_09zXzzh>DT{O|DlO zXiu40Sn}yFQ%wBZ=j+{gE&It!^eWJiNTh1kD>uLMKPl5y*0FV<$HM{}GHmsy3-sNL za(@h}i@>5Hj@Oo!X26}(^=|Ati_K9ZBO3b`pm8<_`J>n5#e0udIB<2<{0g)=kigVb z7{o>c+phFNr_A_C72){N5a=rNN=gWUW;OlYnc;y->d5QCKY#x09Ug|{<*|UBt*ozy zJGWlz*yXA!Dz?`;&MmL3pyg(HCA9&pC zM*>?!L_}alM#kAy#@CZ3R4c^v>TJKx_q@_;4zyd(RaJ?=%z}{fams&s9Heg{);}}b zt+V~GEi5cj)6&|1{UZDE6gA2K9^e6pms;hat4_*Uh;Oyv^I;^N@sWQqr>>7m&HH&k|Zc96jSexE60(1-|JAe1UCEYUbO1;xdYU}9r;%+69<4`+o{RaK1#WYJ0b(`IF5!2}&(M@L7d z_V!WrZhr+)d|v_e_V;y^{H<)n^Dy!N5c*G7=?r= z`K$)x^a_AKZ)P@Ht^2+d74=#Vx!Su+vpe= zq-10v0Bm{&2GWcqrW+$Ubsi{+mYWOvecb3E3>-mf8Ch8@C=|K}ROrr*4s;3%io0CX z(}MwBo!VVQ-1`6%bokH#6;)M}%O;eTu5Pc`Zd1rW3U?>yT=DSmaPja+%l=ljM3{r} z4Gl&`)xNZ3k_iiyW;!@L>_*v_bs1zdG>8HzmlR06ccSmX?AN6RBP`Is!@=T{rA7oj zFfOBpQ0=ceOoD=U>hhgN`%&!eNNYgA(dL9Qv*rXl6j|ty0fNF;U z`T0={F*Y`a&HK%u27iBlzi)V09*AORz7j9BwMWZLBr!2DO%KGcsseE_cK} z7ZfNx!%I}1_y$|<>( zmC!u-*zlAT-Mrm@liz6W(i5oWt4IHS5%oV;t=vC7rDRXIu!QJUzDAx|OJo!C@$sEq zT!8*f%EW|$o}PZX*++<(nYsM+52#`N8!QN*Wo!lphON2p#5XrL8#7hxK&Qg=@bK8b z0Xb1&-i`m*u#N=4E(nk=xF9k$Hy>LDT;)qbK@kqj68FD?$;rvVgq&#S7Zzw7#2jb& zA#KExSAp~MhCrP$Tj>a!Zt&oQv@I<$2nq_0jEyCnpWg{%c9)+4Z}NI>>0N;ergOT& zf~_`Q-cLYCZA@aMYY)G`)79 zI-rT=l$9-w#l4z9b)BQiT04e^V;_X;@{9{e%@WbavZvhqIy!Q9n5o19YHm?cQQP(9 zDah4F^xJ^#zwIf)Y$RP13N)uMHAR2^{CW34I1!D;%a@@b_1b~<25t$kA%Nu*f8%Bp zHg_qegPSuBI*IJqJMvy^@-{?B<3g0WJ`(}aXnDCkq|W>BL1k6dXrVeo)8$U1i>GJu z%!H}6_0)!*k+dij6hhyM0iOcGs0+B2016l>EiEA>C8c4V3)dfm>3Npw7;S+ zrG;g5yFP1&ArLYkdT3~9%h#v;YsSs*%)pgPs@PkupP3>UG&D5n`q3N$4WNp61fqoQgSjn3<_H5r^v9~+b949?i zJ}mGo4$?#&7IOUkt8=&1j0|NXXD6o^pvC>j)PKy&OWNMvu2*G6baz|;brWLq?xYeN zE?(Z=Kg6Bf@(T+)XJ)9tGhQICqfTTMEbeCeHJ*YE00d`_A3O%T85tRAYus%ifUMSs zXQVd|0{R9wG7|j!{08K$;JQFsTKZE?PSCK#B_V36O#aQAr+!qyeRRiQro6m741ns- z`T6aWleO&^)z$of_4<7SwjaMfZWKsQZ!Q6q!4tejDMDbVi-$)yxDa#Q7-71r8G!zW zsHmuzkC92DVKW~q-rC+KrKgV(TJqIm&e3`Kl93tQeFi;W_d&5Q8>kK$Pg4JqrywV1 z1S}#hB)cHOi);IEGoA699q=~?2S?!d??MTQiTh{!7I)=?v9a+Tqa{7m>YAI(##2ky zO=~W>A+%KefHIF}5)q*SCt25OcNCDjNno%D?$#?PxR@M@{1CSe8Y6=bfXV^B3Bb?R zOcf3gc6)EGFU_2tiA_vQAPIa?0tmnW4W8SPfC0>BDlGv>3kPQguCA}y*5#av4X5rb z-CLH5rW2z8;R4x$sA~)*@y?x@A}1VbDG)CH`c-UR>#5C&KsQ{sE3|K9G=WFcFew6$ zDb(VBGxAS`27`?LEs80vK$8P6F_nv@e-C0`+Q}GN&2$mTcc)ig{I}_fAu(=rK+)u= by2Z&g7hQsBBxQi>aEPL;8oX56H26ONPHJT& diff --git a/classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4__inherit__graph.map b/classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4__inherit__graph.map deleted file mode 100644 index 47d468410..000000000 --- a/classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4__inherit__graph.map +++ /dev/null @@ -1,4 +0,0 @@ - - - - diff --git a/classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4__inherit__graph.md5 b/classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4__inherit__graph.md5 deleted file mode 100644 index b846fd401..000000000 --- a/classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4__inherit__graph.md5 +++ /dev/null @@ -1 +0,0 @@ -6abf3444cc953a32a60abb551d58b392 \ No newline at end of file diff --git a/classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4__inherit__graph.png b/classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4__inherit__graph.png deleted file mode 100644 index 8d4e525efb5ab4397350568c863e0ffc0d9d6462..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 7996 zcma)hbyU<*xb4s_Fdz)wf}(_U2m(X5NJ=B!5`uIN14v5?0umz9Al)S)A>AM%GITfh zaMye5y>;*XpTF&SC z_##CfMw>@<$+@Y@_-W^SP_3s@E@+g`+v5g_TGPJ-DkbMXK#OJOVD4ikjB3kVV(1bl z9E9|@(WMTfyw|;jPZ#S?-Tu-_%=-wtamDiXJjZ1U= zWEG6`_4U6k-ayI7;**lbi+dU2=^Gn1udS>E^%j>S>vZgm<4KqYDlB@J*Ve{2d#Oa; zu-3Sat$T@QjsF>!SHWeX&4d5f(S8b<+WT9vDLOiOd2=%|I5=1^R+fX@d?;ODW2%gy zy1Lrb))uLnA(+$DL<@<_%HpcZyV0JI+-=|iQt35A>&;VLSG^v~Xf`dywdadF-Is#}H)fx%$QQQR$YbNhC~jW=Iwnw+jV z`0Rd{m3{t<*%?mMIg}w(;W#IFb#u9^*Xa2qhE@dK$HylEo*OgqK>wMhrlv~2dA+i- za-y)>^&2+`Fv=D>P-EWj%8Ys zWqD6#mrC@jroo@VF)Uh>#u+*BRk!MN(I-}0S6BHlC4Si8;9zuEc(~HFc>URe*L{fI z%a<=h{=BJYE-fzZxHv|QHokR+QB#}$8_V}PKVSBHZ7ntsv z2^nejdHcok)5Cc|$7a&J6N;9OuEK8Ok?Z-N zffOEo{;o7WYe-*V%clKS)j!;#_un09Bz@0#1fAw_B}|^m0tcBLZ%zpNo|O*@dhf5w z>gnsZx3xh`{Ek0()t88tyuTdFSLP8A=&rG!O21C)Q@tL%64hmW_1(#`%4*0wEiG+p zxAoSlwzk$`qF8&i6;fqAY!wz3_L!eP3C(mkThe)QLRwRklz@ongFbef(^AWjl9H01 zt1GXvqM{kt_Tbc%?xqAPSy@RbH9ei003Y96JzK)^@^shwqo{|ubWVBu`9hO-qPLe9 z4;dL*^2d))j`;ZC8d|k zu&(X#2{6x%$2^Uq@Z{TdCbkNzIhQEiaGi1l~9^)*RKLq3pO^ktu7=P^fF!>QFEEb zZwrlzjD+6OPbBDquc^=8uP}sGbTpWF=qh(+i4!=kDNMf(7^`;+YQBqm?!WYF@ zHdlMW{p{JZWPmu2Y>xq1Sy>esnGh^&>_{3bMMXR^Bs`k8r+;8zCPxM_9YM;H`t943 zIgn%__{Hk1(2Avi+mDV54IgHvr_0qoidOXX^+>Cif*kBWq=7YKYpBP@IZC#rpWs#9s&@QO0}M``Em_0{$1(o>5Bd0=wc1hk@{z$&E2 z+|-m&Vz2e~hLbcxoW^$H<`ZC#TFU_nD?7VK9@$^Me1ZO1TYJ5}zTVT|{;%VKS|-Ph zW$`t^#>z^&(|q0NYg*}?I9WM4!HwbKZ*>hYwq4`@bCqQ+XZQ0?{7x@m1;XTBx{^@z(6uI{sd0 zd}~d~Wf<4M#laEbcea9fO6IyyYkYc`co)MjB_$3|OOva&XT1!*#nu5IDkv*sd{x}y zc>Fji^<}=lq`Lj+_;^>P<-p$Fij26=iAqzGXWamx_U-`?BuyQi@Vz~kwY9aj&Q1)n z2P)4&;zz%Kzu!aS%*e!qHdShrxIvaE#|mxl?#6n%Gas+#V-`|ftmyw>ny0g#- z9k@CFo2@Ic)FUh=#v&?8?dt04h5Gj0)X9mtjQ_K$>wvlj;SJU1%s#kn+T`kd)nHTYRxQ@29B?|zV(9T zB_t%g_LkAWnuv#51*TwcL+_jw6_JAnQIy=}&Px($mXN-oAz3xGdvD&n*#o@pFkeU7 z{O&loqJsD6_!tecva-U##pOiu3x~lsuoFSd!p@H4?d`pMc&?$P6;e|pz-8PN0qBpB zjSVX~Ia#mV6wPU&f$f+UL~MC|9h;q=4K`mTxy3_hnc6~q+yhh zpg%u9uXFzg_4V`XMxAcYAtTZa9y!UH|tnCiZ}f1 z%nO7bgGD|jRDrbva25$EDH;n)p4IlNctGfLf-SDULf= zZS8Kk_tf3M9)M`6w2A`6?WaY@@W@Df8c}x+Wfc{2=idNXz*{qcXc*J~eigDU2CVgw zT3K23j89C=e3A;8{*lO@pJf6}nX9nC;S&}fL z4%ZjQCAqoMc3S|DgZ=%H|28+Dg42%zpc1T*?{9T{cVL$_h(CLlR$A&567aJxuVpg| zi8RZTdv6Z1*^=9&C5g&Mi@e4@c-CvK*0sm3K?eAJCXPuawYFA}M%;_%ay`QtoB?Tr z!&*8adjH;1M@J{RBE7$VXvlHj zb@qkZ#ZJkm*{V$`+x+E%wPHZyS zmE+mUZfi(kG5%0{NPA-EUe3uQUfv4Tn8Xhs^2Z&U8a`uoprŸ>Alp4Pt;d%#C3 zCL&T}NvouuGTfV9YNXi>gN8~QazByPWQh%BdXkuw^f}3K{-r8WUQLbJx16ByNc^q2 z#uQW>E@Uxa>4XuVasP7Hb!drUdB5%V;pp%pz4K58LSnZGW8`q7&%T%(-*vYOZ+^Cw zVfgm?yA@M5aV!Dlh-DkZDTD>WLCTp_eDEeTnie_MB+k>*rmG!RRE+=bnNLU00-cPZ z;is8;zA3W=PiDzybZ>KW_pJ3`kCc^zZmsBke=RoO+nPyT-W~RcSd&bOxIefQA20mf z?!Lx%126HtTa=JswlJyl6TQGJ=hh+3P4XQT-IYvW*r_CR_QYw21agy`zlHduG`vgC^5! z^Tvf+l==q~6UWd1M(l9PtiM-rF|64fOU~~`1Vb7hYwcpEUvBL6)oHh`@?{&Vs6GTt&Y6Ex8ONLl zFKO#3(Pydg3GV%!^S3X4<8Y^u7A{K;jm1H!O9c66OAsaSnrPqm>y6IgdW_*^TZT-RG zl$ZAulU_^M;Gf-Ri_g4Q0SgR$$xVt;+B*?tg!N1uo$0;UzD=~ECZ`{{7 zl*W?b+S(B&jTCQV=|ZlBmf8#$ZOVrd*IvIiYK>V@PIe(-^1h!GA%@-)M?w-9N+-ti zt{Xr4EKo9DV+bSj(wew|tVdy)E{A@-r<6-3*^ z0=yDz#kAEE=3hRE6zIc(+vb@}~7c0&Z*fbp3GeXrF} z@Q>y8RJ!}Jigg&d@Odc@DjrC%R$-f#W_$b>t$3f^yUC|q*dO7u{~hiPwEe}yBHq+q zL^Z~%!MxMv-ryOg<<3tyI7lMm_MkE$q3#~CDVV15?SHy|{U4I}?N*#fET-*kQLG-` z%T`|`U$$TPc$GD;?O!!Qcb8>R)-hZiqxS@;$(6DQ+-c{T;2bBXyWLT-nOnBQxB{*P zoUm~$w!(?L<_4lr5fS7c^7DmjY)I*i8pFRxNo_bg4|^zlCK_pusRRH#8Q{*DYZkk6 z{n-yPYWot?eti7BLrJam$_m-r`&K(MjC*+0-&3@G*6c^a zKEIGNl_x(0GqbP&A##j{RzL?D0~kip(fA1oc@Fo?HavHKdMGHd|L(t^X;=Z>Z=(q|+>0(XjnlkCM`bi5O z(H23m5a)R#eqF%=-SCfy*ayvJs|V-NyW@^94^&)sa=5F%KP0x-!)Dvq+l&2eyYu0z~VPIeIAPwdRM1&@ln6pNWtC`=09z{m-xL$g0b~*&*4ytt3HRLwr z=2}IU*NaRskz&ahk--b1Idxs$-1xc&9I8?q9H$@bEXhZI0)QJ3}PcA>a%82gks{+bJpB>(!i);xe1gnhX*_>bIu>$ zl(;IY-7_~d(mc5m0jv_VPvh(YG8U1vD}?A9GG%ACp{8CP&z0pE815Z^<};$Gm53^z zRWVjl0_kdGgsb*3*eRC&Zi$DREDxR}U;oWMv;9fCak@j)yXRs6#D-^ z;=tUczks38G?^cK3+e5&ady7*=W2l}$IqWVIJc((+jb=tfY-a~>ZQ)Ms4~?v0|A@f zEy1ywuEEnALl=^mNH%5GH$g%~G>zJ1-Z*zlLc$FZzZ@twH&Y7=5g6y^97Uz;qO|q7 zCO+L`{#@!wg9WM?b@!xNU?J*0zH3kmy+!)p$t$3@iin9>7bSc_%w~>tEO9KGpd*dc z+aD1&m&RRzvHiF4x+fqvExuHsDdG_n z?5T78%}9d#sh}X7T|MhLBgrz5X`V>vTpyMy(_gapBcK%t{lMT{*(eek8qS(|!^XF} za;G~B?JyZ*V|vf+*|4^@=Oy;P3q7}HYY2ei5|*9KprWD@7at!4J|U;1v^YQbGcr0F z6h+%=XXLZ!_{Rf*_<<-@pg@x=12?=XJ;WKQ0 zcb|ZgD>N(&3v?!Cj*jmw2a=gU2MqaCSct$Ppy=E7s`+blJ7Hk_-CyDIIXEDTN=xNz zY&fijvxsnTaKKSXrmd|Fv2)5RGpr8|BcL?j9RGq#OpF70Y}^Ec@VJ4x$`ayru!ih% z^t!I(_mwc2e=<6LS!UcE3Hm{^)h?uqtE-f+uW#NZ*P}<$va(_09zXzzh>DT{O|DlO zXiu40Sn}yFQ%wBZ=j+{gE&It!^eWJiNTh1kD>uLMKPl5y*0FV<$HM{}GHmsy3-sNL za(@h}i@>5Hj@Oo!X26}(^=|Ati_K9ZBO3b`pm8<_`J>n5#e0udIB<2<{0g)=kigVb z7{o>c+phFNr_A_C72){N5a=rNN=gWUW;OlYnc;y->d5QCKY#x09Ug|{<*|UBt*ozy zJGWlz*yXA!Dz?`;&MmL3pyg(HCA9&pC zM*>?!L_}alM#kAy#@CZ3R4c^v>TJKx_q@_;4zyd(RaJ?=%z}{fams&s9Heg{);}}b zt+V~GEi5cj)6&|1{UZDE6gA2K9^e6pms;hat4_*Uh;Oyv^I;^N@sWQqr>>7m&HH&k|Zc96jSexE60(1-|JAe1UCEYUbO1;xdYU}9r;%+69<4`+o{RaK1#WYJ0b(`IF5!2}&(M@L7d z_V!WrZhr+)d|v_e_V;y^{H<)n^Dy!N5c*G7=?r= z`K$)x^a_AKZ)P@Ht^2+d74=#Vx!Su+vpe= zq-10v0Bm{&2GWcqrW+$Ubsi{+mYWOvecb3E3>-mf8Ch8@C=|K}ROrr*4s;3%io0CX z(}MwBo!VVQ-1`6%bokH#6;)M}%O;eTu5Pc`Zd1rW3U?>yT=DSmaPja+%l=ljM3{r} z4Gl&`)xNZ3k_iiyW;!@L>_*v_bs1zdG>8HzmlR06ccSmX?AN6RBP`Is!@=T{rA7oj zFfOBpQ0=ceOoD=U>hhgN`%&!eNNYgA(dL9Qv*rXl6j|ty0fNF;U z`T0={F*Y`a&HK%u27iBlzi)V09*AORz7j9BwMWZLBr!2DO%KGcsseE_cK} z7ZfNx!%I}1_y$|<>( zmC!u-*zlAT-Mrm@liz6W(i5oWt4IHS5%oV;t=vC7rDRXIu!QJUzDAx|OJo!C@$sEq zT!8*f%EW|$o}PZX*++<(nYsM+52#`N8!QN*Wo!lphON2p#5XrL8#7hxK&Qg=@bK8b z0Xb1&-i`m*u#N=4E(nk=xF9k$Hy>LDT;)qbK@kqj68FD?$;rvVgq&#S7Zzw7#2jb& zA#KExSAp~MhCrP$Tj>a!Zt&oQv@I<$2nq_0jEyCnpWg{%c9)+4Z}NI>>0N;ergOT& zf~_`Q-cLYCZA@aMYY)G`)79 zI-rT=l$9-w#l4z9b)BQiT04e^V;_X;@{9{e%@WbavZvhqIy!Q9n5o19YHm?cQQP(9 zDah4F^xJ^#zwIf)Y$RP13N)uMHAR2^{CW34I1!D;%a@@b_1b~<25t$kA%Nu*f8%Bp zHg_qegPSuBI*IJqJMvy^@-{?B<3g0WJ`(}aXnDCkq|W>BL1k6dXrVeo)8$U1i>GJu z%!H}6_0)!*k+dij6hhyM0iOcGs0+B2016l>EiEA>C8c4V3)dfm>3Npw7;S+ zrG;g5yFP1&ArLYkdT3~9%h#v;YsSs*%)pgPs@PkupP3>UG&D5n`q3N$4WNp61fqoQgSjn3<_H5r^v9~+b949?i zJ}mGo4$?#&7IOUkt8=&1j0|NXXD6o^pvC>j)PKy&OWNMvu2*G6baz|;brWLq?xYeN zE?(Z=Kg6Bf@(T+)XJ)9tGhQICqfTTMEbeCeHJ*YE00d`_A3O%T85tRAYus%ifUMSs zXQVd|0{R9wG7|j!{08K$;JQFsTKZE?PSCK#B_V36O#aQAr+!qyeRRiQro6m741ns- z`T6aWleO&^)z$of_4<7SwjaMfZWKsQZ!Q6q!4tejDMDbVi-$)yxDa#Q7-71r8G!zW zsHmuzkC92DVKW~q-rC+KrKgV(TJqIm&e3`Kl93tQeFi;W_d&5Q8>kK$Pg4JqrywV1 z1S}#hB)cHOi);IEGoA699q=~?2S?!d??MTQiTh{!7I)=?v9a+Tqa{7m>YAI(##2ky zO=~W>A+%KefHIF}5)q*SCt25OcNCDjNno%D?$#?PxR@M@{1CSe8Y6=bfXV^B3Bb?R zOcf3gc6)EGFU_2tiA_vQAPIa?0tmnW4W8SPfC0>BDlGv>3kPQguCA}y*5#av4X5rb z-CLH5rW2z8;R4x$sA~)*@y?x@A}1VbDG)CH`c-UR>#5C&KsQ{sE3|K9G=WFcFew6$ zDb(VBGxAS`27`?LEs80vK$8P6F_nv@e-C0`+Q}GN&2$mTcc)ig{I}_fAu(=rK+)u= by2Z&g7hQsBBxQi>aEPL;8oX56H26ONPHJT& diff --git a/classentt_1_1Bus_3_01Sig_00_01Event_01_4.html b/classentt_1_1Bus_3_01Sig_00_01Event_01_4.html deleted file mode 100644 index 058b32218..000000000 --- a/classentt_1_1Bus_3_01Sig_00_01Event_01_4.html +++ /dev/null @@ -1,437 +0,0 @@ - - - - - - - -entt: entt::Bus< Sig, Event > Class Template Reference - - - - - - - - - -
-
- - - - - - -
-
entt -  2.5.0 -
-
-
- - - - - - - - -
-
- - -
- -
- - -
-
-
-Public Types | -Public Member Functions | -List of all members
-
-
entt::Bus< Sig, Event > Class Template Reference
-
-
- -

Event bus specialization for a single type. - More...

- -

#include <bus.hpp>

-
-Inheritance diagram for entt::Bus< Sig, Event >:
-
-
Inheritance graph
- - - -
[legend]
- - - - - -

-Public Types

-using size_type = typename signal_type::size_type
 Unsigned integer type.
 
- - - - - - - - - - - - - - - - - - - - - - - - - - - -

-Public Member Functions

template<typename Class >
void unreg (instance_type< Class > instance)
 Unregisters member functions of instances. More...
 
template<typename Class >
void reg (instance_type< Class > instance)
 Tries to register an instance. More...
 
size_type size () const noexcept
 Number of listeners connected to the bus. More...
 
bool empty () const noexcept
 Returns false if at least a listener is connected to the bus. More...
 
template<void(*)(const Event &) Function>
void connect ()
 Connects a free function to the bus. More...
 
template<void(*)(const Event &) Function>
void disconnect ()
 Disconnects a free function from the bus. More...
 
template<typename... Args>
void publish (Args &&... args)
 Publishes an event. More...
 
-

Detailed Description

-

template<template< typename... > class Sig, typename Event>
-class entt::Bus< Sig, Event >

- -

Event bus specialization for a single type.

-

The event bus is designed to allow an easy registration of a specific member function to a signal handler (either manager or unmanaged). Classes must publicly expose the required member function to allow the bus to detect it for the purpose of registering and unregistering instances.
- In particular, a matching member function has the following signature: void receive(const Event &). Events of the given type will be properly redirected to all the listeners by calling the right member function, if any.

-
Template Parameters
- - - -
SigType of signal handler to use.
EventType of event managed by the bus.
-
-
- -

Definition at line 166 of file bus.hpp.

-

Member Function Documentation

- -

◆ connect()

- -
-
-
-template<template< typename... > class Sig, typename Event >
-
-template<void(*)(const Event &) Function>
- - - - - -
- - - - - - - -
void entt::Bus< Sig, Event >::connect ()
- 		-inline
-
- -

Connects a free function to the bus.

-
Template Parameters
- - -
FunctionA valid free function pointer.
-
-
- -

Definition at line 244 of file bus.hpp.

- -
-
- -

◆ disconnect()

- -
-
-
-template<template< typename... > class Sig, typename Event >
-
-template<void(*)(const Event &) Function>
- - - - - -
- - - - - - - -
void entt::Bus< Sig, Event >::disconnect ()
- 		-inline
-
- -

Disconnects a free function from the bus.

-
Template Parameters
- - -
FunctionA valid free function pointer.
-
-
- -

Definition at line 253 of file bus.hpp.

- -
-
- -

◆ empty()

- -
-
-
-template<template< typename... > class Sig, typename Event >
- - - - - -
- - - - - - - -
bool entt::Bus< Sig, Event >::empty () const
- 		-inlinenoexcept
-
- -

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 235 of file bus.hpp.

- -
-
- -

◆ publish()

- -
-
-
-template<template< typename... > class Sig, typename Event >
-
-template<typename... Args>
- - - - - -
- - - - - - - - -
void entt::Bus< Sig, Event >::publish (Args &&... args)
- 		-inline
-
- -

Publishes an event.

-

All the listeners are notified. Order isn't guaranteed.

-
Template Parameters
- - -
ArgsTypes of arguments to use to construct the event.
-
-
-
Parameters
- - -
argsArguments to use to construct the event.
-
-
- -

Definition at line 266 of file bus.hpp.

- -
-
- -

◆ reg()

- -
-
-
-template<template< typename... > class Sig, typename Event >
-
-template<typename Class >
- - - - - -
- - - - - - - - -
void entt::Bus< Sig, Event >::reg (instance_type< Class > instance)
- 		-inline
-
- -

Tries to register an instance.

-

This method tries to detect and register to the bus matching member functions of instances.
- A matching member function has the following signature: void receive(const Event &).

-
Template Parameters
- - -
ClassType of instance to register.
-
-
-
Parameters
- - -
instanceA valid instance of the right type.
-
-
- -

Definition at line 219 of file bus.hpp.

- -
-
- -

◆ size()

- -
-
-
-template<template< typename... > class Sig, typename Event >
- - - - - -
- - - - - - - -
size_type entt::Bus< Sig, Event >::size () const
- 		-inlinenoexcept
-
- -

Number of listeners connected to the bus.

-
Returns
Number of listeners currently connected.
- -

Definition at line 227 of file bus.hpp.

- -
-
- -

◆ unreg()

- -
-
-
-template<template< typename... > class Sig, typename Event >
-
-template<typename Class >
- - - - - -
- - - - - - - - -
void entt::Bus< Sig, Event >::unreg (instance_type< Class > instance)
- 		-inline
-
- -

Unregisters member functions of instances.

-

This method tries to detect and unregister from the bus matching member functions of instances.
- A matching member function has the following signature: void receive(const Event &).

-
Template Parameters
- - -
ClassType of instance to unregister.
-
-
-
Parameters
- - -
instanceA valid instance of the right type.
-
-
- -

Definition at line 203 of file bus.hpp.

- -
-
-
The documentation for this class was generated from the following file: -
- -
-Generated by   -doxygen - 1.8.13 -
- - diff --git a/classentt_1_1Bus_3_01Sig_00_01Event_01_4__inherit__graph.map b/classentt_1_1Bus_3_01Sig_00_01Event_01_4__inherit__graph.map deleted file mode 100644 index ef729ea80..000000000 --- a/classentt_1_1Bus_3_01Sig_00_01Event_01_4__inherit__graph.map +++ /dev/null @@ -1,3 +0,0 @@ - - - diff --git a/classentt_1_1Bus_3_01Sig_00_01Event_01_4__inherit__graph.md5 b/classentt_1_1Bus_3_01Sig_00_01Event_01_4__inherit__graph.md5 deleted file mode 100644 index 96369f8fd..000000000 --- a/classentt_1_1Bus_3_01Sig_00_01Event_01_4__inherit__graph.md5 +++ /dev/null @@ -1 +0,0 @@ -015e8f239749a52a3698605734c6d9b7 \ No newline at end of file diff --git a/classentt_1_1Bus_3_01Sig_00_01Event_01_4__inherit__graph.png b/classentt_1_1Bus_3_01Sig_00_01Event_01_4__inherit__graph.png deleted file mode 100644 index 70d4e5194ebd1eadb09abd903f5dcdafbeea0ccf..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 5281 zcmd5=g;!M3w;nnKVGv1a1Vms2>6A`ILO_s~?vNS~BnN2`K?NyEhm;=Lp%DS;Zei$d zc!#&%`mOi=gEzBg?zwl}d-l2e?EUTU+mX+oDU%Y@5knvlQdJcNZE*Yneu0Ge;6Gkj zfEgU{E!342AlEnFjE1~K2!v8kRY6wQCv`IouB-dvyrbzcVW%QZ3;!ddcf?`T?1H}y zw@Y-<w`7N?%*cT3?(X_ro&JNPAK+*6T3K0j_VtYz z=CX|F$;rvp^)TVfbN=f~lee|a9}%dsu_DCh&tcn4WjG>^f&zxz;+SxD$E z#LUVntSyRqf5ddXW?0Ajzb7<7PfSfkcXq1urb$pgw&_EU6d7ec=YmwcD%aN5E`8la zQNP#yaI66?0x=sew}J$Td92u0V$E$$qqvhL-x#e2p)H(m_0Q~5!%WawicyaO&OCkK za5gcq(|1liuLT4J1#NkMR#YfxYg5?U+t*0y>+9bWb$#M6D|2~phl=kNBH8pUEtCHa z*5Kga1jE-xf3SlmN0TmMU>RmBy`N8(lT9HzKTR-_w$3NP)Mf2$ZJDK|aY8#O#eN8Uk1Mz-uN_dx0CZ<(5!I$xX(iaQ_T zLUi(;wVm$&tF5D@rG3QD-||;ehBPSsP@5A5BQr5E8LRc+1iLRTNEI-zi0p`C>VR)I z5ESSVD=RDW7}rt0eEIU#sY6Kv{;gZLG}5IRAkU4Bi}X<|D=R7dmf_FnAv6B_PwNi` z)xjyge?UM&Vq$i(L6X{iv;{vUF<$TQ-@AkAu=&-2Y+xLCLP&^3OpLbY6YsC~7!^>M6I5{za4T+A9K3RPh7I1!K-WksV2?`I#M|X5A z{vwl6aCAf}O;_EqadwVHAPCvn*_k;w@ca7uc6N7L#>y;rCtaH6dtgmV-*_ZXmlDYi zGBY!=3JMB*=EJDxmX>fiIXQ3Q5j-Q|wb5TwKidGOj*X4w_Pu@kb{b=~cy4a4&sOa} z*Q*O(QBl#GJVAMFE_9W`$gzhLPA1*Vd27_(Vr|QSWiq$jIFJ0GiSO# zHf!tnPn-Ge?Km`AL4}+4aZ^ulu>JqFjob0VY?By2}$a;EKw2wso zIkXQ$#Dga?GMIUcsz}swC;(!fTv=Sp@||AaQwS z-kxs~Fk0H!L}+CznfIlNiF$3Mgp*eAsQCDZii~4~Av~syspr)OJmJ~dY@lQ?Q$(6M zIg!f9$T-e6GL)5-88rHf0Z@cMI5;>62??L*>Qc7;`n9{79mgsvYOu^RH#ZkVCVc_{ z=-aZp*Z~EQ{`9M``OaJm-69dVUqge$YilYpD~ok(V#1>P;{$_Ivv*3<`lbPQAv=eo zrXDuw_tig{ZBA4|f_8RXYies-rlwx~yQpOFHZnZ!ygWPnwf{#Z?r)x^LnwT&%mi}- z^=@u%DMAiZ!NI}(B}~_GJBpYlXDOc@W&nnxKW0NcsaUb0Z%ze1fBO~->dOyD96sZ^ zP-B!A@blZ|rLM$;loUb-hxOvRDN8{Sk$rc~K|0p_<@V^yx=J>L0;|cGRCS)2zDIMvX$w@SjBrVP8?wi5%6P>TsHY8V| z8ovRN&ghwa%xv!%YNtkw$$KVL@i2I4qSB%6mTF8*jVN}rHs{~JD=P;~aJayoDAKK{ z_(ZDP_Vq0mo-s9n*YtP=1v{^r7>lK)!@crET4v04BkPeQcx!7xDxn)EKJuu)>t+_q z3G~XbPuQt&6u7#36`qPH_8z}TG4Ne7^q1_PB7u<8($0r}GSE}{XKt}f^zyB=T8YVW zR#<*5?YN=zWap}+22#@PvJ;xr$;R3$Gd`Ywu@1xW8%BYNBY_RU>+OHNMKrYZi|q+) z_tI?8dR+uJRQ*8l}{6BZGgpU9MF&M7Boz@$AY^GYCa!ZJ*l zMMY#qM>7I*t>_87kHmPzocCqNr%2dzbZ9<*k#n@bE{i0xp}*YDn;sq4%jhYcHGA{! ztdLvd`FTUY_~ClZ)$H}c^-v?(q$%r~>Zsp+9?W|i_gKcZf$G`tKrOIwYfh#455rym zL!SPh3~Y}dZxWC(qU(M4{aTYvTAo{4YE+a4sjv%x$dOAYD_y@7!CP2Zs9Vx7wJgqL zASbl5vl}b7iZXd~NVPsy>v%>x9nxrF1^?f~@aEmZP44R@sC@qbN&#I=Im75u5QlQYJe3r*Xb3nL{;pl{%*YgQ zoafrw!3zr(sgk}F)h@F)Ebr9w1xycV@UFL415~%U?WSubfGi(Ad?*E!1rnsd+S0)k z*lQG6w5X>!t!Oivr~X_5-PV@CI9#XU>|CrSgQ=2+WB{Z{s{i87A!&`VNO+ z5Y}{&^}&0-70>Ttx5IZ^eX<7iwGSC5ES^ykGVN~tf{T)ngamCFCxuT>PhWq&g|c;Y z#O-(Q68ArO1PVAyf(khm6+Xmg<+BY0a&&ZL==5ZNu;5S5P-iEhu&}TnLwZUIg5R>e zxwn_(R|HwdOaq*0%*)qT41>W`d{Skn*qExl^Ww#eS2ImlhcEyI$_}#tJ7}c*1d&MO zBj3H(7blBx^~UWszrWxG1_t&yJ38JF+E^x;+khltpgy|N9U$S?0669a2V>W{FB8|I zP>D@VGSJFYyp_H*buc?6Ev+hK71;Jmdub&=tEi-esle)A?ny4l%?&U7@#6s}X9OVj z8Z0a zo|7{GN@my8RH}7vimXwUV`gisTu}gEXMg)M<=6hD2j=eWxr@KSPy(*FCbjL~ni8gSrB5h>Z8vJt$O2 zNXRYuQDYSrrmMUA{odYQMb-Gor>@sSO@V>$5r{clLmeG?wVV$K1ZI8R?$0+VLAM13 zcW>{!?Z)%iJ0W}@)$U)Ot(R1IZ5q0Jc(8#t5_g>oQkpF;F0Kf?ewzd?SW2+#8Al>i z_>vQIa_(DMTT?(2l9QYL+mAq$ZS;~yQp@1uMv9V@z=#`i}1=;l4&Q7)3 zd3vGy#Gs_lVn=E{o<%(^VLf@KyK60fbTy{a{sdQ8UB+uK`e(MAjcis1TUpDcNH z3P3d%H}}FGaE_L~e#A7&JG-KS^6lHVI|m1$8XO_I+-;o+Yzbe!yjM@=E7*{)%+%$c z-`tG(pHXurEhfK>X@W9&Q zQ&Xegzb8(Wf>VLWf8`4>Wox$Sy4lx3Vymj)E+A!q@38>LilXAx7W-6kIN0%ruVvBh zOLk-9x0%4}fbyR|vu{u&81GiiCBqQk%c3f|%na2;js##Inh^eU=xUKS-?$raciWAz zvX7rWwGRVD#Ny!K;I|OTxe5}8yJLH@I_@3=L)XyIN2M4#MdjFg1LBQ^h1?VMzK>&Q z_=ETM_bW%VxG2F#!LmJ?W}E)_5xqwdO2yc)QWslL-q8E52vhXR~tjxt<+3VM#rKOLyHp%5B0^I4DlY5}#3{YOY$13XdtO23rPOvwl+M_OfdD|#Y--EXkQ>yjsfb-)z!5b=)St8^N_6iGwc90Bp`KdZEda| z9)AtDR#w94MVwtr=s=(2MRy#d)O#e72MF(*5_r5djRSEUE5!m*Spl?a_+HfnRa6K9 zf4X;sMMPMFuS^JJarZyk*SCYzS|Ch zFET4HKmat?xGj1z%DnC*hx8M^=i}lE0vhTVm1p-imqkV<{b3;RtnW@E9vlwGB_LQV zX}St7DS@@NwgTxC46uIY%*S9&#{v(+#KZ(NnQVb>;Zo1CJJP87w#Q2EfG@JR^YSR` z)7jzTwR9DLobmB-E*>7Vj;0hI2<4e`pRrXB3sPcYIXk-tVE0_XQkPa%So!&(cQ`bf z^R=>fMvPqC-VC!fdk!Sz-#_g9ezZ|V4*igr$PYhql-%!q{G2*!Qn@8 zNpN_FRG3+QQBh8u^ckW(npPfws-WM2?HT4r31}R}A}W;qWt9)030wL1jp3%oo3=kE zKg7pBN#uB%b$NcQ11iBN=K@Ox8(a@M5Yi+xcGlJ7RmkrL36mS(H6oTD#0p@*cuYcA z{!WHYX#Jn&+kd)n{~5?`6L>dl{;D9EA1F3R4>)>xBvML4hPT=1Z1sqdVr*USf3d_> kg1Pw2G_yws%$L_#)l#}jb#x9>pyvotReYvUEN2${UsL!O-2eap diff --git a/classentt_1_1ContinuousLoader-members.html b/classentt_1_1ContinuousLoader-members.html index bdae424b0..3f1e81744 100644 --- a/classentt_1_1ContinuousLoader-members.html +++ b/classentt_1_1ContinuousLoader-members.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -70,22 +70,20 @@ $(function() {

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

- - - - - - - - - - - - - - - - + + + + + + + + + + + + + +
component(Archive &archive)entt::ContinuousLoader< Entity >inline
component(Archive &archive, Type Component::*... member)entt::ContinuousLoader< Entity >inline
ContinuousLoader(Registry< entity_type > &registry) noexceptentt::ContinuousLoader< Entity >inline
ContinuousLoader(const ContinuousLoader &)=defaultentt::ContinuousLoader< Entity >
ContinuousLoader(ContinuousLoader &&)=defaultentt::ContinuousLoader< Entity >
destroyed(Archive &archive)entt::ContinuousLoader< Entity >inline
entities(Archive &archive)entt::ContinuousLoader< Entity >inline
entity_type typedefentt::ContinuousLoader< Entity >
has(entity_type entity)entt::ContinuousLoader< Entity >inline
map(entity_type entity)entt::ContinuousLoader< Entity >inline
operator=(const ContinuousLoader &)=defaultentt::ContinuousLoader< Entity >
operator=(ContinuousLoader &&)=defaultentt::ContinuousLoader< Entity >
orphans()entt::ContinuousLoader< Entity >inline
shrink()entt::ContinuousLoader< Entity >inline
tag(Archive &archive)entt::ContinuousLoader< Entity >inline
tag(Archive &archive, Type Tag::*... member)entt::ContinuousLoader< Entity >inline
component(Archive &archive, Member Type::*... member)entt::ContinuousLoader< Entity >inline
ContinuousLoader(Registry< entity_type > &registry) ENTT_NOEXCEPTentt::ContinuousLoader< Entity >inline
ContinuousLoader(const ContinuousLoader &)=deleteentt::ContinuousLoader< Entity >
ContinuousLoader(ContinuousLoader &&)=defaultentt::ContinuousLoader< Entity >
destroyed(Archive &archive)entt::ContinuousLoader< Entity >inline
entities(Archive &archive)entt::ContinuousLoader< Entity >inline
entity_type typedefentt::ContinuousLoader< Entity >
has(entity_type entity)entt::ContinuousLoader< Entity >inline
map(entity_type entity)entt::ContinuousLoader< Entity >inline
operator=(const ContinuousLoader &)=deleteentt::ContinuousLoader< Entity >
operator=(ContinuousLoader &&)=defaultentt::ContinuousLoader< Entity >
orphans()entt::ContinuousLoader< Entity >inline
shrink()entt::ContinuousLoader< Entity >inline
tag(Archive &archive, Member Type::*... member)entt::ContinuousLoader< Entity >inline
diff --git a/classentt_1_1ContinuousLoader.html b/classentt_1_1ContinuousLoader.html index 8e858f67d..fdf50ae1f 100644 --- a/classentt_1_1ContinuousLoader.html +++ b/classentt_1_1ContinuousLoader.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -86,20 +86,20 @@ using 

Public Member Functions

- ContinuousLoader (Registry< entity_type > &registry) noexcept - Constructs a loader that is bound to a given registry. More...
-  - - ContinuousLoader (const ContinuousLoader &)=default - Default copy constructor.
-  + ContinuousLoader (Registry< entity_type > &registry) ENTT_NOEXCEPT + Constructs a loader that is bound to a given registry. More...
+  + + ContinuousLoader (const ContinuousLoader &)=delete + Copying a snapshot loader isn't allowed.
+   ContinuousLoader (ContinuousLoader &&)=default  Default move constructor.
  -ContinuousLoader & operator= (const ContinuousLoader &)=default - Default copy assignment operator. More...
-  +ContinuousLoader & operator= (const ContinuousLoader &)=delete + Copying a snapshot loader isn't allowed. More...
+  ContinuousLoader & operator= (ContinuousLoader &&)=default  Default move assignment operator. More...
  @@ -111,22 +111,14 @@ Public Member Functions ContinuousLoader & destroyed (Archive &archive)  Restores entities that were destroyed during serialization. More...
  -template<typename... Component, typename Archive > -ContinuousLoader & component (Archive &archive) - Restores components and assigns them to the right entities. More...
-  -template<typename Component , typename Archive , typename... Type> -ContinuousLoader & component (Archive &archive, Type Component::*... member) - Restores components and assigns them to the right entities. More...
-  -template<typename... Tag, typename Archive > -ContinuousLoader & tag (Archive &archive) - Restores tags and assigns them to the right entities. More...
-  -template<typename Tag , typename Archive , typename... Type> -ContinuousLoader & tag (Archive &archive, Type Tag::*... member) - Restores tags and assigns them to the right entities. More...
-  +template<typename... Component, typename Archive , typename... Type, typename... Member> +ContinuousLoader & component (Archive &archive, Member Type::*... member) + Restores components and assigns them to the right entities. More...
+  +template<typename... Tag, typename Archive , typename... Type, typename... Member> +ContinuousLoader & tag (Archive &archive, Member Type::*... member) + Restores tags and assigns them to the right entities. More...
+  ContinuousLoader & shrink ()  Helps to purge entities that no longer have a conterpart. More...
  @@ -155,10 +147,10 @@ class entt::ContinuousLoader< Entity > -

Definition at line 364 of file snapshot.hpp.

+

Definition at line 430 of file snapshot.hpp.

Constructor & Destructor Documentation

- -

◆ ContinuousLoader()

+ +

◆ ContinuousLoader()

@@ -178,7 +170,7 @@ template<typename Entity >
-inlinenoexcept +inline
@@ -191,69 +183,20 @@ template<typename Entity >
-

Definition at line 494 of file snapshot.hpp.

+

Definition at line 529 of file snapshot.hpp.

Member Function Documentation

- -

◆ component() [1/2]

+ +

◆ component()

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

Restores components and assigns them to the right entities.

-

The template parameter list must be exactly the same used during serialization. In the event that the entity to which the component is assigned doesn't exist yet, the loader will take care to create a local counterpart for it.

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

Definition at line 554 of file snapshot.hpp.

- -
-
- -

◆ component() [2/2]

- -
-
-
-template<typename Entity >
-
-template<typename Component , typename Archive , typename... Type>
+template<typename... Component, typename Archive , typename... Type, typename... Member>
- + @@ -290,7 +233,8 @@ template<typename Component , typename Archive , typename... Type>
@@ -267,7 +210,7 @@ template<typename Component , typename Archive , typename... Type>
Type Component::*... Member Type::*...  member 
- + +
ComponentType of component to restore.
ArchiveType of input archive.
TypeTypes of members to update with their local counterparts.
TypeTypes of components to update with local counterparts.
MemberTypes of members to update with their local counterparts.
@@ -303,7 +247,7 @@ template<typename Component , typename Archive , typename... Type>
Returns
A non-const reference to this loader.
-

Definition at line 580 of file snapshot.hpp.

+

Definition at line 595 of file snapshot.hpp.

@@ -351,7 +295,7 @@ template<typename Archive >
Returns
A non-const reference to this loader.
-

Definition at line 535 of file snapshot.hpp.

+

Definition at line 570 of file snapshot.hpp.

@@ -399,7 +343,7 @@ template<typename Archive >
Returns
A non-const reference to this loader.
-

Definition at line 519 of file snapshot.hpp.

+

Definition at line 554 of file snapshot.hpp.

@@ -438,7 +382,7 @@ template<typename Entity >
Returns
True if entity is managed by the loader, false otherwise.
-

Definition at line 683 of file snapshot.hpp.

+

Definition at line 690 of file snapshot.hpp.

@@ -479,12 +423,12 @@ template<typename Entity >
Returns
The identifier to which entity refers in the target registry.
-

Definition at line 699 of file snapshot.hpp.

+

Definition at line 706 of file snapshot.hpp.

- -

◆ operator=() [1/2]

+ +

◆ operator=() [1/2]

@@ -504,12 +448,12 @@ template<typename Entity >
-default +delete
-

Default copy assignment operator.

+

Copying a snapshot loader isn't allowed.

Returns
This loader.
@@ -575,7 +519,7 @@ template<typename Entity > This functions helps to identify and destroy those entities.

Returns
A non-const reference to this loader.
-

Definition at line 670 of file snapshot.hpp.

+

Definition at line 677 of file snapshot.hpp.

@@ -608,68 +552,19 @@ template<typename Entity >

Users should invoke this member function after restoring each snapshot, unless they know exactly what they are doing.

Returns
A non-const reference to this loader.
-

Definition at line 638 of file snapshot.hpp.

+

Definition at line 645 of file snapshot.hpp.

- -

◆ tag() [1/2]

+ +

◆ tag()

template<typename Entity >
-template<typename... Tag, typename Archive >
- - - - - -
- - - - - - - - -
ContinuousLoader& entt::ContinuousLoader< Entity >::tag (Archive & archive)
- 		-inline
-
- -

Restores tags and assigns them to the right entities.

-

The template parameter list must be exactly the same used during serialization. In the event that the entity to which the tag is assigned doesn't exist yet, the loader will take care to create a local counterpart for it.

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

Definition at line 599 of file snapshot.hpp.

- -
-
- -

◆ tag() [2/2]

- -
-
-
-template<typename Entity >
-
-template<typename Tag , typename Archive , typename... Type>
+template<typename... Tag, typename Archive , typename... Type, typename... Member>
- + @@ -706,7 +601,8 @@ template<typename Tag , typename Archive , typename... Type>
@@ -683,7 +578,7 @@ template<typename Tag , typename Archive , typename... Type>
Type Tag::*... Member Type::*...  member 
- + +
TagType of tag to restore.
ArchiveType of input archive.
TypeTypes of members to update with their local counterparts.
TypeTypes of components to update with local counterparts.
MemberTypes of members to update with their local counterparts.
@@ -719,7 +615,7 @@ template<typename Tag , typename Archive , typename... Type>
Returns
A non-const reference to this loader.
-

Definition at line 625 of file snapshot.hpp.

+

Definition at line 626 of file snapshot.hpp.

diff --git a/classentt_1_1Delegate.html b/classentt_1_1Delegate.html index dcae77683..39bcc1ab5 100644 --- a/classentt_1_1Delegate.html +++ b/classentt_1_1Delegate.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -79,7 +79,7 @@ class entt::Delegate< typename >

Basic delegate implementation.

Primary template isn't defined on purpose. All the specializations give a compile-time error unless the template parameter is a function type.

-

Definition at line 18 of file delegate.hpp.

+

Definition at line 19 of file delegate.hpp.

The documentation for this class was generated from the following file: diff --git a/classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4-members.html b/classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4-members.html index 7f3ed212b..f65450c1f 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.5.0 +  2.6.0
@@ -70,12 +70,12 @@ $(function() {

This is the complete list of members for entt::Delegate< Ret(Args...)>, including all inherited members.

- - - + + + - - + +
connect() noexceptentt::Delegate< Ret(Args...)>inline
connect(Class *instance) noexceptentt::Delegate< Ret(Args...)>inline
Delegate() noexceptentt::Delegate< Ret(Args...)>inline
connect() ENTT_NOEXCEPTentt::Delegate< Ret(Args...)>inline
connect(Class *instance) ENTT_NOEXCEPTentt::Delegate< Ret(Args...)>inline
Delegate() ENTT_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
operator==(const Delegate< Ret(Args...)> &other) const ENTT_NOEXCEPTentt::Delegate< Ret(Args...)>inline
reset() ENTT_NOEXCEPTentt::Delegate< Ret(Args...)>inline
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 07a263dda..2f862fcaf 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 @@
entt -  2.5.0 +  2.6.0
@@ -78,27 +78,27 @@ $(function() { - - - - - - - - - - - - - - + + + + + + + + + + + + + + - - - + + +

Public Member Functions

- Delegate () noexcept
 Default constructor.
 
template<Ret(*)(Args...) Function>
void connect () noexcept
 Binds a free function to a delegate. More...
 
template<typename Class , Ret(Class::*)(Args...) Member>
void connect (Class *instance) noexcept
 Connects a member function for a given instance to a delegate. More...
 
void reset () noexcept
 Resets a delegate. More...
 
+ Delegate () ENTT_NOEXCEPT
 Default constructor.
 
template<Ret(*)(Args...) Function>
void connect () ENTT_NOEXCEPT
 Binds a free function to a delegate. More...
 
template<typename Class , Ret(Class::*)(Args...) Member>
void connect (Class *instance) ENTT_NOEXCEPT
 Connects a member function for a given instance to a delegate. More...
 
void reset () ENTT_NOEXCEPT
 Resets a delegate. More...
 
Ret operator() (Args... args)
 Triggers a delegate. More...
 
bool operator== (const Delegate< Ret(Args...)> &other) const noexcept
 Checks if the contents of the two delegates are different. More...
 
bool operator== (const Delegate< Ret(Args...)> &other) const ENTT_NOEXCEPT
 Checks if the contents of the two delegates are different. More...
 

Detailed Description

template<typename Ret, typename... Args>
@@ -115,10 +115,10 @@ class entt::Delegate< Ret(Args...)>

-

Definition at line 35 of file delegate.hpp.

+

Definition at line 36 of file delegate.hpp.

Member Function Documentation

- -

◆ connect() [1/2]

+ +

◆ connect() [1/2]

@@ -139,7 +139,7 @@ template<Ret(*)(Args...) Function>
-inlinenoexcept +inline
@@ -152,12 +152,12 @@ template<Ret(*)(Args...) Function>
-

Definition at line 62 of file delegate.hpp.

+

Definition at line 63 of file delegate.hpp.

- -

◆ connect() [2/2]

+ +

◆ connect() [2/2]

@@ -179,7 +179,7 @@ template<typename Class , Ret(Class::*)(Args...) Member>
-inlinenoexcept +inline
@@ -200,7 +200,7 @@ template<typename Class , Ret(Class::*)(Args...) Member>
-

Definition at line 78 of file delegate.hpp.

+

Definition at line 79 of file delegate.hpp.

@@ -239,12 +239,12 @@ template<typename Ret , typename... Args>
Returns
The value returned by the underlying function.
-

Definition at line 96 of file delegate.hpp.

+

Definition at line 97 of file delegate.hpp.

- -

◆ operator==()

+ +

◆ operator==()

@@ -264,7 +264,7 @@ template<typename Ret , typename... Args>
-inlinenoexcept +inline
@@ -279,12 +279,12 @@ template<typename Ret , typename... Args>
Returns
True if the two delegates are identical, false otherwise.
-

Definition at line 108 of file delegate.hpp.

+

Definition at line 109 of file delegate.hpp.

- -

◆ reset()

+ +

◆ reset()

@@ -303,7 +303,7 @@ template<typename Ret , typename... Args>
-inlinenoexcept +inline
@@ -311,7 +311,7 @@ template<typename Ret , typename... Args>

Resets a delegate.

After a reset, a delegate can be safely invoked with no effect.

-

Definition at line 87 of file delegate.hpp.

+

Definition at line 88 of file delegate.hpp.

diff --git a/classentt_1_1Dispatcher-members.html b/classentt_1_1Dispatcher-members.html index f3b0e4f56..2d2035fd0 100644 --- a/classentt_1_1Dispatcher-members.html +++ b/classentt_1_1Dispatcher-members.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -64,18 +64,18 @@ $(function() {
-
entt::Dispatcher< Sig > Member List
+
entt::Dispatcher Member List
-

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

+

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

- - - - - - + + + + + +
connect(instance_type< Class, Event > instance) noexceptentt::Dispatcher< Sig >inline
disconnect(instance_type< Class, Event > instance) noexceptentt::Dispatcher< Sig >inline
Dispatcher() noexceptentt::Dispatcher< Sig >inline
enqueue(Args &&... args)entt::Dispatcher< Sig >inline
trigger(Args &&... args)entt::Dispatcher< Sig >inline
update()entt::Dispatcher< Sig >inline
enqueue(Args &&... args)entt::Dispatcherinline
sink() ENTT_NOEXCEPTentt::Dispatcherinline
sink_type typedefentt::Dispatcher
trigger(Args &&... args)entt::Dispatcherinline
update()entt::Dispatcherinline
update()entt::Dispatcherinline
diff --git a/classentt_1_1Dispatcher.html b/classentt_1_1Dispatcher.html index c6933ce4e..1e659dfd3 100644 --- a/classentt_1_1Dispatcher.html +++ b/classentt_1_1Dispatcher.html @@ -5,7 +5,7 @@ -entt: entt::Dispatcher< Sig > Class Template Reference +entt: entt::Dispatcher Class Reference @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -65,10 +65,11 @@ $(function() {
Classes | +Public Types | Public Member Functions | List of all members
-
entt::Dispatcher< Sig > Class Template Referencefinal
+
entt::Dispatcher Class Referencefinal
@@ -77,163 +78,56 @@ $(function() {

#include <dispatcher.hpp>

+ + + + + +

+Public Types

+template<typename Event >
using sink_type = typename SignalWrapper< Event >::sink_type
 Type of sink for the given event.
 
- - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + +

Public Member Functions

- Dispatcher () noexcept
 Default constructor.
 
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...
 
template<typename Event , typename Class , void(Class::*)(const Event &) Member = &Class::receive>
void disconnect (instance_type< Class, Event > instance) noexcept
 Unregisters a listener given in the form of a member function. More...
 
template<typename Event , typename... Args>
void trigger (Args &&... args)
 Triggers an immediate event of the given type. More...
 
template<typename Event , typename... Args>
void enqueue (Args &&... args)
 Enqueues an event of the given type. More...
 
void update ()
 Delivers all the pending events. More...
 
template<typename Event >
sink_type< Event > sink () ENTT_NOEXCEPT
 Returns a sink object for the given event. More...
 
template<typename Event , typename... Args>
void trigger (Args &&... args)
 Triggers an immediate event of the given type. More...
 
template<typename Event , typename... Args>
void enqueue (Args &&... args)
 Enqueues an event of the given type. More...
 
template<typename Event >
void update ()
 Delivers all the pending events of the given type. More...
 
void update ()
 Delivers all the pending events. More...
 

Detailed Description

-

template<template< typename... > class Sig>
-class entt::Dispatcher< Sig >

- -

Basic dispatcher implementation.

+

Basic dispatcher implementation.

A dispatcher can be used either to trigger an immediate event or to enqueue events to be published all together once per tick.
- Listeners are provided in the form of member functions. For each event of type Event, listeners must have the following signature: void(const Event &). Member functions named receive are automatically detected and registered or unregistered by the dispatcher.

-
Template Parameters
- - -
SigType of the signal handler to use.
-
-
+ Listeners are provided in the form of member functions. For each event of type Event, listeners must have the following function type:

void(const Event &)

Member functions named receive are automatically detected and registered or unregistered by the dispatcher. The type of the instances is Class * (a naked pointer). It means that users must guarantee that the lifetimes of the instances overcome the one of the dispatcher itself to avoid crashes.

-

Definition at line 30 of file dispatcher.hpp.

+

Definition at line 35 of file dispatcher.hpp.

Member Function Documentation

- -

◆ connect()

+ +

◆ enqueue()

-template<template< typename... > class Sig>
-
-template<typename Event , typename Class , void(Class::*)(const Event &) Member = &Class::receive>
- - - - - -
- - - - - - - - -
void entt::Dispatcher< Sig >::connect (instance_type< Class, Event > instance)
- 		-inlinenoexcept
-
- -

Registers a listener given in the form of a member function.

-

A matching member function has the following signature: void receive(const Event &). Member functions named receive are automatically detected and registered if available.

-
Warning
Connecting a listener during an update may lead to unexpected behavior. Register listeners before or after invoking the update if possible.
-
Template Parameters
- - - - -
EventType of event to which to connect the function.
ClassType of class to which the member function belongs.
MemberMember function to connect to the signal.
-
-
-
Parameters
- - -
instanceA valid instance of the right type.
-
-
- -

Definition at line 118 of file dispatcher.hpp.

- -
-
- -

◆ disconnect()

- -
-
-
-template<template< typename... > class Sig>
-
-template<typename Event , typename Class , void(Class::*)(const Event &) Member = &Class::receive>
- - - - - -
- - - - - - - - -
void entt::Dispatcher< Sig >::disconnect (instance_type< Class, Event > instance)
- 		-inlinenoexcept
-
- -

Unregisters a listener given in the form of a member function.

-

A matching member function has the following signature: void receive(const Event &). Member functions named receive are automatically detected and unregistered if available.

-
Warning
Disconnecting a listener during an update may lead to unexpected behavior. Unregister listeners before or after invoking the update if possible.
-
Template Parameters
- - - - -
EventType of event from which to disconnect the function.
ClassType of class to which the member function belongs.
MemberMember function to connect to the signal.
-
-
-
Parameters
- - -
instanceA valid instance of the right type.
-
-
- -

Definition at line 140 of file dispatcher.hpp.

- -
-
- -

◆ enqueue()

- -
-
-
-template<template< typename... > class Sig>
-
template<typename Event , typename... Args>
- + @@ -263,17 +157,56 @@ template<typename Event , typename... Args> -

Definition at line 170 of file dispatcher.hpp.

+

Definition at line 145 of file dispatcher.hpp.

- -

◆ trigger()

+ +

◆ sink()

-template<template< typename... > class Sig>
+template<typename Event >
+
void entt::Dispatcher< Sig >::enqueue void entt::Dispatcher::enqueue ( Args &&...  args)
+ + + + +
+ + + + + + + +
sink_type<Event> entt::Dispatcher::sink ()
+ 		+inline
+
+ +

Returns a sink object for the given event.

+

A sink is an opaque object used to connect listeners to events.

+

The function type for a listener is:

void(const Event &)

The order of invocation of the listeners isn't guaranteed.

+
See also
SigH::Sink
+
Template Parameters
+ + +
EventType of event of which to get the sink.
+
+
+
Returns
A temporary sink object.
+ +

Definition at line 115 of file dispatcher.hpp.

+ +
+ + +

◆ trigger()

+ +
+
template<typename Event , typename... Args>
@@ -281,7 +214,7 @@ template<typename Event , typename... Args> +inline
- + @@ -311,23 +244,59 @@ template<typename Event , typename... Args> -

Definition at line 155 of file dispatcher.hpp.

+

Definition at line 130 of file dispatcher.hpp.

- -

◆ update()

+ +

◆ update() [1/2]

-template<template< typename... > class Sig>
+template<typename Event >
void entt::Dispatcher< Sig >::trigger void entt::Dispatcher::trigger ( Args &&...  args)
+ + +
- + + + + + +
void entt::Dispatcher< Sig >::update void entt::Dispatcher::update ()
+ 		+inline
+
+ +

Delivers all the pending events of the given type.

+

This method is blocking and it doesn't return until all the events are delivered to the registered listeners. It's responsibility of the users to reduce at a minimum the time spent in the bodies of the listeners.

+
Template Parameters
+ + +
EventType of events to send.
+
+
+ +

Definition at line 159 of file dispatcher.hpp.

+ +
+ + +

◆ update() [2/2]

+ +
+
+ + + @@ -89,19 +89,19 @@ Public Types - +
+ + + @@ -341,9 +310,9 @@ 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.

+

This method is blocking and it doesn't return until all the events are delivered to the registered listeners. It's responsibility of the users to reduce at a minimum the time spent in the bodies of the listeners.

-

Definition at line 181 of file dispatcher.hpp.

+

Definition at line 170 of file dispatcher.hpp.

diff --git a/classentt_1_1Emitter-members.html b/classentt_1_1Emitter-members.html index bd9febe8a..36853b8e3 100644 --- a/classentt_1_1Emitter-members.html +++ b/classentt_1_1Emitter-members.html @@ -22,7 +22,7 @@ @@ -70,21 +70,21 @@ $(function() {

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

void entt::Dispatcher::update ( )
entt -  2.5.0 +  2.6.0
- - - + + + - - - + + + - +
clear() noexceptentt::Emitter< Derived >inline
clear() noexceptentt::Emitter< Derived >inline
Emitter() noexcept=defaultentt::Emitter< Derived >
clear() ENTT_NOEXCEPTentt::Emitter< Derived >inline
clear() ENTT_NOEXCEPTentt::Emitter< Derived >inline
Emitter() ENTT_NOEXCEPT=defaultentt::Emitter< Derived >
Emitter(const Emitter &)=deleteentt::Emitter< Derived >
Emitter(Emitter &&)=defaultentt::Emitter< Derived >
empty() const noexceptentt::Emitter< Derived >inline
empty() const noexceptentt::Emitter< Derived >inline
erase(Connection< Event > conn) noexceptentt::Emitter< Derived >inline
empty() const ENTT_NOEXCEPTentt::Emitter< Derived >inline
empty() const ENTT_NOEXCEPTentt::Emitter< Derived >inline
erase(Connection< Event > conn) ENTT_NOEXCEPTentt::Emitter< Derived >inline
Listener typedefentt::Emitter< Derived >
on(Listener< Event > listener)entt::Emitter< Derived >inline
once(Listener< Event > listener)entt::Emitter< Derived >inline
operator=(const Emitter &)=deleteentt::Emitter< Derived >
operator=(Emitter &&)=defaultentt::Emitter< Derived >
publish(Args &&... args)entt::Emitter< Derived >inline
~Emitter() noexceptentt::Emitter< Derived >inlinevirtual
~Emitter() ENTT_NOEXCEPTentt::Emitter< Derived >inlinevirtual
diff --git a/classentt_1_1Emitter.html b/classentt_1_1Emitter.html index e127db563..b5badfeee 100644 --- a/classentt_1_1Emitter.html +++ b/classentt_1_1Emitter.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
template<typename Event >
using Listener = typename Handler< Event >::listener_type
 Type of listeners accepted for the given type of event.
 Type of listeners accepted for the given event.
 
- - - - - - + + + + + + @@ -114,7 +114,7 @@ virtual  - + @@ -128,24 +128,24 @@ virtual  - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + +

Public Member Functions

- Emitter () noexcept=default
 Default constructor.
 
-virtual ~Emitter () noexcept
 Default destructor.
 
+ Emitter () ENTT_NOEXCEPT=default
 Default constructor.
 
+virtual ~Emitter () ENTT_NOEXCEPT
 Default destructor.
 
 Emitter (const Emitter &)=delete
 Copying an emitter isn't allowed.
 Copying an emitter isn't allowed. More...
 
Emitter & operator= (Emitter &&)=default
 Default move assignament operator. More...
 Default move assignment operator. More...
 
template<typename Event , typename... Args>
void publish (Args &&... args)
Connection< Event > once (Listener< Event > listener)
 Registers a short-lived listener with the event emitter. More...
 
template<typename Event >
void erase (Connection< Event > conn) noexcept
 Disconnects a listener from the event emitter. More...
 
template<typename Event >
void clear () noexcept
 Disconnects all the listeners for the given event type. More...
 
void clear () noexcept
 Disconnects all the listeners. More...
 
template<typename Event >
bool empty () const noexcept
 Checks if there are listeners registered for the specific event. More...
 
bool empty () const noexcept
 Checks if there are listeners registered with the event emitter. More...
 
template<typename Event >
void erase (Connection< Event > conn) ENTT_NOEXCEPT
 Disconnects a listener from the event emitter. More...
 
template<typename Event >
void clear () ENTT_NOEXCEPT
 Disconnects all the listeners for the given event type. More...
 
void clear () ENTT_NOEXCEPT
 Disconnects all the listeners. More...
 
template<typename Event >
bool empty () const ENTT_NOEXCEPT
 Checks if there are listeners registered for the specific event. More...
 
bool empty () const ENTT_NOEXCEPT
 Checks if there are listeners registered with the event emitter. More...
 

Detailed Description

template<typename Derived>
@@ -153,7 +153,7 @@ class entt::Emitter< Derived >

General purpose event emitter.

The emitter class template follows the CRTP idiom. To create a custom emitter type, derived classes must inherit directly from the base class as:

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

Handlers for the type of events are created internally on the fly. It's not required to specify in advance the full list of accepted types.
+

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

Handlers for the type of events are created internally on the fly. It's not required to specify in advance the full list of accepted types.
Moreover, whenever an event is published, an emitter provides the listeners with a reference to itself along with a const reference to the event. Therefore listeners have an handy way to work with it without incurring in the need of capturing a reference to the emitter.

Template Parameters
@@ -162,10 +162,10 @@ class entt::Emitter< Derived > -

Definition at line 40 of file emitter.hpp.

+

Definition at line 41 of file emitter.hpp.

Member Function Documentation

- -

◆ clear() [1/2]

+ +

◆ clear() [1/2]

@@ -186,7 +186,7 @@ template<typename Event >
-inlinenoexcept
@@ -200,12 +200,12 @@ template<typename Event >
-

Definition at line 295 of file emitter.hpp.

+

Definition at line 296 of file emitter.hpp.

- -

◆ clear() [2/2]

+ +

◆ clear() [2/2]

@@ -224,7 +224,7 @@ template<typename Derived >
-inlinenoexcept +inline
@@ -232,12 +232,12 @@ template<typename Derived >

Disconnects all the listeners.

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

-

Definition at line 305 of file emitter.hpp.

+

Definition at line 306 of file emitter.hpp.

- -

◆ empty() [1/2]

+ +

◆ empty() [1/2]

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

Definition at line 316 of file emitter.hpp.

+

Definition at line 317 of file emitter.hpp.

- -

◆ empty() [2/2]

+ +

◆ empty() [2/2]

@@ -296,7 +296,7 @@ template<typename Derived >
-inlinenoexcept +inline
@@ -304,12 +304,12 @@ template<typename Derived >

Checks if there are listeners registered with the event emitter.

Returns
True if there are no listeners registered, false otherwise.
-

Definition at line 328 of file emitter.hpp.

+

Definition at line 329 of file emitter.hpp.

- -

◆ erase()

+ +

◆ erase()

@@ -331,7 +331,7 @@ template<typename Event >
-inlinenoexcept +inline
@@ -351,7 +351,7 @@ template<typename Event >
-

Definition at line 282 of file emitter.hpp.

+

Definition at line 283 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 243 of file emitter.hpp.

+

Definition at line 244 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 268 of file emitter.hpp.

+

Definition at line 269 of file emitter.hpp.

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

Default move assignament operator.

+

Default move assignment operator.

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

Definition at line 218 of file emitter.hpp.

+

Definition at line 219 of file emitter.hpp.

diff --git a/classentt_1_1Family-members.html b/classentt_1_1Family-members.html index 52111cefa..cae56ccc3 100644 --- a/classentt_1_1Family-members.html +++ b/classentt_1_1Family-members.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -71,7 +71,7 @@ $(function() {

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

- +
family_type typedefentt::Family<... >
type() noexceptentt::Family<... >inlinestatic
type() ENTT_NOEXCEPTentt::Family<... >inlinestatic
diff --git a/classentt_1_1Family.html b/classentt_1_1Family.html index 6b436482f..b75cad7e7 100644 --- a/classentt_1_1Family.html +++ b/classentt_1_1Family.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -86,10 +86,10 @@ using 

Static Public Member Functions

-template<typename... Type> -static family_type type () noexcept - Returns an unique identifier for the given type. More...
-  +template<typename... Type> +static family_type type () ENTT_NOEXCEPT + Returns an unique identifier for the given type. More...
+ 

Detailed Description

template<typename...>
@@ -98,10 +98,10 @@ class entt::Family<... >

Dynamic identifier generator.

Utility class template that can be used to assign unique identifiers to types at runtime. Use different specializations to create separate sets of identifiers.

-

Definition at line 21 of file family.hpp.

+

Definition at line 22 of file family.hpp.

Member Function Documentation

- -

◆ type()

+ +

◆ type()

@@ -122,7 +122,7 @@ template<typename... Type>
-inlinestaticnoexcept +inlinestatic
@@ -130,7 +130,7 @@ template<typename... Type>

Returns an unique identifier for the given type.

Returns
Statically generated unique identifier for the given type.
-

Definition at line 39 of file family.hpp.

+

Definition at line 40 of file family.hpp.

diff --git a/classentt_1_1HashedString-members.html b/classentt_1_1HashedString-members.html index f51653f90..0841f5d50 100644 --- a/classentt_1_1HashedString-members.html +++ b/classentt_1_1HashedString-members.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -71,11 +71,11 @@ $(function() {

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
HashedString(const char(&str)[N]) ENTT_NOEXCEPTentt::HashedStringinline
HashedString(ConstCharWrapper wrapper) ENTT_NOEXCEPTentt::HashedStringinlineexplicit
operator const char *() const ENTT_NOEXCEPTentt::HashedStringinline
operator hash_type() const ENTT_NOEXCEPTentt::HashedStringinline
operator==(const HashedString &other) const ENTT_NOEXCEPTentt::HashedStringinline
diff --git a/classentt_1_1HashedString.html b/classentt_1_1HashedString.html index 8a8b7fcee..baf8f2fe7 100644 --- a/classentt_1_1HashedString.html +++ b/classentt_1_1HashedString.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -87,32 +87,32 @@ using 

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...
-  +template<std::size_t N> +constexpr HashedString (const char(&str)[N]) ENTT_NOEXCEPT + Constructs a hashed string from an array of const chars. More...
+  +constexpr HashedString (ConstCharWrapper wrapper) ENTT_NOEXCEPT + Explicit constructor on purpose to avoid constructing a hashed string directly from a const char *. More...
+  +constexpr operator const char * () const ENTT_NOEXCEPT + Returns the human-readable representation of a hashed string. More...
+  +constexpr operator hash_type () const ENTT_NOEXCEPT + Returns the numeric representation of a hashed string. More...
+  +constexpr bool operator== (const HashedString &other) const ENTT_NOEXCEPT + Compares two hashed strings. More...
+ 

Detailed Description

Zero overhead resource identifier.

A hashed string is a compile-time tool that allows users to use human-readable identifers in the codebase while using their numeric counterparts at runtime.
Because of that, a hashed string can also be used in constant expressions if required.

-

Definition at line 21 of file hashed_string.hpp.

+

Definition at line 22 of file hashed_string.hpp.

Constructor & Destructor Documentation

- -

◆ HashedString() [1/2]

+ +

◆ HashedString() [1/2]

@@ -132,14 +132,14 @@ template<std::size_t N>
-inlinenoexcept +inline

Constructs a hashed string from an array of const chars.

Forcing template resolution avoids implicit conversions. An human-readable identifier can be anything but a plain, old bunch of characters.
- Example of use:

HashedString sh{"my.png"};
Template Parameters
+ Example of use:

HashedString sh{"my.png"};
Template Parameters
NNumber of characters of the identifier.
@@ -152,12 +152,12 @@ template<std::size_t N>
-

Definition at line 55 of file hashed_string.hpp.

+

Definition at line 56 of file hashed_string.hpp.

- -

◆ HashedString() [2/2]

+ +

◆ HashedString() [2/2]

@@ -175,7 +175,7 @@ template<std::size_t N>
-inlineexplicitnoexcept +inlineexplicit
@@ -188,13 +188,13 @@ template<std::size_t N>
-

Definition at line 65 of file hashed_string.hpp.

+

Definition at line 66 of file hashed_string.hpp.

Member Function Documentation

- -

◆ operator const char *()

+ +

◆ operator const char *()

@@ -211,7 +211,7 @@ template<std::size_t N>
-inlinenoexcept +inline
@@ -219,12 +219,12 @@ template<std::size_t N>

Returns the human-readable representation of a hashed string.

Returns
The string used to initialize the instance.
-

Definition at line 73 of file hashed_string.hpp.

+

Definition at line 74 of file hashed_string.hpp.

- -

◆ operator hash_type()

+ +

◆ operator hash_type()

@@ -241,7 +241,7 @@ template<std::size_t N>
-inlinenoexcept +inline
@@ -249,12 +249,12 @@ template<std::size_t N>

Returns the numeric representation of a hashed string.

Returns
The numeric representation of the instance.
-

Definition at line 79 of file hashed_string.hpp.

+

Definition at line 80 of file hashed_string.hpp.

- -

◆ operator==()

+ +

◆ operator==()

@@ -272,7 +272,7 @@ template<std::size_t N>
-inlinenoexcept +inline
@@ -286,7 +286,7 @@ template<std::size_t N>
Returns
True if the two hashed strings are identical, false otherwise.
-

Definition at line 86 of file hashed_string.hpp.

+

Definition at line 87 of file hashed_string.hpp.

diff --git a/classentt_1_1PersistentView-members.html b/classentt_1_1PersistentView-members.html index 2dc654816..bee4f48a8 100644 --- a/classentt_1_1PersistentView-members.html +++ b/classentt_1_1PersistentView-members.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -70,20 +70,26 @@ $(function() {

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

- - - + + + + + + + - + + + - - - - + + + + - +
begin() const noexceptentt::PersistentView< Entity, Component >inline
contains(entity_type entity) const noexceptentt::PersistentView< Entity, Component >inline
data() const noexceptentt::PersistentView< Entity, Component >inline
begin() const ENTT_NOEXCEPTentt::PersistentView< Entity, Component >inline
begin() ENTT_NOEXCEPTentt::PersistentView< Entity, Component >inline
cbegin() const ENTT_NOEXCEPTentt::PersistentView< Entity, Component >inline
cend() const ENTT_NOEXCEPTentt::PersistentView< Entity, Component >inline
const_iterator_type typedefentt::PersistentView< Entity, Component >
contains(const entity_type entity) const ENTT_NOEXCEPTentt::PersistentView< Entity, Component >inline
data() const ENTT_NOEXCEPTentt::PersistentView< Entity, Component >inline
each(Func func) constentt::PersistentView< Entity, Component >inline
each(Func func)entt::PersistentView< Entity, Component >inline
end() const noexceptentt::PersistentView< Entity, Component >inline
empty() const ENTT_NOEXCEPTentt::PersistentView< Entity, Component >inline
end() const ENTT_NOEXCEPTentt::PersistentView< Entity, Component >inline
end() ENTT_NOEXCEPTentt::PersistentView< Entity, Component >inline
entity_type typedefentt::PersistentView< Entity, Component >
get(entity_type entity) const noexceptentt::PersistentView< Entity, Component >inline
get(entity_type entity) noexceptentt::PersistentView< Entity, Component >inline
get(entity_type entity) const noexceptentt::PersistentView< Entity, Component >inline
get(entity_type entity) noexceptentt::PersistentView< Entity, Component >inline
get(const entity_type entity) const ENTT_NOEXCEPTentt::PersistentView< Entity, Component >inline
get(const entity_type entity) ENTT_NOEXCEPTentt::PersistentView< Entity, Component >inline
get(const entity_type entity) const ENTT_NOEXCEPTentt::PersistentView< Entity, Component >inline
get(const entity_type entity) ENTT_NOEXCEPTentt::PersistentView< Entity, Component >inline
iterator_type typedefentt::PersistentView< Entity, Component >
Registry< Entity > classentt::PersistentView< Entity, Component >friend
size() const noexceptentt::PersistentView< Entity, Component >inline
size() const ENTT_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 ef5412ad6..f51f98472 100644 --- a/classentt_1_1PersistentView.html +++ b/classentt_1_1PersistentView.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -84,6 +84,10 @@ Public Types using iterator_type = typename view_type::iterator_type  Input iterator type.
  + +using const_iterator_type = typename view_type::const_iterator_type + Constant input iterator type.
+  using entity_type = typename view_type::entity_type  Underlying entity identifier.
@@ -95,37 +99,52 @@ using 

Public Member Functions

-size_type size () const noexcept - Returns the number of entities that have the given components. More...
-  -const entity_type * data () const noexcept - Direct access to the list of entities. More...
-  -iterator_type begin () const noexcept - Returns an iterator to the first entity that has the given components. More...
-  -iterator_type end () const noexcept - Returns an iterator that is past the last entity that has the given components. More...
-  -bool contains (entity_type entity) const noexcept - Checks if a view contains an entity. More...
-  -template<typename Comp > -const Comp & get (entity_type entity) const noexcept - Returns the component assigned to the given entity. More...
-  -template<typename Comp > -Comp & get (entity_type entity) noexcept - Returns the component assigned to the given entity. More...
-  -template<typename... Comp> -std::enable_if_t<(sizeof...(Comp) > 1), std::tuple< const Comp &... > > get (entity_type entity) const noexcept - Returns the components assigned to the given entity. More...
-  -template<typename... Comp> -std::enable_if_t<(sizeof...(Comp) > 1), std::tuple< Comp &... > > get (entity_type entity) noexcept - Returns the components assigned to the given entity. More...
-  +size_type size () const ENTT_NOEXCEPT + Returns the number of entities that have the given components. More...
+  +bool empty () const ENTT_NOEXCEPT + Checks whether the view is empty. More...
+  +const entity_type * data () const ENTT_NOEXCEPT + Direct access to the list of entities. More...
+  +const_iterator_type cbegin () const ENTT_NOEXCEPT + Returns an iterator to the first entity that has the given components. More...
+  +const_iterator_type begin () const ENTT_NOEXCEPT + Returns an iterator to the first entity that has the given components. More...
+  +iterator_type begin () ENTT_NOEXCEPT + Returns an iterator to the first entity that has the given components. More...
+  +const_iterator_type cend () const ENTT_NOEXCEPT + Returns an iterator that is past the last entity that has the given components. More...
+  +const_iterator_type end () const ENTT_NOEXCEPT + Returns an iterator that is past the last entity that has the given components. More...
+  +iterator_type end () ENTT_NOEXCEPT + Returns an iterator that is past the last entity that has the given components. More...
+  +bool contains (const entity_type entity) const ENTT_NOEXCEPT + Checks if a view contains an entity. More...
+  +template<typename Comp > +const Comp & get (const entity_type entity) const ENTT_NOEXCEPT + Returns the component assigned to the given entity. More...
+  +template<typename Comp > +Comp & get (const entity_type entity) ENTT_NOEXCEPT + Returns the component assigned to the given entity. More...
+  +template<typename... Comp> +std::enable_if_t<(sizeof...(Comp) > 1), std::tuple< const Comp &... > > get (const entity_type entity) const ENTT_NOEXCEPT + Returns the components assigned to the given entity. More...
+  +template<typename... Comp> +std::enable_if_t<(sizeof...(Comp) > 1), std::tuple< Comp &... > > get (const entity_type entity) ENTT_NOEXCEPT + Returns the components assigned to the given entity. More...
+  template<typename Func > void each (Func func) const  Iterates entities and components and applies the given function object to them. More...
@@ -176,10 +195,44 @@ class entt::PersistentView< Entity, Component > -

Definition at line 67 of file view.hpp.

+

Definition at line 68 of file view.hpp.

Member Function Documentation

- -

◆ begin()

+ +

◆ begin() [1/2]

+ +
+
+
+template<typename Entity , typename... Component>
+ + + + + +
+ + + + + + + +
const_iterator_type entt::PersistentView< Entity, Component >::begin () const
+ 		+inline
+
+ +

Returns an iterator to the first entity that has the given components.

+

The returned iterator points to the first entity that has the given components. If the view is empty, the returned iterator will be equal to end().

+
Note
Input iterators stay true to the order imposed to the underlying data structures.
+
Returns
An iterator to the first entity that has the given components.
+ +

Definition at line 158 of file view.hpp.

+ +
+
+ +

◆ begin() [2/2]

@@ -193,27 +246,95 @@ template<typename Entity , typename... Component>
iterator_type entt::PersistentView< Entity, Component >::begin ( ) - const + -inlinenoexcept +inline

Returns an iterator to the first entity that has the given components.

-

The returned iterator points to the first entity that has the given components. If the view is empty, the returned iterator will be equal to end().

+

The returned iterator points to the first entity that has the given components. If the view is empty, the returned iterator will be equal to end().

Note
Input iterators stay true to the order imposed to the underlying data structures.
Returns
An iterator to the first entity that has the given components.
-

Definition at line 129 of file view.hpp.

+

Definition at line 176 of file view.hpp.

- -

◆ contains()

+ +

◆ cbegin()

+ +
+
+
+template<typename Entity , typename... Component>
+ + + + + +
+ + + + + + + +
const_iterator_type entt::PersistentView< Entity, Component >::cbegin () const
+ 		+inline
+
+ +

Returns an iterator to the first entity that has the given components.

+

The returned iterator points to the first entity that has the given components. If the view is empty, the returned iterator will be equal to end().

+
Note
Input iterators stay true to the order imposed to the underlying data structures.
+
Returns
An iterator to the first entity that has the given components.
+ +

Definition at line 140 of file view.hpp.

+ +
+
+ +

◆ cend()

+ +
+
+
+template<typename Entity , typename... Component>
+ + + + + +
+ + + + + + + +
const_iterator_type entt::PersistentView< Entity, Component >::cend () const
+ 		+inline
+
+ +

Returns an iterator that is past the last entity that has the given components.

+

The returned iterator points to the entity following the last entity that has the given components. Attempting to dereference the returned iterator results in undefined behavior.

+
Note
Input iterators stay true to the order imposed to the underlying data structures.
+
Returns
An iterator to the entity following the last entity that has the given components.
+ +

Definition at line 195 of file view.hpp.

+ +
+
+ +

◆ contains()

@@ -226,14 +347,14 @@ template<typename Entity , typename... Component>
bool entt::PersistentView< Entity, Component >::contains ( - entity_type  + const entity_type  entity) const -inlinenoexcept +inline
@@ -247,12 +368,12 @@ template<typename Entity , typename... Component>
Returns
True if the view contains the given entity, false otherwise.
-

Definition at line 157 of file view.hpp.

+

Definition at line 242 of file view.hpp.

- -

◆ data()

+ +

◆ data()

@@ -271,17 +392,17 @@ template<typename Entity , typename... Component>
-inlinenoexcept +inline

Direct access to the list of entities.

-

The returned pointer is such that range [data(), data() + size()] is always a valid range, even if the container is empty.

+

The returned pointer is such that range [data(), data() + size()] is always a valid range, even if the container is empty.

Note
There are no guarantees on the order of the entities. Use begin and end if you want to iterate the view in the expected order.
Returns
A pointer to the array of entities.
-

Definition at line 111 of file view.hpp.

+

Definition at line 122 of file view.hpp.

@@ -316,7 +437,7 @@ template<typename Func >

Iterates entities and components and applies the given function object to them.

The function object is invoked for each entity. It is provided with the entity itself and a set of const references to all the components of the view.
The signature of the function should be equivalent to the following:

-
void(entity_type, const Component &...);
Template Parameters
+
void(const entity_type, const Component &...);
Template Parameters
FuncType of the function object to invoke.
@@ -329,7 +450,7 @@ template<typename Func >
-

Definition at line 271 of file view.hpp.

+

Definition at line 356 of file view.hpp.

@@ -364,7 +485,7 @@ template<typename Func >

Iterates entities and components and applies the given function object to them.

The function object is invoked for each entity. It is provided with the entity itself and a set of references to all the components of the view.
The signature of the function should be equivalent to the following:

-
void(entity_type, Component &...);
Template Parameters
+
void(const entity_type, Component &...);
Template Parameters
FuncType of the function object to invoke.
@@ -377,12 +498,78 @@ template<typename Func >
-

Definition at line 294 of file view.hpp.

+

Definition at line 379 of file view.hpp.

- -

◆ end()

+ +

◆ empty()

+ +
+
+
+template<typename Entity , typename... Component>
+ + + + + +
+ + + + + + + +
bool entt::PersistentView< Entity, Component >::empty () const
+ 		+inline
+
+ +

Checks whether the view is empty.

+
Returns
True if the view is empty, false otherwise.
+ +

Definition at line 106 of file view.hpp.

+ +
+
+ +

◆ end() [1/2]

+ +
+
+
+template<typename Entity , typename... Component>
+ + + + + +
+ + + + + + + +
const_iterator_type entt::PersistentView< Entity, Component >::end () const
+ 		+inline
+
+ +

Returns an iterator that is past the last entity that has the given components.

+

The returned iterator points to the entity following the last entity that has the given components. Attempting to dereference the returned iterator results in undefined behavior.

+
Note
Input iterators stay true to the order imposed to the underlying data structures.
+
Returns
An iterator to the entity following the last entity that has the given components.
+ +

Definition at line 214 of file view.hpp.

+ +
+
+ +

◆ end() [2/2]

@@ -396,12 +583,12 @@ template<typename Entity , typename... Component>
iterator_type entt::PersistentView< Entity, Component >::end ( ) - const + -inlinenoexcept +inline
@@ -411,12 +598,12 @@ 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 148 of file view.hpp.

+

Definition at line 233 of file view.hpp.

- -

◆ get() [1/4]

+ +

◆ get() [1/4]

@@ -431,20 +618,20 @@ template<typename Comp >
const Comp& entt::PersistentView< Entity, Component >::get ( - entity_type  + const entity_type  entity) const -inlinenoexcept +inline

Returns the component assigned to the given entity.

-

Prefer this function instead of Registry::get during iterations. It has far better performance than its companion function.

+

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

Definition at line 179 of file view.hpp.

+

Definition at line 264 of file view.hpp.

- -

◆ get() [2/4]

+ +

◆ get() [2/4]

@@ -481,20 +668,20 @@ template<typename Comp >
Comp& entt::PersistentView< Entity, Component >::get ( - entity_type  + const entity_type  entity) -inlinenoexcept +inline

Returns the component assigned to the given entity.

-

Prefer this function instead of Registry::get during iterations. It has far better performance than its companion function.

+

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

Definition at line 202 of file view.hpp.

+

Definition at line 287 of file view.hpp.

- -

◆ get() [3/4]

+ +

◆ get() [3/4]

@@ -531,20 +718,20 @@ template<typename... Comp>
std::enable_if_t<(sizeof...(Comp) > 1), std::tuple<const Comp &...> > entt::PersistentView< Entity, Component >::get ( - entity_type  + const entity_type  entity) const -inlinenoexcept +inline

Returns the components assigned to the given entity.

-

Prefer this function instead of Registry::get during iterations. It has far better performance than its companion function.

+

Prefer this function instead of Registry::get during iterations. It has far better performance than its companion function.

Warning
Attempting to use invalid component types results in a compilation error. Attempting to use an entity that doesn't belong to the view results in undefined behavior.
An assertion will abort the execution at runtime in debug mode if the view doesn't contain the given entity.
Template Parameters
@@ -561,12 +748,12 @@ template<typename... Comp>
Returns
The components assigned to the entity.
-

Definition at line 225 of file view.hpp.

+

Definition at line 310 of file view.hpp.

- -

◆ get() [4/4]

+ +

◆ get() [4/4]

@@ -581,20 +768,20 @@ template<typename... Comp>
std::enable_if_t<(sizeof...(Comp) > 1), std::tuple<Comp &...> > entt::PersistentView< Entity, Component >::get ( - entity_type  + const entity_type  entity) -inlinenoexcept +inline

Returns the components assigned to the given entity.

-

Prefer this function instead of Registry::get during iterations. It has far better performance than its companion function.

+

Prefer this function instead of Registry::get during iterations. It has far better performance than its companion function.

Warning
Attempting to use invalid component types results in a compilation error. Attempting to use an entity that doesn't belong to the view results in undefined behavior.
An assertion will abort the execution at runtime in debug mode if the view doesn't contain the given entity.
Template Parameters
@@ -611,12 +798,12 @@ template<typename... Comp>
Returns
The components assigned to the entity.
-

Definition at line 249 of file view.hpp.

+

Definition at line 334 of file view.hpp.

- -

◆ size()

+ +

◆ size()

@@ -635,7 +822,7 @@ template<typename Entity , typename... Component>
-inlinenoexcept +inline
@@ -643,7 +830,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 95 of file view.hpp.

+

Definition at line 98 of file view.hpp.

@@ -684,7 +871,7 @@ template<typename Comp > -

Definition at line 317 of file view.hpp.

+

Definition at line 402 of file view.hpp.

diff --git a/classentt_1_1Process-members.html b/classentt_1_1Process-members.html index 03925f91d..19d5e369e 100644 --- a/classentt_1_1Process-members.html +++ b/classentt_1_1Process-members.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -70,18 +70,18 @@ $(function() {

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
abort(const bool immediately=false) ENTT_NOEXCEPTentt::Process< Derived, Delta >inline
alive() const ENTT_NOEXCEPTentt::Process< Derived, Delta >inline
dead() const ENTT_NOEXCEPTentt::Process< Derived, Delta >inline
delta_type typedefentt::Process< Derived, Delta >
fail() 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
succeed() noexceptentt::Process< Derived, Delta >inlineprotected
tick(Delta delta, void *data=nullptr)entt::Process< Derived, Delta >inline
unpause() noexceptentt::Process< Derived, Delta >inlineprotected
~Process() noexceptentt::Process< Derived, Delta >inlinevirtual
fail() ENTT_NOEXCEPTentt::Process< Derived, Delta >inlineprotected
pause() ENTT_NOEXCEPTentt::Process< Derived, Delta >inlineprotected
paused() const ENTT_NOEXCEPTentt::Process< Derived, Delta >inline
rejected() const ENTT_NOEXCEPTentt::Process< Derived, Delta >inline
succeed() ENTT_NOEXCEPTentt::Process< Derived, Delta >inlineprotected
tick(const Delta delta, void *data=nullptr)entt::Process< Derived, Delta >inline
unpause() ENTT_NOEXCEPTentt::Process< Derived, Delta >inlineprotected
~Process() ENTT_NOEXCEPTentt::Process< Derived, Delta >inlinevirtual
diff --git a/classentt_1_1Process.html b/classentt_1_1Process.html index 2ad4d9037..2ad28475c 100644 --- a/classentt_1_1Process.html +++ b/classentt_1_1Process.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -87,43 +87,43 @@ using 

Public Member Functions

- -virtual ~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, void *data=nullptr) - Updates a process and its internal state if required. More...
-  + +virtual ~Process () ENTT_NOEXCEPT + Default destructor.
+  +void abort (const bool immediately=false) ENTT_NOEXCEPT + Aborts a process if it's still alive. More...
+  +bool alive () const ENTT_NOEXCEPT + Returns true if a process is either running or paused. More...
+  +bool dead () const ENTT_NOEXCEPT + Returns true if a process is already terminated. More...
+  +bool paused () const ENTT_NOEXCEPT + Returns true if a process is currently paused. More...
+  +bool rejected () const ENTT_NOEXCEPT + Returns true if a process terminated with errors. More...
+  +void tick (const Delta delta, void *data=nullptr) + Updates a process and its internal state if required. More...
+  - - - - - - - - - - - - + + + + + + + + + + + +

Protected Member Functions

void succeed () 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...
 
void succeed () ENTT_NOEXCEPT
 Terminates a process with success if it's still alive. More...
 
void fail () ENTT_NOEXCEPT
 Terminates a process with errors if it's still alive. More...
 
void pause () ENTT_NOEXCEPT
 Stops a process if it's in a running state. More...
 
void unpause () ENTT_NOEXCEPT
 Restarts a process if it's paused. More...
 

Detailed Description

template<typename Derived, typename Delta>
@@ -154,10 +154,10 @@ class entt::Process< Derived, Delta >

-

Definition at line 72 of file process.hpp.

+

Definition at line 73 of file process.hpp.

Member Function Documentation

- -

◆ abort()

+ +

◆ abort()

@@ -170,14 +170,14 @@ template<typename Derived, typename Delta>
void entt::Process< Derived, Delta >::abort ( - bool  + const bool  immediately = false) -inlinenoexcept +inline
@@ -191,12 +191,12 @@ template<typename Derived, typename Delta>
-

Definition at line 185 of file process.hpp.

+

Definition at line 186 of file process.hpp.

- -

◆ alive()

+ +

◆ alive()

@@ -215,7 +215,7 @@ template<typename Derived, typename Delta>
-inlinenoexcept +inline
@@ -223,12 +223,12 @@ template<typename Derived, typename Delta>

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.

+

Definition at line 200 of file process.hpp.

- -

◆ dead()

+ +

◆ dead()

@@ -247,7 +247,7 @@ template<typename Derived, typename Delta>
-inlinenoexcept +inline
@@ -255,12 +255,12 @@ template<typename Derived, typename Delta>

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.

+

Definition at line 208 of file process.hpp.

- -

◆ fail()

+ +

◆ fail()

@@ -279,7 +279,7 @@ template<typename Derived, typename Delta>
-inlineprotectednoexcept +inlineprotected
@@ -287,12 +287,12 @@ template<typename Derived, typename Delta>

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.

+

Definition at line 139 of file process.hpp.

- -

◆ pause()

+ +

◆ pause()

@@ -311,7 +311,7 @@ template<typename Derived, typename Delta>
-inlineprotectednoexcept +inlineprotected
@@ -319,12 +319,12 @@ template<typename Derived, typename Delta>

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.

+

Definition at line 151 of file process.hpp.

- -

◆ paused()

+ +

◆ paused()

@@ -343,7 +343,7 @@ template<typename Derived, typename Delta>
-inlinenoexcept +inline
@@ -351,12 +351,12 @@ template<typename Derived, typename Delta>

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.

+

Definition at line 216 of file process.hpp.

- -

◆ rejected()

+ +

◆ rejected()

@@ -375,7 +375,7 @@ template<typename Derived, typename Delta>
-inlinenoexcept +inline
@@ -383,12 +383,12 @@ template<typename Derived, typename Delta>

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.

+

Definition at line 224 of file process.hpp.

- -

◆ succeed()

+ +

◆ succeed()

@@ -407,7 +407,7 @@ template<typename Derived, typename Delta>
-inlineprotectednoexcept +inlineprotected
@@ -415,12 +415,12 @@ template<typename Derived, typename Delta>

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.

+

Definition at line 127 of file process.hpp.

- -

◆ tick()

+ +

◆ tick()

@@ -433,7 +433,7 @@ template<typename Derived, typename Delta>
void entt::Process< Derived, Delta >::tick ( - Delta  + const Delta  delta, @@ -464,12 +464,12 @@ template<typename Derived, typename Delta>
-

Definition at line 232 of file process.hpp.

+

Definition at line 233 of file process.hpp.

- -

◆ unpause()

+ +

◆ unpause()

@@ -488,7 +488,7 @@ template<typename Derived, typename Delta>
-inlineprotectednoexcept +inlineprotected
@@ -496,7 +496,7 @@ template<typename Derived, typename Delta>

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.

+

Definition at line 163 of file process.hpp.

diff --git a/classentt_1_1Prototype-members.html b/classentt_1_1Prototype-members.html new file mode 100644 index 000000000..4b14bc681 --- /dev/null +++ b/classentt_1_1Prototype-members.html @@ -0,0 +1,96 @@ + + + + + + + +entt: Member List + + + + + + + + + +
+
+ + + + + + +
+
entt +  2.6.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
entt::Prototype< Entity > Member List
+
+
+ +

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

+ + + + + + + + + + + + + + + + +
accommodate(registry_type &registry, const entity_type entity)entt::Prototype< Entity >inline
assign(registry_type &registry, const entity_type entity)entt::Prototype< Entity >inline
create(registry_type &registry)entt::Prototype< Entity >inline
entity_type typedefentt::Prototype< Entity >
get() const ENTT_NOEXCEPTentt::Prototype< Entity >inline
get() ENTT_NOEXCEPTentt::Prototype< Entity >inline
get() const ENTT_NOEXCEPTentt::Prototype< Entity >inline
get() ENTT_NOEXCEPTentt::Prototype< Entity >inline
has() const ENTT_NOEXCEPTentt::Prototype< Entity >inline
operator()(registry_type &registry, const entity_type entity) ENTT_NOEXCEPTentt::Prototype< Entity >inline
operator()(registry_type &registry) ENTT_NOEXCEPTentt::Prototype< Entity >inline
registry_type typedefentt::Prototype< Entity >
set(Args &&... args)entt::Prototype< Entity >inline
size_type typedefentt::Prototype< Entity >
unset() ENTT_NOEXCEPTentt::Prototype< Entity >inline
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1Prototype.html b/classentt_1_1Prototype.html new file mode 100644 index 000000000..42d8a881f --- /dev/null +++ b/classentt_1_1Prototype.html @@ -0,0 +1,707 @@ + + + + + + + +entt: entt::Prototype< Entity > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
entt +  2.6.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+Classes | +Public Types | +Public Member Functions | +List of all members
+
+
entt::Prototype< Entity > Class Template Reference
+
+
+ +

Prototype container for concepts. + More...

+ +

#include <prototype.hpp>

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

+Public Types

+using registry_type = Registry< Entity >
 Registry type.
 
+using entity_type = Entity
 Underlying entity identifier.
 
+using size_type = std::size_t
 Unsigned integer type.
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

template<typename Component , typename... Args>
Component & set (Args &&... args)
 Assigns to or replaces the given component of a prototype. More...
 
template<typename Component >
void unset () ENTT_NOEXCEPT
 Removes the given component from a prototype. More...
 
template<typename... Component>
bool has () const ENTT_NOEXCEPT
 Checks if a prototype owns all the given components. More...
 
template<typename Component >
const Component & get () const ENTT_NOEXCEPT
 Returns a reference to the given component. More...
 
template<typename Component >
Component & get () ENTT_NOEXCEPT
 Returns a reference to the given component. More...
 
template<typename... Component>
std::enable_if_t<(sizeof...(Component) > 1), std::tuple< const Component &... > > get () const ENTT_NOEXCEPT
 Returns a reference to the given components. More...
 
template<typename... Component>
std::enable_if_t<(sizeof...(Component) > 1), std::tuple< Component &... > > get () ENTT_NOEXCEPT
 Returns a reference to the given components. More...
 
entity_type create (registry_type &registry)
 Creates a new entity using a given prototype. More...
 
void assign (registry_type &registry, const entity_type entity)
 Assigns the components of a prototype to a given entity. More...
 
void accommodate (registry_type &registry, const entity_type entity)
 Assigns or replaces the components of a prototype for an entity. More...
 
void operator() (registry_type &registry, const entity_type entity) ENTT_NOEXCEPT
 Assigns the components of a prototype to an entity. More...
 
entity_type operator() (registry_type &registry) ENTT_NOEXCEPT
 Creates a new entity using a given prototype. More...
 
+

Detailed Description

+

template<typename Entity>
+class entt::Prototype< Entity >

+ +

Prototype container for concepts.

+

A prototype is used to define a concept in terms of components.
+ Prototypes act as templates for those specific types of an application which users would otherwise define through a series of component assignments to entities. In other words, prototypes can be used to assign components to entities of a registry at once.

+
Note
Components used along with prototypes must be copy constructible.
+
Template Parameters
+ + +
EntityA valid entity type (see entt_traits for more details).
+
+
+ +

Definition at line 32 of file prototype.hpp.

+

Member Function Documentation

+ +

◆ accommodate()

+ +
+
+
+template<typename Entity >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void entt::Prototype< Entity >::accommodate (registry_type & registry,
const entity_type entity 
)
+ 		+inline
+
+ +

Assigns or replaces the components of a prototype for an entity.

+

Existing components are overwritten, if any. All the other components will be copied over to the target entity.

+
Warning
Attempting to use an invalid entity results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode in case of invalid entity.
+
Parameters
+ + + +
registryA valid reference to a registry.
entityA valid entity identifier.
+
+
+ +

Definition at line 268 of file prototype.hpp.

+ +
+
+ +

◆ assign()

+ +
+
+
+template<typename Entity >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void entt::Prototype< Entity >::assign (registry_type & registry,
const entity_type entity 
)
+ 		+inline
+
+ +

Assigns the components of a prototype to a given entity.

+

Assigning a prototype to an entity won't overwrite existing components under any circumstances.
+ In other words, only those components that the entity doesn't own yet are copied over. All the other components remain unchanged.

+
Warning
Attempting to use an invalid entity results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode in case of invalid entity.
+
Parameters
+ + + +
registryA valid reference to a registry.
entityA valid entity identifier.
+
+
+ +

Definition at line 248 of file prototype.hpp.

+ +
+
+ +

◆ create()

+ +
+
+
+template<typename Entity >
+ + + + + +
+ + + + + + + + +
entity_type entt::Prototype< Entity >::create (registry_type & registry)
+ 		+inline
+
+ +

Creates a new entity using a given prototype.

+

Utility shortcut, equivalent to the following snippet:

+
const auto entity = registry.create();
prototype(registry, entity);
Warning
Attempting to use an invalid entity results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode in case of invalid entity.
+
Parameters
+ + +
registryA valid reference to a registry.
+
+
+
Returns
A valid entity identifier.
+ +

Definition at line 226 of file prototype.hpp.

+ +
+
+ +

◆ get() [1/4]

+ +
+
+
+template<typename Entity >
+
+template<typename Component >
+ + + + + +
+ + + + + + + +
const Component& entt::Prototype< Entity >::get () const
+ 		+inline
+
+ +

Returns a reference to the given component.

+
Warning
Attempting to get a component from a prototype that doesn't own it results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode if the prototype doesn't own an instance of the given component.
+
Template Parameters
+ + +
ComponentType of component to get.
+
+
+
Returns
A reference to the component owned by the prototype.
+ +

Definition at line 145 of file prototype.hpp.

+ +
+
+ +

◆ get() [2/4]

+ +
+
+
+template<typename Entity >
+
+template<typename Component >
+ + + + + +
+ + + + + + + +
Component& entt::Prototype< Entity >::get ()
+ 		+inline
+
+ +

Returns a reference to the given component.

+
Warning
Attempting to get a component from a prototype that doesn't own it results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode if the prototype doesn't own an instance of the given component.
+
Template Parameters
+ + +
ComponentType of component to get.
+
+
+
Returns
A reference to the component owned by the prototype.
+ +

Definition at line 168 of file prototype.hpp.

+ +
+
+ +

◆ get() [3/4]

+ +
+
+
+template<typename Entity >
+
+template<typename... Component>
+ + + + + +
+ + + + + + + +
std::enable_if_t<(sizeof...(Component) > 1), std::tuple<const Component &...> > entt::Prototype< Entity >::get () const
+ 		+inline
+
+ +

Returns a reference to the given components.

+
Warning
Attempting to get components from a prototype that doesn't own them results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode if the prototype doesn't own instances of the given components.
+
Template Parameters
+ + +
ComponentType of components to get.
+
+
+
Returns
References to the components owned by the prototype.
+ +

Definition at line 186 of file prototype.hpp.

+ +
+
+ +

◆ get() [4/4]

+ +
+
+
+template<typename Entity >
+
+template<typename... Component>
+ + + + + +
+ + + + + + + +
std::enable_if_t<(sizeof...(Component) > 1), std::tuple<Component &...> > entt::Prototype< Entity >::get ()
+ 		+inline
+
+ +

Returns a reference to the given components.

+
Warning
Attempting to get components from a prototype that doesn't own them results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode if the prototype doesn't own instances of the given components.
+
Template Parameters
+ + +
ComponentType of components to get.
+
+
+
Returns
References to the components owned by the prototype.
+ +

Definition at line 204 of file prototype.hpp.

+ +
+
+ +

◆ has()

+ +
+
+
+template<typename Entity >
+
+template<typename... Component>
+ + + + + +
+ + + + + + + +
bool entt::Prototype< Entity >::has () const
+ 		+inline
+
+ +

Checks if a prototype owns all the given components.

+
Template Parameters
+ + +
ComponentComponents for which to perform the check.
+
+
+
Returns
True if the prototype owns all the components, false otherwise.
+ +

Definition at line 118 of file prototype.hpp.

+ +
+
+ +

◆ operator()() [1/2]

+ +
+
+
+template<typename Entity >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void entt::Prototype< Entity >::operator() (registry_type & registry,
const entity_type entity 
)
+ 		+inline
+
+ +

Assigns the components of a prototype to an entity.

+

Assigning a prototype to an entity won't overwrite existing components under any circumstances.
+ In other words, only the components that the entity doesn't own yet are copied over. All the other components remain unchanged.

+
Warning
Attempting to use an invalid entity results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode in case of invalid entity.
+
Parameters
+ + + +
registryA valid reference to a registry.
entityA valid entity identifier.
+
+
+ +

Definition at line 290 of file prototype.hpp.

+ +
+
+ +

◆ operator()() [2/2]

+ +
+
+
+template<typename Entity >
+ + + + + +
+ + + + + + + + +
entity_type entt::Prototype< Entity >::operator() (registry_type & registry)
+ 		+inline
+
+ +

Creates a new entity using a given prototype.

+

Utility shortcut, equivalent to the following snippet:

+
const auto entity = registry.create();
prototype(registry, entity);
Warning
Attempting to use an invalid entity results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode in case of invalid entity.
+
Parameters
+ + +
registryA valid reference to a registry.
+
+
+
Returns
A valid entity identifier.
+ +

Definition at line 312 of file prototype.hpp.

+ +
+
+ +

◆ set()

+ +
+
+
+template<typename Entity >
+
+template<typename Component , typename... Args>
+ + + + + +
+ + + + + + + + +
Component& entt::Prototype< Entity >::set (Args &&... args)
+ 		+inline
+
+ +

Assigns to or replaces the given component of a prototype.

+
Template Parameters
+ + + +
ComponentType of component to assign or replace.
ArgsTypes of arguments to use to construct the component.
+
+
+
Parameters
+ + +
argsParameters to use to initialize the component.
+
+
+
Returns
A reference to the newly created component.
+ +

Definition at line 82 of file prototype.hpp.

+ +
+
+ +

◆ unset()

+ +
+
+
+template<typename Entity >
+
+template<typename Component >
+ + + + + +
+ + + + + + + +
void entt::Prototype< Entity >::unset ()
+ 		+inline
+
+ +

Removes the given component from a prototype.

+
Template Parameters
+ + +
ComponentType of component to remove.
+
+
+ +

Definition at line 106 of file prototype.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1RawView-members.html b/classentt_1_1RawView-members.html index 6cfea9db2..72fa3fbd0 100644 --- a/classentt_1_1RawView-members.html +++ b/classentt_1_1RawView-members.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -70,16 +70,24 @@ $(function() {

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

- - - + + + + + + + + + + + - - + + - +
begin() const noexceptentt::RawView< Entity, Component >inline
data() const noexceptentt::RawView< Entity, Component >inline
end() const noexceptentt::RawView< Entity, Component >inline
begin() const ENTT_NOEXCEPTentt::RawView< Entity, Component >inline
begin() ENTT_NOEXCEPTentt::RawView< Entity, Component >inline
cbegin() const ENTT_NOEXCEPTentt::RawView< Entity, Component >inline
cend() const ENTT_NOEXCEPTentt::RawView< Entity, Component >inline
const_iterator_type typedefentt::RawView< Entity, Component >
data() const ENTT_NOEXCEPTentt::RawView< Entity, Component >inline
each(Func func) constentt::RawView< Entity, Component >inline
each(Func func)entt::RawView< Entity, Component >inline
empty() const ENTT_NOEXCEPTentt::RawView< Entity, Component >inline
end() const ENTT_NOEXCEPTentt::RawView< Entity, Component >inline
end() ENTT_NOEXCEPTentt::RawView< Entity, Component >inline
entity_type typedefentt::RawView< Entity, Component >
iterator_type typedefentt::RawView< Entity, Component >
raw() noexceptentt::RawView< Entity, Component >inline
raw() const noexceptentt::RawView< Entity, Component >inline
raw() const ENTT_NOEXCEPTentt::RawView< Entity, Component >inline
raw() ENTT_NOEXCEPTentt::RawView< Entity, Component >inline
raw_type typedefentt::RawView< Entity, Component >
Registry< Entity > classentt::RawView< Entity, Component >friend
size() const noexceptentt::RawView< Entity, Component >inline
size() const ENTT_NOEXCEPTentt::RawView< Entity, Component >inline
size_type typedefentt::RawView< Entity, Component >
diff --git a/classentt_1_1RawView.html b/classentt_1_1RawView.html index f866eb2aa..47a440e24 100644 --- a/classentt_1_1RawView.html +++ b/classentt_1_1RawView.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -84,6 +84,10 @@ Public Types using iterator_type = typename pool_type::iterator_type  Input iterator type.
  + +using const_iterator_type = typename pool_type::const_iterator_type + Constant input iterator type.
+  using entity_type = typename pool_type::entity_type  Underlying entity identifier.
@@ -99,24 +103,47 @@ using 

Public Member Functions

-size_type size () const noexcept - Returns the number of instances of the given type. More...
-  -raw_type * raw () noexcept - Direct access to the list of components. More...
-  -const raw_type * raw () const noexcept - Direct access to the list of components. More...
-  -const entity_type * data () const noexcept - Direct access to the list of entities. More...
-  -iterator_type begin () const noexcept - Returns an iterator to the first instance of the given type. More...
-  -iterator_type end () const noexcept - Returns an iterator that is past the last instance of the given type. More...
-  +size_type size () const ENTT_NOEXCEPT + Returns the number of instances of the given type. More...
+  +bool empty () const ENTT_NOEXCEPT + Checks whether the view is empty. More...
+  +const raw_type * raw () const ENTT_NOEXCEPT + Direct access to the list of components. More...
+  +raw_type * raw () ENTT_NOEXCEPT + Direct access to the list of components. More...
+  +const entity_type * data () const ENTT_NOEXCEPT + Direct access to the list of entities. More...
+  +const_iterator_type cbegin () const ENTT_NOEXCEPT + Returns an iterator to the first instance of the given type. More...
+  +const_iterator_type begin () const ENTT_NOEXCEPT + Returns an iterator to the first instance of the given type. More...
+  +iterator_type begin () ENTT_NOEXCEPT + Returns an iterator to the first instance of the given type. More...
+  +const_iterator_type cend () const ENTT_NOEXCEPT + Returns an iterator that is past the last instance of the given type. More...
+  +const_iterator_type end () const ENTT_NOEXCEPT + Returns an iterator that is past the last instance of the given type. More...
+  +iterator_type end () ENTT_NOEXCEPT + Returns an iterator that is past the last instance of the given type. More...
+  +template<typename Func > +void each (Func func) const + Iterates components and applies the given function object to them. More...
+  +template<typename Func > +void each (Func func) + Iterates components and applies the given function object to them. More...
+  @@ -154,10 +181,44 @@ class entt::RawView< Entity, Component > -

Definition at line 1008 of file view.hpp.

+

Definition at line 1276 of file view.hpp.

Member Function Documentation

- -

◆ begin()

+ +

◆ begin() [1/2]

+ +
+
+
+template<typename Entity , typename Component >
+

Friends

+ + + + +
+ + + + + + + +
const_iterator_type entt::RawView< Entity, Component >::begin () const
+ 		+inline
+
+ +

Returns an iterator to the first instance of the given type.

+

The returned iterator points to the first instance of the given type. If the view is empty, the returned iterator will be equal to end().

+
Note
Input iterators stay true to the order imposed to the underlying data structures.
+
Returns
An iterator to the first instance of the given type.
+ +

Definition at line 1390 of file view.hpp.

+ +
+ + +

◆ begin() [2/2]

@@ -171,27 +232,95 @@ template<typename Entity , typename Component >
iterator_type entt::RawView< Entity, Component >::begin ( ) - const + -inlinenoexcept +inline

Returns an iterator to the first instance of the given type.

-

The returned iterator points to the first instance of the given type. If the view is empty, the returned iterator will be equal to end().

+

The returned iterator points to the first instance of the given type. If the view is empty, the returned iterator will be equal to end().

Note
Input iterators stay true to the order imposed to the underlying data structures.
Returns
An iterator to the first instance of the given type.
-

Definition at line 1097 of file view.hpp.

+

Definition at line 1406 of file view.hpp.

- -

◆ data()

+ +

◆ cbegin()

+ +
+
+
+template<typename Entity , typename Component >
+ + + + + +
+ + + + + + + +
const_iterator_type entt::RawView< Entity, Component >::cbegin () const
+ 		+inline
+
+ +

Returns an iterator to the first instance of the given type.

+

The returned iterator points to the first instance of the given type. If the view is empty, the returned iterator will be equal to end().

+
Note
Input iterators stay true to the order imposed to the underlying data structures.
+
Returns
An iterator to the first instance of the given type.
+ +

Definition at line 1374 of file view.hpp.

+ +
+
+ +

◆ cend()

+ +
+
+
+template<typename Entity , typename Component >
+ + + + + +
+ + + + + + + +
const_iterator_type entt::RawView< Entity, Component >::cend () const
+ 		+inline
+
+ +

Returns an iterator that is past the last instance of the given type.

+

The returned iterator points to the element following the last instance of the given type. Attempting to dereference the returned iterator results in undefined behavior.

+
Note
Input iterators stay true to the order imposed to the underlying data structures.
+
Returns
An iterator to the element following the last instance of the given type.
+ +

Definition at line 1425 of file view.hpp.

+ +
+
+ +

◆ data()

@@ -210,22 +339,184 @@ template<typename Entity , typename Component >
-inlinenoexcept +inline

Direct access to the list of entities.

-

The returned pointer is such that range [data(), data() + size()] is always a valid range, even if the container is empty.

+

The returned pointer is such that range [data(), data() + size()] is always a valid range, even if the container is empty.

Note
There are no guarantees on the order of the entities. Use begin and end if you want to iterate the view in the expected order.
Returns
A pointer to the array of entities.
-

Definition at line 1081 of file view.hpp.

+

Definition at line 1358 of file view.hpp.

- -

◆ end()

+ +

◆ each() [1/2]

+ +
+
+
+template<typename Entity , typename Component >
+
+template<typename Func >
+ + + + + +
+ + + + + + + + +
void entt::RawView< Entity, Component >::each (Func func) const
+ 		+inline
+
+ +

Iterates components and applies the given function object to them.

+

The function object is provided with a const reference to each component of the view.
+ The signature of the function should be equivalent to the following:

+
void(const Component &);
Template Parameters
+ + +
FuncType of the function object to invoke.
+
+
+
Parameters
+ + +
funcA valid function object.
+
+
+ +

Definition at line 1482 of file view.hpp.

+ +
+
+ +

◆ each() [2/2]

+ +
+
+
+template<typename Entity , typename Component >
+
+template<typename Func >
+ + + + + +
+ + + + + + + + +
void entt::RawView< Entity, Component >::each (Func func)
+ 		+inline
+
+ +

Iterates components and applies the given function object to them.

+

The function object is provided with a const reference to each component of the view.
+ The signature of the function should be equivalent to the following:

+
void(const Component &);
Template Parameters
+ + +
FuncType of the function object to invoke.
+
+
+
Parameters
+ + +
funcA valid function object.
+
+
+ +

Definition at line 1501 of file view.hpp.

+ +
+
+ +

◆ empty()

+ +
+
+
+template<typename Entity , typename Component >
+ + + + + +
+ + + + + + + +
bool entt::RawView< Entity, Component >::empty () const
+ 		+inline
+
+ +

Checks whether the view is empty.

+
Returns
True if the view is empty, false otherwise.
+ +

Definition at line 1310 of file view.hpp.

+ +
+
+ +

◆ end() [1/2]

+ +
+
+
+template<typename Entity , typename Component >
+ + + + + +
+ + + + + + + +
const_iterator_type entt::RawView< Entity, Component >::end () const
+ 		+inline
+
+ +

Returns an iterator that is past the last instance of the given type.

+

The returned iterator points to the element following the last instance of the given type. Attempting to dereference the returned iterator results in undefined behavior.

+
Note
Input iterators stay true to the order imposed to the underlying data structures.
+
Returns
An iterator to the element following the last instance of the given type.
+ +

Definition at line 1444 of file view.hpp.

+ +
+
+ +

◆ end() [2/2]

@@ -239,12 +530,12 @@ template<typename Entity , typename Component >
iterator_type entt::RawView< Entity, Component >::end ( ) - const + -inlinenoexcept +inline
@@ -254,46 +545,12 @@ template<typename Entity , typename Component >
Note
Input iterators stay true to the order imposed to the underlying data structures.
Returns
An iterator to the element following the last instance of the given type.
-

Definition at line 1116 of file view.hpp.

+

Definition at line 1463 of file view.hpp.

- -

◆ raw() [1/2]

- -
-
-
-template<typename Entity , typename Component >
- - - - - -
- - - - - - - -
raw_type* entt::RawView< Entity, Component >::raw ()
- 		-inlinenoexcept
-
- -

Direct access to the list of components.

-

The returned pointer is such that range [raw(), raw() + size()] is always a valid range, even if the container is empty.

-
Note
There are no guarantees on the order of the components. Use begin and end if you want to iterate the view in the expected order.
-
Returns
A pointer to the array of components.
- -

Definition at line 1049 of file view.hpp.

- -
-
- -

◆ raw() [2/2]

+ +

◆ raw() [1/2]

@@ -312,22 +569,56 @@ template<typename Entity , typename Component >
-inlinenoexcept +inline

Direct access to the list of components.

-

The returned pointer is such that range [raw(), raw() + size()] is always a valid range, even if the container is empty.

+

The returned pointer is such that range [raw(), raw() + size()] is always a valid range, even if the container is empty.

Note
There are no guarantees on the order of the components. Use begin and end if you want to iterate the view in the expected order.
Returns
A pointer to the array of components.
-

Definition at line 1065 of file view.hpp.

+

Definition at line 1326 of file view.hpp.

- -

◆ size()

+ +

◆ raw() [2/2]

+ +
+
+
+template<typename Entity , typename Component >
+ + + + + +
+ + + + + + + +
raw_type* entt::RawView< Entity, Component >::raw ()
+ 		+inline
+
+ +

Direct access to the list of components.

+

The returned pointer is such that range [raw(), raw() + size()] is always a valid range, even if the container is empty.

+
Note
There are no guarantees on the order of the components. Use begin and end if you want to iterate the view in the expected order.
+
Returns
A pointer to the array of components.
+ +

Definition at line 1342 of file view.hpp.

+ +
+
+ +

◆ size()

@@ -346,7 +637,7 @@ template<typename Entity , typename Component >
-inlinenoexcept +inline
@@ -354,7 +645,7 @@ template<typename Entity , typename Component >

Returns the number of instances of the given type.

Returns
Number of instances of the given component.
-

Definition at line 1033 of file view.hpp.

+

Definition at line 1302 of file view.hpp.

diff --git a/classentt_1_1Registry-members.html b/classentt_1_1Registry-members.html index 44882d6d0..eb974528e 100644 --- a/classentt_1_1Registry-members.html +++ b/classentt_1_1Registry-members.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -70,66 +70,74 @@ $(function() {

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

- - - - - - + + + + + + - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + - + - - - + + + - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + - - + + + + + +
accommodate(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
component() const noexceptentt::Registry< Entity >inline
accommodate(const entity_type entity, Args &&... args)entt::Registry< Entity >inline
assign(tag_t, const entity_type entity, Args &&... args)entt::Registry< Entity >inline
assign(const entity_type entity, Args &&... args)entt::Registry< Entity >inline
attachee() const ENTT_NOEXCEPTentt::Registry< Entity >inline
capacity() const ENTT_NOEXCEPTentt::Registry< Entity >inline
clone(const entity_type entity) ENTT_NOEXCEPTentt::Registry< Entity >inline
component_type typedefentt::Registry< Entity >
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
each(Func func) constentt::Registry< Entity >inline
empty() const noexceptentt::Registry< Entity >inline
empty() const noexceptentt::Registry< Entity >inline
entity_type typedefentt::Registry< Entity >
fast(entity_type entity) const noexceptentt::Registry< Entity >inline
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
get(entity_type entity) const noexceptentt::Registry< Entity >inline
get(entity_type entity) noexceptentt::Registry< Entity >inline
has() const noexceptentt::Registry< Entity >inline
has(entity_type entity) const noexceptentt::Registry< Entity >inline
move(entity_type entity)entt::Registry< Entity >inline
construction(tag_t) ENTT_NOEXCEPTentt::Registry< Entity >inline
construction() ENTT_NOEXCEPTentt::Registry< Entity >inline
contains() const ENTT_NOEXCEPTentt::Registry< Entity >inline
create() ENTT_NOEXCEPTentt::Registry< Entity >inline
current(const entity_type entity) const ENTT_NOEXCEPTentt::Registry< Entity >inline
data() const ENTT_NOEXCEPTentt::Registry< Entity >inline
destroy(const entity_type entity)entt::Registry< Entity >inline
destruction(tag_t) ENTT_NOEXCEPTentt::Registry< Entity >inline
destruction() ENTT_NOEXCEPTentt::Registry< Entity >inline
discard()entt::Registry< Entity >inline
each(Func func) constentt::Registry< Entity >inline
empty() const ENTT_NOEXCEPTentt::Registry< Entity >inline
empty() const ENTT_NOEXCEPTentt::Registry< Entity >inline
entity_type typedefentt::Registry< Entity >
fast(const entity_type entity) const ENTT_NOEXCEPTentt::Registry< Entity >inline
get() const ENTT_NOEXCEPTentt::Registry< Entity >inline
get() ENTT_NOEXCEPTentt::Registry< Entity >inline
get(const entity_type entity) const ENTT_NOEXCEPTentt::Registry< Entity >inline
get(const entity_type entity) ENTT_NOEXCEPTentt::Registry< Entity >inline
get(const entity_type entity) const ENTT_NOEXCEPTentt::Registry< Entity >inline
get(const entity_type entity) ENTT_NOEXCEPTentt::Registry< Entity >inline
has() const ENTT_NOEXCEPTentt::Registry< Entity >inline
has(tag_t, const entity_type entity) const ENTT_NOEXCEPTentt::Registry< Entity >inline
has(const entity_type entity) const ENTT_NOEXCEPTentt::Registry< Entity >inline
move(const entity_type entity)entt::Registry< Entity >inline
operator=(const Registry &)=deleteentt::Registry< Entity >
operator=(Registry &&)=defaultentt::Registry< Entity >
orphan(entity_type entity) constentt::Registry< Entity >inline
orphan(const entity_type entity) constentt::Registry< Entity >inline
orphans(Func func) constentt::Registry< Entity >inline
persistent()entt::Registry< Entity >inline
prepare()entt::Registry< Entity >inline
raw()entt::Registry< Entity >inline
prepare()entt::Registry< Entity >inline
raw() const ENTT_NOEXCEPTentt::Registry< Entity >inline
raw() ENTT_NOEXCEPTentt::Registry< Entity >inline
Registry()=defaultentt::Registry< Entity >
Registry(const Registry &)=deleteentt::Registry< Entity >
Registry(Registry &&)=defaultentt::Registry< Entity >
remove()entt::Registry< Entity >inline
remove(entity_type entity)entt::Registry< Entity >inline
replace(entity_type entity, Args &&... args)entt::Registry< Entity >inline
reserve(size_type cap)entt::Registry< Entity >inline
reserve(size_type cap)entt::Registry< Entity >inline
reset(entity_type entity)entt::Registry< Entity >inline
reset()entt::Registry< Entity >inline
reset()entt::Registry< Entity >inline
restore()entt::Registry< Entity >inline
set(Args &&... args)entt::Registry< Entity >inline
size() const noexceptentt::Registry< Entity >inline
size() const noexceptentt::Registry< Entity >inline
size_type typedefentt::Registry< Entity >
snapshot() constentt::Registry< Entity >inline
sort(Compare compare)entt::Registry< Entity >inline
sort()entt::Registry< Entity >inline
tag() const noexceptentt::Registry< Entity >inline
remove(const entity_type entity)entt::Registry< Entity >inline
replace(tag_t, Args &&... args)entt::Registry< Entity >inline
replace(const entity_type entity, Args &&... args)entt::Registry< Entity >inline
reserve(const size_type cap)entt::Registry< Entity >inline
reserve(const size_type cap)entt::Registry< Entity >inline
reset(const entity_type entity)entt::Registry< Entity >inline
reset()entt::Registry< Entity >inline
reset()entt::Registry< Entity >inline
restore()entt::Registry< Entity >inline
sink_type typedefentt::Registry< Entity >
size() const ENTT_NOEXCEPTentt::Registry< Entity >inline
size() const ENTT_NOEXCEPTentt::Registry< Entity >inline
size_type typedefentt::Registry< Entity >
snapshot() constentt::Registry< Entity >inline
sort(Compare compare, Sort sort=Sort{})entt::Registry< Entity >inline
sort()entt::Registry< Entity >inline
tag_type typedefentt::Registry< Entity >
valid(entity_type entity) const noexceptentt::Registry< Entity >inline
version(entity_type entity) const noexceptentt::Registry< Entity >inline
type(tag_t) ENTT_NOEXCEPTentt::Registry< Entity >inlinestatic
type() ENTT_NOEXCEPTentt::Registry< Entity >inlinestatic
valid(const entity_type entity) const ENTT_NOEXCEPTentt::Registry< Entity >inline
version(const entity_type entity) const ENTT_NOEXCEPTentt::Registry< Entity >inline
version_type typedefentt::Registry< Entity >
view()entt::Registry< Entity >inline
view(persistent_t)entt::Registry< Entity >inline
view(raw_t)entt::Registry< Entity >inline
diff --git a/classentt_1_1Registry.html b/classentt_1_1Registry.html index 77b6f26b8..f8a0d2c9c 100644 --- a/classentt_1_1Registry.html +++ b/classentt_1_1Registry.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -67,6 +67,7 @@ $(function() { Classes | Public Types | Public Member Functions | +Static Public Member Functions | List of all members
entt::Registry< Entity > Class Template Reference
@@ -100,6 +101,10 @@ using component_type = typename component_family::family_type  Unsigned integer type.
  + +using sink_type = typename signal_type::sink_type + Type of sink for the given component.
+  @@ -121,144 +126,163 @@ Public Member Functions - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - + + + + @@ -270,9 +294,9 @@ Public Member Functions - - - + + + @@ -289,24 +313,35 @@ Public Member Functions - - - - - - - - - - - - + + + + + + + + + + + + +

Public Member Functions

Registry & operator= (Registry &&)=default
 Default move assignment operator. More...
 
template<typename Tag >
tag_type tag () const noexcept
 Returns the numeric identifier of a type of tag at runtime. More...
 
template<typename Component >
component_type component () const noexcept
 Returns the numeric identifier of a type of component at runtime. More...
 
template<typename Component >
size_type size () const noexcept
 Returns the number of existing components of the given type. More...
 
size_type size () const noexcept
 Returns the number of entities still in use. More...
 
template<typename Component >
void reserve (size_type cap)
 Increases the capacity of the pool for a given component. More...
 
void reserve (size_type cap)
 Increases the capacity of a registry in terms of entities. More...
 
size_type capacity () const noexcept
 Returns the number of entities ever created. More...
 
template<typename Component >
bool empty () const noexcept
 Checks whether the pool for the given component is empty. More...
 
bool empty () const noexcept
 Checks if there exists at least an entity still in use. More...
 
bool valid (entity_type entity) const noexcept
 Checks if an entity identifier refers to a valid entity. More...
 
bool fast (entity_type entity) const noexcept
 Checks if an entity identifier refers to a valid entity. More...
 
version_type version (entity_type entity) const noexcept
 Returns the version stored along with an entity identifier. More...
 
version_type current (entity_type entity) const noexcept
 Returns the actual version for an entity identifier. More...
 
template<typename... Component>
entity_type create (Component &&... components) noexcept
 Returns a new entity initialized with the given components. More...
 
template<typename... Component>
entity_type create () noexcept
 Returns a new entity to which the given components are assigned. More...
 
entity_type create () noexcept
 Creates a new entity and returns it. More...
 
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 the given tag to an entity. More...
 
template<typename Component >
size_type size () const ENTT_NOEXCEPT
 Returns the number of existing components of the given type. More...
 
size_type size () const ENTT_NOEXCEPT
 Returns the number of entities still in use. More...
 
template<typename Component >
void reserve (const size_type cap)
 Increases the capacity of the pool for a given component. More...
 
void reserve (const size_type cap)
 Increases the capacity of a registry in terms of entities. More...
 
size_type capacity () const ENTT_NOEXCEPT
 Returns the number of entities ever created. More...
 
template<typename Component >
bool empty () const ENTT_NOEXCEPT
 Checks whether the pool for the given component is empty. More...
 
bool empty () const ENTT_NOEXCEPT
 Checks if there exists at least an entity still in use. More...
 
template<typename Component >
const Component * raw () const ENTT_NOEXCEPT
 Direct access to the list of components of a given pool. More...
 
template<typename Component >
Component * raw () ENTT_NOEXCEPT
 Direct access to the list of components of a given pool. More...
 
template<typename Component >
const entity_type * data () const ENTT_NOEXCEPT
 Direct access to the list of entities of a given pool. More...
 
bool valid (const entity_type entity) const ENTT_NOEXCEPT
 Checks if an entity identifier refers to a valid entity. More...
 
bool fast (const entity_type entity) const ENTT_NOEXCEPT
 Checks if an entity identifier refers to a valid entity. More...
 
version_type version (const entity_type entity) const ENTT_NOEXCEPT
 Returns the version stored along with an entity identifier. More...
 
version_type current (const entity_type entity) const ENTT_NOEXCEPT
 Returns the actual version for an entity identifier. More...
 
entity_type create () ENTT_NOEXCEPT
 Creates a new entity and returns it. More...
 
entity_type clone (const entity_type entity) ENTT_NOEXCEPT
 Clones an entity and returns the newly created one. More...
 
void destroy (const entity_type entity)
 Destroys an entity and lets the registry recycle the identifier. More...
 
template<typename Tag , typename... Args>
Tag & assign (tag_t, const entity_type entity, Args &&... args)
 Attaches the given tag to an entity. More...
 
template<typename Component , typename... Args>
Component & assign (const entity_type entity, Args &&... args)
 Assigns the given component to an entity. More...
 
template<typename Tag >
void remove ()
 Removes the given tag from its owner, if any. More...
 
template<typename Tag >
bool has () const noexcept
 Checks if the given tag has an owner. More...
 
template<typename Tag >
const Tag & get () const noexcept
 Returns a reference to the given tag. More...
 
template<typename Tag >
Tag & get () noexcept
 Returns a reference to the given tag. More...
 
template<typename Tag , typename... Args>
Tag & set (Args &&... args)
 Replaces the given tag. More...
 
template<typename Tag >
entity_type move (entity_type entity)
 Changes the owner of the given tag. More...
 
template<typename Tag >
entity_type attachee () const noexcept
 Gets the owner of the given tag, if any. More...
 
template<typename Component , typename... Args>
Component & assign (entity_type entity, Args &&... args)
 Assigns the given component to an entity. More...
 
template<typename Component >
void remove (entity_type entity)
 Removes the given component from an entity. More...
 
template<typename... Component>
bool has (entity_type entity) const noexcept
 Checks if an entity has all the given components. More...
 
template<typename Component >
const Component & get (entity_type entity) const noexcept
 Returns a reference to the given component for an entity. More...
 
template<typename Component >
Component & get (entity_type entity) noexcept
 Returns a reference to the given component for an entity. More...
 
template<typename... Component>
std::enable_if_t<(sizeof...(Component) > 1), std::tuple< const Component &... > > get (entity_type entity) const noexcept
 Returns a reference to the given components for an entity. More...
 
template<typename... Component>
std::enable_if_t<(sizeof...(Component) > 1), std::tuple< Component &... > > get (entity_type entity) noexcept
 Returns a reference to the given components for an entity. More...
 
template<typename Component , typename... Args>
Component & replace (entity_type entity, Args &&... args)
 Replaces the given component for an entity. More...
 
template<typename Component , typename... Args>
Component & accommodate (entity_type entity, Args &&... args)
 Assigns or replaces the given component for an entity. More...
 
template<typename Component , typename Compare >
void sort (Compare compare)
 Sorts the pool of entities for the given component. More...
 
template<typename Component >
void remove (const entity_type entity)
 Removes the given component from an entity. More...
 
template<typename Tag >
bool has () const ENTT_NOEXCEPT
 Checks if the given tag has an owner. More...
 
template<typename Tag >
bool has (tag_t, const entity_type entity) const ENTT_NOEXCEPT
 Checks if an entity owns the given tag. More...
 
template<typename... Component>
bool has (const entity_type entity) const ENTT_NOEXCEPT
 Checks if an entity has all the given components. More...
 
template<typename Tag >
const Tag & get () const ENTT_NOEXCEPT
 Returns a reference to the given tag. More...
 
template<typename Tag >
Tag & get () ENTT_NOEXCEPT
 Returns a reference to the given tag. More...
 
template<typename Component >
const Component & get (const entity_type entity) const ENTT_NOEXCEPT
 Returns a reference to the given component for an entity. More...
 
template<typename Component >
Component & get (const entity_type entity) ENTT_NOEXCEPT
 Returns a reference to the given component for an entity. More...
 
template<typename... Component>
std::enable_if_t<(sizeof...(Component) > 1), std::tuple< const Component &... > > get (const entity_type entity) const ENTT_NOEXCEPT
 Returns a reference to the given components for an entity. More...
 
template<typename... Component>
std::enable_if_t<(sizeof...(Component) > 1), std::tuple< Component &... > > get (const entity_type entity) ENTT_NOEXCEPT
 Returns a reference to the given components for an entity. More...
 
template<typename Tag , typename... Args>
Tag & replace (tag_t, Args &&... args)
 Replaces the given tag. More...
 
template<typename Component , typename... Args>
Component & replace (const entity_type entity, Args &&... args)
 Replaces the given component for an entity. More...
 
template<typename Tag >
entity_type move (const entity_type entity)
 Changes the owner of the given tag. More...
 
template<typename Tag >
entity_type attachee () const ENTT_NOEXCEPT
 Gets the owner of the given tag, if any. More...
 
template<typename Component , typename... Args>
Component & accommodate (const entity_type entity, Args &&... args)
 Assigns or replaces the given component for an entity. More...
 
template<typename Tag >
sink_type construction (tag_t) ENTT_NOEXCEPT
 Returns a sink object for the given tag. More...
 
template<typename Component >
sink_type construction () ENTT_NOEXCEPT
 Returns a sink object for the given component. More...
 
template<typename Tag >
sink_type destruction (tag_t) ENTT_NOEXCEPT
 Returns a sink object for the given tag. More...
 
template<typename Component >
sink_type destruction () ENTT_NOEXCEPT
 Returns a sink object for the given component. More...
 
template<typename Component , typename Compare , typename Sort = StdSort>
void sort (Compare compare, Sort sort=Sort{})
 Sorts the pool of entities for the given component. More...
 
template<typename To , typename From >
void sort ()
 Sorts two pools of components in the same way. More...
 
template<typename Component >
void reset (entity_type entity)
 Resets the given component for an entity. More...
 
template<typename Component >
void reset (const entity_type entity)
 Resets the given component for an entity. More...
 
template<typename Component >
void reset ()
 Resets the pool of the given component. More...
void each (Func func) const
 Iterates all the entities that are still in use. More...
 
bool orphan (entity_type entity) const
 Checks if an entity is an orphan. More...
 
bool orphan (const entity_type entity) const
 Checks if an entity is an orphan. More...
 
template<typename Func >
void orphans (Func func) const
 Iterates orphans and applies them the given function object. More...
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...
 
template<typename Component >
RawView< Entity, Component > raw ()
 Returns a raw view for the given component. More...
 
template<typename... Component>
bool contains () const ENTT_NOEXCEPT
 Checks if a persistent view has already been prepared. More...
 
template<typename... Component>
PersistentView< Entity, Component... > view (persistent_t)
 Returns a persistent view for the given components. More...
 
template<typename Component >
RawView< Entity, Component > view (raw_t)
 Returns a raw view for the given component. More...
 
Snapshot< Entity > snapshot () const
 Returns a temporary object to use to create snapshots. More...
 
SnapshotLoader< Entity > restore ()
 Returns a temporary object to use to load snapshots. More...
 
+ + + + + + + + +

+Static Public Member Functions

template<typename Tag >
static tag_type type (tag_t) ENTT_NOEXCEPT
 Returns the numeric identifier of a type of tag at runtime. More...
 
template<typename Component >
static component_type type () ENTT_NOEXCEPT
 Returns the numeric identifier of a type of component at runtime. More...
 

Detailed Description

template<typename Entity>
@@ -323,10 +358,10 @@ class entt::Registry< Entity >

-

Definition at line 35 of file registry.hpp.

+

Definition at line 39 of file registry.hpp.

Member Function Documentation

- -

◆ accommodate()

+ +

◆ accommodate()

@@ -341,7 +376,7 @@ template<typename Component , typename... Args>
Component& entt::Registry< Entity >::accommodate ( - entity_type  + const entity_type  entity, @@ -384,74 +419,12 @@ template<typename Component , typename... Args>
Returns
A reference to the newly created component.
-

Definition at line 842 of file registry.hpp.

+

Definition at line 903 of file registry.hpp.

- -

◆ assign()

- -
-
-
-template<typename Entity>
-
-template<typename Component , typename... Args>
- - - - - -
- - - - - - - - - - - - - - - - - - -
Component& entt::Registry< Entity >::assign (entity_type entity,
Args &&... args 
)
- 		-inline
-
- -

Assigns the given component to an entity.

-

A new instance of the given component is created and initialized with the arguments provided (the component must have a proper constructor or be of aggregate type). Then the component is assigned to the given entity.

-
Warning
Attempting to use an invalid entity or to assign a component to an entity that already owns it results in undefined behavior.
- An assertion will abort the execution at runtime in debug mode in case of invalid entity or if the entity already owns an instance of the given component.
-
Template Parameters
- - - -
ComponentType of component to create.
ArgsTypes of arguments to use to construct the component.
-
-
-
Parameters
- - - -
entityA valid entity identifier.
argsParameters to use to initialize the component.
-
-
-
Returns
A reference to the newly created component.
- -

Definition at line 664 of file registry.hpp.

- -
-
- -

◆ attach()

+ +

◆ assign() [1/2]

@@ -464,9 +437,15 @@ template<typename Tag , typename... Args>
- + - + + + + + + + @@ -509,12 +488,74 @@ template<typename Tag , typename... Args>
Returns
A reference to the newly created tag.
-

Definition at line 501 of file registry.hpp.

+

Definition at line 535 of file registry.hpp.

- -

◆ attachee()

+ +

◆ assign() [2/2]

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

Assigns the given component to an entity.

+

A new instance of the given component is created and initialized with the arguments provided (the component must have a proper constructor or be of aggregate type). Then the component is assigned to the given entity.

+
Warning
Attempting to use an invalid entity or to assign a component to an entity that already owns it results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode in case of invalid entity or if the entity already owns an instance of the given component.
+
Template Parameters
+ + + +
ComponentType of component to create.
ArgsTypes of arguments to use to construct the component.
+
+
+
Parameters
+ + + +
entityA valid entity identifier.
argsParameters to use to initialize the component.
+
+
+
Returns
A reference to the newly created component.
+ +

Definition at line 566 of file registry.hpp.

+ +
+ + +

◆ attachee()

@@ -535,7 +576,7 @@ template<typename Tag >
-inlinenoexcept +inline
@@ -551,12 +592,12 @@ template<typename Tag >
Returns
A valid entity identifier.
-

Definition at line 638 of file registry.hpp.

+

Definition at line 871 of file registry.hpp.

- -

◆ capacity()

+ +

◆ capacity()

@@ -575,7 +616,7 @@ template<typename Entity>
-inlinenoexcept +inline
@@ -583,12 +624,107 @@ template<typename Entity>

Returns the number of entities ever created.

Returns
Number of entities ever created.
-

Definition at line 266 of file registry.hpp.

+

Definition at line 228 of file registry.hpp.

- -

◆ component()

+ +

◆ clone()

+ +
+
+
+template<typename Entity>
+ + + + + +
+ + + + + + + + +
entity_type entt::Registry< Entity >::clone (const entity_type entity)
+ 		+inline
+
+ +

Clones an entity and returns the newly created one.

+

There are two kinds of entity identifiers:

+
    +
  • Newly created ones in case no entities have been previously destroyed.
    • +
  • Recycled ones with updated versions.
    • +
+

Users should not care about the type of the returned entity identifier. In case entity identifers are stored around, the valid member function can be used to know if they are still valid or the entity has been destroyed and potentially recycled.

+
Warning
In case there are listeners that observe the construction of components and assign other components to the entity in their bodies, the result of invoking this function may not be as expected. In the worst case, it could lead to undefined behavior. An assertion will abort the execution at runtime in debug mode if a violation is detected.
+
+Attempting to clone an invalid entity results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode in case of invalid entity.
+
Parameters
+ + +
entityA valid entity identifier
+
+
+
Returns
A valid entity identifier.
+ +

Definition at line 439 of file registry.hpp.

+ +
+
+ +

◆ construction() [1/2]

+ +
+
+
+template<typename Entity>
+
+template<typename Tag >
+ + + + + +
+ + + + + + + + +
sink_type entt::Registry< Entity >::construction (tag_t )
+ 		+inline
+
+ +

Returns a sink object for the given tag.

+

A sink is an opaque object used to connect listeners to tags.
+ The sink returned by this function can be used to receive notifications whenever a new instance of the given tag is created and assigned to an entity.

+

The function type for a listener is:

void(Registry<Entity> &, Entity);

Listeners are invoked after the tag has been assigned to the entity. The order of invocation of the listeners isn't guaranteed.
+ Note also that the greater the number of listeners, the greater the performance hit when a new tag is created.

+
See also
SigH::Sink
+
Template Parameters
+ + +
TagType of tag of which to get the sink.
+
+
+
Returns
A temporary sink object.
+ +

Definition at line 936 of file registry.hpp.

+ +
+
+ +

◆ construction() [2/2]

@@ -601,36 +737,39 @@ template<typename Component >
- + - +
component_type entt::Registry< Entity >::component sink_type entt::Registry< Entity >::construction ( ) const
-inlinenoexcept +inline
-

Returns the numeric identifier of a type of component at runtime.

-

The given component doesn't need to be necessarily in use. However, the registry could decide to prepare internal data structures for it for later uses.
- Do not use this functionality to provide numeric identifiers to types at runtime.

+

Returns a sink object for the given component.

+

A sink is an opaque object used to connect listeners to components.
+ The sink returned by this function can be used to receive notifications whenever a new instance of the given component is created and assigned to an entity.

+

The function type for a listener is:

void(Registry<Entity> &, Entity);

Listeners are invoked after the component has been assigned to the entity. The order of invocation of the listeners isn't guaranteed.
+ Note also that the greater the number of listeners, the greater the performance hit when a new component is created.

+
See also
SigH::Sink
Template Parameters
- +
ComponentType of component to query.
ComponentType of component of which to get the sink.
-
Returns
Runtime numeric identifier of the given type of component.
+
Returns
A temporary sink object.
-

Definition at line 214 of file registry.hpp.

+

Definition at line 965 of file registry.hpp.

- -

◆ contains()

+ +

◆ contains()

@@ -651,7 +790,7 @@ template<typename... Component>
-inlinenoexcept +inline
@@ -665,113 +804,12 @@ template<typename... Component>
Returns
True if the view has already been prepared, false otherwise.
-

Definition at line 1159 of file registry.hpp.

+

Definition at line 1385 of file registry.hpp.

- -

◆ create() [1/3]

- -
-
-
-template<typename Entity>
-
-template<typename... Component>
- - - - - -
- - - - - - - - -
entity_type entt::Registry< Entity >::create (Component &&... components)
- 		-inlinenoexcept
-
- -

Returns a new entity initialized with the given components.

-

There are two kinds of entity identifiers:

-
    -
  • Newly created ones in case no entities have been previously destroyed.
    • -
  • Recycled one with updated versions.
    • -
-

Users should not care about the type of the returned entity identifier. In case entity identifers are stored around, the current member function can be used to know if they are still valid or the entity has been destroyed and potentially recycled.

-

The returned entity has fully initialized components assigned.

-
Template Parameters
- - -
ComponentA list of components to assign to the entity.
-
-
-
Parameters
- - -
componentsInstances with which to initialize components.
-
-
-
Returns
A valid entity identifier.
- -

Definition at line 375 of file registry.hpp.

- -
-
- -

◆ create() [2/3]

- -
-
-
-template<typename Entity>
-
-template<typename... Component>
- - - - - -
- - - - - - - -
entity_type entt::Registry< Entity >::create ()
- 		-inlinenoexcept
-
- -

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

-

There are two kinds of entity identifiers:

-
    -
  • Newly created ones in case no entities have been previously destroyed.
    • -
  • Recycled one with updated versions.
    • -
-

Users should not care about the type of the returned entity identifier. In case entity identifers are stored around, the current member function can be used to know if they are still valid or the entity has been destroyed and potentially recycled.

-

The returned entity has default initialized components assigned.

-
Template Parameters
- - -
ComponentA list of components to assign to the entity.
-
-
-
Returns
A valid entity identifier.
- -

Definition at line 402 of file registry.hpp.

- -
-
- -

◆ create() [3/3]

+ +

◆ create()

@@ -790,7 +828,7 @@ template<typename Entity>
-inlinenoexcept +inline
@@ -799,18 +837,18 @@ template<typename Entity>

There are two kinds of entity identifiers:

  • Newly created ones in case no entities have been previously destroyed.
    • -
  • Recycled one with updated versions.
    • +
  • Recycled ones with updated versions.
-

Users should not care about the type of the returned entity identifier. In case entity identifers are stored around, the current member function can be used to know if they are still valid or the entity has been destroyed and potentially recycled.

+

Users should not care about the type of the returned entity identifier. In case entity identifers are stored around, the valid member function can be used to know if they are still valid or the entity has been destroyed and potentially recycled.

The returned entity has no components assigned.

Returns
A valid entity identifier.
-

Definition at line 427 of file registry.hpp.

+

Definition at line 390 of file registry.hpp.

- -

◆ current()

+ +

◆ current()

@@ -823,14 +861,14 @@ template<typename Entity>
version_type entt::Registry< Entity >::current ( - entity_type  + const entity_type  entity) const -inlinenoexcept +inline
@@ -847,12 +885,54 @@ template<typename Entity>
Returns
Actual version for the given entity identifier.
-

Definition at line 349 of file registry.hpp.

+

Definition at line 367 of file registry.hpp.

- -

◆ destroy()

+ +

◆ data()

+ +
+
+
+template<typename Entity>
+
+template<typename Component >
+ + + + + +
+ + + + + + + +
const entity_type* entt::Registry< Entity >::data () const
+ 		+inline
+
+ +

Direct access to the list of entities of a given pool.

+

The returned pointer is such that range [data<Component>(), data<Component>() + size<Component>()] is always a valid range, even if the container is empty.

+
Note
There are no guarantees on the order of the entities. Use a view if you want to iterate entities and components in the expected order.
+
Template Parameters
+ + +
ComponentType of component in which one is interested.
+
+
+
Returns
A pointer to the array of entities.
+ +

Definition at line 304 of file registry.hpp.

+ +
+
+ +

◆ destroy()

@@ -865,7 +945,7 @@ template<typename Entity>
void entt::Registry< Entity >::destroy ( - entity_type  + const entity_type  entity) @@ -878,8 +958,10 @@ template<typename Entity>

Destroys an entity and lets the registry recycle the identifier.

-

When an entity is destroyed, its version is updated and the identifier can be recycled at any time. In case entity identifers are stored around, the current member 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 invalid entity results in undefined behavior.
+

When an entity is destroyed, its version is updated and the identifier can be recycled at any time. In case entity identifers are stored around, the valid member function can be used to know if they are still valid or the entity has been destroyed and potentially recycled.

+
Warning
In case there are listeners that observe the destruction of components and assign other components to the entity in their bodies, the result of invoking this function may not be as expected. In the worst case, it could lead to undefined behavior. An assertion will abort the execution at runtime in debug mode if a violation is detected.
+
+Attempting to use an invalid entity results in undefined behavior.
An assertion will abort the execution at runtime in debug mode in case of invalid entity.
Parameters
@@ -888,7 +970,98 @@ template<typename Entity> -

Definition at line 462 of file registry.hpp.

+

Definition at line 478 of file registry.hpp.

+ + + + +

◆ destruction() [1/2]

+ +
+
+
+template<typename Entity>
+
+template<typename Tag >
+
+ + + + +
+ + + + + + + + +
sink_type entt::Registry< Entity >::destruction (tag_t )
+ 		+inline
+
+ +

Returns a sink object for the given tag.

+

A sink is an opaque object used to connect listeners to tag.
+ The sink returned by this function can be used to receive notifications whenever an instance of the given tag is removed from an entity and thus destroyed.

+

The function type for a listener is:

void(Registry<Entity> &, Entity);

Listeners are invoked before the tag has been removed from the entity. The order of invocation of the listeners isn't guaranteed.
+ Note also that the greater the number of listeners, the greater the performance hit when a tag is destroyed.

+
See also
SigH::Sink
+
Template Parameters
+ + +
TagType of tag of which to get the sink.
+
+
+
Returns
A temporary sink object.
+ +

Definition at line 994 of file registry.hpp.

+ +
+ + +

◆ destruction() [2/2]

+ +
+
+
+template<typename Entity>
+
+template<typename Component >
+ + + + + +
+ + + + + + + +
sink_type entt::Registry< Entity >::destruction ()
+ 		+inline
+
+ +

Returns a sink object for the given component.

+

A sink is an opaque object used to connect listeners to components.
+ The sink returned by this function can be used to receive notifications whenever an instance of the given component is removed from an entity and thus destroyed.

+

The function type for a listener is:

void(Registry<Entity> &, Entity);

Listeners are invoked before the component has been removed from the entity. The order of invocation of the listeners isn't guaranteed.
+ Note also that the greater the number of listeners, the greater the performance hit when a component is destroyed.

+
See also
SigH::Sink
+
Template Parameters
+ + +
ComponentType of component of which to get the sink.
+
+
+
Returns
A temporary sink object.
+ +

Definition at line 1023 of file registry.hpp.

@@ -921,7 +1094,7 @@ template<typename... Component>

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.

+ This function can be used to discard all the internal data structures dedicated to a specific persistent view, with the goal of reducing the memory pressure.

Warning
Attempting to use a persistent view created before calling this function results in undefined behavior. No assertion available in this case, neither in debug mode nor in release mode.
Template Parameters
@@ -930,7 +1103,7 @@ template<typename... Component> -

Definition at line 1141 of file registry.hpp.

+

Definition at line 1361 of file registry.hpp.

@@ -965,7 +1138,7 @@ template<typename Func >

Iterates all the entities that are still in use.

The function object is invoked for each entity that is still in use.
The signature of the function should be equivalent to the following:

-
void(entity_type);

This function is fairly slow and should not be used frequently.
+

void(const entity_type);

This function is fairly slow and should not be used frequently.
Consider using a view if the goal is to iterate entities that have a determinate set of components. A view is usually faster than combining this function with a bunch of custom tests.
On the other side, this function can be used to iterate all the entities that are in use, regardless of their components.

Template Parameters
@@ -981,12 +1154,12 @@ template<typename Func >
-

Definition at line 997 of file registry.hpp.

+

Definition at line 1193 of file registry.hpp.

- -

◆ empty() [1/2]

+ +

◆ empty() [1/2]

@@ -1007,7 +1180,7 @@ template<typename Component >
-inlinenoexcept +inline
@@ -1021,12 +1194,12 @@ template<typename Component >
Returns
True if the pool for the given component is empty, false otherwise.
-

Definition at line 277 of file registry.hpp.

+

Definition at line 239 of file registry.hpp.

- -

◆ empty() [2/2]

+ +

◆ empty() [2/2]

@@ -1045,7 +1218,7 @@ template<typename Entity>
-inlinenoexcept +inline
@@ -1053,12 +1226,12 @@ 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 285 of file registry.hpp.

+

Definition at line 247 of file registry.hpp.

- -

◆ fast()

+ +

◆ fast()

@@ -1071,14 +1244,14 @@ template<typename Entity>
bool entt::Registry< Entity >::fast ( - entity_type  + const entity_type  entity) const -inlinenoexcept +inline
@@ -1096,12 +1269,12 @@ template<typename Entity>
Returns
True if the identifier is valid, false otherwise.
-

Definition at line 316 of file registry.hpp.

+

Definition at line 335 of file registry.hpp.

- -

◆ get() [1/6]

+ +

◆ get() [1/6]

@@ -1122,7 +1295,7 @@ template<typename Tag >
-inlinenoexcept +inline
@@ -1138,12 +1311,12 @@ template<typename Tag >
Returns
A reference to the tag.
-

Definition at line 554 of file registry.hpp.

+

Definition at line 682 of file registry.hpp.

- -

◆ get() [2/6]

+ +

◆ get() [2/6]

@@ -1164,7 +1337,7 @@ template<typename Tag >
-inlinenoexcept +inline
@@ -1180,12 +1353,12 @@ template<typename Tag >
Returns
A reference to the tag.
-

Definition at line 572 of file registry.hpp.

+

Definition at line 700 of file registry.hpp.

- -

◆ get() [3/6]

+ +

◆ get() [3/6]

@@ -1200,14 +1373,14 @@ template<typename Component >
const Component& entt::Registry< Entity >::get ( - entity_type  + const entity_type  entity) const -inlinenoexcept +inline
@@ -1229,12 +1402,12 @@ template<typename Component >
Returns
A reference to the component owned by the entity.
-

Definition at line 725 of file registry.hpp.

+

Definition at line 719 of file registry.hpp.

- -

◆ get() [4/6]

+ +

◆ get() [4/6]

@@ -1249,14 +1422,14 @@ template<typename Component >
Component& entt::Registry< Entity >::get ( - entity_type  + const entity_type  entity) -inlinenoexcept +inline
@@ -1278,12 +1451,12 @@ template<typename Component >
Returns
A reference to the component owned by the entity.
-

Definition at line 745 of file registry.hpp.

+

Definition at line 740 of file registry.hpp.

- -

◆ get() [5/6]

+ +

◆ get() [5/6]

@@ -1298,14 +1471,14 @@ template<typename... Component>
std::enable_if_t<(sizeof...(Component) > 1), std::tuple<const Component &...> > entt::Registry< Entity >::get ( - entity_type  + const entity_type  entity) const -inlinenoexcept +inline
@@ -1327,12 +1500,12 @@ template<typename... Component>
Returns
References to the components owned by the entity.
-

Definition at line 765 of file registry.hpp.

+

Definition at line 760 of file registry.hpp.

- -

◆ get() [6/6]

+ +

◆ get() [6/6]

@@ -1347,14 +1520,14 @@ template<typename... Component>
std::enable_if_t<(sizeof...(Component) > 1), std::tuple<Component &...> > entt::Registry< Entity >::get ( - entity_type  + const entity_type  entity) -inlinenoexcept +inline
@@ -1376,12 +1549,12 @@ template<typename... Component>
Returns
References to the components owned by the entity.
-

Definition at line 785 of file registry.hpp.

+

Definition at line 780 of file registry.hpp.

- -

◆ has() [1/2]

+ +

◆ has() [1/3]

@@ -1402,7 +1575,7 @@ template<typename Tag >
-inlinenoexcept +inline
@@ -1416,12 +1589,70 @@ template<typename Tag >
Returns
True if the tag already has an owner, false otherwise.
-

Definition at line 532 of file registry.hpp.

+

Definition at line 616 of file registry.hpp.

- -

◆ has() [2/2]

+ +

◆ has() [2/3]

+ +
+
+
+template<typename Entity>
+
+template<typename Tag >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool entt::Registry< Entity >::has (tag_t ,
const entity_type entity 
) const
+ 		+inline
+
+ +

Checks if an entity owns the given tag.

+

Syntactic sugar for the following snippet:

+
registry.has<Tag>() && registry.attachee<Tag>() == entity
Template Parameters
+ + +
TagType of tag for which to perform the check.
+
+
+
Parameters
+ + +
entityA valid entity identifier.
+
+
+
Returns
True if the entity owns the tag, false otherwise.
+ +

Definition at line 643 of file registry.hpp.

+ +
+
+ +

◆ has() [3/3]

@@ -1436,14 +1667,14 @@ template<typename... Component>
bool entt::Registry< Entity >::has ( - entity_type  + const entity_type  entity) const -inlinenoexcept +inline
@@ -1465,12 +1696,12 @@ template<typename... Component>
Returns
True if the entity has all the components, false otherwise.
-

Definition at line 701 of file registry.hpp.

+

Definition at line 660 of file registry.hpp.

- -

◆ move()

+ +

◆ move()

@@ -1485,7 +1716,7 @@ template<typename Tag >
entity_type entt::Registry< Entity >::move ( - entity_type  + const entity_type  entity) @@ -1515,7 +1746,7 @@ template<typename Tag >
Returns
A valid entity identifier.
-

Definition at line 616 of file registry.hpp.

+

Definition at line 849 of file registry.hpp.

@@ -1581,8 +1812,8 @@ template<typename Entity> - -

◆ orphan()

+ +

◆ orphan()

@@ -1595,7 +1826,7 @@ template<typename Entity>
bool entt::Registry< Entity >::orphan ( - entity_type  + const entity_type  entity) const @@ -1617,7 +1848,7 @@ template<typename Entity>
Returns
True if the entity is an orphan, false otherwise.
-

Definition at line 1024 of file registry.hpp.

+

Definition at line 1220 of file registry.hpp.

@@ -1652,7 +1883,7 @@ template<typename Func >

Iterates orphans and applies them the given function object.

The function object is invoked for each entity that is still in use and has neither assigned components nor tags.
The signature of the function should be equivalent to the following:

-
void(entity_type);

This function can be very slow and should not be used frequently.

+
void(const entity_type);

This function can be very slow and should not be used frequently.

Template Parameters
@@ -1666,65 +1897,7 @@ template<typename Func > -

Definition at line 1058 of file registry.hpp.

- - - - -

◆ persistent()

- -
-
-
-template<typename Entity>
-
-template<typename... Component>
-
FuncType of the function object to invoke.
- - - - -
- - - - - - - -
PersistentView<Entity, Component...> entt::Registry< Entity >::persistent ()
- 		-inline
-
- -

Returns a persistent view for the given components.

-

This kind of views are created on the fly and share with the registry its internal data structures.
- Feel free to discard a view after the use. Creating and destroying a view is an incredibly cheap operation because they do not require any type of initialization.
- As a rule of thumb, storing a view should never be an option.

-

Persistent views are the right choice to iterate entities when the number of components grows up and the most of the entities have all the given components.
- However they have also drawbacks:

-
    -
  • Each kind of persistent view requires a dedicated data structure that is allocated within the registry and it increases memory pressure.
    • -
  • Internal data structures used to construct persistent views must be kept updated and it affects slightly construction and destruction of entities and components.
    • -
-

That being said, persistent views are an incredibly powerful tool if used with care and offer a boost of performance undoubtedly.

-
Note
Consider to use the prepare member function to initialize the internal data structures used by persistent views when the registry is still empty. Initialization could be a costly operation otherwise and it will be performed the very first time each view is created.
-
See also
View
-
-View<Entity, Component>
-
-PersistentView
-
-RawView
-
Template Parameters
- - -
ComponentTypes of components used to construct the view.
-
-
-
Returns
A newly created persistent view.
- -

Definition at line 1204 of file registry.hpp.

+

Definition at line 1254 of file registry.hpp.

@@ -1766,12 +1939,12 @@ template<typename... Component>
-

Definition at line 1121 of file registry.hpp.

+

Definition at line 1317 of file registry.hpp.

- -

◆ raw()

+ +

◆ raw() [1/2]

@@ -1784,7 +1957,49 @@ template<typename Component >
- + + + + + +
RawView<Entity, Component> entt::Registry< Entity >::raw const Component* entt::Registry< Entity >::raw () const
+ + +inline + + +
+ +

Direct access to the list of components of a given pool.

+

The returned pointer is such that range [raw<Component>(), raw<Component>() + size<Component>()] is always a valid range, even if the container is empty.

+
Note
There are no guarantees on the order of the components. Use a view if you want to iterate entities and components in the expected order.
+
Template Parameters
+ + +
ComponentType of component in which one is interested.
+
+
+
Returns
A pointer to the array of components of the given type.
+ +

Definition at line 266 of file registry.hpp.

+ +
+ + +

◆ raw() [2/2]

+ +
+
+
+template<typename Entity>
+
+template<typename Component >
+ + + - + @@ -1904,12 +2110,73 @@ template<typename Component > -

Definition at line 683 of file registry.hpp.

+

Definition at line 602 of file registry.hpp.

- -

◆ replace()

+ +

◆ replace() [1/2]

+ +
+
+
+template<typename Entity>
+
+template<typename Tag , typename... Args>
+
+ + + @@ -1797,27 +2012,18 @@ template<typename Component >
Component* entt::Registry< Entity >::raw ( )
-

Returns a raw view for the given component.

-

This kind of views are created on the fly and share with the registry its internal data structures.
- Feel free to discard a view after the use. Creating and destroying a view is an incredibly cheap operation because they do not require any type of initialization.
- As a rule of thumb, storing a view should never be an option.

-

Raw views are incredibly fast and must be considered the best tool to iterate components whenever knowing the entities to which they belong isn't required.

-
See also
View
-
-View<Entity, Component>
-
-PersistentView
-
-RawView
+

Direct access to the list of components of a given pool.

+

The returned pointer is such that range [raw<Component>(), raw<Component>() + size<Component>()] is always a valid range, even if the container is empty.

+
Note
There are no guarantees on the order of the components. Use a view if you want to iterate entities and components in the expected order.
Template Parameters
- +
ComponentType of component used to construct the view.
ComponentType of component in which one is interested.
-
Returns
A newly created raw view.
+
Returns
A pointer to the array of components of the given type.
-

Definition at line 1232 of file registry.hpp.

+

Definition at line 285 of file registry.hpp.

@@ -1856,12 +2062,12 @@ template<typename Tag > -

Definition at line 520 of file registry.hpp.

+

Definition at line 579 of file registry.hpp.

- -

◆ remove() [2/2]

+ +

◆ remove() [2/2]

@@ -1876,7 +2082,7 @@ template<typename Component >
void entt::Registry< Entity >::remove (entity_type const entity_type  entity)
+ + + + +
+ + + + + + + + + + + + + + + + + + +
Tag& entt::Registry< Entity >::replace (tag_t ,
Args &&... args 
)
+ 		+inline
+
+ +

Replaces the given tag.

+

A new instance of the given tag is created and initialized with the arguments provided (the tag must have a proper constructor or be of aggregate type).

+
Warning
Attempting to replace a tag that hasn't an owner results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode if the tag hasn't been previously attached to an entity.
+
Template Parameters
+ + + +
TagType of tag to replace.
ArgsTypes of arguments to use to construct the tag.
+
+
+
Parameters
+ + +
argsParameters to use to initialize the tag.
+
+
+
Returns
A reference to the tag.
+ +

Definition at line 803 of file registry.hpp.

+ +
+
+ +

◆ replace() [2/2]

@@ -1924,7 +2191,7 @@ template<typename Component , typename... Args>
Component& entt::Registry< Entity >::replace ( - entity_type  + const entity_type  entity, @@ -1966,12 +2233,12 @@ template<typename Component , typename... Args>
Returns
A reference to the newly created component.
-

Definition at line 810 of file registry.hpp.

+

Definition at line 828 of file registry.hpp.

- -

◆ reserve() [1/2]

+ +

◆ reserve() [1/2]

@@ -1986,7 +2253,7 @@ template<typename Component >
void entt::Registry< Entity >::reserve ( - size_type  + const size_type  cap) @@ -2013,12 +2280,12 @@ template<typename Component >
-

Definition at line 246 of file registry.hpp.

+

Definition at line 207 of file registry.hpp.

- -

◆ reserve() [2/2]

+ +

◆ reserve() [2/2]

@@ -2031,7 +2298,7 @@ template<typename Entity>
void entt::Registry< Entity >::reserve ( - size_type  + const size_type  cap) @@ -2052,12 +2319,12 @@ template<typename Entity>
-

Definition at line 258 of file registry.hpp.

+

Definition at line 220 of file registry.hpp.

- -

◆ reset() [1/3]

+ +

◆ reset() [1/3]

@@ -2072,7 +2339,7 @@ template<typename Component >
void entt::Registry< Entity >::reset ( - entity_type  + const entity_type  entity) @@ -2101,7 +2368,7 @@ template<typename Component >
-

Definition at line 929 of file registry.hpp.

+

Definition at line 1125 of file registry.hpp.

@@ -2141,7 +2408,7 @@ template<typename Component > -

Definition at line 950 of file registry.hpp.

+

Definition at line 1146 of file registry.hpp.

@@ -2171,9 +2438,9 @@ template<typename Entity>

Resets a whole registry.

-

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

+

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

-

Definition at line 970 of file registry.hpp.

+

Definition at line 1166 of file registry.hpp.

@@ -2206,65 +2473,14 @@ template<typename Entity>

A snapshot is either a full or a partial dump of a registry.
It can be used to save and restore its internal state or to keep two or more instances of this class in sync, as an example in a client-server architecture.

Warning
The loader returned by this function requires that the registry be empty. In case it isn't, all the data will be automatically deleted before to return.
-
Returns
A not movable and not copyable object to use to load snasphosts.
+
Returns
A temporary object to use to load snasphosts.
-

Definition at line 1281 of file registry.hpp.

+

Definition at line 1503 of file registry.hpp.

- -

◆ set()

- -
-
-
-template<typename Entity>
-
-template<typename Tag , typename... Args>
- - - - - -
- - - - - - - - -
Tag& entt::Registry< Entity >::set (Args &&... args)
- 		-inline
-
- -

Replaces the given tag.

-

A new instance of the given tag is created and initialized with the arguments provided (the tag must have a proper constructor or be of aggregate type).

-
Warning
Attempting to replace a tag that hasn't an owner results in undefined behavior.
- An assertion will abort the execution at runtime in debug mode if the tag hasn't been previously attached to an entity.
-
Template Parameters
- - - -
TagType of tag to replace.
ArgsTypes of arguments to use to construct the tag.
-
-
-
Parameters
- - -
argsParameters to use to initialize the tag.
-
-
-
Returns
A reference to the tag.
- -

Definition at line 595 of file registry.hpp.

- -
-
- -

◆ size() [1/2]

+ +

◆ size() [1/2]

@@ -2285,7 +2501,7 @@ template<typename Component >
-inlinenoexcept +inline
@@ -2299,12 +2515,12 @@ template<typename Component >
Returns
Number of existing components of the given type.
-

Definition at line 224 of file registry.hpp.

+

Definition at line 185 of file registry.hpp.

- -

◆ size() [2/2]

+ +

◆ size() [2/2]

@@ -2323,7 +2539,7 @@ template<typename Entity>
-inlinenoexcept +inline
@@ -2331,7 +2547,7 @@ template<typename Entity>

Returns the number of entities still in use.

Returns
Number of entities still in use.
-

Definition at line 232 of file registry.hpp.

+

Definition at line 193 of file registry.hpp.

@@ -2363,21 +2579,21 @@ template<typename Entity>

Returns a temporary object to use to create snapshots.

A snapshot is either a full or a partial dump of a registry.
It can be used to save and restore its internal state or to keep two or more instances of this class in sync, as an example in a client-server architecture.

-
Returns
A not movable and not copyable object to use to take snasphosts.
+
Returns
A temporary object to use to take snasphosts.
-

Definition at line 1246 of file registry.hpp.

+

Definition at line 1474 of file registry.hpp.

- -

◆ sort() [1/2]

+ +

◆ sort() [1/2]

template<typename Entity>
-template<typename Component , typename Compare >
+template<typename Component , typename Compare , typename Sort = StdSort>
- + + + + + + + + + + +
@@ -2386,8 +2602,18 @@ template<typename Component , typename Compare > void entt::Registry< Entity >::sort ( Compare compare)compare,
Sort sort = Sort{} 
)
@@ -2401,21 +2627,31 @@ template<typename Component , typename Compare >

The order of the elements in a pool is highly affected by assignments of components to entities and deletions. Components are arranged to maximize the performance during iterations and users should not make any assumption on the order.
This function can be used to impose an order to the elements in the pool 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(const Component &, const Component &)
Template Parameters
+
bool(const Component &, const Component &)

Moreover, the comparison function object shall induce a strict weak ordering on the values.

+

The sort function oject must offer a member function template operator() that accepts three arguments:

+
    +
  • An iterator to the first element of the range to sort.
    • +
  • An iterator past the last element of the range to sort.
    • +
  • A comparison function to use to compare the elements.
    • +
+

The comparison funtion object received by the sort function object hasn't necessarily the type of the one passed along with the other parameters to this member function.

+
Template Parameters
+
ComponentType of components to sort.
CompareType of comparison function object.
SortType of sort function object.
Parameters
+
compareA valid comparison function object.
sortA valid sort function object.
-

Definition at line 875 of file registry.hpp.

+

Definition at line 1068 of file registry.hpp.

@@ -2464,12 +2700,12 @@ template<typename To , typename From >
-

Definition at line 910 of file registry.hpp.

+

Definition at line 1104 of file registry.hpp.

- -

◆ tag()

+ +

◆ type() [1/2]

@@ -2482,15 +2718,16 @@ template<typename Tag >
- + + - +
tag_type entt::Registry< Entity >::tag static tag_type entt::Registry< Entity >::type (tag_t  ) const
-inlinenoexcept +inlinestatic
@@ -2506,12 +2743,54 @@ template<typename Tag >
Returns
Runtime numeric identifier of the given type of tag.
-

Definition at line 197 of file registry.hpp.

+

Definition at line 158 of file registry.hpp.

- -

◆ valid()

+ +

◆ type() [2/2]

+ +
+
+
+template<typename Entity>
+
+template<typename Component >
+ + + + + +
+ + + + + + + +
static component_type entt::Registry< Entity >::type ()
+ 		+inlinestatic
+
+ +

Returns the numeric identifier of a type of component at runtime.

+

The given component doesn't need to be necessarily in use. However, the registry could decide to prepare internal data structures for it for later uses.
+ Do not use this functionality to provide numeric identifiers to types at runtime.

+
Template Parameters
+ + +
ComponentType of component to query.
+
+
+
Returns
Runtime numeric identifier of the given type of component.
+ +

Definition at line 175 of file registry.hpp.

+ +
+
+ +

◆ valid()

@@ -2524,14 +2803,14 @@ template<typename Entity>
bool entt::Registry< Entity >::valid ( - entity_type  + const entity_type  entity) const -inlinenoexcept +inline
@@ -2545,12 +2824,12 @@ template<typename Entity>
Returns
True if the identifier is valid, false otherwise.
-

Definition at line 294 of file registry.hpp.

+

Definition at line 313 of file registry.hpp.

- -

◆ version()

+ +

◆ version()

@@ -2563,14 +2842,14 @@ template<typename Entity>
version_type entt::Registry< Entity >::version ( - entity_type  + const entity_type  entity) const -inlinenoexcept +inline
@@ -2584,12 +2863,12 @@ template<typename Entity>
Returns
Version stored along with the given entity identifier.
-

Definition at line 328 of file registry.hpp.

+

Definition at line 346 of file registry.hpp.

-

◆ view()

+

◆ view() [1/3]

@@ -2641,7 +2920,118 @@ template<typename... Component>
Returns
A newly created standard view.
-

Definition at line 1100 of file registry.hpp.

+

Definition at line 1296 of file registry.hpp.

+ +
+ + +

◆ view() [2/3]

+ +
+
+
+template<typename Entity>
+
+template<typename... Component>
+ + + + + +
+ + + + + + + + +
PersistentView<Entity, Component...> entt::Registry< Entity >::view (persistent_t )
+ 		+inline
+
+ +

Returns a persistent view for the given components.

+

This kind of views are created on the fly and share with the registry its internal data structures.
+ Feel free to discard a view after the use. Creating and destroying a view is an incredibly cheap operation because they do not require any type of initialization.
+ As a rule of thumb, storing a view should never be an option.

+

Persistent views are the right choice to iterate entities when the number of components grows up and the most of the entities have all the given components.
+ However they have also drawbacks:

+
    +
  • Each kind of persistent view requires a dedicated data structure that is allocated within the registry and it increases memory pressure.
    • +
  • Internal data structures used to construct persistent views must be kept updated and it affects slightly construction and destruction of entities and components.
    • +
+

That being said, persistent views are an incredibly powerful tool if used with care and offer a boost of performance undoubtedly.

+
Note
Consider to use the prepare member function to initialize the internal data structures used by persistent views when the registry is still empty. Initialization could be a costly operation otherwise and it will be performed the very first time each view is created.
+
See also
View
+
+View<Entity, Component>
+
+PersistentView
+
+RawView
+
Template Parameters
+ + +
ComponentTypes of components used to construct the view.
+
+
+
Returns
A newly created persistent view.
+ +

Definition at line 1430 of file registry.hpp.

+ +
+
+ +

◆ view() [3/3]

+ +
+
+
+template<typename Entity>
+
+template<typename Component >
+ + + + + +
+ + + + + + + + +
RawView<Entity, Component> entt::Registry< Entity >::view (raw_t )
+ 		+inline
+
+ +

Returns a raw view for the given component.

+

This kind of views are created on the fly and share with the registry its internal data structures.
+ Feel free to discard a view after the use. Creating and destroying a view is an incredibly cheap operation because they do not require any type of initialization.
+ As a rule of thumb, storing a view should never be an option.

+

Raw views are incredibly fast and must be considered the best tool to iterate components whenever knowing the entities to which they belong isn't required.

+
See also
View
+
+View<Entity, Component>
+
+PersistentView
+
+RawView
+
Template Parameters
+ + +
ComponentType of component used to construct the view.
+
+
+
Returns
A newly created raw view.
+ +

Definition at line 1459 of file registry.hpp.

diff --git a/classentt_1_1ResourceCache-members.html b/classentt_1_1ResourceCache-members.html index d6d98913c..b97e73d0c 100644 --- a/classentt_1_1ResourceCache-members.html +++ b/classentt_1_1ResourceCache-members.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -70,20 +70,20 @@ $(function() {

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
clear() ENTT_NOEXCEPTentt::ResourceCache< Resource >inline
contains(const resource_type id) const ENTT_NOEXCEPTentt::ResourceCache< Resource >inline
discard(const resource_type id) ENTT_NOEXCEPTentt::ResourceCache< Resource >inline
empty() const ENTT_NOEXCEPTentt::ResourceCache< Resource >inline
handle(const resource_type id) constentt::ResourceCache< Resource >inline
load(const resource_type id, Args &&... args)entt::ResourceCache< Resource >inline
operator=(const ResourceCache &) ENTT_NOEXCEPT=deleteentt::ResourceCache< Resource >
operator=(ResourceCache &&) ENTT_NOEXCEPT=defaultentt::ResourceCache< Resource >
reload(const resource_type id, Args &&... args)entt::ResourceCache< Resource >inline
resource_type typedefentt::ResourceCache< Resource >
ResourceCache()=defaultentt::ResourceCache< Resource >
ResourceCache(const ResourceCache &) noexcept=deleteentt::ResourceCache< Resource >
ResourceCache(ResourceCache &&) noexcept=defaultentt::ResourceCache< Resource >
size() const noexceptentt::ResourceCache< Resource >inline
ResourceCache(const ResourceCache &) ENTT_NOEXCEPT=deleteentt::ResourceCache< Resource >
ResourceCache(ResourceCache &&) ENTT_NOEXCEPT=defaultentt::ResourceCache< Resource >
size() const ENTT_NOEXCEPTentt::ResourceCache< Resource >inline
size_type typedefentt::ResourceCache< Resource >
temp(Args &&... args) constentt::ResourceCache< Resource >inline
diff --git a/classentt_1_1ResourceCache.html b/classentt_1_1ResourceCache.html index b73c9b2a0..9da373d6a 100644 --- a/classentt_1_1ResourceCache.html +++ b/classentt_1_1ResourceCache.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -94,50 +94,50 @@ 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 a given identifier. More...
-  -template<typename Loader , typename... Args> -bool reload (resource_type id, Args &&... args) - Reloads a resource or loads it for the first time if not present. More...
-  + + ResourceCache (const ResourceCache &) ENTT_NOEXCEPT=delete + Copying a cache isn't allowed.
+  + + ResourceCache (ResourceCache &&) ENTT_NOEXCEPT=default + Default move constructor.
+  +ResourceCache & operator= (const ResourceCache &) ENTT_NOEXCEPT=delete + Copying a cache isn't allowed. More...
+  +ResourceCache & operator= (ResourceCache &&) ENTT_NOEXCEPT=default + Default move assignment operator. More...
+  +size_type size () const ENTT_NOEXCEPT + Number of resources managed by a cache. More...
+  +bool empty () const ENTT_NOEXCEPT + Returns true if a cache contains no resources, false otherwise. More...
+  +void clear () ENTT_NOEXCEPT + Clears a cache and discards all its resources. More...
+  +template<typename Loader , typename... Args> +bool load (const resource_type id, Args &&... args) + Loads the resource that corresponds to a given identifier. More...
+  +template<typename Loader , typename... Args> +bool reload (const resource_type id, Args &&... args) + Reloads a resource or loads it for the first time if not present. More...
+  template<typename Loader , typename... Args> ResourceHandle< Resource > temp (Args &&... args) const  Creates a temporary handle for a resource. More...
  -ResourceHandle< Resource > handle (resource_type id) const - Creates a handle for a given resource identifier. More...
-  -bool contains (resource_type id) const noexcept - Checks if a cache contains a given identifier. More...
-  -void discard (resource_type id) noexcept - Discards the resource that corresponds to a given identifier. More...
-  +ResourceHandle< Resource > handle (const resource_type id) const + Creates a handle for a given resource identifier. More...
+  +bool contains (const resource_type id) const ENTT_NOEXCEPT + Checks if a cache contains a given identifier. More...
+  +void discard (const resource_type id) ENTT_NOEXCEPT + Discards the resource that corresponds to a given identifier. More...
+ 

Detailed Description

template<typename Resource>
@@ -152,10 +152,10 @@ class entt::ResourceCache< Resource >

-

Definition at line 28 of file cache.hpp.

+

Definition at line 29 of file cache.hpp.

Member Function Documentation

- -

◆ clear()

+ +

◆ clear()

@@ -174,7 +174,7 @@ template<typename Resource >
-inlinenoexcept +inline
@@ -182,12 +182,12 @@ template<typename Resource >

Clears a cache and discards all its resources.

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

-

Definition at line 72 of file cache.hpp.

+

Definition at line 73 of file cache.hpp.

- -

◆ contains()

+ +

◆ contains()

@@ -200,14 +200,14 @@ template<typename Resource >
bool entt::ResourceCache< Resource >::contains ( - resource_type  + const resource_type  id) const -inlinenoexcept +inline
@@ -221,12 +221,12 @@ template<typename Resource >
Returns
True if the cache contains the resource, false otherwise.
-

Definition at line 172 of file cache.hpp.

+

Definition at line 173 of file cache.hpp.

- -

◆ discard()

+ +

◆ discard()

@@ -239,14 +239,14 @@ template<typename Resource >
void entt::ResourceCache< Resource >::discard ( - resource_type  + const resource_type  id) -inlinenoexcept +inline
@@ -260,12 +260,12 @@ template<typename Resource >
-

Definition at line 184 of file cache.hpp.

+

Definition at line 185 of file cache.hpp.

- -

◆ empty()

+ +

◆ empty()

@@ -284,7 +284,7 @@ template<typename Resource >
-inlinenoexcept +inline
@@ -292,12 +292,12 @@ template<typename Resource >

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

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

Definition at line 62 of file cache.hpp.

+

Definition at line 63 of file cache.hpp.

- -

◆ handle()

+ +

◆ handle()

@@ -310,7 +310,7 @@ template<typename Resource >
ResourceHandle<Resource> entt::ResourceCache< Resource >::handle ( - resource_type  + const resource_type  id) const @@ -333,12 +333,12 @@ template<typename Resource >
Returns
A handle for the given resource.
-

Definition at line 162 of file cache.hpp.

+

Definition at line 163 of file cache.hpp.

- -

◆ load()

+ +

◆ load()

@@ -353,7 +353,7 @@ template<typename Loader , typename... Args>
bool entt::ResourceCache< Resource >::load ( - resource_type  + const resource_type  id, @@ -394,12 +394,12 @@ template<typename Loader , typename... Args>
Returns
True if the resource is ready to use, false otherwise.
-

Definition at line 95 of file cache.hpp.

+

Definition at line 96 of file cache.hpp.

- -

◆ operator=() [1/2]

+ +

◆ operator=() [1/2]

@@ -419,7 +419,7 @@ template<typename Resource >
-deletenoexcept +delete
@@ -429,8 +429,8 @@ template<typename Resource >
- -

◆ operator=() [2/2]

+ +

◆ operator=() [2/2]

@@ -450,7 +450,7 @@ template<typename Resource >
-defaultnoexcept +default
@@ -460,8 +460,8 @@ template<typename Resource >
- -

◆ reload()

+ +

◆ reload()

@@ -476,7 +476,7 @@ template<typename Loader , typename... Args>
bool entt::ResourceCache< Resource >::reload ( - resource_type  + const resource_type  id, @@ -517,12 +517,12 @@ template<typename Loader , typename... Args>
Returns
True if the resource is ready to use, false otherwise.
-

Definition at line 128 of file cache.hpp.

+

Definition at line 129 of file cache.hpp.

- -

◆ size()

+ +

◆ size()

@@ -541,7 +541,7 @@ template<typename Resource >
-inlinenoexcept +inline
@@ -549,7 +549,7 @@ template<typename Resource >

Number of resources managed by a cache.

Returns
Number of resources currently stored.
-

Definition at line 54 of file cache.hpp.

+

Definition at line 55 of file cache.hpp.

@@ -598,7 +598,7 @@ template<typename Loader , typename... Args>
Returns
A handle for the given resource.
-

Definition at line 145 of file cache.hpp.

+

Definition at line 146 of file cache.hpp.

diff --git a/classentt_1_1ResourceHandle-members.html b/classentt_1_1ResourceHandle-members.html index 1da4b9fd8..b5a2ecde6 100644 --- a/classentt_1_1ResourceHandle-members.html +++ b/classentt_1_1ResourceHandle-members.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -70,16 +70,16 @@ $(function() {

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

- + - - - - - + + + + + - - + +
get() const noexceptentt::ResourceHandle< Resource >inline
get() const ENTT_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 >
operator const Resource &() const ENTT_NOEXCEPTentt::ResourceHandle< Resource >inline
operator*() const ENTT_NOEXCEPTentt::ResourceHandle< Resource >inline
operator->() const ENTT_NOEXCEPTentt::ResourceHandle< Resource >inline
operator=(const ResourceHandle &) ENTT_NOEXCEPT=defaultentt::ResourceHandle< Resource >
operator=(ResourceHandle &&) ENTT_NOEXCEPT=defaultentt::ResourceHandle< Resource >
ResourceCache< Resource > classentt::ResourceHandle< Resource >friend
ResourceHandle(const ResourceHandle &) noexcept=defaultentt::ResourceHandle< Resource >
ResourceHandle(ResourceHandle &&) noexcept=defaultentt::ResourceHandle< Resource >
ResourceHandle(const ResourceHandle &) ENTT_NOEXCEPT=defaultentt::ResourceHandle< Resource >
ResourceHandle(ResourceHandle &&) ENTT_NOEXCEPT=defaultentt::ResourceHandle< Resource >
diff --git a/classentt_1_1ResourceHandle.html b/classentt_1_1ResourceHandle.html index ef08adde0..94f0c5a71 100644 --- a/classentt_1_1ResourceHandle.html +++ b/classentt_1_1ResourceHandle.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -79,32 +79,32 @@ $(function() { - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + @@ -131,10 +131,10 @@ class entt::ResourceHandle< Resource > -

Definition at line 30 of file handle.hpp.

+

Definition at line 31 of file handle.hpp.

Member Function Documentation

- -

◆ get()

+ +

◆ get()

@@ -153,7 +153,7 @@ template<typename Resource >

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...
 
+ ResourceHandle (const ResourceHandle &) ENTT_NOEXCEPT=default
 Default copy constructor.
 
+ ResourceHandle (ResourceHandle &&) ENTT_NOEXCEPT=default
 Default move constructor.
 
ResourceHandle & operator= (const ResourceHandle &) ENTT_NOEXCEPT=default
 Default copy assignment operator. More...
 
ResourceHandle & operator= (ResourceHandle &&) ENTT_NOEXCEPT=default
 Default move assignment operator. More...
 
const Resource & get () const ENTT_NOEXCEPT
 Gets a reference to the managed resource. More...
 
 operator const Resource & () const ENTT_NOEXCEPT
 Casts a handle and gets a reference to the managed resource. More...
 
const Resource & operator* () const ENTT_NOEXCEPT
 Dereferences a handle to obtain the managed resource. More...
 
const Resource * operator-> () const ENTT_NOEXCEPT
 Gets a pointer to the managed resource from a handle . More...
 
 operator bool () const
 Returns true if the handle contains a resource, false otherwise.
-inlinenoexcept +inline
@@ -163,12 +163,12 @@ template<typename Resource >
An assertion will abort the execution at runtime in debug mode if the handle is empty.
Returns
A reference to the managed resource.
-

Definition at line 59 of file handle.hpp.

+

Definition at line 60 of file handle.hpp.

- -

◆ operator const Resource &()

+ +

◆ operator const Resource &()

@@ -187,7 +187,7 @@ template<typename Resource >
-inlinenoexcept +inline
@@ -196,12 +196,12 @@ template<typename Resource >
Warning
The behavior is undefined if the handle doesn't contain a resource.
An assertion will abort the execution at runtime in debug mode if the handle is empty.
-

Definition at line 72 of file handle.hpp.

+

Definition at line 73 of file handle.hpp.

- -

◆ operator*()

+ +

◆ operator*()

@@ -220,7 +220,7 @@ template<typename Resource >
-inlinenoexcept +inline
@@ -230,12 +230,12 @@ template<typename Resource >
An assertion will abort the execution at runtime in debug mode if the handle is empty.
Returns
A reference to the managed resource.
-

Definition at line 84 of file handle.hpp.

+

Definition at line 85 of file handle.hpp.

- -

◆ operator->()

+ +

◆ operator->()

@@ -254,7 +254,7 @@ template<typename Resource >
-inlinenoexcept +inline
@@ -264,12 +264,12 @@ template<typename Resource >
An assertion will abort the execution at runtime in debug mode if the handle is empty.
Returns
A pointer to the managed resource or nullptr if the handle contains no resource at all.
-

Definition at line 97 of file handle.hpp.

+

Definition at line 98 of file handle.hpp.

- -

◆ operator=() [1/2]

+ +

◆ operator=() [1/2]

@@ -289,7 +289,7 @@ template<typename Resource >
-defaultnoexcept +default
@@ -299,8 +299,8 @@ template<typename Resource >
- -

◆ operator=() [2/2]

+ +

◆ operator=() [2/2]

@@ -320,7 +320,7 @@ template<typename Resource >
-defaultnoexcept +default
diff --git a/classentt_1_1ResourceLoader-members.html b/classentt_1_1ResourceLoader-members.html index c268a9c57..d32bb712c 100644 --- a/classentt_1_1ResourceLoader-members.html +++ b/classentt_1_1ResourceLoader-members.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
diff --git a/classentt_1_1ResourceLoader.html b/classentt_1_1ResourceLoader.html index d2eb514c3..3348db02b 100644 --- a/classentt_1_1ResourceLoader.html +++ b/classentt_1_1ResourceLoader.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
diff --git a/classentt_1_1Scheduler-members.html b/classentt_1_1Scheduler-members.html index 575768d74..d1cf43ff4 100644 --- a/classentt_1_1Scheduler-members.html +++ b/classentt_1_1Scheduler-members.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -70,19 +70,19 @@ $(function() {

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

- + - + - + - + - +
abort(bool immediately=false)entt::Scheduler< Delta >inline
abort(const bool immediately=false)entt::Scheduler< Delta >inline
attach(Args &&... args)entt::Scheduler< Delta >inline
attach(Func &&func)entt::Scheduler< Delta >inline
clear()entt::Scheduler< Delta >inline
empty() const noexceptentt::Scheduler< Delta >inline
empty() const ENTT_NOEXCEPTentt::Scheduler< Delta >inline
operator=(const Scheduler &)=deleteentt::Scheduler< Delta >
operator=(Scheduler &&)=defaultentt::Scheduler< Delta >
Scheduler() noexcept=defaultentt::Scheduler< Delta >
Scheduler() ENTT_NOEXCEPT=defaultentt::Scheduler< Delta >
Scheduler(const Scheduler &)=deleteentt::Scheduler< Delta >
Scheduler(Scheduler &&)=defaultentt::Scheduler< Delta >
size() const noexceptentt::Scheduler< Delta >inline
size() const ENTT_NOEXCEPTentt::Scheduler< Delta >inline
size_type typedefentt::Scheduler< Delta >
update(Delta delta, void *data=nullptr)entt::Scheduler< Delta >inline
update(const Delta delta, void *data=nullptr)entt::Scheduler< Delta >inline
diff --git a/classentt_1_1Scheduler.html b/classentt_1_1Scheduler.html index 451cef7a0..6046fcd6b 100644 --- a/classentt_1_1Scheduler.html +++ b/classentt_1_1Scheduler.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -87,10 +87,10 @@ using 

Public Member Functions

- - Scheduler () noexcept=default - Default constructor.
-  + + Scheduler () ENTT_NOEXCEPT=default + Default constructor.
+   Scheduler (const Scheduler &)=delete  Copying a scheduler isn't allowed.
@@ -103,14 +103,14 @@ Public Member Functions  Copying a scheduler isn't allowed. More...
  Scheduler & operator= (Scheduler &&)=default - Default move assignament operator. More...
+ Default move assignment 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...
-  +size_type size () const ENTT_NOEXCEPT + Number of processes currently scheduled. More...
+  +bool empty () const ENTT_NOEXCEPT + Returns true if at least a process is currently scheduled. More...
+  void clear ()  Discards all scheduled processes. More...
  @@ -122,12 +122,12 @@ Public Member Functions auto attach (Func &&func)  Schedules a process for the next tick. More...
  -void update (Delta delta, void *data=nullptr) - Updates all scheduled processes. More...
-  -void abort (bool immediately=false) - Aborts all scheduled processes. More...
-  +void update (const Delta delta, void *data=nullptr) + Updates all scheduled processes. More...
+  +void abort (const bool immediately=false) + Aborts all scheduled processes. More...
+ 

Detailed Description

template<typename Delta>
@@ -147,10 +147,10 @@ class entt::Scheduler< Delta >

-

Definition at line 44 of file scheduler.hpp.

+

Definition at line 45 of file scheduler.hpp.

Member Function Documentation

- -

◆ abort()

+ +

◆ abort()

@@ -163,7 +163,7 @@ template<typename Delta >
void entt::Scheduler< Delta >::abort ( - bool  + const bool  immediately = false) @@ -185,7 +185,7 @@ template<typename Delta >
-

Definition at line 300 of file scheduler.hpp.

+

Definition at line 301 of file scheduler.hpp.

@@ -235,7 +235,7 @@ template<typename Proc , typename... Args>
Returns
An opaque object to use to concatenate processes.
-

Definition at line 197 of file scheduler.hpp.

+

Definition at line 198 of file scheduler.hpp.

@@ -294,7 +294,7 @@ template<typename Func >
Returns
An opaque object to use to concatenate processes.
-

Definition at line 258 of file scheduler.hpp.

+

Definition at line 259 of file scheduler.hpp.

@@ -326,12 +326,12 @@ template<typename Delta >

Discards all scheduled processes.

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

-

Definition at line 167 of file scheduler.hpp.

+

Definition at line 168 of file scheduler.hpp.

- -

◆ empty()

+ +

◆ empty()

@@ -350,7 +350,7 @@ template<typename Delta >
-inlinenoexcept +inline
@@ -358,7 +358,7 @@ template<typename Delta >

Returns true if at least a process is currently scheduled.

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

Definition at line 157 of file scheduler.hpp.

+

Definition at line 158 of file scheduler.hpp.

@@ -419,13 +419,13 @@ template<typename Delta >
-

Default move assignament operator.

+

Default move assignment operator.

Returns
This scheduler.
- -

◆ size()

+ +

◆ size()

@@ -444,7 +444,7 @@ template<typename Delta >
-inlinenoexcept +inline
@@ -452,12 +452,12 @@ template<typename Delta >

Number of processes currently scheduled.

Returns
Number of processes currently scheduled.
-

Definition at line 149 of file scheduler.hpp.

+

Definition at line 150 of file scheduler.hpp.

- -

◆ update()

+ +

◆ update()

@@ -470,7 +470,7 @@ template<typename Delta >
void entt::Scheduler< Delta >::update ( - Delta  + const Delta  delta, @@ -503,7 +503,7 @@ template<typename Delta >
-

Definition at line 274 of file scheduler.hpp.

+

Definition at line 275 of file scheduler.hpp.

diff --git a/classentt_1_1SigH.html b/classentt_1_1SigH.html index 40f746ef0..35b127107 100644 --- a/classentt_1_1SigH.html +++ b/classentt_1_1SigH.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -73,7 +73,7 @@ $(function() {

#include <sigh.hpp>

Detailed Description

-

template<typename Function, typename Collector = DefaultCollectorType<Function>>
+

template<typename Function, typename Collector = internal::DefaultCollectorType<Function>>
class entt::SigH< Function, Collector >

Unmanaged signal handler declaration.

@@ -86,7 +86,7 @@ class entt::SigH< Function, Collector >

-

Definition at line 87 of file sigh.hpp.

+

Definition at line 112 of file sigh.hpp.

The documentation for this class was generated from the following file: 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 e3bfb3995..fca93fb53 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 @@
entt -  2.5.0 +  2.6.0
@@ -70,19 +70,15 @@ $(function() {

This is the complete list of members for entt::SigH< Ret(Args...), Collector >, including all inherited members.

- - - - - - - - - + + + - + - + + +
clear() noexceptentt::SigH< Ret(Args...), Collector >inline
collect(Args... args)entt::SigH< Ret(Args...), Collector >inline
collector_type typedefentt::SigH< Ret(Args...), Collector >
connect()entt::SigH< Ret(Args...), Collector >inline
connect(instance_type< Class > instance)entt::SigH< Ret(Args...), Collector >inline
disconnect()entt::SigH< Ret(Args...), Collector >inline
disconnect(instance_type< Class > instance)entt::SigH< Ret(Args...), Collector >inline
disconnect(instance_type< Class > instance)entt::SigH< Ret(Args...), Collector >inline
empty() const noexceptentt::SigH< Ret(Args...), Collector >inline
collect(Args... args)entt::SigH< Ret(Args...), Collector >inline
collector_type typedefentt::SigH< Ret(Args...), Collector >
empty() const ENTT_NOEXCEPTentt::SigH< Ret(Args...), Collector >inline
instance_type typedefentt::SigH< Ret(Args...), Collector >
operator==(const SigH &other) const noexceptentt::SigH< Ret(Args...), Collector >inline
operator==(const SigH &other) const ENTT_NOEXCEPTentt::SigH< Ret(Args...), Collector >inline
publish(Args... args)entt::SigH< Ret(Args...), Collector >inline
size() const noexceptentt::SigH< Ret(Args...), Collector >inline
sink()entt::SigH< Ret(Args...), Collector >inline
sink_type typedefentt::SigH< Ret(Args...), Collector >
size() const ENTT_NOEXCEPTentt::SigH< Ret(Args...), Collector >inline
size_type typedefentt::SigH< Ret(Args...), Collector >
swap(SigH &lhs, SigH &rhs)entt::SigH< Ret(Args...), Collector >friend
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 05aea3fbb..ccc3b360e 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.5.0 +  2.6.0
@@ -102,6 +102,10 @@ using collector_type = Collector  Collector type.
  + +using sink_type = Sink< Ret(Args...)> + Sink type.
+  template<typename Class > using instance_type = Class *  Instance type when it comes to connecting member functions. More...
@@ -109,45 +113,24 @@ using 

Public Member Functions

-size_type size () const noexcept - Number of listeners connected to the signal. More...
-  -bool empty () const noexcept - Returns false if at least a listener is connected to the signal. More...
-  - -void clear () noexcept - Disconnects all the listeners from a signal.
-  -template<Ret(*)(Args...) Function> -void connect () - Connects a free function to a signal. More...
-  -template<typename Class , Ret(Class::*)(Args...) Member> -void connect (instance_type< Class > instance) - Connects a member function for a given instance to a signal. More...
-  -template<Ret(*)(Args...) Function> -void disconnect () - Disconnects a free function from a signal. More...
-  -template<typename Class , Ret(Class::*)(Args...) Member> -void disconnect (instance_type< Class > instance) - Disconnects the given member function from a signal. More...
-  -template<typename Class > -void disconnect (instance_type< Class > instance) - Removes all existing connections for the given instance. More...
-  +size_type size () const ENTT_NOEXCEPT + Number of listeners connected to the signal. More...
+  +bool empty () const ENTT_NOEXCEPT + Returns false if at least a listener is connected to the signal. More...
+  +sink_type sink () + Returns a sink object for the given signal. More...
+  void publish (Args... args)  Triggers a signal. More...
  collector_type collect (Args... args)  Collects return values from the listeners. More...
  -bool operator== (const SigH &other) const noexcept - Checks if the contents of the two signals are identical. More...
-  +bool operator== (const SigH &other) const ENTT_NOEXCEPT + Checks if the contents of the two signals are identical. More...
+  @@ -180,7 +163,7 @@ class entt::SigH< Ret(Args...), Collector > -

Definition at line 114 of file sigh.hpp.

+

Definition at line 255 of file sigh.hpp.

Member Typedef Documentation

◆ instance_type

@@ -206,7 +189,7 @@ template<typename Class > -

Definition at line 138 of file sigh.hpp.

+

Definition at line 271 of file sigh.hpp.

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

Definition at line 247 of file sigh.hpp.

+

Definition at line 321 of file sigh.hpp.

- -

◆ connect() [1/2]

- -
-
-
-template<typename Ret , typename... Args, typename Collector >
-
-template<Ret(*)(Args...) Function>
-

Friends

- - - - -
- - - - - - - -
void entt::SigH< Ret(Args...), Collector >::connect ()
- 		-inline
-
- -

Connects a free function to a signal.

-

The signal handler performs checks to avoid multiple connections for free functions.

-
Template Parameters
- - -
FunctionA valid free function pointer.
-
-
- -

Definition at line 172 of file sigh.hpp.

- -
- - -

◆ connect() [2/2]

- -
-
-
-template<typename Ret , typename... Args, typename Collector >
-
-template<typename Class , Ret(Class::*)(Args...) Member>
- - - - - -
- - - - - - - - -
void entt::SigH< Ret(Args...), Collector >::connect (instance_type< Class > instance)
- 		-inline
-
- -

Connects a member function for a given instance to a signal.

-

The signal isn't responsible for the connected object. Users must guarantee that the lifetime of the instance overcomes the one of the signal. On the other side, the signal handler performs checks to avoid multiple connections for the same member function of a given instance.

-
Template Parameters
- - - -
ClassType of class to which the member function belongs.
MemberMember function to connect to the signal.
-
-
-
Parameters
- - -
instanceA valid instance of type pointer to Class.
-
-
- -

Definition at line 190 of file sigh.hpp.

- -
-
- -

◆ disconnect() [1/3]

- -
-
-
-template<typename Ret , typename... Args, typename Collector >
-
-template<Ret(*)(Args...) Function>
- - - - - -
- - - - - - - -
void entt::SigH< Ret(Args...), Collector >::disconnect ()
- 		-inline
-
- -

Disconnects a free function from a signal.

-
Template Parameters
- - -
FunctionA valid free function pointer.
-
-
- -

Definition at line 200 of file sigh.hpp.

- -
-
- -

◆ disconnect() [2/3]

- -
-
-
-template<typename Ret , typename... Args, typename Collector >
-
-template<typename Class , Ret(Class::*)(Args...) Member>
- - - - - -
- - - - - - - - -
void entt::SigH< Ret(Args...), Collector >::disconnect (instance_type< Class > instance)
- 		-inline
-
- -

Disconnects the given member function from a signal.

-
Template Parameters
- - - -
ClassType of class to which the member function belongs.
MemberMember function to connect to the signal.
-
-
-
Parameters
- - -
instanceA valid instance of type pointer to Class.
-
-
- -

Definition at line 212 of file sigh.hpp.

- -
-
- -

◆ disconnect() [3/3]

- -
-
-
-template<typename Ret , typename... Args, typename Collector >
-
-template<typename Class >
- - - - - -
- - - - - - - - -
void entt::SigH< Ret(Args...), Collector >::disconnect (instance_type< Class > instance)
- 		-inline
-
- -

Removes all existing connections for the given instance.

-
Template Parameters
- - -
ClassType of class to which the member function belongs.
-
-
-
Parameters
- - -
instanceA valid instance of type pointer to Class.
-
-
- -

Definition at line 223 of file sigh.hpp.

- -
-
- -

◆ empty()

+ +

◆ empty()

@@ -490,7 +253,7 @@ template<typename Ret , typename... Args, typename Collector >
-inlinenoexcept +inline
@@ -498,12 +261,12 @@ template<typename Ret , typename... Args, typename Collector >

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

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

Definition at line 152 of file sigh.hpp.

+

Definition at line 285 of file sigh.hpp.

- -

◆ operator==()

+ +

◆ operator==()

@@ -523,7 +286,7 @@ template<typename Ret , typename... Args, typename Collector >
-inlinenoexcept +inline
@@ -532,13 +295,13 @@ template<typename Ret , typename... Args, typename Collector >

Two signals are identical if they have the same size and the same listeners registered exactly in the same order.

Parameters
- +
otherSignal with which to compare.
otherSignal with which to compare.
Returns
True if the two signals are identical, false otherwise.
-

Definition at line 280 of file sigh.hpp.

+

Definition at line 352 of file sigh.hpp.

@@ -577,12 +340,46 @@ template<typename Ret , typename... Args, typename Collector > -

Definition at line 235 of file sigh.hpp.

+

Definition at line 309 of file sigh.hpp.

- -

◆ size()

+ +

◆ sink()

+ +
+
+
+template<typename Ret , typename... Args, typename Collector >
+ + + + + +
+ + + + + + + +
sink_type entt::SigH< Ret(Args...), Collector >::sink ()
+ 		+inline
+
+ +

Returns a sink object for the given signal.

+

A sink is an opaque object used to connect listeners to signals.
+ The function type for a listener is the one of the signal to which it belongs. The order of invocation of the listeners isn't guaranteed.

+
Returns
A temporary sink object.
+ +

Definition at line 298 of file sigh.hpp.

+ +
+
+ +

◆ size()

@@ -601,7 +398,7 @@ template<typename Ret , typename... Args, typename Collector >
-inlinenoexcept +inline
@@ -609,7 +406,7 @@ template<typename Ret , typename... Args, typename Collector >

Number of listeners connected to the signal.

Returns
Number of listeners currently connected.
-

Definition at line 144 of file sigh.hpp.

+

Definition at line 277 of file sigh.hpp.

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

Definition at line 266 of file sigh.hpp.

+

Definition at line 338 of file sigh.hpp.

diff --git a/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__coll__graph.md5 b/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__coll__graph.md5 index e70a33aaa..6984d2f8c 100644 --- a/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__coll__graph.md5 +++ b/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__coll__graph.md5 @@ -1 +1 @@ -877dca154407d82e21a0b734e03b3666 \ No newline at end of file +5912f9063856265db81c2fd46ab86e10 \ No newline at end of file diff --git a/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__coll__graph.png b/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__coll__graph.png index 7b2c00964a5b78e98f44d73c6c7219445b23fbd9..b450694bb3139658b7ae539b0b0f1e22345bdf6c 100644 GIT binary patch literal 6315 zcmcgxhdY*U-@igON%qLdXxQD^J0r4w$d<}&ln|Mj8RbmXA#^XggEfkb(>TH z9{7*$Dk~tTXCKK`nGpy=_drEKPS@?@dctE}D*aKc{p~9fDE45UKGtu+Z^S=i(mI?3 zxY~RLTeAHK;sohXI1N{cnchDm6vW4jvf@)?DA4rskCapzuKE$g43q(b-wFW-~-|ITUO8HFJXVH9I}s*;N}I*2I`+QtnuB^zv$AMTNLL zk%^}4YgzUG+~1417#JBA_6RvlI5_7-WQ%o?LmDp1L4>=_!G9kg%%1Sv!D>W_c91<^Vi-Yi( ze50^sr6ANulzePwC+%}`R9joy+xt(k$HRwgA5^P+POHD2M`SfL-sR=xy?XU3Fi=rm z-j9?Z-E^s`v*Oz~JOYBWlC-q6?WOJ-=bto4a!t(?7K?>J#>XW&IM8S`o;^1_Cn}sL zCMJHr4V-RhkLC{w3Yv0yVTDKdEpo&ClPz7hl5lS4T_B^fS>}8hm_wU0q#rX7PdE-ted>d}MiL zr7nJbV?$FzgGLh%fZEkh1i%FLOdKix$ob;0p@&qpG}E`5g8=jAm;tLa`+R8%DN+x+Xf z6G?$8Lbtx}>e4`YEp;W_vKdS!gGr_v(lIl89qg?1^icS*a&mG~cB%#>6ZskPMdxH> z+|$#0#rnFk@(^>0yT?c<)|Kv$_RaI3& zf~mGP<$cbZ^bYEG+)9s?Vq#(tqy^pTGCDf?HYB8oCs1DQQhO9{gr%IKVn#{HEdhbB zh8eZ_YZ7(26%_|lCwpb_BKG+PMYEYn-r2dic!-m;GZCI&Q!s6sZEjxP*w|RFlc8a( zzyEDDH8oY$HfnO@DnW(O=Cb)1p zdBKhBBG21*?*Ix+QZI^&i+7IxZbvM~zzRF#MYezc9xO1kx3wih1cZdxBU;tf)vf)T zo0VYWQ3**&NwAj0#QVCs9Nh+_q@;Se2LEVlJD#2#!|4Bd%lB4#%kt-t>6w{}3=E^= z<45~ja~EWeHpk1Ko9{70aW7xyifCA*vM#gb+x{sq3Zkhp6kxe&Ww!lg@uK_zKGMzH4mQB(o!|9 zn-UV0)z#ju?>W7_y{W0G9mR#`YNzfr7bVtC)iW|M;NjFQcE*R+h zTuQ16mw^14C{ul#>^P1etDvAD6>(EvpU|~yXESVRA)LBvWR!YMK29Uk#>OTsm^yND za`O1_55GZSZDS*csHof7X^Ftj@tRhkgoLyciyrLk?j}fi433Ugl$6}tLwDgd4qf8F zE3-d@;)SxvOjdgxI=%UAdtQzr{7!mqZmzX*GZOM)F4|6DQt)2bo%C3KLd<`23E-E5 zDK0KVJcP0LH4bx^YiD=9q}TX#>R}DZ?Mrsbvppq ziAq;<+F_WA?O5sYZh?kGVKy`ubXe}Df$N#AU{fj=3eFb5~+ zL&F<4ZlD-1U#@=g<9aa#%lngGl^Y!$9Vf>dJ~f_yza%HuHaFuVwKLBEj@SnR;t~=y zrzakO*rN#55h^OGjwBf~CEOj|-Mu|k8`dkM?^ts8bv=)FhjR1_@`2K_vWm*eE)WsP zHRfOHdmBu!OhQcj_U+rA%niqP%odc77Vrp(`+xjcUtX?#lF<}hgbzfo>_1BAC+WGb zrKos*qQDoQM9XZ8?Xj`(7>oD*xu4#1&15^FD(dRIY;5N~-~=_)*(sU-#-9dV$1Pe69|>gmZJ8I;%Bu%KVPMuK?Y_c$); zq)^t^pFUYSJKq|t%FZS((Yt^D*ZO+ZgE~KE36}@#5dF{Q@k(qDkX)DA)5xHAak-mH}cg=tU%QJNVGH^DUk2ey-s~v z^HeiYQqIcO&24|Q#KzRr6o?cof&%~kZ{Nv8P(q7h2S-Qo=ZmD(^9Q>>J*CZV-@dI> zoZ!2!3w#NXO)de{n0f!@ObI5P>l4mJkcx_m%QD{MlatkOviv9(&hv+1PJhYrH~IVf zTkj2I>3Hm|JqA6=$?;f9a3yDve%r=mGd(*?$;b#A`_DfYW7WL3X3tx$)|?*mBgtRB zP@ZNsJP-iaVn0<4!rh4$>OJNG76XCH%F5!QxxvOJr>-8-zQ9iS{^Q5-si{zx$f&N4 zj^dIMYJP10#DuN2_42~PJ#B4ms1!A|B73;^!3uZrV1IvvQrayM5!n2Eqmt`DbF z-Br`qFU!a{|L>!GH=3`!vhoTcB?U#HIhNed!N%riVWB`hj{x1*MINtgZf?RKV9e|K2L~4y7cDI9G=5T!1rgfn(OJ&;*0*dw$@?!HA^=;Gjqu*$xHaxZ4x}c;b8+Fk3YXA z9O7TZ`yS>lia$%DMn6sFVpaIx`y`2Pd~QhWUBDFcEWdm_iKM8vr@BE*MR<5BbF3Y> zE&%K%XMrjAz`y`iO{?-nQdj3)Y436Ojl@*ue-LqTaXj@fq94z<7h*2Ns`;|=Z%j^5 zUrez!qq<AfsviDx@(#TE3_x+o;{&5q<$~3oRuG+b^ zr<~N(i0|v}g1YtLn6I+xzF0#;c4-#%3ocGh_w;WJvIO27y0!H^^-*COZu|AD&yum* zWufKy81C}&1u9-4MAbxO(v1Ozm}oRtc~giKBlLlr9C`692*{9UR?#ZbXm+XJv|){Nlr_f zTUrt+`Gq5!q6IDkE;V)a6{i*t5hed#UN1=8=GuGGFb=Ji` zsDhc7U3xOEcIT3Oih!8d$d4aCT3fG4OW$XuKoBM-re714OB)+CHbeRFc@6<)Cq?#` z(?SU!Zyr=3NrQcTZSC!I&qS>U2M1}Y_GZV9j<&m{rKLftXNt_RP)Um^9ge=KDH%VH zg;IqUv{0yZgbd=zP=4!LF{Z`ufzuLJFC_wl-A}k+RWI zBMj~}KEA!(-H9S|NOjl*3D0cN6*bVg4q@78+s-cPFX1_DY?08Fn0?9x-+<%5eePAx#D#2ii{CKTwGkB9=*N2 z)<05i2ct3Rzre2tzhn&jIotd1>3cg~?(v1XcyMDp_4}xg0rJiOq!4`IQ?>;3- zd$n19EwdfNM}{k$Z2(Po?~;5_RkT@gs>sM#fDs!B*dh5xM&jYTeD$iiD?x&pi3y~N z+nix5CN`D~jtv_2MH8gbhv{Y77QdLzgwV$$s zoCA_JGvlzkdJo_Kbm&JKM7YL2PwpMXvorB$v}&N{j+*A`J}g@cm&GglPhY|z8 z;np*(@bj}UF+rsI?zqqvGihXK=(XJ`0?UJr5@bd*pW|IPLCtF! znVHxHN5P;BGJ2arrr&ajlp1o$eAAr(ES`L;6B2esPZU_jvjKI@>*J4gkcvqHu#s4 zE`Csza#m5SK14H{ho z1CfP&k)mPl+l$bi`IMgit+H}yVL?$r;d6F24l+AC3!$RtU0+{FNJ#uMvl|Qq?`w{C zwy-Q;N7iDQZuo3YzXV2bX@y4C353V_a-(UvG7_~-4P{^KocoIx&>*8Pz^7MhlNEpi zl9_4c>G>UcF>6uQxhAtCNh#f>*z}^JtziCYx4pFyfN+1NW<*2;KwxTs5Tg)hB8MPg zfxuNhUpQI*n@)=7--@=I{O+zM*J4@feW7Dw!V8V&kd*umjj`e37)Yg)N}mX&Pxj60 z-x%OWNKm9`EpKed{Q7nE>+a;aSXTR)DqJDwjz{V{dwb1|jgXDcsKiP97?@s&!TjZW z!L;?Tk!&LJAdr>J)Ko|4G{IK(Sr_wH@6XOO1nD^Nh|L|^lYMm#abIZr0BxzW9-Sd1 z@x;W$jt(^sk3$uisE=F6Wv@nFBwW3Iz5ep06eiJUtSA(f`UNtwrsifyk(Ct{LUg3k zN&LO9-KLE>C{4>9EvBly`1tsstzkV7NkK*{qVd|xd~X5M)Gce7!S&6=&ec_f;dZ^2 zj?PUKN}+#iYwM}-;cQbdY$s$Z5xem)Yh}qzukFQ7FrM%(-T-O9-B5uU!J{p&$IZRN zWgvf+HAO|e6BAN`f<<4yKL4`xfH?L;90hS8g1nFP8KWcy%GhoRzd}OG2SI3OYb(4I zI}aWh+6!Px0c=j<(AGIxO7a0s%Fxb&S3o~*=;udHi6&^k3M8cW?X0X^SNb?_-6{be z0m(BeI$HCY{`ii-jiF1R+yE$EUf%uZdS+&)&Yd8p0OZ6t-Bps4mP~bCNdyb#K0I&(j0N;@y_Pn{a_JL$WBA?}g zGY(Q{(H_O(b9B+najA>>rEGF`Hdyn_+}yY8KP-z3NN9M%tQE}6WO#Y=pe+T7L`LQm zBod}I>|9+`B*@Df(xdpwf&NhOg@=c+vGK^$(vT1`hR(Rw4kz{Lv|6{Lqaz4u5#bDEEc|c^-R-QS$);G`mIr#nwl6v2iPF+N42%G(n&QI?KH(w zp;!_!vV|?Ty}dmrapvjS!{t44u@GG3O>po{At4hJ6OANkscW{`TRb^~Zr`{(qb;F1t!clG>IOjtST|Lw#dv24?dv}Wh01i^nF5EVrY Kg?#x3e*XjVo@THB literal 5010 zcmchbbyQSuw}1~NL-V6sTBH;ZK^h#SyGsU;?uJ1?U;ycE1d)&q2?^;AMGyf;Is^rz zQTo1o_n+@u-@5>iXsGyb91HH#i^cL}8QaB1pAlFp|*u`d*)D zD+;N^UjCu4DuwC2CfkZbYYiBG&@3k|HV)yYmZd1h*DY##YU71jNL3*?Y0w`X+5^eL zyGZ%**mD#=tMWquH%( zh(pO6uJ^AEgBjw|Hw6V4>+9>SK85CjmVGcnCJDnC7p~&*Pqk!G*uuiX;J~7mjt*87 z{EefC?xd~ltVk@qi24lw5s!zbr}s{%@!2+^N�GetHjgDdKKr=znd<)nEtwo_o~X z+S)TUML|qV{4y@i`h=E-hM9+lz{SO-wzgIV4#%$7U?*c?W`?Gxr)dN%v74N~-zw8B zZ(98EF=u~0!(7nnfv|A**cjpU#UaU;d&0t$tAh!Vjg7)5JKrN48Xky>i}%jWF^K#A z-kuIpQolvUdH)7__pw`uJ%(Qa(9383t*an5e*5`o_l-{E*1xw;K7$ z=YMun_E!f}_V(NwFRRVkop7TExGiu6F)u7Ezn!C@?LcCw_R zq9Ue2$vbxIlH2Oom>A$^r-vIULqm!-gwPtg(GmYrETgTy zM!l9b>1AeSX5#Fu;g3vudU~aRfVKevohRnhl?%LheiBS0BO|qb`gyl1Gc3y?yuZ z`8Ev5vd++18Vs{OnqhVL<0BUzpS*X#!6vy^#14m$?I*aib5-^HrtfFk|761=Mpay#owL(aBRx_nzjG70zY<<;wkg07 ze1(Sv6;knjZsb8K-U6A>F zJHZ#0$6h(J`5me0xm?haH@3=qHiI3gEdk~8w~py{E+#g0hg^;HK{{7199 zgJa#_->$3zD{?TbpiY1=F0NZZ5OZ*7GuWDmgzxy6tJ7a+=J&fisr;(1Gs|u*nJre4 za`T-=M$n7v!;{~W=?6ZaovM7hZanLf@lCbE!@~o3>d$@TxwN~RkeW)-(A0zpq2yR3BqSctjrR6p z$rWg>BGvZy_B3a2V3n9iDiLr}Ib($>qo+sd<8?+7dq*P=6&Z>9DfiK#zLjGP7B2D9 z)#bS{qmFH8Re5<&GKY$8x-bhT=Ph}8c^CM&P#7-B0N{S(FJD(s ze_s?AbMW%*DmV&U%z; z?t{P1Do2)G$?*trZ%e%Yd zv(LletUuqC6_%F5l9G}P>urd#v$J)ZwnU#gJM(F4Yu|UA=H2uA;9^zE%MbE7yuH0W zlqf{zg@*Jc1$5u@hbm6DPeYx{ych*FbwzAAoK@D(Pc)t1EE-U^YjN?m^wnRhgpNc; zS|C!t7uvs9bc}o+xqjT~^^?rf(h^~BkLT#?iUh9L-q z92*;(nUyuvo}7YWs!GGz*?H*W$Nm=24d#^LTDu8W6bjYV*9W)G|FoK&m9^X#MUL-X zZrN-%@rHjDFI+B`Mj-UAH1Y@rob&HmiUtG;*^G4!r`*vpHpW*_P$*%{ACF8)ArB1= z)g5@#-pw0C7hXAS;r2s@pkgH;4k-1 zPV`IZMctSW->0QfLS3IfYtsLKAW+YMLAm+*M#jVtn3|d{ZEeMn-%)3llIn;-gv+ty z=H^oT5(~;k)9fwiCWnMJkgjYRRG=xOzFI1sl z)q}z#e;_vf30OD{^m%S>&KKL!+B&?nlc+a!C^ADB|t|Y+9096t%4MbPL`0A{O9)Vgz|Fk)U-5#EhRM|R9Z$r z@(223sMFGMfrj6^cMl+P6=-{DWo6&-){Ohw&_BSbed<<$Dxy%>Ya1Jnd8rCtzlH`A zZtqUG$I}VpfeHIay8fX`^6>wY9#ZU=u(!X=&-%*;&NuK->*Dx3{-z!J2Cf1QCjGUmXxI=zKK_ z?fv@71OC2@H!>okXMUa$lo1#{zTETY5}az;MMwJ6fM?4a8>7&a#8CK?AV z^&)+!sCW_UBWa1s#V`T_Fh4!D7QIV9e|}r1AEN?>UvjjfO}=2jyXNr-gs@S}rqhT_ zb5_37oD7lyrhKxyNCK!nmLo#)T5waW9i}5Cb`z-b*fAUO0|9K zZF{cP^mTKhka8Q$`AsMl6&1S*|SvVxpGw&;oQ-ZXOqlf~(*bq5{|Gt@1x=!7x~A=PwOLHSpWhaX9f3d(`o6r?NXpKR2A+m}>lUUT zA5c1yzJY-iz~Y;Z(ZfT~=3{p8bW^!155OKf2gmZadRs0Yp2uEZUKzqaa(F8j(6^p0 zx(|(y4}vEMwLzE2hWGE;9zLW3&oQ1IXdUCU8<7FHSgiC#;qNMWKLhbpR8@roxb*b) zPE1XqlGqeLA;8pmt8R@BN1>R(sQ}Jc8KdEE-`>%$GA@2dKRP~65)~CS+w9JUMx*aL zqaT!X0%NeV<6 diff --git a/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__inherit__graph.md5 b/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__inherit__graph.md5 index f3c5917a1..875b972b2 100644 --- a/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__inherit__graph.md5 +++ b/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__inherit__graph.md5 @@ -1 +1 @@ -25bf8ef3dadecae5ca8667d16dac3e4f \ No newline at end of file +10a9db26013b49724b6014469940db4c \ No newline at end of file diff --git a/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__inherit__graph.png b/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4__inherit__graph.png index 7b2c00964a5b78e98f44d73c6c7219445b23fbd9..b450694bb3139658b7ae539b0b0f1e22345bdf6c 100644 GIT binary patch literal 6315 zcmcgxhdY*U-@igON%qLdXxQD^J0r4w$d<}&ln|Mj8RbmXA#^XggEfkb(>TH z9{7*$Dk~tTXCKK`nGpy=_drEKPS@?@dctE}D*aKc{p~9fDE45UKGtu+Z^S=i(mI?3 zxY~RLTeAHK;sohXI1N{cnchDm6vW4jvf@)?DA4rskCapzuKE$g43q(b-wFW-~-|ITUO8HFJXVH9I}s*;N}I*2I`+QtnuB^zv$AMTNLL zk%^}4YgzUG+~1417#JBA_6RvlI5_7-WQ%o?LmDp1L4>=_!G9kg%%1Sv!D>W_c91<^Vi-Yi( ze50^sr6ANulzePwC+%}`R9joy+xt(k$HRwgA5^P+POHD2M`SfL-sR=xy?XU3Fi=rm z-j9?Z-E^s`v*Oz~JOYBWlC-q6?WOJ-=bto4a!t(?7K?>J#>XW&IM8S`o;^1_Cn}sL zCMJHr4V-RhkLC{w3Yv0yVTDKdEpo&ClPz7hl5lS4T_B^fS>}8hm_wU0q#rX7PdE-ted>d}MiL zr7nJbV?$FzgGLh%fZEkh1i%FLOdKix$ob;0p@&qpG}E`5g8=jAm;tLa`+R8%DN+x+Xf z6G?$8Lbtx}>e4`YEp;W_vKdS!gGr_v(lIl89qg?1^icS*a&mG~cB%#>6ZskPMdxH> z+|$#0#rnFk@(^>0yT?c<)|Kv$_RaI3& zf~mGP<$cbZ^bYEG+)9s?Vq#(tqy^pTGCDf?HYB8oCs1DQQhO9{gr%IKVn#{HEdhbB zh8eZ_YZ7(26%_|lCwpb_BKG+PMYEYn-r2dic!-m;GZCI&Q!s6sZEjxP*w|RFlc8a( zzyEDDH8oY$HfnO@DnW(O=Cb)1p zdBKhBBG21*?*Ix+QZI^&i+7IxZbvM~zzRF#MYezc9xO1kx3wih1cZdxBU;tf)vf)T zo0VYWQ3**&NwAj0#QVCs9Nh+_q@;Se2LEVlJD#2#!|4Bd%lB4#%kt-t>6w{}3=E^= z<45~ja~EWeHpk1Ko9{70aW7xyifCA*vM#gb+x{sq3Zkhp6kxe&Ww!lg@uK_zKGMzH4mQB(o!|9 zn-UV0)z#ju?>W7_y{W0G9mR#`YNzfr7bVtC)iW|M;NjFQcE*R+h zTuQ16mw^14C{ul#>^P1etDvAD6>(EvpU|~yXESVRA)LBvWR!YMK29Uk#>OTsm^yND za`O1_55GZSZDS*csHof7X^Ftj@tRhkgoLyciyrLk?j}fi433Ugl$6}tLwDgd4qf8F zE3-d@;)SxvOjdgxI=%UAdtQzr{7!mqZmzX*GZOM)F4|6DQt)2bo%C3KLd<`23E-E5 zDK0KVJcP0LH4bx^YiD=9q}TX#>R}DZ?Mrsbvppq ziAq;<+F_WA?O5sYZh?kGVKy`ubXe}Df$N#AU{fj=3eFb5~+ zL&F<4ZlD-1U#@=g<9aa#%lngGl^Y!$9Vf>dJ~f_yza%HuHaFuVwKLBEj@SnR;t~=y zrzakO*rN#55h^OGjwBf~CEOj|-Mu|k8`dkM?^ts8bv=)FhjR1_@`2K_vWm*eE)WsP zHRfOHdmBu!OhQcj_U+rA%niqP%odc77Vrp(`+xjcUtX?#lF<}hgbzfo>_1BAC+WGb zrKos*qQDoQM9XZ8?Xj`(7>oD*xu4#1&15^FD(dRIY;5N~-~=_)*(sU-#-9dV$1Pe69|>gmZJ8I;%Bu%KVPMuK?Y_c$); zq)^t^pFUYSJKq|t%FZS((Yt^D*ZO+ZgE~KE36}@#5dF{Q@k(qDkX)DA)5xHAak-mH}cg=tU%QJNVGH^DUk2ey-s~v z^HeiYQqIcO&24|Q#KzRr6o?cof&%~kZ{Nv8P(q7h2S-Qo=ZmD(^9Q>>J*CZV-@dI> zoZ!2!3w#NXO)de{n0f!@ObI5P>l4mJkcx_m%QD{MlatkOviv9(&hv+1PJhYrH~IVf zTkj2I>3Hm|JqA6=$?;f9a3yDve%r=mGd(*?$;b#A`_DfYW7WL3X3tx$)|?*mBgtRB zP@ZNsJP-iaVn0<4!rh4$>OJNG76XCH%F5!QxxvOJr>-8-zQ9iS{^Q5-si{zx$f&N4 zj^dIMYJP10#DuN2_42~PJ#B4ms1!A|B73;^!3uZrV1IvvQrayM5!n2Eqmt`DbF z-Br`qFU!a{|L>!GH=3`!vhoTcB?U#HIhNed!N%riVWB`hj{x1*MINtgZf?RKV9e|K2L~4y7cDI9G=5T!1rgfn(OJ&;*0*dw$@?!HA^=;Gjqu*$xHaxZ4x}c;b8+Fk3YXA z9O7TZ`yS>lia$%DMn6sFVpaIx`y`2Pd~QhWUBDFcEWdm_iKM8vr@BE*MR<5BbF3Y> zE&%K%XMrjAz`y`iO{?-nQdj3)Y436Ojl@*ue-LqTaXj@fq94z<7h*2Ns`;|=Z%j^5 zUrez!qq<AfsviDx@(#TE3_x+o;{&5q<$~3oRuG+b^ zr<~N(i0|v}g1YtLn6I+xzF0#;c4-#%3ocGh_w;WJvIO27y0!H^^-*COZu|AD&yum* zWufKy81C}&1u9-4MAbxO(v1Ozm}oRtc~giKBlLlr9C`692*{9UR?#ZbXm+XJv|){Nlr_f zTUrt+`Gq5!q6IDkE;V)a6{i*t5hed#UN1=8=GuGGFb=Ji` zsDhc7U3xOEcIT3Oih!8d$d4aCT3fG4OW$XuKoBM-re714OB)+CHbeRFc@6<)Cq?#` z(?SU!Zyr=3NrQcTZSC!I&qS>U2M1}Y_GZV9j<&m{rKLftXNt_RP)Um^9ge=KDH%VH zg;IqUv{0yZgbd=zP=4!LF{Z`ufzuLJFC_wl-A}k+RWI zBMj~}KEA!(-H9S|NOjl*3D0cN6*bVg4q@78+s-cPFX1_DY?08Fn0?9x-+<%5eePAx#D#2ii{CKTwGkB9=*N2 z)<05i2ct3Rzre2tzhn&jIotd1>3cg~?(v1XcyMDp_4}xg0rJiOq!4`IQ?>;3- zd$n19EwdfNM}{k$Z2(Po?~;5_RkT@gs>sM#fDs!B*dh5xM&jYTeD$iiD?x&pi3y~N z+nix5CN`D~jtv_2MH8gbhv{Y77QdLzgwV$$s zoCA_JGvlzkdJo_Kbm&JKM7YL2PwpMXvorB$v}&N{j+*A`J}g@cm&GglPhY|z8 z;np*(@bj}UF+rsI?zqqvGihXK=(XJ`0?UJr5@bd*pW|IPLCtF! znVHxHN5P;BGJ2arrr&ajlp1o$eAAr(ES`L;6B2esPZU_jvjKI@>*J4gkcvqHu#s4 zE`Csza#m5SK14H{ho z1CfP&k)mPl+l$bi`IMgit+H}yVL?$r;d6F24l+AC3!$RtU0+{FNJ#uMvl|Qq?`w{C zwy-Q;N7iDQZuo3YzXV2bX@y4C353V_a-(UvG7_~-4P{^KocoIx&>*8Pz^7MhlNEpi zl9_4c>G>UcF>6uQxhAtCNh#f>*z}^JtziCYx4pFyfN+1NW<*2;KwxTs5Tg)hB8MPg zfxuNhUpQI*n@)=7--@=I{O+zM*J4@feW7Dw!V8V&kd*umjj`e37)Yg)N}mX&Pxj60 z-x%OWNKm9`EpKed{Q7nE>+a;aSXTR)DqJDwjz{V{dwb1|jgXDcsKiP97?@s&!TjZW z!L;?Tk!&LJAdr>J)Ko|4G{IK(Sr_wH@6XOO1nD^Nh|L|^lYMm#abIZr0BxzW9-Sd1 z@x;W$jt(^sk3$uisE=F6Wv@nFBwW3Iz5ep06eiJUtSA(f`UNtwrsifyk(Ct{LUg3k zN&LO9-KLE>C{4>9EvBly`1tsstzkV7NkK*{qVd|xd~X5M)Gce7!S&6=&ec_f;dZ^2 zj?PUKN}+#iYwM}-;cQbdY$s$Z5xem)Yh}qzukFQ7FrM%(-T-O9-B5uU!J{p&$IZRN zWgvf+HAO|e6BAN`f<<4yKL4`xfH?L;90hS8g1nFP8KWcy%GhoRzd}OG2SI3OYb(4I zI}aWh+6!Px0c=j<(AGIxO7a0s%Fxb&S3o~*=;udHi6&^k3M8cW?X0X^SNb?_-6{be z0m(BeI$HCY{`ii-jiF1R+yE$EUf%uZdS+&)&Yd8p0OZ6t-Bps4mP~bCNdyb#K0I&(j0N;@y_Pn{a_JL$WBA?}g zGY(Q{(H_O(b9B+najA>>rEGF`Hdyn_+}yY8KP-z3NN9M%tQE}6WO#Y=pe+T7L`LQm zBod}I>|9+`B*@Df(xdpwf&NhOg@=c+vGK^$(vT1`hR(Rw4kz{Lv|6{Lqaz4u5#bDEEc|c^-R-QS$);G`mIr#nwl6v2iPF+N42%G(n&QI?KH(w zp;!_!vV|?Ty}dmrapvjS!{t44u@GG3O>po{At4hJ6OANkscW{`TRb^~Zr`{(qb;F1t!clG>IOjtST|Lw#dv24?dv}Wh01i^nF5EVrY Kg?#x3e*XjVo@THB literal 5010 zcmchbbyQSuw}1~NL-V6sTBH;ZK^h#SyGsU;?uJ1?U;ycE1d)&q2?^;AMGyf;Is^rz zQTo1o_n+@u-@5>iXsGyb91HH#i^cL}8QaB1pAlFp|*u`d*)D zD+;N^UjCu4DuwC2CfkZbYYiBG&@3k|HV)yYmZd1h*DY##YU71jNL3*?Y0w`X+5^eL zyGZ%**mD#=tMWquH%( zh(pO6uJ^AEgBjw|Hw6V4>+9>SK85CjmVGcnCJDnC7p~&*Pqk!G*uuiX;J~7mjt*87 z{EefC?xd~ltVk@qi24lw5s!zbr}s{%@!2+^N�GetHjgDdKKr=znd<)nEtwo_o~X z+S)TUML|qV{4y@i`h=E-hM9+lz{SO-wzgIV4#%$7U?*c?W`?Gxr)dN%v74N~-zw8B zZ(98EF=u~0!(7nnfv|A**cjpU#UaU;d&0t$tAh!Vjg7)5JKrN48Xky>i}%jWF^K#A z-kuIpQolvUdH)7__pw`uJ%(Qa(9383t*an5e*5`o_l-{E*1xw;K7$ z=YMun_E!f}_V(NwFRRVkop7TExGiu6F)u7Ezn!C@?LcCw_R zq9Ue2$vbxIlH2Oom>A$^r-vIULqm!-gwPtg(GmYrETgTy zM!l9b>1AeSX5#Fu;g3vudU~aRfVKevohRnhl?%LheiBS0BO|qb`gyl1Gc3y?yuZ z`8Ev5vd++18Vs{OnqhVL<0BUzpS*X#!6vy^#14m$?I*aib5-^HrtfFk|761=Mpay#owL(aBRx_nzjG70zY<<;wkg07 ze1(Sv6;knjZsb8K-U6A>F zJHZ#0$6h(J`5me0xm?haH@3=qHiI3gEdk~8w~py{E+#g0hg^;HK{{7199 zgJa#_->$3zD{?TbpiY1=F0NZZ5OZ*7GuWDmgzxy6tJ7a+=J&fisr;(1Gs|u*nJre4 za`T-=M$n7v!;{~W=?6ZaovM7hZanLf@lCbE!@~o3>d$@TxwN~RkeW)-(A0zpq2yR3BqSctjrR6p z$rWg>BGvZy_B3a2V3n9iDiLr}Ib($>qo+sd<8?+7dq*P=6&Z>9DfiK#zLjGP7B2D9 z)#bS{qmFH8Re5<&GKY$8x-bhT=Ph}8c^CM&P#7-B0N{S(FJD(s ze_s?AbMW%*DmV&U%z; z?t{P1Do2)G$?*trZ%e%Yd zv(LletUuqC6_%F5l9G}P>urd#v$J)ZwnU#gJM(F4Yu|UA=H2uA;9^zE%MbE7yuH0W zlqf{zg@*Jc1$5u@hbm6DPeYx{ych*FbwzAAoK@D(Pc)t1EE-U^YjN?m^wnRhgpNc; zS|C!t7uvs9bc}o+xqjT~^^?rf(h^~BkLT#?iUh9L-q z92*;(nUyuvo}7YWs!GGz*?H*W$Nm=24d#^LTDu8W6bjYV*9W)G|FoK&m9^X#MUL-X zZrN-%@rHjDFI+B`Mj-UAH1Y@rob&HmiUtG;*^G4!r`*vpHpW*_P$*%{ACF8)ArB1= z)g5@#-pw0C7hXAS;r2s@pkgH;4k-1 zPV`IZMctSW->0QfLS3IfYtsLKAW+YMLAm+*M#jVtn3|d{ZEeMn-%)3llIn;-gv+ty z=H^oT5(~;k)9fwiCWnMJkgjYRRG=xOzFI1sl z)q}z#e;_vf30OD{^m%S>&KKL!+B&?nlc+a!C^ADB|t|Y+9096t%4MbPL`0A{O9)Vgz|Fk)U-5#EhRM|R9Z$r z@(223sMFGMfrj6^cMl+P6=-{DWo6&-){Ohw&_BSbed<<$Dxy%>Ya1Jnd8rCtzlH`A zZtqUG$I}VpfeHIay8fX`^6>wY9#ZU=u(!X=&-%*;&NuK->*Dx3{-z!J2Cf1QCjGUmXxI=zKK_ z?fv@71OC2@H!>okXMUa$lo1#{zTETY5}az;MMwJ6fM?4a8>7&a#8CK?AV z^&)+!sCW_UBWa1s#V`T_Fh4!D7QIV9e|}r1AEN?>UvjjfO}=2jyXNr-gs@S}rqhT_ zb5_37oD7lyrhKxyNCK!nmLo#)T5waW9i}5Cb`z-b*fAUO0|9K zZF{cP^mTKhka8Q$`AsMl6&1S*|SvVxpGw&;oQ-ZXOqlf~(*bq5{|Gt@1x=!7x~A=PwOLHSpWhaX9f3d(`o6r?NXpKR2A+m}>lUUT zA5c1yzJY-iz~Y;Z(ZfT~=3{p8bW^!155OKf2gmZadRs0Yp2uEZUKzqaa(F8j(6^p0 zx(|(y4}vEMwLzE2hWGE;9zLW3&oQ1IXdUCU8<7FHSgiC#;qNMWKLhbpR8@roxb*b) zPE1XqlGqeLA;8pmt8R@BN1>R(sQ}Jc8KdEE-`>%$GA@2dKRP~65)~CS+w9JUMx*aL zqaT!X0%NeV<6 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 deleted file mode 100644 index df33e1758..000000000 --- a/classentt_1_1Signal_3_01void_07Args_8_8_8_08_4-members.html +++ /dev/null @@ -1,94 +0,0 @@ - - - - - - - -entt: Member List - - - - - - - - - -
-
- - - - - - -
-
entt -  2.5.0 -
-
-
- - - - - - - - -
-
- - -
- -
- - -
-
-
-
entt::Signal< void(Args...)> Member List
-
-
- -

This is the complete list of members for entt::Signal< void(Args...)>, including all inherited members.

- - - - - - - - - - - - - - -
clear() noexceptentt::Signal< void(Args...)>inline
connect()entt::Signal< void(Args...)>inline
connect(instance_type< Class > instance)entt::Signal< void(Args...)>inline
disconnect()entt::Signal< void(Args...)>inline
disconnect(instance_type< Class > instance)entt::Signal< void(Args...)>inline
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) const noexceptentt::Signal< void(Args...)>inline
publish(Args... args)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
- -
-Generated by   -doxygen - 1.8.13 -
- - 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 deleted file mode 100644 index 626f178ba..000000000 --- a/classentt_1_1Signal_3_01void_07Args_8_8_8_08_4.html +++ /dev/null @@ -1,606 +0,0 @@ - - - - - - - -entt: entt::Signal< void(Args...)> Class Template Reference - - - - - - - - - -
-
- - - - - - -
-
entt -  2.5.0 -
-
-
- - - - - - - - -
-
- - -
- -
- - -
-
-
-Public Types | -Public Member Functions | -Friends | -List of all members
-
-
entt::Signal< void(Args...)> Class Template Referencefinal
-
-
- -

Managed signal handler definition. - More...

- -

#include <signal.hpp>

- - - - - - - - - -

-Public Types

-using size_type = std::size_t
 Unsigned integer type.
 
template<typename Class >
using instance_type = std::shared_ptr< Class >
 Instance type when it comes to connecting member functions. More...
 
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

-Public Member Functions

size_type size () const noexcept
 Number of listeners connected to the signal. More...
 
bool empty () const noexcept
 Returns false if at least a listener is connected to the signal. More...
 
-void clear () noexcept
 Disconnects all the listeners from a signal.
 
template<void(*)(Args...) Function>
void connect ()
 Connects a free function to a signal. More...
 
template<typename Class , void(Class::*)(Args...) Member>
void connect (instance_type< Class > instance)
 Connects a member function for a given instance to a signal. More...
 
template<void(*)(Args...) Function>
void disconnect ()
 Disconnects a free function from a signal. More...
 
template<typename Class , void(Class::*)(Args...) Member>
void disconnect (instance_type< Class > instance)
 Disconnects the given member function from a signal. More...
 
template<typename Class >
void disconnect (instance_type< Class > instance)
 Removes all existing connections for the given instance. More...
 
void publish (Args... args)
 Triggers a signal. More...
 
bool operator== (const Signal &other) const noexcept
 Checks if the contents of the two signals are identical. More...
 
- - - - -

-Friends

void swap (Signal &lhs, Signal &rhs)
 Swaps listeners between the two signals. More...
 
-

Detailed Description

-

template<typename... Args>
-class entt::Signal< void(Args...)>

- -

Managed signal handler definition.

-

Managed signal handler. It works with weak pointers to classes and pointers to member functions as well as pointers to free functions. References are automatically removed when the instances to which they point are freed.

-

This class can be used to create signals used later to notify a bunch of listeners.

-
Template Parameters
- - -
ArgsTypes of arguments of a function type.
-
-
- -

Definition at line 39 of file signal.hpp.

-

Member Typedef Documentation

- -

◆ instance_type

- -
-
-
-template<typename... Args>
-
-template<typename Class >
- - - - -
using entt::Signal< void(Args...)>::instance_type = std::shared_ptr<Class>
-
- -

Instance type when it comes to connecting member functions.

-
Template Parameters
- - -
ClassType of class to which the member function belongs.
-
-
- -

Definition at line 71 of file signal.hpp.

- -
-
-

Member Function Documentation

- -

◆ connect() [1/2]

- -
-
-
-template<typename... Args>
-
-template<void(*)(Args...) Function>
- - - - - -
- - - - - - - -
void entt::Signal< void(Args...)>::connect ()
- 		-inline
-
- -

Connects a free function to a signal.

-

The signal handler performs checks to avoid multiple connections for free functions.

-
Template Parameters
- - -
FunctionA valid free function pointer.
-
-
- -

Definition at line 105 of file signal.hpp.

- -
-
- -

◆ connect() [2/2]

- -
-
-
-template<typename... Args>
-
-template<typename Class , void(Class::*)(Args...) Member>
- - - - - -
- - - - - - - - -
void entt::Signal< void(Args...)>::connect (instance_type< Class > instance)
- 		-inline
-
- -

Connects a member function for a given instance to a signal.

-

The signal handler performs checks to avoid multiple connections for the same member function of a given instance.

-
Template Parameters
- - - -
ClassType of class to which the member function belongs.
MemberMember function to connect to the signal.
-
-
-
Parameters
- - -
instanceA valid instance of type pointer to Class.
-
-
- -

Definition at line 121 of file signal.hpp.

- -
-
- -

◆ disconnect() [1/3]

- -
-
-
-template<typename... Args>
-
-template<void(*)(Args...) Function>
- - - - - -
- - - - - - - -
void entt::Signal< void(Args...)>::disconnect ()
- 		-inline
-
- -

Disconnects a free function from a signal.

-
Template Parameters
- - -
FunctionA valid free function pointer.
-
-
- -

Definition at line 131 of file signal.hpp.

- -
-
- -

◆ disconnect() [2/3]

- -
-
-
-template<typename... Args>
-
-template<typename Class , void(Class::*)(Args...) Member>
- - - - - -
- - - - - - - - -
void entt::Signal< void(Args...)>::disconnect (instance_type< Class > instance)
- 		-inline
-
- -

Disconnects the given member function from a signal.

-
Template Parameters
- - - -
ClassType of class to which the member function belongs.
MemberMember function to connect to the signal.
-
-
-
Parameters
- - -
instanceA valid instance of type pointer to Class.
-
-
- -

Definition at line 144 of file signal.hpp.

- -
-
- -

◆ disconnect() [3/3]

- -
-
-
-template<typename... Args>
-
-template<typename Class >
- - - - - -
- - - - - - - - -
void entt::Signal< void(Args...)>::disconnect (instance_type< Class > instance)
- 		-inline
-
- -

Removes all existing connections for the given instance.

-
Template Parameters
- - -
ClassType of class to which the member function belongs.
-
-
-
Parameters
- - -
instanceA valid instance of type pointer to Class.
-
-
- -

Definition at line 156 of file signal.hpp.

- -
-
- -

◆ empty()

- -
-
-
-template<typename... Args>
- - - - - -
- - - - - - - -
bool entt::Signal< void(Args...)>::empty () const
- 		-inlinenoexcept
-
- -

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

- -
-
- -

◆ operator==()

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

Checks if the contents of the two signals are identical.

-

Two signals are identical if they have the same size and the same listeners registered exactly in the same order.

-
Parameters
- - -
otherSignal with which to compare.
-
-
-
Returns
True if the two signals are identical, false otherwise.
- -

Definition at line 202 of file signal.hpp.

- -
-
- -

◆ publish()

- -
-
-
-template<typename... Args>
- - - - - -
- - - - - - - - -
void entt::Signal< void(Args...)>::publish (Args... args)
- 		-inline
-
- -

Triggers a signal.

-

All the listeners are notified. Order isn't guaranteed.

-
Parameters
- - -
argsArguments to use to invoke listeners.
-
-
- -

Definition at line 169 of file signal.hpp.

- -
-
- -

◆ size()

- -
-
-
-template<typename... Args>
- - - - - -
- - - - - - - -
size_type entt::Signal< void(Args...)>::size () const
- 		-inlinenoexcept
-
- -

Number of listeners connected to the signal.

-
Returns
Number of listeners currently connected.
- -

Definition at line 77 of file signal.hpp.

- -
-
-

Friends And Related Function Documentation

- -

◆ swap

- -
-
-
-template<typename... Args>
- - - - - -
- - - - - - - - - - - - - - - - - - -
void swap (Signal< void(Args...)> & lhs,
Signal< void(Args...)> & rhs 
)
- 		-friend
-
- -

Swaps listeners between the two signals.

-
Parameters
- - - -
lhsA valid signal object.
rhsA valid signal object.
-
-
- -

Definition at line 188 of file signal.hpp.

- -
-
-
The documentation for this class was generated from the following file: -
- -
-Generated by   -doxygen - 1.8.13 -
- - diff --git a/classentt_1_1Signal.html b/classentt_1_1Sink.html similarity index 73% rename from classentt_1_1Signal.html rename to classentt_1_1Sink.html index 106700dfe..6f27d7d78 100644 --- a/classentt_1_1Signal.html +++ b/classentt_1_1Sink.html @@ -5,7 +5,7 @@ -entt: entt::Signal< typename > Class Template Reference +entt: entt::Sink< Function > Class Template Reference @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -59,29 +59,35 @@ $(function() {
-
entt::Signal< typename > Class Template Reference
+
entt::Sink< Function > Class Template Reference
-

Managed signal handler declaration. - More...

+

Sink implementation. + More...

-

#include <signal.hpp>

+

#include <sigh.hpp>

Detailed Description

-

template<typename>
-class entt::Signal< typename >

+

template<typename Function>
+class entt::Sink< Function >

-

Managed signal handler declaration.

-

Primary template isn't defined on purpose. All the specializations give a compile-time error unless the template parameter is a function type.

+

Sink implementation.

+

Primary template isn't defined on purpose. All the specializations give a compile-time error unless the template parameter is a function type.

+
Template Parameters
+ + +
FunctionA valid function type.
+
+
-

Definition at line 23 of file signal.hpp.

+

Definition at line 99 of file sigh.hpp.

The documentation for this class was generated from the following file:
diff --git a/classentt_1_1Bus_3_01Sig_00_01Event_01_4-members.html b/classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4-members.html similarity index 51% rename from classentt_1_1Bus_3_01Sig_00_01Event_01_4-members.html rename to classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4-members.html index 92c91a08a..38f087798 100644 --- a/classentt_1_1Bus_3_01Sig_00_01Event_01_4-members.html +++ b/classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4-members.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -59,25 +59,24 @@ $(function() {
-
entt::Bus< Sig, Event > Member List
+
entt::Sink< Ret(Args...)> Member List
-

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

+

This is the complete list of members for entt::Sink< Ret(Args...)>, including all inherited members.

- - - - - - - - + + + + + + +
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
connect()entt::Sink< Ret(Args...)>inline
connect(Class *instance)entt::Sink< Ret(Args...)>inline
disconnect()entt::Sink< Ret(Args...)>inline
disconnect(Class *instance)entt::Sink< Ret(Args...)>inline
disconnect(Class *instance)entt::Sink< Ret(Args...)>inline
disconnect()entt::Sink< Ret(Args...)>inline
SigH classentt::Sink< Ret(Args...)>friend
diff --git a/classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html b/classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html new file mode 100644 index 000000000..42efd171d --- /dev/null +++ b/classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html @@ -0,0 +1,364 @@ + + + + + + + +entt: entt::Sink< Ret(Args...)> Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
entt +  2.6.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+Public Member Functions | +Friends | +List of all members
+
+
entt::Sink< Ret(Args...)> Class Template Referencefinal
+
+
+ +

Sink implementation. + More...

+ +

#include <sigh.hpp>

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

+Public Member Functions

template<Ret(*)(Args...) Function>
void connect ()
 Connects a free function to a signal. More...
 
template<typename Class , Ret(Class::*)(Args...) Member = &Class::receive>
void connect (Class *instance)
 Connects a member function for a given instance to a signal. More...
 
template<Ret(*)(Args...) Function>
void disconnect ()
 Disconnects a free function from a signal. More...
 
template<typename Class , Ret(Class::*)(Args...) Member>
void disconnect (Class *instance)
 Disconnects the given member function from a signal. More...
 
template<typename Class >
void disconnect (Class *instance)
 Removes all existing connections for the given instance. More...
 
+void disconnect ()
 Disconnects all the listeners from a signal.
 
+ + + + + +

+Friends

+template<typename , typename >
class SigH
 A signal is allowed to create sinks.
 
+

Detailed Description

+

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

+ +

Sink implementation.

+

A sink is an opaque object used to connect listeners to signals.
+ The function type for a listener is the one of the signal to which it belongs.

+

The clear separation between a signal and a sink permits to store the former as private data member without exposing the publish functionality to the users of a class.

+
Template Parameters
+ + + +
RetReturn type of a function type.
ArgsTypes of arguments of a function type.
+
+
+ +

Definition at line 130 of file sigh.hpp.

+

Member Function Documentation

+ +

◆ connect() [1/2]

+ +
+
+
+template<typename Ret , typename... Args>
+
+template<Ret(*)(Args...) Function>
+ + + + + +
+ + + + + + + +
void entt::Sink< Ret(Args...)>::connect ()
+ 		+inline
+
+ +

Connects a free function to a signal.

+

The signal handler performs checks to avoid multiple connections for free functions.

+
Template Parameters
+ + +
FunctionA valid free function pointer.
+
+
+ +

Definition at line 162 of file sigh.hpp.

+ +
+
+ +

◆ connect() [2/2]

+ +
+
+
+template<typename Ret , typename... Args>
+
+template<typename Class , Ret(Class::*)(Args...) Member = &Class::receive>
+ + + + + +
+ + + + + + + + +
void entt::Sink< Ret(Args...)>::connect (Class * instance)
+ 		+inline
+
+ +

Connects a member function for a given instance to a signal.

+

The signal isn't responsible for the connected object. Users must guarantee that the lifetime of the instance overcomes the one of the signal. On the other side, the signal handler performs checks to avoid multiple connections for the same member function of a given instance.

+
Template Parameters
+ + + +
ClassType of class to which the member function belongs.
MemberMember function to connect to the signal.
+
+
+
Parameters
+ + +
instanceA valid instance of type pointer to Class.
+
+
+ +

Definition at line 181 of file sigh.hpp.

+ +
+
+ +

◆ disconnect() [1/3]

+ +
+
+
+template<typename Ret , typename... Args>
+
+template<Ret(*)(Args...) Function>
+ + + + + +
+ + + + + + + +
void entt::Sink< Ret(Args...)>::disconnect ()
+ 		+inline
+
+ +

Disconnects a free function from a signal.

+
Template Parameters
+ + +
FunctionA valid free function pointer.
+
+
+ +

Definition at line 191 of file sigh.hpp.

+ +
+
+ +

◆ disconnect() [2/3]

+ +
+
+
+template<typename Ret , typename... Args>
+
+template<typename Class , Ret(Class::*)(Args...) Member>
+ + + + + +
+ + + + + + + + +
void entt::Sink< Ret(Args...)>::disconnect (Class * instance)
+ 		+inline
+
+ +

Disconnects the given member function from a signal.

+
Template Parameters
+ + + +
ClassType of class to which the member function belongs.
MemberMember function to connect to the signal.
+
+
+
Parameters
+ + +
instanceA valid instance of type pointer to Class.
+
+
+ +

Definition at line 203 of file sigh.hpp.

+ +
+
+ +

◆ disconnect() [3/3]

+ +
+
+
+template<typename Ret , typename... Args>
+
+template<typename Class >
+ + + + + +
+ + + + + + + + +
void entt::Sink< Ret(Args...)>::disconnect (Class * instance)
+ 		+inline
+
+ +

Removes all existing connections for the given instance.

+
Template Parameters
+ + +
ClassType of class to which the member function belongs.
+
+
+
Parameters
+ + +
instanceA valid instance of type pointer to Class.
+
+
+ +

Definition at line 214 of file sigh.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1Snapshot-members.html b/classentt_1_1Snapshot-members.html index 14f74d194..682414ded 100644 --- a/classentt_1_1Snapshot-members.html +++ b/classentt_1_1Snapshot-members.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -70,11 +70,18 @@ $(function() {

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

- - - + + + + + + + - + + + +
component(Archive &archive) &&entt::Snapshot< Entity >inline
destroyed(Archive &archive) &&entt::Snapshot< Entity >inline
entities(Archive &archive) &&entt::Snapshot< Entity >inline
component(Archive &archive)entt::Snapshot< Entity >inline
component(Archive &archive)entt::Snapshot< Entity >inline
component(Archive &archive, It first, It last)entt::Snapshot< Entity >inline
destroyed(Archive &archive)entt::Snapshot< Entity >inline
entities(Archive &archive)entt::Snapshot< Entity >inline
operator=(const Snapshot &)=deleteentt::Snapshot< Entity >
operator=(Snapshot &&)=defaultentt::Snapshot< Entity >
Registry< Entity > classentt::Snapshot< Entity >friend
tag(Archive &archive) &&entt::Snapshot< Entity >inline
Snapshot(const Snapshot &)=deleteentt::Snapshot< Entity >
Snapshot(Snapshot &&)=defaultentt::Snapshot< Entity >
tag(Archive &archive)entt::Snapshot< Entity >inline
tag(Archive &archive)entt::Snapshot< Entity >inline
diff --git a/classentt_1_1Snapshot.html b/classentt_1_1Snapshot.html index 6eeeba341..deea9392a 100644 --- a/classentt_1_1Snapshot.html +++ b/classentt_1_1Snapshot.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -79,22 +79,48 @@ $(function() { - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Public Member Functions

template<typename Archive >
Snapshot entities (Archive &archive) &&
 Puts aside all the entities that are still in use. More...
 
template<typename Archive >
Snapshot destroyed (Archive &archive) &&
 Puts aside destroyed entities. More...
 
template<typename... Component, typename Archive >
Snapshot component (Archive &archive) &&
 Puts aside the given components. More...
 
template<typename... Tag, typename Archive >
Snapshot tag (Archive &archive) &&
 Puts aside the given tags. More...
 
+ Snapshot (const Snapshot &)=delete
 Copying a snapshot isn't allowed.
 
+ Snapshot (Snapshot &&)=default
 Default move constructor.
 
Snapshot & operator= (const Snapshot &)=delete
 Copying a snapshot isn't allowed. More...
 
Snapshot & operator= (Snapshot &&)=default
 Default move assignment operator. More...
 
template<typename Archive >
Snapshot & entities (Archive &archive)
 Puts aside all the entities that are still in use. More...
 
template<typename Archive >
Snapshot & destroyed (Archive &archive)
 Puts aside destroyed entities. More...
 
template<typename Component , typename Archive >
Snapshot & component (Archive &archive)
 Puts aside the given component. More...
 
template<typename... Component, typename Archive >
std::enable_if_t<(sizeof...(Component) > 1), Snapshot & > component (Archive &archive)
 Puts aside the given components. More...
 
template<typename... Component, typename Archive , typename It >
Snapshot & component (Archive &archive, It first, It last)
 Puts aside the given components for the entities in a range. More...
 
template<typename Tag , typename Archive >
Snapshot & tag (Archive &archive)
 Puts aside the given tag. More...
 
template<typename... Tag, typename Archive >
std::enable_if_t<(sizeof...(Tag) > 1), Snapshot & > tag (Archive &archive)
 Puts aside the given tags. More...
 
@@ -117,10 +143,59 @@ class entt::Snapshot< Entity > -

Definition at line 36 of file snapshot.hpp.

+

Definition at line 38 of file snapshot.hpp.

Member Function Documentation

- -

◆ component()

+ +

◆ component() [1/3]

+ +
+
+
+template<typename Entity >
+
+template<typename Component , typename Archive >
+

Friends

+ + + + +
+ + + + + + + + +
Snapshot& entt::Snapshot< Entity >::component (Archive & archive)
+ 		+inline
+
+ +

Puts aside the given component.

+

Each instance is serialized together with the entity to which it belongs. Entities are serialized along with their versions.

+
Template Parameters
+ + + +
ComponentType of component to serialize.
ArchiveType of output archive.
+
+
+
Parameters
+ + +
archiveA valid reference to an output archive.
+
+
+
Returns
An object of this type to continue creating the snapshot.
+ +

Definition at line 144 of file snapshot.hpp.

+ +
+ + +

◆ component() [2/3]

@@ -133,11 +208,11 @@ template<typename... Component, typename Archive >
- + - +
Snapshot entt::Snapshot< Entity >::component std::enable_if_t<(sizeof...(Component) > 1), Snapshot &> entt::Snapshot< Entity >::component ( Archive &  archive) &&
@@ -148,7 +223,7 @@ template<typename... Component, typename Archive >

Puts aside the given components.

-

Each component is serialized together with the entity to which it belongs. Entities are serialized along with their versions.

+

Each instance is serialized together with the entity to which it belongs. Entities are serialized along with their versions.

Template Parameters
@@ -164,12 +239,80 @@ template<typename... Component, typename Archive >
Returns
An object of this type to continue creating the snapshot.
-

Definition at line 142 of file snapshot.hpp.

+

Definition at line 171 of file snapshot.hpp.

- -

◆ destroyed()

+ +

◆ component() [3/3]

+ +
+
+
+template<typename Entity >
+
+template<typename... Component, typename Archive , typename It >
+
ComponentTypes of components to serialize.
+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
Snapshot& entt::Snapshot< Entity >::component (Archive & archive,
It first,
It last 
)
+ 		+inline
+
+ +

Puts aside the given components for the entities in a range.

+

Each instance is serialized together with the entity to which it belongs. Entities are serialized along with their versions.

+
Template Parameters
+ + + + +
ComponentTypes of components to serialize.
ArchiveType of output archive.
ItType of input iterator.
+
+
+
Parameters
+ + + + +
archiveA valid reference to an output archive.
firstAn iterator to the first element of the range to serialize.
lastAn iterator past the last element of the range to serialize.
+
+
+
Returns
An object of this type to continue creating the snapshot.
+ +

Definition at line 193 of file snapshot.hpp.

+ +
+ + +

◆ destroyed()

@@ -182,11 +325,11 @@ template<typename Archive >
- + - +
Snapshot entt::Snapshot< Entity >::destroyed Snapshot& entt::Snapshot< Entity >::destroyed ( Archive &  archive) &&
@@ -212,12 +355,12 @@ template<typename Archive >
Returns
An object of this type to continue creating the snapshot.
-

Definition at line 114 of file snapshot.hpp.

+

Definition at line 119 of file snapshot.hpp.

- -

◆ entities()

+ +

◆ entities()

@@ -230,11 +373,11 @@ template<typename Archive >
- + - +
Snapshot entt::Snapshot< Entity >::entities Snapshot& entt::Snapshot< Entity >::entities ( Archive &  archive) &&
@@ -260,12 +403,123 @@ template<typename Archive >
Returns
An object of this type to continue creating the snapshot.
-

Definition at line 97 of file snapshot.hpp.

+

Definition at line 102 of file snapshot.hpp.

- -

◆ tag()

+ +

◆ operator=() [1/2]

+ +
+
+
+template<typename Entity >
+ + + + + +
+ + + + + + + + +
Snapshot& entt::Snapshot< Entity >::operator= (const Snapshot< Entity > & )
+ 		+delete
+
+ +

Copying a snapshot isn't allowed.

+
Returns
This snapshot.
+ +
+
+ +

◆ operator=() [2/2]

+ +
+
+
+template<typename Entity >
+ + + + + +
+ + + + + + + + +
Snapshot& entt::Snapshot< Entity >::operator= (Snapshot< Entity > && )
+ 		+default
+
+ +

Default move assignment operator.

+
Returns
This snapshot.
+ +
+
+ +

◆ tag() [1/2]

+ +
+
+
+template<typename Entity >
+
+template<typename Tag , typename Archive >
+ + + + + +
+ + + + + + + + +
Snapshot& entt::Snapshot< Entity >::tag (Archive & archive)
+ 		+inline
+
+ +

Puts aside the given tag.

+

Each instance is serialized together with the entity to which it belongs. Entities are serialized along with their versions.

+
Template Parameters
+ + + +
TagType of tag to serialize.
ArchiveType of output archive.
+
+
+
Parameters
+ + +
archiveA valid reference to an output archive.
+
+
+
Returns
An object of this type to continue creating the snapshot.
+ +

Definition at line 210 of file snapshot.hpp.

+ +
+
+ +

◆ tag() [2/2]

@@ -278,11 +532,11 @@ template<typename... Tag, typename Archive >
- + - +
Snapshot entt::Snapshot< Entity >::tag std::enable_if_t<(sizeof...(Tag) > 1), Snapshot &> entt::Snapshot< Entity >::tag ( Archive &  archive) &&
@@ -293,7 +547,7 @@ template<typename... Tag, typename Archive >

Puts aside the given tags.

-

Each tag is serialized together with the entity to which it belongs. Entities are serialized along with their versions.

+

Each instance is serialized together with the entity to which it belongs. Entities are serialized along with their versions.

Template Parameters
@@ -309,7 +563,7 @@ template<typename... Tag, typename Archive >
Returns
An object of this type to continue creating the snapshot.
-

Definition at line 161 of file snapshot.hpp.

+

Definition at line 236 of file snapshot.hpp.

diff --git a/classentt_1_1SnapshotLoader-members.html b/classentt_1_1SnapshotLoader-members.html index 19052ca49..570f88110 100644 --- a/classentt_1_1SnapshotLoader-members.html +++ b/classentt_1_1SnapshotLoader-members.html @@ -22,7 +22,7 @@ @@ -70,12 +70,16 @@ $(function() {

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

TagTypes of tags to serialize.
entt -  2.5.0 +  2.6.0
- - - - + + + + + + - + + +
component(Archive &archive) &&entt::SnapshotLoader< Entity >inline
destroyed(Archive &archive) &&entt::SnapshotLoader< Entity >inline
entities(Archive &archive) &&entt::SnapshotLoader< Entity >inline
orphans() &&entt::SnapshotLoader< Entity >inline
component(Archive &archive)entt::SnapshotLoader< Entity >inline
destroyed(Archive &archive)entt::SnapshotLoader< Entity >inline
entities(Archive &archive)entt::SnapshotLoader< Entity >inline
operator=(const SnapshotLoader &)=deleteentt::SnapshotLoader< Entity >
operator=(SnapshotLoader &&)=defaultentt::SnapshotLoader< Entity >
orphans()entt::SnapshotLoader< Entity >inline
Registry< Entity > classentt::SnapshotLoader< Entity >friend
tag(Archive &archive) &&entt::SnapshotLoader< Entity >inline
SnapshotLoader(const SnapshotLoader &)=deleteentt::SnapshotLoader< Entity >
SnapshotLoader(SnapshotLoader &&)=defaultentt::SnapshotLoader< Entity >
tag(Archive &archive)entt::SnapshotLoader< Entity >inline
diff --git a/classentt_1_1SnapshotLoader.html b/classentt_1_1SnapshotLoader.html index 7e5d26fdd..db22b87bd 100644 --- a/classentt_1_1SnapshotLoader.html +++ b/classentt_1_1SnapshotLoader.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -79,25 +79,39 @@ $(function() { - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Public Member Functions

template<typename Archive >
SnapshotLoader entities (Archive &archive) &&
 Restores entities that were in use during serialization. More...
 
template<typename Archive >
SnapshotLoader destroyed (Archive &archive) &&
 Restores entities that were destroyed during serialization. More...
 
template<typename... Component, typename Archive >
SnapshotLoader component (Archive &archive) &&
 Restores components and assigns them to the right entities. More...
 
template<typename... Tag, typename Archive >
SnapshotLoader tag (Archive &archive) &&
 Restores tags and assigns them to the right entities. More...
 
SnapshotLoader orphans () &&
 Destroys those entities that have neither components nor tags. More...
 
+ SnapshotLoader (const SnapshotLoader &)=delete
 Copying a snapshot loader isn't allowed.
 
+ SnapshotLoader (SnapshotLoader &&)=default
 Default move constructor.
 
SnapshotLoader & operator= (const SnapshotLoader &)=delete
 Copying a snapshot loader isn't allowed. More...
 
SnapshotLoader & operator= (SnapshotLoader &&)=default
 Default move assignment operator. More...
 
template<typename Archive >
SnapshotLoader & entities (Archive &archive)
 Restores entities that were in use during serialization. More...
 
template<typename Archive >
SnapshotLoader & destroyed (Archive &archive)
 Restores entities that were destroyed during serialization. More...
 
template<typename... Component, typename Archive >
SnapshotLoader & component (Archive &archive)
 Restores components and assigns them to the right entities. More...
 
template<typename... Tag, typename Archive >
SnapshotLoader & tag (Archive &archive)
 Restores tags and assigns them to the right entities. More...
 
SnapshotLoader & orphans ()
 Destroys those entities that have neither components nor tags. More...
 
@@ -120,10 +134,10 @@ class entt::SnapshotLoader< Entity > -

Definition at line 188 of file snapshot.hpp.

+

Definition at line 261 of file snapshot.hpp.

Member Function Documentation

- -

◆ component()

+ +

◆ component()

@@ -136,11 +150,11 @@ template<typename... Component, typename Archive >
@@ -167,12 +181,12 @@ template<typename... Component, typename Archive >
Returns
A valid loader to continue restoring data.
-

Definition at line 294 of file snapshot.hpp.

+

Definition at line 361 of file snapshot.hpp.

- -

◆ destroyed()

+ +

◆ destroyed()

@@ -185,11 +199,11 @@ template<typename Archive >
@@ -215,12 +229,12 @@ template<typename Archive >
Returns
A valid loader to continue restoring data.
-

Definition at line 271 of file snapshot.hpp.

+

Definition at line 341 of file snapshot.hpp.

- -

◆ entities()

+ +

◆ entities()

@@ -233,11 +247,11 @@ template<typename Archive >
@@ -263,12 +277,12 @@ template<typename Archive >
Returns
A valid loader to continue restoring data.
-

Definition at line 251 of file snapshot.hpp.

+

Definition at line 324 of file snapshot.hpp.

- -

◆ orphans()

+ +

◆ operator=() [1/2]

@@ -279,10 +293,72 @@ template<typename Entity >
+ + +

Friends

- + - +
SnapshotLoader entt::SnapshotLoader< Entity >::component SnapshotLoader& entt::SnapshotLoader< Entity >::component ( Archive &  archive) &&
- + - +
SnapshotLoader entt::SnapshotLoader< Entity >::destroyed SnapshotLoader& entt::SnapshotLoader< Entity >::destroyed ( Archive &  archive) &&
- + - +
SnapshotLoader entt::SnapshotLoader< Entity >::entities SnapshotLoader& entt::SnapshotLoader< Entity >::entities ( Archive &  archive) &&
- + + + + + + +
SnapshotLoader entt::SnapshotLoader< Entity >::orphans SnapshotLoader& entt::SnapshotLoader< Entity >::operator= (const SnapshotLoader< Entity > & )
+ 		+delete
+
+ +

Copying a snapshot loader isn't allowed.

+
Returns
This loader.
+ +
+ + +

◆ operator=() [2/2]

+ +
+
+
+template<typename Entity >
+ + + + + +
+ + + + + + + + +
SnapshotLoader& entt::SnapshotLoader< Entity >::operator= (SnapshotLoader< Entity > && )
+ 		+default
+
+ +

Default move assignment operator.

+
Returns
This loader.
+ +
+
+ +

◆ orphans()

+ +
+
+
+template<typename Entity >
+ + + @@ -297,12 +373,12 @@ template<typename Entity > This functions helps to identify and destroy those entities.

Returns
A valid loader to continue restoring data.
-

Definition at line 333 of file snapshot.hpp.

+

Definition at line 399 of file snapshot.hpp.

- -

◆ tag()

+ +

◆ tag()

@@ -315,11 +391,11 @@ template<typename... Tag, typename Archive >
@@ -346,7 +422,7 @@ template<typename... Tag, typename Archive >
Returns
A valid loader to continue restoring data.
-

Definition at line 315 of file snapshot.hpp.

+

Definition at line 382 of file snapshot.hpp.

diff --git a/classentt_1_1SparseSet.html b/classentt_1_1SparseSet.html index a621f77ef..95213147b 100644 --- a/classentt_1_1SparseSet.html +++ b/classentt_1_1SparseSet.html @@ -22,7 +22,7 @@ @@ -79,7 +79,7 @@ class entt::SparseSet<... >

Sparse set.

Primary template isn't defined on purpose. All the specializations give a compile-time error, but for a few reasonable cases.

-

Definition at line 26 of file sparse_set.hpp.

+

Definition at line 28 of file sparse_set.hpp.

The documentation for this class was generated from the following file: 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 e86801f34..fd84edd48 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 @@ @@ -70,40 +70,44 @@ $(function() {

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

+ + + - +
SnapshotLoader& entt::SnapshotLoader< Entity >::orphans ( ) &&
- + - +
SnapshotLoader entt::SnapshotLoader< Entity >::tag SnapshotLoader& entt::SnapshotLoader< Entity >::tag ( Archive &  archive) &&
entt -  2.5.0 +  2.6.0
entt -  2.5.0 +  2.6.0
- - - - - - - - - - + + + + + + + + + + + + + + - - - - - - + + + + + + - - - + + + - - + + - - + + - - + +
begin() noexceptentt::SparseSet< Entity, Type >inline
entt::SparseSet< Entity >::begin() const noexceptentt::SparseSet< Entity >inline
construct(entity_type entity, Args &&... args)entt::SparseSet< Entity, Type >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() noexceptentt::SparseSet< Entity, Type >inline
entt::SparseSet< Entity >::end() const noexceptentt::SparseSet< Entity >inline
begin() const ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
begin() ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
cbegin() const ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
cend() const ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
clone(const entity_type entity, const entity_type source) overrideentt::SparseSet< Entity, Type >inlinevirtual
const_iterator_type typedefentt::SparseSet< Entity, Type >
construct(const entity_type entity, Args &&... args)entt::SparseSet< Entity, Type >inline
construct(const entity_type entity, Args &&... args)entt::SparseSet< Entity, Type >inline
entt::SparseSet< Entity >::construct(const entity_type entity)entt::SparseSet< Entity >inline
data() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
destroy(const entity_type entity) overrideentt::SparseSet< Entity, Type >inlinevirtual
empty() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
end() const ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
end() ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
entity_type typedefentt::SparseSet< Entity, Type >
extent() const noexceptentt::SparseSet< Entity >inline
fast(entity_type entity) const noexceptentt::SparseSet< Entity >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 >
extent() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
fast(const entity_type entity) const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
get(const entity_type entity) const ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
get(const entity_type entity) ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
has(const entity_type entity) const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
iterator_type typedefentt::SparseSet< Entity, Type >
object_type typedefentt::SparseSet< Entity, Type >
operator=(const SparseSet &)=deleteentt::SparseSet< Entity, Type >
operator=(SparseSet &&)=defaultentt::SparseSet< Entity, Type >
pos_type typedefentt::SparseSet< Entity, Type >
raw() const noexceptentt::SparseSet< Entity, Type >inline
raw() noexceptentt::SparseSet< Entity, Type >inline
reserve(size_type cap)entt::SparseSet< Entity, Type >inline
raw() const ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
raw() ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
reserve(const size_type cap)entt::SparseSet< Entity, Type >inline
reset() overrideentt::SparseSet< Entity, Type >inlinevirtual
respect(const SparseSet< Entity > &other) noexceptentt::SparseSet< Entity, Type >inline
size() const noexceptentt::SparseSet< Entity >inline
respect(const SparseSet< Entity > &other) ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
size() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
size_type typedefentt::SparseSet< Entity, Type >
sort(Compare compare)entt::SparseSet< Entity, Type >inline
SparseSet() noexcept=defaultentt::SparseSet< Entity, Type >
sort(Compare compare, Sort sort=Sort{})entt::SparseSet< Entity, Type >inline
SparseSet() ENTT_NOEXCEPT=defaultentt::SparseSet< Entity, Type >
SparseSet(const SparseSet &)=deleteentt::SparseSet< Entity, Type >
SparseSet(SparseSet &&)=defaultentt::SparseSet< Entity, Type >
swap(pos_type lhs, pos_type rhs) noexceptentt::SparseSet< Entity >inline
~SparseSet() noexcept=defaultentt::SparseSet< Entity >virtual
swap(const pos_type lhs, const pos_type rhs) ENTT_NOEXCEPTentt::SparseSet< Entity >inline
~SparseSet() ENTT_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 706e03fa2..e37b1920f 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.5.0 +  2.6.0
@@ -112,10 +112,14 @@ using size_type = typename underlying_type::size_type  Unsigned integer type.
  - -using iterator_type = Iterator - Input iterator type.
-  + +using iterator_type = Iterator< false > + Input iterator type.
+  + +using const_iterator_type = Iterator< true > + Constant input iterator type.
+  - Public Types inherited from entt::SparseSet< Entity > using entity_type = Entity @@ -133,13 +137,17 @@ using iterator_type = Iterator  Input iterator type.
  + +using const_iterator_type = Iterator + Constant input iterator type.
+  - - - + + + @@ -154,58 +162,73 @@ Public Member Functions - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - + + + + + + @@ -220,45 +243,57 @@ virtual  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Public Member Functions

- SparseSet () noexcept=default
 Default constructor.
 
+ SparseSet () ENTT_NOEXCEPT=default
 Default constructor.
 
 SparseSet (const SparseSet &)=delete
 Copying a sparse set isn't allowed.
SparseSet & operator= (SparseSet &&)=default
 Default move assignment operator. More...
 
void reserve (size_type cap)
 Increases the capacity of a sparse set. 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...
 
iterator_type begin () noexcept
 Returns an iterator to the beginning. More...
 
iterator_type end () noexcept
 Returns an iterator to the end. 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>
std::enable_if_t< std::is_constructible< Type, Args... >::value, object_type & > construct (entity_type entity, Args &&... args)
 Assigns an entity to a sparse set and constructs its object. More...
 
template<typename... Args>
std::enable_if_t<!std::is_constructible< Type, Args... >::value, object_type & > construct (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 a sparse set and destroies its object. More...
 
template<typename Compare >
void sort (Compare compare)
 Sort components according to the given comparison function. More...
 
void respect (const SparseSet< Entity > &other) noexcept
 Sort components according to the order of the entities in another sparse set. More...
 
void reserve (const size_type cap)
 Increases the capacity of a sparse set. More...
 
const object_type * raw () const ENTT_NOEXCEPT
 Direct access to the array of objects. More...
 
object_type * raw () ENTT_NOEXCEPT
 Direct access to the array of objects. More...
 
const_iterator_type cbegin () const ENTT_NOEXCEPT
 Returns an iterator to the beginning. More...
 
const_iterator_type begin () const ENTT_NOEXCEPT
 Returns an iterator to the beginning. More...
 
iterator_type begin () ENTT_NOEXCEPT
 Returns an iterator to the beginning. More...
 
const_iterator_type cend () const ENTT_NOEXCEPT
 Returns an iterator to the end. More...
 
const_iterator_type end () const ENTT_NOEXCEPT
 Returns an iterator to the end. More...
 
iterator_type end () ENTT_NOEXCEPT
 Returns an iterator to the end. More...
 
const object_type & get (const entity_type entity) const ENTT_NOEXCEPT
 Returns the object associated to an entity. More...
 
object_type & get (const entity_type entity) ENTT_NOEXCEPT
 Returns the object associated to an entity. More...
 
template<typename... Args>
std::enable_if_t< std::is_constructible< Type, Args... >::value, object_type & > construct (const entity_type entity, Args &&... args)
 Assigns an entity to a sparse set and constructs its object. More...
 
template<typename... Args>
std::enable_if_t<!std::is_constructible< Type, Args... >::value, object_type & > construct (const entity_type entity, Args &&... args)
 Assigns an entity to a sparse set and constructs its object. More...
 
void clone (const entity_type entity, const entity_type source) override
 Assigns an entity to a sparse set by cloning another entity. More...
 
void destroy (const entity_type entity) override
 Removes an entity from a sparse set and destroies its object. More...
 
template<typename Compare , typename Sort = StdSort>
void sort (Compare compare, Sort sort=Sort{})
 Sort components according to the given comparison function. More...
 
void respect (const SparseSet< Entity > &other) ENTT_NOEXCEPT
 Sort components according to the order of the entities in another sparse set. More...
 
void reset () override
 Resets a sparse set.
 
- Public Member Functions inherited from entt::SparseSet< Entity >
- SparseSet () noexcept=default
 Default constructor.
 
-virtual ~SparseSet () noexcept=default
 Default destructor.
 
+ SparseSet () ENTT_NOEXCEPT=default
 Default constructor.
 
+virtual ~SparseSet () ENTT_NOEXCEPT=default
 Default destructor.
 
 SparseSet (const SparseSet &)=delete
 Copying a sparse set isn't allowed.
SparseSet & operator= (SparseSet &&)=default
 Default move assignment operator. More...
 
void reserve (size_type cap)
 Increases the capacity of a sparse set. More...
 
size_type extent () const noexcept
 Returns the extent of a sparse set. More...
 
size_type size () const noexcept
 Returns the number of elements in a sparse set. More...
 
bool empty () const noexcept
 Checks whether a sparse set is empty. More...
 
const entity_type * data () const noexcept
 Direct access to the internal packed array. More...
 
iterator_type begin () const noexcept
 Returns an iterator to the beginning. More...
 
iterator_type end () const noexcept
 Returns an iterator to the end. More...
 
bool has (entity_type entity) const noexcept
 Checks if a sparse set contains an entity. More...
 
bool fast (entity_type entity) const noexcept
 Checks if a sparse set contains an entity (unsafe). More...
 
pos_type get (entity_type entity) const noexcept
 Returns the position of an entity in a sparse set. More...
 
void construct (entity_type entity)
 Assigns an entity to a sparse set. More...
 
void swap (pos_type lhs, pos_type rhs) noexcept
 Swaps the position of two entities in the internal packed array. More...
 
void respect (const SparseSet< Entity > &other) noexcept
 Sort entities according to their order in another sparse set. More...
 
void reserve (const size_type cap)
 Increases the capacity of a sparse set. More...
 
size_type extent () const ENTT_NOEXCEPT
 Returns the extent of a sparse set. More...
 
size_type size () const ENTT_NOEXCEPT
 Returns the number of elements in a sparse set. More...
 
bool empty () const ENTT_NOEXCEPT
 Checks whether a sparse set is empty. More...
 
const entity_type * data () const ENTT_NOEXCEPT
 Direct access to the internal packed array. More...
 
const_iterator_type cbegin () const ENTT_NOEXCEPT
 Returns an iterator to the beginning. More...
 
const_iterator_type begin () const ENTT_NOEXCEPT
 Returns an iterator to the beginning. More...
 
iterator_type begin () ENTT_NOEXCEPT
 Returns an iterator to the beginning. More...
 
const_iterator_type cend () const ENTT_NOEXCEPT
 Returns an iterator to the end. More...
 
const_iterator_type end () const ENTT_NOEXCEPT
 Returns an iterator to the end. More...
 
iterator_type end () ENTT_NOEXCEPT
 Returns an iterator to the end. More...
 
bool has (const entity_type entity) const ENTT_NOEXCEPT
 Checks if a sparse set contains an entity. More...
 
bool fast (const entity_type entity) const ENTT_NOEXCEPT
 Checks if a sparse set contains an entity (unsafe). More...
 
pos_type get (const entity_type entity) const ENTT_NOEXCEPT
 Returns the position of an entity in a sparse set. More...
 
void construct (const entity_type entity)
 Assigns an entity to a sparse set. More...
 
void swap (const pos_type lhs, const pos_type rhs) ENTT_NOEXCEPT
 Swaps the position of two entities in the internal packed array. More...
 
void respect (const SparseSet< Entity > &other) ENTT_NOEXCEPT
 Sort entities according to their order in another sparse set. More...
 

Detailed Description

template<typename Entity, typename Type>
@@ -278,10 +313,44 @@ Internal data structures arrange elements to maximize performance. Because of th -

Definition at line 436 of file sparse_set.hpp.

+

Definition at line 523 of file sparse_set.hpp.

Member Function Documentation

- -

◆ begin()

+ +

◆ begin() [1/2]

+ +
+
+
+template<typename Entity , typename Type >
+ + + + + +
+ + + + + + + +
const_iterator_type entt::SparseSet< Entity, Type >::begin () const
+ 		+inline
+
+ +

Returns an iterator to the beginning.

+

The returned iterator points to the first instance of the given type. If the sparse set is empty, the returned iterator will be equal to end().

+
Note
Input iterators stay true to the order imposed by a call to either sort or respect.
+
Returns
An iterator to the first instance of the given type.
+ +

Definition at line 683 of file sparse_set.hpp.

+ +
+
+ +

◆ begin() [2/2]

@@ -300,22 +369,143 @@ template<typename Entity , typename Type >
-inlinenoexcept +inline

Returns an iterator to the beginning.

-

The returned iterator points to the first instance of the given type. If the sparse set is empty, the returned iterator will be equal to end().

+

The returned iterator points to the first instance of the given type. If the sparse set is empty, the returned iterator will be equal to end().

Note
Input iterators stay true to the order imposed by a call to either sort or respect.
Returns
An iterator to the first instance of the given type.
-

Definition at line 577 of file sparse_set.hpp.

+

Definition at line 699 of file sparse_set.hpp.

- -

◆ construct() [1/2]

+ +

◆ cbegin()

+ +
+
+
+template<typename Entity , typename Type >
+ + + + + +
+ + + + + + + +
const_iterator_type entt::SparseSet< Entity, Type >::cbegin () const
+ 		+inline
+
+ +

Returns an iterator to the beginning.

+

The returned iterator points to the first instance of the given type. If the sparse set is empty, the returned iterator will be equal to end().

+
Note
Input iterators stay true to the order imposed by a call to either sort or respect.
+
Returns
An iterator to the first instance of the given type.
+ +

Definition at line 667 of file sparse_set.hpp.

+ +
+
+ +

◆ cend()

+ +
+
+
+template<typename Entity , typename Type >
+ + + + + +
+ + + + + + + +
const_iterator_type entt::SparseSet< Entity, Type >::cend () const
+ 		+inline
+
+ +

Returns an iterator to the end.

+

The returned iterator points to the element following the last instance of the given type. Attempting to dereference the returned iterator results in undefined behavior.

+
Note
Input iterators stay true to the order imposed by a call to either sort or respect.
+
Returns
An iterator to the element following the last instance of the given type.
+ +

Definition at line 717 of file sparse_set.hpp.

+ +
+
+ +

◆ clone()

+ +
+
+
+template<typename Entity , typename Type >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void entt::SparseSet< Entity, Type >::clone (const entity_type entity,
const entity_type source 
)
+ 		+inlineoverridevirtual
+
+ +

Assigns an entity to a sparse set by cloning another entity.

+
Warning
Attempting to clone an entity that doesn't belong to the sparse set or 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 doesn't contain the entity to clone or if it already contains the given entity.
+
Parameters
+ + + +
entityA valid entity identifier.
sourceA valid entity identifier from which to clone.
+
+
+ +

Reimplemented from entt::SparseSet< Entity >.

+ +

Definition at line 859 of file sparse_set.hpp.

+ +
+
+ +

◆ construct() [1/2]

@@ -330,7 +520,7 @@ template<typename... Args>
std::enable_if_t<std::is_constructible<Type, Args...>::value, object_type &> entt::SparseSet< Entity, Type >::construct ( - entity_type  + const entity_type  entity, @@ -372,12 +562,12 @@ template<typename... Args>
Returns
The object associated to the entity.
-

Definition at line 653 of file sparse_set.hpp.

+

Definition at line 811 of file sparse_set.hpp.

- -

◆ construct() [2/2]

+ +

◆ construct() [2/2]

@@ -392,7 +582,7 @@ template<typename... Args>
std::enable_if_t<!std::is_constructible<Type, Args...>::value, object_type &> entt::SparseSet< Entity, Type >::construct ( - entity_type  + const entity_type  entity, @@ -434,12 +624,12 @@ template<typename... Args>
Returns
The object associated to the entity.
-

Definition at line 681 of file sparse_set.hpp.

+

Definition at line 839 of file sparse_set.hpp.

- -

◆ destroy()

+ +

◆ destroy()

@@ -452,7 +642,7 @@ template<typename Entity , typename Type >
void entt::SparseSet< Entity, Type >::destroy ( - entity_type  + const entity_type  entity) @@ -474,14 +664,48 @@ template<typename Entity , typename Type >
-

Reimplemented from entt::SparseSet< Entity >.

+

Reimplemented from entt::SparseSet< Entity >.

-

Definition at line 698 of file sparse_set.hpp.

+

Definition at line 874 of file sparse_set.hpp.

- -

◆ end()

+ +

◆ end() [1/2]

+ +
+
+
+template<typename Entity , typename Type >
+ + + + + +
+ + + + + + + +
const_iterator_type entt::SparseSet< Entity, Type >::end () const
+ 		+inline
+
+ +

Returns an iterator to the end.

+

The returned iterator points to the element following the last instance of the given type. Attempting to dereference the returned iterator results in undefined behavior.

+
Note
Input iterators stay true to the order imposed by a call to either sort or respect.
+
Returns
An iterator to the element following the last instance of the given type.
+ +

Definition at line 735 of file sparse_set.hpp.

+ +
+
+ +

◆ end() [2/2]

@@ -500,7 +724,7 @@ template<typename Entity , typename Type >
-inlinenoexcept +inline
@@ -510,12 +734,12 @@ template<typename Entity , typename Type >
Note
Input iterators stay true to the order imposed by a call to either sort or respect.
Returns
An iterator to the element following the last instance of the given type.
-

Definition at line 595 of file sparse_set.hpp.

+

Definition at line 753 of file sparse_set.hpp.

- -

◆ get() [1/2]

+ +

◆ get() [1/2]

@@ -528,14 +752,14 @@ template<typename Entity , typename Type >
const object_type& entt::SparseSet< Entity, Type >::get ( - entity_type  + const entity_type  entity) const -inlinenoexcept +inline
@@ -551,12 +775,12 @@ template<typename Entity , typename Type >
Returns
The object associated to the entity.
-

Definition at line 611 of file sparse_set.hpp.

+

Definition at line 769 of file sparse_set.hpp.

- -

◆ get() [2/2]

+ +

◆ get() [2/2]

@@ -569,14 +793,14 @@ template<typename Entity , typename Type >
object_type& entt::SparseSet< Entity, Type >::get ( - entity_type  + const entity_type  entity) -inlinenoexcept +inline
@@ -592,7 +816,7 @@ template<typename Entity , typename Type >
Returns
The object associated to the entity.
-

Definition at line 627 of file sparse_set.hpp.

+

Definition at line 785 of file sparse_set.hpp.

@@ -658,8 +882,8 @@ template<typename Entity , typename Type > - -

◆ raw() [1/2]

+ +

◆ raw() [1/2]

@@ -678,22 +902,22 @@ template<typename Entity , typename Type >
-inlinenoexcept +inline

Direct access to the array of objects.

-

The returned pointer is such that range [raw(), raw() + size()] is always a valid range, even if the container is empty.

+

The returned pointer is such that range [raw(), raw() + size()] is always a valid range, even if the container is empty.

Note
There are no guarantees on the order, even though either sort or respect has been previously invoked. Internal data structures arrange elements to maximize performance. Accessing them directly gives a performance boost but less guarantees. Use begin and end if you want to iterate the sparse set in the expected order.
Returns
A pointer to the array of objects.
-

Definition at line 542 of file sparse_set.hpp.

+

Definition at line 632 of file sparse_set.hpp.

- -

◆ raw() [2/2]

+ +

◆ raw() [2/2]

@@ -712,22 +936,22 @@ template<typename Entity , typename Type >
-inlinenoexcept +inline

Direct access to the array of objects.

-

The returned pointer is such that range [raw(), raw() + size()] is always a valid range, even if the container is empty.

+

The returned pointer is such that range [raw(), raw() + size()] is always a valid range, even if the container is empty.

Note
There are no guarantees on the order, even though either sort or respect has been previously invoked. Internal data structures arrange elements to maximize performance. Accessing them directly gives a performance boost but less guarantees. Use begin and end if you want to iterate the sparse set in the expected order.
Returns
A pointer to the array of objects.
-

Definition at line 561 of file sparse_set.hpp.

+

Definition at line 651 of file sparse_set.hpp.

- -

◆ reserve()

+ +

◆ reserve()

@@ -740,7 +964,7 @@ template<typename Entity , typename Type >
void entt::SparseSet< Entity, Type >::reserve ( - size_type  + const size_type  cap) @@ -761,12 +985,12 @@ template<typename Entity , typename Type >
-

Definition at line 522 of file sparse_set.hpp.

+

Definition at line 612 of file sparse_set.hpp.

- -

◆ respect()

+ +

◆ respect()

@@ -786,7 +1010,7 @@ template<typename Entity , typename Type >
-inlinenoexcept +inline
@@ -803,19 +1027,19 @@ template<typename Entity , typename Type >
-

Definition at line 778 of file sparse_set.hpp.

+

Definition at line 970 of file sparse_set.hpp.

- -

◆ sort()

+ +

◆ sort()

template<typename Entity , typename Type >
-template<typename Compare >
+template<typename Compare , typename Sort = StdSort>
- + + + + + + + + + + +
@@ -824,8 +1048,18 @@ template<typename Compare > void entt::SparseSet< Entity, Type >::sort ( Compare compare)compare,
Sort sort = Sort{} 
)
@@ -838,21 +1072,31 @@ template<typename Compare >

Sort components according to the given comparison function.

Sort the elements so that iterating the sparse set with a couple of iterators returns them in the expected order. See begin and end for more details.

The comparison function object must return true if the first element is less than the second one, false otherwise. The signature of the comparison function should be equivalent to the following:

-
bool(const Type &, const Type &)
Note
Attempting to iterate elements using a raw pointer returned by a call to either data or raw gives no guarantees on the order, even though sort has been invoked.
+
bool(const Type &, const Type &)

Moreover, the comparison function object shall induce a strict weak ordering on the values.

+

The sort function oject must offer a member function template operator() that accepts three arguments:

+
    +
  • An iterator to the first element of the range to sort.
    • +
  • An iterator past the last element of the range to sort.
    • +
  • A comparison function to use to compare the elements.
    • +
+

The comparison funtion object received by the sort function object hasn't necessarily the type of the one passed along with the other parameters to this member function.

+
Note
Attempting to iterate elements using a raw pointer returned by a call to either data or raw gives no guarantees on the order, even though sort has been invoked.
Template Parameters
+
CompareType of comparison function object.
SortType of sort function object.
Parameters
+
compareA valid comparison function object.
sortA valid sort function object.
-

Definition at line 731 of file sparse_set.hpp.

+

Definition at line 923 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 ec567e543..6d2eb92ba 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.5.0 +  2.6.0
@@ -70,31 +70,37 @@ $(function() {

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

- - - - - - + + + + + + + + + + + + - - - - + + + + - + - - + + - + - - + +
begin() const noexceptentt::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
end() const noexceptentt::SparseSet< Entity >inline
begin() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
begin() ENTT_NOEXCEPTentt::SparseSet< Entity >inline
cbegin() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
cend() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
clone(const entity_type entity, const entity_type source)entt::SparseSet< Entity >inlinevirtual
const_iterator_type typedefentt::SparseSet< Entity >
construct(const entity_type entity)entt::SparseSet< Entity >inline
data() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
destroy(const entity_type entity)entt::SparseSet< Entity >inlinevirtual
empty() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
end() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
end() ENTT_NOEXCEPTentt::SparseSet< Entity >inline
entity_type typedefentt::SparseSet< Entity >
extent() const noexceptentt::SparseSet< Entity >inline
fast(entity_type entity) const noexceptentt::SparseSet< Entity >inline
get(entity_type entity) const noexceptentt::SparseSet< Entity >inline
has(entity_type entity) const noexceptentt::SparseSet< Entity >inline
extent() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
fast(const entity_type entity) const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
get(const entity_type entity) const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
has(const entity_type entity) const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
iterator_type typedefentt::SparseSet< Entity >
operator=(const SparseSet &)=deleteentt::SparseSet< Entity >
operator=(SparseSet &&)=defaultentt::SparseSet< Entity >
pos_type typedefentt::SparseSet< Entity >
reserve(size_type cap)entt::SparseSet< Entity >inline
reserve(const size_type cap)entt::SparseSet< Entity >inline
reset()entt::SparseSet< Entity >inlinevirtual
respect(const SparseSet< Entity > &other) noexceptentt::SparseSet< Entity >inline
size() const noexceptentt::SparseSet< Entity >inline
respect(const SparseSet< Entity > &other) ENTT_NOEXCEPTentt::SparseSet< Entity >inline
size() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
size_type typedefentt::SparseSet< Entity >
SparseSet() noexcept=defaultentt::SparseSet< Entity >
SparseSet() ENTT_NOEXCEPT=defaultentt::SparseSet< Entity >
SparseSet(const SparseSet &)=deleteentt::SparseSet< Entity >
SparseSet(SparseSet &&)=defaultentt::SparseSet< Entity >
swap(pos_type lhs, pos_type rhs) noexceptentt::SparseSet< Entity >inline
~SparseSet() noexcept=defaultentt::SparseSet< Entity >virtual
swap(const pos_type lhs, const pos_type rhs) ENTT_NOEXCEPTentt::SparseSet< Entity >inline
~SparseSet() ENTT_NOEXCEPT=defaultentt::SparseSet< Entity >virtual
diff --git a/classentt_1_1SparseSet_3_01Entity_01_4.html b/classentt_1_1SparseSet_3_01Entity_01_4.html index ba68c24c7..74e2fc6b5 100644 --- a/classentt_1_1SparseSet_3_01Entity_01_4.html +++ b/classentt_1_1SparseSet_3_01Entity_01_4.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -104,17 +104,21 @@ using iterator_type = Iterator  Input iterator type.
  + +using const_iterator_type = Iterator + Constant input iterator type.
+  - - - - - - + + + + + + @@ -129,48 +133,63 @@ virtual  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -195,10 +214,44 @@ Internal data structures arrange elements to maximize performance. Because of th -

Definition at line 57 of file sparse_set.hpp.

+

Definition at line 59 of file sparse_set.hpp.

Member Function Documentation

- -

◆ begin()

+ +

◆ begin() [1/2]

+ +
+
+
+template<typename Entity >
+

Public Member Functions

- SparseSet () noexcept=default
 Default constructor.
 
-virtual ~SparseSet () noexcept=default
 Default destructor.
 
+ SparseSet () ENTT_NOEXCEPT=default
 Default constructor.
 
+virtual ~SparseSet () ENTT_NOEXCEPT=default
 Default destructor.
 
 SparseSet (const SparseSet &)=delete
 Copying a sparse set isn't allowed.
SparseSet & operator= (SparseSet &&)=default
 Default move assignment operator. More...
 
void reserve (size_type cap)
 Increases the capacity of a sparse set. More...
 
size_type extent () const noexcept
 Returns the extent of a sparse set. More...
 
size_type size () const noexcept
 Returns the number of elements in a sparse set. More...
 
bool empty () const noexcept
 Checks whether a sparse set is empty. More...
 
const entity_type * data () const noexcept
 Direct access to the internal packed array. More...
 
iterator_type begin () const noexcept
 Returns an iterator to the beginning. More...
 
iterator_type end () const noexcept
 Returns an iterator to the end. More...
 
bool has (entity_type entity) const noexcept
 Checks if a sparse set contains an entity. More...
 
bool fast (entity_type entity) const noexcept
 Checks if a sparse set contains an entity (unsafe). More...
 
pos_type get (entity_type entity) const noexcept
 Returns the position of an entity in a sparse set. More...
 
void construct (entity_type entity)
 Assigns an entity to a sparse set. More...
 
virtual void destroy (entity_type entity)
 Removes an entity from a sparse set. More...
 
void swap (pos_type lhs, pos_type rhs) noexcept
 Swaps the position of two entities in the internal packed array. More...
 
void respect (const SparseSet< Entity > &other) noexcept
 Sort entities according to their order in another sparse set. More...
 
void reserve (const size_type cap)
 Increases the capacity of a sparse set. More...
 
size_type extent () const ENTT_NOEXCEPT
 Returns the extent of a sparse set. More...
 
size_type size () const ENTT_NOEXCEPT
 Returns the number of elements in a sparse set. More...
 
bool empty () const ENTT_NOEXCEPT
 Checks whether a sparse set is empty. More...
 
const entity_type * data () const ENTT_NOEXCEPT
 Direct access to the internal packed array. More...
 
const_iterator_type cbegin () const ENTT_NOEXCEPT
 Returns an iterator to the beginning. More...
 
const_iterator_type begin () const ENTT_NOEXCEPT
 Returns an iterator to the beginning. More...
 
iterator_type begin () ENTT_NOEXCEPT
 Returns an iterator to the beginning. More...
 
const_iterator_type cend () const ENTT_NOEXCEPT
 Returns an iterator to the end. More...
 
const_iterator_type end () const ENTT_NOEXCEPT
 Returns an iterator to the end. More...
 
iterator_type end () ENTT_NOEXCEPT
 Returns an iterator to the end. More...
 
bool has (const entity_type entity) const ENTT_NOEXCEPT
 Checks if a sparse set contains an entity. More...
 
bool fast (const entity_type entity) const ENTT_NOEXCEPT
 Checks if a sparse set contains an entity (unsafe). More...
 
pos_type get (const entity_type entity) const ENTT_NOEXCEPT
 Returns the position of an entity in a sparse set. More...
 
void construct (const entity_type entity)
 Assigns an entity to a sparse set. More...
 
virtual void clone (const entity_type entity, const entity_type source)
 Assigns an entity to a sparse set by cloning another entity. More...
 
virtual void destroy (const entity_type entity)
 Removes an entity from a sparse set. More...
 
void swap (const pos_type lhs, const pos_type rhs) ENTT_NOEXCEPT
 Swaps the position of two entities in the internal packed array. More...
 
void respect (const SparseSet< Entity > &other) ENTT_NOEXCEPT
 Sort entities according to their order in another sparse set. More...
 
virtual void reset ()
 Resets a sparse set.
+ + + + +
+ + + + + + + +
const_iterator_type entt::SparseSet< Entity >::begin () const
+ 		+inline
+
+ +

Returns an iterator to the beginning.

+

The returned iterator points to the first entity of the internal packed array. If the sparse set is empty, the returned iterator will be equal to end().

+
Note
Input iterators stay true to the order imposed by a call to respect.
+
Returns
An iterator to the first entity of the internal packed array.
+ +

Definition at line 233 of file sparse_set.hpp.

+ +
+ + +

◆ begin() [2/2]

@@ -212,27 +265,148 @@ template<typename Entity >
iterator_type entt::SparseSet< Entity >::begin ( ) - const + -inlinenoexcept +inline

Returns an iterator to the beginning.

-

The returned iterator points to the first entity of the internal packed array. If the sparse set is empty, the returned iterator will be equal to end().

+

The returned iterator points to the first entity of the internal packed array. If the sparse set is empty, the returned iterator will be equal to end().

Note
Input iterators stay true to the order imposed by a call to respect.
Returns
An iterator to the first entity of the internal packed array.
-

Definition at line 213 of file sparse_set.hpp.

+

Definition at line 249 of file sparse_set.hpp.

- -

◆ construct()

+ +

◆ cbegin()

+ +
+
+
+template<typename Entity >
+ + + + + +
+ + + + + + + +
const_iterator_type entt::SparseSet< Entity >::cbegin () const
+ 		+inline
+
+ +

Returns an iterator to the beginning.

+

The returned iterator points to the first entity of the internal packed array. If the sparse set is empty, the returned iterator will be equal to end().

+
Note
Input iterators stay true to the order imposed by a call to respect.
+
Returns
An iterator to the first entity of the internal packed array.
+ +

Definition at line 217 of file sparse_set.hpp.

+ +
+
+ +

◆ cend()

+ +
+
+
+template<typename Entity >
+ + + + + +
+ + + + + + + +
const_iterator_type entt::SparseSet< Entity >::cend () const
+ 		+inline
+
+ +

Returns an iterator to the end.

+

The returned iterator points to the element following the last entity in the internal packed array. Attempting to dereference the returned iterator results in undefined behavior.

+
Note
Input iterators stay true to the order imposed by a call to respect.
+
Returns
An iterator to the element following the last entity of the internal packed array.
+ +

Definition at line 266 of file sparse_set.hpp.

+ +
+
+ +

◆ clone()

+ +
+
+
+template<typename Entity >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
virtual void entt::SparseSet< Entity >::clone (const entity_type entity,
const entity_type source 
)
+ 		+inlinevirtual
+
+ +

Assigns an entity to a sparse set by cloning another entity.

+
Warning
Attempting to clone an entity that doesn't belong to the sparse set or 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 doesn't contain the entity to clone or if it already contains the given entity.
+
Parameters
+ + + +
entityA valid entity identifier.
sourceA valid entity identifier from which to clone.
+
+
+ +

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

+ +

Definition at line 394 of file sparse_set.hpp.

+ +
+
+ +

◆ construct()

@@ -245,7 +419,7 @@ template<typename Entity >
void entt::SparseSet< Entity >::construct ( - entity_type  + const entity_type  entity) @@ -267,12 +441,12 @@ template<typename Entity >
-

Definition at line 299 of file sparse_set.hpp.

+

Definition at line 367 of file sparse_set.hpp.

- -

◆ data()

+ +

◆ data()

@@ -291,22 +465,22 @@ template<typename Entity >
-inlinenoexcept +inline

Direct access to the internal packed array.

-

The returned pointer is such that range [data(), data() + size()] is always a valid range, even if the container is empty.

+

The returned pointer is such that range [data(), data() + size()] is always a valid range, even if the container is empty.

Note
There are no guarantees on the order, even though respect has been previously invoked. Internal data structures arrange elements to maximize performance. Accessing them directly gives a performance boost but less guarantees. Use begin and end if you want to iterate the sparse set in the expected order.
Returns
A pointer to the internal packed array.
-

Definition at line 197 of file sparse_set.hpp.

+

Definition at line 201 of file sparse_set.hpp.

- -

◆ destroy()

+ +

◆ destroy()

@@ -319,7 +493,7 @@ template<typename Entity >
virtual void entt::SparseSet< Entity >::destroy ( - entity_type  + const entity_type  entity) @@ -341,14 +515,14 @@ template<typename Entity >
-

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

+

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

-

Definition at line 324 of file sparse_set.hpp.

+

Definition at line 413 of file sparse_set.hpp.

- -

◆ empty()

+ +

◆ empty()

@@ -367,7 +541,7 @@ template<typename Entity >
-inlinenoexcept +inline
@@ -375,12 +549,46 @@ template<typename Entity >

Checks whether a sparse set is empty.

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

Definition at line 178 of file sparse_set.hpp.

+

Definition at line 182 of file sparse_set.hpp.

- -

◆ end()

+ +

◆ end() [1/2]

+ +
+
+
+template<typename Entity >
+ + + + + +
+ + + + + + + +
const_iterator_type entt::SparseSet< Entity >::end () const
+ 		+inline
+
+ +

Returns an iterator to the end.

+

The returned iterator points to the element following the last entity in the internal packed array. Attempting to dereference the returned iterator results in undefined behavior.

+
Note
Input iterators stay true to the order imposed by a call to respect.
+
Returns
An iterator to the element following the last entity of the internal packed array.
+ +

Definition at line 283 of file sparse_set.hpp.

+ +
+
+ +

◆ end() [2/2]

@@ -394,12 +602,12 @@ template<typename Entity >
iterator_type entt::SparseSet< Entity >::end ( ) - const + -inlinenoexcept +inline
@@ -409,12 +617,12 @@ template<typename Entity >
Note
Input iterators stay true to the order imposed by a call to respect.
Returns
An iterator to the element following the last entity of the internal packed array.
-

Definition at line 230 of file sparse_set.hpp.

+

Definition at line 300 of file sparse_set.hpp.

- -

◆ extent()

+ +

◆ extent()

@@ -433,7 +641,7 @@ template<typename Entity >
-inlinenoexcept +inline
@@ -442,12 +650,12 @@ template<typename Entity >

The extent of a sparse set is also the size of the internal sparse array. There is no guarantee that the internal packed array has the same size. Usually the size of the internal sparse array is equal or greater than the one of the internal packed array.

Returns
Extent of the sparse set.
-

Definition at line 156 of file sparse_set.hpp.

+

Definition at line 160 of file sparse_set.hpp.

- -

◆ fast()

+ +

◆ fast()

@@ -460,14 +668,14 @@ template<typename Entity >
bool entt::SparseSet< Entity >::fast ( - entity_type  + const entity_type  entity) const -inlinenoexcept +inline
@@ -485,12 +693,12 @@ template<typename Entity >
Returns
True if the sparse set contains the entity, false otherwise.
-

Definition at line 262 of file sparse_set.hpp.

+

Definition at line 332 of file sparse_set.hpp.

- -

◆ get()

+ +

◆ get()

@@ -503,14 +711,14 @@ template<typename Entity >
pos_type entt::SparseSet< Entity >::get ( - entity_type  + const entity_type  entity) const -inlinenoexcept +inline
@@ -526,12 +734,12 @@ template<typename Entity >
Returns
The position of the entity in the sparse set.
-

Definition at line 281 of file sparse_set.hpp.

+

Definition at line 351 of file sparse_set.hpp.

- -

◆ has()

+ +

◆ has()

@@ -544,14 +752,14 @@ template<typename Entity >
bool entt::SparseSet< Entity >::has ( - entity_type  + const entity_type  entity) const -inlinenoexcept +inline
@@ -565,7 +773,7 @@ template<typename Entity >
Returns
True if the sparse set contains the entity, false otherwise.
-

Definition at line 239 of file sparse_set.hpp.

+

Definition at line 309 of file sparse_set.hpp.

@@ -631,8 +839,8 @@ template<typename Entity > - -

◆ reserve()

+ +

◆ reserve()

@@ -645,7 +853,7 @@ template<typename Entity >
void entt::SparseSet< Entity >::reserve ( - size_type  + const size_type  cap) @@ -666,12 +874,12 @@ template<typename Entity >
-

Definition at line 142 of file sparse_set.hpp.

+

Definition at line 146 of file sparse_set.hpp.

- -

◆ respect()

+ +

◆ respect()

@@ -691,7 +899,7 @@ template<typename Entity >
-inlinenoexcept +inline
@@ -708,12 +916,12 @@ template<typename Entity >
-

Definition at line 380 of file sparse_set.hpp.

+

Definition at line 467 of file sparse_set.hpp.

- -

◆ size()

+ +

◆ size()

@@ -732,7 +940,7 @@ template<typename Entity >
-inlinenoexcept +inline
@@ -741,12 +949,12 @@ template<typename Entity >

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

+

Definition at line 174 of file sparse_set.hpp.

- -

◆ swap()

+ +

◆ swap()

@@ -759,13 +967,13 @@ template<typename Entity >
void entt::SparseSet< Entity >::swap ( - pos_type  + const pos_type  lhs, - pos_type  + const pos_type  rhs  @@ -776,7 +984,7 @@ template<typename Entity >
-inlinenoexcept +inline
@@ -793,7 +1001,7 @@ template<typename Entity >
-

Definition at line 352 of file sparse_set.hpp.

+

Definition at line 439 of file sparse_set.hpp.

diff --git a/classentt_1_1View-members.html b/classentt_1_1View-members.html index eeadfec4d..15e5857f9 100644 --- a/classentt_1_1View-members.html +++ b/classentt_1_1View-members.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -70,21 +70,26 @@ $(function() {

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

- - + + + + + + - + + + - - - - + + + + - - - + +
begin() const noexceptentt::View< Entity, Component >inline
contains(entity_type entity) const noexceptentt::View< Entity, Component >inline
begin() const ENTT_NOEXCEPTentt::View< Entity, Component >inline
begin() ENTT_NOEXCEPTentt::View< Entity, Component >inline
cbegin() const ENTT_NOEXCEPTentt::View< Entity, Component >inline
cend() const ENTT_NOEXCEPTentt::View< Entity, Component >inline
const_iterator_type typedefentt::View< Entity, Component >
contains(const entity_type entity) const ENTT_NOEXCEPTentt::View< Entity, Component >inline
each(Func func) constentt::View< Entity, Component >inline
each(Func func)entt::View< Entity, Component >inline
end() const noexceptentt::View< Entity, Component >inline
empty() const ENTT_NOEXCEPTentt::View< Entity, Component >inline
end() const ENTT_NOEXCEPTentt::View< Entity, Component >inline
end() ENTT_NOEXCEPTentt::View< Entity, Component >inline
entity_type typedefentt::View< Entity, Component >
get(entity_type entity) const noexceptentt::View< Entity, Component >inline
get(entity_type entity) noexceptentt::View< Entity, Component >inline
get(entity_type entity) const noexceptentt::View< Entity, Component >inline
get(entity_type entity) noexceptentt::View< Entity, Component >inline
get(const entity_type entity) const ENTT_NOEXCEPTentt::View< Entity, Component >inline
get(const entity_type entity) ENTT_NOEXCEPTentt::View< Entity, Component >inline
get(const entity_type entity) const ENTT_NOEXCEPTentt::View< Entity, Component >inline
get(const entity_type entity) ENTT_NOEXCEPTentt::View< Entity, Component >inline
iterator_type typedefentt::View< Entity, Component >
Registry< Entity > classentt::View< Entity, Component >friend
reset()entt::View< Entity, Component >inline
size() const noexceptentt::View< Entity, Component >inline
size_type typedefentt::View< Entity, Component >
size() const ENTT_NOEXCEPTentt::View< Entity, Component >inline
size_type typedefentt::View< Entity, Component >
diff --git a/classentt_1_1View.html b/classentt_1_1View.html index e54f47dc8..261910eb5 100644 --- a/classentt_1_1View.html +++ b/classentt_1_1View.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -85,6 +85,10 @@ Public Types using iterator_type = Iterator  Input iterator type.
  + +using const_iterator_type = Iterator + Constant input iterator type.
+  using entity_type = typename view_type::entity_type  Underlying entity identifier.
@@ -96,34 +100,49 @@ using 

Public Member Functions

-size_type size () const noexcept - Estimates the number of entities that have the given components. More...
-  -iterator_type begin () const noexcept - Returns an iterator to the first entity that has the given components. More...
-  -iterator_type end () const noexcept - Returns an iterator that is past the last entity that has the given components. More...
-  -bool contains (entity_type entity) const noexcept - Checks if a view contains an entity. More...
-  -template<typename Comp > -const Comp & get (entity_type entity) const noexcept - Returns the component assigned to the given entity. More...
-  -template<typename Comp > -Comp & get (entity_type entity) noexcept - Returns the component assigned to the given entity. More...
-  -template<typename... Comp> -std::enable_if_t<(sizeof...(Comp) > 1), std::tuple< const Comp &... > > get (entity_type entity) const noexcept - Returns the components assigned to the given entity. More...
-  -template<typename... Comp> -std::enable_if_t<(sizeof...(Comp) > 1), std::tuple< Comp &... > > get (entity_type entity) noexcept - Returns the components assigned to the given entity. More...
-  +size_type size () const ENTT_NOEXCEPT + Estimates the number of entities that have the given components. More...
+  +bool empty () const ENTT_NOEXCEPT + Checks if the view is definitely empty. More...
+  +const_iterator_type cbegin () const ENTT_NOEXCEPT + Returns an iterator to the first entity that has the given components. More...
+  +const_iterator_type begin () const ENTT_NOEXCEPT + Returns an iterator to the first entity that has the given components. More...
+  +iterator_type begin () ENTT_NOEXCEPT + Returns an iterator to the first entity that has the given components. More...
+  +const_iterator_type cend () const ENTT_NOEXCEPT + Returns an iterator that is past the last entity that has the given components. More...
+  +const_iterator_type end () const ENTT_NOEXCEPT + Returns an iterator that is past the last entity that has the given components. More...
+  +iterator_type end () ENTT_NOEXCEPT + Returns an iterator that is past the last entity that has the given components. More...
+  +bool contains (const entity_type entity) const ENTT_NOEXCEPT + Checks if a view contains an entity. More...
+  +template<typename Comp > +const Comp & get (const entity_type entity) const ENTT_NOEXCEPT + Returns the component assigned to the given entity. More...
+  +template<typename Comp > +Comp & get (const entity_type entity) ENTT_NOEXCEPT + Returns the component assigned to the given entity. More...
+  +template<typename... Comp> +std::enable_if_t<(sizeof...(Comp) > 1), std::tuple< const Comp &... > > get (const entity_type entity) const ENTT_NOEXCEPT + Returns the components assigned to the given entity. More...
+  +template<typename... Comp> +std::enable_if_t<(sizeof...(Comp) > 1), std::tuple< Comp &... > > get (const entity_type entity) ENTT_NOEXCEPT + Returns the components assigned to the given entity. More...
+  template<typename Func > void each (Func func) const  Iterates entities and components and applies the given function object to them. More...
@@ -132,9 +151,6 @@ Public Member Functions void each (Func func)  Iterates entities and components and applies the given function object to them. More...
  -void reset () - Resets the view and reinitializes it. More...
-  @@ -149,7 +165,7 @@ class entt::View< Entity, Component >

Multi component view.

Multi component views iterate over those entities that have at least all the given components in their bags. During initialization, a multi component view looks at the number of entities available for each component and picks up a reference to the smallest set of candidate entities in order to get a performance boost when iterate.
- Order of elements during iterations are highly dependent on the order of the underlying data strctures. See SparseSet and its specializations for more details.

+ Order of elements during iterations are highly dependent on the order of the underlying data structures. See SparseSet and its specializations for more details.

Important

Iterators aren't invalidated if:

    @@ -172,10 +188,44 @@ class entt::View< Entity, Component > -

    Definition at line 368 of file view.hpp.

    +

    Definition at line 453 of file view.hpp.

    Member Function Documentation

    - -

    ◆ begin()

    + +

    ◆ begin() [1/2]

    + +
    +
    +
    +template<typename Entity , typename... Component>
    +

Friends

+ + + + +
+ + + + + + + +
const_iterator_type entt::View< Entity, Component >::begin () const
+ 		+inline
+
+ +

Returns an iterator to the first entity that has the given components.

+

The returned iterator points to the first entity that has the given components. If the view is empty, the returned iterator will be equal to end().

+
Note
Input iterators stay true to the order imposed to the underlying data structures.
+
Returns
An iterator to the first entity that has the given components.
+ +

Definition at line 669 of file view.hpp.

+ +
+ + +

◆ begin() [2/2]

@@ -189,27 +239,95 @@ template<typename Entity , typename... Component>
iterator_type entt::View< Entity, Component >::begin ( ) - const + -inlinenoexcept +inline

Returns an iterator to the first entity that has the given components.

-

The returned iterator points to the first entity that has the given components. If the view is empty, the returned iterator will be equal to end().

+

The returned iterator points to the first entity that has the given components. If the view is empty, the returned iterator will be equal to end().

Note
Input iterators stay true to the order imposed to the underlying data structures.
Returns
An iterator to the first entity that has the given components.
-

Definition at line 488 of file view.hpp.

+

Definition at line 687 of file view.hpp.

- -

◆ contains()

+ +

◆ cbegin()

+ +
+
+
+template<typename Entity , typename... Component>
+ + + + + +
+ + + + + + + +
const_iterator_type entt::View< Entity, Component >::cbegin () const
+ 		+inline
+
+ +

Returns an iterator to the first entity that has the given components.

+

The returned iterator points to the first entity that has the given components. If the view is empty, the returned iterator will be equal to end().

+
Note
Input iterators stay true to the order imposed to the underlying data structures.
+
Returns
An iterator to the first entity that has the given components.
+ +

Definition at line 650 of file view.hpp.

+ +
+
+ +

◆ cend()

+ +
+
+
+template<typename Entity , typename... Component>
+ + + + + +
+ + + + + + + +
const_iterator_type entt::View< Entity, Component >::cend () const
+ 		+inline
+
+ +

Returns an iterator that is past the last entity that has the given components.

+

The returned iterator points to the entity following the last entity that has the given components. Attempting to dereference the returned iterator results in undefined behavior.

+
Note
Input iterators stay true to the order imposed to the underlying data structures.
+
Returns
An iterator to the entity following the last entity that has the given components.
+ +

Definition at line 706 of file view.hpp.

+ +
+
+ +

◆ contains()

@@ -222,14 +340,14 @@ template<typename Entity , typename... Component>
bool entt::View< Entity, Component >::contains ( - entity_type  + const entity_type  entity) const -inlinenoexcept +inline
@@ -243,7 +361,7 @@ template<typename Entity , typename... Component>
Returns
True if the view contains the given entity, false otherwise.
-

Definition at line 518 of file view.hpp.

+

Definition at line 754 of file view.hpp.

@@ -278,7 +396,7 @@ template<typename Func >

Iterates entities and components and applies the given function object to them.

The function object is invoked for each entity. It is provided with the entity itself and a set of const references to all the components of the view.
The signature of the function should be equivalent to the following:

-
void(entity_type, const Component &...);
Template Parameters
+
void(const entity_type, const Component &...);
Template Parameters
FuncType of the function object to invoke.
@@ -291,7 +409,7 @@ template<typename Func >
-

Definition at line 640 of file view.hpp.

+

Definition at line 869 of file view.hpp.

@@ -326,7 +444,7 @@ template<typename Func >

Iterates entities and components and applies the given function object to them.

The function object is invoked for each entity. It is provided with the entity itself and a set of references to all the components of the view.
The signature of the function should be equivalent to the following:

-
void(entity_type, Component &...);
Template Parameters
+
void(const entity_type, Component &...);
Template Parameters
FuncType of the function object to invoke.
@@ -339,12 +457,78 @@ template<typename Func >
-

Definition at line 675 of file view.hpp.

+

Definition at line 893 of file view.hpp.

- -

◆ end()

+ +

◆ empty()

+ +
+
+
+template<typename Entity , typename... Component>
+ + + + + +
+ + + + + + + +
bool entt::View< Entity, Component >::empty () const
+ 		+inline
+
+ +

Checks if the view is definitely empty.

+
Returns
True if the view is definitely empty, false otherwise.
+ +

Definition at line 632 of file view.hpp.

+ +
+
+ +

◆ end() [1/2]

+ +
+
+
+template<typename Entity , typename... Component>
+ + + + + +
+ + + + + + + +
const_iterator_type entt::View< Entity, Component >::end () const
+ 		+inline
+
+ +

Returns an iterator that is past the last entity that has the given components.

+

The returned iterator points to the entity following the last entity that has the given components. Attempting to dereference the returned iterator results in undefined behavior.

+
Note
Input iterators stay true to the order imposed to the underlying data structures.
+
Returns
An iterator to the entity following the last entity that has the given components.
+ +

Definition at line 726 of file view.hpp.

+ +
+
+ +

◆ end() [2/2]

@@ -358,12 +542,12 @@ template<typename Entity , typename... Component>
iterator_type entt::View< Entity, Component >::end ( ) - const + -inlinenoexcept +inline
@@ -373,12 +557,12 @@ 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 508 of file view.hpp.

+

Definition at line 745 of file view.hpp.

- -

◆ get() [1/4]

+ +

◆ get() [1/4]

@@ -393,20 +577,20 @@ template<typename Comp >
const Comp& entt::View< Entity, Component >::get ( - entity_type  + const entity_type  entity) const -inlinenoexcept +inline

Returns the component assigned to the given entity.

-

Prefer this function instead of Registry::get during iterations. It has far better performance than its companion function.

+

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

Definition at line 548 of file view.hpp.

+

Definition at line 777 of file view.hpp.

- -

◆ get() [2/4]

+ +

◆ get() [2/4]

@@ -443,20 +627,20 @@ template<typename Comp >
Comp& entt::View< Entity, Component >::get ( - entity_type  + const entity_type  entity) -inlinenoexcept +inline

Returns the component assigned to the given entity.

-

Prefer this function instead of Registry::get during iterations. It has far better performance than its companion function.

+

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

Definition at line 571 of file view.hpp.

+

Definition at line 800 of file view.hpp.

- -

◆ get() [3/4]

+ +

◆ get() [3/4]

@@ -493,20 +677,20 @@ template<typename... Comp>
std::enable_if_t<(sizeof...(Comp) > 1), std::tuple<const Comp &...> > entt::View< Entity, Component >::get ( - entity_type  + const entity_type  entity) const -inlinenoexcept +inline

Returns the components assigned to the given entity.

-

Prefer this function instead of Registry::get during iterations. It has far better performance than its companion function.

+

Prefer this function instead of Registry::get during iterations. It has far better performance than its companion function.

Warning
Attempting to use invalid component types results in a compilation error. Attempting to use an entity that doesn't belong to the view results in undefined behavior.
An assertion will abort the execution at runtime in debug mode if the view doesn't contain the given entity.
Template Parameters
@@ -523,12 +707,12 @@ template<typename... Comp>
Returns
The components assigned to the entity.
-

Definition at line 594 of file view.hpp.

+

Definition at line 823 of file view.hpp.

- -

◆ get() [4/4]

+ +

◆ get() [4/4]

@@ -543,20 +727,20 @@ template<typename... Comp>
std::enable_if_t<(sizeof...(Comp) > 1), std::tuple<Comp &...> > entt::View< Entity, Component >::get ( - entity_type  + const entity_type  entity) -inlinenoexcept +inline

Returns the components assigned to the given entity.

-

Prefer this function instead of Registry::get during iterations. It has far better performance than its companion function.

+

Prefer this function instead of Registry::get during iterations. It has far better performance than its companion function.

Warning
Attempting to use invalid component types results in a compilation error. Attempting to use an entity that doesn't belong to the view results in undefined behavior.
An assertion will abort the execution at runtime in debug mode if the view doesn't contain the given entity.
Template Parameters
@@ -573,45 +757,12 @@ template<typename... Comp>
Returns
The components assigned to the entity.
-

Definition at line 618 of file view.hpp.

+

Definition at line 847 of file view.hpp.

- -

◆ reset()

- -
-
-
-template<typename Entity , typename... Component>
- - - - - -
- - - - - - - -
void entt::View< Entity, Component >::reset ()
- 		-inline
-
- -

Resets the view and reinitializes it.

-

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 691 of file view.hpp.

- -
-
- -

◆ size()

+ +

◆ size()

@@ -630,7 +781,7 @@ template<typename Entity , typename... Component>
-inlinenoexcept +inline
@@ -638,7 +789,7 @@ template<typename Entity , typename... Component>

Estimates the number of entities that have the given components.

Returns
Estimated number of entities that have the given components.
-

Definition at line 470 of file view.hpp.

+

Definition at line 624 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 9ed7f0bfe..ab32df540 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.5.0 +  2.6.0
@@ -70,21 +70,27 @@ $(function() {

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

- - - + + + + + + + - + + + - - + + - - + + - +
begin() const noexceptentt::View< Entity, Component >inline
contains(entity_type entity) const noexceptentt::View< Entity, Component >inline
data() const noexceptentt::View< Entity, Component >inline
begin() const ENTT_NOEXCEPTentt::View< Entity, Component >inline
begin() ENTT_NOEXCEPTentt::View< Entity, Component >inline
cbegin() const ENTT_NOEXCEPTentt::View< Entity, Component >inline
cend() const ENTT_NOEXCEPTentt::View< Entity, Component >inline
const_iterator_type typedefentt::View< Entity, Component >
contains(const entity_type entity) const ENTT_NOEXCEPTentt::View< Entity, Component >inline
data() const ENTT_NOEXCEPTentt::View< Entity, Component >inline
each(Func func) constentt::View< Entity, Component >inline
each(Func func)entt::View< Entity, Component >inline
end() const noexceptentt::View< Entity, Component >inline
empty() const ENTT_NOEXCEPTentt::View< Entity, Component >inline
end() const ENTT_NOEXCEPTentt::View< Entity, Component >inline
end() ENTT_NOEXCEPTentt::View< Entity, Component >inline
entity_type typedefentt::View< Entity, Component >
get(entity_type entity) const noexceptentt::View< Entity, Component >inline
get(entity_type entity) noexceptentt::View< Entity, Component >inline
get(const entity_type entity) const ENTT_NOEXCEPTentt::View< Entity, Component >inline
get(const entity_type entity) ENTT_NOEXCEPTentt::View< Entity, Component >inline
iterator_type typedefentt::View< Entity, Component >
raw() noexceptentt::View< Entity, Component >inline
raw() const noexceptentt::View< Entity, Component >inline
raw() const ENTT_NOEXCEPTentt::View< Entity, Component >inline
raw() ENTT_NOEXCEPTentt::View< Entity, Component >inline
raw_type typedefentt::View< Entity, Component >
Registry< Entity > classentt::View< Entity, Component >friend
size() const noexceptentt::View< Entity, Component >inline
size() const ENTT_NOEXCEPTentt::View< Entity, Component >inline
size_type typedefentt::View< Entity, Component >
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 b9ad45524..ed33888c5 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.5.0 +  2.6.0
@@ -84,6 +84,10 @@ Public Types using iterator_type = typename view_type::iterator_type  Input iterator type.
  + +using const_iterator_type = typename view_type::const_iterator_type + Constant input iterator type.
+  using entity_type = typename pool_type::entity_type  Underlying entity identifier.
@@ -99,33 +103,48 @@ using 

Public Member Functions

-size_type size () const noexcept - Returns the number of entities that have the given component. More...
-  -raw_type * raw () noexcept - Direct access to the list of components. More...
-  -const raw_type * raw () const noexcept - Direct access to the list of components. More...
-  -const entity_type * data () const noexcept - Direct access to the list of entities. More...
-  -iterator_type begin () const noexcept - Returns an iterator to the first entity that has the given component. More...
-  -iterator_type end () const noexcept - Returns an iterator that is past the last entity that has the given component. More...
-  -bool contains (entity_type entity) const noexcept - Checks if a view contains an entity. More...
-  -const Component & get (entity_type entity) const noexcept - Returns the component assigned to the given entity. More...
-  -Component & get (entity_type entity) noexcept - Returns the component assigned to the given entity. More...
-  +size_type size () const ENTT_NOEXCEPT + Returns the number of entities that have the given component. More...
+  +bool empty () const ENTT_NOEXCEPT + Checks whether the view is empty. More...
+  +const raw_type * raw () const ENTT_NOEXCEPT + Direct access to the list of components. More...
+  +raw_type * raw () ENTT_NOEXCEPT + Direct access to the list of components. More...
+  +const entity_type * data () const ENTT_NOEXCEPT + Direct access to the list of entities. More...
+  +const_iterator_type cbegin () const ENTT_NOEXCEPT + Returns an iterator to the first entity that has the given component. More...
+  +const_iterator_type begin () const ENTT_NOEXCEPT + Returns an iterator to the first entity that has the given component. More...
+  +iterator_type begin () ENTT_NOEXCEPT + Returns an iterator to the first entity that has the given component. More...
+  +const_iterator_type cend () const ENTT_NOEXCEPT + Returns an iterator that is past the last entity that has the given component. More...
+  +const_iterator_type end () const ENTT_NOEXCEPT + Returns an iterator that is past the last entity that has the given component. More...
+  +iterator_type end () ENTT_NOEXCEPT + Returns an iterator that is past the last entity that has the given component. More...
+  +bool contains (const entity_type entity) const ENTT_NOEXCEPT + Checks if a view contains an entity. More...
+  +const Component & get (const entity_type entity) const ENTT_NOEXCEPT + Returns the component assigned to the given entity. More...
+  +Component & get (const entity_type entity) ENTT_NOEXCEPT + Returns the component assigned to the given entity. More...
+  template<typename Func > void each (Func func) const  Iterates entities and components and applies the given function object to them. More...
@@ -171,10 +190,44 @@ class entt::View< Entity, Component > -

Definition at line 756 of file view.hpp.

+

Definition at line 942 of file view.hpp.

Member Function Documentation

- -

◆ begin()

+ +

◆ begin() [1/2]

+ +
+
+
+template<typename Entity , typename Component >
+ + + + + +
+ + + + + + + +
const_iterator_type entt::View< Entity, Component >::begin () const
+ 		+inline
+
+ +

Returns an iterator to the first entity that has the given component.

+

The returned iterator points to the first entity that has the given component. If the view is empty, the returned iterator will be equal to end().

+
Note
Input iterators stay true to the order imposed to the underlying data structures.
+
Returns
An iterator to the first entity that has the given component.
+ +

Definition at line 1061 of file view.hpp.

+ +
+
+ +

◆ begin() [2/2]

@@ -188,27 +241,95 @@ template<typename Entity , typename Component >
iterator_type entt::View< Entity, Component >::begin ( ) - const + -inlinenoexcept +inline

Returns an iterator to the first entity that has the given component.

-

The returned iterator points to the first entity that has the given component. If the view is empty, the returned iterator will be equal to end().

+

The returned iterator points to the first entity that has the given component. If the view is empty, the returned iterator will be equal to end().

Note
Input iterators stay true to the order imposed to the underlying data structures.
Returns
An iterator to the first entity that has the given component.
-

Definition at line 847 of file view.hpp.

+

Definition at line 1079 of file view.hpp.

- -

◆ contains()

+ +

◆ cbegin()

+ +
+
+
+template<typename Entity , typename Component >
+ + + + + +
+ + + + + + + +
const_iterator_type entt::View< Entity, Component >::cbegin () const
+ 		+inline
+
+ +

Returns an iterator to the first entity that has the given component.

+

The returned iterator points to the first entity that has the given component. If the view is empty, the returned iterator will be equal to end().

+
Note
Input iterators stay true to the order imposed to the underlying data structures.
+
Returns
An iterator to the first entity that has the given component.
+ +

Definition at line 1043 of file view.hpp.

+ +
+
+ +

◆ cend()

+ +
+
+
+template<typename Entity , typename Component >
+ + + + + +
+ + + + + + + +
const_iterator_type entt::View< Entity, Component >::cend () const
+ 		+inline
+
+ +

Returns an iterator that is past the last entity that has the given component.

+

The returned iterator points to the entity following the last entity that has the given component. Attempting to dereference the returned iterator results in undefined behavior.

+
Note
Input iterators stay true to the order imposed to the underlying data structures.
+
Returns
An iterator to the entity following the last entity that has the given component.
+ +

Definition at line 1098 of file view.hpp.

+ +
+
+ +

◆ contains()

@@ -221,14 +342,14 @@ template<typename Entity , typename Component >
bool entt::View< Entity, Component >::contains ( - entity_type  + const entity_type  entity) const -inlinenoexcept +inline
@@ -242,12 +363,12 @@ template<typename Entity , typename Component >
Returns
True if the view contains the given entity, false otherwise.
-

Definition at line 875 of file view.hpp.

+

Definition at line 1145 of file view.hpp.

- -

◆ data()

+ +

◆ data()

@@ -266,17 +387,17 @@ template<typename Entity , typename Component >
-inlinenoexcept +inline

Direct access to the list of entities.

-

The returned pointer is such that range [data(), data() + size()] is always a valid range, even if the container is empty.

+

The returned pointer is such that range [data(), data() + size()] is always a valid range, even if the container is empty.

Note
There are no guarantees on the order of the entities. Use begin and end if you want to iterate the view in the expected order.
Returns
A pointer to the array of entities.
-

Definition at line 829 of file view.hpp.

+

Definition at line 1025 of file view.hpp.

@@ -311,7 +432,7 @@ template<typename Func >

Iterates entities and components and applies the given function object to them.

The function object is invoked for each entity. It is provided with the entity itself and a const reference to the component of the view.
The signature of the function should be equivalent to the following:

-
void(entity_type, const Component &);
Template Parameters
+
void(const entity_type, const Component &);
Template Parameters
FuncType of the function object to invoke.
@@ -324,7 +445,7 @@ template<typename Func >
-

Definition at line 934 of file view.hpp.

+

Definition at line 1204 of file view.hpp.

@@ -359,7 +480,7 @@ template<typename Func >

Iterates entities and components and applies the given function object to them.

The function object is invoked for each entity. It is provided with the entity itself and a reference to the component of the view.
The signature of the function should be equivalent to the following:

-
void(entity_type, Component &);
Template Parameters
+
void(const entity_type, Component &);
Template Parameters
FuncType of the function object to invoke.
@@ -372,12 +493,78 @@ template<typename Func >
-

Definition at line 958 of file view.hpp.

+

Definition at line 1226 of file view.hpp.

- -

◆ end()

+ +

◆ empty()

+ +
+
+
+template<typename Entity , typename Component >
+ + + + + +
+ + + + + + + +
bool entt::View< Entity, Component >::empty () const
+ 		+inline
+
+ +

Checks whether the view is empty.

+
Returns
True if the view is empty, false otherwise.
+ +

Definition at line 977 of file view.hpp.

+ +
+
+ +

◆ end() [1/2]

+ +
+
+
+template<typename Entity , typename Component >
+ + + + + +
+ + + + + + + +
const_iterator_type entt::View< Entity, Component >::end () const
+ 		+inline
+
+ +

Returns an iterator that is past the last entity that has the given component.

+

The returned iterator points to the entity following the last entity that has the given component. Attempting to dereference the returned iterator results in undefined behavior.

+
Note
Input iterators stay true to the order imposed to the underlying data structures.
+
Returns
An iterator to the entity following the last entity that has the given component.
+ +

Definition at line 1117 of file view.hpp.

+ +
+
+ +

◆ end() [2/2]

@@ -391,12 +578,12 @@ template<typename Entity , typename Component >
iterator_type entt::View< Entity, Component >::end ( ) - const + -inlinenoexcept +inline
@@ -406,12 +593,12 @@ 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 866 of file view.hpp.

+

Definition at line 1136 of file view.hpp.

- -

◆ get() [1/2]

+ +

◆ get() [1/2]

@@ -424,20 +611,20 @@ template<typename Entity , typename Component >
const Component& entt::View< Entity, Component >::get ( - entity_type  + const entity_type  entity) const -inlinenoexcept +inline

Returns the component assigned to the given entity.

-

Prefer this function instead of Registry::get during iterations. It has far better performance than its companion function.

+

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

Definition at line 894 of file view.hpp.

+

Definition at line 1164 of file view.hpp.

- -

◆ get() [2/2]

+ +

◆ get() [2/2]

@@ -466,20 +653,20 @@ template<typename Entity , typename Component >
Component& entt::View< Entity, Component >::get ( - entity_type  + const entity_type  entity) -inlinenoexcept +inline

Returns the component assigned to the given entity.

-

Prefer this function instead of Registry::get during iterations. It has far better performance than its companion function.

+

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

Definition at line 914 of file view.hpp.

+

Definition at line 1184 of file view.hpp.

- -

◆ raw() [1/2]

- -
-
-
-template<typename Entity , typename Component >
- - - - - -
- - - - - - - -
raw_type* entt::View< Entity, Component >::raw ()
- 		-inlinenoexcept
-
- -

Direct access to the list of components.

-

The returned pointer is such that range [raw(), raw() + size()] is always a valid range, even if the container is empty.

-
Note
There are no guarantees on the order of the components. Use begin and end if you want to iterate the view in the expected order.
-
Returns
A pointer to the array of components.
- -

Definition at line 797 of file view.hpp.

- -
-
- -

◆ raw() [2/2]

+ +

◆ raw() [1/2]

@@ -548,22 +701,56 @@ template<typename Entity , typename Component >
-inlinenoexcept +inline

Direct access to the list of components.

-

The returned pointer is such that range [raw(), raw() + size()] is always a valid range, even if the container is empty.

+

The returned pointer is such that range [raw(), raw() + size()] is always a valid range, even if the container is empty.

Note
There are no guarantees on the order of the components. Use begin and end if you want to iterate the view in the expected order.
Returns
A pointer to the array of components.
-

Definition at line 813 of file view.hpp.

+

Definition at line 993 of file view.hpp.

- -

◆ size()

+ +

◆ raw() [2/2]

+ +
+
+
+template<typename Entity , typename Component >
+ + + + + +
+ + + + + + + +
raw_type* entt::View< Entity, Component >::raw ()
+ 		+inline
+
+ +

Direct access to the list of components.

+

The returned pointer is such that range [raw(), raw() + size()] is always a valid range, even if the container is empty.

+
Note
There are no guarantees on the order of the components. Use begin and end if you want to iterate the view in the expected order.
+
Returns
A pointer to the array of components.
+ +

Definition at line 1009 of file view.hpp.

+ +
+
+ +

◆ size()

@@ -582,7 +769,7 @@ template<typename Entity , typename Component >
-inlinenoexcept +inline
@@ -590,7 +777,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 781 of file view.hpp.

+

Definition at line 969 of file view.hpp.

diff --git a/classes.html b/classes.html index fcecd5a23..f1ddf5d1b 100644 --- a/classes.html +++ b/classes.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -63,36 +63,38 @@ $(function() {
Class Index
-
a | b | c | d | e | f | h | p | r | s | v
+
a | b | c | d | e | f | h | i | p | r | s | t | v
- - + + + - - + - - + - - - - - + + + + + + + +
  a  
-
  d  
-
  f  
-		Registry (entt)   Snapshot (entt)   
ResourceCache (entt)   SnapshotLoader (entt)   
Actor (entt)   Delegate (entt)   Family (entt)   ResourceHandle (entt)   SparseSet (entt)   
Dispatcher (entt)   
  i  
+		Registry (entt)   SparseSet (entt)   
  e  
+		ResourceCache (entt)   SparseSet< Entity > (entt)   
Actor (entt)   InsertionSort (entt)   ResourceHandle (entt)   SparseSet< Entity, Type > (entt)   
  b  
-		Delegate< Ret(Args...)> (entt)   
  h  
-		ResourceLoader (entt)   SparseSet< Entity > (entt)   
Dispatcher (entt)   
  s  
-		SparseSet< Entity, Type > (entt)   
Bus (entt)   
  e  
-		HashedString (entt)   
  v  
+		Emitter (entt)   
  p  
+		ResourceLoader (entt)   StdSort (entt)   
entt_traits (entt)   
  s  
+
  t  
Bus< Sig, Event > (entt)   
  p  
-		Scheduler (entt)   
Bus< Sig, Event, Other... > (entt)   Emitter (entt)   ServiceLocator (entt)   View (entt)   
break_t (entt)   entt_traits< std::uint16_t > (entt)   persistent_t (entt)   
  c  
-		entt_traits (entt)   PersistentView (entt)   SigH (entt)   View< Entity, Component > (entt)   
entt_traits< std::uint16_t > (entt)   Process (entt)   SigH< Ret(Args...), Collector > (entt)   
Emitter::Connection (entt)   entt_traits< std::uint32_t > (entt)   ProcessAdaptor (entt)   Signal (entt)   
ContinuousLoader (entt)   entt_traits< std::uint64_t > (entt)   
  r  
-		Signal< void(Args...)> (entt)   
RawView (entt)   
entt_traits< std::uint32_t > (entt)   PersistentView (entt)   Scheduler (entt)   tag_t (entt)   
entt_traits< std::uint64_t > (entt)   Process (entt)   ServiceLocator (entt)   
  v  
+
Emitter::Connection (entt)   
  f  
+		ProcessAdaptor (entt)   SigH (entt)   
ContinuousLoader (entt)   Prototype (entt)   SigH< Ret(Args...), Collector > (entt)   View (entt)   
  d  
+		Family (entt)   
  r  
+		Sink (entt)   View< Entity, Component > (entt)   
  h  
+		Sink< Ret(Args...)> (entt)   
Delegate (entt)   raw_t (entt)   Snapshot (entt)   
Delegate< Ret(Args...)> (entt)   HashedString (entt)   RawView (entt)   SnapshotLoader (entt)   
-
a | b | c | d | e | f | h | p | r | s | v
+
a | b | c | d | e | f | h | i | p | r | s | t | v
diff --git a/config_8h_source.html b/config_8h_source.html new file mode 100644 index 000000000..2065c264a --- /dev/null +++ b/config_8h_source.html @@ -0,0 +1,78 @@ + + + + + + + +entt: src/entt/config/config.h Source File + + + + + + + + + +
+
+ + + + + + +
+
entt +  2.6.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
config.h
+
+
+
1 #ifndef ENTT_CONFIG_CONFIG_H
2 #define ENTT_CONFIG_CONFIG_H
3 
4 
5 #ifndef ENTT_NOEXCEPT
6 #define ENTT_NOEXCEPT noexcept
7 #endif
8 
9 
10 #endif // ENTT_CONFIG_CONFIG_H
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/delegate_8hpp_source.html b/delegate_8hpp_source.html index aafccf315..352dd2248 100644 --- a/delegate_8hpp_source.html +++ b/delegate_8hpp_source.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -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  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:10
-
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:102
+
1 #ifndef ENTT_SIGNAL_DELEGATE_HPP
2 #define ENTT_SIGNAL_DELEGATE_HPP
3 
4 
5 #include <utility>
6 #include "../config/config.h"
7 
8 
9 namespace entt {
10 
11 
18 template<typename>
19 class Delegate;
20 
21 
35 template<typename Ret, typename... Args>
36 class Delegate<Ret(Args...)> final {
37  using proto_type = Ret(*)(void *, Args...);
38  using stub_type = std::pair<void *, proto_type>;
39 
40  static Ret fallback(void *, Args...) ENTT_NOEXCEPT { return {}; }
41 
42  template<Ret(*Function)(Args...)>
43  static Ret proto(void *, Args... args) {
44  return (Function)(args...);
45  }
46 
47  template<typename Class, Ret(Class:: *Member)(Args...)>
48  static Ret proto(void *instance, Args... args) {
49  return (static_cast<Class *>(instance)->*Member)(args...);
50  }
51 
52 public:
54  Delegate() ENTT_NOEXCEPT
55  : stub{std::make_pair(nullptr, &fallback)}
56  {}
57 
62  template<Ret(*Function)(Args...)>
63  void connect() ENTT_NOEXCEPT {
64  stub = std::make_pair(nullptr, &proto<Function>);
65  }
66 
78  template<typename Class, Ret(Class:: *Member)(Args...)>
79  void connect(Class *instance) ENTT_NOEXCEPT {
80  stub = std::make_pair(instance, &proto<Class, Member>);
81  }
82 
88  void reset() ENTT_NOEXCEPT {
89  stub = std::make_pair(nullptr, &fallback);
90  }
91 
97  Ret operator()(Args... args) {
98  return stub.second(stub.first, args...);
99  }
100 
109  bool operator==(const Delegate<Ret(Args...)> &other) const ENTT_NOEXCEPT {
110  return stub.first == other.stub.first && stub.second == other.stub.second;
111  }
112 
113 private:
114  stub_type stub;
115 };
116 
117 
129 template<typename Ret, typename... Args>
130 bool operator!=(const Delegate<Ret(Args...)> &lhs, const Delegate<Ret(Args...)> &rhs) ENTT_NOEXCEPT {
131  return !(lhs == rhs);
132 }
133 
134 
135 }
136 
137 
138 #endif // ENTT_SIGNAL_DELEGATE_HPP
entt::operator!=
constexpr bool operator!=(const HashedString &lhs, const HashedString &rhs) ENTT_NOEXCEPT
Compares two hashed strings.
Definition: hashed_string.hpp:103
+
entt::Delegate< Ret(Args...)>::connect
void connect() ENTT_NOEXCEPT
Binds a free function to a delegate.
Definition: delegate.hpp:63
+
entt
EnTT default namespace.
Definition: algorithm.hpp:10
+
entt::Delegate
Basic delegate implementation.
Definition: delegate.hpp:19
+
entt::Delegate< Ret(Args...)>::Delegate
Delegate() ENTT_NOEXCEPT
Default constructor.
Definition: delegate.hpp:54
+
entt::Delegate< Ret(Args...)>::operator==
bool operator==(const Delegate< Ret(Args...)> &other) const ENTT_NOEXCEPT
Checks if the contents of the two delegates are different.
Definition: delegate.hpp:109
+
entt::Delegate< Ret(Args...)>::operator()
Ret operator()(Args... args)
Triggers a delegate.
Definition: delegate.hpp:97
+
entt::Delegate< Ret(Args...)>::reset
void reset() ENTT_NOEXCEPT
Resets a delegate.
Definition: delegate.hpp:88
+
entt::Delegate< Ret(Args...)>::connect
void connect(Class *instance) ENTT_NOEXCEPT
Connects a member function for a given instance to a delegate.
Definition: delegate.hpp:79
diff --git a/dir_66e9674e8206a335795995fa32a03c91.html b/dir_66e9674e8206a335795995fa32a03c91.html index 3878dd91f..5fdfb7f30 100644 --- a/dir_66e9674e8206a335795995fa32a03c91.html +++ b/dir_66e9674e8206a335795995fa32a03c91.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
diff --git a/dir_68267d1309a1af8e8297ef4c3efbcdba.html b/dir_68267d1309a1af8e8297ef4c3efbcdba.html index 3366cd7c4..35f1c31f2 100644 --- a/dir_68267d1309a1af8e8297ef4c3efbcdba.html +++ b/dir_68267d1309a1af8e8297ef4c3efbcdba.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
diff --git a/dir_721f6154dba3c88bcdead5f446bce319.html b/dir_721f6154dba3c88bcdead5f446bce319.html index 258dee0de..db0c5b55c 100644 --- a/dir_721f6154dba3c88bcdead5f446bce319.html +++ b/dir_721f6154dba3c88bcdead5f446bce319.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
diff --git a/dir_7929ab29d3f740cf727ccbd263321562.html b/dir_7929ab29d3f740cf727ccbd263321562.html new file mode 100644 index 000000000..c3ca98cc7 --- /dev/null +++ b/dir_7929ab29d3f740cf727ccbd263321562.html @@ -0,0 +1,78 @@ + + + + + + + +entt: src/entt/config Directory Reference + + + + + + + + + +
+
+ + + + + + +
+
entt +  2.6.0 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
config Directory Reference
+
+
+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/dir_85dbee8884f1b3a817fa7eff8dff73ec.html b/dir_85dbee8884f1b3a817fa7eff8dff73ec.html index 694f04dda..b7c82ac64 100644 --- a/dir_85dbee8884f1b3a817fa7eff8dff73ec.html +++ b/dir_85dbee8884f1b3a817fa7eff8dff73ec.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
diff --git a/dir_a53318306f6ac0f7fe657839abd543ab.html b/dir_a53318306f6ac0f7fe657839abd543ab.html index afd643159..43543487d 100644 --- a/dir_a53318306f6ac0f7fe657839abd543ab.html +++ b/dir_a53318306f6ac0f7fe657839abd543ab.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
diff --git a/dir_b64489a1e8130d5ebf6d86d282f500f0.html b/dir_b64489a1e8130d5ebf6d86d282f500f0.html index 9123df3ee..7804d6283 100644 --- a/dir_b64489a1e8130d5ebf6d86d282f500f0.html +++ b/dir_b64489a1e8130d5ebf6d86d282f500f0.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
diff --git a/dir_de8f4e6ba3f54a2a21309f742e93a373.html b/dir_de8f4e6ba3f54a2a21309f742e93a373.html index 98a8fe27f..971a99a58 100644 --- a/dir_de8f4e6ba3f54a2a21309f742e93a373.html +++ b/dir_de8f4e6ba3f54a2a21309f742e93a373.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
diff --git a/dir_e3a7bb56c55e5c2286e2fe96e197d4f5.html b/dir_e3a7bb56c55e5c2286e2fe96e197d4f5.html index 97d5295eb..ba4137225 100644 --- a/dir_e3a7bb56c55e5c2286e2fe96e197d4f5.html +++ b/dir_e3a7bb56c55e5c2286e2fe96e197d4f5.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
diff --git a/dispatcher_8hpp_source.html b/dispatcher_8hpp_source.html index 670c52139..ab53c79dd 100644 --- a/dispatcher_8hpp_source.html +++ b/dispatcher_8hpp_source.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -67,15 +67,16 @@ $(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) override {
44  for(const 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  const 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 
139  template<typename Event, typename Class, void(Class::*Member)(const Event &) = &Class::receive>
140  void disconnect(instance_type<Class, Event> instance) noexcept {
141  wrapper<Event>().template disconnect<Class, Member>(std::move(instance));
142  }
143 
154  template<typename Event, typename... Args>
155  void trigger(Args &&... args) {
156  wrapper<Event>().trigger(std::forward<Args>(args)...);
157  }
158 
169  template<typename Event, typename... Args>
170  void enqueue(Args &&... args) {
171  wrapper<Event>().enqueue(buffer(mode), std::forward<Args>(args)...);
172  }
173 
181  void update() {
182  const auto buf = buffer(mode);
183  mode = !mode;
184 
185  for(auto pos = wrappers.size(); pos; --pos) {
186  auto &wrapper = wrappers[pos-1];
187 
188  if(wrapper) {
189  wrapper->publish(buf);
190  }
191  }
192  }
193 
194 private:
195  std::vector<std::unique_ptr<BaseSignalWrapper>> wrappers;
196  bool mode;
197 };
198 
199 
207 using ManagedDispatcher = Dispatcher<Signal>;
208 
209 
219 using UnmanagedDispatcher = Dispatcher<SigH>;
220 
221 
222 }
223 
224 
225 #endif // ENTT_SIGNAL_DISPATCHER_HPP
entt::Dispatcher::Dispatcher
Dispatcher() noexcept
Default constructor.
Definition: dispatcher.hpp:97
-
entt
EnTT default namespace.
Definition: family.hpp:10
-
entt::Dispatcher::update
void update()
Delivers all the pending events.
Definition: dispatcher.hpp:181
-
entt::Dispatcher::trigger
void trigger(Args &&... args)
Triggers an immediate event of the given type.
Definition: dispatcher.hpp:155
-
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:170
-
entt::Dispatcher
Basic dispatcher implementation.
Definition: dispatcher.hpp:30
-
entt::Family
Dynamic identifier generator.
Definition: family.hpp:21
-
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:140
+
1 #ifndef ENTT_SIGNAL_DISPATCHER_HPP
2 #define ENTT_SIGNAL_DISPATCHER_HPP
3 
4 
5 #include <vector>
6 #include <memory>
7 #include <utility>
8 #include <cstdint>
9 #include <algorithm>
10 #include <type_traits>
11 #include "../config/config.h"
12 #include "../core/family.hpp"
13 #include "sigh.hpp"
14 
15 
16 namespace entt {
17 
18 
35 class Dispatcher final {
36  using event_family = Family<struct InternalDispatcherEventFamily>;
37 
38  template<typename Class, typename Event>
39  using instance_type = typename SigH<void(const Event &)>::template instance_type<Class>;
40 
41  struct BaseSignalWrapper {
42  virtual ~BaseSignalWrapper() = default;
43  virtual void publish() = 0;
44  };
45 
46  template<typename Event>
47  struct SignalWrapper final: BaseSignalWrapper {
48  using sink_type = typename SigH<void(const Event &)>::sink_type;
49 
50  void publish() override {
51  const auto &curr = current++;
52  current %= std::extent<decltype(events)>::value;
53  std::for_each(events[curr].cbegin(), events[curr].cend(), [this](const auto &event) { signal.publish(event); });
54  events[curr].clear();
55  }
56 
57  inline sink_type sink() ENTT_NOEXCEPT {
58  return signal.sink();
59  }
60 
61  template<typename... Args>
62  inline void trigger(Args &&... args) {
63  signal.publish({ std::forward<Args>(args)... });
64  }
65 
66  template<typename... Args>
67  inline void enqueue(Args &&... args) {
68  events[current].push_back({ std::forward<Args>(args)... });
69  }
70 
71  private:
72  SigH<void(const Event &)> signal{};
73  std::vector<Event> events[2];
74  int current{};
75  };
76 
77  template<typename Event>
78  SignalWrapper<Event> & wrapper() {
79  const auto type = event_family::type<Event>();
80 
81  if(!(type < wrappers.size())) {
82  wrappers.resize(type + 1);
83  }
84 
85  if(!wrappers[type]) {
86  wrappers[type] = std::make_unique<SignalWrapper<Event>>();
87  }
88 
89  return static_cast<SignalWrapper<Event> &>(*wrappers[type]);
90  }
91 
92 public:
94  template<typename Event>
95  using sink_type = typename SignalWrapper<Event>::sink_type;
96 
114  template<typename Event>
115  inline sink_type<Event> sink() ENTT_NOEXCEPT {
116  return wrapper<Event>().sink();
117  }
118 
129  template<typename Event, typename... Args>
130  inline void trigger(Args &&... args) {
131  wrapper<Event>().trigger(std::forward<Args>(args)...);
132  }
133 
144  template<typename Event, typename... Args>
145  inline void enqueue(Args &&... args) {
146  wrapper<Event>().enqueue(std::forward<Args>(args)...);
147  }
148 
158  template<typename Event>
159  inline void update() {
160  wrapper<Event>().publish();
161  }
162 
170  inline void update() {
171  for(auto pos = wrappers.size(); pos; --pos) {
172  auto &wrapper = wrappers[pos-1];
173 
174  if(wrapper) {
175  wrapper->publish();
176  }
177  }
178  }
179 
180 private:
181  std::vector<std::unique_ptr<BaseSignalWrapper>> wrappers;
182 };
183 
184 
185 }
186 
187 
188 #endif // ENTT_SIGNAL_DISPATCHER_HPP
entt::Dispatcher::sink_type
typename SignalWrapper< Event >::sink_type sink_type
Type of sink for the given event.
Definition: dispatcher.hpp:95
+
entt::Dispatcher::sink
sink_type< Event > sink() ENTT_NOEXCEPT
Returns a sink object for the given event.
Definition: dispatcher.hpp:115
+
entt
EnTT default namespace.
Definition: algorithm.hpp:10
+
entt::Dispatcher::enqueue
void enqueue(Args &&... args)
Enqueues an event of the given type.
Definition: dispatcher.hpp:145
+
entt::Dispatcher::trigger
void trigger(Args &&... args)
Triggers an immediate event of the given type.
Definition: dispatcher.hpp:130
+
entt::Dispatcher
Basic dispatcher implementation.
Definition: dispatcher.hpp:35
+
entt::Dispatcher::update
void update()
Delivers all the pending events of the given type.
Definition: dispatcher.hpp:159
+
entt::Dispatcher::update
void update()
Delivers all the pending events.
Definition: dispatcher.hpp:170
+
entt::SigH
Unmanaged signal handler declaration.
Definition: sigh.hpp:112
+
entt::Family
Dynamic identifier generator.
Definition: family.hpp:22
diff --git a/emitter_8hpp_source.html b/emitter_8hpp_source.html index 3a80add66..2023bf3f7 100644 --- a/emitter_8hpp_source.html +++ b/emitter_8hpp_source.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -67,21 +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  const 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  const 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
+
1 #ifndef ENTT_SIGNAL_EMITTER_HPP
2 #define ENTT_SIGNAL_EMITTER_HPP
3 
4 
5 #include <type_traits>
6 #include <functional>
7 #include <algorithm>
8 #include <utility>
9 #include <cstdint>
10 #include <memory>
11 #include <vector>
12 #include <list>
13 #include "../config/config.h"
14 
15 
16 namespace entt {
17 
18 
40 template<typename Derived>
41 class Emitter {
42  struct BaseHandler {
43  virtual ~BaseHandler() = default;
44  virtual bool empty() const ENTT_NOEXCEPT = 0;
45  virtual void clear() ENTT_NOEXCEPT = 0;
46  };
47 
48  template<typename Event>
49  struct Handler final: BaseHandler {
50  using listener_type = std::function<void(const Event &, Derived &)>;
51  using element_type = std::pair<bool, listener_type>;
52  using container_type = std::list<element_type>;
53  using connection_type = typename container_type::iterator;
54 
55  bool empty() const ENTT_NOEXCEPT override {
56  auto pred = [](auto &&element) { return element.first; };
57 
58  return std::all_of(onceL.cbegin(), onceL.cend(), pred) &&
59  std::all_of(onL.cbegin(), onL.cend(), pred);
60  }
61 
62  void clear() ENTT_NOEXCEPT override {
63  if(publishing) {
64  auto func = [](auto &&element) { element.first = true; };
65  std::for_each(onceL.begin(), onceL.end(), func);
66  std::for_each(onL.begin(), onL.end(), func);
67  } else {
68  onceL.clear();
69  onL.clear();
70  }
71  }
72 
73  inline connection_type once(listener_type listener) {
74  return onceL.emplace(onceL.cend(), false, std::move(listener));
75  }
76 
77  inline connection_type on(listener_type listener) {
78  return onL.emplace(onL.cend(), false, std::move(listener));
79  }
80 
81  void erase(connection_type conn) ENTT_NOEXCEPT {
82  conn->first = true;
83 
84  if(!publishing) {
85  auto pred = [](auto &&element) { return element.first; };
86  onceL.remove_if(pred);
87  onL.remove_if(pred);
88  }
89  }
90 
91  void publish(const Event &event, Derived &ref) {
92  container_type currentL;
93  onceL.swap(currentL);
94 
95  auto func = [&event, &ref](auto &&element) {
96  return element.first ? void() : element.second(event, ref);
97  };
98 
99  publishing = true;
100 
101  std::for_each(onL.rbegin(), onL.rend(), func);
102  std::for_each(currentL.rbegin(), currentL.rend(), func);
103 
104  publishing = false;
105 
106  onL.remove_if([](auto &&element) { return element.first; });
107  }
108 
109  private:
110  bool publishing{false};
111  container_type onceL{};
112  container_type onL{};
113  };
114 
115  static std::size_t next() ENTT_NOEXCEPT {
116  static std::size_t counter = 0;
117  return counter++;
118  }
119 
120  template<typename>
121  static std::size_t type() ENTT_NOEXCEPT {
122  static std::size_t value = next();
123  return value;
124  }
125 
126  template<typename Event>
127  Handler<Event> & handler() ENTT_NOEXCEPT {
128  const std::size_t family = type<Event>();
129 
130  if(!(family < handlers.size())) {
131  handlers.resize(family+1);
132  }
133 
134  if(!handlers[family]) {
135  handlers[family] = std::make_unique<Handler<Event>>();
136  }
137 
138  return static_cast<Handler<Event> &>(*handlers[family]);
139  }
140 
141 public:
143  template<typename Event>
144  using Listener = typename Handler<Event>::listener_type;
145 
155  template<typename Event>
156  struct Connection final: private Handler<Event>::connection_type {
158  friend class Emitter;
159 
161  Connection() ENTT_NOEXCEPT = default;
162 
167  Connection(typename Handler<Event>::connection_type conn)
168  : Handler<Event>::connection_type{std::move(conn)}
169  {}
170 
172  Connection(const Connection &) = default;
174  Connection(Connection &&) = default;
175 
180  Connection & operator=(const Connection &) = default;
181 
186  Connection & operator=(Connection &&) = default;
187  };
188 
190  Emitter() ENTT_NOEXCEPT = default;
191 
193  virtual ~Emitter() ENTT_NOEXCEPT {
194  static_assert(std::is_base_of<Emitter<Derived>, Derived>::value, "!");
195  }
196 
198  Emitter(const Emitter &) = delete;
200  Emitter(Emitter &&) = default;
201 
203  Emitter & operator=(const Emitter &) = delete;
205  Emitter & operator=(Emitter &&) = default;
206 
218  template<typename Event, typename... Args>
219  void publish(Args &&... args) {
220  handler<Event>().publish({ std::forward<Args>(args)... }, *static_cast<Derived *>(this));
221  }
222 
243  template<typename Event>
244  Connection<Event> on(Listener<Event> listener) {
245  return handler<Event>().on(std::move(listener));
246  }
247 
268  template<typename Event>
269  Connection<Event> once(Listener<Event> listener) {
270  return handler<Event>().once(std::move(listener));
271  }
272 
282  template<typename Event>
283  void erase(Connection<Event> conn) ENTT_NOEXCEPT {
284  handler<Event>().erase(std::move(conn));
285  }
286 
295  template<typename Event>
296  void clear() ENTT_NOEXCEPT {
297  handler<Event>().clear();
298  }
299 
306  void clear() ENTT_NOEXCEPT {
307  std::for_each(handlers.begin(), handlers.end(),
308  [](auto &&handler) { if(handler) { handler->clear(); } });
309  }
310 
316  template<typename Event>
317  bool empty() const ENTT_NOEXCEPT {
318  const std::size_t family = type<Event>();
319 
320  return (!(family < handlers.size()) ||
321  !handlers[family] ||
322  static_cast<Handler<Event> &>(*handlers[family]).empty());
323  }
324 
329  bool empty() const ENTT_NOEXCEPT {
330  return std::all_of(handlers.cbegin(), handlers.cend(),
331  [](auto &&handler) { return !handler || handler->empty(); });
332  }
333 
334 private:
335  std::vector<std::unique_ptr<BaseHandler>> handlers{};
336 };
337 
338 
339 }
340 
341 
342 #endif // ENTT_SIGNAL_EMITTER_HPP
entt::Emitter::empty
bool empty() const ENTT_NOEXCEPT
Checks if there are listeners registered for the specific event.
Definition: emitter.hpp:317
+
entt::Emitter::empty
bool empty() const ENTT_NOEXCEPT
Checks if there are listeners registered with the event emitter.
Definition: emitter.hpp:329
+
entt::Emitter::on
Connection< Event > on(Listener< Event > listener)
Registers a long-lived listener with the event emitter.
Definition: emitter.hpp:244
entt::Emitter::operator=
Emitter & operator=(const Emitter &)=delete
Copying an emitter isn&#39;t allowed.
-
entt
EnTT default namespace.
Definition: family.hpp:10
-
entt::Emitter::Connection
Generic connection type for events.
Definition: emitter.hpp:155
-
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: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:192
+
entt
EnTT default namespace.
Definition: algorithm.hpp:10
+
entt::Emitter::Connection
Generic connection type for events.
Definition: emitter.hpp:156
+
entt::Emitter::publish
void publish(Args &&... args)
Emits the given event.
Definition: emitter.hpp:219
+
entt::Emitter::once
Connection< Event > once(Listener< Event > listener)
Registers a short-lived listener with the event emitter.
Definition: emitter.hpp:269
+
entt::Emitter::clear
void clear() ENTT_NOEXCEPT
Disconnects all the listeners for the given event type.
Definition: emitter.hpp:296
+
entt::Emitter::clear
void clear() ENTT_NOEXCEPT
Disconnects all the listeners.
Definition: emitter.hpp:306
+
entt::Emitter
General purpose event emitter.
Definition: emitter.hpp:41
+
entt::Emitter::Emitter
Emitter() ENTT_NOEXCEPT=default
Default constructor.
+
entt::Emitter::~Emitter
virtual ~Emitter() ENTT_NOEXCEPT
Default destructor.
Definition: emitter.hpp:193
+
entt::Emitter::erase
void erase(Connection< Event > conn) ENTT_NOEXCEPT
Disconnects a listener from the event emitter.
Definition: emitter.hpp:283
+
entt::Emitter::Listener
typename Handler< Event >::listener_type Listener
Type of listeners accepted for the given event.
Definition: emitter.hpp:144
diff --git a/entt_8hpp_source.html b/entt_8hpp_source.html index 437dc918f..124404159 100644 --- a/entt_8hpp_source.html +++ b/entt_8hpp_source.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -67,7 +67,7 @@ $(function() {
entt.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/entt_traits.hpp"
6 #include "entity/registry.hpp"
7 #include "entity/snapshot.hpp"
8 #include "entity/sparse_set.hpp"
9 #include "entity/view.hpp"
10 #include "locator/locator.hpp"
11 #include "process/process.hpp"
12 #include "process/scheduler.hpp"
13 #include "resource/cache.hpp"
14 #include "resource/handle.hpp"
15 #include "resource/loader.hpp"
16 #include "signal/bus.hpp"
17 #include "signal/delegate.hpp"
18 #include "signal/dispatcher.hpp"
19 #include "signal/emitter.hpp"
20 #include "signal/sigh.hpp"
21 #include "signal/signal.hpp"
+
1 #include "core/algorithm.hpp"
2 #include "core/family.hpp"
3 #include "core/hashed_string.hpp"
4 #include "core/ident.hpp"
5 #include "entity/actor.hpp"
6 #include "entity/entt_traits.hpp"
7 #include "entity/helper.hpp"
8 #include "entity/prototype.hpp"
9 #include "entity/registry.hpp"
10 #include "entity/snapshot.hpp"
11 #include "entity/sparse_set.hpp"
12 #include "entity/utility.hpp"
13 #include "entity/view.hpp"
14 #include "locator/locator.hpp"
15 #include "process/process.hpp"
16 #include "process/scheduler.hpp"
17 #include "resource/cache.hpp"
18 #include "resource/handle.hpp"
19 #include "resource/loader.hpp"
20 #include "signal/delegate.hpp"
21 #include "signal/dispatcher.hpp"
22 #include "signal/emitter.hpp"
23 #include "signal/sigh.hpp"
Generated by   diff --git a/entt__traits_8hpp_source.html b/entt__traits_8hpp_source.html index d91e360a9..38ed1dbf6 100644 --- a/entt__traits_8hpp_source.html +++ b/entt__traits_8hpp_source.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -69,7 +69,7 @@ $(function() {
1 #ifndef ENTT_ENTITY_ENTT_TRAITS_HPP
2 #define ENTT_ENTITY_ENTT_TRAITS_HPP
3 
4 
5 #include <cstdint>
6 
7 
8 namespace entt {
9 
10 
17 template<typename>
18 struct entt_traits;
19 
20 
29 template<>
30 struct entt_traits<std::uint16_t> {
32  using entity_type = std::uint16_t;
34  using version_type = std::uint8_t;
35 
37  static constexpr auto entity_mask = 0xFFF;
39  static constexpr auto version_mask = 0xF;
41  static constexpr auto entity_shift = 12;
42 };
43 
44 
53 template<>
54 struct entt_traits<std::uint32_t> {
56  using entity_type = std::uint32_t;
58  using version_type = std::uint16_t;
59 
61  static constexpr auto entity_mask = 0xFFFFF;
63  static constexpr auto version_mask = 0xFFF;
65  static constexpr auto entity_shift = 20;
66 };
67 
68 
77 template<>
78 struct entt_traits<std::uint64_t> {
80  using entity_type = std::uint64_t;
82  using version_type = std::uint32_t;
83 
85  static constexpr auto entity_mask = 0xFFFFFFFFFF;
87  static constexpr auto version_mask = 0xFFFFFF;
89  static constexpr auto entity_shift = 40;
90 };
91 
92 
93 }
94 
95 
96 #endif // ENTT_ENTITY_ENTT_TRAITS_HPP
entt::entt_traits< std::uint32_t >::entity_type
std::uint32_t entity_type
Underlying entity type.
Definition: entt_traits.hpp:56
entt::entt_traits< std::uint64_t >::entity_type
std::uint64_t entity_type
Underlying entity type.
Definition: entt_traits.hpp:80
-
entt
EnTT default namespace.
Definition: family.hpp:10
+
entt
EnTT default namespace.
Definition: algorithm.hpp:10
entt::entt_traits< std::uint16_t >::entity_type
std::uint16_t entity_type
Underlying entity type.
Definition: entt_traits.hpp:32
entt::entt_traits< std::uint64_t >::version_type
std::uint32_t version_type
Underlying version type.
Definition: entt_traits.hpp:82
entt::entt_traits< std::uint16_t >::version_type
std::uint8_t version_type
Underlying version type.
Definition: entt_traits.hpp:34
diff --git a/family_8hpp_source.html b/family_8hpp_source.html index a9f6d16dd..cfcc1a4fb 100644 --- a/family_8hpp_source.html +++ b/family_8hpp_source.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -67,10 +67,10 @@ $(function() {
family.hpp
-
1 #ifndef ENTT_CORE_FAMILY_HPP
2 #define ENTT_CORE_FAMILY_HPP
3 
4 
5 #include<type_traits>
6 #include<cstddef>
7 #include<atomic>
8 
9 
10 namespace entt {
11 
12 
20 template<typename...>
21 class Family {
22  static std::atomic<std::size_t> identifier;
23 
24  template<typename...>
25  static std::size_t family() noexcept {
26  static const std::size_t value = identifier.fetch_add(1);
27  return value;
28  }
29 
30 public:
32  using family_type = std::size_t;
33 
38  template<typename... Type>
39  inline static family_type type() noexcept {
40  return family<std::decay_t<Type>...>();
41  }
42 };
43 
44 
45 template<typename... Types>
46 std::atomic<std::size_t> Family<Types...>::identifier{};
47 
48 
49 }
50 
51 
52 #endif // ENTT_CORE_FAMILY_HPP
entt
EnTT default namespace.
Definition: family.hpp:10
-
entt::Family::type
static family_type type() noexcept
Returns an unique identifier for the given type.
Definition: family.hpp:39
-
entt::Family::family_type
std::size_t family_type
Unsigned integer type.
Definition: family.hpp:32
-
entt::Family
Dynamic identifier generator.
Definition: family.hpp:21
+
1 #ifndef ENTT_CORE_FAMILY_HPP
2 #define ENTT_CORE_FAMILY_HPP
3 
4 
5 #include<type_traits>
6 #include<cstddef>
7 #include<atomic>
8 #include "../config/config.h"
9 
10 
11 namespace entt {
12 
13 
21 template<typename...>
22 class Family {
23  static std::atomic<std::size_t> identifier;
24 
25  template<typename...>
26  static std::size_t family() ENTT_NOEXCEPT {
27  static const std::size_t value = identifier.fetch_add(1);
28  return value;
29  }
30 
31 public:
33  using family_type = std::size_t;
34 
39  template<typename... Type>
40  inline static family_type type() ENTT_NOEXCEPT {
41  return family<std::decay_t<Type>...>();
42  }
43 };
44 
45 
46 template<typename... Types>
47 std::atomic<std::size_t> Family<Types...>::identifier{};
48 
49 
50 }
51 
52 
53 #endif // ENTT_CORE_FAMILY_HPP
entt
EnTT default namespace.
Definition: algorithm.hpp:10
+
entt::Family::type
static family_type type() ENTT_NOEXCEPT
Returns an unique identifier for the given type.
Definition: family.hpp:40
+
entt::Family::family_type
std::size_t family_type
Unsigned integer type.
Definition: family.hpp:33
+
entt::Family
Dynamic identifier generator.
Definition: family.hpp:22
diff --git a/files.html b/files.html index b0a46311e..de79b6df8 100644 --- a/files.html +++ b/files.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -67,34 +67,38 @@ $(function() {
[detail level 1234]
- - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
 ▼ src
 ▼ entt
 ▼ core
 family.hpp
 hashed_string.hpp
 ident.hpp
 ▼ entity
 actor.hpp
 entt_traits.hpp
 registry.hpp
 snapshot.hpp
 sparse_set.hpp
 view.hpp
 ▼ locator
 locator.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
 ▼ config
 config.h
 ▼ core
 algorithm.hpp
 family.hpp
 hashed_string.hpp
 ident.hpp
 ▼ entity
 actor.hpp
 entt_traits.hpp
 helper.hpp
 prototype.hpp
 registry.hpp
 snapshot.hpp
 sparse_set.hpp
 utility.hpp
 view.hpp
 ▼ locator
 locator.hpp
 ▼ process
 process.hpp
 scheduler.hpp
 ▼ resource
 cache.hpp
 handle.hpp
 loader.hpp
 ▼ signal
 delegate.hpp
 dispatcher.hpp
 emitter.hpp
 sigh.hpp
 entt.hpp
diff --git a/functions.html b/functions.html index 3f3458af0..233161e5f 100644 --- a/functions.html +++ b/functions.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -63,27 +63,29 @@ $(function() {

- a -

diff --git a/functions_0x7e.html b/functions_0x7e.html index 144c5a9ac..61a285900 100644 --- a/functions_0x7e.html +++ b/functions_0x7e.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -63,19 +63,19 @@ $(function() {

- ~ -

diff --git a/functions_b.html b/functions_b.html index f231143ec..ba5389d32 100644 --- a/functions_b.html +++ b/functions_b.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -63,11 +63,11 @@ $(function() {

- b -

diff --git a/functions_c.html b/functions_c.html index 3b2a504ab..da407ba88 100644 --- a/functions_c.html +++ b/functions_c.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -63,14 +63,31 @@ $(function() {

- c -

diff --git a/functions_d.html b/functions_d.html index ad3016dd9..dc349e21a 100644 --- a/functions_d.html +++ b/functions_d.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -63,44 +63,40 @@ $(function() {

- d -

diff --git a/functions_e.html b/functions_e.html index e68bd2249..e9d52f326 100644 --- a/functions_e.html +++ b/functions_e.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -64,39 +64,43 @@ $(function() {

- e -

diff --git a/functions_f.html b/functions_f.html index 42992d2ac..ea155313a 100644 --- a/functions_f.html +++ b/functions_f.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -63,14 +63,14 @@ $(function() {

- f -

diff --git a/functions_func.html b/functions_func.html index be159c30c..810608a75 100644 --- a/functions_func.html +++ b/functions_func.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -63,27 +63,29 @@ $(function() {

- a -

diff --git a/functions_func_0x7e.html b/functions_func_0x7e.html index 6f54cd978..d73150199 100644 --- a/functions_func_0x7e.html +++ b/functions_func_0x7e.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -63,19 +63,19 @@ $(function() {

- ~ -

diff --git a/functions_func_b.html b/functions_func_b.html index 388e7c478..b96d1a2ec 100644 --- a/functions_func_b.html +++ b/functions_func_b.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -63,11 +63,11 @@ $(function() {

- b -

diff --git a/functions_func_c.html b/functions_func_c.html index 79c80b9bb..088aabc66 100644 --- a/functions_func_c.html +++ b/functions_func_c.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -63,53 +63,69 @@ $(function() {

- c -

diff --git a/functions_func_d.html b/functions_func_d.html index 74a03a103..a30c9534a 100644 --- a/functions_func_d.html +++ b/functions_func_d.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -63,40 +63,37 @@ $(function() {

- d -

diff --git a/functions_func_e.html b/functions_func_e.html index ca420b17b..eff084e16 100644 --- a/functions_func_e.html +++ b/functions_func_e.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -64,44 +64,48 @@ $(function() {

- e -

diff --git a/functions_func_f.html b/functions_func_f.html index 8da464ffb..049e4cd35 100644 --- a/functions_func_f.html +++ b/functions_func_f.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -63,11 +63,11 @@ $(function() {

- f -

diff --git a/functions_func_g.html b/functions_func_g.html index 48060f53b..4c9cc46d5 100644 --- a/functions_func_g.html +++ b/functions_func_g.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -63,14 +63,15 @@ $(function() {

- g -

diff --git a/functions_func_h.html b/functions_func_h.html index f9f0bbb4e..c8744a902 100644 --- a/functions_func_h.html +++ b/functions_func_h.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -63,16 +63,17 @@ $(function() {

- h -

diff --git a/functions_func_l.html b/functions_func_l.html index 62581d0cc..446924d03 100644 --- a/functions_func_l.html +++ b/functions_func_l.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -63,7 +63,7 @@ $(function() {

- l -

diff --git a/functions_func_m.html b/functions_func_m.html index 6bf8ab72d..825f238f2 100644 --- a/functions_func_m.html +++ b/functions_func_m.html @@ -22,7 +22,7 @@
entt -  2.5.0 +  2.6.0
@@ -66,7 +66,7 @@ $(function() { : entt::ContinuousLoader< Entity >
  • move() -: entt::Registry< Entity > +: entt::Registry< Entity >
    • diff --git a/functions_func_o.html b/functions_func_o.html index 343e21bde..6e009637a 100644 --- a/functions_func_o.html +++ b/functions_func_o.html @@ -22,7 +22,7 @@
    entt -  2.5.0 +  2.6.0
    @@ -72,48 +72,52 @@ $(function() { : entt::ResourceHandle< Resource >
  • operator const char *() -: entt::HashedString +: entt::HashedString
  • operator const Resource &() -: entt::ResourceHandle< Resource > +: entt::ResourceHandle< Resource >
  • operator hash_type() -: entt::HashedString +: entt::HashedString
  • operator()() : entt::Delegate< Ret(Args...)> +, entt::InsertionSort +, entt::Prototype< Entity > +, entt::StdSort
  • operator*() -: entt::ResourceHandle< Resource > +: entt::ResourceHandle< Resource >
  • operator->() -: entt::ResourceHandle< Resource > +: entt::ResourceHandle< Resource >
  • operator=() -: entt::Actor< Entity, Delta > -, entt::ContinuousLoader< Entity > +: entt::Actor< Entity > +, entt::ContinuousLoader< Entity > , entt::Emitter< Derived >::Connection< Event > -, entt::Emitter< Derived > +, entt::Emitter< Derived > , entt::Registry< Entity > -, entt::ResourceCache< Resource > -, entt::ResourceHandle< Resource > -, entt::Scheduler< Delta > +, entt::ResourceCache< Resource > +, entt::ResourceHandle< Resource > +, entt::Scheduler< Delta > +, entt::Snapshot< Entity > +, entt::SnapshotLoader< Entity > , entt::SparseSet< Entity > -, entt::SparseSet< Entity, Type > +, entt::SparseSet< Entity, Type >
  • operator==() -: entt::Delegate< Ret(Args...)> -, entt::HashedString -, entt::SigH< Ret(Args...), Collector > -, entt::Signal< void(Args...)> +: entt::Delegate< Ret(Args...)> +, entt::HashedString +, entt::SigH< Ret(Args...), Collector >
  • orphan() -: entt::Registry< Entity > +: entt::Registry< Entity >
  • orphans() : entt::ContinuousLoader< Entity > , entt::Registry< Entity > -, entt::SnapshotLoader< Entity > +, entt::SnapshotLoader< Entity >
    • diff --git a/functions_func_p.html b/functions_func_p.html index 0ad593911..e8a4b91cf 100644 --- a/functions_func_p.html +++ b/functions_func_p.html @@ -22,7 +22,7 @@
    entt -  2.5.0 +  2.6.0
    @@ -63,13 +63,10 @@ $(function() {

    - p -

    diff --git a/functions_func_r.html b/functions_func_r.html index c3eb02e4e..d0e66dc78 100644 --- a/functions_func_r.html +++ b/functions_func_r.html @@ -22,7 +22,7 @@
    entt -  2.5.0 +  2.6.0
    @@ -63,58 +63,54 @@ $(function() {

    - r -

    diff --git a/functions_m.html b/functions_m.html index 248a3f8e6..a561a3ce3 100644 --- a/functions_m.html +++ b/functions_m.html @@ -22,7 +22,7 @@
    entt -  2.5.0 +  2.6.0
    @@ -66,7 +66,7 @@ $(function() { : entt::ContinuousLoader< Entity >
  • move() -: entt::Registry< Entity > +: entt::Registry< Entity >
    • diff --git a/functions_o.html b/functions_o.html index 7c3d5d52d..499504f31 100644 --- a/functions_o.html +++ b/functions_o.html @@ -22,7 +22,7 @@
    entt -  2.5.0 +  2.6.0
    @@ -75,48 +75,52 @@ $(function() { : entt::ResourceHandle< Resource >
  • operator const char *() -: entt::HashedString +: entt::HashedString
  • operator const Resource &() -: entt::ResourceHandle< Resource > +: entt::ResourceHandle< Resource >
  • operator hash_type() -: entt::HashedString +: entt::HashedString
  • operator()() : entt::Delegate< Ret(Args...)> +, entt::InsertionSort +, entt::Prototype< Entity > +, entt::StdSort
  • operator*() -: entt::ResourceHandle< Resource > +: entt::ResourceHandle< Resource >
  • operator->() -: entt::ResourceHandle< Resource > +: entt::ResourceHandle< Resource >
  • operator=() -: entt::Actor< Entity, Delta > -, entt::ContinuousLoader< Entity > +: entt::Actor< Entity > +, entt::ContinuousLoader< Entity > , entt::Emitter< Derived >::Connection< Event > , entt::Emitter< Derived > , entt::Registry< Entity > -, entt::ResourceCache< Resource > -, entt::ResourceHandle< Resource > -, entt::Scheduler< Delta > +, entt::ResourceCache< Resource > +, entt::ResourceHandle< Resource > +, entt::Scheduler< Delta > +, entt::Snapshot< Entity > +, entt::SnapshotLoader< Entity > , entt::SparseSet< Entity > -, entt::SparseSet< Entity, Type > +, entt::SparseSet< Entity, Type >
  • operator==() -: entt::Delegate< Ret(Args...)> -, entt::HashedString -, entt::SigH< Ret(Args...), Collector > -, entt::Signal< void(Args...)> +: entt::Delegate< Ret(Args...)> +, entt::HashedString +, entt::SigH< Ret(Args...), Collector >
  • orphan() -: entt::Registry< Entity > +: entt::Registry< Entity >
  • orphans() : entt::ContinuousLoader< Entity > , entt::Registry< Entity > -, entt::SnapshotLoader< Entity > +, entt::SnapshotLoader< Entity >
    • diff --git a/functions_p.html b/functions_p.html index da832dcab..daef86368 100644 --- a/functions_p.html +++ b/functions_p.html @@ -22,7 +22,7 @@
    entt -  2.5.0 +  2.6.0
    @@ -63,13 +63,10 @@ $(function() {

    - p -

    diff --git a/functions_r.html b/functions_r.html index 49d49ef56..49503b74c 100644 --- a/functions_r.html +++ b/functions_r.html @@ -22,7 +22,7 @@
    entt -  2.5.0 +  2.6.0
    @@ -63,24 +63,20 @@ $(function() {

    - r -

    diff --git a/functions_s.html b/functions_s.html index ffbb2067c..5fa69f0df 100644 --- a/functions_s.html +++ b/functions_s.html @@ -22,7 +22,7 @@
    entt -  2.5.0 +  2.6.0
    @@ -63,7 +63,7 @@ $(function() {

    - s -

    diff --git a/functions_t.html b/functions_t.html index f1c0c10ee..468d0af53 100644 --- a/functions_t.html +++ b/functions_t.html @@ -22,7 +22,7 @@
    entt -  2.5.0 +  2.6.0
    @@ -63,10 +63,9 @@ $(function() {

    - t -

    diff --git a/functions_type.html b/functions_type.html index 60e58a777..a65774cb6 100644 --- a/functions_type.html +++ b/functions_type.html @@ -22,7 +22,7 @@
    entt -  2.5.0 +  2.6.0
    @@ -68,25 +68,32 @@ $(function() {
  • component_type : entt::Registry< Entity >
    • +
  • const_iterator_type +: entt::PersistentView< Entity, Component > +, entt::RawView< Entity, Component > +, entt::SparseSet< Entity > +, entt::SparseSet< Entity, Type > +, entt::View< Entity, Component > +

    • - d -

    - e -

  • View: to persist or not to persist?