AssetDataGathererPrivate.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "AssetDataGatherer.h"
 
#include "AssetDataGathererDiscoveryCache.h"
#include "Containers/Set.h"
#include "Containers/StringFwd.h"
#include "Misc/Optional.h"
#include "Misc/StringBuilder.h"
#include "Templates/RefCounting.h"
#include "Templates/UniquePtr.h"
 
#include <atomic>
 
namespace UE::AssetDataGather::Private
{
 
class FMountDir;
struct FScanDirAndParentData;
 
enum class EPriority : uint8
{
    Blocking,
    High,
    Normal,
 
    Highest = Blocking,
    Lowest = Normal,
};
 
struct FSetPathProperties
{
    TOptional<bool> IsOnAllowList;
    TOptional<bool> MatchesDenyList;
    TOptional<bool> IgnoreDenyList;
    TOptional<bool> HasScanned;
 
    bool IsSet() const
    {
        return IsOnAllowList.IsSet() | HasScanned.IsSet() | MatchesDenyList.IsSet() | //-V792
            IgnoreDenyList.IsSet(); //-V792
    }
};
 
enum class EGatherableFileType : uint8
{
    Invalid,
    Directory,
    PackageFile,
    VerseFile,
    VerseModule,
};
 
bool IsVerseFile(const EGatherableFileType FileType);
 
struct FDiscoveredPathData
{
    FString LocalAbsPath;
    FString LongPackageName;
    FString RelPath;
    FDateTime PackageTimestamp;
    bool bIsReadOnly;
    EGatherableFileType Type = EGatherableFileType::Invalid;
 
    FDiscoveredPathData() = default;
    FDiscoveredPathData(FStringView InLocalAbsPath, FStringView InLongPackageName, FStringView InRelPath,
        const FDateTime& InPackageTimestamp, bool InIsReadonly, EGatherableFileType InType);
    FDiscoveredPathData(FStringView InLocalAbsPath, FStringView InLongPackageName, FStringView InRelPath,
        EGatherableFileType InType);
    void Assign(FStringView InLocalAbsPath, FStringView InLongPackageName, FStringView InRelPath,
        const FDateTime& InPackageTimestamp, bool InIsReadOnly, EGatherableFileType InType);
    void Assign(FStringView InLocalAbsPath, FStringView InLongPackageName, FStringView InRelPath,
        EGatherableFileType InType);
 
    SIZE_T GetAllocatedSize() const;
};
 
struct FGatheredPathData
{
    FString LocalAbsPath;
    FString LongPackageName;
    FDateTime PackageTimestamp;
    bool bIsReadOnly;
    EGatherableFileType Type = EGatherableFileType::Invalid;
 
    FGatheredPathData() = default;
    FGatheredPathData(FStringView InLocalAbsPath, FStringView InLongPackageName, const FDateTime& InPackageTimestamp,
        bool InIsReadOnly, EGatherableFileType InType);
    explicit FGatheredPathData(const FDiscoveredPathData& DiscoveredData);
    explicit FGatheredPathData(FDiscoveredPathData&& DiscoveredData);
    void Assign(FStringView InLocalAbsPath, FStringView InLongPackageName, const FDateTime& InPackageTimestamp,
        bool InIsReadOnly, EGatherableFileType InType);
    void Assign(const FDiscoveredPathData& DiscoveredData);
 
    SIZE_T GetAllocatedSize() const;
};
 
struct FDirectoryReadTaskData
{
    FDirectoryReadTaskData()
        : UnblockRead(TEXT("UnblockingDirectoryReadTaskEvent"))
        , LastScheduledReadTask()
    {
    }
 
    ~FDirectoryReadTaskData()
    {
        // We can verify that we properly signaled our task, but we cannot verify that the ReadTask is complete,
        // because it is possible that we insert the last outstanding read from the task and then process and remove
        // our DirectoryReadTaskData before the task can complete. However we can verify there is no outstanding work.
        check(UnblockRead.IsCompleted());
        check(OutstandingReads == 0);
    }
 
