LinkerLoad.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Async/Mutex.h"
#include "Async/RecursiveMutex.h"
#include "Containers/Array.h"
#include "Containers/Map.h"
#include "Containers/Set.h"
#include "Containers/UnrealString.h"
#include "CoreGlobals.h"
#include "CoreMinimal.h"
#include "HAL/LowLevelMemTracker.h"
#include "HAL/PlatformMath.h"
#include "HAL/ThreadSafeCounter.h"
#include "Misc/AssertionMacros.h"
#include "Misc/Optional.h"
#include "Misc/PackagePath.h"
#include "Serialization/Archive.h"
#include "Serialization/ArchiveUObject.h"
#include "Serialization/AsyncLoadingEvents.h"
#include "Serialization/StructuredArchive.h"
#include "Serialization/StructuredArchiveFwd.h"
#include "Serialization/StructuredArchiveSlots.h"
#include "Templates/UniquePtr.h"
#include "UObject/LazyObjectPtr.h"
#include "UObject/Linker.h"
#include "UObject/LinkerInstancingContext.h"
#include "UObject/NameTypes.h"
#include "UObject/ObjectHandle.h"
#include "UObject/ObjectMacros.h"
#include "UObject/ObjectResource.h"
#include "UObject/PackageResourceManager.h"
#include "UObject/PersistentObjectPtr.h"
#include "UObject/SoftObjectPath.h"
#include "UObject/SoftObjectPtr.h"
#include "UObject/UnrealNames.h"
 
class FBulkData;
class FLinkerLoad;
class FLinkerPlaceholderBase;
class FPackageIndex;
class FStructuredArchiveChildReader;
class IPakFile;
class UClass;
class ULinkerPlaceholderExportObject;
class UObject;
class UPackage;
class UStruct;
namespace UE::Serialization{ class FEditorBulkData; }
namespace UE::BulkData::Private{ class FBulkMetaData; }
namespace UE{ class FPackageTrailer; }
struct FObjectPtr;
struct FOpenPackageResult;
struct FScopedSlowTask;
struct FUObjectSerializeContext;
template <typename FuncType> class TFunction;
 
LLM_DECLARE_TAG(UObject_Linker);
 
/*----------------------------------------------------------------------------
    FLinkerLoad.
----------------------------------------------------------------------------*/
 
struct FDependencyRef
{
    FLinkerLoad* Linker;
 
    int32 ExportIndex;
 
    bool operator==(const FDependencyRef& Other) const
    {
        return Linker == Other.Linker && ExportIndex == Other.ExportIndex;
    }
 
    friend uint32 GetTypeHash( const FDependencyRef& Ref  );
};
 
struct FScopedCreateImportCounter
{
    FScopedCreateImportCounter(FLinkerLoad* Linker, int32 Index);
 
    ~FScopedCreateImportCounter();
 
    FUObjectSerializeContext* LoadContext;
    FLinkerLoad* PreviousLinker;
    int32 PreviousIndex;
};
 
class FAsyncArchive;
 
class FLinkerLoad 
#if !WITH_EDITOR && !WITH_LOW_LEVEL_TESTS
    final 
