PackageWriter.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Async/Future.h"
#include "Containers/Set.h"
#include "Containers/StringView.h"
#include "IO/IoDispatcher.h"
#include "IO/IoHash.h"
#include "Memory/CompositeBuffer.h"
#include "Misc/AssertionMacros.h"
#include "Misc/DateTime.h"
#include "Misc/EnumClassFlags.h"
#include "Misc/Optional.h"
#include "Misc/SecureHash.h"
#include "Serialization/CompactBinary.h"
#include "Templates/RefCounting.h"
#include "Templates/UniquePtr.h"
 
class FAssetRegistryState;
class FCbObject;
class FCbObjectView;
class FLargeMemoryWriter;
class ICookedPackageWriter;
class IPackageStoreWriter;
class UObject;
namespace UE::Cook { class IDeterminismHelper; }
struct FPackageStoreEntryResource;
struct FSavePackageArgs;
struct FSavePackageResultStruct;
 
enum class EPackageWriterResult : uint8
{
    Success,
    Error,
    Timeout,
};
 
class IPackageWriter
{
public:
    virtual ~IPackageWriter() = default;
 
    struct FCapabilities
    {
        bool bDeclareRegionForEachAdditionalFile = false;
 
        bool bIgnoreHeaderDiffs = false;
 
        bool bDeterminismDebug = false;
    };
 
    virtual FCapabilities GetCapabilities() const
    {
        return FCapabilities();
    }
 
    // Events the PackageWriter receives
    struct FBeginPackageInfo
    {
        FName   PackageName;
        FString LooseFilePath;
    };
 
    virtual void BeginPackage(const FBeginPackageInfo& Info) = 0;
 
    struct FCommitAttachmentInfo
    {
        FUtf8StringView Key;
        FCbObject Value;
    };
    enum class EWriteOptions
    {
        None = 0,
        WritePackage = 0x01,
        WriteSidecars = 0x02,
        Write = WritePackage | WriteSidecars,
        ComputeHash = 0x04,
        SaveForDiff = 0x08,
    };
    enum class ECommitStatus
    {
        Success,
        Canceled,
        NothingToCook,
        Error,
        NotCommitted,
    };
    struct FCommitPackageInfo
    {
        FName PackageName;
        FIoHash PackageHash;
        UE_DEPRECATED(5.4, "Use PackageHash instead")
        FGuid PackageGuid;
        TArray<FCommitAttachmentInfo> Attachments;
        ECommitStatus Status;
        EWriteOptions WriteOptions;
 
        PRAGMA_DISABLE_DEPRECATION_WARNINGS;
        inline FCommitPackageInfo() = default;
        inline FCommitPackageInfo(const FCommitPackageInfo&) = default;
        inline FCommitPackageInfo(FCommitPackageInfo&&) = default;
        inline FCommitPackageInfo& operator=(FCommitPackageInfo&) = default;
        inline FCommitPackageInfo& operator=(FCommitPackageInfo&&) = default;
        PRAGMA_ENABLE_DEPRECATION_WARNINGS;
    };
 
    virtual void CommitPackage(FCommitPackageInfo&& Info) = 0;
 
    struct FPackageInfo
    {
        FName       PackageName;
        FString     LooseFilePath;
        uint64      HeaderSize = 0;
        FIoChunkId  ChunkId = FIoChunkId::InvalidChunkId;
        uint16      MultiOutputIndex = 0;
    };
 
    virtual void WritePackageData(const FPackageInfo& Info, FLargeMemoryWriter& ExportsArchive, const TArray<FFileRegion>& FileRegions) = 0;
 
    struct FBulkDataInfo
    {
        enum EType
        {
            AppendToExports,
            BulkSegment,
            Mmap,
            Optional,
            NumTypes,
        };
 
        FName       PackageName;
        EType       BulkDataType = BulkSegment;
        FString     LooseFilePath;
        FIoChunkId  ChunkId = FIoChunkId::InvalidChunkId;
        uint16      MultiOutputIndex = 0;
    };
 
    virtual void WriteBulkData(const FBulkDataInfo& Info, const FIoBuffer& BulkData, const TArray<FFileRegion>& FileRegions) = 0;
 
    struct FAdditionalFileInfo
    {
        FName       PackageName;
        FString     Filename;
        FIoChunkId  ChunkId = FIoChunkId::InvalidChunkId;
        uint16      MultiOutputIndex = 0;
    };
 
    virtual void WriteAdditionalFile(const FAdditionalFileInfo& Info, const FIoBuffer& FileData) = 0;
 
    struct FLinkerAdditionalDataInfo
    {
        FName   PackageName;
        uint16  MultiOutputIndex = 0;
    };
    virtual void WriteLinkerAdditionalData(const FLinkerAdditionalDataInfo& Info, const FIoBuffer& Data, const TArray<FFileRegion>& FileRegions) = 0;
 
    virtual int64 GetExportsFooterSize()
    {
        return 0;
    }
 
