AssetRegistryImpl.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "AssetDataGatherer.h"
#include "AssetRegistry/AssetData.h"
#include "AssetRegistry/AssetRegistryState.h"
#include "AssetRegistry/IAssetRegistry.h"
#include "AssetRegistry/PathTree.h"
#include "Containers/RingBuffer.h"
#include "Containers/Map.h"
#include "Containers/Set.h"
#include "HAL/CriticalSection.h"
#include "Math/NumericLimits.h"
#include "Misc/Optional.h"
#include "Misc/TransactionallySafeRWLock.h"
#include "Misc/ScopeRWLock.h"
#include "ModuleDescriptor.h"
#include "PackageDependencyData.h"
#include "Templates/Function.h"
#include "Templates/UniquePtr.h"
 
#include <atomic>
 
// Disable premade asset registry until the target specifies it in UBT
#ifdef ASSETREGISTRY_ENABLE_PREMADE_REGISTRY_IN_EDITOR
#error "Please use ASSETREGISTRY_FORCE_PREMADE_REGISTRY_IN_EDITOR instead of ASSETREGISTRY_ENABLE_PREMADE_REGISTRY_IN_EDITOR"
#endif
 
#ifndef ASSETREGISTRY_FORCE_PREMADE_REGISTRY_IN_EDITOR
#define ASSETREGISTRY_FORCE_PREMADE_REGISTRY_IN_EDITOR 0
#endif
 
class ITargetPlatform;
class FDependsNode;
struct FARFilter;
class FAssetDataGatherer;
struct FFileChangeData;
class FPackageReader;
class UAssetRegistryImpl;
namespace UE::AssetRegistry::Impl { struct FEventContext; }
namespace UE::AssetRegistry::Premade { enum class ELoadResult : uint8; }
namespace UE::AssetRegistry::Premade { struct FAsyncConsumer; }
namespace UE::AssetRegistry::Impl { struct FInitializeContext; }
namespace UE::AssetRegistry::Impl { struct FScanPathContext; }
namespace UE::AssetRegistry::Impl { struct FTickContext; }
namespace UE::AssetRegistry::Impl { struct FClassInheritanceContext; }
namespace UE::AssetRegistry::Private { class FRWLockWithPriority; }
namespace UE::AssetRegistry::Private { using FInterfaceRWLock = FRWLockWithPriority; }
namespace UE::AssetRegistry::DependsNode { struct FGatherDependencyDataScratchpad; }
namespace UE::AssetRegistry { template <typename TScopeLockType> class TRWScopeLockWithPriority; }
namespace UE::AssetRegistry { using FInterfaceReadScopeLock = TRWScopeLockWithPriority<UE::TReadScopeLock<Private::FRWLockWithPriority>>; }
namespace UE::AssetRegistry { using FInterfaceWriteScopeLock = TRWScopeLockWithPriority<UE::TWriteScopeLock<Private::FRWLockWithPriority>>; }
namespace UE::AssetRegistry { using FInterfaceRWScopeLock = class FRWScopeLockWithPriority; }
 
#if WITH_EDITOR
namespace UE::AssetDependencyGatherer::Private { class FRegisteredAssetDependencyGatherer; }
#endif
 
namespace UE::AssetRegistry
{
namespace Premade
{
struct FAsyncConsumer
{
    ~FAsyncConsumer();
    void PrepareForConsume();
    void Wait(FInterfaceWriteScopeLock& ScopeLock);
    void Consume(UAssetRegistryImpl& UARI, UE::AssetRegistry::Impl::FEventContext& EventContext, ELoadResult LoadResult, FAssetRegistryState&& ARState);
 
private:
    int32 ReferenceCount = 0;
    FEvent* Consumed = nullptr;
};
} // namespace Premade within UE::AssetRegistry
 
namespace Private
{
class FRWLockWithPriority
{
public:
    FORCEINLINE void WriteLock()
    {
        Mutex.WriteLock();
    }
 
    FORCEINLINE void WriteUnlock()
    {
        Mutex.WriteUnlock();
    }
 
    FORCEINLINE void ReadLock()
    {
        Mutex.ReadLock();
    }
 
    FORCEINLINE void ReadUnlock()
    {
        Mutex.ReadUnlock();
    }
 
    bool HasWaiters() const
    {
        bool Result;
        UE_AUTORTFM_OPEN
        {
            Result = HighPriorityWaitersCount.load(std::memory_order_relaxed) > 0;
        };
        return Result;
    }
 
private:
    friend FInterfaceReadScopeLock;
    friend FInterfaceWriteScopeLock;
    friend FInterfaceRWScopeLock;
    FTransactionallySafeRWLock Mutex;
    std::atomic<int32> HighPriorityWaitersCount;
};
 
enum ELockPriority : uint8
{
    PriorityLow,
    PriorityHigh
};
} // namespace Private within namespace UE::AssetRegistry
 
class FScopedHighPriorityWaitTracker
{
public:
    FScopedHighPriorityWaitTracker(std::atomic<int32>* InCounter, Private::ELockPriority InPriority)
        : Counter((InPriority == Private::PriorityHigh) ? InCounter : nullptr)
    {
        if (Counter)
        {
            UE_AUTORTFM_OPEN
            {
                Counter->fetch_add(1, std::memory_order_relaxed);
            };
            AutoRTFM::PushOnAbortHandler(this, [this]
                {
                    Counter->fetch_sub(1, std::memory_order_relaxed);
                });
        }
    }
 
