AssetRegistryState.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "AssetRegistry/AssetData.h"
#include "AssetRegistry/AssetDataMap.h"
#include "AssetRegistry/IAssetRegistry.h"
#include "Containers/Array.h"
#include "Containers/ArrayView.h"
#include "Containers/ContainerAllocationPolicies.h"
#include "Containers/Map.h"
#include "Containers/Set.h"
#include "Containers/StringFwd.h"
#include "CoreTypes.h"
#include "HAL/PlatformCrt.h"
#include "Misc/AssetRegistryInterface.h"
#include "Templates/UnrealTemplate.h"
#include "UObject/NameTypes.h"
#include "UObject/SoftObjectPath.h"
#include "UObject/TopLevelAssetPath.h"
 
#ifndef UE_ASSETREGISTRY_CACHEDASSETSBYTAG
#define UE_ASSETREGISTRY_CACHEDASSETSBYTAG WITH_EDITORONLY_DATA
#endif 
 
class FArchive;
class FAssetDataTagMap;
class FAssetDataTagMapSharedView;
class FAssetRegistryGenerator;
class FDependsNode;
class FString;
namespace UE::AssetRegistry { class FAssetRegistryImpl; }
struct FARCompiledFilter;
struct FAssetRegistryHeader;
struct FPrimaryAssetId;
template <typename FuncType> class TFunctionRef;
class FAssetDataGatherer;
 
struct FAssetRegistrySerializationOptions
{
    FAssetRegistrySerializationOptions(
        UE::AssetRegistry::ESerializationTarget Target = UE::AssetRegistry::ESerializationTarget::ForGame);
 
    bool bSerializeAssetRegistry = false;
 
    bool bSerializeDependencies = false;
 
    bool bSerializeSearchableNameDependencies = false;
 
    bool bSerializeManageDependencies = false;
 
    bool bSerializePackageData = false;
 
    bool bUseAssetRegistryTagsAllowListInsteadOfDenyList = false;
 
    bool bFilterAssetDataWithNoTags = false;
 
    bool bFilterDependenciesWithNoTags = false;
 
    bool bFilterSearchableNames = false;
 
    bool bKeepDevelopmentAssetRegistryTags = false;
 
    TMap<FTopLevelAssetPath, TSet<FName>> CookFilterlistTagsByClass;
 
    TSet<FName> CookTagsAsName;
 
    TSet<FName> CookTagsAsPath;
 
    TSet<FString> AssetBundlesDenyList;
 
    void DisableFilters();
 
private:
    void InitForDevelopment();
};
 
struct FAssetRegistryLoadOptions
{
    FAssetRegistryLoadOptions() = default;
    explicit FAssetRegistryLoadOptions(const FAssetRegistrySerializationOptions& Options);
 
    bool bLoadDependencies = true;
    bool bLoadPackageData = true;
    int32 ParallelWorkers = 0;
};
 
struct FAssetRegistryPruneOptions
{
    TSet<FName> RequiredPackages;
    TSet<FName> RemovePackages;
    TSet<int32> ChunksToKeep;
    FAssetRegistrySerializationOptions Options;
 
    /* Remove FDependsNodes that do not point to packages */
    bool bRemoveDependenciesWithoutPackages = false;
 
    /* List of types that should not be pruned because they do not have a package */
    TSet<FPrimaryAssetType> RemoveDependenciesWithoutPackagesKeepPrimaryAssetTypes;
};
 
struct FAssetRegistryAppendResult
{
    TArray<const FAssetData*> AddedAssets;
    TArray<const FAssetData*> UpdatedAssets;
};
 
class FAssetRegistryState
{
private:
    using FCachedAssetKey = UE::AssetRegistry::Private::FCachedAssetKey;
#if UE_ASSETREGISTRY_INDIRECT_ASSETDATA_POINTERS
    using FAssetDataMap = UE::AssetRegistry::Private::FAssetDataMap;
    using FAssetDataPtrIndex = UE::AssetRegistry::Private::FAssetDataPtrIndex;
    using FAssetDataArrayIndex = UE::AssetRegistry::Private::FAssetDataArrayIndex;
    using FAssetDataOrArrayIndex = UE::AssetRegistry::Private::FAssetDataOrArrayIndex;
#endif
 
public:
#if !UE_ASSETREGISTRY_INDIRECT_ASSETDATA_POINTERS
    // These types are an implementation detail and they and the functions which take/return them are subject to change
    // without deprecation warnings.
    using FAssetDataMap = UE::AssetRegistry::Private::FAssetDataMap;
    using FConstAssetDataMap = UE::AssetRegistry::Private::FConstAssetDataMap;
#endif
 
