Class.h File Reference

#include "Concepts/GetTypeHashable.h"
#include "Concepts/StaticClassProvider.h"
#include "Concepts/StaticStructProvider.h"
#include "Concepts/StructSerializableWithDefaults.h"
#include "Containers/Array.h"
#include "Containers/ContainersFwd.h"
#include "Containers/EnumAsByte.h"
#include "Containers/Map.h"
#include "Containers/Set.h"
#include "Containers/StringFwd.h"
#include "Containers/UnrealString.h"
#include "CoreTypes.h"
#include "Algo/MaxElement.h"
#include "Async/Mutex.h"
#include "Async/SharedLock.h"
#include "Async/SharedMutex.h"
#include "Async/UniqueLock.h"
#include "HAL/CriticalSection.h"
#include "HAL/PlatformCrt.h"
#include "HAL/UnrealMemory.h"
#include "Internationalization/Text.h"
#include "Logging/LogCategory.h"
#include "Logging/LogMacros.h"
#include "Logging/LogVerbosity.h"
#include "Math/Box2D.h"
#include "Math/InterpCurvePoint.h"
#include "Math/MathFwd.h"
#include "Math/Matrix.h"
#include "Math/Plane.h"
#include "Math/Quat.h"
#include "Math/RandomStream.h"
#include "Math/Rotator.h"
#include "Math/Transform.h"
#include "Math/Vector2D.h"
#include "Math/Vector4.h"
#include "Misc/AssertionMacros.h"
#include "Misc/CString.h"
#include "Misc/EnumClassFlags.h"
#include "Misc/FallbackStruct.h"
#include "Misc/Guid.h"
#include "Misc/NotNull.h"
#include "Misc/Optional.h"
#include "Misc/ScopeRWLock.h"
#include "Serialization/StructuredArchive.h"
#include "Serialization/StructuredArchiveAdapters.h"
#include "Templates/AlignmentTemplates.h"
#include "Templates/EnableIf.h"
#include "Templates/Identity.h"
#include "Templates/IsAbstract.h"
#include "Templates/IsEnum.h"
#include "Templates/IsPODType.h"
#include "Templates/IsUECoreType.h"
#include "Templates/Models.h"
#include "Templates/NoDestroy.h"
#include "Templates/Tuple.h"
#include "Templates/TypeCompatibleBytes.h"
#include "Templates/UnrealTemplate.h"
#include "Templates/UnrealTypeTraits.h"
#include "Trace/Detail/Channel.h"
#include "UObject/CoreNative.h"
#include "UObject/Field.h"
#include "UObject/FieldPath.h"
#include "UObject/GarbageCollection.h"
#include "UObject/NameTypes.h"
#include "UObject/Object.h"
#include "UObject/ObjectMacros.h"
#include "UObject/PropertyTag.h"
#include "UObject/PropertyVisitor.h"
#include "UObject/ReflectedTypeAccessors.h"
#include "UObject/Script.h"
#include "UObject/StructOpsTypeTraits.h"
#include "UObject/TopLevelAssetPath.h"
#include "UObject/UObjectGlobals.h"
#include "UObject/UnrealNames.h"
#include "UObject/ObjectPtr.h"
#include "UObject/ObjectPtrLinkedListBuilder.h"
#include "UObject/ObjectPtrLinkedListIterator.h"
#include <type_traits>
#include <atomic>
#include "Class.generated.h"

Go to the source code of this file.

