description: Execute the specified token as a unary operator, if such an overload exists

code: FExpressionResult ExecPostUnary ( const [FExpressionToken](API\Runtime\Core\Misc\FExpressionToken) & Operator, const [FExpressionToken](API\Runtime\Core\Misc\FExpressionToken) & L, const ContextType * Context ) const


module: Core

code: FExpressionResult ExecPreUnary ( const [FExpressionToken](API\Runtime\Core\Misc\FExpressionToken) & Operator, const [FExpressionToken](API\Runtime\Core\Misc\FExpressionToken) & R, const ContextType * Context ) const


description: Examples that binds a '/' token to a function that attempts to do a division: JumpTable.MapUnary({ return A / B; }); // Runtime exception on div/0 JumpTable.MapUnary({ if (!Ctxt->IsMathEnabled()) { return A; } return A / B; // Runtime exception on div/0 }); JumpTable.MapUnary(-> FExpressionResult { if (!Ctxt->IsMathEnabled()) { return MakeError(FExpressionError(LOCTEXT("MathNotEnabled", "Math is not enabled."))); } else if (B == 0) { /**

code: *return MakeError ( [FExpressionError](API\Runtime\Core\Misc\FExpressionError)(LOCTEXT("DivisionByZero","[Division](API\Plugins\AnimationModifierLibrary\EMotionExtractor_MathOperation) by zero.")) )


description: Map an expression node to a post-unary operator with the specified implementation. The same function signature rules apply here as with MapPreUnary.

code: template<typename OperatorType, typename FuncType> void MapPostUnary ( FuncType InFunc )


description:
Examples that binds a '!' token to a function that attempts to do a boolean 'not': JumpTable.MapPreUnary({ return !A; }); JumpTable.MapPreUnary({ if (Ctxt->IsBooleanNotOpEnabled()) { return !A; } else { return A; } }); JumpTable.MapPreUnary(-> FExpressionResult { if (Ctxt->IsBooleanNotOpEnabled())
{
    return MakeValue(!A);
}
return MakeError(FExpressionError(LOCTEXT("NotNotEnabled", "Boolean not is not enabled.")));
 });

code: template<typename OperatorType, typename FuncType> void MapPreUnary ( FuncType InFunc )


description: Check whether we should short circuit the specified operator

code: bool ShouldShortCircuit ( const [FExpressionToken](API\Runtime\Core\Misc\FExpressionToken) & Operator, const [FExpressionToken](API\Runtime\Core\Misc\FExpressionToken) & L, const ContextType * Context ) const


className: TOperatorJumpTable

description: Jump table specifying how to execute an operator with different types

code: template<typename ContextType> struct TOperatorJumpTable


className: TOptionalStorage

code: template<typename OptionalType, bool HasIntrusiveUnsetOptionalState> struct TOptionalStorage


className: Value

code: static constexpr SIZE_T Value = TParameterPackTypeIndexHelper<0, LookupType, Ts...>::Value;


className: TParameterPackTypeIndex

description: Entry-point for looking up the index of a type in a template parameter pack

code: template<typename LookupType, typename... Ts> struct TParameterPackTypeIndex


code: static constexpr SIZE_T Value = (SIZE_T)-1;


code: static Value = TParameterPackTypeIndexHelper<N + 1, LookupType, Ts...>::Value;


className: TParameterPackTypeIndexHelper

description: TParameterPackTypeIndexHelper< N, LookupType, T, Ts... >TParameterPackTypeIndexHelper< N, T, T, Ts... >

code: template<SIZE_T N, typename LookupType, typename... Ts> struct TParameterPackTypeIndexHelper


description: When different type than the lookup is at the front of the parameter pack, we increase the index and move to the next type

code: template<SIZE_T N, typename LookupType, typename T, typename... Ts> struct TParameterPackTypeIndexHelper< N, LookupType, T, Ts... >


description: When the type we're looking up bubbles up to the top, we return the current index

code: template<SIZE_T N, typename T, typename... Ts> struct TParameterPackTypeIndexHelper< N, T, T, Ts... >


code: [Private::TIterator](API\Runtime\Core\Misc\TIterator)< EnumType > begin() const


code: [Private::TIterator](API\Runtime\Core\Misc\TIterator)< EnumType > end() const


className: TRange

code: template<typename EnumType> struct TRange


code: [FPointerType](API\Runtime\Core\Misc\TRangeAllocator\FPointerType) Alloc ( uint32 Size, uint32 Alignment, [FAllocInfo](API\Runtime\Core\Misc\TRangeAllocator\FAllocInfo) & OutAllocInfo )


code: bool Contains ( [FConstPointerType](API\Runtime\Core\Misc\TRangeAllocator\FConstPointerType) Addr ) const


className: FAllocInfo

code: struct FAllocInfo : public FAllocInfoModifier


className: FAllocInfoModifier

code: typedef typename FAllocatorModifier::FAllocInfoModifier FAllocInfoModifier


code: SIZE_T Alloc &40; uint32 InSize, uint32 InAlignment, uint16 & InOutMaxFreeRangeSize, uint16 & OutOffset, uint16 & OutSize &41;


code: void Free &40; uint16 Offset, uint16 Size, uint16 & InOutMaxFreeRangeSize &41;


code: FChunk &40; const FRangeAllocator & Allocator &41;


className: FChunk

code: class FChunk : public FChunkModifier

type: union TRangeAll...


className: FChunkModifier

code: typedef typename FAllocatorModifier::FChunkModifier FChunkModifier


className: FConstPointerType

code: typedef typename FAllocatorModifier::FConstPointerType FConstPointerType


code: FFreeChunkInfo &40; uint16 InMaxFreeRangeSize, uint16 InChunkIndex &41;


className: FPointerType

code: typedef typename FAllocatorModifier::FPointerType FPointerType


className: FRangeAllocator

code: typedef [TRangeAllocator](API\Runtime\Core\Misc\TRangeAllocator)< FAllocatorModifier > FRangeAllocator


code: void Free ( const [FAllocInfo](API\Runtime\Core\Misc\TRangeAllocator\FAllocInfo) & AllocInfo )


code: void FreeChunk ( uint32 ChunkIndex )


code: void RemoveFreeChunkInfo ( int32 InfoIndex )


code: template<typename... ArgTypes> TRangeAllocator ( uint32 InMinAllocSize, ArgTypes &&... Args )


className: TRangeAllocator

description: Once the modifier is implemented, feed it toTRangeAllocatoras a template argument. You may derive from TRangeAllocatorto do further customization like adding methods that access protectedTRangeAllocatormember variables.

code: template<typename FAllocatorModifier> class TRangeAllocator : public FAllocatorModifier

Chunks

type: TArray<FChunk...

CS

type: FCriticalSectio...

FreeChunkInfos

type: TArray<FFreeCh...

MinAllocSize

type: const uint16


code: namespace TransformUtilities { uint32 TransformUtilities::GetRoundedTransformCRC32 ( const FTransform & InTransform ) }


code: [TReverseIterationAdapter](API\Runtime\Core\Misc\TReverseIterationAdapter) & operator= ( [TReverseIterationAdapter](API\Runtime\Core\Misc\TReverseIterationAdapter) && )


code: [TReverseIterationAdapter](API\Runtime\Core\Misc\TReverseIterationAdapter) & operator= ( const [TReverseIterationAdapter](API\Runtime\Core\Misc\TReverseIterationAdapter) & )


code: constexpr TReverseIterationAdapter ( RangeType & InRange )


code: TReverseIterationAdapter ( [TReverseIterationAdapter](API\Runtime\Core\Misc\TReverseIterationAdapter) && )


className: TReverseIterationAdapter

description: TReverseIterationAdapter< ElementType(&)[N]>

code: template<typename RangeType> struct TReverseIterationAdapter


code: constexpr TReversePointerIterator< ElementType > begin&40;&41; const


code: constexpr TReversePointerIterator< ElementType > end&40;&41; const


code: TReverseIterationAdapter & operator&61; &40; TReverseIterationAdapter && &41;


code: TReverseIterationAdapter & operator&61; &40; const TReverseIterationAdapter & &41;


code: TReverseIterationAdapter ( const [TReverseIterationAdapter](API\Runtime\Core\Misc\TReverseIterationAdapter) & )


code: constexpr TReverseIterationAdapter &40; ElementType &42; InArray &41;


code: TReverseIterationAdapter &40; TReverseIterationAdapter && &41;


code: TReverseIterationAdapter &40; const TReverseIterationAdapter & &41;


code: template<typename ElementType, std::size_t N> struct TReverseIterationAdapter< ElementType(&)[N]>


code: constexpr bool operator!= ( const [TReversePointerIterator](API\Runtime\Core\Misc\TReversePointerIterator) & Rhs ) const


code: constexpr [TReversePointerIterator](API\Runtime\Core\Misc\TReversePointerIterator) & operator++()


description: Like std::reverse_iterator, this points to one past the element being referenced. Therefore, for an array of size N starting at P, the begin iterator should be constructed at (P+N) and the end iterator should be constructed at P.

code: constexpr TReversePointerIterator ( T * InPtr )


className: TReversePointerIterator

description: Pointer-like reverse iterator type.

code: template<typename T> struct TReversePointerIterator


code: TScopedReaderAccessDetector ( RWAccessDetector & InAccessDetector )


className: TScopedReaderAccessDetector

code: template<typename RWAccessDetector> struct TScopedReaderAccessDetector : public [FBaseScopedAccessDetector](API\Runtime\Core\Misc\FBaseScopedAccessDetector)


code: TScopedWriterDetector ( RWAccessDetector & InAccessDetector )


className: TScopedWriterDetector

code: template<typename RWAccessDetector> struct TScopedWriterDetector : public [FBaseScopedAccessDetector](API\Runtime\Core\Misc\FBaseScopedAccessDetector)


code: TScopeGuard &40; TScopeGuard && &41;


code: TScopeGuard &40; const TScopeGuard & &41;


description: Given a lambda, constructs an RAII scope guard.

code: TScopeGuard ( FuncType && InFunc )


description: Causes the lambda to be executed.

code: ~TScopeGuard()


className: TScopeGuard

description: RAII class that calls a lambda when it is destroyed.

code: template<typename FuncType> class TScopeGuard


code: [TScopeLock](API\Runtime\Core\Misc\TScopeLock) & operator= ( const [TScopeLock](API\Runtime\Core\Misc\TScopeLock) & )


code: TScopeLock ( [TScopeLock](API\Runtime\Core\Misc\TScopeLock) && )


code: TScopeLock ( const [TScopeLock](API\Runtime\Core\Misc\TScopeLock) & )


code: [TScopeLock](API\Runtime\Core\Misc\TScopeLock) & operator= ( [TScopeLock](API\Runtime\Core\Misc\TScopeLock) && )


className: TScopeLock

description: RAII-style scope locking of a synchronisation primitiveMutexType_ is required to implementLock_ and `Unlock_ methods Example: { TScopeLockScopeLock(CriticalSection); ... }

code: template<typename MutexType> class TScopeLock


code: [TScopeUnlock](API\Runtime\Core\Misc\TScopeUnlock) & operator= ( const [TScopeUnlock](API\Runtime\Core\Misc\TScopeUnlock) & )


code: [TScopeUnlock](API\Runtime\Core\Misc\TScopeUnlock) & operator= ( [TScopeUnlock](API\Runtime\Core\Misc\TScopeUnlock) && )


code: TScopeUnlock ( [TScopeUnlock](API\Runtime\Core\Misc\TScopeUnlock) && )


code: TScopeUnlock ( const [TScopeUnlock](API\Runtime\Core\Misc\TScopeUnlock) & )


code: TScopeUnlock ( MutexType & InMutex )


className: TScopeUnlock

description: RAII-style scope unlocking of a synchronisation primitiveMutexType_ is required to implementLock_ and `Unlock_ methods Example: { TScopeLockScopeLock(CriticalSection); for (FElementType& Element : ThreadUnsafeContainer) { TScopeUnlockScopeUnlock(CriticalSection); Process(Element); } }

code: template<typename MutexType> class TScopeUnlock


className: TStaticDeprecateExpression

code: template<bool bIsDeprecated> struct TStaticDeprecateExpression


className: TStaticGetTypeLayoutHelper<                          FGuid >::CallAppendHash

code: static uint32 CallAppendHash &40; const FTypeLayoutDesc & TypeDesc, const FPlatformTypeLayoutParameters & LayoutParams, FSHA1 & Hasher &41;


