AssetData.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "AssetRegistry/AssetBundleData.h"
#include "AssetRegistry/AssetDataTagMap.h"
#include "AssetRegistry/AssetIdentifier.h"
#include "Containers/Array.h"
#include "Containers/ArrayView.h"
#include "Containers/ContainerAllocationPolicies.h"
#include "Containers/ContainersFwd.h"
#include "Containers/Map.h"
#include "Containers/Set.h"
#include "Containers/SparseArray.h"
#include "Containers/StringFwd.h"
#include "Containers/StringView.h"
#include "Containers/UnrealString.h"
#include "Containers/Utf8String.h"
#include "Containers/VersePathFwd.h"
#include "HAL/PlatformMath.h"
#include "HAL/UnrealMemory.h"
#include "IO/IoChunkId.h"
#include "IO/IoHash.h"
#include "Internationalization/Text.h"
#include "Logging/LogCategory.h"
#include "Logging/LogMacros.h"
#include "Logging/LogVerbosity.h"
#include "Misc/AssertionMacros.h"
#include "Misc/CString.h"
#include "Misc/EnumClassFlags.h"
#include "Misc/Guid.h"
#include "Misc/Optional.h"
#include "Misc/PackageName.h"
#include "Misc/PackagePath.h"
#include "Misc/SecureHash.h"
#include "Misc/StringBuilder.h"
#include "Serialization/Archive.h"
#include "Templates/SharedPointer.h"
#include "Templates/Tuple.h"
#include "Templates/TypeHash.h"
#include "Templates/UniquePtr.h"
#include "Templates/UnrealTemplate.h"
#include "Trace/Detail/Channel.h"
#include "UObject/Class.h"
#include "UObject/LinkerInstancingContext.h"
#include "UObject/NameTypes.h"
#include "UObject/Object.h"
#include "UObject/ObjectMacros.h"
#include "UObject/ObjectRedirector.h"
#include "UObject/ObjectVersion.h"
#include "UObject/Package.h"
#include "UObject/PrimaryAssetId.h"
#include "UObject/SoftObjectPath.h"
#include "UObject/TopLevelAssetPath.h"
#include "UObject/UObjectGlobals.h"
#include "UObject/UnrealNames.h"
 
#include "AssetData.generated.h"
 
struct FAssetBundleData;
struct FCustomVersion;
class FCbWriter;
class FCbFieldView;
enum class EAssetRegistryTagsCaller : uint8;
 
COREUOBJECT_API DECLARE_LOG_CATEGORY_EXTERN(LogAssetData, Log, All);
COREUOBJECT_API extern const FName GAssetBundleDataName;
 
struct FAssetRegistryVersion
{
    enum Type
    {
        PreVersioning = 0,                  // From before file versioning was implemented
        HardSoftDependencies,               // The first version of the runtime asset registry to include file versioning.
        AddAssetRegistryState,              // Added FAssetRegistryState and support for piecemeal serialization
        ChangedAssetData,                   // AssetData serialization format changed, versions before this are not readable
        RemovedMD5Hash,                     // Removed MD5 hash from package data
        AddedHardManage,                    // Added hard/soft manage references
        AddedCookedMD5Hash,                 // Added MD5 hash of cooked package to package data
        AddedDependencyFlags,               // Added UE::AssetRegistry::EDependencyProperty to each dependency
        FixedTags,                          // Major tag format change that replaces USE_COMPACT_ASSET_REGISTRY:
                                            // * Target tag INI settings cooked into tag data
                                            // * Instead of FString values are stored directly as one of:
                                            //      - Narrow / wide string
                                            //      - [Numberless] FName
                                            //      - [Numberless] export path
                                            //      - Localized string
                                            // * All value types are deduplicated
                                            // * All key-value maps are cooked into a single contiguous range 
                                            // * Switched from FName table to seek-free and more optimized FName batch loading
                                            // * Removed global tag storage, a tag map reference-counts one store per asset registry
                                            // * All configs can mix fixed and loose tag maps 
        WorkspaceDomain,                    // Added Version information to AssetPackageData
        PackageImportedClasses,             // Added ImportedClasses to AssetPackageData
        PackageFileSummaryVersionChange,    // A new version number of UE5 was added to FPackageFileSummary
        ObjectResourceOptionalVersionChange,// Change to linker export/import resource serialization
        AddedChunkHashes,                   // Added FIoHash for each FIoChunkId in the package to the AssetPackageData.
        ClassPaths,                         // Classes are serialized as path names rather than short object names, e.g. /Script/Engine.StaticMesh
        RemoveAssetPathFNames,              // Asset bundles are serialized as FTopLevelAssetPath instead of FSoftObjectPath, deprecated FAssetData::ObjectPath 
        AddedHeader,                        // Added header with bFilterEditorOnlyData flag 
        AssetPackageDataHasExtension,       // Added Extension to AssetPackageData.
        AssetPackageDataHasPackageLocation, // Added PackageLocation to AssetPackageData.
        MarshalledTextAsUTF8String,         // Replaced 2 byte wide string with UTF8 String
        PackageSavedHash,                   // Replaced FAssetPackageData::PackageGuid with PackageSavedHash
        ExternalActorToWorldIsEditorOnly,   // FPackageDependencyData::LoadDependenciesFromPackageHeader changed how it calculates PackageDependencies
        ManageDependenciesCookRule,         // CookRule property added to EDependencyProperties for EDependencyCategory::Manage
 
