EnTT v3.6.0 changelog preview

[skypjack]

Changelog

This is the changelog preview of EnTT 3.6.0, that is, the current master. Any feedback is appreciated.
Of course, feel free to comment even just to correct my English, which is certainly not the best! 🙂
If there are no relevant issues, I'll cut a new release in the next few days or early 2021 at the latest.

Short version (aka most wanted/relevant changes)

• Stamp is back. 😄
• Truly const and therefore const thread safe registry.
• meta_any as well as the new any class support const references.
• I've added the organizer class to create a minimal dependency graph for your systems.
• The EnTT type system was improved and type_info is now an opaque type returnd by type_id<T>.
• There is a new module called poly for automated static polymorphism.
• Full support for custom pools is finally a (very important) thing.

Long version (aka all you can find in v3.6.0)

• config:

  • Reintroduced ENTT_DISABLE_ASSERT to fully disable asserts.

• core:

  • Added sfinae-friendly class type_seq to provide sequential identifiers for types.
  • Added sfinae-friendly class type_hash to provide unique identifiers for types.
  • Added sfinae-friendly class type_name to provide demangled names for types.
  • Added untyped class type_info as a replacement for the template class type_info<T>.
  • Added type_id function template to generate untyped type_info objects from types:

    auto info = entt::type_id<a_type>();
    

  • Added utility type_list_contains[_v].
  • Added size_of_v, an extension for sizeof that doesn't complain when used with functions or incomplete types.
  • Added type_list<T...>::size to know the number of types of a type list.
  • Added operator+ for type lists (similar to type_list_cat[_t], but for variables rather than types):

    constexpr auto list = entt::type_list<int, char>{} + entt::type_list<double>{};
    

  • Added traits is_applicable[_v] and is_applicable_r[_v], a sort of std::is_invocable with tuples.
  • Added trait is_empty[_v] (mainly used for internal purposes) that is true only if ENTT_NO_ETO isn't defined.
  • Updated default page size (ENTT_PAGE_SIZE) to 4096.
  • hashed_string::value is now constexpr, suitable for uses with string views in constant expressions.
  • Added trait constness_as[_t] to transfer the constness between types.
  • User defined literals for hashed strings (_hs and _hws) have been moved to the namespace entt::literals.
  • Added trait is_complete[_v] to detect complete types.
  • Standalone, branchless implementation of entt::any with a default SBO size of sizeof(double[2]).
  • entt::any support for both const and non-const references (extended to meta and poly, see below).
  • Added entt::any_cast overloads similar to what the standard library offers.
  • Added as_ref to create aliases to unmanaged objects with any.
  • Added value_list and value_list_cat[_t] (similar to type_list and type_list_cast[_t], but for values rather than types).
  • Added type_identity[_t] trait (waiting for a C++20 version of EnTT).
  • Added type_list_element[_t] for type_lists, similar to std::tuple_element_t.
  • Added value_list_element[_v] for value_lists, similar to std::tuple_element_t.