    ~FScopedHighPriorityWaitTracker()
    {
        if (Counter)
        {
            UE_AUTORTFM_OPEN
            {
                Counter->fetch_sub(1, std::memory_order_relaxed);
            };
            AutoRTFM::PopOnAbortHandler(this);
        }
    }
 
private:
    std::atomic<int32>* Counter = nullptr;
};
 
template <typename TScopeLockType> class TRWScopeLockWithPriority
{
public:
    UE_NODISCARD_CTOR explicit TRWScopeLockWithPriority(Private::FRWLockWithPriority& InLock,
        Private::ELockPriority InPriority = Private::PriorityHigh)
        : Lock(InLock)
        , Priority(InPriority)
    {
        FScopedHighPriorityWaitTracker Tracker(&Lock.HighPriorityWaitersCount, Priority);
        GuardWrapper.Emplace(Lock);
    }
 
    TOptional<TScopeLockType> GuardWrapper;
    UE::AssetRegistry::Private::FRWLockWithPriority& Lock;
    UE::AssetRegistry::Private::ELockPriority Priority;
};
 
class FRWScopeLockWithPriority
{
public:
    UE_NODISCARD_CTOR explicit FRWScopeLockWithPriority(Private::FRWLockWithPriority& InLockObject,
        FRWScopeLockType InLockType, Private::ELockPriority InPriority = Private::PriorityHigh)
        : Lock(InLockObject)
        , Priority(InPriority)
        , LockType(InLockType)
    {
        FScopedHighPriorityWaitTracker Tracker(&Lock.HighPriorityWaitersCount, Priority);
        GuardWrapper.Emplace(Lock, LockType);
    }
 
    // NOTE: As the name suggests, this function should be used with caution. 
    // It releases the read lock _before_ acquiring a new write lock. This is not an atomic operation and the caller should 
    // not treat it as such. 
    // E.g. Pointers read from protected data structures prior to this call may be invalid after the function is called. 
    void ReleaseReadOnlyLockAndAcquireWriteLock_USE_WITH_CAUTION()
    {
        if (LockType == SLT_ReadOnly)
        {
            GuardWrapper.Reset();
            {
                FScopedHighPriorityWaitTracker Tracker(&Lock.HighPriorityWaitersCount, Priority);
                GuardWrapper.Emplace(Lock, SLT_Write);
            }
            LockType = SLT_Write;
        }
    }
 
    Private::FRWLockWithPriority& Lock;
    TOptional<TRWScopeLock<Private::FRWLockWithPriority>> GuardWrapper;
    Private::ELockPriority Priority;
    FRWScopeLockType LockType;
};
 
namespace Impl
{
struct FClassInheritanceBuffer
{
    TMap<FTopLevelAssetPath, FTopLevelAssetPath> InheritanceMap;
    TMap<FTopLevelAssetPath, TArray<FTopLevelAssetPath>> ReverseInheritanceMap;
    uint64 SavedAllClassesVersionNumber = MAX_uint64;
    bool bDirty = true;
 
    bool IsUpToDate(uint64 CurrentAllClassesVersionNumber) const;
    void Clear();
    SIZE_T GetAllocatedSize() const;
};
 
enum class EGatherStatus : uint8
{
    TickActiveGatherActive,
    TickActiveGatherIdle,
    TickGameThreadActiveGatherIdle,
    Complete,
    UnableToProgress,
    WaitingForEvents,
};
    
enum EPerformanceMode : uint8
{
    // Handling slow async load
    BulkLoading,
 
    // Not changing, optimize for runtime queries
    MostlyStatic,
};
 
struct FInterruptionContext
{
public:
    typedef TFunction<bool(void)> ShouldExitEarlyCallbackType;
 
    FInterruptionContext() = default;
    explicit FInterruptionContext(double InTickStartTime, double InMaxRunningTime)
        : TickStartTime(InTickStartTime)
        , MaxRunningTime(InMaxRunningTime)
    {
    }
 
    FInterruptionContext(double InTickStartTime, double InMaxRunningTime, ShouldExitEarlyCallbackType& Callback)
        : TickStartTime(InTickStartTime)
        , MaxRunningTime(InMaxRunningTime)
        , EarlyExitCallback(Callback) {}
 
    void SetEarlyExitCallback(const ShouldExitEarlyCallbackType& InCallback)
    {
        EarlyExitCallback = InCallback;
    }
    void SetUnlimitedTickTime()
    {
        TickStartTime = -1.;
        MaxRunningTime = -1.;
    }
    void SetLimitedTickTime(double InTickStartTime, double InMaxRunningTime)
    {
        TickStartTime = InTickStartTime;
        MaxRunningTime = InMaxRunningTime;
    }
    double GetTickStartTime() const { return TickStartTime; }
    bool IsTimeSlicingEnabled() const { return TickStartTime > 0; }
    bool WasInterrupted() const { return OutInterrupted; }
    bool ShouldExitEarly();
    void RequestEarlyExit() { OutInterrupted = true; }
 
private:
    // A negative value disables time slicing
    double TickStartTime = -1.;
    // The maximum time should allow before interruption. If TickStartTime is negative, this is ignored
    double MaxRunningTime = -1.;
    // If provided, this is always checked
    ShouldExitEarlyCallbackType EarlyExitCallback;
    // True if we ran out of time, EarlyExitCallback returned true, or RequestEarlyExit() was called
    bool OutInterrupted = false;
};
 
struct FParsedFilterTagRules
{
    struct FFilterTagsRule
    {
        FTopLevelAssetPath ClassPath;
        const UClass* ClassPtr = nullptr;
        int32 InheritanceDepth = 0; // used as a sorting criteria to order classes from base to leaf.
        bool bInclude = false;
    };
    TArray<FFilterTagsRule> OrderedList;
    bool bContainsAnyUnresolvedRule = false;
};
 
struct FFilterTagRules
{
    SIZE_T GetAllocatedSize() const { return Rules.GetAllocatedSize(); }
 
