LazyObjectPtr.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    LazyObjectPtr.h: Lazy, guid-based weak pointer to a UObject, mostly useful for actors
=============================================================================*/
 
#pragma once
 
#include "Containers/UnrealString.h"
#include "CoreGlobals.h"
#include "HAL/Platform.h"
#include "HAL/ThreadSafeCounter.h"
#include "Misc/Guid.h"
#include "Serialization/Archive.h"
#include "Serialization/StructuredArchive.h"
#include "Templates/Casts.h"
#include "Templates/Requires.h"
#include "Templates/UnrealTemplate.h"
#include "UObject/Object.h"
#include "UObject/PersistentObjectPtr.h"
 
#include <type_traits>
 
class UObject;
 
template <typename T> struct TIsPODType;
template <typename T> struct TIsWeakPointerType;
 
struct FUniqueObjectGuid
{
    FUniqueObjectGuid()
    {}
 
    FUniqueObjectGuid(const FGuid& InGuid)
        : Guid(InGuid)
    {}
 
    UE_FORCEINLINE_HINT void Reset()
    {
        Guid.Invalidate();
    }
 
    COREUOBJECT_API explicit FUniqueObjectGuid(const UObject* InObject);
 
    COREUOBJECT_API FString ToString() const;
 
    COREUOBJECT_API void FromString(const FString& From);
 
    COREUOBJECT_API FUniqueObjectGuid FixupForPIE(int32 PlayInEditorID = UE::GetPlayInEditorID()) const;
 
    COREUOBJECT_API UObject* ResolveObject() const;
 
    UE_FORCEINLINE_HINT bool IsValid() const
    {
        return Guid.IsValid();
    }
 
    UE_FORCEINLINE_HINT bool operator==(const FUniqueObjectGuid& Other) const
    {
        return Guid == Other.Guid;
    }
 
    UE_FORCEINLINE_HINT bool operator!=(const FUniqueObjectGuid& Other) const
    {
        return Guid != Other.Guid;
    }
 
    UE_FORCEINLINE_HINT bool IsDefault() const
    {
        // A default GUID is 0,0,0,0 and this is "invalid"
        return !IsValid(); 
    }
 
    UE_FORCEINLINE_HINT friend uint32 GetTypeHash(const FUniqueObjectGuid& ObjectGuid)
    {
        return GetTypeHash(ObjectGuid.Guid);
    }
    UE_FORCEINLINE_HINT const FGuid& GetGuid() const
    {
        return Guid;
    }
 
    friend FArchive& operator<<(FArchive& Ar,FUniqueObjectGuid& ObjectGuid)
    {
        Ar << ObjectGuid.Guid;
        return Ar;
    }
 
    friend void operator<<(FStructuredArchive::FSlot Slot, FUniqueObjectGuid& ObjectGuid)
    {
        Slot << ObjectGuid.Guid;
    }
 
    UE_DEPRECATED(5.4, "The current object tag is no longer used by TSoftObjectPtr, you can remove all calls")
    static int32 GetCurrentTag()
    {
        return 0;
    }
    UE_DEPRECATED(5.4, "The current object tag is no longer used by TSoftObjectPtr, you can remove all calls")
    static int32 InvalidateTag()
    {
        return 0;
    }
 
    static COREUOBJECT_API FUniqueObjectGuid GetOrCreateIDForObject(FObjectPtr Object);
    static UE_FORCEINLINE_HINT FUniqueObjectGuid GetOrCreateIDForObject(const UObject* Object)
    {
        return GetOrCreateIDForObject(FObjectPtr(const_cast<UObject*>(Object)));
    }
    template <typename T>
    static UE_FORCEINLINE_HINT FUniqueObjectGuid GetOrCreateIDForObject(TObjectPtr<T> Object)
    {
        return GetOrCreateIDForObject(FObjectPtr(Object));
    }
 
private:
    FGuid Guid;
};
 
template<> struct TIsPODType<FUniqueObjectGuid> { enum { Value = true }; };
 
struct FLazyObjectPtr : public TPersistentObjectPtr<FUniqueObjectGuid>
{
private:
    using Super = TPersistentObjectPtr<FUniqueObjectGuid>;
 
public:
    UE_FORCEINLINE_HINT FLazyObjectPtr()
    {
    }
 