        // -----<new versions can be added above this line>-------------------------------------------------
        VersionPlusOne,
        LatestVersion = VersionPlusOne - 1
    };
 
    COREUOBJECT_API const static FGuid GUID;
 
    static COREUOBJECT_API bool SerializeVersion(FArchive& Ar, FAssetRegistryVersion::Type& Version);
 
private:
    FAssetRegistryVersion() {}
};
 
namespace UE::AssetRegistry
{
    using FChunkArrayRegistryHandle = FSetElementId;
}
 
namespace UE::AssetRegistry::Private
{
    struct FAssetPathParts
    {
        FStringView OuterPath;
        FStringView InnermostName;
    };
 
    COREUOBJECT_API FAssetPathParts SplitIntoOuterPathAndAssetName(FStringView InObjectPath);
    COREUOBJECT_API void ConcatenateOuterPathAndObjectName(FStringBuilderBase& Builder, FName OuterPath, FName ObjectName);
}
 
enum class EResolveClass : uint8
{
    No,
    Yes,
};
 
USTRUCT(BlueprintType)
struct FAssetData
{
    GENERATED_BODY()
public:
    static const TCHAR* GetCollectionTagPrefix()
    {
        return TEXT("CL_");
    }
 
    enum class ECreationFlags
    {
        None = 0,
        SkipAssetRegistryTagsGathering = 1 << 0, // Do not perform expensive step of gathering asset registry tags at construction.
        AllowBlueprintClass            = 1 << 1, // Unless specified, the default when trying to create one for a blueprint class 
                                                 // will create one for the UBlueprint instead, but this can be overridden
    };
 
public:
#if WITH_EDITORONLY_DATA
    UE_DEPRECATED(5.1, "FName asset paths have been deprecated. Use GetSoftObjectPath to get the path this asset will use in memory when loaded or GetObjectPathString() if you were just doing ObjectPath.ToString()")
    UPROPERTY()
    FName ObjectPath;
#endif
    UPROPERTY(BlueprintReadOnly, Category = AssetData, transient)
    FName PackageName;
    UPROPERTY(BlueprintReadOnly, Category = AssetData, transient)
    FName PackagePath;
    UPROPERTY(BlueprintReadOnly, Category = AssetData, transient)
    FName AssetName;
    UE_DEPRECATED(5.1, "Class names are now represented by path names. Please use AssetClassPath.")
    UPROPERTY(BlueprintReadOnly, Category = AssetData, transient, meta=(DeprecatedProperty, DeprecationMessage="Short asset class name must be converted to full asset pathname. Use AssetClassPath instead."))
    FName AssetClass;
    UPROPERTY(BlueprintReadOnly, Category = AssetData, transient)
    FTopLevelAssetPath AssetClassPath;
 
private:
    UE::AssetRegistry::FChunkArrayRegistryHandle ChunkArrayRegistryHandle;
 
public:
    uint32 PackageFlags = 0;
 
#if WITH_EDITORONLY_DATA
private:
    FName OptionalOuterPath;
public:
#endif
 
    FAssetDataTagMapSharedView TagsAndValues;
    TSharedPtr<FAssetBundleData, ESPMode::ThreadSafe> TaggedAssetBundles;
 
#if !UE_STRIP_DEPRECATED_PROPERTIES
    UE_DEPRECATED(5.1, "Use SetChunkIDs/GetChunkIDs/AddChunkID instead.")
    TArray<int32, TInlineAllocator<2>> ChunkIDs;
#endif
 
    COREUOBJECT_API void SetTagsAndAssetBundles(FAssetDataTagMap&& Tags);
 
    // These are usually very small arrays and we can preallocate two elements for the same cost as one on 64-bit systems
    using FChunkArray = TArray<int32, TInlineAllocator<2>>;
    using FChunkArrayView = TConstArrayView<int32>;
 
    COREUOBJECT_API FChunkArrayView GetChunkIDs() const;
    COREUOBJECT_API void SetChunkIDs(FChunkArray&& InChunkIDs);
    COREUOBJECT_API void SetChunkIDs(const FChunkArrayView& InChunkIDs);
    COREUOBJECT_API void AddChunkID(int32 ChunkID);
    COREUOBJECT_API void ClearChunkIDs();
    COREUOBJECT_API bool HasSameChunkIDs(const FAssetData& OtherAssetData) const;
 