    TMap<FName, FParsedFilterTagRules> Rules;
    uint64 ClassesFingerprint = 0;
    bool bContainsAnyUnresolvedRule = false;
};
} // namespace Impl within namespace UE::AssetRegistry
 
enum class EDeferFlag
{
    CanExecuteGameThread,
    RetryLater,
    QueueToGameThread,
    BypassNow,
};
 
} // namespace UE::AssetRegistry
 
FORCEINLINE bool IsTickActive(UE::AssetRegistry::Impl::EGatherStatus Status) 
{ 
    return (Status == UE::AssetRegistry::Impl::EGatherStatus::TickGameThreadActiveGatherIdle) 
        || (Status == UE::AssetRegistry::Impl::EGatherStatus::TickActiveGatherActive)
        || (Status == UE::AssetRegistry::Impl::EGatherStatus::TickActiveGatherIdle);
}
 
namespace UE::AssetRegistry
{
 
class FAssetRegistryImpl
{
    using FAssetDataMap = UE::AssetRegistry::Private::FAssetDataMap;
    using FCachedAssetKey = UE::AssetRegistry::Private::FCachedAssetKey;
 
public:
    FAssetRegistryImpl();
    void Initialize(UE::AssetRegistry::FInterfaceWriteScopeLock& ScopeLock, Impl::FInitializeContext& Context);
 
    IAssetRegistry::FAssetCollisionEvent& OnAssetCollision_Private();
 
    // Helpers for functions of the same name from UAssetRegistryImpl
 
 
    bool HasAssets(const FName PackagePath, const bool bRecursive) const;
    FSoftObjectPath GetRedirectedObjectPath(FInterfaceReadScopeLock& ScopeLock, const FSoftObjectPath& ObjectPath);
    FSoftObjectPath GetAndScanRedirectedObjectPath(FInterfaceWriteScopeLock& ScopeLock, const FSoftObjectPath& ObjectPath, 
        UE::AssetRegistry::Impl::FEventContext* EventContext, UE::AssetRegistry::Impl::FClassInheritanceContext* InheritanceContext);
    bool GetAncestorClassNames(Impl::FClassInheritanceContext& InheritanceContext, FTopLevelAssetPath ClassName,
        TArray<FTopLevelAssetPath>& OutAncestorClassNames) const;
    void CompileFilter(Impl::FClassInheritanceContext& InheritanceContext, const FARFilter& InFilter,
        FARCompiledFilter& OutCompiledFilter) const;
    void SetTemporaryCachingMode(bool bEnable);
    void SetTemporaryCachingModeInvalidated();
    bool AddPath(Impl::FEventContext& EventContext, FStringView PathToAdd);
    void SearchAllAssets(Impl::FEventContext& EventContext, Impl::FClassInheritanceContext& InheritanceContext,
        bool bSynchronousSearch);
    bool GetVerseFilesByPath(FName PackagePath, TArray<FName>* OutFilePaths, bool bRecursive) const;
    void ScanPathsSynchronous(FInterfaceWriteScopeLock* ScopeLock, Impl::FScanPathContext& Context);
    void PrioritizeSearchPath(const FString& PathToPrioritize);
    void ScanModifiedAssetFiles(FInterfaceWriteScopeLock& ScopeLock, Impl::FEventContext& EventContext, Impl::FClassInheritanceContext& InheritanceContext,
        const TArray<FString>& InFilePaths, UE::AssetRegistry::EScanFlags ScanFlags);
    void Serialize(FArchive& Ar, Impl::FEventContext& EventContext);
    void AppendState(Impl::FEventContext& EventContext, const FAssetRegistryState& InState,
        FAssetRegistryState::EInitializationMode Mode = FAssetRegistryState::EInitializationMode::Append, bool bEmitAssetEvents = false);
    void GetAllocatedSize(bool bLogDetailed, SIZE_T& StateSize, SIZE_T& StaticSize, SIZE_T& SearchSize) const;
    bool IsLoadingAssets() const;
    bool IsGathering() const;
    bool HasSerializedDiscoveryCache() const;
    void SetManageReferences(FSetManageReferencesContext& Context);
    bool SetPrimaryAssetIdForObjectPath(Impl::FEventContext& EventContext, const FSoftObjectPath& ObjectPath, FPrimaryAssetId PrimaryAssetId);
    bool ResolveRedirect(const FString& InPackageName, FString& OutPackageName) const;
#if WITH_EDITOR
    void OnDirectoryChanged(FInterfaceWriteScopeLock& ScopeLock, Impl::FEventContext& EventContext, Impl::FClassInheritanceContext& InheritanceContext,
        TArray<FFileChangeData>& FileChangesProcessed);
    void OnDirectoryRescanRequired(FInterfaceWriteScopeLock& ScopeLock, Impl::FEventContext& EventContext,
        Impl::FClassInheritanceContext& InheritanceContext, FString& DirPath, int64 BeforeTimeStamp);
    void AddLoadedAssetToProcess(const UObject& AssetLoaded);
#endif
    void OnContentPathMounted(UE::AssetRegistry::FInterfaceWriteScopeLock& ScopeLock, Impl::FEventContext& EventContext, Impl::FClassInheritanceContext& InheritanceContext,
        const FString& InAssetPath, const FString& AssetPathWithTrailingSlash, const FString& FileSystemPath);
    void OnContentPathDismounted(Impl::FEventContext& EventContext, const FString& InAssetPath,
        const FString& AssetPathNoTrailingSlash, const FString& FileSystemPath);
 
 
    // Other helper functions called by UAssetRegistryImpl
 
 
    void OnPluginLoadingComplete(bool bPhaseSuccessful);
    void RefreshNativeClasses();
 