• entity:

  • Full support for custom storage/views (🥳). This is HUGE, even if at the moment it lacks proper documentation.
  • storage_adapter_mixin and sigh_pool_mixin are now independent from each other. It's also easy to set a signal-less default pool:

    template<typename Entity, typename Type>
    struct pool<Entity, Type> {
        using type = storage_adapter_mixin<basic_storage<Entity, Type>>;
    };
    

  • Added multi-type view ::size_hint member function.
  • registry::visit and registry::ctx return now a whole type_info object rather than the sole identifier.
  • It's now possible to create truly invalid instances of entt::handle.
  • Added the new class organizer to create a minimal dependency graph for your systems, see the documentation for further details.
  • storage::emplace returns now the newly created object.
  • Introduced the alias value_type as a replacement for object_type (storage, pool).
  • Added basic_group<...>::each() and basic_view<...>::each() as a replacement for ::proxy.
  • Reduced scope for candidate selection in views.
  • Extended get for views and groups:

    auto [pos, vel] = registry.view<position, velocity>().get(entity);
    

  • Added the view_pack class template to combine views and decide what type leads the iteration:

    for(auto entity: registry.view<position>() | registry.view<velocity>()) {
        // ...
    }
    

    The intended use for this tool is with custom storage/views, but it's also useful in everyday uses.
    The view pack is a view-like object, similar to a multi-type view. It's also iterable and it offers both each(func) and each() as well:

    for(auto [entity, pos, vel]: (registry.view<position>() | registry.view<velocity>()).each()) {
       // ...
    }
    

    A view pack converts to references to its views. See the documentation for further details.
  • Callbacks with entity are now the first choice for views and groups.
  • Iterable views and groups (each()) also offer reverse iterators.
  • registry::assign also requires the head of the list of destroyed entities now and is much (much!) faster.
  • Added registry::destroyed to get the head of the list of destroyed entities (to use with ::raw and ::assign).
  • Added view<...>::use<T> to multi-type views to force the pool to use a given storage (useful when using iterators).
  • Added the handle_view class, a more restricted version of handle which also specifies the types it operates on (conversion operators available).
  • Relaxed the requirement to expose a try_get member functions for (custom) storage classes.
  • Added the entt::get_as_tuple function to get the content of a storage given an entity as a (possibly empty) tuple.
  • Added the sfinae-friendly storage_traits class to provide information on storage classes.
  • Views constructors are public now, it's possible to create views from custom or externally managed storage.
  • Added runtime view ::size_hint member function.
  • Default constructible, invalid (pool-less) groups, views and runtime views.
  • Truly const and therefore const thread safe registry (currently based on pool-less views).
  • Support for destroying entities from a handle (namely basic_handle<Entity>::destroy).
  • Added poly_storage, fully customizable poly_storage_traits and const/non-const registry::storage for opaque proxies to pools (aka welcome back stamp, copy, ...). 🙂

• meta:

  • Added opaque meta_type::size_of to know the size of the underlying type.
  • Added meta_type::info as a replacement for meta_type::hash.
  • Extended resolve, it accepts now a type as a template parameter, or an unique identifier or type info object as an argument.
  • Meta functions and meta constructors finally support external functions:

    entt::meta<Type>().type("Type"_hs).func<&entt::registry::emplace_or_replace<Type>, entt::as_ref_t>("emplace"_hs);
    

  • Added meta function overload support.
  • Container traits are no longer an internal details only.
  • A meta_any that doesn't contain a pointer-like object can be safely dereferenced and will return an invalid instance.
  • meta_any uses entt::any internally rather than meta_storage.
  • Reduced instantiations due to meta_any using a single fake vtable function internally.
  • Added as_ref to create aliases to unmanaged objects with meta_any.
  • Support for const references when working with aliased objects.
  • Added the as_cref_t policy to receive data members and return values as const references.
  • Pointer-like types to const elements return wrapped const references rather than making a copy of the pointed object.
  • Meta containers support for const containers, their const iterators and const references to their elements.
  • Added meta_any::allow_cast as a better, more flexible alternative for meta_any::convert.
  • Added const and non-const overloads of meta_any::get and meta_any::invoke.
  • Direct alias constructor for meta_any:

    int value = 42;
    entt::meta_any any{std::in_place_type<int>, &value};

  • Added const and non-const overloads for operator*, as_sequence_container and as_associative_container to meta_any.
  • Support for pointer-like types with a custom dereference operator other than operator*.

• poly:

  • Added a new module called poly for automated static polymorphism.
    See the official documentation for all the details and usage instructions.

• signal:

  • Truly const and therefore const thread safe emitter.

• The single include file also contains the version now.

• Allow compilation for Windows with GNU-like compilers.

• Performance improvements here and there (registry::create, registry::clear, storage remove and range-remove, ...).

Breaking changes

• config

  • ENTT_STANDALONE has been removed.
  • ENTT_HS_SUFFIX has been removed.
  • ENTT_HWS_SUFFIX has been removed.

• core:

  • type_index has been removed, use type_seq instead.
  • has_type_index[_v] utility has been removed.
  • type_info is not longer a class template. See the untyped version of type_info, the type_id function template, other than type_seq, type_hash and type_name for further details.
  • Removed type_list_size[_v], use type_list<T...>::size instead.
  • is_eto_eligible[_v] is now is_empty[_v].
  • Importing entt::literals namespace is required in order to use user defined literals for hashed strings (_hs and _hws).

