1. Epic GamesDeveloper
  3. FLinkerLoad

FLinkerLoad

API > API/Runtime > API/Runtime/CoreUObject

   
Name FLinkerLoad
Type class
Header File /Engine/Source/Runtime/CoreUObject/Public/UObject/LinkerLoad.h
Include Path #include "UObject/LinkerLoad.h"

Syntax

class FLinkerLoad :  
    public FLinker ,  
    public FArchiveUObject

Inheritance Hierarchy

Constructors

Name Remarks Include Path Unreal Specifiers

FLinkerLoad ( UPackage* InParent,
const FPackagePath& PackagePath,
uint32 InLoadFlags,
FLinkerInstancingContext InstancingContext
)

 Private constructor, passing arguments through from CreateLinker. UObject/LinkerLoad.h  

Destructors

Name Remarks Include Path Unreal Specifiers

virtual ~FLinkerLoad()

   UObject/LinkerLoad.h  

Structs

Name Remarks
FPackagePrecacheInfo Helper struct to keep track of background file reads

Enums

Protected

Name Remarks
ELinkerStatus Linker loading status.
EVerifyResult Verify result.

Constants

Name Type Remarks Include Path
bActiveRedirectsMapInitialized bool Makes sure the deprecated active redirects inis have been read UObject/LinkerLoad.h
bPreloadingEnabled bool   UObject/LinkerLoad.h
ExportHashCount int32 Hash table for exports. UObject/LinkerLoad.h
NAME_LoadErrors FName   UObject/LinkerLoad.h

Variables

Public

Name Type Remarks Include Path Unreal Specifiers
AsyncRoot void * The async package associated with this linker UObject/LinkerLoad.h  
bForceSimpleIndexToObject bool   UObject/LinkerLoad.h  
bHaveImportsBeenVerified bool Indicates whether the imports for this loader have been verified UObject/LinkerLoad.h  
bIsAsyncLoader bool True if Loader is FAsyncArchive UObject/LinkerLoad.h  
bLockoutLegacyOperations bool   UObject/LinkerLoad.h  
BulkDataLoaders TSet< FBulkData * > Bulk data that use the FLinkerLoad to track the state of the file on disk UObject/LinkerLoad.h  
BulkDataMutex UE::FMutex Used when accessing BulkDataLoaders/EditorBulkDataLoaders to ensure thread safety UObject/LinkerLoad.h  
EditorBulkDataLoaders TSet< UE::Serialization::FEditorBulkData * >   UObject/LinkerLoad.h  
ExportHash TUniquePtr< int32[]>   UObject/LinkerLoad.h  
ExternalReadDependencies TArray< FExternalReadCallback > List of external read dependencies that must be finished to load this package UObject/LinkerLoad.h  
LoadFlags uint32 Flags determining loading behavior. UObject/LinkerLoad.h  
PreloadDependencies TArray< FPackageIndex > List of imports and exports that must be serialized before other exports...all packed together, see FirstExportDependency UObject/LinkerLoad.h  
TemplateForGetArchetypeFromLoader UObject *   UObject/LinkerLoad.h  

Protected

