UObjectThreadContext.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    UnAsyncLoading.cpp: Unreal async loading code.
=============================================================================*/
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/ContainerAllocationPolicies.h"
#include "Containers/Map.h"
#include "Containers/Set.h"
#include "CoreMinimal.h"
#include "CoreTypes.h"
#include "HAL/PlatformCrt.h"
#include "HAL/ThreadSafeCounter.h"
#include "HAL/ThreadSingleton.h"
#include "Logging/LogCategory.h"
#include "Logging/LogMacros.h"
#include "Misc/AssertionMacros.h"
#include "Templates/RefCounting.h"
#include "Templates/UnrealTemplate.h"
#include "Trace/Detail/Channel.h"
#include "UObject/PropertyPathName.h"
#include "UObject/ObjectMacros.h"
 
class FLinkerLoad;
class FName;
class FObjectInitializer;
class IAsyncPackageLoader;
class UObject;
struct FUObjectSerializeContext;
 
COREUOBJECT_API DECLARE_LOG_CATEGORY_EXTERN(LogUObjectThreadContext, Log, All);
 
UE_DECLARE_THREAD_SINGLETON_TLS(class FUObjectThreadContext, COREUOBJECT_API)
 
class FUObjectThreadContext : public TThreadSingleton<FUObjectThreadContext>
{
    friend TThreadSingleton<FUObjectThreadContext>;
 
    COREUOBJECT_API FUObjectThreadContext();
    COREUOBJECT_API virtual ~FUObjectThreadContext();
#if WITH_EDITORONLY_DATA
    // Remove declaration of manual constructors after removing deprecated PackagesMarkedEditorOnlyByOtherPackage
    COREUOBJECT_API FUObjectThreadContext(const FUObjectThreadContext& Other);
    COREUOBJECT_API FUObjectThreadContext(FUObjectThreadContext&& Other);
#endif
 
    TArray<FObjectInitializer*> InitializerStack;
 
public:
    
    void PopInitializer()
    {
        InitializerStack.Pop(EAllowShrinking::No);
    }
 
    void PushInitializer(FObjectInitializer* Initializer)
    {
        InitializerStack.Push(Initializer);
    }
 
    FObjectInitializer* TopInitializer()
    {
        return InitializerStack.Num() ? InitializerStack.Last() : nullptr;
    }
 
    FObjectInitializer& TopInitializerChecked()
    {
        if (FObjectInitializer* ObjectInitializerPtr = TopInitializer())
        {
            return *ObjectInitializerPtr;
        }
        return ReportNull();
    }
 
    bool IsRoutingPostLoad;
    bool IsDeletingLinkers;
    /* Global int to track how many nested loads we're doing by triggering an async load and immediately flushing that request. */
    int32 SyncLoadUsingAsyncLoaderCount;
    /* Global flag so that FObjectFinders know if they are called from inside the UObject constructors or not. */
    int32 IsInConstructor;
    /* Object that is currently being constructed with ObjectInitializer */
    UObject* ConstructedObject;
    UObject* CurrentlyPostLoadedObjectByALT;
    void* AsyncPackage;
    IAsyncPackageLoader* AsyncPackageLoader;
    EInternalObjectFlags AsyncVisibilityFilter = EInternalObjectFlags::None;
 
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
    TArray<UObject*, TInlineAllocator<16>> PostInitPropertiesCheck;
    TArray<UObject*, TInlineAllocator<16> > DebugPostLoad;
#endif
#if WITH_EDITORONLY_DATA
    UE_DEPRECATED(5.5, "No longer used; skiponlyeditoronly is used instead and tracks editoronly references via savepackage results.")
    TMap<FName, TSet<FName>> PackagesMarkedEditorOnlyByOtherPackage;
#endif
 
    FUObjectSerializeContext* GetSerializeContext()
    {
        return SerializeContext;
    }
 
private:
    COREUOBJECT_API FObjectInitializer& ReportNull();
 
    TRefCountPtr<FUObjectSerializeContext> SerializeContext;
};
 
struct FUObjectSerializeContext
{
    friend class FUObjectThreadContext;
 
private:
 
    COREUOBJECT_API FUObjectSerializeContext();
 
    COREUOBJECT_API ~FUObjectSerializeContext();
 
    int32 RefCount;
 
    int32 ImportCount;
    int32 ForcedExportCount;
    int32 ObjBeginLoadCount;
    TArray<UObject*> ObjectsLoaded;
    TArray<FLinkerLoad*> DelayedLinkerClosePackages;
 
public:
 
