TypedElementHandle.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include <type_traits>
#include "CoreMinimal.h"
#include "Elements/Framework/TypedElementData.h"
 
#include "TypedElementHandle.generated.h"
 
struct FTypedElementHandle
{
public:
    FTypedElementHandle() = default;
 
    FTypedElementHandle(const FTypedElementHandle& InOther)
    {
        if (InOther)
        {
            Private_InitializeAddRef(*InOther.DataPtr);
        }
    }
 
    FTypedElementHandle& operator=(const FTypedElementHandle& InOther)
    {
        if (this != &InOther)
        {
            Private_DestroyReleaseRef();
 
            if (InOther)
            {
                Private_InitializeAddRef(*InOther.DataPtr);
            }
        }
        return *this;
    }
 
    FTypedElementHandle(FTypedElementHandle&& InOther)
        : DataPtr(InOther.DataPtr)
#if UE_TYPED_ELEMENT_HAS_REFTRACKING
        , ReferenceId(InOther.ReferenceId)
#endif  // UE_TYPED_ELEMENT_HAS_REFTRACKING
    {
        InOther.DataPtr = nullptr;
#if UE_TYPED_ELEMENT_HAS_REFTRACKING
        InOther.ReferenceId = INDEX_NONE;
#endif  // UE_TYPED_ELEMENT_HAS_REFTRACKING
        checkSlow(!InOther.IsSet());
    }
 
    FTypedElementHandle& operator=(FTypedElementHandle&& InOther)
    {
        if (this != &InOther)
        {
            Private_DestroyReleaseRef();
 
            DataPtr = InOther.DataPtr;
#if UE_TYPED_ELEMENT_HAS_REFTRACKING
            ReferenceId = InOther.ReferenceId;
#endif  // UE_TYPED_ELEMENT_HAS_REFTRACKING
 
            InOther.DataPtr = nullptr;
#if UE_TYPED_ELEMENT_HAS_REFTRACKING
            InOther.ReferenceId = INDEX_NONE;
#endif  // UE_TYPED_ELEMENT_HAS_REFTRACKING
            checkSlow(!InOther.IsSet());
        }
        return *this;
    }
 
    ~FTypedElementHandle()
    {
        Private_DestroyReleaseRef();
    }
 
    inline explicit operator bool() const
    {
        return IsSet();
    }
 
    inline bool IsSet() const
    {
        return DataPtr != nullptr;
    }
 
    inline void Release()
    {
        Private_DestroyReleaseRef();
    }
 
    inline const FTypedElementId& GetId() const
    {
        return DataPtr
            ? DataPtr->GetId()
            : FTypedElementId::Unset;
    }
 
    template <typename ElementDataType>
    inline bool IsDataOfType() const
    {
        return GetId().GetTypeId() == ElementDataType::StaticTypeId();
    }
 
    template <typename ElementDataType>
    const ElementDataType* GetData(const bool bSilent = false) const
    {
        if (!DataPtr)
        {
            if (!bSilent)
            {
                FFrame::KismetExecutionMessage(TEXT("Element handle data is null!"), ELogVerbosity::Error);
            }
            return nullptr;
        }
 
        if (!IsDataOfType<ElementDataType>())
        {
            if (!bSilent)
            {
                FFrame::KismetExecutionMessage(*FString::Printf(TEXT("Element handle data type is '%d', but '%d' (%s) was requested!"), GetId().GetTypeId(), ElementDataType::StaticTypeId(), *ElementDataType::StaticTypeName().ToString()), ELogVerbosity::Error);
            }
            return nullptr;
        }
 
        return static_cast<const ElementDataType*>(DataPtr->GetUntypedData());
    }
 
    template <typename ElementDataType>
    inline const ElementDataType& GetDataChecked() const
    {
        checkf(DataPtr, TEXT("Element handle data is null!"));
        checkf(IsDataOfType<ElementDataType>(), TEXT("Element handle data type is '%d', but '%d' (%s) was requested!"), GetId().GetTypeId(), ElementDataType::StaticTypeId(), *ElementDataType::StaticTypeName().ToString());
        return *static_cast<const ElementDataType*>(DataPtr->GetUntypedData());
    }
    