    struct FPackageTrailerInfo
    {
        FName PackageName;
        uint16 MultiOutputIndex = 0;
    };
    virtual void WritePackageTrailer(const FPackageTrailerInfo& Info, const FIoBuffer& Data) = 0;
 
    virtual TUniquePtr<FLargeMemoryWriter> CreateLinkerArchive(FName PackageName, UObject* Asset, uint16 MultiOutputIndex) = 0;
 
    virtual TUniquePtr<FLargeMemoryWriter> CreateLinkerExportsArchive(FName PackageName, UObject* Asset, uint16 MultiOutputIndex) = 0;
 
    virtual void RegisterDeterminismHelper(UObject* SourceObject,
        const TRefCountPtr<UE::Cook::IDeterminismHelper>& DeterminismHelper)
    {
    }
 
    virtual bool IsPreSaveCompleted() const
    {
        return false;
    }
 
    virtual ICookedPackageWriter* AsCookedPackageWriter()
    {
        return nullptr;
    }
};
 
ENUM_CLASS_FLAGS(IPackageWriter::EWriteOptions);
 
struct FPackageHashes : FThreadSafeRefCountedObject
{
    TMap<FIoChunkId, FIoHash> ChunkHashes;
 
    FMD5Hash PackageHash;
 
    TFuture<int> CompletionFuture;
};
 
namespace UE::PackageWriter::Private
{
 
struct FBeginCacheForCookedPlatformDataInfo
{
    FName PackageName;
    const ITargetPlatform* TargetPlatform;
    TConstArrayView<UObject*> SaveableObjects;
    uint32 SaveFlags;
};
 
struct FWriteFileData
{
    FString Filename;
    FCompositeBuffer Buffer;
    TArray<FFileRegion> Regions;
    bool bIsSidecar = false;
    bool bContributeToHash = true;
    bool bPackageSpecificFilename = false;
    FIoChunkId ChunkId = FIoChunkId::InvalidChunkId;
};
 
class ICookerInterface
{
public:
    virtual EPackageWriterResult CookerBeginCacheForCookedPlatformData(FBeginCacheForCookedPlatformDataInfo& Info) = 0;
    virtual void RegisterDeterminismHelper(ICookedPackageWriter* PackageWriter, UObject* SourceObject,
        const TRefCountPtr<UE::Cook::IDeterminismHelper>& DeterminismHelper) = 0;
    virtual bool IsDeterminismDebug() const = 0;
    virtual void WriteFileOnCookDirector(const FWriteFileData& FileData, FMD5& AccumulatedHash,
        const TRefCountPtr<FPackageHashes>& PackageHashes, IPackageWriter::EWriteOptions WriteOptions) = 0;
 
protected:
    ~ICookerInterface() = default;
};
 
} // namespace UE::PackageWriter::Private
 
class ICookedPackageWriter : public IPackageWriter
{
public:
    virtual ~ICookedPackageWriter() = default;
 
    virtual void SetCooker(UE::PackageWriter::Private::ICookerInterface* CookerInterface) = 0;
 
    enum class EPackageHeaderFormat
    {
        PackageFileSummary,
        ZenPackageSummary
    };
 
    struct FCookCapabilities
    {
        bool bDiffModeSupported = false;
 
        bool bReadOnly = false;
 
        bool bOverridesPackageModificationStatus = false;
 
        bool bOplogAttachments = false;
 
        bool bIgnorePathLengthLimits = false;
 
        EPackageHeaderFormat HeaderFormat = EPackageHeaderFormat::PackageFileSummary;
    };
 
    virtual FCookCapabilities GetCookCapabilities() const
    {
        return FCookCapabilities();
    }
 
    virtual FDateTime GetPreviousCookTime() const
    {
        return FDateTime::MaxValue();
    }
 
    virtual ICookedPackageWriter* AsCookedPackageWriter() override
    {
        return this;
    }
 
    struct FReferencedPluginsInfo
    {
        TSet<FString> ReferencedPlugins;
        bool bReferencesGame = false;
        bool bReferencesEngine = false;
    };
 
    struct FCookInfo
    {
        enum ECookMode
        {
            CookByTheBookMode,
            CookOnTheFlyMode
        };
 
        TOptional<FReferencedPluginsInfo> ReferencedPlugins;
        ECookMode CookMode = CookByTheBookMode;
        bool bFullBuild = true;
        UE_DEPRECATED(5.6, "Use bLegacyIterativeSharedBuild")
        bool bIterateSharedBuild = false;
        bool bLegacyIterativeSharedBuild = false;
        bool bWorkerOnSharedSandbox = false;
    };
 
    virtual void Initialize(const FCookInfo& Info) = 0;
 
    virtual void BeginCook(const FCookInfo& Info) = 0;
 
    virtual void EndCook(const FCookInfo& Info) = 0;
 
    virtual TUniquePtr<FAssetRegistryState> LoadPreviousAssetRegistry() = 0;
 