#endif
    : public FLinker, public FArchiveUObject
{
    // Friends.
    friend class UObject;
    friend class UPackageMap;
    friend struct FAsyncPackage;
    friend struct FAsyncPackage2;
    friend class FAsyncLoadingThread2;
    friend struct FResolvingExportTracker;
protected:
    enum ELinkerStatus
    {
        LINKER_Failed = 0,
        LINKER_Loaded = 1,
        LINKER_TimedOut = 2
    };
 
    enum EVerifyResult
    {
        VERIFY_Failed = 0,
        VERIFY_Success = 1,
        VERIFY_Redirected = 2
    };
 
    // Variables.
public:
 
    UE_FORCEINLINE_HINT static ELinkerType::Type StaticType()
    {
        return ELinkerType::Load;
    }
 
    virtual ~FLinkerLoad();
 
    uint32                  LoadFlags;
    bool                    bHaveImportsBeenVerified;
 
    UObject*                TemplateForGetArchetypeFromLoader;
    bool                    bForceSimpleIndexToObject;
    bool                    bLockoutLegacyOperations;
 
    // Used to protect LinkerLoad from multithreaded access
    UE::FRecursiveMutex     Mutex;
 
    bool                    bIsAsyncLoader;
    UE_FORCEINLINE_HINT FAsyncArchive* GetAsyncLoader()
    {
        return bIsAsyncLoader ? (FAsyncArchive*)Loader : nullptr;
    }
 
    virtual FString GetDebugName() const override
    {
        return GetPackagePath().GetDebugName();
    }
 
    const FPackagePath& GetPackagePath() const
    {
        return PackagePath;
    }
 
    UE_FORCEINLINE_HINT const FLinkerInstancingContext& GetInstancingContext() const
    {
        return InstancingContext;
    }
 
    const UE::FPackageTrailer* GetPackageTrailer() const
    {
        return PackageTrailer.Get();
    }
 
#if WITH_EDITOR
    bool IsPackageRelocated() const
    {
        return bIsPackageRelocated;
    }
#endif
 
private:
 
    bool                    bIsDestroyingLoader;
#if WITH_EDITOR
    bool                    bDetachedLoader;
#endif // WITH_EDITOR
 
    FStructuredArchive* StructuredArchive;
    FArchiveFormatterType* StructuredArchiveFormatter;
    TOptional<FStructuredArchive::FRecord> StructuredArchiveRootRecord;
    TArray<FStructuredArchiveChildReader*> ExportReaders;
    FPackagePath        PackagePath;
 
    void SetPackagePath(const FPackagePath& PackagePath);
 
    FArchive*               Loader;
 
    FLinkerInstancingContext InstancingContext;
 
    TUniquePtr<UE::FPackageTrailer> PackageTrailer;
 
    TSet<int32> ImportsToVerifyOnCreate;
 
    // Helper function to access the InstancingContext IsInstanced, 
    bool IsContextInstanced() const;
 
    // Helper function to query if we should do any SoftObjectPath fixup
    bool IsSoftObjectRemappingEnabled() const;
 
    void FixupSoftObjectPathForInstancedPackage(FSoftObjectPath& InOutSoftObjectPath);
 
protected:
 
    void SetLoader(FArchive* InLoader, bool bInLoaderNeedsEngineVersionChecks);
    FArchive* GetLoader() const { return Loader; }
 
public:
 
    FArchive * GetLoader_Unsafe() const
    {
        return Loader;
    }
 
    bool HasLoader() const
    {
        return Loader != nullptr;
    }
 
    void DestroyLoader();
 
    COREUOBJECT_API void DetachLoader();
 
    UE_FORCEINLINE_HINT bool IsDestroyingLoader() const
    {
        return bIsDestroyingLoader;
    }
 
    void* AsyncRoot;
 
#if WITH_EDITOR
    UE::FMutex BulkDataMutex;
 
    TSet<FBulkData*> BulkDataLoaders;
    TSet<UE::Serialization::FEditorBulkData*> EditorBulkDataLoaders;
#endif // WITH_EDITOR
 
    static constexpr int32 ExportHashCount = 256;
    TUniquePtr<int32[]> ExportHash;
 
    UE_FORCEINLINE_HINT static int32 GetHashBucket(FName Object)
    {
        return GetTypeHash(Object.GetComparisonIndex()) & (ExportHashCount - 1);
    }
 
    TArray<FPackageIndex> PreloadDependencies;
 
    TArray<FExternalReadCallback> ExternalReadDependencies;
 
    COREUOBJECT_API static TArray<FName> FindPreviousNamesForClass(const FString& CurrentClassPath, bool bIsInstance);
 
    COREUOBJECT_API static TArray<FString> FindPreviousPathNamesForClass(const FString& CurrentClassPath, bool bIsInstance, bool bIncludeShortNames = false);
 
    COREUOBJECT_API static FName FindNewNameForClass(FName OldClassName, bool bIsInstance);
 
    COREUOBJECT_API static FString FindNewPathNameForClass(const FString& OldClassNameOrPathName, bool bIsInstance);
 
    COREUOBJECT_API static FName FindNewNameForEnum(FName OldEnumName);
 
    COREUOBJECT_API static FName FindNewNameForStruct(FName OldStructName);
 
    COREUOBJECT_API static bool IsKnownMissingPackage(FName PackageName);
 
    COREUOBJECT_API static void AddKnownMissingPackage(FName PackageName);
 
    COREUOBJECT_API static bool RemoveKnownMissingPackage(FName PackageName);
 
    #if UE_WITH_OBJECT_HANDLE_LATE_RESOLVE
    COREUOBJECT_API static bool IsImportLazyLoadEnabled();
    #else
    inline static bool IsImportLazyLoadEnabled() { return false; }
    #endif // UE_WITH_OBJECT_HANDLE_LATE_RESOLVE
 
    COREUOBJECT_API static void OnNewFileAdded(const FString& Filename);
 
    COREUOBJECT_API static void OnPakFileMounted(const IPakFile& PakFile);
 
    COREUOBJECT_API bool HasAnyObjectsPendingLoad() const;
 
    COREUOBJECT_API static void AddGameNameRedirect(const FName OldName, const FName NewName);
 
    virtual bool SerializeBulkData(FBulkData& BulkData, const FBulkDataSerializationParams& Params) override;
 
private:
 
    void SerializeBulkMeta(UE::BulkData::Private::FBulkMetaData& Meta, FBulkDataCookedIndex& CookedIndex, int64& DuplicateSerialOffset, int32 ElementSize);
 
    // Variables used during async linker creation.
 
    int32                       SoftObjectPathListIndex;
    int32                       GatherableTextDataMapIndex;
    int32                       ImportMapIndex;
    int32                       ExportMapIndex;
#if WITH_METADATA
    int32                       MetaDataMapIndex;
    int32                       NumObjectMetaDataMap;
    int32                       NumRootMetaDataMap;
#endif
    int32                       DependsMapIndex;
    int32                       ExportHashIndex;
 
 
    bool                    bHasSerializedPackageFileSummary:1;
    bool                    bHasSerializedPackageTrailer : 1;
    bool                    bHasConstructedExportsReaders:1;
    bool                    bHasSerializedPreloadDependencies:1;
    bool                    bHasFixedUpImportMap:1;
    bool                    bHasPopulatedInstancingContext:1;
    bool                    bHasRelocatedReferences:1;
    bool                    bHasAppliedInstancingContext : 1;
    bool                    bFixupExportMapDone:1;
    bool                    bHasFoundExistingExports:1;
    bool                    bHasFinishedInitialization:1;
    bool                    bIsGatheringDependencies:1;
    bool                    bTimeLimitExceeded:1;
    bool                    bUseTimeLimit:1;
    bool                    bUseFullTimeLimit:1;
    bool                    bLoaderNeedsEngineVersionChecks : 1;
    bool                    bHasSerializedImportTypeHierarchies : 1;
 
#if WITH_EDITOR
    bool bExportsDuplicatesFixed : 1;
 
    bool bIsPackageRelocated : 1;
 
    bool bIsLoadingToPropertyBagObject : 1;
 
    bool bIsSerializingScriptProperties : 1;
#endif // WITH_EDITOR
 
    int32                   IsTimeLimitExceededCallCount;
    float                   TimeLimit;
    double                  TickStartTime;
    int32                   OwnerThread;
 
    struct FPackagePrecacheInfo
    {
        FThreadSafeCounter* SynchronizationObject;
 
        void* PackageData;
 
        int64 PackageDataSize;
 
        FPackagePrecacheInfo()
        : SynchronizationObject(NULL)
        , PackageData(NULL)
        , PackageDataSize(0)
        {
        }
        ~FPackagePrecacheInfo()
        {
            delete SynchronizationObject;
        }
    };
 
private:
 
    static FName NAME_LoadErrors;
 
    static bool bActiveRedirectsMapInitialized;
 
#if WITH_EDITOR
    FScopedSlowTask* LoadProgressScope;
 
    UE_FORCEINLINE_HINT bool ShouldReportProgress() const
    {
        return !IsAsyncLoading() && (LoadFlags & (LOAD_Quiet | LOAD_Async)) == 0;
    }
 
    bool ShouldCreateThrottledSlowTask() const;
 
    virtual void PushDebugDataString(const FName& DebugData) override
    {
        FArchiveUObject::PushDebugDataString(DebugData);
        if ( Loader )
            Loader->PushDebugDataString(DebugData);
    }
 
    virtual void PopDebugDataString() override
    {
        FArchiveUObject::PopDebugDataString();
        if ( Loader )
            Loader->PopDebugDataString();
    }
 
#endif 
 
public:
 
    static void CreateActiveRedirectsMap(const FString& GEngineIniName);
 
    bool IsValidPackageIndex(FPackageIndex InIndex);
 
    COREUOBJECT_API bool FindImportPackage(FName PackageName, FPackageIndex& PackageIdx);
 
    COREUOBJECT_API bool FindImport(FPackageIndex OuterIndex, FName ObjectName, FPackageIndex& OutObjectIndex);
 
    COREUOBJECT_API bool FindImport(FStringView FullObjectPath, FPackageIndex& OutObjectIndex);
 
    COREUOBJECT_API bool FindImportClassAndPackage(FName ClassName, FPackageIndex& ClassIdx, FPackageIndex& PackageIdx);
    
    COREUOBJECT_API bool CreateImportClassAndPackage(FName ClassName, FName PackageName, FPackageIndex& ClassIdx, FPackageIndex& PackageIdx);
 
    COREUOBJECT_API ELinkerStatus FixupExportMap();
 
    UE_FORCEINLINE_HINT bool HasFinishedInitialization() const
    {
        return bHasFinishedInitialization;
    }
 
    UE_FORCEINLINE_HINT int32 GetOwnerThreadId() const
    {
        return OwnerThread;
    }
 
    virtual FLinker* GetLinker() override { return this; }
 
    virtual void FlushCache() override;
 
    COREUOBJECT_API static FLinkerLoad* CreateLinker(FUObjectSerializeContext* LoadContext, UPackage* Parent, const FPackagePath& PackagePath, uint32 LoadFlags, FArchive* InLoader = nullptr, const FLinkerInstancingContext* InstancingContext = nullptr);
 
    void Verify();
 
    COREUOBJECT_API FName GetExportClassPackage( int32 i );
    virtual FString GetArchiveName() const override;
 
#if WITH_EDITORONLY_DATA
    COREUOBJECT_API void GatherExportDependencies(int32 ExportIndex, TSet<FDependencyRef>& Dependencies, bool bSkipLoadedObjects=true);
 
    COREUOBJECT_API void GatherImportDependencies(int32 ImportIndex, TSet<FDependencyRef>& Dependencies, bool bSkipLoadedObjects=true);
#endif
 
    EVerifyResult VerifyImport(int32 ImportIndex);
    
    COREUOBJECT_API void LoadAllObjects(bool bForcePreload);
 
    FName ResolveResourceName( FPackageIndex ResourceIndex );
 
    UObject* ResolveResource(FPackageIndex ResourceIndex);
    
    UE_DEPRECATED(5.6, "This function was used only for the now-deleted Conform functionality and will be removed. Contact Epic if you need this function.")
    int32 FindExportIndex( FName ClassName, FName ClassPackage, FName ObjectName, FPackageIndex ExportOuterIndex );
 
    COREUOBJECT_API void Preload( UObject* Object ) override;
 
    UObject* FindExistingExport(int32 ExportIndex);
 
    UObject* FindExistingImport(int32 ImportIndex);
 
    void BuildPathName( FString& OutPathName, FPackageIndex ExportIndex ) const;
 
    COREUOBJECT_API bool WillTextureBeLoaded( UClass* Class, int32 ExportIndex );
 
    virtual void MarkScriptSerializationStart( const UObject* Obj ) override;
 
    virtual void MarkScriptSerializationEnd( const UObject* Obj ) override;
 
    virtual UObject* GetArchetypeFromLoader(const UObject* Obj) override;
 
    COREUOBJECT_API static FLinkerLoad* FindExistingLinkerForPackage(const UPackage* Package);
 
    COREUOBJECT_API static void PRIVATE_PatchNewObjectIntoExport(UObject* OldObject, UObject* NewObject,
        FUObjectSerializeContext* InLoadContext = nullptr, bool bHideGarbageObjects=true);
    COREUOBJECT_API void PRIVATE_PatchNewObjectIntoExport(int32 OldExportIndex, UObject* NewObject,
        FUObjectSerializeContext* InLoadContext = nullptr, bool bHideGarbageObjects = true);
 
    COREUOBJECT_API static void PRIVATE_ForceLoadAllDependencies(UPackage* Package);
 
    COREUOBJECT_API static void InvalidateExport(UObject* OldObject, bool bHideGarbageObjects = true);
 
#if WITH_EDITOR
    COREUOBJECT_API static bool GetPreloadingEnabled();
    COREUOBJECT_API static void SetPreloadingEnabled(bool bEnabled);
    COREUOBJECT_API static bool TryGetPreloadedLoader(const FPackagePath& InPackagePath, FOpenPackageResult& OutResult);
    private:
        static bool bPreloadingEnabled;
    public:
#endif
 
    virtual bool AttachExternalReadDependency(FExternalReadCallback& ReadCallback) override;
 
    bool FinishExternalReadDependencies(double TimeLimit);
 
private:
#if WITH_EDITOR
     bool DoesSavedClassMatchActualClass(int32 ExportIndex) const;
    
    const UObject* GetCurrentObjectAtIndex(FPackageIndex ObjectIndex) const;
 
    void FixupDuplicateExports();
 
    void ReplaceExportIndexes(const FPackageIndex& OldIndex, const FPackageIndex& NewIndex);
 
#endif // WITH_EDITOR
    void FindDirectChildExportsFromExportTable(int32 ExportIndex, TArray<int32>& OutChildExports);
    void InvalidateExportIndex(int32 ExportIndex, bool bHideGarbageObjects);
 
    bool IsPackageReferenceAllowed(UPackage* InPackage);
 
    UObject* CreateExport( int32 Index );
 
    UObject* CreateExportAndPreload(int32 ExportIndex, bool bForcePreload = false);
 
    UClass* GetExportLoadClass(int32 ExportIndex);
 
#if WITH_EDITOR
    UClass* TryCreatePlaceholderClassImport(int32 ImportIndex);
 
    UClass* TryCreatePlaceholderClassForExport(int32 ExportIndex);
#endif
 
#if WITH_METADATA
    int32 LoadMetaDataFromExportMap(bool bForcePreload);
#endif // WITH_METADATA
 
    UObject* CreateImport( int32 Index );
 
    bool IsImportNative(const int32 ImportIndex) const;
 
    FLinkerLoad* FindExistingLinkerForImport(int32 ImportIndex) const;
 
    UObject* IndexToObject( FPackageIndex Index );
 
    void DetachExport( int32 i );
 
#if WITH_EDITOR
    virtual void AttachBulkData(UObject* Owner, FBulkData* BulkData) override;
    virtual void AttachBulkData(UE::Serialization::FEditorBulkData* BulkData) override;
    virtual void DetachBulkData(FBulkData* BulkData, bool bEnsureBulkDataIsLoaded) override;
    virtual void DetachBulkData(UE::Serialization::FEditorBulkData* BulkData, bool bEnsureBulkDataIsLoaded) override;
#endif
    void DetachAllBulkData(bool bEnsureBulkDataIsLoaded);
public:
 
    COREUOBJECT_API void LoadAndDetachAllBulkData();
 
    COREUOBJECT_API void Detach();
 
    COREUOBJECT_API void DetachExports();
 
    UE_DEPRECATED(5.5, "LOAD_RegenerateBulkDataGuids is now obsolete so this method no longer has any purpose.")
    bool ShouldRegenerateGuids() const
    {
        return false;
    }
 
private:
 
    // FArchive interface.
    inline virtual bool Precache(int64 PrecacheOffset, int64 PrecacheSize) override
    {
#if WITH_EDITOR
        checkf(!bDetachedLoader, TEXT("Attempting to call ::Precache on a FLinkerLoad that has previously called ::DetachLoader"));
#endif // WITH_EDITOR
 
        return Loader->Precache(PrecacheOffset, PrecacheSize);
    }
 
    inline virtual void Seek(int64 InPos) override
    {
#if WITH_EDITOR
        checkf(!bDetachedLoader, TEXT("Attempting to call ::Seek on a FLinkerLoad that has previously called ::DetachLoader"));
#endif // WITH_EDITOR
 
        Loader->Seek(InPos);
    }
 
    inline virtual int64 Tell() override
    {
#if WITH_EDITOR
        checkf(!bDetachedLoader, TEXT("Attempting to call ::Tell on a FLinkerLoad that has previously called ::DetachLoader"));
#endif // WITH_EDITOR
 
        return Loader->Tell();
    }
 
    inline virtual int64 TotalSize() override
    {
#if WITH_EDITOR
        checkf(!bDetachedLoader, TEXT("Attempting to call ::TotalSize on a FLinkerLoad that has previously called ::DetachLoader"));
#endif // WITH_EDITOR
 
        return Loader->TotalSize();
    }
 
    // this fixes the warning : 'ULinkerLoad::Serialize' hides overloaded virtual function
    using FLinker::Serialize;
    inline virtual void Serialize(void* V, int64 Length) override
    {
#if WITH_EDITOR
        checkf(!bDetachedLoader, TEXT("Attempting to call ::Serialize on a FLinkerLoad that has previously called ::DetachLoader"));
#endif // WITH_EDITOR
 
        checkSlow(FPlatformTLS::GetCurrentThreadId() == OwnerThread);
#if WITH_EDITOR
        // This handles the case where we're only serializing to a property bag and we don't immediately know where the script
        // property data starts/ends in the object's data stream. Allows for loading from packages saved with an older version.
        if (UNLIKELY(bIsLoadingToPropertyBagObject && !bIsSerializingScriptProperties))
        {
            Loader->Seek(Tell() + Length);
        }
        else
#endif
        {
            Loader->Serialize(V, Length);
        }
    }
    using FArchiveUObject::operator<<; // For visibility of the overloads we don't override
    virtual FArchive& operator<<(UObject*& Object) override;
    inline virtual FArchive& operator<<(FLazyObjectPtr& LazyObjectPtr) override
    {
        FArchive& Ar = *this;
        FUniqueObjectGuid ID;
        Ar << ID;
        LazyObjectPtr = ID;
        return Ar;
    }
 
    virtual FArchive& operator<<(FObjectPtr& ObjectPtr) override;
    virtual FArchive& operator<<(FSoftObjectPath& Value) override;
 
    void BadSoftObjectPathError(int32 SoftObjIndex);
    void BadNameIndexError(int32 NameIndex);
 
    inline virtual FArchive& operator<<(FName& Name) override
    {
        FArchive& Ar = *this;
        int32 NameIndex;
        Ar << NameIndex;
        int32 Number = 0;
        Ar << Number;
 
        if (NameMap.IsValidIndex(NameIndex))
        {
            // if the name wasn't loaded (because it wasn't valid in this context)
            FNameEntryId MappedName = NameMap[NameIndex];
 
            // simply create the name from the NameMap's name and the serialized instance number
            Name = FName::CreateFromDisplayId(MappedName, Number);
        }
        else
        {
            Name = FName();
            BadNameIndexError(NameIndex);
            SetCriticalError();
        }
 
        return *this;
    }
 
    virtual void SetSerializedProperty(FProperty* InProperty) override
    {
        FArchiveUObject::SetSerializedProperty(InProperty);
        Loader->SetSerializedProperty(InProperty);
    }
    virtual void SetSerializedPropertyChain(const FArchiveSerializedPropertyChain* InSerializedPropertyChain,
        class FProperty* InSerializedPropertyOverride = nullptr) override
    {
        FArchiveUObject::SetSerializedPropertyChain(InSerializedPropertyChain, InSerializedPropertyOverride);
        Loader->SetSerializedPropertyChain(InSerializedPropertyChain, InSerializedPropertyOverride);
    }
    virtual void PushSerializedProperty(class FProperty* InProperty, const bool bIsEditorOnlyProperty) override
    {
        FArchive::PushSerializedProperty(InProperty, bIsEditorOnlyProperty);
        Loader->PushSerializedProperty(InProperty, bIsEditorOnlyProperty);
    }
    virtual void PopSerializedProperty(class FProperty* InProperty, const bool bIsEditorOnlyProperty) override
    {
        FArchive::PopSerializedProperty(InProperty, bIsEditorOnlyProperty);
        Loader->PopSerializedProperty(InProperty, bIsEditorOnlyProperty);
    }
#if WITH_EDITORONLY_DATA
    virtual bool IsEditorOnlyPropertyOnTheStack() const override
    {
        return Loader->IsEditorOnlyPropertyOnTheStack();
    }
#endif
 
    virtual void SetDebugSerializationFlags(uint32 InCustomFlags) override
    {
        FArchiveUObject::SetDebugSerializationFlags(InCustomFlags);
        Loader->SetDebugSerializationFlags(InCustomFlags);
    }
 
 
    // FLinkerLoad functions
    bool VerifyImportInner(const int32 ImportIndex, FString& WarningSuffix);
 
    //
    // FLinkerLoad creation helpers BEGIN
    //
 
    COREUOBJECT_API static FLinkerLoad* CreateLinkerAsync(FUObjectSerializeContext* LoadContext, UPackage* Parent, const FPackagePath& PackagePath, uint32 LoadFlags, const FLinkerInstancingContext* InstancingContext
        , TFunction<void()>&& InSummaryReadyCallback
    );
 
protected: // Daniel L: Made this protected so I can override the constructor and create a custom loader to load the header of the linker in the DiffFilesCommandlet
    ELinkerStatus Tick( float InTimeLimit, bool bInUseTimeLimit, bool bInUseFullTimeLimit, TMap<TPair<FName, FPackageIndex>, FPackageIndex>* ObjectNameWithOuterToExportMap);
 
    FLinkerLoad(UPackage* InParent, const FPackagePath& PackagePath, uint32 InLoadFlags, FLinkerInstancingContext InstancingContext = FLinkerInstancingContext());
private:
    COREUOBJECT_API bool IsTimeLimitExceeded( const TCHAR* CurrentTask, int32 Granularity = 1 );
protected: // Daniel L: Made this protected so I can override the constructor and create a custom loader to load the header of the linker in the DiffFilesCommandlet
    ELinkerStatus CreateLoader(
        TFunction<void()>&& InSummaryReadyCallback
    );
private:
    ELinkerStatus ProcessPackageSummary(TMap<TPair<FName, FPackageIndex>, FPackageIndex>* ObjectNameWithOuterToExportMap);
 
    ELinkerStatus SerializePackageFileSummary();
 
    ELinkerStatus SerializePackageFileSummaryInternal();
 
    ELinkerStatus UpdateFromPackageFileSummary();
    
    ELinkerStatus SerializePackageTrailer();
 
    ELinkerStatus SerializeNameMap();
 
    ELinkerStatus SerializeSoftObjectPathList();
 
    ELinkerStatus SerializeImportMap();
 
    ELinkerStatus FixupImportMap();
 
    ELinkerStatus PopulateInstancingContext();
 
    ELinkerStatus RelocateReferences();
 
    ELinkerStatus ApplyInstancingContext();
 
    ELinkerStatus SerializeExportMap();
 
#if WITH_TEXT_ARCHIVE_SUPPORT
    ELinkerStatus ConstructExportsReaders();
#endif
 
#if WITH_METADATA
    ELinkerStatus SerializeMetaData();
#endif
 
    ELinkerStatus SerializeDependsMap();
 
    ELinkerStatus SerializePreloadDependencies();
    
    ELinkerStatus SerializeDataResourceMap();
 
#if WITH_EDITORONLY_DATA
    FLinkerLoad::ELinkerStatus SerializeImportTypeHierarchies();
#endif
 
    void ResetStatusInfo();
public:
    COREUOBJECT_API ELinkerStatus SerializeGatherableTextDataMap(bool bForceEnableForCommandlet = false);
 
    COREUOBJECT_API ELinkerStatus SerializeThumbnails( bool bForceEnableForCommandlet=false );
 
    virtual void ForceBlueprintFinalization() override;
 
    bool IsBlueprintFinalizationPending() const;
 
    UObject* RequestPlaceholderValue(const FProperty* Property, const UClass* ObjectType, const TCHAR* ObjectPath);
 
private:
    bool RegenerateBlueprintClass(UClass* LoadClass, UObject* ExportObject);
 
    bool DeferPotentialCircularImport(const int32 ImportIndex);
    
#if WITH_EDITOR
    bool IsSuppressableBlueprintImportError(int32 ImportIndex) const;
#endif // WITH_EDITOR
 
    bool DeferExportCreation(const int32 ExportIndex, UObject* Outer);
 
    int32 FindCDOExportIndex(UClass* LoadClass);
 
    void ResolveDeferredDependencies(UStruct* LoadStruct);
 
    int32 ResolveDependencyPlaceholder(class FLinkerPlaceholderBase* Placeholder, UClass* ReferencingClass = nullptr, const FName ObjectPath = NAME_None);
 
    bool HasUnresolvedDependencies() const;
 
    void ResolveAllImports();
 
    void FinalizeBlueprint(UClass* LoadClass);
 
    void ResolveDeferredExports(UClass* LoadClass);
 
    void ResolvePlaceholder(ULinkerPlaceholderExportObject* Placeholder);
 
    void ResolvedDeferredSubobjects(ULinkerPlaceholderExportObject* OwningPlaceholder);
 
    bool ForceRegenerateClass(UClass* ImportClass);
 
    bool IsExportBeingResolved(int32 ExportIndex);
 
    void ResetDeferredLoadingState();
 
    bool HasPerformedFullExportResolvePass();
 
    UObject* FindImport(UClass* ImportClass, UObject* ImportOuter, const TCHAR* Name);
    static UObject* FindImportFast(UClass* ImportClass, UObject* ImportOuter, FName Name, bool bFindObjectbyName = false);
 
#if USE_CIRCULAR_DEPENDENCY_LOAD_DEFERRING
    bool bForceBlueprintFinalization;
 
    int32 DeferredCDOIndex;
 
    TArray<class FLinkerPlaceholderBase*> ResolvingPlaceholderStack;
 
    TMap<FName, FLinkerPlaceholderBase*> ImportPlaceholders;
#endif // USE_CIRCULAR_DEPENDENCY_LOAD_DEFERRING
 
 
    ELinkerStatus CreateExportHash();
 
    ELinkerStatus FindExistingExports();
 
    ELinkerStatus FinalizeCreation(TMap<TPair<FName, FPackageIndex>, FPackageIndex>* ObjectNameWithOuterToExportMap);
 
    //
    // FLinkerLoad creation helpers END
    //
 
private:
 
#if WITH_TEXT_ARCHIVE_SUPPORT
    // Function to get a slot for a given export
    FStructuredArchiveSlot GetExportSlot(FPackageIndex InExportIndex);
#endif
 
public:
 
    //~ FArchive interface
    UE_DEPRECATED(5.5, "GetSerializeContext is not supported. Use FUObjectThreadContext::Get().GetSerializeContext().")
    COREUOBJECT_API virtual FUObjectSerializeContext* GetSerializeContext() override;
};
 
COREUOBJECT_API bool IsEnforcePackageCompatibleVersionCheck();