IAssetRegistry.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "AssetRegistry/ARFilter.h"
#include "AssetRegistry/AssetIdentifier.h"
#include "Containers/Array.h"
#include "Containers/BitArray.h"
#include "Containers/StringFwd.h"
#include "Misc/AssetRegistryInterface.h"
#include "Misc/Optional.h"
#include "Templates/Function.h"
#include "Templates/PimplPtr.h"
#include "UObject/Interface.h"
#include "IAssetRegistry.generated.h"
 
#ifndef ASSET_REGISTRY_STATE_DUMPING_ENABLED
#define ASSET_REGISTRY_STATE_DUMPING_ENABLED !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
#endif
 
class FArchive;
class FAssetRegistryState;
class FCbFieldView;
class FCbWriter;
class FDependsNode;
enum class EAssetRegistryTagsCaller : uint8;
namespace UE::AssetRegistry { struct FSetManageReferencesScratch; }
struct FARFilter;
struct FARCompiledFilter;
struct FAssetData;
struct FAssetRegistrySerializationOptions;
struct FPackageFileSummary;
struct FObjectExport;
struct FObjectImport;
class ITargetPlatform;
 
namespace EAssetAvailability
{
    enum Type
    {
        DoesNotExist,   // asset chunkid does not exist
        NotAvailable,   // chunk containing asset has not been installed yet
        LocalSlow,      // chunk containing asset is on local slow media (optical)
        LocalFast       // chunk containing asset is on local fast media (HDD)
    };
}
 
namespace EAssetAvailabilityProgressReportingType
{
    enum Type
    {
        ETA,                    // time remaining in seconds
        PercentageComplete      // percentage complete in 99.99 format
    };
}
 
namespace UE::AssetRegistry
{
 
// Please update LexToString when modifying this enum
enum class EScanFlags : uint32
{
    None = 0,
    ForceRescan = 1 << 0,               // the paths will be scanned again, even if they were previously scanned
    IgnoreDenyListScanFilters = 1 << 1, // ignore deny list scan filters
    WaitForInMemoryObjects = 1 << 2,    // update the tags of all assets that have loaded into memory before returning from the scan
    IgnoreInvalidPathWarning = 1 << 3,  // By default, scans of invalid paths (unmounted, or /Temp) log a warning. Suppress that warning.
};
ENUM_CLASS_FLAGS(EScanFlags);
 
ASSETREGISTRY_API FString LexToString(EScanFlags Flags);
 
enum class EAssetSetManagerAssetFlags : uint32
{
    None = 0x0,
    ScriptPackage = 0x1,
};
ENUM_CLASS_FLAGS(EAssetSetManagerAssetFlags);
 
struct FShouldSetManagerContext
{
    const FAssetIdentifier& Manager;
    const FAssetIdentifier& Source;
    const FAssetIdentifier& Target;
    EAssetSetManagerAssetFlags ManagerAssetFlags;
    EAssetSetManagerAssetFlags SourceAssetFlags;
    EAssetSetManagerAssetFlags TargetAssetFlags;
    /* Properties of the edge, and of the target's status in the current phase of SetManageReferences. */
    EAssetSetManagerFlags::Type EdgeFlags;
    EDependencyCategory EdgeARCategory;
    EDependencyProperty EdgeARProperties;
};
 
struct FSetManageReferencesContext
{
    const TMultiMap<FAssetIdentifier, FAssetIdentifier>* ManagerMap = nullptr;
    bool bClearExisting = false;
    EDependencyCategory RecurseType = EDependencyCategory::None;
    TOptional<TFunctionRef<EAssetSetManagerResult::Type(FShouldSetManagerContext& Context)>> ShouldSetManager;
 
    TPimplPtr<FSetManageReferencesScratch> Scratch;
};
 
enum class EAppendMode
{
    Rebuild,
    OnlyUpdateExisting,
    Append,
    OnlyUpdateNew,
};
 
} // namespace UE::AssetRegistry
 
USTRUCT(BlueprintType)
struct FAssetRegistryDependencyOptions
{
    GENERATED_BODY()
 
    bool GetPackageQuery(UE::AssetRegistry::FDependencyQuery& Flags) const;
    bool GetSearchableNameQuery(UE::AssetRegistry::FDependencyQuery& Flags) const;
    bool GetManageQuery(UE::AssetRegistry::FDependencyQuery& Flags) const;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "AssetRegistry")
    bool bIncludeSoftPackageReferences = true;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "AssetRegistry")
    bool bIncludeHardPackageReferences = true;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "AssetRegistry")
    bool bIncludeGamePackageReferences = true;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "AssetRegistry")
    bool bIncludeEditorOnlyPackageReferences = true;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "AssetRegistry")
    bool bIncludeSearchableNames = false;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "AssetRegistry")
    bool bIncludeSoftManagementReferences = false;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "AssetRegistry")
    bool bIncludeHardManagementReferences = false;
};
 
struct FAssetDependency
{
    FAssetIdentifier AssetId;
    UE::AssetRegistry::EDependencyCategory Category = UE::AssetRegistry::EDependencyCategory::None;
    UE::AssetRegistry::EDependencyProperty Properties = UE::AssetRegistry::EDependencyProperty::None;
 