    UE::Tasks::FTaskEvent UnblockRead;
    UE::Tasks::FTask LastScheduledReadTask;
    int32 OutstandingReads = 0;
    bool bHasCanceledRead = false;
};
 
struct FReadContext
{
    FName PackageName;
    FName Extension;
    FGatheredPathData AssetFileData;
    TArray<FAssetData*> AssetDataFromFile;
    FPackageDependencyData DependencyData;
    TArray<FString> CookedPackageNamesWithoutAssetData;
    TSharedPtr<FDirectoryReadTaskData> DirectoryReadTaskData;
    UE::AssetRegistry::Private::EOptionalBool HasMarkOfTheWeb = UE::AssetRegistry::Private::EOptionalBool::Unset;
    bool bCanAttemptAssetRetry = false;
    bool bResult = false;
    bool bCanceled = false;
 
    FReadContext(FName InPackageName, FName InExtension, FGatheredPathData&& InAssetFileData,
        TSharedPtr<FDirectoryReadTaskData> InDirectoryReadTaskData)
        : PackageName(InPackageName)
        , Extension(InExtension)
        , AssetFileData(MoveTemp(InAssetFileData))
        , DirectoryReadTaskData(MoveTemp(InDirectoryReadTaskData))
    {
        check(!AssetFileData.LocalAbsPath.IsEmpty());
        check(DirectoryReadTaskData.IsValid());
        check(DirectoryReadTaskData->OutstandingReads >= 0);
        DirectoryReadTaskData->OutstandingReads++;
    }
 
    ~FReadContext()
    {
        check(DirectoryReadTaskData.IsValid());
        check(DirectoryReadTaskData->OutstandingReads > 0);
        DirectoryReadTaskData->OutstandingReads--;
    }
};
 
class FFileReadScheduler
{
public:
    FFileReadScheduler(int32 InNumReadThreads, bool InGatherAssetPackageData, bool InGatherDependsData);
    ~FFileReadScheduler();
 
    bool IsAssetPackageDataGatherEnabled() const;
    bool IsDependsDataGatherEnabled() const;
    void AddFile(const FName PackageName, FGatheredPathData&& AssetData);
    void WaitOnDirectoriesAndUpdateWaitList(FWaitBatchDirectorySet& WaitBatchDirectories);
    void Schedule(const TArray<FString>& PriorityDirectories);
    void CollectCompletedReads(TArray<TUniquePtr<FReadContext>>& OutReadyContexts);
    void RemoveScheduledDirectory(const FString& Directory);
    void ProcessReadContexts(TArray<TUniquePtr<UE::AssetDataGather::Private::FReadContext>>&& ReadContexts, bool bIsTimeSliced);
    void FreeReadTaskLoaders();
    void Shrink();
private:
    void ScheduleDirectory(UE::Tasks::FTaskConcurrencyLimiter& TaskLimiter, const FString& DirectoryPath, 
        TArray<TUniquePtr<FReadContext>>&& ReadContexts, bool bUnblockImmediately);
 
    TMap<FString, TArray<TUniquePtr<FReadContext>>> DirectoryReadsToSchedule;
    TMpscQueue<TUniquePtr<UE::AssetDataGather::Private::FReadContext>> ReadyReadContexts;
    TLockFreePointerListFIFO<FNonBufferingReadOnlyArchive, 0> ReadTaskLoaderFreeList;
    UE::Tasks::FTaskConcurrencyLimiter ReadConcurrencyLimiter;
    TUniquePtr<TDirectoryTree<TSharedPtr<UE::AssetDataGather::Private::FDirectoryReadTaskData>>> ScheduledDirectories;
    int32 NumReadTaskThreads;
    bool bGatherAssetPackageData;
    bool bGatherDependsData;
};
 
class FFilesToSearch
{
public:
    void AddPriorityFile(FGatheredPathData&& FilePath);
    void AddFiles(TArray<FGatheredPathData>&& FilePaths);
    void AddFileAgainAfterTimeout(FGatheredPathData&& FilePath);
    void AddFileForLaterRetry(FGatheredPathData&& FilePath);
    void RetryLaterRetryFiles();
 
