Linker.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/ArrayView.h"
#include "Containers/Map.h"
#include "Containers/Set.h"
#include "Containers/UnrealString.h"
#include "CoreMinimal.h"
#include "CoreTypes.h"
#include "Internationalization/GatherableTextData.h"
#include "Logging/LogMacros.h"
#include "Misc/AssertionMacros.h"
#include "Serialization/StructuredArchive.h"
#include "Serialization/StructuredArchiveSlots.h"
#include "Serialization/ImportTypeHierarchy.h"
#include "Templates/RefCounting.h"
#include "UObject/LinkerInstancingContext.h"
#include "UObject/NameTypes.h"
#include "UObject/ObjectMacros.h"
#include "UObject/ObjectResource.h"
#include "UObject/PackageFileSummary.h"
 
class FArchive;
class FLinkerInstancingContext;
class FLinkerLoad;
class FPackagePath;
class FReferenceCollector;
class UObject;
class UPackage;
class UPackageMap;
struct FGatherableTextData;
struct FGuid;
struct FPackageSaveInfo;
struct FUObjectSerializeContext;
template <typename FuncType> class TFunctionRef;
 
DECLARE_LOG_CATEGORY_EXTERN(LogLinker, Log, All);
 
struct FCompressedChunk
{
    FCompressedChunk();
 
    int32       UncompressedOffset;
    int32       UncompressedSize;
    int32       CompressedOffset;
    int32       CompressedSize;
 
    friend COREUOBJECT_API FArchive& operator<<(FArchive& Ar, FCompressedChunk& Chunk);
    friend COREUOBJECT_API void operator<<(FStructuredArchive::FSlot Slot, FCompressedChunk& Chunk);
};
 
 
class FLinkerTables
{
public:
    TArray<FObjectImport> ImportMap;
    TArray<FObjectExport> ExportMap;
    TArray<FCellImport> CellImportMap;
    TArray<FCellExport> CellExportMap;
    TArray<TArray<FPackageIndex> > DependsMap;
    TArray<FName> SoftPackageReferenceList;
    TMap<FPackageIndex, TArray<FName> > SearchableNamesMap;
 
    inline FObjectResource& ImpExp(FPackageIndex Index)
    {
        check(!Index.IsNull());
        if (Index.IsImport())
        {
            return Imp(Index);
        }
        else
        {
            return Exp(Index);
        }
    }
    inline FObjectResource const& ImpExp(FPackageIndex Index) const
    {
        check(!Index.IsNull());
        if (Index.IsImport())
        {
            return Imp(Index);
        }
        else
        {
            return Exp(Index);
        }
    }   
    inline FObjectResource* ImpExpPtr(FPackageIndex Index)
    {
        if (Index.IsImport())
        {
            return ImpPtr(Index);
        }
        else
        {
            return ExpPtr(Index);
        }
    }
 
    inline FObjectImport& Imp(FPackageIndex Index)
    {
        check(Index.IsImport() && ImportMap.IsValidIndex(Index.ToImport()));
        return ImportMap[Index.ToImport()];
    }
    inline FObjectImport const& Imp(FPackageIndex Index) const
    {
        check(Index.IsImport() && ImportMap.IsValidIndex(Index.ToImport()));
        return ImportMap[Index.ToImport()];
    }
    inline FObjectImport* ImpPtr(FPackageIndex Index)
    {
        if (Index.IsImport())
        {
            check(ImportMap.IsValidIndex(Index.ToImport()));
            return &ImportMap[Index.ToImport()];
        }
        return nullptr;
    }
 
    inline FObjectExport& Exp(FPackageIndex Index)
    {
        check(Index.IsExport() && ExportMap.IsValidIndex(Index.ToExport()));
        return ExportMap[Index.ToExport()];
    }
    inline FObjectExport const& Exp(FPackageIndex Index) const
    {
        check(Index.IsExport() && ExportMap.IsValidIndex(Index.ToExport()));
        return ExportMap[Index.ToExport()];
    }
    inline FObjectExport* ExpPtr(FPackageIndex Index)
    {
        if (Index.IsExport())
        {
            check(ExportMap.IsValidIndex(Index.ToExport()));
            return &ExportMap[Index.ToExport()];
        }
        return nullptr;
    }
 
    COREUOBJECT_API void SerializeSearchableNamesMap(FArchive &Ar);
    COREUOBJECT_API void SerializeSearchableNamesMap(FStructuredArchive::FSlot Slot);
 
    COREUOBJECT_API FString GetImportPathName(int32 ImportIndex);
    FString GetImportPathName(FPackageIndex PackageIndex)
    {
        if (PackageIndex.IsImport())
        {
            return GetImportPathName(PackageIndex.ToImport());
        }
        return FString();
    }
    COREUOBJECT_API FString GetExportPathName(const FString& RootPackagePath, int32 ExportIndex, bool bResolveForcedExports = false);
 
