Package.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Async/Future.h"
#include "Containers/Array.h"
#include "Containers/ArrayView.h"
#include "CoreGlobals.h"
#include "CoreMinimal.h"
#include "Delegates/Delegate.h"
#include "HAL/PlatformMath.h"
#include "IO/IoHash.h"
#include "IO/PackageId.h"
#include "Misc/AssertionMacros.h"
#include "Misc/DateTime.h"
#include "Misc/Guid.h"
#include "Misc/ObjectThumbnail.h"
#include "Misc/OutputDeviceError.h"
#include "Misc/PackagePath.h"
#include "Misc/SecureHash.h"
#include "Misc/WorldCompositionUtility.h"
#include "Serialization/CustomVersion.h"
#include "Templates/PimplPtr.h"
#include "Templates/UniquePtr.h"
#include "Templates/UnrealTemplate.h"
#include "UObject/NameTypes.h"
#include "UObject/Object.h"
#include "UObject/ObjectMacros.h"
#include "UObject/ObjectVersion.h"
#include "UObject/UObjectGlobals.h"
 
#if WITH_METADATA
#include "UObject/MetaData.h"
#endif
 
#if WITH_EDITORONLY_DATA
#include "IO/IoHash.h"
#endif
 
#if WITH_EDITOR
#include "Cooker/BuildResultDependenciesMap.h"
#endif
 
#include "Package.generated.h"
 
class Error;
class FArchive;
class FLinkerLoad;
// This is a dummy type which is not implemented anywhere. It's only
// used to flag a deprecated Conform argument to package save functions.
class FLinkerNull;
class FLinkerSave;
class FObjectPostSaveContext;
class FObjectPreSaveContext;
class FOutputDevice;
class FSavePackageContext;
class FString;
class ITargetPlatform;
class UFunction;
class UDEPRECATED_MetaData;
struct FAssetData;
struct FMD5Hash;
struct FPackageSaveInfo;
struct FSavePackageArgs;
 
#if WITH_EDITOR
namespace UE::Cook { class FCookDependency; }
#endif
 
enum class ESavePackageResult
{
    Success,
    Error,
    Canceled,
    ContainsEditorOnlyData,
    ReferencedOnlyByEditorOnlyData UE_DEPRECATED(5.6, "The cooker now uses SkipOnlyEditorOnly to detect ReferencedOnlyByEditorOnlyData instead of detecting it during SavePackage"),
    ReplaceCompletely,
    GenerateStub,
    DifferentContent    UE_DEPRECATED(5.0, "Diffing is now done using FDiffPackageWriter."),
    MissingFile,
    ValidatorError,
    ValidatorSuppress,
    EmptyRealm,
    Timeout,
};
 
inline bool IsSuccessful(ESavePackageResult Result)
{
    return
        Result == ESavePackageResult::Success ||
        Result == ESavePackageResult::GenerateStub ||
        Result == ESavePackageResult::ReplaceCompletely;
}
 
namespace UE::SavePackageUtilities
{
 
struct FPreloadDependency
{
    UObject* SourceObject;
    UObject* TargetObject;
    bool bSourceIsSerialize;
    bool bTargetIsSerialize;
};
 
}
struct FSavePackageResultStruct
{
    ESavePackageResult Result;
 
    int64 TotalFileSize;
 
    UE_DEPRECATED(5.1, "CookedHash is now available through PackageWriter->CommitPackage instead. For waiting on completion in the non-cook case, use UPackage::WaitForAsyncFileWrites.")
    TFuture<FMD5Hash> CookedHash;
 
    uint32 SerializedPackageFlags;
 
    UE_DEPRECATED(5.6, "Returning the LinkerSave for comparison is no longer used. Contact Epic if you need this functionality.")
    TPimplPtr<FLinkerSave> LinkerSave;
 
    TArray<FAssetData> SavedAssets;
 