    FTypedElementId AcquireId() const
    {
        FTypedElementId ElementId;
        if (IsSet())
        {
            DataPtr->AddRef(/*bCanTrackReference*/false); // Cannot track element ID references as we have no space to store the reference ID
            ElementId.Private_InitializeNoRef(DataPtr->GetId().GetTypeId(), DataPtr->GetId().GetElementId());
        }
        return ElementId;
    }
 
    void ReleaseId(FTypedElementId& InOutElementId) const
    {
        checkf(InOutElementId == GetId(), TEXT("Element ID does not match this handle!"));
        if (InOutElementId)
        {
            DataPtr->ReleaseRef(INDEX_NONE); // Cannot track element ID references as we have no space to store the reference ID
            InOutElementId.Private_DestroyNoRef();
        }
    }
 
    inline friend bool operator==(const FTypedElementHandle& InLHS, const FTypedElementHandle& InRHS)
    {
        return InLHS.DataPtr == InRHS.DataPtr;
    }
 
    inline friend bool operator!=(const FTypedElementHandle& InLHS, const FTypedElementHandle& InRHS)
    {
        return !(InLHS == InRHS);
    }
 
    friend inline uint32 GetTypeHash(const FTypedElementHandle& InElementHandle)
    {
        return GetTypeHash(InElementHandle.GetId());
    }
 
    inline void Private_InitializeNoRef(const FTypedElementInternalData& InData)
    {
        DataPtr = &InData;
    }
 
    inline void Private_InitializeAddRef(const FTypedElementInternalData& InData)
    {
        Private_InitializeNoRef(InData);
        RegisterRef();
    }
 
    inline void Private_DestroyNoRef()
    {
        DataPtr = nullptr;
#if UE_TYPED_ELEMENT_HAS_REFTRACKING
        ReferenceId = INDEX_NONE;
#endif  // UE_TYPED_ELEMENT_HAS_REFTRACKING
    }
 
    inline void Private_DestroyReleaseRef()
    {
        UnregisterRef();
        Private_DestroyNoRef();
    }
 
    inline const FTypedElementInternalData* Private_GetInternalData() const
    {
        return DataPtr;
    }
 
private:
    inline void RegisterRef()
    {
        if (DataPtr)
        {
#if !UE_TYPED_ELEMENT_HAS_REFTRACKING
            FTypedElementReferenceId ReferenceId = INDEX_NONE;
#endif  // !UE_TYPED_ELEMENT_HAS_REFTRACKING
            ReferenceId = DataPtr->AddRef(/*bCanTrackReference*/true);
        }
    }
 
    inline void UnregisterRef()
    {
        if (DataPtr)
        {
#if !UE_TYPED_ELEMENT_HAS_REFTRACKING
            FTypedElementReferenceId ReferenceId = INDEX_NONE;
#endif  // !UE_TYPED_ELEMENT_HAS_REFTRACKING
            DataPtr->ReleaseRef(ReferenceId);
        }
    }
 
    const FTypedElementInternalData* DataPtr = nullptr;
#if UE_TYPED_ELEMENT_HAS_REFTRACKING
    FTypedElementReferenceId ReferenceId = INDEX_NONE;
#endif  // UE_TYPED_ELEMENT_HAS_REFTRACKING
};
 
template <typename BaseInterfaceType>
struct TTypedElementBase : public FTypedElementHandle
{
public:
    TTypedElementBase() = default;
 
    TTypedElementBase(const TTypedElementBase&) = default;
    TTypedElementBase& operator=(const TTypedElementBase&) = default;
 
    TTypedElementBase(TTypedElementBase&& InOther)
        : FTypedElementHandle(MoveTemp(InOther))
        , InterfacePtr(InOther.InterfacePtr)
    {
        InOther.InterfacePtr = nullptr;
        checkSlow(!InOther.IsSet());
    }
 
    TTypedElementBase& operator=(TTypedElementBase&& InOther)
    {
        if (this != &InOther)
        {
            FTypedElementHandle::operator=(MoveTemp(InOther));
            InterfacePtr = InOther.InterfacePtr;
 
            InOther.InterfacePtr = nullptr;
            checkSlow(!InOther.IsSet());
        }
        return *this;
    }
 