    COREUOBJECT_API FString GetImportFullName(int32 ImportIndex);
    FString GetImportFullName(FPackageIndex PackageIndex)
    {
        if (PackageIndex.IsImport())
        {
            return GetImportFullName(PackageIndex.ToImport());
        }
        return FString();
    }
 
    COREUOBJECT_API FString GetExportFullName(const FString& RootPackagePath, int32 ExportIndex, bool bResolveForcedExports = false);
 
    FPackageIndex ResourceGetOutermost(FPackageIndex LinkerIndex) const;
 
    bool ResourceIsIn(FPackageIndex LinkerIndex, FPackageIndex OuterIndex) const;
 
    bool DoResourcesShareOutermost(FPackageIndex LinkerIndexLHS, FPackageIndex LinkerIndexRHS) const;
 
    bool ImportIsInAnyExport(int32 ImportIndex) const;
 
    bool AnyExportIsInImport(int32 ImportIndex) const;
 
    bool AnyExportShareOuterWithImport(int32 ImportIndex) const;
 
    COREUOBJECT_API FName GetExportClassName(int32 ExportIdx);
    FName GetExportClassName(FPackageIndex PackageIndex)
    {
        if (PackageIndex.IsExport())
        {
            return GetExportClassName(PackageIndex.ToExport());
        }
        return FName();
    }
    FName GetImportClassName(int32 ImportIdx)
    {
        return ImportMap[ImportIdx].ClassName;
    }
    FName GetImportClassName(FPackageIndex PackageIndex)
    {
        if (PackageIndex.IsImport())
        {
            return GetImportClassName(PackageIndex.ToImport());
        }
        return FName();
    }
    FName GetClassName(FPackageIndex PackageIndex)
    {
        if (PackageIndex.IsImport())
        {
            return GetImportClassName(PackageIndex);
        }
        else if (PackageIndex.IsExport())
        {
            return GetExportClassName(PackageIndex);
        }
        return FName();
    }
 
    COREUOBJECT_API SIZE_T GetAllocatedSize() const;
};
 
/*----------------------------------------------------------------------------
    FLinker.
----------------------------------------------------------------------------*/
namespace ELinkerType
{
    enum Type
    {
        None,
        Load,
        Save
    };
}
 
class FLinker : public FLinkerTables
{
private:    
 
    ELinkerType::Type LinkerType;
 
public:
 
    UPackage*               LinkerRoot;
 
    FPackageFileSummary     Summary;
 
    TArray<FNameEntryId>    NameMap;
 
    TArray<FSoftObjectPath> SoftObjectPathList;
 
    TArray<FGatherableTextData> GatherableTextDataMap;
    
    TArray<FObjectDataResource> DataResourceMap;
 
    TMap<FPackageIndex, UE::Serialization::Private::FImportTypeHierarchy> ImportTypeHierarchies;
 
    bool                    FilterClientButNotServer;
 
    bool                    FilterServerButNotClient;
 
    UE_DEPRECATED(5.6, "No longer supported. Contact Epic if you need this functionality.")
    class FSHA1*            ScriptSHA = nullptr;
 
    FLinker(ELinkerType::Type InType, UPackage* InRoot);
 
    virtual ~FLinker();
 
    UE_FORCEINLINE_HINT ELinkerType::Type GetType() const
    {
        return LinkerType;
    }
 
    virtual FString GetDebugName() const;
 
    void Serialize(FArchive& Ar);
    
    COREUOBJECT_API FString GetExportPathName(int32 ExportIndex, const TCHAR* FakeRoot = nullptr, bool bResolveForcedExports = false);
 
    FString GetExportPathName(FPackageIndex PackageIndex, const TCHAR* FakeRoot = nullptr, bool bResolveForcedExports = false)
    {
        if (PackageIndex.IsExport())
        {
            return GetExportPathName(PackageIndex.ToExport(), FakeRoot, bResolveForcedExports);
        }
        return FString();
    }
 
    FString GetPathName(FPackageIndex PackageIndex)
    {
        if (PackageIndex.IsImport())
        {
            return GetImportPathName(PackageIndex);
        }
        else if (PackageIndex.IsExport())
        {
            return GetExportPathName(PackageIndex);
        }
        return FString();
    }
 
    COREUOBJECT_API FString GetExportFullName(int32 ExportIndex, const TCHAR* FakeRoot = nullptr, bool bResolveForcedExports = false);
 
    FString GetExportFullName(FPackageIndex PackageIndex, const TCHAR* FakeRoot = nullptr, bool bResolveForcedExports = false)
    {
        if (PackageIndex.IsExport())
        {
            return GetExportFullName(PackageIndex.ToExport(), FakeRoot, bResolveForcedExports);
        }
        return FString();
    }
 