    TArray<FName> ImportPackages;
    TArray<FName> SoftPackageReferences;
    TArray<FName> UntrackedSoftPackageReferences;
 
#if WITH_EDITOR
    UE_DEPRECATED(5.6, "Use BuildResultDependencies instead..")
    TArray<UE::Cook::FCookDependency> CookDependencies;
    UE::Cook::FBuildResultDependenciesMap BuildResultDependencies;
 
    TArray<UObject*> Imports;
    TArray<UObject*> Exports;
    UE_INTERNAL TArray<UE::SavePackageUtilities::FPreloadDependency> PreloadDependencies;
#endif
 
    COREUOBJECT_API FSavePackageResultStruct();
    COREUOBJECT_API FSavePackageResultStruct(ESavePackageResult InResult);
    COREUOBJECT_API FSavePackageResultStruct(ESavePackageResult InResult, int64 InTotalFileSize);
    COREUOBJECT_API FSavePackageResultStruct(ESavePackageResult InResult, int64 InTotalFileSize,
        uint32 InSerializedPackageFlags);
    UE_DEPRECATED(5.6, "Returning the LinkerSave for comparison is no longer used. Contact Epic if you need this functionality.")
    COREUOBJECT_API FSavePackageResultStruct(ESavePackageResult InResult, int64 InTotalFileSize,
        uint32 InSerializedPackageFlags, TPimplPtr<FLinkerSave> Linker);
    COREUOBJECT_API FSavePackageResultStruct(FSavePackageResultStruct&& Other);
    COREUOBJECT_API FSavePackageResultStruct& operator=(FSavePackageResultStruct&& Other);
    COREUOBJECT_API ~FSavePackageResultStruct();
 
    bool operator==(const FSavePackageResultStruct& Other) const
    {
        return Result == Other.Result;
    }
 
    bool operator!=(const FSavePackageResultStruct& Other) const
    {
        return Result != Other.Result;
    }
 
    bool IsSuccessful() const
    {
        return ::IsSuccessful(Result);
    }
};
 
enum class EAssetAccessSpecifier : uint8
{
    Private,
    Public,
    EpicInternal,
};
 
PRAGMA_DISABLE_DEPRECATION_WARNINGS // Required for auto-generated functions referencing PackageFlags
UCLASS(MinimalAPI, Config=Engine)
class UPackage : public UObject
{
    GENERATED_BODY()
 
    
    UPackage(FVTableHelper& Helper)
        : Super(Helper)
    {
    };
 
    friend UDEPRECATED_MetaData;
 
public:
 
    UPackage(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get())
        : Super(ObjectInitializer)
    {
    }
 
    ~UPackage() = default;
 
#if UE_WITH_CONSTINIT_UOBJECT
    explicit consteval UPackage(UE::CodeGen::ConstInit::FPackageParams InParams)
        : UObject(InParams.Object)
        , bDirty(false)
#if WITH_EDITORONLY_DATA
        , bIsDynamicPIEPackagePending(false)
#endif
        , bHasBeenFullyLoaded(false)
        , bCanBeImported(false)
#if WITH_EDITORONLY_DATA
        , PersistentGuid(FGuid(InParams.BodiesHash, InParams.DeclarationsHash, 0, 0))
        , ChunkIDs(ConstEval)
#endif
        , PackageFlagsPrivate(InParams.Flags)
        , PackageId()
        , LoadedPath()
#if WITH_METADATA
        , MetaData(ConstEval)
#endif
#if WITH_EDITORONLY_DATA
        , PIEInstanceID(INDEX_NONE)
#endif
    {
 
    }
#endif
 
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnPackageDirtyStateChanged, class UPackage*);
    DECLARE_MULTICAST_DELEGATE_TwoParams(FOnPackageSaved, const FString&, UObject*);                    
    DECLARE_MULTICAST_DELEGATE_ThreeParams(FOnPackageSavedWithContext, const FString&, UPackage*, FObjectPostSaveContext);
    DECLARE_MULTICAST_DELEGATE_TwoParams(FOnPackageMarkedDirty, class UPackage*, bool);
    DECLARE_MULTICAST_DELEGATE_OneParam(FPreSavePackage, class UPackage*);
    DECLARE_MULTICAST_DELEGATE_TwoParams(FPreSavePackageWithContext, class UPackage*, FObjectPreSaveContext);
 
