Dynamic call, C++ (clang)

Dynamic call

#include <iostream>
#include <utility>
#include <memory>

struct Arguments;
struct BaseCallable;

struct BaseCallable
{
    virtual void call(Arguments const &) const = 0;
};

template <typename ...Args>
struct FixedArguments;
template <typename F>
struct Callable;

struct Arguments
{
    virtual void expand(BaseCallable const & ) const = 0;

template <typename R, typename ...Args>
    void expand(Callable<R(Args...)> const & f) const
    {
        /*
            Вместо dynamic_cast здесь лучше использовать свою проверку типа
            this->check_sig<R(Args...)>();
            Но ее реализация становится слишком многословной, поэтому тут я сделал по-простому.
        */
        if(auto const * rargs = dynamic_cast<FixedArguments<Args...> const *>(this))
        {
            rargs->expand(f);
        }
        else
        {
            std::cout << "[Warning] " << expand_call<R(Args...)>() << " not resolved!";
        }
    }

private:
    template <typename F>
    static char const * expand_call()
    {
        return __PRETTY_FUNCTION__;
    }
};

template <typename F>
class Callable
    : public BaseCallable
{
public:
    explicit Callable(F && f)
        : m_callable{f}
    { }
    template <typename ...Args>
    void call(Args && ...args) const
    {
        m_callable(std::forward<Args>(args)...);
    }
    void call(Arguments const & args) const
    {
        args.expand(*this);
    }

private:
    F * m_callable;
};

template <typename ...Args>
class FixedArguments
    : public Arguments
{
public:
    FixedArguments(Args && ...args)
        : m_args{std::forward<Args>(args)...}
    { }

template <typename F>
    void expand(Callable<F> const & f) const
    {
        call(f, std::make_index_sequence<sizeof...(Args)>{});
    }
private:
    void expand(BaseCallable const & f) const
    {
        f.call(*this);
    }
    template <typename F, size_t ...I>
    void call(Callable<F> const & f, std::index_sequence<I...>) const
    {
        f.call(std::get<I>(m_args)...);
    }

private:
    std::tuple<Args...> m_args;
};

//==============================================================================
class Base
{
protected:
    virtual void run_function(Arguments const & args) const = 0;

public:
    template <typename ...Args>
    void run(Args && ...args)
    {
        run_function(FixedArguments<Args...>{std::forward<Args>(args)...});
    }
};

class Test
    : public Base
{
public:
    typedef void function_t(int v, char c);

explicit Test(function_t & f)
        : m_func(f)
    { }

private:
    void run_function(Arguments const & args) const
    {
        return m_func.call(args);
    }

private:
    Callable<function_t> m_func;
};

void func(int v, char c)
{
    std::cout << v << " " << c << std::endl;
}

int main()
{
    std::shared_ptr<Base> f = std::make_shared<Test>(func);

f->run(1, '2');
}


run \| edit \| history \| help	0