Classes
struct	FRepRecord
class	UField
class	FStructBaseChain
class	UStruct
struct	UE::CoreUObject::Private::FCapabilities
struct	UE::CoreUObject::Private::FStructOpsFakeVTable
struct	UE::CoreUObject::Private::TStructOpsFakeVTable< Funcs >
struct	UE::CoreUObject::Private::TStructOpsFakeVTable<>
struct	UE::CoreUObject::Private::TStructOpsFakeVTableForTypeImpl< CppStruct, Flags, Funcs >
struct	UE::CoreUObject::Private::TStructOpsFakeVTableForTypeImpl< CppStruct, EStructOpsFakeVTableFlags::None, Funcs... >
class	UScriptStruct
struct	UScriptStruct::ICppStructOps
struct	UScriptStruct::TCppStructOps< CPPSTRUCT >
struct	UScriptStruct::TAutoCppStructOps< CPPSTRUCT >
class	UFunction
class	UDelegateFunction
class	USparseDelegateFunction
class	UEnum
class	UEnum::FNameData
struct	UEnum::FNameData::FIteratorEnd
struct	UEnum::FNameData::FIterator
struct	FCppClassTypeTraitsBase
struct	TCppClassTypeTraits< CPPCLASS >
struct	ICppClassTypeInfo
struct	FCppClassTypeInfoStatic
struct	FCppClassTypeInfo
struct	FImplementedInterface
struct	FNativeFunctionLookup
struct	FClassFunctionLinkInfo
class	UClass
struct	FObjectInstancingGraph
struct	FStructUtils
struct	TBaseStructureBase< T, bHasStaticStruct >
struct	TBaseStructureBase< T, false >
struct	TBaseStructure< T >
struct	TBaseStructure< FIntPoint >
struct	TBaseStructure< FIntVector >
struct	TBaseStructure< FInt64Vector2 >
struct	TBaseStructure< FIntVector4 >
struct	TBaseStructure< FLinearColor >
struct	TBaseStructure< FColor >
struct	TBaseStructure< FRandomStream >
struct	TBaseStructure< FGuid >
struct	TBaseStructure< FFallbackStruct >
struct	TBaseStructure< FInterpCurveFloat >
struct	TBaseStructure< FInterpCurveVector2D >
struct	TBaseStructure< FInterpCurveVector >
struct	TBaseStructure< FInterpCurveQuat >
struct	TBaseStructure< FInterpCurveTwoVectors >
struct	TBaseStructure< FInterpCurveLinearColor >
struct	TBaseStructure< FInterpCurvePointFloat >
struct	TBaseStructure< FInterpCurvePointVector2D >
struct	TBaseStructure< FInterpCurvePointVector >
struct	TBaseStructure< FInterpCurvePointQuat >
struct	TBaseStructure< FInterpCurvePointTwoVectors >
struct	TBaseStructure< FInterpCurvePointLinearColor >
struct	TBaseStructure< FFloatRangeBound >
struct	TBaseStructure< FFloatRange >
struct	TBaseStructure< FDoubleRangeBound >
struct	TBaseStructure< FDoubleRange >
struct	TBaseStructure< FInt32RangeBound >
struct	TBaseStructure< FInt32Range >
struct	TBaseStructure< FFloatInterval >
struct	TBaseStructure< FDoubleInterval >
struct	TBaseStructure< FInt32Interval >
struct	TBaseStructure< FFrameNumber >
struct	TBaseStructure< FFrameTime >
struct	TBaseStructure< FFrameRate >
struct	TBaseStructure< FDateTime >
struct	TBaseStructure< FPolyglotTextData >
struct	TBaseStructure< FRemoteObjectId >
struct	TStructOpsTypeTraits< FRemoteObjectId >
struct	TBaseStructure< FRemoteObjectTables >
struct	TBaseStructure< FRemoteObjectPathName >
struct	TBaseStructure< FPackedRemoteObjectPathName >
struct	TBaseStructure< FRemoteObjectBytes >
struct	TBaseStructure< FRemoteObjectData >
struct	TBaseStructure< FRemoteServerId >
struct	TStructOpsTypeTraits< FRemoteServerId >
struct	TBaseStructure< FRemoteObjectReference >
struct	TVariantStructure< T >

Namespaces
namespace	UE
namespace	UE::Private
namespace	UE::CodeGen
namespace	UE::CodeGen::ConstInit
namespace	UE::CoreUObject
namespace	UE::CoreUObject::Private
namespace	EIncludeSuperFlag

Macros
#define	DISABLE_ABSTRACT_CONSTRUCT   (false && TStructOpsTypeTraits<CPPSTRUCT>::WithPureVirtual)
#define	UE_FOREACH_FAKE_VTABLE_FUNC_EDITOR_ONLY(...)
#define	UE_FOREACH_FAKE_VTABLE_FUNC_WITH_TESTS_ONLY(...)   __VA_ARGS__
#define	UE_FOREACH_FAKE_VTABLE_FUNC(IndexNameFunctype)
#define	UE_VTABLE_ENUM(Index, Name, Functype)   Name = 1u << Index,
#define	UE_VTABLE_FUNC(Index, Name, Functype)
#define	UE_VTABLE_SETFLAG(Index, Name, Functype)
#define	IMPLEMENT_STRUCT(BaseName)    UE_DEPRECATED_MACRO(5.1, "IMPLEMENT_STRUCT has been deprecated. Use UE_IMPLEMENT_STRUCT and provide struct package name as well as struct name") static UScriptStruct::TAutoCppStructOps<F##BaseName> BaseName##_Ops(FTopLevelAssetPath(TEXT("/Script/CoreUObject"), TEXT(#BaseName)));
#define	UE_IMPLEMENT_STRUCT(PackageNameText, BaseName)    static UScriptStruct::TAutoCppStructOps<F##BaseName> BaseName##_Ops(FTopLevelAssetPath(TEXT(PackageNameText), TEXT(#BaseName)));
#define	UE_DECLARE_CORE_VARIANT_TYPE(VARIANT, CORE)

Typedefs
typedef FReadScopeLock	FUClassFuncScopeReadLock
typedef FWriteScopeLock	FUClassFuncScopeWriteLock
typedef FRWLock	FUClassFuncLock
template<typename CppStruct >
using	UE::CoreUObject::Private::TStructOpsFakeVTableForType = TStructOpsFakeVTableForTypeImpl< CppStruct, GetStructOpsFakeVTableFlags< CppStruct >()>
typedef FText(*	FEnumDisplayNameFn) (int32)

