SoftObjectPtr.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    SoftObjectPtr.h: Pointer to UObject asset, keeps extra information so that it is works even if the asset is not in memory
=============================================================================*/
 
#pragma once
 
#include "UObject/Object.h"
#include "Templates/Casts.h"
#include "UObject/PersistentObjectPtr.h"
#include "UObject/SoftObjectPath.h"
#include "Templates/Models.h"
#include "Concepts/EqualityComparable.h"
 
#include <type_traits>
 
#ifndef UE_DEPRECATE_SOFTOBJECTPTR_CONVERSIONS
    #define UE_DEPRECATE_SOFTOBJECTPTR_CONVERSIONS 1
#endif
#if UE_DEPRECATE_SOFTOBJECTPTR_CONVERSIONS
    #define UE_SOFTOBJECTPTR_CONVERSION_DEPRECATED(Version, Message) UE_DEPRECATED(Version, Message)
#else
    #define UE_SOFTOBJECTPTR_CONVERSION_DEPRECATED(Version, Message)
#endif
 
template<typename T> 
struct TIsSoftObjectPointerType
{ 
    enum { Value = false };
};
 
struct FSoftObjectPtr : public TPersistentObjectPtr<FSoftObjectPath>
{
private:
    using Super = TPersistentObjectPtr<FSoftObjectPath>;
 
public: 
    [[nodiscard]] UE_FORCEINLINE_HINT FSoftObjectPtr() = default;
    [[nodiscard]] UE_FORCEINLINE_HINT FSoftObjectPtr(const FSoftObjectPtr& Other) = default;
    [[nodiscard]] UE_FORCEINLINE_HINT FSoftObjectPtr(FSoftObjectPtr&& Other) = default;
    UE_FORCEINLINE_HINT ~FSoftObjectPtr() = default;
    UE_FORCEINLINE_HINT FSoftObjectPtr& operator=(const FSoftObjectPtr& Other) = default;
    UE_FORCEINLINE_HINT FSoftObjectPtr& operator=(FSoftObjectPtr&& Other) = default;
 
    [[nodiscard]] explicit UE_FORCEINLINE_HINT FSoftObjectPtr(const FSoftObjectPath& ObjectPath)
        : Super(ObjectPath)
    {
    }
 
    [[nodiscard]] explicit UE_FORCEINLINE_HINT FSoftObjectPtr(FObjectPtr Object)
    {
        (*this)=Object;
    }
    [[nodiscard]] explicit UE_FORCEINLINE_HINT FSoftObjectPtr(const UObject* Object)
        : FSoftObjectPtr(FObjectPtr(const_cast<UObject*>(Object)))
    {
    }
    template <typename T>
    [[nodiscard]] explicit UE_FORCEINLINE_HINT FSoftObjectPtr(TObjectPtr<T> Object)
        : FSoftObjectPtr(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 situations that TSmartPtr<Derived>-to-TSmartPtr<Base>
        // conversions ('user-defined conversions') doesn't, meaning it won't auto-convert in many real use cases.
        //
        // https://en.cppreference.com/w/cpp/language/implicit_conversion
    }
 
