SoftObjectPath.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Algo/Transform.h"
#include "Containers/Array.h"
#include "Containers/Set.h"
#include "Containers/StringFwd.h"
#include "Containers/StringOverload.h"
#include "Containers/StringView.h"
#include "Containers/Utf8String.h"
#include "Containers/UnrealString.h"
#include "CoreTypes.h"
#include "HAL/ThreadSafeCounter.h"
#include "HAL/ThreadSingleton.h"
#include "Misc/CString.h"
#include "Serialization/ArchiveUObject.h"
#include "Serialization/StructuredArchive.h"
#include "Templates/Function.h"
#include "Templates/TypeHash.h"
#include "Templates/UnrealTemplate.h"
#include "UObject/Class.h"
#include "UObject/NameTypes.h"
#include "UObject/Object.h"
#include "UObject/ObjectMacros.h"
#include "UObject/ObjectPtr.h"
#include "UObject/StructOpsTypeTraits.h"
#include "UObject/TopLevelAssetPath.h"
#include "UObject/UObjectGlobals.h"
#include "UObject/UObjectHash.h"
 
#include "SoftObjectPath.generated.h"
 
class FArchive;
class FCbWriter;
class FOutputDevice;
struct FPropertyTag;
struct FUObjectSerializeContext;
 
// Wrapper for UE_DEPRECATED that can be selectively enabled.
#define UE_SOFTOBJECTPATH_FSTRING_DEPRECATED(Version, Message) /*UE_DEPRECATED(Version, Message)*/
 
DECLARE_DELEGATE_TwoParams(FLoadSoftObjectPathAsyncDelegate, const FSoftObjectPath&, UObject*);
 
constexpr inline auto FSoftObjectPath_DefaultPreFixupForPIEFunction = [](int32, FSoftObjectPath&) {};
 
USTRUCT(BlueprintType, meta=(HasNativeMake="/Script/Engine.KismetSystemLibrary.MakeSoftObjectPath", HasNativeBreak="/Script/Engine.KismetSystemLibrary.BreakSoftObjectPath"))
struct FSoftObjectPath
{
    GENERATED_BODY()
public:
 
    [[nodiscard]] FSoftObjectPath() = default;
    [[nodiscard]] FSoftObjectPath(const FSoftObjectPath& Other) = default;
    [[nodiscard]] FSoftObjectPath(FSoftObjectPath&& Other) = default;
    ~FSoftObjectPath() = default;
    FSoftObjectPath& operator=(const FSoftObjectPath& Path) = default;
    FSoftObjectPath& operator=(FSoftObjectPath&& Path) = default;
 
    [[nodiscard]] FSoftObjectPath(const FString& Path)
    {
        SetPath(FStringView(Path));
    }
    UE_SOFTOBJECTPATH_FSTRING_DEPRECATED(5.6, "FSoftObjectPath with a wide string subpath has been deprecated - please use a UTF8 subpath instead.")
    [[nodiscard]] explicit FSoftObjectPath(FTopLevelAssetPath InAssetPath, TStringOverload<FWideString> InSubPathString)
    {
        SetPath(InAssetPath, FUtf8String(InSubPathString.MoveTemp()));
    }
    [[nodiscard]] explicit FSoftObjectPath(FTopLevelAssetPath InAssetPath, TStringOverload<FUtf8String> InSubPathString)
    {
        SetPath(InAssetPath, InSubPathString.MoveTemp());
    }
    UE_DEPRECATED(5.6, "FSoftObjectPath which takes a package name and asset name has been deprecated - please pass FTopLevelAssetPath instead.")
    [[nodiscard]] explicit FSoftObjectPath(FName InPackageName, FName InAssetName, const FString& InSubPathString)
    {
        SetPath(FTopLevelAssetPath(InPackageName, InAssetName), FUtf8String(InSubPathString));
    }
 
