function/Function.hpp

#include <memory>



template <typename Fun>
class Function;


template <typename Ret, typename... Args>
class Function<Ret(Args...)>
{
private:
    class callable_base
    {
    public:
        virtual Ret call(Args...) = 0;
        virtual ~callable_base() {}
        //virtual ~callable_base() = default;    // melyik számít szebbnek? van bármi különbség?
    };

    template <typename Fun>
    class callable : public callable_base
    {
    private:
        Fun _fun;
    public:
        callable(Fun fun):_fun(fun) {}

        virtual Ret call(Args... args) override
        { return _fun(std::forward<Args>(args)...); }

        virtual ~callable() override {}
    };

    std::unique_ptr _fun;

public:
    Function() {}

    template <typename Fun>
    Function& operator=(Fun fun)
    {
        _fun = std::make_unique<callable<Fun>>(fun);
        return *this;
    }

    Ret operator()(Args... args) const
    { return _fun->call(std::forward<Args>(args)...); }

    operator bool() const
    { return static_cast<bool>(_fun); }
};