#if WITH_METADATA
    DECLARE_MULTICAST_DELEGATE_FourParams(FOnMetaDataTransferRequestedDelegate, const FMetaData& OldMetaData, FMetaData& NewMetaData, const UPackage* OldPackage, UPackage* NewPackage);
#endif
    
    UE_DEPRECATED(5.0, "Use PreSavePackageWithContextEvent instead.")
    COREUOBJECT_API static FPreSavePackage PreSavePackageEvent;
    COREUOBJECT_API static FPreSavePackageWithContext PreSavePackageWithContextEvent;
    UE_DEPRECATED(5.0, "Use PackageSavedWithContextEvent instead.")
    COREUOBJECT_API static FOnPackageSaved PackageSavedEvent;
    COREUOBJECT_API static FOnPackageSavedWithContext PackageSavedWithContextEvent;
    COREUOBJECT_API static FOnPackageDirtyStateChanged PackageDirtyStateChangedEvent;
    COREUOBJECT_API static FOnPackageMarkedDirty PackageMarkedDirtyEvent;
 
#if WITH_METADATA
    COREUOBJECT_API static FOnMetaDataTransferRequestedDelegate OnMetaDataTransferRequestedDelegate;
#endif
private:
    uint8   bDirty:1;
 
#if WITH_EDITORONLY_DATA
    uint8 bIsDynamicPIEPackagePending:1;
#endif
 
public:
    mutable uint8 bHasBeenFullyLoaded:1;
 
    uint8 bCanBeImported:1;
 
#if WITH_EDITORONLY_DATA
    bool bIsCookedForEditor{ false };
 
private:
    std::atomic<bool> bHasBeenEndLoaded{ false };
 
public:
    bool GetHasBeenEndLoaded() const
    {
        return bHasBeenEndLoaded.load(std::memory_order_acquire) != 0;
    }
    void SetHasBeenEndLoaded(bool bValue)
    {
        bHasBeenEndLoaded.store(bValue, std::memory_order_release);
    }
#endif
 
private:
#if WITH_EDITORONLY_DATA
    FGuid PersistentGuid;
 
    TArray<int32> ChunkIDs;
 
    FIoHash SavedHash;
#endif // WITH_EDITORONLY_DATA
 
    std::atomic<uint32> PackageFlagsPrivate;
    
    FPackageId PackageId;
 
    FPackagePath LoadedPath;
 
    // @note this should probably be entirely deprecated and removed but certain stat dump function are still using it,
    // just compile it out in shipping for now
#if !UE_BUILD_SHIPPING
    float LoadTime = 0.0f;
#endif
 
    struct FAdditionalInfo
    {
        FPackageFileVersion LinkerPackageVersion = GPackageFileUEVersion;
 
        int32 LinkerLicenseeVersion = GPackageFileLicenseeUEVersion;
 
    FCustomVersionContainer LinkerCustomVersion;
 
        FLinkerLoad* LinkerLoad = nullptr;
 
        uint64 FileSize = 0;
 
        // World browser information
        TUniquePtr< FWorldTileInfo > WorldTileInfo;
    };
    
    TUniquePtr<FAdditionalInfo> AdditionalInfo;
 
#if WITH_METADATA
    // MetaData for the editor
    FMetaData MetaData;
 
    // Deprecated UMetaData member when loading older packages
    UE_DEPRECATED(5.6, "UMetaData was replaced by FMetaData, this member is only used for migrating t he existing data, do not use.")
    UDEPRECATED_MetaData* DeprecatedMetaData = nullptr;