    [[nodiscard]] explicit FSoftObjectPath(FTopLevelAssetPath InAssetPath)
    {
        SetPath(InAssetPath);
    }
    [[nodiscard]] explicit FSoftObjectPath(FWideStringView Path)
    {
        SetPath(Path);
    }
    [[nodiscard]] explicit FSoftObjectPath(FAnsiStringView Path)
    {
        SetPath(Path);
    }
    [[nodiscard]] explicit FSoftObjectPath(const WIDECHAR* Path)
    {
        SetPath(FWideStringView(Path));
    }
    [[nodiscard]] explicit FSoftObjectPath(const ANSICHAR* Path)
    {
        SetPath(FAnsiStringView(Path));
    }
    [[nodiscard]] explicit FSoftObjectPath(TYPE_OF_NULLPTR)
    {
    }
 
    template <typename T>
    [[nodiscard]] FSoftObjectPath(const TObjectPtr<T>& InObject)
    {
        // Avoid conversion to string if the object is resolved
        if (InObject.IsResolved())
        {
            // reinterpret_cast here is used because T may be an incomplete type, but we only support using TObjectPtr for UObject-derived types 
            SetPath(reinterpret_cast<const UObject*>(InObject.Get()));
        }
        else
        {
            SetPath(InObject.GetPathName());
        }
    }
 
    [[nodiscard]] FSoftObjectPath(const FObjectPtr& InObject)
    {
        // Avoid conversion to string if the object is resolved
        if (InObject.IsResolved())
        {
            SetPath(InObject.Get());
        }
        else
        {
            SetPath(InObject.GetPathName());
        }
    }
 
    [[nodiscard]] FSoftObjectPath(const UObject* InObject)
    {
        // Avoid conversion to string 
        SetPath(InObject);
    }
 
    UE_DEPRECATED(5.6, "FSoftObjectPath::ConstructFromPackageAssetSubpath has been deprecated - please use ConstructFromAssetPathAndSubpath instead.")
    [[nodiscard]] COREUOBJECT_API static FSoftObjectPath ConstructFromPackageAssetSubpath(FName InPackageName, FName InAssetName, const FString& InSubPathString);
    UE_DEPRECATED(5.6, "FSoftObjectPath::ConstructFromPackageAsset has been deprecated - please use ConstructFromAssetPath instead.")
    [[nodiscard]] COREUOBJECT_API static FSoftObjectPath ConstructFromPackageAsset(FName InPackageName, FName InAssetName);
    UE_SOFTOBJECTPATH_FSTRING_DEPRECATED(5.6, "FSoftObjectPath::ConstructFromAssetPathAndSubpath with a wide string subpath has been deprecated - please use a UTF8 subpath instead.")
    [[nodiscard]] COREUOBJECT_API static FSoftObjectPath ConstructFromAssetPathAndSubpath(FTopLevelAssetPath InAssetPath, TStringOverload<FWideString> InSubPathString);
    [[nodiscard]] COREUOBJECT_API static FSoftObjectPath ConstructFromAssetPathAndSubpath(FTopLevelAssetPath InAssetPath, TStringOverload<FUtf8String> InSubPathString);
    [[nodiscard]] COREUOBJECT_API static FSoftObjectPath ConstructFromAssetPath(FTopLevelAssetPath InAssetPath);
    [[nodiscard]] COREUOBJECT_API static FSoftObjectPath ConstructFromStringPath(FString&& InPath);
    [[nodiscard]] COREUOBJECT_API static FSoftObjectPath ConstructFromStringPath(FStringView InPath);
    [[nodiscard]] COREUOBJECT_API static FSoftObjectPath ConstructFromStringPath(FUtf8StringView InPath);
    [[nodiscard]] COREUOBJECT_API static FSoftObjectPath ConstructFromObject(const UObject* InObject);
    [[nodiscard]] COREUOBJECT_API static FSoftObjectPath ConstructFromObject(const FObjectPtr& InObject);
    template <typename T>
    [[nodiscard]] static FSoftObjectPath ConstructFromObject(const TObjectPtr<T>& InObject)
    {
        return ConstructFromObject(InObject.Get());
    }
 
