Enabling pointer stability selectively for only one registry

[alektron]

I have a project in which I use entt in more than one structure. Leaving out a lot of detail it basically boils down to this

struct Scene
{
  entt::registry Reg;
}

using MyIdType = size_t;
enum class MyHandle : MyIdType {};
struct SomethingElse
{
  entt::basic_registry<MyHandle> Reg;
}

For Scene I am fine with not having any guarantees on pointer stability.
For SomethingElse however I could make my life easier if pointer stability was enabled.
The docs mentioned the feature but I had some trouble understanding it.
After searching the source a little bit it seems to me that I have two (maybe three?) options

A: I change in_place_deletion in component.hpp to true. This would do the trick but then I have in-place deletion enabled in the whole project which means for Scene as well.

B: I specialize component_traits for every component that I intend to use with SomethingElse::Reg. If I understood correctly this would look something like this (at least I tried it and it worked).

namespace entt
{
  template<> struct component_traits<MySomethingComponent> : basic_component_traits
  { 
    static constexpr auto in_place_delete = true;
  };
}

However now I have to make sure that whenever me or someone else in the team adds a new component, the spcialization gets added as well which could be easily forgotten.

C: I don't know how but maybe there is a way to change in_place_deletion in basic_component_traits to true without editing component.hpp? It would seem a bit strange to me that I have to edit entt source for that. But even if there was that possibilty, this would mean I'd have to guarantee that whatever code enables it can never by seen by Scene in any compilation unit which would be a problem.

TLDR; Can I enable in-place deletion for only a selection of basic_registry types?

(Btw. great job on entt. I enjoy using it a lot and the template magic required for it to work is completely beyond me!)

EDIT:
The wiki also shows an example where static constexpr auto in_place_delete = true; is simply defined in the components. While this would still suffer from the issues that it can be forgotten it would at be less code than the component_trait specialization. However it does not seem to work for me.

[skypjack]

TLDR; Can I enable in-place deletion for only a selection of basic_registry types?

You mean as in enable it for entt::registry<EntityType1> but not for entt::registry<EntityType2>?
This is an interesting feature that I need to address because of my work too. Briefly, it requires me to add a dependency on the entity type to the component traits.
Unfortunately it's not that simple because just adding it breaks a couple of other things here and there. Therefore, I've still to address it.

[alektron]

Not exactly. At least in my case EntityType1 and EntityType2 are in fact both a uint32 under the hood. Just as different aliases.
So unless using declares Type1 and Type2 as different types (unlike typedef which is not typesafe) I would still have my problem.
To simplify my original example even more one could say both registries are entt::registry<entt::entity> but they are INSIDE different structs.

struct Scene
{
  entt::registry Reg;
}

struct SomethingElse
{
  entt::registry Reg;
}

For Scene::Reg I do not need pointer stability but for SomethingElse::Reg I do

[skypjack]

Oh, no, this isn't possible then. For performance reasons (that is, to avoid having ifs everywhere in the storage and sparse set classes), pointer stability is defined at compile time. It happens on a component type basis and the registry looks for the component traits on its own.

[alektron]

Alright but that means, specializing component_traits for all components that I use with SomethingElse::Reg would be an option, right (As in my previous example B)?
That is, as long as I do not use these components in Scene::Reg as well. However that would not be the case anyways so it'll be fine with me.

Thank you for the quick replies!

[skypjack]

Yeah, although I wouldn't specialize the traits for all components. component_traits is sfinae-friendly. You can either add something to your types that you capture in a single specialization or use the in_place_delete static member as it happens here.