TVariantMeta.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Templates/MemoryOps.h"
#include "Templates/TypeCompatibleBytes.h"
#include "Templates/UnrealTemplate.h"
#include "Templates/UnrealTypeTraits.h"
#include "Delegates/IntegerSequence.h"
#include "Concepts/Insertable.h"
 
#include "Misc/AssertionMacros.h"
 
template <typename T, typename... Ts>
class TVariant;
 
template <typename T>
constexpr bool TIsVariant_V = false;
 
template <typename... Ts>
constexpr bool TIsVariant_V<TVariant<Ts...>> = true;
 
template <typename T> constexpr bool TIsVariant_V<const          T> = TIsVariant_V<T>;
template <typename T> constexpr bool TIsVariant_V<      volatile T> = TIsVariant_V<T>;
template <typename T> constexpr bool TIsVariant_V<const volatile T> = TIsVariant_V<T>;
 
template <typename>
constexpr SIZE_T TVariantSize_V = 0;
 
template <typename... Ts>
constexpr SIZE_T TVariantSize_V<TVariant<Ts...>> = sizeof...(Ts);
 
template <typename T> constexpr SIZE_T TVariantSize_V<const          T> = TVariantSize_V<T>;
template <typename T> constexpr SIZE_T TVariantSize_V<      volatile T> = TVariantSize_V<T>;
template <typename T> constexpr SIZE_T TVariantSize_V<const volatile T> = TVariantSize_V<T>;
 
template <typename T>
struct UE_DEPRECATED(5.4, "TIsVariant<T> has been deprecated, please use TIsVariant_V<std::remove_reference_t<T>> instead") TIsVariant
{
    static constexpr inline bool Value = TIsVariant_V<T>;
};
 
template <typename> struct TVariantSize;
 
template <typename T>
struct UE_DEPRECATED(5.4, "TVariantSize<T> has been deprecated, please use TVariantSize_V<std::remove_reference_t<T>> instead") TVariantSize
{
    static constexpr inline SIZE_T Value = TVariantSize_V<std::remove_reference_t<T>>;
};
 
namespace UE
{
namespace Core
{
namespace Private
{
    template <typename T>
    struct TAlwaysFArchive
    {
        using Type = FArchive;
    };
 
    template <typename...>
    struct TTypePackContainsDuplicates;
 
    template <typename T>
    struct TTypePackContainsDuplicates<T>
    {
        static constexpr inline bool Value = false;
    };
 
    template <typename T, typename... Ts>
    struct TTypePackContainsDuplicates<T, T, Ts...>
    {
        static constexpr inline bool Value = true;
    };
 
    template <typename T, typename U, typename... Rest>
    struct TTypePackContainsDuplicates<T, U, Rest...>
    {
        static constexpr inline bool Value = TTypePackContainsDuplicates<T, Rest...>::Value || TTypePackContainsDuplicates<U, Rest...>::Value;
    };
 
    template <typename... Ts>
    struct TContainsReferenceType
    {
        static constexpr inline bool Value = (std::is_reference_v<Ts> || ...);
    };
 
    template <typename... Ts>
    struct TVariantStorage
    {
        static constexpr SIZE_T MaxOf(const SIZE_T Sizes[])
        {
            SIZE_T MaxSize = 0;
            for (SIZE_T Itr = 0; Itr < sizeof...(Ts); ++Itr)
            {
                if (Sizes[Itr] > MaxSize)
                {
                    MaxSize = Sizes[Itr];
                }
            }
            return MaxSize;
        }
        static constexpr SIZE_T MaxSizeof()
        {
            constexpr SIZE_T Sizes[] = { sizeof(Ts)... };
            return MaxOf(Sizes);
        }
        static constexpr SIZE_T MaxAlignof()
        {
            constexpr SIZE_T Sizes[] = { alignof(Ts)... };
            return MaxOf(Sizes);
        }
 
        static constexpr inline SIZE_T SizeofValue = MaxSizeof();
        static constexpr inline SIZE_T AlignofValue = MaxAlignof();
        static_assert(SizeofValue > 0, "MaxSizeof must be greater than 0");
        static_assert(AlignofValue > 0, "MaxAlignof must be greater than 0");
 
        template <SIZE_T N>
        auto& GetValueAsIndexedType() &
        {
            using ReturnType = typename TNthTypeFromParameterPack<N, Ts...>::Type;
            return *reinterpret_cast<ReturnType*>(&Storage);
        }
 