    bool operator==(const FAssetDependency& Other) const
    {
        return AssetId == Other.AssetId && Category == Other.Category && Properties == Other.Properties;
    }
    bool LexicalLess(const FAssetDependency& Other) const
    {
        if (!(AssetId == Other.AssetId))
        {
            return AssetId.LexicalLess(Other.AssetId);
        }
        if (Category != Other.Category)
        {
            return Category < Other.Category;
        }
        return Properties < Other.Properties;
    }
 
    static FAssetDependency PackageDependency(FName PackageName, UE::AssetRegistry::EDependencyProperty Properties)
    {
        return FAssetDependency{ FAssetIdentifier(PackageName), UE::AssetRegistry::EDependencyCategory::Package,
            Properties };
    }
 
    friend inline uint32 GetTypeHash(const FAssetDependency& InHash)
    {
        uint32 Hash = GetTypeHash(InHash.AssetId);
        Hash = HashCombine(Hash, GetTypeHash(InHash.Category));
        Hash = HashCombine(Hash, GetTypeHash(InHash.Properties));
 
        return Hash;
    }
 
 
    ASSETREGISTRY_API void WriteCompactBinary(FCbWriter& Writer) const;
private:
    friend FCbWriter& operator<<(FCbWriter& Writer, const FAssetDependency& Dependency)
    {
        // Hidden friend function needs to be inline, but call a subfunction to hide the implementation
        Dependency.WriteCompactBinary(Writer);
        return Writer;
    }
    // Load Cannot be inline because we need to hide implementation and copy-by-value is invalid without definition
    ASSETREGISTRY_API friend bool LoadFromCompactBinary(FCbFieldView Field, FAssetDependency& Dependency);
};
 
UINTERFACE(MinimalApi, BlueprintType, meta = (CannotImplementInterfaceInBlueprint))
class UAssetRegistry : public UInterface
{
    GENERATED_UINTERFACE_BODY()
};
 
class IAssetRegistry
{
    GENERATED_IINTERFACE_BODY()
public:
    static IAssetRegistry* Get()
    {
        return UE::AssetRegistry::Private::IAssetRegistrySingleton::Get();
    }
    static IAssetRegistry& GetChecked()
    {
        IAssetRegistry* Singleton = UE::AssetRegistry::Private::IAssetRegistrySingleton::Get();
        check(Singleton);
        return *Singleton;
    }
 
    UFUNCTION(BlueprintCallable, BlueprintPure=false, Category = "AssetRegistry")
    virtual bool HasAssets(const FName PackagePath, const bool bRecursive = false) const = 0;
 
    UFUNCTION(BlueprintCallable, BlueprintPure=false, Category="AssetRegistry")
    virtual bool GetAssetsByPackageName(FName PackageName, TArray<FAssetData>& OutAssetData,
        bool bIncludeOnlyOnDiskAssets = false, bool bSkipARFilteredAssets=true) const = 0;
 
    UFUNCTION(BlueprintCallable, BlueprintPure=false, Category = "AssetRegistry")
    virtual bool GetAssetsByPath(FName PackagePath, TArray<FAssetData>& OutAssetData, bool bRecursive = false,
        bool bIncludeOnlyOnDiskAssets = false) const = 0;
 
    UFUNCTION(BlueprintCallable, BlueprintPure = false, Category = "AssetRegistry")
    virtual bool GetAssetsByPaths(TArray<FName> PackagePaths, TArray<FAssetData>& OutAssetData, bool bRecursive = false,
        bool bIncludeOnlyOnDiskAssets = false) const = 0;
 
    UFUNCTION(BlueprintCallable, BlueprintPure=false, Category = "AssetRegistry")
    virtual bool GetAssetsByClass(FTopLevelAssetPath ClassPathName, TArray<FAssetData>& OutAssetData, bool bSearchSubClasses = false) const = 0;
 
    virtual bool GetAssetsByTags(const TArray<FName>& AssetTags, TArray<FAssetData>& OutAssetData) const = 0;
 
    virtual bool GetAssetsByTagValues(const TMultiMap<FName, FString>& AssetTagsAndValues, TArray<FAssetData>& OutAssetData) const = 0;
 
    UFUNCTION(BlueprintCallable, BlueprintPure=false, Category="AssetRegistry")
    virtual bool GetAssets(const FARFilter& Filter, TArray<FAssetData>& OutAssetData, bool bSkipARFilteredAssets=true) const = 0;
    virtual bool GetAssets(const FARCompiledFilter& Filter, TArray<FAssetData>& OutAssetData, bool bSkipARFilteredAssets=true) const = 0;
 
    UFUNCTION(BlueprintCallable, BlueprintPure=false, Category="AssetRegistry")
    virtual bool GetInMemoryAssets(const FARFilter& Filter, TArray<FAssetData>& OutAssetData, bool bSkipARFilteredAssets=true) const = 0;
    virtual bool GetInMemoryAssets(const FARCompiledFilter& Filter, TArray<FAssetData>& OutAssetData, bool bSkipARFilteredAssets=true) const = 0;
 
