PackageHarvester.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Map.h"
#include "Containers/Set.h"
#include "Containers/Queue.h"
#include "UObject/NameTypes.h"
#include "UObject/ObjectPtr.h"
#include "UObject/SavePackage.h"
 
enum class ESaveableStatus;
enum class ESaveRealm : uint32;
enum class EIllegalRefReason : uint8;
class FSaveContext;
class UObject;
namespace UE::SavePackageUtilities { struct FObjectStatus; }
struct FWeakObjectPtr;
struct FLazyObjectPtr;
struct FSoftObjectPath;
namespace Verse { struct VCell; }
 
class FPackageHarvester : public UE::SavePackageUtilities::Private::FArchiveSavePackageCollector
{
public:
    using FExportingRealmsArray = TArray<ESaveRealm, TInlineAllocator<2>>;
    struct FExportWithContext
    {
        /* Export to process. Only one of these two should be set. */
        UObject* Export = nullptr;
        Verse::VCell* CellExport = nullptr;
        /* The realms from which this export was harvested. */
        FExportingRealmsArray HarvestedFromRealms;
 
        operator bool() const
        {
            return Export != nullptr || CellExport != nullptr;
        }
    };
 
    class FHarvestScope
    {
    public:
        FHarvestScope(FPackageHarvester& InHarvester);
        FHarvestScope(FHarvestScope&& Other);
        FHarvestScope(const FHarvestScope& Other) = delete;
        FHarvestScope& operator=(FHarvestScope&& Other) = delete;
        FHarvestScope& operator=(const FHarvestScope& Other) = delete;
        ~FHarvestScope();
        bool IsEmpty() const;
    private:
        FPackageHarvester& Harvester;
        FExportingRealmsArray PreviousExportHarvestingRealms;
        bool bActive;
    };
 
public:
    FPackageHarvester(FSaveContext& InContext);
 
    FExportWithContext PopExportToProcess();
 
    void TryHarvestExport(UObject* InObject, UE::SavePackageUtilities::FObjectStatus& ObjectStatus);
    void ProcessExport(const FExportWithContext& InProcessContext);
#if WITH_VERSE_VM || defined(__INTELLISENSE__)
    void TryHarvestCellExport(Verse::VCell* InCell);
    void ProcessCellExport(const FExportWithContext& InProcessContext);
#endif
    FHarvestScope EnterRootReferencesScope();
 
    void HarvestExportDataName(FName Name);
    void HarvestPackageHeaderName(FName Name);
    void HarvestSearchableName(TObjectPtr<UObject> TypeObject, FName Name);
    void HarvestDependency(TObjectPtr<UObject> InObj, bool bIsNative);
 
    bool CurrentExportHasDependency(TObjectPtr<UObject> InObj, ESaveRealm HarvestingRealm) const;
    TMap<UObject*, TSet<FProperty*>> ReleaseTransientPropertyOverrides();
 
    // FArchiveUObject implementation
    virtual FString GetArchiveName() const override;
    virtual void MarkSearchableName(const TObjectPtr<const UObject>& TypeObject, const FName& ValueName) const override;
    virtual FArchive& operator<<(UObject*& Obj) override;
    virtual FArchive& operator<<(struct FWeakObjectPtr& Value) override;
    virtual FArchive& operator<<(FLazyObjectPtr& LazyObjectPtr) override;
    virtual FArchive& operator<<(FSoftObjectPath& Value) override;
    virtual FArchive& operator<<(FName& Name) override;
    virtual FArchive& operator<<(FObjectPtr& Value) override;
#if WITH_VERSE_VM || defined(__INTELLISENSE__)
    virtual FArchive& operator<<(Verse::VCell*& Cell) override;
#endif
 
    virtual bool ShouldSkipProperty(const FProperty* InProperty) const override;
 
    static bool IsObjNative(UObject* InObj);
    static bool ShouldObjectBeHarvestedInOptionalRealm(TObjectPtr<UObject> InObj, FSaveContext& InSaveContext);
 
private:
    struct FExportDependencies
    {
        UObject* CurrentExport = nullptr;
        Verse::VCell* CurrentCellExport = nullptr;
        TSet<TObjectPtr<UObject>> ObjectReferences;
        TSet<TObjectPtr<UObject>> NativeObjectReferences;
        TSet<Verse::VCell*> CellReferences;
        int32 ProcessImportDepth = 0;
        bool bIgnoreDependencies = false;
    };
 
