TVariant.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Templates/Requires.h"
#include "TVariantMeta.h"
#include <type_traits>
 
template <typename T>
struct TInPlaceType {};
 
namespace UE::Core::Private
{
template <typename T>
struct TUninitializedType {};
}
 
struct FEmptyVariantState
{
    friend inline FArchive& operator<<(FArchive& Ar, FEmptyVariantState&)
    {
        return Ar;
    }
};
 
template <typename T, typename... Ts>
class TVariant final
#if PLATFORM_COMPILER_SUPPORTS_CONSTRAINED_DESTRUCTORS
    : private UE::Core::Private::TVariantStorage<T, Ts...>
#else
    : private std::conditional_t<!std::is_trivially_destructible_v<T> || (!std::is_trivially_destructible_v<Ts> || ...), UE::Core::Private::TDestructibleVariantStorage<T, Ts...> , UE::Core::Private::TVariantStorage<T, Ts...>>
#endif
{
#if PLATFORM_COMPILER_SUPPORTS_CONSTRAINED_DESTRUCTORS
    using Super = UE::Core::Private::TVariantStorage<T, Ts...>;
#else
    using Super = std::conditional_t<!std::is_trivially_destructible_v<T> || (!std::is_trivially_destructible_v<Ts> || ...), UE::Core::Private::TDestructibleVariantStorage<T, Ts...> , UE::Core::Private::TVariantStorage<T, Ts...>>;
#endif
 
    static_assert(!UE::Core::Private::TTypePackContainsDuplicates<T, Ts...>::Value, "All the types used in TVariant should be unique");
    static_assert(!UE::Core::Private::TContainsReferenceType<T, Ts...>::Value, "TVariant cannot hold reference types");
 
    // Test for 255 here, because the parameter pack doesn't include the initial T
    static_assert(sizeof...(Ts) <= 255, "TVariant cannot hold more than 256 types");
 
public:
    [[nodiscard]] TVariant()
    {
        static_assert(std::is_constructible_v<T>, "To default-initialize a TVariant, the first type in the parameter pack must be default constructible. Use FEmptyVariantState as the first type if none of the other types can be listed first.");
        ::new((void*)&UE::Core::Private::CastToStorage(*this).Storage) T();
        TypeIndex = 0;
    }
 
    template <
        typename U,
        typename... ArgTypes
        UE_REQUIRES(std::is_constructible_v<U, ArgTypes...>)
    >
    [[nodiscard]] explicit TVariant(TInPlaceType<U>&&, ArgTypes&&... Args)
    {
        constexpr SIZE_T Index = UE::Core::Private::TParameterPackTypeIndex<U, T, Ts...>::Value;
        static_assert(Index != (SIZE_T)-1, "The TVariant is not declared to hold the type being constructed");
 
        ::new((void*)&UE::Core::Private::CastToStorage(*this).Storage) U(Forward<ArgTypes>(Args)...);
        TypeIndex = (uint8)Index;
    }
 
    [[nodiscard]] TVariant(const TVariant& Other)
    {
        TypeIndex = Other.TypeIndex;
        UE::Core::Private::TCopyConstructorLookup<T, Ts...>::Construct(TypeIndex, &UE::Core::Private::CastToStorage(*this).Storage, &UE::Core::Private::CastToStorage(Other).Storage);
    }
 
    [[nodiscard]] TVariant(TVariant&& Other)
    {
        TypeIndex = Other.TypeIndex;
        UE::Core::Private::TMoveConstructorLookup<T, Ts...>::Construct(TypeIndex, &UE::Core::Private::CastToStorage(*this).Storage, &UE::Core::Private::CastToStorage(Other).Storage);
    }
 
    TVariant& operator=(const TVariant& Other)
    {
        if (&Other != this)
        {
            TVariant Temp = Other;
            Swap(Temp, *this);
        }
        return *this;
    }
 
    TVariant& operator=(TVariant&& Other)
    {
        if (&Other != this)
        {
            TVariant Temp = MoveTemp(Other);
            Swap(Temp, *this);
        }
        return *this;
    }
 
#if PLATFORM_COMPILER_SUPPORTS_CONSTRAINED_DESTRUCTORS
    ~TVariant()
        requires(!std::is_trivially_destructible_v<T> || (!std::is_trivially_destructible_v<Ts> || ...))
    {
        UE::Core::Private::TDestructorLookup<T, Ts...>::Destruct(TypeIndex, &UE::Core::Private::CastToStorage(*this).Storage);
    }
    ~TVariant()
        requires(std::is_trivially_destructible_v<T> && (std::is_trivially_destructible_v<Ts> && ...))
    = default;
#else
    // Defer to the storage as to how to destruct the elements
    ~TVariant() = default;
#endif
 
    template <typename U>
    [[nodiscard]] bool IsType() const
    {
        static_assert(UE::Core::Private::TParameterPackTypeIndex<U, T, Ts...>::Value != (SIZE_T)-1, "The TVariant is not declared to hold the type passed to IsType<>");
        return UE::Core::Private::TIsType<U, T, Ts...>::IsSame(TypeIndex);
    }
 
    template <typename U>
    [[nodiscard]] U& Get() UE_LIFETIMEBOUND
    {
        constexpr SIZE_T Index = UE::Core::Private::TParameterPackTypeIndex<U, T, Ts...>::Value;
        static_assert(Index != (SIZE_T)-1, "The TVariant is not declared to hold the type passed to Get<>");
 
        check(Index == TypeIndex);
        // The intermediate step of casting to void* is used to avoid warnings due to use of reinterpret_cast between related types if U and the storage class are related
        // This was specifically encountered when U derives from TAlignedBytes
        return *reinterpret_cast<U*>(reinterpret_cast<void*>(&UE::Core::Private::CastToStorage(*this).Storage));
    }
 
    template <typename U>
    [[nodiscard]] const U& Get() const UE_LIFETIMEBOUND
    {
        // Temporarily remove the const qualifier so we can implement Get in one location.
        return const_cast<TVariant*>(this)->template Get<U>();
    }
 
    template <typename U>
    const U& Get(const TIdentity_T<U>& DefaultValue UE_LIFETIMEBOUND) const UE_LIFETIMEBOUND
    {
        return IsType<U>() ? Get<U>() : DefaultValue;
    }
 
    template <typename U>
    [[nodiscard]] U* TryGet() UE_LIFETIMEBOUND
    {
        constexpr SIZE_T Index = UE::Core::Private::TParameterPackTypeIndex<U, T, Ts...>::Value;
        static_assert(Index != (SIZE_T)-1, "The TVariant is not declared to hold the type passed to TryGet<>");
        // The intermediate step of casting to void* is used to avoid warnings due to use of reinterpret_cast between related types if U and the storage class are related
        // This was specifically encountered when U derives from TAlignedBytes
        return Index == (SIZE_T)TypeIndex ? reinterpret_cast<U*>(reinterpret_cast<void*>(&UE::Core::Private::CastToStorage(*this).Storage)) : nullptr;
    }
 
    template <typename U>
    [[nodiscard]] const U* TryGet() const UE_LIFETIMEBOUND
    {
        // Temporarily remove the const qualifier so we can implement TryGet in one location.
        return const_cast<TVariant*>(this)->template TryGet<U>();
    }
 
    template <typename U>
    void Set(typename TIdentity<U>::Type&& Value)
    {
        Emplace<U>(MoveTemp(Value));
    }
 
    template <typename U>
    void Set(const typename TIdentity<U>::Type& Value)
    {
        Emplace<U>(Value);
    }
 
    template <
        typename U,
        typename... ArgTypes
        UE_REQUIRES(std::is_constructible_v<U, ArgTypes...>)
    >
    void Emplace(ArgTypes&&... Args)
    {
        constexpr SIZE_T Index = UE::Core::Private::TParameterPackTypeIndex<U, T, Ts...>::Value;
        static_assert(Index != (SIZE_T)-1, "The TVariant is not declared to hold the type passed to Emplace<>");
 
        UE::Core::Private::TDestructorLookup<T, Ts...>::Destruct(TypeIndex, &UE::Core::Private::CastToStorage(*this).Storage);
        ::new((void*)&UE::Core::Private::CastToStorage(*this).Storage) U(Forward<ArgTypes>(Args)...);
        TypeIndex = (uint8)Index;
    }
 
    template <typename U>
    [[nodiscard]] static constexpr SIZE_T IndexOfType()
    {
        constexpr SIZE_T Index = UE::Core::Private::TParameterPackTypeIndex<U, T, Ts...>::Value;
        static_assert(Index != (SIZE_T)-1, "The TVariant is not declared to hold the type passed to IndexOfType<>");
        return Index;
    }
 
    [[nodiscard]] SIZE_T GetIndex() const
    {
        return (SIZE_T)TypeIndex;
    }
 
    template <typename U>
    [[nodiscard]] explicit TVariant(UE::Core::Private::TUninitializedType<U>&&)
    {
        constexpr SIZE_T Index = UE::Core::Private::TParameterPackTypeIndex<U, T, Ts...>::Value;
        static_assert(Index != (SIZE_T)-1, "The TVariant is not declared to store the specified type");
        TypeIndex = (uint8)Index;
    }
 
private:
#if PLATFORM_COMPILER_SUPPORTS_CONSTRAINED_DESTRUCTORS
    uint8 TypeIndex;
#else
    using Super::TypeIndex;
#endif
};
 
