Object.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
/*=============================================================================
    Object.h: Direct base class for all UE objects
=============================================================================*/
 
#include "UObject/Script.h"
#include "UObject/ObjectMacros.h"
#include "UObject/UObjectBaseUtility.h"
#include "UObject/ObjectCompileContext.h"
#include "ProfilingDebugging/ResourceSize.h"
#include "UObject/PrimaryAssetId.h"
#include "Containers/VersePathFwd.h"
 
#include "Object.generated.h"
 
struct FAssetData;
class FAssetRegistryTagsContext;
namespace UE::AssetRegistry { class FAssetRegistryImpl; }
namespace UE::ConfigAccessTracking { struct FConfigAccessData; }
namespace UE::Cook { class FCookEventContext; }
namespace UE::Cook { enum class ECookEvent : uint32; }
class FConfigCacheIni;
class FCustomPropertyConditionState;
class FEditPropertyChain;
class FObjectCollectSaveOverridesContext;
class FObjectPostSaveContext;
class FObjectPostSaveRootContext;
class FObjectPreSaveContext;
class FObjectPreSaveRootContext;
class ITargetPlatform;
class ITransactionObjectAnnotation;
class FTransactionObjectEvent;
struct FArchiveCookContext;
struct FAppendToClassSchemaContext;
struct FFrame;
struct FObjectInstancingGraph;
struct FPropertyChangedChainEvent;
struct FTopLevelAssetPath;
class UClass;
 
namespace UE::Net
{
    class FFragmentRegistrationContext;
    enum class EFragmentRegistrationFlags : uint32;
    namespace Private
    {
        struct FNetHandleLegacyPushModelHelper;
    }
}
 
DECLARE_LOG_CATEGORY_EXTERN(LogObj, Log, All);
 
namespace ECastCheckedType
{
    enum Type
    {
        NullAllowed,
        NullChecked
    };
};
 
#if WITH_EDITOR
enum class EEditChangePropagationFlags : uint8
{
    None = 0,
     OnlyMarkRealignedInstancesAsDirty = (1 << 0),
};
 
ENUM_CLASS_FLAGS(EEditChangePropagationFlags);
#endif // WITH_EDITOR
 
UCLASS(Abstract, MinimalAPI, Config = Engine)
class UObject : public UObjectBaseUtility
{
    GENERATED_BODY()
 
public:
    typedef UObject WithinClass;
 
    COREUOBJECT_API UObject();
 
    COREUOBJECT_API UObject(const FObjectInitializer& ObjectInitializer);
 
    COREUOBJECT_API UObject(EStaticConstructor, EObjectFlags InFlags);
 
    COREUOBJECT_API UObject(FVTableHelper& Helper);
 
#if UE_WITH_CONSTINIT_UOBJECT
    explicit consteval UObject(UE::CodeGen::ConstInit::FObjectParams InParams)
        : UObjectBaseUtility(InParams)
    {
    }
#endif
 
    COREUOBJECT_API UObject* CreateDefaultSubobject(FName SubobjectFName, UClass* ReturnType, UClass* ClassToCreateByDefault, bool bIsRequired, bool bIsTransient);
 
    template<class TReturnType>
    TReturnType* CreateEditorOnlyDefaultSubobject(FName SubobjectName, bool bTransient = false)
    {
        UClass* ReturnType = TReturnType::StaticClass();
        return static_cast<TReturnType*>(CreateEditorOnlyDefaultSubobjectImpl(SubobjectName, ReturnType, bTransient));
    }
 
    template<class TReturnType>
    TReturnType* CreateDefaultSubobject(FName SubobjectName, bool bTransient = false)
    {
        UClass* ReturnType = TReturnType::StaticClass();
        return static_cast<TReturnType*>(CreateDefaultSubobject(SubobjectName, ReturnType, ReturnType, /*bIsRequired =*/ true, bTransient));
    }
    
    template<class TReturnType, class TClassToConstructByDefault>
    TReturnType* CreateDefaultSubobject(FName SubobjectName, bool bTransient = false)
    {
        return static_cast<TReturnType*>(CreateDefaultSubobject(SubobjectName, TReturnType::StaticClass(), TClassToConstructByDefault::StaticClass(), /*bIsRequired =*/ true, bTransient));
    }
    
    template<class TReturnType>
    TReturnType* CreateOptionalDefaultSubobject(FName SubobjectName, bool bTransient = false)
    {
        UClass* ReturnType = TReturnType::StaticClass();
        return static_cast<TReturnType*>(CreateDefaultSubobject(SubobjectName, ReturnType, ReturnType, /*bIsRequired =*/ false, bTransient));
    }
    
    template<class TReturnType, class TClassToConstructByDefault>
    TReturnType* CreateOptionalDefaultSubobject(FName SubobjectName, bool bTransient = false)
    {
        return static_cast<TReturnType*>(CreateDefaultSubobject(SubobjectName, TReturnType::StaticClass(), TClassToConstructByDefault::StaticClass(), /*bIsRequired =*/ false, bTransient));
    }
 
    COREUOBJECT_API void GetDefaultSubobjects(TArray<UObject*>& OutDefaultSubobjects);
 
    COREUOBJECT_API UObject* GetDefaultSubobjectByName(FName ToFind);
 
    /*----------------------------------
            UObject interface
    ----------------------------------*/
 
protected:
    virtual FString GetDetailedInfoInternal() const { return TEXT("No_Detailed_Info_Specified"); }
 
public:
    COREUOBJECT_API virtual void PostInitProperties();
    
    COREUOBJECT_API virtual void PostReinitProperties();
 
    virtual void PostCDOContruct()
    {
    }
 
#if WITH_EDITOR
    using FPostCDOCompiledContext = FObjectPostCDOCompiledContext;
 
