InlineValue.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Misc/AssertionMacros.h"
#include "HAL/UnrealMemory.h"
#include "Templates/MemoryOps.h"
#include "Templates/PointerIsConvertibleFromTo.h"
#include "Templates/Decay.h"
#include "Templates/TypeCompatibleBytes.h"
#include "Templates/UnrealTemplate.h"
 
template<typename BaseType, uint16 DesiredMaxInlineSize=64, uint8 DefaultAlignment=8>
class TInlineValue
{
public:
    TInlineValue()
        : bIsValid(false), bInline(true)
    {
    }
 
    template<
        typename T,
        typename = typename TEnableIf<TPointerIsConvertibleFromTo<typename TDecay<T>::Type, BaseType>::Value>::Type
    >
    TInlineValue(T&& In)
        : bIsValid(false)
    {
        InitializeFrom<typename TDecay<T>::Type>(Forward<T>(In));
    }
 
    template<typename... ArgTypes>
    TInlineValue(EInPlace, ArgTypes&&... Args)
        : bIsValid(false)
    {
        InitializeFrom<BaseType>(Forward<ArgTypes>(Args)...);
    }
 
    ~TInlineValue()
    {
        Reset();
    }
 
    TInlineValue(TInlineValue&& In)
        : bIsValid(false), bInline(true)
    {
        *this = MoveTemp(In);
    }
    TInlineValue& operator=(TInlineValue&& In)
    {
        Reset(MoveTemp(In));
        return *this;
    }
 
    TInlineValue(const TInlineValue& In) = delete;
    TInlineValue& operator=(const TInlineValue& In) = delete;
 
    template<typename T>
    typename TEnableIf<TPointerIsConvertibleFromTo<typename TDecay<T>::Type, BaseType>::Value, TInlineValue&>::Type operator=(T&& In)
    {
        *this = TInlineValue(Forward<T>(In));
        return *this;
    }
 
    void Reset(TInlineValue&& In)
    {
        Reset();
 
        if (In.bIsValid)
        {
            // Steal the object contained within 'In'
            bIsValid = true;
            In.bIsValid = false;
 
            bInline = In.bInline;
            Data = In.Data;
        }
    }
 
    void Reset()
    {
        if (bIsValid)
        {
            BaseType& Value = GetValue();
            // Set bIsValid immediately to avoid double-deletion on potential re-entry
            bIsValid = false;
            Value.~BaseType();
            ConditionallyDestroyAllocation();
        }
    }
 
    template <typename T, typename... ArgsType>
    inline void Emplace(ArgsType&&... Args)
    {
        static_assert(TPointerIsConvertibleFromTo<T, BaseType>::Value, "T must derive from BaseType.");
        Reset();
        InitializeFrom<T>(Forward<ArgsType>(Args)...);
    }
 
    UE_FORCEINLINE_HINT bool IsValid() const
    {
        return bIsValid;
    }
 
    inline BaseType& GetValue() const
    {
        checkf(bIsValid, TEXT("It is an error to call GetValue() on an invalid TInlineValue. Please either check IsValid() or use Get(DefaultValue) instead."));
        return bInline ? (BaseType&)Data : **((BaseType**)&Data);
    }
 
    UE_FORCEINLINE_HINT const BaseType& Get(const BaseType& Default) const
    {
        return bIsValid ? GetValue() : Default;
    }
 
    UE_FORCEINLINE_HINT BaseType* GetPtr(BaseType* Default = nullptr) const
    {
        return bIsValid ? &GetValue() : Default;
    }
 
    UE_FORCEINLINE_HINT BaseType&       operator*() const   { return GetValue(); }
    UE_FORCEINLINE_HINT BaseType*       operator->() const  { return &GetValue(); }
 
    void* Reserve(uint32 InSize, uint32 InAlignment)
    {
        Reset();
 
        bInline = InSize <= MaxInlineSize && InAlignment <= DefaultAlignment;
 
        ConditionallyAllocateObject(InSize, InAlignment);
        bIsValid = true;
        
        return &GetValue();
    }
 
private:
 
    template<typename T, typename... ArgsType>
    void InitializeFrom(ArgsType&&... Args)
    {
        bInline = sizeof(T) <= MaxInlineSize && alignof(T) <= DefaultAlignment;
 
        // Allocate the object
        ConditionallyAllocateObject(sizeof(T), alignof(T));
        bIsValid = true;
 
        // Placement new our value into the structure
        ::new((void*)&GetValue()) T(Forward<ArgsType>(Args)...);
 
        checkf((void*)&GetValue() == (BaseType*)((T*)&GetValue()), TEXT("TInlineValue cannot operate with multiple inheritance objects."));
    }
 
    void ConditionallyAllocateObject(uint32 Size, uint32 Alignment)
    {
        if (!bInline)
        {
            // We store a *ptr* to the data in the aligned bytes, when we allocate on the heap
            BaseType* Allocation = (BaseType*)FMemory::Malloc(Size, Alignment);
            *((BaseType**)&Data) = Allocation;
        }
    }
 
    void ConditionallyDestroyAllocation()
    {
        if (!bInline)
        {
            FMemory::Free(*((void**)&Data));
        }
    }
 
private:
    enum { MaxInlineSize = DesiredMaxInlineSize < sizeof(void*) ? sizeof(void*) : DesiredMaxInlineSize };
 
    TAlignedBytes<MaxInlineSize, DefaultAlignment> Data;
 
    bool bIsValid : 1;
 
    bool bInline : 1;
};
 
template<typename BaseType, typename UserType, uint8 MaxInlineSize = 64, uint8 DefaultAlignment = 8, typename... ArgsType>
TInlineValue<BaseType, MaxInlineSize, DefaultAlignment> MakeInlineValue(ArgsType... Args)
{
    return TInlineValue<BaseType, MaxInlineSize, DefaultAlignment>(UserType(Forward<ArgsType>(Args)...));
}