WeakFieldPtr.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    WeakFieldPtr.h: Weak pointer to FField
=============================================================================*/
 
#pragma once
 
#include "Templates/Requires.h"
#include "UObject/WeakObjectPtrTemplates.h"
#include "UObject/WeakObjectPtr.h"
#include "UObject/FieldPath.h"
 
#include <type_traits>
 
template<class T>
struct TWeakFieldPtr;
 
template <
    typename LhsType,
    typename RhsType
    UE_REQUIRES(UE_REQUIRES_EXPR((LhsType*)nullptr == (RhsType*)nullptr))
>
bool operator==(const TWeakFieldPtr<LhsType>& Lhs, const TWeakFieldPtr<RhsType>& Rhs);
 
template <
    typename LhsType,
    typename RhsType
    UE_REQUIRES(UE_REQUIRES_EXPR((LhsType*)nullptr == (const RhsType*)nullptr))
>
bool operator==(const TWeakFieldPtr<LhsType>& Lhs, const RhsType* Rhs);
 
template <
    typename LhsType,
    typename RhsType
    UE_REQUIRES(UE_REQUIRES_EXPR((const LhsType*)nullptr == (RhsType*)nullptr))
>
bool operator==(const LhsType* Lhs, const TWeakFieldPtr<RhsType>& Rhs);
 
#if !PLATFORM_COMPILER_HAS_GENERATED_COMPARISON_OPERATORS
template <
    typename LhsType,
    typename RhsType
    UE_REQUIRES(UE_REQUIRES_EXPR((LhsType*)nullptr != (RhsType*)nullptr))
>
bool operator!=(const TWeakFieldPtr<LhsType>& Lhs, const TWeakFieldPtr<RhsType>& Rhs);
 
template <
    typename LhsType,
    typename RhsType
    UE_REQUIRES(UE_REQUIRES_EXPR((LhsType*)nullptr != (const RhsType*)nullptr))
>
bool operator!=(const TWeakFieldPtr<LhsType>& Lhs, const RhsType* Rhs);
 
template <
    typename LhsType,
    typename RhsType
    UE_REQUIRES(UE_REQUIRES_EXPR((const LhsType*)nullptr != (RhsType*)nullptr))
>
bool operator!=(const LhsType* Lhs, const TWeakFieldPtr<RhsType>& Rhs);
#endif
 
template<class T>
struct TWeakFieldPtr
{
    template <typename>
    friend struct TWeakFieldPtr;
 
    template <
        typename LhsType,
        typename RhsType
        UE_REQUIRES_FRIEND(UE_REQUIRES_EXPR((LhsType*)nullptr == (RhsType*)nullptr))
    >
    friend bool operator==(const TWeakFieldPtr<LhsType>& Lhs, const TWeakFieldPtr<RhsType>& Rhs);
 
    template <
        typename LhsType,
        typename RhsType
        UE_REQUIRES_FRIEND(UE_REQUIRES_EXPR((LhsType*)nullptr == (const RhsType*)nullptr))
    >
    friend bool operator==(const TWeakFieldPtr<LhsType>& Lhs, const RhsType* Rhs);
 
    template <
        typename LhsType,
        typename RhsType
        UE_REQUIRES_FRIEND(UE_REQUIRES_EXPR((const LhsType*)nullptr == (RhsType*)nullptr))
    >
    friend bool operator==(const LhsType* Lhs, const TWeakFieldPtr<RhsType>& Rhs);
 
#if !PLATFORM_COMPILER_HAS_GENERATED_COMPARISON_OPERATORS
    template <
        typename LhsType,
        typename RhsType
        UE_REQUIRES_FRIEND(UE_REQUIRES_EXPR((LhsType*)nullptr != (RhsType*)nullptr))
    >
    friend bool operator!=(const TWeakFieldPtr<LhsType>& Lhs, const TWeakFieldPtr<RhsType>& Rhs);
 
    template <
        typename LhsType,
        typename RhsType
        UE_REQUIRES_FRIEND(UE_REQUIRES_EXPR((LhsType*)nullptr != (const RhsType*)nullptr))
    >
    friend bool operator!=(const TWeakFieldPtr<LhsType>& Lhs, const RhsType* Rhs);
 
    template <
        typename LhsType,
        typename RhsType
        UE_REQUIRES_FRIEND(UE_REQUIRES_EXPR((const LhsType*)nullptr != (RhsType*)nullptr))
    >
    friend bool operator!=(const LhsType* Lhs, const TWeakFieldPtr<RhsType>& Rhs);
#endif
 
private:
 
    // These exists only to disambiguate the two constructors below
    enum EDummy1 { Dummy1 };
 
    TWeakObjectPtr<UObject> Owner;
    mutable TFieldPath<T> Field;
 
public:
    using ElementType = T;
    