    virtual void PostCDOCompiled(const FPostCDOCompiledContext& Context)
    {
    }
 
    UE_DEPRECATED(5.1, "Use version that takes FPostCDOCompiledContext instead.")
    virtual void PostCDOCompiled()
    {
    }
#endif
 
    COREUOBJECT_API virtual void PreSaveRoot(FObjectPreSaveRootContext ObjectSaveContext);
 
    COREUOBJECT_API virtual void PostSaveRoot(FObjectPostSaveRootContext ObjectSaveContext);
 
    COREUOBJECT_API virtual void PreSave(FObjectPreSaveContext SaveContext);
 
    COREUOBJECT_API virtual void CollectSaveOverrides(FObjectCollectSaveOverridesContext SaveContext);
 
#if WITH_EDITOR
    virtual void OnCookEvent(UE::Cook::ECookEvent CookEvent, UE::Cook::FCookEventContext& Context)
    {
    }
 
    COREUOBJECT_API virtual bool Modify( bool bAlwaysMarkDirty=true );
 
    COREUOBJECT_API virtual bool IsCapturingAsRootObjectForTransaction() const;
 
    COREUOBJECT_API bool CanModify() const;
 
#else
    UE_FORCEINLINE_HINT bool Modify(bool bAlwaysMarkDirty = true) { return false; }
    UE_FORCEINLINE_HINT bool IsCapturingAsRootObjectForTransaction() const { return false; };
#endif
 
#if WITH_EDITOR
    virtual void LoadedFromAnotherClass(const FName& OldClassName) {}
#endif
 
    virtual bool ResolveSubobject(const TCHAR* SubObjectPath, UObject*& OutObject, bool bLoadIfExists) { return false; }
 
    virtual bool IsReadyForAsyncPostLoad() const { return true; }
 
    COREUOBJECT_API virtual void PostLoad();
 
    COREUOBJECT_API virtual void PostLoadSubobjects(FObjectInstancingGraph* OuterInstanceGraph);
    
    COREUOBJECT_API virtual void BeginDestroy();
 
    virtual bool IsReadyForFinishDestroy() { return true; }
 
#if WITH_EDITOR
    virtual void PostLinkerChange() {}
#endif
 
    COREUOBJECT_API virtual void FinishDestroy();
 
    COREUOBJECT_API virtual void Serialize(FArchive& Ar);
    COREUOBJECT_API virtual void Serialize(FStructuredArchive::FRecord Record);
#if WITH_EDITORONLY_DATA
    static COREUOBJECT_API void DeclareCustomVersions(FArchive& Ar, const UClass* SpecificSubclass);
    static COREUOBJECT_API void AppendToClassSchema(FAppendToClassSchemaContext& Context);
    static COREUOBJECT_API void DeclareConstructClasses(TArray<FTopLevelAssetPath>& OutConstructClasses, const UClass* SpecificSubclass);
#endif
 
    virtual void ShutdownAfterError() {}
 
    UE_DEPRECATED(5.3, "Matinee has been removed in 5.0, nothing is calling PostInterpChange anymore")
    virtual void PostInterpChange(FProperty* PropertyThatChanged) {}
 
#if WITH_EDITOR
    COREUOBJECT_API virtual void PreEditChange(FProperty* PropertyAboutToChange);
 
    COREUOBJECT_API virtual void PreEditChange( class FEditPropertyChain& PropertyAboutToChange );
 
    COREUOBJECT_API virtual bool CanEditChange( const FProperty* InProperty ) const;
 
    COREUOBJECT_API virtual bool CanEditChange(const FEditPropertyChain& PropertyChain) const;
 
    COREUOBJECT_API void PostEditChange();
 
    COREUOBJECT_API virtual void PostEditChangeProperty( struct FPropertyChangedEvent& PropertyChangedEvent);
 
    COREUOBJECT_API virtual void PostEditChangeChainProperty( struct FPropertyChangedChainEvent& PropertyChangedEvent );
 
    COREUOBJECT_API void SetEditChangePropagationFlags(EEditChangePropagationFlags InFlags);
 
    COREUOBJECT_API virtual void PreEditUndo();
 
    COREUOBJECT_API virtual void PostEditUndo();
 
    COREUOBJECT_API virtual void PostEditUndo(TSharedPtr<ITransactionObjectAnnotation> TransactionAnnotation);
 
    COREUOBJECT_API virtual void PostTransacted(const FTransactionObjectEvent& TransactionEvent);
 
    COREUOBJECT_API TSharedPtr<ITransactionObjectAnnotation> FindOrCreateTransactionAnnotation() const;
 
    COREUOBJECT_API TSharedPtr<ITransactionObjectAnnotation> CreateAndRestoreTransactionAnnotation(FArchive& Ar) const;
 
protected:
    enum class ETransactionAnnotationCreationMode : uint8 { DefaultInstance, FindOrCreate };
    virtual TSharedPtr<ITransactionObjectAnnotation> FactoryTransactionAnnotation(const ETransactionAnnotationCreationMode InCreationMode) const { return nullptr; }
 
    COREUOBJECT_API virtual bool IsSelectedInEditor() const;
 
public:
#endif // WITH_EDITOR
 
    COREUOBJECT_API virtual void PostRename(UObject* OldOuter, const FName OldName);
 
    virtual void PreDuplicate(FObjectDuplicationParameters& DupParams) {}
 
    virtual void PostDuplicate(bool bDuplicateForPIE) {}
    virtual void PostDuplicate(EDuplicateMode::Type DuplicateMode) 
    {
        PostDuplicate(DuplicateMode == EDuplicateMode::PIE);
    }
 
#if UE_WITH_REMOTE_OBJECT_HANDLE
    virtual void PostMigrate(const struct FUObjectMigrationContext& MigrationContext) {}
 