    ~TTypedElementBase()
    {
        Private_DestroyReleaseRef();
    }
 
    inline explicit operator bool() const
    {
        return IsSet();
    }
 
    inline bool IsSet() const
    {
        return FTypedElementHandle::IsSet()
            && InterfacePtr;
    }
 
    inline void Release()
    {
        Private_DestroyReleaseRef();
    }
 
    inline BaseInterfaceType* GetInterface() const
    {
        return InterfacePtr;
    }
 
    template <typename U = BaseInterfaceType, std::enable_if_t<!std::is_void<U>::value>* = nullptr>
    inline U& GetInterfaceChecked() const
    {
        static_assert(std::is_same<U, BaseInterfaceType>::value, "Don't explicitly specify U!");
        checkf(InterfacePtr, TEXT("Interface is null!"));
        return *InterfacePtr;
    }
 
    inline friend bool operator==(const TTypedElementBase& InLHS, const TTypedElementBase& InRHS)
    {
        return static_cast<const FTypedElementHandle&>(InLHS) == static_cast<const FTypedElementHandle&>(InRHS)
            && InLHS.InterfacePtr == InRHS.InterfacePtr;
    }
 
    inline friend bool operator!=(const TTypedElementBase& InLHS, const TTypedElementBase& InRHS)
    {
        return !(InLHS == InRHS);
    }
 
    friend inline uint32 GetTypeHash(const TTypedElementBase& InElement)
    {
        return HashCombine(GetTypeHash(static_cast<const FTypedElementHandle&>(InElement)), GetTypeHash(InElement.InterfacePtr));
    }
 
    inline void Private_InitializeNoRef(const FTypedElementInternalData& InData, BaseInterfaceType* InInterfacePtr)
    {
        FTypedElementHandle::Private_InitializeNoRef(InData);
        InterfacePtr = InInterfacePtr;
    }
 
    inline void Private_InitializeAddRef(const FTypedElementInternalData& InData, BaseInterfaceType* InInterfacePtr)
    {
        FTypedElementHandle::Private_InitializeAddRef(InData);
        InterfacePtr = InInterfacePtr;
    }
 
    inline void Private_DestroyNoRef()
    {
        FTypedElementHandle::Private_DestroyNoRef();
        InterfacePtr = nullptr;
    }
 
    inline void Private_DestroyReleaseRef()
    {
        FTypedElementHandle::Private_DestroyReleaseRef();
        InterfacePtr = nullptr;
    }
 
protected:
    BaseInterfaceType* InterfacePtr = nullptr;
};
 
template <typename BaseInterfaceType>
struct TTypedElement : public TTypedElementBase<BaseInterfaceType>
{
};
 
// The typed element InterfacePtr will points toward the vtable of the interface
using FTypedElement = TTypedElement<void>;
 
template <typename ElementDataType>
struct TTypedElementOwner
{
public:
    TTypedElementOwner() = default;
 
    TTypedElementOwner(const TTypedElementOwner&) = delete;
    TTypedElementOwner& operator=(const TTypedElementOwner&) = delete;
 
    TTypedElementOwner(TTypedElementOwner&& InOther)
        : DataPtr(InOther.DataPtr)
    {
        InOther.DataPtr = nullptr;
        checkSlow(!InOther.IsSet());
    }
 
    TTypedElementOwner& operator=(TTypedElementOwner&& InOther)
    {
        if (this != &InOther)
        {
            DataPtr = InOther.DataPtr;
 
            InOther.DataPtr = nullptr;
            checkSlow(!InOther.IsSet());
        }
        return *this;
    }
 
    ~TTypedElementOwner()
    {
        checkf(!IsSet(), TEXT("Element owner was still set during destruction! This will leak an element, and you should destroy this element prior to destruction!"));
    }
 
    inline explicit operator bool() const
    {
        return IsSet();
    }
 
    inline bool IsSet() const
    {
        return DataPtr != nullptr;
    }
 
