SavePackageUtilities.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/Set.h"
#include "Containers/StringFwd.h"
#include "Memory/MemoryView.h"
#include "Misc/FileHelper.h"
#include "ProfilingDebugging/CookStats.h"
#include "Serialization/ArchiveObjectCrc32.h"
#include "Serialization/ArchiveStackTrace.h"
#include "Serialization/FileRegions.h"
#include "UObject/NameTypes.h"
#include "UObject/Package.h"
#include "UObject/UObjectMarks.h"
#include "UObject/ObjectPtr.h"
#include "UObject/SavePackage.h"
#include "UObject/UObjectGlobals.h"
 
// This file contains private utilities shared by UPackage::Save and UPackage::Save2 
 
class FCbFieldView;
class FCbWriter;
class FPackagePath;
class FSaveContext;
class FSavePackageContext;
class IPackageWriter;
class ITargetPlatform;
enum class ESavePackageResult;
enum class ESaveRealm : uint32;
struct FIoHash;
 
// Save Time trace
#if UE_TRACE_ENABLED && !UE_BUILD_SHIPPING
UE_TRACE_CHANNEL_EXTERN(SaveTimeChannel)
#define SCOPED_SAVETIMER(TimerName) TRACE_CPUPROFILER_EVENT_SCOPE_ON_CHANNEL(TimerName, SaveTimeChannel)
#define SCOPED_SAVETIMER_TEXT(TimerName) TRACE_CPUPROFILER_EVENT_SCOPE_TEXT_ON_CHANNEL(TimerName, SaveTimeChannel)
#else
#define SCOPED_SAVETIMER(TimerName)
#define SCOPED_SAVETIMER_TEXT(TimerName)
#endif
 
struct FLargeMemoryDelete
{
    void operator()(uint8* Ptr) const
    {
        if (Ptr)
        {
            FMemory::Free(Ptr);
        }
    }
};
typedef TUniquePtr<uint8, FLargeMemoryDelete> FLargeMemoryPtr;
 
enum class EAsyncWriteOptions
{
    None = 0
};
ENUM_CLASS_FLAGS(EAsyncWriteOptions)
 
struct FScopedSavingFlag
{
    FScopedSavingFlag(bool InSavingConcurrent, UPackage* InSavedPackage);
    ~FScopedSavingFlag();
 
    bool bSavingConcurrent;
 
private:
    // The package being saved
    UPackage* SavedPackage = nullptr;
};
 
struct FCanSkipEditorReferencedPackagesWhenCooking
{
    FCanSkipEditorReferencedPackagesWhenCooking();
};
 
 
struct FSavePackageOutputFile
{
    FSavePackageOutputFile(const FString& InTargetPath, FLargeMemoryPtr&& MemoryBuffer, const TArray<FFileRegion>& InFileRegions, int64 InDataSize)
        : TargetPath(InTargetPath)
        , FileMemoryBuffer(MoveTemp(MemoryBuffer))
        , FileRegions(InFileRegions)
        , DataSize(InDataSize)
    {
 
    }
 
    FSavePackageOutputFile(const FString& InTargetPath, const FString& InTempFilePath, int64 InDataSize)
        : TargetPath(InTargetPath)
        , TempFilePath(InTempFilePath)
        , DataSize(InDataSize)
    {
 
    }
 
    FString TargetPath;
 
    FString TempFilePath;
 
    FLargeMemoryPtr FileMemoryBuffer;
    TArray<FFileRegion> FileRegions;
 
    int64 DataSize;
};
 
// Currently we only expect to store up to 2 files in this, so set the inline capacity to double of this
using FSavePackageOutputFileArray = TArray<FSavePackageOutputFile, TInlineAllocator<4>>;
 
struct FObjectImportSortHelper
{
    static void SortImports(FLinkerSave* Linker);
};
 
struct FObjectExportSortHelper
{
    static void SortExports(FLinkerSave* Linker);
};
 