    static COREUOBJECT_API SIZE_T GetChunkArrayRegistryAllocatedSize();
 
public: 
PRAGMA_DISABLE_DEPRECATION_WARNINGS // Compilers can complain about deprecated members in compiler generated code
    FAssetData()
    {
    }
    FAssetData(FAssetData&&) = default;
    FAssetData(const FAssetData&) = default;
    FAssetData& operator=(FAssetData&&) = default;
    FAssetData& operator=(const FAssetData&) = default;
PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
    UE_DEPRECATED(5.1, "Class names are now represented by path names. Please use a version of FAssetData constructor that uses FTopLevelAssetPath.")
    COREUOBJECT_API FAssetData(FName InPackageName, FName InPackagePath, FName InAssetName, FName InAssetClassName, FAssetDataTagMap InTags = FAssetDataTagMap(), TArrayView<const int32> InChunkIDs = TArrayView<const int32>(), uint32 InPackageFlags = 0);
    UE_DEPRECATED(5.1, "Class names are now represented by path names. Please use a version of FAssetData constructor that uses FTopLevelAssetPath.")
    COREUOBJECT_API FAssetData(const FString& InLongPackageName, const FString& InObjectPath, FName InAssetClassName, FAssetDataTagMap InTags = FAssetDataTagMap(), TArrayView<const int32> InChunkIDs = TArrayView<const int32>(), uint32 InPackageFlags = 0);
 
    COREUOBJECT_API FAssetData(FName InPackageName, FName InPackagePath, FName InAssetName, FTopLevelAssetPath InAssetClassPathName, FAssetDataTagMap InTags = FAssetDataTagMap(), TArrayView<const int32> InChunkIDs = TArrayView<const int32>(), uint32 InPackageFlags = 0);
    COREUOBJECT_API FAssetData(const FString& InLongPackageName, const FString& InObjectPath, FTopLevelAssetPath InAssetClassPathName, FAssetDataTagMap InTags = FAssetDataTagMap(), TArrayView<const int32> InChunkIDs = TArrayView<const int32>(), uint32 InPackageFlags = 0);
 
    COREUOBJECT_API FAssetData(const UObject* InAsset, FAssetData::ECreationFlags InCreationFlags = ECreationFlags::None);
    COREUOBJECT_API FAssetData(const UObject* InAsset, FAssetData::ECreationFlags InCreationFlags, EAssetRegistryTagsCaller Caller);
 
    inline FAssetData(const UObject* InAsset, bool bAllowBlueprintClass)
        : FAssetData(InAsset, bAllowBlueprintClass ? ECreationFlags::AllowBlueprintClass : ECreationFlags::None)
    {
    }
 
    bool operator==(const FAssetData& Other) const
    {
        return PackageName == Other.PackageName && AssetName == Other.AssetName;
    }
 
    bool operator!=(const FAssetData& Other) const
    {
        return PackageName != Other.PackageName || AssetName != Other.AssetName;
    }
 
    bool operator>(const FAssetData& Other) const
    {
        if (PackageName == Other.PackageName)
        {
            return Other.AssetName.LexicalLess(AssetName);
        }
        return Other.PackageName.LexicalLess(PackageName);
    }
 
    bool operator<(const FAssetData& Other) const
    {
        if (PackageName == Other.PackageName)
        {
            return AssetName.LexicalLess(Other.AssetName);
        }
        return PackageName.LexicalLess(Other.PackageName);
    }
 
    bool IsValid() const
    {
        return !PackageName.IsNone() && !AssetName.IsNone();
    }
 
    bool IsUAsset() const
    {
        if (!IsValid())
        {
            return false;
        }
 
        TStringBuilder<FName::StringBufferSize> AssetNameStrBuilder;
        AssetName.ToString(AssetNameStrBuilder);
 
        TStringBuilder<FName::StringBufferSize> PackageNameStrBuilder;
        PackageName.ToString(PackageNameStrBuilder);
        return DetectIsUAssetByNames(PackageNameStrBuilder, AssetNameStrBuilder);
    }
 
    COREUOBJECT_API FSoftObjectPath GetSoftObjectPath() const;
    
    // TODO: Deprecate in favor of GetSoftObjectPath
    FSoftObjectPath ToSoftObjectPath() const
    {
        return GetSoftObjectPath();
    }
    
    FString GetObjectPathString() const
    {
        TStringBuilder<FName::StringBufferSize> Builder;
        AppendObjectPath(Builder);
        return FString(Builder);
    }
 
    COREUOBJECT_API static bool IsUAsset(UObject* Object);
 
    COREUOBJECT_API bool IsTopLevelAsset() const;
    
    COREUOBJECT_API static bool IsTopLevelAsset(UObject* Object);
 
    void Shrink()
    {
        TagsAndValues.Shrink();
    }
 
#if WITH_EDITORONLY_DATA    
    FName GetOptionalOuterPathName() const { return OptionalOuterPath; }
    void SetOptionalOuterPathName(FName InName) { OptionalOuterPath = InName; }
#endif
 
    FString GetFullName() const
    {
        FString FullName;
        GetFullName(FullName);
        return FullName;
    }
 
    void GetFullName(FString& OutFullName) const
    {
        OutFullName.Reset();
        OutFullName += AssetClassPath.ToString();
        OutFullName.AppendChar(TEXT(' '));
        AppendObjectPath(OutFullName);
    }
 
