SavePackage.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/UnrealString.h"
#include "CoreGlobals.h"
#include "CoreTypes.h"
#include "Delegates/Delegate.h"
#include "Logging/LogMacros.h"
#include "Misc/DateTime.h"
#include "Misc/EnumClassFlags.h"
#include "Misc/Optional.h"
#include "Misc/OutputDeviceError.h"
#include "ObjectMacros.h"
#include "Serialization/ArchiveCookData.h"
#include "Serialization/ArchiveUObject.h"
#include "Serialization/FileRegions.h"
#include "Serialization/PackageWriter.h"
#include "Templates/Function.h"
#include "Templates/UniquePtr.h"
#include "Templates/UnrealTemplate.h"
#include "UObject/NameTypes.h"
#include "UObject/ObjectSaveOverride.h"
#include "UObject/Package.h"
 
class ITargetPlatform;
class UObject;
 
#if !defined(UE_WITH_SAVEPACKAGE)
#   define UE_WITH_SAVEPACKAGE 1
#endif
 
class FArchive;
class FCbFieldView;
class FCbWriter;
class FIoBuffer;
class FOutputDevice;
class FPackagePath;
class FSavePackageContext;
class IPackageWriter;
namespace UE { class FLogRecord; }
struct FArchiveSavePackageData;
struct FObjectSaveContextData;
 
struct FPackageSaveInfo
{
    class UPackage* Package = nullptr;
    class UObject* Asset = nullptr;
    FString Filename;
};
 
struct FSavePackageArgs
{
    /* nullptr if not cooking, passed to the FArchive */
    FArchiveCookData* ArchiveCookData = nullptr;
 
    bool IsCooking() const { return ArchiveCookData != nullptr; }
    const ITargetPlatform* GetTargetPlatform() const { return ArchiveCookData ? &ArchiveCookData->TargetPlatform : nullptr; }
    
    EObjectFlags TopLevelFlags = RF_NoFlags;
    /* Flags to control saving, a bitwise-or'd combination of values from ESaveFlags */
    uint32 SaveFlags = SAVE_None;
    /* Whether we should forcefully byte swap before writing header and exports to disk. Passed into FLinkerSave. */
    bool bForceByteSwapping = false;
    /* If true (the default), warn when saving to a long filename. */
    bool bWarnOfLongFilename = true;
    bool bSlowTask = true;
    /*
     * If not FDateTime::MinValue() (the default), the timestamp the saved file should be set to.
     * (Intended for cooking only...)
     */
    FDateTime FinalTimeStamp;
    FOutputDevice* Error = GError;
    FSavePackageContext* SavePackageContext = nullptr;
 
    TMap<UObject*, FObjectSaveOverride>* InOutSaveOverrides = nullptr;
 
    FSavePackageArgs() = default;
    FSavePackageArgs(const FSavePackageArgs&) = default;
    FSavePackageArgs(FSavePackageArgs&&) = default;
    FSavePackageArgs& operator=(const FSavePackageArgs&) = default;
    FSavePackageArgs& operator=(FSavePackageArgs&&) = default;
 
    UE_DEPRECATED(5.6, "Use the default constructor and assign elements individually.")
    FSavePackageArgs(
        const ITargetPlatform* InTargetPlatform,
        FArchiveCookData* InArchiveCookData,
        EObjectFlags InTopLevelFlags,
        uint32 InSaveFlags,
        bool bInForceByteSwapping,
        bool bInWarnOfLongFilename,
        bool bInSlowTask,
        FDateTime InFinalTimeStamp,
        FOutputDevice* InError,
        FSavePackageContext* InSavePackageContext = nullptr
    )
    : ArchiveCookData(InArchiveCookData)
    , TopLevelFlags(InTopLevelFlags)
    , SaveFlags(InSaveFlags)
    , bForceByteSwapping(bInForceByteSwapping)
    , bWarnOfLongFilename(bInWarnOfLongFilename)
    , bSlowTask(bInSlowTask)
    , FinalTimeStamp(InFinalTimeStamp)
    , Error(InError)
    , SavePackageContext(InSavePackageContext)
    {
    }
};
 
class UE_DEPRECATED(5.2, "Use a FSavePackageContext::ExternalValidationFunc if you need to run external validation") ISavePackageValidator;
class ISavePackageValidator
{
public:
    virtual ~ISavePackageValidator()
    {
    }
 
    virtual ESavePackageResult ValidateImports(const UPackage* Package, const TSet<TObjectPtr<UObject>>& Imports) = 0;
};
 
 
struct FImportsValidationContext
{
    FImportsValidationContext(const UPackage* InPackage, const TSet<TObjectPtr<UObject>>& InImports, FOutputDevice* InOutputDevice)
        : Package(InPackage)
        , Imports(InImports)
        , OutputDevice(InOutputDevice)
    {}
 