    void EnumerateDiskAssets(const FARCompiledFilter& InFilter, TSet<FName>& PackagesToSkip,
        TFunctionRef<bool(const FAssetData&)> Callback, UE::AssetRegistry::EEnumerateAssetsFlags InEnumerateFlags) const;
    void EnumerateAllDiskAssets(TSet<FName>& PackageNamesToSkip, TFunctionRef<bool(const FAssetData&)> Callback, UE::AssetRegistry::EEnumerateAssetsFlags InEnumerateFlags = UE::AssetRegistry::EEnumerateAssetsFlags::None) const;
 
    void WaitForGathererIdleIfSynchronous();
    void WaitForGathererIdle(float TimeoutSeconds);
    Impl::EGatherStatus TickGatherer(Impl::FTickContext& TickContext);
    void ProcessGameThreadRequestedClasses();
    void ConditionalRetryGatherAssetsForGameThread(Impl::FTickContext& TickContext);
    void ConditionalClearGameThreadRequestedClasses(Impl::FTickContext& TickContext);
    void RequestGameThreadProcessClass(const FTopLevelAssetPath& RequestedGameThreadClass);
    bool IsGameThreadTakeOverGatherEachTick() const;
    void SetGameThreadTakeOverGatherEachTick(bool bValue);
 
    void LogSearchDiagnostics(double StartTime);
    void TickGatherPackage(UE::AssetRegistry::FInterfaceWriteScopeLock& ScopeLock, Impl::FEventContext& EventContext, const FString& PackageName, const FString& LocalPath);
    void ClearGathererCache();
#if WITH_EDITOR
    void AssetsSaved(UE::AssetRegistry::Impl::FEventContext& EventContext, TArray<FAssetData>&& Assets);
    void GetProcessLoadedAssetsBatch(TArray<const UObject*>& OutLoadedAssets, uint32 BatchSize,
        bool bUpdateDiskCacheAfterLoad);
    void PushProcessLoadedAssetsBatch(Impl::FEventContext& EventContext,
        TArrayView<FAssetData> LoadedAssetDatas, TArrayView<const UObject*> UnprocessedFromBatch);
    bool IsLoadedAndTrackedAsset(const FSoftObjectPath& InObjectPath) const;
    void LoadCalculatedDependencies(TArray<FName>* AssetPackageNamessToCalculate, Impl::FClassInheritanceContext& InheritanceContext, 
        TSet<FName>* InPackagesNeedingDependencyCalculation, Impl::FInterruptionContext& InOutInterruptionContext);
    void PruneAndCoalescePackagesRequiringDependencyCalculation(TSet<FName>& BackgroundPackages, TSet<FName>& GameThreadPackages,
        Impl::FInterruptionContext& InOutInterruptionContext);
 
    void LoadCalculatedDependencies(FName PackageName, Impl::FClassInheritanceContext& InheritanceContext,
        bool& bOutHadActivity);
    void AddDirectoryReferencer(FName PackageName, const FString& DirectoryLocalPathOrLongPackageName);
    void SetDirectoriesWatchedByPackage(FName PackageName, TConstArrayView<FString> Directories);
 
    void OnAssetDependencyGathererRegistered() { bRegisteredDependencyGathererClassesDirty = true; }
 
    void ApplyObjectRedirectsToGatheredAssetDatas();
#endif
 
    void AddEmptyPackage(FName PackageName);
    bool RemoveEmptyPackage(FName PackageName);
    bool AddAssetPath(Impl::FEventContext& EventContext, FName PathToAdd);
    bool RemoveAssetPath(Impl::FEventContext& EventContext, FName PathToRemove, bool bEvenIfAssetsStillExist = false);
    void RemovePackageData(Impl::FEventContext& EventContext, const FName PackageName);
    void AddVerseFile(Impl::FEventContext& EventContext, FName VerseFilePathToAdd);
    void RemoveVerseFile(Impl::FEventContext& EventContext, FName VerseFilePathToRemove);
 
    void GetSubClasses(Impl::FClassInheritanceContext& InheritanceContext, const TArray<FTopLevelAssetPath>& InClassNames,
        const TSet<FTopLevelAssetPath>& ExcludedClassNames, TSet<FTopLevelAssetPath>& SubClassNames) const;
 