    void GetFullName(FStringBuilderBase& OutFullNameBuilder) const
    {
        OutFullNameBuilder.Reset();
        AssetClassPath.AppendString(OutFullNameBuilder);
        OutFullNameBuilder.AppendChar(TEXT(' '));
        AppendObjectPath(OutFullNameBuilder);
    }
 
    FString GetExportTextName() const
    {
        FString ExportTextName;
        GetExportTextName(ExportTextName);
        return ExportTextName;
    }
 
    void GetExportTextName(FString& OutExportTextName) const
    {
        OutExportTextName.Reset();
        OutExportTextName.Append(AssetClassPath.ToString());
        OutExportTextName.AppendChar(TEXT('\''));
        AppendObjectPath(OutExportTextName);
        OutExportTextName.AppendChar(TEXT('\''));
    }
 
    void GetExportTextName(FStringBuilderBase& OutExportTextNameBuilder) const
    {
        OutExportTextNameBuilder.Reset();
        AssetClassPath.AppendString(OutExportTextNameBuilder);
        OutExportTextNameBuilder.AppendChar(TEXT('\''));
        AppendObjectPath(OutExportTextNameBuilder);
        OutExportTextNameBuilder.AppendChar(TEXT('\''));
    }
 
    COREUOBJECT_API UE::Core::FVersePath GetVersePath() const;
 
    bool IsRedirector() const
    {
        return IsRedirectorClassName(AssetClassPath);
    }
 
    static bool IsRedirector(UObject* Object)
    {
        return Object && IsRedirectorClassName(Object->GetClass()->GetClassPathName());
    }
 
    COREUOBJECT_API UClass* GetClass(EResolveClass ResolveClass = EResolveClass::No) const;
    
    bool IsInstanceOf(const UClass* BaseClass, EResolveClass ResolveClass = EResolveClass::No) const
    {
        UClass* ClassPointer = GetClass(ResolveClass);
        return ClassPointer && ClassPointer->IsChildOf(BaseClass);
    }
 
    template<typename BaseClass>
    bool IsInstanceOf(EResolveClass ResolveClass = EResolveClass::No) const
    {
        return IsInstanceOf(BaseClass::StaticClass(), ResolveClass);
    }
 
    void AppendObjectPath(FStringBuilderBase& Builder) const
    {
        if (!IsValid())
        {
            return;
        }
 
#if WITH_EDITORONLY_DATA
        if (!OptionalOuterPath.IsNone())
        {
            UE::AssetRegistry::Private::ConcatenateOuterPathAndObjectName(Builder, OptionalOuterPath, AssetName);
        }
        else
#endif
        {
            Builder << PackageName << '.' << AssetName;
        }
    }
    
    void AppendObjectPath(FString& String) const
    {
        TStringBuilder<FName::StringBufferSize> Builder;
        AppendObjectPath(Builder);
        String.Append(FString(Builder));
    }
    
    COREUOBJECT_API FPrimaryAssetId GetPrimaryAssetId() const;
 
    UObject* FastGetAsset(bool bLoad = false, TSet<FName> LoadTags = {}) const
    {
        if (!IsValid())
        {
            // Do not try to find the object if the fields are not set
            return nullptr;
        }
 
        // We load PackageName rather than using GetObjectPath because external assets may be saved in a different package to their loaded path. 
        UPackage* FoundPackage = FindObjectFast<UPackage>(nullptr, PackageName);
 
        // We could find an existing package in memory that is still pending load in the loader.
        if (FoundPackage && !FoundPackage->IsFullyLoaded())
        {
            FoundPackage = nullptr;
        }
 
        if (FoundPackage == nullptr && bLoad)
        {
            FLinkerInstancingContext InstancingContext(MoveTemp(LoadTags));
            FoundPackage = LoadPackage(nullptr, *PackageName.ToString(), LOAD_None, nullptr, &InstancingContext);
        }
 
        if (!FoundPackage)
        {
            return nullptr;
        }
 
#if WITH_EDITORONLY_DATA
        if (!OptionalOuterPath.IsNone())
        {
            TStringBuilder<FName::StringBufferSize> Builder;
            AppendObjectPath(Builder);
            return FindObject<UObject>(nullptr, *Builder);
        }
        else
#endif
        {
            // If the package is loaded all objects in it must be loaded, just search for the asset in memory with its outer.
            return FindObjectFast<UObject>(FoundPackage, AssetName);
        }
    }
 
    UObject* GetAsset(TSet<FName> LoadTags = {}) const
    {
 
        return FastGetAsset(true /* bLoad */, MoveTemp(LoadTags));
    }
 
    bool HasAnyPackageFlags(uint32 FlagsToCheck) const
    {
        return (PackageFlags & FlagsToCheck) != 0;
    }
 
    bool HasAllPackageFlags(uint32 FlagsToCheck) const
    {
        return ((PackageFlags & FlagsToCheck) == FlagsToCheck);
    }
 
    EAssetAccessSpecifier GetAssetAccessSpecifier() const
    {
        if (PackageFlags & PKG_NotExternallyReferenceable)
        {
            return EAssetAccessSpecifier::Private;
        }
        else if (PackageFlags & PKG_AccessSpecifierEpicInternal)
        {
            return EAssetAccessSpecifier::EpicInternal;
        }
 
        return EAssetAccessSpecifier::Public;
    }
 
