ObjectSaveContext.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/UnrealString.h"
#include "HAL/Platform.h"
#include "Serialization/ArchiveSavePackageData.h"
#include "Templates/RefCounting.h"
#include "UObject/CookEnums.h"
#include "UObject/NameTypes.h"
#include "UObject/ObjectSaveOverride.h"
#if WITH_EDITOR
#include "Cooker/BuildResultDependenciesMap.h"
#include "Cooker/CookDependency.h"
#endif
 
class FPackagePath;
class IPackageWriter;
class ITargetPlatform;
class UPackage;
struct FSoftObjectPath;
namespace UE::Cook { class ICookInfo; }
#if WITH_EDITOR
namespace UE::Cook { class IDeterminismHelper; }
#endif
 
enum class EObjectSaveContextPhase : uint8
{
    Invalid,
    PreSave,
    Harvest,
    CookDependencyHarvest,
    Write,
    PostSave,
};
 
struct FObjectSaveContextData
{
    COREUOBJECT_API FObjectSaveContextData();
    COREUOBJECT_API ~FObjectSaveContextData();
    COREUOBJECT_API FObjectSaveContextData(const FObjectSaveContextData& Other);
    COREUOBJECT_API FObjectSaveContextData(FObjectSaveContextData&& Other);
 
    COREUOBJECT_API FObjectSaveContextData(UPackage* Package, const ITargetPlatform* InTargetPlatform, const TCHAR* InTargetFilename, uint32 InSaveFlags);
    COREUOBJECT_API FObjectSaveContextData(UPackage* Package, const ITargetPlatform* InTargetPlatform, const FPackagePath& TargetPath, uint32 InSaveFlags);
 
    COREUOBJECT_API void Set(UPackage* Package, const ITargetPlatform* InTargetPlatform, const TCHAR* InTargetFilename, uint32 InSaveFlags);
    COREUOBJECT_API void Set(UPackage* Package, const ITargetPlatform* InTargetPlatform, const FPackagePath& TargetPath, uint32 InSaveFlags);
 
    void AddSaveOverride(UObject* Target, FObjectSaveOverride InOverride)
    {
        if (FObjectSaveOverride* MatchingSaveOverride = SaveOverrides.Find(Target))
        {
            MatchingSaveOverride->Merge(InOverride);
        }
        else
        {
            SaveOverrides.Add(Target, MoveTemp(InOverride));
        }
    }
 
    // Global Parameters that are read-only by the interfaces
 
    FString TargetFilename;
 
    const ITargetPlatform* TargetPlatform = nullptr;
 
    UE::Cook::ICookInfo* CookInfo = nullptr;
 
    IPackageWriter* PackageWriter = nullptr;
 
    UObject* Object = nullptr;
 
    uint32 SaveFlags = 0;
 
    uint32 OriginalPackageFlags = 0;
 
    UE::Cook::ECookType CookType = UE::Cook::ECookType::Unknown;
    UE::Cook::ECookingDLC CookingDLC = UE::Cook::ECookingDLC::Unknown;
 
    EObjectSaveContextPhase ObjectSaveContextPhase = EObjectSaveContextPhase::Invalid;
 
    bool bProceduralSave = false;
 
    bool bUpdatingLoadedPath = false;
 
    bool bOuterConcurrentSave = true;
 
    bool bSaveSucceeded = true;
 
    bool bDeterminismDebug = false;
 
    // Collection variables that are written but not read during the PreSave/PostSave functions
#if WITH_EDITOR
    UE_DEPRECATED(5.6, "Use BuildResultDependencies instead.")
    TArray<UE::Cook::FCookDependency> CookDependencies;
    UE::Cook::FBuildResultDependenciesMap BuildResultDependencies;
    TArray<FSoftObjectPath> CookRuntimeDependencies;
#endif
 
    // Per-object Output variables; writable from PreSave functions, readable from PostSave functions
 
    TMap<UObject*, FObjectSaveOverride> SaveOverrides;
 
    bool bCleanupRequired = false;
 
    // Variables set/read per call to PreSave/PostSave functions
    int32 NumRefPasses = 0;
 
    bool bBaseClassCalled = false;
 
    bool bRequestPostSaveSerialization = false;
 
};
 
class FObjectCollectSaveOverridesContext
{
public:
    explicit FObjectCollectSaveOverridesContext(FObjectSaveContextData& InData)
        : Data(InData)
    {
        // Note: Doesn't increment NumRefPasses as CollectSaveOverrides is called from PreSave
    }
 
    FObjectCollectSaveOverridesContext(const FObjectCollectSaveOverridesContext& Other)
        : Data(Other.Data)
    {
        // Note: Doesn't increment NumRefPasses as CollectSaveOverrides is called from PreSave
    }
 
    bool IsCooking() const { return Data.TargetPlatform != nullptr; }
 
    const ITargetPlatform* GetTargetPlatform() const { return Data.TargetPlatform; }
 
