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 FunctionErasedOperation
    {
        Destruct,
        CopyConstruct,
        MoveConstruct
    };
    using StubFunction      = R (*)(const void* const*, typename TypeTraits::AddPointer<Args>::type...);
    using OperationFunction = void (*)(FunctionErasedOperation operation, const void** other, const void* const*);
 
    static const int LAMBDA_SIZE = sizeof(void*) * 2;
 
    StubFunction      functionStub;
    OperationFunction functionOperation;
 
    union
    {
        const void* classInstance;
        char        lambdaMemory[LAMBDA_SIZE] = {0};
    };
 
    void executeOperation(FunctionErasedOperation operation, const void** other) const
    {
        if (functionOperation)
            (*functionOperation)(operation, other, &classInstance);
    }
 
    Function(const void* instance, StubFunction stub, OperationFunction operation)
        : functionStub(stub), functionOperation(operation)
    {
        classInstance = instance;
    }
    using FreeFunction = R (*)(Args...);
 
  public:
    Function()
    {
        static_assert(sizeof(Function) == sizeof(void*) * 4, "Function Size");
        functionStub      = nullptr;
        functionOperation = nullptr;
    }
 
    template <
        typename Lambda,
        typename = typename TypeTraits::EnableIf<
            not TypeTraits::IsSame<typename TypeTraits::RemoveReference<Lambda>::type, Function>::value, void>::type>
    Function(Lambda&& lambda)
    {
        functionStub      = nullptr;
        functionOperation = nullptr;
        bind(forward<typename TypeTraits::RemoveReference<Lambda>::type>(lambda));
    }
 
    ~Function() { executeOperation(FunctionErasedOperation::Destruct, nullptr); }
 
    Function(Function&& other)
    {
        functionStub      = other.functionStub;
        functionOperation = other.functionOperation;
        classInstance     = other.classInstance;
        other.executeOperation(FunctionErasedOperation::MoveConstruct, &classInstance);
        other.executeOperation(FunctionErasedOperation::Destruct, nullptr);
        other.functionStub      = nullptr;
        other.functionOperation = nullptr;
    }
 
    Function(const Function& other)
    {
        functionStub      = other.functionStub;
        functionOperation = other.functionOperation;
        other.executeOperation(FunctionErasedOperation::CopyConstruct, &classInstance);
    }
 
    Function& operator=(const Function& other)
    {
        executeOperation(FunctionErasedOperation::Destruct, nullptr);
        functionStub      = other.functionStub;
        functionOperation = other.functionOperation;
        other.executeOperation(FunctionErasedOperation::CopyConstruct, &classInstance);
        return *this;
    }
 
    Function& operator=(Function&& other) noexcept
    {
        executeOperation(FunctionErasedOperation::Destruct, nullptr);
        functionStub      = other.functionStub;
        functionOperation = other.functionOperation;
        other.executeOperation(FunctionErasedOperation::MoveConstruct, &classInstance);
        other.executeOperation(FunctionErasedOperation::Destruct, nullptr);
        other.functionStub = nullptr;
        return *this;
    }
 
    [[nodiscard]] bool isValid() const { return functionStub != nullptr; }
 
    [[nodiscard]] bool isBoundToClassInstance(void* instance) const { return classInstance == instance; }
 
    bool operator==(const Function& other) const
    {
        return functionStub == other.functionStub and functionOperation == other.functionOperation and
               classInstance == other.classInstance;
    }
    template <typename Lambda>
    void bind(Lambda&& lambda)
    {
        executeOperation(FunctionErasedOperation::Destruct, nullptr);
        functionStub      = nullptr;
        functionOperation = nullptr;
 
        new (&classInstance, PlacementNew()) Lambda(forward<Lambda>(lambda));
        static_assert(sizeof(Lambda) <= sizeof(lambdaMemory), "Lambda is too big");
        functionStub = [](const void* const* p, typename TypeTraits::AddPointer<Args>::type... args) -> R
        {
            Lambda& lambda = *reinterpret_cast<Lambda*>(const_cast<void**>(p));
            return lambda(*args...);
        };
        functionOperation = [](FunctionErasedOperation operation, const void** other, const void* const* p)
        {
            Lambda& lambda = *reinterpret_cast<Lambda*>(const_cast<void**>(p));
            if (operation == FunctionErasedOperation::Destruct)
                lambda.~Lambda();
            else if (operation == FunctionErasedOperation::CopyConstruct)
                new (other, PlacementNew()) Lambda(lambda);
            else if (operation == FunctionErasedOperation::MoveConstruct)
                new (other, PlacementNew()) Lambda(move(lambda));
            else
#if SC_COMPILER_MSVC
                __assume(false);
#else
                __builtin_unreachable();
#endif
        };
    }
 
    template <R (*FreeFunction)(Args...)>
    void bind()
    {
        executeOperation(FunctionErasedOperation::Destruct, nullptr);
        classInstance     = nullptr;
        functionStub      = &FunctionWrapper<FreeFunction>;
        functionOperation = &FunctionOperation;
    }
 
    template <typename Class, R (Class::*MemberFunction)(Args...) const>
    void bind(const Class& c)
    {
        executeOperation(FunctionErasedOperation::Destruct, nullptr);
        classInstance     = &c;
        functionStub      = &MemberWrapper<Class, MemberFunction>;
        functionOperation = &MemberOperation;
    }
 
    template <typename Class, R (Class::*MemberFunction)(Args...)>
    void bind(Class& c)
    {
        executeOperation(FunctionErasedOperation::Destruct, nullptr);
        classInstance     = &c;
        functionStub      = &MemberWrapper<Class, MemberFunction>;
        functionOperation = &MemberOperation;
    }
 
    template <typename Class, R (Class::*MemberFunction)(Args...)>
    static Function fromMember(Class& c)
    {
        return Function(&c, &MemberWrapper<Class, MemberFunction>, &MemberOperation);
    }
 
    template <typename Class, R (Class::*MemberFunction)(Args...) const>
    static Function fromMember(const Class& c)
    {
        return Function(&c, &MemberWrapper<Class, MemberFunction>, &MemberOperation);
    }
 
    [[nodiscard]] R operator()(Args... args) const { return (*functionStub)(&classInstance, &args...); }
 
  private:
    static void MemberOperation(FunctionErasedOperation operation, const void** other, const void* const* p)
    {
        if (operation == FunctionErasedOperation::CopyConstruct or operation == FunctionErasedOperation::MoveConstruct)
            *other = *p;
    }
 
    template <typename Class, R (Class::*MemberFunction)(Args...)>
    static R MemberWrapper(const void* const* p, typename TypeTraits::RemoveReference<Args>::type*... args)
    {
        Class* cls = const_cast<Class*>(static_cast<const Class*>(*p));
        return (cls->*MemberFunction)(*args...);
    }
 
    template <typename Class, R (Class::*MemberFunction)(Args...) const>
    static R MemberWrapper(const void* const* p, typename TypeTraits::RemoveReference<Args>::type*... args)
    {
        const Class* cls = static_cast<const Class*>(*p);
        return (cls->*MemberFunction)(*args...);
    }
 
    template <R (*FreeFunction)(Args...)>
    static R FunctionWrapper(const void* const* p, typename TypeTraits::RemoveReference<Args>::type*... args)
    {
        SC_COMPILER_UNUSED(p);
        return FreeFunction(*args...);
    }
    static void FunctionOperation(FunctionErasedOperation, const void**, const void* const*) {}
};
 
template <typename T>
using Delegate = Function<void(T)>;
using Action   = Function<void()>;
} // namespace SC