    UPackage* GetPackage() const
    {
        if (PackageName.IsNone())
        {
            return nullptr;
        }
 
        UPackage* Package = FindPackage(NULL, *PackageName.ToString());
        if (Package)
        {
            Package->FullyLoad();
        }
        else
        {
            Package = LoadPackage(NULL, *PackageName.ToString(), LOAD_None);
        }
 
        return Package;
    }
 
    bool FindTag(const FName InTagName) const
    {
        return TagsAndValues.FindTag(InTagName).IsSet();
    }
 
    template <typename ValueType>
    bool GetTagValue(FName Tag, ValueType& OutValue) const;
 
    template<typename Func>
    void EnumerateTags(Func Fn) const
    {
        TagsAndValues.ForEach(Fn);
    }
 
    template <typename ValueType>
    ValueType GetTagValueRef(const FName Tag) const;
 
    bool IsAssetLoaded() const
    {
        return FastGetAsset(false) != nullptr;
    }
 
    void PrintAssetData() const
    {
        UE_LOG(LogAssetData, Log, TEXT("    FAssetData for %s"), *GetObjectPathString());
        UE_LOG(LogAssetData, Log, TEXT("    ============================="));
        UE_LOG(LogAssetData, Log, TEXT("        PackageName: %s"), *PackageName.ToString());
        UE_LOG(LogAssetData, Log, TEXT("        PackagePath: %s"), *PackagePath.ToString());
        UE_LOG(LogAssetData, Log, TEXT("        AssetName: %s"), *AssetName.ToString());
        UE_LOG(LogAssetData, Log, TEXT("        AssetClassPath: %s"), *AssetClassPath.ToString());
        UE_LOG(LogAssetData, Log, TEXT("        TagsAndValues: %d"), TagsAndValues.Num());
 
        for (const auto TagValue: TagsAndValues)
        {
            UE_LOG(LogAssetData, Log, TEXT("            %s : %s"), *TagValue.Key.ToString(), *TagValue.Value.AsString());
        }
 
        const TConstArrayView<int32> CurrentChunkIDs = GetChunkIDs();
        UE_LOG(LogAssetData, Log, TEXT("        ChunkIDs: %d"), CurrentChunkIDs.Num());
 
        for (int32 Chunk : CurrentChunkIDs)
        {
            UE_LOG(LogAssetData, Log, TEXT("                 %d"), Chunk);
        }
 
        UE_LOG(LogAssetData, Log, TEXT("        PackageFlags: %d"), PackageFlags);
    }
 
    static FAssetData GetFirstAssetDataOfClass(const TArray<FAssetData>& Assets, const UClass* DesiredClass)
    {
        for(int32 AssetIdx=0; AssetIdx<Assets.Num(); AssetIdx++)
        {
            const FAssetData& Data = Assets[AssetIdx];
            if (Data.IsInstanceOf(DesiredClass))
            {
                return Data;
            }
        }
        return FAssetData();
    }
 
    template <class T>
    static T* GetFirstAsset(const TArray<FAssetData>& Assets)
    {
        UClass* DesiredClass = T::StaticClass();
        UObject* Asset = FAssetData::GetFirstAssetDataOfClass(Assets, DesiredClass).GetAsset(); //-V758
        check(Asset == NULL || Asset->IsA(DesiredClass));
        return (T*)Asset;
    }
 
    template<class Archive>
    inline void SerializeForCache(Archive&& Ar)
    {
        SerializeForCacheWithTagsAndBundles(Ar, [](FArchive& Ar, FAssetData& Ad, FAssetRegistryVersion::Type) {
            static_cast<Archive&>(Ar).SerializeTagsAndBundles(Ad);
            });
    }
    template<class Archive>
    inline void SerializeForCacheOldVersion(Archive&& Ar, FAssetRegistryVersion::Type Version = FAssetRegistryVersion::LatestVersion)
    {
        SerializeForCacheOldVersionWithTagsAndBundles(Ar, Version, [](FArchive& Ar, FAssetData& Ad, FAssetRegistryVersion::Type Version) {
            static_cast<Archive&>(Ar).SerializeTagsAndBundlesOldVersion(Ad, Version);
            });
    }
 
    // Note: these functions should only be used for live communication between processes running the same version of the engine.
    // There is no versioning support
    COREUOBJECT_API void NetworkWrite(FCbWriter& Writer, bool bWritePackageName) const;
    COREUOBJECT_API bool TryNetworkRead(FCbFieldView Field, bool bReadPackageName, FName InPackageName);
private:
    UE_FORCEINLINE_HINT void SerializeForCacheInternal(FArchive& Ar, FAssetRegistryVersion::Type Version, void (*SerializeTagsAndBundles)(FArchive& , FAssetData&, FAssetRegistryVersion::Type));
    COREUOBJECT_API void SerializeForCacheWithTagsAndBundles(FArchive& Ar, void (*SerializeTagsAndBundles)(FArchive&, FAssetData&, FAssetRegistryVersion::Type));
    COREUOBJECT_API void SerializeForCacheOldVersionWithTagsAndBundles(FArchive& Ar, FAssetRegistryVersion::Type Version, void (*SerializeTagsAndBundles)(FArchive&, FAssetData&, FAssetRegistryVersion::Type));
 