    explicit UE_FORCEINLINE_HINT FLazyObjectPtr(FObjectPtr Object)
    {
        (*this)=Object;
    }
    explicit UE_FORCEINLINE_HINT FLazyObjectPtr(const UObject* Object)
        : FLazyObjectPtr(FObjectPtr(const_cast<UObject*>(Object)))
    {
    }
    template <typename T>
    explicit UE_FORCEINLINE_HINT FLazyObjectPtr(TObjectPtr<T> Object)
        : FLazyObjectPtr(FObjectPtr(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
    }
 
    UE_FORCEINLINE_HINT void operator=(FObjectPtr Object)
    {
        Super::operator=(Object);
    }
    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);
    }
 
    UE_FORCEINLINE_HINT void operator=(const FUniqueObjectGuid& InObjectID)
    {
        Super::operator=(InObjectID);
    }
 
    UE_FORCEINLINE_HINT void FixupForPIE(int32 PIEInstance)
    {
        *this = GetUniqueID().FixupForPIE(PIEInstance);
    }
    
    COREUOBJECT_API static void PossiblySerializeObjectGuid(UObject* Object, FStructuredArchive::FRecord Record);
 
    COREUOBJECT_API static void ResetPIEFixups();
};
 
template <> struct TIsPODType<FLazyObjectPtr> { enum { Value = TIsPODType<TPersistentObjectPtr<FUniqueObjectGuid> >::Value }; };
template <> struct TIsWeakPointerType<FLazyObjectPtr> { enum { Value = TIsWeakPointerType<TPersistentObjectPtr<FUniqueObjectGuid> >::Value }; };
 
template<class T=UObject>
struct TLazyObjectPtr : private FLazyObjectPtr
{
public:
    using ElementType = T;
    
    TLazyObjectPtr() = default;
 
    TLazyObjectPtr(TLazyObjectPtr<T>&&) = default;
    TLazyObjectPtr(const TLazyObjectPtr<T>&) = default;
    TLazyObjectPtr<T>& operator=(TLazyObjectPtr<T>&&) = default;
    TLazyObjectPtr<T>& operator=(const TLazyObjectPtr<T>&) = default;
 
    template <
        typename U
        UE_REQUIRES(std::is_convertible_v<U*, T*>)
    >
    UE_FORCEINLINE_HINT TLazyObjectPtr(const TLazyObjectPtr<U>& Other) :
        FLazyObjectPtr((const FLazyObjectPtr&)Other)
    {
    }
    
    template <
        typename U
        UE_REQUIRES(std::is_convertible_v<U*, T*>)
    >
    UE_FORCEINLINE_HINT TLazyObjectPtr<T>& operator=(const TLazyObjectPtr<U>& Other)
    {
        FLazyObjectPtr::operator=((const FLazyObjectPtr&)Other);
        return *this;
    }
 
    UE_FORCEINLINE_HINT TLazyObjectPtr(T* Object)
    {
        FLazyObjectPtr::operator=(Object);
    }
 
    UE_FORCEINLINE_HINT void Reset()
    {
        FLazyObjectPtr::Reset();
    }
 
    UE_FORCEINLINE_HINT void operator=(T* Object)
    {
        FLazyObjectPtr::operator=(Object);
    }
 
    UE_FORCEINLINE_HINT void operator=(const FUniqueObjectGuid& InObjectID)
    {
        FLazyObjectPtr::operator=(InObjectID);
    }
 
    UE_FORCEINLINE_HINT const FUniqueObjectGuid& GetUniqueID() const
    {
        return FLazyObjectPtr::GetUniqueID();
    }
 
    UE_FORCEINLINE_HINT T* Get() const
    {
        // there are cases where a TLazyObjectPtr can get an object of the wrong type assigned to it which are difficult to avoid
        // e.g. operator=(const FUniqueObjectGuid& ObjectID)
        // "WARNING: this doesn't check the type of the object is correct..."
        return dynamic_cast<T*>(FLazyObjectPtr::Get());
    }
 
    UE_FORCEINLINE_HINT T& operator*() const
    {
        return *Get();
    }
 