    bool IsInitialSearchCompleted() const { return bInitialSearchCompleted.load(std::memory_order_relaxed); }
    bool IsTempCachingEnabled() const { return bIsTempCachingEnabled; }
    bool IsTempCachingAlwaysEnabled() const { return bIsTempCachingAlwaysEnabled; }
    bool IsInitialSearchStarted() const { return bInitialSearchStarted; }
    bool IsAdditionalMountSearchInProgress() const { return bAdditionalMountSearchInProgress.load(std::memory_order_relaxed); }
    bool IsSearchAllAssets() const { return bSearchAllAssets; }
    Impl::FClassInheritanceBuffer& GetTempCachedInheritanceBuffer() { return TempCachedInheritanceBuffer; }
    uint64 GetSavedGeneratorClassesVersionNumber() const { return SavedGeneratorClassesVersionNumber; }
    uint64 GetSavedAllClassesVersionNumber() const { return SavedAllClassesVersionNumber; }
    static uint64 GetCurrentGeneratorClassesVersionNumber();
    static uint64 GetCurrentAllClassesVersionNumber();
 
    void CopySerializationOptions(FAssetRegistrySerializationOptions& OutOptions, ESerializationTarget Target) const;
    
    Impl::EPerformanceMode GetPerformanceMode() const { return PerformanceMode; }
    void SetPerformanceMode(Impl::EPerformanceMode NewMode);
    bool ShouldSortDependencies() const;
    bool ShouldSortReferencers() const;
 
    const FAssetRegistryState& GetState() const;
    const FPathTree& GetCachedPathTree() const;
    const TSet<FName>& GetCachedEmptyPackages() const;
 
    bool ShouldSkipAsset(FTopLevelAssetPath AssetClass, uint32 PackageFlags) const;
    bool ShouldSkipAsset(const UObject* InAsset) const;
 
    void CollectCodeGeneratorClasses();
 
    void ConditionalLoadPremadeAssetRegistry(UE::AssetRegistry::FInterfaceWriteScopeLock& ScopeLock, UE::AssetRegistry::Impl::FEventContext& EventContext);
 
#if WITH_EDITOR
    void RequestPauseBackgroundProcessing();
    void RequestResumeBackgroundProcessing();
    bool IsBackgroundProcessingPaused() const;
    uint32& GetBackgroundTickInterruptionsCount();
 
#endif
private:
 
    IAssetRegistry::FAssetCollisionEvent AssetCollisionEvent;
 
    template<typename TScopeLock>
    FSoftObjectPath GetRedirectedObjectPath(TScopeLock& ScopeLock, const FSoftObjectPath& ObjectPath, UE::AssetRegistry::Impl::FEventContext* EventContext,
        UE::AssetRegistry::Impl::FClassInheritanceContext* InheritanceContext);
    void EnumerateAssetsByPathNoTags(FName PackagePath,
        TFunctionRef<bool(const FAssetData&)> Callback, bool bRecursive, bool bIncludeOnlyOnDiskAssets) const;
    void InitRedirectors(Impl::FEventContext& EventContext, Impl::FClassInheritanceContext& InheritanceContext,
        bool& bOutRedirectorsNeedSubscribe);
    void ReadScriptPackages();
    /* Try to construct the gatherer if it does not already exist. If that is not possible (e.g., because we are shutting down)
     * return false. If it was successfully created or already existed, return true.
     */
    bool TryConstructGathererIfNeeded();
    void SearchAllAssetsInitialAsync(Impl::FEventContext& EventContext, Impl::FClassInheritanceContext& InheritanceContext);
    void AssetSearchDataGathered(Impl::FEventContext& EventContext,
        TMultiMap<FName, TUniquePtr<FAssetData>>& AssetResults, 
        TMultiMap<FName, TUniquePtr<FAssetData>>& OutDeferredResults,
        Impl::FInterruptionContext& InOutInterruptionContext,
        TOptional<TSet<FString>>& MountPointsForVerifyAfterGather,
        EDeferFlag DeferFlag);
    bool ShouldSkipGatheredAsset(FAssetData& AssetData);
 
    void PathDataGathered(Impl::FEventContext& EventContext, TRingBuffer<FString>& PathResults,
        Impl::FInterruptionContext& InOutInterruptionContext,
        TOptional<TSet<FString>>& MountPointsForVerifyAfterGather);
 
    void DependencyDataGathered(TMultiMap<FName, FPackageDependencyData>& DependsResults, 
        TMultiMap<FName, FPackageDependencyData>& OutDeferredDependencyResults,
        TSet<FName>* OutPackagesNeedingDependencyCalculation, Impl::FInterruptionContext& InOutInterruptionContext,
        TOptional<TSet<FString>>& MountPointsForVerifyAfterGather);
 
    void CookedPackageNamesWithoutAssetDataGathered(Impl::FEventContext& EventContext, 
        TRingBuffer<FString>& CookedPackageNamesWithoutAssetDataResults, Impl::FInterruptionContext& InOutInterruptionContext);
 
    void VerseFilesGathered(Impl::FEventContext& EventContext, TRingBuffer<FName>& VerseResults, Impl::FInterruptionContext& InOutInterruptionContext);
 
    void AddAssetData(Impl::FEventContext& EventContext, FAssetData* AssetData);
 
    void UpdateAssetData(Impl::FEventContext& EventContext, FAssetData* AssetData, FAssetData&& NewAssetData, bool bKeepDeletedTags);
 
    void AddNonOverlappingTags(Impl::FEventContext& EventContext, FAssetData& ExistingAssetData,
        const FAssetData& NewAssetData);
 
    bool RemoveAssetData(Impl::FEventContext& EventContext, FAssetData* AssetData);
 
    bool RemoveAssetDatas(Impl::FEventContext& EventContext, TArrayView<FAssetData*> AssetDatas);
 
#if WITH_EDITOR
    FAssetData* ResolveAssetIdCollision(FAssetData& A, FAssetData& B);
    bool TryPostLoadAssetRegistryTags(FAssetData* AssetData, EDeferFlag DeferFlag,
        FTopLevelAssetPath& OutRequestedGameThreadClass);
 