    static bool DetectIsUAssetByNames(FStringView PackageName, FStringView ObjectPathName)
    {
        FStringView PackageBaseName;
        {
            // Get everything after the last slash
            int32 IndexOfLastSlash = INDEX_NONE;
            PackageName.FindLastChar(TEXT('/'), IndexOfLastSlash);
            PackageBaseName = PackageName.Mid(IndexOfLastSlash + 1);
        }
 
        return PackageBaseName.Equals(ObjectPathName, ESearchCase::IgnoreCase);
    }
 
public:
    COREUOBJECT_API static bool IsRedirectorClassName(FTopLevelAssetPath ClassPathName);
 
    COREUOBJECT_API static FTopLevelAssetPath TryConvertShortClassNameToPathName(FName InClassName, ELogVerbosity::Type FailureMessageVerbosity = ELogVerbosity::Warning);
 
    friend UE_FORCEINLINE_HINT uint32 GetTypeHash(const FAssetData& AssetData)
    {
        return HashCombine(GetTypeHash(AssetData.PackageName), GetTypeHash(AssetData.AssetName));
    }
};
 
ENUM_CLASS_FLAGS(FAssetData::ECreationFlags);
 
 
template<>
struct TStructOpsTypeTraits<FAssetData> : public TStructOpsTypeTraitsBase2<FAssetData>
{
    enum
    {
        WithIdenticalViaEquality = true
    };
};
 
template <typename ValueType>
inline bool FAssetData::GetTagValue(FName Tag, ValueType& OutValue) const
{
    const FAssetDataTagMapSharedView::FFindTagResult FoundValue = TagsAndValues.FindTag(Tag);
    if (FoundValue.IsSet())
    {
        FMemory::Memzero(&OutValue, sizeof(ValueType));
        LexFromString(OutValue, *FoundValue.GetValue());
        return true;
    }
    return false;
}
 
template <>
inline bool FAssetData::GetTagValue<FString>(FName Tag, FString& OutValue) const
{
    const FAssetDataTagMapSharedView::FFindTagResult FoundValue = TagsAndValues.FindTag(Tag);
    if (FoundValue.IsSet())
    {
        OutValue = FoundValue.AsString();
        return true;
    }
 
    return false;
}
 
template <>
inline bool FAssetData::GetTagValue<FText>(FName Tag, FText& OutValue) const
{
    const FAssetDataTagMapSharedView::FFindTagResult FoundValue = TagsAndValues.FindTag(Tag);
    if (FoundValue.IsSet())
    {
        OutValue = FoundValue.AsText();
        return true;
    }
 
    return false;
}
 
template <>
inline bool FAssetData::GetTagValue<FName>(FName Tag, FName& OutValue) const
{
    const FAssetDataTagMapSharedView::FFindTagResult FoundValue = TagsAndValues.FindTag(Tag);
    if (FoundValue.IsSet())
    {
        OutValue = FoundValue.AsName();
        return true;
    }
    return false;
}
 
template <typename ValueType>
inline ValueType FAssetData::GetTagValueRef(FName Tag) const
{
    ValueType TmpValue;
    FMemory::Memzero(&TmpValue, sizeof(ValueType));
    const FAssetDataTagMapSharedView::FFindTagResult FoundValue = TagsAndValues.FindTag(Tag);
    if (FoundValue.IsSet())
    {
        LexFromString(TmpValue, *FoundValue.GetValue());
    }
    return TmpValue;
}
 
template <>
inline FString FAssetData::GetTagValueRef<FString>(FName Tag) const
{
    const FAssetDataTagMapSharedView::FFindTagResult FoundValue = TagsAndValues.FindTag(Tag);
    return FoundValue.IsSet() ? FoundValue.AsString() : FString();
}
 
template <>
inline FText FAssetData::GetTagValueRef<FText>(FName Tag) const
{
    FText TmpValue;
    GetTagValue(Tag, TmpValue);
    return TmpValue;
}
 
template <>
inline FName FAssetData::GetTagValueRef<FName>(FName Tag) const
{
    const FAssetDataTagMapSharedView::FFindTagResult FoundValue = TagsAndValues.FindTag(Tag);
    return FoundValue.IsSet() ? FoundValue.AsName() : FName();
}
 
template <>
inline FAssetRegistryExportPath FAssetData::GetTagValueRef<FAssetRegistryExportPath>(FName Tag) const
{
    const FAssetDataTagMapSharedView::FFindTagResult FoundValue = TagsAndValues.FindTag(Tag);
    return FoundValue.IsSet() ? FoundValue.AsExportPath() : FAssetRegistryExportPath();
}
 
namespace UE::AssetRegistry
{
 
struct FPackageCustomVersion
{
    FGuid Key;
    int32 Version = 0;
 
