ChunkReferenceTracker.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "CoreMinimal.h"
#include "BuildPatchManifest.h"
#include "IBuildManifestSet.h"
 
namespace BuildPatchServices
{
    class IChunkReferenceTracker
    {
    public:
        enum class ESortDirection : uint8
        {
            Ascending = 0,
            Descending
        };
 
    public:
        virtual ~IChunkReferenceTracker() {}
 
        virtual TSet<FGuid> GetReferencedChunks() const = 0;
 
        virtual int32 GetReferenceCount(const FGuid& ChunkId) const = 0;
 
        virtual void SortByUseOrder(TArray<FGuid>& ChunkList, ESortDirection Direction) const = 0;
 
        virtual TArray<FGuid> GetNextReferences(int32 Count, const TFunction<bool(const FGuid&)>& SelectPredicate) const = 0;
 
        virtual TArray<FGuid> SelectFromNextReferences(int32 Count, const TFunction<bool(const FGuid&)>& SelectPredicate) const = 0;
 
        virtual bool PopReference(const FGuid& ChunkId) = 0;
 
        // Return how many chunks are left to process.
        virtual int32 GetRemainingChunkCount() const = 0;
 
        // Return the ordered list we are consuming.
        // copies the _remaining_ items!
        virtual void CopyOutOrderedUseList(TArray<FGuid>& OutUseList) const = 0;
 
        // Returns the next usage index in _advancing order_ for the chunkid, or -1 if it won't
        // be used again.
        virtual int32 GetNextUsageForChunk(const FGuid& ChunkId, int32& OutLastUsageIndex) const = 0;
 
        virtual int32 GetCurrentUsageIndex() const = 0;
    };
 
    class FChunkReferenceTrackerFactory
    {
    public:
        static IChunkReferenceTracker* Create(const IBuildManifestSet* Manifest, const TSet<FString>& FilesToConstruct);
        
        static IChunkReferenceTracker* Create(TArray<FGuid> CustomChunkReferences);
    };
 
 
    namespace CustomChunkReferencesHelpers
    {
        FORCEINLINE TArray<FGuid> OrderedUniqueReferences(const FBuildPatchAppManifestRef& InstallManifest)
        {
            TArray<FGuid> ChunkReferences;
            // Create our full list of chunks, no dupes, just one reference per chunk in the correct order.
            TArray<FString> AllFiles;
            TSet<FGuid> AllChunks;
            InstallManifest->GetFileList(AllFiles);
            for (const FString& File : AllFiles)
            {
                const FFileManifest* NewFileManifest = InstallManifest->GetFileManifest(File);
                if (NewFileManifest != nullptr)
                {
                    for (const FChunkPart& ChunkPart : NewFileManifest->ChunkParts)
                    {
                        bool bWasAlreadyInSet = false;
                        AllChunks.Add(ChunkPart.Guid, &bWasAlreadyInSet);
                        if (!bWasAlreadyInSet)
                        {
                            ChunkReferences.Add(ChunkPart.Guid);
                        }
                    }
                }
            }
            return ChunkReferences;
        }
        
        FORCEINLINE TArray<FGuid> OrderedUniquePatchReferences(const FBuildPatchAppManifestRef& InstallManifest, const FBuildPatchAppManifestRef& CurrentManifest)
        {
            TArray<FGuid> ChunkReferences;
            // Create our list of chunks, no dupes, just one reference per chunk which appears only in InstallManifest, and in the correct order of use.
            TArray<FString> AllFiles;
            TSet<FGuid> OldChunks;
            TSet<FGuid> NewChunks;
            CurrentManifest->GetDataList(OldChunks);
            InstallManifest->GetFileList(AllFiles);
            for (const FString& File : AllFiles)
            {
                const FFileManifest* NewFileManifest = InstallManifest->GetFileManifest(File);
                if (NewFileManifest != nullptr)
                {
                    for (const FChunkPart& ChunkPart : NewFileManifest->ChunkParts)
                    {
                        const bool bIsNewChunk = !OldChunks.Contains(ChunkPart.Guid);
                        if (bIsNewChunk)
                        {
                            bool bWasAlreadyInSet = false;
                            NewChunks.Add(ChunkPart.Guid, &bWasAlreadyInSet);
                            if (!bWasAlreadyInSet)
                            {
                                ChunkReferences.Add(ChunkPart.Guid);
                            }
                        }
                    }
                }
            }
            return ChunkReferences;
        }
        
        FORCEINLINE TArray<FGuid> OrderedUniqueReferencesTagged(const FBuildPatchAppManifestRef& InstallManifest, const TSet<FString>& InstallTagSet)
        {
            TArray<FGuid> ChunkReferences;
            // Create our full list of chunks, no dupes, just one reference per chunk in the correct order.
            TArray<FString> TaggedFiles;
            TSet<FGuid> TaggedChunks;
            InstallManifest->GetTaggedFileList(InstallTagSet, TaggedFiles);
            for (const FString& File : TaggedFiles)
            {
                const FFileManifest* NewFileManifest = InstallManifest->GetFileManifest(File);
                if (NewFileManifest != nullptr)
                {
                    for (const FChunkPart& ChunkPart : NewFileManifest->ChunkParts)
                    {
                        bool bWasAlreadyInSet = false;
                        TaggedChunks.Add(ChunkPart.Guid, &bWasAlreadyInSet);
                        if (!bWasAlreadyInSet)
                        {
                            ChunkReferences.Add(ChunkPart.Guid);
                        }
                    }
                }
            }
            return ChunkReferences;
        }
        
        FORCEINLINE TArray<FGuid> OrderedUniquePatchReferencesTagged(const FBuildPatchAppManifestRef& InstallManifest, const TSet<FString>& InstallTagSet, const FBuildPatchAppManifestRef& CurrentManifest, const TSet<FString>& CurrentTagSet)
        {
            // Enumerate what is available in the current build.
            TSet<FString> FilesInstalled;
            TSet<FGuid> ChunksRequired;
            TSet<FGuid> ChunksInstalled;
            CurrentManifest->GetTaggedFileList(CurrentTagSet, FilesInstalled);
            CurrentManifest->GetChunksRequiredForFiles(FilesInstalled, ChunksRequired);
            CurrentManifest->EnumerateProducibleChunks(CurrentTagSet, ChunksRequired, ChunksInstalled);
 
            TArray<FGuid> ChunkReferences;
            // Create our list of chunks, no dupes, just one reference per chunk which appears only in InstallManifest, and in the correct order of use.
            TArray<FString> TaggedFiles;
            TSet<FGuid> TaggedNewChunks;
            InstallManifest->GetTaggedFileList(InstallTagSet, TaggedFiles);
            for (const FString& File : TaggedFiles)
            {
                const FFileManifest* NewFileManifest = InstallManifest->GetFileManifest(File);
                if (NewFileManifest != nullptr)
                {
                    for (const FChunkPart& ChunkPart : NewFileManifest->ChunkParts)
                    {
                        const bool bIsNewChunk = !ChunksInstalled.Contains(ChunkPart.Guid);
                        if (bIsNewChunk)
                        {
                            bool bWasAlreadyInSet = false;
                            TaggedNewChunks.Add(ChunkPart.Guid, &bWasAlreadyInSet);
                            if (!bWasAlreadyInSet)
                            {
                                ChunkReferences.Add(ChunkPart.Guid);
                            }
                        }
                    }
                }
            }
            return ChunkReferences;
        }
    }
}