    FAssetRegistryState();
    FAssetRegistryState(const FAssetRegistryState&) = delete;
    FAssetRegistryState(FAssetRegistryState&& Rhs);
    ASSETREGISTRY_API ~FAssetRegistryState();
 
    FAssetRegistryState& operator=(const FAssetRegistryState&) = delete;
    ASSETREGISTRY_API FAssetRegistryState& operator=(FAssetRegistryState&& O);
 
    using EInitializationMode = UE::AssetRegistry::EAppendMode;
    using EEnumerateAssetsFlags = UE::AssetRegistry::EEnumerateAssetsFlags;
 
    ASSETREGISTRY_API bool HasAssets(const FName PackagePath, bool bARFiltering=false) const;
 
    ASSETREGISTRY_API bool GetAssets(const FARCompiledFilter& Filter, const TSet<FName>& PackageNamesToSkip,
        TArray<FAssetData>& OutAssetData, bool bSkipARFilteredAssets = false) const;
 
    ASSETREGISTRY_API bool EnumerateAssets(const FARCompiledFilter& Filter, const TSet<FName>& PackageNamesToSkip, 
        TFunctionRef<bool(const FAssetData&)> Callback,
        EEnumerateAssetsFlags InEnumerateFlags = EEnumerateAssetsFlags::AllowUnfilteredArAssets) const;
 
    ASSETREGISTRY_API bool GetAllAssets(const TSet<FName>& PackageNamesToSkip, TArray<FAssetData>& OutAssetData,
        bool bARFiltering = false) const;
 
    ASSETREGISTRY_API void EnumerateAllAssets(TFunctionRef<void(const FAssetData&)> Callback,
        EEnumerateAssetsFlags InEnumerateFlags = EEnumerateAssetsFlags::AllowAll) const;
 
    ASSETREGISTRY_API bool EnumerateAllAssets(const TSet<FName>& PackageNamesToSkip,
        TFunctionRef<bool(const FAssetData&)> Callback,
        EEnumerateAssetsFlags InEnumerateFlags = EEnumerateAssetsFlags::AllowUnfilteredArAssets) const;
 
    ASSETREGISTRY_API void EnumerateAllPaths(TFunctionRef<void(FName PathName)> Callback) const;
 
    ASSETREGISTRY_API void GetPackagesByName(FStringView PackageName, TArray<FName>& OutPackageNames) const;
 
    ASSETREGISTRY_API FName GetFirstPackageByName(FStringView PackageName) const;
 
    ASSETREGISTRY_API bool GetDependencies(const FAssetIdentifier& AssetIdentifier,
        TArray<FAssetIdentifier>& OutDependencies,
        UE::AssetRegistry::EDependencyCategory Category = UE::AssetRegistry::EDependencyCategory::All,
        const UE::AssetRegistry::FDependencyQuery& Flags = UE::AssetRegistry::FDependencyQuery()) const;
    ASSETREGISTRY_API bool GetDependencies(const FAssetIdentifier& AssetIdentifier,
        TArray<FAssetDependency>& OutDependencies,
        UE::AssetRegistry::EDependencyCategory Category = UE::AssetRegistry::EDependencyCategory::All,
        const UE::AssetRegistry::FDependencyQuery& Flags = UE::AssetRegistry::FDependencyQuery()) const;
 
    ASSETREGISTRY_API bool ContainsDependency(const FAssetIdentifier& AssetIdentifier,
        const FAssetIdentifier& QueryAsset,
        UE::AssetRegistry::EDependencyCategory Category = UE::AssetRegistry::EDependencyCategory::All,
        const UE::AssetRegistry::FDependencyQuery& Flags = UE::AssetRegistry::FDependencyQuery()) const;
 