#endif // WITH_METADATA
 
#if WITH_EDITORONLY_DATA
    TUniquePtr< FThumbnailMap > ThumbnailMap;
 
    int32 PIEInstanceID;
#endif
 
#if WITH_RELOAD
    TArray<UFunction*> Delegates;
#endif
 
public:
 
    // For now, assume all packages have stable net names
    virtual bool IsNameStableForNetworking() const override { return true; }
    // We override NeedsLoadForClient to avoid calling the expensive generic version, which only makes sure that the
    // UPackage static class isn't excluded
    virtual bool NeedsLoadForClient() const override { return true; }
    virtual bool NeedsLoadForServer() const override { return true; }
    COREUOBJECT_API virtual bool IsPostLoadThreadSafe() const override;
    COREUOBJECT_API virtual bool Rename(const TCHAR* NewName = nullptr, UObject* NewOuter = nullptr, ERenameFlags Flags = REN_None) override;
 
#if WITH_EDITORONLY_DATA
    UE_DEPRECATED(5.5, "No longer used; skiponlyeditoronly is used instead and tracks editoronly references via savepackage results.")
    void SetLoadedByEditorPropertiesOnly(bool bIsEditorOnly, bool bRecursive = false) {}
    UE_DEPRECATED(5.5, "No longer used; skiponlyeditoronly is used instead and tracks editoronly references via savepackage results.")
    bool IsLoadedByEditorPropertiesOnly() const { return false; }
 
    void SetDynamicPIEPackagePending(bool bInIsDynamicPIEPackagePending)
    {
        bIsDynamicPIEPackagePending = bInIsDynamicPIEPackagePending;
    }
    bool IsDynamicPIEPackagePending() const { return bIsDynamicPIEPackagePending; }
#endif
 
    COREUOBJECT_API virtual void PostInitProperties() override;
 
    COREUOBJECT_API virtual void FinishDestroy() override;
 
    COREUOBJECT_API virtual void Serialize( FArchive& Ar ) override;
 
    virtual bool IsAsset() const override { return false; }
 
#if WITH_EDITOR
    COREUOBJECT_API static bool bSupportCookerSoftGC;
    COREUOBJECT_API static TMap<UPackage*, TArrayView<TObjectPtr<UObject>>> SoftGCPackageToObjectList;
    COREUOBJECT_API static void AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector);
#endif
 
    // UPackage interface.
 
private:
    friend class FLinkerLoad;
    friend class FUnsafeLinkerLoad;
    friend class FSaveContext;
    friend struct FAsyncPackage2;
 
    void SetLinker(FLinkerLoad* InLinker)
    {
        LLM_SCOPE_BYNAME(TEXT("Package/AdditionalInfo"));
        if (AdditionalInfo.IsValid())
        {
            AdditionalInfo->LinkerLoad = InLinker;
        }
        else if (InLinker != nullptr)
        {
            AdditionalInfo = MakeUnique<FAdditionalInfo>();
            AdditionalInfo->LinkerLoad = InLinker;
        }
    }
 
    void SetLinkerPackageVersion(FPackageFileVersion InVersion)
    {
        LLM_SCOPE_BYNAME(TEXT("Package/AdditionalInfo"));
        if (AdditionalInfo.IsValid())
        {
            AdditionalInfo->LinkerPackageVersion = MoveTemp(InVersion);
        }
        else if (InVersion != GPackageFileUEVersion)
        {
            AdditionalInfo = MakeUnique<FAdditionalInfo>();
            AdditionalInfo->LinkerPackageVersion = MoveTemp(InVersion);
        }
    }
 
    void SetLinkerLicenseeVersion(int32 InVersion)
    {
        LLM_SCOPE_BYNAME(TEXT("Package/AdditionalInfo"));
        if (AdditionalInfo.IsValid())
        {
            AdditionalInfo->LinkerLicenseeVersion = InVersion;
        }
        else if (InVersion != GPackageFileLicenseeUEVersion)
        {
            AdditionalInfo = MakeUnique<FAdditionalInfo>();
            AdditionalInfo->LinkerLicenseeVersion = InVersion;
        }
    }
 
    void SetLinkerCustomVersions(FCustomVersionContainer InVersions)
    {
        LLM_SCOPE_BYNAME(TEXT("Package/AdditionalInfo"));
        if (AdditionalInfo.IsValid())
        {
            AdditionalInfo->LinkerCustomVersion = MoveTemp(InVersions);
        }
        else if (!InVersions.GetAllVersions().IsEmpty())
        {
            AdditionalInfo = MakeUnique<FAdditionalInfo>();
            AdditionalInfo->LinkerCustomVersion = MoveTemp(InVersions);
        }
    }
 
    void SetFileSize(int64 InFileSize)
    {
        LLM_SCOPE_BYNAME(TEXT("Package/AdditionalInfo"));
        if (AdditionalInfo.IsValid())
        {
            AdditionalInfo->FileSize = InFileSize;
        }
        else if (InFileSize != 0)
        {
            AdditionalInfo = MakeUnique<FAdditionalInfo>();
            AdditionalInfo->FileSize = MoveTemp(InFileSize);
        }
    }
 