    virtual bool EnumerateAssets(const FARFilter& Filter, TFunctionRef<bool(const FAssetData&)> Callback,
        UE::AssetRegistry::EEnumerateAssetsFlags InEnumerateFlags = UE::AssetRegistry::EEnumerateAssetsFlags::None) const = 0;
    virtual bool EnumerateAssets(const FARCompiledFilter& Filter, TFunctionRef<bool(const FAssetData&)> Callback,
        UE::AssetRegistry::EEnumerateAssetsFlags InEnumerateFlags = UE::AssetRegistry::EEnumerateAssetsFlags::None) const = 0;
 
    UE_DEPRECATED(5.6, "Asset path FNames have been deprecated, use Soft Object Path instead.")
    UFUNCTION(BlueprintCallable, BlueprintPure=false, Category="AssetRegistry", meta=(DeprecatedFunction="Note", DeprecationMessage="Use other version that takes a SoftObjectPath"))
    virtual FAssetData GetAssetByObjectPath( const FName ObjectPath, bool bIncludeOnlyOnDiskAssets = false ) const = 0;
 
    UFUNCTION(BlueprintCallable, BlueprintPure=false, Category = "AssetRegistry", DisplayName="Get Asset By Object Path")
    ASSETREGISTRY_API virtual FAssetData K2_GetAssetByObjectPath(const FSoftObjectPath& ObjectPath,
        bool bIncludeOnlyOnDiskAssets = false, bool bSkipARFilteredAssets = true) const;
 
    virtual FAssetData GetAssetByObjectPath(const FSoftObjectPath& ObjectPath,
        bool bIncludeOnlyOnDiskAssets = false, bool bSkipARFilteredAssets = true) const = 0;
 
    virtual UE::AssetRegistry::EExists TryGetAssetByObjectPath(const FSoftObjectPath& ObjectPath,
        FAssetData& OutAssetData) const = 0;
 
    virtual UE::AssetRegistry::EExists TryGetAssetPackageData(FName PackageName,
        FAssetPackageData& OutAssetPackageData) const = 0;
 
    virtual UE::AssetRegistry::EExists TryGetAssetPackageData(FName PackageName,
        FAssetPackageData& OutAssetPackageData, FName& OutCorrectCasePackageName) const = 0;
    
    UFUNCTION(BlueprintCallable, BlueprintPure=false, Category = "AssetRegistry")
    virtual bool GetAllAssets(TArray<FAssetData>& OutAssetData, bool bIncludeOnlyOnDiskAssets = false) const = 0;
 
    virtual bool EnumerateAllAssets(TFunctionRef<bool(const FAssetData&)> Callback,
        UE::AssetRegistry::EEnumerateAssetsFlags InEnumerateFlags = UE::AssetRegistry::EEnumerateAssetsFlags::None) const = 0;
 
    virtual void GetPackagesByName(FStringView PackageName, TArray<FName>& OutPackageNames) const = 0;
 
    virtual FName GetFirstPackageByName(FStringView PackageName) const = 0;
 
    virtual 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 = 0;
    virtual 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 = 0;
 
    virtual bool GetDependencies(FName PackageName, TArray<FName>& OutDependencies,
        UE::AssetRegistry::EDependencyCategory Category = UE::AssetRegistry::EDependencyCategory::Package,
        const UE::AssetRegistry::FDependencyQuery& Flags = UE::AssetRegistry::FDependencyQuery()) const = 0;
 
    virtual bool ContainsDependency(FName PackageName, FName QueryDependencyName,
        UE::AssetRegistry::EDependencyCategory Category = UE::AssetRegistry::EDependencyCategory::Package,
        const UE::AssetRegistry::FDependencyQuery& Flags = UE::AssetRegistry::FDependencyQuery()) const = 0;
 
    UFUNCTION(BlueprintCallable, BlueprintPure=false, Category = "AssetRegistry",
        meta=(DisplayName="Get Dependencies", ScriptName="GetDependencies"))
    virtual bool K2_GetDependencies(FName PackageName, const FAssetRegistryDependencyOptions& DependencyOptions,
        TArray<FName>& OutDependencies) const;
 
    virtual 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 = 0;
    virtual 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 = 0;
 
    virtual bool GetReferencers(FName PackageName, TArray<FName>& OutReferencers,
        UE::AssetRegistry::EDependencyCategory Category = UE::AssetRegistry::EDependencyCategory::Package,
        const UE::AssetRegistry::FDependencyQuery& Flags = UE::AssetRegistry::FDependencyQuery()) const = 0;
 
    UFUNCTION(BlueprintCallable, BlueprintPure=false, Category = "AssetRegistry",
        meta=(DisplayName="Get Referencers", ScriptName="GetReferencers"))
    virtual bool K2_GetReferencers(FName PackageName, const FAssetRegistryDependencyOptions& ReferenceOptions,
        TArray<FName>& OutReferencers) const;
 
    virtual TOptional<FAssetPackageData> GetAssetPackageDataCopy(FName PackageName) const = 0;
 