    template <typename AllocatorType>
    void PopFront(TArray<FGatheredPathData, AllocatorType>& Out, int32 NumToPop);
 
    void PrioritizePath(FPathExistence& QueryPath, EPriority Priority);
 
    void PopPriorityDirectories(TArray<FString>& OutPriorityDirectories);
 
    int32 NumBlockingFiles() const;
 
    void Shrink();
    int32 Num() const;
    int32 GetNumAvailable() const;
    SIZE_T GetAllocatedSize() const;
private:
    TRingBuffer<FString> PriorityDirectories;
    TRingBuffer<UE::AssetDataGather::Private::FGatheredPathData> NormalPriorityFiles;
    TRingBuffer<UE::AssetDataGather::Private::FGatheredPathData> BlockingFiles;
    TRingBuffer<UE::AssetDataGather::Private::FGatheredPathData> LaterRetryFiles;
    int32 AvailableFilesNum = 0;
};
 
 
struct FPathExistence
{
    enum EType
    {
        Directory,
        File,
        MissingButDirExists,
        MissingParentDir,
    };
 
    explicit FPathExistence(FStringView InLocalAbsPath);
    const FString& GetLocalAbsPath() const;
    EType GetType();
    FDateTime GetModificationTime();
    bool IsReadOnly();
 
    FStringView GetLowestExistingPath();
 
    void LoadExistenceData();
    bool HasExistenceData() const;
    void SetConfirmedExists(bool bValue);
 
private:
    FString LocalAbsPath;
    FDateTime ModificationTime;
    EType PathType = EType::MissingParentDir;
    bool bIsReadOnly = false;
    bool bHasExistenceData = false;
};
 
class FScanDir : public FRefCountBase
{
public:
    struct FInherited
    {
        FInherited() = default;
 
        bool bIsOnAllowList = false;
        bool bMatchesDenyList = false;
        bool bIgnoreDenyList = false;
 
        bool IsMonitored() const;
        bool IsOnDenyList() const;
        bool IsOnAllowList() const;
        bool HasSetting() const;
        FInherited(const FInherited& Parent, const FInherited& Child);
    };
 
    FScanDir(FMountDir& InMountDir, FScanDir* InParent, FStringView RelPath);
    ~FScanDir();
 
    void Shutdown();
 
    bool IsValid() const;
 
    FMountDir* GetMountDir() const;
 
    FStringView GetRelPath() const;
 
    void AppendLocalAbsPath(FStringBuilderBase& OutFullPath) const;
    FString GetLocalAbsPath() const;
    void AppendMountRelPath(FStringBuilderBase& OutRelPath) const;
    FString GetMountRelPath() const;
 
    void GetMonitorData(FStringView InRelPath, const FInherited& ParentData, FInherited& OutData) const;
    bool IsMonitored(const FInherited& ParentData) const;
 
    bool ShouldScan(const FInherited& ParentData) const;
    bool HasScanned() const;
    bool IsComplete() const;
 
    SIZE_T GetAllocatedSize() const;
    FScanDir* GetControllingDir(FStringView InRelPath, bool bIsDirectory, const FInherited& ParentData,
        FInherited& OutData, FString& OutRelPath);
 
    void TrySetDirectoryProperties(FPathExistence& QueryPath, FStringView InRelPath, FInherited& ParentData,
        const FSetPathProperties& InProperties, FScanDirAndParentData& OutControllingDir,
        FStringView& OutControllingDirRelPath, bool& bInOutMadeChanges);
    void MarkFileAlreadyScanned(FStringView BaseName);
 
    void SetScanResults(FStringView LocalAbsPath, const FInherited& ParentData,
        TArrayView<FDiscoveredPathData>& InOutSubDirs, TArrayView<FDiscoveredPathData>& InOutFiles);
    void Update(TArray<FScanDirAndParentData>& OutScanRequests, const FScanDir::FInherited& ParentData);
 
    FScanDir* GetFirstIncompleteScanDir();
 