    virtual bool IsMigrationRoot() const { return false; }
#endif
 
    COREUOBJECT_API virtual bool NeedsLoadForClient() const;
 
    COREUOBJECT_API virtual bool NeedsLoadForServer() const;
 
    COREUOBJECT_API virtual bool NeedsLoadForTargetPlatform(const class ITargetPlatform* TargetPlatform) const;
 
    virtual bool NeedsLoadForEditorGame() const
    {
        return false;
    }
 
    virtual bool IsEditorOnly() const
    {
        return false;
    }
 
    virtual bool HasNonEditorOnlyReferences() const
    {
        return false;
    }
 
    virtual bool IsPostLoadThreadSafe() const
    {
        return false;
    }
 
    UE_DEPRECATED(5.5, "Multithreaded destruction of UObjects is no longer supported.")
    COREUOBJECT_API virtual bool IsDestructionThreadSafe() const;
 
    COREUOBJECT_API virtual void GetPreloadDependencies(TArray<UObject*>& OutDeps);
 
    virtual void GetPrestreamPackages(TArray<UObject*>& OutPrestream)
    {
    }
 
    static COREUOBJECT_API void UpdateClassesExcludedFromDedicatedServer(const TArray<FString>& InClassNames, const TArray<FString>& InModulesNames);
 
    static COREUOBJECT_API void UpdateClassesExcludedFromDedicatedClient(const TArray<FString>& InClassNames, const TArray<FString>& InModulesNames);
 
    static COREUOBJECT_API bool CanCreateInCurrentContext(UObject* Template);
 
    virtual void ExportCustomProperties(FOutputDevice& Out, uint32 Indent)  {}
 
    virtual void ImportCustomProperties(const TCHAR* SourceText, FFeedbackContext* Warn) {}
 
    virtual void PostEditImport() {}
 
    virtual void PostReloadConfig( class FProperty* PropertyThatWasLoaded ) {}
 
    COREUOBJECT_API virtual bool Rename(const TCHAR* NewName=nullptr, UObject* NewOuter=nullptr, ERenameFlags Flags=REN_None);
 
    virtual FString GetDesc() { return TEXT( "" ); }
 
    COREUOBJECT_API UScriptStruct* GetSparseClassDataStruct() const;
 
#if WITH_EDITOR
    virtual void MoveDataToSparseClassDataStruct() const {}
    virtual bool ConformSparseClassDataStruct(UScriptStruct* SourceSparseClassDataStruct, void* SourceSparseClassData) const { return false; }
#endif
 
#if WITH_ENGINE
    COREUOBJECT_API virtual class UWorld* GetWorld() const;
 
    COREUOBJECT_API class UWorld* GetWorldChecked(bool& bSupported) const;
 
#if WITH_EDITOR
    COREUOBJECT_API virtual bool ImplementsGetWorld() const;
#endif // #if WITH_EDITOR
 
#endif // #if WITH_ENGINE
 
    virtual bool GetNativePropertyValues( TMap<FString,FString>& out_PropertyValues, uint32 ExportFlags=0 ) const
    {
        return false;
    }
 
    COREUOBJECT_API virtual void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize);
 
    SIZE_T GetResourceSizeBytes(EResourceSizeMode::Type Mode)
    {
        FResourceSizeEx ResSize = FResourceSizeEx(Mode);
        GetResourceSizeEx(ResSize);
        return ResSize.GetTotalMemoryBytes();
    }
 
    virtual FName GetExporterName( void )
    {
        return( FName( TEXT( "" ) ) );
    }
 
    static COREUOBJECT_API void AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector);
 
    COREUOBJECT_API void CallAddReferencedObjects(FReferenceCollector& Collector);
 
#if WITH_VERSE_VM || defined(__INTELLISENSE__)
    COREUOBJECT_API void VerseMarkAsReachable() const;
#endif
 
    virtual FRestoreForUObjectOverwrite* GetRestoreForUObjectOverwrite()
    {
        return NULL;
    }
 
    virtual bool AreNativePropertiesIdenticalTo( UObject* Other ) const
    {
        return true;
    }
 
    struct FAssetRegistryTag
    {
        enum ETagType
        {
            TT_Hidden,
            TT_Alphabetical,
            TT_Numerical,
            TT_Dimensional,
            TT_Chronological,
        };
 
        enum ETagDisplay
        {
            TD_None = 0,
            TD_Date = 1<<0,
            TD_Time = 1<<1,
            TD_InvariantTz = 1<<2,
            TD_Memory = 1<<3,
        };
        
        FName Name;
 
        FString Value;
 
        ETagType Type = TT_Alphabetical;
 
        uint32 DisplayFlags = TD_None;
 
        FAssetRegistryTag() = default;
        FAssetRegistryTag(FName InName, const FString& InValue, ETagType InType, uint32 InDisplayFlags = TD_None)
            : Name(InName), Value(InValue), Type(InType), DisplayFlags(InDisplayFlags) {}
        FAssetRegistryTag(FName InName, FString&& InValue, ETagType InType, uint32 InDisplayFlags = TD_None)
            : Name(InName), Value(MoveTemp(InValue)), Type(InType), DisplayFlags(InDisplayFlags) {}
 
#if WITH_EDITOR
        DECLARE_TS_MULTICAST_DELEGATE_OneParam(FOnGetObjectAssetRegistryTagsWithContext, FAssetRegistryTagsContext);
        COREUOBJECT_API static FOnGetObjectAssetRegistryTagsWithContext OnGetExtraObjectTagsWithContext;
 
        DECLARE_TS_MULTICAST_DELEGATE_TwoParams(FOnGetObjectAssetRegistryTags, const UObject* /*Object*/, TArray<FAssetRegistryTag>& /*InOutTags*/);
        UE_DEPRECATED(5.4, "Subscribe to OnGetExtraObjectTagsWithContext instead")
        COREUOBJECT_API static FOnGetObjectAssetRegistryTags OnGetExtraObjectTags;
        DECLARE_TS_MULTICAST_DELEGATE_ThreeParams(FOnGetExtendedAssetRegistryTagsForSave, const UObject* /*Object*/, const ITargetPlatform* TargetPlatform, TArray<FAssetRegistryTag>& /*InOutTags*/);
        UE_DEPRECATED(5.4, "Subscribe to OnGetExtraObjectTagsWithContext instead, and early exit if !Context.IsSaving")
        COREUOBJECT_API static FOnGetExtendedAssetRegistryTagsForSave OnGetExtendedAssetRegistryTagsForSave;
#endif // WITH_EDITOR
    };
 
    COREUOBJECT_API virtual void GetAssetRegistryTags(FAssetRegistryTagsContext Context) const;
    UE_DEPRECATED(5.4, "Implement the version that takes FAssetRegistryTagsContext instead.")
    COREUOBJECT_API virtual void GetAssetRegistryTags(TArray<FAssetRegistryTag>& OutTags) const;
 
