function.hpp

#ifndef SIPLASPLAS_TYPEERASURE_FUNCTION_HPP
#define SIPLASPLAS_TYPEERASURE_FUNCTION_HPP

#include "simpleany.hpp"
#include "anyarg.hpp"
#include "invoke.hpp"
#include "anystorage/deadpool.hpp"
#include "anystorage/fixedsize.hpp"
#include <siplasplas/utility/function_traits.hpp>
#include <siplasplas/utility/staticif.hpp>
#include <siplasplas/utility/compiles.hpp>
#include <siplasplas/utility/exception.hpp>

namespace cpp
{

namespace typeerasure
{

template<typename Storage, typename ArgsStorage = Storage, typename ReturnStorage = Storage>
class Function
{
public:
    Function() = default;

    template<typename Callable,
        typename = std::enable_if_t<!std::is_same<std::decay_t<Callable>, Function>::value>
    >
    Function(Callable&& callable) :
        _invoke{Invoke<std::decay_t<Callable>>{std::forward<Callable>(callable)}}
    {}

    bool empty() const
    {
        return _invoke.empty();
    }

    template<typename Callable, typename... Args>
    static Function<Storage> create(Args&&... args)
    {
        return Function<Storage>{meta::identity<Callable>(), std::forward<Args>(args)...};
    }

    template<typename... Args>
    SimpleAny<ReturnStorage> operator()(Args&&... args)
    {
        SIPLASPLAS_ASSERT_FALSE(empty());

        AnyArg argsArray[] = {std::forward<Args>(args)..., AnyArg(nullptr)};
        return _invoke.template get<InvokeInterface>().invoke(std::begin(argsArray));
    }

    template<typename... Args>
    SimpleAny<ReturnStorage> operator()(Args&&... args) const
    {
        SIPLASPLAS_ASSERT_FALSE(empty());

        AnyArg argsArray[] = {std::forward<Args>(args)..., AnyArg(nullptr)};
        return _invoke.template get<InvokeInterface>().invoke(std::begin(argsArray));
    }

    template<typename ArgsVector>
    SimpleAny<ReturnStorage> invoke(ArgsVector&& args)
    {
        SIPLASPLAS_ASSERT_FALSE(empty());

        return _invoke.template get<InvokeInterface>().invoke(std::forward<ArgsVector>(args));
    }

    template<typename ArgsVector>
    SimpleAny<ReturnStorage> invoke(ArgsVector&& args) const
    {
        SIPLASPLAS_ASSERT_FALSE(empty());

        return _invoke.template get<InvokeInterface>().invoke(std::forward<ArgsVector>(args));
    }

    SimpleAny<ReturnStorage> invoke(AnyArg* args)
    {
        SIPLASPLAS_ASSERT_FALSE(empty());

        return _invoke.template get<InvokeInterface>().invoke(args);
    }

    SimpleAny<ReturnStorage> invoke(AnyArg* args) const
    {
        SIPLASPLAS_ASSERT_FALSE(empty());

        return _invoke.template get<InvokeInterface>().invoke(args);
    }

    template<typename Callable>
    Function& operator=(Callable&& callable)
    {
        _invoke = Invoke<std::decay_t<Callable>>{std::forward<Callable>(callable)};
        return *this;
    }

    cpp::FunctionKind kind() const
    {
        return _invoke.template get<InvokeInterface>().kind();
    }

    template<typename T>
    const T& get() const
    {
        return _invoke.template get<InvokeInterface>().template get<T>();
    }

    template<typename T>
    T& get()
    {
        return _invoke.template get<InvokeInterface>().template get<T>();
    }

private:
    template<typename Callable, typename... Args>
    Function(meta::identity<Callable>, Args&&... args) :
        _invoke{Invoke<Callable>{std::forward<Args>(args)...}}
    {}

    class InvokeInterface
    {
    public:
        virtual ~InvokeInterface() = default;
        virtual SimpleAny<ReturnStorage> invoke(std::vector<AnyArg>&& args) = 0;
        virtual SimpleAny<ReturnStorage> invoke(std::vector<AnyArg>&& args) const = 0;
        virtual SimpleAny<ReturnStorage> invoke(std::vector<AnyArg>& args) = 0;
        virtual SimpleAny<ReturnStorage> invoke(std::vector<AnyArg>& args) const = 0;
        virtual SimpleAny<ReturnStorage> invoke(AnyArg* args) = 0;
        virtual SimpleAny<ReturnStorage> invoke(AnyArg* args) const = 0;
        virtual SimpleAny<ReturnStorage> invoke(std::vector<SimpleAny<ArgsStorage>>&& args) = 0;
        virtual SimpleAny<ReturnStorage> invoke(std::vector<SimpleAny<ArgsStorage>>&& args) const = 0;
        virtual SimpleAny<ReturnStorage> invoke(std::vector<SimpleAny<ArgsStorage>>& args) = 0;
        virtual SimpleAny<ReturnStorage> invoke(std::vector<SimpleAny<ArgsStorage>>& args) const = 0;
        virtual SimpleAny<ReturnStorage> invoke(SimpleAny<ArgsStorage>* args) = 0;
        virtual SimpleAny<ReturnStorage> invoke(SimpleAny<ArgsStorage>* args) const = 0;

        virtual void* getObject() = 0;
        virtual const void* getObject() const = 0;
        virtual cpp::FunctionKind kind() const = 0;
        virtual cpp::typeerasure::TypeInfo typeInfo() const = 0;