    virtual TArray<TOptional<FAssetPackageData>> GetAssetPackageDatasCopy(TArrayView<FName> PackageNames) const = 0;
 
    virtual void EnumerateAllPackages(TFunctionRef<void(FName PackageName, const FAssetPackageData& PackageData)> Callback,
        UE::AssetRegistry::EEnumeratePackagesFlags InEnumerateFlags = UE::AssetRegistry::EEnumeratePackagesFlags::None) const = 0;
 
    /*
    * Checks if the specified package exists on disk. If the package exists and the optional parameters are provided, 
    * OutCorrectCasePackageName will be populated with the case matching package name found on disk and 
    * OutExtension will be populated with the extension for the package (dot included) if the package contains assets
    * 
    * @param PackageName                the name of the package to check for existence on disk (eg, /Game/MyFolder/MyAsset)
    * @param OutCorrectCasePackageName  out package name matching the case on disk
    * @param OutExtension               out extension for packages containing assets (dot included)
    */
    virtual bool DoesPackageExistOnDisk(FName PackageName, FString* OutCorrectCasePackageName = nullptr,
        FString* OutExtension = nullptr) const = 0;
 
    virtual FSoftObjectPath GetRedirectedObjectPath(const FSoftObjectPath& ObjectPath) = 0;
 
    UFUNCTION(BlueprintCallable, BlueprintPure = false, Category = "AssetRegistry",
        meta=(DisplayName = "GetAncestorClassNames", ScriptName = "GetAncestorClassNames"))
    virtual bool GetAncestorClassNames(FTopLevelAssetPath ClassPathName,
        TArray<FTopLevelAssetPath>& OutAncestorClassNames) const = 0;
 
    UFUNCTION(BlueprintCallable, BlueprintPure = false, Category = "AssetRegistry",
        meta=(DisplayName = "GetDerivedClassNames", ScriptName = "GetDerivedClassNames"))
    virtual void GetDerivedClassNames(const TArray<FTopLevelAssetPath>& ClassNames,
        const TSet<FTopLevelAssetPath>& ExcludedClassNames, TSet<FTopLevelAssetPath>& OutDerivedClassNames) const = 0;
    
    UFUNCTION(BlueprintCallable, BlueprintPure=false, Category = "AssetRegistry")
    virtual void GetAllCachedPaths(TArray<FString>& OutPathList) const = 0;
 
    virtual void EnumerateAllCachedPaths(TFunctionRef<bool(FString)> Callback) const = 0;
 
    virtual void EnumerateAllCachedPaths(TFunctionRef<bool(FName)> Callback) const = 0;
 
    UFUNCTION(BlueprintCallable, BlueprintPure=false, Category = "AssetRegistry")
    virtual void GetSubPaths(const FString& InBasePath, TArray<FString>& OutPathList, bool bInRecurse) const = 0;
 
    virtual void GetSubPaths(const FName& InBasePath, TArray<FName>& OutPathList, bool bInRecurse) const = 0;
 
    virtual void EnumerateSubPaths(const FString& InBasePath, TFunctionRef<bool(FString)> Callback, bool bInRecurse) const = 0;
 
    virtual void EnumerateSubPaths(const FName InBasePath, TFunctionRef<bool(FName)> Callback, bool bInRecurse) const = 0;
 
    UFUNCTION(BlueprintCallable, BlueprintPure=false, Category = "AssetRegistry")
    virtual void RunAssetsThroughFilter(UPARAM(ref) TArray<FAssetData>& AssetDataList, const FARFilter& Filter) const = 0;
 
    UFUNCTION(BlueprintCallable, BlueprintPure=false, Category = "AssetRegistry")
    virtual void UseFilterToExcludeAssets(UPARAM(ref) TArray<FAssetData>& AssetDataList, const FARFilter& Filter) const = 0;
 
    virtual void UseFilterToExcludeAssets(TArray<FAssetData>& AssetDataList, const FARCompiledFilter& CompiledFilter) const = 0;
    
    virtual bool IsAssetIncludedByFilter(const FAssetData& AssetData, const FARCompiledFilter& Filter) const = 0;
 
    virtual bool IsAssetExcludedByFilter(const FAssetData& AssetData, const FARCompiledFilter& Filter) const = 0;
 
    virtual void CompileFilter(const FARFilter& InFilter, FARCompiledFilter& OutCompiledFilter) const = 0;
 
    virtual void SetTemporaryCachingMode(bool bEnable) = 0;
    virtual void SetTemporaryCachingModeInvalidated() = 0;
 
    virtual bool GetTemporaryCachingMode() const = 0;
 
    virtual EAssetAvailability::Type GetAssetAvailability(const FAssetData& AssetData) const = 0;
 
    virtual float GetAssetAvailabilityProgress(const FAssetData& AssetData,
        EAssetAvailabilityProgressReportingType::Type ReportType) const = 0;
 
    virtual bool GetAssetAvailabilityProgressTypeSupported(EAssetAvailabilityProgressReportingType::Type ReportType) const = 0; 
 
