WeakObjectPtrTemplates.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Templates/LosesQualifiersFromTo.h"
#include "Templates/Requires.h"
#include "Containers/Map.h"
#include "Misc/UEOps.h"
#include "UObject/WeakObjectPtrTemplatesFwd.h"
#include "UObject/StrongObjectPtrTemplatesFwd.h"
 
#include <type_traits>
 
struct FFieldPath;
struct FWeakObjectPtr;
struct FUObjectItem;
struct FRemoteObjectId;
 
template<class T, class TWeakObjectPtrBase>
struct TWeakObjectPtr
{
    friend struct FFieldPath;
 
    template <class, class>
    friend struct TWeakObjectPtr;
 
    friend struct FFieldPath;
 
    // Although templated, these parameters are not intended to be anything other than the default,
    // and are only templates for module organization reasons.
    static_assert(std::is_same_v<TWeakObjectPtrBase*, FWeakObjectPtr*>, "TWeakObjectPtrBase should not be overridden");
 
public:
    using ElementType = T;
    
    [[nodiscard]] TWeakObjectPtr() = default;
    [[nodiscard]] TWeakObjectPtr(const TWeakObjectPtr&) = default;
    TWeakObjectPtr& operator=(const TWeakObjectPtr&) = default;
    ~TWeakObjectPtr() = default;
 
    [[nodiscard]] FORCEINLINE TWeakObjectPtr(TYPE_OF_NULLPTR) :
        WeakPtr((UObject*)nullptr)
    {
    }
 
    template <
        typename U
        UE_REQUIRES(std::is_convertible_v<U, T*>)
    >
    [[nodiscard]] FORCEINLINE TWeakObjectPtr(U Object) :
        WeakPtr((const UObject*)Object)
    {
        // This static assert is in here rather than in the body of the class because we want
        // to be able to define TWeakObjectPtr<UUndefinedClass>.
        static_assert(std::is_convertible_v<T*, const volatile UObject*>, "TWeakObjectPtr can only be constructed with UObject types");
    }
 
    template <
        typename OtherT
        UE_REQUIRES(std::is_convertible_v<OtherT*, T*>)
    >
    [[nodiscard]] FORCEINLINE TWeakObjectPtr(const TWeakObjectPtr<OtherT, TWeakObjectPtrBase>& Other) :
        WeakPtr(Other.WeakPtr) // we do a C-style cast to private base here to avoid clang 3.6.0 compilation problems with friend declarations
    {
    }
 
#if UE_WITH_REMOTE_OBJECT_HANDLE
    explicit TWeakObjectPtr(const FRemoteObjectId& RemoteId)
        : WeakPtr(RemoteId)
    {
    }
#endif
 
    FORCEINLINE void Reset()
    {
        WeakPtr.Reset();
    }
 
    template <
        typename U
        UE_REQUIRES(!TLosesQualifiersFromTo_V<U, T>)
    >
    FORCEINLINE TWeakObjectPtr& operator=(U* Object)
    {
        T* TempObject = Object;
        WeakPtr = TempObject;
        return *this;
    }
 
    template <
        typename OtherT
        UE_REQUIRES(std::is_convertible_v<OtherT*, T*>)
    >
    FORCEINLINE TWeakObjectPtr& operator=(const TWeakObjectPtr<OtherT, TWeakObjectPtrBase>& Other)
    {
        WeakPtr = Other.WeakPtr;
 
        return *this;
    }
 
    [[nodiscard]] FORCEINLINE T* Get(bool bEvenIfPendingKill) const
    {
        return (T*)WeakPtr.Get(bEvenIfPendingKill);
    }
 
    [[nodiscard]] FORCEINLINE T* Get(/*bool bEvenIfPendingKill = false*/) const
    {
        return (T*)WeakPtr.Get();
    }
 
    [[nodiscard]] FORCEINLINE TStrongObjectPtr<T> Pin(bool bEvenIfPendingKill) const
    {
        TStrongObjectPtr<T> StrongPtr;
        StrongPtr.Attach((T*)WeakPtr.Pin(bEvenIfPendingKill).Detach());
        return StrongPtr;
    }
 
    [[nodiscard]] FORCEINLINE TStrongObjectPtr<T> Pin(/*bool bEvenIfPendingKill = false*/) const
    {
        TStrongObjectPtr<T> StrongPtr;
        StrongPtr.Attach((T*)WeakPtr.Pin().Detach());
        return StrongPtr;
    }
 