    UE_FORCEINLINE_HINT T* operator->() const
    {
        return Get();
    }
 
    UE_FORCEINLINE_HINT bool IsValid() const
    {
        return FLazyObjectPtr::IsValid();
    }
 
    UE_FORCEINLINE_HINT bool IsStale() const
    {
        return FLazyObjectPtr::IsStale();
    }
 
    UE_FORCEINLINE_HINT bool IsPending() const
    {
        return FLazyObjectPtr::IsPending();
    }
 
    UE_FORCEINLINE_HINT bool IsNull() const
    {
        return FLazyObjectPtr::IsNull();
    }
 
    UE_FORCEINLINE_HINT explicit operator bool() const
    {
        return IsValid();
    }
 
    UE_FORCEINLINE_HINT uint32 GetLazyObjecPtrTypeHash() const
    {
        return GetTypeHash(static_cast<const FLazyObjectPtr&>(*this));
    }
 
    UE_FORCEINLINE_HINT void SerializePtr(FArchive& Ar)
    {
        Ar << static_cast<FLazyObjectPtr&>(*this);
    }
 
    template<typename U, typename = decltype((T*)nullptr == (U*)nullptr)>
    UE_FORCEINLINE_HINT bool operator==(const TLazyObjectPtr<U>& Rhs) const
    {
        return (const FLazyObjectPtr&)*this == (const FLazyObjectPtr&)Rhs;
    }
    template<typename U, typename = decltype((T*)nullptr != (U*)nullptr)>
    UE_FORCEINLINE_HINT bool operator!=(const TLazyObjectPtr<U>& Rhs) const
    {
        return (const FLazyObjectPtr&)*this != (const FLazyObjectPtr&)Rhs;
    }
 
    template<typename U, typename = decltype((T*)nullptr == (U*)nullptr)>
    UE_FORCEINLINE_HINT bool operator==(const U* Rhs) const
    {
        return Get() == Rhs;
    }
 
    UE_FORCEINLINE_HINT bool operator==(TYPE_OF_NULLPTR) const
    {
        return !IsValid();
    }
    template<typename U, typename = decltype((T*)nullptr != (U*)nullptr)>
    UE_FORCEINLINE_HINT bool operator!=(const U* Rhs) const
    {
        return Get() != Rhs;
    }
 
    UE_FORCEINLINE_HINT bool operator!=(TYPE_OF_NULLPTR) const
    {
        return IsValid();
    }
};
 
template<typename T>
UE_FORCEINLINE_HINT uint32 GetTypeHash(const TLazyObjectPtr<T>& LazyObjectPtr)
{
    return LazyObjectPtr.GetLazyObjecPtrTypeHash();
}
 
template<typename T>
FArchive& operator<<(FArchive& Ar, TLazyObjectPtr<T>& LazyObjectPtr)
{
    LazyObjectPtr.SerializePtr(Ar);
    return Ar;
}
 
template<typename T, typename U, typename = decltype((T*)nullptr == (U*)nullptr)>
UE_FORCEINLINE_HINT bool operator==(const U* Lhs, const TLazyObjectPtr<T>& Rhs)
{
    return Lhs == Rhs.Get();
}
 
template<typename T>
UE_FORCEINLINE_HINT bool operator==(TYPE_OF_NULLPTR, const TLazyObjectPtr<T>& Rhs)
{
    return !Rhs.IsValid();
}
 
template<typename T, typename U, typename = decltype((T*)nullptr != (U*)nullptr)>
UE_FORCEINLINE_HINT bool operator!=(const U* Lhs, const TLazyObjectPtr<T>& Rhs)
{
    return Lhs != Rhs.Get();
}
 
template<typename T>
UE_FORCEINLINE_HINT bool operator!=(TYPE_OF_NULLPTR, const TLazyObjectPtr<T>& Rhs)
{
    return Rhs.IsValid();
}
 
template<class T> struct TIsPODType<TLazyObjectPtr<T> > { enum { Value = TIsPODType<FLazyObjectPtr>::Value }; };
template<class T> struct TIsWeakPointerType<TLazyObjectPtr<T> > { enum { Value = TIsWeakPointerType<FLazyObjectPtr>::Value }; };