    virtual void PrioritizeAssetInstall(const FAssetData& AssetData) const = 0;
 
    virtual bool HasVerseFiles(FName PackagePath, bool bRecursive = false) const = 0;
 
    virtual bool GetVerseFilesByPath(FName PackagePath, TArray<FName>& OutFilePaths, bool bRecursive = false) const = 0;
 
    virtual bool AddPath(const FString& PathToAdd) = 0;
 
    virtual bool RemovePath(const FString& PathToRemove) = 0;
 
    virtual bool PathExists(const FString& PathToTest) const = 0;
    virtual bool PathExists(const FName PathToTest) const = 0;
 
    UFUNCTION(BlueprintCallable, Category = "AssetRegistry")
    virtual void ScanPathsSynchronous(const TArray<FString>& InPaths, bool bForceRescan = false,
        bool bIgnoreDenyListScanFilters = false) = 0;
 
    UFUNCTION(BlueprintCallable, Category = "AssetRegistry")
    virtual void ScanFilesSynchronous(const TArray<FString>& InFilePaths, bool bForceRescan = false) = 0;
 
    virtual void ScanSynchronous(const TArray<FString>& InPaths, const TArray<FString>& InFilePaths,
        UE::AssetRegistry::EScanFlags InScanFlags = UE::AssetRegistry::EScanFlags::None) = 0;
 
    UFUNCTION(BlueprintCallable, Category = "AssetRegistry")
    virtual void SearchAllAssets(bool bSynchronousSearch) = 0;
 
    UFUNCTION(BlueprintCallable, Category = "AssetRegistry")
    virtual bool IsSearchAllAssets() const = 0;
 
    UFUNCTION(BlueprintCallable, Category = "AssetRegistry")
    virtual bool IsSearchAsync() const = 0;
 
    UFUNCTION(BlueprintCallable, Category = "AssetRegistry")
    virtual void WaitForCompletion() = 0;
 
    virtual void WaitForPremadeAssetRegistry() = 0;
 
    virtual void ClearGathererCache() = 0;
 
    UFUNCTION(BlueprintCallable, Category = "AssetRegistry")
    virtual void WaitForPackage(const FString& PackageName) = 0;
 
    UFUNCTION(BlueprintCallable, Category = "AssetRegistry")
    virtual void PrioritizeSearchPath(const FString& PathToPrioritize) = 0;
 
    UFUNCTION(BlueprintCallable, Category = "AssetRegistry")
    virtual void ScanModifiedAssetFiles(const TArray<FString>& InFilePaths) = 0;
    virtual void ScanModifiedAssetFiles(const TArray<FString>& InFilePaths, UE::AssetRegistry::EScanFlags ScanFlags) = 0;
 
    DECLARE_EVENT_OneParam( IAssetRegistry, FFilesBlockedEvent, const TArray<FString>& /*Files*/ );
    virtual FFilesBlockedEvent& OnFilesBlocked() = 0;
 
    DECLARE_TS_MULTICAST_DELEGATE_OneParam( FPathsEvent, TConstArrayView<FStringView> /* Paths */);
    DECLARE_TS_MULTICAST_DELEGATE_OneParam( FPathAddedEvent, const FString& /*Path*/ );
    DECLARE_EVENT_OneParam( IAssetRegistry, FPathRemovedEvent, const FString& /*Path*/ );
    virtual FPathsEvent& OnPathsAdded() = 0;
    virtual FPathsEvent& OnPathsRemoved() = 0;
    virtual FPathAddedEvent& OnPathAdded() = 0;
    virtual FPathRemovedEvent& OnPathRemoved() = 0;
 
    virtual void AssetCreated(UObject* NewAsset) = 0;
 
    virtual void AssetDeleted(UObject* DeletedAsset) = 0;
 
    virtual void AssetRenamed(const UObject* RenamedAsset, const FString& OldObjectPath) = 0;
 
    virtual void AssetsSaved(TArray<FAssetData>&& Assets) = 0;
 
    virtual void AssetUpdateTags(UObject* Object, EAssetRegistryTagsCaller Caller) = 0;
 
    virtual bool VerseCreated(const FString& FilePathOnDisk) = 0;
 
    virtual bool VerseDeleted(const FString& FilePathOnDisk) = 0;
 
    virtual void PackageDeleted (UPackage* DeletedPackage) = 0;
 
    virtual void AssetTagsFinalized(const UObject& FinalizedAsset) = 0;
 
    DECLARE_TS_MULTICAST_DELEGATE_OneParam( FAssetsEvent, TConstArrayView<FAssetData> );
 
    DECLARE_TS_MULTICAST_DELEGATE_ThreeParams( FAssetCollisionEvent, FAssetData&, FAssetData&, FAssetData*& );
    virtual FAssetCollisionEvent& OnAssetCollision_Private() = 0;
 
    DECLARE_TS_MULTICAST_DELEGATE_OneParam( FAssetAddedEvent, const FAssetData& );
    virtual FAssetAddedEvent& OnAssetAdded() = 0;
 
    virtual FAssetsEvent& OnAssetsAdded() = 0;
 