    [[nodiscard]] FORCEINLINE TStrongObjectPtr<T> TryPin(bool& bOutPinValid, bool bEvenIfPendingKill) const
    {
        TStrongObjectPtr<T> StrongPtr;
        StrongPtr.Attach((T*)WeakPtr.TryPin(bOutPinValid, bEvenIfPendingKill).Detach());
        return StrongPtr;
    }
 
    [[nodiscard]] FORCEINLINE TStrongObjectPtr<T> TryPin(bool& bOutPinValid /*, bool bEvenIfPendingKill = false */ ) const
    {
        return TryPin(bOutPinValid, false);
    }
 
    [[nodiscard]] FORCEINLINE T* GetEvenIfUnreachable() const
    {
        return (T*)WeakPtr.GetEvenIfUnreachable();
    }
 
    [[nodiscard]] FORCEINLINE T& operator*() const
    {
        return *Get();
    }
 
    [[nodiscard]] FORCEINLINE T* operator->() const
    {
        return Get();
    }
 
    // This is explicitly not added to avoid resolving weak pointers too often - use Get() once in a function.
    explicit operator bool() const = delete;
 
    explicit operator TWeakObjectPtrBase() const
    {
        return WeakPtr;
    }
 
    [[nodiscard]] FORCEINLINE bool IsValid(bool bEvenIfPendingKill, bool bThreadsafeTest = false) const
    {
        return WeakPtr.IsValid(bEvenIfPendingKill, bThreadsafeTest);
    }
 
    [[nodiscard]] FORCEINLINE bool IsValid(/*bool bEvenIfPendingKill = false, bool bThreadsafeTest = false*/) const
    {
        return WeakPtr.IsValid();
    }
 
    [[nodiscard]] FORCEINLINE bool IsStale(bool bIncludingIfPendingKill = true, bool bThreadsafeTest = false) const
    {
        return WeakPtr.IsStale(bIncludingIfPendingKill, bThreadsafeTest);
    }
    
    [[nodiscard]] FORCEINLINE bool IsExplicitlyNull() const
    {
        return WeakPtr.IsExplicitlyNull();
    }
 
    [[nodiscard]] FORCEINLINE bool HasSameIndexAndSerialNumber(const TWeakObjectPtr& Other) const
    {
        return WeakPtr.HasSameIndexAndSerialNumber(Other.WeakPtr);
    }
 
    template <
        typename OtherT
        UE_REQUIRES(UE_REQUIRES_EXPR((T*)nullptr == (OtherT*)nullptr))
    >
    [[nodiscard]] FORCEINLINE bool HasSameIndexAndSerialNumber(const TWeakObjectPtr<OtherT, TWeakObjectPtrBase>& Other) const
    {
        return WeakPtr.HasSameIndexAndSerialNumber(Other.WeakPtr);
    }
 
#if UE_WITH_REMOTE_OBJECT_HANDLE
    FORCEINLINE bool HasSameObject(const UObject* Other) const
    {
        return WeakPtr.HasSameObject(Other);
    }
 
    FORCEINLINE auto GetRemoteId() const
    {
        return WeakPtr.GetRemoteId();
    }
#endif // UE_WITH_REMOTE_OBJECT_HANDLE
 
    [[nodiscard]] FORCEINLINE bool IsRemote() const
    {
        return WeakPtr.IsRemote();
    }
 
    FORCEINLINE void Serialize(FArchive& Ar)
    {
        Ar << WeakPtr;
    }
 
    [[nodiscard]] FORCEINLINE uint32 GetWeakPtrTypeHash() const
    {
        return WeakPtr.GetTypeHash();
    }
 
    template <typename RhsT, typename = decltype((T*)nullptr == (RhsT*)nullptr)>
    [[nodiscard]] FORCENOINLINE bool UEOpEquals(const TWeakObjectPtr<RhsT, TWeakObjectPtrBase>& Rhs) const
    {
        return WeakPtr == Rhs.WeakPtr;
    }
 
    template <typename RhsT, typename = decltype((T*)nullptr == (RhsT*)nullptr)>
    [[nodiscard]] FORCENOINLINE bool UEOpEquals(const RhsT* Rhs) const
    {
        // NOTE: this constructs a TWeakObjectPtrBase, which has some amount of overhead, so this may not be an efficient operation
        return WeakPtr == TWeakObjectPtrBase(Rhs);
    }
 