    FPackageCustomVersion() = default;
    FPackageCustomVersion(const FGuid& InKey, const int32 InVersion)
        : Key(InKey)
        , Version(InVersion)
    {
    }
    bool operator<(const FPackageCustomVersion& RHS) const
    {
        if (Key < RHS.Key) return true;
        if (RHS.Key < Key) return false;
        return Version < RHS.Version;
    }
    bool operator==(const FPackageCustomVersion& RHS) const
    {
        return Key == RHS.Key && Version == RHS.Version;
    }
    friend FArchive& operator<<(FArchive& Ar, FPackageCustomVersion& CustomVersion)
    {
        return Ar << CustomVersion.Key << CustomVersion.Version;
    }
 
private:
    friend FCbWriter& operator<<(FCbWriter& Writer, const FPackageCustomVersion& Value)
    {
        return Value.Write(Writer);
    }
    COREUOBJECT_API FCbWriter& Write(FCbWriter& Writer) const;
    friend bool LoadFromCompactBinary(const FCbFieldView& Field, FPackageCustomVersion& Value)
    {
        return Value.TryRead(Field);
    }
    COREUOBJECT_API bool TryRead(const FCbFieldView& Field);
};
 
class FPackageCustomVersionsHandle
{
public:
    TConstArrayView<FPackageCustomVersion> Get() const { return Ptr; }
 
    COREUOBJECT_API static FPackageCustomVersionsHandle FindOrAdd(TConstArrayView<FCustomVersion> InCustomVersions);
    COREUOBJECT_API static FPackageCustomVersionsHandle FindOrAdd(TConstArrayView<FPackageCustomVersion> InCustomVersions);
    COREUOBJECT_API static FPackageCustomVersionsHandle FindOrAdd(TArray<FPackageCustomVersion>&& InCustomVersions);
    COREUOBJECT_API friend FArchive& operator<<(FArchive& Ar, FPackageCustomVersionsHandle& Handle);
 
private:
    TConstArrayView<FPackageCustomVersion> Ptr;
    friend class FPackageCustomVersionRegistry;
};
 
}
 
class FAssetPackageData
{
public:
    FMD5Hash CookedHash;
 
    EPackageExtension Extension;
 
private:
    uint32 Flags;
 
public:
 
    TMap<FIoChunkId, FIoHash> ChunkHashes;
 
    TArray<FName> ImportedClasses;
 
    int64 DiskSize;
 
    FPackageFileVersion FileVersionUE;
 
private:
#if WITH_EDITORONLY_DATA
    FIoHash PackageSavedHash;
#endif
 
public:
    int32 FileVersionLicenseeUE;
 
private:
    UE::AssetRegistry::FPackageCustomVersionsHandle CustomVersions;
 
public:
 
 
    FAssetPackageData()
        : Extension(EPackageExtension::Unspecified)
        , Flags(0)
        , DiskSize(0)
        , FileVersionLicenseeUE(-1)
    {
    }
 
    TConstArrayView<UE::AssetRegistry::FPackageCustomVersion> GetCustomVersions() const
    {
        return CustomVersions.Get();
    }
    void SetCustomVersions(TConstArrayView<FCustomVersion> InCustomVersions)
    {
        CustomVersions = UE::AssetRegistry::FPackageCustomVersionsHandle::FindOrAdd(InCustomVersions);
    }
    void SetCustomVersions(TConstArrayView<UE::AssetRegistry::FPackageCustomVersion> InCustomVersions)
    {
        CustomVersions = UE::AssetRegistry::FPackageCustomVersionsHandle::FindOrAdd(InCustomVersions);
    }
    void SetCustomVersions(TArray<UE::AssetRegistry::FPackageCustomVersion>&& InCustomVersions)
    {
        CustomVersions = UE::AssetRegistry::FPackageCustomVersionsHandle::FindOrAdd(MoveTemp(InCustomVersions));
    }
 
    bool IsLicenseeVersion() const { return (Flags & FLAG_LICENSEE_VERSION) != 0; }
    void SetIsLicenseeVersion(bool bValue) { Flags = (Flags & ~FLAG_LICENSEE_VERSION) | (bValue ? FLAG_LICENSEE_VERSION : 0); }
 
    bool HasVirtualizedPayloads() const { return (Flags & FLAG_HAS_VIRTUALIZED_PAYLOADS) != 0; }
    void SetHasVirtualizedPayloads(bool bValue) { Flags = (Flags & ~FLAG_HAS_VIRTUALIZED_PAYLOADS) | (bValue ? FLAG_HAS_VIRTUALIZED_PAYLOADS : 0); }
 
    bool IsReadOnly() const { return (Flags & FLAG_PACKAGE_READ_ONLY) != 0; }
    void SetIsReadOnly(bool bValue) { Flags = (Flags & ~FLAG_PACKAGE_READ_ONLY) | (bValue ? FLAG_PACKAGE_READ_ONLY : 0); }
 
    COREUOBJECT_API void SerializeForCache(FArchive& Ar);
    COREUOBJECT_API void SerializeForCacheOldVersion(FArchive& Ar, FAssetRegistryVersion::Type Version);
 