    ASSETREGISTRY_API bool GetReferencers(const FAssetIdentifier& AssetIdentifier,
        TArray<FAssetIdentifier>& OutReferencers,
        UE::AssetRegistry::EDependencyCategory Category = UE::AssetRegistry::EDependencyCategory::All,
        const UE::AssetRegistry::FDependencyQuery& Flags = UE::AssetRegistry::FDependencyQuery()) const;
    ASSETREGISTRY_API bool GetReferencers(const FAssetIdentifier& AssetIdentifier,
        TArray<FAssetDependency>& OutReferencers,
        UE::AssetRegistry::EDependencyCategory Category = UE::AssetRegistry::EDependencyCategory::All,
        const UE::AssetRegistry::FDependencyQuery& Flags = UE::AssetRegistry::FDependencyQuery()) const;
 
    const FAssetData* GetAssetByObjectPath(const FSoftObjectPath& ObjectPath) const;
 
    const FAssetData* GetAssetByObjectPath(const UE::AssetRegistry::Private::FCachedAssetKey& Key) const;
 
    void EnumerateAssetsByPackageName(const FName PackageName,
        TFunctionRef<bool(const FAssetData* AssetData)> Callback) const;
    TArray<const FAssetData*> CopyAssetsByPackageName(const FName PackageName) const;
    int32 NumAssetsByPackageName(const FName PackageName) const;
 
    void EnumerateAssetsByPackagePath(FName LongPackagePathName,
        TFunctionRef<bool(const FAssetData* AssetData)> Callback) const;
 
    void EnumerateAssetsByClassPathName(const FTopLevelAssetPath ClassPathName,
        TFunctionRef<bool(const FAssetData* AssetData)> Callback) const;
 
    void EnumerateTags(TFunctionRef<bool(FName TagName)> Callback) const;
 
    bool ContainsTag(FName TagName) const;
 
    ASSETREGISTRY_API void EnumerateAssetsByTagName(const FName TagName,
        TFunctionRef<bool(const FAssetData* AssetData)> Callback) const;
 
    ASSETREGISTRY_API void EnumerateTagToAssetDatas(
        TFunctionRef<bool(FName TagName, IAssetRegistry::FEnumerateAssetDatasFunc EnumerateAssets)> Callback) const;
 
    const TMap<FName, const FAssetPackageData*>& GetAssetPackageDataMap() const;
 
    ASSETREGISTRY_API void GetPrimaryAssetsIds(TSet<FPrimaryAssetId>& OutPrimaryAssets) const;
 
    ASSETREGISTRY_API const FAssetPackageData* GetAssetPackageData(FName PackageName) const;
    ASSETREGISTRY_API const FAssetPackageData* GetAssetPackageData(FName PackageName,
        FName& OutCorrectCasePackageName) const;
    ASSETREGISTRY_API FAssetPackageData* GetAssetPackageData(FName PackageName);
 
    void GetPackageNames(TArray<FName>& OutPackageNames) const;
 
    ASSETREGISTRY_API FAssetPackageData* CreateOrGetAssetPackageData(FName PackageName);
 
    ASSETREGISTRY_API bool RemovePackageData(FName PackageName);
 
    ASSETREGISTRY_API void AddAssetData(FAssetData* AssetData);
 
    ASSETREGISTRY_API void AddTagsToAssetData(const FSoftObjectPath& InObjectPath, FAssetDataTagMap&& InTagsAndValues);
 
    ASSETREGISTRY_API void UpdateAssetData(const FAssetData& NewAssetData, bool bCreateIfNotExists=false);
    ASSETREGISTRY_API void UpdateAssetData(FAssetData&& NewAssetData, bool bCreateIfNotExists = false);
 
    ASSETREGISTRY_API void UpdateAssetData(FAssetData* AssetData, const FAssetData& NewAssetData,
        bool* bOutModified = nullptr);
    ASSETREGISTRY_API void UpdateAssetData(FAssetData* AssetData, FAssetData&& NewAssetData,
        bool* bOutModified = nullptr);
 
    ASSETREGISTRY_API bool UpdateAssetDataPackageFlags(FName PackageName, uint32 PackageFlags);
 