    DECLARE_TS_MULTICAST_DELEGATE_OneParam( FAssetRemovedEvent, const FAssetData& );
    virtual FAssetRemovedEvent& OnAssetRemoved() = 0;
 
    virtual FAssetsEvent& OnAssetsRemoved() = 0;
 
    DECLARE_TS_MULTICAST_DELEGATE_TwoParams( FAssetRenamedEvent, const FAssetData&, const FString& );
    virtual FAssetRenamedEvent& OnAssetRenamed() = 0;
 
    DECLARE_TS_MULTICAST_DELEGATE_OneParam( FAssetUpdatedEvent, const FAssetData&);
    virtual FAssetUpdatedEvent& OnAssetUpdated() = 0;
 
    virtual FAssetsEvent& OnAssetsUpdated() = 0;
 
    virtual FAssetUpdatedEvent& OnAssetUpdatedOnDisk() = 0;
 
    virtual FAssetsEvent& OnAssetsUpdatedOnDisk() = 0;
 
    DECLARE_TS_MULTICAST_DELEGATE_OneParam( FInMemoryAssetCreatedEvent, UObject* );
    virtual FInMemoryAssetCreatedEvent& OnInMemoryAssetCreated() = 0;
 
    DECLARE_TS_MULTICAST_DELEGATE_OneParam( FInMemoryAssetDeletedEvent, UObject* );
    virtual FInMemoryAssetDeletedEvent& OnInMemoryAssetDeleted() = 0;
 
    DECLARE_TS_MULTICAST_DELEGATE_OneParam( FVerseAddedEvent, const FName /* VerseFilePath */);
    virtual FVerseAddedEvent& OnVerseAdded() = 0;
 
    DECLARE_TS_MULTICAST_DELEGATE_OneParam( FVerseRemovedEvent, const FName /* VerseFilePath */);
    virtual FVerseRemovedEvent& OnVerseRemoved() = 0;
 
    DECLARE_TS_MULTICAST_DELEGATE( FFilesLoadedEvent );
    virtual FFilesLoadedEvent& OnFilesLoaded() = 0;
 
    DECLARE_TS_MULTICAST_DELEGATE(FScanStartedEvent);
    virtual FScanStartedEvent& OnScanStarted() = 0;
 
    DECLARE_TS_MULTICAST_DELEGATE(FScanEndedEvent);
    virtual FScanEndedEvent& OnScanEnded() = 0;
 
    DECLARE_TS_MULTICAST_DELEGATE(FKnownGathersCompleteEvent);
    virtual FKnownGathersCompleteEvent& OnKnownGathersComplete() = 0;
 
    struct FFileLoadProgressUpdateData
    {
        FFileLoadProgressUpdateData(int32 InNumTotalAssets, int32 InNumAssetsProcessedByAssetRegistry,
            int32 InNumAssetsPendingDataLoad, bool InIsDiscoveringAssetFiles)
            : NumTotalAssets(InNumTotalAssets)
            , NumAssetsProcessedByAssetRegistry(InNumAssetsProcessedByAssetRegistry)
            , NumAssetsPendingDataLoad(InNumAssetsPendingDataLoad)
            , bIsDiscoveringAssetFiles(InIsDiscoveringAssetFiles)
        {
        }
 
        bool operator==(const FFileLoadProgressUpdateData& Other) const
        {
            return NumTotalAssets == Other.NumTotalAssets 
                && NumAssetsProcessedByAssetRegistry == Other.NumAssetsProcessedByAssetRegistry
                && NumAssetsPendingDataLoad == Other.NumAssetsPendingDataLoad
                && bIsDiscoveringAssetFiles == Other.bIsDiscoveringAssetFiles;
        }
 
        int32 NumTotalAssets;
        int32 NumAssetsProcessedByAssetRegistry;
        int32 NumAssetsPendingDataLoad;
        bool bIsDiscoveringAssetFiles;
    };
 
    DECLARE_TS_MULTICAST_DELEGATE_OneParam( FFileLoadProgressUpdatedEvent, const FFileLoadProgressUpdateData& /*ProgressUpdateData*/ );
    virtual FFileLoadProgressUpdatedEvent& OnFileLoadProgressUpdated() = 0;
 
    UFUNCTION(BlueprintCallable, Category = "AssetRegistry")
    virtual bool IsLoadingAssets() const = 0;
    virtual bool IsGathering() const = 0;
 
    virtual bool HasSerializedDiscoveryCache() const = 0;
 
    virtual bool ShouldUpdateDiskCacheAfterLoad() const = 0;
 
    virtual void Tick (float DeltaTime) = 0;
 
    virtual void Serialize(FArchive& Ar) = 0;
    virtual void Serialize(FStructuredArchive::FRecord Record) = 0;
 
    virtual void AppendState(const FAssetRegistryState& InState, UE::AssetRegistry::EAppendMode AppendMode = UE::AssetRegistry::EAppendMode::Append) = 0;
 
    virtual SIZE_T GetAllocatedSize(bool bLogDetailed = false) const = 0;
 