    virtual FCbObject GetOplogAttachment(FName PackageName, FUtf8StringView AttachmentKey) = 0;
 
    virtual void GetOplogAttachments(TArrayView<FName> PackageNames,
        TArrayView<FUtf8StringView> AttachmentKeys,
        TUniqueFunction<void(FName PackageName, FUtf8StringView AttachmentKey, FCbObject&& Attachment)>&& Callback) = 0;
 
    virtual void GetBaseGameOplogAttachments(TArrayView<FName> PackageNames,
        TArrayView<FUtf8StringView> AttachmentKeys,
        TUniqueFunction<void(FName PackageName, FUtf8StringView AttachmentKey, FCbObject&& Attachment)>&& Callback) = 0;
 
    virtual ECommitStatus GetCommitStatus(FName PackageName) = 0;
 
    virtual void RemoveCookedPackages(TArrayView<const FName> PackageNamesToRemove) = 0;
 
    virtual void RemoveCookedPackages() = 0;
 
    struct FUpdatePackageModifiedStatusContext
    {
        FName PackageName;
        bool bIncrementallyUnmodified = false;
        bool bPreviouslyCooked = false;
        bool bInOutShouldIncrementallySkip = false;
    };
    virtual void UpdatePackageModifiedStatus(FUpdatePackageModifiedStatusContext& Context)
    {
    }
    UE_DEPRECATED(5.4, "No longer called; override UpdatePackageModifiedStatus instead")
    virtual void UpdatePackageModificationStatus(FName PackageName, bool bIncrementallyUnmodified,
        bool& bInOutShouldIncrementallySkip)
    {
    }
 
    struct FDeleteByFree
    {
        void operator()(void* Ptr) const
        {
            FMemory::Free(Ptr);
        }
    };
 
    struct FPreviousCookedBytesData
    {
        TUniquePtr<uint8, FDeleteByFree> Data;
        int64 Size;
        int64 HeaderSize;
        int64 StartOffset;
    };
    virtual bool GetPreviousCookedBytes(const FPackageInfo& Info, FPreviousCookedBytesData& OutData)
    {
        // The subclass must override this method if it returns bDiffModeSupported=true in GetCookCapabilities
        unimplemented();
        return false;
    }
    virtual void CompleteExportsArchiveForDiff(FPackageInfo& Info, FLargeMemoryWriter& ExportsArchive)
    {
        // The subclass must override this method if it returns bDiffModeSupported=true in GetCookCapabilities
        unimplemented();
    }
 
    using FBeginCacheForCookedPlatformDataInfo = UE::PackageWriter::Private::FBeginCacheForCookedPlatformDataInfo;
    // Helper callback type for Writers that need to send the message on to UCookOnTheFlyServer
    UE_DEPRECATED(5.7, "Use ICookedPackageWriterCookerInterface.BeginCacheForCookedPlatformData instead.")
    typedef TUniqueFunction<EPackageWriterResult(FBeginCacheForCookedPlatformDataInfo& Info)> FBeginCacheCallback;
    UE_DEPRECATED(5.7, "Use ICookedPackageWriterCookerInterface.RegisterDeterminismHelper instead.")
    typedef TUniqueFunction<void(UObject* SourceObject,
        const TRefCountPtr<UE::Cook::IDeterminismHelper>& DeterminismHelper)> FRegisterDeterminismHelperCallback;
 
    virtual EPackageWriterResult BeginCacheForCookedPlatformData(FBeginCacheForCookedPlatformDataInfo& Info)
    {
        unimplemented();
        return EPackageWriterResult::Error;
    }
 
    virtual void UpdateSaveArguments(FSavePackageArgs& SaveArgs)
    {
    }
    virtual bool IsAnotherSaveNeeded(FSavePackageResultStruct& PreviousResult, FSavePackageArgs& SaveArgs)
    {
        return false;
    }
    virtual TFuture<FCbObject> WriteMPCookMessageForPackage(FName PackageName) = 0;
 
    virtual bool TryReadMPCookMessageForPackage(FName PackageName, FCbObjectView Message) = 0;
 
    virtual IPackageStoreWriter* AsPackageStoreWriter()
    {
        return nullptr;
    }
 
    virtual TMap<FName, TRefCountPtr<FPackageHashes>>& GetPackageHashes() = 0;
};
 
static inline const ANSICHAR* LexToString(IPackageWriter::FBulkDataInfo::EType Value)
{
    switch (Value)
    {
    case IPackageWriter::FBulkDataInfo::AppendToExports:
        return "AppendToExports";
    case IPackageWriter::FBulkDataInfo::BulkSegment:
        return "Standard";
    case IPackageWriter::FBulkDataInfo::Mmap:
        return "Mmap";
    case IPackageWriter::FBulkDataInfo::Optional:
        return "Optional";
    case IPackageWriter::FBulkDataInfo::NumTypes:
        return "NumTypes";
    default:
        checkNoEntry();
        return "Unknown";
    }
 
}