    bool IsScanInFlight() const;
    void SetScanInFlight(bool bInScanInFlight);
    bool IsScanInFlightInvalidated() const;
    void SetScanInFlightInvalidated(bool bInValidated);
 
    void MarkDirty(bool bMarkDescendents);
 
    void Shrink();
 
protected:
 
    void SetComplete(bool bInIsComplete);
    bool HasPersistentSettings() const;
 
    FScanDir* FindSubDir(FStringView SubDirBaseName);
    const FScanDir* FindSubDir(FStringView SubDirBaseName) const;
    FScanDir& FindOrAddSubDir(FStringView SubDirBaseName);
    void RemoveSubDir(FStringView SubDirBaseName);
 
    int32 FindLowerBoundSubDir(FStringView SubDirBaseName);
 
    template <typename CallbackType> void ForEachSubDir(const CallbackType& Callback);
    template <typename CallbackType> void ForEachDescendent(const CallbackType& Callback);
 
    TArray<TRefCountPtr<FScanDir>> SubDirs; // Sorted
    TArray<FString> AlreadyScannedFiles; // Unsorted
    FMountDir* MountDir = nullptr;
    FScanDir* Parent = nullptr;
    FString RelPath;
    FInherited DirectData;
    bool bHasScanned = false;
    bool bScanInFlight = false;
    bool bScanInFlightInvalidated = false;
    bool bIsComplete = false;
};
 
struct FScanDirAndParentData
{
    TRefCountPtr<FScanDir> ScanDir;
    FScanDir::FInherited ParentData;
};
 
class FMountDir
{
public:
    FMountDir(FAssetDataDiscovery& InDiscovery, FStringView LocalAbsPath, FStringView PackagePath);
    ~FMountDir();
 
    FStringView GetLocalAbsPath() const;
    FStringView GetLongPackageName() const;
 
    FAssetDataDiscovery& GetDiscovery() const;
 
    FScanDir* GetControllingDir(FStringView LocalAbsPath, bool bIsDirectory, FScanDir::FInherited& OutParentData,
        FString& OutRelPath);
    SIZE_T GetAllocatedSize() const;
 
    bool IsComplete() const;
 
    void GetMonitorData(FStringView InLocalAbsPath, FScanDir::FInherited& OutData) const;
    bool IsMonitored(FStringView InLocalAbsPath) const;
 
    /*
     * Set values of fields on the given directory for all of the properties existing on InProperties.
     */
    void TrySetDirectoryProperties(FPathExistence& QueryPath, const FSetPathProperties& InProperties,
        FScanDirAndParentData* OutControllingDir = nullptr,
        FStringView* OutControllingDirRelPath = nullptr,
        bool* bOutMadeChanges = nullptr);
    void Update(TArray<FScanDirAndParentData>& OutScanRequests);
 
    FScanDir* GetFirstIncompleteScanDir();
 
    void SetHasStartedScanning();
    void Shrink();
 
    void AddChildMount(FMountDir* ChildMount);
    void RemoveChildMount(FMountDir* ChildMount);
    void OnDestroyClearChildMounts();
    void SetParentMount(FMountDir* ParentMount);
    FMountDir* GetParentMount() const;
    TArray<FMountDir*> GetChildMounts() const;
 
protected:
    void UpdateDenyList();
    void MarkDirty(FStringView MountRelPath);
 
    void AddChildMountPath(FStringView MountRelPath);
    bool RemoveChildMountPath(FStringView MountRelPath);
    bool IsChildMountPath(FStringView MountRelPath) const;
 
    TArray<FString> ChildMountPaths;
    TSet<FString> RelPathsDenyList;
    FString LocalAbsPath;
    FString LongPackageName;
    TRefCountPtr<FScanDir> Root;
    FAssetDataDiscovery& Discovery;
    FMountDir* ParentMount = nullptr;
    bool bHasStartedScanning = false;
};
 
class FAssetDataDiscovery : public FRunnable
{
public:
    FAssetDataDiscovery();
    virtual ~FAssetDataDiscovery();
 
 
    // Controlling Async behavior
 
    void StartAsync();
 