    ASSETREGISTRY_API void RemoveAssetData(FAssetData* AssetData, bool bRemoveDependencyData,
        bool& bOutRemovedAssetData, bool& bOutRemovedPackageData);
    ASSETREGISTRY_API void RemoveAssetData(const FSoftObjectPath& SoftObjectPath, bool bRemoveDependencyData,
        bool& bOutRemovedAssetData, bool& bOutRemovedPackageData);
    ASSETREGISTRY_API void RemoveAssetDatas(TArrayView<FAssetData*> AssetDatas, bool bRemoveDependencyData,
        TBitArray<>& bOutRemovedAssetData, TBitArray<>& bOutRemovedPackageData);
 
    ASSETREGISTRY_API void ClearDependencies(const FAssetIdentifier& AssetIdentifier,
        UE::AssetRegistry::EDependencyCategory Category);
    ASSETREGISTRY_API void AddDependencies(const FAssetIdentifier& AssetIdentifier,
        TConstArrayView<FAssetDependency> Dependencies);
    ASSETREGISTRY_API void SetDependencies(const FAssetIdentifier& AssetIdentifier,
        TConstArrayView<FAssetDependency> Dependencies,
        UE::AssetRegistry::EDependencyCategory Category = UE::AssetRegistry::EDependencyCategory::All);
    ASSETREGISTRY_API void ClearReferencers(const FAssetIdentifier& AssetIdentifier,
        UE::AssetRegistry::EDependencyCategory Category);
    ASSETREGISTRY_API void AddReferencers(const FAssetIdentifier& AssetIdentifier,
        TConstArrayView<FAssetDependency> Referencers);
    ASSETREGISTRY_API void SetReferencers(const FAssetIdentifier& AssetIdentifier,
        TConstArrayView<FAssetDependency> Referencers,
        UE::AssetRegistry::EDependencyCategory Category = UE::AssetRegistry::EDependencyCategory::All);
 
    ASSETREGISTRY_API void Reset();
 
    void InitializeFromExisting(const FAssetRegistryState& Existing, const FAssetRegistrySerializationOptions& Options,
        EInitializationMode InitializationMode = EInitializationMode::Rebuild, FAssetRegistryAppendResult* OutAppendResult = nullptr);
 
    ASSETREGISTRY_API void PruneAssetData(const TSet<FName>& RequiredPackages, const TSet<FName>& RemovePackages,
        const TSet<int32> ChunksToKeep, const FAssetRegistrySerializationOptions& Options);
    ASSETREGISTRY_API void PruneAssetData(const TSet<FName>& RequiredPackages, const TSet<FName>& RemovePackages,
        const FAssetRegistrySerializationOptions& Options);
    ASSETREGISTRY_API void Prune(const FAssetRegistryPruneOptions& PruneOptions);
 
    
    ASSETREGISTRY_API void InitializeFromExistingAndPrune(const FAssetRegistryState& ExistingState,
        const TSet<FName>& RequiredPackages, const TSet<FName>& RemovePackages, const TSet<int32> ChunksToKeep,
        const FAssetRegistrySerializationOptions& Options);
 
    ASSETREGISTRY_API void FilterTags(const FAssetRegistrySerializationOptions& Options);
 
 
    ASSETREGISTRY_API bool Serialize(FArchive& Ar, const FAssetRegistrySerializationOptions& Options);
 
    ASSETREGISTRY_API bool Save(FArchive& Ar, const FAssetRegistrySerializationOptions& Options);
    ASSETREGISTRY_API bool Load(FArchive& Ar,
        const FAssetRegistryLoadOptions& Options = FAssetRegistryLoadOptions(),
        FAssetRegistryVersion::Type* OutVersion = nullptr);
 
    static ASSETREGISTRY_API bool LoadFromDisk(const TCHAR* InPath, const FAssetRegistryLoadOptions& InOptions,
        FAssetRegistryState& OutState, FAssetRegistryVersion::Type* OutVersion = nullptr);
 
    ASSETREGISTRY_API SIZE_T GetAllocatedSize(bool bLogDetailed = false) const;
 
    static ASSETREGISTRY_API bool IsFilterValid(const FARCompiledFilter& Filter);
 
    int32 GetNumAssets() const;
 
