Function.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Foundation/TypeTraits.h" // RemoveReference, AddPointer, IsSame
 
namespace SC
{
 
template <typename FuncType>
struct Function;
 
template <typename R, typename... Args>
struct Function<R(Args...)>
{
  private:
    enum class Operation
    {
        Destruct,
        CopyConstruct,
        MoveConstruct
    };
    using ExecuteFunction   = R (*)(const void* const*, typename TypeTraits::AddPointer<Args>::type...);
    using OperationFunction = void (*)(Operation operation, const void** other, const void* const*);
 
    struct VTable
    {
        ExecuteFunction   execute;
        OperationFunction operation;
    };
 
    static const int LAMBDA_SIZE = sizeof(void*) * 2;
 
    const VTable* vtable;
 
    union
    {
        const void* classInstance;
        char        lambdaMemory[LAMBDA_SIZE] = {0};
    };
 
    void checkedOperation(Operation operation, const void** other) const
    {
        if (vtable)
            vtable->operation(operation, other, &classInstance);
    }
 
  public:
    Function()
    {
        static_assert(sizeof(Function) == sizeof(void*) * 3, "Function Size");
        vtable = nullptr;
    }
 
    template <
        typename Lambda,
        typename = typename TypeTraits::EnableIf<
            not TypeTraits::IsSame<typename TypeTraits::RemoveReference<Lambda>::type, Function>::value, void>::type>
    Function(Lambda&& lambda)
    {
        vtable = nullptr;
        bind(forward<typename TypeTraits::RemoveReference<Lambda>::type>(lambda));
    }
 
    ~Function() { checkedOperation(Operation::Destruct, nullptr); }
 
    Function(Function&& other)
    {
        vtable        = other.vtable;
        classInstance = other.classInstance;
        other.checkedOperation(Operation::MoveConstruct, &classInstance);
        other.checkedOperation(Operation::Destruct, nullptr);
        other.vtable = nullptr;
    }
 
    Function(const Function& other)
    {
        vtable = other.vtable;
        other.checkedOperation(Operation::CopyConstruct, &classInstance);
    }
 
    Function& operator=(const Function& other)
    {
        checkedOperation(Operation::Destruct, nullptr);
        vtable = other.vtable;
        other.checkedOperation(Operation::CopyConstruct, &classInstance);
        return *this;
    }
 
    Function& operator=(Function&& other) noexcept
    {
        checkedOperation(Operation::Destruct, nullptr);
        vtable = other.vtable;
        other.checkedOperation(Operation::MoveConstruct, &classInstance);
        other.checkedOperation(Operation::Destruct, nullptr);
        other.vtable = nullptr;
        return *this;
    }
 
    [[nodiscard]] bool isValid() const { return vtable != nullptr; }
 
    [[nodiscard]] bool isBoundToClassInstance(void* instance) const { return classInstance == instance; }
 
    bool operator==(const Function& other) const
    {
        return vtable == other.vtable and classInstance == other.classInstance;
    }
 
    template <typename Lambda>
    void bind(Lambda&& lambda)
    {
        checkedOperation(Operation::Destruct, nullptr);
        vtable = nullptr;
        new (&classInstance, PlacementNew()) Lambda(forward<Lambda>(lambda));
        vtable = getVTableForLambda<Lambda>();
    }
 
  private:
    template <typename Lambda>
    static auto getVTableForLambda()
    {
        static_assert(sizeof(Lambda) <= sizeof(lambdaMemory), "Lambda is too big");
        static SC_LANGUAGE_IF_CONSTEXPR const VTable staticVTable = {
            [](const void* const* p, typename TypeTraits::AddPointer<Args>::type... args) SC_LANGUAGE_IF_CONSTEXPR
            {
                Lambda& lambda = *reinterpret_cast<Lambda*>(const_cast<void**>(p));
                return lambda(*args...);
            },
            [](Operation operation, const void** other, const void* const* p) SC_LANGUAGE_IF_CONSTEXPR
            {
                Lambda& lambda = *reinterpret_cast<Lambda*>(const_cast<void**>(p));
                if (operation == Operation::Destruct)
                    lambda.~Lambda();
                else if (operation == Operation::CopyConstruct)
                    new (other, PlacementNew()) Lambda(lambda);
                else if (operation == Operation::MoveConstruct)
                    new (other, PlacementNew()) Lambda(move(lambda));
            }};
        return &staticVTable;
    }
 
  public:
    template <typename Lambda>
    Lambda* dynamicCastTo() const
    {
        if (getVTableForLambda<Lambda>() != vtable)
            return nullptr;
        else
            return &const_cast<Lambda&>(reinterpret_cast<const Lambda&>(classInstance));
    }
 
    template <R (*FreeFunction)(Args...)>
    void bind()
    {
        checkedOperation(Operation::Destruct, nullptr);
        static SC_LANGUAGE_IF_CONSTEXPR const VTable staticVTable = {
            [](const void* const*, typename TypeTraits::RemoveReference<Args>::type*... args) SC_LANGUAGE_IF_CONSTEXPR
            { return FreeFunction(*args...); },
            [](Operation, const void**, const void* const*) SC_LANGUAGE_IF_CONSTEXPR {}};
        vtable        = &staticVTable;
        classInstance = nullptr;
    }
 
    template <typename Class, R (Class::*MemberFunction)(Args...) const>
    void bind(const Class& c)
    {
        checkedOperation(Operation::Destruct, nullptr);
        static SC_LANGUAGE_IF_CONSTEXPR const VTable staticVTable = {
            [](const void* const* p, typename TypeTraits::RemoveReference<Args>::type*... args) SC_LANGUAGE_IF_CONSTEXPR
            {
                const Class* cls = static_cast<const Class*>(*p);
                return (cls->*MemberFunction)(*args...);
            },
            [](Operation operation, const void** other, const void* const* p) SC_LANGUAGE_IF_CONSTEXPR
            {
                if (operation != Operation::Destruct)
                    *other = *p;
            }};
        vtable        = &staticVTable;
        classInstance = &c;
    }
 
    template <typename Class, R (Class::*MemberFunction)(Args...)>
    void bind(Class& c)
    {
        checkedOperation(Operation::Destruct, nullptr);
        static SC_LANGUAGE_IF_CONSTEXPR const VTable staticVTable = {
            [](const void* const* p, typename TypeTraits::RemoveReference<Args>::type*... args) SC_LANGUAGE_IF_CONSTEXPR
            {
                Class* cls = const_cast<Class*>(static_cast<const Class*>(*p));
                return (cls->*MemberFunction)(*args...);
            },
            [](Operation operation, const void** other, const void* const* p) SC_LANGUAGE_IF_CONSTEXPR
            {
                if (operation != Operation::Destruct)
                    *other = *p;
            }};
        vtable        = &staticVTable;
        classInstance = &c;
    }
 
    [[nodiscard]] R operator()(Args... args) const { return vtable->execute(&classInstance, &args...); }
};
 
template <typename T>
using Delegate = Function<void(T)>;
using Action   = Function<void()>;
} // namespace SC