public:
 
    int32 GetPIEInstanceID() const
    {
#if WITH_EDITORONLY_DATA
        return PIEInstanceID;
#else
        return INDEX_NONE;
#endif
    }
 
    void SetPIEInstanceID(int32 InPIEInstanceID)
    {
#if WITH_EDITORONLY_DATA
        PIEInstanceID = InPIEInstanceID;
#endif
    }
 
    FLinkerLoad* GetLinker() const
    {
        return AdditionalInfo.IsValid() ? AdditionalInfo->LinkerLoad : nullptr;
    }
 
    const FPackageFileVersion& GetLinkerPackageVersion() const
    {
        return AdditionalInfo.IsValid() ? AdditionalInfo->LinkerPackageVersion : GPackageFileUEVersion;
    }
 
    int32 GetLinkerLicenseeVersion() const
    {
        return AdditionalInfo.IsValid() ? AdditionalInfo->LinkerLicenseeVersion : GPackageFileLicenseeUEVersion;
    }
 
    const FCustomVersionContainer& GetLinkerCustomVersions() const
    {
        static FCustomVersionContainer EmptyVersions;
        return AdditionalInfo.IsValid() ? AdditionalInfo->LinkerCustomVersion : EmptyVersions;
    }
 
private:
    void EmptyLinkerCustomVersion()
    {
        if (AdditionalInfo.IsValid())
        {
            AdditionalInfo->LinkerCustomVersion.Empty();
        }
    }
 
public:
    void SetLoadTime( float InLoadTime ) 
    {
#if !UE_BUILD_SHIPPING
        LoadTime = InLoadTime;
#endif
    }
 
    float GetLoadTime() const
    {
#if !UE_BUILD_SHIPPING
        return LoadTime;
#else
        return 0.0f;
#endif
    }
 
    void ClearDirtyFlag()
    {
        bDirty = false;
    }
 
    COREUOBJECT_API void SetDirtyFlag( bool bIsDirty );
 
    bool IsDirty() const
    {
        return bDirty;
    }
 
#if WITH_EDITOR
    void MarkAsNewlyCreated()
    {
        MarkAsUnloaded();
        SetPackageFlags(PKG_NewlyCreated);
        SetFileSize(0);
    }
 
    void MarkAsUnloaded()
    {
        bHasBeenFullyLoaded = false;
        ClearFlags(RF_WasLoaded);
    }