Enumerations
enum class	EStructPropertyLinkFlags : uint8 { None = 0 , LinkPostConstruct = 1 << 0 , LinkDestructor = 1 << 1 }
enum	EStructFlags {   STRUCT_NoFlags = 0x00000000 , STRUCT_Native = 0x00000001 , STRUCT_IdenticalNative = 0x00000002 , STRUCT_HasInstancedReference = 0x00000004 ,   STRUCT_NoExport = 0x00000008 , STRUCT_Atomic = 0x00000010 , STRUCT_Immutable = 0x00000020 , STRUCT_AddStructReferencedObjects = 0x00000040 ,   STRUCT_RequiredAPI = 0x00000200 , STRUCT_NetSerializeNative = 0x00000400 , STRUCT_SerializeNative = 0x00000800 , STRUCT_CopyNative = 0x00001000 ,   STRUCT_IsPlainOldData = 0x00002000 , STRUCT_NoDestructor = 0x00004000 , STRUCT_ZeroConstructor = 0x00008000 , STRUCT_ExportTextItemNative = 0x00010000 ,   STRUCT_ImportTextItemNative = 0x00020000 , STRUCT_PostSerializeNative = 0x00040000 , STRUCT_SerializeFromMismatchedTag = 0x00080000 , STRUCT_NetDeltaSerializeNative = 0x00100000 ,   STRUCT_PostScriptConstruct = 0x00200000 , STRUCT_NetSharedSerialization = 0x00400000 , STRUCT_Trashed = 0x00800000 , STRUCT_NewerVersionExists = 0x01000000 ,   STRUCT_CanEditChange = 0x02000000 , STRUCT_Visitor = 0x04000000 , STRUCT_Inherit = STRUCT_HasInstancedReference|STRUCT_Atomic , STRUCT_ComputedFlags = STRUCT_NetDeltaSerializeNative | STRUCT_NetSerializeNative | STRUCT_SerializeNative | STRUCT_PostSerializeNative | STRUCT_CopyNative | STRUCT_IsPlainOldData | STRUCT_NoDestructor | STRUCT_ZeroConstructor | STRUCT_IdenticalNative | STRUCT_AddStructReferencedObjects | STRUCT_ExportTextItemNative | STRUCT_ImportTextItemNative | STRUCT_SerializeFromMismatchedTag | STRUCT_PostScriptConstruct | STRUCT_NetSharedSerialization }
enum class	UE::CoreUObject::Private::EStructOpsFakeVTableFlags : uint32 { UE::CoreUObject::Private::None = 0 , UE::CoreUObject::Private::UE_VTABLE_ENUM }
enum class	EGetByNameFlags { None = 0 , ErrorIfNotFound = 0x01 , CaseSensitive = 0x02 , CheckAuthoredName = 0x04 }
enum	EIncludeSuperFlag::Type { EIncludeSuperFlag::ExcludeSuper , EIncludeSuperFlag::IncludeSuper }
enum class	EGetSparseClassDataMethod : uint8 { CreateIfNull , ArchetypeIfNull , ReturnIfNull , DeferIfNull }
enum class	EInstancePropertyValueFlags { None = 0x00 , CausesInstancing = 0x01 , AllowSelfReference = 0x02 , DoNotCreateNewInstance = 0x04 }
enum class	EObjectInstancingGraphOptions { None = 0x00 , DisableInstancing = 0x01 , InstanceTemplatesOnly = 0x02 }

