AssetDataGathererDiscoveryCache.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/Map.h"
#include "Containers/MpscQueue.h"
#include "Containers/SortedMap.h"
#include "Containers/StringView.h"
#include "Containers/UnrealString.h"
#include "HAL/PlatformFile.h"
#include "Misc/DateTime.h"
 
class FArchive;
 
namespace UE::AssetDataGather::Private
{
 
enum class EFeatureEnabled : uint8
{
    Never,
    IfPlatformSupported,
    Always
};
 
enum class EFeatureEnabledReadWrite : uint32
{
    NeverRead       = 0x00,
    DefaultRead     = 0x01,
    AlwaysRead      = 0x02,
    ReadMask        = 0x0f,
    NeverWrite      = 0x00,
    DefaultWrite    = 0x10,
    AlwaysWrite     = 0x20,
    WriteMask       = 0xf0,
    Invalid         = 0xffffffff,
    NeverWriteNeverRead     = NeverWrite   | NeverRead,   // aka Never
    NeverWriteDefaultRead   = NeverWrite   | DefaultRead,
    NeverWriteAlwaysRead    = NeverWrite   | AlwaysRead,
    DefaultWriteNeverRead   = DefaultWrite | NeverRead,   
    DefaultWriteDefaultRead = DefaultWrite | DefaultRead, // aka Default
    DefaultWriteAlwaysRead  = DefaultWrite | AlwaysRead,
    AlwaysWriteNeverRead    = AlwaysWrite  | NeverRead,
    AlwaysWriteDefaultRead  = AlwaysWrite  | DefaultRead, // aka AlwaysWrite
    // NOT given the nickname "Always", because skipping invalidation is not what users would expect from "Always"
    AlwaysWriteAlwaysRead   = AlwaysWrite  | AlwaysRead,
};
ENUM_CLASS_FLAGS(EFeatureEnabledReadWrite);
void LexFromString(EFeatureEnabledReadWrite& OutValue, FStringView Text);
 
struct FCachedDirScanFile
{
    FString RelPath;
    FDateTime ModificationTime;
    bool bIsReadOnly = false;
};
FArchive& operator<<(FArchive& Ar, FCachedDirScanFile& Data);
 
struct FCachedDirScanDir
{
    TArray<FString> SubDirRelPaths;
    TArray<FCachedDirScanFile> Files;
    FFileJournalFileHandle JournalHandle = FileJournalFileHandleInvalid;
    bool bCacheValid = false;
 
    TOptional<bool> bIsReparsePoint;
 
    TOptional<bool> bIsInsideReparsePoint;
};
FArchive& operator<<(FArchive& Ar, FCachedDirScanDir& Data);
 
struct FDiscoveredSubDirData
{
    FString DirNameAbsPath;
    FFileJournalFileHandle JournalHandle;
    TOptional<bool> bIsReparsePoint;
};
 
class FCachedVolumeInfo
{
public:
    void ConditionalConstruct(const FString& InVolumeName);
    void PreSave();
    void InitializePlatformData();
    
    FCachedDirScanDir& FindOrAddDir(FStringView InPath);
    FCachedDirScanDir& FindOrAddDir(FStringView InPath, bool& bOutAdded);
    void RemoveDirs(TArray<FString>&& InPaths);
 
    FCachedDirScanDir* FindDir(FStringView Path);
 
public:
    TMap<FString, FCachedDirScanDir> Dirs;
    FString VolumeName;
    FFileJournalId JournalId = FileJournalIdInvalid;
    FFileJournalEntryHandle NextJournalEntryToScan = FileJournalEntryHandleInvalid;
 
    // Transient
    TArray<FString> DirsToRemove;
    FString LastError;
    FFileJournalId JournalIdOnDisk = FileJournalIdInvalid;
    FFileJournalEntryHandle NextJournalEntryOnDisk = FileJournalEntryHandleInvalid;
    uint64 JournalMaximumSize = 0;
    bool bJournalAvailable = false;
};
FArchive& operator<<(FArchive& Ar, FCachedVolumeInfo& Data);
 
class FAssetDataDiscoveryCache
{
public:
    FString GetCacheFileName() const;
 
    bool IsInitialized() const { return bInitialized; }
    EFeatureEnabled IsWriteEnabled() const { return WriteEnabled; }
    void Shutdown();
 
    void LoadAndUpdateCache();
    void SaveCache();
 
    FCachedVolumeInfo& FindOrAddVolume(FStringView PathOrVolumeName);
    FCachedDirScanDir& FindOrAddDir(FStringView Path, FCachedVolumeInfo** OutVolume = nullptr);
    void RemoveDir(FStringView Path);
 
    FCachedVolumeInfo* FindVolume(FStringView PathOrVolumeName);
    FCachedDirScanDir* FindDir(FStringView Path, FCachedVolumeInfo** OutVolume = nullptr);
 
    void QueueConsume();
    void QueueAdd(FString DirName, FCachedDirScanDir DirData);
    void QueueAdd(FString DirName, FFileJournalFileHandle JournalHandle, bool bIsReparsePoint);
 
private:
    bool TryReadCacheFile();
    void SerializeReadCacheFile(FArchive& Ar, bool& bOutCacheVersionMismatch);
    void SerializeWriteCacheFile(FArchive& Ar);
 
    bool FindOrAddIsReparsePoint(FStringView DirName, FCachedVolumeInfo& CachedVolume);
 
private:
    TSortedMap<FString, FCachedVolumeInfo> CachedVolumes;
    TMpscQueue<TPair<FString, FCachedDirScanDir>> ScanQueueDirFullDatas;
    TMpscQueue<FDiscoveredSubDirData> ScanQueueDirHandles;
 
    bool bInitialized = false;
    EFeatureEnabled WriteEnabled = EFeatureEnabled::Never;
};
 
constexpr const TCHAR* GEmptyVolumeName = TEXT("<EmptyVolume>");
 
} // UE::AssetDataGather::Private