• entity:

  • registry::visit and registry::ctx return now a whole type_info object rather than the sole identifier.
  • Removed multi-type view ::empty because it was misleading, use ::size_hint instead.
  • Removed multi-type view ::size because it was misleading, use ::size_hint instead.
  • Removed multi-type view ::size<T>, raw<T> and data<T> because they were misleading.
  • Removed the alias object_type, use value_type instead (storage, pool).
  • Removed basic_group<...>::proxy and basic_view<...>::proxy, use ::each() instead.
  • Single type views return an std::tuple<T> when the type isn't provided to the ::get member function (uniformity purpose for extended selection).
  • Callbacks with entity are now the first choice for views and groups.
  • registry::assign also requires the head of the list of destroyed entities (see ::destroyed).
  • Removed chunked iteration for multi-type views, there was no way to make it consistent across all views with custom storage.
  • pool_traits is replaced by storage_traits.
  • Removed member functions ::size<T>, ::empty<T..> and data<T> from groups, they provide misleading information.
  • Reduced the scope of the member function ::raw for groups, it provides misleading information.
  • Removed runtime view ::empty because it was misleading, use ::size_hint instead.
  • Removed runtime view ::size because it was misleading, use ::size_hint instead.

• meta:

  • Removed meta_type::hash, use meta_type::info instead.
  • Removed resolve_id, use resolve instead.
  • Removed resolve_type, use resolve instead.
  • Removed meta_storage, replaced by entt::any.
  • Removed as_ref tag, no replacement available.
  • Removed meta_any::ref, use as_ref(any) instead.
  • Removed meta_any::convert, use meta_any::allow_cast instead.

• EnTT across boundaries:

  • Standalone mode is now the default.
    To make EnTT work across boundaries, you've to provide support for contiguous identifiers.
    See the examples in the test directory for more details.

Deprecated features

All previously deprecated functions and classes have been removed.
This release contains many breaking changes. There was no way to make a smooth transition because of the amount and nature of these changes.
Because of that, I decided to not deprecate functions when possible and remove them directly instead.
See the above section for a migration guide.

Examples

I'm adding some examples (see test/example) to answer the most frequently asked questions.
Custom storage/views also deserve a fair number of examples. I'll add them time by time as possible.

Any other business

The documentation is up-to-date and the library is battle-tested with 100% coverage as usual.
I've also updated the FAQs and the section EnTT in Action with more and more examples.

There are a couple of extra pages available in the documentation:

• UE4 usage instructions.
• poly module.

I started a long term process to reduce the number of instantiations and therefore speed up the compilation.
This release contains some more changes in this regard. Still a work in progress though.

[Green-Sky]

Added the new class organizer, see the documentation for further details.

Please provide a short summary (or teaser with some buzzwords 😏 ).
Also please add actual links to all "see documentation".

Biggest? release so far! 🥳

[skypjack]

Please provide a short summary (or teaser with some buzzwords 😏 ).

A short summary is hard to provide, but I can sum up the most interesting/wanted changes:

• Stamp is back. 😄
• Truly const and therefore const thread safe registry.
• meta_any as well as the new any class support const references.
• I've added the organizer class to create a minimal dependency graph for your systems.
• The EnTT type system was improved and type_info is now an opaque type returnd by type_id<T>.
• There is a new module called poly for automated static polymorphism.
• Full support for custom pools is finally a (very important) thing.

[Green-Sky]

wait, why does the link at poly link to view-packs and not the dedicated poly page? copy-paste error? 😏

[Green-Sky]

A short summary is hard to provide, but I can sum up the most interesting/wanted changes

in this case i specifically meant the organizer bullet point. since it actually gives zero information ...

but having a shorter summary at the beginning would be nice too, i think imgui does something similar... Its also how you write "Text", apparently ... :D

[skypjack]

wait, why does the link at poly link to view-packs and not the dedicated poly page? copy-paste error? 😏

Ehm... good catch. 😄

[skypjack]

Added a short version at the top of the discussion and some details about the organizer class. 👍
Thank you for the feedback. Really appreciated! ❤️

[Green-Sky]

Old topic, but again