    TWeakFieldPtr() = default;
    TWeakFieldPtr(const TWeakFieldPtr&) = default;
    TWeakFieldPtr& operator=(const TWeakFieldPtr&) = default;
    ~TWeakFieldPtr() = default;
 
    inline TWeakFieldPtr(TYPE_OF_NULLPTR)
        : Owner((UObject*)nullptr)
        , Field()
    {
    }
 
    template <
        typename U
        UE_REQUIRES(std::is_convertible_v<U*, T*>)
    >
    inline TWeakFieldPtr(U* InField, EDummy1 = Dummy1)
        : Owner(InField ? InField->GetOwnerUObject() : (UObject*)nullptr)
        , Field(InField)
    {
        // This static assert is in here rather than in the body of the class because we want
        // to be able to define TWeakFieldPtr<UUndefinedClass>.
        static_assert(std::is_convertible_v<T*, const volatile FField*>, "TWeakFieldPtr can only be constructed with FField types");
    }
 
    template <
        typename OtherT
        UE_REQUIRES(std::is_convertible_v<OtherT*, T*>)
    >
    inline TWeakFieldPtr(const TWeakFieldPtr<OtherT>& Other)
        : Owner(Other.Owner)
        , Field(Other.Field)
    {
        // This static assert is in here rather than in the body of the class because we want
        // to be able to define TWeakFieldPtr<UUndefinedClass>.
        static_assert(std::is_convertible_v<T*, const volatile FField*>, "TWeakFieldPtr can only be constructed with FField types");
    }
 
    inline void Reset()
    {
        Owner.Reset();
        Field.Reset();
    }
 
    template <
        typename U
        UE_REQUIRES(std::is_convertible_v<U*, T*>)
    >
    inline void operator=(U* InField)
    {
        Owner = InField ? InField->GetOwnerUObject() : (UObject*)nullptr;
        Field = (U*)InField;
    }
 
    template <
        typename OtherT
        UE_REQUIRES(std::is_convertible_v<OtherT*, T*>)
    >
    inline void operator=(const TWeakFieldPtr<OtherT>& Other)
    {
        Owner = Other.Owner;
        Field = Other.Field;
    }
 
    inline T* Get(bool bEvenIfPendingKill) const
    {
        if (Owner.Get(bEvenIfPendingKill))
        {
            return Field.Get();
        }
        else
        {
            // Clear potentially stale pointer to the actual field
            Field.ClearCachedField();
        }
        return nullptr;
    }
 
    inline T* Get(/*bool bEvenIfPendingKill = false*/) const
    {
        if (Owner.Get())
        {
            return Field.Get();
        }
        else
        {
            // Clear potentially stale pointer to the actual field
            Field.ClearCachedField();
        }
        return nullptr;
    }
 
    inline T* GetEvenIfUnreachable() const
    {
        if (Owner.GetEvenIfUnreachable())
        {
            return Field.Get();
        }
        else
        {
            // Clear potentially stale pointer to the actual field
            Field.ClearCachedField();
        }
        return nullptr;
    }
 
    UE_FORCEINLINE_HINT T & operator*() const
    {
        return *Get();
    }
 
    UE_FORCEINLINE_HINT T * operator->() const
    {
        return Get();
    }
 
    UE_FORCEINLINE_HINT bool IsValid(bool bEvenIfPendingKill, bool bThreadsafeTest = false) const
    {
        return Owner.IsValid(bEvenIfPendingKill, bThreadsafeTest) && Field.Get();
    }
 
    UE_FORCEINLINE_HINT bool IsValid(/*bool bEvenIfPendingKill = false, bool bThreadsafeTest = false*/) const
    {
        return Owner.IsValid() && Field.Get();
    }
 
    UE_FORCEINLINE_HINT bool IsStale(bool bIncludingIfPendingKill = false, bool bThreadsafeTest = false) const
    {
        return Owner.IsStale(bIncludingIfPendingKill, bThreadsafeTest);
    }
 