    bool IsCookByTheBook() const { return GetCookType()  == UE::Cook::ECookType::ByTheBook; }
    bool IsCookOnTheFly() const { return GetCookType() == UE::Cook::ECookType::OnTheFly; }
    bool IsCookTypeUnknown() const { return GetCookType() == UE::Cook::ECookType::Unknown; }
    UE::Cook::ECookType GetCookType() const { return Data.CookType; }
    UE::Cook::ECookingDLC GetCookingDLC() const { return Data.CookingDLC; }
 
    bool IsProceduralSave() const { return Data.bProceduralSave; }
 
    uint32 GetSaveFlags() const { return Data.SaveFlags; }
 
    void AddSaveOverride(UObject* Target, FObjectSaveOverride InOverride)
    {
        Data.AddSaveOverride(Target, MoveTemp(InOverride));
    }
 
protected:
    FObjectSaveContextData& Data;
    friend class UObject;
};
 
class FObjectPreSaveContext
{
public:
    explicit FObjectPreSaveContext(FObjectSaveContextData& InData)
        : Data(InData)
    {
        ++Data.NumRefPasses; // Record the number of copies; used to check whether PreSave is overridden
    }
 
    FObjectPreSaveContext(const FObjectPreSaveContext& Other)
        : Data(Other.Data)
    {
        ++Data.NumRefPasses; // Record the number of copies; used to check whether PreSave is overridden
    }
 
    const TCHAR* GetTargetFilename() const { return *Data.TargetFilename; }
 
    bool IsCooking() const { return Data.TargetPlatform != nullptr; }
 
    const ITargetPlatform* GetTargetPlatform() const { return Data.TargetPlatform; }
 
    bool IsCookByTheBook() const { return GetCookType()  == UE::Cook::ECookType::ByTheBook; }
    bool IsCookOnTheFly() const { return GetCookType() == UE::Cook::ECookType::OnTheFly; }
    bool IsCookTypeUnknown() const { return GetCookType() == UE::Cook::ECookType::Unknown; }
    UE::Cook::ECookType GetCookType() const { return Data.CookType; }
    UE::Cook::ECookingDLC GetCookingDLC() const { return Data.CookingDLC; }
 
    EObjectSaveContextPhase GetPhase() const { return Data.ObjectSaveContextPhase; }
 
#if WITH_EDITOR
    UE_DEPRECATED(5.6, "These dependencies should instead be reported in OnCookEvent(UE::Cook::ECookEvent::PlatformCookDependencies, ...) by calling FCookEventContext.AddLoadBuildDependency (@see CookEvents.h).")
    COREUOBJECT_API void AddCookBuildDependency(UE::Cook::FCookDependency BuildDependency);
    UE_DEPRECATED(5.6, "These dependencies should instead be reported in OnCookEvent(UE::Cook::ECookEvent::PlatformCookDependencies, ...) by calling FCookEventContext.AddRuntimeDependency (@see CookEvents.h).")
    COREUOBJECT_API void AddCookRuntimeDependency(FSoftObjectPath Dependency);
    UE_DEPRECATED(5.6, "These dependencies should instead be reported in OnCookEvent(UE::Cook::ECookEvent::PlatformCookDependencies, ...) by calling FCookEventContext.HarvestCookRuntimeDependencies (@see CookEvents.h).")
    COREUOBJECT_API void HarvestCookRuntimeDependencies(UObject* HarvestReferencesFrom);
 
    COREUOBJECT_API bool IsDeterminismDebug() const;
    COREUOBJECT_API void RegisterDeterminismHelper(const TRefCountPtr<UE::Cook::IDeterminismHelper>& DeterminismHelper);
#endif
 
    bool IsProceduralSave() const { return Data.bProceduralSave; }
 
    bool IsFromAutoSave() const { return (Data.SaveFlags & SAVE_FromAutosave) != 0; }
 
    bool IsUpdatingLoadedPath() const { return Data.bUpdatingLoadedPath; }
 
    uint32 GetSaveFlags() const { return Data.SaveFlags; }
 
    bool IsFirstConcurrentSave() const { return Data.bOuterConcurrentSave; }
 
    UE_DEPRECATED(5.5, "Calling AddSaveOverride in UObject::PreSave is deprecated. Override UObject::CollectSaveOverrides and call AddSaveOverride on its context instead.")
    void AddSaveOverride(UObject* Target, FObjectSaveOverride InOverride)
    {
        Data.AddSaveOverride(Target, MoveTemp(InOverride));
    }
 
protected:
    FObjectSaveContextData& Data;
    friend class UObject;
};
 
class FObjectSavePackageSerializeContext
{
public:
    explicit FObjectSavePackageSerializeContext(FObjectSaveContextData& InData)
        : Data(InData)
    {
    }
 
    FObjectSavePackageSerializeContext(const FObjectSavePackageSerializeContext& Other)
        : Data(Other.Data)
    {
    }
 
    const TCHAR* GetTargetFilename() const { return *Data.TargetFilename; }
 
    bool IsCooking() const { return Data.TargetPlatform != nullptr; }
 
    const ITargetPlatform* GetTargetPlatform() const { return Data.TargetPlatform; }
 
