PersistentObjectPtr.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    PersistentObjectPtr.h: Template that is a base class for Lazy and Asset pointers
=============================================================================*/
 
#pragma once
 
#include "UObject/Object.h"
#include "UObject/WeakObjectPtr.h"
 
class UObject;
 
template<class TObjectID>
struct TPersistentObjectPtr
{
    using ElementType = TObjectID;
 
    UE_FORCEINLINE_HINT TPersistentObjectPtr()
    {
        Reset();
    }
 
    inline void Reset()
    {
        WeakPtr.Reset();
        ObjectID.Reset();
    }
 
    UE_FORCEINLINE_HINT void ResetWeakPtr()
    {
        WeakPtr.Reset();
    }
 
    explicit inline TPersistentObjectPtr(const TObjectID& InObjectID)
        : WeakPtr()
        , ObjectID(InObjectID)
    {
    }
 
    inline void operator=(const TObjectID& InObjectID)
    {
        WeakPtr.Reset();
        ObjectID = InObjectID;
    }
 
    void operator=(FObjectPtr Object)
    {
        if (Object)
        {
            ObjectID = TObjectID::GetOrCreateIDForObject(Object);
            if (CanCacheObjectPointer(Object))
            {
                WeakPtr = Object;
            }
            else
            {
                WeakPtr.Reset();
            }
        }
        else
        {
            Reset();
        }
    }
    UE_FORCEINLINE_HINT void operator=(const UObject* Object)
    {
        *this = FObjectPtr(const_cast<UObject*>(Object));
    }
    template <typename T>
    UE_FORCEINLINE_HINT void operator=(TObjectPtr<T> Object)
    {
        // This needs to be a template instead of TObjectPtr<const UObject> because C++ does derived-to-base
        // pointer conversions ('standard conversion sequences') in more cases than TSmartPtr<Derived>-to-TSmartPtr<Base>
        // conversions ('user-defined conversions'), meaning it doesn't auto-convert in many real use cases.
        //
        // https://en.cppreference.com/w/cpp/language/implicit_conversion
 
        *this = FObjectPtr(Object);
    }
 
    inline void operator=(const FWeakObjectPtr& Other)
    {
        // If object exists need to make sure it gets registered properly in above function, if it doesn't exist just empty it
        const UObject* Object = Other.Get();
        *this = Object;
    }
 
    UE_FORCEINLINE_HINT const TObjectID& GetUniqueID() const
    {
        return ObjectID;
    }
 
    UE_FORCEINLINE_HINT TObjectID& GetUniqueID()
    {
        return ObjectID;
    }
 
    inline UObject* Get() const
    {
        UObject* Object = WeakPtr.Get();
        
        // Do a full resolve if the cached object is null but we have a valid object ID that might resolve
        // This used to check TObjectID::GetCurrentTag() before resolving but that was unreliable and did not improve performance in actual use
        if (!Object && ObjectID.IsValid())
        {
            Object = ObjectID.ResolveObject();
            if (CanCacheObjectPointer(FObjectPtr(Object)))
            {
                WeakPtr = Object;
            }
 
            // Make sure it isn't garbage to match the default behavior of WeakPtr.Get() without looking it up again
            return ::GetValid(Object);
        }
        return Object;
    }
 
    inline UObject* Get(bool bEvenIfPendingKill) const
    {
        UObject* Object = WeakPtr.Get(bEvenIfPendingKill);
 
        // Do a full resolve if the cached object is null but we have a valid object ID that might resolve
        // This used to check TObjectID::GetCurrentTag() before resolving but that was unreliable and did not improve performance in actual use
        if (!Object && ObjectID.IsValid())
        {
            Object = ObjectID.ResolveObject();
            FWeakObjectPtr LocalWeakPtr = Object;
 
            if (CanCacheObjectPointer(FObjectPtr(Object)))
            {
                WeakPtr = Object;
            }
            // Get the object again using the correct flag
            Object = LocalWeakPtr.Get(bEvenIfPendingKill);
        }
        return Object;
    }
 
    UE_FORCEINLINE_HINT UObject& operator*() const
    {
        return *Get();
    }
 
    UE_FORCEINLINE_HINT UObject* operator->() const
    {
        return Get();
    }
 
    UE_FORCEINLINE_HINT bool operator==(const TPersistentObjectPtr& Rhs) const
    {
        return ObjectID == Rhs.ObjectID;
    }
 
    UE_FORCEINLINE_HINT bool operator==(TYPE_OF_NULLPTR) const
    {
        return !IsValid();
    }
 
    UE_FORCEINLINE_HINT bool operator!=(const TPersistentObjectPtr& Rhs) const
    {
        return ObjectID != Rhs.ObjectID;
    }
 
    UE_FORCEINLINE_HINT bool operator!=(TYPE_OF_NULLPTR) const
    {
        return IsValid();
    }
 
#if !PLATFORM_COMPILER_HAS_GENERATED_COMPARISON_OPERATORS
    UE_FORCEINLINE_HINT friend bool operator==(TYPE_OF_NULLPTR, const TPersistentObjectPtr& Rhs)
    {
        return !Rhs.IsValid();
    }
 
    UE_FORCEINLINE_HINT friend bool operator!=(TYPE_OF_NULLPTR, const TPersistentObjectPtr& Rhs)
    {
        return Rhs.IsValid();
    }
#endif
 
    UE_FORCEINLINE_HINT bool IsPending() const
    {
        return Get() == nullptr && ObjectID.IsValid();
    }
 
    UE_FORCEINLINE_HINT bool IsValid() const
    {
        return !!Get();
    }
 
    UE_FORCEINLINE_HINT bool IsStale() const
    {
        return WeakPtr.IsStale();
    }
    UE_FORCEINLINE_HINT bool IsNull() const
    {
        return !ObjectID.IsValid();
    }
 
    UE_FORCEINLINE_HINT friend uint32 GetTypeHash(const TPersistentObjectPtr& Ptr)
    {
        return GetTypeHash(Ptr.ObjectID);
    }
 
private:
 
    // Returns whether the object pointer can be stored in WeakPtr for later retrieval
    // For example, objects that are in the process of being async loaded may not be cached
    inline bool CanCacheObjectPointer(FObjectPtr Ptr) const
    {
        if (IsInAsyncLoadingThread() && Ptr && Ptr->HasAnyInternalFlags(EInternalObjectFlags_AsyncLoading))
        {
            return false;
        }
        return true;
    }
 
    mutable FWeakObjectPtr  WeakPtr;
    TObjectID               ObjectID;
};
 
template <class TObjectID> struct TIsPODType<TPersistentObjectPtr<TObjectID> > { enum { Value = TIsPODType<TObjectID>::Value }; };
template <class TObjectID> struct TIsWeakPointerType<TPersistentObjectPtr<TObjectID> > { enum { Value = TIsWeakPointerType<FWeakObjectPtr>::Value }; };