    inline const FTypedElementId& GetId() const
    {
        return DataPtr
            ? DataPtr->GetId()
            : FTypedElementId::Unset;
    }
 
    template <typename U = ElementDataType, std::enable_if_t<!std::is_void<U>::value>* = nullptr>
    inline U* GetData() const
    {
        static_assert(std::is_same<U, ElementDataType>::value, "Don't explicitly specify U!");
        return DataPtr
            ? &DataPtr->GetMutableData()
            : nullptr;
    }
 
    template <typename U = ElementDataType, std::enable_if_t<!std::is_void<U>::value>* = nullptr>
    inline U& GetDataChecked() const
    {
        static_assert(std::is_same<U, ElementDataType>::value, "Don't explicitly specify U!");
        checkf(DataPtr, TEXT("Handle data is null!"));
        return DataPtr->GetMutableData();
    }
 
    FTypedElementId AcquireId() const
    {
        FTypedElementId ElementId;
        if (IsSet())
        {
            DataPtr->AddRef(/*bCanTrackReference*/false); // Cannot track element ID references as we have no space to store the reference ID
            ElementId.Private_InitializeNoRef(DataPtr->GetId().GetTypeId(), DataPtr->GetId().GetElementId());
        }
        return ElementId;
    }
 
    void ReleaseId(FTypedElementId& InOutElementId) const
    {
        checkf(InOutElementId == GetId(), TEXT("Element ID does not match this owner!"));
        if (InOutElementId)
        {
            DataPtr->ReleaseRef(INDEX_NONE); // Cannot track element ID references as we have no space to store the reference ID
            InOutElementId.Private_DestroyNoRef();
        }
    }
 
    FTypedElementHandle AcquireHandle() const
    {
        FTypedElementHandle ElementHandle;
        if (IsSet())
        {
            ElementHandle.Private_InitializeAddRef(*DataPtr);
        }
        return ElementHandle;
    }
 
    void ReleaseHandle(FTypedElementHandle& InOutElementHandle) const
    {
        checkf(InOutElementHandle.GetId() == GetId(), TEXT("Element handle ID does not match this owner!"));
        InOutElementHandle.Release();
    }
 
    inline friend bool operator==(const TTypedElementOwner& InLHS, const TTypedElementOwner& InRHS)
    {
        return InLHS.DataPtr == InRHS.DataPtr;
    }
 
    inline friend bool operator!=(const TTypedElementOwner& InLHS, const TTypedElementOwner& InRHS)
    {
        return !(InLHS == InRHS);
    }
 
    friend inline uint32 GetTypeHash(const TTypedElementOwner& InElementOwner)
    {
        return GetTypeHash(InElementOwner.GetId());
    }
 
    inline void Private_InitializeNoRef(TTypedElementInternalData<ElementDataType>& InData)
    {
        DataPtr = &InData;
    }
 
    inline void Private_InitializeAddRef(TTypedElementInternalData<ElementDataType>& InData)
    {
        Private_InitializeNoRef(InData);
        RegisterRef();
    }
 
    inline void Private_DestroyNoRef()
    {
        DataPtr = nullptr;
#if UE_TYPED_ELEMENT_HAS_REFTRACKING
        ReferenceId = INDEX_NONE;
#endif  // UE_TYPED_ELEMENT_HAS_REFTRACKING
    }
 
    inline void Private_DestroyReleaseRef()
    {
        UnregisterRef();
        Private_DestroyNoRef();
    }
 
    inline const TTypedElementInternalData<ElementDataType>* Private_GetInternalData() const
    {
        return DataPtr;
    }
 
private:
    inline void RegisterRef()
    {
        if (DataPtr)
        {
#if !UE_TYPED_ELEMENT_HAS_REFTRACKING
            FTypedElementReferenceId ReferenceId = INDEX_NONE;
#endif  // !UE_TYPED_ELEMENT_HAS_REFTRACKING
            ReferenceId = DataPtr->AddRef(/*bCanTrackReference*/true);
        }
    }
 
