problem when sf::RenderWindow is noncopyable

[Mortal]

i'm recently working on new game design that reply on boost::any. the idea is simple, storing all update and draw methods for each game entities in appropriate container and call those methods when it is needed. sound simple and it can be done. also i went further and implemented my own any class similar to boost::any. my attempting seems work fine when i tested against primitives type (int, float and so on) even i tested with user-types. all previous tests went smoothly but when time come to test it with sfml i got some issues. for example, sf::Drawable::draw takes two parameters and it can be call through (sfml magic) by instance of any sf::RenderTarget. this doesn't work on my design. i solved it by make game entity non-drawable.

the issue that i can't find any solution for it is when sf::RenderWindow is noncopyable so, whenever, i tried to cast it down from boost::any or from my own any class, i got always bad cast assertion says "sf::RenderWindow& is deleted object". the only cheep solution that i come up with it, is to turn off assert checking, since i don't have access to boost::any, i changed my own any class and comment assert. the test code run fine but i not quite conformable with it.

here my code:

(click to show/hide)

#include <functional>
#include <vector>
#include <cassert>
#include <iostream>
#include <memory>

#include <SFML/Graphics.hpp>

////////////////////////// Any Class ////////////////////////////////
class AnyFunction
{
        struct placeholder
        {
                virtual ~placeholder() = default;
        };

        template <typename F>
        struct holder : placeholder
        {
                holder(F&& f) : data(std::forward<F>(f)) {}
                F data;
        };

public:
        template <typename F>
        AnyFunction(F&& f)
                : mContent(std::make_shared<holder<std::decay_t<F>>>(std::forward<F>(f)))
        {
        }

        template <typename F>
        const F& cast() const
        {
                assert(dynamic_cast<const holder<F>*>(mContent.get()) != nullptr);
                return static_cast<const holder<F>&>(*mContent).data;
        }

private:
        std::shared_ptr<placeholder> mContent = nullptr;
};

////////////////////////// Function Holder //////////////////////////
class FunctionHolder
{
public:
        template <typename T, typename R, typename... Ts>
        void insert(T&& t, R(T::*method)(Ts...))
        {
                using namespace std::placeholders;
                mHolder.emplace_back(std::function<R(Ts...)>(std::bind(method, std::forward<T>(t), _1)));
        }

        template <typename... Ts>
        void call(Ts&&... ts)
        {
                for (auto&& fn : mHolder)
                {
                        fn.cast<std::function<void(Ts...)>>()(std::forward<Ts>(ts)...);
                }
        }

private:
        std::vector<AnyFunction> mHolder;
};

////////////////////////// Test /////////////////////////////////////
struct Player : public sf::Transformable
{
        Player()
                : shape(100.f)
        {
                shape.setFillColor(sf::Color::Cyan);
        }

        void update(sf::Time dt)
        {
                std::cout << dt.asSeconds() << "Player update\n";
        }
        void draw(sf::RenderWindow& window)
        {
                window.draw(shape, getTransform());
        }

private:
        sf::CircleShape shape;

};

struct Enemy : public sf::Transformable
{
        Enemy()
                : shape(100.f)
        {
                shape.setFillColor(sf::Color::Red);
        }

        void update(sf::Time dt)
        {
                std::cout << dt.asSeconds() << "Enemy update\n";
        }
        void draw(sf::RenderWindow& window)
        {
                window.draw(shape, getTransform());
        }

private:
        sf::CircleShape shape;

};

int main()
{
        sf::RenderWindow window({ 800, 600 }, "test");

        Player player;
        player.setPosition(100, 100);

        Enemy enemy;
        enemy.setPosition(400, 300);

        FunctionHolder updater;
        updater.insert(std::move(player), &Player::update);
        updater.insert(std::move(enemy), &Enemy::update);

        FunctionHolder drawer;
        drawer.insert(std::move(player), &Player::draw);
        drawer.insert(std::move(enemy), &Enemy::draw);

        sf::Clock clock;
        while (window.isOpen())
        {
                sf::Event event;
                while (window.pollEvent(event))
                {
                        if (event.type == sf::Event::Closed)
                                window.close();
                }

                sf::Time dt = clock.restart();
                updater.call(dt);

                window.clear();
                drawer.call(window);
                window.display();
        }
}

my Questions:
how to solve noncopyable issue?
is my design reliable in game dev?

[Mortal]

i manage to solve it, the problem wasn't with sf::RenderWindow being noncopyable. it actually with with for-loop in call() function, for unknown reason it modifies the type of std::function signature when it calls cast() function. the solution was by using std::move to sf::Time instance (dt) instead of passing the object itself to call() function. so to run the code in main post safely, i need to change it to this:

updater.call(std::move(dt));

really i can't explain it more, because i don't know why this happen in first place!

to make the insert function more generic to allow more function parameters, the lambda would be handy here.

template <typename T, typename R, typename... Ts>
void insert(T&& t, R(T::*method)(Ts...))
{
        mHolder.emplace_back(std::function<R(Ts...)>(
                [source = std::forward<T>(t), method](Ts&&... ts) mutable
        {
                (source.*method)(std::forward<Ts>(ts)...);
        }));
}