    int32 GetNumPackages() const;
 
#if ASSET_REGISTRY_STATE_DUMPING_ENABLED
    ASSETREGISTRY_API void Dump(const TArray<FString>& Arguments, TArray<FString>& OutPages,
        int32 LinesPerPage=1) const;
#endif
 
private:
    // Accessors of mutable FAssetData*, for friend classes
    ASSETREGISTRY_API void EnumerateAllMutableAssets(TFunctionRef<void(FAssetData&)> Callback,
        EEnumerateAssetsFlags InEnumerateFlags = EEnumerateAssetsFlags::AllowAll) const;
    ASSETREGISTRY_API TArray<FAssetData*> GetMutableAssetsSortedByObjectPath();
 
    FAssetData* GetMutableAssetByObjectPath(const FSoftObjectPath& ObjectPath) const;
    FAssetData* GetMutableAssetByObjectPath(const UE::AssetRegistry::Private::FCachedAssetKey& Key) const;
    void EnumerateMutableAssetsByPackageName(const FName PackageName,
        TFunctionRef<bool(FAssetData* AssetData)> Callback) const;
    void EnumerateMutableAssetsByPackagePath(FName LongPackagePathName,
        TFunctionRef<bool(FAssetData* AssetData)> Callback) const;
 
    ASSETREGISTRY_API void InitializeFromExisting(const FAssetDataMap& AssetDataMap,
        const TMap<FAssetIdentifier, FDependsNode*>& DependsNodeMap,
        const TMap<FName, FAssetPackageData*>& AssetPackageDataMap,
        const FAssetRegistrySerializationOptions& Options,
        EInitializationMode InitializationMode = EInitializationMode::Rebuild,
        FAssetRegistryAppendResult* OutAppendResult = nullptr);
 
    template<class Archive>
    void Load(Archive&& Ar, const FAssetRegistryHeader& Header, const FAssetRegistryLoadOptions& Options);
 
    void SetAssetDatas(TArrayView<FAssetData> AssetDatas, const FAssetRegistryLoadOptions& Options);
 
    FDependsNode* ResolveRedirector(FDependsNode* InDependency, const FAssetDataMap& InAllowedAssets,
        TMap<FDependsNode*, FDependsNode*>& InCache);
 
    FDependsNode* FindDependsNode(const FAssetIdentifier& Identifier) const;
 
    FDependsNode* CreateOrFindDependsNode(const FAssetIdentifier& Identifier, bool* bAlreadyExists = nullptr);
 
    bool RemoveDependsNode(const FAssetIdentifier& Identifier);
 
    bool RemoveDependsNodes(const TSet<FAssetIdentifier>& Identifiers);
 
    template<typename SetKeyFuncs, typename SetAllocator>
    bool RemovePackageData(const TSet<FAssetIdentifier, SetKeyFuncs, SetAllocator>& AssetIdentifiers);
 
    static void FilterTags(const FAssetDataTagMapSharedView& InTagsAndValues, FAssetDataTagMap& OutTagsAndValues,
        const TSet<FName>* ClassSpecificFilterList, const FAssetRegistrySerializationOptions & Options);
 
    static TSharedPtr<FAssetBundleData> FilterBundles(const TSharedPtr<FAssetBundleData>& InAssetBundles,
        const FAssetRegistrySerializationOptions& Options);
 
    void LoadDependencies(FArchive& Ar, const FAssetRegistryLoadOptions& Options, FAssetRegistryVersion::Type Version);
    template <bool bLatestVersion>
    void LoadDependenciesImpl(FArchive& Ar, FAssetRegistryVersion::Type Version);
    void LegacyLoadDependencies_BeforeFlags(FArchive& Ar, bool bSerializeDependencies, FAssetRegistryVersion::Type Version);
 
    void SetTagsOnExistingAsset(FAssetData* AssetData, FAssetDataTagMap&& NewTags);
 
    void SetDependencyNodeSorting(bool bSortDependencies, bool bSortReferencers);
 
    void RemoveAssetData(FAssetData* AssetData, const FCachedAssetKey& Key, bool bRemoveDependencyData,
#if UE_ASSETREGISTRY_INDIRECT_ASSETDATA_POINTERS
        UE::AssetRegistry::Private::FAssetDataPtrIndex AssetIndex,
#endif
        bool& bOutRemovedAssetData, bool& bOutRemovedPackageData
    );
 
