WeakInterfacePtr.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/Object.h"
#include "UObject/WeakObjectPtr.h"
#include "Templates/Casts.h"
#include "ScriptInterface.h"
 
#include <type_traits>
 
template<class T>
struct TWeakInterfacePtr
{
    using ElementType = T;
    using UObjectType = TCopyQualifiersFromTo_T<T, UObject>;
 
    [[nodiscard]] UE_FORCEINLINE_HINT TWeakInterfacePtr() = default;
    [[nodiscard]] UE_FORCEINLINE_HINT TWeakInterfacePtr(const TWeakInterfacePtr& Other) = default;
    [[nodiscard]] UE_FORCEINLINE_HINT TWeakInterfacePtr(TWeakInterfacePtr&& Other) = default;
    UE_FORCEINLINE_HINT ~TWeakInterfacePtr() = default;
    UE_FORCEINLINE_HINT TWeakInterfacePtr& operator=(const TWeakInterfacePtr& Other) = default;
    UE_FORCEINLINE_HINT TWeakInterfacePtr& operator=(TWeakInterfacePtr&& Other) = default;
 
    [[nodiscard]] UE_FORCEINLINE_HINT TWeakInterfacePtr(TYPE_OF_NULLPTR) :
        ObjectInstance(nullptr)
    {
    }
 
    template<
        typename U
        UE_REQUIRES(std::is_convertible_v<U, TCopyQualifiersFromTo_T<U, UObject>*>)
    >
    [[nodiscard]] TWeakInterfacePtr(U&& Object)
    {
        InterfaceInstance = Cast<T>(ImplicitConv<TCopyQualifiersFromTo_T<U, UObject>*>(Object));
        if (InterfaceInstance != nullptr)
        {
            ObjectInstance = Object;
        }
    }
 
    [[nodiscard]] TWeakInterfacePtr(T* Interface)
    {
        ObjectInstance = Cast<UObject>(Interface);
        if (ObjectInstance != nullptr)
        {
            InterfaceInstance = Interface;
        }
    }
 
    [[nodiscard]] TWeakInterfacePtr(const TScriptInterface<T>& ScriptInterface)
    {
        ObjectInstance = ScriptInterface.GetObject();
        InterfaceInstance = ScriptInterface.GetInterface();
    }
 
    inline void Reset()
    {
        InterfaceInstance = nullptr;
        ObjectInstance.Reset();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool IsValid(bool bEvenIfPendingKill, bool bThreadsafeTest = false) const
    {
        return InterfaceInstance != nullptr && ObjectInstance.IsValid(bEvenIfPendingKill, bThreadsafeTest);
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool IsValid() const
    {
        return InterfaceInstance != nullptr && ObjectInstance.IsValid();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool IsStale(bool bEvenIfPendingKill = false, bool bThreadsafeTest = false) const
    {
        return InterfaceInstance != nullptr && ObjectInstance.IsStale(bEvenIfPendingKill, bThreadsafeTest);
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT T* Get() const
    {
        return IsValid() ? InterfaceInstance : nullptr;
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT UObjectType* GetObject() const
    {
        return ObjectInstance.Get();
    }
 
    [[nodiscard]] inline T& operator*() const
    {
        check(IsValid());
        return *InterfaceInstance;
    }
 
    [[nodiscard]] inline T* operator->() const
    {
        check(IsValid());
        return InterfaceInstance;
    }
 
    inline TWeakInterfacePtr<T>& operator=(T* Other)
    {
        *this = TWeakInterfacePtr<T>(Other);
        return *this;
    }
 
    inline TWeakInterfacePtr<T>& operator=(const TScriptInterface<T>& Other)
    {
        ObjectInstance = Other.GetObject();
        InterfaceInstance = (T*)Other.GetInterface();
        return *this;
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool operator==(const TWeakInterfacePtr<T>& Other) const
    {
        return InterfaceInstance == Other.InterfaceInstance;
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool operator!=(const TWeakInterfacePtr<T>& Other) const
    {
        return InterfaceInstance != Other.InterfaceInstance;
    }
 
    [[nodiscard]] FORCENOINLINE bool operator==(TYPE_OF_NULLPTR) const
    {
        return !IsValid();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool operator!=(TYPE_OF_NULLPTR) const
    {
        return !(*this == nullptr);
    }
 
    [[nodiscard]] inline TScriptInterface<T> ToScriptInterface() const
    {
        UObjectType* Object = ObjectInstance.Get();
        if (Object)
        {
            return TScriptInterface<T>(Object);
        }
 
        return TScriptInterface<T>();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT TWeakObjectPtr<UObjectType> GetWeakObjectPtr() const
    {
        return ObjectInstance;
    }
 
private:
    TWeakObjectPtr<UObjectType> ObjectInstance;
    T* InterfaceInstance = nullptr;
};