#if WITH_EDITOR
    COREUOBJECT_API virtual void GetAdditionalAssetDataObjectsForCook(FArchiveCookContext& CookContext,
        TArray<UObject*>& OutObjects) const;
    COREUOBJECT_API virtual void GetExtendedAssetRegistryTagsForSave(const ITargetPlatform* TargetPlatform, TArray<FAssetRegistryTag>& OutTags) const;
#endif // WITH_EDITOR
 
    COREUOBJECT_API void GetAssetRegistryTags(FAssetData& Out) const;
    COREUOBJECT_API void GetAssetRegistryTags(FAssetRegistryTagsContext Context, FAssetData& Out) const;
 
    static COREUOBJECT_API const FName& SourceFileTagName();
 
#if WITH_EDITOR
 
    UE_DEPRECATED(5.5, "This function is no longer called. If you require this functionality, please implement ThreadedPostLoadAssetRegistryTagsOverride. " \
        "Note that this function MUST be safe to call on a background thread. If you have functionality that doesn't meet that requirement, " \
        "consider using the AssetRegistry's AssetAddedEvent which fires on the game thread.")
    virtual void PostLoadAssetRegistryTags(const FAssetData& InAssetData, TArray<FAssetRegistryTag>& OutTagsAndValuesToUpdate) const final {}
 
    struct FPostLoadAssetRegistryTagsContext
    {
        FPostLoadAssetRegistryTagsContext(const FAssetData& InAssetData, TArray<FAssetRegistryTag>& InTagsAndValuesToUpdate,
            bool bInCanCreateObjects)
        : AssetData(InAssetData), TagsAndValuesToUpdate(InTagsAndValuesToUpdate), bCanCreateObjects(bInCanCreateObjects) { }
 
        const FAssetData& GetAssetData() const { return AssetData; }
        void AddTagToUpdate(const FAssetRegistryTag& Tag) { TagsAndValuesToUpdate.Add(Tag); }
 
        bool CanCreateObjects() const { return bCanCreateObjects; }
        bool PostLoadCouldComplete() const { return bPostLoadCouldComplete; }
        void SetPostLoadCouldComplete(bool bValue) { bPostLoadCouldComplete = bValue; }
    private:
        const FAssetData& AssetData;
        TArray<FAssetRegistryTag>& TagsAndValuesToUpdate;
        bool bCanCreateObjects = true;
        bool bPostLoadCouldComplete = true;
    };
 
protected:
    virtual void ThreadedPostLoadAssetRegistryTagsOverride(FPostLoadAssetRegistryTagsContext& Context) const {}
 
public:
 
    COREUOBJECT_API void ThreadedPostLoadAssetRegistryTags(FPostLoadAssetRegistryTagsContext& Context) const;
 
    struct FAssetRegistryTagMetadata
    {
        FText DisplayName;
        FText TooltipText;
        FText Suffix;
        FString ImportantValue;
 
        FAssetRegistryTagMetadata& SetDisplayName(const FText& InDisplayName)
        {
            DisplayName = InDisplayName;
            return *this;
        }
 
        FAssetRegistryTagMetadata& SetTooltip(const FText& InTooltipText)
        {
            TooltipText = InTooltipText;
            return *this;
        }
 
        FAssetRegistryTagMetadata& SetSuffix(const FText& InSuffix)
        {
            Suffix = InSuffix;
            return *this;
        }
 
        FAssetRegistryTagMetadata& SetImportantValue(const FString& InImportantValue)
        {
            ImportantValue = InImportantValue;
            return *this;
        }
    };
 
    COREUOBJECT_API virtual void GetAssetRegistryTagMetadata(TMap<FName, FAssetRegistryTagMetadata>& OutMetadata) const;
 
    static COREUOBJECT_API TSet<FName>& GetMetaDataTagsForAssetRegistry();
 