Name Type Remarks Include Path Unreal Specifiers
bDetachedLoader bool Tracks if DetachLoader has been called or not UObject/LinkerLoad.h  
bExportsDuplicatesFixed bool Check to avoid multiple export duplicate fixups in case we don't save asset. UObject/LinkerLoad.h  
bFixupExportMapDone bool Used for ActiveClassRedirects functionality UObject/LinkerLoad.h  
bForceBlueprintFinalization bool For deferring dependency loads, we block CDO serialization until the class if complete. UObject/LinkerLoad.h  
bHasAppliedInstancingContext bool Whether we already applied the instancing context to the soft object list. UObject/LinkerLoad.h  
bHasConstructedExportsReaders bool Whether we have already constructed the exports readers UObject/LinkerLoad.h  
bHasFinishedInitialization bool Whether we are already fully initialized. UObject/LinkerLoad.h  
bHasFixedUpImportMap bool Whether we already fixed up import map. UObject/LinkerLoad.h  
bHasFoundExistingExports bool Whether we already matched up existing exports. UObject/LinkerLoad.h  
bHasPopulatedInstancingContext bool Whether we already populated the instancing context. UObject/LinkerLoad.h  
bHasRelocatedReferences bool Whether we already relocated references. UObject/LinkerLoad.h  
bHasSerializedPackageFileSummary bool Whether we already serialized the package file summary. UObject/LinkerLoad.h  
bHasSerializedPackageTrailer bool Whether we already serialized the package trailer. UObject/LinkerLoad.h  
bHasSerializedPreloadDependencies bool Whether we already serialized preload dependencies. UObject/LinkerLoad.h  
bIsDestroyingLoader bool True if the linker is currently deleting loader UObject/LinkerLoad.h  
bIsGatheringDependencies bool Whether we are gathering dependencies, can be used to streamline VerifyImports, etc UObject/LinkerLoad.h  
bIsLoadingToPropertyBagObject bool Set when the loader is serializing to a property bag placeholder object. UObject/LinkerLoad.h  
bIsPackageRelocated bool Cache if the package is relocated or not UObject/LinkerLoad.h  
bIsSerializingScriptProperties bool TRUE when the loader is actively serializing an object's script properties data. UObject/LinkerLoad.h  
bLoaderNeedsEngineVersionChecks bool Whether the loader needs version and correctness checks (see OpenReadPackage) UObject/LinkerLoad.h  
bTimeLimitExceeded bool Whether time limit is/ has been exceeded in current/ last tick. UObject/LinkerLoad.h  
bUseFullTimeLimit bool Whether to use the full time limit, even if we're blocked on I/O UObject/LinkerLoad.h  
bUseTimeLimit bool Whether to use a time limit for async linker creation. UObject/LinkerLoad.h  
DeferredCDOIndex int32 Index of the CDO that should be used for blueprint finalization, may be INDEX_NONE in the case of some legacy content. UObject/LinkerLoad.h  
DependsMapIndex int32 Current index into depends map, used by async linker creation for spreading out serializing dependsmap entries. UObject/LinkerLoad.h  
ExportHashIndex int32 Current index into export hash map, used by async linker creation for spreading out hashing exports. UObject/LinkerLoad.h  
ExportMapIndex int32 Current index into export map, used by async linker creation for spreading out serializing exportmap entries. UObject/LinkerLoad.h  
ExportReaders TArray< FStructuredArchiveChildReader * >   UObject/LinkerLoad.h  
GatherableTextDataMapIndex int32 Current index into gatherable text data map, used by async linker creation for spreading out serializing text entries. UObject/LinkerLoad.h  
ImportMapIndex int32 Current index into import map, used by async linker creation for spreading out serializing importmap entries. UObject/LinkerLoad.h  
ImportPlaceholders TMap< FName, FLinkerPlaceholderBase * > Internal list to track imports that were deferred, but don't belong to the ImportMap (thinks ones loaded through config files via FProperty::ImportText). UObject/LinkerLoad.h  
ImportsToVerifyOnCreate TSet< int32 > Set of imports that require additional verification at creation time. UObject/LinkerLoad.h  
InstancingContext FLinkerInstancingContext The linker instancing context. UObject/LinkerLoad.h  
IsTimeLimitExceededCallCount int32 Call count of IsTimeLimitExceeded. UObject/LinkerLoad.h  
Loader FArchive * The archive that actually reads the raw data from disk. UObject/LinkerLoad.h  
LoadProgressScope FScopedSlowTask * Feedback scope that is created to house the slow task of an asynchronous linker load. UObject/LinkerLoad.h  
MetaDataMapIndex int32 Current index into meta data, used by async linker creation for spreading out serializing meta data entries. UObject/LinkerLoad.h  
NumObjectMetaDataMap int32   UObject/LinkerLoad.h  
NumRootMetaDataMap int32   UObject/LinkerLoad.h  
OwnerThread int32 Id of the thread that created this linker. UObject/LinkerLoad.h  
PackagePath FPackagePath The packagepath being loaded UObject/LinkerLoad.h  
PackageTrailer TUniquePtr< UE::FPackageTrailer > The trailer for the package UObject/LinkerLoad.h  
ResolvingPlaceholderStack TArray< class FLinkerPlaceholderBase * > Used to track dependency placeholders currently being resolved inside of ResolveDependencyPlaceholder()... UObject/LinkerLoad.h  
SoftObjectPathListIndex int32 Current index into soft object path list, used by async linker creation for spreading out serializing soft object path entries. UObject/LinkerLoad.h  
StructuredArchive FStructuredArchive * Structured archive interface. UObject/LinkerLoad.h  
StructuredArchiveFormatter FArchiveFormatterType *   UObject/LinkerLoad.h  
StructuredArchiveRootRecord TOptional< FStructuredArchive::FRecord >   UObject/LinkerLoad.h  
TickStartTime double Time at begin of Tick function. Used for time limit determination. UObject/LinkerLoad.h  
TimeLimit float Current time limit to use if bUseTimeLimit is true. UObject/LinkerLoad.h  