Functions
COREUOBJECT_API	DECLARE_LOG_CATEGORY_EXTERN (LogClass, Log, All)
COREUOBJECT_API	DECLARE_LOG_CATEGORY_EXTERN (LogScriptSerialization, Log, All)
template<class CPPSTRUCT >
void	AddStructReferencedObjectsOrNot (void *A, FReferenceCollector &Collector)
template<typename CppStruct >
constexpr FCapabilities	UE::CoreUObject::Private::GetCapabilities ()
template<typename CppStruct > requires (!TStructOpsTypeTraits<CppStruct>::WithZeroConstructor)
void	UE::CoreUObject::Private::Construct (void *Dest)
template<typename CppStruct > requires (!TStructOpsTypeTraits<CppStruct>::WithZeroConstructor)
void	UE::CoreUObject::Private::ConstructForTests (void *Dest)
template<typename CppStruct > requires (!TStructOpsTypeTraits<CppStruct>::WithNoDestructor && !TIsPODType<CppStruct>::Value)
void	UE::CoreUObject::Private::Destruct (void *Dest)
template<typename CppStruct > requires (!!TStructOpsTypeTraits<CppStruct>::WithSerializer)
bool	UE::CoreUObject::Private::SerializeArchive (FArchive &Ar, void *Data, UStruct *DefaultsStruct, const void *Defaults)
template<typename CppStruct > requires (!!TStructOpsTypeTraits<CppStruct>::WithStructuredSerializer)
bool	UE::CoreUObject::Private::SerializeSlot (FStructuredArchive::FSlot Slot, void *Data, UStruct *DefaultsStruct, const void *Defaults)
template<typename CppStruct > requires (!!TStructOpsTypeTraits<CppStruct>::WithPostSerialize)
void	UE::CoreUObject::Private::PostSerialize (const FArchive &Ar, void *Data)
template<typename CppStruct > requires (!!TStructOpsTypeTraits<CppStruct>::WithNetSerializer)
bool	UE::CoreUObject::Private::NetSerialize (FArchive &Ar, UPackageMap *Map, bool &bOutSuccess, void *Data)
template<typename CppStruct > requires (!!TStructOpsTypeTraits<CppStruct>::WithNetDeltaSerializer)
bool	UE::CoreUObject::Private::NetDeltaSerialize (FNetDeltaSerializeInfo &DeltaParms, void *Data)
template<typename CppStruct > requires (!!TStructOpsTypeTraits<CppStruct>::WithPostScriptConstruct)
void	UE::CoreUObject::Private::PostScriptConstruct (void *Data)
template<typename CppStruct > requires (!!TStructOpsTypeTraits<CppStruct>::WithGetPreloadDependencies)
void	UE::CoreUObject::Private::GetPreloadDependencies (void *Data, TArray< UObject * > &OutDeps)
template<typename CppStruct > requires (!!TStructOpsTypeTraits<CppStruct>::WithCopy)
bool	UE::CoreUObject::Private::Copy (void *Dest, void const *Src, int32 ArrayDim)
template<typename CppStruct > requires (!!TStructOpsTypeTraits<CppStruct>::WithIdentical)
bool	UE::CoreUObject::Private::Identical (const void *A, const void *B, uint32 PortFlags, bool &bOutResult)
template<typename CppStruct > requires (!!TStructOpsTypeTraits<CppStruct>::WithIdenticalViaEquality)
bool	UE::CoreUObject::Private::Identical (const void *A, const void *B, uint32 PortFlags, bool &bOutResult)
template<typename CppStruct > requires (!!TStructOpsTypeTraits<CppStruct>::WithExportTextItem)
bool	UE::CoreUObject::Private::ExportTextItem (FString &ValueStr, const void *PropertyValue, const void *DefaultValue, UObject *Parent, int32 PortFlags, UObject *ExportRootScope)
template<typename CppStruct > requires (!!TStructOpsTypeTraits<CppStruct>::WithImportTextItem)
bool	UE::CoreUObject::Private::ImportTextItem (const TCHAR *&Buffer, void *Data, int32 PortFlags, UObject *OwnerObject, FOutputDevice *ErrorText)
template<typename CppStruct > requires (!!TStructOpsTypeTraits<CppStruct>::WithFindInnerPropertyInstance)
bool	UE::CoreUObject::Private::FindInnerPropertyInstance (FName PropertyName, const void *Data, const FProperty *&OutProp, const void *&OutData)
template<typename CppStruct > requires (!!TStructOpsTypeTraits<CppStruct>::WithSerializeFromMismatchedTag)
bool	UE::CoreUObject::Private::SerializeFromMismatchedTag (FPropertyTag const &Tag, FArchive &Ar, void *Data)
template<typename CppStruct > requires (!!TStructOpsTypeTraits<CppStruct>::WithStructuredSerializeFromMismatchedTag)
bool	UE::CoreUObject::Private::StructuredSerializeFromMismatchedTag (FPropertyTag const &Tag, FStructuredArchive::FSlot Slot, void *Data)
template<typename CppStruct > requires (TModels_V<CGetTypeHashable, CppStruct>)
uint32	UE::CoreUObject::Private::GetStructTypeHash (const void *Src)
template<typename CppStruct > requires (HasIntrusiveUnsetOptionalState<CppStruct>())
void	UE::CoreUObject::Private::InitializeIntrusiveUnsetOptionalValue (void *Data)
template<typename CppStruct > requires (HasIntrusiveUnsetOptionalState<CppStruct>())
bool	UE::CoreUObject::Private::IsIntrusiveOptionalValueSet (const void *Data)
template<typename CppStruct > requires (HasIntrusiveUnsetOptionalState<CppStruct>())
void	UE::CoreUObject::Private::ClearIntrusiveOptionalValue (void *Data)
template<typename CppStruct > requires (!!TStructOpsTypeTraits<CppStruct>::WithVisitor)
EPropertyVisitorControlFlow	UE::CoreUObject::Private::Visit (FPropertyVisitorContext &Context, const TFunctionRef< EPropertyVisitorControlFlow(const FPropertyVisitorContext &Context)> InFunc)
template<typename CppStruct > requires (!!TStructOpsTypeTraits<CppStruct>::WithVisitor)
void *	UE::CoreUObject::Private::ResolveVisitedPathInfo (void *Data, const FPropertyVisitorInfo &Info)
template<typename CppStruct >
constexpr EStructOpsFakeVTableFlags	UE::CoreUObject::Private::GetStructOpsFakeVTableFlags ()
template<class T >
void	InternalConstructor (const FObjectInitializer &X)
template<class T >
UObject *	InternalVTableHelperCtorCaller (FVTableHelper &Helper)
COREUOBJECT_API void	InitializePrivateStaticClass (class UClass *(*TClass_StaticClassFn)(), class UClass *TClass_Super_StaticClass, class UClass *TClass_PrivateStaticClass, class UClass *TClass_WithinClass_StaticClass, const TCHAR *PackageName, const TCHAR *Name)
COREUOBJECT_API void	InitializePrivateStaticClass (class UClass *TClass_Super_StaticClass, class UClass *TClass_PrivateStaticClass, class UClass *TClass_WithinClass_StaticClass, const TCHAR *PackageName, const TCHAR *Name)
COREUOBJECT_API void	GetPrivateStaticClassBody (const TCHAR *PackageName, const TCHAR *Name, UClass *&ReturnClass, void(*RegisterNativeFunc)(), uint32 InSize, uint32 InAlignment, EClassFlags InClassFlags, EClassCastFlags InClassCastFlags, const TCHAR *InConfigName, UClass::ClassConstructorType InClassConstructor, UClass::ClassVTableHelperCtorCallerType InClassVTableHelperCtorCaller, FUObjectCppClassStaticFunctions &&InCppClassStaticFunctions, UClass::StaticClassFunctionType InSuperClassFn, UClass::StaticClassFunctionType InWithinClassFn)
	Expose_TNameOf (FObjectInstancingGraph)
	Expose_TNameOf (FObjectInstancingGraph *)