#endif
 
    COREUOBJECT_API virtual bool IsAsset() const;
 
    COREUOBJECT_API virtual FPrimaryAssetId GetPrimaryAssetId() const;
 
    COREUOBJECT_API virtual bool IsLocalizedResource() const;
 
    COREUOBJECT_API virtual bool IsSafeForRootSet() const;
 
    COREUOBJECT_API virtual void TagSubobjects(EObjectFlags NewFlags);
 
    COREUOBJECT_API virtual void GetLifetimeReplicatedProps( TArray< class FLifetimeProperty > & OutLifetimeProps ) const;
 
    COREUOBJECT_API virtual void GetReplicatedCustomConditionState(FCustomPropertyConditionState& OutActiveState) const;
    COREUOBJECT_API virtual void RegisterReplicationFragments(UE::Net::FFragmentRegistrationContext& Context, UE::Net::EFragmentRegistrationFlags RegistrationFlags);
 
    COREUOBJECT_API virtual bool IsNameStableForNetworking() const;
 
    COREUOBJECT_API virtual bool IsFullNameStableForNetworking() const;
 
    COREUOBJECT_API virtual bool IsSupportedForNetworking() const;
 
    UE_DEPRECATED(5.7, "This function is useless now and will be deleted")
    virtual void GetSubobjectsWithStableNamesForNetworking(TArray<UObject*> &ObjList) {}
 
    COREUOBJECT_API virtual void PreNetReceive();
 
    COREUOBJECT_API virtual void PostNetReceive();
 
    virtual void PostRepNotifies() {}
 
    COREUOBJECT_API virtual void PreDestroyFromReplication();
 
#if WITH_EDITOR
    COREUOBJECT_API virtual EDataValidationResult IsDataValid(class FDataValidationContext& Context) const;
 
    UE_DEPRECATED(5.3, "Please use the the const version of IsDataValid(FDataValidationContext&)")
    COREUOBJECT_API virtual EDataValidationResult IsDataValid(class FDataValidationContext& Context);
 
    UE_DEPRECATED(5.3, "Please use IsDataValid(FDataValidationContext&) const as the FDataValidationContext will allow distinguishing between Warnings and Errors.")
    COREUOBJECT_API virtual EDataValidationResult IsDataValid(TArray<FText>& ValidationErrors);
#endif // WITH_EDITOR
 
    /*----------------------------------------------------------
        Non virtual functions, not intended to be overridden
    ----------------------------------------------------------*/
 
    COREUOBJECT_API bool IsSelected() const;
 
#if WITH_EDITOR
    COREUOBJECT_API void PropagatePreEditChange( TArray<UObject*>& AffectedObjects, FEditPropertyChain& PropertyAboutToChange );
 
    COREUOBJECT_API void PropagatePostEditChange( TArray<UObject*>& AffectedObjects, FPropertyChangedChainEvent& PropertyChangedEvent );
#endif // WITH_EDITOR
 
    COREUOBJECT_API void SerializeScriptProperties( FArchive& Ar ) const;
 
    COREUOBJECT_API void SerializeScriptProperties( FStructuredArchive::FSlot Slot ) const;
 
    COREUOBJECT_API void ReinitializeProperties( UObject* SourceObject=NULL, struct FObjectInstancingGraph* InstanceGraph=NULL );
 
    COREUOBJECT_API FString GetDetailedInfo() const;
 
    COREUOBJECT_API bool ConditionalBeginDestroy();
 
    COREUOBJECT_API bool ConditionalFinishDestroy();
    
    COREUOBJECT_API void ConditionalPostLoad();
 
    COREUOBJECT_API void ConditionalPreload();
 
    COREUOBJECT_API void ConditionalPostLoadSubobjects( struct FObjectInstancingGraph* OuterInstanceGraph=NULL );
 
#if WITH_EDITOR
    virtual void BeginCacheForCookedPlatformData( const ITargetPlatform* TargetPlatform ) {  }
    
    virtual bool IsCachedCookedPlatformDataLoaded( const ITargetPlatform* TargetPlatform ) { return true; }
 
    virtual void WillNeverCacheCookedPlatformDataAgain() { }
 
    virtual void ClearCachedCookedPlatformData( const ITargetPlatform* TargetPlatform ) {  }
 
    virtual void ClearAllCachedCookedPlatformData() { }
 
    void CookAdditionalFiles(const TCHAR* PackageFilename, const ITargetPlatform* TargetPlatform,
        TFunctionRef<void(const TCHAR* Filename, void* Data, int64 Size)> WriteAdditionalFile)
    {
        CookAdditionalFilesOverride(PackageFilename, TargetPlatform, WriteAdditionalFile);
    }
 
private:
    virtual void CookAdditionalFilesOverride(const TCHAR* PackageFilename, const ITargetPlatform* TargetPlatform,
        TFunctionRef<void(const TCHAR* Filename, void* Data, int64 Size)> WriteAdditionalFile)
    {
    }
 
public:
#endif
    inline bool IsBasedOnArchetype( const UObject* const SomeObject ) const;
 
    COREUOBJECT_API UFunction* FindFunction( FName InName ) const;
    
    COREUOBJECT_API UFunction* FindFunctionChecked( FName InName ) const;
 
    COREUOBJECT_API virtual void BuildSubobjectMapping(UObject* OtherObject, TMap<UObject*, UObject*>& ObjectMapping) const;
 
    UE_DEPRECATED(5.4, "Call GetDefaultSubobjects for top level subobjects or use ForEachObjectWithOuter with a more precise check")
    COREUOBJECT_API void CollectDefaultSubobjects( TArray<UObject*>& OutDefaultSubobjects, bool bIncludeNestedSubobjects=false ) const;
 
    COREUOBJECT_API bool CheckDefaultSubobjects(bool bForceCheck = false) const;
 
    COREUOBJECT_API void SaveConfig(uint64 RequiredPropertyFlags = CPF_Config, const TCHAR* Filename = nullptr,
        FConfigCacheIni* Config=GConfig, bool bAllowCopyToDefaultObject = true);
 
    struct FSaveConfigContext
    {
        EPropertyFlags RequiredPropertyFlags = CPF_Config;
        FString Filename;
        FConfigCacheIni* ConfigSystem = GConfig;
        bool bAllowCopyToDefaultObject = true;
 
        bool bSaveToLayer = false;
        TSet<FName> PropertyNames = {};
        FString OverrideConfigSectionName;
    };
    COREUOBJECT_API void SaveConfig(const FSaveConfigContext& Context);
 
    UE_DEPRECATED(5.0, "TryUpdateDefaultConfigFile replaces UpdateDefaultConfigFile")
    COREUOBJECT_API void UpdateDefaultConfigFile(const FString& SpecificFileLocation = "");
 
    COREUOBJECT_API bool TryUpdateDefaultConfigFile(const FString& SpecificFileLocation = "", bool bWarnIfFail = true);
 
    COREUOBJECT_API void UpdateGlobalUserConfigFile();
 
    COREUOBJECT_API void UpdateProjectUserConfigFile();
 
    COREUOBJECT_API void UpdateSinglePropertyInConfigFile(const FProperty* InProperty, const FString& InConfigIniName);
 