    inline void UnregisterRef()
    {
        if (DataPtr)
        {
#if !UE_TYPED_ELEMENT_HAS_REFTRACKING
            FTypedElementReferenceId ReferenceId = INDEX_NONE;
#endif  // !UE_TYPED_ELEMENT_HAS_REFTRACKING
            DataPtr->ReleaseRef(ReferenceId);
        }
    }
 
    TTypedElementInternalData<ElementDataType>* DataPtr = nullptr;
#if UE_TYPED_ELEMENT_HAS_REFTRACKING
    FTypedElementReferenceId ReferenceId = INDEX_NONE;
#endif  // UE_TYPED_ELEMENT_HAS_REFTRACKING
};
using FTypedElementOwner = TTypedElementOwner<void>;
 
 
USTRUCT(BlueprintType)
struct FScriptTypedElementHandle
{
    GENERATED_BODY()
public:
 
    FScriptTypedElementHandle() = default;
 
    FScriptTypedElementHandle(const FScriptTypedElementHandle& InOther)
        : InternalData(InOther.InternalData)
    {
    }
 
    FScriptTypedElementHandle(FScriptTypedElementHandle&& InOther)
        : InternalData(MoveTemp(InOther.InternalData))
    {
    }
 
    FScriptTypedElementHandle& operator=(const FScriptTypedElementHandle& InOther)
    {
        InternalData = InOther.InternalData;
        return *this;
    }
 
    FScriptTypedElementHandle& operator=(FScriptTypedElementHandle&& InOther)
    {
        InternalData = MoveTemp(InOther.InternalData);
        return *this;
    }
 
    inline bool operator==(const FScriptTypedElementHandle& InOther) const
    {
        return InternalData == InOther.InternalData;
    }
 
    inline bool operator!=(const FScriptTypedElementHandle& InOther) const
    {
        return !(*this == InOther);
    }
 
    inline explicit operator bool() const
    {
        return IsSet();
    }
 
    inline bool IsSet() const
    {
        return InternalData.IsSet();
    }
 
    inline void Release()
    {
        InternalData.Release();
    }
 
    inline void Private_Initialize(FScriptTypedElementInternalDataPtr&& InInternalData)
    {
        InternalData = InInternalData;
    }
 
    inline const FTypedElementId& GetId() const
    {
        return InternalData.GetId();
    }
 
    FTypedElementHandle GetTypedElementHandle() const
    {
        FTypedElementHandle Handle;
        if (FTypedElementInternalData* TypedElementInternalData = InternalData.GetInternalData())
        {
            Handle.Private_InitializeAddRef(*TypedElementInternalData);
        }
 
        return Handle;
    }
 
private:
    FScriptTypedElementInternalDataPtr InternalData;
};
 
UCLASS()
class UTypedElementHandleLibrary : public UObject
{
    GENERATED_BODY()
 
public:
    UFUNCTION(BlueprintPure, Category="TypedElementFramework|Handle", meta=(ScriptMethod, ScriptOperator="bool"))
    static bool IsSet(const FScriptTypedElementHandle& ElementHandle)
    {
        return ElementHandle.IsSet();
    }
 
    UFUNCTION(BlueprintCallable, Category="TypedElementFramework|Handle", meta=(ScriptMethod))
    static void Release(UPARAM(ref) FScriptTypedElementHandle& ElementHandle)
    {
        ElementHandle.Release();
    }
 
    UFUNCTION(BlueprintPure, Category="TypedElementFramework|Handle", meta=(DisplayName="Equal (TypedElementHandle)", CompactNodeTitle="==", Keywords="== equal", ScriptMethod, ScriptOperator="=="))
    static bool Equal(const FScriptTypedElementHandle& LHS, const FScriptTypedElementHandle& RHS)
    {
        return LHS == RHS;
    }
 
    UFUNCTION(BlueprintPure, Category="TypedElementFramework|Handle", meta=(DisplayName="NotEqual (TypedElementHandle)", CompactNodeTitle="!=", Keywords="!= not equal", ScriptMethod, ScriptOperator="!="))
    static bool NotEqual(const FScriptTypedElementHandle& LHS, const FScriptTypedElementHandle& RHS)
    {
        return LHS != RHS;
    }
};