2022-04-07 07:57:02 +00:00
|
|
|
#pragma once
|
|
|
|
|
|
|
|
#include "CoreTypes.h"
|
|
|
|
#include "Memory/Memory.h"
|
2022-04-08 03:44:36 +00:00
|
|
|
#include "Concepts/Same.h"
|
2022-04-07 07:57:02 +00:00
|
|
|
#include "Templates/Any.h"
|
|
|
|
#include "Templates/Tuple.h"
|
|
|
|
#include "Templates/Invoke.h"
|
2022-04-08 03:44:36 +00:00
|
|
|
#include "Templates/Utility.h"
|
2022-04-07 07:57:02 +00:00
|
|
|
#include "Templates/Container.h"
|
2022-04-08 03:44:36 +00:00
|
|
|
#include "Concepts/Comparable.h"
|
|
|
|
#include "Concepts/Convertible.h"
|
2022-04-07 07:57:02 +00:00
|
|
|
#include "TypeTraits/TypeTraits.h"
|
|
|
|
#include "Miscellaneous/TypeInfo.h"
|
2022-04-08 03:44:36 +00:00
|
|
|
#include "Concepts/BooleanTestable.h"
|
2022-04-07 07:57:02 +00:00
|
|
|
#include "Miscellaneous/AssertionMacros.h"
|
|
|
|
|
|
|
|
NAMESPACE_REDCRAFT_BEGIN
|
|
|
|
NAMESPACE_MODULE_BEGIN(Redcraft)
|
|
|
|
NAMESPACE_MODULE_BEGIN(Utility)
|
|
|
|
|
|
|
|
NAMESPACE_PRIVATE_BEGIN
|
|
|
|
|
|
|
|
enum class EFunctionType
|
|
|
|
{
|
|
|
|
Reference,
|
|
|
|
Object,
|
|
|
|
Unique,
|
|
|
|
};
|
|
|
|
|
|
|
|
enum class EFunctionSpecifiers
|
|
|
|
{
|
|
|
|
None,
|
|
|
|
LValue,
|
|
|
|
RValue,
|
|
|
|
Const,
|
|
|
|
ConstLValue,
|
|
|
|
ConstRValue,
|
|
|
|
};
|
|
|
|
|
|
|
|
template <typename F, size_t InlineSize, size_t InlineAlignment, EFunctionSpecifiers Specifiers, EFunctionType FunctionType>
|
|
|
|
struct TFunctionImpl;
|
|
|
|
|
|
|
|
template <typename T> struct TIsTFunctionImpl : FFalse { };
|
|
|
|
template <typename F, size_t I, size_t J, EFunctionSpecifiers S, EFunctionType E> struct TIsTFunctionImpl<TFunctionImpl<F, I, J, S, E>> : FTrue { };
|
|
|
|
|
|
|
|
template <typename T> struct TIsTFunctionRef : FFalse { };
|
|
|
|
template <typename F, size_t I, size_t J, EFunctionSpecifiers S> struct TIsTFunctionRef<TFunctionImpl<F, I, J, S, EFunctionType::Reference>> : FTrue { };
|
|
|
|
|
|
|
|
template <typename T> struct TIsTFunction : FFalse { };
|
|
|
|
template <typename F, size_t I, size_t J, EFunctionSpecifiers S> struct TIsTFunction<TFunctionImpl<F, I, J, S, EFunctionType::Object>> : FTrue { };
|
|
|
|
|
|
|
|
template <typename T> struct TIsTUniqueFunction : FFalse { };
|
|
|
|
template <typename F, size_t I, size_t J, EFunctionSpecifiers S> struct TIsTUniqueFunction<TFunctionImpl<F, I, J, S, EFunctionType::Unique>> : FTrue { };
|
|
|
|
|
|
|
|
struct FFunctionIsBoundImpl
|
|
|
|
{
|
|
|
|
template <typename T>
|
|
|
|
static constexpr bool F(const T& Func)
|
|
|
|
{
|
|
|
|
if constexpr (TIsPointer<T>::Value || TIsMemberPointer<T>::Value || TIsTFunctionImpl<T>::Value)
|
|
|
|
{
|
|
|
|
return !!Func;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template <EFunctionSpecifiers Specifiers, typename R, typename F, typename... Types>
|
|
|
|
struct TIsInvocableResultWithSpecifiers : FFalse { };
|
|
|
|
|
|
|
|
template <typename R, typename F, typename... Types>
|
|
|
|
struct TIsInvocableResultWithSpecifiers<EFunctionSpecifiers::None, R, F, Types...>
|
|
|
|
: TBoolConstant<TIsInvocableResult<R, F, Types...>::Value && TIsInvocableResult<R, F&, Types...>::Value>
|
|
|
|
{ };
|
|
|
|
|
|
|
|
template <typename R, typename F, typename... Types>
|
|
|
|
struct TIsInvocableResultWithSpecifiers<EFunctionSpecifiers::LValue, R, F, Types...> : TIsInvocableResult<R, F&, Types...> { };
|
|
|
|
|
|
|
|
template <typename R, typename F, typename... Types>
|
|
|
|
struct TIsInvocableResultWithSpecifiers<EFunctionSpecifiers::RValue, R, F, Types...> : TIsInvocableResult<R, F, Types...> { };
|
|
|
|
|
|
|
|
template <typename R, typename F, typename... Types>
|
|
|
|
struct TIsInvocableResultWithSpecifiers<EFunctionSpecifiers::Const, R, F, Types...>
|
|
|
|
: TBoolConstant<TIsInvocableResult<R, const F, Types...>::Value && TIsInvocableResult<R, const F&, Types...>::Value>
|
|
|
|
{ };
|
|
|
|
|
|
|
|
template <typename R, typename F, typename... Types>
|
|
|
|
struct TIsInvocableResultWithSpecifiers<EFunctionSpecifiers::ConstLValue, R, F, Types...> : TIsInvocableResult<R, const F&, Types...> { };
|
|
|
|
|
|
|
|
template <typename R, typename F, typename... Types>
|
|
|
|
struct TIsInvocableResultWithSpecifiers<EFunctionSpecifiers::ConstRValue, R, F, Types...> : TIsInvocableResult<R, const F, Types...> { };
|
|
|
|
|
|
|
|
template <EFunctionSpecifiers Specifiers, typename T, typename F>
|
|
|
|
struct TFunctionCallImpl;
|
|
|
|
|
|
|
|
template <typename T, typename R, typename... Types>
|
|
|
|
struct TFunctionCallImpl<EFunctionSpecifiers::None, T, R(Types...)>
|
|
|
|
{
|
|
|
|
static inline R F(void* Func, Types&&... Args)
|
|
|
|
{
|
|
|
|
return InvokeResult<R>(*reinterpret_cast<T*>(Func), Forward<Types>(Args)...);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template <typename T, typename R, typename... Types>
|
|
|
|
struct TFunctionCallImpl<EFunctionSpecifiers::LValue, T, R(Types...)>
|
|
|
|
{
|
|
|
|
static inline R F(void* Func, Types&&... Args)
|
|
|
|
{
|
|
|
|
return InvokeResult<R>(*reinterpret_cast<T*>(Func), Forward<Types>(Args)...);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template <typename T, typename R, typename... Types>
|
|
|
|
struct TFunctionCallImpl<EFunctionSpecifiers::RValue, T, R(Types...)>
|
|
|
|
{
|
|
|
|
static inline R F(void* Func, Types&&... Args)
|
|
|
|
{
|
|
|
|
return InvokeResult<R>(MoveTemp(*reinterpret_cast<T*>(Func)), Forward<Types>(Args)...);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template <typename T, typename R, typename... Types>
|
|
|
|
struct TFunctionCallImpl<EFunctionSpecifiers::Const, T, R(Types...)>
|
|
|
|
{
|
|
|
|
static inline R F(void* Func, Types&&... Args)
|
|
|
|
{
|
|
|
|
return InvokeResult<R>(AsConst(*reinterpret_cast<T*>(Func)), Forward<Types>(Args)...);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template <typename T, typename R, typename... Types>
|
|
|
|
struct TFunctionCallImpl<EFunctionSpecifiers::ConstLValue, T, R(Types...)>
|
|
|
|
{
|
|
|
|
static inline R F(void* Func, Types&&... Args)
|
|
|
|
{
|
|
|
|
return InvokeResult<R>(AsConst(*reinterpret_cast<T*>(Func)), Forward<Types>(Args)...);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template <typename T, typename R, typename... Types>
|
|
|
|
struct TFunctionCallImpl<EFunctionSpecifiers::ConstRValue, T, R(Types...)>
|
|
|
|
{
|
|
|
|
static inline R F(void* Func, Types&&... Args)
|
|
|
|
{
|
|
|
|
return InvokeResult<R>(MoveTemp(AsConst(*reinterpret_cast<T*>(Func))), Forward<Types>(Args)...);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template <typename R, typename... Types, size_t InlineSize, size_t InlineAlignment, EFunctionSpecifiers Specifiers, EFunctionType FunctionType>
|
|
|
|
struct TFunctionImpl<R(Types...), InlineSize, InlineAlignment, Specifiers, FunctionType>
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
|
|
|
|
using ResultType = R;
|
|
|
|
using ArgumentType = TTuple<Types...>;
|
|
|
|
|
|
|
|
constexpr TFunctionImpl(nullptr_t = nullptr) requires (FunctionType != EFunctionType::Reference) : Call(nullptr) { }
|
|
|
|
|
|
|
|
TFunctionImpl(const TFunctionImpl& InValue) requires (FunctionType != EFunctionType::Unique)
|
|
|
|
: Call(InValue.Call), Storage(InValue.Storage)
|
|
|
|
{ }
|
|
|
|
|
|
|
|
TFunctionImpl(TFunctionImpl&& InValue)
|
|
|
|
: Call(InValue.Call), Storage(MoveTemp(InValue.Storage))
|
|
|
|
{ if constexpr (FunctionType != EFunctionType::Reference) InValue.Reset(); }
|
|
|
|
|
|
|
|
template <typename T> requires (!TIsTFunctionImpl<typename TDecay<T>::Type>::Value) && (!TIsTInPlaceType<typename TDecay<T>::Type>::Value)
|
|
|
|
&& TIsInvocableResultWithSpecifiers<Specifiers, ResultType, typename TDecay<T>::Type, Types...>::Value
|
|
|
|
&& (FunctionType == EFunctionType::Reference || TIsConstructible<typename TDecay<T>::Type, T&&>::Value)
|
|
|
|
&& ((FunctionType == EFunctionType::Object && TIsCopyConstructible<typename TDecay<T>::Type>::Value)
|
|
|
|
|| (FunctionType == EFunctionType::Unique && TIsMoveConstructible<typename TDecay<T>::Type>::Value)
|
|
|
|
|| FunctionType == EFunctionType::Reference)
|
|
|
|
FORCEINLINE TFunctionImpl(T&& InValue)
|
|
|
|
{
|
|
|
|
using DecayedFunctorType = typename TDecay<T>::Type;
|
|
|
|
|
|
|
|
if constexpr (FunctionType == EFunctionType::Reference)
|
|
|
|
{
|
|
|
|
checkf(FFunctionIsBoundImpl::F(InValue), TEXT("Cannot bind a null/unbound callable to a TFunctionRef"));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!FFunctionIsBoundImpl::F(InValue)) Call = nullptr;
|
|
|
|
else EmplaceImpl<DecayedFunctorType>(Forward<T>(InValue));
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T, typename... ArgTypes> requires (FunctionType != EFunctionType::Reference)
|
|
|
|
&& TIsInvocableResultWithSpecifiers<Specifiers, ResultType, typename TDecay<T>::Type, Types...>::Value && TIsConstructible<typename TDecay<T>::Type, ArgTypes...>::Value
|
|
|
|
&& ((FunctionType == EFunctionType::Object && TIsCopyConstructible<typename TDecay<T>::Type>::Value)
|
|
|
|
|| (FunctionType == EFunctionType::Unique && TIsMoveConstructible<typename TDecay<T>::Type>::Value))
|
|
|
|
FORCEINLINE TFunctionImpl(TInPlaceType<T>, ArgTypes&&... Args)
|
|
|
|
{
|
|
|
|
using DecayedFunctorType = typename TDecay<T>::Type;
|
|
|
|
EmplaceImpl<DecayedFunctorType>(Forward<ArgTypes>(Args)...);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <size_t OtherInlineSize, size_t OtherInlineAlignment, EFunctionType OtherFunctionType>
|
|
|
|
requires (FunctionType == EFunctionType::Reference) && (OtherFunctionType != EFunctionType::Reference)
|
|
|
|
FORCEINLINE TFunctionImpl(const TFunctionImpl<R(Types...), OtherInlineSize, OtherInlineAlignment, Specifiers, OtherFunctionType>& InValue)
|
|
|
|
{
|
|
|
|
checkf(FFunctionIsBoundImpl::F(InValue), TEXT("Cannot bind a null/unbound callable to a TFunctionRef"));
|
|
|
|
EmplaceImpl<TFunctionImpl<R(Types...), OtherInlineSize, OtherInlineAlignment, Specifiers, OtherFunctionType>>(InValue);
|
|
|
|
}
|
|
|
|
|
|
|
|
FORCEINLINE TFunctionImpl(const TFunctionImpl<R(Types...), InlineSize, InlineAlignment, Specifiers, EFunctionType::Object>& InValue) requires (FunctionType == EFunctionType::Unique)
|
|
|
|
: Call((*reinterpret_cast<const TFunctionImpl*>(&InValue)).Call), Storage((*reinterpret_cast<const TFunctionImpl*>(&InValue)).Storage)
|
|
|
|
{ }
|
|
|
|
|
|
|
|
FORCEINLINE TFunctionImpl(TFunctionImpl<R(Types...), InlineSize, InlineAlignment, Specifiers, EFunctionType::Object>&& InValue) requires (FunctionType == EFunctionType::Unique)
|
|
|
|
: Call((*reinterpret_cast<TFunctionImpl*>(&InValue)).Call), Storage(MoveTemp((*reinterpret_cast<TFunctionImpl*>(&InValue)).Storage))
|
|
|
|
{ InValue.Reset(); }
|
|
|
|
|
|
|
|
~TFunctionImpl() = default;
|
|
|
|
|
|
|
|
FORCEINLINE TFunctionImpl& operator=(const TFunctionImpl& InValue) requires (FunctionType == EFunctionType::Object)
|
|
|
|
{
|
|
|
|
AssignImpl(InValue);
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
FORCEINLINE TFunctionImpl& operator=(TFunctionImpl&& InValue) requires (FunctionType != EFunctionType::Reference)
|
|
|
|
{
|
|
|
|
if (&InValue == this) return *this;
|
|
|
|
AssignImpl(MoveTemp(InValue));
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
FORCEINLINE TFunctionImpl& operator=(const TFunctionImpl<R(Types...), InlineSize, InlineAlignment, Specifiers, EFunctionType::Object>& InValue) requires (FunctionType == EFunctionType::Unique)
|
|
|
|
{
|
|
|
|
AssignImpl(*reinterpret_cast<const TFunctionImpl*>(&InValue));
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
FORCEINLINE TFunctionImpl& operator=(TFunctionImpl<R(Types...), InlineSize, InlineAlignment, Specifiers, EFunctionType::Object>&& InValue) requires (FunctionType == EFunctionType::Unique)
|
|
|
|
{
|
|
|
|
AssignImpl(MoveTemp(*reinterpret_cast<TFunctionImpl*>(&InValue)));
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
constexpr TFunctionImpl& operator=(nullptr_t) requires (FunctionType != EFunctionType::Reference) { Reset(); return *this; }
|
|
|
|
|
|
|
|
template <typename T> requires (FunctionType != EFunctionType::Reference) && (!TIsTFunctionImpl<typename TDecay<T>::Type>::Value)
|
|
|
|
&& TIsInvocableResultWithSpecifiers<Specifiers, ResultType, typename TDecay<T>::Type, Types...>::Value
|
|
|
|
&& TIsConstructible<typename TDecay<T>::Type, T&&>::Value
|
|
|
|
&& ((FunctionType == EFunctionType::Object && TIsCopyConstructible<typename TDecay<T>::Type>::Value)
|
|
|
|
|| (FunctionType == EFunctionType::Unique && TIsMoveConstructible<typename TDecay<T>::Type>::Value))
|
|
|
|
FORCEINLINE TFunctionImpl& operator=(T&& InValue)
|
|
|
|
{
|
|
|
|
using DecayedFunctorType = typename TDecay<T>::Type;
|
|
|
|
|
|
|
|
if (!FFunctionIsBoundImpl::F(InValue)) Reset();
|
|
|
|
else EmplaceImpl<DecayedFunctorType>(Forward<T>(InValue));
|
|
|
|
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T, typename... ArgTypes> requires (FunctionType != EFunctionType::Reference)
|
|
|
|
&& TIsInvocableResultWithSpecifiers<Specifiers, ResultType, typename TDecay<T>::Type, Types...>::Value
|
|
|
|
&& TIsConstructible<typename TDecay<T>::Type, ArgTypes...>::Value
|
|
|
|
&& ((FunctionType == EFunctionType::Object && TIsCopyConstructible<typename TDecay<T>::Type>::Value)
|
|
|
|
|| (FunctionType == EFunctionType::Unique && TIsMoveConstructible<typename TDecay<T>::Type>::Value))
|
|
|
|
FORCEINLINE typename TDecay<T>::Type& Emplace(ArgTypes&&... Args)
|
|
|
|
{
|
|
|
|
using DecayedFunctorType = typename TDecay<T>::Type;
|
|
|
|
EmplaceImpl<DecayedFunctorType>(Forward<ArgTypes>(Args)...);
|
2022-04-08 08:52:17 +00:00
|
|
|
return Target<DecayedFunctorType>();
|
2022-04-07 07:57:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
FORCEINLINE ResultType operator()(Types... Args) requires (Specifiers == EFunctionSpecifiers::None ) { return CallImpl(Forward<Types>(Args)...); }
|
|
|
|
FORCEINLINE ResultType operator()(Types... Args) & requires (Specifiers == EFunctionSpecifiers::LValue ) { return CallImpl(Forward<Types>(Args)...); }
|
|
|
|
FORCEINLINE ResultType operator()(Types... Args) && requires (Specifiers == EFunctionSpecifiers::RValue ) { return CallImpl(Forward<Types>(Args)...); }
|
|
|
|
FORCEINLINE ResultType operator()(Types... Args) const requires (Specifiers == EFunctionSpecifiers::Const ) { return CallImpl(Forward<Types>(Args)...); }
|
|
|
|
FORCEINLINE ResultType operator()(Types... Args) const& requires (Specifiers == EFunctionSpecifiers::ConstLValue) { return CallImpl(Forward<Types>(Args)...); }
|
|
|
|
FORCEINLINE ResultType operator()(Types... Args) const&& requires (Specifiers == EFunctionSpecifiers::ConstRValue) { return CallImpl(Forward<Types>(Args)...); }
|
|
|
|
|
|
|
|
constexpr bool IsValid() const { return Call != nullptr; }
|
|
|
|
constexpr explicit operator bool() const { return Call != nullptr; }
|
|
|
|
|
2022-04-08 08:52:17 +00:00
|
|
|
FORCEINLINE void* GetData() { if constexpr (FunctionType != EFunctionType::Reference) return Storage.GetData(); else return Storage; }
|
|
|
|
FORCEINLINE const void* GetData() const { if constexpr (FunctionType != EFunctionType::Reference) return Storage.GetData(); else return Storage; }
|
|
|
|
|
2022-04-07 07:57:02 +00:00
|
|
|
FORCEINLINE const FTypeInfo& TargetType() const requires (FunctionType != EFunctionType::Reference) { return IsValid() ? Storage.GetTypeInfo() : Typeid(void); };
|
|
|
|
|
2022-04-08 08:52:17 +00:00
|
|
|
template <typename T> FORCEINLINE T& Target() & requires (FunctionType != EFunctionType::Reference) && TIsSame<T, typename TDecay<T>::Type>::Value && TIsObject<typename TDecay<T>::Type>::Value && (!TIsArray<typename TDecay<T>::Type>::Value) && TIsDestructible<typename TDecay<T>::Type>::Value { return static_cast< StorageType& >(Storage).template GetValue<T>(); }
|
|
|
|
template <typename T> FORCEINLINE T&& Target() && requires (FunctionType != EFunctionType::Reference) && TIsSame<T, typename TDecay<T>::Type>::Value && TIsObject<typename TDecay<T>::Type>::Value && (!TIsArray<typename TDecay<T>::Type>::Value) && TIsDestructible<typename TDecay<T>::Type>::Value { return static_cast< StorageType&&>(Storage).template GetValue<T>(); }
|
|
|
|
template <typename T> FORCEINLINE const T& Target() const& requires (FunctionType != EFunctionType::Reference) && TIsSame<T, typename TDecay<T>::Type>::Value && TIsObject<typename TDecay<T>::Type>::Value && (!TIsArray<typename TDecay<T>::Type>::Value) && TIsDestructible<typename TDecay<T>::Type>::Value { return static_cast<const StorageType& >(Storage).template GetValue<T>(); }
|
|
|
|
template <typename T> FORCEINLINE const T&& Target() const&& requires (FunctionType != EFunctionType::Reference) && TIsSame<T, typename TDecay<T>::Type>::Value && TIsObject<typename TDecay<T>::Type>::Value && (!TIsArray<typename TDecay<T>::Type>::Value) && TIsDestructible<typename TDecay<T>::Type>::Value { return static_cast<const StorageType&&>(Storage).template GetValue<T>(); }
|
2022-04-07 07:57:02 +00:00
|
|
|
|
|
|
|
constexpr void Reset() requires (FunctionType != EFunctionType::Reference) { Call = nullptr; }
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
|
|
|
using CallFunc = ResultType(*)(void*, Types&&...);
|
|
|
|
using StorageType = typename TConditional<FunctionType == EFunctionType::Reference, void*, TAny<InlineSize, InlineAlignment>>::Type;
|
|
|
|
|
|
|
|
CallFunc Call;
|
|
|
|
StorageType Storage;
|
|
|
|
|
|
|
|
template <typename SelectedType, typename... ArgTypes>
|
|
|
|
FORCEINLINE void EmplaceImpl(ArgTypes&&... Args)
|
|
|
|
{
|
|
|
|
if constexpr (FunctionType == EFunctionType::Reference) Storage = ((void*)&Args, ...);
|
|
|
|
else Storage.template Emplace<SelectedType>(Forward<ArgTypes>(Args)...);
|
|
|
|
Call = &TFunctionCallImpl<Specifiers, SelectedType, ResultType(Types...)>::F;
|
|
|
|
}
|
|
|
|
|
|
|
|
FORCEINLINE ResultType CallImpl(Types&&... Args) const
|
|
|
|
{
|
|
|
|
checkf(IsValid(), TEXT("Attempting to call an unbound TFunction!"));
|
2022-04-08 08:52:17 +00:00
|
|
|
return Call(const_cast<TFunctionImpl&>(*this).GetData(), Forward<Types>(Args)...);
|
2022-04-07 07:57:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
FORCEINLINE void AssignImpl(const TFunctionImpl& InValue)
|
|
|
|
{
|
|
|
|
if (InValue.IsValid())
|
|
|
|
{
|
|
|
|
Call = InValue.Call;
|
|
|
|
Storage = InValue.Storage;
|
|
|
|
}
|
|
|
|
else Reset();
|
|
|
|
}
|
|
|
|
|
|
|
|
FORCEINLINE void AssignImpl(TFunctionImpl&& InValue)
|
|
|
|
{
|
|
|
|
if (InValue.IsValid())
|
|
|
|
{
|
|
|
|
Call = InValue.Call;
|
|
|
|
Storage = MoveTemp(InValue.Storage);
|
|
|
|
InValue.Reset();
|
|
|
|
}
|
|
|
|
else Reset();
|
|
|
|
}
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
template <typename F, size_t InlineSize, size_t InlineAlignment, EFunctionType FunctionType>
|
|
|
|
struct TFunctionSelect;
|
|
|
|
|
|
|
|
template <typename R, typename... Types, size_t InlineSize, size_t InlineAlignment, EFunctionType FunctionType>
|
|
|
|
struct TFunctionSelect<R(Types...) , InlineSize, InlineAlignment, FunctionType>
|
|
|
|
{
|
2022-04-08 08:52:17 +00:00
|
|
|
using Type = TFunctionImpl<R(Types...), InlineSize, InlineAlignment, EFunctionSpecifiers::None, FunctionType>;
|
2022-04-07 07:57:02 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
template <typename R, typename... Types, size_t InlineSize, size_t InlineAlignment, EFunctionType FunctionType>
|
|
|
|
struct TFunctionSelect<R(Types...) & , InlineSize, InlineAlignment, FunctionType>
|
|
|
|
{
|
2022-04-08 08:52:17 +00:00
|
|
|
using Type = TFunctionImpl<R(Types...), InlineSize, InlineAlignment, EFunctionSpecifiers::LValue, FunctionType>;
|
2022-04-07 07:57:02 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
template <typename R, typename... Types, size_t InlineSize, size_t InlineAlignment, EFunctionType FunctionType>
|
|
|
|
struct TFunctionSelect<R(Types...) && , InlineSize, InlineAlignment, FunctionType>
|
|
|
|
{
|
2022-04-08 08:52:17 +00:00
|
|
|
using Type = TFunctionImpl<R(Types...), InlineSize, InlineAlignment, EFunctionSpecifiers::RValue, FunctionType>;
|
2022-04-07 07:57:02 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
template <typename R, typename... Types, size_t InlineSize, size_t InlineAlignment, EFunctionType FunctionType>
|
|
|
|
struct TFunctionSelect<R(Types...) const , InlineSize, InlineAlignment, FunctionType>
|
|
|
|
{
|
2022-04-08 08:52:17 +00:00
|
|
|
using Type = TFunctionImpl<R(Types...), InlineSize, InlineAlignment, EFunctionSpecifiers::Const, FunctionType>;
|
2022-04-07 07:57:02 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
template <typename R, typename... Types, size_t InlineSize, size_t InlineAlignment, EFunctionType FunctionType>
|
|
|
|
struct TFunctionSelect<R(Types...) const& , InlineSize, InlineAlignment, FunctionType>
|
|
|
|
{
|
2022-04-08 08:52:17 +00:00
|
|
|
using Type = TFunctionImpl<R(Types...), InlineSize, InlineAlignment, EFunctionSpecifiers::ConstLValue, FunctionType>;
|
2022-04-07 07:57:02 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
template <typename R, typename... Types, size_t InlineSize, size_t InlineAlignment, EFunctionType FunctionType>
|
|
|
|
struct TFunctionSelect<R(Types...) const&&, InlineSize, InlineAlignment, FunctionType>
|
|
|
|
{
|
2022-04-08 08:52:17 +00:00
|
|
|
using Type = TFunctionImpl<R(Types...), InlineSize, InlineAlignment, EFunctionSpecifiers::ConstRValue, FunctionType>;
|
2022-04-07 07:57:02 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
NAMESPACE_PRIVATE_END
|
|
|
|
|
|
|
|
inline constexpr size_t FUNCTION_DEFAULT_INLINE_SIZE = 32;
|
|
|
|
inline constexpr size_t FUNCTION_DEFAULT_INLINE_ALIGNMENT = 16;
|
|
|
|
|
|
|
|
template <typename F>
|
|
|
|
using TFunctionRef = typename NAMESPACE_PRIVATE::TFunctionSelect<F, INDEX_NONE, INDEX_NONE, NAMESPACE_PRIVATE::EFunctionType::Reference>::Type;
|
|
|
|
|
|
|
|
template <typename F, size_t InlineSize = FUNCTION_DEFAULT_INLINE_SIZE, size_t InlineAlignment = FUNCTION_DEFAULT_INLINE_ALIGNMENT>
|
|
|
|
using TFunction = typename NAMESPACE_PRIVATE::TFunctionSelect<F, InlineSize, InlineAlignment, NAMESPACE_PRIVATE::EFunctionType::Object>::Type;
|
|
|
|
|
|
|
|
template <typename F, size_t InlineSize = FUNCTION_DEFAULT_INLINE_SIZE, size_t InlineAlignment = FUNCTION_DEFAULT_INLINE_ALIGNMENT>
|
|
|
|
using TUniqueFunction = typename NAMESPACE_PRIVATE::TFunctionSelect<F, InlineSize, InlineAlignment, NAMESPACE_PRIVATE::EFunctionType::Unique>::Type;
|
|
|
|
|
|
|
|
template <typename T> struct TIsTFunctionRef : NAMESPACE_PRIVATE::TIsTFunctionRef<T> { };
|
|
|
|
template <typename T> struct TIsTFunction : NAMESPACE_PRIVATE::TIsTFunction<T> { };
|
|
|
|
template <typename T> struct TIsTUniqueFunction : NAMESPACE_PRIVATE::TIsTUniqueFunction<T> { };
|
|
|
|
|
|
|
|
template <typename F>
|
|
|
|
constexpr bool operator==(const TFunctionRef<F>& LHS, nullptr_t)
|
|
|
|
{
|
|
|
|
return !LHS;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename F>
|
|
|
|
constexpr bool operator==(const TFunction<F>& LHS, nullptr_t)
|
|
|
|
{
|
|
|
|
return !LHS;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename F>
|
|
|
|
constexpr bool operator==(const TUniqueFunction<F>& LHS, nullptr_t)
|
|
|
|
{
|
|
|
|
return !LHS;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename F, size_t I, size_t J>
|
|
|
|
constexpr void Swap(TFunction<F, I, J>& A, TFunction<F, I, J>& B)
|
|
|
|
{
|
|
|
|
if (!A && !B) return;
|
|
|
|
|
|
|
|
if (A && !B)
|
|
|
|
{
|
|
|
|
B = MoveTemp(A);
|
|
|
|
A = nullptr;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (B && !A)
|
|
|
|
{
|
|
|
|
A = MoveTemp(B);
|
|
|
|
B = nullptr;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
TFunction<F, I, J> Temp = MoveTemp(A);
|
|
|
|
A = MoveTemp(B);
|
|
|
|
B = MoveTemp(Temp);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename F, size_t I, size_t J>
|
|
|
|
constexpr void Swap(TUniqueFunction<F, I, J>& A, TUniqueFunction<F, I, J>& B)
|
|
|
|
{
|
|
|
|
if (!A && !B) return;
|
|
|
|
|
|
|
|
if (A && !B)
|
|
|
|
{
|
|
|
|
B = MoveTemp(A);
|
|
|
|
A = nullptr;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (B && !A)
|
|
|
|
{
|
|
|
|
A = MoveTemp(B);
|
|
|
|
B = nullptr;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
TFunction<F, I, J> Temp = MoveTemp(A);
|
|
|
|
A = MoveTemp(B);
|
|
|
|
B = MoveTemp(Temp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static_assert(sizeof(TFunctionRef<void()>) == 16, "The byte size of TFunctionRef is unexpected");
|
|
|
|
static_assert(sizeof(TFunction<void()>) == 64, "The byte size of TFunction is unexpected");
|
|
|
|
static_assert(sizeof(TUniqueFunction<void()>) == 64, "The byte size of TUniqueFunction is unexpected");
|
|
|
|
|
2022-04-08 03:44:36 +00:00
|
|
|
template <typename T = void>
|
|
|
|
struct TIdentity
|
|
|
|
{
|
|
|
|
using Type = T;
|
|
|
|
|
|
|
|
constexpr T&& operator()(T&& InValue) const
|
|
|
|
{
|
|
|
|
return Forward<T>(InValue);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template <>
|
|
|
|
struct TIdentity<void>
|
|
|
|
{
|
|
|
|
using Type = void;
|
|
|
|
|
|
|
|
template<typename T>
|
|
|
|
constexpr T&& operator()(T&& InValue) const
|
|
|
|
{
|
|
|
|
return Forward<T>(InValue);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
NAMESPACE_PRIVATE_BEGIN
|
|
|
|
|
|
|
|
template <typename F>
|
|
|
|
struct NotFunctionType
|
|
|
|
{
|
|
|
|
F Func;
|
|
|
|
|
|
|
|
NotFunctionType(const NotFunctionType&) = default;
|
|
|
|
NotFunctionType(NotFunctionType&&) = default;
|
|
|
|
|
|
|
|
template <typename InF>
|
|
|
|
constexpr NotFunctionType(InF&& InFunc) : Func(Forward<InF>(InFunc)) { }
|
|
|
|
|
|
|
|
template <typename... Types> requires TIsInvocable<F&, Types&&...>::Value
|
|
|
|
constexpr auto operator()(Types&&... Args) &
|
|
|
|
-> decltype(!Invoke(Func, Forward<Types>(Args)...))
|
|
|
|
{
|
|
|
|
return !Invoke(Func, Forward<Types>(Args)...);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename... Types> requires TIsInvocable<F&&, Types&&...>::Value
|
|
|
|
constexpr auto operator()(Types&&... Args) &&
|
|
|
|
-> decltype(!Invoke(MoveTemp(Func), Forward<Types>(Args)...))
|
|
|
|
{
|
|
|
|
return !Invoke(MoveTemp(Func), Forward<Types>(Args)...);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename... Types> requires TIsInvocable<const F&, Types&&...>::Value
|
|
|
|
constexpr auto operator()(Types&&... Args) const&
|
|
|
|
-> decltype(!Invoke(Func, Forward<Types>(Args)...))
|
|
|
|
{
|
|
|
|
return !Invoke(Func, Forward<Types>(Args)...);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename... Types> requires TIsInvocable<const F&&, Types&&...>::Value
|
|
|
|
constexpr auto operator()(Types&&... Args) const&&
|
|
|
|
-> decltype(!Invoke(MoveTemp(Func), Forward<Types>(Args)...))
|
|
|
|
{
|
|
|
|
return !Invoke(MoveTemp(Func), Forward<Types>(Args)...);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
NAMESPACE_PRIVATE_END
|
|
|
|
|
|
|
|
template <typename F>
|
|
|
|
constexpr NAMESPACE_PRIVATE::NotFunctionType<typename TDecay<F>::Type> NotFn(F&& Func)
|
|
|
|
{
|
|
|
|
return NAMESPACE_PRIVATE::NotFunctionType<typename TDecay<F>::Type>(Forward<F>(Func));
|
|
|
|
}
|
|
|
|
|
|
|
|
#define FUNCTOR_UNARY_OPERATOR_IMPL(Name, Operator, ReturnType, ConceptT, ConceptU) \
|
|
|
|
template <typename T = void> requires (CSameAs<T, void> || ConceptT) \
|
|
|
|
struct Name \
|
|
|
|
{ \
|
|
|
|
constexpr ReturnType operator()(const T& InValue) const { \
|
|
|
|
return Operator InValue; \
|
|
|
|
} \
|
|
|
|
}; \
|
|
|
|
\
|
|
|
|
template <> \
|
|
|
|
struct Name<void> \
|
|
|
|
{ \
|
|
|
|
template <typename U> requires ConceptU \
|
|
|
|
constexpr auto operator()(U&& InValue) const \
|
|
|
|
-> decltype(Operator Forward<U>(InValue)) \
|
|
|
|
{ \
|
|
|
|
return Operator Forward<U>(InValue); \
|
|
|
|
} \
|
|
|
|
}
|
|
|
|
|
|
|
|
#define FUNCTOR_BINARY_OPERATOR_IMPL(Name, Operator, ReturnType, ConceptT, ConceptTU) \
|
|
|
|
template <typename T = void> requires (CSameAs<T, void> || ConceptT) \
|
|
|
|
struct Name \
|
|
|
|
{ \
|
|
|
|
constexpr ReturnType operator()(const T& LHS, const T& RHS) const \
|
|
|
|
{ \
|
|
|
|
return LHS Operator RHS; \
|
|
|
|
} \
|
|
|
|
}; \
|
|
|
|
\
|
|
|
|
template <> \
|
|
|
|
struct Name<void> \
|
|
|
|
{ \
|
|
|
|
template <typename T, typename U> requires ConceptTU \
|
|
|
|
constexpr auto operator()(T&& LHS, U&& RHS) const \
|
|
|
|
-> decltype(Forward<T>(LHS) Operator Forward<U>(RHS)) \
|
|
|
|
{ \
|
|
|
|
return Forward<T>(LHS) Operator Forward<U>(RHS); \
|
|
|
|
} \
|
|
|
|
}
|
|
|
|
|
|
|
|
#define FUNCTOR_UNARY_OPERATOR_A_IMPL(Name, Operator) \
|
|
|
|
FUNCTOR_UNARY_OPERATOR_IMPL \
|
|
|
|
( \
|
|
|
|
Name, Operator, T, \
|
|
|
|
(requires(const T& InValue) { { Operator InValue } -> CConvertibleTo<T>; }), \
|
|
|
|
(requires(U&& InValue) { Operator Forward<U>(InValue); }) \
|
|
|
|
)
|
|
|
|
|
|
|
|
#define FUNCTOR_BINARY_OPERATOR_A_IMPL(Name, Operator) \
|
|
|
|
FUNCTOR_BINARY_OPERATOR_IMPL \
|
|
|
|
( \
|
|
|
|
Name, Operator, T, \
|
|
|
|
(requires(const T& LHS, const T& RHS) { { LHS Operator RHS } -> CConvertibleTo<T>; }), \
|
|
|
|
(requires(T&& LHS, U&& RHS) { Forward<T>(LHS) Operator Forward<U>(RHS); }) \
|
|
|
|
)
|
|
|
|
|
|
|
|
#define FUNCTOR_UNARY_OPERATOR_B_IMPL(Name, Operator) \
|
|
|
|
FUNCTOR_UNARY_OPERATOR_IMPL \
|
|
|
|
( \
|
|
|
|
Name, Operator, bool, \
|
|
|
|
(requires(const T& InValue) { { Operator InValue } -> CBooleanTestable; }), \
|
|
|
|
(requires(U&& InValue) { { Operator Forward<U>(InValue) } -> CBooleanTestable; }) \
|
|
|
|
)
|
|
|
|
|
|
|
|
#define FUNCTOR_BINARY_OPERATOR_B_IMPL(Name, Operator) \
|
|
|
|
FUNCTOR_BINARY_OPERATOR_IMPL \
|
|
|
|
( \
|
|
|
|
Name, Operator, bool, \
|
|
|
|
(requires(const T& LHS, const T& RHS) { { LHS Operator RHS } -> CBooleanTestable; }), \
|
|
|
|
(requires(T&& LHS, U&& RHS) { { Forward<T>(LHS) Operator Forward<U>(RHS) } -> CBooleanTestable; }) \
|
|
|
|
)
|
|
|
|
|
|
|
|
#define FUNCTOR_BINARY_OPERATOR_C_IMPL(Name, Operator) \
|
|
|
|
FUNCTOR_BINARY_OPERATOR_IMPL \
|
|
|
|
( \
|
|
|
|
Name, Operator, bool, \
|
|
|
|
(CEqualityComparable<T>), \
|
|
|
|
(CEqualityComparableWith<T, U>) \
|
|
|
|
)
|
|
|
|
|
|
|
|
#define FUNCTOR_BINARY_OPERATOR_D_IMPL(Name, Operator) \
|
|
|
|
FUNCTOR_BINARY_OPERATOR_IMPL \
|
|
|
|
( \
|
|
|
|
Name, Operator, bool, \
|
|
|
|
(CTotallyOrdered<T>), \
|
|
|
|
(CTotallyOrderedWith<T, U>) \
|
|
|
|
)
|
|
|
|
|
|
|
|
FUNCTOR_BINARY_OPERATOR_A_IMPL(TPlus, +);
|
|
|
|
FUNCTOR_BINARY_OPERATOR_A_IMPL(TMinus, -);
|
|
|
|
FUNCTOR_BINARY_OPERATOR_A_IMPL(TMultiplies, *);
|
|
|
|
FUNCTOR_BINARY_OPERATOR_A_IMPL(TDivides, /);
|
|
|
|
FUNCTOR_BINARY_OPERATOR_A_IMPL(TModulus, %);
|
|
|
|
FUNCTOR_UNARY_OPERATOR_A_IMPL (TNegate, -);
|
|
|
|
|
|
|
|
FUNCTOR_BINARY_OPERATOR_C_IMPL(TEqualTo, ==);
|
|
|
|
FUNCTOR_BINARY_OPERATOR_C_IMPL(TNotEqualTo, !=);
|
|
|
|
FUNCTOR_BINARY_OPERATOR_D_IMPL(TGreater, > );
|
|
|
|
FUNCTOR_BINARY_OPERATOR_D_IMPL(TLess, < );
|
|
|
|
FUNCTOR_BINARY_OPERATOR_D_IMPL(TGreaterEqual, >=);
|
|
|
|
FUNCTOR_BINARY_OPERATOR_D_IMPL(TLessEqual, <=);
|
|
|
|
|
|
|
|
FUNCTOR_BINARY_OPERATOR_B_IMPL(TLogicalAnd, &&);
|
|
|
|
FUNCTOR_BINARY_OPERATOR_B_IMPL(TLogicalOr, ||);
|
|
|
|
FUNCTOR_UNARY_OPERATOR_B_IMPL (TLogicalNot, ! );
|
|
|
|
|
|
|
|
FUNCTOR_BINARY_OPERATOR_A_IMPL(TBitAnd, &);
|
|
|
|
FUNCTOR_BINARY_OPERATOR_A_IMPL(TBitOr, |);
|
|
|
|
FUNCTOR_BINARY_OPERATOR_A_IMPL(TBitXor, ^);
|
|
|
|
FUNCTOR_UNARY_OPERATOR_A_IMPL (TBitNot, ~);
|
|
|
|
|
|
|
|
#undef FUNCTOR_BINARY_OPERATOR_D_IMPL
|
|
|
|
#undef FUNCTOR_BINARY_OPERATOR_C_IMPL
|
|
|
|
|
|
|
|
#undef FUNCTOR_BINARY_OPERATOR_B_IMPL
|
|
|
|
#undef FUNCTOR_UNARY_OPERATOR_B_IMPL
|
|
|
|
|
|
|
|
#undef FUNCTOR_BINARY_OPERATOR_A_IMPL
|
|
|
|
#undef FUNCTOR_UNARY_OPERATOR_A_IMPL
|
|
|
|
|
|
|
|
#undef FUNCTOR_BINARY_OPERATOR_IMPL
|
|
|
|
#undef FUNCTOR_UNARY_OPERATOR_IMPL
|
|
|
|
|
2022-04-07 07:57:02 +00:00
|
|
|
NAMESPACE_MODULE_END(Utility)
|
|
|
|
NAMESPACE_MODULE_END(Redcraft)
|
|
|
|
NAMESPACE_REDCRAFT_END
|