    virtual void InitializeTemporaryAssetRegistryState(FAssetRegistryState& OutState, const FAssetRegistrySerializationOptions& Options,
        bool bRefreshExisting = false, const TSet<FName>& RequiredPackages = TSet<FName>(),
        const TSet<FName>& RemovePackages = TSet<FName>()) const = 0;
 
#if ASSET_REGISTRY_STATE_DUMPING_ENABLED
    virtual void DumpState(const TArray<FString>& Arguments, TArray<FString>& OutPages, int32 LinesPerPage = 1) const = 0;
#endif
 
    virtual TSet<FName> GetCachedEmptyPackagesCopy() const = 0;
 
    virtual bool ContainsTag(FName TagName) const = 0;
 
    UE_DEPRECATED(5.7, "Use version taking ITargetPlatform parameter instead")
    ASSETREGISTRY_API virtual void InitializeSerializationOptions(FAssetRegistrySerializationOptions& Options,
        const FString& PlatformIniName,
        UE::AssetRegistry::ESerializationTarget Target) const;
 
    virtual void InitializeSerializationOptions(FAssetRegistrySerializationOptions& Options,
        const ITargetPlatform* TargetPlatform = nullptr,
        UE::AssetRegistry::ESerializationTarget Target = UE::AssetRegistry::ESerializationTarget::ForGame) const = 0;
 
    struct FLoadPackageRegistryData
    {
        ASSETREGISTRY_API FLoadPackageRegistryData(bool bInGetDependencies = false);
        ASSETREGISTRY_API ~FLoadPackageRegistryData();
 
        TArray<FAssetData> Data;
        TArray<FName> DataDependencies;
        bool bGetDependencies;
    };
 
    virtual void LoadPackageRegistryData(FArchive& Ar, FLoadPackageRegistryData& InOutData) const = 0;
    
    virtual void LoadPackageRegistryData(const FString& PackageFilename, FLoadPackageRegistryData& InOutData) const = 0;
 
    typedef TFunctionRef<bool(const FAssetData* AssetData)> FAssetDataFunc;
    typedef TFunctionRef<bool(FAssetDataFunc AssetCallback)> FEnumerateAssetDatasFunc;
 
    virtual void ReadLockEnumerateAllTagToAssetDatas(TFunctionRef<bool(FName TagName,
        FEnumerateAssetDatasFunc EnumerateAssets)> Callback) const = 0;
 
    typedef TFunction<EAssetSetManagerResult::Type(const FAssetIdentifier& Manager, const FAssetIdentifier& Source,
        const FAssetIdentifier& Target, UE::AssetRegistry::EDependencyCategory Category,
        UE::AssetRegistry::EDependencyProperty Properties, EAssetSetManagerFlags::Type Flags)>
        ShouldSetManagerPredicate;
 
    virtual bool IsPathBeautificationNeeded(const FString& InAssetPath) const = 0;
 
    struct FPauseBackgroundProcessingScope
    {
        FPauseBackgroundProcessingScope() { IAssetRegistry::GetChecked().RequestPauseBackgroundProcessing(); }
        ~FPauseBackgroundProcessingScope() { IAssetRegistry::GetChecked().RequestResumeBackgroundProcessing(); }
    };
 
    DECLARE_TS_MULTICAST_DELEGATE_TwoParams(FEnumerateAssetsEvent, const FARCompiledFilter& /*Filter*/, UE::AssetRegistry::EEnumerateAssetsFlags /*Flag*/)
    virtual FEnumerateAssetsEvent& OnEnumerateAssetsEvent() = 0;
 
protected:
 
    // Implementation methods for FPauseBackgroundProcessingScope
    virtual void RequestPauseBackgroundProcessing() {}
    virtual void RequestResumeBackgroundProcessing() {}
 
    // Functions specifically for calling from the asset manager
    friend class UAssetManager;
 
    UE_DEPRECATED(5.6, "Use version that takes FSetManageReferencesContext.")
    virtual void SetManageReferences(const TMultiMap<FAssetIdentifier, FAssetIdentifier>& ManagerMap,
        bool bClearExisting, UE::AssetRegistry::EDependencyCategory RecurseType,
        TSet<FDependsNode*>& ExistingManagedNodes, ShouldSetManagerPredicate ShouldSetManager = nullptr) = 0;
 
    virtual void SetManageReferences(UE::AssetRegistry::FSetManageReferencesContext& Context) = 0;
 
    virtual bool SetPrimaryAssetIdForObjectPath(const FSoftObjectPath& ObjectPath, FPrimaryAssetId PrimaryAssetId) = 0;
};
 
namespace UE::AssetRegistry
{
    enum EReadPackageDataMainErrorCode
    {
        Unknown = 0,
        InvalidObjectCount = 1,
        InvalidTagCount = 2,
        InvalidTag = 3,
    };
 
    struct FDeserializePackageData
    {
        int64 DependencyDataOffset = INDEX_NONE;
        int32 ObjectCount = 0;
 
        ASSETREGISTRY_API bool DoSerialize(FArchive& BinaryArchive, const FPackageFileSummary& PackageFileSummary,
            EReadPackageDataMainErrorCode& OutError);
    };
 