    FString GetFullImpExpName(FPackageIndex PackageIndex)
    {
        if (PackageIndex.IsImport())
        {
            return GetImportFullName(PackageIndex);
        }
        else if (PackageIndex.IsExport())
        {
            return GetExportFullName(PackageIndex);
        }
        return FString();
    }
 
    UE_DEPRECATED(5.6, "No longer supported. Contact Epic if you need this functionality.")
    void StartScriptSHAGeneration();
    UE_DEPRECATED(5.6, "No longer supported. Contact Epic if you need this functionality.")
    void UpdateScriptSHAKey(const TArray<uint8>& ScriptCode);
    UE_DEPRECATED(5.6, "No longer supported. Contact Epic if you need this functionality.")
    void GetScriptSHAKey(uint8* OutKey);
 
    bool FilterExport(const FObjectExport& Export)
    {
        if (Export.bExportLoadFailed || Export.bWasFiltered)
        {
            return true;
        }
#if WITH_EDITOR
        if (!Export.bNotAlwaysLoadedForEditorGame) // Always load, even if is editor only
        {
            return false;
        }
#endif
        if (FilterClientButNotServer && Export.bNotForServer) // "we are a dedicated server"
        {
            return true;
        }
        if (FilterServerButNotClient && Export.bNotForClient) // "we are a client only"
        {
            return true;
        }
        if (Export.ThisIndex.IsNull()) // Export is invalid and shouldn't be processed.
        {
            return true;
        }
        return false;
    }
 
};
 
 
 
template<typename T> 
UE_FORCEINLINE_HINT T* Cast(FLinker* Src)
{
    return Src && T::StaticType() == Src->GetType() ? (T*)Src : nullptr;
}
 
template<typename T>
inline T* CastChecked(FLinker* Src)
{
    T* LinkerCastResult = Src && T::StaticType() == Src->GetType() ? (T*)Src : nullptr;
    check(LinkerCastResult);
    return LinkerCastResult;
}
 
/*-----------------------------------------------------------------------------
    Lazy loading.
-----------------------------------------------------------------------------*/
 
typedef uint32 ELazyLoaderFlags;
 
#define LLF_None                    0x00000000
#define LLF_PayloadInSeparateFile   0x00000001
#define LLF_SerializeCompressed     0x00000002
#define LLF_AllFlags                0xFFFFFFFF
 
/*-----------------------------------------------------------------------------
    Global functions
-----------------------------------------------------------------------------*/
 
UE_DEPRECATED(5.4, "Use GetPackageLinker instead")
COREUOBJECT_API FLinkerLoad* LoadPackageLinker(UPackage* InOuter, const FPackagePath& PackagePath, uint32 LoadFlags, UPackageMap* Sandbox, FArchive* InReaderOverride, TFunctionRef<void(FLinkerLoad* LoadedLinker)> LinkerLoadedCallback);
UE_DEPRECATED(5.4, "Use GetPackageLinker instead")
COREUOBJECT_API FLinkerLoad* LoadPackageLinker(UPackage* InOuter, const FPackagePath& PackagePath, uint32 LoadFlags = LOAD_None, UPackageMap* Sandbox = nullptr, FArchive* InReaderOverride = nullptr);
 
COREUOBJECT_API FLinkerLoad* GetPackageLinker(UPackage* InOuter, const FPackagePath& PackagePath, uint32 LoadFlags, UPackageMap* Sandbox, FArchive* InReaderOverride = nullptr, FUObjectSerializeContext** InOutLoadContext = nullptr, FLinkerLoad* ImportLinker = nullptr, const FLinkerInstancingContext* InstancingContext = nullptr);
 
COREUOBJECT_API FString GetPrestreamPackageLinkerName(const TCHAR* InLongPackageName, bool bSkipIfExists = true);
 
COREUOBJECT_API void ResetLinkerExports(UPackage* InPackage);
 
COREUOBJECT_API void ResetLoaders(UObject* InOuter);
COREUOBJECT_API void ResetLoaders(TConstArrayView<UObject*> InOuters);
 
 
COREUOBJECT_API void ConditionalFlushAsyncLoadingForSave(UPackage* InPackage);
 
COREUOBJECT_API void ResetLoadersForSave(UPackage* Package, const TCHAR* Filename);
 
COREUOBJECT_API void ResetLoadersForSave(TConstArrayView<FPackageSaveInfo> InPackages);
 
COREUOBJECT_API void DeleteLoaders();
 
COREUOBJECT_API void DeleteLoader(FLinkerLoad* Loader);
 
/*
 * Ensure all data that can be loaded from the linker (thumbnails, bulk data) is loaded, in preparation for saving out the given package
 *
 * @param Package   The the package for which the linker should be fully loaded
 */
COREUOBJECT_API void EnsureLoadingComplete(UPackage* Package);