#endif
 
    void MarkAsFullyLoaded()
    {
        bHasBeenFullyLoaded = true;
    }
 
    COREUOBJECT_API bool IsFullyLoaded() const;
 
    COREUOBJECT_API void FullyLoad();
 
    COREUOBJECT_API const FPackagePath& GetLoadedPath() const;
 
    COREUOBJECT_API void SetLoadedPath(const FPackagePath& PackagePath);
 
    void SetCanBeImportedFlag(bool bInCanBeImported)
    {
        bCanBeImported = bInCanBeImported;
    }
 
    bool CanBeImported() const
    {
        return bCanBeImported;
    }
 
    void ThisContainsMap() 
    {
        SetPackageFlags(PKG_ContainsMap);
    }
 
    bool ContainsMap() const
    {
        return HasAnyPackageFlags(PKG_ContainsMap);
    }
 
    void ThisRequiresLocalizationGather(bool Value)
    {
        if(Value)
        {
            SetPackageFlags(PKG_RequiresLocalizationGather);
        }
        else
        {
            ClearPackageFlags(PKG_RequiresLocalizationGather);
        }
    }
 
    bool RequiresLocalizationGather() const
    {
        return HasAnyPackageFlags(PKG_RequiresLocalizationGather);
    }
 
    void ThisShouldLoadUncooked(const FArchive& Ar)
    {
        if (Ar.IsSaving() && Ar.IsCooking())
        {
            SetPackageFlags(PKG_LoadUncooked);
        }
    }
 
 
    inline void SetPackageFlagsTo( uint32 NewFlags )
    {
        uint32 OldFlags = GetPackageFlags();
 
        // Fast path without atomics if already set
        if (NewFlags == OldFlags)
        {
            return;
        }
 
        if (AutoRTFM::IsClosed())
        {
            UE_AUTORTFM_OPEN
            {
                OldFlags = PackageFlagsPrivate.exchange(NewFlags, std::memory_order_relaxed);
            };
 
            // If we abort we undo setting the flags we just set.
            AutoRTFM::OnAbort([this, OldFlags]
                {
                    PackageFlagsPrivate.store(OldFlags, std::memory_order_relaxed);
                });
        }
        else
        {
            PackageFlagsPrivate.store(NewFlags, std::memory_order_relaxed);
        }
    }
 
    inline void SetPackageFlags( uint32 FlagsToSet )
    {
        uint32 OldFlags = GetPackageFlags();
        uint32 NewFlags = OldFlags | FlagsToSet;
 
        // Fast path without atomics if already set
        if (NewFlags == OldFlags)
        {
            return;
        }
 
        if (AutoRTFM::IsClosed())
        {
            UE_AUTORTFM_OPEN
            {
                OldFlags = PackageFlagsPrivate.fetch_or(FlagsToSet, std::memory_order_relaxed);
            };
 
            // If we abort we undo setting the flags we just set.
            AutoRTFM::OnAbort([this, OldFlags, FlagsToSet]
                {
                    uint32 MaskFlags = OldFlags;
 
                    // Now just extract out the old flags that mattered (the ones we were setting).
                    MaskFlags &= FlagsToSet;
                    // And unmask the flags we didn't mention.
                    MaskFlags |= ~FlagsToSet;
 
                    PackageFlagsPrivate.fetch_and(MaskFlags, std::memory_order_relaxed);
                });
        }
        else
        {
            PackageFlagsPrivate.fetch_or(FlagsToSet, std::memory_order_relaxed);
        }
    }
 
    inline void ClearPackageFlags( uint32 FlagsToClear )
    {
        uint32 OldFlags = GetPackageFlags();
        uint32 NewFlags = OldFlags & ~FlagsToClear;
 
        // Fast path without atomics if already cleared
        if (NewFlags == OldFlags)
        {
            return;
        }
 
        if (AutoRTFM::IsClosed())
        {
            UE_AUTORTFM_OPEN 
            {
                OldFlags = PackageFlagsPrivate.fetch_and(~FlagsToClear, std::memory_order_relaxed);
            };
 
            // If we abort we undo clearing the flags we just unset.
            AutoRTFM::OnAbort([this, OldFlags, FlagsToClear]
            {
                int32 MaskFlags = OldFlags;
 
                // Now just extract out the old flags that mattered (the ones we were setting).
                MaskFlags &= FlagsToClear;
 
                PackageFlagsPrivate.fetch_or(MaskFlags, std::memory_order_relaxed);
            });
        }
        else
        {
            PackageFlagsPrivate.fetch_and(~FlagsToClear, std::memory_order_relaxed);
        }
    }
 
    UE_FORCEINLINE_HINT bool HasAnyPackageFlags( uint32 FlagsToCheck ) const
    {
        return (GetPackageFlags() & FlagsToCheck) != 0;
    }
 
    UE_FORCEINLINE_HINT bool HasAllPackagesFlags( uint32 FlagsToCheck ) const
    {
        return ((GetPackageFlags() & FlagsToCheck) == FlagsToCheck);
    }
 
    inline uint32 GetPackageFlags() const
    {
        uint32 Result = 0;
 
        UE_AUTORTFM_OPEN
        {
            Result = PackageFlagsPrivate.load(std::memory_order_relaxed);
        };
 
        return Result;
    }
 
    UE_FORCEINLINE_HINT bool IsExternallyReferenceable() const
    {
        return GetAssetAccessSpecifier() == EAssetAccessSpecifier::Public;
    }
 
    UE_FORCEINLINE_HINT void SetIsExternallyReferenceable(bool bValue)
    {
        SetAssetAccessSpecifier(bValue ? EAssetAccessSpecifier::Public : EAssetAccessSpecifier::Private);
    }
 
    inline EAssetAccessSpecifier GetAssetAccessSpecifier() const
    {
        if (HasAnyPackageFlags(PKG_NotExternallyReferenceable))
        {
            return EAssetAccessSpecifier::Private;
        }
        else if (HasAnyPackageFlags(PKG_AccessSpecifierEpicInternal))
        {
            return EAssetAccessSpecifier::EpicInternal;
        }
 
        return EAssetAccessSpecifier::Public;
    }
 
    inline bool SetAssetAccessSpecifier(const EAssetAccessSpecifier InAccessSpecifier)
    {
        if (GetAssetAccessSpecifier() == InAccessSpecifier)
        {
            return false;
        }
 
#if WITH_EDITOR
        Modify();
#endif
 
        ClearPackageFlags(PKG_NotExternallyReferenceable | PKG_AccessSpecifierEpicInternal);
 
        if (EAssetAccessSpecifier::Private == InAccessSpecifier)
        {
            SetPackageFlags(PKG_NotExternallyReferenceable);
        }
        else if (EAssetAccessSpecifier::EpicInternal == InAccessSpecifier)
        {
            SetPackageFlags(PKG_AccessSpecifierEpicInternal);
        }
 
        return true;
    }
 