Functions

Public

Name Remarks Include Path Unreal Specifiers

void BuildPathName ( FString& OutPathName,
FPackageIndex ExportIndex
) const

 Builds a string containing the full path for a resource in the export table. UObject/LinkerLoad.h  

bool CreateImportClassAndPackage ( FName ClassName,
FName PackageName,
FPackageIndex& ClassIdx,
FPackageIndex& PackageIdx
)

 Attempts to find the index for the given class object in the import list and adds it + its package if it does not exist UObject/LinkerLoad.h  

void DestroyLoader()

   UObject/LinkerLoad.h  

void Detach()

 Detaches linker from bulk data and exports and removes itself from array of loaders. UObject/LinkerLoad.h  

void DetachExports()

 Only detaches the linker from its exports and the reset their cached state in the linker without touching bulkdata or underlying loader UObject/LinkerLoad.h  

void DetachLoader ()

 Detaches all bulkdata currently attached to the FLinkerLoad followed by destroying the internal loader. UObject/LinkerLoad.h  

UObject * FindExistingExport ( int32 ExportIndex
)

 Before loading a persistent object from disk, this function can be used to discover the object in memory. UObject/LinkerLoad.h  

UObject * FindExistingImport ( int32 ImportIndex
)

   UObject/LinkerLoad.h  

int32 FindExportIndex ( FName ClassName,
FName ClassPackage,
FName ObjectName,
FPackageIndex ExportOuterIndex
)

   UObject/LinkerLoad.h  

bool FindImport ( FStringView FullObjectPath,
FPackageIndex& OutObjectIndex
)

 Finds an import given the full object path as a string. UObject/LinkerLoad.h  

bool FindImport ( FPackageIndex OuterIndex,
FName ObjectName,
FPackageIndex& OutObjectIndex
)

 Locates package index for a given name in an outer. UObject/LinkerLoad.h  

bool FindImportClassAndPackage ( FName ClassName,
FPackageIndex& ClassIdx,
FPackageIndex& PackageIdx
)

 Locates the class adjusted index and its package adjusted index for a given class name in the import map UObject/LinkerLoad.h  

bool FindImportPackage ( FName PackageName,
FPackageIndex& PackageIdx
)

 Locates package index for a UPackage import UObject/LinkerLoad.h  

bool FinishExternalReadDependencies ( double TimeLimit
)

 Finalizes external dependencies till time limit is exceeded UObject/LinkerLoad.h  