template<class T >
const T *	GetDefault (const UClass *Class)
template<class T >
T *	GetMutableDefault (UClass *Class)
	UE_DECLARE_CORE_VARIANT_TYPE (Vector2, Vector2D)
	UE_DECLARE_CORE_VARIANT_TYPE (Vector3, Vector)
	UE_DECLARE_CORE_VARIANT_TYPE (Vector4, Vector4)
	UE_DECLARE_CORE_VARIANT_TYPE (Plane4, Plane)
	UE_DECLARE_CORE_VARIANT_TYPE (Quat4, Quat)
	UE_DECLARE_CORE_VARIANT_TYPE (Rotator3, Rotator)
	UE_DECLARE_CORE_VARIANT_TYPE (Transform3, Transform)
	UE_DECLARE_CORE_VARIANT_TYPE (Matrix44, Matrix)
	UE_DECLARE_CORE_VARIANT_TYPE (Box2, Box2D)
	UE_DECLARE_CORE_VARIANT_TYPE (Ray3, Ray)
	UE_DECLARE_CORE_VARIANT_TYPE (Sphere3, Sphere)

Variables
template<typename CppStruct >
void(*)(void *A, FReferenceCollector &Collector)	UE::CoreUObject::Private::AddStructReferencedObjects ()
template<typename CppStruct , auto... Funcs>
constexpr const TStructOpsFakeVTable< Funcs... >	UE::CoreUObject::Private::TStructOpsFakeVTableInstance
template<typename CppStruct >
constexpr const TStructOpsFakeVTable	UE::CoreUObject::Private::TStructOpsFakeVTableInstance< CppStruct >

Macro Definition Documentation

DISABLE_ABSTRACT_CONSTRUCT

#define DISABLE_ABSTRACT_CONSTRUCT   (false && TStructOpsTypeTraits<CPPSTRUCT>::WithPureVirtual)

IMPLEMENT_STRUCT

#define IMPLEMENT_STRUCT

(

BaseName

)

UE_DEPRECATED_MACRO(5.1, "IMPLEMENT_STRUCT has been deprecated. Use UE_IMPLEMENT_STRUCT and provide struct package name as well as struct name") static UScriptStruct::TAutoCppStructOps<F##BaseName> BaseName##_Ops(FTopLevelAssetPath(TEXT("/Script/CoreUObject"), TEXT(#BaseName)));

UE_DECLARE_CORE_VARIANT_TYPE

#define UE_DECLARE_CORE_VARIANT_TYPE	(		VARIANT,
			CORE
	)

Value:

template<> struct TBaseStructure<::F##CORE> { COREUOBJECT_API static UScriptStruct* Get(); };           \
template<> struct TVariantStructure<::F##VARIANT##f> { COREUOBJECT_API static UScriptStruct* Get(); };  \
template<> struct TVariantStructure<::F##VARIANT##d> { COREUOBJECT_API static UScriptStruct* Get(); };

UE_FOREACH_FAKE_VTABLE_FUNC

#define UE_FOREACH_FAKE_VTABLE_FUNC

(

IndexNameFunctype

)

