398 lines
14 KiB
C++
398 lines
14 KiB
C++
#pragma once
|
|
|
|
#include "CoreTypes.h"
|
|
#include "Memory/Memory.h"
|
|
#include "Memory/Alignment.h"
|
|
#include "Templates/Utility.h"
|
|
#include "Templates/TypeHash.h"
|
|
#include "TypeTraits/TypeTraits.h"
|
|
#include "Miscellaneous/TypeInfo.h"
|
|
#include "Miscellaneous/AssertionMacros.h"
|
|
|
|
// NOTE: Disable alignment limit warning
|
|
#pragma warning(disable : 4359)
|
|
|
|
NAMESPACE_REDCRAFT_BEGIN
|
|
NAMESPACE_MODULE_BEGIN(Redcraft)
|
|
NAMESPACE_MODULE_BEGIN(Utility)
|
|
|
|
NAMESPACE_PRIVATE_BEGIN
|
|
|
|
enum class EAnyRepresentation : uint8
|
|
{
|
|
Trivial, // Trivial
|
|
// Inline, // InlineAllocation
|
|
Small, // Trivial & Inline
|
|
Big, // HeapAllocation
|
|
};
|
|
|
|
NAMESPACE_PRIVATE_END
|
|
|
|
inline constexpr size_t ANY_DEFAULT_INLINE_SIZE = 64 - sizeof(uintptr);
|
|
inline constexpr size_t ANY_DEFAULT_INLINE_ALIGNMENT = 16;
|
|
|
|
template <size_t InlineSize, size_t InlineAlignment = ANY_DEFAULT_INLINE_ALIGNMENT> requires (Memory::IsValidAlignment(InlineAlignment))
|
|
struct alignas(InlineAlignment) TAny
|
|
{
|
|
constexpr TAny() : TypeInfo(0) { }
|
|
|
|
constexpr TAny(FInvalid) : TAny() { }
|
|
|
|
FORCEINLINE TAny(const TAny& InValue)
|
|
: TypeInfo(InValue.TypeInfo)
|
|
{
|
|
if (!IsValid()) return;
|
|
|
|
switch (GetRepresentation())
|
|
{
|
|
case NAMESPACE_PRIVATE::EAnyRepresentation::Trivial:
|
|
Memory::Memcpy(InlineAllocation, InValue.InlineAllocation);
|
|
break;
|
|
case NAMESPACE_PRIVATE::EAnyRepresentation::Small:
|
|
GetTypeInfo().CopyConstruct(GetAllocation(), InValue.GetAllocation());
|
|
break;
|
|
case NAMESPACE_PRIVATE::EAnyRepresentation::Big:
|
|
HeapAllocation = Memory::Malloc(GetTypeInfo().GetTypeSize(), GetTypeInfo().GetTypeAlignment());
|
|
GetTypeInfo().CopyConstruct(GetAllocation(), InValue.GetAllocation());
|
|
break;
|
|
default: check_no_entry();
|
|
}
|
|
}
|
|
|
|
FORCEINLINE TAny(TAny&& InValue)
|
|
: TypeInfo(InValue.TypeInfo)
|
|
{
|
|
if (!IsValid()) return;
|
|
|
|
switch (GetRepresentation())
|
|
{
|
|
case NAMESPACE_PRIVATE::EAnyRepresentation::Trivial:
|
|
Memory::Memcpy(InlineAllocation, InValue.InlineAllocation);
|
|
break;
|
|
case NAMESPACE_PRIVATE::EAnyRepresentation::Small:
|
|
GetTypeInfo().MoveConstruct(GetAllocation(), InValue.GetAllocation());
|
|
break;
|
|
case NAMESPACE_PRIVATE::EAnyRepresentation::Big:
|
|
HeapAllocation = InValue.HeapAllocation;
|
|
InValue.TypeInfo = 0;
|
|
break;
|
|
default: check_no_entry();
|
|
}
|
|
}
|
|
|
|
template <typename T, typename... Types> requires TIsObject<typename TDecay<T>::Type>::Value
|
|
&& (!TIsArray<typename TDecay<T>::Type>::Value) && TIsDestructible<typename TDecay<T>::Type>::Value
|
|
&& TIsConstructible<typename TDecay<T>::Type, Types...>::Value
|
|
FORCEINLINE explicit TAny(TInPlaceType<T>, Types&&... Args)
|
|
{
|
|
using SelectedType = typename TDecay<T>::Type;
|
|
EmplaceImpl<SelectedType>(Forward<Types>(Args)...);
|
|
}
|
|
|
|
template <typename T> requires (!TIsSame<typename TDecay<T>::Type, TAny>::Value) && (!TIsTInPlaceType<typename TDecay<T>::Type>::Value)
|
|
&& TIsObject<typename TDecay<T>::Type>::Value && (!TIsArray<typename TDecay<T>::Type>::Value) && TIsDestructible<typename TDecay<T>::Type>::Value
|
|
&& TIsConstructible<typename TDecay<T>::Type, T&&>::Value
|
|
FORCEINLINE TAny(T&& InValue) : TAny(InPlaceType<typename TDecay<T>::Type>, Forward<T>(InValue))
|
|
{ }
|
|
|
|
FORCEINLINE ~TAny()
|
|
{
|
|
ResetImpl();
|
|
}
|
|
|
|
FORCEINLINE TAny& operator=(const TAny& InValue)
|
|
{
|
|
if (&InValue == this) return *this;
|
|
|
|
if (!InValue.IsValid())
|
|
{
|
|
Reset();
|
|
}
|
|
else if (GetTypeInfo() == InValue.GetTypeInfo())
|
|
{
|
|
switch (GetRepresentation())
|
|
{
|
|
case NAMESPACE_PRIVATE::EAnyRepresentation::Trivial:
|
|
Memory::Memcpy(InlineAllocation, InValue.InlineAllocation);
|
|
break;
|
|
case NAMESPACE_PRIVATE::EAnyRepresentation::Small:
|
|
case NAMESPACE_PRIVATE::EAnyRepresentation::Big:
|
|
GetTypeInfo().CopyAssign(GetAllocation(), InValue.GetAllocation());
|
|
break;
|
|
default: check_no_entry();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ResetImpl();
|
|
|
|
TypeInfo = InValue.TypeInfo;
|
|
|
|
switch (GetRepresentation())
|
|
{
|
|
case NAMESPACE_PRIVATE::EAnyRepresentation::Trivial:
|
|
Memory::Memcpy(InlineAllocation, InValue.InlineAllocation);
|
|
break;
|
|
case NAMESPACE_PRIVATE::EAnyRepresentation::Small:
|
|
GetTypeInfo().CopyConstruct(GetAllocation(), InValue.GetAllocation());
|
|
break;
|
|
case NAMESPACE_PRIVATE::EAnyRepresentation::Big:
|
|
HeapAllocation = Memory::Malloc(GetTypeInfo().GetTypeSize(), GetTypeInfo().GetTypeAlignment());
|
|
GetTypeInfo().CopyConstruct(GetAllocation(), InValue.GetAllocation());
|
|
break;
|
|
default: check_no_entry();
|
|
}
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
FORCEINLINE TAny& operator=(TAny&& InValue)
|
|
{
|
|
if (&InValue == this) return *this;
|
|
|
|
if (!InValue.IsValid())
|
|
{
|
|
Reset();
|
|
}
|
|
else if (GetTypeInfo() == InValue.GetTypeInfo())
|
|
{
|
|
switch (GetRepresentation())
|
|
{
|
|
case NAMESPACE_PRIVATE::EAnyRepresentation::Trivial:
|
|
Memory::Memcpy(InlineAllocation, InValue.InlineAllocation);
|
|
break;
|
|
case NAMESPACE_PRIVATE::EAnyRepresentation::Small:
|
|
GetTypeInfo().MoveAssign(GetAllocation(), InValue.GetAllocation());
|
|
break;
|
|
case NAMESPACE_PRIVATE::EAnyRepresentation::Big:
|
|
ResetImpl();
|
|
HeapAllocation = InValue.HeapAllocation;
|
|
InValue.TypeInfo = 0;
|
|
break;
|
|
default: check_no_entry();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ResetImpl();
|
|
|
|
TypeInfo = InValue.TypeInfo;
|
|
|
|
switch (GetRepresentation())
|
|
{
|
|
case NAMESPACE_PRIVATE::EAnyRepresentation::Trivial:
|
|
Memory::Memcpy(InlineAllocation, InValue.InlineAllocation);
|
|
break;
|
|
case NAMESPACE_PRIVATE::EAnyRepresentation::Small:
|
|
GetTypeInfo().MoveConstruct(GetAllocation(), InValue.GetAllocation());
|
|
break;
|
|
case NAMESPACE_PRIVATE::EAnyRepresentation::Big:
|
|
HeapAllocation = InValue.HeapAllocation;
|
|
InValue.TypeInfo = 0;
|
|
break;
|
|
default: check_no_entry();
|
|
}
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
template <typename T> requires (!TIsSame<typename TDecay<T>::Type, TAny>::Value) && (!TIsTInPlaceType<typename TDecay<T>::Type>::Value)
|
|
&& TIsObject<typename TDecay<T>::Type>::Value && (!TIsArray<typename TDecay<T>::Type>::Value) && TIsDestructible<typename TDecay<T>::Type>::Value
|
|
&& TIsConstructible<typename TDecay<T>::Type, T&&>::Value
|
|
FORCEINLINE TAny& operator=(T&& InValue)
|
|
{
|
|
using SelectedType = typename TDecay<T>::Type;
|
|
|
|
if (HoldsAlternative<SelectedType>())
|
|
{
|
|
GetValue<SelectedType>() = Forward<T>(InValue);
|
|
}
|
|
else
|
|
{
|
|
ResetImpl();
|
|
EmplaceImpl<SelectedType>(Forward<T>(InValue));
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
template <typename T, typename... Types> requires TIsObject<typename TDecay<T>::Type>::Value
|
|
&& (!TIsArray<typename TDecay<T>::Type>::Value) && TIsDestructible<typename TDecay<T>::Type>::Value
|
|
&& TIsConstructible<typename TDecay<T>::Type, T&&>::Value
|
|
FORCEINLINE typename TDecay<T>::Type& Emplace(Types&&... Args)
|
|
{
|
|
ResetImpl();
|
|
|
|
using SelectedType = typename TDecay<T>::Type;
|
|
EmplaceImpl<SelectedType>(Forward<Types>(Args)...);
|
|
return GetValue<SelectedType>();
|
|
}
|
|
|
|
constexpr const FTypeInfo& GetTypeInfo() const { return IsValid() ? *reinterpret_cast<FTypeInfo*>(TypeInfo & ~RepresentationMask) : Typeid(void); }
|
|
|
|
constexpr bool IsValid() const { return TypeInfo != 0; }
|
|
constexpr explicit operator bool() const { return TypeInfo != 0; }
|
|
|
|
template <typename T> constexpr bool HoldsAlternative() const { return IsValid() ? GetTypeInfo() == Typeid(T) : false; }
|
|
|
|
template <typename T> requires 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
|
|
constexpr T& GetValue() & { checkf(HoldsAlternative<T>(), TEXT("It is an error to call GetValue() on an wrong TAny. Please either check HoldsAlternative() or use Get(DefaultValue) instead.")); return *reinterpret_cast< T*>(GetAllocation()); }
|
|
|
|
template <typename T> requires 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
|
|
constexpr T&& GetValue() && { checkf(HoldsAlternative<T>(), TEXT("It is an error to call GetValue() on an wrong TAny. Please either check HoldsAlternative() or use Get(DefaultValue) instead.")); return MoveTemp(*reinterpret_cast< T*>(GetAllocation())); }
|
|
|
|
template <typename T> requires 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
|
|
constexpr const T& GetValue() const& { checkf(HoldsAlternative<T>(), TEXT("It is an error to call GetValue() on an wrong TAny. Please either check HoldsAlternative() or use Get(DefaultValue) instead.")); return *reinterpret_cast<const T*>(GetAllocation()); }
|
|
|
|
template <typename T> requires 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
|
|
constexpr const T&& GetValue() const&& { checkf(HoldsAlternative<T>(), TEXT("It is an error to call GetValue() on an wrong TAny. Please either check HoldsAlternative() or use Get(DefaultValue) instead.")); return MoveTemp(*reinterpret_cast<const T*>(GetAllocation())); }
|
|
|
|
template <typename T> requires 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
|
|
constexpr T& Get( T& DefaultValue) & { return HoldsAlternative<T>() ? GetValue<T>() : DefaultValue; }
|
|
|
|
template <typename T> requires 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
|
|
constexpr const T& Get(const T& DefaultValue) const& { return HoldsAlternative<T>() ? GetValue<T>() : DefaultValue; }
|
|
|
|
FORCEINLINE void Reset()
|
|
{
|
|
ResetImpl();
|
|
TypeInfo = 0;
|
|
}
|
|
|
|
FORCEINLINE size_t GetTypeHash() const
|
|
{
|
|
if (!IsValid()) return 20090007;
|
|
return HashCombine(GetTypeInfo().GetTypeHash(), GetTypeInfo().HashItem(GetAllocation()));
|
|
}
|
|
|
|
FORCEINLINE void Swap(TAny& InValue)
|
|
{
|
|
if (!IsValid() && !InValue.IsValid()) return;
|
|
|
|
if (IsValid() && !InValue.IsValid())
|
|
{
|
|
InValue = MoveTemp(*this);
|
|
Reset();
|
|
return;
|
|
}
|
|
|
|
if (InValue.IsValid() && !IsValid())
|
|
{
|
|
*this = MoveTemp(InValue);
|
|
InValue.Reset();
|
|
return;
|
|
}
|
|
|
|
if (GetTypeInfo() == InValue.GetTypeInfo())
|
|
{
|
|
GetTypeInfo().SwapItem(GetAllocation(), InValue.GetAllocation());
|
|
return;
|
|
}
|
|
|
|
TAny Temp = MoveTemp(*this);
|
|
*this = MoveTemp(InValue);
|
|
InValue = MoveTemp(Temp);
|
|
}
|
|
|
|
private:
|
|
|
|
static constexpr uintptr_t RepresentationMask = 3;
|
|
|
|
union
|
|
{
|
|
TAlignedStorage<InlineSize, 1>::Type InlineAllocation;
|
|
void* HeapAllocation;
|
|
};
|
|
|
|
uintptr TypeInfo;
|
|
|
|
constexpr NAMESPACE_PRIVATE::EAnyRepresentation GetRepresentation() const { return static_cast<NAMESPACE_PRIVATE::EAnyRepresentation>(TypeInfo & RepresentationMask); }
|
|
|
|
constexpr void* GetAllocation() { return GetRepresentation() == NAMESPACE_PRIVATE::EAnyRepresentation::Trivial || GetRepresentation() == NAMESPACE_PRIVATE::EAnyRepresentation::Small ? &InlineAllocation : HeapAllocation; }
|
|
constexpr const void* GetAllocation() const { return GetRepresentation() == NAMESPACE_PRIVATE::EAnyRepresentation::Trivial || GetRepresentation() == NAMESPACE_PRIVATE::EAnyRepresentation::Small ? &InlineAllocation : HeapAllocation; }
|
|
|
|
template <typename SelectedType, typename... Types>
|
|
FORCEINLINE void EmplaceImpl(Types&&... Args)
|
|
{
|
|
TypeInfo = reinterpret_cast<uintptr>(&Typeid(SelectedType));
|
|
|
|
constexpr bool bIsInlineStorable = sizeof(SelectedType) <= InlineSize && alignof(SelectedType) <= InlineAlignment;
|
|
constexpr bool bIsTriviallyStorable = bIsInlineStorable && TIsTrivial<SelectedType>::Value && TIsTriviallyCopyable<SelectedType>::Value;
|
|
|
|
if constexpr (bIsTriviallyStorable)
|
|
{
|
|
new(&InlineAllocation) SelectedType(Forward<Types>(Args)...);
|
|
TypeInfo |= static_cast<uintptr>(NAMESPACE_PRIVATE::EAnyRepresentation::Trivial);
|
|
}
|
|
else if constexpr (bIsInlineStorable)
|
|
{
|
|
new(&InlineAllocation) SelectedType(Forward<Types>(Args)...);
|
|
TypeInfo |= static_cast<uintptr>(NAMESPACE_PRIVATE::EAnyRepresentation::Small);
|
|
}
|
|
else
|
|
{
|
|
HeapAllocation = new SelectedType(Forward<Types>(Args)...);
|
|
TypeInfo |= static_cast<uintptr>(NAMESPACE_PRIVATE::EAnyRepresentation::Big);
|
|
}
|
|
}
|
|
|
|
FORCEINLINE void ResetImpl()
|
|
{
|
|
if (!IsValid()) return;
|
|
|
|
switch (GetRepresentation())
|
|
{
|
|
case NAMESPACE_PRIVATE::EAnyRepresentation::Trivial:
|
|
break;
|
|
case NAMESPACE_PRIVATE::EAnyRepresentation::Small:
|
|
GetTypeInfo().Destroy(GetAllocation());
|
|
break;
|
|
case NAMESPACE_PRIVATE::EAnyRepresentation::Big:
|
|
GetTypeInfo().Destroy(GetAllocation());
|
|
Memory::Free(HeapAllocation);
|
|
break;
|
|
default: check_no_entry();
|
|
}
|
|
}
|
|
|
|
friend FORCEINLINE bool operator==(const TAny& LHS, const TAny& RHS)
|
|
{
|
|
if (LHS.GetTypeInfo() != RHS.GetTypeInfo()) return false;
|
|
if (LHS.IsValid() == false) return true;
|
|
return LHS.GetTypeInfo().EqualityCompare(LHS.GetAllocation(), RHS.GetAllocation());
|
|
}
|
|
|
|
friend FORCEINLINE partial_ordering operator<=>(const TAny& LHS, const TAny& RHS)
|
|
{
|
|
if (LHS.GetTypeInfo() != RHS.GetTypeInfo()) return partial_ordering::unordered;
|
|
if (LHS.IsValid() == false) return partial_ordering::equivalent;
|
|
return LHS.GetTypeInfo().SynthThreeWayCompare(LHS.GetAllocation(), RHS.GetAllocation());;
|
|
}
|
|
|
|
};
|
|
|
|
template <typename T, size_t InlineSize, size_t InlineAlignment>
|
|
constexpr bool operator==(const TAny<InlineSize, InlineAlignment>& LHS, const T& RHS)
|
|
{
|
|
return LHS.template HoldsAlternative<T>() ? LHS.template GetValue<T>() == RHS : false;
|
|
}
|
|
|
|
template <size_t InlineSize, size_t InlineAlignment>
|
|
constexpr bool operator==(const TAny<InlineSize, InlineAlignment>& LHS, FInvalid)
|
|
{
|
|
return !LHS.IsValid();
|
|
}
|
|
|
|
template <typename T> struct TIsTAny : FFalse { };
|
|
template <size_t InlineSize, size_t InlineAlignment> struct TIsTAny<TAny<InlineSize, InlineAlignment>> : FTrue { };
|
|
|
|
using FAny = TAny<ANY_DEFAULT_INLINE_SIZE>;
|
|
|
|
static_assert(sizeof(FAny) == 64, "The byte size of FAny is unexpected");
|
|
|
|
NAMESPACE_MODULE_END(Utility)
|
|
NAMESPACE_MODULE_END(Redcraft)
|
|
NAMESPACE_REDCRAFT_END
|