ELinkerStatus FixupExportMap()

 Allows object instances to be converted to other classes upon loading a package UObject/LinkerLoad.h  

void GatherExportDependencies ( int32 ExportIndex,
TSet< FDependencyRef >& Dependencies,
bool bSkipLoadedObjects
)

 Recursively gathers the dependencies of a given export (the recursive chain of imports and their imports, and so on) UObject/LinkerLoad.h  

void GatherImportDependencies ( int32 ImportIndex,
TSet< FDependencyRef >& Dependencies,
bool bSkipLoadedObjects
)

 Recursively gathers the dependencies of a given import (the recursive chain of imports and their imports, and so on) UObject/LinkerLoad.h  

FAsyncArchive * GetAsyncLoader()

   UObject/LinkerLoad.h  

FName GetExportClassPackage ( int32 i
)

   UObject/LinkerLoad.h  

const FLinkerInstancingContext & GetInstancingContext()

   UObject/LinkerLoad.h  
Access the underlying archive. UObject/LinkerLoad.h  

int32 GetOwnerThreadId()

 Returns ID of the thread that created this linker UObject/LinkerLoad.h  
Get the PackagePath being loaded. UObject/LinkerLoad.h  

const UE::FPackageTrailer * GetPackageTrailer()

   UObject/LinkerLoad.h  

bool HasAnyObjectsPendingLoad()

 Checks if the linker has any objects in the export table that require loading. UObject/LinkerLoad.h  

bool HasFinishedInitialization()

 Returns whether linker has finished (potentially) async initialization. UObject/LinkerLoad.h  

bool HasLoader()

   UObject/LinkerLoad.h  
Query method to help handle recursive behavior. UObject/LinkerLoad.h  

bool IsDestroyingLoader()

   UObject/LinkerLoad.h  

bool IsPackageRelocated()

   UObject/LinkerLoad.h  

bool IsValidPackageIndex ( FPackageIndex InIndex
)

 Test whether the given package index is a valid import or export in this package UObject/LinkerLoad.h  

void LoadAllObjects ( bool bForcePreload
)

 Loads all objects in package. UObject/LinkerLoad.h  

void LoadAndDetachAllBulkData()

 Detaches linker from bulk data. UObject/LinkerLoad.h  

void PRIVATE_PatchNewObjectIntoExport ( int32 OldExportIndex,
UObject* NewObject,
FUObjectSerializeContext* InLoadContext,
bool bHideGarbageObjects
)

 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! CAUTION: This function is potentially DANGEROUS. UObject/LinkerLoad.h  

UObject * RequestPlaceholderValue ( const FProperty* Property,
const UClass* ObjectType,
const TCHAR* ObjectPath
)

 Gives external code the ability to create FLinkerPlaceholderBase objects in place of loads that may violate the LOAD_DeferDependencyLoads state. UObject/LinkerLoad.h  

UObject * ResolveResource ( FPackageIndex ResourceIndex
)

 Returns the Object associated with the resource indicated. UObject/LinkerLoad.h  

FName ResolveResourceName ( FPackageIndex ResourceIndex
)

 Returns the ObjectName associated with the resource indicated. UObject/LinkerLoad.h  

ELinkerStatus SerializeGatherableTextDataMap ( bool bForceEnableForCommandlet
)

 Serializes the gatherable text data container. UObject/LinkerLoad.h  

ELinkerStatus SerializeThumbnails ( bool bForceEnableForCommandlet
)

 Serializes thumbnails UObject/LinkerLoad.h  

bool ShouldRegenerateGuids()

   UObject/LinkerLoad.h  

void Verify()

   UObject/LinkerLoad.h  

EVerifyResult VerifyImport ( int32 ImportIndex
)

 A wrapper around VerifyImportInner. UObject/LinkerLoad.h  

bool WillTextureBeLoaded ( UClass* Class,
int32 ExportIndex
)

 Checks if the specified export should be loaded or not. Performs similar checks as CreateExport(). UObject/LinkerLoad.h  