Value:

        IndexNameFunctype(0,    Construct,                              void(void* Address)) \
		UE_FOREACH_FAKE_VTABLE_FUNC_WITH_TESTS_ONLY( \
        IndexNameFunctype(1,    ConstructForTests,                      void(void* Address)) \
        ) \
		IndexNameFunctype(2,  Destruct,                               void(void* Address)) \
		IndexNameFunctype(3,  SerializeArchive,                       bool(FArchive& Ar, void* Data, UStruct* DefaultsStruct, const void* Defaults)) \
		IndexNameFunctype(4,  SerializeSlot,                          bool(FStructuredArchive::FSlot Slot, void* Data, UStruct* DefaultsStruct, const void* Defaults)) \
		IndexNameFunctype(5,  PostSerialize,                          void(const FArchive& Ar, void* Data)) \
		IndexNameFunctype(6,  NetSerialize,                           bool(FArchive& Ar, UPackageMap* Map, bool& bOutSuccess, void* Data)) \
		IndexNameFunctype(7,  NetDeltaSerialize,                      bool(FNetDeltaSerializeInfo& DeltaParms, void* Data)) \
		IndexNameFunctype(8,  PostScriptConstruct,                    void(void* Data)) \
		IndexNameFunctype(9,  GetPreloadDependencies,                 void(void* Data, TArray<UObject*>& OutDeps)) \
		IndexNameFunctype(10, Copy,                                   bool(void* Dest, void const* Src, int32 ArrayDim)) \
		IndexNameFunctype(11, Identical,                              bool(const void* A, const void* B, uint32 PortFlags, bool& bOutResult)) \
		IndexNameFunctype(12, ExportTextItem,                         bool(FString& ValueStr, const void* PropertyValue, const void* DefaultValue, UObject* Parent, int32 PortFlags, UObject* ExportRootScope)) \
		IndexNameFunctype(13, ImportTextItem,                         bool(const TCHAR*& Buffer, void* Data, int32 PortFlags, UObject* OwnerObject, FOutputDevice* ErrorText)) \
		IndexNameFunctype(14, FindInnerPropertyInstance,              bool(FName PropertyName, const void* Data, const FProperty*& OutProp, const void*& OutData)) \
		IndexNameFunctype(15, AddStructReferencedObjects,             void(*())(void* A, FReferenceCollector& Collector)) \
		IndexNameFunctype(16, SerializeFromMismatchedTag,             bool(FPropertyTag const& Tag, FArchive& Ar, void* Data)) \
		IndexNameFunctype(17, StructuredSerializeFromMismatchedTag,   bool(FPropertyTag const& Tag, FStructuredArchive::FSlot Slot, void* Data)) \
		IndexNameFunctype(18, GetStructTypeHash,                      uint32(const void* Src)) \
		IndexNameFunctype(19, InitializeIntrusiveUnsetOptionalValue,  void(void* Data)) \
		IndexNameFunctype(20, IsIntrusiveOptionalValueSet,            bool(const void* Data)) \
		IndexNameFunctype(21, ClearIntrusiveOptionalValue,            void(void* Data)) \
		UE_FOREACH_FAKE_VTABLE_FUNC_EDITOR_ONLY( \
        IndexNameFunctype(22,   CanEditChange,                          bool(const FEditPropertyChain& PropertyChain, const void* Data)) \
        ) \
		IndexNameFunctype(23, Visit,                                  EPropertyVisitorControlFlow(FPropertyVisitorContext& Context, const TFunctionRef<EPropertyVisitorControlFlow(const FPropertyVisitorContext& Context)> InFunc)) \
		IndexNameFunctype(24, ResolveVisitedPathInfo,                 void*(void* Data, const FPropertyVisitorInfo& Info))

UE_FOREACH_FAKE_VTABLE_FUNC_EDITOR_ONLY

#define UE_FOREACH_FAKE_VTABLE_FUNC_EDITOR_ONLY

(

...

)

UE_FOREACH_FAKE_VTABLE_FUNC_WITH_TESTS_ONLY

#define UE_FOREACH_FAKE_VTABLE_FUNC_WITH_TESTS_ONLY

(

...

)

__VA_ARGS__

UE_IMPLEMENT_STRUCT

#define UE_IMPLEMENT_STRUCT	(		PackageNameText,
			BaseName
	)		static UScriptStruct::TAutoCppStructOps<F##BaseName> BaseName##_Ops(FTopLevelAssetPath(TEXT(PackageNameText), TEXT(#BaseName)));

UE_VTABLE_ENUM

#define UE_VTABLE_ENUM	(		Index,
			Name,
			Functype
	)		Name = 1u << Index,

UE_VTABLE_FUNC

#define UE_VTABLE_FUNC	(		Index,
			Name,
			Functype
	)

Value:

        template <> \
        struct THandlingFunctionType<EStructOpsFakeVTableFlags::Name> \
        { \
            using Type = Functype; \
        }; \
        template <typename CppStruct> \
        struct THandlingFunctionPtr<CppStruct, EStructOpsFakeVTableFlags::Name> \
        { \
            inline static constexpr TIdentity_T<Functype>* Value = &Name<CppStruct>; \
        };

UE_VTABLE_SETFLAG

#define UE_VTABLE_SETFLAG	(		Index,
			Name,
			Functype
	)

Value:

            if constexpr (requires(TIdentity_T<Functype>*& PtrRef) { PtrRef = &Name<CppStruct>; }) /* assignment to RefPtr shouldn't be needed, but is a workaround for MSVC bug: https://developercommunity.microsoft.com/t/Compiler-fails-overload-resolution-when/10939568 */ \
            { \
                Result |= EStructOpsFakeVTableFlags::Name; \
            }

Typedef Documentation

FEnumDisplayNameFn

typedef FText(* FEnumDisplayNameFn) (int32)

FUClassFuncLock

typedef FRWLock FUClassFuncLock

FUClassFuncScopeReadLock

typedef FReadScopeLock FUClassFuncScopeReadLock

FUClassFuncScopeWriteLock

typedef FWriteScopeLock FUClassFuncScopeWriteLock

Enumeration Type Documentation

EGetByNameFlags

enum class EGetByNameFlags

strong

Optional flags for the UEnum::Get*ByName() functions.

Enumerator
None
ErrorIfNotFound	Outputs an warning if the enum lookup fails
CaseSensitive	Does a case sensitive match
CheckAuthoredName	Checks the GetAuthoredNameStringByIndex value as well as normal names

EGetSparseClassDataMethod

enum class EGetSparseClassDataMethod : uint8

strong

Flag describing desired behavior of GetSparseClassData in the case where the SparseClassData has not been created. The class's instance is guaranteed already created if the class has sparse data of its own, so the only differences in behavior are when the class does not have sparse data of its own.