    FSoftObjectPath& operator=(const FTopLevelAssetPath Path)
    {
        SetPath(Path);
        return *this;
    }
    FSoftObjectPath& operator=(const FString& Path)
    {
        SetPath(FStringView(Path));
        return *this;
    }
    FSoftObjectPath& operator=(FWideStringView Path)
    {
        SetPath(Path);
        return *this;
    }
    FSoftObjectPath& operator=(FAnsiStringView Path)
    {
        SetPath(Path);
        return *this;
    }
    FSoftObjectPath& operator=(const WIDECHAR* Path)
    {
        SetPath(FWideStringView(Path));
        return *this;
    }
    FSoftObjectPath& operator=(const ANSICHAR* Path)
    {
        SetPath(FAnsiStringView(Path));
        return *this;
    }
    FSoftObjectPath& operator=(TYPE_OF_NULLPTR)
    {
        Reset();
        return *this;
    }
 
    [[nodiscard]] COREUOBJECT_API FString ToString() const;
 
    COREUOBJECT_API void ToString(FStringBuilderBase& Builder) const;
    COREUOBJECT_API void ToString(FUtf8StringBuilderBase& Builder) const;
 
    COREUOBJECT_API void AppendString(FString& Builder) const;
    COREUOBJECT_API void AppendString(FStringBuilderBase& Builder) const;
    COREUOBJECT_API void AppendString(FUtf8StringBuilderBase& Builder) const;
 
    [[nodiscard]] FTopLevelAssetPath GetAssetPath() const
    {
        return AssetPath;
    }
 
    [[nodiscard]] FSoftObjectPath GetWithoutSubPath() const
    {
        return FSoftObjectPath(AssetPath);
    }
 
    [[nodiscard]] inline FString GetAssetPathString() const
    {
        if (AssetPath.IsNull())
        {
            return FString();
        }
 
        return AssetPath.ToString();
    }
 
    UE_SOFTOBJECTPATH_FSTRING_DEPRECATED(5.6, "FSoftObjectPath::GetSubPathString has been deprecated - please use GetSubPathUtf8String() instead.")
    [[nodiscard]] UE_FORCEINLINE_HINT FString GetSubPathString() const
    {
        return FString(SubPathString);
    }
    [[nodiscard]] UE_FORCEINLINE_HINT const FUtf8String& GetSubPathUtf8String() const
    {
        return SubPathString;
    }
 
    UE_SOFTOBJECTPATH_FSTRING_DEPRECATED(5.6, "FSoftObjectPath::ConstructFromAssetPathAndSubpath with a wide string subpath has been deprecated - please use a UTF8 subpath instead.")
    UE_FORCEINLINE_HINT void SetSubPathString(TStringOverload<FWideString> InSubPathString)
    {
        SubPathString = FUtf8String(InSubPathString.MoveTemp());
    }
    UE_FORCEINLINE_HINT void SetSubPathString(TStringOverload<FUtf8String> InSubPathString)
    {
        SubPathString = InSubPathString.MoveTemp();
    }
 
    [[nodiscard]] FString GetLongPackageName() const
    {
        FName PackageName = GetAssetPath().GetPackageName();
        return PackageName.IsNone() ? FString() : PackageName.ToString();
    }
 
    [[nodiscard]] FName GetLongPackageFName() const
    {
        return GetAssetPath().GetPackageName();
    }
 
    [[nodiscard]] FString GetAssetName() const
    {
        FName AssetName = GetAssetPath().GetAssetName();
        return AssetName.IsNone() ? FString() : AssetName.ToString();
    }
 
    [[nodiscard]] FName GetAssetFName() const
    {
        return GetAssetPath().GetAssetName();
    }
 
    COREUOBJECT_API void SetPath(const FTopLevelAssetPath& InAssetPath);
    UE_SOFTOBJECTPATH_FSTRING_DEPRECATED(5.6, "FSoftObjectPath::SetPath with a wide string subpath has been deprecated - please use a UTF8 subpath instead.")
    COREUOBJECT_API void SetPath(const FTopLevelAssetPath& InAssetPath, TStringOverload<FWideString> InSubPathString);
    COREUOBJECT_API void SetPath(const FTopLevelAssetPath& InAssetPath, TStringOverload<FUtf8String> InSubPathString);
    COREUOBJECT_API void SetPath(FWideStringView Path);
    COREUOBJECT_API void SetPath(FAnsiStringView Path);
    COREUOBJECT_API void SetPath(FUtf8StringView Path);
    COREUOBJECT_API void SetPath(const UObject* InObject);
    void SetPath(const WIDECHAR* Path)
    {
        SetPath(FWideStringView(Path));
    }
    void SetPath(const ANSICHAR* Path)
    {
        SetPath(FAnsiStringView(Path));
    }
    void SetPath(const FString& Path)
    {
        SetPath(FStringView(Path));
    }
 