private:
    COREUOBJECT_API void UpdateSingleSectionOfConfigFile(const FString& ConfigIniName);
 
    COREUOBJECT_API void EnsureNotRetrievingVTablePtr() const;
 
public:
    COREUOBJECT_API FString GetDefaultConfigFilename() const;
 
    COREUOBJECT_API FString GetGlobalUserConfigFilename() const;
 
    COREUOBJECT_API FString GetProjectUserConfigFilename() const;
 
#if WITH_EDITOR
    DECLARE_DELEGATE_RetVal_OneParam(bool, FOnGetPreviewPlatform, FName&);
    COREUOBJECT_API static FOnGetPreviewPlatform OnGetPreviewPlatform;
#endif
 
    virtual const TCHAR* GetConfigOverridePlatform() const { return nullptr; }
 
    virtual void OverrideConfigSection(FString& SectionName) {}
 
    virtual void OverridePerObjectConfigSection(FString& SectionName) {}
 
    COREUOBJECT_API void LoadConfig(UClass* ConfigClass = nullptr, const TCHAR* Filename = nullptr,
        uint32 PropagationFlags = UE::LCPF_None, class FProperty* PropertyToLoad = nullptr,
        TArray<UE::ConfigAccessTracking::FConfigAccessData>* OutAccessedKeys = nullptr);
 
    COREUOBJECT_API void ReloadConfig( UClass* ConfigClass=NULL, const TCHAR* Filename=NULL, uint32 PropagationFlags=UE::LCPF_None, class FProperty* PropertyToLoad=NULL );
 
    COREUOBJECT_API void ParseParms( const TCHAR* Parms );
 
    COREUOBJECT_API void OutputReferencers( FOutputDevice& Ar, FReferencerInformationList* Referencers=NULL );
    
    COREUOBJECT_API void RetrieveReferencers( TArray<FReferencerInformation>* OutInternalReferencers, TArray<FReferencerInformation>* OutExternalReferencers);
 
    COREUOBJECT_API void SetLinker( FLinkerLoad* LinkerLoad, int32 LinkerIndex, bool bShouldDetachExisting = true, bool bSilenceLogs = false);
 
    static COREUOBJECT_API UObject* GetArchetypeFromRequiredInfo(const UClass* Class, const UObject* Outer, FName Name, EObjectFlags ObjectFlags);
 
    COREUOBJECT_API UObject* GetArchetype() const;
 
    COREUOBJECT_API void GetArchetypeInstances( TArray<UObject*>& Instances );
 
    COREUOBJECT_API void InstanceSubobjectTemplates( struct FObjectInstancingGraph* InstanceGraph = NULL );
 
    template<class T>
    bool Implements() const;
 
 
    /*-----------------------------
            Virtual Machine
    -----------------------------*/
 
    COREUOBJECT_API virtual void ProcessEvent( UFunction* Function, void* Parms );
 
    virtual int32 GetFunctionCallspace( UFunction* Function, FFrame* Stack )
    {
        return FunctionCallspace::Local;
    }
 
    virtual bool CallRemoteFunction( UFunction* Function, void* Parms, struct FOutParmRec* OutParms, FFrame* Stack )
    {
        return false;
    }
 
    COREUOBJECT_API bool CallFunctionByNameWithArguments( const TCHAR* Cmd, FOutputDevice& Ar, UObject* Executor, bool bForceCallWithNonExec = false );
 
    COREUOBJECT_API void CallFunction( FFrame& Stack, RESULT_DECL, UFunction* Function );
 
    DECLARE_FUNCTION(ProcessInternal);
 
    virtual bool ProcessConsoleExec(const TCHAR* Cmd, FOutputDevice& Ar, UObject* Executor)
    {
        return CallFunctionByNameWithArguments(Cmd, Ar, Executor);
    }
 
    COREUOBJECT_API void SkipFunction(FFrame& Stack, RESULT_DECL, UFunction* Function);
 
    virtual UClass* RegenerateClass(UClass* ClassToRegenerate, UObject* PreviousCDO) { return NULL; };
 
    COREUOBJECT_API bool IsInBlueprint() const;
 
    COREUOBJECT_API void DestroyNonNativeProperties();
 
    virtual void MarkAsEditorOnlySubobject() { }
 
    COREUOBJECT_API void AbortInsideMemberFunction() const;
 
    // UnrealScript intrinsics, do not call directly
 
    // Undefined native handler
    DECLARE_FUNCTION(execUndefined);
 
    // Variables
    DECLARE_FUNCTION(execLocalVariable);
    DECLARE_FUNCTION(execInstanceVariable);
    DECLARE_FUNCTION(execDefaultVariable);
    DECLARE_FUNCTION(execLocalOutVariable);
    DECLARE_FUNCTION(execInterfaceVariable);
    DECLARE_FUNCTION(execClassSparseDataVariable);
    DECLARE_FUNCTION(execInterfaceContext);
    DECLARE_FUNCTION(execArrayElement);
    DECLARE_FUNCTION(execBoolVariable);
    DECLARE_FUNCTION(execClassDefaultVariable);
    DECLARE_FUNCTION(execEndFunctionParms);
 
    // Do Nothing 
    DECLARE_FUNCTION(execNothing);
    DECLARE_FUNCTION(execNothingInt32);
    DECLARE_FUNCTION(execNothingOp4a);
 
    DECLARE_FUNCTION(execBreakpoint);
 
    DECLARE_FUNCTION(execTracepoint);
    DECLARE_FUNCTION(execWireTracepoint);
 
    DECLARE_FUNCTION(execInstrumentation);
 
    DECLARE_FUNCTION(execEndOfScript);
 
    DECLARE_FUNCTION(execReturnNothing);
    DECLARE_FUNCTION(execEmptyParmValue);
 
    // Commands
    DECLARE_FUNCTION(execJump);
    DECLARE_FUNCTION(execJumpIfNot);
    DECLARE_FUNCTION(execAssert);
 
    DECLARE_FUNCTION(execPushExecutionFlow);
 
    DECLARE_FUNCTION(execPopExecutionFlow);
    DECLARE_FUNCTION(execComputedJump);
 
    DECLARE_FUNCTION(execPopExecutionFlowIfNot);
 
 
    // Assignment
    DECLARE_FUNCTION(execLet);
    DECLARE_FUNCTION(execLetObj);
    DECLARE_FUNCTION(execLetWeakObjPtr);
    DECLARE_FUNCTION(execLetBool);
    DECLARE_FUNCTION(execLetDelegate);
    DECLARE_FUNCTION(execLetMulticastDelegate);
 
    // Delegates 
    DECLARE_FUNCTION(execAddMulticastDelegate);
    DECLARE_FUNCTION(execClearMulticastDelegate);
    DECLARE_FUNCTION(execEatReturnValue);
    DECLARE_FUNCTION(execRemoveMulticastDelegate);
 
    // Context expressions
    DECLARE_FUNCTION(execSelf);
    DECLARE_FUNCTION(execContext);
    DECLARE_FUNCTION(execContext_FailSilent);
    DECLARE_FUNCTION(execStructMemberContext);
 
    // Function calls
    DECLARE_FUNCTION(execVirtualFunction);
    DECLARE_FUNCTION(execFinalFunction);
    DECLARE_FUNCTION(execLocalVirtualFunction);
    DECLARE_FUNCTION(execLocalFinalFunction);
 
    // Struct comparison
    DECLARE_FUNCTION(execStructCmpEq);
    DECLARE_FUNCTION(execStructCmpNe);
    DECLARE_FUNCTION(execStructMember);
 
    DECLARE_FUNCTION(execEqualEqual_DelegateDelegate);
    DECLARE_FUNCTION(execNotEqual_DelegateDelegate);
    DECLARE_FUNCTION(execEqualEqual_DelegateFunction);
    DECLARE_FUNCTION(execNotEqual_DelegateFunction);
 
    // Constants
    DECLARE_FUNCTION(execIntConst);
    DECLARE_FUNCTION(execInt64Const);
    DECLARE_FUNCTION(execUInt64Const);
    DECLARE_FUNCTION(execSkipOffsetConst);
    DECLARE_FUNCTION(execFloatConst);
    DECLARE_FUNCTION(execDoubleConst);
    DECLARE_FUNCTION(execStringConst);
    DECLARE_FUNCTION(execUnicodeStringConst);
    DECLARE_FUNCTION(execTextConst);
    DECLARE_FUNCTION(execPropertyConst);
    DECLARE_FUNCTION(execObjectConst);
    DECLARE_FUNCTION(execSoftObjectConst);
    DECLARE_FUNCTION(execFieldPathConst);
 
    DECLARE_FUNCTION(execInstanceDelegate);
    DECLARE_FUNCTION(execNameConst);
    DECLARE_FUNCTION(execByteConst);
    DECLARE_FUNCTION(execIntZero);
    DECLARE_FUNCTION(execIntOne);
    DECLARE_FUNCTION(execTrue);
    DECLARE_FUNCTION(execFalse);
    DECLARE_FUNCTION(execNoObject);
    DECLARE_FUNCTION(execNullInterface);
    DECLARE_FUNCTION(execIntConstByte);
    DECLARE_FUNCTION(execRotationConst);
    DECLARE_FUNCTION(execVectorConst);
    DECLARE_FUNCTION(execVector3fConst);
    DECLARE_FUNCTION(execTransformConst);
    DECLARE_FUNCTION(execStructConst);
    DECLARE_FUNCTION(execSetArray);
    DECLARE_FUNCTION(execSetSet);
    DECLARE_FUNCTION(execSetMap);
    DECLARE_FUNCTION(execArrayConst);
    DECLARE_FUNCTION(execSetConst);
    DECLARE_FUNCTION(execMapConst);
    DECLARE_FUNCTION(execBitFieldConst);
 
    // Object construction
    DECLARE_FUNCTION(execNew);
    DECLARE_FUNCTION(execClassContext);
    DECLARE_FUNCTION(execNativeParm);
 
    // Conversions 
    DECLARE_FUNCTION(execCast);
    DECLARE_FUNCTION(execDynamicCast);
    DECLARE_FUNCTION(execMetaCast);
    DECLARE_FUNCTION(execInterfaceCast);
    DECLARE_FUNCTION(execDoubleToFloatCast);
    DECLARE_FUNCTION(execFloatToDoubleCast);
    DECLARE_FUNCTION(execObjectToBool);
    DECLARE_FUNCTION(execInterfaceToBool);
    DECLARE_FUNCTION(execObjectToInterface);
    DECLARE_FUNCTION(execInterfaceToInterface);
    DECLARE_FUNCTION(execInterfaceToObject);
 
    // Dynamic array functions
    // Array support
    DECLARE_FUNCTION(execGetDynArrayElement);
    DECLARE_FUNCTION(execSetDynArrayElement);
    DECLARE_FUNCTION(execGetDynArrayLength);
    DECLARE_FUNCTION(execSetDynArrayLength);
    DECLARE_FUNCTION(execDynArrayInsert);
    DECLARE_FUNCTION(execDynArrayRemove);
    DECLARE_FUNCTION(execDynArrayFind);
    DECLARE_FUNCTION(execDynArrayFindStruct);
    DECLARE_FUNCTION(execDynArrayAdd);
    DECLARE_FUNCTION(execDynArrayAddItem);
    DECLARE_FUNCTION(execDynArrayInsertItem);
    DECLARE_FUNCTION(execDynArrayRemoveItem);
    DECLARE_FUNCTION(execDynArraySort);
 
    DECLARE_FUNCTION(execBindDelegate);
    DECLARE_FUNCTION(execCallMulticastDelegate);
 
    DECLARE_FUNCTION(execLetValueOnPersistentFrame);
 
    DECLARE_FUNCTION(execCallMathFunction);
 
    DECLARE_FUNCTION(execSwitchValue);
 
    DECLARE_FUNCTION(execArrayGetByRef);
 
    DECLARE_FUNCTION(execAutoRtfmTransact);
    DECLARE_FUNCTION(execAutoRtfmStopTransact);
    DECLARE_FUNCTION(execAutoRtfmAbortIfNot);
 
 
    UFUNCTION(BlueprintImplementableEvent, meta=(BlueprintInternalUseOnly = "true"))
    void ExecuteUbergraph(int32 EntryPoint);
 