Enumerator
CreateIfNull	If not yet created, store and return a new instance, whether or not the class can use its archetype's instance.
ArchetypeIfNull	If not yet created, return the archetype instance (if possible to use for this class). If not possible to use the archetype's instance, store and return a new instance.
ReturnIfNull	This is an advanced flag and should usually be avoided. Callers should instead call with ArchetypeIfNull if they are currently allowed to create an instance, or with DeferIfNull if not. Callers that want to know whether the class has sparse data of its own beyond what the archetype has should compare GetSparseClassDataStruct() != GetSparseClassDataArchetypeStruct(). If not yet created, return null. An instance might still be created later when called with ArchetypeIfNull. This call never creates an instance.
DeferIfNull	If not yet created, return the archetype's instance (if possible to use for this class). If not possible to use the archetype's instance, return null. User should call later with ArchetypeIfNull when they are allowed to create an instance. This call never creates an instance.

EInstancePropertyValueFlags

enum class EInstancePropertyValueFlags

strong

Enumerator
None
CausesInstancing
AllowSelfReference
DoNotCreateNewInstance

EObjectInstancingGraphOptions

enum class EObjectInstancingGraphOptions

strong

Enumerator
None
DisableInstancing
InstanceTemplatesOnly

EStructFlags

enum EStructFlags

Flags describing a struct

This MUST be kept in sync with EStructFlags defined in Engine\Source\Programs\Shared\EpicGames.Core\UnrealEngineTypes.cs

Enumerator
STRUCT_NoFlags
STRUCT_Native
STRUCT_IdenticalNative	If set, this struct will be compared using native code
STRUCT_HasInstancedReference
STRUCT_NoExport
STRUCT_Atomic	Indicates that this struct should always be serialized as a single unit
STRUCT_Immutable	Indicates that this struct uses binary serialization; it is unsafe to add/remove members from this struct without incrementing the package version
STRUCT_AddStructReferencedObjects	If set, native code needs to be run to find referenced objects
STRUCT_RequiredAPI	Indicates that this struct should be exportable/importable at the DLL layer. Base structs must also be exportable for this to work.
STRUCT_NetSerializeNative	If set, this struct will be serialized using the CPP net serializer
STRUCT_SerializeNative	If set, this struct will be serialized using the CPP serializer
STRUCT_CopyNative	If set, this struct will be copied using the CPP operator=
STRUCT_IsPlainOldData	If set, this struct will be copied using memcpy
STRUCT_NoDestructor	If set, this struct has no destructor and non will be called. STRUCT_IsPlainOldData implies STRUCT_NoDestructor
STRUCT_ZeroConstructor	If set, this struct will not be constructed because it is assumed that memory is zero before construction.
STRUCT_ExportTextItemNative	If set, native code will be used to export text
STRUCT_ImportTextItemNative	If set, native code will be used to export text
STRUCT_PostSerializeNative	If set, this struct will have PostSerialize called on it after CPP serializer or tagged property serialization is complete
STRUCT_SerializeFromMismatchedTag	If set, this struct will have SerializeFromMismatchedTag called on it if a mismatched tag is encountered.
STRUCT_NetDeltaSerializeNative	If set, this struct will be serialized using the CPP net delta serializer
STRUCT_PostScriptConstruct	If set, this struct will be have PostScriptConstruct called on it after a temporary object is constructed in a running blueprint
STRUCT_NetSharedSerialization	If set, this struct can share net serialization state across connections
STRUCT_Trashed	If set, this struct has been cleaned and sanitized (trashed) and should not be used
STRUCT_NewerVersionExists	If set, this structure has been replaced via reinstancing
STRUCT_CanEditChange	If set, this struct will have CanEditChange on it in the editor to determine if a child property can be edited
STRUCT_Visitor	If set, this struct will have Visit on it to allow custom property visiting implementation
STRUCT_Inherit	Struct flags that are automatically inherited
STRUCT_ComputedFlags	Flags that are always computed, never loaded or done with code generation

EStructPropertyLinkFlags

enum class EStructPropertyLinkFlags : uint8

strong

Provides more explicit control over if a property is added to PostConstruct & Destructor collections

Enumerator
None	Property should not be added to any link lists
LinkPostConstruct	If set, add the property to the post constructor link list
LinkDestructor	If set, add the property to the destructor link list

Function Documentation

AddStructReferencedObjectsOrNot()

template<class CPPSTRUCT >

void AddStructReferencedObjectsOrNot ( void *  A, FReferenceCollector &  Collector  )

inline

Selection of AddStructReferencedObjects check.

DECLARE_LOG_CATEGORY_EXTERN() [1/2]

COREUOBJECT_API DECLARE_LOG_CATEGORY_EXTERN	(	LogClass	,
		Log	,
		All
	)

DECLARE_LOG_CATEGORY_EXTERN() [2/2]

COREUOBJECT_API DECLARE_LOG_CATEGORY_EXTERN	(	LogScriptSerialization	,
		Log	,
		All
	)

Expose_TNameOf() [1/2]

Expose_TNameOf

(

FObjectInstancingGraph *

)

Expose_TNameOf() [2/2]

Expose_TNameOf

(

FObjectInstancingGraph

)

GetDefault()

template<class T >

const T * GetDefault ( const UClass *  Class )

inline