// Utility functions used by both UPackage::Save and/or UPackage::Save2
namespace UE::SavePackageUtilities
{
 
extern const FName NAME_World;
extern const FName NAME_Level;
extern const FName NAME_PrestreamPackage;
 
void SaveThumbnails(UPackage* InOuter, FLinkerSave* Linker, FStructuredArchive::FSlot Slot);
 
ESavePackageResult AppendAdditionalData(FLinkerSave& Linker, int64& InOutDataStartOffset, FSavePackageContext* SavePackageContext);
    
ESavePackageResult CreatePayloadSidecarFile(FLinkerSave& Linker, const FPackagePath& PackagePath, const bool bSaveToMemory,
    FSavePackageOutputFileArray& AdditionalPackageFiles, FSavePackageContext* SavePackageContext);
 
void SaveMetaData(UPackage* InOuter, FLinkerSave* Linker, FStructuredArchive::FRecord Record);
void SaveWorldLevelInfo(UPackage* InOuter, FLinkerSave* Linker, FStructuredArchive::FRecord Record);
EObjectMark GetExcludedObjectMarksForTargetPlatform(const ITargetPlatform* TargetPlatform);
void FindMostLikelyCulprit(const TArray<UObject*>& BadObjects, FSaveContext& SaveContext,
    ESaveRealm HarvestedRealm, UObject*& OutMostLikelyCulprit, UObject*& OutReferencer,
    const FProperty*& OutReferencerProperty, bool& OutIsCulpritArchetype, FString& OutDiagnosticText);
    
ESavePackageResult FinalizeTempOutputFiles(const FPackagePath& PackagePath, const FSavePackageOutputFileArray& OutputFiles, const FDateTime& FinalTimeStamp);
 
void WriteToFile(const FString& Filename, const uint8* InDataPtr, int64 InDataSize);
void AsyncWriteFile(FLargeMemoryPtr Data, const int64 DataSize, const TCHAR* Filename, EAsyncWriteOptions Options, TArrayView<const FFileRegion> InFileRegions);
void AsyncWriteFile(EAsyncWriteOptions Options, FSavePackageOutputFile& File);
 
template <typename HashBuilderType>
bool TryHashFile(FStringView Filename, HashBuilderType& Builder, int64 Offset = 0, int64 Size = -1);
bool TryHashFile(FStringView Filename, FIoHash& OutHash, int64 Offset = 0, int64 Size = -1);
 
void GetCDOSubobjects(UObject* CDO, TArray<UObject*>& Subobjects);
 
enum class EEditorOnlyObjectFlags
{
    None = 0,
    CheckRecursive = 1 << 1,
    ApplyHasNonEditorOnlyReferences = 1 << 2,
 
};
ENUM_CLASS_FLAGS(EEditorOnlyObjectFlags);
 
#if WITH_EDITORONLY_DATA
bool CanStripEditorOnlyImportsAndExports();
 
bool IsEditorOnlyObjectInternal(const UObject* InObject, EEditorOnlyObjectFlags Flags,
    TFunctionRef<UE::SavePackageUtilities::EEditorOnlyObjectResult(const UObject*)> LookupInCache,
    TFunctionRef<void(const UObject*, bool)> AddToCache);
bool IsEditorOnlyObjectInternal(const UObject* InObject, EEditorOnlyObjectFlags Flags);
#endif
 
void HarvestCookRuntimeDependencies(FObjectSaveContextData& Data, UObject* HarvestReferencesFrom);
 
} // namespace UE::SavePackageUtilities
 
#if ENABLE_COOK_STATS
struct FSavePackageStats
{
    static int32 NumPackagesSaved;
    static double SavePackageTimeSec;
    static double TagPackageExportsPresaveTimeSec;
    static double TagPackageExportsTimeSec;
    static double FullyLoadLoadersTimeSec;
    static double ResetLoadersTimeSec;
    static double TagPackageExportsGetObjectsWithOuter;
    static double TagPackageExportsGetObjectsWithMarks;
    static double SerializeImportsTimeSec;
    static double SortExportsSeekfreeInnerTimeSec;
    static double SerializeExportsTimeSec;
    static double SerializeBulkDataTimeSec;
    static double AsyncWriteTimeSec;
    static double MBWritten;
    static TMap<FName, FArchiveDiffStats> PackageDiffStats;
    static int32 NumberOfDifferentPackages;
    static FCookStatsManager::FAutoRegisterCallback RegisterCookStats;
    static void AddSavePackageStats(FCookStatsManager::AddStatFuncRef AddStat);
    static void MergeStats(const TMap<FName, FArchiveDiffStats>& ToMerge);
};
#endif
 
 
// Inline implementations
 
 
namespace UE::SavePackageUtilities
{
 
template <typename HashBuilderType>
bool TryHashFile(FStringView Filename, HashBuilderType& Builder, int64 Offset, int64 Size)
{
    return FFileHelper::LoadFileInBlocks(Filename, [&Builder](FMemoryView Block)
        {
            Builder.Update(Block);
        }, Offset, Size);
}
 
}