protected: 
    COREUOBJECT_API bool CanCheckDefaultSubObjects(bool bForceCheck, bool& bResult) const;
 
    COREUOBJECT_API virtual bool CheckDefaultSubobjectsInternal() const;
 
private:
    COREUOBJECT_API void ProcessContextOpcode(FFrame& Stack, RESULT_DECL, bool bCanFailSilent);
 
    COREUOBJECT_API UObject* CreateEditorOnlyDefaultSubobjectImpl(FName SubobjectName, UClass* ReturnType, bool bTransient = false);
 
public:
 
    enum class ENetFields_Private
    {
        NETFIELD_REP_START = 0,
        NETFIELD_REP_END = -1
    };
 
    virtual void ValidateGeneratedRepEnums(const TArray<struct FRepRecord>& ClassReps) const {} 
 
private:
    
    friend struct FObjectNetPushIdHelper;
    virtual void SetNetPushIdDynamic(const uint64 NewNetPushId)
    {
        // This method should only be called on Objects that are networked, and those should
        // always have this implemented (by UHT).
        checkf(false, TEXT("REPLICATED_BASE_CLASS macro is not implemented in %s. Something went very wrong."), *GetFullName());
    }
 
    // Here for UHT to be happy
    friend COREUOBJECT_API UClass* Z_Construct_UClass_UObject_NoRegister();
 
