LinkerSave.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Compression/CompressedBuffer.h"
#include "Containers/Array.h"
#include "Containers/Map.h"
#include "Containers/Set.h"
#include "Containers/StringFwd.h"
#include "Containers/UnrealString.h"
#include "CoreMinimal.h"
#include "CoreTypes.h"
#include "IO/IoHash.h"
#include "Serialization/Archive.h"
#include "Serialization/ArchiveUObject.h"
#include "Serialization/BulkDataCookedIndex.h"
#include "Serialization/FileRegionArchive.h"
#include "Templates/Function.h"
#include "Templates/RefCounting.h"
#include "Templates/UniquePtr.h"
#include "UObject/Linker.h"
#include "UObject/NameTypes.h"
#include "UObject/ObjectResource.h"
#include "UObject/PackageTrailer.h"
#include "UObject/SoftObjectPath.h"
#include "UObject/UObjectThreadContext.h"
 
class FBulkData;
class FObjectPostSaveContext;
class FOutputDevice;
class FPackagePath;
class UObject;
class UPackage;
class FSaveContext;
namespace UE { class FDerivedData; }
namespace UE { class FPackageTrailerBuilder; }
struct FLazyObjectPtr;
struct FUObjectSerializeContext;
 
/*----------------------------------------------------------------------------
    FLinkerSave.
----------------------------------------------------------------------------*/
 
class FLinkerSave : public FLinker, public FArchiveUObject
{
public:
 
    UE_FORCEINLINE_HINT static ELinkerType::Type StaticType()
    {
        return ELinkerType::Save;
    }
 
    virtual ~FLinkerSave();
 
    // Variables.
    FArchive* Saver = nullptr;
 
    FPackageIndex CurrentlySavingExport;
    UObject* CurrentlySavingExportObject = nullptr;
    TArray<FPackageIndex> DepListForErrorChecking;
 
    TMap<TObjectPtr<UObject>, FPackageIndex> ObjectIndicesMap;
    TMap<Verse::VCell*, FPackageIndex> CellIndicesMap;
 
    TMap<const UObject *, TArray<FName> > SearchableNamesObjectMap;
 
    /* Map from FName to the index of the name in the name array written into the package header. */
    TMap<FNameEntryId, int32> NameIndices;
 
    /* Map from FSoftObjectPath to the index of the path in the soft object path array written into the package header. */
    TMap<FSoftObjectPath, int32> SoftObjectPathIndices;
 
    bool bIsWritingHeaderSoftObjectPaths = false;
 
    TArray<FFileRegion> FileRegions;
 
    using AdditionalDataCallback = TUniqueFunction<void(FLinkerSave& ExportsArchive, FArchive& DataArchive, int64 DataStartOffset)>;
    TArray<AdditionalDataCallback> AdditionalDataToAppend;
 
    bool bProceduralSave = false;
 
    bool bUpdatingLoadedPath = false;
 
    bool bRehydratePayloads = false;
    
    struct FSidecarStorageInfo
    {
        FIoHash Identifier;
        FCompressedBuffer Payload;
    };
 
    TArray<FSidecarStorageInfo> SidecarDataToAppend;
    
    TUniquePtr<UE::FPackageTrailerBuilder> PackageTrailerBuilder;
 
    TArray<TUniqueFunction<void(const FPackagePath& PackagePath, FObjectPostSaveContext ObjectSaveContext)>> PostSaveCallbacks;
 
    UE_DEPRECATED(5.6, "No longer supported, contact Epic if you need this functionality.")
    COREUOBJECT_API static TMap<FString, TArray<uint8> > PackagesToScriptSHAMap;
 
    UE_DEPRECATED(5.6, "Use constructor that takes only Parent and then call AssignFileSaver.")
    FLinkerSave(UPackage* InParent, const TCHAR* InFilename, bool bForceByteSwapping, bool bInSaveUnversioned = false );
    UE_DEPRECATED(5.6, "Use constructor that takes only Parent and then call AssignMemorySaver.")
    FLinkerSave(UPackage* InParent, bool bForceByteSwapping, bool bInSaveUnversioned = false );
    UE_DEPRECATED(5.6, "Use constructor that takes only Parent and then call AssignSaver.")
    FLinkerSave(UPackage* InParent, FArchive *InSaver, bool bForceByteSwapping, bool bInSaveUnversioned = false);
 