    UObject* SerializedObject;
    FLinkerLoad* SerializedPackageLinker;
    int32 SerializedImportIndex;
    FLinkerLoad* SerializedImportLinker;
    int32 SerializedExportIndex;
    FLinkerLoad* SerializedExportLinker;
#if WITH_EDITORONLY_DATA
    UE_INTERNAL int64 SerializedObjectScriptStartOffset = -1;
    UE_INTERNAL int64 SerializedObjectScriptEndOffset = -1;
    UE_INTERNAL UE::FPropertyPathName SerializedPropertyPath;
    UE_INTERNAL bool bTrackSerializedPropertyPath;
    UE_INTERNAL bool bTrackInitializedProperties;
    UE_INTERNAL bool bTrackSerializedProperties;
    UE_INTERNAL bool bTrackUnknownProperties;
    UE_INTERNAL bool bTrackUnknownEnumNames;
    UE_INTERNAL bool bImpersonateProperties;
#endif
 
    COREUOBJECT_API void AddLoadedObject(UObject* InObject);
    COREUOBJECT_API void AddUniqueLoadedObjects(const TArray<UObject*>& InObjects);
 
    bool HasStartedLoading() const
    {
        return ObjBeginLoadCount > 0;
    }
    int32 GetBeginLoadCount() const
    {
        return ObjBeginLoadCount;
    }
 
    COREUOBJECT_API int32 IncrementBeginLoadCount();
    COREUOBJECT_API int32 DecrementBeginLoadCount();
 
    int32 IncrementImportCount()
    {
        return ++ImportCount;
    }
    void ResetImportCount()
    {
        ImportCount = 0;
    }
 
    int32 IncrementForcedExportCount()
    {
        return ++ForcedExportCount;
    }
    void ResetForcedExports()
    {
        ForcedExportCount = 0;
    }
 
    bool HasPendingImportsOrForcedExports() const
    {
        return ImportCount || ForcedExportCount;
    }
 
    bool HasLoadedObjects() const
    {
        return !!ObjectsLoaded.Num();
    }
 
    COREUOBJECT_API bool PRIVATE_PatchNewObjectIntoExport(UObject* OldObject, UObject* NewObject);
 
    TArray<UObject*>& PRIVATE_GetObjectsLoadedInternalUseOnly()
    {
        return ObjectsLoaded;
    }
 
    void AppendLoadedObjectsAndEmpty(TArray<UObject*>& InLoadedObject)
    {
        InLoadedObject.Append(ObjectsLoaded);
        ObjectsLoaded.Reset();
    }
 
    void ReserveObjectsLoaded(int32 InReserveSize)
    {
        ObjectsLoaded.Reserve(InReserveSize);
    }
 
    int32 GetNumObjectsLoaded() const
    {
        return ObjectsLoaded.Num();
    }
 
    void AddDelayedLinkerClosePackage(class FLinkerLoad* InLinker)
    {
        DelayedLinkerClosePackages.AddUnique(InLinker);
    }
 
    void RemoveDelayedLinkerClosePackage(class FLinkerLoad* InLinker)
    {
        DelayedLinkerClosePackages.Remove(InLinker);
    }
 
    void MoveDelayedLinkerClosePackages(TArray<class FLinkerLoad*>& OutDelayedLinkerClosePackages)
    {
        OutDelayedLinkerClosePackages = MoveTemp(DelayedLinkerClosePackages);
    }
 
    UE_DEPRECATED(5.5, "AttachLinker is not necessary. Remove calls to it.")
    COREUOBJECT_API void AttachLinker(FLinkerLoad* InLinker);
    
    UE_DEPRECATED(5.5, "DetachLinker is not necessary. Remove calls to it.")
    COREUOBJECT_API void DetachLinker(FLinkerLoad* InLinker);
 
    UE_DEPRECATED(5.5, "DetachFromLinkers is not necessary. Remove calls to it.")
    COREUOBJECT_API void DetachFromLinkers();
 
    //~ TRefCountPtr interface
    int32 AddRef()
    {
        return ++RefCount;
    }
    int32 Release()
    {
        int32 CurrentRefCount = --RefCount;
        check(CurrentRefCount >= 0);
        if (CurrentRefCount == 0)
        {
            delete this;
        }
        return CurrentRefCount;
    }
    int32 GetRefCount() const
    {
        return RefCount;
    }
    //~ TRefCountPtr interface
};