className: TStaticGetTypeLayoutHelper<                          FGuid >::CallDestroy

code: static void CallDestroy &40; void &42; Object, const FTypeLayoutDesc &, const FPointerTableBase &42; PtrTable, bool bIsFrozen &41;


className: TStaticGetTypeLayoutHelper<                          FGuid >::CallGetTargetAlignment

code: static uint32 CallGetTargetAlignment &40; const FTypeLayoutDesc & TypeDesc, const FPlatformTypeLayoutParameters & LayoutParams &41;


className: TStaticGetTypeLayoutHelper<                          FGuid >::CallToString

code: static void CallToString &40; const void &42; Object, const FTypeLayoutDesc & TypeDesc, const FPlatformTypeLayoutParameters & LayoutParams, FMemoryToStringContext & OutContext &41;


className: TStaticGetTypeLayoutHelper<                          FGuid >::CallUnfrozenCopy

code: static uint32 CallUnfrozenCopy &40; const FMemoryUnfreezeContent & Context, const void &42; Object, const FTypeLayoutDesc & TypeDesc, void &42; OutDst &41;


className: TStaticGetTypeLayoutHelper<                          FGuid >::CallWriteMemoryImage

code: static void CallWriteMemoryImage &40; FMemoryImageWriter & Writer, const void &42; Object, const FTypeLayoutDesc & TypeDesc, const FTypeLayoutDesc & DerivedTypeDesc &41;


className: TStaticGetTypeLayoutHelper<                          FGuid >::Do

code: static const FTypeLayoutDesc & Do&40;&41;


className: TStaticGetTypeLayoutHelper<                          FGuid >

code: template<> struct TStaticGetTypeLayoutHelper< FGuid >


className: TStaticGetTypeLayoutHelper<                          FSHAHash >::CallDestroy


className: TStaticGetTypeLayoutHelper<                          FSHAHash >::CallAppendHash


className: TStaticGetTypeLayoutHelper<                          FSHAHash >::CallGetTargetAlignment


className: TStaticGetTypeLayoutHelper<                          FSHAHash >::CallToString


className: TStaticGetTypeLayoutHelper<                          FSHAHash >::CallUnfrozenCopy


className: TStaticGetTypeLayoutHelper<                          FSHAHash >::CallWriteMemoryImage


className: TStaticGetTypeLayoutHelper<                          FSHAHash >::Do


className: TStaticGetTypeLayoutHelper<                          FSHAHash >

code: template<> struct TStaticGetTypeLayoutHelper< FSHAHash >


className: TStorageTypeDeduction

code: template<typename T, uint32 MaxStackAllocationSize, typename Enabled> struct TStorageTypeDeduction


className: bAllowDuplicateKeys

code: static constexpr bool bAllowDuplicateKeys = bInAllowDuplicateKeys;


className: ElementInitType

code: typedef const [TTuple](API\Runtime\Core\Misc\TTuple)< typename [TTypeTraits](API\Runtime\Core\Templates\TTypeTraits)< InKeyType >::ConstInitType, typename [TTypeTraits](API\Runtime\Core\Templates\TTypeTraits)< InValueType >::ConstInitType > & ElementInitType


code: template<typename ComparableKey> static uint32 GetKeyHash ( ComparableKey Key )


code: static [KeyInitType](API\Runtime\Core\Misc\TStringPointerMapKeyFuncs_DEPREC-\KeyInitType) GetSetKey ( [ElementInitType](API\Runtime\Core\Misc\TStringPointerMapKeyFuncs_DEPREC-\ElementInitType) Element )


className: KeyInitType

code: typedef typename [TTypeTraits](API\Runtime\Core\Templates\TTypeTraits)< InKeyType >::ConstPointerType KeyInitType


code: template<typename ComparableKey> static bool Matches ( [KeyInitType](API\Runtime\Core\Misc\TStringPointerMapKeyFuncs_DEPREC-\KeyInitType) A, const ComparableKey & B )


code: typedef typename [TCallTraits](API\Runtime\Core\GenericPlatform\TCallTraits)< InKeyType >::ParamType ElementInitType


description: An implementation of KeyFuncs for maps which hashes string pointers byFCrc::Strihash_DEPRECATED.

code: template<typename InKeyType, typename InValueType, bool bInAllowDuplicateKeys> struct TStringPointerMapKeyFuncs_DEPRECATED


code: static [KeyInitType](API\Runtime\Core\Misc\TStringPointerSetKeyFuncs_DEPREC-\KeyInitType) GetSetKey ( [ElementInitType](API\Runtime\Core\Misc\TStringPointerSetKeyFuncs_DEPREC-\ElementInitType) Element )


code: template<typename ComparableKey> static bool Matches ( [KeyInitType](API\Runtime\Core\Misc\TStringPointerSetKeyFuncs_DEPREC-\KeyInitType) A, const ComparableKey & B )


description: An implementation of KeyFuncs for sets which hashes string pointers byFCrc::Strihash_DEPRECATED.

code: template<typename InKeyType, bool bInAllowDuplicateKeys> struct TStringPointerSetKeyFuncs_DEPRECATED


className: FItemTestComplexExpression

description: Defines a function signature used to test a complex expression for an Item

code: typedef TBaseDelegate_FiveParams< bool, [ItemType](API\Runtime\Core\Misc\IFilter\ItemType), const [FName](API\Runtime\Core\UObject\FName) &, const [FTextFilterString](API\Runtime\Core\Misc\FTextFilterString) &, ETextFilterComparisonOperation, ETextFilterTextComparisonMode > FItemTestComplexExpression


className: FItemToStringArray

description: Defines a function signature for functions used to transform an Item into an array of FStrings

code: typedef TBaseDelegate_TwoParams< void, [ItemType](API\Runtime\Core\Misc\IFilter\ItemType), [TArray](API\Runtime\Core\Containers\TArray)< [FString](API\Runtime\Core\Containers\FString) > & > FItemToStringArray


description: Get the last error returned from lexing or compiling the current filter text


description: Returns the unsanitized and unsplit filter terms


description:
Returns whether the specified Item passes the Filter's text restrictions
Whether the specified Item passed the filter

code: virtual bool PassesFilter ( [ItemType](API\Runtime\Core\Misc\IFilter\ItemType) InItem ) const


description: Set the Text to be used as the Filter's restrictions

code: void SetRawFilterText ( const [FText](API\Runtime\Core\Internationalization\FText) & InFilterText )


description: TTextFilterConstructor

code: TTextFilter ( [FItemToStringArray](API\Runtime\Core\Misc\TTextFilter\FItemToStringArray) InTransformDelegate )


code: TTextFilter ( [FItemToStringArray](API\Runtime\Core\Misc\TTextFilter\FItemToStringArray) InTransformDelegate, [FItemTestComplexExpression](API\Runtime\Core\Misc\TTextFilter\FItemTestComplexExpression) InTestComplexExpressionDelegate )


className: TTextFilter

description: A generic filter specialized for text restrictions

code: template<typename ItemType> class TTextFilter : public [IFilter< ItemType >](API\Runtime\Core\Misc\IFilter), public [TSharedFromThis< TTextFilter< ItemType > >](API\Runtime\Core\Templates\TSharedFromThis)


description: Pointer/view arguments are passed without causingFStringtemporaries to be created, andFStringarguments are referenced directly without creating extra copies.

code: typedef decltype([GetBindingType](API\Runtime\Core\Misc\UE__Core__Private__GetBindingTyp-\1)(std::declval< T >())) TToStringType_T


code: [TTuple](API\Runtime\Core\Misc\TTuple) & operator= ( [TTuple](API\Runtime\Core\Misc\TTuple) && )


code: [TTuple](API\Runtime\Core\Misc\TTuple) & operator= ( const [TTuple](API\Runtime\Core\Misc\TTuple) & )


code: template<typename... OtherTypes, decltype([UE::Core::Private::Tuple::AssignableConceptCheck](API\Runtime\Core\Templates\UE__Core__Private__Tuple__Assign-)< Types &... >(DeclVal< const OtherTypes & >()...))*> [TTuple](API\Runtime\Core\Misc\TTuple) & operator= ( const [TTuple](API\Runtime\Core\Misc\TTuple)< OtherTypes... > & Other )


code: template<typename... OtherTypes, decltype([UE::Core::Private::Tuple::AssignableConceptCheck](API\Runtime\Core\Templates\UE__Core__Private__Tuple__Assign-)< Types &... >(DeclVal< OtherTypes && >()...))*> [TTuple](API\Runtime\Core\Misc\TTuple) & operator= ( [TTuple](API\Runtime\Core\Misc\TTuple)< OtherTypes... > && Other )


className: Super

code: typedef [UE::Core::Private::Tuple::TTupleBase](API\Runtime\Core\Templates\TTupleBase)< TMakeIntegerSequence< uint32, sizeof...(Types)>, Types... > Super


code: template<typename... ArgTypes, decltype([UE::Core::Private::Tuple::ConstructibleConceptCheck](API\Runtime\Core\Templates\UE__Core__Private__Tuple__Constr-)< Types... >(DeclVal< ArgTypes && >()...))*> TTuple ( ArgTypes &&... Args )


code: template<typename... OtherTypes, decltype([UE::Core::Private::Tuple::ConstructibleConceptCheck](API\Runtime\Core\Templates\UE__Core__Private__Tuple__Constr-)< Types... >(DeclVal< OtherTypes && >()...))*> TTuple ( [TTuple](API\Runtime\Core\Misc\TTuple)< OtherTypes... > && Other )


code: template<typename... OtherTypes, decltype([UE::Core::Private::Tuple::ConstructibleConceptCheck](API\Runtime\Core\Templates\UE__Core__Private__Tuple__Constr-)< Types... >(DeclVal< const OtherTypes & >()...))*> TTuple ( const [TTuple](API\Runtime\Core\Misc\TTuple)< OtherTypes... > & Other )


code: TTuple ( [TTuple](API\Runtime\Core\Misc\TTuple) && )


code: TTuple ( const [TTuple](API\Runtime\Core\Misc\TTuple) & )


className: TTuple

code: template<typename... Types> struct TTuple : public [UE::Core::Private::Tuple::TTupleBase< TMakeIntegerSequence< uint32, sizeof...(Types)>, Types... >](API\Runtime\Core\Templates\TTupleBase)


description: RegisterInstance