    [[nodiscard]] FORCENOINLINE bool UEOpEquals(TYPE_OF_NULLPTR) const
    {
        return !IsValid();
    }
 
#if !PLATFORM_COMPILER_HAS_GENERATED_COMPARISON_OPERATORS
    template <typename RhsT, typename = decltype((T*)nullptr != (RhsT*)nullptr)>
    [[nodiscard]] FORCEINLINE bool operator!=(const TWeakObjectPtr<RhsT, TWeakObjectPtrBase>& Rhs) const
    {
        return !(*this == Rhs);
    }
 
    template <typename RhsT, typename = decltype((T*)nullptr != (RhsT*)nullptr)>
    [[nodiscard]] FORCEINLINE bool operator!=(const RhsT* Rhs) const
    {
        return !(*this == Rhs);
    }
 
    [[nodiscard]] FORCEINLINE bool operator!=(TYPE_OF_NULLPTR) const
    {
        return !(*this == nullptr);
    }
#endif
 
private:
    FORCEINLINE FUObjectItem* Internal_GetObjectItem() const
    {
        return WeakPtr.Internal_GetObjectItem();
    }
 
    TWeakObjectPtrBase WeakPtr;
};
 
template <typename T>
TWeakObjectPtr(T*) -> TWeakObjectPtr<T>;
 
template <typename T>
TWeakObjectPtr(const TWeakObjectPtr<T>&) -> TWeakObjectPtr<T>;
 
// Helper function which deduces the type of the initializer
template <typename T>
[[nodiscard]] FORCEINLINE TWeakObjectPtr<T> MakeWeakObjectPtr(T* Ptr)
{
    return TWeakObjectPtr<T>(Ptr);
}
 
 
template <typename ElementType, bool bInAllowDuplicateKeys = false>
struct TWeakObjectPtrSetKeyFuncs : DefaultKeyFuncs<ElementType, bInAllowDuplicateKeys>
{
    typedef typename DefaultKeyFuncs<ElementType, bInAllowDuplicateKeys>::KeyInitType KeyInitType;
 
    static FORCEINLINE bool Matches(KeyInitType A, KeyInitType B)
    {
        return A.HasSameIndexAndSerialNumber(B);
    }
 
    static FORCEINLINE uint32 GetKeyHash(KeyInitType Key)
    {
        return GetTypeHash(Key);
    }
};
 
template <typename KeyType, typename ValueType, bool bInAllowDuplicateKeys = false>
struct TWeakObjectPtrMapKeyFuncs : public TDefaultMapKeyFuncs<KeyType, ValueType, bInAllowDuplicateKeys>
{
    typedef typename TDefaultMapKeyFuncs<KeyType, ValueType, bInAllowDuplicateKeys>::KeyInitType KeyInitType;
 
    static FORCEINLINE bool Matches(KeyInitType A, KeyInitType B)
    {
        return A.HasSameIndexAndSerialNumber(B);
    }
 
    static FORCEINLINE uint32 GetKeyHash(KeyInitType Key)
    {
        return GetTypeHash(Key);
    }
};
 
template <typename T>
struct TCallTraits<TWeakObjectPtr<T>> : public TCallTraitsBase<TWeakObjectPtr<T>>
{
    using ConstPointerType = TWeakObjectPtr<const T>;
};
 
template<typename DestArrayType, typename SourceArrayType>
void CopyFromWeakArray(DestArrayType& Dest, const SourceArrayType& Src)
{
    const int32 Count = Src.Num();
    Dest.Empty(Count);
    for (int32 Index = 0; Index < Count; Index++)
    {
        if (auto Value = Src[Index].Get())
        {
            Dest.Add(Value);
        }
    }
}
 
template<typename DestArrayType, typename SourceArrayType>
void CopyToWeakArray(DestArrayType& Dest, const SourceArrayType& Src)
{
    const int32 Count = Src.Num();
    Dest.Empty(Count);
    for (int32 Index = 0; Index < Count; Index++)
    {
        if (auto* Value = Src[Index])
        {
            Dest.Add(Value);
        }
    }
}
 
template <typename T>
[[nodiscard]] FORCEINLINE uint32 GetTypeHash(const TWeakObjectPtr<T>& WeakObjectPtr)
{
    return WeakObjectPtr.GetWeakPtrTypeHash();
}
 
 
template<class T, class TWeakObjectPtrBase>
FArchive& operator<<( FArchive& Ar, TWeakObjectPtr<T, TWeakObjectPtrBase>& WeakObjectPtr )
{
    WeakObjectPtr.Serialize(Ar);
    return Ar;
}
 
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_4
#include "Templates/AndOrNot.h"
#include "Templates/IsPointer.h"
#include "Templates/PointerIsConvertibleFromTo.h"
#endif