        template<typename T>
        const T& get() const
        {
            SIPLASPLAS_ASSERT(typeInfo() == cpp::typeerasure::TypeInfo::get<std::decay_t<T>>())(
                "Callable is of type {}, not {}",
                typeInfo().typeName(),
                ctti::type_id<std::decay_t<T>>().name()
            );

            return *reinterpret_cast<const T*>(getObject());
        }

        template<typename T>
        T& get()
        {
            SIPLASPLAS_ASSERT(typeInfo() == cpp::typeerasure::TypeInfo::get<std::decay_t<T>>())(
                "Callable is of type {}, not {}",
                typeInfo().typeName(),
                ctti::type_id<std::decay_t<T>>().name()
            );

            return *reinterpret_cast<T*>(getObject());
        }
    };

    template<typename Callable>
    class Invoke : public InvokeInterface
    {
    public:
        template<typename... Args>
        Invoke(Args&&... args) :
            _callable{std::forward<Args>(args)...}
        {}

        SimpleAny<ReturnStorage> invoke(std::vector<AnyArg>&& args) override
        {
            return doInvoke(std::move(args));
        }

        SimpleAny<ReturnStorage> invoke(std::vector<AnyArg>&& args) const override
        {
            return doInvoke(std::move(args));
        }

        SimpleAny<ReturnStorage> invoke(std::vector<AnyArg>& args) override
        {
            return doInvoke(args);
        }

        SimpleAny<ReturnStorage> invoke(std::vector<AnyArg>& args) const override
        {
            return doInvoke(args);
        }

        SimpleAny<ReturnStorage> invoke(AnyArg* args) override
        {
            return doInvoke(args);
        }

        SimpleAny<ReturnStorage> invoke(AnyArg* args) const override
        {
            return doInvoke(args);
        }

        SimpleAny<ReturnStorage> invoke(std::vector<SimpleAny<ArgsStorage>>&& args) override
        {
            return doInvoke(std::move(args));
        }

        SimpleAny<ReturnStorage> invoke(std::vector<SimpleAny<ArgsStorage>>&& args) const override
        {
            return doInvoke(std::move(args));
        }

        SimpleAny<ReturnStorage> invoke(std::vector<SimpleAny<ArgsStorage>>& args) override
        {
            return doInvoke(args);
        }

        SimpleAny<ReturnStorage> invoke(std::vector<SimpleAny<ArgsStorage>>& args) const override
        {
            return doInvoke(args);
        }

        SimpleAny<ReturnStorage> invoke(SimpleAny<ArgsStorage>* args) override
        {
            return doInvoke(args);
        }

        SimpleAny<ReturnStorage> invoke(SimpleAny<ArgsStorage>* args) const override
        {
            return doInvoke(args);
        }

        template<typename Args>
        SimpleAny<ReturnStorage> doInvoke(Args&& args)
        {
            return doInvoke(_callable, std::forward<Args>(args));
        }

        template<typename Args>
        SimpleAny<ReturnStorage> doInvoke(Args&& args) const
        {
            return doInvoke(_callable, std::forward<Args>(args));
        }

#define SIPLASPLAS_FUNCTION_INVOKE_EXPRESSION cpp::typeerasure::invoke(identity(std::forward<Callable_>(callable)), identity(std::forward<Args>(args)))

        template<typename Callable_, typename Args>
        static SimpleAny<ReturnStorage> doInvoke(Callable_&& callable, Args&& args)
        {
            return cpp::staticIf<!(cpp::function_kind<Callable>() == cpp::FunctionKind::MEMBER_FUNCTION && std::is_const<std::remove_reference_t<Args>>::value)>([&](auto identity) -> SimpleAny<ReturnStorage>
            {
                return cpp::staticIf<std::is_void<decltype(SIPLASPLAS_FUNCTION_INVOKE_EXPRESSION)>::value>([&](auto identity) -> SimpleAny<ReturnStorage>
                {
                    SIPLASPLAS_FUNCTION_INVOKE_EXPRESSION;
                    return cpp::SimpleAny<ReturnStorage>();
                }).Else([&](auto identity) -> SimpleAny<ReturnStorage>
                {
                    return SIPLASPLAS_FUNCTION_INVOKE_EXPRESSION;
                });
            })
            .Else([](auto) -> SimpleAny<ReturnStorage>
            {
                throw cpp::exception<std::runtime_error>(
                    "Cannot invoke a non-const member function with a const vector of arguments"
                );
            });

        }

#undef SIPLASPLAS_FUNCTION_INVOKE_EXPRESSION

        void* getObject() override
        {
            return &_callable;
        }

        const void* getObject() const override
        {
            return &_callable;
        }

        cpp::FunctionKind kind() const override
        {
            return cpp::function_kind<Callable>();
        }

        cpp::typeerasure::TypeInfo typeInfo() const override
        {
            return cpp::typeerasure::TypeInfo::get<Callable>();
        }

    private:
        Callable _callable;
    };

    SimpleAny32 _invoke;
};


using Function8  = Function<DeadPoolStorage<8>>;

using Function16 = Function<DeadPoolStorage<16>>;

using Function32 = Function<DeadPoolStorage<32>>;

using Function64 = Function<DeadPoolStorage<64>>;

}

}
#endif // SIPLASPLAS_TYPEERASURE_FUNCTION_HPP