Overridden from FLinker

Name Remarks Include Path Unreal Specifiers

virtual FString GetDebugName()

 Returns a descriptor of the PackagePath this Linker is reading from or writing to, usable for an identifier in warning and log messages UObject/LinkerLoad.h  

Overridden from FArchive

Name Remarks Include Path Unreal Specifiers

virtual bool AttachExternalReadDependency ( FExternalReadCallback& ReadCallback
)

 Adds external read dependency UObject/LinkerLoad.h  

virtual void FlushCache()

 Flush Loader Cache UObject/LinkerLoad.h  

virtual void ForceBlueprintFinalization()

 Inform the archive that blueprint finalization is pending. UObject/LinkerLoad.h  

virtual void MarkScriptSerializationEnd ( const UObject* Obj
)

 Called when an object stops serializing property data using script serialization. UObject/LinkerLoad.h  

virtual void MarkScriptSerializationStart ( const UObject* Obj
)

 Called when an object begins serializing property data using script serialization. UObject/LinkerLoad.h  

virtual void Preload ( UObject* Object
)

 Serialize the object data for the specified object from the unreal package file. UObject/LinkerLoad.h  

virtual bool SerializeBulkData ( FBulkData& BulkData,
const FBulkDataSerializationParams& Params
)

   UObject/LinkerLoad.h  

Overridden from FArchiveState

Name Remarks Include Path Unreal Specifiers

virtual UObject * GetArchetypeFromLoader ( const UObject* Obj
)

   UObject/LinkerLoad.h  

virtual FString GetArchiveName()

   UObject/LinkerLoad.h  

virtual FLinker * GetLinker()

 If this archive is a FLinkerLoad or FLinkerSave, returns a pointer to the FLinker portion. UObject/LinkerLoad.h  

virtual FUObjectSerializeContext * GetSerializeContext()

   UObject/LinkerLoad.h  

Protected

Name Remarks Include Path Unreal Specifiers

ELinkerStatus CreateLoader ( TFunction< void()>&& InSummaryReadyCallback
)

 Creates loader used to serialize content. UObject/LinkerLoad.h  

FArchive * GetLoader()

   UObject/LinkerLoad.h  

void SetLoader ( FArchive* InLoader,
bool bInLoaderNeedsEngineVersionChecks
)

   UObject/LinkerLoad.h  

ELinkerStatus Tick ( float InTimeLimit,
bool bInUseTimeLimit,
bool bInUseFullTimeLimit,
TMap< TPair< FName, FPackageIndex >, FPackageIndex >* ObjectNameWithOuterToExportMap
)

 Ticks an in-flight linker and spends InTimeLimit seconds on creation. UObject/LinkerLoad.h  

Static

Name Remarks Include Path Unreal Specifiers

static void AddGameNameRedirect ( const FName OldName,
const FName NewName
)

 Add a new redirect from old game name to new game name for ImportMap UObject/LinkerLoad.h  

static void AddKnownMissingPackage ( FName PackageName
)

 Register that a package is now known missing and that it should silence future warnings/issues UObject/LinkerLoad.h  

static void CreateActiveRedirectsMap ( const FString& GEngineIniName
)

 Add redirects to FLinkerLoad static map UObject/LinkerLoad.h  

static FLinkerLoad * CreateLinker ( FUObjectSerializeContext* LoadContext,
UPackage* Parent,
const FPackagePath& PackagePath,
uint32 LoadFlags,
FArchive* InLoader,
const FLinkerInstancingContext* InstancingContext
)

 Creates and returns a FLinkerLoad object. UObject/LinkerLoad.h  

