Wrap .connect callback (delegates and lambdas)

[gergovari]

My goal is to return my own Entity wrapper class instead of entt::registry and entt::entity.

The approach I tried:

template <typename ComponentType> void Scene::onConstruct(std::function<void(Entity&)> func) {
    registry.on_construct<ComponentType>().template connect([](entt::registry &registry, entt::entity e) {});
} 

Even this simple example (without any way to call func in the lambda) fails to compile with:

scene.tpp:23:60: error: no matching function for call to ‘entt::sink<entt::sigh<void(entt::basic_registry<>&, entt::entity), std::allocator<Tag::Renderable> > >::connect(Scene::onConstruct<Tag::Renderable>(std::function<void(Entity&)>)::<lambda(entt::registry&, entt::entity)>)’
   23 |     registry.on_construct<ComponentType>().template connect([](entt::registry &registry, entt::entity e) {
      |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   24 |     });
      |     ~~                                                      
In file included from mixin.hpp:9,
                 from entt.hpp:30,
                 from components.hpp:3,
                 from scene.hpp:3:
sigh.hpp:410:16: note: candidate: ‘template<auto Candidate, class ... Type> entt::connection entt::sink<entt::sigh<Ret(Args ...), Allocator> >::connect(Type&& ...) [with auto Candidate = Candidate; Type = {Type ...}; Ret = void; Args = {entt::basic_registry<entt::entity, std::allocator<entt::entity> >&, entt::entity}; Allocator = std::allocator<Tag::Renderable>]’
  410 |     connection connect(Type &&...value_or_instance) {
      |                ^~~~~~~
sigh.hpp:410:16: note:   template argument deduction/substitution failed:
scene.tpp:23:60: note:   couldn’t deduce template parameter ‘Candidate’
   23 |     registry.on_construct<ComponentType>().template connect([](entt::registry &registry, entt::entity e) {
      |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   24 |     });
      |     ~~  

I (hopefully) understand the limitations and design choices behind delegates, although many specific examples seem (to me) inconsistent.

In theory I could also pass a pointer to the lambda as a sort of "capture" according to this blog post by @skypjack but as I couldn't even get the first example to compile this didn't help.

Next I tried to use the unary operator as mentioned in #132 but that didn't help. (Although as I understand that wasn't supposed to be a working example as lambdas can't be used as template parameters.)

From the error I could guess that the problem is related to that this is called from within a Scene instance in a member function, although I don't quite understand why that would be an issue.

How could this be made to work?

Are there any alternatives that I haven't yet considered that would be a better fit for my problem?

[gergovari]

Okay, I found one solution.

A SceneCallback class is needed that holds a reference to the Scene and whatever callback you want.
(I use std::function here, but I'm sure this would work with something else.)

class SceneCallback {
    private:
        Scene *scene;
        EntityCallback func;

    public:
        SceneCallback(Scene *s, EntityCallback f);
    
        void connect(entt::registry &registry, entt::entity e);
};

...

void SceneCallback::connect(entt::registry &registry, entt::entity e)
{
    auto *entityP = scene->get(e);
    if (entityP) {
        func(*entityP);
    }
}

There needs to be a place where these callback objects are stored.
(I've done it in my Scene class.)

class Scene {
  public:
    std::forward_list<Entity> entities;
    std::forward_list<SceneCallback> callbacks;
    
...

    template <typename ComponentType> void onConstruct(EntityCallback func);
    
...

}

...

template <typename ComponentType> void Scene::onConstruct(EntityCallback func)
{   
    registry.on_construct<ComponentType>().template connect<&SceneCallback::connect>(callbacks.emplace_front(this, func));
}   

It works, although if anyone has a better approach I would be glad to hear it.

[skypjack]

Sorry for the late reply. I'm a little busy due to personal issues. 🙏
The point is that delegates receive their callbacks as template arguments. You can't have lambdas in this case (well, you can have non-capturing lambdas with C++20, but it's technically a pointer to a free function at the end of the day).
Therefore, what you were trying to do in your first example wasn't possible. The last one gets the job done instead.

Consider that the whole signal support is a storage mixin in EnTT. Something you can swap off as you like. You can also replace it with your own implementation that works with lambdas if you prefer, it's also pretty easy to code I guess.
I decided to use delegates because I don't want risky captures or large capture lists in my own applications, but it's a matter of tastes at the end of the day. Nothing wrong with using a mixin that relies on standard functions.

[gergovari]

Your answer wasn't late at all, and this whole project alone would be a big task!

Didn't think that the library was that flexible, will look into this if the current setup becomes an issue.

Thank you for your answer!