    // FRunnable implementation
    virtual bool Init() override;
    virtual uint32 Run() override;
    virtual void Stop() override;
    virtual void Exit() override;
 
    void EnsureCompletion();
 
    bool IsSynchronous() const;
 
    // Receiving Results and reading properties (possibly while tick is running)
    void GetAndTrimSearchResults(bool& bOutIsComplete, TArray<FString>& OutDiscoveredPaths,
        FFilesToSearch& OutFilesToSearch, int32& OutNumPathsToSearch);
    void GetDiagnostics(float& OutCumulativeDiscoveryTime, int32& OutNumCachedDirectories,
        int32& OutNumUncachedDirectories);
    void WaitForIdle(double EndTimeSeconds);
    bool IsIdle() const;
    void OnInitialSearchCompleted();
    void OnAdditionalMountSearchCompleted();
 
    void SetPropertiesAndWait(TArrayView<FPathExistence> QueryPaths, bool bAddToAllowList, bool bForceRescan,
        bool bIgnoreDenyListScanFilters);
    bool IsOnAllowList(FStringView LocalAbsPath) const;
    bool IsOnDenyList(FStringView LocalAbsPath) const;
    bool IsMonitored(FStringView LocalAbsPath) const;
    bool IsCacheWriteEnabled() const;
    SIZE_T GetAllocatedSize() const;
 
    // Events and setting of properties (possibly while tick is running)
    void AddMountPoint(const FString& LocalAbsPath, FStringView LongPackageName, bool& bOutAlreadyExisted);
    void RemoveMountPoint(const FString& LocalAbsPath);
    void PrioritizeSearchPath(const FString& LocalAbsPath, EPriority Priority);
    void TrySetDirectoryProperties(const FString& LocalAbsPath, const FSetPathProperties& Properties,
        bool bConfirmedExists);
    void OnDirectoryCreated(FStringView LocalAbsPath);
    void OnFilesCreated(TConstArrayView<FString> LocalAbsPaths);
 
private:
    FMountDir* FindContainingMountPoint(FStringView LocalAbsPath);
    const FMountDir* FindContainingMountPoint(FStringView LocalAbsPath) const;
    FMountDir* FindMountPoint(FStringView LocalAbsPath);
    FMountDir& FindOrAddMountPoint(FStringView LocalAbsPath, FStringView LongPackageName);
    int32 FindLowerBoundMountPoint(FStringView LocalAbsPath) const;
 
    void TickInternal(bool bTickAll);
    void UpdateAll(TArray<FScanDirAndParentData>& OutScanRequests);
    void SetIsIdle(bool bInIdle);
    void SetIsIdle(bool bInIdle, double& TickStartTime);
 
    void AddDiscovered(FStringView DirAbsPath, FStringView DirPackagePath, TConstArrayView<FDiscoveredPathData> SubDirs,
        TConstArrayView<FDiscoveredPathData> Files);
    void AddDiscoveredFile(FDiscoveredPathData&& File);
 
    static EGatherableFileType GetFileType(FStringView FilePath);
 
    void OnFileCreated(const FString& LocalPaths);
    void TrySetDirectoryPropertiesInternal(FPathExistence& QueryPath, const FSetPathProperties& Properties);
 
    void AddMountPointInternal(const FString& LocalAbsPath, FStringView LongPackageName, bool& bOutAlreadyExisted);
    void RemoveMountPointInternal(const FString& LocalAbsPath);
 
    void Shrink();
 
    struct FScopedPause
    {
        FScopedPause(const FAssetDataDiscovery& InOwner);
        ~FScopedPause();
        const FAssetDataDiscovery& Owner;
    };
 
private:
    mutable FGathererCriticalSection TreeLock;
    mutable FThreadOwnerSection TickOwner;
    mutable FGathererCriticalSection ResultsLock;
 
 
    // Variable section for variables that are constant during threading.
 
    TArray<FString> LongPackageNamesDenyList;
    TArray<FString> MountRelativePathsDenyList;
    FRunnableThread* Thread;
    bool bAsyncEnabled;
 
 
    // Variable section for variables that are atomics read/writable from outside critical sections.
 