public:
 
    virtual uint64 GetNetPushIdDynamic() const
    {
        return uint64(int64(INDEX_NONE));
    }
};
 
struct FObjectNetPushIdHelper
{
private:
    friend struct FNetPrivatePushIdHelper;
    friend struct FNetObjectManagerPushIdHelper;
    friend struct UE::Net::Private::FNetHandleLegacyPushModelHelper;
 
    static void SetNetPushIdDynamic(UObject* Object, const uint64 NewNetPushId)
    {
        Object->SetNetPushIdDynamic(NewNetPushId);
    }
};
 
struct FInternalUObjectBaseUtilityIsValidFlagsChecker
{
    inline static bool CheckObjectValidBasedOnItsFlags(const UObject* Test)
    {
        // Here we don't really check if the flags match but if the end result is the same
        checkSlow(GUObjectArray.IndexToObject(Test->InternalIndex)->HasAnyFlags(EInternalObjectFlags::Garbage) == Test->HasAnyFlags(RF_MirroredGarbage));
        return !Test->HasAnyFlags(RF_MirroredGarbage);
    }
};
 
#if WITH_EDITORONLY_DATA
struct FAppendToClassSchemaContext
{
public:
    explicit FAppendToClassSchemaContext(void* InHasher) // Type is void* to mask the implementation detail
        :Hasher(InHasher)
    {
    }
    COREUOBJECT_API void Update(const void* Data, uint64 Size);
 
private:
    void* Hasher; // Type is void* to mask the implementation detail
};
#endif
 
UE_FORCEINLINE_HINT bool IsValid(const UObject *Test)
{
    return Test && FInternalUObjectBaseUtilityIsValidFlagsChecker::CheckObjectValidBasedOnItsFlags(Test);
}
 
inline bool IsValidChecked(const UObject* Test)
{
    check(Test);
    return FInternalUObjectBaseUtilityIsValidFlagsChecker::CheckObjectValidBasedOnItsFlags(Test);
}
 
template <typename T>
T* GetValid(T* Test)
{
    static_assert(std::is_base_of<UObject, T>::value, "GetValid can only work with UObject-derived classes");
    return IsValid(Test) ? Test : nullptr;
}
 
template <typename T>
const T* GetValid(const T* Test)
{
    static_assert(std::is_base_of<UObject, T>::value, "GetValid can only work with UObject-derived classes");
    return IsValid(Test) ? Test : nullptr;
}
 
#if WITH_EDITOR
extern COREUOBJECT_API TFunction<bool(const UObject*)> GIsObjectSelectedInEditor;
#endif