    void RebuildAssetDependencyGathererMapIfNeeded();
 
    void ResolveRedirectionsInCachedBPInheritanceMap();
 
#endif // WITH_EDITOR
    void GetSubClasses_Recursive(Impl::FClassInheritanceContext& InheritanceContext, FTopLevelAssetPath InClassName,
        TSet<FTopLevelAssetPath>& SubClassNames, TSet<FTopLevelAssetPath>& ProcessedClassNames, const TSet<FTopLevelAssetPath>& ExcludedClassNames) const;
 
    void CachePathsFromState(Impl::FEventContext& EventContext, const FAssetRegistryState& InState);
 
    void AddCachedBPClassParent(const FTopLevelAssetPath& ClassPath, const FTopLevelAssetPath& NotYetRedirectedParentPath);
 
    void UpdateInheritanceBuffer(Impl::FClassInheritanceBuffer& OutBuffer) const;
 
    void ConsumeOrDeferPreloadedPremade(UAssetRegistryImpl& UARI, Impl::FEventContext& EventContext);
    void LoadPremadeAssetRegistry(Impl::FEventContext& Context,
        Premade::ELoadResult LoadResult, FAssetRegistryState&& ARState);
    void UpdatePersistentMountPoints();
    void OnInitialSearchCompleted(Impl::FEventContext& EventContext);
    void OnAdditionalMountSearchCompleted(Impl::FEventContext& EventContext);
 
    friend FAssetDataGatherer;
    bool ClassRequiresGameThreadProcessing(const UClass* Class) const;
 
    friend UAssetRegistryImpl;
    TUniquePtr<FAssetDataGatherer>& AccessGlobalGatherer() { return GlobalGatherer; }
 
    void UpdateMaxSecondsPerFrame();
 
    void Shrink();
private:
 
    FAssetRegistryState State;
 
    TSet<FName> CachedVerseFiles;
    TMap<FName, TArray<FName>> CachedVerseFilesByPath;
 
    FAssetRegistrySerializationOptions SerializationOptions;
    FAssetRegistrySerializationOptions DevelopmentSerializationOptions;
 
    TSet<FName> CachedEmptyPackages;
 
    TMap<FTopLevelAssetPath, FTopLevelAssetPath> CachedBPInheritanceMap;
 
    Impl::FFilterTagRules CachedParsedFilterRules;
 
    bool bIsTempCachingEnabled;
 
    bool bIsTempCachingAlwaysEnabled;
 
    Impl::FClassInheritanceBuffer TempCachedInheritanceBuffer;
 
    uint64 SavedGeneratorClassesVersionNumber;
    uint64 SavedAllClassesVersionNumber;
 
    FPathTree CachedPathTree;
 
    TUniquePtr<FAssetDataGatherer> GlobalGatherer;
 
    UE::AssetDataGather::FResults BackgroundResults;
 
    TMultiMap<FName, TUniquePtr<FAssetData>> DeferredAssets;
    TMultiMap<FName, TUniquePtr<FAssetData>> DeferredAssetsForGameThread;
    TMultiMap<FName, FPackageDependencyData> DeferredDependencies;
    TMultiMap<FName, FPackageDependencyData> DeferredDependenciesForGameThread;
    TSet<FTopLevelAssetPath> GameThreadRequestedClasses;
    FCriticalSection GameThreadRequestedClassesLock;
    std::atomic<bool> bGameThreadRequestedClassesShouldRetry{ false };
    std::atomic<bool> bGameThreadRequestedClassesShouldProcess{ false };
 
#if !NO_LOGGING
    TMap<FTopLevelAssetPath, int64> TagSizeByClass;
#endif
 
    TSet<FName> PersistentMountPoints;
 
    float StoreGatherResultsTimeSeconds;
    int32 HighestPending = 0;
 
    double InitialSearchStartTime = 0.0f;
    double AdditionalMountSearchStartTime = 0.0f;
    bool bInitialSearchStarted = false;
    bool bInitializationComplete = false;
    std::atomic<bool> bInitialSearchCompleted;
    std::atomic<bool> bAdditionalMountSearchInProgress;
    bool bPreloadingComplete = false;
    Impl::EGatherStatus GatherStatus;
    Impl::EPerformanceMode PerformanceMode;
 
    bool bVerifyMountPointAfterGather;
 
    bool bSearchAllAssets;
 
    bool bVerboseLogging;
 
    bool bForceCompletionEvenIfClassNotLoaded = false;
    bool bForceCompletionEvenIfNotOnGameThread = false;
    bool bProcessedAnyAssetsAfterRetryDeferred = true;
    float MaxSecondsPerFrame = 0.04f;
 
    TSet<FTopLevelAssetPath> ClassGeneratorNames;
 
    struct FAssetRegistryPackageRedirect
    {
    public:
        FAssetRegistryPackageRedirect(const FString& InSourcePackageName, const FString& InDestPackageName)
            : SourcePackageName(InSourcePackageName), DestPackageName(InDestPackageName)
        {
        }
        FString SourcePackageName;
        FString DestPackageName;
    };
    TArray<FAssetRegistryPackageRedirect> PackageRedirects;
 
#if WITH_EDITOR
    TSet<FName> PackagesNeedingDependencyCalculation;
    TSet<FName> PackagesNeedingDependencyCalculationOnGameThread;
 