    UE_FORCEINLINE_HINT bool HasSameIndexAndSerialNumber(const TWeakFieldPtr& Other) const
    {
        return Owner.HasSameIndexAndSerialNumber(Other.Owner);
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT friend uint32 GetTypeHash(const TWeakFieldPtr& WeakObjectPtr)
    {
        return GetTypeHash(WeakObjectPtr.Field);
    }
 
    inline void Serialize(FArchive& Ar)
    {
        Ar << Owner;
        Ar << Field;
    }
};
 
template <
    typename LhsType,
    typename RhsType
    UE_REQUIRES_DEFINITION(UE_REQUIRES_EXPR((LhsType*)nullptr == (RhsType*)nullptr))
>
UE_FORCEINLINE_HINT bool operator==(const TWeakFieldPtr<LhsType>& Lhs, const TWeakFieldPtr<RhsType>& Rhs)
{
    return Lhs.Field == Rhs.Field;
}
 
template <
    typename LhsType,
    typename RhsType
    UE_REQUIRES_DEFINITION(UE_REQUIRES_EXPR((LhsType*)nullptr == (const RhsType*)nullptr))
>
UE_FORCEINLINE_HINT bool operator==(const TWeakFieldPtr<LhsType>& Lhs, const RhsType* Rhs)
{
    return Lhs.Field == Rhs;
}
 
template <
    typename LhsType,
    typename RhsType
    UE_REQUIRES_DEFINITION(UE_REQUIRES_EXPR((const LhsType*)nullptr == (RhsType*)nullptr))
>
UE_FORCEINLINE_HINT bool operator==(const LhsType* Lhs, const TWeakFieldPtr<RhsType>& Rhs)
{
    return Lhs == Rhs.Field;
}
 
template <typename LhsType>
UE_FORCEINLINE_HINT bool operator==(const TWeakFieldPtr<LhsType>& Lhs, TYPE_OF_NULLPTR)
{
    return !Lhs.Get();
}
 
template <typename RhsType>
UE_FORCEINLINE_HINT bool operator==(TYPE_OF_NULLPTR, const TWeakFieldPtr<RhsType>& Rhs)
{
    return !Rhs.Get();
}
 
#if !PLATFORM_COMPILER_HAS_GENERATED_COMPARISON_OPERATORS
template <
    typename LhsType,
    typename RhsType
    UE_REQUIRES_DEFINITION(UE_REQUIRES_EXPR((LhsType*)nullptr != (RhsType*)nullptr))
>
UE_FORCEINLINE_HINT bool operator!=(const TWeakFieldPtr<LhsType>& Lhs, const TWeakFieldPtr<RhsType>& Rhs)
{
    return !(Lhs == Rhs);
}
 
template <
    typename LhsType,
    typename RhsType
    UE_REQUIRES_DEFINITION(UE_REQUIRES_EXPR((LhsType*)nullptr != (const RhsType*)nullptr))
>
UE_FORCEINLINE_HINT bool operator!=(const TWeakFieldPtr<LhsType>& Lhs, const RhsType* Rhs)
{
    return !(Lhs == Rhs);
}
 
template <
    typename LhsType,
    typename RhsType
    UE_REQUIRES_DEFINITION(UE_REQUIRES_EXPR((const LhsType*)nullptr != (RhsType*)nullptr))
>
UE_FORCEINLINE_HINT bool operator!=(const LhsType* Lhs, const TWeakFieldPtr<RhsType>& Rhs)
{
    return !(Lhs == Rhs);
}
 
template <typename LhsType>
UE_FORCEINLINE_HINT bool operator!=(const TWeakFieldPtr<LhsType>& Lhs, TYPE_OF_NULLPTR)
{
    return !(Lhs == nullptr);
}
 
template <typename RhsType>
UE_FORCEINLINE_HINT bool operator!=(TYPE_OF_NULLPTR, const TWeakFieldPtr<RhsType>& Rhs)
{
    return !(nullptr == Rhs);
}
#endif
 
// Helper function which deduces the type of the initializer
template <typename T>
UE_FORCEINLINE_HINT TWeakFieldPtr<T> MakeWeakFieldPtr(T* Ptr)
{
    return TWeakFieldPtr<T>(Ptr);
}
 
template<class T> struct TIsPODType<TWeakFieldPtr<T> > { enum { Value = true }; };
template<class T> struct TIsZeroConstructType<TWeakFieldPtr<T> > { enum { Value = true }; };
template<class T> struct TIsWeakPointerType<TWeakFieldPtr<T> > { enum { Value = true }; };
 
 
template <typename KeyType, typename ValueType, bool bInAllowDuplicateKeys = false>
struct TWeakFieldPtrMapKeyFuncs : public TDefaultMapKeyFuncs<KeyType, ValueType, bInAllowDuplicateKeys>
{
    typedef typename TDefaultMapKeyFuncs<KeyType, ValueType, bInAllowDuplicateKeys>::KeyInitType KeyInitType;
 
    static UE_FORCEINLINE_HINT bool Matches(KeyInitType A, KeyInitType B)
    {
        return A == B;
    }
 
    static UE_FORCEINLINE_HINT uint32 GetKeyHash(KeyInitType Key)
    {
        return GetTypeHash(Key);
    }
};
 
template<class T>
FArchive& operator<<(FArchive& Ar, TWeakFieldPtr<T>& WeakFieldPtr)
{
    WeakFieldPtr.Serialize(Ar);
    return Ar;
}