#if WITH_EDITORONLY_DATA
    bool HasThumbnailMap() const
    {
        return ThumbnailMap.IsValid();
    }
 
    const FThumbnailMap& GetThumbnailMap() const
    {
        check( HasThumbnailMap() );
        return *ThumbnailMap;
    }
 
    FThumbnailMap& AccessThumbnailMap()
    {
        check( HasThumbnailMap() );
        return *ThumbnailMap;
    }
 
    void SetThumbnailMap(TUniquePtr<FThumbnailMap> InThumbnailMap)
    {
        ThumbnailMap = MoveTemp(InThumbnailMap);
    }
 
    UE_FORCEINLINE_HINT FGuid GetPersistentGuid() const
    {
        return PersistentGuid;
    }
    UE_FORCEINLINE_HINT void SetPersistentGuid(FGuid NewPersistentGuid)
    {
        PersistentGuid = NewPersistentGuid;
    }
 
    COREUOBJECT_API FIoHash GetSavedHash() const;
    COREUOBJECT_API void SetSavedHash(const FIoHash& InSavedHash);
#endif
 
#if WITH_RELOAD
    const TArray<UFunction*>& GetReloadDelegates() const
    {
        return Delegates;
    }
 
    void SetReloadDelegates(TArray<UFunction*> InDelegates) 
    {
        Delegates = MoveTemp(InDelegates);
    }