    struct FDeserializeObjectPackageData
    {
        FString ObjectPath;
        FString ObjectClassName;
        int32 TagCount = 0;
 
        ASSETREGISTRY_API bool DoSerialize(FArchive& BinaryArchive, EReadPackageDataMainErrorCode& OutError);
    };
 
    struct FDeserializeTagData
    {
        FString Key;
        FString Value;
 
        ASSETREGISTRY_API bool DoSerialize(FArchive& BinaryArchive, EReadPackageDataMainErrorCode& OutError);
    };
 
    // Functions to read and write the data used by the AssetRegistry in each package; the format of this data is
    // separate from the format of the data in the asset registry.
    // WritePackageData is declared in AssetRegistryInterface.h, in the CoreUObject module, because it is needed by
    // SavePackage in CoreUObject
    ASSETREGISTRY_API bool ReadPackageDataMain(FArchive& BinaryArchive, const FString& PackageName,
        const FPackageFileSummary& PackageFileSummary, int64& OutDependencyDataOffset,
        TArray<FAssetData*>& OutAssetDataList, EReadPackageDataMainErrorCode& OutError,
        const TArray<FObjectImport>* InImports = nullptr, const TArray<FObjectExport>* InExports = nullptr);
    struct FReadPackageDataDependenciesArgs
    {
        // Required inputs, must be initialized and non-null
        FArchive* BinaryNameAwareArchive = nullptr;
        int64 AssetRegistryDependencyDataOffset = -1;
        int32 NumImports = -1;
        int32 NumSoftPackageReferences = -1;
        FPackageFileVersion PackageVersion;
 
        // Outputs
        TBitArray<> ImportUsedInGame;
        TBitArray<> SoftPackageUsedInGame;
        TArray<TPair<FName, EExtraDependencyFlags>> ExtraPackageDependencies;
        int64 AssetRegistryDependencyDataSize = 0;
    };
    ASSETREGISTRY_API bool ReadPackageDataDependencies(FReadPackageDataDependenciesArgs& Args);
 
    ASSETREGISTRY_API void GetAssetForPackages(TConstArrayView<FName> PackageNames, TMap<FName,
        FAssetData>& OutPackageToAssetData);
 
    enum class EGetMostImportantAssetFlags
    {
        None = 0,
        
        /* Returns nullptr if there are multiple top level assets. */
        RequireOneTopLevelAsset = 0x1,
 
        /* Don't skip AR filtered classes (i.e. BP and BPGC). This is cruicial if you are
        * running in environments where the skip classes can't be initialized (i.e. Programs) as you
        * could get different results in such cases. */
        IgnoreSkipClasses = 0x2
    };
 
    ASSETREGISTRY_API const FAssetData* GetMostImportantAsset(TConstArrayView<const FAssetData*> PackageAssetDatas,
        EGetMostImportantAssetFlags InFlags = EGetMostImportantAssetFlags::None);
 
    /*
    * Returns true if the asset registry should start searching all assets on startup
    */
    ASSETREGISTRY_API bool ShouldSearchAllAssetsAtStart();
 
    // Wildcards (*) used when looking up assets in the asset registry
    extern ASSETREGISTRY_API const FName WildcardFName;
    extern ASSETREGISTRY_API const FTopLevelAssetPath WildcardPathName;
 
 
    /*
    * Various FNames for asset tags that get added during staging if asset registry writeback is enabled.
    * Note that these sizes refer to the package as a whole, and some packages have more than one asset per
    * package. In that case, the data is stored on the asset returned by GetMostImportantAsset with IgnoreSkipClasses.
    * 
    * NOTE some platforms do not compress in UnrealPak. For those platforms, all compressed sizes are actually
    * uncompressed!
    * 
    * Stage_ChunkCountFName             Total iostore chunks in the package.
    * Stage_ChunkSizeFName              The total uncompressed size of the chunks in the package.
    * Stage_ChunkCompressedSizeFName    The total compressed size of the chunks in the package. SEE NOTE ABOVE!
    * Stage_ChunkInstalledSizeFName     The compressed size of all chunks that must be installed with the game/plugin.
    * Stage_ChunkStreamingSizeFName     The compressed size of all chunks that are delivered using IAS.
    * Stage_ChunkOptionalSizeFName      The compressed size of all chunks that are placed in an optional container.
    * 
    * See CookMetadata.h - UE::Cook::EPluginSizeTypes for more information on size types.
    */
    extern ASSETREGISTRY_API const FName Stage_ChunkCountFName;
    extern ASSETREGISTRY_API const FName Stage_ChunkSizeFName;
    extern ASSETREGISTRY_API const FName Stage_ChunkCompressedSizeFName;
    extern ASSETREGISTRY_API const FName Stage_ChunkInstalledSizeFName;
    extern ASSETREGISTRY_API const FName Stage_ChunkStreamingSizeFName;
    extern ASSETREGISTRY_API const FName Stage_ChunkOptionalSizeFName;
} // namespace UE::AssetRegistry
 
ASSETREGISTRY_API const TCHAR* GetDevelopmentAssetRegistryFilename();