    COREUOBJECT_API bool RemapPackage(FName OldPackageName, FName NewPackageName);
 
    COREUOBJECT_API UObject* TryLoad(FUObjectSerializeContext* InLoadContext = nullptr) const;
 
    COREUOBJECT_API int32 LoadAsync(FLoadSoftObjectPathAsyncDelegate InCompletionDelegate, FLoadAssetAsyncOptionalParams InOptionalParams = FLoadAssetAsyncOptionalParams()) const;
 
    [[nodiscard]] COREUOBJECT_API UObject* ResolveObject() const;
 
    void Reset()
    {
        AssetPath.Reset();
        SubPathString.Reset();
    }
    
    [[nodiscard]] UE_FORCEINLINE_HINT bool IsValid() const
    {
        return AssetPath.IsValid();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool IsNull() const
    {
        return AssetPath.IsNull();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool IsAsset() const
    {
        return !AssetPath.IsNull() && SubPathString.IsEmpty();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool IsSubobject() const
    {
        return !AssetPath.IsNull() && !SubPathString.IsEmpty();
    }
 
    [[nodiscard]] bool LexicalLess(const FSoftObjectPath& Other) const
    {
        int32 PathCompare = AssetPath.Compare(Other.AssetPath);
        if (PathCompare != 0)
        {
            return PathCompare < 0;
        }
        return SubPathString.Compare(Other.SubPathString) < 0; 
    }
 
    [[nodiscard]] bool FastLess(const FSoftObjectPath& Other) const
    {
        int32 PathCompare = AssetPath.CompareFast(Other.AssetPath);
        if (PathCompare != 0)
        {
            return PathCompare < 0;
        }
        return SubPathString.Compare(Other.SubPathString) < 0; 
    }
 
    COREUOBJECT_API bool Serialize(FArchive& Ar);
    COREUOBJECT_API bool Serialize(FStructuredArchive::FSlot Slot);
    [[nodiscard]] COREUOBJECT_API bool operator==(FSoftObjectPath const& Other) const;
 
#if !PLATFORM_COMPILER_HAS_GENERATED_COMPARISON_OPERATORS
    [[nodiscard]] bool operator!=(FSoftObjectPath const& Other) const
    {
        return !(*this == Other);
    }
#endif
 
    COREUOBJECT_API bool ExportTextItem(FString& ValueStr, FSoftObjectPath const& DefaultValue, UObject* Parent, int32 PortFlags, UObject* ExportRootScope) const;
    COREUOBJECT_API bool ImportTextItem(const TCHAR*& Buffer, int32 PortFlags, UObject* Parent, FOutputDevice* ErrorText, FArchive* InSerializingArchive = nullptr);
    COREUOBJECT_API bool SerializeFromMismatchedTag(struct FPropertyTag const& Tag, FStructuredArchive::FSlot Slot);
 
    COREUOBJECT_API void SerializePath(FArchive& Ar);
 
    COREUOBJECT_API void SerializePathWithoutFixup(FArchive& Ar);
 
    COREUOBJECT_API bool PreSavePath(bool* bReportSoftObjectPathRedirects = nullptr);
 
    COREUOBJECT_API void PostLoadPath(FArchive* InArchive) const;
 
    COREUOBJECT_API bool FixupForPIE(TFunctionRef<void(int32, FSoftObjectPath&)> InPreFixupForPIECustomFunction = FSoftObjectPath_DefaultPreFixupForPIEFunction);
 
    COREUOBJECT_API bool FixupForPIE(int32 PIEInstance, TFunctionRef<void(int32, FSoftObjectPath&)> InPreFixupForPIECustomFunction = FSoftObjectPath_DefaultPreFixupForPIEFunction);
 
    COREUOBJECT_API bool FixupCoreRedirects();
 
    [[nodiscard]] inline friend uint32 GetTypeHash(FSoftObjectPath const& This)
    {
        uint32 Hash = GetTypeHash(This.AssetPath);
            
        if (!This.SubPathString.IsEmpty())
        {
            Hash = HashCombineFast(Hash, GetTypeHash(This.SubPathString));
        }
 
        return Hash;
    }
 
    [[nodiscard]] static COREUOBJECT_API FSoftObjectPath GetOrCreateIDForObject(FObjectPtr Object);
    [[nodiscard]] static UE_FORCEINLINE_HINT FSoftObjectPath GetOrCreateIDForObject(const UObject* Object)
    {
        return GetOrCreateIDForObject(FObjectPtr(const_cast<UObject*>(Object)));
    }
    template <typename T>
    [[nodiscard]] static UE_FORCEINLINE_HINT FSoftObjectPath GetOrCreateIDForObject(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
 
        return GetOrCreateIDForObject(FObjectPtr(Object));
    }
 
    static COREUOBJECT_API void AddPIEPackageName(FName NewPIEPackageName);
    
    static COREUOBJECT_API void ClearPIEPackageNames();
 
#if WITH_EDITOR
    static COREUOBJECT_API FName NAME_Untracked;
#endif
private:
    UPROPERTY()
    FTopLevelAssetPath AssetPath;
 
    UPROPERTY()
    FUtf8String SubPathString;
 
    static COREUOBJECT_API TSet<FName> PIEPackageNames;
 
    [[nodiscard]] COREUOBJECT_API UObject* ResolveObjectInternal() const;
 
    COREUOBJECT_API friend void SerializeForLog(FCbWriter& Writer, const FSoftObjectPath& Value);
    friend struct Z_Construct_UScriptStruct_FSoftObjectPath_Statics;
};
 
template<>
struct TStructOpsTypeTraits<FSoftObjectPath> : public TStructOpsTypeTraitsBase2<FSoftObjectPath>
{
    enum
    {
        WithZeroConstructor = true,
        WithStructuredSerializer = true,
        WithCopy = true,
        WithIdenticalViaEquality = true,
        WithExportTextItem = true,
        WithImportTextItem = true,
        WithStructuredSerializeFromMismatchedTag = true,
    };
    static constexpr EPropertyObjectReferenceType WithSerializerObjectReferences = EPropertyObjectReferenceType::Soft;
};
 
 
struct FSoftObjectPathFastLess
{
    [[nodiscard]] bool operator()(const FSoftObjectPath& Lhs, const FSoftObjectPath& Rhs) const
    {
        return Lhs.FastLess(Rhs);
    }
};
 
struct FSoftObjectPathLexicalLess
{
    [[nodiscard]] bool operator()(const FSoftObjectPath& Lhs, const FSoftObjectPath& Rhs) const
    {
        return Lhs.LexicalLess(Rhs);
    }
};
 
inline FStringBuilderBase& operator<<(FStringBuilderBase& Builder, const FSoftObjectPath& Path)
{
    Path.ToString(Builder);
    return Builder;
}
inline FUtf8StringBuilderBase& operator<<(FUtf8StringBuilderBase& Builder, const FSoftObjectPath& Path)
{
    Path.ToString(Builder);
    return Builder;
}
 
USTRUCT(BlueprintType, meta=(HasNativeMake="/Script/Engine.KismetSystemLibrary.MakeSoftClassPath", HasNativeBreak="/Script/Engine.KismetSystemLibrary.BreakSoftClassPath"))
struct FSoftClassPath : public FSoftObjectPath
{
    GENERATED_BODY()
public:
    [[nodiscard]] FSoftClassPath() = default;
    [[nodiscard]] FSoftClassPath(const FSoftClassPath& Other) = default;
    [[nodiscard]] FSoftClassPath(FSoftClassPath&& Other) = default;
    ~FSoftClassPath() = default;
    FSoftClassPath& operator=(const FSoftClassPath& Path) = default;
    FSoftClassPath& operator=(FSoftClassPath&& Path) = default;
 
    [[nodiscard]] FSoftClassPath(const FString& PathString)
        : FSoftObjectPath(PathString)
    {
    }
 
    [[nodiscard]] FSoftClassPath(const UClass* InClass)
        : FSoftObjectPath(InClass)
    {
    }
 
    template<typename T>
    UClass* TryLoadClass() const
    {
        if ( IsValid() )
        {
            return LoadClass<T>(nullptr, *ToString(), nullptr, LOAD_None, nullptr);
        }
 
        return nullptr;
    }
 
    [[nodiscard]] COREUOBJECT_API UClass* ResolveClass() const;
 
    COREUOBJECT_API bool SerializeFromMismatchedTag(const FPropertyTag& Tag, FStructuredArchive::FSlot Slot);
 
    [[nodiscard]] static COREUOBJECT_API FSoftClassPath GetOrCreateIDForClass(const UClass *InClass);
 
private:
    [[nodiscard]] explicit FSoftClassPath(const UObject* InObject)
    {
    }
 
    static COREUOBJECT_API FSoftObjectPath GetOrCreateIDForObject(const UObject *Object);
};
 
template<>
struct TStructOpsTypeTraits<FSoftClassPath> : public TStructOpsTypeTraitsBase2<FSoftClassPath>
{
    enum
    {
        WithZeroConstructor = true,
        WithSerializer = true,
        WithCopy = true,
        WithIdenticalViaEquality = true,
        WithExportTextItem = true,
        WithImportTextItem = true,
        WithStructuredSerializeFromMismatchedTag = true,
    };
    static constexpr EPropertyObjectReferenceType WithSerializerObjectReferences = EPropertyObjectReferenceType::Soft;
};
 
enum class ESoftObjectPathCollectType : uint8
{
    NonPackage,
    PackageHeader,
    NeverCollect,
    EditorOnlyCollect,
    AlwaysCollect,
};
 
namespace UE::SoftObjectPath
{
 
inline bool IsPackageType(ESoftObjectPathCollectType CollectType)
{
    return CollectType != ESoftObjectPathCollectType::NonPackage;
}
 
inline bool IsObjectType(ESoftObjectPathCollectType CollectType)
{
    return (CollectType != ESoftObjectPathCollectType::NonPackage)
        & (CollectType != ESoftObjectPathCollectType::PackageHeader);
}
 
inline bool IsCollectable(ESoftObjectPathCollectType CollectType)
{
    return (CollectType != ESoftObjectPathCollectType::NonPackage)
        & (CollectType != ESoftObjectPathCollectType::PackageHeader)
        & (CollectType != ESoftObjectPathCollectType::NeverCollect);
}
 
}
 
enum class ESoftObjectPathSerializeType : uint8
{
    NeverSerialize,
    SkipSerializeIfArchiveHasSize,
    AlwaysSerialize,
};
 
UE_DECLARE_THREAD_SINGLETON_TLS(class FSoftObjectPathThreadContext, COREUOBJECT_API)
 
class FSoftObjectPathThreadContext : public TThreadSingleton<FSoftObjectPathThreadContext>
{
    friend TThreadSingleton<FSoftObjectPathThreadContext>;
    friend struct FSoftObjectPathSerializationScope;
 
    [[nodiscard]] FSoftObjectPathThreadContext()
    {
    }
 
    struct FSerializationOptions
    {
        FName PackageName;
        FName PropertyName;
        ESoftObjectPathCollectType CollectType;
        ESoftObjectPathSerializeType SerializeType;
 
        [[nodiscard]] FSerializationOptions()
            : CollectType(ESoftObjectPathCollectType::AlwaysCollect)
        {
        }
 
        [[nodiscard]] explicit FSerializationOptions(FName InPackageName, FName InPropertyName, ESoftObjectPathCollectType InCollectType, ESoftObjectPathSerializeType InSerializeType)
            : PackageName(InPackageName)
            , PropertyName(InPropertyName)
            , CollectType(InCollectType)
            , SerializeType(InSerializeType)
        {
        }
    };
 
    TArray<FSerializationOptions> OptionStack;
public:
    COREUOBJECT_API bool GetSerializationOptions(FName& OutPackageName, FName& OutPropertyName, ESoftObjectPathCollectType& OutCollectType, ESoftObjectPathSerializeType& OutSerializeType, FArchive* Archive = nullptr) const;
};
 
struct FSoftObjectPathSerializationScope
{
    [[nodiscard]] explicit FSoftObjectPathSerializationScope(FName SerializingPackageName, FName SerializingPropertyName, ESoftObjectPathCollectType CollectType, ESoftObjectPathSerializeType SerializeType)
    {
        FSoftObjectPathThreadContext::Get().OptionStack.Emplace(SerializingPackageName, SerializingPropertyName, CollectType, SerializeType);
    }
 
    [[nodiscard]] explicit FSoftObjectPathSerializationScope(ESoftObjectPathCollectType CollectType)
    {
        FSoftObjectPathThreadContext::Get().OptionStack.Emplace(NAME_None, NAME_None, CollectType, ESoftObjectPathSerializeType::AlwaysSerialize);
    }
 
    ~FSoftObjectPathSerializationScope()
    {
        FSoftObjectPathThreadContext::Get().OptionStack.Pop();
    }
};
 
USTRUCT(BlueprintType)
struct FFilePath
{
    GENERATED_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = FilePath)
    FString FilePath;
};
 
USTRUCT(BlueprintType)
struct FDirectoryPath
{
    GENERATED_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Path)
    FString Path;
};
 
// Fixup archive
struct FSoftObjectPathFixupArchive : public FArchiveUObject
{
    [[nodiscard]] explicit FSoftObjectPathFixupArchive(TFunction<void(FSoftObjectPath&)> InFixupFunction)
        : FixupFunction(InFixupFunction)
    {
        this->SetIsSaving(true);
        this->ArShouldSkipBulkData = true;
        this->SetShouldSkipCompilingAssets(true);
    }
 