    const UPackage* Package;
    const TSet<TObjectPtr<UObject>>& Imports;
    FOutputDevice* OutputDevice;
};
 
struct FExportsValidationContext
{
    enum class EFlags
    {
        None        = 0,
        IsCooking   = 1 << 0,
    };
 
    FExportsValidationContext(const UPackage* InPackage, const TSet<UObject*>& InExports, const TMap<UObject*, FObjectSaveOverride>& InSaveOverrides, 
        EFlags InFlags, FOutputDevice* InOutputDevice)
        : Package(InPackage)
        , Exports(InExports)
        , SaveOverrides(InSaveOverrides)
        , Flags(InFlags)
        , OutputDevice(InOutputDevice)
    {}
 
    const UPackage* Package;
    const TSet<UObject*>& Exports;
    const TMap<UObject*, FObjectSaveOverride>& SaveOverrides;
    const EFlags Flags;
    FOutputDevice* OutputDevice;
};
ENUM_CLASS_FLAGS(FExportsValidationContext::EFlags)
 
 
class FSavePackageSettings
{
public:
    typedef ESavePackageResult ExternalImportValidationFunc(const FImportsValidationContext& InValidationContext);
    typedef ESavePackageResult ExternalExportValidationFunc(const FExportsValidationContext& InValidationContext);
    
    FSavePackageSettings() = default;
 
    COREUOBJECT_API static FSavePackageSettings& GetDefaultSettings();
 
    bool IsDefault() const
    {
        return ExternalImportValidations.Num() == 0 && ExternalExportValidations.Num() == 0;
    }
 
    const TArray<TFunction<ExternalImportValidationFunc>>& GetExternalImportValidations() const
    {
        return ExternalImportValidations;
    }
    const TArray<TFunction<ExternalExportValidationFunc>>& GetExternalExportValidations() const
    {
        return ExternalExportValidations;
    }
 
    void AddExternalImportValidation(TFunction<ExternalImportValidationFunc> InValidation)
    {
        ExternalImportValidations.Add(MoveTemp(InValidation));
    }
    void AddExternalExportValidation(TFunction<ExternalExportValidationFunc> InValidation)
    {
        ExternalExportValidations.Add(MoveTemp(InValidation));
    }
 
private:
    TArray<TFunction<ExternalImportValidationFunc>> ExternalImportValidations;
    TArray<TFunction<ExternalExportValidationFunc>> ExternalExportValidations;
};
 
class FSavePackageContext
{
public:
 
    FSavePackageContext(const ITargetPlatform* InTargetPlatform, IPackageWriter* InPackageWriter, FSavePackageSettings InSettings = FSavePackageSettings())
    : TargetPlatform(InTargetPlatform)
    , PackageWriter(InPackageWriter)
    , SavePackageSettings(MoveTemp(InSettings))
    {
        if (PackageWriter)
        {
            PackageWriterCapabilities = PackageWriter->GetCapabilities();
        }
    }
 
    UE_DEPRECATED(5.0, "bInForceLegacyOffsets is no longer supported; remove the variable from your constructor call")
    FSavePackageContext(const ITargetPlatform* InTargetPlatform, IPackageWriter* InPackageWriter, bool InbForceLegacyOffsets)
        : FSavePackageContext(InTargetPlatform, InPackageWriter)
    {
    }
 
    COREUOBJECT_API ~FSavePackageContext();
 
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
    ISavePackageValidator* GetValidator()
    {
        return Validator.Get(); 
    }
    void SetValidator(TUniquePtr<ISavePackageValidator>&& InValidator)
    {
        Validator = MoveTemp(InValidator);
    }
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
    const TArray<TFunction<FSavePackageSettings::ExternalImportValidationFunc>>& GetExternalImportValidations() const
    {
        return SavePackageSettings.GetExternalImportValidations();
    }
 
    const TArray<TFunction<FSavePackageSettings::ExternalExportValidationFunc>>& GetExternalExportValidations() const
    {
        return SavePackageSettings.GetExternalExportValidations();
    }
 
    const ITargetPlatform* const TargetPlatform;
    IPackageWriter* const PackageWriter;
    IPackageWriter::FCapabilities PackageWriterCapabilities;
 
private:
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
    TUniquePtr<ISavePackageValidator> Validator;
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
    FSavePackageSettings SavePackageSettings;
public:
 
    UE_DEPRECATED(5.0, "bForceLegacyOffsets is no longer supported; remove uses of the variable")
    const bool bForceLegacyOffsets = false;
};
 
namespace UE::SavePackageUtilities
{
    COREUOBJECT_API bool IsUpdatingLoadedPath(bool bIsCooking, const FPackagePath& TargetPackagePath, uint32 SaveFlags);
 