template <
    typename Func,
    typename... Variants
    UE_REQUIRES((TIsVariant_V<std::decay_t<Variants>> && ...))
>
decltype(auto) Visit(Func&& Callable, Variants&&... Args)
{
    constexpr SIZE_T NumPermutations = (1 * ... * (TVariantSize_V<std::decay_t<Variants>>));
 
    return UE::Core::Private::VisitImpl(
        UE::Core::Private::EncodeIndices(Args...),
        Forward<Func>(Callable),
        TMakeIntegerSequence<SIZE_T, NumPermutations>{},
        TMakeIntegerSequence<SIZE_T, sizeof...(Variants)>{},
        Forward<Variants>(Args)...
    );
}
 
template <typename... Ts>
inline FArchive& operator<<(typename UE::Core::Private::TAlwaysFArchive<TVariant<Ts...>>::Type& Ar, TVariant<Ts...>& Variant)
{
    if (Ar.IsLoading())
    {
        uint8 Index;
        Ar << Index;
        check(Index < sizeof...(Ts));
 
        UE::Core::Private::TVariantLoadFromArchiveLookup<Ts...>::Load((SIZE_T)Index, Ar, Variant);
    }
    else
    {
        uint8 Index = (uint8)Variant.GetIndex();
        Ar << Index;
        Visit([&Ar](auto& StoredValue)
        {
            Ar << StoredValue;
        }, Variant);
    }
    return Ar;
}