    SIZE_T GetAllocatedSize() const
    {
        return ImportedClasses.GetAllocatedSize();
    }
 
#if WITH_EDITORONLY_DATA
    COREUOBJECT_API FIoHash GetPackageSavedHash() const;
    COREUOBJECT_API void SetPackageSavedHash(const FIoHash& InHash);
#else
    UE_DEPRECATED(5.6, "No longer supported in non-editor configurations, to save memory.")
    COREUOBJECT_API FIoHash GetPackageSavedHash() const;
    UE_DEPRECATED(5.6, "No longer supported in non-editor configurations, to save memory.")
    COREUOBJECT_API void SetPackageSavedHash(const FIoHash& InHash);
#endif
 
    // Note: these functions should only be used for live communication between processes running the same version of the engine.
    // There is no versioning support
    COREUOBJECT_API void NetworkWrite(FCbWriter& Writer) const;
    COREUOBJECT_API bool TryNetworkRead(FCbFieldView Field);
 
    void SetPackageLocation(FPackageName::EPackageLocationFilter PackageLocation)
    {   
        // Clear existing location flags
        Flags = Flags & ~FLAG_PACKAGE_LOCATION_MASK;
 
        static_assert((uint8)FPackageName::EPackageLocationFilter::MaxBit <= 2, "We are storing PackageLocation in two bits");
        check(PackageLocation <= FPackageName::EPackageLocationFilter::ValidMask);
        Flags |= uint32(PackageLocation) << FLAG_PACKAGE_LOCATION_TO_ENUM_SHIFT_SIZE;
    }
 
    FPackageName::EPackageLocationFilter GetPackageLocation() const
    {
        return FPackageName::EPackageLocationFilter((Flags & FLAG_PACKAGE_LOCATION_MASK) >> FLAG_PACKAGE_LOCATION_TO_ENUM_SHIFT_SIZE);
    }
 
private:
    UE_FORCEINLINE_HINT void SerializeForCacheInternal(FArchive& Ar, FAssetPackageData& PackageData, FAssetRegistryVersion::Type Version);
 
    enum : uint32
    {
        FLAG_LICENSEE_VERSION                       = 1u << 0,
        FLAG_HAS_VIRTUALIZED_PAYLOADS               = 1u << 1,
        FLAG_PACKAGE_READ_ONLY                      = 1u << 2,
 
        FLAG_PACKAGE_LOCATION_IODISPATCHER          = 1u << 30,
        FLAG_PACKAGE_LOCATION_FILESYSTEM            = 1u << 31,
 
        FLAG_PACKAGE_LOCATION_TO_ENUM_SHIFT_SIZE    = 30u,
        FLAG_PACKAGE_LOCATION_MASK                  = uint32(FPackageName::EPackageLocationFilter::ValidMask) << FLAG_PACKAGE_LOCATION_TO_ENUM_SHIFT_SIZE
    };
};
 
 
#if WITH_EDITORONLY_DATA
PRAGMA_DISABLE_DEPRECATION_WARNINGS
struct FReferenceViewerParams
{
    FReferenceViewerParams()
        // Displayed-on-graph options
        : bShowReferencers(true)
        , bShowDependencies(true)
        // Slider-based options
        , FixAndHideSearchDepthLimit(0)
        , FixAndHideSearchBreadthLimit(0)
        , bShowCollectionFilter(true)
        , bShowPluginFilter(true)
        // Checkbox options
        , bShowShowReferencesOptions(true)
        , bShowShowSearchableNames(true)
        , bShowShowNativePackages(true)
        , bShowShowCodePackages(true)
        , bShowShowFilteredPackagesOnly(true)
        , bShowCompactMode(true)
    {}
 
    /* Whether to display the Referencers */
    bool bShowReferencers;
    /* Whether to display the Dependencies */
    bool bShowDependencies;
    /* Whether to only display the References/Dependencies which match the text filter, if any. 
       If the optional is not set, don't change the current reference viewer's value. */
    TOptional<bool> bShowFilteredPackagesOnly;
    TArray<FName> PluginFilter;
    /* Compact mode allows to hide the thumbnail and minimize the space taken by the nodes. Useful when there are many dependencies to inspect, to keep the UI responsive. 
       If the optional is not set, don't change the current reference viewer's value. */
    TOptional<bool> bCompactMode;
    int32 FixAndHideSearchDepthLimit;
    int32 FixAndHideSearchBreadthLimit;
    bool bShowCollectionFilter;
    bool bShowPluginFilter;
    bool bShowShowReferencesOptions;
    bool bShowShowSearchableNames;
    UE_DEPRECATED(5.1, "bShowShowNativePackages is deprecated, please use bShowShowCodePackages instead.")
    bool bShowShowNativePackages;
    bool bShowShowCodePackages;
    bool bShowShowFilteredPackagesOnly;
    bool bShowCompactMode;
};
PRAGMA_ENABLE_DEPRECATION_WARNINGS
#endif // WITH_EDITORONLY_DATA