        template <SIZE_T N>
        auto&& GetValueAsIndexedType() &&
        {
            using ReturnType = typename TNthTypeFromParameterPack<N, Ts...>::Type;
            return (ReturnType&&)GetValueAsIndexedType<N>();
        }
 
        template <SIZE_T N>
        const auto& GetValueAsIndexedType() const&
        {
            // Temporarily remove the const qualifier so we can implement GetValueAsIndexedType in one location.
            return const_cast<TVariantStorage*>(this)->template GetValueAsIndexedType<N>();
        }
 
        TAlignedBytes<SizeofValue, AlignofValue> Storage;
 
#if !PLATFORM_COMPILER_SUPPORTS_CONSTRAINED_DESTRUCTORS
        uint8 TypeIndex;
#endif
    };
 
    template <SIZE_T N, typename LookupType, typename... Ts>
    struct TParameterPackTypeIndexHelper
    {
        static constexpr inline SIZE_T Value = (SIZE_T)-1;
    };
 
    template <SIZE_T N, typename T, typename... Ts>
    struct TParameterPackTypeIndexHelper<N, T, T, Ts...>
    {
        static constexpr inline SIZE_T Value = N;
    };
 
    template <SIZE_T N, typename LookupType, typename T, typename... Ts>
    struct TParameterPackTypeIndexHelper<N, LookupType, T, Ts...>
    {
        static constexpr inline SIZE_T Value = TParameterPackTypeIndexHelper<N + 1, LookupType, Ts...>::Value;
    };
 
    template <typename LookupType, typename... Ts>
    struct TParameterPackTypeIndex
    {
        static constexpr inline SIZE_T Value = TParameterPackTypeIndexHelper<0, LookupType, Ts...>::Value;
    };
 
    template <typename T>
    struct TDestructorCaller
    {
        static constexpr void Destruct(void* Storage)
        {
            DestructItem(static_cast<T*>(Storage));
        }
    };
 
    template <typename... Ts>
    struct TDestructorLookup
    {
        static void Destruct(SIZE_T TypeIndex, void* Value)
        {
            static constexpr void(*Destructors[])(void*) = { &TDestructorCaller<Ts>::Destruct... };
            check(TypeIndex < UE_ARRAY_COUNT(Destructors));
            Destructors[TypeIndex](Value);
        }
    };
 
    template <typename T>
    struct TCopyConstructorCaller
    {
        static void Construct(void* Storage, const void* Value)
        {
            ::new(Storage) T(*static_cast<const T*>(Value));
        }
    };
 
    template <typename... Ts>
    struct TCopyConstructorLookup
    {
        static void Construct(SIZE_T TypeIndex, void* Storage, const void* Value)
        {
            static constexpr void(*CopyConstructors[])(void*, const void*) = { &TCopyConstructorCaller<Ts>::Construct... };
            check(TypeIndex < UE_ARRAY_COUNT(CopyConstructors));
            CopyConstructors[TypeIndex](Storage, Value);
        }
    };
 
 
    template <typename T>
    struct TMoveConstructorCaller
    {
        static void Construct(void* Storage, void* Value)
        {
            ::new(Storage) T(MoveTemp(*static_cast<T*>(Value)));
        }
    };
 
    template <typename... Ts>
    struct TMoveConstructorLookup
    {
        static void Construct(SIZE_T TypeIndex, void* Target, void* Source)
        {
            static constexpr void(*MoveConstructors[])(void*, void*) = { &TMoveConstructorCaller<Ts>::Construct... };
            check(TypeIndex < UE_ARRAY_COUNT(MoveConstructors));
            MoveConstructors[TypeIndex](Target, Source);
        }
    };
 
    template <typename T, typename VariantType>
    struct TVariantLoadFromArchiveCaller
    {
        static void Load(FArchive& Ar, VariantType& OutVariant)
        {
            OutVariant.template Emplace<T>();
            Ar << OutVariant.template Get<T>();
        }
    };
 
    template <typename... Ts>
    struct TVariantLoadFromArchiveLookup
    {
        using VariantType = TVariant<Ts...>;
        static_assert((std::is_default_constructible_v<Ts> && ...), "Each type in TVariant template parameter pack must be default constructible in order to use FArchive serialization");
        static_assert((TModels_V<CInsertable<FArchive&>, Ts> && ...), "Each type in TVariant template parameter pack must be able to use operator<< with an FArchive");
 