    explicit FLinkerSave(UPackage* InParent);
 
    void AssignSaver(FArchive* InSaver, bool bForceByteSwapping, bool bInSaveUnversioned = false);
    void AssignMemorySaver(bool bForceByteSwapping, bool bInSaveUnversioned = false);
    bool TryAssignFileSaver(FStringView InFilename, bool bForceByteSwapping, bool bInSaveUnversioned = false);
 
    void AssignSaveContext(FSaveContext* InContext)
    {
        SaveContext = InContext;
    }
 
    int32 MapName( FNameEntryId Name) const;
 
    int32 MapSoftObjectPath(const FSoftObjectPath& SoftObjectPath) const;
 
    FPackageIndex MapObject(TObjectPtr<const UObject> Object, bool bValidateExcluded = true) const;
 
    virtual void MarkScriptSerializationStart(const UObject* Obj) override;
 
    virtual void MarkScriptSerializationEnd(const UObject* Obj) override;
 
    // FArchive interface.
    using FArchiveUObject::operator<<; // For visibility of the overloads we don't override
    virtual FArchive& operator<<(FName& InName) override;
    virtual FArchive& operator<<(UObject*& Obj) override;
    virtual FArchive& operator<<(FObjectPtr& Value) override;
#if WITH_VERSE_VM || defined(__INTELLISENSE__)
    virtual FArchive& operator<<(Verse::VCell*& Cell) override;
#endif
    virtual FArchive& operator<<(FSoftObjectPath& SoftObjectPath) override;
    virtual FArchive& operator<<(FLazyObjectPtr& LazyObjectPtr) override;
    virtual bool ShouldSkipProperty(const FProperty* InProperty) const override;
    UE_DEPRECATED(5.5, "GetSerializeContext is not supported. Use FUObjectThreadContext::Get().GetSerializeContext().")
    FUObjectSerializeContext* GetSerializeContext() override;
    virtual void UsingCustomVersion(const struct FGuid& Guid) override;
    virtual void SetUseUnversionedPropertySerialization(bool bInUseUnversioned) override;
    virtual void SetDebugSerializationFlags(uint32 InCustomFlags) override;
    virtual void SetFilterEditorOnly(bool bInFilterEditorOnly) override;
 
    void SetTransientPropertyOverrides(const TMap<UObject*, TSet<FProperty*>>& InTransientPropertyOverrides)
    {
        TransientPropertyOverrides = &InTransientPropertyOverrides;
    }
 
    void SetMemoryMapAlignment(int64 InAlignment)
    {
        MemoryMappingAlignment = InAlignment;
    }
 
    void SetFileRegionsEnabled(bool bEnabled)
    {
        bFileRegionsEnabled = bEnabled;
    }
 
    void SetDeclareRegionForEachAdditionalFile(bool bValue)
    {
        bDeclareRegionForEachAdditionalFile = bValue;
    }
 
    void SetSaveBulkDataByReference(bool bValue)
    {
        bSaveBulkDataByReference = bValue;
    }
    
    void SetSaveBulkDataToSeparateFiles(bool bValue)
    {
        bSaveBulkDataToSeparateFiles = bValue;
    }
 
#if WITH_EDITOR
    // proxy for debugdata
    virtual void PushDebugDataString(const FName& DebugData) override { Saver->PushDebugDataString(DebugData); }
    virtual void PopDebugDataString() override { Saver->PopDebugDataString(); }
#endif
 
    virtual FString GetArchiveName() const override;
 
    virtual FLinker* GetLinker() { return this; }
 
    void Seek( int64 InPos );
    int64 Tell();
    // this fixes the warning : 'FLinkerSave::Serialize' hides overloaded virtual function
    using FLinker::Serialize;
    void Serialize( void* V, int64 Length );
 
    void OnPostSave(const FPackagePath& PackagePath, FObjectPostSaveContext ObjectSaveContext);
    
    void OnPostSaveBulkData();
 
    virtual void SetSerializedProperty(FProperty* InProperty) override;
    virtual void SetSerializedPropertyChain(const FArchiveSerializedPropertyChain* InSerializedPropertyChain,
        class FProperty* InSerializedPropertyOverride = nullptr) override;
    virtual void PushSerializedProperty(class FProperty* InProperty, const bool bIsEditorOnlyProperty) override;
    virtual void PopSerializedProperty(class FProperty* InProperty, const bool bIsEditorOnlyProperty) override;
#if WITH_EDITORONLY_DATA
    virtual bool IsEditorOnlyPropertyOnTheStack() const override;
#endif
 