code: template<class R> [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< R, Mode > GetInstance() const


description: Add an instance provider to the container.

code: void AddProvider ( const TCHAR * Name, const [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr)< IInstanceProvider > & Provider )


description: RegisterInstance

code: template<class R> [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< R, Mode > GetInstanceRef() const


description:
Check whether the specified class has been registered.
true if the class was registered, false otherwise.

code: template<class R> bool IsRegistered() const


description: Register a factory delegate for the specified class.

code: template<class R, class D, typename... P> void RegisterDelegate ( D Delegate )


description: Unregister

code: template<class R, class T, typename... P> void RegisterClass ( ETypeContainerScope Scope )


description: Unregister

code: template<class R> void RegisterFactory ( const [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< R, Mode >()> & CreateFunc )


description: Unregister

code: template<class R, typename P0, typename... P> void RegisterFactory ( const [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< R, Mode >([TSharedRef](API\Runtime\Core\Templates\TSharedRef)< P0, Mode >, [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< P, Mode >...)> & CreateFunc )


description: Unregister

code: template<class R, class T> void RegisterInstance ( const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< T, Mode > & Instance )


description: RegisterInstance

code: template<class R> void Unregister()


className: TTypeContainer

description: Note: Type containers depend on variadic templates and are therefore not available on XboxOne at this time, which means they should only be used for desktop applications.

code: template<ESPMode Mode> class TTypeContainer


className: TTypePackContainsDuplicates< T >

description: A template parameter pack containing a single type has no duplicates

code: template<typename T> struct TTypePackContainsDuplicates< T >


description: A template parameter pack containing the same type adjacently contains duplicate types. The next structure ensures that we check all pairs of types in a template parameter pack.

code: template<typename T, typename... Ts> struct TTypePackContainsDuplicates< T, T, Ts... >


className: Value

code: static Value = TTypePackContainsDuplicates<T, Rest...>::Value || TTypePackContainsDuplicates<U, Rest...>::Value;


description: Check all pairs of types in a template parameter pack to determine if any type is duplicated

code: template<typename T, typename U, typename... Rest> struct TTypePackContainsDuplicates< T, U, Rest... >


className: TUEStaticAssertTypeChecker

code: template<typename T> struct TUEStaticAssertTypeChecker


code: template<> struct TUEStaticAssertTypeChecker< const void >


className: TUEStaticAssertTypeChecker< const                                                                  void >::Func

code: static FIncompleteType Func&40;&41;


className: TUEStaticAssertTypeChecker< const volatile void >::Func


code: template<> struct TUEStaticAssertTypeChecker< const volatile void >


description: Function types are complete types, but we can't form a reference to one, so let's just make those work too.

code: template<typename RetType, typename... ArgTypes> struct TUEStaticAssertTypeChecker< RetType(ArgTypes...)>


className: TUEStaticAssertTypeChecker< T & >::Func

code: static int Func&40;&41;


className: TUEStaticAssertTypeChecker< T & >

description: References are always complete types, but as we're using sizeof to check and sizeof ignores references, let's just return a known complete type to make it work.

code: template<typename T> struct TUEStaticAssertTypeChecker< T & >


className: TUEStaticAssertTypeChecker< T && >::Func


className: TUEStaticAssertTypeChecker< T && >

code: template<typename T> struct TUEStaticAssertTypeChecker< T && >


className: TUEStaticAssertTypeChecker<                                                                                void >::Func


className: TUEStaticAssertTypeChecker<                                                                                void >

description: Voids will give an unhelpful error message when trying to take a reference to them, so work around it.

code: template<> struct TUEStaticAssertTypeChecker< void >


className: TUEStaticAssertTypeChecker< volatile                                   void >::Func


code: template<> struct TUEStaticAssertTypeChecker< volatile void >


description: Set a specifically-typed value into the variant using in-place construction

code: template<typename U, typename... TArgs> void Emplace ( TArgs &&... Args )


description: Get a reference to the held value. Bad things can happen if this is called on a variant that does not hold the type asked for

code: template<typename U> U & Get()


code: template<typename U> const U & Get() const


description: Returns the currently held type's index into the template parameter pack

code: SIZE_T GetIndex() const


description: Lookup the index of a type in the template parameter pack at compile time.

code: template<typename U> static constexpr SIZE_T IndexOfType()


description: Determine if the variant holds the specific type

code: template<typename U> bool IsType() const


description: Copy assign a variant from another variant of the same type

code: [TVariant](API\Runtime\Core\Misc\TVariant) & operator= ( const [TVariant](API\Runtime\Core\Misc\TVariant) & Other )


description: Move assign a variant from another variant of the same type

code: [TVariant](API\Runtime\Core\Misc\TVariant) & operator= ( [TVariant](API\Runtime\Core\Misc\TVariant) && Other )


description: Set a specifically-typed value into the variant

code: template<typename U> void Set ( typename [TIdentity](API\Runtime\Core\Templates\TIdentity)< U >::Type && Value )


code: template<typename U> void Set ( const typename [TIdentity](API\Runtime\Core\Templates\TIdentity)< U >::Type & Value )


description: Get a pointer to the held value if the held type is the same as the one specified

code: template<typename U> U * TryGet()


code: template<typename U> const U * TryGet() const


description: Default initialize theTVariantto the first type in the parameter pack

code: TVariant()


description: Copy construct the variant from another variant of the same type

code: TVariant ( const [TVariant](API\Runtime\Core\Misc\TVariant) & Other )


description: Move construct the variant from another variant of the same type

code: TVariant ( [TVariant](API\Runtime\Core\Misc\TVariant) && Other )


description: Perform in-place construction of a type into the variant

code: template<typename U, typename... TArgs> TVariant ( [TInPlaceType](API\Runtime\Core\Misc\TInPlaceType)< U > &&, TArgs &&... Args )


description: Destruct the underlying type (if appropriate)

code: ~TVariant()


description: Default construct the type and load it from theFArchive

code: static void Load ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar, VariantType & OutVariant )


className: TVariant

description: A type-safe union based loosely on std::variant. This flavor of variant requires that all the types in the declaring template parameter pack be unique. Attempting to use the value of aGet()when the underlying type is different leads to undefined behavior.

code: template<typename T, typename... Ts> class TVariant : private [UE::Core::Private::TVariantStorage< T, Ts... >](API\Runtime\Core\Misc\TVariantStorage)


className: TVariantLoadFromArchiveCaller

description: A utility for loading a specific type fromFArchiveinto aTVariant

code: template<typename T, typename VariantType> struct TVariantLoadFromArchiveCaller


description: Load the type at the specified index from theFArchiveand emplace it into theTVariant

code: static void Load ( SIZE_T TypeIndex, [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar, [VariantType](API\Runtime\Core\Misc\TVariantLoadFromArchiveLookup\VariantType) & OutVariant )


className: VariantType

code: typedef [TVariant](API\Runtime\Core\Misc\TVariant)< Ts... > VariantType


className: TVariantLoadFromArchiveLookup

description: A utility for loading a type fromFArchivebased on an index into a template parameter pack.

code: template<typename... Ts> struct TVariantLoadFromArchiveLookup


className: TVariantSize

code: template<typename> struct TVariantSize


className: TVariantSize< const T >

code: template<typename T> struct TVariantSize< const T > : public [TVariantSize< T >](API\Runtime\Core\Misc\TVariantSize)


className: TVariantSize< T && >

code: template<typename T> struct TVariantSize< T && > : public [TVariantSize< T >](API\Runtime\Core\Misc\TVariantSize)


className: TVariantSize< T & >

code: template<typename T> struct TVariantSize< T & > : public [TVariantSize< T >](API\Runtime\Core\Misc\TVariantSize)


className: AlignofValue

code: static constexpr SIZE_T AlignofValue = MaxAlignof();


description: Interpret the underlying data as the type in the variant parameter pack at the compile-time index. This function is used to implement Visit and should not be used directly

code: template<SIZE_T N> auto & GetValueAsIndexedType()


code: template<SIZE_T N> auto && GetValueAsIndexedType()


code: template<SIZE_T N> const auto & GetValueAsIndexedType() const


code: static constexpr SIZE_T MaxAlignof()


code: static constexpr SIZE_T MaxOf ( const SIZE_T Sizes )


className: SizeofValue

code: static constexpr SIZE_T SizeofValue = MaxSizeof();


className: TVariantStorage

description: Determine the max alignof and sizeof of all types in a template parameter pack and provide a type that is compatible with those sizes

code: template<typename... Ts> struct TVariantStorage

Storage

type: TAlignedBytes< ...


code: static constexpr EVariantTypes GetType()


className: TVariantTraits

code: template<typename T> struct TVariantTraits


className: TVariantTraits< ANSICHAR >::GetType

code: static constexpr EVariantTypes GetType&40;&41;


className: TVariantTraits< ANSICHAR >

description: DefaultFVarianttraits for built-in typesImplements variant type traits for the built-in ANSICHAR type.

code: template<> struct TVariantTraits< ANSICHAR >


className: TVariantTraits< bool >::GetType


className: TVariantTraits< bool >

description: Implements variant type traits for the built-in bool type.

code: template<> struct TVariantTraits< bool >


className: TVariantTraits< double >::GetType


className: TVariantTraits< double >

description: Implements variant type traits for the built-in double type.

code: template<> struct TVariantTraits< double >


className: TVariantTraits< FBox >::GetType


className: TVariantTraits< FBox >

description: Implements variant type traits for the built-in FBox type.

code: template<> struct TVariantTraits< FBox >


className: TVariantTraits< FBoxSphereBounds >

description: Implements variant type traits for the built-in FBoxSphereBounds type.

code: template<> struct TVariantTraits< FBoxSphereBounds >


className: TVariantTraits< FColor >::GetType


className: TVariantTraits< FColor >

description: Implements variant type traits for the built-inFColortype.

code: template<> struct TVariantTraits< FColor >


className: TVariantTraits< FDateTime >::GetType


className: TVariantTraits< FDateTime >

description: Implements variant type traits for the built-inFDateTimetype.

code: template<> struct TVariantTraits< FDateTime >


className: TVariantTraits< FGuid >::GetType


className: TVariantTraits< FGuid >

description: Implements variant type traits for the built-inFGuidtype.

code: template<> struct TVariantTraits< FGuid >


className: TVariantTraits< FIntPoint >::GetType


className: TVariantTraits< FIntPoint >

description: Implements variant type traits for the built-in FIntPoint type.

code: template<> struct TVariantTraits< FIntPoint >


className: TVariantTraits< FIntRect >::GetType


className: TVariantTraits< FIntRect >

description: Implements variant type traits for the built-in FIntRect type.

code: template<> struct TVariantTraits< FIntRect >


className: TVariantTraits< FIntVector >::GetType


className: TVariantTraits< FIntVector >

description: Implements variant type traits for the built-in FIntVector type.

code: template<> struct TVariantTraits< FIntVector >


className: TVariantTraits< FLinearColor >::GetType


className: TVariantTraits< FLinearColor >

description: Implements variant type traits for the built-inFLinearColortype.

code: template<> struct TVariantTraits< FLinearColor >


className: TVariantTraits< float >::GetType


className: TVariantTraits< float >

description: Implements variant type traits for the built-in float type.

code: template<> struct TVariantTraits< float >


className: TVariantTraits< FMatrix >::GetType


className: TVariantTraits< FMatrix >

description: Implements variant type traits for the built-in FMatrix type.

code: template<> struct TVariantTraits< FMatrix >


className: TVariantTraits< FName >::GetType


className: TVariantTraits< FName >

description: Implements variant type traits for the built-inFNametype.

code: template<> struct TVariantTraits< FName >


className: TVariantTraits< FNetworkGUID >::GetType


className: TVariantTraits< FNetworkGUID >

description: Implements variant type traits for the built-in NetworkGUID type.

code: template<> struct TVariantTraits< FNetworkGUID >


className: TVariantTraits< FPlane >::GetType

code: static constexpr EVariantTypes GetType&40;&41;


className: TVariantTraits< FPlane >

description: Implements variant type traits for the built-in FPlane type.

code: template<> struct TVariantTraits< FPlane >


className: TVariantTraits< FQuat >::GetType


className: TVariantTraits< FQuat >

description: Implements variant type traits for the built-in FQuat type.

code: template<> struct TVariantTraits< FQuat >


className: TVariantTraits< FRandomStream >

description: Implements variant type traits for the built-inFRandomStreamtype.

code: template<> struct TVariantTraits< FRandomStream >


className: TVariantTraits< FRotator >::GetType


className: TVariantTraits< FRotator >

description: Implements variant type traits for the built-in FRotator type.

code: template<> struct TVariantTraits< FRotator >


className: TVariantTraits< FString >::GetType


className: TVariantTraits< FString >

description: Implements variant type traits for the built-inFStringtype.

code: template<> struct TVariantTraits< FString >


className: TVariantTraits< FTimespan >::GetType


className: TVariantTraits< FTimespan >

description: Implements variant type traits for the built-inFTimespantype.

code: template<> struct TVariantTraits< FTimespan >


className: TVariantTraits< FTransform >::GetType


className: TVariantTraits< FTransform >

description: Implements variant type traits for the built-in FTransform type.

code: template<> struct TVariantTraits< FTransform >


className: TVariantTraits< FTwoVectors >::GetType


className: TVariantTraits< FTwoVectors >

description: Implements variant type traits for the built-inFTwoVectorstype.

code: template<> struct TVariantTraits< FTwoVectors >


className: TVariantTraits< FVector >::GetType


className: TVariantTraits< FVector >

description: Implements variant type traits for the built-in FVector type.

code: template<> struct TVariantTraits< FVector >


className: TVariantTraits< FVector2D >::GetType


className: TVariantTraits< FVector2D >

description: Implements variant type traits for the built-in FVector2D type.

code: template<> struct TVariantTraits< FVector2D >


className: TVariantTraits< FVector4 >::GetType


className: TVariantTraits< FVector4 >

description: Implements variant type traits for the built-in FVector4 type.

code: template<> struct TVariantTraits< FVector4 >


className: TVariantTraits< int16 >::GetType


className: TVariantTraits< int16 >

description: Implements variant type traits for the built-in int16 type.

code: template<> struct TVariantTraits< int16 >


className: TVariantTraits< int32 >::GetType


className: TVariantTraits< int32 >

description: Implements variant type traits for the built-in int32 type.

code: template<> struct TVariantTraits< int32 >


className: TVariantTraits< int64 >::GetType


className: TVariantTraits< int64 >

description: Implements variant type traits for the built-in int64 type.

code: template<> struct TVariantTraits< int64 >


className: TVariantTraits< int8 >::GetType


className: TVariantTraits< int8 >

description: Implements variant type traits for the built-in int8 type.

code: template<> struct TVariantTraits< int8 >


className: TVariantTraits< uint16 >::GetType


className: TVariantTraits< uint16 >

description: Implements variant type traits for the built-in uint16 type.

code: template<> struct TVariantTraits< uint16 >


className: TVariantTraits< uint32 >::GetType

code: static constexpr EVariantTypes GetType&40;&41;


className: TVariantTraits< uint32 >

description: Implements variant type traits for the built-in uint32 type.

code: template<> struct TVariantTraits< uint32 >


className: TVariantTraits< uint64 >::GetType


className: TVariantTraits< uint64 >

description: Implements variant type traits for the built-in uint64 type.

code: template<> struct TVariantTraits< uint64 >


className: TVariantTraits< uint8 >::GetType


className: TVariantTraits< uint8 >

description: Implements variant type traits for the built-in uint8 type.

code: template<> struct TVariantTraits< uint8 >


className: TVariantTraits< WIDECHAR >::GetType


className: TVariantTraits< WIDECHAR >

description: Implements variant type traits for the built-in WIDECHAR type.

code: template<> struct TVariantTraits< WIDECHAR >


className: FuncPtr

code: static constexpr InvokeFn FuncPtr = &VisitApplyEncoded<EncodedIndex, VariantIndices...>;


className: TWrapper

description: Due to what appears to be a lexing bug, MSVC 2017 tries to expand EncodedIndices and VariantIndices together

code: template<typename InvokeFn, SIZE_T... VariantIndices> struct TWrapper


description: A junk function to allow us to use sizeof on a member variable which is potentially a bitfield.

code: namespace UEAsserts_Private { template<typename T> bool UEAsserts_Private::GetMemberNameCheckedJunk ( const T & ) }


code: namespace UEAsserts_Private { template<typename T> bool UEAsserts_Private::GetMemberNameCheckedJunk ( const volatile T & ) }


code: namespace UEAsserts_Private { template<typename R, typename... Args> bool UEAsserts_Private::GetMemberNameCheckedJunk ( R(*)(Args...) ) }


code: namespace UE { namespace AccessDetection { enum EType { None = 0, File = 1 << 0, Ini = 1 << 1, CVar = 1 << 2, } } }


code: namespace UE { namespace AccessDetection { [EType](API\Runtime\Core\Misc\UE__AccessDetection__EType) & UE::AccessDetection::operator|= ( [EType](API\Runtime\Core\Misc\UE__AccessDetection__EType) & Lhs, [EType](API\Runtime\Core\Misc\UE__AccessDetection__EType) Rhs ) } }


code: namespace UE { namespace AccessDetection { [EType](API\Runtime\Core\Misc\UE__AccessDetection__EType) & UE::AccessDetection::operator&= ( [EType](API\Runtime\Core\Misc\UE__AccessDetection__EType) & Lhs, [EType](API\Runtime\Core\Misc\UE__AccessDetection__EType) Rhs ) } }


code: namespace UE { namespace AccessDetection { [EType](API\Runtime\Core\Misc\UE__AccessDetection__EType) & UE::AccessDetection::operator^= ( [EType](API\Runtime\Core\Misc\UE__AccessDetection__EType) & Lhs, [EType](API\Runtime\Core\Misc\UE__AccessDetection__EType) Rhs ) } }


code: namespace UE { namespace AccessDetection { constexpr [EType](API\Runtime\Core\Misc\UE__AccessDetection__EType) UE::AccessDetection::operator| ( [EType](API\Runtime\Core\Misc\UE__AccessDetection__EType) Lhs, [EType](API\Runtime\Core\Misc\UE__AccessDetection__EType) Rhs ) } }


code: namespace UE { namespace AccessDetection { constexpr [EType](API\Runtime\Core\Misc\UE__AccessDetection__EType) UE::AccessDetection::operator& ( [EType](API\Runtime\Core\Misc\UE__AccessDetection__EType) Lhs, [EType](API\Runtime\Core\Misc\UE__AccessDetection__EType) Rhs ) } }


code: namespace UE { namespace AccessDetection { constexpr [EType](API\Runtime\Core\Misc\UE__AccessDetection__EType) UE::AccessDetection::operator^ ( [EType](API\Runtime\Core\Misc\UE__AccessDetection__EType) Lhs, [EType](API\Runtime\Core\Misc\UE__AccessDetection__EType) Rhs ) } }


code: namespace UE { namespace AccessDetection { constexpr bool UE::AccessDetection::operator! ( [EType](API\Runtime\Core\Misc\UE__AccessDetection__EType) E ) } }


code: namespace UE { namespace AccessDetection { constexpr [EType](API\Runtime\Core\Misc\UE__AccessDetection__EType) UE::AccessDetection::operator~ ( [EType](API\Runtime\Core\Misc\UE__AccessDetection__EType) E ) } }


code: namespace UE { namespace AccessDetection { void UE::AccessDetection::ReportAccess ( [EType](API\Runtime\Core\Misc\UE__AccessDetection__EType) Type ) } }


description: Cast aTVariantto its private base

code: namespace UE { namespace Core { namespace Private { template<typename... Ts> [TVariantStorage](API\Runtime\Core\Misc\TVariantStorage)< Ts... > & UE::Core::Private::CastToStorage ( [TVariant](API\Runtime\Core\Misc\TVariant)< Ts... > & Variant ) } } }


code: namespace UE { namespace Core { namespace Private { template<typename... Ts> [TVariantStorage](API\Runtime\Core\Misc\TVariantStorage)< Ts... > && UE::Core::Private::CastToStorage ( [TVariant](API\Runtime\Core\Misc\TVariant)< Ts... > && Variant ) } } }


code: namespace UE { namespace Core { namespace Private { template<typename... Ts> const [TVariantStorage](API\Runtime\Core\Misc\TVariantStorage)< Ts... > & UE::Core::Private::CastToStorage ( const [TVariant](API\Runtime\Core\Misc\TVariant)< Ts... > & Variant ) } } }


description: Inverse operation of EncodeIndices. Decodes an encoded index into the individual index for the specified variant index.

code: namespace UE { namespace Core { namespace Private { constexpr SIZE_T UE::Core::Private::DecodeIndex ( SIZE_T EncodedIndex, SIZE_T VariantIndex, const SIZE_T * VariantSizes ) } } }


description: Encode the stored index of a bunch of variants into a single value used to lookup a Visit invocation function

code: namespace UE { namespace Core { namespace Private { template<typename T> SIZE_T UE::Core::Private::EncodeIndices ( const T & Variant ) } } }


code: namespace UE { namespace Core { namespace Private { template<typename Variant0, typename... Variants> SIZE_T UE::Core::Private::EncodeIndices ( const Variant0 & First, const Variants &... Rest ) } } }


code: namespace UE { namespace Core { namespace Private { const TCHAR * UE::Core::Private::GetBindingType ( const TCHAR * Ptr ) } } }


code: namespace UE { namespace Core { namespace Private { const [FString](API\Runtime\Core\Containers\FString) & UE::Core::Private::GetBindingType ( const [FString](API\Runtime\Core\Containers\FString) & Str ) } } }


code: namespace UE { namespace Core { namespace Private { const FStringView & UE::Core::Private::GetBindingType ( const FStringView & StringView ) } } }


description: Used to determine the total number of possible Visit invocations when fold expressions are not available.

code: namespace UE { namespace Core { namespace Private { constexpr SIZE_T UE::Core::Private::Multiply ( const SIZE_T * Args, SIZE_T Num ) } } }


code: namespace UE { namespace Core { namespace Private { void UE::Core::Private::OnInvalidMemStackAllocatorNum ( int32 NewNum, SIZE_T NumBytesPerElement ) } } }


description: Invocation detail for a single combination of stored variant indices

code: namespace UE { namespace Core { namespace Private { template<SIZE_T EncodedIndex, SIZE_T... VariantIndices, typename Func, typename... Variants> decltype(auto) UE::Core::Private::VisitApplyEncoded ( Func && Callable, Variants &&... Args ) } } }


description: Implementation detail for Visit(Callable, Variants...). Builds an array of invokers, and forwards the variants to the callable for the specific EncodedIndex

code: namespace UE { namespace Core { namespace Private { template<typename Func, SIZE_T... EncodedIndices, SIZE_T... VariantIndices, typename... Variants> decltype(auto) UE::Core::Private::VisitImpl ( SIZE_T EncodedIndex, Func && Callable, [TIntegerSequence](API\Runtime\Core\Delegates\TIntegerSequence)< SIZE_T, EncodedIndices... > &&, [TIntegerSequence](API\Runtime\Core\Delegates\TIntegerSequence)< SIZE_T, VariantIndices... > && VariantIndicesSeq, Variants &&... Args ) } } }


code: namespace UE { namespace MemStack { template<typename T> [TArrayView](API\Runtime\Core\Containers\TArrayView)< T > UE::MemStack::AllocateArrayView ( [FMemStackBase](API\Runtime\Core\Misc\FMemStackBase) & Allocator, [TArrayView](API\Runtime\Core\Containers\TArrayView)< T > View ) } }


code: namespace UE { namespace MemStack { const TCHAR * UE::MemStack::AllocateString ( [FMemStackBase](API\Runtime\Core\Misc\FMemStackBase) & Allocator, FStringView String ) } }


code: namespace UE { namespace MemStack { const TCHAR * UE::MemStack::AllocateString ( [FMemStackBase](API\Runtime\Core\Misc\FMemStackBase) & Allocator, const FStringBuilderBase & StringBuilder ) } }


code: namespace UE { namespace MemStack { const TCHAR * UE::MemStack::AllocateString ( [FMemStackBase](API\Runtime\Core\Misc\FMemStackBase) & Allocator, const TCHAR * String, int32 Length ) } }


code: namespace UE { namespace MemStack { template<typename FormatType, typename... ArgTypes> const TCHAR * UE::MemStack::AllocateStringf ( [FMemStackBase](API\Runtime\Core\Misc\FMemStackBase) & Allocator, const FormatType & Format, ArgTypes... Args ) } }


code: namespace UE { namespace MemStack { FStringView UE::MemStack::AllocateStringView ( [FMemStackBase](API\Runtime\Core\Misc\FMemStackBase) & Allocator, FStringView String ) } }


description:
Get a compatible engine version object for this build version
New engine version object


description:
Get the default path to the build.version file on disk
Path to the Build.version file


description:
Gets the compatible changelist if set, otherwise the default compatible changelist
The compatible changelist


description:
Get the path to the version file for the current executable.
Path to the target's version file


description:
Get an engine version object for this build version
New engine version object


code: namespace UE { namespace MemStack { template<typename FormatType, typename... ArgTypes> FStringView UE::MemStack::AllocateStringViewf ( [FMemStackBase](API\Runtime\Core\Misc\FMemStackBase) & Allocator, const FormatType & Format, ArgTypes... Args ) } }


description:
Try to read a version file from disk
True if the version was read successfully, false otherwise

code: static bool TryRead ( const [FString](API\Runtime\Core\Containers\FString) & FileName, [FBuildVersion](API\Runtime\Core\Modules\FBuildVersion) & OutVersion )


description: Default constructor. Initializes the structure to empty.

code: FBuildVersion()


className: FBuildVersion

description: Stores the version information associated with a build

code: class FBuildVersion

BranchName

type: FString

description: Name of the current branch, with '/' characters escaped as '+'

BuildId

description: The current build id.

BuildVersion

description: The build version string.

Changelist

type: int

description: The changelist that the engine is being built from

CompatibleChangelist

description: The changelist that the engine maintains compatibility with

IsLicenseeVersion

description: Whether the changelist numbers are a licensee changelist

IsPromotedBuild

description: Whether the current build is a promoted build, that is, built strictly from a clean sync of the given changelist

MajorVersion

description: The major engine version (4 for UE4)

MinorVersion

description: The minor engine version

PatchVersion

description: The hotfix/patch version


className: FDefaultGameModuleImpl

description: Default minimal module class for gameplay modules. Does nothing at startup and shutdown.

code: class FDefaultGameModuleImpl : public [FDefaultModuleImpl](API\Runtime\Core\Modules\FDefaultModuleImpl)


className: FDefaultModuleImpl

description: A default minimal implementation of a module that does nothing at startup and shutdown

code: class FDefaultModuleImpl : public [IModuleInterface](API\Runtime\Core\Modules\IModuleInterface)


description: UnloadModule

code: void AbandonModule ( const [FName](API\Runtime\Core\UObject\FName) InModuleName )


description: LoadModuleWithCallback

code: void AbandonModuleWithCallback ( const [FName](API\Runtime\Core\UObject\FName) InModuleName )


description: Adds an engine binaries directory.

code: void AddBinariesDirectory ( const TCHAR * InDirectory, bool bIsGameDirectory )


description: Add any extra search paths that may be required

code: void AddExtraBinarySearchPaths()


description: Adds a module to our list of modules, unless it's already known.

code: void AddModule ( const [FName](API\Runtime\Core\UObject\FName) InModuleName )


code: void AddModuleToModulesList ( const [FName](API\Runtime\Core\UObject\FName) InModuleName, [FModuleManager::ModuleInfoRef](API\Runtime\Core\Templates\TSharedRef) & ModuleInfo )


description:
Determines whether the specified module contains UObjects. The module must already be loaded into memory before calling this function.
True if the module was found to contain UObjects, or false if it did not (or wasn't loaded.)

code: bool DoesLoadedModuleHaveUObjects ( const [FName](API\Runtime\Core\UObject\FName) ModuleName ) const


description: Implementation of Exec that is only called in non-shipping targets

code: virtual bool Exec_Dev ( [UWorld](API\Runtime\Engine\Engine\UWorld) * InWorld, const TCHAR * Cmd, [FOutputDevice](API\Runtime\Core\Misc\FOutputDevice) & Ar )


description: Finds module files on the disk for loadable modules matching the specified wildcard.

code: void FindModules ( const TCHAR * WildcardWithoutExtension, [TArray](API\Runtime\Core\Containers\TArray)< [FName](API\Runtime\Core\UObject\FName) > & OutModules ) const


className: FInitializeStaticallyLinkedModule

description: Delegate that's used by the module manager to initialize a registered module that we statically linked with (monolithic only)

code: typedef TBaseDelegate_NoParams< [IModuleInterface](API\Runtime\Core\Modules\IModuleInterface) * > FInitializeStaticallyLinkedModule


className: FIsPackageLoadedCallback

description: The first parameter is the name of the loaded module.

code: typedef TBaseDelegate_OneParam< bool, [FName](API\Runtime\Core\UObject\FName) > FIsPackageLoadedCallback


className: FModuleMap

description: Type definition for maps of module names to module infos.

code: typedef [TMap](API\Runtime\Core\Containers\TMap)< [FName](API\Runtime\Core\UObject\FName), [ModuleInfoRef](API\Runtime\Core\Templates\TSharedRef) > FModuleMap


className: FModulesChangedEvent

description: The first parameter is the name of the module that changed. The second parameter is the reason for the change.

code: class FModulesChangedEvent : public TBaseMulticastDelegate_TwoParams< void, FName, EModuleChangeReason >


description:
Gets the singleton instance of the module manager.
The module manager instance.

code: static [FModuleManager](API\Runtime\Core\Modules\FModuleManager) & Get()


description: Gets the game binaries directory


description: GetModulePtr

code: [IModuleInterface](API\Runtime\Core\Modules\IModuleInterface) * GetModule ( const [FName](API\Runtime\Core\UObject\FName) InModuleName )


description: LoadModuleChecked

code: template<typename TModuleInterface> static TModuleInterface & GetModuleChecked ( const [FName](API\Runtime\Core\UObject\FName) ModuleName )


description:
Gets the number of loaded modules.
The number of modules.

code: int32 GetModuleCount() const


description: Gets the filename for a module. The return value is a full path of a module known to the module manager.

code: [FString](API\Runtime\Core\Containers\FString) GetModuleFilename ( [FName](API\Runtime\Core\UObject\FName) ModuleName ) const


description: LoadModuleChecked

code: template<typename TModuleInterface> static TModuleInterface * GetModulePtr ( const [FName](API\Runtime\Core\UObject\FName) ModuleName )


description:
Gets the build configuration for compiling modules, as required by UBT.
Configuration name for UBT.

code: static const TCHAR * GetUBTConfiguration()


description: Determines if any non-default module instances are loaded (eg. hot reloaded modules)


description: UnloadModule

code: bool IsModuleLoaded ( const [FName](API\Runtime\Core\UObject\FName) InModuleName ) const


description:
Checks to see if the specified module exists and is compatible with the current engine version.
true if module exists and is up to date, false otherwise.

code: bool IsModuleUpToDate ( const [FName](API\Runtime\Core\UObject\FName) InModuleName ) const


description: UnloadModule

code: [IModuleInterface](API\Runtime\Core\Modules\IModuleInterface) * LoadModule ( const [FName](API\Runtime\Core\UObject\FName) InModuleName, ELoadModuleFlags InLoadModuleFlags )


description: Will load the binary without doing initialization. Calling this will not make it possible to unload the module again

code: void LoadModuleBinaryOnly ( [FName](API\Runtime\Core\UObject\FName) ModuleName )


description: UnloadModule

code: [IModuleInterface](API\Runtime\Core\Modules\IModuleInterface) & LoadModuleChecked ( const [FName](API\Runtime\Core\UObject\FName) InModuleName )


description: LoadModuleChecked

code: template<typename TModuleInterface> static TModuleInterface & LoadModuleChecked ( const [FName](API\Runtime\Core\UObject\FName) InModuleName )


description: LoadModuleChecked

code: template<typename TModuleInterface> static TModuleInterface * LoadModulePtr ( const [FName](API\Runtime\Core\UObject\FName) InModuleName )


description: UnloadOrAbandonModuleWithCallback

code: bool LoadModuleWithCallback ( const [FName](API\Runtime\Core\UObject\FName) InModuleName, [FOutputDevice](API\Runtime\Core\Misc\FOutputDevice) & Ar )


description: UnloadModule

code: [IModuleInterface](API\Runtime\Core\Modules\IModuleInterface) * LoadModuleWithFailureReason ( const [FName](API\Runtime\Core\UObject\FName) InModuleName, EModuleLoadResult & OutFailureReason, ELoadModuleFlags InLoadModuleFlags )


description: Generates a unique file name for the specified module name by adding a random suffix and checking for file collisions.

code: void MakeUniqueModuleFilename ( const [FName](API\Runtime\Core\UObject\FName) InModuleName, [FString](API\Runtime\Core\Containers\FString) & UniqueSuffix, [FString](API\Runtime\Core\Containers\FString) & UniqueModuleFileName ) const


description:
Determines if a module with the given name exists, regardless of whether it is currently loaded.
Whether the module exists.

code: bool ModuleExists ( const TCHAR * ModuleName ) const


className: ModuleInfoPtr

code: typedef [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr)< FModuleInfo, ESPMode::ThreadSafe > ModuleInfoPtr


className: ModuleInfoRef

code: typedef [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< FModuleInfo, ESPMode::ThreadSafe > ModuleInfoRef


code: [FModuleManager](API\Runtime\Core\Modules\FModuleManager) & operator= ( const [FModuleManager](API\Runtime\Core\Modules\FModuleManager) & )


className: ProcessLoadedObjectsEvent

description: Gets a multicast delegate that is executed when any UObjects need processing after a module was loaded.

code: class ProcessLoadedObjectsEvent : public TBaseMulticastDelegate_TwoParams< void, FName, bool >


description: QueryModules

code: bool QueryModule ( const [FName](API\Runtime\Core\UObject\FName) InModuleName, [FModuleStatus](API\Runtime\Core\Modules\FModuleStatus) & OutModuleStatus ) const


description: QueryModule

code: void QueryModules ( [TArray](API\Runtime\Core\Containers\TArray)< [FModuleStatus](API\Runtime\Core\Modules\FModuleStatus) > & OutModuleStatuses ) const


code: void RefreshModuleFilenameFromManifest ( const [FName](API\Runtime\Core\UObject\FName) InModuleName )


description: Registers an initializer for a module that is statically linked.

code: void RegisterStaticallyLinkedModule ( const [FLazyName](API\Runtime\Core\UObject\FLazyName) InModuleName, const [FInitializeStaticallyLinkedModule](API\Runtime\Core\Modules\FModuleManager\FInitializeStaticallyLinkedModul-) & InInitializerDelegate )


description: Clears module path cache

code: void ResetModulePathsCache()


description: Save the current module manager's state into a file for bootstrapping other processes.

code: void SaveCurrentStateForBootstrap ( const TCHAR * Filename )


description: Set the game binaries directory

code: void SetGameBinariesDirectory ( const TCHAR * InDirectory )


description: Sets the filename for a module. The module is not reloaded immediately, but the new name will be used for subsequent unload/load events.

code: void SetModuleFilename ( [FName](API\Runtime\Core\UObject\FName) ModuleName, const [FString](API\Runtime\Core\Containers\FString) & Filename )


description: Called by the engine at startup to let the Module Manager know that it's now safe to process new UObjects discovered by loading C++ modules.


description: Destroys singleton if it exists.Get()must not be called afterDestroy().

code: static void TearDown()


description: LoadModuleWithFailureReason

code: bool UnloadModule ( const [FName](API\Runtime\Core\UObject\FName) InModuleName, bool bIsShutdown )


description: This method is Usually called at various points while exiting an application.

code: void UnloadModulesAtShutdown()


description: LoadModuleWithCallback

code: void UnloadOrAbandonModuleWithCallback ( const [FName](API\Runtime\Core\UObject\FName) InModuleName, [FOutputDevice](API\Runtime\Core\Misc\FOutputDevice) & Ar )


description: Use the static Get function to return the singleton instance.

code: FModuleManager ( FPrivateToken )


code: FModuleManager ( const [FModuleManager](API\Runtime\Core\Modules\FModuleManager) & )


description: Destructor.

code: ~FModuleManager()


className: FModuleManager

description: The module manager is used to load and unload modules, as well as to keep track of all of the modules that are currently loaded. You can access this singleton usingFModuleManager::Get().

code: class FModuleManager : private [FSelfRegisteringExec](API\Runtime\Core\Misc\FSelfRegisteringExec)


description:
Gets the path to a version manifest for the given folder.
The filename of the version manifest.

code: static [FString](API\Runtime\Core\Containers\FString) GetFileName ( const [FString](API\Runtime\Core\Containers\FString) & DirectoryName, bool bIsGameFolder )


description: Read a version manifest from disk.

code: static bool TryRead ( const [FString](API\Runtime\Core\Containers\FString) & FileName, [FModuleManifest](API\Runtime\Core\Modules\FModuleManifest) & Manifest )


className: FModuleManifest

description: Stores a record of a built target, with all metadata that other tools may need to know about the build.

code: class FModuleManifest

ModuleNameToFileName

type: TMap<FString, ...


description: Default constructor

code: FModuleManifest()


description: Constructor

code: FModuleObserver ( [FName](API\Runtime\Core\UObject\FName) InModuleName, FSimpleDelegate InOnModuleLoaded, FSimpleDelegate InOnModuleUnloaded )


className: FModuleObserver

description: A simple class that observes the currently active module list for a specific module to be (un)loaded

code: class FModuleObserver


className: FModuleStatus

description: Structure for reporting module statuses.

code: struct FModuleStatus

bIsGameModule

type: bool

description: Whether this module contains game play code.

bIsLoaded

description: Whether the module is currently loaded or not.

FilePath

description: Full path to this module file on disk.

Name

description: Short name for this module.


description: Default constructor.

code: FModuleStatus()


description: FStaticallyLinkedModuleRegistrantconstructor.


description: Explicit constructor that registers a statically linked module

code: FStaticallyLinkedModuleRegistrant ( [FLazyName](API\Runtime\Core\UObject\FLazyName) InModuleName )


className: FStaticallyLinkedModuleRegistrant

description: Utility class for registering modules that are statically linked.

code: template<class ModuleClass> class FStaticallyLinkedModuleRegistrant


description:
Returns true if this module hosts gameplay code
True for "gameplay modules", or false for engine code modules, plugins, etc.

code: virtual bool IsGameModule() const


description: Called after the module has been reloaded

code: virtual void PostLoadCallback()


description: Called before the module has been unloaded

code: virtual void PreUnloadCallback()


description: FModuleManager::Get().LoadModuleChecked(TEXT("HTTP"));

code: virtual void StartupModule()


description: Called before the module is unloaded, right before the module object is destroyed. During normal shutdown, this is called in reverse order that modules finishStartupModule(). This means that, as long as a module references dependent modules in it'sStartupModule(), it can safely reference those dependencies inShutdownModule()as well.

code: virtual void ShutdownModule()


description:
Override this to set whether your module would like cleanup on application shutdown
Whether the module supports shutdown on application exit


description:
Override this to set whether your module is allowed to be unloaded on the fly
Whether the module supports shutdown separate from the rest of the engine.

code: virtual bool SupportsDynamicReloading()


description: Note: Even though this is an interface class we need a virtual destructor here because modules are deleted via a pointer to this interface

code: virtual ~IModuleInterface()


className: IModuleInterface

description: Interface class that all module implementations should derive from. This is used to initialize a module after it's been loaded, and also to clean it up before the module is unloaded.

code: class IModuleInterface


code: namespace UE { namespace Core { namespace Private { [TOptional](API\Runtime\Core\IO\TOptional)< [FModuleManager](API\Runtime\Core\Modules\FModuleManager) > & UE::Core::Private::GetModuleManagerSingleton() } } }


code: static void ABTestCmdFunc ( const [TArray](API\Runtime\Core\Containers\TArray)< [FString](API\Runtime\Core\Containers\FString) > & Args )


description: Indicate what types of resources should be included for calculating used memory

code: namespace EResourceSizeMode { enum Type { Exclusive, EstimatedTotal, } }


code: static [FABTest](API\Runtime\Core\ProfilingDebugging\FABTest) & Get()


code: void ReportScopeTime ( double ScopeTime )


description: Returns a command to execute, if any.

code: const TCHAR * TickAndGetCommand()


className: ActiveProfiler

description: Static: Active profiler instance that we're using

code: static [FExternalProfiler](API\Runtime\Core\ProfilingDebugging\FExternalProfiler) * ActiveProfiler = nullptr;


className: bDidInitialize

description: Static: True if we've tried to initialize a profiler already

code: static bool bDidInitialize = false;


code: static [FExternalProfiler](API\Runtime\Core\ProfilingDebugging\FExternalProfiler) * GetActiveProfiler()


code: static [FExternalProfiler](API\Runtime\Core\ProfilingDebugging\FExternalProfiler) * InitActiveProfiler()


className: FActiveExternalProfilerBase

code: class FActiveExternalProfilerBase


code: int32 ParseValueStrings ( const [TArray](API\Runtime\Core\Containers\TArray)< [FString](API\Runtime\Core\Containers\FString) > & ValueStrings )


code: static int32 WriteHeader ( ANSICHAR * Dest )


code: int32 WriteValueStrings ( ANSICHAR * Dest ) const


className: FAllocOpBase

description: Representation of an alloc or free operation. Derive from this struct to add items such as size and alignment. Override the three methods to log or parse the values of custom items. A new line character must be added to the end once all items have been written to the string buffer.

code: struct FAllocOpBase


className: FAutoScopedDurationTimer

description: Same asFScopedDurationTimer, except that it tracks the time value internally so you don't have to pass in a double to accumulate. CallGetTime()to get the total time since starting.

code: class FAutoScopedDurationTimer : public [FScopedDurationTimer](API\Runtime\Core\ProfilingDebugging\FScopedDurationTimer)


code: static double GetEngineInitDuration()


description: Make it easier to update an accumulator by providing strongly typed access to the 2D array.

code: void Accumulate &40; EHitOrMiss HitOrMiss, EStatType StatType, int64 Value, bool bIsInGameThread &41;


code: void Combine &40; const CallStats & Other &41;


className: EHitOrMiss

description: One group of accumulators for hits and misses.

code: enum EHitOrMiss { Hit, Miss, MaxValue, }


className: EStatType

description: Each hit or miss will contain these accumulator stats.

code: enum EStatType { Counter, Cycles, Bytes, MaxValue, }


description: Accumulates a stat. Uses thread safe primitives for non-game thread accumulation.

code: void Accumulate &40; int64 Value, bool bIsInGameThread &41;


description: Access the accumulated values (exposed for more uniform access methds to each accumulator).

code: int64 GetAccumulatedValue &40; bool bIsInGameThread &41; const


className: GameAndOtherThreadAccumulator

description:
GetAccumulatedValue(
bool bIsInGameThread)

code: struct GameAndOtherThreadAccumulator


description: Make it easier to access an accumulator using a uniform, stronly typed interface.

code: int64 GetAccumulatedValueAnyThread &40; EHitOrMiss HitOrMiss, EStatType StatType &41; const


code: int64 GetAccumulatedValue &40; EHitOrMiss HitOrMiss, EStatType StatType, bool bIsInGameThread &41; const


className: CallStats

description: Each call type that will be tracked will track call counts, call cycles, and bytes processed, grouped by hits and misses. Some stats will by definition be zero but it limits the branching in the tracking code.

code: struct CallStats


description: Used to log the instance in a common way.

code: void LogStats &40; FCookStatsManager::AddStatFuncRef AddStat, const FString & StatName, const FString & NodeName, const TCHAR &42; CallName &41; const


description: Call to indicate a Get or Put "cache hit". Exists calls by definition don't have hits or misses.

code: void AddHit &40; int64 InBytesProcessed &41;


description: Call to indicate either a hit or miss. See AddHit and AddMiss.

code: void AddHitOrMiss &40; CallStats::EHitOrMiss InHitOrMiss, int64 InBytesProcessed &41;


description: Call to indicate a Get or Put "cache miss". This is optional, as a Miss is assumed by the timer. Some calls by definition don't have hits or misses.

code: void AddMiss &40; int64 InBytesProcessed &41;


description: Used to cancel a timing, if we had to start one without knowing in advance if we must record it.

code: void Cancel&40;&41;


description: Used to track cycles, but not as a new hit/miss. Used when the timing for a "call" is spread out in the code and mustbe measured in multiple places.

code: void TrackCyclesOnly&40;&41;


description: Starts the time, tracks the underlying stat it will update. Use bCyclesOnly if you need to track additional cycles in a different scope without adding to the call count.

code: FScopedStatsCounter &40; CallStats & InStats &41;


code: FScopedStatsCounter &40; FScopedStatsCounter && InOther &41;


code: FScopedStatsCounter &40; const FScopedStatsCounter & &41;


description: Stop the timer and flushes the stats to the underlying stats object.


className: FCookStats

description: Shared code to provide some common cook telemetry functionality. Exposes aCallStatsclass that exposes counters that track call count, cycles, and "bytes processed" for a call, bucketing by "cache hits/misses" and "game/other thread". This allows us to quickly time a call that may be executing on any thread, but quickly see the main thread time vs other time, split by "hits" or "misses", where hit/miss typically refers to a DDC hit/miss.

code: class FCookStats


className: FScopedStatsCounter

description: Used to accumulate cycles to aCallStatsinstance. Will also accumulate hit/miss stats in the dtor as well. If AddHit is not called, it will assume a miss. If AddMiss is called, it will convert the call to a miss.

code: class FScopedStatsCounter


className: AddStatFuncRef

description: When you register a callback for reporting your stats, you will be given aTFunctionRefto call to add stats. This is the signature of the function you will call.

code: typedef [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< void(const [FString](API\Runtime\Core\Containers\FString) &StatName, const [TArray](API\Runtime\Core\Containers\TArray)< [StringKeyValue](API\Runtime\Core\ProfilingDebugging\FCookStatsManager\StringKeyValue) > &StatAttributes)> AddStatFuncRef


className: CookStatsCallbacks

description: Use this to register a callback to gather cook stats for a translation unit. When a cook is finished, this delegate will be fired.


description: Helper to create an array of KeyValues using a single expression. If there is an odd number of arguments, the last value is considered to be an empty string.

code: template<typename... ArgTypes> static [TArray](API\Runtime\Core\Containers\TArray)< [FCookStatsManager::StringKeyValue](API\Runtime\Core\ProfilingDebugging\FCookStatsManager\StringKeyValue) > CreateKeyValueArray ( ArgTypes &&... Args )


code: template<typename Func> FAutoRegisterCallback &40; Func Callback &41;


className: FAutoRegisterCallback

description: Helper struct to auto-register your STATIC FUNCTION with CookStatsCallbacks

code: struct FAutoRegisterCallback


className: FGatherCookStatsDelegate

description: To register a callback for reporting stats, create an instance of this delegate type and add it to the delegate variable below.

code: typedef TMulticastDelegate_OneParam< void, [AddStatFuncRef](API\Runtime\Core\ProfilingDebugging\FCookStatsManager\AddStatFuncRef) > FGatherCookStatsDelegate


description: Called after the cook is finished to gather the stats.

code: static void LogCookStats ( [AddStatFuncRef](API\Runtime\Core\ProfilingDebugging\FCookStatsManager\AddStatFuncRef) AddStat )


description: Helper to construct aTKeyValuePair.

code: template<typename KeyType, typename ValueType> static [TKeyValuePair](API\Runtime\Core\ProfilingDebugging\FCookStatsManager\TKeyValuePair)< typename [TDecay](API\Runtime\Core\ProfilingDebugging\TDecay)< KeyType >::Type, typename [TDecay](API\Runtime\Core\ProfilingDebugging\TDecay)< ValueType >::Type > MakePair ( KeyType && InKey, ValueType && InValue )


className: StringKeyValue

description: Every stat is essentially a name followed by an array of key/value "attributes" associated with the stat.


code: bool operator&61;&61; &40; const TKeyValuePair & Other &41; const


code: bool operator&40;&41; &40; const TKeyValuePair & A, const TKeyValuePair & B &41; const


code: bool operator< &40; const TKeyValuePair & Other &41; const


code: bool operator&33;&61; &40; const TKeyValuePair & Other &41; const


code: template<typename KeyType2, typename ValueType2> TKeyValuePair &40; KeyType2 && InKey, ValueType2 && InValue &41;


className: TKeyValuePair

description: Copy of TKeyValuePair<> from Core, but with a default initializer for each member. Useful for containers that auto-add default constructed members. We can't changeTKeyValuePairbecause code relies on it and don't want to slow it down for those use cases.

code: template<typename KeyType, typename ValueType> struct TKeyValuePair

Key

type: KeyType

Value

type: ValueType


className: FCookStatsManager

description: When a cook is complete, your callback will be called, and the stats will be either logged, sent to an analytics provider, logged to an external file, etc. You don't care how they are added, you just call AddStat for each stat you want to add.

code: class FCookStatsManager


code: void LogStats ( [FCookStatsManager::AddStatFuncRef](API\Runtime\Core\ProfilingDebugging\FCookStatsManager\AddStatFuncRef) AddStat, const [FString](API\Runtime\Core\Containers\FString) & StatName, const [FString](API\Runtime\Core\Containers\FString) & NodeName ) const


description: Call this where the code is waiting on async work to build the resource


description: Call this where the code is building the resource synchronously


className: FDerivedDataUsageStats

description: Async tasks can sometimes actually be executed synchronously if the code ends up waiting on the results before the task can even get started. Either way, this should be treated as "async" wait time. Be sure not to double count this time. Basically, do your counting at the level that decides whether to execute the work synchronously or not, so you can be sure to track the time properly as SyncWork or AsyncWait.

code: struct FDerivedDataUsageStats

SyncWorkStats

description: Expose these publicly for low level access. These should really never be accessed directly except when finished accumulating them.


code: FDurationTimer ( double & AccumulatorIn )


className: FDurationTimer

description: Utility stopwatch class for tracking the duration of some action (tracks time in seconds and adds it to the specified variable on destruction).

code: class FDurationTimer

Accumulator

type: double &

description: Time variable to update.

StartTime

type: double

description: Start time, captured in ctor.


description: Profiler interface.Mark where the profiler should consider the frame boundary to be.

code: void FrameSync()


description: Ends a scoped event specific to the profiler.

code: virtual void EndScopedEvent()


description: Returns the name to use for any profiler registered as a modular feature usable by this system


description: Gets the name of this profiler as a string. This is used to allow the user to select this profiler in a system configuration file or on the command-line

code: const TCHAR * GetProfilerName() const


description: Pauses profiling.

code: void PauseProfiler()


description: Pauses profiling.

code: void ProfilerPauseFunction()


description: Resumes profiling.

code: void ProfilerResumeFunction()


description: Initialize profiler, register some delegates..

code: virtual void Register()


description: Resumes profiling.

code: void ResumeProfiler()


code: virtual void SetThreadName ( const TCHAR * Name )


description: Starts a scoped event specific to the profiler.

code: virtual void StartScopedEvent ( const struct [FColor](API\Runtime\Core\Math\FColor) & Color, const TCHAR * Text )


description: Starts a scoped event specific to the profiler. Default implementation for backward compabitility.

code: virtual void StartScopedEvent ( const struct [FColor](API\Runtime\Core\Math\FColor) & Color, const ANSICHAR * Text )


description: Constructor

code: FExternalProfiler()


description: Empty virtual destructor.

code: virtual ~FExternalProfiler()


className: FExternalProfiler

description: Interface to various external profiler API functions, dynamically linked

code: class FExternalProfiler : public [IModularFeature](API\Runtime\Core\Features\IModularFeature)


description: Constructor

code: FExternalProfilerExcluder()


description: Destructor

code: ~FExternalProfilerExcluder()


className: FExternalProfilerExcluder

description: Use this to EXCLUDE a body of code from profiler's captured session. It can safely be embedded within another 'timer' or 'excluder' scope.

code: class FExternalProfilerExcluder : public [FScopedExternalProfilerBase](API\Runtime\Core\ProfilingDebugging\FScopedExternalProfilerBase)


code: static void EndScopedEvent()


description: Destructor

code: ~FExternalProfilerIncluder()


description: Constructor

code: FExternalProfilerIncluder()


className: FExternalProfilerIncluder

description: Use this to include a body of code in profiler's captured session using 'Resume' and 'Pause' cues. It can safely be embedded within another 'timer' or 'excluder' scope.

code: class FExternalProfilerIncluder : public [FScopedExternalProfilerBase](API\Runtime\Core\ProfilingDebugging\FScopedExternalProfilerBase)


code: static void StartScopedEvent ( const struct [FColor](API\Runtime\Core\Math\FColor) & Color, const TCHAR * Text )


code: static void StartScopedEvent ( const struct [FColor](API\Runtime\Core\Math\FColor) & Color, const ANSICHAR * Text )


className: FExternalProfilerTrace

code: class FExternalProfilerTrace


className: EFormatArgTypeCode

code: enum EFormatArgTypeCode { FormatArgTypeCode_CategoryBitShift = 6, FormatArgTypeCode_SizeBitMask = (1 << FormatArgTypeCode_CategoryBitShift) - 1, FormatArgTypeCode_CategoryBitMask = ~FormatArgTypeCode_SizeBitMask, FormatArgTypeCode_CategoryInteger = 1 << FormatArgTypeCode_CategoryBitShift, FormatArgTypeCode_CategoryFloatingPoint = 2 << FormatArgTypeCode_CategoryBitShift, FormatArgTypeCode_CategoryString = 3 << FormatArgTypeCode_CategoryBitShift, }


code: template<int BufferSize, typename... Types> static uint16 EncodeArguments ( uint8(&) Buffer, Types... FormatArgs )


className: FFormatArgsTrace

code: struct FFormatArgsTrace


description: Adds an observed measurement.

code: void AddMeasurement ( double Value )


description: Adds an observed measurement (with a different thresholding key than the measurement, e.g., when accumulating time spent in a chart keyed on framerate).

code: void AddMeasurement ( double ValueForBinning, double MeasurementValue )


description: Default stringifier for bins for use with DumpToJsonString. Truncates to int and uses Plus as the suffix for the last bin. ie. [0.0, 3.75, 9.8] -> 0_3, 3_9, 9_Plus

code: static [FString](API\Runtime\Core\Containers\FString) DefaultConvertBinToLabel ( double MinValue, double UpperBound )


description: Same as DumpToJsonString but uses a DefaultConvertBinToLabel.


description: Returns a string in a Json format: [{"Bin":"BinName","Count":Count,"Sum":Sum},...]. Bucket name is constructed by calling ConvertBinToLabel on the MinValue and UpperBound for each bin. Convert function is used to allow the bin range, which is stored as a double, to be printed prettily.

code: [FString](API\Runtime\Core\Containers\FString) DumpToJsonString ( [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< [FString](API\Runtime\Core\Containers\FString)(double, double)> ConvertBinToLabel ) const


description: Same as DumpToJsonString2 but uses a DefaultConvertBinToLabel.


description: Returns a string in a Json format: [{"BinName":{"Count":Count,"Sum":Sum}},...]. Bucket name is constructed by calling ConvertBinToLabel on the MinValue and UpperBound for each bin. Convert function is used to allow the bin range, which is stored as a double, to be printed prettily.

code: [FString](API\Runtime\Core\Containers\FString) DumpToJsonString2 ( [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< [FString](API\Runtime\Core\Containers\FString)(double, double)> ConvertBinToLabel ) const


description: Prints histogram contents to the log.

code: void DumpToLog ( const [FString](API\Runtime\Core\Containers\FString) & HistogramName )


code: FBin operator&43; &40; const FBin & Other &41; const


code: FBin & operator&43;&61; &40; const FBin & Other &41;


code: FBin operator&45; &40; const FBin & Other &41; const


description: Constructor for the last bin.

code: FBin &40; double MinInclusive &41;


description: Constructor for any bin

code: FBin &40; double MinInclusive, double MaxExclusive &41;


description: Constructor for a pre-seeded bin

code: FBin &40; double MinInclusive, double MaxExclusive, double InSum, int32 InCount &41;


className: FBin

description: Bin

code: struct FBin

Count

description: How many elements are in this bin.

MinValue

description: MinValue to be stored in the bin, inclusive.

Sum

description: Sum of all values that were put into this bin.

UpperBound

description: First value NOT to be stored in the bin.


description: Gets lower bound of the bin, i.e. minimum value that goes into it.

code: double GetBinLowerBound ( int IdxBin ) const


description: Returns the average of all measurements (essentially a shortcut for Sum/Count).

code: double GetAverageOfAllMeasures() const


description: Gets number of observations in the bin.

code: int32 GetBinObservationsCount ( int IdxBin ) const


description: Gets sum of observations in the bin.

code: double GetBinObservationsSum ( int IdxBin ) const


description: Gets upper bound of the bin, i.e. first value that does not go into it.

code: double GetBinUpperBound ( int IdxBin ) const


description: Returns the minimum of all measurements.

code: double GetMinOfAllMeasures() const


description: Returns the maximum of all measurements.

code: double GetMaxOfAllMeasures() const


description: Gets number of bins.

code: int32 GetNumBins() const


description: Returns the sum of all counts (the number of recorded measurements)

code: int64 GetNumMeasurements() const


description: Returns the sum of all measurements

code: double GetSumOfAllMeasures() const


description: Inits histogram with the specified bin boundaries, with the final bucket extending to infinity (e.g., passing in 0,5 creates a [0..5) bucket and a [5..infinity) bucket)

code: void InitFromArray ( [TArrayView](API\Runtime\Core\Containers\TArrayView)< const double > Thresholds )


code: void InitFromArray ( std::initializer_list< double > Thresholds )


description: Inits histogram to mimic our existing hitch buckets

code: void InitHitchTracking()


code: [FHistogram](API\Runtime\Core\ProfilingDebugging\FHistogram) operator+ ( const [FHistogram](API\Runtime\Core\ProfilingDebugging\FHistogram) & Other ) const


description: Inits histogram with linear, equally sized bins

code: void InitLinear ( double MinTime, double MaxTime, double BinSize )


code: [FHistogram](API\Runtime\Core\ProfilingDebugging\FHistogram) & operator+= ( const [FHistogram](API\Runtime\Core\ProfilingDebugging\FHistogram) & Other )


code: [FHistogram](API\Runtime\Core\ProfilingDebugging\FHistogram) operator- ( const [FHistogram](API\Runtime\Core\ProfilingDebugging\FHistogram) & Other ) const


description: Resets measurements, without resetting the configured bins.

code: void Reset()


className: FHistogram

description: Fairly generic histogram for values that have natural lower bound and possibly no upper bound, e.g., frame time

code: struct FHistogram

Bins

type: TArray<FBin>

description: Bins themselves, should be continous in terms of [MinValue; UpperBound) and sorted ascending by MinValue.

FHistogramBuilder

type: friend

description: This is exposed as a clean way to build bins while enforcing the condition mentioned above

SumOfAllMeasures

description: Quick stats for all bins


description: This will add a bin to the histogram, extending from the previous bin (or starting value) to the passed in MaxValue

code: void AddBin ( double MaxValue )


description: Call when done adding bins, this will create a final unbounded bin to catch values above the maximum value

code: void FinishBins()


code: FHistogramBuilder ( [FHistogram](API\Runtime\Core\ProfilingDebugging\FHistogram) & InHistogram, double StartingValue )


className: FHistogramBuilder

description: Used to construct a histogram that runs over a custom set of ranges, while still enforcing contiguity on the bin ranges

code: struct FHistogramBuilder


description: Decrements stats for objects of this type

code: void DecrementStats()


className: FGlobalVars

description: Vars used by our singleton

code: struct FGlobalVars

InstanceCounts

type: TMap<FName, in...


code: static [FGlobalVars](API\Runtime\Core\ProfilingDebugging\FInstanceCountingObject\FGlobalVars) & GetGlobals()


description: Returns the count of instances with "Name".

code: static int32 GetInstanceCount ( const TCHAR * Name )


className: Globals

description: Vars are stored as a pointer and initialized on demand due to avoid dependencies on global crot order

code: static [FGlobalVars](API\Runtime\Core\ProfilingDebugging\FInstanceCountingObject\FGlobalVars) * Globals = nullptr;


description: Increments stats for objects of this type

code: void IncrementStats()


description: Dumps stats for all counted instances to the provided output device. This is bound to the "LogCountedInstances" console command

code: static void LogCounts ( [FOutputDevice](API\Runtime\Core\Misc\FOutputDevice) & OutputDevice )


description: Copy-constructor for assigment

code: FInstanceCountingObject ( const [FInstanceCountingObject](API\Runtime\Core\ProfilingDebugging\FInstanceCountingObject) & RHS )


description: Constructor, though geneerally these objects should be created using the COUNT_INSTANCES_ macro.

code: FInstanceCountingObject ( const TCHAR * InName, bool InLogConstruction )


description: Destructor

code: virtual ~FInstanceCountingObject()


className: FInstanceCountingObject

description:
class UFoo { public: etc etc protected:
    COUNT_INSTANCES(FTypeIWantToCount)
};

code: class FInstanceCountingObject

DoLog

description: Log increment/decrement?

Name

type: FName

description: Name we are tracking


description: Prints out total time and individual times

code: void DumpHighLevelLoadTimes() const


description: Prints out raw load times for individual timers

code: void DumpRawLoadTimes() const


code: static void DumpRawLoadTimesStatic()


code: static [FLoadTimeTracker](API\Runtime\Core\ProfilingDebugging\FLoadTimeTracker) & Get()


code: const [TMap](API\Runtime\Core\Containers\TMap)< [FName](API\Runtime\Core\UObject\FName), [TArray](API\Runtime\Core\Containers\TArray)< double > > & GetData() const


description: Gets/adds a scoped time for a given label and instance. Records each instance individually

code: double & GetScopeTimeAccumulator ( const [FName](API\Runtime\Core\UObject\FName) & ScopeLabel, const [FName](API\Runtime\Core\UObject\FName) & ScopeInstance )


description: Adds a scoped time for a given label. Records each instance individually

code: void ReportScopeTime ( double ScopeTime, const [FName](API\Runtime\Core\UObject\FName) ScopeLabel )


code: static void ResetRawLoadTimesStatic()


className: FLoadTimeTracker

description: No constructors are accessible with public or protected access.

code: class FLoadTimeTracker


code: static void BeginClose ( uint64 FileHandle )


code: static void BeginOpen ( const TCHAR * Path )


code: static void BeginRead ( uint64 ReadHandle, uint64 FileHandle, uint64 Offset, uint64 Size )


code: static void EndClose ( uint64 FileHandle )


code: static void BeginReOpen ( uint64 OldFileHandle )


code: static void BeginWrite ( uint64 WriteHandle, uint64 FileHandle, uint64 Offset, uint64 Size )


code: static void EndOpen ( uint64 FileHandle )


code: static void EndRead ( uint64 ReadHandle, uint64 SizeRead )


code: static void EndReOpen ( uint64 NewFileHandle )


code: static void EndWrite ( uint64 WriteHandle, uint64 SizeWritten )


code: static void FailClose ( uint64 FileHandle )


code: static void FailOpen ( const TCHAR * Path )


code: static uint32 GetOpenFileHandleCount()


className: FPlatformFileTrace

code: struct FPlatformFileTrace


description: DedicatedSystemMemoryBytes for a description of that memory type.

code: [FResourceSizeEx](API\Runtime\Core\ProfilingDebugging\FResourceSizeEx) & AddDedicatedSystemMemoryBytes ( const SIZE_T InMemoryBytes )


code: [FResourceSizeEx](API\Runtime\Core\ProfilingDebugging\FResourceSizeEx) & AddDedicatedSystemMemoryBytes ( const [FName](API\Runtime\Core\UObject\FName) & Tag, const SIZE_T InMemoryBytes )


code: [FResourceSizeEx](API\Runtime\Core\ProfilingDebugging\FResourceSizeEx) & AddDedicatedVideoMemoryBytes ( const [FName](API\Runtime\Core\UObject\FName) & Tag, const SIZE_T InMemoryBytes )


description: DedicatedVideoMemoryBytes for a description of that memory type.

code: [FResourceSizeEx](API\Runtime\Core\ProfilingDebugging\FResourceSizeEx) & AddDedicatedVideoMemoryBytes ( const SIZE_T InMemoryBytes )


description: UnknownMemoryBytes for a description of that memory type.

code: [FResourceSizeEx](API\Runtime\Core\ProfilingDebugging\FResourceSizeEx) & AddUnknownMemoryBytes ( const SIZE_T InMemoryBytes )


code: [FResourceSizeEx](API\Runtime\Core\ProfilingDebugging\FResourceSizeEx) & AddUnknownMemoryBytes ( const [FName](API\Runtime\Core\UObject\FName) & Tag, const SIZE_T InMemoryBytes )


description: Get the type of resource size held in this struct.


description: Get the total number of bytes allocated from any memory.

code: SIZE_T GetTotalMemoryBytes() const


code: SIZE_T GetUnknownMemoryBytes() const


code: void LogSummary ( [FOutputDevice](API\Runtime\Core\Misc\FOutputDevice) & Ar ) const


description: Add anotherFResourceSizeExto this one.

code: [FResourceSizeEx](API\Runtime\Core\ProfilingDebugging\FResourceSizeEx) & operator+= ( const [FResourceSizeEx](API\Runtime\Core\ProfilingDebugging\FResourceSizeEx) & InRHS )


description: Default constructor.

code: FResourceSizeEx()


description: Construct using a given mode.

code: FResourceSizeEx ( const [EResourceSizeMode::Type](API\Runtime\Core\ProfilingDebugging\EResourceSizeMode__Type) InResourceSizeMode )


description: Construct from legacy unknown size. Deliberately explicit to avoid accidental use.

code: FResourceSizeEx ( const [EResourceSizeMode::Type](API\Runtime\Core\ProfilingDebugging\EResourceSizeMode__Type) InResourceSizeMode, const SIZE_T InUnknownMemoryBytes )


description: Construct from known sizes.

code: FResourceSizeEx ( const [EResourceSizeMode::Type](API\Runtime\Core\ProfilingDebugging\EResourceSizeMode__Type) InResourceSizeMode, const SIZE_T InDedicatedSystemMemoryBytes, const SIZE_T InDedicatedVideoMemoryBytes )


className: FResourceSizeEx

description: Struct used to count up the amount of memory used by a resource. This is typically used for assets viaUObject::GetResourceSizeEx(...).

code: struct FResourceSizeEx


className: FScopedABTimer

code: class FScopedABTimer : public [FDurationTimer](API\Runtime\Core\ProfilingDebugging\FDurationTimer)


description: Dtor, updating seconds with time delta.

code: ~FScopedABTimer()


code: FScopedCookStat ( [FScopedCookStat](API\Runtime\Core\ProfilingDebugging\FScopedCookStat) && )


code: FScopedCookStat ( const [FScopedCookStat](API\Runtime\Core\ProfilingDebugging\FScopedCookStat) & )


code: FScopedCookStat ( uint64 Id, EPackageEventStatType InStatType )


className: FScopedCookStat

code: struct FScopedCookStat


description: The filename to display on the call stack for this debug info.


description: Accesses the list of debug infos on the stack in this thread.

code: static [FScopedDebugInfo](API\Runtime\Core\ProfilingDebugging\FScopedDebugInfo) * GetDebugInfoStack()


description: The "function name" to display on the call stack for this debug info.


description: The line number to display on the call stack for this debug info.

code: int32 GetLineNumber() const


className: MaxDescriptionLength

code: enum { MaxDescriptionLength = 128 }


description: Initialization constructor.

code: FScopedDebugInfo ( int32 InNumReplacedOuterCalls )


className: FScopedDebugInfo

description: Debug info that is stored on the stack and handled by stack unwinding.

code: class FScopedDebugInfo

NextOuterInfo

type: FScopedDebugInf...

description: The next debug info on the stack, or NULL if this is the last debug info on the stack.

NumReplacedOuterCalls

type: const int32

description: The number of calls on the stack the debug info replaces.


code: FScopedDurationTimeCustomLogger ( const TCHAR * InTitle, double & InTotalTime, Func InLogFunc )


className: FScopedDurationTimeCustomLogger

description: Utility class for logging the duration of a scoped action (the user doesn't have to call Start() and Stop() manually) using a custom output function.

code: template<class Func> class FScopedDurationTimeCustomLogger


code: FScopedDurationTimeLogger ( [FString](API\Runtime\Core\Containers\FString) InMsg, [FOutputDevice](API\Runtime\Core\Misc\FOutputDevice) * InDevice )


className: FScopedDurationTimeLogger

description: Utility class for logging the duration of a scoped action (the user doesn't have to call Start() and Stop() manually).

code: class FScopedDurationTimeLogger


code: FScopedDurationTimer ( double & AccumulatorIn )


description: Destructor.

code: virtual ~FScopedDebugInfo()


description: Dtor, updating seconds with time delta.

code: ~FScopedDurationTimer()


className: FScopedDurationTimer

description: Utility class for tracking the duration of a scoped action (the user doesn't have to callStart()andStop()manually).

code: class FScopedDurationTimer : public [FDurationTimer](API\Runtime\Core\ProfilingDebugging\FDurationTimer)


description: Stops the scoped timer and restores profiler to its prior state

code: void StopScopedTimer()


description: Pauses or resumes profiler and keeps track of the prior state so it can be restored later.

code: void StartScopedTimer ( const bool bWantPause )


className: FScopedExternalProfilerBase

description: Base class for FScoped*Timer and FScoped*Excluder

code: class FScopedExternalProfilerBase : public [FActiveExternalProfilerBase](API\Runtime\Core\ProfilingDebugging\FActiveExternalProfilerBase)


className: DummyTimer

description: Here are a number of profiling helper functions so we do not have to duplicate a lot of the glue code everywhere. And we can have consistent naming for all our files.

code: static double DummyTimer = 0.0;


code: FScopedLoadTimeAccumulatorTimer ( const [FName](API\Runtime\Core\UObject\FName) & InTimerName, const [FName](API\Runtime\Core\UObject\FName) & InInstanceName )


className: FScopedLoadTimeAccumulatorTimer

description: Scoped helper class for tracking accumulated object times

code: struct FScopedLoadTimeAccumulatorTimer : public [FScopedDurationTimer](API\Runtime\Core\ProfilingDebugging\FScopedDurationTimer)


code: FScopedSwitchedCountedDurationTimer ( double & TimeAccumulatorIn, int32 & CountAccumlatorIn, bool bDoFunctionalityIn )


className: FScopedSwitchedCountedDurationTimer

description: Utility stopwatch class for tracking the duration of some action (tracks time in seconds and adds it to the specified variable on destruction). useful for timing that only wants to occur when a feature is optionally turned on Also counts the number of timings

code: class FScopedSwitchedCountedDurationTimer : private [FScopedSwitchedDurationTimer](API\Runtime\Core\ProfilingDebugging\FScopedSwitchedDurationTimer)


code: FScopedSwitchedDurationTimer ( double & AccumulatorIn, bool bDoFunctionalityIn )


className: FScopedSwitchedDurationTimer

description: Utility stopwatch class for tracking the duration of some action (tracks time in seconds and adds it to the specified variable on destruction). useful for timing that only wants to occur when a feature is optionally turned on

code: class FScopedSwitchedDurationTimer

Accumulator

description: Time variable to update.

bDoFunctionality

type: const bool

StartTime

description: Start time, captured in ctor.


code: const FTraceDisabled & operator&40;&41; &40; ... &41; const


className: FStringsFNameDummy::operator bool

code: operator bool() const


code: const [FStringsFNameDummy](API\Runtime\Core\ProfilingDebugging\FStringsFNameDummy) & operator<< ( const [FTraceDisabled](API\Runtime\Core\ProfilingDebugging\FStringsFNameDummy\FTraceDisabled) & ) const


className: FStringsFNameDummy

code: struct FStringsFNameDummy

DisplayAnsi

type: constFTraceDis...


code: const [FStringsStaticStringDummy](API\Runtime\Core\ProfilingDebugging\FStringsStaticStringDummy) & operator<< ( const [FTraceDisabled](API\Runtime\Core\ProfilingDebugging\FStringsStaticStringDummy\FTraceDisabled) & ) const


className: FStringsStaticStringDummy

code: struct FStringsStaticStringDummy


description:
Gets the trace id of aFName.
Id that can be used to reference the name.

code: static [UE::Trace::FEventRef32](API\Runtime\TraceLog\Trace\FEventRef32) GetNameRef ( const [FName](API\Runtime\Core\UObject\FName) & Name )


description:
Gets the trace id of a static string. Will use the address of the string for deduplication, so it is important to only pass static strings to this function.
Id that can be used to reference the string.

code: static [UE::Trace::FEventRef64](API\Runtime\TraceLog\Trace\FEventRef64) GetStaticStringRef ( const TCHAR * String )


code: static [UE::Trace::FEventRef64](API\Runtime\TraceLog\Trace\FEventRef64) GetStaticStringRef ( const ANSICHAR * String )


description: On a new connection callback.

code: static void OnConnection()


description: Callback whenever a trace is started

code: DECLARE_TS_MULTICAST_DELEGATE_TwoParams ( FOnTraceStarted, [FTraceAuxiliary::EConnectionType](API\Runtime\Core\ProfilingDebugging\FTraceAuxiliary\EConnectionType) TraceType, const [FString](API\Runtime\Core\Containers\FString) & TraceDestination )


description: Callback whenever a trace recording is stopped. TraceType tells what kind of trace it is. TraceDestination will be either the the filename and path for a file trace or the network connection for a network trace

code: DECLARE_TS_MULTICAST_DELEGATE_TwoParams ( FOnTraceStopped, [FTraceAuxiliary::EConnectionType](API\Runtime\Core\ProfilingDebugging\FTraceAuxiliary\EConnectionType) TraceType, const [FString](API\Runtime\Core\Containers\FString) & TraceDestination )


description: Callback whenever a trace snapshot is saved. Path is the file system path of the snapshot file.

code: DECLARE_TS_MULTICAST_DELEGATE_TwoParams ( FOnSnapshotSaved, [FTraceAuxiliary::EConnectionType](API\Runtime\Core\ProfilingDebugging\FTraceAuxiliary\EConnectionType) TraceType, const [FString](API\Runtime\Core\Containers\FString) & TraceDestination )


description: Callback type when a new connection is established.

code: DECLARE_TS_MULTICAST_DELEGATE ( FOnConnection )


description: Disable channels to stop recording traces with them.

code: static void DisableChannels ( const TCHAR * Channels )


className: EConnectionType

code: enum EConnectionType { Network, File, None, }


description: Enable previously selected channels. This method can be called multiple times as channels can be announced on module loading.

code: static void EnableChannels()


className: FLogCategoryAlias

description: In no logging configurations all log categories are of type FNoLoggingCategory, which has no relation withFLogCategoryBase. In order to not need to conditionally set the argument alias the type here.


description: Adds a comma separated list of currently active channels to the passed in StringBuilder

code: static void GetActiveChannelsString ( FStringBuilderBase & String )