    std::atomic<bool> bIsIdle;
    std::atomic<bool> bPriorityDirty;
    std::atomic<uint32> IsStopped;
    mutable std::atomic<uint32> IsPaused;
    FThreadSafeCounter NumDirectoriesToScan;
    FEventRef PriorityDataUpdated{ EEventMode::ManualReset };
 
    // Variable section for variables that are read/writable only within ResultsLock.
 
    TArray<FString> DiscoveredDirectories;
 
    struct FDirectoryResult
    {
        FDirectoryResult(FStringView InDirAbsPath, TConstArrayView<FDiscoveredPathData> InFiles);
        FString DirAbsPath;
        TArray<FGatheredPathData> Files;
        SIZE_T GetAllocatedSize() const;
    };
    TArray<FDirectoryResult> DiscoveredFiles;
    TArray<FGatheredPathData> DiscoveredSingleFiles;
    double CurrentDiscoveryTime = 0.;
    int32 NumDiscoveredFiles = 0;
    int32 CumulativeDiscoveredFiles = 0;
    float CumulativeDiscoveryTime = 0.f;
    int32 NumCachedDirectories = 0;
    int32 NumUncachedDirectories = 0;
 
    // Variable section for variables that are read/writable only within TreeLock.
 
    TArray<TUniquePtr<FMountDir>> MountDirs;
 
    struct FPriorityScanDirData
    {
        TRefCountPtr<FScanDir> ScanDir;
        FScanDir::FInherited ParentData;
        int32 RequestCount = 0;
        bool bReleaseWhenComplete = false;
    };
    TArray<FPriorityScanDirData> PriorityScanDirs;
 
    // Variable section for variables that are read/writable only by the TickOwner thread
 
    struct FDirToScanData
    {
        TRefCountPtr<FScanDir> ScanDir;
        FScanDir::FInherited ParentData;
        // This type is used in a TArray, and TArray assumes elements can be memmoved. 
        // TStringBuilder<N> cannot be memmoved, so use FStringBuilderBase without a buffer.
        FStringBuilderBase DirLocalAbsPath;
        FStringBuilderBase DirLongPackageName;
        TArray<FDiscoveredPathData> IteratedSubDirs;
        TArray<FDiscoveredPathData> IteratedFiles;
        int32 NumIteratedDirs = 0;
        int32 NumIteratedFiles = 0;
        bool bScanned = false;
 
        void Reset();
        SIZE_T GetAllocatedSize() const;
    };
    TArray<FDirToScanData> DirToScanDatas;
 
    struct FDirToScanBuffer
    {
        bool bAbort = false;
 
        void Reset();
    };
    TArray<FDirToScanBuffer> DirToScanBuffers;
 
    FAssetDataDiscoveryCache Cache;
 
    friend class FMountDir;
    friend class FScanDir;
};
 
enum class EEditorGameScanMode : uint8
{
    Sync,
    Async,
    None
};
 
struct FGatherSettings
{
public:
    static constexpr int32 ExpectedMaxBatchSize = 100;
    static constexpr int32 MinSecondsToElapseBeforeCacheWrite = 300;
    static constexpr int32 MinAssetReadsBeforeCacheWrite = 100000;
    static constexpr int32 CacheShardAssetCount = 250000;
    static constexpr uint32 CacheSerializationMagic = 0x29FE48B0; // Versioning and integrity checking
    static constexpr uint64 CurrentVersion = FAssetRegistryVersion::LatestVersion | (uint64(CacheSerializationMagic) << 32);
    static inline const FTimespan CachePruneAge = FTimespan(7, 0, 0, 0);
 
    static constexpr float PollDiscoveryPeriodSeconds = .005f;
 
    static inline int32 GARDiscoverThreads = 15;
    static inline int32 GARDiscoverMinBatchSize = 1;
    static inline int32 GARGatherThreads = 0;
 
    static inline int32 GARGatherCacheParallelism = 16;
 