    [[nodiscard]] explicit FSoftObjectPathFixupArchive(const FString& InOldAssetPathString, const FString& InNewAssetPathString)
        : FSoftObjectPathFixupArchive([OldAssetPathString = InOldAssetPathString, NewAssetPath = FTopLevelAssetPath(InNewAssetPathString)](FSoftObjectPath& Value)
        {
            if (!Value.IsNull() && Value.GetAssetPathString().Equals(OldAssetPathString, ESearchCase::IgnoreCase))
            {
                Value = FSoftObjectPath(NewAssetPath, Value.GetSubPathUtf8String());
            }
        })
    {
    }
 
    FArchive& operator<<(FSoftObjectPath& Value) override
    {
        FixupFunction(Value);
        return *this;
    }
 
    virtual FArchive& operator<<(FObjectPtr& Value) override
    {
        //do nothing to avoid resolving
        return *this;
    }
 
    void Fixup(UObject* Root)
    {
        Root->Serialize(*this);
        TArray<UObject*> SubObjects;
        GetObjectsWithOuter(Root, SubObjects);
        for (UObject* Obj : SubObjects)
        {
            Obj->Serialize(*this);
        }
    }
 
    TFunction<void(FSoftObjectPath&)> FixupFunction;
};
 
namespace UE::SoftObjectPath::Private
{
    UE_DEPRECATED(5.1, "This function is only for use in fixing up deprecated APIs.")
    [[nodiscard]] inline TArray<FName> ConvertSoftObjectPaths(TConstArrayView<FSoftObjectPath> InPaths)
    {
        TArray<FName> Out;
        Out.Reserve(InPaths.Num());
PRAGMA_DISABLE_DEPRECATION_WARNINGS
        Algo::Transform(InPaths, Out, [](const FSoftObjectPath& Path)
        {
            return FName(*Path.ToString());
        });
PRAGMA_ENABLE_DEPRECATION_WARNINGS
        return Out;
    }
 
    UE_DEPRECATED(5.1, "This function is only for use in fixing up deprecated APIs.")
    [[nodiscard]] inline TArray<FSoftObjectPath> ConvertObjectPathNames(TConstArrayView<FName> InPaths)
    {
        TArray<FSoftObjectPath> Out;
        Out.Reserve(InPaths.Num());
PRAGMA_DISABLE_DEPRECATION_WARNINGS
        Algo::Transform(InPaths, Out, [](FName Name)
        {
                FSoftObjectPath Result;
                Result.SetPath(Name.ToString());
                return Result;
        });
PRAGMA_ENABLE_DEPRECATION_WARNINGS
        return Out;
    }
}
 
#if WITH_LOW_LEVEL_TESTS
#include <ostream>
COREUOBJECT_API std::ostream& operator<<(std::ostream& Stream, const FSoftObjectPath& Value);
#endif