    bool IsCookByTheBook() const { return GetCookType() == UE::Cook::ECookType::ByTheBook; }
    bool IsCookOnTheFly() const { return GetCookType() == UE::Cook::ECookType::OnTheFly; }
    bool IsCookTypeUnknown() const { return GetCookType() == UE::Cook::ECookType::Unknown; }
    UE::Cook::ECookType GetCookType() const { return Data.CookType; }
    UE::Cook::ECookingDLC GetCookingDLC() const { return Data.CookingDLC; }
 
    EObjectSaveContextPhase GetPhase() const { return Data.ObjectSaveContextPhase; }
 
#if WITH_EDITOR
    COREUOBJECT_API bool IsHarvestingCookDependencies() const;
 
    UE_DEPRECATED(5.6, "Use AddCookLoadDependency.")
    COREUOBJECT_API void AddCookBuildDependency(UE::Cook::FCookDependency BuildDependency);
 
    COREUOBJECT_API void AddCookLoadDependency(UE::Cook::FCookDependency BuildDependency);
 
    COREUOBJECT_API void AddCookSaveDependency(UE::Cook::FCookDependency BuildDependency);
    COREUOBJECT_API void AddCookRuntimeDependency(FSoftObjectPath Dependency);
    COREUOBJECT_API void HarvestCookRuntimeDependencies(UObject* HarvestReferencesFrom);
 
    COREUOBJECT_API bool IsDeterminismDebug() const;
    COREUOBJECT_API void RegisterDeterminismHelper(const TRefCountPtr<UE::Cook::IDeterminismHelper>& DeterminismHelper);
    COREUOBJECT_API void RequestPostSaveSerialization();
#endif
 
    bool IsProceduralSave() const { return Data.bProceduralSave; }
 
    bool IsFromAutoSave() const { return (Data.SaveFlags & SAVE_FromAutosave) != 0; }
 
    bool IsUpdatingLoadedPath() const { return Data.bUpdatingLoadedPath; }
 
    uint32 GetSaveFlags() const { return Data.SaveFlags; }
 
    bool IsFirstConcurrentSave() const { return Data.bOuterConcurrentSave; }
 
protected:
    FObjectSaveContextData& Data;
};
 
class FObjectPostSaveContext
{
public:
    explicit FObjectPostSaveContext(FObjectSaveContextData& InData)
        : Data(InData)
    {
        ++Data.NumRefPasses; // Record the number of copies; used to check whether PreSave is overridden
    }
 
    FObjectPostSaveContext(const FObjectPostSaveContext& Other)
        : Data(Other.Data)
    {
        ++Data.NumRefPasses; // Record the number of copies; used to check whether PreSave is overridden
    }
 
    const TCHAR* GetTargetFilename() const { return *Data.TargetFilename; }
 
    bool IsCooking() const { return Data.TargetPlatform != nullptr; }
 
    const ITargetPlatform* GetTargetPlatform() const { return Data.TargetPlatform; }
 
    bool IsCookByTheBook() const { return GetCookType() == UE::Cook::ECookType::ByTheBook; }
    bool IsCookOnTheFly() const { return GetCookType() == UE::Cook::ECookType::OnTheFly; }
    bool IsCookTypeUnknown() const { return GetCookType() == UE::Cook::ECookType::Unknown; }
    UE::Cook::ECookType GetCookType() const { return Data.CookType; }
    UE::Cook::ECookingDLC GetCookingDLC() const { return Data.CookingDLC; }
 
    bool IsProceduralSave() const { return Data.bProceduralSave; }
 
    bool IsFromAutoSave() const { return (Data.SaveFlags & SAVE_FromAutosave) != 0; }
 
    bool IsUpdatingLoadedPath() const { return Data.bUpdatingLoadedPath; }
 
    uint32 GetSaveFlags() const { return Data.SaveFlags; }
 
    uint32 GetOriginalPackageFlags() const { return Data.OriginalPackageFlags; }
 
    bool SaveSucceeded() const { return Data.bSaveSucceeded; }
 
    bool IsLastConcurrentSave() const { return Data.bOuterConcurrentSave; }
 
    EObjectSaveContextPhase GetPhase() const { return Data.ObjectSaveContextPhase; }
 
protected:
    FObjectSaveContextData& Data;
    friend class UObject;
};
 
class FObjectPreSaveRootContext : public FObjectPreSaveContext
{
public:
    explicit FObjectPreSaveRootContext(FObjectSaveContextData& InData)
        : FObjectPreSaveContext(InData)
    {
    }
 
    FObjectPreSaveRootContext(const FObjectPreSaveRootContext& Other)
        : FObjectPreSaveContext(Other.Data)
    {
    }
 
    void SetCleanupRequired(bool bCleanupRequired) { Data.bCleanupRequired = bCleanupRequired; }
 
};
 
class FObjectPostSaveRootContext : public FObjectPostSaveContext
{
public:
    explicit FObjectPostSaveRootContext(FObjectSaveContextData& InData)
        : FObjectPostSaveContext(InData)
    {
    }
 
    FObjectPostSaveRootContext(const FObjectPostSaveRootContext& Other)
        : FObjectPostSaveContext(Other.Data)
    {
    }
 
    bool IsCleanupRequired() const { return Data.bCleanupRequired; }
};