    void Initialize();
    bool IsAsyncEnabled() const;
    bool IsGatherCacheReadEnabled() const;
    bool IsGatherCacheWriteEnabled() const;
    bool IsDiscoveryCacheReadEnabled() const;
    EFeatureEnabled IsDiscoveryCacheWriteEnabled() const;
    bool IsDiscoveryCacheInvalidateEnabled() const;
    bool IsPreloadGatherCache() const;
    bool IsPreloadDiscoveryCache() const;
    bool IsGatherDependsData() const;
    bool IsForceDependsGathering() const;
    EEditorGameScanMode GetEditorGameScanMode() const;
    FString GetLegacyCacheFilename() const;
    FString GetLegacyNonMonolithicCacheDirectory() const;
    const FString& GetCacheBaseFilename() const;
    const FString& GetAssetRegistryCacheRootFolder() const;
    TArray<FString> FindShardedCacheFiles() const;
 
private:
    FString CacheBaseFilename;
    FString AssetRegistryCacheRootFolder;
    bool bForceDependsGathering = false;
    bool bGatherDependsData = false;
    bool bGatherCacheReadEnabled = false;
    bool bGatherCacheWriteEnabled = false;
    bool bDiscoveryCacheReadEnabled = false;
    EFeatureEnabled DiscoveryCacheWriteEnabled = EFeatureEnabled::Never;
    bool bDiscoveryCacheInvalidateEnabled = false;
    bool bPreloadGatherCache = false;
    bool bAsyncEnabled = false;
    bool bInitialized = false;
    EEditorGameScanMode EditorGameScanMode = EEditorGameScanMode::None;
};
extern FGatherSettings GGatherSettings;
 
bool DoesPathContainInvalidCharacters(const EGatherableFileType FileType, FStringView FilePath);
 
// Inline implementations
 
inline bool FGatherSettings::IsAsyncEnabled() const
{
    return bAsyncEnabled;
}
 
inline bool FGatherSettings::IsGatherCacheReadEnabled() const
{
    return bGatherCacheReadEnabled;
}
 
inline bool FGatherSettings::IsGatherCacheWriteEnabled() const
{
    return bGatherCacheWriteEnabled;
}
 
inline bool FGatherSettings::IsDiscoveryCacheReadEnabled() const
{
    return bDiscoveryCacheReadEnabled;
}
 
inline EFeatureEnabled FGatherSettings::IsDiscoveryCacheWriteEnabled() const
{
    return DiscoveryCacheWriteEnabled;
}
 
inline bool FGatherSettings::IsDiscoveryCacheInvalidateEnabled() const
{
    return bDiscoveryCacheInvalidateEnabled;
}
 
inline bool FGatherSettings::IsPreloadGatherCache() const
{
    return bGatherCacheReadEnabled && bPreloadGatherCache;
}
 
inline bool FGatherSettings::IsPreloadDiscoveryCache() const
{
    return IsDiscoveryCacheReadEnabled() && bPreloadGatherCache;
}
 
inline bool FGatherSettings::IsGatherDependsData() const
{
    return bGatherDependsData;
}
 
inline bool FGatherSettings::IsForceDependsGathering() const
{
    return bForceDependsGathering;
}
 
inline EEditorGameScanMode FGatherSettings::GetEditorGameScanMode() const
{
    return EditorGameScanMode;
}
 
inline FString FGatherSettings::GetLegacyCacheFilename() const
{
    return CacheBaseFilename + TEXT(".bin");
}
 
inline FString FGatherSettings::GetLegacyNonMonolithicCacheDirectory() const
{
    return GetAssetRegistryCacheRootFolder() / TEXT("AssetRegistryCache");
}
 
inline const FString& FGatherSettings::GetCacheBaseFilename() const
{
    return CacheBaseFilename;
}
 
inline const FString& FGatherSettings::GetAssetRegistryCacheRootFolder() const
{
    return AssetRegistryCacheRootFolder;
}
inline bool FFileReadScheduler::IsAssetPackageDataGatherEnabled() const
{
    return bGatherAssetPackageData;
}
inline bool FFileReadScheduler::IsDependsDataGatherEnabled() const
{
    return bGatherDependsData;
}
} // namespace UE::AssetDataGather::Private