    // FLinker interface
    virtual FString GetDebugName() const override;
 
    // FLinkerSave interface
    bool CloseAndDestroySaver();
 
    const FString& GetFilename() const;
 
    /* Set the output device used to log errors, if any. */
    void SetOutputDevice(FOutputDevice* InOutputDevice)
    {
        LogOutput = InOutputDevice;
    }
 
    /* Returns an output Device that can be used to log info, warnings and errors etc. */
    FOutputDevice* GetOutputDevice() const 
    {
        return LogOutput;
    }
 
#if WITH_EDITORONLY_DATA
    UE::FDerivedData AddDerivedData(const UE::FDerivedData& Data);
#endif // WITH_EDITORONLY_DATA
 
    virtual bool SerializeBulkData(FBulkData& BulkData, const FBulkDataSerializationParams& Params) override;
 
    void ForEachBulkDataCookedIndex(TUniqueFunction<void(FBulkDataCookedIndex, FFileRegionMemoryWriter&)>&& Func, EBulkDataPayloadType Type) const;
 
    FFileRegionMemoryWriter& GetBulkDataArchive(FBulkDataCookedIndex CookedIndex);
    FFileRegionMemoryWriter& GetOptionalBulkDataArchive(FBulkDataCookedIndex CookedIndex);
    FFileRegionMemoryWriter& GetMemoryMappedBulkDataArchive(FBulkDataCookedIndex CookedIndex);
 
    bool HasCookedIndexBulkData() const;
 
    UE_DEPRECATED(5.5, "Use the overload that takes a FBulkDataCookedIndex")
    FFileRegionMemoryWriter& GetBulkDataArchive()
    {
        return GetBulkDataArchive(FBulkDataCookedIndex::Default);
    }
 
    UE_DEPRECATED(5.5, "Use the overload that takes a FBulkDataCookedIndex")
    FFileRegionMemoryWriter& GetOptionalBulkDataArchive()
    {
        return GetOptionalBulkDataArchive(FBulkDataCookedIndex::Default);
    }
 
    UE_DEPRECATED(5.5, "Use the overload that takes a FBulkDataCookedIndex")
    FFileRegionMemoryWriter& GetMemoryMappedBulkDataArchive()
    {
        return GetMemoryMappedBulkDataArchive(FBulkDataCookedIndex::Default);
    }
 
protected:
    void SetFilename(FStringView InFilename);
 
    const TMap<FBulkDataCookedIndex, TUniquePtr<FFileRegionMemoryWriter>>& GetArchives(EBulkDataPayloadType Type) const;
 
    void SerializeObjectPointer(const FObjectPtr& Value);
 
    void AssignSaverInternal(FArchive* InSaver, bool bForceByteSwapping, bool bInSaveUnversioned);
 
private:
    FSaveContext* SaveContext = nullptr;
    FOutputDevice* LogOutput = nullptr;
 
#if WITH_EDITORONLY_DATA
    int32 LastDerivedDataIndex = -1;
#endif
 
#if WITH_EDITOR
    TMap<FBulkData*, int32> SerializedBulkData;
#endif //WITH_EDITOR
 
    TMap<FBulkDataCookedIndex, TUniquePtr<FFileRegionMemoryWriter>> BulkDataAr; // Can't use TUniqueObj as FFileRegionMemoryWriter isn't movable
    TMap<FBulkDataCookedIndex, TUniquePtr<FFileRegionMemoryWriter>> OptionalBulkDataAr;
    TMap<FBulkDataCookedIndex, TUniquePtr<FFileRegionMemoryWriter>> MemoryMappedBulkDataAr;
 
    FString Filename;
 
    const TMap<UObject*, TSet<FProperty*>>* TransientPropertyOverrides = nullptr;
    int64 MemoryMappingAlignment = -1;
    bool bFileRegionsEnabled = false;
    bool bDeclareRegionForEachAdditionalFile = false;
    bool bSaveBulkDataByReference = false;
    bool bSaveBulkDataToSeparateFiles = false;
};