    template<typename BitArrayAllocator>
    void RemoveAssetDatasImpl(TArrayView<FAssetData*> AssetDatas, bool bRemoveDependencyData,
        TBitArray<BitArrayAllocator>& bOutRemovedAssetData, TBitArray<BitArrayAllocator>& bOutRemovedPackageData);
 
    template<typename BitArrayAllocator>
    void RemoveAssetDatasImpl(TArrayView<FAssetData*> AssetDatas, TArrayView<const FCachedAssetKey> Keys, bool bRemoveDependencyData,
#if UE_ASSETREGISTRY_INDIRECT_ASSETDATA_POINTERS
        TArrayView<UE::AssetRegistry::Private::FAssetDataPtrIndex> AssetIndices,
#endif
        TBitArray<BitArrayAllocator>& bOutRemovedAssetDatas, TBitArray<BitArrayAllocator>& bOutRemovedPackageDatas
    );
 
    void Shrink();
 
    bool IsPackageUnmountedAndFiltered(const FName PackageName) const;
 
    FAssetDataMap CachedAssets;
#if UE_ASSETREGISTRY_INDIRECT_ASSETDATA_POINTERS
    UE::AssetRegistry::Private::FIndirectAssetDataArrays IndirectAssetDataArrays;
#endif
 
#if !UE_ASSETREGISTRY_INDIRECT_ASSETDATA_POINTERS
    TMap<FName, TArray<FAssetData*, TInlineAllocator<1>> > CachedAssetsByPackageName;
    TMap<FName, TArray<FAssetData*> > CachedAssetsByPath;
    TMap<FTopLevelAssetPath, TArray<FAssetData*> > CachedAssetsByClass;
#else
    UE::AssetRegistry::Private::FAssetPackageNameMap CachedAssetsByPackageName;
    TMap<FName, TArray<FAssetDataPtrIndex> > CachedAssetsByPath;
    TMap<FTopLevelAssetPath, TArray<FAssetDataPtrIndex> > CachedAssetsByClass;
#endif
 
#if UE_ASSETREGISTRY_CACHEDASSETSBYTAG
#if !UE_ASSETREGISTRY_INDIRECT_ASSETDATA_POINTERS
    TMap<FName, TSet<FAssetData*> > CachedAssetsByTag;
#else
    TMap<FName, TSet<FAssetDataPtrIndex> > CachedAssetsByTag;
#endif
#else
    TMap<FName, TSet<FTopLevelAssetPath> > CachedClassesByTag;
#endif
 
    TMap<FAssetIdentifier, FDependsNode*> CachedDependsNodes;
 
    TMap<FName, FAssetPackageData*> CachedPackageData;
 
    TArray<FAssetData*> PreallocatedAssetDataBuffers;
    TArray<FDependsNode*> PreallocatedDependsNodeDataBuffers;
    TArray<FAssetPackageData*> PreallocatedPackageDataBuffers;
 
    int32 NumAssets = 0;
    int32 NumDependsNodes = 0;
    int32 NumPackageData = 0;
 
    bool bCookedGlobalAssetRegistryState = false;
 
    friend class FAssetRegistryGenerator;
    friend class UAssetRegistryImpl;
    friend class UE::AssetRegistry::FAssetRegistryImpl;
    friend class FAssetDataGatherer;
};
 
 
// Inline implementations
 
 
inline FAssetRegistrySerializationOptions::FAssetRegistrySerializationOptions(
    UE::AssetRegistry::ESerializationTarget Target)
{
    if (Target == UE::AssetRegistry::ESerializationTarget::ForDevelopment)
    {
        InitForDevelopment();
    }
}
 
inline void FAssetRegistrySerializationOptions::DisableFilters()
{
    bFilterAssetDataWithNoTags = false;
    bFilterDependenciesWithNoTags = false;
    bFilterSearchableNames = false;
    bUseAssetRegistryTagsAllowListInsteadOfDenyList = false;
    CookFilterlistTagsByClass.Empty();
}
 
inline void FAssetRegistrySerializationOptions::InitForDevelopment()
{
    bSerializeAssetRegistry = true;
    bSerializeDependencies = true;
    bSerializeSearchableNameDependencies = true;
    bSerializeManageDependencies = true;
    bSerializePackageData = true;
    DisableFilters();
}
 