    class FExportScope
    {
    public:
        FExportScope(FPackageHarvester& InHarvester, const FExportWithContext& InToProcess);
        ~FExportScope();
    private:
        FPackageHarvester& Harvester;
        FExportingRealmsArray PreviousExportHarvestingRealms;
        bool bPreviousFilterEditorOnly;
        bool bPreviousSavingOptionalObject;
    };
 
    class FIgnoreDependenciesScope
    {
    public:
        FIgnoreDependenciesScope(FPackageHarvester& InHarvester);
        ~FIgnoreDependenciesScope();
    private:
        FPackageHarvester& Harvester;
        bool bPreviousValue;
    };
 
private:
 
    template <typename CallbackType>
    void ForEachExportHarvestingRealm(CallbackType&& Callback);
    bool HasAnyExportHarvestingRealms();
 
    void ResolveOverrides();
 
    void TryHarvestExportInternal(UObject* InObject, UE::SavePackageUtilities::FObjectStatus& ObjectStatus);
    void HarvestExport(UObject* InObject, UE::SavePackageUtilities::FObjectStatus& ObjectStatus);
    void TryHarvestImport(TObjectPtr<UObject> InObject, UE::SavePackageUtilities::FObjectStatus& ObjectStatus);
    void HarvestImport(TObjectPtr<UObject> InObject, UE::SavePackageUtilities::FObjectStatus& ObjectStatus);
    void ProcessImport(TObjectPtr<UObject> InObject, UE::SavePackageUtilities::FObjectStatus& ObjectStatus);
    void SetInstigatorFromProcessingStack(UE::SavePackageUtilities::FObjectStatus& ObjectStatus,
        ESaveRealm HarvestingRealm);
 
#if WITH_VERSE_VM || defined(__INTELLISENSE__)
    void HarvestCellExport(Verse::VCell* InCell);
    void HarvestCellImport(Verse::VCell* InCell);
#endif
 
#if WITH_EDITORONLY_DATA
    void HarvestImportTypeHierarchyNames(const UObject* Import);
#endif
 
    void AppendCurrentExportDependencies();
    FString GetUnsaveableReason(UObject* Required, ESaveRealm RealmInWhichItIsUnsaveable);
    ESaveableStatus GetSaveableStatusForRealm(UObject* Obj, ESaveRealm RealmInWhichItIsUnsaveable,
        TObjectPtr<UObject>& OutCulprit, FString& OutReason);
 
    FHarvestScope EnterRealmsArrayScope(FExportingRealmsArray& Array);
    FHarvestScope EnterConditionalEditorOnlyScope(bool bIsEditorOnly);
    FHarvestScope EnterConditionalOptionalObjectScope(TObjectPtr<UObject> Object);
    FHarvestScope EnterNewExportOnlyScope(UObject* Export);
    FHarvestScope EnterNotExcludedScope(TObjectPtr<UObject> Object,
        UE::SavePackageUtilities::FObjectStatus& ObjectStatus);
    FHarvestScope EnterNotPreviouslyExcludedScope(TObjectPtr<UObject> Object);
    FHarvestScope EnterIncludedScope(TObjectPtr<UObject> Object);
    void GetPreviouslyIncludedRealms(TObjectPtr<UObject> Object, FExportingRealmsArray& OutAlreadyIncluded,
        FExportingRealmsArray& OutNotAlreadyIncluded);
 
    FHarvestScope EnterIncludedScope(Verse::VCell* Cell);
    void GetPreviouslyIncludedRealms(Verse::VCell* Cell, FExportingRealmsArray& OutAlreadyIncluded,
        FExportingRealmsArray& OutNotAlreadyIncluded);
 
    FSaveContext& SaveContext;
    TQueue<FExportWithContext> ExportsToProcess;
    FExportDependencies CurrentExportDependencies;
    TMap<UObject*, TSet<FProperty*>> TransientPropertyOverrides;
    FExportingRealmsArray CurrentExportHarvestingRealms;
};