    UObject* LoadSynchronous() const
    {
        UObject* Asset = Get();
        if (Asset == nullptr && !IsNull())
        {
            ToSoftObjectPath().TryLoad();
            
            // TryLoad will have loaded this pointer if it is valid
            Asset = Get();
        }
        return Asset;
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT const FSoftObjectPath& ToSoftObjectPath() const
    {
        return GetUniqueID();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT FString ToString() const
    {
        return ToSoftObjectPath().ToString();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT FString GetLongPackageName() const
    {
        return ToSoftObjectPath().GetLongPackageName();
    }
    
    [[nodiscard]] UE_FORCEINLINE_HINT FName GetLongPackageFName() const
    {
        return ToSoftObjectPath().GetLongPackageFName();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT FString GetAssetName() const
    {
        return ToSoftObjectPath().GetAssetName();
    }
 
#if WITH_EDITOR
    [[nodiscard]] inline UObject* Get() const
    {
        if (UE::GetPlayInEditorID() != INDEX_NONE)
        {
            // Cannot use or set the cached value in PIE as it may affect other PIE instances or the editor
            TWeakObjectPtr<UObject> Result = GetUniqueID().ResolveObject();
            // If this object is pending kill or otherwise invalid, this will return nullptr just like TPersistentObjectPtr<FSoftObjectPath>::Get()
            return Result.Get();
        }
        return Super::Get();
    }
#endif
 
    // Implicit conversion from UObject* via assignment shouldn't really be allowed if the constructor is explicit
    using TPersistentObjectPtr<FSoftObjectPath>::operator=;
    FSoftObjectPtr& operator=(FObjectPtr Ptr)
    {
        Super* SuperThis = this;
        (*SuperThis) = Ptr;
        return *this;
    }
    UE_FORCEINLINE_HINT FSoftObjectPtr& operator=(const UObject* Ptr)
    {
        return *this = FObjectPtr(const_cast<UObject*>(Ptr));
    }
    template <typename T>
    UE_FORCEINLINE_HINT FSoftObjectPtr& operator=(TObjectPtr<T> Ptr)
    {
        // This needs to be a template instead of TObjectPtr<const UObject> because C++ does derived-to-base
        // pointer conversions ('standard conversion sequences') in situations that TSmartPtr<Derived>-to-TSmartPtr<Base>
        // conversions ('user-defined conversions') doesn't, meaning it won't auto-convert in many real use cases.
        //
        // https://en.cppreference.com/w/cpp/language/implicit_conversion
 
        return *this = FObjectPtr(Ptr);
    }
};
 
template <> struct TIsPODType<FSoftObjectPtr> { enum { Value = TIsPODType<TPersistentObjectPtr<FSoftObjectPath> >::Value }; };
template <> struct TIsWeakPointerType<FSoftObjectPtr> { enum { Value = TIsWeakPointerType<TPersistentObjectPtr<FSoftObjectPath> >::Value }; };
template <> struct TIsSoftObjectPointerType<FSoftObjectPtr> { enum { Value = true }; };
 
template<class T=UObject>
struct TSoftObjectPtr
{
    template <class U>
    friend struct TSoftObjectPtr;
 
public:
    using ElementType = T;
    
    [[nodiscard]] UE_FORCEINLINE_HINT TSoftObjectPtr() = default;
    [[nodiscard]] UE_FORCEINLINE_HINT TSoftObjectPtr(const TSoftObjectPtr& Other) = default;
    [[nodiscard]] UE_FORCEINLINE_HINT TSoftObjectPtr(TSoftObjectPtr&& Other) = default;
    UE_FORCEINLINE_HINT ~TSoftObjectPtr() = default;
    UE_FORCEINLINE_HINT TSoftObjectPtr& operator=(const TSoftObjectPtr& Other) = default;
    UE_FORCEINLINE_HINT TSoftObjectPtr& operator=(TSoftObjectPtr&& Other) = default;
    
    template <
        class U
        UE_REQUIRES(std::is_convertible_v<U*, T*>)
    >
    [[nodiscard]] UE_FORCEINLINE_HINT TSoftObjectPtr(const TSoftObjectPtr<U>& Other)
        : SoftObjectPtr(Other.SoftObjectPtr)
    {
    }
    template <
        class U
        UE_REQUIRES(!std::is_convertible_v<U*, T*>)
    >
    UE_SOFTOBJECTPTR_CONVERSION_DEPRECATED(5.5, "Constructing TSoftObjectPtr from an incompatible pointer type has been deprecated.")
    [[nodiscard]] UE_FORCEINLINE_HINT TSoftObjectPtr(const TSoftObjectPtr<U>& Other)
        : SoftObjectPtr(Other.SoftObjectPtr)
    {
    }
 
    template <
        class U
        UE_REQUIRES(std::is_convertible_v<U*, T*>)
    >
    [[nodiscard]] UE_FORCEINLINE_HINT TSoftObjectPtr(TSoftObjectPtr<U>&& Other)
        : SoftObjectPtr(MoveTemp(Other.SoftObjectPtr))
    {
    }
    template <
        class U
        UE_REQUIRES(!std::is_convertible_v<U*, T*>)
    >
    UE_SOFTOBJECTPTR_CONVERSION_DEPRECATED(5.5, "Constructing TSoftObjectPtr from an incompatible pointer type has been deprecated.")
    [[nodiscard]] UE_FORCEINLINE_HINT TSoftObjectPtr(TSoftObjectPtr<U>&& Other)
        : SoftObjectPtr(MoveTemp(Other.SoftObjectPtr))
    {
    }
 
    template <
        typename U
        UE_REQUIRES(std::is_convertible_v<U*, T*>)
    >
    [[nodiscard]] UE_FORCEINLINE_HINT TSoftObjectPtr(U* Object)
        : SoftObjectPtr(Object)
    {
    }
    template <
        typename U
        UE_REQUIRES(!std::is_convertible_v<U*, T*>)
    >
    UE_SOFTOBJECTPTR_CONVERSION_DEPRECATED(5.5, "Constructing TSoftObjectPtr from an incompatible pointer type has been deprecated.")
    [[nodiscard]] UE_FORCEINLINE_HINT TSoftObjectPtr(U* Object)
        : SoftObjectPtr(Object)
    {
    }
 
#if UE_ENABLE_NOTNULL_WRAPPER
    template <
        typename U
        UE_REQUIRES(std::is_convertible_v<U*, T*>)
    >
    [[nodiscard]] UE_FORCEINLINE_HINT TSoftObjectPtr(TNotNull<U*> Object)
        : SoftObjectPtr(Object)
    {
    }
    template <
        typename U
        UE_REQUIRES(std::is_convertible_v<U*, T*>)
    >
    [[nodiscard]] UE_FORCEINLINE_HINT TSoftObjectPtr(TNotNull<TObjectPtr<U>> Object)
        : SoftObjectPtr(static_cast<TObjectPtr<U>>(Object).Get())
    {
    }
#endif
 
    template <
        typename U
        UE_REQUIRES(std::is_convertible_v<U*, T*>)
    >
    [[nodiscard]] UE_FORCEINLINE_HINT TSoftObjectPtr(const TObjectPtr<U> Object)
        : SoftObjectPtr(Object.Get())
    {
    }
    template <
        typename U
        UE_REQUIRES(!std::is_convertible_v<U*, T*>)
    >
    UE_SOFTOBJECTPTR_CONVERSION_DEPRECATED(5.5, "Constructing TSoftObjectPtr from an incompatible pointer type has been deprecated.")
    [[nodiscard]] UE_FORCEINLINE_HINT TSoftObjectPtr(const TObjectPtr<U> Object)
        : SoftObjectPtr(Object.Get())
    {
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT TSoftObjectPtr(TYPE_OF_NULLPTR)
        : SoftObjectPtr(nullptr)
    {
    }
 
    template <
        typename SoftObjectPathType
        UE_REQUIRES(std::is_same_v<SoftObjectPathType, FSoftObjectPath>)
    >
    [[nodiscard]] explicit UE_FORCEINLINE_HINT TSoftObjectPtr(SoftObjectPathType ObjectPath)
        : SoftObjectPtr(MoveTemp(ObjectPath))
    {
        // The reason for the strange templated/constrained signature is to prevent this type hole:
        //
        // const UThing* ConstPtr = ...;
        // TSoftObjectPtr<UThing*> NonConstSoftPtr(ConstPtr); // implicitly constructs an FSoftObjectPath from ConstPtr, then explicitly constructs the TSoftObjectPtr from that
        //
        // The real fix is to make the FSoftObjectPath(const UObject*) constructor explicit, but that will involve substantially more changes.
    }
    UE_SOFTOBJECTPTR_CONVERSION_DEPRECATED(5.5, "Constructing TSoftObjectPtr from an FString has been deprecated - instead, explicitly construct a FSoftObjectPath.")
    [[nodiscard]] explicit TSoftObjectPtr(const FString& Path)
        : SoftObjectPtr(FSoftObjectPath(Path))
    {
    }
 
    UE_FORCEINLINE_HINT void Reset()
    {
        SoftObjectPtr.Reset();
    }
 
    UE_FORCEINLINE_HINT void ResetWeakPtr()
    {
        SoftObjectPtr.ResetWeakPtr();
    }
 
    template <
        typename U
        UE_REQUIRES(std::is_convertible_v<U*, T*>)
    >
    inline TSoftObjectPtr& operator=(U* Object)
    {
        SoftObjectPtr = Object;
        return *this;
    }
    template <
        typename U
        UE_REQUIRES(!std::is_convertible_v<U*, T*>)
    >
    UE_SOFTOBJECTPTR_CONVERSION_DEPRECATED(5.5, "Assigning TSoftObjectPtr from an incompatible pointer type has been deprecated.")
    inline TSoftObjectPtr& operator=(U* Object)
    {
        SoftObjectPtr = Object;
        return *this;
    }
 
#if UE_ENABLE_NOTNULL_WRAPPER
    template <
        typename U
        UE_REQUIRES(std::is_convertible_v<U*, T*>)
    >
    inline TSoftObjectPtr& operator=(TNotNull<U*> Object)
    {
        SoftObjectPtr = Object;
        return *this;
    }
    template <
        typename U
        UE_REQUIRES(std::is_convertible_v<U*, T*>)
    >
    inline TSoftObjectPtr& operator=(TNotNull<TObjectPtr<U>> Object)
    {
        SoftObjectPtr = static_cast<TObjectPtr<U>>(Object).Get();
        return *this;
    }
#endif
 
    template <
        typename U
        UE_REQUIRES(std::is_convertible_v<U*, T*>)
    >
    inline TSoftObjectPtr& operator=(const TObjectPtr<U> Object)
    {
        SoftObjectPtr = Object.Get();
        return *this;
    }
    template <
        typename U
        UE_REQUIRES(!std::is_convertible_v<U*, T*>)
    >
    UE_SOFTOBJECTPTR_CONVERSION_DEPRECATED(5.5, "Assigning TSoftObjectPtr from an incompatible pointer type has been deprecated.")
    inline TSoftObjectPtr& operator=(const TObjectPtr<U> Object)
    {
        SoftObjectPtr = Object.Get();
        return *this;
    }
 
    inline TSoftObjectPtr& operator=(TYPE_OF_NULLPTR)
    {
        SoftObjectPtr = nullptr;
        return *this;
    }
 
    inline TSoftObjectPtr& operator=(FSoftObjectPath ObjectPath)
    {
        SoftObjectPtr = MoveTemp(ObjectPath);
        return *this;
    }
 
    template <
        class U
        UE_REQUIRES(std::is_convertible_v<U*, T*>)
    >
    inline TSoftObjectPtr& operator=(const TWeakObjectPtr<U>& Other)
    {
        SoftObjectPtr = Other;
        return *this;
    }
    template <
        class U
        UE_REQUIRES(!std::is_convertible_v<U*, T*>)
    >
    UE_SOFTOBJECTPTR_CONVERSION_DEPRECATED(5.5, "Assigning TSoftObjectPtr from an incompatible pointer type has been deprecated.")
    inline TSoftObjectPtr& operator=(const TWeakObjectPtr<U>& Other)
    {
        SoftObjectPtr = Other;
        return *this;
    }
 
    template <
        class U
        UE_REQUIRES(std::is_convertible_v<U*, T*>)
    >
    inline TSoftObjectPtr& operator=(TSoftObjectPtr<U> Other)
    {
        SoftObjectPtr = MoveTemp(Other.SoftObjectPtr);
        return *this;
    }
    template <
        class U
        UE_REQUIRES(!std::is_convertible_v<U*, T*>)
    >
    UE_SOFTOBJECTPTR_CONVERSION_DEPRECATED(5.5, "Assigning TSoftObjectPtr from an incompatible pointer type has been deprecated.")
    inline TSoftObjectPtr& operator=(TSoftObjectPtr<U> Other)
    {
        SoftObjectPtr = MoveTemp(Other.SoftObjectPtr);
        return *this;
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool operator==(const TSoftObjectPtr& Rhs) const
    {
        return SoftObjectPtr == Rhs.SoftObjectPtr;
    }
    template <
        typename U
        UE_REQUIRES(TModels_V<CEqualityComparableWith, T*, U*>)
    >
    [[nodiscard]] UE_FORCEINLINE_HINT bool operator==(const TSoftObjectPtr<U>& Rhs) const
    {
        return SoftObjectPtr == Rhs.SoftObjectPtr;
    }
    template <
        typename U
        UE_REQUIRES(!TModels_V<CEqualityComparableWith, T*, U*>)
    >
    UE_SOFTOBJECTPTR_CONVERSION_DEPRECATED(5.5, "Comparing TSoftObjectPtrs of incompatible pointer types has been deprecated.")
    [[nodiscard]] UE_FORCEINLINE_HINT bool operator==(const TSoftObjectPtr<U>& Rhs) const
    {
        return SoftObjectPtr == Rhs.SoftObjectPtr;
    }
    template <
        typename U
        UE_REQUIRES(TModels_V<CEqualityComparableWith, T*, U*>)
    >
    [[nodiscard]] UE_FORCEINLINE_HINT bool operator==(U* Rhs) const
    {
        return SoftObjectPtr == TSoftObjectPtr<U>(Rhs).SoftObjectPtr;
    }
    template <
        typename U
        UE_REQUIRES(!TModels_V<CEqualityComparableWith, T*, U*>)
    >
    UE_SOFTOBJECTPTR_CONVERSION_DEPRECATED(5.5, "Comparing TSoftObjectPtrs of incompatible pointer types has been deprecated.")
    [[nodiscard]] UE_FORCEINLINE_HINT bool operator==(U* Rhs) const
    {
        return SoftObjectPtr == TSoftObjectPtr<U>(Rhs).SoftObjectPtr;
    }
    [[nodiscard]] UE_FORCEINLINE_HINT bool operator==(TYPE_OF_NULLPTR) const
    {
        return SoftObjectPtr == nullptr;
    }
 
    [[nodiscard]] T* Get() const;
 
    [[nodiscard]] UE_FORCEINLINE_HINT T& operator*() const
    {
        return *Get();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT T* operator->() const
    {
        return Get();
    }
 
    T* LoadSynchronous() const
    {
        UObject* Asset = SoftObjectPtr.LoadSynchronous();
        return Cast<T>(Asset);
    }
 
    int32 LoadAsync(FLoadSoftObjectPathAsyncDelegate InCompletionDelegate, FLoadAssetAsyncOptionalParams InOptionalParams = FLoadAssetAsyncOptionalParams()) const
    {
        return SoftObjectPtr.ToSoftObjectPath().LoadAsync(MoveTemp(InCompletionDelegate), MoveTemp(InOptionalParams));
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool IsValid() const
    {
        // This does the runtime type check
        return Get() != nullptr;
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool IsPending() const
    {
        return SoftObjectPtr.IsPending();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool IsNull() const
    {
        return SoftObjectPtr.IsNull();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT const FSoftObjectPath& GetUniqueID() const
    {
        return SoftObjectPtr.GetUniqueID();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT const FSoftObjectPath& ToSoftObjectPath() const
    {
        return SoftObjectPtr.GetUniqueID();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT FString ToString() const
    {
        return ToSoftObjectPath().ToString();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT FString GetLongPackageName() const
    {
        return ToSoftObjectPath().GetLongPackageName();
    }
    
    [[nodiscard]] UE_FORCEINLINE_HINT FName GetLongPackageFName() const
    {
        return ToSoftObjectPath().GetLongPackageFName();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT FString GetAssetName() const
    {
        return ToSoftObjectPath().GetAssetName();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT explicit operator bool() const
    {
        return IsValid();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT uint32 GetPtrTypeHash() const
    {
        return GetTypeHash(static_cast<const TPersistentObjectPtr<FSoftObjectPath>&>(SoftObjectPtr));
    }
 
    UE_FORCEINLINE_HINT void Serialize(FArchive& Ar)
    {
        Ar << SoftObjectPtr;
    }
 
private:
    FSoftObjectPtr SoftObjectPtr;
};
 
template <typename T>
TSoftObjectPtr(T*) -> TSoftObjectPtr<T>;
 
#if !PLATFORM_COMPILER_HAS_GENERATED_COMPARISON_OPERATORS
template <
    typename LhsType,
    typename RhsType
    UE_REQUIRES(TModels_V<CEqualityComparableWith, LhsType*, RhsType*>)
>
[[nodiscard]] UE_FORCEINLINE_HINT bool operator==(LhsType* Lhs, const TSoftObjectPtr<RhsType>& Rhs)
{
    return Rhs == Lhs;
}
template <
    typename LhsType,
    typename RhsType
    UE_REQUIRES(!TModels_V<CEqualityComparableWith, LhsType*, RhsType*>)
>
UE_SOFTOBJECTPTR_CONVERSION_DEPRECATED(5.5, "Comparing TSoftObjectPtrs of incompatible pointer types has been deprecated.")
[[nodiscard]] UE_FORCEINLINE_HINT bool operator==(LhsType* Lhs, const TSoftObjectPtr<RhsType>& Rhs)
{
    return Rhs == Lhs;
}
template <typename RhsType>
[[nodiscard]] UE_FORCEINLINE_HINT bool operator==(TYPE_OF_NULLPTR Lhs, const TSoftObjectPtr<RhsType>& Rhs)
{
    return Rhs == Lhs;
}
template <
    typename LhsType,
    typename RhsType
    UE_REQUIRES(TModels_V<CEqualityComparableWith, LhsType*, RhsType*>)
>
[[nodiscard]] UE_FORCEINLINE_HINT bool operator!=(const TSoftObjectPtr<LhsType>& Lhs, const TSoftObjectPtr<RhsType>& Rhs)
{
    return !(Lhs == Rhs);
}
template <
    typename LhsType,
    typename RhsType
    UE_REQUIRES(!TModels_V<CEqualityComparableWith, LhsType*, RhsType*>)
>
UE_SOFTOBJECTPTR_CONVERSION_DEPRECATED(5.5, "Comparing TSoftObjectPtrs of incompatible pointer types has been deprecated.")
[[nodiscard]] UE_FORCEINLINE_HINT bool operator!=(const TSoftObjectPtr<LhsType>& Lhs, const TSoftObjectPtr<RhsType>& Rhs)
{
    return !(Lhs == Rhs);
}
template <
    typename LhsType,
    typename RhsType
    UE_REQUIRES(TModels_V<CEqualityComparableWith, LhsType*, RhsType*>)
>
[[nodiscard]] UE_FORCEINLINE_HINT bool operator!=(const TSoftObjectPtr<LhsType>& Lhs, RhsType* Rhs)
{
    return !(Lhs == Rhs);
}
template <
    typename LhsType,
    typename RhsType
    UE_REQUIRES(!TModels_V<CEqualityComparableWith, LhsType*, RhsType*>)
>
UE_SOFTOBJECTPTR_CONVERSION_DEPRECATED(5.5, "Comparing TSoftObjectPtrs of incompatible pointer types has been deprecated.")
[[nodiscard]] UE_FORCEINLINE_HINT bool operator!=(const TSoftObjectPtr<LhsType>& Lhs, RhsType* Rhs)
{
    return !(Lhs == Rhs);
}
template <typename LhsType>
[[nodiscard]] UE_FORCEINLINE_HINT bool operator!=(const TSoftObjectPtr<LhsType>& Lhs, TYPE_OF_NULLPTR Rhs)
{
    return !(Lhs == Rhs);
}
template <
    typename LhsType,
    typename RhsType
    UE_REQUIRES(TModels_V<CEqualityComparableWith, LhsType*, RhsType*>)
>
[[nodiscard]] UE_FORCEINLINE_HINT bool operator!=(LhsType* Lhs, const TSoftObjectPtr<RhsType>& Rhs)
{
    return !(Lhs == Rhs);
}
template <
    typename LhsType,
    typename RhsType
    UE_REQUIRES(!TModels_V<CEqualityComparableWith, LhsType*, RhsType*>)
>
UE_SOFTOBJECTPTR_CONVERSION_DEPRECATED(5.5, "Comparing TSoftObjectPtrs of incompatible pointer types has been deprecated.")
[[nodiscard]] UE_FORCEINLINE_HINT bool operator!=(LhsType* Lhs, const TSoftObjectPtr<RhsType>& Rhs)
{
    return !(Lhs == Rhs);
}
template <typename RhsType>
[[nodiscard]] UE_FORCEINLINE_HINT bool operator!=(TYPE_OF_NULLPTR Lhs, const TSoftObjectPtr<RhsType>& Rhs)
{
    return !(Lhs == Rhs);
}
#endif
 
template<class T>
[[nodiscard]] UE_FORCEINLINE_HINT uint32 GetTypeHash(const TSoftObjectPtr<T>& Ptr)
{
    return Ptr.GetPtrTypeHash();
}
 
template<class T>
FArchive& operator<<(FArchive& Ar, TSoftObjectPtr<T>& Ptr)
{
    Ptr.Serialize(Ar);
    return Ar;
}
 
 
template<class T> struct TIsPODType<TSoftObjectPtr<T> > { enum { Value = TIsPODType<FSoftObjectPtr>::Value }; };
template<class T> struct TIsWeakPointerType<TSoftObjectPtr<T> > { enum { Value = TIsWeakPointerType<FSoftObjectPtr>::Value }; };
template<class T> struct TIsSoftObjectPointerType<TSoftObjectPtr<T>> { enum { Value = TIsSoftObjectPointerType<FSoftObjectPtr>::Value }; };
 
template <typename T>
struct TCallTraits<TSoftObjectPtr<T>> : public TCallTraitsBase<TSoftObjectPtr<T>>
{
    using ConstPointerType = TSoftObjectPtr<const T>;
};
 
template <class T>
[[nodiscard]] TSoftObjectPtr<T> MakeSoftObjectPtr(T* Object)
{
    static_assert(std::is_base_of_v<UObject, T>, "Type must derive from UObject");
    return TSoftObjectPtr<T>(Object);
}
 
template <class T>
[[nodiscard]] TSoftObjectPtr<T> MakeSoftObjectPtr(TObjectPtr<T> Object)
{
    static_assert(std::is_base_of_v<UObject, T>, "Type must derive from UObject");
    return TSoftObjectPtr<T>(ToRawPtr(Object));
}
 
template<class TClass=UObject>
class TSoftClassPtr
{
    template <class TClassA>
    friend class TSoftClassPtr;
 
public:
    using ElementType = TClass;
    
    [[nodiscard]] UE_FORCEINLINE_HINT TSoftClassPtr() = default;
    [[nodiscard]] UE_FORCEINLINE_HINT TSoftClassPtr(const TSoftClassPtr& Other) = default;
    [[nodiscard]] UE_FORCEINLINE_HINT TSoftClassPtr(TSoftClassPtr&& Other) = default;
    UE_FORCEINLINE_HINT ~TSoftClassPtr() = default;
    UE_FORCEINLINE_HINT TSoftClassPtr& operator=(const TSoftClassPtr& Other) = default;
    UE_FORCEINLINE_HINT TSoftClassPtr& operator=(TSoftClassPtr&& Other) = default;
        
    template <
        class TClassA
        UE_REQUIRES(std::is_convertible_v<TClassA*, TClass*>)
    >
    [[nodiscard]] UE_FORCEINLINE_HINT TSoftClassPtr(const TSoftClassPtr<TClassA>& Other)
        : SoftObjectPtr(Other.SoftObjectPtr)
    {
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT TSoftClassPtr(const UClass* From)
        : SoftObjectPtr(From)
    {
    }
 
    [[nodiscard]] explicit UE_FORCEINLINE_HINT TSoftClassPtr(const FSoftObjectPath& ObjectPath)
        : SoftObjectPtr(ObjectPath)
    {
    }
 
    UE_FORCEINLINE_HINT void Reset()
    {
        SoftObjectPtr.Reset();
    }
 
    UE_FORCEINLINE_HINT void ResetWeakPtr()
    {
        SoftObjectPtr.ResetWeakPtr();
    }
 
    UE_FORCEINLINE_HINT void operator=(const UClass* From)
    {
        SoftObjectPtr = From;
    }
 
    UE_FORCEINLINE_HINT void operator=(const FSoftObjectPath& ObjectPath)
    {
        SoftObjectPtr = ObjectPath;
    }
 
    template <
        class TClassA
        UE_REQUIRES(std::is_convertible_v<TClassA*, TClass*>)
    >
    inline TSoftClassPtr& operator=(const TWeakObjectPtr<TClassA>& Other)
    {
        SoftObjectPtr = Other;
        return *this;
    }
 
    template <
        class TClassA
        UE_REQUIRES(std::is_convertible_v<TClassA*, TClass*>)
    >
    inline TSoftClassPtr& operator=(const TSoftObjectPtr<TClassA>& Other)
    {
        SoftObjectPtr = Other.SoftObjectPtr;
        return *this;
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool operator==(const TSoftClassPtr& Other) const
    {
        return SoftObjectPtr == Other.SoftObjectPtr;
    }
#if !PLATFORM_COMPILER_HAS_GENERATED_COMPARISON_OPERATORS
    [[nodiscard]] UE_FORCEINLINE_HINT bool operator!=(const TSoftClassPtr& Other) const
    {
        return SoftObjectPtr != Other.SoftObjectPtr;
    }
#endif
 
    [[nodiscard]] inline UClass* Get() const
    {
        UClass* Class = dynamic_cast<UClass*>(SoftObjectPtr.Get());
        if (!Class || !Class->IsChildOf(TClass::StaticClass()))
        {
            return nullptr;
        }
        return Class;
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT UClass& operator*() const
    {
        return *Get();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT UClass* operator->() const
    {
        return Get();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool IsValid() const
    {
        // This also does the UClass type check
        return Get() != nullptr;
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool IsPending() const
    {
        return SoftObjectPtr.IsPending();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool IsNull() const
    {
        return SoftObjectPtr.IsNull();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT const FSoftObjectPath& GetUniqueID() const
    {
        return SoftObjectPtr.GetUniqueID();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT const FSoftObjectPath& ToSoftObjectPath() const
    {
        return SoftObjectPtr.GetUniqueID();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT FString ToString() const
    {
        return ToSoftObjectPath().ToString();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT FString GetLongPackageName() const
    {
        return ToSoftObjectPath().GetLongPackageName();
    }
    
    [[nodiscard]] UE_FORCEINLINE_HINT FName GetLongPackageFName() const
    {
        return ToSoftObjectPath().GetLongPackageFName();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT FString GetAssetName() const
    {
        return ToSoftObjectPath().GetAssetName();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT explicit operator bool() const
    {
        return IsValid();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT uint32 GetPtrTypeHash() const
    {
        return GetTypeHash(static_cast<const TPersistentObjectPtr<FSoftObjectPath>&>(SoftObjectPtr));
    }
 
    UClass* LoadSynchronous() const
    {
        UObject* Asset = SoftObjectPtr.LoadSynchronous();
        UClass* Class = dynamic_cast<UClass*>(Asset);
        if (!Class || !Class->IsChildOf(TClass::StaticClass()))
        {
            return nullptr;
        }
        return Class;
    }
 
    int32 LoadAsync(FLoadSoftObjectPathAsyncDelegate InCompletionDelegate, FLoadAssetAsyncOptionalParams InOptionalParams = FLoadAssetAsyncOptionalParams()) const
    {
        return SoftObjectPtr.ToSoftObjectPath().LoadAsync(MoveTemp(InCompletionDelegate), MoveTemp(InOptionalParams));
    }
 
    inline void Serialize(FArchive& Ar)
    {
        Ar << static_cast<FSoftObjectPtr&>(SoftObjectPtr);
    }
 
private:
    FSoftObjectPtr SoftObjectPtr;
};
 
template <class T> struct TIsPODType<TSoftClassPtr<T> > { enum { Value = TIsPODType<FSoftObjectPtr>::Value }; };
template <class T> struct TIsWeakPointerType<TSoftClassPtr<T> > { enum { Value = TIsWeakPointerType<FSoftObjectPtr>::Value }; };
 
template <typename T>
struct TCallTraits<TSoftClassPtr<T>> : public TCallTraitsBase<TSoftClassPtr<T>>
{
    using ConstPointerType = TSoftClassPtr<const T>;
};
 
template <class T>
[[nodiscard]] TSoftClassPtr<std::remove_cv_t<T>> MakeSoftClassPtr(T* Object)
{
    static_assert(std::is_base_of_v<UClass, T>, "Type must derive from UClass");
    return TSoftClassPtr<std::remove_cv_t<T>>(Object);
}
 
template <class T>
[[nodiscard]] TSoftClassPtr<std::remove_cv_t<T>> MakeSoftClassPtr(TObjectPtr<T> Object)
{
    static_assert(std::is_base_of_v<UClass, T>, "Type must derive from UClass");
    return TSoftClassPtr<std::remove_cv_t<T>>(ToRawPtr(Object));
}
 
struct FSoftObjectPtrFastLess : private FSoftObjectPathFastLess
{
    template <typename SoftObjectPtrType>
    bool operator()(const SoftObjectPtrType& Lhs, const SoftObjectPtrType& Rhs) const
    {
        return FSoftObjectPathFastLess::operator()(Lhs.ToSoftObjectPath(), Rhs.ToSoftObjectPath());
    }
};
 
struct FSoftObjectPtrLexicalLess : private FSoftObjectPathLexicalLess
{
    template <typename SoftObjectPtrType>
    bool operator()(const SoftObjectPtrType& Lhs, const SoftObjectPtrType& Rhs) const
    {
        return FSoftObjectPathLexicalLess::operator()(Lhs.ToSoftObjectPath(), Rhs.ToSoftObjectPath());
    }
};
 
template<class T>
T* TSoftObjectPtr<T>::Get() const
{
    return dynamic_cast<T*>(SoftObjectPtr.Get());
}
 
#if !PLATFORM_COMPILER_HAS_GENERATED_COMPARISON_OPERATORS
template<class TClass>
[[nodiscard]] UE_FORCEINLINE_HINT bool operator==(const UClass* Lhs, const TSoftClassPtr<TClass>& Rhs)
{
    return Rhs == Lhs;
}
 
template<class TClass>
[[nodiscard]] UE_FORCEINLINE_HINT bool operator!=(const UClass* Lhs, const TSoftClassPtr<TClass>& Rhs)
{
    return Rhs != Lhs;
}
#endif
 
template<class TClass>
[[nodiscard]] UE_FORCEINLINE_HINT uint32 GetTypeHash(const TSoftClassPtr<TClass>& Ptr)
{
    return Ptr.GetPtrTypeHash();
}
 
template<class TClass>
FArchive& operator<<(FArchive& Ar, TSoftClassPtr<TClass>& Ptr)
{
    Ptr.Serialize(Ar);
    return Ar;
}