Gets the default object of a class.

In most cases, class default objects should not be modified. This method therefore returns an immutable pointer. If you need to modify the default object, use GetMutableDefault instead.

Parameters

Class

- The class to get the CDO for.

Returns

Class default object (CDO).

See also

GetMutableDefault

GetMutableDefault()

template<class T >

T * GetMutableDefault ( UClass *  Class )

inline

Gets the mutable default object of a class.

Parameters

Class

- The class to get the CDO for.

Returns

Class default object (CDO).

See also

GetDefault

GetPrivateStaticClassBody()

COREUOBJECT_API void GetPrivateStaticClassBody	(	const TCHAR *	PackageName,
		const TCHAR *	Name,
		UClass *&	ReturnClass,
		void(*)()	RegisterNativeFunc,
		uint32	InSize,
		uint32	InAlignment,
		EClassFlags	InClassFlags,
		EClassCastFlags	InClassCastFlags,
		const TCHAR *	InConfigName,
		UClass::ClassConstructorType	InClassConstructor,
		UClass::ClassVTableHelperCtorCallerType	InClassVTableHelperCtorCaller,
		FUObjectCppClassStaticFunctions &&	InCppClassStaticFunctions,
		UClass::StaticClassFunctionType	InSuperClassFn,
		UClass::StaticClassFunctionType	InWithinClassFn
	)

Helper template allocate and construct a UClass

Parameters

PackageName	name of the package this class will be inside
Name	of the class
ReturnClass	reference to pointer to result. This must be PrivateStaticClass.
RegisterNativeFunc	Native function registration function pointer.
InSize	Size of the class
InAlignment	Alignment of the class
InClassFlags	Class flags
InClassCastFlags	Class cast flags
InConfigName	Class config name
InClassConstructor	Class constructor function pointer
InClassVTableHelperCtorCaller	Class constructor function for vtable pointer
InCppClassStaticFunctions	Function pointers for the class's version of Unreal's reflected static functions
InSuperClassFn	Super class function pointer
InWithinClassFn	Within class function pointer

InitializePrivateStaticClass() [1/2]

COREUOBJECT_API void InitializePrivateStaticClass	(	class UClass *(*)()	TClass_StaticClassFn,
		class UClass *	TClass_Super_StaticClass,
		class UClass *	TClass_PrivateStaticClass,
		class UClass *	TClass_WithinClass_StaticClass,
		const TCHAR *	PackageName,
		const TCHAR *	Name
	)

Shared function called from the various InitializePrivateStaticClass functions generated my the IMPLEMENT_CLASS macro.

InitializePrivateStaticClass() [2/2]

COREUOBJECT_API void InitializePrivateStaticClass	(	class UClass *	TClass_Super_StaticClass,
		class UClass *	TClass_PrivateStaticClass,
		class UClass *	TClass_WithinClass_StaticClass,
		const TCHAR *	PackageName,
		const TCHAR *	Name
	)

InternalConstructor()

template<class T >

void InternalConstructor

(

const FObjectInitializer &

X

)

Helper template to call the default constructor for a class

InternalVTableHelperCtorCaller()

template<class T >

UObject * InternalVTableHelperCtorCaller

(

FVTableHelper &

Helper

)

Helper template to call the vtable ctor caller for a class

UE_DECLARE_CORE_VARIANT_TYPE() [1/11]

UE_DECLARE_CORE_VARIANT_TYPE	(	Box2	,
		Box2D
	)

UE_DECLARE_CORE_VARIANT_TYPE() [2/11]

UE_DECLARE_CORE_VARIANT_TYPE	(	Matrix44	,
		Matrix
	)

UE_DECLARE_CORE_VARIANT_TYPE() [3/11]

UE_DECLARE_CORE_VARIANT_TYPE	(	Plane4	,
		Plane
	)

UE_DECLARE_CORE_VARIANT_TYPE() [4/11]

UE_DECLARE_CORE_VARIANT_TYPE	(	Quat4	,
		Quat
	)

UE_DECLARE_CORE_VARIANT_TYPE() [5/11]

UE_DECLARE_CORE_VARIANT_TYPE	(	Ray3	,
		Ray
	)

UE_DECLARE_CORE_VARIANT_TYPE() [6/11]

UE_DECLARE_CORE_VARIANT_TYPE	(	Rotator3	,
		Rotator
	)

UE_DECLARE_CORE_VARIANT_TYPE() [7/11]

UE_DECLARE_CORE_VARIANT_TYPE	(	Sphere3	,
		Sphere
	)

UE_DECLARE_CORE_VARIANT_TYPE() [8/11]

UE_DECLARE_CORE_VARIANT_TYPE	(	Transform3	,
		Transform
	)

UE_DECLARE_CORE_VARIANT_TYPE() [9/11]

UE_DECLARE_CORE_VARIANT_TYPE	(	Vector2	,
		Vector2D
	)

UE_DECLARE_CORE_VARIANT_TYPE() [10/11]

UE_DECLARE_CORE_VARIANT_TYPE	(	Vector3	,
		Vector
	)

UE_DECLARE_CORE_VARIANT_TYPE() [11/11]

UE_DECLARE_CORE_VARIANT_TYPE	(	Vector4	,
		Vector4
	)