        static void Load(SIZE_T TypeIndex, FArchive& Ar, VariantType& OutVariant)
        {
            static constexpr void(*Loaders[])(FArchive&, VariantType&) = { &TVariantLoadFromArchiveCaller<Ts, VariantType>::Load... };
            check(TypeIndex < UE_ARRAY_COUNT(Loaders));
            Loaders[TypeIndex](Ar, OutVariant);
        }
    };
 
    template <typename LookupType, typename... Ts>
    struct TIsType
    {
        static bool IsSame(SIZE_T TypeIndex)
        {
            static constexpr bool bIsSameType[] = { std::is_same_v<Ts, LookupType>... };
            check(TypeIndex < UE_ARRAY_COUNT(bIsSameType));
            return bIsSameType[TypeIndex];
        }
    };
 
    template <typename T>
    inline SIZE_T EncodeIndices(const T& Variant)
    {
        return Variant.GetIndex();
    }
 
    template <typename Variant0, typename... Variants>
    inline SIZE_T EncodeIndices(const Variant0& First, const Variants&... Rest)
    {
        return First.GetIndex() + TVariantSize_V<Variant0> * EncodeIndices(Rest...);
    }
 
    constexpr SIZE_T DecodeIndex(SIZE_T EncodedIndex, SIZE_T VariantIndex, const SIZE_T* VariantSizes)
    {
        while (VariantIndex)
        {
            EncodedIndex /= *VariantSizes;
            --VariantIndex;
            ++VariantSizes;
        }
        return EncodedIndex % *VariantSizes;
    }
 
    template <typename... Ts>
    UE_FORCEINLINE_HINT TVariantStorage<Ts...>& CastToStorage(TVariant<Ts...>& Variant)
    {
        return *(TVariantStorage<Ts...>*)(&Variant);
    }
 
    template <typename... Ts>
    UE_FORCEINLINE_HINT TVariantStorage<Ts...>&& CastToStorage(TVariant<Ts...>&& Variant)
    {
        return (TVariantStorage<Ts...>&&)(*(TVariantStorage<Ts...>*)(&Variant));
    }
 
    template <typename... Ts>
    UE_FORCEINLINE_HINT const TVariantStorage<Ts...>& CastToStorage(const TVariant<Ts...>& Variant)
    {
        return *(const TVariantStorage<Ts...>*)(&Variant);
    }
 
    template <SIZE_T EncodedIndex, SIZE_T... VariantIndices, typename Func, typename... Variants>
    inline decltype(auto) VisitApplyEncoded(Func&& Callable, Variants&&... Args)
    {
        constexpr SIZE_T VariantSizes[] = { TVariantSize_V<std::decay_t<Variants>>... };
        return Callable(CastToStorage(Forward<Variants>(Args)).template GetValueAsIndexedType<DecodeIndex(EncodedIndex, VariantIndices, VariantSizes)>()...);
    }
 
    template <typename InvokeFn, SIZE_T... VariantIndices>
    struct TWrapper
    {
        template <SIZE_T EncodedIndex>
        static constexpr InvokeFn FuncPtr = &VisitApplyEncoded<EncodedIndex, VariantIndices...>;
    };
 
    template <typename Func, SIZE_T... EncodedIndices, SIZE_T... VariantIndices, typename... Variants>
    decltype(auto) VisitImpl(SIZE_T EncodedIndex, Func&& Callable, TIntegerSequence<SIZE_T, EncodedIndices...>&&, TIntegerSequence<SIZE_T, VariantIndices...>&& VariantIndicesSeq, Variants&&... Args)
    {
        using ReturnType = decltype(VisitApplyEncoded<0, VariantIndices...>(Forward<Func>(Callable), Forward<Variants>(Args)...));
        using InvokeFn = ReturnType(*)(Func&&, Variants&&...);
        using WrapperType = TWrapper<InvokeFn, VariantIndices...>;
        static constexpr InvokeFn Invokers[] = { WrapperType::template FuncPtr<EncodedIndices>... };
        return Invokers[EncodedIndex](Forward<Func>(Callable), Forward<Variants>(Args)...);
    }
 
#if !PLATFORM_COMPILER_SUPPORTS_CONSTRAINED_DESTRUCTORS
    template <typename T, typename... Ts>
    struct TDestructibleVariantStorage : TVariantStorage<T, Ts...>
    {
    protected:
        ~TDestructibleVariantStorage()
        {
            UE::Core::Private::TDestructorLookup<T, Ts...>::Destruct(this->TypeIndex, this);
        }
    };
#endif
 
} // namespace Private
} // namespace Core
} // namespace UE