Deprecated features
All previously deprecated functions and classes have been removed.
This release contains many breaking changes. There was no way to make a smooth transition because of the amount and nature of these changes.
Because of that, I decided to not deprecate functions when possible and remove them directly instead.
See the above section for a migration guide.

... why is it not v4.0.0 ? (sorry for bothering)

[Innokentiy-Alaytsev]

I'd think of the major version of EnTT as an epoch, i.e. it denotes a super-version that has the same underlying concept and very similar model and API overall. The minor version is closer to being semantic major version as most of the time changes to it means breaking changes. In theory, the fourth number could be introduced for patch-level releases but they are relatively rare.

[Lawrencemm]

... why is it not v4.0.0 ? (sorry for bothering)

@Green-Sky I think we'd be up to major release three million by now if each release with breaking changes was a new major version.

I've seen this point made from reddit users as well with the announcement posts.

This library has been and likely will continue to be highly experimental and this is the nature of the beast. Semantic versioning isn't the right fit for every project.

[Green-Sky]

we'd be up to major release three million by now if each release with breaking changes was a new major version.

😆 well, not untrue...

[...] this is the nature of the beast.

Yea, i guess. Since this is a "header-only" library this also makes a bit of sense, we don't maintain ABI compatibility after all...

[skypjack]

Yeah. Also, with the last releases I tried to give a deprecation cycle to all feature.
However, because of my current job, I need some changes to enter the upstream quickly. So...

Btw, the list is long but all of them are more or less tiny changes and I pointed out the alternative in all cases.
So, it works as a migration guide and I can guarantee that it's pretty easy to migrate from v3.5.x to this new version.

[Innokentiy-Alaytsev]

🤔
I've seen an approach to versioning header-only libraries: all the things inside the library live inside an inline namespace that has the version as its name, e.g. v3_6_0. It may not be important but may same you in some cases where things with different EnTT versions are used in the same project somehow for some reason.

[Innokentiy-Alaytsev]

What about adding some kind of a hook for tags that will automatically re-generate single include file? I see users have many problems with its version being out of date.

[skypjack]

Do you mean something similar to deploy.yml (that updates the homebrew repo)?

[Innokentiy-Alaytsev]

Yup. This will lower the confusion of the users by a lot.

[skypjack]

Makes sense, though I've not clear how we can do that. Any idea? Otherwise I'll investigate it.

[Innokentiy-Alaytsev]

It seems like it should be very similar to how deploy.yml works. The only difference is that instead of doing whatever deploy.yml is doing you run scripts/amalgamate.py before committing and pushing.

[skypjack]

Mmm... triggers for GH actions are on pushes, tags and so on, I don't think we can update a file before committing. So, it would result as a new commit after tag creation in the best case. Am I wrong?

[LiliumAtratum]

Added size_of_v, an extension for sizeof that doesn't complain when used with functions or incomplete types.

So I presume it returns some value for those incomplete types. 0? -1?
Are you not concerned that the same size_of_v expression (even the same physical source line!) may return different values depending on which #include header files are included up to that point? I would be very cautious about it - while the concept is convenient, I fear it may be a source of really hard-to-track bugs.
Maybe just live with the current sizeof and wait till C++20 modules become more popular, so that having the full type definition won't be a problem anymore?

[LiliumAtratum]

Why will values differ?

In the first compiland, MyType is undefined, so size_of_v<MyType> is 0. In the second case, MyType is defined, so size_of_v<MyType> will equal the actual size of MyType.

[Innokentiy-Alaytsev]

Oh, now I see what you mean. I didn't look at the code before and thought that the size_of_v is for type packs. That's why I couldn't understand why would the value differ.

[skypjack]

size_of_v is only used within meta_node::resolve. This function is only invoked on first use of any type, to register a node internally with the meta system. I don't see how the type could be undefined to be honest. So, all in all, it's just a shortcut to have a 0 for when the type is void.

[LiliumAtratum]

Oh, so by saying "0 for incomplete types" you intend to use it that way only for void types, which formally is an incomplete type. Got it.
Hopefully the problem will not bite someone in the future...

[skypjack]

Yeah, at least internally, size_of_v is used only when the type is actually required and therefore you would get an error for other reasons anyway, so it's more of a shortcut for void. 👍