    TRingBuffer<TWeakObjectPtr<const UObject>> LoadedAssetsToProcess;
 
    TSet<FSoftObjectPath> AssetDataObjectPathsUpdatedOnLoad;
 
    TMap<FString, TSet<FName>> PackagesWatchingDirectory;
    TMap<FName, TArray<FString>> DirectoriesWatchedByPackage;
 
    uint32 BackgroundTickInterruptionsCount = 0;
    std::atomic<bool> bGameThreadTakeOverGatherEachTick;
 
    TMultiMap<FTopLevelAssetPath, UE::AssetDependencyGatherer::Private::FRegisteredAssetDependencyGatherer*> RegisteredDependencyGathererClasses;
    mutable FRWLock RegisteredDependencyGathererClassesLock;
    bool bRegisteredDependencyGathererClassesDirty;
 
    bool bGatherNeedsApplyObjectRedirects = false;
#endif
#if WITH_ENGINE && WITH_EDITOR
    mutable FRWLock SkipClassesLock;
    TSet<FTopLevelAssetPath> SkipUncookedClasses;
    TSet<FTopLevelAssetPath> SkipCookedClasses;
#endif
    UE::AssetRegistry::Premade::FAsyncConsumer AsyncConsumer;
    friend UE::AssetRegistry::Premade::FAsyncConsumer;
    friend UE::AssetRegistry::Impl::FClassInheritanceContext;
    friend UE::AssetRegistry::Impl::FTickContext;
 
    TUniquePtr<UE::AssetRegistry::DependsNode::FGatherDependencyDataScratchpad> GatherDependencyDataScratchPad = nullptr;
};
 
namespace Impl
{
 
struct FEventContext
{
    enum class EEvent : uint32
    {
        Added,
        Removed,
        Updated,
        UpdatedOnDisk,
        
        MAX
    };
    TOptional<IAssetRegistry::FFileLoadProgressUpdateData> ProgressUpdateData;
    TArray<TPair<FString, EEvent>> PathEvents;
    TArray<TPair<FAssetData, EEvent>> AssetEvents;
    TArray<TPair<FName, EEvent>> VerseEvents;
    TArray<FString> RequiredLoads;
    TArray<FString> BlockedFiles;
    bool bFileLoadedEventBroadcast = false;
    bool bScanStartedEventBroadcast = false;
    bool bHasSentFileLoadedEventBroadcast = false;
    bool bKnownGathersCompleteEventBroadcast = false;
 
    void Clear();
    bool IsEmpty() const;
    void Append(FEventContext&& Other);
};
 
 
/*
 * An accessor for the inheritance map and related data for functions that need them; the source
 * of this data is an internal detail unneeded by the functions reading it. Readers of the data call
 * ConditionalUpdate to ensure it is up to date before reading it.
 */
struct FClassInheritanceContext
{
    FClassInheritanceBuffer* Buffer = nullptr;
    FClassInheritanceBuffer* StackBuffer = nullptr;
    FAssetRegistryImpl* AssetRegistryImpl = nullptr;
    bool bInheritanceMapUpToDate = false;
    bool bCodeGeneratorClassesUpToDate = false;
 
    void BindToBuffer(FClassInheritanceBuffer& InBuffer, FAssetRegistryImpl& InAssetRegistryImpl,
        bool bInInheritanceMapUpToDate, bool bInCodeGeneratorClassesUpToDate);
    void ConditionalUpdate();
    void SelectBuffer(FAssetRegistryImpl& GuardedData, uint64 CurrentGeneratorClassesVersionNumber, uint64 CurrentAllClassesVersionNumber);
    void OnLockReentered(FAssetRegistryImpl& GuardedData);
};
 
struct FScanPathContext
{
    FScanPathContext(FEventContext& InEventContext, FClassInheritanceContext& InInheritanceContext,
        const TArray<FString>& InDirs, const TArray<FString>& InFiles,
        UE::AssetRegistry::EScanFlags InScanFlags = UE::AssetRegistry::EScanFlags::None,
        TArray<FSoftObjectPath>* FoundAssets = nullptr);
 
    TArray<FString> PackageDirs;
    TArray<FString> LocalDirs;
    TArray<FString> PackageFiles;
    TArray<FString> LocalFiles;
    TArray<FString> LocalPaths;
    FEventContext& EventContext;
    FClassInheritanceContext& InheritanceContext;
    TArray<FSoftObjectPath>* OutFoundAssets = nullptr;
    int32 NumFoundAssets = 0;
    bool bForceRescan = false;
    bool bIgnoreDenyListScanFilters = false;
    bool bIgnoreInvalidPathWarning = false;
    EGatherStatus Status = EGatherStatus::TickActiveGatherActive;
};
 
struct FTickContext
{
public:
    FTickContext(FAssetRegistryImpl& InGuardedData, Impl::FEventContext& InEventContext,
        Impl::FClassInheritanceContext& InInheritanceContext);
 
    void LazyStartTimer();
    void RecordTimer();
 
    int32 GetNumPending();
    int32 GetNumGatherFromDiskPending();
    void SetNumGatherFromDiskPendingDirty();
    int32 CalculateNumGatherFromDiskPending();
 
