ManifestData.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "CoreMinimal.h"
#include "Misc/SecureHash.h"
#include "Misc/EnumClassFlags.h"
#include "Misc/EnumRange.h"
#include "Serialization/Archive.h"
#include "Data/ChunkData.h"
#include "BuildPatchFeatureLevel.h"
 
class FBuildPatchAppManifest;
 
namespace BuildPatchServices
{
    enum class EManifestStorageFlags : uint8
    {
        // Stored as raw data.
        None       = 0,
        // Flag for compressed data.
        Compressed = 1,
        // Flag for encrypted. If also compressed, decrypt first. Encryption will ruin compressibility.
        Encrypted  = 1 << 1,
    };
    ENUM_CLASS_FLAGS(EManifestStorageFlags);
 
    namespace ManifestVersionHelpers
    {
        const TCHAR* GetChunkSubdir(EFeatureLevel FeatureLevel);
 
        const TCHAR* GetFileSubdir(EFeatureLevel FeatureLevel);
    }
 
    struct FManifestHeader
    {
        FManifestHeader();
        friend FArchive& operator<<(FArchive& Ar, FManifestHeader& Header);
        // The version of this header and manifest data format, driven by the feature level.
        EFeatureLevel Version;
        // The size of this header.
        uint32 HeaderSize;
        // The size of this data compressed.
        uint32 DataSizeCompressed;
        // The size of this data uncompressed.
        uint32 DataSizeUncompressed;
        // How the chunk data is stored.
        EManifestStorageFlags StoredAs;
        // The SHA1 hash for the manifest data that follows.
        FSHAHash SHAHash;
    };
 
    struct FManifestMeta
    {
        FManifestMeta();
        friend FArchive& operator<<(FArchive& Ar, FManifestMeta& Meta);
        // The feature level support this build was created with, regardless of the serialised format.
        EFeatureLevel FeatureLevel;
        // Whether this is a legacy 'nochunks' build.
        bool bIsFileData;
        // The app id provided at generation.
        uint32 AppID;
        // The app name string provided at generation.
        FString AppName;
        // The build version string provided at generation.
        FString BuildVersion;
        // The file in this manifest designated the application executable of the build.
        FString LaunchExe;
        // The command line required when launching the application executable.
        FString LaunchCommand;
        // The set of prerequisite ids for dependencies that this build's prerequisite installer will apply.
        TSet<FString> PrereqIds;
        // A display string for the prerequisite provided at generation.
        FString PrereqName;
        // The file in this manifest designated the launch executable of the prerequisite installer.
        FString PrereqPath;
        // The command line required when launching the prerequisite installer.
        FString PrereqArgs;
        // A unique build id generated at original chunking time to identify an exact build.
        FString BuildId;
    };
 
    struct FChunkDataList
    {
        FChunkDataList();
        friend FArchive& operator<<(FArchive& Ar, FChunkDataList& ChunkDataList);
        // The list of chunks.
        TArray<FChunkInfo> ChunkList;
    };
 
    enum class EFileMetaFlags : uint8
    {
        None           = 0,
        // Flag for readonly file.
        ReadOnly       = 1,
        // Flag for natively compressed.
        Compressed     = 1 << 1,
        // Flag for unix executable.
        UnixExecutable = 1 << 2
    };
    ENUM_CLASS_FLAGS(EFileMetaFlags);
 
    struct FFileManifest
    {
        FFileManifest();
        // The build relative filename.
        FString Filename;
        // Whether this is a symlink to another file.
        FString SymlinkTarget;
        // The file SHA1.
        FSHAHash FileHash;
        // The flags for this file.
        EFileMetaFlags FileMetaFlags;
        // The install tags for this file.
        TArray<FString> InstallTags;
        // The list of chunk parts to stitch.
        TArray<FChunkPart> ChunkParts;
        // The size of this file.
        uint64 FileSize;
    };
 
    struct FFileManifestList
    {
        FFileManifestList();
        friend FArchive& operator<<(FArchive& Ar, FFileManifestList& FileManifestList);
        void OnPostLoad();
        // The list of files.
        TArray<FFileManifest> FileList;
    };
 
    struct FCustomFields
    {
        FCustomFields();
        friend FArchive& operator<<(FArchive& Ar, FCustomFields& CustomFields);
        // The map of field name to field data.
        TMap<FString, FString> Fields;
    };
 
    class FManifestData
    {
    public:
        static void Init();
        static bool Serialize(FArchive& Ar, FBuildPatchAppManifest& AppManifest, BuildPatchServices::EFeatureLevel SaveFormat /* Ignored for loading */ = BuildPatchServices::EFeatureLevel::Latest);
    };
}
 
ENUM_RANGE_BY_FIRST_AND_LAST(BuildPatchServices::EFeatureLevel, BuildPatchServices::EFeatureLevel::Original, BuildPatchServices::EFeatureLevel::Latest);