inline FAssetRegistryLoadOptions::FAssetRegistryLoadOptions(const FAssetRegistrySerializationOptions& Options)
    : bLoadDependencies(Options.bSerializeDependencies)
    , bLoadPackageData(Options.bSerializePackageData)
{
}
 
inline FAssetRegistryState::FAssetRegistryState()
#if UE_ASSETREGISTRY_INDIRECT_ASSETDATA_POINTERS
    : CachedAssetsByPackageName(CachedAssets, IndirectAssetDataArrays)
#endif
{
}
 
inline FAssetRegistryState::FAssetRegistryState(FAssetRegistryState&& Rhs)
#if UE_ASSETREGISTRY_INDIRECT_ASSETDATA_POINTERS
    : CachedAssetsByPackageName(CachedAssets, IndirectAssetDataArrays)
#endif
{
    *this = MoveTemp(Rhs);
}
 
inline const FAssetData* FAssetRegistryState::GetAssetByObjectPath(const FSoftObjectPath& ObjectPath) const
{
    return GetAssetByObjectPath(UE::AssetRegistry::Private::FCachedAssetKey(ObjectPath));
}
 
inline const FAssetData* FAssetRegistryState::GetAssetByObjectPath(
    const UE::AssetRegistry::Private::FCachedAssetKey& Key) const
{
    return GetMutableAssetByObjectPath(Key);
}
 
inline FAssetData* FAssetRegistryState::GetMutableAssetByObjectPath(const FSoftObjectPath& ObjectPath) const
{
    return GetMutableAssetByObjectPath(UE::AssetRegistry::Private::FCachedAssetKey(ObjectPath));
}
 
inline FAssetData* FAssetRegistryState::GetMutableAssetByObjectPath(
    const UE::AssetRegistry::Private::FCachedAssetKey& Key) const
{
    FAssetData* const* FoundAsset = CachedAssets.Find(Key);
    return FoundAsset ? *FoundAsset : nullptr;
}
 
inline void FAssetRegistryState::EnumerateAssetsByPackageName(const FName PackageName,
    TFunctionRef<bool(const FAssetData* AssetData)> Callback) const
{
    EnumerateMutableAssetsByPackageName(PackageName, [&Callback](FAssetData* AssetData)
        {
            return Callback(AssetData);
        });
}
 
inline void FAssetRegistryState::EnumerateMutableAssetsByPackageName(const FName PackageName,
    TFunctionRef<bool(FAssetData* AssetData)> Callback) const
{
    using namespace UE::AssetRegistry::Private;
 
#if !UE_ASSETREGISTRY_INDIRECT_ASSETDATA_POINTERS
    if (const TArray<FAssetData*, TInlineAllocator<1>>* FoundAssetArray
        = CachedAssetsByPackageName.Find(PackageName))
    {
        for (FAssetData* AssetData : *FoundAssetArray)
        {
            if (!Callback(AssetData))
            {
                break;
            }
        }
    }
#else
    if (TOptional<TConstArrayView<FAssetDataPtrIndex>> AssetArray = CachedAssetsByPackageName.Find(PackageName))
    {
        for (FAssetDataPtrIndex Index : *AssetArray)
        {
            if (!Callback(CachedAssets[Index]))
            {
                break;
            }
        }
    }
#endif
}
 
inline TArray<const FAssetData*> FAssetRegistryState::CopyAssetsByPackageName(const FName PackageName) const
{
    TArray<const FAssetData*> Result;
    Result.Reserve(NumAssetsByPackageName(PackageName));
    EnumerateAssetsByPackageName(PackageName, [&Result](const FAssetData* AssetData)
        {
            Result.Add(AssetData);
            return true;
        });
    return Result;
}
 
inline int32 FAssetRegistryState::NumAssetsByPackageName(const FName PackageName) const
{
#if !UE_ASSETREGISTRY_INDIRECT_ASSETDATA_POINTERS
    const auto* Array = CachedAssetsByPackageName.Find(PackageName);
    return Array ? Array->Num() : 0;
#else
    const TOptional<TConstArrayView<FAssetDataPtrIndex>> Array = CachedAssetsByPackageName.Find(PackageName);
    return Array ? Array->Num() : 0;
#endif
}
 