static FLinkerLoad * CreateLinkerAsync ( FUObjectSerializeContext* LoadContext,
UPackage* Parent,
const FPackagePath& PackagePath,
uint32 LoadFlags,
const FLinkerInstancingContext* InstancingContext,
TFunction< void()>&& InSummaryReadyCallback
)

 FLinkerLoad creation helpers BEGIN Creates a FLinkerLoad object for async creation. UObject/LinkerLoad.h  

static FLinkerLoad * FindExistingLinkerForPackage ( const UPackage* Package
)

 Looks for an existing linker for the given package, without trying to make one if it doesn't exist UObject/LinkerLoad.h  

static UObject * FindImportFast ( UClass* ImportClass,
UObject* ImportOuter,
FName Name,
bool bFindObjectbyName
)

 Finds import, tries to fall back to dynamic class if the object could not be found UObject/LinkerLoad.h  

static FName FindNewNameForClass ( FName OldClassName,
bool bIsInstance
)

 Utility functions to query the object name redirects list for the current name for a class UObject/LinkerLoad.h  

static FName FindNewNameForEnum ( FName OldEnumName
)

 Utility functions to query the enum name redirects list for the current name for an enum UObject/LinkerLoad.h  

static FName FindNewNameForStruct ( FName OldStructName
)

 Utility functions to query the struct name redirects list for the current name for a struct UObject/LinkerLoad.h  

static FString FindNewPathNameForClass ( const FString& OldClassNameOrPathName,
bool bIsInstance
)

 Utility functions to query the object name redirects list for the current name for a class UObject/LinkerLoad.h  

static TArray< FName > FindPreviousNamesForClass ( const FString& CurrentClassPath,
bool bIsInstance
)

 Utility functions to query the object name redirects list for previous names for a class UObject/LinkerLoad.h  

static TArray< FString > FindPreviousPathNamesForClass ( const FString& CurrentClassPath,
bool bIsInstance,
bool bIncludeShortNames
)

 Utility functions to query the object name redirects list for previous names for a class UObject/LinkerLoad.h  

static int32 GetHashBucket ( FName Object
)

   UObject/LinkerLoad.h  

static bool GetPreloadingEnabled()

   UObject/LinkerLoad.h  

static void InvalidateExport ( UObject* OldObject,
bool bHideGarbageObjects
)

 Invalidates the future loading of a specific object, so that subsequent loads will fail This is used to invalidate sub objects of a replaced object that may no longer be valid UObject/LinkerLoad.h  

static bool IsImportLazyLoadEnabled ()

 Determines if imports can be lazily loaded. UObject/LinkerLoad.h  

static bool IsKnownMissingPackage ( FName PackageName
)

 Utility functions to check the list of known missing packages and silence any warnings that may have occurred on load. UObject/LinkerLoad.h  

static void OnNewFileAdded ( const FString& Filename
)

   UObject/LinkerLoad.h  

static void OnPakFileMounted ( const IPakFile& PakFile
)

   UObject/LinkerLoad.h  

static void PRIVATE_ForceLoadAllDependencies ( UPackage* Package
)

 Wraps a call to the package linker's ResolveAllImports(). UObject/LinkerLoad.h  

static void PRIVATE_PatchNewObjectIntoExport ( UObject* OldObject,
UObject* NewObject,
FUObjectSerializeContext* InLoadContext,
bool bHideGarbageObjects
)

 Replaces OldObject's entry in its linker with NewObject, so that all subsequent loads of OldObject will return NewObject. UObject/LinkerLoad.h  

static bool RemoveKnownMissingPackage ( FName PackageName
)

 Register that a package is no longer known missing and that it should be searched for again in the future UObject/LinkerLoad.h  

static void SetPreloadingEnabled ( bool bEnabled
)

   UObject/LinkerLoad.h  

static ELinkerType::Type StaticType()

 Variables. UObject/LinkerLoad.h  

static bool TryGetPreloadedLoader ( const FPackagePath& InPackagePath,
FOpenPackageResult& OutResult
)

   UObject/LinkerLoad.h  

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page