    COREUOBJECT_API bool IsProceduralSave(bool bIsCooking, const FPackagePath& TargetPackagePath, uint32 SaveFlags);
 
    COREUOBJECT_API void CallPreSave(UObject* Object, FObjectSaveContextData& ObjectSaveContext);
 
#if WITH_EDITOR
    COREUOBJECT_API void CallCookEventPlatformCookDependencies(UObject* Object, FObjectSaveContextData& ObjectSaveContext);
#endif
 
    COREUOBJECT_API void CallPreSaveRoot(UObject* Object, FObjectSaveContextData& ObjectSaveContext);
 
    COREUOBJECT_API void CallPostSaveRoot(UObject* Object, FObjectSaveContextData& ObjectSaveContext, bool bCleanupRequired);
 
    COREUOBJECT_API EObjectFlags NormalizeTopLevelFlags(EObjectFlags TopLevelFlags, bool bIsCooking);
 
    COREUOBJECT_API void IncrementOutstandingAsyncWrites();
    COREUOBJECT_API void DecrementOutstandingAsyncWrites();
 
    COREUOBJECT_API void ResetCookStats();
    COREUOBJECT_API int32 GetNumPackagesSaved();
 
    UE_DEPRECATED(5.6, "Functionality has moved into private cooker implementation; contact Epic if you need this functionality.")
    COREUOBJECT_API void StartSavingEDLCookInfoForVerification();
    using FEDLMessageCallback = TFunction<void(ELogVerbosity::Type, FStringView)>;
    using FEDLLogRecordCallback = TFunction<void(UE::FLogRecord&& Record)>;
    UE_DEPRECATED(5.6, "Functionality has moved into private cooker implementation; contact Epic if you need this functionality.")
    COREUOBJECT_API void VerifyEDLCookInfo(bool bFullReferencesExpected = true);
    UE_DEPRECATED(5.5, "Functionality has moved into private cooker implementation; contact Epic if you need this functionality.")
    COREUOBJECT_API void VerifyEDLCookInfo(const FEDLMessageCallback& MessageCallback, bool bFullReferencesExpected = true);
    UE_DEPRECATED(5.6, "Functionality has moved into private cooker implementation; contact Epic if you need this functionality.")
    COREUOBJECT_API void VerifyEDLCookInfo(const FEDLLogRecordCallback& MessageCallback, bool bFullReferencesExpected = true);
    UE_DEPRECATED(5.6, "Functionality has moved into private cooker implementation; contact Epic if you need this functionality.")
    COREUOBJECT_API void EDLCookInfoAddIterativelySkippedPackage(FName LongPackageName);
    UE_DEPRECATED(5.6, "Functionality has moved into private cooker implementation; contact Epic if you need this functionality.")
    COREUOBJECT_API void EDLCookInfoMoveToCompactBinaryAndClear(FCbWriter& Writer, bool& bOutHasData);
    UE_DEPRECATED(5.6, "Functionality has moved into private cooker implementation; contact Epic if you need this functionality.")
    COREUOBJECT_API void EDLCookInfoMoveToCompactBinaryAndClear(FCbWriter& Writer, bool& bOutHasData, FName PackageName);
    UE_DEPRECATED(5.6, "Functionality has moved into private cooker implementation; contact Epic if you need this functionality.")
    COREUOBJECT_API bool EDLCookInfoAppendFromCompactBinary(FCbFieldView Field);
 
    UE_DEPRECATED(5.5, "No longer used; skiponlyeditoronly is used instead and tracks editoronly references via savepackage results.")
    inline bool CanSkipEditorReferencedPackagesWhenCooking() { return false; }
 
 
#if WITH_EDITOR
    DECLARE_DELEGATE_TwoParams(FAddResaveOnDemandPackage, FName, FName);
    extern COREUOBJECT_API FAddResaveOnDemandPackage OnAddResaveOnDemandPackage;
#endif
 
}
 
namespace UE::SavePackageUtilities::Private
{
 
class FArchiveSavePackageCollector : public FArchiveUObject
{
public:
    FArchiveSavePackageCollector() = default;
    COREUOBJECT_API FArchiveSavePackageCollector(FArchiveSavePackageData& InSavePackageData,
        bool bFilterEditorOnly, bool bSaveUnversioned, bool bCooking);
 
    COREUOBJECT_API void SetArchiveFlags(FArchiveSavePackageData& InSavePackageData,
        bool bFilterEditorOnly, bool bSaveUnversioned, bool bCooking);
};
 
COREUOBJECT_API uint32 GetSavePackagePortFlags();
 
}
 
COREUOBJECT_API DECLARE_LOG_CATEGORY_EXTERN(LogSavePackage, Log, All);