    EGatherStatus SetIntermediateStatus(EGatherStatus Status);
    EGatherStatus UpdateIntermediateStatus();
 
 
    void RunAssetSearchDataGathered(TMultiMap<FName, TUniquePtr<FAssetData>>& InAssetResults,
        TMultiMap<FName, TUniquePtr<FAssetData>>& OutDeferredAssetResults);
    void RunDependencyDataGathered(TMultiMap<FName, FPackageDependencyData>& DependenciesToProcess,
        TMultiMap<FName, FPackageDependencyData>& OutDeferredDependencies,
        TSet<FName>* OutPackagesNeedingDependencyCalculation);
 
public:
    UE::AssetDataGather::FResultContext ResultContext;
    Impl::FInterruptionContext InterruptionContext;
    FAssetRegistryImpl& GuardedData;
    Impl::FEventContext& EventContext;
    Impl::FClassInheritanceContext& InheritanceContext;
    TOptional<TSet<FString>> MountPointsForVerifyAfterGather;
    double TimingStartTime = -1.;
    int32 NumGatherFromDiskPending = 0;
    bool bHandleCompletion = false;
    bool bHandleDeferred = false;
    bool bNumGatherFromDiskPendingDirty = true;
    bool bHadAssetsToProcess = false;
    bool bIsInGameThread = false;
};
 
} // namespace Impl within namespace UE::AssetRegistry
 
namespace Utils
{
 
enum class EFilterMode : uint8
{
    Inclusive,
    Exclusive,
};
 
bool IsFilterValid(const FARCompiledFilter& Filter);
bool RunAssetThroughFilter(const FAssetData& AssetData, const FARCompiledFilter& Filter, const EFilterMode FilterMode);
bool RunAssetThroughFilter_Unchecked(const FAssetData& AssetData, const FARCompiledFilter& Filter, const bool bPassFilterValue);
void RunAssetsThroughFilter(TArray<FAssetData>& AssetDataList, const FARCompiledFilter& Filter, const EFilterMode FilterMode);
 
void InitializeSerializationOptionsFromIni(
    FAssetRegistrySerializationOptions& Options,
    Impl::FFilterTagRules* OutRules,
    const ITargetPlatform* TargetPlatform = nullptr,
    ESerializationTarget Target = ESerializationTarget::ForGame,
    bool bSuppressWarnings = false);
 
bool HasEngineModuleLoaded();
 
void UpdateSerializationOptions(
    FAssetRegistrySerializationOptions& InOutOptions,
    Impl::FFilterTagRules& InOutFilterRules,
    bool bSuppressWarnings);
 
TMap<FName, Impl::FParsedFilterTagRules> ParseFilterTags(const TArray<FString>& FilterListItems, bool bIsFilteringDevelopmentAR, bool bUseAllowListInsteadOfDenyList);
 
TMap<FTopLevelAssetPath, TSet<FName>> ResolveFilterTags(Impl::FFilterTagRules& InOutRules, bool bSuppressWarnings);
 
EAssetAvailability::Type GetAssetAvailability(const FAssetData& AssetData);
float GetAssetAvailabilityProgress(const FAssetData& AssetData, EAssetAvailabilityProgressReportingType::Type ReportType);
bool GetAssetAvailabilityProgressTypeSupported(EAssetAvailabilityProgressReportingType::Type ReportType);
void PrioritizeAssetInstall(const FAssetData& AssetData);
 
bool ReadAssetFile(FPackageReader& PackageReader, IAssetRegistry::FLoadPackageRegistryData& InOutData);
 
void InitializeMountPoints(TOptional<TSet<FString>>& InOutMountPoints);
 
bool IsPathMounted(const FString& Path, const TSet<FString>& MountPointsNoTrailingSlashes, FString& StringBuffer);
 
void EnumerateAllMemoryAssets(TSet<FName>& OutPackageNamesWithAssets, bool& bOutStopIteration, TFunctionRef<bool(FAssetData&&)> Callback);
void EnumerateMemoryAssetsHelper(const FARCompiledFilter& InFilter, TSet<FName>& OutPackageNamesWithAssets,
    bool& bOutStopIteration, TFunctionRef<bool(const UObject* Object, FAssetData&& PartialAssetData)> Callback,
    bool bSkipARFilteredAssets);
void EnumerateMemoryAssets(const FARCompiledFilter& InFilter, TSet<FName>& OutPackageNamesWithAssets,
    bool& bOutStopIteration, UE::AssetRegistry::Private::FInterfaceRWLock& InterfaceLock, const FAssetRegistryState& GuardedDataState,
    TFunctionRef<bool(FAssetData&&)> Callback, bool bSkipARFilteredAssets);
 
} // namespace Utils within namespace UE::AssetRegistry
 
// Normalization functions for paths. We require that normalized paths are case-insensitively string-identical for the same input
// path specification. e.g. all slashes must be replaced with forward-slashes. Special case: a leading \\ is left unreplaced,
// so //share will be seen as different than \\share.
FString CreateStandardFilename(const FString& InFilename);
 
} // namespace UE::AssetRegistry
 
 
// Inline implementations
 
 
namespace UE::AssetRegistry
{
 
#if WITH_EDITOR
inline uint32& FAssetRegistryImpl::GetBackgroundTickInterruptionsCount()
{
    return BackgroundTickInterruptionsCount;
}
 
inline bool FAssetRegistryImpl::IsGameThreadTakeOverGatherEachTick() const
{
    return bGameThreadTakeOverGatherEachTick.load(std::memory_order_relaxed);
}
 
inline void FAssetRegistryImpl::SetGameThreadTakeOverGatherEachTick(bool bValue)
{
    bGameThreadTakeOverGatherEachTick.store(bValue, std::memory_order_relaxed);
}
#endif
 
} // namespace UE::AssetRegistry