inline void FAssetRegistryState::EnumerateAssetsByPackagePath(FName LongPackagePathName,
    TFunctionRef<bool(const FAssetData* AssetData)> Callback) const
{
    EnumerateMutableAssetsByPackagePath(LongPackagePathName, [&Callback](FAssetData* AssetData)
        {
            return Callback(AssetData);
        });
}
 
inline void FAssetRegistryState::EnumerateMutableAssetsByPackagePath(FName LongPackagePathName,
    TFunctionRef<bool(FAssetData* AssetData)> Callback) const
{
    using namespace UE::AssetRegistry::Private;
 
#if !UE_ASSETREGISTRY_INDIRECT_ASSETDATA_POINTERS
    const TArray<FAssetData*>* AssetsInPath = CachedAssetsByPath.Find(LongPackagePathName);
    if (AssetsInPath)
    {
        for (FAssetData* AssetData : *AssetsInPath)
        {
            if (!Callback(AssetData))
            {
                break;
            }
        }
    }
#else
    const TArray<FAssetDataPtrIndex>* AssetsInPath = CachedAssetsByPath.Find(LongPackagePathName);
    if (AssetsInPath)
    {
        for (FAssetDataPtrIndex AssetIndex : *AssetsInPath)
        {
            if (!Callback(CachedAssets[AssetIndex]))
            {
                break;
            }
        }
    }
#endif
}
 
inline void FAssetRegistryState::EnumerateAssetsByClassPathName(
    const FTopLevelAssetPath ClassPathName, TFunctionRef<bool(const FAssetData* AssetData)> Callback) const
{
    using namespace UE::AssetRegistry::Private;
 
#if !UE_ASSETREGISTRY_INDIRECT_ASSETDATA_POINTERS
    if (const TArray<FAssetData*>* FoundAssetArray = CachedAssetsByClass.Find(ClassPathName))
    {
        for (FAssetData* AssetData : *FoundAssetArray)
        {
            Callback(AssetData);
        }
    }
#else
    if (const TArray<FAssetDataPtrIndex>* FoundAssetArray = CachedAssetsByClass.Find(ClassPathName))
    {
        for (FAssetDataPtrIndex AssetIndex : *FoundAssetArray)
        {
            if (!Callback(CachedAssets[AssetIndex]))
            {
                break;
            }
        }
    }
#endif
}
 
inline void FAssetRegistryState::EnumerateTags(TFunctionRef<bool(FName TagName)> Callback) const
{
#if UE_ASSETREGISTRY_CACHEDASSETSBYTAG
    for (const auto& Pair : CachedAssetsByTag)
#else
    for (const TPair<FName, TSet<FTopLevelAssetPath>>& Pair : CachedClassesByTag)
#endif
    {
        if (!Callback(Pair.Key))
        {
            break;
        }
    }
}
 
inline bool FAssetRegistryState::ContainsTag(FName TagName) const
{
#if UE_ASSETREGISTRY_CACHEDASSETSBYTAG
    return CachedAssetsByTag.Contains(TagName);
#else
    return CachedClassesByTag.Contains(TagName);
#endif
}
 
inline const TMap<FName, const FAssetPackageData*>& FAssetRegistryState::GetAssetPackageDataMap() const
{
    return reinterpret_cast<const TMap<FName, const FAssetPackageData*>&>(CachedPackageData);
}
 
inline void FAssetRegistryState::GetPackageNames(TArray<FName>& OutPackageNames) const
{
    OutPackageNames.Reserve(CachedAssetsByPackageName.Num());
    for (const auto& It : CachedAssetsByPackageName)
    {
        OutPackageNames.Add(It.Key);
    }
}
 
inline int32 FAssetRegistryState::GetNumAssets() const
{
    return NumAssets;
}
 
inline int32 FAssetRegistryState::GetNumPackages() const
{
    return CachedAssetsByPackageName.Num();
}
 
inline void FAssetRegistryState::InitializeFromExisting(const FAssetRegistryState& Existing,
    const FAssetRegistrySerializationOptions& Options,
    EInitializationMode InitializationMode,
    FAssetRegistryAppendResult* OutAppendResult)
{
    InitializeFromExisting(Existing.CachedAssets, Existing.CachedDependsNodes,
        Existing.CachedPackageData, Options, InitializationMode, OutAppendResult);
}