#endif
 
    FWorldTileInfo* GetWorldTileInfo() const
    {
        return AdditionalInfo.IsValid() ? AdditionalInfo->WorldTileInfo.Get() : nullptr;
    }
 
    void SetWorldTileInfo(TUniquePtr<FWorldTileInfo> InWorldTileInfo)
    {
        LLM_SCOPE_BYNAME(TEXT("Package/AdditionalInfo"));
        if (AdditionalInfo.IsValid())
        {
            AdditionalInfo->WorldTileInfo = MoveTemp(InWorldTileInfo);
        }
        else if (InWorldTileInfo.IsValid())
        {
            AdditionalInfo = MakeUnique<FAdditionalInfo>();
            AdditionalInfo->WorldTileInfo = MoveTemp(InWorldTileInfo);
        }
    }
 
    UE_FORCEINLINE_HINT int64 GetFileSize() const
    {
        return AdditionalInfo.IsValid() ? AdditionalInfo->FileSize : 0;
    }
 
    const TArray<int32>& GetChunkIDs() const
    {
#if WITH_EDITORONLY_DATA
        return ChunkIDs;
#else
        static TArray<int32> Dummy;
        return Dummy;
#endif
    }
 
    UE_FORCEINLINE_HINT void SetChunkIDs(const TArray<int32>& InChunkIDs)
    {
#if WITH_EDITORONLY_DATA
        ChunkIDs = InChunkIDs;
#endif
    }
 
    UE_FORCEINLINE_HINT FPackageId GetPackageId() const
    {
        return PackageId;
    }
 
    UE_FORCEINLINE_HINT void SetPackageId(FPackageId InPackageId)
    {
        PackageId = InPackageId;
    }
 
    UE_FORCEINLINE_HINT FPackageId GetPackageIdToLoad() const
    {
        return FPackageId::FromName(LoadedPath.GetPackageFName());
    }
 
    COREUOBJECT_API UObject* FindAssetInPackage(EObjectFlags RequiredTopLevelFlags = RF_NoFlags) const;
 
    COREUOBJECT_API TArray<UPackage*> GetExternalPackages() const;
 
    // MetaData 
 
#if WITH_METADATA
    COREUOBJECT_API FMetaData& GetMetaData();
#endif
 
    COREUOBJECT_API static FSavePackageResultStruct Save(UPackage* InOuter, UObject* InAsset, const TCHAR* Filename,
        const FSavePackageArgs& SaveArgs);
 
    COREUOBJECT_API static ESavePackageResult SaveConcurrent(TArrayView<FPackageSaveInfo> InPackages,
        const FSavePackageArgs& SaveArgs, TArray<FSavePackageResultStruct>& OutResults);
 
    COREUOBJECT_API static bool SavePackage(UPackage* InOuter, UObject* InAsset, const TCHAR* Filename,
        const FSavePackageArgs& SaveArgs);
 
    COREUOBJECT_API static void WaitForAsyncFileWrites();
 
    COREUOBJECT_API static bool HasAsyncFileWrites();
 
    COREUOBJECT_API static bool IsEmptyPackage(UPackage* Package, const UObject* LastReferencer = NULL);
 
private:
    static FSavePackageResultStruct Save2(UPackage* InPackage, UObject* InAsset, const TCHAR* InFilename, const FSavePackageArgs& SaveArgs);
};
PRAGMA_ENABLE_DEPRECATION_WARNINGS